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