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(WX_TIMEZONE) && !defined(WX_GMTOFF_IN_TM)
121 #if defined(__WXPALMOS__)
122 #define WX_GMTOFF_IN_TM
123 #elif 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()
137 #define WX_TIMEZONE wxGetTimeZone()
138 #elif defined(__DARWIN__)
139 #define WX_GMTOFF_IN_TM
140 #elif defined(__WXWINCE__) && defined(__VISUALC8__)
141 // _timezone is not present in dynamic run-time library
143 // Solution (1): use the function equivalent of _timezone
144 static long wxGetTimeZone()
150 #define WX_TIMEZONE wxGetTimeZone()
152 // Solution (2): using GetTimeZoneInformation
153 static long wxGetTimeZone()
155 TIME_ZONE_INFORMATION tzi
;
156 ::GetTimeZoneInformation(&tzi
);
157 return tzi
.Bias
; // x 60
159 #define WX_TIMEZONE wxGetTimeZone()
161 // Old method using _timezone: this symbol doesn't exist in the dynamic run-time library (i.e. using /MD)
162 #define WX_TIMEZONE _timezone
164 #else // unknown platform - try timezone
165 #define WX_TIMEZONE timezone
167 #endif // !WX_TIMEZONE && !WX_GMTOFF_IN_TM
169 // NB: VC8 safe time functions could/should be used for wxMSW as well probably
170 #if defined(__WXWINCE__) && defined(__VISUALC8__)
172 struct tm
*wxLocaltime_r(const time_t *t
, struct tm
* tm
)
175 return _localtime64_s(tm
, &t64
) == 0 ? tm
: NULL
;
178 struct tm
*wxGmtime_r(const time_t* t
, struct tm
* tm
)
181 return _gmtime64_s(tm
, &t64
) == 0 ? tm
: NULL
;
184 #else // !wxWinCE with VC8
186 #if (!defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)) && wxUSE_THREADS && !defined(__WINDOWS__)
187 static wxMutex timeLock
;
190 #ifndef HAVE_LOCALTIME_R
191 struct tm
*wxLocaltime_r(const time_t* ticks
, struct tm
* temp
)
193 #if wxUSE_THREADS && !defined(__WINDOWS__)
194 // No need to waste time with a mutex on windows since it's using
195 // thread local storage for localtime anyway.
196 wxMutexLocker
locker(timeLock
);
199 // Borland CRT crashes when passed 0 ticks for some reason, see SF bug 1704438
205 const tm
* const t
= localtime(ticks
);
209 memcpy(temp
, t
, sizeof(struct tm
));
212 #endif // !HAVE_LOCALTIME_R
214 #ifndef HAVE_GMTIME_R
215 struct tm
*wxGmtime_r(const time_t* ticks
, struct tm
* temp
)
217 #if wxUSE_THREADS && !defined(__WINDOWS__)
218 // No need to waste time with a mutex on windows since it's
219 // using thread local storage for gmtime anyway.
220 wxMutexLocker
locker(timeLock
);
228 const tm
* const t
= gmtime(ticks
);
232 memcpy(temp
, gmtime(ticks
), sizeof(struct tm
));
235 #endif // !HAVE_GMTIME_R
237 #endif // wxWinCE with VC8/other platforms
239 // ----------------------------------------------------------------------------
241 // ----------------------------------------------------------------------------
243 // debugging helper: just a convenient replacement of wxCHECK()
244 #define wxDATETIME_CHECK(expr, msg) \
245 wxCHECK2_MSG(expr, *this = wxInvalidDateTime; return *this, msg)
247 // ----------------------------------------------------------------------------
249 // ----------------------------------------------------------------------------
251 class wxDateTimeHolidaysModule
: public wxModule
254 virtual bool OnInit()
256 wxDateTimeHolidayAuthority::AddAuthority(new wxDateTimeWorkDays
);
261 virtual void OnExit()
263 wxDateTimeHolidayAuthority::ClearAllAuthorities();
264 wxDateTimeHolidayAuthority::ms_authorities
.clear();
268 DECLARE_DYNAMIC_CLASS(wxDateTimeHolidaysModule
)
271 IMPLEMENT_DYNAMIC_CLASS(wxDateTimeHolidaysModule
, wxModule
)
273 // ----------------------------------------------------------------------------
275 // ----------------------------------------------------------------------------
278 static const int MONTHS_IN_YEAR
= 12;
280 static const int SEC_PER_MIN
= 60;
282 static const int MIN_PER_HOUR
= 60;
284 static const int HOURS_PER_DAY
= 24;
286 static const long SECONDS_PER_DAY
= 86400l;
288 static const int DAYS_PER_WEEK
= 7;
290 static const long MILLISECONDS_PER_DAY
= 86400000l;
292 // this is the integral part of JDN of the midnight of Jan 1, 1970
293 // (i.e. JDN(Jan 1, 1970) = 2440587.5)
294 static const long EPOCH_JDN
= 2440587l;
296 // these values are only used in asserts so don't define them if asserts are
297 // disabled to avoid warnings about unused static variables
299 // the date of JDN -0.5 (as we don't work with fractional parts, this is the
300 // reference date for us) is Nov 24, 4714BC
301 static const int JDN_0_YEAR
= -4713;
302 static const int JDN_0_MONTH
= wxDateTime::Nov
;
303 static const int JDN_0_DAY
= 24;
304 #endif // wxDEBUG_LEVEL
306 // the constants used for JDN calculations
307 static const long JDN_OFFSET
= 32046l;
308 static const long DAYS_PER_5_MONTHS
= 153l;
309 static const long DAYS_PER_4_YEARS
= 1461l;
310 static const long DAYS_PER_400_YEARS
= 146097l;
312 // this array contains the cumulated number of days in all previous months for
313 // normal and leap years
314 static const wxDateTime::wxDateTime_t gs_cumulatedDays
[2][MONTHS_IN_YEAR
] =
316 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
317 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
320 const long wxDateTime::TIME_T_FACTOR
= 1000l;
322 // ----------------------------------------------------------------------------
324 // ----------------------------------------------------------------------------
326 const char wxDefaultDateTimeFormat
[] = "%c";
327 const char wxDefaultTimeSpanFormat
[] = "%H:%M:%S";
329 // in the fine tradition of ANSI C we use our equivalent of (time_t)-1 to
330 // indicate an invalid wxDateTime object
331 const wxDateTime wxDefaultDateTime
;
333 wxDateTime::Country
wxDateTime::ms_country
= wxDateTime::Country_Unknown
;
335 // ----------------------------------------------------------------------------
337 // ----------------------------------------------------------------------------
339 // debugger helper: this function can be called from a debugger to show what
340 // the date really is
341 extern const char *wxDumpDate(const wxDateTime
* dt
)
343 static char buf
[128];
345 wxString
fmt(dt
->Format("%Y-%m-%d (%a) %H:%M:%S"));
347 (fmt
+ " (" + dt
->GetValue().ToString() + " ticks)").ToAscii(),
353 // get the number of days in the given month of the given year
355 wxDateTime::wxDateTime_t
GetNumOfDaysInMonth(int year
, wxDateTime::Month month
)
357 // the number of days in month in Julian/Gregorian calendar: the first line
358 // is for normal years, the second one is for the leap ones
359 static const wxDateTime::wxDateTime_t daysInMonth
[2][MONTHS_IN_YEAR
] =
361 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
362 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
365 return daysInMonth
[wxDateTime::IsLeapYear(year
)][month
];
368 // returns the time zone in the C sense, i.e. the difference UTC - local
370 // NOTE: not static because used by datetimefmt.cpp
373 #ifdef WX_GMTOFF_IN_TM
374 // set to true when the timezone is set
375 static bool s_timezoneSet
= false;
376 static long gmtoffset
= LONG_MAX
; // invalid timezone
378 // ensure that the timezone variable is set by calling wxLocaltime_r
379 if ( !s_timezoneSet
)
381 // just call wxLocaltime_r() instead of figuring out whether this
382 // system supports tzset(), _tzset() or something else
386 wxLocaltime_r(&t
, &tm
);
387 s_timezoneSet
= true;
389 // note that GMT offset is the opposite of time zone and so to return
390 // consistent results in both WX_GMTOFF_IN_TM and !WX_GMTOFF_IN_TM
391 // cases we have to negate it
392 gmtoffset
= -tm
.tm_gmtoff
;
394 return (int)gmtoffset
;
395 #else // !WX_GMTOFF_IN_TM
397 #endif // WX_GMTOFF_IN_TM/!WX_GMTOFF_IN_TM
400 // return the integral part of the JDN for the midnight of the given date (to
401 // get the real JDN you need to add 0.5, this is, in fact, JDN of the
402 // noon of the previous day)
403 static long GetTruncatedJDN(wxDateTime::wxDateTime_t day
,
404 wxDateTime::Month mon
,
407 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
409 // check the date validity
411 (year
> JDN_0_YEAR
) ||
412 ((year
== JDN_0_YEAR
) && (mon
> JDN_0_MONTH
)) ||
413 ((year
== JDN_0_YEAR
) && (mon
== JDN_0_MONTH
) && (day
>= JDN_0_DAY
)),
414 wxT("date out of range - can't convert to JDN")
417 // make the year positive to avoid problems with negative numbers division
420 // months are counted from March here
422 if ( mon
>= wxDateTime::Mar
)
432 // now we can simply add all the contributions together
433 return ((year
/ 100) * DAYS_PER_400_YEARS
) / 4
434 + ((year
% 100) * DAYS_PER_4_YEARS
) / 4
435 + (month
* DAYS_PER_5_MONTHS
+ 2) / 5
440 #ifdef wxHAS_STRFTIME
442 // this function is a wrapper around strftime(3) adding error checking
443 // NOTE: not static because used by datetimefmt.cpp
444 wxString
CallStrftime(const wxString
& format
, const tm
* tm
)
447 // Create temp wxString here to work around mingw/cygwin bug 1046059
448 // http://sourceforge.net/tracker/?func=detail&atid=102435&aid=1046059&group_id=2435
451 if ( !wxStrftime(buf
, WXSIZEOF(buf
), format
, tm
) )
453 // if the format is valid, buffer must be too small?
454 wxFAIL_MSG(wxT("strftime() failed"));
463 #endif // wxHAS_STRFTIME
465 // if year and/or month have invalid values, replace them with the current ones
466 static void ReplaceDefaultYearMonthWithCurrent(int *year
,
467 wxDateTime::Month
*month
)
469 struct tm
*tmNow
= NULL
;
472 if ( *year
== wxDateTime::Inv_Year
)
474 tmNow
= wxDateTime::GetTmNow(&tmstruct
);
476 *year
= 1900 + tmNow
->tm_year
;
479 if ( *month
== wxDateTime::Inv_Month
)
482 tmNow
= wxDateTime::GetTmNow(&tmstruct
);
484 *month
= (wxDateTime::Month
)tmNow
->tm_mon
;
488 // fill the struct tm with default values
489 // NOTE: not static because used by datetimefmt.cpp
490 void InitTm(struct tm
& tm
)
492 // struct tm may have etxra fields (undocumented and with unportable
493 // names) which, nevertheless, must be set to 0
494 memset(&tm
, 0, sizeof(struct tm
));
496 tm
.tm_mday
= 1; // mday 0 is invalid
497 tm
.tm_year
= 76; // any valid year
498 tm
.tm_isdst
= -1; // auto determine
501 // ============================================================================
502 // implementation of wxDateTime
503 // ============================================================================
505 // ----------------------------------------------------------------------------
507 // ----------------------------------------------------------------------------
511 year
= (wxDateTime_t
)wxDateTime::Inv_Year
;
512 mon
= wxDateTime::Inv_Month
;
514 hour
= min
= sec
= msec
= 0;
515 wday
= wxDateTime::Inv_WeekDay
;
518 wxDateTime::Tm::Tm(const struct tm
& tm
, const TimeZone
& tz
)
522 sec
= (wxDateTime::wxDateTime_t
)tm
.tm_sec
;
523 min
= (wxDateTime::wxDateTime_t
)tm
.tm_min
;
524 hour
= (wxDateTime::wxDateTime_t
)tm
.tm_hour
;
525 mday
= (wxDateTime::wxDateTime_t
)tm
.tm_mday
;
526 mon
= (wxDateTime::Month
)tm
.tm_mon
;
527 year
= 1900 + tm
.tm_year
;
528 wday
= (wxDateTime::wxDateTime_t
)tm
.tm_wday
;
529 yday
= (wxDateTime::wxDateTime_t
)tm
.tm_yday
;
532 bool wxDateTime::Tm::IsValid() const
534 // we allow for the leap seconds, although we don't use them (yet)
535 return (year
!= wxDateTime::Inv_Year
) && (mon
!= wxDateTime::Inv_Month
) &&
536 (mday
<= GetNumOfDaysInMonth(year
, mon
)) &&
537 (hour
< 24) && (min
< 60) && (sec
< 62) && (msec
< 1000);
540 void wxDateTime::Tm::ComputeWeekDay()
542 // compute the week day from day/month/year: we use the dumbest algorithm
543 // possible: just compute our JDN and then use the (simple to derive)
544 // formula: weekday = (JDN + 1.5) % 7
545 wday
= (wxDateTime::wxDateTime_t
)((GetTruncatedJDN(mday
, mon
, year
) + 2) % 7);
548 void wxDateTime::Tm::AddMonths(int monDiff
)
550 // normalize the months field
551 while ( monDiff
< -mon
)
555 monDiff
+= MONTHS_IN_YEAR
;
558 while ( monDiff
+ mon
>= MONTHS_IN_YEAR
)
562 monDiff
-= MONTHS_IN_YEAR
;
565 mon
= (wxDateTime::Month
)(mon
+ monDiff
);
567 wxASSERT_MSG( mon
>= 0 && mon
< MONTHS_IN_YEAR
, wxT("logic error") );
569 // NB: we don't check here that the resulting date is valid, this function
570 // is private and the caller must check it if needed
573 void wxDateTime::Tm::AddDays(int dayDiff
)
575 // normalize the days field
576 while ( dayDiff
+ mday
< 1 )
580 dayDiff
+= GetNumOfDaysInMonth(year
, mon
);
583 mday
= (wxDateTime::wxDateTime_t
)( mday
+ dayDiff
);
584 while ( mday
> GetNumOfDaysInMonth(year
, mon
) )
586 mday
-= GetNumOfDaysInMonth(year
, mon
);
591 wxASSERT_MSG( mday
> 0 && mday
<= GetNumOfDaysInMonth(year
, mon
),
592 wxT("logic error") );
595 // ----------------------------------------------------------------------------
597 // ----------------------------------------------------------------------------
599 wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz
)
603 case wxDateTime::Local
:
604 // get the offset from C RTL: it returns the difference GMT-local
605 // while we want to have the offset _from_ GMT, hence the '-'
606 m_offset
= -GetTimeZone();
609 case wxDateTime::GMT_12
:
610 case wxDateTime::GMT_11
:
611 case wxDateTime::GMT_10
:
612 case wxDateTime::GMT_9
:
613 case wxDateTime::GMT_8
:
614 case wxDateTime::GMT_7
:
615 case wxDateTime::GMT_6
:
616 case wxDateTime::GMT_5
:
617 case wxDateTime::GMT_4
:
618 case wxDateTime::GMT_3
:
619 case wxDateTime::GMT_2
:
620 case wxDateTime::GMT_1
:
621 m_offset
= -3600*(wxDateTime::GMT0
- tz
);
624 case wxDateTime::GMT0
:
625 case wxDateTime::GMT1
:
626 case wxDateTime::GMT2
:
627 case wxDateTime::GMT3
:
628 case wxDateTime::GMT4
:
629 case wxDateTime::GMT5
:
630 case wxDateTime::GMT6
:
631 case wxDateTime::GMT7
:
632 case wxDateTime::GMT8
:
633 case wxDateTime::GMT9
:
634 case wxDateTime::GMT10
:
635 case wxDateTime::GMT11
:
636 case wxDateTime::GMT12
:
637 case wxDateTime::GMT13
:
638 m_offset
= 3600*(tz
- wxDateTime::GMT0
);
641 case wxDateTime::A_CST
:
642 // Central Standard Time in use in Australia = UTC + 9.5
643 m_offset
= 60l*(9*MIN_PER_HOUR
+ MIN_PER_HOUR
/2);
647 wxFAIL_MSG( wxT("unknown time zone") );
651 // ----------------------------------------------------------------------------
653 // ----------------------------------------------------------------------------
656 struct tm
*wxDateTime::GetTmNow(struct tm
*tmstruct
)
658 time_t t
= GetTimeNow();
659 return wxLocaltime_r(&t
, tmstruct
);
663 bool wxDateTime::IsLeapYear(int year
, wxDateTime::Calendar cal
)
665 if ( year
== Inv_Year
)
666 year
= GetCurrentYear();
668 if ( cal
== Gregorian
)
670 // in Gregorian calendar leap years are those divisible by 4 except
671 // those divisible by 100 unless they're also divisible by 400
672 // (in some countries, like Russia and Greece, additional corrections
673 // exist, but they won't manifest themselves until 2700)
674 return (year
% 4 == 0) && ((year
% 100 != 0) || (year
% 400 == 0));
676 else if ( cal
== Julian
)
678 // in Julian calendar the rule is simpler
679 return year
% 4 == 0;
683 wxFAIL_MSG(wxT("unknown calendar"));
690 int wxDateTime::GetCentury(int year
)
692 return year
> 0 ? year
/ 100 : year
/ 100 - 1;
696 int wxDateTime::ConvertYearToBC(int year
)
699 return year
> 0 ? year
: year
- 1;
703 int wxDateTime::GetCurrentYear(wxDateTime::Calendar cal
)
708 return Now().GetYear();
711 wxFAIL_MSG(wxT("TODO"));
715 wxFAIL_MSG(wxT("unsupported calendar"));
723 wxDateTime::Month
wxDateTime::GetCurrentMonth(wxDateTime::Calendar cal
)
728 return Now().GetMonth();
731 wxFAIL_MSG(wxT("TODO"));
735 wxFAIL_MSG(wxT("unsupported calendar"));
743 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(int year
, Calendar cal
)
745 if ( year
== Inv_Year
)
747 // take the current year if none given
748 year
= GetCurrentYear();
755 return IsLeapYear(year
) ? 366 : 365;
758 wxFAIL_MSG(wxT("unsupported calendar"));
766 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(wxDateTime::Month month
,
768 wxDateTime::Calendar cal
)
770 wxCHECK_MSG( month
< MONTHS_IN_YEAR
, 0, wxT("invalid month") );
772 if ( cal
== Gregorian
|| cal
== Julian
)
774 if ( year
== Inv_Year
)
776 // take the current year if none given
777 year
= GetCurrentYear();
780 return GetNumOfDaysInMonth(year
, month
);
784 wxFAIL_MSG(wxT("unsupported calendar"));
793 // helper function used by GetEnglish/WeekDayName(): returns 0 if flags is
794 // Name_Full and 1 if it is Name_Abbr or -1 if the flags is incorrect (and
795 // asserts in this case)
797 // the return value of this function is used as an index into 2D array
798 // containing full names in its first row and abbreviated ones in the 2nd one
799 int NameArrayIndexFromFlag(wxDateTime::NameFlags flags
)
803 case wxDateTime::Name_Full
:
806 case wxDateTime::Name_Abbr
:
810 wxFAIL_MSG( "unknown wxDateTime::NameFlags value" );
816 } // anonymous namespace
819 wxString
wxDateTime::GetEnglishMonthName(Month month
, NameFlags flags
)
821 wxCHECK_MSG( month
!= Inv_Month
, wxEmptyString
, "invalid month" );
823 static const char *const monthNames
[2][MONTHS_IN_YEAR
] =
825 { "January", "February", "March", "April", "May", "June",
826 "July", "August", "September", "October", "November", "December" },
827 { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
828 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }
831 const int idx
= NameArrayIndexFromFlag(flags
);
835 return monthNames
[idx
][month
];
839 wxString
wxDateTime::GetMonthName(wxDateTime::Month month
,
840 wxDateTime::NameFlags flags
)
842 #ifdef wxHAS_STRFTIME
843 wxCHECK_MSG( month
!= Inv_Month
, wxEmptyString
, wxT("invalid month") );
845 // notice that we must set all the fields to avoid confusing libc (GNU one
846 // gets confused to a crash if we don't do this)
851 return CallStrftime(flags
== Name_Abbr
? wxT("%b") : wxT("%B"), &tm
);
852 #else // !wxHAS_STRFTIME
853 return GetEnglishMonthName(month
, flags
);
854 #endif // wxHAS_STRFTIME/!wxHAS_STRFTIME
858 wxString
wxDateTime::GetEnglishWeekDayName(WeekDay wday
, NameFlags flags
)
860 wxCHECK_MSG( wday
!= Inv_WeekDay
, wxEmptyString
, wxT("invalid weekday") );
862 static const char *const weekdayNames
[2][DAYS_PER_WEEK
] =
864 { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday",
866 { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" },
869 const int idx
= NameArrayIndexFromFlag(flags
);
873 return weekdayNames
[idx
][wday
];
877 wxString
wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday
,
878 wxDateTime::NameFlags flags
)
880 #ifdef wxHAS_STRFTIME
881 wxCHECK_MSG( wday
!= Inv_WeekDay
, wxEmptyString
, wxT("invalid weekday") );
883 // take some arbitrary Sunday (but notice that the day should be such that
884 // after adding wday to it below we still have a valid date, e.g. don't
892 // and offset it by the number of days needed to get the correct wday
895 // call mktime() to normalize it...
898 // ... and call strftime()
899 return CallStrftime(flags
== Name_Abbr
? wxT("%a") : wxT("%A"), &tm
);
900 #else // !wxHAS_STRFTIME
901 return GetEnglishWeekDayName(wday
, flags
);
902 #endif // wxHAS_STRFTIME/!wxHAS_STRFTIME
906 void wxDateTime::GetAmPmStrings(wxString
*am
, wxString
*pm
)
911 // @Note: Do not call 'CallStrftime' here! CallStrftime checks the return code
912 // and causes an assertion failed if the buffer is to small (which is good) - OR -
913 // if strftime does not return anything because the format string is invalid - OR -
914 // if there are no 'am' / 'pm' tokens defined for the current locale (which is not good).
915 // wxDateTime::ParseTime will try several different formats to parse the time.
916 // As a result, GetAmPmStrings might get called, even if the current locale
917 // does not define any 'am' / 'pm' tokens. In this case, wxStrftime would
918 // assert, even though it is a perfectly legal use.
921 if (wxStrftime(buffer
, WXSIZEOF(buffer
), wxT("%p"), &tm
) > 0)
922 *am
= wxString(buffer
);
929 if (wxStrftime(buffer
, WXSIZEOF(buffer
), wxT("%p"), &tm
) > 0)
930 *pm
= wxString(buffer
);
937 // ----------------------------------------------------------------------------
938 // Country stuff: date calculations depend on the country (DST, work days,
939 // ...), so we need to know which rules to follow.
940 // ----------------------------------------------------------------------------
943 wxDateTime::Country
wxDateTime::GetCountry()
945 // TODO use LOCALE_ICOUNTRY setting under Win32
947 if ( ms_country
== Country_Unknown
)
949 // try to guess from the time zone name
950 time_t t
= time(NULL
);
952 struct tm
*tm
= wxLocaltime_r(&t
, &tmstruct
);
954 wxString tz
= CallStrftime(wxT("%Z"), tm
);
955 if ( tz
== wxT("WET") || tz
== wxT("WEST") )
959 else if ( tz
== wxT("CET") || tz
== wxT("CEST") )
961 ms_country
= Country_EEC
;
963 else if ( tz
== wxT("MSK") || tz
== wxT("MSD") )
967 else if ( tz
== wxT("AST") || tz
== wxT("ADT") ||
968 tz
== wxT("EST") || tz
== wxT("EDT") ||
969 tz
== wxT("CST") || tz
== wxT("CDT") ||
970 tz
== wxT("MST") || tz
== wxT("MDT") ||
971 tz
== wxT("PST") || tz
== wxT("PDT") )
977 // well, choose a default one
983 #endif // !__WXWINCE__/__WXWINCE__
989 void wxDateTime::SetCountry(wxDateTime::Country country
)
991 ms_country
= country
;
995 bool wxDateTime::IsWestEuropeanCountry(Country country
)
997 if ( country
== Country_Default
)
999 country
= GetCountry();
1002 return (Country_WesternEurope_Start
<= country
) &&
1003 (country
<= Country_WesternEurope_End
);
1006 // ----------------------------------------------------------------------------
1007 // DST calculations: we use 3 different rules for the West European countries,
1008 // USA and for the rest of the world. This is undoubtedly false for many
1009 // countries, but I lack the necessary info (and the time to gather it),
1010 // please add the other rules here!
1011 // ----------------------------------------------------------------------------
1014 bool wxDateTime::IsDSTApplicable(int year
, Country country
)
1016 if ( year
== Inv_Year
)
1018 // take the current year if none given
1019 year
= GetCurrentYear();
1022 if ( country
== Country_Default
)
1024 country
= GetCountry();
1031 // DST was first observed in the US and UK during WWI, reused
1032 // during WWII and used again since 1966
1033 return year
>= 1966 ||
1034 (year
>= 1942 && year
<= 1945) ||
1035 (year
== 1918 || year
== 1919);
1038 // assume that it started after WWII
1044 wxDateTime
wxDateTime::GetBeginDST(int year
, Country country
)
1046 if ( year
== Inv_Year
)
1048 // take the current year if none given
1049 year
= GetCurrentYear();
1052 if ( country
== Country_Default
)
1054 country
= GetCountry();
1057 if ( !IsDSTApplicable(year
, country
) )
1059 return wxInvalidDateTime
;
1064 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
1066 // DST begins at 1 a.m. GMT on the last Sunday of March
1067 if ( !dt
.SetToLastWeekDay(Sun
, Mar
, year
) )
1070 wxFAIL_MSG( wxT("no last Sunday in March?") );
1073 dt
+= wxTimeSpan::Hours(1);
1075 else switch ( country
)
1082 // don't know for sure - assume it was in effect all year
1087 dt
.Set(1, Jan
, year
);
1091 // DST was installed Feb 2, 1942 by the Congress
1092 dt
.Set(2, Feb
, year
);
1095 // Oil embargo changed the DST period in the US
1097 dt
.Set(6, Jan
, 1974);
1101 dt
.Set(23, Feb
, 1975);
1105 // before 1986, DST begun on the last Sunday of April, but
1106 // in 1986 Reagan changed it to begin at 2 a.m. of the
1107 // first Sunday in April
1110 if ( !dt
.SetToLastWeekDay(Sun
, Apr
, year
) )
1113 wxFAIL_MSG( wxT("no first Sunday in April?") );
1116 else if ( year
> 2006 )
1117 // Energy Policy Act of 2005, Pub. L. no. 109-58, 119 Stat 594 (2005).
1118 // Starting in 2007, daylight time begins in the United States on the
1119 // second Sunday in March and ends on the first Sunday in November
1121 if ( !dt
.SetToWeekDay(Sun
, 2, Mar
, year
) )
1124 wxFAIL_MSG( wxT("no second Sunday in March?") );
1129 if ( !dt
.SetToWeekDay(Sun
, 1, Apr
, year
) )
1132 wxFAIL_MSG( wxT("no first Sunday in April?") );
1136 dt
+= wxTimeSpan::Hours(2);
1138 // TODO what about timezone??
1144 // assume Mar 30 as the start of the DST for the rest of the world
1145 // - totally bogus, of course
1146 dt
.Set(30, Mar
, year
);
1153 wxDateTime
wxDateTime::GetEndDST(int year
, Country country
)
1155 if ( year
== Inv_Year
)
1157 // take the current year if none given
1158 year
= GetCurrentYear();
1161 if ( country
== Country_Default
)
1163 country
= GetCountry();
1166 if ( !IsDSTApplicable(year
, country
) )
1168 return wxInvalidDateTime
;
1173 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
1175 // DST ends at 1 a.m. GMT on the last Sunday of October
1176 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1178 // weirder and weirder...
1179 wxFAIL_MSG( wxT("no last Sunday in October?") );
1182 dt
+= wxTimeSpan::Hours(1);
1184 else switch ( country
)
1191 // don't know for sure - assume it was in effect all year
1195 dt
.Set(31, Dec
, year
);
1199 // the time was reset after the end of the WWII
1200 dt
.Set(30, Sep
, year
);
1203 default: // default for switch (year)
1205 // Energy Policy Act of 2005, Pub. L. no. 109-58, 119 Stat 594 (2005).
1206 // Starting in 2007, daylight time begins in the United States on the
1207 // second Sunday in March and ends on the first Sunday in November
1209 if ( !dt
.SetToWeekDay(Sun
, 1, Nov
, year
) )
1212 wxFAIL_MSG( wxT("no first Sunday in November?") );
1217 // DST ends at 2 a.m. on the last Sunday of October
1219 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1221 // weirder and weirder...
1222 wxFAIL_MSG( wxT("no last Sunday in October?") );
1226 dt
+= wxTimeSpan::Hours(2);
1228 // TODO: what about timezone??
1232 default: // default for switch (country)
1233 // assume October 26th as the end of the DST - totally bogus too
1234 dt
.Set(26, Oct
, year
);
1240 // ----------------------------------------------------------------------------
1241 // constructors and assignment operators
1242 // ----------------------------------------------------------------------------
1244 // return the current time with ms precision
1245 /* static */ wxDateTime
wxDateTime::UNow()
1247 return wxDateTime(wxGetLocalTimeMillis());
1250 // the values in the tm structure contain the local time
1251 wxDateTime
& wxDateTime::Set(const struct tm
& tm
)
1254 time_t timet
= mktime(&tm2
);
1256 if ( timet
== (time_t)-1 )
1258 // mktime() rather unintuitively fails for Jan 1, 1970 if the hour is
1259 // less than timezone - try to make it work for this case
1260 if ( tm2
.tm_year
== 70 && tm2
.tm_mon
== 0 && tm2
.tm_mday
== 1 )
1262 return Set((time_t)(
1264 tm2
.tm_hour
* MIN_PER_HOUR
* SEC_PER_MIN
+
1265 tm2
.tm_min
* SEC_PER_MIN
+
1269 wxFAIL_MSG( wxT("mktime() failed") );
1271 *this = wxInvalidDateTime
;
1281 wxDateTime
& wxDateTime::Set(wxDateTime_t hour
,
1282 wxDateTime_t minute
,
1283 wxDateTime_t second
,
1284 wxDateTime_t millisec
)
1286 // we allow seconds to be 61 to account for the leap seconds, even if we
1287 // don't use them really
1288 wxDATETIME_CHECK( hour
< 24 &&
1292 wxT("Invalid time in wxDateTime::Set()") );
1294 // get the current date from system
1296 struct tm
*tm
= GetTmNow(&tmstruct
);
1298 wxDATETIME_CHECK( tm
, wxT("wxLocaltime_r() failed") );
1300 // make a copy so it isn't clobbered by the call to mktime() below
1305 tm1
.tm_min
= minute
;
1306 tm1
.tm_sec
= second
;
1308 // and the DST in case it changes on this date
1311 if ( tm2
.tm_isdst
!= tm1
.tm_isdst
)
1312 tm1
.tm_isdst
= tm2
.tm_isdst
;
1316 // and finally adjust milliseconds
1317 return SetMillisecond(millisec
);
1320 wxDateTime
& wxDateTime::Set(wxDateTime_t day
,
1324 wxDateTime_t minute
,
1325 wxDateTime_t second
,
1326 wxDateTime_t millisec
)
1328 wxDATETIME_CHECK( hour
< 24 &&
1332 wxT("Invalid time in wxDateTime::Set()") );
1334 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1336 wxDATETIME_CHECK( (0 < day
) && (day
<= GetNumberOfDays(month
, year
)),
1337 wxT("Invalid date in wxDateTime::Set()") );
1339 // the range of time_t type (inclusive)
1340 static const int yearMinInRange
= 1970;
1341 static const int yearMaxInRange
= 2037;
1343 // test only the year instead of testing for the exact end of the Unix
1344 // time_t range - it doesn't bring anything to do more precise checks
1345 if ( year
>= yearMinInRange
&& year
<= yearMaxInRange
)
1347 // use the standard library version if the date is in range - this is
1348 // probably more efficient than our code
1350 tm
.tm_year
= year
- 1900;
1356 tm
.tm_isdst
= -1; // mktime() will guess it
1360 // and finally adjust milliseconds
1362 SetMillisecond(millisec
);
1368 // do time calculations ourselves: we want to calculate the number of
1369 // milliseconds between the given date and the epoch
1371 // get the JDN for the midnight of this day
1372 m_time
= GetTruncatedJDN(day
, month
, year
);
1373 m_time
-= EPOCH_JDN
;
1374 m_time
*= SECONDS_PER_DAY
* TIME_T_FACTOR
;
1376 // JDN corresponds to GMT, we take localtime
1377 Add(wxTimeSpan(hour
, minute
, second
+ GetTimeZone(), millisec
));
1383 wxDateTime
& wxDateTime::Set(double jdn
)
1385 // so that m_time will be 0 for the midnight of Jan 1, 1970 which is jdn
1387 jdn
-= EPOCH_JDN
+ 0.5;
1389 m_time
.Assign(jdn
*MILLISECONDS_PER_DAY
);
1391 // JDNs always are in UTC, so we don't need any adjustments for time zone
1396 wxDateTime
& wxDateTime::ResetTime()
1400 if ( tm
.hour
|| tm
.min
|| tm
.sec
|| tm
.msec
)
1413 wxDateTime
wxDateTime::GetDateOnly() const
1420 return wxDateTime(tm
);
1423 // ----------------------------------------------------------------------------
1424 // DOS Date and Time Format functions
1425 // ----------------------------------------------------------------------------
1426 // the dos date and time value is an unsigned 32 bit value in the format:
1427 // YYYYYYYMMMMDDDDDhhhhhmmmmmmsssss
1429 // Y = year offset from 1980 (0-127)
1431 // D = day of month (1-31)
1433 // m = minute (0-59)
1434 // s = bisecond (0-29) each bisecond indicates two seconds
1435 // ----------------------------------------------------------------------------
1437 wxDateTime
& wxDateTime::SetFromDOS(unsigned long ddt
)
1442 long year
= ddt
& 0xFE000000;
1447 long month
= ddt
& 0x1E00000;
1452 long day
= ddt
& 0x1F0000;
1456 long hour
= ddt
& 0xF800;
1460 long minute
= ddt
& 0x7E0;
1464 long second
= ddt
& 0x1F;
1465 tm
.tm_sec
= second
* 2;
1467 return Set(mktime(&tm
));
1470 unsigned long wxDateTime::GetAsDOS() const
1473 time_t ticks
= GetTicks();
1475 struct tm
*tm
= wxLocaltime_r(&ticks
, &tmstruct
);
1476 wxCHECK_MSG( tm
, ULONG_MAX
, wxT("time can't be represented in DOS format") );
1478 long year
= tm
->tm_year
;
1482 long month
= tm
->tm_mon
;
1486 long day
= tm
->tm_mday
;
1489 long hour
= tm
->tm_hour
;
1492 long minute
= tm
->tm_min
;
1495 long second
= tm
->tm_sec
;
1498 ddt
= year
| month
| day
| hour
| minute
| second
;
1502 // ----------------------------------------------------------------------------
1503 // time_t <-> broken down time conversions
1504 // ----------------------------------------------------------------------------
1506 wxDateTime::Tm
wxDateTime::GetTm(const TimeZone
& tz
) const
1508 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1510 time_t time
= GetTicks();
1511 if ( time
!= (time_t)-1 )
1513 // use C RTL functions
1516 if ( tz
.GetOffset() == -GetTimeZone() )
1518 // we are working with local time
1519 tm
= wxLocaltime_r(&time
, &tmstruct
);
1521 // should never happen
1522 wxCHECK_MSG( tm
, Tm(), wxT("wxLocaltime_r() failed") );
1526 time
+= (time_t)tz
.GetOffset();
1527 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
1528 int time2
= (int) time
;
1534 tm
= wxGmtime_r(&time
, &tmstruct
);
1536 // should never happen
1537 wxCHECK_MSG( tm
, Tm(), wxT("wxGmtime_r() failed") );
1541 tm
= (struct tm
*)NULL
;
1547 // adjust the milliseconds
1549 long timeOnly
= (m_time
% MILLISECONDS_PER_DAY
).ToLong();
1550 tm2
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1553 //else: use generic code below
1556 // remember the time and do the calculations with the date only - this
1557 // eliminates rounding errors of the floating point arithmetics
1559 wxLongLong timeMidnight
= m_time
+ tz
.GetOffset() * 1000;
1561 long timeOnly
= (timeMidnight
% MILLISECONDS_PER_DAY
).ToLong();
1563 // we want to always have positive time and timeMidnight to be really
1564 // the midnight before it
1567 timeOnly
= MILLISECONDS_PER_DAY
+ timeOnly
;
1570 timeMidnight
-= timeOnly
;
1572 // calculate the Gregorian date from JDN for the midnight of our date:
1573 // this will yield day, month (in 1..12 range) and year
1575 // actually, this is the JDN for the noon of the previous day
1576 long jdn
= (timeMidnight
/ MILLISECONDS_PER_DAY
).ToLong() + EPOCH_JDN
;
1578 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
1580 wxASSERT_MSG( jdn
> -2, wxT("JDN out of range") );
1582 // calculate the century
1583 long temp
= (jdn
+ JDN_OFFSET
) * 4 - 1;
1584 long century
= temp
/ DAYS_PER_400_YEARS
;
1586 // then the year and day of year (1 <= dayOfYear <= 366)
1587 temp
= ((temp
% DAYS_PER_400_YEARS
) / 4) * 4 + 3;
1588 long year
= (century
* 100) + (temp
/ DAYS_PER_4_YEARS
);
1589 long dayOfYear
= (temp
% DAYS_PER_4_YEARS
) / 4 + 1;
1591 // and finally the month and day of the month
1592 temp
= dayOfYear
* 5 - 3;
1593 long month
= temp
/ DAYS_PER_5_MONTHS
;
1594 long day
= (temp
% DAYS_PER_5_MONTHS
) / 5 + 1;
1596 // month is counted from March - convert to normal
1607 // year is offset by 4800
1610 // check that the algorithm gave us something reasonable
1611 wxASSERT_MSG( (0 < month
) && (month
<= 12), wxT("invalid month") );
1612 wxASSERT_MSG( (1 <= day
) && (day
< 32), wxT("invalid day") );
1614 // construct Tm from these values
1616 tm
.year
= (int)year
;
1617 tm
.mon
= (Month
)(month
- 1); // algorithm yields 1 for January, not 0
1618 tm
.mday
= (wxDateTime_t
)day
;
1619 tm
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1620 timeOnly
-= tm
.msec
;
1621 timeOnly
/= 1000; // now we have time in seconds
1623 tm
.sec
= (wxDateTime_t
)(timeOnly
% SEC_PER_MIN
);
1625 timeOnly
/= SEC_PER_MIN
; // now we have time in minutes
1627 tm
.min
= (wxDateTime_t
)(timeOnly
% MIN_PER_HOUR
);
1630 tm
.hour
= (wxDateTime_t
)(timeOnly
/ MIN_PER_HOUR
);
1635 wxDateTime
& wxDateTime::SetYear(int year
)
1637 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1646 wxDateTime
& wxDateTime::SetMonth(Month month
)
1648 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1657 wxDateTime
& wxDateTime::SetDay(wxDateTime_t mday
)
1659 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1668 wxDateTime
& wxDateTime::SetHour(wxDateTime_t hour
)
1670 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1679 wxDateTime
& wxDateTime::SetMinute(wxDateTime_t min
)
1681 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1690 wxDateTime
& wxDateTime::SetSecond(wxDateTime_t sec
)
1692 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1701 wxDateTime
& wxDateTime::SetMillisecond(wxDateTime_t millisecond
)
1703 wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1705 // we don't need to use GetTm() for this one
1706 m_time
-= m_time
% 1000l;
1707 m_time
+= millisecond
;
1712 // ----------------------------------------------------------------------------
1713 // wxDateTime arithmetics
1714 // ----------------------------------------------------------------------------
1716 wxDateTime
& wxDateTime::Add(const wxDateSpan
& diff
)
1720 tm
.year
+= diff
.GetYears();
1721 tm
.AddMonths(diff
.GetMonths());
1723 // check that the resulting date is valid
1724 if ( tm
.mday
> GetNumOfDaysInMonth(tm
.year
, tm
.mon
) )
1726 // We suppose that when adding one month to Jan 31 we want to get Feb
1727 // 28 (or 29), i.e. adding a month to the last day of the month should
1728 // give the last day of the next month which is quite logical.
1730 // Unfortunately, there is no logic way to understand what should
1731 // Jan 30 + 1 month be - Feb 28 too or Feb 27 (assuming non leap year)?
1732 // We make it Feb 28 (last day too), but it is highly questionable.
1733 tm
.mday
= GetNumOfDaysInMonth(tm
.year
, tm
.mon
);
1736 tm
.AddDays(diff
.GetTotalDays());
1740 wxASSERT_MSG( IsSameTime(tm
),
1741 wxT("Add(wxDateSpan) shouldn't modify time") );
1746 // ----------------------------------------------------------------------------
1747 // Weekday and monthday stuff
1748 // ----------------------------------------------------------------------------
1750 // convert Sun, Mon, ..., Sat into 6, 0, ..., 5
1751 static inline int ConvertWeekDayToMondayBase(int wd
)
1753 return wd
== wxDateTime::Sun
? 6 : wd
- 1;
1758 wxDateTime::SetToWeekOfYear(int year
, wxDateTime_t numWeek
, WeekDay wd
)
1760 wxASSERT_MSG( numWeek
> 0,
1761 wxT("invalid week number: weeks are counted from 1") );
1763 // Jan 4 always lies in the 1st week of the year
1764 wxDateTime
dt(4, Jan
, year
);
1765 dt
.SetToWeekDayInSameWeek(wd
);
1766 dt
+= wxDateSpan::Weeks(numWeek
- 1);
1771 #if WXWIN_COMPATIBILITY_2_6
1772 // use a separate function to avoid warnings about using deprecated
1773 // SetToTheWeek in GetWeek below
1775 SetToTheWeek(int year
,
1776 wxDateTime::wxDateTime_t numWeek
,
1777 wxDateTime::WeekDay weekday
,
1778 wxDateTime::WeekFlags flags
)
1780 // Jan 4 always lies in the 1st week of the year
1781 wxDateTime
dt(4, wxDateTime::Jan
, year
);
1782 dt
.SetToWeekDayInSameWeek(weekday
, flags
);
1783 dt
+= wxDateSpan::Weeks(numWeek
- 1);
1788 bool wxDateTime::SetToTheWeek(wxDateTime_t numWeek
,
1792 int year
= GetYear();
1793 *this = ::SetToTheWeek(year
, numWeek
, weekday
, flags
);
1794 if ( GetYear() != year
)
1796 // oops... numWeek was too big
1803 wxDateTime
wxDateTime::GetWeek(wxDateTime_t numWeek
,
1805 WeekFlags flags
) const
1807 return ::SetToTheWeek(GetYear(), numWeek
, weekday
, flags
);
1809 #endif // WXWIN_COMPATIBILITY_2_6
1811 wxDateTime
& wxDateTime::SetToLastMonthDay(Month month
,
1814 // take the current month/year if none specified
1815 if ( year
== Inv_Year
)
1817 if ( month
== Inv_Month
)
1820 return Set(GetNumOfDaysInMonth(year
, month
), month
, year
);
1823 wxDateTime
& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday
, WeekFlags flags
)
1825 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, wxT("invalid weekday") );
1827 int wdayDst
= weekday
,
1828 wdayThis
= GetWeekDay();
1829 if ( wdayDst
== wdayThis
)
1835 if ( flags
== Default_First
)
1837 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
1840 // the logic below based on comparing weekday and wdayThis works if Sun (0)
1841 // is the first day in the week, but breaks down for Monday_First case so
1842 // we adjust the week days in this case
1843 if ( flags
== Monday_First
)
1845 if ( wdayThis
== Sun
)
1847 if ( wdayDst
== Sun
)
1850 //else: Sunday_First, nothing to do
1852 // go forward or back in time to the day we want
1853 if ( wdayDst
< wdayThis
)
1855 return Subtract(wxDateSpan::Days(wdayThis
- wdayDst
));
1857 else // weekday > wdayThis
1859 return Add(wxDateSpan::Days(wdayDst
- wdayThis
));
1863 wxDateTime
& wxDateTime::SetToNextWeekDay(WeekDay weekday
)
1865 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, wxT("invalid weekday") );
1868 WeekDay wdayThis
= GetWeekDay();
1869 if ( weekday
== wdayThis
)
1874 else if ( weekday
< wdayThis
)
1876 // need to advance a week
1877 diff
= 7 - (wdayThis
- weekday
);
1879 else // weekday > wdayThis
1881 diff
= weekday
- wdayThis
;
1884 return Add(wxDateSpan::Days(diff
));
1887 wxDateTime
& wxDateTime::SetToPrevWeekDay(WeekDay weekday
)
1889 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, wxT("invalid weekday") );
1892 WeekDay wdayThis
= GetWeekDay();
1893 if ( weekday
== wdayThis
)
1898 else if ( weekday
> wdayThis
)
1900 // need to go to previous week
1901 diff
= 7 - (weekday
- wdayThis
);
1903 else // weekday < wdayThis
1905 diff
= wdayThis
- weekday
;
1908 return Subtract(wxDateSpan::Days(diff
));
1911 bool wxDateTime::SetToWeekDay(WeekDay weekday
,
1916 wxCHECK_MSG( weekday
!= Inv_WeekDay
, false, wxT("invalid weekday") );
1918 // we don't check explicitly that -5 <= n <= 5 because we will return false
1919 // anyhow in such case - but may be should still give an assert for it?
1921 // take the current month/year if none specified
1922 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1926 // TODO this probably could be optimised somehow...
1930 // get the first day of the month
1931 dt
.Set(1, month
, year
);
1934 WeekDay wdayFirst
= dt
.GetWeekDay();
1936 // go to the first weekday of the month
1937 int diff
= weekday
- wdayFirst
;
1941 // add advance n-1 weeks more
1944 dt
+= wxDateSpan::Days(diff
);
1946 else // count from the end of the month
1948 // get the last day of the month
1949 dt
.SetToLastMonthDay(month
, year
);
1952 WeekDay wdayLast
= dt
.GetWeekDay();
1954 // go to the last weekday of the month
1955 int diff
= wdayLast
- weekday
;
1959 // and rewind n-1 weeks from there
1962 dt
-= wxDateSpan::Days(diff
);
1965 // check that it is still in the same month
1966 if ( dt
.GetMonth() == month
)
1974 // no such day in this month
1980 wxDateTime::wxDateTime_t
GetDayOfYearFromTm(const wxDateTime::Tm
& tm
)
1982 return (wxDateTime::wxDateTime_t
)(gs_cumulatedDays
[wxDateTime::IsLeapYear(tm
.year
)][tm
.mon
] + tm
.mday
);
1985 wxDateTime::wxDateTime_t
wxDateTime::GetDayOfYear(const TimeZone
& tz
) const
1987 return GetDayOfYearFromTm(GetTm(tz
));
1990 wxDateTime::wxDateTime_t
1991 wxDateTime::GetWeekOfYear(wxDateTime::WeekFlags flags
, const TimeZone
& tz
) const
1993 if ( flags
== Default_First
)
1995 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
1999 wxDateTime_t nDayInYear
= GetDayOfYearFromTm(tm
);
2001 int wdTarget
= GetWeekDay(tz
);
2002 int wdYearStart
= wxDateTime(1, Jan
, GetYear()).GetWeekDay();
2004 if ( flags
== Sunday_First
)
2006 // FIXME: First week is not calculated correctly.
2007 week
= (nDayInYear
- wdTarget
+ 7) / 7;
2008 if ( wdYearStart
== Wed
|| wdYearStart
== Thu
)
2011 else // week starts with monday
2013 // adjust the weekdays to non-US style.
2014 wdYearStart
= ConvertWeekDayToMondayBase(wdYearStart
);
2015 wdTarget
= ConvertWeekDayToMondayBase(wdTarget
);
2017 // quoting from http://www.cl.cam.ac.uk/~mgk25/iso-time.html:
2019 // Week 01 of a year is per definition the first week that has the
2020 // Thursday in this year, which is equivalent to the week that
2021 // contains the fourth day of January. In other words, the first
2022 // week of a new year is the week that has the majority of its
2023 // days in the new year. Week 01 might also contain days from the
2024 // previous year and the week before week 01 of a year is the last
2025 // week (52 or 53) of the previous year even if it contains days
2026 // from the new year. A week starts with Monday (day 1) and ends
2027 // with Sunday (day 7).
2030 // if Jan 1 is Thursday or less, it is in the first week of this year
2031 if ( wdYearStart
< 4 )
2033 // count the number of entire weeks between Jan 1 and this date
2034 week
= (nDayInYear
+ wdYearStart
+ 6 - wdTarget
)/7;
2036 // be careful to check for overflow in the next year
2037 if ( week
== 53 && tm
.mday
- wdTarget
> 28 )
2040 else // Jan 1 is in the last week of the previous year
2042 // check if we happen to be at the last week of previous year:
2043 if ( tm
.mon
== Jan
&& tm
.mday
< 8 - wdYearStart
)
2044 week
= wxDateTime(31, Dec
, GetYear()-1).GetWeekOfYear();
2046 week
= (nDayInYear
+ wdYearStart
- 1 - wdTarget
)/7;
2050 return (wxDateTime::wxDateTime_t
)week
;
2053 wxDateTime::wxDateTime_t
wxDateTime::GetWeekOfMonth(wxDateTime::WeekFlags flags
,
2054 const TimeZone
& tz
) const
2057 wxDateTime dtMonthStart
= wxDateTime(1, tm
.mon
, tm
.year
);
2058 int nWeek
= GetWeekOfYear(flags
) - dtMonthStart
.GetWeekOfYear(flags
) + 1;
2061 // this may happen for January when Jan, 1 is the last week of the
2063 nWeek
+= IsLeapYear(tm
.year
- 1) ? 53 : 52;
2066 return (wxDateTime::wxDateTime_t
)nWeek
;
2069 wxDateTime
& wxDateTime::SetToYearDay(wxDateTime::wxDateTime_t yday
)
2071 int year
= GetYear();
2072 wxDATETIME_CHECK( (0 < yday
) && (yday
<= GetNumberOfDays(year
)),
2073 wxT("invalid year day") );
2075 bool isLeap
= IsLeapYear(year
);
2076 for ( Month mon
= Jan
; mon
< Inv_Month
; wxNextMonth(mon
) )
2078 // for Dec, we can't compare with gs_cumulatedDays[mon + 1], but we
2079 // don't need it neither - because of the CHECK above we know that
2080 // yday lies in December then
2081 if ( (mon
== Dec
) || (yday
<= gs_cumulatedDays
[isLeap
][mon
+ 1]) )
2083 Set((wxDateTime::wxDateTime_t
)(yday
- gs_cumulatedDays
[isLeap
][mon
]), mon
, year
);
2092 // ----------------------------------------------------------------------------
2093 // Julian day number conversion and related stuff
2094 // ----------------------------------------------------------------------------
2096 double wxDateTime::GetJulianDayNumber() const
2098 return m_time
.ToDouble() / MILLISECONDS_PER_DAY
+ EPOCH_JDN
+ 0.5;
2101 double wxDateTime::GetRataDie() const
2103 // March 1 of the year 0 is Rata Die day -306 and JDN 1721119.5
2104 return GetJulianDayNumber() - 1721119.5 - 306;
2107 // ----------------------------------------------------------------------------
2108 // timezone and DST stuff
2109 // ----------------------------------------------------------------------------
2111 int wxDateTime::IsDST(wxDateTime::Country country
) const
2113 wxCHECK_MSG( country
== Country_Default
, -1,
2114 wxT("country support not implemented") );
2116 // use the C RTL for the dates in the standard range
2117 time_t timet
= GetTicks();
2118 if ( timet
!= (time_t)-1 )
2121 tm
*tm
= wxLocaltime_r(&timet
, &tmstruct
);
2123 wxCHECK_MSG( tm
, -1, wxT("wxLocaltime_r() failed") );
2125 return tm
->tm_isdst
;
2129 int year
= GetYear();
2131 if ( !IsDSTApplicable(year
, country
) )
2133 // no DST time in this year in this country
2137 return IsBetween(GetBeginDST(year
, country
), GetEndDST(year
, country
));
2141 wxDateTime
& wxDateTime::MakeTimezone(const TimeZone
& tz
, bool noDST
)
2143 long secDiff
= GetTimeZone() + tz
.GetOffset();
2145 // we need to know whether DST is or not in effect for this date unless
2146 // the test disabled by the caller
2147 if ( !noDST
&& (IsDST() == 1) )
2149 // FIXME we assume that the DST is always shifted by 1 hour
2153 return Add(wxTimeSpan::Seconds(secDiff
));
2156 wxDateTime
& wxDateTime::MakeFromTimezone(const TimeZone
& tz
, bool noDST
)
2158 long secDiff
= GetTimeZone() + tz
.GetOffset();
2160 // we need to know whether DST is or not in effect for this date unless
2161 // the test disabled by the caller
2162 if ( !noDST
&& (IsDST() == 1) )
2164 // FIXME we assume that the DST is always shifted by 1 hour
2168 return Subtract(wxTimeSpan::Seconds(secDiff
));
2171 // ============================================================================
2172 // wxDateTimeHolidayAuthority and related classes
2173 // ============================================================================
2175 #include "wx/arrimpl.cpp"
2177 WX_DEFINE_OBJARRAY(wxDateTimeArray
)
2179 static int wxCMPFUNC_CONV
2180 wxDateTimeCompareFunc(wxDateTime
**first
, wxDateTime
**second
)
2182 wxDateTime dt1
= **first
,
2185 return dt1
== dt2
? 0 : dt1
< dt2
? -1 : +1;
2188 // ----------------------------------------------------------------------------
2189 // wxDateTimeHolidayAuthority
2190 // ----------------------------------------------------------------------------
2192 wxHolidayAuthoritiesArray
wxDateTimeHolidayAuthority::ms_authorities
;
2195 bool wxDateTimeHolidayAuthority::IsHoliday(const wxDateTime
& dt
)
2197 size_t count
= ms_authorities
.size();
2198 for ( size_t n
= 0; n
< count
; n
++ )
2200 if ( ms_authorities
[n
]->DoIsHoliday(dt
) )
2211 wxDateTimeHolidayAuthority::GetHolidaysInRange(const wxDateTime
& dtStart
,
2212 const wxDateTime
& dtEnd
,
2213 wxDateTimeArray
& holidays
)
2215 wxDateTimeArray hol
;
2219 const size_t countAuth
= ms_authorities
.size();
2220 for ( size_t nAuth
= 0; nAuth
< countAuth
; nAuth
++ )
2222 ms_authorities
[nAuth
]->DoGetHolidaysInRange(dtStart
, dtEnd
, hol
);
2224 WX_APPEND_ARRAY(holidays
, hol
);
2227 holidays
.Sort(wxDateTimeCompareFunc
);
2229 return holidays
.size();
2233 void wxDateTimeHolidayAuthority::ClearAllAuthorities()
2235 WX_CLEAR_ARRAY(ms_authorities
);
2239 void wxDateTimeHolidayAuthority::AddAuthority(wxDateTimeHolidayAuthority
*auth
)
2241 ms_authorities
.push_back(auth
);
2244 wxDateTimeHolidayAuthority::~wxDateTimeHolidayAuthority()
2246 // required here for Darwin
2249 // ----------------------------------------------------------------------------
2250 // wxDateTimeWorkDays
2251 // ----------------------------------------------------------------------------
2253 bool wxDateTimeWorkDays::DoIsHoliday(const wxDateTime
& dt
) const
2255 wxDateTime::WeekDay wd
= dt
.GetWeekDay();
2257 return (wd
== wxDateTime::Sun
) || (wd
== wxDateTime::Sat
);
2260 size_t wxDateTimeWorkDays::DoGetHolidaysInRange(const wxDateTime
& dtStart
,
2261 const wxDateTime
& dtEnd
,
2262 wxDateTimeArray
& holidays
) const
2264 if ( dtStart
> dtEnd
)
2266 wxFAIL_MSG( wxT("invalid date range in GetHolidaysInRange") );
2273 // instead of checking all days, start with the first Sat after dtStart and
2274 // end with the last Sun before dtEnd
2275 wxDateTime dtSatFirst
= dtStart
.GetNextWeekDay(wxDateTime::Sat
),
2276 dtSatLast
= dtEnd
.GetPrevWeekDay(wxDateTime::Sat
),
2277 dtSunFirst
= dtStart
.GetNextWeekDay(wxDateTime::Sun
),
2278 dtSunLast
= dtEnd
.GetPrevWeekDay(wxDateTime::Sun
),
2281 for ( dt
= dtSatFirst
; dt
<= dtSatLast
; dt
+= wxDateSpan::Week() )
2286 for ( dt
= dtSunFirst
; dt
<= dtSunLast
; dt
+= wxDateSpan::Week() )
2291 return holidays
.GetCount();
2294 // ============================================================================
2295 // other helper functions
2296 // ============================================================================
2298 // ----------------------------------------------------------------------------
2299 // iteration helpers: can be used to write a for loop over enum variable like
2301 // for ( m = wxDateTime::Jan; m < wxDateTime::Inv_Month; wxNextMonth(m) )
2302 // ----------------------------------------------------------------------------
2304 WXDLLIMPEXP_BASE
void wxNextMonth(wxDateTime::Month
& m
)
2306 wxASSERT_MSG( m
< wxDateTime::Inv_Month
, wxT("invalid month") );
2308 // no wrapping or the for loop above would never end!
2309 m
= (wxDateTime::Month
)(m
+ 1);
2312 WXDLLIMPEXP_BASE
void wxPrevMonth(wxDateTime::Month
& m
)
2314 wxASSERT_MSG( m
< wxDateTime::Inv_Month
, wxT("invalid month") );
2316 m
= m
== wxDateTime::Jan
? wxDateTime::Inv_Month
2317 : (wxDateTime::Month
)(m
- 1);
2320 WXDLLIMPEXP_BASE
void wxNextWDay(wxDateTime::WeekDay
& wd
)
2322 wxASSERT_MSG( wd
< wxDateTime::Inv_WeekDay
, wxT("invalid week day") );
2324 // no wrapping or the for loop above would never end!
2325 wd
= (wxDateTime::WeekDay
)(wd
+ 1);
2328 WXDLLIMPEXP_BASE
void wxPrevWDay(wxDateTime::WeekDay
& wd
)
2330 wxASSERT_MSG( wd
< wxDateTime::Inv_WeekDay
, wxT("invalid week day") );
2332 wd
= wd
== wxDateTime::Sun
? wxDateTime::Inv_WeekDay
2333 : (wxDateTime::WeekDay
)(wd
- 1);
2338 wxDateTime
& wxDateTime::SetFromMSWSysTime(const SYSTEMTIME
& st
)
2341 static_cast<wxDateTime::Month
>(wxDateTime::Jan
+ st
.wMonth
- 1),
2343 st
.wHour
, st
.wMinute
, st
.wSecond
, st
.wMilliseconds
);
2346 void wxDateTime::GetAsMSWSysTime(SYSTEMTIME
* st
) const
2348 const wxDateTime::Tm
tm(GetTm());
2350 st
->wYear
= (WXWORD
)tm
.year
;
2351 st
->wMonth
= (WXWORD
)(tm
.mon
- wxDateTime::Jan
+ 1);
2355 st
->wHour
= tm
.hour
;
2356 st
->wMinute
= tm
.min
;
2357 st
->wSecond
= tm
.sec
;
2358 st
->wMilliseconds
= tm
.msec
;
2362 #endif // wxUSE_DATETIME