Dodanie aplikacji sorl.thumbnail i filebrowser.
[redakcja.git] / platforma / static / filebrowser / uploadify / com / adobe / utils / .svn / text-base / DateUtil.as.svn-base
1 /*
2   Copyright (c) 2008, Adobe Systems Incorporated
3   All rights reserved.
4
5   Redistribution and use in source and binary forms, with or without 
6   modification, are permitted provided that the following conditions are
7   met:
8
9   * Redistributions of source code must retain the above copyright notice, 
10     this list of conditions and the following disclaimer.
11   
12   * Redistributions in binary form must reproduce the above copyright
13     notice, this list of conditions and the following disclaimer in the 
14     documentation and/or other materials provided with the distribution.
15   
16   * Neither the name of Adobe Systems Incorporated nor the names of its 
17     contributors may be used to endorse or promote products derived from 
18     this software without specific prior written permission.
19
20   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
21   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22   THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23   PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
24   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
27   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
28   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
29   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
30   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 package com.adobe.utils
34 {
35         import mx.formatters.DateBase;
36
37         /**
38         *       Class that contains static utility methods for manipulating and working
39         *       with Dates.
40         * 
41         *       @langversion ActionScript 3.0
42         *       @playerversion Flash 9.0
43         *       @tiptext
44         */      
45         public class DateUtil
46         {
47         
48                 /**
49                 *       Returns the English Short Month name (3 letters) for the Month that
50                 *       the Date represents.    
51                 * 
52                 *       @param d The Date instance whose month will be used to retrieve the
53                 *       short month name.
54                 * 
55                 *       @return An English 3 Letter Month abbreviation.
56                 *
57                 *       @langversion ActionScript 3.0
58                 *       @playerversion Flash 9.0
59                 *       @tiptext
60                 *
61                 *       @see SHORT_MONTH
62                 */      
63                 public static function getShortMonthName(d:Date):String
64                 {
65                         return DateBase.monthNamesShort[d.getMonth()];
66                 }
67
68                 /**
69                 *       Returns the index of the month that the short month name string
70                 *       represents.     
71                 * 
72                 *       @param m The 3 letter abbreviation representing a short month name.
73                 *
74                 *       @param Optional parameter indicating whether the search should be case
75                 *       sensitive
76                 * 
77                 *       @return A int that represents that month represented by the specifed
78                 *       short name.
79                 *
80                 *       @langversion ActionScript 3.0
81                 *       @playerversion Flash 9.0
82                 *       @tiptext
83                 *
84                 *       @see SHORT_MONTH
85                 */      
86                 public static function getShortMonthIndex(m:String):int
87                 {
88                         return DateBase.monthNamesShort.indexOf(m);
89                 }
90                 
91                 /**
92                 *       Returns the English full Month name for the Month that
93                 *       the Date represents.    
94                 * 
95                 *       @param d The Date instance whose month will be used to retrieve the
96                 *       full month name.
97                 * 
98                 *       @return An English full month name.
99                 *
100                 *       @langversion ActionScript 3.0
101                 *       @playerversion Flash 9.0
102                 *       @tiptext
103                 *
104                 *       @see FULL_MONTH
105                 */      
106                 public static function getFullMonthName(d:Date):String
107                 {
108                         return DateBase.monthNamesLong[d.getMonth()];   
109                 }
110
111                 /**
112                 *       Returns the index of the month that the full month name string
113                 *       represents.     
114                 * 
115                 *       @param m A full month name.
116                 * 
117                 *       @return A int that represents that month represented by the specifed
118                 *       full month name.
119                 *
120                 *       @langversion ActionScript 3.0
121                 *       @playerversion Flash 9.0
122                 *       @tiptext
123                 *
124                 *       @see FULL_MONTH
125                 */      
126                 public static function getFullMonthIndex(m:String):int
127                 {
128                         return DateBase.monthNamesLong.indexOf(m);
129                 }
130
131                 /**
132                 *       Returns the English Short Day name (3 letters) for the day that
133                 *       the Date represents.    
134                 * 
135                 *       @param d The Date instance whose day will be used to retrieve the
136                 *       short day name.
137                 * 
138                 *       @return An English 3 Letter day abbreviation.
139                 *
140                 *       @langversion ActionScript 3.0
141                 *       @playerversion Flash 9.0
142                 *       @tiptext
143                 *
144                 *       @see SHORT_DAY
145                 */      
146                 public static function getShortDayName(d:Date):String
147                 {
148                         return DateBase.dayNamesShort[d.getDay()];      
149                 }
150                 
151                 /**
152                 *       Returns the index of the day that the short day name string
153                 *       represents.     
154                 * 
155                 *       @param m A short day name.
156                 * 
157                 *       @return A int that represents that short day represented by the specifed
158                 *       full month name.
159                 *
160                 *       @langversion ActionScript 3.0
161                 *       @playerversion Flash 9.0
162                 *       @tiptext
163                 *
164                 *       @see SHORT_DAY
165                 */                      
166                 public static function getShortDayIndex(d:String):int
167                 {
168                         return DateBase.dayNamesShort.indexOf(d);
169                 }
170
171                 /**
172                 *       Returns the English full day name for the day that
173                 *       the Date represents.    
174                 * 
175                 *       @param d The Date instance whose day will be used to retrieve the
176                 *       full day name.
177                 * 
178                 *       @return An English full day name.
179                 *
180                 *       @langversion ActionScript 3.0
181                 *       @playerversion Flash 9.0
182                 *       @tiptext
183                 *
184                 *       @see FULL_DAY
185                 */      
186                 public static function getFullDayName(d:Date):String
187                 {
188                         return DateBase.dayNamesLong[d.getDay()];       
189                 }               
190
191                 /**
192                 *       Returns the index of the day that the full day name string
193                 *       represents.     
194                 * 
195                 *       @param m A full day name.
196                 * 
197                 *       @return A int that represents that full day represented by the specifed
198                 *       full month name.
199                 *
200                 *       @langversion ActionScript 3.0
201                 *       @playerversion Flash 9.0
202                 *       @tiptext
203                 *
204                 *       @see FULL_DAY
205                 */              
206                 public static function getFullDayIndex(d:String):int
207                 {
208                         return DateBase.dayNamesLong.indexOf(d);
209                 }
210
211                 /**
212                 *       Returns a two digit representation of the year represented by the 
213                 *       specified date.
214                 * 
215                 *       @param d The Date instance whose year will be used to generate a two
216                 *       digit string representation of the year.
217                 * 
218                 *       @return A string that contains a 2 digit representation of the year.
219                 *       Single digits will be padded with 0.
220                 *
221                 *       @langversion ActionScript 3.0
222                 *       @playerversion Flash 9.0
223                 *       @tiptext
224                 */      
225                 public static function getShortYear(d:Date):String
226                 {
227                         var dStr:String = String(d.getFullYear());
228                         
229                         if(dStr.length < 3)
230                         {
231                                 return dStr;
232                         }
233
234                         return (dStr.substr(dStr.length - 2));
235                 }
236
237                 /**
238                 *       Compares two dates and returns an integer depending on their relationship.
239                 *
240                 *       Returns -1 if d1 is greater than d2.
241                 *       Returns 1 if d2 is greater than d1.
242                 *       Returns 0 if both dates are equal.
243                 * 
244                 *       @param d1 The date that will be compared to the second date.
245                 *       @param d2 The date that will be compared to the first date.
246                 * 
247                 *       @return An int indicating how the two dates compare.
248                 *
249                 *       @langversion ActionScript 3.0
250                 *       @playerversion Flash 9.0
251                 *       @tiptext
252                 */      
253                 public static function compareDates(d1:Date, d2:Date):int
254                 {
255                         var d1ms:Number = d1.getTime();
256                         var d2ms:Number = d2.getTime();
257                         
258                         if(d1ms > d2ms)
259                         {
260                                 return -1;
261                         }
262                         else if(d1ms < d2ms)
263                         {
264                                 return 1;
265                         }
266                         else
267                         {
268                                 return 0;
269                         }
270                 }
271
272                 /**
273                 *       Returns a short hour (0 - 12) represented by the specified date.
274                 *
275                 *       If the hour is less than 12 (0 - 11 AM) then the hour will be returned.
276                 *
277                 *       If the hour is greater than 12 (12 - 23 PM) then the hour minus 12
278                 *       will be returned.
279                 * 
280                 *       @param d1 The Date from which to generate the short hour
281                 * 
282                 *       @return An int between 0 and 13 ( 1 - 12 ) representing the short hour.
283                 *
284                 *       @langversion ActionScript 3.0
285                 *       @playerversion Flash 9.0
286                 *       @tiptext
287                 */      
288                 public static function getShortHour(d:Date):int
289                 {
290                         var h:int = d.hours;
291                         
292                         if(h == 0 || h == 12)
293                         {
294                                 return 12;
295                         }
296                         else if(h > 12)
297                         {
298                                 return h - 12;
299                         }
300                         else
301                         {
302                                 return h;
303                         }
304                 }
305                 
306                 /**
307                 *       Returns a string indicating whether the date represents a time in the
308                 *       ante meridiem (AM) or post meridiem (PM).
309                 *
310                 *       If the hour is less than 12 then "AM" will be returned.
311                 *
312                 *       If the hour is greater than 12 then "PM" will be returned.
313                 * 
314                 *       @param d1 The Date from which to generate the 12 hour clock indicator.
315                 * 
316                 *       @return A String ("AM" or "PM") indicating which half of the day the 
317                 *       hour represents.
318                 *
319                 *       @langversion ActionScript 3.0
320                 *       @playerversion Flash 9.0
321                 *       @tiptext
322                 */      
323                 public static function getAMPM(d:Date):String
324                 {
325                         return (d.hours > 11)? "PM" : "AM";
326                 }
327
328                 /**
329                 * Parses dates that conform to RFC822 into Date objects. This method also
330                 * supports four-digit years (not supported in RFC822), but two-digit years
331                 * (referring to the 20th century) are fine, too.
332                 *
333                 * This function is useful for parsing RSS .91, .92, and 2.0 dates.
334                 *
335                 * @param str
336                 *
337                 * @returns
338                 *
339                 * @langversion ActionScript 3.0
340                 * @playerversion Flash 9.0
341                 * @tiptext
342                 *
343                 * @see http://asg.web.cmu.edu/rfc/rfc822.html
344                 */              
345                 public static function parseRFC822(str:String):Date
346                 {
347             var finalDate:Date;
348                         try
349                         {
350                                 var dateParts:Array = str.split(" ");
351                                 var day:String = null;
352                                 
353                                 if (dateParts[0].search(/\d/) == -1)
354                                 {
355                                         day = dateParts.shift().replace(/\W/, "");
356                                 }
357                                 
358                                 var date:Number = Number(dateParts.shift());
359                                 var month:Number = Number(DateUtil.getShortMonthIndex(dateParts.shift()));
360                                 var year:Number = Number(dateParts.shift());
361                                 var timeParts:Array = dateParts.shift().split(":");
362                                 var hour:Number = int(timeParts.shift());
363                                 var minute:Number = int(timeParts.shift());
364                                 var second:Number = (timeParts.length > 0) ? int(timeParts.shift()): 0;
365         
366                                 var milliseconds:Number = Date.UTC(year, month, date, hour, minute, second, 0);
367         
368                                 var timezone:String = dateParts.shift();
369                                 var offset:Number = 0;
370
371                                 if (timezone.search(/\d/) == -1)
372                                 {
373                                         switch(timezone)
374                                         {
375                                                 case "UT":
376                                                         offset = 0;
377                                                         break;
378                                                 case "UTC":
379                                                         offset = 0;
380                                                         break;
381                                                 case "GMT":
382                                                         offset = 0;
383                                                         break;
384                                                 case "EST":
385                                                         offset = (-5 * 3600000);
386                                                         break;
387                                                 case "EDT":
388                                                         offset = (-4 * 3600000);
389                                                         break;
390                                                 case "CST":
391                                                         offset = (-6 * 3600000);
392                                                         break;
393                                                 case "CDT":
394                                                         offset = (-5 * 3600000);
395                                                         break;
396                                                 case "MST":
397                                                         offset = (-7 * 3600000);
398                                                         break;
399                                                 case "MDT":
400                                                         offset = (-6 * 3600000);
401                                                         break;
402                                                 case "PST":
403                                                         offset = (-8 * 3600000);
404                                                         break;
405                                                 case "PDT":
406                                                         offset = (-7 * 3600000);
407                                                         break;
408                                                 case "Z":
409                                                         offset = 0;
410                                                         break;
411                                                 case "A":
412                                                         offset = (-1 * 3600000);
413                                                         break;
414                                                 case "M":
415                                                         offset = (-12 * 3600000);
416                                                         break;
417                                                 case "N":
418                                                         offset = (1 * 3600000);
419                                                         break;
420                                                 case "Y":
421                                                         offset = (12 * 3600000);
422                                                         break;
423                                                 default:
424                                                         offset = 0;
425                                         }
426                                 }
427                                 else
428                                 {
429                                         var multiplier:Number = 1;
430                                         var oHours:Number = 0;
431                                         var oMinutes:Number = 0;
432                                         if (timezone.length != 4)
433                                         {
434                                                 if (timezone.charAt(0) == "-")
435                                                 {
436                                                         multiplier = -1;
437                                                 }
438                                                 timezone = timezone.substr(1, 4);
439                                         }
440                                         oHours = Number(timezone.substr(0, 2));
441                                         oMinutes = Number(timezone.substr(2, 2));
442                                         offset = (((oHours * 3600000) + (oMinutes * 60000)) * multiplier);
443                                 }
444
445                                 finalDate = new Date(milliseconds - offset);
446
447                                 if (finalDate.toString() == "Invalid Date")
448                                 {
449                                         throw new Error("This date does not conform to RFC822.");
450                                 }
451                         }
452                         catch (e:Error)
453                         {
454                                 var eStr:String = "Unable to parse the string [" +str+ "] into a date. ";
455                                 eStr += "The internal error was: " + e.toString();
456                                 throw new Error(eStr);
457                         }
458             return finalDate;
459                 }
460              
461                 /**
462                 * Returns a date string formatted according to RFC822.
463                 *
464                 * @param d
465                 *
466                 * @returns
467                 *
468                 * @langversion ActionScript 3.0
469                 * @playerversion Flash 9.0
470                 * @tiptext
471                 *
472                 * @see http://asg.web.cmu.edu/rfc/rfc822.html
473                 */      
474                 public static function toRFC822(d:Date):String
475                 {
476                         var date:Number = d.getUTCDate();
477                         var hours:Number = d.getUTCHours();
478                         var minutes:Number = d.getUTCMinutes();
479                         var seconds:Number = d.getUTCSeconds();
480                         var sb:String = new String();
481                         sb += DateBase.dayNamesShort[d.getUTCDay()];
482                         sb += ", ";
483                         
484                         if (date < 10)
485                         {
486                                 sb += "0";
487                         }
488                         sb += date;
489                         sb += " ";
490                         //sb += DateUtil.SHORT_MONTH[d.getUTCMonth()];
491                         sb += DateBase.monthNamesShort[d.getUTCMonth()];
492                         sb += " ";
493                         sb += d.getUTCFullYear();
494                         sb += " ";
495                         if (hours < 10)
496                         {                       
497                                 sb += "0";
498                         }
499                         sb += hours;
500                         sb += ":";
501                         if (minutes < 10)
502                         {                       
503                                 sb += "0";
504                         }
505                         sb += minutes;
506                         sb += ":";
507                         if (seconds < 10)
508                         {                       
509                                 sb += "0";
510                         }
511                         sb += seconds;
512                         sb += " GMT";
513                         return sb;
514                 }
515              
516                 /**
517                 * Parses dates that conform to the W3C Date-time Format into Date objects.
518                 *
519                 * This function is useful for parsing RSS 1.0 and Atom 1.0 dates.
520                 *
521                 * @param str
522                 *
523                 * @returns
524                 *
525                 * @langversion ActionScript 3.0
526                 * @playerversion Flash 9.0
527                 * @tiptext
528                 *
529                 * @see http://www.w3.org/TR/NOTE-datetime
530                 */                   
531                 public static function parseW3CDTF(str:String):Date
532                 {
533             var finalDate:Date;
534                         try
535                         {
536                                 var dateStr:String = str.substring(0, str.indexOf("T"));
537                                 var timeStr:String = str.substring(str.indexOf("T")+1, str.length);
538                                 var dateArr:Array = dateStr.split("-");
539                                 var year:Number = Number(dateArr.shift());
540                                 var month:Number = Number(dateArr.shift());
541                                 var date:Number = Number(dateArr.shift());
542                                 
543                                 var multiplier:Number;
544                                 var offsetHours:Number;
545                                 var offsetMinutes:Number;
546                                 var offsetStr:String;
547                                 
548                                 if (timeStr.indexOf("Z") != -1)
549                                 {
550                                         multiplier = 1;
551                                         offsetHours = 0;
552                                         offsetMinutes = 0;
553                                         timeStr = timeStr.replace("Z", "");
554                                 }
555                                 else if (timeStr.indexOf("+") != -1)
556                                 {
557                                         multiplier = 1;
558                                         offsetStr = timeStr.substring(timeStr.indexOf("+")+1, timeStr.length);
559                                         offsetHours = Number(offsetStr.substring(0, offsetStr.indexOf(":")));
560                                         offsetMinutes = Number(offsetStr.substring(offsetStr.indexOf(":")+1, offsetStr.length));
561                                         timeStr = timeStr.substring(0, timeStr.indexOf("+"));
562                                 }
563                                 else // offset is -
564                                 {
565                                         multiplier = -1;
566                                         offsetStr = timeStr.substring(timeStr.indexOf("-")+1, timeStr.length);
567                                         offsetHours = Number(offsetStr.substring(0, offsetStr.indexOf(":")));
568                                         offsetMinutes = Number(offsetStr.substring(offsetStr.indexOf(":")+1, offsetStr.length));
569                                         timeStr = timeStr.substring(0, timeStr.indexOf("-"));
570                                 }
571                                 var timeArr:Array = timeStr.split(":");
572                                 var hour:Number = Number(timeArr.shift());
573                                 var minutes:Number = Number(timeArr.shift());
574                                 var secondsArr:Array = (timeArr.length > 0) ? String(timeArr.shift()).split(".") : null;
575                                 var seconds:Number = (secondsArr != null && secondsArr.length > 0) ? Number(secondsArr.shift()) : 0;
576                                 var milliseconds:Number = (secondsArr != null && secondsArr.length > 0) ? Number(secondsArr.shift()) : 0;
577                                 var utc:Number = Date.UTC(year, month-1, date, hour, minutes, seconds, milliseconds);
578                                 var offset:Number = (((offsetHours * 3600000) + (offsetMinutes * 60000)) * multiplier);
579                                 finalDate = new Date(utc - offset);
580         
581                                 if (finalDate.toString() == "Invalid Date")
582                                 {
583                                         throw new Error("This date does not conform to W3CDTF.");
584                                 }
585                         }
586                         catch (e:Error)
587                         {
588                                 var eStr:String = "Unable to parse the string [" +str+ "] into a date. ";
589                                 eStr += "The internal error was: " + e.toString();
590                                 throw new Error(eStr);
591                         }
592             return finalDate;
593                 }
594              
595                 /**
596                 * Returns a date string formatted according to W3CDTF.
597                 *
598                 * @param d
599                 * @param includeMilliseconds Determines whether to include the
600                 * milliseconds value (if any) in the formatted string.
601                 *
602                 * @returns
603                 *
604                 * @langversion ActionScript 3.0
605                 * @playerversion Flash 9.0
606                 * @tiptext
607                 *
608                 * @see http://www.w3.org/TR/NOTE-datetime
609                 */                   
610                 public static function toW3CDTF(d:Date,includeMilliseconds:Boolean=false):String
611                 {
612                         var date:Number = d.getUTCDate();
613                         var month:Number = d.getUTCMonth();
614                         var hours:Number = d.getUTCHours();
615                         var minutes:Number = d.getUTCMinutes();
616                         var seconds:Number = d.getUTCSeconds();
617                         var milliseconds:Number = d.getUTCMilliseconds();
618                         var sb:String = new String();
619                         
620                         sb += d.getUTCFullYear();
621                         sb += "-";
622                         
623                         //thanks to "dom" who sent in a fix for the line below
624                         if (month + 1 < 10)
625                         {
626                                 sb += "0";
627                         }
628                         sb += month + 1;
629                         sb += "-";
630                         if (date < 10)
631                         {
632                                 sb += "0";
633                         }
634                         sb += date;
635                         sb += "T";
636                         if (hours < 10)
637                         {
638                                 sb += "0";
639                         }
640                         sb += hours;
641                         sb += ":";
642                         if (minutes < 10)
643                         {
644                                 sb += "0";
645                         }
646                         sb += minutes;
647                         sb += ":";
648                         if (seconds < 10)
649                         {
650                                 sb += "0";
651                         }
652                         sb += seconds;
653                         if (includeMilliseconds && milliseconds > 0)
654                         {
655                                 sb += ".";
656                                 sb += milliseconds;
657                         }
658                         sb += "-00:00";
659                         return sb;
660                 }
661                 
662                 /**
663                  * Converts a date into just after midnight.
664                  */
665                 public static function makeMorning(d:Date):Date
666                 {
667                         var d:Date = new Date(d.time);
668                         d.hours = 0;
669             d.minutes = 0;
670             d.seconds = 0;
671             d.milliseconds = 0;
672             return d;
673                 }
674                 
675                 /**
676                  * Converts a date into just befor midnight.
677                  */
678                 public static function makeNight(d:Date):Date
679                 {
680                         var d:Date = new Date(d.time);
681                         d.hours = 23;
682             d.minutes = 59;
683             d.seconds = 59;
684             d.milliseconds = 999;                               
685             return d;
686                 }
687
688                 /**
689                  * Sort of converts a date into UTC.
690                  */
691                 public static function getUTCDate(d:Date):Date
692                 {
693                         var nd:Date = new Date();
694                         var offset:Number = d.getTimezoneOffset() * 60 * 1000; 
695                         nd.setTime(d.getTime() + offset);
696                         return nd;
697                 }
698         }
699 }