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 licence
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 // ----------------------------------------------------------------------------
55 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
56 #pragma implementation "datetime.h"
59 // For compilers that support precompilation, includes "wx.h".
60 #include "wx/wxprec.h"
66 #if !defined(wxUSE_DATETIME) || wxUSE_DATETIME
69 #include "wx/string.h"
74 #include "wx/thread.h"
75 #include "wx/tokenzr.h"
76 #include "wx/module.h"
80 #include "wx/datetime.h"
81 #include "wx/stopwatch.h" // for wxGetLocalTimeMillis()
83 const long wxDateTime::TIME_T_FACTOR
= 1000l;
85 #if wxUSE_EXTENDED_RTTI
87 template<> void wxStringReadValue(const wxString
&s
, wxDateTime
&data
)
89 data
.ParseFormat(s
,wxT("%Y-%m-%d %H:%M:%S")) ;
92 template<> void wxStringWriteValue(wxString
&s
, const wxDateTime
&data
)
94 s
= data
.Format(wxT("%Y-%m-%d %H:%M:%S")) ;
97 wxCUSTOM_TYPE_INFO(wxDateTime
, wxToStringConverter
<wxDateTime
> , wxFromStringConverter
<wxDateTime
>)
102 // ----------------------------------------------------------------------------
103 // conditional compilation
104 // ----------------------------------------------------------------------------
106 #if defined(HAVE_STRPTIME) && defined(__GLIBC__) && \
107 ((__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0))
108 // glibc 2.0.7 strptime() is broken - the following snippet causes it to
109 // crash (instead of just failing):
111 // strncpy(buf, "Tue Dec 21 20:25:40 1999", 128);
112 // strptime(buf, "%x", &tm);
116 #endif // broken strptime()
118 #if defined(__MWERKS__) && wxUSE_UNICODE
122 #if !defined(WX_TIMEZONE) && !defined(WX_GMTOFF_IN_TM)
123 #if defined(__BORLANDC__) || defined(__MINGW32__) || defined(__VISAGECPP__)
124 #define WX_TIMEZONE _timezone
125 #elif defined(__MWERKS__)
126 long wxmw_timezone
= 28800;
127 #define WX_TIMEZONE wxmw_timezone
128 #elif defined(__DJGPP__) || defined(__WINE__)
129 #include <sys/timeb.h>
131 static long wxGetTimeZone()
133 static long timezone
= MAXLONG
; // invalid timezone
134 if (timezone
== MAXLONG
)
138 timezone
= tb
.timezone
;
142 #define WX_TIMEZONE wxGetTimeZone()
143 #elif defined(__DARWIN__)
144 #define WX_GMTOFF_IN_TM
145 #else // unknown platform - try timezone
146 #define WX_TIMEZONE timezone
148 #endif // !WX_TIMEZONE && !WX_GMTOFF_IN_TM
150 // ----------------------------------------------------------------------------
152 // ----------------------------------------------------------------------------
154 // debugging helper: just a convenient replacement of wxCHECK()
155 #define wxDATETIME_CHECK(expr, msg) \
159 *this = wxInvalidDateTime; \
163 // ----------------------------------------------------------------------------
165 // ----------------------------------------------------------------------------
167 class wxDateTimeHolidaysModule
: public wxModule
170 virtual bool OnInit()
172 wxDateTimeHolidayAuthority::AddAuthority(new wxDateTimeWorkDays
);
177 virtual void OnExit()
179 wxDateTimeHolidayAuthority::ClearAllAuthorities();
180 wxDateTimeHolidayAuthority::ms_authorities
.clear();
184 DECLARE_DYNAMIC_CLASS(wxDateTimeHolidaysModule
)
187 IMPLEMENT_DYNAMIC_CLASS(wxDateTimeHolidaysModule
, wxModule
)
189 // ----------------------------------------------------------------------------
191 // ----------------------------------------------------------------------------
194 static const int MONTHS_IN_YEAR
= 12;
196 static const int SEC_PER_MIN
= 60;
198 static const int MIN_PER_HOUR
= 60;
200 static const int HOURS_PER_DAY
= 24;
202 static const long SECONDS_PER_DAY
= 86400l;
204 static const int DAYS_PER_WEEK
= 7;
206 static const long MILLISECONDS_PER_DAY
= 86400000l;
208 // this is the integral part of JDN of the midnight of Jan 1, 1970
209 // (i.e. JDN(Jan 1, 1970) = 2440587.5)
210 static const long EPOCH_JDN
= 2440587l;
212 // the date of JDN -0.5 (as we don't work with fractional parts, this is the
213 // reference date for us) is Nov 24, 4714BC
214 static const int JDN_0_YEAR
= -4713;
215 static const int JDN_0_MONTH
= wxDateTime::Nov
;
216 static const int JDN_0_DAY
= 24;
218 // the constants used for JDN calculations
219 static const long JDN_OFFSET
= 32046l;
220 static const long DAYS_PER_5_MONTHS
= 153l;
221 static const long DAYS_PER_4_YEARS
= 1461l;
222 static const long DAYS_PER_400_YEARS
= 146097l;
224 // this array contains the cumulated number of days in all previous months for
225 // normal and leap years
226 static const wxDateTime::wxDateTime_t gs_cumulatedDays
[2][MONTHS_IN_YEAR
] =
228 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
229 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
232 // ----------------------------------------------------------------------------
234 // ----------------------------------------------------------------------------
236 // in the fine tradition of ANSI C we use our equivalent of (time_t)-1 to
237 // indicate an invalid wxDateTime object
238 const wxDateTime wxDefaultDateTime
;
240 wxDateTime::Country
wxDateTime::ms_country
= wxDateTime::Country_Unknown
;
242 // ----------------------------------------------------------------------------
244 // ----------------------------------------------------------------------------
246 // debugger helper: shows what the date really is
248 extern const wxChar
*wxDumpDate(const wxDateTime
* dt
)
250 static wxChar buf
[128];
252 wxStrcpy(buf
, dt
->Format(_T("%Y-%m-%d (%a) %H:%M:%S")));
258 // get the number of days in the given month of the given year
260 wxDateTime::wxDateTime_t
GetNumOfDaysInMonth(int year
, wxDateTime::Month month
)
262 // the number of days in month in Julian/Gregorian calendar: the first line
263 // is for normal years, the second one is for the leap ones
264 static wxDateTime::wxDateTime_t daysInMonth
[2][MONTHS_IN_YEAR
] =
266 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
267 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
270 return daysInMonth
[wxDateTime::IsLeapYear(year
)][month
];
273 // returns the time zone in the C sense, i.e. the difference UTC - local
275 static int GetTimeZone()
277 #ifdef WX_GMTOFF_IN_TM
278 // set to TRUE when the timezone is set
279 static bool s_timezoneSet
= FALSE
;
280 static long gmtoffset
= LONG_MAX
; // invalid timezone
282 // ensure that the timezone variable is set by calling localtime
283 if ( !s_timezoneSet
)
285 // just call localtime() instead of figuring out whether this system
286 // supports tzset(), _tzset() or something else
291 s_timezoneSet
= TRUE
;
293 // note that GMT offset is the opposite of time zone and so to return
294 // consistent results in both WX_GMTOFF_IN_TM and !WX_GMTOFF_IN_TM
295 // cases we have to negate it
296 gmtoffset
= -tm
->tm_gmtoff
;
299 return (int)gmtoffset
;
300 #else // !WX_GMTOFF_IN_TM
301 return (int)WX_TIMEZONE
;
302 #endif // WX_GMTOFF_IN_TM/!WX_GMTOFF_IN_TM
305 // return the integral part of the JDN for the midnight of the given date (to
306 // get the real JDN you need to add 0.5, this is, in fact, JDN of the
307 // noon of the previous day)
308 static long GetTruncatedJDN(wxDateTime::wxDateTime_t day
,
309 wxDateTime::Month mon
,
312 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
314 // check the date validity
316 (year
> JDN_0_YEAR
) ||
317 ((year
== JDN_0_YEAR
) && (mon
> JDN_0_MONTH
)) ||
318 ((year
== JDN_0_YEAR
) && (mon
== JDN_0_MONTH
) && (day
>= JDN_0_DAY
)),
319 _T("date out of range - can't convert to JDN")
322 // make the year positive to avoid problems with negative numbers division
325 // months are counted from March here
327 if ( mon
>= wxDateTime::Mar
)
337 // now we can simply add all the contributions together
338 return ((year
/ 100) * DAYS_PER_400_YEARS
) / 4
339 + ((year
% 100) * DAYS_PER_4_YEARS
) / 4
340 + (month
* DAYS_PER_5_MONTHS
+ 2) / 5
345 // this function is a wrapper around strftime(3) adding error checking
346 static wxString
CallStrftime(const wxChar
*format
, const tm
* tm
)
349 if ( !wxStrftime(buf
, WXSIZEOF(buf
), format
, tm
) )
351 // buffer is too small?
352 wxFAIL_MSG(_T("strftime() failed"));
355 return wxString(buf
);
360 // glibc2 doesn't define this in the headers unless _XOPEN_SOURCE is defined
361 // which, unfortunately, wreaks havoc elsewhere
362 #if defined(__GLIBC__) && (__GLIBC__ == 2)
363 extern "C" char *strptime(const char *, const char *, struct tm
*);
366 // Unicode-friendly strptime() wrapper
367 static const wxChar
*
368 CallStrptime(const wxChar
*input
, const char *fmt
, tm
*tm
)
370 // the problem here is that strptime() returns pointer into the string we
371 // passed to it while we're really interested in the pointer into the
372 // original, Unicode, string so we try to transform the pointer back
374 wxCharBuffer
inputMB(wxConvertWX2MB(input
));
376 const char * const inputMB
= input
;
377 #endif // Unicode/Ascii
379 const char *result
= strptime(inputMB
, fmt
, tm
);
384 // FIXME: this is wrong in presence of surrogates &c
385 return input
+ (result
- inputMB
.data());
388 #endif // Unicode/Ascii
391 #endif // HAVE_STRPTIME
393 // if year and/or month have invalid values, replace them with the current ones
394 static void ReplaceDefaultYearMonthWithCurrent(int *year
,
395 wxDateTime::Month
*month
)
397 struct tm
*tmNow
= NULL
;
399 if ( *year
== wxDateTime::Inv_Year
)
401 tmNow
= wxDateTime::GetTmNow();
403 *year
= 1900 + tmNow
->tm_year
;
406 if ( *month
== wxDateTime::Inv_Month
)
409 tmNow
= wxDateTime::GetTmNow();
411 *month
= (wxDateTime::Month
)tmNow
->tm_mon
;
415 // fll the struct tm with default values
416 static void InitTm(struct tm
& tm
)
418 // struct tm may have etxra fields (undocumented and with unportable
419 // names) which, nevertheless, must be set to 0
420 memset(&tm
, 0, sizeof(struct tm
));
422 tm
.tm_mday
= 1; // mday 0 is invalid
423 tm
.tm_year
= 76; // any valid year
424 tm
.tm_isdst
= -1; // auto determine
430 // return the month if the string is a month name or Inv_Month otherwise
431 static wxDateTime::Month
GetMonthFromName(const wxString
& name
, int flags
)
433 wxDateTime::Month mon
;
434 for ( mon
= wxDateTime::Jan
; mon
< wxDateTime::Inv_Month
; wxNextMonth(mon
) )
436 // case-insensitive comparison either one of or with both abbreviated
438 if ( flags
& wxDateTime::Name_Full
)
440 if ( name
.CmpNoCase(wxDateTime::
441 GetMonthName(mon
, wxDateTime::Name_Full
)) == 0 )
447 if ( flags
& wxDateTime::Name_Abbr
)
449 if ( name
.CmpNoCase(wxDateTime::
450 GetMonthName(mon
, wxDateTime::Name_Abbr
)) == 0 )
460 // return the weekday if the string is a weekday name or Inv_WeekDay otherwise
461 static wxDateTime::WeekDay
GetWeekDayFromName(const wxString
& name
, int flags
)
463 wxDateTime::WeekDay wd
;
464 for ( wd
= wxDateTime::Sun
; wd
< wxDateTime::Inv_WeekDay
; wxNextWDay(wd
) )
466 // case-insensitive comparison either one of or with both abbreviated
468 if ( flags
& wxDateTime::Name_Full
)
470 if ( name
.CmpNoCase(wxDateTime::
471 GetWeekDayName(wd
, wxDateTime::Name_Full
)) == 0 )
477 if ( flags
& wxDateTime::Name_Abbr
)
479 if ( name
.CmpNoCase(wxDateTime::
480 GetWeekDayName(wd
, wxDateTime::Name_Abbr
)) == 0 )
490 // scans all digits (but no more than len) and returns the resulting number
491 static bool GetNumericToken(size_t len
, const wxChar
*& p
, unsigned long *number
)
495 while ( wxIsdigit(*p
) )
499 if ( len
&& ++n
> len
)
503 return !!s
&& s
.ToULong(number
);
506 // scans all alphabetic characters and returns the resulting string
507 static wxString
GetAlphaToken(const wxChar
*& p
)
510 while ( wxIsalpha(*p
) )
518 // ============================================================================
519 // implementation of wxDateTime
520 // ============================================================================
522 // ----------------------------------------------------------------------------
524 // ----------------------------------------------------------------------------
528 year
= (wxDateTime_t
)wxDateTime::Inv_Year
;
529 mon
= wxDateTime::Inv_Month
;
531 hour
= min
= sec
= msec
= 0;
532 wday
= wxDateTime::Inv_WeekDay
;
535 wxDateTime::Tm::Tm(const struct tm
& tm
, const TimeZone
& tz
)
543 mon
= (wxDateTime::Month
)tm
.tm_mon
;
544 year
= 1900 + tm
.tm_year
;
549 bool wxDateTime::Tm::IsValid() const
551 // we allow for the leap seconds, although we don't use them (yet)
552 return (year
!= wxDateTime::Inv_Year
) && (mon
!= wxDateTime::Inv_Month
) &&
553 (mday
<= GetNumOfDaysInMonth(year
, mon
)) &&
554 (hour
< 24) && (min
< 60) && (sec
< 62) && (msec
< 1000);
557 void wxDateTime::Tm::ComputeWeekDay()
559 // compute the week day from day/month/year: we use the dumbest algorithm
560 // possible: just compute our JDN and then use the (simple to derive)
561 // formula: weekday = (JDN + 1.5) % 7
562 wday
= (wxDateTime::WeekDay
)(GetTruncatedJDN(mday
, mon
, year
) + 2) % 7;
565 void wxDateTime::Tm::AddMonths(int monDiff
)
567 // normalize the months field
568 while ( monDiff
< -mon
)
572 monDiff
+= MONTHS_IN_YEAR
;
575 while ( monDiff
+ mon
>= MONTHS_IN_YEAR
)
579 monDiff
-= MONTHS_IN_YEAR
;
582 mon
= (wxDateTime::Month
)(mon
+ monDiff
);
584 wxASSERT_MSG( mon
>= 0 && mon
< MONTHS_IN_YEAR
, _T("logic error") );
586 // NB: we don't check here that the resulting date is valid, this function
587 // is private and the caller must check it if needed
590 void wxDateTime::Tm::AddDays(int dayDiff
)
592 // normalize the days field
593 while ( dayDiff
+ mday
< 1 )
597 dayDiff
+= GetNumOfDaysInMonth(year
, mon
);
601 while ( mday
> GetNumOfDaysInMonth(year
, mon
) )
603 mday
-= GetNumOfDaysInMonth(year
, mon
);
608 wxASSERT_MSG( mday
> 0 && mday
<= GetNumOfDaysInMonth(year
, mon
),
612 // ----------------------------------------------------------------------------
614 // ----------------------------------------------------------------------------
616 wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz
)
620 case wxDateTime::Local
:
621 // get the offset from C RTL: it returns the difference GMT-local
622 // while we want to have the offset _from_ GMT, hence the '-'
623 m_offset
= -GetTimeZone();
626 case wxDateTime::GMT_12
:
627 case wxDateTime::GMT_11
:
628 case wxDateTime::GMT_10
:
629 case wxDateTime::GMT_9
:
630 case wxDateTime::GMT_8
:
631 case wxDateTime::GMT_7
:
632 case wxDateTime::GMT_6
:
633 case wxDateTime::GMT_5
:
634 case wxDateTime::GMT_4
:
635 case wxDateTime::GMT_3
:
636 case wxDateTime::GMT_2
:
637 case wxDateTime::GMT_1
:
638 m_offset
= -3600*(wxDateTime::GMT0
- tz
);
641 case wxDateTime::GMT0
:
642 case wxDateTime::GMT1
:
643 case wxDateTime::GMT2
:
644 case wxDateTime::GMT3
:
645 case wxDateTime::GMT4
:
646 case wxDateTime::GMT5
:
647 case wxDateTime::GMT6
:
648 case wxDateTime::GMT7
:
649 case wxDateTime::GMT8
:
650 case wxDateTime::GMT9
:
651 case wxDateTime::GMT10
:
652 case wxDateTime::GMT11
:
653 case wxDateTime::GMT12
:
654 m_offset
= 3600*(tz
- wxDateTime::GMT0
);
657 case wxDateTime::A_CST
:
658 // Central Standard Time in use in Australia = UTC + 9.5
659 m_offset
= 60l*(9*60 + 30);
663 wxFAIL_MSG( _T("unknown time zone") );
667 // ----------------------------------------------------------------------------
669 // ----------------------------------------------------------------------------
672 bool wxDateTime::IsLeapYear(int year
, wxDateTime::Calendar cal
)
674 if ( year
== Inv_Year
)
675 year
= GetCurrentYear();
677 if ( cal
== Gregorian
)
679 // in Gregorian calendar leap years are those divisible by 4 except
680 // those divisible by 100 unless they're also divisible by 400
681 // (in some countries, like Russia and Greece, additional corrections
682 // exist, but they won't manifest themselves until 2700)
683 return (year
% 4 == 0) && ((year
% 100 != 0) || (year
% 400 == 0));
685 else if ( cal
== Julian
)
687 // in Julian calendar the rule is simpler
688 return year
% 4 == 0;
692 wxFAIL_MSG(_T("unknown calendar"));
699 int wxDateTime::GetCentury(int year
)
701 return year
> 0 ? year
/ 100 : year
/ 100 - 1;
705 int wxDateTime::ConvertYearToBC(int year
)
708 return year
> 0 ? year
: year
- 1;
712 int wxDateTime::GetCurrentYear(wxDateTime::Calendar cal
)
717 return Now().GetYear();
720 wxFAIL_MSG(_T("TODO"));
724 wxFAIL_MSG(_T("unsupported calendar"));
732 wxDateTime::Month
wxDateTime::GetCurrentMonth(wxDateTime::Calendar cal
)
737 return Now().GetMonth();
740 wxFAIL_MSG(_T("TODO"));
744 wxFAIL_MSG(_T("unsupported calendar"));
752 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(int year
, Calendar cal
)
754 if ( year
== Inv_Year
)
756 // take the current year if none given
757 year
= GetCurrentYear();
764 return IsLeapYear(year
) ? 366 : 365;
767 wxFAIL_MSG(_T("unsupported calendar"));
775 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(wxDateTime::Month month
,
777 wxDateTime::Calendar cal
)
779 wxCHECK_MSG( month
< MONTHS_IN_YEAR
, 0, _T("invalid month") );
781 if ( cal
== Gregorian
|| cal
== Julian
)
783 if ( year
== Inv_Year
)
785 // take the current year if none given
786 year
= GetCurrentYear();
789 return GetNumOfDaysInMonth(year
, month
);
793 wxFAIL_MSG(_T("unsupported calendar"));
800 wxString
wxDateTime::GetMonthName(wxDateTime::Month month
,
801 wxDateTime::NameFlags flags
)
803 wxCHECK_MSG( month
!= Inv_Month
, _T(""), _T("invalid month") );
805 // notice that we must set all the fields to avoid confusing libc (GNU one
806 // gets confused to a crash if we don't do this)
811 return CallStrftime(flags
== Name_Abbr
? _T("%b") : _T("%B"), &tm
);
815 wxString
wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday
,
816 wxDateTime::NameFlags flags
)
818 wxCHECK_MSG( wday
!= Inv_WeekDay
, _T(""), _T("invalid weekday") );
820 // take some arbitrary Sunday
827 // and offset it by the number of days needed to get the correct wday
830 // call mktime() to normalize it...
833 // ... and call strftime()
834 return CallStrftime(flags
== Name_Abbr
? _T("%a") : _T("%A"), &tm
);
838 void wxDateTime::GetAmPmStrings(wxString
*am
, wxString
*pm
)
844 *am
= CallStrftime(_T("%p"), &tm
);
849 *pm
= CallStrftime(_T("%p"), &tm
);
853 // ----------------------------------------------------------------------------
854 // Country stuff: date calculations depend on the country (DST, work days,
855 // ...), so we need to know which rules to follow.
856 // ----------------------------------------------------------------------------
859 wxDateTime::Country
wxDateTime::GetCountry()
861 // TODO use LOCALE_ICOUNTRY setting under Win32
863 if ( ms_country
== Country_Unknown
)
865 // try to guess from the time zone name
866 time_t t
= time(NULL
);
867 struct tm
*tm
= localtime(&t
);
869 wxString tz
= CallStrftime(_T("%Z"), tm
);
870 if ( tz
== _T("WET") || tz
== _T("WEST") )
874 else if ( tz
== _T("CET") || tz
== _T("CEST") )
876 ms_country
= Country_EEC
;
878 else if ( tz
== _T("MSK") || tz
== _T("MSD") )
882 else if ( tz
== _T("AST") || tz
== _T("ADT") ||
883 tz
== _T("EST") || tz
== _T("EDT") ||
884 tz
== _T("CST") || tz
== _T("CDT") ||
885 tz
== _T("MST") || tz
== _T("MDT") ||
886 tz
== _T("PST") || tz
== _T("PDT") )
892 // well, choose a default one
901 void wxDateTime::SetCountry(wxDateTime::Country country
)
903 ms_country
= country
;
907 bool wxDateTime::IsWestEuropeanCountry(Country country
)
909 if ( country
== Country_Default
)
911 country
= GetCountry();
914 return (Country_WesternEurope_Start
<= country
) &&
915 (country
<= Country_WesternEurope_End
);
918 // ----------------------------------------------------------------------------
919 // DST calculations: we use 3 different rules for the West European countries,
920 // USA and for the rest of the world. This is undoubtedly false for many
921 // countries, but I lack the necessary info (and the time to gather it),
922 // please add the other rules here!
923 // ----------------------------------------------------------------------------
926 bool wxDateTime::IsDSTApplicable(int year
, Country country
)
928 if ( year
== Inv_Year
)
930 // take the current year if none given
931 year
= GetCurrentYear();
934 if ( country
== Country_Default
)
936 country
= GetCountry();
943 // DST was first observed in the US and UK during WWI, reused
944 // during WWII and used again since 1966
945 return year
>= 1966 ||
946 (year
>= 1942 && year
<= 1945) ||
947 (year
== 1918 || year
== 1919);
950 // assume that it started after WWII
956 wxDateTime
wxDateTime::GetBeginDST(int year
, Country country
)
958 if ( year
== Inv_Year
)
960 // take the current year if none given
961 year
= GetCurrentYear();
964 if ( country
== Country_Default
)
966 country
= GetCountry();
969 if ( !IsDSTApplicable(year
, country
) )
971 return wxInvalidDateTime
;
976 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
978 // DST begins at 1 a.m. GMT on the last Sunday of March
979 if ( !dt
.SetToLastWeekDay(Sun
, Mar
, year
) )
982 wxFAIL_MSG( _T("no last Sunday in March?") );
985 dt
+= wxTimeSpan::Hours(1);
987 // disable DST tests because it could result in an infinite recursion!
990 else switch ( country
)
997 // don't know for sure - assume it was in effect all year
1002 dt
.Set(1, Jan
, year
);
1006 // DST was installed Feb 2, 1942 by the Congress
1007 dt
.Set(2, Feb
, year
);
1010 // Oil embargo changed the DST period in the US
1012 dt
.Set(6, Jan
, 1974);
1016 dt
.Set(23, Feb
, 1975);
1020 // before 1986, DST begun on the last Sunday of April, but
1021 // in 1986 Reagan changed it to begin at 2 a.m. of the
1022 // first Sunday in April
1025 if ( !dt
.SetToLastWeekDay(Sun
, Apr
, year
) )
1028 wxFAIL_MSG( _T("no first Sunday in April?") );
1033 if ( !dt
.SetToWeekDay(Sun
, 1, Apr
, year
) )
1036 wxFAIL_MSG( _T("no first Sunday in April?") );
1040 dt
+= wxTimeSpan::Hours(2);
1042 // TODO what about timezone??
1048 // assume Mar 30 as the start of the DST for the rest of the world
1049 // - totally bogus, of course
1050 dt
.Set(30, Mar
, year
);
1057 wxDateTime
wxDateTime::GetEndDST(int year
, Country country
)
1059 if ( year
== Inv_Year
)
1061 // take the current year if none given
1062 year
= GetCurrentYear();
1065 if ( country
== Country_Default
)
1067 country
= GetCountry();
1070 if ( !IsDSTApplicable(year
, country
) )
1072 return wxInvalidDateTime
;
1077 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
1079 // DST ends at 1 a.m. GMT on the last Sunday of October
1080 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1082 // weirder and weirder...
1083 wxFAIL_MSG( _T("no last Sunday in October?") );
1086 dt
+= wxTimeSpan::Hours(1);
1088 // disable DST tests because it could result in an infinite recursion!
1091 else switch ( country
)
1098 // don't know for sure - assume it was in effect all year
1102 dt
.Set(31, Dec
, year
);
1106 // the time was reset after the end of the WWII
1107 dt
.Set(30, Sep
, year
);
1111 // DST ends at 2 a.m. on the last Sunday of October
1112 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1114 // weirder and weirder...
1115 wxFAIL_MSG( _T("no last Sunday in October?") );
1118 dt
+= wxTimeSpan::Hours(2);
1120 // TODO what about timezone??
1125 // assume October 26th as the end of the DST - totally bogus too
1126 dt
.Set(26, Oct
, year
);
1132 // ----------------------------------------------------------------------------
1133 // constructors and assignment operators
1134 // ----------------------------------------------------------------------------
1136 // return the current time with ms precision
1137 /* static */ wxDateTime
wxDateTime::UNow()
1139 return wxDateTime(wxGetLocalTimeMillis());
1142 // the values in the tm structure contain the local time
1143 wxDateTime
& wxDateTime::Set(const struct tm
& tm
)
1146 time_t timet
= mktime(&tm2
);
1148 if ( timet
== (time_t)-1 )
1150 // mktime() rather unintuitively fails for Jan 1, 1970 if the hour is
1151 // less than timezone - try to make it work for this case
1152 if ( tm2
.tm_year
== 70 && tm2
.tm_mon
== 0 && tm2
.tm_mday
== 1 )
1154 // add timezone to make sure that date is in range
1155 tm2
.tm_sec
-= GetTimeZone();
1157 timet
= mktime(&tm2
);
1158 if ( timet
!= (time_t)-1 )
1160 timet
+= GetTimeZone();
1166 wxFAIL_MSG( _T("mktime() failed") );
1168 *this = wxInvalidDateTime
;
1178 wxDateTime
& wxDateTime::Set(wxDateTime_t hour
,
1179 wxDateTime_t minute
,
1180 wxDateTime_t second
,
1181 wxDateTime_t millisec
)
1183 // we allow seconds to be 61 to account for the leap seconds, even if we
1184 // don't use them really
1185 wxDATETIME_CHECK( hour
< 24 &&
1189 _T("Invalid time in wxDateTime::Set()") );
1191 // get the current date from system
1192 struct tm
*tm
= GetTmNow();
1194 wxDATETIME_CHECK( tm
, _T("localtime() failed") );
1198 tm
->tm_min
= minute
;
1199 tm
->tm_sec
= second
;
1203 // and finally adjust milliseconds
1204 return SetMillisecond(millisec
);
1207 wxDateTime
& wxDateTime::Set(wxDateTime_t day
,
1211 wxDateTime_t minute
,
1212 wxDateTime_t second
,
1213 wxDateTime_t millisec
)
1215 wxDATETIME_CHECK( hour
< 24 &&
1219 _T("Invalid time in wxDateTime::Set()") );
1221 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1223 wxDATETIME_CHECK( (0 < day
) && (day
<= GetNumberOfDays(month
, year
)),
1224 _T("Invalid date in wxDateTime::Set()") );
1226 // the range of time_t type (inclusive)
1227 static const int yearMinInRange
= 1970;
1228 static const int yearMaxInRange
= 2037;
1230 // test only the year instead of testing for the exact end of the Unix
1231 // time_t range - it doesn't bring anything to do more precise checks
1232 if ( year
>= yearMinInRange
&& year
<= yearMaxInRange
)
1234 // use the standard library version if the date is in range - this is
1235 // probably more efficient than our code
1237 tm
.tm_year
= year
- 1900;
1243 tm
.tm_isdst
= -1; // mktime() will guess it
1247 // and finally adjust milliseconds
1248 return SetMillisecond(millisec
);
1252 // do time calculations ourselves: we want to calculate the number of
1253 // milliseconds between the given date and the epoch
1255 // get the JDN for the midnight of this day
1256 m_time
= GetTruncatedJDN(day
, month
, year
);
1257 m_time
-= EPOCH_JDN
;
1258 m_time
*= SECONDS_PER_DAY
* TIME_T_FACTOR
;
1260 // JDN corresponds to GMT, we take localtime
1261 Add(wxTimeSpan(hour
, minute
, second
+ GetTimeZone(), millisec
));
1267 wxDateTime
& wxDateTime::Set(double jdn
)
1269 // so that m_time will be 0 for the midnight of Jan 1, 1970 which is jdn
1271 jdn
-= EPOCH_JDN
+ 0.5;
1273 jdn
*= MILLISECONDS_PER_DAY
;
1280 wxDateTime
& wxDateTime::ResetTime()
1284 if ( tm
.hour
|| tm
.min
|| tm
.sec
|| tm
.msec
)
1297 // ----------------------------------------------------------------------------
1298 // DOS Date and Time Format functions
1299 // ----------------------------------------------------------------------------
1300 // the dos date and time value is an unsigned 32 bit value in the format:
1301 // YYYYYYYMMMMDDDDDhhhhhmmmmmmsssss
1303 // Y = year offset from 1980 (0-127)
1305 // D = day of month (1-31)
1307 // m = minute (0-59)
1308 // s = bisecond (0-29) each bisecond indicates two seconds
1309 // ----------------------------------------------------------------------------
1311 wxDateTime
& wxDateTime::SetFromDOS(unsigned long ddt
)
1315 long year
= ddt
& 0xFE000000;
1320 long month
= ddt
& 0x1E00000;
1325 long day
= ddt
& 0x1F0000;
1329 long hour
= ddt
& 0xF800;
1333 long minute
= ddt
& 0x7E0;
1337 long second
= ddt
& 0x1F;
1338 tm
.tm_sec
= second
* 2;
1340 return Set(mktime(&tm
));
1343 unsigned long wxDateTime::GetAsDOS() const
1346 time_t ticks
= GetTicks();
1347 struct tm
*tm
= localtime(&ticks
);
1349 long year
= tm
->tm_year
;
1353 long month
= tm
->tm_mon
;
1357 long day
= tm
->tm_mday
;
1360 long hour
= tm
->tm_hour
;
1363 long minute
= tm
->tm_min
;
1366 long second
= tm
->tm_sec
;
1369 ddt
= year
| month
| day
| hour
| minute
| second
;
1373 // ----------------------------------------------------------------------------
1374 // time_t <-> broken down time conversions
1375 // ----------------------------------------------------------------------------
1377 wxDateTime::Tm
wxDateTime::GetTm(const TimeZone
& tz
) const
1379 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1381 time_t time
= GetTicks();
1382 if ( time
!= (time_t)-1 )
1384 // use C RTL functions
1386 if ( tz
.GetOffset() == -GetTimeZone() )
1388 // we are working with local time
1389 tm
= localtime(&time
);
1391 // should never happen
1392 wxCHECK_MSG( tm
, Tm(), _T("localtime() failed") );
1396 time
+= (time_t)tz
.GetOffset();
1397 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
1398 int time2
= (int) time
;
1406 // should never happen
1407 wxCHECK_MSG( tm
, Tm(), _T("gmtime() failed") );
1411 tm
= (struct tm
*)NULL
;
1417 // adjust the milliseconds
1419 long timeOnly
= (m_time
% MILLISECONDS_PER_DAY
).ToLong();
1420 tm2
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1423 //else: use generic code below
1426 // remember the time and do the calculations with the date only - this
1427 // eliminates rounding errors of the floating point arithmetics
1429 wxLongLong timeMidnight
= m_time
+ tz
.GetOffset() * 1000;
1431 long timeOnly
= (timeMidnight
% MILLISECONDS_PER_DAY
).ToLong();
1433 // we want to always have positive time and timeMidnight to be really
1434 // the midnight before it
1437 timeOnly
= MILLISECONDS_PER_DAY
+ timeOnly
;
1440 timeMidnight
-= timeOnly
;
1442 // calculate the Gregorian date from JDN for the midnight of our date:
1443 // this will yield day, month (in 1..12 range) and year
1445 // actually, this is the JDN for the noon of the previous day
1446 long jdn
= (timeMidnight
/ MILLISECONDS_PER_DAY
).ToLong() + EPOCH_JDN
;
1448 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
1450 wxASSERT_MSG( jdn
> -2, _T("JDN out of range") );
1452 // calculate the century
1453 long temp
= (jdn
+ JDN_OFFSET
) * 4 - 1;
1454 long century
= temp
/ DAYS_PER_400_YEARS
;
1456 // then the year and day of year (1 <= dayOfYear <= 366)
1457 temp
= ((temp
% DAYS_PER_400_YEARS
) / 4) * 4 + 3;
1458 long year
= (century
* 100) + (temp
/ DAYS_PER_4_YEARS
);
1459 long dayOfYear
= (temp
% DAYS_PER_4_YEARS
) / 4 + 1;
1461 // and finally the month and day of the month
1462 temp
= dayOfYear
* 5 - 3;
1463 long month
= temp
/ DAYS_PER_5_MONTHS
;
1464 long day
= (temp
% DAYS_PER_5_MONTHS
) / 5 + 1;
1466 // month is counted from March - convert to normal
1477 // year is offset by 4800
1480 // check that the algorithm gave us something reasonable
1481 wxASSERT_MSG( (0 < month
) && (month
<= 12), _T("invalid month") );
1482 wxASSERT_MSG( (1 <= day
) && (day
< 32), _T("invalid day") );
1484 // construct Tm from these values
1486 tm
.year
= (int)year
;
1487 tm
.mon
= (Month
)(month
- 1); // algorithm yields 1 for January, not 0
1488 tm
.mday
= (wxDateTime_t
)day
;
1489 tm
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1490 timeOnly
-= tm
.msec
;
1491 timeOnly
/= 1000; // now we have time in seconds
1493 tm
.sec
= (wxDateTime_t
)(timeOnly
% 60);
1495 timeOnly
/= 60; // now we have time in minutes
1497 tm
.min
= (wxDateTime_t
)(timeOnly
% 60);
1500 tm
.hour
= (wxDateTime_t
)(timeOnly
/ 60);
1505 wxDateTime
& wxDateTime::SetYear(int year
)
1507 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1516 wxDateTime
& wxDateTime::SetMonth(Month month
)
1518 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1527 wxDateTime
& wxDateTime::SetDay(wxDateTime_t mday
)
1529 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1538 wxDateTime
& wxDateTime::SetHour(wxDateTime_t hour
)
1540 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1549 wxDateTime
& wxDateTime::SetMinute(wxDateTime_t min
)
1551 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1560 wxDateTime
& wxDateTime::SetSecond(wxDateTime_t sec
)
1562 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1571 wxDateTime
& wxDateTime::SetMillisecond(wxDateTime_t millisecond
)
1573 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1575 // we don't need to use GetTm() for this one
1576 m_time
-= m_time
% 1000l;
1577 m_time
+= millisecond
;
1582 // ----------------------------------------------------------------------------
1583 // wxDateTime arithmetics
1584 // ----------------------------------------------------------------------------
1586 wxDateTime
& wxDateTime::Add(const wxDateSpan
& diff
)
1590 tm
.year
+= diff
.GetYears();
1591 tm
.AddMonths(diff
.GetMonths());
1593 // check that the resulting date is valid
1594 if ( tm
.mday
> GetNumOfDaysInMonth(tm
.year
, tm
.mon
) )
1596 // We suppose that when adding one month to Jan 31 we want to get Feb
1597 // 28 (or 29), i.e. adding a month to the last day of the month should
1598 // give the last day of the next month which is quite logical.
1600 // Unfortunately, there is no logic way to understand what should
1601 // Jan 30 + 1 month be - Feb 28 too or Feb 27 (assuming non leap year)?
1602 // We make it Feb 28 (last day too), but it is highly questionable.
1603 tm
.mday
= GetNumOfDaysInMonth(tm
.year
, tm
.mon
);
1606 tm
.AddDays(diff
.GetTotalDays());
1610 wxASSERT_MSG( IsSameTime(tm
),
1611 _T("Add(wxDateSpan) shouldn't modify time") );
1616 // ----------------------------------------------------------------------------
1617 // Weekday and monthday stuff
1618 // ----------------------------------------------------------------------------
1620 bool wxDateTime::SetToTheWeek(wxDateTime_t numWeek
,
1624 wxASSERT_MSG( numWeek
> 0,
1625 _T("invalid week number: weeks are counted from 1") );
1627 int year
= GetYear();
1629 // Jan 4 always lies in the 1st week of the year
1631 SetToWeekDayInSameWeek(weekday
, flags
) += wxDateSpan::Weeks(numWeek
- 1);
1633 if ( GetYear() != year
)
1635 // oops... numWeek was too big
1642 wxDateTime
& wxDateTime::SetToLastMonthDay(Month month
,
1645 // take the current month/year if none specified
1646 if ( year
== Inv_Year
)
1648 if ( month
== Inv_Month
)
1651 return Set(GetNumOfDaysInMonth(year
, month
), month
, year
);
1654 wxDateTime
& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday
, WeekFlags flags
)
1656 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
1658 int wdayThis
= GetWeekDay();
1659 if ( weekday
== wdayThis
)
1665 if ( flags
== Default_First
)
1667 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
1670 // the logic below based on comparing weekday and wdayThis works if Sun (0)
1671 // is the first day in the week, but breaks down for Monday_First case so
1672 // we adjust the week days in this case
1673 if( flags
== Monday_First
)
1675 if ( wdayThis
== Sun
)
1678 //else: Sunday_First, nothing to do
1680 // go forward or back in time to the day we want
1681 if ( weekday
< wdayThis
)
1683 return Subtract(wxDateSpan::Days(wdayThis
- weekday
));
1685 else // weekday > wdayThis
1687 return Add(wxDateSpan::Days(weekday
- wdayThis
));
1691 wxDateTime
& wxDateTime::SetToNextWeekDay(WeekDay weekday
)
1693 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
1696 WeekDay wdayThis
= GetWeekDay();
1697 if ( weekday
== wdayThis
)
1702 else if ( weekday
< wdayThis
)
1704 // need to advance a week
1705 diff
= 7 - (wdayThis
- weekday
);
1707 else // weekday > wdayThis
1709 diff
= weekday
- wdayThis
;
1712 return Add(wxDateSpan::Days(diff
));
1715 wxDateTime
& wxDateTime::SetToPrevWeekDay(WeekDay weekday
)
1717 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
1720 WeekDay wdayThis
= GetWeekDay();
1721 if ( weekday
== wdayThis
)
1726 else if ( weekday
> wdayThis
)
1728 // need to go to previous week
1729 diff
= 7 - (weekday
- wdayThis
);
1731 else // weekday < wdayThis
1733 diff
= wdayThis
- weekday
;
1736 return Subtract(wxDateSpan::Days(diff
));
1739 bool wxDateTime::SetToWeekDay(WeekDay weekday
,
1744 wxCHECK_MSG( weekday
!= Inv_WeekDay
, FALSE
, _T("invalid weekday") );
1746 // we don't check explicitly that -5 <= n <= 5 because we will return FALSE
1747 // anyhow in such case - but may be should still give an assert for it?
1749 // take the current month/year if none specified
1750 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1754 // TODO this probably could be optimised somehow...
1758 // get the first day of the month
1759 dt
.Set(1, month
, year
);
1762 WeekDay wdayFirst
= dt
.GetWeekDay();
1764 // go to the first weekday of the month
1765 int diff
= weekday
- wdayFirst
;
1769 // add advance n-1 weeks more
1772 dt
+= wxDateSpan::Days(diff
);
1774 else // count from the end of the month
1776 // get the last day of the month
1777 dt
.SetToLastMonthDay(month
, year
);
1780 WeekDay wdayLast
= dt
.GetWeekDay();
1782 // go to the last weekday of the month
1783 int diff
= wdayLast
- weekday
;
1787 // and rewind n-1 weeks from there
1790 dt
-= wxDateSpan::Days(diff
);
1793 // check that it is still in the same month
1794 if ( dt
.GetMonth() == month
)
1802 // no such day in this month
1807 wxDateTime::wxDateTime_t
wxDateTime::GetDayOfYear(const TimeZone
& tz
) const
1811 return gs_cumulatedDays
[IsLeapYear(tm
.year
)][tm
.mon
] + tm
.mday
;
1814 wxDateTime::wxDateTime_t
wxDateTime::GetWeekOfYear(wxDateTime::WeekFlags flags
,
1815 const TimeZone
& tz
) const
1817 if ( flags
== Default_First
)
1819 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
1822 wxDateTime_t nDayInYear
= GetDayOfYear(tz
);
1825 WeekDay wd
= GetWeekDay(tz
);
1826 if ( flags
== Sunday_First
)
1828 week
= (nDayInYear
- wd
+ 7) / 7;
1832 // have to shift the week days values
1833 week
= (nDayInYear
- (wd
- 1 + 7) % 7 + 7) / 7;
1836 // FIXME some more elegant way??
1837 WeekDay wdYearStart
= wxDateTime(1, Jan
, GetYear()).GetWeekDay();
1838 if ( wdYearStart
== Wed
|| wdYearStart
== Thu
)
1846 wxDateTime::wxDateTime_t
wxDateTime::GetWeekOfMonth(wxDateTime::WeekFlags flags
,
1847 const TimeZone
& tz
) const
1850 wxDateTime dtMonthStart
= wxDateTime(1, tm
.mon
, tm
.year
);
1851 int nWeek
= GetWeekOfYear(flags
) - dtMonthStart
.GetWeekOfYear(flags
) + 1;
1854 // this may happen for January when Jan, 1 is the last week of the
1856 nWeek
+= IsLeapYear(tm
.year
- 1) ? 53 : 52;
1859 return (wxDateTime::wxDateTime_t
)nWeek
;
1862 wxDateTime
& wxDateTime::SetToYearDay(wxDateTime::wxDateTime_t yday
)
1864 int year
= GetYear();
1865 wxDATETIME_CHECK( (0 < yday
) && (yday
<= GetNumberOfDays(year
)),
1866 _T("invalid year day") );
1868 bool isLeap
= IsLeapYear(year
);
1869 for ( Month mon
= Jan
; mon
< Inv_Month
; wxNextMonth(mon
) )
1871 // for Dec, we can't compare with gs_cumulatedDays[mon + 1], but we
1872 // don't need it neither - because of the CHECK above we know that
1873 // yday lies in December then
1874 if ( (mon
== Dec
) || (yday
< gs_cumulatedDays
[isLeap
][mon
+ 1]) )
1876 Set(yday
- gs_cumulatedDays
[isLeap
][mon
], mon
, year
);
1885 // ----------------------------------------------------------------------------
1886 // Julian day number conversion and related stuff
1887 // ----------------------------------------------------------------------------
1889 double wxDateTime::GetJulianDayNumber() const
1891 // JDN are always expressed for the GMT dates
1892 Tm
tm(ToTimezone(GMT0
).GetTm(GMT0
));
1894 double result
= GetTruncatedJDN(tm
.mday
, tm
.mon
, tm
.year
);
1896 // add the part GetTruncatedJDN() neglected
1899 // and now add the time: 86400 sec = 1 JDN
1900 return result
+ ((double)(60*(60*tm
.hour
+ tm
.min
) + tm
.sec
)) / 86400;
1903 double wxDateTime::GetRataDie() const
1905 // March 1 of the year 0 is Rata Die day -306 and JDN 1721119.5
1906 return GetJulianDayNumber() - 1721119.5 - 306;
1909 // ----------------------------------------------------------------------------
1910 // timezone and DST stuff
1911 // ----------------------------------------------------------------------------
1913 int wxDateTime::IsDST(wxDateTime::Country country
) const
1915 wxCHECK_MSG( country
== Country_Default
, -1,
1916 _T("country support not implemented") );
1918 // use the C RTL for the dates in the standard range
1919 time_t timet
= GetTicks();
1920 if ( timet
!= (time_t)-1 )
1922 tm
*tm
= localtime(&timet
);
1924 wxCHECK_MSG( tm
, -1, _T("localtime() failed") );
1926 return tm
->tm_isdst
;
1930 int year
= GetYear();
1932 if ( !IsDSTApplicable(year
, country
) )
1934 // no DST time in this year in this country
1938 return IsBetween(GetBeginDST(year
, country
), GetEndDST(year
, country
));
1942 wxDateTime
& wxDateTime::MakeTimezone(const TimeZone
& tz
, bool noDST
)
1944 long secDiff
= GetTimeZone() + tz
.GetOffset();
1946 // we need to know whether DST is or not in effect for this date unless
1947 // the test disabled by the caller
1948 if ( !noDST
&& (IsDST() == 1) )
1950 // FIXME we assume that the DST is always shifted by 1 hour
1954 return Subtract(wxTimeSpan::Seconds(secDiff
));
1957 // ----------------------------------------------------------------------------
1958 // wxDateTime to/from text representations
1959 // ----------------------------------------------------------------------------
1961 wxString
wxDateTime::Format(const wxChar
*format
, const TimeZone
& tz
) const
1963 wxCHECK_MSG( format
, _T(""), _T("NULL format in wxDateTime::Format") );
1965 // we have to use our own implementation if the date is out of range of
1966 // strftime() or if we use non standard specificators
1967 time_t time
= GetTicks();
1968 if ( (time
!= (time_t)-1) && !wxStrstr(format
, _T("%l")) )
1972 if ( tz
.GetOffset() == -GetTimeZone() )
1974 // we are working with local time
1975 tm
= localtime(&time
);
1977 // should never happen
1978 wxCHECK_MSG( tm
, wxEmptyString
, _T("localtime() failed") );
1982 time
+= (int)tz
.GetOffset();
1984 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
1985 int time2
= (int) time
;
1993 // should never happen
1994 wxCHECK_MSG( tm
, wxEmptyString
, _T("gmtime() failed") );
1998 tm
= (struct tm
*)NULL
;
2004 return CallStrftime(format
, tm
);
2006 //else: use generic code below
2009 // we only parse ANSI C format specifications here, no POSIX 2
2010 // complications, no GNU extensions but we do add support for a "%l" format
2011 // specifier allowing to get the number of milliseconds
2014 // used for calls to strftime() when we only deal with time
2015 struct tm tmTimeOnly
;
2016 tmTimeOnly
.tm_hour
= tm
.hour
;
2017 tmTimeOnly
.tm_min
= tm
.min
;
2018 tmTimeOnly
.tm_sec
= tm
.sec
;
2019 tmTimeOnly
.tm_wday
= 0;
2020 tmTimeOnly
.tm_yday
= 0;
2021 tmTimeOnly
.tm_mday
= 1; // any date will do
2022 tmTimeOnly
.tm_mon
= 0;
2023 tmTimeOnly
.tm_year
= 76;
2024 tmTimeOnly
.tm_isdst
= 0; // no DST, we adjust for tz ourselves
2026 wxString tmp
, res
, fmt
;
2027 for ( const wxChar
*p
= format
; *p
; p
++ )
2029 if ( *p
!= _T('%') )
2037 // set the default format
2040 case _T('Y'): // year has 4 digits
2044 case _T('j'): // day of year has 3 digits
2045 case _T('l'): // milliseconds have 3 digits
2049 case _T('w'): // week day as number has only one
2054 // it's either another valid format specifier in which case
2055 // the format is "%02d" (for all the rest) or we have the
2056 // field width preceding the format in which case it will
2057 // override the default format anyhow
2061 bool restart
= TRUE
;
2066 // start of the format specification
2069 case _T('a'): // a weekday name
2071 // second parameter should be TRUE for abbreviated names
2072 res
+= GetWeekDayName(tm
.GetWeekDay(),
2073 *p
== _T('a') ? Name_Abbr
: Name_Full
);
2076 case _T('b'): // a month name
2078 res
+= GetMonthName(tm
.mon
,
2079 *p
== _T('b') ? Name_Abbr
: Name_Full
);
2082 case _T('c'): // locale default date and time representation
2083 case _T('x'): // locale default date representation
2085 // the problem: there is no way to know what do these format
2086 // specifications correspond to for the current locale.
2088 // the solution: use a hack and still use strftime(): first
2089 // find the YEAR which is a year in the strftime() range (1970
2090 // - 2038) whose Jan 1 falls on the same week day as the Jan 1
2091 // of the real year. Then make a copy of the format and
2092 // replace all occurences of YEAR in it with some unique
2093 // string not appearing anywhere else in it, then use
2094 // strftime() to format the date in year YEAR and then replace
2095 // YEAR back by the real year and the unique replacement
2096 // string back with YEAR. Notice that "all occurences of YEAR"
2097 // means all occurences of 4 digit as well as 2 digit form!
2099 // the bugs: we assume that neither of %c nor %x contains any
2100 // fields which may change between the YEAR and real year. For
2101 // example, the week number (%U, %W) and the day number (%j)
2102 // will change if one of these years is leap and the other one
2105 // find the YEAR: normally, for any year X, Jan 1 or the
2106 // year X + 28 is the same weekday as Jan 1 of X (because
2107 // the weekday advances by 1 for each normal X and by 2
2108 // for each leap X, hence by 5 every 4 years or by 35
2109 // which is 0 mod 7 every 28 years) but this rule breaks
2110 // down if there are years between X and Y which are
2111 // divisible by 4 but not leap (i.e. divisible by 100 but
2112 // not 400), hence the correction.
2114 int yearReal
= GetYear(tz
);
2115 int mod28
= yearReal
% 28;
2117 // be careful to not go too far - we risk to leave the
2122 year
= 1988 + mod28
; // 1988 == 0 (mod 28)
2126 year
= 1970 + mod28
- 10; // 1970 == 10 (mod 28)
2129 int nCentury
= year
/ 100,
2130 nCenturyReal
= yearReal
/ 100;
2132 // need to adjust for the years divisble by 400 which are
2133 // not leap but are counted like leap ones if we just take
2134 // the number of centuries in between for nLostWeekDays
2135 int nLostWeekDays
= (nCentury
- nCenturyReal
) -
2136 (nCentury
/ 4 - nCenturyReal
/ 4);
2138 // we have to gain back the "lost" weekdays: note that the
2139 // effect of this loop is to not do anything to
2140 // nLostWeekDays (which we won't use any more), but to
2141 // (indirectly) set the year correctly
2142 while ( (nLostWeekDays
% 7) != 0 )
2144 nLostWeekDays
+= year
++ % 4 ? 1 : 2;
2147 // at any rate, we couldn't go further than 1988 + 9 + 28!
2148 wxASSERT_MSG( year
< 2030,
2149 _T("logic error in wxDateTime::Format") );
2151 wxString strYear
, strYear2
;
2152 strYear
.Printf(_T("%d"), year
);
2153 strYear2
.Printf(_T("%d"), year
% 100);
2155 // find two strings not occuring in format (this is surely
2156 // not optimal way of doing it... improvements welcome!)
2157 wxString fmt
= format
;
2158 wxString replacement
= (wxChar
)-1;
2159 while ( fmt
.Find(replacement
) != wxNOT_FOUND
)
2161 replacement
<< (wxChar
)-1;
2164 wxString replacement2
= (wxChar
)-2;
2165 while ( fmt
.Find(replacement
) != wxNOT_FOUND
)
2167 replacement
<< (wxChar
)-2;
2170 // replace all occurences of year with it
2171 bool wasReplaced
= fmt
.Replace(strYear
, replacement
) > 0;
2173 wasReplaced
= fmt
.Replace(strYear2
, replacement2
) > 0;
2175 // use strftime() to format the same date but in supported
2178 // NB: we assume that strftime() doesn't check for the
2179 // date validity and will happily format the date
2180 // corresponding to Feb 29 of a non leap year (which
2181 // may happen if yearReal was leap and year is not)
2182 struct tm tmAdjusted
;
2184 tmAdjusted
.tm_hour
= tm
.hour
;
2185 tmAdjusted
.tm_min
= tm
.min
;
2186 tmAdjusted
.tm_sec
= tm
.sec
;
2187 tmAdjusted
.tm_wday
= tm
.GetWeekDay();
2188 tmAdjusted
.tm_yday
= GetDayOfYear();
2189 tmAdjusted
.tm_mday
= tm
.mday
;
2190 tmAdjusted
.tm_mon
= tm
.mon
;
2191 tmAdjusted
.tm_year
= year
- 1900;
2192 tmAdjusted
.tm_isdst
= 0; // no DST, already adjusted
2193 wxString str
= CallStrftime(*p
== _T('c') ? _T("%c")
2197 // now replace the occurence of 1999 with the real year
2198 wxString strYearReal
, strYearReal2
;
2199 strYearReal
.Printf(_T("%04d"), yearReal
);
2200 strYearReal2
.Printf(_T("%02d"), yearReal
% 100);
2201 str
.Replace(strYear
, strYearReal
);
2202 str
.Replace(strYear2
, strYearReal2
);
2204 // and replace back all occurences of replacement string
2207 str
.Replace(replacement2
, strYear2
);
2208 str
.Replace(replacement
, strYear
);
2215 case _T('d'): // day of a month (01-31)
2216 res
+= wxString::Format(fmt
, tm
.mday
);
2219 case _T('H'): // hour in 24h format (00-23)
2220 res
+= wxString::Format(fmt
, tm
.hour
);
2223 case _T('I'): // hour in 12h format (01-12)
2225 // 24h -> 12h, 0h -> 12h too
2226 int hour12
= tm
.hour
> 12 ? tm
.hour
- 12
2227 : tm
.hour
? tm
.hour
: 12;
2228 res
+= wxString::Format(fmt
, hour12
);
2232 case _T('j'): // day of the year
2233 res
+= wxString::Format(fmt
, GetDayOfYear(tz
));
2236 case _T('l'): // milliseconds (NOT STANDARD)
2237 res
+= wxString::Format(fmt
, GetMillisecond(tz
));
2240 case _T('m'): // month as a number (01-12)
2241 res
+= wxString::Format(fmt
, tm
.mon
+ 1);
2244 case _T('M'): // minute as a decimal number (00-59)
2245 res
+= wxString::Format(fmt
, tm
.min
);
2248 case _T('p'): // AM or PM string
2249 res
+= CallStrftime(_T("%p"), &tmTimeOnly
);
2252 case _T('S'): // second as a decimal number (00-61)
2253 res
+= wxString::Format(fmt
, tm
.sec
);
2256 case _T('U'): // week number in the year (Sunday 1st week day)
2257 res
+= wxString::Format(fmt
, GetWeekOfYear(Sunday_First
, tz
));
2260 case _T('W'): // week number in the year (Monday 1st week day)
2261 res
+= wxString::Format(fmt
, GetWeekOfYear(Monday_First
, tz
));
2264 case _T('w'): // weekday as a number (0-6), Sunday = 0
2265 res
+= wxString::Format(fmt
, tm
.GetWeekDay());
2268 // case _T('x'): -- handled with "%c"
2270 case _T('X'): // locale default time representation
2271 // just use strftime() to format the time for us
2272 res
+= CallStrftime(_T("%X"), &tmTimeOnly
);
2275 case _T('y'): // year without century (00-99)
2276 res
+= wxString::Format(fmt
, tm
.year
% 100);
2279 case _T('Y'): // year with century
2280 res
+= wxString::Format(fmt
, tm
.year
);
2283 case _T('Z'): // timezone name
2284 res
+= CallStrftime(_T("%Z"), &tmTimeOnly
);
2288 // is it the format width?
2290 while ( *p
== _T('-') || *p
== _T('+') ||
2291 *p
== _T(' ') || wxIsdigit(*p
) )
2296 if ( !fmt
.IsEmpty() )
2298 // we've only got the flags and width so far in fmt
2299 fmt
.Prepend(_T('%'));
2300 fmt
.Append(_T('d'));
2307 // no, it wasn't the width
2308 wxFAIL_MSG(_T("unknown format specificator"));
2310 // fall through and just copy it nevertheless
2312 case _T('%'): // a percent sign
2316 case 0: // the end of string
2317 wxFAIL_MSG(_T("missing format at the end of string"));
2319 // just put the '%' which was the last char in format
2329 // this function parses a string in (strict) RFC 822 format: see the section 5
2330 // of the RFC for the detailed description, but briefly it's something of the
2331 // form "Sat, 18 Dec 1999 00:48:30 +0100"
2333 // this function is "strict" by design - it must reject anything except true
2334 // RFC822 time specs.
2336 // TODO a great candidate for using reg exps
2337 const wxChar
*wxDateTime::ParseRfc822Date(const wxChar
* date
)
2339 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
2341 const wxChar
*p
= date
;
2342 const wxChar
*comma
= wxStrchr(p
, _T(','));
2345 // the part before comma is the weekday
2347 // skip it for now - we don't use but might check that it really
2348 // corresponds to the specfied date
2351 if ( *p
!= _T(' ') )
2353 wxLogDebug(_T("no space after weekday in RFC822 time spec"));
2355 return (wxChar
*)NULL
;
2361 // the following 1 or 2 digits are the day number
2362 if ( !wxIsdigit(*p
) )
2364 wxLogDebug(_T("day number expected in RFC822 time spec, none found"));
2366 return (wxChar
*)NULL
;
2369 wxDateTime_t day
= *p
++ - _T('0');
2370 if ( wxIsdigit(*p
) )
2373 day
+= *p
++ - _T('0');
2376 if ( *p
++ != _T(' ') )
2378 return (wxChar
*)NULL
;
2381 // the following 3 letters specify the month
2382 wxString
monName(p
, 3);
2384 if ( monName
== _T("Jan") )
2386 else if ( monName
== _T("Feb") )
2388 else if ( monName
== _T("Mar") )
2390 else if ( monName
== _T("Apr") )
2392 else if ( monName
== _T("May") )
2394 else if ( monName
== _T("Jun") )
2396 else if ( monName
== _T("Jul") )
2398 else if ( monName
== _T("Aug") )
2400 else if ( monName
== _T("Sep") )
2402 else if ( monName
== _T("Oct") )
2404 else if ( monName
== _T("Nov") )
2406 else if ( monName
== _T("Dec") )
2410 wxLogDebug(_T("Invalid RFC 822 month name '%s'"), monName
.c_str());
2412 return (wxChar
*)NULL
;
2417 if ( *p
++ != _T(' ') )
2419 return (wxChar
*)NULL
;
2423 if ( !wxIsdigit(*p
) )
2426 return (wxChar
*)NULL
;
2429 int year
= *p
++ - _T('0');
2431 if ( !wxIsdigit(*p
) )
2433 // should have at least 2 digits in the year
2434 return (wxChar
*)NULL
;
2438 year
+= *p
++ - _T('0');
2440 // is it a 2 digit year (as per original RFC 822) or a 4 digit one?
2441 if ( wxIsdigit(*p
) )
2444 year
+= *p
++ - _T('0');
2446 if ( !wxIsdigit(*p
) )
2448 // no 3 digit years please
2449 return (wxChar
*)NULL
;
2453 year
+= *p
++ - _T('0');
2456 if ( *p
++ != _T(' ') )
2458 return (wxChar
*)NULL
;
2461 // time is in the format hh:mm:ss and seconds are optional
2462 if ( !wxIsdigit(*p
) )
2464 return (wxChar
*)NULL
;
2467 wxDateTime_t hour
= *p
++ - _T('0');
2469 if ( !wxIsdigit(*p
) )
2471 return (wxChar
*)NULL
;
2475 hour
+= *p
++ - _T('0');
2477 if ( *p
++ != _T(':') )
2479 return (wxChar
*)NULL
;
2482 if ( !wxIsdigit(*p
) )
2484 return (wxChar
*)NULL
;
2487 wxDateTime_t min
= *p
++ - _T('0');
2489 if ( !wxIsdigit(*p
) )
2491 return (wxChar
*)NULL
;
2495 min
+= *p
++ - _T('0');
2497 wxDateTime_t sec
= 0;
2498 if ( *p
++ == _T(':') )
2500 if ( !wxIsdigit(*p
) )
2502 return (wxChar
*)NULL
;
2505 sec
= *p
++ - _T('0');
2507 if ( !wxIsdigit(*p
) )
2509 return (wxChar
*)NULL
;
2513 sec
+= *p
++ - _T('0');
2516 if ( *p
++ != _T(' ') )
2518 return (wxChar
*)NULL
;
2521 // and now the interesting part: the timezone
2523 if ( *p
== _T('-') || *p
== _T('+') )
2525 // the explicit offset given: it has the form of hhmm
2526 bool plus
= *p
++ == _T('+');
2528 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2530 return (wxChar
*)NULL
;
2534 offset
= 60*(10*(*p
- _T('0')) + (*(p
+ 1) - _T('0')));
2538 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2540 return (wxChar
*)NULL
;
2544 offset
+= 10*(*p
- _T('0')) + (*(p
+ 1) - _T('0'));
2555 // the symbolic timezone given: may be either military timezone or one
2556 // of standard abbreviations
2559 // military: Z = UTC, J unused, A = -1, ..., Y = +12
2560 static const int offsets
[26] =
2562 //A B C D E F G H I J K L M
2563 -1, -2, -3, -4, -5, -6, -7, -8, -9, 0, -10, -11, -12,
2564 //N O P R Q S T U V W Z Y Z
2565 +1, +2, +3, +4, +5, +6, +7, +8, +9, +10, +11, +12, 0
2568 if ( *p
< _T('A') || *p
> _T('Z') || *p
== _T('J') )
2570 wxLogDebug(_T("Invalid militaty timezone '%c'"), *p
);
2572 return (wxChar
*)NULL
;
2575 offset
= offsets
[*p
++ - _T('A')];
2581 if ( tz
== _T("UT") || tz
== _T("UTC") || tz
== _T("GMT") )
2583 else if ( tz
== _T("AST") )
2584 offset
= AST
- GMT0
;
2585 else if ( tz
== _T("ADT") )
2586 offset
= ADT
- GMT0
;
2587 else if ( tz
== _T("EST") )
2588 offset
= EST
- GMT0
;
2589 else if ( tz
== _T("EDT") )
2590 offset
= EDT
- GMT0
;
2591 else if ( tz
== _T("CST") )
2592 offset
= CST
- GMT0
;
2593 else if ( tz
== _T("CDT") )
2594 offset
= CDT
- GMT0
;
2595 else if ( tz
== _T("MST") )
2596 offset
= MST
- GMT0
;
2597 else if ( tz
== _T("MDT") )
2598 offset
= MDT
- GMT0
;
2599 else if ( tz
== _T("PST") )
2600 offset
= PST
- GMT0
;
2601 else if ( tz
== _T("PDT") )
2602 offset
= PDT
- GMT0
;
2605 wxLogDebug(_T("Unknown RFC 822 timezone '%s'"), p
);
2607 return (wxChar
*)NULL
;
2617 // the spec was correct
2618 Set(day
, mon
, year
, hour
, min
, sec
);
2619 MakeTimezone((wxDateTime_t
)(60*offset
));
2624 const wxChar
*wxDateTime::ParseFormat(const wxChar
*date
,
2625 const wxChar
*format
,
2626 const wxDateTime
& dateDef
)
2628 wxCHECK_MSG( date
&& format
, (wxChar
*)NULL
,
2629 _T("NULL pointer in wxDateTime::ParseFormat()") );
2634 // what fields have we found?
2635 bool haveWDay
= FALSE
,
2644 bool hourIsIn12hFormat
= FALSE
, // or in 24h one?
2645 isPM
= FALSE
; // AM by default
2647 // and the value of the items we have (init them to get rid of warnings)
2648 wxDateTime_t sec
= 0,
2651 WeekDay wday
= Inv_WeekDay
;
2652 wxDateTime_t yday
= 0,
2654 wxDateTime::Month mon
= Inv_Month
;
2657 const wxChar
*input
= date
;
2658 for ( const wxChar
*fmt
= format
; *fmt
; fmt
++ )
2660 if ( *fmt
!= _T('%') )
2662 if ( wxIsspace(*fmt
) )
2664 // a white space in the format string matches 0 or more white
2665 // spaces in the input
2666 while ( wxIsspace(*input
) )
2673 // any other character (not whitespace, not '%') must be
2674 // matched by itself in the input
2675 if ( *input
++ != *fmt
)
2678 return (wxChar
*)NULL
;
2682 // done with this format char
2686 // start of a format specification
2688 // parse the optional width
2690 while ( wxIsdigit(*++fmt
) )
2693 width
+= *fmt
- _T('0');
2696 // the default widths for the various fields
2701 case _T('Y'): // year has 4 digits
2705 case _T('j'): // day of year has 3 digits
2706 case _T('l'): // milliseconds have 3 digits
2710 case _T('w'): // week day as number has only one
2715 // default for all other fields
2720 // then the format itself
2723 case _T('a'): // a weekday name
2726 int flag
= *fmt
== _T('a') ? Name_Abbr
: Name_Full
;
2727 wday
= GetWeekDayFromName(GetAlphaToken(input
), flag
);
2728 if ( wday
== Inv_WeekDay
)
2731 return (wxChar
*)NULL
;
2737 case _T('b'): // a month name
2740 int flag
= *fmt
== _T('b') ? Name_Abbr
: Name_Full
;
2741 mon
= GetMonthFromName(GetAlphaToken(input
), flag
);
2742 if ( mon
== Inv_Month
)
2745 return (wxChar
*)NULL
;
2751 case _T('c'): // locale default date and time representation
2755 // this is the format which corresponds to ctime() output
2756 // and strptime("%c") should parse it, so try it first
2757 static const wxChar
*fmtCtime
= _T("%a %b %d %H:%M:%S %Y");
2759 const wxChar
*result
= dt
.ParseFormat(input
, fmtCtime
);
2762 result
= dt
.ParseFormat(input
, _T("%x %X"));
2767 result
= dt
.ParseFormat(input
, _T("%X %x"));
2772 // we've tried everything and still no match
2773 return (wxChar
*)NULL
;
2778 haveDay
= haveMon
= haveYear
=
2779 haveHour
= haveMin
= haveSec
= TRUE
;
2793 case _T('d'): // day of a month (01-31)
2794 if ( !GetNumericToken(width
, input
, &num
) ||
2795 (num
> 31) || (num
< 1) )
2798 return (wxChar
*)NULL
;
2801 // we can't check whether the day range is correct yet, will
2802 // do it later - assume ok for now
2804 mday
= (wxDateTime_t
)num
;
2807 case _T('H'): // hour in 24h format (00-23)
2808 if ( !GetNumericToken(width
, input
, &num
) || (num
> 23) )
2811 return (wxChar
*)NULL
;
2815 hour
= (wxDateTime_t
)num
;
2818 case _T('I'): // hour in 12h format (01-12)
2819 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 12) )
2822 return (wxChar
*)NULL
;
2826 hourIsIn12hFormat
= TRUE
;
2827 hour
= (wxDateTime_t
)(num
% 12); // 12 should be 0
2830 case _T('j'): // day of the year
2831 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 366) )
2834 return (wxChar
*)NULL
;
2838 yday
= (wxDateTime_t
)num
;
2841 case _T('m'): // month as a number (01-12)
2842 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 12) )
2845 return (wxChar
*)NULL
;
2849 mon
= (Month
)(num
- 1);
2852 case _T('M'): // minute as a decimal number (00-59)
2853 if ( !GetNumericToken(width
, input
, &num
) || (num
> 59) )
2856 return (wxChar
*)NULL
;
2860 min
= (wxDateTime_t
)num
;
2863 case _T('p'): // AM or PM string
2865 wxString am
, pm
, token
= GetAlphaToken(input
);
2867 GetAmPmStrings(&am
, &pm
);
2868 if ( token
.CmpNoCase(pm
) == 0 )
2872 else if ( token
.CmpNoCase(am
) != 0 )
2875 return (wxChar
*)NULL
;
2880 case _T('r'): // time as %I:%M:%S %p
2883 input
= dt
.ParseFormat(input
, _T("%I:%M:%S %p"));
2887 return (wxChar
*)NULL
;
2890 haveHour
= haveMin
= haveSec
= TRUE
;
2899 case _T('R'): // time as %H:%M
2902 input
= dt
.ParseFormat(input
, _T("%H:%M"));
2906 return (wxChar
*)NULL
;
2909 haveHour
= haveMin
= TRUE
;
2916 case _T('S'): // second as a decimal number (00-61)
2917 if ( !GetNumericToken(width
, input
, &num
) || (num
> 61) )
2920 return (wxChar
*)NULL
;
2924 sec
= (wxDateTime_t
)num
;
2927 case _T('T'): // time as %H:%M:%S
2930 input
= dt
.ParseFormat(input
, _T("%H:%M:%S"));
2934 return (wxChar
*)NULL
;
2937 haveHour
= haveMin
= haveSec
= TRUE
;
2946 case _T('w'): // weekday as a number (0-6), Sunday = 0
2947 if ( !GetNumericToken(width
, input
, &num
) || (wday
> 6) )
2950 return (wxChar
*)NULL
;
2954 wday
= (WeekDay
)num
;
2957 case _T('x'): // locale default date representation
2958 #ifdef HAVE_STRPTIME
2959 // try using strptime() -- it may fail even if the input is
2960 // correct but the date is out of range, so we will fall back
2961 // to our generic code anyhow
2965 const wxChar
*result
= CallStrptime(input
, "%x", &tm
);
2970 haveDay
= haveMon
= haveYear
= TRUE
;
2972 year
= 1900 + tm
.tm_year
;
2973 mon
= (Month
)tm
.tm_mon
;
2979 #endif // HAVE_STRPTIME
2981 // TODO query the LOCALE_IDATE setting under Win32
2985 wxString fmtDate
, fmtDateAlt
;
2986 if ( IsWestEuropeanCountry(GetCountry()) ||
2987 GetCountry() == Russia
)
2989 fmtDate
= _T("%d/%m/%y");
2990 fmtDateAlt
= _T("%m/%d/%y");
2994 fmtDate
= _T("%m/%d/%y");
2995 fmtDateAlt
= _T("%d/%m/%y");
2998 const wxChar
*result
= dt
.ParseFormat(input
, fmtDate
);
3002 // ok, be nice and try another one
3003 result
= dt
.ParseFormat(input
, fmtDateAlt
);
3009 return (wxChar
*)NULL
;
3014 haveDay
= haveMon
= haveYear
= TRUE
;
3025 case _T('X'): // locale default time representation
3026 #ifdef HAVE_STRPTIME
3028 // use strptime() to do it for us (FIXME !Unicode friendly)
3030 input
= CallStrptime(input
, "%X", &tm
);
3033 return (wxChar
*)NULL
;
3036 haveHour
= haveMin
= haveSec
= TRUE
;
3042 #else // !HAVE_STRPTIME
3043 // TODO under Win32 we can query the LOCALE_ITIME system
3044 // setting which says whether the default time format is
3047 // try to parse what follows as "%H:%M:%S" and, if this
3048 // fails, as "%I:%M:%S %p" - this should catch the most
3052 const wxChar
*result
= dt
.ParseFormat(input
, _T("%T"));
3055 result
= dt
.ParseFormat(input
, _T("%r"));
3061 return (wxChar
*)NULL
;
3064 haveHour
= haveMin
= haveSec
= TRUE
;
3073 #endif // HAVE_STRPTIME/!HAVE_STRPTIME
3076 case _T('y'): // year without century (00-99)
3077 if ( !GetNumericToken(width
, input
, &num
) || (num
> 99) )
3080 return (wxChar
*)NULL
;
3085 // TODO should have an option for roll over date instead of
3086 // hard coding it here
3087 year
= (num
> 30 ? 1900 : 2000) + (wxDateTime_t
)num
;
3090 case _T('Y'): // year with century
3091 if ( !GetNumericToken(width
, input
, &num
) )
3094 return (wxChar
*)NULL
;
3098 year
= (wxDateTime_t
)num
;
3101 case _T('Z'): // timezone name
3102 wxFAIL_MSG(_T("TODO"));
3105 case _T('%'): // a percent sign
3106 if ( *input
++ != _T('%') )
3109 return (wxChar
*)NULL
;
3113 case 0: // the end of string
3114 wxFAIL_MSG(_T("unexpected format end"));
3118 default: // not a known format spec
3119 return (wxChar
*)NULL
;
3123 // format matched, try to construct a date from what we have now
3125 if ( dateDef
.IsValid() )
3127 // take this date as default
3128 tmDef
= dateDef
.GetTm();
3130 else if ( IsValid() )
3132 // if this date is valid, don't change it
3137 // no default and this date is invalid - fall back to Today()
3138 tmDef
= Today().GetTm();
3149 // TODO we don't check here that the values are consistent, if both year
3150 // day and month/day were found, we just ignore the year day and we
3151 // also always ignore the week day
3152 if ( haveMon
&& haveDay
)
3154 if ( mday
> GetNumOfDaysInMonth(tm
.year
, mon
) )
3156 wxLogDebug(_T("bad month day in wxDateTime::ParseFormat"));
3158 return (wxChar
*)NULL
;
3164 else if ( haveYDay
)
3166 if ( yday
> GetNumberOfDays(tm
.year
) )
3168 wxLogDebug(_T("bad year day in wxDateTime::ParseFormat"));
3170 return (wxChar
*)NULL
;
3173 Tm tm2
= wxDateTime(1, Jan
, tm
.year
).SetToYearDay(yday
).GetTm();
3180 if ( haveHour
&& hourIsIn12hFormat
&& isPM
)
3182 // translate to 24hour format
3185 //else: either already in 24h format or no translation needed
3205 // finally check that the week day is consistent -- if we had it
3206 if ( haveWDay
&& GetWeekDay() != wday
)
3208 wxLogDebug(_T("inconsistsnet week day in wxDateTime::ParseFormat()"));
3216 const wxChar
*wxDateTime::ParseDateTime(const wxChar
*date
)
3218 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3220 // Set to current day and hour, so strings like '14:00' becomes today at
3221 // 14, not some other random date
3222 wxDateTime dtDate
= wxDateTime::Today();
3223 wxDateTime dtTime
= wxDateTime::Today();
3225 const wxChar
* pchTime
;
3227 // Try to parse the beginning of the string as a date
3228 const wxChar
* pchDate
= dtDate
.ParseDate(date
);
3230 // We got a date in the beginning, see if there is a time specified after the date
3233 // Skip spaces, as the ParseTime() function fails on spaces
3234 while ( wxIsspace(*pchDate
) )
3237 pchTime
= dtTime
.ParseTime(pchDate
);
3239 else // no date in the beginning
3241 // check and see if we have a time followed by a date
3242 pchTime
= dtTime
.ParseTime(date
);
3245 while ( wxIsspace(*pchTime
) )
3248 pchDate
= dtDate
.ParseDate(pchTime
);
3252 // If we have a date specified, set our own data to the same date
3253 if ( !pchDate
|| !pchTime
)
3256 Set(dtDate
.GetDay(), dtDate
.GetMonth(), dtDate
.GetYear(),
3257 dtTime
.GetHour(), dtTime
.GetMinute(), dtTime
.GetSecond(),
3258 dtTime
.GetMillisecond());
3260 // Return endpoint of scan
3261 return pchDate
> pchTime
? pchDate
: pchTime
;
3264 const wxChar
*wxDateTime::ParseDate(const wxChar
*date
)
3266 // this is a simplified version of ParseDateTime() which understands only
3267 // "today" (for wxDate compatibility) and digits only otherwise (and not
3268 // all esoteric constructions ParseDateTime() knows about)
3270 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3272 const wxChar
*p
= date
;
3273 while ( wxIsspace(*p
) )
3276 // some special cases
3280 int dayDiffFromToday
;
3283 { wxTRANSLATE("today"), 0 },
3284 { wxTRANSLATE("yesterday"), -1 },
3285 { wxTRANSLATE("tomorrow"), 1 },
3288 for ( size_t n
= 0; n
< WXSIZEOF(literalDates
); n
++ )
3290 wxString date
= wxGetTranslation(literalDates
[n
].str
);
3291 size_t len
= date
.length();
3292 if ( wxStrlen(p
) >= len
&& (wxString(p
, len
).CmpNoCase(date
) == 0) )
3294 // nothing can follow this, so stop here
3297 int dayDiffFromToday
= literalDates
[n
].dayDiffFromToday
;
3299 if ( dayDiffFromToday
)
3301 *this += wxDateSpan::Days(dayDiffFromToday
);
3308 // We try to guess what we have here: for each new (numeric) token, we
3309 // determine if it can be a month, day or a year. Of course, there is an
3310 // ambiguity as some numbers may be days as well as months, so we also
3311 // have the ability to back track.
3314 bool haveDay
= FALSE
, // the months day?
3315 haveWDay
= FALSE
, // the day of week?
3316 haveMon
= FALSE
, // the month?
3317 haveYear
= FALSE
; // the year?
3319 // and the value of the items we have (init them to get rid of warnings)
3320 WeekDay wday
= Inv_WeekDay
;
3321 wxDateTime_t day
= 0;
3322 wxDateTime::Month mon
= Inv_Month
;
3325 // tokenize the string
3327 static const wxChar
*dateDelimiters
= _T(".,/-\t\r\n ");
3328 wxStringTokenizer
tok(p
, dateDelimiters
);
3329 while ( tok
.HasMoreTokens() )
3331 wxString token
= tok
.GetNextToken();
3337 if ( token
.ToULong(&val
) )
3339 // guess what this number is
3345 if ( !haveMon
&& val
> 0 && val
<= 12 )
3347 // assume it is month
3350 else // not the month
3354 // this can only be the year
3357 else // may be either day or year
3359 wxDateTime_t maxDays
= haveMon
3360 ? GetNumOfDaysInMonth(haveYear
? year
: Inv_Year
, mon
)
3364 if ( (val
== 0) || (val
> (unsigned long)maxDays
) )
3369 else // yes, suppose it's the day
3383 year
= (wxDateTime_t
)val
;
3392 day
= (wxDateTime_t
)val
;
3398 mon
= (Month
)(val
- 1);
3401 else // not a number
3403 // be careful not to overwrite the current mon value
3404 Month mon2
= GetMonthFromName(token
, Name_Full
| Name_Abbr
);
3405 if ( mon2
!= Inv_Month
)
3410 // but we already have a month - maybe we guessed wrong?
3413 // no need to check in month range as always < 12, but
3414 // the days are counted from 1 unlike the months
3415 day
= (wxDateTime_t
)mon
+ 1;
3420 // could possible be the year (doesn't the year come
3421 // before the month in the japanese format?) (FIXME)
3430 else // not a valid month name
3432 wday
= GetWeekDayFromName(token
, Name_Full
| Name_Abbr
);
3433 if ( wday
!= Inv_WeekDay
)
3443 else // not a valid weekday name
3446 static const wxChar
*ordinals
[] =
3448 wxTRANSLATE("first"),
3449 wxTRANSLATE("second"),
3450 wxTRANSLATE("third"),
3451 wxTRANSLATE("fourth"),
3452 wxTRANSLATE("fifth"),
3453 wxTRANSLATE("sixth"),
3454 wxTRANSLATE("seventh"),
3455 wxTRANSLATE("eighth"),
3456 wxTRANSLATE("ninth"),
3457 wxTRANSLATE("tenth"),
3458 wxTRANSLATE("eleventh"),
3459 wxTRANSLATE("twelfth"),
3460 wxTRANSLATE("thirteenth"),
3461 wxTRANSLATE("fourteenth"),
3462 wxTRANSLATE("fifteenth"),
3463 wxTRANSLATE("sixteenth"),
3464 wxTRANSLATE("seventeenth"),
3465 wxTRANSLATE("eighteenth"),
3466 wxTRANSLATE("nineteenth"),
3467 wxTRANSLATE("twentieth"),
3468 // that's enough - otherwise we'd have problems with
3469 // composite (or not) ordinals
3473 for ( n
= 0; n
< WXSIZEOF(ordinals
); n
++ )
3475 if ( token
.CmpNoCase(ordinals
[n
]) == 0 )
3481 if ( n
== WXSIZEOF(ordinals
) )
3483 // stop here - something unknown
3490 // don't try anything here (as in case of numeric day
3491 // above) - the symbolic day spec should always
3492 // precede the month/year
3498 day
= (wxDateTime_t
)(n
+ 1);
3503 nPosCur
= tok
.GetPosition();
3506 // either no more tokens or the scan was stopped by something we couldn't
3507 // parse - in any case, see if we can construct a date from what we have
3508 if ( !haveDay
&& !haveWDay
)
3510 wxLogDebug(_T("ParseDate: no day, no weekday hence no date."));
3512 return (wxChar
*)NULL
;
3515 if ( haveWDay
&& (haveMon
|| haveYear
|| haveDay
) &&
3516 !(haveDay
&& haveMon
&& haveYear
) )
3518 // without adjectives (which we don't support here) the week day only
3519 // makes sense completely separately or with the full date
3520 // specification (what would "Wed 1999" mean?)
3521 return (wxChar
*)NULL
;
3524 if ( !haveWDay
&& haveYear
&& !(haveDay
&& haveMon
) )
3526 // may be we have month and day instead of day and year?
3527 if ( haveDay
&& !haveMon
)
3531 // exchange day and month
3532 mon
= (wxDateTime::Month
)(day
- 1);
3534 // we're in the current year then
3535 if ( (year
> 0) && (year
<= (int)GetNumOfDaysInMonth(Inv_Year
, mon
)) )
3542 //else: no, can't exchange, leave haveMon == FALSE
3548 // if we give the year, month and day must be given too
3549 wxLogDebug(_T("ParseDate: day and month should be specified if year is."));
3551 return (wxChar
*)NULL
;
3557 mon
= GetCurrentMonth();
3562 year
= GetCurrentYear();
3567 Set(day
, mon
, year
);
3571 // check that it is really the same
3572 if ( GetWeekDay() != wday
)
3574 // inconsistency detected
3575 wxLogDebug(_T("ParseDate: inconsistent day/weekday."));
3577 return (wxChar
*)NULL
;
3585 SetToWeekDayInSameWeek(wday
);
3588 // return the pointer to the first unparsed char
3590 if ( nPosCur
&& wxStrchr(dateDelimiters
, *(p
- 1)) )
3592 // if we couldn't parse the token after the delimiter, put back the
3593 // delimiter as well
3600 const wxChar
*wxDateTime::ParseTime(const wxChar
*time
)
3602 wxCHECK_MSG( time
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3604 // first try some extra things
3611 { wxTRANSLATE("noon"), 12 },
3612 { wxTRANSLATE("midnight"), 00 },
3616 for ( size_t n
= 0; n
< WXSIZEOF(stdTimes
); n
++ )
3618 wxString timeString
= wxGetTranslation(stdTimes
[n
].name
);
3619 size_t len
= timeString
.length();
3620 if ( timeString
.CmpNoCase(wxString(time
, len
)) == 0 )
3622 // casts required by DigitalMars
3623 Set(stdTimes
[n
].hour
, wxDateTime_t(0), wxDateTime_t(0));
3629 // try all time formats we may think about in the order from longest to
3632 // 12hour with AM/PM?
3633 const wxChar
*result
= ParseFormat(time
, _T("%I:%M:%S %p"));
3637 // normally, it's the same, but why not try it?
3638 result
= ParseFormat(time
, _T("%H:%M:%S"));
3643 // 12hour with AM/PM but without seconds?
3644 result
= ParseFormat(time
, _T("%I:%M %p"));
3650 result
= ParseFormat(time
, _T("%H:%M"));
3655 // just the hour and AM/PM?
3656 result
= ParseFormat(time
, _T("%I %p"));
3662 result
= ParseFormat(time
, _T("%H"));
3667 // parse the standard format: normally it is one of the formats above
3668 // but it may be set to something completely different by the user
3669 result
= ParseFormat(time
, _T("%X"));
3672 // TODO: parse timezones
3677 // ----------------------------------------------------------------------------
3678 // Workdays and holidays support
3679 // ----------------------------------------------------------------------------
3681 bool wxDateTime::IsWorkDay(Country
WXUNUSED(country
)) const
3683 return !wxDateTimeHolidayAuthority::IsHoliday(*this);
3686 // ============================================================================
3688 // ============================================================================
3690 // this enum is only used in wxTimeSpan::Format() below but we can't declare
3691 // it locally to the method as it provokes an internal compiler error in egcs
3692 // 2.91.60 when building with -O2
3703 // not all strftime(3) format specifiers make sense here because, for example,
3704 // a time span doesn't have a year nor a timezone
3706 // Here are the ones which are supported (all of them are supported by strftime
3708 // %H hour in 24 hour format
3709 // %M minute (00 - 59)
3710 // %S second (00 - 59)
3713 // Also, for MFC CTimeSpan compatibility, we support
3714 // %D number of days
3716 // And, to be better than MFC :-), we also have
3717 // %E number of wEeks
3718 // %l milliseconds (000 - 999)
3719 wxString
wxTimeSpan::Format(const wxChar
*format
) const
3721 wxCHECK_MSG( format
, _T(""), _T("NULL format in wxTimeSpan::Format") );
3724 str
.Alloc(wxStrlen(format
));
3726 // Suppose we have wxTimeSpan ts(1 /* hour */, 2 /* min */, 3 /* sec */)
3728 // Then, of course, ts.Format("%H:%M:%S") must return "01:02:03", but the
3729 // question is what should ts.Format("%S") do? The code here returns "3273"
3730 // in this case (i.e. the total number of seconds, not just seconds % 60)
3731 // because, for me, this call means "give me entire time interval in
3732 // seconds" and not "give me the seconds part of the time interval"
3734 // If we agree that it should behave like this, it is clear that the
3735 // interpretation of each format specifier depends on the presence of the
3736 // other format specs in the string: if there was "%H" before "%M", we
3737 // should use GetMinutes() % 60, otherwise just GetMinutes() &c
3739 // we remember the most important unit found so far
3740 TimeSpanPart partBiggest
= Part_MSec
;
3742 for ( const wxChar
*pch
= format
; *pch
; pch
++ )
3746 if ( ch
== _T('%') )
3748 // the start of the format specification of the printf() below
3749 wxString fmtPrefix
= _T('%');
3754 ch
= *++pch
; // get the format spec char
3758 wxFAIL_MSG( _T("invalid format character") );
3764 // skip the part below switch
3769 if ( partBiggest
< Part_Day
)
3775 partBiggest
= Part_Day
;
3780 partBiggest
= Part_Week
;
3786 if ( partBiggest
< Part_Hour
)
3792 partBiggest
= Part_Hour
;
3795 fmtPrefix
+= _T("02");
3799 n
= GetMilliseconds().ToLong();
3800 if ( partBiggest
< Part_MSec
)
3804 //else: no need to reset partBiggest to Part_MSec, it is
3805 // the least significant one anyhow
3807 fmtPrefix
+= _T("03");
3812 if ( partBiggest
< Part_Min
)
3818 partBiggest
= Part_Min
;
3821 fmtPrefix
+= _T("02");
3825 n
= GetSeconds().ToLong();
3826 if ( partBiggest
< Part_Sec
)
3832 partBiggest
= Part_Sec
;
3835 fmtPrefix
+= _T("02");
3839 str
+= wxString::Format(fmtPrefix
+ _T("ld"), n
);
3843 // normal character, just copy
3851 // ============================================================================
3852 // wxDateTimeHolidayAuthority and related classes
3853 // ============================================================================
3855 #include "wx/arrimpl.cpp"
3857 WX_DEFINE_OBJARRAY(wxDateTimeArray
);
3859 static int wxCMPFUNC_CONV
3860 wxDateTimeCompareFunc(wxDateTime
**first
, wxDateTime
**second
)
3862 wxDateTime dt1
= **first
,
3865 return dt1
== dt2
? 0 : dt1
< dt2
? -1 : +1;
3868 // ----------------------------------------------------------------------------
3869 // wxDateTimeHolidayAuthority
3870 // ----------------------------------------------------------------------------
3872 wxHolidayAuthoritiesArray
wxDateTimeHolidayAuthority::ms_authorities
;
3875 bool wxDateTimeHolidayAuthority::IsHoliday(const wxDateTime
& dt
)
3877 size_t count
= ms_authorities
.size();
3878 for ( size_t n
= 0; n
< count
; n
++ )
3880 if ( ms_authorities
[n
]->DoIsHoliday(dt
) )
3891 wxDateTimeHolidayAuthority::GetHolidaysInRange(const wxDateTime
& dtStart
,
3892 const wxDateTime
& dtEnd
,
3893 wxDateTimeArray
& holidays
)
3895 wxDateTimeArray hol
;
3899 size_t count
= ms_authorities
.size();
3900 for ( size_t nAuth
= 0; nAuth
< count
; nAuth
++ )
3902 ms_authorities
[nAuth
]->DoGetHolidaysInRange(dtStart
, dtEnd
, hol
);
3904 WX_APPEND_ARRAY(holidays
, hol
);
3907 holidays
.Sort(wxDateTimeCompareFunc
);
3909 return holidays
.size();
3913 void wxDateTimeHolidayAuthority::ClearAllAuthorities()
3915 WX_CLEAR_ARRAY(ms_authorities
);
3919 void wxDateTimeHolidayAuthority::AddAuthority(wxDateTimeHolidayAuthority
*auth
)
3921 ms_authorities
.push_back(auth
);
3924 wxDateTimeHolidayAuthority::~wxDateTimeHolidayAuthority()
3926 // nothing to do here
3929 // ----------------------------------------------------------------------------
3930 // wxDateTimeWorkDays
3931 // ----------------------------------------------------------------------------
3933 bool wxDateTimeWorkDays::DoIsHoliday(const wxDateTime
& dt
) const
3935 wxDateTime::WeekDay wd
= dt
.GetWeekDay();
3937 return (wd
== wxDateTime::Sun
) || (wd
== wxDateTime::Sat
);
3940 size_t wxDateTimeWorkDays::DoGetHolidaysInRange(const wxDateTime
& dtStart
,
3941 const wxDateTime
& dtEnd
,
3942 wxDateTimeArray
& holidays
) const
3944 if ( dtStart
> dtEnd
)
3946 wxFAIL_MSG( _T("invalid date range in GetHolidaysInRange") );
3953 // instead of checking all days, start with the first Sat after dtStart and
3954 // end with the last Sun before dtEnd
3955 wxDateTime dtSatFirst
= dtStart
.GetNextWeekDay(wxDateTime::Sat
),
3956 dtSatLast
= dtEnd
.GetPrevWeekDay(wxDateTime::Sat
),
3957 dtSunFirst
= dtStart
.GetNextWeekDay(wxDateTime::Sun
),
3958 dtSunLast
= dtEnd
.GetPrevWeekDay(wxDateTime::Sun
),
3961 for ( dt
= dtSatFirst
; dt
<= dtSatLast
; dt
+= wxDateSpan::Week() )
3966 for ( dt
= dtSunFirst
; dt
<= dtSunLast
; dt
+= wxDateSpan::Week() )
3971 return holidays
.GetCount();
3974 #endif // wxUSE_DATETIME