1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/datetime.cpp
3 // Purpose: implementation of time/date related classes
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // parts of code taken from sndcal library by Scott E. Lee:
11 // Copyright 1993-1995, Scott E. Lee, all rights reserved.
12 // Permission granted to use, copy, modify, distribute and sell
13 // so long as the above copyright and this permission statement
14 // are retained in all copies.
16 // Licence: wxWindows licence
17 ///////////////////////////////////////////////////////////////////////////////
20 * Implementation notes:
22 * 1. the time is stored as a 64bit integer containing the signed number of
23 * milliseconds since Jan 1. 1970 (the Unix Epoch) - so it is always
26 * 2. the range is thus something about 580 million years, but due to current
27 * algorithms limitations, only dates from Nov 24, 4714BC are handled
29 * 3. standard ANSI C functions are used to do time calculations whenever
30 * possible, i.e. when the date is in the range Jan 1, 1970 to 2038
32 * 4. otherwise, the calculations are done by converting the date to/from JDN
33 * first (the range limitation mentioned above comes from here: the
34 * algorithm used by Scott E. Lee's code only works for positive JDNs, more
37 * 5. the object constructed for the given DD-MM-YYYY HH:MM:SS corresponds to
38 * this moment in local time and may be converted to the object
39 * corresponding to the same date/time in another time zone by using
42 * 6. the conversions to the current (or any other) timezone are done when the
43 * internal time representation is converted to the broken-down one in
47 // ============================================================================
49 // ============================================================================
51 // ----------------------------------------------------------------------------
53 // ----------------------------------------------------------------------------
55 // For compilers that support precompilation, includes "wx.h".
56 #include "wx/wxprec.h"
62 #if !defined(wxUSE_DATETIME) || wxUSE_DATETIME
66 #include "wx/msw/wrapwin.h"
68 #include "wx/string.h"
71 #include "wx/stopwatch.h" // for wxGetLocalTimeMillis()
72 #include "wx/module.h"
76 #include "wx/thread.h"
77 #include "wx/tokenzr.h"
88 #include "wx/datetime.h"
90 const long wxDateTime
::TIME_T_FACTOR
= 1000l;
92 #if wxUSE_EXTENDED_RTTI
94 template<> void wxStringReadValue(const wxString
&s
, wxDateTime
&data
)
96 data
.ParseFormat(s
,wxT("%Y-%m-%d %H:%M:%S")) ;
99 template<> void wxStringWriteValue(wxString
&s
, const wxDateTime
&data
)
101 s
= data
.Format(wxT("%Y-%m-%d %H:%M:%S")) ;
104 wxCUSTOM_TYPE_INFO(wxDateTime
, wxToStringConverter
<wxDateTime
> , wxFromStringConverter
<wxDateTime
>)
109 // ----------------------------------------------------------------------------
110 // conditional compilation
111 // ----------------------------------------------------------------------------
113 #if defined(HAVE_STRPTIME) && defined(__GLIBC__) && \
114 ((__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0))
115 // glibc 2.0.7 strptime() is broken - the following snippet causes it to
116 // crash (instead of just failing):
118 // strncpy(buf, "Tue Dec 21 20:25:40 1999", 128);
119 // strptime(buf, "%x", &tm);
123 #endif // broken strptime()
125 #if defined(HAVE_STRPTIME) && defined(__DARWIN__) && defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
126 // configure detects strptime as linkable because it's in the OS X
127 // System library but MSL headers don't declare it.
129 // char *strptime(const char *, const char *, struct tm *);
130 // However, we DON'T want to just provide it here because we would
131 // crash and/or overwrite data when strptime from OS X tries
132 // to fill in MW's struct tm which is two fields shorter (no TZ stuff)
133 // So for now let's just say we don't have strptime
137 #if defined(__MWERKS__) && wxUSE_UNICODE
141 // define a special symbol for VC8 instead of writing tests for 1400 repeatedly
143 #if __VISUALC__ >= 1400
148 #if !defined(WX_TIMEZONE) && !defined(WX_GMTOFF_IN_TM)
149 #if defined(__WXPALMOS__)
150 #define WX_GMTOFF_IN_TM
151 #elif defined(__BORLANDC__) || defined(__MINGW32__) || defined(__VISAGECPP__)
152 #define WX_TIMEZONE _timezone
153 #elif defined(__MWERKS__)
154 long wxmw_timezone
= 28800;
155 #define WX_TIMEZONE wxmw_timezone
156 #elif defined(__DJGPP__) || defined(__WINE__)
157 #include <sys/timeb.h>
159 static long wxGetTimeZone()
161 static long timezone
= MAXLONG
; // invalid timezone
162 if (timezone
== MAXLONG
)
166 timezone
= tb
.timezone
;
170 #define WX_TIMEZONE wxGetTimeZone()
171 #elif defined(__DARWIN__)
172 #define WX_GMTOFF_IN_TM
173 #elif defined(__WXWINCE__) && defined(__VISUALC8__)
174 // _timezone is not present in dynamic run-time library
176 // Solution (1): use the function equivalent of _timezone
177 static long wxGetTimeZone()
179 static long s_Timezone
= MAXLONG
; // invalid timezone
180 if (s_Timezone
== MAXLONG
)
184 s_Timezone
= (long) t
;
188 #define WX_TIMEZONE wxGetTimeZone()
190 // Solution (2): using GetTimeZoneInformation
191 static long wxGetTimeZone()
193 static long timezone
= MAXLONG
; // invalid timezone
194 if (timezone
== MAXLONG
)
196 TIME_ZONE_INFORMATION tzi
;
197 ::GetTimeZoneInformation(&tzi
);
202 #define WX_TIMEZONE wxGetTimeZone()
204 // Old method using _timezone: this symbol doesn't exist in the dynamic run-time library (i.e. using /MD)
205 #define WX_TIMEZONE _timezone
207 #else // unknown platform - try timezone
208 #define WX_TIMEZONE timezone
210 #endif // !WX_TIMEZONE && !WX_GMTOFF_IN_TM
212 // everyone has strftime except Win CE unless VC8 is used
213 #if !defined(__WXWINCE__) || defined(__VISUALC8__)
214 #define HAVE_STRFTIME
217 // NB: VC8 safe time functions could/should be used for wxMSW as well probably
218 #if defined(__WXWINCE__) && defined(__VISUALC8__)
220 struct tm
*wxLocaltime_r(const time_t *t
, struct tm
* tm
)
223 return _localtime64_s(tm
, &t64
) == 0 ? tm
: NULL
;
226 struct tm
*wxGmtime_r(const time_t* t
, struct tm
* tm
)
229 return _gmtime64_s(tm
, &t64
) == 0 ? tm
: NULL
;
232 #else // !wxWinCE with VC8
234 #if (!defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)) && wxUSE_THREADS && !defined(__WINDOWS__)
235 static wxMutex timeLock
;
238 #ifndef HAVE_LOCALTIME_R
239 struct tm
*wxLocaltime_r(const time_t* ticks
, struct tm
* temp
)
241 #if wxUSE_THREADS && !defined(__WINDOWS__)
242 // No need to waste time with a mutex on windows since it's using
243 // thread local storage for localtime anyway.
244 wxMutexLocker
locker(timeLock
);
247 // Borland CRT crashes when passed 0 ticks for some reason, see SF bug 1704438
253 const tm
* const t
= localtime(ticks
);
257 memcpy(temp
, t
, sizeof(struct tm
));
260 #endif // !HAVE_LOCALTIME_R
262 #ifndef HAVE_GMTIME_R
263 struct tm
*wxGmtime_r(const time_t* ticks
, struct tm
* temp
)
265 #if wxUSE_THREADS && !defined(__WINDOWS__)
266 // No need to waste time with a mutex on windows since it's
267 // using thread local storage for gmtime anyway.
268 wxMutexLocker
locker(timeLock
);
276 const tm
* const t
= gmtime(ticks
);
280 memcpy(temp
, gmtime(ticks
), sizeof(struct tm
));
283 #endif // !HAVE_GMTIME_R
285 #endif // wxWinCE with VC8/other platforms
287 // ----------------------------------------------------------------------------
289 // ----------------------------------------------------------------------------
291 // debugging helper: just a convenient replacement of wxCHECK()
292 #define wxDATETIME_CHECK(expr, msg) \
293 wxCHECK2_MSG(expr, *this = wxInvalidDateTime; return *this, msg)
295 // ----------------------------------------------------------------------------
297 // ----------------------------------------------------------------------------
299 class wxDateTimeHolidaysModule
: public wxModule
302 virtual bool OnInit()
304 wxDateTimeHolidayAuthority
::AddAuthority(new wxDateTimeWorkDays
);
309 virtual void OnExit()
311 wxDateTimeHolidayAuthority
::ClearAllAuthorities();
312 wxDateTimeHolidayAuthority
::ms_authorities
.clear();
316 DECLARE_DYNAMIC_CLASS(wxDateTimeHolidaysModule
)
319 IMPLEMENT_DYNAMIC_CLASS(wxDateTimeHolidaysModule
, wxModule
)
321 // ----------------------------------------------------------------------------
323 // ----------------------------------------------------------------------------
326 static const int MONTHS_IN_YEAR
= 12;
328 static const int SEC_PER_MIN
= 60;
330 static const int MIN_PER_HOUR
= 60;
332 static const int HOURS_PER_DAY
= 24;
334 static const long SECONDS_PER_DAY
= 86400l;
336 static const int DAYS_PER_WEEK
= 7;
338 static const long MILLISECONDS_PER_DAY
= 86400000l;
340 // this is the integral part of JDN of the midnight of Jan 1, 1970
341 // (i.e. JDN(Jan 1, 1970) = 2440587.5)
342 static const long EPOCH_JDN
= 2440587l;
344 // used only in asserts
346 // the date of JDN -0.5 (as we don't work with fractional parts, this is the
347 // reference date for us) is Nov 24, 4714BC
348 static const int JDN_0_YEAR
= -4713;
349 static const int JDN_0_MONTH
= wxDateTime
::Nov
;
350 static const int JDN_0_DAY
= 24;
351 #endif // __WXDEBUG__
353 // the constants used for JDN calculations
354 static const long JDN_OFFSET
= 32046l;
355 static const long DAYS_PER_5_MONTHS
= 153l;
356 static const long DAYS_PER_4_YEARS
= 1461l;
357 static const long DAYS_PER_400_YEARS
= 146097l;
359 // this array contains the cumulated number of days in all previous months for
360 // normal and leap years
361 static const wxDateTime
::wxDateTime_t gs_cumulatedDays
[2][MONTHS_IN_YEAR
] =
363 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
364 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
367 // ----------------------------------------------------------------------------
369 // ----------------------------------------------------------------------------
371 const wxChar
* wxDefaultDateTimeFormat
= wxT("%c");
372 const wxChar
* wxDefaultTimeSpanFormat
= wxT("%H:%M:%S");
374 // in the fine tradition of ANSI C we use our equivalent of (time_t)-1 to
375 // indicate an invalid wxDateTime object
376 const wxDateTime wxDefaultDateTime
;
378 wxDateTime
::Country wxDateTime
::ms_country
= wxDateTime
::Country_Unknown
;
380 // ----------------------------------------------------------------------------
382 // ----------------------------------------------------------------------------
384 // debugger helper: shows what the date really is
386 extern const wxChar
*wxDumpDate(const wxDateTime
* dt
)
388 static wxChar buf
[128];
390 wxStrcpy(buf
, dt
->Format(_T("%Y-%m-%d (%a) %H:%M:%S")));
396 // get the number of days in the given month of the given year
398 wxDateTime
::wxDateTime_t
GetNumOfDaysInMonth(int year
, wxDateTime
::Month month
)
400 // the number of days in month in Julian/Gregorian calendar: the first line
401 // is for normal years, the second one is for the leap ones
402 static wxDateTime
::wxDateTime_t daysInMonth
[2][MONTHS_IN_YEAR
] =
404 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
405 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
408 return daysInMonth
[wxDateTime
::IsLeapYear(year
)][month
];
411 // returns the time zone in the C sense, i.e. the difference UTC - local
413 static int GetTimeZone()
415 // set to true when the timezone is set
416 static bool s_timezoneSet
= false;
417 static long gmtoffset
= LONG_MAX
; // invalid timezone
419 // ensure that the timezone variable is set by calling wxLocaltime_r
420 if ( !s_timezoneSet
)
422 // just call wxLocaltime_r() instead of figuring out whether this
423 // system supports tzset(), _tzset() or something else
427 wxLocaltime_r(&t
, &tm
);
428 s_timezoneSet
= true;
430 #ifdef WX_GMTOFF_IN_TM
431 // note that GMT offset is the opposite of time zone and so to return
432 // consistent results in both WX_GMTOFF_IN_TM and !WX_GMTOFF_IN_TM
433 // cases we have to negate it
434 gmtoffset
= -tm
.tm_gmtoff
;
435 #else // !WX_GMTOFF_IN_TM
436 gmtoffset
= WX_TIMEZONE
;
437 #endif // WX_GMTOFF_IN_TM/!WX_GMTOFF_IN_TM
440 return (int)gmtoffset
;
443 // return the integral part of the JDN for the midnight of the given date (to
444 // get the real JDN you need to add 0.5, this is, in fact, JDN of the
445 // noon of the previous day)
446 static long GetTruncatedJDN(wxDateTime
::wxDateTime_t day
,
447 wxDateTime
::Month mon
,
450 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
452 // check the date validity
454 (year
> JDN_0_YEAR
) ||
455 ((year
== JDN_0_YEAR
) && (mon
> JDN_0_MONTH
)) ||
456 ((year
== JDN_0_YEAR
) && (mon
== JDN_0_MONTH
) && (day
>= JDN_0_DAY
)),
457 _T("date out of range - can't convert to JDN")
460 // make the year positive to avoid problems with negative numbers division
463 // months are counted from March here
465 if ( mon
>= wxDateTime
::Mar
)
475 // now we can simply add all the contributions together
476 return ((year
/ 100) * DAYS_PER_400_YEARS
) / 4
477 + ((year
% 100) * DAYS_PER_4_YEARS
) / 4
478 + (month
* DAYS_PER_5_MONTHS
+ 2) / 5
485 // this function is a wrapper around strftime(3) adding error checking
486 static wxString
CallStrftime(const wxString
& format
, const tm
* tm
)
489 // Create temp wxString here to work around mingw/cygwin bug 1046059
490 // http://sourceforge.net/tracker/?func=detail&atid=102435&aid=1046059&group_id=2435
493 if ( !wxStrftime(buf
, WXSIZEOF(buf
), format
, tm
) )
495 // buffer is too small?
496 wxFAIL_MSG(_T("strftime() failed"));
503 #endif // HAVE_STRFTIME
507 #if wxUSE_UNIX && !defined(HAVE_STRPTIME_DECL)
508 // configure detected that we had strptime() but not its declaration,
509 // provide it ourselves
510 extern "C" char *strptime(const char *, const char *, struct tm
*);
513 // Unicode-friendly strptime() wrapper
514 static const wxChar
*
515 CallStrptime(const wxChar
*input
, const char *fmt
, tm
*tm
)
517 // the problem here is that strptime() returns pointer into the string we
518 // passed to it while we're really interested in the pointer into the
519 // original, Unicode, string so we try to transform the pointer back
521 wxCharBuffer
inputMB(wxConvertWX2MB(input
));
523 const char * const inputMB
= input
;
524 #endif // Unicode/Ascii
526 const char *result
= strptime(inputMB
, fmt
, tm
);
531 // FIXME: this is wrong in presence of surrogates &c
532 return input
+ (result
- inputMB
.data());
535 #endif // Unicode/Ascii
538 #endif // HAVE_STRPTIME
540 // if year and/or month have invalid values, replace them with the current ones
541 static void ReplaceDefaultYearMonthWithCurrent(int *year
,
542 wxDateTime
::Month
*month
)
544 struct tm
*tmNow
= NULL
;
547 if ( *year
== wxDateTime
::Inv_Year
)
549 tmNow
= wxDateTime
::GetTmNow(&tmstruct
);
551 *year
= 1900 + tmNow
->tm_year
;
554 if ( *month
== wxDateTime
::Inv_Month
)
557 tmNow
= wxDateTime
::GetTmNow(&tmstruct
);
559 *month
= (wxDateTime
::Month
)tmNow
->tm_mon
;
563 // fll the struct tm with default values
564 static void InitTm(struct tm
& tm
)
566 // struct tm may have etxra fields (undocumented and with unportable
567 // names) which, nevertheless, must be set to 0
568 memset(&tm
, 0, sizeof(struct tm
));
570 tm
.tm_mday
= 1; // mday 0 is invalid
571 tm
.tm_year
= 76; // any valid year
572 tm
.tm_isdst
= -1; // auto determine
578 // return the month if the string is a month name or Inv_Month otherwise
579 static wxDateTime
::Month
GetMonthFromName(const wxString
& name
, int flags
)
581 wxDateTime
::Month mon
;
582 for ( mon
= wxDateTime
::Jan
; mon
< wxDateTime
::Inv_Month
; wxNextMonth(mon
) )
584 // case-insensitive comparison either one of or with both abbreviated
586 if ( flags
& wxDateTime
::Name_Full
)
588 if ( name
.CmpNoCase(wxDateTime
::
589 GetMonthName(mon
, wxDateTime
::Name_Full
)) == 0 )
595 if ( flags
& wxDateTime
::Name_Abbr
)
597 if ( name
.CmpNoCase(wxDateTime
::
598 GetMonthName(mon
, wxDateTime
::Name_Abbr
)) == 0 )
608 // return the weekday if the string is a weekday name or Inv_WeekDay otherwise
609 static wxDateTime
::WeekDay
GetWeekDayFromName(const wxString
& name
, int flags
)
611 wxDateTime
::WeekDay wd
;
612 for ( wd
= wxDateTime
::Sun
; wd
< wxDateTime
::Inv_WeekDay
; wxNextWDay(wd
) )
614 // case-insensitive comparison either one of or with both abbreviated
616 if ( flags
& wxDateTime
::Name_Full
)
618 if ( name
.CmpNoCase(wxDateTime
::
619 GetWeekDayName(wd
, wxDateTime
::Name_Full
)) == 0 )
625 if ( flags
& wxDateTime
::Name_Abbr
)
627 if ( name
.CmpNoCase(wxDateTime
::
628 GetWeekDayName(wd
, wxDateTime
::Name_Abbr
)) == 0 )
639 struct tm
*wxDateTime
::GetTmNow(struct tm
*tmstruct
)
641 time_t t
= GetTimeNow();
642 return wxLocaltime_r(&t
, tmstruct
);
645 // scans all digits (but no more than len) and returns the resulting number
646 static bool GetNumericToken(size_t len
, const wxChar
*& p
, unsigned long *number
)
650 while ( wxIsdigit(*p
) )
654 if ( len
&& ++n
> len
)
658 return !s
.empty() && s
.ToULong(number
);
661 // scans all alphabetic characters and returns the resulting string
662 static wxString
GetAlphaToken(const wxChar
*& p
)
665 while ( wxIsalpha(*p
) )
673 // ============================================================================
674 // implementation of wxDateTime
675 // ============================================================================
677 // ----------------------------------------------------------------------------
679 // ----------------------------------------------------------------------------
683 year
= (wxDateTime_t
)wxDateTime
::Inv_Year
;
684 mon
= wxDateTime
::Inv_Month
;
686 hour
= min
= sec
= msec
= 0;
687 wday
= wxDateTime
::Inv_WeekDay
;
690 wxDateTime
::Tm
::Tm(const struct tm
& tm
, const TimeZone
& tz
)
694 sec
= (wxDateTime
::wxDateTime_t
)tm
.tm_sec
;
695 min
= (wxDateTime
::wxDateTime_t
)tm
.tm_min
;
696 hour
= (wxDateTime
::wxDateTime_t
)tm
.tm_hour
;
697 mday
= (wxDateTime
::wxDateTime_t
)tm
.tm_mday
;
698 mon
= (wxDateTime
::Month
)tm
.tm_mon
;
699 year
= 1900 + tm
.tm_year
;
700 wday
= (wxDateTime
::wxDateTime_t
)tm
.tm_wday
;
701 yday
= (wxDateTime
::wxDateTime_t
)tm
.tm_yday
;
704 bool wxDateTime
::Tm
::IsValid() const
706 // we allow for the leap seconds, although we don't use them (yet)
707 return (year
!= wxDateTime
::Inv_Year
) && (mon
!= wxDateTime
::Inv_Month
) &&
708 (mday
<= GetNumOfDaysInMonth(year
, mon
)) &&
709 (hour
< 24) && (min
< 60) && (sec
< 62) && (msec
< 1000);
712 void wxDateTime
::Tm
::ComputeWeekDay()
714 // compute the week day from day/month/year: we use the dumbest algorithm
715 // possible: just compute our JDN and then use the (simple to derive)
716 // formula: weekday = (JDN + 1.5) % 7
717 wday
= (wxDateTime
::wxDateTime_t
)((GetTruncatedJDN(mday
, mon
, year
) + 2) % 7);
720 void wxDateTime
::Tm
::AddMonths(int monDiff
)
722 // normalize the months field
723 while ( monDiff
< -mon
)
727 monDiff
+= MONTHS_IN_YEAR
;
730 while ( monDiff
+ mon
>= MONTHS_IN_YEAR
)
734 monDiff
-= MONTHS_IN_YEAR
;
737 mon
= (wxDateTime
::Month
)(mon
+ monDiff
);
739 wxASSERT_MSG( mon
>= 0 && mon
< MONTHS_IN_YEAR
, _T("logic error") );
741 // NB: we don't check here that the resulting date is valid, this function
742 // is private and the caller must check it if needed
745 void wxDateTime
::Tm
::AddDays(int dayDiff
)
747 // normalize the days field
748 while ( dayDiff
+ mday
< 1 )
752 dayDiff
+= GetNumOfDaysInMonth(year
, mon
);
755 mday
= (wxDateTime
::wxDateTime_t
)( mday
+ dayDiff
);
756 while ( mday
> GetNumOfDaysInMonth(year
, mon
) )
758 mday
-= GetNumOfDaysInMonth(year
, mon
);
763 wxASSERT_MSG( mday
> 0 && mday
<= GetNumOfDaysInMonth(year
, mon
),
767 // ----------------------------------------------------------------------------
769 // ----------------------------------------------------------------------------
771 wxDateTime
::TimeZone
::TimeZone(wxDateTime
::TZ tz
)
775 case wxDateTime
::Local
:
776 // get the offset from C RTL: it returns the difference GMT-local
777 // while we want to have the offset _from_ GMT, hence the '-'
778 m_offset
= -GetTimeZone();
781 case wxDateTime
::GMT_12
:
782 case wxDateTime
::GMT_11
:
783 case wxDateTime
::GMT_10
:
784 case wxDateTime
::GMT_9
:
785 case wxDateTime
::GMT_8
:
786 case wxDateTime
::GMT_7
:
787 case wxDateTime
::GMT_6
:
788 case wxDateTime
::GMT_5
:
789 case wxDateTime
::GMT_4
:
790 case wxDateTime
::GMT_3
:
791 case wxDateTime
::GMT_2
:
792 case wxDateTime
::GMT_1
:
793 m_offset
= -3600*(wxDateTime
::GMT0
- tz
);
796 case wxDateTime
::GMT0
:
797 case wxDateTime
::GMT1
:
798 case wxDateTime
::GMT2
:
799 case wxDateTime
::GMT3
:
800 case wxDateTime
::GMT4
:
801 case wxDateTime
::GMT5
:
802 case wxDateTime
::GMT6
:
803 case wxDateTime
::GMT7
:
804 case wxDateTime
::GMT8
:
805 case wxDateTime
::GMT9
:
806 case wxDateTime
::GMT10
:
807 case wxDateTime
::GMT11
:
808 case wxDateTime
::GMT12
:
809 case wxDateTime
::GMT13
:
810 m_offset
= 3600*(tz
- wxDateTime
::GMT0
);
813 case wxDateTime
::A_CST
:
814 // Central Standard Time in use in Australia = UTC + 9.5
815 m_offset
= 60l*(9*MIN_PER_HOUR
+ MIN_PER_HOUR
/2);
819 wxFAIL_MSG( _T("unknown time zone") );
823 // ----------------------------------------------------------------------------
825 // ----------------------------------------------------------------------------
828 bool wxDateTime
::IsLeapYear(int year
, wxDateTime
::Calendar cal
)
830 if ( year
== Inv_Year
)
831 year
= GetCurrentYear();
833 if ( cal
== Gregorian
)
835 // in Gregorian calendar leap years are those divisible by 4 except
836 // those divisible by 100 unless they're also divisible by 400
837 // (in some countries, like Russia and Greece, additional corrections
838 // exist, but they won't manifest themselves until 2700)
839 return (year
% 4 == 0) && ((year
% 100 != 0) || (year
% 400 == 0));
841 else if ( cal
== Julian
)
843 // in Julian calendar the rule is simpler
844 return year
% 4 == 0;
848 wxFAIL_MSG(_T("unknown calendar"));
855 int wxDateTime
::GetCentury(int year
)
857 return year
> 0 ? year
/ 100 : year
/ 100 - 1;
861 int wxDateTime
::ConvertYearToBC(int year
)
864 return year
> 0 ? year
: year
- 1;
868 int wxDateTime
::GetCurrentYear(wxDateTime
::Calendar cal
)
873 return Now().GetYear();
876 wxFAIL_MSG(_T("TODO"));
880 wxFAIL_MSG(_T("unsupported calendar"));
888 wxDateTime
::Month wxDateTime
::GetCurrentMonth(wxDateTime
::Calendar cal
)
893 return Now().GetMonth();
896 wxFAIL_MSG(_T("TODO"));
900 wxFAIL_MSG(_T("unsupported calendar"));
908 wxDateTime
::wxDateTime_t wxDateTime
::GetNumberOfDays(int year
, Calendar cal
)
910 if ( year
== Inv_Year
)
912 // take the current year if none given
913 year
= GetCurrentYear();
920 return IsLeapYear(year
) ?
366 : 365;
923 wxFAIL_MSG(_T("unsupported calendar"));
931 wxDateTime
::wxDateTime_t wxDateTime
::GetNumberOfDays(wxDateTime
::Month month
,
933 wxDateTime
::Calendar cal
)
935 wxCHECK_MSG( month
< MONTHS_IN_YEAR
, 0, _T("invalid month") );
937 if ( cal
== Gregorian
|| cal
== Julian
)
939 if ( year
== Inv_Year
)
941 // take the current year if none given
942 year
= GetCurrentYear();
945 return GetNumOfDaysInMonth(year
, month
);
949 wxFAIL_MSG(_T("unsupported calendar"));
956 wxString wxDateTime
::GetMonthName(wxDateTime
::Month month
,
957 wxDateTime
::NameFlags flags
)
959 wxCHECK_MSG( month
!= Inv_Month
, wxEmptyString
, _T("invalid month") );
961 // notice that we must set all the fields to avoid confusing libc (GNU one
962 // gets confused to a crash if we don't do this)
967 return CallStrftime(flags
== Name_Abbr ?
_T("%b") : _T("%B"), &tm
);
968 #else // !HAVE_STRFTIME
973 ret
= (flags
== Name_Abbr ?
wxT("Jan"): wxT("January"));
976 ret
= (flags
== Name_Abbr ?
wxT("Feb"): wxT("Febuary"));
979 ret
= (flags
== Name_Abbr ?
wxT("Mar"): wxT("March"));
982 ret
= (flags
== Name_Abbr ?
wxT("Apr"): wxT("April"));
985 ret
= (flags
== Name_Abbr ?
wxT("May"): wxT("May"));
988 ret
= (flags
== Name_Abbr ?
wxT("Jun"): wxT("June"));
991 ret
= (flags
== Name_Abbr ?
wxT("Jul"): wxT("July"));
994 ret
= (flags
== Name_Abbr ?
wxT("Aug"): wxT("August"));
997 ret
= (flags
== Name_Abbr ?
wxT("Sep"): wxT("September"));
1000 ret
= (flags
== Name_Abbr ?
wxT("Oct"): wxT("October"));
1003 ret
= (flags
== Name_Abbr ?
wxT("Nov"): wxT("November"));
1006 ret
= (flags
== Name_Abbr ?
wxT("Dec"): wxT("December"));
1010 #endif // HAVE_STRFTIME/!HAVE_STRFTIME
1014 wxString wxDateTime
::GetWeekDayName(wxDateTime
::WeekDay wday
,
1015 wxDateTime
::NameFlags flags
)
1017 wxCHECK_MSG( wday
!= Inv_WeekDay
, wxEmptyString
, _T("invalid weekday") );
1018 #ifdef HAVE_STRFTIME
1019 // take some arbitrary Sunday (but notice that the day should be such that
1020 // after adding wday to it below we still have a valid date, e.g. don't
1028 // and offset it by the number of days needed to get the correct wday
1031 // call mktime() to normalize it...
1034 // ... and call strftime()
1035 return CallStrftime(flags
== Name_Abbr ?
_T("%a") : _T("%A"), &tm
);
1036 #else // !HAVE_STRFTIME
1041 ret
= (flags
== Name_Abbr ?
wxT("Sun") : wxT("Sunday"));
1044 ret
= (flags
== Name_Abbr ?
wxT("Mon") : wxT("Monday"));
1047 ret
= (flags
== Name_Abbr ?
wxT("Tue") : wxT("Tuesday"));
1050 ret
= (flags
== Name_Abbr ?
wxT("Wed") : wxT("Wednesday"));
1053 ret
= (flags
== Name_Abbr ?
wxT("Thu") : wxT("Thursday"));
1056 ret
= (flags
== Name_Abbr ?
wxT("Fri") : wxT("Friday"));
1059 ret
= (flags
== Name_Abbr ?
wxT("Sat") : wxT("Saturday"));
1063 #endif // HAVE_STRFTIME/!HAVE_STRFTIME
1067 void wxDateTime
::GetAmPmStrings(wxString
*am
, wxString
*pm
)
1072 // @Note: Do not call 'CallStrftime' here! CallStrftime checks the return code
1073 // and causes an assertion failed if the buffer is to small (which is good) - OR -
1074 // if strftime does not return anything because the format string is invalid - OR -
1075 // if there are no 'am' / 'pm' tokens defined for the current locale (which is not good).
1076 // wxDateTime::ParseTime will try several different formats to parse the time.
1077 // As a result, GetAmPmStrings might get called, even if the current locale
1078 // does not define any 'am' / 'pm' tokens. In this case, wxStrftime would
1079 // assert, even though it is a perfectly legal use.
1082 if (wxStrftime(buffer
, sizeof(buffer
)/sizeof(wxChar
), _T("%p"), &tm
) > 0)
1083 *am
= wxString(buffer
);
1090 if (wxStrftime(buffer
, sizeof(buffer
)/sizeof(wxChar
), _T("%p"), &tm
) > 0)
1091 *pm
= wxString(buffer
);
1097 // ----------------------------------------------------------------------------
1098 // Country stuff: date calculations depend on the country (DST, work days,
1099 // ...), so we need to know which rules to follow.
1100 // ----------------------------------------------------------------------------
1103 wxDateTime
::Country wxDateTime
::GetCountry()
1105 // TODO use LOCALE_ICOUNTRY setting under Win32
1107 if ( ms_country
== Country_Unknown
)
1109 // try to guess from the time zone name
1110 time_t t
= time(NULL
);
1112 struct tm
*tm
= wxLocaltime_r(&t
, &tmstruct
);
1114 wxString tz
= CallStrftime(_T("%Z"), tm
);
1115 if ( tz
== _T("WET") || tz
== _T("WEST") )
1119 else if ( tz
== _T("CET") || tz
== _T("CEST") )
1121 ms_country
= Country_EEC
;
1123 else if ( tz
== _T("MSK") || tz
== _T("MSD") )
1125 ms_country
= Russia
;
1127 else if ( tz
== _T("AST") || tz
== _T("ADT") ||
1128 tz
== _T("EST") || tz
== _T("EDT") ||
1129 tz
== _T("CST") || tz
== _T("CDT") ||
1130 tz
== _T("MST") || tz
== _T("MDT") ||
1131 tz
== _T("PST") || tz
== _T("PDT") )
1137 // well, choose a default one
1141 #else // __WXWINCE__
1143 #endif // !__WXWINCE__/__WXWINCE__
1149 void wxDateTime
::SetCountry(wxDateTime
::Country country
)
1151 ms_country
= country
;
1155 bool wxDateTime
::IsWestEuropeanCountry(Country country
)
1157 if ( country
== Country_Default
)
1159 country
= GetCountry();
1162 return (Country_WesternEurope_Start
<= country
) &&
1163 (country
<= Country_WesternEurope_End
);
1166 // ----------------------------------------------------------------------------
1167 // DST calculations: we use 3 different rules for the West European countries,
1168 // USA and for the rest of the world. This is undoubtedly false for many
1169 // countries, but I lack the necessary info (and the time to gather it),
1170 // please add the other rules here!
1171 // ----------------------------------------------------------------------------
1174 bool wxDateTime
::IsDSTApplicable(int year
, Country country
)
1176 if ( year
== Inv_Year
)
1178 // take the current year if none given
1179 year
= GetCurrentYear();
1182 if ( country
== Country_Default
)
1184 country
= GetCountry();
1191 // DST was first observed in the US and UK during WWI, reused
1192 // during WWII and used again since 1966
1193 return year
>= 1966 ||
1194 (year
>= 1942 && year
<= 1945) ||
1195 (year
== 1918 || year
== 1919);
1198 // assume that it started after WWII
1204 wxDateTime wxDateTime
::GetBeginDST(int year
, Country country
)
1206 if ( year
== Inv_Year
)
1208 // take the current year if none given
1209 year
= GetCurrentYear();
1212 if ( country
== Country_Default
)
1214 country
= GetCountry();
1217 if ( !IsDSTApplicable(year
, country
) )
1219 return wxInvalidDateTime
;
1224 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
1226 // DST begins at 1 a.m. GMT on the last Sunday of March
1227 if ( !dt
.SetToLastWeekDay(Sun
, Mar
, year
) )
1230 wxFAIL_MSG( _T("no last Sunday in March?") );
1233 dt
+= wxTimeSpan
::Hours(1);
1235 else switch ( country
)
1242 // don't know for sure - assume it was in effect all year
1247 dt
.Set(1, Jan
, year
);
1251 // DST was installed Feb 2, 1942 by the Congress
1252 dt
.Set(2, Feb
, year
);
1255 // Oil embargo changed the DST period in the US
1257 dt
.Set(6, Jan
, 1974);
1261 dt
.Set(23, Feb
, 1975);
1265 // before 1986, DST begun on the last Sunday of April, but
1266 // in 1986 Reagan changed it to begin at 2 a.m. of the
1267 // first Sunday in April
1270 if ( !dt
.SetToLastWeekDay(Sun
, Apr
, year
) )
1273 wxFAIL_MSG( _T("no first Sunday in April?") );
1278 if ( !dt
.SetToWeekDay(Sun
, 1, Apr
, year
) )
1281 wxFAIL_MSG( _T("no first Sunday in April?") );
1285 dt
+= wxTimeSpan
::Hours(2);
1287 // TODO what about timezone??
1293 // assume Mar 30 as the start of the DST for the rest of the world
1294 // - totally bogus, of course
1295 dt
.Set(30, Mar
, year
);
1302 wxDateTime wxDateTime
::GetEndDST(int year
, Country country
)
1304 if ( year
== Inv_Year
)
1306 // take the current year if none given
1307 year
= GetCurrentYear();
1310 if ( country
== Country_Default
)
1312 country
= GetCountry();
1315 if ( !IsDSTApplicable(year
, country
) )
1317 return wxInvalidDateTime
;
1322 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
1324 // DST ends at 1 a.m. GMT on the last Sunday of October
1325 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1327 // weirder and weirder...
1328 wxFAIL_MSG( _T("no last Sunday in October?") );
1331 dt
+= wxTimeSpan
::Hours(1);
1333 else switch ( country
)
1340 // don't know for sure - assume it was in effect all year
1344 dt
.Set(31, Dec
, year
);
1348 // the time was reset after the end of the WWII
1349 dt
.Set(30, Sep
, year
);
1353 // DST ends at 2 a.m. on the last Sunday of October
1354 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1356 // weirder and weirder...
1357 wxFAIL_MSG( _T("no last Sunday in October?") );
1360 dt
+= wxTimeSpan
::Hours(2);
1362 // TODO what about timezone??
1367 // assume October 26th as the end of the DST - totally bogus too
1368 dt
.Set(26, Oct
, year
);
1374 // ----------------------------------------------------------------------------
1375 // constructors and assignment operators
1376 // ----------------------------------------------------------------------------
1378 // return the current time with ms precision
1379 /* static */ wxDateTime wxDateTime
::UNow()
1381 return wxDateTime(wxGetLocalTimeMillis());
1384 // the values in the tm structure contain the local time
1385 wxDateTime
& wxDateTime
::Set(const struct tm
& tm
)
1388 time_t timet
= mktime(&tm2
);
1390 if ( timet
== (time_t)-1 )
1392 // mktime() rather unintuitively fails for Jan 1, 1970 if the hour is
1393 // less than timezone - try to make it work for this case
1394 if ( tm2
.tm_year
== 70 && tm2
.tm_mon
== 0 && tm2
.tm_mday
== 1 )
1396 return Set((time_t)(
1398 tm2
.tm_hour
* MIN_PER_HOUR
* SEC_PER_MIN
+
1399 tm2
.tm_min
* SEC_PER_MIN
+
1403 wxFAIL_MSG( _T("mktime() failed") );
1405 *this = wxInvalidDateTime
;
1415 wxDateTime
& wxDateTime
::Set(wxDateTime_t hour
,
1416 wxDateTime_t minute
,
1417 wxDateTime_t second
,
1418 wxDateTime_t millisec
)
1420 // we allow seconds to be 61 to account for the leap seconds, even if we
1421 // don't use them really
1422 wxDATETIME_CHECK( hour
< 24 &&
1426 _T("Invalid time in wxDateTime::Set()") );
1428 // get the current date from system
1430 struct tm
*tm
= GetTmNow(&tmstruct
);
1432 wxDATETIME_CHECK( tm
, _T("wxLocaltime_r() failed") );
1434 // make a copy so it isn't clobbered by the call to mktime() below
1439 tm1
.tm_min
= minute
;
1440 tm1
.tm_sec
= second
;
1442 // and the DST in case it changes on this date
1445 if ( tm2
.tm_isdst
!= tm1
.tm_isdst
)
1446 tm1
.tm_isdst
= tm2
.tm_isdst
;
1450 // and finally adjust milliseconds
1451 return SetMillisecond(millisec
);
1454 wxDateTime
& wxDateTime
::Set(wxDateTime_t day
,
1458 wxDateTime_t minute
,
1459 wxDateTime_t second
,
1460 wxDateTime_t millisec
)
1462 wxDATETIME_CHECK( hour
< 24 &&
1466 _T("Invalid time in wxDateTime::Set()") );
1468 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1470 wxDATETIME_CHECK( (0 < day
) && (day
<= GetNumberOfDays(month
, year
)),
1471 _T("Invalid date in wxDateTime::Set()") );
1473 // the range of time_t type (inclusive)
1474 static const int yearMinInRange
= 1970;
1475 static const int yearMaxInRange
= 2037;
1477 // test only the year instead of testing for the exact end of the Unix
1478 // time_t range - it doesn't bring anything to do more precise checks
1479 if ( year
>= yearMinInRange
&& year
<= yearMaxInRange
)
1481 // use the standard library version if the date is in range - this is
1482 // probably more efficient than our code
1484 tm
.tm_year
= year
- 1900;
1490 tm
.tm_isdst
= -1; // mktime() will guess it
1494 // and finally adjust milliseconds
1496 SetMillisecond(millisec
);
1502 // do time calculations ourselves: we want to calculate the number of
1503 // milliseconds between the given date and the epoch
1505 // get the JDN for the midnight of this day
1506 m_time
= GetTruncatedJDN(day
, month
, year
);
1507 m_time
-= EPOCH_JDN
;
1508 m_time
*= SECONDS_PER_DAY
* TIME_T_FACTOR
;
1510 // JDN corresponds to GMT, we take localtime
1511 Add(wxTimeSpan(hour
, minute
, second
+ GetTimeZone(), millisec
));
1517 wxDateTime
& wxDateTime
::Set(double jdn
)
1519 // so that m_time will be 0 for the midnight of Jan 1, 1970 which is jdn
1521 jdn
-= EPOCH_JDN
+ 0.5;
1523 m_time
.Assign(jdn
*MILLISECONDS_PER_DAY
);
1525 // JDNs always are in UTC, so we don't need any adjustments for time zone
1530 wxDateTime
& wxDateTime
::ResetTime()
1534 if ( tm
.hour
|| tm
.min
|| tm
.sec
|| tm
.msec
)
1547 wxDateTime wxDateTime
::GetDateOnly() const
1554 return wxDateTime(tm
);
1557 // ----------------------------------------------------------------------------
1558 // DOS Date and Time Format functions
1559 // ----------------------------------------------------------------------------
1560 // the dos date and time value is an unsigned 32 bit value in the format:
1561 // YYYYYYYMMMMDDDDDhhhhhmmmmmmsssss
1563 // Y = year offset from 1980 (0-127)
1565 // D = day of month (1-31)
1567 // m = minute (0-59)
1568 // s = bisecond (0-29) each bisecond indicates two seconds
1569 // ----------------------------------------------------------------------------
1571 wxDateTime
& wxDateTime
::SetFromDOS(unsigned long ddt
)
1576 long year
= ddt
& 0xFE000000;
1581 long month
= ddt
& 0x1E00000;
1586 long day
= ddt
& 0x1F0000;
1590 long hour
= ddt
& 0xF800;
1594 long minute
= ddt
& 0x7E0;
1598 long second
= ddt
& 0x1F;
1599 tm
.tm_sec
= second
* 2;
1601 return Set(mktime(&tm
));
1604 unsigned long wxDateTime
::GetAsDOS() const
1607 time_t ticks
= GetTicks();
1609 struct tm
*tm
= wxLocaltime_r(&ticks
, &tmstruct
);
1611 long year
= tm
->tm_year
;
1615 long month
= tm
->tm_mon
;
1619 long day
= tm
->tm_mday
;
1622 long hour
= tm
->tm_hour
;
1625 long minute
= tm
->tm_min
;
1628 long second
= tm
->tm_sec
;
1631 ddt
= year
| month
| day
| hour
| minute
| second
;
1635 // ----------------------------------------------------------------------------
1636 // time_t <-> broken down time conversions
1637 // ----------------------------------------------------------------------------
1639 wxDateTime
::Tm wxDateTime
::GetTm(const TimeZone
& tz
) const
1641 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1643 time_t time
= GetTicks();
1644 if ( time
!= (time_t)-1 )
1646 // use C RTL functions
1649 if ( tz
.GetOffset() == -GetTimeZone() )
1651 // we are working with local time
1652 tm
= wxLocaltime_r(&time
, &tmstruct
);
1654 // should never happen
1655 wxCHECK_MSG( tm
, Tm(), _T("wxLocaltime_r() failed") );
1659 time
+= (time_t)tz
.GetOffset();
1660 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
1661 int time2
= (int) time
;
1667 tm
= wxGmtime_r(&time
, &tmstruct
);
1669 // should never happen
1670 wxCHECK_MSG( tm
, Tm(), _T("wxGmtime_r() failed") );
1674 tm
= (struct tm
*)NULL
;
1680 // adjust the milliseconds
1682 long timeOnly
= (m_time
% MILLISECONDS_PER_DAY
).ToLong();
1683 tm2
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1686 //else: use generic code below
1689 // remember the time and do the calculations with the date only - this
1690 // eliminates rounding errors of the floating point arithmetics
1692 wxLongLong timeMidnight
= m_time
+ tz
.GetOffset() * 1000;
1694 long timeOnly
= (timeMidnight
% MILLISECONDS_PER_DAY
).ToLong();
1696 // we want to always have positive time and timeMidnight to be really
1697 // the midnight before it
1700 timeOnly
= MILLISECONDS_PER_DAY
+ timeOnly
;
1703 timeMidnight
-= timeOnly
;
1705 // calculate the Gregorian date from JDN for the midnight of our date:
1706 // this will yield day, month (in 1..12 range) and year
1708 // actually, this is the JDN for the noon of the previous day
1709 long jdn
= (timeMidnight
/ MILLISECONDS_PER_DAY
).ToLong() + EPOCH_JDN
;
1711 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
1713 wxASSERT_MSG( jdn
> -2, _T("JDN out of range") );
1715 // calculate the century
1716 long temp
= (jdn
+ JDN_OFFSET
) * 4 - 1;
1717 long century
= temp
/ DAYS_PER_400_YEARS
;
1719 // then the year and day of year (1 <= dayOfYear <= 366)
1720 temp
= ((temp
% DAYS_PER_400_YEARS
) / 4) * 4 + 3;
1721 long year
= (century
* 100) + (temp
/ DAYS_PER_4_YEARS
);
1722 long dayOfYear
= (temp
% DAYS_PER_4_YEARS
) / 4 + 1;
1724 // and finally the month and day of the month
1725 temp
= dayOfYear
* 5 - 3;
1726 long month
= temp
/ DAYS_PER_5_MONTHS
;
1727 long day
= (temp
% DAYS_PER_5_MONTHS
) / 5 + 1;
1729 // month is counted from March - convert to normal
1740 // year is offset by 4800
1743 // check that the algorithm gave us something reasonable
1744 wxASSERT_MSG( (0 < month
) && (month
<= 12), _T("invalid month") );
1745 wxASSERT_MSG( (1 <= day
) && (day
< 32), _T("invalid day") );
1747 // construct Tm from these values
1749 tm
.year
= (int)year
;
1750 tm
.mon
= (Month
)(month
- 1); // algorithm yields 1 for January, not 0
1751 tm
.mday
= (wxDateTime_t
)day
;
1752 tm
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1753 timeOnly
-= tm
.msec
;
1754 timeOnly
/= 1000; // now we have time in seconds
1756 tm
.sec
= (wxDateTime_t
)(timeOnly
% SEC_PER_MIN
);
1758 timeOnly
/= SEC_PER_MIN
; // now we have time in minutes
1760 tm
.min
= (wxDateTime_t
)(timeOnly
% MIN_PER_HOUR
);
1763 tm
.hour
= (wxDateTime_t
)(timeOnly
/ MIN_PER_HOUR
);
1768 wxDateTime
& wxDateTime
::SetYear(int year
)
1770 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1779 wxDateTime
& wxDateTime
::SetMonth(Month month
)
1781 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1790 wxDateTime
& wxDateTime
::SetDay(wxDateTime_t mday
)
1792 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1801 wxDateTime
& wxDateTime
::SetHour(wxDateTime_t hour
)
1803 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1812 wxDateTime
& wxDateTime
::SetMinute(wxDateTime_t min
)
1814 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1823 wxDateTime
& wxDateTime
::SetSecond(wxDateTime_t sec
)
1825 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1834 wxDateTime
& wxDateTime
::SetMillisecond(wxDateTime_t millisecond
)
1836 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1838 // we don't need to use GetTm() for this one
1839 m_time
-= m_time
% 1000l;
1840 m_time
+= millisecond
;
1845 // ----------------------------------------------------------------------------
1846 // wxDateTime arithmetics
1847 // ----------------------------------------------------------------------------
1849 wxDateTime
& wxDateTime
::Add(const wxDateSpan
& diff
)
1853 tm
.year
+= diff
.GetYears();
1854 tm
.AddMonths(diff
.GetMonths());
1856 // check that the resulting date is valid
1857 if ( tm
.mday
> GetNumOfDaysInMonth(tm
.year
, tm
.mon
) )
1859 // We suppose that when adding one month to Jan 31 we want to get Feb
1860 // 28 (or 29), i.e. adding a month to the last day of the month should
1861 // give the last day of the next month which is quite logical.
1863 // Unfortunately, there is no logic way to understand what should
1864 // Jan 30 + 1 month be - Feb 28 too or Feb 27 (assuming non leap year)?
1865 // We make it Feb 28 (last day too), but it is highly questionable.
1866 tm
.mday
= GetNumOfDaysInMonth(tm
.year
, tm
.mon
);
1869 tm
.AddDays(diff
.GetTotalDays());
1873 wxASSERT_MSG( IsSameTime(tm
),
1874 _T("Add(wxDateSpan) shouldn't modify time") );
1879 // ----------------------------------------------------------------------------
1880 // Weekday and monthday stuff
1881 // ----------------------------------------------------------------------------
1883 // convert Sun, Mon, ..., Sat into 6, 0, ..., 5
1884 static inline int ConvertWeekDayToMondayBase(int wd
)
1886 return wd
== wxDateTime
::Sun ?
6 : wd
- 1;
1891 wxDateTime
::SetToWeekOfYear(int year
, wxDateTime_t numWeek
, WeekDay wd
)
1893 wxASSERT_MSG( numWeek
> 0,
1894 _T("invalid week number: weeks are counted from 1") );
1896 // Jan 4 always lies in the 1st week of the year
1897 wxDateTime
dt(4, Jan
, year
);
1898 dt
.SetToWeekDayInSameWeek(wd
);
1899 dt
+= wxDateSpan
::Weeks(numWeek
- 1);
1904 #if WXWIN_COMPATIBILITY_2_6
1905 // use a separate function to avoid warnings about using deprecated
1906 // SetToTheWeek in GetWeek below
1908 SetToTheWeek(int year
,
1909 wxDateTime
::wxDateTime_t numWeek
,
1910 wxDateTime
::WeekDay weekday
,
1911 wxDateTime
::WeekFlags flags
)
1913 // Jan 4 always lies in the 1st week of the year
1914 wxDateTime
dt(4, wxDateTime
::Jan
, year
);
1915 dt
.SetToWeekDayInSameWeek(weekday
, flags
);
1916 dt
+= wxDateSpan
::Weeks(numWeek
- 1);
1921 bool wxDateTime
::SetToTheWeek(wxDateTime_t numWeek
,
1925 int year
= GetYear();
1926 *this = ::SetToTheWeek(year
, numWeek
, weekday
, flags
);
1927 if ( GetYear() != year
)
1929 // oops... numWeek was too big
1936 wxDateTime wxDateTime
::GetWeek(wxDateTime_t numWeek
,
1938 WeekFlags flags
) const
1940 return ::SetToTheWeek(GetYear(), numWeek
, weekday
, flags
);
1942 #endif // WXWIN_COMPATIBILITY_2_6
1944 wxDateTime
& wxDateTime
::SetToLastMonthDay(Month month
,
1947 // take the current month/year if none specified
1948 if ( year
== Inv_Year
)
1950 if ( month
== Inv_Month
)
1953 return Set(GetNumOfDaysInMonth(year
, month
), month
, year
);
1956 wxDateTime
& wxDateTime
::SetToWeekDayInSameWeek(WeekDay weekday
, WeekFlags flags
)
1958 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
1960 int wdayDst
= weekday
,
1961 wdayThis
= GetWeekDay();
1962 if ( wdayDst
== wdayThis
)
1968 if ( flags
== Default_First
)
1970 flags
= GetCountry() == USA ? Sunday_First
: Monday_First
;
1973 // the logic below based on comparing weekday and wdayThis works if Sun (0)
1974 // is the first day in the week, but breaks down for Monday_First case so
1975 // we adjust the week days in this case
1976 if ( flags
== Monday_First
)
1978 if ( wdayThis
== Sun
)
1980 if ( wdayDst
== Sun
)
1983 //else: Sunday_First, nothing to do
1985 // go forward or back in time to the day we want
1986 if ( wdayDst
< wdayThis
)
1988 return Subtract(wxDateSpan
::Days(wdayThis
- wdayDst
));
1990 else // weekday > wdayThis
1992 return Add(wxDateSpan
::Days(wdayDst
- wdayThis
));
1996 wxDateTime
& wxDateTime
::SetToNextWeekDay(WeekDay weekday
)
1998 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
2001 WeekDay wdayThis
= GetWeekDay();
2002 if ( weekday
== wdayThis
)
2007 else if ( weekday
< wdayThis
)
2009 // need to advance a week
2010 diff
= 7 - (wdayThis
- weekday
);
2012 else // weekday > wdayThis
2014 diff
= weekday
- wdayThis
;
2017 return Add(wxDateSpan
::Days(diff
));
2020 wxDateTime
& wxDateTime
::SetToPrevWeekDay(WeekDay weekday
)
2022 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
2025 WeekDay wdayThis
= GetWeekDay();
2026 if ( weekday
== wdayThis
)
2031 else if ( weekday
> wdayThis
)
2033 // need to go to previous week
2034 diff
= 7 - (weekday
- wdayThis
);
2036 else // weekday < wdayThis
2038 diff
= wdayThis
- weekday
;
2041 return Subtract(wxDateSpan
::Days(diff
));
2044 bool wxDateTime
::SetToWeekDay(WeekDay weekday
,
2049 wxCHECK_MSG( weekday
!= Inv_WeekDay
, false, _T("invalid weekday") );
2051 // we don't check explicitly that -5 <= n <= 5 because we will return false
2052 // anyhow in such case - but may be should still give an assert for it?
2054 // take the current month/year if none specified
2055 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
2059 // TODO this probably could be optimised somehow...
2063 // get the first day of the month
2064 dt
.Set(1, month
, year
);
2067 WeekDay wdayFirst
= dt
.GetWeekDay();
2069 // go to the first weekday of the month
2070 int diff
= weekday
- wdayFirst
;
2074 // add advance n-1 weeks more
2077 dt
+= wxDateSpan
::Days(diff
);
2079 else // count from the end of the month
2081 // get the last day of the month
2082 dt
.SetToLastMonthDay(month
, year
);
2085 WeekDay wdayLast
= dt
.GetWeekDay();
2087 // go to the last weekday of the month
2088 int diff
= wdayLast
- weekday
;
2092 // and rewind n-1 weeks from there
2095 dt
-= wxDateSpan
::Days(diff
);
2098 // check that it is still in the same month
2099 if ( dt
.GetMonth() == month
)
2107 // no such day in this month
2113 wxDateTime
::wxDateTime_t
GetDayOfYearFromTm(const wxDateTime
::Tm
& tm
)
2115 return (wxDateTime
::wxDateTime_t
)(gs_cumulatedDays
[wxDateTime
::IsLeapYear(tm
.year
)][tm
.mon
] + tm
.mday
);
2118 wxDateTime
::wxDateTime_t wxDateTime
::GetDayOfYear(const TimeZone
& tz
) const
2120 return GetDayOfYearFromTm(GetTm(tz
));
2123 wxDateTime
::wxDateTime_t
2124 wxDateTime
::GetWeekOfYear(wxDateTime
::WeekFlags flags
, const TimeZone
& tz
) const
2126 if ( flags
== Default_First
)
2128 flags
= GetCountry() == USA ? Sunday_First
: Monday_First
;
2132 wxDateTime_t nDayInYear
= GetDayOfYearFromTm(tm
);
2134 int wdTarget
= GetWeekDay(tz
);
2135 int wdYearStart
= wxDateTime(1, Jan
, GetYear()).GetWeekDay();
2137 if ( flags
== Sunday_First
)
2139 // FIXME: First week is not calculated correctly.
2140 week
= (nDayInYear
- wdTarget
+ 7) / 7;
2141 if ( wdYearStart
== Wed
|| wdYearStart
== Thu
)
2144 else // week starts with monday
2146 // adjust the weekdays to non-US style.
2147 wdYearStart
= ConvertWeekDayToMondayBase(wdYearStart
);
2148 wdTarget
= ConvertWeekDayToMondayBase(wdTarget
);
2150 // quoting from http://www.cl.cam.ac.uk/~mgk25/iso-time.html:
2152 // Week 01 of a year is per definition the first week that has the
2153 // Thursday in this year, which is equivalent to the week that
2154 // contains the fourth day of January. In other words, the first
2155 // week of a new year is the week that has the majority of its
2156 // days in the new year. Week 01 might also contain days from the
2157 // previous year and the week before week 01 of a year is the last
2158 // week (52 or 53) of the previous year even if it contains days
2159 // from the new year. A week starts with Monday (day 1) and ends
2160 // with Sunday (day 7).
2163 // if Jan 1 is Thursday or less, it is in the first week of this year
2164 if ( wdYearStart
< 4 )
2166 // count the number of entire weeks between Jan 1 and this date
2167 week
= (nDayInYear
+ wdYearStart
+ 6 - wdTarget
)/7;
2169 // be careful to check for overflow in the next year
2170 if ( week
== 53 && tm
.mday
- wdTarget
> 28 )
2173 else // Jan 1 is in the last week of the previous year
2175 // check if we happen to be at the last week of previous year:
2176 if ( tm
.mon
== Jan
&& tm
.mday
< 8 - wdYearStart
)
2177 week
= wxDateTime(31, Dec
, GetYear()-1).GetWeekOfYear();
2179 week
= (nDayInYear
+ wdYearStart
- 1 - wdTarget
)/7;
2183 return (wxDateTime
::wxDateTime_t
)week
;
2186 wxDateTime
::wxDateTime_t wxDateTime
::GetWeekOfMonth(wxDateTime
::WeekFlags flags
,
2187 const TimeZone
& tz
) const
2190 wxDateTime dtMonthStart
= wxDateTime(1, tm
.mon
, tm
.year
);
2191 int nWeek
= GetWeekOfYear(flags
) - dtMonthStart
.GetWeekOfYear(flags
) + 1;
2194 // this may happen for January when Jan, 1 is the last week of the
2196 nWeek
+= IsLeapYear(tm
.year
- 1) ?
53 : 52;
2199 return (wxDateTime
::wxDateTime_t
)nWeek
;
2202 wxDateTime
& wxDateTime
::SetToYearDay(wxDateTime
::wxDateTime_t yday
)
2204 int year
= GetYear();
2205 wxDATETIME_CHECK( (0 < yday
) && (yday
<= GetNumberOfDays(year
)),
2206 _T("invalid year day") );
2208 bool isLeap
= IsLeapYear(year
);
2209 for ( Month mon
= Jan
; mon
< Inv_Month
; wxNextMonth(mon
) )
2211 // for Dec, we can't compare with gs_cumulatedDays[mon + 1], but we
2212 // don't need it neither - because of the CHECK above we know that
2213 // yday lies in December then
2214 if ( (mon
== Dec
) || (yday
<= gs_cumulatedDays
[isLeap
][mon
+ 1]) )
2216 Set((wxDateTime
::wxDateTime_t
)(yday
- gs_cumulatedDays
[isLeap
][mon
]), mon
, year
);
2225 // ----------------------------------------------------------------------------
2226 // Julian day number conversion and related stuff
2227 // ----------------------------------------------------------------------------
2229 double wxDateTime
::GetJulianDayNumber() const
2231 return m_time
.ToDouble() / MILLISECONDS_PER_DAY
+ EPOCH_JDN
+ 0.5;
2234 double wxDateTime
::GetRataDie() const
2236 // March 1 of the year 0 is Rata Die day -306 and JDN 1721119.5
2237 return GetJulianDayNumber() - 1721119.5 - 306;
2240 // ----------------------------------------------------------------------------
2241 // timezone and DST stuff
2242 // ----------------------------------------------------------------------------
2244 int wxDateTime
::IsDST(wxDateTime
::Country country
) const
2246 wxCHECK_MSG( country
== Country_Default
, -1,
2247 _T("country support not implemented") );
2249 // use the C RTL for the dates in the standard range
2250 time_t timet
= GetTicks();
2251 if ( timet
!= (time_t)-1 )
2254 tm
*tm
= wxLocaltime_r(&timet
, &tmstruct
);
2256 wxCHECK_MSG( tm
, -1, _T("wxLocaltime_r() failed") );
2258 return tm
->tm_isdst
;
2262 int year
= GetYear();
2264 if ( !IsDSTApplicable(year
, country
) )
2266 // no DST time in this year in this country
2270 return IsBetween(GetBeginDST(year
, country
), GetEndDST(year
, country
));
2274 wxDateTime
& wxDateTime
::MakeTimezone(const TimeZone
& tz
, bool noDST
)
2276 long secDiff
= GetTimeZone() + tz
.GetOffset();
2278 // we need to know whether DST is or not in effect for this date unless
2279 // the test disabled by the caller
2280 if ( !noDST
&& (IsDST() == 1) )
2282 // FIXME we assume that the DST is always shifted by 1 hour
2286 return Add(wxTimeSpan
::Seconds(secDiff
));
2289 wxDateTime
& wxDateTime
::MakeFromTimezone(const TimeZone
& tz
, bool noDST
)
2291 long secDiff
= GetTimeZone() + tz
.GetOffset();
2293 // we need to know whether DST is or not in effect for this date unless
2294 // the test disabled by the caller
2295 if ( !noDST
&& (IsDST() == 1) )
2297 // FIXME we assume that the DST is always shifted by 1 hour
2301 return Subtract(wxTimeSpan
::Seconds(secDiff
));
2304 // ----------------------------------------------------------------------------
2305 // wxDateTime to/from text representations
2306 // ----------------------------------------------------------------------------
2308 wxString wxDateTime
::Format(const wxString
& format
, const TimeZone
& tz
) const
2310 wxCHECK_MSG( !format
.empty(), wxEmptyString
,
2311 _T("NULL format in wxDateTime::Format") );
2313 // we have to use our own implementation if the date is out of range of
2314 // strftime() or if we use non standard specificators
2315 #ifdef HAVE_STRFTIME
2316 time_t time
= GetTicks();
2318 if ( (time
!= (time_t)-1) && !wxStrstr(format
, _T("%l")) )
2323 if ( tz
.GetOffset() == -GetTimeZone() )
2325 // we are working with local time
2326 tm
= wxLocaltime_r(&time
, &tmstruct
);
2328 // should never happen
2329 wxCHECK_MSG( tm
, wxEmptyString
, _T("wxLocaltime_r() failed") );
2333 time
+= (int)tz
.GetOffset();
2335 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
2336 int time2
= (int) time
;
2342 tm
= wxGmtime_r(&time
, &tmstruct
);
2344 // should never happen
2345 wxCHECK_MSG( tm
, wxEmptyString
, _T("wxGmtime_r() failed") );
2349 tm
= (struct tm
*)NULL
;
2355 return CallStrftime(format
, tm
);
2358 //else: use generic code below
2359 #endif // HAVE_STRFTIME
2361 // we only parse ANSI C format specifications here, no POSIX 2
2362 // complications, no GNU extensions but we do add support for a "%l" format
2363 // specifier allowing to get the number of milliseconds
2366 // used for calls to strftime() when we only deal with time
2367 struct tm tmTimeOnly
;
2368 tmTimeOnly
.tm_hour
= tm
.hour
;
2369 tmTimeOnly
.tm_min
= tm
.min
;
2370 tmTimeOnly
.tm_sec
= tm
.sec
;
2371 tmTimeOnly
.tm_wday
= 0;
2372 tmTimeOnly
.tm_yday
= 0;
2373 tmTimeOnly
.tm_mday
= 1; // any date will do
2374 tmTimeOnly
.tm_mon
= 0;
2375 tmTimeOnly
.tm_year
= 76;
2376 tmTimeOnly
.tm_isdst
= 0; // no DST, we adjust for tz ourselves
2378 wxString tmp
, res
, fmt
;
2379 for ( wxString
::const_iterator p
= format
.begin(); p
!= format
.end(); ++p
)
2381 if ( *p
!= _T('%') )
2389 // set the default format
2390 switch ( (*++p
).GetValue() )
2392 case _T('Y'): // year has 4 digits
2396 case _T('j'): // day of year has 3 digits
2397 case _T('l'): // milliseconds have 3 digits
2401 case _T('w'): // week day as number has only one
2406 // it's either another valid format specifier in which case
2407 // the format is "%02d" (for all the rest) or we have the
2408 // field width preceding the format in which case it will
2409 // override the default format anyhow
2413 bool restart
= true;
2418 // start of the format specification
2419 switch ( (*p
).GetValue() )
2421 case _T('a'): // a weekday name
2423 // second parameter should be true for abbreviated names
2424 res
+= GetWeekDayName(tm
.GetWeekDay(),
2425 *p
== _T('a') ? Name_Abbr
: Name_Full
);
2428 case _T('b'): // a month name
2430 res
+= GetMonthName(tm
.mon
,
2431 *p
== _T('b') ? Name_Abbr
: Name_Full
);
2434 case _T('c'): // locale default date and time representation
2435 case _T('x'): // locale default date representation
2436 #ifdef HAVE_STRFTIME
2438 // the problem: there is no way to know what do these format
2439 // specifications correspond to for the current locale.
2441 // the solution: use a hack and still use strftime(): first
2442 // find the YEAR which is a year in the strftime() range (1970
2443 // - 2038) whose Jan 1 falls on the same week day as the Jan 1
2444 // of the real year. Then make a copy of the format and
2445 // replace all occurrences of YEAR in it with some unique
2446 // string not appearing anywhere else in it, then use
2447 // strftime() to format the date in year YEAR and then replace
2448 // YEAR back by the real year and the unique replacement
2449 // string back with YEAR. Notice that "all occurrences of YEAR"
2450 // means all occurrences of 4 digit as well as 2 digit form!
2452 // the bugs: we assume that neither of %c nor %x contains any
2453 // fields which may change between the YEAR and real year. For
2454 // example, the week number (%U, %W) and the day number (%j)
2455 // will change if one of these years is leap and the other one
2458 // find the YEAR: normally, for any year X, Jan 1 of the
2459 // year X + 28 is the same weekday as Jan 1 of X (because
2460 // the weekday advances by 1 for each normal X and by 2
2461 // for each leap X, hence by 5 every 4 years or by 35
2462 // which is 0 mod 7 every 28 years) but this rule breaks
2463 // down if there are years between X and Y which are
2464 // divisible by 4 but not leap (i.e. divisible by 100 but
2465 // not 400), hence the correction.
2467 int yearReal
= GetYear(tz
);
2468 int mod28
= yearReal
% 28;
2470 // be careful to not go too far - we risk to leave the
2475 year
= 1988 + mod28
; // 1988 == 0 (mod 28)
2479 year
= 1970 + mod28
- 10; // 1970 == 10 (mod 28)
2482 int nCentury
= year
/ 100,
2483 nCenturyReal
= yearReal
/ 100;
2485 // need to adjust for the years divisble by 400 which are
2486 // not leap but are counted like leap ones if we just take
2487 // the number of centuries in between for nLostWeekDays
2488 int nLostWeekDays
= (nCentury
- nCenturyReal
) -
2489 (nCentury
/ 4 - nCenturyReal
/ 4);
2491 // we have to gain back the "lost" weekdays: note that the
2492 // effect of this loop is to not do anything to
2493 // nLostWeekDays (which we won't use any more), but to
2494 // (indirectly) set the year correctly
2495 while ( (nLostWeekDays
% 7) != 0 )
2497 nLostWeekDays
+= year
++ % 4 ?
1 : 2;
2500 // finally move the year below 2000 so that the 2-digit
2501 // year number can never match the month or day of the
2502 // month when we do the replacements below
2506 wxASSERT_MSG( year
>= 1970 && year
< 2000,
2507 _T("logic error in wxDateTime::Format") );
2510 // use strftime() to format the same date but in supported
2513 // NB: we assume that strftime() doesn't check for the
2514 // date validity and will happily format the date
2515 // corresponding to Feb 29 of a non leap year (which
2516 // may happen if yearReal was leap and year is not)
2517 struct tm tmAdjusted
;
2519 tmAdjusted
.tm_hour
= tm
.hour
;
2520 tmAdjusted
.tm_min
= tm
.min
;
2521 tmAdjusted
.tm_sec
= tm
.sec
;
2522 tmAdjusted
.tm_wday
= tm
.GetWeekDay();
2523 tmAdjusted
.tm_yday
= GetDayOfYear();
2524 tmAdjusted
.tm_mday
= tm
.mday
;
2525 tmAdjusted
.tm_mon
= tm
.mon
;
2526 tmAdjusted
.tm_year
= year
- 1900;
2527 tmAdjusted
.tm_isdst
= 0; // no DST, already adjusted
2528 wxString str
= CallStrftime(*p
== _T('c') ?
_T("%c")
2532 // now replace the replacement year with the real year:
2533 // notice that we have to replace the 4 digit year with
2534 // a unique string not appearing in strftime() output
2535 // first to prevent the 2 digit year from matching any
2536 // substring of the 4 digit year (but any day, month,
2537 // hours or minutes components should be safe because
2538 // they are never in 70-99 range)
2539 wxString
replacement("|");
2540 while ( str
.find(replacement
) != wxString
::npos
)
2543 str
.Replace(wxString
::Format("%d", year
),
2545 str
.Replace(wxString
::Format("%d", year
% 100),
2546 wxString
::Format("%d", yearReal
% 100));
2547 str
.Replace(replacement
,
2548 wxString
::Format("%d", yearReal
));
2552 #else // !HAVE_STRFTIME
2553 // Use "%m/%d/%y %H:%M:%S" format instead
2554 res
+= wxString
::Format(wxT("%02d/%02d/%04d %02d:%02d:%02d"),
2555 tm
.mon
+1,tm
.mday
, tm
.year
, tm
.hour
, tm
.min
, tm
.sec
);
2556 #endif // HAVE_STRFTIME/!HAVE_STRFTIME
2559 case _T('d'): // day of a month (01-31)
2560 res
+= wxString
::Format(fmt
, tm
.mday
);
2563 case _T('H'): // hour in 24h format (00-23)
2564 res
+= wxString
::Format(fmt
, tm
.hour
);
2567 case _T('I'): // hour in 12h format (01-12)
2569 // 24h -> 12h, 0h -> 12h too
2570 int hour12
= tm
.hour
> 12 ? tm
.hour
- 12
2571 : tm
.hour ? tm
.hour
: 12;
2572 res
+= wxString
::Format(fmt
, hour12
);
2576 case _T('j'): // day of the year
2577 res
+= wxString
::Format(fmt
, GetDayOfYear(tz
));
2580 case _T('l'): // milliseconds (NOT STANDARD)
2581 res
+= wxString
::Format(fmt
, GetMillisecond(tz
));
2584 case _T('m'): // month as a number (01-12)
2585 res
+= wxString
::Format(fmt
, tm
.mon
+ 1);
2588 case _T('M'): // minute as a decimal number (00-59)
2589 res
+= wxString
::Format(fmt
, tm
.min
);
2592 case _T('p'): // AM or PM string
2593 #ifdef HAVE_STRFTIME
2594 res
+= CallStrftime(_T("%p"), &tmTimeOnly
);
2595 #else // !HAVE_STRFTIME
2596 res
+= (tmTimeOnly
.tm_hour
> 12) ?
wxT("pm") : wxT("am");
2597 #endif // HAVE_STRFTIME/!HAVE_STRFTIME
2600 case _T('S'): // second as a decimal number (00-61)
2601 res
+= wxString
::Format(fmt
, tm
.sec
);
2604 case _T('U'): // week number in the year (Sunday 1st week day)
2605 res
+= wxString
::Format(fmt
, GetWeekOfYear(Sunday_First
, tz
));
2608 case _T('W'): // week number in the year (Monday 1st week day)
2609 res
+= wxString
::Format(fmt
, GetWeekOfYear(Monday_First
, tz
));
2612 case _T('w'): // weekday as a number (0-6), Sunday = 0
2613 res
+= wxString
::Format(fmt
, tm
.GetWeekDay());
2616 // case _T('x'): -- handled with "%c"
2618 case _T('X'): // locale default time representation
2619 // just use strftime() to format the time for us
2620 #ifdef HAVE_STRFTIME
2621 res
+= CallStrftime(_T("%X"), &tmTimeOnly
);
2622 #else // !HAVE_STRFTIME
2623 res
+= wxString
::Format(wxT("%02d:%02d:%02d"),tm
.hour
, tm
.min
, tm
.sec
);
2624 #endif // HAVE_STRFTIME/!HAVE_STRFTIME
2627 case _T('y'): // year without century (00-99)
2628 res
+= wxString
::Format(fmt
, tm
.year
% 100);
2631 case _T('Y'): // year with century
2632 res
+= wxString
::Format(fmt
, tm
.year
);
2635 case _T('Z'): // timezone name
2636 #ifdef HAVE_STRFTIME
2637 res
+= CallStrftime(_T("%Z"), &tmTimeOnly
);
2642 // is it the format width?
2644 while ( *p
== _T('-') || *p
== _T('+') ||
2645 *p
== _T(' ') || wxIsdigit(*p
) )
2652 // we've only got the flags and width so far in fmt
2653 fmt
.Prepend(_T('%'));
2654 fmt
.Append(_T('d'));
2661 // no, it wasn't the width
2662 wxFAIL_MSG(_T("unknown format specificator"));
2664 // fall through and just copy it nevertheless
2666 case _T('%'): // a percent sign
2670 case 0: // the end of string
2671 wxFAIL_MSG(_T("missing format at the end of string"));
2673 // just put the '%' which was the last char in format
2683 // this function parses a string in (strict) RFC 822 format: see the section 5
2684 // of the RFC for the detailed description, but briefly it's something of the
2685 // form "Sat, 18 Dec 1999 00:48:30 +0100"
2687 // this function is "strict" by design - it must reject anything except true
2688 // RFC822 time specs.
2690 // TODO a great candidate for using reg exps
2691 const wxChar
*wxDateTime
::ParseRfc822Date(const wxChar
* date
)
2693 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
2695 const wxChar
*p
= date
;
2696 const wxChar
*comma
= wxStrchr(p
, _T(','));
2699 // the part before comma is the weekday
2701 // skip it for now - we don't use but might check that it really
2702 // corresponds to the specfied date
2705 if ( *p
!= _T(' ') )
2707 wxLogDebug(_T("no space after weekday in RFC822 time spec"));
2709 return (wxChar
*)NULL
;
2715 // the following 1 or 2 digits are the day number
2716 if ( !wxIsdigit(*p
) )
2718 wxLogDebug(_T("day number expected in RFC822 time spec, none found"));
2720 return (wxChar
*)NULL
;
2723 wxDateTime_t day
= (wxDateTime_t
)(*p
++ - _T('0'));
2724 if ( wxIsdigit(*p
) )
2727 day
= (wxDateTime_t
)(day
+ (*p
++ - _T('0')));
2730 if ( *p
++ != _T(' ') )
2732 return (wxChar
*)NULL
;
2735 // the following 3 letters specify the month
2736 wxString
monName(p
, 3);
2738 if ( monName
== _T("Jan") )
2740 else if ( monName
== _T("Feb") )
2742 else if ( monName
== _T("Mar") )
2744 else if ( monName
== _T("Apr") )
2746 else if ( monName
== _T("May") )
2748 else if ( monName
== _T("Jun") )
2750 else if ( monName
== _T("Jul") )
2752 else if ( monName
== _T("Aug") )
2754 else if ( monName
== _T("Sep") )
2756 else if ( monName
== _T("Oct") )
2758 else if ( monName
== _T("Nov") )
2760 else if ( monName
== _T("Dec") )
2764 wxLogDebug(_T("Invalid RFC 822 month name '%s'"), monName
.c_str());
2766 return (wxChar
*)NULL
;
2771 if ( *p
++ != _T(' ') )
2773 return (wxChar
*)NULL
;
2777 if ( !wxIsdigit(*p
) )
2780 return (wxChar
*)NULL
;
2783 int year
= *p
++ - _T('0');
2785 if ( !wxIsdigit(*p
) )
2787 // should have at least 2 digits in the year
2788 return (wxChar
*)NULL
;
2792 year
+= *p
++ - _T('0');
2794 // is it a 2 digit year (as per original RFC 822) or a 4 digit one?
2795 if ( wxIsdigit(*p
) )
2798 year
+= *p
++ - _T('0');
2800 if ( !wxIsdigit(*p
) )
2802 // no 3 digit years please
2803 return (wxChar
*)NULL
;
2807 year
+= *p
++ - _T('0');
2810 if ( *p
++ != _T(' ') )
2812 return (wxChar
*)NULL
;
2815 // time is in the format hh:mm:ss and seconds are optional
2816 if ( !wxIsdigit(*p
) )
2818 return (wxChar
*)NULL
;
2821 wxDateTime_t hour
= (wxDateTime_t
)(*p
++ - _T('0'));
2823 if ( !wxIsdigit(*p
) )
2825 return (wxChar
*)NULL
;
2829 hour
= (wxDateTime_t
)(hour
+ (*p
++ - _T('0')));
2831 if ( *p
++ != _T(':') )
2833 return (wxChar
*)NULL
;
2836 if ( !wxIsdigit(*p
) )
2838 return (wxChar
*)NULL
;
2841 wxDateTime_t min
= (wxDateTime_t
)(*p
++ - _T('0'));
2843 if ( !wxIsdigit(*p
) )
2845 return (wxChar
*)NULL
;
2849 min
= (wxDateTime_t
)(min
+ *p
++ - _T('0'));
2851 wxDateTime_t sec
= 0;
2852 if ( *p
++ == _T(':') )
2854 if ( !wxIsdigit(*p
) )
2856 return (wxChar
*)NULL
;
2859 sec
= (wxDateTime_t
)(*p
++ - _T('0'));
2861 if ( !wxIsdigit(*p
) )
2863 return (wxChar
*)NULL
;
2867 sec
= (wxDateTime_t
)(sec
+ *p
++ - _T('0'));
2870 if ( *p
++ != _T(' ') )
2872 return (wxChar
*)NULL
;
2875 // and now the interesting part: the timezone
2876 int offset
wxDUMMY_INITIALIZE(0);
2877 if ( *p
== _T('-') || *p
== _T('+') )
2879 // the explicit offset given: it has the form of hhmm
2880 bool plus
= *p
++ == _T('+');
2882 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2884 return (wxChar
*)NULL
;
2888 offset
= MIN_PER_HOUR
*(10*(*p
- _T('0')) + (*(p
+ 1) - _T('0')));
2892 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2894 return (wxChar
*)NULL
;
2898 offset
+= 10*(*p
- _T('0')) + (*(p
+ 1) - _T('0'));
2909 // the symbolic timezone given: may be either military timezone or one
2910 // of standard abbreviations
2913 // military: Z = UTC, J unused, A = -1, ..., Y = +12
2914 static const int offsets
[26] =
2916 //A B C D E F G H I J K L M
2917 -1, -2, -3, -4, -5, -6, -7, -8, -9, 0, -10, -11, -12,
2918 //N O P R Q S T U V W Z Y Z
2919 +1, +2, +3, +4, +5, +6, +7, +8, +9, +10, +11, +12, 0
2922 if ( *p
< _T('A') || *p
> _T('Z') || *p
== _T('J') )
2924 wxLogDebug(_T("Invalid militaty timezone '%c'"), *p
);
2926 return (wxChar
*)NULL
;
2929 offset
= offsets
[*p
++ - _T('A')];
2935 if ( tz
== _T("UT") || tz
== _T("UTC") || tz
== _T("GMT") )
2937 else if ( tz
== _T("AST") )
2938 offset
= AST
- GMT0
;
2939 else if ( tz
== _T("ADT") )
2940 offset
= ADT
- GMT0
;
2941 else if ( tz
== _T("EST") )
2942 offset
= EST
- GMT0
;
2943 else if ( tz
== _T("EDT") )
2944 offset
= EDT
- GMT0
;
2945 else if ( tz
== _T("CST") )
2946 offset
= CST
- GMT0
;
2947 else if ( tz
== _T("CDT") )
2948 offset
= CDT
- GMT0
;
2949 else if ( tz
== _T("MST") )
2950 offset
= MST
- GMT0
;
2951 else if ( tz
== _T("MDT") )
2952 offset
= MDT
- GMT0
;
2953 else if ( tz
== _T("PST") )
2954 offset
= PST
- GMT0
;
2955 else if ( tz
== _T("PDT") )
2956 offset
= PDT
- GMT0
;
2959 wxLogDebug(_T("Unknown RFC 822 timezone '%s'"), p
);
2961 return (wxChar
*)NULL
;
2968 offset
*= MIN_PER_HOUR
;
2971 // the spec was correct, construct the date from the values we found
2972 Set(day
, mon
, year
, hour
, min
, sec
);
2973 MakeFromTimezone(TimeZone((wxDateTime_t
)(offset
*SEC_PER_MIN
)));
2980 // returns the string containing strftime() format used for short dates in the
2981 // current locale or an empty string
2982 static wxString
GetLocaleDateFormat()
2986 // there is no setlocale() under Windows CE, so just always query the
2989 if ( strcmp(setlocale(LC_ALL
, NULL
), "C") != 0 )
2992 // The locale was programatically set to non-C. We assume that this was
2993 // done using wxLocale, in which case thread's current locale is also
2994 // set to correct LCID value and we can use GetLocaleInfo to determine
2995 // the correct formatting string:
2997 LCID lcid
= LOCALE_USER_DEFAULT
;
2999 LCID lcid
= GetThreadLocale();
3001 // according to MSDN 80 chars is max allowed for short date format
3003 if ( ::GetLocaleInfo(lcid
, LOCALE_SSHORTDATE
, fmt
, WXSIZEOF(fmt
)) )
3005 wxChar chLast
= _T('\0');
3006 size_t lastCount
= 0;
3007 for ( const wxChar
*p
= fmt
; /* NUL handled inside */; p
++ )
3017 // these characters come in groups, start counting them
3027 // first deal with any special characters we have had
3033 switch ( lastCount
)
3037 // these two are the same as we
3038 // don't distinguish between 1 and
3039 // 2 digits for days
3052 wxFAIL_MSG( _T("too many 'd's") );
3057 switch ( lastCount
)
3061 // as for 'd' and 'dd' above
3074 wxFAIL_MSG( _T("too many 'M's") );
3079 switch ( lastCount
)
3091 wxFAIL_MSG( _T("wrong number of 'y's") );
3096 // strftime() doesn't have era string,
3097 // ignore this format
3098 wxASSERT_MSG( lastCount
<= 2,
3099 _T("too many 'g's") );
3103 wxFAIL_MSG( _T("unreachable") );
3110 // not a special character so must be just a separator,
3112 if ( *p
!= _T('\0') )
3114 if ( *p
== _T('%') )
3116 // this one needs to be escaped
3124 if ( *p
== _T('\0') )
3128 //else: GetLocaleInfo() failed, leave fmtDate value unchanged and
3129 // try our luck with the default formats
3131 //else: default C locale, default formats should work
3136 #endif // __WINDOWS__
3138 const wxChar
*wxDateTime
::ParseFormat(const wxChar
*date
,
3139 const wxString
& format
,
3140 const wxDateTime
& dateDef
)
3142 wxCHECK_MSG( date
&& !format
.empty(), (wxChar
*)NULL
,
3143 _T("NULL pointer in wxDateTime::ParseFormat()") );
3148 // what fields have we found?
3149 bool haveWDay
= false,
3158 bool hourIsIn12hFormat
= false, // or in 24h one?
3159 isPM
= false; // AM by default
3161 // and the value of the items we have (init them to get rid of warnings)
3162 wxDateTime_t sec
= 0,
3165 WeekDay wday
= Inv_WeekDay
;
3166 wxDateTime_t yday
= 0,
3168 wxDateTime
::Month mon
= Inv_Month
;
3171 const wxChar
*input
= date
;
3172 for ( wxString
::const_iterator fmt
= format
.begin(); fmt
!= format
.end(); ++fmt
)
3174 if ( *fmt
!= _T('%') )
3176 if ( wxIsspace(*fmt
) )
3178 // a white space in the format string matches 0 or more white
3179 // spaces in the input
3180 while ( wxIsspace(*input
) )
3187 // any other character (not whitespace, not '%') must be
3188 // matched by itself in the input
3189 if ( *input
++ != *fmt
)
3192 return (wxChar
*)NULL
;
3196 // done with this format char
3200 // start of a format specification
3202 // parse the optional width
3204 while ( wxIsdigit(*++fmt
) )
3207 width
+= *fmt
- _T('0');
3210 // the default widths for the various fields
3213 switch ( (*fmt
).GetValue() )
3215 case _T('Y'): // year has 4 digits
3219 case _T('j'): // day of year has 3 digits
3220 case _T('l'): // milliseconds have 3 digits
3224 case _T('w'): // week day as number has only one
3229 // default for all other fields
3234 // then the format itself
3235 switch ( (*fmt
).GetValue() )
3237 case _T('a'): // a weekday name
3240 int flag
= *fmt
== _T('a') ? Name_Abbr
: Name_Full
;
3241 wday
= GetWeekDayFromName(GetAlphaToken(input
), flag
);
3242 if ( wday
== Inv_WeekDay
)
3245 return (wxChar
*)NULL
;
3251 case _T('b'): // a month name
3254 int flag
= *fmt
== _T('b') ? Name_Abbr
: Name_Full
;
3255 mon
= GetMonthFromName(GetAlphaToken(input
), flag
);
3256 if ( mon
== Inv_Month
)
3259 return (wxChar
*)NULL
;
3265 case _T('c'): // locale default date and time representation
3269 // this is the format which corresponds to ctime() output
3270 // and strptime("%c") should parse it, so try it first
3271 static const wxChar
*fmtCtime
= _T("%a %b %d %H:%M:%S %Y");
3273 const wxChar
*result
= dt
.ParseFormat(input
, fmtCtime
);
3276 result
= dt
.ParseFormat(input
, _T("%x %X"));
3281 result
= dt
.ParseFormat(input
, _T("%X %x"));
3286 // we've tried everything and still no match
3287 return (wxChar
*)NULL
;
3292 haveDay
= haveMon
= haveYear
=
3293 haveHour
= haveMin
= haveSec
= true;
3307 case _T('d'): // day of a month (01-31)
3308 if ( !GetNumericToken(width
, input
, &num
) ||
3309 (num
> 31) || (num
< 1) )
3312 return (wxChar
*)NULL
;
3315 // we can't check whether the day range is correct yet, will
3316 // do it later - assume ok for now
3318 mday
= (wxDateTime_t
)num
;
3321 case _T('H'): // hour in 24h format (00-23)
3322 if ( !GetNumericToken(width
, input
, &num
) || (num
> 23) )
3325 return (wxChar
*)NULL
;
3329 hour
= (wxDateTime_t
)num
;
3332 case _T('I'): // hour in 12h format (01-12)
3333 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 12) )
3336 return (wxChar
*)NULL
;
3340 hourIsIn12hFormat
= true;
3341 hour
= (wxDateTime_t
)(num
% 12); // 12 should be 0
3344 case _T('j'): // day of the year
3345 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 366) )
3348 return (wxChar
*)NULL
;
3352 yday
= (wxDateTime_t
)num
;
3355 case _T('m'): // month as a number (01-12)
3356 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 12) )
3359 return (wxChar
*)NULL
;
3363 mon
= (Month
)(num
- 1);
3366 case _T('M'): // minute as a decimal number (00-59)
3367 if ( !GetNumericToken(width
, input
, &num
) || (num
> 59) )
3370 return (wxChar
*)NULL
;
3374 min
= (wxDateTime_t
)num
;
3377 case _T('p'): // AM or PM string
3379 wxString am
, pm
, token
= GetAlphaToken(input
);
3381 GetAmPmStrings(&am
, &pm
);
3382 if (am
.empty() && pm
.empty())
3383 return (wxChar
*)NULL
; // no am/pm strings defined
3384 if ( token
.CmpNoCase(pm
) == 0 )
3388 else if ( token
.CmpNoCase(am
) != 0 )
3391 return (wxChar
*)NULL
;
3396 case _T('r'): // time as %I:%M:%S %p
3399 input
= dt
.ParseFormat(input
, _T("%I:%M:%S %p"));
3403 return (wxChar
*)NULL
;
3406 haveHour
= haveMin
= haveSec
= true;
3415 case _T('R'): // time as %H:%M
3418 input
= dt
.ParseFormat(input
, _T("%H:%M"));
3422 return (wxChar
*)NULL
;
3425 haveHour
= haveMin
= true;
3433 case _T('S'): // second as a decimal number (00-61)
3434 if ( !GetNumericToken(width
, input
, &num
) || (num
> 61) )
3437 return (wxChar
*)NULL
;
3441 sec
= (wxDateTime_t
)num
;
3444 case _T('T'): // time as %H:%M:%S
3447 input
= dt
.ParseFormat(input
, _T("%H:%M:%S"));
3451 return (wxChar
*)NULL
;
3454 haveHour
= haveMin
= haveSec
= true;
3463 case _T('w'): // weekday as a number (0-6), Sunday = 0
3464 if ( !GetNumericToken(width
, input
, &num
) || (wday
> 6) )
3467 return (wxChar
*)NULL
;
3471 wday
= (WeekDay
)num
;
3474 case _T('x'): // locale default date representation
3475 #ifdef HAVE_STRPTIME
3476 // try using strptime() -- it may fail even if the input is
3477 // correct but the date is out of range, so we will fall back
3478 // to our generic code anyhow
3482 const wxChar
*result
= CallStrptime(input
, "%x", &tm
);
3487 haveDay
= haveMon
= haveYear
= true;
3489 year
= 1900 + tm
.tm_year
;
3490 mon
= (Month
)tm
.tm_mon
;
3496 #endif // HAVE_STRPTIME
3504 // The above doesn't work for all locales, try to query
3505 // Windows for the right way of formatting the date:
3506 fmtDate
= GetLocaleDateFormat();
3507 if ( fmtDate
.empty() )
3510 if ( IsWestEuropeanCountry(GetCountry()) ||
3511 GetCountry() == Russia
)
3513 fmtDate
= _T("%d/%m/%y");
3514 fmtDateAlt
= _T("%m/%d/%y");
3518 fmtDate
= _T("%m/%d/%y");
3519 fmtDateAlt
= _T("%d/%m/%y");
3523 const wxChar
*result
= dt
.ParseFormat(input
, fmtDate
);
3525 if ( !result
&& !fmtDateAlt
.empty() )
3527 // ok, be nice and try another one
3528 result
= dt
.ParseFormat(input
, fmtDateAlt
);
3534 return (wxChar
*)NULL
;
3539 haveDay
= haveMon
= haveYear
= true;
3550 case _T('X'): // locale default time representation
3551 #ifdef HAVE_STRPTIME
3553 // use strptime() to do it for us (FIXME !Unicode friendly)
3555 input
= CallStrptime(input
, "%X", &tm
);
3558 return (wxChar
*)NULL
;
3561 haveHour
= haveMin
= haveSec
= true;
3567 #else // !HAVE_STRPTIME
3568 // TODO under Win32 we can query the LOCALE_ITIME system
3569 // setting which says whether the default time format is
3572 // try to parse what follows as "%H:%M:%S" and, if this
3573 // fails, as "%I:%M:%S %p" - this should catch the most
3577 const wxChar
*result
= dt
.ParseFormat(input
, _T("%T"));
3580 result
= dt
.ParseFormat(input
, _T("%r"));
3586 return (wxChar
*)NULL
;
3589 haveHour
= haveMin
= haveSec
= true;
3598 #endif // HAVE_STRPTIME/!HAVE_STRPTIME
3601 case _T('y'): // year without century (00-99)
3602 if ( !GetNumericToken(width
, input
, &num
) || (num
> 99) )
3605 return (wxChar
*)NULL
;
3610 // TODO should have an option for roll over date instead of
3611 // hard coding it here
3612 year
= (num
> 30 ?
1900 : 2000) + (wxDateTime_t
)num
;
3615 case _T('Y'): // year with century
3616 if ( !GetNumericToken(width
, input
, &num
) )
3619 return (wxChar
*)NULL
;
3623 year
= (wxDateTime_t
)num
;
3626 case _T('Z'): // timezone name
3627 wxFAIL_MSG(_T("TODO"));
3630 case _T('%'): // a percent sign
3631 if ( *input
++ != _T('%') )
3634 return (wxChar
*)NULL
;
3638 case 0: // the end of string
3639 wxFAIL_MSG(_T("unexpected format end"));
3643 default: // not a known format spec
3644 return (wxChar
*)NULL
;
3648 // format matched, try to construct a date from what we have now
3650 if ( dateDef
.IsValid() )
3652 // take this date as default
3653 tmDef
= dateDef
.GetTm();
3655 else if ( IsValid() )
3657 // if this date is valid, don't change it
3662 // no default and this date is invalid - fall back to Today()
3663 tmDef
= Today().GetTm();
3674 // TODO we don't check here that the values are consistent, if both year
3675 // day and month/day were found, we just ignore the year day and we
3676 // also always ignore the week day
3677 if ( haveMon
&& haveDay
)
3679 if ( mday
> GetNumOfDaysInMonth(tm
.year
, mon
) )
3681 wxLogDebug(_T("bad month day in wxDateTime::ParseFormat"));
3683 return (wxChar
*)NULL
;
3689 else if ( haveYDay
)
3691 if ( yday
> GetNumberOfDays(tm
.year
) )
3693 wxLogDebug(_T("bad year day in wxDateTime::ParseFormat"));
3695 return (wxChar
*)NULL
;
3698 Tm tm2
= wxDateTime(1, Jan
, tm
.year
).SetToYearDay(yday
).GetTm();
3705 if ( haveHour
&& hourIsIn12hFormat
&& isPM
)
3707 // translate to 24hour format
3710 //else: either already in 24h format or no translation needed
3730 // finally check that the week day is consistent -- if we had it
3731 if ( haveWDay
&& GetWeekDay() != wday
)
3733 wxLogDebug(_T("inconsistsnet week day in wxDateTime::ParseFormat()"));
3741 const wxChar
*wxDateTime
::ParseDateTime(const wxChar
*date
)
3743 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3745 // Set to current day and hour, so strings like '14:00' becomes today at
3746 // 14, not some other random date
3747 wxDateTime dtDate
= wxDateTime
::Today();
3748 wxDateTime dtTime
= wxDateTime
::Today();
3750 const wxChar
* pchTime
;
3752 // Try to parse the beginning of the string as a date
3753 const wxChar
* pchDate
= dtDate
.ParseDate(date
);
3755 // We got a date in the beginning, see if there is a time specified after the date
3758 // Skip spaces, as the ParseTime() function fails on spaces
3759 while ( wxIsspace(*pchDate
) )
3762 pchTime
= dtTime
.ParseTime(pchDate
);
3764 else // no date in the beginning
3766 // check and see if we have a time followed by a date
3767 pchTime
= dtTime
.ParseTime(date
);
3770 while ( wxIsspace(*pchTime
) )
3773 pchDate
= dtDate
.ParseDate(pchTime
);
3777 // If we have a date specified, set our own data to the same date
3778 if ( !pchDate
|| !pchTime
)
3781 Set(dtDate
.GetDay(), dtDate
.GetMonth(), dtDate
.GetYear(),
3782 dtTime
.GetHour(), dtTime
.GetMinute(), dtTime
.GetSecond(),
3783 dtTime
.GetMillisecond());
3785 // Return endpoint of scan
3786 return pchDate
> pchTime ? pchDate
: pchTime
;
3789 const wxChar
*wxDateTime
::ParseDate(const wxChar
*date
)
3791 // this is a simplified version of ParseDateTime() which understands only
3792 // "today" (for wxDate compatibility) and digits only otherwise (and not
3793 // all esoteric constructions ParseDateTime() knows about)
3795 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3797 const wxChar
*p
= date
;
3798 while ( wxIsspace(*p
) )
3801 // some special cases
3805 int dayDiffFromToday
;
3808 { wxTRANSLATE("today"), 0 },
3809 { wxTRANSLATE("yesterday"), -1 },
3810 { wxTRANSLATE("tomorrow"), 1 },
3813 for ( size_t n
= 0; n
< WXSIZEOF(literalDates
); n
++ )
3815 const wxString dateStr
= wxGetTranslation(literalDates
[n
].str
);
3816 size_t len
= dateStr
.length();
3817 if ( wxStrlen(p
) >= len
)
3819 wxString
str(p
, len
);
3820 if ( str
.CmpNoCase(dateStr
) == 0 )
3822 // nothing can follow this, so stop here
3825 int dayDiffFromToday
= literalDates
[n
].dayDiffFromToday
;
3827 if ( dayDiffFromToday
)
3829 *this += wxDateSpan
::Days(dayDiffFromToday
);
3837 // We try to guess what we have here: for each new (numeric) token, we
3838 // determine if it can be a month, day or a year. Of course, there is an
3839 // ambiguity as some numbers may be days as well as months, so we also
3840 // have the ability to back track.
3843 bool haveDay
= false, // the months day?
3844 haveWDay
= false, // the day of week?
3845 haveMon
= false, // the month?
3846 haveYear
= false; // the year?
3848 // and the value of the items we have (init them to get rid of warnings)
3849 WeekDay wday
= Inv_WeekDay
;
3850 wxDateTime_t day
= 0;
3851 wxDateTime
::Month mon
= Inv_Month
;
3854 // tokenize the string
3856 static const wxChar
*dateDelimiters
= _T(".,/-\t\r\n ");
3857 wxStringTokenizer
tok(p
, dateDelimiters
);
3858 while ( tok
.HasMoreTokens() )
3860 wxString token
= tok
.GetNextToken();
3866 if ( token
.ToULong(&val
) )
3868 // guess what this number is
3874 if ( !haveMon
&& val
> 0 && val
<= 12 )
3876 // assume it is month
3879 else // not the month
3883 // this can only be the year
3886 else // may be either day or year
3888 // use a leap year if we don't have the year yet to allow
3889 // dates like 2/29/1976 which would be rejected otherwise
3890 wxDateTime_t max_days
= (wxDateTime_t
)(
3892 ?
GetNumOfDaysInMonth(haveYear ? year
: 1976, mon
)
3897 if ( (val
== 0) || (val
> (unsigned long)max_days
) )
3902 else // yes, suppose it's the day
3916 year
= (wxDateTime_t
)val
;
3925 day
= (wxDateTime_t
)val
;
3931 mon
= (Month
)(val
- 1);
3934 else // not a number
3936 // be careful not to overwrite the current mon value
3937 Month mon2
= GetMonthFromName(token
, Name_Full
| Name_Abbr
);
3938 if ( mon2
!= Inv_Month
)
3943 // but we already have a month - maybe we guessed wrong?
3946 // no need to check in month range as always < 12, but
3947 // the days are counted from 1 unlike the months
3948 day
= (wxDateTime_t
)(mon
+ 1);
3953 // could possible be the year (doesn't the year come
3954 // before the month in the japanese format?) (FIXME)
3963 else // not a valid month name
3965 wday
= GetWeekDayFromName(token
, Name_Full
| Name_Abbr
);
3966 if ( wday
!= Inv_WeekDay
)
3976 else // not a valid weekday name
3979 static const char *ordinals
[] =
3981 wxTRANSLATE("first"),
3982 wxTRANSLATE("second"),
3983 wxTRANSLATE("third"),
3984 wxTRANSLATE("fourth"),
3985 wxTRANSLATE("fifth"),
3986 wxTRANSLATE("sixth"),
3987 wxTRANSLATE("seventh"),
3988 wxTRANSLATE("eighth"),
3989 wxTRANSLATE("ninth"),
3990 wxTRANSLATE("tenth"),
3991 wxTRANSLATE("eleventh"),
3992 wxTRANSLATE("twelfth"),
3993 wxTRANSLATE("thirteenth"),
3994 wxTRANSLATE("fourteenth"),
3995 wxTRANSLATE("fifteenth"),
3996 wxTRANSLATE("sixteenth"),
3997 wxTRANSLATE("seventeenth"),
3998 wxTRANSLATE("eighteenth"),
3999 wxTRANSLATE("nineteenth"),
4000 wxTRANSLATE("twentieth"),
4001 // that's enough - otherwise we'd have problems with
4002 // composite (or not) ordinals
4006 for ( n
= 0; n
< WXSIZEOF(ordinals
); n
++ )
4008 if ( token
.CmpNoCase(ordinals
[n
]) == 0 )
4014 if ( n
== WXSIZEOF(ordinals
) )
4016 // stop here - something unknown
4023 // don't try anything here (as in case of numeric day
4024 // above) - the symbolic day spec should always
4025 // precede the month/year
4031 day
= (wxDateTime_t
)(n
+ 1);
4036 nPosCur
= tok
.GetPosition();
4039 // either no more tokens or the scan was stopped by something we couldn't
4040 // parse - in any case, see if we can construct a date from what we have
4041 if ( !haveDay
&& !haveWDay
)
4043 wxLogDebug(_T("ParseDate: no day, no weekday hence no date."));
4048 if ( haveWDay
&& (haveMon
|| haveYear
|| haveDay
) &&
4049 !(haveDay
&& haveMon
&& haveYear
) )
4051 // without adjectives (which we don't support here) the week day only
4052 // makes sense completely separately or with the full date
4053 // specification (what would "Wed 1999" mean?)
4057 if ( !haveWDay
&& haveYear
&& !(haveDay
&& haveMon
) )
4059 // may be we have month and day instead of day and year?
4060 if ( haveDay
&& !haveMon
)
4064 // exchange day and month
4065 mon
= (wxDateTime
::Month
)(day
- 1);
4067 // we're in the current year then
4068 if ( (year
> 0) && (year
<= (int)GetNumOfDaysInMonth(Inv_Year
, mon
)) )
4070 day
= (wxDateTime_t
)year
;
4075 //else: no, can't exchange, leave haveMon == false
4081 // if we give the year, month and day must be given too
4082 wxLogDebug(_T("ParseDate: day and month should be specified if year is."));
4090 mon
= GetCurrentMonth();
4095 year
= GetCurrentYear();
4100 // normally we check the day above but the check is optimistic in case
4101 // we find the day before its month/year so we have to redo it now
4102 if ( day
> GetNumOfDaysInMonth(year
, mon
) )
4105 Set(day
, mon
, year
);
4109 // check that it is really the same
4110 if ( GetWeekDay() != wday
)
4112 // inconsistency detected
4113 wxLogDebug(_T("ParseDate: inconsistent day/weekday."));
4115 return (wxChar
*)NULL
;
4123 SetToWeekDayInSameWeek(wday
);
4126 // return the pointer to the first unparsed char
4128 if ( nPosCur
&& wxStrchr(dateDelimiters
, *(p
- 1)) )
4130 // if we couldn't parse the token after the delimiter, put back the
4131 // delimiter as well
4138 const wxChar
*wxDateTime
::ParseTime(const wxChar
*time
)
4140 wxCHECK_MSG( time
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
4142 // first try some extra things
4149 { wxTRANSLATE("noon"), 12 },
4150 { wxTRANSLATE("midnight"), 00 },
4154 for ( size_t n
= 0; n
< WXSIZEOF(stdTimes
); n
++ )
4156 wxString timeString
= wxGetTranslation(stdTimes
[n
].name
);
4157 size_t len
= timeString
.length();
4158 if ( timeString
.CmpNoCase(wxString(time
, len
)) == 0 )
4160 // casts required by DigitalMars
4161 Set(stdTimes
[n
].hour
, wxDateTime_t(0), wxDateTime_t(0));
4167 // try all time formats we may think about in the order from longest to
4170 // 12hour with AM/PM?
4171 const wxChar
*result
= ParseFormat(time
, _T("%I:%M:%S %p"));
4175 // normally, it's the same, but why not try it?
4176 result
= ParseFormat(time
, _T("%H:%M:%S"));
4181 // 12hour with AM/PM but without seconds?
4182 result
= ParseFormat(time
, _T("%I:%M %p"));
4188 result
= ParseFormat(time
, _T("%H:%M"));
4193 // just the hour and AM/PM?
4194 result
= ParseFormat(time
, _T("%I %p"));
4200 result
= ParseFormat(time
, _T("%H"));
4205 // parse the standard format: normally it is one of the formats above
4206 // but it may be set to something completely different by the user
4207 result
= ParseFormat(time
, _T("%X"));
4210 // TODO: parse timezones
4215 // ----------------------------------------------------------------------------
4216 // Workdays and holidays support
4217 // ----------------------------------------------------------------------------
4219 bool wxDateTime
::IsWorkDay(Country
WXUNUSED(country
)) const
4221 return !wxDateTimeHolidayAuthority
::IsHoliday(*this);
4224 // ============================================================================
4226 // ============================================================================
4228 wxDateSpan WXDLLIMPEXP_BASE
operator*(int n
, const wxDateSpan
& ds
)
4231 return ds1
.Multiply(n
);
4234 // ============================================================================
4236 // ============================================================================
4238 wxTimeSpan WXDLLIMPEXP_BASE
operator*(int n
, const wxTimeSpan
& ts
)
4240 return wxTimeSpan(ts
).Multiply(n
);
4243 // this enum is only used in wxTimeSpan::Format() below but we can't declare
4244 // it locally to the method as it provokes an internal compiler error in egcs
4245 // 2.91.60 when building with -O2
4256 // not all strftime(3) format specifiers make sense here because, for example,
4257 // a time span doesn't have a year nor a timezone
4259 // Here are the ones which are supported (all of them are supported by strftime
4261 // %H hour in 24 hour format
4262 // %M minute (00 - 59)
4263 // %S second (00 - 59)
4266 // Also, for MFC CTimeSpan compatibility, we support
4267 // %D number of days
4269 // And, to be better than MFC :-), we also have
4270 // %E number of wEeks
4271 // %l milliseconds (000 - 999)
4272 wxString wxTimeSpan
::Format(const wxString
& format
) const
4274 wxCHECK_MSG( !format
.empty(), wxEmptyString
,
4275 _T("NULL format in wxTimeSpan::Format") );
4278 str
.Alloc(format
.length());
4280 // Suppose we have wxTimeSpan ts(1 /* hour */, 2 /* min */, 3 /* sec */)
4282 // Then, of course, ts.Format("%H:%M:%S") must return "01:02:03", but the
4283 // question is what should ts.Format("%S") do? The code here returns "3273"
4284 // in this case (i.e. the total number of seconds, not just seconds % 60)
4285 // because, for me, this call means "give me entire time interval in
4286 // seconds" and not "give me the seconds part of the time interval"
4288 // If we agree that it should behave like this, it is clear that the
4289 // interpretation of each format specifier depends on the presence of the
4290 // other format specs in the string: if there was "%H" before "%M", we
4291 // should use GetMinutes() % 60, otherwise just GetMinutes() &c
4293 // we remember the most important unit found so far
4294 TimeSpanPart partBiggest
= Part_MSec
;
4296 for ( wxString
::const_iterator pch
= format
.begin(); pch
!= format
.end(); ++pch
)
4300 if ( ch
== _T('%') )
4302 // the start of the format specification of the printf() below
4303 wxString
fmtPrefix(_T('%'));
4308 // the number of digits for the format string, 0 if unused
4309 unsigned digits
= 0;
4311 ch
= *++pch
; // get the format spec char
4315 wxFAIL_MSG( _T("invalid format character") );
4321 // skip the part below switch
4326 if ( partBiggest
< Part_Day
)
4332 partBiggest
= Part_Day
;
4337 partBiggest
= Part_Week
;
4343 if ( partBiggest
< Part_Hour
)
4347 // the sign has already been taken into account
4348 // when outputting the biggest part
4356 partBiggest
= Part_Hour
;
4363 n
= GetMilliseconds().ToLong();
4364 if ( partBiggest
< Part_MSec
)
4371 //else: no need to reset partBiggest to Part_MSec, it is
4372 // the least significant one anyhow
4379 if ( partBiggest
< Part_Min
)
4388 partBiggest
= Part_Min
;
4395 n
= GetSeconds().ToLong();
4396 if ( partBiggest
< Part_Sec
)
4405 partBiggest
= Part_Sec
;
4414 // negative numbers need one extra position for '-' display
4418 fmtPrefix
<< _T("0") << digits
;
4421 str
+= wxString
::Format(fmtPrefix
+ _T("ld"), n
);
4425 // normal character, just copy
4433 // ============================================================================
4434 // wxDateTimeHolidayAuthority and related classes
4435 // ============================================================================
4437 #include "wx/arrimpl.cpp"
4439 WX_DEFINE_OBJARRAY(wxDateTimeArray
)
4441 static int wxCMPFUNC_CONV
4442 wxDateTimeCompareFunc(wxDateTime
**first
, wxDateTime
**second
)
4444 wxDateTime dt1
= **first
,
4447 return dt1
== dt2 ?
0 : dt1
< dt2 ?
-1 : +1;
4450 // ----------------------------------------------------------------------------
4451 // wxDateTimeHolidayAuthority
4452 // ----------------------------------------------------------------------------
4454 wxHolidayAuthoritiesArray wxDateTimeHolidayAuthority
::ms_authorities
;
4457 bool wxDateTimeHolidayAuthority
::IsHoliday(const wxDateTime
& dt
)
4459 size_t count
= ms_authorities
.size();
4460 for ( size_t n
= 0; n
< count
; n
++ )
4462 if ( ms_authorities
[n
]->DoIsHoliday(dt
) )
4473 wxDateTimeHolidayAuthority
::GetHolidaysInRange(const wxDateTime
& dtStart
,
4474 const wxDateTime
& dtEnd
,
4475 wxDateTimeArray
& holidays
)
4477 wxDateTimeArray hol
;
4481 const size_t countAuth
= ms_authorities
.size();
4482 for ( size_t nAuth
= 0; nAuth
< countAuth
; nAuth
++ )
4484 ms_authorities
[nAuth
]->DoGetHolidaysInRange(dtStart
, dtEnd
, hol
);
4486 WX_APPEND_ARRAY(holidays
, hol
);
4489 holidays
.Sort(wxDateTimeCompareFunc
);
4491 return holidays
.size();
4495 void wxDateTimeHolidayAuthority
::ClearAllAuthorities()
4497 WX_CLEAR_ARRAY(ms_authorities
);
4501 void wxDateTimeHolidayAuthority
::AddAuthority(wxDateTimeHolidayAuthority
*auth
)
4503 ms_authorities
.push_back(auth
);
4506 wxDateTimeHolidayAuthority
::~wxDateTimeHolidayAuthority()
4508 // required here for Darwin
4511 // ----------------------------------------------------------------------------
4512 // wxDateTimeWorkDays
4513 // ----------------------------------------------------------------------------
4515 bool wxDateTimeWorkDays
::DoIsHoliday(const wxDateTime
& dt
) const
4517 wxDateTime
::WeekDay wd
= dt
.GetWeekDay();
4519 return (wd
== wxDateTime
::Sun
) || (wd
== wxDateTime
::Sat
);
4522 size_t wxDateTimeWorkDays
::DoGetHolidaysInRange(const wxDateTime
& dtStart
,
4523 const wxDateTime
& dtEnd
,
4524 wxDateTimeArray
& holidays
) const
4526 if ( dtStart
> dtEnd
)
4528 wxFAIL_MSG( _T("invalid date range in GetHolidaysInRange") );
4535 // instead of checking all days, start with the first Sat after dtStart and
4536 // end with the last Sun before dtEnd
4537 wxDateTime dtSatFirst
= dtStart
.GetNextWeekDay(wxDateTime
::Sat
),
4538 dtSatLast
= dtEnd
.GetPrevWeekDay(wxDateTime
::Sat
),
4539 dtSunFirst
= dtStart
.GetNextWeekDay(wxDateTime
::Sun
),
4540 dtSunLast
= dtEnd
.GetPrevWeekDay(wxDateTime
::Sun
),
4543 for ( dt
= dtSatFirst
; dt
<= dtSatLast
; dt
+= wxDateSpan
::Week() )
4548 for ( dt
= dtSunFirst
; dt
<= dtSunLast
; dt
+= wxDateSpan
::Week() )
4553 return holidays
.GetCount();
4556 // ============================================================================
4557 // other helper functions
4558 // ============================================================================
4560 // ----------------------------------------------------------------------------
4561 // iteration helpers: can be used to write a for loop over enum variable like
4563 // for ( m = wxDateTime::Jan; m < wxDateTime::Inv_Month; wxNextMonth(m) )
4564 // ----------------------------------------------------------------------------
4566 WXDLLIMPEXP_BASE
void wxNextMonth(wxDateTime
::Month
& m
)
4568 wxASSERT_MSG( m
< wxDateTime
::Inv_Month
, _T("invalid month") );
4570 // no wrapping or the for loop above would never end!
4571 m
= (wxDateTime
::Month
)(m
+ 1);
4574 WXDLLIMPEXP_BASE
void wxPrevMonth(wxDateTime
::Month
& m
)
4576 wxASSERT_MSG( m
< wxDateTime
::Inv_Month
, _T("invalid month") );
4578 m
= m
== wxDateTime
::Jan ? wxDateTime
::Inv_Month
4579 : (wxDateTime
::Month
)(m
- 1);
4582 WXDLLIMPEXP_BASE
void wxNextWDay(wxDateTime
::WeekDay
& wd
)
4584 wxASSERT_MSG( wd
< wxDateTime
::Inv_WeekDay
, _T("invalid week day") );
4586 // no wrapping or the for loop above would never end!
4587 wd
= (wxDateTime
::WeekDay
)(wd
+ 1);
4590 WXDLLIMPEXP_BASE
void wxPrevWDay(wxDateTime
::WeekDay
& wd
)
4592 wxASSERT_MSG( wd
< wxDateTime
::Inv_WeekDay
, _T("invalid week day") );
4594 wd
= wd
== wxDateTime
::Sun ? wxDateTime
::Inv_WeekDay
4595 : (wxDateTime
::WeekDay
)(wd
- 1);
4598 #endif // wxUSE_DATETIME