src/common/datetime.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/datetime.cpp
   3 // Purpose:     implementation of time/date related classes
   4 //              (for formatting&parsing see datetimefmt.cpp)
   5 // Author:      Vadim Zeitlin
   6 // Modified by:
   7 // Created:     11.05.99
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
  10 //              parts of code taken from sndcal library by Scott E. Lee:
  11 //
  12 //               Copyright 1993-1995, Scott E. Lee, all rights reserved.
  13 //               Permission granted to use, copy, modify, distribute and sell
  14 //               so long as the above copyright and this permission statement
  15 //               are retained in all copies.
  16 //
  17 // Licence:     wxWindows licence
  18 ///////////////////////////////////////////////////////////////////////////////
  19
  20 /*
  21  * Implementation notes:
  22  *
  23  * 1. the time is stored as a 64bit integer containing the signed number of
  24  *    milliseconds since Jan 1. 1970 (the Unix Epoch) - so it is always
  25  *    expressed in GMT.
  26  *
  27  * 2. the range is thus something about 580 million years, but due to current
  28  *    algorithms limitations, only dates from Nov 24, 4714BC are handled
  29  *
  30  * 3. standard ANSI C functions are used to do time calculations whenever
  31  *    possible, i.e. when the date is in the range Jan 1, 1970 to 2038
  32  *
  33  * 4. otherwise, the calculations are done by converting the date to/from JDN
  34  *    first (the range limitation mentioned above comes from here: the
  35  *    algorithm used by Scott E. Lee's code only works for positive JDNs, more
  36  *    or less)
  37  *
  38  * 5. the object constructed for the given DD-MM-YYYY HH:MM:SS corresponds to
  39  *    this moment in local time and may be converted to the object
  40  *    corresponding to the same date/time in another time zone by using
  41  *    ToTimezone()
  42  *
  43  * 6. the conversions to the current (or any other) timezone are done when the
  44  *    internal time representation is converted to the broken-down one in
  45  *    wxDateTime::Tm.
  46  */
  47
  48 // ============================================================================
  49 // declarations
  50 // ============================================================================
  51
  52 // ----------------------------------------------------------------------------
  53 // headers
  54 // ----------------------------------------------------------------------------
  55
  56 // For compilers that support precompilation, includes "wx.h".
  57 #include "wx/wxprec.h"
  58
  59 #ifdef __BORLANDC__
  60     #pragma hdrstop
  61 #endif
  62
  63 #if !defined(wxUSE_DATETIME) || wxUSE_DATETIME
  64
  65 #ifndef WX_PRECOMP
  66     #ifdef __WXMSW__
  67         #include "wx/msw/wrapwin.h"
  68     #endif
  69     #include "wx/string.h"
  70     #include "wx/log.h"
  71     #include "wx/intl.h"
  72     #include "wx/stopwatch.h"           // for wxGetLocalTimeMillis()
  73     #include "wx/module.h"
  74     #include "wx/crt.h"
  75 #endif // WX_PRECOMP
  76
  77 #include "wx/thread.h"
  78 #include "wx/tokenzr.h"
  79
  80 #include <ctype.h>
  81
  82 #ifdef __WINDOWS__
  83     #include <winnls.h>
  84     #ifndef __WXWINCE__
  85         #include <locale.h>
  86     #endif
  87 #endif
  88
  89 #include "wx/datetime.h"
  90
  91 // ----------------------------------------------------------------------------
  92 // wxXTI
  93 // ----------------------------------------------------------------------------
  94
  95 #if wxUSE_EXTENDED_RTTI
  96
  97 template<> void wxStringReadValue(const wxString &s , wxDateTime &data )
  98 {
  99     data.ParseFormat(s,"%Y-%m-%d %H:%M:%S", NULL);
 100 }
 101
 102 template<> void wxStringWriteValue(wxString &s , const wxDateTime &data )
 103 {
 104     s = data.Format("%Y-%m-%d %H:%M:%S");
 105 }
 106
 107 wxCUSTOM_TYPE_INFO(wxDateTime, wxToStringConverter<wxDateTime> , wxFromStringConverter<wxDateTime>)
 108
 109 #endif // wxUSE_EXTENDED_RTTI
 110
 111
 112 // ----------------------------------------------------------------------------
 113 // conditional compilation
 114 // ----------------------------------------------------------------------------
 115
 116 #if defined(__MWERKS__) && wxUSE_UNICODE
 117     #include <wtime.h>
 118 #endif
 119
 120 #if defined(__DJGPP__) || defined(__WINE__)
 121     #include <sys/timeb.h>
 122     #include <values.h>
 123 #endif
 124
 125 #ifndef WX_GMTOFF_IN_TM
 126     // Define it for some systems which don't (always) use configure but are
 127     // known to have tm_gmtoff field.
 128     #if defined(__WXPALMOS__) || defined(__DARWIN__)
 129         #define WX_GMTOFF_IN_TM
 130     #endif
 131 #endif
 132
 133 // NB: VC8 safe time functions could/should be used for wxMSW as well probably
 134 #if defined(__WXWINCE__) && defined(__VISUALC8__)
 135
 136 struct tm *wxLocaltime_r(const time_t *t, struct tm* tm)
 137 {
 138     __time64_t t64 = *t;
 139     return _localtime64_s(tm, &t64) == 0 ? tm : NULL;
 140 }
 141
 142 struct tm *wxGmtime_r(const time_t* t, struct tm* tm)
 143 {
 144     __time64_t t64 = *t;
 145     return _gmtime64_s(tm, &t64) == 0 ? tm : NULL;
 146 }
 147
 148 #else // !wxWinCE with VC8
 149
 150 #if (!defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)) && wxUSE_THREADS && !defined(__WINDOWS__)
 151 static wxMutex timeLock;
 152 #endif
 153
 154 #ifndef HAVE_LOCALTIME_R
 155 struct tm *wxLocaltime_r(const time_t* ticks, struct tm* temp)
 156 {
 157 #if wxUSE_THREADS && !defined(__WINDOWS__)
 158   // No need to waste time with a mutex on windows since it's using
 159   // thread local storage for localtime anyway.
 160   wxMutexLocker locker(timeLock);
 161 #endif
 162
 163   // Borland CRT crashes when passed 0 ticks for some reason, see SF bug 1704438
 164 #ifdef __BORLANDC__
 165   if ( !*ticks )
 166       return NULL;
 167 #endif
 168
 169   const tm * const t = localtime(ticks);
 170   if ( !t )
 171       return NULL;
 172
 173   memcpy(temp, t, sizeof(struct tm));
 174   return temp;
 175 }
 176 #endif // !HAVE_LOCALTIME_R
 177
 178 #ifndef HAVE_GMTIME_R
 179 struct tm *wxGmtime_r(const time_t* ticks, struct tm* temp)
 180 {
 181 #if wxUSE_THREADS && !defined(__WINDOWS__)
 182   // No need to waste time with a mutex on windows since it's
 183   // using thread local storage for gmtime anyway.
 184   wxMutexLocker locker(timeLock);
 185 #endif
 186
 187 #ifdef __BORLANDC__
 188   if ( !*ticks )
 189       return NULL;
 190 #endif
 191
 192   const tm * const t = gmtime(ticks);
 193   if ( !t )
 194       return NULL;
 195
 196   memcpy(temp, gmtime(ticks), sizeof(struct tm));
 197   return temp;
 198 }
 199 #endif // !HAVE_GMTIME_R
 200
 201 #endif // wxWinCE with VC8/other platforms
 202
 203 // ----------------------------------------------------------------------------
 204 // macros
 205 // ----------------------------------------------------------------------------
 206
 207 // debugging helper: just a convenient replacement of wxCHECK()
 208 #define wxDATETIME_CHECK(expr, msg) \
 209     wxCHECK2_MSG(expr, *this = wxInvalidDateTime; return *this, msg)
 210
 211 // ----------------------------------------------------------------------------
 212 // private classes
 213 // ----------------------------------------------------------------------------
 214
 215 class wxDateTimeHolidaysModule : public wxModule
 216 {
 217 public:
 218     virtual bool OnInit()
 219     {
 220         wxDateTimeHolidayAuthority::AddAuthority(new wxDateTimeWorkDays);
 221
 222         return true;
 223     }
 224
 225     virtual void OnExit()
 226     {
 227         wxDateTimeHolidayAuthority::ClearAllAuthorities();
 228         wxDateTimeHolidayAuthority::ms_authorities.clear();
 229     }
 230
 231 private:
 232     DECLARE_DYNAMIC_CLASS(wxDateTimeHolidaysModule)
 233 };
 234
 235 IMPLEMENT_DYNAMIC_CLASS(wxDateTimeHolidaysModule, wxModule)
 236
 237 // ----------------------------------------------------------------------------
 238 // constants
 239 // ----------------------------------------------------------------------------
 240
 241 // some trivial ones
 242 static const int MONTHS_IN_YEAR = 12;
 243
 244 static const int SEC_PER_MIN = 60;
 245
 246 static const int MIN_PER_HOUR = 60;
 247
 248 static const long SECONDS_PER_DAY = 86400l;
 249
 250 static const int DAYS_PER_WEEK = 7;
 251
 252 static const long MILLISECONDS_PER_DAY = 86400000l;
 253
 254 // this is the integral part of JDN of the midnight of Jan 1, 1970
 255 // (i.e. JDN(Jan 1, 1970) = 2440587.5)
 256 static const long EPOCH_JDN = 2440587l;
 257
 258 // these values are only used in asserts so don't define them if asserts are
 259 // disabled to avoid warnings about unused static variables
 260 #if wxDEBUG_LEVEL
 261 // the date of JDN -0.5 (as we don't work with fractional parts, this is the
 262 // reference date for us) is Nov 24, 4714BC
 263 static const int JDN_0_YEAR = -4713;
 264 static const int JDN_0_MONTH = wxDateTime::Nov;
 265 static const int JDN_0_DAY = 24;
 266 #endif // wxDEBUG_LEVEL
 267
 268 // the constants used for JDN calculations
 269 static const long JDN_OFFSET         = 32046l;
 270 static const long DAYS_PER_5_MONTHS  = 153l;
 271 static const long DAYS_PER_4_YEARS   = 1461l;
 272 static const long DAYS_PER_400_YEARS = 146097l;
 273
 274 // this array contains the cumulated number of days in all previous months for
 275 // normal and leap years
 276 static const wxDateTime::wxDateTime_t gs_cumulatedDays[2][MONTHS_IN_YEAR] =
 277 {
 278     { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
 279     { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
 280 };
 281
 282 const long wxDateTime::TIME_T_FACTOR = 1000l;
 283
 284 // ----------------------------------------------------------------------------
 285 // global data
 286 // ----------------------------------------------------------------------------
 287
 288 const char wxDefaultDateTimeFormat[] = "%c";
 289 const char wxDefaultTimeSpanFormat[] = "%H:%M:%S";
 290
 291 // in the fine tradition of ANSI C we use our equivalent of (time_t)-1 to
 292 // indicate an invalid wxDateTime object
 293 const wxDateTime wxDefaultDateTime;
 294
 295 wxDateTime::Country wxDateTime::ms_country = wxDateTime::Country_Unknown;
 296
 297 // ----------------------------------------------------------------------------
 298 // private functions
 299 // ----------------------------------------------------------------------------
 300
 301 // debugger helper: this function can be called from a debugger to show what
 302 // the date really is
 303 extern const char *wxDumpDate(const wxDateTime* dt)
 304 {
 305     static char buf[128];
 306
 307     wxString fmt(dt->Format("%Y-%m-%d (%a) %H:%M:%S"));
 308     wxStrlcpy(buf,
 309               (fmt + " (" + dt->GetValue().ToString() + " ticks)").ToAscii(),
 310               WXSIZEOF(buf));
 311
 312     return buf;
 313 }
 314
 315 // get the number of days in the given month of the given year
 316 static inline
 317 wxDateTime::wxDateTime_t GetNumOfDaysInMonth(int year, wxDateTime::Month month)
 318 {
 319     // the number of days in month in Julian/Gregorian calendar: the first line
 320     // is for normal years, the second one is for the leap ones
 321     static const wxDateTime::wxDateTime_t daysInMonth[2][MONTHS_IN_YEAR] =
 322     {
 323         { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
 324         { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
 325     };
 326
 327     return daysInMonth[wxDateTime::IsLeapYear(year)][month];
 328 }
 329
 330 // returns the time zone in the C sense, i.e. the difference UTC - local
 331 // (in seconds)
 332 // NOTE: not static because used by datetimefmt.cpp
 333 int GetTimeZone()
 334 {
 335 #ifdef WX_GMTOFF_IN_TM
 336     // set to true when the timezone is set
 337     static bool s_timezoneSet = false;
 338     static long gmtoffset = LONG_MAX; // invalid timezone
 339
 340     // ensure that the timezone variable is set by calling wxLocaltime_r
 341     if ( !s_timezoneSet )
 342     {
 343         // just call wxLocaltime_r() instead of figuring out whether this
 344         // system supports tzset(), _tzset() or something else
 345         time_t t = 0;
 346         struct tm tm;
 347
 348         wxLocaltime_r(&t, &tm);
 349         s_timezoneSet = true;
 350
 351         // note that GMT offset is the opposite of time zone and so to return
 352         // consistent results in both WX_GMTOFF_IN_TM and !WX_GMTOFF_IN_TM
 353         // cases we have to negate it
 354         gmtoffset = -tm.tm_gmtoff;
 355     }
 356     return (int)gmtoffset;
 357 #elif defined(__DJGPP__) || defined(__WINE__)
 358     struct timeb tb;
 359     ftime(&tb);
 360     return tb.timezone*60;
 361 #elif defined(__VISUALC__)
 362     // We must initialize the time zone information before using it (this will
 363     // be done only once internally).
 364     _tzset();
 365
 366     // Starting with VC++ 8 timezone variable is deprecated and is not even
 367     // available in some standard library version so use the new function for
 368     // accessing it instead.
 369     #if wxCHECK_VISUALC_VERSION(8)
 370         long t;
 371         _get_timezone(&t);
 372         return t;
 373     #else // VC++ < 8
 374         return timezone;
 375     #endif
 376 #elif defined(WX_TIMEZONE) // If WX_TIMEZONE was defined by configure, use it.
 377     return WX_TIMEZONE;
 378 #elif defined(__BORLANDC__) || defined(__MINGW32__) || defined(__VISAGECPP__)
 379     return _timezone;
 380 #elif defined(__MWERKS__)
 381     return 28800;
 382 #else // unknown platform -- assume it has timezone
 383     return timezone;
 384 #endif // WX_GMTOFF_IN_TM/!WX_GMTOFF_IN_TM
 385 }
 386
 387 // return the integral part of the JDN for the midnight of the given date (to
 388 // get the real JDN you need to add 0.5, this is, in fact, JDN of the
 389 // noon of the previous day)
 390 static long GetTruncatedJDN(wxDateTime::wxDateTime_t day,
 391                             wxDateTime::Month mon,
 392                             int year)
 393 {
 394     // CREDIT: code below is by Scott E. Lee (but bugs are mine)
 395
 396     // check the date validity
 397     wxASSERT_MSG(
 398       (year > JDN_0_YEAR) ||
 399       ((year == JDN_0_YEAR) && (mon > JDN_0_MONTH)) ||
 400       ((year == JDN_0_YEAR) && (mon == JDN_0_MONTH) && (day >= JDN_0_DAY)),
 401       wxT("date out of range - can't convert to JDN")
 402                 );
 403
 404     // make the year positive to avoid problems with negative numbers division
 405     year += 4800;
 406
 407     // months are counted from March here
 408     int month;
 409     if ( mon >= wxDateTime::Mar )
 410     {
 411         month = mon - 2;
 412     }
 413     else
 414     {
 415         month = mon + 10;
 416         year--;
 417     }
 418
 419     // now we can simply add all the contributions together
 420     return ((year / 100) * DAYS_PER_400_YEARS) / 4
 421             + ((year % 100) * DAYS_PER_4_YEARS) / 4
 422             + (month * DAYS_PER_5_MONTHS + 2) / 5
 423             + day
 424             - JDN_OFFSET;
 425 }
 426
 427 #ifdef wxHAS_STRFTIME
 428
 429 // this function is a wrapper around strftime(3) adding error checking
 430 // NOTE: not static because used by datetimefmt.cpp
 431 wxString CallStrftime(const wxString& format, const tm* tm)
 432 {
 433     wxChar buf[4096];
 434     // Create temp wxString here to work around mingw/cygwin bug 1046059
 435     // http://sourceforge.net/tracker/?func=detail&atid=102435&aid=1046059&group_id=2435
 436     wxString s;
 437
 438     if ( !wxStrftime(buf, WXSIZEOF(buf), format, tm) )
 439     {
 440         // if the format is valid, buffer must be too small?
 441         wxFAIL_MSG(wxT("strftime() failed"));
 442
 443         buf[0] = '\0';
 444     }
 445
 446     s = buf;
 447     return s;
 448 }
 449
 450 #endif // wxHAS_STRFTIME
 451
 452 // if year and/or month have invalid values, replace them with the current ones
 453 static void ReplaceDefaultYearMonthWithCurrent(int *year,
 454                                                wxDateTime::Month *month)
 455 {
 456     struct tm *tmNow = NULL;
 457     struct tm tmstruct;
 458
 459     if ( *year == wxDateTime::Inv_Year )
 460     {
 461         tmNow = wxDateTime::GetTmNow(&tmstruct);
 462
 463         *year = 1900 + tmNow->tm_year;
 464     }
 465
 466     if ( *month == wxDateTime::Inv_Month )
 467     {
 468         if ( !tmNow )
 469             tmNow = wxDateTime::GetTmNow(&tmstruct);
 470
 471         *month = (wxDateTime::Month)tmNow->tm_mon;
 472     }
 473 }
 474
 475 // fill the struct tm with default values
 476 // NOTE: not static because used by datetimefmt.cpp
 477 void InitTm(struct tm& tm)
 478 {
 479     // struct tm may have etxra fields (undocumented and with unportable
 480     // names) which, nevertheless, must be set to 0
 481     memset(&tm, 0, sizeof(struct tm));
 482
 483     tm.tm_mday = 1;   // mday 0 is invalid
 484     tm.tm_year = 76;  // any valid year
 485     tm.tm_isdst = -1; // auto determine
 486 }
 487
 488 // ============================================================================
 489 // implementation of wxDateTime
 490 // ============================================================================
 491
 492 // ----------------------------------------------------------------------------
 493 // struct Tm
 494 // ----------------------------------------------------------------------------
 495
 496 wxDateTime::Tm::Tm()
 497 {
 498     year = (wxDateTime_t)wxDateTime::Inv_Year;
 499     mon = wxDateTime::Inv_Month;
 500     mday =
 501     yday = 0;
 502     hour =
 503     min =
 504     sec =
 505     msec = 0;
 506     wday = wxDateTime::Inv_WeekDay;
 507 }
 508
 509 wxDateTime::Tm::Tm(const struct tm& tm, const TimeZone& tz)
 510               : m_tz(tz)
 511 {
 512     msec = 0;
 513     sec = (wxDateTime::wxDateTime_t)tm.tm_sec;
 514     min = (wxDateTime::wxDateTime_t)tm.tm_min;
 515     hour = (wxDateTime::wxDateTime_t)tm.tm_hour;
 516     mday = (wxDateTime::wxDateTime_t)tm.tm_mday;
 517     mon = (wxDateTime::Month)tm.tm_mon;
 518     year = 1900 + tm.tm_year;
 519     wday = (wxDateTime::wxDateTime_t)tm.tm_wday;
 520     yday = (wxDateTime::wxDateTime_t)tm.tm_yday;
 521 }
 522
 523 bool wxDateTime::Tm::IsValid() const
 524 {
 525     if ( mon == wxDateTime::Inv_Month )
 526         return false;
 527
 528     // We need to check this here to avoid crashing in GetNumOfDaysInMonth() if
 529     // somebody passed us "(wxDateTime::Month)1000".
 530     wxCHECK_MSG( mon >= wxDateTime::Jan && mon < wxDateTime::Inv_Month, false,
 531                  wxS("Invalid month value") );
 532
 533     // we allow for the leap seconds, although we don't use them (yet)
 534     return (year != wxDateTime::Inv_Year) && (mon != wxDateTime::Inv_Month) &&
 535            (mday > 0 && mday <= GetNumOfDaysInMonth(year, mon)) &&
 536            (hour < 24) && (min < 60) && (sec < 62) && (msec < 1000);
 537 }
 538
 539 void wxDateTime::Tm::ComputeWeekDay()
 540 {
 541     // compute the week day from day/month/year: we use the dumbest algorithm
 542     // possible: just compute our JDN and then use the (simple to derive)
 543     // formula: weekday = (JDN + 1.5) % 7
 544     wday = (wxDateTime::wxDateTime_t)((GetTruncatedJDN(mday, mon, year) + 2) % 7);
 545 }
 546
 547 void wxDateTime::Tm::AddMonths(int monDiff)
 548 {
 549     // normalize the months field
 550     while ( monDiff < -mon )
 551     {
 552         year--;
 553
 554         monDiff += MONTHS_IN_YEAR;
 555     }
 556
 557     while ( monDiff + mon >= MONTHS_IN_YEAR )
 558     {
 559         year++;
 560
 561         monDiff -= MONTHS_IN_YEAR;
 562     }
 563
 564     mon = (wxDateTime::Month)(mon + monDiff);
 565
 566     wxASSERT_MSG( mon >= 0 && mon < MONTHS_IN_YEAR, wxT("logic error") );
 567
 568     // NB: we don't check here that the resulting date is valid, this function
 569     //     is private and the caller must check it if needed
 570 }
 571
 572 void wxDateTime::Tm::AddDays(int dayDiff)
 573 {
 574     // normalize the days field
 575     while ( dayDiff + mday < 1 )
 576     {
 577         AddMonths(-1);
 578
 579         dayDiff += GetNumOfDaysInMonth(year, mon);
 580     }
 581
 582     mday = (wxDateTime::wxDateTime_t)( mday + dayDiff );
 583     while ( mday > GetNumOfDaysInMonth(year, mon) )
 584     {
 585         mday -= GetNumOfDaysInMonth(year, mon);
 586
 587         AddMonths(1);
 588     }
 589
 590     wxASSERT_MSG( mday > 0 && mday <= GetNumOfDaysInMonth(year, mon),
 591                   wxT("logic error") );
 592 }
 593
 594 // ----------------------------------------------------------------------------
 595 // class TimeZone
 596 // ----------------------------------------------------------------------------
 597
 598 wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz)
 599 {
 600     switch ( tz )
 601     {
 602         case wxDateTime::Local:
 603             // get the offset from C RTL: it returns the difference GMT-local
 604             // while we want to have the offset _from_ GMT, hence the '-'
 605             m_offset = -GetTimeZone();
 606             break;
 607
 608         case wxDateTime::GMT_12:
 609         case wxDateTime::GMT_11:
 610         case wxDateTime::GMT_10:
 611         case wxDateTime::GMT_9:
 612         case wxDateTime::GMT_8:
 613         case wxDateTime::GMT_7:
 614         case wxDateTime::GMT_6:
 615         case wxDateTime::GMT_5:
 616         case wxDateTime::GMT_4:
 617         case wxDateTime::GMT_3:
 618         case wxDateTime::GMT_2:
 619         case wxDateTime::GMT_1:
 620             m_offset = -3600*(wxDateTime::GMT0 - tz);
 621             break;
 622
 623         case wxDateTime::GMT0:
 624         case wxDateTime::GMT1:
 625         case wxDateTime::GMT2:
 626         case wxDateTime::GMT3:
 627         case wxDateTime::GMT4:
 628         case wxDateTime::GMT5:
 629         case wxDateTime::GMT6:
 630         case wxDateTime::GMT7:
 631         case wxDateTime::GMT8:
 632         case wxDateTime::GMT9:
 633         case wxDateTime::GMT10:
 634         case wxDateTime::GMT11:
 635         case wxDateTime::GMT12:
 636         case wxDateTime::GMT13:
 637             m_offset = 3600*(tz - wxDateTime::GMT0);
 638             break;
 639
 640         case wxDateTime::A_CST:
 641             // Central Standard Time in use in Australia = UTC + 9.5
 642             m_offset = 60l*(9*MIN_PER_HOUR + MIN_PER_HOUR/2);
 643             break;
 644
 645         default:
 646             wxFAIL_MSG( wxT("unknown time zone") );
 647     }
 648 }
 649
 650 // ----------------------------------------------------------------------------
 651 // static functions
 652 // ----------------------------------------------------------------------------
 653
 654 /* static */
 655 struct tm *wxDateTime::GetTmNow(struct tm *tmstruct)
 656 {
 657     time_t t = GetTimeNow();
 658     return wxLocaltime_r(&t, tmstruct);
 659 }
 660
 661 /* static */
 662 bool wxDateTime::IsLeapYear(int year, wxDateTime::Calendar cal)
 663 {
 664     if ( year == Inv_Year )
 665         year = GetCurrentYear();
 666
 667     if ( cal == Gregorian )
 668     {
 669         // in Gregorian calendar leap years are those divisible by 4 except
 670         // those divisible by 100 unless they're also divisible by 400
 671         // (in some countries, like Russia and Greece, additional corrections
 672         // exist, but they won't manifest themselves until 2700)
 673         return (year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0));
 674     }
 675     else if ( cal == Julian )
 676     {
 677         // in Julian calendar the rule is simpler
 678         return year % 4 == 0;
 679     }
 680     else
 681     {
 682         wxFAIL_MSG(wxT("unknown calendar"));
 683
 684         return false;
 685     }
 686 }
 687
 688 /* static */
 689 int wxDateTime::GetCentury(int year)
 690 {
 691     return year > 0 ? year / 100 : year / 100 - 1;
 692 }
 693
 694 /* static */
 695 int wxDateTime::ConvertYearToBC(int year)
 696 {
 697     // year 0 is BC 1
 698     return year > 0 ? year : year - 1;
 699 }
 700
 701 /* static */
 702 int wxDateTime::GetCurrentYear(wxDateTime::Calendar cal)
 703 {
 704     switch ( cal )
 705     {
 706         case Gregorian:
 707             return Now().GetYear();
 708
 709         case Julian:
 710             wxFAIL_MSG(wxT("TODO"));
 711             break;
 712
 713         default:
 714             wxFAIL_MSG(wxT("unsupported calendar"));
 715             break;
 716     }
 717
 718     return Inv_Year;
 719 }
 720
 721 /* static */
 722 wxDateTime::Month wxDateTime::GetCurrentMonth(wxDateTime::Calendar cal)
 723 {
 724     switch ( cal )
 725     {
 726         case Gregorian:
 727             return Now().GetMonth();
 728
 729         case Julian:
 730             wxFAIL_MSG(wxT("TODO"));
 731             break;
 732
 733         default:
 734             wxFAIL_MSG(wxT("unsupported calendar"));
 735             break;
 736     }
 737
 738     return Inv_Month;
 739 }
 740
 741 /* static */
 742 wxDateTime::wxDateTime_t wxDateTime::GetNumberOfDays(int year, Calendar cal)
 743 {
 744     if ( year == Inv_Year )
 745     {
 746         // take the current year if none given
 747         year = GetCurrentYear();
 748     }
 749
 750     switch ( cal )
 751     {
 752         case Gregorian:
 753         case Julian:
 754             return IsLeapYear(year) ? 366 : 365;
 755
 756         default:
 757             wxFAIL_MSG(wxT("unsupported calendar"));
 758             break;
 759     }
 760
 761     return 0;
 762 }
 763
 764 /* static */
 765 wxDateTime::wxDateTime_t wxDateTime::GetNumberOfDays(wxDateTime::Month month,
 766                                                      int year,
 767                                                      wxDateTime::Calendar cal)
 768 {
 769     wxCHECK_MSG( month < MONTHS_IN_YEAR, 0, wxT("invalid month") );
 770
 771     if ( cal == Gregorian || cal == Julian )
 772     {
 773         if ( year == Inv_Year )
 774         {
 775             // take the current year if none given
 776             year = GetCurrentYear();
 777         }
 778
 779         return GetNumOfDaysInMonth(year, month);
 780     }
 781     else
 782     {
 783         wxFAIL_MSG(wxT("unsupported calendar"));
 784
 785         return 0;
 786     }
 787 }
 788
 789 namespace
 790 {
 791
 792 // helper function used by GetEnglish/WeekDayName(): returns 0 if flags is
 793 // Name_Full and 1 if it is Name_Abbr or -1 if the flags is incorrect (and
 794 // asserts in this case)
 795 //
 796 // the return value of this function is used as an index into 2D array
 797 // containing full names in its first row and abbreviated ones in the 2nd one
 798 int NameArrayIndexFromFlag(wxDateTime::NameFlags flags)
 799 {
 800     switch ( flags )
 801     {
 802         case wxDateTime::Name_Full:
 803             return 0;
 804
 805         case wxDateTime::Name_Abbr:
 806             return 1;
 807
 808         default:
 809             wxFAIL_MSG( "unknown wxDateTime::NameFlags value" );
 810     }
 811
 812     return -1;
 813 }
 814
 815 } // anonymous namespace
 816
 817 /* static */
 818 wxString wxDateTime::GetEnglishMonthName(Month month, NameFlags flags)
 819 {
 820     wxCHECK_MSG( month != Inv_Month, wxEmptyString, "invalid month" );
 821
 822     static const char *const monthNames[2][MONTHS_IN_YEAR] =
 823     {
 824         { "January", "February", "March", "April", "May", "June",
 825           "July", "August", "September", "October", "November", "December" },
 826         { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
 827           "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }
 828     };
 829
 830     const int idx = NameArrayIndexFromFlag(flags);
 831     if ( idx == -1 )
 832         return wxString();
 833
 834     return monthNames[idx][month];
 835 }
 836
 837 /* static */
 838 wxString wxDateTime::GetMonthName(wxDateTime::Month month,
 839                                   wxDateTime::NameFlags flags)
 840 {
 841 #ifdef wxHAS_STRFTIME
 842     wxCHECK_MSG( month != Inv_Month, wxEmptyString, wxT("invalid month") );
 843
 844     // notice that we must set all the fields to avoid confusing libc (GNU one
 845     // gets confused to a crash if we don't do this)
 846     tm tm;
 847     InitTm(tm);
 848     tm.tm_mon = month;
 849
 850     return CallStrftime(flags == Name_Abbr ? wxT("%b") : wxT("%B"), &tm);
 851 #else // !wxHAS_STRFTIME
 852     return GetEnglishMonthName(month, flags);
 853 #endif // wxHAS_STRFTIME/!wxHAS_STRFTIME
 854 }
 855
 856 /* static */
 857 wxString wxDateTime::GetEnglishWeekDayName(WeekDay wday, NameFlags flags)
 858 {
 859     wxCHECK_MSG( wday != Inv_WeekDay, wxEmptyString, wxT("invalid weekday") );
 860
 861     static const char *const weekdayNames[2][DAYS_PER_WEEK] =
 862     {
 863         { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday",
 864           "Saturday" },
 865         { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" },
 866     };
 867
 868     const int idx = NameArrayIndexFromFlag(flags);
 869     if ( idx == -1 )
 870         return wxString();
 871
 872     return weekdayNames[idx][wday];
 873 }
 874
 875 /* static */
 876 wxString wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday,
 877                                     wxDateTime::NameFlags flags)
 878 {
 879 #ifdef wxHAS_STRFTIME
 880     wxCHECK_MSG( wday != Inv_WeekDay, wxEmptyString, wxT("invalid weekday") );
 881
 882     // take some arbitrary Sunday (but notice that the day should be such that
 883     // after adding wday to it below we still have a valid date, e.g. don't
 884     // take 28 here!)
 885     tm tm;
 886     InitTm(tm);
 887     tm.tm_mday = 21;
 888     tm.tm_mon = Nov;
 889     tm.tm_year = 99;
 890
 891     // and offset it by the number of days needed to get the correct wday
 892     tm.tm_mday += wday;
 893
 894     // call mktime() to normalize it...
 895     (void)mktime(&tm);
 896
 897     // ... and call strftime()
 898     return CallStrftime(flags == Name_Abbr ? wxT("%a") : wxT("%A"), &tm);
 899 #else // !wxHAS_STRFTIME
 900     return GetEnglishWeekDayName(wday, flags);
 901 #endif // wxHAS_STRFTIME/!wxHAS_STRFTIME
 902 }
 903
 904 /* static */
 905 void wxDateTime::GetAmPmStrings(wxString *am, wxString *pm)
 906 {
 907     tm tm;
 908     InitTm(tm);
 909     wxChar buffer[64];
 910     // @Note: Do not call 'CallStrftime' here! CallStrftime checks the return code
 911     // and causes an assertion failed if the buffer is to small (which is good) - OR -
 912     // if strftime does not return anything because the format string is invalid - OR -
 913     // if there are no 'am' / 'pm' tokens defined for the current locale (which is not good).
 914     // wxDateTime::ParseTime will try several different formats to parse the time.
 915     // As a result, GetAmPmStrings might get called, even if the current locale
 916     // does not define any 'am' / 'pm' tokens. In this case, wxStrftime would
 917     // assert, even though it is a perfectly legal use.
 918     if ( am )
 919     {
 920         if (wxStrftime(buffer, WXSIZEOF(buffer), wxT("%p"), &tm) > 0)
 921             *am = wxString(buffer);
 922         else
 923             *am = wxString();
 924     }
 925     if ( pm )
 926     {
 927         tm.tm_hour = 13;
 928         if (wxStrftime(buffer, WXSIZEOF(buffer), wxT("%p"), &tm) > 0)
 929             *pm = wxString(buffer);
 930         else
 931             *pm = wxString();
 932     }
 933 }
 934
 935
 936 // ----------------------------------------------------------------------------
 937 // Country stuff: date calculations depend on the country (DST, work days,
 938 // ...), so we need to know which rules to follow.
 939 // ----------------------------------------------------------------------------
 940
 941 /* static */
 942 wxDateTime::Country wxDateTime::GetCountry()
 943 {
 944     // TODO use LOCALE_ICOUNTRY setting under Win32
 945 #ifndef __WXWINCE__
 946     if ( ms_country == Country_Unknown )
 947     {
 948         // try to guess from the time zone name
 949         time_t t = time(NULL);
 950         struct tm tmstruct;
 951         struct tm *tm = wxLocaltime_r(&t, &tmstruct);
 952
 953         wxString tz = CallStrftime(wxT("%Z"), tm);
 954         if ( tz == wxT("WET") || tz == wxT("WEST") )
 955         {
 956             ms_country = UK;
 957         }
 958         else if ( tz == wxT("CET") || tz == wxT("CEST") )
 959         {
 960             ms_country = Country_EEC;
 961         }
 962         else if ( tz == wxT("MSK") || tz == wxT("MSD") )
 963         {
 964             ms_country = Russia;
 965         }
 966         else if ( tz == wxT("AST") || tz == wxT("ADT") ||
 967                   tz == wxT("EST") || tz == wxT("EDT") ||
 968                   tz == wxT("CST") || tz == wxT("CDT") ||
 969                   tz == wxT("MST") || tz == wxT("MDT") ||
 970                   tz == wxT("PST") || tz == wxT("PDT") )
 971         {
 972             ms_country = USA;
 973         }
 974         else
 975         {
 976             // well, choose a default one
 977             ms_country = USA;
 978         }
 979     }
 980 #else // __WXWINCE__
 981      ms_country = USA;
 982 #endif // !__WXWINCE__/__WXWINCE__
 983
 984     return ms_country;
 985 }
 986
 987 /* static */
 988 void wxDateTime::SetCountry(wxDateTime::Country country)
 989 {
 990     ms_country = country;
 991 }
 992
 993 /* static */
 994 bool wxDateTime::IsWestEuropeanCountry(Country country)
 995 {
 996     if ( country == Country_Default )
 997     {
 998         country = GetCountry();
 999     }
1000
1001     return (Country_WesternEurope_Start <= country) &&
1002            (country <= Country_WesternEurope_End);
1003 }
1004
1005 // ----------------------------------------------------------------------------
1006 // DST calculations: we use 3 different rules for the West European countries,
1007 // USA and for the rest of the world. This is undoubtedly false for many
1008 // countries, but I lack the necessary info (and the time to gather it),
1009 // please add the other rules here!
1010 // ----------------------------------------------------------------------------
1011
1012 /* static */
1013 bool wxDateTime::IsDSTApplicable(int year, Country country)
1014 {
1015     if ( year == Inv_Year )
1016     {
1017         // take the current year if none given
1018         year = GetCurrentYear();
1019     }
1020
1021     if ( country == Country_Default )
1022     {
1023         country = GetCountry();
1024     }
1025
1026     switch ( country )
1027     {
1028         case USA:
1029         case UK:
1030             // DST was first observed in the US and UK during WWI, reused
1031             // during WWII and used again since 1966
1032             return year >= 1966 ||
1033                    (year >= 1942 && year <= 1945) ||
1034                    (year == 1918 || year == 1919);
1035
1036         default:
1037             // assume that it started after WWII
1038             return year > 1950;
1039     }
1040 }
1041
1042 /* static */
1043 wxDateTime wxDateTime::GetBeginDST(int year, Country country)
1044 {
1045     if ( year == Inv_Year )
1046     {
1047         // take the current year if none given
1048         year = GetCurrentYear();
1049     }
1050
1051     if ( country == Country_Default )
1052     {
1053         country = GetCountry();
1054     }
1055
1056     if ( !IsDSTApplicable(year, country) )
1057     {
1058         return wxInvalidDateTime;
1059     }
1060
1061     wxDateTime dt;
1062
1063     if ( IsWestEuropeanCountry(country) || (country == Russia) )
1064     {
1065         // DST begins at 1 a.m. GMT on the last Sunday of March
1066         if ( !dt.SetToLastWeekDay(Sun, Mar, year) )
1067         {
1068             // weird...
1069             wxFAIL_MSG( wxT("no last Sunday in March?") );
1070         }
1071
1072         dt += wxTimeSpan::Hours(1);
1073     }
1074     else switch ( country )
1075     {
1076         case USA:
1077             switch ( year )
1078             {
1079                 case 1918:
1080                 case 1919:
1081                     // don't know for sure - assume it was in effect all year
1082
1083                 case 1943:
1084                 case 1944:
1085                 case 1945:
1086                     dt.Set(1, Jan, year);
1087                     break;
1088
1089                 case 1942:
1090                     // DST was installed Feb 2, 1942 by the Congress
1091                     dt.Set(2, Feb, year);
1092                     break;
1093
1094                     // Oil embargo changed the DST period in the US
1095                 case 1974:
1096                     dt.Set(6, Jan, 1974);
1097                     break;
1098
1099                 case 1975:
1100                     dt.Set(23, Feb, 1975);
1101                     break;
1102
1103                 default:
1104                     // before 1986, DST begun on the last Sunday of April, but
1105                     // in 1986 Reagan changed it to begin at 2 a.m. of the
1106                     // first Sunday in April
1107                     if ( year < 1986 )
1108                     {
1109                         if ( !dt.SetToLastWeekDay(Sun, Apr, year) )
1110                         {
1111                             // weird...
1112                             wxFAIL_MSG( wxT("no first Sunday in April?") );
1113                         }
1114                     }
1115                     else if ( year > 2006 )
1116                     // Energy Policy Act of 2005, Pub. L. no. 109-58, 119 Stat 594 (2005).
1117                     // Starting in 2007, daylight time begins in the United States on the
1118                     // second Sunday in March and ends on the first Sunday in November
1119                     {
1120                         if ( !dt.SetToWeekDay(Sun, 2, Mar, year) )
1121                         {
1122                             // weird...
1123                             wxFAIL_MSG( wxT("no second Sunday in March?") );
1124                         }
1125                     }
1126                     else
1127                     {
1128                         if ( !dt.SetToWeekDay(Sun, 1, Apr, year) )
1129                         {
1130                             // weird...
1131                             wxFAIL_MSG( wxT("no first Sunday in April?") );
1132                         }
1133                     }
1134
1135                     dt += wxTimeSpan::Hours(2);
1136
1137                     // TODO what about timezone??
1138             }
1139
1140             break;
1141
1142         default:
1143             // assume Mar 30 as the start of the DST for the rest of the world
1144             // - totally bogus, of course
1145             dt.Set(30, Mar, year);
1146     }
1147
1148     return dt;
1149 }
1150
1151 /* static */
1152 wxDateTime wxDateTime::GetEndDST(int year, Country country)
1153 {
1154     if ( year == Inv_Year )
1155     {
1156         // take the current year if none given
1157         year = GetCurrentYear();
1158     }
1159
1160     if ( country == Country_Default )
1161     {
1162         country = GetCountry();
1163     }
1164
1165     if ( !IsDSTApplicable(year, country) )
1166     {
1167         return wxInvalidDateTime;
1168     }
1169
1170     wxDateTime dt;
1171
1172     if ( IsWestEuropeanCountry(country) || (country == Russia) )
1173     {
1174         // DST ends at 1 a.m. GMT on the last Sunday of October
1175         if ( !dt.SetToLastWeekDay(Sun, Oct, year) )
1176         {
1177             // weirder and weirder...
1178             wxFAIL_MSG( wxT("no last Sunday in October?") );
1179         }
1180
1181         dt += wxTimeSpan::Hours(1);
1182     }
1183     else switch ( country )
1184     {
1185         case USA:
1186             switch ( year )
1187             {
1188                 case 1918:
1189                 case 1919:
1190                     // don't know for sure - assume it was in effect all year
1191
1192                 case 1943:
1193                 case 1944:
1194                     dt.Set(31, Dec, year);
1195                     break;
1196
1197                 case 1945:
1198                     // the time was reset after the end of the WWII
1199                     dt.Set(30, Sep, year);
1200                     break;
1201
1202                 default: // default for switch (year)
1203                     if ( year > 2006 )
1204                       // Energy Policy Act of 2005, Pub. L. no. 109-58, 119 Stat 594 (2005).
1205                       // Starting in 2007, daylight time begins in the United States on the
1206                       // second Sunday in March and ends on the first Sunday in November
1207                     {
1208                         if ( !dt.SetToWeekDay(Sun, 1, Nov, year) )
1209                         {
1210                             // weird...
1211                             wxFAIL_MSG( wxT("no first Sunday in November?") );
1212                         }
1213                     }
1214                     else
1215                      // pre-2007
1216                      // DST ends at 2 a.m. on the last Sunday of October
1217                     {
1218                         if ( !dt.SetToLastWeekDay(Sun, Oct, year) )
1219                         {
1220                             // weirder and weirder...
1221                             wxFAIL_MSG( wxT("no last Sunday in October?") );
1222                         }
1223                     }
1224
1225                     dt += wxTimeSpan::Hours(2);
1226
1227             // TODO: what about timezone??
1228             }
1229             break;
1230
1231         default: // default for switch (country)
1232             // assume October 26th as the end of the DST - totally bogus too
1233             dt.Set(26, Oct, year);
1234     }
1235
1236     return dt;
1237 }
1238
1239 // ----------------------------------------------------------------------------
1240 // constructors and assignment operators
1241 // ----------------------------------------------------------------------------
1242
1243 // return the current time with ms precision
1244 /* static */ wxDateTime wxDateTime::UNow()
1245 {
1246     return wxDateTime(wxGetLocalTimeMillis());
1247 }
1248
1249 // the values in the tm structure contain the local time
1250 wxDateTime& wxDateTime::Set(const struct tm& tm)
1251 {
1252     struct tm tm2(tm);
1253     time_t timet = mktime(&tm2);
1254
1255     if ( timet == (time_t)-1 )
1256     {
1257         // mktime() rather unintuitively fails for Jan 1, 1970 if the hour is
1258         // less than timezone - try to make it work for this case
1259         if ( tm2.tm_year == 70 && tm2.tm_mon == 0 && tm2.tm_mday == 1 )
1260         {
1261             return Set((time_t)(
1262                        GetTimeZone() +
1263                        tm2.tm_hour * MIN_PER_HOUR * SEC_PER_MIN +
1264                        tm2.tm_min * SEC_PER_MIN +
1265                        tm2.tm_sec));
1266         }
1267
1268         wxFAIL_MSG( wxT("mktime() failed") );
1269
1270         *this = wxInvalidDateTime;
1271
1272         return *this;
1273     }
1274     else
1275     {
1276         return Set(timet);
1277     }
1278 }
1279
1280 wxDateTime& wxDateTime::Set(wxDateTime_t hour,
1281                             wxDateTime_t minute,
1282                             wxDateTime_t second,
1283                             wxDateTime_t millisec)
1284 {
1285     // we allow seconds to be 61 to account for the leap seconds, even if we
1286     // don't use them really
1287     wxDATETIME_CHECK( hour < 24 &&
1288                       second < 62 &&
1289                       minute < 60 &&
1290                       millisec < 1000,
1291                       wxT("Invalid time in wxDateTime::Set()") );
1292
1293     // get the current date from system
1294     struct tm tmstruct;
1295     struct tm *tm = GetTmNow(&tmstruct);
1296
1297     wxDATETIME_CHECK( tm, wxT("wxLocaltime_r() failed") );
1298
1299     // make a copy so it isn't clobbered by the call to mktime() below
1300     struct tm tm1(*tm);
1301
1302     // adjust the time
1303     tm1.tm_hour = hour;
1304     tm1.tm_min = minute;
1305     tm1.tm_sec = second;
1306
1307     // and the DST in case it changes on this date
1308     struct tm tm2(tm1);
1309     mktime(&tm2);
1310     if ( tm2.tm_isdst != tm1.tm_isdst )
1311         tm1.tm_isdst = tm2.tm_isdst;
1312
1313     (void)Set(tm1);
1314
1315     // and finally adjust milliseconds
1316     return SetMillisecond(millisec);
1317 }
1318
1319 wxDateTime& wxDateTime::Set(wxDateTime_t day,
1320                             Month        month,
1321                             int          year,
1322                             wxDateTime_t hour,
1323                             wxDateTime_t minute,
1324                             wxDateTime_t second,
1325                             wxDateTime_t millisec)
1326 {
1327     wxDATETIME_CHECK( hour < 24 &&
1328                       second < 62 &&
1329                       minute < 60 &&
1330                       millisec < 1000,
1331                       wxT("Invalid time in wxDateTime::Set()") );
1332
1333     ReplaceDefaultYearMonthWithCurrent(&year, &month);
1334
1335     wxDATETIME_CHECK( (0 < day) && (day <= GetNumberOfDays(month, year)),
1336                       wxT("Invalid date in wxDateTime::Set()") );
1337
1338     // the range of time_t type (inclusive)
1339     static const int yearMinInRange = 1970;
1340     static const int yearMaxInRange = 2037;
1341
1342     // test only the year instead of testing for the exact end of the Unix
1343     // time_t range - it doesn't bring anything to do more precise checks
1344     if ( year >= yearMinInRange && year <= yearMaxInRange )
1345     {
1346         // use the standard library version if the date is in range - this is
1347         // probably more efficient than our code
1348         struct tm tm;
1349         tm.tm_year = year - 1900;
1350         tm.tm_mon = month;
1351         tm.tm_mday = day;
1352         tm.tm_hour = hour;
1353         tm.tm_min = minute;
1354         tm.tm_sec = second;
1355         tm.tm_isdst = -1;       // mktime() will guess it
1356
1357         (void)Set(tm);
1358
1359         // and finally adjust milliseconds
1360         if (IsValid())
1361             SetMillisecond(millisec);
1362
1363         return *this;
1364     }
1365     else
1366     {
1367         // do time calculations ourselves: we want to calculate the number of
1368         // milliseconds between the given date and the epoch
1369
1370         // get the JDN for the midnight of this day
1371         m_time = GetTruncatedJDN(day, month, year);
1372         m_time -= EPOCH_JDN;
1373         m_time *= SECONDS_PER_DAY * TIME_T_FACTOR;
1374
1375         // JDN corresponds to GMT, we take localtime
1376         Add(wxTimeSpan(hour, minute, second + GetTimeZone(), millisec));
1377     }
1378
1379     return *this;
1380 }
1381
1382 wxDateTime& wxDateTime::Set(double jdn)
1383 {
1384     // so that m_time will be 0 for the midnight of Jan 1, 1970 which is jdn
1385     // EPOCH_JDN + 0.5
1386     jdn -= EPOCH_JDN + 0.5;
1387
1388     m_time.Assign(jdn*MILLISECONDS_PER_DAY);
1389
1390     // JDNs always are in UTC, so we don't need any adjustments for time zone
1391
1392     return *this;
1393 }
1394
1395 wxDateTime& wxDateTime::ResetTime()
1396 {
1397     Tm tm = GetTm();
1398
1399     if ( tm.hour || tm.min || tm.sec || tm.msec )
1400     {
1401         tm.msec =
1402         tm.sec =
1403         tm.min =
1404         tm.hour = 0;
1405
1406         Set(tm);
1407     }
1408
1409     return *this;
1410 }
1411
1412 wxDateTime wxDateTime::GetDateOnly() const
1413 {
1414     Tm tm = GetTm();
1415     tm.msec =
1416     tm.sec =
1417     tm.min =
1418     tm.hour = 0;
1419     return wxDateTime(tm);
1420 }
1421
1422 // ----------------------------------------------------------------------------
1423 // DOS Date and Time Format functions
1424 // ----------------------------------------------------------------------------
1425 // the dos date and time value is an unsigned 32 bit value in the format:
1426 // YYYYYYYMMMMDDDDDhhhhhmmmmmmsssss
1427 //
1428 // Y = year offset from 1980 (0-127)
1429 // M = month (1-12)
1430 // D = day of month (1-31)
1431 // h = hour (0-23)
1432 // m = minute (0-59)
1433 // s = bisecond (0-29) each bisecond indicates two seconds
1434 // ----------------------------------------------------------------------------
1435
1436 wxDateTime& wxDateTime::SetFromDOS(unsigned long ddt)
1437 {
1438     struct tm tm;
1439     InitTm(tm);
1440
1441     long year = ddt & 0xFE000000;
1442     year >>= 25;
1443     year += 80;
1444     tm.tm_year = year;
1445
1446     long month = ddt & 0x1E00000;
1447     month >>= 21;
1448     month -= 1;
1449     tm.tm_mon = month;
1450
1451     long day = ddt & 0x1F0000;
1452     day >>= 16;
1453     tm.tm_mday = day;
1454
1455     long hour = ddt & 0xF800;
1456     hour >>= 11;
1457     tm.tm_hour = hour;
1458
1459     long minute = ddt & 0x7E0;
1460     minute >>= 5;
1461     tm.tm_min = minute;
1462
1463     long second = ddt & 0x1F;
1464     tm.tm_sec = second * 2;
1465
1466     return Set(mktime(&tm));
1467 }
1468
1469 unsigned long wxDateTime::GetAsDOS() const
1470 {
1471     unsigned long ddt;
1472     time_t ticks = GetTicks();
1473     struct tm tmstruct;
1474     struct tm *tm = wxLocaltime_r(&ticks, &tmstruct);
1475     wxCHECK_MSG( tm, ULONG_MAX, wxT("time can't be represented in DOS format") );
1476
1477     long year = tm->tm_year;
1478     year -= 80;
1479     year <<= 25;
1480
1481     long month = tm->tm_mon;
1482     month += 1;
1483     month <<= 21;
1484
1485     long day = tm->tm_mday;
1486     day <<= 16;
1487
1488     long hour = tm->tm_hour;
1489     hour <<= 11;
1490
1491     long minute = tm->tm_min;
1492     minute <<= 5;
1493
1494     long second = tm->tm_sec;
1495     second /= 2;
1496
1497     ddt = year | month | day | hour | minute | second;
1498     return ddt;
1499 }
1500
1501 // ----------------------------------------------------------------------------
1502 // time_t <-> broken down time conversions
1503 // ----------------------------------------------------------------------------
1504
1505 wxDateTime::Tm wxDateTime::GetTm(const TimeZone& tz) const
1506 {
1507     wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1508
1509     time_t time = GetTicks();
1510     if ( time != (time_t)-1 )
1511     {
1512         // use C RTL functions
1513         struct tm tmstruct;
1514         tm *tm;
1515         if ( tz.GetOffset() == -GetTimeZone() )
1516         {
1517             // we are working with local time
1518             tm = wxLocaltime_r(&time, &tmstruct);
1519
1520             // should never happen
1521             wxCHECK_MSG( tm, Tm(), wxT("wxLocaltime_r() failed") );
1522         }
1523         else
1524         {
1525             time += (time_t)tz.GetOffset();
1526 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
1527             int time2 = (int) time;
1528             if ( time2 >= 0 )
1529 #else
1530             if ( time >= 0 )
1531 #endif
1532             {
1533                 tm = wxGmtime_r(&time, &tmstruct);
1534
1535                 // should never happen
1536                 wxCHECK_MSG( tm, Tm(), wxT("wxGmtime_r() failed") );
1537             }
1538             else
1539             {
1540                 tm = (struct tm *)NULL;
1541             }
1542         }
1543
1544         if ( tm )
1545         {
1546             // adjust the milliseconds
1547             Tm tm2(*tm, tz);
1548             long timeOnly = (m_time % MILLISECONDS_PER_DAY).ToLong();
1549             tm2.msec = (wxDateTime_t)(timeOnly % 1000);
1550             return tm2;
1551         }
1552         //else: use generic code below
1553     }
1554
1555     // remember the time and do the calculations with the date only - this
1556     // eliminates rounding errors of the floating point arithmetics
1557
1558     wxLongLong timeMidnight = m_time + tz.GetOffset() * 1000;
1559
1560     long timeOnly = (timeMidnight % MILLISECONDS_PER_DAY).ToLong();
1561
1562     // we want to always have positive time and timeMidnight to be really
1563     // the midnight before it
1564     if ( timeOnly < 0 )
1565     {
1566         timeOnly = MILLISECONDS_PER_DAY + timeOnly;
1567     }
1568
1569     timeMidnight -= timeOnly;
1570
1571     // calculate the Gregorian date from JDN for the midnight of our date:
1572     // this will yield day, month (in 1..12 range) and year
1573
1574     // actually, this is the JDN for the noon of the previous day
1575     long jdn = (timeMidnight / MILLISECONDS_PER_DAY).ToLong() + EPOCH_JDN;
1576
1577     // CREDIT: code below is by Scott E. Lee (but bugs are mine)
1578
1579     wxASSERT_MSG( jdn > -2, wxT("JDN out of range") );
1580
1581     // calculate the century
1582     long temp = (jdn + JDN_OFFSET) * 4 - 1;
1583     long century = temp / DAYS_PER_400_YEARS;
1584
1585     // then the year and day of year (1 <= dayOfYear <= 366)
1586     temp = ((temp % DAYS_PER_400_YEARS) / 4) * 4 + 3;
1587     long year = (century * 100) + (temp / DAYS_PER_4_YEARS);
1588     long dayOfYear = (temp % DAYS_PER_4_YEARS) / 4 + 1;
1589
1590     // and finally the month and day of the month
1591     temp = dayOfYear * 5 - 3;
1592     long month = temp / DAYS_PER_5_MONTHS;
1593     long day = (temp % DAYS_PER_5_MONTHS) / 5 + 1;
1594
1595     // month is counted from March - convert to normal
1596     if ( month < 10 )
1597     {
1598         month += 3;
1599     }
1600     else
1601     {
1602         year += 1;
1603         month -= 9;
1604     }
1605
1606     // year is offset by 4800
1607     year -= 4800;
1608
1609     // check that the algorithm gave us something reasonable
1610     wxASSERT_MSG( (0 < month) && (month <= 12), wxT("invalid month") );
1611     wxASSERT_MSG( (1 <= day) && (day < 32), wxT("invalid day") );
1612
1613     // construct Tm from these values
1614     Tm tm;
1615     tm.year = (int)year;
1616     tm.yday = (wxDateTime_t)(dayOfYear - 1); // use C convention for day number
1617     tm.mon = (Month)(month - 1); // algorithm yields 1 for January, not 0
1618     tm.mday = (wxDateTime_t)day;
1619     tm.msec = (wxDateTime_t)(timeOnly % 1000);
1620     timeOnly -= tm.msec;
1621     timeOnly /= 1000;               // now we have time in seconds
1622
1623     tm.sec = (wxDateTime_t)(timeOnly % SEC_PER_MIN);
1624     timeOnly -= tm.sec;
1625     timeOnly /= SEC_PER_MIN;        // now we have time in minutes
1626
1627     tm.min = (wxDateTime_t)(timeOnly % MIN_PER_HOUR);
1628     timeOnly -= tm.min;
1629
1630     tm.hour = (wxDateTime_t)(timeOnly / MIN_PER_HOUR);
1631
1632     return tm;
1633 }
1634
1635 wxDateTime& wxDateTime::SetYear(int year)
1636 {
1637     wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1638
1639     Tm tm(GetTm());
1640     tm.year = year;
1641     Set(tm);
1642
1643     return *this;
1644 }
1645
1646 wxDateTime& wxDateTime::SetMonth(Month month)
1647 {
1648     wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1649
1650     Tm tm(GetTm());
1651     tm.mon = month;
1652     Set(tm);
1653
1654     return *this;
1655 }
1656
1657 wxDateTime& wxDateTime::SetDay(wxDateTime_t mday)
1658 {
1659     wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1660
1661     Tm tm(GetTm());
1662     tm.mday = mday;
1663     Set(tm);
1664
1665     return *this;
1666 }
1667
1668 wxDateTime& wxDateTime::SetHour(wxDateTime_t hour)
1669 {
1670     wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1671
1672     Tm tm(GetTm());
1673     tm.hour = hour;
1674     Set(tm);
1675
1676     return *this;
1677 }
1678
1679 wxDateTime& wxDateTime::SetMinute(wxDateTime_t min)
1680 {
1681     wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1682
1683     Tm tm(GetTm());
1684     tm.min = min;
1685     Set(tm);
1686
1687     return *this;
1688 }
1689
1690 wxDateTime& wxDateTime::SetSecond(wxDateTime_t sec)
1691 {
1692     wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1693
1694     Tm tm(GetTm());
1695     tm.sec = sec;
1696     Set(tm);
1697
1698     return *this;
1699 }
1700
1701 wxDateTime& wxDateTime::SetMillisecond(wxDateTime_t millisecond)
1702 {
1703     wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime") );
1704
1705     // we don't need to use GetTm() for this one
1706     m_time -= m_time % 1000l;
1707     m_time += millisecond;
1708
1709     return *this;
1710 }
1711
1712 // ----------------------------------------------------------------------------
1713 // wxDateTime arithmetics
1714 // ----------------------------------------------------------------------------
1715
1716 wxDateTime& wxDateTime::Add(const wxDateSpan& diff)
1717 {
1718     Tm tm(GetTm());
1719
1720     tm.year += diff.GetYears();
1721     tm.AddMonths(diff.GetMonths());
1722
1723     // check that the resulting date is valid
1724     if ( tm.mday > GetNumOfDaysInMonth(tm.year, tm.mon) )
1725     {
1726         // We suppose that when adding one month to Jan 31 we want to get Feb
1727         // 28 (or 29), i.e. adding a month to the last day of the month should
1728         // give the last day of the next month which is quite logical.
1729         //
1730         // Unfortunately, there is no logic way to understand what should
1731         // Jan 30 + 1 month be - Feb 28 too or Feb 27 (assuming non leap year)?
1732         // We make it Feb 28 (last day too), but it is highly questionable.
1733         tm.mday = GetNumOfDaysInMonth(tm.year, tm.mon);
1734     }
1735
1736     tm.AddDays(diff.GetTotalDays());
1737
1738     Set(tm);
1739
1740     wxASSERT_MSG( IsSameTime(tm),
1741                   wxT("Add(wxDateSpan) shouldn't modify time") );
1742
1743     return *this;
1744 }
1745
1746 // ----------------------------------------------------------------------------
1747 // Weekday and monthday stuff
1748 // ----------------------------------------------------------------------------
1749
1750 // convert Sun, Mon, ..., Sat into 6, 0, ..., 5
1751 static inline int ConvertWeekDayToMondayBase(int wd)
1752 {
1753     return wd == wxDateTime::Sun ? 6 : wd - 1;
1754 }
1755
1756 /* static */
1757 wxDateTime
1758 wxDateTime::SetToWeekOfYear(int year, wxDateTime_t numWeek, WeekDay wd)
1759 {
1760     wxASSERT_MSG( numWeek > 0,
1761                   wxT("invalid week number: weeks are counted from 1") );
1762
1763     // Jan 4 always lies in the 1st week of the year
1764     wxDateTime dt(4, Jan, year);
1765     dt.SetToWeekDayInSameWeek(wd);
1766     dt += wxDateSpan::Weeks(numWeek - 1);
1767
1768     return dt;
1769 }
1770
1771 #if WXWIN_COMPATIBILITY_2_6
1772 // use a separate function to avoid warnings about using deprecated
1773 // SetToTheWeek in GetWeek below
1774 static wxDateTime
1775 SetToTheWeek(int year,
1776              wxDateTime::wxDateTime_t numWeek,
1777              wxDateTime::WeekDay weekday,
1778              wxDateTime::WeekFlags flags)
1779 {
1780     // Jan 4 always lies in the 1st week of the year
1781     wxDateTime dt(4, wxDateTime::Jan, year);
1782     dt.SetToWeekDayInSameWeek(weekday, flags);
1783     dt += wxDateSpan::Weeks(numWeek - 1);
1784
1785     return dt;
1786 }
1787
1788 bool wxDateTime::SetToTheWeek(wxDateTime_t numWeek,
1789                               WeekDay weekday,
1790                               WeekFlags flags)
1791 {
1792     int year = GetYear();
1793     *this = ::SetToTheWeek(year, numWeek, weekday, flags);
1794     if ( GetYear() != year )
1795     {
1796         // oops... numWeek was too big
1797         return false;
1798     }
1799
1800     return true;
1801 }
1802
1803 wxDateTime wxDateTime::GetWeek(wxDateTime_t numWeek,
1804                                WeekDay weekday,
1805                                WeekFlags flags) const
1806 {
1807     return ::SetToTheWeek(GetYear(), numWeek, weekday, flags);
1808 }
1809 #endif // WXWIN_COMPATIBILITY_2_6
1810
1811 wxDateTime& wxDateTime::SetToLastMonthDay(Month month,
1812                                           int year)
1813 {
1814     // take the current month/year if none specified
1815     if ( year == Inv_Year )
1816         year = GetYear();
1817     if ( month == Inv_Month )
1818         month = GetMonth();
1819
1820     return Set(GetNumOfDaysInMonth(year, month), month, year);
1821 }
1822
1823 wxDateTime& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday, WeekFlags flags)
1824 {
1825     wxDATETIME_CHECK( weekday != Inv_WeekDay, wxT("invalid weekday") );
1826
1827     int wdayDst = weekday,
1828         wdayThis = GetWeekDay();
1829     if ( wdayDst == wdayThis )
1830     {
1831         // nothing to do
1832         return *this;
1833     }
1834
1835     if ( flags == Default_First )
1836     {
1837         flags = GetCountry() == USA ? Sunday_First : Monday_First;
1838     }
1839
1840     // the logic below based on comparing weekday and wdayThis works if Sun (0)
1841     // is the first day in the week, but breaks down for Monday_First case so
1842     // we adjust the week days in this case
1843     if ( flags == Monday_First )
1844     {
1845         if ( wdayThis == Sun )
1846             wdayThis += 7;
1847         if ( wdayDst == Sun )
1848             wdayDst += 7;
1849     }
1850     //else: Sunday_First, nothing to do
1851
1852     // go forward or back in time to the day we want
1853     if ( wdayDst < wdayThis )
1854     {
1855         return Subtract(wxDateSpan::Days(wdayThis - wdayDst));
1856     }
1857     else // weekday > wdayThis
1858     {
1859         return Add(wxDateSpan::Days(wdayDst - wdayThis));
1860     }
1861 }
1862
1863 wxDateTime& wxDateTime::SetToNextWeekDay(WeekDay weekday)
1864 {
1865     wxDATETIME_CHECK( weekday != Inv_WeekDay, wxT("invalid weekday") );
1866
1867     int diff;
1868     WeekDay wdayThis = GetWeekDay();
1869     if ( weekday == wdayThis )
1870     {
1871         // nothing to do
1872         return *this;
1873     }
1874     else if ( weekday < wdayThis )
1875     {
1876         // need to advance a week
1877         diff = 7 - (wdayThis - weekday);
1878     }
1879     else // weekday > wdayThis
1880     {
1881         diff = weekday - wdayThis;
1882     }
1883
1884     return Add(wxDateSpan::Days(diff));
1885 }
1886
1887 wxDateTime& wxDateTime::SetToPrevWeekDay(WeekDay weekday)
1888 {
1889     wxDATETIME_CHECK( weekday != Inv_WeekDay, wxT("invalid weekday") );
1890
1891     int diff;
1892     WeekDay wdayThis = GetWeekDay();
1893     if ( weekday == wdayThis )
1894     {
1895         // nothing to do
1896         return *this;
1897     }
1898     else if ( weekday > wdayThis )
1899     {
1900         // need to go to previous week
1901         diff = 7 - (weekday - wdayThis);
1902     }
1903     else // weekday < wdayThis
1904     {
1905         diff = wdayThis - weekday;
1906     }
1907
1908     return Subtract(wxDateSpan::Days(diff));
1909 }
1910
1911 bool wxDateTime::SetToWeekDay(WeekDay weekday,
1912                               int n,
1913                               Month month,
1914                               int year)
1915 {
1916     wxCHECK_MSG( weekday != Inv_WeekDay, false, wxT("invalid weekday") );
1917
1918     // we don't check explicitly that -5 <= n <= 5 because we will return false
1919     // anyhow in such case - but may be should still give an assert for it?
1920
1921     // take the current month/year if none specified
1922     ReplaceDefaultYearMonthWithCurrent(&year, &month);
1923
1924     wxDateTime dt;
1925
1926     // TODO this probably could be optimised somehow...
1927
1928     if ( n > 0 )
1929     {
1930         // get the first day of the month
1931         dt.Set(1, month, year);
1932
1933         // get its wday
1934         WeekDay wdayFirst = dt.GetWeekDay();
1935
1936         // go to the first weekday of the month
1937         int diff = weekday - wdayFirst;
1938         if ( diff < 0 )
1939             diff += 7;
1940
1941         // add advance n-1 weeks more
1942         diff += 7*(n - 1);
1943
1944         dt += wxDateSpan::Days(diff);
1945     }
1946     else // count from the end of the month
1947     {
1948         // get the last day of the month
1949         dt.SetToLastMonthDay(month, year);
1950
1951         // get its wday
1952         WeekDay wdayLast = dt.GetWeekDay();
1953
1954         // go to the last weekday of the month
1955         int diff = wdayLast - weekday;
1956         if ( diff < 0 )
1957             diff += 7;
1958
1959         // and rewind n-1 weeks from there
1960         diff += 7*(-n - 1);
1961
1962         dt -= wxDateSpan::Days(diff);
1963     }
1964
1965     // check that it is still in the same month
1966     if ( dt.GetMonth() == month )
1967     {
1968         *this = dt;
1969
1970         return true;
1971     }
1972     else
1973     {
1974         // no such day in this month
1975         return false;
1976     }
1977 }
1978
1979 static inline
1980 wxDateTime::wxDateTime_t GetDayOfYearFromTm(const wxDateTime::Tm& tm)
1981 {
1982     return (wxDateTime::wxDateTime_t)(gs_cumulatedDays[wxDateTime::IsLeapYear(tm.year)][tm.mon] + tm.mday);
1983 }
1984
1985 wxDateTime::wxDateTime_t wxDateTime::GetDayOfYear(const TimeZone& tz) const
1986 {
1987     return GetDayOfYearFromTm(GetTm(tz));
1988 }
1989
1990 wxDateTime::wxDateTime_t
1991 wxDateTime::GetWeekOfYear(wxDateTime::WeekFlags flags, const TimeZone& tz) const
1992 {
1993     if ( flags == Default_First )
1994     {
1995         flags = GetCountry() == USA ? Sunday_First : Monday_First;
1996     }
1997
1998     Tm tm(GetTm(tz));
1999     wxDateTime_t nDayInYear = GetDayOfYearFromTm(tm);
2000
2001     int wdTarget = GetWeekDay(tz);
2002     int wdYearStart = wxDateTime(1, Jan, GetYear()).GetWeekDay();
2003     int week;
2004     if ( flags == Sunday_First )
2005     {
2006         // FIXME: First week is not calculated correctly.
2007         week = (nDayInYear - wdTarget + 7) / 7;
2008         if ( wdYearStart == Wed || wdYearStart == Thu )
2009             week++;
2010     }
2011     else // week starts with monday
2012     {
2013         // adjust the weekdays to non-US style.
2014         wdYearStart = ConvertWeekDayToMondayBase(wdYearStart);
2015         wdTarget = ConvertWeekDayToMondayBase(wdTarget);
2016
2017         // quoting from http://www.cl.cam.ac.uk/~mgk25/iso-time.html:
2018         //
2019         //      Week 01 of a year is per definition the first week that has the
2020         //      Thursday in this year, which is equivalent to the week that
2021         //      contains the fourth day of January. In other words, the first
2022         //      week of a new year is the week that has the majority of its
2023         //      days in the new year. Week 01 might also contain days from the
2024         //      previous year and the week before week 01 of a year is the last
2025         //      week (52 or 53) of the previous year even if it contains days
2026         //      from the new year. A week starts with Monday (day 1) and ends
2027         //      with Sunday (day 7).
2028         //
2029
2030         // if Jan 1 is Thursday or less, it is in the first week of this year
2031         if ( wdYearStart < 4 )
2032         {
2033             // count the number of entire weeks between Jan 1 and this date
2034             week = (nDayInYear + wdYearStart + 6 - wdTarget)/7;
2035
2036             // be careful to check for overflow in the next year
2037             if ( week == 53 && tm.mday - wdTarget > 28 )
2038                     week = 1;
2039         }
2040         else // Jan 1 is in the last week of the previous year
2041         {
2042             // check if we happen to be at the last week of previous year:
2043             if ( tm.mon == Jan && tm.mday < 8 - wdYearStart )
2044                 week = wxDateTime(31, Dec, GetYear()-1).GetWeekOfYear();
2045             else
2046                 week = (nDayInYear + wdYearStart - 1 - wdTarget)/7;
2047         }
2048     }
2049
2050     return (wxDateTime::wxDateTime_t)week;
2051 }
2052
2053 wxDateTime::wxDateTime_t wxDateTime::GetWeekOfMonth(wxDateTime::WeekFlags flags,
2054                                                     const TimeZone& tz) const
2055 {
2056     Tm tm = GetTm(tz);
2057     const wxDateTime dateFirst = wxDateTime(1, tm.mon, tm.year);
2058     const wxDateTime::WeekDay wdFirst = dateFirst.GetWeekDay();
2059
2060     if ( flags == Default_First )
2061     {
2062         flags = GetCountry() == USA ? Sunday_First : Monday_First;
2063     }
2064
2065     // compute offset of dateFirst from the beginning of the week
2066     int firstOffset;
2067     if ( flags == Sunday_First )
2068         firstOffset = wdFirst - Sun;
2069     else
2070         firstOffset = wdFirst == Sun ? DAYS_PER_WEEK - 1 : wdFirst - Mon;
2071
2072     return (wxDateTime::wxDateTime_t)((tm.mday - 1 + firstOffset)/7 + 1);
2073 }
2074
2075 wxDateTime& wxDateTime::SetToYearDay(wxDateTime::wxDateTime_t yday)
2076 {
2077     int year = GetYear();
2078     wxDATETIME_CHECK( (0 < yday) && (yday <= GetNumberOfDays(year)),
2079                       wxT("invalid year day") );
2080
2081     bool isLeap = IsLeapYear(year);
2082     for ( Month mon = Jan; mon < Inv_Month; wxNextMonth(mon) )
2083     {
2084         // for Dec, we can't compare with gs_cumulatedDays[mon + 1], but we
2085         // don't need it neither - because of the CHECK above we know that
2086         // yday lies in December then
2087         if ( (mon == Dec) || (yday <= gs_cumulatedDays[isLeap][mon + 1]) )
2088         {
2089             Set((wxDateTime::wxDateTime_t)(yday - gs_cumulatedDays[isLeap][mon]), mon, year);
2090
2091             break;
2092         }
2093     }
2094
2095     return *this;
2096 }
2097
2098 // ----------------------------------------------------------------------------
2099 // Julian day number conversion and related stuff
2100 // ----------------------------------------------------------------------------
2101
2102 double wxDateTime::GetJulianDayNumber() const
2103 {
2104     return m_time.ToDouble() / MILLISECONDS_PER_DAY + EPOCH_JDN + 0.5;
2105 }
2106
2107 double wxDateTime::GetRataDie() const
2108 {
2109     // March 1 of the year 0 is Rata Die day -306 and JDN 1721119.5
2110     return GetJulianDayNumber() - 1721119.5 - 306;
2111 }
2112
2113 // ----------------------------------------------------------------------------
2114 // timezone and DST stuff
2115 // ----------------------------------------------------------------------------
2116
2117 int wxDateTime::IsDST(wxDateTime::Country country) const
2118 {
2119     wxCHECK_MSG( country == Country_Default, -1,
2120                  wxT("country support not implemented") );
2121
2122     // use the C RTL for the dates in the standard range
2123     time_t timet = GetTicks();
2124     if ( timet != (time_t)-1 )
2125     {
2126         struct tm tmstruct;
2127         tm *tm = wxLocaltime_r(&timet, &tmstruct);
2128
2129         wxCHECK_MSG( tm, -1, wxT("wxLocaltime_r() failed") );
2130
2131         return tm->tm_isdst;
2132     }
2133     else
2134     {
2135         int year = GetYear();
2136
2137         if ( !IsDSTApplicable(year, country) )
2138         {
2139             // no DST time in this year in this country
2140             return -1;
2141         }
2142
2143         return IsBetween(GetBeginDST(year, country), GetEndDST(year, country));
2144     }
2145 }
2146
2147 wxDateTime& wxDateTime::MakeTimezone(const TimeZone& tz, bool noDST)
2148 {
2149     long secDiff = GetTimeZone() + tz.GetOffset();
2150
2151     // we need to know whether DST is or not in effect for this date unless
2152     // the test disabled by the caller
2153     if ( !noDST && (IsDST() == 1) )
2154     {
2155         // FIXME we assume that the DST is always shifted by 1 hour
2156         secDiff -= 3600;
2157     }
2158
2159     return Add(wxTimeSpan::Seconds(secDiff));
2160 }
2161
2162 wxDateTime& wxDateTime::MakeFromTimezone(const TimeZone& tz, bool noDST)
2163 {
2164     long secDiff = GetTimeZone() + tz.GetOffset();
2165
2166     // we need to know whether DST is or not in effect for this date unless
2167     // the test disabled by the caller
2168     if ( !noDST && (IsDST() == 1) )
2169     {
2170         // FIXME we assume that the DST is always shifted by 1 hour
2171         secDiff -= 3600;
2172     }
2173
2174     return Subtract(wxTimeSpan::Seconds(secDiff));
2175 }
2176
2177 // ============================================================================
2178 // wxDateTimeHolidayAuthority and related classes
2179 // ============================================================================
2180
2181 #include "wx/arrimpl.cpp"
2182
2183 WX_DEFINE_OBJARRAY(wxDateTimeArray)
2184
2185 static int wxCMPFUNC_CONV
2186 wxDateTimeCompareFunc(wxDateTime **first, wxDateTime **second)
2187 {
2188     wxDateTime dt1 = **first,
2189                dt2 = **second;
2190
2191     return dt1 == dt2 ? 0 : dt1 < dt2 ? -1 : +1;
2192 }
2193
2194 // ----------------------------------------------------------------------------
2195 // wxDateTimeHolidayAuthority
2196 // ----------------------------------------------------------------------------
2197
2198 wxHolidayAuthoritiesArray wxDateTimeHolidayAuthority::ms_authorities;
2199
2200 /* static */
2201 bool wxDateTimeHolidayAuthority::IsHoliday(const wxDateTime& dt)
2202 {
2203     size_t count = ms_authorities.size();
2204     for ( size_t n = 0; n < count; n++ )
2205     {
2206         if ( ms_authorities[n]->DoIsHoliday(dt) )
2207         {
2208             return true;
2209         }
2210     }
2211
2212     return false;
2213 }
2214
2215 /* static */
2216 size_t
2217 wxDateTimeHolidayAuthority::GetHolidaysInRange(const wxDateTime& dtStart,
2218                                                const wxDateTime& dtEnd,
2219                                                wxDateTimeArray& holidays)
2220 {
2221     wxDateTimeArray hol;
2222
2223     holidays.Clear();
2224
2225     const size_t countAuth = ms_authorities.size();
2226     for ( size_t nAuth = 0; nAuth < countAuth; nAuth++ )
2227     {
2228         ms_authorities[nAuth]->DoGetHolidaysInRange(dtStart, dtEnd, hol);
2229
2230         WX_APPEND_ARRAY(holidays, hol);
2231     }
2232
2233     holidays.Sort(wxDateTimeCompareFunc);
2234
2235     return holidays.size();
2236 }
2237
2238 /* static */
2239 void wxDateTimeHolidayAuthority::ClearAllAuthorities()
2240 {
2241     WX_CLEAR_ARRAY(ms_authorities);
2242 }
2243
2244 /* static */
2245 void wxDateTimeHolidayAuthority::AddAuthority(wxDateTimeHolidayAuthority *auth)
2246 {
2247     ms_authorities.push_back(auth);
2248 }
2249
2250 wxDateTimeHolidayAuthority::~wxDateTimeHolidayAuthority()
2251 {
2252     // required here for Darwin
2253 }
2254
2255 // ----------------------------------------------------------------------------
2256 // wxDateTimeWorkDays
2257 // ----------------------------------------------------------------------------
2258
2259 bool wxDateTimeWorkDays::DoIsHoliday(const wxDateTime& dt) const
2260 {
2261     wxDateTime::WeekDay wd = dt.GetWeekDay();
2262
2263     return (wd == wxDateTime::Sun) || (wd == wxDateTime::Sat);
2264 }
2265
2266 size_t wxDateTimeWorkDays::DoGetHolidaysInRange(const wxDateTime& dtStart,
2267                                                 const wxDateTime& dtEnd,
2268                                                 wxDateTimeArray& holidays) const
2269 {
2270     if ( dtStart > dtEnd )
2271     {
2272         wxFAIL_MSG( wxT("invalid date range in GetHolidaysInRange") );
2273
2274         return 0u;
2275     }
2276
2277     holidays.Empty();
2278
2279     // instead of checking all days, start with the first Sat after dtStart and
2280     // end with the last Sun before dtEnd
2281     wxDateTime dtSatFirst = dtStart.GetNextWeekDay(wxDateTime::Sat),
2282                dtSatLast = dtEnd.GetPrevWeekDay(wxDateTime::Sat),
2283                dtSunFirst = dtStart.GetNextWeekDay(wxDateTime::Sun),
2284                dtSunLast = dtEnd.GetPrevWeekDay(wxDateTime::Sun),
2285                dt;
2286
2287     for ( dt = dtSatFirst; dt <= dtSatLast; dt += wxDateSpan::Week() )
2288     {
2289         holidays.Add(dt);
2290     }
2291
2292     for ( dt = dtSunFirst; dt <= dtSunLast; dt += wxDateSpan::Week() )
2293     {
2294         holidays.Add(dt);
2295     }
2296
2297     return holidays.GetCount();
2298 }
2299
2300 // ============================================================================
2301 // other helper functions
2302 // ============================================================================
2303
2304 // ----------------------------------------------------------------------------
2305 // iteration helpers: can be used to write a for loop over enum variable like
2306 // this:
2307 //  for ( m = wxDateTime::Jan; m < wxDateTime::Inv_Month; wxNextMonth(m) )
2308 // ----------------------------------------------------------------------------
2309
2310 WXDLLIMPEXP_BASE void wxNextMonth(wxDateTime::Month& m)
2311 {
2312     wxASSERT_MSG( m < wxDateTime::Inv_Month, wxT("invalid month") );
2313
2314     // no wrapping or the for loop above would never end!
2315     m = (wxDateTime::Month)(m + 1);
2316 }
2317
2318 WXDLLIMPEXP_BASE void wxPrevMonth(wxDateTime::Month& m)
2319 {
2320     wxASSERT_MSG( m < wxDateTime::Inv_Month, wxT("invalid month") );
2321
2322     m = m == wxDateTime::Jan ? wxDateTime::Inv_Month
2323                              : (wxDateTime::Month)(m - 1);
2324 }
2325
2326 WXDLLIMPEXP_BASE void wxNextWDay(wxDateTime::WeekDay& wd)
2327 {
2328     wxASSERT_MSG( wd < wxDateTime::Inv_WeekDay, wxT("invalid week day") );
2329
2330     // no wrapping or the for loop above would never end!
2331     wd = (wxDateTime::WeekDay)(wd + 1);
2332 }
2333
2334 WXDLLIMPEXP_BASE void wxPrevWDay(wxDateTime::WeekDay& wd)
2335 {
2336     wxASSERT_MSG( wd < wxDateTime::Inv_WeekDay, wxT("invalid week day") );
2337
2338     wd = wd == wxDateTime::Sun ? wxDateTime::Inv_WeekDay
2339                                : (wxDateTime::WeekDay)(wd - 1);
2340 }
2341
2342 #ifdef __WXMSW__
2343
2344 wxDateTime& wxDateTime::SetFromMSWSysTime(const SYSTEMTIME& st)
2345 {
2346     return Set(st.wDay,
2347             static_cast<wxDateTime::Month>(wxDateTime::Jan + st.wMonth - 1),
2348             st.wYear,
2349             st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
2350 }
2351
2352 wxDateTime& wxDateTime::SetFromMSWSysDate(const SYSTEMTIME& st)
2353 {
2354     return Set(st.wDay,
2355             static_cast<wxDateTime::Month>(wxDateTime::Jan + st.wMonth - 1),
2356             st.wYear,
2357             0, 0, 0, 0);
2358 }
2359
2360 void wxDateTime::GetAsMSWSysTime(SYSTEMTIME* st) const
2361 {
2362     const wxDateTime::Tm tm(GetTm());
2363
2364     st->wYear = (WXWORD)tm.year;
2365     st->wMonth = (WXWORD)(tm.mon - wxDateTime::Jan + 1);
2366     st->wDay = tm.mday;
2367
2368     st->wDayOfWeek = 0;
2369     st->wHour = tm.hour;
2370     st->wMinute = tm.min;
2371     st->wSecond = tm.sec;
2372     st->wMilliseconds = tm.msec;
2373 }
2374
2375 void wxDateTime::GetAsMSWSysDate(SYSTEMTIME* st) const
2376 {
2377     const wxDateTime::Tm tm(GetTm());
2378
2379     st->wYear = (WXWORD)tm.year;
2380     st->wMonth = (WXWORD)(tm.mon - wxDateTime::Jan + 1);
2381     st->wDay = tm.mday;
2382
2383     st->wDayOfWeek =
2384     st->wHour =
2385     st->wMinute =
2386     st->wSecond =
2387     st->wMilliseconds = 0;
2388 }
2389
2390 #endif // __WXMSW__
2391
2392 #endif // wxUSE_DATETIME