docs/source/Date5.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="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
   7   <script type="text/javascript" src="../resources/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-Date'>/**
  19 </span> * @class Ext.Date
  20  * A set of useful static methods to deal with date
  21  * Note that if Ext.Date is required and loaded, it will copy all methods / properties to
  22  * this object for convenience
  23  *
  24  * The date parsing and formatting syntax contains a subset of
  25  * &lt;a href=&quot;http://www.php.net/date&quot;&gt;PHP's date() function&lt;/a&gt;, and the formats that are
  26  * supported will provide results equivalent to their PHP versions.
  27  *
  28  * The following is a list of all currently supported formats:
  29  * &lt;pre class=&quot;&quot;&gt;
  30 Format  Description                                                               Example returned values
  31 ------  -----------------------------------------------------------------------   -----------------------
  32   d     Day of the month, 2 digits with leading zeros                             01 to 31
  33   D     A short textual representation of the day of the week                     Mon to Sun
  34   j     Day of the month without leading zeros                                    1 to 31
  35   l     A full textual representation of the day of the week                      Sunday to Saturday
  36   N     ISO-8601 numeric representation of the day of the week                    1 (for Monday) through 7 (for Sunday)
  37   S     English ordinal suffix for the day of the month, 2 characters             st, nd, rd or th. Works well with j
  38   w     Numeric representation of the day of the week                             0 (for Sunday) to 6 (for Saturday)
  39   z     The day of the year (starting from 0)                                     0 to 364 (365 in leap years)
  40   W     ISO-8601 week number of year, weeks starting on Monday                    01 to 53
  41   F     A full textual representation of a month, such as January or March        January to December
  42   m     Numeric representation of a month, with leading zeros                     01 to 12
  43   M     A short textual representation of a month                                 Jan to Dec
  44   n     Numeric representation of a month, without leading zeros                  1 to 12
  45   t     Number of days in the given month                                         28 to 31
  46   L     Whether it&amp;#39;s a leap year                                                  1 if it is a leap year, 0 otherwise.
  47   o     ISO-8601 year number (identical to (Y), but if the ISO week number (W)    Examples: 1998 or 2004
  48         belongs to the previous or next year, that year is used instead)
  49   Y     A full numeric representation of a year, 4 digits                         Examples: 1999 or 2003
  50   y     A two digit representation of a year                                      Examples: 99 or 03
  51   a     Lowercase Ante meridiem and Post meridiem                                 am or pm
  52   A     Uppercase Ante meridiem and Post meridiem                                 AM or PM
  53   g     12-hour format of an hour without leading zeros                           1 to 12
  54   G     24-hour format of an hour without leading zeros                           0 to 23
  55   h     12-hour format of an hour with leading zeros                              01 to 12
  56   H     24-hour format of an hour with leading zeros                              00 to 23
  57   i     Minutes, with leading zeros                                               00 to 59
  58   s     Seconds, with leading zeros                                               00 to 59
  59   u     Decimal fraction of a second                                              Examples:
  60         (minimum 1 digit, arbitrary number of digits allowed)                     001 (i.e. 0.001s) or
  61                                                                                   100 (i.e. 0.100s) or
  62                                                                                   999 (i.e. 0.999s) or
  63                                                                                   999876543210 (i.e. 0.999876543210s)
  64   O     Difference to Greenwich time (GMT) in hours and minutes                   Example: +1030
  65   P     Difference to Greenwich time (GMT) with colon between hours and minutes   Example: -08:00
  66   T     Timezone abbreviation of the machine running the code                     Examples: EST, MDT, PDT ...
  67   Z     Timezone offset in seconds (negative if west of UTC, positive if east)    -43200 to 50400
  68   c     ISO 8601 date
  69         Notes:                                                                    Examples:
  70         1) If unspecified, the month / day defaults to the current month / day,   1991 or
  71            the time defaults to midnight, while the timezone defaults to the      1992-10 or
  72            browser's timezone. If a time is specified, it must include both hours 1993-09-20 or
  73            and minutes. The &quot;T&quot; delimiter, seconds, milliseconds and timezone     1994-08-19T16:20+01:00 or
  74            are optional.                                                          1995-07-18T17:21:28-02:00 or
  75         2) The decimal fraction of a second, if specified, must contain at        1996-06-17T18:22:29.98765+03:00 or
  76            least 1 digit (there is no limit to the maximum number                 1997-05-16T19:23:30,12345-0400 or
  77            of digits allowed), and may be delimited by either a '.' or a ','      1998-04-15T20:24:31.2468Z or
  78         Refer to the examples on the right for the various levels of              1999-03-14T20:24:32Z or
  79         date-time granularity which are supported, or see                         2000-02-13T21:25:33
  80         http://www.w3.org/TR/NOTE-datetime for more info.                         2001-01-12 22:26:34
  81   U     Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)                1193432466 or -2138434463
  82   MS    Microsoft AJAX serialized dates                                           \/Date(1238606590509)\/ (i.e. UTC milliseconds since epoch) or
  83                                                                                   \/Date(1238606590509+0800)\/
  84 &lt;/pre&gt;
  85  *
  86  * Example usage (note that you must escape format specifiers with '\\' to render them as character literals):
  87  * &lt;pre&gt;&lt;code&gt;
  88 // Sample date:
  89 // 'Wed Jan 10 2007 15:05:01 GMT-0600 (Central Standard Time)'
  90
  91 var dt = new Date('1/10/2007 03:05:01 PM GMT-0600');
  92 console.log(Ext.Date.format(dt, 'Y-m-d'));                          // 2007-01-10
  93 console.log(Ext.Date.format(dt, 'F j, Y, g:i a'));                  // January 10, 2007, 3:05 pm
  94 console.log(Ext.Date.format(dt, 'l, \\t\\he jS \\of F Y h:i:s A')); // Wednesday, the 10th of January 2007 03:05:01 PM
  95 &lt;/code&gt;&lt;/pre&gt;
  96  *
  97  * Here are some standard date/time patterns that you might find helpful.  They
  98  * are not part of the source of Ext.Date, but to use them you can simply copy this
  99  * block of code into any script that is included after Ext.Date and they will also become
 100  * globally available on the Date object.  Feel free to add or remove patterns as needed in your code.
 101  * &lt;pre&gt;&lt;code&gt;
 102 Ext.Date.patterns = {
 103     ISO8601Long:&quot;Y-m-d H:i:s&quot;,
 104     ISO8601Short:&quot;Y-m-d&quot;,
 105     ShortDate: &quot;n/j/Y&quot;,
 106     LongDate: &quot;l, F d, Y&quot;,
 107     FullDateTime: &quot;l, F d, Y g:i:s A&quot;,
 108     MonthDay: &quot;F d&quot;,
 109     ShortTime: &quot;g:i A&quot;,
 110     LongTime: &quot;g:i:s A&quot;,
 111     SortableDateTime: &quot;Y-m-d\\TH:i:s&quot;,
 112     UniversalSortableDateTime: &quot;Y-m-d H:i:sO&quot;,
 113     YearMonth: &quot;F, Y&quot;
 114 };
 115 &lt;/code&gt;&lt;/pre&gt;
 116  *
 117  * Example usage:
 118  * &lt;pre&gt;&lt;code&gt;
 119 var dt = new Date();
 120 console.log(Ext.Date.format(dt, Ext.Date.patterns.ShortDate));
 121 &lt;/code&gt;&lt;/pre&gt;
 122  * &lt;p&gt;Developer-written, custom formats may be used by supplying both a formatting and a parsing function
 123  * which perform to specialized requirements. The functions are stored in {@link #parseFunctions} and {@link #formatFunctions}.&lt;/p&gt;
 124  * @singleton
 125  */
 126
 127 /*
 128  * Most of the date-formatting functions below are the excellent work of Baron Schwartz.
 129  * (see http://www.xaprb.com/blog/2005/12/12/javascript-closures-for-runtime-efficiency/)
 130  * They generate precompiled functions from format patterns instead of parsing and
 131  * processing each pattern every time a date is formatted. These functions are available
 132  * on every Date object.
 133  */
 134
 135 (function() {
 136
 137 // create private copy of Ext's Ext.util.Format.format() method
 138 // - to remove unnecessary dependency
 139 // - to resolve namespace conflict with MS-Ajax's implementation
 140 function xf(format) {
 141     var args = Array.prototype.slice.call(arguments, 1);
 142     return format.replace(/\{(\d+)\}/g, function(m, i) {
 143         return args[i];
 144     });
 145 }
 146
 147 Ext.Date = {
 148 <span id='Ext-Date-method-now'>    /**
 149 </span>     * Returns the current timestamp
 150      * @return {Date} The current timestamp
 151      * @method
 152      */
 153     now: Date.now || function() {
 154         return +new Date();
 155     },
 156
 157 <span id='Ext-Date-method-toString'>    /**
 158 </span>     * @private
 159      * Private for now
 160      */
 161     toString: function(date) {
 162         var pad = Ext.String.leftPad;
 163
 164         return date.getFullYear() + &quot;-&quot;
 165             + pad(date.getMonth() + 1, 2, '0') + &quot;-&quot;
 166             + pad(date.getDate(), 2, '0') + &quot;T&quot;
 167             + pad(date.getHours(), 2, '0') + &quot;:&quot;
 168             + pad(date.getMinutes(), 2, '0') + &quot;:&quot;
 169             + pad(date.getSeconds(), 2, '0');
 170     },
 171
 172 <span id='Ext-Date-method-getElapsed'>    /**
 173 </span>     * Returns the number of milliseconds between two dates
 174      * @param {Date} dateA The first date
 175      * @param {Date} dateB (optional) The second date, defaults to now
 176      * @return {Number} The difference in milliseconds
 177      */
 178     getElapsed: function(dateA, dateB) {
 179         return Math.abs(dateA - (dateB || new Date()));
 180     },
 181
 182 <span id='Ext-Date-property-useStrict'>    /**
 183 </span>     * Global flag which determines if strict date parsing should be used.
 184      * Strict date parsing will not roll-over invalid dates, which is the
 185      * default behaviour of javascript Date objects.
 186      * (see {@link #parse} for more information)
 187      * Defaults to &lt;tt&gt;false&lt;/tt&gt;.
 188      * @type Boolean
 189     */
 190     useStrict: false,
 191
 192     // private
 193     formatCodeToRegex: function(character, currentGroup) {
 194         // Note: currentGroup - position in regex result array (see notes for Ext.Date.parseCodes below)
 195         var p = utilDate.parseCodes[character];
 196
 197         if (p) {
 198           p = typeof p == 'function'? p() : p;
 199           utilDate.parseCodes[character] = p; // reassign function result to prevent repeated execution
 200         }
 201
 202         return p ? Ext.applyIf({
 203           c: p.c ? xf(p.c, currentGroup || &quot;{0}&quot;) : p.c
 204         }, p) : {
 205             g: 0,
 206             c: null,
 207             s: Ext.String.escapeRegex(character) // treat unrecognised characters as literals
 208         };
 209     },
 210
 211 <span id='Ext-Date-property-parseFunctions'>    /**
 212 </span>     * &lt;p&gt;An object hash in which each property is a date parsing function. The property name is the
 213      * format string which that function parses.&lt;/p&gt;
 214      * &lt;p&gt;This object is automatically populated with date parsing functions as
 215      * date formats are requested for Ext standard formatting strings.&lt;/p&gt;
 216      * &lt;p&gt;Custom parsing functions may be inserted into this object, keyed by a name which from then on
 217      * may be used as a format string to {@link #parse}.&lt;p&gt;
 218      * &lt;p&gt;Example:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
 219 Ext.Date.parseFunctions['x-date-format'] = myDateParser;
 220 &lt;/code&gt;&lt;/pre&gt;
 221      * &lt;p&gt;A parsing function should return a Date object, and is passed the following parameters:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
 222      * &lt;li&gt;&lt;code&gt;date&lt;/code&gt; : String&lt;div class=&quot;sub-desc&quot;&gt;The date string to parse.&lt;/div&gt;&lt;/li&gt;
 223      * &lt;li&gt;&lt;code&gt;strict&lt;/code&gt; : Boolean&lt;div class=&quot;sub-desc&quot;&gt;True to validate date strings while parsing
 224      * (i.e. prevent javascript Date &quot;rollover&quot;) (The default must be false).
 225      * Invalid date strings should return null when parsed.&lt;/div&gt;&lt;/li&gt;
 226      * &lt;/ul&gt;&lt;/div&gt;&lt;/p&gt;
 227      * &lt;p&gt;To enable Dates to also be &lt;i&gt;formatted&lt;/i&gt; according to that format, a corresponding
 228      * formatting function must be placed into the {@link #formatFunctions} property.
 229      * @property parseFunctions
 230      * @type Object
 231      */
 232     parseFunctions: {
 233         &quot;MS&quot;: function(input, strict) {
 234             // note: the timezone offset is ignored since the MS Ajax server sends
 235             // a UTC milliseconds-since-Unix-epoch value (negative values are allowed)
 236             var re = new RegExp('\\/Date\\(([-+])?(\\d+)(?:[+-]\\d{4})?\\)\\/');
 237             var r = (input || '').match(re);
 238             return r? new Date(((r[1] || '') + r[2]) * 1) : null;
 239         }
 240     },
 241     parseRegexes: [],
 242
 243 <span id='Ext-Date-property-formatFunctions'>    /**
 244 </span>     * &lt;p&gt;An object hash in which each property is a date formatting function. The property name is the
 245      * format string which corresponds to the produced formatted date string.&lt;/p&gt;
 246      * &lt;p&gt;This object is automatically populated with date formatting functions as
 247      * date formats are requested for Ext standard formatting strings.&lt;/p&gt;
 248      * &lt;p&gt;Custom formatting functions may be inserted into this object, keyed by a name which from then on
 249      * may be used as a format string to {@link #format}. Example:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
 250 Ext.Date.formatFunctions['x-date-format'] = myDateFormatter;
 251 &lt;/code&gt;&lt;/pre&gt;
 252      * &lt;p&gt;A formatting function should return a string representation of the passed Date object, and is passed the following parameters:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
 253      * &lt;li&gt;&lt;code&gt;date&lt;/code&gt; : Date&lt;div class=&quot;sub-desc&quot;&gt;The Date to format.&lt;/div&gt;&lt;/li&gt;
 254      * &lt;/ul&gt;&lt;/div&gt;&lt;/p&gt;
 255      * &lt;p&gt;To enable date strings to also be &lt;i&gt;parsed&lt;/i&gt; according to that format, a corresponding
 256      * parsing function must be placed into the {@link #parseFunctions} property.
 257      * @property formatFunctions
 258      * @type Object
 259      */
 260     formatFunctions: {
 261         &quot;MS&quot;: function() {
 262             // UTC milliseconds since Unix epoch (MS-AJAX serialized date format (MRSF))
 263             return '\\/Date(' + this.getTime() + ')\\/';
 264         }
 265     },
 266
 267     y2kYear : 50,
 268
 269 <span id='Ext-Date-property-MILLI'>    /**
 270 </span>     * Date interval constant
 271      * @type String
 272      */
 273     MILLI : &quot;ms&quot;,
 274
 275 <span id='Ext-Date-property-SECOND'>    /**
 276 </span>     * Date interval constant
 277      * @type String
 278      */
 279     SECOND : &quot;s&quot;,
 280
 281 <span id='Ext-Date-property-MINUTE'>    /**
 282 </span>     * Date interval constant
 283      * @type String
 284      */
 285     MINUTE : &quot;mi&quot;,
 286
 287 <span id='Ext-Date-property-HOUR'>    /** Date interval constant
 288 </span>     * @type String
 289      */
 290     HOUR : &quot;h&quot;,
 291
 292 <span id='Ext-Date-property-DAY'>    /**
 293 </span>     * Date interval constant
 294      * @type String
 295      */
 296     DAY : &quot;d&quot;,
 297
 298 <span id='Ext-Date-property-MONTH'>    /**
 299 </span>     * Date interval constant
 300      * @type String
 301      */
 302     MONTH : &quot;mo&quot;,
 303
 304 <span id='Ext-Date-property-YEAR'>    /**
 305 </span>     * Date interval constant
 306      * @type String
 307      */
 308     YEAR : &quot;y&quot;,
 309
 310 <span id='Ext-Date-property-defaults'>    /**
 311 </span>     * &lt;p&gt;An object hash containing default date values used during date parsing.&lt;/p&gt;
 312      * &lt;p&gt;The following properties are available:&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
 313      * &lt;li&gt;&lt;code&gt;y&lt;/code&gt; : Number&lt;div class=&quot;sub-desc&quot;&gt;The default year value. (defaults to undefined)&lt;/div&gt;&lt;/li&gt;
 314      * &lt;li&gt;&lt;code&gt;m&lt;/code&gt; : Number&lt;div class=&quot;sub-desc&quot;&gt;The default 1-based month value. (defaults to undefined)&lt;/div&gt;&lt;/li&gt;
 315      * &lt;li&gt;&lt;code&gt;d&lt;/code&gt; : Number&lt;div class=&quot;sub-desc&quot;&gt;The default day value. (defaults to undefined)&lt;/div&gt;&lt;/li&gt;
 316      * &lt;li&gt;&lt;code&gt;h&lt;/code&gt; : Number&lt;div class=&quot;sub-desc&quot;&gt;The default hour value. (defaults to undefined)&lt;/div&gt;&lt;/li&gt;
 317      * &lt;li&gt;&lt;code&gt;i&lt;/code&gt; : Number&lt;div class=&quot;sub-desc&quot;&gt;The default minute value. (defaults to undefined)&lt;/div&gt;&lt;/li&gt;
 318      * &lt;li&gt;&lt;code&gt;s&lt;/code&gt; : Number&lt;div class=&quot;sub-desc&quot;&gt;The default second value. (defaults to undefined)&lt;/div&gt;&lt;/li&gt;
 319      * &lt;li&gt;&lt;code&gt;ms&lt;/code&gt; : Number&lt;div class=&quot;sub-desc&quot;&gt;The default millisecond value. (defaults to undefined)&lt;/div&gt;&lt;/li&gt;
 320      * &lt;/ul&gt;&lt;/div&gt;&lt;/p&gt;
 321      * &lt;p&gt;Override these properties to customize the default date values used by the {@link #parse} method.&lt;/p&gt;
 322      * &lt;p&gt;&lt;b&gt;Note: In countries which experience Daylight Saving Time (i.e. DST), the &lt;tt&gt;h&lt;/tt&gt;, &lt;tt&gt;i&lt;/tt&gt;, &lt;tt&gt;s&lt;/tt&gt;
 323      * and &lt;tt&gt;ms&lt;/tt&gt; properties may coincide with the exact time in which DST takes effect.
 324      * It is the responsiblity of the developer to account for this.&lt;/b&gt;&lt;/p&gt;
 325      * Example Usage:
 326      * &lt;pre&gt;&lt;code&gt;
 327 // set default day value to the first day of the month
 328 Ext.Date.defaults.d = 1;
 329
 330 // parse a February date string containing only year and month values.
 331 // setting the default day value to 1 prevents weird date rollover issues
 332 // when attempting to parse the following date string on, for example, March 31st 2009.
 333 Ext.Date.parse('2009-02', 'Y-m'); // returns a Date object representing February 1st 2009
 334 &lt;/code&gt;&lt;/pre&gt;
 335      * @property defaults
 336      * @type Object
 337      */
 338     defaults: {},
 339
 340 <span id='Ext-Date-property-dayNames'>    /**
 341 </span>     * @property {String[]} dayNames
 342      * An array of textual day names.
 343      * Override these values for international dates.
 344      * Example:
 345      * &lt;pre&gt;&lt;code&gt;
 346 Ext.Date.dayNames = [
 347     'SundayInYourLang',
 348     'MondayInYourLang',
 349     ...
 350 ];
 351 &lt;/code&gt;&lt;/pre&gt;
 352      */
 353     dayNames : [
 354         &quot;Sunday&quot;,
 355         &quot;Monday&quot;,
 356         &quot;Tuesday&quot;,
 357         &quot;Wednesday&quot;,
 358         &quot;Thursday&quot;,
 359         &quot;Friday&quot;,
 360         &quot;Saturday&quot;
 361     ],
 362
 363 <span id='Ext-Date-property-monthNames'>    /**
 364 </span>     * @property {String[]} monthNames
 365      * An array of textual month names.
 366      * Override these values for international dates.
 367      * Example:
 368      * &lt;pre&gt;&lt;code&gt;
 369 Ext.Date.monthNames = [
 370     'JanInYourLang',
 371     'FebInYourLang',
 372     ...
 373 ];
 374 &lt;/code&gt;&lt;/pre&gt;
 375      */
 376     monthNames : [
 377         &quot;January&quot;,
 378         &quot;February&quot;,
 379         &quot;March&quot;,
 380         &quot;April&quot;,
 381         &quot;May&quot;,
 382         &quot;June&quot;,
 383         &quot;July&quot;,
 384         &quot;August&quot;,
 385         &quot;September&quot;,
 386         &quot;October&quot;,
 387         &quot;November&quot;,
 388         &quot;December&quot;
 389     ],
 390
 391 <span id='Ext-Date-property-monthNumbers'>    /**
 392 </span>     * @property {Object} monthNumbers
 393      * An object hash of zero-based javascript month numbers (with short month names as keys. note: keys are case-sensitive).
 394      * Override these values for international dates.
 395      * Example:
 396      * &lt;pre&gt;&lt;code&gt;
 397 Ext.Date.monthNumbers = {
 398     'ShortJanNameInYourLang':0,
 399     'ShortFebNameInYourLang':1,
 400     ...
 401 };
 402 &lt;/code&gt;&lt;/pre&gt;
 403      */
 404     monthNumbers : {
 405         Jan:0,
 406         Feb:1,
 407         Mar:2,
 408         Apr:3,
 409         May:4,
 410         Jun:5,
 411         Jul:6,
 412         Aug:7,
 413         Sep:8,
 414         Oct:9,
 415         Nov:10,
 416         Dec:11
 417     },
 418 <span id='Ext-Date-property-defaultFormat'>    /**
 419 </span>     * @property {String} defaultFormat
 420      * &lt;p&gt;The date format string that the {@link Ext.util.Format#dateRenderer}
 421      * and {@link Ext.util.Format#date} functions use.  See {@link Ext.Date} for details.&lt;/p&gt;
 422      * &lt;p&gt;This may be overridden in a locale file.&lt;/p&gt;
 423      */
 424     defaultFormat : &quot;m/d/Y&quot;,
 425 <span id='Ext-Date-method-getShortMonthName'>    /**
 426 </span>     * Get the short month name for the given month number.
 427      * Override this function for international dates.
 428      * @param {Number} month A zero-based javascript month number.
 429      * @return {String} The short month name.
 430      */
 431     getShortMonthName : function(month) {
 432         return utilDate.monthNames[month].substring(0, 3);
 433     },
 434
 435 <span id='Ext-Date-method-getShortDayName'>    /**
 436 </span>     * Get the short day name for the given day number.
 437      * Override this function for international dates.
 438      * @param {Number} day A zero-based javascript day number.
 439      * @return {String} The short day name.
 440      */
 441     getShortDayName : function(day) {
 442         return utilDate.dayNames[day].substring(0, 3);
 443     },
 444
 445 <span id='Ext-Date-method-getMonthNumber'>    /**
 446 </span>     * Get the zero-based javascript month number for the given short/full month name.
 447      * Override this function for international dates.
 448      * @param {String} name The short/full month name.
 449      * @return {Number} The zero-based javascript month number.
 450      */
 451     getMonthNumber : function(name) {
 452         // handle camel casing for english month names (since the keys for the Ext.Date.monthNumbers hash are case sensitive)
 453         return utilDate.monthNumbers[name.substring(0, 1).toUpperCase() + name.substring(1, 3).toLowerCase()];
 454     },
 455
 456 <span id='Ext-Date-method-formatContainsHourInfo'>    /**
 457 </span>     * Checks if the specified format contains hour information
 458      * @param {String} format The format to check
 459      * @return {Boolean} True if the format contains hour information
 460      * @method
 461      */
 462     formatContainsHourInfo : (function(){
 463         var stripEscapeRe = /(\\.)/g,
 464             hourInfoRe = /([gGhHisucUOPZ]|MS)/;
 465         return function(format){
 466             return hourInfoRe.test(format.replace(stripEscapeRe, ''));
 467         };
 468     })(),
 469
 470 <span id='Ext-Date-method-formatContainsDateInfo'>    /**
 471 </span>     * Checks if the specified format contains information about
 472      * anything other than the time.
 473      * @param {String} format The format to check
 474      * @return {Boolean} True if the format contains information about
 475      * date/day information.
 476      * @method
 477      */
 478     formatContainsDateInfo : (function(){
 479         var stripEscapeRe = /(\\.)/g,
 480             dateInfoRe = /([djzmnYycU]|MS)/;
 481
 482         return function(format){
 483             return dateInfoRe.test(format.replace(stripEscapeRe, ''));
 484         };
 485     })(),
 486
 487 <span id='Ext-Date-property-formatCodes'>    /**
 488 </span>     * The base format-code to formatting-function hashmap used by the {@link #format} method.
 489      * Formatting functions are strings (or functions which return strings) which
 490      * will return the appropriate value when evaluated in the context of the Date object
 491      * from which the {@link #format} method is called.
 492      * Add to / override these mappings for custom date formatting.
 493      * Note: Ext.Date.format() treats characters as literals if an appropriate mapping cannot be found.
 494      * Example:
 495      * &lt;pre&gt;&lt;code&gt;
 496 Ext.Date.formatCodes.x = &quot;Ext.util.Format.leftPad(this.getDate(), 2, '0')&quot;;
 497 console.log(Ext.Date.format(new Date(), 'X'); // returns the current day of the month
 498 &lt;/code&gt;&lt;/pre&gt;
 499      * @type Object
 500      */
 501     formatCodes : {
 502         d: &quot;Ext.String.leftPad(this.getDate(), 2, '0')&quot;,
 503         D: &quot;Ext.Date.getShortDayName(this.getDay())&quot;, // get localised short day name
 504         j: &quot;this.getDate()&quot;,
 505         l: &quot;Ext.Date.dayNames[this.getDay()]&quot;,
 506         N: &quot;(this.getDay() ? this.getDay() : 7)&quot;,
 507         S: &quot;Ext.Date.getSuffix(this)&quot;,
 508         w: &quot;this.getDay()&quot;,
 509         z: &quot;Ext.Date.getDayOfYear(this)&quot;,
 510         W: &quot;Ext.String.leftPad(Ext.Date.getWeekOfYear(this), 2, '0')&quot;,
 511         F: &quot;Ext.Date.monthNames[this.getMonth()]&quot;,
 512         m: &quot;Ext.String.leftPad(this.getMonth() + 1, 2, '0')&quot;,
 513         M: &quot;Ext.Date.getShortMonthName(this.getMonth())&quot;, // get localised short month name
 514         n: &quot;(this.getMonth() + 1)&quot;,
 515         t: &quot;Ext.Date.getDaysInMonth(this)&quot;,
 516         L: &quot;(Ext.Date.isLeapYear(this) ? 1 : 0)&quot;,
 517         o: &quot;(this.getFullYear() + (Ext.Date.getWeekOfYear(this) == 1 &amp;&amp; this.getMonth() &gt; 0 ? +1 : (Ext.Date.getWeekOfYear(this) &gt;= 52 &amp;&amp; this.getMonth() &lt; 11 ? -1 : 0)))&quot;,
 518         Y: &quot;Ext.String.leftPad(this.getFullYear(), 4, '0')&quot;,
 519         y: &quot;('' + this.getFullYear()).substring(2, 4)&quot;,
 520         a: &quot;(this.getHours() &lt; 12 ? 'am' : 'pm')&quot;,
 521         A: &quot;(this.getHours() &lt; 12 ? 'AM' : 'PM')&quot;,
 522         g: &quot;((this.getHours() % 12) ? this.getHours() % 12 : 12)&quot;,
 523         G: &quot;this.getHours()&quot;,
 524         h: &quot;Ext.String.leftPad((this.getHours() % 12) ? this.getHours() % 12 : 12, 2, '0')&quot;,
 525         H: &quot;Ext.String.leftPad(this.getHours(), 2, '0')&quot;,
 526         i: &quot;Ext.String.leftPad(this.getMinutes(), 2, '0')&quot;,
 527         s: &quot;Ext.String.leftPad(this.getSeconds(), 2, '0')&quot;,
 528         u: &quot;Ext.String.leftPad(this.getMilliseconds(), 3, '0')&quot;,
 529         O: &quot;Ext.Date.getGMTOffset(this)&quot;,
 530         P: &quot;Ext.Date.getGMTOffset(this, true)&quot;,
 531         T: &quot;Ext.Date.getTimezone(this)&quot;,
 532         Z: &quot;(this.getTimezoneOffset() * -60)&quot;,
 533
 534         c: function() { // ISO-8601 -- GMT format
 535             for (var c = &quot;Y-m-dTH:i:sP&quot;, code = [], i = 0, l = c.length; i &lt; l; ++i) {
 536                 var e = c.charAt(i);
 537                 code.push(e == &quot;T&quot; ? &quot;'T'&quot; : utilDate.getFormatCode(e)); // treat T as a character literal
 538             }
 539             return code.join(&quot; + &quot;);
 540         },
 541         /*
 542         c: function() { // ISO-8601 -- UTC format
 543             return [
 544               &quot;this.getUTCFullYear()&quot;, &quot;'-'&quot;,
 545               &quot;Ext.util.Format.leftPad(this.getUTCMonth() + 1, 2, '0')&quot;, &quot;'-'&quot;,
 546               &quot;Ext.util.Format.leftPad(this.getUTCDate(), 2, '0')&quot;,
 547               &quot;'T'&quot;,
 548               &quot;Ext.util.Format.leftPad(this.getUTCHours(), 2, '0')&quot;, &quot;':'&quot;,
 549               &quot;Ext.util.Format.leftPad(this.getUTCMinutes(), 2, '0')&quot;, &quot;':'&quot;,
 550               &quot;Ext.util.Format.leftPad(this.getUTCSeconds(), 2, '0')&quot;,
 551               &quot;'Z'&quot;
 552             ].join(&quot; + &quot;);
 553         },
 554         */
 555
 556         U: &quot;Math.round(this.getTime() / 1000)&quot;
 557     },
 558
 559 <span id='Ext-Date-method-isValid'>    /**
 560 </span>     * Checks if the passed Date parameters will cause a javascript Date &quot;rollover&quot;.
 561      * @param {Number} year 4-digit year
 562      * @param {Number} month 1-based month-of-year
 563      * @param {Number} day Day of month
 564      * @param {Number} hour (optional) Hour
 565      * @param {Number} minute (optional) Minute
 566      * @param {Number} second (optional) Second
 567      * @param {Number} millisecond (optional) Millisecond
 568      * @return {Boolean} true if the passed parameters do not cause a Date &quot;rollover&quot;, false otherwise.
 569      */
 570     isValid : function(y, m, d, h, i, s, ms) {
 571         // setup defaults
 572         h = h || 0;
 573         i = i || 0;
 574         s = s || 0;
 575         ms = ms || 0;
 576
 577         // Special handling for year &lt; 100
 578         var dt = utilDate.add(new Date(y &lt; 100 ? 100 : y, m - 1, d, h, i, s, ms), utilDate.YEAR, y &lt; 100 ? y - 100 : 0);
 579
 580         return y == dt.getFullYear() &amp;&amp;
 581             m == dt.getMonth() + 1 &amp;&amp;
 582             d == dt.getDate() &amp;&amp;
 583             h == dt.getHours() &amp;&amp;
 584             i == dt.getMinutes() &amp;&amp;
 585             s == dt.getSeconds() &amp;&amp;
 586             ms == dt.getMilliseconds();
 587     },
 588
 589 <span id='Ext-Date-method-parse'>    /**
 590 </span>     * Parses the passed string using the specified date format.
 591      * Note that this function expects normal calendar dates, meaning that months are 1-based (i.e. 1 = January).
 592      * The {@link #defaults} hash will be used for any date value (i.e. year, month, day, hour, minute, second or millisecond)
 593      * which cannot be found in the passed string. If a corresponding default date value has not been specified in the {@link #defaults} hash,
 594      * the current date's year, month, day or DST-adjusted zero-hour time value will be used instead.
 595      * Keep in mind that the input date string must precisely match the specified format string
 596      * in order for the parse operation to be successful (failed parse operations return a null value).
 597      * &lt;p&gt;Example:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
 598 //dt = Fri May 25 2007 (current date)
 599 var dt = new Date();
 600
 601 //dt = Thu May 25 2006 (today&amp;#39;s month/day in 2006)
 602 dt = Ext.Date.parse(&quot;2006&quot;, &quot;Y&quot;);
 603
 604 //dt = Sun Jan 15 2006 (all date parts specified)
 605 dt = Ext.Date.parse(&quot;2006-01-15&quot;, &quot;Y-m-d&quot;);
 606
 607 //dt = Sun Jan 15 2006 15:20:01
 608 dt = Ext.Date.parse(&quot;2006-01-15 3:20:01 PM&quot;, &quot;Y-m-d g:i:s A&quot;);
 609
 610 // attempt to parse Sun Feb 29 2006 03:20:01 in strict mode
 611 dt = Ext.Date.parse(&quot;2006-02-29 03:20:01&quot;, &quot;Y-m-d H:i:s&quot;, true); // returns null
 612 &lt;/code&gt;&lt;/pre&gt;
 613      * @param {String} input The raw date string.
 614      * @param {String} format The expected date string format.
 615      * @param {Boolean} strict (optional) True to validate date strings while parsing (i.e. prevents javascript Date &quot;rollover&quot;)
 616                         (defaults to false). Invalid date strings will return null when parsed.
 617      * @return {Date} The parsed Date.
 618      */
 619     parse : function(input, format, strict) {
 620         var p = utilDate.parseFunctions;
 621         if (p[format] == null) {
 622             utilDate.createParser(format);
 623         }
 624         return p[format](input, Ext.isDefined(strict) ? strict : utilDate.useStrict);
 625     },
 626
 627     // Backwards compat
 628     parseDate: function(input, format, strict){
 629         return utilDate.parse(input, format, strict);
 630     },
 631
 632
 633     // private
 634     getFormatCode : function(character) {
 635         var f = utilDate.formatCodes[character];
 636
 637         if (f) {
 638           f = typeof f == 'function'? f() : f;
 639           utilDate.formatCodes[character] = f; // reassign function result to prevent repeated execution
 640         }
 641
 642         // note: unknown characters are treated as literals
 643         return f || (&quot;'&quot; + Ext.String.escape(character) + &quot;'&quot;);
 644     },
 645
 646     // private
 647     createFormat : function(format) {
 648         var code = [],
 649             special = false,
 650             ch = '';
 651
 652         for (var i = 0; i &lt; format.length; ++i) {
 653             ch = format.charAt(i);
 654             if (!special &amp;&amp; ch == &quot;\\&quot;) {
 655                 special = true;
 656             } else if (special) {
 657                 special = false;
 658                 code.push(&quot;'&quot; + Ext.String.escape(ch) + &quot;'&quot;);
 659             } else {
 660                 code.push(utilDate.getFormatCode(ch));
 661             }
 662         }
 663         utilDate.formatFunctions[format] = Ext.functionFactory(&quot;return &quot; + code.join('+'));
 664     },
 665
 666     // private
 667     createParser : (function() {
 668         var code = [
 669             &quot;var dt, y, m, d, h, i, s, ms, o, z, zz, u, v,&quot;,
 670                 &quot;def = Ext.Date.defaults,&quot;,
 671                 &quot;results = String(input).match(Ext.Date.parseRegexes[{0}]);&quot;, // either null, or an array of matched strings
 672
 673             &quot;if(results){&quot;,
 674                 &quot;{1}&quot;,
 675
 676                 &quot;if(u != null){&quot;, // i.e. unix time is defined
 677                     &quot;v = new Date(u * 1000);&quot;, // give top priority to UNIX time
 678                 &quot;}else{&quot;,
 679                     // create Date object representing midnight of the current day;
 680                     // this will provide us with our date defaults
 681                     // (note: clearTime() handles Daylight Saving Time automatically)
 682                     &quot;dt = Ext.Date.clearTime(new Date);&quot;,
 683
 684                     // date calculations (note: these calculations create a dependency on Ext.Number.from())
 685                     &quot;y = Ext.Number.from(y, Ext.Number.from(def.y, dt.getFullYear()));&quot;,
 686                     &quot;m = Ext.Number.from(m, Ext.Number.from(def.m - 1, dt.getMonth()));&quot;,
 687                     &quot;d = Ext.Number.from(d, Ext.Number.from(def.d, dt.getDate()));&quot;,
 688
 689                     // time calculations (note: these calculations create a dependency on Ext.Number.from())
 690                     &quot;h  = Ext.Number.from(h, Ext.Number.from(def.h, dt.getHours()));&quot;,
 691                     &quot;i  = Ext.Number.from(i, Ext.Number.from(def.i, dt.getMinutes()));&quot;,
 692                     &quot;s  = Ext.Number.from(s, Ext.Number.from(def.s, dt.getSeconds()));&quot;,
 693                     &quot;ms = Ext.Number.from(ms, Ext.Number.from(def.ms, dt.getMilliseconds()));&quot;,
 694
 695                     &quot;if(z &gt;= 0 &amp;&amp; y &gt;= 0){&quot;,
 696                         // both the year and zero-based day of year are defined and &gt;= 0.
 697                         // these 2 values alone provide sufficient info to create a full date object
 698
 699                         // create Date object representing January 1st for the given year
 700                         // handle years &lt; 100 appropriately
 701                         &quot;v = Ext.Date.add(new Date(y &lt; 100 ? 100 : y, 0, 1, h, i, s, ms), Ext.Date.YEAR, y &lt; 100 ? y - 100 : 0);&quot;,
 702
 703                         // then add day of year, checking for Date &quot;rollover&quot; if necessary
 704                         &quot;v = !strict? v : (strict === true &amp;&amp; (z &lt;= 364 || (Ext.Date.isLeapYear(v) &amp;&amp; z &lt;= 365))? Ext.Date.add(v, Ext.Date.DAY, z) : null);&quot;,
 705                     &quot;}else if(strict === true &amp;&amp; !Ext.Date.isValid(y, m + 1, d, h, i, s, ms)){&quot;, // check for Date &quot;rollover&quot;
 706                         &quot;v = null;&quot;, // invalid date, so return null
 707                     &quot;}else{&quot;,
 708                         // plain old Date object
 709                         // handle years &lt; 100 properly
 710                         &quot;v = Ext.Date.add(new Date(y &lt; 100 ? 100 : y, m, d, h, i, s, ms), Ext.Date.YEAR, y &lt; 100 ? y - 100 : 0);&quot;,
 711                     &quot;}&quot;,
 712                 &quot;}&quot;,
 713             &quot;}&quot;,
 714
 715             &quot;if(v){&quot;,
 716                 // favour UTC offset over GMT offset
 717                 &quot;if(zz != null){&quot;,
 718                     // reset to UTC, then add offset
 719                     &quot;v = Ext.Date.add(v, Ext.Date.SECOND, -v.getTimezoneOffset() * 60 - zz);&quot;,
 720                 &quot;}else if(o){&quot;,
 721                     // reset to GMT, then add offset
 722                     &quot;v = Ext.Date.add(v, Ext.Date.MINUTE, -v.getTimezoneOffset() + (sn == '+'? -1 : 1) * (hr * 60 + mn));&quot;,
 723                 &quot;}&quot;,
 724             &quot;}&quot;,
 725
 726             &quot;return v;&quot;
 727         ].join('\n');
 728
 729         return function(format) {
 730             var regexNum = utilDate.parseRegexes.length,
 731                 currentGroup = 1,
 732                 calc = [],
 733                 regex = [],
 734                 special = false,
 735                 ch = &quot;&quot;;
 736
 737             for (var i = 0; i &lt; format.length; ++i) {
 738                 ch = format.charAt(i);
 739                 if (!special &amp;&amp; ch == &quot;\\&quot;) {
 740                     special = true;
 741                 } else if (special) {
 742                     special = false;
 743                     regex.push(Ext.String.escape(ch));
 744                 } else {
 745                     var obj = utilDate.formatCodeToRegex(ch, currentGroup);
 746                     currentGroup += obj.g;
 747                     regex.push(obj.s);
 748                     if (obj.g &amp;&amp; obj.c) {
 749                         calc.push(obj.c);
 750                     }
 751                 }
 752             }
 753
 754             utilDate.parseRegexes[regexNum] = new RegExp(&quot;^&quot; + regex.join('') + &quot;$&quot;, 'i');
 755             utilDate.parseFunctions[format] = Ext.functionFactory(&quot;input&quot;, &quot;strict&quot;, xf(code, regexNum, calc.join('')));
 756         };
 757     })(),
 758
 759     // private
 760     parseCodes : {
 761         /*
 762          * Notes:
 763          * g = {Number} calculation group (0 or 1. only group 1 contributes to date calculations.)
 764          * c = {String} calculation method (required for group 1. null for group 0. {0} = currentGroup - position in regex result array)
 765          * s = {String} regex pattern. all matches are stored in results[], and are accessible by the calculation mapped to 'c'
 766          */
 767         d: {
 768             g:1,
 769             c:&quot;d = parseInt(results[{0}], 10);\n&quot;,
 770             s:&quot;(\\d{2})&quot; // day of month with leading zeroes (01 - 31)
 771         },
 772         j: {
 773             g:1,
 774             c:&quot;d = parseInt(results[{0}], 10);\n&quot;,
 775             s:&quot;(\\d{1,2})&quot; // day of month without leading zeroes (1 - 31)
 776         },
 777         D: function() {
 778             for (var a = [], i = 0; i &lt; 7; a.push(utilDate.getShortDayName(i)), ++i); // get localised short day names
 779             return {
 780                 g:0,
 781                 c:null,
 782                 s:&quot;(?:&quot; + a.join(&quot;|&quot;) +&quot;)&quot;
 783             };
 784         },
 785         l: function() {
 786             return {
 787                 g:0,
 788                 c:null,
 789                 s:&quot;(?:&quot; + utilDate.dayNames.join(&quot;|&quot;) + &quot;)&quot;
 790             };
 791         },
 792         N: {
 793             g:0,
 794             c:null,
 795             s:&quot;[1-7]&quot; // ISO-8601 day number (1 (monday) - 7 (sunday))
 796         },
 797         S: {
 798             g:0,
 799             c:null,
 800             s:&quot;(?:st|nd|rd|th)&quot;
 801         },
 802         w: {
 803             g:0,
 804             c:null,
 805             s:&quot;[0-6]&quot; // javascript day number (0 (sunday) - 6 (saturday))
 806         },
 807         z: {
 808             g:1,
 809             c:&quot;z = parseInt(results[{0}], 10);\n&quot;,
 810             s:&quot;(\\d{1,3})&quot; // day of the year (0 - 364 (365 in leap years))
 811         },
 812         W: {
 813             g:0,
 814             c:null,
 815             s:&quot;(?:\\d{2})&quot; // ISO-8601 week number (with leading zero)
 816         },
 817         F: function() {
 818             return {
 819                 g:1,
 820                 c:&quot;m = parseInt(Ext.Date.getMonthNumber(results[{0}]), 10);\n&quot;, // get localised month number
 821                 s:&quot;(&quot; + utilDate.monthNames.join(&quot;|&quot;) + &quot;)&quot;
 822             };
 823         },
 824         M: function() {
 825             for (var a = [], i = 0; i &lt; 12; a.push(utilDate.getShortMonthName(i)), ++i); // get localised short month names
 826             return Ext.applyIf({
 827                 s:&quot;(&quot; + a.join(&quot;|&quot;) + &quot;)&quot;
 828             }, utilDate.formatCodeToRegex(&quot;F&quot;));
 829         },
 830         m: {
 831             g:1,
 832             c:&quot;m = parseInt(results[{0}], 10) - 1;\n&quot;,
 833             s:&quot;(\\d{2})&quot; // month number with leading zeros (01 - 12)
 834         },
 835         n: {
 836             g:1,
 837             c:&quot;m = parseInt(results[{0}], 10) - 1;\n&quot;,
 838             s:&quot;(\\d{1,2})&quot; // month number without leading zeros (1 - 12)
 839         },
 840         t: {
 841             g:0,
 842             c:null,
 843             s:&quot;(?:\\d{2})&quot; // no. of days in the month (28 - 31)
 844         },
 845         L: {
 846             g:0,
 847             c:null,
 848             s:&quot;(?:1|0)&quot;
 849         },
 850         o: function() {
 851             return utilDate.formatCodeToRegex(&quot;Y&quot;);
 852         },
 853         Y: {
 854             g:1,
 855             c:&quot;y = parseInt(results[{0}], 10);\n&quot;,
 856             s:&quot;(\\d{4})&quot; // 4-digit year
 857         },
 858         y: {
 859             g:1,
 860             c:&quot;var ty = parseInt(results[{0}], 10);\n&quot;
 861                 + &quot;y = ty &gt; Ext.Date.y2kYear ? 1900 + ty : 2000 + ty;\n&quot;, // 2-digit year
 862             s:&quot;(\\d{1,2})&quot;
 863         },
 864         /*
 865          * In the am/pm parsing routines, we allow both upper and lower case
 866          * even though it doesn't exactly match the spec. It gives much more flexibility
 867          * in being able to specify case insensitive regexes.
 868          */
 869         a: {
 870             g:1,
 871             c:&quot;if (/(am)/i.test(results[{0}])) {\n&quot;
 872                 + &quot;if (!h || h == 12) { h = 0; }\n&quot;
 873                 + &quot;} else { if (!h || h &lt; 12) { h = (h || 0) + 12; }}&quot;,
 874             s:&quot;(am|pm|AM|PM)&quot;
 875         },
 876         A: {
 877             g:1,
 878             c:&quot;if (/(am)/i.test(results[{0}])) {\n&quot;
 879                 + &quot;if (!h || h == 12) { h = 0; }\n&quot;
 880                 + &quot;} else { if (!h || h &lt; 12) { h = (h || 0) + 12; }}&quot;,
 881             s:&quot;(AM|PM|am|pm)&quot;
 882         },
 883         g: function() {
 884             return utilDate.formatCodeToRegex(&quot;G&quot;);
 885         },
 886         G: {
 887             g:1,
 888             c:&quot;h = parseInt(results[{0}], 10);\n&quot;,
 889             s:&quot;(\\d{1,2})&quot; // 24-hr format of an hour without leading zeroes (0 - 23)
 890         },
 891         h: function() {
 892             return utilDate.formatCodeToRegex(&quot;H&quot;);
 893         },
 894         H: {
 895             g:1,
 896             c:&quot;h = parseInt(results[{0}], 10);\n&quot;,
 897             s:&quot;(\\d{2})&quot; //  24-hr format of an hour with leading zeroes (00 - 23)
 898         },
 899         i: {
 900             g:1,
 901             c:&quot;i = parseInt(results[{0}], 10);\n&quot;,
 902             s:&quot;(\\d{2})&quot; // minutes with leading zeros (00 - 59)
 903         },
 904         s: {
 905             g:1,
 906             c:&quot;s = parseInt(results[{0}], 10);\n&quot;,
 907             s:&quot;(\\d{2})&quot; // seconds with leading zeros (00 - 59)
 908         },
 909         u: {
 910             g:1,
 911             c:&quot;ms = results[{0}]; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);\n&quot;,
 912             s:&quot;(\\d+)&quot; // decimal fraction of a second (minimum = 1 digit, maximum = unlimited)
 913         },
 914         O: {
 915             g:1,
 916             c:[
 917                 &quot;o = results[{0}];&quot;,
 918                 &quot;var sn = o.substring(0,1),&quot;, // get + / - sign
 919                     &quot;hr = o.substring(1,3)*1 + Math.floor(o.substring(3,5) / 60),&quot;, // get hours (performs minutes-to-hour conversion also, just in case)
 920                     &quot;mn = o.substring(3,5) % 60;&quot;, // get minutes
 921                 &quot;o = ((-12 &lt;= (hr*60 + mn)/60) &amp;&amp; ((hr*60 + mn)/60 &lt;= 14))? (sn + Ext.String.leftPad(hr, 2, '0') + Ext.String.leftPad(mn, 2, '0')) : null;\n&quot; // -12hrs &lt;= GMT offset &lt;= 14hrs
 922             ].join(&quot;\n&quot;),
 923             s: &quot;([+\-]\\d{4})&quot; // GMT offset in hrs and mins
 924         },
 925         P: {
 926             g:1,
 927             c:[
 928                 &quot;o = results[{0}];&quot;,
 929                 &quot;var sn = o.substring(0,1),&quot;, // get + / - sign
 930                     &quot;hr = o.substring(1,3)*1 + Math.floor(o.substring(4,6) / 60),&quot;, // get hours (performs minutes-to-hour conversion also, just in case)
 931                     &quot;mn = o.substring(4,6) % 60;&quot;, // get minutes
 932                 &quot;o = ((-12 &lt;= (hr*60 + mn)/60) &amp;&amp; ((hr*60 + mn)/60 &lt;= 14))? (sn + Ext.String.leftPad(hr, 2, '0') + Ext.String.leftPad(mn, 2, '0')) : null;\n&quot; // -12hrs &lt;= GMT offset &lt;= 14hrs
 933             ].join(&quot;\n&quot;),
 934             s: &quot;([+\-]\\d{2}:\\d{2})&quot; // GMT offset in hrs and mins (with colon separator)
 935         },
 936         T: {
 937             g:0,
 938             c:null,
 939             s:&quot;[A-Z]{1,4}&quot; // timezone abbrev. may be between 1 - 4 chars
 940         },
 941         Z: {
 942             g:1,
 943             c:&quot;zz = results[{0}] * 1;\n&quot; // -43200 &lt;= UTC offset &lt;= 50400
 944                   + &quot;zz = (-43200 &lt;= zz &amp;&amp; zz &lt;= 50400)? zz : null;\n&quot;,
 945             s:&quot;([+\-]?\\d{1,5})&quot; // leading '+' sign is optional for UTC offset
 946         },
 947         c: function() {
 948             var calc = [],
 949                 arr = [
 950                     utilDate.formatCodeToRegex(&quot;Y&quot;, 1), // year
 951                     utilDate.formatCodeToRegex(&quot;m&quot;, 2), // month
 952                     utilDate.formatCodeToRegex(&quot;d&quot;, 3), // day
 953                     utilDate.formatCodeToRegex(&quot;h&quot;, 4), // hour
 954                     utilDate.formatCodeToRegex(&quot;i&quot;, 5), // minute
 955                     utilDate.formatCodeToRegex(&quot;s&quot;, 6), // second
 956                     {c:&quot;ms = results[7] || '0'; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);\n&quot;}, // decimal fraction of a second (minimum = 1 digit, maximum = unlimited)
 957                     {c:[ // allow either &quot;Z&quot; (i.e. UTC) or &quot;-0530&quot; or &quot;+08:00&quot; (i.e. UTC offset) timezone delimiters. assumes local timezone if no timezone is specified
 958                         &quot;if(results[8]) {&quot;, // timezone specified
 959                             &quot;if(results[8] == 'Z'){&quot;,
 960                                 &quot;zz = 0;&quot;, // UTC
 961                             &quot;}else if (results[8].indexOf(':') &gt; -1){&quot;,
 962                                 utilDate.formatCodeToRegex(&quot;P&quot;, 8).c, // timezone offset with colon separator
 963                             &quot;}else{&quot;,
 964                                 utilDate.formatCodeToRegex(&quot;O&quot;, 8).c, // timezone offset without colon separator
 965                             &quot;}&quot;,
 966                         &quot;}&quot;
 967                     ].join('\n')}
 968                 ];
 969
 970             for (var i = 0, l = arr.length; i &lt; l; ++i) {
 971                 calc.push(arr[i].c);
 972             }
 973
 974             return {
 975                 g:1,
 976                 c:calc.join(&quot;&quot;),
 977                 s:[
 978                     arr[0].s, // year (required)
 979                     &quot;(?:&quot;, &quot;-&quot;, arr[1].s, // month (optional)
 980                         &quot;(?:&quot;, &quot;-&quot;, arr[2].s, // day (optional)
 981                             &quot;(?:&quot;,
 982                                 &quot;(?:T| )?&quot;, // time delimiter -- either a &quot;T&quot; or a single blank space
 983                                 arr[3].s, &quot;:&quot;, arr[4].s,  // hour AND minute, delimited by a single colon (optional). MUST be preceded by either a &quot;T&quot; or a single blank space
 984                                 &quot;(?::&quot;, arr[5].s, &quot;)?&quot;, // seconds (optional)
 985                                 &quot;(?:(?:\\.|,)(\\d+))?&quot;, // decimal fraction of a second (e.g. &quot;,12345&quot; or &quot;.98765&quot;) (optional)
 986                                 &quot;(Z|(?:[-+]\\d{2}(?::)?\\d{2}))?&quot;, // &quot;Z&quot; (UTC) or &quot;-0530&quot; (UTC offset without colon delimiter) or &quot;+08:00&quot; (UTC offset with colon delimiter) (optional)
 987                             &quot;)?&quot;,
 988                         &quot;)?&quot;,
 989                     &quot;)?&quot;
 990                 ].join(&quot;&quot;)
 991             };
 992         },
 993         U: {
 994             g:1,
 995             c:&quot;u = parseInt(results[{0}], 10);\n&quot;,
 996             s:&quot;(-?\\d+)&quot; // leading minus sign indicates seconds before UNIX epoch
 997         }
 998     },
 999
1000     //Old Ext.Date prototype methods.
1001     // private
1002     dateFormat: function(date, format) {
1003         return utilDate.format(date, format);
1004     },
1005
1006 <span id='Ext-Date-method-format'>    /**
1007 </span>     * Formats a date given the supplied format string.
1008      * @param {Date} date The date to format
1009      * @param {String} format The format string
1010      * @return {String} The formatted date
1011      */
1012     format: function(date, format) {
1013         if (utilDate.formatFunctions[format] == null) {
1014             utilDate.createFormat(format);
1015         }
1016         var result = utilDate.formatFunctions[format].call(date);
1017         return result + '';
1018     },
1019
1020 <span id='Ext-Date-method-getTimezone'>    /**
1021 </span>     * Get the timezone abbreviation of the current date (equivalent to the format specifier 'T').
1022      *
1023      * Note: The date string returned by the javascript Date object's toString() method varies
1024      * between browsers (e.g. FF vs IE) and system region settings (e.g. IE in Asia vs IE in America).
1025      * For a given date string e.g. &quot;Thu Oct 25 2007 22:55:35 GMT+0800 (Malay Peninsula Standard Time)&quot;,
1026      * getTimezone() first tries to get the timezone abbreviation from between a pair of parentheses
1027      * (which may or may not be present), failing which it proceeds to get the timezone abbreviation
1028      * from the GMT offset portion of the date string.
1029      * @param {Date} date The date
1030      * @return {String} The abbreviated timezone name (e.g. 'CST', 'PDT', 'EDT', 'MPST' ...).
1031      */
1032     getTimezone : function(date) {
1033         // the following list shows the differences between date strings from different browsers on a WinXP SP2 machine from an Asian locale:
1034         //
1035         // Opera  : &quot;Thu, 25 Oct 2007 22:53:45 GMT+0800&quot; -- shortest (weirdest) date string of the lot
1036         // Safari : &quot;Thu Oct 25 2007 22:55:35 GMT+0800 (Malay Peninsula Standard Time)&quot; -- value in parentheses always gives the correct timezone (same as FF)
1037         // FF     : &quot;Thu Oct 25 2007 22:55:35 GMT+0800 (Malay Peninsula Standard Time)&quot; -- value in parentheses always gives the correct timezone
1038         // IE     : &quot;Thu Oct 25 22:54:35 UTC+0800 2007&quot; -- (Asian system setting) look for 3-4 letter timezone abbrev
1039         // IE     : &quot;Thu Oct 25 17:06:37 PDT 2007&quot; -- (American system setting) look for 3-4 letter timezone abbrev
1040         //
1041         // this crazy regex attempts to guess the correct timezone abbreviation despite these differences.
1042         // step 1: (?:\((.*)\) -- find timezone in parentheses
1043         // step 2: ([A-Z]{1,4})(?:[\-+][0-9]{4})?(?: -?\d+)?) -- if nothing was found in step 1, find timezone from timezone offset portion of date string
1044         // step 3: remove all non uppercase characters found in step 1 and 2
1045         return date.toString().replace(/^.* (?:\((.*)\)|([A-Z]{1,4})(?:[\-+][0-9]{4})?(?: -?\d+)?)$/, &quot;$1$2&quot;).replace(/[^A-Z]/g, &quot;&quot;);
1046     },
1047
1048 <span id='Ext-Date-method-getGMTOffset'>    /**
1049 </span>     * Get the offset from GMT of the current date (equivalent to the format specifier 'O').
1050      * @param {Date} date The date
1051      * @param {Boolean} colon (optional) true to separate the hours and minutes with a colon (defaults to false).
1052      * @return {String} The 4-character offset string prefixed with + or - (e.g. '-0600').
1053      */
1054     getGMTOffset : function(date, colon) {
1055         var offset = date.getTimezoneOffset();
1056         return (offset &gt; 0 ? &quot;-&quot; : &quot;+&quot;)
1057             + Ext.String.leftPad(Math.floor(Math.abs(offset) / 60), 2, &quot;0&quot;)
1058             + (colon ? &quot;:&quot; : &quot;&quot;)
1059             + Ext.String.leftPad(Math.abs(offset % 60), 2, &quot;0&quot;);
1060     },
1061
1062 <span id='Ext-Date-method-getDayOfYear'>    /**
1063 </span>     * Get the numeric day number of the year, adjusted for leap year.
1064      * @param {Date} date The date
1065      * @return {Number} 0 to 364 (365 in leap years).
1066      */
1067     getDayOfYear: function(date) {
1068         var num = 0,
1069             d = Ext.Date.clone(date),
1070             m = date.getMonth(),
1071             i;
1072
1073         for (i = 0, d.setDate(1), d.setMonth(0); i &lt; m; d.setMonth(++i)) {
1074             num += utilDate.getDaysInMonth(d);
1075         }
1076         return num + date.getDate() - 1;
1077     },
1078
1079 <span id='Ext-Date-method-getWeekOfYear'>    /**
1080 </span>     * Get the numeric ISO-8601 week number of the year.
1081      * (equivalent to the format specifier 'W', but without a leading zero).
1082      * @param {Date} date The date
1083      * @return {Number} 1 to 53
1084      * @method
1085      */
1086     getWeekOfYear : (function() {
1087         // adapted from http://www.merlyn.demon.co.uk/weekcalc.htm
1088         var ms1d = 864e5, // milliseconds in a day
1089             ms7d = 7 * ms1d; // milliseconds in a week
1090
1091         return function(date) { // return a closure so constants get calculated only once
1092             var DC3 = Date.UTC(date.getFullYear(), date.getMonth(), date.getDate() + 3) / ms1d, // an Absolute Day Number
1093                 AWN = Math.floor(DC3 / 7), // an Absolute Week Number
1094                 Wyr = new Date(AWN * ms7d).getUTCFullYear();
1095
1096             return AWN - Math.floor(Date.UTC(Wyr, 0, 7) / ms7d) + 1;
1097         };
1098     })(),
1099
1100 <span id='Ext-Date-method-isLeapYear'>    /**
1101 </span>     * Checks if the current date falls within a leap year.
1102      * @param {Date} date The date
1103      * @return {Boolean} True if the current date falls within a leap year, false otherwise.
1104      */
1105     isLeapYear : function(date) {
1106         var year = date.getFullYear();
1107         return !!((year &amp; 3) == 0 &amp;&amp; (year % 100 || (year % 400 == 0 &amp;&amp; year)));
1108     },
1109
1110 <span id='Ext-Date-method-getFirstDayOfMonth'>    /**
1111 </span>     * Get the first day of the current month, adjusted for leap year.  The returned value
1112      * is the numeric day index within the week (0-6) which can be used in conjunction with
1113      * the {@link #monthNames} array to retrieve the textual day name.
1114      * Example:
1115      * &lt;pre&gt;&lt;code&gt;
1116 var dt = new Date('1/10/2007'),
1117     firstDay = Ext.Date.getFirstDayOfMonth(dt);
1118 console.log(Ext.Date.dayNames[firstDay]); //output: 'Monday'
1119      * &lt;/code&gt;&lt;/pre&gt;
1120      * @param {Date} date The date
1121      * @return {Number} The day number (0-6).
1122      */
1123     getFirstDayOfMonth : function(date) {
1124         var day = (date.getDay() - (date.getDate() - 1)) % 7;
1125         return (day &lt; 0) ? (day + 7) : day;
1126     },
1127
1128 <span id='Ext-Date-method-getLastDayOfMonth'>    /**
1129 </span>     * Get the last day of the current month, adjusted for leap year.  The returned value
1130      * is the numeric day index within the week (0-6) which can be used in conjunction with
1131      * the {@link #monthNames} array to retrieve the textual day name.
1132      * Example:
1133      * &lt;pre&gt;&lt;code&gt;
1134 var dt = new Date('1/10/2007'),
1135     lastDay = Ext.Date.getLastDayOfMonth(dt);
1136 console.log(Ext.Date.dayNames[lastDay]); //output: 'Wednesday'
1137      * &lt;/code&gt;&lt;/pre&gt;
1138      * @param {Date} date The date
1139      * @return {Number} The day number (0-6).
1140      */
1141     getLastDayOfMonth : function(date) {
1142         return utilDate.getLastDateOfMonth(date).getDay();
1143     },
1144
1145
1146 <span id='Ext-Date-method-getFirstDateOfMonth'>    /**
1147 </span>     * Get the date of the first day of the month in which this date resides.
1148      * @param {Date} date The date
1149      * @return {Date}
1150      */
1151     getFirstDateOfMonth : function(date) {
1152         return new Date(date.getFullYear(), date.getMonth(), 1);
1153     },
1154
1155 <span id='Ext-Date-method-getLastDateOfMonth'>    /**
1156 </span>     * Get the date of the last day of the month in which this date resides.
1157      * @param {Date} date The date
1158      * @return {Date}
1159      */
1160     getLastDateOfMonth : function(date) {
1161         return new Date(date.getFullYear(), date.getMonth(), utilDate.getDaysInMonth(date));
1162     },
1163
1164 <span id='Ext-Date-method-getDaysInMonth'>    /**
1165 </span>     * Get the number of days in the current month, adjusted for leap year.
1166      * @param {Date} date The date
1167      * @return {Number} The number of days in the month.
1168      * @method
1169      */
1170     getDaysInMonth: (function() {
1171         var daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
1172
1173         return function(date) { // return a closure for efficiency
1174             var m = date.getMonth();
1175
1176             return m == 1 &amp;&amp; utilDate.isLeapYear(date) ? 29 : daysInMonth[m];
1177         };
1178     })(),
1179
1180 <span id='Ext-Date-method-getSuffix'>    /**
1181 </span>     * Get the English ordinal suffix of the current day (equivalent to the format specifier 'S').
1182      * @param {Date} date The date
1183      * @return {String} 'st, 'nd', 'rd' or 'th'.
1184      */
1185     getSuffix : function(date) {
1186         switch (date.getDate()) {
1187             case 1:
1188             case 21:
1189             case 31:
1190                 return &quot;st&quot;;
1191             case 2:
1192             case 22:
1193                 return &quot;nd&quot;;
1194             case 3:
1195             case 23:
1196                 return &quot;rd&quot;;
1197             default:
1198                 return &quot;th&quot;;
1199         }
1200     },
1201
1202 <span id='Ext-Date-method-clone'>    /**
1203 </span>     * Creates and returns a new Date instance with the exact same date value as the called instance.
1204      * Dates are copied and passed by reference, so if a copied date variable is modified later, the original
1205      * variable will also be changed.  When the intention is to create a new variable that will not
1206      * modify the original instance, you should create a clone.
1207      *
1208      * Example of correctly cloning a date:
1209      * &lt;pre&gt;&lt;code&gt;
1210 //wrong way:
1211 var orig = new Date('10/1/2006');
1212 var copy = orig;
1213 copy.setDate(5);
1214 console.log(orig);  //returns 'Thu Oct 05 2006'!
1215
1216 //correct way:
1217 var orig = new Date('10/1/2006'),
1218     copy = Ext.Date.clone(orig);
1219 copy.setDate(5);
1220 console.log(orig);  //returns 'Thu Oct 01 2006'
1221      * &lt;/code&gt;&lt;/pre&gt;
1222      * @param {Date} date The date
1223      * @return {Date} The new Date instance.
1224      */
1225     clone : function(date) {
1226         return new Date(date.getTime());
1227     },
1228
1229 <span id='Ext-Date-method-isDST'>    /**
1230 </span>     * Checks if the current date is affected by Daylight Saving Time (DST).
1231      * @param {Date} date The date
1232      * @return {Boolean} True if the current date is affected by DST.
1233      */
1234     isDST : function(date) {
1235         // adapted from http://sencha.com/forum/showthread.php?p=247172#post247172
1236         // courtesy of @geoffrey.mcgill
1237         return new Date(date.getFullYear(), 0, 1).getTimezoneOffset() != date.getTimezoneOffset();
1238     },
1239
1240 <span id='Ext-Date-method-clearTime'>    /**
1241 </span>     * Attempts to clear all time information from this Date by setting the time to midnight of the same day,
1242      * automatically adjusting for Daylight Saving Time (DST) where applicable.
1243      * (note: DST timezone information for the browser's host operating system is assumed to be up-to-date)
1244      * @param {Date} date The date
1245      * @param {Boolean} clone true to create a clone of this date, clear the time and return it (defaults to false).
1246      * @return {Date} this or the clone.
1247      */
1248     clearTime : function(date, clone) {
1249         if (clone) {
1250             return Ext.Date.clearTime(Ext.Date.clone(date));
1251         }
1252
1253         // get current date before clearing time
1254         var d = date.getDate();
1255
1256         // clear time
1257         date.setHours(0);
1258         date.setMinutes(0);
1259         date.setSeconds(0);
1260         date.setMilliseconds(0);
1261
1262         if (date.getDate() != d) { // account for DST (i.e. day of month changed when setting hour = 0)
1263             // note: DST adjustments are assumed to occur in multiples of 1 hour (this is almost always the case)
1264             // refer to http://www.timeanddate.com/time/aboutdst.html for the (rare) exceptions to this rule
1265
1266             // increment hour until cloned date == current date
1267             for (var hr = 1, c = utilDate.add(date, Ext.Date.HOUR, hr); c.getDate() != d; hr++, c = utilDate.add(date, Ext.Date.HOUR, hr));
1268
1269             date.setDate(d);
1270             date.setHours(c.getHours());
1271         }
1272
1273         return date;
1274     },
1275
1276 <span id='Ext-Date-method-add'>    /**
1277 </span>     * Provides a convenient method for performing basic date arithmetic. This method
1278      * does not modify the Date instance being called - it creates and returns
1279      * a new Date instance containing the resulting date value.
1280      *
1281      * Examples:
1282      * &lt;pre&gt;&lt;code&gt;
1283 // Basic usage:
1284 var dt = Ext.Date.add(new Date('10/29/2006'), Ext.Date.DAY, 5);
1285 console.log(dt); //returns 'Fri Nov 03 2006 00:00:00'
1286
1287 // Negative values will be subtracted:
1288 var dt2 = Ext.Date.add(new Date('10/1/2006'), Ext.Date.DAY, -5);
1289 console.log(dt2); //returns 'Tue Sep 26 2006 00:00:00'
1290
1291      * &lt;/code&gt;&lt;/pre&gt;
1292      *
1293      * @param {Date} date The date to modify
1294      * @param {String} interval A valid date interval enum value.
1295      * @param {Number} value The amount to add to the current date.
1296      * @return {Date} The new Date instance.
1297      */
1298     add : function(date, interval, value) {
1299         var d = Ext.Date.clone(date),
1300             Date = Ext.Date;
1301         if (!interval || value === 0) return d;
1302
1303         switch(interval.toLowerCase()) {
1304             case Ext.Date.MILLI:
1305                 d.setMilliseconds(d.getMilliseconds() + value);
1306                 break;
1307             case Ext.Date.SECOND:
1308                 d.setSeconds(d.getSeconds() + value);
1309                 break;
1310             case Ext.Date.MINUTE:
1311                 d.setMinutes(d.getMinutes() + value);
1312                 break;
1313             case Ext.Date.HOUR:
1314                 d.setHours(d.getHours() + value);
1315                 break;
1316             case Ext.Date.DAY:
1317                 d.setDate(d.getDate() + value);
1318                 break;
1319             case Ext.Date.MONTH:
1320                 var day = date.getDate();
1321                 if (day &gt; 28) {
1322                     day = Math.min(day, Ext.Date.getLastDateOfMonth(Ext.Date.add(Ext.Date.getFirstDateOfMonth(date), 'mo', value)).getDate());
1323                 }
1324                 d.setDate(day);
1325                 d.setMonth(date.getMonth() + value);
1326                 break;
1327             case Ext.Date.YEAR:
1328                 d.setFullYear(date.getFullYear() + value);
1329                 break;
1330         }
1331         return d;
1332     },
1333
1334 <span id='Ext-Date-method-between'>    /**
1335 </span>     * Checks if a date falls on or between the given start and end dates.
1336      * @param {Date} date The date to check
1337      * @param {Date} start Start date
1338      * @param {Date} end End date
1339      * @return {Boolean} true if this date falls on or between the given start and end dates.
1340      */
1341     between : function(date, start, end) {
1342         var t = date.getTime();
1343         return start.getTime() &lt;= t &amp;&amp; t &lt;= end.getTime();
1344     },
1345
1346     //Maintains compatibility with old static and prototype window.Date methods.
1347     compat: function() {
1348         var nativeDate = window.Date,
1349             p, u,
1350             statics = ['useStrict', 'formatCodeToRegex', 'parseFunctions', 'parseRegexes', 'formatFunctions', 'y2kYear', 'MILLI', 'SECOND', 'MINUTE', 'HOUR', 'DAY', 'MONTH', 'YEAR', 'defaults', 'dayNames', 'monthNames', 'monthNumbers', 'getShortMonthName', 'getShortDayName', 'getMonthNumber', 'formatCodes', 'isValid', 'parseDate', 'getFormatCode', 'createFormat', 'createParser', 'parseCodes'],
1351             proto = ['dateFormat', 'format', 'getTimezone', 'getGMTOffset', 'getDayOfYear', 'getWeekOfYear', 'isLeapYear', 'getFirstDayOfMonth', 'getLastDayOfMonth', 'getDaysInMonth', 'getSuffix', 'clone', 'isDST', 'clearTime', 'add', 'between'];
1352
1353         //Append statics
1354         Ext.Array.forEach(statics, function(s) {
1355             nativeDate[s] = utilDate[s];
1356         });
1357
1358         //Append to prototype
1359         Ext.Array.forEach(proto, function(s) {
1360             nativeDate.prototype[s] = function() {
1361                 var args = Array.prototype.slice.call(arguments);
1362                 args.unshift(this);
1363                 return utilDate[s].apply(utilDate, args);
1364             };
1365         });
1366     }
1367 };
1368
1369 var utilDate = Ext.Date;
1370
1371 })();
1372 </pre>
1373 </body>
1374 </html>