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 ///////////////////////////////////////////////////////////////////////////////
19 // TODO: for $DEITY sake, someone please fix the #ifdef __WXWINCE__ everywhere,
20 // the proper way to do it is to implement (subset of) wxStrftime() for
21 // CE instead of this horror!!
24 * Implementation notes:
26 * 1. the time is stored as a 64bit integer containing the signed number of
27 * milliseconds since Jan 1. 1970 (the Unix Epoch) - so it is always
30 * 2. the range is thus something about 580 million years, but due to current
31 * algorithms limitations, only dates from Nov 24, 4714BC are handled
33 * 3. standard ANSI C functions are used to do time calculations whenever
34 * possible, i.e. when the date is in the range Jan 1, 1970 to 2038
36 * 4. otherwise, the calculations are done by converting the date to/from JDN
37 * first (the range limitation mentioned above comes from here: the
38 * algorithm used by Scott E. Lee's code only works for positive JDNs, more
41 * 5. the object constructed for the given DD-MM-YYYY HH:MM:SS corresponds to
42 * this moment in local time and may be converted to the object
43 * corresponding to the same date/time in another time zone by using
46 * 6. the conversions to the current (or any other) timezone are done when the
47 * internal time representation is converted to the broken-down one in
51 // ============================================================================
53 // ============================================================================
55 // ----------------------------------------------------------------------------
57 // ----------------------------------------------------------------------------
59 // For compilers that support precompilation, includes "wx.h".
60 #include "wx/wxprec.h"
66 #if !defined(wxUSE_DATETIME) || wxUSE_DATETIME
69 #include "wx/string.h"
74 #include "wx/thread.h"
75 #include "wx/tokenzr.h"
76 #include "wx/module.h"
81 #include "wx/msw/wrapwin.h"
88 #include "wx/datetime.h"
89 #include "wx/stopwatch.h" // for wxGetLocalTimeMillis()
91 const long wxDateTime::TIME_T_FACTOR
= 1000l;
93 #if wxUSE_EXTENDED_RTTI
95 template<> void wxStringReadValue(const wxString
&s
, wxDateTime
&data
)
97 data
.ParseFormat(s
,wxT("%Y-%m-%d %H:%M:%S")) ;
100 template<> void wxStringWriteValue(wxString
&s
, const wxDateTime
&data
)
102 s
= data
.Format(wxT("%Y-%m-%d %H:%M:%S")) ;
105 wxCUSTOM_TYPE_INFO(wxDateTime
, wxToStringConverter
<wxDateTime
> , wxFromStringConverter
<wxDateTime
>)
110 // ----------------------------------------------------------------------------
111 // conditional compilation
112 // ----------------------------------------------------------------------------
114 #if defined(HAVE_STRPTIME) && defined(__GLIBC__) && \
115 ((__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0))
116 // glibc 2.0.7 strptime() is broken - the following snippet causes it to
117 // crash (instead of just failing):
119 // strncpy(buf, "Tue Dec 21 20:25:40 1999", 128);
120 // strptime(buf, "%x", &tm);
124 #endif // broken strptime()
126 #if defined(HAVE_STRPTIME) && defined(__DARWIN__) && defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
127 // configure detects strptime as linkable because it's in the OS X
128 // System library but MSL headers don't declare it.
130 // char *strptime(const char *, const char *, struct tm *);
131 // However, we DON'T want to just provide it here because we would
132 // crash and/or overwrite data when strptime from OS X tries
133 // to fill in MW's struct tm which is two fields shorter (no TZ stuff)
134 // So for now let's just say we don't have strptime
138 #if defined(__MWERKS__) && wxUSE_UNICODE
142 #if !defined(WX_TIMEZONE) && !defined(WX_GMTOFF_IN_TM)
143 #if defined(__WXPALMOS__)
144 #define WX_GMTOFF_IN_TM
145 #elif defined(__BORLANDC__) || defined(__MINGW32__) || defined(__VISAGECPP__)
146 #define WX_TIMEZONE _timezone
147 #elif defined(__MWERKS__)
148 long wxmw_timezone
= 28800;
149 #define WX_TIMEZONE wxmw_timezone
150 #elif defined(__DJGPP__) || defined(__WINE__)
151 #include <sys/timeb.h>
153 static long wxGetTimeZone()
155 static long timezone
= MAXLONG
; // invalid timezone
156 if (timezone
== MAXLONG
)
160 timezone
= tb
.timezone
;
164 #define WX_TIMEZONE wxGetTimeZone()
165 #elif defined(__DARWIN__)
166 #define WX_GMTOFF_IN_TM
167 #else // unknown platform - try timezone
168 #define WX_TIMEZONE timezone
170 #endif // !WX_TIMEZONE && !WX_GMTOFF_IN_TM
173 static wxMutex timeLock
;
176 #ifndef HAVE_LOCALTIME_R
177 struct tm
*wxLocaltime_r(const time_t* ticks
, struct tm
* temp
)
179 #if wxUSE_THREADS && !defined(__WINDOWS__)
180 // No need to waste time with a mutex on windows since it's using
181 // thread local storage for localtime anyway.
182 wxMutexLocker(timeLock
);
184 memcpy(temp
, localtime(ticks
), sizeof(struct tm
));
189 #ifndef HAVE_GMTIME_R
190 struct tm
*wxGmtime_r(const time_t* ticks
, struct tm
* temp
)
192 #if wxUSE_THREADS && !defined(__WINDOWS__)
193 // No need to waste time with a mutex on windows since it's
194 // using thread local storage for gmtime anyway.
195 wxMutexLocker(timeLock
);
197 memcpy(temp
, gmtime(ticks
), sizeof(struct tm
));
202 // ----------------------------------------------------------------------------
204 // ----------------------------------------------------------------------------
206 // debugging helper: just a convenient replacement of wxCHECK()
207 #define wxDATETIME_CHECK(expr, msg) \
211 *this = wxInvalidDateTime; \
215 // ----------------------------------------------------------------------------
217 // ----------------------------------------------------------------------------
219 class wxDateTimeHolidaysModule
: public wxModule
222 virtual bool OnInit()
224 wxDateTimeHolidayAuthority::AddAuthority(new wxDateTimeWorkDays
);
229 virtual void OnExit()
231 wxDateTimeHolidayAuthority::ClearAllAuthorities();
232 wxDateTimeHolidayAuthority::ms_authorities
.clear();
236 DECLARE_DYNAMIC_CLASS(wxDateTimeHolidaysModule
)
239 IMPLEMENT_DYNAMIC_CLASS(wxDateTimeHolidaysModule
, wxModule
)
241 // ----------------------------------------------------------------------------
243 // ----------------------------------------------------------------------------
246 static const int MONTHS_IN_YEAR
= 12;
248 static const int SEC_PER_MIN
= 60;
250 static const int MIN_PER_HOUR
= 60;
252 static const int HOURS_PER_DAY
= 24;
254 static const long SECONDS_PER_DAY
= 86400l;
256 static const int DAYS_PER_WEEK
= 7;
258 static const long MILLISECONDS_PER_DAY
= 86400000l;
260 // this is the integral part of JDN of the midnight of Jan 1, 1970
261 // (i.e. JDN(Jan 1, 1970) = 2440587.5)
262 static const long EPOCH_JDN
= 2440587l;
264 // used only in asserts
266 // the date of JDN -0.5 (as we don't work with fractional parts, this is the
267 // reference date for us) is Nov 24, 4714BC
268 static const int JDN_0_YEAR
= -4713;
269 static const int JDN_0_MONTH
= wxDateTime::Nov
;
270 static const int JDN_0_DAY
= 24;
271 #endif // __WXDEBUG__
273 // the constants used for JDN calculations
274 static const long JDN_OFFSET
= 32046l;
275 static const long DAYS_PER_5_MONTHS
= 153l;
276 static const long DAYS_PER_4_YEARS
= 1461l;
277 static const long DAYS_PER_400_YEARS
= 146097l;
279 // this array contains the cumulated number of days in all previous months for
280 // normal and leap years
281 static const wxDateTime::wxDateTime_t gs_cumulatedDays
[2][MONTHS_IN_YEAR
] =
283 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
284 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
287 // ----------------------------------------------------------------------------
289 // ----------------------------------------------------------------------------
291 const wxChar
* wxDefaultDateTimeFormat
= wxT("%c");
292 const wxChar
* wxDefaultTimeSpanFormat
= wxT("%H:%M:%S");
294 // in the fine tradition of ANSI C we use our equivalent of (time_t)-1 to
295 // indicate an invalid wxDateTime object
296 const wxDateTime wxDefaultDateTime
;
298 wxDateTime::Country
wxDateTime::ms_country
= wxDateTime::Country_Unknown
;
300 // ----------------------------------------------------------------------------
302 // ----------------------------------------------------------------------------
304 // debugger helper: shows what the date really is
306 extern const wxChar
*wxDumpDate(const wxDateTime
* dt
)
308 static wxChar buf
[128];
310 wxStrcpy(buf
, dt
->Format(_T("%Y-%m-%d (%a) %H:%M:%S")));
316 // get the number of days in the given month of the given year
318 wxDateTime::wxDateTime_t
GetNumOfDaysInMonth(int year
, wxDateTime::Month month
)
320 // the number of days in month in Julian/Gregorian calendar: the first line
321 // is for normal years, the second one is for the leap ones
322 static wxDateTime::wxDateTime_t daysInMonth
[2][MONTHS_IN_YEAR
] =
324 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
325 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
328 return daysInMonth
[wxDateTime::IsLeapYear(year
)][month
];
331 // returns the time zone in the C sense, i.e. the difference UTC - local
333 static int GetTimeZone()
335 #ifdef WX_GMTOFF_IN_TM
336 // set to true when the timezone is set
337 static bool s_timezoneSet
= false;
338 static long gmtoffset
= LONG_MAX
; // invalid timezone
340 // ensure that the timezone variable is set by calling wxLocaltime_r
341 if ( !s_timezoneSet
)
343 // just call wxLocaltime_r() instead of figuring out whether this
344 // system supports tzset(), _tzset() or something else
349 tm
= wxLocaltime_r(&t
, &tmstruct
);
350 s_timezoneSet
= true;
352 // note that GMT offset is the opposite of time zone and so to return
353 // consistent results in both WX_GMTOFF_IN_TM and !WX_GMTOFF_IN_TM
354 // cases we have to negate it
355 gmtoffset
= -tm
->tm_gmtoff
;
358 return (int)gmtoffset
;
359 #else // !WX_GMTOFF_IN_TM
360 return (int)WX_TIMEZONE
;
361 #endif // WX_GMTOFF_IN_TM/!WX_GMTOFF_IN_TM
364 // return the integral part of the JDN for the midnight of the given date (to
365 // get the real JDN you need to add 0.5, this is, in fact, JDN of the
366 // noon of the previous day)
367 static long GetTruncatedJDN(wxDateTime::wxDateTime_t day
,
368 wxDateTime::Month mon
,
371 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
373 // check the date validity
375 (year
> JDN_0_YEAR
) ||
376 ((year
== JDN_0_YEAR
) && (mon
> JDN_0_MONTH
)) ||
377 ((year
== JDN_0_YEAR
) && (mon
== JDN_0_MONTH
) && (day
>= JDN_0_DAY
)),
378 _T("date out of range - can't convert to JDN")
381 // make the year positive to avoid problems with negative numbers division
384 // months are counted from March here
386 if ( mon
>= wxDateTime::Mar
)
396 // now we can simply add all the contributions together
397 return ((year
/ 100) * DAYS_PER_400_YEARS
) / 4
398 + ((year
% 100) * DAYS_PER_4_YEARS
) / 4
399 + (month
* DAYS_PER_5_MONTHS
+ 2) / 5
405 // this function is a wrapper around strftime(3) adding error checking
406 static wxString
CallStrftime(const wxChar
*format
, const tm
* tm
)
409 // Create temp wxString here to work around mingw/cygwin bug 1046059
410 // http://sourceforge.net/tracker/?func=detail&atid=102435&aid=1046059&group_id=2435
413 if ( !wxStrftime(buf
, WXSIZEOF(buf
), format
, tm
) )
415 // buffer is too small?
416 wxFAIL_MSG(_T("strftime() failed"));
426 #if wxUSE_UNIX && !defined(HAVE_STRPTIME_DECL)
427 // configure detected that we had strptime() but not its declaration,
428 // provide it ourselves
429 extern "C" char *strptime(const char *, const char *, struct tm
*);
432 // Unicode-friendly strptime() wrapper
433 static const wxChar
*
434 CallStrptime(const wxChar
*input
, const char *fmt
, tm
*tm
)
436 // the problem here is that strptime() returns pointer into the string we
437 // passed to it while we're really interested in the pointer into the
438 // original, Unicode, string so we try to transform the pointer back
440 wxCharBuffer
inputMB(wxConvertWX2MB(input
));
442 const char * const inputMB
= input
;
443 #endif // Unicode/Ascii
445 const char *result
= strptime(inputMB
, fmt
, tm
);
450 // FIXME: this is wrong in presence of surrogates &c
451 return input
+ (result
- inputMB
.data());
454 #endif // Unicode/Ascii
457 #endif // HAVE_STRPTIME
459 // if year and/or month have invalid values, replace them with the current ones
460 static void ReplaceDefaultYearMonthWithCurrent(int *year
,
461 wxDateTime::Month
*month
)
463 struct tm
*tmNow
= NULL
;
466 if ( *year
== wxDateTime::Inv_Year
)
468 tmNow
= wxDateTime::GetTmNow(&tmstruct
);
470 *year
= 1900 + tmNow
->tm_year
;
473 if ( *month
== wxDateTime::Inv_Month
)
476 tmNow
= wxDateTime::GetTmNow(&tmstruct
);
478 *month
= (wxDateTime::Month
)tmNow
->tm_mon
;
482 // fll the struct tm with default values
483 static void InitTm(struct tm
& tm
)
485 // struct tm may have etxra fields (undocumented and with unportable
486 // names) which, nevertheless, must be set to 0
487 memset(&tm
, 0, sizeof(struct tm
));
489 tm
.tm_mday
= 1; // mday 0 is invalid
490 tm
.tm_year
= 76; // any valid year
491 tm
.tm_isdst
= -1; // auto determine
497 // return the month if the string is a month name or Inv_Month otherwise
498 static wxDateTime::Month
GetMonthFromName(const wxString
& name
, int flags
)
500 wxDateTime::Month mon
;
501 for ( mon
= wxDateTime::Jan
; mon
< wxDateTime::Inv_Month
; wxNextMonth(mon
) )
503 // case-insensitive comparison either one of or with both abbreviated
505 if ( flags
& wxDateTime::Name_Full
)
507 if ( name
.CmpNoCase(wxDateTime::
508 GetMonthName(mon
, wxDateTime::Name_Full
)) == 0 )
514 if ( flags
& wxDateTime::Name_Abbr
)
516 if ( name
.CmpNoCase(wxDateTime::
517 GetMonthName(mon
, wxDateTime::Name_Abbr
)) == 0 )
527 // return the weekday if the string is a weekday name or Inv_WeekDay otherwise
528 static wxDateTime::WeekDay
GetWeekDayFromName(const wxString
& name
, int flags
)
530 wxDateTime::WeekDay wd
;
531 for ( wd
= wxDateTime::Sun
; wd
< wxDateTime::Inv_WeekDay
; wxNextWDay(wd
) )
533 // case-insensitive comparison either one of or with both abbreviated
535 if ( flags
& wxDateTime::Name_Full
)
537 if ( name
.CmpNoCase(wxDateTime::
538 GetWeekDayName(wd
, wxDateTime::Name_Full
)) == 0 )
544 if ( flags
& wxDateTime::Name_Abbr
)
546 if ( name
.CmpNoCase(wxDateTime::
547 GetWeekDayName(wd
, wxDateTime::Name_Abbr
)) == 0 )
558 struct tm
*wxDateTime::GetTmNow(struct tm
*tmstruct
)
560 time_t t
= GetTimeNow();
561 return wxLocaltime_r(&t
, tmstruct
);
564 // scans all digits (but no more than len) and returns the resulting number
565 static bool GetNumericToken(size_t len
, const wxChar
*& p
, unsigned long *number
)
569 while ( wxIsdigit(*p
) )
573 if ( len
&& ++n
> len
)
577 return !s
.empty() && s
.ToULong(number
);
580 // scans all alphabetic characters and returns the resulting string
581 static wxString
GetAlphaToken(const wxChar
*& p
)
584 while ( wxIsalpha(*p
) )
592 // ============================================================================
593 // implementation of wxDateTime
594 // ============================================================================
596 // ----------------------------------------------------------------------------
598 // ----------------------------------------------------------------------------
602 year
= (wxDateTime_t
)wxDateTime::Inv_Year
;
603 mon
= wxDateTime::Inv_Month
;
605 hour
= min
= sec
= msec
= 0;
606 wday
= wxDateTime::Inv_WeekDay
;
609 wxDateTime::Tm::Tm(const struct tm
& tm
, const TimeZone
& tz
)
613 sec
= (wxDateTime::wxDateTime_t
)tm
.tm_sec
;
614 min
= (wxDateTime::wxDateTime_t
)tm
.tm_min
;
615 hour
= (wxDateTime::wxDateTime_t
)tm
.tm_hour
;
616 mday
= (wxDateTime::wxDateTime_t
)tm
.tm_mday
;
617 mon
= (wxDateTime::Month
)tm
.tm_mon
;
618 year
= 1900 + tm
.tm_year
;
619 wday
= (wxDateTime::wxDateTime_t
)tm
.tm_wday
;
620 yday
= (wxDateTime::wxDateTime_t
)tm
.tm_yday
;
623 bool wxDateTime::Tm::IsValid() const
625 // we allow for the leap seconds, although we don't use them (yet)
626 return (year
!= wxDateTime::Inv_Year
) && (mon
!= wxDateTime::Inv_Month
) &&
627 (mday
<= GetNumOfDaysInMonth(year
, mon
)) &&
628 (hour
< 24) && (min
< 60) && (sec
< 62) && (msec
< 1000);
631 void wxDateTime::Tm::ComputeWeekDay()
633 // compute the week day from day/month/year: we use the dumbest algorithm
634 // possible: just compute our JDN and then use the (simple to derive)
635 // formula: weekday = (JDN + 1.5) % 7
636 wday
= (wxDateTime::wxDateTime_t
)((wxDateTime::WeekDay
)(GetTruncatedJDN(mday
, mon
, year
) + 2) % 7);
639 void wxDateTime::Tm::AddMonths(int monDiff
)
641 // normalize the months field
642 while ( monDiff
< -mon
)
646 monDiff
+= MONTHS_IN_YEAR
;
649 while ( monDiff
+ mon
>= MONTHS_IN_YEAR
)
653 monDiff
-= MONTHS_IN_YEAR
;
656 mon
= (wxDateTime::Month
)(mon
+ monDiff
);
658 wxASSERT_MSG( mon
>= 0 && mon
< MONTHS_IN_YEAR
, _T("logic error") );
660 // NB: we don't check here that the resulting date is valid, this function
661 // is private and the caller must check it if needed
664 void wxDateTime::Tm::AddDays(int dayDiff
)
666 // normalize the days field
667 while ( dayDiff
+ mday
< 1 )
671 dayDiff
+= GetNumOfDaysInMonth(year
, mon
);
674 mday
= (wxDateTime::wxDateTime_t
)( mday
+ dayDiff
);
675 while ( mday
> GetNumOfDaysInMonth(year
, mon
) )
677 mday
-= GetNumOfDaysInMonth(year
, mon
);
682 wxASSERT_MSG( mday
> 0 && mday
<= GetNumOfDaysInMonth(year
, mon
),
686 // ----------------------------------------------------------------------------
688 // ----------------------------------------------------------------------------
690 wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz
)
694 case wxDateTime::Local
:
695 // get the offset from C RTL: it returns the difference GMT-local
696 // while we want to have the offset _from_ GMT, hence the '-'
697 m_offset
= -GetTimeZone();
700 case wxDateTime::GMT_12
:
701 case wxDateTime::GMT_11
:
702 case wxDateTime::GMT_10
:
703 case wxDateTime::GMT_9
:
704 case wxDateTime::GMT_8
:
705 case wxDateTime::GMT_7
:
706 case wxDateTime::GMT_6
:
707 case wxDateTime::GMT_5
:
708 case wxDateTime::GMT_4
:
709 case wxDateTime::GMT_3
:
710 case wxDateTime::GMT_2
:
711 case wxDateTime::GMT_1
:
712 m_offset
= -3600*(wxDateTime::GMT0
- tz
);
715 case wxDateTime::GMT0
:
716 case wxDateTime::GMT1
:
717 case wxDateTime::GMT2
:
718 case wxDateTime::GMT3
:
719 case wxDateTime::GMT4
:
720 case wxDateTime::GMT5
:
721 case wxDateTime::GMT6
:
722 case wxDateTime::GMT7
:
723 case wxDateTime::GMT8
:
724 case wxDateTime::GMT9
:
725 case wxDateTime::GMT10
:
726 case wxDateTime::GMT11
:
727 case wxDateTime::GMT12
:
728 m_offset
= 3600*(tz
- wxDateTime::GMT0
);
731 case wxDateTime::A_CST
:
732 // Central Standard Time in use in Australia = UTC + 9.5
733 m_offset
= 60l*(9*MIN_PER_HOUR
+ MIN_PER_HOUR
/2);
737 wxFAIL_MSG( _T("unknown time zone") );
741 // ----------------------------------------------------------------------------
743 // ----------------------------------------------------------------------------
746 bool wxDateTime::IsLeapYear(int year
, wxDateTime::Calendar cal
)
748 if ( year
== Inv_Year
)
749 year
= GetCurrentYear();
751 if ( cal
== Gregorian
)
753 // in Gregorian calendar leap years are those divisible by 4 except
754 // those divisible by 100 unless they're also divisible by 400
755 // (in some countries, like Russia and Greece, additional corrections
756 // exist, but they won't manifest themselves until 2700)
757 return (year
% 4 == 0) && ((year
% 100 != 0) || (year
% 400 == 0));
759 else if ( cal
== Julian
)
761 // in Julian calendar the rule is simpler
762 return year
% 4 == 0;
766 wxFAIL_MSG(_T("unknown calendar"));
773 int wxDateTime::GetCentury(int year
)
775 return year
> 0 ? year
/ 100 : year
/ 100 - 1;
779 int wxDateTime::ConvertYearToBC(int year
)
782 return year
> 0 ? year
: year
- 1;
786 int wxDateTime::GetCurrentYear(wxDateTime::Calendar cal
)
791 return Now().GetYear();
794 wxFAIL_MSG(_T("TODO"));
798 wxFAIL_MSG(_T("unsupported calendar"));
806 wxDateTime::Month
wxDateTime::GetCurrentMonth(wxDateTime::Calendar cal
)
811 return Now().GetMonth();
814 wxFAIL_MSG(_T("TODO"));
818 wxFAIL_MSG(_T("unsupported calendar"));
826 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(int year
, Calendar cal
)
828 if ( year
== Inv_Year
)
830 // take the current year if none given
831 year
= GetCurrentYear();
838 return IsLeapYear(year
) ? 366 : 365;
841 wxFAIL_MSG(_T("unsupported calendar"));
849 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(wxDateTime::Month month
,
851 wxDateTime::Calendar cal
)
853 wxCHECK_MSG( month
< MONTHS_IN_YEAR
, 0, _T("invalid month") );
855 if ( cal
== Gregorian
|| cal
== Julian
)
857 if ( year
== Inv_Year
)
859 // take the current year if none given
860 year
= GetCurrentYear();
863 return GetNumOfDaysInMonth(year
, month
);
867 wxFAIL_MSG(_T("unsupported calendar"));
874 wxString
wxDateTime::GetMonthName(wxDateTime::Month month
,
875 wxDateTime::NameFlags flags
)
877 wxCHECK_MSG( month
!= Inv_Month
, wxEmptyString
, _T("invalid month") );
879 // notice that we must set all the fields to avoid confusing libc (GNU one
880 // gets confused to a crash if we don't do this)
885 return CallStrftime(flags
== Name_Abbr
? _T("%b") : _T("%B"), &tm
);
891 ret
= (flags
== Name_Abbr
? wxT("Jan"): wxT("January"));
894 ret
= (flags
== Name_Abbr
? wxT("Feb"): wxT("Febuary"));
897 ret
= (flags
== Name_Abbr
? wxT("Mar"): wxT("March"));
900 ret
= (flags
== Name_Abbr
? wxT("Apr"): wxT("April"));
903 ret
= (flags
== Name_Abbr
? wxT("May"): wxT("May"));
906 ret
= (flags
== Name_Abbr
? wxT("Jun"): wxT("June"));
909 ret
= (flags
== Name_Abbr
? wxT("Jul"): wxT("July"));
912 ret
= (flags
== Name_Abbr
? wxT("Aug"): wxT("August"));
915 ret
= (flags
== Name_Abbr
? wxT("Sep"): wxT("September"));
918 ret
= (flags
== Name_Abbr
? wxT("Oct"): wxT("October"));
921 ret
= (flags
== Name_Abbr
? wxT("Nov"): wxT("November"));
924 ret
= (flags
== Name_Abbr
? wxT("Dec"): wxT("December"));
932 wxString
wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday
,
933 wxDateTime::NameFlags flags
)
935 wxCHECK_MSG( wday
!= Inv_WeekDay
, wxEmptyString
, _T("invalid weekday") );
937 // take some arbitrary Sunday (but notice that the day should be such that
938 // after adding wday to it below we still have a valid date, e.g. don't
946 // and offset it by the number of days needed to get the correct wday
949 // call mktime() to normalize it...
952 // ... and call strftime()
953 return CallStrftime(flags
== Name_Abbr
? _T("%a") : _T("%A"), &tm
);
959 ret
= (flags
== Name_Abbr
? wxT("Sun") : wxT("Sunday"));
962 ret
= (flags
== Name_Abbr
? wxT("Mon") : wxT("Monday"));
965 ret
= (flags
== Name_Abbr
? wxT("Tue") : wxT("Tuesday"));
968 ret
= (flags
== Name_Abbr
? wxT("Wed") : wxT("Wednesday"));
971 ret
= (flags
== Name_Abbr
? wxT("Thu") : wxT("Thursday"));
974 ret
= (flags
== Name_Abbr
? wxT("Fri") : wxT("Friday"));
977 ret
= (flags
== Name_Abbr
? wxT("Sat") : wxT("Saturday"));
986 void wxDateTime::GetAmPmStrings(wxString
*am
, wxString
*pm
)
991 // @Note: Do not call 'CallStrftime' here! CallStrftime checks the return code
992 // and causes an assertion failed if the buffer is to small (which is good) - OR -
993 // if strftime does not return anything because the format string is invalid - OR -
994 // if there are no 'am' / 'pm' tokens defined for the current locale (which is not good).
995 // wxDateTime::ParseTime will try several different formats to parse the time.
996 // As a result, GetAmPmStrings might get called, even if the current locale
997 // does not define any 'am' / 'pm' tokens. In this case, wxStrftime would
998 // assert, even though it is a perfectly legal use.
1001 if (wxStrftime(buffer
, sizeof(buffer
)/sizeof(wxChar
), _T("%p"), &tm
) > 0)
1002 *am
= wxString(buffer
);
1009 if (wxStrftime(buffer
, sizeof(buffer
)/sizeof(wxChar
), _T("%p"), &tm
) > 0)
1010 *pm
= wxString(buffer
);
1016 // ----------------------------------------------------------------------------
1017 // Country stuff: date calculations depend on the country (DST, work days,
1018 // ...), so we need to know which rules to follow.
1019 // ----------------------------------------------------------------------------
1022 wxDateTime::Country
wxDateTime::GetCountry()
1024 // TODO use LOCALE_ICOUNTRY setting under Win32
1026 if ( ms_country
== Country_Unknown
)
1028 // try to guess from the time zone name
1029 time_t t
= time(NULL
);
1031 struct tm
*tm
= wxLocaltime_r(&t
, &tmstruct
);
1033 wxString tz
= CallStrftime(_T("%Z"), tm
);
1034 if ( tz
== _T("WET") || tz
== _T("WEST") )
1038 else if ( tz
== _T("CET") || tz
== _T("CEST") )
1040 ms_country
= Country_EEC
;
1042 else if ( tz
== _T("MSK") || tz
== _T("MSD") )
1044 ms_country
= Russia
;
1046 else if ( tz
== _T("AST") || tz
== _T("ADT") ||
1047 tz
== _T("EST") || tz
== _T("EDT") ||
1048 tz
== _T("CST") || tz
== _T("CDT") ||
1049 tz
== _T("MST") || tz
== _T("MDT") ||
1050 tz
== _T("PST") || tz
== _T("PDT") )
1056 // well, choose a default one
1068 void wxDateTime::SetCountry(wxDateTime::Country country
)
1070 ms_country
= country
;
1074 bool wxDateTime::IsWestEuropeanCountry(Country country
)
1076 if ( country
== Country_Default
)
1078 country
= GetCountry();
1081 return (Country_WesternEurope_Start
<= country
) &&
1082 (country
<= Country_WesternEurope_End
);
1085 // ----------------------------------------------------------------------------
1086 // DST calculations: we use 3 different rules for the West European countries,
1087 // USA and for the rest of the world. This is undoubtedly false for many
1088 // countries, but I lack the necessary info (and the time to gather it),
1089 // please add the other rules here!
1090 // ----------------------------------------------------------------------------
1093 bool wxDateTime::IsDSTApplicable(int year
, Country country
)
1095 if ( year
== Inv_Year
)
1097 // take the current year if none given
1098 year
= GetCurrentYear();
1101 if ( country
== Country_Default
)
1103 country
= GetCountry();
1110 // DST was first observed in the US and UK during WWI, reused
1111 // during WWII and used again since 1966
1112 return year
>= 1966 ||
1113 (year
>= 1942 && year
<= 1945) ||
1114 (year
== 1918 || year
== 1919);
1117 // assume that it started after WWII
1123 wxDateTime
wxDateTime::GetBeginDST(int year
, Country country
)
1125 if ( year
== Inv_Year
)
1127 // take the current year if none given
1128 year
= GetCurrentYear();
1131 if ( country
== Country_Default
)
1133 country
= GetCountry();
1136 if ( !IsDSTApplicable(year
, country
) )
1138 return wxInvalidDateTime
;
1143 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
1145 // DST begins at 1 a.m. GMT on the last Sunday of March
1146 if ( !dt
.SetToLastWeekDay(Sun
, Mar
, year
) )
1149 wxFAIL_MSG( _T("no last Sunday in March?") );
1152 dt
+= wxTimeSpan::Hours(1);
1154 // disable DST tests because it could result in an infinite recursion!
1157 else switch ( country
)
1164 // don't know for sure - assume it was in effect all year
1169 dt
.Set(1, Jan
, year
);
1173 // DST was installed Feb 2, 1942 by the Congress
1174 dt
.Set(2, Feb
, year
);
1177 // Oil embargo changed the DST period in the US
1179 dt
.Set(6, Jan
, 1974);
1183 dt
.Set(23, Feb
, 1975);
1187 // before 1986, DST begun on the last Sunday of April, but
1188 // in 1986 Reagan changed it to begin at 2 a.m. of the
1189 // first Sunday in April
1192 if ( !dt
.SetToLastWeekDay(Sun
, Apr
, year
) )
1195 wxFAIL_MSG( _T("no first Sunday in April?") );
1200 if ( !dt
.SetToWeekDay(Sun
, 1, Apr
, year
) )
1203 wxFAIL_MSG( _T("no first Sunday in April?") );
1207 dt
+= wxTimeSpan::Hours(2);
1209 // TODO what about timezone??
1215 // assume Mar 30 as the start of the DST for the rest of the world
1216 // - totally bogus, of course
1217 dt
.Set(30, Mar
, year
);
1224 wxDateTime
wxDateTime::GetEndDST(int year
, Country country
)
1226 if ( year
== Inv_Year
)
1228 // take the current year if none given
1229 year
= GetCurrentYear();
1232 if ( country
== Country_Default
)
1234 country
= GetCountry();
1237 if ( !IsDSTApplicable(year
, country
) )
1239 return wxInvalidDateTime
;
1244 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
1246 // DST ends at 1 a.m. GMT on the last Sunday of October
1247 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1249 // weirder and weirder...
1250 wxFAIL_MSG( _T("no last Sunday in October?") );
1253 dt
+= wxTimeSpan::Hours(1);
1255 // disable DST tests because it could result in an infinite recursion!
1258 else switch ( country
)
1265 // don't know for sure - assume it was in effect all year
1269 dt
.Set(31, Dec
, year
);
1273 // the time was reset after the end of the WWII
1274 dt
.Set(30, Sep
, year
);
1278 // DST ends at 2 a.m. on the last Sunday of October
1279 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1281 // weirder and weirder...
1282 wxFAIL_MSG( _T("no last Sunday in October?") );
1285 dt
+= wxTimeSpan::Hours(2);
1287 // TODO what about timezone??
1292 // assume October 26th as the end of the DST - totally bogus too
1293 dt
.Set(26, Oct
, year
);
1299 // ----------------------------------------------------------------------------
1300 // constructors and assignment operators
1301 // ----------------------------------------------------------------------------
1303 // return the current time with ms precision
1304 /* static */ wxDateTime
wxDateTime::UNow()
1306 return wxDateTime(wxGetLocalTimeMillis());
1309 // the values in the tm structure contain the local time
1310 wxDateTime
& wxDateTime::Set(const struct tm
& tm
)
1313 time_t timet
= mktime(&tm2
);
1315 if ( timet
== (time_t)-1 )
1317 // mktime() rather unintuitively fails for Jan 1, 1970 if the hour is
1318 // less than timezone - try to make it work for this case
1319 if ( tm2
.tm_year
== 70 && tm2
.tm_mon
== 0 && tm2
.tm_mday
== 1 )
1321 return Set((time_t)(
1323 tm2
.tm_hour
* MIN_PER_HOUR
* SEC_PER_MIN
+
1324 tm2
.tm_min
* SEC_PER_MIN
+
1328 wxFAIL_MSG( _T("mktime() failed") );
1330 *this = wxInvalidDateTime
;
1340 wxDateTime
& wxDateTime::Set(wxDateTime_t hour
,
1341 wxDateTime_t minute
,
1342 wxDateTime_t second
,
1343 wxDateTime_t millisec
)
1345 // we allow seconds to be 61 to account for the leap seconds, even if we
1346 // don't use them really
1347 wxDATETIME_CHECK( hour
< 24 &&
1351 _T("Invalid time in wxDateTime::Set()") );
1353 // get the current date from system
1355 struct tm
*tm
= GetTmNow(&tmstruct
);
1357 wxDATETIME_CHECK( tm
, _T("wxLocaltime_r() failed") );
1359 // make a copy so it isn't clobbered by the call to mktime() below
1364 tm1
.tm_min
= minute
;
1365 tm1
.tm_sec
= second
;
1367 // and the DST in case it changes on this date
1370 if ( tm2
.tm_isdst
!= tm1
.tm_isdst
)
1371 tm1
.tm_isdst
= tm2
.tm_isdst
;
1375 // and finally adjust milliseconds
1376 return SetMillisecond(millisec
);
1379 wxDateTime
& wxDateTime::Set(wxDateTime_t day
,
1383 wxDateTime_t minute
,
1384 wxDateTime_t second
,
1385 wxDateTime_t millisec
)
1387 wxDATETIME_CHECK( hour
< 24 &&
1391 _T("Invalid time in wxDateTime::Set()") );
1393 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1395 wxDATETIME_CHECK( (0 < day
) && (day
<= GetNumberOfDays(month
, year
)),
1396 _T("Invalid date in wxDateTime::Set()") );
1398 // the range of time_t type (inclusive)
1399 static const int yearMinInRange
= 1970;
1400 static const int yearMaxInRange
= 2037;
1402 // test only the year instead of testing for the exact end of the Unix
1403 // time_t range - it doesn't bring anything to do more precise checks
1404 if ( year
>= yearMinInRange
&& year
<= yearMaxInRange
)
1406 // use the standard library version if the date is in range - this is
1407 // probably more efficient than our code
1409 tm
.tm_year
= year
- 1900;
1415 tm
.tm_isdst
= -1; // mktime() will guess it
1419 // and finally adjust milliseconds
1421 SetMillisecond(millisec
);
1427 // do time calculations ourselves: we want to calculate the number of
1428 // milliseconds between the given date and the epoch
1430 // get the JDN for the midnight of this day
1431 m_time
= GetTruncatedJDN(day
, month
, year
);
1432 m_time
-= EPOCH_JDN
;
1433 m_time
*= SECONDS_PER_DAY
* TIME_T_FACTOR
;
1435 // JDN corresponds to GMT, we take localtime
1436 Add(wxTimeSpan(hour
, minute
, second
+ GetTimeZone(), millisec
));
1442 wxDateTime
& wxDateTime::Set(double jdn
)
1444 // so that m_time will be 0 for the midnight of Jan 1, 1970 which is jdn
1446 jdn
-= EPOCH_JDN
+ 0.5;
1448 m_time
.Assign(jdn
*MILLISECONDS_PER_DAY
);
1450 // JDNs always are in UTC, so we don't need any adjustments for time zone
1455 wxDateTime
& wxDateTime::ResetTime()
1459 if ( tm
.hour
|| tm
.min
|| tm
.sec
|| tm
.msec
)
1472 // ----------------------------------------------------------------------------
1473 // DOS Date and Time Format functions
1474 // ----------------------------------------------------------------------------
1475 // the dos date and time value is an unsigned 32 bit value in the format:
1476 // YYYYYYYMMMMDDDDDhhhhhmmmmmmsssss
1478 // Y = year offset from 1980 (0-127)
1480 // D = day of month (1-31)
1482 // m = minute (0-59)
1483 // s = bisecond (0-29) each bisecond indicates two seconds
1484 // ----------------------------------------------------------------------------
1486 wxDateTime
& wxDateTime::SetFromDOS(unsigned long ddt
)
1491 long year
= ddt
& 0xFE000000;
1496 long month
= ddt
& 0x1E00000;
1501 long day
= ddt
& 0x1F0000;
1505 long hour
= ddt
& 0xF800;
1509 long minute
= ddt
& 0x7E0;
1513 long second
= ddt
& 0x1F;
1514 tm
.tm_sec
= second
* 2;
1516 return Set(mktime(&tm
));
1519 unsigned long wxDateTime::GetAsDOS() const
1522 time_t ticks
= GetTicks();
1524 struct tm
*tm
= wxLocaltime_r(&ticks
, &tmstruct
);
1526 long year
= tm
->tm_year
;
1530 long month
= tm
->tm_mon
;
1534 long day
= tm
->tm_mday
;
1537 long hour
= tm
->tm_hour
;
1540 long minute
= tm
->tm_min
;
1543 long second
= tm
->tm_sec
;
1546 ddt
= year
| month
| day
| hour
| minute
| second
;
1550 // ----------------------------------------------------------------------------
1551 // time_t <-> broken down time conversions
1552 // ----------------------------------------------------------------------------
1554 wxDateTime::Tm
wxDateTime::GetTm(const TimeZone
& tz
) const
1556 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1558 time_t time
= GetTicks();
1559 if ( time
!= (time_t)-1 )
1561 // use C RTL functions
1564 if ( tz
.GetOffset() == -GetTimeZone() )
1566 // we are working with local time
1567 tm
= wxLocaltime_r(&time
, &tmstruct
);
1569 // should never happen
1570 wxCHECK_MSG( tm
, Tm(), _T("wxLocaltime_r() failed") );
1574 time
+= (time_t)tz
.GetOffset();
1575 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
1576 int time2
= (int) time
;
1582 tm
= wxGmtime_r(&time
, &tmstruct
);
1584 // should never happen
1585 wxCHECK_MSG( tm
, Tm(), _T("wxGmtime_r() failed") );
1589 tm
= (struct tm
*)NULL
;
1595 // adjust the milliseconds
1597 long timeOnly
= (m_time
% MILLISECONDS_PER_DAY
).ToLong();
1598 tm2
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1601 //else: use generic code below
1604 // remember the time and do the calculations with the date only - this
1605 // eliminates rounding errors of the floating point arithmetics
1607 wxLongLong timeMidnight
= m_time
+ tz
.GetOffset() * 1000;
1609 long timeOnly
= (timeMidnight
% MILLISECONDS_PER_DAY
).ToLong();
1611 // we want to always have positive time and timeMidnight to be really
1612 // the midnight before it
1615 timeOnly
= MILLISECONDS_PER_DAY
+ timeOnly
;
1618 timeMidnight
-= timeOnly
;
1620 // calculate the Gregorian date from JDN for the midnight of our date:
1621 // this will yield day, month (in 1..12 range) and year
1623 // actually, this is the JDN for the noon of the previous day
1624 long jdn
= (timeMidnight
/ MILLISECONDS_PER_DAY
).ToLong() + EPOCH_JDN
;
1626 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
1628 wxASSERT_MSG( jdn
> -2, _T("JDN out of range") );
1630 // calculate the century
1631 long temp
= (jdn
+ JDN_OFFSET
) * 4 - 1;
1632 long century
= temp
/ DAYS_PER_400_YEARS
;
1634 // then the year and day of year (1 <= dayOfYear <= 366)
1635 temp
= ((temp
% DAYS_PER_400_YEARS
) / 4) * 4 + 3;
1636 long year
= (century
* 100) + (temp
/ DAYS_PER_4_YEARS
);
1637 long dayOfYear
= (temp
% DAYS_PER_4_YEARS
) / 4 + 1;
1639 // and finally the month and day of the month
1640 temp
= dayOfYear
* 5 - 3;
1641 long month
= temp
/ DAYS_PER_5_MONTHS
;
1642 long day
= (temp
% DAYS_PER_5_MONTHS
) / 5 + 1;
1644 // month is counted from March - convert to normal
1655 // year is offset by 4800
1658 // check that the algorithm gave us something reasonable
1659 wxASSERT_MSG( (0 < month
) && (month
<= 12), _T("invalid month") );
1660 wxASSERT_MSG( (1 <= day
) && (day
< 32), _T("invalid day") );
1662 // construct Tm from these values
1664 tm
.year
= (int)year
;
1665 tm
.mon
= (Month
)(month
- 1); // algorithm yields 1 for January, not 0
1666 tm
.mday
= (wxDateTime_t
)day
;
1667 tm
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1668 timeOnly
-= tm
.msec
;
1669 timeOnly
/= 1000; // now we have time in seconds
1671 tm
.sec
= (wxDateTime_t
)(timeOnly
% SEC_PER_MIN
);
1673 timeOnly
/= SEC_PER_MIN
; // now we have time in minutes
1675 tm
.min
= (wxDateTime_t
)(timeOnly
% MIN_PER_HOUR
);
1678 tm
.hour
= (wxDateTime_t
)(timeOnly
/ MIN_PER_HOUR
);
1683 wxDateTime
& wxDateTime::SetYear(int year
)
1685 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1694 wxDateTime
& wxDateTime::SetMonth(Month month
)
1696 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1705 wxDateTime
& wxDateTime::SetDay(wxDateTime_t mday
)
1707 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1716 wxDateTime
& wxDateTime::SetHour(wxDateTime_t hour
)
1718 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1727 wxDateTime
& wxDateTime::SetMinute(wxDateTime_t min
)
1729 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1738 wxDateTime
& wxDateTime::SetSecond(wxDateTime_t sec
)
1740 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1749 wxDateTime
& wxDateTime::SetMillisecond(wxDateTime_t millisecond
)
1751 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1753 // we don't need to use GetTm() for this one
1754 m_time
-= m_time
% 1000l;
1755 m_time
+= millisecond
;
1760 // ----------------------------------------------------------------------------
1761 // wxDateTime arithmetics
1762 // ----------------------------------------------------------------------------
1764 wxDateTime
& wxDateTime::Add(const wxDateSpan
& diff
)
1768 tm
.year
+= diff
.GetYears();
1769 tm
.AddMonths(diff
.GetMonths());
1771 // check that the resulting date is valid
1772 if ( tm
.mday
> GetNumOfDaysInMonth(tm
.year
, tm
.mon
) )
1774 // We suppose that when adding one month to Jan 31 we want to get Feb
1775 // 28 (or 29), i.e. adding a month to the last day of the month should
1776 // give the last day of the next month which is quite logical.
1778 // Unfortunately, there is no logic way to understand what should
1779 // Jan 30 + 1 month be - Feb 28 too or Feb 27 (assuming non leap year)?
1780 // We make it Feb 28 (last day too), but it is highly questionable.
1781 tm
.mday
= GetNumOfDaysInMonth(tm
.year
, tm
.mon
);
1784 tm
.AddDays(diff
.GetTotalDays());
1788 wxASSERT_MSG( IsSameTime(tm
),
1789 _T("Add(wxDateSpan) shouldn't modify time") );
1794 // ----------------------------------------------------------------------------
1795 // Weekday and monthday stuff
1796 // ----------------------------------------------------------------------------
1798 // convert Sun, Mon, ..., Sat into 6, 0, ..., 5
1799 static inline int ConvertWeekDayToMondayBase(int wd
)
1801 return wd
== wxDateTime::Sun
? 6 : wd
- 1;
1806 wxDateTime::SetToWeekOfYear(int year
, wxDateTime_t numWeek
, WeekDay wd
)
1808 wxASSERT_MSG( numWeek
> 0,
1809 _T("invalid week number: weeks are counted from 1") );
1811 // Jan 4 always lies in the 1st week of the year
1812 wxDateTime
dt(4, Jan
, year
);
1813 dt
.SetToWeekDayInSameWeek(wd
);
1814 dt
+= wxDateSpan::Weeks(numWeek
- 1);
1819 // use a separate function to avoid warnings about using deprecated
1820 // SetToTheWeek in GetWeek below
1822 SetToTheWeek(int year
,
1823 wxDateTime::wxDateTime_t numWeek
,
1824 wxDateTime::WeekDay weekday
,
1825 wxDateTime::WeekFlags flags
)
1827 // Jan 4 always lies in the 1st week of the year
1828 wxDateTime
dt(4, wxDateTime::Jan
, year
);
1829 dt
.SetToWeekDayInSameWeek(weekday
, flags
);
1830 dt
+= wxDateSpan::Weeks(numWeek
- 1);
1835 bool wxDateTime::SetToTheWeek(wxDateTime_t numWeek
,
1839 int year
= GetYear();
1840 *this = ::SetToTheWeek(year
, numWeek
, weekday
, flags
);
1841 if ( GetYear() != year
)
1843 // oops... numWeek was too big
1850 wxDateTime
wxDateTime::GetWeek(wxDateTime_t numWeek
,
1852 WeekFlags flags
) const
1854 return ::SetToTheWeek(GetYear(), numWeek
, weekday
, flags
);
1857 wxDateTime
& wxDateTime::SetToLastMonthDay(Month month
,
1860 // take the current month/year if none specified
1861 if ( year
== Inv_Year
)
1863 if ( month
== Inv_Month
)
1866 return Set(GetNumOfDaysInMonth(year
, month
), month
, year
);
1869 wxDateTime
& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday
, WeekFlags flags
)
1871 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
1873 int wdayDst
= weekday
,
1874 wdayThis
= GetWeekDay();
1875 if ( wdayDst
== wdayThis
)
1881 if ( flags
== Default_First
)
1883 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
1886 // the logic below based on comparing weekday and wdayThis works if Sun (0)
1887 // is the first day in the week, but breaks down for Monday_First case so
1888 // we adjust the week days in this case
1889 if ( flags
== Monday_First
)
1891 if ( wdayThis
== Sun
)
1893 if ( wdayDst
== Sun
)
1896 //else: Sunday_First, nothing to do
1898 // go forward or back in time to the day we want
1899 if ( wdayDst
< wdayThis
)
1901 return Subtract(wxDateSpan::Days(wdayThis
- wdayDst
));
1903 else // weekday > wdayThis
1905 return Add(wxDateSpan::Days(wdayDst
- wdayThis
));
1909 wxDateTime
& wxDateTime::SetToNextWeekDay(WeekDay weekday
)
1911 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
1914 WeekDay wdayThis
= GetWeekDay();
1915 if ( weekday
== wdayThis
)
1920 else if ( weekday
< wdayThis
)
1922 // need to advance a week
1923 diff
= 7 - (wdayThis
- weekday
);
1925 else // weekday > wdayThis
1927 diff
= weekday
- wdayThis
;
1930 return Add(wxDateSpan::Days(diff
));
1933 wxDateTime
& wxDateTime::SetToPrevWeekDay(WeekDay weekday
)
1935 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
1938 WeekDay wdayThis
= GetWeekDay();
1939 if ( weekday
== wdayThis
)
1944 else if ( weekday
> wdayThis
)
1946 // need to go to previous week
1947 diff
= 7 - (weekday
- wdayThis
);
1949 else // weekday < wdayThis
1951 diff
= wdayThis
- weekday
;
1954 return Subtract(wxDateSpan::Days(diff
));
1957 bool wxDateTime::SetToWeekDay(WeekDay weekday
,
1962 wxCHECK_MSG( weekday
!= Inv_WeekDay
, false, _T("invalid weekday") );
1964 // we don't check explicitly that -5 <= n <= 5 because we will return false
1965 // anyhow in such case - but may be should still give an assert for it?
1967 // take the current month/year if none specified
1968 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1972 // TODO this probably could be optimised somehow...
1976 // get the first day of the month
1977 dt
.Set(1, month
, year
);
1980 WeekDay wdayFirst
= dt
.GetWeekDay();
1982 // go to the first weekday of the month
1983 int diff
= weekday
- wdayFirst
;
1987 // add advance n-1 weeks more
1990 dt
+= wxDateSpan::Days(diff
);
1992 else // count from the end of the month
1994 // get the last day of the month
1995 dt
.SetToLastMonthDay(month
, year
);
1998 WeekDay wdayLast
= dt
.GetWeekDay();
2000 // go to the last weekday of the month
2001 int diff
= wdayLast
- weekday
;
2005 // and rewind n-1 weeks from there
2008 dt
-= wxDateSpan::Days(diff
);
2011 // check that it is still in the same month
2012 if ( dt
.GetMonth() == month
)
2020 // no such day in this month
2026 wxDateTime::wxDateTime_t
GetDayOfYearFromTm(const wxDateTime::Tm
& tm
)
2028 return (wxDateTime::wxDateTime_t
)(gs_cumulatedDays
[wxDateTime::IsLeapYear(tm
.year
)][tm
.mon
] + tm
.mday
);
2031 wxDateTime::wxDateTime_t
wxDateTime::GetDayOfYear(const TimeZone
& tz
) const
2033 return GetDayOfYearFromTm(GetTm(tz
));
2036 wxDateTime::wxDateTime_t
2037 wxDateTime::GetWeekOfYear(wxDateTime::WeekFlags flags
, const TimeZone
& tz
) const
2039 if ( flags
== Default_First
)
2041 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
2045 wxDateTime_t nDayInYear
= GetDayOfYearFromTm(tm
);
2047 int wdTarget
= GetWeekDay(tz
);
2048 int wdYearStart
= wxDateTime(1, Jan
, GetYear()).GetWeekDay();
2050 if ( flags
== Sunday_First
)
2052 // FIXME: First week is not calculated correctly.
2053 week
= (nDayInYear
- wdTarget
+ 7) / 7;
2054 if ( wdYearStart
== Wed
|| wdYearStart
== Thu
)
2057 else // week starts with monday
2059 // adjust the weekdays to non-US style.
2060 wdYearStart
= ConvertWeekDayToMondayBase(wdYearStart
);
2061 wdTarget
= ConvertWeekDayToMondayBase(wdTarget
);
2063 // quoting from http://www.cl.cam.ac.uk/~mgk25/iso-time.html:
2065 // Week 01 of a year is per definition the first week that has the
2066 // Thursday in this year, which is equivalent to the week that
2067 // contains the fourth day of January. In other words, the first
2068 // week of a new year is the week that has the majority of its
2069 // days in the new year. Week 01 might also contain days from the
2070 // previous year and the week before week 01 of a year is the last
2071 // week (52 or 53) of the previous year even if it contains days
2072 // from the new year. A week starts with Monday (day 1) and ends
2073 // with Sunday (day 7).
2076 // if Jan 1 is Thursday or less, it is in the first week of this year
2077 if ( wdYearStart
< 4 )
2079 // count the number of entire weeks between Jan 1 and this date
2080 week
= (nDayInYear
+ wdYearStart
+ 6 - wdTarget
)/7;
2082 // be careful to check for overflow in the next year
2083 if ( week
== 53 && tm
.mday
- wdTarget
> 28 )
2086 else // Jan 1 is in the last week of the previous year
2088 // check if we happen to be at the last week of previous year:
2089 if ( tm
.mon
== Jan
&& tm
.mday
< 8 - wdYearStart
)
2090 week
= wxDateTime(31, Dec
, GetYear()-1).GetWeekOfYear();
2092 week
= (nDayInYear
+ wdYearStart
- 1 - wdTarget
)/7;
2096 return (wxDateTime::wxDateTime_t
)week
;
2099 wxDateTime::wxDateTime_t
wxDateTime::GetWeekOfMonth(wxDateTime::WeekFlags flags
,
2100 const TimeZone
& tz
) const
2103 wxDateTime dtMonthStart
= wxDateTime(1, tm
.mon
, tm
.year
);
2104 int nWeek
= GetWeekOfYear(flags
) - dtMonthStart
.GetWeekOfYear(flags
) + 1;
2107 // this may happen for January when Jan, 1 is the last week of the
2109 nWeek
+= IsLeapYear(tm
.year
- 1) ? 53 : 52;
2112 return (wxDateTime::wxDateTime_t
)nWeek
;
2115 wxDateTime
& wxDateTime::SetToYearDay(wxDateTime::wxDateTime_t yday
)
2117 int year
= GetYear();
2118 wxDATETIME_CHECK( (0 < yday
) && (yday
<= GetNumberOfDays(year
)),
2119 _T("invalid year day") );
2121 bool isLeap
= IsLeapYear(year
);
2122 for ( Month mon
= Jan
; mon
< Inv_Month
; wxNextMonth(mon
) )
2124 // for Dec, we can't compare with gs_cumulatedDays[mon + 1], but we
2125 // don't need it neither - because of the CHECK above we know that
2126 // yday lies in December then
2127 if ( (mon
== Dec
) || (yday
<= gs_cumulatedDays
[isLeap
][mon
+ 1]) )
2129 Set((wxDateTime::wxDateTime_t
)(yday
- gs_cumulatedDays
[isLeap
][mon
]), mon
, year
);
2138 // ----------------------------------------------------------------------------
2139 // Julian day number conversion and related stuff
2140 // ----------------------------------------------------------------------------
2142 double wxDateTime::GetJulianDayNumber() const
2144 return m_time
.ToDouble() / MILLISECONDS_PER_DAY
+ EPOCH_JDN
+ 0.5;
2147 double wxDateTime::GetRataDie() const
2149 // March 1 of the year 0 is Rata Die day -306 and JDN 1721119.5
2150 return GetJulianDayNumber() - 1721119.5 - 306;
2153 // ----------------------------------------------------------------------------
2154 // timezone and DST stuff
2155 // ----------------------------------------------------------------------------
2157 int wxDateTime::IsDST(wxDateTime::Country country
) const
2159 wxCHECK_MSG( country
== Country_Default
, -1,
2160 _T("country support not implemented") );
2162 // use the C RTL for the dates in the standard range
2163 time_t timet
= GetTicks();
2164 if ( timet
!= (time_t)-1 )
2167 tm
*tm
= wxLocaltime_r(&timet
, &tmstruct
);
2169 wxCHECK_MSG( tm
, -1, _T("wxLocaltime_r() failed") );
2171 return tm
->tm_isdst
;
2175 int year
= GetYear();
2177 if ( !IsDSTApplicable(year
, country
) )
2179 // no DST time in this year in this country
2183 return IsBetween(GetBeginDST(year
, country
), GetEndDST(year
, country
));
2187 wxDateTime
& wxDateTime::MakeTimezone(const TimeZone
& tz
, bool noDST
)
2189 long secDiff
= GetTimeZone() + tz
.GetOffset();
2191 // we need to know whether DST is or not in effect for this date unless
2192 // the test disabled by the caller
2193 if ( !noDST
&& (IsDST() == 1) )
2195 // FIXME we assume that the DST is always shifted by 1 hour
2199 return Add(wxTimeSpan::Seconds(secDiff
));
2202 wxDateTime
& wxDateTime::MakeFromTimezone(const TimeZone
& tz
, bool noDST
)
2204 long secDiff
= GetTimeZone() + tz
.GetOffset();
2206 // we need to know whether DST is or not in effect for this date unless
2207 // the test disabled by the caller
2208 if ( !noDST
&& (IsDST() == 1) )
2210 // FIXME we assume that the DST is always shifted by 1 hour
2214 return Subtract(wxTimeSpan::Seconds(secDiff
));
2217 // ----------------------------------------------------------------------------
2218 // wxDateTime to/from text representations
2219 // ----------------------------------------------------------------------------
2221 wxString
wxDateTime::Format(const wxChar
*format
, const TimeZone
& tz
) const
2223 wxCHECK_MSG( format
, wxEmptyString
, _T("NULL format in wxDateTime::Format") );
2225 // we have to use our own implementation if the date is out of range of
2226 // strftime() or if we use non standard specificators
2227 time_t time
= GetTicks();
2228 if ( (time
!= (time_t)-1) && !wxStrstr(format
, _T("%l")) )
2233 if ( tz
.GetOffset() == -GetTimeZone() )
2235 // we are working with local time
2236 tm
= wxLocaltime_r(&time
, &tmstruct
);
2238 // should never happen
2239 wxCHECK_MSG( tm
, wxEmptyString
, _T("wxLocaltime_r() failed") );
2243 time
+= (int)tz
.GetOffset();
2245 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
2246 int time2
= (int) time
;
2252 tm
= wxGmtime_r(&time
, &tmstruct
);
2254 // should never happen
2255 wxCHECK_MSG( tm
, wxEmptyString
, _T("wxGmtime_r() failed") );
2259 tm
= (struct tm
*)NULL
;
2263 //Windows CE doesn't support strftime or wcsftime, so we use the generic implementation
2266 return CallStrftime(format
, tm
);
2269 //else: use generic code below
2272 // we only parse ANSI C format specifications here, no POSIX 2
2273 // complications, no GNU extensions but we do add support for a "%l" format
2274 // specifier allowing to get the number of milliseconds
2277 // used for calls to strftime() when we only deal with time
2278 struct tm tmTimeOnly
;
2279 tmTimeOnly
.tm_hour
= tm
.hour
;
2280 tmTimeOnly
.tm_min
= tm
.min
;
2281 tmTimeOnly
.tm_sec
= tm
.sec
;
2282 tmTimeOnly
.tm_wday
= 0;
2283 tmTimeOnly
.tm_yday
= 0;
2284 tmTimeOnly
.tm_mday
= 1; // any date will do
2285 tmTimeOnly
.tm_mon
= 0;
2286 tmTimeOnly
.tm_year
= 76;
2287 tmTimeOnly
.tm_isdst
= 0; // no DST, we adjust for tz ourselves
2289 wxString tmp
, res
, fmt
;
2290 for ( const wxChar
*p
= format
; *p
; p
++ )
2292 if ( *p
!= _T('%') )
2300 // set the default format
2303 case _T('Y'): // year has 4 digits
2307 case _T('j'): // day of year has 3 digits
2308 case _T('l'): // milliseconds have 3 digits
2312 case _T('w'): // week day as number has only one
2317 // it's either another valid format specifier in which case
2318 // the format is "%02d" (for all the rest) or we have the
2319 // field width preceding the format in which case it will
2320 // override the default format anyhow
2324 bool restart
= true;
2329 // start of the format specification
2332 case _T('a'): // a weekday name
2334 // second parameter should be true for abbreviated names
2335 res
+= GetWeekDayName(tm
.GetWeekDay(),
2336 *p
== _T('a') ? Name_Abbr
: Name_Full
);
2339 case _T('b'): // a month name
2341 res
+= GetMonthName(tm
.mon
,
2342 *p
== _T('b') ? Name_Abbr
: Name_Full
);
2345 case _T('c'): // locale default date and time representation
2346 case _T('x'): // locale default date representation
2349 // the problem: there is no way to know what do these format
2350 // specifications correspond to for the current locale.
2352 // the solution: use a hack and still use strftime(): first
2353 // find the YEAR which is a year in the strftime() range (1970
2354 // - 2038) whose Jan 1 falls on the same week day as the Jan 1
2355 // of the real year. Then make a copy of the format and
2356 // replace all occurrences of YEAR in it with some unique
2357 // string not appearing anywhere else in it, then use
2358 // strftime() to format the date in year YEAR and then replace
2359 // YEAR back by the real year and the unique replacement
2360 // string back with YEAR. Notice that "all occurrences of YEAR"
2361 // means all occurrences of 4 digit as well as 2 digit form!
2363 // the bugs: we assume that neither of %c nor %x contains any
2364 // fields which may change between the YEAR and real year. For
2365 // example, the week number (%U, %W) and the day number (%j)
2366 // will change if one of these years is leap and the other one
2369 // find the YEAR: normally, for any year X, Jan 1 or the
2370 // year X + 28 is the same weekday as Jan 1 of X (because
2371 // the weekday advances by 1 for each normal X and by 2
2372 // for each leap X, hence by 5 every 4 years or by 35
2373 // which is 0 mod 7 every 28 years) but this rule breaks
2374 // down if there are years between X and Y which are
2375 // divisible by 4 but not leap (i.e. divisible by 100 but
2376 // not 400), hence the correction.
2378 int yearReal
= GetYear(tz
);
2379 int mod28
= yearReal
% 28;
2381 // be careful to not go too far - we risk to leave the
2386 year
= 1988 + mod28
; // 1988 == 0 (mod 28)
2390 year
= 1970 + mod28
- 10; // 1970 == 10 (mod 28)
2393 int nCentury
= year
/ 100,
2394 nCenturyReal
= yearReal
/ 100;
2396 // need to adjust for the years divisble by 400 which are
2397 // not leap but are counted like leap ones if we just take
2398 // the number of centuries in between for nLostWeekDays
2399 int nLostWeekDays
= (nCentury
- nCenturyReal
) -
2400 (nCentury
/ 4 - nCenturyReal
/ 4);
2402 // we have to gain back the "lost" weekdays: note that the
2403 // effect of this loop is to not do anything to
2404 // nLostWeekDays (which we won't use any more), but to
2405 // (indirectly) set the year correctly
2406 while ( (nLostWeekDays
% 7) != 0 )
2408 nLostWeekDays
+= year
++ % 4 ? 1 : 2;
2411 // at any rate, we couldn't go further than 1988 + 9 + 28!
2412 wxASSERT_MSG( year
< 2030,
2413 _T("logic error in wxDateTime::Format") );
2415 wxString strYear
, strYear2
;
2416 strYear
.Printf(_T("%d"), year
);
2417 strYear2
.Printf(_T("%d"), year
% 100);
2419 // find two strings not occurring in format (this is surely
2420 // not the optimal way of doing it... improvements welcome!)
2421 wxString fmt2
= format
;
2422 wxString replacement
= (wxChar
)-1;
2423 while ( fmt2
.Find(replacement
) != wxNOT_FOUND
)
2425 replacement
<< (wxChar
)-1;
2428 wxString replacement2
= (wxChar
)-2;
2429 while ( fmt2
.Find(replacement
) != wxNOT_FOUND
)
2431 replacement
<< (wxChar
)-2;
2434 // replace all occurrences of year with it
2435 bool wasReplaced
= fmt2
.Replace(strYear
, replacement
) > 0;
2437 wasReplaced
= fmt2
.Replace(strYear2
, replacement2
) > 0;
2439 // use strftime() to format the same date but in supported
2442 // NB: we assume that strftime() doesn't check for the
2443 // date validity and will happily format the date
2444 // corresponding to Feb 29 of a non leap year (which
2445 // may happen if yearReal was leap and year is not)
2446 struct tm tmAdjusted
;
2448 tmAdjusted
.tm_hour
= tm
.hour
;
2449 tmAdjusted
.tm_min
= tm
.min
;
2450 tmAdjusted
.tm_sec
= tm
.sec
;
2451 tmAdjusted
.tm_wday
= tm
.GetWeekDay();
2452 tmAdjusted
.tm_yday
= GetDayOfYear();
2453 tmAdjusted
.tm_mday
= tm
.mday
;
2454 tmAdjusted
.tm_mon
= tm
.mon
;
2455 tmAdjusted
.tm_year
= year
- 1900;
2456 tmAdjusted
.tm_isdst
= 0; // no DST, already adjusted
2457 wxString str
= CallStrftime(*p
== _T('c') ? _T("%c")
2461 // now replace the occurrence of 1999 with the real year
2462 wxString strYearReal
, strYearReal2
;
2463 strYearReal
.Printf(_T("%04d"), yearReal
);
2464 strYearReal2
.Printf(_T("%02d"), yearReal
% 100);
2465 str
.Replace(strYear
, strYearReal
);
2466 str
.Replace(strYear2
, strYearReal2
);
2468 // and replace back all occurrences of replacement string
2471 str
.Replace(replacement2
, strYear2
);
2472 str
.Replace(replacement
, strYear
);
2478 //Use "%m/%d/%y %H:%M:%S" format instead
2479 res
+= wxString::Format(wxT("%02d/%02d/%04d %02d:%02d:%02d"),
2480 tm
.mon
+1,tm
.mday
, tm
.year
, tm
.hour
, tm
.min
, tm
.sec
);
2484 case _T('d'): // day of a month (01-31)
2485 res
+= wxString::Format(fmt
, tm
.mday
);
2488 case _T('H'): // hour in 24h format (00-23)
2489 res
+= wxString::Format(fmt
, tm
.hour
);
2492 case _T('I'): // hour in 12h format (01-12)
2494 // 24h -> 12h, 0h -> 12h too
2495 int hour12
= tm
.hour
> 12 ? tm
.hour
- 12
2496 : tm
.hour
? tm
.hour
: 12;
2497 res
+= wxString::Format(fmt
, hour12
);
2501 case _T('j'): // day of the year
2502 res
+= wxString::Format(fmt
, GetDayOfYear(tz
));
2505 case _T('l'): // milliseconds (NOT STANDARD)
2506 res
+= wxString::Format(fmt
, GetMillisecond(tz
));
2509 case _T('m'): // month as a number (01-12)
2510 res
+= wxString::Format(fmt
, tm
.mon
+ 1);
2513 case _T('M'): // minute as a decimal number (00-59)
2514 res
+= wxString::Format(fmt
, tm
.min
);
2517 case _T('p'): // AM or PM string
2519 res
+= CallStrftime(_T("%p"), &tmTimeOnly
);
2521 res
+= (tmTimeOnly
.tm_hour
> 12) ? wxT("pm") : wxT("am");
2525 case _T('S'): // second as a decimal number (00-61)
2526 res
+= wxString::Format(fmt
, tm
.sec
);
2529 case _T('U'): // week number in the year (Sunday 1st week day)
2530 res
+= wxString::Format(fmt
, GetWeekOfYear(Sunday_First
, tz
));
2533 case _T('W'): // week number in the year (Monday 1st week day)
2534 res
+= wxString::Format(fmt
, GetWeekOfYear(Monday_First
, tz
));
2537 case _T('w'): // weekday as a number (0-6), Sunday = 0
2538 res
+= wxString::Format(fmt
, tm
.GetWeekDay());
2541 // case _T('x'): -- handled with "%c"
2543 case _T('X'): // locale default time representation
2544 // just use strftime() to format the time for us
2546 res
+= CallStrftime(_T("%X"), &tmTimeOnly
);
2548 res
+= wxString::Format(wxT("%02d:%02d:%02d"),tm
.hour
, tm
.min
, tm
.sec
);
2552 case _T('y'): // year without century (00-99)
2553 res
+= wxString::Format(fmt
, tm
.year
% 100);
2556 case _T('Y'): // year with century
2557 res
+= wxString::Format(fmt
, tm
.year
);
2560 case _T('Z'): // timezone name
2562 res
+= CallStrftime(_T("%Z"), &tmTimeOnly
);
2567 // is it the format width?
2569 while ( *p
== _T('-') || *p
== _T('+') ||
2570 *p
== _T(' ') || wxIsdigit(*p
) )
2577 // we've only got the flags and width so far in fmt
2578 fmt
.Prepend(_T('%'));
2579 fmt
.Append(_T('d'));
2586 // no, it wasn't the width
2587 wxFAIL_MSG(_T("unknown format specificator"));
2589 // fall through and just copy it nevertheless
2591 case _T('%'): // a percent sign
2595 case 0: // the end of string
2596 wxFAIL_MSG(_T("missing format at the end of string"));
2598 // just put the '%' which was the last char in format
2608 // this function parses a string in (strict) RFC 822 format: see the section 5
2609 // of the RFC for the detailed description, but briefly it's something of the
2610 // form "Sat, 18 Dec 1999 00:48:30 +0100"
2612 // this function is "strict" by design - it must reject anything except true
2613 // RFC822 time specs.
2615 // TODO a great candidate for using reg exps
2616 const wxChar
*wxDateTime::ParseRfc822Date(const wxChar
* date
)
2618 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
2620 const wxChar
*p
= date
;
2621 const wxChar
*comma
= wxStrchr(p
, _T(','));
2624 // the part before comma is the weekday
2626 // skip it for now - we don't use but might check that it really
2627 // corresponds to the specfied date
2630 if ( *p
!= _T(' ') )
2632 wxLogDebug(_T("no space after weekday in RFC822 time spec"));
2634 return (wxChar
*)NULL
;
2640 // the following 1 or 2 digits are the day number
2641 if ( !wxIsdigit(*p
) )
2643 wxLogDebug(_T("day number expected in RFC822 time spec, none found"));
2645 return (wxChar
*)NULL
;
2648 wxDateTime_t day
= (wxDateTime_t
)(*p
++ - _T('0'));
2649 if ( wxIsdigit(*p
) )
2652 day
= (wxDateTime_t
)(day
+ (*p
++ - _T('0')));
2655 if ( *p
++ != _T(' ') )
2657 return (wxChar
*)NULL
;
2660 // the following 3 letters specify the month
2661 wxString
monName(p
, 3);
2663 if ( monName
== _T("Jan") )
2665 else if ( monName
== _T("Feb") )
2667 else if ( monName
== _T("Mar") )
2669 else if ( monName
== _T("Apr") )
2671 else if ( monName
== _T("May") )
2673 else if ( monName
== _T("Jun") )
2675 else if ( monName
== _T("Jul") )
2677 else if ( monName
== _T("Aug") )
2679 else if ( monName
== _T("Sep") )
2681 else if ( monName
== _T("Oct") )
2683 else if ( monName
== _T("Nov") )
2685 else if ( monName
== _T("Dec") )
2689 wxLogDebug(_T("Invalid RFC 822 month name '%s'"), monName
.c_str());
2691 return (wxChar
*)NULL
;
2696 if ( *p
++ != _T(' ') )
2698 return (wxChar
*)NULL
;
2702 if ( !wxIsdigit(*p
) )
2705 return (wxChar
*)NULL
;
2708 int year
= *p
++ - _T('0');
2710 if ( !wxIsdigit(*p
) )
2712 // should have at least 2 digits in the year
2713 return (wxChar
*)NULL
;
2717 year
+= *p
++ - _T('0');
2719 // is it a 2 digit year (as per original RFC 822) or a 4 digit one?
2720 if ( wxIsdigit(*p
) )
2723 year
+= *p
++ - _T('0');
2725 if ( !wxIsdigit(*p
) )
2727 // no 3 digit years please
2728 return (wxChar
*)NULL
;
2732 year
+= *p
++ - _T('0');
2735 if ( *p
++ != _T(' ') )
2737 return (wxChar
*)NULL
;
2740 // time is in the format hh:mm:ss and seconds are optional
2741 if ( !wxIsdigit(*p
) )
2743 return (wxChar
*)NULL
;
2746 wxDateTime_t hour
= (wxDateTime_t
)(*p
++ - _T('0'));
2748 if ( !wxIsdigit(*p
) )
2750 return (wxChar
*)NULL
;
2754 hour
= (wxDateTime_t
)(hour
+ (*p
++ - _T('0')));
2756 if ( *p
++ != _T(':') )
2758 return (wxChar
*)NULL
;
2761 if ( !wxIsdigit(*p
) )
2763 return (wxChar
*)NULL
;
2766 wxDateTime_t min
= (wxDateTime_t
)(*p
++ - _T('0'));
2768 if ( !wxIsdigit(*p
) )
2770 return (wxChar
*)NULL
;
2774 min
= (wxDateTime_t
)(min
+ *p
++ - _T('0'));
2776 wxDateTime_t sec
= 0;
2777 if ( *p
++ == _T(':') )
2779 if ( !wxIsdigit(*p
) )
2781 return (wxChar
*)NULL
;
2784 sec
= (wxDateTime_t
)(*p
++ - _T('0'));
2786 if ( !wxIsdigit(*p
) )
2788 return (wxChar
*)NULL
;
2792 sec
= (wxDateTime_t
)(sec
+ *p
++ - _T('0'));
2795 if ( *p
++ != _T(' ') )
2797 return (wxChar
*)NULL
;
2800 // and now the interesting part: the timezone
2801 int offset
wxDUMMY_INITIALIZE(0);
2802 if ( *p
== _T('-') || *p
== _T('+') )
2804 // the explicit offset given: it has the form of hhmm
2805 bool plus
= *p
++ == _T('+');
2807 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2809 return (wxChar
*)NULL
;
2813 offset
= MIN_PER_HOUR
*(10*(*p
- _T('0')) + (*(p
+ 1) - _T('0')));
2817 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2819 return (wxChar
*)NULL
;
2823 offset
+= 10*(*p
- _T('0')) + (*(p
+ 1) - _T('0'));
2834 // the symbolic timezone given: may be either military timezone or one
2835 // of standard abbreviations
2838 // military: Z = UTC, J unused, A = -1, ..., Y = +12
2839 static const int offsets
[26] =
2841 //A B C D E F G H I J K L M
2842 -1, -2, -3, -4, -5, -6, -7, -8, -9, 0, -10, -11, -12,
2843 //N O P R Q S T U V W Z Y Z
2844 +1, +2, +3, +4, +5, +6, +7, +8, +9, +10, +11, +12, 0
2847 if ( *p
< _T('A') || *p
> _T('Z') || *p
== _T('J') )
2849 wxLogDebug(_T("Invalid militaty timezone '%c'"), *p
);
2851 return (wxChar
*)NULL
;
2854 offset
= offsets
[*p
++ - _T('A')];
2860 if ( tz
== _T("UT") || tz
== _T("UTC") || tz
== _T("GMT") )
2862 else if ( tz
== _T("AST") )
2863 offset
= AST
- GMT0
;
2864 else if ( tz
== _T("ADT") )
2865 offset
= ADT
- GMT0
;
2866 else if ( tz
== _T("EST") )
2867 offset
= EST
- GMT0
;
2868 else if ( tz
== _T("EDT") )
2869 offset
= EDT
- GMT0
;
2870 else if ( tz
== _T("CST") )
2871 offset
= CST
- GMT0
;
2872 else if ( tz
== _T("CDT") )
2873 offset
= CDT
- GMT0
;
2874 else if ( tz
== _T("MST") )
2875 offset
= MST
- GMT0
;
2876 else if ( tz
== _T("MDT") )
2877 offset
= MDT
- GMT0
;
2878 else if ( tz
== _T("PST") )
2879 offset
= PST
- GMT0
;
2880 else if ( tz
== _T("PDT") )
2881 offset
= PDT
- GMT0
;
2884 wxLogDebug(_T("Unknown RFC 822 timezone '%s'"), p
);
2886 return (wxChar
*)NULL
;
2893 offset
*= MIN_PER_HOUR
;
2896 // the spec was correct, construct the date from the values we found
2897 Set(day
, mon
, year
, hour
, min
, sec
);
2898 MakeFromTimezone(TimeZone((wxDateTime_t
)(offset
*SEC_PER_MIN
)));
2905 // returns the string containing strftime() format used for short dates in the
2906 // current locale or an empty string
2907 static wxString
GetLocaleDateFormat()
2911 // there is no setlocale() under Windows CE, so just always query the
2914 if ( strcmp(setlocale(LC_ALL
, NULL
), "C") != 0 )
2917 // The locale was programatically set to non-C. We assume that this was
2918 // done using wxLocale, in which case thread's current locale is also
2919 // set to correct LCID value and we can use GetLocaleInfo to determine
2920 // the correct formatting string:
2922 LCID lcid
= LOCALE_USER_DEFAULT
;
2924 LCID lcid
= GetThreadLocale();
2926 // according to MSDN 80 chars is max allowed for short date format
2928 if ( ::GetLocaleInfo(lcid
, LOCALE_SSHORTDATE
, fmt
, WXSIZEOF(fmt
)) )
2930 wxChar chLast
= _T('\0');
2931 size_t lastCount
= 0;
2932 for ( const wxChar
*p
= fmt
; /* NUL handled inside */; p
++ )
2942 // these characters come in groups, start counting them
2952 // first deal with any special characters we have had
2958 switch ( lastCount
)
2962 // these two are the same as we
2963 // don't distinguish between 1 and
2964 // 2 digits for days
2977 wxFAIL_MSG( _T("too many 'd's") );
2982 switch ( lastCount
)
2986 // as for 'd' and 'dd' above
2999 wxFAIL_MSG( _T("too many 'M's") );
3004 switch ( lastCount
)
3016 wxFAIL_MSG( _T("wrong number of 'y's") );
3021 // strftime() doesn't have era string,
3022 // ignore this format
3023 wxASSERT_MSG( lastCount
<= 2,
3024 _T("too many 'g's") );
3028 wxFAIL_MSG( _T("unreachable") );
3035 // not a special character so must be just a separator,
3037 if ( *p
!= _T('\0') )
3039 if ( *p
== _T('%') )
3041 // this one needs to be escaped
3049 if ( *p
== _T('\0') )
3053 //else: GetLocaleInfo() failed, leave fmtDate value unchanged and
3054 // try our luck with the default formats
3056 //else: default C locale, default formats should work
3061 #endif // __WINDOWS__
3063 const wxChar
*wxDateTime::ParseFormat(const wxChar
*date
,
3064 const wxChar
*format
,
3065 const wxDateTime
& dateDef
)
3067 wxCHECK_MSG( date
&& format
, (wxChar
*)NULL
,
3068 _T("NULL pointer in wxDateTime::ParseFormat()") );
3073 // what fields have we found?
3074 bool haveWDay
= false,
3083 bool hourIsIn12hFormat
= false, // or in 24h one?
3084 isPM
= false; // AM by default
3086 // and the value of the items we have (init them to get rid of warnings)
3087 wxDateTime_t sec
= 0,
3090 WeekDay wday
= Inv_WeekDay
;
3091 wxDateTime_t yday
= 0,
3093 wxDateTime::Month mon
= Inv_Month
;
3096 const wxChar
*input
= date
;
3097 for ( const wxChar
*fmt
= format
; *fmt
; fmt
++ )
3099 if ( *fmt
!= _T('%') )
3101 if ( wxIsspace(*fmt
) )
3103 // a white space in the format string matches 0 or more white
3104 // spaces in the input
3105 while ( wxIsspace(*input
) )
3112 // any other character (not whitespace, not '%') must be
3113 // matched by itself in the input
3114 if ( *input
++ != *fmt
)
3117 return (wxChar
*)NULL
;
3121 // done with this format char
3125 // start of a format specification
3127 // parse the optional width
3129 while ( wxIsdigit(*++fmt
) )
3132 width
+= *fmt
- _T('0');
3135 // the default widths for the various fields
3140 case _T('Y'): // year has 4 digits
3144 case _T('j'): // day of year has 3 digits
3145 case _T('l'): // milliseconds have 3 digits
3149 case _T('w'): // week day as number has only one
3154 // default for all other fields
3159 // then the format itself
3162 case _T('a'): // a weekday name
3165 int flag
= *fmt
== _T('a') ? Name_Abbr
: Name_Full
;
3166 wday
= GetWeekDayFromName(GetAlphaToken(input
), flag
);
3167 if ( wday
== Inv_WeekDay
)
3170 return (wxChar
*)NULL
;
3176 case _T('b'): // a month name
3179 int flag
= *fmt
== _T('b') ? Name_Abbr
: Name_Full
;
3180 mon
= GetMonthFromName(GetAlphaToken(input
), flag
);
3181 if ( mon
== Inv_Month
)
3184 return (wxChar
*)NULL
;
3190 case _T('c'): // locale default date and time representation
3194 // this is the format which corresponds to ctime() output
3195 // and strptime("%c") should parse it, so try it first
3196 static const wxChar
*fmtCtime
= _T("%a %b %d %H:%M:%S %Y");
3198 const wxChar
*result
= dt
.ParseFormat(input
, fmtCtime
);
3201 result
= dt
.ParseFormat(input
, _T("%x %X"));
3206 result
= dt
.ParseFormat(input
, _T("%X %x"));
3211 // we've tried everything and still no match
3212 return (wxChar
*)NULL
;
3217 haveDay
= haveMon
= haveYear
=
3218 haveHour
= haveMin
= haveSec
= true;
3232 case _T('d'): // day of a month (01-31)
3233 if ( !GetNumericToken(width
, input
, &num
) ||
3234 (num
> 31) || (num
< 1) )
3237 return (wxChar
*)NULL
;
3240 // we can't check whether the day range is correct yet, will
3241 // do it later - assume ok for now
3243 mday
= (wxDateTime_t
)num
;
3246 case _T('H'): // hour in 24h format (00-23)
3247 if ( !GetNumericToken(width
, input
, &num
) || (num
> 23) )
3250 return (wxChar
*)NULL
;
3254 hour
= (wxDateTime_t
)num
;
3257 case _T('I'): // hour in 12h format (01-12)
3258 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 12) )
3261 return (wxChar
*)NULL
;
3265 hourIsIn12hFormat
= true;
3266 hour
= (wxDateTime_t
)(num
% 12); // 12 should be 0
3269 case _T('j'): // day of the year
3270 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 366) )
3273 return (wxChar
*)NULL
;
3277 yday
= (wxDateTime_t
)num
;
3280 case _T('m'): // month as a number (01-12)
3281 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 12) )
3284 return (wxChar
*)NULL
;
3288 mon
= (Month
)(num
- 1);
3291 case _T('M'): // minute as a decimal number (00-59)
3292 if ( !GetNumericToken(width
, input
, &num
) || (num
> 59) )
3295 return (wxChar
*)NULL
;
3299 min
= (wxDateTime_t
)num
;
3302 case _T('p'): // AM or PM string
3304 wxString am
, pm
, token
= GetAlphaToken(input
);
3306 GetAmPmStrings(&am
, &pm
);
3307 if (am
.empty() && pm
.empty())
3308 return (wxChar
*)NULL
; // no am/pm strings defined
3309 if ( token
.CmpNoCase(pm
) == 0 )
3313 else if ( token
.CmpNoCase(am
) != 0 )
3316 return (wxChar
*)NULL
;
3321 case _T('r'): // time as %I:%M:%S %p
3324 input
= dt
.ParseFormat(input
, _T("%I:%M:%S %p"));
3328 return (wxChar
*)NULL
;
3331 haveHour
= haveMin
= haveSec
= true;
3340 case _T('R'): // time as %H:%M
3343 input
= dt
.ParseFormat(input
, _T("%H:%M"));
3347 return (wxChar
*)NULL
;
3350 haveHour
= haveMin
= true;
3358 case _T('S'): // second as a decimal number (00-61)
3359 if ( !GetNumericToken(width
, input
, &num
) || (num
> 61) )
3362 return (wxChar
*)NULL
;
3366 sec
= (wxDateTime_t
)num
;
3369 case _T('T'): // time as %H:%M:%S
3372 input
= dt
.ParseFormat(input
, _T("%H:%M:%S"));
3376 return (wxChar
*)NULL
;
3379 haveHour
= haveMin
= haveSec
= true;
3388 case _T('w'): // weekday as a number (0-6), Sunday = 0
3389 if ( !GetNumericToken(width
, input
, &num
) || (wday
> 6) )
3392 return (wxChar
*)NULL
;
3396 wday
= (WeekDay
)num
;
3399 case _T('x'): // locale default date representation
3400 #ifdef HAVE_STRPTIME
3401 // try using strptime() -- it may fail even if the input is
3402 // correct but the date is out of range, so we will fall back
3403 // to our generic code anyhow
3407 const wxChar
*result
= CallStrptime(input
, "%x", &tm
);
3412 haveDay
= haveMon
= haveYear
= true;
3414 year
= 1900 + tm
.tm_year
;
3415 mon
= (Month
)tm
.tm_mon
;
3421 #endif // HAVE_STRPTIME
3429 // The above doesn't work for all locales, try to query
3430 // Windows for the right way of formatting the date:
3431 fmtDate
= GetLocaleDateFormat();
3432 if ( fmtDate
.empty() )
3435 if ( IsWestEuropeanCountry(GetCountry()) ||
3436 GetCountry() == Russia
)
3438 fmtDate
= _T("%d/%m/%y");
3439 fmtDateAlt
= _T("%m/%d/%y");
3443 fmtDate
= _T("%m/%d/%y");
3444 fmtDateAlt
= _T("%d/%m/%y");
3448 const wxChar
*result
= dt
.ParseFormat(input
, fmtDate
);
3450 if ( !result
&& !fmtDateAlt
.empty() )
3452 // ok, be nice and try another one
3453 result
= dt
.ParseFormat(input
, fmtDateAlt
);
3459 return (wxChar
*)NULL
;
3464 haveDay
= haveMon
= haveYear
= true;
3475 case _T('X'): // locale default time representation
3476 #ifdef HAVE_STRPTIME
3478 // use strptime() to do it for us (FIXME !Unicode friendly)
3480 input
= CallStrptime(input
, "%X", &tm
);
3483 return (wxChar
*)NULL
;
3486 haveHour
= haveMin
= haveSec
= true;
3492 #else // !HAVE_STRPTIME
3493 // TODO under Win32 we can query the LOCALE_ITIME system
3494 // setting which says whether the default time format is
3497 // try to parse what follows as "%H:%M:%S" and, if this
3498 // fails, as "%I:%M:%S %p" - this should catch the most
3502 const wxChar
*result
= dt
.ParseFormat(input
, _T("%T"));
3505 result
= dt
.ParseFormat(input
, _T("%r"));
3511 return (wxChar
*)NULL
;
3514 haveHour
= haveMin
= haveSec
= true;
3523 #endif // HAVE_STRPTIME/!HAVE_STRPTIME
3526 case _T('y'): // year without century (00-99)
3527 if ( !GetNumericToken(width
, input
, &num
) || (num
> 99) )
3530 return (wxChar
*)NULL
;
3535 // TODO should have an option for roll over date instead of
3536 // hard coding it here
3537 year
= (num
> 30 ? 1900 : 2000) + (wxDateTime_t
)num
;
3540 case _T('Y'): // year with century
3541 if ( !GetNumericToken(width
, input
, &num
) )
3544 return (wxChar
*)NULL
;
3548 year
= (wxDateTime_t
)num
;
3551 case _T('Z'): // timezone name
3552 wxFAIL_MSG(_T("TODO"));
3555 case _T('%'): // a percent sign
3556 if ( *input
++ != _T('%') )
3559 return (wxChar
*)NULL
;
3563 case 0: // the end of string
3564 wxFAIL_MSG(_T("unexpected format end"));
3568 default: // not a known format spec
3569 return (wxChar
*)NULL
;
3573 // format matched, try to construct a date from what we have now
3575 if ( dateDef
.IsValid() )
3577 // take this date as default
3578 tmDef
= dateDef
.GetTm();
3580 else if ( IsValid() )
3582 // if this date is valid, don't change it
3587 // no default and this date is invalid - fall back to Today()
3588 tmDef
= Today().GetTm();
3599 // TODO we don't check here that the values are consistent, if both year
3600 // day and month/day were found, we just ignore the year day and we
3601 // also always ignore the week day
3602 if ( haveMon
&& haveDay
)
3604 if ( mday
> GetNumOfDaysInMonth(tm
.year
, mon
) )
3606 wxLogDebug(_T("bad month day in wxDateTime::ParseFormat"));
3608 return (wxChar
*)NULL
;
3614 else if ( haveYDay
)
3616 if ( yday
> GetNumberOfDays(tm
.year
) )
3618 wxLogDebug(_T("bad year day in wxDateTime::ParseFormat"));
3620 return (wxChar
*)NULL
;
3623 Tm tm2
= wxDateTime(1, Jan
, tm
.year
).SetToYearDay(yday
).GetTm();
3630 if ( haveHour
&& hourIsIn12hFormat
&& isPM
)
3632 // translate to 24hour format
3635 //else: either already in 24h format or no translation needed
3655 // finally check that the week day is consistent -- if we had it
3656 if ( haveWDay
&& GetWeekDay() != wday
)
3658 wxLogDebug(_T("inconsistsnet week day in wxDateTime::ParseFormat()"));
3666 const wxChar
*wxDateTime::ParseDateTime(const wxChar
*date
)
3668 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3670 // Set to current day and hour, so strings like '14:00' becomes today at
3671 // 14, not some other random date
3672 wxDateTime dtDate
= wxDateTime::Today();
3673 wxDateTime dtTime
= wxDateTime::Today();
3675 const wxChar
* pchTime
;
3677 // Try to parse the beginning of the string as a date
3678 const wxChar
* pchDate
= dtDate
.ParseDate(date
);
3680 // We got a date in the beginning, see if there is a time specified after the date
3683 // Skip spaces, as the ParseTime() function fails on spaces
3684 while ( wxIsspace(*pchDate
) )
3687 pchTime
= dtTime
.ParseTime(pchDate
);
3689 else // no date in the beginning
3691 // check and see if we have a time followed by a date
3692 pchTime
= dtTime
.ParseTime(date
);
3695 while ( wxIsspace(*pchTime
) )
3698 pchDate
= dtDate
.ParseDate(pchTime
);
3702 // If we have a date specified, set our own data to the same date
3703 if ( !pchDate
|| !pchTime
)
3706 Set(dtDate
.GetDay(), dtDate
.GetMonth(), dtDate
.GetYear(),
3707 dtTime
.GetHour(), dtTime
.GetMinute(), dtTime
.GetSecond(),
3708 dtTime
.GetMillisecond());
3710 // Return endpoint of scan
3711 return pchDate
> pchTime
? pchDate
: pchTime
;
3714 const wxChar
*wxDateTime::ParseDate(const wxChar
*date
)
3716 // this is a simplified version of ParseDateTime() which understands only
3717 // "today" (for wxDate compatibility) and digits only otherwise (and not
3718 // all esoteric constructions ParseDateTime() knows about)
3720 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3722 const wxChar
*p
= date
;
3723 while ( wxIsspace(*p
) )
3726 // some special cases
3730 int dayDiffFromToday
;
3733 { wxTRANSLATE("today"), 0 },
3734 { wxTRANSLATE("yesterday"), -1 },
3735 { wxTRANSLATE("tomorrow"), 1 },
3738 for ( size_t n
= 0; n
< WXSIZEOF(literalDates
); n
++ )
3740 const wxString dateStr
= wxGetTranslation(literalDates
[n
].str
);
3741 size_t len
= dateStr
.length();
3742 if ( wxStrlen(p
) >= len
)
3744 wxString
str(p
, len
);
3745 if ( str
.CmpNoCase(dateStr
) == 0 )
3747 // nothing can follow this, so stop here
3750 int dayDiffFromToday
= literalDates
[n
].dayDiffFromToday
;
3752 if ( dayDiffFromToday
)
3754 *this += wxDateSpan::Days(dayDiffFromToday
);
3762 // We try to guess what we have here: for each new (numeric) token, we
3763 // determine if it can be a month, day or a year. Of course, there is an
3764 // ambiguity as some numbers may be days as well as months, so we also
3765 // have the ability to back track.
3768 bool haveDay
= false, // the months day?
3769 haveWDay
= false, // the day of week?
3770 haveMon
= false, // the month?
3771 haveYear
= false; // the year?
3773 // and the value of the items we have (init them to get rid of warnings)
3774 WeekDay wday
= Inv_WeekDay
;
3775 wxDateTime_t day
= 0;
3776 wxDateTime::Month mon
= Inv_Month
;
3779 // tokenize the string
3781 static const wxChar
*dateDelimiters
= _T(".,/-\t\r\n ");
3782 wxStringTokenizer
tok(p
, dateDelimiters
);
3783 while ( tok
.HasMoreTokens() )
3785 wxString token
= tok
.GetNextToken();
3791 if ( token
.ToULong(&val
) )
3793 // guess what this number is
3799 if ( !haveMon
&& val
> 0 && val
<= 12 )
3801 // assume it is month
3804 else // not the month
3808 // this can only be the year
3811 else // may be either day or year
3813 wxDateTime_t max_days
= (wxDateTime_t
)(
3815 ? GetNumOfDaysInMonth(haveYear
? year
: Inv_Year
, mon
)
3820 if ( (val
== 0) || (val
> (unsigned long)max_days
) )
3825 else // yes, suppose it's the day
3839 year
= (wxDateTime_t
)val
;
3848 day
= (wxDateTime_t
)val
;
3854 mon
= (Month
)(val
- 1);
3857 else // not a number
3859 // be careful not to overwrite the current mon value
3860 Month mon2
= GetMonthFromName(token
, Name_Full
| Name_Abbr
);
3861 if ( mon2
!= Inv_Month
)
3866 // but we already have a month - maybe we guessed wrong?
3869 // no need to check in month range as always < 12, but
3870 // the days are counted from 1 unlike the months
3871 day
= (wxDateTime_t
)(mon
+ 1);
3876 // could possible be the year (doesn't the year come
3877 // before the month in the japanese format?) (FIXME)
3886 else // not a valid month name
3888 wday
= GetWeekDayFromName(token
, Name_Full
| Name_Abbr
);
3889 if ( wday
!= Inv_WeekDay
)
3899 else // not a valid weekday name
3902 static const wxChar
*ordinals
[] =
3904 wxTRANSLATE("first"),
3905 wxTRANSLATE("second"),
3906 wxTRANSLATE("third"),
3907 wxTRANSLATE("fourth"),
3908 wxTRANSLATE("fifth"),
3909 wxTRANSLATE("sixth"),
3910 wxTRANSLATE("seventh"),
3911 wxTRANSLATE("eighth"),
3912 wxTRANSLATE("ninth"),
3913 wxTRANSLATE("tenth"),
3914 wxTRANSLATE("eleventh"),
3915 wxTRANSLATE("twelfth"),
3916 wxTRANSLATE("thirteenth"),
3917 wxTRANSLATE("fourteenth"),
3918 wxTRANSLATE("fifteenth"),
3919 wxTRANSLATE("sixteenth"),
3920 wxTRANSLATE("seventeenth"),
3921 wxTRANSLATE("eighteenth"),
3922 wxTRANSLATE("nineteenth"),
3923 wxTRANSLATE("twentieth"),
3924 // that's enough - otherwise we'd have problems with
3925 // composite (or not) ordinals
3929 for ( n
= 0; n
< WXSIZEOF(ordinals
); n
++ )
3931 if ( token
.CmpNoCase(ordinals
[n
]) == 0 )
3937 if ( n
== WXSIZEOF(ordinals
) )
3939 // stop here - something unknown
3946 // don't try anything here (as in case of numeric day
3947 // above) - the symbolic day spec should always
3948 // precede the month/year
3954 day
= (wxDateTime_t
)(n
+ 1);
3959 nPosCur
= tok
.GetPosition();
3962 // either no more tokens or the scan was stopped by something we couldn't
3963 // parse - in any case, see if we can construct a date from what we have
3964 if ( !haveDay
&& !haveWDay
)
3966 wxLogDebug(_T("ParseDate: no day, no weekday hence no date."));
3968 return (wxChar
*)NULL
;
3971 if ( haveWDay
&& (haveMon
|| haveYear
|| haveDay
) &&
3972 !(haveDay
&& haveMon
&& haveYear
) )
3974 // without adjectives (which we don't support here) the week day only
3975 // makes sense completely separately or with the full date
3976 // specification (what would "Wed 1999" mean?)
3977 return (wxChar
*)NULL
;
3980 if ( !haveWDay
&& haveYear
&& !(haveDay
&& haveMon
) )
3982 // may be we have month and day instead of day and year?
3983 if ( haveDay
&& !haveMon
)
3987 // exchange day and month
3988 mon
= (wxDateTime::Month
)(day
- 1);
3990 // we're in the current year then
3991 if ( (year
> 0) && (year
<= (int)GetNumOfDaysInMonth(Inv_Year
, mon
)) )
3993 day
= (wxDateTime_t
)year
;
3998 //else: no, can't exchange, leave haveMon == false
4004 // if we give the year, month and day must be given too
4005 wxLogDebug(_T("ParseDate: day and month should be specified if year is."));
4007 return (wxChar
*)NULL
;
4013 mon
= GetCurrentMonth();
4018 year
= GetCurrentYear();
4023 Set(day
, mon
, year
);
4027 // check that it is really the same
4028 if ( GetWeekDay() != wday
)
4030 // inconsistency detected
4031 wxLogDebug(_T("ParseDate: inconsistent day/weekday."));
4033 return (wxChar
*)NULL
;
4041 SetToWeekDayInSameWeek(wday
);
4044 // return the pointer to the first unparsed char
4046 if ( nPosCur
&& wxStrchr(dateDelimiters
, *(p
- 1)) )
4048 // if we couldn't parse the token after the delimiter, put back the
4049 // delimiter as well
4056 const wxChar
*wxDateTime::ParseTime(const wxChar
*time
)
4058 wxCHECK_MSG( time
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
4060 // first try some extra things
4067 { wxTRANSLATE("noon"), 12 },
4068 { wxTRANSLATE("midnight"), 00 },
4072 for ( size_t n
= 0; n
< WXSIZEOF(stdTimes
); n
++ )
4074 wxString timeString
= wxGetTranslation(stdTimes
[n
].name
);
4075 size_t len
= timeString
.length();
4076 if ( timeString
.CmpNoCase(wxString(time
, len
)) == 0 )
4078 // casts required by DigitalMars
4079 Set(stdTimes
[n
].hour
, wxDateTime_t(0), wxDateTime_t(0));
4085 // try all time formats we may think about in the order from longest to
4088 // 12hour with AM/PM?
4089 const wxChar
*result
= ParseFormat(time
, _T("%I:%M:%S %p"));
4093 // normally, it's the same, but why not try it?
4094 result
= ParseFormat(time
, _T("%H:%M:%S"));
4099 // 12hour with AM/PM but without seconds?
4100 result
= ParseFormat(time
, _T("%I:%M %p"));
4106 result
= ParseFormat(time
, _T("%H:%M"));
4111 // just the hour and AM/PM?
4112 result
= ParseFormat(time
, _T("%I %p"));
4118 result
= ParseFormat(time
, _T("%H"));
4123 // parse the standard format: normally it is one of the formats above
4124 // but it may be set to something completely different by the user
4125 result
= ParseFormat(time
, _T("%X"));
4128 // TODO: parse timezones
4133 // ----------------------------------------------------------------------------
4134 // Workdays and holidays support
4135 // ----------------------------------------------------------------------------
4137 bool wxDateTime::IsWorkDay(Country
WXUNUSED(country
)) const
4139 return !wxDateTimeHolidayAuthority::IsHoliday(*this);
4142 // ============================================================================
4144 // ============================================================================
4146 wxDateSpan WXDLLIMPEXP_BASE
operator*(int n
, const wxDateSpan
& ds
)
4149 return ds1
.Multiply(n
);
4152 // ============================================================================
4154 // ============================================================================
4156 wxTimeSpan WXDLLIMPEXP_BASE
operator*(int n
, const wxTimeSpan
& ts
)
4158 return wxTimeSpan(ts
).Multiply(n
);
4161 // this enum is only used in wxTimeSpan::Format() below but we can't declare
4162 // it locally to the method as it provokes an internal compiler error in egcs
4163 // 2.91.60 when building with -O2
4174 // not all strftime(3) format specifiers make sense here because, for example,
4175 // a time span doesn't have a year nor a timezone
4177 // Here are the ones which are supported (all of them are supported by strftime
4179 // %H hour in 24 hour format
4180 // %M minute (00 - 59)
4181 // %S second (00 - 59)
4184 // Also, for MFC CTimeSpan compatibility, we support
4185 // %D number of days
4187 // And, to be better than MFC :-), we also have
4188 // %E number of wEeks
4189 // %l milliseconds (000 - 999)
4190 wxString
wxTimeSpan::Format(const wxChar
*format
) const
4192 wxCHECK_MSG( format
, wxEmptyString
, _T("NULL format in wxTimeSpan::Format") );
4195 str
.Alloc(wxStrlen(format
));
4197 // Suppose we have wxTimeSpan ts(1 /* hour */, 2 /* min */, 3 /* sec */)
4199 // Then, of course, ts.Format("%H:%M:%S") must return "01:02:03", but the
4200 // question is what should ts.Format("%S") do? The code here returns "3273"
4201 // in this case (i.e. the total number of seconds, not just seconds % 60)
4202 // because, for me, this call means "give me entire time interval in
4203 // seconds" and not "give me the seconds part of the time interval"
4205 // If we agree that it should behave like this, it is clear that the
4206 // interpretation of each format specifier depends on the presence of the
4207 // other format specs in the string: if there was "%H" before "%M", we
4208 // should use GetMinutes() % 60, otherwise just GetMinutes() &c
4210 // we remember the most important unit found so far
4211 TimeSpanPart partBiggest
= Part_MSec
;
4213 for ( const wxChar
*pch
= format
; *pch
; pch
++ )
4217 if ( ch
== _T('%') )
4219 // the start of the format specification of the printf() below
4220 wxString fmtPrefix
= _T('%');
4225 ch
= *++pch
; // get the format spec char
4229 wxFAIL_MSG( _T("invalid format character") );
4235 // skip the part below switch
4240 if ( partBiggest
< Part_Day
)
4246 partBiggest
= Part_Day
;
4251 partBiggest
= Part_Week
;
4257 if ( partBiggest
< Part_Hour
)
4263 partBiggest
= Part_Hour
;
4266 fmtPrefix
+= _T("02");
4270 n
= GetMilliseconds().ToLong();
4271 if ( partBiggest
< Part_MSec
)
4275 //else: no need to reset partBiggest to Part_MSec, it is
4276 // the least significant one anyhow
4278 fmtPrefix
+= _T("03");
4283 if ( partBiggest
< Part_Min
)
4289 partBiggest
= Part_Min
;
4292 fmtPrefix
+= _T("02");
4296 n
= GetSeconds().ToLong();
4297 if ( partBiggest
< Part_Sec
)
4303 partBiggest
= Part_Sec
;
4306 fmtPrefix
+= _T("02");
4310 str
+= wxString::Format(fmtPrefix
+ _T("ld"), n
);
4314 // normal character, just copy
4322 // ============================================================================
4323 // wxDateTimeHolidayAuthority and related classes
4324 // ============================================================================
4326 #include "wx/arrimpl.cpp"
4328 WX_DEFINE_OBJARRAY(wxDateTimeArray
)
4330 static int wxCMPFUNC_CONV
4331 wxDateTimeCompareFunc(wxDateTime
**first
, wxDateTime
**second
)
4333 wxDateTime dt1
= **first
,
4336 return dt1
== dt2
? 0 : dt1
< dt2
? -1 : +1;
4339 // ----------------------------------------------------------------------------
4340 // wxDateTimeHolidayAuthority
4341 // ----------------------------------------------------------------------------
4343 wxHolidayAuthoritiesArray
wxDateTimeHolidayAuthority::ms_authorities
;
4346 bool wxDateTimeHolidayAuthority::IsHoliday(const wxDateTime
& dt
)
4348 size_t count
= ms_authorities
.size();
4349 for ( size_t n
= 0; n
< count
; n
++ )
4351 if ( ms_authorities
[n
]->DoIsHoliday(dt
) )
4362 wxDateTimeHolidayAuthority::GetHolidaysInRange(const wxDateTime
& dtStart
,
4363 const wxDateTime
& dtEnd
,
4364 wxDateTimeArray
& holidays
)
4366 wxDateTimeArray hol
;
4370 const size_t countAuth
= ms_authorities
.size();
4371 for ( size_t nAuth
= 0; nAuth
< countAuth
; nAuth
++ )
4373 ms_authorities
[nAuth
]->DoGetHolidaysInRange(dtStart
, dtEnd
, hol
);
4375 WX_APPEND_ARRAY(holidays
, hol
);
4378 holidays
.Sort(wxDateTimeCompareFunc
);
4380 return holidays
.size();
4384 void wxDateTimeHolidayAuthority::ClearAllAuthorities()
4386 WX_CLEAR_ARRAY(ms_authorities
);
4390 void wxDateTimeHolidayAuthority::AddAuthority(wxDateTimeHolidayAuthority
*auth
)
4392 ms_authorities
.push_back(auth
);
4395 wxDateTimeHolidayAuthority::~wxDateTimeHolidayAuthority()
4397 // required here for Darwin
4400 // ----------------------------------------------------------------------------
4401 // wxDateTimeWorkDays
4402 // ----------------------------------------------------------------------------
4404 bool wxDateTimeWorkDays::DoIsHoliday(const wxDateTime
& dt
) const
4406 wxDateTime::WeekDay wd
= dt
.GetWeekDay();
4408 return (wd
== wxDateTime::Sun
) || (wd
== wxDateTime::Sat
);
4411 size_t wxDateTimeWorkDays::DoGetHolidaysInRange(const wxDateTime
& dtStart
,
4412 const wxDateTime
& dtEnd
,
4413 wxDateTimeArray
& holidays
) const
4415 if ( dtStart
> dtEnd
)
4417 wxFAIL_MSG( _T("invalid date range in GetHolidaysInRange") );
4424 // instead of checking all days, start with the first Sat after dtStart and
4425 // end with the last Sun before dtEnd
4426 wxDateTime dtSatFirst
= dtStart
.GetNextWeekDay(wxDateTime::Sat
),
4427 dtSatLast
= dtEnd
.GetPrevWeekDay(wxDateTime::Sat
),
4428 dtSunFirst
= dtStart
.GetNextWeekDay(wxDateTime::Sun
),
4429 dtSunLast
= dtEnd
.GetPrevWeekDay(wxDateTime::Sun
),
4432 for ( dt
= dtSatFirst
; dt
<= dtSatLast
; dt
+= wxDateSpan::Week() )
4437 for ( dt
= dtSunFirst
; dt
<= dtSunLast
; dt
+= wxDateSpan::Week() )
4442 return holidays
.GetCount();
4445 // ============================================================================
4446 // other helper functions
4447 // ============================================================================
4449 // ----------------------------------------------------------------------------
4450 // iteration helpers: can be used to write a for loop over enum variable like
4452 // for ( m = wxDateTime::Jan; m < wxDateTime::Inv_Month; wxNextMonth(m) )
4453 // ----------------------------------------------------------------------------
4455 WXDLLIMPEXP_BASE
void wxNextMonth(wxDateTime::Month
& m
)
4457 wxASSERT_MSG( m
< wxDateTime::Inv_Month
, _T("invalid month") );
4459 // no wrapping or the for loop above would never end!
4460 m
= (wxDateTime::Month
)(m
+ 1);
4463 WXDLLIMPEXP_BASE
void wxPrevMonth(wxDateTime::Month
& m
)
4465 wxASSERT_MSG( m
< wxDateTime::Inv_Month
, _T("invalid month") );
4467 m
= m
== wxDateTime::Jan
? wxDateTime::Inv_Month
4468 : (wxDateTime::Month
)(m
- 1);
4471 WXDLLIMPEXP_BASE
void wxNextWDay(wxDateTime::WeekDay
& wd
)
4473 wxASSERT_MSG( wd
< wxDateTime::Inv_WeekDay
, _T("invalid week day") );
4475 // no wrapping or the for loop above would never end!
4476 wd
= (wxDateTime::WeekDay
)(wd
+ 1);
4479 WXDLLIMPEXP_BASE
void wxPrevWDay(wxDateTime::WeekDay
& wd
)
4481 wxASSERT_MSG( wd
< wxDateTime::Inv_WeekDay
, _T("invalid week day") );
4483 wd
= wd
== wxDateTime::Sun
? wxDateTime::Inv_WeekDay
4484 : (wxDateTime::WeekDay
)(wd
- 1);
4487 #endif // wxUSE_DATETIME