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 #define WX_TIMEZONE _timezone
175 #else // unknown platform - try timezone
176 #define WX_TIMEZONE timezone
178 #endif // !WX_TIMEZONE && !WX_GMTOFF_IN_TM
180 // everyone has strftime except Win CE unless VC8 is used
181 #if !defined(__WXWINCE__) || defined(__VISUALC8__)
182 #define HAVE_STRFTIME
185 // NB: VC8 safe time functions could/should be used for wxMSW as well probably
186 #if defined(__WXWINCE__) && defined(__VISUALC8__)
188 struct tm
*wxLocaltime_r(const time_t *t
, struct tm
* tm
)
191 return _localtime64_s(tm
, &t64
) == 0 ? tm
: NULL
;
194 struct tm
*wxGmtime_r(const time_t* t
, struct tm
* tm
)
197 return _gmtime64_s(tm
, &t64
) == 0 ? tm
: NULL
;
200 #else // !wxWinCE with VC8
202 #if (!defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)) && wxUSE_THREADS && !defined(__WINDOWS__)
203 static wxMutex timeLock
;
206 #ifndef HAVE_LOCALTIME_R
207 struct tm
*wxLocaltime_r(const time_t* ticks
, struct tm
* temp
)
209 #if wxUSE_THREADS && !defined(__WINDOWS__)
210 // No need to waste time with a mutex on windows since it's using
211 // thread local storage for localtime anyway.
212 wxMutexLocker
locker(timeLock
);
215 // Borland CRT crashes when passed 0 ticks for some reason, see SF bug 1704438
221 const tm
* const t
= localtime(ticks
);
225 memcpy(temp
, t
, sizeof(struct tm
));
228 #endif // !HAVE_LOCALTIME_R
230 #ifndef HAVE_GMTIME_R
231 struct tm
*wxGmtime_r(const time_t* ticks
, struct tm
* temp
)
233 #if wxUSE_THREADS && !defined(__WINDOWS__)
234 // No need to waste time with a mutex on windows since it's
235 // using thread local storage for gmtime anyway.
236 wxMutexLocker
locker(timeLock
);
244 const tm
* const t
= gmtime(ticks
);
248 memcpy(temp
, gmtime(ticks
), sizeof(struct tm
));
251 #endif // !HAVE_GMTIME_R
253 #endif // wxWinCE with VC8/other platforms
255 // ----------------------------------------------------------------------------
257 // ----------------------------------------------------------------------------
259 // debugging helper: just a convenient replacement of wxCHECK()
260 #define wxDATETIME_CHECK(expr, msg) \
261 wxCHECK2_MSG(expr, *this = wxInvalidDateTime; return *this, msg)
263 // ----------------------------------------------------------------------------
265 // ----------------------------------------------------------------------------
267 class wxDateTimeHolidaysModule
: public wxModule
270 virtual bool OnInit()
272 wxDateTimeHolidayAuthority::AddAuthority(new wxDateTimeWorkDays
);
277 virtual void OnExit()
279 wxDateTimeHolidayAuthority::ClearAllAuthorities();
280 wxDateTimeHolidayAuthority::ms_authorities
.clear();
284 DECLARE_DYNAMIC_CLASS(wxDateTimeHolidaysModule
)
287 IMPLEMENT_DYNAMIC_CLASS(wxDateTimeHolidaysModule
, wxModule
)
289 // ----------------------------------------------------------------------------
291 // ----------------------------------------------------------------------------
294 static const int MONTHS_IN_YEAR
= 12;
296 static const int SEC_PER_MIN
= 60;
298 static const int MIN_PER_HOUR
= 60;
300 static const int HOURS_PER_DAY
= 24;
302 static const long SECONDS_PER_DAY
= 86400l;
304 static const int DAYS_PER_WEEK
= 7;
306 static const long MILLISECONDS_PER_DAY
= 86400000l;
308 // this is the integral part of JDN of the midnight of Jan 1, 1970
309 // (i.e. JDN(Jan 1, 1970) = 2440587.5)
310 static const long EPOCH_JDN
= 2440587l;
312 // used only in asserts
314 // the date of JDN -0.5 (as we don't work with fractional parts, this is the
315 // reference date for us) is Nov 24, 4714BC
316 static const int JDN_0_YEAR
= -4713;
317 static const int JDN_0_MONTH
= wxDateTime::Nov
;
318 static const int JDN_0_DAY
= 24;
319 #endif // __WXDEBUG__
321 // the constants used for JDN calculations
322 static const long JDN_OFFSET
= 32046l;
323 static const long DAYS_PER_5_MONTHS
= 153l;
324 static const long DAYS_PER_4_YEARS
= 1461l;
325 static const long DAYS_PER_400_YEARS
= 146097l;
327 // this array contains the cumulated number of days in all previous months for
328 // normal and leap years
329 static const wxDateTime::wxDateTime_t gs_cumulatedDays
[2][MONTHS_IN_YEAR
] =
331 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
332 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
335 // ----------------------------------------------------------------------------
337 // ----------------------------------------------------------------------------
339 const wxChar
* wxDefaultDateTimeFormat
= wxT("%c");
340 const wxChar
* wxDefaultTimeSpanFormat
= wxT("%H:%M:%S");
342 // in the fine tradition of ANSI C we use our equivalent of (time_t)-1 to
343 // indicate an invalid wxDateTime object
344 const wxDateTime wxDefaultDateTime
;
346 wxDateTime::Country
wxDateTime::ms_country
= wxDateTime::Country_Unknown
;
348 // ----------------------------------------------------------------------------
350 // ----------------------------------------------------------------------------
352 // debugger helper: shows what the date really is
354 extern const wxChar
*wxDumpDate(const wxDateTime
* dt
)
356 static wxChar buf
[128];
358 wxStrcpy(buf
, dt
->Format(_T("%Y-%m-%d (%a) %H:%M:%S")));
364 // get the number of days in the given month of the given year
366 wxDateTime::wxDateTime_t
GetNumOfDaysInMonth(int year
, wxDateTime::Month month
)
368 // the number of days in month in Julian/Gregorian calendar: the first line
369 // is for normal years, the second one is for the leap ones
370 static wxDateTime::wxDateTime_t daysInMonth
[2][MONTHS_IN_YEAR
] =
372 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
373 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
376 return daysInMonth
[wxDateTime::IsLeapYear(year
)][month
];
379 // returns the time zone in the C sense, i.e. the difference UTC - local
381 static int GetTimeZone()
383 // set to true when the timezone is set
384 static bool s_timezoneSet
= false;
385 static long gmtoffset
= LONG_MAX
; // invalid timezone
387 // ensure that the timezone variable is set by calling wxLocaltime_r
388 if ( !s_timezoneSet
)
390 // just call wxLocaltime_r() instead of figuring out whether this
391 // system supports tzset(), _tzset() or something else
395 wxLocaltime_r(&t
, &tm
);
396 s_timezoneSet
= true;
398 #ifdef WX_GMTOFF_IN_TM
399 // note that GMT offset is the opposite of time zone and so to return
400 // consistent results in both WX_GMTOFF_IN_TM and !WX_GMTOFF_IN_TM
401 // cases we have to negate it
402 gmtoffset
= -tm
.tm_gmtoff
;
403 #else // !WX_GMTOFF_IN_TM
404 gmtoffset
= WX_TIMEZONE
;
405 #endif // WX_GMTOFF_IN_TM/!WX_GMTOFF_IN_TM
408 return (int)gmtoffset
;
411 // return the integral part of the JDN for the midnight of the given date (to
412 // get the real JDN you need to add 0.5, this is, in fact, JDN of the
413 // noon of the previous day)
414 static long GetTruncatedJDN(wxDateTime::wxDateTime_t day
,
415 wxDateTime::Month mon
,
418 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
420 // check the date validity
422 (year
> JDN_0_YEAR
) ||
423 ((year
== JDN_0_YEAR
) && (mon
> JDN_0_MONTH
)) ||
424 ((year
== JDN_0_YEAR
) && (mon
== JDN_0_MONTH
) && (day
>= JDN_0_DAY
)),
425 _T("date out of range - can't convert to JDN")
428 // make the year positive to avoid problems with negative numbers division
431 // months are counted from March here
433 if ( mon
>= wxDateTime::Mar
)
443 // now we can simply add all the contributions together
444 return ((year
/ 100) * DAYS_PER_400_YEARS
) / 4
445 + ((year
% 100) * DAYS_PER_4_YEARS
) / 4
446 + (month
* DAYS_PER_5_MONTHS
+ 2) / 5
453 // this function is a wrapper around strftime(3) adding error checking
454 static wxString
CallStrftime(const wxChar
*format
, const tm
* tm
)
457 // Create temp wxString here to work around mingw/cygwin bug 1046059
458 // http://sourceforge.net/tracker/?func=detail&atid=102435&aid=1046059&group_id=2435
461 if ( !wxStrftime(buf
, WXSIZEOF(buf
), format
, tm
) )
463 // buffer is too small?
464 wxFAIL_MSG(_T("strftime() failed"));
471 #endif // HAVE_STRFTIME
475 #if wxUSE_UNIX && !defined(HAVE_STRPTIME_DECL)
476 // configure detected that we had strptime() but not its declaration,
477 // provide it ourselves
478 extern "C" char *strptime(const char *, const char *, struct tm
*);
481 // Unicode-friendly strptime() wrapper
482 static const wxChar
*
483 CallStrptime(const wxChar
*input
, const char *fmt
, tm
*tm
)
485 // the problem here is that strptime() returns pointer into the string we
486 // passed to it while we're really interested in the pointer into the
487 // original, Unicode, string so we try to transform the pointer back
489 wxCharBuffer
inputMB(wxConvertWX2MB(input
));
491 const char * const inputMB
= input
;
492 #endif // Unicode/Ascii
494 const char *result
= strptime(inputMB
, fmt
, tm
);
499 // FIXME: this is wrong in presence of surrogates &c
500 return input
+ (result
- inputMB
.data());
503 #endif // Unicode/Ascii
506 #endif // HAVE_STRPTIME
508 // if year and/or month have invalid values, replace them with the current ones
509 static void ReplaceDefaultYearMonthWithCurrent(int *year
,
510 wxDateTime::Month
*month
)
512 struct tm
*tmNow
= NULL
;
515 if ( *year
== wxDateTime::Inv_Year
)
517 tmNow
= wxDateTime::GetTmNow(&tmstruct
);
519 *year
= 1900 + tmNow
->tm_year
;
522 if ( *month
== wxDateTime::Inv_Month
)
525 tmNow
= wxDateTime::GetTmNow(&tmstruct
);
527 *month
= (wxDateTime::Month
)tmNow
->tm_mon
;
531 // fll the struct tm with default values
532 static void InitTm(struct tm
& tm
)
534 // struct tm may have etxra fields (undocumented and with unportable
535 // names) which, nevertheless, must be set to 0
536 memset(&tm
, 0, sizeof(struct tm
));
538 tm
.tm_mday
= 1; // mday 0 is invalid
539 tm
.tm_year
= 76; // any valid year
540 tm
.tm_isdst
= -1; // auto determine
546 // return the month if the string is a month name or Inv_Month otherwise
547 static wxDateTime::Month
GetMonthFromName(const wxString
& name
, int flags
)
549 wxDateTime::Month mon
;
550 for ( mon
= wxDateTime::Jan
; mon
< wxDateTime::Inv_Month
; wxNextMonth(mon
) )
552 // case-insensitive comparison either one of or with both abbreviated
554 if ( flags
& wxDateTime::Name_Full
)
556 if ( name
.CmpNoCase(wxDateTime::
557 GetMonthName(mon
, wxDateTime::Name_Full
)) == 0 )
563 if ( flags
& wxDateTime::Name_Abbr
)
565 if ( name
.CmpNoCase(wxDateTime::
566 GetMonthName(mon
, wxDateTime::Name_Abbr
)) == 0 )
576 // return the weekday if the string is a weekday name or Inv_WeekDay otherwise
577 static wxDateTime::WeekDay
GetWeekDayFromName(const wxString
& name
, int flags
)
579 wxDateTime::WeekDay wd
;
580 for ( wd
= wxDateTime::Sun
; wd
< wxDateTime::Inv_WeekDay
; wxNextWDay(wd
) )
582 // case-insensitive comparison either one of or with both abbreviated
584 if ( flags
& wxDateTime::Name_Full
)
586 if ( name
.CmpNoCase(wxDateTime::
587 GetWeekDayName(wd
, wxDateTime::Name_Full
)) == 0 )
593 if ( flags
& wxDateTime::Name_Abbr
)
595 if ( name
.CmpNoCase(wxDateTime::
596 GetWeekDayName(wd
, wxDateTime::Name_Abbr
)) == 0 )
607 struct tm
*wxDateTime::GetTmNow(struct tm
*tmstruct
)
609 time_t t
= GetTimeNow();
610 return wxLocaltime_r(&t
, tmstruct
);
613 // scans all digits (but no more than len) and returns the resulting number
614 static bool GetNumericToken(size_t len
, const wxChar
*& p
, unsigned long *number
)
618 while ( wxIsdigit(*p
) )
622 if ( len
&& ++n
> len
)
626 return !s
.empty() && s
.ToULong(number
);
629 // scans all alphabetic characters and returns the resulting string
630 static wxString
GetAlphaToken(const wxChar
*& p
)
633 while ( wxIsalpha(*p
) )
641 // ============================================================================
642 // implementation of wxDateTime
643 // ============================================================================
645 // ----------------------------------------------------------------------------
647 // ----------------------------------------------------------------------------
651 year
= (wxDateTime_t
)wxDateTime::Inv_Year
;
652 mon
= wxDateTime::Inv_Month
;
654 hour
= min
= sec
= msec
= 0;
655 wday
= wxDateTime::Inv_WeekDay
;
658 wxDateTime::Tm::Tm(const struct tm
& tm
, const TimeZone
& tz
)
662 sec
= (wxDateTime::wxDateTime_t
)tm
.tm_sec
;
663 min
= (wxDateTime::wxDateTime_t
)tm
.tm_min
;
664 hour
= (wxDateTime::wxDateTime_t
)tm
.tm_hour
;
665 mday
= (wxDateTime::wxDateTime_t
)tm
.tm_mday
;
666 mon
= (wxDateTime::Month
)tm
.tm_mon
;
667 year
= 1900 + tm
.tm_year
;
668 wday
= (wxDateTime::wxDateTime_t
)tm
.tm_wday
;
669 yday
= (wxDateTime::wxDateTime_t
)tm
.tm_yday
;
672 bool wxDateTime::Tm::IsValid() const
674 // we allow for the leap seconds, although we don't use them (yet)
675 return (year
!= wxDateTime::Inv_Year
) && (mon
!= wxDateTime::Inv_Month
) &&
676 (mday
<= GetNumOfDaysInMonth(year
, mon
)) &&
677 (hour
< 24) && (min
< 60) && (sec
< 62) && (msec
< 1000);
680 void wxDateTime::Tm::ComputeWeekDay()
682 // compute the week day from day/month/year: we use the dumbest algorithm
683 // possible: just compute our JDN and then use the (simple to derive)
684 // formula: weekday = (JDN + 1.5) % 7
685 wday
= (wxDateTime::wxDateTime_t
)((GetTruncatedJDN(mday
, mon
, year
) + 2) % 7);
688 void wxDateTime::Tm::AddMonths(int monDiff
)
690 // normalize the months field
691 while ( monDiff
< -mon
)
695 monDiff
+= MONTHS_IN_YEAR
;
698 while ( monDiff
+ mon
>= MONTHS_IN_YEAR
)
702 monDiff
-= MONTHS_IN_YEAR
;
705 mon
= (wxDateTime::Month
)(mon
+ monDiff
);
707 wxASSERT_MSG( mon
>= 0 && mon
< MONTHS_IN_YEAR
, _T("logic error") );
709 // NB: we don't check here that the resulting date is valid, this function
710 // is private and the caller must check it if needed
713 void wxDateTime::Tm::AddDays(int dayDiff
)
715 // normalize the days field
716 while ( dayDiff
+ mday
< 1 )
720 dayDiff
+= GetNumOfDaysInMonth(year
, mon
);
723 mday
= (wxDateTime::wxDateTime_t
)( mday
+ dayDiff
);
724 while ( mday
> GetNumOfDaysInMonth(year
, mon
) )
726 mday
-= GetNumOfDaysInMonth(year
, mon
);
731 wxASSERT_MSG( mday
> 0 && mday
<= GetNumOfDaysInMonth(year
, mon
),
735 // ----------------------------------------------------------------------------
737 // ----------------------------------------------------------------------------
739 wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz
)
743 case wxDateTime::Local
:
744 // get the offset from C RTL: it returns the difference GMT-local
745 // while we want to have the offset _from_ GMT, hence the '-'
746 m_offset
= -GetTimeZone();
749 case wxDateTime::GMT_12
:
750 case wxDateTime::GMT_11
:
751 case wxDateTime::GMT_10
:
752 case wxDateTime::GMT_9
:
753 case wxDateTime::GMT_8
:
754 case wxDateTime::GMT_7
:
755 case wxDateTime::GMT_6
:
756 case wxDateTime::GMT_5
:
757 case wxDateTime::GMT_4
:
758 case wxDateTime::GMT_3
:
759 case wxDateTime::GMT_2
:
760 case wxDateTime::GMT_1
:
761 m_offset
= -3600*(wxDateTime::GMT0
- tz
);
764 case wxDateTime::GMT0
:
765 case wxDateTime::GMT1
:
766 case wxDateTime::GMT2
:
767 case wxDateTime::GMT3
:
768 case wxDateTime::GMT4
:
769 case wxDateTime::GMT5
:
770 case wxDateTime::GMT6
:
771 case wxDateTime::GMT7
:
772 case wxDateTime::GMT8
:
773 case wxDateTime::GMT9
:
774 case wxDateTime::GMT10
:
775 case wxDateTime::GMT11
:
776 case wxDateTime::GMT12
:
777 case wxDateTime::GMT13
:
778 m_offset
= 3600*(tz
- wxDateTime::GMT0
);
781 case wxDateTime::A_CST
:
782 // Central Standard Time in use in Australia = UTC + 9.5
783 m_offset
= 60l*(9*MIN_PER_HOUR
+ MIN_PER_HOUR
/2);
787 wxFAIL_MSG( _T("unknown time zone") );
791 // ----------------------------------------------------------------------------
793 // ----------------------------------------------------------------------------
796 bool wxDateTime::IsLeapYear(int year
, wxDateTime::Calendar cal
)
798 if ( year
== Inv_Year
)
799 year
= GetCurrentYear();
801 if ( cal
== Gregorian
)
803 // in Gregorian calendar leap years are those divisible by 4 except
804 // those divisible by 100 unless they're also divisible by 400
805 // (in some countries, like Russia and Greece, additional corrections
806 // exist, but they won't manifest themselves until 2700)
807 return (year
% 4 == 0) && ((year
% 100 != 0) || (year
% 400 == 0));
809 else if ( cal
== Julian
)
811 // in Julian calendar the rule is simpler
812 return year
% 4 == 0;
816 wxFAIL_MSG(_T("unknown calendar"));
823 int wxDateTime::GetCentury(int year
)
825 return year
> 0 ? year
/ 100 : year
/ 100 - 1;
829 int wxDateTime::ConvertYearToBC(int year
)
832 return year
> 0 ? year
: year
- 1;
836 int wxDateTime::GetCurrentYear(wxDateTime::Calendar cal
)
841 return Now().GetYear();
844 wxFAIL_MSG(_T("TODO"));
848 wxFAIL_MSG(_T("unsupported calendar"));
856 wxDateTime::Month
wxDateTime::GetCurrentMonth(wxDateTime::Calendar cal
)
861 return Now().GetMonth();
864 wxFAIL_MSG(_T("TODO"));
868 wxFAIL_MSG(_T("unsupported calendar"));
876 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(int year
, Calendar cal
)
878 if ( year
== Inv_Year
)
880 // take the current year if none given
881 year
= GetCurrentYear();
888 return IsLeapYear(year
) ? 366 : 365;
891 wxFAIL_MSG(_T("unsupported calendar"));
899 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(wxDateTime::Month month
,
901 wxDateTime::Calendar cal
)
903 wxCHECK_MSG( month
< MONTHS_IN_YEAR
, 0, _T("invalid month") );
905 if ( cal
== Gregorian
|| cal
== Julian
)
907 if ( year
== Inv_Year
)
909 // take the current year if none given
910 year
= GetCurrentYear();
913 return GetNumOfDaysInMonth(year
, month
);
917 wxFAIL_MSG(_T("unsupported calendar"));
924 wxString
wxDateTime::GetMonthName(wxDateTime::Month month
,
925 wxDateTime::NameFlags flags
)
927 wxCHECK_MSG( month
!= Inv_Month
, wxEmptyString
, _T("invalid month") );
929 // notice that we must set all the fields to avoid confusing libc (GNU one
930 // gets confused to a crash if we don't do this)
935 return CallStrftime(flags
== Name_Abbr
? _T("%b") : _T("%B"), &tm
);
936 #else // !HAVE_STRFTIME
941 ret
= (flags
== Name_Abbr
? wxT("Jan"): wxT("January"));
944 ret
= (flags
== Name_Abbr
? wxT("Feb"): wxT("Febuary"));
947 ret
= (flags
== Name_Abbr
? wxT("Mar"): wxT("March"));
950 ret
= (flags
== Name_Abbr
? wxT("Apr"): wxT("April"));
953 ret
= (flags
== Name_Abbr
? wxT("May"): wxT("May"));
956 ret
= (flags
== Name_Abbr
? wxT("Jun"): wxT("June"));
959 ret
= (flags
== Name_Abbr
? wxT("Jul"): wxT("July"));
962 ret
= (flags
== Name_Abbr
? wxT("Aug"): wxT("August"));
965 ret
= (flags
== Name_Abbr
? wxT("Sep"): wxT("September"));
968 ret
= (flags
== Name_Abbr
? wxT("Oct"): wxT("October"));
971 ret
= (flags
== Name_Abbr
? wxT("Nov"): wxT("November"));
974 ret
= (flags
== Name_Abbr
? wxT("Dec"): wxT("December"));
978 #endif // HAVE_STRFTIME/!HAVE_STRFTIME
982 wxString
wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday
,
983 wxDateTime::NameFlags flags
)
985 wxCHECK_MSG( wday
!= Inv_WeekDay
, wxEmptyString
, _T("invalid weekday") );
987 // take some arbitrary Sunday (but notice that the day should be such that
988 // after adding wday to it below we still have a valid date, e.g. don't
996 // and offset it by the number of days needed to get the correct wday
999 // call mktime() to normalize it...
1002 // ... and call strftime()
1003 return CallStrftime(flags
== Name_Abbr
? _T("%a") : _T("%A"), &tm
);
1004 #else // !HAVE_STRFTIME
1009 ret
= (flags
== Name_Abbr
? wxT("Sun") : wxT("Sunday"));
1012 ret
= (flags
== Name_Abbr
? wxT("Mon") : wxT("Monday"));
1015 ret
= (flags
== Name_Abbr
? wxT("Tue") : wxT("Tuesday"));
1018 ret
= (flags
== Name_Abbr
? wxT("Wed") : wxT("Wednesday"));
1021 ret
= (flags
== Name_Abbr
? wxT("Thu") : wxT("Thursday"));
1024 ret
= (flags
== Name_Abbr
? wxT("Fri") : wxT("Friday"));
1027 ret
= (flags
== Name_Abbr
? wxT("Sat") : wxT("Saturday"));
1031 #endif // HAVE_STRFTIME/!HAVE_STRFTIME
1035 void wxDateTime::GetAmPmStrings(wxString
*am
, wxString
*pm
)
1040 // @Note: Do not call 'CallStrftime' here! CallStrftime checks the return code
1041 // and causes an assertion failed if the buffer is to small (which is good) - OR -
1042 // if strftime does not return anything because the format string is invalid - OR -
1043 // if there are no 'am' / 'pm' tokens defined for the current locale (which is not good).
1044 // wxDateTime::ParseTime will try several different formats to parse the time.
1045 // As a result, GetAmPmStrings might get called, even if the current locale
1046 // does not define any 'am' / 'pm' tokens. In this case, wxStrftime would
1047 // assert, even though it is a perfectly legal use.
1050 if (wxStrftime(buffer
, sizeof(buffer
)/sizeof(wxChar
), _T("%p"), &tm
) > 0)
1051 *am
= wxString(buffer
);
1058 if (wxStrftime(buffer
, sizeof(buffer
)/sizeof(wxChar
), _T("%p"), &tm
) > 0)
1059 *pm
= wxString(buffer
);
1065 // ----------------------------------------------------------------------------
1066 // Country stuff: date calculations depend on the country (DST, work days,
1067 // ...), so we need to know which rules to follow.
1068 // ----------------------------------------------------------------------------
1071 wxDateTime::Country
wxDateTime::GetCountry()
1073 // TODO use LOCALE_ICOUNTRY setting under Win32
1075 if ( ms_country
== Country_Unknown
)
1077 // try to guess from the time zone name
1078 time_t t
= time(NULL
);
1080 struct tm
*tm
= wxLocaltime_r(&t
, &tmstruct
);
1082 wxString tz
= CallStrftime(_T("%Z"), tm
);
1083 if ( tz
== _T("WET") || tz
== _T("WEST") )
1087 else if ( tz
== _T("CET") || tz
== _T("CEST") )
1089 ms_country
= Country_EEC
;
1091 else if ( tz
== _T("MSK") || tz
== _T("MSD") )
1093 ms_country
= Russia
;
1095 else if ( tz
== _T("AST") || tz
== _T("ADT") ||
1096 tz
== _T("EST") || tz
== _T("EDT") ||
1097 tz
== _T("CST") || tz
== _T("CDT") ||
1098 tz
== _T("MST") || tz
== _T("MDT") ||
1099 tz
== _T("PST") || tz
== _T("PDT") )
1105 // well, choose a default one
1109 #else // __WXWINCE__
1111 #endif // !__WXWINCE__/__WXWINCE__
1117 void wxDateTime::SetCountry(wxDateTime::Country country
)
1119 ms_country
= country
;
1123 bool wxDateTime::IsWestEuropeanCountry(Country country
)
1125 if ( country
== Country_Default
)
1127 country
= GetCountry();
1130 return (Country_WesternEurope_Start
<= country
) &&
1131 (country
<= Country_WesternEurope_End
);
1134 // ----------------------------------------------------------------------------
1135 // DST calculations: we use 3 different rules for the West European countries,
1136 // USA and for the rest of the world. This is undoubtedly false for many
1137 // countries, but I lack the necessary info (and the time to gather it),
1138 // please add the other rules here!
1139 // ----------------------------------------------------------------------------
1142 bool wxDateTime::IsDSTApplicable(int year
, Country country
)
1144 if ( year
== Inv_Year
)
1146 // take the current year if none given
1147 year
= GetCurrentYear();
1150 if ( country
== Country_Default
)
1152 country
= GetCountry();
1159 // DST was first observed in the US and UK during WWI, reused
1160 // during WWII and used again since 1966
1161 return year
>= 1966 ||
1162 (year
>= 1942 && year
<= 1945) ||
1163 (year
== 1918 || year
== 1919);
1166 // assume that it started after WWII
1172 wxDateTime
wxDateTime::GetBeginDST(int year
, Country country
)
1174 if ( year
== Inv_Year
)
1176 // take the current year if none given
1177 year
= GetCurrentYear();
1180 if ( country
== Country_Default
)
1182 country
= GetCountry();
1185 if ( !IsDSTApplicable(year
, country
) )
1187 return wxInvalidDateTime
;
1192 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
1194 // DST begins at 1 a.m. GMT on the last Sunday of March
1195 if ( !dt
.SetToLastWeekDay(Sun
, Mar
, year
) )
1198 wxFAIL_MSG( _T("no last Sunday in March?") );
1201 dt
+= wxTimeSpan::Hours(1);
1203 // disable DST tests because it could result in an infinite recursion!
1206 else switch ( country
)
1213 // don't know for sure - assume it was in effect all year
1218 dt
.Set(1, Jan
, year
);
1222 // DST was installed Feb 2, 1942 by the Congress
1223 dt
.Set(2, Feb
, year
);
1226 // Oil embargo changed the DST period in the US
1228 dt
.Set(6, Jan
, 1974);
1232 dt
.Set(23, Feb
, 1975);
1236 // before 1986, DST begun on the last Sunday of April, but
1237 // in 1986 Reagan changed it to begin at 2 a.m. of the
1238 // first Sunday in April
1241 if ( !dt
.SetToLastWeekDay(Sun
, Apr
, year
) )
1244 wxFAIL_MSG( _T("no first Sunday in April?") );
1249 if ( !dt
.SetToWeekDay(Sun
, 1, Apr
, year
) )
1252 wxFAIL_MSG( _T("no first Sunday in April?") );
1256 dt
+= wxTimeSpan::Hours(2);
1258 // TODO what about timezone??
1264 // assume Mar 30 as the start of the DST for the rest of the world
1265 // - totally bogus, of course
1266 dt
.Set(30, Mar
, year
);
1273 wxDateTime
wxDateTime::GetEndDST(int year
, Country country
)
1275 if ( year
== Inv_Year
)
1277 // take the current year if none given
1278 year
= GetCurrentYear();
1281 if ( country
== Country_Default
)
1283 country
= GetCountry();
1286 if ( !IsDSTApplicable(year
, country
) )
1288 return wxInvalidDateTime
;
1293 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
1295 // DST ends at 1 a.m. GMT on the last Sunday of October
1296 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1298 // weirder and weirder...
1299 wxFAIL_MSG( _T("no last Sunday in October?") );
1302 dt
+= wxTimeSpan::Hours(1);
1304 // disable DST tests because it could result in an infinite recursion!
1307 else switch ( country
)
1314 // don't know for sure - assume it was in effect all year
1318 dt
.Set(31, Dec
, year
);
1322 // the time was reset after the end of the WWII
1323 dt
.Set(30, Sep
, year
);
1327 // DST ends at 2 a.m. on the last Sunday of October
1328 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1330 // weirder and weirder...
1331 wxFAIL_MSG( _T("no last Sunday in October?") );
1334 dt
+= wxTimeSpan::Hours(2);
1336 // TODO what about timezone??
1341 // assume October 26th as the end of the DST - totally bogus too
1342 dt
.Set(26, Oct
, year
);
1348 // ----------------------------------------------------------------------------
1349 // constructors and assignment operators
1350 // ----------------------------------------------------------------------------
1352 // return the current time with ms precision
1353 /* static */ wxDateTime
wxDateTime::UNow()
1355 return wxDateTime(wxGetLocalTimeMillis());
1358 // the values in the tm structure contain the local time
1359 wxDateTime
& wxDateTime::Set(const struct tm
& tm
)
1362 time_t timet
= mktime(&tm2
);
1364 if ( timet
== (time_t)-1 )
1366 // mktime() rather unintuitively fails for Jan 1, 1970 if the hour is
1367 // less than timezone - try to make it work for this case
1368 if ( tm2
.tm_year
== 70 && tm2
.tm_mon
== 0 && tm2
.tm_mday
== 1 )
1370 return Set((time_t)(
1372 tm2
.tm_hour
* MIN_PER_HOUR
* SEC_PER_MIN
+
1373 tm2
.tm_min
* SEC_PER_MIN
+
1377 wxFAIL_MSG( _T("mktime() failed") );
1379 *this = wxInvalidDateTime
;
1389 wxDateTime
& wxDateTime::Set(wxDateTime_t hour
,
1390 wxDateTime_t minute
,
1391 wxDateTime_t second
,
1392 wxDateTime_t millisec
)
1394 // we allow seconds to be 61 to account for the leap seconds, even if we
1395 // don't use them really
1396 wxDATETIME_CHECK( hour
< 24 &&
1400 _T("Invalid time in wxDateTime::Set()") );
1402 // get the current date from system
1404 struct tm
*tm
= GetTmNow(&tmstruct
);
1406 wxDATETIME_CHECK( tm
, _T("wxLocaltime_r() failed") );
1408 // make a copy so it isn't clobbered by the call to mktime() below
1413 tm1
.tm_min
= minute
;
1414 tm1
.tm_sec
= second
;
1416 // and the DST in case it changes on this date
1419 if ( tm2
.tm_isdst
!= tm1
.tm_isdst
)
1420 tm1
.tm_isdst
= tm2
.tm_isdst
;
1424 // and finally adjust milliseconds
1425 return SetMillisecond(millisec
);
1428 wxDateTime
& wxDateTime::Set(wxDateTime_t day
,
1432 wxDateTime_t minute
,
1433 wxDateTime_t second
,
1434 wxDateTime_t millisec
)
1436 wxDATETIME_CHECK( hour
< 24 &&
1440 _T("Invalid time in wxDateTime::Set()") );
1442 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1444 wxDATETIME_CHECK( (0 < day
) && (day
<= GetNumberOfDays(month
, year
)),
1445 _T("Invalid date in wxDateTime::Set()") );
1447 // the range of time_t type (inclusive)
1448 static const int yearMinInRange
= 1970;
1449 static const int yearMaxInRange
= 2037;
1451 // test only the year instead of testing for the exact end of the Unix
1452 // time_t range - it doesn't bring anything to do more precise checks
1453 if ( year
>= yearMinInRange
&& year
<= yearMaxInRange
)
1455 // use the standard library version if the date is in range - this is
1456 // probably more efficient than our code
1458 tm
.tm_year
= year
- 1900;
1464 tm
.tm_isdst
= -1; // mktime() will guess it
1468 // and finally adjust milliseconds
1470 SetMillisecond(millisec
);
1476 // do time calculations ourselves: we want to calculate the number of
1477 // milliseconds between the given date and the epoch
1479 // get the JDN for the midnight of this day
1480 m_time
= GetTruncatedJDN(day
, month
, year
);
1481 m_time
-= EPOCH_JDN
;
1482 m_time
*= SECONDS_PER_DAY
* TIME_T_FACTOR
;
1484 // JDN corresponds to GMT, we take localtime
1485 Add(wxTimeSpan(hour
, minute
, second
+ GetTimeZone(), millisec
));
1491 wxDateTime
& wxDateTime::Set(double jdn
)
1493 // so that m_time will be 0 for the midnight of Jan 1, 1970 which is jdn
1495 jdn
-= EPOCH_JDN
+ 0.5;
1497 m_time
.Assign(jdn
*MILLISECONDS_PER_DAY
);
1499 // JDNs always are in UTC, so we don't need any adjustments for time zone
1504 wxDateTime
& wxDateTime::ResetTime()
1508 if ( tm
.hour
|| tm
.min
|| tm
.sec
|| tm
.msec
)
1521 wxDateTime
wxDateTime::GetDateOnly() const
1528 return wxDateTime(tm
);
1531 // ----------------------------------------------------------------------------
1532 // DOS Date and Time Format functions
1533 // ----------------------------------------------------------------------------
1534 // the dos date and time value is an unsigned 32 bit value in the format:
1535 // YYYYYYYMMMMDDDDDhhhhhmmmmmmsssss
1537 // Y = year offset from 1980 (0-127)
1539 // D = day of month (1-31)
1541 // m = minute (0-59)
1542 // s = bisecond (0-29) each bisecond indicates two seconds
1543 // ----------------------------------------------------------------------------
1545 wxDateTime
& wxDateTime::SetFromDOS(unsigned long ddt
)
1550 long year
= ddt
& 0xFE000000;
1555 long month
= ddt
& 0x1E00000;
1560 long day
= ddt
& 0x1F0000;
1564 long hour
= ddt
& 0xF800;
1568 long minute
= ddt
& 0x7E0;
1572 long second
= ddt
& 0x1F;
1573 tm
.tm_sec
= second
* 2;
1575 return Set(mktime(&tm
));
1578 unsigned long wxDateTime::GetAsDOS() const
1581 time_t ticks
= GetTicks();
1583 struct tm
*tm
= wxLocaltime_r(&ticks
, &tmstruct
);
1585 long year
= tm
->tm_year
;
1589 long month
= tm
->tm_mon
;
1593 long day
= tm
->tm_mday
;
1596 long hour
= tm
->tm_hour
;
1599 long minute
= tm
->tm_min
;
1602 long second
= tm
->tm_sec
;
1605 ddt
= year
| month
| day
| hour
| minute
| second
;
1609 // ----------------------------------------------------------------------------
1610 // time_t <-> broken down time conversions
1611 // ----------------------------------------------------------------------------
1613 wxDateTime::Tm
wxDateTime::GetTm(const TimeZone
& tz
) const
1615 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1617 time_t time
= GetTicks();
1618 if ( time
!= (time_t)-1 )
1620 // use C RTL functions
1623 if ( tz
.GetOffset() == -GetTimeZone() )
1625 // we are working with local time
1626 tm
= wxLocaltime_r(&time
, &tmstruct
);
1628 // should never happen
1629 wxCHECK_MSG( tm
, Tm(), _T("wxLocaltime_r() failed") );
1633 time
+= (time_t)tz
.GetOffset();
1634 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
1635 int time2
= (int) time
;
1641 tm
= wxGmtime_r(&time
, &tmstruct
);
1643 // should never happen
1644 wxCHECK_MSG( tm
, Tm(), _T("wxGmtime_r() failed") );
1648 tm
= (struct tm
*)NULL
;
1654 // adjust the milliseconds
1656 long timeOnly
= (m_time
% MILLISECONDS_PER_DAY
).ToLong();
1657 tm2
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1660 //else: use generic code below
1663 // remember the time and do the calculations with the date only - this
1664 // eliminates rounding errors of the floating point arithmetics
1666 wxLongLong timeMidnight
= m_time
+ tz
.GetOffset() * 1000;
1668 long timeOnly
= (timeMidnight
% MILLISECONDS_PER_DAY
).ToLong();
1670 // we want to always have positive time and timeMidnight to be really
1671 // the midnight before it
1674 timeOnly
= MILLISECONDS_PER_DAY
+ timeOnly
;
1677 timeMidnight
-= timeOnly
;
1679 // calculate the Gregorian date from JDN for the midnight of our date:
1680 // this will yield day, month (in 1..12 range) and year
1682 // actually, this is the JDN for the noon of the previous day
1683 long jdn
= (timeMidnight
/ MILLISECONDS_PER_DAY
).ToLong() + EPOCH_JDN
;
1685 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
1687 wxASSERT_MSG( jdn
> -2, _T("JDN out of range") );
1689 // calculate the century
1690 long temp
= (jdn
+ JDN_OFFSET
) * 4 - 1;
1691 long century
= temp
/ DAYS_PER_400_YEARS
;
1693 // then the year and day of year (1 <= dayOfYear <= 366)
1694 temp
= ((temp
% DAYS_PER_400_YEARS
) / 4) * 4 + 3;
1695 long year
= (century
* 100) + (temp
/ DAYS_PER_4_YEARS
);
1696 long dayOfYear
= (temp
% DAYS_PER_4_YEARS
) / 4 + 1;
1698 // and finally the month and day of the month
1699 temp
= dayOfYear
* 5 - 3;
1700 long month
= temp
/ DAYS_PER_5_MONTHS
;
1701 long day
= (temp
% DAYS_PER_5_MONTHS
) / 5 + 1;
1703 // month is counted from March - convert to normal
1714 // year is offset by 4800
1717 // check that the algorithm gave us something reasonable
1718 wxASSERT_MSG( (0 < month
) && (month
<= 12), _T("invalid month") );
1719 wxASSERT_MSG( (1 <= day
) && (day
< 32), _T("invalid day") );
1721 // construct Tm from these values
1723 tm
.year
= (int)year
;
1724 tm
.mon
= (Month
)(month
- 1); // algorithm yields 1 for January, not 0
1725 tm
.mday
= (wxDateTime_t
)day
;
1726 tm
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1727 timeOnly
-= tm
.msec
;
1728 timeOnly
/= 1000; // now we have time in seconds
1730 tm
.sec
= (wxDateTime_t
)(timeOnly
% SEC_PER_MIN
);
1732 timeOnly
/= SEC_PER_MIN
; // now we have time in minutes
1734 tm
.min
= (wxDateTime_t
)(timeOnly
% MIN_PER_HOUR
);
1737 tm
.hour
= (wxDateTime_t
)(timeOnly
/ MIN_PER_HOUR
);
1742 wxDateTime
& wxDateTime::SetYear(int year
)
1744 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1753 wxDateTime
& wxDateTime::SetMonth(Month month
)
1755 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1764 wxDateTime
& wxDateTime::SetDay(wxDateTime_t mday
)
1766 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1775 wxDateTime
& wxDateTime::SetHour(wxDateTime_t hour
)
1777 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1786 wxDateTime
& wxDateTime::SetMinute(wxDateTime_t min
)
1788 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1797 wxDateTime
& wxDateTime::SetSecond(wxDateTime_t sec
)
1799 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1808 wxDateTime
& wxDateTime::SetMillisecond(wxDateTime_t millisecond
)
1810 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1812 // we don't need to use GetTm() for this one
1813 m_time
-= m_time
% 1000l;
1814 m_time
+= millisecond
;
1819 // ----------------------------------------------------------------------------
1820 // wxDateTime arithmetics
1821 // ----------------------------------------------------------------------------
1823 wxDateTime
& wxDateTime::Add(const wxDateSpan
& diff
)
1827 tm
.year
+= diff
.GetYears();
1828 tm
.AddMonths(diff
.GetMonths());
1830 // check that the resulting date is valid
1831 if ( tm
.mday
> GetNumOfDaysInMonth(tm
.year
, tm
.mon
) )
1833 // We suppose that when adding one month to Jan 31 we want to get Feb
1834 // 28 (or 29), i.e. adding a month to the last day of the month should
1835 // give the last day of the next month which is quite logical.
1837 // Unfortunately, there is no logic way to understand what should
1838 // Jan 30 + 1 month be - Feb 28 too or Feb 27 (assuming non leap year)?
1839 // We make it Feb 28 (last day too), but it is highly questionable.
1840 tm
.mday
= GetNumOfDaysInMonth(tm
.year
, tm
.mon
);
1843 tm
.AddDays(diff
.GetTotalDays());
1847 wxASSERT_MSG( IsSameTime(tm
),
1848 _T("Add(wxDateSpan) shouldn't modify time") );
1853 // ----------------------------------------------------------------------------
1854 // Weekday and monthday stuff
1855 // ----------------------------------------------------------------------------
1857 // convert Sun, Mon, ..., Sat into 6, 0, ..., 5
1858 static inline int ConvertWeekDayToMondayBase(int wd
)
1860 return wd
== wxDateTime::Sun
? 6 : wd
- 1;
1865 wxDateTime::SetToWeekOfYear(int year
, wxDateTime_t numWeek
, WeekDay wd
)
1867 wxASSERT_MSG( numWeek
> 0,
1868 _T("invalid week number: weeks are counted from 1") );
1870 // Jan 4 always lies in the 1st week of the year
1871 wxDateTime
dt(4, Jan
, year
);
1872 dt
.SetToWeekDayInSameWeek(wd
);
1873 dt
+= wxDateSpan::Weeks(numWeek
- 1);
1878 #if WXWIN_COMPATIBILITY_2_6
1879 // use a separate function to avoid warnings about using deprecated
1880 // SetToTheWeek in GetWeek below
1882 SetToTheWeek(int year
,
1883 wxDateTime::wxDateTime_t numWeek
,
1884 wxDateTime::WeekDay weekday
,
1885 wxDateTime::WeekFlags flags
)
1887 // Jan 4 always lies in the 1st week of the year
1888 wxDateTime
dt(4, wxDateTime::Jan
, year
);
1889 dt
.SetToWeekDayInSameWeek(weekday
, flags
);
1890 dt
+= wxDateSpan::Weeks(numWeek
- 1);
1895 bool wxDateTime::SetToTheWeek(wxDateTime_t numWeek
,
1899 int year
= GetYear();
1900 *this = ::SetToTheWeek(year
, numWeek
, weekday
, flags
);
1901 if ( GetYear() != year
)
1903 // oops... numWeek was too big
1910 wxDateTime
wxDateTime::GetWeek(wxDateTime_t numWeek
,
1912 WeekFlags flags
) const
1914 return ::SetToTheWeek(GetYear(), numWeek
, weekday
, flags
);
1916 #endif // WXWIN_COMPATIBILITY_2_6
1918 wxDateTime
& wxDateTime::SetToLastMonthDay(Month month
,
1921 // take the current month/year if none specified
1922 if ( year
== Inv_Year
)
1924 if ( month
== Inv_Month
)
1927 return Set(GetNumOfDaysInMonth(year
, month
), month
, year
);
1930 wxDateTime
& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday
, WeekFlags flags
)
1932 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
1934 int wdayDst
= weekday
,
1935 wdayThis
= GetWeekDay();
1936 if ( wdayDst
== wdayThis
)
1942 if ( flags
== Default_First
)
1944 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
1947 // the logic below based on comparing weekday and wdayThis works if Sun (0)
1948 // is the first day in the week, but breaks down for Monday_First case so
1949 // we adjust the week days in this case
1950 if ( flags
== Monday_First
)
1952 if ( wdayThis
== Sun
)
1954 if ( wdayDst
== Sun
)
1957 //else: Sunday_First, nothing to do
1959 // go forward or back in time to the day we want
1960 if ( wdayDst
< wdayThis
)
1962 return Subtract(wxDateSpan::Days(wdayThis
- wdayDst
));
1964 else // weekday > wdayThis
1966 return Add(wxDateSpan::Days(wdayDst
- wdayThis
));
1970 wxDateTime
& wxDateTime::SetToNextWeekDay(WeekDay weekday
)
1972 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
1975 WeekDay wdayThis
= GetWeekDay();
1976 if ( weekday
== wdayThis
)
1981 else if ( weekday
< wdayThis
)
1983 // need to advance a week
1984 diff
= 7 - (wdayThis
- weekday
);
1986 else // weekday > wdayThis
1988 diff
= weekday
- wdayThis
;
1991 return Add(wxDateSpan::Days(diff
));
1994 wxDateTime
& wxDateTime::SetToPrevWeekDay(WeekDay weekday
)
1996 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
1999 WeekDay wdayThis
= GetWeekDay();
2000 if ( weekday
== wdayThis
)
2005 else if ( weekday
> wdayThis
)
2007 // need to go to previous week
2008 diff
= 7 - (weekday
- wdayThis
);
2010 else // weekday < wdayThis
2012 diff
= wdayThis
- weekday
;
2015 return Subtract(wxDateSpan::Days(diff
));
2018 bool wxDateTime::SetToWeekDay(WeekDay weekday
,
2023 wxCHECK_MSG( weekday
!= Inv_WeekDay
, false, _T("invalid weekday") );
2025 // we don't check explicitly that -5 <= n <= 5 because we will return false
2026 // anyhow in such case - but may be should still give an assert for it?
2028 // take the current month/year if none specified
2029 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
2033 // TODO this probably could be optimised somehow...
2037 // get the first day of the month
2038 dt
.Set(1, month
, year
);
2041 WeekDay wdayFirst
= dt
.GetWeekDay();
2043 // go to the first weekday of the month
2044 int diff
= weekday
- wdayFirst
;
2048 // add advance n-1 weeks more
2051 dt
+= wxDateSpan::Days(diff
);
2053 else // count from the end of the month
2055 // get the last day of the month
2056 dt
.SetToLastMonthDay(month
, year
);
2059 WeekDay wdayLast
= dt
.GetWeekDay();
2061 // go to the last weekday of the month
2062 int diff
= wdayLast
- weekday
;
2066 // and rewind n-1 weeks from there
2069 dt
-= wxDateSpan::Days(diff
);
2072 // check that it is still in the same month
2073 if ( dt
.GetMonth() == month
)
2081 // no such day in this month
2087 wxDateTime::wxDateTime_t
GetDayOfYearFromTm(const wxDateTime::Tm
& tm
)
2089 return (wxDateTime::wxDateTime_t
)(gs_cumulatedDays
[wxDateTime::IsLeapYear(tm
.year
)][tm
.mon
] + tm
.mday
);
2092 wxDateTime::wxDateTime_t
wxDateTime::GetDayOfYear(const TimeZone
& tz
) const
2094 return GetDayOfYearFromTm(GetTm(tz
));
2097 wxDateTime::wxDateTime_t
2098 wxDateTime::GetWeekOfYear(wxDateTime::WeekFlags flags
, const TimeZone
& tz
) const
2100 if ( flags
== Default_First
)
2102 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
2106 wxDateTime_t nDayInYear
= GetDayOfYearFromTm(tm
);
2108 int wdTarget
= GetWeekDay(tz
);
2109 int wdYearStart
= wxDateTime(1, Jan
, GetYear()).GetWeekDay();
2111 if ( flags
== Sunday_First
)
2113 // FIXME: First week is not calculated correctly.
2114 week
= (nDayInYear
- wdTarget
+ 7) / 7;
2115 if ( wdYearStart
== Wed
|| wdYearStart
== Thu
)
2118 else // week starts with monday
2120 // adjust the weekdays to non-US style.
2121 wdYearStart
= ConvertWeekDayToMondayBase(wdYearStart
);
2122 wdTarget
= ConvertWeekDayToMondayBase(wdTarget
);
2124 // quoting from http://www.cl.cam.ac.uk/~mgk25/iso-time.html:
2126 // Week 01 of a year is per definition the first week that has the
2127 // Thursday in this year, which is equivalent to the week that
2128 // contains the fourth day of January. In other words, the first
2129 // week of a new year is the week that has the majority of its
2130 // days in the new year. Week 01 might also contain days from the
2131 // previous year and the week before week 01 of a year is the last
2132 // week (52 or 53) of the previous year even if it contains days
2133 // from the new year. A week starts with Monday (day 1) and ends
2134 // with Sunday (day 7).
2137 // if Jan 1 is Thursday or less, it is in the first week of this year
2138 if ( wdYearStart
< 4 )
2140 // count the number of entire weeks between Jan 1 and this date
2141 week
= (nDayInYear
+ wdYearStart
+ 6 - wdTarget
)/7;
2143 // be careful to check for overflow in the next year
2144 if ( week
== 53 && tm
.mday
- wdTarget
> 28 )
2147 else // Jan 1 is in the last week of the previous year
2149 // check if we happen to be at the last week of previous year:
2150 if ( tm
.mon
== Jan
&& tm
.mday
< 8 - wdYearStart
)
2151 week
= wxDateTime(31, Dec
, GetYear()-1).GetWeekOfYear();
2153 week
= (nDayInYear
+ wdYearStart
- 1 - wdTarget
)/7;
2157 return (wxDateTime::wxDateTime_t
)week
;
2160 wxDateTime::wxDateTime_t
wxDateTime::GetWeekOfMonth(wxDateTime::WeekFlags flags
,
2161 const TimeZone
& tz
) const
2164 wxDateTime dtMonthStart
= wxDateTime(1, tm
.mon
, tm
.year
);
2165 int nWeek
= GetWeekOfYear(flags
) - dtMonthStart
.GetWeekOfYear(flags
) + 1;
2168 // this may happen for January when Jan, 1 is the last week of the
2170 nWeek
+= IsLeapYear(tm
.year
- 1) ? 53 : 52;
2173 return (wxDateTime::wxDateTime_t
)nWeek
;
2176 wxDateTime
& wxDateTime::SetToYearDay(wxDateTime::wxDateTime_t yday
)
2178 int year
= GetYear();
2179 wxDATETIME_CHECK( (0 < yday
) && (yday
<= GetNumberOfDays(year
)),
2180 _T("invalid year day") );
2182 bool isLeap
= IsLeapYear(year
);
2183 for ( Month mon
= Jan
; mon
< Inv_Month
; wxNextMonth(mon
) )
2185 // for Dec, we can't compare with gs_cumulatedDays[mon + 1], but we
2186 // don't need it neither - because of the CHECK above we know that
2187 // yday lies in December then
2188 if ( (mon
== Dec
) || (yday
<= gs_cumulatedDays
[isLeap
][mon
+ 1]) )
2190 Set((wxDateTime::wxDateTime_t
)(yday
- gs_cumulatedDays
[isLeap
][mon
]), mon
, year
);
2199 // ----------------------------------------------------------------------------
2200 // Julian day number conversion and related stuff
2201 // ----------------------------------------------------------------------------
2203 double wxDateTime::GetJulianDayNumber() const
2205 return m_time
.ToDouble() / MILLISECONDS_PER_DAY
+ EPOCH_JDN
+ 0.5;
2208 double wxDateTime::GetRataDie() const
2210 // March 1 of the year 0 is Rata Die day -306 and JDN 1721119.5
2211 return GetJulianDayNumber() - 1721119.5 - 306;
2214 // ----------------------------------------------------------------------------
2215 // timezone and DST stuff
2216 // ----------------------------------------------------------------------------
2218 int wxDateTime::IsDST(wxDateTime::Country country
) const
2220 wxCHECK_MSG( country
== Country_Default
, -1,
2221 _T("country support not implemented") );
2223 // use the C RTL for the dates in the standard range
2224 time_t timet
= GetTicks();
2225 if ( timet
!= (time_t)-1 )
2228 tm
*tm
= wxLocaltime_r(&timet
, &tmstruct
);
2230 wxCHECK_MSG( tm
, -1, _T("wxLocaltime_r() failed") );
2232 return tm
->tm_isdst
;
2236 int year
= GetYear();
2238 if ( !IsDSTApplicable(year
, country
) )
2240 // no DST time in this year in this country
2244 return IsBetween(GetBeginDST(year
, country
), GetEndDST(year
, country
));
2248 wxDateTime
& wxDateTime::MakeTimezone(const TimeZone
& tz
, bool noDST
)
2250 long secDiff
= GetTimeZone() + tz
.GetOffset();
2252 // we need to know whether DST is or not in effect for this date unless
2253 // the test disabled by the caller
2254 if ( !noDST
&& (IsDST() == 1) )
2256 // FIXME we assume that the DST is always shifted by 1 hour
2260 return Add(wxTimeSpan::Seconds(secDiff
));
2263 wxDateTime
& wxDateTime::MakeFromTimezone(const TimeZone
& tz
, bool noDST
)
2265 long secDiff
= GetTimeZone() + tz
.GetOffset();
2267 // we need to know whether DST is or not in effect for this date unless
2268 // the test disabled by the caller
2269 if ( !noDST
&& (IsDST() == 1) )
2271 // FIXME we assume that the DST is always shifted by 1 hour
2275 return Subtract(wxTimeSpan::Seconds(secDiff
));
2278 // ----------------------------------------------------------------------------
2279 // wxDateTime to/from text representations
2280 // ----------------------------------------------------------------------------
2282 wxString
wxDateTime::Format(const wxChar
*format
, const TimeZone
& tz
) const
2284 wxCHECK_MSG( format
, wxEmptyString
, _T("NULL format in wxDateTime::Format") );
2286 // we have to use our own implementation if the date is out of range of
2287 // strftime() or if we use non standard specificators
2288 #ifdef HAVE_STRFTIME
2289 time_t time
= GetTicks();
2291 if ( (time
!= (time_t)-1) && !wxStrstr(format
, _T("%l")) )
2296 if ( tz
.GetOffset() == -GetTimeZone() )
2298 // we are working with local time
2299 tm
= wxLocaltime_r(&time
, &tmstruct
);
2301 // should never happen
2302 wxCHECK_MSG( tm
, wxEmptyString
, _T("wxLocaltime_r() failed") );
2306 time
+= (int)tz
.GetOffset();
2308 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
2309 int time2
= (int) time
;
2315 tm
= wxGmtime_r(&time
, &tmstruct
);
2317 // should never happen
2318 wxCHECK_MSG( tm
, wxEmptyString
, _T("wxGmtime_r() failed") );
2322 tm
= (struct tm
*)NULL
;
2328 return CallStrftime(format
, tm
);
2331 //else: use generic code below
2332 #endif // HAVE_STRFTIME
2334 // we only parse ANSI C format specifications here, no POSIX 2
2335 // complications, no GNU extensions but we do add support for a "%l" format
2336 // specifier allowing to get the number of milliseconds
2339 // used for calls to strftime() when we only deal with time
2340 struct tm tmTimeOnly
;
2341 tmTimeOnly
.tm_hour
= tm
.hour
;
2342 tmTimeOnly
.tm_min
= tm
.min
;
2343 tmTimeOnly
.tm_sec
= tm
.sec
;
2344 tmTimeOnly
.tm_wday
= 0;
2345 tmTimeOnly
.tm_yday
= 0;
2346 tmTimeOnly
.tm_mday
= 1; // any date will do
2347 tmTimeOnly
.tm_mon
= 0;
2348 tmTimeOnly
.tm_year
= 76;
2349 tmTimeOnly
.tm_isdst
= 0; // no DST, we adjust for tz ourselves
2351 wxString tmp
, res
, fmt
;
2352 for ( const wxChar
*p
= format
; *p
; p
++ )
2354 if ( *p
!= _T('%') )
2362 // set the default format
2365 case _T('Y'): // year has 4 digits
2369 case _T('j'): // day of year has 3 digits
2370 case _T('l'): // milliseconds have 3 digits
2374 case _T('w'): // week day as number has only one
2379 // it's either another valid format specifier in which case
2380 // the format is "%02d" (for all the rest) or we have the
2381 // field width preceding the format in which case it will
2382 // override the default format anyhow
2386 bool restart
= true;
2391 // start of the format specification
2394 case _T('a'): // a weekday name
2396 // second parameter should be true for abbreviated names
2397 res
+= GetWeekDayName(tm
.GetWeekDay(),
2398 *p
== _T('a') ? Name_Abbr
: Name_Full
);
2401 case _T('b'): // a month name
2403 res
+= GetMonthName(tm
.mon
,
2404 *p
== _T('b') ? Name_Abbr
: Name_Full
);
2407 case _T('c'): // locale default date and time representation
2408 case _T('x'): // locale default date representation
2409 #ifdef HAVE_STRFTIME
2411 // the problem: there is no way to know what do these format
2412 // specifications correspond to for the current locale.
2414 // the solution: use a hack and still use strftime(): first
2415 // find the YEAR which is a year in the strftime() range (1970
2416 // - 2038) whose Jan 1 falls on the same week day as the Jan 1
2417 // of the real year. Then make a copy of the format and
2418 // replace all occurrences of YEAR in it with some unique
2419 // string not appearing anywhere else in it, then use
2420 // strftime() to format the date in year YEAR and then replace
2421 // YEAR back by the real year and the unique replacement
2422 // string back with YEAR. Notice that "all occurrences of YEAR"
2423 // means all occurrences of 4 digit as well as 2 digit form!
2425 // the bugs: we assume that neither of %c nor %x contains any
2426 // fields which may change between the YEAR and real year. For
2427 // example, the week number (%U, %W) and the day number (%j)
2428 // will change if one of these years is leap and the other one
2431 // find the YEAR: normally, for any year X, Jan 1 or the
2432 // year X + 28 is the same weekday as Jan 1 of X (because
2433 // the weekday advances by 1 for each normal X and by 2
2434 // for each leap X, hence by 5 every 4 years or by 35
2435 // which is 0 mod 7 every 28 years) but this rule breaks
2436 // down if there are years between X and Y which are
2437 // divisible by 4 but not leap (i.e. divisible by 100 but
2438 // not 400), hence the correction.
2440 int yearReal
= GetYear(tz
);
2441 int mod28
= yearReal
% 28;
2443 // be careful to not go too far - we risk to leave the
2448 year
= 1988 + mod28
; // 1988 == 0 (mod 28)
2452 year
= 1970 + mod28
- 10; // 1970 == 10 (mod 28)
2455 int nCentury
= year
/ 100,
2456 nCenturyReal
= yearReal
/ 100;
2458 // need to adjust for the years divisble by 400 which are
2459 // not leap but are counted like leap ones if we just take
2460 // the number of centuries in between for nLostWeekDays
2461 int nLostWeekDays
= (nCentury
- nCenturyReal
) -
2462 (nCentury
/ 4 - nCenturyReal
/ 4);
2464 // we have to gain back the "lost" weekdays: note that the
2465 // effect of this loop is to not do anything to
2466 // nLostWeekDays (which we won't use any more), but to
2467 // (indirectly) set the year correctly
2468 while ( (nLostWeekDays
% 7) != 0 )
2470 nLostWeekDays
+= year
++ % 4 ? 1 : 2;
2473 // Keep year below 2000 so the 2digit year number
2474 // can never match the month or day of the month
2475 if (year
>=2000) year
-=28;
2476 // at any rate, we couldn't go further than 1988 + 9 + 28!
2477 wxASSERT_MSG( year
< 2030,
2478 _T("logic error in wxDateTime::Format") );
2480 wxString strYear
, strYear2
;
2481 strYear
.Printf(_T("%d"), year
);
2482 strYear2
.Printf(_T("%d"), year
% 100);
2484 // find four strings not occurring in format (this is surely
2485 // not the optimal way of doing it... improvements welcome!)
2486 wxString fmt2
= format
;
2487 wxString replacement
,replacement2
,replacement3
,replacement4
;
2488 for (int rnr
=1; rnr
<5 ; rnr
++)
2490 wxString r
= (wxChar
)-rnr
;
2491 while ( fmt2
.Find(r
) != wxNOT_FOUND
)
2498 case 1: replacement
=r
; break;
2499 case 2: replacement2
=r
; break;
2500 case 3: replacement3
=r
; break;
2501 case 4: replacement4
=r
; break;
2504 // replace all occurrences of year with it
2505 bool wasReplaced
= fmt2
.Replace(strYear
, replacement
) > 0;
2506 // evaluation order ensures we always attempt the replacement.
2507 wasReplaced
= (fmt2
.Replace(strYear2
, replacement2
) > 0) || wasReplaced
;
2509 // use strftime() to format the same date but in supported
2512 // NB: we assume that strftime() doesn't check for the
2513 // date validity and will happily format the date
2514 // corresponding to Feb 29 of a non leap year (which
2515 // may happen if yearReal was leap and year is not)
2516 struct tm tmAdjusted
;
2518 tmAdjusted
.tm_hour
= tm
.hour
;
2519 tmAdjusted
.tm_min
= tm
.min
;
2520 tmAdjusted
.tm_sec
= tm
.sec
;
2521 tmAdjusted
.tm_wday
= tm
.GetWeekDay();
2522 tmAdjusted
.tm_yday
= GetDayOfYear();
2523 tmAdjusted
.tm_mday
= tm
.mday
;
2524 tmAdjusted
.tm_mon
= tm
.mon
;
2525 tmAdjusted
.tm_year
= year
- 1900;
2526 tmAdjusted
.tm_isdst
= 0; // no DST, already adjusted
2527 wxString str
= CallStrftime(*p
== _T('c') ? _T("%c")
2531 // now replace the occurrence of 1999 with the real year
2532 // we do this in two stages to stop the 2 digit year
2533 // matching any substring of the 4 digit year.
2534 // Any day,month hours and minutes components should be safe due
2535 // to ensuring the range of the years.
2536 wxString strYearReal
, strYearReal2
;
2537 strYearReal
.Printf(_T("%04d"), yearReal
);
2538 strYearReal2
.Printf(_T("%02d"), yearReal
% 100);
2539 str
.Replace(strYear
, replacement3
);
2540 str
.Replace(strYear2
,replacement4
);
2541 str
.Replace(replacement3
, strYearReal
);
2542 str
.Replace(replacement4
, strYearReal2
);
2544 // and replace back all occurrences of replacement string
2547 str
.Replace(replacement2
, strYear2
);
2548 str
.Replace(replacement
, strYear
);
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 wxChar
*format
,
3141 const wxDateTime
& dateDef
)
3143 wxCHECK_MSG( date
&& format
, (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 ( const wxChar
*fmt
= format
; *fmt
; 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
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
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 wday
= GetWeekDayFromName(token
, Name_Full
| Name_Abbr
);
3967 if ( wday
!= Inv_WeekDay
)
3977 else // not a valid weekday name
3980 static const wxChar
*ordinals
[] =
3982 wxTRANSLATE("first"),
3983 wxTRANSLATE("second"),
3984 wxTRANSLATE("third"),
3985 wxTRANSLATE("fourth"),
3986 wxTRANSLATE("fifth"),
3987 wxTRANSLATE("sixth"),
3988 wxTRANSLATE("seventh"),
3989 wxTRANSLATE("eighth"),
3990 wxTRANSLATE("ninth"),
3991 wxTRANSLATE("tenth"),
3992 wxTRANSLATE("eleventh"),
3993 wxTRANSLATE("twelfth"),
3994 wxTRANSLATE("thirteenth"),
3995 wxTRANSLATE("fourteenth"),
3996 wxTRANSLATE("fifteenth"),
3997 wxTRANSLATE("sixteenth"),
3998 wxTRANSLATE("seventeenth"),
3999 wxTRANSLATE("eighteenth"),
4000 wxTRANSLATE("nineteenth"),
4001 wxTRANSLATE("twentieth"),
4002 // that's enough - otherwise we'd have problems with
4003 // composite (or not) ordinals
4007 for ( n
= 0; n
< WXSIZEOF(ordinals
); n
++ )
4009 if ( token
.CmpNoCase(ordinals
[n
]) == 0 )
4015 if ( n
== WXSIZEOF(ordinals
) )
4017 // stop here - something unknown
4024 // don't try anything here (as in case of numeric day
4025 // above) - the symbolic day spec should always
4026 // precede the month/year
4032 day
= (wxDateTime_t
)(n
+ 1);
4037 nPosCur
= tok
.GetPosition();
4040 // either no more tokens or the scan was stopped by something we couldn't
4041 // parse - in any case, see if we can construct a date from what we have
4042 if ( !haveDay
&& !haveWDay
)
4044 wxLogDebug(_T("ParseDate: no day, no weekday hence no date."));
4049 if ( haveWDay
&& (haveMon
|| haveYear
|| haveDay
) &&
4050 !(haveDay
&& haveMon
&& haveYear
) )
4052 // without adjectives (which we don't support here) the week day only
4053 // makes sense completely separately or with the full date
4054 // specification (what would "Wed 1999" mean?)
4058 if ( !haveWDay
&& haveYear
&& !(haveDay
&& haveMon
) )
4060 // may be we have month and day instead of day and year?
4061 if ( haveDay
&& !haveMon
)
4065 // exchange day and month
4066 mon
= (wxDateTime::Month
)(day
- 1);
4068 // we're in the current year then
4069 if ( (year
> 0) && (year
<= (int)GetNumOfDaysInMonth(Inv_Year
, mon
)) )
4071 day
= (wxDateTime_t
)year
;
4076 //else: no, can't exchange, leave haveMon == false
4082 // if we give the year, month and day must be given too
4083 wxLogDebug(_T("ParseDate: day and month should be specified if year is."));
4091 mon
= GetCurrentMonth();
4096 year
= GetCurrentYear();
4101 // normally we check the day above but the check is optimistic in case
4102 // we find the day before its month/year so we have to redo it now
4103 if ( day
> GetNumOfDaysInMonth(year
, mon
) )
4106 Set(day
, mon
, year
);
4110 // check that it is really the same
4111 if ( GetWeekDay() != wday
)
4113 // inconsistency detected
4114 wxLogDebug(_T("ParseDate: inconsistent day/weekday."));
4116 return (wxChar
*)NULL
;
4124 SetToWeekDayInSameWeek(wday
);
4127 // return the pointer to the first unparsed char
4129 if ( nPosCur
&& wxStrchr(dateDelimiters
, *(p
- 1)) )
4131 // if we couldn't parse the token after the delimiter, put back the
4132 // delimiter as well
4139 const wxChar
*wxDateTime::ParseTime(const wxChar
*time
)
4141 wxCHECK_MSG( time
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
4143 // first try some extra things
4150 { wxTRANSLATE("noon"), 12 },
4151 { wxTRANSLATE("midnight"), 00 },
4155 for ( size_t n
= 0; n
< WXSIZEOF(stdTimes
); n
++ )
4157 wxString timeString
= wxGetTranslation(stdTimes
[n
].name
);
4158 size_t len
= timeString
.length();
4159 if ( timeString
.CmpNoCase(wxString(time
, len
)) == 0 )
4161 // casts required by DigitalMars
4162 Set(stdTimes
[n
].hour
, wxDateTime_t(0), wxDateTime_t(0));
4168 // try all time formats we may think about in the order from longest to
4171 // 12hour with AM/PM?
4172 const wxChar
*result
= ParseFormat(time
, _T("%I:%M:%S %p"));
4176 // normally, it's the same, but why not try it?
4177 result
= ParseFormat(time
, _T("%H:%M:%S"));
4182 // 12hour with AM/PM but without seconds?
4183 result
= ParseFormat(time
, _T("%I:%M %p"));
4189 result
= ParseFormat(time
, _T("%H:%M"));
4194 // just the hour and AM/PM?
4195 result
= ParseFormat(time
, _T("%I %p"));
4201 result
= ParseFormat(time
, _T("%H"));
4206 // parse the standard format: normally it is one of the formats above
4207 // but it may be set to something completely different by the user
4208 result
= ParseFormat(time
, _T("%X"));
4211 // TODO: parse timezones
4216 // ----------------------------------------------------------------------------
4217 // Workdays and holidays support
4218 // ----------------------------------------------------------------------------
4220 bool wxDateTime::IsWorkDay(Country
WXUNUSED(country
)) const
4222 return !wxDateTimeHolidayAuthority::IsHoliday(*this);
4225 // ============================================================================
4227 // ============================================================================
4229 wxDateSpan WXDLLIMPEXP_BASE
operator*(int n
, const wxDateSpan
& ds
)
4232 return ds1
.Multiply(n
);
4235 // ============================================================================
4237 // ============================================================================
4239 wxTimeSpan WXDLLIMPEXP_BASE
operator*(int n
, const wxTimeSpan
& ts
)
4241 return wxTimeSpan(ts
).Multiply(n
);
4244 // this enum is only used in wxTimeSpan::Format() below but we can't declare
4245 // it locally to the method as it provokes an internal compiler error in egcs
4246 // 2.91.60 when building with -O2
4257 // not all strftime(3) format specifiers make sense here because, for example,
4258 // a time span doesn't have a year nor a timezone
4260 // Here are the ones which are supported (all of them are supported by strftime
4262 // %H hour in 24 hour format
4263 // %M minute (00 - 59)
4264 // %S second (00 - 59)
4267 // Also, for MFC CTimeSpan compatibility, we support
4268 // %D number of days
4270 // And, to be better than MFC :-), we also have
4271 // %E number of wEeks
4272 // %l milliseconds (000 - 999)
4273 wxString
wxTimeSpan::Format(const wxChar
*format
) const
4275 wxCHECK_MSG( format
, wxEmptyString
, _T("NULL format in wxTimeSpan::Format") );
4278 str
.Alloc(wxStrlen(format
));
4280 // Suppose we have wxTimeSpan ts(1 /* hour */, 2 /* min */, 3 /* sec */)
4282 // Then, of course, ts.Format("%H:%M:%S") must return "01:02:03", but the
4283 // question is what should ts.Format("%S") do? The code here returns "3273"
4284 // in this case (i.e. the total number of seconds, not just seconds % 60)
4285 // because, for me, this call means "give me entire time interval in
4286 // seconds" and not "give me the seconds part of the time interval"
4288 // If we agree that it should behave like this, it is clear that the
4289 // interpretation of each format specifier depends on the presence of the
4290 // other format specs in the string: if there was "%H" before "%M", we
4291 // should use GetMinutes() % 60, otherwise just GetMinutes() &c
4293 // we remember the most important unit found so far
4294 TimeSpanPart partBiggest
= Part_MSec
;
4296 for ( const wxChar
*pch
= format
; *pch
; pch
++ )
4300 if ( ch
== _T('%') )
4302 // the start of the format specification of the printf() below
4303 wxString
fmtPrefix(_T('%'));
4308 // the number of digits for the format string, 0 if unused
4309 unsigned digits
= 0;
4311 ch
= *++pch
; // get the format spec char
4315 wxFAIL_MSG( _T("invalid format character") );
4321 // skip the part below switch
4326 if ( partBiggest
< Part_Day
)
4332 partBiggest
= Part_Day
;
4337 partBiggest
= Part_Week
;
4343 if ( partBiggest
< Part_Hour
)
4347 // the sign has already been taken into account
4348 // when outputting the biggest part
4356 partBiggest
= Part_Hour
;
4363 n
= GetMilliseconds().ToLong();
4364 if ( partBiggest
< Part_MSec
)
4371 //else: no need to reset partBiggest to Part_MSec, it is
4372 // the least significant one anyhow
4379 if ( partBiggest
< Part_Min
)
4388 partBiggest
= Part_Min
;
4395 n
= GetSeconds().ToLong();
4396 if ( partBiggest
< Part_Sec
)
4405 partBiggest
= Part_Sec
;
4414 // negative numbers need one extra position for '-' display
4418 fmtPrefix
<< _T("0") << digits
;
4421 str
+= wxString::Format(fmtPrefix
+ _T("ld"), n
);
4425 // normal character, just copy
4433 // ============================================================================
4434 // wxDateTimeHolidayAuthority and related classes
4435 // ============================================================================
4437 #include "wx/arrimpl.cpp"
4439 WX_DEFINE_OBJARRAY(wxDateTimeArray
)
4441 static int wxCMPFUNC_CONV
4442 wxDateTimeCompareFunc(wxDateTime
**first
, wxDateTime
**second
)
4444 wxDateTime dt1
= **first
,
4447 return dt1
== dt2
? 0 : dt1
< dt2
? -1 : +1;
4450 // ----------------------------------------------------------------------------
4451 // wxDateTimeHolidayAuthority
4452 // ----------------------------------------------------------------------------
4454 wxHolidayAuthoritiesArray
wxDateTimeHolidayAuthority::ms_authorities
;
4457 bool wxDateTimeHolidayAuthority::IsHoliday(const wxDateTime
& dt
)
4459 size_t count
= ms_authorities
.size();
4460 for ( size_t n
= 0; n
< count
; n
++ )
4462 if ( ms_authorities
[n
]->DoIsHoliday(dt
) )
4473 wxDateTimeHolidayAuthority::GetHolidaysInRange(const wxDateTime
& dtStart
,
4474 const wxDateTime
& dtEnd
,
4475 wxDateTimeArray
& holidays
)
4477 wxDateTimeArray hol
;
4481 const size_t countAuth
= ms_authorities
.size();
4482 for ( size_t nAuth
= 0; nAuth
< countAuth
; nAuth
++ )
4484 ms_authorities
[nAuth
]->DoGetHolidaysInRange(dtStart
, dtEnd
, hol
);
4486 WX_APPEND_ARRAY(holidays
, hol
);
4489 holidays
.Sort(wxDateTimeCompareFunc
);
4491 return holidays
.size();
4495 void wxDateTimeHolidayAuthority::ClearAllAuthorities()
4497 WX_CLEAR_ARRAY(ms_authorities
);
4501 void wxDateTimeHolidayAuthority::AddAuthority(wxDateTimeHolidayAuthority
*auth
)
4503 ms_authorities
.push_back(auth
);
4506 wxDateTimeHolidayAuthority::~wxDateTimeHolidayAuthority()
4508 // required here for Darwin
4511 // ----------------------------------------------------------------------------
4512 // wxDateTimeWorkDays
4513 // ----------------------------------------------------------------------------
4515 bool wxDateTimeWorkDays::DoIsHoliday(const wxDateTime
& dt
) const
4517 wxDateTime::WeekDay wd
= dt
.GetWeekDay();
4519 return (wd
== wxDateTime::Sun
) || (wd
== wxDateTime::Sat
);
4522 size_t wxDateTimeWorkDays::DoGetHolidaysInRange(const wxDateTime
& dtStart
,
4523 const wxDateTime
& dtEnd
,
4524 wxDateTimeArray
& holidays
) const
4526 if ( dtStart
> dtEnd
)
4528 wxFAIL_MSG( _T("invalid date range in GetHolidaysInRange") );
4535 // instead of checking all days, start with the first Sat after dtStart and
4536 // end with the last Sun before dtEnd
4537 wxDateTime dtSatFirst
= dtStart
.GetNextWeekDay(wxDateTime::Sat
),
4538 dtSatLast
= dtEnd
.GetPrevWeekDay(wxDateTime::Sat
),
4539 dtSunFirst
= dtStart
.GetNextWeekDay(wxDateTime::Sun
),
4540 dtSunLast
= dtEnd
.GetPrevWeekDay(wxDateTime::Sun
),
4543 for ( dt
= dtSatFirst
; dt
<= dtSatLast
; dt
+= wxDateSpan::Week() )
4548 for ( dt
= dtSunFirst
; dt
<= dtSunLast
; dt
+= wxDateSpan::Week() )
4553 return holidays
.GetCount();
4556 // ============================================================================
4557 // other helper functions
4558 // ============================================================================
4560 // ----------------------------------------------------------------------------
4561 // iteration helpers: can be used to write a for loop over enum variable like
4563 // for ( m = wxDateTime::Jan; m < wxDateTime::Inv_Month; wxNextMonth(m) )
4564 // ----------------------------------------------------------------------------
4566 WXDLLIMPEXP_BASE
void wxNextMonth(wxDateTime::Month
& m
)
4568 wxASSERT_MSG( m
< wxDateTime::Inv_Month
, _T("invalid month") );
4570 // no wrapping or the for loop above would never end!
4571 m
= (wxDateTime::Month
)(m
+ 1);
4574 WXDLLIMPEXP_BASE
void wxPrevMonth(wxDateTime::Month
& m
)
4576 wxASSERT_MSG( m
< wxDateTime::Inv_Month
, _T("invalid month") );
4578 m
= m
== wxDateTime::Jan
? wxDateTime::Inv_Month
4579 : (wxDateTime::Month
)(m
- 1);
4582 WXDLLIMPEXP_BASE
void wxNextWDay(wxDateTime::WeekDay
& wd
)
4584 wxASSERT_MSG( wd
< wxDateTime::Inv_WeekDay
, _T("invalid week day") );
4586 // no wrapping or the for loop above would never end!
4587 wd
= (wxDateTime::WeekDay
)(wd
+ 1);
4590 WXDLLIMPEXP_BASE
void wxPrevWDay(wxDateTime::WeekDay
& wd
)
4592 wxASSERT_MSG( wd
< wxDateTime::Inv_WeekDay
, _T("invalid week day") );
4594 wd
= wd
== wxDateTime::Sun
? wxDateTime::Inv_WeekDay
4595 : (wxDateTime::WeekDay
)(wd
- 1);
4598 #endif // wxUSE_DATETIME