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