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(__MWERKS__) && wxUSE_UNICODE
134 #if !defined(WX_TIMEZONE) && !defined(WX_GMTOFF_IN_TM)
135 #if defined(__WXPALMOS__)
136 #define WX_GMTOFF_IN_TM
137 #elif defined(__BORLANDC__) || defined(__MINGW32__) || defined(__VISAGECPP__)
138 #define WX_TIMEZONE _timezone
139 #elif defined(__MWERKS__)
140 long wxmw_timezone
= 28800;
141 #define WX_TIMEZONE wxmw_timezone
142 #elif defined(__DJGPP__) || defined(__WINE__)
143 #include <sys/timeb.h>
145 static long wxGetTimeZone()
147 static long timezone
= MAXLONG
; // invalid timezone
148 if (timezone
== MAXLONG
)
152 timezone
= tb
.timezone
;
156 #define WX_TIMEZONE wxGetTimeZone()
157 #elif defined(__DARWIN__)
158 #define WX_GMTOFF_IN_TM
159 #else // unknown platform - try timezone
160 #define WX_TIMEZONE timezone
162 #endif // !WX_TIMEZONE && !WX_GMTOFF_IN_TM
164 // ----------------------------------------------------------------------------
166 // ----------------------------------------------------------------------------
168 // debugging helper: just a convenient replacement of wxCHECK()
169 #define wxDATETIME_CHECK(expr, msg) \
173 *this = wxInvalidDateTime; \
177 // ----------------------------------------------------------------------------
179 // ----------------------------------------------------------------------------
181 class wxDateTimeHolidaysModule
: public wxModule
184 virtual bool OnInit()
186 wxDateTimeHolidayAuthority::AddAuthority(new wxDateTimeWorkDays
);
191 virtual void OnExit()
193 wxDateTimeHolidayAuthority::ClearAllAuthorities();
194 wxDateTimeHolidayAuthority::ms_authorities
.clear();
198 DECLARE_DYNAMIC_CLASS(wxDateTimeHolidaysModule
)
201 IMPLEMENT_DYNAMIC_CLASS(wxDateTimeHolidaysModule
, wxModule
)
203 // ----------------------------------------------------------------------------
205 // ----------------------------------------------------------------------------
208 static const int MONTHS_IN_YEAR
= 12;
210 static const int SEC_PER_MIN
= 60;
212 static const int MIN_PER_HOUR
= 60;
214 static const int HOURS_PER_DAY
= 24;
216 static const long SECONDS_PER_DAY
= 86400l;
218 static const int DAYS_PER_WEEK
= 7;
220 static const long MILLISECONDS_PER_DAY
= 86400000l;
222 // this is the integral part of JDN of the midnight of Jan 1, 1970
223 // (i.e. JDN(Jan 1, 1970) = 2440587.5)
224 static const long EPOCH_JDN
= 2440587l;
226 // the date of JDN -0.5 (as we don't work with fractional parts, this is the
227 // reference date for us) is Nov 24, 4714BC
228 static const int JDN_0_YEAR
= -4713;
229 static const int JDN_0_MONTH
= wxDateTime::Nov
;
230 static const int JDN_0_DAY
= 24;
232 // the constants used for JDN calculations
233 static const long JDN_OFFSET
= 32046l;
234 static const long DAYS_PER_5_MONTHS
= 153l;
235 static const long DAYS_PER_4_YEARS
= 1461l;
236 static const long DAYS_PER_400_YEARS
= 146097l;
238 // this array contains the cumulated number of days in all previous months for
239 // normal and leap years
240 static const wxDateTime::wxDateTime_t gs_cumulatedDays
[2][MONTHS_IN_YEAR
] =
242 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
243 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
246 // ----------------------------------------------------------------------------
248 // ----------------------------------------------------------------------------
250 const wxChar
* wxDefaultDateTimeFormat
= wxT("%c");
251 const wxChar
* wxDefaultTimeSpanFormat
= wxT("%H:%M:%S");
253 // in the fine tradition of ANSI C we use our equivalent of (time_t)-1 to
254 // indicate an invalid wxDateTime object
255 const wxDateTime wxDefaultDateTime
;
257 wxDateTime::Country
wxDateTime::ms_country
= wxDateTime::Country_Unknown
;
259 // ----------------------------------------------------------------------------
261 // ----------------------------------------------------------------------------
263 // debugger helper: shows what the date really is
265 extern const wxChar
*wxDumpDate(const wxDateTime
* dt
)
267 static wxChar buf
[128];
269 wxStrcpy(buf
, dt
->Format(_T("%Y-%m-%d (%a) %H:%M:%S")));
275 // get the number of days in the given month of the given year
277 wxDateTime::wxDateTime_t
GetNumOfDaysInMonth(int year
, wxDateTime::Month month
)
279 // the number of days in month in Julian/Gregorian calendar: the first line
280 // is for normal years, the second one is for the leap ones
281 static wxDateTime::wxDateTime_t daysInMonth
[2][MONTHS_IN_YEAR
] =
283 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
284 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
287 return daysInMonth
[wxDateTime::IsLeapYear(year
)][month
];
290 // returns the time zone in the C sense, i.e. the difference UTC - local
292 static int GetTimeZone()
294 #ifdef WX_GMTOFF_IN_TM
295 // set to true when the timezone is set
296 static bool s_timezoneSet
= false;
297 static long gmtoffset
= LONG_MAX
; // invalid timezone
299 // ensure that the timezone variable is set by calling localtime
300 if ( !s_timezoneSet
)
302 // just call localtime() instead of figuring out whether this system
303 // supports tzset(), _tzset() or something else
308 s_timezoneSet
= true;
310 // note that GMT offset is the opposite of time zone and so to return
311 // consistent results in both WX_GMTOFF_IN_TM and !WX_GMTOFF_IN_TM
312 // cases we have to negate it
313 gmtoffset
= -tm
->tm_gmtoff
;
316 return (int)gmtoffset
;
317 #else // !WX_GMTOFF_IN_TM
318 return (int)WX_TIMEZONE
;
319 #endif // WX_GMTOFF_IN_TM/!WX_GMTOFF_IN_TM
322 // return the integral part of the JDN for the midnight of the given date (to
323 // get the real JDN you need to add 0.5, this is, in fact, JDN of the
324 // noon of the previous day)
325 static long GetTruncatedJDN(wxDateTime::wxDateTime_t day
,
326 wxDateTime::Month mon
,
329 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
331 // check the date validity
333 (year
> JDN_0_YEAR
) ||
334 ((year
== JDN_0_YEAR
) && (mon
> JDN_0_MONTH
)) ||
335 ((year
== JDN_0_YEAR
) && (mon
== JDN_0_MONTH
) && (day
>= JDN_0_DAY
)),
336 _T("date out of range - can't convert to JDN")
339 // make the year positive to avoid problems with negative numbers division
342 // months are counted from March here
344 if ( mon
>= wxDateTime::Mar
)
354 // now we can simply add all the contributions together
355 return ((year
/ 100) * DAYS_PER_400_YEARS
) / 4
356 + ((year
% 100) * DAYS_PER_4_YEARS
) / 4
357 + (month
* DAYS_PER_5_MONTHS
+ 2) / 5
363 // this function is a wrapper around strftime(3) adding error checking
364 static wxString
CallStrftime(const wxChar
*format
, const tm
* tm
)
367 if ( !wxStrftime(buf
, WXSIZEOF(buf
), format
, tm
) )
369 // buffer is too small?
370 wxFAIL_MSG(_T("strftime() failed"));
373 return wxString(buf
);
379 // glibc2 doesn't define this in the headers unless _XOPEN_SOURCE is defined
380 // which, unfortunately, wreaks havoc elsewhere
381 #if defined(__GLIBC__) && (__GLIBC__ == 2)
382 extern "C" char *strptime(const char *, const char *, struct tm
*);
385 // Unicode-friendly strptime() wrapper
386 static const wxChar
*
387 CallStrptime(const wxChar
*input
, const char *fmt
, tm
*tm
)
389 // the problem here is that strptime() returns pointer into the string we
390 // passed to it while we're really interested in the pointer into the
391 // original, Unicode, string so we try to transform the pointer back
393 wxCharBuffer
inputMB(wxConvertWX2MB(input
));
395 const char * const inputMB
= input
;
396 #endif // Unicode/Ascii
398 const char *result
= strptime(inputMB
, fmt
, tm
);
403 // FIXME: this is wrong in presence of surrogates &c
404 return input
+ (result
- inputMB
.data());
407 #endif // Unicode/Ascii
410 #endif // HAVE_STRPTIME
412 // if year and/or month have invalid values, replace them with the current ones
413 static void ReplaceDefaultYearMonthWithCurrent(int *year
,
414 wxDateTime::Month
*month
)
416 struct tm
*tmNow
= NULL
;
418 if ( *year
== wxDateTime::Inv_Year
)
420 tmNow
= wxDateTime::GetTmNow();
422 *year
= 1900 + tmNow
->tm_year
;
425 if ( *month
== wxDateTime::Inv_Month
)
428 tmNow
= wxDateTime::GetTmNow();
430 *month
= (wxDateTime::Month
)tmNow
->tm_mon
;
434 // fll the struct tm with default values
435 static void InitTm(struct tm
& tm
)
437 // struct tm may have etxra fields (undocumented and with unportable
438 // names) which, nevertheless, must be set to 0
439 memset(&tm
, 0, sizeof(struct tm
));
441 tm
.tm_mday
= 1; // mday 0 is invalid
442 tm
.tm_year
= 76; // any valid year
443 tm
.tm_isdst
= -1; // auto determine
449 // return the month if the string is a month name or Inv_Month otherwise
450 static wxDateTime::Month
GetMonthFromName(const wxString
& name
, int flags
)
452 wxDateTime::Month mon
;
453 for ( mon
= wxDateTime::Jan
; mon
< wxDateTime::Inv_Month
; wxNextMonth(mon
) )
455 // case-insensitive comparison either one of or with both abbreviated
457 if ( flags
& wxDateTime::Name_Full
)
459 if ( name
.CmpNoCase(wxDateTime::
460 GetMonthName(mon
, wxDateTime::Name_Full
)) == 0 )
466 if ( flags
& wxDateTime::Name_Abbr
)
468 if ( name
.CmpNoCase(wxDateTime::
469 GetMonthName(mon
, wxDateTime::Name_Abbr
)) == 0 )
479 // return the weekday if the string is a weekday name or Inv_WeekDay otherwise
480 static wxDateTime::WeekDay
GetWeekDayFromName(const wxString
& name
, int flags
)
482 wxDateTime::WeekDay wd
;
483 for ( wd
= wxDateTime::Sun
; wd
< wxDateTime::Inv_WeekDay
; wxNextWDay(wd
) )
485 // case-insensitive comparison either one of or with both abbreviated
487 if ( flags
& wxDateTime::Name_Full
)
489 if ( name
.CmpNoCase(wxDateTime::
490 GetWeekDayName(wd
, wxDateTime::Name_Full
)) == 0 )
496 if ( flags
& wxDateTime::Name_Abbr
)
498 if ( name
.CmpNoCase(wxDateTime::
499 GetWeekDayName(wd
, wxDateTime::Name_Abbr
)) == 0 )
509 // scans all digits (but no more than len) and returns the resulting number
510 static bool GetNumericToken(size_t len
, const wxChar
*& p
, unsigned long *number
)
514 while ( wxIsdigit(*p
) )
518 if ( len
&& ++n
> len
)
522 return !s
.empty() && s
.ToULong(number
);
525 // scans all alphabetic characters and returns the resulting string
526 static wxString
GetAlphaToken(const wxChar
*& p
)
529 while ( wxIsalpha(*p
) )
537 // ============================================================================
538 // implementation of wxDateTime
539 // ============================================================================
541 // ----------------------------------------------------------------------------
543 // ----------------------------------------------------------------------------
547 year
= (wxDateTime_t
)wxDateTime::Inv_Year
;
548 mon
= wxDateTime::Inv_Month
;
550 hour
= min
= sec
= msec
= 0;
551 wday
= wxDateTime::Inv_WeekDay
;
554 wxDateTime::Tm::Tm(const struct tm
& tm
, const TimeZone
& tz
)
558 sec
= (wxDateTime::wxDateTime_t
)tm
.tm_sec
;
559 min
= (wxDateTime::wxDateTime_t
)tm
.tm_min
;
560 hour
= (wxDateTime::wxDateTime_t
)tm
.tm_hour
;
561 mday
= (wxDateTime::wxDateTime_t
)tm
.tm_mday
;
562 mon
= (wxDateTime::Month
)tm
.tm_mon
;
563 year
= 1900 + tm
.tm_year
;
564 wday
= (wxDateTime::wxDateTime_t
)tm
.tm_wday
;
565 yday
= (wxDateTime::wxDateTime_t
)tm
.tm_yday
;
568 bool wxDateTime::Tm::IsValid() const
570 // we allow for the leap seconds, although we don't use them (yet)
571 return (year
!= wxDateTime::Inv_Year
) && (mon
!= wxDateTime::Inv_Month
) &&
572 (mday
<= GetNumOfDaysInMonth(year
, mon
)) &&
573 (hour
< 24) && (min
< 60) && (sec
< 62) && (msec
< 1000);
576 void wxDateTime::Tm::ComputeWeekDay()
578 // compute the week day from day/month/year: we use the dumbest algorithm
579 // possible: just compute our JDN and then use the (simple to derive)
580 // formula: weekday = (JDN + 1.5) % 7
581 wday
= (wxDateTime::wxDateTime_t
)((wxDateTime::WeekDay
)(GetTruncatedJDN(mday
, mon
, year
) + 2) % 7);
584 void wxDateTime::Tm::AddMonths(int monDiff
)
586 // normalize the months field
587 while ( monDiff
< -mon
)
591 monDiff
+= MONTHS_IN_YEAR
;
594 while ( monDiff
+ mon
>= MONTHS_IN_YEAR
)
598 monDiff
-= MONTHS_IN_YEAR
;
601 mon
= (wxDateTime::Month
)(mon
+ monDiff
);
603 wxASSERT_MSG( mon
>= 0 && mon
< MONTHS_IN_YEAR
, _T("logic error") );
605 // NB: we don't check here that the resulting date is valid, this function
606 // is private and the caller must check it if needed
609 void wxDateTime::Tm::AddDays(int dayDiff
)
611 // normalize the days field
612 while ( dayDiff
+ mday
< 1 )
616 dayDiff
+= GetNumOfDaysInMonth(year
, mon
);
619 mday
= (wxDateTime::wxDateTime_t
)( mday
+ dayDiff
);
620 while ( mday
> GetNumOfDaysInMonth(year
, mon
) )
622 mday
-= GetNumOfDaysInMonth(year
, mon
);
627 wxASSERT_MSG( mday
> 0 && mday
<= GetNumOfDaysInMonth(year
, mon
),
631 // ----------------------------------------------------------------------------
633 // ----------------------------------------------------------------------------
635 wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz
)
639 case wxDateTime::Local
:
640 // get the offset from C RTL: it returns the difference GMT-local
641 // while we want to have the offset _from_ GMT, hence the '-'
642 m_offset
= -GetTimeZone();
645 case wxDateTime::GMT_12
:
646 case wxDateTime::GMT_11
:
647 case wxDateTime::GMT_10
:
648 case wxDateTime::GMT_9
:
649 case wxDateTime::GMT_8
:
650 case wxDateTime::GMT_7
:
651 case wxDateTime::GMT_6
:
652 case wxDateTime::GMT_5
:
653 case wxDateTime::GMT_4
:
654 case wxDateTime::GMT_3
:
655 case wxDateTime::GMT_2
:
656 case wxDateTime::GMT_1
:
657 m_offset
= -3600*(wxDateTime::GMT0
- tz
);
660 case wxDateTime::GMT0
:
661 case wxDateTime::GMT1
:
662 case wxDateTime::GMT2
:
663 case wxDateTime::GMT3
:
664 case wxDateTime::GMT4
:
665 case wxDateTime::GMT5
:
666 case wxDateTime::GMT6
:
667 case wxDateTime::GMT7
:
668 case wxDateTime::GMT8
:
669 case wxDateTime::GMT9
:
670 case wxDateTime::GMT10
:
671 case wxDateTime::GMT11
:
672 case wxDateTime::GMT12
:
673 m_offset
= 3600*(tz
- wxDateTime::GMT0
);
676 case wxDateTime::A_CST
:
677 // Central Standard Time in use in Australia = UTC + 9.5
678 m_offset
= 60l*(9*60 + 30);
682 wxFAIL_MSG( _T("unknown time zone") );
686 // ----------------------------------------------------------------------------
688 // ----------------------------------------------------------------------------
691 bool wxDateTime::IsLeapYear(int year
, wxDateTime::Calendar cal
)
693 if ( year
== Inv_Year
)
694 year
= GetCurrentYear();
696 if ( cal
== Gregorian
)
698 // in Gregorian calendar leap years are those divisible by 4 except
699 // those divisible by 100 unless they're also divisible by 400
700 // (in some countries, like Russia and Greece, additional corrections
701 // exist, but they won't manifest themselves until 2700)
702 return (year
% 4 == 0) && ((year
% 100 != 0) || (year
% 400 == 0));
704 else if ( cal
== Julian
)
706 // in Julian calendar the rule is simpler
707 return year
% 4 == 0;
711 wxFAIL_MSG(_T("unknown calendar"));
718 int wxDateTime::GetCentury(int year
)
720 return year
> 0 ? year
/ 100 : year
/ 100 - 1;
724 int wxDateTime::ConvertYearToBC(int year
)
727 return year
> 0 ? year
: year
- 1;
731 int wxDateTime::GetCurrentYear(wxDateTime::Calendar cal
)
736 return Now().GetYear();
739 wxFAIL_MSG(_T("TODO"));
743 wxFAIL_MSG(_T("unsupported calendar"));
751 wxDateTime::Month
wxDateTime::GetCurrentMonth(wxDateTime::Calendar cal
)
756 return Now().GetMonth();
759 wxFAIL_MSG(_T("TODO"));
763 wxFAIL_MSG(_T("unsupported calendar"));
771 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(int year
, Calendar cal
)
773 if ( year
== Inv_Year
)
775 // take the current year if none given
776 year
= GetCurrentYear();
783 return IsLeapYear(year
) ? 366 : 365;
786 wxFAIL_MSG(_T("unsupported calendar"));
794 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(wxDateTime::Month month
,
796 wxDateTime::Calendar cal
)
798 wxCHECK_MSG( month
< MONTHS_IN_YEAR
, 0, _T("invalid month") );
800 if ( cal
== Gregorian
|| cal
== Julian
)
802 if ( year
== Inv_Year
)
804 // take the current year if none given
805 year
= GetCurrentYear();
808 return GetNumOfDaysInMonth(year
, month
);
812 wxFAIL_MSG(_T("unsupported calendar"));
819 wxString
wxDateTime::GetMonthName(wxDateTime::Month month
,
820 wxDateTime::NameFlags flags
)
822 wxCHECK_MSG( month
!= Inv_Month
, wxEmptyString
, _T("invalid month") );
824 // notice that we must set all the fields to avoid confusing libc (GNU one
825 // gets confused to a crash if we don't do this)
830 return CallStrftime(flags
== Name_Abbr
? _T("%b") : _T("%B"), &tm
);
836 ret
= (flags
== Name_Abbr
? wxT("Jan"): wxT("January"));
839 ret
= (flags
== Name_Abbr
? wxT("Feb"): wxT("Febuary"));
842 ret
= (flags
== Name_Abbr
? wxT("Mar"): wxT("March"));
845 ret
= (flags
== Name_Abbr
? wxT("Apr"): wxT("April"));
848 ret
= (flags
== Name_Abbr
? wxT("May"): wxT("May"));
851 ret
= (flags
== Name_Abbr
? wxT("Jun"): wxT("June"));
854 ret
= (flags
== Name_Abbr
? wxT("Jul"): wxT("July"));
857 ret
= (flags
== Name_Abbr
? wxT("Aug"): wxT("August"));
860 ret
= (flags
== Name_Abbr
? wxT("Sep"): wxT("September"));
863 ret
= (flags
== Name_Abbr
? wxT("Oct"): wxT("October"));
866 ret
= (flags
== Name_Abbr
? wxT("Nov"): wxT("November"));
869 ret
= (flags
== Name_Abbr
? wxT("Dec"): wxT("December"));
877 wxString
wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday
,
878 wxDateTime::NameFlags flags
)
880 wxCHECK_MSG( wday
!= Inv_WeekDay
, wxEmptyString
, _T("invalid weekday") );
882 // take some arbitrary Sunday (but notice that the day should be such that
883 // after adding wday to it below we still have a valid date, e.g. don't
891 // and offset it by the number of days needed to get the correct wday
894 // call mktime() to normalize it...
897 // ... and call strftime()
898 return CallStrftime(flags
== Name_Abbr
? _T("%a") : _T("%A"), &tm
);
904 ret
= (flags
== Name_Abbr
? wxT("Sun") : wxT("Sunday"));
907 ret
= (flags
== Name_Abbr
? wxT("Mon") : wxT("Monday"));
910 ret
= (flags
== Name_Abbr
? wxT("Tue") : wxT("Tuesday"));
913 ret
= (flags
== Name_Abbr
? wxT("Wed") : wxT("Wednesday"));
916 ret
= (flags
== Name_Abbr
? wxT("Thu") : wxT("Thursday"));
919 ret
= (flags
== Name_Abbr
? wxT("Fri") : wxT("Friday"));
922 ret
= (flags
== Name_Abbr
? wxT("Sat") : wxT("Saturday"));
931 void wxDateTime::GetAmPmStrings(wxString
*am
, wxString
*pm
)
936 // @Note: Do not call 'CallStrftime' here! CallStrftime checks the return code
937 // and causes an assertion failed if the buffer is to small (which is good) - OR -
938 // if strftime does not return anything because the format string is invalid - OR -
939 // if there are no 'am' / 'pm' tokens defined for the current locale (which is not good).
940 // wxDateTime::ParseTime will try several different formats to parse the time.
941 // As a result, GetAmPmStrings might get called, even if the current locale
942 // does not define any 'am' / 'pm' tokens. In this case, wxStrftime would
943 // assert, even though it is a perfectly legal use.
946 if (wxStrftime(buffer
, sizeof(buffer
)/sizeof(wxChar
), _T("%p"), &tm
) > 0)
947 *am
= wxString(buffer
);
954 if (wxStrftime(buffer
, sizeof(buffer
)/sizeof(wxChar
), _T("%p"), &tm
) > 0)
955 *pm
= wxString(buffer
);
961 // ----------------------------------------------------------------------------
962 // Country stuff: date calculations depend on the country (DST, work days,
963 // ...), so we need to know which rules to follow.
964 // ----------------------------------------------------------------------------
967 wxDateTime::Country
wxDateTime::GetCountry()
969 // TODO use LOCALE_ICOUNTRY setting under Win32
971 if ( ms_country
== Country_Unknown
)
973 // try to guess from the time zone name
974 time_t t
= time(NULL
);
975 struct tm
*tm
= localtime(&t
);
977 wxString tz
= CallStrftime(_T("%Z"), tm
);
978 if ( tz
== _T("WET") || tz
== _T("WEST") )
982 else if ( tz
== _T("CET") || tz
== _T("CEST") )
984 ms_country
= Country_EEC
;
986 else if ( tz
== _T("MSK") || tz
== _T("MSD") )
990 else if ( tz
== _T("AST") || tz
== _T("ADT") ||
991 tz
== _T("EST") || tz
== _T("EDT") ||
992 tz
== _T("CST") || tz
== _T("CDT") ||
993 tz
== _T("MST") || tz
== _T("MDT") ||
994 tz
== _T("PST") || tz
== _T("PDT") )
1000 // well, choose a default one
1012 void wxDateTime::SetCountry(wxDateTime::Country country
)
1014 ms_country
= country
;
1018 bool wxDateTime::IsWestEuropeanCountry(Country country
)
1020 if ( country
== Country_Default
)
1022 country
= GetCountry();
1025 return (Country_WesternEurope_Start
<= country
) &&
1026 (country
<= Country_WesternEurope_End
);
1029 // ----------------------------------------------------------------------------
1030 // DST calculations: we use 3 different rules for the West European countries,
1031 // USA and for the rest of the world. This is undoubtedly false for many
1032 // countries, but I lack the necessary info (and the time to gather it),
1033 // please add the other rules here!
1034 // ----------------------------------------------------------------------------
1037 bool wxDateTime::IsDSTApplicable(int year
, Country country
)
1039 if ( year
== Inv_Year
)
1041 // take the current year if none given
1042 year
= GetCurrentYear();
1045 if ( country
== Country_Default
)
1047 country
= GetCountry();
1054 // DST was first observed in the US and UK during WWI, reused
1055 // during WWII and used again since 1966
1056 return year
>= 1966 ||
1057 (year
>= 1942 && year
<= 1945) ||
1058 (year
== 1918 || year
== 1919);
1061 // assume that it started after WWII
1067 wxDateTime
wxDateTime::GetBeginDST(int year
, Country country
)
1069 if ( year
== Inv_Year
)
1071 // take the current year if none given
1072 year
= GetCurrentYear();
1075 if ( country
== Country_Default
)
1077 country
= GetCountry();
1080 if ( !IsDSTApplicable(year
, country
) )
1082 return wxInvalidDateTime
;
1087 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
1089 // DST begins at 1 a.m. GMT on the last Sunday of March
1090 if ( !dt
.SetToLastWeekDay(Sun
, Mar
, year
) )
1093 wxFAIL_MSG( _T("no last Sunday in March?") );
1096 dt
+= wxTimeSpan::Hours(1);
1098 // disable DST tests because it could result in an infinite recursion!
1101 else switch ( country
)
1108 // don't know for sure - assume it was in effect all year
1113 dt
.Set(1, Jan
, year
);
1117 // DST was installed Feb 2, 1942 by the Congress
1118 dt
.Set(2, Feb
, year
);
1121 // Oil embargo changed the DST period in the US
1123 dt
.Set(6, Jan
, 1974);
1127 dt
.Set(23, Feb
, 1975);
1131 // before 1986, DST begun on the last Sunday of April, but
1132 // in 1986 Reagan changed it to begin at 2 a.m. of the
1133 // first Sunday in April
1136 if ( !dt
.SetToLastWeekDay(Sun
, Apr
, year
) )
1139 wxFAIL_MSG( _T("no first Sunday in April?") );
1144 if ( !dt
.SetToWeekDay(Sun
, 1, Apr
, year
) )
1147 wxFAIL_MSG( _T("no first Sunday in April?") );
1151 dt
+= wxTimeSpan::Hours(2);
1153 // TODO what about timezone??
1159 // assume Mar 30 as the start of the DST for the rest of the world
1160 // - totally bogus, of course
1161 dt
.Set(30, Mar
, year
);
1168 wxDateTime
wxDateTime::GetEndDST(int year
, Country country
)
1170 if ( year
== Inv_Year
)
1172 // take the current year if none given
1173 year
= GetCurrentYear();
1176 if ( country
== Country_Default
)
1178 country
= GetCountry();
1181 if ( !IsDSTApplicable(year
, country
) )
1183 return wxInvalidDateTime
;
1188 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
1190 // DST ends at 1 a.m. GMT on the last Sunday of October
1191 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1193 // weirder and weirder...
1194 wxFAIL_MSG( _T("no last Sunday in October?") );
1197 dt
+= wxTimeSpan::Hours(1);
1199 // disable DST tests because it could result in an infinite recursion!
1202 else switch ( country
)
1209 // don't know for sure - assume it was in effect all year
1213 dt
.Set(31, Dec
, year
);
1217 // the time was reset after the end of the WWII
1218 dt
.Set(30, Sep
, year
);
1222 // DST ends at 2 a.m. on the last Sunday of October
1223 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
1225 // weirder and weirder...
1226 wxFAIL_MSG( _T("no last Sunday in October?") );
1229 dt
+= wxTimeSpan::Hours(2);
1231 // TODO what about timezone??
1236 // assume October 26th as the end of the DST - totally bogus too
1237 dt
.Set(26, Oct
, year
);
1243 // ----------------------------------------------------------------------------
1244 // constructors and assignment operators
1245 // ----------------------------------------------------------------------------
1247 // return the current time with ms precision
1248 /* static */ wxDateTime
wxDateTime::UNow()
1250 return wxDateTime(wxGetLocalTimeMillis());
1253 // the values in the tm structure contain the local time
1254 wxDateTime
& wxDateTime::Set(const struct tm
& tm
)
1257 time_t timet
= mktime(&tm2
);
1259 if ( timet
== (time_t)-1 )
1261 // mktime() rather unintuitively fails for Jan 1, 1970 if the hour is
1262 // less than timezone - try to make it work for this case
1263 if ( tm2
.tm_year
== 70 && tm2
.tm_mon
== 0 && tm2
.tm_mday
== 1 )
1265 return Set((time_t)(
1267 tm2
.tm_hour
* MIN_PER_HOUR
* SEC_PER_MIN
+
1268 tm2
.tm_min
* SEC_PER_MIN
+
1272 wxFAIL_MSG( _T("mktime() failed") );
1274 *this = wxInvalidDateTime
;
1284 wxDateTime
& wxDateTime::Set(wxDateTime_t hour
,
1285 wxDateTime_t minute
,
1286 wxDateTime_t second
,
1287 wxDateTime_t millisec
)
1289 // we allow seconds to be 61 to account for the leap seconds, even if we
1290 // don't use them really
1291 wxDATETIME_CHECK( hour
< 24 &&
1295 _T("Invalid time in wxDateTime::Set()") );
1297 // get the current date from system
1298 struct tm
*tm
= GetTmNow();
1300 wxDATETIME_CHECK( tm
, _T("localtime() failed") );
1302 // make a copy so it isn't clobbered by the call to mktime() below
1307 tm1
.tm_min
= minute
;
1308 tm1
.tm_sec
= second
;
1310 // and the DST in case it changes on this date
1313 if ( tm2
.tm_isdst
!= tm1
.tm_isdst
)
1314 tm1
.tm_isdst
= tm2
.tm_isdst
;
1318 // and finally adjust milliseconds
1319 return SetMillisecond(millisec
);
1322 wxDateTime
& wxDateTime::Set(wxDateTime_t day
,
1326 wxDateTime_t minute
,
1327 wxDateTime_t second
,
1328 wxDateTime_t millisec
)
1330 wxDATETIME_CHECK( hour
< 24 &&
1334 _T("Invalid time in wxDateTime::Set()") );
1336 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1338 wxDATETIME_CHECK( (0 < day
) && (day
<= GetNumberOfDays(month
, year
)),
1339 _T("Invalid date in wxDateTime::Set()") );
1341 // the range of time_t type (inclusive)
1342 static const int yearMinInRange
= 1970;
1343 static const int yearMaxInRange
= 2037;
1345 // test only the year instead of testing for the exact end of the Unix
1346 // time_t range - it doesn't bring anything to do more precise checks
1347 if ( year
>= yearMinInRange
&& year
<= yearMaxInRange
)
1349 // use the standard library version if the date is in range - this is
1350 // probably more efficient than our code
1352 tm
.tm_year
= year
- 1900;
1358 tm
.tm_isdst
= -1; // mktime() will guess it
1362 // and finally adjust milliseconds
1364 SetMillisecond(millisec
);
1370 // do time calculations ourselves: we want to calculate the number of
1371 // milliseconds between the given date and the epoch
1373 // get the JDN for the midnight of this day
1374 m_time
= GetTruncatedJDN(day
, month
, year
);
1375 m_time
-= EPOCH_JDN
;
1376 m_time
*= SECONDS_PER_DAY
* TIME_T_FACTOR
;
1378 // JDN corresponds to GMT, we take localtime
1379 Add(wxTimeSpan(hour
, minute
, second
+ GetTimeZone(), millisec
));
1385 wxDateTime
& wxDateTime::Set(double jdn
)
1387 // so that m_time will be 0 for the midnight of Jan 1, 1970 which is jdn
1389 jdn
-= EPOCH_JDN
+ 0.5;
1391 jdn
*= MILLISECONDS_PER_DAY
;
1395 // JDNs always suppose an UTC date, so bring it back to local time zone
1396 // (also see GetJulianDayNumber() implementation)
1397 long tzDiff
= GetTimeZone();
1400 // FIXME: again, we suppose that DST is always one hour
1404 m_time
+= tzDiff
*1000; // tzDiff is in seconds
1409 wxDateTime
& wxDateTime::ResetTime()
1413 if ( tm
.hour
|| tm
.min
|| tm
.sec
|| tm
.msec
)
1426 // ----------------------------------------------------------------------------
1427 // DOS Date and Time Format functions
1428 // ----------------------------------------------------------------------------
1429 // the dos date and time value is an unsigned 32 bit value in the format:
1430 // YYYYYYYMMMMDDDDDhhhhhmmmmmmsssss
1432 // Y = year offset from 1980 (0-127)
1434 // D = day of month (1-31)
1436 // m = minute (0-59)
1437 // s = bisecond (0-29) each bisecond indicates two seconds
1438 // ----------------------------------------------------------------------------
1440 wxDateTime
& wxDateTime::SetFromDOS(unsigned long ddt
)
1445 long year
= ddt
& 0xFE000000;
1450 long month
= ddt
& 0x1E00000;
1455 long day
= ddt
& 0x1F0000;
1459 long hour
= ddt
& 0xF800;
1463 long minute
= ddt
& 0x7E0;
1467 long second
= ddt
& 0x1F;
1468 tm
.tm_sec
= second
* 2;
1470 return Set(mktime(&tm
));
1473 unsigned long wxDateTime::GetAsDOS() const
1476 time_t ticks
= GetTicks();
1477 struct tm
*tm
= localtime(&ticks
);
1479 long year
= tm
->tm_year
;
1483 long month
= tm
->tm_mon
;
1487 long day
= tm
->tm_mday
;
1490 long hour
= tm
->tm_hour
;
1493 long minute
= tm
->tm_min
;
1496 long second
= tm
->tm_sec
;
1499 ddt
= year
| month
| day
| hour
| minute
| second
;
1503 // ----------------------------------------------------------------------------
1504 // time_t <-> broken down time conversions
1505 // ----------------------------------------------------------------------------
1507 wxDateTime::Tm
wxDateTime::GetTm(const TimeZone
& tz
) const
1509 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1511 time_t time
= GetTicks();
1512 if ( time
!= (time_t)-1 )
1514 // use C RTL functions
1516 if ( tz
.GetOffset() == -GetTimeZone() )
1518 // we are working with local time
1519 tm
= localtime(&time
);
1521 // should never happen
1522 wxCHECK_MSG( tm
, Tm(), _T("localtime() failed") );
1526 time
+= (time_t)tz
.GetOffset();
1527 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
1528 int time2
= (int) time
;
1536 // should never happen
1537 wxCHECK_MSG( tm
, Tm(), _T("gmtime() failed") );
1541 tm
= (struct tm
*)NULL
;
1547 // adjust the milliseconds
1549 long timeOnly
= (m_time
% MILLISECONDS_PER_DAY
).ToLong();
1550 tm2
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1553 //else: use generic code below
1556 // remember the time and do the calculations with the date only - this
1557 // eliminates rounding errors of the floating point arithmetics
1559 wxLongLong timeMidnight
= m_time
+ tz
.GetOffset() * 1000;
1561 long timeOnly
= (timeMidnight
% MILLISECONDS_PER_DAY
).ToLong();
1563 // we want to always have positive time and timeMidnight to be really
1564 // the midnight before it
1567 timeOnly
= MILLISECONDS_PER_DAY
+ timeOnly
;
1570 timeMidnight
-= timeOnly
;
1572 // calculate the Gregorian date from JDN for the midnight of our date:
1573 // this will yield day, month (in 1..12 range) and year
1575 // actually, this is the JDN for the noon of the previous day
1576 long jdn
= (timeMidnight
/ MILLISECONDS_PER_DAY
).ToLong() + EPOCH_JDN
;
1578 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
1580 wxASSERT_MSG( jdn
> -2, _T("JDN out of range") );
1582 // calculate the century
1583 long temp
= (jdn
+ JDN_OFFSET
) * 4 - 1;
1584 long century
= temp
/ DAYS_PER_400_YEARS
;
1586 // then the year and day of year (1 <= dayOfYear <= 366)
1587 temp
= ((temp
% DAYS_PER_400_YEARS
) / 4) * 4 + 3;
1588 long year
= (century
* 100) + (temp
/ DAYS_PER_4_YEARS
);
1589 long dayOfYear
= (temp
% DAYS_PER_4_YEARS
) / 4 + 1;
1591 // and finally the month and day of the month
1592 temp
= dayOfYear
* 5 - 3;
1593 long month
= temp
/ DAYS_PER_5_MONTHS
;
1594 long day
= (temp
% DAYS_PER_5_MONTHS
) / 5 + 1;
1596 // month is counted from March - convert to normal
1607 // year is offset by 4800
1610 // check that the algorithm gave us something reasonable
1611 wxASSERT_MSG( (0 < month
) && (month
<= 12), _T("invalid month") );
1612 wxASSERT_MSG( (1 <= day
) && (day
< 32), _T("invalid day") );
1614 // construct Tm from these values
1616 tm
.year
= (int)year
;
1617 tm
.mon
= (Month
)(month
- 1); // algorithm yields 1 for January, not 0
1618 tm
.mday
= (wxDateTime_t
)day
;
1619 tm
.msec
= (wxDateTime_t
)(timeOnly
% 1000);
1620 timeOnly
-= tm
.msec
;
1621 timeOnly
/= 1000; // now we have time in seconds
1623 tm
.sec
= (wxDateTime_t
)(timeOnly
% 60);
1625 timeOnly
/= 60; // now we have time in minutes
1627 tm
.min
= (wxDateTime_t
)(timeOnly
% 60);
1630 tm
.hour
= (wxDateTime_t
)(timeOnly
/ 60);
1635 wxDateTime
& wxDateTime::SetYear(int year
)
1637 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1646 wxDateTime
& wxDateTime::SetMonth(Month month
)
1648 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1657 wxDateTime
& wxDateTime::SetDay(wxDateTime_t mday
)
1659 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1668 wxDateTime
& wxDateTime::SetHour(wxDateTime_t hour
)
1670 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1679 wxDateTime
& wxDateTime::SetMinute(wxDateTime_t min
)
1681 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1690 wxDateTime
& wxDateTime::SetSecond(wxDateTime_t sec
)
1692 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1701 wxDateTime
& wxDateTime::SetMillisecond(wxDateTime_t millisecond
)
1703 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1705 // we don't need to use GetTm() for this one
1706 m_time
-= m_time
% 1000l;
1707 m_time
+= millisecond
;
1712 // ----------------------------------------------------------------------------
1713 // wxDateTime arithmetics
1714 // ----------------------------------------------------------------------------
1716 wxDateTime
& wxDateTime::Add(const wxDateSpan
& diff
)
1720 tm
.year
+= diff
.GetYears();
1721 tm
.AddMonths(diff
.GetMonths());
1723 // check that the resulting date is valid
1724 if ( tm
.mday
> GetNumOfDaysInMonth(tm
.year
, tm
.mon
) )
1726 // We suppose that when adding one month to Jan 31 we want to get Feb
1727 // 28 (or 29), i.e. adding a month to the last day of the month should
1728 // give the last day of the next month which is quite logical.
1730 // Unfortunately, there is no logic way to understand what should
1731 // Jan 30 + 1 month be - Feb 28 too or Feb 27 (assuming non leap year)?
1732 // We make it Feb 28 (last day too), but it is highly questionable.
1733 tm
.mday
= GetNumOfDaysInMonth(tm
.year
, tm
.mon
);
1736 tm
.AddDays(diff
.GetTotalDays());
1740 wxASSERT_MSG( IsSameTime(tm
),
1741 _T("Add(wxDateSpan) shouldn't modify time") );
1746 // ----------------------------------------------------------------------------
1747 // Weekday and monthday stuff
1748 // ----------------------------------------------------------------------------
1750 // convert Sun, Mon, ..., Sat into 6, 0, ..., 5
1751 static inline int ConvertWeekDayToMondayBase(int wd
)
1753 return wd
== wxDateTime::Sun
? 6 : wd
- 1;
1758 wxDateTime::SetToWeekOfYear(int year
, wxDateTime_t numWeek
, WeekDay wd
)
1760 wxASSERT_MSG( numWeek
> 0,
1761 _T("invalid week number: weeks are counted from 1") );
1763 // Jan 4 always lies in the 1st week of the year
1764 wxDateTime
dt(4, Jan
, year
);
1765 dt
.SetToWeekDayInSameWeek(wd
);
1766 dt
+= wxDateSpan::Weeks(numWeek
- 1);
1771 // use a separate function to avoid warnings about using deprecated
1772 // SetToTheWeek in GetWeek below
1774 SetToTheWeek(int year
,
1775 wxDateTime::wxDateTime_t numWeek
,
1776 wxDateTime::WeekDay weekday
,
1777 wxDateTime::WeekFlags flags
)
1779 // Jan 4 always lies in the 1st week of the year
1780 wxDateTime
dt(4, wxDateTime::Jan
, year
);
1781 dt
.SetToWeekDayInSameWeek(weekday
, flags
);
1782 dt
+= wxDateSpan::Weeks(numWeek
- 1);
1787 bool wxDateTime::SetToTheWeek(wxDateTime_t numWeek
,
1791 int year
= GetYear();
1792 *this = ::SetToTheWeek(year
, numWeek
, weekday
, flags
);
1793 if ( GetYear() != year
)
1795 // oops... numWeek was too big
1802 wxDateTime
wxDateTime::GetWeek(wxDateTime_t numWeek
,
1804 WeekFlags flags
) const
1806 return ::SetToTheWeek(GetYear(), numWeek
, weekday
, flags
);
1809 wxDateTime
& wxDateTime::SetToLastMonthDay(Month month
,
1812 // take the current month/year if none specified
1813 if ( year
== Inv_Year
)
1815 if ( month
== Inv_Month
)
1818 return Set(GetNumOfDaysInMonth(year
, month
), month
, year
);
1821 wxDateTime
& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday
, WeekFlags flags
)
1823 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
1825 int wdayDst
= weekday
,
1826 wdayThis
= GetWeekDay();
1827 if ( wdayDst
== wdayThis
)
1833 if ( flags
== Default_First
)
1835 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
1838 // the logic below based on comparing weekday and wdayThis works if Sun (0)
1839 // is the first day in the week, but breaks down for Monday_First case so
1840 // we adjust the week days in this case
1841 if ( flags
== Monday_First
)
1843 if ( wdayThis
== Sun
)
1845 if ( wdayDst
== Sun
)
1848 //else: Sunday_First, nothing to do
1850 // go forward or back in time to the day we want
1851 if ( wdayDst
< wdayThis
)
1853 return Subtract(wxDateSpan::Days(wdayThis
- wdayDst
));
1855 else // weekday > wdayThis
1857 return Add(wxDateSpan::Days(wdayDst
- wdayThis
));
1861 wxDateTime
& wxDateTime::SetToNextWeekDay(WeekDay weekday
)
1863 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
1866 WeekDay wdayThis
= GetWeekDay();
1867 if ( weekday
== wdayThis
)
1872 else if ( weekday
< wdayThis
)
1874 // need to advance a week
1875 diff
= 7 - (wdayThis
- weekday
);
1877 else // weekday > wdayThis
1879 diff
= weekday
- wdayThis
;
1882 return Add(wxDateSpan::Days(diff
));
1885 wxDateTime
& wxDateTime::SetToPrevWeekDay(WeekDay weekday
)
1887 wxDATETIME_CHECK( weekday
!= Inv_WeekDay
, _T("invalid weekday") );
1890 WeekDay wdayThis
= GetWeekDay();
1891 if ( weekday
== wdayThis
)
1896 else if ( weekday
> wdayThis
)
1898 // need to go to previous week
1899 diff
= 7 - (weekday
- wdayThis
);
1901 else // weekday < wdayThis
1903 diff
= wdayThis
- weekday
;
1906 return Subtract(wxDateSpan::Days(diff
));
1909 bool wxDateTime::SetToWeekDay(WeekDay weekday
,
1914 wxCHECK_MSG( weekday
!= Inv_WeekDay
, false, _T("invalid weekday") );
1916 // we don't check explicitly that -5 <= n <= 5 because we will return false
1917 // anyhow in such case - but may be should still give an assert for it?
1919 // take the current month/year if none specified
1920 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1924 // TODO this probably could be optimised somehow...
1928 // get the first day of the month
1929 dt
.Set(1, month
, year
);
1932 WeekDay wdayFirst
= dt
.GetWeekDay();
1934 // go to the first weekday of the month
1935 int diff
= weekday
- wdayFirst
;
1939 // add advance n-1 weeks more
1942 dt
+= wxDateSpan::Days(diff
);
1944 else // count from the end of the month
1946 // get the last day of the month
1947 dt
.SetToLastMonthDay(month
, year
);
1950 WeekDay wdayLast
= dt
.GetWeekDay();
1952 // go to the last weekday of the month
1953 int diff
= wdayLast
- weekday
;
1957 // and rewind n-1 weeks from there
1960 dt
-= wxDateSpan::Days(diff
);
1963 // check that it is still in the same month
1964 if ( dt
.GetMonth() == month
)
1972 // no such day in this month
1978 wxDateTime::wxDateTime_t
GetDayOfYearFromTm(const wxDateTime::Tm
& tm
)
1980 return (wxDateTime::wxDateTime_t
)(gs_cumulatedDays
[wxDateTime::IsLeapYear(tm
.year
)][tm
.mon
] + tm
.mday
);
1983 wxDateTime::wxDateTime_t
wxDateTime::GetDayOfYear(const TimeZone
& tz
) const
1985 return GetDayOfYearFromTm(GetTm(tz
));
1988 wxDateTime::wxDateTime_t
1989 wxDateTime::GetWeekOfYear(wxDateTime::WeekFlags flags
, const TimeZone
& tz
) const
1991 if ( flags
== Default_First
)
1993 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
1997 wxDateTime_t nDayInYear
= GetDayOfYearFromTm(tm
);
1999 int wdTarget
= GetWeekDay(tz
);
2000 int wdYearStart
= wxDateTime(1, Jan
, GetYear()).GetWeekDay();
2002 if ( flags
== Sunday_First
)
2004 // FIXME: First week is not calculated correctly.
2005 week
= (nDayInYear
- wdTarget
+ 7) / 7;
2006 if ( wdYearStart
== Wed
|| wdYearStart
== Thu
)
2009 else // week starts with monday
2011 // adjust the weekdays to non-US style.
2012 wdYearStart
= ConvertWeekDayToMondayBase(wdYearStart
);
2013 wdTarget
= ConvertWeekDayToMondayBase(wdTarget
);
2015 // quoting from http://www.cl.cam.ac.uk/~mgk25/iso-time.html:
2017 // Week 01 of a year is per definition the first week that has the
2018 // Thursday in this year, which is equivalent to the week that
2019 // contains the fourth day of January. In other words, the first
2020 // week of a new year is the week that has the majority of its
2021 // days in the new year. Week 01 might also contain days from the
2022 // previous year and the week before week 01 of a year is the last
2023 // week (52 or 53) of the previous year even if it contains days
2024 // from the new year. A week starts with Monday (day 1) and ends
2025 // with Sunday (day 7).
2028 // if Jan 1 is Thursday or less, it is in the first week of this year
2029 if ( wdYearStart
< 4 )
2031 // count the number of entire weeks between Jan 1 and this date
2032 week
= (nDayInYear
+ wdYearStart
+ 6 - wdTarget
)/7;
2034 // be careful to check for overflow in the next year
2035 if ( week
== 53 && tm
.mday
- wdTarget
> 28 )
2038 else // Jan 1 is in the last week of the previous year
2040 // check if we happen to be at the last week of previous year:
2041 if ( tm
.mon
== Jan
&& tm
.mday
< 8 - wdYearStart
)
2042 week
= wxDateTime(31, Dec
, GetYear()-1).GetWeekOfYear();
2044 week
= (nDayInYear
+ wdYearStart
- 1 - wdTarget
)/7;
2048 return (wxDateTime::wxDateTime_t
)week
;
2051 wxDateTime::wxDateTime_t
wxDateTime::GetWeekOfMonth(wxDateTime::WeekFlags flags
,
2052 const TimeZone
& tz
) const
2055 wxDateTime dtMonthStart
= wxDateTime(1, tm
.mon
, tm
.year
);
2056 int nWeek
= GetWeekOfYear(flags
) - dtMonthStart
.GetWeekOfYear(flags
) + 1;
2059 // this may happen for January when Jan, 1 is the last week of the
2061 nWeek
+= IsLeapYear(tm
.year
- 1) ? 53 : 52;
2064 return (wxDateTime::wxDateTime_t
)nWeek
;
2067 wxDateTime
& wxDateTime::SetToYearDay(wxDateTime::wxDateTime_t yday
)
2069 int year
= GetYear();
2070 wxDATETIME_CHECK( (0 < yday
) && (yday
<= GetNumberOfDays(year
)),
2071 _T("invalid year day") );
2073 bool isLeap
= IsLeapYear(year
);
2074 for ( Month mon
= Jan
; mon
< Inv_Month
; wxNextMonth(mon
) )
2076 // for Dec, we can't compare with gs_cumulatedDays[mon + 1], but we
2077 // don't need it neither - because of the CHECK above we know that
2078 // yday lies in December then
2079 if ( (mon
== Dec
) || (yday
<= gs_cumulatedDays
[isLeap
][mon
+ 1]) )
2081 Set((wxDateTime::wxDateTime_t
)(yday
- gs_cumulatedDays
[isLeap
][mon
]), mon
, year
);
2090 // ----------------------------------------------------------------------------
2091 // Julian day number conversion and related stuff
2092 // ----------------------------------------------------------------------------
2094 double wxDateTime::GetJulianDayNumber() const
2096 // JDN are always expressed for the UTC dates
2097 Tm
tm(ToTimezone(UTC
).GetTm(UTC
));
2099 double result
= GetTruncatedJDN(tm
.mday
, tm
.mon
, tm
.year
);
2101 // add the part GetTruncatedJDN() neglected
2104 // and now add the time: 86400 sec = 1 JDN
2105 return result
+ ((double)(60*(60*tm
.hour
+ tm
.min
) + tm
.sec
)) / 86400;
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 Subtract(wxTimeSpan::Seconds(secDiff
));
2162 // ----------------------------------------------------------------------------
2163 // wxDateTime to/from text representations
2164 // ----------------------------------------------------------------------------
2166 wxString
wxDateTime::Format(const wxChar
*format
, const TimeZone
& tz
) const
2168 wxCHECK_MSG( format
, wxEmptyString
, _T("NULL format in wxDateTime::Format") );
2170 // we have to use our own implementation if the date is out of range of
2171 // strftime() or if we use non standard specificators
2172 time_t time
= GetTicks();
2173 if ( (time
!= (time_t)-1) && !wxStrstr(format
, _T("%l")) )
2177 if ( tz
.GetOffset() == -GetTimeZone() )
2179 // we are working with local time
2180 tm
= localtime(&time
);
2182 // should never happen
2183 wxCHECK_MSG( tm
, wxEmptyString
, _T("localtime() failed") );
2187 time
+= (int)tz
.GetOffset();
2189 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
2190 int time2
= (int) time
;
2198 // should never happen
2199 wxCHECK_MSG( tm
, wxEmptyString
, _T("gmtime() failed") );
2203 tm
= (struct tm
*)NULL
;
2207 //Windows CE doesn't support strftime or wcsftime, so we use the generic implementation
2210 return CallStrftime(format
, tm
);
2213 //else: use generic code below
2216 // we only parse ANSI C format specifications here, no POSIX 2
2217 // complications, no GNU extensions but we do add support for a "%l" format
2218 // specifier allowing to get the number of milliseconds
2221 // used for calls to strftime() when we only deal with time
2222 struct tm tmTimeOnly
;
2223 tmTimeOnly
.tm_hour
= tm
.hour
;
2224 tmTimeOnly
.tm_min
= tm
.min
;
2225 tmTimeOnly
.tm_sec
= tm
.sec
;
2226 tmTimeOnly
.tm_wday
= 0;
2227 tmTimeOnly
.tm_yday
= 0;
2228 tmTimeOnly
.tm_mday
= 1; // any date will do
2229 tmTimeOnly
.tm_mon
= 0;
2230 tmTimeOnly
.tm_year
= 76;
2231 tmTimeOnly
.tm_isdst
= 0; // no DST, we adjust for tz ourselves
2233 wxString tmp
, res
, fmt
;
2234 for ( const wxChar
*p
= format
; *p
; p
++ )
2236 if ( *p
!= _T('%') )
2244 // set the default format
2247 case _T('Y'): // year has 4 digits
2251 case _T('j'): // day of year has 3 digits
2252 case _T('l'): // milliseconds have 3 digits
2256 case _T('w'): // week day as number has only one
2261 // it's either another valid format specifier in which case
2262 // the format is "%02d" (for all the rest) or we have the
2263 // field width preceding the format in which case it will
2264 // override the default format anyhow
2268 bool restart
= true;
2273 // start of the format specification
2276 case _T('a'): // a weekday name
2278 // second parameter should be true for abbreviated names
2279 res
+= GetWeekDayName(tm
.GetWeekDay(),
2280 *p
== _T('a') ? Name_Abbr
: Name_Full
);
2283 case _T('b'): // a month name
2285 res
+= GetMonthName(tm
.mon
,
2286 *p
== _T('b') ? Name_Abbr
: Name_Full
);
2289 case _T('c'): // locale default date and time representation
2290 case _T('x'): // locale default date representation
2293 // the problem: there is no way to know what do these format
2294 // specifications correspond to for the current locale.
2296 // the solution: use a hack and still use strftime(): first
2297 // find the YEAR which is a year in the strftime() range (1970
2298 // - 2038) whose Jan 1 falls on the same week day as the Jan 1
2299 // of the real year. Then make a copy of the format and
2300 // replace all occurences of YEAR in it with some unique
2301 // string not appearing anywhere else in it, then use
2302 // strftime() to format the date in year YEAR and then replace
2303 // YEAR back by the real year and the unique replacement
2304 // string back with YEAR. Notice that "all occurences of YEAR"
2305 // means all occurences of 4 digit as well as 2 digit form!
2307 // the bugs: we assume that neither of %c nor %x contains any
2308 // fields which may change between the YEAR and real year. For
2309 // example, the week number (%U, %W) and the day number (%j)
2310 // will change if one of these years is leap and the other one
2313 // find the YEAR: normally, for any year X, Jan 1 or the
2314 // year X + 28 is the same weekday as Jan 1 of X (because
2315 // the weekday advances by 1 for each normal X and by 2
2316 // for each leap X, hence by 5 every 4 years or by 35
2317 // which is 0 mod 7 every 28 years) but this rule breaks
2318 // down if there are years between X and Y which are
2319 // divisible by 4 but not leap (i.e. divisible by 100 but
2320 // not 400), hence the correction.
2322 int yearReal
= GetYear(tz
);
2323 int mod28
= yearReal
% 28;
2325 // be careful to not go too far - we risk to leave the
2330 year
= 1988 + mod28
; // 1988 == 0 (mod 28)
2334 year
= 1970 + mod28
- 10; // 1970 == 10 (mod 28)
2337 int nCentury
= year
/ 100,
2338 nCenturyReal
= yearReal
/ 100;
2340 // need to adjust for the years divisble by 400 which are
2341 // not leap but are counted like leap ones if we just take
2342 // the number of centuries in between for nLostWeekDays
2343 int nLostWeekDays
= (nCentury
- nCenturyReal
) -
2344 (nCentury
/ 4 - nCenturyReal
/ 4);
2346 // we have to gain back the "lost" weekdays: note that the
2347 // effect of this loop is to not do anything to
2348 // nLostWeekDays (which we won't use any more), but to
2349 // (indirectly) set the year correctly
2350 while ( (nLostWeekDays
% 7) != 0 )
2352 nLostWeekDays
+= year
++ % 4 ? 1 : 2;
2355 // at any rate, we couldn't go further than 1988 + 9 + 28!
2356 wxASSERT_MSG( year
< 2030,
2357 _T("logic error in wxDateTime::Format") );
2359 wxString strYear
, strYear2
;
2360 strYear
.Printf(_T("%d"), year
);
2361 strYear2
.Printf(_T("%d"), year
% 100);
2363 // find two strings not occuring in format (this is surely
2364 // not optimal way of doing it... improvements welcome!)
2365 wxString fmt
= format
;
2366 wxString replacement
= (wxChar
)-1;
2367 while ( fmt
.Find(replacement
) != wxNOT_FOUND
)
2369 replacement
<< (wxChar
)-1;
2372 wxString replacement2
= (wxChar
)-2;
2373 while ( fmt
.Find(replacement
) != wxNOT_FOUND
)
2375 replacement
<< (wxChar
)-2;
2378 // replace all occurences of year with it
2379 bool wasReplaced
= fmt
.Replace(strYear
, replacement
) > 0;
2381 wasReplaced
= fmt
.Replace(strYear2
, replacement2
) > 0;
2383 // use strftime() to format the same date but in supported
2386 // NB: we assume that strftime() doesn't check for the
2387 // date validity and will happily format the date
2388 // corresponding to Feb 29 of a non leap year (which
2389 // may happen if yearReal was leap and year is not)
2390 struct tm tmAdjusted
;
2392 tmAdjusted
.tm_hour
= tm
.hour
;
2393 tmAdjusted
.tm_min
= tm
.min
;
2394 tmAdjusted
.tm_sec
= tm
.sec
;
2395 tmAdjusted
.tm_wday
= tm
.GetWeekDay();
2396 tmAdjusted
.tm_yday
= GetDayOfYear();
2397 tmAdjusted
.tm_mday
= tm
.mday
;
2398 tmAdjusted
.tm_mon
= tm
.mon
;
2399 tmAdjusted
.tm_year
= year
- 1900;
2400 tmAdjusted
.tm_isdst
= 0; // no DST, already adjusted
2401 wxString str
= CallStrftime(*p
== _T('c') ? _T("%c")
2405 // now replace the occurence of 1999 with the real year
2406 wxString strYearReal
, strYearReal2
;
2407 strYearReal
.Printf(_T("%04d"), yearReal
);
2408 strYearReal2
.Printf(_T("%02d"), yearReal
% 100);
2409 str
.Replace(strYear
, strYearReal
);
2410 str
.Replace(strYear2
, strYearReal2
);
2412 // and replace back all occurences of replacement string
2415 str
.Replace(replacement2
, strYear2
);
2416 str
.Replace(replacement
, strYear
);
2422 //Use "%m/%d/%y %H:%M:%S" format instead
2423 res
+= wxString::Format(wxT("%02d/%02d/%04d %02d:%02d:%02d"),
2424 tm
.mon
+1,tm
.mday
, tm
.year
, tm
.hour
, tm
.min
, tm
.sec
);
2428 case _T('d'): // day of a month (01-31)
2429 res
+= wxString::Format(fmt
, tm
.mday
);
2432 case _T('H'): // hour in 24h format (00-23)
2433 res
+= wxString::Format(fmt
, tm
.hour
);
2436 case _T('I'): // hour in 12h format (01-12)
2438 // 24h -> 12h, 0h -> 12h too
2439 int hour12
= tm
.hour
> 12 ? tm
.hour
- 12
2440 : tm
.hour
? tm
.hour
: 12;
2441 res
+= wxString::Format(fmt
, hour12
);
2445 case _T('j'): // day of the year
2446 res
+= wxString::Format(fmt
, GetDayOfYear(tz
));
2449 case _T('l'): // milliseconds (NOT STANDARD)
2450 res
+= wxString::Format(fmt
, GetMillisecond(tz
));
2453 case _T('m'): // month as a number (01-12)
2454 res
+= wxString::Format(fmt
, tm
.mon
+ 1);
2457 case _T('M'): // minute as a decimal number (00-59)
2458 res
+= wxString::Format(fmt
, tm
.min
);
2461 case _T('p'): // AM or PM string
2463 res
+= CallStrftime(_T("%p"), &tmTimeOnly
);
2465 res
+= (tmTimeOnly
.tm_hour
> 12) ? wxT("pm") : wxT("am");
2469 case _T('S'): // second as a decimal number (00-61)
2470 res
+= wxString::Format(fmt
, tm
.sec
);
2473 case _T('U'): // week number in the year (Sunday 1st week day)
2474 res
+= wxString::Format(fmt
, GetWeekOfYear(Sunday_First
, tz
));
2477 case _T('W'): // week number in the year (Monday 1st week day)
2478 res
+= wxString::Format(fmt
, GetWeekOfYear(Monday_First
, tz
));
2481 case _T('w'): // weekday as a number (0-6), Sunday = 0
2482 res
+= wxString::Format(fmt
, tm
.GetWeekDay());
2485 // case _T('x'): -- handled with "%c"
2487 case _T('X'): // locale default time representation
2488 // just use strftime() to format the time for us
2490 res
+= CallStrftime(_T("%X"), &tmTimeOnly
);
2492 res
+= wxString::Format(wxT("%02d:%02d:%02d"),tm
.hour
, tm
.min
, tm
.sec
);
2496 case _T('y'): // year without century (00-99)
2497 res
+= wxString::Format(fmt
, tm
.year
% 100);
2500 case _T('Y'): // year with century
2501 res
+= wxString::Format(fmt
, tm
.year
);
2504 case _T('Z'): // timezone name
2506 res
+= CallStrftime(_T("%Z"), &tmTimeOnly
);
2511 // is it the format width?
2513 while ( *p
== _T('-') || *p
== _T('+') ||
2514 *p
== _T(' ') || wxIsdigit(*p
) )
2521 // we've only got the flags and width so far in fmt
2522 fmt
.Prepend(_T('%'));
2523 fmt
.Append(_T('d'));
2530 // no, it wasn't the width
2531 wxFAIL_MSG(_T("unknown format specificator"));
2533 // fall through and just copy it nevertheless
2535 case _T('%'): // a percent sign
2539 case 0: // the end of string
2540 wxFAIL_MSG(_T("missing format at the end of string"));
2542 // just put the '%' which was the last char in format
2552 // this function parses a string in (strict) RFC 822 format: see the section 5
2553 // of the RFC for the detailed description, but briefly it's something of the
2554 // form "Sat, 18 Dec 1999 00:48:30 +0100"
2556 // this function is "strict" by design - it must reject anything except true
2557 // RFC822 time specs.
2559 // TODO a great candidate for using reg exps
2560 const wxChar
*wxDateTime::ParseRfc822Date(const wxChar
* date
)
2562 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
2564 const wxChar
*p
= date
;
2565 const wxChar
*comma
= wxStrchr(p
, _T(','));
2568 // the part before comma is the weekday
2570 // skip it for now - we don't use but might check that it really
2571 // corresponds to the specfied date
2574 if ( *p
!= _T(' ') )
2576 wxLogDebug(_T("no space after weekday in RFC822 time spec"));
2578 return (wxChar
*)NULL
;
2584 // the following 1 or 2 digits are the day number
2585 if ( !wxIsdigit(*p
) )
2587 wxLogDebug(_T("day number expected in RFC822 time spec, none found"));
2589 return (wxChar
*)NULL
;
2592 wxDateTime_t day
= (wxDateTime_t
)(*p
++ - _T('0'));
2593 if ( wxIsdigit(*p
) )
2596 day
= (wxDateTime_t
)(day
+ (*p
++ - _T('0')));
2599 if ( *p
++ != _T(' ') )
2601 return (wxChar
*)NULL
;
2604 // the following 3 letters specify the month
2605 wxString
monName(p
, 3);
2607 if ( monName
== _T("Jan") )
2609 else if ( monName
== _T("Feb") )
2611 else if ( monName
== _T("Mar") )
2613 else if ( monName
== _T("Apr") )
2615 else if ( monName
== _T("May") )
2617 else if ( monName
== _T("Jun") )
2619 else if ( monName
== _T("Jul") )
2621 else if ( monName
== _T("Aug") )
2623 else if ( monName
== _T("Sep") )
2625 else if ( monName
== _T("Oct") )
2627 else if ( monName
== _T("Nov") )
2629 else if ( monName
== _T("Dec") )
2633 wxLogDebug(_T("Invalid RFC 822 month name '%s'"), monName
.c_str());
2635 return (wxChar
*)NULL
;
2640 if ( *p
++ != _T(' ') )
2642 return (wxChar
*)NULL
;
2646 if ( !wxIsdigit(*p
) )
2649 return (wxChar
*)NULL
;
2652 int year
= *p
++ - _T('0');
2654 if ( !wxIsdigit(*p
) )
2656 // should have at least 2 digits in the year
2657 return (wxChar
*)NULL
;
2661 year
+= *p
++ - _T('0');
2663 // is it a 2 digit year (as per original RFC 822) or a 4 digit one?
2664 if ( wxIsdigit(*p
) )
2667 year
+= *p
++ - _T('0');
2669 if ( !wxIsdigit(*p
) )
2671 // no 3 digit years please
2672 return (wxChar
*)NULL
;
2676 year
+= *p
++ - _T('0');
2679 if ( *p
++ != _T(' ') )
2681 return (wxChar
*)NULL
;
2684 // time is in the format hh:mm:ss and seconds are optional
2685 if ( !wxIsdigit(*p
) )
2687 return (wxChar
*)NULL
;
2690 wxDateTime_t hour
= (wxDateTime_t
)(*p
++ - _T('0'));
2692 if ( !wxIsdigit(*p
) )
2694 return (wxChar
*)NULL
;
2698 hour
= (wxDateTime_t
)(hour
+ (*p
++ - _T('0')));
2700 if ( *p
++ != _T(':') )
2702 return (wxChar
*)NULL
;
2705 if ( !wxIsdigit(*p
) )
2707 return (wxChar
*)NULL
;
2710 wxDateTime_t min
= (wxDateTime_t
)(*p
++ - _T('0'));
2712 if ( !wxIsdigit(*p
) )
2714 return (wxChar
*)NULL
;
2718 min
= (wxDateTime_t
)(min
+ *p
++ - _T('0'));
2720 wxDateTime_t sec
= 0;
2721 if ( *p
++ == _T(':') )
2723 if ( !wxIsdigit(*p
) )
2725 return (wxChar
*)NULL
;
2728 sec
= (wxDateTime_t
)(*p
++ - _T('0'));
2730 if ( !wxIsdigit(*p
) )
2732 return (wxChar
*)NULL
;
2736 sec
= (wxDateTime_t
)(sec
+ *p
++ - _T('0'));
2739 if ( *p
++ != _T(' ') )
2741 return (wxChar
*)NULL
;
2744 // and now the interesting part: the timezone
2745 int offset
wxDUMMY_INITIALIZE(0);
2746 if ( *p
== _T('-') || *p
== _T('+') )
2748 // the explicit offset given: it has the form of hhmm
2749 bool plus
= *p
++ == _T('+');
2751 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2753 return (wxChar
*)NULL
;
2757 offset
= 60*(10*(*p
- _T('0')) + (*(p
+ 1) - _T('0')));
2761 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2763 return (wxChar
*)NULL
;
2767 offset
+= 10*(*p
- _T('0')) + (*(p
+ 1) - _T('0'));
2778 // the symbolic timezone given: may be either military timezone or one
2779 // of standard abbreviations
2782 // military: Z = UTC, J unused, A = -1, ..., Y = +12
2783 static const int offsets
[26] =
2785 //A B C D E F G H I J K L M
2786 -1, -2, -3, -4, -5, -6, -7, -8, -9, 0, -10, -11, -12,
2787 //N O P R Q S T U V W Z Y Z
2788 +1, +2, +3, +4, +5, +6, +7, +8, +9, +10, +11, +12, 0
2791 if ( *p
< _T('A') || *p
> _T('Z') || *p
== _T('J') )
2793 wxLogDebug(_T("Invalid militaty timezone '%c'"), *p
);
2795 return (wxChar
*)NULL
;
2798 offset
= offsets
[*p
++ - _T('A')];
2804 if ( tz
== _T("UT") || tz
== _T("UTC") || tz
== _T("GMT") )
2806 else if ( tz
== _T("AST") )
2807 offset
= AST
- GMT0
;
2808 else if ( tz
== _T("ADT") )
2809 offset
= ADT
- GMT0
;
2810 else if ( tz
== _T("EST") )
2811 offset
= EST
- GMT0
;
2812 else if ( tz
== _T("EDT") )
2813 offset
= EDT
- GMT0
;
2814 else if ( tz
== _T("CST") )
2815 offset
= CST
- GMT0
;
2816 else if ( tz
== _T("CDT") )
2817 offset
= CDT
- GMT0
;
2818 else if ( tz
== _T("MST") )
2819 offset
= MST
- GMT0
;
2820 else if ( tz
== _T("MDT") )
2821 offset
= MDT
- GMT0
;
2822 else if ( tz
== _T("PST") )
2823 offset
= PST
- GMT0
;
2824 else if ( tz
== _T("PDT") )
2825 offset
= PDT
- GMT0
;
2828 wxLogDebug(_T("Unknown RFC 822 timezone '%s'"), p
);
2830 return (wxChar
*)NULL
;
2840 // the spec was correct
2841 Set(day
, mon
, year
, hour
, min
, sec
);
2842 MakeTimezone((wxDateTime_t
)(60*offset
));
2849 // Get's current locale's date formatting string and stores it in fmt if
2850 // the locale is set; otherwise or in case of failure, leaves fmt unchanged
2851 static void GetLocaleDateFormat(wxString
*fmt
)
2853 // there is no setlocale() under Windows CE, so just always query the
2856 if ( strcmp(setlocale(LC_ALL
, NULL
), "C") != 0 )
2859 // The locale was programatically set to non-C. We assume that this was
2860 // done using wxLocale, in which case thread's current locale is also
2861 // set to correct LCID value and we can use GetLocaleInfo to determine
2862 // the correct formatting string:
2864 LCID lcid
= LOCALE_USER_DEFAULT
;
2866 LCID lcid
= GetThreadLocale();
2868 wxChar delim
[5]; // fields deliminer, 4 chars max
2869 if ( GetLocaleInfo(lcid
, LOCALE_SDATE
, delim
, 5) )
2871 wxChar centurybuf
[2]; // use %y or %Y, 1 char max
2872 wxChar century
= 'y';
2873 if ( GetLocaleInfo(lcid
, LOCALE_ICENTURY
, centurybuf
, 2) )
2875 if ( centurybuf
[0] == _T('1') )
2877 // else 'y' as above
2880 wxChar order
[2]; // order code, 1 char max
2881 if ( GetLocaleInfo(lcid
, LOCALE_IDATE
, order
, 2) )
2883 if ( order
[0] == _T('0') ) // M-D-Y
2885 *fmt
= wxString::Format(_T("%%m%s%%d%s%%%c"),
2886 delim
, delim
, century
);
2888 else if ( order
[0] == _T('1') ) // D-M-Y
2890 *fmt
= wxString::Format(_T("%%d%s%%m%s%%%c"),
2891 delim
, delim
, century
);
2893 else if ( order
[0] == _T('2') ) // Y-M-D
2895 *fmt
= wxString::Format(_T("%%%c%s%%m%s%%d"),
2896 century
, delim
, delim
);
2900 wxFAIL_MSG(_T("unexpected GetLocaleInfo return value"));
2904 // if we failed, leave fmtDate value unchanged and
2905 // try our luck with the default set above
2909 #endif // __WINDOWS__
2911 const wxChar
*wxDateTime::ParseFormat(const wxChar
*date
,
2912 const wxChar
*format
,
2913 const wxDateTime
& dateDef
)
2915 wxCHECK_MSG( date
&& format
, (wxChar
*)NULL
,
2916 _T("NULL pointer in wxDateTime::ParseFormat()") );
2921 // what fields have we found?
2922 bool haveWDay
= false,
2931 bool hourIsIn12hFormat
= false, // or in 24h one?
2932 isPM
= false; // AM by default
2934 // and the value of the items we have (init them to get rid of warnings)
2935 wxDateTime_t sec
= 0,
2938 WeekDay wday
= Inv_WeekDay
;
2939 wxDateTime_t yday
= 0,
2941 wxDateTime::Month mon
= Inv_Month
;
2944 const wxChar
*input
= date
;
2945 for ( const wxChar
*fmt
= format
; *fmt
; fmt
++ )
2947 if ( *fmt
!= _T('%') )
2949 if ( wxIsspace(*fmt
) )
2951 // a white space in the format string matches 0 or more white
2952 // spaces in the input
2953 while ( wxIsspace(*input
) )
2960 // any other character (not whitespace, not '%') must be
2961 // matched by itself in the input
2962 if ( *input
++ != *fmt
)
2965 return (wxChar
*)NULL
;
2969 // done with this format char
2973 // start of a format specification
2975 // parse the optional width
2977 while ( wxIsdigit(*++fmt
) )
2980 width
+= *fmt
- _T('0');
2983 // the default widths for the various fields
2988 case _T('Y'): // year has 4 digits
2992 case _T('j'): // day of year has 3 digits
2993 case _T('l'): // milliseconds have 3 digits
2997 case _T('w'): // week day as number has only one
3002 // default for all other fields
3007 // then the format itself
3010 case _T('a'): // a weekday name
3013 int flag
= *fmt
== _T('a') ? Name_Abbr
: Name_Full
;
3014 wday
= GetWeekDayFromName(GetAlphaToken(input
), flag
);
3015 if ( wday
== Inv_WeekDay
)
3018 return (wxChar
*)NULL
;
3024 case _T('b'): // a month name
3027 int flag
= *fmt
== _T('b') ? Name_Abbr
: Name_Full
;
3028 mon
= GetMonthFromName(GetAlphaToken(input
), flag
);
3029 if ( mon
== Inv_Month
)
3032 return (wxChar
*)NULL
;
3038 case _T('c'): // locale default date and time representation
3042 // this is the format which corresponds to ctime() output
3043 // and strptime("%c") should parse it, so try it first
3044 static const wxChar
*fmtCtime
= _T("%a %b %d %H:%M:%S %Y");
3046 const wxChar
*result
= dt
.ParseFormat(input
, fmtCtime
);
3049 result
= dt
.ParseFormat(input
, _T("%x %X"));
3054 result
= dt
.ParseFormat(input
, _T("%X %x"));
3059 // we've tried everything and still no match
3060 return (wxChar
*)NULL
;
3065 haveDay
= haveMon
= haveYear
=
3066 haveHour
= haveMin
= haveSec
= true;
3080 case _T('d'): // day of a month (01-31)
3081 if ( !GetNumericToken(width
, input
, &num
) ||
3082 (num
> 31) || (num
< 1) )
3085 return (wxChar
*)NULL
;
3088 // we can't check whether the day range is correct yet, will
3089 // do it later - assume ok for now
3091 mday
= (wxDateTime_t
)num
;
3094 case _T('H'): // hour in 24h format (00-23)
3095 if ( !GetNumericToken(width
, input
, &num
) || (num
> 23) )
3098 return (wxChar
*)NULL
;
3102 hour
= (wxDateTime_t
)num
;
3105 case _T('I'): // hour in 12h format (01-12)
3106 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 12) )
3109 return (wxChar
*)NULL
;
3113 hourIsIn12hFormat
= true;
3114 hour
= (wxDateTime_t
)(num
% 12); // 12 should be 0
3117 case _T('j'): // day of the year
3118 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 366) )
3121 return (wxChar
*)NULL
;
3125 yday
= (wxDateTime_t
)num
;
3128 case _T('m'): // month as a number (01-12)
3129 if ( !GetNumericToken(width
, input
, &num
) || !num
|| (num
> 12) )
3132 return (wxChar
*)NULL
;
3136 mon
= (Month
)(num
- 1);
3139 case _T('M'): // minute as a decimal number (00-59)
3140 if ( !GetNumericToken(width
, input
, &num
) || (num
> 59) )
3143 return (wxChar
*)NULL
;
3147 min
= (wxDateTime_t
)num
;
3150 case _T('p'): // AM or PM string
3152 wxString am
, pm
, token
= GetAlphaToken(input
);
3154 GetAmPmStrings(&am
, &pm
);
3155 if (am
.empty() && pm
.empty())
3156 return (wxChar
*)NULL
; // no am/pm strings defined
3157 if ( token
.CmpNoCase(pm
) == 0 )
3161 else if ( token
.CmpNoCase(am
) != 0 )
3164 return (wxChar
*)NULL
;
3169 case _T('r'): // time as %I:%M:%S %p
3172 input
= dt
.ParseFormat(input
, _T("%I:%M:%S %p"));
3176 return (wxChar
*)NULL
;
3179 haveHour
= haveMin
= haveSec
= true;
3188 case _T('R'): // time as %H:%M
3191 input
= dt
.ParseFormat(input
, _T("%H:%M"));
3195 return (wxChar
*)NULL
;
3198 haveHour
= haveMin
= true;
3205 case _T('S'): // second as a decimal number (00-61)
3206 if ( !GetNumericToken(width
, input
, &num
) || (num
> 61) )
3209 return (wxChar
*)NULL
;
3213 sec
= (wxDateTime_t
)num
;
3216 case _T('T'): // time as %H:%M:%S
3219 input
= dt
.ParseFormat(input
, _T("%H:%M:%S"));
3223 return (wxChar
*)NULL
;
3226 haveHour
= haveMin
= haveSec
= true;
3235 case _T('w'): // weekday as a number (0-6), Sunday = 0
3236 if ( !GetNumericToken(width
, input
, &num
) || (wday
> 6) )
3239 return (wxChar
*)NULL
;
3243 wday
= (WeekDay
)num
;
3246 case _T('x'): // locale default date representation
3247 #ifdef HAVE_STRPTIME
3248 // try using strptime() -- it may fail even if the input is
3249 // correct but the date is out of range, so we will fall back
3250 // to our generic code anyhow
3254 const wxChar
*result
= CallStrptime(input
, "%x", &tm
);
3259 haveDay
= haveMon
= haveYear
= true;
3261 year
= 1900 + tm
.tm_year
;
3262 mon
= (Month
)tm
.tm_mon
;
3268 #endif // HAVE_STRPTIME
3273 wxString fmtDate
, fmtDateAlt
;
3275 if ( IsWestEuropeanCountry(GetCountry()) ||
3276 GetCountry() == Russia
)
3278 fmtDate
= _T("%d/%m/%y");
3279 fmtDateAlt
= _T("%m/%d/%y");
3283 fmtDate
= _T("%m/%d/%y");
3284 fmtDateAlt
= _T("%d/%m/%y");
3288 // The above doesn't work for all locales, try to query
3289 // Windows for the right way of formatting the date:
3290 GetLocaleDateFormat(&fmtDate
);
3293 const wxChar
*result
= dt
.ParseFormat(input
, fmtDate
);
3297 // ok, be nice and try another one
3298 result
= dt
.ParseFormat(input
, fmtDateAlt
);
3304 return (wxChar
*)NULL
;
3309 haveDay
= haveMon
= haveYear
= true;
3320 case _T('X'): // locale default time representation
3321 #ifdef HAVE_STRPTIME
3323 // use strptime() to do it for us (FIXME !Unicode friendly)
3325 input
= CallStrptime(input
, "%X", &tm
);
3328 return (wxChar
*)NULL
;
3331 haveHour
= haveMin
= haveSec
= true;
3337 #else // !HAVE_STRPTIME
3338 // TODO under Win32 we can query the LOCALE_ITIME system
3339 // setting which says whether the default time format is
3342 // try to parse what follows as "%H:%M:%S" and, if this
3343 // fails, as "%I:%M:%S %p" - this should catch the most
3347 const wxChar
*result
= dt
.ParseFormat(input
, _T("%T"));
3350 result
= dt
.ParseFormat(input
, _T("%r"));
3356 return (wxChar
*)NULL
;
3359 haveHour
= haveMin
= haveSec
= true;
3368 #endif // HAVE_STRPTIME/!HAVE_STRPTIME
3371 case _T('y'): // year without century (00-99)
3372 if ( !GetNumericToken(width
, input
, &num
) || (num
> 99) )
3375 return (wxChar
*)NULL
;
3380 // TODO should have an option for roll over date instead of
3381 // hard coding it here
3382 year
= (num
> 30 ? 1900 : 2000) + (wxDateTime_t
)num
;
3385 case _T('Y'): // year with century
3386 if ( !GetNumericToken(width
, input
, &num
) )
3389 return (wxChar
*)NULL
;
3393 year
= (wxDateTime_t
)num
;
3396 case _T('Z'): // timezone name
3397 wxFAIL_MSG(_T("TODO"));
3400 case _T('%'): // a percent sign
3401 if ( *input
++ != _T('%') )
3404 return (wxChar
*)NULL
;
3408 case 0: // the end of string
3409 wxFAIL_MSG(_T("unexpected format end"));
3413 default: // not a known format spec
3414 return (wxChar
*)NULL
;
3418 // format matched, try to construct a date from what we have now
3420 if ( dateDef
.IsValid() )
3422 // take this date as default
3423 tmDef
= dateDef
.GetTm();
3425 else if ( IsValid() )
3427 // if this date is valid, don't change it
3432 // no default and this date is invalid - fall back to Today()
3433 tmDef
= Today().GetTm();
3444 // TODO we don't check here that the values are consistent, if both year
3445 // day and month/day were found, we just ignore the year day and we
3446 // also always ignore the week day
3447 if ( haveMon
&& haveDay
)
3449 if ( mday
> GetNumOfDaysInMonth(tm
.year
, mon
) )
3451 wxLogDebug(_T("bad month day in wxDateTime::ParseFormat"));
3453 return (wxChar
*)NULL
;
3459 else if ( haveYDay
)
3461 if ( yday
> GetNumberOfDays(tm
.year
) )
3463 wxLogDebug(_T("bad year day in wxDateTime::ParseFormat"));
3465 return (wxChar
*)NULL
;
3468 Tm tm2
= wxDateTime(1, Jan
, tm
.year
).SetToYearDay(yday
).GetTm();
3475 if ( haveHour
&& hourIsIn12hFormat
&& isPM
)
3477 // translate to 24hour format
3480 //else: either already in 24h format or no translation needed
3500 // finally check that the week day is consistent -- if we had it
3501 if ( haveWDay
&& GetWeekDay() != wday
)
3503 wxLogDebug(_T("inconsistsnet week day in wxDateTime::ParseFormat()"));
3511 const wxChar
*wxDateTime::ParseDateTime(const wxChar
*date
)
3513 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3515 // Set to current day and hour, so strings like '14:00' becomes today at
3516 // 14, not some other random date
3517 wxDateTime dtDate
= wxDateTime::Today();
3518 wxDateTime dtTime
= wxDateTime::Today();
3520 const wxChar
* pchTime
;
3522 // Try to parse the beginning of the string as a date
3523 const wxChar
* pchDate
= dtDate
.ParseDate(date
);
3525 // We got a date in the beginning, see if there is a time specified after the date
3528 // Skip spaces, as the ParseTime() function fails on spaces
3529 while ( wxIsspace(*pchDate
) )
3532 pchTime
= dtTime
.ParseTime(pchDate
);
3534 else // no date in the beginning
3536 // check and see if we have a time followed by a date
3537 pchTime
= dtTime
.ParseTime(date
);
3540 while ( wxIsspace(*pchTime
) )
3543 pchDate
= dtDate
.ParseDate(pchTime
);
3547 // If we have a date specified, set our own data to the same date
3548 if ( !pchDate
|| !pchTime
)
3551 Set(dtDate
.GetDay(), dtDate
.GetMonth(), dtDate
.GetYear(),
3552 dtTime
.GetHour(), dtTime
.GetMinute(), dtTime
.GetSecond(),
3553 dtTime
.GetMillisecond());
3555 // Return endpoint of scan
3556 return pchDate
> pchTime
? pchDate
: pchTime
;
3559 const wxChar
*wxDateTime::ParseDate(const wxChar
*date
)
3561 // this is a simplified version of ParseDateTime() which understands only
3562 // "today" (for wxDate compatibility) and digits only otherwise (and not
3563 // all esoteric constructions ParseDateTime() knows about)
3565 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3567 const wxChar
*p
= date
;
3568 while ( wxIsspace(*p
) )
3571 // some special cases
3575 int dayDiffFromToday
;
3578 { wxTRANSLATE("today"), 0 },
3579 { wxTRANSLATE("yesterday"), -1 },
3580 { wxTRANSLATE("tomorrow"), 1 },
3583 for ( size_t n
= 0; n
< WXSIZEOF(literalDates
); n
++ )
3585 wxString date
= wxGetTranslation(literalDates
[n
].str
);
3586 size_t len
= date
.length();
3587 if ( wxStrlen(p
) >= len
)
3589 wxString
str(p
, len
);
3590 if ( str
.CmpNoCase(date
) == 0 )
3592 // nothing can follow this, so stop here
3595 int dayDiffFromToday
= literalDates
[n
].dayDiffFromToday
;
3597 if ( dayDiffFromToday
)
3599 *this += wxDateSpan::Days(dayDiffFromToday
);
3607 // We try to guess what we have here: for each new (numeric) token, we
3608 // determine if it can be a month, day or a year. Of course, there is an
3609 // ambiguity as some numbers may be days as well as months, so we also
3610 // have the ability to back track.
3613 bool haveDay
= false, // the months day?
3614 haveWDay
= false, // the day of week?
3615 haveMon
= false, // the month?
3616 haveYear
= false; // the year?
3618 // and the value of the items we have (init them to get rid of warnings)
3619 WeekDay wday
= Inv_WeekDay
;
3620 wxDateTime_t day
= 0;
3621 wxDateTime::Month mon
= Inv_Month
;
3624 // tokenize the string
3626 static const wxChar
*dateDelimiters
= _T(".,/-\t\r\n ");
3627 wxStringTokenizer
tok(p
, dateDelimiters
);
3628 while ( tok
.HasMoreTokens() )
3630 wxString token
= tok
.GetNextToken();
3636 if ( token
.ToULong(&val
) )
3638 // guess what this number is
3644 if ( !haveMon
&& val
> 0 && val
<= 12 )
3646 // assume it is month
3649 else // not the month
3653 // this can only be the year
3656 else // may be either day or year
3658 wxDateTime_t max_days
= (wxDateTime_t
)(
3660 ? GetNumOfDaysInMonth(haveYear
? year
: Inv_Year
, mon
)
3665 if ( (val
== 0) || (val
> (unsigned long)max_days
) )
3670 else // yes, suppose it's the day
3684 year
= (wxDateTime_t
)val
;
3693 day
= (wxDateTime_t
)val
;
3699 mon
= (Month
)(val
- 1);
3702 else // not a number
3704 // be careful not to overwrite the current mon value
3705 Month mon2
= GetMonthFromName(token
, Name_Full
| Name_Abbr
);
3706 if ( mon2
!= Inv_Month
)
3711 // but we already have a month - maybe we guessed wrong?
3714 // no need to check in month range as always < 12, but
3715 // the days are counted from 1 unlike the months
3716 day
= (wxDateTime_t
)(mon
+ 1);
3721 // could possible be the year (doesn't the year come
3722 // before the month in the japanese format?) (FIXME)
3731 else // not a valid month name
3733 wday
= GetWeekDayFromName(token
, Name_Full
| Name_Abbr
);
3734 if ( wday
!= Inv_WeekDay
)
3744 else // not a valid weekday name
3747 static const wxChar
*ordinals
[] =
3749 wxTRANSLATE("first"),
3750 wxTRANSLATE("second"),
3751 wxTRANSLATE("third"),
3752 wxTRANSLATE("fourth"),
3753 wxTRANSLATE("fifth"),
3754 wxTRANSLATE("sixth"),
3755 wxTRANSLATE("seventh"),
3756 wxTRANSLATE("eighth"),
3757 wxTRANSLATE("ninth"),
3758 wxTRANSLATE("tenth"),
3759 wxTRANSLATE("eleventh"),
3760 wxTRANSLATE("twelfth"),
3761 wxTRANSLATE("thirteenth"),
3762 wxTRANSLATE("fourteenth"),
3763 wxTRANSLATE("fifteenth"),
3764 wxTRANSLATE("sixteenth"),
3765 wxTRANSLATE("seventeenth"),
3766 wxTRANSLATE("eighteenth"),
3767 wxTRANSLATE("nineteenth"),
3768 wxTRANSLATE("twentieth"),
3769 // that's enough - otherwise we'd have problems with
3770 // composite (or not) ordinals
3774 for ( n
= 0; n
< WXSIZEOF(ordinals
); n
++ )
3776 if ( token
.CmpNoCase(ordinals
[n
]) == 0 )
3782 if ( n
== WXSIZEOF(ordinals
) )
3784 // stop here - something unknown
3791 // don't try anything here (as in case of numeric day
3792 // above) - the symbolic day spec should always
3793 // precede the month/year
3799 day
= (wxDateTime_t
)(n
+ 1);
3804 nPosCur
= tok
.GetPosition();
3807 // either no more tokens or the scan was stopped by something we couldn't
3808 // parse - in any case, see if we can construct a date from what we have
3809 if ( !haveDay
&& !haveWDay
)
3811 wxLogDebug(_T("ParseDate: no day, no weekday hence no date."));
3813 return (wxChar
*)NULL
;
3816 if ( haveWDay
&& (haveMon
|| haveYear
|| haveDay
) &&
3817 !(haveDay
&& haveMon
&& haveYear
) )
3819 // without adjectives (which we don't support here) the week day only
3820 // makes sense completely separately or with the full date
3821 // specification (what would "Wed 1999" mean?)
3822 return (wxChar
*)NULL
;
3825 if ( !haveWDay
&& haveYear
&& !(haveDay
&& haveMon
) )
3827 // may be we have month and day instead of day and year?
3828 if ( haveDay
&& !haveMon
)
3832 // exchange day and month
3833 mon
= (wxDateTime::Month
)(day
- 1);
3835 // we're in the current year then
3836 if ( (year
> 0) && (year
<= (int)GetNumOfDaysInMonth(Inv_Year
, mon
)) )
3838 day
= (wxDateTime_t
)year
;
3843 //else: no, can't exchange, leave haveMon == false
3849 // if we give the year, month and day must be given too
3850 wxLogDebug(_T("ParseDate: day and month should be specified if year is."));
3852 return (wxChar
*)NULL
;
3858 mon
= GetCurrentMonth();
3863 year
= GetCurrentYear();
3868 Set(day
, mon
, year
);
3872 // check that it is really the same
3873 if ( GetWeekDay() != wday
)
3875 // inconsistency detected
3876 wxLogDebug(_T("ParseDate: inconsistent day/weekday."));
3878 return (wxChar
*)NULL
;
3886 SetToWeekDayInSameWeek(wday
);
3889 // return the pointer to the first unparsed char
3891 if ( nPosCur
&& wxStrchr(dateDelimiters
, *(p
- 1)) )
3893 // if we couldn't parse the token after the delimiter, put back the
3894 // delimiter as well
3901 const wxChar
*wxDateTime::ParseTime(const wxChar
*time
)
3903 wxCHECK_MSG( time
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3905 // first try some extra things
3912 { wxTRANSLATE("noon"), 12 },
3913 { wxTRANSLATE("midnight"), 00 },
3917 for ( size_t n
= 0; n
< WXSIZEOF(stdTimes
); n
++ )
3919 wxString timeString
= wxGetTranslation(stdTimes
[n
].name
);
3920 size_t len
= timeString
.length();
3921 if ( timeString
.CmpNoCase(wxString(time
, len
)) == 0 )
3923 // casts required by DigitalMars
3924 Set(stdTimes
[n
].hour
, wxDateTime_t(0), wxDateTime_t(0));
3930 // try all time formats we may think about in the order from longest to
3933 // 12hour with AM/PM?
3934 const wxChar
*result
= ParseFormat(time
, _T("%I:%M:%S %p"));
3938 // normally, it's the same, but why not try it?
3939 result
= ParseFormat(time
, _T("%H:%M:%S"));
3944 // 12hour with AM/PM but without seconds?
3945 result
= ParseFormat(time
, _T("%I:%M %p"));
3951 result
= ParseFormat(time
, _T("%H:%M"));
3956 // just the hour and AM/PM?
3957 result
= ParseFormat(time
, _T("%I %p"));
3963 result
= ParseFormat(time
, _T("%H"));
3968 // parse the standard format: normally it is one of the formats above
3969 // but it may be set to something completely different by the user
3970 result
= ParseFormat(time
, _T("%X"));
3973 // TODO: parse timezones
3978 // ----------------------------------------------------------------------------
3979 // Workdays and holidays support
3980 // ----------------------------------------------------------------------------
3982 bool wxDateTime::IsWorkDay(Country
WXUNUSED(country
)) const
3984 return !wxDateTimeHolidayAuthority::IsHoliday(*this);
3987 // ============================================================================
3989 // ============================================================================
3991 wxDateSpan WXDLLIMPEXP_BASE
operator*(int n
, const wxDateSpan
& ds
)
3994 return ds1
.Multiply(n
);
3997 // ============================================================================
3999 // ============================================================================
4001 wxTimeSpan WXDLLIMPEXP_BASE
operator*(int n
, const wxTimeSpan
& ts
)
4003 return wxTimeSpan(ts
).Multiply(n
);
4006 // this enum is only used in wxTimeSpan::Format() below but we can't declare
4007 // it locally to the method as it provokes an internal compiler error in egcs
4008 // 2.91.60 when building with -O2
4019 // not all strftime(3) format specifiers make sense here because, for example,
4020 // a time span doesn't have a year nor a timezone
4022 // Here are the ones which are supported (all of them are supported by strftime
4024 // %H hour in 24 hour format
4025 // %M minute (00 - 59)
4026 // %S second (00 - 59)
4029 // Also, for MFC CTimeSpan compatibility, we support
4030 // %D number of days
4032 // And, to be better than MFC :-), we also have
4033 // %E number of wEeks
4034 // %l milliseconds (000 - 999)
4035 wxString
wxTimeSpan::Format(const wxChar
*format
) const
4037 wxCHECK_MSG( format
, wxEmptyString
, _T("NULL format in wxTimeSpan::Format") );
4040 str
.Alloc(wxStrlen(format
));
4042 // Suppose we have wxTimeSpan ts(1 /* hour */, 2 /* min */, 3 /* sec */)
4044 // Then, of course, ts.Format("%H:%M:%S") must return "01:02:03", but the
4045 // question is what should ts.Format("%S") do? The code here returns "3273"
4046 // in this case (i.e. the total number of seconds, not just seconds % 60)
4047 // because, for me, this call means "give me entire time interval in
4048 // seconds" and not "give me the seconds part of the time interval"
4050 // If we agree that it should behave like this, it is clear that the
4051 // interpretation of each format specifier depends on the presence of the
4052 // other format specs in the string: if there was "%H" before "%M", we
4053 // should use GetMinutes() % 60, otherwise just GetMinutes() &c
4055 // we remember the most important unit found so far
4056 TimeSpanPart partBiggest
= Part_MSec
;
4058 for ( const wxChar
*pch
= format
; *pch
; pch
++ )
4062 if ( ch
== _T('%') )
4064 // the start of the format specification of the printf() below
4065 wxString fmtPrefix
= _T('%');
4070 ch
= *++pch
; // get the format spec char
4074 wxFAIL_MSG( _T("invalid format character") );
4080 // skip the part below switch
4085 if ( partBiggest
< Part_Day
)
4091 partBiggest
= Part_Day
;
4096 partBiggest
= Part_Week
;
4102 if ( partBiggest
< Part_Hour
)
4108 partBiggest
= Part_Hour
;
4111 fmtPrefix
+= _T("02");
4115 n
= GetMilliseconds().ToLong();
4116 if ( partBiggest
< Part_MSec
)
4120 //else: no need to reset partBiggest to Part_MSec, it is
4121 // the least significant one anyhow
4123 fmtPrefix
+= _T("03");
4128 if ( partBiggest
< Part_Min
)
4134 partBiggest
= Part_Min
;
4137 fmtPrefix
+= _T("02");
4141 n
= GetSeconds().ToLong();
4142 if ( partBiggest
< Part_Sec
)
4148 partBiggest
= Part_Sec
;
4151 fmtPrefix
+= _T("02");
4155 str
+= wxString::Format(fmtPrefix
+ _T("ld"), n
);
4159 // normal character, just copy
4167 // ============================================================================
4168 // wxDateTimeHolidayAuthority and related classes
4169 // ============================================================================
4171 #include "wx/arrimpl.cpp"
4173 WX_DEFINE_OBJARRAY(wxDateTimeArray
);
4175 static int wxCMPFUNC_CONV
4176 wxDateTimeCompareFunc(wxDateTime
**first
, wxDateTime
**second
)
4178 wxDateTime dt1
= **first
,
4181 return dt1
== dt2
? 0 : dt1
< dt2
? -1 : +1;
4184 // ----------------------------------------------------------------------------
4185 // wxDateTimeHolidayAuthority
4186 // ----------------------------------------------------------------------------
4188 wxHolidayAuthoritiesArray
wxDateTimeHolidayAuthority::ms_authorities
;
4191 bool wxDateTimeHolidayAuthority::IsHoliday(const wxDateTime
& dt
)
4193 size_t count
= ms_authorities
.size();
4194 for ( size_t n
= 0; n
< count
; n
++ )
4196 if ( ms_authorities
[n
]->DoIsHoliday(dt
) )
4207 wxDateTimeHolidayAuthority::GetHolidaysInRange(const wxDateTime
& dtStart
,
4208 const wxDateTime
& dtEnd
,
4209 wxDateTimeArray
& holidays
)
4211 wxDateTimeArray hol
;
4215 size_t count
= ms_authorities
.size();
4216 for ( size_t nAuth
= 0; nAuth
< count
; nAuth
++ )
4218 ms_authorities
[nAuth
]->DoGetHolidaysInRange(dtStart
, dtEnd
, hol
);
4220 WX_APPEND_ARRAY(holidays
, hol
);
4223 holidays
.Sort(wxDateTimeCompareFunc
);
4225 return holidays
.size();
4229 void wxDateTimeHolidayAuthority::ClearAllAuthorities()
4231 WX_CLEAR_ARRAY(ms_authorities
);
4235 void wxDateTimeHolidayAuthority::AddAuthority(wxDateTimeHolidayAuthority
*auth
)
4237 ms_authorities
.push_back(auth
);
4240 wxDateTimeHolidayAuthority::~wxDateTimeHolidayAuthority()
4242 // required here for Darwin
4245 // ----------------------------------------------------------------------------
4246 // wxDateTimeWorkDays
4247 // ----------------------------------------------------------------------------
4249 bool wxDateTimeWorkDays::DoIsHoliday(const wxDateTime
& dt
) const
4251 wxDateTime::WeekDay wd
= dt
.GetWeekDay();
4253 return (wd
== wxDateTime::Sun
) || (wd
== wxDateTime::Sat
);
4256 size_t wxDateTimeWorkDays::DoGetHolidaysInRange(const wxDateTime
& dtStart
,
4257 const wxDateTime
& dtEnd
,
4258 wxDateTimeArray
& holidays
) const
4260 if ( dtStart
> dtEnd
)
4262 wxFAIL_MSG( _T("invalid date range in GetHolidaysInRange") );
4269 // instead of checking all days, start with the first Sat after dtStart and
4270 // end with the last Sun before dtEnd
4271 wxDateTime dtSatFirst
= dtStart
.GetNextWeekDay(wxDateTime::Sat
),
4272 dtSatLast
= dtEnd
.GetPrevWeekDay(wxDateTime::Sat
),
4273 dtSunFirst
= dtStart
.GetNextWeekDay(wxDateTime::Sun
),
4274 dtSunLast
= dtEnd
.GetPrevWeekDay(wxDateTime::Sun
),
4277 for ( dt
= dtSatFirst
; dt
<= dtSatLast
; dt
+= wxDateSpan::Week() )
4282 for ( dt
= dtSunFirst
; dt
<= dtSunLast
; dt
+= wxDateSpan::Week() )
4287 return holidays
.GetCount();
4290 // ============================================================================
4291 // other helper functions
4292 // ============================================================================
4294 // ----------------------------------------------------------------------------
4295 // iteration helpers: can be used to write a for loop over enum variable like
4297 // for ( m = wxDateTime::Jan; m < wxDateTime::Inv_Month; wxNextMonth(m) )
4298 // ----------------------------------------------------------------------------
4300 WXDLLIMPEXP_BASE
void wxNextMonth(wxDateTime::Month
& m
)
4302 wxASSERT_MSG( m
< wxDateTime::Inv_Month
, _T("invalid month") );
4304 // no wrapping or the for loop above would never end!
4305 m
= (wxDateTime::Month
)(m
+ 1);
4308 WXDLLIMPEXP_BASE
void wxPrevMonth(wxDateTime::Month
& m
)
4310 wxASSERT_MSG( m
< wxDateTime::Inv_Month
, _T("invalid month") );
4312 m
= m
== wxDateTime::Jan
? wxDateTime::Inv_Month
4313 : (wxDateTime::Month
)(m
- 1);
4316 WXDLLIMPEXP_BASE
void wxNextWDay(wxDateTime::WeekDay
& wd
)
4318 wxASSERT_MSG( wd
< wxDateTime::Inv_WeekDay
, _T("invalid week day") );
4320 // no wrapping or the for loop above would never end!
4321 wd
= (wxDateTime::WeekDay
)(wd
+ 1);
4324 WXDLLIMPEXP_BASE
void wxPrevWDay(wxDateTime::WeekDay
& wd
)
4326 wxASSERT_MSG( wd
< wxDateTime::Inv_WeekDay
, _T("invalid week day") );
4328 wd
= wd
== wxDateTime::Sun
? wxDateTime::Inv_WeekDay
4329 : (wxDateTime::WeekDay
)(wd
- 1);
4332 #endif // wxUSE_DATETIME