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