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