1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/datetime.cpp
3 // Purpose: implementation of time/date related classes
4 // (for formatting&parsing see datetimefmt.cpp)
5 // Author: Vadim Zeitlin
9 // Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
10 // parts of code taken from sndcal library by Scott E. Lee:
12 // Copyright 1993-1995, Scott E. Lee, all rights reserved.
13 // Permission granted to use, copy, modify, distribute and sell
14 // so long as the above copyright and this permission statement
15 // are retained in all copies.
17 // Licence: wxWindows licence
18 ///////////////////////////////////////////////////////////////////////////////
21 * Implementation notes:
23 * 1. the time is stored as a 64bit integer containing the signed number of
24 * milliseconds since Jan 1. 1970 (the Unix Epoch) - so it is always
27 * 2. the range is thus something about 580 million years, but due to current
28 * algorithms limitations, only dates from Nov 24, 4714BC are handled
30 * 3. standard ANSI C functions are used to do time calculations whenever
31 * possible, i.e. when the date is in the range Jan 1, 1970 to 2038
33 * 4. otherwise, the calculations are done by converting the date to/from JDN
34 * first (the range limitation mentioned above comes from here: the
35 * algorithm used by Scott E. Lee's code only works for positive JDNs, more
38 * 5. the object constructed for the given DD-MM-YYYY HH:MM:SS corresponds to
39 * this moment in local time and may be converted to the object
40 * corresponding to the same date/time in another time zone by using
43 * 6. the conversions to the current (or any other) timezone are done when the
44 * internal time representation is converted to the broken-down one in
48 // ============================================================================
50 // ============================================================================
52 // ----------------------------------------------------------------------------
54 // ----------------------------------------------------------------------------
56 // For compilers that support precompilation, includes "wx.h".
57 #include "wx/wxprec.h"
63 #if !defined(wxUSE_DATETIME) || wxUSE_DATETIME
67 #include "wx/msw/wrapwin.h"
69 #include "wx/string.h"
72 #include "wx/stopwatch.h" // for wxGetLocalTimeMillis()
73 #include "wx/module.h"
77 #include "wx/thread.h"
78 #include "wx/tokenzr.h"
89 #include "wx/datetime.h"
91 // ----------------------------------------------------------------------------
93 // ----------------------------------------------------------------------------
95 #if wxUSE_EXTENDED_RTTI
97 template<> void wxStringReadValue(const wxString
&s
, wxDateTime
&data
)
99 data
.ParseFormat(s
,"%Y-%m-%d %H:%M:%S", NULL
);
102 template<> void wxStringWriteValue(wxString
&s
, const wxDateTime
&data
)
104 s
= data
.Format("%Y-%m-%d %H:%M:%S");
107 wxCUSTOM_TYPE_INFO(wxDateTime
, wxToStringConverter
<wxDateTime
> , wxFromStringConverter
<wxDateTime
>)
109 #endif // wxUSE_EXTENDED_RTTI
112 // ----------------------------------------------------------------------------
113 // conditional compilation
114 // ----------------------------------------------------------------------------
116 #if defined(__MWERKS__) && wxUSE_UNICODE
120 #if defined(__DJGPP__) || defined(__WINE__)
121 #include <sys/timeb.h>
125 #ifndef WX_GMTOFF_IN_TM
126 // Define it for some systems which don't (always) use configure but are
127 // known to have tm_gmtoff field.
128 #if defined(__WXPALMOS__) || defined(__DARWIN__)
129 #define WX_GMTOFF_IN_TM
133 // NB: VC8 safe time functions could/should be used for wxMSW as well probably
134 #if defined(__WXWINCE__) && defined(__VISUALC8__)
136 struct tm
*wxLocaltime_r(const time_t *t
, struct tm
* tm
)
139 return _localtime64_s(tm
, &t64
) == 0 ? tm
: NULL
;
142 struct tm
*wxGmtime_r(const time_t* t
, struct tm
* tm
)
145 return _gmtime64_s(tm
, &t64
) == 0 ? tm
: NULL
;
148 #else // !wxWinCE with VC8
150 #if (!defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)) && wxUSE_THREADS && !defined(__WINDOWS__)
151 static wxMutex timeLock
;
154 #ifndef HAVE_LOCALTIME_R
155 struct tm
*wxLocaltime_r(const time_t* ticks
, struct tm
* temp
)
157 #if wxUSE_THREADS && !defined(__WINDOWS__)
158 // No need to waste time with a mutex on windows since it's using
159 // thread local storage for localtime anyway.
160 wxMutexLocker
locker(timeLock
);
163 // Borland CRT crashes when passed 0 ticks for some reason, see SF bug 1704438
169 const tm
* const t
= localtime(ticks
);
173 memcpy(temp
, t
, sizeof(struct tm
));
176 #endif // !HAVE_LOCALTIME_R
178 #ifndef HAVE_GMTIME_R
179 struct tm
*wxGmtime_r(const time_t* ticks
, struct tm
* temp
)
181 #if wxUSE_THREADS && !defined(__WINDOWS__)
182 // No need to waste time with a mutex on windows since it's
183 // using thread local storage for gmtime anyway.
184 wxMutexLocker
locker(timeLock
);
192 const tm
* const t
= gmtime(ticks
);
196 memcpy(temp
, gmtime(ticks
), sizeof(struct tm
));
199 #endif // !HAVE_GMTIME_R
201 #endif // wxWinCE with VC8/other platforms
203 // ----------------------------------------------------------------------------
205 // ----------------------------------------------------------------------------
207 // debugging helper: just a convenient replacement of wxCHECK()
208 #define wxDATETIME_CHECK(expr, msg) \
209 wxCHECK2_MSG(expr, *this = wxInvalidDateTime; return *this, msg)
211 // ----------------------------------------------------------------------------
213 // ----------------------------------------------------------------------------
215 class wxDateTimeHolidaysModule
: public wxModule
218 virtual bool OnInit()
220 wxDateTimeHolidayAuthority::AddAuthority(new wxDateTimeWorkDays
);
225 virtual void OnExit()
227 wxDateTimeHolidayAuthority::ClearAllAuthorities();
228 wxDateTimeHolidayAuthority::ms_authorities
.clear();
232 DECLARE_DYNAMIC_CLASS(wxDateTimeHolidaysModule
)
235 IMPLEMENT_DYNAMIC_CLASS(wxDateTimeHolidaysModule
, wxModule
)
237 // ----------------------------------------------------------------------------
239 // ----------------------------------------------------------------------------
242 static const int MONTHS_IN_YEAR
= 12;
244 static const int SEC_PER_MIN
= 60;
246 static const int MIN_PER_HOUR
= 60;
248 static const long SECONDS_PER_DAY
= 86400l;
250 static const int DAYS_PER_WEEK
= 7;
252 static const long MILLISECONDS_PER_DAY
= 86400000l;
254 // this is the integral part of JDN of the midnight of Jan 1, 1970
255 // (i.e. JDN(Jan 1, 1970) = 2440587.5)
256 static const long EPOCH_JDN
= 2440587l;
258 // these values are only used in asserts so don't define them if asserts are
259 // disabled to avoid warnings about unused static variables
261 // the date of JDN -0.5 (as we don't work with fractional parts, this is the
262 // reference date for us) is Nov 24, 4714BC
263 static const int JDN_0_YEAR
= -4713;
264 static const int JDN_0_MONTH
= wxDateTime::Nov
;
265 static const int JDN_0_DAY
= 24;
266 #endif // wxDEBUG_LEVEL
268 // the constants used for JDN calculations
269 static const long JDN_OFFSET
= 32046l;
270 static const long DAYS_PER_5_MONTHS
= 153l;
271 static const long DAYS_PER_4_YEARS
= 1461l;
272 static const long DAYS_PER_400_YEARS
= 146097l;
274 // this array contains the cumulated number of days in all previous months for
275 // normal and leap years
276 static const wxDateTime::wxDateTime_t gs_cumulatedDays
[2][MONTHS_IN_YEAR
] =
278 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
279 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
282 const long wxDateTime::TIME_T_FACTOR
= 1000l;
284 // ----------------------------------------------------------------------------
286 // ----------------------------------------------------------------------------
288 const char wxDefaultDateTimeFormat
[] = "%c";
289 const char wxDefaultTimeSpanFormat
[] = "%H:%M:%S";
291 // in the fine tradition of ANSI C we use our equivalent of (time_t)-1 to
292 // indicate an invalid wxDateTime object
293 const wxDateTime wxDefaultDateTime
;
295 wxDateTime::Country
wxDateTime::ms_country
= wxDateTime::Country_Unknown
;
297 // ----------------------------------------------------------------------------
299 // ----------------------------------------------------------------------------
301 // debugger helper: this function can be called from a debugger to show what
302 // the date really is
303 extern const char *wxDumpDate(const wxDateTime
* dt
)
305 static char buf
[128];
307 wxString
fmt(dt
->Format("%Y-%m-%d (%a) %H:%M:%S"));
309 (fmt
+ " (" + dt
->GetValue().ToString() + " ticks)").ToAscii(),
315 // get the number of days in the given month of the given year
317 wxDateTime::wxDateTime_t
GetNumOfDaysInMonth(int year
, wxDateTime::Month month
)
319 // the number of days in month in Julian/Gregorian calendar: the first line
320 // is for normal years, the second one is for the leap ones
321 static const wxDateTime::wxDateTime_t daysInMonth
[2][MONTHS_IN_YEAR
] =
323 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
324 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
327 return daysInMonth
[wxDateTime::IsLeapYear(year
)][month
];
330 // returns the time zone in the C sense, i.e. the difference UTC - local
332 // NOTE: not static because used by datetimefmt.cpp
335 #ifdef WX_GMTOFF_IN_TM
336 // set to true when the timezone is set
337 static bool s_timezoneSet
= false;
338 static long gmtoffset
= LONG_MAX
; // invalid timezone
340 // ensure that the timezone variable is set by calling wxLocaltime_r
341 if ( !s_timezoneSet
)
343 // just call wxLocaltime_r() instead of figuring out whether this
344 // system supports tzset(), _tzset() or something else
348 wxLocaltime_r(&t
, &tm
);
349 s_timezoneSet
= true;
351 // note that GMT offset is the opposite of time zone and so to return
352 // consistent results in both WX_GMTOFF_IN_TM and !WX_GMTOFF_IN_TM
353 // cases we have to negate it
354 gmtoffset
= -tm
.tm_gmtoff
;
356 return (int)gmtoffset
;
357 #elif defined(__DJGPP__) || defined(__WINE__)
360 return tb
.timezone
*60;
361 #elif defined(__VISUALC__)
362 // We must initialize the time zone information before using it (this will
363 // be done only once internally).
366 // Starting with VC++ 8 timezone variable is deprecated and is not even
367 // available in some standard library version so use the new function for
368 // accessing it instead.
369 #if wxCHECK_VISUALC_VERSION(8)
376 #elif defined(WX_TIMEZONE) // If WX_TIMEZONE was defined by configure, use it.
378 #elif defined(__BORLANDC__) || defined(__MINGW32__) || defined(__VISAGECPP__)
380 #elif defined(__MWERKS__)
382 #else // unknown platform -- assume it has timezone
384 #endif // WX_GMTOFF_IN_TM/!WX_GMTOFF_IN_TM
387 // return the integral part of the JDN for the midnight of the given date (to
388 // get the real JDN you need to add 0.5, this is, in fact, JDN of the
389 // noon of the previous day)
390 static long GetTruncatedJDN(wxDateTime::wxDateTime_t day
,
391 wxDateTime::Month mon
,
394 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
396 // check the date validity
398 (year
> JDN_0_YEAR
) ||
399 ((year
== JDN_0_YEAR
) && (mon
> JDN_0_MONTH
)) ||
400 ((year
== JDN_0_YEAR
) && (mon
== JDN_0_MONTH
) && (day
>= JDN_0_DAY
)),
401 wxT("date out of range - can't convert to JDN")
404 // make the year positive to avoid problems with negative numbers division
407 // months are counted from March here
409 if ( mon
>= wxDateTime::Mar
)
419 // now we can simply add all the contributions together
420 return ((year
/ 100) * DAYS_PER_400_YEARS
) / 4
421 + ((year
% 100) * DAYS_PER_4_YEARS
) / 4
422 + (month
* DAYS_PER_5_MONTHS
+ 2) / 5
427 #ifdef wxHAS_STRFTIME
429 // this function is a wrapper around strftime(3) adding error checking
430 // NOTE: not static because used by datetimefmt.cpp
431 wxString
CallStrftime(const wxString
& format
, const tm
* tm
)
434 // Create temp wxString here to work around mingw/cygwin bug 1046059
435 // http://sourceforge.net/tracker/?func=detail&atid=102435&aid=1046059&group_id=2435
438 if ( !wxStrftime(buf
, WXSIZEOF(buf
), format
, tm
) )
440 // There is one special case in which strftime() can return 0 without
441 // indicating an error: "%p" may give empty string depending on the
442 // locale, so check for it explicitly. Apparently it's really the only
444 if ( format
!= wxS("%p") )
446 // if the format is valid, buffer must be too small?
447 wxFAIL_MSG(wxT("strftime() failed"));
457 #endif // wxHAS_STRFTIME
459 // if year and/or month have invalid values, replace them with the current ones
460 static void ReplaceDefaultYearMonthWithCurrent(int *year
,
461 wxDateTime::Month
*month
)
463 struct tm
*tmNow
= NULL
;
466 if ( *year
== wxDateTime::Inv_Year
)
468 tmNow
= wxDateTime::GetTmNow(&tmstruct
);
470 *year
= 1900 + tmNow
->tm_year
;
473 if ( *month
== wxDateTime::Inv_Month
)
476 tmNow
= wxDateTime::GetTmNow(&tmstruct
);
478 *month
= (wxDateTime::Month
)tmNow
->tm_mon
;
482 // fill the struct tm with default values
483 // NOTE: not static because used by datetimefmt.cpp
484 void InitTm(struct tm
& tm
)
486 // struct tm may have etxra fields (undocumented and with unportable
487 // names) which, nevertheless, must be set to 0
488 memset(&tm
, 0, sizeof(struct tm
));
490 tm
.tm_mday
= 1; // mday 0 is invalid
491 tm
.tm_year
= 76; // any valid year
492 tm
.tm_isdst
= -1; // auto determine
495 // ============================================================================
496 // implementation of wxDateTime
497 // ============================================================================
499 // ----------------------------------------------------------------------------
501 // ----------------------------------------------------------------------------
505 year
= (wxDateTime_t
)wxDateTime::Inv_Year
;
506 mon
= wxDateTime::Inv_Month
;
513 wday
= wxDateTime::Inv_WeekDay
;
516 wxDateTime::Tm::Tm(const struct tm
& tm
, const TimeZone
& tz
)
520 sec
= (wxDateTime::wxDateTime_t
)tm
.tm_sec
;
521 min
= (wxDateTime::wxDateTime_t
)tm
.tm_min
;
522 hour
= (wxDateTime::wxDateTime_t
)tm
.tm_hour
;
523 mday
= (wxDateTime::wxDateTime_t
)tm
.tm_mday
;
524 mon
= (wxDateTime::Month
)tm
.tm_mon
;
525 year
= 1900 + tm
.tm_year
;
526 wday
= (wxDateTime::wxDateTime_t
)tm
.tm_wday
;
527 yday
= (wxDateTime::wxDateTime_t
)tm
.tm_yday
;
530 bool wxDateTime::Tm::IsValid() const
532 if ( mon
== wxDateTime::Inv_Month
)
535 // We need to check this here to avoid crashing in GetNumOfDaysInMonth() if
536 // somebody passed us "(wxDateTime::Month)1000".
537 wxCHECK_MSG( mon
>= wxDateTime::Jan
&& mon
< wxDateTime::Inv_Month
, false,
538 wxS("Invalid month value") );
540 // we allow for the leap seconds, although we don't use them (yet)
541 return (year
!= wxDateTime::Inv_Year
) && (mon
!= wxDateTime::Inv_Month
) &&
542 (mday
> 0 && mday
<= GetNumOfDaysInMonth(year
, mon
)) &&
543 (hour
< 24) && (min
< 60) && (sec
< 62) && (msec
< 1000);
546 void wxDateTime::Tm::ComputeWeekDay()
548 // compute the week day from day/month/year: we use the dumbest algorithm
549 // possible: just compute our JDN and then use the (simple to derive)
550 // formula: weekday = (JDN + 1.5) % 7
551 wday
= (wxDateTime::wxDateTime_t
)((GetTruncatedJDN(mday
, mon
, year
) + 2) % 7);
554 void wxDateTime::Tm::AddMonths(int monDiff
)
556 // normalize the months field
557 while ( monDiff
< -mon
)
561 monDiff
+= MONTHS_IN_YEAR
;
564 while ( monDiff
+ mon
>= MONTHS_IN_YEAR
)
568 monDiff
-= MONTHS_IN_YEAR
;
571 mon
= (wxDateTime::Month
)(mon
+ monDiff
);
573 wxASSERT_MSG( mon
>= 0 && mon
< MONTHS_IN_YEAR
, wxT("logic error") );
575 // NB: we don't check here that the resulting date is valid, this function
576 // is private and the caller must check it if needed
579 void wxDateTime::Tm::AddDays(int dayDiff
)
581 // normalize the days field
582 while ( dayDiff
+ mday
< 1 )
586 dayDiff
+= GetNumOfDaysInMonth(year
, mon
);
589 mday
= (wxDateTime::wxDateTime_t
)( mday
+ dayDiff
);
590 while ( mday
> GetNumOfDaysInMonth(year
, mon
) )
592 mday
-= GetNumOfDaysInMonth(year
, mon
);
597 wxASSERT_MSG( mday
> 0 && mday
<= GetNumOfDaysInMonth(year
, mon
),
598 wxT("logic error") );
601 // ----------------------------------------------------------------------------
603 // ----------------------------------------------------------------------------
605 wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz
)
609 case wxDateTime::Local
:
610 // get the offset from C RTL: it returns the difference GMT-local
611 // while we want to have the offset _from_ GMT, hence the '-'
612 m_offset
= -GetTimeZone();
615 case wxDateTime::GMT_12
:
616 case wxDateTime::GMT_11
:
617 case wxDateTime::GMT_10
:
618 case wxDateTime::GMT_9
:
619 case wxDateTime::GMT_8
:
620 case wxDateTime::GMT_7
:
621 case wxDateTime::GMT_6
:
622 case wxDateTime::GMT_5
:
623 case wxDateTime::GMT_4
:
624 case wxDateTime::GMT_3
:
625 case wxDateTime::GMT_2
:
626 case wxDateTime::GMT_1
:
627 m_offset
= -3600*(wxDateTime::GMT0
- tz
);
630 case wxDateTime::GMT0
:
631 case wxDateTime::GMT1
:
632 case wxDateTime::GMT2
:
633 case wxDateTime::GMT3
:
634 case wxDateTime::GMT4
:
635 case wxDateTime::GMT5
:
636 case wxDateTime::GMT6
:
637 case wxDateTime::GMT7
:
638 case wxDateTime::GMT8
:
639 case wxDateTime::GMT9
:
640 case wxDateTime::GMT10
:
641 case wxDateTime::GMT11
:
642 case wxDateTime::GMT12
:
643 case wxDateTime::GMT13
:
644 m_offset
= 3600*(tz
- wxDateTime::GMT0
);
647 case wxDateTime::A_CST
:
648 // Central Standard Time in use in Australia = UTC + 9.5
649 m_offset
= 60l*(9*MIN_PER_HOUR
+ MIN_PER_HOUR
/2);
653 wxFAIL_MSG( wxT("unknown time zone") );
657 // ----------------------------------------------------------------------------
659 // ----------------------------------------------------------------------------
662 struct tm
*wxDateTime::GetTmNow(struct tm
*tmstruct
)
664 time_t t
= GetTimeNow();
665 return wxLocaltime_r(&t
, tmstruct
);
669 bool wxDateTime::IsLeapYear(int year
, wxDateTime::Calendar cal
)
671 if ( year
== Inv_Year
)
672 year
= GetCurrentYear();
674 if ( cal
== Gregorian
)
676 // in Gregorian calendar leap years are those divisible by 4 except
677 // those divisible by 100 unless they're also divisible by 400
678 // (in some countries, like Russia and Greece, additional corrections
679 // exist, but they won't manifest themselves until 2700)
680 return (year
% 4 == 0) && ((year
% 100 != 0) || (year
% 400 == 0));
682 else if ( cal
== Julian
)
684 // in Julian calendar the rule is simpler
685 return year
% 4 == 0;
689 wxFAIL_MSG(wxT("unknown calendar"));
696 int wxDateTime::GetCentury(int year
)
698 return year
> 0 ? year
/ 100 : year
/ 100 - 1;
702 int wxDateTime::ConvertYearToBC(int year
)
705 return year
> 0 ? year
: year
- 1;
709 int wxDateTime::GetCurrentYear(wxDateTime::Calendar cal
)
714 return Now().GetYear();
717 wxFAIL_MSG(wxT("TODO"));
721 wxFAIL_MSG(wxT("unsupported calendar"));
729 wxDateTime::Month
wxDateTime::GetCurrentMonth(wxDateTime::Calendar cal
)
734 return Now().GetMonth();
737 wxFAIL_MSG(wxT("TODO"));
741 wxFAIL_MSG(wxT("unsupported calendar"));
749 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(int year
, Calendar cal
)
751 if ( year
== Inv_Year
)
753 // take the current year if none given
754 year
= GetCurrentYear();
761 return IsLeapYear(year
) ? 366 : 365;
764 wxFAIL_MSG(wxT("unsupported calendar"));
772 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(wxDateTime::Month month
,
774 wxDateTime::Calendar cal
)
776 wxCHECK_MSG( month
< MONTHS_IN_YEAR
, 0, wxT("invalid month") );
778 if ( cal
== Gregorian
|| cal
== Julian
)
780 if ( year
== Inv_Year
)
782 // take the current year if none given
783 year
= GetCurrentYear();
786 return GetNumOfDaysInMonth(year
, month
);
790 wxFAIL_MSG(wxT("unsupported calendar"));
799 // helper function used by GetEnglish/WeekDayName(): returns 0 if flags is
800 // Name_Full and 1 if it is Name_Abbr or -1 if the flags is incorrect (and
801 // asserts in this case)
803 // the return value of this function is used as an index into 2D array
804 // containing full names in its first row and abbreviated ones in the 2nd one
805 int NameArrayIndexFromFlag(wxDateTime::NameFlags flags
)
809 case wxDateTime::Name_Full
:
812 case wxDateTime::Name_Abbr
:
816 wxFAIL_MSG( "unknown wxDateTime::NameFlags value" );
822 } // anonymous namespace
825 wxString
wxDateTime::GetEnglishMonthName(Month month
, NameFlags flags
)
827 wxCHECK_MSG( month
!= Inv_Month
, wxEmptyString
, "invalid month" );
829 static const char *const monthNames
[2][MONTHS_IN_YEAR
] =
831 { "January", "February", "March", "April", "May", "June",
832 "July", "August", "September", "October", "November", "December" },
833 { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
834 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }
837 const int idx
= NameArrayIndexFromFlag(flags
);
841 return monthNames
[idx
][month
];
845 wxString
wxDateTime::GetMonthName(wxDateTime::Month month
,
846 wxDateTime::NameFlags flags
)
848 #ifdef wxHAS_STRFTIME
849 wxCHECK_MSG( month
!= Inv_Month
, wxEmptyString
, wxT("invalid month") );
851 // notice that we must set all the fields to avoid confusing libc (GNU one
852 // gets confused to a crash if we don't do this)
857 return CallStrftime(flags
== Name_Abbr
? wxT("%b") : wxT("%B"), &tm
);
858 #else // !wxHAS_STRFTIME
859 return GetEnglishMonthName(month
, flags
);
860 #endif // wxHAS_STRFTIME/!wxHAS_STRFTIME
864 wxString
wxDateTime::GetEnglishWeekDayName(WeekDay wday
, NameFlags flags
)
866 wxCHECK_MSG( wday
!= Inv_WeekDay
, wxEmptyString
, wxT("invalid weekday") );
868 static const char *const weekdayNames
[2][DAYS_PER_WEEK
] =
870 { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday",
872 { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" },
875 const int idx
= NameArrayIndexFromFlag(flags
);
879 return weekdayNames
[idx
][wday
];
883 wxString
wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday
,
884 wxDateTime::NameFlags flags
)
886 #ifdef wxHAS_STRFTIME
887 wxCHECK_MSG( wday
!= Inv_WeekDay
, wxEmptyString
, wxT("invalid weekday") );
889 // take some arbitrary Sunday (but notice that the day should be such that
890 // after adding wday to it below we still have a valid date, e.g. don't
898 // and offset it by the number of days needed to get the correct wday
901 // call mktime() to normalize it...
904 // ... and call strftime()
905 return CallStrftime(flags
== Name_Abbr
? wxT("%a") : wxT("%A"), &tm
);
906 #else // !wxHAS_STRFTIME
907 return GetEnglishWeekDayName(wday
, flags
);
908 #endif // wxHAS_STRFTIME/!wxHAS_STRFTIME
912 void wxDateTime::GetAmPmStrings(wxString
*am
, wxString
*pm
)
917 // @Note: Do not call 'CallStrftime' here! CallStrftime checks the return code
918 // and causes an assertion failed if the buffer is to small (which is good) - OR -
919 // if strftime does not return anything because the format string is invalid - OR -
920 // if there are no 'am' / 'pm' tokens defined for the current locale (which is not good).
921 // wxDateTime::ParseTime will try several different formats to parse the time.
922 // As a result, GetAmPmStrings might get called, even if the current locale
923 // does not define any 'am' / 'pm' tokens. In this case, wxStrftime would
924 // assert, even though it is a perfectly legal use.
927 if (wxStrftime(buffer
, WXSIZEOF(buffer
), wxT("%p"), &tm
) > 0)
928 *am
= wxString(buffer
);
935 if (wxStrftime(buffer
, WXSIZEOF(buffer
), wxT("%p"), &tm
) > 0)
936 *pm
= wxString(buffer
);
943 // ----------------------------------------------------------------------------
944 // Country stuff: date calculations depend on the country (DST, work days,
945 // ...), so we need to know which rules to follow.
946 // ----------------------------------------------------------------------------
949 wxDateTime::Country
wxDateTime::GetCountry()
951 // TODO use LOCALE_ICOUNTRY setting under Win32
953 if ( ms_country
== Country_Unknown
)
955 // try to guess from the time zone name
956 time_t t
= time(NULL
);
958 struct tm
*tm
= wxLocaltime_r(&t
, &tmstruct
);
960 wxString tz
= CallStrftime(wxT("%Z"), tm
);
961 if ( tz
== wxT("WET") || tz
== wxT("WEST") )
965 else if ( tz
== wxT("CET") || tz
== wxT("CEST") )
967 ms_country
= Country_EEC
;
969 else if ( tz
== wxT("MSK") || tz
== wxT("MSD") )
973 else if ( tz
== wxT("AST") || tz
== wxT("ADT") ||
974 tz
== wxT("EST") || tz
== wxT("EDT") ||
975 tz
== wxT("CST") || tz
== wxT("CDT") ||
976 tz
== wxT("MST") || tz
== wxT("MDT") ||
977 tz
== wxT("PST") || tz
== wxT("PDT") )
983 // well, choose a default one
989 #endif // !__WXWINCE__/__WXWINCE__
995 void wxDateTime::SetCountry(wxDateTime::Country country
)
997 ms_country
= country
;
1001 bool wxDateTime::IsWestEuropeanCountry(Country country
)
1003 if ( country
== Country_Default
)
1005 country
= GetCountry();
1008 return (Country_WesternEurope_Start
<= country
) &&
1009 (country
<= Country_WesternEurope_End
);
1012 // ----------------------------------------------------------------------------
1013 // DST calculations: we use 3 different rules for the West European countries,
1014 // USA and for the rest of the world. This is undoubtedly false for many
1015 // countries, but I lack the necessary info (and the time to gather it),
1016 // please add the other rules here!
1017 // ----------------------------------------------------------------------------
1020 bool wxDateTime::IsDSTApplicable(int year
, Country country
)
1022 if ( year
== Inv_Year
)
1024 // take the current year if none given
1025 year
= GetCurrentYear();
1028 if ( country
== Country_Default
)
1030 country
= GetCountry();
1037 // DST was first observed in the US and UK during WWI, reused
1038 // during WWII and used again since 1966
1039 return year
>= 1966 ||
1040 (year
>= 1942 && year
<= 1945) ||
1041 (year
== 1918 || year
== 1919);
1044 // assume that it started after WWII
1050 wxDateTime
wxDateTime::GetBeginDST(int year
, Country country
)
1052 if ( year
== Inv_Year
)
1054 // take the current year if none given
1055 year
= GetCurrentYear();
1058 if ( country
== Country_Default
)
1060 country
= GetCountry();
1063 if ( !IsDSTApplicable(year
, country
) )
1065 return wxInvalidDateTime
;
1070 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
1072 // DST begins at 1 a.m. GMT on the last Sunday of March
1073 if ( !dt
.SetToLastWeekDay(Sun
, Mar
, year
) )
1076 wxFAIL_MSG( wxT("no last Sunday in March?") );
1079 dt
+= wxTimeSpan::Hours(1);
1081 else switch ( country
)
1088 // don't know for sure - assume it was in effect all year
1093 dt
.Set(1, Jan
, year
);
1097 // DST was installed Feb 2, 1942 by the Congress
1098 dt
.Set(2, Feb
, year
);
1101 // Oil embargo changed the DST period in the US
1103 dt
.Set(6, Jan
, 1974);
1107 dt
.Set(23, Feb
, 1975);
1111 // before 1986, DST begun on the last Sunday of April, but
1112 // in 1986 Reagan changed it to begin at 2 a.m. of the
1113 // first Sunday in April
1116 if ( !dt
.SetToLastWeekDay(Sun
, Apr
, year
) )
1119 wxFAIL_MSG( wxT("no first Sunday in April?") );
1122 else if ( year
> 2006 )
1123 // Energy Policy Act of 2005, Pub. L. no. 109-58, 119 Stat 594 (2005).
1124 // Starting in 2007, daylight time begins in the United States on the
1125 // second Sunday in March and ends on the first Sunday in November
1127 if ( !dt
.SetToWeekDay(Sun
, 2, Mar
, year
) )
1130 wxFAIL_MSG( wxT("no second Sunday in March?") );
1135 if ( !dt
.SetToWeekDay(Sun
, 1, Apr
, year
) )
1138 wxFAIL_MSG( wxT("no first Sunday in April?") );
1142 dt
+= wxTimeSpan::Hours(2);
1144 // TODO what about timezone??
1150 // assume Mar 30 as the start of the DST for the rest of the world
1151 // - totally bogus, of course
1152 dt
.Set(30, Mar
, year
);
1159 wxDateTime
wxDateTime::GetEndDST(int year
, Country country
)
1161 if ( year
== Inv_Year
)
1163 // take the current year if none given
1164 year
= GetCurrentYear();
1167 if ( country
== Country_Default
)
1169 country
= GetCountry();
1172 if ( !IsDSTApplicable(year
, country
) )
1174 return wxInvalidDateTime
;
1179 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
1181 // DST ends at 1 a.m. GMT on the last Sunday of October
1182 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1184 // weirder and weirder...
1185 wxFAIL_MSG( wxT("no last Sunday in October?") );
1188 dt
+= wxTimeSpan::Hours(1);
1190 else switch ( country
)
1197 // don't know for sure - assume it was in effect all year
1201 dt
.Set(31, Dec
, year
);
1205 // the time was reset after the end of the WWII
1206 dt
.Set(30, Sep
, year
);
1209 default: // default for switch (year)
1211 // Energy Policy Act of 2005, Pub. L. no. 109-58, 119 Stat 594 (2005).
1212 // Starting in 2007, daylight time begins in the United States on the
1213 // second Sunday in March and ends on the first Sunday in November
1215 if ( !dt
.SetToWeekDay(Sun
, 1, Nov
, year
) )
1218 wxFAIL_MSG( wxT("no first Sunday in November?") );
1223 // DST ends at 2 a.m. on the last Sunday of October
1225 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1227 // weirder and weirder...
1228 wxFAIL_MSG( wxT("no last Sunday in October?") );
1232 dt
+= wxTimeSpan::Hours(2);
1234 // TODO: what about timezone??
1238 default: // default for switch (country)
1239 // assume October 26th as the end of the DST - totally bogus too
1240 dt
.Set(26, Oct
, year
);
1246 // ----------------------------------------------------------------------------
1247 // constructors and assignment operators
1248 // ----------------------------------------------------------------------------
1250 // return the current time with ms precision
1251 /* static */ wxDateTime
wxDateTime::UNow()
1253 return wxDateTime(wxGetLocalTimeMillis());
1256 // the values in the tm structure contain the local time
1257 wxDateTime
& wxDateTime::Set(const struct tm
& tm
)
1260 time_t timet
= mktime(&tm2
);
1262 if ( timet
== (time_t)-1 )
1264 // mktime() rather unintuitively fails for Jan 1, 1970 if the hour is
1265 // less than timezone - try to make it work for this case
1266 if ( tm2
.tm_year
== 70 && tm2
.tm_mon
== 0 && tm2
.tm_mday
== 1 )
1268 return Set((time_t)(
1270 tm2
.tm_hour
* MIN_PER_HOUR
* SEC_PER_MIN
+
1271 tm2
.tm_min
* SEC_PER_MIN
+
1275 wxFAIL_MSG( wxT("mktime() failed") );
1277 *this = wxInvalidDateTime
;
1287 wxDateTime
& wxDateTime::Set(wxDateTime_t hour
,
1288 wxDateTime_t minute
,
1289 wxDateTime_t second
,
1290 wxDateTime_t millisec
)
1292 // we allow seconds to be 61 to account for the leap seconds, even if we
1293 // don't use them really
1294 wxDATETIME_CHECK( hour
< 24 &&
1298 wxT("Invalid time in wxDateTime::Set()") );
1300 // get the current date from system
1302 struct tm
*tm
= GetTmNow(&tmstruct
);
1304 wxDATETIME_CHECK( tm
, wxT("wxLocaltime_r() failed") );
1306 // make a copy so it isn't clobbered by the call to mktime() below
1311 tm1
.tm_min
= minute
;
1312 tm1
.tm_sec
= second
;
1314 // and the DST in case it changes on this date
1317 if ( tm2
.tm_isdst
!= tm1
.tm_isdst
)
1318 tm1
.tm_isdst
= tm2
.tm_isdst
;
1322 // and finally adjust milliseconds
1323 return SetMillisecond(millisec
);
1326 wxDateTime
& wxDateTime::Set(wxDateTime_t day
,
1330 wxDateTime_t minute
,
1331 wxDateTime_t second
,
1332 wxDateTime_t millisec
)
1334 wxDATETIME_CHECK( hour
< 24 &&
1338 wxT("Invalid time in wxDateTime::Set()") );
1340 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1342 wxDATETIME_CHECK( (0 < day
) && (day
<= GetNumberOfDays(month
, year
)),
1343 wxT("Invalid date in wxDateTime::Set()") );
1345 // the range of time_t type (inclusive)
1346 static const int yearMinInRange
= 1970;
1347 static const int yearMaxInRange
= 2037;
1349 // test only the year instead of testing for the exact end of the Unix
1350 // time_t range - it doesn't bring anything to do more precise checks
1351 if ( year
>= yearMinInRange
&& year
<= yearMaxInRange
)
1353 // use the standard library version if the date is in range - this is
1354 // probably more efficient than our code
1356 tm
.tm_year
= year
- 1900;
1362 tm
.tm_isdst
= -1; // mktime() will guess it
1366 // and finally adjust milliseconds
1368 SetMillisecond(millisec
);
1374 // do time calculations ourselves: we want to calculate the number of
1375 // milliseconds between the given date and the epoch
1377 // get the JDN for the midnight of this day
1378 m_time
= GetTruncatedJDN(day
, month
, year
);
1379 m_time
-= EPOCH_JDN
;
1380 m_time
*= SECONDS_PER_DAY
* TIME_T_FACTOR
;
1382 // JDN corresponds to GMT, we take localtime
1383 Add(wxTimeSpan(hour
, minute
, second
+ GetTimeZone(), millisec
));
1389 wxDateTime
& wxDateTime::Set(double jdn
)
1391 // so that m_time will be 0 for the midnight of Jan 1, 1970 which is jdn
1393 jdn
-= EPOCH_JDN
+ 0.5;
1395 m_time
.Assign(jdn
*MILLISECONDS_PER_DAY
);
1397 // JDNs always are in UTC, so we don't need any adjustments for time zone
1402 wxDateTime
& wxDateTime::ResetTime()
1406 if ( tm
.hour
|| tm
.min
|| tm
.sec
|| tm
.msec
)
1419 wxDateTime
wxDateTime::GetDateOnly() const
1426 return wxDateTime(tm
);
1429 // ----------------------------------------------------------------------------
1430 // DOS Date and Time Format functions
1431 // ----------------------------------------------------------------------------
1432 // the dos date and time value is an unsigned 32 bit value in the format:
1433 // YYYYYYYMMMMDDDDDhhhhhmmmmmmsssss
1435 // Y = year offset from 1980 (0-127)
1437 // D = day of month (1-31)
1439 // m = minute (0-59)
1440 // s = bisecond (0-29) each bisecond indicates two seconds
1441 // ----------------------------------------------------------------------------
1443 wxDateTime
& wxDateTime::SetFromDOS(unsigned long ddt
)
1448 long year
= ddt
& 0xFE000000;
1453 long month
= ddt
& 0x1E00000;
1458 long day
= ddt
& 0x1F0000;
1462 long hour
= ddt
& 0xF800;
1466 long minute
= ddt
& 0x7E0;
1470 long second
= ddt
& 0x1F;
1471 tm
.tm_sec
= second
* 2;
1473 return Set(mktime(&tm
));
1476 unsigned long wxDateTime::GetAsDOS() const
1479 time_t ticks
= GetTicks();
1481 struct tm
*tm
= wxLocaltime_r(&ticks
, &tmstruct
);
1482 wxCHECK_MSG( tm
, ULONG_MAX
, wxT("time can't be represented in DOS format") );
1484 long year
= tm
->tm_year
;
1488 long month
= tm
->tm_mon
;
1492 long day
= tm
->tm_mday
;
1495 long hour
= tm
->tm_hour
;
1498 long minute
= tm
->tm_min
;
1501 long second
= tm
->tm_sec
;
1504 ddt
= year
| month
| day
| hour
| minute
| second
;
1508 // ----------------------------------------------------------------------------
1509 // time_t <-> broken down time conversions
1510 // ----------------------------------------------------------------------------
1512 wxDateTime::Tm
wxDateTime::GetTm(const TimeZone
& tz
) const
1514 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1516 time_t time
= GetTicks();
1517 if ( time
!= (time_t)-1 )
1519 // use C RTL functions
1522 if ( tz
.GetOffset() == -GetTimeZone() )
1524 // we are working with local time
1525 tm
= wxLocaltime_r(&time
, &tmstruct
);
1527 // should never happen
1528 wxCHECK_MSG( tm
, Tm(), wxT("wxLocaltime_r() failed") );
1532 time
+= (time_t)tz
.GetOffset();
1533 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
1534 int time2
= (int) time
;
1540 tm
= wxGmtime_r(&time
, &tmstruct
);
1542 // should never happen
1543 wxCHECK_MSG( tm
, Tm(), wxT("wxGmtime_r() failed") );
1547 tm
= (struct tm
*)NULL
;
1553 // adjust the milliseconds
1555 long timeOnly
= (m_time
% MILLISECONDS_PER_DAY
).ToLong();
1556 tm2
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1559 //else: use generic code below
1562 // remember the time and do the calculations with the date only - this
1563 // eliminates rounding errors of the floating point arithmetics
1565 wxLongLong timeMidnight
= m_time
+ tz
.GetOffset() * 1000;
1567 long timeOnly
= (timeMidnight
% MILLISECONDS_PER_DAY
).ToLong();
1569 // we want to always have positive time and timeMidnight to be really
1570 // the midnight before it
1573 timeOnly
= MILLISECONDS_PER_DAY
+ timeOnly
;
1576 timeMidnight
-= timeOnly
;
1578 // calculate the Gregorian date from JDN for the midnight of our date:
1579 // this will yield day, month (in 1..12 range) and year
1581 // actually, this is the JDN for the noon of the previous day
1582 long jdn
= (timeMidnight
/ MILLISECONDS_PER_DAY
).ToLong() + EPOCH_JDN
;
1584 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
1586 wxASSERT_MSG( jdn
> -2, wxT("JDN out of range") );
1588 // calculate the century
1589 long temp
= (jdn
+ JDN_OFFSET
) * 4 - 1;
1590 long century
= temp
/ DAYS_PER_400_YEARS
;
1592 // then the year and day of year (1 <= dayOfYear <= 366)
1593 temp
= ((temp
% DAYS_PER_400_YEARS
) / 4) * 4 + 3;
1594 long year
= (century
* 100) + (temp
/ DAYS_PER_4_YEARS
);
1595 long dayOfYear
= (temp
% DAYS_PER_4_YEARS
) / 4 + 1;
1597 // and finally the month and day of the month
1598 temp
= dayOfYear
* 5 - 3;
1599 long month
= temp
/ DAYS_PER_5_MONTHS
;
1600 long day
= (temp
% DAYS_PER_5_MONTHS
) / 5 + 1;
1602 // month is counted from March - convert to normal
1613 // year is offset by 4800
1616 // check that the algorithm gave us something reasonable
1617 wxASSERT_MSG( (0 < month
) && (month
<= 12), wxT("invalid month") );
1618 wxASSERT_MSG( (1 <= day
) && (day
< 32), wxT("invalid day") );
1620 // construct Tm from these values
1622 tm
.year
= (int)year
;
1623 tm
.yday
= (wxDateTime_t
)(dayOfYear
- 1); // use C convention for day number
1624 tm
.mon
= (Month
)(month
- 1); // algorithm yields 1 for January, not 0
1625 tm
.mday
= (wxDateTime_t
)day
;
1626 tm
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1627 timeOnly
-= tm
.msec
;
1628 timeOnly
/= 1000; // now we have time in seconds
1630 tm
.sec
= (wxDateTime_t
)(timeOnly
% SEC_PER_MIN
);
1632 timeOnly
/= SEC_PER_MIN
; // now we have time in minutes
1634 tm
.min
= (wxDateTime_t
)(timeOnly
% MIN_PER_HOUR
);
1637 tm
.hour
= (wxDateTime_t
)(timeOnly
/ MIN_PER_HOUR
);
1642 wxDateTime
& wxDateTime::SetYear(int year
)
1644 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1653 wxDateTime
& wxDateTime::SetMonth(Month month
)
1655 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1664 wxDateTime
& wxDateTime::SetDay(wxDateTime_t mday
)
1666 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1675 wxDateTime
& wxDateTime::SetHour(wxDateTime_t hour
)
1677 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1686 wxDateTime
& wxDateTime::SetMinute(wxDateTime_t min
)
1688 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1697 wxDateTime
& wxDateTime::SetSecond(wxDateTime_t sec
)
1699 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1708 wxDateTime
& wxDateTime::SetMillisecond(wxDateTime_t millisecond
)
1710 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1712 // we don't need to use GetTm() for this one
1713 m_time
-= m_time
% 1000l;
1714 m_time
+= millisecond
;
1719 // ----------------------------------------------------------------------------
1720 // wxDateTime arithmetics
1721 // ----------------------------------------------------------------------------
1723 wxDateTime
& wxDateTime::Add(const wxDateSpan
& diff
)
1727 tm
.year
+= diff
.GetYears();
1728 tm
.AddMonths(diff
.GetMonths());
1730 // check that the resulting date is valid
1731 if ( tm
.mday
> GetNumOfDaysInMonth(tm
.year
, tm
.mon
) )
1733 // We suppose that when adding one month to Jan 31 we want to get Feb
1734 // 28 (or 29), i.e. adding a month to the last day of the month should
1735 // give the last day of the next month which is quite logical.
1737 // Unfortunately, there is no logic way to understand what should
1738 // Jan 30 + 1 month be - Feb 28 too or Feb 27 (assuming non leap year)?
1739 // We make it Feb 28 (last day too), but it is highly questionable.
1740 tm
.mday
= GetNumOfDaysInMonth(tm
.year
, tm
.mon
);
1743 tm
.AddDays(diff
.GetTotalDays());
1747 wxASSERT_MSG( IsSameTime(tm
),
1748 wxT("Add(wxDateSpan) shouldn't modify time") );
1753 // ----------------------------------------------------------------------------
1754 // Weekday and monthday stuff
1755 // ----------------------------------------------------------------------------
1757 // convert Sun, Mon, ..., Sat into 6, 0, ..., 5
1758 static inline int ConvertWeekDayToMondayBase(int wd
)
1760 return wd
== wxDateTime::Sun
? 6 : wd
- 1;
1765 wxDateTime::SetToWeekOfYear(int year
, wxDateTime_t numWeek
, WeekDay wd
)
1767 wxASSERT_MSG( numWeek
> 0,
1768 wxT("invalid week number: weeks are counted from 1") );
1770 // Jan 4 always lies in the 1st week of the year
1771 wxDateTime
dt(4, Jan
, year
);
1772 dt
.SetToWeekDayInSameWeek(wd
);
1773 dt
+= wxDateSpan::Weeks(numWeek
- 1);
1778 #if WXWIN_COMPATIBILITY_2_6
1779 // use a separate function to avoid warnings about using deprecated
1780 // SetToTheWeek in GetWeek below
1782 SetToTheWeek(int year
,
1783 wxDateTime::wxDateTime_t numWeek
,
1784 wxDateTime::WeekDay weekday
,
1785 wxDateTime::WeekFlags flags
)
1787 // Jan 4 always lies in the 1st week of the year
1788 wxDateTime
dt(4, wxDateTime::Jan
, year
);
1789 dt
.SetToWeekDayInSameWeek(weekday
, flags
);
1790 dt
+= wxDateSpan::Weeks(numWeek
- 1);
1795 bool wxDateTime::SetToTheWeek(wxDateTime_t numWeek
,
1799 int year
= GetYear();
1800 *this = ::SetToTheWeek(year
, numWeek
, weekday
, flags
);
1801 if ( GetYear() != year
)
1803 // oops... numWeek was too big
1810 wxDateTime
wxDateTime::GetWeek(wxDateTime_t numWeek
,
1812 WeekFlags flags
) const
1814 return ::SetToTheWeek(GetYear(), numWeek
, weekday
, flags
);
1816 #endif // WXWIN_COMPATIBILITY_2_6
1818 wxDateTime
& wxDateTime::SetToLastMonthDay(Month month
,
1821 // take the current month/year if none specified
1822 if ( year
== Inv_Year
)
1824 if ( month
== Inv_Month
)
1827 return Set(GetNumOfDaysInMonth(year
, month
), month
, year
);
1830 wxDateTime
& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday
, WeekFlags flags
)
1832 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, wxT("invalid weekday") );
1834 int wdayDst
= weekday
,
1835 wdayThis
= GetWeekDay();
1836 if ( wdayDst
== wdayThis
)
1842 if ( flags
== Default_First
)
1844 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
1847 // the logic below based on comparing weekday and wdayThis works if Sun (0)
1848 // is the first day in the week, but breaks down for Monday_First case so
1849 // we adjust the week days in this case
1850 if ( flags
== Monday_First
)
1852 if ( wdayThis
== Sun
)
1854 if ( wdayDst
== Sun
)
1857 //else: Sunday_First, nothing to do
1859 // go forward or back in time to the day we want
1860 if ( wdayDst
< wdayThis
)
1862 return Subtract(wxDateSpan::Days(wdayThis
- wdayDst
));
1864 else // weekday > wdayThis
1866 return Add(wxDateSpan::Days(wdayDst
- wdayThis
));
1870 wxDateTime
& wxDateTime::SetToNextWeekDay(WeekDay weekday
)
1872 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, wxT("invalid weekday") );
1875 WeekDay wdayThis
= GetWeekDay();
1876 if ( weekday
== wdayThis
)
1881 else if ( weekday
< wdayThis
)
1883 // need to advance a week
1884 diff
= 7 - (wdayThis
- weekday
);
1886 else // weekday > wdayThis
1888 diff
= weekday
- wdayThis
;
1891 return Add(wxDateSpan::Days(diff
));
1894 wxDateTime
& wxDateTime::SetToPrevWeekDay(WeekDay weekday
)
1896 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, wxT("invalid weekday") );
1899 WeekDay wdayThis
= GetWeekDay();
1900 if ( weekday
== wdayThis
)
1905 else if ( weekday
> wdayThis
)
1907 // need to go to previous week
1908 diff
= 7 - (weekday
- wdayThis
);
1910 else // weekday < wdayThis
1912 diff
= wdayThis
- weekday
;
1915 return Subtract(wxDateSpan::Days(diff
));
1918 bool wxDateTime::SetToWeekDay(WeekDay weekday
,
1923 wxCHECK_MSG( weekday
!= Inv_WeekDay
, false, wxT("invalid weekday") );
1925 // we don't check explicitly that -5 <= n <= 5 because we will return false
1926 // anyhow in such case - but may be should still give an assert for it?
1928 // take the current month/year if none specified
1929 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1933 // TODO this probably could be optimised somehow...
1937 // get the first day of the month
1938 dt
.Set(1, month
, year
);
1941 WeekDay wdayFirst
= dt
.GetWeekDay();
1943 // go to the first weekday of the month
1944 int diff
= weekday
- wdayFirst
;
1948 // add advance n-1 weeks more
1951 dt
+= wxDateSpan::Days(diff
);
1953 else // count from the end of the month
1955 // get the last day of the month
1956 dt
.SetToLastMonthDay(month
, year
);
1959 WeekDay wdayLast
= dt
.GetWeekDay();
1961 // go to the last weekday of the month
1962 int diff
= wdayLast
- weekday
;
1966 // and rewind n-1 weeks from there
1969 dt
-= wxDateSpan::Days(diff
);
1972 // check that it is still in the same month
1973 if ( dt
.GetMonth() == month
)
1981 // no such day in this month
1987 wxDateTime::wxDateTime_t
GetDayOfYearFromTm(const wxDateTime::Tm
& tm
)
1989 return (wxDateTime::wxDateTime_t
)(gs_cumulatedDays
[wxDateTime::IsLeapYear(tm
.year
)][tm
.mon
] + tm
.mday
);
1992 wxDateTime::wxDateTime_t
wxDateTime::GetDayOfYear(const TimeZone
& tz
) const
1994 return GetDayOfYearFromTm(GetTm(tz
));
1997 wxDateTime::wxDateTime_t
1998 wxDateTime::GetWeekOfYear(wxDateTime::WeekFlags flags
, const TimeZone
& tz
) const
2000 if ( flags
== Default_First
)
2002 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
2006 wxDateTime_t nDayInYear
= GetDayOfYearFromTm(tm
);
2008 int wdTarget
= GetWeekDay(tz
);
2009 int wdYearStart
= wxDateTime(1, Jan
, GetYear()).GetWeekDay();
2011 if ( flags
== Sunday_First
)
2013 // FIXME: First week is not calculated correctly.
2014 week
= (nDayInYear
- wdTarget
+ 7) / 7;
2015 if ( wdYearStart
== Wed
|| wdYearStart
== Thu
)
2018 else // week starts with monday
2020 // adjust the weekdays to non-US style.
2021 wdYearStart
= ConvertWeekDayToMondayBase(wdYearStart
);
2022 wdTarget
= ConvertWeekDayToMondayBase(wdTarget
);
2024 // quoting from http://www.cl.cam.ac.uk/~mgk25/iso-time.html:
2026 // Week 01 of a year is per definition the first week that has the
2027 // Thursday in this year, which is equivalent to the week that
2028 // contains the fourth day of January. In other words, the first
2029 // week of a new year is the week that has the majority of its
2030 // days in the new year. Week 01 might also contain days from the
2031 // previous year and the week before week 01 of a year is the last
2032 // week (52 or 53) of the previous year even if it contains days
2033 // from the new year. A week starts with Monday (day 1) and ends
2034 // with Sunday (day 7).
2037 // if Jan 1 is Thursday or less, it is in the first week of this year
2038 if ( wdYearStart
< 4 )
2040 // count the number of entire weeks between Jan 1 and this date
2041 week
= (nDayInYear
+ wdYearStart
+ 6 - wdTarget
)/7;
2043 // be careful to check for overflow in the next year
2044 if ( week
== 53 && tm
.mday
- wdTarget
> 28 )
2047 else // Jan 1 is in the last week of the previous year
2049 // check if we happen to be at the last week of previous year:
2050 if ( tm
.mon
== Jan
&& tm
.mday
< 8 - wdYearStart
)
2051 week
= wxDateTime(31, Dec
, GetYear()-1).GetWeekOfYear();
2053 week
= (nDayInYear
+ wdYearStart
- 1 - wdTarget
)/7;
2057 return (wxDateTime::wxDateTime_t
)week
;
2060 wxDateTime::wxDateTime_t
wxDateTime::GetWeekOfMonth(wxDateTime::WeekFlags flags
,
2061 const TimeZone
& tz
) const
2064 const wxDateTime dateFirst
= wxDateTime(1, tm
.mon
, tm
.year
);
2065 const wxDateTime::WeekDay wdFirst
= dateFirst
.GetWeekDay();
2067 if ( flags
== Default_First
)
2069 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
2072 // compute offset of dateFirst from the beginning of the week
2074 if ( flags
== Sunday_First
)
2075 firstOffset
= wdFirst
- Sun
;
2077 firstOffset
= wdFirst
== Sun
? DAYS_PER_WEEK
- 1 : wdFirst
- Mon
;
2079 return (wxDateTime::wxDateTime_t
)((tm
.mday
- 1 + firstOffset
)/7 + 1);
2082 wxDateTime
& wxDateTime::SetToYearDay(wxDateTime::wxDateTime_t yday
)
2084 int year
= GetYear();
2085 wxDATETIME_CHECK( (0 < yday
) && (yday
<= GetNumberOfDays(year
)),
2086 wxT("invalid year day") );
2088 bool isLeap
= IsLeapYear(year
);
2089 for ( Month mon
= Jan
; mon
< Inv_Month
; wxNextMonth(mon
) )
2091 // for Dec, we can't compare with gs_cumulatedDays[mon + 1], but we
2092 // don't need it neither - because of the CHECK above we know that
2093 // yday lies in December then
2094 if ( (mon
== Dec
) || (yday
<= gs_cumulatedDays
[isLeap
][mon
+ 1]) )
2096 Set((wxDateTime::wxDateTime_t
)(yday
- gs_cumulatedDays
[isLeap
][mon
]), mon
, year
);
2105 // ----------------------------------------------------------------------------
2106 // Julian day number conversion and related stuff
2107 // ----------------------------------------------------------------------------
2109 double wxDateTime::GetJulianDayNumber() const
2111 return m_time
.ToDouble() / MILLISECONDS_PER_DAY
+ EPOCH_JDN
+ 0.5;
2114 double wxDateTime::GetRataDie() const
2116 // March 1 of the year 0 is Rata Die day -306 and JDN 1721119.5
2117 return GetJulianDayNumber() - 1721119.5 - 306;
2120 // ----------------------------------------------------------------------------
2121 // timezone and DST stuff
2122 // ----------------------------------------------------------------------------
2124 int wxDateTime::IsDST(wxDateTime::Country country
) const
2126 wxCHECK_MSG( country
== Country_Default
, -1,
2127 wxT("country support not implemented") );
2129 // use the C RTL for the dates in the standard range
2130 time_t timet
= GetTicks();
2131 if ( timet
!= (time_t)-1 )
2134 tm
*tm
= wxLocaltime_r(&timet
, &tmstruct
);
2136 wxCHECK_MSG( tm
, -1, wxT("wxLocaltime_r() failed") );
2138 return tm
->tm_isdst
;
2142 int year
= GetYear();
2144 if ( !IsDSTApplicable(year
, country
) )
2146 // no DST time in this year in this country
2150 return IsBetween(GetBeginDST(year
, country
), GetEndDST(year
, country
));
2154 wxDateTime
& wxDateTime::MakeTimezone(const TimeZone
& tz
, bool noDST
)
2156 long secDiff
= GetTimeZone() + tz
.GetOffset();
2158 // we need to know whether DST is or not in effect for this date unless
2159 // the test disabled by the caller
2160 if ( !noDST
&& (IsDST() == 1) )
2162 // FIXME we assume that the DST is always shifted by 1 hour
2166 return Add(wxTimeSpan::Seconds(secDiff
));
2169 wxDateTime
& wxDateTime::MakeFromTimezone(const TimeZone
& tz
, bool noDST
)
2171 long secDiff
= GetTimeZone() + tz
.GetOffset();
2173 // we need to know whether DST is or not in effect for this date unless
2174 // the test disabled by the caller
2175 if ( !noDST
&& (IsDST() == 1) )
2177 // FIXME we assume that the DST is always shifted by 1 hour
2181 return Subtract(wxTimeSpan::Seconds(secDiff
));
2184 // ============================================================================
2185 // wxDateTimeHolidayAuthority and related classes
2186 // ============================================================================
2188 #include "wx/arrimpl.cpp"
2190 WX_DEFINE_OBJARRAY(wxDateTimeArray
)
2192 static int wxCMPFUNC_CONV
2193 wxDateTimeCompareFunc(wxDateTime
**first
, wxDateTime
**second
)
2195 wxDateTime dt1
= **first
,
2198 return dt1
== dt2
? 0 : dt1
< dt2
? -1 : +1;
2201 // ----------------------------------------------------------------------------
2202 // wxDateTimeHolidayAuthority
2203 // ----------------------------------------------------------------------------
2205 wxHolidayAuthoritiesArray
wxDateTimeHolidayAuthority::ms_authorities
;
2208 bool wxDateTimeHolidayAuthority::IsHoliday(const wxDateTime
& dt
)
2210 size_t count
= ms_authorities
.size();
2211 for ( size_t n
= 0; n
< count
; n
++ )
2213 if ( ms_authorities
[n
]->DoIsHoliday(dt
) )
2224 wxDateTimeHolidayAuthority::GetHolidaysInRange(const wxDateTime
& dtStart
,
2225 const wxDateTime
& dtEnd
,
2226 wxDateTimeArray
& holidays
)
2228 wxDateTimeArray hol
;
2232 const size_t countAuth
= ms_authorities
.size();
2233 for ( size_t nAuth
= 0; nAuth
< countAuth
; nAuth
++ )
2235 ms_authorities
[nAuth
]->DoGetHolidaysInRange(dtStart
, dtEnd
, hol
);
2237 WX_APPEND_ARRAY(holidays
, hol
);
2240 holidays
.Sort(wxDateTimeCompareFunc
);
2242 return holidays
.size();
2246 void wxDateTimeHolidayAuthority::ClearAllAuthorities()
2248 WX_CLEAR_ARRAY(ms_authorities
);
2252 void wxDateTimeHolidayAuthority::AddAuthority(wxDateTimeHolidayAuthority
*auth
)
2254 ms_authorities
.push_back(auth
);
2257 wxDateTimeHolidayAuthority::~wxDateTimeHolidayAuthority()
2259 // required here for Darwin
2262 // ----------------------------------------------------------------------------
2263 // wxDateTimeWorkDays
2264 // ----------------------------------------------------------------------------
2266 bool wxDateTimeWorkDays::DoIsHoliday(const wxDateTime
& dt
) const
2268 wxDateTime::WeekDay wd
= dt
.GetWeekDay();
2270 return (wd
== wxDateTime::Sun
) || (wd
== wxDateTime::Sat
);
2273 size_t wxDateTimeWorkDays::DoGetHolidaysInRange(const wxDateTime
& dtStart
,
2274 const wxDateTime
& dtEnd
,
2275 wxDateTimeArray
& holidays
) const
2277 if ( dtStart
> dtEnd
)
2279 wxFAIL_MSG( wxT("invalid date range in GetHolidaysInRange") );
2286 // instead of checking all days, start with the first Sat after dtStart and
2287 // end with the last Sun before dtEnd
2288 wxDateTime dtSatFirst
= dtStart
.GetNextWeekDay(wxDateTime::Sat
),
2289 dtSatLast
= dtEnd
.GetPrevWeekDay(wxDateTime::Sat
),
2290 dtSunFirst
= dtStart
.GetNextWeekDay(wxDateTime::Sun
),
2291 dtSunLast
= dtEnd
.GetPrevWeekDay(wxDateTime::Sun
),
2294 for ( dt
= dtSatFirst
; dt
<= dtSatLast
; dt
+= wxDateSpan::Week() )
2299 for ( dt
= dtSunFirst
; dt
<= dtSunLast
; dt
+= wxDateSpan::Week() )
2304 return holidays
.GetCount();
2307 // ============================================================================
2308 // other helper functions
2309 // ============================================================================
2311 // ----------------------------------------------------------------------------
2312 // iteration helpers: can be used to write a for loop over enum variable like
2314 // for ( m = wxDateTime::Jan; m < wxDateTime::Inv_Month; wxNextMonth(m) )
2315 // ----------------------------------------------------------------------------
2317 WXDLLIMPEXP_BASE
void wxNextMonth(wxDateTime::Month
& m
)
2319 wxASSERT_MSG( m
< wxDateTime::Inv_Month
, wxT("invalid month") );
2321 // no wrapping or the for loop above would never end!
2322 m
= (wxDateTime::Month
)(m
+ 1);
2325 WXDLLIMPEXP_BASE
void wxPrevMonth(wxDateTime::Month
& m
)
2327 wxASSERT_MSG( m
< wxDateTime::Inv_Month
, wxT("invalid month") );
2329 m
= m
== wxDateTime::Jan
? wxDateTime::Inv_Month
2330 : (wxDateTime::Month
)(m
- 1);
2333 WXDLLIMPEXP_BASE
void wxNextWDay(wxDateTime::WeekDay
& wd
)
2335 wxASSERT_MSG( wd
< wxDateTime::Inv_WeekDay
, wxT("invalid week day") );
2337 // no wrapping or the for loop above would never end!
2338 wd
= (wxDateTime::WeekDay
)(wd
+ 1);
2341 WXDLLIMPEXP_BASE
void wxPrevWDay(wxDateTime::WeekDay
& wd
)
2343 wxASSERT_MSG( wd
< wxDateTime::Inv_WeekDay
, wxT("invalid week day") );
2345 wd
= wd
== wxDateTime::Sun
? wxDateTime::Inv_WeekDay
2346 : (wxDateTime::WeekDay
)(wd
- 1);
2351 wxDateTime
& wxDateTime::SetFromMSWSysTime(const SYSTEMTIME
& st
)
2354 static_cast<wxDateTime::Month
>(wxDateTime::Jan
+ st
.wMonth
- 1),
2356 st
.wHour
, st
.wMinute
, st
.wSecond
, st
.wMilliseconds
);
2359 wxDateTime
& wxDateTime::SetFromMSWSysDate(const SYSTEMTIME
& st
)
2362 static_cast<wxDateTime::Month
>(wxDateTime::Jan
+ st
.wMonth
- 1),
2367 void wxDateTime::GetAsMSWSysTime(SYSTEMTIME
* st
) const
2369 const wxDateTime::Tm
tm(GetTm());
2371 st
->wYear
= (WXWORD
)tm
.year
;
2372 st
->wMonth
= (WXWORD
)(tm
.mon
- wxDateTime::Jan
+ 1);
2376 st
->wHour
= tm
.hour
;
2377 st
->wMinute
= tm
.min
;
2378 st
->wSecond
= tm
.sec
;
2379 st
->wMilliseconds
= tm
.msec
;
2382 void wxDateTime::GetAsMSWSysDate(SYSTEMTIME
* st
) const
2384 const wxDateTime::Tm
tm(GetTm());
2386 st
->wYear
= (WXWORD
)tm
.year
;
2387 st
->wMonth
= (WXWORD
)(tm
.mon
- wxDateTime::Jan
+ 1);
2394 st
->wMilliseconds
= 0;
2399 #endif // wxUSE_DATETIME