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