1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/datetime.cpp
3 // Purpose: implementation of time/date related classes
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // parts of code taken from sndcal library by Scott E. Lee:
11 // Copyright 1993-1995, Scott E. Lee, all rights reserved.
12 // Permission granted to use, copy, modify, distribute and sell
13 // so long as the above copyright and this permission statement
14 // are retained in all copies.
16 // Licence: wxWindows licence
17 ///////////////////////////////////////////////////////////////////////////////
20 * Implementation notes:
22 * 1. the time is stored as a 64bit integer containing the signed number of
23 * milliseconds since Jan 1. 1970 (the Unix Epoch) - so it is always
26 * 2. the range is thus something about 580 million years, but due to current
27 * algorithms limitations, only dates from Nov 24, 4714BC are handled
29 * 3. standard ANSI C functions are used to do time calculations whenever
30 * possible, i.e. when the date is in the range Jan 1, 1970 to 2038
32 * 4. otherwise, the calculations are done by converting the date to/from JDN
33 * first (the range limitation mentioned above comes from here: the
34 * algorithm used by Scott E. Lee's code only works for positive JDNs, more
37 * 5. the object constructed for the given DD-MM-YYYY HH:MM:SS corresponds to
38 * this moment in local time and may be converted to the object
39 * corresponding to the same date/time in another time zone by using
42 * 6. the conversions to the current (or any other) timezone are done when the
43 * internal time representation is converted to the broken-down one in
47 // ============================================================================
49 // ============================================================================
51 // ----------------------------------------------------------------------------
53 // ----------------------------------------------------------------------------
55 // For compilers that support precompilation, includes "wx.h".
56 #include "wx/wxprec.h"
62 #if !defined(wxUSE_DATETIME) || wxUSE_DATETIME
66 #include "wx/msw/wrapwin.h"
68 #include "wx/string.h"
71 #include "wx/stopwatch.h" // for wxGetLocalTimeMillis()
72 #include "wx/module.h"
76 #include "wx/thread.h"
77 #include "wx/tokenzr.h"
88 #include "wx/datetime.h"
90 const long wxDateTime::TIME_T_FACTOR
= 1000l;
92 #if wxUSE_EXTENDED_RTTI
94 template<> void wxStringReadValue(const wxString
&s
, wxDateTime
&data
)
96 data
.ParseFormat(s
,wxT("%Y-%m-%d %H:%M:%S")) ;
99 template<> void wxStringWriteValue(wxString
&s
, const wxDateTime
&data
)
101 s
= data
.Format(wxT("%Y-%m-%d %H:%M:%S")) ;
104 wxCUSTOM_TYPE_INFO(wxDateTime
, wxToStringConverter
<wxDateTime
> , wxFromStringConverter
<wxDateTime
>)
109 // ----------------------------------------------------------------------------
110 // conditional compilation
111 // ----------------------------------------------------------------------------
113 #if defined(HAVE_STRPTIME) && defined(__GLIBC__) && \
114 ((__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0))
115 // glibc 2.0.7 strptime() is broken - the following snippet causes it to
116 // crash (instead of just failing):
118 // strncpy(buf, "Tue Dec 21 20:25:40 1999", 128);
119 // strptime(buf, "%x", &tm);
123 #endif // broken strptime()
125 #if defined(HAVE_STRPTIME) && defined(__DARWIN__) && defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
126 // configure detects strptime as linkable because it's in the OS X
127 // System library but MSL headers don't declare it.
129 // char *strptime(const char *, const char *, struct tm *);
130 // However, we DON'T want to just provide it here because we would
131 // crash and/or overwrite data when strptime from OS X tries
132 // to fill in MW's struct tm which is two fields shorter (no TZ stuff)
133 // So for now let's just say we don't have strptime
137 #if defined(__MWERKS__) && wxUSE_UNICODE
141 // define a special symbol for VC8 instead of writing tests for 1400 repeatedly
143 #if __VISUALC__ >= 1400
148 #if !defined(WX_TIMEZONE) && !defined(WX_GMTOFF_IN_TM)
149 #if defined(__WXPALMOS__)
150 #define WX_GMTOFF_IN_TM
151 #elif defined(__BORLANDC__) || defined(__MINGW32__) || defined(__VISAGECPP__)
152 #define WX_TIMEZONE _timezone
153 #elif defined(__MWERKS__)
154 long wxmw_timezone
= 28800;
155 #define WX_TIMEZONE wxmw_timezone
156 #elif defined(__DJGPP__) || defined(__WINE__)
157 #include <sys/timeb.h>
159 static long wxGetTimeZone()
161 static long timezone
= MAXLONG
; // invalid timezone
162 if (timezone
== MAXLONG
)
166 timezone
= tb
.timezone
;
170 #define WX_TIMEZONE wxGetTimeZone()
171 #elif defined(__DARWIN__)
172 #define WX_GMTOFF_IN_TM
173 #elif defined(__WXWINCE__) && defined(__VISUALC8__)
174 // _timezone is not present in dynamic run-time library
176 // Solution (1): use the function equivalent of _timezone
177 static long wxGetTimeZone()
179 static long s_Timezone
= MAXLONG
; // invalid timezone
180 if (s_Timezone
== MAXLONG
)
184 s_Timezone
= (long) t
;
188 #define WX_TIMEZONE wxGetTimeZone()
190 // Solution (2): using GetTimeZoneInformation
191 static long wxGetTimeZone()
193 static long timezone
= MAXLONG
; // invalid timezone
194 if (timezone
== MAXLONG
)
196 TIME_ZONE_INFORMATION tzi
;
197 ::GetTimeZoneInformation(&tzi
);
202 #define WX_TIMEZONE wxGetTimeZone()
204 // Old method using _timezone: this symbol doesn't exist in the dynamic run-time library (i.e. using /MD)
205 #define WX_TIMEZONE _timezone
207 #else // unknown platform - try timezone
208 #define WX_TIMEZONE timezone
210 #endif // !WX_TIMEZONE && !WX_GMTOFF_IN_TM
212 // everyone has strftime except Win CE unless VC8 is used
213 #if !defined(__WXWINCE__) || defined(__VISUALC8__)
214 #define HAVE_STRFTIME
217 // NB: VC8 safe time functions could/should be used for wxMSW as well probably
218 #if defined(__WXWINCE__) && defined(__VISUALC8__)
220 struct tm
*wxLocaltime_r(const time_t *t
, struct tm
* tm
)
223 return _localtime64_s(tm
, &t64
) == 0 ? tm
: NULL
;
226 struct tm
*wxGmtime_r(const time_t* t
, struct tm
* tm
)
229 return _gmtime64_s(tm
, &t64
) == 0 ? tm
: NULL
;
232 #else // !wxWinCE with VC8
234 #if (!defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)) && wxUSE_THREADS && !defined(__WINDOWS__)
235 static wxMutex timeLock
;
238 #ifndef HAVE_LOCALTIME_R
239 struct tm
*wxLocaltime_r(const time_t* ticks
, struct tm
* temp
)
241 #if wxUSE_THREADS && !defined(__WINDOWS__)
242 // No need to waste time with a mutex on windows since it's using
243 // thread local storage for localtime anyway.
244 wxMutexLocker
locker(timeLock
);
247 // Borland CRT crashes when passed 0 ticks for some reason, see SF bug 1704438
253 const tm
* const t
= localtime(ticks
);
257 memcpy(temp
, t
, sizeof(struct tm
));
260 #endif // !HAVE_LOCALTIME_R
262 #ifndef HAVE_GMTIME_R
263 struct tm
*wxGmtime_r(const time_t* ticks
, struct tm
* temp
)
265 #if wxUSE_THREADS && !defined(__WINDOWS__)
266 // No need to waste time with a mutex on windows since it's
267 // using thread local storage for gmtime anyway.
268 wxMutexLocker
locker(timeLock
);
276 const tm
* const t
= gmtime(ticks
);
280 memcpy(temp
, gmtime(ticks
), sizeof(struct tm
));
283 #endif // !HAVE_GMTIME_R
285 #endif // wxWinCE with VC8/other platforms
287 // ----------------------------------------------------------------------------
289 // ----------------------------------------------------------------------------
291 // debugging helper: just a convenient replacement of wxCHECK()
292 #define wxDATETIME_CHECK(expr, msg) \
293 wxCHECK2_MSG(expr, *this = wxInvalidDateTime; return *this, msg)
295 // ----------------------------------------------------------------------------
297 // ----------------------------------------------------------------------------
299 class wxDateTimeHolidaysModule
: public wxModule
302 virtual bool OnInit()
304 wxDateTimeHolidayAuthority::AddAuthority(new wxDateTimeWorkDays
);
309 virtual void OnExit()
311 wxDateTimeHolidayAuthority::ClearAllAuthorities();
312 wxDateTimeHolidayAuthority::ms_authorities
.clear();
316 DECLARE_DYNAMIC_CLASS(wxDateTimeHolidaysModule
)
319 IMPLEMENT_DYNAMIC_CLASS(wxDateTimeHolidaysModule
, wxModule
)
321 // ----------------------------------------------------------------------------
323 // ----------------------------------------------------------------------------
326 static const int MONTHS_IN_YEAR
= 12;
328 static const int SEC_PER_MIN
= 60;
330 static const int MIN_PER_HOUR
= 60;
332 static const int HOURS_PER_DAY
= 24;
334 static const long SECONDS_PER_DAY
= 86400l;
336 static const int DAYS_PER_WEEK
= 7;
338 static const long MILLISECONDS_PER_DAY
= 86400000l;
340 // this is the integral part of JDN of the midnight of Jan 1, 1970
341 // (i.e. JDN(Jan 1, 1970) = 2440587.5)
342 static const long EPOCH_JDN
= 2440587l;
344 // used only in asserts
346 // the date of JDN -0.5 (as we don't work with fractional parts, this is the
347 // reference date for us) is Nov 24, 4714BC
348 static const int JDN_0_YEAR
= -4713;
349 static const int JDN_0_MONTH
= wxDateTime::Nov
;
350 static const int JDN_0_DAY
= 24;
351 #endif // __WXDEBUG__
353 // the constants used for JDN calculations
354 static const long JDN_OFFSET
= 32046l;
355 static const long DAYS_PER_5_MONTHS
= 153l;
356 static const long DAYS_PER_4_YEARS
= 1461l;
357 static const long DAYS_PER_400_YEARS
= 146097l;
359 // this array contains the cumulated number of days in all previous months for
360 // normal and leap years
361 static const wxDateTime::wxDateTime_t gs_cumulatedDays
[2][MONTHS_IN_YEAR
] =
363 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
364 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
367 // ----------------------------------------------------------------------------
369 // ----------------------------------------------------------------------------
371 const wxChar
* wxDefaultDateTimeFormat
= wxT("%c");
372 const wxChar
* wxDefaultTimeSpanFormat
= wxT("%H:%M:%S");
374 // in the fine tradition of ANSI C we use our equivalent of (time_t)-1 to
375 // indicate an invalid wxDateTime object
376 const wxDateTime wxDefaultDateTime
;
378 wxDateTime::Country
wxDateTime::ms_country
= wxDateTime::Country_Unknown
;
380 // ----------------------------------------------------------------------------
382 // ----------------------------------------------------------------------------
384 // debugger helper: shows what the date really is
386 extern const wxChar
*wxDumpDate(const wxDateTime
* dt
)
388 static wxChar buf
[128];
390 wxStrcpy(buf
, dt
->Format(_T("%Y-%m-%d (%a) %H:%M:%S")));
396 // get the number of days in the given month of the given year
398 wxDateTime::wxDateTime_t
GetNumOfDaysInMonth(int year
, wxDateTime::Month month
)
400 // the number of days in month in Julian/Gregorian calendar: the first line
401 // is for normal years, the second one is for the leap ones
402 static wxDateTime::wxDateTime_t daysInMonth
[2][MONTHS_IN_YEAR
] =
404 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
405 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
408 return daysInMonth
[wxDateTime::IsLeapYear(year
)][month
];
411 // returns the time zone in the C sense, i.e. the difference UTC - local
413 static int GetTimeZone()
415 // set to true when the timezone is set
416 static bool s_timezoneSet
= false;
417 static long gmtoffset
= LONG_MAX
; // invalid timezone
419 // ensure that the timezone variable is set by calling wxLocaltime_r
420 if ( !s_timezoneSet
)
422 // just call wxLocaltime_r() instead of figuring out whether this
423 // system supports tzset(), _tzset() or something else
427 wxLocaltime_r(&t
, &tm
);
428 s_timezoneSet
= true;
430 #ifdef WX_GMTOFF_IN_TM
431 // note that GMT offset is the opposite of time zone and so to return
432 // consistent results in both WX_GMTOFF_IN_TM and !WX_GMTOFF_IN_TM
433 // cases we have to negate it
434 gmtoffset
= -tm
.tm_gmtoff
;
435 #else // !WX_GMTOFF_IN_TM
436 gmtoffset
= WX_TIMEZONE
;
437 #endif // WX_GMTOFF_IN_TM/!WX_GMTOFF_IN_TM
440 return (int)gmtoffset
;
443 // return the integral part of the JDN for the midnight of the given date (to
444 // get the real JDN you need to add 0.5, this is, in fact, JDN of the
445 // noon of the previous day)
446 static long GetTruncatedJDN(wxDateTime::wxDateTime_t day
,
447 wxDateTime::Month mon
,
450 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
452 // check the date validity
454 (year
> JDN_0_YEAR
) ||
455 ((year
== JDN_0_YEAR
) && (mon
> JDN_0_MONTH
)) ||
456 ((year
== JDN_0_YEAR
) && (mon
== JDN_0_MONTH
) && (day
>= JDN_0_DAY
)),
457 _T("date out of range - can't convert to JDN")
460 // make the year positive to avoid problems with negative numbers division
463 // months are counted from March here
465 if ( mon
>= wxDateTime::Mar
)
475 // now we can simply add all the contributions together
476 return ((year
/ 100) * DAYS_PER_400_YEARS
) / 4
477 + ((year
% 100) * DAYS_PER_4_YEARS
) / 4
478 + (month
* DAYS_PER_5_MONTHS
+ 2) / 5
485 // this function is a wrapper around strftime(3) adding error checking
486 static wxString
CallStrftime(const wxString
& format
, const tm
* tm
)
489 // Create temp wxString here to work around mingw/cygwin bug 1046059
490 // http://sourceforge.net/tracker/?func=detail&atid=102435&aid=1046059&group_id=2435
493 if ( !wxStrftime(buf
, WXSIZEOF(buf
), format
, tm
) )
495 // buffer is too small?
496 wxFAIL_MSG(_T("strftime() failed"));
503 #endif // HAVE_STRFTIME
507 #if wxUSE_UNIX && !defined(HAVE_STRPTIME_DECL)
508 // configure detected that we had strptime() but not its declaration,
509 // provide it ourselves
510 extern "C" char *strptime(const char *, const char *, struct tm
*);
513 // Unicode-friendly strptime() wrapper
514 static const wxChar
*
515 CallStrptime(const wxChar
*input
, const char *fmt
, tm
*tm
)
517 // the problem here is that strptime() returns pointer into the string we
518 // passed to it while we're really interested in the pointer into the
519 // original, Unicode, string so we try to transform the pointer back
521 wxCharBuffer
inputMB(wxConvertWX2MB(input
));
523 const char * const inputMB
= input
;
524 #endif // Unicode/Ascii
526 const char *result
= strptime(inputMB
, fmt
, tm
);
531 // FIXME: this is wrong in presence of surrogates &c
532 return input
+ (result
- inputMB
.data());
535 #endif // Unicode/Ascii
538 #endif // HAVE_STRPTIME
540 // if year and/or month have invalid values, replace them with the current ones
541 static void ReplaceDefaultYearMonthWithCurrent(int *year
,
542 wxDateTime::Month
*month
)
544 struct tm
*tmNow
= NULL
;
547 if ( *year
== wxDateTime::Inv_Year
)
549 tmNow
= wxDateTime::GetTmNow(&tmstruct
);
551 *year
= 1900 + tmNow
->tm_year
;
554 if ( *month
== wxDateTime::Inv_Month
)
557 tmNow
= wxDateTime::GetTmNow(&tmstruct
);
559 *month
= (wxDateTime::Month
)tmNow
->tm_mon
;
563 // fll the struct tm with default values
564 static void InitTm(struct tm
& tm
)
566 // struct tm may have etxra fields (undocumented and with unportable
567 // names) which, nevertheless, must be set to 0
568 memset(&tm
, 0, sizeof(struct tm
));
570 tm
.tm_mday
= 1; // mday 0 is invalid
571 tm
.tm_year
= 76; // any valid year
572 tm
.tm_isdst
= -1; // auto determine
578 // return the month if the string is a month name or Inv_Month otherwise
579 static wxDateTime::Month
GetMonthFromName(const wxString
& name
, int flags
)
581 wxDateTime::Month mon
;
582 for ( mon
= wxDateTime::Jan
; mon
< wxDateTime::Inv_Month
; wxNextMonth(mon
) )
584 // case-insensitive comparison either one of or with both abbreviated
586 if ( flags
& wxDateTime::Name_Full
)
588 if ( name
.CmpNoCase(wxDateTime::
589 GetMonthName(mon
, wxDateTime::Name_Full
)) == 0 )
595 if ( flags
& wxDateTime::Name_Abbr
)
597 if ( name
.CmpNoCase(wxDateTime::
598 GetMonthName(mon
, wxDateTime::Name_Abbr
)) == 0 )
608 // return the weekday if the string is a weekday name or Inv_WeekDay otherwise
609 static wxDateTime::WeekDay
GetWeekDayFromName(const wxString
& name
, int flags
)
611 wxDateTime::WeekDay wd
;
612 for ( wd
= wxDateTime::Sun
; wd
< wxDateTime::Inv_WeekDay
; wxNextWDay(wd
) )
614 // case-insensitive comparison either one of or with both abbreviated
616 if ( flags
& wxDateTime::Name_Full
)
618 if ( name
.CmpNoCase(wxDateTime::
619 GetWeekDayName(wd
, wxDateTime::Name_Full
)) == 0 )
625 if ( flags
& wxDateTime::Name_Abbr
)
627 if ( name
.CmpNoCase(wxDateTime::
628 GetWeekDayName(wd
, wxDateTime::Name_Abbr
)) == 0 )
639 struct tm
*wxDateTime::GetTmNow(struct tm
*tmstruct
)
641 time_t t
= GetTimeNow();
642 return wxLocaltime_r(&t
, tmstruct
);
645 // scans all digits (but no more than len) and returns the resulting number
646 static bool GetNumericToken(size_t len
, const wxChar
*& p
, unsigned long *number
)
650 while ( wxIsdigit(*p
) )
654 if ( len
&& ++n
> len
)
658 return !s
.empty() && s
.ToULong(number
);
661 // scans all alphabetic characters and returns the resulting string
662 static wxString
GetAlphaToken(const wxChar
*& p
)
665 while ( wxIsalpha(*p
) )
673 // ============================================================================
674 // implementation of wxDateTime
675 // ============================================================================
677 // ----------------------------------------------------------------------------
679 // ----------------------------------------------------------------------------
683 year
= (wxDateTime_t
)wxDateTime::Inv_Year
;
684 mon
= wxDateTime::Inv_Month
;
686 hour
= min
= sec
= msec
= 0;
687 wday
= wxDateTime::Inv_WeekDay
;
690 wxDateTime::Tm::Tm(const struct tm
& tm
, const TimeZone
& tz
)
694 sec
= (wxDateTime::wxDateTime_t
)tm
.tm_sec
;
695 min
= (wxDateTime::wxDateTime_t
)tm
.tm_min
;
696 hour
= (wxDateTime::wxDateTime_t
)tm
.tm_hour
;
697 mday
= (wxDateTime::wxDateTime_t
)tm
.tm_mday
;
698 mon
= (wxDateTime::Month
)tm
.tm_mon
;
699 year
= 1900 + tm
.tm_year
;
700 wday
= (wxDateTime::wxDateTime_t
)tm
.tm_wday
;
701 yday
= (wxDateTime::wxDateTime_t
)tm
.tm_yday
;
704 bool wxDateTime::Tm::IsValid() const
706 // we allow for the leap seconds, although we don't use them (yet)
707 return (year
!= wxDateTime::Inv_Year
) && (mon
!= wxDateTime::Inv_Month
) &&
708 (mday
<= GetNumOfDaysInMonth(year
, mon
)) &&
709 (hour
< 24) && (min
< 60) && (sec
< 62) && (msec
< 1000);
712 void wxDateTime::Tm::ComputeWeekDay()
714 // compute the week day from day/month/year: we use the dumbest algorithm
715 // possible: just compute our JDN and then use the (simple to derive)
716 // formula: weekday = (JDN + 1.5) % 7
717 wday
= (wxDateTime::wxDateTime_t
)((GetTruncatedJDN(mday
, mon
, year
) + 2) % 7);
720 void wxDateTime::Tm::AddMonths(int monDiff
)
722 // normalize the months field
723 while ( monDiff
< -mon
)
727 monDiff
+= MONTHS_IN_YEAR
;
730 while ( monDiff
+ mon
>= MONTHS_IN_YEAR
)
734 monDiff
-= MONTHS_IN_YEAR
;
737 mon
= (wxDateTime::Month
)(mon
+ monDiff
);
739 wxASSERT_MSG( mon
>= 0 && mon
< MONTHS_IN_YEAR
, _T("logic error") );
741 // NB: we don't check here that the resulting date is valid, this function
742 // is private and the caller must check it if needed
745 void wxDateTime::Tm::AddDays(int dayDiff
)
747 // normalize the days field
748 while ( dayDiff
+ mday
< 1 )
752 dayDiff
+= GetNumOfDaysInMonth(year
, mon
);
755 mday
= (wxDateTime::wxDateTime_t
)( mday
+ dayDiff
);
756 while ( mday
> GetNumOfDaysInMonth(year
, mon
) )
758 mday
-= GetNumOfDaysInMonth(year
, mon
);
763 wxASSERT_MSG( mday
> 0 && mday
<= GetNumOfDaysInMonth(year
, mon
),
767 // ----------------------------------------------------------------------------
769 // ----------------------------------------------------------------------------
771 wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz
)
775 case wxDateTime::Local
:
776 // get the offset from C RTL: it returns the difference GMT-local
777 // while we want to have the offset _from_ GMT, hence the '-'
778 m_offset
= -GetTimeZone();
781 case wxDateTime::GMT_12
:
782 case wxDateTime::GMT_11
:
783 case wxDateTime::GMT_10
:
784 case wxDateTime::GMT_9
:
785 case wxDateTime::GMT_8
:
786 case wxDateTime::GMT_7
:
787 case wxDateTime::GMT_6
:
788 case wxDateTime::GMT_5
:
789 case wxDateTime::GMT_4
:
790 case wxDateTime::GMT_3
:
791 case wxDateTime::GMT_2
:
792 case wxDateTime::GMT_1
:
793 m_offset
= -3600*(wxDateTime::GMT0
- tz
);
796 case wxDateTime::GMT0
:
797 case wxDateTime::GMT1
:
798 case wxDateTime::GMT2
:
799 case wxDateTime::GMT3
:
800 case wxDateTime::GMT4
:
801 case wxDateTime::GMT5
:
802 case wxDateTime::GMT6
:
803 case wxDateTime::GMT7
:
804 case wxDateTime::GMT8
:
805 case wxDateTime::GMT9
:
806 case wxDateTime::GMT10
:
807 case wxDateTime::GMT11
:
808 case wxDateTime::GMT12
:
809 case wxDateTime::GMT13
:
810 m_offset
= 3600*(tz
- wxDateTime::GMT0
);
813 case wxDateTime::A_CST
:
814 // Central Standard Time in use in Australia = UTC + 9.5
815 m_offset
= 60l*(9*MIN_PER_HOUR
+ MIN_PER_HOUR
/2);
819 wxFAIL_MSG( _T("unknown time zone") );
823 // ----------------------------------------------------------------------------
825 // ----------------------------------------------------------------------------
828 bool wxDateTime::IsLeapYear(int year
, wxDateTime::Calendar cal
)
830 if ( year
== Inv_Year
)
831 year
= GetCurrentYear();
833 if ( cal
== Gregorian
)
835 // in Gregorian calendar leap years are those divisible by 4 except
836 // those divisible by 100 unless they're also divisible by 400
837 // (in some countries, like Russia and Greece, additional corrections
838 // exist, but they won't manifest themselves until 2700)
839 return (year
% 4 == 0) && ((year
% 100 != 0) || (year
% 400 == 0));
841 else if ( cal
== Julian
)
843 // in Julian calendar the rule is simpler
844 return year
% 4 == 0;
848 wxFAIL_MSG(_T("unknown calendar"));
855 int wxDateTime::GetCentury(int year
)
857 return year
> 0 ? year
/ 100 : year
/ 100 - 1;
861 int wxDateTime::ConvertYearToBC(int year
)
864 return year
> 0 ? year
: year
- 1;
868 int wxDateTime::GetCurrentYear(wxDateTime::Calendar cal
)
873 return Now().GetYear();
876 wxFAIL_MSG(_T("TODO"));
880 wxFAIL_MSG(_T("unsupported calendar"));
888 wxDateTime::Month
wxDateTime::GetCurrentMonth(wxDateTime::Calendar cal
)
893 return Now().GetMonth();
896 wxFAIL_MSG(_T("TODO"));
900 wxFAIL_MSG(_T("unsupported calendar"));
908 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(int year
, Calendar cal
)
910 if ( year
== Inv_Year
)
912 // take the current year if none given
913 year
= GetCurrentYear();
920 return IsLeapYear(year
) ? 366 : 365;
923 wxFAIL_MSG(_T("unsupported calendar"));
931 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(wxDateTime::Month month
,
933 wxDateTime::Calendar cal
)
935 wxCHECK_MSG( month
< MONTHS_IN_YEAR
, 0, _T("invalid month") );
937 if ( cal
== Gregorian
|| cal
== Julian
)
939 if ( year
== Inv_Year
)
941 // take the current year if none given
942 year
= GetCurrentYear();
945 return GetNumOfDaysInMonth(year
, month
);
949 wxFAIL_MSG(_T("unsupported calendar"));
956 wxString
wxDateTime::GetMonthName(wxDateTime::Month month
,
957 wxDateTime::NameFlags flags
)
959 wxCHECK_MSG( month
!= Inv_Month
, wxEmptyString
, _T("invalid month") );
961 // notice that we must set all the fields to avoid confusing libc (GNU one
962 // gets confused to a crash if we don't do this)
967 return CallStrftime(flags
== Name_Abbr
? _T("%b") : _T("%B"), &tm
);
968 #else // !HAVE_STRFTIME
973 ret
= (flags
== Name_Abbr
? wxT("Jan"): wxT("January"));
976 ret
= (flags
== Name_Abbr
? wxT("Feb"): wxT("Febuary"));
979 ret
= (flags
== Name_Abbr
? wxT("Mar"): wxT("March"));
982 ret
= (flags
== Name_Abbr
? wxT("Apr"): wxT("April"));
985 ret
= (flags
== Name_Abbr
? wxT("May"): wxT("May"));
988 ret
= (flags
== Name_Abbr
? wxT("Jun"): wxT("June"));
991 ret
= (flags
== Name_Abbr
? wxT("Jul"): wxT("July"));
994 ret
= (flags
== Name_Abbr
? wxT("Aug"): wxT("August"));
997 ret
= (flags
== Name_Abbr
? wxT("Sep"): wxT("September"));
1000 ret
= (flags
== Name_Abbr
? wxT("Oct"): wxT("October"));
1003 ret
= (flags
== Name_Abbr
? wxT("Nov"): wxT("November"));
1006 ret
= (flags
== Name_Abbr
? wxT("Dec"): wxT("December"));
1010 #endif // HAVE_STRFTIME/!HAVE_STRFTIME
1014 wxString
wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday
,
1015 wxDateTime::NameFlags flags
)
1017 wxCHECK_MSG( wday
!= Inv_WeekDay
, wxEmptyString
, _T("invalid weekday") );
1018 #ifdef HAVE_STRFTIME
1019 // take some arbitrary Sunday (but notice that the day should be such that
1020 // after adding wday to it below we still have a valid date, e.g. don't
1028 // and offset it by the number of days needed to get the correct wday
1031 // call mktime() to normalize it...
1034 // ... and call strftime()
1035 return CallStrftime(flags
== Name_Abbr
? _T("%a") : _T("%A"), &tm
);
1036 #else // !HAVE_STRFTIME
1041 ret
= (flags
== Name_Abbr
? wxT("Sun") : wxT("Sunday"));
1044 ret
= (flags
== Name_Abbr
? wxT("Mon") : wxT("Monday"));
1047 ret
= (flags
== Name_Abbr
? wxT("Tue") : wxT("Tuesday"));
1050 ret
= (flags
== Name_Abbr
? wxT("Wed") : wxT("Wednesday"));
1053 ret
= (flags
== Name_Abbr
? wxT("Thu") : wxT("Thursday"));
1056 ret
= (flags
== Name_Abbr
? wxT("Fri") : wxT("Friday"));
1059 ret
= (flags
== Name_Abbr
? wxT("Sat") : wxT("Saturday"));
1063 #endif // HAVE_STRFTIME/!HAVE_STRFTIME
1067 void wxDateTime::GetAmPmStrings(wxString
*am
, wxString
*pm
)
1072 // @Note: Do not call 'CallStrftime' here! CallStrftime checks the return code
1073 // and causes an assertion failed if the buffer is to small (which is good) - OR -
1074 // if strftime does not return anything because the format string is invalid - OR -
1075 // if there are no 'am' / 'pm' tokens defined for the current locale (which is not good).
1076 // wxDateTime::ParseTime will try several different formats to parse the time.
1077 // As a result, GetAmPmStrings might get called, even if the current locale
1078 // does not define any 'am' / 'pm' tokens. In this case, wxStrftime would
1079 // assert, even though it is a perfectly legal use.
1082 if (wxStrftime(buffer
, sizeof(buffer
)/sizeof(wxChar
), _T("%p"), &tm
) > 0)
1083 *am
= wxString(buffer
);
1090 if (wxStrftime(buffer
, sizeof(buffer
)/sizeof(wxChar
), _T("%p"), &tm
) > 0)
1091 *pm
= wxString(buffer
);
1097 // ----------------------------------------------------------------------------
1098 // Country stuff: date calculations depend on the country (DST, work days,
1099 // ...), so we need to know which rules to follow.
1100 // ----------------------------------------------------------------------------
1103 wxDateTime::Country
wxDateTime::GetCountry()
1105 // TODO use LOCALE_ICOUNTRY setting under Win32
1107 if ( ms_country
== Country_Unknown
)
1109 // try to guess from the time zone name
1110 time_t t
= time(NULL
);
1112 struct tm
*tm
= wxLocaltime_r(&t
, &tmstruct
);
1114 wxString tz
= CallStrftime(_T("%Z"), tm
);
1115 if ( tz
== _T("WET") || tz
== _T("WEST") )
1119 else if ( tz
== _T("CET") || tz
== _T("CEST") )
1121 ms_country
= Country_EEC
;
1123 else if ( tz
== _T("MSK") || tz
== _T("MSD") )
1125 ms_country
= Russia
;
1127 else if ( tz
== _T("AST") || tz
== _T("ADT") ||
1128 tz
== _T("EST") || tz
== _T("EDT") ||
1129 tz
== _T("CST") || tz
== _T("CDT") ||
1130 tz
== _T("MST") || tz
== _T("MDT") ||
1131 tz
== _T("PST") || tz
== _T("PDT") )
1137 // well, choose a default one
1141 #else // __WXWINCE__
1143 #endif // !__WXWINCE__/__WXWINCE__
1149 void wxDateTime::SetCountry(wxDateTime::Country country
)
1151 ms_country
= country
;
1155 bool wxDateTime::IsWestEuropeanCountry(Country country
)
1157 if ( country
== Country_Default
)
1159 country
= GetCountry();
1162 return (Country_WesternEurope_Start
<= country
) &&
1163 (country
<= Country_WesternEurope_End
);
1166 // ----------------------------------------------------------------------------
1167 // DST calculations: we use 3 different rules for the West European countries,
1168 // USA and for the rest of the world. This is undoubtedly false for many
1169 // countries, but I lack the necessary info (and the time to gather it),
1170 // please add the other rules here!
1171 // ----------------------------------------------------------------------------
1174 bool wxDateTime::IsDSTApplicable(int year
, Country country
)
1176 if ( year
== Inv_Year
)
1178 // take the current year if none given
1179 year
= GetCurrentYear();
1182 if ( country
== Country_Default
)
1184 country
= GetCountry();
1191 // DST was first observed in the US and UK during WWI, reused
1192 // during WWII and used again since 1966
1193 return year
>= 1966 ||
1194 (year
>= 1942 && year
<= 1945) ||
1195 (year
== 1918 || year
== 1919);
1198 // assume that it started after WWII
1204 wxDateTime
wxDateTime::GetBeginDST(int year
, Country country
)
1206 if ( year
== Inv_Year
)
1208 // take the current year if none given
1209 year
= GetCurrentYear();
1212 if ( country
== Country_Default
)
1214 country
= GetCountry();
1217 if ( !IsDSTApplicable(year
, country
) )
1219 return wxInvalidDateTime
;
1224 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
1226 // DST begins at 1 a.m. GMT on the last Sunday of March
1227 if ( !dt
.SetToLastWeekDay(Sun
, Mar
, year
) )
1230 wxFAIL_MSG( _T("no last Sunday in March?") );
1233 dt
+= wxTimeSpan::Hours(1);
1235 else switch ( country
)
1242 // don't know for sure - assume it was in effect all year
1247 dt
.Set(1, Jan
, year
);
1251 // DST was installed Feb 2, 1942 by the Congress
1252 dt
.Set(2, Feb
, year
);
1255 // Oil embargo changed the DST period in the US
1257 dt
.Set(6, Jan
, 1974);
1261 dt
.Set(23, Feb
, 1975);
1265 // before 1986, DST begun on the last Sunday of April, but
1266 // in 1986 Reagan changed it to begin at 2 a.m. of the
1267 // first Sunday in April
1270 if ( !dt
.SetToLastWeekDay(Sun
, Apr
, year
) )
1273 wxFAIL_MSG( _T("no first Sunday in April?") );
1278 if ( !dt
.SetToWeekDay(Sun
, 1, Apr
, year
) )
1281 wxFAIL_MSG( _T("no first Sunday in April?") );
1285 dt
+= wxTimeSpan::Hours(2);
1287 // TODO what about timezone??
1293 // assume Mar 30 as the start of the DST for the rest of the world
1294 // - totally bogus, of course
1295 dt
.Set(30, Mar
, year
);
1302 wxDateTime
wxDateTime::GetEndDST(int year
, Country country
)
1304 if ( year
== Inv_Year
)
1306 // take the current year if none given
1307 year
= GetCurrentYear();
1310 if ( country
== Country_Default
)
1312 country
= GetCountry();
1315 if ( !IsDSTApplicable(year
, country
) )
1317 return wxInvalidDateTime
;
1322 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
1324 // DST ends at 1 a.m. GMT on the last Sunday of October
1325 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1327 // weirder and weirder...
1328 wxFAIL_MSG( _T("no last Sunday in October?") );
1331 dt
+= wxTimeSpan::Hours(1);
1333 else switch ( country
)
1340 // don't know for sure - assume it was in effect all year
1344 dt
.Set(31, Dec
, year
);
1348 // the time was reset after the end of the WWII
1349 dt
.Set(30, Sep
, year
);
1353 // DST ends at 2 a.m. on the last Sunday of October
1354 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1356 // weirder and weirder...
1357 wxFAIL_MSG( _T("no last Sunday in October?") );
1360 dt
+= wxTimeSpan::Hours(2);
1362 // TODO what about timezone??
1367 // assume October 26th as the end of the DST - totally bogus too
1368 dt
.Set(26, Oct
, year
);
1374 // ----------------------------------------------------------------------------
1375 // constructors and assignment operators
1376 // ----------------------------------------------------------------------------
1378 // return the current time with ms precision
1379 /* static */ wxDateTime
wxDateTime::UNow()
1381 return wxDateTime(wxGetLocalTimeMillis());
1384 // the values in the tm structure contain the local time
1385 wxDateTime
& wxDateTime::Set(const struct tm
& tm
)
1388 time_t timet
= mktime(&tm2
);
1390 if ( timet
== (time_t)-1 )
1392 // mktime() rather unintuitively fails for Jan 1, 1970 if the hour is
1393 // less than timezone - try to make it work for this case
1394 if ( tm2
.tm_year
== 70 && tm2
.tm_mon
== 0 && tm2
.tm_mday
== 1 )
1396 return Set((time_t)(
1398 tm2
.tm_hour
* MIN_PER_HOUR
* SEC_PER_MIN
+
1399 tm2
.tm_min
* SEC_PER_MIN
+
1403 wxFAIL_MSG( _T("mktime() failed") );
1405 *this = wxInvalidDateTime
;
1415 wxDateTime
& wxDateTime::Set(wxDateTime_t hour
,
1416 wxDateTime_t minute
,
1417 wxDateTime_t second
,
1418 wxDateTime_t millisec
)
1420 // we allow seconds to be 61 to account for the leap seconds, even if we
1421 // don't use them really
1422 wxDATETIME_CHECK( hour
< 24 &&
1426 _T("Invalid time in wxDateTime::Set()") );
1428 // get the current date from system
1430 struct tm
*tm
= GetTmNow(&tmstruct
);
1432 wxDATETIME_CHECK( tm
, _T("wxLocaltime_r() failed") );
1434 // make a copy so it isn't clobbered by the call to mktime() below
1439 tm1
.tm_min
= minute
;
1440 tm1
.tm_sec
= second
;
1442 // and the DST in case it changes on this date
1445 if ( tm2
.tm_isdst
!= tm1
.tm_isdst
)
1446 tm1
.tm_isdst
= tm2
.tm_isdst
;
1450 // and finally adjust milliseconds
1451 return SetMillisecond(millisec
);
1454 wxDateTime
& wxDateTime::Set(wxDateTime_t day
,
1458 wxDateTime_t minute
,
1459 wxDateTime_t second
,
1460 wxDateTime_t millisec
)
1462 wxDATETIME_CHECK( hour
< 24 &&
1466 _T("Invalid time in wxDateTime::Set()") );
1468 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1470 wxDATETIME_CHECK( (0 < day
) && (day
<= GetNumberOfDays(month
, year
)),
1471 _T("Invalid date in wxDateTime::Set()") );
1473 // the range of time_t type (inclusive)
1474 static const int yearMinInRange
= 1970;
1475 static const int yearMaxInRange
= 2037;
1477 // test only the year instead of testing for the exact end of the Unix
1478 // time_t range - it doesn't bring anything to do more precise checks
1479 if ( year
>= yearMinInRange
&& year
<= yearMaxInRange
)
1481 // use the standard library version if the date is in range - this is
1482 // probably more efficient than our code
1484 tm
.tm_year
= year
- 1900;
1490 tm
.tm_isdst
= -1; // mktime() will guess it
1494 // and finally adjust milliseconds
1496 SetMillisecond(millisec
);
1502 // do time calculations ourselves: we want to calculate the number of
1503 // milliseconds between the given date and the epoch
1505 // get the JDN for the midnight of this day
1506 m_time
= GetTruncatedJDN(day
, month
, year
);
1507 m_time
-= EPOCH_JDN
;
1508 m_time
*= SECONDS_PER_DAY
* TIME_T_FACTOR
;
1510 // JDN corresponds to GMT, we take localtime
1511 Add(wxTimeSpan(hour
, minute
, second
+ GetTimeZone(), millisec
));
1517 wxDateTime
& wxDateTime::Set(double jdn
)
1519 // so that m_time will be 0 for the midnight of Jan 1, 1970 which is jdn
1521 jdn
-= EPOCH_JDN
+ 0.5;
1523 m_time
.Assign(jdn
*MILLISECONDS_PER_DAY
);
1525 // JDNs always are in UTC, so we don't need any adjustments for time zone
1530 wxDateTime
& wxDateTime::ResetTime()
1534 if ( tm
.hour
|| tm
.min
|| tm
.sec
|| tm
.msec
)
1547 wxDateTime
wxDateTime::GetDateOnly() const
1554 return wxDateTime(tm
);
1557 // ----------------------------------------------------------------------------
1558 // DOS Date and Time Format functions
1559 // ----------------------------------------------------------------------------
1560 // the dos date and time value is an unsigned 32 bit value in the format:
1561 // YYYYYYYMMMMDDDDDhhhhhmmmmmmsssss
1563 // Y = year offset from 1980 (0-127)
1565 // D = day of month (1-31)
1567 // m = minute (0-59)
1568 // s = bisecond (0-29) each bisecond indicates two seconds
1569 // ----------------------------------------------------------------------------
1571 wxDateTime
& wxDateTime::SetFromDOS(unsigned long ddt
)
1576 long year
= ddt
& 0xFE000000;
1581 long month
= ddt
& 0x1E00000;
1586 long day
= ddt
& 0x1F0000;
1590 long hour
= ddt
& 0xF800;
1594 long minute
= ddt
& 0x7E0;
1598 long second
= ddt
& 0x1F;
1599 tm
.tm_sec
= second
* 2;
1601 return Set(mktime(&tm
));
1604 unsigned long wxDateTime::GetAsDOS() const
1607 time_t ticks
= GetTicks();
1609 struct tm
*tm
= wxLocaltime_r(&ticks
, &tmstruct
);
1610 wxCHECK_MSG( tm
, ULONG_MAX
, _T("time can't be represented in DOS format") );
1612 long year
= tm
->tm_year
;
1616 long month
= tm
->tm_mon
;
1620 long day
= tm
->tm_mday
;
1623 long hour
= tm
->tm_hour
;
1626 long minute
= tm
->tm_min
;
1629 long second
= tm
->tm_sec
;
1632 ddt
= year
| month
| day
| hour
| minute
| second
;
1636 // ----------------------------------------------------------------------------
1637 // time_t <-> broken down time conversions
1638 // ----------------------------------------------------------------------------
1640 wxDateTime::Tm
wxDateTime::GetTm(const TimeZone
& tz
) const
1642 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1644 time_t time
= GetTicks();
1645 if ( time
!= (time_t)-1 )
1647 // use C RTL functions
1650 if ( tz
.GetOffset() == -GetTimeZone() )
1652 // we are working with local time
1653 tm
= wxLocaltime_r(&time
, &tmstruct
);
1655 // should never happen
1656 wxCHECK_MSG( tm
, Tm(), _T("wxLocaltime_r() failed") );
1660 time
+= (time_t)tz
.GetOffset();
1661 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
1662 int time2
= (int) time
;
1668 tm
= wxGmtime_r(&time
, &tmstruct
);
1670 // should never happen
1671 wxCHECK_MSG( tm
, Tm(), _T("wxGmtime_r() failed") );
1675 tm
= (struct tm
*)NULL
;
1681 // adjust the milliseconds
1683 long timeOnly
= (m_time
% MILLISECONDS_PER_DAY
).ToLong();
1684 tm2
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1687 //else: use generic code below
1690 // remember the time and do the calculations with the date only - this
1691 // eliminates rounding errors of the floating point arithmetics
1693 wxLongLong timeMidnight
= m_time
+ tz
.GetOffset() * 1000;
1695 long timeOnly
= (timeMidnight
% MILLISECONDS_PER_DAY
).ToLong();
1697 // we want to always have positive time and timeMidnight to be really
1698 // the midnight before it
1701 timeOnly
= MILLISECONDS_PER_DAY
+ timeOnly
;
1704 timeMidnight
-= timeOnly
;
1706 // calculate the Gregorian date from JDN for the midnight of our date:
1707 // this will yield day, month (in 1..12 range) and year
1709 // actually, this is the JDN for the noon of the previous day
1710 long jdn
= (timeMidnight
/ MILLISECONDS_PER_DAY
).ToLong() + EPOCH_JDN
;
1712 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
1714 wxASSERT_MSG( jdn
> -2, _T("JDN out of range") );
1716 // calculate the century
1717 long temp
= (jdn
+ JDN_OFFSET
) * 4 - 1;
1718 long century
= temp
/ DAYS_PER_400_YEARS
;
1720 // then the year and day of year (1 <= dayOfYear <= 366)
1721 temp
= ((temp
% DAYS_PER_400_YEARS
) / 4) * 4 + 3;
1722 long year
= (century
* 100) + (temp
/ DAYS_PER_4_YEARS
);
1723 long dayOfYear
= (temp
% DAYS_PER_4_YEARS
) / 4 + 1;
1725 // and finally the month and day of the month
1726 temp
= dayOfYear
* 5 - 3;
1727 long month
= temp
/ DAYS_PER_5_MONTHS
;
1728 long day
= (temp
% DAYS_PER_5_MONTHS
) / 5 + 1;
1730 // month is counted from March - convert to normal
1741 // year is offset by 4800
1744 // check that the algorithm gave us something reasonable
1745 wxASSERT_MSG( (0 < month
) && (month
<= 12), _T("invalid month") );
1746 wxASSERT_MSG( (1 <= day
) && (day
< 32), _T("invalid day") );
1748 // construct Tm from these values
1750 tm
.year
= (int)year
;
1751 tm
.mon
= (Month
)(month
- 1); // algorithm yields 1 for January, not 0
1752 tm
.mday
= (wxDateTime_t
)day
;
1753 tm
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1754 timeOnly
-= tm
.msec
;
1755 timeOnly
/= 1000; // now we have time in seconds
1757 tm
.sec
= (wxDateTime_t
)(timeOnly
% SEC_PER_MIN
);
1759 timeOnly
/= SEC_PER_MIN
; // now we have time in minutes
1761 tm
.min
= (wxDateTime_t
)(timeOnly
% MIN_PER_HOUR
);
1764 tm
.hour
= (wxDateTime_t
)(timeOnly
/ MIN_PER_HOUR
);
1769 wxDateTime
& wxDateTime::SetYear(int year
)
1771 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1780 wxDateTime
& wxDateTime::SetMonth(Month month
)
1782 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1791 wxDateTime
& wxDateTime::SetDay(wxDateTime_t mday
)
1793 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1802 wxDateTime
& wxDateTime::SetHour(wxDateTime_t hour
)
1804 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1813 wxDateTime
& wxDateTime::SetMinute(wxDateTime_t min
)
1815 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1824 wxDateTime
& wxDateTime::SetSecond(wxDateTime_t sec
)
1826 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1835 wxDateTime
& wxDateTime::SetMillisecond(wxDateTime_t millisecond
)
1837 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1839 // we don't need to use GetTm() for this one
1840 m_time
-= m_time
% 1000l;
1841 m_time
+= millisecond
;
1846 // ----------------------------------------------------------------------------
1847 // wxDateTime arithmetics
1848 // ----------------------------------------------------------------------------
1850 wxDateTime
& wxDateTime::Add(const wxDateSpan
& diff
)
1854 tm
.year
+= diff
.GetYears();
1855 tm
.AddMonths(diff
.GetMonths());
1857 // check that the resulting date is valid
1858 if ( tm
.mday
> GetNumOfDaysInMonth(tm
.year
, tm
.mon
) )
1860 // We suppose that when adding one month to Jan 31 we want to get Feb
1861 // 28 (or 29), i.e. adding a month to the last day of the month should
1862 // give the last day of the next month which is quite logical.
1864 // Unfortunately, there is no logic way to understand what should
1865 // Jan 30 + 1 month be - Feb 28 too or Feb 27 (assuming non leap year)?
1866 // We make it Feb 28 (last day too), but it is highly questionable.
1867 tm
.mday
= GetNumOfDaysInMonth(tm
.year
, tm
.mon
);
1870 tm
.AddDays(diff
.GetTotalDays());
1874 wxASSERT_MSG( IsSameTime(tm
),
1875 _T("Add(wxDateSpan) shouldn't modify time") );
1880 // ----------------------------------------------------------------------------
1881 // Weekday and monthday stuff
1882 // ----------------------------------------------------------------------------
1884 // convert Sun, Mon, ..., Sat into 6, 0, ..., 5
1885 static inline int ConvertWeekDayToMondayBase(int wd
)
1887 return wd
== wxDateTime::Sun
? 6 : wd
- 1;
1892 wxDateTime::SetToWeekOfYear(int year
, wxDateTime_t numWeek
, WeekDay wd
)
1894 wxASSERT_MSG( numWeek
> 0,
1895 _T("invalid week number: weeks are counted from 1") );
1897 // Jan 4 always lies in the 1st week of the year
1898 wxDateTime
dt(4, Jan
, year
);
1899 dt
.SetToWeekDayInSameWeek(wd
);
1900 dt
+= wxDateSpan::Weeks(numWeek
- 1);
1905 #if WXWIN_COMPATIBILITY_2_6
1906 // use a separate function to avoid warnings about using deprecated
1907 // SetToTheWeek in GetWeek below
1909 SetToTheWeek(int year
,
1910 wxDateTime::wxDateTime_t numWeek
,
1911 wxDateTime::WeekDay weekday
,
1912 wxDateTime::WeekFlags flags
)
1914 // Jan 4 always lies in the 1st week of the year
1915 wxDateTime
dt(4, wxDateTime::Jan
, year
);
1916 dt
.SetToWeekDayInSameWeek(weekday
, flags
);
1917 dt
+= wxDateSpan::Weeks(numWeek
- 1);
1922 bool wxDateTime::SetToTheWeek(wxDateTime_t numWeek
,
1926 int year
= GetYear();
1927 *this = ::SetToTheWeek(year
, numWeek
, weekday
, flags
);
1928 if ( GetYear() != year
)
1930 // oops... numWeek was too big
1937 wxDateTime
wxDateTime::GetWeek(wxDateTime_t numWeek
,
1939 WeekFlags flags
) const
1941 return ::SetToTheWeek(GetYear(), numWeek
, weekday
, flags
);
1943 #endif // WXWIN_COMPATIBILITY_2_6
1945 wxDateTime
& wxDateTime::SetToLastMonthDay(Month month
,
1948 // take the current month/year if none specified
1949 if ( year
== Inv_Year
)
1951 if ( month
== Inv_Month
)
1954 return Set(GetNumOfDaysInMonth(year
, month
), month
, year
);
1957 wxDateTime
& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday
, WeekFlags flags
)
1959 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
1961 int wdayDst
= weekday
,
1962 wdayThis
= GetWeekDay();
1963 if ( wdayDst
== wdayThis
)
1969 if ( flags
== Default_First
)
1971 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
1974 // the logic below based on comparing weekday and wdayThis works if Sun (0)
1975 // is the first day in the week, but breaks down for Monday_First case so
1976 // we adjust the week days in this case
1977 if ( flags
== Monday_First
)
1979 if ( wdayThis
== Sun
)
1981 if ( wdayDst
== Sun
)
1984 //else: Sunday_First, nothing to do
1986 // go forward or back in time to the day we want
1987 if ( wdayDst
< wdayThis
)
1989 return Subtract(wxDateSpan::Days(wdayThis
- wdayDst
));
1991 else // weekday > wdayThis
1993 return Add(wxDateSpan::Days(wdayDst
- wdayThis
));
1997 wxDateTime
& wxDateTime::SetToNextWeekDay(WeekDay weekday
)
1999 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
2002 WeekDay wdayThis
= GetWeekDay();
2003 if ( weekday
== wdayThis
)
2008 else if ( weekday
< wdayThis
)
2010 // need to advance a week
2011 diff
= 7 - (wdayThis
- weekday
);
2013 else // weekday > wdayThis
2015 diff
= weekday
- wdayThis
;
2018 return Add(wxDateSpan::Days(diff
));
2021 wxDateTime
& wxDateTime::SetToPrevWeekDay(WeekDay weekday
)
2023 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
2026 WeekDay wdayThis
= GetWeekDay();
2027 if ( weekday
== wdayThis
)
2032 else if ( weekday
> wdayThis
)
2034 // need to go to previous week
2035 diff
= 7 - (weekday
- wdayThis
);
2037 else // weekday < wdayThis
2039 diff
= wdayThis
- weekday
;
2042 return Subtract(wxDateSpan::Days(diff
));
2045 bool wxDateTime::SetToWeekDay(WeekDay weekday
,
2050 wxCHECK_MSG( weekday
!= Inv_WeekDay
, false, _T("invalid weekday") );
2052 // we don't check explicitly that -5 <= n <= 5 because we will return false
2053 // anyhow in such case - but may be should still give an assert for it?
2055 // take the current month/year if none specified
2056 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
2060 // TODO this probably could be optimised somehow...
2064 // get the first day of the month
2065 dt
.Set(1, month
, year
);
2068 WeekDay wdayFirst
= dt
.GetWeekDay();
2070 // go to the first weekday of the month
2071 int diff
= weekday
- wdayFirst
;
2075 // add advance n-1 weeks more
2078 dt
+= wxDateSpan::Days(diff
);
2080 else // count from the end of the month
2082 // get the last day of the month
2083 dt
.SetToLastMonthDay(month
, year
);
2086 WeekDay wdayLast
= dt
.GetWeekDay();
2088 // go to the last weekday of the month
2089 int diff
= wdayLast
- weekday
;
2093 // and rewind n-1 weeks from there
2096 dt
-= wxDateSpan::Days(diff
);
2099 // check that it is still in the same month
2100 if ( dt
.GetMonth() == month
)
2108 // no such day in this month
2114 wxDateTime::wxDateTime_t
GetDayOfYearFromTm(const wxDateTime::Tm
& tm
)
2116 return (wxDateTime::wxDateTime_t
)(gs_cumulatedDays
[wxDateTime::IsLeapYear(tm
.year
)][tm
.mon
] + tm
.mday
);
2119 wxDateTime::wxDateTime_t
wxDateTime::GetDayOfYear(const TimeZone
& tz
) const
2121 return GetDayOfYearFromTm(GetTm(tz
));
2124 wxDateTime::wxDateTime_t
2125 wxDateTime::GetWeekOfYear(wxDateTime::WeekFlags flags
, const TimeZone
& tz
) const
2127 if ( flags
== Default_First
)
2129 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
2133 wxDateTime_t nDayInYear
= GetDayOfYearFromTm(tm
);
2135 int wdTarget
= GetWeekDay(tz
);
2136 int wdYearStart
= wxDateTime(1, Jan
, GetYear()).GetWeekDay();
2138 if ( flags
== Sunday_First
)
2140 // FIXME: First week is not calculated correctly.
2141 week
= (nDayInYear
- wdTarget
+ 7) / 7;
2142 if ( wdYearStart
== Wed
|| wdYearStart
== Thu
)
2145 else // week starts with monday
2147 // adjust the weekdays to non-US style.
2148 wdYearStart
= ConvertWeekDayToMondayBase(wdYearStart
);
2149 wdTarget
= ConvertWeekDayToMondayBase(wdTarget
);
2151 // quoting from http://www.cl.cam.ac.uk/~mgk25/iso-time.html:
2153 // Week 01 of a year is per definition the first week that has the
2154 // Thursday in this year, which is equivalent to the week that
2155 // contains the fourth day of January. In other words, the first
2156 // week of a new year is the week that has the majority of its
2157 // days in the new year. Week 01 might also contain days from the
2158 // previous year and the week before week 01 of a year is the last
2159 // week (52 or 53) of the previous year even if it contains days
2160 // from the new year. A week starts with Monday (day 1) and ends
2161 // with Sunday (day 7).
2164 // if Jan 1 is Thursday or less, it is in the first week of this year
2165 if ( wdYearStart
< 4 )
2167 // count the number of entire weeks between Jan 1 and this date
2168 week
= (nDayInYear
+ wdYearStart
+ 6 - wdTarget
)/7;
2170 // be careful to check for overflow in the next year
2171 if ( week
== 53 && tm
.mday
- wdTarget
> 28 )
2174 else // Jan 1 is in the last week of the previous year
2176 // check if we happen to be at the last week of previous year:
2177 if ( tm
.mon
== Jan
&& tm
.mday
< 8 - wdYearStart
)
2178 week
= wxDateTime(31, Dec
, GetYear()-1).GetWeekOfYear();
2180 week
= (nDayInYear
+ wdYearStart
- 1 - wdTarget
)/7;
2184 return (wxDateTime::wxDateTime_t
)week
;
2187 wxDateTime::wxDateTime_t
wxDateTime::GetWeekOfMonth(wxDateTime::WeekFlags flags
,
2188 const TimeZone
& tz
) const
2191 wxDateTime dtMonthStart
= wxDateTime(1, tm
.mon
, tm
.year
);
2192 int nWeek
= GetWeekOfYear(flags
) - dtMonthStart
.GetWeekOfYear(flags
) + 1;
2195 // this may happen for January when Jan, 1 is the last week of the
2197 nWeek
+= IsLeapYear(tm
.year
- 1) ? 53 : 52;
2200 return (wxDateTime::wxDateTime_t
)nWeek
;
2203 wxDateTime
& wxDateTime::SetToYearDay(wxDateTime::wxDateTime_t yday
)
2205 int year
= GetYear();
2206 wxDATETIME_CHECK( (0 < yday
) && (yday
<= GetNumberOfDays(year
)),
2207 _T("invalid year day") );
2209 bool isLeap
= IsLeapYear(year
);
2210 for ( Month mon
= Jan
; mon
< Inv_Month
; wxNextMonth(mon
) )
2212 // for Dec, we can't compare with gs_cumulatedDays[mon + 1], but we
2213 // don't need it neither - because of the CHECK above we know that
2214 // yday lies in December then
2215 if ( (mon
== Dec
) || (yday
<= gs_cumulatedDays
[isLeap
][mon
+ 1]) )
2217 Set((wxDateTime::wxDateTime_t
)(yday
- gs_cumulatedDays
[isLeap
][mon
]), mon
, year
);
2226 // ----------------------------------------------------------------------------
2227 // Julian day number conversion and related stuff
2228 // ----------------------------------------------------------------------------
2230 double wxDateTime::GetJulianDayNumber() const
2232 return m_time
.ToDouble() / MILLISECONDS_PER_DAY
+ EPOCH_JDN
+ 0.5;
2235 double wxDateTime::GetRataDie() const
2237 // March 1 of the year 0 is Rata Die day -306 and JDN 1721119.5
2238 return GetJulianDayNumber() - 1721119.5 - 306;
2241 // ----------------------------------------------------------------------------
2242 // timezone and DST stuff
2243 // ----------------------------------------------------------------------------
2245 int wxDateTime::IsDST(wxDateTime::Country country
) const
2247 wxCHECK_MSG( country
== Country_Default
, -1,
2248 _T("country support not implemented") );
2250 // use the C RTL for the dates in the standard range
2251 time_t timet
= GetTicks();
2252 if ( timet
!= (time_t)-1 )
2255 tm
*tm
= wxLocaltime_r(&timet
, &tmstruct
);
2257 wxCHECK_MSG( tm
, -1, _T("wxLocaltime_r() failed") );
2259 return tm
->tm_isdst
;
2263 int year
= GetYear();
2265 if ( !IsDSTApplicable(year
, country
) )
2267 // no DST time in this year in this country
2271 return IsBetween(GetBeginDST(year
, country
), GetEndDST(year
, country
));
2275 wxDateTime
& wxDateTime::MakeTimezone(const TimeZone
& tz
, bool noDST
)
2277 long secDiff
= GetTimeZone() + tz
.GetOffset();
2279 // we need to know whether DST is or not in effect for this date unless
2280 // the test disabled by the caller
2281 if ( !noDST
&& (IsDST() == 1) )
2283 // FIXME we assume that the DST is always shifted by 1 hour
2287 return Add(wxTimeSpan::Seconds(secDiff
));
2290 wxDateTime
& wxDateTime::MakeFromTimezone(const TimeZone
& tz
, bool noDST
)
2292 long secDiff
= GetTimeZone() + tz
.GetOffset();
2294 // we need to know whether DST is or not in effect for this date unless
2295 // the test disabled by the caller
2296 if ( !noDST
&& (IsDST() == 1) )
2298 // FIXME we assume that the DST is always shifted by 1 hour
2302 return Subtract(wxTimeSpan::Seconds(secDiff
));
2305 // ----------------------------------------------------------------------------
2306 // wxDateTime to/from text representations
2307 // ----------------------------------------------------------------------------
2309 wxString
wxDateTime::Format(const wxString
& format
, const TimeZone
& tz
) const
2311 wxCHECK_MSG( !format
.empty(), wxEmptyString
,
2312 _T("NULL format in wxDateTime::Format") );
2314 // we have to use our own implementation if the date is out of range of
2315 // strftime() or if we use non standard specificators
2316 #ifdef HAVE_STRFTIME
2317 time_t time
= GetTicks();
2319 if ( (time
!= (time_t)-1) && !wxStrstr(format
, _T("%l")) )
2324 if ( tz
.GetOffset() == -GetTimeZone() )
2326 // we are working with local time
2327 tm
= wxLocaltime_r(&time
, &tmstruct
);
2329 // should never happen
2330 wxCHECK_MSG( tm
, wxEmptyString
, _T("wxLocaltime_r() failed") );
2334 time
+= (int)tz
.GetOffset();
2336 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
2337 int time2
= (int) time
;
2343 tm
= wxGmtime_r(&time
, &tmstruct
);
2345 // should never happen
2346 wxCHECK_MSG( tm
, wxEmptyString
, _T("wxGmtime_r() failed") );
2350 tm
= (struct tm
*)NULL
;
2356 return CallStrftime(format
, tm
);
2359 //else: use generic code below
2360 #endif // HAVE_STRFTIME
2362 // we only parse ANSI C format specifications here, no POSIX 2
2363 // complications, no GNU extensions but we do add support for a "%l" format
2364 // specifier allowing to get the number of milliseconds
2367 // used for calls to strftime() when we only deal with time
2368 struct tm tmTimeOnly
;
2369 tmTimeOnly
.tm_hour
= tm
.hour
;
2370 tmTimeOnly
.tm_min
= tm
.min
;
2371 tmTimeOnly
.tm_sec
= tm
.sec
;
2372 tmTimeOnly
.tm_wday
= 0;
2373 tmTimeOnly
.tm_yday
= 0;
2374 tmTimeOnly
.tm_mday
= 1; // any date will do
2375 tmTimeOnly
.tm_mon
= 0;
2376 tmTimeOnly
.tm_year
= 76;
2377 tmTimeOnly
.tm_isdst
= 0; // no DST, we adjust for tz ourselves
2379 wxString tmp
, res
, fmt
;
2380 for ( wxString::const_iterator p
= format
.begin(); p
!= format
.end(); ++p
)
2382 if ( *p
!= _T('%') )
2390 // set the default format
2391 switch ( (*++p
).GetValue() )
2393 case _T('Y'): // year has 4 digits
2397 case _T('j'): // day of year has 3 digits
2398 case _T('l'): // milliseconds have 3 digits
2402 case _T('w'): // week day as number has only one
2407 // it's either another valid format specifier in which case
2408 // the format is "%02d" (for all the rest) or we have the
2409 // field width preceding the format in which case it will
2410 // override the default format anyhow
2414 bool restart
= true;
2419 // start of the format specification
2420 switch ( (*p
).GetValue() )
2422 case _T('a'): // a weekday name
2424 // second parameter should be true for abbreviated names
2425 res
+= GetWeekDayName(tm
.GetWeekDay(),
2426 *p
== _T('a') ? Name_Abbr
: Name_Full
);
2429 case _T('b'): // a month name
2431 res
+= GetMonthName(tm
.mon
,
2432 *p
== _T('b') ? Name_Abbr
: Name_Full
);
2435 case _T('c'): // locale default date and time representation
2436 case _T('x'): // locale default date representation
2437 #ifdef HAVE_STRFTIME
2439 // the problem: there is no way to know what do these format
2440 // specifications correspond to for the current locale.
2442 // the solution: use a hack and still use strftime(): first
2443 // find the YEAR which is a year in the strftime() range (1970
2444 // - 2038) whose Jan 1 falls on the same week day as the Jan 1
2445 // of the real year. Then make a copy of the format and
2446 // replace all occurrences of YEAR in it with some unique
2447 // string not appearing anywhere else in it, then use
2448 // strftime() to format the date in year YEAR and then replace
2449 // YEAR back by the real year and the unique replacement
2450 // string back with YEAR. Notice that "all occurrences of YEAR"
2451 // means all occurrences of 4 digit as well as 2 digit form!
2453 // the bugs: we assume that neither of %c nor %x contains any
2454 // fields which may change between the YEAR and real year. For
2455 // example, the week number (%U, %W) and the day number (%j)
2456 // will change if one of these years is leap and the other one
2459 // find the YEAR: normally, for any year X, Jan 1 of the
2460 // year X + 28 is the same weekday as Jan 1 of X (because
2461 // the weekday advances by 1 for each normal X and by 2
2462 // for each leap X, hence by 5 every 4 years or by 35
2463 // which is 0 mod 7 every 28 years) but this rule breaks
2464 // down if there are years between X and Y which are
2465 // divisible by 4 but not leap (i.e. divisible by 100 but
2466 // not 400), hence the correction.
2468 int yearReal
= GetYear(tz
);
2469 int mod28
= yearReal
% 28;
2471 // be careful to not go too far - we risk to leave the
2476 year
= 1988 + mod28
; // 1988 == 0 (mod 28)
2480 year
= 1970 + mod28
- 10; // 1970 == 10 (mod 28)
2483 int nCentury
= year
/ 100,
2484 nCenturyReal
= yearReal
/ 100;
2486 // need to adjust for the years divisble by 400 which are
2487 // not leap but are counted like leap ones if we just take
2488 // the number of centuries in between for nLostWeekDays
2489 int nLostWeekDays
= (nCentury
- nCenturyReal
) -
2490 (nCentury
/ 4 - nCenturyReal
/ 4);
2492 // we have to gain back the "lost" weekdays: note that the
2493 // effect of this loop is to not do anything to
2494 // nLostWeekDays (which we won't use any more), but to
2495 // (indirectly) set the year correctly
2496 while ( (nLostWeekDays
% 7) != 0 )
2498 nLostWeekDays
+= year
++ % 4 ? 1 : 2;
2501 // finally move the year below 2000 so that the 2-digit
2502 // year number can never match the month or day of the
2503 // month when we do the replacements below
2507 wxASSERT_MSG( year
>= 1970 && year
< 2000,
2508 _T("logic error in wxDateTime::Format") );
2511 // use strftime() to format the same date but in supported
2514 // NB: we assume that strftime() doesn't check for the
2515 // date validity and will happily format the date
2516 // corresponding to Feb 29 of a non leap year (which
2517 // may happen if yearReal was leap and year is not)
2518 struct tm tmAdjusted
;
2520 tmAdjusted
.tm_hour
= tm
.hour
;
2521 tmAdjusted
.tm_min
= tm
.min
;
2522 tmAdjusted
.tm_sec
= tm
.sec
;
2523 tmAdjusted
.tm_wday
= tm
.GetWeekDay();
2524 tmAdjusted
.tm_yday
= GetDayOfYear();
2525 tmAdjusted
.tm_mday
= tm
.mday
;
2526 tmAdjusted
.tm_mon
= tm
.mon
;
2527 tmAdjusted
.tm_year
= year
- 1900;
2528 tmAdjusted
.tm_isdst
= 0; // no DST, already adjusted
2529 wxString str
= CallStrftime(*p
== _T('c') ? _T("%c")
2533 // now replace the replacement year with the real year:
2534 // notice that we have to replace the 4 digit year with
2535 // a unique string not appearing in strftime() output
2536 // first to prevent the 2 digit year from matching any
2537 // substring of the 4 digit year (but any day, month,
2538 // hours or minutes components should be safe because
2539 // they are never in 70-99 range)
2540 wxString
replacement("|");
2541 while ( str
.find(replacement
) != wxString::npos
)
2544 str
.Replace(wxString::Format("%d", year
),
2546 str
.Replace(wxString::Format("%d", year
% 100),
2547 wxString::Format("%d", yearReal
% 100));
2548 str
.Replace(replacement
,
2549 wxString::Format("%d", yearReal
));
2553 #else // !HAVE_STRFTIME
2554 // Use "%m/%d/%y %H:%M:%S" format instead
2555 res
+= wxString::Format(wxT("%02d/%02d/%04d %02d:%02d:%02d"),
2556 tm
.mon
+1,tm
.mday
, tm
.year
, tm
.hour
, tm
.min
, tm
.sec
);
2557 #endif // HAVE_STRFTIME/!HAVE_STRFTIME
2560 case _T('d'): // day of a month (01-31)
2561 res
+= wxString::Format(fmt
, tm
.mday
);
2564 case _T('H'): // hour in 24h format (00-23)
2565 res
+= wxString::Format(fmt
, tm
.hour
);
2568 case _T('I'): // hour in 12h format (01-12)
2570 // 24h -> 12h, 0h -> 12h too
2571 int hour12
= tm
.hour
> 12 ? tm
.hour
- 12
2572 : tm
.hour
? tm
.hour
: 12;
2573 res
+= wxString::Format(fmt
, hour12
);
2577 case _T('j'): // day of the year
2578 res
+= wxString::Format(fmt
, GetDayOfYear(tz
));
2581 case _T('l'): // milliseconds (NOT STANDARD)
2582 res
+= wxString::Format(fmt
, GetMillisecond(tz
));
2585 case _T('m'): // month as a number (01-12)
2586 res
+= wxString::Format(fmt
, tm
.mon
+ 1);
2589 case _T('M'): // minute as a decimal number (00-59)
2590 res
+= wxString::Format(fmt
, tm
.min
);
2593 case _T('p'): // AM or PM string
2594 #ifdef HAVE_STRFTIME
2595 res
+= CallStrftime(_T("%p"), &tmTimeOnly
);
2596 #else // !HAVE_STRFTIME
2597 res
+= (tmTimeOnly
.tm_hour
> 12) ? wxT("pm") : wxT("am");
2598 #endif // HAVE_STRFTIME/!HAVE_STRFTIME
2601 case _T('S'): // second as a decimal number (00-61)
2602 res
+= wxString::Format(fmt
, tm
.sec
);
2605 case _T('U'): // week number in the year (Sunday 1st week day)
2606 res
+= wxString::Format(fmt
, GetWeekOfYear(Sunday_First
, tz
));
2609 case _T('W'): // week number in the year (Monday 1st week day)
2610 res
+= wxString::Format(fmt
, GetWeekOfYear(Monday_First
, tz
));
2613 case _T('w'): // weekday as a number (0-6), Sunday = 0
2614 res
+= wxString::Format(fmt
, tm
.GetWeekDay());
2617 // case _T('x'): -- handled with "%c"
2619 case _T('X'): // locale default time representation
2620 // just use strftime() to format the time for us
2621 #ifdef HAVE_STRFTIME
2622 res
+= CallStrftime(_T("%X"), &tmTimeOnly
);
2623 #else // !HAVE_STRFTIME
2624 res
+= wxString::Format(wxT("%02d:%02d:%02d"),tm
.hour
, tm
.min
, tm
.sec
);
2625 #endif // HAVE_STRFTIME/!HAVE_STRFTIME
2628 case _T('y'): // year without century (00-99)
2629 res
+= wxString::Format(fmt
, tm
.year
% 100);
2632 case _T('Y'): // year with century
2633 res
+= wxString::Format(fmt
, tm
.year
);
2636 case _T('Z'): // timezone name
2637 #ifdef HAVE_STRFTIME
2638 res
+= CallStrftime(_T("%Z"), &tmTimeOnly
);
2643 // is it the format width?
2645 while ( *p
== _T('-') || *p
== _T('+') ||
2646 *p
== _T(' ') || wxIsdigit(*p
) )
2653 // we've only got the flags and width so far in fmt
2654 fmt
.Prepend(_T('%'));
2655 fmt
.Append(_T('d'));
2662 // no, it wasn't the width
2663 wxFAIL_MSG(_T("unknown format specificator"));
2665 // fall through and just copy it nevertheless
2667 case _T('%'): // a percent sign
2671 case 0: // the end of string
2672 wxFAIL_MSG(_T("missing format at the end of string"));
2674 // just put the '%' which was the last char in format
2684 // this function parses a string in (strict) RFC 822 format: see the section 5
2685 // of the RFC for the detailed description, but briefly it's something of the
2686 // form "Sat, 18 Dec 1999 00:48:30 +0100"
2688 // this function is "strict" by design - it must reject anything except true
2689 // RFC822 time specs.
2691 // TODO a great candidate for using reg exps
2692 const wxChar
*wxDateTime::ParseRfc822Date(const wxChar
* date
)
2694 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
2696 const wxChar
*p
= date
;
2697 const wxChar
*comma
= wxStrchr(p
, _T(','));
2700 // the part before comma is the weekday
2702 // skip it for now - we don't use but might check that it really
2703 // corresponds to the specfied date
2706 if ( *p
!= _T(' ') )
2708 wxLogDebug(_T("no space after weekday in RFC822 time spec"));
2710 return (wxChar
*)NULL
;
2716 // the following 1 or 2 digits are the day number
2717 if ( !wxIsdigit(*p
) )
2719 wxLogDebug(_T("day number expected in RFC822 time spec, none found"));
2721 return (wxChar
*)NULL
;
2724 wxDateTime_t day
= (wxDateTime_t
)(*p
++ - _T('0'));
2725 if ( wxIsdigit(*p
) )
2728 day
= (wxDateTime_t
)(day
+ (*p
++ - _T('0')));
2731 if ( *p
++ != _T(' ') )
2733 return (wxChar
*)NULL
;
2736 // the following 3 letters specify the month
2737 wxString
monName(p
, 3);
2739 if ( monName
== _T("Jan") )
2741 else if ( monName
== _T("Feb") )
2743 else if ( monName
== _T("Mar") )
2745 else if ( monName
== _T("Apr") )
2747 else if ( monName
== _T("May") )
2749 else if ( monName
== _T("Jun") )
2751 else if ( monName
== _T("Jul") )
2753 else if ( monName
== _T("Aug") )
2755 else if ( monName
== _T("Sep") )
2757 else if ( monName
== _T("Oct") )
2759 else if ( monName
== _T("Nov") )
2761 else if ( monName
== _T("Dec") )
2765 wxLogDebug(_T("Invalid RFC 822 month name '%s'"), monName
.c_str());
2767 return (wxChar
*)NULL
;
2772 if ( *p
++ != _T(' ') )
2774 return (wxChar
*)NULL
;
2778 if ( !wxIsdigit(*p
) )
2781 return (wxChar
*)NULL
;
2784 int year
= *p
++ - _T('0');
2786 if ( !wxIsdigit(*p
) )
2788 // should have at least 2 digits in the year
2789 return (wxChar
*)NULL
;
2793 year
+= *p
++ - _T('0');
2795 // is it a 2 digit year (as per original RFC 822) or a 4 digit one?
2796 if ( wxIsdigit(*p
) )
2799 year
+= *p
++ - _T('0');
2801 if ( !wxIsdigit(*p
) )
2803 // no 3 digit years please
2804 return (wxChar
*)NULL
;
2808 year
+= *p
++ - _T('0');
2811 if ( *p
++ != _T(' ') )
2813 return (wxChar
*)NULL
;
2816 // time is in the format hh:mm:ss and seconds are optional
2817 if ( !wxIsdigit(*p
) )
2819 return (wxChar
*)NULL
;
2822 wxDateTime_t hour
= (wxDateTime_t
)(*p
++ - _T('0'));
2824 if ( !wxIsdigit(*p
) )
2826 return (wxChar
*)NULL
;
2830 hour
= (wxDateTime_t
)(hour
+ (*p
++ - _T('0')));
2832 if ( *p
++ != _T(':') )
2834 return (wxChar
*)NULL
;
2837 if ( !wxIsdigit(*p
) )
2839 return (wxChar
*)NULL
;
2842 wxDateTime_t min
= (wxDateTime_t
)(*p
++ - _T('0'));
2844 if ( !wxIsdigit(*p
) )
2846 return (wxChar
*)NULL
;
2850 min
= (wxDateTime_t
)(min
+ *p
++ - _T('0'));
2852 wxDateTime_t sec
= 0;
2853 if ( *p
++ == _T(':') )
2855 if ( !wxIsdigit(*p
) )
2857 return (wxChar
*)NULL
;
2860 sec
= (wxDateTime_t
)(*p
++ - _T('0'));
2862 if ( !wxIsdigit(*p
) )
2864 return (wxChar
*)NULL
;
2868 sec
= (wxDateTime_t
)(sec
+ *p
++ - _T('0'));
2871 if ( *p
++ != _T(' ') )
2873 return (wxChar
*)NULL
;
2876 // and now the interesting part: the timezone
2877 int offset
wxDUMMY_INITIALIZE(0);
2878 if ( *p
== _T('-') || *p
== _T('+') )
2880 // the explicit offset given: it has the form of hhmm
2881 bool plus
= *p
++ == _T('+');
2883 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2885 return (wxChar
*)NULL
;
2889 offset
= MIN_PER_HOUR
*(10*(*p
- _T('0')) + (*(p
+ 1) - _T('0')));
2893 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2895 return (wxChar
*)NULL
;
2899 offset
+= 10*(*p
- _T('0')) + (*(p
+ 1) - _T('0'));
2910 // the symbolic timezone given: may be either military timezone or one
2911 // of standard abbreviations
2914 // military: Z = UTC, J unused, A = -1, ..., Y = +12
2915 static const int offsets
[26] =
2917 //A B C D E F G H I J K L M
2918 -1, -2, -3, -4, -5, -6, -7, -8, -9, 0, -10, -11, -12,
2919 //N O P R Q S T U V W Z Y Z
2920 +1, +2, +3, +4, +5, +6, +7, +8, +9, +10, +11, +12, 0
2923 if ( *p
< _T('A') || *p
> _T('Z') || *p
== _T('J') )
2925 wxLogDebug(_T("Invalid militaty timezone '%c'"), *p
);
2927 return (wxChar
*)NULL
;
2930 offset
= offsets
[*p
++ - _T('A')];
2936 if ( tz
== _T("UT") || tz
== _T("UTC") || tz
== _T("GMT") )
2938 else if ( tz
== _T("AST") )
2939 offset
= AST
- GMT0
;
2940 else if ( tz
== _T("ADT") )
2941 offset
= ADT
- GMT0
;
2942 else if ( tz
== _T("EST") )
2943 offset
= EST
- GMT0
;
2944 else if ( tz
== _T("EDT") )
2945 offset
= EDT
- GMT0
;
2946 else if ( tz
== _T("CST") )
2947 offset
= CST
- GMT0
;
2948 else if ( tz
== _T("CDT") )
2949 offset
= CDT
- GMT0
;
2950 else if ( tz
== _T("MST") )
2951 offset
= MST
- GMT0
;
2952 else if ( tz
== _T("MDT") )
2953 offset
= MDT
- GMT0
;
2954 else if ( tz
== _T("PST") )
2955 offset
= PST
- GMT0
;
2956 else if ( tz
== _T("PDT") )
2957 offset
= PDT
- GMT0
;
2960 wxLogDebug(_T("Unknown RFC 822 timezone '%s'"), p
);
2962 return (wxChar
*)NULL
;
2969 offset
*= MIN_PER_HOUR
;
2972 // the spec was correct, construct the date from the values we found
2973 Set(day
, mon
, year
, hour
, min
, sec
);
2974 MakeFromTimezone(TimeZone((wxDateTime_t
)(offset
*SEC_PER_MIN
)));
2981 // returns the string containing strftime() format used for short dates in the
2982 // current locale or an empty string
2983 static wxString
GetLocaleDateFormat()
2987 // there is no setlocale() under Windows CE, so just always query the
2990 if ( strcmp(setlocale(LC_ALL
, NULL
), "C") != 0 )
2993 // The locale was programatically set to non-C. We assume that this was
2994 // done using wxLocale, in which case thread's current locale is also
2995 // set to correct LCID value and we can use GetLocaleInfo to determine
2996 // the correct formatting string:
2998 LCID lcid
= LOCALE_USER_DEFAULT
;
3000 LCID lcid
= GetThreadLocale();
3002 // according to MSDN 80 chars is max allowed for short date format
3004 if ( ::GetLocaleInfo(lcid
, LOCALE_SSHORTDATE
, fmt
, WXSIZEOF(fmt
)) )
3006 wxChar chLast
= _T('\0');
3007 size_t lastCount
= 0;
3008 for ( const wxChar
*p
= fmt
; /* NUL handled inside */; p
++ )
3018 // these characters come in groups, start counting them
3028 // first deal with any special characters we have had
3034 switch ( lastCount
)
3038 // these two are the same as we
3039 // don't distinguish between 1 and
3040 // 2 digits for days
3053 wxFAIL_MSG( _T("too many 'd's") );
3058 switch ( lastCount
)
3062 // as for 'd' and 'dd' above
3075 wxFAIL_MSG( _T("too many 'M's") );
3080 switch ( lastCount
)
3092 wxFAIL_MSG( _T("wrong number of 'y's") );
3097 // strftime() doesn't have era string,
3098 // ignore this format
3099 wxASSERT_MSG( lastCount
<= 2,
3100 _T("too many 'g's") );
3104 wxFAIL_MSG( _T("unreachable") );
3111 // not a special character so must be just a separator,
3113 if ( *p
!= _T('\0') )
3115 if ( *p
== _T('%') )
3117 // this one needs to be escaped
3125 if ( *p
== _T('\0') )
3129 //else: GetLocaleInfo() failed, leave fmtDate value unchanged and
3130 // try our luck with the default formats
3132 //else: default C locale, default formats should work
3137 #endif // __WINDOWS__
3139 const wxChar
*wxDateTime::ParseFormat(const wxChar
*date
,
3140 const wxString
& format
,
3141 const wxDateTime
& dateDef
)
3143 wxCHECK_MSG( date
&& !format
.empty(), (wxChar
*)NULL
,
3144 _T("NULL pointer in wxDateTime::ParseFormat()") );
3149 // what fields have we found?
3150 bool haveWDay
= false,
3159 bool hourIsIn12hFormat
= false, // or in 24h one?
3160 isPM
= false; // AM by default
3162 // and the value of the items we have (init them to get rid of warnings)
3163 wxDateTime_t sec
= 0,
3166 WeekDay wday
= Inv_WeekDay
;
3167 wxDateTime_t yday
= 0,
3169 wxDateTime::Month mon
= Inv_Month
;
3172 const wxChar
*input
= date
;
3173 for ( wxString::const_iterator fmt
= format
.begin(); fmt
!= format
.end(); ++fmt
)
3175 if ( *fmt
!= _T('%') )
3177 if ( wxIsspace(*fmt
) )
3179 // a white space in the format string matches 0 or more white
3180 // spaces in the input
3181 while ( wxIsspace(*input
) )
3188 // any other character (not whitespace, not '%') must be
3189 // matched by itself in the input
3190 if ( *input
++ != *fmt
)
3193 return (wxChar
*)NULL
;
3197 // done with this format char
3201 // start of a format specification
3203 // parse the optional width
3205 while ( wxIsdigit(*++fmt
) )
3208 width
+= *fmt
- _T('0');
3211 // the default widths for the various fields
3214 switch ( (*fmt
).GetValue() )
3216 case _T('Y'): // year has 4 digits
3220 case _T('j'): // day of year has 3 digits
3221 case _T('l'): // milliseconds have 3 digits
3225 case _T('w'): // week day as number has only one
3230 // default for all other fields
3235 // then the format itself
3236 switch ( (*fmt
).GetValue() )
3238 case _T('a'): // a weekday name
3241 int flag
= *fmt
== _T('a') ? Name_Abbr
: Name_Full
;
3242 wday
= GetWeekDayFromName(GetAlphaToken(input
), flag
);
3243 if ( wday
== Inv_WeekDay
)
3246 return (wxChar
*)NULL
;
3252 case _T('b'): // a month name
3255 int flag
= *fmt
== _T('b') ? Name_Abbr
: Name_Full
;
3256 mon
= GetMonthFromName(GetAlphaToken(input
), flag
);
3257 if ( mon
== Inv_Month
)
3260 return (wxChar
*)NULL
;
3266 case _T('c'): // locale default date and time representation
3270 // this is the format which corresponds to ctime() output
3271 // and strptime("%c") should parse it, so try it first
3272 static const wxChar
*fmtCtime
= _T("%a %b %d %H:%M:%S %Y");
3274 const wxChar
*result
= dt
.ParseFormat(input
, fmtCtime
);
3277 result
= dt
.ParseFormat(input
, _T("%x %X"));
3282 result
= dt
.ParseFormat(input
, _T("%X %x"));
3287 // we've tried everything and still no match
3288 return (wxChar
*)NULL
;
3293 haveDay
= haveMon
= haveYear
=
3294 haveHour
= haveMin
= haveSec
= true;
3308 case _T('d'): // day of a month (01-31)
3309 if ( !GetNumericToken(width
, input
, &num
) ||
3310 (num
> 31) || (num
< 1) )
3313 return (wxChar
*)NULL
;
3316 // we can't check whether the day range is correct yet, will
3317 // do it later - assume ok for now
3319 mday
= (wxDateTime_t
)num
;
3322 case _T('H'): // hour in 24h format (00-23)
3323 if ( !GetNumericToken(width
, input
, &num
) || (num
> 23) )
3326 return (wxChar
*)NULL
;
3330 hour
= (wxDateTime_t
)num
;
3333 case _T('I'): // hour in 12h format (01-12)
3334 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 12) )
3337 return (wxChar
*)NULL
;
3341 hourIsIn12hFormat
= true;
3342 hour
= (wxDateTime_t
)(num
% 12); // 12 should be 0
3345 case _T('j'): // day of the year
3346 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 366) )
3349 return (wxChar
*)NULL
;
3353 yday
= (wxDateTime_t
)num
;
3356 case _T('m'): // month as a number (01-12)
3357 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 12) )
3360 return (wxChar
*)NULL
;
3364 mon
= (Month
)(num
- 1);
3367 case _T('M'): // minute as a decimal number (00-59)
3368 if ( !GetNumericToken(width
, input
, &num
) || (num
> 59) )
3371 return (wxChar
*)NULL
;
3375 min
= (wxDateTime_t
)num
;
3378 case _T('p'): // AM or PM string
3380 wxString am
, pm
, token
= GetAlphaToken(input
);
3382 GetAmPmStrings(&am
, &pm
);
3383 if (am
.empty() && pm
.empty())
3384 return (wxChar
*)NULL
; // no am/pm strings defined
3385 if ( token
.CmpNoCase(pm
) == 0 )
3389 else if ( token
.CmpNoCase(am
) != 0 )
3392 return (wxChar
*)NULL
;
3397 case _T('r'): // time as %I:%M:%S %p
3400 input
= dt
.ParseFormat(input
, _T("%I:%M:%S %p"));
3404 return (wxChar
*)NULL
;
3407 haveHour
= haveMin
= haveSec
= true;
3416 case _T('R'): // time as %H:%M
3419 input
= dt
.ParseFormat(input
, _T("%H:%M"));
3423 return (wxChar
*)NULL
;
3426 haveHour
= haveMin
= true;
3434 case _T('S'): // second as a decimal number (00-61)
3435 if ( !GetNumericToken(width
, input
, &num
) || (num
> 61) )
3438 return (wxChar
*)NULL
;
3442 sec
= (wxDateTime_t
)num
;
3445 case _T('T'): // time as %H:%M:%S
3448 input
= dt
.ParseFormat(input
, _T("%H:%M:%S"));
3452 return (wxChar
*)NULL
;
3455 haveHour
= haveMin
= haveSec
= true;
3464 case _T('w'): // weekday as a number (0-6), Sunday = 0
3465 if ( !GetNumericToken(width
, input
, &num
) || (wday
> 6) )
3468 return (wxChar
*)NULL
;
3472 wday
= (WeekDay
)num
;
3475 case _T('x'): // locale default date representation
3476 #ifdef HAVE_STRPTIME
3477 // try using strptime() -- it may fail even if the input is
3478 // correct but the date is out of range, so we will fall back
3479 // to our generic code anyhow
3483 const wxChar
*result
= CallStrptime(input
, "%x", &tm
);
3488 haveDay
= haveMon
= haveYear
= true;
3490 year
= 1900 + tm
.tm_year
;
3491 mon
= (Month
)tm
.tm_mon
;
3497 #endif // HAVE_STRPTIME
3505 // The above doesn't work for all locales, try to query
3506 // Windows for the right way of formatting the date:
3507 fmtDate
= GetLocaleDateFormat();
3508 if ( fmtDate
.empty() )
3511 if ( IsWestEuropeanCountry(GetCountry()) ||
3512 GetCountry() == Russia
)
3514 fmtDate
= _T("%d/%m/%y");
3515 fmtDateAlt
= _T("%m/%d/%y");
3519 fmtDate
= _T("%m/%d/%y");
3520 fmtDateAlt
= _T("%d/%m/%y");
3524 const wxChar
*result
= dt
.ParseFormat(input
, fmtDate
);
3526 if ( !result
&& !fmtDateAlt
.empty() )
3528 // ok, be nice and try another one
3529 result
= dt
.ParseFormat(input
, fmtDateAlt
);
3535 return (wxChar
*)NULL
;
3540 haveDay
= haveMon
= haveYear
= true;
3551 case _T('X'): // locale default time representation
3552 #ifdef HAVE_STRPTIME
3554 // use strptime() to do it for us (FIXME !Unicode friendly)
3556 input
= CallStrptime(input
, "%X", &tm
);
3559 return (wxChar
*)NULL
;
3562 haveHour
= haveMin
= haveSec
= true;
3568 #else // !HAVE_STRPTIME
3569 // TODO under Win32 we can query the LOCALE_ITIME system
3570 // setting which says whether the default time format is
3573 // try to parse what follows as "%H:%M:%S" and, if this
3574 // fails, as "%I:%M:%S %p" - this should catch the most
3578 const wxChar
*result
= dt
.ParseFormat(input
, _T("%T"));
3581 result
= dt
.ParseFormat(input
, _T("%r"));
3587 return (wxChar
*)NULL
;
3590 haveHour
= haveMin
= haveSec
= true;
3599 #endif // HAVE_STRPTIME/!HAVE_STRPTIME
3602 case _T('y'): // year without century (00-99)
3603 if ( !GetNumericToken(width
, input
, &num
) || (num
> 99) )
3606 return (wxChar
*)NULL
;
3611 // TODO should have an option for roll over date instead of
3612 // hard coding it here
3613 year
= (num
> 30 ? 1900 : 2000) + (wxDateTime_t
)num
;
3616 case _T('Y'): // year with century
3617 if ( !GetNumericToken(width
, input
, &num
) )
3620 return (wxChar
*)NULL
;
3624 year
= (wxDateTime_t
)num
;
3627 case _T('Z'): // timezone name
3628 wxFAIL_MSG(_T("TODO"));
3631 case _T('%'): // a percent sign
3632 if ( *input
++ != _T('%') )
3635 return (wxChar
*)NULL
;
3639 case 0: // the end of string
3640 wxFAIL_MSG(_T("unexpected format end"));
3644 default: // not a known format spec
3645 return (wxChar
*)NULL
;
3649 // format matched, try to construct a date from what we have now
3651 if ( dateDef
.IsValid() )
3653 // take this date as default
3654 tmDef
= dateDef
.GetTm();
3656 else if ( IsValid() )
3658 // if this date is valid, don't change it
3663 // no default and this date is invalid - fall back to Today()
3664 tmDef
= Today().GetTm();
3675 // TODO we don't check here that the values are consistent, if both year
3676 // day and month/day were found, we just ignore the year day and we
3677 // also always ignore the week day
3678 if ( haveMon
&& haveDay
)
3680 if ( mday
> GetNumOfDaysInMonth(tm
.year
, mon
) )
3682 wxLogDebug(_T("bad month day in wxDateTime::ParseFormat"));
3684 return (wxChar
*)NULL
;
3690 else if ( haveYDay
)
3692 if ( yday
> GetNumberOfDays(tm
.year
) )
3694 wxLogDebug(_T("bad year day in wxDateTime::ParseFormat"));
3696 return (wxChar
*)NULL
;
3699 Tm tm2
= wxDateTime(1, Jan
, tm
.year
).SetToYearDay(yday
).GetTm();
3706 if ( haveHour
&& hourIsIn12hFormat
&& isPM
)
3708 // translate to 24hour format
3711 //else: either already in 24h format or no translation needed
3731 // finally check that the week day is consistent -- if we had it
3732 if ( haveWDay
&& GetWeekDay() != wday
)
3734 wxLogDebug(_T("inconsistsnet week day in wxDateTime::ParseFormat()"));
3742 const wxChar
*wxDateTime::ParseDateTime(const wxChar
*date
)
3744 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3746 // Set to current day and hour, so strings like '14:00' becomes today at
3747 // 14, not some other random date
3748 wxDateTime dtDate
= wxDateTime::Today();
3749 wxDateTime dtTime
= wxDateTime::Today();
3751 const wxChar
* pchTime
;
3753 // Try to parse the beginning of the string as a date
3754 const wxChar
* pchDate
= dtDate
.ParseDate(date
);
3756 // We got a date in the beginning, see if there is a time specified after the date
3759 // Skip spaces, as the ParseTime() function fails on spaces
3760 while ( wxIsspace(*pchDate
) )
3763 pchTime
= dtTime
.ParseTime(pchDate
);
3765 else // no date in the beginning
3767 // check and see if we have a time followed by a date
3768 pchTime
= dtTime
.ParseTime(date
);
3771 while ( wxIsspace(*pchTime
) )
3774 pchDate
= dtDate
.ParseDate(pchTime
);
3778 // If we have a date specified, set our own data to the same date
3779 if ( !pchDate
|| !pchTime
)
3782 Set(dtDate
.GetDay(), dtDate
.GetMonth(), dtDate
.GetYear(),
3783 dtTime
.GetHour(), dtTime
.GetMinute(), dtTime
.GetSecond(),
3784 dtTime
.GetMillisecond());
3786 // Return endpoint of scan
3787 return pchDate
> pchTime
? pchDate
: pchTime
;
3790 const wxChar
*wxDateTime::ParseDate(const wxChar
*date
)
3792 // this is a simplified version of ParseDateTime() which understands only
3793 // "today" (for wxDate compatibility) and digits only otherwise (and not
3794 // all esoteric constructions ParseDateTime() knows about)
3796 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3798 const wxChar
*p
= date
;
3799 while ( wxIsspace(*p
) )
3802 // some special cases
3806 int dayDiffFromToday
;
3809 { wxTRANSLATE("today"), 0 },
3810 { wxTRANSLATE("yesterday"), -1 },
3811 { wxTRANSLATE("tomorrow"), 1 },
3814 for ( size_t n
= 0; n
< WXSIZEOF(literalDates
); n
++ )
3816 const wxString dateStr
= wxGetTranslation(literalDates
[n
].str
);
3817 size_t len
= dateStr
.length();
3818 if ( wxStrlen(p
) >= len
)
3820 wxString
str(p
, len
);
3821 if ( str
.CmpNoCase(dateStr
) == 0 )
3823 // nothing can follow this, so stop here
3826 int dayDiffFromToday
= literalDates
[n
].dayDiffFromToday
;
3828 if ( dayDiffFromToday
)
3830 *this += wxDateSpan::Days(dayDiffFromToday
);
3838 // We try to guess what we have here: for each new (numeric) token, we
3839 // determine if it can be a month, day or a year. Of course, there is an
3840 // ambiguity as some numbers may be days as well as months, so we also
3841 // have the ability to back track.
3844 bool haveDay
= false, // the months day?
3845 haveWDay
= false, // the day of week?
3846 haveMon
= false, // the month?
3847 haveYear
= false; // the year?
3849 // and the value of the items we have (init them to get rid of warnings)
3850 WeekDay wday
= Inv_WeekDay
;
3851 wxDateTime_t day
= 0;
3852 wxDateTime::Month mon
= Inv_Month
;
3855 // tokenize the string
3857 static const wxChar
*dateDelimiters
= _T(".,/-\t\r\n ");
3858 wxStringTokenizer
tok(p
, dateDelimiters
);
3859 while ( tok
.HasMoreTokens() )
3861 wxString token
= tok
.GetNextToken();
3867 if ( token
.ToULong(&val
) )
3869 // guess what this number is
3875 if ( !haveMon
&& val
> 0 && val
<= 12 )
3877 // assume it is month
3880 else // not the month
3884 // this can only be the year
3887 else // may be either day or year
3889 // use a leap year if we don't have the year yet to allow
3890 // dates like 2/29/1976 which would be rejected otherwise
3891 wxDateTime_t max_days
= (wxDateTime_t
)(
3893 ? GetNumOfDaysInMonth(haveYear
? year
: 1976, mon
)
3898 if ( (val
== 0) || (val
> (unsigned long)max_days
) )
3903 else // yes, suppose it's the day
3917 year
= (wxDateTime_t
)val
;
3926 day
= (wxDateTime_t
)val
;
3932 mon
= (Month
)(val
- 1);
3935 else // not a number
3937 // be careful not to overwrite the current mon value
3938 Month mon2
= GetMonthFromName(token
, Name_Full
| Name_Abbr
);
3939 if ( mon2
!= Inv_Month
)
3944 // but we already have a month - maybe we guessed wrong?
3947 // no need to check in month range as always < 12, but
3948 // the days are counted from 1 unlike the months
3949 day
= (wxDateTime_t
)(mon
+ 1);
3954 // could possible be the year (doesn't the year come
3955 // before the month in the japanese format?) (FIXME)
3964 else // not a valid month name
3966 WeekDay wday2
= GetWeekDayFromName(token
, Name_Full
| Name_Abbr
);
3967 if ( wday2
!= Inv_WeekDay
)
3979 else // not a valid weekday name
3982 static const char *ordinals
[] =
3984 wxTRANSLATE("first"),
3985 wxTRANSLATE("second"),
3986 wxTRANSLATE("third"),
3987 wxTRANSLATE("fourth"),
3988 wxTRANSLATE("fifth"),
3989 wxTRANSLATE("sixth"),
3990 wxTRANSLATE("seventh"),
3991 wxTRANSLATE("eighth"),
3992 wxTRANSLATE("ninth"),
3993 wxTRANSLATE("tenth"),
3994 wxTRANSLATE("eleventh"),
3995 wxTRANSLATE("twelfth"),
3996 wxTRANSLATE("thirteenth"),
3997 wxTRANSLATE("fourteenth"),
3998 wxTRANSLATE("fifteenth"),
3999 wxTRANSLATE("sixteenth"),
4000 wxTRANSLATE("seventeenth"),
4001 wxTRANSLATE("eighteenth"),
4002 wxTRANSLATE("nineteenth"),
4003 wxTRANSLATE("twentieth"),
4004 // that's enough - otherwise we'd have problems with
4005 // composite (or not) ordinals
4009 for ( n
= 0; n
< WXSIZEOF(ordinals
); n
++ )
4011 if ( token
.CmpNoCase(ordinals
[n
]) == 0 )
4017 if ( n
== WXSIZEOF(ordinals
) )
4019 // stop here - something unknown
4026 // don't try anything here (as in case of numeric day
4027 // above) - the symbolic day spec should always
4028 // precede the month/year
4034 day
= (wxDateTime_t
)(n
+ 1);
4039 nPosCur
= tok
.GetPosition();
4042 // either no more tokens or the scan was stopped by something we couldn't
4043 // parse - in any case, see if we can construct a date from what we have
4044 if ( !haveDay
&& !haveWDay
)
4046 wxLogDebug(_T("ParseDate: no day, no weekday hence no date."));
4051 if ( haveWDay
&& (haveMon
|| haveYear
|| haveDay
) &&
4052 !(haveDay
&& haveMon
&& haveYear
) )
4054 // without adjectives (which we don't support here) the week day only
4055 // makes sense completely separately or with the full date
4056 // specification (what would "Wed 1999" mean?)
4060 if ( !haveWDay
&& haveYear
&& !(haveDay
&& haveMon
) )
4062 // may be we have month and day instead of day and year?
4063 if ( haveDay
&& !haveMon
)
4067 // exchange day and month
4068 mon
= (wxDateTime::Month
)(day
- 1);
4070 // we're in the current year then
4071 if ( (year
> 0) && (year
<= (int)GetNumOfDaysInMonth(Inv_Year
, mon
)) )
4073 day
= (wxDateTime_t
)year
;
4078 //else: no, can't exchange, leave haveMon == false
4084 // if we give the year, month and day must be given too
4085 wxLogDebug(_T("ParseDate: day and month should be specified if year is."));
4093 mon
= GetCurrentMonth();
4098 year
= GetCurrentYear();
4103 // normally we check the day above but the check is optimistic in case
4104 // we find the day before its month/year so we have to redo it now
4105 if ( day
> GetNumOfDaysInMonth(year
, mon
) )
4108 Set(day
, mon
, year
);
4112 // check that it is really the same
4113 if ( GetWeekDay() != wday
)
4115 // inconsistency detected
4116 wxLogDebug(_T("ParseDate: inconsistent day/weekday."));
4118 return (wxChar
*)NULL
;
4126 SetToWeekDayInSameWeek(wday
);
4129 // return the pointer to the first unparsed char
4131 if ( nPosCur
&& wxStrchr(dateDelimiters
, *(p
- 1)) )
4133 // if we couldn't parse the token after the delimiter, put back the
4134 // delimiter as well
4141 const wxChar
*wxDateTime::ParseTime(const wxChar
*time
)
4143 wxCHECK_MSG( time
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
4145 // first try some extra things
4152 { wxTRANSLATE("noon"), 12 },
4153 { wxTRANSLATE("midnight"), 00 },
4157 for ( size_t n
= 0; n
< WXSIZEOF(stdTimes
); n
++ )
4159 wxString timeString
= wxGetTranslation(stdTimes
[n
].name
);
4160 size_t len
= timeString
.length();
4161 if ( timeString
.CmpNoCase(wxString(time
, len
)) == 0 )
4163 // casts required by DigitalMars
4164 Set(stdTimes
[n
].hour
, wxDateTime_t(0), wxDateTime_t(0));
4170 // try all time formats we may think about in the order from longest to
4173 // 12hour with AM/PM?
4174 const wxChar
*result
= ParseFormat(time
, _T("%I:%M:%S %p"));
4178 // normally, it's the same, but why not try it?
4179 result
= ParseFormat(time
, _T("%H:%M:%S"));
4184 // 12hour with AM/PM but without seconds?
4185 result
= ParseFormat(time
, _T("%I:%M %p"));
4191 result
= ParseFormat(time
, _T("%H:%M"));
4196 // just the hour and AM/PM?
4197 result
= ParseFormat(time
, _T("%I %p"));
4203 result
= ParseFormat(time
, _T("%H"));
4208 // parse the standard format: normally it is one of the formats above
4209 // but it may be set to something completely different by the user
4210 result
= ParseFormat(time
, _T("%X"));
4213 // TODO: parse timezones
4218 // ----------------------------------------------------------------------------
4219 // Workdays and holidays support
4220 // ----------------------------------------------------------------------------
4222 bool wxDateTime::IsWorkDay(Country
WXUNUSED(country
)) const
4224 return !wxDateTimeHolidayAuthority::IsHoliday(*this);
4227 // ============================================================================
4229 // ============================================================================
4231 wxDateSpan WXDLLIMPEXP_BASE
operator*(int n
, const wxDateSpan
& ds
)
4234 return ds1
.Multiply(n
);
4237 // ============================================================================
4239 // ============================================================================
4241 wxTimeSpan WXDLLIMPEXP_BASE
operator*(int n
, const wxTimeSpan
& ts
)
4243 return wxTimeSpan(ts
).Multiply(n
);
4246 // this enum is only used in wxTimeSpan::Format() below but we can't declare
4247 // it locally to the method as it provokes an internal compiler error in egcs
4248 // 2.91.60 when building with -O2
4259 // not all strftime(3) format specifiers make sense here because, for example,
4260 // a time span doesn't have a year nor a timezone
4262 // Here are the ones which are supported (all of them are supported by strftime
4264 // %H hour in 24 hour format
4265 // %M minute (00 - 59)
4266 // %S second (00 - 59)
4269 // Also, for MFC CTimeSpan compatibility, we support
4270 // %D number of days
4272 // And, to be better than MFC :-), we also have
4273 // %E number of wEeks
4274 // %l milliseconds (000 - 999)
4275 wxString
wxTimeSpan::Format(const wxString
& format
) const
4277 wxCHECK_MSG( !format
.empty(), wxEmptyString
,
4278 _T("NULL format in wxTimeSpan::Format") );
4281 str
.Alloc(format
.length());
4283 // Suppose we have wxTimeSpan ts(1 /* hour */, 2 /* min */, 3 /* sec */)
4285 // Then, of course, ts.Format("%H:%M:%S") must return "01:02:03", but the
4286 // question is what should ts.Format("%S") do? The code here returns "3273"
4287 // in this case (i.e. the total number of seconds, not just seconds % 60)
4288 // because, for me, this call means "give me entire time interval in
4289 // seconds" and not "give me the seconds part of the time interval"
4291 // If we agree that it should behave like this, it is clear that the
4292 // interpretation of each format specifier depends on the presence of the
4293 // other format specs in the string: if there was "%H" before "%M", we
4294 // should use GetMinutes() % 60, otherwise just GetMinutes() &c
4296 // we remember the most important unit found so far
4297 TimeSpanPart partBiggest
= Part_MSec
;
4299 for ( wxString::const_iterator pch
= format
.begin(); pch
!= format
.end(); ++pch
)
4303 if ( ch
== _T('%') )
4305 // the start of the format specification of the printf() below
4306 wxString
fmtPrefix(_T('%'));
4311 // the number of digits for the format string, 0 if unused
4312 unsigned digits
= 0;
4314 ch
= *++pch
; // get the format spec char
4318 wxFAIL_MSG( _T("invalid format character") );
4324 // skip the part below switch
4329 if ( partBiggest
< Part_Day
)
4335 partBiggest
= Part_Day
;
4340 partBiggest
= Part_Week
;
4346 if ( partBiggest
< Part_Hour
)
4350 // the sign has already been taken into account
4351 // when outputting the biggest part
4359 partBiggest
= Part_Hour
;
4366 n
= GetMilliseconds().ToLong();
4367 if ( partBiggest
< Part_MSec
)
4374 //else: no need to reset partBiggest to Part_MSec, it is
4375 // the least significant one anyhow
4382 if ( partBiggest
< Part_Min
)
4391 partBiggest
= Part_Min
;
4398 n
= GetSeconds().ToLong();
4399 if ( partBiggest
< Part_Sec
)
4408 partBiggest
= Part_Sec
;
4417 // negative numbers need one extra position for '-' display
4421 fmtPrefix
<< _T("0") << digits
;
4424 str
+= wxString::Format(fmtPrefix
+ _T("ld"), n
);
4428 // normal character, just copy
4436 // ============================================================================
4437 // wxDateTimeHolidayAuthority and related classes
4438 // ============================================================================
4440 #include "wx/arrimpl.cpp"
4442 WX_DEFINE_OBJARRAY(wxDateTimeArray
)
4444 static int wxCMPFUNC_CONV
4445 wxDateTimeCompareFunc(wxDateTime
**first
, wxDateTime
**second
)
4447 wxDateTime dt1
= **first
,
4450 return dt1
== dt2
? 0 : dt1
< dt2
? -1 : +1;
4453 // ----------------------------------------------------------------------------
4454 // wxDateTimeHolidayAuthority
4455 // ----------------------------------------------------------------------------
4457 wxHolidayAuthoritiesArray
wxDateTimeHolidayAuthority::ms_authorities
;
4460 bool wxDateTimeHolidayAuthority::IsHoliday(const wxDateTime
& dt
)
4462 size_t count
= ms_authorities
.size();
4463 for ( size_t n
= 0; n
< count
; n
++ )
4465 if ( ms_authorities
[n
]->DoIsHoliday(dt
) )
4476 wxDateTimeHolidayAuthority::GetHolidaysInRange(const wxDateTime
& dtStart
,
4477 const wxDateTime
& dtEnd
,
4478 wxDateTimeArray
& holidays
)
4480 wxDateTimeArray hol
;
4484 const size_t countAuth
= ms_authorities
.size();
4485 for ( size_t nAuth
= 0; nAuth
< countAuth
; nAuth
++ )
4487 ms_authorities
[nAuth
]->DoGetHolidaysInRange(dtStart
, dtEnd
, hol
);
4489 WX_APPEND_ARRAY(holidays
, hol
);
4492 holidays
.Sort(wxDateTimeCompareFunc
);
4494 return holidays
.size();
4498 void wxDateTimeHolidayAuthority::ClearAllAuthorities()
4500 WX_CLEAR_ARRAY(ms_authorities
);
4504 void wxDateTimeHolidayAuthority::AddAuthority(wxDateTimeHolidayAuthority
*auth
)
4506 ms_authorities
.push_back(auth
);
4509 wxDateTimeHolidayAuthority::~wxDateTimeHolidayAuthority()
4511 // required here for Darwin
4514 // ----------------------------------------------------------------------------
4515 // wxDateTimeWorkDays
4516 // ----------------------------------------------------------------------------
4518 bool wxDateTimeWorkDays::DoIsHoliday(const wxDateTime
& dt
) const
4520 wxDateTime::WeekDay wd
= dt
.GetWeekDay();
4522 return (wd
== wxDateTime::Sun
) || (wd
== wxDateTime::Sat
);
4525 size_t wxDateTimeWorkDays::DoGetHolidaysInRange(const wxDateTime
& dtStart
,
4526 const wxDateTime
& dtEnd
,
4527 wxDateTimeArray
& holidays
) const
4529 if ( dtStart
> dtEnd
)
4531 wxFAIL_MSG( _T("invalid date range in GetHolidaysInRange") );
4538 // instead of checking all days, start with the first Sat after dtStart and
4539 // end with the last Sun before dtEnd
4540 wxDateTime dtSatFirst
= dtStart
.GetNextWeekDay(wxDateTime::Sat
),
4541 dtSatLast
= dtEnd
.GetPrevWeekDay(wxDateTime::Sat
),
4542 dtSunFirst
= dtStart
.GetNextWeekDay(wxDateTime::Sun
),
4543 dtSunLast
= dtEnd
.GetPrevWeekDay(wxDateTime::Sun
),
4546 for ( dt
= dtSatFirst
; dt
<= dtSatLast
; dt
+= wxDateSpan::Week() )
4551 for ( dt
= dtSunFirst
; dt
<= dtSunLast
; dt
+= wxDateSpan::Week() )
4556 return holidays
.GetCount();
4559 // ============================================================================
4560 // other helper functions
4561 // ============================================================================
4563 // ----------------------------------------------------------------------------
4564 // iteration helpers: can be used to write a for loop over enum variable like
4566 // for ( m = wxDateTime::Jan; m < wxDateTime::Inv_Month; wxNextMonth(m) )
4567 // ----------------------------------------------------------------------------
4569 WXDLLIMPEXP_BASE
void wxNextMonth(wxDateTime::Month
& m
)
4571 wxASSERT_MSG( m
< wxDateTime::Inv_Month
, _T("invalid month") );
4573 // no wrapping or the for loop above would never end!
4574 m
= (wxDateTime::Month
)(m
+ 1);
4577 WXDLLIMPEXP_BASE
void wxPrevMonth(wxDateTime::Month
& m
)
4579 wxASSERT_MSG( m
< wxDateTime::Inv_Month
, _T("invalid month") );
4581 m
= m
== wxDateTime::Jan
? wxDateTime::Inv_Month
4582 : (wxDateTime::Month
)(m
- 1);
4585 WXDLLIMPEXP_BASE
void wxNextWDay(wxDateTime::WeekDay
& wd
)
4587 wxASSERT_MSG( wd
< wxDateTime::Inv_WeekDay
, _T("invalid week day") );
4589 // no wrapping or the for loop above would never end!
4590 wd
= (wxDateTime::WeekDay
)(wd
+ 1);
4593 WXDLLIMPEXP_BASE
void wxPrevWDay(wxDateTime::WeekDay
& wd
)
4595 wxASSERT_MSG( wd
< wxDateTime::Inv_WeekDay
, _T("invalid week day") );
4597 wd
= wd
== wxDateTime::Sun
? wxDateTime::Inv_WeekDay
4598 : (wxDateTime::WeekDay
)(wd
- 1);
4601 #endif // wxUSE_DATETIME