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"
74 #include "wx/module.h"
76 #define wxDEFINE_TIME_CONSTANTS // before including datetime.h
78 #include "wx/datetime.h"
80 // ----------------------------------------------------------------------------
81 // conditional compilation
82 // ----------------------------------------------------------------------------
84 #if defined(HAVE_STRPTIME) && defined(__LINUX__)
85 // glibc 2.0.7 strptime() is broken - the following snippet causes it to
86 // crash (instead of just failing):
88 // strncpy(buf, "Tue Dec 21 20:25:40 1999", 128);
89 // strptime(buf, "%x", &tm);
93 #endif // broken strptime()
96 #if defined(__BORLANDC__) || defined(__MINGW32__) || defined(__VISAGECPP__)
97 #define WX_TIMEZONE _timezone
98 #elif defined(__WXMAC__)
99 long wxmac_timezone
= 28800;
100 #define WX_TIMEZONE wxmac_timezone ;
101 #else // unknown platform - try timezone
102 #define WX_TIMEZONE timezone
104 #endif // !WX_TIMEZONE
106 // ----------------------------------------------------------------------------
108 // ----------------------------------------------------------------------------
110 class wxDateTimeHolidaysModule
: public wxModule
113 virtual bool OnInit()
115 wxDateTimeHolidayAuthority::AddAuthority(new wxDateTimeWorkDays
);
120 virtual void OnExit()
122 wxDateTimeHolidayAuthority::ClearAllAuthorities();
126 DECLARE_DYNAMIC_CLASS(wxDateTimeHolidaysModule
)
129 IMPLEMENT_DYNAMIC_CLASS(wxDateTimeHolidaysModule
, wxModule
)
131 // ----------------------------------------------------------------------------
133 // ----------------------------------------------------------------------------
136 static const int MONTHS_IN_YEAR
= 12;
138 static const int SECONDS_IN_MINUTE
= 60;
140 static const long SECONDS_PER_DAY
= 86400l;
142 static const long MILLISECONDS_PER_DAY
= 86400000l;
144 // this is the integral part of JDN of the midnight of Jan 1, 1970
145 // (i.e. JDN(Jan 1, 1970) = 2440587.5)
146 static const long EPOCH_JDN
= 2440587l;
148 // the date of JDN -0.5 (as we don't work with fractional parts, this is the
149 // reference date for us) is Nov 24, 4714BC
150 static const int JDN_0_YEAR
= -4713;
151 static const int JDN_0_MONTH
= wxDateTime::Nov
;
152 static const int JDN_0_DAY
= 24;
154 // the constants used for JDN calculations
155 static const long JDN_OFFSET
= 32046l;
156 static const long DAYS_PER_5_MONTHS
= 153l;
157 static const long DAYS_PER_4_YEARS
= 1461l;
158 static const long DAYS_PER_400_YEARS
= 146097l;
160 // this array contains the cumulated number of days in all previous months for
161 // normal and leap years
162 static const wxDateTime::wxDateTime_t gs_cumulatedDays
[2][MONTHS_IN_YEAR
] =
164 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
165 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
168 // ----------------------------------------------------------------------------
170 // ----------------------------------------------------------------------------
172 static wxDateTime gs_dtDefault
;
174 wxDateTime
& wxDefaultDateTime
= gs_dtDefault
;
176 wxDateTime::Country
wxDateTime::ms_country
= wxDateTime::Country_Unknown
;
178 // ----------------------------------------------------------------------------
180 // ----------------------------------------------------------------------------
182 // a critical section is needed to protect GetTimeZone() static
183 // variable in MT case
185 static wxCriticalSection gs_critsectTimezone
;
186 #endif // wxUSE_THREADS
188 // ----------------------------------------------------------------------------
190 // ----------------------------------------------------------------------------
192 // debugger helper: shows what the date really is
194 extern const wxChar
*wxDumpDate(const wxDateTime
* dt
)
196 static wxChar buf
[128];
198 wxStrcpy(buf
, dt
->Format(_T("%Y-%m-%d (%a) %H:%M:%S")));
204 // get the number of days in the given month of the given year
206 wxDateTime::wxDateTime_t
GetNumOfDaysInMonth(int year
, wxDateTime::Month month
)
208 // the number of days in month in Julian/Gregorian calendar: the first line
209 // is for normal years, the second one is for the leap ones
210 static wxDateTime::wxDateTime_t daysInMonth
[2][MONTHS_IN_YEAR
] =
212 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
213 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
216 return daysInMonth
[wxDateTime::IsLeapYear(year
)][month
];
219 // ensure that the timezone variable is set by calling localtime
220 static int GetTimeZone()
222 // set to TRUE when the timezone is set
223 static bool s_timezoneSet
= FALSE
;
225 wxCRIT_SECT_LOCKER(lock
, gs_critsectTimezone
);
227 if ( !s_timezoneSet
)
229 // just call localtime() instead of figuring out whether this system
230 // supports tzset(), _tzset() or something else
234 s_timezoneSet
= TRUE
;
237 return (int)WX_TIMEZONE
;
240 // return the integral part of the JDN for the midnight of the given date (to
241 // get the real JDN you need to add 0.5, this is, in fact, JDN of the
242 // noon of the previous day)
243 static long GetTruncatedJDN(wxDateTime::wxDateTime_t day
,
244 wxDateTime::Month mon
,
247 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
249 // check the date validity
251 (year
> JDN_0_YEAR
) ||
252 ((year
== JDN_0_YEAR
) && (mon
> JDN_0_MONTH
)) ||
253 ((year
== JDN_0_YEAR
) && (mon
== JDN_0_MONTH
) && (day
>= JDN_0_DAY
)),
254 _T("date out of range - can't convert to JDN")
257 // make the year positive to avoid problems with negative numbers division
260 // months are counted from March here
262 if ( mon
>= wxDateTime::Mar
)
272 // now we can simply add all the contributions together
273 return ((year
/ 100) * DAYS_PER_400_YEARS
) / 4
274 + ((year
% 100) * DAYS_PER_4_YEARS
) / 4
275 + (month
* DAYS_PER_5_MONTHS
+ 2) / 5
280 // this function is a wrapper around strftime(3)
281 static wxString
CallStrftime(const wxChar
*format
, const tm
* tm
)
284 if ( !wxStrftime(buf
, WXSIZEOF(buf
), format
, tm
) )
286 // buffer is too small?
287 wxFAIL_MSG(_T("strftime() failed"));
290 return wxString(buf
);
293 // if year and/or month have invalid values, replace them with the current ones
294 static void ReplaceDefaultYearMonthWithCurrent(int *year
,
295 wxDateTime::Month
*month
)
297 struct tm
*tmNow
= NULL
;
299 if ( *year
== wxDateTime::Inv_Year
)
301 tmNow
= wxDateTime::GetTmNow();
303 *year
= 1900 + tmNow
->tm_year
;
306 if ( *month
== wxDateTime::Inv_Month
)
309 tmNow
= wxDateTime::GetTmNow();
311 *month
= (wxDateTime::Month
)tmNow
->tm_mon
;
315 // fll the struct tm with default values
316 static void InitTm(struct tm
& tm
)
318 // struct tm may have etxra fields (undocumented and with unportable
319 // names) which, nevertheless, must be set to 0
320 memset(&tm
, 0, sizeof(struct tm
));
322 tm
.tm_mday
= 1; // mday 0 is invalid
323 tm
.tm_year
= 76; // any valid year
324 tm
.tm_isdst
= -1; // auto determine
330 // return the month if the string is a month name or Inv_Month otherwise
331 static wxDateTime::Month
GetMonthFromName(const wxString
& name
, int flags
)
333 wxDateTime::Month mon
;
334 for ( mon
= wxDateTime::Jan
; mon
< wxDateTime::Inv_Month
; wxNextMonth(mon
) )
336 // case-insensitive comparison either one of or with both abbreviated
338 if ( flags
& wxDateTime::Name_Full
)
340 if ( name
.CmpNoCase(wxDateTime::
341 GetMonthName(mon
, wxDateTime::Name_Full
)) == 0 )
347 if ( flags
& wxDateTime::Name_Abbr
)
349 if ( name
.CmpNoCase(wxDateTime::
350 GetMonthName(mon
, wxDateTime::Name_Abbr
)) == 0 )
360 // return the weekday if the string is a weekday name or Inv_WeekDay otherwise
361 static wxDateTime::WeekDay
GetWeekDayFromName(const wxString
& name
, int flags
)
363 wxDateTime::WeekDay wd
;
364 for ( wd
= wxDateTime::Sun
; wd
< wxDateTime::Inv_WeekDay
; wxNextWDay(wd
) )
366 // case-insensitive comparison either one of or with both abbreviated
368 if ( flags
& wxDateTime::Name_Full
)
370 if ( name
.CmpNoCase(wxDateTime::
371 GetWeekDayName(wd
, wxDateTime::Name_Full
)) == 0 )
377 if ( flags
& wxDateTime::Name_Abbr
)
379 if ( name
.CmpNoCase(wxDateTime::
380 GetWeekDayName(wd
, wxDateTime::Name_Abbr
)) == 0 )
390 // scans all digits and returns the resulting number
391 static bool GetNumericToken(const wxChar
*& p
, unsigned long *number
)
394 while ( wxIsdigit(*p
) )
399 return !!s
&& s
.ToULong(number
);
402 // scans all alphabetic characters and returns the resulting string
403 static wxString
GetAlphaToken(const wxChar
*& p
)
406 while ( wxIsalpha(*p
) )
414 // ============================================================================
415 // implementation of wxDateTime
416 // ============================================================================
418 // ----------------------------------------------------------------------------
420 // ----------------------------------------------------------------------------
424 year
= (wxDateTime_t
)wxDateTime::Inv_Year
;
425 mon
= wxDateTime::Inv_Month
;
427 hour
= min
= sec
= msec
= 0;
428 wday
= wxDateTime::Inv_WeekDay
;
431 wxDateTime::Tm::Tm(const struct tm
& tm
, const TimeZone
& tz
)
439 mon
= (wxDateTime::Month
)tm
.tm_mon
;
440 year
= 1900 + tm
.tm_year
;
445 bool wxDateTime::Tm::IsValid() const
447 // we allow for the leap seconds, although we don't use them (yet)
448 return (year
!= wxDateTime::Inv_Year
) && (mon
!= wxDateTime::Inv_Month
) &&
449 (mday
<= GetNumOfDaysInMonth(year
, mon
)) &&
450 (hour
< 24) && (min
< 60) && (sec
< 62) && (msec
< 1000);
453 void wxDateTime::Tm::ComputeWeekDay()
455 // compute the week day from day/month/year: we use the dumbest algorithm
456 // possible: just compute our JDN and then use the (simple to derive)
457 // formula: weekday = (JDN + 1.5) % 7
458 wday
= (wxDateTime::WeekDay
)(GetTruncatedJDN(mday
, mon
, year
) + 2) % 7;
461 void wxDateTime::Tm::AddMonths(int monDiff
)
463 // normalize the months field
464 while ( monDiff
< -mon
)
468 monDiff
+= MONTHS_IN_YEAR
;
471 while ( monDiff
+ mon
>= MONTHS_IN_YEAR
)
475 monDiff
-= MONTHS_IN_YEAR
;
478 mon
= (wxDateTime::Month
)(mon
+ monDiff
);
480 wxASSERT_MSG( mon
>= 0 && mon
< MONTHS_IN_YEAR
, _T("logic error") );
482 // NB: we don't check here that the resulting date is valid, this function
483 // is private and the caller must check it if needed
486 void wxDateTime::Tm::AddDays(int dayDiff
)
488 // normalize the days field
489 while ( dayDiff
+ mday
< 1 )
493 dayDiff
+= GetNumOfDaysInMonth(year
, mon
);
497 while ( mday
> GetNumOfDaysInMonth(year
, mon
) )
499 mday
-= GetNumOfDaysInMonth(year
, mon
);
504 wxASSERT_MSG( mday
> 0 && mday
<= GetNumOfDaysInMonth(year
, mon
),
508 // ----------------------------------------------------------------------------
510 // ----------------------------------------------------------------------------
512 wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz
)
516 case wxDateTime::Local
:
517 // get the offset from C RTL: it returns the difference GMT-local
518 // while we want to have the offset _from_ GMT, hence the '-'
519 m_offset
= -GetTimeZone();
522 case wxDateTime::GMT_12
:
523 case wxDateTime::GMT_11
:
524 case wxDateTime::GMT_10
:
525 case wxDateTime::GMT_9
:
526 case wxDateTime::GMT_8
:
527 case wxDateTime::GMT_7
:
528 case wxDateTime::GMT_6
:
529 case wxDateTime::GMT_5
:
530 case wxDateTime::GMT_4
:
531 case wxDateTime::GMT_3
:
532 case wxDateTime::GMT_2
:
533 case wxDateTime::GMT_1
:
534 m_offset
= -3600*(wxDateTime::GMT0
- tz
);
537 case wxDateTime::GMT0
:
538 case wxDateTime::GMT1
:
539 case wxDateTime::GMT2
:
540 case wxDateTime::GMT3
:
541 case wxDateTime::GMT4
:
542 case wxDateTime::GMT5
:
543 case wxDateTime::GMT6
:
544 case wxDateTime::GMT7
:
545 case wxDateTime::GMT8
:
546 case wxDateTime::GMT9
:
547 case wxDateTime::GMT10
:
548 case wxDateTime::GMT11
:
549 case wxDateTime::GMT12
:
550 m_offset
= 3600*(tz
- wxDateTime::GMT0
);
553 case wxDateTime::A_CST
:
554 // Central Standard Time in use in Australia = UTC + 9.5
555 m_offset
= 60l*(9*60 + 30);
559 wxFAIL_MSG( _T("unknown time zone") );
563 // ----------------------------------------------------------------------------
565 // ----------------------------------------------------------------------------
568 bool wxDateTime::IsLeapYear(int year
, wxDateTime::Calendar cal
)
570 if ( year
== Inv_Year
)
571 year
= GetCurrentYear();
573 if ( cal
== Gregorian
)
575 // in Gregorian calendar leap years are those divisible by 4 except
576 // those divisible by 100 unless they're also divisible by 400
577 // (in some countries, like Russia and Greece, additional corrections
578 // exist, but they won't manifest themselves until 2700)
579 return (year
% 4 == 0) && ((year
% 100 != 0) || (year
% 400 == 0));
581 else if ( cal
== Julian
)
583 // in Julian calendar the rule is simpler
584 return year
% 4 == 0;
588 wxFAIL_MSG(_T("unknown calendar"));
595 int wxDateTime::GetCentury(int year
)
597 return year
> 0 ? year
/ 100 : year
/ 100 - 1;
601 int wxDateTime::ConvertYearToBC(int year
)
604 return year
> 0 ? year
: year
- 1;
608 int wxDateTime::GetCurrentYear(wxDateTime::Calendar cal
)
613 return Now().GetYear();
616 wxFAIL_MSG(_T("TODO"));
620 wxFAIL_MSG(_T("unsupported calendar"));
628 wxDateTime::Month
wxDateTime::GetCurrentMonth(wxDateTime::Calendar cal
)
633 return Now().GetMonth();
636 wxFAIL_MSG(_T("TODO"));
640 wxFAIL_MSG(_T("unsupported calendar"));
648 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(int year
, Calendar cal
)
650 if ( year
== Inv_Year
)
652 // take the current year if none given
653 year
= GetCurrentYear();
660 return IsLeapYear(year
) ? 366 : 365;
663 wxFAIL_MSG(_T("unsupported calendar"));
671 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(wxDateTime::Month month
,
673 wxDateTime::Calendar cal
)
675 wxCHECK_MSG( month
< MONTHS_IN_YEAR
, 0, _T("invalid month") );
677 if ( cal
== Gregorian
|| cal
== Julian
)
679 if ( year
== Inv_Year
)
681 // take the current year if none given
682 year
= GetCurrentYear();
685 return GetNumOfDaysInMonth(year
, month
);
689 wxFAIL_MSG(_T("unsupported calendar"));
696 wxString
wxDateTime::GetMonthName(wxDateTime::Month month
,
697 wxDateTime::NameFlags flags
)
699 wxCHECK_MSG( month
!= Inv_Month
, _T(""), _T("invalid month") );
701 // notice that we must set all the fields to avoid confusing libc (GNU one
702 // gets confused to a crash if we don't do this)
707 return CallStrftime(flags
== Name_Abbr
? _T("%b") : _T("%B"), &tm
);
711 wxString
wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday
,
712 wxDateTime::NameFlags flags
)
714 wxCHECK_MSG( wday
!= Inv_WeekDay
, _T(""), _T("invalid weekday") );
716 // take some arbitrary Sunday
723 // and offset it by the number of days needed to get the correct wday
726 // call mktime() to normalize it...
729 // ... and call strftime()
730 return CallStrftime(flags
== Name_Abbr
? _T("%a") : _T("%A"), &tm
);
734 void wxDateTime::GetAmPmStrings(wxString
*am
, wxString
*pm
)
740 *am
= CallStrftime(_T("%p"), &tm
);
745 *pm
= CallStrftime(_T("%p"), &tm
);
749 // ----------------------------------------------------------------------------
750 // Country stuff: date calculations depend on the country (DST, work days,
751 // ...), so we need to know which rules to follow.
752 // ----------------------------------------------------------------------------
755 wxDateTime::Country
wxDateTime::GetCountry()
757 // TODO use LOCALE_ICOUNTRY setting under Win32
759 if ( ms_country
== Country_Unknown
)
761 // try to guess from the time zone name
762 time_t t
= time(NULL
);
763 struct tm
*tm
= localtime(&t
);
765 wxString tz
= CallStrftime(_T("%Z"), tm
);
766 if ( tz
== _T("WET") || tz
== _T("WEST") )
770 else if ( tz
== _T("CET") || tz
== _T("CEST") )
772 ms_country
= Country_EEC
;
774 else if ( tz
== _T("MSK") || tz
== _T("MSD") )
778 else if ( tz
== _T("AST") || tz
== _T("ADT") ||
779 tz
== _T("EST") || tz
== _T("EDT") ||
780 tz
== _T("CST") || tz
== _T("CDT") ||
781 tz
== _T("MST") || tz
== _T("MDT") ||
782 tz
== _T("PST") || tz
== _T("PDT") )
788 // well, choose a default one
797 void wxDateTime::SetCountry(wxDateTime::Country country
)
799 ms_country
= country
;
803 bool wxDateTime::IsWestEuropeanCountry(Country country
)
805 if ( country
== Country_Default
)
807 country
= GetCountry();
810 return (Country_WesternEurope_Start
<= country
) &&
811 (country
<= Country_WesternEurope_End
);
814 // ----------------------------------------------------------------------------
815 // DST calculations: we use 3 different rules for the West European countries,
816 // USA and for the rest of the world. This is undoubtedly false for many
817 // countries, but I lack the necessary info (and the time to gather it),
818 // please add the other rules here!
819 // ----------------------------------------------------------------------------
822 bool wxDateTime::IsDSTApplicable(int year
, Country country
)
824 if ( year
== Inv_Year
)
826 // take the current year if none given
827 year
= GetCurrentYear();
830 if ( country
== Country_Default
)
832 country
= GetCountry();
839 // DST was first observed in the US and UK during WWI, reused
840 // during WWII and used again since 1966
841 return year
>= 1966 ||
842 (year
>= 1942 && year
<= 1945) ||
843 (year
== 1918 || year
== 1919);
846 // assume that it started after WWII
852 wxDateTime
wxDateTime::GetBeginDST(int year
, Country country
)
854 if ( year
== Inv_Year
)
856 // take the current year if none given
857 year
= GetCurrentYear();
860 if ( country
== Country_Default
)
862 country
= GetCountry();
865 if ( !IsDSTApplicable(year
, country
) )
867 return wxInvalidDateTime
;
872 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
874 // DST begins at 1 a.m. GMT on the last Sunday of March
875 if ( !dt
.SetToLastWeekDay(Sun
, Mar
, year
) )
878 wxFAIL_MSG( _T("no last Sunday in March?") );
881 dt
+= wxTimeSpan::Hours(1);
883 // disable DST tests because it could result in an infinite recursion!
886 else switch ( country
)
893 // don't know for sure - assume it was in effect all year
898 dt
.Set(1, Jan
, year
);
902 // DST was installed Feb 2, 1942 by the Congress
903 dt
.Set(2, Feb
, year
);
906 // Oil embargo changed the DST period in the US
908 dt
.Set(6, Jan
, 1974);
912 dt
.Set(23, Feb
, 1975);
916 // before 1986, DST begun on the last Sunday of April, but
917 // in 1986 Reagan changed it to begin at 2 a.m. of the
918 // first Sunday in April
921 if ( !dt
.SetToLastWeekDay(Sun
, Apr
, year
) )
924 wxFAIL_MSG( _T("no first Sunday in April?") );
929 if ( !dt
.SetToWeekDay(Sun
, 1, Apr
, year
) )
932 wxFAIL_MSG( _T("no first Sunday in April?") );
936 dt
+= wxTimeSpan::Hours(2);
938 // TODO what about timezone??
944 // assume Mar 30 as the start of the DST for the rest of the world
945 // - totally bogus, of course
946 dt
.Set(30, Mar
, year
);
953 wxDateTime
wxDateTime::GetEndDST(int year
, Country country
)
955 if ( year
== Inv_Year
)
957 // take the current year if none given
958 year
= GetCurrentYear();
961 if ( country
== Country_Default
)
963 country
= GetCountry();
966 if ( !IsDSTApplicable(year
, country
) )
968 return wxInvalidDateTime
;
973 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
975 // DST ends at 1 a.m. GMT on the last Sunday of October
976 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
978 // weirder and weirder...
979 wxFAIL_MSG( _T("no last Sunday in October?") );
982 dt
+= wxTimeSpan::Hours(1);
984 // disable DST tests because it could result in an infinite recursion!
987 else switch ( country
)
994 // don't know for sure - assume it was in effect all year
998 dt
.Set(31, Dec
, year
);
1002 // the time was reset after the end of the WWII
1003 dt
.Set(30, Sep
, year
);
1007 // DST ends at 2 a.m. on the last Sunday of October
1008 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1010 // weirder and weirder...
1011 wxFAIL_MSG( _T("no last Sunday in October?") );
1014 dt
+= wxTimeSpan::Hours(2);
1016 // TODO what about timezone??
1021 // assume October 26th as the end of the DST - totally bogus too
1022 dt
.Set(26, Oct
, year
);
1028 // ----------------------------------------------------------------------------
1029 // constructors and assignment operators
1030 // ----------------------------------------------------------------------------
1032 // the values in the tm structure contain the local time
1033 wxDateTime
& wxDateTime::Set(const struct tm
& tm
)
1035 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1038 time_t timet
= mktime(&tm2
);
1040 if ( timet
== (time_t)-1 )
1042 // mktime() rather unintuitively fails for Jan 1, 1970 if the hour is
1043 // less than timezone - try to make it work for this case
1044 if ( tm2
.tm_year
== 70 && tm2
.tm_mon
== 0 && tm2
.tm_mday
== 1 )
1046 // add timezone to make sure that date is in range
1047 tm2
.tm_sec
-= GetTimeZone();
1049 timet
= mktime(&tm2
);
1050 if ( timet
!= (time_t)-1 )
1052 timet
+= GetTimeZone();
1058 wxFAIL_MSG( _T("mktime() failed") );
1060 return wxInvalidDateTime
;
1068 wxDateTime
& wxDateTime::Set(wxDateTime_t hour
,
1069 wxDateTime_t minute
,
1070 wxDateTime_t second
,
1071 wxDateTime_t millisec
)
1073 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1075 // we allow seconds to be 61 to account for the leap seconds, even if we
1076 // don't use them really
1077 wxCHECK_MSG( hour
< 24 && second
< 62 && minute
< 60 && millisec
< 1000,
1079 _T("Invalid time in wxDateTime::Set()") );
1081 // get the current date from system
1082 struct tm
*tm
= GetTmNow();
1084 wxCHECK_MSG( tm
, wxInvalidDateTime
, _T("localtime() failed") );
1088 tm
->tm_min
= minute
;
1089 tm
->tm_sec
= second
;
1093 // and finally adjust milliseconds
1094 return SetMillisecond(millisec
);
1097 wxDateTime
& wxDateTime::Set(wxDateTime_t day
,
1101 wxDateTime_t minute
,
1102 wxDateTime_t second
,
1103 wxDateTime_t millisec
)
1105 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1107 wxCHECK_MSG( hour
< 24 && second
< 62 && minute
< 60 && millisec
< 1000,
1109 _T("Invalid time in wxDateTime::Set()") );
1111 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1113 wxCHECK_MSG( (0 < day
) && (day
<= GetNumberOfDays(month
, year
)),
1115 _T("Invalid date in wxDateTime::Set()") );
1117 // the range of time_t type (inclusive)
1118 static const int yearMinInRange
= 1970;
1119 static const int yearMaxInRange
= 2037;
1121 // test only the year instead of testing for the exact end of the Unix
1122 // time_t range - it doesn't bring anything to do more precise checks
1123 if ( year
>= yearMinInRange
&& year
<= yearMaxInRange
)
1125 // use the standard library version if the date is in range - this is
1126 // probably more efficient than our code
1128 tm
.tm_year
= year
- 1900;
1134 tm
.tm_isdst
= -1; // mktime() will guess it
1138 // and finally adjust milliseconds
1139 return SetMillisecond(millisec
);
1143 // do time calculations ourselves: we want to calculate the number of
1144 // milliseconds between the given date and the epoch
1146 // get the JDN for the midnight of this day
1147 m_time
= GetTruncatedJDN(day
, month
, year
);
1148 m_time
-= EPOCH_JDN
;
1149 m_time
*= SECONDS_PER_DAY
* TIME_T_FACTOR
;
1151 // JDN corresponds to GMT, we take localtime
1152 Add(wxTimeSpan(hour
, minute
, second
+ GetTimeZone(), millisec
));
1158 wxDateTime
& wxDateTime::Set(double jdn
)
1160 // so that m_time will be 0 for the midnight of Jan 1, 1970 which is jdn
1162 jdn
-= EPOCH_JDN
+ 0.5;
1164 jdn
*= MILLISECONDS_PER_DAY
;
1171 wxDateTime
& wxDateTime::ResetTime()
1175 if ( tm
.hour
|| tm
.min
|| tm
.sec
|| tm
.msec
)
1188 // ----------------------------------------------------------------------------
1189 // time_t <-> broken down time conversions
1190 // ----------------------------------------------------------------------------
1192 wxDateTime::Tm
wxDateTime::GetTm(const TimeZone
& tz
) const
1194 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1196 time_t time
= GetTicks();
1197 if ( time
!= (time_t)-1 )
1199 // use C RTL functions
1201 if ( tz
.GetOffset() == -GetTimeZone() )
1203 // we are working with local time
1204 tm
= localtime(&time
);
1206 // should never happen
1207 wxCHECK_MSG( tm
, Tm(), _T("gmtime() failed") );
1211 time
+= (time_t)tz
.GetOffset();
1212 #ifdef __VMS__ // time is unsigned so avoid warning
1213 int time2
= (int) time
;
1221 // should never happen
1222 wxCHECK_MSG( tm
, Tm(), _T("gmtime() failed") );
1226 tm
= (struct tm
*)NULL
;
1234 //else: use generic code below
1237 // remember the time and do the calculations with the date only - this
1238 // eliminates rounding errors of the floating point arithmetics
1240 wxLongLong timeMidnight
= m_time
+ tz
.GetOffset() * 1000;
1242 long timeOnly
= (timeMidnight
% MILLISECONDS_PER_DAY
).ToLong();
1244 // we want to always have positive time and timeMidnight to be really
1245 // the midnight before it
1248 timeOnly
= MILLISECONDS_PER_DAY
+ timeOnly
;
1251 timeMidnight
-= timeOnly
;
1253 // calculate the Gregorian date from JDN for the midnight of our date:
1254 // this will yield day, month (in 1..12 range) and year
1256 // actually, this is the JDN for the noon of the previous day
1257 long jdn
= (timeMidnight
/ MILLISECONDS_PER_DAY
).ToLong() + EPOCH_JDN
;
1259 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
1261 wxASSERT_MSG( jdn
> -2, _T("JDN out of range") );
1263 // calculate the century
1264 long temp
= (jdn
+ JDN_OFFSET
) * 4 - 1;
1265 long century
= temp
/ DAYS_PER_400_YEARS
;
1267 // then the year and day of year (1 <= dayOfYear <= 366)
1268 temp
= ((temp
% DAYS_PER_400_YEARS
) / 4) * 4 + 3;
1269 long year
= (century
* 100) + (temp
/ DAYS_PER_4_YEARS
);
1270 long dayOfYear
= (temp
% DAYS_PER_4_YEARS
) / 4 + 1;
1272 // and finally the month and day of the month
1273 temp
= dayOfYear
* 5 - 3;
1274 long month
= temp
/ DAYS_PER_5_MONTHS
;
1275 long day
= (temp
% DAYS_PER_5_MONTHS
) / 5 + 1;
1277 // month is counted from March - convert to normal
1288 // year is offset by 4800
1291 // check that the algorithm gave us something reasonable
1292 wxASSERT_MSG( (0 < month
) && (month
<= 12), _T("invalid month") );
1293 wxASSERT_MSG( (1 <= day
) && (day
< 32), _T("invalid day") );
1294 wxASSERT_MSG( (INT_MIN
<= year
) && (year
<= INT_MAX
),
1295 _T("year range overflow") );
1297 // construct Tm from these values
1299 tm
.year
= (int)year
;
1300 tm
.mon
= (Month
)(month
- 1); // algorithm yields 1 for January, not 0
1301 tm
.mday
= (wxDateTime_t
)day
;
1302 tm
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1303 timeOnly
-= tm
.msec
;
1304 timeOnly
/= 1000; // now we have time in seconds
1306 tm
.sec
= (wxDateTime_t
)(timeOnly
% 60);
1308 timeOnly
/= 60; // now we have time in minutes
1310 tm
.min
= (wxDateTime_t
)(timeOnly
% 60);
1313 tm
.hour
= (wxDateTime_t
)(timeOnly
/ 60);
1318 wxDateTime
& wxDateTime::SetYear(int year
)
1320 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1329 wxDateTime
& wxDateTime::SetMonth(Month month
)
1331 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1340 wxDateTime
& wxDateTime::SetDay(wxDateTime_t mday
)
1342 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1351 wxDateTime
& wxDateTime::SetHour(wxDateTime_t hour
)
1353 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1362 wxDateTime
& wxDateTime::SetMinute(wxDateTime_t min
)
1364 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1373 wxDateTime
& wxDateTime::SetSecond(wxDateTime_t sec
)
1375 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1384 wxDateTime
& wxDateTime::SetMillisecond(wxDateTime_t millisecond
)
1386 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1388 // we don't need to use GetTm() for this one
1389 m_time
-= m_time
% 1000l;
1390 m_time
+= millisecond
;
1395 // ----------------------------------------------------------------------------
1396 // wxDateTime arithmetics
1397 // ----------------------------------------------------------------------------
1399 wxDateTime
& wxDateTime::Add(const wxDateSpan
& diff
)
1403 tm
.year
+= diff
.GetYears();
1404 tm
.AddMonths(diff
.GetMonths());
1406 // check that the resulting date is valid
1407 if ( tm
.mday
> GetNumOfDaysInMonth(tm
.year
, tm
.mon
) )
1409 // We suppose that when adding one month to Jan 31 we want to get Feb
1410 // 28 (or 29), i.e. adding a month to the last day of the month should
1411 // give the last day of the next month which is quite logical.
1413 // Unfortunately, there is no logic way to understand what should
1414 // Jan 30 + 1 month be - Feb 28 too or Feb 27 (assuming non leap year)?
1415 // We make it Feb 28 (last day too), but it is highly questionable.
1416 tm
.mday
= GetNumOfDaysInMonth(tm
.year
, tm
.mon
);
1419 tm
.AddDays(diff
.GetTotalDays());
1423 wxASSERT_MSG( IsSameTime(tm
),
1424 _T("Add(wxDateSpan) shouldn't modify time") );
1429 // ----------------------------------------------------------------------------
1430 // Weekday and monthday stuff
1431 // ----------------------------------------------------------------------------
1433 bool wxDateTime::SetToTheWeek(wxDateTime_t numWeek
, WeekDay weekday
)
1435 int year
= GetYear();
1437 // Jan 4 always lies in the 1st week of the year
1439 SetToWeekDayInSameWeek(weekday
) += wxDateSpan::Weeks(numWeek
);
1441 if ( GetYear() != year
)
1443 // oops... numWeek was too big
1450 wxDateTime
& wxDateTime::SetToLastMonthDay(Month month
,
1453 // take the current month/year if none specified
1454 if ( year
== Inv_Year
)
1456 if ( month
== Inv_Month
)
1459 return Set(GetNumOfDaysInMonth(year
, month
), month
, year
);
1462 wxDateTime
& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday
)
1464 wxCHECK_MSG( weekday
!= Inv_WeekDay
, wxInvalidDateTime
, _T("invalid weekday") );
1466 WeekDay wdayThis
= GetWeekDay();
1467 if ( weekday
== wdayThis
)
1472 else if ( weekday
< wdayThis
)
1474 return Substract(wxDateSpan::Days(wdayThis
- weekday
));
1476 else // weekday > wdayThis
1478 return Add(wxDateSpan::Days(weekday
- wdayThis
));
1482 wxDateTime
& wxDateTime::SetToNextWeekDay(WeekDay weekday
)
1484 wxCHECK_MSG( weekday
!= Inv_WeekDay
, wxInvalidDateTime
, _T("invalid weekday") );
1487 WeekDay wdayThis
= GetWeekDay();
1488 if ( weekday
== wdayThis
)
1493 else if ( weekday
< wdayThis
)
1495 // need to advance a week
1496 diff
= 7 - (wdayThis
- weekday
);
1498 else // weekday > wdayThis
1500 diff
= weekday
- wdayThis
;
1503 return Add(wxDateSpan::Days(diff
));
1506 wxDateTime
& wxDateTime::SetToPrevWeekDay(WeekDay weekday
)
1508 wxCHECK_MSG( weekday
!= Inv_WeekDay
, wxInvalidDateTime
, _T("invalid weekday") );
1511 WeekDay wdayThis
= GetWeekDay();
1512 if ( weekday
== wdayThis
)
1517 else if ( weekday
> wdayThis
)
1519 // need to go to previous week
1520 diff
= 7 - (weekday
- wdayThis
);
1522 else // weekday < wdayThis
1524 diff
= wdayThis
- weekday
;
1527 return Substract(wxDateSpan::Days(diff
));
1530 bool wxDateTime::SetToWeekDay(WeekDay weekday
,
1535 wxCHECK_MSG( weekday
!= Inv_WeekDay
, FALSE
, _T("invalid weekday") );
1537 // we don't check explicitly that -5 <= n <= 5 because we will return FALSE
1538 // anyhow in such case - but may be should still give an assert for it?
1540 // take the current month/year if none specified
1541 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1545 // TODO this probably could be optimised somehow...
1549 // get the first day of the month
1550 dt
.Set(1, month
, year
);
1553 WeekDay wdayFirst
= dt
.GetWeekDay();
1555 // go to the first weekday of the month
1556 int diff
= weekday
- wdayFirst
;
1560 // add advance n-1 weeks more
1563 dt
+= wxDateSpan::Days(diff
);
1565 else // count from the end of the month
1567 // get the last day of the month
1568 dt
.SetToLastMonthDay(month
, year
);
1571 WeekDay wdayLast
= dt
.GetWeekDay();
1573 // go to the last weekday of the month
1574 int diff
= wdayLast
- weekday
;
1578 // and rewind n-1 weeks from there
1581 dt
-= wxDateSpan::Days(diff
);
1584 // check that it is still in the same month
1585 if ( dt
.GetMonth() == month
)
1593 // no such day in this month
1598 wxDateTime::wxDateTime_t
wxDateTime::GetDayOfYear(const TimeZone
& tz
) const
1602 return gs_cumulatedDays
[IsLeapYear(tm
.year
)][tm
.mon
] + tm
.mday
;
1605 wxDateTime::wxDateTime_t
wxDateTime::GetWeekOfYear(wxDateTime::WeekFlags flags
,
1606 const TimeZone
& tz
) const
1608 if ( flags
== Default_First
)
1610 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
1613 wxDateTime_t nDayInYear
= GetDayOfYear(tz
);
1616 WeekDay wd
= GetWeekDay(tz
);
1617 if ( flags
== Sunday_First
)
1619 week
= (nDayInYear
- wd
+ 7) / 7;
1623 // have to shift the week days values
1624 week
= (nDayInYear
- (wd
- 1 + 7) % 7 + 7) / 7;
1627 // FIXME some more elegant way??
1628 WeekDay wdYearStart
= wxDateTime(1, Jan
, GetYear()).GetWeekDay();
1629 if ( wdYearStart
== Wed
|| wdYearStart
== Thu
)
1637 wxDateTime::wxDateTime_t
wxDateTime::GetWeekOfMonth(wxDateTime::WeekFlags flags
,
1638 const TimeZone
& tz
) const
1641 wxDateTime dtMonthStart
= wxDateTime(1, tm
.mon
, tm
.year
);
1642 size_t nWeek
= GetWeekOfYear(flags
) - dtMonthStart
.GetWeekOfYear(flags
) + 1;
1643 #ifdef __VMS__ // nWeek is unsigned so avoid the warning
1644 int nweek2
= (int) nWeek
;
1650 // this may happen for January when Jan, 1 is the last week of the
1652 nWeek
+= IsLeapYear(tm
.year
- 1) ? 53 : 52;
1658 wxDateTime
& wxDateTime::SetToYearDay(wxDateTime::wxDateTime_t yday
)
1660 int year
= GetYear();
1661 wxCHECK_MSG( (0 < yday
) && (yday
<= GetNumberOfDays(year
)),
1662 wxInvalidDateTime
, _T("invalid year day") );
1664 bool isLeap
= IsLeapYear(year
);
1665 for ( Month mon
= Jan
; mon
< Inv_Month
; wxNextMonth(mon
) )
1667 // for Dec, we can't compare with gs_cumulatedDays[mon + 1], but we
1668 // don't need it neither - because of the CHECK above we know that
1669 // yday lies in December then
1670 if ( (mon
== Dec
) || (yday
< gs_cumulatedDays
[isLeap
][mon
+ 1]) )
1672 Set(yday
- gs_cumulatedDays
[isLeap
][mon
], mon
, year
);
1681 // ----------------------------------------------------------------------------
1682 // Julian day number conversion and related stuff
1683 // ----------------------------------------------------------------------------
1685 double wxDateTime::GetJulianDayNumber() const
1687 // JDN are always expressed for the GMT dates
1688 Tm
tm(ToTimezone(GMT0
).GetTm(GMT0
));
1690 double result
= GetTruncatedJDN(tm
.mday
, tm
.mon
, tm
.year
);
1692 // add the part GetTruncatedJDN() neglected
1695 // and now add the time: 86400 sec = 1 JDN
1696 return result
+ ((double)(60*(60*tm
.hour
+ tm
.min
) + tm
.sec
)) / 86400;
1699 double wxDateTime::GetRataDie() const
1701 // March 1 of the year 0 is Rata Die day -306 and JDN 1721119.5
1702 return GetJulianDayNumber() - 1721119.5 - 306;
1705 // ----------------------------------------------------------------------------
1706 // timezone and DST stuff
1707 // ----------------------------------------------------------------------------
1709 int wxDateTime::IsDST(wxDateTime::Country country
) const
1711 wxCHECK_MSG( country
== Country_Default
, -1,
1712 _T("country support not implemented") );
1714 // use the C RTL for the dates in the standard range
1715 time_t timet
= GetTicks();
1716 if ( timet
!= (time_t)-1 )
1718 tm
*tm
= localtime(&timet
);
1720 wxCHECK_MSG( tm
, -1, _T("localtime() failed") );
1722 return tm
->tm_isdst
;
1726 int year
= GetYear();
1728 if ( !IsDSTApplicable(year
, country
) )
1730 // no DST time in this year in this country
1734 return IsBetween(GetBeginDST(year
, country
), GetEndDST(year
, country
));
1738 wxDateTime
& wxDateTime::MakeTimezone(const TimeZone
& tz
, bool noDST
)
1740 long secDiff
= GetTimeZone() + tz
.GetOffset();
1742 // we need to know whether DST is or not in effect for this date unless
1743 // the test disabled by the caller
1744 if ( !noDST
&& (IsDST() == 1) )
1746 // FIXME we assume that the DST is always shifted by 1 hour
1750 return Substract(wxTimeSpan::Seconds(secDiff
));
1753 // ----------------------------------------------------------------------------
1754 // wxDateTime to/from text representations
1755 // ----------------------------------------------------------------------------
1757 wxString
wxDateTime::Format(const wxChar
*format
, const TimeZone
& tz
) const
1759 wxCHECK_MSG( format
, _T(""), _T("NULL format in wxDateTime::Format") );
1761 time_t time
= GetTicks();
1762 if ( time
!= (time_t)-1 )
1766 if ( tz
.GetOffset() == -GetTimeZone() )
1768 // we are working with local time
1769 tm
= localtime(&time
);
1771 // should never happen
1772 wxCHECK_MSG( tm
, wxEmptyString
, _T("localtime() failed") );
1776 time
+= (int)tz
.GetOffset();
1778 #ifdef __VMS__ // time is unsigned so avoid the warning
1779 int time2
= (int) time
;
1787 // should never happen
1788 wxCHECK_MSG( tm
, wxEmptyString
, _T("gmtime() failed") );
1792 tm
= (struct tm
*)NULL
;
1798 return CallStrftime(format
, tm
);
1800 //else: use generic code below
1803 // we only parse ANSI C format specifications here, no POSIX 2
1804 // complications, no GNU extensions
1807 // used for calls to strftime() when we only deal with time
1808 struct tm tmTimeOnly
;
1809 tmTimeOnly
.tm_hour
= tm
.hour
;
1810 tmTimeOnly
.tm_min
= tm
.min
;
1811 tmTimeOnly
.tm_sec
= tm
.sec
;
1812 tmTimeOnly
.tm_wday
= 0;
1813 tmTimeOnly
.tm_yday
= 0;
1814 tmTimeOnly
.tm_mday
= 1; // any date will do
1815 tmTimeOnly
.tm_mon
= 0;
1816 tmTimeOnly
.tm_year
= 76;
1817 tmTimeOnly
.tm_isdst
= 0; // no DST, we adjust for tz ourselves
1819 wxString tmp
, res
, fmt
;
1820 for ( const wxChar
*p
= format
; *p
; p
++ )
1822 if ( *p
!= _T('%') )
1830 // set the default format
1833 case _T('Y'): // year has 4 digits
1837 case _T('j'): // day of year has 3 digits
1842 // it's either another valid format specifier in which case
1843 // the format is "%02d" (for all the rest) or we have the
1844 // field width preceding the format in which case it will
1845 // override the default format anyhow
1850 // start of the format specification
1853 case _T('a'): // a weekday name
1855 // second parameter should be TRUE for abbreviated names
1856 res
+= GetWeekDayName(tm
.GetWeekDay(),
1857 *p
== _T('a') ? Name_Abbr
: Name_Full
);
1860 case _T('b'): // a month name
1862 res
+= GetMonthName(tm
.mon
,
1863 *p
== _T('b') ? Name_Abbr
: Name_Full
);
1866 case _T('c'): // locale default date and time representation
1867 case _T('x'): // locale default date representation
1869 // the problem: there is no way to know what do these format
1870 // specifications correspond to for the current locale.
1872 // the solution: use a hack and still use strftime(): first
1873 // find the YEAR which is a year in the strftime() range (1970
1874 // - 2038) whose Jan 1 falls on the same week day as the Jan 1
1875 // of the real year. Then make a copy of the format and
1876 // replace all occurences of YEAR in it with some unique
1877 // string not appearing anywhere else in it, then use
1878 // strftime() to format the date in year YEAR and then replace
1879 // YEAR back by the real year and the unique replacement
1880 // string back with YEAR. Notice that "all occurences of YEAR"
1881 // means all occurences of 4 digit as well as 2 digit form!
1883 // the bugs: we assume that neither of %c nor %x contains any
1884 // fields which may change between the YEAR and real year. For
1885 // example, the week number (%U, %W) and the day number (%j)
1886 // will change if one of these years is leap and the other one
1889 // find the YEAR: normally, for any year X, Jan 1 or the
1890 // year X + 28 is the same weekday as Jan 1 of X (because
1891 // the weekday advances by 1 for each normal X and by 2
1892 // for each leap X, hence by 5 every 4 years or by 35
1893 // which is 0 mod 7 every 28 years) but this rule breaks
1894 // down if there are years between X and Y which are
1895 // divisible by 4 but not leap (i.e. divisible by 100 but
1896 // not 400), hence the correction.
1898 int yearReal
= GetYear(tz
);
1899 int mod28
= yearReal
% 28;
1901 // be careful to not go too far - we risk to leave the
1906 year
= 1988 + mod28
; // 1988 == 0 (mod 28)
1910 year
= 1970 + mod28
- 10; // 1970 == 10 (mod 28)
1913 int nCentury
= year
/ 100,
1914 nCenturyReal
= yearReal
/ 100;
1916 // need to adjust for the years divisble by 400 which are
1917 // not leap but are counted like leap ones if we just take
1918 // the number of centuries in between for nLostWeekDays
1919 int nLostWeekDays
= (nCentury
- nCenturyReal
) -
1920 (nCentury
/ 4 - nCenturyReal
/ 4);
1922 // we have to gain back the "lost" weekdays: note that the
1923 // effect of this loop is to not do anything to
1924 // nLostWeekDays (which we won't use any more), but to
1925 // (indirectly) set the year correctly
1926 while ( (nLostWeekDays
% 7) != 0 )
1928 nLostWeekDays
+= year
++ % 4 ? 1 : 2;
1931 // at any rate, we couldn't go further than 1988 + 9 + 28!
1932 wxASSERT_MSG( year
< 2030,
1933 _T("logic error in wxDateTime::Format") );
1935 wxString strYear
, strYear2
;
1936 strYear
.Printf(_T("%d"), year
);
1937 strYear2
.Printf(_T("%d"), year
% 100);
1939 // find two strings not occuring in format (this is surely
1940 // not optimal way of doing it... improvements welcome!)
1941 wxString fmt
= format
;
1942 wxString replacement
= (wxChar
)-1;
1943 while ( fmt
.Find(replacement
) != wxNOT_FOUND
)
1945 replacement
<< (wxChar
)-1;
1948 wxString replacement2
= (wxChar
)-2;
1949 while ( fmt
.Find(replacement
) != wxNOT_FOUND
)
1951 replacement
<< (wxChar
)-2;
1954 // replace all occurences of year with it
1955 bool wasReplaced
= fmt
.Replace(strYear
, replacement
) > 0;
1957 wasReplaced
= fmt
.Replace(strYear2
, replacement2
) > 0;
1959 // use strftime() to format the same date but in supported
1962 // NB: we assume that strftime() doesn't check for the
1963 // date validity and will happily format the date
1964 // corresponding to Feb 29 of a non leap year (which
1965 // may happen if yearReal was leap and year is not)
1966 struct tm tmAdjusted
;
1968 tmAdjusted
.tm_hour
= tm
.hour
;
1969 tmAdjusted
.tm_min
= tm
.min
;
1970 tmAdjusted
.tm_sec
= tm
.sec
;
1971 tmAdjusted
.tm_wday
= tm
.GetWeekDay();
1972 tmAdjusted
.tm_yday
= GetDayOfYear();
1973 tmAdjusted
.tm_mday
= tm
.mday
;
1974 tmAdjusted
.tm_mon
= tm
.mon
;
1975 tmAdjusted
.tm_year
= year
- 1900;
1976 tmAdjusted
.tm_isdst
= 0; // no DST, already adjusted
1977 wxString str
= CallStrftime(*p
== _T('c') ? _T("%c")
1981 // now replace the occurence of 1999 with the real year
1982 wxString strYearReal
, strYearReal2
;
1983 strYearReal
.Printf(_T("%04d"), yearReal
);
1984 strYearReal2
.Printf(_T("%02d"), yearReal
% 100);
1985 str
.Replace(strYear
, strYearReal
);
1986 str
.Replace(strYear2
, strYearReal2
);
1988 // and replace back all occurences of replacement string
1991 str
.Replace(replacement2
, strYear2
);
1992 str
.Replace(replacement
, strYear
);
1999 case _T('d'): // day of a month (01-31)
2000 res
+= wxString::Format(fmt
, tm
.mday
);
2003 case _T('H'): // hour in 24h format (00-23)
2004 res
+= wxString::Format(fmt
, tm
.hour
);
2007 case _T('I'): // hour in 12h format (01-12)
2009 // 24h -> 12h, 0h -> 12h too
2010 int hour12
= tm
.hour
> 12 ? tm
.hour
- 12
2011 : tm
.hour
? tm
.hour
: 12;
2012 res
+= wxString::Format(fmt
, hour12
);
2016 case _T('j'): // day of the year
2017 res
+= wxString::Format(fmt
, GetDayOfYear(tz
));
2020 case _T('m'): // month as a number (01-12)
2021 res
+= wxString::Format(fmt
, tm
.mon
+ 1);
2024 case _T('M'): // minute as a decimal number (00-59)
2025 res
+= wxString::Format(fmt
, tm
.min
);
2028 case _T('p'): // AM or PM string
2029 res
+= CallStrftime(_T("%p"), &tmTimeOnly
);
2032 case _T('S'): // second as a decimal number (00-61)
2033 res
+= wxString::Format(fmt
, tm
.sec
);
2036 case _T('U'): // week number in the year (Sunday 1st week day)
2037 res
+= wxString::Format(fmt
, GetWeekOfYear(Sunday_First
, tz
));
2040 case _T('W'): // week number in the year (Monday 1st week day)
2041 res
+= wxString::Format(fmt
, GetWeekOfYear(Monday_First
, tz
));
2044 case _T('w'): // weekday as a number (0-6), Sunday = 0
2045 res
+= wxString::Format(fmt
, tm
.GetWeekDay());
2048 // case _T('x'): -- handled with "%c"
2050 case _T('X'): // locale default time representation
2051 // just use strftime() to format the time for us
2052 res
+= CallStrftime(_T("%X"), &tmTimeOnly
);
2055 case _T('y'): // year without century (00-99)
2056 res
+= wxString::Format(fmt
, tm
.year
% 100);
2059 case _T('Y'): // year with century
2060 res
+= wxString::Format(fmt
, tm
.year
);
2063 case _T('Z'): // timezone name
2064 res
+= CallStrftime(_T("%Z"), &tmTimeOnly
);
2068 // is it the format width?
2070 while ( *p
== _T('-') || *p
== _T('+') ||
2071 *p
== _T(' ') || wxIsdigit(*p
) )
2076 if ( !fmt
.IsEmpty() )
2078 // we've only got the flags and width so far in fmt
2079 fmt
.Prepend(_T('%'));
2080 fmt
.Append(_T('d'));
2085 // no, it wasn't the width
2086 wxFAIL_MSG(_T("unknown format specificator"));
2088 // fall through and just copy it nevertheless
2090 case _T('%'): // a percent sign
2094 case 0: // the end of string
2095 wxFAIL_MSG(_T("missing format at the end of string"));
2097 // just put the '%' which was the last char in format
2106 // this function parses a string in (strict) RFC 822 format: see the section 5
2107 // of the RFC for the detailed description, but briefly it's something of the
2108 // form "Sat, 18 Dec 1999 00:48:30 +0100"
2110 // this function is "strict" by design - it must reject anything except true
2111 // RFC822 time specs.
2113 // TODO a great candidate for using reg exps
2114 const wxChar
*wxDateTime::ParseRfc822Date(const wxChar
* date
)
2116 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
2118 const wxChar
*p
= date
;
2119 const wxChar
*comma
= wxStrchr(p
, _T(','));
2122 // the part before comma is the weekday
2124 // skip it for now - we don't use but might check that it really
2125 // corresponds to the specfied date
2128 if ( *p
!= _T(' ') )
2130 wxLogDebug(_T("no space after weekday in RFC822 time spec"));
2132 return (wxChar
*)NULL
;
2138 // the following 1 or 2 digits are the day number
2139 if ( !wxIsdigit(*p
) )
2141 wxLogDebug(_T("day number expected in RFC822 time spec, none found"));
2143 return (wxChar
*)NULL
;
2146 wxDateTime_t day
= *p
++ - _T('0');
2147 if ( wxIsdigit(*p
) )
2150 day
+= *p
++ - _T('0');
2153 if ( *p
++ != _T(' ') )
2155 return (wxChar
*)NULL
;
2158 // the following 3 letters specify the month
2159 wxString
monName(p
, 3);
2161 if ( monName
== _T("Jan") )
2163 else if ( monName
== _T("Feb") )
2165 else if ( monName
== _T("Mar") )
2167 else if ( monName
== _T("Apr") )
2169 else if ( monName
== _T("May") )
2171 else if ( monName
== _T("Jun") )
2173 else if ( monName
== _T("Jul") )
2175 else if ( monName
== _T("Aug") )
2177 else if ( monName
== _T("Sep") )
2179 else if ( monName
== _T("Oct") )
2181 else if ( monName
== _T("Nov") )
2183 else if ( monName
== _T("Dec") )
2187 wxLogDebug(_T("Invalid RFC 822 month name '%s'"), monName
.c_str());
2189 return (wxChar
*)NULL
;
2194 if ( *p
++ != _T(' ') )
2196 return (wxChar
*)NULL
;
2200 if ( !wxIsdigit(*p
) )
2203 return (wxChar
*)NULL
;
2206 int year
= *p
++ - _T('0');
2208 if ( !wxIsdigit(*p
) )
2210 // should have at least 2 digits in the year
2211 return (wxChar
*)NULL
;
2215 year
+= *p
++ - _T('0');
2217 // is it a 2 digit year (as per original RFC 822) or a 4 digit one?
2218 if ( wxIsdigit(*p
) )
2221 year
+= *p
++ - _T('0');
2223 if ( !wxIsdigit(*p
) )
2225 // no 3 digit years please
2226 return (wxChar
*)NULL
;
2230 year
+= *p
++ - _T('0');
2233 if ( *p
++ != _T(' ') )
2235 return (wxChar
*)NULL
;
2238 // time is in the format hh:mm:ss and seconds are optional
2239 if ( !wxIsdigit(*p
) )
2241 return (wxChar
*)NULL
;
2244 wxDateTime_t hour
= *p
++ - _T('0');
2246 if ( !wxIsdigit(*p
) )
2248 return (wxChar
*)NULL
;
2252 hour
+= *p
++ - _T('0');
2254 if ( *p
++ != _T(':') )
2256 return (wxChar
*)NULL
;
2259 if ( !wxIsdigit(*p
) )
2261 return (wxChar
*)NULL
;
2264 wxDateTime_t min
= *p
++ - _T('0');
2266 if ( !wxIsdigit(*p
) )
2268 return (wxChar
*)NULL
;
2272 min
+= *p
++ - _T('0');
2274 wxDateTime_t sec
= 0;
2275 if ( *p
++ == _T(':') )
2277 if ( !wxIsdigit(*p
) )
2279 return (wxChar
*)NULL
;
2282 sec
= *p
++ - _T('0');
2284 if ( !wxIsdigit(*p
) )
2286 return (wxChar
*)NULL
;
2290 sec
+= *p
++ - _T('0');
2293 if ( *p
++ != _T(' ') )
2295 return (wxChar
*)NULL
;
2298 // and now the interesting part: the timezone
2300 if ( *p
== _T('-') || *p
== _T('+') )
2302 // the explicit offset given: it has the form of hhmm
2303 bool plus
= *p
++ == _T('+');
2305 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2307 return (wxChar
*)NULL
;
2311 offset
= 60*(10*(*p
- _T('0')) + (*(p
+ 1) - _T('0')));
2315 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2317 return (wxChar
*)NULL
;
2321 offset
+= 10*(*p
- _T('0')) + (*(p
+ 1) - _T('0'));
2332 // the symbolic timezone given: may be either military timezone or one
2333 // of standard abbreviations
2336 // military: Z = UTC, J unused, A = -1, ..., Y = +12
2337 static const int offsets
[26] =
2339 //A B C D E F G H I J K L M
2340 -1, -2, -3, -4, -5, -6, -7, -8, -9, 0, -10, -11, -12,
2341 //N O P R Q S T U V W Z Y Z
2342 +1, +2, +3, +4, +5, +6, +7, +8, +9, +10, +11, +12, 0
2345 if ( *p
< _T('A') || *p
> _T('Z') || *p
== _T('J') )
2347 wxLogDebug(_T("Invalid militaty timezone '%c'"), *p
);
2349 return (wxChar
*)NULL
;
2352 offset
= offsets
[*p
++ - _T('A')];
2358 if ( tz
== _T("UT") || tz
== _T("UTC") || tz
== _T("GMT") )
2360 else if ( tz
== _T("AST") )
2361 offset
= AST
- GMT0
;
2362 else if ( tz
== _T("ADT") )
2363 offset
= ADT
- GMT0
;
2364 else if ( tz
== _T("EST") )
2365 offset
= EST
- GMT0
;
2366 else if ( tz
== _T("EDT") )
2367 offset
= EDT
- GMT0
;
2368 else if ( tz
== _T("CST") )
2369 offset
= CST
- GMT0
;
2370 else if ( tz
== _T("CDT") )
2371 offset
= CDT
- GMT0
;
2372 else if ( tz
== _T("MST") )
2373 offset
= MST
- GMT0
;
2374 else if ( tz
== _T("MDT") )
2375 offset
= MDT
- GMT0
;
2376 else if ( tz
== _T("PST") )
2377 offset
= PST
- GMT0
;
2378 else if ( tz
== _T("PDT") )
2379 offset
= PDT
- GMT0
;
2382 wxLogDebug(_T("Unknown RFC 822 timezone '%s'"), p
);
2384 return (wxChar
*)NULL
;
2394 // the spec was correct
2395 Set(day
, mon
, year
, hour
, min
, sec
);
2396 MakeTimezone((wxDateTime_t
)(60*offset
));
2401 const wxChar
*wxDateTime::ParseFormat(const wxChar
*date
,
2402 const wxChar
*format
,
2403 const wxDateTime
& dateDef
)
2405 wxCHECK_MSG( date
&& format
, (wxChar
*)NULL
,
2406 _T("NULL pointer in wxDateTime::ParseFormat()") );
2411 // what fields have we found?
2412 bool haveWDay
= FALSE
,
2421 bool hourIsIn12hFormat
= FALSE
, // or in 24h one?
2422 isPM
= FALSE
; // AM by default
2424 // and the value of the items we have (init them to get rid of warnings)
2425 wxDateTime_t sec
= 0,
2428 WeekDay wday
= Inv_WeekDay
;
2429 wxDateTime_t yday
= 0,
2431 wxDateTime::Month mon
= Inv_Month
;
2434 const wxChar
*input
= date
;
2435 for ( const wxChar
*fmt
= format
; *fmt
; fmt
++ )
2437 if ( *fmt
!= _T('%') )
2439 if ( wxIsspace(*fmt
) )
2441 // a white space in the format string matches 0 or more white
2442 // spaces in the input
2443 while ( wxIsspace(*input
) )
2450 // any other character (not whitespace, not '%') must be
2451 // matched by itself in the input
2452 if ( *input
++ != *fmt
)
2455 return (wxChar
*)NULL
;
2459 // done with this format char
2463 // start of a format specification
2466 case _T('a'): // a weekday name
2469 int flag
= *fmt
== _T('a') ? Name_Abbr
: Name_Full
;
2470 wday
= GetWeekDayFromName(GetAlphaToken(input
), flag
);
2471 if ( wday
== Inv_WeekDay
)
2474 return (wxChar
*)NULL
;
2480 case _T('b'): // a month name
2483 int flag
= *fmt
== _T('b') ? Name_Abbr
: Name_Full
;
2484 mon
= GetMonthFromName(GetAlphaToken(input
), flag
);
2485 if ( mon
== Inv_Month
)
2488 return (wxChar
*)NULL
;
2494 case _T('c'): // locale default date and time representation
2498 // this is the format which corresponds to ctime() output
2499 // and strptime("%c") should parse it, so try it first
2500 static const wxChar
*fmtCtime
= _T("%a %b %d %H:%M:%S %Y");
2502 const wxChar
*result
= dt
.ParseFormat(input
, fmtCtime
);
2505 result
= dt
.ParseFormat(input
, _T("%x %X"));
2510 result
= dt
.ParseFormat(input
, _T("%X %x"));
2515 // we've tried everything and still no match
2516 return (wxChar
*)NULL
;
2521 haveDay
= haveMon
= haveYear
=
2522 haveHour
= haveMin
= haveSec
= TRUE
;
2536 case _T('d'): // day of a month (01-31)
2537 if ( !GetNumericToken(input
, &num
) || (num
> 31) )
2540 return (wxChar
*)NULL
;
2543 // we can't check whether the day range is correct yet, will
2544 // do it later - assume ok for now
2546 mday
= (wxDateTime_t
)num
;
2549 case _T('H'): // hour in 24h format (00-23)
2550 if ( !GetNumericToken(input
, &num
) || (num
> 23) )
2553 return (wxChar
*)NULL
;
2557 hour
= (wxDateTime_t
)num
;
2560 case _T('I'): // hour in 12h format (01-12)
2561 if ( !GetNumericToken(input
, &num
) || !num
|| (num
> 12) )
2564 return (wxChar
*)NULL
;
2568 hourIsIn12hFormat
= TRUE
;
2569 hour
= (wxDateTime_t
)(num
% 12); // 12 should be 0
2572 case _T('j'): // day of the year
2573 if ( !GetNumericToken(input
, &num
) || !num
|| (num
> 366) )
2576 return (wxChar
*)NULL
;
2580 yday
= (wxDateTime_t
)num
;
2583 case _T('m'): // month as a number (01-12)
2584 if ( !GetNumericToken(input
, &num
) || !num
|| (num
> 12) )
2587 return (wxChar
*)NULL
;
2591 mon
= (Month
)(num
- 1);
2594 case _T('M'): // minute as a decimal number (00-59)
2595 if ( !GetNumericToken(input
, &num
) || (num
> 59) )
2598 return (wxChar
*)NULL
;
2602 min
= (wxDateTime_t
)num
;
2605 case _T('p'): // AM or PM string
2607 wxString am
, pm
, token
= GetAlphaToken(input
);
2609 GetAmPmStrings(&am
, &pm
);
2610 if ( token
.CmpNoCase(pm
) == 0 )
2614 else if ( token
.CmpNoCase(am
) != 0 )
2617 return (wxChar
*)NULL
;
2622 case _T('r'): // time as %I:%M:%S %p
2625 input
= dt
.ParseFormat(input
, _T("%I:%M:%S %p"));
2629 return (wxChar
*)NULL
;
2632 haveHour
= haveMin
= haveSec
= TRUE
;
2641 case _T('R'): // time as %H:%M
2644 input
= dt
.ParseFormat(input
, _T("%H:%M"));
2648 return (wxChar
*)NULL
;
2651 haveHour
= haveMin
= TRUE
;
2658 case _T('S'): // second as a decimal number (00-61)
2659 if ( !GetNumericToken(input
, &num
) || (num
> 61) )
2662 return (wxChar
*)NULL
;
2666 sec
= (wxDateTime_t
)num
;
2669 case _T('T'): // time as %H:%M:%S
2672 input
= dt
.ParseFormat(input
, _T("%H:%M:%S"));
2676 return (wxChar
*)NULL
;
2679 haveHour
= haveMin
= haveSec
= TRUE
;
2688 case _T('w'): // weekday as a number (0-6), Sunday = 0
2689 if ( !GetNumericToken(input
, &num
) || (wday
> 6) )
2692 return (wxChar
*)NULL
;
2696 wday
= (WeekDay
)num
;
2699 case _T('x'): // locale default date representation
2700 #ifdef HAVE_STRPTIME
2701 // try using strptime() - it may fail even if the input is
2702 // correct but the date is out of range, so we will fall back
2703 // to our generic code anyhow (FIXME !Unicode friendly)
2706 const wxChar
*result
= strptime(input
, "%x", &tm
);
2711 haveDay
= haveMon
= haveYear
= TRUE
;
2713 year
= 1900 + tm
.tm_year
;
2714 mon
= (Month
)tm
.tm_mon
;
2720 #endif // HAVE_STRPTIME
2722 // TODO query the LOCALE_IDATE setting under Win32
2726 wxString fmtDate
, fmtDateAlt
;
2727 if ( IsWestEuropeanCountry(GetCountry()) ||
2728 GetCountry() == Russia
)
2730 fmtDate
= _T("%d/%m/%y");
2731 fmtDateAlt
= _T("%m/%d/%y");
2735 fmtDate
= _T("%m/%d/%y");
2736 fmtDateAlt
= _T("%d/%m/%y");
2739 const wxChar
*result
= dt
.ParseFormat(input
, fmtDate
);
2743 // ok, be nice and try another one
2744 result
= dt
.ParseFormat(input
, fmtDateAlt
);
2750 return (wxChar
*)NULL
;
2755 haveDay
= haveMon
= haveYear
= TRUE
;
2766 case _T('X'): // locale default time representation
2767 #ifdef HAVE_STRPTIME
2769 // use strptime() to do it for us (FIXME !Unicode friendly)
2771 input
= strptime(input
, "%X", &tm
);
2774 return (wxChar
*)NULL
;
2777 haveHour
= haveMin
= haveSec
= TRUE
;
2783 #else // !HAVE_STRPTIME
2784 // TODO under Win32 we can query the LOCALE_ITIME system
2785 // setting which says whether the default time format is
2788 // try to parse what follows as "%H:%M:%S" and, if this
2789 // fails, as "%I:%M:%S %p" - this should catch the most
2793 const wxChar
*result
= dt
.ParseFormat(input
, _T("%T"));
2796 result
= dt
.ParseFormat(input
, _T("%r"));
2802 return (wxChar
*)NULL
;
2805 haveHour
= haveMin
= haveSec
= TRUE
;
2814 #endif // HAVE_STRPTIME/!HAVE_STRPTIME
2817 case _T('y'): // year without century (00-99)
2818 if ( !GetNumericToken(input
, &num
) || (num
> 99) )
2821 return (wxChar
*)NULL
;
2825 year
= 1900 + (wxDateTime_t
)num
;
2828 case _T('Y'): // year with century
2829 if ( !GetNumericToken(input
, &num
) )
2832 return (wxChar
*)NULL
;
2836 year
= (wxDateTime_t
)num
;
2839 case _T('Z'): // timezone name
2840 wxFAIL_MSG(_T("TODO"));
2843 case _T('%'): // a percent sign
2844 if ( *input
++ != _T('%') )
2847 return (wxChar
*)NULL
;
2851 case 0: // the end of string
2852 wxFAIL_MSG(_T("unexpected format end"));
2856 default: // not a known format spec
2857 return (wxChar
*)NULL
;
2861 // format matched, try to construct a date from what we have now
2863 if ( dateDef
.IsValid() )
2865 // take this date as default
2866 tmDef
= dateDef
.GetTm();
2868 else if ( m_time
!= 0 )
2870 // if this date is valid, don't change it
2875 // no default and this date is invalid - fall back to Today()
2876 tmDef
= Today().GetTm();
2887 // TODO we don't check here that the values are consistent, if both year
2888 // day and month/day were found, we just ignore the year day and we
2889 // also always ignore the week day
2890 if ( haveMon
&& haveDay
)
2892 if ( mday
> GetNumOfDaysInMonth(tm
.year
, mon
) )
2894 wxLogDebug(_T("bad month day in wxDateTime::ParseFormat"));
2896 return (wxChar
*)NULL
;
2902 else if ( haveYDay
)
2904 if ( yday
> GetNumberOfDays(tm
.year
) )
2906 wxLogDebug(_T("bad year day in wxDateTime::ParseFormat"));
2908 return (wxChar
*)NULL
;
2911 Tm tm2
= wxDateTime(1, Jan
, tm
.year
).SetToYearDay(yday
).GetTm();
2918 if ( haveHour
&& hourIsIn12hFormat
&& isPM
)
2920 // translate to 24hour format
2923 //else: either already in 24h format or no translation needed
2946 const wxChar
*wxDateTime::ParseDateTime(const wxChar
*date
)
2948 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
2950 // there is a public domain version of getdate.y, but it only works for
2952 wxFAIL_MSG(_T("TODO"));
2954 return (wxChar
*)NULL
;
2957 const wxChar
*wxDateTime::ParseDate(const wxChar
*date
)
2959 // this is a simplified version of ParseDateTime() which understands only
2960 // "today" (for wxDate compatibility) and digits only otherwise (and not
2961 // all esoteric constructions ParseDateTime() knows about)
2963 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
2965 const wxChar
*p
= date
;
2966 while ( wxIsspace(*p
) )
2969 // some special cases
2973 int dayDiffFromToday
;
2976 { wxTRANSLATE("today"), 0 },
2977 { wxTRANSLATE("yesterday"), -1 },
2978 { wxTRANSLATE("tomorrow"), 1 },
2981 for ( size_t n
= 0; n
< WXSIZEOF(literalDates
); n
++ )
2983 wxString date
= wxGetTranslation(literalDates
[n
].str
);
2984 size_t len
= date
.length();
2985 if ( wxString(p
, len
).CmpNoCase(date
) == 0 )
2987 // nothing can follow this, so stop here
2990 int dayDiffFromToday
= literalDates
[n
].dayDiffFromToday
;
2992 if ( dayDiffFromToday
)
2994 *this += wxDateSpan::Days(dayDiffFromToday
);
3002 bool haveDay
= FALSE
, // the months day?
3003 haveWDay
= FALSE
, // the day of week?
3004 haveMon
= FALSE
, // the month?
3005 haveYear
= FALSE
; // the year?
3007 // and the value of the items we have (init them to get rid of warnings)
3008 WeekDay wday
= Inv_WeekDay
;
3009 wxDateTime_t day
= 0;
3010 wxDateTime::Month mon
= Inv_Month
;
3013 // tokenize the string
3014 wxStringTokenizer
tok(p
, _T(",/-\t\n "));
3015 while ( tok
.HasMoreTokens() )
3017 wxString token
= tok
.GetNextToken();
3021 if ( token
.ToULong(&val
) )
3023 // guess what this number is
3027 // only years are counted from 0
3028 isYear
= (val
== 0) || (val
> 31);
3031 // may be the month or month day or the year, assume the
3032 // month day by default and fallback to month if the range
3033 // allow it or to the year if our assumption doesn't work
3036 // we already have the day, so may only be a month or year
3046 else // it may be day
3053 if ( val
> GetNumOfDaysInMonth(haveYear
? year
3057 // oops, it can't be a day finally
3073 // remember that we have this and stop the scan if it's the second
3074 // time we find this, except for the day logic (see there)
3084 // no roll over - 99 means 99, not 1999 for us
3085 year
= (wxDateTime_t
)val
;
3096 mon
= (wxDateTime::Month
)val
;
3100 wxASSERT_MSG( isDay
, _T("logic error") );
3104 // may be were mistaken when we found it for the first
3105 // time? may be it was a month or year instead?
3107 // this ability to "backtrack" allows us to correctly parse
3108 // both things like 01/13 and 13/01 - but, of course, we
3109 // still can't resolve the ambiguity in 01/02 (it will be
3110 // Feb 1 for us, not Jan 2 as americans might expect!)
3111 if ( (day
<= 12) && !haveMon
)
3113 // exchange day and month
3114 mon
= (wxDateTime::Month
)day
;
3118 else if ( !haveYear
)
3120 // exchange day and year
3129 day
= (wxDateTime_t
)val
;
3132 else // not a number
3134 mon
= GetMonthFromName(token
, Name_Full
| Name_Abbr
);
3135 if ( mon
!= Inv_Month
)
3147 wday
= GetWeekDayFromName(token
, Name_Full
| Name_Abbr
);
3148 if ( wday
!= Inv_WeekDay
)
3161 static const wxChar
*ordinals
[] =
3163 wxTRANSLATE("first"),
3164 wxTRANSLATE("second"),
3165 wxTRANSLATE("third"),
3166 wxTRANSLATE("fourth"),
3167 wxTRANSLATE("fifth"),
3168 wxTRANSLATE("sixth"),
3169 wxTRANSLATE("seventh"),
3170 wxTRANSLATE("eighth"),
3171 wxTRANSLATE("ninth"),
3172 wxTRANSLATE("tenth"),
3173 wxTRANSLATE("eleventh"),
3174 wxTRANSLATE("twelfth"),
3175 wxTRANSLATE("thirteenth"),
3176 wxTRANSLATE("fourteenth"),
3177 wxTRANSLATE("fifteenth"),
3178 wxTRANSLATE("sixteenth"),
3179 wxTRANSLATE("seventeenth"),
3180 wxTRANSLATE("eighteenth"),
3181 wxTRANSLATE("nineteenth"),
3182 wxTRANSLATE("twentieth"),
3183 // that's enough - otherwise we'd have problems with
3184 // composite (or not) ordinals otherwise
3188 for ( n
= 0; n
< WXSIZEOF(ordinals
); n
++ )
3190 if ( token
.CmpNoCase(ordinals
[n
]) == 0 )
3196 if ( n
== WXSIZEOF(ordinals
) )
3198 // stop here - something unknown
3205 // don't try anything here (as in case of numeric day
3206 // above) - the symbolic day spec should always
3207 // precede the month/year
3219 // either no more tokens or the scan was stopped by something we couldn't
3220 // parse - in any case, see if we can construct a date from what we have
3221 if ( !haveDay
&& !haveWDay
)
3223 wxLogDebug(_T("no day, no weekday hence no date."));
3225 return (wxChar
*)NULL
;
3228 if ( haveWDay
&& (haveMon
|| haveYear
|| haveDay
) &&
3229 !(haveMon
&& haveMon
&& haveYear
) )
3231 // without adjectives (which we don't support here) the week day only
3232 // makes sense completely separately or with the full date
3233 // specification (what would "Wed 1999" mean?)
3234 return (wxChar
*)NULL
;
3239 mon
= GetCurrentMonth();
3244 year
= GetCurrentYear();
3249 Set(day
, mon
, year
);
3253 // check that it is really the same
3254 if ( GetWeekDay() != wday
)
3256 // inconsistency detected
3257 return (wxChar
*)NULL
;
3265 SetToWeekDayInSameWeek(wday
);
3268 // return the pointer to the next char
3269 return p
+ wxStrlen(p
) - wxStrlen(tok
.GetString());
3272 const wxChar
*wxDateTime::ParseTime(const wxChar
*time
)
3274 wxCHECK_MSG( time
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3276 // first try some extra things
3283 { wxTRANSLATE("noon"), 12 },
3284 { wxTRANSLATE("midnight"), 00 },
3288 for ( size_t n
= 0; n
< WXSIZEOF(stdTimes
); n
++ )
3290 wxString timeString
= wxGetTranslation(stdTimes
[n
].name
);
3291 size_t len
= timeString
.length();
3292 if ( timeString
.CmpNoCase(wxString(time
, len
)) == 0 )
3294 Set(stdTimes
[n
].hour
, 0, 0);
3300 // try all time formats we may think about starting with the standard one
3301 const wxChar
*result
= ParseFormat(time
, _T("%X"));
3304 // normally, it's the same, but why not try it?
3305 result
= ParseFormat(time
, _T("%H:%M:%S"));
3310 // 12hour with AM/PM?
3311 result
= ParseFormat(time
, _T("%I:%M:%S %p"));
3317 result
= ParseFormat(time
, _T("%H:%M"));
3322 // 12hour with AM/PM but without seconds?
3323 result
= ParseFormat(time
, _T("%I:%M %p"));
3329 result
= ParseFormat(time
, _T("%H"));
3334 // just the hour and AM/PM?
3335 result
= ParseFormat(time
, _T("%I %p"));
3338 // TODO: parse timezones
3343 // ----------------------------------------------------------------------------
3344 // Workdays and holidays support
3345 // ----------------------------------------------------------------------------
3347 bool wxDateTime::IsWorkDay(Country
WXUNUSED(country
)) const
3349 return !wxDateTimeHolidayAuthority::IsHoliday(*this);
3352 // ============================================================================
3354 // ============================================================================
3356 // not all strftime(3) format specifiers make sense here because, for example,
3357 // a time span doesn't have a year nor a timezone
3359 // Here are the ones which are supported (all of them are supported by strftime
3361 // %H hour in 24 hour format
3362 // %M minute (00 - 59)
3363 // %S second (00 - 59)
3366 // Also, for MFC CTimeSpan compatibility, we support
3367 // %D number of days
3369 // And, to be better than MFC :-), we also have
3370 // %E number of wEeks
3371 // %l milliseconds (000 - 999)
3372 wxString
wxTimeSpan::Format(const wxChar
*format
) const
3374 wxCHECK_MSG( format
, _T(""), _T("NULL format in wxTimeSpan::Format") );
3377 str
.Alloc(wxStrlen(format
));
3379 for ( const wxChar
*pch
= format
; pch
; pch
++ )
3391 wxFAIL_MSG( _T("invalid format character") );
3395 // will get to str << ch below
3399 tmp
.Printf(_T("%d"), GetDays());
3403 tmp
.Printf(_T("%d"), GetWeeks());
3407 tmp
.Printf(_T("%02d"), GetHours());
3411 tmp
.Printf(_T("%03ld"), GetMilliseconds().ToLong());
3415 tmp
.Printf(_T("%02d"), GetMinutes());
3419 tmp
.Printf(_T("%02ld"), GetSeconds().ToLong());
3427 // skip str += ch below
3438 // ============================================================================
3439 // wxDateTimeHolidayAuthority and related classes
3440 // ============================================================================
3442 #include "wx/arrimpl.cpp"
3444 WX_DEFINE_OBJARRAY(wxDateTimeArray
)
3446 static int wxCMPFUNC_CONV
3447 wxDateTimeCompareFunc(wxDateTime
**first
, wxDateTime
**second
)
3449 wxDateTime dt1
= **first
,
3452 return dt1
== dt2
? 0 : dt1
< dt2
? -1 : +1;
3455 // ----------------------------------------------------------------------------
3456 // wxDateTimeHolidayAuthority
3457 // ----------------------------------------------------------------------------
3459 wxHolidayAuthoritiesArray
wxDateTimeHolidayAuthority::ms_authorities
;
3462 bool wxDateTimeHolidayAuthority::IsHoliday(const wxDateTime
& dt
)
3464 size_t count
= ms_authorities
.GetCount();
3465 for ( size_t n
= 0; n
< count
; n
++ )
3467 if ( ms_authorities
[n
]->DoIsHoliday(dt
) )
3478 wxDateTimeHolidayAuthority::GetHolidaysInRange(const wxDateTime
& dtStart
,
3479 const wxDateTime
& dtEnd
,
3480 wxDateTimeArray
& holidays
)
3482 wxDateTimeArray hol
;
3486 size_t count
= ms_authorities
.GetCount();
3487 for ( size_t n
= 0; n
< count
; n
++ )
3489 ms_authorities
[n
]->DoGetHolidaysInRange(dtStart
, dtEnd
, hol
);
3491 WX_APPEND_ARRAY(holidays
, hol
);
3494 holidays
.Sort(wxDateTimeCompareFunc
);
3496 return holidays
.GetCount();
3500 void wxDateTimeHolidayAuthority::ClearAllAuthorities()
3502 WX_CLEAR_ARRAY(ms_authorities
);
3506 void wxDateTimeHolidayAuthority::AddAuthority(wxDateTimeHolidayAuthority
*auth
)
3508 ms_authorities
.Add(auth
);
3511 // ----------------------------------------------------------------------------
3512 // wxDateTimeWorkDays
3513 // ----------------------------------------------------------------------------
3515 bool wxDateTimeWorkDays::DoIsHoliday(const wxDateTime
& dt
) const
3517 wxDateTime::WeekDay wd
= dt
.GetWeekDay();
3519 return (wd
== wxDateTime::Sun
) || (wd
== wxDateTime::Sat
);
3522 size_t wxDateTimeWorkDays::DoGetHolidaysInRange(const wxDateTime
& dtStart
,
3523 const wxDateTime
& dtEnd
,
3524 wxDateTimeArray
& holidays
) const
3526 if ( dtStart
> dtEnd
)
3528 wxFAIL_MSG( _T("invalid date range in GetHolidaysInRange") );
3535 // instead of checking all days, start with the first Sat after dtStart and
3536 // end with the last Sun before dtEnd
3537 wxDateTime dtSatFirst
= dtStart
.GetNextWeekDay(wxDateTime::Sat
),
3538 dtSatLast
= dtEnd
.GetPrevWeekDay(wxDateTime::Sat
),
3539 dtSunFirst
= dtStart
.GetNextWeekDay(wxDateTime::Sun
),
3540 dtSunLast
= dtEnd
.GetPrevWeekDay(wxDateTime::Sun
),
3543 for ( dt
= dtSatFirst
; dt
<= dtSatLast
; dt
+= wxDateSpan::Week() )
3548 for ( dt
= dtSunFirst
; dt
<= dtSunLast
; dt
+= wxDateSpan::Week() )
3553 return holidays
.GetCount();