1 ///////////////////////////////////////////////////////////////////////////////
3 // Purpose: implementation of time/date related classes
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // parts of code taken from sndcal library by Scott E. Lee:
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.
16 // Licence: wxWindows license
17 ///////////////////////////////////////////////////////////////////////////////
20 * Implementation notes:
22 * 1. the time is stored as a 64bit integer containing the signed number of
23 * milliseconds since Jan 1. 1970 (the Unix Epoch) - so it is always
26 * 2. the range is thus something about 580 million years, but due to current
27 * algorithms limitations, only dates from Nov 24, 4714BC are handled
29 * 3. standard ANSI C functions are used to do time calculations whenever
30 * possible, i.e. when the date is in the range Jan 1, 1970 to 2038
32 * 4. otherwise, the calculations are done by converting the date to/from JDN
33 * first (the range limitation mentioned above comes from here: the
34 * algorithm used by Scott E. Lee's code only works for positive JDNs, more
37 * 5. the object constructed for the given DD-MM-YYYY HH:MM:SS corresponds to
38 * this moment in local time and may be converted to the object
39 * corresponding to the same date/time in another time zone by using
42 * 6. the conversions to the current (or any other) timezone are done when the
43 * internal time representation is converted to the broken-down one in
47 // ============================================================================
49 // ============================================================================
51 // ----------------------------------------------------------------------------
53 // ----------------------------------------------------------------------------
56 #pragma implementation "datetime.h"
59 // For compilers that support precompilation, includes "wx.h".
60 #include "wx/wxprec.h"
67 #include "wx/string.h"
72 #include "wx/thread.h"
73 #include "wx/tokenzr.h"
75 #define wxDEFINE_TIME_CONSTANTS // before including datetime.h
77 #include "wx/datetime.h"
79 // ----------------------------------------------------------------------------
80 // conditional compilation
81 // ----------------------------------------------------------------------------
83 #if defined(HAVE_STRPTIME) && defined(__LINUX__)
84 // glibc 2.0.7 strptime() is broken - the following snippet causes it to
85 // crash (instead of just failing):
87 // strncpy(buf, "Tue Dec 21 20:25:40 1999", 128);
88 // strptime(buf, "%x", &tm);
92 #endif // broken strptime()
96 #define WX_TIMEZONE _timezone
97 #else // unknown platform - try timezone
98 #define WX_TIMEZONE timezone
100 #endif // !WX_TIMEZONE
102 // ----------------------------------------------------------------------------
104 // ----------------------------------------------------------------------------
107 static const int MONTHS_IN_YEAR
= 12;
109 static const int SECONDS_IN_MINUTE
= 60;
111 static const long SECONDS_PER_DAY
= 86400l;
113 static const long MILLISECONDS_PER_DAY
= 86400000l;
115 // this is the integral part of JDN of the midnight of Jan 1, 1970
116 // (i.e. JDN(Jan 1, 1970) = 2440587.5)
117 static const long EPOCH_JDN
= 2440587l;
119 // the date of JDN -0.5 (as we don't work with fractional parts, this is the
120 // reference date for us) is Nov 24, 4714BC
121 static const int JDN_0_YEAR
= -4713;
122 static const int JDN_0_MONTH
= wxDateTime::Nov
;
123 static const int JDN_0_DAY
= 24;
125 // the constants used for JDN calculations
126 static const long JDN_OFFSET
= 32046l;
127 static const long DAYS_PER_5_MONTHS
= 153l;
128 static const long DAYS_PER_4_YEARS
= 1461l;
129 static const long DAYS_PER_400_YEARS
= 146097l;
131 // this array contains the cumulated number of days in all previous months for
132 // normal and leap years
133 static const wxDateTime::wxDateTime_t gs_cumulatedDays
[2][MONTHS_IN_YEAR
] =
135 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
136 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
139 // ----------------------------------------------------------------------------
141 // ----------------------------------------------------------------------------
143 // a critical section is needed to protect GetTimeZone() static
144 // variable in MT case
146 wxCriticalSection gs_critsectTimezone
;
147 #endif // wxUSE_THREADS
149 // ----------------------------------------------------------------------------
151 // ----------------------------------------------------------------------------
153 // get the number of days in the given month of the given year
155 wxDateTime::wxDateTime_t
GetNumOfDaysInMonth(int year
, wxDateTime::Month month
)
157 // the number of days in month in Julian/Gregorian calendar: the first line
158 // is for normal years, the second one is for the leap ones
159 static wxDateTime::wxDateTime_t daysInMonth
[2][MONTHS_IN_YEAR
] =
161 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
162 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
165 return daysInMonth
[wxDateTime::IsLeapYear(year
)][month
];
168 // ensure that the timezone variable is set by calling localtime
169 static int GetTimeZone()
171 // set to TRUE when the timezone is set
172 static bool s_timezoneSet
= FALSE
;
174 wxCRIT_SECT_LOCKER(lock
, gs_critsectTimezone
);
176 if ( !s_timezoneSet
)
178 // just call localtime() instead of figuring out whether this system
179 // supports tzset(), _tzset() or something else
183 s_timezoneSet
= TRUE
;
186 return (int)WX_TIMEZONE
;
189 // return the integral part of the JDN for the midnight of the given date (to
190 // get the real JDN you need to add 0.5, this is, in fact, JDN of the
191 // noon of the previous day)
192 static long GetTruncatedJDN(wxDateTime::wxDateTime_t day
,
193 wxDateTime::Month mon
,
196 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
198 // check the date validity
200 (year
> JDN_0_YEAR
) ||
201 ((year
== JDN_0_YEAR
) && (mon
> JDN_0_MONTH
)) ||
202 ((year
== JDN_0_YEAR
) && (mon
== JDN_0_MONTH
) && (day
>= JDN_0_DAY
)),
203 _T("date out of range - can't convert to JDN")
206 // make the year positive to avoid problems with negative numbers division
209 // months are counted from March here
211 if ( mon
>= wxDateTime::Mar
)
221 // now we can simply add all the contributions together
222 return ((year
/ 100) * DAYS_PER_400_YEARS
) / 4
223 + ((year
% 100) * DAYS_PER_4_YEARS
) / 4
224 + (month
* DAYS_PER_5_MONTHS
+ 2) / 5
229 // this function is a wrapper around strftime(3)
230 static wxString
CallStrftime(const wxChar
*format
, const tm
* tm
)
233 if ( !wxStrftime(buf
, WXSIZEOF(buf
), format
, tm
) )
235 // buffer is too small?
236 wxFAIL_MSG(_T("strftime() failed"));
239 return wxString(buf
);
242 // if year and/or month have invalid values, replace them with the current ones
243 static void ReplaceDefaultYearMonthWithCurrent(int *year
,
244 wxDateTime::Month
*month
)
246 struct tm
*tmNow
= NULL
;
248 if ( *year
== wxDateTime::Inv_Year
)
250 tmNow
= wxDateTime::GetTmNow();
252 *year
= 1900 + tmNow
->tm_year
;
255 if ( *month
== wxDateTime::Inv_Month
)
258 tmNow
= wxDateTime::GetTmNow();
260 *month
= (wxDateTime::Month
)tmNow
->tm_mon
;
264 // fll the struct tm with default values
265 static void InitTm(struct tm
& tm
)
267 // struct tm may have etxra fields (undocumented and with unportable
268 // names) which, nevertheless, must be set to 0
269 memset(&tm
, 0, sizeof(struct tm
));
271 tm
.tm_mday
= 1; // mday 0 is invalid
272 tm
.tm_year
= 76; // any valid year
273 tm
.tm_isdst
= -1; // auto determine
279 // return the month if the string is a month name or Inv_Month otherwise
280 static wxDateTime::Month
GetMonthFromName(const wxString
& name
, int flags
)
282 wxDateTime::Month mon
;
283 for ( mon
= wxDateTime::Jan
; mon
< wxDateTime::Inv_Month
; wxNextMonth(mon
) )
285 // case-insensitive comparison either one of or with both abbreviated
287 if ( flags
& wxDateTime::Name_Full
)
289 if ( name
.CmpNoCase(wxDateTime::
290 GetMonthName(mon
, wxDateTime::Name_Full
)) == 0 )
296 if ( flags
& wxDateTime::Name_Abbr
)
298 if ( name
.CmpNoCase(wxDateTime::
299 GetMonthName(mon
, wxDateTime::Name_Abbr
)) == 0 )
309 // return the weekday if the string is a weekday name or Inv_WeekDay otherwise
310 static wxDateTime::WeekDay
GetWeekDayFromName(const wxString
& name
, int flags
)
312 wxDateTime::WeekDay wd
;
313 for ( wd
= wxDateTime::Sun
; wd
< wxDateTime::Inv_WeekDay
; wxNextWDay(wd
) )
315 // case-insensitive comparison either one of or with both abbreviated
317 if ( flags
& wxDateTime::Name_Full
)
319 if ( name
.CmpNoCase(wxDateTime::
320 GetWeekDayName(wd
, wxDateTime::Name_Full
)) == 0 )
326 if ( flags
& wxDateTime::Name_Abbr
)
328 if ( name
.CmpNoCase(wxDateTime::
329 GetWeekDayName(wd
, wxDateTime::Name_Abbr
)) == 0 )
339 // scans all digits and returns the resulting number
340 static bool GetNumericToken(const wxChar
*& p
, unsigned long *number
)
343 while ( wxIsdigit(*p
) )
348 return !!s
&& s
.ToULong(number
);
351 // scans all alphabetic characters and returns the resulting string
352 static wxString
GetAlphaToken(const wxChar
*& p
)
355 while ( wxIsalpha(*p
) )
363 // ============================================================================
364 // implementation of wxDateTime
365 // ============================================================================
367 // ----------------------------------------------------------------------------
369 // ----------------------------------------------------------------------------
371 wxDateTime::Country
wxDateTime::ms_country
= wxDateTime::Country_Unknown
;
372 wxDateTime
wxDateTime::ms_InvDateTime
;
374 // ----------------------------------------------------------------------------
376 // ----------------------------------------------------------------------------
380 year
= (wxDateTime_t
)wxDateTime::Inv_Year
;
381 mon
= wxDateTime::Inv_Month
;
383 hour
= min
= sec
= msec
= 0;
384 wday
= wxDateTime::Inv_WeekDay
;
387 wxDateTime::Tm::Tm(const struct tm
& tm
, const TimeZone
& tz
)
395 mon
= (wxDateTime::Month
)tm
.tm_mon
;
396 year
= 1900 + tm
.tm_year
;
401 bool wxDateTime::Tm::IsValid() const
403 // we allow for the leap seconds, although we don't use them (yet)
404 return (year
!= wxDateTime::Inv_Year
) && (mon
!= wxDateTime::Inv_Month
) &&
405 (mday
<= GetNumOfDaysInMonth(year
, mon
)) &&
406 (hour
< 24) && (min
< 60) && (sec
< 62) && (msec
< 1000);
409 void wxDateTime::Tm::ComputeWeekDay()
411 // compute the week day from day/month/year: we use the dumbest algorithm
412 // possible: just compute our JDN and then use the (simple to derive)
413 // formula: weekday = (JDN + 1.5) % 7
414 wday
= (wxDateTime::WeekDay
)(GetTruncatedJDN(mday
, mon
, year
) + 2) % 7;
417 void wxDateTime::Tm::AddMonths(int monDiff
)
419 // normalize the months field
420 while ( monDiff
< -mon
)
424 monDiff
+= MONTHS_IN_YEAR
;
427 while ( monDiff
+ mon
> MONTHS_IN_YEAR
)
431 monDiff
-= MONTHS_IN_YEAR
;
434 mon
= (wxDateTime::Month
)(mon
+ monDiff
);
436 wxASSERT_MSG( mon
>= 0 && mon
< MONTHS_IN_YEAR
, _T("logic error") );
439 void wxDateTime::Tm::AddDays(int dayDiff
)
441 // normalize the days field
447 mday
+= GetNumOfDaysInMonth(year
, mon
);
450 while ( mday
> GetNumOfDaysInMonth(year
, mon
) )
452 mday
-= GetNumOfDaysInMonth(year
, mon
);
457 wxASSERT_MSG( mday
> 0 && mday
<= GetNumOfDaysInMonth(year
, mon
),
461 // ----------------------------------------------------------------------------
463 // ----------------------------------------------------------------------------
465 wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz
)
469 case wxDateTime::Local
:
470 // get the offset from C RTL: it returns the difference GMT-local
471 // while we want to have the offset _from_ GMT, hence the '-'
472 m_offset
= -GetTimeZone();
475 case wxDateTime::GMT_12
:
476 case wxDateTime::GMT_11
:
477 case wxDateTime::GMT_10
:
478 case wxDateTime::GMT_9
:
479 case wxDateTime::GMT_8
:
480 case wxDateTime::GMT_7
:
481 case wxDateTime::GMT_6
:
482 case wxDateTime::GMT_5
:
483 case wxDateTime::GMT_4
:
484 case wxDateTime::GMT_3
:
485 case wxDateTime::GMT_2
:
486 case wxDateTime::GMT_1
:
487 m_offset
= -3600*(wxDateTime::GMT0
- tz
);
490 case wxDateTime::GMT0
:
491 case wxDateTime::GMT1
:
492 case wxDateTime::GMT2
:
493 case wxDateTime::GMT3
:
494 case wxDateTime::GMT4
:
495 case wxDateTime::GMT5
:
496 case wxDateTime::GMT6
:
497 case wxDateTime::GMT7
:
498 case wxDateTime::GMT8
:
499 case wxDateTime::GMT9
:
500 case wxDateTime::GMT10
:
501 case wxDateTime::GMT11
:
502 case wxDateTime::GMT12
:
503 m_offset
= 3600*(tz
- wxDateTime::GMT0
);
506 case wxDateTime::A_CST
:
507 // Central Standard Time in use in Australia = UTC + 9.5
508 m_offset
= 60l*(9*60 + 30);
512 wxFAIL_MSG( _T("unknown time zone") );
516 // ----------------------------------------------------------------------------
518 // ----------------------------------------------------------------------------
521 bool wxDateTime::IsLeapYear(int year
, wxDateTime::Calendar cal
)
523 if ( year
== Inv_Year
)
524 year
= GetCurrentYear();
526 if ( cal
== Gregorian
)
528 // in Gregorian calendar leap years are those divisible by 4 except
529 // those divisible by 100 unless they're also divisible by 400
530 // (in some countries, like Russia and Greece, additional corrections
531 // exist, but they won't manifest themselves until 2700)
532 return (year
% 4 == 0) && ((year
% 100 != 0) || (year
% 400 == 0));
534 else if ( cal
== Julian
)
536 // in Julian calendar the rule is simpler
537 return year
% 4 == 0;
541 wxFAIL_MSG(_T("unknown calendar"));
548 int wxDateTime::GetCentury(int year
)
550 return year
> 0 ? year
/ 100 : year
/ 100 - 1;
554 int wxDateTime::ConvertYearToBC(int year
)
557 return year
> 0 ? year
: year
- 1;
561 int wxDateTime::GetCurrentYear(wxDateTime::Calendar cal
)
566 return Now().GetYear();
569 wxFAIL_MSG(_T("TODO"));
573 wxFAIL_MSG(_T("unsupported calendar"));
581 wxDateTime::Month
wxDateTime::GetCurrentMonth(wxDateTime::Calendar cal
)
586 return Now().GetMonth();
590 wxFAIL_MSG(_T("TODO"));
594 wxFAIL_MSG(_T("unsupported calendar"));
602 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(int year
, Calendar cal
)
604 if ( year
== Inv_Year
)
606 // take the current year if none given
607 year
= GetCurrentYear();
614 return IsLeapYear(year
) ? 366 : 365;
618 wxFAIL_MSG(_T("unsupported calendar"));
626 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(wxDateTime::Month month
,
628 wxDateTime::Calendar cal
)
630 wxCHECK_MSG( month
< MONTHS_IN_YEAR
, 0, _T("invalid month") );
632 if ( cal
== Gregorian
|| cal
== Julian
)
634 if ( year
== Inv_Year
)
636 // take the current year if none given
637 year
= GetCurrentYear();
640 return GetNumOfDaysInMonth(year
, month
);
644 wxFAIL_MSG(_T("unsupported calendar"));
651 wxString
wxDateTime::GetMonthName(wxDateTime::Month month
,
652 wxDateTime::NameFlags flags
)
654 wxCHECK_MSG( month
!= Inv_Month
, _T(""), _T("invalid month") );
656 // notice that we must set all the fields to avoid confusing libc (GNU one
657 // gets confused to a crash if we don't do this)
662 return CallStrftime(flags
== Name_Abbr
? _T("%b") : _T("%B"), &tm
);
666 wxString
wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday
,
667 wxDateTime::NameFlags flags
)
669 wxCHECK_MSG( wday
!= Inv_WeekDay
, _T(""), _T("invalid weekday") );
671 // take some arbitrary Sunday
678 // and offset it by the number of days needed to get the correct wday
681 // call mktime() to normalize it...
684 // ... and call strftime()
685 return CallStrftime(flags
== Name_Abbr
? _T("%a") : _T("%A"), &tm
);
689 void wxDateTime::GetAmPmStrings(wxString
*am
, wxString
*pm
)
695 *am
= CallStrftime(_T("%p"), &tm
);
700 *pm
= CallStrftime(_T("%p"), &tm
);
704 // ----------------------------------------------------------------------------
705 // Country stuff: date calculations depend on the country (DST, work days,
706 // ...), so we need to know which rules to follow.
707 // ----------------------------------------------------------------------------
710 wxDateTime::Country
wxDateTime::GetCountry()
712 // TODO use LOCALE_ICOUNTRY setting under Win32
714 if ( ms_country
== Country_Unknown
)
716 // try to guess from the time zone name
717 time_t t
= time(NULL
);
718 struct tm
*tm
= localtime(&t
);
720 wxString tz
= CallStrftime(_T("%Z"), tm
);
721 if ( tz
== _T("WET") || tz
== _T("WEST") )
725 else if ( tz
== _T("CET") || tz
== _T("CEST") )
727 ms_country
= Country_EEC
;
729 else if ( tz
== _T("MSK") || tz
== _T("MSD") )
733 else if ( tz
== _T("AST") || tz
== _T("ADT") ||
734 tz
== _T("EST") || tz
== _T("EDT") ||
735 tz
== _T("CST") || tz
== _T("CDT") ||
736 tz
== _T("MST") || tz
== _T("MDT") ||
737 tz
== _T("PST") || tz
== _T("PDT") )
743 // well, choose a default one
752 void wxDateTime::SetCountry(wxDateTime::Country country
)
754 ms_country
= country
;
758 bool wxDateTime::IsWestEuropeanCountry(Country country
)
760 if ( country
== Country_Default
)
762 country
= GetCountry();
765 return (Country_WesternEurope_Start
<= country
) &&
766 (country
<= Country_WesternEurope_End
);
769 // ----------------------------------------------------------------------------
770 // DST calculations: we use 3 different rules for the West European countries,
771 // USA and for the rest of the world. This is undoubtedly false for many
772 // countries, but I lack the necessary info (and the time to gather it),
773 // please add the other rules here!
774 // ----------------------------------------------------------------------------
777 bool wxDateTime::IsDSTApplicable(int year
, Country country
)
779 if ( year
== Inv_Year
)
781 // take the current year if none given
782 year
= GetCurrentYear();
785 if ( country
== Country_Default
)
787 country
= GetCountry();
794 // DST was first observed in the US and UK during WWI, reused
795 // during WWII and used again since 1966
796 return year
>= 1966 ||
797 (year
>= 1942 && year
<= 1945) ||
798 (year
== 1918 || year
== 1919);
801 // assume that it started after WWII
807 wxDateTime
wxDateTime::GetBeginDST(int year
, Country country
)
809 if ( year
== Inv_Year
)
811 // take the current year if none given
812 year
= GetCurrentYear();
815 if ( country
== Country_Default
)
817 country
= GetCountry();
820 if ( !IsDSTApplicable(year
, country
) )
822 return ms_InvDateTime
;
827 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
829 // DST begins at 1 a.m. GMT on the last Sunday of March
830 if ( !dt
.SetToLastWeekDay(Sun
, Mar
, year
) )
833 wxFAIL_MSG( _T("no last Sunday in March?") );
836 dt
+= wxTimeSpan::Hours(1);
840 else switch ( country
)
847 // don't know for sure - assume it was in effect all year
852 dt
.Set(1, Jan
, year
);
856 // DST was installed Feb 2, 1942 by the Congress
857 dt
.Set(2, Feb
, year
);
860 // Oil embargo changed the DST period in the US
862 dt
.Set(6, Jan
, 1974);
866 dt
.Set(23, Feb
, 1975);
870 // before 1986, DST begun on the last Sunday of April, but
871 // in 1986 Reagan changed it to begin at 2 a.m. of the
872 // first Sunday in April
875 if ( !dt
.SetToLastWeekDay(Sun
, Apr
, year
) )
878 wxFAIL_MSG( _T("no first Sunday in April?") );
883 if ( !dt
.SetToWeekDay(Sun
, 1, Apr
, year
) )
886 wxFAIL_MSG( _T("no first Sunday in April?") );
890 dt
+= wxTimeSpan::Hours(2);
892 // TODO what about timezone??
898 // assume Mar 30 as the start of the DST for the rest of the world
899 // - totally bogus, of course
900 dt
.Set(30, Mar
, year
);
907 wxDateTime
wxDateTime::GetEndDST(int year
, Country country
)
909 if ( year
== Inv_Year
)
911 // take the current year if none given
912 year
= GetCurrentYear();
915 if ( country
== Country_Default
)
917 country
= GetCountry();
920 if ( !IsDSTApplicable(year
, country
) )
922 return ms_InvDateTime
;
927 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
929 // DST ends at 1 a.m. GMT on the last Sunday of October
930 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
932 // weirder and weirder...
933 wxFAIL_MSG( _T("no last Sunday in October?") );
936 dt
+= wxTimeSpan::Hours(1);
940 else switch ( country
)
947 // don't know for sure - assume it was in effect all year
951 dt
.Set(31, Dec
, year
);
955 // the time was reset after the end of the WWII
956 dt
.Set(30, Sep
, year
);
960 // DST ends at 2 a.m. on the last Sunday of October
961 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
963 // weirder and weirder...
964 wxFAIL_MSG( _T("no last Sunday in October?") );
967 dt
+= wxTimeSpan::Hours(2);
969 // TODO what about timezone??
974 // assume October 26th as the end of the DST - totally bogus too
975 dt
.Set(26, Oct
, year
);
981 // ----------------------------------------------------------------------------
982 // constructors and assignment operators
983 // ----------------------------------------------------------------------------
985 // the values in the tm structure contain the local time
986 wxDateTime
& wxDateTime::Set(const struct tm
& tm
)
988 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
991 time_t timet
= mktime(&tm2
);
993 if ( timet
== (time_t)-1 )
995 // mktime() rather unintuitively fails for Jan 1, 1970 if the hour is
996 // less than timezone - try to make it work for this case
997 if ( tm2
.tm_year
== 70 && tm2
.tm_mon
== 0 && tm2
.tm_mday
== 1 )
999 // add timezone to make sure that date is in range
1000 tm2
.tm_sec
-= GetTimeZone();
1002 timet
= mktime(&tm2
);
1003 if ( timet
!= (time_t)-1 )
1005 timet
+= GetTimeZone();
1011 wxFAIL_MSG( _T("mktime() failed") );
1013 return ms_InvDateTime
;
1021 wxDateTime
& wxDateTime::Set(wxDateTime_t hour
,
1022 wxDateTime_t minute
,
1023 wxDateTime_t second
,
1024 wxDateTime_t millisec
)
1026 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1028 // we allow seconds to be 61 to account for the leap seconds, even if we
1029 // don't use them really
1030 wxCHECK_MSG( hour
< 24 && second
< 62 && minute
< 60 && millisec
< 1000,
1032 _T("Invalid time in wxDateTime::Set()") );
1034 // get the current date from system
1035 time_t timet
= GetTimeNow();
1036 struct tm
*tm
= localtime(&timet
);
1038 wxCHECK_MSG( tm
, ms_InvDateTime
, _T("localtime() failed") );
1042 tm
->tm_min
= minute
;
1043 tm
->tm_sec
= second
;
1047 // and finally adjust milliseconds
1048 return SetMillisecond(millisec
);
1051 wxDateTime
& wxDateTime::Set(wxDateTime_t day
,
1055 wxDateTime_t minute
,
1056 wxDateTime_t second
,
1057 wxDateTime_t millisec
)
1059 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1061 wxCHECK_MSG( hour
< 24 && second
< 62 && minute
< 60 && millisec
< 1000,
1063 _T("Invalid time in wxDateTime::Set()") );
1065 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1067 wxCHECK_MSG( (0 < day
) && (day
<= GetNumberOfDays(month
, year
)),
1069 _T("Invalid date in wxDateTime::Set()") );
1071 // the range of time_t type (inclusive)
1072 static const int yearMinInRange
= 1970;
1073 static const int yearMaxInRange
= 2037;
1075 // test only the year instead of testing for the exact end of the Unix
1076 // time_t range - it doesn't bring anything to do more precise checks
1077 if ( year
>= yearMinInRange
&& year
<= yearMaxInRange
)
1079 // use the standard library version if the date is in range - this is
1080 // probably more efficient than our code
1082 tm
.tm_year
= year
- 1900;
1088 tm
.tm_isdst
= -1; // mktime() will guess it
1092 // and finally adjust milliseconds
1093 return SetMillisecond(millisec
);
1097 // do time calculations ourselves: we want to calculate the number of
1098 // milliseconds between the given date and the epoch
1100 // get the JDN for the midnight of this day
1101 m_time
= GetTruncatedJDN(day
, month
, year
);
1102 m_time
-= EPOCH_JDN
;
1103 m_time
*= SECONDS_PER_DAY
* TIME_T_FACTOR
;
1105 // JDN corresponds to GMT, we take localtime
1106 Add(wxTimeSpan(hour
, minute
, second
+ GetTimeZone(), millisec
));
1112 wxDateTime
& wxDateTime::Set(double jdn
)
1114 // so that m_time will be 0 for the midnight of Jan 1, 1970 which is jdn
1116 jdn
-= EPOCH_JDN
+ 0.5;
1118 jdn
*= MILLISECONDS_PER_DAY
;
1125 // ----------------------------------------------------------------------------
1126 // time_t <-> broken down time conversions
1127 // ----------------------------------------------------------------------------
1129 wxDateTime::Tm
wxDateTime::GetTm(const TimeZone
& tz
) const
1131 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1133 time_t time
= GetTicks();
1134 if ( time
!= (time_t)-1 )
1136 // use C RTL functions
1138 if ( tz
.GetOffset() == -GetTimeZone() )
1140 // we are working with local time
1141 tm
= localtime(&time
);
1143 // should never happen
1144 wxCHECK_MSG( tm
, Tm(), _T("gmtime() failed") );
1148 time
+= tz
.GetOffset();
1153 // should never happen
1154 wxCHECK_MSG( tm
, Tm(), _T("gmtime() failed") );
1158 tm
= (struct tm
*)NULL
;
1166 //else: use generic code below
1169 // remember the time and do the calculations with the date only - this
1170 // eliminates rounding errors of the floating point arithmetics
1172 wxLongLong timeMidnight
= m_time
+ tz
.GetOffset() * 1000;
1174 long timeOnly
= (timeMidnight
% MILLISECONDS_PER_DAY
).ToLong();
1176 // we want to always have positive time and timeMidnight to be really
1177 // the midnight before it
1180 timeOnly
= MILLISECONDS_PER_DAY
+ timeOnly
;
1183 timeMidnight
-= timeOnly
;
1185 // calculate the Gregorian date from JDN for the midnight of our date:
1186 // this will yield day, month (in 1..12 range) and year
1188 // actually, this is the JDN for the noon of the previous day
1189 long jdn
= (timeMidnight
/ MILLISECONDS_PER_DAY
).ToLong() + EPOCH_JDN
;
1191 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
1193 wxASSERT_MSG( jdn
> -2, _T("JDN out of range") );
1195 // calculate the century
1196 int temp
= (jdn
+ JDN_OFFSET
) * 4 - 1;
1197 int century
= temp
/ DAYS_PER_400_YEARS
;
1199 // then the year and day of year (1 <= dayOfYear <= 366)
1200 temp
= ((temp
% DAYS_PER_400_YEARS
) / 4) * 4 + 3;
1201 int year
= (century
* 100) + (temp
/ DAYS_PER_4_YEARS
);
1202 int dayOfYear
= (temp
% DAYS_PER_4_YEARS
) / 4 + 1;
1204 // and finally the month and day of the month
1205 temp
= dayOfYear
* 5 - 3;
1206 int month
= temp
/ DAYS_PER_5_MONTHS
;
1207 int day
= (temp
% DAYS_PER_5_MONTHS
) / 5 + 1;
1209 // month is counted from March - convert to normal
1220 // year is offset by 4800
1223 // check that the algorithm gave us something reasonable
1224 wxASSERT_MSG( (0 < month
) && (month
<= 12), _T("invalid month") );
1225 wxASSERT_MSG( (1 <= day
) && (day
< 32), _T("invalid day") );
1226 wxASSERT_MSG( (INT_MIN
<= year
) && (year
<= INT_MAX
),
1227 _T("year range overflow") );
1229 // construct Tm from these values
1231 tm
.year
= (int)year
;
1232 tm
.mon
= (Month
)(month
- 1); // algorithm yields 1 for January, not 0
1233 tm
.mday
= (wxDateTime_t
)day
;
1234 tm
.msec
= timeOnly
% 1000;
1235 timeOnly
-= tm
.msec
;
1236 timeOnly
/= 1000; // now we have time in seconds
1238 tm
.sec
= timeOnly
% 60;
1240 timeOnly
/= 60; // now we have time in minutes
1242 tm
.min
= timeOnly
% 60;
1245 tm
.hour
= timeOnly
/ 60;
1250 wxDateTime
& wxDateTime::SetYear(int year
)
1252 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1261 wxDateTime
& wxDateTime::SetMonth(Month month
)
1263 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1272 wxDateTime
& wxDateTime::SetDay(wxDateTime_t mday
)
1274 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1283 wxDateTime
& wxDateTime::SetHour(wxDateTime_t hour
)
1285 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1294 wxDateTime
& wxDateTime::SetMinute(wxDateTime_t min
)
1296 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1305 wxDateTime
& wxDateTime::SetSecond(wxDateTime_t sec
)
1307 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1316 wxDateTime
& wxDateTime::SetMillisecond(wxDateTime_t millisecond
)
1318 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1320 // we don't need to use GetTm() for this one
1321 m_time
-= m_time
% 1000l;
1322 m_time
+= millisecond
;
1327 // ----------------------------------------------------------------------------
1328 // wxDateTime arithmetics
1329 // ----------------------------------------------------------------------------
1331 wxDateTime
& wxDateTime::Add(const wxDateSpan
& diff
)
1335 tm
.year
+= diff
.GetYears();
1336 tm
.AddMonths(diff
.GetMonths());
1337 tm
.AddDays(diff
.GetTotalDays());
1344 // ----------------------------------------------------------------------------
1345 // Weekday and monthday stuff
1346 // ----------------------------------------------------------------------------
1348 wxDateTime
& wxDateTime::SetToLastMonthDay(Month month
,
1351 // take the current month/year if none specified
1352 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1354 return Set(GetNumOfDaysInMonth(year
, month
), month
, year
);
1357 wxDateTime
& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday
)
1359 wxCHECK_MSG( weekday
!= Inv_WeekDay
, ms_InvDateTime
, _T("invalid weekday") );
1361 WeekDay wdayThis
= GetWeekDay();
1362 if ( weekday
== wdayThis
)
1367 else if ( weekday
< wdayThis
)
1369 return Substract(wxTimeSpan::Days(wdayThis
- weekday
));
1371 else // weekday > wdayThis
1373 return Add(wxTimeSpan::Days(weekday
- wdayThis
));
1377 wxDateTime
& wxDateTime::SetToNextWeekDay(WeekDay weekday
)
1379 wxCHECK_MSG( weekday
!= Inv_WeekDay
, ms_InvDateTime
, _T("invalid weekday") );
1382 WeekDay wdayThis
= GetWeekDay();
1383 if ( weekday
== wdayThis
)
1388 else if ( weekday
< wdayThis
)
1390 // need to advance a week
1391 diff
= 7 - (wdayThis
- weekday
);
1393 else // weekday > wdayThis
1395 diff
= weekday
- wdayThis
;
1398 return Add(wxTimeSpan::Days(diff
));
1401 wxDateTime
& wxDateTime::SetToPrevWeekDay(WeekDay weekday
)
1403 wxCHECK_MSG( weekday
!= Inv_WeekDay
, ms_InvDateTime
, _T("invalid weekday") );
1406 WeekDay wdayThis
= GetWeekDay();
1407 if ( weekday
== wdayThis
)
1412 else if ( weekday
> wdayThis
)
1414 // need to go to previous week
1415 diff
= 7 - (weekday
- wdayThis
);
1417 else // weekday < wdayThis
1419 diff
= wdayThis
- weekday
;
1422 return Substract(wxTimeSpan::Days(diff
));
1425 bool wxDateTime::SetToWeekDay(WeekDay weekday
,
1430 wxCHECK_MSG( weekday
!= Inv_WeekDay
, FALSE
, _T("invalid weekday") );
1432 // we don't check explicitly that -5 <= n <= 5 because we will return FALSE
1433 // anyhow in such case - but may be should still give an assert for it?
1435 // take the current month/year if none specified
1436 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1440 // TODO this probably could be optimised somehow...
1444 // get the first day of the month
1445 dt
.Set(1, month
, year
);
1448 WeekDay wdayFirst
= dt
.GetWeekDay();
1450 // go to the first weekday of the month
1451 int diff
= weekday
- wdayFirst
;
1455 // add advance n-1 weeks more
1458 dt
+= wxDateSpan::Days(diff
);
1460 else // count from the end of the month
1462 // get the last day of the month
1463 dt
.SetToLastMonthDay(month
, year
);
1466 WeekDay wdayLast
= dt
.GetWeekDay();
1468 // go to the last weekday of the month
1469 int diff
= wdayLast
- weekday
;
1473 // and rewind n-1 weeks from there
1476 dt
-= wxDateSpan::Days(diff
);
1479 // check that it is still in the same month
1480 if ( dt
.GetMonth() == month
)
1488 // no such day in this month
1493 wxDateTime::wxDateTime_t
wxDateTime::GetDayOfYear(const TimeZone
& tz
) const
1497 return gs_cumulatedDays
[IsLeapYear(tm
.year
)][tm
.mon
] + tm
.mday
;
1500 wxDateTime::wxDateTime_t
wxDateTime::GetWeekOfYear(const TimeZone
& tz
) const
1503 // the first week of the year is the one which contains Jan, 4 (according
1504 // to ISO standard rule), so the year day N0 = 4 + 7*W always lies in the
1505 // week W+1. As any day N = 7*W + 4 + (N - 4)%7, it lies in the same week
1506 // as N0 or in the next one.
1508 // TODO this surely may be optimized - I got confused while writing it
1510 wxDateTime_t nDayInYear
= GetDayOfYear(tz
);
1512 // the week day of the day lying in the first week
1513 WeekDay wdayStart
= wxDateTime(4, Jan
, GetYear()).GetWeekDay();
1515 wxDateTime_t week
= (nDayInYear
- 4) / 7 + 1;
1517 // notice that Sunday shoould be counted as 7, not 0 here!
1518 if ( ((nDayInYear
- 4) % 7) + (!wdayStart
? 7 : wdayStart
) > 7 )
1524 #else // this seems to be a bit simpler and I believe is also correct
1525 return (WeekDay
)((GetDayOfYear() - (GetWeekDay() - 1 + 7) % 7 + 7) / 7);
1529 wxDateTime::wxDateTime_t
wxDateTime::GetWeekOfMonth(const TimeZone
& tz
) const
1533 wxDateTime
dt(*this);
1538 dt
-= wxTimeSpan::Week();
1540 while ( dt
.GetMonth(tz
) == GetMonth(tz
) );
1545 wxDateTime
& wxDateTime::SetToYearDay(wxDateTime::wxDateTime_t yday
)
1547 int year
= GetYear();
1548 wxCHECK_MSG( (0 < yday
) && (yday
< GetNumberOfDays(year
)),
1549 ms_InvDateTime
, _T("invalid year day") );
1551 bool isLeap
= IsLeapYear(year
);
1552 for ( Month mon
= Jan
; mon
< Inv_Month
; wxNextMonth(mon
) )
1554 // for Dec, we can't compare with gs_cumulatedDays[mon + 1], but we
1555 // don't need it neither - because of the CHECK above we know that
1556 // yday lies in December then
1557 if ( (mon
== Dec
) || (yday
< gs_cumulatedDays
[isLeap
][mon
+ 1]) )
1559 Set(yday
- gs_cumulatedDays
[isLeap
][mon
], mon
, year
);
1568 // ----------------------------------------------------------------------------
1569 // Julian day number conversion and related stuff
1570 // ----------------------------------------------------------------------------
1572 double wxDateTime::GetJulianDayNumber() const
1574 // JDN are always expressed for the GMT dates
1575 Tm
tm(ToTimezone(GMT0
).GetTm(GMT0
));
1577 double result
= GetTruncatedJDN(tm
.mday
, tm
.mon
, tm
.year
);
1579 // add the part GetTruncatedJDN() neglected
1582 // and now add the time: 86400 sec = 1 JDN
1583 return result
+ ((double)(60*(60*tm
.hour
+ tm
.min
) + tm
.sec
)) / 86400;
1586 double wxDateTime::GetRataDie() const
1588 // March 1 of the year 0 is Rata Die day -306 and JDN 1721119.5
1589 return GetJulianDayNumber() - 1721119.5 - 306;
1592 // ----------------------------------------------------------------------------
1593 // timezone and DST stuff
1594 // ----------------------------------------------------------------------------
1596 int wxDateTime::IsDST(wxDateTime::Country country
) const
1598 wxCHECK_MSG( country
== Country_Default
, -1,
1599 _T("country support not implemented") );
1601 // use the C RTL for the dates in the standard range
1602 time_t timet
= GetTicks();
1603 if ( timet
!= (time_t)-1 )
1605 tm
*tm
= localtime(&timet
);
1607 wxCHECK_MSG( tm
, -1, _T("localtime() failed") );
1609 return tm
->tm_isdst
;
1613 int year
= GetYear();
1615 if ( !IsDSTApplicable(year
, country
) )
1617 // no DST time in this year in this country
1621 return IsBetween(GetBeginDST(year
, country
), GetEndDST(year
, country
));
1625 wxDateTime
& wxDateTime::MakeTimezone(const TimeZone
& tz
)
1627 int secDiff
= GetTimeZone() + tz
.GetOffset();
1629 // we need to know whether DST is or not in effect for this date
1632 // FIXME we assume that the DST is always shifted by 1 hour
1636 return Substract(wxTimeSpan::Seconds(secDiff
));
1639 // ----------------------------------------------------------------------------
1640 // wxDateTime to/from text representations
1641 // ----------------------------------------------------------------------------
1643 wxString
wxDateTime::Format(const wxChar
*format
, const TimeZone
& tz
) const
1645 wxCHECK_MSG( format
, _T(""), _T("NULL format in wxDateTime::Format") );
1647 time_t time
= GetTicks();
1648 if ( time
!= (time_t)-1 )
1652 if ( tz
.GetOffset() == -GetTimeZone() )
1654 // we are working with local time
1655 tm
= localtime(&time
);
1657 // should never happen
1658 wxCHECK_MSG( tm
, wxEmptyString
, _T("localtime() failed") );
1662 time
+= tz
.GetOffset();
1668 // should never happen
1669 wxCHECK_MSG( tm
, wxEmptyString
, _T("gmtime() failed") );
1673 tm
= (struct tm
*)NULL
;
1679 return CallStrftime(format
, tm
);
1681 //else: use generic code below
1684 // we only parse ANSI C format specifications here, no POSIX 2
1685 // complications, no GNU extensions
1688 // used for calls to strftime() when we only deal with time
1689 struct tm tmTimeOnly
;
1690 tmTimeOnly
.tm_hour
= tm
.hour
;
1691 tmTimeOnly
.tm_min
= tm
.min
;
1692 tmTimeOnly
.tm_sec
= tm
.sec
;
1693 tmTimeOnly
.tm_wday
= 0;
1694 tmTimeOnly
.tm_yday
= 0;
1695 tmTimeOnly
.tm_mday
= 1; // any date will do
1696 tmTimeOnly
.tm_mon
= 0;
1697 tmTimeOnly
.tm_year
= 76;
1698 tmTimeOnly
.tm_isdst
= 0; // no DST, we adjust for tz ourselves
1700 wxString tmp
, res
, fmt
;
1701 for ( const wxChar
*p
= format
; *p
; p
++ )
1703 if ( *p
!= _T('%') )
1711 // set the default format
1714 case _T('Y'): // year has 4 digits
1718 case _T('j'): // day of year has 3 digits
1723 // it's either another valid format specifier in which case
1724 // the format is "%02d" (for all the rest) or we have the
1725 // field width preceding the format in which case it will
1726 // override the default format anyhow
1731 // start of the format specification
1734 case _T('a'): // a weekday name
1736 // second parameter should be TRUE for abbreviated names
1737 res
+= GetWeekDayName(tm
.GetWeekDay(),
1738 *p
== _T('a') ? Name_Abbr
: Name_Full
);
1741 case _T('b'): // a month name
1743 res
+= GetMonthName(tm
.mon
,
1744 *p
== _T('b') ? Name_Abbr
: Name_Full
);
1747 case _T('c'): // locale default date and time representation
1748 case _T('x'): // locale default date representation
1750 // the problem: there is no way to know what do these format
1751 // specifications correspond to for the current locale.
1753 // the solution: use a hack and still use strftime(): first
1754 // find the YEAR which is a year in the strftime() range (1970
1755 // - 2038) whose Jan 1 falls on the same week day as the Jan 1
1756 // of the real year. Then make a copy of the format and
1757 // replace all occurences of YEAR in it with some unique
1758 // string not appearing anywhere else in it, then use
1759 // strftime() to format the date in year YEAR and then replace
1760 // YEAR back by the real year and the unique replacement
1761 // string back with YEAR. Notice that "all occurences of YEAR"
1762 // means all occurences of 4 digit as well as 2 digit form!
1764 // the bugs: we assume that neither of %c nor %x contains any
1765 // fields which may change between the YEAR and real year. For
1766 // example, the week number (%U, %W) and the day number (%j)
1767 // will change if one of these years is leap and the other one
1770 // find the YEAR: normally, for any year X, Jan 1 or the
1771 // year X + 28 is the same weekday as Jan 1 of X (because
1772 // the weekday advances by 1 for each normal X and by 2
1773 // for each leap X, hence by 5 every 4 years or by 35
1774 // which is 0 mod 7 every 28 years) but this rule breaks
1775 // down if there are years between X and Y which are
1776 // divisible by 4 but not leap (i.e. divisible by 100 but
1777 // not 400), hence the correction.
1779 int yearReal
= GetYear(tz
);
1780 int mod28
= yearReal
% 28;
1782 // be careful to not go too far - we risk to leave the
1787 year
= 1988 + mod28
; // 1988 == 0 (mod 28)
1791 year
= 1970 + mod28
- 10; // 1970 == 10 (mod 28)
1794 int nCentury
= year
/ 100,
1795 nCenturyReal
= yearReal
/ 100;
1797 // need to adjust for the years divisble by 400 which are
1798 // not leap but are counted like leap ones if we just take
1799 // the number of centuries in between for nLostWeekDays
1800 int nLostWeekDays
= (nCentury
- nCenturyReal
) -
1801 (nCentury
/ 4 - nCenturyReal
/ 4);
1803 // we have to gain back the "lost" weekdays: note that the
1804 // effect of this loop is to not do anything to
1805 // nLostWeekDays (which we won't use any more), but to
1806 // (indirectly) set the year correctly
1807 while ( (nLostWeekDays
% 7) != 0 )
1809 nLostWeekDays
+= year
++ % 4 ? 1 : 2;
1812 // at any rate, we couldn't go further than 1988 + 9 + 28!
1813 wxASSERT_MSG( year
< 2030,
1814 _T("logic error in wxDateTime::Format") );
1816 wxString strYear
, strYear2
;
1817 strYear
.Printf(_T("%d"), year
);
1818 strYear2
.Printf(_T("%d"), year
% 100);
1820 // find two strings not occuring in format (this is surely
1821 // not optimal way of doing it... improvements welcome!)
1822 wxString fmt
= format
;
1823 wxString replacement
= (wxChar
)-1;
1824 while ( fmt
.Find(replacement
) != wxNOT_FOUND
)
1826 replacement
<< (wxChar
)-1;
1829 wxString replacement2
= (wxChar
)-2;
1830 while ( fmt
.Find(replacement
) != wxNOT_FOUND
)
1832 replacement
<< (wxChar
)-2;
1835 // replace all occurences of year with it
1836 bool wasReplaced
= fmt
.Replace(strYear
, replacement
) > 0;
1838 wasReplaced
= fmt
.Replace(strYear2
, replacement2
) > 0;
1840 // use strftime() to format the same date but in supported
1843 // NB: we assume that strftime() doesn't check for the
1844 // date validity and will happily format the date
1845 // corresponding to Feb 29 of a non leap year (which
1846 // may happen if yearReal was leap and year is not)
1847 struct tm tmAdjusted
;
1849 tmAdjusted
.tm_hour
= tm
.hour
;
1850 tmAdjusted
.tm_min
= tm
.min
;
1851 tmAdjusted
.tm_sec
= tm
.sec
;
1852 tmAdjusted
.tm_wday
= tm
.GetWeekDay();
1853 tmAdjusted
.tm_yday
= GetDayOfYear();
1854 tmAdjusted
.tm_mday
= tm
.mday
;
1855 tmAdjusted
.tm_mon
= tm
.mon
;
1856 tmAdjusted
.tm_year
= year
- 1900;
1857 tmAdjusted
.tm_isdst
= 0; // no DST, already adjusted
1858 wxString str
= CallStrftime(*p
== _T('c') ? _T("%c")
1862 // now replace the occurence of 1999 with the real year
1863 wxString strYearReal
, strYearReal2
;
1864 strYearReal
.Printf(_T("%04d"), yearReal
);
1865 strYearReal2
.Printf(_T("%02d"), yearReal
% 100);
1866 str
.Replace(strYear
, strYearReal
);
1867 str
.Replace(strYear2
, strYearReal2
);
1869 // and replace back all occurences of replacement string
1872 str
.Replace(replacement2
, strYear2
);
1873 str
.Replace(replacement
, strYear
);
1880 case _T('d'): // day of a month (01-31)
1881 res
+= wxString::Format(fmt
, tm
.mday
);
1884 case _T('H'): // hour in 24h format (00-23)
1885 res
+= wxString::Format(fmt
, tm
.hour
);
1888 case _T('I'): // hour in 12h format (01-12)
1890 // 24h -> 12h, 0h -> 12h too
1891 int hour12
= tm
.hour
> 12 ? tm
.hour
- 12
1892 : tm
.hour
? tm
.hour
: 12;
1893 res
+= wxString::Format(fmt
, hour12
);
1897 case _T('j'): // day of the year
1898 res
+= wxString::Format(fmt
, GetDayOfYear(tz
));
1901 case _T('m'): // month as a number (01-12)
1902 res
+= wxString::Format(fmt
, tm
.mon
+ 1);
1905 case _T('M'): // minute as a decimal number (00-59)
1906 res
+= wxString::Format(fmt
, tm
.min
);
1909 case _T('p'): // AM or PM string
1910 res
+= CallStrftime(_T("%p"), &tmTimeOnly
);
1913 case _T('S'): // second as a decimal number (00-61)
1914 res
+= wxString::Format(fmt
, tm
.sec
);
1917 case _T('U'): // week number in the year (Sunday 1st week day)
1919 int week
= (GetDayOfYear(tz
) - tm
.GetWeekDay() + 7) / 7;
1920 res
+= wxString::Format(fmt
, week
);
1924 case _T('W'): // week number in the year (Monday 1st week day)
1925 res
+= wxString::Format(fmt
, GetWeekOfYear(tz
));
1928 case _T('w'): // weekday as a number (0-6), Sunday = 0
1929 res
+= wxString::Format(fmt
, tm
.GetWeekDay());
1932 // case _T('x'): -- handled with "%c"
1934 case _T('X'): // locale default time representation
1935 // just use strftime() to format the time for us
1936 res
+= CallStrftime(_T("%X"), &tmTimeOnly
);
1939 case _T('y'): // year without century (00-99)
1940 res
+= wxString::Format(fmt
, tm
.year
% 100);
1943 case _T('Y'): // year with century
1944 res
+= wxString::Format(fmt
, tm
.year
);
1947 case _T('Z'): // timezone name
1948 res
+= CallStrftime(_T("%Z"), &tmTimeOnly
);
1952 // is it the format width?
1954 while ( *p
== _T('-') || *p
== _T('+') ||
1955 *p
== _T(' ') || wxIsdigit(*p
) )
1960 if ( !fmt
.IsEmpty() )
1962 // we've only got the flags and width so far in fmt
1963 fmt
.Prepend(_T('%'));
1964 fmt
.Append(_T('d'));
1969 // no, it wasn't the width
1970 wxFAIL_MSG(_T("unknown format specificator"));
1972 // fall through and just copy it nevertheless
1974 case _T('%'): // a percent sign
1978 case 0: // the end of string
1979 wxFAIL_MSG(_T("missing format at the end of string"));
1981 // just put the '%' which was the last char in format
1990 // this function parses a string in (strict) RFC 822 format: see the section 5
1991 // of the RFC for the detailed description, but briefly it's something of the
1992 // form "Sat, 18 Dec 1999 00:48:30 +0100"
1994 // this function is "strict" by design - it must reject anything except true
1995 // RFC822 time specs.
1997 // TODO a great candidate for using reg exps
1998 const wxChar
*wxDateTime::ParseRfc822Date(const wxChar
* date
)
2000 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
2002 const wxChar
*p
= date
;
2003 const wxChar
*comma
= wxStrchr(p
, _T(','));
2006 // the part before comma is the weekday
2008 // skip it for now - we don't use but might check that it really
2009 // corresponds to the specfied date
2012 if ( *p
!= _T(' ') )
2014 wxLogDebug(_T("no space after weekday in RFC822 time spec"));
2016 return (wxChar
*)NULL
;
2022 // the following 1 or 2 digits are the day number
2023 if ( !wxIsdigit(*p
) )
2025 wxLogDebug(_T("day number expected in RFC822 time spec, none found"));
2027 return (wxChar
*)NULL
;
2030 wxDateTime_t day
= *p
++ - _T('0');
2031 if ( wxIsdigit(*p
) )
2034 day
+= *p
++ - _T('0');
2037 if ( *p
++ != _T(' ') )
2039 return (wxChar
*)NULL
;
2042 // the following 3 letters specify the month
2043 wxString
monName(p
, 3);
2045 if ( monName
== _T("Jan") )
2047 else if ( monName
== _T("Feb") )
2049 else if ( monName
== _T("Mar") )
2051 else if ( monName
== _T("Apr") )
2053 else if ( monName
== _T("May") )
2055 else if ( monName
== _T("Jun") )
2057 else if ( monName
== _T("Jul") )
2059 else if ( monName
== _T("Aug") )
2061 else if ( monName
== _T("Sep") )
2063 else if ( monName
== _T("Oct") )
2065 else if ( monName
== _T("Nov") )
2067 else if ( monName
== _T("Dec") )
2071 wxLogDebug(_T("Invalid RFC 822 month name '%s'"), monName
.c_str());
2073 return (wxChar
*)NULL
;
2078 if ( *p
++ != _T(' ') )
2080 return (wxChar
*)NULL
;
2084 if ( !wxIsdigit(*p
) )
2087 return (wxChar
*)NULL
;
2090 int year
= *p
++ - _T('0');
2092 if ( !wxIsdigit(*p
) )
2094 // should have at least 2 digits in the year
2095 return (wxChar
*)NULL
;
2099 year
+= *p
++ - _T('0');
2101 // is it a 2 digit year (as per original RFC 822) or a 4 digit one?
2102 if ( wxIsdigit(*p
) )
2105 year
+= *p
++ - _T('0');
2107 if ( !wxIsdigit(*p
) )
2109 // no 3 digit years please
2110 return (wxChar
*)NULL
;
2114 year
+= *p
++ - _T('0');
2117 if ( *p
++ != _T(' ') )
2119 return (wxChar
*)NULL
;
2122 // time is in the format hh:mm:ss and seconds are optional
2123 if ( !wxIsdigit(*p
) )
2125 return (wxChar
*)NULL
;
2128 wxDateTime_t hour
= *p
++ - _T('0');
2130 if ( !wxIsdigit(*p
) )
2132 return (wxChar
*)NULL
;
2136 hour
+= *p
++ - _T('0');
2138 if ( *p
++ != _T(':') )
2140 return (wxChar
*)NULL
;
2143 if ( !wxIsdigit(*p
) )
2145 return (wxChar
*)NULL
;
2148 wxDateTime_t min
= *p
++ - _T('0');
2150 if ( !wxIsdigit(*p
) )
2152 return (wxChar
*)NULL
;
2156 min
+= *p
++ - _T('0');
2158 wxDateTime_t sec
= 0;
2159 if ( *p
++ == _T(':') )
2161 if ( !wxIsdigit(*p
) )
2163 return (wxChar
*)NULL
;
2166 sec
= *p
++ - _T('0');
2168 if ( !wxIsdigit(*p
) )
2170 return (wxChar
*)NULL
;
2174 sec
+= *p
++ - _T('0');
2177 if ( *p
++ != _T(' ') )
2179 return (wxChar
*)NULL
;
2182 // and now the interesting part: the timezone
2184 if ( *p
== _T('-') || *p
== _T('+') )
2186 // the explicit offset given: it has the form of hhmm
2187 bool plus
= *p
++ == _T('+');
2189 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2191 return (wxChar
*)NULL
;
2195 offset
= 60*(10*(*p
- _T('0')) + (*(p
+ 1) - _T('0')));
2199 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2201 return (wxChar
*)NULL
;
2205 offset
+= 10*(*p
- _T('0')) + (*(p
+ 1) - _T('0'));
2216 // the symbolic timezone given: may be either military timezone or one
2217 // of standard abbreviations
2220 // military: Z = UTC, J unused, A = -1, ..., Y = +12
2221 static const int offsets
[26] =
2223 //A B C D E F G H I J K L M
2224 -1, -2, -3, -4, -5, -6, -7, -8, -9, 0, -10, -11, -12,
2225 //N O P R Q S T U V W Z Y Z
2226 +1, +2, +3, +4, +5, +6, +7, +8, +9, +10, +11, +12, 0
2229 if ( *p
< _T('A') || *p
> _T('Z') || *p
== _T('J') )
2231 wxLogDebug(_T("Invalid militaty timezone '%c'"), *p
);
2233 return (wxChar
*)NULL
;
2236 offset
= offsets
[*p
++ - _T('A')];
2242 if ( tz
== _T("UT") || tz
== _T("UTC") || tz
== _T("GMT") )
2244 else if ( tz
== _T("AST") )
2245 offset
= AST
- GMT0
;
2246 else if ( tz
== _T("ADT") )
2247 offset
= ADT
- GMT0
;
2248 else if ( tz
== _T("EST") )
2249 offset
= EST
- GMT0
;
2250 else if ( tz
== _T("EDT") )
2251 offset
= EDT
- GMT0
;
2252 else if ( tz
== _T("CST") )
2253 offset
= CST
- GMT0
;
2254 else if ( tz
== _T("CDT") )
2255 offset
= CDT
- GMT0
;
2256 else if ( tz
== _T("MST") )
2257 offset
= MST
- GMT0
;
2258 else if ( tz
== _T("MDT") )
2259 offset
= MDT
- GMT0
;
2260 else if ( tz
== _T("PST") )
2261 offset
= PST
- GMT0
;
2262 else if ( tz
== _T("PDT") )
2263 offset
= PDT
- GMT0
;
2266 wxLogDebug(_T("Unknown RFC 822 timezone '%s'"), p
);
2268 return (wxChar
*)NULL
;
2278 // the spec was correct
2279 Set(day
, mon
, year
, hour
, min
, sec
);
2280 MakeTimezone(60*offset
);
2285 const wxChar
*wxDateTime::ParseFormat(const wxChar
*date
,
2286 const wxChar
*format
,
2287 const wxDateTime
& dateDef
)
2289 wxCHECK_MSG( date
&& format
, (wxChar
*)NULL
,
2290 _T("NULL pointer in wxDateTime::ParseFormat()") );
2295 // what fields have we found?
2296 bool haveWDay
= FALSE
,
2305 bool hourIsIn12hFormat
= FALSE
, // or in 24h one?
2306 isPM
= FALSE
; // AM by default
2308 // and the value of the items we have (init them to get rid of warnings)
2309 wxDateTime_t sec
= 0,
2312 WeekDay wday
= Inv_WeekDay
;
2313 wxDateTime_t yday
= 0,
2315 wxDateTime::Month mon
= Inv_Month
;
2318 const wxChar
*input
= date
;
2319 for ( const wxChar
*fmt
= format
; *fmt
; fmt
++ )
2321 if ( *fmt
!= _T('%') )
2323 if ( wxIsspace(*fmt
) )
2325 // a white space in the format string matches 0 or more white
2326 // spaces in the input
2327 while ( wxIsspace(*input
) )
2334 // any other character (not whitespace, not '%') must be
2335 // matched by itself in the input
2336 if ( *input
++ != *fmt
)
2339 return (wxChar
*)NULL
;
2343 // done with this format char
2347 // start of a format specification
2350 case _T('a'): // a weekday name
2353 int flag
= *fmt
== _T('a') ? Name_Abbr
: Name_Full
;
2354 wday
= GetWeekDayFromName(GetAlphaToken(input
), flag
);
2355 if ( wday
== Inv_WeekDay
)
2358 return (wxChar
*)NULL
;
2364 case _T('b'): // a month name
2367 int flag
= *fmt
== _T('b') ? Name_Abbr
: Name_Full
;
2368 mon
= GetMonthFromName(GetAlphaToken(input
), flag
);
2369 if ( mon
== Inv_Month
)
2372 return (wxChar
*)NULL
;
2378 case _T('c'): // locale default date and time representation
2382 // this is the format which corresponds to ctime() output
2383 // and strptime("%c") should parse it, so try it first
2384 static const wxChar
*fmtCtime
= _T("%a %b %e %H:%M:%S %Y");
2386 const wxChar
*result
= dt
.ParseFormat(input
, fmtCtime
);
2389 result
= dt
.ParseFormat(input
, _T("%x %X"));
2394 result
= dt
.ParseFormat(input
, _T("%X %x"));
2399 // we've tried everything and still no match
2400 return (wxChar
*)NULL
;
2407 case _T('d'): // day of a month (01-31)
2408 if ( !GetNumericToken(input
, &num
) || (num
> 31) )
2411 return (wxChar
*)NULL
;
2414 // we can't check whether the day range is correct yet, will
2415 // do it later - assume ok for now
2417 mday
= (wxDateTime_t
)num
;
2420 case _T('H'): // hour in 24h format (00-23)
2421 if ( !GetNumericToken(input
, &num
) || (num
> 23) )
2424 return (wxChar
*)NULL
;
2428 hour
= (wxDateTime_t
)num
;
2431 case _T('I'): // hour in 12h format (01-12)
2432 if ( !GetNumericToken(input
, &num
) || !num
|| (num
> 12) )
2435 return (wxChar
*)NULL
;
2439 hourIsIn12hFormat
= TRUE
;
2440 hour
= num
% 12; // 12 should be 0
2443 case _T('j'): // day of the year
2444 if ( !GetNumericToken(input
, &num
) || !num
|| (num
> 366) )
2447 return (wxChar
*)NULL
;
2451 yday
= (wxDateTime_t
)num
;
2454 case _T('m'): // month as a number (01-12)
2455 if ( !GetNumericToken(input
, &num
) || !num
|| (num
> 12) )
2458 return (wxChar
*)NULL
;
2465 case _T('M'): // minute as a decimal number (00-59)
2466 if ( !GetNumericToken(input
, &num
) || (num
> 59) )
2469 return (wxChar
*)NULL
;
2473 min
= (wxDateTime_t
)num
;
2476 case _T('p'): // AM or PM string
2478 wxString am
, pm
, token
= GetAlphaToken(input
);
2480 GetAmPmStrings(&am
, &pm
);
2481 if ( token
.CmpNoCase(pm
) == 0 )
2485 else if ( token
.CmpNoCase(am
) != 0 )
2488 return (wxChar
*)NULL
;
2493 case _T('r'): // time as %I:%M:%S %p
2496 input
= dt
.ParseFormat(input
, _T("%I:%M:%S %p"));
2500 return (wxChar
*)NULL
;
2503 haveHour
= haveMin
= haveSec
= TRUE
;
2512 case _T('R'): // time as %H:%M
2515 input
= dt
.ParseFormat(input
, _T("%H:%M"));
2519 return (wxChar
*)NULL
;
2522 haveHour
= haveMin
= TRUE
;
2529 case _T('S'): // second as a decimal number (00-61)
2530 if ( !GetNumericToken(input
, &num
) || (num
> 61) )
2533 return (wxChar
*)NULL
;
2537 sec
= (wxDateTime_t
)num
;
2540 case _T('T'): // time as %H:%M:%S
2543 input
= dt
.ParseFormat(input
, _T("%H:%M:%S"));
2547 return (wxChar
*)NULL
;
2550 haveHour
= haveMin
= haveSec
= TRUE
;
2558 case _T('w'): // weekday as a number (0-6), Sunday = 0
2559 if ( !GetNumericToken(input
, &num
) || (wday
> 6) )
2562 return (wxChar
*)NULL
;
2566 wday
= (WeekDay
)num
;
2569 case _T('x'): // locale default date representation
2570 #ifdef HAVE_STRPTIME
2571 // try using strptime() - it may fail even if the input is
2572 // correct but the date is out of range, so we will fall back
2573 // to our generic code anyhow (FIXME !Unicode friendly)
2576 const wxChar
*result
= strptime(input
, "%x", &tm
);
2581 haveDay
= haveMon
= haveYear
= TRUE
;
2583 year
= 1900 + tm
.tm_year
;
2584 mon
= (Month
)tm
.tm_mon
;
2590 #endif // HAVE_STRPTIME
2592 // TODO query the LOCALE_IDATE setting under Win32
2597 if ( IsWestEuropeanCountry(GetCountry()) ||
2598 GetCountry() == Russia
)
2600 fmtDate
= _T("%d/%m/%y");
2604 fmtDate
= _T("%m/%d/%y");
2607 const wxChar
*result
= dt
.ParseFormat(input
, fmtDate
);
2611 return (wxChar
*)NULL
;
2616 haveDay
= haveMon
= haveYear
= TRUE
;
2627 case _T('X'): // locale default time representation
2628 #ifdef HAVE_STRPTIME
2630 // use strptime() to do it for us (FIXME !Unicode friendly)
2632 input
= strptime(input
, "%X", &tm
);
2635 return (wxChar
*)NULL
;
2638 haveHour
= haveMin
= haveSec
= TRUE
;
2644 #else // !HAVE_STRPTIME
2645 // TODO under Win32 we can query the LOCALE_ITIME system
2646 // setting which says whether the default time format is
2649 // try to parse what follows as "%H:%M:%S" and, if this
2650 // fails, as "%I:%M:%S %p" - this should catch the most
2654 const wxChar
*result
= dt
.ParseFormat(input
, _T("%T"));
2657 result
= dt
.ParseFormat(input
, _T("%r"));
2663 return (wxChar
*)NULL
;
2666 haveHour
= haveMin
= haveSec
= TRUE
;
2675 #endif // HAVE_STRPTIME/!HAVE_STRPTIME
2678 case _T('y'): // year without century (00-99)
2679 if ( !GetNumericToken(input
, &num
) || (num
> 99) )
2682 return (wxChar
*)NULL
;
2689 case _T('Y'): // year with century
2690 if ( !GetNumericToken(input
, &num
) || !num
|| (num
> 366) )
2693 return (wxChar
*)NULL
;
2697 yday
= (wxDateTime_t
)num
;
2700 case _T('Z'): // timezone name
2701 wxFAIL_MSG(_T("TODO"));
2704 case _T('%'): // a percent sign
2705 if ( *input
++ != _T('%') )
2708 return (wxChar
*)NULL
;
2712 case 0: // the end of string
2713 wxFAIL_MSG(_T("unexpected format end"));
2717 default: // not a known format spec
2718 return (wxChar
*)NULL
;
2722 // format matched, try to construct a date from what we have now
2724 if ( dateDef
.IsValid() )
2726 // take this date as default
2727 tmDef
= dateDef
.GetTm();
2729 else if ( IsValid() )
2731 // if this date is valid, don't change it
2736 // no default and this date is invalid - fall back to Today()
2737 tmDef
= Today().GetTm();
2748 // TODO we don't check here that the values are consistent, if both year
2749 // day and month/day were found, we just ignore the year day and we
2750 // also always ignore the week day
2751 if ( haveMon
&& haveDay
)
2756 else if ( haveYDay
)
2758 Tm tm2
= wxDateTime(1, Jan
, tm
.year
).SetToYearDay(yday
).GetTm();
2765 if ( haveHour
&& hourIsIn12hFormat
&& isPM
)
2767 // translate to 24hour format
2770 //else: either already in 24h format or no translation needed
2793 const wxChar
*wxDateTime::ParseDateTime(const wxChar
*date
)
2795 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
2797 // there is a public domain version of getdate.y, but it only works for
2799 wxFAIL_MSG(_T("TODO"));
2801 return (wxChar
*)NULL
;
2804 const wxChar
*wxDateTime::ParseDate(const wxChar
*date
)
2806 // this is a simplified version of ParseDateTime() which understands only
2807 // "today" (for wxDate compatibility) and digits only otherwise (and not
2808 // all esoteric constructions ParseDateTime() knows about)
2810 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
2812 const wxChar
*p
= date
;
2813 while ( wxIsspace(*p
) )
2816 wxString today
= _T("today");
2817 size_t len
= today
.length();
2818 if ( wxString(p
, len
).CmpNoCase(today
) == 0 )
2820 // nothing can follow this, so stop here
2829 bool haveDay
= FALSE
, // the months day?
2830 haveWDay
= FALSE
, // the day of week?
2831 haveMon
= FALSE
, // the month?
2832 haveYear
= FALSE
; // the year?
2834 // and the value of the items we have (init them to get rid of warnings)
2835 WeekDay wday
= Inv_WeekDay
;
2836 wxDateTime_t day
= 0;
2837 wxDateTime::Month mon
= Inv_Month
;
2840 // tokenize the string
2841 wxStringTokenizer
tok(p
, _T(",/-\t "));
2842 while ( tok
.HasMoreTokens() )
2844 wxString token
= tok
.GetNextToken();
2848 if ( token
.ToULong(&val
) )
2850 // guess what this number is
2854 // only years are counted from 0
2855 isYear
= (val
== 0) || (val
> 31);
2858 // may be the month or month day or the year, assume the
2859 // month day by default and fallback to month if the range
2860 // allow it or to the year if our assumption doesn't work
2863 // we already have the day, so may only be a month or year
2873 else // it may be day
2880 if ( val
> GetNumOfDaysInMonth(haveYear
? year
2884 // oops, it can't be a day finally
2900 // remember that we have this and stop the scan if it's the second
2901 // time we find this, except for the day logic (see there)
2911 // no roll over - 99 means 99, not 1999 for us
2923 mon
= (wxDateTime::Month
)val
;
2927 wxASSERT_MSG( isDay
, _T("logic error") );
2931 // may be were mistaken when we found it for the first
2932 // time? may be it was a month or year instead?
2934 // this ability to "backtrack" allows us to correctly parse
2935 // both things like 01/13 and 13/01 - but, of course, we
2936 // still can't resolve the ambiguity in 01/02 (it will be
2937 // Feb 1 for us, not Jan 2 as americans might expect!)
2938 if ( (day
<= 12) && !haveMon
)
2940 // exchange day and month
2941 mon
= (wxDateTime::Month
)day
;
2945 else if ( !haveYear
)
2947 // exchange day and year
2959 else // not a number
2961 mon
= GetMonthFromName(token
, Name_Full
| Name_Abbr
);
2962 if ( mon
!= Inv_Month
)
2974 wday
= GetWeekDayFromName(token
, Name_Full
| Name_Abbr
);
2975 if ( wday
!= Inv_WeekDay
)
2988 static const wxChar
*ordinals
[] =
2990 wxTRANSLATE("first"),
2991 wxTRANSLATE("second"),
2992 wxTRANSLATE("third"),
2993 wxTRANSLATE("fourth"),
2994 wxTRANSLATE("fifth"),
2995 wxTRANSLATE("sixth"),
2996 wxTRANSLATE("seventh"),
2997 wxTRANSLATE("eighth"),
2998 wxTRANSLATE("ninth"),
2999 wxTRANSLATE("tenth"),
3000 wxTRANSLATE("eleventh"),
3001 wxTRANSLATE("twelfth"),
3002 wxTRANSLATE("thirteenth"),
3003 wxTRANSLATE("fourteenth"),
3004 wxTRANSLATE("fifteenth"),
3005 wxTRANSLATE("sixteenth"),
3006 wxTRANSLATE("seventeenth"),
3007 wxTRANSLATE("eighteenth"),
3008 wxTRANSLATE("nineteenth"),
3009 wxTRANSLATE("twentieth"),
3010 // that's enough - otherwise we'd have problems with
3011 // composite (or not) ordinals otherwise
3015 for ( n
= 0; n
< WXSIZEOF(ordinals
); n
++ )
3017 if ( token
.CmpNoCase(ordinals
[n
]) == 0 )
3023 if ( n
== WXSIZEOF(ordinals
) )
3025 // stop here - something unknown
3032 // don't try anything here (as in case of numeric day
3033 // above) - the symbolic day spec should always
3034 // precede the month/year
3046 // either no more tokens or the scan was stopped by something we couldn't
3047 // parse - in any case, see if we can construct a date from what we have
3048 if ( !haveDay
&& !haveWDay
)
3050 wxLogDebug(_T("no day, no weekday hence no date."));
3052 return (wxChar
*)NULL
;
3055 if ( haveWDay
&& (haveMon
|| haveYear
|| haveDay
) &&
3056 !(haveMon
&& haveMon
&& haveYear
) )
3058 // without adjectives (which we don't support here) the week day only
3059 // makes sense completely separately or with the full date
3060 // specification (what would "Wed 1999" mean?)
3061 return (wxChar
*)NULL
;
3066 mon
= GetCurrentMonth();
3071 year
= GetCurrentYear();
3076 Set(day
, mon
, year
);
3080 // check that it is really the same
3081 if ( GetWeekDay() != wday
)
3083 // inconsistency detected
3084 return (wxChar
*)NULL
;
3092 SetToWeekDayInSameWeek(wday
);
3095 // return the pointer to the next char
3096 return p
+ wxStrlen(p
) - wxStrlen(tok
.GetString());
3099 const wxChar
*wxDateTime::ParseTime(const wxChar
*time
)
3101 wxCHECK_MSG( time
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3103 // first try some extra things
3110 { wxTRANSLATE("noon"), 12 },
3111 { wxTRANSLATE("midnight"), 00 },
3115 for ( size_t n
= 0; n
< WXSIZEOF(stdTimes
); n
++ )
3117 wxString timeString
= wxGetTranslation(stdTimes
[n
].name
);
3118 size_t len
= timeString
.length();
3119 if ( timeString
.CmpNoCase(wxString(time
, len
)) == 0 )
3121 Set(stdTimes
[n
].hour
, 0, 0);
3127 // try all time formats we may think about starting with the standard one
3128 const wxChar
*result
= ParseFormat(time
, _T("%X"));
3131 // normally, it's the same, but why not try it?
3132 result
= ParseFormat(time
, _T("%H:%M:%S"));
3137 // 12hour with AM/PM?
3138 result
= ParseFormat(time
, _T("%I:%M:%S %p"));
3144 result
= ParseFormat(time
, _T("%H:%M"));
3149 // 12hour with AM/PM but without seconds?
3150 result
= ParseFormat(time
, _T("%I:%M %p"));
3156 result
= ParseFormat(time
, _T("%H"));
3161 // just the hour and AM/PM?
3162 result
= ParseFormat(time
, _T("%I %p"));
3165 // TODO: parse timezones
3170 // ============================================================================
3172 // ============================================================================
3174 // not all strftime(3) format specifiers make sense here because, for example,
3175 // a time span doesn't have a year nor a timezone
3177 // Here are the ones which are supported (all of them are supported by strftime
3179 // %H hour in 24 hour format
3180 // %M minute (00 - 59)
3181 // %S second (00 - 59)
3184 // Also, for MFC CTimeSpan compatibility, we support
3185 // %D number of days
3187 // And, to be better than MFC :-), we also have
3188 // %E number of wEeks
3189 // %l milliseconds (000 - 999)
3190 wxString
wxTimeSpan::Format(const wxChar
*format
) const
3192 wxCHECK_MSG( format
, _T(""), _T("NULL format in wxTimeSpan::Format") );
3195 str
.Alloc(strlen(format
));
3197 for ( const wxChar
*pch
= format
; pch
; pch
++ )
3209 wxFAIL_MSG( _T("invalid format character") );
3213 // will get to str << ch below
3217 tmp
.Printf(_T("%d"), GetDays());
3221 tmp
.Printf(_T("%d"), GetWeeks());
3225 tmp
.Printf(_T("%02d"), GetHours());
3229 tmp
.Printf(_T("%03ld"), GetMilliseconds().ToLong());
3233 tmp
.Printf(_T("%02d"), GetMinutes());
3237 tmp
.Printf(_T("%02ld"), GetSeconds().ToLong());
3245 // skip str += ch below