]> git.saurik.com Git - wxWidgets.git/blob - src/common/datetime.cpp
minor tab height bug fix
[wxWidgets.git] / src / common / datetime.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/datetime.cpp
3 // Purpose: implementation of time/date related classes
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 11.05.99
7 // RCS-ID: $Id$
8 // Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // parts of code taken from sndcal library by Scott E. Lee:
10 //
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.
15 //
16 // Licence: wxWindows licence
17 ///////////////////////////////////////////////////////////////////////////////
18
19 /*
20 * Implementation notes:
21 *
22 * 1. the time is stored as a 64bit integer containing the signed number of
23 * milliseconds since Jan 1. 1970 (the Unix Epoch) - so it is always
24 * expressed in GMT.
25 *
26 * 2. the range is thus something about 580 million years, but due to current
27 * algorithms limitations, only dates from Nov 24, 4714BC are handled
28 *
29 * 3. standard ANSI C functions are used to do time calculations whenever
30 * possible, i.e. when the date is in the range Jan 1, 1970 to 2038
31 *
32 * 4. otherwise, the calculations are done by converting the date to/from JDN
33 * first (the range limitation mentioned above comes from here: the
34 * algorithm used by Scott E. Lee's code only works for positive JDNs, more
35 * or less)
36 *
37 * 5. the object constructed for the given DD-MM-YYYY HH:MM:SS corresponds to
38 * this moment in local time and may be converted to the object
39 * corresponding to the same date/time in another time zone by using
40 * ToTimezone()
41 *
42 * 6. the conversions to the current (or any other) timezone are done when the
43 * internal time representation is converted to the broken-down one in
44 * wxDateTime::Tm.
45 */
46
47 // ============================================================================
48 // declarations
49 // ============================================================================
50
51 // ----------------------------------------------------------------------------
52 // headers
53 // ----------------------------------------------------------------------------
54
55 // For compilers that support precompilation, includes "wx.h".
56 #include "wx/wxprec.h"
57
58 #ifdef __BORLANDC__
59 #pragma hdrstop
60 #endif
61
62 #if !defined(wxUSE_DATETIME) || wxUSE_DATETIME
63
64 #ifndef WX_PRECOMP
65 #ifdef __WXMSW__
66 #include "wx/msw/wrapwin.h"
67 #endif
68 #include "wx/string.h"
69 #include "wx/log.h"
70 #include "wx/intl.h"
71 #include "wx/stopwatch.h" // for wxGetLocalTimeMillis()
72 #include "wx/module.h"
73 #endif // WX_PRECOMP
74
75 #include "wx/thread.h"
76 #include "wx/tokenzr.h"
77
78 #include <ctype.h>
79
80 #ifdef __WINDOWS__
81 #include <winnls.h>
82 #ifndef __WXWINCE__
83 #include <locale.h>
84 #endif
85 #endif
86
87 #include "wx/datetime.h"
88
89 const long wxDateTime::TIME_T_FACTOR = 1000l;
90
91 #if wxUSE_EXTENDED_RTTI
92
93 template<> void wxStringReadValue(const wxString &s , wxDateTime &data )
94 {
95 data.ParseFormat(s,wxT("%Y-%m-%d %H:%M:%S")) ;
96 }
97
98 template<> void wxStringWriteValue(wxString &s , const wxDateTime &data )
99 {
100 s = data.Format(wxT("%Y-%m-%d %H:%M:%S")) ;
101 }
102
103 wxCUSTOM_TYPE_INFO(wxDateTime, wxToStringConverter<wxDateTime> , wxFromStringConverter<wxDateTime>)
104
105 #endif
106
107 //
108 // ----------------------------------------------------------------------------
109 // conditional compilation
110 // ----------------------------------------------------------------------------
111
112 #if defined(HAVE_STRPTIME) && defined(__GLIBC__) && \
113 ((__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0))
114 // glibc 2.0.7 strptime() is broken - the following snippet causes it to
115 // crash (instead of just failing):
116 //
117 // strncpy(buf, "Tue Dec 21 20:25:40 1999", 128);
118 // strptime(buf, "%x", &tm);
119 //
120 // so don't use it
121 #undef HAVE_STRPTIME
122 #endif // broken strptime()
123
124 #if defined(HAVE_STRPTIME) && defined(__DARWIN__) && defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
125 // configure detects strptime as linkable because it's in the OS X
126 // System library but MSL headers don't declare it.
127
128 // char *strptime(const char *, const char *, struct tm *);
129 // However, we DON'T want to just provide it here because we would
130 // crash and/or overwrite data when strptime from OS X tries
131 // to fill in MW's struct tm which is two fields shorter (no TZ stuff)
132 // So for now let's just say we don't have strptime
133 #undef HAVE_STRPTIME
134 #endif
135
136 #if defined(__MWERKS__) && wxUSE_UNICODE
137 #include <wtime.h>
138 #endif
139
140 // define a special symbol for VC8 instead of writing tests for 1400 repeatedly
141 #ifdef __VISUALC__
142 #if __VISUALC__ >= 1400
143 #define __VISUALC8__
144 #endif
145 #endif
146
147 #if !defined(WX_TIMEZONE) && !defined(WX_GMTOFF_IN_TM)
148 #if defined(__WXPALMOS__)
149 #define WX_GMTOFF_IN_TM
150 #elif defined(__BORLANDC__) || defined(__MINGW32__) || defined(__VISAGECPP__)
151 #define WX_TIMEZONE _timezone
152 #elif defined(__MWERKS__)
153 long wxmw_timezone = 28800;
154 #define WX_TIMEZONE wxmw_timezone
155 #elif defined(__DJGPP__) || defined(__WINE__)
156 #include <sys/timeb.h>
157 #include <values.h>
158 static long wxGetTimeZone()
159 {
160 static long timezone = MAXLONG; // invalid timezone
161 if (timezone == MAXLONG)
162 {
163 struct timeb tb;
164 ftime(&tb);
165 timezone = tb.timezone;
166 }
167 return timezone;
168 }
169 #define WX_TIMEZONE wxGetTimeZone()
170 #elif defined(__DARWIN__)
171 #define WX_GMTOFF_IN_TM
172 #elif defined(__WXWINCE__) && defined(__VISUALC8__)
173 #define WX_TIMEZONE _timezone
174 #else // unknown platform - try timezone
175 #define WX_TIMEZONE timezone
176 #endif
177 #endif // !WX_TIMEZONE && !WX_GMTOFF_IN_TM
178
179 // everyone has strftime except Win CE unless VC8 is used
180 #if !defined(__WXWINCE__) || defined(__VISUALC8__)
181 #define HAVE_STRFTIME
182 #endif
183
184 // NB: VC8 safe time functions could/should be used for wxMSW as well probably
185 #if defined(__WXWINCE__) && defined(__VISUALC8__)
186
187 struct tm *wxLocaltime_r(const time_t *t, struct tm* tm)
188 {
189 __time64_t t64 = *t;
190 return _localtime64_s(tm, &t64) == 0 ? tm : NULL;
191 }
192
193 struct tm *wxGmtime_r(const time_t* t, struct tm* tm)
194 {
195 __time64_t t64 = *t;
196 return _gmtime64_s(tm, &t64) == 0 ? tm : NULL;
197 }
198
199 #else // !wxWinCE with VC8
200
201 #if (!defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)) && wxUSE_THREADS && !defined(__WINDOWS__)
202 static wxMutex timeLock;
203 #endif
204
205 #ifndef HAVE_LOCALTIME_R
206 struct tm *wxLocaltime_r(const time_t* ticks, struct tm* temp)
207 {
208 #if wxUSE_THREADS && !defined(__WINDOWS__)
209 // No need to waste time with a mutex on windows since it's using
210 // thread local storage for localtime anyway.
211 wxMutexLocker locker(timeLock);
212 #endif
213 memcpy(temp, localtime(ticks), sizeof(struct tm));
214 return temp;
215 }
216 #endif // !HAVE_LOCALTIME_R
217
218 #ifndef HAVE_GMTIME_R
219 struct tm *wxGmtime_r(const time_t* ticks, struct tm* temp)
220 {
221 #if wxUSE_THREADS && !defined(__WINDOWS__)
222 // No need to waste time with a mutex on windows since it's
223 // using thread local storage for gmtime anyway.
224 wxMutexLocker locker(timeLock);
225 #endif
226 memcpy(temp, gmtime(ticks), sizeof(struct tm));
227 return temp;
228 }
229 #endif // !HAVE_GMTIME_R
230
231 #endif // wxWinCE with VC8/other platforms
232
233 // ----------------------------------------------------------------------------
234 // macros
235 // ----------------------------------------------------------------------------
236
237 // debugging helper: just a convenient replacement of wxCHECK()
238 #define wxDATETIME_CHECK(expr, msg) \
239 wxCHECK2_MSG(expr, *this = wxInvalidDateTime; return *this, msg)
240
241 // ----------------------------------------------------------------------------
242 // private classes
243 // ----------------------------------------------------------------------------
244
245 class wxDateTimeHolidaysModule : public wxModule
246 {
247 public:
248 virtual bool OnInit()
249 {
250 wxDateTimeHolidayAuthority::AddAuthority(new wxDateTimeWorkDays);
251
252 return true;
253 }
254
255 virtual void OnExit()
256 {
257 wxDateTimeHolidayAuthority::ClearAllAuthorities();
258 wxDateTimeHolidayAuthority::ms_authorities.clear();
259 }
260
261 private:
262 DECLARE_DYNAMIC_CLASS(wxDateTimeHolidaysModule)
263 };
264
265 IMPLEMENT_DYNAMIC_CLASS(wxDateTimeHolidaysModule, wxModule)
266
267 // ----------------------------------------------------------------------------
268 // constants
269 // ----------------------------------------------------------------------------
270
271 // some trivial ones
272 static const int MONTHS_IN_YEAR = 12;
273
274 static const int SEC_PER_MIN = 60;
275
276 static const int MIN_PER_HOUR = 60;
277
278 static const int HOURS_PER_DAY = 24;
279
280 static const long SECONDS_PER_DAY = 86400l;
281
282 static const int DAYS_PER_WEEK = 7;
283
284 static const long MILLISECONDS_PER_DAY = 86400000l;
285
286 // this is the integral part of JDN of the midnight of Jan 1, 1970
287 // (i.e. JDN(Jan 1, 1970) = 2440587.5)
288 static const long EPOCH_JDN = 2440587l;
289
290 // used only in asserts
291 #ifdef __WXDEBUG__
292 // the date of JDN -0.5 (as we don't work with fractional parts, this is the
293 // reference date for us) is Nov 24, 4714BC
294 static const int JDN_0_YEAR = -4713;
295 static const int JDN_0_MONTH = wxDateTime::Nov;
296 static const int JDN_0_DAY = 24;
297 #endif // __WXDEBUG__
298
299 // the constants used for JDN calculations
300 static const long JDN_OFFSET = 32046l;
301 static const long DAYS_PER_5_MONTHS = 153l;
302 static const long DAYS_PER_4_YEARS = 1461l;
303 static const long DAYS_PER_400_YEARS = 146097l;
304
305 // this array contains the cumulated number of days in all previous months for
306 // normal and leap years
307 static const wxDateTime::wxDateTime_t gs_cumulatedDays[2][MONTHS_IN_YEAR] =
308 {
309 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
310 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
311 };
312
313 // ----------------------------------------------------------------------------
314 // global data
315 // ----------------------------------------------------------------------------
316
317 const wxChar * wxDefaultDateTimeFormat = wxT("%c");
318 const wxChar * wxDefaultTimeSpanFormat = wxT("%H:%M:%S");
319
320 // in the fine tradition of ANSI C we use our equivalent of (time_t)-1 to
321 // indicate an invalid wxDateTime object
322 const wxDateTime wxDefaultDateTime;
323
324 wxDateTime::Country wxDateTime::ms_country = wxDateTime::Country_Unknown;
325
326 // ----------------------------------------------------------------------------
327 // private functions
328 // ----------------------------------------------------------------------------
329
330 // debugger helper: shows what the date really is
331 #ifdef __WXDEBUG__
332 extern const wxChar *wxDumpDate(const wxDateTime* dt)
333 {
334 static wxChar buf[128];
335
336 wxStrcpy(buf, dt->Format(_T("%Y-%m-%d (%a) %H:%M:%S")));
337
338 return buf;
339 }
340 #endif // Debug
341
342 // get the number of days in the given month of the given year
343 static inline
344 wxDateTime::wxDateTime_t GetNumOfDaysInMonth(int year, wxDateTime::Month month)
345 {
346 // the number of days in month in Julian/Gregorian calendar: the first line
347 // is for normal years, the second one is for the leap ones
348 static wxDateTime::wxDateTime_t daysInMonth[2][MONTHS_IN_YEAR] =
349 {
350 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
351 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
352 };
353
354 return daysInMonth[wxDateTime::IsLeapYear(year)][month];
355 }
356
357 // returns the time zone in the C sense, i.e. the difference UTC - local
358 // (in seconds)
359 static int GetTimeZone()
360 {
361 // set to true when the timezone is set
362 static bool s_timezoneSet = false;
363 static long gmtoffset = LONG_MAX; // invalid timezone
364
365 // ensure that the timezone variable is set by calling wxLocaltime_r
366 if ( !s_timezoneSet )
367 {
368 // just call wxLocaltime_r() instead of figuring out whether this
369 // system supports tzset(), _tzset() or something else
370 time_t t = 0;
371 struct tm tm;
372
373 wxLocaltime_r(&t, &tm);
374 s_timezoneSet = true;
375
376 #ifdef WX_GMTOFF_IN_TM
377 // note that GMT offset is the opposite of time zone and so to return
378 // consistent results in both WX_GMTOFF_IN_TM and !WX_GMTOFF_IN_TM
379 // cases we have to negate it
380 gmtoffset = -tm.tm_gmtoff;
381 #else // !WX_GMTOFF_IN_TM
382 gmtoffset = WX_TIMEZONE;
383 #endif // WX_GMTOFF_IN_TM/!WX_GMTOFF_IN_TM
384 }
385
386 return (int)gmtoffset;
387 }
388
389 // return the integral part of the JDN for the midnight of the given date (to
390 // get the real JDN you need to add 0.5, this is, in fact, JDN of the
391 // noon of the previous day)
392 static long GetTruncatedJDN(wxDateTime::wxDateTime_t day,
393 wxDateTime::Month mon,
394 int year)
395 {
396 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
397
398 // check the date validity
399 wxASSERT_MSG(
400 (year > JDN_0_YEAR) ||
401 ((year == JDN_0_YEAR) && (mon > JDN_0_MONTH)) ||
402 ((year == JDN_0_YEAR) && (mon == JDN_0_MONTH) && (day >= JDN_0_DAY)),
403 _T("date out of range - can't convert to JDN")
404 );
405
406 // make the year positive to avoid problems with negative numbers division
407 year += 4800;
408
409 // months are counted from March here
410 int month;
411 if ( mon >= wxDateTime::Mar )
412 {
413 month = mon - 2;
414 }
415 else
416 {
417 month = mon + 10;
418 year--;
419 }
420
421 // now we can simply add all the contributions together
422 return ((year / 100) * DAYS_PER_400_YEARS) / 4
423 + ((year % 100) * DAYS_PER_4_YEARS) / 4
424 + (month * DAYS_PER_5_MONTHS + 2) / 5
425 + day
426 - JDN_OFFSET;
427 }
428
429 #ifdef HAVE_STRFTIME
430
431 // this function is a wrapper around strftime(3) adding error checking
432 static wxString CallStrftime(const wxChar *format, const tm* tm)
433 {
434 wxChar buf[4096];
435 // Create temp wxString here to work around mingw/cygwin bug 1046059
436 // http://sourceforge.net/tracker/?func=detail&atid=102435&aid=1046059&group_id=2435
437 wxString s;
438
439 if ( !wxStrftime(buf, WXSIZEOF(buf), format, tm) )
440 {
441 // buffer is too small?
442 wxFAIL_MSG(_T("strftime() failed"));
443 }
444
445 s = buf;
446 return s;
447 }
448
449 #endif // HAVE_STRFTIME
450
451 #ifdef HAVE_STRPTIME
452
453 #if wxUSE_UNIX && !defined(HAVE_STRPTIME_DECL)
454 // configure detected that we had strptime() but not its declaration,
455 // provide it ourselves
456 extern "C" char *strptime(const char *, const char *, struct tm *);
457 #endif
458
459 // Unicode-friendly strptime() wrapper
460 static const wxChar *
461 CallStrptime(const wxChar *input, const char *fmt, tm *tm)
462 {
463 // the problem here is that strptime() returns pointer into the string we
464 // passed to it while we're really interested in the pointer into the
465 // original, Unicode, string so we try to transform the pointer back
466 #if wxUSE_UNICODE
467 wxCharBuffer inputMB(wxConvertWX2MB(input));
468 #else // ASCII
469 const char * const inputMB = input;
470 #endif // Unicode/Ascii
471
472 const char *result = strptime(inputMB, fmt, tm);
473 if ( !result )
474 return NULL;
475
476 #if wxUSE_UNICODE
477 // FIXME: this is wrong in presence of surrogates &c
478 return input + (result - inputMB.data());
479 #else // ASCII
480 return result;
481 #endif // Unicode/Ascii
482 }
483
484 #endif // HAVE_STRPTIME
485
486 // if year and/or month have invalid values, replace them with the current ones
487 static void ReplaceDefaultYearMonthWithCurrent(int *year,
488 wxDateTime::Month *month)
489 {
490 struct tm *tmNow = NULL;
491 struct tm tmstruct;
492
493 if ( *year == wxDateTime::Inv_Year )
494 {
495 tmNow = wxDateTime::GetTmNow(&tmstruct);
496
497 *year = 1900 + tmNow->tm_year;
498 }
499
500 if ( *month == wxDateTime::Inv_Month )
501 {
502 if ( !tmNow )
503 tmNow = wxDateTime::GetTmNow(&tmstruct);
504
505 *month = (wxDateTime::Month)tmNow->tm_mon;
506 }
507 }
508
509 // fll the struct tm with default values
510 static void InitTm(struct tm& tm)
511 {
512 // struct tm may have etxra fields (undocumented and with unportable
513 // names) which, nevertheless, must be set to 0
514 memset(&tm, 0, sizeof(struct tm));
515
516 tm.tm_mday = 1; // mday 0 is invalid
517 tm.tm_year = 76; // any valid year
518 tm.tm_isdst = -1; // auto determine
519 }
520
521 // parsing helpers
522 // ---------------
523
524 // return the month if the string is a month name or Inv_Month otherwise
525 static wxDateTime::Month GetMonthFromName(const wxString& name, int flags)
526 {
527 wxDateTime::Month mon;
528 for ( mon = wxDateTime::Jan; mon < wxDateTime::Inv_Month; wxNextMonth(mon) )
529 {
530 // case-insensitive comparison either one of or with both abbreviated
531 // and not versions
532 if ( flags & wxDateTime::Name_Full )
533 {
534 if ( name.CmpNoCase(wxDateTime::
535 GetMonthName(mon, wxDateTime::Name_Full)) == 0 )
536 {
537 break;
538 }
539 }
540
541 if ( flags & wxDateTime::Name_Abbr )
542 {
543 if ( name.CmpNoCase(wxDateTime::
544 GetMonthName(mon, wxDateTime::Name_Abbr)) == 0 )
545 {
546 break;
547 }
548 }
549 }
550
551 return mon;
552 }
553
554 // return the weekday if the string is a weekday name or Inv_WeekDay otherwise
555 static wxDateTime::WeekDay GetWeekDayFromName(const wxString& name, int flags)
556 {
557 wxDateTime::WeekDay wd;
558 for ( wd = wxDateTime::Sun; wd < wxDateTime::Inv_WeekDay; wxNextWDay(wd) )
559 {
560 // case-insensitive comparison either one of or with both abbreviated
561 // and not versions
562 if ( flags & wxDateTime::Name_Full )
563 {
564 if ( name.CmpNoCase(wxDateTime::
565 GetWeekDayName(wd, wxDateTime::Name_Full)) == 0 )
566 {
567 break;
568 }
569 }
570
571 if ( flags & wxDateTime::Name_Abbr )
572 {
573 if ( name.CmpNoCase(wxDateTime::
574 GetWeekDayName(wd, wxDateTime::Name_Abbr)) == 0 )
575 {
576 break;
577 }
578 }
579 }
580
581 return wd;
582 }
583
584 /* static */
585 struct tm *wxDateTime::GetTmNow(struct tm *tmstruct)
586 {
587 time_t t = GetTimeNow();
588 return wxLocaltime_r(&t, tmstruct);
589 }
590
591 // scans all digits (but no more than len) and returns the resulting number
592 static bool GetNumericToken(size_t len, const wxChar*& p, unsigned long *number)
593 {
594 size_t n = 1;
595 wxString s;
596 while ( wxIsdigit(*p) )
597 {
598 s += *p++;
599
600 if ( len && ++n > len )
601 break;
602 }
603
604 return !s.empty() && s.ToULong(number);
605 }
606
607 // scans all alphabetic characters and returns the resulting string
608 static wxString GetAlphaToken(const wxChar*& p)
609 {
610 wxString s;
611 while ( wxIsalpha(*p) )
612 {
613 s += *p++;
614 }
615
616 return s;
617 }
618
619 // ============================================================================
620 // implementation of wxDateTime
621 // ============================================================================
622
623 // ----------------------------------------------------------------------------
624 // struct Tm
625 // ----------------------------------------------------------------------------
626
627 wxDateTime::Tm::Tm()
628 {
629 year = (wxDateTime_t)wxDateTime::Inv_Year;
630 mon = wxDateTime::Inv_Month;
631 mday = 0;
632 hour = min = sec = msec = 0;
633 wday = wxDateTime::Inv_WeekDay;
634 }
635
636 wxDateTime::Tm::Tm(const struct tm& tm, const TimeZone& tz)
637 : m_tz(tz)
638 {
639 msec = 0;
640 sec = (wxDateTime::wxDateTime_t)tm.tm_sec;
641 min = (wxDateTime::wxDateTime_t)tm.tm_min;
642 hour = (wxDateTime::wxDateTime_t)tm.tm_hour;
643 mday = (wxDateTime::wxDateTime_t)tm.tm_mday;
644 mon = (wxDateTime::Month)tm.tm_mon;
645 year = 1900 + tm.tm_year;
646 wday = (wxDateTime::wxDateTime_t)tm.tm_wday;
647 yday = (wxDateTime::wxDateTime_t)tm.tm_yday;
648 }
649
650 bool wxDateTime::Tm::IsValid() const
651 {
652 // we allow for the leap seconds, although we don't use them (yet)
653 return (year != wxDateTime::Inv_Year) && (mon != wxDateTime::Inv_Month) &&
654 (mday <= GetNumOfDaysInMonth(year, mon)) &&
655 (hour < 24) && (min < 60) && (sec < 62) && (msec < 1000);
656 }
657
658 void wxDateTime::Tm::ComputeWeekDay()
659 {
660 // compute the week day from day/month/year: we use the dumbest algorithm
661 // possible: just compute our JDN and then use the (simple to derive)
662 // formula: weekday = (JDN + 1.5) % 7
663 wday = (wxDateTime::wxDateTime_t)((wxDateTime::WeekDay)(GetTruncatedJDN(mday, mon, year) + 2) % 7);
664 }
665
666 void wxDateTime::Tm::AddMonths(int monDiff)
667 {
668 // normalize the months field
669 while ( monDiff < -mon )
670 {
671 year--;
672
673 monDiff += MONTHS_IN_YEAR;
674 }
675
676 while ( monDiff + mon >= MONTHS_IN_YEAR )
677 {
678 year++;
679
680 monDiff -= MONTHS_IN_YEAR;
681 }
682
683 mon = (wxDateTime::Month)(mon + monDiff);
684
685 wxASSERT_MSG( mon >= 0 && mon < MONTHS_IN_YEAR, _T("logic error") );
686
687 // NB: we don't check here that the resulting date is valid, this function
688 // is private and the caller must check it if needed
689 }
690
691 void wxDateTime::Tm::AddDays(int dayDiff)
692 {
693 // normalize the days field
694 while ( dayDiff + mday < 1 )
695 {
696 AddMonths(-1);
697
698 dayDiff += GetNumOfDaysInMonth(year, mon);
699 }
700
701 mday = (wxDateTime::wxDateTime_t)( mday + dayDiff );
702 while ( mday > GetNumOfDaysInMonth(year, mon) )
703 {
704 mday -= GetNumOfDaysInMonth(year, mon);
705
706 AddMonths(1);
707 }
708
709 wxASSERT_MSG( mday > 0 && mday <= GetNumOfDaysInMonth(year, mon),
710 _T("logic error") );
711 }
712
713 // ----------------------------------------------------------------------------
714 // class TimeZone
715 // ----------------------------------------------------------------------------
716
717 wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz)
718 {
719 switch ( tz )
720 {
721 case wxDateTime::Local:
722 // get the offset from C RTL: it returns the difference GMT-local
723 // while we want to have the offset _from_ GMT, hence the '-'
724 m_offset = -GetTimeZone();
725 break;
726
727 case wxDateTime::GMT_12:
728 case wxDateTime::GMT_11:
729 case wxDateTime::GMT_10:
730 case wxDateTime::GMT_9:
731 case wxDateTime::GMT_8:
732 case wxDateTime::GMT_7:
733 case wxDateTime::GMT_6:
734 case wxDateTime::GMT_5:
735 case wxDateTime::GMT_4:
736 case wxDateTime::GMT_3:
737 case wxDateTime::GMT_2:
738 case wxDateTime::GMT_1:
739 m_offset = -3600*(wxDateTime::GMT0 - tz);
740 break;
741
742 case wxDateTime::GMT0:
743 case wxDateTime::GMT1:
744 case wxDateTime::GMT2:
745 case wxDateTime::GMT3:
746 case wxDateTime::GMT4:
747 case wxDateTime::GMT5:
748 case wxDateTime::GMT6:
749 case wxDateTime::GMT7:
750 case wxDateTime::GMT8:
751 case wxDateTime::GMT9:
752 case wxDateTime::GMT10:
753 case wxDateTime::GMT11:
754 case wxDateTime::GMT12:
755 case wxDateTime::GMT13:
756 m_offset = 3600*(tz - wxDateTime::GMT0);
757 break;
758
759 case wxDateTime::A_CST:
760 // Central Standard Time in use in Australia = UTC + 9.5
761 m_offset = 60l*(9*MIN_PER_HOUR + MIN_PER_HOUR/2);
762 break;
763
764 default:
765 wxFAIL_MSG( _T("unknown time zone") );
766 }
767 }
768
769 // ----------------------------------------------------------------------------
770 // static functions
771 // ----------------------------------------------------------------------------
772
773 /* static */
774 bool wxDateTime::IsLeapYear(int year, wxDateTime::Calendar cal)
775 {
776 if ( year == Inv_Year )
777 year = GetCurrentYear();
778
779 if ( cal == Gregorian )
780 {
781 // in Gregorian calendar leap years are those divisible by 4 except
782 // those divisible by 100 unless they're also divisible by 400
783 // (in some countries, like Russia and Greece, additional corrections
784 // exist, but they won't manifest themselves until 2700)
785 return (year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0));
786 }
787 else if ( cal == Julian )
788 {
789 // in Julian calendar the rule is simpler
790 return year % 4 == 0;
791 }
792 else
793 {
794 wxFAIL_MSG(_T("unknown calendar"));
795
796 return false;
797 }
798 }
799
800 /* static */
801 int wxDateTime::GetCentury(int year)
802 {
803 return year > 0 ? year / 100 : year / 100 - 1;
804 }
805
806 /* static */
807 int wxDateTime::ConvertYearToBC(int year)
808 {
809 // year 0 is BC 1
810 return year > 0 ? year : year - 1;
811 }
812
813 /* static */
814 int wxDateTime::GetCurrentYear(wxDateTime::Calendar cal)
815 {
816 switch ( cal )
817 {
818 case Gregorian:
819 return Now().GetYear();
820
821 case Julian:
822 wxFAIL_MSG(_T("TODO"));
823 break;
824
825 default:
826 wxFAIL_MSG(_T("unsupported calendar"));
827 break;
828 }
829
830 return Inv_Year;
831 }
832
833 /* static */
834 wxDateTime::Month wxDateTime::GetCurrentMonth(wxDateTime::Calendar cal)
835 {
836 switch ( cal )
837 {
838 case Gregorian:
839 return Now().GetMonth();
840
841 case Julian:
842 wxFAIL_MSG(_T("TODO"));
843 break;
844
845 default:
846 wxFAIL_MSG(_T("unsupported calendar"));
847 break;
848 }
849
850 return Inv_Month;
851 }
852
853 /* static */
854 wxDateTime::wxDateTime_t wxDateTime::GetNumberOfDays(int year, Calendar cal)
855 {
856 if ( year == Inv_Year )
857 {
858 // take the current year if none given
859 year = GetCurrentYear();
860 }
861
862 switch ( cal )
863 {
864 case Gregorian:
865 case Julian:
866 return IsLeapYear(year) ? 366 : 365;
867
868 default:
869 wxFAIL_MSG(_T("unsupported calendar"));
870 break;
871 }
872
873 return 0;
874 }
875
876 /* static */
877 wxDateTime::wxDateTime_t wxDateTime::GetNumberOfDays(wxDateTime::Month month,
878 int year,
879 wxDateTime::Calendar cal)
880 {
881 wxCHECK_MSG( month < MONTHS_IN_YEAR, 0, _T("invalid month") );
882
883 if ( cal == Gregorian || cal == Julian )
884 {
885 if ( year == Inv_Year )
886 {
887 // take the current year if none given
888 year = GetCurrentYear();
889 }
890
891 return GetNumOfDaysInMonth(year, month);
892 }
893 else
894 {
895 wxFAIL_MSG(_T("unsupported calendar"));
896
897 return 0;
898 }
899 }
900
901 /* static */
902 wxString wxDateTime::GetMonthName(wxDateTime::Month month,
903 wxDateTime::NameFlags flags)
904 {
905 wxCHECK_MSG( month != Inv_Month, wxEmptyString, _T("invalid month") );
906 #ifdef HAVE_STRFTIME
907 // notice that we must set all the fields to avoid confusing libc (GNU one
908 // gets confused to a crash if we don't do this)
909 tm tm;
910 InitTm(tm);
911 tm.tm_mon = month;
912
913 return CallStrftime(flags == Name_Abbr ? _T("%b") : _T("%B"), &tm);
914 #else // !HAVE_STRFTIME
915 wxString ret;
916 switch(month)
917 {
918 case Jan:
919 ret = (flags == Name_Abbr ? wxT("Jan"): wxT("January"));
920 break;
921 case Feb:
922 ret = (flags == Name_Abbr ? wxT("Feb"): wxT("Febuary"));
923 break;
924 case Mar:
925 ret = (flags == Name_Abbr ? wxT("Mar"): wxT("March"));
926 break;
927 case Apr:
928 ret = (flags == Name_Abbr ? wxT("Apr"): wxT("April"));
929 break;
930 case May:
931 ret = (flags == Name_Abbr ? wxT("May"): wxT("May"));
932 break;
933 case Jun:
934 ret = (flags == Name_Abbr ? wxT("Jun"): wxT("June"));
935 break;
936 case Jul:
937 ret = (flags == Name_Abbr ? wxT("Jul"): wxT("July"));
938 break;
939 case Aug:
940 ret = (flags == Name_Abbr ? wxT("Aug"): wxT("August"));
941 break;
942 case Sep:
943 ret = (flags == Name_Abbr ? wxT("Sep"): wxT("September"));
944 break;
945 case Oct:
946 ret = (flags == Name_Abbr ? wxT("Oct"): wxT("October"));
947 break;
948 case Nov:
949 ret = (flags == Name_Abbr ? wxT("Nov"): wxT("November"));
950 break;
951 case Dec:
952 ret = (flags == Name_Abbr ? wxT("Dec"): wxT("December"));
953 break;
954 }
955 return ret;
956 #endif // HAVE_STRFTIME/!HAVE_STRFTIME
957 }
958
959 /* static */
960 wxString wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday,
961 wxDateTime::NameFlags flags)
962 {
963 wxCHECK_MSG( wday != Inv_WeekDay, wxEmptyString, _T("invalid weekday") );
964 #ifdef HAVE_STRFTIME
965 // take some arbitrary Sunday (but notice that the day should be such that
966 // after adding wday to it below we still have a valid date, e.g. don't
967 // take 28 here!)
968 tm tm;
969 InitTm(tm);
970 tm.tm_mday = 21;
971 tm.tm_mon = Nov;
972 tm.tm_year = 99;
973
974 // and offset it by the number of days needed to get the correct wday
975 tm.tm_mday += wday;
976
977 // call mktime() to normalize it...
978 (void)mktime(&tm);
979
980 // ... and call strftime()
981 return CallStrftime(flags == Name_Abbr ? _T("%a") : _T("%A"), &tm);
982 #else // !HAVE_STRFTIME
983 wxString ret;
984 switch(wday)
985 {
986 case Sun:
987 ret = (flags == Name_Abbr ? wxT("Sun") : wxT("Sunday"));
988 break;
989 case Mon:
990 ret = (flags == Name_Abbr ? wxT("Mon") : wxT("Monday"));
991 break;
992 case Tue:
993 ret = (flags == Name_Abbr ? wxT("Tue") : wxT("Tuesday"));
994 break;
995 case Wed:
996 ret = (flags == Name_Abbr ? wxT("Wed") : wxT("Wednesday"));
997 break;
998 case Thu:
999 ret = (flags == Name_Abbr ? wxT("Thu") : wxT("Thursday"));
1000 break;
1001 case Fri:
1002 ret = (flags == Name_Abbr ? wxT("Fri") : wxT("Friday"));
1003 break;
1004 case Sat:
1005 ret = (flags == Name_Abbr ? wxT("Sat") : wxT("Saturday"));
1006 break;
1007 }
1008 return ret;
1009 #endif // HAVE_STRFTIME/!HAVE_STRFTIME
1010 }
1011
1012 /* static */
1013 void wxDateTime::GetAmPmStrings(wxString *am, wxString *pm)
1014 {
1015 tm tm;
1016 InitTm(tm);
1017 wxChar buffer[64];
1018 // @Note: Do not call 'CallStrftime' here! CallStrftime checks the return code
1019 // and causes an assertion failed if the buffer is to small (which is good) - OR -
1020 // if strftime does not return anything because the format string is invalid - OR -
1021 // if there are no 'am' / 'pm' tokens defined for the current locale (which is not good).
1022 // wxDateTime::ParseTime will try several different formats to parse the time.
1023 // As a result, GetAmPmStrings might get called, even if the current locale
1024 // does not define any 'am' / 'pm' tokens. In this case, wxStrftime would
1025 // assert, even though it is a perfectly legal use.
1026 if ( am )
1027 {
1028 if (wxStrftime(buffer, sizeof(buffer)/sizeof(wxChar), _T("%p"), &tm) > 0)
1029 *am = wxString(buffer);
1030 else
1031 *am = wxString();
1032 }
1033 if ( pm )
1034 {
1035 tm.tm_hour = 13;
1036 if (wxStrftime(buffer, sizeof(buffer)/sizeof(wxChar), _T("%p"), &tm) > 0)
1037 *pm = wxString(buffer);
1038 else
1039 *pm = wxString();
1040 }
1041 }
1042
1043 // ----------------------------------------------------------------------------
1044 // Country stuff: date calculations depend on the country (DST, work days,
1045 // ...), so we need to know which rules to follow.
1046 // ----------------------------------------------------------------------------
1047
1048 /* static */
1049 wxDateTime::Country wxDateTime::GetCountry()
1050 {
1051 // TODO use LOCALE_ICOUNTRY setting under Win32
1052 #ifndef __WXWINCE__
1053 if ( ms_country == Country_Unknown )
1054 {
1055 // try to guess from the time zone name
1056 time_t t = time(NULL);
1057 struct tm tmstruct;
1058 struct tm *tm = wxLocaltime_r(&t, &tmstruct);
1059
1060 wxString tz = CallStrftime(_T("%Z"), tm);
1061 if ( tz == _T("WET") || tz == _T("WEST") )
1062 {
1063 ms_country = UK;
1064 }
1065 else if ( tz == _T("CET") || tz == _T("CEST") )
1066 {
1067 ms_country = Country_EEC;
1068 }
1069 else if ( tz == _T("MSK") || tz == _T("MSD") )
1070 {
1071 ms_country = Russia;
1072 }
1073 else if ( tz == _T("AST") || tz == _T("ADT") ||
1074 tz == _T("EST") || tz == _T("EDT") ||
1075 tz == _T("CST") || tz == _T("CDT") ||
1076 tz == _T("MST") || tz == _T("MDT") ||
1077 tz == _T("PST") || tz == _T("PDT") )
1078 {
1079 ms_country = USA;
1080 }
1081 else
1082 {
1083 // well, choose a default one
1084 ms_country = USA;
1085 }
1086 }
1087 #else // __WXWINCE__
1088 ms_country = USA;
1089 #endif // !__WXWINCE__/__WXWINCE__
1090
1091 return ms_country;
1092 }
1093
1094 /* static */
1095 void wxDateTime::SetCountry(wxDateTime::Country country)
1096 {
1097 ms_country = country;
1098 }
1099
1100 /* static */
1101 bool wxDateTime::IsWestEuropeanCountry(Country country)
1102 {
1103 if ( country == Country_Default )
1104 {
1105 country = GetCountry();
1106 }
1107
1108 return (Country_WesternEurope_Start <= country) &&
1109 (country <= Country_WesternEurope_End);
1110 }
1111
1112 // ----------------------------------------------------------------------------
1113 // DST calculations: we use 3 different rules for the West European countries,
1114 // USA and for the rest of the world. This is undoubtedly false for many
1115 // countries, but I lack the necessary info (and the time to gather it),
1116 // please add the other rules here!
1117 // ----------------------------------------------------------------------------
1118
1119 /* static */
1120 bool wxDateTime::IsDSTApplicable(int year, Country country)
1121 {
1122 if ( year == Inv_Year )
1123 {
1124 // take the current year if none given
1125 year = GetCurrentYear();
1126 }
1127
1128 if ( country == Country_Default )
1129 {
1130 country = GetCountry();
1131 }
1132
1133 switch ( country )
1134 {
1135 case USA:
1136 case UK:
1137 // DST was first observed in the US and UK during WWI, reused
1138 // during WWII and used again since 1966
1139 return year >= 1966 ||
1140 (year >= 1942 && year <= 1945) ||
1141 (year == 1918 || year == 1919);
1142
1143 default:
1144 // assume that it started after WWII
1145 return year > 1950;
1146 }
1147 }
1148
1149 /* static */
1150 wxDateTime wxDateTime::GetBeginDST(int year, Country country)
1151 {
1152 if ( year == Inv_Year )
1153 {
1154 // take the current year if none given
1155 year = GetCurrentYear();
1156 }
1157
1158 if ( country == Country_Default )
1159 {
1160 country = GetCountry();
1161 }
1162
1163 if ( !IsDSTApplicable(year, country) )
1164 {
1165 return wxInvalidDateTime;
1166 }
1167
1168 wxDateTime dt;
1169
1170 if ( IsWestEuropeanCountry(country) || (country == Russia) )
1171 {
1172 // DST begins at 1 a.m. GMT on the last Sunday of March
1173 if ( !dt.SetToLastWeekDay(Sun, Mar, year) )
1174 {
1175 // weird...
1176 wxFAIL_MSG( _T("no last Sunday in March?") );
1177 }
1178
1179 dt += wxTimeSpan::Hours(1);
1180
1181 // disable DST tests because it could result in an infinite recursion!
1182 dt.MakeGMT(true);
1183 }
1184 else switch ( country )
1185 {
1186 case USA:
1187 switch ( year )
1188 {
1189 case 1918:
1190 case 1919:
1191 // don't know for sure - assume it was in effect all year
1192
1193 case 1943:
1194 case 1944:
1195 case 1945:
1196 dt.Set(1, Jan, year);
1197 break;
1198
1199 case 1942:
1200 // DST was installed Feb 2, 1942 by the Congress
1201 dt.Set(2, Feb, year);
1202 break;
1203
1204 // Oil embargo changed the DST period in the US
1205 case 1974:
1206 dt.Set(6, Jan, 1974);
1207 break;
1208
1209 case 1975:
1210 dt.Set(23, Feb, 1975);
1211 break;
1212
1213 default:
1214 // before 1986, DST begun on the last Sunday of April, but
1215 // in 1986 Reagan changed it to begin at 2 a.m. of the
1216 // first Sunday in April
1217 if ( year < 1986 )
1218 {
1219 if ( !dt.SetToLastWeekDay(Sun, Apr, year) )
1220 {
1221 // weird...
1222 wxFAIL_MSG( _T("no first Sunday in April?") );
1223 }
1224 }
1225 else
1226 {
1227 if ( !dt.SetToWeekDay(Sun, 1, Apr, year) )
1228 {
1229 // weird...
1230 wxFAIL_MSG( _T("no first Sunday in April?") );
1231 }
1232 }
1233
1234 dt += wxTimeSpan::Hours(2);
1235
1236 // TODO what about timezone??
1237 }
1238
1239 break;
1240
1241 default:
1242 // assume Mar 30 as the start of the DST for the rest of the world
1243 // - totally bogus, of course
1244 dt.Set(30, Mar, year);
1245 }
1246
1247 return dt;
1248 }
1249
1250 /* static */
1251 wxDateTime wxDateTime::GetEndDST(int year, Country country)
1252 {
1253 if ( year == Inv_Year )
1254 {
1255 // take the current year if none given
1256 year = GetCurrentYear();
1257 }
1258
1259 if ( country == Country_Default )
1260 {
1261 country = GetCountry();
1262 }
1263
1264 if ( !IsDSTApplicable(year, country) )
1265 {
1266 return wxInvalidDateTime;
1267 }
1268
1269 wxDateTime dt;
1270
1271 if ( IsWestEuropeanCountry(country) || (country == Russia) )
1272 {
1273 // DST ends at 1 a.m. GMT on the last Sunday of October
1274 if ( !dt.SetToLastWeekDay(Sun, Oct, year) )
1275 {
1276 // weirder and weirder...
1277 wxFAIL_MSG( _T("no last Sunday in October?") );
1278 }
1279
1280 dt += wxTimeSpan::Hours(1);
1281
1282 // disable DST tests because it could result in an infinite recursion!
1283 dt.MakeGMT(true);
1284 }
1285 else switch ( country )
1286 {
1287 case USA:
1288 switch ( year )
1289 {
1290 case 1918:
1291 case 1919:
1292 // don't know for sure - assume it was in effect all year
1293
1294 case 1943:
1295 case 1944:
1296 dt.Set(31, Dec, year);
1297 break;
1298
1299 case 1945:
1300 // the time was reset after the end of the WWII
1301 dt.Set(30, Sep, year);
1302 break;
1303
1304 default:
1305 // DST ends at 2 a.m. on the last Sunday of October
1306 if ( !dt.SetToLastWeekDay(Sun, Oct, year) )
1307 {
1308 // weirder and weirder...
1309 wxFAIL_MSG( _T("no last Sunday in October?") );
1310 }
1311
1312 dt += wxTimeSpan::Hours(2);
1313
1314 // TODO what about timezone??
1315 }
1316 break;
1317
1318 default:
1319 // assume October 26th as the end of the DST - totally bogus too
1320 dt.Set(26, Oct, year);
1321 }
1322
1323 return dt;
1324 }
1325
1326 // ----------------------------------------------------------------------------
1327 // constructors and assignment operators
1328 // ----------------------------------------------------------------------------
1329
1330 // return the current time with ms precision
1331 /* static */ wxDateTime wxDateTime::UNow()
1332 {
1333 return wxDateTime(wxGetLocalTimeMillis());
1334 }
1335
1336 // the values in the tm structure contain the local time
1337 wxDateTime& wxDateTime::Set(const struct tm& tm)
1338 {
1339 struct tm tm2(tm);
1340 time_t timet = mktime(&tm2);
1341
1342 if ( timet == (time_t)-1 )
1343 {
1344 // mktime() rather unintuitively fails for Jan 1, 1970 if the hour is
1345 // less than timezone - try to make it work for this case
1346 if ( tm2.tm_year == 70 && tm2.tm_mon == 0 && tm2.tm_mday == 1 )
1347 {
1348 return Set((time_t)(
1349 GetTimeZone() +
1350 tm2.tm_hour * MIN_PER_HOUR * SEC_PER_MIN +
1351 tm2.tm_min * SEC_PER_MIN +
1352 tm2.tm_sec));
1353 }
1354
1355 wxFAIL_MSG( _T("mktime() failed") );
1356
1357 *this = wxInvalidDateTime;
1358
1359 return *this;
1360 }
1361 else
1362 {
1363 return Set(timet);
1364 }
1365 }
1366
1367 wxDateTime& wxDateTime::Set(wxDateTime_t hour,
1368 wxDateTime_t minute,
1369 wxDateTime_t second,
1370 wxDateTime_t millisec)
1371 {
1372 // we allow seconds to be 61 to account for the leap seconds, even if we
1373 // don't use them really
1374 wxDATETIME_CHECK( hour < 24 &&
1375 second < 62 &&
1376 minute < 60 &&
1377 millisec < 1000,
1378 _T("Invalid time in wxDateTime::Set()") );
1379
1380 // get the current date from system
1381 struct tm tmstruct;
1382 struct tm *tm = GetTmNow(&tmstruct);
1383
1384 wxDATETIME_CHECK( tm, _T("wxLocaltime_r() failed") );
1385
1386 // make a copy so it isn't clobbered by the call to mktime() below
1387 struct tm tm1(*tm);
1388
1389 // adjust the time
1390 tm1.tm_hour = hour;
1391 tm1.tm_min = minute;
1392 tm1.tm_sec = second;
1393
1394 // and the DST in case it changes on this date
1395 struct tm tm2(tm1);
1396 mktime(&tm2);
1397 if ( tm2.tm_isdst != tm1.tm_isdst )
1398 tm1.tm_isdst = tm2.tm_isdst;
1399
1400 (void)Set(tm1);
1401
1402 // and finally adjust milliseconds
1403 return SetMillisecond(millisec);
1404 }
1405
1406 wxDateTime& wxDateTime::Set(wxDateTime_t day,
1407 Month month,
1408 int year,
1409 wxDateTime_t hour,
1410 wxDateTime_t minute,
1411 wxDateTime_t second,
1412 wxDateTime_t millisec)
1413 {
1414 wxDATETIME_CHECK( hour < 24 &&
1415 second < 62 &&
1416 minute < 60 &&
1417 millisec < 1000,
1418 _T("Invalid time in wxDateTime::Set()") );
1419
1420 ReplaceDefaultYearMonthWithCurrent(&year, &month);
1421
1422 wxDATETIME_CHECK( (0 < day) && (day <= GetNumberOfDays(month, year)),
1423 _T("Invalid date in wxDateTime::Set()") );
1424
1425 // the range of time_t type (inclusive)
1426 static const int yearMinInRange = 1970;
1427 static const int yearMaxInRange = 2037;
1428
1429 // test only the year instead of testing for the exact end of the Unix
1430 // time_t range - it doesn't bring anything to do more precise checks
1431 if ( year >= yearMinInRange && year <= yearMaxInRange )
1432 {
1433 // use the standard library version if the date is in range - this is
1434 // probably more efficient than our code
1435 struct tm tm;
1436 tm.tm_year = year - 1900;
1437 tm.tm_mon = month;
1438 tm.tm_mday = day;
1439 tm.tm_hour = hour;
1440 tm.tm_min = minute;
1441 tm.tm_sec = second;
1442 tm.tm_isdst = -1; // mktime() will guess it
1443
1444 (void)Set(tm);
1445
1446 // and finally adjust milliseconds
1447 if (IsValid())
1448 SetMillisecond(millisec);
1449
1450 return *this;
1451 }
1452 else
1453 {
1454 // do time calculations ourselves: we want to calculate the number of
1455 // milliseconds between the given date and the epoch
1456
1457 // get the JDN for the midnight of this day
1458 m_time = GetTruncatedJDN(day, month, year);
1459 m_time -= EPOCH_JDN;
1460 m_time *= SECONDS_PER_DAY * TIME_T_FACTOR;
1461
1462 // JDN corresponds to GMT, we take localtime
1463 Add(wxTimeSpan(hour, minute, second + GetTimeZone(), millisec));
1464 }
1465
1466 return *this;
1467 }
1468
1469 wxDateTime& wxDateTime::Set(double jdn)
1470 {
1471 // so that m_time will be 0 for the midnight of Jan 1, 1970 which is jdn
1472 // EPOCH_JDN + 0.5
1473 jdn -= EPOCH_JDN + 0.5;
1474
1475 m_time.Assign(jdn*MILLISECONDS_PER_DAY);
1476
1477 // JDNs always are in UTC, so we don't need any adjustments for time zone
1478
1479 return *this;
1480 }
1481
1482 wxDateTime& wxDateTime::ResetTime()
1483 {
1484 Tm tm = GetTm();
1485
1486 if ( tm.hour || tm.min || tm.sec || tm.msec )
1487 {
1488 tm.msec =
1489 tm.sec =
1490 tm.min =
1491 tm.hour = 0;
1492
1493 Set(tm);
1494 }
1495
1496 return *this;
1497 }
1498
1499 // ----------------------------------------------------------------------------
1500 // DOS Date and Time Format functions
1501 // ----------------------------------------------------------------------------
1502 // the dos date and time value is an unsigned 32 bit value in the format:
1503 // YYYYYYYMMMMDDDDDhhhhhmmmmmmsssss
1504 //
1505 // Y = year offset from 1980 (0-127)
1506 // M = month (1-12)
1507 // D = day of month (1-31)
1508 // h = hour (0-23)
1509 // m = minute (0-59)
1510 // s = bisecond (0-29) each bisecond indicates two seconds
1511 // ----------------------------------------------------------------------------
1512
1513 wxDateTime& wxDateTime::SetFromDOS(unsigned long ddt)
1514 {
1515 struct tm tm;
1516 InitTm(tm);
1517
1518 long year = ddt & 0xFE000000;
1519 year >>= 25;
1520 year += 80;
1521 tm.tm_year = year;
1522
1523 long month = ddt & 0x1E00000;
1524 month >>= 21;
1525 month -= 1;
1526 tm.tm_mon = month;
1527
1528 long day = ddt & 0x1F0000;
1529 day >>= 16;
1530 tm.tm_mday = day;
1531
1532 long hour = ddt & 0xF800;
1533 hour >>= 11;
1534 tm.tm_hour = hour;
1535
1536 long minute = ddt & 0x7E0;
1537 minute >>= 5;
1538 tm.tm_min = minute;
1539
1540 long second = ddt & 0x1F;
1541 tm.tm_sec = second * 2;
1542
1543 return Set(mktime(&tm));
1544 }
1545
1546 unsigned long wxDateTime::GetAsDOS() const
1547 {
1548 unsigned long ddt;
1549 time_t ticks = GetTicks();
1550 struct tm tmstruct;
1551 struct tm *tm = wxLocaltime_r(&ticks, &tmstruct);
1552
1553 long year = tm->tm_year;
1554 year -= 80;
1555 year <<= 25;
1556
1557 long month = tm->tm_mon;
1558 month += 1;
1559 month <<= 21;
1560
1561 long day = tm->tm_mday;
1562 day <<= 16;
1563
1564 long hour = tm->tm_hour;
1565 hour <<= 11;
1566
1567 long minute = tm->tm_min;
1568 minute <<= 5;
1569
1570 long second = tm->tm_sec;
1571 second /= 2;
1572
1573 ddt = year | month | day | hour | minute | second;
1574 return ddt;
1575 }
1576
1577 // ----------------------------------------------------------------------------
1578 // time_t <-> broken down time conversions
1579 // ----------------------------------------------------------------------------
1580
1581 wxDateTime::Tm wxDateTime::GetTm(const TimeZone& tz) const
1582 {
1583 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1584
1585 time_t time = GetTicks();
1586 if ( time != (time_t)-1 )
1587 {
1588 // use C RTL functions
1589 struct tm tmstruct;
1590 tm *tm;
1591 if ( tz.GetOffset() == -GetTimeZone() )
1592 {
1593 // we are working with local time
1594 tm = wxLocaltime_r(&time, &tmstruct);
1595
1596 // should never happen
1597 wxCHECK_MSG( tm, Tm(), _T("wxLocaltime_r() failed") );
1598 }
1599 else
1600 {
1601 time += (time_t)tz.GetOffset();
1602 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
1603 int time2 = (int) time;
1604 if ( time2 >= 0 )
1605 #else
1606 if ( time >= 0 )
1607 #endif
1608 {
1609 tm = wxGmtime_r(&time, &tmstruct);
1610
1611 // should never happen
1612 wxCHECK_MSG( tm, Tm(), _T("wxGmtime_r() failed") );
1613 }
1614 else
1615 {
1616 tm = (struct tm *)NULL;
1617 }
1618 }
1619
1620 if ( tm )
1621 {
1622 // adjust the milliseconds
1623 Tm tm2(*tm, tz);
1624 long timeOnly = (m_time % MILLISECONDS_PER_DAY).ToLong();
1625 tm2.msec = (wxDateTime_t)(timeOnly % 1000);
1626 return tm2;
1627 }
1628 //else: use generic code below
1629 }
1630
1631 // remember the time and do the calculations with the date only - this
1632 // eliminates rounding errors of the floating point arithmetics
1633
1634 wxLongLong timeMidnight = m_time + tz.GetOffset() * 1000;
1635
1636 long timeOnly = (timeMidnight % MILLISECONDS_PER_DAY).ToLong();
1637
1638 // we want to always have positive time and timeMidnight to be really
1639 // the midnight before it
1640 if ( timeOnly < 0 )
1641 {
1642 timeOnly = MILLISECONDS_PER_DAY + timeOnly;
1643 }
1644
1645 timeMidnight -= timeOnly;
1646
1647 // calculate the Gregorian date from JDN for the midnight of our date:
1648 // this will yield day, month (in 1..12 range) and year
1649
1650 // actually, this is the JDN for the noon of the previous day
1651 long jdn = (timeMidnight / MILLISECONDS_PER_DAY).ToLong() + EPOCH_JDN;
1652
1653 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
1654
1655 wxASSERT_MSG( jdn > -2, _T("JDN out of range") );
1656
1657 // calculate the century
1658 long temp = (jdn + JDN_OFFSET) * 4 - 1;
1659 long century = temp / DAYS_PER_400_YEARS;
1660
1661 // then the year and day of year (1 <= dayOfYear <= 366)
1662 temp = ((temp % DAYS_PER_400_YEARS) / 4) * 4 + 3;
1663 long year = (century * 100) + (temp / DAYS_PER_4_YEARS);
1664 long dayOfYear = (temp % DAYS_PER_4_YEARS) / 4 + 1;
1665
1666 // and finally the month and day of the month
1667 temp = dayOfYear * 5 - 3;
1668 long month = temp / DAYS_PER_5_MONTHS;
1669 long day = (temp % DAYS_PER_5_MONTHS) / 5 + 1;
1670
1671 // month is counted from March - convert to normal
1672 if ( month < 10 )
1673 {
1674 month += 3;
1675 }
1676 else
1677 {
1678 year += 1;
1679 month -= 9;
1680 }
1681
1682 // year is offset by 4800
1683 year -= 4800;
1684
1685 // check that the algorithm gave us something reasonable
1686 wxASSERT_MSG( (0 < month) && (month <= 12), _T("invalid month") );
1687 wxASSERT_MSG( (1 <= day) && (day < 32), _T("invalid day") );
1688
1689 // construct Tm from these values
1690 Tm tm;
1691 tm.year = (int)year;
1692 tm.mon = (Month)(month - 1); // algorithm yields 1 for January, not 0
1693 tm.mday = (wxDateTime_t)day;
1694 tm.msec = (wxDateTime_t)(timeOnly % 1000);
1695 timeOnly -= tm.msec;
1696 timeOnly /= 1000; // now we have time in seconds
1697
1698 tm.sec = (wxDateTime_t)(timeOnly % SEC_PER_MIN);
1699 timeOnly -= tm.sec;
1700 timeOnly /= SEC_PER_MIN; // now we have time in minutes
1701
1702 tm.min = (wxDateTime_t)(timeOnly % MIN_PER_HOUR);
1703 timeOnly -= tm.min;
1704
1705 tm.hour = (wxDateTime_t)(timeOnly / MIN_PER_HOUR);
1706
1707 return tm;
1708 }
1709
1710 wxDateTime& wxDateTime::SetYear(int year)
1711 {
1712 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1713
1714 Tm tm(GetTm());
1715 tm.year = year;
1716 Set(tm);
1717
1718 return *this;
1719 }
1720
1721 wxDateTime& wxDateTime::SetMonth(Month month)
1722 {
1723 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1724
1725 Tm tm(GetTm());
1726 tm.mon = month;
1727 Set(tm);
1728
1729 return *this;
1730 }
1731
1732 wxDateTime& wxDateTime::SetDay(wxDateTime_t mday)
1733 {
1734 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1735
1736 Tm tm(GetTm());
1737 tm.mday = mday;
1738 Set(tm);
1739
1740 return *this;
1741 }
1742
1743 wxDateTime& wxDateTime::SetHour(wxDateTime_t hour)
1744 {
1745 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1746
1747 Tm tm(GetTm());
1748 tm.hour = hour;
1749 Set(tm);
1750
1751 return *this;
1752 }
1753
1754 wxDateTime& wxDateTime::SetMinute(wxDateTime_t min)
1755 {
1756 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1757
1758 Tm tm(GetTm());
1759 tm.min = min;
1760 Set(tm);
1761
1762 return *this;
1763 }
1764
1765 wxDateTime& wxDateTime::SetSecond(wxDateTime_t sec)
1766 {
1767 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1768
1769 Tm tm(GetTm());
1770 tm.sec = sec;
1771 Set(tm);
1772
1773 return *this;
1774 }
1775
1776 wxDateTime& wxDateTime::SetMillisecond(wxDateTime_t millisecond)
1777 {
1778 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1779
1780 // we don't need to use GetTm() for this one
1781 m_time -= m_time % 1000l;
1782 m_time += millisecond;
1783
1784 return *this;
1785 }
1786
1787 // ----------------------------------------------------------------------------
1788 // wxDateTime arithmetics
1789 // ----------------------------------------------------------------------------
1790
1791 wxDateTime& wxDateTime::Add(const wxDateSpan& diff)
1792 {
1793 Tm tm(GetTm());
1794
1795 tm.year += diff.GetYears();
1796 tm.AddMonths(diff.GetMonths());
1797
1798 // check that the resulting date is valid
1799 if ( tm.mday > GetNumOfDaysInMonth(tm.year, tm.mon) )
1800 {
1801 // We suppose that when adding one month to Jan 31 we want to get Feb
1802 // 28 (or 29), i.e. adding a month to the last day of the month should
1803 // give the last day of the next month which is quite logical.
1804 //
1805 // Unfortunately, there is no logic way to understand what should
1806 // Jan 30 + 1 month be - Feb 28 too or Feb 27 (assuming non leap year)?
1807 // We make it Feb 28 (last day too), but it is highly questionable.
1808 tm.mday = GetNumOfDaysInMonth(tm.year, tm.mon);
1809 }
1810
1811 tm.AddDays(diff.GetTotalDays());
1812
1813 Set(tm);
1814
1815 wxASSERT_MSG( IsSameTime(tm),
1816 _T("Add(wxDateSpan) shouldn't modify time") );
1817
1818 return *this;
1819 }
1820
1821 // ----------------------------------------------------------------------------
1822 // Weekday and monthday stuff
1823 // ----------------------------------------------------------------------------
1824
1825 // convert Sun, Mon, ..., Sat into 6, 0, ..., 5
1826 static inline int ConvertWeekDayToMondayBase(int wd)
1827 {
1828 return wd == wxDateTime::Sun ? 6 : wd - 1;
1829 }
1830
1831 /* static */
1832 wxDateTime
1833 wxDateTime::SetToWeekOfYear(int year, wxDateTime_t numWeek, WeekDay wd)
1834 {
1835 wxASSERT_MSG( numWeek > 0,
1836 _T("invalid week number: weeks are counted from 1") );
1837
1838 // Jan 4 always lies in the 1st week of the year
1839 wxDateTime dt(4, Jan, year);
1840 dt.SetToWeekDayInSameWeek(wd);
1841 dt += wxDateSpan::Weeks(numWeek - 1);
1842
1843 return dt;
1844 }
1845
1846 #if WXWIN_COMPATIBILITY_2_6
1847 // use a separate function to avoid warnings about using deprecated
1848 // SetToTheWeek in GetWeek below
1849 static wxDateTime
1850 SetToTheWeek(int year,
1851 wxDateTime::wxDateTime_t numWeek,
1852 wxDateTime::WeekDay weekday,
1853 wxDateTime::WeekFlags flags)
1854 {
1855 // Jan 4 always lies in the 1st week of the year
1856 wxDateTime dt(4, wxDateTime::Jan, year);
1857 dt.SetToWeekDayInSameWeek(weekday, flags);
1858 dt += wxDateSpan::Weeks(numWeek - 1);
1859
1860 return dt;
1861 }
1862
1863 bool wxDateTime::SetToTheWeek(wxDateTime_t numWeek,
1864 WeekDay weekday,
1865 WeekFlags flags)
1866 {
1867 int year = GetYear();
1868 *this = ::SetToTheWeek(year, numWeek, weekday, flags);
1869 if ( GetYear() != year )
1870 {
1871 // oops... numWeek was too big
1872 return false;
1873 }
1874
1875 return true;
1876 }
1877
1878 wxDateTime wxDateTime::GetWeek(wxDateTime_t numWeek,
1879 WeekDay weekday,
1880 WeekFlags flags) const
1881 {
1882 return ::SetToTheWeek(GetYear(), numWeek, weekday, flags);
1883 }
1884 #endif // WXWIN_COMPATIBILITY_2_6
1885
1886 wxDateTime& wxDateTime::SetToLastMonthDay(Month month,
1887 int year)
1888 {
1889 // take the current month/year if none specified
1890 if ( year == Inv_Year )
1891 year = GetYear();
1892 if ( month == Inv_Month )
1893 month = GetMonth();
1894
1895 return Set(GetNumOfDaysInMonth(year, month), month, year);
1896 }
1897
1898 wxDateTime& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday, WeekFlags flags)
1899 {
1900 wxDATETIME_CHECK( weekday != Inv_WeekDay, _T("invalid weekday") );
1901
1902 int wdayDst = weekday,
1903 wdayThis = GetWeekDay();
1904 if ( wdayDst == wdayThis )
1905 {
1906 // nothing to do
1907 return *this;
1908 }
1909
1910 if ( flags == Default_First )
1911 {
1912 flags = GetCountry() == USA ? Sunday_First : Monday_First;
1913 }
1914
1915 // the logic below based on comparing weekday and wdayThis works if Sun (0)
1916 // is the first day in the week, but breaks down for Monday_First case so
1917 // we adjust the week days in this case
1918 if ( flags == Monday_First )
1919 {
1920 if ( wdayThis == Sun )
1921 wdayThis += 7;
1922 if ( wdayDst == Sun )
1923 wdayDst += 7;
1924 }
1925 //else: Sunday_First, nothing to do
1926
1927 // go forward or back in time to the day we want
1928 if ( wdayDst < wdayThis )
1929 {
1930 return Subtract(wxDateSpan::Days(wdayThis - wdayDst));
1931 }
1932 else // weekday > wdayThis
1933 {
1934 return Add(wxDateSpan::Days(wdayDst - wdayThis));
1935 }
1936 }
1937
1938 wxDateTime& wxDateTime::SetToNextWeekDay(WeekDay weekday)
1939 {
1940 wxDATETIME_CHECK( weekday != Inv_WeekDay, _T("invalid weekday") );
1941
1942 int diff;
1943 WeekDay wdayThis = GetWeekDay();
1944 if ( weekday == wdayThis )
1945 {
1946 // nothing to do
1947 return *this;
1948 }
1949 else if ( weekday < wdayThis )
1950 {
1951 // need to advance a week
1952 diff = 7 - (wdayThis - weekday);
1953 }
1954 else // weekday > wdayThis
1955 {
1956 diff = weekday - wdayThis;
1957 }
1958
1959 return Add(wxDateSpan::Days(diff));
1960 }
1961
1962 wxDateTime& wxDateTime::SetToPrevWeekDay(WeekDay weekday)
1963 {
1964 wxDATETIME_CHECK( weekday != Inv_WeekDay, _T("invalid weekday") );
1965
1966 int diff;
1967 WeekDay wdayThis = GetWeekDay();
1968 if ( weekday == wdayThis )
1969 {
1970 // nothing to do
1971 return *this;
1972 }
1973 else if ( weekday > wdayThis )
1974 {
1975 // need to go to previous week
1976 diff = 7 - (weekday - wdayThis);
1977 }
1978 else // weekday < wdayThis
1979 {
1980 diff = wdayThis - weekday;
1981 }
1982
1983 return Subtract(wxDateSpan::Days(diff));
1984 }
1985
1986 bool wxDateTime::SetToWeekDay(WeekDay weekday,
1987 int n,
1988 Month month,
1989 int year)
1990 {
1991 wxCHECK_MSG( weekday != Inv_WeekDay, false, _T("invalid weekday") );
1992
1993 // we don't check explicitly that -5 <= n <= 5 because we will return false
1994 // anyhow in such case - but may be should still give an assert for it?
1995
1996 // take the current month/year if none specified
1997 ReplaceDefaultYearMonthWithCurrent(&year, &month);
1998
1999 wxDateTime dt;
2000
2001 // TODO this probably could be optimised somehow...
2002
2003 if ( n > 0 )
2004 {
2005 // get the first day of the month
2006 dt.Set(1, month, year);
2007
2008 // get its wday
2009 WeekDay wdayFirst = dt.GetWeekDay();
2010
2011 // go to the first weekday of the month
2012 int diff = weekday - wdayFirst;
2013 if ( diff < 0 )
2014 diff += 7;
2015
2016 // add advance n-1 weeks more
2017 diff += 7*(n - 1);
2018
2019 dt += wxDateSpan::Days(diff);
2020 }
2021 else // count from the end of the month
2022 {
2023 // get the last day of the month
2024 dt.SetToLastMonthDay(month, year);
2025
2026 // get its wday
2027 WeekDay wdayLast = dt.GetWeekDay();
2028
2029 // go to the last weekday of the month
2030 int diff = wdayLast - weekday;
2031 if ( diff < 0 )
2032 diff += 7;
2033
2034 // and rewind n-1 weeks from there
2035 diff += 7*(-n - 1);
2036
2037 dt -= wxDateSpan::Days(diff);
2038 }
2039
2040 // check that it is still in the same month
2041 if ( dt.GetMonth() == month )
2042 {
2043 *this = dt;
2044
2045 return true;
2046 }
2047 else
2048 {
2049 // no such day in this month
2050 return false;
2051 }
2052 }
2053
2054 static inline
2055 wxDateTime::wxDateTime_t GetDayOfYearFromTm(const wxDateTime::Tm& tm)
2056 {
2057 return (wxDateTime::wxDateTime_t)(gs_cumulatedDays[wxDateTime::IsLeapYear(tm.year)][tm.mon] + tm.mday);
2058 }
2059
2060 wxDateTime::wxDateTime_t wxDateTime::GetDayOfYear(const TimeZone& tz) const
2061 {
2062 return GetDayOfYearFromTm(GetTm(tz));
2063 }
2064
2065 wxDateTime::wxDateTime_t
2066 wxDateTime::GetWeekOfYear(wxDateTime::WeekFlags flags, const TimeZone& tz) const
2067 {
2068 if ( flags == Default_First )
2069 {
2070 flags = GetCountry() == USA ? Sunday_First : Monday_First;
2071 }
2072
2073 Tm tm(GetTm(tz));
2074 wxDateTime_t nDayInYear = GetDayOfYearFromTm(tm);
2075
2076 int wdTarget = GetWeekDay(tz);
2077 int wdYearStart = wxDateTime(1, Jan, GetYear()).GetWeekDay();
2078 int week;
2079 if ( flags == Sunday_First )
2080 {
2081 // FIXME: First week is not calculated correctly.
2082 week = (nDayInYear - wdTarget + 7) / 7;
2083 if ( wdYearStart == Wed || wdYearStart == Thu )
2084 week++;
2085 }
2086 else // week starts with monday
2087 {
2088 // adjust the weekdays to non-US style.
2089 wdYearStart = ConvertWeekDayToMondayBase(wdYearStart);
2090 wdTarget = ConvertWeekDayToMondayBase(wdTarget);
2091
2092 // quoting from http://www.cl.cam.ac.uk/~mgk25/iso-time.html:
2093 //
2094 // Week 01 of a year is per definition the first week that has the
2095 // Thursday in this year, which is equivalent to the week that
2096 // contains the fourth day of January. In other words, the first
2097 // week of a new year is the week that has the majority of its
2098 // days in the new year. Week 01 might also contain days from the
2099 // previous year and the week before week 01 of a year is the last
2100 // week (52 or 53) of the previous year even if it contains days
2101 // from the new year. A week starts with Monday (day 1) and ends
2102 // with Sunday (day 7).
2103 //
2104
2105 // if Jan 1 is Thursday or less, it is in the first week of this year
2106 if ( wdYearStart < 4 )
2107 {
2108 // count the number of entire weeks between Jan 1 and this date
2109 week = (nDayInYear + wdYearStart + 6 - wdTarget)/7;
2110
2111 // be careful to check for overflow in the next year
2112 if ( week == 53 && tm.mday - wdTarget > 28 )
2113 week = 1;
2114 }
2115 else // Jan 1 is in the last week of the previous year
2116 {
2117 // check if we happen to be at the last week of previous year:
2118 if ( tm.mon == Jan && tm.mday < 8 - wdYearStart )
2119 week = wxDateTime(31, Dec, GetYear()-1).GetWeekOfYear();
2120 else
2121 week = (nDayInYear + wdYearStart - 1 - wdTarget)/7;
2122 }
2123 }
2124
2125 return (wxDateTime::wxDateTime_t)week;
2126 }
2127
2128 wxDateTime::wxDateTime_t wxDateTime::GetWeekOfMonth(wxDateTime::WeekFlags flags,
2129 const TimeZone& tz) const
2130 {
2131 Tm tm = GetTm(tz);
2132 wxDateTime dtMonthStart = wxDateTime(1, tm.mon, tm.year);
2133 int nWeek = GetWeekOfYear(flags) - dtMonthStart.GetWeekOfYear(flags) + 1;
2134 if ( nWeek < 0 )
2135 {
2136 // this may happen for January when Jan, 1 is the last week of the
2137 // previous year
2138 nWeek += IsLeapYear(tm.year - 1) ? 53 : 52;
2139 }
2140
2141 return (wxDateTime::wxDateTime_t)nWeek;
2142 }
2143
2144 wxDateTime& wxDateTime::SetToYearDay(wxDateTime::wxDateTime_t yday)
2145 {
2146 int year = GetYear();
2147 wxDATETIME_CHECK( (0 < yday) && (yday <= GetNumberOfDays(year)),
2148 _T("invalid year day") );
2149
2150 bool isLeap = IsLeapYear(year);
2151 for ( Month mon = Jan; mon < Inv_Month; wxNextMonth(mon) )
2152 {
2153 // for Dec, we can't compare with gs_cumulatedDays[mon + 1], but we
2154 // don't need it neither - because of the CHECK above we know that
2155 // yday lies in December then
2156 if ( (mon == Dec) || (yday <= gs_cumulatedDays[isLeap][mon + 1]) )
2157 {
2158 Set((wxDateTime::wxDateTime_t)(yday - gs_cumulatedDays[isLeap][mon]), mon, year);
2159
2160 break;
2161 }
2162 }
2163
2164 return *this;
2165 }
2166
2167 // ----------------------------------------------------------------------------
2168 // Julian day number conversion and related stuff
2169 // ----------------------------------------------------------------------------
2170
2171 double wxDateTime::GetJulianDayNumber() const
2172 {
2173 return m_time.ToDouble() / MILLISECONDS_PER_DAY + EPOCH_JDN + 0.5;
2174 }
2175
2176 double wxDateTime::GetRataDie() const
2177 {
2178 // March 1 of the year 0 is Rata Die day -306 and JDN 1721119.5
2179 return GetJulianDayNumber() - 1721119.5 - 306;
2180 }
2181
2182 // ----------------------------------------------------------------------------
2183 // timezone and DST stuff
2184 // ----------------------------------------------------------------------------
2185
2186 int wxDateTime::IsDST(wxDateTime::Country country) const
2187 {
2188 wxCHECK_MSG( country == Country_Default, -1,
2189 _T("country support not implemented") );
2190
2191 // use the C RTL for the dates in the standard range
2192 time_t timet = GetTicks();
2193 if ( timet != (time_t)-1 )
2194 {
2195 struct tm tmstruct;
2196 tm *tm = wxLocaltime_r(&timet, &tmstruct);
2197
2198 wxCHECK_MSG( tm, -1, _T("wxLocaltime_r() failed") );
2199
2200 return tm->tm_isdst;
2201 }
2202 else
2203 {
2204 int year = GetYear();
2205
2206 if ( !IsDSTApplicable(year, country) )
2207 {
2208 // no DST time in this year in this country
2209 return -1;
2210 }
2211
2212 return IsBetween(GetBeginDST(year, country), GetEndDST(year, country));
2213 }
2214 }
2215
2216 wxDateTime& wxDateTime::MakeTimezone(const TimeZone& tz, bool noDST)
2217 {
2218 long secDiff = GetTimeZone() + tz.GetOffset();
2219
2220 // we need to know whether DST is or not in effect for this date unless
2221 // the test disabled by the caller
2222 if ( !noDST && (IsDST() == 1) )
2223 {
2224 // FIXME we assume that the DST is always shifted by 1 hour
2225 secDiff -= 3600;
2226 }
2227
2228 return Add(wxTimeSpan::Seconds(secDiff));
2229 }
2230
2231 wxDateTime& wxDateTime::MakeFromTimezone(const TimeZone& tz, bool noDST)
2232 {
2233 long secDiff = GetTimeZone() + tz.GetOffset();
2234
2235 // we need to know whether DST is or not in effect for this date unless
2236 // the test disabled by the caller
2237 if ( !noDST && (IsDST() == 1) )
2238 {
2239 // FIXME we assume that the DST is always shifted by 1 hour
2240 secDiff -= 3600;
2241 }
2242
2243 return Subtract(wxTimeSpan::Seconds(secDiff));
2244 }
2245
2246 // ----------------------------------------------------------------------------
2247 // wxDateTime to/from text representations
2248 // ----------------------------------------------------------------------------
2249
2250 wxString wxDateTime::Format(const wxChar *format, const TimeZone& tz) const
2251 {
2252 wxCHECK_MSG( format, wxEmptyString, _T("NULL format in wxDateTime::Format") );
2253
2254 time_t time = GetTicks();
2255
2256 // we have to use our own implementation if the date is out of range of
2257 // strftime() or if we use non standard specificators
2258 #ifdef HAVE_STRFTIME
2259 if ( (time != (time_t)-1) && !wxStrstr(format, _T("%l")) )
2260 {
2261 // use strftime()
2262 struct tm tmstruct;
2263 struct tm *tm;
2264 if ( tz.GetOffset() == -GetTimeZone() )
2265 {
2266 // we are working with local time
2267 tm = wxLocaltime_r(&time, &tmstruct);
2268
2269 // should never happen
2270 wxCHECK_MSG( tm, wxEmptyString, _T("wxLocaltime_r() failed") );
2271 }
2272 else
2273 {
2274 time += (int)tz.GetOffset();
2275
2276 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
2277 int time2 = (int) time;
2278 if ( time2 >= 0 )
2279 #else
2280 if ( time >= 0 )
2281 #endif
2282 {
2283 tm = wxGmtime_r(&time, &tmstruct);
2284
2285 // should never happen
2286 wxCHECK_MSG( tm, wxEmptyString, _T("wxGmtime_r() failed") );
2287 }
2288 else
2289 {
2290 tm = (struct tm *)NULL;
2291 }
2292 }
2293
2294 if ( tm )
2295 {
2296 return CallStrftime(format, tm);
2297 }
2298 }
2299 //else: use generic code below
2300 #endif // HAVE_STRFTIME
2301
2302 // we only parse ANSI C format specifications here, no POSIX 2
2303 // complications, no GNU extensions but we do add support for a "%l" format
2304 // specifier allowing to get the number of milliseconds
2305 Tm tm = GetTm(tz);
2306
2307 // used for calls to strftime() when we only deal with time
2308 struct tm tmTimeOnly;
2309 tmTimeOnly.tm_hour = tm.hour;
2310 tmTimeOnly.tm_min = tm.min;
2311 tmTimeOnly.tm_sec = tm.sec;
2312 tmTimeOnly.tm_wday = 0;
2313 tmTimeOnly.tm_yday = 0;
2314 tmTimeOnly.tm_mday = 1; // any date will do
2315 tmTimeOnly.tm_mon = 0;
2316 tmTimeOnly.tm_year = 76;
2317 tmTimeOnly.tm_isdst = 0; // no DST, we adjust for tz ourselves
2318
2319 wxString tmp, res, fmt;
2320 for ( const wxChar *p = format; *p; p++ )
2321 {
2322 if ( *p != _T('%') )
2323 {
2324 // copy as is
2325 res += *p;
2326
2327 continue;
2328 }
2329
2330 // set the default format
2331 switch ( *++p )
2332 {
2333 case _T('Y'): // year has 4 digits
2334 fmt = _T("%04d");
2335 break;
2336
2337 case _T('j'): // day of year has 3 digits
2338 case _T('l'): // milliseconds have 3 digits
2339 fmt = _T("%03d");
2340 break;
2341
2342 case _T('w'): // week day as number has only one
2343 fmt = _T("%d");
2344 break;
2345
2346 default:
2347 // it's either another valid format specifier in which case
2348 // the format is "%02d" (for all the rest) or we have the
2349 // field width preceding the format in which case it will
2350 // override the default format anyhow
2351 fmt = _T("%02d");
2352 }
2353
2354 bool restart = true;
2355 while ( restart )
2356 {
2357 restart = false;
2358
2359 // start of the format specification
2360 switch ( *p )
2361 {
2362 case _T('a'): // a weekday name
2363 case _T('A'):
2364 // second parameter should be true for abbreviated names
2365 res += GetWeekDayName(tm.GetWeekDay(),
2366 *p == _T('a') ? Name_Abbr : Name_Full);
2367 break;
2368
2369 case _T('b'): // a month name
2370 case _T('B'):
2371 res += GetMonthName(tm.mon,
2372 *p == _T('b') ? Name_Abbr : Name_Full);
2373 break;
2374
2375 case _T('c'): // locale default date and time representation
2376 case _T('x'): // locale default date representation
2377 #ifdef HAVE_STRFTIME
2378 //
2379 // the problem: there is no way to know what do these format
2380 // specifications correspond to for the current locale.
2381 //
2382 // the solution: use a hack and still use strftime(): first
2383 // find the YEAR which is a year in the strftime() range (1970
2384 // - 2038) whose Jan 1 falls on the same week day as the Jan 1
2385 // of the real year. Then make a copy of the format and
2386 // replace all occurrences of YEAR in it with some unique
2387 // string not appearing anywhere else in it, then use
2388 // strftime() to format the date in year YEAR and then replace
2389 // YEAR back by the real year and the unique replacement
2390 // string back with YEAR. Notice that "all occurrences of YEAR"
2391 // means all occurrences of 4 digit as well as 2 digit form!
2392 //
2393 // the bugs: we assume that neither of %c nor %x contains any
2394 // fields which may change between the YEAR and real year. For
2395 // example, the week number (%U, %W) and the day number (%j)
2396 // will change if one of these years is leap and the other one
2397 // is not!
2398 {
2399 // find the YEAR: normally, for any year X, Jan 1 or the
2400 // year X + 28 is the same weekday as Jan 1 of X (because
2401 // the weekday advances by 1 for each normal X and by 2
2402 // for each leap X, hence by 5 every 4 years or by 35
2403 // which is 0 mod 7 every 28 years) but this rule breaks
2404 // down if there are years between X and Y which are
2405 // divisible by 4 but not leap (i.e. divisible by 100 but
2406 // not 400), hence the correction.
2407
2408 int yearReal = GetYear(tz);
2409 int mod28 = yearReal % 28;
2410
2411 // be careful to not go too far - we risk to leave the
2412 // supported range
2413 int year;
2414 if ( mod28 < 10 )
2415 {
2416 year = 1988 + mod28; // 1988 == 0 (mod 28)
2417 }
2418 else
2419 {
2420 year = 1970 + mod28 - 10; // 1970 == 10 (mod 28)
2421 }
2422
2423 int nCentury = year / 100,
2424 nCenturyReal = yearReal / 100;
2425
2426 // need to adjust for the years divisble by 400 which are
2427 // not leap but are counted like leap ones if we just take
2428 // the number of centuries in between for nLostWeekDays
2429 int nLostWeekDays = (nCentury - nCenturyReal) -
2430 (nCentury / 4 - nCenturyReal / 4);
2431
2432 // we have to gain back the "lost" weekdays: note that the
2433 // effect of this loop is to not do anything to
2434 // nLostWeekDays (which we won't use any more), but to
2435 // (indirectly) set the year correctly
2436 while ( (nLostWeekDays % 7) != 0 )
2437 {
2438 nLostWeekDays += year++ % 4 ? 1 : 2;
2439 }
2440
2441 // Keep year below 2000 so the 2digit year number
2442 // can never match the month or day of the month
2443 if (year>=2000) year-=28;
2444 // at any rate, we couldn't go further than 1988 + 9 + 28!
2445 wxASSERT_MSG( year < 2030,
2446 _T("logic error in wxDateTime::Format") );
2447
2448 wxString strYear, strYear2;
2449 strYear.Printf(_T("%d"), year);
2450 strYear2.Printf(_T("%d"), year % 100);
2451
2452 // find four strings not occurring in format (this is surely
2453 // not the optimal way of doing it... improvements welcome!)
2454 wxString fmt2 = format;
2455 wxString replacement,replacement2,replacement3,replacement4;
2456 for (int rnr=1; rnr<5 ; rnr++)
2457 {
2458 wxString r = (wxChar)-rnr;
2459 while ( fmt2.Find(r) != wxNOT_FOUND )
2460 {
2461 r << (wxChar)-rnr;
2462 }
2463
2464 switch (rnr)
2465 {
2466 case 1: replacement=r; break;
2467 case 2: replacement2=r; break;
2468 case 3: replacement3=r; break;
2469 case 4: replacement4=r; break;
2470 }
2471 }
2472 // replace all occurrences of year with it
2473 bool wasReplaced = fmt2.Replace(strYear, replacement) > 0;
2474 // evaluation order ensures we always attempt the replacement.
2475 wasReplaced = (fmt2.Replace(strYear2, replacement2) > 0) | wasReplaced ;
2476
2477 // use strftime() to format the same date but in supported
2478 // year
2479 //
2480 // NB: we assume that strftime() doesn't check for the
2481 // date validity and will happily format the date
2482 // corresponding to Feb 29 of a non leap year (which
2483 // may happen if yearReal was leap and year is not)
2484 struct tm tmAdjusted;
2485 InitTm(tmAdjusted);
2486 tmAdjusted.tm_hour = tm.hour;
2487 tmAdjusted.tm_min = tm.min;
2488 tmAdjusted.tm_sec = tm.sec;
2489 tmAdjusted.tm_wday = tm.GetWeekDay();
2490 tmAdjusted.tm_yday = GetDayOfYear();
2491 tmAdjusted.tm_mday = tm.mday;
2492 tmAdjusted.tm_mon = tm.mon;
2493 tmAdjusted.tm_year = year - 1900;
2494 tmAdjusted.tm_isdst = 0; // no DST, already adjusted
2495 wxString str = CallStrftime(*p == _T('c') ? _T("%c")
2496 : _T("%x"),
2497 &tmAdjusted);
2498
2499 // now replace the occurrence of 1999 with the real year
2500 // we do this in two stages to stop the 2 digit year
2501 // matching any substring of the 4 digit year.
2502 // Any day,month hours and minutes components should be safe due
2503 // to ensuring the range of the years.
2504 wxString strYearReal, strYearReal2;
2505 strYearReal.Printf(_T("%04d"), yearReal);
2506 strYearReal2.Printf(_T("%02d"), yearReal % 100);
2507 str.Replace(strYear, replacement3);
2508 str.Replace(strYear2,replacement4);
2509 str.Replace(replacement3, strYearReal);
2510 str.Replace(replacement4, strYearReal2);
2511
2512 // and replace back all occurrences of replacement string
2513 if ( wasReplaced )
2514 {
2515 str.Replace(replacement2, strYear2);
2516 str.Replace(replacement, strYear);
2517 }
2518
2519 res += str;
2520 }
2521 #else // !HAVE_STRFTIME
2522 // Use "%m/%d/%y %H:%M:%S" format instead
2523 res += wxString::Format(wxT("%02d/%02d/%04d %02d:%02d:%02d"),
2524 tm.mon+1,tm.mday, tm.year, tm.hour, tm.min, tm.sec);
2525 #endif // HAVE_STRFTIME/!HAVE_STRFTIME
2526 break;
2527
2528 case _T('d'): // day of a month (01-31)
2529 res += wxString::Format(fmt, tm.mday);
2530 break;
2531
2532 case _T('H'): // hour in 24h format (00-23)
2533 res += wxString::Format(fmt, tm.hour);
2534 break;
2535
2536 case _T('I'): // hour in 12h format (01-12)
2537 {
2538 // 24h -> 12h, 0h -> 12h too
2539 int hour12 = tm.hour > 12 ? tm.hour - 12
2540 : tm.hour ? tm.hour : 12;
2541 res += wxString::Format(fmt, hour12);
2542 }
2543 break;
2544
2545 case _T('j'): // day of the year
2546 res += wxString::Format(fmt, GetDayOfYear(tz));
2547 break;
2548
2549 case _T('l'): // milliseconds (NOT STANDARD)
2550 res += wxString::Format(fmt, GetMillisecond(tz));
2551 break;
2552
2553 case _T('m'): // month as a number (01-12)
2554 res += wxString::Format(fmt, tm.mon + 1);
2555 break;
2556
2557 case _T('M'): // minute as a decimal number (00-59)
2558 res += wxString::Format(fmt, tm.min);
2559 break;
2560
2561 case _T('p'): // AM or PM string
2562 #ifdef HAVE_STRFTIME
2563 res += CallStrftime(_T("%p"), &tmTimeOnly);
2564 #else // !HAVE_STRFTIME
2565 res += (tmTimeOnly.tm_hour > 12) ? wxT("pm") : wxT("am");
2566 #endif // HAVE_STRFTIME/!HAVE_STRFTIME
2567 break;
2568
2569 case _T('S'): // second as a decimal number (00-61)
2570 res += wxString::Format(fmt, tm.sec);
2571 break;
2572
2573 case _T('U'): // week number in the year (Sunday 1st week day)
2574 res += wxString::Format(fmt, GetWeekOfYear(Sunday_First, tz));
2575 break;
2576
2577 case _T('W'): // week number in the year (Monday 1st week day)
2578 res += wxString::Format(fmt, GetWeekOfYear(Monday_First, tz));
2579 break;
2580
2581 case _T('w'): // weekday as a number (0-6), Sunday = 0
2582 res += wxString::Format(fmt, tm.GetWeekDay());
2583 break;
2584
2585 // case _T('x'): -- handled with "%c"
2586
2587 case _T('X'): // locale default time representation
2588 // just use strftime() to format the time for us
2589 #ifdef HAVE_STRFTIME
2590 res += CallStrftime(_T("%X"), &tmTimeOnly);
2591 #else // !HAVE_STRFTIME
2592 res += wxString::Format(wxT("%02d:%02d:%02d"),tm.hour, tm.min, tm.sec);
2593 #endif // HAVE_STRFTIME/!HAVE_STRFTIME
2594 break;
2595
2596 case _T('y'): // year without century (00-99)
2597 res += wxString::Format(fmt, tm.year % 100);
2598 break;
2599
2600 case _T('Y'): // year with century
2601 res += wxString::Format(fmt, tm.year);
2602 break;
2603
2604 case _T('Z'): // timezone name
2605 #ifdef HAVE_STRFTIME
2606 res += CallStrftime(_T("%Z"), &tmTimeOnly);
2607 #endif
2608 break;
2609
2610 default:
2611 // is it the format width?
2612 fmt.Empty();
2613 while ( *p == _T('-') || *p == _T('+') ||
2614 *p == _T(' ') || wxIsdigit(*p) )
2615 {
2616 fmt += *p;
2617 }
2618
2619 if ( !fmt.empty() )
2620 {
2621 // we've only got the flags and width so far in fmt
2622 fmt.Prepend(_T('%'));
2623 fmt.Append(_T('d'));
2624
2625 restart = true;
2626
2627 break;
2628 }
2629
2630 // no, it wasn't the width
2631 wxFAIL_MSG(_T("unknown format specificator"));
2632
2633 // fall through and just copy it nevertheless
2634
2635 case _T('%'): // a percent sign
2636 res += *p;
2637 break;
2638
2639 case 0: // the end of string
2640 wxFAIL_MSG(_T("missing format at the end of string"));
2641
2642 // just put the '%' which was the last char in format
2643 res += _T('%');
2644 break;
2645 }
2646 }
2647 }
2648
2649 return res;
2650 }
2651
2652 // this function parses a string in (strict) RFC 822 format: see the section 5
2653 // of the RFC for the detailed description, but briefly it's something of the
2654 // form "Sat, 18 Dec 1999 00:48:30 +0100"
2655 //
2656 // this function is "strict" by design - it must reject anything except true
2657 // RFC822 time specs.
2658 //
2659 // TODO a great candidate for using reg exps
2660 const wxChar *wxDateTime::ParseRfc822Date(const wxChar* date)
2661 {
2662 wxCHECK_MSG( date, (wxChar *)NULL, _T("NULL pointer in wxDateTime::Parse") );
2663
2664 const wxChar *p = date;
2665 const wxChar *comma = wxStrchr(p, _T(','));
2666 if ( comma )
2667 {
2668 // the part before comma is the weekday
2669
2670 // skip it for now - we don't use but might check that it really
2671 // corresponds to the specfied date
2672 p = comma + 1;
2673
2674 if ( *p != _T(' ') )
2675 {
2676 wxLogDebug(_T("no space after weekday in RFC822 time spec"));
2677
2678 return (wxChar *)NULL;
2679 }
2680
2681 p++; // skip space
2682 }
2683
2684 // the following 1 or 2 digits are the day number
2685 if ( !wxIsdigit(*p) )
2686 {
2687 wxLogDebug(_T("day number expected in RFC822 time spec, none found"));
2688
2689 return (wxChar *)NULL;
2690 }
2691
2692 wxDateTime_t day = (wxDateTime_t)(*p++ - _T('0'));
2693 if ( wxIsdigit(*p) )
2694 {
2695 day *= 10;
2696 day = (wxDateTime_t)(day + (*p++ - _T('0')));
2697 }
2698
2699 if ( *p++ != _T(' ') )
2700 {
2701 return (wxChar *)NULL;
2702 }
2703
2704 // the following 3 letters specify the month
2705 wxString monName(p, 3);
2706 Month mon;
2707 if ( monName == _T("Jan") )
2708 mon = Jan;
2709 else if ( monName == _T("Feb") )
2710 mon = Feb;
2711 else if ( monName == _T("Mar") )
2712 mon = Mar;
2713 else if ( monName == _T("Apr") )
2714 mon = Apr;
2715 else if ( monName == _T("May") )
2716 mon = May;
2717 else if ( monName == _T("Jun") )
2718 mon = Jun;
2719 else if ( monName == _T("Jul") )
2720 mon = Jul;
2721 else if ( monName == _T("Aug") )
2722 mon = Aug;
2723 else if ( monName == _T("Sep") )
2724 mon = Sep;
2725 else if ( monName == _T("Oct") )
2726 mon = Oct;
2727 else if ( monName == _T("Nov") )
2728 mon = Nov;
2729 else if ( monName == _T("Dec") )
2730 mon = Dec;
2731 else
2732 {
2733 wxLogDebug(_T("Invalid RFC 822 month name '%s'"), monName.c_str());
2734
2735 return (wxChar *)NULL;
2736 }
2737
2738 p += 3;
2739
2740 if ( *p++ != _T(' ') )
2741 {
2742 return (wxChar *)NULL;
2743 }
2744
2745 // next is the year
2746 if ( !wxIsdigit(*p) )
2747 {
2748 // no year?
2749 return (wxChar *)NULL;
2750 }
2751
2752 int year = *p++ - _T('0');
2753
2754 if ( !wxIsdigit(*p) )
2755 {
2756 // should have at least 2 digits in the year
2757 return (wxChar *)NULL;
2758 }
2759
2760 year *= 10;
2761 year += *p++ - _T('0');
2762
2763 // is it a 2 digit year (as per original RFC 822) or a 4 digit one?
2764 if ( wxIsdigit(*p) )
2765 {
2766 year *= 10;
2767 year += *p++ - _T('0');
2768
2769 if ( !wxIsdigit(*p) )
2770 {
2771 // no 3 digit years please
2772 return (wxChar *)NULL;
2773 }
2774
2775 year *= 10;
2776 year += *p++ - _T('0');
2777 }
2778
2779 if ( *p++ != _T(' ') )
2780 {
2781 return (wxChar *)NULL;
2782 }
2783
2784 // time is in the format hh:mm:ss and seconds are optional
2785 if ( !wxIsdigit(*p) )
2786 {
2787 return (wxChar *)NULL;
2788 }
2789
2790 wxDateTime_t hour = (wxDateTime_t)(*p++ - _T('0'));
2791
2792 if ( !wxIsdigit(*p) )
2793 {
2794 return (wxChar *)NULL;
2795 }
2796
2797 hour *= 10;
2798 hour = (wxDateTime_t)(hour + (*p++ - _T('0')));
2799
2800 if ( *p++ != _T(':') )
2801 {
2802 return (wxChar *)NULL;
2803 }
2804
2805 if ( !wxIsdigit(*p) )
2806 {
2807 return (wxChar *)NULL;
2808 }
2809
2810 wxDateTime_t min = (wxDateTime_t)(*p++ - _T('0'));
2811
2812 if ( !wxIsdigit(*p) )
2813 {
2814 return (wxChar *)NULL;
2815 }
2816
2817 min *= 10;
2818 min = (wxDateTime_t)(min + *p++ - _T('0'));
2819
2820 wxDateTime_t sec = 0;
2821 if ( *p++ == _T(':') )
2822 {
2823 if ( !wxIsdigit(*p) )
2824 {
2825 return (wxChar *)NULL;
2826 }
2827
2828 sec = (wxDateTime_t)(*p++ - _T('0'));
2829
2830 if ( !wxIsdigit(*p) )
2831 {
2832 return (wxChar *)NULL;
2833 }
2834
2835 sec *= 10;
2836 sec = (wxDateTime_t)(sec + *p++ - _T('0'));
2837 }
2838
2839 if ( *p++ != _T(' ') )
2840 {
2841 return (wxChar *)NULL;
2842 }
2843
2844 // and now the interesting part: the timezone
2845 int offset wxDUMMY_INITIALIZE(0);
2846 if ( *p == _T('-') || *p == _T('+') )
2847 {
2848 // the explicit offset given: it has the form of hhmm
2849 bool plus = *p++ == _T('+');
2850
2851 if ( !wxIsdigit(*p) || !wxIsdigit(*(p + 1)) )
2852 {
2853 return (wxChar *)NULL;
2854 }
2855
2856 // hours
2857 offset = MIN_PER_HOUR*(10*(*p - _T('0')) + (*(p + 1) - _T('0')));
2858
2859 p += 2;
2860
2861 if ( !wxIsdigit(*p) || !wxIsdigit(*(p + 1)) )
2862 {
2863 return (wxChar *)NULL;
2864 }
2865
2866 // minutes
2867 offset += 10*(*p - _T('0')) + (*(p + 1) - _T('0'));
2868
2869 if ( !plus )
2870 {
2871 offset = -offset;
2872 }
2873
2874 p += 2;
2875 }
2876 else
2877 {
2878 // the symbolic timezone given: may be either military timezone or one
2879 // of standard abbreviations
2880 if ( !*(p + 1) )
2881 {
2882 // military: Z = UTC, J unused, A = -1, ..., Y = +12
2883 static const int offsets[26] =
2884 {
2885 //A B C D E F G H I J K L M
2886 -1, -2, -3, -4, -5, -6, -7, -8, -9, 0, -10, -11, -12,
2887 //N O P R Q S T U V W Z Y Z
2888 +1, +2, +3, +4, +5, +6, +7, +8, +9, +10, +11, +12, 0
2889 };
2890
2891 if ( *p < _T('A') || *p > _T('Z') || *p == _T('J') )
2892 {
2893 wxLogDebug(_T("Invalid militaty timezone '%c'"), *p);
2894
2895 return (wxChar *)NULL;
2896 }
2897
2898 offset = offsets[*p++ - _T('A')];
2899 }
2900 else
2901 {
2902 // abbreviation
2903 wxString tz = p;
2904 if ( tz == _T("UT") || tz == _T("UTC") || tz == _T("GMT") )
2905 offset = 0;
2906 else if ( tz == _T("AST") )
2907 offset = AST - GMT0;
2908 else if ( tz == _T("ADT") )
2909 offset = ADT - GMT0;
2910 else if ( tz == _T("EST") )
2911 offset = EST - GMT0;
2912 else if ( tz == _T("EDT") )
2913 offset = EDT - GMT0;
2914 else if ( tz == _T("CST") )
2915 offset = CST - GMT0;
2916 else if ( tz == _T("CDT") )
2917 offset = CDT - GMT0;
2918 else if ( tz == _T("MST") )
2919 offset = MST - GMT0;
2920 else if ( tz == _T("MDT") )
2921 offset = MDT - GMT0;
2922 else if ( tz == _T("PST") )
2923 offset = PST - GMT0;
2924 else if ( tz == _T("PDT") )
2925 offset = PDT - GMT0;
2926 else
2927 {
2928 wxLogDebug(_T("Unknown RFC 822 timezone '%s'"), p);
2929
2930 return (wxChar *)NULL;
2931 }
2932
2933 p += tz.length();
2934 }
2935
2936 // make it minutes
2937 offset *= MIN_PER_HOUR;
2938 }
2939
2940 // the spec was correct, construct the date from the values we found
2941 Set(day, mon, year, hour, min, sec);
2942 MakeFromTimezone(TimeZone((wxDateTime_t)(offset*SEC_PER_MIN)));
2943
2944 return p;
2945 }
2946
2947 #ifdef __WINDOWS__
2948
2949 // returns the string containing strftime() format used for short dates in the
2950 // current locale or an empty string
2951 static wxString GetLocaleDateFormat()
2952 {
2953 wxString fmtWX;
2954
2955 // there is no setlocale() under Windows CE, so just always query the
2956 // system there
2957 #ifndef __WXWINCE__
2958 if ( strcmp(setlocale(LC_ALL, NULL), "C") != 0 )
2959 #endif
2960 {
2961 // The locale was programatically set to non-C. We assume that this was
2962 // done using wxLocale, in which case thread's current locale is also
2963 // set to correct LCID value and we can use GetLocaleInfo to determine
2964 // the correct formatting string:
2965 #ifdef __WXWINCE__
2966 LCID lcid = LOCALE_USER_DEFAULT;
2967 #else
2968 LCID lcid = GetThreadLocale();
2969 #endif
2970 // according to MSDN 80 chars is max allowed for short date format
2971 wxChar fmt[81];
2972 if ( ::GetLocaleInfo(lcid, LOCALE_SSHORTDATE, fmt, WXSIZEOF(fmt)) )
2973 {
2974 wxChar chLast = _T('\0');
2975 size_t lastCount = 0;
2976 for ( const wxChar *p = fmt; /* NUL handled inside */; p++ )
2977 {
2978 if ( *p == chLast )
2979 {
2980 lastCount++;
2981 continue;
2982 }
2983
2984 switch ( *p )
2985 {
2986 // these characters come in groups, start counting them
2987 case _T('d'):
2988 case _T('M'):
2989 case _T('y'):
2990 case _T('g'):
2991 chLast = *p;
2992 lastCount = 1;
2993 break;
2994
2995 default:
2996 // first deal with any special characters we have had
2997 if ( lastCount )
2998 {
2999 switch ( chLast )
3000 {
3001 case _T('d'):
3002 switch ( lastCount )
3003 {
3004 case 1: // d
3005 case 2: // dd
3006 // these two are the same as we
3007 // don't distinguish between 1 and
3008 // 2 digits for days
3009 fmtWX += _T("%d");
3010 break;
3011
3012 case 3: // ddd
3013 fmtWX += _T("%a");
3014 break;
3015
3016 case 4: // dddd
3017 fmtWX += _T("%A");
3018 break;
3019
3020 default:
3021 wxFAIL_MSG( _T("too many 'd's") );
3022 }
3023 break;
3024
3025 case _T('M'):
3026 switch ( lastCount )
3027 {
3028 case 1: // M
3029 case 2: // MM
3030 // as for 'd' and 'dd' above
3031 fmtWX += _T("%m");
3032 break;
3033
3034 case 3:
3035 fmtWX += _T("%b");
3036 break;
3037
3038 case 4:
3039 fmtWX += _T("%B");
3040 break;
3041
3042 default:
3043 wxFAIL_MSG( _T("too many 'M's") );
3044 }
3045 break;
3046
3047 case _T('y'):
3048 switch ( lastCount )
3049 {
3050 case 1: // y
3051 case 2: // yy
3052 fmtWX += _T("%y");
3053 break;
3054
3055 case 4: // yyyy
3056 fmtWX += _T("%Y");
3057 break;
3058
3059 default:
3060 wxFAIL_MSG( _T("wrong number of 'y's") );
3061 }
3062 break;
3063
3064 case _T('g'):
3065 // strftime() doesn't have era string,
3066 // ignore this format
3067 wxASSERT_MSG( lastCount <= 2,
3068 _T("too many 'g's") );
3069 break;
3070
3071 default:
3072 wxFAIL_MSG( _T("unreachable") );
3073 }
3074
3075 chLast = _T('\0');
3076 lastCount = 0;
3077 }
3078
3079 // not a special character so must be just a separator,
3080 // treat as is
3081 if ( *p != _T('\0') )
3082 {
3083 if ( *p == _T('%') )
3084 {
3085 // this one needs to be escaped
3086 fmtWX += _T('%');
3087 }
3088
3089 fmtWX += *p;
3090 }
3091 }
3092
3093 if ( *p == _T('\0') )
3094 break;
3095 }
3096 }
3097 //else: GetLocaleInfo() failed, leave fmtDate value unchanged and
3098 // try our luck with the default formats
3099 }
3100 //else: default C locale, default formats should work
3101
3102 return fmtWX;
3103 }
3104
3105 #endif // __WINDOWS__
3106
3107 const wxChar *wxDateTime::ParseFormat(const wxChar *date,
3108 const wxChar *format,
3109 const wxDateTime& dateDef)
3110 {
3111 wxCHECK_MSG( date && format, (wxChar *)NULL,
3112 _T("NULL pointer in wxDateTime::ParseFormat()") );
3113
3114 wxString str;
3115 unsigned long num;
3116
3117 // what fields have we found?
3118 bool haveWDay = false,
3119 haveYDay = false,
3120 haveDay = false,
3121 haveMon = false,
3122 haveYear = false,
3123 haveHour = false,
3124 haveMin = false,
3125 haveSec = false;
3126
3127 bool hourIsIn12hFormat = false, // or in 24h one?
3128 isPM = false; // AM by default
3129
3130 // and the value of the items we have (init them to get rid of warnings)
3131 wxDateTime_t sec = 0,
3132 min = 0,
3133 hour = 0;
3134 WeekDay wday = Inv_WeekDay;
3135 wxDateTime_t yday = 0,
3136 mday = 0;
3137 wxDateTime::Month mon = Inv_Month;
3138 int year = 0;
3139
3140 const wxChar *input = date;
3141 for ( const wxChar *fmt = format; *fmt; fmt++ )
3142 {
3143 if ( *fmt != _T('%') )
3144 {
3145 if ( wxIsspace(*fmt) )
3146 {
3147 // a white space in the format string matches 0 or more white
3148 // spaces in the input
3149 while ( wxIsspace(*input) )
3150 {
3151 input++;
3152 }
3153 }
3154 else // !space
3155 {
3156 // any other character (not whitespace, not '%') must be
3157 // matched by itself in the input
3158 if ( *input++ != *fmt )
3159 {
3160 // no match
3161 return (wxChar *)NULL;
3162 }
3163 }
3164
3165 // done with this format char
3166 continue;
3167 }
3168
3169 // start of a format specification
3170
3171 // parse the optional width
3172 size_t width = 0;
3173 while ( wxIsdigit(*++fmt) )
3174 {
3175 width *= 10;
3176 width += *fmt - _T('0');
3177 }
3178
3179 // the default widths for the various fields
3180 if ( !width )
3181 {
3182 switch ( *fmt )
3183 {
3184 case _T('Y'): // year has 4 digits
3185 width = 4;
3186 break;
3187
3188 case _T('j'): // day of year has 3 digits
3189 case _T('l'): // milliseconds have 3 digits
3190 width = 3;
3191 break;
3192
3193 case _T('w'): // week day as number has only one
3194 width = 1;
3195 break;
3196
3197 default:
3198 // default for all other fields
3199 width = 2;
3200 }
3201 }
3202
3203 // then the format itself
3204 switch ( *fmt )
3205 {
3206 case _T('a'): // a weekday name
3207 case _T('A'):
3208 {
3209 int flag = *fmt == _T('a') ? Name_Abbr : Name_Full;
3210 wday = GetWeekDayFromName(GetAlphaToken(input), flag);
3211 if ( wday == Inv_WeekDay )
3212 {
3213 // no match
3214 return (wxChar *)NULL;
3215 }
3216 }
3217 haveWDay = true;
3218 break;
3219
3220 case _T('b'): // a month name
3221 case _T('B'):
3222 {
3223 int flag = *fmt == _T('b') ? Name_Abbr : Name_Full;
3224 mon = GetMonthFromName(GetAlphaToken(input), flag);
3225 if ( mon == Inv_Month )
3226 {
3227 // no match
3228 return (wxChar *)NULL;
3229 }
3230 }
3231 haveMon = true;
3232 break;
3233
3234 case _T('c'): // locale default date and time representation
3235 {
3236 wxDateTime dt;
3237
3238 // this is the format which corresponds to ctime() output
3239 // and strptime("%c") should parse it, so try it first
3240 static const wxChar *fmtCtime = _T("%a %b %d %H:%M:%S %Y");
3241
3242 const wxChar *result = dt.ParseFormat(input, fmtCtime);
3243 if ( !result )
3244 {
3245 result = dt.ParseFormat(input, _T("%x %X"));
3246 }
3247
3248 if ( !result )
3249 {
3250 result = dt.ParseFormat(input, _T("%X %x"));
3251 }
3252
3253 if ( !result )
3254 {
3255 // we've tried everything and still no match
3256 return (wxChar *)NULL;
3257 }
3258
3259 Tm tm = dt.GetTm();
3260
3261 haveDay = haveMon = haveYear =
3262 haveHour = haveMin = haveSec = true;
3263
3264 hour = tm.hour;
3265 min = tm.min;
3266 sec = tm.sec;
3267
3268 year = tm.year;
3269 mon = tm.mon;
3270 mday = tm.mday;
3271
3272 input = result;
3273 }
3274 break;
3275
3276 case _T('d'): // day of a month (01-31)
3277 if ( !GetNumericToken(width, input, &num) ||
3278 (num > 31) || (num < 1) )
3279 {
3280 // no match
3281 return (wxChar *)NULL;
3282 }
3283
3284 // we can't check whether the day range is correct yet, will
3285 // do it later - assume ok for now
3286 haveDay = true;
3287 mday = (wxDateTime_t)num;
3288 break;
3289
3290 case _T('H'): // hour in 24h format (00-23)
3291 if ( !GetNumericToken(width, input, &num) || (num > 23) )
3292 {
3293 // no match
3294 return (wxChar *)NULL;
3295 }
3296
3297 haveHour = true;
3298 hour = (wxDateTime_t)num;
3299 break;
3300
3301 case _T('I'): // hour in 12h format (01-12)
3302 if ( !GetNumericToken(width, input, &num) || !num || (num > 12) )
3303 {
3304 // no match
3305 return (wxChar *)NULL;
3306 }
3307
3308 haveHour = true;
3309 hourIsIn12hFormat = true;
3310 hour = (wxDateTime_t)(num % 12); // 12 should be 0
3311 break;
3312
3313 case _T('j'): // day of the year
3314 if ( !GetNumericToken(width, input, &num) || !num || (num > 366) )
3315 {
3316 // no match
3317 return (wxChar *)NULL;
3318 }
3319
3320 haveYDay = true;
3321 yday = (wxDateTime_t)num;
3322 break;
3323
3324 case _T('m'): // month as a number (01-12)
3325 if ( !GetNumericToken(width, input, &num) || !num || (num > 12) )
3326 {
3327 // no match
3328 return (wxChar *)NULL;
3329 }
3330
3331 haveMon = true;
3332 mon = (Month)(num - 1);
3333 break;
3334
3335 case _T('M'): // minute as a decimal number (00-59)
3336 if ( !GetNumericToken(width, input, &num) || (num > 59) )
3337 {
3338 // no match
3339 return (wxChar *)NULL;
3340 }
3341
3342 haveMin = true;
3343 min = (wxDateTime_t)num;
3344 break;
3345
3346 case _T('p'): // AM or PM string
3347 {
3348 wxString am, pm, token = GetAlphaToken(input);
3349
3350 GetAmPmStrings(&am, &pm);
3351 if (am.empty() && pm.empty())
3352 return (wxChar *)NULL; // no am/pm strings defined
3353 if ( token.CmpNoCase(pm) == 0 )
3354 {
3355 isPM = true;
3356 }
3357 else if ( token.CmpNoCase(am) != 0 )
3358 {
3359 // no match
3360 return (wxChar *)NULL;
3361 }
3362 }
3363 break;
3364
3365 case _T('r'): // time as %I:%M:%S %p
3366 {
3367 wxDateTime dt;
3368 input = dt.ParseFormat(input, _T("%I:%M:%S %p"));
3369 if ( !input )
3370 {
3371 // no match
3372 return (wxChar *)NULL;
3373 }
3374
3375 haveHour = haveMin = haveSec = true;
3376
3377 Tm tm = dt.GetTm();
3378 hour = tm.hour;
3379 min = tm.min;
3380 sec = tm.sec;
3381 }
3382 break;
3383
3384 case _T('R'): // time as %H:%M
3385 {
3386 wxDateTime dt;
3387 input = dt.ParseFormat(input, _T("%H:%M"));
3388 if ( !input )
3389 {
3390 // no match
3391 return (wxChar *)NULL;
3392 }
3393
3394 haveHour = haveMin = true;
3395
3396 Tm tm = dt.GetTm();
3397 hour = tm.hour;
3398 min = tm.min;
3399 }
3400 break;
3401
3402 case _T('S'): // second as a decimal number (00-61)
3403 if ( !GetNumericToken(width, input, &num) || (num > 61) )
3404 {
3405 // no match
3406 return (wxChar *)NULL;
3407 }
3408
3409 haveSec = true;
3410 sec = (wxDateTime_t)num;
3411 break;
3412
3413 case _T('T'): // time as %H:%M:%S
3414 {
3415 wxDateTime dt;
3416 input = dt.ParseFormat(input, _T("%H:%M:%S"));
3417 if ( !input )
3418 {
3419 // no match
3420 return (wxChar *)NULL;
3421 }
3422
3423 haveHour = haveMin = haveSec = true;
3424
3425 Tm tm = dt.GetTm();
3426 hour = tm.hour;
3427 min = tm.min;
3428 sec = tm.sec;
3429 }
3430 break;
3431
3432 case _T('w'): // weekday as a number (0-6), Sunday = 0
3433 if ( !GetNumericToken(width, input, &num) || (wday > 6) )
3434 {
3435 // no match
3436 return (wxChar *)NULL;
3437 }
3438
3439 haveWDay = true;
3440 wday = (WeekDay)num;
3441 break;
3442
3443 case _T('x'): // locale default date representation
3444 #ifdef HAVE_STRPTIME
3445 // try using strptime() -- it may fail even if the input is
3446 // correct but the date is out of range, so we will fall back
3447 // to our generic code anyhow
3448 {
3449 struct tm tm;
3450
3451 const wxChar *result = CallStrptime(input, "%x", &tm);
3452 if ( result )
3453 {
3454 input = result;
3455
3456 haveDay = haveMon = haveYear = true;
3457
3458 year = 1900 + tm.tm_year;
3459 mon = (Month)tm.tm_mon;
3460 mday = tm.tm_mday;
3461
3462 break;
3463 }
3464 }
3465 #endif // HAVE_STRPTIME
3466
3467 {
3468 wxDateTime dt;
3469 wxString fmtDate,
3470 fmtDateAlt;
3471
3472 #ifdef __WINDOWS__
3473 // The above doesn't work for all locales, try to query
3474 // Windows for the right way of formatting the date:
3475 fmtDate = GetLocaleDateFormat();
3476 if ( fmtDate.empty() )
3477 #endif
3478 {
3479 if ( IsWestEuropeanCountry(GetCountry()) ||
3480 GetCountry() == Russia )
3481 {
3482 fmtDate = _T("%d/%m/%y");
3483 fmtDateAlt = _T("%m/%d/%y");
3484 }
3485 else // assume USA
3486 {
3487 fmtDate = _T("%m/%d/%y");
3488 fmtDateAlt = _T("%d/%m/%y");
3489 }
3490 }
3491
3492 const wxChar *result = dt.ParseFormat(input, fmtDate);
3493
3494 if ( !result && !fmtDateAlt.empty() )
3495 {
3496 // ok, be nice and try another one
3497 result = dt.ParseFormat(input, fmtDateAlt);
3498 }
3499
3500 if ( !result )
3501 {
3502 // bad luck
3503 return (wxChar *)NULL;
3504 }
3505
3506 Tm tm = dt.GetTm();
3507
3508 haveDay = haveMon = haveYear = true;
3509
3510 year = tm.year;
3511 mon = tm.mon;
3512 mday = tm.mday;
3513
3514 input = result;
3515 }
3516
3517 break;
3518
3519 case _T('X'): // locale default time representation
3520 #ifdef HAVE_STRPTIME
3521 {
3522 // use strptime() to do it for us (FIXME !Unicode friendly)
3523 struct tm tm;
3524 input = CallStrptime(input, "%X", &tm);
3525 if ( !input )
3526 {
3527 return (wxChar *)NULL;
3528 }
3529
3530 haveHour = haveMin = haveSec = true;
3531
3532 hour = tm.tm_hour;
3533 min = tm.tm_min;
3534 sec = tm.tm_sec;
3535 }
3536 #else // !HAVE_STRPTIME
3537 // TODO under Win32 we can query the LOCALE_ITIME system
3538 // setting which says whether the default time format is
3539 // 24 or 12 hour
3540 {
3541 // try to parse what follows as "%H:%M:%S" and, if this
3542 // fails, as "%I:%M:%S %p" - this should catch the most
3543 // common cases
3544 wxDateTime dt;
3545
3546 const wxChar *result = dt.ParseFormat(input, _T("%T"));
3547 if ( !result )
3548 {
3549 result = dt.ParseFormat(input, _T("%r"));
3550 }
3551
3552 if ( !result )
3553 {
3554 // no match
3555 return (wxChar *)NULL;
3556 }
3557
3558 haveHour = haveMin = haveSec = true;
3559
3560 Tm tm = dt.GetTm();
3561 hour = tm.hour;
3562 min = tm.min;
3563 sec = tm.sec;
3564
3565 input = result;
3566 }
3567 #endif // HAVE_STRPTIME/!HAVE_STRPTIME
3568 break;
3569
3570 case _T('y'): // year without century (00-99)
3571 if ( !GetNumericToken(width, input, &num) || (num > 99) )
3572 {
3573 // no match
3574 return (wxChar *)NULL;
3575 }
3576
3577 haveYear = true;
3578
3579 // TODO should have an option for roll over date instead of
3580 // hard coding it here
3581 year = (num > 30 ? 1900 : 2000) + (wxDateTime_t)num;
3582 break;
3583
3584 case _T('Y'): // year with century
3585 if ( !GetNumericToken(width, input, &num) )
3586 {
3587 // no match
3588 return (wxChar *)NULL;
3589 }
3590
3591 haveYear = true;
3592 year = (wxDateTime_t)num;
3593 break;
3594
3595 case _T('Z'): // timezone name
3596 wxFAIL_MSG(_T("TODO"));
3597 break;
3598
3599 case _T('%'): // a percent sign
3600 if ( *input++ != _T('%') )
3601 {
3602 // no match
3603 return (wxChar *)NULL;
3604 }
3605 break;
3606
3607 case 0: // the end of string
3608 wxFAIL_MSG(_T("unexpected format end"));
3609
3610 // fall through
3611
3612 default: // not a known format spec
3613 return (wxChar *)NULL;
3614 }
3615 }
3616
3617 // format matched, try to construct a date from what we have now
3618 Tm tmDef;
3619 if ( dateDef.IsValid() )
3620 {
3621 // take this date as default
3622 tmDef = dateDef.GetTm();
3623 }
3624 else if ( IsValid() )
3625 {
3626 // if this date is valid, don't change it
3627 tmDef = GetTm();
3628 }
3629 else
3630 {
3631 // no default and this date is invalid - fall back to Today()
3632 tmDef = Today().GetTm();
3633 }
3634
3635 Tm tm = tmDef;
3636
3637 // set the date
3638 if ( haveYear )
3639 {
3640 tm.year = year;
3641 }
3642
3643 // TODO we don't check here that the values are consistent, if both year
3644 // day and month/day were found, we just ignore the year day and we
3645 // also always ignore the week day
3646 if ( haveMon && haveDay )
3647 {
3648 if ( mday > GetNumOfDaysInMonth(tm.year, mon) )
3649 {
3650 wxLogDebug(_T("bad month day in wxDateTime::ParseFormat"));
3651
3652 return (wxChar *)NULL;
3653 }
3654
3655 tm.mon = mon;
3656 tm.mday = mday;
3657 }
3658 else if ( haveYDay )
3659 {
3660 if ( yday > GetNumberOfDays(tm.year) )
3661 {
3662 wxLogDebug(_T("bad year day in wxDateTime::ParseFormat"));
3663
3664 return (wxChar *)NULL;
3665 }
3666
3667 Tm tm2 = wxDateTime(1, Jan, tm.year).SetToYearDay(yday).GetTm();
3668
3669 tm.mon = tm2.mon;
3670 tm.mday = tm2.mday;
3671 }
3672
3673 // deal with AM/PM
3674 if ( haveHour && hourIsIn12hFormat && isPM )
3675 {
3676 // translate to 24hour format
3677 hour += 12;
3678 }
3679 //else: either already in 24h format or no translation needed
3680
3681 // set the time
3682 if ( haveHour )
3683 {
3684 tm.hour = hour;
3685 }
3686
3687 if ( haveMin )
3688 {
3689 tm.min = min;
3690 }
3691
3692 if ( haveSec )
3693 {
3694 tm.sec = sec;
3695 }
3696
3697 Set(tm);
3698
3699 // finally check that the week day is consistent -- if we had it
3700 if ( haveWDay && GetWeekDay() != wday )
3701 {
3702 wxLogDebug(_T("inconsistsnet week day in wxDateTime::ParseFormat()"));
3703
3704 return NULL;
3705 }
3706
3707 return input;
3708 }
3709
3710 const wxChar *wxDateTime::ParseDateTime(const wxChar *date)
3711 {
3712 wxCHECK_MSG( date, (wxChar *)NULL, _T("NULL pointer in wxDateTime::Parse") );
3713
3714 // Set to current day and hour, so strings like '14:00' becomes today at
3715 // 14, not some other random date
3716 wxDateTime dtDate = wxDateTime::Today();
3717 wxDateTime dtTime = wxDateTime::Today();
3718
3719 const wxChar* pchTime;
3720
3721 // Try to parse the beginning of the string as a date
3722 const wxChar* pchDate = dtDate.ParseDate(date);
3723
3724 // We got a date in the beginning, see if there is a time specified after the date
3725 if ( pchDate )
3726 {
3727 // Skip spaces, as the ParseTime() function fails on spaces
3728 while ( wxIsspace(*pchDate) )
3729 pchDate++;
3730
3731 pchTime = dtTime.ParseTime(pchDate);
3732 }
3733 else // no date in the beginning
3734 {
3735 // check and see if we have a time followed by a date
3736 pchTime = dtTime.ParseTime(date);
3737 if ( pchTime )
3738 {
3739 while ( wxIsspace(*pchTime) )
3740 pchTime++;
3741
3742 pchDate = dtDate.ParseDate(pchTime);
3743 }
3744 }
3745
3746 // If we have a date specified, set our own data to the same date
3747 if ( !pchDate || !pchTime )
3748 return NULL;
3749
3750 Set(dtDate.GetDay(), dtDate.GetMonth(), dtDate.GetYear(),
3751 dtTime.GetHour(), dtTime.GetMinute(), dtTime.GetSecond(),
3752 dtTime.GetMillisecond());
3753
3754 // Return endpoint of scan
3755 return pchDate > pchTime ? pchDate : pchTime;
3756 }
3757
3758 const wxChar *wxDateTime::ParseDate(const wxChar *date)
3759 {
3760 // this is a simplified version of ParseDateTime() which understands only
3761 // "today" (for wxDate compatibility) and digits only otherwise (and not
3762 // all esoteric constructions ParseDateTime() knows about)
3763
3764 wxCHECK_MSG( date, (wxChar *)NULL, _T("NULL pointer in wxDateTime::Parse") );
3765
3766 const wxChar *p = date;
3767 while ( wxIsspace(*p) )
3768 p++;
3769
3770 // some special cases
3771 static struct
3772 {
3773 const wxChar *str;
3774 int dayDiffFromToday;
3775 } literalDates[] =
3776 {
3777 { wxTRANSLATE("today"), 0 },
3778 { wxTRANSLATE("yesterday"), -1 },
3779 { wxTRANSLATE("tomorrow"), 1 },
3780 };
3781
3782 for ( size_t n = 0; n < WXSIZEOF(literalDates); n++ )
3783 {
3784 const wxString dateStr = wxGetTranslation(literalDates[n].str);
3785 size_t len = dateStr.length();
3786 if ( wxStrlen(p) >= len )
3787 {
3788 wxString str(p, len);
3789 if ( str.CmpNoCase(dateStr) == 0 )
3790 {
3791 // nothing can follow this, so stop here
3792 p += len;
3793
3794 int dayDiffFromToday = literalDates[n].dayDiffFromToday;
3795 *this = Today();
3796 if ( dayDiffFromToday )
3797 {
3798 *this += wxDateSpan::Days(dayDiffFromToday);
3799 }
3800
3801 return p;
3802 }
3803 }
3804 }
3805
3806 // We try to guess what we have here: for each new (numeric) token, we
3807 // determine if it can be a month, day or a year. Of course, there is an
3808 // ambiguity as some numbers may be days as well as months, so we also
3809 // have the ability to back track.
3810
3811 // what do we have?
3812 bool haveDay = false, // the months day?
3813 haveWDay = false, // the day of week?
3814 haveMon = false, // the month?
3815 haveYear = false; // the year?
3816
3817 // and the value of the items we have (init them to get rid of warnings)
3818 WeekDay wday = Inv_WeekDay;
3819 wxDateTime_t day = 0;
3820 wxDateTime::Month mon = Inv_Month;
3821 int year = 0;
3822
3823 // tokenize the string
3824 size_t nPosCur = 0;
3825 static const wxChar *dateDelimiters = _T(".,/-\t\r\n ");
3826 wxStringTokenizer tok(p, dateDelimiters);
3827 while ( tok.HasMoreTokens() )
3828 {
3829 wxString token = tok.GetNextToken();
3830 if ( !token )
3831 continue;
3832
3833 // is it a number?
3834 unsigned long val;
3835 if ( token.ToULong(&val) )
3836 {
3837 // guess what this number is
3838
3839 bool isDay = false,
3840 isMonth = false,
3841 isYear = false;
3842
3843 if ( !haveMon && val > 0 && val <= 12 )
3844 {
3845 // assume it is month
3846 isMonth = true;
3847 }
3848 else // not the month
3849 {
3850 if ( haveDay )
3851 {
3852 // this can only be the year
3853 isYear = true;
3854 }
3855 else // may be either day or year
3856 {
3857 // use a leap year if we don't have the year yet to allow
3858 // dates like 2/29/1976 which would be rejected otherwise
3859 wxDateTime_t max_days = (wxDateTime_t)(
3860 haveMon
3861 ? GetNumOfDaysInMonth(haveYear ? year : 1976, mon)
3862 : 31
3863 );
3864
3865 // can it be day?
3866 if ( (val == 0) || (val > (unsigned long)max_days) )
3867 {
3868 // no
3869 isYear = true;
3870 }
3871 else // yes, suppose it's the day
3872 {
3873 isDay = true;
3874 }
3875 }
3876 }
3877
3878 if ( isYear )
3879 {
3880 if ( haveYear )
3881 break;
3882
3883 haveYear = true;
3884
3885 year = (wxDateTime_t)val;
3886 }
3887 else if ( isDay )
3888 {
3889 if ( haveDay )
3890 break;
3891
3892 haveDay = true;
3893
3894 day = (wxDateTime_t)val;
3895 }
3896 else if ( isMonth )
3897 {
3898 haveMon = true;
3899
3900 mon = (Month)(val - 1);
3901 }
3902 }
3903 else // not a number
3904 {
3905 // be careful not to overwrite the current mon value
3906 Month mon2 = GetMonthFromName(token, Name_Full | Name_Abbr);
3907 if ( mon2 != Inv_Month )
3908 {
3909 // it's a month
3910 if ( haveMon )
3911 {
3912 // but we already have a month - maybe we guessed wrong?
3913 if ( !haveDay )
3914 {
3915 // no need to check in month range as always < 12, but
3916 // the days are counted from 1 unlike the months
3917 day = (wxDateTime_t)(mon + 1);
3918 haveDay = true;
3919 }
3920 else
3921 {
3922 // could possible be the year (doesn't the year come
3923 // before the month in the japanese format?) (FIXME)
3924 break;
3925 }
3926 }
3927
3928 mon = mon2;
3929
3930 haveMon = true;
3931 }
3932 else // not a valid month name
3933 {
3934 wday = GetWeekDayFromName(token, Name_Full | Name_Abbr);
3935 if ( wday != Inv_WeekDay )
3936 {
3937 // a week day
3938 if ( haveWDay )
3939 {
3940 break;
3941 }
3942
3943 haveWDay = true;
3944 }
3945 else // not a valid weekday name
3946 {
3947 // try the ordinals
3948 static const wxChar *ordinals[] =
3949 {
3950 wxTRANSLATE("first"),
3951 wxTRANSLATE("second"),
3952 wxTRANSLATE("third"),
3953 wxTRANSLATE("fourth"),
3954 wxTRANSLATE("fifth"),
3955 wxTRANSLATE("sixth"),
3956 wxTRANSLATE("seventh"),
3957 wxTRANSLATE("eighth"),
3958 wxTRANSLATE("ninth"),
3959 wxTRANSLATE("tenth"),
3960 wxTRANSLATE("eleventh"),
3961 wxTRANSLATE("twelfth"),
3962 wxTRANSLATE("thirteenth"),
3963 wxTRANSLATE("fourteenth"),
3964 wxTRANSLATE("fifteenth"),
3965 wxTRANSLATE("sixteenth"),
3966 wxTRANSLATE("seventeenth"),
3967 wxTRANSLATE("eighteenth"),
3968 wxTRANSLATE("nineteenth"),
3969 wxTRANSLATE("twentieth"),
3970 // that's enough - otherwise we'd have problems with
3971 // composite (or not) ordinals
3972 };
3973
3974 size_t n;
3975 for ( n = 0; n < WXSIZEOF(ordinals); n++ )
3976 {
3977 if ( token.CmpNoCase(ordinals[n]) == 0 )
3978 {
3979 break;
3980 }
3981 }
3982
3983 if ( n == WXSIZEOF(ordinals) )
3984 {
3985 // stop here - something unknown
3986 break;
3987 }
3988
3989 // it's a day
3990 if ( haveDay )
3991 {
3992 // don't try anything here (as in case of numeric day
3993 // above) - the symbolic day spec should always
3994 // precede the month/year
3995 break;
3996 }
3997
3998 haveDay = true;
3999
4000 day = (wxDateTime_t)(n + 1);
4001 }
4002 }
4003 }
4004
4005 nPosCur = tok.GetPosition();
4006 }
4007
4008 // either no more tokens or the scan was stopped by something we couldn't
4009 // parse - in any case, see if we can construct a date from what we have
4010 if ( !haveDay && !haveWDay )
4011 {
4012 wxLogDebug(_T("ParseDate: no day, no weekday hence no date."));
4013
4014 return NULL;
4015 }
4016
4017 if ( haveWDay && (haveMon || haveYear || haveDay) &&
4018 !(haveDay && haveMon && haveYear) )
4019 {
4020 // without adjectives (which we don't support here) the week day only
4021 // makes sense completely separately or with the full date
4022 // specification (what would "Wed 1999" mean?)
4023 return NULL;
4024 }
4025
4026 if ( !haveWDay && haveYear && !(haveDay && haveMon) )
4027 {
4028 // may be we have month and day instead of day and year?
4029 if ( haveDay && !haveMon )
4030 {
4031 if ( day <= 12 )
4032 {
4033 // exchange day and month
4034 mon = (wxDateTime::Month)(day - 1);
4035
4036 // we're in the current year then
4037 if ( (year > 0) && (year <= (int)GetNumOfDaysInMonth(Inv_Year, mon)) )
4038 {
4039 day = (wxDateTime_t)year;
4040
4041 haveMon = true;
4042 haveYear = false;
4043 }
4044 //else: no, can't exchange, leave haveMon == false
4045 }
4046 }
4047
4048 if ( !haveMon )
4049 {
4050 // if we give the year, month and day must be given too
4051 wxLogDebug(_T("ParseDate: day and month should be specified if year is."));
4052
4053 return NULL;
4054 }
4055 }
4056
4057 if ( !haveMon )
4058 {
4059 mon = GetCurrentMonth();
4060 }
4061
4062 if ( !haveYear )
4063 {
4064 year = GetCurrentYear();
4065 }
4066
4067 if ( haveDay )
4068 {
4069 // normally we check the day above but the check is optimistic in case
4070 // we find the day before its month/year so we have to redo it now
4071 if ( day > GetNumOfDaysInMonth(year, mon) )
4072 return NULL;
4073
4074 Set(day, mon, year);
4075
4076 if ( haveWDay )
4077 {
4078 // check that it is really the same
4079 if ( GetWeekDay() != wday )
4080 {
4081 // inconsistency detected
4082 wxLogDebug(_T("ParseDate: inconsistent day/weekday."));
4083
4084 return (wxChar *)NULL;
4085 }
4086 }
4087 }
4088 else // haveWDay
4089 {
4090 *this = Today();
4091
4092 SetToWeekDayInSameWeek(wday);
4093 }
4094
4095 // return the pointer to the first unparsed char
4096 p += nPosCur;
4097 if ( nPosCur && wxStrchr(dateDelimiters, *(p - 1)) )
4098 {
4099 // if we couldn't parse the token after the delimiter, put back the
4100 // delimiter as well
4101 p--;
4102 }
4103
4104 return p;
4105 }
4106
4107 const wxChar *wxDateTime::ParseTime(const wxChar *time)
4108 {
4109 wxCHECK_MSG( time, (wxChar *)NULL, _T("NULL pointer in wxDateTime::Parse") );
4110
4111 // first try some extra things
4112 static const struct
4113 {
4114 const wxChar *name;
4115 wxDateTime_t hour;
4116 } stdTimes[] =
4117 {
4118 { wxTRANSLATE("noon"), 12 },
4119 { wxTRANSLATE("midnight"), 00 },
4120 // anything else?
4121 };
4122
4123 for ( size_t n = 0; n < WXSIZEOF(stdTimes); n++ )
4124 {
4125 wxString timeString = wxGetTranslation(stdTimes[n].name);
4126 size_t len = timeString.length();
4127 if ( timeString.CmpNoCase(wxString(time, len)) == 0 )
4128 {
4129 // casts required by DigitalMars
4130 Set(stdTimes[n].hour, wxDateTime_t(0), wxDateTime_t(0));
4131
4132 return time + len;
4133 }
4134 }
4135
4136 // try all time formats we may think about in the order from longest to
4137 // shortest
4138
4139 // 12hour with AM/PM?
4140 const wxChar *result = ParseFormat(time, _T("%I:%M:%S %p"));
4141
4142 if ( !result )
4143 {
4144 // normally, it's the same, but why not try it?
4145 result = ParseFormat(time, _T("%H:%M:%S"));
4146 }
4147
4148 if ( !result )
4149 {
4150 // 12hour with AM/PM but without seconds?
4151 result = ParseFormat(time, _T("%I:%M %p"));
4152 }
4153
4154 if ( !result )
4155 {
4156 // without seconds?
4157 result = ParseFormat(time, _T("%H:%M"));
4158 }
4159
4160 if ( !result )
4161 {
4162 // just the hour and AM/PM?
4163 result = ParseFormat(time, _T("%I %p"));
4164 }
4165
4166 if ( !result )
4167 {
4168 // just the hour?
4169 result = ParseFormat(time, _T("%H"));
4170 }
4171
4172 if ( !result )
4173 {
4174 // parse the standard format: normally it is one of the formats above
4175 // but it may be set to something completely different by the user
4176 result = ParseFormat(time, _T("%X"));
4177 }
4178
4179 // TODO: parse timezones
4180
4181 return result;
4182 }
4183
4184 // ----------------------------------------------------------------------------
4185 // Workdays and holidays support
4186 // ----------------------------------------------------------------------------
4187
4188 bool wxDateTime::IsWorkDay(Country WXUNUSED(country)) const
4189 {
4190 return !wxDateTimeHolidayAuthority::IsHoliday(*this);
4191 }
4192
4193 // ============================================================================
4194 // wxDateSpan
4195 // ============================================================================
4196
4197 wxDateSpan WXDLLIMPEXP_BASE operator*(int n, const wxDateSpan& ds)
4198 {
4199 wxDateSpan ds1(ds);
4200 return ds1.Multiply(n);
4201 }
4202
4203 // ============================================================================
4204 // wxTimeSpan
4205 // ============================================================================
4206
4207 wxTimeSpan WXDLLIMPEXP_BASE operator*(int n, const wxTimeSpan& ts)
4208 {
4209 return wxTimeSpan(ts).Multiply(n);
4210 }
4211
4212 // this enum is only used in wxTimeSpan::Format() below but we can't declare
4213 // it locally to the method as it provokes an internal compiler error in egcs
4214 // 2.91.60 when building with -O2
4215 enum TimeSpanPart
4216 {
4217 Part_Week,
4218 Part_Day,
4219 Part_Hour,
4220 Part_Min,
4221 Part_Sec,
4222 Part_MSec
4223 };
4224
4225 // not all strftime(3) format specifiers make sense here because, for example,
4226 // a time span doesn't have a year nor a timezone
4227 //
4228 // Here are the ones which are supported (all of them are supported by strftime
4229 // as well):
4230 // %H hour in 24 hour format
4231 // %M minute (00 - 59)
4232 // %S second (00 - 59)
4233 // %% percent sign
4234 //
4235 // Also, for MFC CTimeSpan compatibility, we support
4236 // %D number of days
4237 //
4238 // And, to be better than MFC :-), we also have
4239 // %E number of wEeks
4240 // %l milliseconds (000 - 999)
4241 wxString wxTimeSpan::Format(const wxChar *format) const
4242 {
4243 wxCHECK_MSG( format, wxEmptyString, _T("NULL format in wxTimeSpan::Format") );
4244
4245 wxString str;
4246 str.Alloc(wxStrlen(format));
4247
4248 // Suppose we have wxTimeSpan ts(1 /* hour */, 2 /* min */, 3 /* sec */)
4249 //
4250 // Then, of course, ts.Format("%H:%M:%S") must return "01:02:03", but the
4251 // question is what should ts.Format("%S") do? The code here returns "3273"
4252 // in this case (i.e. the total number of seconds, not just seconds % 60)
4253 // because, for me, this call means "give me entire time interval in
4254 // seconds" and not "give me the seconds part of the time interval"
4255 //
4256 // If we agree that it should behave like this, it is clear that the
4257 // interpretation of each format specifier depends on the presence of the
4258 // other format specs in the string: if there was "%H" before "%M", we
4259 // should use GetMinutes() % 60, otherwise just GetMinutes() &c
4260
4261 // we remember the most important unit found so far
4262 TimeSpanPart partBiggest = Part_MSec;
4263
4264 for ( const wxChar *pch = format; *pch; pch++ )
4265 {
4266 wxChar ch = *pch;
4267
4268 if ( ch == _T('%') )
4269 {
4270 // the start of the format specification of the printf() below
4271 wxString fmtPrefix(_T('%'));
4272
4273 // the number
4274 long n;
4275
4276 // the number of digits for the format string, 0 if unused
4277 unsigned digits = 0;
4278
4279 ch = *++pch; // get the format spec char
4280 switch ( ch )
4281 {
4282 default:
4283 wxFAIL_MSG( _T("invalid format character") );
4284 // fall through
4285
4286 case _T('%'):
4287 str += ch;
4288
4289 // skip the part below switch
4290 continue;
4291
4292 case _T('D'):
4293 n = GetDays();
4294 if ( partBiggest < Part_Day )
4295 {
4296 n %= DAYS_PER_WEEK;
4297 }
4298 else
4299 {
4300 partBiggest = Part_Day;
4301 }
4302 break;
4303
4304 case _T('E'):
4305 partBiggest = Part_Week;
4306 n = GetWeeks();
4307 break;
4308
4309 case _T('H'):
4310 n = GetHours();
4311 if ( partBiggest < Part_Hour )
4312 {
4313 if ( n < 0 )
4314 {
4315 // the sign has already been taken into account
4316 // when outputting the biggest part
4317 n = -n;
4318 }
4319
4320 n %= HOURS_PER_DAY;
4321 }
4322 else
4323 {
4324 partBiggest = Part_Hour;
4325 }
4326
4327 digits = 2;
4328 break;
4329
4330 case _T('l'):
4331 n = GetMilliseconds().ToLong();
4332 if ( partBiggest < Part_MSec )
4333 {
4334 if ( n < 0 )
4335 n = -n;
4336
4337 n %= 1000;
4338 }
4339 //else: no need to reset partBiggest to Part_MSec, it is
4340 // the least significant one anyhow
4341
4342 digits = 3;
4343 break;
4344
4345 case _T('M'):
4346 n = GetMinutes();
4347 if ( partBiggest < Part_Min )
4348 {
4349 if ( n < 0 )
4350 n = -n;
4351
4352 n %= MIN_PER_HOUR;
4353 }
4354 else
4355 {
4356 partBiggest = Part_Min;
4357 }
4358
4359 digits = 2;
4360 break;
4361
4362 case _T('S'):
4363 n = GetSeconds().ToLong();
4364 if ( partBiggest < Part_Sec )
4365 {
4366 if ( n < 0 )
4367 n = -n;
4368
4369 n %= SEC_PER_MIN;
4370 }
4371 else
4372 {
4373 partBiggest = Part_Sec;
4374 }
4375
4376 digits = 2;
4377 break;
4378 }
4379
4380 if ( digits )
4381 {
4382 // negative numbers need one extra position for '-' display
4383 if ( n < 0 )
4384 digits++;
4385
4386 fmtPrefix << _T("0") << digits;
4387 }
4388
4389 str += wxString::Format(fmtPrefix + _T("ld"), n);
4390 }
4391 else
4392 {
4393 // normal character, just copy
4394 str += ch;
4395 }
4396 }
4397
4398 return str;
4399 }
4400
4401 // ============================================================================
4402 // wxDateTimeHolidayAuthority and related classes
4403 // ============================================================================
4404
4405 #include "wx/arrimpl.cpp"
4406
4407 WX_DEFINE_OBJARRAY(wxDateTimeArray)
4408
4409 static int wxCMPFUNC_CONV
4410 wxDateTimeCompareFunc(wxDateTime **first, wxDateTime **second)
4411 {
4412 wxDateTime dt1 = **first,
4413 dt2 = **second;
4414
4415 return dt1 == dt2 ? 0 : dt1 < dt2 ? -1 : +1;
4416 }
4417
4418 // ----------------------------------------------------------------------------
4419 // wxDateTimeHolidayAuthority
4420 // ----------------------------------------------------------------------------
4421
4422 wxHolidayAuthoritiesArray wxDateTimeHolidayAuthority::ms_authorities;
4423
4424 /* static */
4425 bool wxDateTimeHolidayAuthority::IsHoliday(const wxDateTime& dt)
4426 {
4427 size_t count = ms_authorities.size();
4428 for ( size_t n = 0; n < count; n++ )
4429 {
4430 if ( ms_authorities[n]->DoIsHoliday(dt) )
4431 {
4432 return true;
4433 }
4434 }
4435
4436 return false;
4437 }
4438
4439 /* static */
4440 size_t
4441 wxDateTimeHolidayAuthority::GetHolidaysInRange(const wxDateTime& dtStart,
4442 const wxDateTime& dtEnd,
4443 wxDateTimeArray& holidays)
4444 {
4445 wxDateTimeArray hol;
4446
4447 holidays.Clear();
4448
4449 const size_t countAuth = ms_authorities.size();
4450 for ( size_t nAuth = 0; nAuth < countAuth; nAuth++ )
4451 {
4452 ms_authorities[nAuth]->DoGetHolidaysInRange(dtStart, dtEnd, hol);
4453
4454 WX_APPEND_ARRAY(holidays, hol);
4455 }
4456
4457 holidays.Sort(wxDateTimeCompareFunc);
4458
4459 return holidays.size();
4460 }
4461
4462 /* static */
4463 void wxDateTimeHolidayAuthority::ClearAllAuthorities()
4464 {
4465 WX_CLEAR_ARRAY(ms_authorities);
4466 }
4467
4468 /* static */
4469 void wxDateTimeHolidayAuthority::AddAuthority(wxDateTimeHolidayAuthority *auth)
4470 {
4471 ms_authorities.push_back(auth);
4472 }
4473
4474 wxDateTimeHolidayAuthority::~wxDateTimeHolidayAuthority()
4475 {
4476 // required here for Darwin
4477 }
4478
4479 // ----------------------------------------------------------------------------
4480 // wxDateTimeWorkDays
4481 // ----------------------------------------------------------------------------
4482
4483 bool wxDateTimeWorkDays::DoIsHoliday(const wxDateTime& dt) const
4484 {
4485 wxDateTime::WeekDay wd = dt.GetWeekDay();
4486
4487 return (wd == wxDateTime::Sun) || (wd == wxDateTime::Sat);
4488 }
4489
4490 size_t wxDateTimeWorkDays::DoGetHolidaysInRange(const wxDateTime& dtStart,
4491 const wxDateTime& dtEnd,
4492 wxDateTimeArray& holidays) const
4493 {
4494 if ( dtStart > dtEnd )
4495 {
4496 wxFAIL_MSG( _T("invalid date range in GetHolidaysInRange") );
4497
4498 return 0u;
4499 }
4500
4501 holidays.Empty();
4502
4503 // instead of checking all days, start with the first Sat after dtStart and
4504 // end with the last Sun before dtEnd
4505 wxDateTime dtSatFirst = dtStart.GetNextWeekDay(wxDateTime::Sat),
4506 dtSatLast = dtEnd.GetPrevWeekDay(wxDateTime::Sat),
4507 dtSunFirst = dtStart.GetNextWeekDay(wxDateTime::Sun),
4508 dtSunLast = dtEnd.GetPrevWeekDay(wxDateTime::Sun),
4509 dt;
4510
4511 for ( dt = dtSatFirst; dt <= dtSatLast; dt += wxDateSpan::Week() )
4512 {
4513 holidays.Add(dt);
4514 }
4515
4516 for ( dt = dtSunFirst; dt <= dtSunLast; dt += wxDateSpan::Week() )
4517 {
4518 holidays.Add(dt);
4519 }
4520
4521 return holidays.GetCount();
4522 }
4523
4524 // ============================================================================
4525 // other helper functions
4526 // ============================================================================
4527
4528 // ----------------------------------------------------------------------------
4529 // iteration helpers: can be used to write a for loop over enum variable like
4530 // this:
4531 // for ( m = wxDateTime::Jan; m < wxDateTime::Inv_Month; wxNextMonth(m) )
4532 // ----------------------------------------------------------------------------
4533
4534 WXDLLIMPEXP_BASE void wxNextMonth(wxDateTime::Month& m)
4535 {
4536 wxASSERT_MSG( m < wxDateTime::Inv_Month, _T("invalid month") );
4537
4538 // no wrapping or the for loop above would never end!
4539 m = (wxDateTime::Month)(m + 1);
4540 }
4541
4542 WXDLLIMPEXP_BASE void wxPrevMonth(wxDateTime::Month& m)
4543 {
4544 wxASSERT_MSG( m < wxDateTime::Inv_Month, _T("invalid month") );
4545
4546 m = m == wxDateTime::Jan ? wxDateTime::Inv_Month
4547 : (wxDateTime::Month)(m - 1);
4548 }
4549
4550 WXDLLIMPEXP_BASE void wxNextWDay(wxDateTime::WeekDay& wd)
4551 {
4552 wxASSERT_MSG( wd < wxDateTime::Inv_WeekDay, _T("invalid week day") );
4553
4554 // no wrapping or the for loop above would never end!
4555 wd = (wxDateTime::WeekDay)(wd + 1);
4556 }
4557
4558 WXDLLIMPEXP_BASE void wxPrevWDay(wxDateTime::WeekDay& wd)
4559 {
4560 wxASSERT_MSG( wd < wxDateTime::Inv_WeekDay, _T("invalid week day") );
4561
4562 wd = wd == wxDateTime::Sun ? wxDateTime::Inv_WeekDay
4563 : (wxDateTime::WeekDay)(wd - 1);
4564 }
4565
4566 #endif // wxUSE_DATETIME