]> git.saurik.com Git - wxWidgets.git/blob - src/common/datetime.cpp
Don't change the fg/bg colours so that the native colours will be
[wxWidgets.git] / src / common / datetime.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: wx/datetime.h
3 // Purpose: implementation of time/date related classes
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 11.05.99
7 // RCS-ID: $Id$
8 // Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // parts of code taken from sndcal library by Scott E. Lee:
10 //
11 // Copyright 1993-1995, Scott E. Lee, all rights reserved.
12 // Permission granted to use, copy, modify, distribute and sell
13 // so long as the above copyright and this permission statement
14 // are retained in all copies.
15 //
16 // Licence: wxWindows licence
17 ///////////////////////////////////////////////////////////////////////////////
18
19 // TODO: for $DEITY sake, someone please fix the #ifdef __WXWINCE__ everywhere,
20 // the proper way to do it is to implement (subset of) wxStrftime() for
21 // CE instead of this horror!!
22
23 /*
24 * Implementation notes:
25 *
26 * 1. the time is stored as a 64bit integer containing the signed number of
27 * milliseconds since Jan 1. 1970 (the Unix Epoch) - so it is always
28 * expressed in GMT.
29 *
30 * 2. the range is thus something about 580 million years, but due to current
31 * algorithms limitations, only dates from Nov 24, 4714BC are handled
32 *
33 * 3. standard ANSI C functions are used to do time calculations whenever
34 * possible, i.e. when the date is in the range Jan 1, 1970 to 2038
35 *
36 * 4. otherwise, the calculations are done by converting the date to/from JDN
37 * first (the range limitation mentioned above comes from here: the
38 * algorithm used by Scott E. Lee's code only works for positive JDNs, more
39 * or less)
40 *
41 * 5. the object constructed for the given DD-MM-YYYY HH:MM:SS corresponds to
42 * this moment in local time and may be converted to the object
43 * corresponding to the same date/time in another time zone by using
44 * ToTimezone()
45 *
46 * 6. the conversions to the current (or any other) timezone are done when the
47 * internal time representation is converted to the broken-down one in
48 * wxDateTime::Tm.
49 */
50
51 // ============================================================================
52 // declarations
53 // ============================================================================
54
55 // ----------------------------------------------------------------------------
56 // headers
57 // ----------------------------------------------------------------------------
58
59 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
60 #pragma implementation "datetime.h"
61 #endif
62
63 // For compilers that support precompilation, includes "wx.h".
64 #include "wx/wxprec.h"
65
66 #ifdef __BORLANDC__
67 #pragma hdrstop
68 #endif
69
70 #if !defined(wxUSE_DATETIME) || wxUSE_DATETIME
71
72 #ifndef WX_PRECOMP
73 #include "wx/string.h"
74 #include "wx/log.h"
75 #endif // WX_PRECOMP
76
77 #include "wx/intl.h"
78 #include "wx/thread.h"
79 #include "wx/tokenzr.h"
80 #include "wx/module.h"
81
82 #include <ctype.h>
83
84 #ifdef __WINDOWS__
85 #include "wx/msw/wrapwin.h"
86 #include <winnls.h>
87 #ifndef __WXWINCE__
88 #include <locale.h>
89 #endif
90 #endif
91
92 #include "wx/datetime.h"
93 #include "wx/stopwatch.h" // for wxGetLocalTimeMillis()
94
95 const long wxDateTime::TIME_T_FACTOR = 1000l;
96
97 #if wxUSE_EXTENDED_RTTI
98
99 template<> void wxStringReadValue(const wxString &s , wxDateTime &data )
100 {
101 data.ParseFormat(s,wxT("%Y-%m-%d %H:%M:%S")) ;
102 }
103
104 template<> void wxStringWriteValue(wxString &s , const wxDateTime &data )
105 {
106 s = data.Format(wxT("%Y-%m-%d %H:%M:%S")) ;
107 }
108
109 wxCUSTOM_TYPE_INFO(wxDateTime, wxToStringConverter<wxDateTime> , wxFromStringConverter<wxDateTime>)
110
111 #endif
112
113 //
114 // ----------------------------------------------------------------------------
115 // conditional compilation
116 // ----------------------------------------------------------------------------
117
118 #if defined(HAVE_STRPTIME) && defined(__GLIBC__) && \
119 ((__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0))
120 // glibc 2.0.7 strptime() is broken - the following snippet causes it to
121 // crash (instead of just failing):
122 //
123 // strncpy(buf, "Tue Dec 21 20:25:40 1999", 128);
124 // strptime(buf, "%x", &tm);
125 //
126 // so don't use it
127 #undef HAVE_STRPTIME
128 #endif // broken strptime()
129
130 #if defined(HAVE_STRPTIME) && defined(__DARWIN__) && defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
131 // configure detects strptime as linkable because it's in the OS X
132 // System library but MSL headers don't declare it.
133
134 // char *strptime(const char *, const char *, struct tm *);
135 // However, we DON'T want to just provide it here because we would
136 // crash and/or overwrite data when strptime from OS X tries
137 // to fill in MW's struct tm which is two fields shorter (no TZ stuff)
138 // So for now let's just say we don't have strptime
139 #undef HAVE_STRPTIME
140 #endif
141
142 #if defined(__MWERKS__) && wxUSE_UNICODE
143 #include <wtime.h>
144 #endif
145
146 #if !defined(WX_TIMEZONE) && !defined(WX_GMTOFF_IN_TM)
147 #if defined(__WXPALMOS__)
148 #define WX_GMTOFF_IN_TM
149 #elif defined(__BORLANDC__) || defined(__MINGW32__) || defined(__VISAGECPP__)
150 #define WX_TIMEZONE _timezone
151 #elif defined(__MWERKS__)
152 long wxmw_timezone = 28800;
153 #define WX_TIMEZONE wxmw_timezone
154 #elif defined(__DJGPP__) || defined(__WINE__)
155 #include <sys/timeb.h>
156 #include <values.h>
157 static long wxGetTimeZone()
158 {
159 static long timezone = MAXLONG; // invalid timezone
160 if (timezone == MAXLONG)
161 {
162 struct timeb tb;
163 ftime(&tb);
164 timezone = tb.timezone;
165 }
166 return timezone;
167 }
168 #define WX_TIMEZONE wxGetTimeZone()
169 #elif defined(__DARWIN__)
170 #define WX_GMTOFF_IN_TM
171 #else // unknown platform - try timezone
172 #define WX_TIMEZONE timezone
173 #endif
174 #endif // !WX_TIMEZONE && !WX_GMTOFF_IN_TM
175
176 // ----------------------------------------------------------------------------
177 // macros
178 // ----------------------------------------------------------------------------
179
180 // debugging helper: just a convenient replacement of wxCHECK()
181 #define wxDATETIME_CHECK(expr, msg) \
182 if ( !(expr) ) \
183 { \
184 wxFAIL_MSG(msg); \
185 *this = wxInvalidDateTime; \
186 return *this; \
187 }
188
189 // ----------------------------------------------------------------------------
190 // private classes
191 // ----------------------------------------------------------------------------
192
193 class wxDateTimeHolidaysModule : public wxModule
194 {
195 public:
196 virtual bool OnInit()
197 {
198 wxDateTimeHolidayAuthority::AddAuthority(new wxDateTimeWorkDays);
199
200 return true;
201 }
202
203 virtual void OnExit()
204 {
205 wxDateTimeHolidayAuthority::ClearAllAuthorities();
206 wxDateTimeHolidayAuthority::ms_authorities.clear();
207 }
208
209 private:
210 DECLARE_DYNAMIC_CLASS(wxDateTimeHolidaysModule)
211 };
212
213 IMPLEMENT_DYNAMIC_CLASS(wxDateTimeHolidaysModule, wxModule)
214
215 // ----------------------------------------------------------------------------
216 // constants
217 // ----------------------------------------------------------------------------
218
219 // some trivial ones
220 static const int MONTHS_IN_YEAR = 12;
221
222 static const int SEC_PER_MIN = 60;
223
224 static const int MIN_PER_HOUR = 60;
225
226 static const int HOURS_PER_DAY = 24;
227
228 static const long SECONDS_PER_DAY = 86400l;
229
230 static const int DAYS_PER_WEEK = 7;
231
232 static const long MILLISECONDS_PER_DAY = 86400000l;
233
234 // this is the integral part of JDN of the midnight of Jan 1, 1970
235 // (i.e. JDN(Jan 1, 1970) = 2440587.5)
236 static const long EPOCH_JDN = 2440587l;
237
238 // the date of JDN -0.5 (as we don't work with fractional parts, this is the
239 // reference date for us) is Nov 24, 4714BC
240 static const int JDN_0_YEAR = -4713;
241 static const int JDN_0_MONTH = wxDateTime::Nov;
242 static const int JDN_0_DAY = 24;
243
244 // the constants used for JDN calculations
245 static const long JDN_OFFSET = 32046l;
246 static const long DAYS_PER_5_MONTHS = 153l;
247 static const long DAYS_PER_4_YEARS = 1461l;
248 static const long DAYS_PER_400_YEARS = 146097l;
249
250 // this array contains the cumulated number of days in all previous months for
251 // normal and leap years
252 static const wxDateTime::wxDateTime_t gs_cumulatedDays[2][MONTHS_IN_YEAR] =
253 {
254 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
255 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
256 };
257
258 // ----------------------------------------------------------------------------
259 // global data
260 // ----------------------------------------------------------------------------
261
262 const wxChar * wxDefaultDateTimeFormat = wxT("%c");
263 const wxChar * wxDefaultTimeSpanFormat = wxT("%H:%M:%S");
264
265 // in the fine tradition of ANSI C we use our equivalent of (time_t)-1 to
266 // indicate an invalid wxDateTime object
267 const wxDateTime wxDefaultDateTime;
268
269 wxDateTime::Country wxDateTime::ms_country = wxDateTime::Country_Unknown;
270
271 // ----------------------------------------------------------------------------
272 // private functions
273 // ----------------------------------------------------------------------------
274
275 // debugger helper: shows what the date really is
276 #ifdef __WXDEBUG__
277 extern const wxChar *wxDumpDate(const wxDateTime* dt)
278 {
279 static wxChar buf[128];
280
281 wxStrcpy(buf, dt->Format(_T("%Y-%m-%d (%a) %H:%M:%S")));
282
283 return buf;
284 }
285 #endif // Debug
286
287 // get the number of days in the given month of the given year
288 static inline
289 wxDateTime::wxDateTime_t GetNumOfDaysInMonth(int year, wxDateTime::Month month)
290 {
291 // the number of days in month in Julian/Gregorian calendar: the first line
292 // is for normal years, the second one is for the leap ones
293 static wxDateTime::wxDateTime_t daysInMonth[2][MONTHS_IN_YEAR] =
294 {
295 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
296 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
297 };
298
299 return daysInMonth[wxDateTime::IsLeapYear(year)][month];
300 }
301
302 // returns the time zone in the C sense, i.e. the difference UTC - local
303 // (in seconds)
304 static int GetTimeZone()
305 {
306 #ifdef WX_GMTOFF_IN_TM
307 // set to true when the timezone is set
308 static bool s_timezoneSet = false;
309 static long gmtoffset = LONG_MAX; // invalid timezone
310
311 // ensure that the timezone variable is set by calling localtime
312 if ( !s_timezoneSet )
313 {
314 // just call localtime() instead of figuring out whether this system
315 // supports tzset(), _tzset() or something else
316 time_t t = 0;
317 struct tm *tm;
318
319 tm = localtime(&t);
320 s_timezoneSet = true;
321
322 // note that GMT offset is the opposite of time zone and so to return
323 // consistent results in both WX_GMTOFF_IN_TM and !WX_GMTOFF_IN_TM
324 // cases we have to negate it
325 gmtoffset = -tm->tm_gmtoff;
326 }
327
328 return (int)gmtoffset;
329 #else // !WX_GMTOFF_IN_TM
330 return (int)WX_TIMEZONE;
331 #endif // WX_GMTOFF_IN_TM/!WX_GMTOFF_IN_TM
332 }
333
334 // return the integral part of the JDN for the midnight of the given date (to
335 // get the real JDN you need to add 0.5, this is, in fact, JDN of the
336 // noon of the previous day)
337 static long GetTruncatedJDN(wxDateTime::wxDateTime_t day,
338 wxDateTime::Month mon,
339 int year)
340 {
341 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
342
343 // check the date validity
344 wxASSERT_MSG(
345 (year > JDN_0_YEAR) ||
346 ((year == JDN_0_YEAR) && (mon > JDN_0_MONTH)) ||
347 ((year == JDN_0_YEAR) && (mon == JDN_0_MONTH) && (day >= JDN_0_DAY)),
348 _T("date out of range - can't convert to JDN")
349 );
350
351 // make the year positive to avoid problems with negative numbers division
352 year += 4800;
353
354 // months are counted from March here
355 int month;
356 if ( mon >= wxDateTime::Mar )
357 {
358 month = mon - 2;
359 }
360 else
361 {
362 month = mon + 10;
363 year--;
364 }
365
366 // now we can simply add all the contributions together
367 return ((year / 100) * DAYS_PER_400_YEARS) / 4
368 + ((year % 100) * DAYS_PER_4_YEARS) / 4
369 + (month * DAYS_PER_5_MONTHS + 2) / 5
370 + day
371 - JDN_OFFSET;
372 }
373
374 #ifndef __WXWINCE__
375 // this function is a wrapper around strftime(3) adding error checking
376 static wxString CallStrftime(const wxChar *format, const tm* tm)
377 {
378 wxChar buf[4096];
379 if ( !wxStrftime(buf, WXSIZEOF(buf), format, tm) )
380 {
381 // buffer is too small?
382 wxFAIL_MSG(_T("strftime() failed"));
383 }
384
385 return wxString(buf);
386 }
387 #endif
388
389 #ifdef HAVE_STRPTIME
390
391 // glibc2 doesn't define this in the headers unless _XOPEN_SOURCE is defined
392 // which, unfortunately, wreaks havoc elsewhere
393 #if defined(__GLIBC__) && (__GLIBC__ == 2)
394 extern "C" char *strptime(const char *, const char *, struct tm *);
395 #endif
396
397 // Unicode-friendly strptime() wrapper
398 static const wxChar *
399 CallStrptime(const wxChar *input, const char *fmt, tm *tm)
400 {
401 // the problem here is that strptime() returns pointer into the string we
402 // passed to it while we're really interested in the pointer into the
403 // original, Unicode, string so we try to transform the pointer back
404 #if wxUSE_UNICODE
405 wxCharBuffer inputMB(wxConvertWX2MB(input));
406 #else // ASCII
407 const char * const inputMB = input;
408 #endif // Unicode/Ascii
409
410 const char *result = strptime(inputMB, fmt, tm);
411 if ( !result )
412 return NULL;
413
414 #if wxUSE_UNICODE
415 // FIXME: this is wrong in presence of surrogates &c
416 return input + (result - inputMB.data());
417 #else // ASCII
418 return result;
419 #endif // Unicode/Ascii
420 }
421
422 #endif // HAVE_STRPTIME
423
424 // if year and/or month have invalid values, replace them with the current ones
425 static void ReplaceDefaultYearMonthWithCurrent(int *year,
426 wxDateTime::Month *month)
427 {
428 struct tm *tmNow = NULL;
429
430 if ( *year == wxDateTime::Inv_Year )
431 {
432 tmNow = wxDateTime::GetTmNow();
433
434 *year = 1900 + tmNow->tm_year;
435 }
436
437 if ( *month == wxDateTime::Inv_Month )
438 {
439 if ( !tmNow )
440 tmNow = wxDateTime::GetTmNow();
441
442 *month = (wxDateTime::Month)tmNow->tm_mon;
443 }
444 }
445
446 // fll the struct tm with default values
447 static void InitTm(struct tm& tm)
448 {
449 // struct tm may have etxra fields (undocumented and with unportable
450 // names) which, nevertheless, must be set to 0
451 memset(&tm, 0, sizeof(struct tm));
452
453 tm.tm_mday = 1; // mday 0 is invalid
454 tm.tm_year = 76; // any valid year
455 tm.tm_isdst = -1; // auto determine
456 }
457
458 // parsing helpers
459 // ---------------
460
461 // return the month if the string is a month name or Inv_Month otherwise
462 static wxDateTime::Month GetMonthFromName(const wxString& name, int flags)
463 {
464 wxDateTime::Month mon;
465 for ( mon = wxDateTime::Jan; mon < wxDateTime::Inv_Month; wxNextMonth(mon) )
466 {
467 // case-insensitive comparison either one of or with both abbreviated
468 // and not versions
469 if ( flags & wxDateTime::Name_Full )
470 {
471 if ( name.CmpNoCase(wxDateTime::
472 GetMonthName(mon, wxDateTime::Name_Full)) == 0 )
473 {
474 break;
475 }
476 }
477
478 if ( flags & wxDateTime::Name_Abbr )
479 {
480 if ( name.CmpNoCase(wxDateTime::
481 GetMonthName(mon, wxDateTime::Name_Abbr)) == 0 )
482 {
483 break;
484 }
485 }
486 }
487
488 return mon;
489 }
490
491 // return the weekday if the string is a weekday name or Inv_WeekDay otherwise
492 static wxDateTime::WeekDay GetWeekDayFromName(const wxString& name, int flags)
493 {
494 wxDateTime::WeekDay wd;
495 for ( wd = wxDateTime::Sun; wd < wxDateTime::Inv_WeekDay; wxNextWDay(wd) )
496 {
497 // case-insensitive comparison either one of or with both abbreviated
498 // and not versions
499 if ( flags & wxDateTime::Name_Full )
500 {
501 if ( name.CmpNoCase(wxDateTime::
502 GetWeekDayName(wd, wxDateTime::Name_Full)) == 0 )
503 {
504 break;
505 }
506 }
507
508 if ( flags & wxDateTime::Name_Abbr )
509 {
510 if ( name.CmpNoCase(wxDateTime::
511 GetWeekDayName(wd, wxDateTime::Name_Abbr)) == 0 )
512 {
513 break;
514 }
515 }
516 }
517
518 return wd;
519 }
520
521 // scans all digits (but no more than len) and returns the resulting number
522 static bool GetNumericToken(size_t len, const wxChar*& p, unsigned long *number)
523 {
524 size_t n = 1;
525 wxString s;
526 while ( wxIsdigit(*p) )
527 {
528 s += *p++;
529
530 if ( len && ++n > len )
531 break;
532 }
533
534 return !s.empty() && s.ToULong(number);
535 }
536
537 // scans all alphabetic characters and returns the resulting string
538 static wxString GetAlphaToken(const wxChar*& p)
539 {
540 wxString s;
541 while ( wxIsalpha(*p) )
542 {
543 s += *p++;
544 }
545
546 return s;
547 }
548
549 // ============================================================================
550 // implementation of wxDateTime
551 // ============================================================================
552
553 // ----------------------------------------------------------------------------
554 // struct Tm
555 // ----------------------------------------------------------------------------
556
557 wxDateTime::Tm::Tm()
558 {
559 year = (wxDateTime_t)wxDateTime::Inv_Year;
560 mon = wxDateTime::Inv_Month;
561 mday = 0;
562 hour = min = sec = msec = 0;
563 wday = wxDateTime::Inv_WeekDay;
564 }
565
566 wxDateTime::Tm::Tm(const struct tm& tm, const TimeZone& tz)
567 : m_tz(tz)
568 {
569 msec = 0;
570 sec = (wxDateTime::wxDateTime_t)tm.tm_sec;
571 min = (wxDateTime::wxDateTime_t)tm.tm_min;
572 hour = (wxDateTime::wxDateTime_t)tm.tm_hour;
573 mday = (wxDateTime::wxDateTime_t)tm.tm_mday;
574 mon = (wxDateTime::Month)tm.tm_mon;
575 year = 1900 + tm.tm_year;
576 wday = (wxDateTime::wxDateTime_t)tm.tm_wday;
577 yday = (wxDateTime::wxDateTime_t)tm.tm_yday;
578 }
579
580 bool wxDateTime::Tm::IsValid() const
581 {
582 // we allow for the leap seconds, although we don't use them (yet)
583 return (year != wxDateTime::Inv_Year) && (mon != wxDateTime::Inv_Month) &&
584 (mday <= GetNumOfDaysInMonth(year, mon)) &&
585 (hour < 24) && (min < 60) && (sec < 62) && (msec < 1000);
586 }
587
588 void wxDateTime::Tm::ComputeWeekDay()
589 {
590 // compute the week day from day/month/year: we use the dumbest algorithm
591 // possible: just compute our JDN and then use the (simple to derive)
592 // formula: weekday = (JDN + 1.5) % 7
593 wday = (wxDateTime::wxDateTime_t)((wxDateTime::WeekDay)(GetTruncatedJDN(mday, mon, year) + 2) % 7);
594 }
595
596 void wxDateTime::Tm::AddMonths(int monDiff)
597 {
598 // normalize the months field
599 while ( monDiff < -mon )
600 {
601 year--;
602
603 monDiff += MONTHS_IN_YEAR;
604 }
605
606 while ( monDiff + mon >= MONTHS_IN_YEAR )
607 {
608 year++;
609
610 monDiff -= MONTHS_IN_YEAR;
611 }
612
613 mon = (wxDateTime::Month)(mon + monDiff);
614
615 wxASSERT_MSG( mon >= 0 && mon < MONTHS_IN_YEAR, _T("logic error") );
616
617 // NB: we don't check here that the resulting date is valid, this function
618 // is private and the caller must check it if needed
619 }
620
621 void wxDateTime::Tm::AddDays(int dayDiff)
622 {
623 // normalize the days field
624 while ( dayDiff + mday < 1 )
625 {
626 AddMonths(-1);
627
628 dayDiff += GetNumOfDaysInMonth(year, mon);
629 }
630
631 mday = (wxDateTime::wxDateTime_t)( mday + dayDiff );
632 while ( mday > GetNumOfDaysInMonth(year, mon) )
633 {
634 mday -= GetNumOfDaysInMonth(year, mon);
635
636 AddMonths(1);
637 }
638
639 wxASSERT_MSG( mday > 0 && mday <= GetNumOfDaysInMonth(year, mon),
640 _T("logic error") );
641 }
642
643 // ----------------------------------------------------------------------------
644 // class TimeZone
645 // ----------------------------------------------------------------------------
646
647 wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz)
648 {
649 switch ( tz )
650 {
651 case wxDateTime::Local:
652 // get the offset from C RTL: it returns the difference GMT-local
653 // while we want to have the offset _from_ GMT, hence the '-'
654 m_offset = -GetTimeZone();
655 break;
656
657 case wxDateTime::GMT_12:
658 case wxDateTime::GMT_11:
659 case wxDateTime::GMT_10:
660 case wxDateTime::GMT_9:
661 case wxDateTime::GMT_8:
662 case wxDateTime::GMT_7:
663 case wxDateTime::GMT_6:
664 case wxDateTime::GMT_5:
665 case wxDateTime::GMT_4:
666 case wxDateTime::GMT_3:
667 case wxDateTime::GMT_2:
668 case wxDateTime::GMT_1:
669 m_offset = -3600*(wxDateTime::GMT0 - tz);
670 break;
671
672 case wxDateTime::GMT0:
673 case wxDateTime::GMT1:
674 case wxDateTime::GMT2:
675 case wxDateTime::GMT3:
676 case wxDateTime::GMT4:
677 case wxDateTime::GMT5:
678 case wxDateTime::GMT6:
679 case wxDateTime::GMT7:
680 case wxDateTime::GMT8:
681 case wxDateTime::GMT9:
682 case wxDateTime::GMT10:
683 case wxDateTime::GMT11:
684 case wxDateTime::GMT12:
685 m_offset = 3600*(tz - wxDateTime::GMT0);
686 break;
687
688 case wxDateTime::A_CST:
689 // Central Standard Time in use in Australia = UTC + 9.5
690 m_offset = 60l*(9*60 + 30);
691 break;
692
693 default:
694 wxFAIL_MSG( _T("unknown time zone") );
695 }
696 }
697
698 // ----------------------------------------------------------------------------
699 // static functions
700 // ----------------------------------------------------------------------------
701
702 /* static */
703 bool wxDateTime::IsLeapYear(int year, wxDateTime::Calendar cal)
704 {
705 if ( year == Inv_Year )
706 year = GetCurrentYear();
707
708 if ( cal == Gregorian )
709 {
710 // in Gregorian calendar leap years are those divisible by 4 except
711 // those divisible by 100 unless they're also divisible by 400
712 // (in some countries, like Russia and Greece, additional corrections
713 // exist, but they won't manifest themselves until 2700)
714 return (year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0));
715 }
716 else if ( cal == Julian )
717 {
718 // in Julian calendar the rule is simpler
719 return year % 4 == 0;
720 }
721 else
722 {
723 wxFAIL_MSG(_T("unknown calendar"));
724
725 return false;
726 }
727 }
728
729 /* static */
730 int wxDateTime::GetCentury(int year)
731 {
732 return year > 0 ? year / 100 : year / 100 - 1;
733 }
734
735 /* static */
736 int wxDateTime::ConvertYearToBC(int year)
737 {
738 // year 0 is BC 1
739 return year > 0 ? year : year - 1;
740 }
741
742 /* static */
743 int wxDateTime::GetCurrentYear(wxDateTime::Calendar cal)
744 {
745 switch ( cal )
746 {
747 case Gregorian:
748 return Now().GetYear();
749
750 case Julian:
751 wxFAIL_MSG(_T("TODO"));
752 break;
753
754 default:
755 wxFAIL_MSG(_T("unsupported calendar"));
756 break;
757 }
758
759 return Inv_Year;
760 }
761
762 /* static */
763 wxDateTime::Month wxDateTime::GetCurrentMonth(wxDateTime::Calendar cal)
764 {
765 switch ( cal )
766 {
767 case Gregorian:
768 return Now().GetMonth();
769
770 case Julian:
771 wxFAIL_MSG(_T("TODO"));
772 break;
773
774 default:
775 wxFAIL_MSG(_T("unsupported calendar"));
776 break;
777 }
778
779 return Inv_Month;
780 }
781
782 /* static */
783 wxDateTime::wxDateTime_t wxDateTime::GetNumberOfDays(int year, Calendar cal)
784 {
785 if ( year == Inv_Year )
786 {
787 // take the current year if none given
788 year = GetCurrentYear();
789 }
790
791 switch ( cal )
792 {
793 case Gregorian:
794 case Julian:
795 return IsLeapYear(year) ? 366 : 365;
796
797 default:
798 wxFAIL_MSG(_T("unsupported calendar"));
799 break;
800 }
801
802 return 0;
803 }
804
805 /* static */
806 wxDateTime::wxDateTime_t wxDateTime::GetNumberOfDays(wxDateTime::Month month,
807 int year,
808 wxDateTime::Calendar cal)
809 {
810 wxCHECK_MSG( month < MONTHS_IN_YEAR, 0, _T("invalid month") );
811
812 if ( cal == Gregorian || cal == Julian )
813 {
814 if ( year == Inv_Year )
815 {
816 // take the current year if none given
817 year = GetCurrentYear();
818 }
819
820 return GetNumOfDaysInMonth(year, month);
821 }
822 else
823 {
824 wxFAIL_MSG(_T("unsupported calendar"));
825
826 return 0;
827 }
828 }
829
830 /* static */
831 wxString wxDateTime::GetMonthName(wxDateTime::Month month,
832 wxDateTime::NameFlags flags)
833 {
834 wxCHECK_MSG( month != Inv_Month, wxEmptyString, _T("invalid month") );
835 #ifndef __WXWINCE__
836 // notice that we must set all the fields to avoid confusing libc (GNU one
837 // gets confused to a crash if we don't do this)
838 tm tm;
839 InitTm(tm);
840 tm.tm_mon = month;
841
842 return CallStrftime(flags == Name_Abbr ? _T("%b") : _T("%B"), &tm);
843 #else
844 wxString ret;
845 switch(month)
846 {
847 case Jan:
848 ret = (flags == Name_Abbr ? wxT("Jan"): wxT("January"));
849 break;
850 case Feb:
851 ret = (flags == Name_Abbr ? wxT("Feb"): wxT("Febuary"));
852 break;
853 case Mar:
854 ret = (flags == Name_Abbr ? wxT("Mar"): wxT("March"));
855 break;
856 case Apr:
857 ret = (flags == Name_Abbr ? wxT("Apr"): wxT("April"));
858 break;
859 case May:
860 ret = (flags == Name_Abbr ? wxT("May"): wxT("May"));
861 break;
862 case Jun:
863 ret = (flags == Name_Abbr ? wxT("Jun"): wxT("June"));
864 break;
865 case Jul:
866 ret = (flags == Name_Abbr ? wxT("Jul"): wxT("July"));
867 break;
868 case Aug:
869 ret = (flags == Name_Abbr ? wxT("Aug"): wxT("August"));
870 break;
871 case Sep:
872 ret = (flags == Name_Abbr ? wxT("Sep"): wxT("September"));
873 break;
874 case Oct:
875 ret = (flags == Name_Abbr ? wxT("Oct"): wxT("October"));
876 break;
877 case Nov:
878 ret = (flags == Name_Abbr ? wxT("Nov"): wxT("November"));
879 break;
880 case Dec:
881 ret = (flags == Name_Abbr ? wxT("Dec"): wxT("December"));
882 break;
883 }
884 return ret;
885 #endif
886 }
887
888 /* static */
889 wxString wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday,
890 wxDateTime::NameFlags flags)
891 {
892 wxCHECK_MSG( wday != Inv_WeekDay, wxEmptyString, _T("invalid weekday") );
893 #ifndef __WXWINCE__
894 // take some arbitrary Sunday (but notice that the day should be such that
895 // after adding wday to it below we still have a valid date, e.g. don't
896 // take 28 here!)
897 tm tm;
898 InitTm(tm);
899 tm.tm_mday = 21;
900 tm.tm_mon = Nov;
901 tm.tm_year = 99;
902
903 // and offset it by the number of days needed to get the correct wday
904 tm.tm_mday += wday;
905
906 // call mktime() to normalize it...
907 (void)mktime(&tm);
908
909 // ... and call strftime()
910 return CallStrftime(flags == Name_Abbr ? _T("%a") : _T("%A"), &tm);
911 #else
912 wxString ret;
913 switch(wday)
914 {
915 case Sun:
916 ret = (flags == Name_Abbr ? wxT("Sun") : wxT("Sunday"));
917 break;
918 case Mon:
919 ret = (flags == Name_Abbr ? wxT("Mon") : wxT("Monday"));
920 break;
921 case Tue:
922 ret = (flags == Name_Abbr ? wxT("Tue") : wxT("Tuesday"));
923 break;
924 case Wed:
925 ret = (flags == Name_Abbr ? wxT("Wed") : wxT("Wednesday"));
926 break;
927 case Thu:
928 ret = (flags == Name_Abbr ? wxT("Thu") : wxT("Thursday"));
929 break;
930 case Fri:
931 ret = (flags == Name_Abbr ? wxT("Fri") : wxT("Friday"));
932 break;
933 case Sat:
934 ret = (flags == Name_Abbr ? wxT("Sat") : wxT("Saturday"));
935 break;
936 }
937 return ret;
938
939 #endif
940 }
941
942 /* static */
943 void wxDateTime::GetAmPmStrings(wxString *am, wxString *pm)
944 {
945 tm tm;
946 InitTm(tm);
947 wxChar buffer[64];
948 // @Note: Do not call 'CallStrftime' here! CallStrftime checks the return code
949 // and causes an assertion failed if the buffer is to small (which is good) - OR -
950 // if strftime does not return anything because the format string is invalid - OR -
951 // if there are no 'am' / 'pm' tokens defined for the current locale (which is not good).
952 // wxDateTime::ParseTime will try several different formats to parse the time.
953 // As a result, GetAmPmStrings might get called, even if the current locale
954 // does not define any 'am' / 'pm' tokens. In this case, wxStrftime would
955 // assert, even though it is a perfectly legal use.
956 if ( am )
957 {
958 if (wxStrftime(buffer, sizeof(buffer)/sizeof(wxChar), _T("%p"), &tm) > 0)
959 *am = wxString(buffer);
960 else
961 *am = wxString();
962 }
963 if ( pm )
964 {
965 tm.tm_hour = 13;
966 if (wxStrftime(buffer, sizeof(buffer)/sizeof(wxChar), _T("%p"), &tm) > 0)
967 *pm = wxString(buffer);
968 else
969 *pm = wxString();
970 }
971 }
972
973 // ----------------------------------------------------------------------------
974 // Country stuff: date calculations depend on the country (DST, work days,
975 // ...), so we need to know which rules to follow.
976 // ----------------------------------------------------------------------------
977
978 /* static */
979 wxDateTime::Country wxDateTime::GetCountry()
980 {
981 // TODO use LOCALE_ICOUNTRY setting under Win32
982 #ifndef __WXWINCE__
983 if ( ms_country == Country_Unknown )
984 {
985 // try to guess from the time zone name
986 time_t t = time(NULL);
987 struct tm *tm = localtime(&t);
988
989 wxString tz = CallStrftime(_T("%Z"), tm);
990 if ( tz == _T("WET") || tz == _T("WEST") )
991 {
992 ms_country = UK;
993 }
994 else if ( tz == _T("CET") || tz == _T("CEST") )
995 {
996 ms_country = Country_EEC;
997 }
998 else if ( tz == _T("MSK") || tz == _T("MSD") )
999 {
1000 ms_country = Russia;
1001 }
1002 else if ( tz == _T("AST") || tz == _T("ADT") ||
1003 tz == _T("EST") || tz == _T("EDT") ||
1004 tz == _T("CST") || tz == _T("CDT") ||
1005 tz == _T("MST") || tz == _T("MDT") ||
1006 tz == _T("PST") || tz == _T("PDT") )
1007 {
1008 ms_country = USA;
1009 }
1010 else
1011 {
1012 // well, choose a default one
1013 ms_country = USA;
1014 }
1015 }
1016 #else
1017 ms_country = USA;
1018 #endif
1019
1020 return ms_country;
1021 }
1022
1023 /* static */
1024 void wxDateTime::SetCountry(wxDateTime::Country country)
1025 {
1026 ms_country = country;
1027 }
1028
1029 /* static */
1030 bool wxDateTime::IsWestEuropeanCountry(Country country)
1031 {
1032 if ( country == Country_Default )
1033 {
1034 country = GetCountry();
1035 }
1036
1037 return (Country_WesternEurope_Start <= country) &&
1038 (country <= Country_WesternEurope_End);
1039 }
1040
1041 // ----------------------------------------------------------------------------
1042 // DST calculations: we use 3 different rules for the West European countries,
1043 // USA and for the rest of the world. This is undoubtedly false for many
1044 // countries, but I lack the necessary info (and the time to gather it),
1045 // please add the other rules here!
1046 // ----------------------------------------------------------------------------
1047
1048 /* static */
1049 bool wxDateTime::IsDSTApplicable(int year, Country country)
1050 {
1051 if ( year == Inv_Year )
1052 {
1053 // take the current year if none given
1054 year = GetCurrentYear();
1055 }
1056
1057 if ( country == Country_Default )
1058 {
1059 country = GetCountry();
1060 }
1061
1062 switch ( country )
1063 {
1064 case USA:
1065 case UK:
1066 // DST was first observed in the US and UK during WWI, reused
1067 // during WWII and used again since 1966
1068 return year >= 1966 ||
1069 (year >= 1942 && year <= 1945) ||
1070 (year == 1918 || year == 1919);
1071
1072 default:
1073 // assume that it started after WWII
1074 return year > 1950;
1075 }
1076 }
1077
1078 /* static */
1079 wxDateTime wxDateTime::GetBeginDST(int year, Country country)
1080 {
1081 if ( year == Inv_Year )
1082 {
1083 // take the current year if none given
1084 year = GetCurrentYear();
1085 }
1086
1087 if ( country == Country_Default )
1088 {
1089 country = GetCountry();
1090 }
1091
1092 if ( !IsDSTApplicable(year, country) )
1093 {
1094 return wxInvalidDateTime;
1095 }
1096
1097 wxDateTime dt;
1098
1099 if ( IsWestEuropeanCountry(country) || (country == Russia) )
1100 {
1101 // DST begins at 1 a.m. GMT on the last Sunday of March
1102 if ( !dt.SetToLastWeekDay(Sun, Mar, year) )
1103 {
1104 // weird...
1105 wxFAIL_MSG( _T("no last Sunday in March?") );
1106 }
1107
1108 dt += wxTimeSpan::Hours(1);
1109
1110 // disable DST tests because it could result in an infinite recursion!
1111 dt.MakeGMT(true);
1112 }
1113 else switch ( country )
1114 {
1115 case USA:
1116 switch ( year )
1117 {
1118 case 1918:
1119 case 1919:
1120 // don't know for sure - assume it was in effect all year
1121
1122 case 1943:
1123 case 1944:
1124 case 1945:
1125 dt.Set(1, Jan, year);
1126 break;
1127
1128 case 1942:
1129 // DST was installed Feb 2, 1942 by the Congress
1130 dt.Set(2, Feb, year);
1131 break;
1132
1133 // Oil embargo changed the DST period in the US
1134 case 1974:
1135 dt.Set(6, Jan, 1974);
1136 break;
1137
1138 case 1975:
1139 dt.Set(23, Feb, 1975);
1140 break;
1141
1142 default:
1143 // before 1986, DST begun on the last Sunday of April, but
1144 // in 1986 Reagan changed it to begin at 2 a.m. of the
1145 // first Sunday in April
1146 if ( year < 1986 )
1147 {
1148 if ( !dt.SetToLastWeekDay(Sun, Apr, year) )
1149 {
1150 // weird...
1151 wxFAIL_MSG( _T("no first Sunday in April?") );
1152 }
1153 }
1154 else
1155 {
1156 if ( !dt.SetToWeekDay(Sun, 1, Apr, year) )
1157 {
1158 // weird...
1159 wxFAIL_MSG( _T("no first Sunday in April?") );
1160 }
1161 }
1162
1163 dt += wxTimeSpan::Hours(2);
1164
1165 // TODO what about timezone??
1166 }
1167
1168 break;
1169
1170 default:
1171 // assume Mar 30 as the start of the DST for the rest of the world
1172 // - totally bogus, of course
1173 dt.Set(30, Mar, year);
1174 }
1175
1176 return dt;
1177 }
1178
1179 /* static */
1180 wxDateTime wxDateTime::GetEndDST(int year, Country country)
1181 {
1182 if ( year == Inv_Year )
1183 {
1184 // take the current year if none given
1185 year = GetCurrentYear();
1186 }
1187
1188 if ( country == Country_Default )
1189 {
1190 country = GetCountry();
1191 }
1192
1193 if ( !IsDSTApplicable(year, country) )
1194 {
1195 return wxInvalidDateTime;
1196 }
1197
1198 wxDateTime dt;
1199
1200 if ( IsWestEuropeanCountry(country) || (country == Russia) )
1201 {
1202 // DST ends at 1 a.m. GMT on the last Sunday of October
1203 if ( !dt.SetToLastWeekDay(Sun, Oct, year) )
1204 {
1205 // weirder and weirder...
1206 wxFAIL_MSG( _T("no last Sunday in October?") );
1207 }
1208
1209 dt += wxTimeSpan::Hours(1);
1210
1211 // disable DST tests because it could result in an infinite recursion!
1212 dt.MakeGMT(true);
1213 }
1214 else switch ( country )
1215 {
1216 case USA:
1217 switch ( year )
1218 {
1219 case 1918:
1220 case 1919:
1221 // don't know for sure - assume it was in effect all year
1222
1223 case 1943:
1224 case 1944:
1225 dt.Set(31, Dec, year);
1226 break;
1227
1228 case 1945:
1229 // the time was reset after the end of the WWII
1230 dt.Set(30, Sep, year);
1231 break;
1232
1233 default:
1234 // DST ends at 2 a.m. on the last Sunday of October
1235 if ( !dt.SetToLastWeekDay(Sun, Oct, year) )
1236 {
1237 // weirder and weirder...
1238 wxFAIL_MSG( _T("no last Sunday in October?") );
1239 }
1240
1241 dt += wxTimeSpan::Hours(2);
1242
1243 // TODO what about timezone??
1244 }
1245 break;
1246
1247 default:
1248 // assume October 26th as the end of the DST - totally bogus too
1249 dt.Set(26, Oct, year);
1250 }
1251
1252 return dt;
1253 }
1254
1255 // ----------------------------------------------------------------------------
1256 // constructors and assignment operators
1257 // ----------------------------------------------------------------------------
1258
1259 // return the current time with ms precision
1260 /* static */ wxDateTime wxDateTime::UNow()
1261 {
1262 return wxDateTime(wxGetLocalTimeMillis());
1263 }
1264
1265 // the values in the tm structure contain the local time
1266 wxDateTime& wxDateTime::Set(const struct tm& tm)
1267 {
1268 struct tm tm2(tm);
1269 time_t timet = mktime(&tm2);
1270
1271 if ( timet == (time_t)-1 )
1272 {
1273 // mktime() rather unintuitively fails for Jan 1, 1970 if the hour is
1274 // less than timezone - try to make it work for this case
1275 if ( tm2.tm_year == 70 && tm2.tm_mon == 0 && tm2.tm_mday == 1 )
1276 {
1277 return Set((time_t)(
1278 GetTimeZone() +
1279 tm2.tm_hour * MIN_PER_HOUR * SEC_PER_MIN +
1280 tm2.tm_min * SEC_PER_MIN +
1281 tm2.tm_sec));
1282 }
1283
1284 wxFAIL_MSG( _T("mktime() failed") );
1285
1286 *this = wxInvalidDateTime;
1287
1288 return *this;
1289 }
1290 else
1291 {
1292 return Set(timet);
1293 }
1294 }
1295
1296 wxDateTime& wxDateTime::Set(wxDateTime_t hour,
1297 wxDateTime_t minute,
1298 wxDateTime_t second,
1299 wxDateTime_t millisec)
1300 {
1301 // we allow seconds to be 61 to account for the leap seconds, even if we
1302 // don't use them really
1303 wxDATETIME_CHECK( hour < 24 &&
1304 second < 62 &&
1305 minute < 60 &&
1306 millisec < 1000,
1307 _T("Invalid time in wxDateTime::Set()") );
1308
1309 // get the current date from system
1310 struct tm *tm = GetTmNow();
1311
1312 wxDATETIME_CHECK( tm, _T("localtime() failed") );
1313
1314 // make a copy so it isn't clobbered by the call to mktime() below
1315 struct tm tm1(*tm);
1316
1317 // adjust the time
1318 tm1.tm_hour = hour;
1319 tm1.tm_min = minute;
1320 tm1.tm_sec = second;
1321
1322 // and the DST in case it changes on this date
1323 struct tm tm2(tm1);
1324 mktime(&tm2);
1325 if ( tm2.tm_isdst != tm1.tm_isdst )
1326 tm1.tm_isdst = tm2.tm_isdst;
1327
1328 (void)Set(tm1);
1329
1330 // and finally adjust milliseconds
1331 return SetMillisecond(millisec);
1332 }
1333
1334 wxDateTime& wxDateTime::Set(wxDateTime_t day,
1335 Month month,
1336 int year,
1337 wxDateTime_t hour,
1338 wxDateTime_t minute,
1339 wxDateTime_t second,
1340 wxDateTime_t millisec)
1341 {
1342 wxDATETIME_CHECK( hour < 24 &&
1343 second < 62 &&
1344 minute < 60 &&
1345 millisec < 1000,
1346 _T("Invalid time in wxDateTime::Set()") );
1347
1348 ReplaceDefaultYearMonthWithCurrent(&year, &month);
1349
1350 wxDATETIME_CHECK( (0 < day) && (day <= GetNumberOfDays(month, year)),
1351 _T("Invalid date in wxDateTime::Set()") );
1352
1353 // the range of time_t type (inclusive)
1354 static const int yearMinInRange = 1970;
1355 static const int yearMaxInRange = 2037;
1356
1357 // test only the year instead of testing for the exact end of the Unix
1358 // time_t range - it doesn't bring anything to do more precise checks
1359 if ( year >= yearMinInRange && year <= yearMaxInRange )
1360 {
1361 // use the standard library version if the date is in range - this is
1362 // probably more efficient than our code
1363 struct tm tm;
1364 tm.tm_year = year - 1900;
1365 tm.tm_mon = month;
1366 tm.tm_mday = day;
1367 tm.tm_hour = hour;
1368 tm.tm_min = minute;
1369 tm.tm_sec = second;
1370 tm.tm_isdst = -1; // mktime() will guess it
1371
1372 (void)Set(tm);
1373
1374 // and finally adjust milliseconds
1375 if (IsValid())
1376 SetMillisecond(millisec);
1377
1378 return *this;
1379 }
1380 else
1381 {
1382 // do time calculations ourselves: we want to calculate the number of
1383 // milliseconds between the given date and the epoch
1384
1385 // get the JDN for the midnight of this day
1386 m_time = GetTruncatedJDN(day, month, year);
1387 m_time -= EPOCH_JDN;
1388 m_time *= SECONDS_PER_DAY * TIME_T_FACTOR;
1389
1390 // JDN corresponds to GMT, we take localtime
1391 Add(wxTimeSpan(hour, minute, second + GetTimeZone(), millisec));
1392 }
1393
1394 return *this;
1395 }
1396
1397 wxDateTime& wxDateTime::Set(double jdn)
1398 {
1399 // so that m_time will be 0 for the midnight of Jan 1, 1970 which is jdn
1400 // EPOCH_JDN + 0.5
1401 jdn -= EPOCH_JDN + 0.5;
1402
1403 jdn *= MILLISECONDS_PER_DAY;
1404
1405 m_time.Assign(jdn);
1406
1407 // JDNs always suppose an UTC date, so bring it back to local time zone
1408 // (also see GetJulianDayNumber() implementation)
1409 long tzDiff = GetTimeZone();
1410 if ( IsDST() == 1 )
1411 {
1412 // FIXME: again, we suppose that DST is always one hour
1413 tzDiff -= 3600;
1414 }
1415
1416 m_time += tzDiff*1000; // tzDiff is in seconds
1417
1418 return *this;
1419 }
1420
1421 wxDateTime& wxDateTime::ResetTime()
1422 {
1423 Tm tm = GetTm();
1424
1425 if ( tm.hour || tm.min || tm.sec || tm.msec )
1426 {
1427 tm.msec =
1428 tm.sec =
1429 tm.min =
1430 tm.hour = 0;
1431
1432 Set(tm);
1433 }
1434
1435 return *this;
1436 }
1437
1438 // ----------------------------------------------------------------------------
1439 // DOS Date and Time Format functions
1440 // ----------------------------------------------------------------------------
1441 // the dos date and time value is an unsigned 32 bit value in the format:
1442 // YYYYYYYMMMMDDDDDhhhhhmmmmmmsssss
1443 //
1444 // Y = year offset from 1980 (0-127)
1445 // M = month (1-12)
1446 // D = day of month (1-31)
1447 // h = hour (0-23)
1448 // m = minute (0-59)
1449 // s = bisecond (0-29) each bisecond indicates two seconds
1450 // ----------------------------------------------------------------------------
1451
1452 wxDateTime& wxDateTime::SetFromDOS(unsigned long ddt)
1453 {
1454 struct tm tm;
1455 InitTm(tm);
1456
1457 long year = ddt & 0xFE000000;
1458 year >>= 25;
1459 year += 80;
1460 tm.tm_year = year;
1461
1462 long month = ddt & 0x1E00000;
1463 month >>= 21;
1464 month -= 1;
1465 tm.tm_mon = month;
1466
1467 long day = ddt & 0x1F0000;
1468 day >>= 16;
1469 tm.tm_mday = day;
1470
1471 long hour = ddt & 0xF800;
1472 hour >>= 11;
1473 tm.tm_hour = hour;
1474
1475 long minute = ddt & 0x7E0;
1476 minute >>= 5;
1477 tm.tm_min = minute;
1478
1479 long second = ddt & 0x1F;
1480 tm.tm_sec = second * 2;
1481
1482 return Set(mktime(&tm));
1483 }
1484
1485 unsigned long wxDateTime::GetAsDOS() const
1486 {
1487 unsigned long ddt;
1488 time_t ticks = GetTicks();
1489 struct tm *tm = localtime(&ticks);
1490
1491 long year = tm->tm_year;
1492 year -= 80;
1493 year <<= 25;
1494
1495 long month = tm->tm_mon;
1496 month += 1;
1497 month <<= 21;
1498
1499 long day = tm->tm_mday;
1500 day <<= 16;
1501
1502 long hour = tm->tm_hour;
1503 hour <<= 11;
1504
1505 long minute = tm->tm_min;
1506 minute <<= 5;
1507
1508 long second = tm->tm_sec;
1509 second /= 2;
1510
1511 ddt = year | month | day | hour | minute | second;
1512 return ddt;
1513 }
1514
1515 // ----------------------------------------------------------------------------
1516 // time_t <-> broken down time conversions
1517 // ----------------------------------------------------------------------------
1518
1519 wxDateTime::Tm wxDateTime::GetTm(const TimeZone& tz) const
1520 {
1521 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1522
1523 time_t time = GetTicks();
1524 if ( time != (time_t)-1 )
1525 {
1526 // use C RTL functions
1527 tm *tm;
1528 if ( tz.GetOffset() == -GetTimeZone() )
1529 {
1530 // we are working with local time
1531 tm = localtime(&time);
1532
1533 // should never happen
1534 wxCHECK_MSG( tm, Tm(), _T("localtime() failed") );
1535 }
1536 else
1537 {
1538 time += (time_t)tz.GetOffset();
1539 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
1540 int time2 = (int) time;
1541 if ( time2 >= 0 )
1542 #else
1543 if ( time >= 0 )
1544 #endif
1545 {
1546 tm = gmtime(&time);
1547
1548 // should never happen
1549 wxCHECK_MSG( tm, Tm(), _T("gmtime() failed") );
1550 }
1551 else
1552 {
1553 tm = (struct tm *)NULL;
1554 }
1555 }
1556
1557 if ( tm )
1558 {
1559 // adjust the milliseconds
1560 Tm tm2(*tm, tz);
1561 long timeOnly = (m_time % MILLISECONDS_PER_DAY).ToLong();
1562 tm2.msec = (wxDateTime_t)(timeOnly % 1000);
1563 return tm2;
1564 }
1565 //else: use generic code below
1566 }
1567
1568 // remember the time and do the calculations with the date only - this
1569 // eliminates rounding errors of the floating point arithmetics
1570
1571 wxLongLong timeMidnight = m_time + tz.GetOffset() * 1000;
1572
1573 long timeOnly = (timeMidnight % MILLISECONDS_PER_DAY).ToLong();
1574
1575 // we want to always have positive time and timeMidnight to be really
1576 // the midnight before it
1577 if ( timeOnly < 0 )
1578 {
1579 timeOnly = MILLISECONDS_PER_DAY + timeOnly;
1580 }
1581
1582 timeMidnight -= timeOnly;
1583
1584 // calculate the Gregorian date from JDN for the midnight of our date:
1585 // this will yield day, month (in 1..12 range) and year
1586
1587 // actually, this is the JDN for the noon of the previous day
1588 long jdn = (timeMidnight / MILLISECONDS_PER_DAY).ToLong() + EPOCH_JDN;
1589
1590 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
1591
1592 wxASSERT_MSG( jdn > -2, _T("JDN out of range") );
1593
1594 // calculate the century
1595 long temp = (jdn + JDN_OFFSET) * 4 - 1;
1596 long century = temp / DAYS_PER_400_YEARS;
1597
1598 // then the year and day of year (1 <= dayOfYear <= 366)
1599 temp = ((temp % DAYS_PER_400_YEARS) / 4) * 4 + 3;
1600 long year = (century * 100) + (temp / DAYS_PER_4_YEARS);
1601 long dayOfYear = (temp % DAYS_PER_4_YEARS) / 4 + 1;
1602
1603 // and finally the month and day of the month
1604 temp = dayOfYear * 5 - 3;
1605 long month = temp / DAYS_PER_5_MONTHS;
1606 long day = (temp % DAYS_PER_5_MONTHS) / 5 + 1;
1607
1608 // month is counted from March - convert to normal
1609 if ( month < 10 )
1610 {
1611 month += 3;
1612 }
1613 else
1614 {
1615 year += 1;
1616 month -= 9;
1617 }
1618
1619 // year is offset by 4800
1620 year -= 4800;
1621
1622 // check that the algorithm gave us something reasonable
1623 wxASSERT_MSG( (0 < month) && (month <= 12), _T("invalid month") );
1624 wxASSERT_MSG( (1 <= day) && (day < 32), _T("invalid day") );
1625
1626 // construct Tm from these values
1627 Tm tm;
1628 tm.year = (int)year;
1629 tm.mon = (Month)(month - 1); // algorithm yields 1 for January, not 0
1630 tm.mday = (wxDateTime_t)day;
1631 tm.msec = (wxDateTime_t)(timeOnly % 1000);
1632 timeOnly -= tm.msec;
1633 timeOnly /= 1000; // now we have time in seconds
1634
1635 tm.sec = (wxDateTime_t)(timeOnly % 60);
1636 timeOnly -= tm.sec;
1637 timeOnly /= 60; // now we have time in minutes
1638
1639 tm.min = (wxDateTime_t)(timeOnly % 60);
1640 timeOnly -= tm.min;
1641
1642 tm.hour = (wxDateTime_t)(timeOnly / 60);
1643
1644 return tm;
1645 }
1646
1647 wxDateTime& wxDateTime::SetYear(int year)
1648 {
1649 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1650
1651 Tm tm(GetTm());
1652 tm.year = year;
1653 Set(tm);
1654
1655 return *this;
1656 }
1657
1658 wxDateTime& wxDateTime::SetMonth(Month month)
1659 {
1660 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1661
1662 Tm tm(GetTm());
1663 tm.mon = month;
1664 Set(tm);
1665
1666 return *this;
1667 }
1668
1669 wxDateTime& wxDateTime::SetDay(wxDateTime_t mday)
1670 {
1671 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1672
1673 Tm tm(GetTm());
1674 tm.mday = mday;
1675 Set(tm);
1676
1677 return *this;
1678 }
1679
1680 wxDateTime& wxDateTime::SetHour(wxDateTime_t hour)
1681 {
1682 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1683
1684 Tm tm(GetTm());
1685 tm.hour = hour;
1686 Set(tm);
1687
1688 return *this;
1689 }
1690
1691 wxDateTime& wxDateTime::SetMinute(wxDateTime_t min)
1692 {
1693 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1694
1695 Tm tm(GetTm());
1696 tm.min = min;
1697 Set(tm);
1698
1699 return *this;
1700 }
1701
1702 wxDateTime& wxDateTime::SetSecond(wxDateTime_t sec)
1703 {
1704 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1705
1706 Tm tm(GetTm());
1707 tm.sec = sec;
1708 Set(tm);
1709
1710 return *this;
1711 }
1712
1713 wxDateTime& wxDateTime::SetMillisecond(wxDateTime_t millisecond)
1714 {
1715 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1716
1717 // we don't need to use GetTm() for this one
1718 m_time -= m_time % 1000l;
1719 m_time += millisecond;
1720
1721 return *this;
1722 }
1723
1724 // ----------------------------------------------------------------------------
1725 // wxDateTime arithmetics
1726 // ----------------------------------------------------------------------------
1727
1728 wxDateTime& wxDateTime::Add(const wxDateSpan& diff)
1729 {
1730 Tm tm(GetTm());
1731
1732 tm.year += diff.GetYears();
1733 tm.AddMonths(diff.GetMonths());
1734
1735 // check that the resulting date is valid
1736 if ( tm.mday > GetNumOfDaysInMonth(tm.year, tm.mon) )
1737 {
1738 // We suppose that when adding one month to Jan 31 we want to get Feb
1739 // 28 (or 29), i.e. adding a month to the last day of the month should
1740 // give the last day of the next month which is quite logical.
1741 //
1742 // Unfortunately, there is no logic way to understand what should
1743 // Jan 30 + 1 month be - Feb 28 too or Feb 27 (assuming non leap year)?
1744 // We make it Feb 28 (last day too), but it is highly questionable.
1745 tm.mday = GetNumOfDaysInMonth(tm.year, tm.mon);
1746 }
1747
1748 tm.AddDays(diff.GetTotalDays());
1749
1750 Set(tm);
1751
1752 wxASSERT_MSG( IsSameTime(tm),
1753 _T("Add(wxDateSpan) shouldn't modify time") );
1754
1755 return *this;
1756 }
1757
1758 // ----------------------------------------------------------------------------
1759 // Weekday and monthday stuff
1760 // ----------------------------------------------------------------------------
1761
1762 // convert Sun, Mon, ..., Sat into 6, 0, ..., 5
1763 static inline int ConvertWeekDayToMondayBase(int wd)
1764 {
1765 return wd == wxDateTime::Sun ? 6 : wd - 1;
1766 }
1767
1768 /* static */
1769 wxDateTime
1770 wxDateTime::SetToWeekOfYear(int year, wxDateTime_t numWeek, WeekDay wd)
1771 {
1772 wxASSERT_MSG( numWeek > 0,
1773 _T("invalid week number: weeks are counted from 1") );
1774
1775 // Jan 4 always lies in the 1st week of the year
1776 wxDateTime dt(4, Jan, year);
1777 dt.SetToWeekDayInSameWeek(wd);
1778 dt += wxDateSpan::Weeks(numWeek - 1);
1779
1780 return dt;
1781 }
1782
1783 // use a separate function to avoid warnings about using deprecated
1784 // SetToTheWeek in GetWeek below
1785 static wxDateTime
1786 SetToTheWeek(int year,
1787 wxDateTime::wxDateTime_t numWeek,
1788 wxDateTime::WeekDay weekday,
1789 wxDateTime::WeekFlags flags)
1790 {
1791 // Jan 4 always lies in the 1st week of the year
1792 wxDateTime dt(4, wxDateTime::Jan, year);
1793 dt.SetToWeekDayInSameWeek(weekday, flags);
1794 dt += wxDateSpan::Weeks(numWeek - 1);
1795
1796 return dt;
1797 }
1798
1799 bool wxDateTime::SetToTheWeek(wxDateTime_t numWeek,
1800 WeekDay weekday,
1801 WeekFlags flags)
1802 {
1803 int year = GetYear();
1804 *this = ::SetToTheWeek(year, numWeek, weekday, flags);
1805 if ( GetYear() != year )
1806 {
1807 // oops... numWeek was too big
1808 return false;
1809 }
1810
1811 return true;
1812 }
1813
1814 wxDateTime wxDateTime::GetWeek(wxDateTime_t numWeek,
1815 WeekDay weekday,
1816 WeekFlags flags) const
1817 {
1818 return ::SetToTheWeek(GetYear(), numWeek, weekday, flags);
1819 }
1820
1821 wxDateTime& wxDateTime::SetToLastMonthDay(Month month,
1822 int year)
1823 {
1824 // take the current month/year if none specified
1825 if ( year == Inv_Year )
1826 year = GetYear();
1827 if ( month == Inv_Month )
1828 month = GetMonth();
1829
1830 return Set(GetNumOfDaysInMonth(year, month), month, year);
1831 }
1832
1833 wxDateTime& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday, WeekFlags flags)
1834 {
1835 wxDATETIME_CHECK( weekday != Inv_WeekDay, _T("invalid weekday") );
1836
1837 int wdayDst = weekday,
1838 wdayThis = GetWeekDay();
1839 if ( wdayDst == wdayThis )
1840 {
1841 // nothing to do
1842 return *this;
1843 }
1844
1845 if ( flags == Default_First )
1846 {
1847 flags = GetCountry() == USA ? Sunday_First : Monday_First;
1848 }
1849
1850 // the logic below based on comparing weekday and wdayThis works if Sun (0)
1851 // is the first day in the week, but breaks down for Monday_First case so
1852 // we adjust the week days in this case
1853 if ( flags == Monday_First )
1854 {
1855 if ( wdayThis == Sun )
1856 wdayThis += 7;
1857 if ( wdayDst == Sun )
1858 wdayDst += 7;
1859 }
1860 //else: Sunday_First, nothing to do
1861
1862 // go forward or back in time to the day we want
1863 if ( wdayDst < wdayThis )
1864 {
1865 return Subtract(wxDateSpan::Days(wdayThis - wdayDst));
1866 }
1867 else // weekday > wdayThis
1868 {
1869 return Add(wxDateSpan::Days(wdayDst - wdayThis));
1870 }
1871 }
1872
1873 wxDateTime& wxDateTime::SetToNextWeekDay(WeekDay weekday)
1874 {
1875 wxDATETIME_CHECK( weekday != Inv_WeekDay, _T("invalid weekday") );
1876
1877 int diff;
1878 WeekDay wdayThis = GetWeekDay();
1879 if ( weekday == wdayThis )
1880 {
1881 // nothing to do
1882 return *this;
1883 }
1884 else if ( weekday < wdayThis )
1885 {
1886 // need to advance a week
1887 diff = 7 - (wdayThis - weekday);
1888 }
1889 else // weekday > wdayThis
1890 {
1891 diff = weekday - wdayThis;
1892 }
1893
1894 return Add(wxDateSpan::Days(diff));
1895 }
1896
1897 wxDateTime& wxDateTime::SetToPrevWeekDay(WeekDay weekday)
1898 {
1899 wxDATETIME_CHECK( weekday != Inv_WeekDay, _T("invalid weekday") );
1900
1901 int diff;
1902 WeekDay wdayThis = GetWeekDay();
1903 if ( weekday == wdayThis )
1904 {
1905 // nothing to do
1906 return *this;
1907 }
1908 else if ( weekday > wdayThis )
1909 {
1910 // need to go to previous week
1911 diff = 7 - (weekday - wdayThis);
1912 }
1913 else // weekday < wdayThis
1914 {
1915 diff = wdayThis - weekday;
1916 }
1917
1918 return Subtract(wxDateSpan::Days(diff));
1919 }
1920
1921 bool wxDateTime::SetToWeekDay(WeekDay weekday,
1922 int n,
1923 Month month,
1924 int year)
1925 {
1926 wxCHECK_MSG( weekday != Inv_WeekDay, false, _T("invalid weekday") );
1927
1928 // we don't check explicitly that -5 <= n <= 5 because we will return false
1929 // anyhow in such case - but may be should still give an assert for it?
1930
1931 // take the current month/year if none specified
1932 ReplaceDefaultYearMonthWithCurrent(&year, &month);
1933
1934 wxDateTime dt;
1935
1936 // TODO this probably could be optimised somehow...
1937
1938 if ( n > 0 )
1939 {
1940 // get the first day of the month
1941 dt.Set(1, month, year);
1942
1943 // get its wday
1944 WeekDay wdayFirst = dt.GetWeekDay();
1945
1946 // go to the first weekday of the month
1947 int diff = weekday - wdayFirst;
1948 if ( diff < 0 )
1949 diff += 7;
1950
1951 // add advance n-1 weeks more
1952 diff += 7*(n - 1);
1953
1954 dt += wxDateSpan::Days(diff);
1955 }
1956 else // count from the end of the month
1957 {
1958 // get the last day of the month
1959 dt.SetToLastMonthDay(month, year);
1960
1961 // get its wday
1962 WeekDay wdayLast = dt.GetWeekDay();
1963
1964 // go to the last weekday of the month
1965 int diff = wdayLast - weekday;
1966 if ( diff < 0 )
1967 diff += 7;
1968
1969 // and rewind n-1 weeks from there
1970 diff += 7*(-n - 1);
1971
1972 dt -= wxDateSpan::Days(diff);
1973 }
1974
1975 // check that it is still in the same month
1976 if ( dt.GetMonth() == month )
1977 {
1978 *this = dt;
1979
1980 return true;
1981 }
1982 else
1983 {
1984 // no such day in this month
1985 return false;
1986 }
1987 }
1988
1989 static inline
1990 wxDateTime::wxDateTime_t GetDayOfYearFromTm(const wxDateTime::Tm& tm)
1991 {
1992 return (wxDateTime::wxDateTime_t)(gs_cumulatedDays[wxDateTime::IsLeapYear(tm.year)][tm.mon] + tm.mday);
1993 }
1994
1995 wxDateTime::wxDateTime_t wxDateTime::GetDayOfYear(const TimeZone& tz) const
1996 {
1997 return GetDayOfYearFromTm(GetTm(tz));
1998 }
1999
2000 wxDateTime::wxDateTime_t
2001 wxDateTime::GetWeekOfYear(wxDateTime::WeekFlags flags, const TimeZone& tz) const
2002 {
2003 if ( flags == Default_First )
2004 {
2005 flags = GetCountry() == USA ? Sunday_First : Monday_First;
2006 }
2007
2008 Tm tm(GetTm(tz));
2009 wxDateTime_t nDayInYear = GetDayOfYearFromTm(tm);
2010
2011 int wdTarget = GetWeekDay(tz);
2012 int wdYearStart = wxDateTime(1, Jan, GetYear()).GetWeekDay();
2013 int week;
2014 if ( flags == Sunday_First )
2015 {
2016 // FIXME: First week is not calculated correctly.
2017 week = (nDayInYear - wdTarget + 7) / 7;
2018 if ( wdYearStart == Wed || wdYearStart == Thu )
2019 week++;
2020 }
2021 else // week starts with monday
2022 {
2023 // adjust the weekdays to non-US style.
2024 wdYearStart = ConvertWeekDayToMondayBase(wdYearStart);
2025 wdTarget = ConvertWeekDayToMondayBase(wdTarget);
2026
2027 // quoting from http://www.cl.cam.ac.uk/~mgk25/iso-time.html:
2028 //
2029 // Week 01 of a year is per definition the first week that has the
2030 // Thursday in this year, which is equivalent to the week that
2031 // contains the fourth day of January. In other words, the first
2032 // week of a new year is the week that has the majority of its
2033 // days in the new year. Week 01 might also contain days from the
2034 // previous year and the week before week 01 of a year is the last
2035 // week (52 or 53) of the previous year even if it contains days
2036 // from the new year. A week starts with Monday (day 1) and ends
2037 // with Sunday (day 7).
2038 //
2039
2040 // if Jan 1 is Thursday or less, it is in the first week of this year
2041 if ( wdYearStart < 4 )
2042 {
2043 // count the number of entire weeks between Jan 1 and this date
2044 week = (nDayInYear + wdYearStart + 6 - wdTarget)/7;
2045
2046 // be careful to check for overflow in the next year
2047 if ( week == 53 && tm.mday - wdTarget > 28 )
2048 week = 1;
2049 }
2050 else // Jan 1 is in the last week of the previous year
2051 {
2052 // check if we happen to be at the last week of previous year:
2053 if ( tm.mon == Jan && tm.mday < 8 - wdYearStart )
2054 week = wxDateTime(31, Dec, GetYear()-1).GetWeekOfYear();
2055 else
2056 week = (nDayInYear + wdYearStart - 1 - wdTarget)/7;
2057 }
2058 }
2059
2060 return (wxDateTime::wxDateTime_t)week;
2061 }
2062
2063 wxDateTime::wxDateTime_t wxDateTime::GetWeekOfMonth(wxDateTime::WeekFlags flags,
2064 const TimeZone& tz) const
2065 {
2066 Tm tm = GetTm(tz);
2067 wxDateTime dtMonthStart = wxDateTime(1, tm.mon, tm.year);
2068 int nWeek = GetWeekOfYear(flags) - dtMonthStart.GetWeekOfYear(flags) + 1;
2069 if ( nWeek < 0 )
2070 {
2071 // this may happen for January when Jan, 1 is the last week of the
2072 // previous year
2073 nWeek += IsLeapYear(tm.year - 1) ? 53 : 52;
2074 }
2075
2076 return (wxDateTime::wxDateTime_t)nWeek;
2077 }
2078
2079 wxDateTime& wxDateTime::SetToYearDay(wxDateTime::wxDateTime_t yday)
2080 {
2081 int year = GetYear();
2082 wxDATETIME_CHECK( (0 < yday) && (yday <= GetNumberOfDays(year)),
2083 _T("invalid year day") );
2084
2085 bool isLeap = IsLeapYear(year);
2086 for ( Month mon = Jan; mon < Inv_Month; wxNextMonth(mon) )
2087 {
2088 // for Dec, we can't compare with gs_cumulatedDays[mon + 1], but we
2089 // don't need it neither - because of the CHECK above we know that
2090 // yday lies in December then
2091 if ( (mon == Dec) || (yday <= gs_cumulatedDays[isLeap][mon + 1]) )
2092 {
2093 Set((wxDateTime::wxDateTime_t)(yday - gs_cumulatedDays[isLeap][mon]), mon, year);
2094
2095 break;
2096 }
2097 }
2098
2099 return *this;
2100 }
2101
2102 // ----------------------------------------------------------------------------
2103 // Julian day number conversion and related stuff
2104 // ----------------------------------------------------------------------------
2105
2106 double wxDateTime::GetJulianDayNumber() const
2107 {
2108 // JDN are always expressed for the UTC dates
2109 Tm tm(ToTimezone(UTC).GetTm(UTC));
2110
2111 double result = GetTruncatedJDN(tm.mday, tm.mon, tm.year);
2112
2113 // add the part GetTruncatedJDN() neglected
2114 result += 0.5;
2115
2116 // and now add the time: 86400 sec = 1 JDN
2117 return result + ((double)(60*(60*tm.hour + tm.min) + tm.sec)) / 86400;
2118 }
2119
2120 double wxDateTime::GetRataDie() const
2121 {
2122 // March 1 of the year 0 is Rata Die day -306 and JDN 1721119.5
2123 return GetJulianDayNumber() - 1721119.5 - 306;
2124 }
2125
2126 // ----------------------------------------------------------------------------
2127 // timezone and DST stuff
2128 // ----------------------------------------------------------------------------
2129
2130 int wxDateTime::IsDST(wxDateTime::Country country) const
2131 {
2132 wxCHECK_MSG( country == Country_Default, -1,
2133 _T("country support not implemented") );
2134
2135 // use the C RTL for the dates in the standard range
2136 time_t timet = GetTicks();
2137 if ( timet != (time_t)-1 )
2138 {
2139 tm *tm = localtime(&timet);
2140
2141 wxCHECK_MSG( tm, -1, _T("localtime() failed") );
2142
2143 return tm->tm_isdst;
2144 }
2145 else
2146 {
2147 int year = GetYear();
2148
2149 if ( !IsDSTApplicable(year, country) )
2150 {
2151 // no DST time in this year in this country
2152 return -1;
2153 }
2154
2155 return IsBetween(GetBeginDST(year, country), GetEndDST(year, country));
2156 }
2157 }
2158
2159 wxDateTime& wxDateTime::MakeTimezone(const TimeZone& tz, bool noDST)
2160 {
2161 long secDiff = GetTimeZone() + tz.GetOffset();
2162
2163 // we need to know whether DST is or not in effect for this date unless
2164 // the test disabled by the caller
2165 if ( !noDST && (IsDST() == 1) )
2166 {
2167 // FIXME we assume that the DST is always shifted by 1 hour
2168 secDiff -= 3600;
2169 }
2170
2171 return Subtract(wxTimeSpan::Seconds(secDiff));
2172 }
2173
2174 // ----------------------------------------------------------------------------
2175 // wxDateTime to/from text representations
2176 // ----------------------------------------------------------------------------
2177
2178 wxString wxDateTime::Format(const wxChar *format, const TimeZone& tz) const
2179 {
2180 wxCHECK_MSG( format, wxEmptyString, _T("NULL format in wxDateTime::Format") );
2181
2182 // we have to use our own implementation if the date is out of range of
2183 // strftime() or if we use non standard specificators
2184 time_t time = GetTicks();
2185 if ( (time != (time_t)-1) && !wxStrstr(format, _T("%l")) )
2186 {
2187 // use strftime()
2188 tm *tm;
2189 if ( tz.GetOffset() == -GetTimeZone() )
2190 {
2191 // we are working with local time
2192 tm = localtime(&time);
2193
2194 // should never happen
2195 wxCHECK_MSG( tm, wxEmptyString, _T("localtime() failed") );
2196 }
2197 else
2198 {
2199 time += (int)tz.GetOffset();
2200
2201 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
2202 int time2 = (int) time;
2203 if ( time2 >= 0 )
2204 #else
2205 if ( time >= 0 )
2206 #endif
2207 {
2208 tm = gmtime(&time);
2209
2210 // should never happen
2211 wxCHECK_MSG( tm, wxEmptyString, _T("gmtime() failed") );
2212 }
2213 else
2214 {
2215 tm = (struct tm *)NULL;
2216 }
2217 }
2218 #ifndef __WXWINCE__
2219 //Windows CE doesn't support strftime or wcsftime, so we use the generic implementation
2220 if ( tm )
2221 {
2222 return CallStrftime(format, tm);
2223 }
2224 #endif
2225 //else: use generic code below
2226 }
2227
2228 // we only parse ANSI C format specifications here, no POSIX 2
2229 // complications, no GNU extensions but we do add support for a "%l" format
2230 // specifier allowing to get the number of milliseconds
2231 Tm tm = GetTm(tz);
2232
2233 // used for calls to strftime() when we only deal with time
2234 struct tm tmTimeOnly;
2235 tmTimeOnly.tm_hour = tm.hour;
2236 tmTimeOnly.tm_min = tm.min;
2237 tmTimeOnly.tm_sec = tm.sec;
2238 tmTimeOnly.tm_wday = 0;
2239 tmTimeOnly.tm_yday = 0;
2240 tmTimeOnly.tm_mday = 1; // any date will do
2241 tmTimeOnly.tm_mon = 0;
2242 tmTimeOnly.tm_year = 76;
2243 tmTimeOnly.tm_isdst = 0; // no DST, we adjust for tz ourselves
2244
2245 wxString tmp, res, fmt;
2246 for ( const wxChar *p = format; *p; p++ )
2247 {
2248 if ( *p != _T('%') )
2249 {
2250 // copy as is
2251 res += *p;
2252
2253 continue;
2254 }
2255
2256 // set the default format
2257 switch ( *++p )
2258 {
2259 case _T('Y'): // year has 4 digits
2260 fmt = _T("%04d");
2261 break;
2262
2263 case _T('j'): // day of year has 3 digits
2264 case _T('l'): // milliseconds have 3 digits
2265 fmt = _T("%03d");
2266 break;
2267
2268 case _T('w'): // week day as number has only one
2269 fmt = _T("%d");
2270 break;
2271
2272 default:
2273 // it's either another valid format specifier in which case
2274 // the format is "%02d" (for all the rest) or we have the
2275 // field width preceding the format in which case it will
2276 // override the default format anyhow
2277 fmt = _T("%02d");
2278 }
2279
2280 bool restart = true;
2281 while ( restart )
2282 {
2283 restart = false;
2284
2285 // start of the format specification
2286 switch ( *p )
2287 {
2288 case _T('a'): // a weekday name
2289 case _T('A'):
2290 // second parameter should be true for abbreviated names
2291 res += GetWeekDayName(tm.GetWeekDay(),
2292 *p == _T('a') ? Name_Abbr : Name_Full);
2293 break;
2294
2295 case _T('b'): // a month name
2296 case _T('B'):
2297 res += GetMonthName(tm.mon,
2298 *p == _T('b') ? Name_Abbr : Name_Full);
2299 break;
2300
2301 case _T('c'): // locale default date and time representation
2302 case _T('x'): // locale default date representation
2303 #ifndef __WXWINCE__
2304 //
2305 // the problem: there is no way to know what do these format
2306 // specifications correspond to for the current locale.
2307 //
2308 // the solution: use a hack and still use strftime(): first
2309 // find the YEAR which is a year in the strftime() range (1970
2310 // - 2038) whose Jan 1 falls on the same week day as the Jan 1
2311 // of the real year. Then make a copy of the format and
2312 // replace all occurences of YEAR in it with some unique
2313 // string not appearing anywhere else in it, then use
2314 // strftime() to format the date in year YEAR and then replace
2315 // YEAR back by the real year and the unique replacement
2316 // string back with YEAR. Notice that "all occurences of YEAR"
2317 // means all occurences of 4 digit as well as 2 digit form!
2318 //
2319 // the bugs: we assume that neither of %c nor %x contains any
2320 // fields which may change between the YEAR and real year. For
2321 // example, the week number (%U, %W) and the day number (%j)
2322 // will change if one of these years is leap and the other one
2323 // is not!
2324 {
2325 // find the YEAR: normally, for any year X, Jan 1 or the
2326 // year X + 28 is the same weekday as Jan 1 of X (because
2327 // the weekday advances by 1 for each normal X and by 2
2328 // for each leap X, hence by 5 every 4 years or by 35
2329 // which is 0 mod 7 every 28 years) but this rule breaks
2330 // down if there are years between X and Y which are
2331 // divisible by 4 but not leap (i.e. divisible by 100 but
2332 // not 400), hence the correction.
2333
2334 int yearReal = GetYear(tz);
2335 int mod28 = yearReal % 28;
2336
2337 // be careful to not go too far - we risk to leave the
2338 // supported range
2339 int year;
2340 if ( mod28 < 10 )
2341 {
2342 year = 1988 + mod28; // 1988 == 0 (mod 28)
2343 }
2344 else
2345 {
2346 year = 1970 + mod28 - 10; // 1970 == 10 (mod 28)
2347 }
2348
2349 int nCentury = year / 100,
2350 nCenturyReal = yearReal / 100;
2351
2352 // need to adjust for the years divisble by 400 which are
2353 // not leap but are counted like leap ones if we just take
2354 // the number of centuries in between for nLostWeekDays
2355 int nLostWeekDays = (nCentury - nCenturyReal) -
2356 (nCentury / 4 - nCenturyReal / 4);
2357
2358 // we have to gain back the "lost" weekdays: note that the
2359 // effect of this loop is to not do anything to
2360 // nLostWeekDays (which we won't use any more), but to
2361 // (indirectly) set the year correctly
2362 while ( (nLostWeekDays % 7) != 0 )
2363 {
2364 nLostWeekDays += year++ % 4 ? 1 : 2;
2365 }
2366
2367 // at any rate, we couldn't go further than 1988 + 9 + 28!
2368 wxASSERT_MSG( year < 2030,
2369 _T("logic error in wxDateTime::Format") );
2370
2371 wxString strYear, strYear2;
2372 strYear.Printf(_T("%d"), year);
2373 strYear2.Printf(_T("%d"), year % 100);
2374
2375 // find two strings not occuring in format (this is surely
2376 // not optimal way of doing it... improvements welcome!)
2377 wxString fmt = format;
2378 wxString replacement = (wxChar)-1;
2379 while ( fmt.Find(replacement) != wxNOT_FOUND )
2380 {
2381 replacement << (wxChar)-1;
2382 }
2383
2384 wxString replacement2 = (wxChar)-2;
2385 while ( fmt.Find(replacement) != wxNOT_FOUND )
2386 {
2387 replacement << (wxChar)-2;
2388 }
2389
2390 // replace all occurences of year with it
2391 bool wasReplaced = fmt.Replace(strYear, replacement) > 0;
2392 if ( !wasReplaced )
2393 wasReplaced = fmt.Replace(strYear2, replacement2) > 0;
2394
2395 // use strftime() to format the same date but in supported
2396 // year
2397 //
2398 // NB: we assume that strftime() doesn't check for the
2399 // date validity and will happily format the date
2400 // corresponding to Feb 29 of a non leap year (which
2401 // may happen if yearReal was leap and year is not)
2402 struct tm tmAdjusted;
2403 InitTm(tmAdjusted);
2404 tmAdjusted.tm_hour = tm.hour;
2405 tmAdjusted.tm_min = tm.min;
2406 tmAdjusted.tm_sec = tm.sec;
2407 tmAdjusted.tm_wday = tm.GetWeekDay();
2408 tmAdjusted.tm_yday = GetDayOfYear();
2409 tmAdjusted.tm_mday = tm.mday;
2410 tmAdjusted.tm_mon = tm.mon;
2411 tmAdjusted.tm_year = year - 1900;
2412 tmAdjusted.tm_isdst = 0; // no DST, already adjusted
2413 wxString str = CallStrftime(*p == _T('c') ? _T("%c")
2414 : _T("%x"),
2415 &tmAdjusted);
2416
2417 // now replace the occurence of 1999 with the real year
2418 wxString strYearReal, strYearReal2;
2419 strYearReal.Printf(_T("%04d"), yearReal);
2420 strYearReal2.Printf(_T("%02d"), yearReal % 100);
2421 str.Replace(strYear, strYearReal);
2422 str.Replace(strYear2, strYearReal2);
2423
2424 // and replace back all occurences of replacement string
2425 if ( wasReplaced )
2426 {
2427 str.Replace(replacement2, strYear2);
2428 str.Replace(replacement, strYear);
2429 }
2430
2431 res += str;
2432 }
2433 #else
2434 //Use "%m/%d/%y %H:%M:%S" format instead
2435 res += wxString::Format(wxT("%02d/%02d/%04d %02d:%02d:%02d"),
2436 tm.mon+1,tm.mday, tm.year, tm.hour, tm.min, tm.sec);
2437 #endif
2438 break;
2439
2440 case _T('d'): // day of a month (01-31)
2441 res += wxString::Format(fmt, tm.mday);
2442 break;
2443
2444 case _T('H'): // hour in 24h format (00-23)
2445 res += wxString::Format(fmt, tm.hour);
2446 break;
2447
2448 case _T('I'): // hour in 12h format (01-12)
2449 {
2450 // 24h -> 12h, 0h -> 12h too
2451 int hour12 = tm.hour > 12 ? tm.hour - 12
2452 : tm.hour ? tm.hour : 12;
2453 res += wxString::Format(fmt, hour12);
2454 }
2455 break;
2456
2457 case _T('j'): // day of the year
2458 res += wxString::Format(fmt, GetDayOfYear(tz));
2459 break;
2460
2461 case _T('l'): // milliseconds (NOT STANDARD)
2462 res += wxString::Format(fmt, GetMillisecond(tz));
2463 break;
2464
2465 case _T('m'): // month as a number (01-12)
2466 res += wxString::Format(fmt, tm.mon + 1);
2467 break;
2468
2469 case _T('M'): // minute as a decimal number (00-59)
2470 res += wxString::Format(fmt, tm.min);
2471 break;
2472
2473 case _T('p'): // AM or PM string
2474 #ifndef __WXWINCE__
2475 res += CallStrftime(_T("%p"), &tmTimeOnly);
2476 #else
2477 res += (tmTimeOnly.tm_hour > 12) ? wxT("pm") : wxT("am");
2478 #endif
2479 break;
2480
2481 case _T('S'): // second as a decimal number (00-61)
2482 res += wxString::Format(fmt, tm.sec);
2483 break;
2484
2485 case _T('U'): // week number in the year (Sunday 1st week day)
2486 res += wxString::Format(fmt, GetWeekOfYear(Sunday_First, tz));
2487 break;
2488
2489 case _T('W'): // week number in the year (Monday 1st week day)
2490 res += wxString::Format(fmt, GetWeekOfYear(Monday_First, tz));
2491 break;
2492
2493 case _T('w'): // weekday as a number (0-6), Sunday = 0
2494 res += wxString::Format(fmt, tm.GetWeekDay());
2495 break;
2496
2497 // case _T('x'): -- handled with "%c"
2498
2499 case _T('X'): // locale default time representation
2500 // just use strftime() to format the time for us
2501 #ifndef __WXWINCE__
2502 res += CallStrftime(_T("%X"), &tmTimeOnly);
2503 #else
2504 res += wxString::Format(wxT("%02d:%02d:%02d"),tm.hour, tm.min, tm.sec);
2505 #endif
2506 break;
2507
2508 case _T('y'): // year without century (00-99)
2509 res += wxString::Format(fmt, tm.year % 100);
2510 break;
2511
2512 case _T('Y'): // year with century
2513 res += wxString::Format(fmt, tm.year);
2514 break;
2515
2516 case _T('Z'): // timezone name
2517 #ifndef __WXWINCE__
2518 res += CallStrftime(_T("%Z"), &tmTimeOnly);
2519 #endif
2520 break;
2521
2522 default:
2523 // is it the format width?
2524 fmt.Empty();
2525 while ( *p == _T('-') || *p == _T('+') ||
2526 *p == _T(' ') || wxIsdigit(*p) )
2527 {
2528 fmt += *p;
2529 }
2530
2531 if ( !fmt.empty() )
2532 {
2533 // we've only got the flags and width so far in fmt
2534 fmt.Prepend(_T('%'));
2535 fmt.Append(_T('d'));
2536
2537 restart = true;
2538
2539 break;
2540 }
2541
2542 // no, it wasn't the width
2543 wxFAIL_MSG(_T("unknown format specificator"));
2544
2545 // fall through and just copy it nevertheless
2546
2547 case _T('%'): // a percent sign
2548 res += *p;
2549 break;
2550
2551 case 0: // the end of string
2552 wxFAIL_MSG(_T("missing format at the end of string"));
2553
2554 // just put the '%' which was the last char in format
2555 res += _T('%');
2556 break;
2557 }
2558 }
2559 }
2560
2561 return res;
2562 }
2563
2564 // this function parses a string in (strict) RFC 822 format: see the section 5
2565 // of the RFC for the detailed description, but briefly it's something of the
2566 // form "Sat, 18 Dec 1999 00:48:30 +0100"
2567 //
2568 // this function is "strict" by design - it must reject anything except true
2569 // RFC822 time specs.
2570 //
2571 // TODO a great candidate for using reg exps
2572 const wxChar *wxDateTime::ParseRfc822Date(const wxChar* date)
2573 {
2574 wxCHECK_MSG( date, (wxChar *)NULL, _T("NULL pointer in wxDateTime::Parse") );
2575
2576 const wxChar *p = date;
2577 const wxChar *comma = wxStrchr(p, _T(','));
2578 if ( comma )
2579 {
2580 // the part before comma is the weekday
2581
2582 // skip it for now - we don't use but might check that it really
2583 // corresponds to the specfied date
2584 p = comma + 1;
2585
2586 if ( *p != _T(' ') )
2587 {
2588 wxLogDebug(_T("no space after weekday in RFC822 time spec"));
2589
2590 return (wxChar *)NULL;
2591 }
2592
2593 p++; // skip space
2594 }
2595
2596 // the following 1 or 2 digits are the day number
2597 if ( !wxIsdigit(*p) )
2598 {
2599 wxLogDebug(_T("day number expected in RFC822 time spec, none found"));
2600
2601 return (wxChar *)NULL;
2602 }
2603
2604 wxDateTime_t day = (wxDateTime_t)(*p++ - _T('0'));
2605 if ( wxIsdigit(*p) )
2606 {
2607 day *= 10;
2608 day = (wxDateTime_t)(day + (*p++ - _T('0')));
2609 }
2610
2611 if ( *p++ != _T(' ') )
2612 {
2613 return (wxChar *)NULL;
2614 }
2615
2616 // the following 3 letters specify the month
2617 wxString monName(p, 3);
2618 Month mon;
2619 if ( monName == _T("Jan") )
2620 mon = Jan;
2621 else if ( monName == _T("Feb") )
2622 mon = Feb;
2623 else if ( monName == _T("Mar") )
2624 mon = Mar;
2625 else if ( monName == _T("Apr") )
2626 mon = Apr;
2627 else if ( monName == _T("May") )
2628 mon = May;
2629 else if ( monName == _T("Jun") )
2630 mon = Jun;
2631 else if ( monName == _T("Jul") )
2632 mon = Jul;
2633 else if ( monName == _T("Aug") )
2634 mon = Aug;
2635 else if ( monName == _T("Sep") )
2636 mon = Sep;
2637 else if ( monName == _T("Oct") )
2638 mon = Oct;
2639 else if ( monName == _T("Nov") )
2640 mon = Nov;
2641 else if ( monName == _T("Dec") )
2642 mon = Dec;
2643 else
2644 {
2645 wxLogDebug(_T("Invalid RFC 822 month name '%s'"), monName.c_str());
2646
2647 return (wxChar *)NULL;
2648 }
2649
2650 p += 3;
2651
2652 if ( *p++ != _T(' ') )
2653 {
2654 return (wxChar *)NULL;
2655 }
2656
2657 // next is the year
2658 if ( !wxIsdigit(*p) )
2659 {
2660 // no year?
2661 return (wxChar *)NULL;
2662 }
2663
2664 int year = *p++ - _T('0');
2665
2666 if ( !wxIsdigit(*p) )
2667 {
2668 // should have at least 2 digits in the year
2669 return (wxChar *)NULL;
2670 }
2671
2672 year *= 10;
2673 year += *p++ - _T('0');
2674
2675 // is it a 2 digit year (as per original RFC 822) or a 4 digit one?
2676 if ( wxIsdigit(*p) )
2677 {
2678 year *= 10;
2679 year += *p++ - _T('0');
2680
2681 if ( !wxIsdigit(*p) )
2682 {
2683 // no 3 digit years please
2684 return (wxChar *)NULL;
2685 }
2686
2687 year *= 10;
2688 year += *p++ - _T('0');
2689 }
2690
2691 if ( *p++ != _T(' ') )
2692 {
2693 return (wxChar *)NULL;
2694 }
2695
2696 // time is in the format hh:mm:ss and seconds are optional
2697 if ( !wxIsdigit(*p) )
2698 {
2699 return (wxChar *)NULL;
2700 }
2701
2702 wxDateTime_t hour = (wxDateTime_t)(*p++ - _T('0'));
2703
2704 if ( !wxIsdigit(*p) )
2705 {
2706 return (wxChar *)NULL;
2707 }
2708
2709 hour *= 10;
2710 hour = (wxDateTime_t)(hour + (*p++ - _T('0')));
2711
2712 if ( *p++ != _T(':') )
2713 {
2714 return (wxChar *)NULL;
2715 }
2716
2717 if ( !wxIsdigit(*p) )
2718 {
2719 return (wxChar *)NULL;
2720 }
2721
2722 wxDateTime_t min = (wxDateTime_t)(*p++ - _T('0'));
2723
2724 if ( !wxIsdigit(*p) )
2725 {
2726 return (wxChar *)NULL;
2727 }
2728
2729 min *= 10;
2730 min = (wxDateTime_t)(min + *p++ - _T('0'));
2731
2732 wxDateTime_t sec = 0;
2733 if ( *p++ == _T(':') )
2734 {
2735 if ( !wxIsdigit(*p) )
2736 {
2737 return (wxChar *)NULL;
2738 }
2739
2740 sec = (wxDateTime_t)(*p++ - _T('0'));
2741
2742 if ( !wxIsdigit(*p) )
2743 {
2744 return (wxChar *)NULL;
2745 }
2746
2747 sec *= 10;
2748 sec = (wxDateTime_t)(sec + *p++ - _T('0'));
2749 }
2750
2751 if ( *p++ != _T(' ') )
2752 {
2753 return (wxChar *)NULL;
2754 }
2755
2756 // and now the interesting part: the timezone
2757 int offset wxDUMMY_INITIALIZE(0);
2758 if ( *p == _T('-') || *p == _T('+') )
2759 {
2760 // the explicit offset given: it has the form of hhmm
2761 bool plus = *p++ == _T('+');
2762
2763 if ( !wxIsdigit(*p) || !wxIsdigit(*(p + 1)) )
2764 {
2765 return (wxChar *)NULL;
2766 }
2767
2768 // hours
2769 offset = 60*(10*(*p - _T('0')) + (*(p + 1) - _T('0')));
2770
2771 p += 2;
2772
2773 if ( !wxIsdigit(*p) || !wxIsdigit(*(p + 1)) )
2774 {
2775 return (wxChar *)NULL;
2776 }
2777
2778 // minutes
2779 offset += 10*(*p - _T('0')) + (*(p + 1) - _T('0'));
2780
2781 if ( !plus )
2782 {
2783 offset = -offset;
2784 }
2785
2786 p += 2;
2787 }
2788 else
2789 {
2790 // the symbolic timezone given: may be either military timezone or one
2791 // of standard abbreviations
2792 if ( !*(p + 1) )
2793 {
2794 // military: Z = UTC, J unused, A = -1, ..., Y = +12
2795 static const int offsets[26] =
2796 {
2797 //A B C D E F G H I J K L M
2798 -1, -2, -3, -4, -5, -6, -7, -8, -9, 0, -10, -11, -12,
2799 //N O P R Q S T U V W Z Y Z
2800 +1, +2, +3, +4, +5, +6, +7, +8, +9, +10, +11, +12, 0
2801 };
2802
2803 if ( *p < _T('A') || *p > _T('Z') || *p == _T('J') )
2804 {
2805 wxLogDebug(_T("Invalid militaty timezone '%c'"), *p);
2806
2807 return (wxChar *)NULL;
2808 }
2809
2810 offset = offsets[*p++ - _T('A')];
2811 }
2812 else
2813 {
2814 // abbreviation
2815 wxString tz = p;
2816 if ( tz == _T("UT") || tz == _T("UTC") || tz == _T("GMT") )
2817 offset = 0;
2818 else if ( tz == _T("AST") )
2819 offset = AST - GMT0;
2820 else if ( tz == _T("ADT") )
2821 offset = ADT - GMT0;
2822 else if ( tz == _T("EST") )
2823 offset = EST - GMT0;
2824 else if ( tz == _T("EDT") )
2825 offset = EDT - GMT0;
2826 else if ( tz == _T("CST") )
2827 offset = CST - GMT0;
2828 else if ( tz == _T("CDT") )
2829 offset = CDT - GMT0;
2830 else if ( tz == _T("MST") )
2831 offset = MST - GMT0;
2832 else if ( tz == _T("MDT") )
2833 offset = MDT - GMT0;
2834 else if ( tz == _T("PST") )
2835 offset = PST - GMT0;
2836 else if ( tz == _T("PDT") )
2837 offset = PDT - GMT0;
2838 else
2839 {
2840 wxLogDebug(_T("Unknown RFC 822 timezone '%s'"), p);
2841
2842 return (wxChar *)NULL;
2843 }
2844
2845 p += tz.length();
2846 }
2847
2848 // make it minutes
2849 offset *= 60;
2850 }
2851
2852 // the spec was correct
2853 Set(day, mon, year, hour, min, sec);
2854 MakeTimezone((wxDateTime_t)(60*offset));
2855
2856 return p;
2857 }
2858
2859 #ifdef __WINDOWS__
2860
2861 // returns the string containing strftime() format used for short dates in the
2862 // current locale or an empty string
2863 static wxString GetLocaleDateFormat()
2864 {
2865 wxString fmtWX;
2866
2867 // there is no setlocale() under Windows CE, so just always query the
2868 // system there
2869 #ifndef __WXWINCE__
2870 if ( strcmp(setlocale(LC_ALL, NULL), "C") != 0 )
2871 #endif
2872 {
2873 // The locale was programatically set to non-C. We assume that this was
2874 // done using wxLocale, in which case thread's current locale is also
2875 // set to correct LCID value and we can use GetLocaleInfo to determine
2876 // the correct formatting string:
2877 #ifdef __WXWINCE__
2878 LCID lcid = LOCALE_USER_DEFAULT;
2879 #else
2880 LCID lcid = GetThreadLocale();
2881 #endif
2882 // according to MSDN 80 chars is max allowed for short date format
2883 wxChar fmt[81];
2884 if ( ::GetLocaleInfo(lcid, LOCALE_SSHORTDATE, fmt, WXSIZEOF(fmt)) )
2885 {
2886 wxChar chLast = _T('\0');
2887 size_t lastCount = 0;
2888 for ( const wxChar *p = fmt; /* NUL handled inside */; p++ )
2889 {
2890 if ( *p == chLast )
2891 {
2892 lastCount++;
2893 continue;
2894 }
2895
2896 switch ( *p )
2897 {
2898 // these characters come in groups, start counting them
2899 case _T('d'):
2900 case _T('M'):
2901 case _T('y'):
2902 case _T('g'):
2903 chLast = *p;
2904 lastCount = 1;
2905 break;
2906
2907 default:
2908 // first deal with any special characters we have had
2909 if ( lastCount )
2910 {
2911 switch ( chLast )
2912 {
2913 case _T('d'):
2914 switch ( lastCount )
2915 {
2916 case 1: // d
2917 case 2: // dd
2918 // these two are the same as we
2919 // don't distinguish between 1 and
2920 // 2 digits for days
2921 fmtWX += _T("%d");
2922 break;
2923
2924 case 3: // ddd
2925 fmtWX += _T("%a");
2926 break;
2927
2928 case 4: // dddd
2929 fmtWX += _T("%A");
2930 break;
2931
2932 default:
2933 wxFAIL_MSG( _T("too many 'd's") );
2934 }
2935 break;
2936
2937 case _T('M'):
2938 switch ( lastCount )
2939 {
2940 case 1: // M
2941 case 2: // MM
2942 // as for 'd' and 'dd' above
2943 fmtWX += _T("%m");
2944 break;
2945
2946 case 3:
2947 fmtWX += _T("%b");
2948 break;
2949
2950 case 4:
2951 fmtWX += _T("%B");
2952 break;
2953
2954 default:
2955 wxFAIL_MSG( _T("too many 'M's") );
2956 }
2957 break;
2958
2959 case _T('y'):
2960 switch ( lastCount )
2961 {
2962 case 1: // y
2963 case 2: // yy
2964 fmtWX += _T("%y");
2965 break;
2966
2967 case 4: // yyyy
2968 fmtWX += _T("%Y");
2969 break;
2970
2971 default:
2972 wxFAIL_MSG( _T("wrong number of 'y's") );
2973 }
2974 break;
2975
2976 case _T('g'):
2977 // strftime() doesn't have era string,
2978 // ignore this format
2979 wxASSERT_MSG( lastCount <= 2,
2980 _T("too many 'g's") );
2981 break;
2982
2983 default:
2984 wxFAIL_MSG( _T("unreachable") );
2985 }
2986
2987 chLast = _T('\0');
2988 lastCount = 0;
2989 }
2990
2991 // not a special character so must be just a separator,
2992 // treat as is
2993 if ( *p != _T('\0') )
2994 {
2995 if ( *p == _T('%') )
2996 {
2997 // this one needs to be escaped
2998 fmtWX += _T('%');
2999 }
3000
3001 fmtWX += *p;
3002 }
3003 }
3004
3005 if ( *p == _T('\0') )
3006 break;
3007 }
3008 }
3009 //else: GetLocaleInfo() failed, leave fmtDate value unchanged and
3010 // try our luck with the default formats
3011 }
3012 //else: default C locale, default formats should work
3013
3014 return fmtWX;
3015 }
3016
3017 #endif // __WINDOWS__
3018
3019 const wxChar *wxDateTime::ParseFormat(const wxChar *date,
3020 const wxChar *format,
3021 const wxDateTime& dateDef)
3022 {
3023 wxCHECK_MSG( date && format, (wxChar *)NULL,
3024 _T("NULL pointer in wxDateTime::ParseFormat()") );
3025
3026 wxString str;
3027 unsigned long num;
3028
3029 // what fields have we found?
3030 bool haveWDay = false,
3031 haveYDay = false,
3032 haveDay = false,
3033 haveMon = false,
3034 haveYear = false,
3035 haveHour = false,
3036 haveMin = false,
3037 haveSec = false;
3038
3039 bool hourIsIn12hFormat = false, // or in 24h one?
3040 isPM = false; // AM by default
3041
3042 // and the value of the items we have (init them to get rid of warnings)
3043 wxDateTime_t sec = 0,
3044 min = 0,
3045 hour = 0;
3046 WeekDay wday = Inv_WeekDay;
3047 wxDateTime_t yday = 0,
3048 mday = 0;
3049 wxDateTime::Month mon = Inv_Month;
3050 int year = 0;
3051
3052 const wxChar *input = date;
3053 for ( const wxChar *fmt = format; *fmt; fmt++ )
3054 {
3055 if ( *fmt != _T('%') )
3056 {
3057 if ( wxIsspace(*fmt) )
3058 {
3059 // a white space in the format string matches 0 or more white
3060 // spaces in the input
3061 while ( wxIsspace(*input) )
3062 {
3063 input++;
3064 }
3065 }
3066 else // !space
3067 {
3068 // any other character (not whitespace, not '%') must be
3069 // matched by itself in the input
3070 if ( *input++ != *fmt )
3071 {
3072 // no match
3073 return (wxChar *)NULL;
3074 }
3075 }
3076
3077 // done with this format char
3078 continue;
3079 }
3080
3081 // start of a format specification
3082
3083 // parse the optional width
3084 size_t width = 0;
3085 while ( wxIsdigit(*++fmt) )
3086 {
3087 width *= 10;
3088 width += *fmt - _T('0');
3089 }
3090
3091 // the default widths for the various fields
3092 if ( !width )
3093 {
3094 switch ( *fmt )
3095 {
3096 case _T('Y'): // year has 4 digits
3097 width = 4;
3098 break;
3099
3100 case _T('j'): // day of year has 3 digits
3101 case _T('l'): // milliseconds have 3 digits
3102 width = 3;
3103 break;
3104
3105 case _T('w'): // week day as number has only one
3106 width = 1;
3107 break;
3108
3109 default:
3110 // default for all other fields
3111 width = 2;
3112 }
3113 }
3114
3115 // then the format itself
3116 switch ( *fmt )
3117 {
3118 case _T('a'): // a weekday name
3119 case _T('A'):
3120 {
3121 int flag = *fmt == _T('a') ? Name_Abbr : Name_Full;
3122 wday = GetWeekDayFromName(GetAlphaToken(input), flag);
3123 if ( wday == Inv_WeekDay )
3124 {
3125 // no match
3126 return (wxChar *)NULL;
3127 }
3128 }
3129 haveWDay = true;
3130 break;
3131
3132 case _T('b'): // a month name
3133 case _T('B'):
3134 {
3135 int flag = *fmt == _T('b') ? Name_Abbr : Name_Full;
3136 mon = GetMonthFromName(GetAlphaToken(input), flag);
3137 if ( mon == Inv_Month )
3138 {
3139 // no match
3140 return (wxChar *)NULL;
3141 }
3142 }
3143 haveMon = true;
3144 break;
3145
3146 case _T('c'): // locale default date and time representation
3147 {
3148 wxDateTime dt;
3149
3150 // this is the format which corresponds to ctime() output
3151 // and strptime("%c") should parse it, so try it first
3152 static const wxChar *fmtCtime = _T("%a %b %d %H:%M:%S %Y");
3153
3154 const wxChar *result = dt.ParseFormat(input, fmtCtime);
3155 if ( !result )
3156 {
3157 result = dt.ParseFormat(input, _T("%x %X"));
3158 }
3159
3160 if ( !result )
3161 {
3162 result = dt.ParseFormat(input, _T("%X %x"));
3163 }
3164
3165 if ( !result )
3166 {
3167 // we've tried everything and still no match
3168 return (wxChar *)NULL;
3169 }
3170
3171 Tm tm = dt.GetTm();
3172
3173 haveDay = haveMon = haveYear =
3174 haveHour = haveMin = haveSec = true;
3175
3176 hour = tm.hour;
3177 min = tm.min;
3178 sec = tm.sec;
3179
3180 year = tm.year;
3181 mon = tm.mon;
3182 mday = tm.mday;
3183
3184 input = result;
3185 }
3186 break;
3187
3188 case _T('d'): // day of a month (01-31)
3189 if ( !GetNumericToken(width, input, &num) ||
3190 (num > 31) || (num < 1) )
3191 {
3192 // no match
3193 return (wxChar *)NULL;
3194 }
3195
3196 // we can't check whether the day range is correct yet, will
3197 // do it later - assume ok for now
3198 haveDay = true;
3199 mday = (wxDateTime_t)num;
3200 break;
3201
3202 case _T('H'): // hour in 24h format (00-23)
3203 if ( !GetNumericToken(width, input, &num) || (num > 23) )
3204 {
3205 // no match
3206 return (wxChar *)NULL;
3207 }
3208
3209 haveHour = true;
3210 hour = (wxDateTime_t)num;
3211 break;
3212
3213 case _T('I'): // hour in 12h format (01-12)
3214 if ( !GetNumericToken(width, input, &num) || !num || (num > 12) )
3215 {
3216 // no match
3217 return (wxChar *)NULL;
3218 }
3219
3220 haveHour = true;
3221 hourIsIn12hFormat = true;
3222 hour = (wxDateTime_t)(num % 12); // 12 should be 0
3223 break;
3224
3225 case _T('j'): // day of the year
3226 if ( !GetNumericToken(width, input, &num) || !num || (num > 366) )
3227 {
3228 // no match
3229 return (wxChar *)NULL;
3230 }
3231
3232 haveYDay = true;
3233 yday = (wxDateTime_t)num;
3234 break;
3235
3236 case _T('m'): // month as a number (01-12)
3237 if ( !GetNumericToken(width, input, &num) || !num || (num > 12) )
3238 {
3239 // no match
3240 return (wxChar *)NULL;
3241 }
3242
3243 haveMon = true;
3244 mon = (Month)(num - 1);
3245 break;
3246
3247 case _T('M'): // minute as a decimal number (00-59)
3248 if ( !GetNumericToken(width, input, &num) || (num > 59) )
3249 {
3250 // no match
3251 return (wxChar *)NULL;
3252 }
3253
3254 haveMin = true;
3255 min = (wxDateTime_t)num;
3256 break;
3257
3258 case _T('p'): // AM or PM string
3259 {
3260 wxString am, pm, token = GetAlphaToken(input);
3261
3262 GetAmPmStrings(&am, &pm);
3263 if (am.empty() && pm.empty())
3264 return (wxChar *)NULL; // no am/pm strings defined
3265 if ( token.CmpNoCase(pm) == 0 )
3266 {
3267 isPM = true;
3268 }
3269 else if ( token.CmpNoCase(am) != 0 )
3270 {
3271 // no match
3272 return (wxChar *)NULL;
3273 }
3274 }
3275 break;
3276
3277 case _T('r'): // time as %I:%M:%S %p
3278 {
3279 wxDateTime dt;
3280 input = dt.ParseFormat(input, _T("%I:%M:%S %p"));
3281 if ( !input )
3282 {
3283 // no match
3284 return (wxChar *)NULL;
3285 }
3286
3287 haveHour = haveMin = haveSec = true;
3288
3289 Tm tm = dt.GetTm();
3290 hour = tm.hour;
3291 min = tm.min;
3292 sec = tm.sec;
3293 }
3294 break;
3295
3296 case _T('R'): // time as %H:%M
3297 {
3298 wxDateTime dt;
3299 input = dt.ParseFormat(input, _T("%H:%M"));
3300 if ( !input )
3301 {
3302 // no match
3303 return (wxChar *)NULL;
3304 }
3305
3306 haveHour = haveMin = true;
3307
3308 Tm tm = dt.GetTm();
3309 hour = tm.hour;
3310 min = tm.min;
3311 }
3312 break;
3313
3314 case _T('S'): // second as a decimal number (00-61)
3315 if ( !GetNumericToken(width, input, &num) || (num > 61) )
3316 {
3317 // no match
3318 return (wxChar *)NULL;
3319 }
3320
3321 haveSec = true;
3322 sec = (wxDateTime_t)num;
3323 break;
3324
3325 case _T('T'): // time as %H:%M:%S
3326 {
3327 wxDateTime dt;
3328 input = dt.ParseFormat(input, _T("%H:%M:%S"));
3329 if ( !input )
3330 {
3331 // no match
3332 return (wxChar *)NULL;
3333 }
3334
3335 haveHour = haveMin = haveSec = true;
3336
3337 Tm tm = dt.GetTm();
3338 hour = tm.hour;
3339 min = tm.min;
3340 sec = tm.sec;
3341 }
3342 break;
3343
3344 case _T('w'): // weekday as a number (0-6), Sunday = 0
3345 if ( !GetNumericToken(width, input, &num) || (wday > 6) )
3346 {
3347 // no match
3348 return (wxChar *)NULL;
3349 }
3350
3351 haveWDay = true;
3352 wday = (WeekDay)num;
3353 break;
3354
3355 case _T('x'): // locale default date representation
3356 #ifdef HAVE_STRPTIME
3357 // try using strptime() -- it may fail even if the input is
3358 // correct but the date is out of range, so we will fall back
3359 // to our generic code anyhow
3360 {
3361 struct tm tm;
3362
3363 const wxChar *result = CallStrptime(input, "%x", &tm);
3364 if ( result )
3365 {
3366 input = result;
3367
3368 haveDay = haveMon = haveYear = true;
3369
3370 year = 1900 + tm.tm_year;
3371 mon = (Month)tm.tm_mon;
3372 mday = tm.tm_mday;
3373
3374 break;
3375 }
3376 }
3377 #endif // HAVE_STRPTIME
3378
3379 {
3380 wxDateTime dt;
3381 wxString fmtDate,
3382 fmtDateAlt;
3383
3384 #ifdef __WINDOWS__
3385 // The above doesn't work for all locales, try to query
3386 // Windows for the right way of formatting the date:
3387 fmtDate = GetLocaleDateFormat();
3388 if ( fmtDate.empty() )
3389 #endif
3390 {
3391 if ( IsWestEuropeanCountry(GetCountry()) ||
3392 GetCountry() == Russia )
3393 {
3394 fmtDate = _T("%d/%m/%y");
3395 fmtDateAlt = _T("%m/%d/%y");
3396 }
3397 else // assume USA
3398 {
3399 fmtDate = _T("%m/%d/%y");
3400 fmtDateAlt = _T("%d/%m/%y");
3401 }
3402 }
3403
3404 const wxChar *result = dt.ParseFormat(input, fmtDate);
3405
3406 if ( !result && !fmtDateAlt.empty() )
3407 {
3408 // ok, be nice and try another one
3409 result = dt.ParseFormat(input, fmtDateAlt);
3410 }
3411
3412 if ( !result )
3413 {
3414 // bad luck
3415 return (wxChar *)NULL;
3416 }
3417
3418 Tm tm = dt.GetTm();
3419
3420 haveDay = haveMon = haveYear = true;
3421
3422 year = tm.year;
3423 mon = tm.mon;
3424 mday = tm.mday;
3425
3426 input = result;
3427 }
3428
3429 break;
3430
3431 case _T('X'): // locale default time representation
3432 #ifdef HAVE_STRPTIME
3433 {
3434 // use strptime() to do it for us (FIXME !Unicode friendly)
3435 struct tm tm;
3436 input = CallStrptime(input, "%X", &tm);
3437 if ( !input )
3438 {
3439 return (wxChar *)NULL;
3440 }
3441
3442 haveHour = haveMin = haveSec = true;
3443
3444 hour = tm.tm_hour;
3445 min = tm.tm_min;
3446 sec = tm.tm_sec;
3447 }
3448 #else // !HAVE_STRPTIME
3449 // TODO under Win32 we can query the LOCALE_ITIME system
3450 // setting which says whether the default time format is
3451 // 24 or 12 hour
3452 {
3453 // try to parse what follows as "%H:%M:%S" and, if this
3454 // fails, as "%I:%M:%S %p" - this should catch the most
3455 // common cases
3456 wxDateTime dt;
3457
3458 const wxChar *result = dt.ParseFormat(input, _T("%T"));
3459 if ( !result )
3460 {
3461 result = dt.ParseFormat(input, _T("%r"));
3462 }
3463
3464 if ( !result )
3465 {
3466 // no match
3467 return (wxChar *)NULL;
3468 }
3469
3470 haveHour = haveMin = haveSec = true;
3471
3472 Tm tm = dt.GetTm();
3473 hour = tm.hour;
3474 min = tm.min;
3475 sec = tm.sec;
3476
3477 input = result;
3478 }
3479 #endif // HAVE_STRPTIME/!HAVE_STRPTIME
3480 break;
3481
3482 case _T('y'): // year without century (00-99)
3483 if ( !GetNumericToken(width, input, &num) || (num > 99) )
3484 {
3485 // no match
3486 return (wxChar *)NULL;
3487 }
3488
3489 haveYear = true;
3490
3491 // TODO should have an option for roll over date instead of
3492 // hard coding it here
3493 year = (num > 30 ? 1900 : 2000) + (wxDateTime_t)num;
3494 break;
3495
3496 case _T('Y'): // year with century
3497 if ( !GetNumericToken(width, input, &num) )
3498 {
3499 // no match
3500 return (wxChar *)NULL;
3501 }
3502
3503 haveYear = true;
3504 year = (wxDateTime_t)num;
3505 break;
3506
3507 case _T('Z'): // timezone name
3508 wxFAIL_MSG(_T("TODO"));
3509 break;
3510
3511 case _T('%'): // a percent sign
3512 if ( *input++ != _T('%') )
3513 {
3514 // no match
3515 return (wxChar *)NULL;
3516 }
3517 break;
3518
3519 case 0: // the end of string
3520 wxFAIL_MSG(_T("unexpected format end"));
3521
3522 // fall through
3523
3524 default: // not a known format spec
3525 return (wxChar *)NULL;
3526 }
3527 }
3528
3529 // format matched, try to construct a date from what we have now
3530 Tm tmDef;
3531 if ( dateDef.IsValid() )
3532 {
3533 // take this date as default
3534 tmDef = dateDef.GetTm();
3535 }
3536 else if ( IsValid() )
3537 {
3538 // if this date is valid, don't change it
3539 tmDef = GetTm();
3540 }
3541 else
3542 {
3543 // no default and this date is invalid - fall back to Today()
3544 tmDef = Today().GetTm();
3545 }
3546
3547 Tm tm = tmDef;
3548
3549 // set the date
3550 if ( haveYear )
3551 {
3552 tm.year = year;
3553 }
3554
3555 // TODO we don't check here that the values are consistent, if both year
3556 // day and month/day were found, we just ignore the year day and we
3557 // also always ignore the week day
3558 if ( haveMon && haveDay )
3559 {
3560 if ( mday > GetNumOfDaysInMonth(tm.year, mon) )
3561 {
3562 wxLogDebug(_T("bad month day in wxDateTime::ParseFormat"));
3563
3564 return (wxChar *)NULL;
3565 }
3566
3567 tm.mon = mon;
3568 tm.mday = mday;
3569 }
3570 else if ( haveYDay )
3571 {
3572 if ( yday > GetNumberOfDays(tm.year) )
3573 {
3574 wxLogDebug(_T("bad year day in wxDateTime::ParseFormat"));
3575
3576 return (wxChar *)NULL;
3577 }
3578
3579 Tm tm2 = wxDateTime(1, Jan, tm.year).SetToYearDay(yday).GetTm();
3580
3581 tm.mon = tm2.mon;
3582 tm.mday = tm2.mday;
3583 }
3584
3585 // deal with AM/PM
3586 if ( haveHour && hourIsIn12hFormat && isPM )
3587 {
3588 // translate to 24hour format
3589 hour += 12;
3590 }
3591 //else: either already in 24h format or no translation needed
3592
3593 // set the time
3594 if ( haveHour )
3595 {
3596 tm.hour = hour;
3597 }
3598
3599 if ( haveMin )
3600 {
3601 tm.min = min;
3602 }
3603
3604 if ( haveSec )
3605 {
3606 tm.sec = sec;
3607 }
3608
3609 Set(tm);
3610
3611 // finally check that the week day is consistent -- if we had it
3612 if ( haveWDay && GetWeekDay() != wday )
3613 {
3614 wxLogDebug(_T("inconsistsnet week day in wxDateTime::ParseFormat()"));
3615
3616 return NULL;
3617 }
3618
3619 return input;
3620 }
3621
3622 const wxChar *wxDateTime::ParseDateTime(const wxChar *date)
3623 {
3624 wxCHECK_MSG( date, (wxChar *)NULL, _T("NULL pointer in wxDateTime::Parse") );
3625
3626 // Set to current day and hour, so strings like '14:00' becomes today at
3627 // 14, not some other random date
3628 wxDateTime dtDate = wxDateTime::Today();
3629 wxDateTime dtTime = wxDateTime::Today();
3630
3631 const wxChar* pchTime;
3632
3633 // Try to parse the beginning of the string as a date
3634 const wxChar* pchDate = dtDate.ParseDate(date);
3635
3636 // We got a date in the beginning, see if there is a time specified after the date
3637 if ( pchDate )
3638 {
3639 // Skip spaces, as the ParseTime() function fails on spaces
3640 while ( wxIsspace(*pchDate) )
3641 pchDate++;
3642
3643 pchTime = dtTime.ParseTime(pchDate);
3644 }
3645 else // no date in the beginning
3646 {
3647 // check and see if we have a time followed by a date
3648 pchTime = dtTime.ParseTime(date);
3649 if ( pchTime )
3650 {
3651 while ( wxIsspace(*pchTime) )
3652 pchTime++;
3653
3654 pchDate = dtDate.ParseDate(pchTime);
3655 }
3656 }
3657
3658 // If we have a date specified, set our own data to the same date
3659 if ( !pchDate || !pchTime )
3660 return NULL;
3661
3662 Set(dtDate.GetDay(), dtDate.GetMonth(), dtDate.GetYear(),
3663 dtTime.GetHour(), dtTime.GetMinute(), dtTime.GetSecond(),
3664 dtTime.GetMillisecond());
3665
3666 // Return endpoint of scan
3667 return pchDate > pchTime ? pchDate : pchTime;
3668 }
3669
3670 const wxChar *wxDateTime::ParseDate(const wxChar *date)
3671 {
3672 // this is a simplified version of ParseDateTime() which understands only
3673 // "today" (for wxDate compatibility) and digits only otherwise (and not
3674 // all esoteric constructions ParseDateTime() knows about)
3675
3676 wxCHECK_MSG( date, (wxChar *)NULL, _T("NULL pointer in wxDateTime::Parse") );
3677
3678 const wxChar *p = date;
3679 while ( wxIsspace(*p) )
3680 p++;
3681
3682 // some special cases
3683 static struct
3684 {
3685 const wxChar *str;
3686 int dayDiffFromToday;
3687 } literalDates[] =
3688 {
3689 { wxTRANSLATE("today"), 0 },
3690 { wxTRANSLATE("yesterday"), -1 },
3691 { wxTRANSLATE("tomorrow"), 1 },
3692 };
3693
3694 for ( size_t n = 0; n < WXSIZEOF(literalDates); n++ )
3695 {
3696 wxString date = wxGetTranslation(literalDates[n].str);
3697 size_t len = date.length();
3698 if ( wxStrlen(p) >= len )
3699 {
3700 wxString str(p, len);
3701 if ( str.CmpNoCase(date) == 0 )
3702 {
3703 // nothing can follow this, so stop here
3704 p += len;
3705
3706 int dayDiffFromToday = literalDates[n].dayDiffFromToday;
3707 *this = Today();
3708 if ( dayDiffFromToday )
3709 {
3710 *this += wxDateSpan::Days(dayDiffFromToday);
3711 }
3712
3713 return p;
3714 }
3715 }
3716 }
3717
3718 // We try to guess what we have here: for each new (numeric) token, we
3719 // determine if it can be a month, day or a year. Of course, there is an
3720 // ambiguity as some numbers may be days as well as months, so we also
3721 // have the ability to back track.
3722
3723 // what do we have?
3724 bool haveDay = false, // the months day?
3725 haveWDay = false, // the day of week?
3726 haveMon = false, // the month?
3727 haveYear = false; // the year?
3728
3729 // and the value of the items we have (init them to get rid of warnings)
3730 WeekDay wday = Inv_WeekDay;
3731 wxDateTime_t day = 0;
3732 wxDateTime::Month mon = Inv_Month;
3733 int year = 0;
3734
3735 // tokenize the string
3736 size_t nPosCur = 0;
3737 static const wxChar *dateDelimiters = _T(".,/-\t\r\n ");
3738 wxStringTokenizer tok(p, dateDelimiters);
3739 while ( tok.HasMoreTokens() )
3740 {
3741 wxString token = tok.GetNextToken();
3742 if ( !token )
3743 continue;
3744
3745 // is it a number?
3746 unsigned long val;
3747 if ( token.ToULong(&val) )
3748 {
3749 // guess what this number is
3750
3751 bool isDay = false,
3752 isMonth = false,
3753 isYear = false;
3754
3755 if ( !haveMon && val > 0 && val <= 12 )
3756 {
3757 // assume it is month
3758 isMonth = true;
3759 }
3760 else // not the month
3761 {
3762 if ( haveDay )
3763 {
3764 // this can only be the year
3765 isYear = true;
3766 }
3767 else // may be either day or year
3768 {
3769 wxDateTime_t max_days = (wxDateTime_t)(
3770 haveMon
3771 ? GetNumOfDaysInMonth(haveYear ? year : Inv_Year, mon)
3772 : 31
3773 );
3774
3775 // can it be day?
3776 if ( (val == 0) || (val > (unsigned long)max_days) )
3777 {
3778 // no
3779 isYear = true;
3780 }
3781 else // yes, suppose it's the day
3782 {
3783 isDay = true;
3784 }
3785 }
3786 }
3787
3788 if ( isYear )
3789 {
3790 if ( haveYear )
3791 break;
3792
3793 haveYear = true;
3794
3795 year = (wxDateTime_t)val;
3796 }
3797 else if ( isDay )
3798 {
3799 if ( haveDay )
3800 break;
3801
3802 haveDay = true;
3803
3804 day = (wxDateTime_t)val;
3805 }
3806 else if ( isMonth )
3807 {
3808 haveMon = true;
3809
3810 mon = (Month)(val - 1);
3811 }
3812 }
3813 else // not a number
3814 {
3815 // be careful not to overwrite the current mon value
3816 Month mon2 = GetMonthFromName(token, Name_Full | Name_Abbr);
3817 if ( mon2 != Inv_Month )
3818 {
3819 // it's a month
3820 if ( haveMon )
3821 {
3822 // but we already have a month - maybe we guessed wrong?
3823 if ( !haveDay )
3824 {
3825 // no need to check in month range as always < 12, but
3826 // the days are counted from 1 unlike the months
3827 day = (wxDateTime_t)(mon + 1);
3828 haveDay = true;
3829 }
3830 else
3831 {
3832 // could possible be the year (doesn't the year come
3833 // before the month in the japanese format?) (FIXME)
3834 break;
3835 }
3836 }
3837
3838 mon = mon2;
3839
3840 haveMon = true;
3841 }
3842 else // not a valid month name
3843 {
3844 wday = GetWeekDayFromName(token, Name_Full | Name_Abbr);
3845 if ( wday != Inv_WeekDay )
3846 {
3847 // a week day
3848 if ( haveWDay )
3849 {
3850 break;
3851 }
3852
3853 haveWDay = true;
3854 }
3855 else // not a valid weekday name
3856 {
3857 // try the ordinals
3858 static const wxChar *ordinals[] =
3859 {
3860 wxTRANSLATE("first"),
3861 wxTRANSLATE("second"),
3862 wxTRANSLATE("third"),
3863 wxTRANSLATE("fourth"),
3864 wxTRANSLATE("fifth"),
3865 wxTRANSLATE("sixth"),
3866 wxTRANSLATE("seventh"),
3867 wxTRANSLATE("eighth"),
3868 wxTRANSLATE("ninth"),
3869 wxTRANSLATE("tenth"),
3870 wxTRANSLATE("eleventh"),
3871 wxTRANSLATE("twelfth"),
3872 wxTRANSLATE("thirteenth"),
3873 wxTRANSLATE("fourteenth"),
3874 wxTRANSLATE("fifteenth"),
3875 wxTRANSLATE("sixteenth"),
3876 wxTRANSLATE("seventeenth"),
3877 wxTRANSLATE("eighteenth"),
3878 wxTRANSLATE("nineteenth"),
3879 wxTRANSLATE("twentieth"),
3880 // that's enough - otherwise we'd have problems with
3881 // composite (or not) ordinals
3882 };
3883
3884 size_t n;
3885 for ( n = 0; n < WXSIZEOF(ordinals); n++ )
3886 {
3887 if ( token.CmpNoCase(ordinals[n]) == 0 )
3888 {
3889 break;
3890 }
3891 }
3892
3893 if ( n == WXSIZEOF(ordinals) )
3894 {
3895 // stop here - something unknown
3896 break;
3897 }
3898
3899 // it's a day
3900 if ( haveDay )
3901 {
3902 // don't try anything here (as in case of numeric day
3903 // above) - the symbolic day spec should always
3904 // precede the month/year
3905 break;
3906 }
3907
3908 haveDay = true;
3909
3910 day = (wxDateTime_t)(n + 1);
3911 }
3912 }
3913 }
3914
3915 nPosCur = tok.GetPosition();
3916 }
3917
3918 // either no more tokens or the scan was stopped by something we couldn't
3919 // parse - in any case, see if we can construct a date from what we have
3920 if ( !haveDay && !haveWDay )
3921 {
3922 wxLogDebug(_T("ParseDate: no day, no weekday hence no date."));
3923
3924 return (wxChar *)NULL;
3925 }
3926
3927 if ( haveWDay && (haveMon || haveYear || haveDay) &&
3928 !(haveDay && haveMon && haveYear) )
3929 {
3930 // without adjectives (which we don't support here) the week day only
3931 // makes sense completely separately or with the full date
3932 // specification (what would "Wed 1999" mean?)
3933 return (wxChar *)NULL;
3934 }
3935
3936 if ( !haveWDay && haveYear && !(haveDay && haveMon) )
3937 {
3938 // may be we have month and day instead of day and year?
3939 if ( haveDay && !haveMon )
3940 {
3941 if ( day <= 12 )
3942 {
3943 // exchange day and month
3944 mon = (wxDateTime::Month)(day - 1);
3945
3946 // we're in the current year then
3947 if ( (year > 0) && (year <= (int)GetNumOfDaysInMonth(Inv_Year, mon)) )
3948 {
3949 day = (wxDateTime_t)year;
3950
3951 haveMon = true;
3952 haveYear = false;
3953 }
3954 //else: no, can't exchange, leave haveMon == false
3955 }
3956 }
3957
3958 if ( !haveMon )
3959 {
3960 // if we give the year, month and day must be given too
3961 wxLogDebug(_T("ParseDate: day and month should be specified if year is."));
3962
3963 return (wxChar *)NULL;
3964 }
3965 }
3966
3967 if ( !haveMon )
3968 {
3969 mon = GetCurrentMonth();
3970 }
3971
3972 if ( !haveYear )
3973 {
3974 year = GetCurrentYear();
3975 }
3976
3977 if ( haveDay )
3978 {
3979 Set(day, mon, year);
3980
3981 if ( haveWDay )
3982 {
3983 // check that it is really the same
3984 if ( GetWeekDay() != wday )
3985 {
3986 // inconsistency detected
3987 wxLogDebug(_T("ParseDate: inconsistent day/weekday."));
3988
3989 return (wxChar *)NULL;
3990 }
3991 }
3992 }
3993 else // haveWDay
3994 {
3995 *this = Today();
3996
3997 SetToWeekDayInSameWeek(wday);
3998 }
3999
4000 // return the pointer to the first unparsed char
4001 p += nPosCur;
4002 if ( nPosCur && wxStrchr(dateDelimiters, *(p - 1)) )
4003 {
4004 // if we couldn't parse the token after the delimiter, put back the
4005 // delimiter as well
4006 p--;
4007 }
4008
4009 return p;
4010 }
4011
4012 const wxChar *wxDateTime::ParseTime(const wxChar *time)
4013 {
4014 wxCHECK_MSG( time, (wxChar *)NULL, _T("NULL pointer in wxDateTime::Parse") );
4015
4016 // first try some extra things
4017 static const struct
4018 {
4019 const wxChar *name;
4020 wxDateTime_t hour;
4021 } stdTimes[] =
4022 {
4023 { wxTRANSLATE("noon"), 12 },
4024 { wxTRANSLATE("midnight"), 00 },
4025 // anything else?
4026 };
4027
4028 for ( size_t n = 0; n < WXSIZEOF(stdTimes); n++ )
4029 {
4030 wxString timeString = wxGetTranslation(stdTimes[n].name);
4031 size_t len = timeString.length();
4032 if ( timeString.CmpNoCase(wxString(time, len)) == 0 )
4033 {
4034 // casts required by DigitalMars
4035 Set(stdTimes[n].hour, wxDateTime_t(0), wxDateTime_t(0));
4036
4037 return time + len;
4038 }
4039 }
4040
4041 // try all time formats we may think about in the order from longest to
4042 // shortest
4043
4044 // 12hour with AM/PM?
4045 const wxChar *result = ParseFormat(time, _T("%I:%M:%S %p"));
4046
4047 if ( !result )
4048 {
4049 // normally, it's the same, but why not try it?
4050 result = ParseFormat(time, _T("%H:%M:%S"));
4051 }
4052
4053 if ( !result )
4054 {
4055 // 12hour with AM/PM but without seconds?
4056 result = ParseFormat(time, _T("%I:%M %p"));
4057 }
4058
4059 if ( !result )
4060 {
4061 // without seconds?
4062 result = ParseFormat(time, _T("%H:%M"));
4063 }
4064
4065 if ( !result )
4066 {
4067 // just the hour and AM/PM?
4068 result = ParseFormat(time, _T("%I %p"));
4069 }
4070
4071 if ( !result )
4072 {
4073 // just the hour?
4074 result = ParseFormat(time, _T("%H"));
4075 }
4076
4077 if ( !result )
4078 {
4079 // parse the standard format: normally it is one of the formats above
4080 // but it may be set to something completely different by the user
4081 result = ParseFormat(time, _T("%X"));
4082 }
4083
4084 // TODO: parse timezones
4085
4086 return result;
4087 }
4088
4089 // ----------------------------------------------------------------------------
4090 // Workdays and holidays support
4091 // ----------------------------------------------------------------------------
4092
4093 bool wxDateTime::IsWorkDay(Country WXUNUSED(country)) const
4094 {
4095 return !wxDateTimeHolidayAuthority::IsHoliday(*this);
4096 }
4097
4098 // ============================================================================
4099 // wxDateSpan
4100 // ============================================================================
4101
4102 wxDateSpan WXDLLIMPEXP_BASE operator*(int n, const wxDateSpan& ds)
4103 {
4104 wxDateSpan ds1(ds);
4105 return ds1.Multiply(n);
4106 }
4107
4108 // ============================================================================
4109 // wxTimeSpan
4110 // ============================================================================
4111
4112 wxTimeSpan WXDLLIMPEXP_BASE operator*(int n, const wxTimeSpan& ts)
4113 {
4114 return wxTimeSpan(ts).Multiply(n);
4115 }
4116
4117 // this enum is only used in wxTimeSpan::Format() below but we can't declare
4118 // it locally to the method as it provokes an internal compiler error in egcs
4119 // 2.91.60 when building with -O2
4120 enum TimeSpanPart
4121 {
4122 Part_Week,
4123 Part_Day,
4124 Part_Hour,
4125 Part_Min,
4126 Part_Sec,
4127 Part_MSec
4128 };
4129
4130 // not all strftime(3) format specifiers make sense here because, for example,
4131 // a time span doesn't have a year nor a timezone
4132 //
4133 // Here are the ones which are supported (all of them are supported by strftime
4134 // as well):
4135 // %H hour in 24 hour format
4136 // %M minute (00 - 59)
4137 // %S second (00 - 59)
4138 // %% percent sign
4139 //
4140 // Also, for MFC CTimeSpan compatibility, we support
4141 // %D number of days
4142 //
4143 // And, to be better than MFC :-), we also have
4144 // %E number of wEeks
4145 // %l milliseconds (000 - 999)
4146 wxString wxTimeSpan::Format(const wxChar *format) const
4147 {
4148 wxCHECK_MSG( format, wxEmptyString, _T("NULL format in wxTimeSpan::Format") );
4149
4150 wxString str;
4151 str.Alloc(wxStrlen(format));
4152
4153 // Suppose we have wxTimeSpan ts(1 /* hour */, 2 /* min */, 3 /* sec */)
4154 //
4155 // Then, of course, ts.Format("%H:%M:%S") must return "01:02:03", but the
4156 // question is what should ts.Format("%S") do? The code here returns "3273"
4157 // in this case (i.e. the total number of seconds, not just seconds % 60)
4158 // because, for me, this call means "give me entire time interval in
4159 // seconds" and not "give me the seconds part of the time interval"
4160 //
4161 // If we agree that it should behave like this, it is clear that the
4162 // interpretation of each format specifier depends on the presence of the
4163 // other format specs in the string: if there was "%H" before "%M", we
4164 // should use GetMinutes() % 60, otherwise just GetMinutes() &c
4165
4166 // we remember the most important unit found so far
4167 TimeSpanPart partBiggest = Part_MSec;
4168
4169 for ( const wxChar *pch = format; *pch; pch++ )
4170 {
4171 wxChar ch = *pch;
4172
4173 if ( ch == _T('%') )
4174 {
4175 // the start of the format specification of the printf() below
4176 wxString fmtPrefix = _T('%');
4177
4178 // the number
4179 long n;
4180
4181 ch = *++pch; // get the format spec char
4182 switch ( ch )
4183 {
4184 default:
4185 wxFAIL_MSG( _T("invalid format character") );
4186 // fall through
4187
4188 case _T('%'):
4189 str += ch;
4190
4191 // skip the part below switch
4192 continue;
4193
4194 case _T('D'):
4195 n = GetDays();
4196 if ( partBiggest < Part_Day )
4197 {
4198 n %= DAYS_PER_WEEK;
4199 }
4200 else
4201 {
4202 partBiggest = Part_Day;
4203 }
4204 break;
4205
4206 case _T('E'):
4207 partBiggest = Part_Week;
4208 n = GetWeeks();
4209 break;
4210
4211 case _T('H'):
4212 n = GetHours();
4213 if ( partBiggest < Part_Hour )
4214 {
4215 n %= HOURS_PER_DAY;
4216 }
4217 else
4218 {
4219 partBiggest = Part_Hour;
4220 }
4221
4222 fmtPrefix += _T("02");
4223 break;
4224
4225 case _T('l'):
4226 n = GetMilliseconds().ToLong();
4227 if ( partBiggest < Part_MSec )
4228 {
4229 n %= 1000;
4230 }
4231 //else: no need to reset partBiggest to Part_MSec, it is
4232 // the least significant one anyhow
4233
4234 fmtPrefix += _T("03");
4235 break;
4236
4237 case _T('M'):
4238 n = GetMinutes();
4239 if ( partBiggest < Part_Min )
4240 {
4241 n %= MIN_PER_HOUR;
4242 }
4243 else
4244 {
4245 partBiggest = Part_Min;
4246 }
4247
4248 fmtPrefix += _T("02");
4249 break;
4250
4251 case _T('S'):
4252 n = GetSeconds().ToLong();
4253 if ( partBiggest < Part_Sec )
4254 {
4255 n %= SEC_PER_MIN;
4256 }
4257 else
4258 {
4259 partBiggest = Part_Sec;
4260 }
4261
4262 fmtPrefix += _T("02");
4263 break;
4264 }
4265
4266 str += wxString::Format(fmtPrefix + _T("ld"), n);
4267 }
4268 else
4269 {
4270 // normal character, just copy
4271 str += ch;
4272 }
4273 }
4274
4275 return str;
4276 }
4277
4278 // ============================================================================
4279 // wxDateTimeHolidayAuthority and related classes
4280 // ============================================================================
4281
4282 #include "wx/arrimpl.cpp"
4283
4284 WX_DEFINE_OBJARRAY(wxDateTimeArray);
4285
4286 static int wxCMPFUNC_CONV
4287 wxDateTimeCompareFunc(wxDateTime **first, wxDateTime **second)
4288 {
4289 wxDateTime dt1 = **first,
4290 dt2 = **second;
4291
4292 return dt1 == dt2 ? 0 : dt1 < dt2 ? -1 : +1;
4293 }
4294
4295 // ----------------------------------------------------------------------------
4296 // wxDateTimeHolidayAuthority
4297 // ----------------------------------------------------------------------------
4298
4299 wxHolidayAuthoritiesArray wxDateTimeHolidayAuthority::ms_authorities;
4300
4301 /* static */
4302 bool wxDateTimeHolidayAuthority::IsHoliday(const wxDateTime& dt)
4303 {
4304 size_t count = ms_authorities.size();
4305 for ( size_t n = 0; n < count; n++ )
4306 {
4307 if ( ms_authorities[n]->DoIsHoliday(dt) )
4308 {
4309 return true;
4310 }
4311 }
4312
4313 return false;
4314 }
4315
4316 /* static */
4317 size_t
4318 wxDateTimeHolidayAuthority::GetHolidaysInRange(const wxDateTime& dtStart,
4319 const wxDateTime& dtEnd,
4320 wxDateTimeArray& holidays)
4321 {
4322 wxDateTimeArray hol;
4323
4324 holidays.Clear();
4325
4326 size_t count = ms_authorities.size();
4327 for ( size_t nAuth = 0; nAuth < count; nAuth++ )
4328 {
4329 ms_authorities[nAuth]->DoGetHolidaysInRange(dtStart, dtEnd, hol);
4330
4331 WX_APPEND_ARRAY(holidays, hol);
4332 }
4333
4334 holidays.Sort(wxDateTimeCompareFunc);
4335
4336 return holidays.size();
4337 }
4338
4339 /* static */
4340 void wxDateTimeHolidayAuthority::ClearAllAuthorities()
4341 {
4342 WX_CLEAR_ARRAY(ms_authorities);
4343 }
4344
4345 /* static */
4346 void wxDateTimeHolidayAuthority::AddAuthority(wxDateTimeHolidayAuthority *auth)
4347 {
4348 ms_authorities.push_back(auth);
4349 }
4350
4351 wxDateTimeHolidayAuthority::~wxDateTimeHolidayAuthority()
4352 {
4353 // required here for Darwin
4354 }
4355
4356 // ----------------------------------------------------------------------------
4357 // wxDateTimeWorkDays
4358 // ----------------------------------------------------------------------------
4359
4360 bool wxDateTimeWorkDays::DoIsHoliday(const wxDateTime& dt) const
4361 {
4362 wxDateTime::WeekDay wd = dt.GetWeekDay();
4363
4364 return (wd == wxDateTime::Sun) || (wd == wxDateTime::Sat);
4365 }
4366
4367 size_t wxDateTimeWorkDays::DoGetHolidaysInRange(const wxDateTime& dtStart,
4368 const wxDateTime& dtEnd,
4369 wxDateTimeArray& holidays) const
4370 {
4371 if ( dtStart > dtEnd )
4372 {
4373 wxFAIL_MSG( _T("invalid date range in GetHolidaysInRange") );
4374
4375 return 0u;
4376 }
4377
4378 holidays.Empty();
4379
4380 // instead of checking all days, start with the first Sat after dtStart and
4381 // end with the last Sun before dtEnd
4382 wxDateTime dtSatFirst = dtStart.GetNextWeekDay(wxDateTime::Sat),
4383 dtSatLast = dtEnd.GetPrevWeekDay(wxDateTime::Sat),
4384 dtSunFirst = dtStart.GetNextWeekDay(wxDateTime::Sun),
4385 dtSunLast = dtEnd.GetPrevWeekDay(wxDateTime::Sun),
4386 dt;
4387
4388 for ( dt = dtSatFirst; dt <= dtSatLast; dt += wxDateSpan::Week() )
4389 {
4390 holidays.Add(dt);
4391 }
4392
4393 for ( dt = dtSunFirst; dt <= dtSunLast; dt += wxDateSpan::Week() )
4394 {
4395 holidays.Add(dt);
4396 }
4397
4398 return holidays.GetCount();
4399 }
4400
4401 // ============================================================================
4402 // other helper functions
4403 // ============================================================================
4404
4405 // ----------------------------------------------------------------------------
4406 // iteration helpers: can be used to write a for loop over enum variable like
4407 // this:
4408 // for ( m = wxDateTime::Jan; m < wxDateTime::Inv_Month; wxNextMonth(m) )
4409 // ----------------------------------------------------------------------------
4410
4411 WXDLLIMPEXP_BASE void wxNextMonth(wxDateTime::Month& m)
4412 {
4413 wxASSERT_MSG( m < wxDateTime::Inv_Month, _T("invalid month") );
4414
4415 // no wrapping or the for loop above would never end!
4416 m = (wxDateTime::Month)(m + 1);
4417 }
4418
4419 WXDLLIMPEXP_BASE void wxPrevMonth(wxDateTime::Month& m)
4420 {
4421 wxASSERT_MSG( m < wxDateTime::Inv_Month, _T("invalid month") );
4422
4423 m = m == wxDateTime::Jan ? wxDateTime::Inv_Month
4424 : (wxDateTime::Month)(m - 1);
4425 }
4426
4427 WXDLLIMPEXP_BASE void wxNextWDay(wxDateTime::WeekDay& wd)
4428 {
4429 wxASSERT_MSG( wd < wxDateTime::Inv_WeekDay, _T("invalid week day") );
4430
4431 // no wrapping or the for loop above would never end!
4432 wd = (wxDateTime::WeekDay)(wd + 1);
4433 }
4434
4435 WXDLLIMPEXP_BASE void wxPrevWDay(wxDateTime::WeekDay& wd)
4436 {
4437 wxASSERT_MSG( wd < wxDateTime::Inv_WeekDay, _T("invalid week day") );
4438
4439 wd = wd == wxDateTime::Sun ? wxDateTime::Inv_WeekDay
4440 : (wxDateTime::WeekDay)(wd - 1);
4441 }
4442
4443 #endif // wxUSE_DATETIME