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
.IsEmpty() && 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 (but notice that the day should be such that
821 // after adding wday to it below we still have a valid date, e.g. don't
829 // and offset it by the number of days needed to get the correct wday
832 // call mktime() to normalize it...
835 // ... and call strftime()
836 return CallStrftime(flags
== Name_Abbr
? _T("%a") : _T("%A"), &tm
);
840 void wxDateTime::GetAmPmStrings(wxString
*am
, wxString
*pm
)
845 // @Note: Do not call 'CallStrftime' here! CallStrftime checks the return code
846 // and causes an assertion failed if the buffer is to small (which is good) - OR -
847 // if strftime does not return anything because the format string is invalid - OR -
848 // if there are no 'am' / 'pm' tokens defined for the current locale (which is not good).
849 // wxDateTime::ParseTime will try several different formats to parse the time.
850 // As a result, GetAmPmStrings might get called, even if the current locale
851 // does not define any 'am' / 'pm' tokens. In this case, wxStrftime would
852 // assert, even though it is a perfectly legal use.
855 if (wxStrftime(buffer
, sizeof buffer
, _T("%p"), &tm
) > 0)
856 *am
= wxString(buffer
);
863 if (wxStrftime(buffer
, sizeof buffer
, _T("%p"), &tm
) > 0)
864 *pm
= wxString(buffer
);
870 // ----------------------------------------------------------------------------
871 // Country stuff: date calculations depend on the country (DST, work days,
872 // ...), so we need to know which rules to follow.
873 // ----------------------------------------------------------------------------
876 wxDateTime::Country
wxDateTime::GetCountry()
878 // TODO use LOCALE_ICOUNTRY setting under Win32
880 if ( ms_country
== Country_Unknown
)
882 // try to guess from the time zone name
883 time_t t
= time(NULL
);
884 struct tm
*tm
= localtime(&t
);
886 wxString tz
= CallStrftime(_T("%Z"), tm
);
887 if ( tz
== _T("WET") || tz
== _T("WEST") )
891 else if ( tz
== _T("CET") || tz
== _T("CEST") )
893 ms_country
= Country_EEC
;
895 else if ( tz
== _T("MSK") || tz
== _T("MSD") )
899 else if ( tz
== _T("AST") || tz
== _T("ADT") ||
900 tz
== _T("EST") || tz
== _T("EDT") ||
901 tz
== _T("CST") || tz
== _T("CDT") ||
902 tz
== _T("MST") || tz
== _T("MDT") ||
903 tz
== _T("PST") || tz
== _T("PDT") )
909 // well, choose a default one
918 void wxDateTime::SetCountry(wxDateTime::Country country
)
920 ms_country
= country
;
924 bool wxDateTime::IsWestEuropeanCountry(Country country
)
926 if ( country
== Country_Default
)
928 country
= GetCountry();
931 return (Country_WesternEurope_Start
<= country
) &&
932 (country
<= Country_WesternEurope_End
);
935 // ----------------------------------------------------------------------------
936 // DST calculations: we use 3 different rules for the West European countries,
937 // USA and for the rest of the world. This is undoubtedly false for many
938 // countries, but I lack the necessary info (and the time to gather it),
939 // please add the other rules here!
940 // ----------------------------------------------------------------------------
943 bool wxDateTime::IsDSTApplicable(int year
, Country country
)
945 if ( year
== Inv_Year
)
947 // take the current year if none given
948 year
= GetCurrentYear();
951 if ( country
== Country_Default
)
953 country
= GetCountry();
960 // DST was first observed in the US and UK during WWI, reused
961 // during WWII and used again since 1966
962 return year
>= 1966 ||
963 (year
>= 1942 && year
<= 1945) ||
964 (year
== 1918 || year
== 1919);
967 // assume that it started after WWII
973 wxDateTime
wxDateTime::GetBeginDST(int year
, Country country
)
975 if ( year
== Inv_Year
)
977 // take the current year if none given
978 year
= GetCurrentYear();
981 if ( country
== Country_Default
)
983 country
= GetCountry();
986 if ( !IsDSTApplicable(year
, country
) )
988 return wxInvalidDateTime
;
993 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
995 // DST begins at 1 a.m. GMT on the last Sunday of March
996 if ( !dt
.SetToLastWeekDay(Sun
, Mar
, year
) )
999 wxFAIL_MSG( _T("no last Sunday in March?") );
1002 dt
+= wxTimeSpan::Hours(1);
1004 // disable DST tests because it could result in an infinite recursion!
1007 else switch ( country
)
1014 // don't know for sure - assume it was in effect all year
1019 dt
.Set(1, Jan
, year
);
1023 // DST was installed Feb 2, 1942 by the Congress
1024 dt
.Set(2, Feb
, year
);
1027 // Oil embargo changed the DST period in the US
1029 dt
.Set(6, Jan
, 1974);
1033 dt
.Set(23, Feb
, 1975);
1037 // before 1986, DST begun on the last Sunday of April, but
1038 // in 1986 Reagan changed it to begin at 2 a.m. of the
1039 // first Sunday in April
1042 if ( !dt
.SetToLastWeekDay(Sun
, Apr
, year
) )
1045 wxFAIL_MSG( _T("no first Sunday in April?") );
1050 if ( !dt
.SetToWeekDay(Sun
, 1, Apr
, year
) )
1053 wxFAIL_MSG( _T("no first Sunday in April?") );
1057 dt
+= wxTimeSpan::Hours(2);
1059 // TODO what about timezone??
1065 // assume Mar 30 as the start of the DST for the rest of the world
1066 // - totally bogus, of course
1067 dt
.Set(30, Mar
, year
);
1074 wxDateTime
wxDateTime::GetEndDST(int year
, Country country
)
1076 if ( year
== Inv_Year
)
1078 // take the current year if none given
1079 year
= GetCurrentYear();
1082 if ( country
== Country_Default
)
1084 country
= GetCountry();
1087 if ( !IsDSTApplicable(year
, country
) )
1089 return wxInvalidDateTime
;
1094 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
1096 // DST ends at 1 a.m. GMT on the last Sunday of October
1097 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1099 // weirder and weirder...
1100 wxFAIL_MSG( _T("no last Sunday in October?") );
1103 dt
+= wxTimeSpan::Hours(1);
1105 // disable DST tests because it could result in an infinite recursion!
1108 else switch ( country
)
1115 // don't know for sure - assume it was in effect all year
1119 dt
.Set(31, Dec
, year
);
1123 // the time was reset after the end of the WWII
1124 dt
.Set(30, Sep
, year
);
1128 // DST ends at 2 a.m. on the last Sunday of October
1129 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1131 // weirder and weirder...
1132 wxFAIL_MSG( _T("no last Sunday in October?") );
1135 dt
+= wxTimeSpan::Hours(2);
1137 // TODO what about timezone??
1142 // assume October 26th as the end of the DST - totally bogus too
1143 dt
.Set(26, Oct
, year
);
1149 // ----------------------------------------------------------------------------
1150 // constructors and assignment operators
1151 // ----------------------------------------------------------------------------
1153 // return the current time with ms precision
1154 /* static */ wxDateTime
wxDateTime::UNow()
1156 return wxDateTime(wxGetLocalTimeMillis());
1159 // the values in the tm structure contain the local time
1160 wxDateTime
& wxDateTime::Set(const struct tm
& tm
)
1163 time_t timet
= mktime(&tm2
);
1165 if ( timet
== (time_t)-1 )
1167 // mktime() rather unintuitively fails for Jan 1, 1970 if the hour is
1168 // less than timezone - try to make it work for this case
1169 if ( tm2
.tm_year
== 70 && tm2
.tm_mon
== 0 && tm2
.tm_mday
== 1 )
1171 // add timezone to make sure that date is in range
1172 tm2
.tm_sec
-= GetTimeZone();
1174 timet
= mktime(&tm2
);
1175 if ( timet
!= (time_t)-1 )
1177 timet
+= GetTimeZone();
1183 wxFAIL_MSG( _T("mktime() failed") );
1185 *this = wxInvalidDateTime
;
1195 wxDateTime
& wxDateTime::Set(wxDateTime_t hour
,
1196 wxDateTime_t minute
,
1197 wxDateTime_t second
,
1198 wxDateTime_t millisec
)
1200 // we allow seconds to be 61 to account for the leap seconds, even if we
1201 // don't use them really
1202 wxDATETIME_CHECK( hour
< 24 &&
1206 _T("Invalid time in wxDateTime::Set()") );
1208 // get the current date from system
1209 struct tm
*tm
= GetTmNow();
1211 wxDATETIME_CHECK( tm
, _T("localtime() failed") );
1215 tm
->tm_min
= minute
;
1216 tm
->tm_sec
= second
;
1220 // and finally adjust milliseconds
1221 return SetMillisecond(millisec
);
1224 wxDateTime
& wxDateTime::Set(wxDateTime_t day
,
1228 wxDateTime_t minute
,
1229 wxDateTime_t second
,
1230 wxDateTime_t millisec
)
1232 wxDATETIME_CHECK( hour
< 24 &&
1236 _T("Invalid time in wxDateTime::Set()") );
1238 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1240 wxDATETIME_CHECK( (0 < day
) && (day
<= GetNumberOfDays(month
, year
)),
1241 _T("Invalid date in wxDateTime::Set()") );
1243 // the range of time_t type (inclusive)
1244 static const int yearMinInRange
= 1970;
1245 static const int yearMaxInRange
= 2037;
1247 // test only the year instead of testing for the exact end of the Unix
1248 // time_t range - it doesn't bring anything to do more precise checks
1249 if ( year
>= yearMinInRange
&& year
<= yearMaxInRange
)
1251 // use the standard library version if the date is in range - this is
1252 // probably more efficient than our code
1254 tm
.tm_year
= year
- 1900;
1260 tm
.tm_isdst
= -1; // mktime() will guess it
1264 // and finally adjust milliseconds
1265 return SetMillisecond(millisec
);
1269 // do time calculations ourselves: we want to calculate the number of
1270 // milliseconds between the given date and the epoch
1272 // get the JDN for the midnight of this day
1273 m_time
= GetTruncatedJDN(day
, month
, year
);
1274 m_time
-= EPOCH_JDN
;
1275 m_time
*= SECONDS_PER_DAY
* TIME_T_FACTOR
;
1277 // JDN corresponds to GMT, we take localtime
1278 Add(wxTimeSpan(hour
, minute
, second
+ GetTimeZone(), millisec
));
1284 wxDateTime
& wxDateTime::Set(double jdn
)
1286 // so that m_time will be 0 for the midnight of Jan 1, 1970 which is jdn
1288 jdn
-= EPOCH_JDN
+ 0.5;
1290 jdn
*= MILLISECONDS_PER_DAY
;
1292 // JDNs always suppose an UTC date, so bring it back to local time zone
1293 // (also see GetJulianDayNumber() implementation)
1294 long tzDiff
= GetTimeZone();
1297 // FIXME: again, we suppose that DST is always one hour
1301 jdn
+= tzDiff
*1000; // tzDiff is in seconds
1308 wxDateTime
& wxDateTime::ResetTime()
1312 if ( tm
.hour
|| tm
.min
|| tm
.sec
|| tm
.msec
)
1325 // ----------------------------------------------------------------------------
1326 // DOS Date and Time Format functions
1327 // ----------------------------------------------------------------------------
1328 // the dos date and time value is an unsigned 32 bit value in the format:
1329 // YYYYYYYMMMMDDDDDhhhhhmmmmmmsssss
1331 // Y = year offset from 1980 (0-127)
1333 // D = day of month (1-31)
1335 // m = minute (0-59)
1336 // s = bisecond (0-29) each bisecond indicates two seconds
1337 // ----------------------------------------------------------------------------
1339 wxDateTime
& wxDateTime::SetFromDOS(unsigned long ddt
)
1344 long year
= ddt
& 0xFE000000;
1349 long month
= ddt
& 0x1E00000;
1354 long day
= ddt
& 0x1F0000;
1358 long hour
= ddt
& 0xF800;
1362 long minute
= ddt
& 0x7E0;
1366 long second
= ddt
& 0x1F;
1367 tm
.tm_sec
= second
* 2;
1369 return Set(mktime(&tm
));
1372 unsigned long wxDateTime::GetAsDOS() const
1375 time_t ticks
= GetTicks();
1376 struct tm
*tm
= localtime(&ticks
);
1378 long year
= tm
->tm_year
;
1382 long month
= tm
->tm_mon
;
1386 long day
= tm
->tm_mday
;
1389 long hour
= tm
->tm_hour
;
1392 long minute
= tm
->tm_min
;
1395 long second
= tm
->tm_sec
;
1398 ddt
= year
| month
| day
| hour
| minute
| second
;
1402 // ----------------------------------------------------------------------------
1403 // time_t <-> broken down time conversions
1404 // ----------------------------------------------------------------------------
1406 wxDateTime::Tm
wxDateTime::GetTm(const TimeZone
& tz
) const
1408 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1410 time_t time
= GetTicks();
1411 if ( time
!= (time_t)-1 )
1413 // use C RTL functions
1415 if ( tz
.GetOffset() == -GetTimeZone() )
1417 // we are working with local time
1418 tm
= localtime(&time
);
1420 // should never happen
1421 wxCHECK_MSG( tm
, Tm(), _T("localtime() failed") );
1425 time
+= (time_t)tz
.GetOffset();
1426 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
1427 int time2
= (int) time
;
1435 // should never happen
1436 wxCHECK_MSG( tm
, Tm(), _T("gmtime() failed") );
1440 tm
= (struct tm
*)NULL
;
1446 // adjust the milliseconds
1448 long timeOnly
= (m_time
% MILLISECONDS_PER_DAY
).ToLong();
1449 tm2
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1452 //else: use generic code below
1455 // remember the time and do the calculations with the date only - this
1456 // eliminates rounding errors of the floating point arithmetics
1458 wxLongLong timeMidnight
= m_time
+ tz
.GetOffset() * 1000;
1460 long timeOnly
= (timeMidnight
% MILLISECONDS_PER_DAY
).ToLong();
1462 // we want to always have positive time and timeMidnight to be really
1463 // the midnight before it
1466 timeOnly
= MILLISECONDS_PER_DAY
+ timeOnly
;
1469 timeMidnight
-= timeOnly
;
1471 // calculate the Gregorian date from JDN for the midnight of our date:
1472 // this will yield day, month (in 1..12 range) and year
1474 // actually, this is the JDN for the noon of the previous day
1475 long jdn
= (timeMidnight
/ MILLISECONDS_PER_DAY
).ToLong() + EPOCH_JDN
;
1477 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
1479 wxASSERT_MSG( jdn
> -2, _T("JDN out of range") );
1481 // calculate the century
1482 long temp
= (jdn
+ JDN_OFFSET
) * 4 - 1;
1483 long century
= temp
/ DAYS_PER_400_YEARS
;
1485 // then the year and day of year (1 <= dayOfYear <= 366)
1486 temp
= ((temp
% DAYS_PER_400_YEARS
) / 4) * 4 + 3;
1487 long year
= (century
* 100) + (temp
/ DAYS_PER_4_YEARS
);
1488 long dayOfYear
= (temp
% DAYS_PER_4_YEARS
) / 4 + 1;
1490 // and finally the month and day of the month
1491 temp
= dayOfYear
* 5 - 3;
1492 long month
= temp
/ DAYS_PER_5_MONTHS
;
1493 long day
= (temp
% DAYS_PER_5_MONTHS
) / 5 + 1;
1495 // month is counted from March - convert to normal
1506 // year is offset by 4800
1509 // check that the algorithm gave us something reasonable
1510 wxASSERT_MSG( (0 < month
) && (month
<= 12), _T("invalid month") );
1511 wxASSERT_MSG( (1 <= day
) && (day
< 32), _T("invalid day") );
1513 // construct Tm from these values
1515 tm
.year
= (int)year
;
1516 tm
.mon
= (Month
)(month
- 1); // algorithm yields 1 for January, not 0
1517 tm
.mday
= (wxDateTime_t
)day
;
1518 tm
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1519 timeOnly
-= tm
.msec
;
1520 timeOnly
/= 1000; // now we have time in seconds
1522 tm
.sec
= (wxDateTime_t
)(timeOnly
% 60);
1524 timeOnly
/= 60; // now we have time in minutes
1526 tm
.min
= (wxDateTime_t
)(timeOnly
% 60);
1529 tm
.hour
= (wxDateTime_t
)(timeOnly
/ 60);
1534 wxDateTime
& wxDateTime::SetYear(int year
)
1536 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1545 wxDateTime
& wxDateTime::SetMonth(Month month
)
1547 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1556 wxDateTime
& wxDateTime::SetDay(wxDateTime_t mday
)
1558 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1567 wxDateTime
& wxDateTime::SetHour(wxDateTime_t hour
)
1569 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1578 wxDateTime
& wxDateTime::SetMinute(wxDateTime_t min
)
1580 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1589 wxDateTime
& wxDateTime::SetSecond(wxDateTime_t sec
)
1591 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1600 wxDateTime
& wxDateTime::SetMillisecond(wxDateTime_t millisecond
)
1602 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1604 // we don't need to use GetTm() for this one
1605 m_time
-= m_time
% 1000l;
1606 m_time
+= millisecond
;
1611 // ----------------------------------------------------------------------------
1612 // wxDateTime arithmetics
1613 // ----------------------------------------------------------------------------
1615 wxDateTime
& wxDateTime::Add(const wxDateSpan
& diff
)
1619 tm
.year
+= diff
.GetYears();
1620 tm
.AddMonths(diff
.GetMonths());
1622 // check that the resulting date is valid
1623 if ( tm
.mday
> GetNumOfDaysInMonth(tm
.year
, tm
.mon
) )
1625 // We suppose that when adding one month to Jan 31 we want to get Feb
1626 // 28 (or 29), i.e. adding a month to the last day of the month should
1627 // give the last day of the next month which is quite logical.
1629 // Unfortunately, there is no logic way to understand what should
1630 // Jan 30 + 1 month be - Feb 28 too or Feb 27 (assuming non leap year)?
1631 // We make it Feb 28 (last day too), but it is highly questionable.
1632 tm
.mday
= GetNumOfDaysInMonth(tm
.year
, tm
.mon
);
1635 tm
.AddDays(diff
.GetTotalDays());
1639 wxASSERT_MSG( IsSameTime(tm
),
1640 _T("Add(wxDateSpan) shouldn't modify time") );
1645 // ----------------------------------------------------------------------------
1646 // Weekday and monthday stuff
1647 // ----------------------------------------------------------------------------
1649 bool wxDateTime::SetToTheWeek(wxDateTime_t numWeek
,
1653 wxASSERT_MSG( numWeek
> 0,
1654 _T("invalid week number: weeks are counted from 1") );
1656 int year
= GetYear();
1658 // Jan 4 always lies in the 1st week of the year
1660 SetToWeekDayInSameWeek(weekday
, flags
) += wxDateSpan::Weeks(numWeek
- 1);
1662 if ( GetYear() != year
)
1664 // oops... numWeek was too big
1671 wxDateTime
& wxDateTime::SetToLastMonthDay(Month month
,
1674 // take the current month/year if none specified
1675 if ( year
== Inv_Year
)
1677 if ( month
== Inv_Month
)
1680 return Set(GetNumOfDaysInMonth(year
, month
), month
, year
);
1683 wxDateTime
& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday
, WeekFlags flags
)
1685 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
1687 int wdayThis
= GetWeekDay();
1688 if ( weekday
== wdayThis
)
1694 if ( flags
== Default_First
)
1696 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
1699 // the logic below based on comparing weekday and wdayThis works if Sun (0)
1700 // is the first day in the week, but breaks down for Monday_First case so
1701 // we adjust the week days in this case
1702 if( flags
== Monday_First
)
1704 if ( wdayThis
== Sun
)
1707 //else: Sunday_First, nothing to do
1709 // go forward or back in time to the day we want
1710 if ( weekday
< wdayThis
)
1712 return Subtract(wxDateSpan::Days(wdayThis
- weekday
));
1714 else // weekday > wdayThis
1716 return Add(wxDateSpan::Days(weekday
- wdayThis
));
1720 wxDateTime
& wxDateTime::SetToNextWeekDay(WeekDay weekday
)
1722 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
1725 WeekDay wdayThis
= GetWeekDay();
1726 if ( weekday
== wdayThis
)
1731 else if ( weekday
< wdayThis
)
1733 // need to advance a week
1734 diff
= 7 - (wdayThis
- weekday
);
1736 else // weekday > wdayThis
1738 diff
= weekday
- wdayThis
;
1741 return Add(wxDateSpan::Days(diff
));
1744 wxDateTime
& wxDateTime::SetToPrevWeekDay(WeekDay weekday
)
1746 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
1749 WeekDay wdayThis
= GetWeekDay();
1750 if ( weekday
== wdayThis
)
1755 else if ( weekday
> wdayThis
)
1757 // need to go to previous week
1758 diff
= 7 - (weekday
- wdayThis
);
1760 else // weekday < wdayThis
1762 diff
= wdayThis
- weekday
;
1765 return Subtract(wxDateSpan::Days(diff
));
1768 bool wxDateTime::SetToWeekDay(WeekDay weekday
,
1773 wxCHECK_MSG( weekday
!= Inv_WeekDay
, false, _T("invalid weekday") );
1775 // we don't check explicitly that -5 <= n <= 5 because we will return false
1776 // anyhow in such case - but may be should still give an assert for it?
1778 // take the current month/year if none specified
1779 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1783 // TODO this probably could be optimised somehow...
1787 // get the first day of the month
1788 dt
.Set(1, month
, year
);
1791 WeekDay wdayFirst
= dt
.GetWeekDay();
1793 // go to the first weekday of the month
1794 int diff
= weekday
- wdayFirst
;
1798 // add advance n-1 weeks more
1801 dt
+= wxDateSpan::Days(diff
);
1803 else // count from the end of the month
1805 // get the last day of the month
1806 dt
.SetToLastMonthDay(month
, year
);
1809 WeekDay wdayLast
= dt
.GetWeekDay();
1811 // go to the last weekday of the month
1812 int diff
= wdayLast
- weekday
;
1816 // and rewind n-1 weeks from there
1819 dt
-= wxDateSpan::Days(diff
);
1822 // check that it is still in the same month
1823 if ( dt
.GetMonth() == month
)
1831 // no such day in this month
1837 wxDateTime::wxDateTime_t
GetDayOfYearFromTm(const wxDateTime::Tm
& tm
)
1839 return gs_cumulatedDays
[wxDateTime::IsLeapYear(tm
.year
)][tm
.mon
] + tm
.mday
;
1842 wxDateTime::wxDateTime_t
wxDateTime::GetDayOfYear(const TimeZone
& tz
) const
1844 return GetDayOfYearFromTm(GetTm(tz
));
1847 // convert Sun, Mon, ..., Sat into 6, 0, ..., 5
1848 static inline int ConvertWeekDayToMondayBase(int wd
)
1850 return wd
== wxDateTime::Sun
? 6 : wd
- 1;
1853 wxDateTime::wxDateTime_t
1854 wxDateTime::GetWeekOfYear(wxDateTime::WeekFlags flags
, const TimeZone
& tz
) const
1856 if ( flags
== Default_First
)
1858 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
1862 wxDateTime_t nDayInYear
= GetDayOfYearFromTm(tm
);
1864 int wdTarget
= GetWeekDay(tz
);
1865 int wdYearStart
= wxDateTime(1, Jan
, GetYear()).GetWeekDay();
1867 if ( flags
== Sunday_First
)
1869 // FIXME: First week is not calculated correctly.
1870 week
= (nDayInYear
- wdTarget
+ 7) / 7;
1871 if ( wdYearStart
== Wed
|| wdYearStart
== Thu
)
1874 else // week starts with monday
1876 // adjust the weekdays to non-US style.
1877 wdYearStart
= ConvertWeekDayToMondayBase(wdYearStart
);
1878 wdTarget
= ConvertWeekDayToMondayBase(wdTarget
);
1880 // quoting from http://www.cl.cam.ac.uk/~mgk25/iso-time.html:
1882 // Week 01 of a year is per definition the first week that has the
1883 // Thursday in this year, which is equivalent to the week that
1884 // contains the fourth day of January. In other words, the first
1885 // week of a new year is the week that has the majority of its
1886 // days in the new year. Week 01 might also contain days from the
1887 // previous year and the week before week 01 of a year is the last
1888 // week (52 or 53) of the previous year even if it contains days
1889 // from the new year. A week starts with Monday (day 1) and ends
1890 // with Sunday (day 7).
1893 // if Jan 1 is Thursday or less, it is in the first week of this year
1894 if ( wdYearStart
< 4 )
1896 // count the number of entire weeks between Jan 1 and this date
1897 week
= (nDayInYear
+ wdYearStart
+ 6 - wdTarget
)/7;
1899 // be careful to check for overflow in the next year
1900 if ( week
== 53 && tm
.mday
- wdTarget
> 28 )
1903 else // Jan 1 is in the last week of the previous year
1905 // check if we happen to be at the last week of previous year:
1906 if ( tm
.mon
== Jan
&& tm
.mday
< 8 - wdYearStart
)
1907 week
= wxDateTime(31, Dec
, GetYear()-1).GetWeekOfYear();
1909 week
= (nDayInYear
+ wdYearStart
- 1 - wdTarget
)/7;
1916 wxDateTime::wxDateTime_t
wxDateTime::GetWeekOfMonth(wxDateTime::WeekFlags flags
,
1917 const TimeZone
& tz
) const
1920 wxDateTime dtMonthStart
= wxDateTime(1, tm
.mon
, tm
.year
);
1921 int nWeek
= GetWeekOfYear(flags
) - dtMonthStart
.GetWeekOfYear(flags
) + 1;
1924 // this may happen for January when Jan, 1 is the last week of the
1926 nWeek
+= IsLeapYear(tm
.year
- 1) ? 53 : 52;
1929 return (wxDateTime::wxDateTime_t
)nWeek
;
1932 wxDateTime
& wxDateTime::SetToYearDay(wxDateTime::wxDateTime_t yday
)
1934 int year
= GetYear();
1935 wxDATETIME_CHECK( (0 < yday
) && (yday
<= GetNumberOfDays(year
)),
1936 _T("invalid year day") );
1938 bool isLeap
= IsLeapYear(year
);
1939 for ( Month mon
= Jan
; mon
< Inv_Month
; wxNextMonth(mon
) )
1941 // for Dec, we can't compare with gs_cumulatedDays[mon + 1], but we
1942 // don't need it neither - because of the CHECK above we know that
1943 // yday lies in December then
1944 if ( (mon
== Dec
) || (yday
<= gs_cumulatedDays
[isLeap
][mon
+ 1]) )
1946 Set(yday
- gs_cumulatedDays
[isLeap
][mon
], mon
, year
);
1955 // ----------------------------------------------------------------------------
1956 // Julian day number conversion and related stuff
1957 // ----------------------------------------------------------------------------
1959 double wxDateTime::GetJulianDayNumber() const
1961 // JDN are always expressed for the UTC dates
1962 Tm
tm(ToTimezone(UTC
).GetTm(UTC
));
1964 double result
= GetTruncatedJDN(tm
.mday
, tm
.mon
, tm
.year
);
1966 // add the part GetTruncatedJDN() neglected
1969 // and now add the time: 86400 sec = 1 JDN
1970 return result
+ ((double)(60*(60*tm
.hour
+ tm
.min
) + tm
.sec
)) / 86400;
1973 double wxDateTime::GetRataDie() const
1975 // March 1 of the year 0 is Rata Die day -306 and JDN 1721119.5
1976 return GetJulianDayNumber() - 1721119.5 - 306;
1979 // ----------------------------------------------------------------------------
1980 // timezone and DST stuff
1981 // ----------------------------------------------------------------------------
1983 int wxDateTime::IsDST(wxDateTime::Country country
) const
1985 wxCHECK_MSG( country
== Country_Default
, -1,
1986 _T("country support not implemented") );
1988 // use the C RTL for the dates in the standard range
1989 time_t timet
= GetTicks();
1990 if ( timet
!= (time_t)-1 )
1992 tm
*tm
= localtime(&timet
);
1994 wxCHECK_MSG( tm
, -1, _T("localtime() failed") );
1996 return tm
->tm_isdst
;
2000 int year
= GetYear();
2002 if ( !IsDSTApplicable(year
, country
) )
2004 // no DST time in this year in this country
2008 return IsBetween(GetBeginDST(year
, country
), GetEndDST(year
, country
));
2012 wxDateTime
& wxDateTime::MakeTimezone(const TimeZone
& tz
, bool noDST
)
2014 long secDiff
= GetTimeZone() + tz
.GetOffset();
2016 // we need to know whether DST is or not in effect for this date unless
2017 // the test disabled by the caller
2018 if ( !noDST
&& (IsDST() == 1) )
2020 // FIXME we assume that the DST is always shifted by 1 hour
2024 return Subtract(wxTimeSpan::Seconds(secDiff
));
2027 // ----------------------------------------------------------------------------
2028 // wxDateTime to/from text representations
2029 // ----------------------------------------------------------------------------
2031 wxString
wxDateTime::Format(const wxChar
*format
, const TimeZone
& tz
) const
2033 wxCHECK_MSG( format
, _T(""), _T("NULL format in wxDateTime::Format") );
2035 // we have to use our own implementation if the date is out of range of
2036 // strftime() or if we use non standard specificators
2037 time_t time
= GetTicks();
2038 if ( (time
!= (time_t)-1) && !wxStrstr(format
, _T("%l")) )
2042 if ( tz
.GetOffset() == -GetTimeZone() )
2044 // we are working with local time
2045 tm
= localtime(&time
);
2047 // should never happen
2048 wxCHECK_MSG( tm
, wxEmptyString
, _T("localtime() failed") );
2052 time
+= (int)tz
.GetOffset();
2054 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
2055 int time2
= (int) time
;
2063 // should never happen
2064 wxCHECK_MSG( tm
, wxEmptyString
, _T("gmtime() failed") );
2068 tm
= (struct tm
*)NULL
;
2074 return CallStrftime(format
, tm
);
2076 //else: use generic code below
2079 // we only parse ANSI C format specifications here, no POSIX 2
2080 // complications, no GNU extensions but we do add support for a "%l" format
2081 // specifier allowing to get the number of milliseconds
2084 // used for calls to strftime() when we only deal with time
2085 struct tm tmTimeOnly
;
2086 tmTimeOnly
.tm_hour
= tm
.hour
;
2087 tmTimeOnly
.tm_min
= tm
.min
;
2088 tmTimeOnly
.tm_sec
= tm
.sec
;
2089 tmTimeOnly
.tm_wday
= 0;
2090 tmTimeOnly
.tm_yday
= 0;
2091 tmTimeOnly
.tm_mday
= 1; // any date will do
2092 tmTimeOnly
.tm_mon
= 0;
2093 tmTimeOnly
.tm_year
= 76;
2094 tmTimeOnly
.tm_isdst
= 0; // no DST, we adjust for tz ourselves
2096 wxString tmp
, res
, fmt
;
2097 for ( const wxChar
*p
= format
; *p
; p
++ )
2099 if ( *p
!= _T('%') )
2107 // set the default format
2110 case _T('Y'): // year has 4 digits
2114 case _T('j'): // day of year has 3 digits
2115 case _T('l'): // milliseconds have 3 digits
2119 case _T('w'): // week day as number has only one
2124 // it's either another valid format specifier in which case
2125 // the format is "%02d" (for all the rest) or we have the
2126 // field width preceding the format in which case it will
2127 // override the default format anyhow
2131 bool restart
= true;
2136 // start of the format specification
2139 case _T('a'): // a weekday name
2141 // second parameter should be true for abbreviated names
2142 res
+= GetWeekDayName(tm
.GetWeekDay(),
2143 *p
== _T('a') ? Name_Abbr
: Name_Full
);
2146 case _T('b'): // a month name
2148 res
+= GetMonthName(tm
.mon
,
2149 *p
== _T('b') ? Name_Abbr
: Name_Full
);
2152 case _T('c'): // locale default date and time representation
2153 case _T('x'): // locale default date representation
2155 // the problem: there is no way to know what do these format
2156 // specifications correspond to for the current locale.
2158 // the solution: use a hack and still use strftime(): first
2159 // find the YEAR which is a year in the strftime() range (1970
2160 // - 2038) whose Jan 1 falls on the same week day as the Jan 1
2161 // of the real year. Then make a copy of the format and
2162 // replace all occurences of YEAR in it with some unique
2163 // string not appearing anywhere else in it, then use
2164 // strftime() to format the date in year YEAR and then replace
2165 // YEAR back by the real year and the unique replacement
2166 // string back with YEAR. Notice that "all occurences of YEAR"
2167 // means all occurences of 4 digit as well as 2 digit form!
2169 // the bugs: we assume that neither of %c nor %x contains any
2170 // fields which may change between the YEAR and real year. For
2171 // example, the week number (%U, %W) and the day number (%j)
2172 // will change if one of these years is leap and the other one
2175 // find the YEAR: normally, for any year X, Jan 1 or the
2176 // year X + 28 is the same weekday as Jan 1 of X (because
2177 // the weekday advances by 1 for each normal X and by 2
2178 // for each leap X, hence by 5 every 4 years or by 35
2179 // which is 0 mod 7 every 28 years) but this rule breaks
2180 // down if there are years between X and Y which are
2181 // divisible by 4 but not leap (i.e. divisible by 100 but
2182 // not 400), hence the correction.
2184 int yearReal
= GetYear(tz
);
2185 int mod28
= yearReal
% 28;
2187 // be careful to not go too far - we risk to leave the
2192 year
= 1988 + mod28
; // 1988 == 0 (mod 28)
2196 year
= 1970 + mod28
- 10; // 1970 == 10 (mod 28)
2199 int nCentury
= year
/ 100,
2200 nCenturyReal
= yearReal
/ 100;
2202 // need to adjust for the years divisble by 400 which are
2203 // not leap but are counted like leap ones if we just take
2204 // the number of centuries in between for nLostWeekDays
2205 int nLostWeekDays
= (nCentury
- nCenturyReal
) -
2206 (nCentury
/ 4 - nCenturyReal
/ 4);
2208 // we have to gain back the "lost" weekdays: note that the
2209 // effect of this loop is to not do anything to
2210 // nLostWeekDays (which we won't use any more), but to
2211 // (indirectly) set the year correctly
2212 while ( (nLostWeekDays
% 7) != 0 )
2214 nLostWeekDays
+= year
++ % 4 ? 1 : 2;
2217 // at any rate, we couldn't go further than 1988 + 9 + 28!
2218 wxASSERT_MSG( year
< 2030,
2219 _T("logic error in wxDateTime::Format") );
2221 wxString strYear
, strYear2
;
2222 strYear
.Printf(_T("%d"), year
);
2223 strYear2
.Printf(_T("%d"), year
% 100);
2225 // find two strings not occuring in format (this is surely
2226 // not optimal way of doing it... improvements welcome!)
2227 wxString fmt
= format
;
2228 wxString replacement
= (wxChar
)-1;
2229 while ( fmt
.Find(replacement
) != wxNOT_FOUND
)
2231 replacement
<< (wxChar
)-1;
2234 wxString replacement2
= (wxChar
)-2;
2235 while ( fmt
.Find(replacement
) != wxNOT_FOUND
)
2237 replacement
<< (wxChar
)-2;
2240 // replace all occurences of year with it
2241 bool wasReplaced
= fmt
.Replace(strYear
, replacement
) > 0;
2243 wasReplaced
= fmt
.Replace(strYear2
, replacement2
) > 0;
2245 // use strftime() to format the same date but in supported
2248 // NB: we assume that strftime() doesn't check for the
2249 // date validity and will happily format the date
2250 // corresponding to Feb 29 of a non leap year (which
2251 // may happen if yearReal was leap and year is not)
2252 struct tm tmAdjusted
;
2254 tmAdjusted
.tm_hour
= tm
.hour
;
2255 tmAdjusted
.tm_min
= tm
.min
;
2256 tmAdjusted
.tm_sec
= tm
.sec
;
2257 tmAdjusted
.tm_wday
= tm
.GetWeekDay();
2258 tmAdjusted
.tm_yday
= GetDayOfYear();
2259 tmAdjusted
.tm_mday
= tm
.mday
;
2260 tmAdjusted
.tm_mon
= tm
.mon
;
2261 tmAdjusted
.tm_year
= year
- 1900;
2262 tmAdjusted
.tm_isdst
= 0; // no DST, already adjusted
2263 wxString str
= CallStrftime(*p
== _T('c') ? _T("%c")
2267 // now replace the occurence of 1999 with the real year
2268 wxString strYearReal
, strYearReal2
;
2269 strYearReal
.Printf(_T("%04d"), yearReal
);
2270 strYearReal2
.Printf(_T("%02d"), yearReal
% 100);
2271 str
.Replace(strYear
, strYearReal
);
2272 str
.Replace(strYear2
, strYearReal2
);
2274 // and replace back all occurences of replacement string
2277 str
.Replace(replacement2
, strYear2
);
2278 str
.Replace(replacement
, strYear
);
2285 case _T('d'): // day of a month (01-31)
2286 res
+= wxString::Format(fmt
, tm
.mday
);
2289 case _T('H'): // hour in 24h format (00-23)
2290 res
+= wxString::Format(fmt
, tm
.hour
);
2293 case _T('I'): // hour in 12h format (01-12)
2295 // 24h -> 12h, 0h -> 12h too
2296 int hour12
= tm
.hour
> 12 ? tm
.hour
- 12
2297 : tm
.hour
? tm
.hour
: 12;
2298 res
+= wxString::Format(fmt
, hour12
);
2302 case _T('j'): // day of the year
2303 res
+= wxString::Format(fmt
, GetDayOfYear(tz
));
2306 case _T('l'): // milliseconds (NOT STANDARD)
2307 res
+= wxString::Format(fmt
, GetMillisecond(tz
));
2310 case _T('m'): // month as a number (01-12)
2311 res
+= wxString::Format(fmt
, tm
.mon
+ 1);
2314 case _T('M'): // minute as a decimal number (00-59)
2315 res
+= wxString::Format(fmt
, tm
.min
);
2318 case _T('p'): // AM or PM string
2319 res
+= CallStrftime(_T("%p"), &tmTimeOnly
);
2322 case _T('S'): // second as a decimal number (00-61)
2323 res
+= wxString::Format(fmt
, tm
.sec
);
2326 case _T('U'): // week number in the year (Sunday 1st week day)
2327 res
+= wxString::Format(fmt
, GetWeekOfYear(Sunday_First
, tz
));
2330 case _T('W'): // week number in the year (Monday 1st week day)
2331 res
+= wxString::Format(fmt
, GetWeekOfYear(Monday_First
, tz
));
2334 case _T('w'): // weekday as a number (0-6), Sunday = 0
2335 res
+= wxString::Format(fmt
, tm
.GetWeekDay());
2338 // case _T('x'): -- handled with "%c"
2340 case _T('X'): // locale default time representation
2341 // just use strftime() to format the time for us
2342 res
+= CallStrftime(_T("%X"), &tmTimeOnly
);
2345 case _T('y'): // year without century (00-99)
2346 res
+= wxString::Format(fmt
, tm
.year
% 100);
2349 case _T('Y'): // year with century
2350 res
+= wxString::Format(fmt
, tm
.year
);
2353 case _T('Z'): // timezone name
2354 res
+= CallStrftime(_T("%Z"), &tmTimeOnly
);
2358 // is it the format width?
2360 while ( *p
== _T('-') || *p
== _T('+') ||
2361 *p
== _T(' ') || wxIsdigit(*p
) )
2366 if ( !fmt
.IsEmpty() )
2368 // we've only got the flags and width so far in fmt
2369 fmt
.Prepend(_T('%'));
2370 fmt
.Append(_T('d'));
2377 // no, it wasn't the width
2378 wxFAIL_MSG(_T("unknown format specificator"));
2380 // fall through and just copy it nevertheless
2382 case _T('%'): // a percent sign
2386 case 0: // the end of string
2387 wxFAIL_MSG(_T("missing format at the end of string"));
2389 // just put the '%' which was the last char in format
2399 // this function parses a string in (strict) RFC 822 format: see the section 5
2400 // of the RFC for the detailed description, but briefly it's something of the
2401 // form "Sat, 18 Dec 1999 00:48:30 +0100"
2403 // this function is "strict" by design - it must reject anything except true
2404 // RFC822 time specs.
2406 // TODO a great candidate for using reg exps
2407 const wxChar
*wxDateTime::ParseRfc822Date(const wxChar
* date
)
2409 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
2411 const wxChar
*p
= date
;
2412 const wxChar
*comma
= wxStrchr(p
, _T(','));
2415 // the part before comma is the weekday
2417 // skip it for now - we don't use but might check that it really
2418 // corresponds to the specfied date
2421 if ( *p
!= _T(' ') )
2423 wxLogDebug(_T("no space after weekday in RFC822 time spec"));
2425 return (wxChar
*)NULL
;
2431 // the following 1 or 2 digits are the day number
2432 if ( !wxIsdigit(*p
) )
2434 wxLogDebug(_T("day number expected in RFC822 time spec, none found"));
2436 return (wxChar
*)NULL
;
2439 wxDateTime_t day
= *p
++ - _T('0');
2440 if ( wxIsdigit(*p
) )
2443 day
+= *p
++ - _T('0');
2446 if ( *p
++ != _T(' ') )
2448 return (wxChar
*)NULL
;
2451 // the following 3 letters specify the month
2452 wxString
monName(p
, 3);
2454 if ( monName
== _T("Jan") )
2456 else if ( monName
== _T("Feb") )
2458 else if ( monName
== _T("Mar") )
2460 else if ( monName
== _T("Apr") )
2462 else if ( monName
== _T("May") )
2464 else if ( monName
== _T("Jun") )
2466 else if ( monName
== _T("Jul") )
2468 else if ( monName
== _T("Aug") )
2470 else if ( monName
== _T("Sep") )
2472 else if ( monName
== _T("Oct") )
2474 else if ( monName
== _T("Nov") )
2476 else if ( monName
== _T("Dec") )
2480 wxLogDebug(_T("Invalid RFC 822 month name '%s'"), monName
.c_str());
2482 return (wxChar
*)NULL
;
2487 if ( *p
++ != _T(' ') )
2489 return (wxChar
*)NULL
;
2493 if ( !wxIsdigit(*p
) )
2496 return (wxChar
*)NULL
;
2499 int year
= *p
++ - _T('0');
2501 if ( !wxIsdigit(*p
) )
2503 // should have at least 2 digits in the year
2504 return (wxChar
*)NULL
;
2508 year
+= *p
++ - _T('0');
2510 // is it a 2 digit year (as per original RFC 822) or a 4 digit one?
2511 if ( wxIsdigit(*p
) )
2514 year
+= *p
++ - _T('0');
2516 if ( !wxIsdigit(*p
) )
2518 // no 3 digit years please
2519 return (wxChar
*)NULL
;
2523 year
+= *p
++ - _T('0');
2526 if ( *p
++ != _T(' ') )
2528 return (wxChar
*)NULL
;
2531 // time is in the format hh:mm:ss and seconds are optional
2532 if ( !wxIsdigit(*p
) )
2534 return (wxChar
*)NULL
;
2537 wxDateTime_t hour
= *p
++ - _T('0');
2539 if ( !wxIsdigit(*p
) )
2541 return (wxChar
*)NULL
;
2545 hour
+= *p
++ - _T('0');
2547 if ( *p
++ != _T(':') )
2549 return (wxChar
*)NULL
;
2552 if ( !wxIsdigit(*p
) )
2554 return (wxChar
*)NULL
;
2557 wxDateTime_t min
= *p
++ - _T('0');
2559 if ( !wxIsdigit(*p
) )
2561 return (wxChar
*)NULL
;
2565 min
+= *p
++ - _T('0');
2567 wxDateTime_t sec
= 0;
2568 if ( *p
++ == _T(':') )
2570 if ( !wxIsdigit(*p
) )
2572 return (wxChar
*)NULL
;
2575 sec
= *p
++ - _T('0');
2577 if ( !wxIsdigit(*p
) )
2579 return (wxChar
*)NULL
;
2583 sec
+= *p
++ - _T('0');
2586 if ( *p
++ != _T(' ') )
2588 return (wxChar
*)NULL
;
2591 // and now the interesting part: the timezone
2593 if ( *p
== _T('-') || *p
== _T('+') )
2595 // the explicit offset given: it has the form of hhmm
2596 bool plus
= *p
++ == _T('+');
2598 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2600 return (wxChar
*)NULL
;
2604 offset
= 60*(10*(*p
- _T('0')) + (*(p
+ 1) - _T('0')));
2608 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2610 return (wxChar
*)NULL
;
2614 offset
+= 10*(*p
- _T('0')) + (*(p
+ 1) - _T('0'));
2625 // the symbolic timezone given: may be either military timezone or one
2626 // of standard abbreviations
2629 // military: Z = UTC, J unused, A = -1, ..., Y = +12
2630 static const int offsets
[26] =
2632 //A B C D E F G H I J K L M
2633 -1, -2, -3, -4, -5, -6, -7, -8, -9, 0, -10, -11, -12,
2634 //N O P R Q S T U V W Z Y Z
2635 +1, +2, +3, +4, +5, +6, +7, +8, +9, +10, +11, +12, 0
2638 if ( *p
< _T('A') || *p
> _T('Z') || *p
== _T('J') )
2640 wxLogDebug(_T("Invalid militaty timezone '%c'"), *p
);
2642 return (wxChar
*)NULL
;
2645 offset
= offsets
[*p
++ - _T('A')];
2651 if ( tz
== _T("UT") || tz
== _T("UTC") || tz
== _T("GMT") )
2653 else if ( tz
== _T("AST") )
2654 offset
= AST
- GMT0
;
2655 else if ( tz
== _T("ADT") )
2656 offset
= ADT
- GMT0
;
2657 else if ( tz
== _T("EST") )
2658 offset
= EST
- GMT0
;
2659 else if ( tz
== _T("EDT") )
2660 offset
= EDT
- GMT0
;
2661 else if ( tz
== _T("CST") )
2662 offset
= CST
- GMT0
;
2663 else if ( tz
== _T("CDT") )
2664 offset
= CDT
- GMT0
;
2665 else if ( tz
== _T("MST") )
2666 offset
= MST
- GMT0
;
2667 else if ( tz
== _T("MDT") )
2668 offset
= MDT
- GMT0
;
2669 else if ( tz
== _T("PST") )
2670 offset
= PST
- GMT0
;
2671 else if ( tz
== _T("PDT") )
2672 offset
= PDT
- GMT0
;
2675 wxLogDebug(_T("Unknown RFC 822 timezone '%s'"), p
);
2677 return (wxChar
*)NULL
;
2687 // the spec was correct
2688 Set(day
, mon
, year
, hour
, min
, sec
);
2689 MakeTimezone((wxDateTime_t
)(60*offset
));
2694 const wxChar
*wxDateTime::ParseFormat(const wxChar
*date
,
2695 const wxChar
*format
,
2696 const wxDateTime
& dateDef
)
2698 wxCHECK_MSG( date
&& format
, (wxChar
*)NULL
,
2699 _T("NULL pointer in wxDateTime::ParseFormat()") );
2704 // what fields have we found?
2705 bool haveWDay
= false,
2714 bool hourIsIn12hFormat
= false, // or in 24h one?
2715 isPM
= false; // AM by default
2717 // and the value of the items we have (init them to get rid of warnings)
2718 wxDateTime_t sec
= 0,
2721 WeekDay wday
= Inv_WeekDay
;
2722 wxDateTime_t yday
= 0,
2724 wxDateTime::Month mon
= Inv_Month
;
2727 const wxChar
*input
= date
;
2728 for ( const wxChar
*fmt
= format
; *fmt
; fmt
++ )
2730 if ( *fmt
!= _T('%') )
2732 if ( wxIsspace(*fmt
) )
2734 // a white space in the format string matches 0 or more white
2735 // spaces in the input
2736 while ( wxIsspace(*input
) )
2743 // any other character (not whitespace, not '%') must be
2744 // matched by itself in the input
2745 if ( *input
++ != *fmt
)
2748 return (wxChar
*)NULL
;
2752 // done with this format char
2756 // start of a format specification
2758 // parse the optional width
2760 while ( wxIsdigit(*++fmt
) )
2763 width
+= *fmt
- _T('0');
2766 // the default widths for the various fields
2771 case _T('Y'): // year has 4 digits
2775 case _T('j'): // day of year has 3 digits
2776 case _T('l'): // milliseconds have 3 digits
2780 case _T('w'): // week day as number has only one
2785 // default for all other fields
2790 // then the format itself
2793 case _T('a'): // a weekday name
2796 int flag
= *fmt
== _T('a') ? Name_Abbr
: Name_Full
;
2797 wday
= GetWeekDayFromName(GetAlphaToken(input
), flag
);
2798 if ( wday
== Inv_WeekDay
)
2801 return (wxChar
*)NULL
;
2807 case _T('b'): // a month name
2810 int flag
= *fmt
== _T('b') ? Name_Abbr
: Name_Full
;
2811 mon
= GetMonthFromName(GetAlphaToken(input
), flag
);
2812 if ( mon
== Inv_Month
)
2815 return (wxChar
*)NULL
;
2821 case _T('c'): // locale default date and time representation
2825 // this is the format which corresponds to ctime() output
2826 // and strptime("%c") should parse it, so try it first
2827 static const wxChar
*fmtCtime
= _T("%a %b %d %H:%M:%S %Y");
2829 const wxChar
*result
= dt
.ParseFormat(input
, fmtCtime
);
2832 result
= dt
.ParseFormat(input
, _T("%x %X"));
2837 result
= dt
.ParseFormat(input
, _T("%X %x"));
2842 // we've tried everything and still no match
2843 return (wxChar
*)NULL
;
2848 haveDay
= haveMon
= haveYear
=
2849 haveHour
= haveMin
= haveSec
= true;
2863 case _T('d'): // day of a month (01-31)
2864 if ( !GetNumericToken(width
, input
, &num
) ||
2865 (num
> 31) || (num
< 1) )
2868 return (wxChar
*)NULL
;
2871 // we can't check whether the day range is correct yet, will
2872 // do it later - assume ok for now
2874 mday
= (wxDateTime_t
)num
;
2877 case _T('H'): // hour in 24h format (00-23)
2878 if ( !GetNumericToken(width
, input
, &num
) || (num
> 23) )
2881 return (wxChar
*)NULL
;
2885 hour
= (wxDateTime_t
)num
;
2888 case _T('I'): // hour in 12h format (01-12)
2889 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 12) )
2892 return (wxChar
*)NULL
;
2896 hourIsIn12hFormat
= true;
2897 hour
= (wxDateTime_t
)(num
% 12); // 12 should be 0
2900 case _T('j'): // day of the year
2901 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 366) )
2904 return (wxChar
*)NULL
;
2908 yday
= (wxDateTime_t
)num
;
2911 case _T('m'): // month as a number (01-12)
2912 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 12) )
2915 return (wxChar
*)NULL
;
2919 mon
= (Month
)(num
- 1);
2922 case _T('M'): // minute as a decimal number (00-59)
2923 if ( !GetNumericToken(width
, input
, &num
) || (num
> 59) )
2926 return (wxChar
*)NULL
;
2930 min
= (wxDateTime_t
)num
;
2933 case _T('p'): // AM or PM string
2935 wxString am
, pm
, token
= GetAlphaToken(input
);
2937 GetAmPmStrings(&am
, &pm
);
2938 if (am
.IsEmpty() && pm
.IsEmpty())
2939 return (wxChar
*)NULL
; // no am/pm strings defined
2940 if ( token
.CmpNoCase(pm
) == 0 )
2944 else if ( token
.CmpNoCase(am
) != 0 )
2947 return (wxChar
*)NULL
;
2952 case _T('r'): // time as %I:%M:%S %p
2955 input
= dt
.ParseFormat(input
, _T("%I:%M:%S %p"));
2959 return (wxChar
*)NULL
;
2962 haveHour
= haveMin
= haveSec
= true;
2971 case _T('R'): // time as %H:%M
2974 input
= dt
.ParseFormat(input
, _T("%H:%M"));
2978 return (wxChar
*)NULL
;
2981 haveHour
= haveMin
= true;
2988 case _T('S'): // second as a decimal number (00-61)
2989 if ( !GetNumericToken(width
, input
, &num
) || (num
> 61) )
2992 return (wxChar
*)NULL
;
2996 sec
= (wxDateTime_t
)num
;
2999 case _T('T'): // time as %H:%M:%S
3002 input
= dt
.ParseFormat(input
, _T("%H:%M:%S"));
3006 return (wxChar
*)NULL
;
3009 haveHour
= haveMin
= haveSec
= true;
3018 case _T('w'): // weekday as a number (0-6), Sunday = 0
3019 if ( !GetNumericToken(width
, input
, &num
) || (wday
> 6) )
3022 return (wxChar
*)NULL
;
3026 wday
= (WeekDay
)num
;
3029 case _T('x'): // locale default date representation
3030 #ifdef HAVE_STRPTIME
3031 // try using strptime() -- it may fail even if the input is
3032 // correct but the date is out of range, so we will fall back
3033 // to our generic code anyhow
3037 const wxChar
*result
= CallStrptime(input
, "%x", &tm
);
3042 haveDay
= haveMon
= haveYear
= true;
3044 year
= 1900 + tm
.tm_year
;
3045 mon
= (Month
)tm
.tm_mon
;
3051 #endif // HAVE_STRPTIME
3053 // TODO query the LOCALE_IDATE setting under Win32
3057 wxString fmtDate
, fmtDateAlt
;
3058 if ( IsWestEuropeanCountry(GetCountry()) ||
3059 GetCountry() == Russia
)
3061 fmtDate
= _T("%d/%m/%y");
3062 fmtDateAlt
= _T("%m/%d/%y");
3066 fmtDate
= _T("%m/%d/%y");
3067 fmtDateAlt
= _T("%d/%m/%y");
3070 const wxChar
*result
= dt
.ParseFormat(input
, fmtDate
);
3074 // ok, be nice and try another one
3075 result
= dt
.ParseFormat(input
, fmtDateAlt
);
3081 return (wxChar
*)NULL
;
3086 haveDay
= haveMon
= haveYear
= true;
3097 case _T('X'): // locale default time representation
3098 #ifdef HAVE_STRPTIME
3100 // use strptime() to do it for us (FIXME !Unicode friendly)
3102 input
= CallStrptime(input
, "%X", &tm
);
3105 return (wxChar
*)NULL
;
3108 haveHour
= haveMin
= haveSec
= true;
3114 #else // !HAVE_STRPTIME
3115 // TODO under Win32 we can query the LOCALE_ITIME system
3116 // setting which says whether the default time format is
3119 // try to parse what follows as "%H:%M:%S" and, if this
3120 // fails, as "%I:%M:%S %p" - this should catch the most
3124 const wxChar
*result
= dt
.ParseFormat(input
, _T("%T"));
3127 result
= dt
.ParseFormat(input
, _T("%r"));
3133 return (wxChar
*)NULL
;
3136 haveHour
= haveMin
= haveSec
= true;
3145 #endif // HAVE_STRPTIME/!HAVE_STRPTIME
3148 case _T('y'): // year without century (00-99)
3149 if ( !GetNumericToken(width
, input
, &num
) || (num
> 99) )
3152 return (wxChar
*)NULL
;
3157 // TODO should have an option for roll over date instead of
3158 // hard coding it here
3159 year
= (num
> 30 ? 1900 : 2000) + (wxDateTime_t
)num
;
3162 case _T('Y'): // year with century
3163 if ( !GetNumericToken(width
, input
, &num
) )
3166 return (wxChar
*)NULL
;
3170 year
= (wxDateTime_t
)num
;
3173 case _T('Z'): // timezone name
3174 wxFAIL_MSG(_T("TODO"));
3177 case _T('%'): // a percent sign
3178 if ( *input
++ != _T('%') )
3181 return (wxChar
*)NULL
;
3185 case 0: // the end of string
3186 wxFAIL_MSG(_T("unexpected format end"));
3190 default: // not a known format spec
3191 return (wxChar
*)NULL
;
3195 // format matched, try to construct a date from what we have now
3197 if ( dateDef
.IsValid() )
3199 // take this date as default
3200 tmDef
= dateDef
.GetTm();
3202 else if ( IsValid() )
3204 // if this date is valid, don't change it
3209 // no default and this date is invalid - fall back to Today()
3210 tmDef
= Today().GetTm();
3221 // TODO we don't check here that the values are consistent, if both year
3222 // day and month/day were found, we just ignore the year day and we
3223 // also always ignore the week day
3224 if ( haveMon
&& haveDay
)
3226 if ( mday
> GetNumOfDaysInMonth(tm
.year
, mon
) )
3228 wxLogDebug(_T("bad month day in wxDateTime::ParseFormat"));
3230 return (wxChar
*)NULL
;
3236 else if ( haveYDay
)
3238 if ( yday
> GetNumberOfDays(tm
.year
) )
3240 wxLogDebug(_T("bad year day in wxDateTime::ParseFormat"));
3242 return (wxChar
*)NULL
;
3245 Tm tm2
= wxDateTime(1, Jan
, tm
.year
).SetToYearDay(yday
).GetTm();
3252 if ( haveHour
&& hourIsIn12hFormat
&& isPM
)
3254 // translate to 24hour format
3257 //else: either already in 24h format or no translation needed
3277 // finally check that the week day is consistent -- if we had it
3278 if ( haveWDay
&& GetWeekDay() != wday
)
3280 wxLogDebug(_T("inconsistsnet week day in wxDateTime::ParseFormat()"));
3288 const wxChar
*wxDateTime::ParseDateTime(const wxChar
*date
)
3290 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3292 // Set to current day and hour, so strings like '14:00' becomes today at
3293 // 14, not some other random date
3294 wxDateTime dtDate
= wxDateTime::Today();
3295 wxDateTime dtTime
= wxDateTime::Today();
3297 const wxChar
* pchTime
;
3299 // Try to parse the beginning of the string as a date
3300 const wxChar
* pchDate
= dtDate
.ParseDate(date
);
3302 // We got a date in the beginning, see if there is a time specified after the date
3305 // Skip spaces, as the ParseTime() function fails on spaces
3306 while ( wxIsspace(*pchDate
) )
3309 pchTime
= dtTime
.ParseTime(pchDate
);
3311 else // no date in the beginning
3313 // check and see if we have a time followed by a date
3314 pchTime
= dtTime
.ParseTime(date
);
3317 while ( wxIsspace(*pchTime
) )
3320 pchDate
= dtDate
.ParseDate(pchTime
);
3324 // If we have a date specified, set our own data to the same date
3325 if ( !pchDate
|| !pchTime
)
3328 Set(dtDate
.GetDay(), dtDate
.GetMonth(), dtDate
.GetYear(),
3329 dtTime
.GetHour(), dtTime
.GetMinute(), dtTime
.GetSecond(),
3330 dtTime
.GetMillisecond());
3332 // Return endpoint of scan
3333 return pchDate
> pchTime
? pchDate
: pchTime
;
3336 const wxChar
*wxDateTime::ParseDate(const wxChar
*date
)
3338 // this is a simplified version of ParseDateTime() which understands only
3339 // "today" (for wxDate compatibility) and digits only otherwise (and not
3340 // all esoteric constructions ParseDateTime() knows about)
3342 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3344 const wxChar
*p
= date
;
3345 while ( wxIsspace(*p
) )
3348 // some special cases
3352 int dayDiffFromToday
;
3355 { wxTRANSLATE("today"), 0 },
3356 { wxTRANSLATE("yesterday"), -1 },
3357 { wxTRANSLATE("tomorrow"), 1 },
3360 for ( size_t n
= 0; n
< WXSIZEOF(literalDates
); n
++ )
3362 wxString date
= wxGetTranslation(literalDates
[n
].str
);
3363 size_t len
= date
.length();
3364 if ( wxStrlen(p
) >= len
&& (wxString(p
, len
).CmpNoCase(date
) == 0) )
3366 // nothing can follow this, so stop here
3369 int dayDiffFromToday
= literalDates
[n
].dayDiffFromToday
;
3371 if ( dayDiffFromToday
)
3373 *this += wxDateSpan::Days(dayDiffFromToday
);
3380 // We try to guess what we have here: for each new (numeric) token, we
3381 // determine if it can be a month, day or a year. Of course, there is an
3382 // ambiguity as some numbers may be days as well as months, so we also
3383 // have the ability to back track.
3386 bool haveDay
= false, // the months day?
3387 haveWDay
= false, // the day of week?
3388 haveMon
= false, // the month?
3389 haveYear
= false; // the year?
3391 // and the value of the items we have (init them to get rid of warnings)
3392 WeekDay wday
= Inv_WeekDay
;
3393 wxDateTime_t day
= 0;
3394 wxDateTime::Month mon
= Inv_Month
;
3397 // tokenize the string
3399 static const wxChar
*dateDelimiters
= _T(".,/-\t\r\n ");
3400 wxStringTokenizer
tok(p
, dateDelimiters
);
3401 while ( tok
.HasMoreTokens() )
3403 wxString token
= tok
.GetNextToken();
3409 if ( token
.ToULong(&val
) )
3411 // guess what this number is
3417 if ( !haveMon
&& val
> 0 && val
<= 12 )
3419 // assume it is month
3422 else // not the month
3426 // this can only be the year
3429 else // may be either day or year
3431 wxDateTime_t maxDays
= haveMon
3432 ? GetNumOfDaysInMonth(haveYear
? year
: Inv_Year
, mon
)
3436 if ( (val
== 0) || (val
> (unsigned long)maxDays
) )
3441 else // yes, suppose it's the day
3455 year
= (wxDateTime_t
)val
;
3464 day
= (wxDateTime_t
)val
;
3470 mon
= (Month
)(val
- 1);
3473 else // not a number
3475 // be careful not to overwrite the current mon value
3476 Month mon2
= GetMonthFromName(token
, Name_Full
| Name_Abbr
);
3477 if ( mon2
!= Inv_Month
)
3482 // but we already have a month - maybe we guessed wrong?
3485 // no need to check in month range as always < 12, but
3486 // the days are counted from 1 unlike the months
3487 day
= (wxDateTime_t
)mon
+ 1;
3492 // could possible be the year (doesn't the year come
3493 // before the month in the japanese format?) (FIXME)
3502 else // not a valid month name
3504 wday
= GetWeekDayFromName(token
, Name_Full
| Name_Abbr
);
3505 if ( wday
!= Inv_WeekDay
)
3515 else // not a valid weekday name
3518 static const wxChar
*ordinals
[] =
3520 wxTRANSLATE("first"),
3521 wxTRANSLATE("second"),
3522 wxTRANSLATE("third"),
3523 wxTRANSLATE("fourth"),
3524 wxTRANSLATE("fifth"),
3525 wxTRANSLATE("sixth"),
3526 wxTRANSLATE("seventh"),
3527 wxTRANSLATE("eighth"),
3528 wxTRANSLATE("ninth"),
3529 wxTRANSLATE("tenth"),
3530 wxTRANSLATE("eleventh"),
3531 wxTRANSLATE("twelfth"),
3532 wxTRANSLATE("thirteenth"),
3533 wxTRANSLATE("fourteenth"),
3534 wxTRANSLATE("fifteenth"),
3535 wxTRANSLATE("sixteenth"),
3536 wxTRANSLATE("seventeenth"),
3537 wxTRANSLATE("eighteenth"),
3538 wxTRANSLATE("nineteenth"),
3539 wxTRANSLATE("twentieth"),
3540 // that's enough - otherwise we'd have problems with
3541 // composite (or not) ordinals
3545 for ( n
= 0; n
< WXSIZEOF(ordinals
); n
++ )
3547 if ( token
.CmpNoCase(ordinals
[n
]) == 0 )
3553 if ( n
== WXSIZEOF(ordinals
) )
3555 // stop here - something unknown
3562 // don't try anything here (as in case of numeric day
3563 // above) - the symbolic day spec should always
3564 // precede the month/year
3570 day
= (wxDateTime_t
)(n
+ 1);
3575 nPosCur
= tok
.GetPosition();
3578 // either no more tokens or the scan was stopped by something we couldn't
3579 // parse - in any case, see if we can construct a date from what we have
3580 if ( !haveDay
&& !haveWDay
)
3582 wxLogDebug(_T("ParseDate: no day, no weekday hence no date."));
3584 return (wxChar
*)NULL
;
3587 if ( haveWDay
&& (haveMon
|| haveYear
|| haveDay
) &&
3588 !(haveDay
&& haveMon
&& haveYear
) )
3590 // without adjectives (which we don't support here) the week day only
3591 // makes sense completely separately or with the full date
3592 // specification (what would "Wed 1999" mean?)
3593 return (wxChar
*)NULL
;
3596 if ( !haveWDay
&& haveYear
&& !(haveDay
&& haveMon
) )
3598 // may be we have month and day instead of day and year?
3599 if ( haveDay
&& !haveMon
)
3603 // exchange day and month
3604 mon
= (wxDateTime::Month
)(day
- 1);
3606 // we're in the current year then
3607 if ( (year
> 0) && (year
<= (int)GetNumOfDaysInMonth(Inv_Year
, mon
)) )
3614 //else: no, can't exchange, leave haveMon == false
3620 // if we give the year, month and day must be given too
3621 wxLogDebug(_T("ParseDate: day and month should be specified if year is."));
3623 return (wxChar
*)NULL
;
3629 mon
= GetCurrentMonth();
3634 year
= GetCurrentYear();
3639 Set(day
, mon
, year
);
3643 // check that it is really the same
3644 if ( GetWeekDay() != wday
)
3646 // inconsistency detected
3647 wxLogDebug(_T("ParseDate: inconsistent day/weekday."));
3649 return (wxChar
*)NULL
;
3657 SetToWeekDayInSameWeek(wday
);
3660 // return the pointer to the first unparsed char
3662 if ( nPosCur
&& wxStrchr(dateDelimiters
, *(p
- 1)) )
3664 // if we couldn't parse the token after the delimiter, put back the
3665 // delimiter as well
3672 const wxChar
*wxDateTime::ParseTime(const wxChar
*time
)
3674 wxCHECK_MSG( time
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3676 // first try some extra things
3683 { wxTRANSLATE("noon"), 12 },
3684 { wxTRANSLATE("midnight"), 00 },
3688 for ( size_t n
= 0; n
< WXSIZEOF(stdTimes
); n
++ )
3690 wxString timeString
= wxGetTranslation(stdTimes
[n
].name
);
3691 size_t len
= timeString
.length();
3692 if ( timeString
.CmpNoCase(wxString(time
, len
)) == 0 )
3694 // casts required by DigitalMars
3695 Set(stdTimes
[n
].hour
, wxDateTime_t(0), wxDateTime_t(0));
3701 // try all time formats we may think about in the order from longest to
3704 // 12hour with AM/PM?
3705 const wxChar
*result
= ParseFormat(time
, _T("%I:%M:%S %p"));
3709 // normally, it's the same, but why not try it?
3710 result
= ParseFormat(time
, _T("%H:%M:%S"));
3715 // 12hour with AM/PM but without seconds?
3716 result
= ParseFormat(time
, _T("%I:%M %p"));
3722 result
= ParseFormat(time
, _T("%H:%M"));
3727 // just the hour and AM/PM?
3728 result
= ParseFormat(time
, _T("%I %p"));
3734 result
= ParseFormat(time
, _T("%H"));
3739 // parse the standard format: normally it is one of the formats above
3740 // but it may be set to something completely different by the user
3741 result
= ParseFormat(time
, _T("%X"));
3744 // TODO: parse timezones
3749 // ----------------------------------------------------------------------------
3750 // Workdays and holidays support
3751 // ----------------------------------------------------------------------------
3753 bool wxDateTime::IsWorkDay(Country
WXUNUSED(country
)) const
3755 return !wxDateTimeHolidayAuthority::IsHoliday(*this);
3758 // ============================================================================
3760 // ============================================================================
3762 // this enum is only used in wxTimeSpan::Format() below but we can't declare
3763 // it locally to the method as it provokes an internal compiler error in egcs
3764 // 2.91.60 when building with -O2
3775 // not all strftime(3) format specifiers make sense here because, for example,
3776 // a time span doesn't have a year nor a timezone
3778 // Here are the ones which are supported (all of them are supported by strftime
3780 // %H hour in 24 hour format
3781 // %M minute (00 - 59)
3782 // %S second (00 - 59)
3785 // Also, for MFC CTimeSpan compatibility, we support
3786 // %D number of days
3788 // And, to be better than MFC :-), we also have
3789 // %E number of wEeks
3790 // %l milliseconds (000 - 999)
3791 wxString
wxTimeSpan::Format(const wxChar
*format
) const
3793 wxCHECK_MSG( format
, _T(""), _T("NULL format in wxTimeSpan::Format") );
3796 str
.Alloc(wxStrlen(format
));
3798 // Suppose we have wxTimeSpan ts(1 /* hour */, 2 /* min */, 3 /* sec */)
3800 // Then, of course, ts.Format("%H:%M:%S") must return "01:02:03", but the
3801 // question is what should ts.Format("%S") do? The code here returns "3273"
3802 // in this case (i.e. the total number of seconds, not just seconds % 60)
3803 // because, for me, this call means "give me entire time interval in
3804 // seconds" and not "give me the seconds part of the time interval"
3806 // If we agree that it should behave like this, it is clear that the
3807 // interpretation of each format specifier depends on the presence of the
3808 // other format specs in the string: if there was "%H" before "%M", we
3809 // should use GetMinutes() % 60, otherwise just GetMinutes() &c
3811 // we remember the most important unit found so far
3812 TimeSpanPart partBiggest
= Part_MSec
;
3814 for ( const wxChar
*pch
= format
; *pch
; pch
++ )
3818 if ( ch
== _T('%') )
3820 // the start of the format specification of the printf() below
3821 wxString fmtPrefix
= _T('%');
3826 ch
= *++pch
; // get the format spec char
3830 wxFAIL_MSG( _T("invalid format character") );
3836 // skip the part below switch
3841 if ( partBiggest
< Part_Day
)
3847 partBiggest
= Part_Day
;
3852 partBiggest
= Part_Week
;
3858 if ( partBiggest
< Part_Hour
)
3864 partBiggest
= Part_Hour
;
3867 fmtPrefix
+= _T("02");
3871 n
= GetMilliseconds().ToLong();
3872 if ( partBiggest
< Part_MSec
)
3876 //else: no need to reset partBiggest to Part_MSec, it is
3877 // the least significant one anyhow
3879 fmtPrefix
+= _T("03");
3884 if ( partBiggest
< Part_Min
)
3890 partBiggest
= Part_Min
;
3893 fmtPrefix
+= _T("02");
3897 n
= GetSeconds().ToLong();
3898 if ( partBiggest
< Part_Sec
)
3904 partBiggest
= Part_Sec
;
3907 fmtPrefix
+= _T("02");
3911 str
+= wxString::Format(fmtPrefix
+ _T("ld"), n
);
3915 // normal character, just copy
3923 // ============================================================================
3924 // wxDateTimeHolidayAuthority and related classes
3925 // ============================================================================
3927 #include "wx/arrimpl.cpp"
3929 WX_DEFINE_OBJARRAY(wxDateTimeArray
);
3931 static int wxCMPFUNC_CONV
3932 wxDateTimeCompareFunc(wxDateTime
**first
, wxDateTime
**second
)
3934 wxDateTime dt1
= **first
,
3937 return dt1
== dt2
? 0 : dt1
< dt2
? -1 : +1;
3940 // ----------------------------------------------------------------------------
3941 // wxDateTimeHolidayAuthority
3942 // ----------------------------------------------------------------------------
3944 wxHolidayAuthoritiesArray
wxDateTimeHolidayAuthority::ms_authorities
;
3947 bool wxDateTimeHolidayAuthority::IsHoliday(const wxDateTime
& dt
)
3949 size_t count
= ms_authorities
.size();
3950 for ( size_t n
= 0; n
< count
; n
++ )
3952 if ( ms_authorities
[n
]->DoIsHoliday(dt
) )
3963 wxDateTimeHolidayAuthority::GetHolidaysInRange(const wxDateTime
& dtStart
,
3964 const wxDateTime
& dtEnd
,
3965 wxDateTimeArray
& holidays
)
3967 wxDateTimeArray hol
;
3971 size_t count
= ms_authorities
.size();
3972 for ( size_t nAuth
= 0; nAuth
< count
; nAuth
++ )
3974 ms_authorities
[nAuth
]->DoGetHolidaysInRange(dtStart
, dtEnd
, hol
);
3976 WX_APPEND_ARRAY(holidays
, hol
);
3979 holidays
.Sort(wxDateTimeCompareFunc
);
3981 return holidays
.size();
3985 void wxDateTimeHolidayAuthority::ClearAllAuthorities()
3987 WX_CLEAR_ARRAY(ms_authorities
);
3991 void wxDateTimeHolidayAuthority::AddAuthority(wxDateTimeHolidayAuthority
*auth
)
3993 ms_authorities
.push_back(auth
);
3996 wxDateTimeHolidayAuthority::~wxDateTimeHolidayAuthority()
3998 // nothing to do here
4001 // ----------------------------------------------------------------------------
4002 // wxDateTimeWorkDays
4003 // ----------------------------------------------------------------------------
4005 bool wxDateTimeWorkDays::DoIsHoliday(const wxDateTime
& dt
) const
4007 wxDateTime::WeekDay wd
= dt
.GetWeekDay();
4009 return (wd
== wxDateTime::Sun
) || (wd
== wxDateTime::Sat
);
4012 size_t wxDateTimeWorkDays::DoGetHolidaysInRange(const wxDateTime
& dtStart
,
4013 const wxDateTime
& dtEnd
,
4014 wxDateTimeArray
& holidays
) const
4016 if ( dtStart
> dtEnd
)
4018 wxFAIL_MSG( _T("invalid date range in GetHolidaysInRange") );
4025 // instead of checking all days, start with the first Sat after dtStart and
4026 // end with the last Sun before dtEnd
4027 wxDateTime dtSatFirst
= dtStart
.GetNextWeekDay(wxDateTime::Sat
),
4028 dtSatLast
= dtEnd
.GetPrevWeekDay(wxDateTime::Sat
),
4029 dtSunFirst
= dtStart
.GetNextWeekDay(wxDateTime::Sun
),
4030 dtSunLast
= dtEnd
.GetPrevWeekDay(wxDateTime::Sun
),
4033 for ( dt
= dtSatFirst
; dt
<= dtSatLast
; dt
+= wxDateSpan::Week() )
4038 for ( dt
= dtSunFirst
; dt
<= dtSunLast
; dt
+= wxDateSpan::Week() )
4043 return holidays
.GetCount();
4046 #endif // wxUSE_DATETIME