1 ///////////////////////////////////////////////////////////////////////////////
3 // Purpose: implementation of time/date related classes
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // parts of code taken from sndcal library by Scott E. Lee:
11 // Copyright 1993-1995, Scott E. Lee, all rights reserved.
12 // Permission granted to use, copy, modify, distribute and sell
13 // so long as the above copyright and this permission statement
14 // are retained in all copies.
16 // Licence: wxWindows licence
17 ///////////////////////////////////////////////////////////////////////////////
19 // TODO: for $DEITY sake, someone please fix the #ifdef __WXWINCE__ everywhere,
20 // the proper way to do it is to implement (subset of) wxStrftime() for
21 // CE instead of this horror!!
24 * Implementation notes:
26 * 1. the time is stored as a 64bit integer containing the signed number of
27 * milliseconds since Jan 1. 1970 (the Unix Epoch) - so it is always
30 * 2. the range is thus something about 580 million years, but due to current
31 * algorithms limitations, only dates from Nov 24, 4714BC are handled
33 * 3. standard ANSI C functions are used to do time calculations whenever
34 * possible, i.e. when the date is in the range Jan 1, 1970 to 2038
36 * 4. otherwise, the calculations are done by converting the date to/from JDN
37 * first (the range limitation mentioned above comes from here: the
38 * algorithm used by Scott E. Lee's code only works for positive JDNs, more
41 * 5. the object constructed for the given DD-MM-YYYY HH:MM:SS corresponds to
42 * this moment in local time and may be converted to the object
43 * corresponding to the same date/time in another time zone by using
46 * 6. the conversions to the current (or any other) timezone are done when the
47 * internal time representation is converted to the broken-down one in
51 // ============================================================================
53 // ============================================================================
55 // ----------------------------------------------------------------------------
57 // ----------------------------------------------------------------------------
59 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
60 #pragma implementation "datetime.h"
63 // For compilers that support precompilation, includes "wx.h".
64 #include "wx/wxprec.h"
70 #if !defined(wxUSE_DATETIME) || wxUSE_DATETIME
73 #include "wx/string.h"
78 #include "wx/thread.h"
79 #include "wx/tokenzr.h"
80 #include "wx/module.h"
85 #include "wx/msw/wrapwin.h"
92 #include "wx/datetime.h"
93 #include "wx/stopwatch.h" // for wxGetLocalTimeMillis()
95 const long wxDateTime::TIME_T_FACTOR
= 1000l;
97 #if wxUSE_EXTENDED_RTTI
99 template<> void wxStringReadValue(const wxString
&s
, wxDateTime
&data
)
101 data
.ParseFormat(s
,wxT("%Y-%m-%d %H:%M:%S")) ;
104 template<> void wxStringWriteValue(wxString
&s
, const wxDateTime
&data
)
106 s
= data
.Format(wxT("%Y-%m-%d %H:%M:%S")) ;
109 wxCUSTOM_TYPE_INFO(wxDateTime
, wxToStringConverter
<wxDateTime
> , wxFromStringConverter
<wxDateTime
>)
114 // ----------------------------------------------------------------------------
115 // conditional compilation
116 // ----------------------------------------------------------------------------
118 #if defined(HAVE_STRPTIME) && defined(__GLIBC__) && \
119 ((__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0))
120 // glibc 2.0.7 strptime() is broken - the following snippet causes it to
121 // crash (instead of just failing):
123 // strncpy(buf, "Tue Dec 21 20:25:40 1999", 128);
124 // strptime(buf, "%x", &tm);
128 #endif // broken strptime()
130 #if defined(HAVE_STRPTIME) && defined(__DARWIN__) && defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
131 // configure detects strptime as linkable because it's in the OS X
132 // System library but MSL headers don't declare it.
134 // char *strptime(const char *, const char *, struct tm *);
135 // However, we DON'T want to just provide it here because we would
136 // crash and/or overwrite data when strptime from OS X tries
137 // to fill in MW's struct tm which is two fields shorter (no TZ stuff)
138 // So for now let's just say we don't have strptime
142 #if defined(__MWERKS__) && wxUSE_UNICODE
146 #if !defined(WX_TIMEZONE) && !defined(WX_GMTOFF_IN_TM)
147 #if defined(__WXPALMOS__)
148 #define WX_GMTOFF_IN_TM
149 #elif defined(__BORLANDC__) || defined(__MINGW32__) || defined(__VISAGECPP__)
150 #define WX_TIMEZONE _timezone
151 #elif defined(__MWERKS__)
152 long wxmw_timezone
= 28800;
153 #define WX_TIMEZONE wxmw_timezone
154 #elif defined(__DJGPP__) || defined(__WINE__)
155 #include <sys/timeb.h>
157 static long wxGetTimeZone()
159 static long timezone
= MAXLONG
; // invalid timezone
160 if (timezone
== MAXLONG
)
164 timezone
= tb
.timezone
;
168 #define WX_TIMEZONE wxGetTimeZone()
169 #elif defined(__DARWIN__)
170 #define WX_GMTOFF_IN_TM
171 #else // unknown platform - try timezone
172 #define WX_TIMEZONE timezone
174 #endif // !WX_TIMEZONE && !WX_GMTOFF_IN_TM
176 // ----------------------------------------------------------------------------
178 // ----------------------------------------------------------------------------
180 // debugging helper: just a convenient replacement of wxCHECK()
181 #define wxDATETIME_CHECK(expr, msg) \
185 *this = wxInvalidDateTime; \
189 // ----------------------------------------------------------------------------
191 // ----------------------------------------------------------------------------
193 class wxDateTimeHolidaysModule
: public wxModule
196 virtual bool OnInit()
198 wxDateTimeHolidayAuthority::AddAuthority(new wxDateTimeWorkDays
);
203 virtual void OnExit()
205 wxDateTimeHolidayAuthority::ClearAllAuthorities();
206 wxDateTimeHolidayAuthority::ms_authorities
.clear();
210 DECLARE_DYNAMIC_CLASS(wxDateTimeHolidaysModule
)
213 IMPLEMENT_DYNAMIC_CLASS(wxDateTimeHolidaysModule
, wxModule
)
215 // ----------------------------------------------------------------------------
217 // ----------------------------------------------------------------------------
220 static const int MONTHS_IN_YEAR
= 12;
222 static const int SEC_PER_MIN
= 60;
224 static const int MIN_PER_HOUR
= 60;
226 static const int HOURS_PER_DAY
= 24;
228 static const long SECONDS_PER_DAY
= 86400l;
230 static const int DAYS_PER_WEEK
= 7;
232 static const long MILLISECONDS_PER_DAY
= 86400000l;
234 // this is the integral part of JDN of the midnight of Jan 1, 1970
235 // (i.e. JDN(Jan 1, 1970) = 2440587.5)
236 static const long EPOCH_JDN
= 2440587l;
238 // used only in asserts
240 // the date of JDN -0.5 (as we don't work with fractional parts, this is the
241 // reference date for us) is Nov 24, 4714BC
242 static const int JDN_0_YEAR
= -4713;
243 static const int JDN_0_MONTH
= wxDateTime::Nov
;
244 static const int JDN_0_DAY
= 24;
245 #endif // __WXDEBUG__
247 // the constants used for JDN calculations
248 static const long JDN_OFFSET
= 32046l;
249 static const long DAYS_PER_5_MONTHS
= 153l;
250 static const long DAYS_PER_4_YEARS
= 1461l;
251 static const long DAYS_PER_400_YEARS
= 146097l;
253 // this array contains the cumulated number of days in all previous months for
254 // normal and leap years
255 static const wxDateTime::wxDateTime_t gs_cumulatedDays
[2][MONTHS_IN_YEAR
] =
257 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
258 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
261 // ----------------------------------------------------------------------------
263 // ----------------------------------------------------------------------------
265 const wxChar
* wxDefaultDateTimeFormat
= wxT("%c");
266 const wxChar
* wxDefaultTimeSpanFormat
= wxT("%H:%M:%S");
268 // in the fine tradition of ANSI C we use our equivalent of (time_t)-1 to
269 // indicate an invalid wxDateTime object
270 const wxDateTime wxDefaultDateTime
;
272 wxDateTime::Country
wxDateTime::ms_country
= wxDateTime::Country_Unknown
;
274 // ----------------------------------------------------------------------------
276 // ----------------------------------------------------------------------------
278 // debugger helper: shows what the date really is
280 extern const wxChar
*wxDumpDate(const wxDateTime
* dt
)
282 static wxChar buf
[128];
284 wxStrcpy(buf
, dt
->Format(_T("%Y-%m-%d (%a) %H:%M:%S")));
290 // get the number of days in the given month of the given year
292 wxDateTime::wxDateTime_t
GetNumOfDaysInMonth(int year
, wxDateTime::Month month
)
294 // the number of days in month in Julian/Gregorian calendar: the first line
295 // is for normal years, the second one is for the leap ones
296 static wxDateTime::wxDateTime_t daysInMonth
[2][MONTHS_IN_YEAR
] =
298 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
299 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
302 return daysInMonth
[wxDateTime::IsLeapYear(year
)][month
];
305 // returns the time zone in the C sense, i.e. the difference UTC - local
307 static int GetTimeZone()
309 #ifdef WX_GMTOFF_IN_TM
310 // set to true when the timezone is set
311 static bool s_timezoneSet
= false;
312 static long gmtoffset
= LONG_MAX
; // invalid timezone
314 // ensure that the timezone variable is set by calling localtime
315 if ( !s_timezoneSet
)
317 // just call localtime() instead of figuring out whether this system
318 // supports tzset(), _tzset() or something else
323 s_timezoneSet
= true;
325 // note that GMT offset is the opposite of time zone and so to return
326 // consistent results in both WX_GMTOFF_IN_TM and !WX_GMTOFF_IN_TM
327 // cases we have to negate it
328 gmtoffset
= -tm
->tm_gmtoff
;
331 return (int)gmtoffset
;
332 #else // !WX_GMTOFF_IN_TM
333 return (int)WX_TIMEZONE
;
334 #endif // WX_GMTOFF_IN_TM/!WX_GMTOFF_IN_TM
337 // return the integral part of the JDN for the midnight of the given date (to
338 // get the real JDN you need to add 0.5, this is, in fact, JDN of the
339 // noon of the previous day)
340 static long GetTruncatedJDN(wxDateTime::wxDateTime_t day
,
341 wxDateTime::Month mon
,
344 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
346 // check the date validity
348 (year
> JDN_0_YEAR
) ||
349 ((year
== JDN_0_YEAR
) && (mon
> JDN_0_MONTH
)) ||
350 ((year
== JDN_0_YEAR
) && (mon
== JDN_0_MONTH
) && (day
>= JDN_0_DAY
)),
351 _T("date out of range - can't convert to JDN")
354 // make the year positive to avoid problems with negative numbers division
357 // months are counted from March here
359 if ( mon
>= wxDateTime::Mar
)
369 // now we can simply add all the contributions together
370 return ((year
/ 100) * DAYS_PER_400_YEARS
) / 4
371 + ((year
% 100) * DAYS_PER_4_YEARS
) / 4
372 + (month
* DAYS_PER_5_MONTHS
+ 2) / 5
378 // this function is a wrapper around strftime(3) adding error checking
379 static wxString
CallStrftime(const wxChar
*format
, const tm
* tm
)
382 // Create temp wxString here to work around mingw/cygwin bug 1046059
383 // http://sourceforge.net/tracker/?func=detail&atid=102435&aid=1046059&group_id=2435
386 if ( !wxStrftime(buf
, WXSIZEOF(buf
), format
, tm
) )
388 // buffer is too small?
389 wxFAIL_MSG(_T("strftime() failed"));
399 // glibc2 doesn't define this in the headers unless _XOPEN_SOURCE is defined
400 // which, unfortunately, wreaks havoc elsewhere
401 #if defined(__GLIBC__) && (__GLIBC__ == 2)
402 extern "C" char *strptime(const char *, const char *, struct tm
*);
405 // Unicode-friendly strptime() wrapper
406 static const wxChar
*
407 CallStrptime(const wxChar
*input
, const char *fmt
, tm
*tm
)
409 // the problem here is that strptime() returns pointer into the string we
410 // passed to it while we're really interested in the pointer into the
411 // original, Unicode, string so we try to transform the pointer back
413 wxCharBuffer
inputMB(wxConvertWX2MB(input
));
415 const char * const inputMB
= input
;
416 #endif // Unicode/Ascii
418 const char *result
= strptime(inputMB
, fmt
, tm
);
423 // FIXME: this is wrong in presence of surrogates &c
424 return input
+ (result
- inputMB
.data());
427 #endif // Unicode/Ascii
430 #endif // HAVE_STRPTIME
432 // if year and/or month have invalid values, replace them with the current ones
433 static void ReplaceDefaultYearMonthWithCurrent(int *year
,
434 wxDateTime::Month
*month
)
436 struct tm
*tmNow
= NULL
;
438 if ( *year
== wxDateTime::Inv_Year
)
440 tmNow
= wxDateTime::GetTmNow();
442 *year
= 1900 + tmNow
->tm_year
;
445 if ( *month
== wxDateTime::Inv_Month
)
448 tmNow
= wxDateTime::GetTmNow();
450 *month
= (wxDateTime::Month
)tmNow
->tm_mon
;
454 // fll the struct tm with default values
455 static void InitTm(struct tm
& tm
)
457 // struct tm may have etxra fields (undocumented and with unportable
458 // names) which, nevertheless, must be set to 0
459 memset(&tm
, 0, sizeof(struct tm
));
461 tm
.tm_mday
= 1; // mday 0 is invalid
462 tm
.tm_year
= 76; // any valid year
463 tm
.tm_isdst
= -1; // auto determine
469 // return the month if the string is a month name or Inv_Month otherwise
470 static wxDateTime::Month
GetMonthFromName(const wxString
& name
, int flags
)
472 wxDateTime::Month mon
;
473 for ( mon
= wxDateTime::Jan
; mon
< wxDateTime::Inv_Month
; wxNextMonth(mon
) )
475 // case-insensitive comparison either one of or with both abbreviated
477 if ( flags
& wxDateTime::Name_Full
)
479 if ( name
.CmpNoCase(wxDateTime::
480 GetMonthName(mon
, wxDateTime::Name_Full
)) == 0 )
486 if ( flags
& wxDateTime::Name_Abbr
)
488 if ( name
.CmpNoCase(wxDateTime::
489 GetMonthName(mon
, wxDateTime::Name_Abbr
)) == 0 )
499 // return the weekday if the string is a weekday name or Inv_WeekDay otherwise
500 static wxDateTime::WeekDay
GetWeekDayFromName(const wxString
& name
, int flags
)
502 wxDateTime::WeekDay wd
;
503 for ( wd
= wxDateTime::Sun
; wd
< wxDateTime::Inv_WeekDay
; wxNextWDay(wd
) )
505 // case-insensitive comparison either one of or with both abbreviated
507 if ( flags
& wxDateTime::Name_Full
)
509 if ( name
.CmpNoCase(wxDateTime::
510 GetWeekDayName(wd
, wxDateTime::Name_Full
)) == 0 )
516 if ( flags
& wxDateTime::Name_Abbr
)
518 if ( name
.CmpNoCase(wxDateTime::
519 GetWeekDayName(wd
, wxDateTime::Name_Abbr
)) == 0 )
529 // scans all digits (but no more than len) and returns the resulting number
530 static bool GetNumericToken(size_t len
, const wxChar
*& p
, unsigned long *number
)
534 while ( wxIsdigit(*p
) )
538 if ( len
&& ++n
> len
)
542 return !s
.empty() && s
.ToULong(number
);
545 // scans all alphabetic characters and returns the resulting string
546 static wxString
GetAlphaToken(const wxChar
*& p
)
549 while ( wxIsalpha(*p
) )
557 // ============================================================================
558 // implementation of wxDateTime
559 // ============================================================================
561 // ----------------------------------------------------------------------------
563 // ----------------------------------------------------------------------------
567 year
= (wxDateTime_t
)wxDateTime::Inv_Year
;
568 mon
= wxDateTime::Inv_Month
;
570 hour
= min
= sec
= msec
= 0;
571 wday
= wxDateTime::Inv_WeekDay
;
574 wxDateTime::Tm::Tm(const struct tm
& tm
, const TimeZone
& tz
)
578 sec
= (wxDateTime::wxDateTime_t
)tm
.tm_sec
;
579 min
= (wxDateTime::wxDateTime_t
)tm
.tm_min
;
580 hour
= (wxDateTime::wxDateTime_t
)tm
.tm_hour
;
581 mday
= (wxDateTime::wxDateTime_t
)tm
.tm_mday
;
582 mon
= (wxDateTime::Month
)tm
.tm_mon
;
583 year
= 1900 + tm
.tm_year
;
584 wday
= (wxDateTime::wxDateTime_t
)tm
.tm_wday
;
585 yday
= (wxDateTime::wxDateTime_t
)tm
.tm_yday
;
588 bool wxDateTime::Tm::IsValid() const
590 // we allow for the leap seconds, although we don't use them (yet)
591 return (year
!= wxDateTime::Inv_Year
) && (mon
!= wxDateTime::Inv_Month
) &&
592 (mday
<= GetNumOfDaysInMonth(year
, mon
)) &&
593 (hour
< 24) && (min
< 60) && (sec
< 62) && (msec
< 1000);
596 void wxDateTime::Tm::ComputeWeekDay()
598 // compute the week day from day/month/year: we use the dumbest algorithm
599 // possible: just compute our JDN and then use the (simple to derive)
600 // formula: weekday = (JDN + 1.5) % 7
601 wday
= (wxDateTime::wxDateTime_t
)((wxDateTime::WeekDay
)(GetTruncatedJDN(mday
, mon
, year
) + 2) % 7);
604 void wxDateTime::Tm::AddMonths(int monDiff
)
606 // normalize the months field
607 while ( monDiff
< -mon
)
611 monDiff
+= MONTHS_IN_YEAR
;
614 while ( monDiff
+ mon
>= MONTHS_IN_YEAR
)
618 monDiff
-= MONTHS_IN_YEAR
;
621 mon
= (wxDateTime::Month
)(mon
+ monDiff
);
623 wxASSERT_MSG( mon
>= 0 && mon
< MONTHS_IN_YEAR
, _T("logic error") );
625 // NB: we don't check here that the resulting date is valid, this function
626 // is private and the caller must check it if needed
629 void wxDateTime::Tm::AddDays(int dayDiff
)
631 // normalize the days field
632 while ( dayDiff
+ mday
< 1 )
636 dayDiff
+= GetNumOfDaysInMonth(year
, mon
);
639 mday
= (wxDateTime::wxDateTime_t
)( mday
+ dayDiff
);
640 while ( mday
> GetNumOfDaysInMonth(year
, mon
) )
642 mday
-= GetNumOfDaysInMonth(year
, mon
);
647 wxASSERT_MSG( mday
> 0 && mday
<= GetNumOfDaysInMonth(year
, mon
),
651 // ----------------------------------------------------------------------------
653 // ----------------------------------------------------------------------------
655 wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz
)
659 case wxDateTime::Local
:
660 // get the offset from C RTL: it returns the difference GMT-local
661 // while we want to have the offset _from_ GMT, hence the '-'
662 m_offset
= -GetTimeZone();
665 case wxDateTime::GMT_12
:
666 case wxDateTime::GMT_11
:
667 case wxDateTime::GMT_10
:
668 case wxDateTime::GMT_9
:
669 case wxDateTime::GMT_8
:
670 case wxDateTime::GMT_7
:
671 case wxDateTime::GMT_6
:
672 case wxDateTime::GMT_5
:
673 case wxDateTime::GMT_4
:
674 case wxDateTime::GMT_3
:
675 case wxDateTime::GMT_2
:
676 case wxDateTime::GMT_1
:
677 m_offset
= -3600*(wxDateTime::GMT0
- tz
);
680 case wxDateTime::GMT0
:
681 case wxDateTime::GMT1
:
682 case wxDateTime::GMT2
:
683 case wxDateTime::GMT3
:
684 case wxDateTime::GMT4
:
685 case wxDateTime::GMT5
:
686 case wxDateTime::GMT6
:
687 case wxDateTime::GMT7
:
688 case wxDateTime::GMT8
:
689 case wxDateTime::GMT9
:
690 case wxDateTime::GMT10
:
691 case wxDateTime::GMT11
:
692 case wxDateTime::GMT12
:
693 m_offset
= 3600*(tz
- wxDateTime::GMT0
);
696 case wxDateTime::A_CST
:
697 // Central Standard Time in use in Australia = UTC + 9.5
698 m_offset
= 60l*(9*MIN_PER_HOUR
+ MIN_PER_HOUR
/2);
702 wxFAIL_MSG( _T("unknown time zone") );
706 // ----------------------------------------------------------------------------
708 // ----------------------------------------------------------------------------
711 bool wxDateTime::IsLeapYear(int year
, wxDateTime::Calendar cal
)
713 if ( year
== Inv_Year
)
714 year
= GetCurrentYear();
716 if ( cal
== Gregorian
)
718 // in Gregorian calendar leap years are those divisible by 4 except
719 // those divisible by 100 unless they're also divisible by 400
720 // (in some countries, like Russia and Greece, additional corrections
721 // exist, but they won't manifest themselves until 2700)
722 return (year
% 4 == 0) && ((year
% 100 != 0) || (year
% 400 == 0));
724 else if ( cal
== Julian
)
726 // in Julian calendar the rule is simpler
727 return year
% 4 == 0;
731 wxFAIL_MSG(_T("unknown calendar"));
738 int wxDateTime::GetCentury(int year
)
740 return year
> 0 ? year
/ 100 : year
/ 100 - 1;
744 int wxDateTime::ConvertYearToBC(int year
)
747 return year
> 0 ? year
: year
- 1;
751 int wxDateTime::GetCurrentYear(wxDateTime::Calendar cal
)
756 return Now().GetYear();
759 wxFAIL_MSG(_T("TODO"));
763 wxFAIL_MSG(_T("unsupported calendar"));
771 wxDateTime::Month
wxDateTime::GetCurrentMonth(wxDateTime::Calendar cal
)
776 return Now().GetMonth();
779 wxFAIL_MSG(_T("TODO"));
783 wxFAIL_MSG(_T("unsupported calendar"));
791 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(int year
, Calendar cal
)
793 if ( year
== Inv_Year
)
795 // take the current year if none given
796 year
= GetCurrentYear();
803 return IsLeapYear(year
) ? 366 : 365;
806 wxFAIL_MSG(_T("unsupported calendar"));
814 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(wxDateTime::Month month
,
816 wxDateTime::Calendar cal
)
818 wxCHECK_MSG( month
< MONTHS_IN_YEAR
, 0, _T("invalid month") );
820 if ( cal
== Gregorian
|| cal
== Julian
)
822 if ( year
== Inv_Year
)
824 // take the current year if none given
825 year
= GetCurrentYear();
828 return GetNumOfDaysInMonth(year
, month
);
832 wxFAIL_MSG(_T("unsupported calendar"));
839 wxString
wxDateTime::GetMonthName(wxDateTime::Month month
,
840 wxDateTime::NameFlags flags
)
842 wxCHECK_MSG( month
!= Inv_Month
, wxEmptyString
, _T("invalid month") );
844 // notice that we must set all the fields to avoid confusing libc (GNU one
845 // gets confused to a crash if we don't do this)
850 return CallStrftime(flags
== Name_Abbr
? _T("%b") : _T("%B"), &tm
);
856 ret
= (flags
== Name_Abbr
? wxT("Jan"): wxT("January"));
859 ret
= (flags
== Name_Abbr
? wxT("Feb"): wxT("Febuary"));
862 ret
= (flags
== Name_Abbr
? wxT("Mar"): wxT("March"));
865 ret
= (flags
== Name_Abbr
? wxT("Apr"): wxT("April"));
868 ret
= (flags
== Name_Abbr
? wxT("May"): wxT("May"));
871 ret
= (flags
== Name_Abbr
? wxT("Jun"): wxT("June"));
874 ret
= (flags
== Name_Abbr
? wxT("Jul"): wxT("July"));
877 ret
= (flags
== Name_Abbr
? wxT("Aug"): wxT("August"));
880 ret
= (flags
== Name_Abbr
? wxT("Sep"): wxT("September"));
883 ret
= (flags
== Name_Abbr
? wxT("Oct"): wxT("October"));
886 ret
= (flags
== Name_Abbr
? wxT("Nov"): wxT("November"));
889 ret
= (flags
== Name_Abbr
? wxT("Dec"): wxT("December"));
897 wxString
wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday
,
898 wxDateTime::NameFlags flags
)
900 wxCHECK_MSG( wday
!= Inv_WeekDay
, wxEmptyString
, _T("invalid weekday") );
902 // take some arbitrary Sunday (but notice that the day should be such that
903 // after adding wday to it below we still have a valid date, e.g. don't
911 // and offset it by the number of days needed to get the correct wday
914 // call mktime() to normalize it...
917 // ... and call strftime()
918 return CallStrftime(flags
== Name_Abbr
? _T("%a") : _T("%A"), &tm
);
924 ret
= (flags
== Name_Abbr
? wxT("Sun") : wxT("Sunday"));
927 ret
= (flags
== Name_Abbr
? wxT("Mon") : wxT("Monday"));
930 ret
= (flags
== Name_Abbr
? wxT("Tue") : wxT("Tuesday"));
933 ret
= (flags
== Name_Abbr
? wxT("Wed") : wxT("Wednesday"));
936 ret
= (flags
== Name_Abbr
? wxT("Thu") : wxT("Thursday"));
939 ret
= (flags
== Name_Abbr
? wxT("Fri") : wxT("Friday"));
942 ret
= (flags
== Name_Abbr
? wxT("Sat") : wxT("Saturday"));
951 void wxDateTime::GetAmPmStrings(wxString
*am
, wxString
*pm
)
956 // @Note: Do not call 'CallStrftime' here! CallStrftime checks the return code
957 // and causes an assertion failed if the buffer is to small (which is good) - OR -
958 // if strftime does not return anything because the format string is invalid - OR -
959 // if there are no 'am' / 'pm' tokens defined for the current locale (which is not good).
960 // wxDateTime::ParseTime will try several different formats to parse the time.
961 // As a result, GetAmPmStrings might get called, even if the current locale
962 // does not define any 'am' / 'pm' tokens. In this case, wxStrftime would
963 // assert, even though it is a perfectly legal use.
966 if (wxStrftime(buffer
, sizeof(buffer
)/sizeof(wxChar
), _T("%p"), &tm
) > 0)
967 *am
= wxString(buffer
);
974 if (wxStrftime(buffer
, sizeof(buffer
)/sizeof(wxChar
), _T("%p"), &tm
) > 0)
975 *pm
= wxString(buffer
);
981 // ----------------------------------------------------------------------------
982 // Country stuff: date calculations depend on the country (DST, work days,
983 // ...), so we need to know which rules to follow.
984 // ----------------------------------------------------------------------------
987 wxDateTime::Country
wxDateTime::GetCountry()
989 // TODO use LOCALE_ICOUNTRY setting under Win32
991 if ( ms_country
== Country_Unknown
)
993 // try to guess from the time zone name
994 time_t t
= time(NULL
);
995 struct tm
*tm
= localtime(&t
);
997 wxString tz
= CallStrftime(_T("%Z"), tm
);
998 if ( tz
== _T("WET") || tz
== _T("WEST") )
1002 else if ( tz
== _T("CET") || tz
== _T("CEST") )
1004 ms_country
= Country_EEC
;
1006 else if ( tz
== _T("MSK") || tz
== _T("MSD") )
1008 ms_country
= Russia
;
1010 else if ( tz
== _T("AST") || tz
== _T("ADT") ||
1011 tz
== _T("EST") || tz
== _T("EDT") ||
1012 tz
== _T("CST") || tz
== _T("CDT") ||
1013 tz
== _T("MST") || tz
== _T("MDT") ||
1014 tz
== _T("PST") || tz
== _T("PDT") )
1020 // well, choose a default one
1032 void wxDateTime::SetCountry(wxDateTime::Country country
)
1034 ms_country
= country
;
1038 bool wxDateTime::IsWestEuropeanCountry(Country country
)
1040 if ( country
== Country_Default
)
1042 country
= GetCountry();
1045 return (Country_WesternEurope_Start
<= country
) &&
1046 (country
<= Country_WesternEurope_End
);
1049 // ----------------------------------------------------------------------------
1050 // DST calculations: we use 3 different rules for the West European countries,
1051 // USA and for the rest of the world. This is undoubtedly false for many
1052 // countries, but I lack the necessary info (and the time to gather it),
1053 // please add the other rules here!
1054 // ----------------------------------------------------------------------------
1057 bool wxDateTime::IsDSTApplicable(int year
, Country country
)
1059 if ( year
== Inv_Year
)
1061 // take the current year if none given
1062 year
= GetCurrentYear();
1065 if ( country
== Country_Default
)
1067 country
= GetCountry();
1074 // DST was first observed in the US and UK during WWI, reused
1075 // during WWII and used again since 1966
1076 return year
>= 1966 ||
1077 (year
>= 1942 && year
<= 1945) ||
1078 (year
== 1918 || year
== 1919);
1081 // assume that it started after WWII
1087 wxDateTime
wxDateTime::GetBeginDST(int year
, Country country
)
1089 if ( year
== Inv_Year
)
1091 // take the current year if none given
1092 year
= GetCurrentYear();
1095 if ( country
== Country_Default
)
1097 country
= GetCountry();
1100 if ( !IsDSTApplicable(year
, country
) )
1102 return wxInvalidDateTime
;
1107 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
1109 // DST begins at 1 a.m. GMT on the last Sunday of March
1110 if ( !dt
.SetToLastWeekDay(Sun
, Mar
, year
) )
1113 wxFAIL_MSG( _T("no last Sunday in March?") );
1116 dt
+= wxTimeSpan::Hours(1);
1118 // disable DST tests because it could result in an infinite recursion!
1121 else switch ( country
)
1128 // don't know for sure - assume it was in effect all year
1133 dt
.Set(1, Jan
, year
);
1137 // DST was installed Feb 2, 1942 by the Congress
1138 dt
.Set(2, Feb
, year
);
1141 // Oil embargo changed the DST period in the US
1143 dt
.Set(6, Jan
, 1974);
1147 dt
.Set(23, Feb
, 1975);
1151 // before 1986, DST begun on the last Sunday of April, but
1152 // in 1986 Reagan changed it to begin at 2 a.m. of the
1153 // first Sunday in April
1156 if ( !dt
.SetToLastWeekDay(Sun
, Apr
, year
) )
1159 wxFAIL_MSG( _T("no first Sunday in April?") );
1164 if ( !dt
.SetToWeekDay(Sun
, 1, Apr
, year
) )
1167 wxFAIL_MSG( _T("no first Sunday in April?") );
1171 dt
+= wxTimeSpan::Hours(2);
1173 // TODO what about timezone??
1179 // assume Mar 30 as the start of the DST for the rest of the world
1180 // - totally bogus, of course
1181 dt
.Set(30, Mar
, year
);
1188 wxDateTime
wxDateTime::GetEndDST(int year
, Country country
)
1190 if ( year
== Inv_Year
)
1192 // take the current year if none given
1193 year
= GetCurrentYear();
1196 if ( country
== Country_Default
)
1198 country
= GetCountry();
1201 if ( !IsDSTApplicable(year
, country
) )
1203 return wxInvalidDateTime
;
1208 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
1210 // DST ends at 1 a.m. GMT on the last Sunday of October
1211 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1213 // weirder and weirder...
1214 wxFAIL_MSG( _T("no last Sunday in October?") );
1217 dt
+= wxTimeSpan::Hours(1);
1219 // disable DST tests because it could result in an infinite recursion!
1222 else switch ( country
)
1229 // don't know for sure - assume it was in effect all year
1233 dt
.Set(31, Dec
, year
);
1237 // the time was reset after the end of the WWII
1238 dt
.Set(30, Sep
, year
);
1242 // DST ends at 2 a.m. on the last Sunday of October
1243 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1245 // weirder and weirder...
1246 wxFAIL_MSG( _T("no last Sunday in October?") );
1249 dt
+= wxTimeSpan::Hours(2);
1251 // TODO what about timezone??
1256 // assume October 26th as the end of the DST - totally bogus too
1257 dt
.Set(26, Oct
, year
);
1263 // ----------------------------------------------------------------------------
1264 // constructors and assignment operators
1265 // ----------------------------------------------------------------------------
1267 // return the current time with ms precision
1268 /* static */ wxDateTime
wxDateTime::UNow()
1270 return wxDateTime(wxGetLocalTimeMillis());
1273 // the values in the tm structure contain the local time
1274 wxDateTime
& wxDateTime::Set(const struct tm
& tm
)
1277 time_t timet
= mktime(&tm2
);
1279 if ( timet
== (time_t)-1 )
1281 // mktime() rather unintuitively fails for Jan 1, 1970 if the hour is
1282 // less than timezone - try to make it work for this case
1283 if ( tm2
.tm_year
== 70 && tm2
.tm_mon
== 0 && tm2
.tm_mday
== 1 )
1285 return Set((time_t)(
1287 tm2
.tm_hour
* MIN_PER_HOUR
* SEC_PER_MIN
+
1288 tm2
.tm_min
* SEC_PER_MIN
+
1292 wxFAIL_MSG( _T("mktime() failed") );
1294 *this = wxInvalidDateTime
;
1304 wxDateTime
& wxDateTime::Set(wxDateTime_t hour
,
1305 wxDateTime_t minute
,
1306 wxDateTime_t second
,
1307 wxDateTime_t millisec
)
1309 // we allow seconds to be 61 to account for the leap seconds, even if we
1310 // don't use them really
1311 wxDATETIME_CHECK( hour
< 24 &&
1315 _T("Invalid time in wxDateTime::Set()") );
1317 // get the current date from system
1318 struct tm
*tm
= GetTmNow();
1320 wxDATETIME_CHECK( tm
, _T("localtime() failed") );
1322 // make a copy so it isn't clobbered by the call to mktime() below
1327 tm1
.tm_min
= minute
;
1328 tm1
.tm_sec
= second
;
1330 // and the DST in case it changes on this date
1333 if ( tm2
.tm_isdst
!= tm1
.tm_isdst
)
1334 tm1
.tm_isdst
= tm2
.tm_isdst
;
1338 // and finally adjust milliseconds
1339 return SetMillisecond(millisec
);
1342 wxDateTime
& wxDateTime::Set(wxDateTime_t day
,
1346 wxDateTime_t minute
,
1347 wxDateTime_t second
,
1348 wxDateTime_t millisec
)
1350 wxDATETIME_CHECK( hour
< 24 &&
1354 _T("Invalid time in wxDateTime::Set()") );
1356 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1358 wxDATETIME_CHECK( (0 < day
) && (day
<= GetNumberOfDays(month
, year
)),
1359 _T("Invalid date in wxDateTime::Set()") );
1361 // the range of time_t type (inclusive)
1362 static const int yearMinInRange
= 1970;
1363 static const int yearMaxInRange
= 2037;
1365 // test only the year instead of testing for the exact end of the Unix
1366 // time_t range - it doesn't bring anything to do more precise checks
1367 if ( year
>= yearMinInRange
&& year
<= yearMaxInRange
)
1369 // use the standard library version if the date is in range - this is
1370 // probably more efficient than our code
1372 tm
.tm_year
= year
- 1900;
1378 tm
.tm_isdst
= -1; // mktime() will guess it
1382 // and finally adjust milliseconds
1384 SetMillisecond(millisec
);
1390 // do time calculations ourselves: we want to calculate the number of
1391 // milliseconds between the given date and the epoch
1393 // get the JDN for the midnight of this day
1394 m_time
= GetTruncatedJDN(day
, month
, year
);
1395 m_time
-= EPOCH_JDN
;
1396 m_time
*= SECONDS_PER_DAY
* TIME_T_FACTOR
;
1398 // JDN corresponds to GMT, we take localtime
1399 Add(wxTimeSpan(hour
, minute
, second
+ GetTimeZone(), millisec
));
1405 wxDateTime
& wxDateTime::Set(double jdn
)
1407 // so that m_time will be 0 for the midnight of Jan 1, 1970 which is jdn
1409 jdn
-= EPOCH_JDN
+ 0.5;
1411 m_time
.Assign(jdn
*MILLISECONDS_PER_DAY
);
1413 // JDNs always are in UTC, so we don't need any adjustments for time zone
1418 wxDateTime
& wxDateTime::ResetTime()
1422 if ( tm
.hour
|| tm
.min
|| tm
.sec
|| tm
.msec
)
1435 // ----------------------------------------------------------------------------
1436 // DOS Date and Time Format functions
1437 // ----------------------------------------------------------------------------
1438 // the dos date and time value is an unsigned 32 bit value in the format:
1439 // YYYYYYYMMMMDDDDDhhhhhmmmmmmsssss
1441 // Y = year offset from 1980 (0-127)
1443 // D = day of month (1-31)
1445 // m = minute (0-59)
1446 // s = bisecond (0-29) each bisecond indicates two seconds
1447 // ----------------------------------------------------------------------------
1449 wxDateTime
& wxDateTime::SetFromDOS(unsigned long ddt
)
1454 long year
= ddt
& 0xFE000000;
1459 long month
= ddt
& 0x1E00000;
1464 long day
= ddt
& 0x1F0000;
1468 long hour
= ddt
& 0xF800;
1472 long minute
= ddt
& 0x7E0;
1476 long second
= ddt
& 0x1F;
1477 tm
.tm_sec
= second
* 2;
1479 return Set(mktime(&tm
));
1482 unsigned long wxDateTime::GetAsDOS() const
1485 time_t ticks
= GetTicks();
1486 struct tm
*tm
= localtime(&ticks
);
1488 long year
= tm
->tm_year
;
1492 long month
= tm
->tm_mon
;
1496 long day
= tm
->tm_mday
;
1499 long hour
= tm
->tm_hour
;
1502 long minute
= tm
->tm_min
;
1505 long second
= tm
->tm_sec
;
1508 ddt
= year
| month
| day
| hour
| minute
| second
;
1512 // ----------------------------------------------------------------------------
1513 // time_t <-> broken down time conversions
1514 // ----------------------------------------------------------------------------
1516 wxDateTime::Tm
wxDateTime::GetTm(const TimeZone
& tz
) const
1518 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1520 time_t time
= GetTicks();
1521 if ( time
!= (time_t)-1 )
1523 // use C RTL functions
1525 if ( tz
.GetOffset() == -GetTimeZone() )
1527 // we are working with local time
1528 tm
= localtime(&time
);
1530 // should never happen
1531 wxCHECK_MSG( tm
, Tm(), _T("localtime() failed") );
1535 time
+= (time_t)tz
.GetOffset();
1536 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
1537 int time2
= (int) time
;
1545 // should never happen
1546 wxCHECK_MSG( tm
, Tm(), _T("gmtime() failed") );
1550 tm
= (struct tm
*)NULL
;
1556 // adjust the milliseconds
1558 long timeOnly
= (m_time
% MILLISECONDS_PER_DAY
).ToLong();
1559 tm2
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1562 //else: use generic code below
1565 // remember the time and do the calculations with the date only - this
1566 // eliminates rounding errors of the floating point arithmetics
1568 wxLongLong timeMidnight
= m_time
+ tz
.GetOffset() * 1000;
1570 long timeOnly
= (timeMidnight
% MILLISECONDS_PER_DAY
).ToLong();
1572 // we want to always have positive time and timeMidnight to be really
1573 // the midnight before it
1576 timeOnly
= MILLISECONDS_PER_DAY
+ timeOnly
;
1579 timeMidnight
-= timeOnly
;
1581 // calculate the Gregorian date from JDN for the midnight of our date:
1582 // this will yield day, month (in 1..12 range) and year
1584 // actually, this is the JDN for the noon of the previous day
1585 long jdn
= (timeMidnight
/ MILLISECONDS_PER_DAY
).ToLong() + EPOCH_JDN
;
1587 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
1589 wxASSERT_MSG( jdn
> -2, _T("JDN out of range") );
1591 // calculate the century
1592 long temp
= (jdn
+ JDN_OFFSET
) * 4 - 1;
1593 long century
= temp
/ DAYS_PER_400_YEARS
;
1595 // then the year and day of year (1 <= dayOfYear <= 366)
1596 temp
= ((temp
% DAYS_PER_400_YEARS
) / 4) * 4 + 3;
1597 long year
= (century
* 100) + (temp
/ DAYS_PER_4_YEARS
);
1598 long dayOfYear
= (temp
% DAYS_PER_4_YEARS
) / 4 + 1;
1600 // and finally the month and day of the month
1601 temp
= dayOfYear
* 5 - 3;
1602 long month
= temp
/ DAYS_PER_5_MONTHS
;
1603 long day
= (temp
% DAYS_PER_5_MONTHS
) / 5 + 1;
1605 // month is counted from March - convert to normal
1616 // year is offset by 4800
1619 // check that the algorithm gave us something reasonable
1620 wxASSERT_MSG( (0 < month
) && (month
<= 12), _T("invalid month") );
1621 wxASSERT_MSG( (1 <= day
) && (day
< 32), _T("invalid day") );
1623 // construct Tm from these values
1625 tm
.year
= (int)year
;
1626 tm
.mon
= (Month
)(month
- 1); // algorithm yields 1 for January, not 0
1627 tm
.mday
= (wxDateTime_t
)day
;
1628 tm
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1629 timeOnly
-= tm
.msec
;
1630 timeOnly
/= 1000; // now we have time in seconds
1632 tm
.sec
= (wxDateTime_t
)(timeOnly
% SEC_PER_MIN
);
1634 timeOnly
/= SEC_PER_MIN
; // now we have time in minutes
1636 tm
.min
= (wxDateTime_t
)(timeOnly
% MIN_PER_HOUR
);
1639 tm
.hour
= (wxDateTime_t
)(timeOnly
/ MIN_PER_HOUR
);
1644 wxDateTime
& wxDateTime::SetYear(int year
)
1646 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1655 wxDateTime
& wxDateTime::SetMonth(Month month
)
1657 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1666 wxDateTime
& wxDateTime::SetDay(wxDateTime_t mday
)
1668 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1677 wxDateTime
& wxDateTime::SetHour(wxDateTime_t hour
)
1679 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1688 wxDateTime
& wxDateTime::SetMinute(wxDateTime_t min
)
1690 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1699 wxDateTime
& wxDateTime::SetSecond(wxDateTime_t sec
)
1701 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1710 wxDateTime
& wxDateTime::SetMillisecond(wxDateTime_t millisecond
)
1712 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1714 // we don't need to use GetTm() for this one
1715 m_time
-= m_time
% 1000l;
1716 m_time
+= millisecond
;
1721 // ----------------------------------------------------------------------------
1722 // wxDateTime arithmetics
1723 // ----------------------------------------------------------------------------
1725 wxDateTime
& wxDateTime::Add(const wxDateSpan
& diff
)
1729 tm
.year
+= diff
.GetYears();
1730 tm
.AddMonths(diff
.GetMonths());
1732 // check that the resulting date is valid
1733 if ( tm
.mday
> GetNumOfDaysInMonth(tm
.year
, tm
.mon
) )
1735 // We suppose that when adding one month to Jan 31 we want to get Feb
1736 // 28 (or 29), i.e. adding a month to the last day of the month should
1737 // give the last day of the next month which is quite logical.
1739 // Unfortunately, there is no logic way to understand what should
1740 // Jan 30 + 1 month be - Feb 28 too or Feb 27 (assuming non leap year)?
1741 // We make it Feb 28 (last day too), but it is highly questionable.
1742 tm
.mday
= GetNumOfDaysInMonth(tm
.year
, tm
.mon
);
1745 tm
.AddDays(diff
.GetTotalDays());
1749 wxASSERT_MSG( IsSameTime(tm
),
1750 _T("Add(wxDateSpan) shouldn't modify time") );
1755 // ----------------------------------------------------------------------------
1756 // Weekday and monthday stuff
1757 // ----------------------------------------------------------------------------
1759 // convert Sun, Mon, ..., Sat into 6, 0, ..., 5
1760 static inline int ConvertWeekDayToMondayBase(int wd
)
1762 return wd
== wxDateTime::Sun
? 6 : wd
- 1;
1767 wxDateTime::SetToWeekOfYear(int year
, wxDateTime_t numWeek
, WeekDay wd
)
1769 wxASSERT_MSG( numWeek
> 0,
1770 _T("invalid week number: weeks are counted from 1") );
1772 // Jan 4 always lies in the 1st week of the year
1773 wxDateTime
dt(4, Jan
, year
);
1774 dt
.SetToWeekDayInSameWeek(wd
);
1775 dt
+= wxDateSpan::Weeks(numWeek
- 1);
1780 // use a separate function to avoid warnings about using deprecated
1781 // SetToTheWeek in GetWeek below
1783 SetToTheWeek(int year
,
1784 wxDateTime::wxDateTime_t numWeek
,
1785 wxDateTime::WeekDay weekday
,
1786 wxDateTime::WeekFlags flags
)
1788 // Jan 4 always lies in the 1st week of the year
1789 wxDateTime
dt(4, wxDateTime::Jan
, year
);
1790 dt
.SetToWeekDayInSameWeek(weekday
, flags
);
1791 dt
+= wxDateSpan::Weeks(numWeek
- 1);
1796 bool wxDateTime::SetToTheWeek(wxDateTime_t numWeek
,
1800 int year
= GetYear();
1801 *this = ::SetToTheWeek(year
, numWeek
, weekday
, flags
);
1802 if ( GetYear() != year
)
1804 // oops... numWeek was too big
1811 wxDateTime
wxDateTime::GetWeek(wxDateTime_t numWeek
,
1813 WeekFlags flags
) const
1815 return ::SetToTheWeek(GetYear(), numWeek
, weekday
, flags
);
1818 wxDateTime
& wxDateTime::SetToLastMonthDay(Month month
,
1821 // take the current month/year if none specified
1822 if ( year
== Inv_Year
)
1824 if ( month
== Inv_Month
)
1827 return Set(GetNumOfDaysInMonth(year
, month
), month
, year
);
1830 wxDateTime
& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday
, WeekFlags flags
)
1832 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
1834 int wdayDst
= weekday
,
1835 wdayThis
= GetWeekDay();
1836 if ( wdayDst
== wdayThis
)
1842 if ( flags
== Default_First
)
1844 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
1847 // the logic below based on comparing weekday and wdayThis works if Sun (0)
1848 // is the first day in the week, but breaks down for Monday_First case so
1849 // we adjust the week days in this case
1850 if ( flags
== Monday_First
)
1852 if ( wdayThis
== Sun
)
1854 if ( wdayDst
== Sun
)
1857 //else: Sunday_First, nothing to do
1859 // go forward or back in time to the day we want
1860 if ( wdayDst
< wdayThis
)
1862 return Subtract(wxDateSpan::Days(wdayThis
- wdayDst
));
1864 else // weekday > wdayThis
1866 return Add(wxDateSpan::Days(wdayDst
- wdayThis
));
1870 wxDateTime
& wxDateTime::SetToNextWeekDay(WeekDay weekday
)
1872 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
1875 WeekDay wdayThis
= GetWeekDay();
1876 if ( weekday
== wdayThis
)
1881 else if ( weekday
< wdayThis
)
1883 // need to advance a week
1884 diff
= 7 - (wdayThis
- weekday
);
1886 else // weekday > wdayThis
1888 diff
= weekday
- wdayThis
;
1891 return Add(wxDateSpan::Days(diff
));
1894 wxDateTime
& wxDateTime::SetToPrevWeekDay(WeekDay weekday
)
1896 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
1899 WeekDay wdayThis
= GetWeekDay();
1900 if ( weekday
== wdayThis
)
1905 else if ( weekday
> wdayThis
)
1907 // need to go to previous week
1908 diff
= 7 - (weekday
- wdayThis
);
1910 else // weekday < wdayThis
1912 diff
= wdayThis
- weekday
;
1915 return Subtract(wxDateSpan::Days(diff
));
1918 bool wxDateTime::SetToWeekDay(WeekDay weekday
,
1923 wxCHECK_MSG( weekday
!= Inv_WeekDay
, false, _T("invalid weekday") );
1925 // we don't check explicitly that -5 <= n <= 5 because we will return false
1926 // anyhow in such case - but may be should still give an assert for it?
1928 // take the current month/year if none specified
1929 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1933 // TODO this probably could be optimised somehow...
1937 // get the first day of the month
1938 dt
.Set(1, month
, year
);
1941 WeekDay wdayFirst
= dt
.GetWeekDay();
1943 // go to the first weekday of the month
1944 int diff
= weekday
- wdayFirst
;
1948 // add advance n-1 weeks more
1951 dt
+= wxDateSpan::Days(diff
);
1953 else // count from the end of the month
1955 // get the last day of the month
1956 dt
.SetToLastMonthDay(month
, year
);
1959 WeekDay wdayLast
= dt
.GetWeekDay();
1961 // go to the last weekday of the month
1962 int diff
= wdayLast
- weekday
;
1966 // and rewind n-1 weeks from there
1969 dt
-= wxDateSpan::Days(diff
);
1972 // check that it is still in the same month
1973 if ( dt
.GetMonth() == month
)
1981 // no such day in this month
1987 wxDateTime::wxDateTime_t
GetDayOfYearFromTm(const wxDateTime::Tm
& tm
)
1989 return (wxDateTime::wxDateTime_t
)(gs_cumulatedDays
[wxDateTime::IsLeapYear(tm
.year
)][tm
.mon
] + tm
.mday
);
1992 wxDateTime::wxDateTime_t
wxDateTime::GetDayOfYear(const TimeZone
& tz
) const
1994 return GetDayOfYearFromTm(GetTm(tz
));
1997 wxDateTime::wxDateTime_t
1998 wxDateTime::GetWeekOfYear(wxDateTime::WeekFlags flags
, const TimeZone
& tz
) const
2000 if ( flags
== Default_First
)
2002 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
2006 wxDateTime_t nDayInYear
= GetDayOfYearFromTm(tm
);
2008 int wdTarget
= GetWeekDay(tz
);
2009 int wdYearStart
= wxDateTime(1, Jan
, GetYear()).GetWeekDay();
2011 if ( flags
== Sunday_First
)
2013 // FIXME: First week is not calculated correctly.
2014 week
= (nDayInYear
- wdTarget
+ 7) / 7;
2015 if ( wdYearStart
== Wed
|| wdYearStart
== Thu
)
2018 else // week starts with monday
2020 // adjust the weekdays to non-US style.
2021 wdYearStart
= ConvertWeekDayToMondayBase(wdYearStart
);
2022 wdTarget
= ConvertWeekDayToMondayBase(wdTarget
);
2024 // quoting from http://www.cl.cam.ac.uk/~mgk25/iso-time.html:
2026 // Week 01 of a year is per definition the first week that has the
2027 // Thursday in this year, which is equivalent to the week that
2028 // contains the fourth day of January. In other words, the first
2029 // week of a new year is the week that has the majority of its
2030 // days in the new year. Week 01 might also contain days from the
2031 // previous year and the week before week 01 of a year is the last
2032 // week (52 or 53) of the previous year even if it contains days
2033 // from the new year. A week starts with Monday (day 1) and ends
2034 // with Sunday (day 7).
2037 // if Jan 1 is Thursday or less, it is in the first week of this year
2038 if ( wdYearStart
< 4 )
2040 // count the number of entire weeks between Jan 1 and this date
2041 week
= (nDayInYear
+ wdYearStart
+ 6 - wdTarget
)/7;
2043 // be careful to check for overflow in the next year
2044 if ( week
== 53 && tm
.mday
- wdTarget
> 28 )
2047 else // Jan 1 is in the last week of the previous year
2049 // check if we happen to be at the last week of previous year:
2050 if ( tm
.mon
== Jan
&& tm
.mday
< 8 - wdYearStart
)
2051 week
= wxDateTime(31, Dec
, GetYear()-1).GetWeekOfYear();
2053 week
= (nDayInYear
+ wdYearStart
- 1 - wdTarget
)/7;
2057 return (wxDateTime::wxDateTime_t
)week
;
2060 wxDateTime::wxDateTime_t
wxDateTime::GetWeekOfMonth(wxDateTime::WeekFlags flags
,
2061 const TimeZone
& tz
) const
2064 wxDateTime dtMonthStart
= wxDateTime(1, tm
.mon
, tm
.year
);
2065 int nWeek
= GetWeekOfYear(flags
) - dtMonthStart
.GetWeekOfYear(flags
) + 1;
2068 // this may happen for January when Jan, 1 is the last week of the
2070 nWeek
+= IsLeapYear(tm
.year
- 1) ? 53 : 52;
2073 return (wxDateTime::wxDateTime_t
)nWeek
;
2076 wxDateTime
& wxDateTime::SetToYearDay(wxDateTime::wxDateTime_t yday
)
2078 int year
= GetYear();
2079 wxDATETIME_CHECK( (0 < yday
) && (yday
<= GetNumberOfDays(year
)),
2080 _T("invalid year day") );
2082 bool isLeap
= IsLeapYear(year
);
2083 for ( Month mon
= Jan
; mon
< Inv_Month
; wxNextMonth(mon
) )
2085 // for Dec, we can't compare with gs_cumulatedDays[mon + 1], but we
2086 // don't need it neither - because of the CHECK above we know that
2087 // yday lies in December then
2088 if ( (mon
== Dec
) || (yday
<= gs_cumulatedDays
[isLeap
][mon
+ 1]) )
2090 Set((wxDateTime::wxDateTime_t
)(yday
- gs_cumulatedDays
[isLeap
][mon
]), mon
, year
);
2099 // ----------------------------------------------------------------------------
2100 // Julian day number conversion and related stuff
2101 // ----------------------------------------------------------------------------
2103 double wxDateTime::GetJulianDayNumber() const
2105 return m_time
.ToDouble() / MILLISECONDS_PER_DAY
+ EPOCH_JDN
+ 0.5;
2108 double wxDateTime::GetRataDie() const
2110 // March 1 of the year 0 is Rata Die day -306 and JDN 1721119.5
2111 return GetJulianDayNumber() - 1721119.5 - 306;
2114 // ----------------------------------------------------------------------------
2115 // timezone and DST stuff
2116 // ----------------------------------------------------------------------------
2118 int wxDateTime::IsDST(wxDateTime::Country country
) const
2120 wxCHECK_MSG( country
== Country_Default
, -1,
2121 _T("country support not implemented") );
2123 // use the C RTL for the dates in the standard range
2124 time_t timet
= GetTicks();
2125 if ( timet
!= (time_t)-1 )
2127 tm
*tm
= localtime(&timet
);
2129 wxCHECK_MSG( tm
, -1, _T("localtime() failed") );
2131 return tm
->tm_isdst
;
2135 int year
= GetYear();
2137 if ( !IsDSTApplicable(year
, country
) )
2139 // no DST time in this year in this country
2143 return IsBetween(GetBeginDST(year
, country
), GetEndDST(year
, country
));
2147 wxDateTime
& wxDateTime::MakeTimezone(const TimeZone
& tz
, bool noDST
)
2149 long secDiff
= GetTimeZone() + tz
.GetOffset();
2151 // we need to know whether DST is or not in effect for this date unless
2152 // the test disabled by the caller
2153 if ( !noDST
&& (IsDST() == 1) )
2155 // FIXME we assume that the DST is always shifted by 1 hour
2159 return Add(wxTimeSpan::Seconds(secDiff
));
2162 wxDateTime
& wxDateTime::MakeFromTimezone(const TimeZone
& tz
, bool noDST
)
2164 long secDiff
= GetTimeZone() + tz
.GetOffset();
2166 // we need to know whether DST is or not in effect for this date unless
2167 // the test disabled by the caller
2168 if ( !noDST
&& (IsDST() == 1) )
2170 // FIXME we assume that the DST is always shifted by 1 hour
2174 return Subtract(wxTimeSpan::Seconds(secDiff
));
2177 // ----------------------------------------------------------------------------
2178 // wxDateTime to/from text representations
2179 // ----------------------------------------------------------------------------
2181 wxString
wxDateTime::Format(const wxChar
*format
, const TimeZone
& tz
) const
2183 wxCHECK_MSG( format
, wxEmptyString
, _T("NULL format in wxDateTime::Format") );
2185 // we have to use our own implementation if the date is out of range of
2186 // strftime() or if we use non standard specificators
2187 time_t time
= GetTicks();
2188 if ( (time
!= (time_t)-1) && !wxStrstr(format
, _T("%l")) )
2192 if ( tz
.GetOffset() == -GetTimeZone() )
2194 // we are working with local time
2195 tm
= localtime(&time
);
2197 // should never happen
2198 wxCHECK_MSG( tm
, wxEmptyString
, _T("localtime() failed") );
2202 time
+= (int)tz
.GetOffset();
2204 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
2205 int time2
= (int) time
;
2213 // should never happen
2214 wxCHECK_MSG( tm
, wxEmptyString
, _T("gmtime() failed") );
2218 tm
= (struct tm
*)NULL
;
2222 //Windows CE doesn't support strftime or wcsftime, so we use the generic implementation
2225 return CallStrftime(format
, tm
);
2228 //else: use generic code below
2231 // we only parse ANSI C format specifications here, no POSIX 2
2232 // complications, no GNU extensions but we do add support for a "%l" format
2233 // specifier allowing to get the number of milliseconds
2236 // used for calls to strftime() when we only deal with time
2237 struct tm tmTimeOnly
;
2238 tmTimeOnly
.tm_hour
= tm
.hour
;
2239 tmTimeOnly
.tm_min
= tm
.min
;
2240 tmTimeOnly
.tm_sec
= tm
.sec
;
2241 tmTimeOnly
.tm_wday
= 0;
2242 tmTimeOnly
.tm_yday
= 0;
2243 tmTimeOnly
.tm_mday
= 1; // any date will do
2244 tmTimeOnly
.tm_mon
= 0;
2245 tmTimeOnly
.tm_year
= 76;
2246 tmTimeOnly
.tm_isdst
= 0; // no DST, we adjust for tz ourselves
2248 wxString tmp
, res
, fmt
;
2249 for ( const wxChar
*p
= format
; *p
; p
++ )
2251 if ( *p
!= _T('%') )
2259 // set the default format
2262 case _T('Y'): // year has 4 digits
2266 case _T('j'): // day of year has 3 digits
2267 case _T('l'): // milliseconds have 3 digits
2271 case _T('w'): // week day as number has only one
2276 // it's either another valid format specifier in which case
2277 // the format is "%02d" (for all the rest) or we have the
2278 // field width preceding the format in which case it will
2279 // override the default format anyhow
2283 bool restart
= true;
2288 // start of the format specification
2291 case _T('a'): // a weekday name
2293 // second parameter should be true for abbreviated names
2294 res
+= GetWeekDayName(tm
.GetWeekDay(),
2295 *p
== _T('a') ? Name_Abbr
: Name_Full
);
2298 case _T('b'): // a month name
2300 res
+= GetMonthName(tm
.mon
,
2301 *p
== _T('b') ? Name_Abbr
: Name_Full
);
2304 case _T('c'): // locale default date and time representation
2305 case _T('x'): // locale default date representation
2308 // the problem: there is no way to know what do these format
2309 // specifications correspond to for the current locale.
2311 // the solution: use a hack and still use strftime(): first
2312 // find the YEAR which is a year in the strftime() range (1970
2313 // - 2038) whose Jan 1 falls on the same week day as the Jan 1
2314 // of the real year. Then make a copy of the format and
2315 // replace all occurrences of YEAR in it with some unique
2316 // string not appearing anywhere else in it, then use
2317 // strftime() to format the date in year YEAR and then replace
2318 // YEAR back by the real year and the unique replacement
2319 // string back with YEAR. Notice that "all occurrences of YEAR"
2320 // means all occurrences of 4 digit as well as 2 digit form!
2322 // the bugs: we assume that neither of %c nor %x contains any
2323 // fields which may change between the YEAR and real year. For
2324 // example, the week number (%U, %W) and the day number (%j)
2325 // will change if one of these years is leap and the other one
2328 // find the YEAR: normally, for any year X, Jan 1 or the
2329 // year X + 28 is the same weekday as Jan 1 of X (because
2330 // the weekday advances by 1 for each normal X and by 2
2331 // for each leap X, hence by 5 every 4 years or by 35
2332 // which is 0 mod 7 every 28 years) but this rule breaks
2333 // down if there are years between X and Y which are
2334 // divisible by 4 but not leap (i.e. divisible by 100 but
2335 // not 400), hence the correction.
2337 int yearReal
= GetYear(tz
);
2338 int mod28
= yearReal
% 28;
2340 // be careful to not go too far - we risk to leave the
2345 year
= 1988 + mod28
; // 1988 == 0 (mod 28)
2349 year
= 1970 + mod28
- 10; // 1970 == 10 (mod 28)
2352 int nCentury
= year
/ 100,
2353 nCenturyReal
= yearReal
/ 100;
2355 // need to adjust for the years divisble by 400 which are
2356 // not leap but are counted like leap ones if we just take
2357 // the number of centuries in between for nLostWeekDays
2358 int nLostWeekDays
= (nCentury
- nCenturyReal
) -
2359 (nCentury
/ 4 - nCenturyReal
/ 4);
2361 // we have to gain back the "lost" weekdays: note that the
2362 // effect of this loop is to not do anything to
2363 // nLostWeekDays (which we won't use any more), but to
2364 // (indirectly) set the year correctly
2365 while ( (nLostWeekDays
% 7) != 0 )
2367 nLostWeekDays
+= year
++ % 4 ? 1 : 2;
2370 // at any rate, we couldn't go further than 1988 + 9 + 28!
2371 wxASSERT_MSG( year
< 2030,
2372 _T("logic error in wxDateTime::Format") );
2374 wxString strYear
, strYear2
;
2375 strYear
.Printf(_T("%d"), year
);
2376 strYear2
.Printf(_T("%d"), year
% 100);
2378 // find two strings not occurring in format (this is surely
2379 // not the optimal way of doing it... improvements welcome!)
2380 wxString fmt
= format
;
2381 wxString replacement
= (wxChar
)-1;
2382 while ( fmt
.Find(replacement
) != wxNOT_FOUND
)
2384 replacement
<< (wxChar
)-1;
2387 wxString replacement2
= (wxChar
)-2;
2388 while ( fmt
.Find(replacement
) != wxNOT_FOUND
)
2390 replacement
<< (wxChar
)-2;
2393 // replace all occurrences of year with it
2394 bool wasReplaced
= fmt
.Replace(strYear
, replacement
) > 0;
2396 wasReplaced
= fmt
.Replace(strYear2
, replacement2
) > 0;
2398 // use strftime() to format the same date but in supported
2401 // NB: we assume that strftime() doesn't check for the
2402 // date validity and will happily format the date
2403 // corresponding to Feb 29 of a non leap year (which
2404 // may happen if yearReal was leap and year is not)
2405 struct tm tmAdjusted
;
2407 tmAdjusted
.tm_hour
= tm
.hour
;
2408 tmAdjusted
.tm_min
= tm
.min
;
2409 tmAdjusted
.tm_sec
= tm
.sec
;
2410 tmAdjusted
.tm_wday
= tm
.GetWeekDay();
2411 tmAdjusted
.tm_yday
= GetDayOfYear();
2412 tmAdjusted
.tm_mday
= tm
.mday
;
2413 tmAdjusted
.tm_mon
= tm
.mon
;
2414 tmAdjusted
.tm_year
= year
- 1900;
2415 tmAdjusted
.tm_isdst
= 0; // no DST, already adjusted
2416 wxString str
= CallStrftime(*p
== _T('c') ? _T("%c")
2420 // now replace the occurrence of 1999 with the real year
2421 wxString strYearReal
, strYearReal2
;
2422 strYearReal
.Printf(_T("%04d"), yearReal
);
2423 strYearReal2
.Printf(_T("%02d"), yearReal
% 100);
2424 str
.Replace(strYear
, strYearReal
);
2425 str
.Replace(strYear2
, strYearReal2
);
2427 // and replace back all occurrences of replacement string
2430 str
.Replace(replacement2
, strYear2
);
2431 str
.Replace(replacement
, strYear
);
2437 //Use "%m/%d/%y %H:%M:%S" format instead
2438 res
+= wxString::Format(wxT("%02d/%02d/%04d %02d:%02d:%02d"),
2439 tm
.mon
+1,tm
.mday
, tm
.year
, tm
.hour
, tm
.min
, tm
.sec
);
2443 case _T('d'): // day of a month (01-31)
2444 res
+= wxString::Format(fmt
, tm
.mday
);
2447 case _T('H'): // hour in 24h format (00-23)
2448 res
+= wxString::Format(fmt
, tm
.hour
);
2451 case _T('I'): // hour in 12h format (01-12)
2453 // 24h -> 12h, 0h -> 12h too
2454 int hour12
= tm
.hour
> 12 ? tm
.hour
- 12
2455 : tm
.hour
? tm
.hour
: 12;
2456 res
+= wxString::Format(fmt
, hour12
);
2460 case _T('j'): // day of the year
2461 res
+= wxString::Format(fmt
, GetDayOfYear(tz
));
2464 case _T('l'): // milliseconds (NOT STANDARD)
2465 res
+= wxString::Format(fmt
, GetMillisecond(tz
));
2468 case _T('m'): // month as a number (01-12)
2469 res
+= wxString::Format(fmt
, tm
.mon
+ 1);
2472 case _T('M'): // minute as a decimal number (00-59)
2473 res
+= wxString::Format(fmt
, tm
.min
);
2476 case _T('p'): // AM or PM string
2478 res
+= CallStrftime(_T("%p"), &tmTimeOnly
);
2480 res
+= (tmTimeOnly
.tm_hour
> 12) ? wxT("pm") : wxT("am");
2484 case _T('S'): // second as a decimal number (00-61)
2485 res
+= wxString::Format(fmt
, tm
.sec
);
2488 case _T('U'): // week number in the year (Sunday 1st week day)
2489 res
+= wxString::Format(fmt
, GetWeekOfYear(Sunday_First
, tz
));
2492 case _T('W'): // week number in the year (Monday 1st week day)
2493 res
+= wxString::Format(fmt
, GetWeekOfYear(Monday_First
, tz
));
2496 case _T('w'): // weekday as a number (0-6), Sunday = 0
2497 res
+= wxString::Format(fmt
, tm
.GetWeekDay());
2500 // case _T('x'): -- handled with "%c"
2502 case _T('X'): // locale default time representation
2503 // just use strftime() to format the time for us
2505 res
+= CallStrftime(_T("%X"), &tmTimeOnly
);
2507 res
+= wxString::Format(wxT("%02d:%02d:%02d"),tm
.hour
, tm
.min
, tm
.sec
);
2511 case _T('y'): // year without century (00-99)
2512 res
+= wxString::Format(fmt
, tm
.year
% 100);
2515 case _T('Y'): // year with century
2516 res
+= wxString::Format(fmt
, tm
.year
);
2519 case _T('Z'): // timezone name
2521 res
+= CallStrftime(_T("%Z"), &tmTimeOnly
);
2526 // is it the format width?
2528 while ( *p
== _T('-') || *p
== _T('+') ||
2529 *p
== _T(' ') || wxIsdigit(*p
) )
2536 // we've only got the flags and width so far in fmt
2537 fmt
.Prepend(_T('%'));
2538 fmt
.Append(_T('d'));
2545 // no, it wasn't the width
2546 wxFAIL_MSG(_T("unknown format specificator"));
2548 // fall through and just copy it nevertheless
2550 case _T('%'): // a percent sign
2554 case 0: // the end of string
2555 wxFAIL_MSG(_T("missing format at the end of string"));
2557 // just put the '%' which was the last char in format
2567 // this function parses a string in (strict) RFC 822 format: see the section 5
2568 // of the RFC for the detailed description, but briefly it's something of the
2569 // form "Sat, 18 Dec 1999 00:48:30 +0100"
2571 // this function is "strict" by design - it must reject anything except true
2572 // RFC822 time specs.
2574 // TODO a great candidate for using reg exps
2575 const wxChar
*wxDateTime::ParseRfc822Date(const wxChar
* date
)
2577 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
2579 const wxChar
*p
= date
;
2580 const wxChar
*comma
= wxStrchr(p
, _T(','));
2583 // the part before comma is the weekday
2585 // skip it for now - we don't use but might check that it really
2586 // corresponds to the specfied date
2589 if ( *p
!= _T(' ') )
2591 wxLogDebug(_T("no space after weekday in RFC822 time spec"));
2593 return (wxChar
*)NULL
;
2599 // the following 1 or 2 digits are the day number
2600 if ( !wxIsdigit(*p
) )
2602 wxLogDebug(_T("day number expected in RFC822 time spec, none found"));
2604 return (wxChar
*)NULL
;
2607 wxDateTime_t day
= (wxDateTime_t
)(*p
++ - _T('0'));
2608 if ( wxIsdigit(*p
) )
2611 day
= (wxDateTime_t
)(day
+ (*p
++ - _T('0')));
2614 if ( *p
++ != _T(' ') )
2616 return (wxChar
*)NULL
;
2619 // the following 3 letters specify the month
2620 wxString
monName(p
, 3);
2622 if ( monName
== _T("Jan") )
2624 else if ( monName
== _T("Feb") )
2626 else if ( monName
== _T("Mar") )
2628 else if ( monName
== _T("Apr") )
2630 else if ( monName
== _T("May") )
2632 else if ( monName
== _T("Jun") )
2634 else if ( monName
== _T("Jul") )
2636 else if ( monName
== _T("Aug") )
2638 else if ( monName
== _T("Sep") )
2640 else if ( monName
== _T("Oct") )
2642 else if ( monName
== _T("Nov") )
2644 else if ( monName
== _T("Dec") )
2648 wxLogDebug(_T("Invalid RFC 822 month name '%s'"), monName
.c_str());
2650 return (wxChar
*)NULL
;
2655 if ( *p
++ != _T(' ') )
2657 return (wxChar
*)NULL
;
2661 if ( !wxIsdigit(*p
) )
2664 return (wxChar
*)NULL
;
2667 int year
= *p
++ - _T('0');
2669 if ( !wxIsdigit(*p
) )
2671 // should have at least 2 digits in the year
2672 return (wxChar
*)NULL
;
2676 year
+= *p
++ - _T('0');
2678 // is it a 2 digit year (as per original RFC 822) or a 4 digit one?
2679 if ( wxIsdigit(*p
) )
2682 year
+= *p
++ - _T('0');
2684 if ( !wxIsdigit(*p
) )
2686 // no 3 digit years please
2687 return (wxChar
*)NULL
;
2691 year
+= *p
++ - _T('0');
2694 if ( *p
++ != _T(' ') )
2696 return (wxChar
*)NULL
;
2699 // time is in the format hh:mm:ss and seconds are optional
2700 if ( !wxIsdigit(*p
) )
2702 return (wxChar
*)NULL
;
2705 wxDateTime_t hour
= (wxDateTime_t
)(*p
++ - _T('0'));
2707 if ( !wxIsdigit(*p
) )
2709 return (wxChar
*)NULL
;
2713 hour
= (wxDateTime_t
)(hour
+ (*p
++ - _T('0')));
2715 if ( *p
++ != _T(':') )
2717 return (wxChar
*)NULL
;
2720 if ( !wxIsdigit(*p
) )
2722 return (wxChar
*)NULL
;
2725 wxDateTime_t min
= (wxDateTime_t
)(*p
++ - _T('0'));
2727 if ( !wxIsdigit(*p
) )
2729 return (wxChar
*)NULL
;
2733 min
= (wxDateTime_t
)(min
+ *p
++ - _T('0'));
2735 wxDateTime_t sec
= 0;
2736 if ( *p
++ == _T(':') )
2738 if ( !wxIsdigit(*p
) )
2740 return (wxChar
*)NULL
;
2743 sec
= (wxDateTime_t
)(*p
++ - _T('0'));
2745 if ( !wxIsdigit(*p
) )
2747 return (wxChar
*)NULL
;
2751 sec
= (wxDateTime_t
)(sec
+ *p
++ - _T('0'));
2754 if ( *p
++ != _T(' ') )
2756 return (wxChar
*)NULL
;
2759 // and now the interesting part: the timezone
2760 int offset
wxDUMMY_INITIALIZE(0);
2761 if ( *p
== _T('-') || *p
== _T('+') )
2763 // the explicit offset given: it has the form of hhmm
2764 bool plus
= *p
++ == _T('+');
2766 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2768 return (wxChar
*)NULL
;
2772 offset
= MIN_PER_HOUR
*(10*(*p
- _T('0')) + (*(p
+ 1) - _T('0')));
2776 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2778 return (wxChar
*)NULL
;
2782 offset
+= 10*(*p
- _T('0')) + (*(p
+ 1) - _T('0'));
2793 // the symbolic timezone given: may be either military timezone or one
2794 // of standard abbreviations
2797 // military: Z = UTC, J unused, A = -1, ..., Y = +12
2798 static const int offsets
[26] =
2800 //A B C D E F G H I J K L M
2801 -1, -2, -3, -4, -5, -6, -7, -8, -9, 0, -10, -11, -12,
2802 //N O P R Q S T U V W Z Y Z
2803 +1, +2, +3, +4, +5, +6, +7, +8, +9, +10, +11, +12, 0
2806 if ( *p
< _T('A') || *p
> _T('Z') || *p
== _T('J') )
2808 wxLogDebug(_T("Invalid militaty timezone '%c'"), *p
);
2810 return (wxChar
*)NULL
;
2813 offset
= offsets
[*p
++ - _T('A')];
2819 if ( tz
== _T("UT") || tz
== _T("UTC") || tz
== _T("GMT") )
2821 else if ( tz
== _T("AST") )
2822 offset
= AST
- GMT0
;
2823 else if ( tz
== _T("ADT") )
2824 offset
= ADT
- GMT0
;
2825 else if ( tz
== _T("EST") )
2826 offset
= EST
- GMT0
;
2827 else if ( tz
== _T("EDT") )
2828 offset
= EDT
- GMT0
;
2829 else if ( tz
== _T("CST") )
2830 offset
= CST
- GMT0
;
2831 else if ( tz
== _T("CDT") )
2832 offset
= CDT
- GMT0
;
2833 else if ( tz
== _T("MST") )
2834 offset
= MST
- GMT0
;
2835 else if ( tz
== _T("MDT") )
2836 offset
= MDT
- GMT0
;
2837 else if ( tz
== _T("PST") )
2838 offset
= PST
- GMT0
;
2839 else if ( tz
== _T("PDT") )
2840 offset
= PDT
- GMT0
;
2843 wxLogDebug(_T("Unknown RFC 822 timezone '%s'"), p
);
2845 return (wxChar
*)NULL
;
2852 offset
*= MIN_PER_HOUR
;
2855 // the spec was correct, construct the date from the values we found
2856 Set(day
, mon
, year
, hour
, min
, sec
);
2857 MakeFromTimezone(TimeZone((wxDateTime_t
)(offset
*SEC_PER_MIN
)));
2864 // returns the string containing strftime() format used for short dates in the
2865 // current locale or an empty string
2866 static wxString
GetLocaleDateFormat()
2870 // there is no setlocale() under Windows CE, so just always query the
2873 if ( strcmp(setlocale(LC_ALL
, NULL
), "C") != 0 )
2876 // The locale was programatically set to non-C. We assume that this was
2877 // done using wxLocale, in which case thread's current locale is also
2878 // set to correct LCID value and we can use GetLocaleInfo to determine
2879 // the correct formatting string:
2881 LCID lcid
= LOCALE_USER_DEFAULT
;
2883 LCID lcid
= GetThreadLocale();
2885 // according to MSDN 80 chars is max allowed for short date format
2887 if ( ::GetLocaleInfo(lcid
, LOCALE_SSHORTDATE
, fmt
, WXSIZEOF(fmt
)) )
2889 wxChar chLast
= _T('\0');
2890 size_t lastCount
= 0;
2891 for ( const wxChar
*p
= fmt
; /* NUL handled inside */; p
++ )
2901 // these characters come in groups, start counting them
2911 // first deal with any special characters we have had
2917 switch ( lastCount
)
2921 // these two are the same as we
2922 // don't distinguish between 1 and
2923 // 2 digits for days
2936 wxFAIL_MSG( _T("too many 'd's") );
2941 switch ( lastCount
)
2945 // as for 'd' and 'dd' above
2958 wxFAIL_MSG( _T("too many 'M's") );
2963 switch ( lastCount
)
2975 wxFAIL_MSG( _T("wrong number of 'y's") );
2980 // strftime() doesn't have era string,
2981 // ignore this format
2982 wxASSERT_MSG( lastCount
<= 2,
2983 _T("too many 'g's") );
2987 wxFAIL_MSG( _T("unreachable") );
2994 // not a special character so must be just a separator,
2996 if ( *p
!= _T('\0') )
2998 if ( *p
== _T('%') )
3000 // this one needs to be escaped
3008 if ( *p
== _T('\0') )
3012 //else: GetLocaleInfo() failed, leave fmtDate value unchanged and
3013 // try our luck with the default formats
3015 //else: default C locale, default formats should work
3020 #endif // __WINDOWS__
3022 const wxChar
*wxDateTime::ParseFormat(const wxChar
*date
,
3023 const wxChar
*format
,
3024 const wxDateTime
& dateDef
)
3026 wxCHECK_MSG( date
&& format
, (wxChar
*)NULL
,
3027 _T("NULL pointer in wxDateTime::ParseFormat()") );
3032 // what fields have we found?
3033 bool haveWDay
= false,
3042 bool hourIsIn12hFormat
= false, // or in 24h one?
3043 isPM
= false; // AM by default
3045 // and the value of the items we have (init them to get rid of warnings)
3046 wxDateTime_t sec
= 0,
3049 WeekDay wday
= Inv_WeekDay
;
3050 wxDateTime_t yday
= 0,
3052 wxDateTime::Month mon
= Inv_Month
;
3055 const wxChar
*input
= date
;
3056 for ( const wxChar
*fmt
= format
; *fmt
; fmt
++ )
3058 if ( *fmt
!= _T('%') )
3060 if ( wxIsspace(*fmt
) )
3062 // a white space in the format string matches 0 or more white
3063 // spaces in the input
3064 while ( wxIsspace(*input
) )
3071 // any other character (not whitespace, not '%') must be
3072 // matched by itself in the input
3073 if ( *input
++ != *fmt
)
3076 return (wxChar
*)NULL
;
3080 // done with this format char
3084 // start of a format specification
3086 // parse the optional width
3088 while ( wxIsdigit(*++fmt
) )
3091 width
+= *fmt
- _T('0');
3094 // the default widths for the various fields
3099 case _T('Y'): // year has 4 digits
3103 case _T('j'): // day of year has 3 digits
3104 case _T('l'): // milliseconds have 3 digits
3108 case _T('w'): // week day as number has only one
3113 // default for all other fields
3118 // then the format itself
3121 case _T('a'): // a weekday name
3124 int flag
= *fmt
== _T('a') ? Name_Abbr
: Name_Full
;
3125 wday
= GetWeekDayFromName(GetAlphaToken(input
), flag
);
3126 if ( wday
== Inv_WeekDay
)
3129 return (wxChar
*)NULL
;
3135 case _T('b'): // a month name
3138 int flag
= *fmt
== _T('b') ? Name_Abbr
: Name_Full
;
3139 mon
= GetMonthFromName(GetAlphaToken(input
), flag
);
3140 if ( mon
== Inv_Month
)
3143 return (wxChar
*)NULL
;
3149 case _T('c'): // locale default date and time representation
3153 // this is the format which corresponds to ctime() output
3154 // and strptime("%c") should parse it, so try it first
3155 static const wxChar
*fmtCtime
= _T("%a %b %d %H:%M:%S %Y");
3157 const wxChar
*result
= dt
.ParseFormat(input
, fmtCtime
);
3160 result
= dt
.ParseFormat(input
, _T("%x %X"));
3165 result
= dt
.ParseFormat(input
, _T("%X %x"));
3170 // we've tried everything and still no match
3171 return (wxChar
*)NULL
;
3176 haveDay
= haveMon
= haveYear
=
3177 haveHour
= haveMin
= haveSec
= true;
3191 case _T('d'): // day of a month (01-31)
3192 if ( !GetNumericToken(width
, input
, &num
) ||
3193 (num
> 31) || (num
< 1) )
3196 return (wxChar
*)NULL
;
3199 // we can't check whether the day range is correct yet, will
3200 // do it later - assume ok for now
3202 mday
= (wxDateTime_t
)num
;
3205 case _T('H'): // hour in 24h format (00-23)
3206 if ( !GetNumericToken(width
, input
, &num
) || (num
> 23) )
3209 return (wxChar
*)NULL
;
3213 hour
= (wxDateTime_t
)num
;
3216 case _T('I'): // hour in 12h format (01-12)
3217 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 12) )
3220 return (wxChar
*)NULL
;
3224 hourIsIn12hFormat
= true;
3225 hour
= (wxDateTime_t
)(num
% 12); // 12 should be 0
3228 case _T('j'): // day of the year
3229 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 366) )
3232 return (wxChar
*)NULL
;
3236 yday
= (wxDateTime_t
)num
;
3239 case _T('m'): // month as a number (01-12)
3240 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 12) )
3243 return (wxChar
*)NULL
;
3247 mon
= (Month
)(num
- 1);
3250 case _T('M'): // minute as a decimal number (00-59)
3251 if ( !GetNumericToken(width
, input
, &num
) || (num
> 59) )
3254 return (wxChar
*)NULL
;
3258 min
= (wxDateTime_t
)num
;
3261 case _T('p'): // AM or PM string
3263 wxString am
, pm
, token
= GetAlphaToken(input
);
3265 GetAmPmStrings(&am
, &pm
);
3266 if (am
.empty() && pm
.empty())
3267 return (wxChar
*)NULL
; // no am/pm strings defined
3268 if ( token
.CmpNoCase(pm
) == 0 )
3272 else if ( token
.CmpNoCase(am
) != 0 )
3275 return (wxChar
*)NULL
;
3280 case _T('r'): // time as %I:%M:%S %p
3283 input
= dt
.ParseFormat(input
, _T("%I:%M:%S %p"));
3287 return (wxChar
*)NULL
;
3290 haveHour
= haveMin
= haveSec
= true;
3299 case _T('R'): // time as %H:%M
3302 input
= dt
.ParseFormat(input
, _T("%H:%M"));
3306 return (wxChar
*)NULL
;
3309 haveHour
= haveMin
= true;
3317 case _T('S'): // second as a decimal number (00-61)
3318 if ( !GetNumericToken(width
, input
, &num
) || (num
> 61) )
3321 return (wxChar
*)NULL
;
3325 sec
= (wxDateTime_t
)num
;
3328 case _T('T'): // time as %H:%M:%S
3331 input
= dt
.ParseFormat(input
, _T("%H:%M:%S"));
3335 return (wxChar
*)NULL
;
3338 haveHour
= haveMin
= haveSec
= true;
3347 case _T('w'): // weekday as a number (0-6), Sunday = 0
3348 if ( !GetNumericToken(width
, input
, &num
) || (wday
> 6) )
3351 return (wxChar
*)NULL
;
3355 wday
= (WeekDay
)num
;
3358 case _T('x'): // locale default date representation
3359 #ifdef HAVE_STRPTIME
3360 // try using strptime() -- it may fail even if the input is
3361 // correct but the date is out of range, so we will fall back
3362 // to our generic code anyhow
3366 const wxChar
*result
= CallStrptime(input
, "%x", &tm
);
3371 haveDay
= haveMon
= haveYear
= true;
3373 year
= 1900 + tm
.tm_year
;
3374 mon
= (Month
)tm
.tm_mon
;
3380 #endif // HAVE_STRPTIME
3388 // The above doesn't work for all locales, try to query
3389 // Windows for the right way of formatting the date:
3390 fmtDate
= GetLocaleDateFormat();
3391 if ( fmtDate
.empty() )
3394 if ( IsWestEuropeanCountry(GetCountry()) ||
3395 GetCountry() == Russia
)
3397 fmtDate
= _T("%d/%m/%y");
3398 fmtDateAlt
= _T("%m/%d/%y");
3402 fmtDate
= _T("%m/%d/%y");
3403 fmtDateAlt
= _T("%d/%m/%y");
3407 const wxChar
*result
= dt
.ParseFormat(input
, fmtDate
);
3409 if ( !result
&& !fmtDateAlt
.empty() )
3411 // ok, be nice and try another one
3412 result
= dt
.ParseFormat(input
, fmtDateAlt
);
3418 return (wxChar
*)NULL
;
3423 haveDay
= haveMon
= haveYear
= true;
3434 case _T('X'): // locale default time representation
3435 #ifdef HAVE_STRPTIME
3437 // use strptime() to do it for us (FIXME !Unicode friendly)
3439 input
= CallStrptime(input
, "%X", &tm
);
3442 return (wxChar
*)NULL
;
3445 haveHour
= haveMin
= haveSec
= true;
3451 #else // !HAVE_STRPTIME
3452 // TODO under Win32 we can query the LOCALE_ITIME system
3453 // setting which says whether the default time format is
3456 // try to parse what follows as "%H:%M:%S" and, if this
3457 // fails, as "%I:%M:%S %p" - this should catch the most
3461 const wxChar
*result
= dt
.ParseFormat(input
, _T("%T"));
3464 result
= dt
.ParseFormat(input
, _T("%r"));
3470 return (wxChar
*)NULL
;
3473 haveHour
= haveMin
= haveSec
= true;
3482 #endif // HAVE_STRPTIME/!HAVE_STRPTIME
3485 case _T('y'): // year without century (00-99)
3486 if ( !GetNumericToken(width
, input
, &num
) || (num
> 99) )
3489 return (wxChar
*)NULL
;
3494 // TODO should have an option for roll over date instead of
3495 // hard coding it here
3496 year
= (num
> 30 ? 1900 : 2000) + (wxDateTime_t
)num
;
3499 case _T('Y'): // year with century
3500 if ( !GetNumericToken(width
, input
, &num
) )
3503 return (wxChar
*)NULL
;
3507 year
= (wxDateTime_t
)num
;
3510 case _T('Z'): // timezone name
3511 wxFAIL_MSG(_T("TODO"));
3514 case _T('%'): // a percent sign
3515 if ( *input
++ != _T('%') )
3518 return (wxChar
*)NULL
;
3522 case 0: // the end of string
3523 wxFAIL_MSG(_T("unexpected format end"));
3527 default: // not a known format spec
3528 return (wxChar
*)NULL
;
3532 // format matched, try to construct a date from what we have now
3534 if ( dateDef
.IsValid() )
3536 // take this date as default
3537 tmDef
= dateDef
.GetTm();
3539 else if ( IsValid() )
3541 // if this date is valid, don't change it
3546 // no default and this date is invalid - fall back to Today()
3547 tmDef
= Today().GetTm();
3558 // TODO we don't check here that the values are consistent, if both year
3559 // day and month/day were found, we just ignore the year day and we
3560 // also always ignore the week day
3561 if ( haveMon
&& haveDay
)
3563 if ( mday
> GetNumOfDaysInMonth(tm
.year
, mon
) )
3565 wxLogDebug(_T("bad month day in wxDateTime::ParseFormat"));
3567 return (wxChar
*)NULL
;
3573 else if ( haveYDay
)
3575 if ( yday
> GetNumberOfDays(tm
.year
) )
3577 wxLogDebug(_T("bad year day in wxDateTime::ParseFormat"));
3579 return (wxChar
*)NULL
;
3582 Tm tm2
= wxDateTime(1, Jan
, tm
.year
).SetToYearDay(yday
).GetTm();
3589 if ( haveHour
&& hourIsIn12hFormat
&& isPM
)
3591 // translate to 24hour format
3594 //else: either already in 24h format or no translation needed
3614 // finally check that the week day is consistent -- if we had it
3615 if ( haveWDay
&& GetWeekDay() != wday
)
3617 wxLogDebug(_T("inconsistsnet week day in wxDateTime::ParseFormat()"));
3625 const wxChar
*wxDateTime::ParseDateTime(const wxChar
*date
)
3627 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3629 // Set to current day and hour, so strings like '14:00' becomes today at
3630 // 14, not some other random date
3631 wxDateTime dtDate
= wxDateTime::Today();
3632 wxDateTime dtTime
= wxDateTime::Today();
3634 const wxChar
* pchTime
;
3636 // Try to parse the beginning of the string as a date
3637 const wxChar
* pchDate
= dtDate
.ParseDate(date
);
3639 // We got a date in the beginning, see if there is a time specified after the date
3642 // Skip spaces, as the ParseTime() function fails on spaces
3643 while ( wxIsspace(*pchDate
) )
3646 pchTime
= dtTime
.ParseTime(pchDate
);
3648 else // no date in the beginning
3650 // check and see if we have a time followed by a date
3651 pchTime
= dtTime
.ParseTime(date
);
3654 while ( wxIsspace(*pchTime
) )
3657 pchDate
= dtDate
.ParseDate(pchTime
);
3661 // If we have a date specified, set our own data to the same date
3662 if ( !pchDate
|| !pchTime
)
3665 Set(dtDate
.GetDay(), dtDate
.GetMonth(), dtDate
.GetYear(),
3666 dtTime
.GetHour(), dtTime
.GetMinute(), dtTime
.GetSecond(),
3667 dtTime
.GetMillisecond());
3669 // Return endpoint of scan
3670 return pchDate
> pchTime
? pchDate
: pchTime
;
3673 const wxChar
*wxDateTime::ParseDate(const wxChar
*date
)
3675 // this is a simplified version of ParseDateTime() which understands only
3676 // "today" (for wxDate compatibility) and digits only otherwise (and not
3677 // all esoteric constructions ParseDateTime() knows about)
3679 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3681 const wxChar
*p
= date
;
3682 while ( wxIsspace(*p
) )
3685 // some special cases
3689 int dayDiffFromToday
;
3692 { wxTRANSLATE("today"), 0 },
3693 { wxTRANSLATE("yesterday"), -1 },
3694 { wxTRANSLATE("tomorrow"), 1 },
3697 for ( size_t n
= 0; n
< WXSIZEOF(literalDates
); n
++ )
3699 wxString date
= wxGetTranslation(literalDates
[n
].str
);
3700 size_t len
= date
.length();
3701 if ( wxStrlen(p
) >= len
)
3703 wxString
str(p
, len
);
3704 if ( str
.CmpNoCase(date
) == 0 )
3706 // nothing can follow this, so stop here
3709 int dayDiffFromToday
= literalDates
[n
].dayDiffFromToday
;
3711 if ( dayDiffFromToday
)
3713 *this += wxDateSpan::Days(dayDiffFromToday
);
3721 // We try to guess what we have here: for each new (numeric) token, we
3722 // determine if it can be a month, day or a year. Of course, there is an
3723 // ambiguity as some numbers may be days as well as months, so we also
3724 // have the ability to back track.
3727 bool haveDay
= false, // the months day?
3728 haveWDay
= false, // the day of week?
3729 haveMon
= false, // the month?
3730 haveYear
= false; // the year?
3732 // and the value of the items we have (init them to get rid of warnings)
3733 WeekDay wday
= Inv_WeekDay
;
3734 wxDateTime_t day
= 0;
3735 wxDateTime::Month mon
= Inv_Month
;
3738 // tokenize the string
3740 static const wxChar
*dateDelimiters
= _T(".,/-\t\r\n ");
3741 wxStringTokenizer
tok(p
, dateDelimiters
);
3742 while ( tok
.HasMoreTokens() )
3744 wxString token
= tok
.GetNextToken();
3750 if ( token
.ToULong(&val
) )
3752 // guess what this number is
3758 if ( !haveMon
&& val
> 0 && val
<= 12 )
3760 // assume it is month
3763 else // not the month
3767 // this can only be the year
3770 else // may be either day or year
3772 wxDateTime_t max_days
= (wxDateTime_t
)(
3774 ? GetNumOfDaysInMonth(haveYear
? year
: Inv_Year
, mon
)
3779 if ( (val
== 0) || (val
> (unsigned long)max_days
) )
3784 else // yes, suppose it's the day
3798 year
= (wxDateTime_t
)val
;
3807 day
= (wxDateTime_t
)val
;
3813 mon
= (Month
)(val
- 1);
3816 else // not a number
3818 // be careful not to overwrite the current mon value
3819 Month mon2
= GetMonthFromName(token
, Name_Full
| Name_Abbr
);
3820 if ( mon2
!= Inv_Month
)
3825 // but we already have a month - maybe we guessed wrong?
3828 // no need to check in month range as always < 12, but
3829 // the days are counted from 1 unlike the months
3830 day
= (wxDateTime_t
)(mon
+ 1);
3835 // could possible be the year (doesn't the year come
3836 // before the month in the japanese format?) (FIXME)
3845 else // not a valid month name
3847 wday
= GetWeekDayFromName(token
, Name_Full
| Name_Abbr
);
3848 if ( wday
!= Inv_WeekDay
)
3858 else // not a valid weekday name
3861 static const wxChar
*ordinals
[] =
3863 wxTRANSLATE("first"),
3864 wxTRANSLATE("second"),
3865 wxTRANSLATE("third"),
3866 wxTRANSLATE("fourth"),
3867 wxTRANSLATE("fifth"),
3868 wxTRANSLATE("sixth"),
3869 wxTRANSLATE("seventh"),
3870 wxTRANSLATE("eighth"),
3871 wxTRANSLATE("ninth"),
3872 wxTRANSLATE("tenth"),
3873 wxTRANSLATE("eleventh"),
3874 wxTRANSLATE("twelfth"),
3875 wxTRANSLATE("thirteenth"),
3876 wxTRANSLATE("fourteenth"),
3877 wxTRANSLATE("fifteenth"),
3878 wxTRANSLATE("sixteenth"),
3879 wxTRANSLATE("seventeenth"),
3880 wxTRANSLATE("eighteenth"),
3881 wxTRANSLATE("nineteenth"),
3882 wxTRANSLATE("twentieth"),
3883 // that's enough - otherwise we'd have problems with
3884 // composite (or not) ordinals
3888 for ( n
= 0; n
< WXSIZEOF(ordinals
); n
++ )
3890 if ( token
.CmpNoCase(ordinals
[n
]) == 0 )
3896 if ( n
== WXSIZEOF(ordinals
) )
3898 // stop here - something unknown
3905 // don't try anything here (as in case of numeric day
3906 // above) - the symbolic day spec should always
3907 // precede the month/year
3913 day
= (wxDateTime_t
)(n
+ 1);
3918 nPosCur
= tok
.GetPosition();
3921 // either no more tokens or the scan was stopped by something we couldn't
3922 // parse - in any case, see if we can construct a date from what we have
3923 if ( !haveDay
&& !haveWDay
)
3925 wxLogDebug(_T("ParseDate: no day, no weekday hence no date."));
3927 return (wxChar
*)NULL
;
3930 if ( haveWDay
&& (haveMon
|| haveYear
|| haveDay
) &&
3931 !(haveDay
&& haveMon
&& haveYear
) )
3933 // without adjectives (which we don't support here) the week day only
3934 // makes sense completely separately or with the full date
3935 // specification (what would "Wed 1999" mean?)
3936 return (wxChar
*)NULL
;
3939 if ( !haveWDay
&& haveYear
&& !(haveDay
&& haveMon
) )
3941 // may be we have month and day instead of day and year?
3942 if ( haveDay
&& !haveMon
)
3946 // exchange day and month
3947 mon
= (wxDateTime::Month
)(day
- 1);
3949 // we're in the current year then
3950 if ( (year
> 0) && (year
<= (int)GetNumOfDaysInMonth(Inv_Year
, mon
)) )
3952 day
= (wxDateTime_t
)year
;
3957 //else: no, can't exchange, leave haveMon == false
3963 // if we give the year, month and day must be given too
3964 wxLogDebug(_T("ParseDate: day and month should be specified if year is."));
3966 return (wxChar
*)NULL
;
3972 mon
= GetCurrentMonth();
3977 year
= GetCurrentYear();
3982 Set(day
, mon
, year
);
3986 // check that it is really the same
3987 if ( GetWeekDay() != wday
)
3989 // inconsistency detected
3990 wxLogDebug(_T("ParseDate: inconsistent day/weekday."));
3992 return (wxChar
*)NULL
;
4000 SetToWeekDayInSameWeek(wday
);
4003 // return the pointer to the first unparsed char
4005 if ( nPosCur
&& wxStrchr(dateDelimiters
, *(p
- 1)) )
4007 // if we couldn't parse the token after the delimiter, put back the
4008 // delimiter as well
4015 const wxChar
*wxDateTime::ParseTime(const wxChar
*time
)
4017 wxCHECK_MSG( time
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
4019 // first try some extra things
4026 { wxTRANSLATE("noon"), 12 },
4027 { wxTRANSLATE("midnight"), 00 },
4031 for ( size_t n
= 0; n
< WXSIZEOF(stdTimes
); n
++ )
4033 wxString timeString
= wxGetTranslation(stdTimes
[n
].name
);
4034 size_t len
= timeString
.length();
4035 if ( timeString
.CmpNoCase(wxString(time
, len
)) == 0 )
4037 // casts required by DigitalMars
4038 Set(stdTimes
[n
].hour
, wxDateTime_t(0), wxDateTime_t(0));
4044 // try all time formats we may think about in the order from longest to
4047 // 12hour with AM/PM?
4048 const wxChar
*result
= ParseFormat(time
, _T("%I:%M:%S %p"));
4052 // normally, it's the same, but why not try it?
4053 result
= ParseFormat(time
, _T("%H:%M:%S"));
4058 // 12hour with AM/PM but without seconds?
4059 result
= ParseFormat(time
, _T("%I:%M %p"));
4065 result
= ParseFormat(time
, _T("%H:%M"));
4070 // just the hour and AM/PM?
4071 result
= ParseFormat(time
, _T("%I %p"));
4077 result
= ParseFormat(time
, _T("%H"));
4082 // parse the standard format: normally it is one of the formats above
4083 // but it may be set to something completely different by the user
4084 result
= ParseFormat(time
, _T("%X"));
4087 // TODO: parse timezones
4092 // ----------------------------------------------------------------------------
4093 // Workdays and holidays support
4094 // ----------------------------------------------------------------------------
4096 bool wxDateTime::IsWorkDay(Country
WXUNUSED(country
)) const
4098 return !wxDateTimeHolidayAuthority::IsHoliday(*this);
4101 // ============================================================================
4103 // ============================================================================
4105 wxDateSpan WXDLLIMPEXP_BASE
operator*(int n
, const wxDateSpan
& ds
)
4108 return ds1
.Multiply(n
);
4111 // ============================================================================
4113 // ============================================================================
4115 wxTimeSpan WXDLLIMPEXP_BASE
operator*(int n
, const wxTimeSpan
& ts
)
4117 return wxTimeSpan(ts
).Multiply(n
);
4120 // this enum is only used in wxTimeSpan::Format() below but we can't declare
4121 // it locally to the method as it provokes an internal compiler error in egcs
4122 // 2.91.60 when building with -O2
4133 // not all strftime(3) format specifiers make sense here because, for example,
4134 // a time span doesn't have a year nor a timezone
4136 // Here are the ones which are supported (all of them are supported by strftime
4138 // %H hour in 24 hour format
4139 // %M minute (00 - 59)
4140 // %S second (00 - 59)
4143 // Also, for MFC CTimeSpan compatibility, we support
4144 // %D number of days
4146 // And, to be better than MFC :-), we also have
4147 // %E number of wEeks
4148 // %l milliseconds (000 - 999)
4149 wxString
wxTimeSpan::Format(const wxChar
*format
) const
4151 wxCHECK_MSG( format
, wxEmptyString
, _T("NULL format in wxTimeSpan::Format") );
4154 str
.Alloc(wxStrlen(format
));
4156 // Suppose we have wxTimeSpan ts(1 /* hour */, 2 /* min */, 3 /* sec */)
4158 // Then, of course, ts.Format("%H:%M:%S") must return "01:02:03", but the
4159 // question is what should ts.Format("%S") do? The code here returns "3273"
4160 // in this case (i.e. the total number of seconds, not just seconds % 60)
4161 // because, for me, this call means "give me entire time interval in
4162 // seconds" and not "give me the seconds part of the time interval"
4164 // If we agree that it should behave like this, it is clear that the
4165 // interpretation of each format specifier depends on the presence of the
4166 // other format specs in the string: if there was "%H" before "%M", we
4167 // should use GetMinutes() % 60, otherwise just GetMinutes() &c
4169 // we remember the most important unit found so far
4170 TimeSpanPart partBiggest
= Part_MSec
;
4172 for ( const wxChar
*pch
= format
; *pch
; pch
++ )
4176 if ( ch
== _T('%') )
4178 // the start of the format specification of the printf() below
4179 wxString fmtPrefix
= _T('%');
4184 ch
= *++pch
; // get the format spec char
4188 wxFAIL_MSG( _T("invalid format character") );
4194 // skip the part below switch
4199 if ( partBiggest
< Part_Day
)
4205 partBiggest
= Part_Day
;
4210 partBiggest
= Part_Week
;
4216 if ( partBiggest
< Part_Hour
)
4222 partBiggest
= Part_Hour
;
4225 fmtPrefix
+= _T("02");
4229 n
= GetMilliseconds().ToLong();
4230 if ( partBiggest
< Part_MSec
)
4234 //else: no need to reset partBiggest to Part_MSec, it is
4235 // the least significant one anyhow
4237 fmtPrefix
+= _T("03");
4242 if ( partBiggest
< Part_Min
)
4248 partBiggest
= Part_Min
;
4251 fmtPrefix
+= _T("02");
4255 n
= GetSeconds().ToLong();
4256 if ( partBiggest
< Part_Sec
)
4262 partBiggest
= Part_Sec
;
4265 fmtPrefix
+= _T("02");
4269 str
+= wxString::Format(fmtPrefix
+ _T("ld"), n
);
4273 // normal character, just copy
4281 // ============================================================================
4282 // wxDateTimeHolidayAuthority and related classes
4283 // ============================================================================
4285 #include "wx/arrimpl.cpp"
4287 WX_DEFINE_OBJARRAY(wxDateTimeArray
);
4289 static int wxCMPFUNC_CONV
4290 wxDateTimeCompareFunc(wxDateTime
**first
, wxDateTime
**second
)
4292 wxDateTime dt1
= **first
,
4295 return dt1
== dt2
? 0 : dt1
< dt2
? -1 : +1;
4298 // ----------------------------------------------------------------------------
4299 // wxDateTimeHolidayAuthority
4300 // ----------------------------------------------------------------------------
4302 wxHolidayAuthoritiesArray
wxDateTimeHolidayAuthority::ms_authorities
;
4305 bool wxDateTimeHolidayAuthority::IsHoliday(const wxDateTime
& dt
)
4307 size_t count
= ms_authorities
.size();
4308 for ( size_t n
= 0; n
< count
; n
++ )
4310 if ( ms_authorities
[n
]->DoIsHoliday(dt
) )
4321 wxDateTimeHolidayAuthority::GetHolidaysInRange(const wxDateTime
& dtStart
,
4322 const wxDateTime
& dtEnd
,
4323 wxDateTimeArray
& holidays
)
4325 wxDateTimeArray hol
;
4329 size_t count
= ms_authorities
.size();
4330 for ( size_t nAuth
= 0; nAuth
< count
; nAuth
++ )
4332 ms_authorities
[nAuth
]->DoGetHolidaysInRange(dtStart
, dtEnd
, hol
);
4334 WX_APPEND_ARRAY(holidays
, hol
);
4337 holidays
.Sort(wxDateTimeCompareFunc
);
4339 return holidays
.size();
4343 void wxDateTimeHolidayAuthority::ClearAllAuthorities()
4345 WX_CLEAR_ARRAY(ms_authorities
);
4349 void wxDateTimeHolidayAuthority::AddAuthority(wxDateTimeHolidayAuthority
*auth
)
4351 ms_authorities
.push_back(auth
);
4354 wxDateTimeHolidayAuthority::~wxDateTimeHolidayAuthority()
4356 // required here for Darwin
4359 // ----------------------------------------------------------------------------
4360 // wxDateTimeWorkDays
4361 // ----------------------------------------------------------------------------
4363 bool wxDateTimeWorkDays::DoIsHoliday(const wxDateTime
& dt
) const
4365 wxDateTime::WeekDay wd
= dt
.GetWeekDay();
4367 return (wd
== wxDateTime::Sun
) || (wd
== wxDateTime::Sat
);
4370 size_t wxDateTimeWorkDays::DoGetHolidaysInRange(const wxDateTime
& dtStart
,
4371 const wxDateTime
& dtEnd
,
4372 wxDateTimeArray
& holidays
) const
4374 if ( dtStart
> dtEnd
)
4376 wxFAIL_MSG( _T("invalid date range in GetHolidaysInRange") );
4383 // instead of checking all days, start with the first Sat after dtStart and
4384 // end with the last Sun before dtEnd
4385 wxDateTime dtSatFirst
= dtStart
.GetNextWeekDay(wxDateTime::Sat
),
4386 dtSatLast
= dtEnd
.GetPrevWeekDay(wxDateTime::Sat
),
4387 dtSunFirst
= dtStart
.GetNextWeekDay(wxDateTime::Sun
),
4388 dtSunLast
= dtEnd
.GetPrevWeekDay(wxDateTime::Sun
),
4391 for ( dt
= dtSatFirst
; dt
<= dtSatLast
; dt
+= wxDateSpan::Week() )
4396 for ( dt
= dtSunFirst
; dt
<= dtSunLast
; dt
+= wxDateSpan::Week() )
4401 return holidays
.GetCount();
4404 // ============================================================================
4405 // other helper functions
4406 // ============================================================================
4408 // ----------------------------------------------------------------------------
4409 // iteration helpers: can be used to write a for loop over enum variable like
4411 // for ( m = wxDateTime::Jan; m < wxDateTime::Inv_Month; wxNextMonth(m) )
4412 // ----------------------------------------------------------------------------
4414 WXDLLIMPEXP_BASE
void wxNextMonth(wxDateTime::Month
& m
)
4416 wxASSERT_MSG( m
< wxDateTime::Inv_Month
, _T("invalid month") );
4418 // no wrapping or the for loop above would never end!
4419 m
= (wxDateTime::Month
)(m
+ 1);
4422 WXDLLIMPEXP_BASE
void wxPrevMonth(wxDateTime::Month
& m
)
4424 wxASSERT_MSG( m
< wxDateTime::Inv_Month
, _T("invalid month") );
4426 m
= m
== wxDateTime::Jan
? wxDateTime::Inv_Month
4427 : (wxDateTime::Month
)(m
- 1);
4430 WXDLLIMPEXP_BASE
void wxNextWDay(wxDateTime::WeekDay
& wd
)
4432 wxASSERT_MSG( wd
< wxDateTime::Inv_WeekDay
, _T("invalid week day") );
4434 // no wrapping or the for loop above would never end!
4435 wd
= (wxDateTime::WeekDay
)(wd
+ 1);
4438 WXDLLIMPEXP_BASE
void wxPrevWDay(wxDateTime::WeekDay
& wd
)
4440 wxASSERT_MSG( wd
< wxDateTime::Inv_WeekDay
, _T("invalid week day") );
4442 wd
= wd
== wxDateTime::Sun
? wxDateTime::Inv_WeekDay
4443 : (wxDateTime::WeekDay
)(wd
- 1);
4446 #endif // wxUSE_DATETIME