From 299fcbfe98fce39cdc9ab142b65824a175542ff2 Mon Sep 17 00:00:00 2001 From: Vadim Zeitlin Date: Fri, 10 Dec 1999 20:44:37 +0000 Subject: [PATCH] more timezone stuff - it's a miracle, but it seems to work git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4896 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- include/wx/datetime.h | 123 ++++++++++++---------- include/wx/datetime.inl | 10 -- samples/console/console.cpp | 202 ++++++++++++++++++++++++++++-------- src/common/datetime.cpp | 141 ++++++++++++++++--------- 4 files changed, 316 insertions(+), 160 deletions(-) diff --git a/include/wx/datetime.h b/include/wx/datetime.h index 23909f3d61..c0091ce142 100644 --- a/include/wx/datetime.h +++ b/include/wx/datetime.h @@ -37,13 +37,14 @@ class WXDLLEXPORT wxDateSpan; /* * TODO Well, everything :-) * - * 1. Time zones with minutes (make wxTimeZone a class) - * 2. getdate() function like under Solaris - * 3. text conversion for wxDateSpan + * + 1. Time zones with minutes (make TimeZone a class) + * 2. getdate() function like under Solaris + * + 3. text conversion for wxDateSpan + * 4. pluggable modules for the workdays calculations */ /* - The three classes declared in this header represent: + The three (main) classes declared in this header represent: 1. An absolute moment in the time (wxDateTime) 2. A difference between two moments in the time, positive or negative @@ -322,6 +323,21 @@ public: // helper classes // ------------------------------------------------------------------------ + // a class representing a time zone: basicly, this is just an offset + // (in seconds) from GMT + class TimeZone + { + public: + TimeZone(TZ tz); + TimeZone(wxDateTime_t offset = 0) { m_offset = offset; } + + int GetOffset() const { return m_offset; } + + private: + // offset for this timezone from GMT in seconds + int m_offset; + }; + // standard struct tm is limited to the years from 1900 (because // tm_year field is the offset from 1900), so we use our own struct // instead to represent broken down time @@ -338,8 +354,8 @@ public: // default ctor inits the object to an invalid value Tm(); - // ctor from struct tm - Tm(const struct tm& tm); + // ctor from struct tm and the timezone + Tm(const struct tm& tm, const TimeZone& tz); // check that the given date/time is valid (in Gregorian calendar) bool IsValid() const; @@ -363,26 +379,14 @@ public: // compute the weekday from other fields void ComputeWeekDay(); + // the timezone we correspond to + TimeZone m_tz; + // these values can't be accessed directly because they're not always // computed and we calculate them on demand wxDateTime_t wday, yday; }; - // a class representing a time zone: basicly, this is just an offset - // (in minutes) from GMT - class TimeZone - { - public: - TimeZone(TZ tz); - TimeZone(wxDateTime_t offset) { m_offset = offset; } - - int GetOffset() const { return m_offset; } - - private: - // offset for this timezone from GMT in minutes - int m_offset; - }; - // static methods // ------------------------------------------------------------------------ @@ -442,9 +446,6 @@ public: // constructors: you should test whether the constructor succeeded with // IsValid() function. The values Inv_Month and Inv_Year for the // parameters mean take current month and/or year values. - // - // All new wxDateTime correspond to the local time, use ToUTC() or - // MakeUTC() to get the time in UTC/GMT. // ------------------------------------------------------------------------ // default ctor does not initialize the object, use Set()! @@ -607,27 +608,21 @@ public: // religious holidays (Easter...) or moon/solar eclipses? Some // algorithms can be found in the calendar FAQ - // timezone stuff: by default, we always work with local times, to get - // anything else, it should be requested explicitly + // timezone stuff: a wxDateTime object constructed using given + // day/month/year/hour/min/sec values correspond to this moment in local + // time. Using the functions below, it may be converted to another time + // zone (for example, the Unix epoch is wxDateTime(1, Jan, 1970).ToGMT()) + // + // Converting to the local time zone doesn't do anything. // ------------------------------------------------------------------------ - // transform this object to UTC/GMT - wxDateTime& MakeUTC(); - wxDateTime& MakeGMT() { return MakeUTC(); } - - // get the time corresponding to this one in UTC/GMT - inline wxDateTime ToUTC() const; - wxDateTime ToGMT() const { return ToUTC(); } - - // generic versions of the above - - // transform from local time to any given timezone + // transform to any given timezone inline wxDateTime ToTimezone(const TimeZone& tz) const; wxDateTime& MakeTimezone(const TimeZone& tz); - // transform time from any timezone to the local time - inline wxDateTime ToLocalTime(const TimeZone& tz) const; - wxDateTime& MakeLocalTime(const TimeZone& tz); + // transform to GMT/UTC + wxDateTime ToGMT() const { return ToTimezone(GMT0); } + wxDateTime& MakeGMT() { return MakeTimezone(GMT0); } // accessors: many of them take the timezone parameter which indicates the // timezone for which to make the calculations and the default value means @@ -640,40 +635,52 @@ public: // the functions which failed to convert the date to supported range) inline bool IsValid() const { return this != &ms_InvDateTime; } - // get the broken down date/time representation - Tm GetTm() const; + // get the broken down date/time representation in the given timezone + // + // If you wish to get several time components (day, month and year), + // consider getting the whole Tm strcuture first and retrieving the + // value from it - this is much more efficient + Tm GetTm(const TimeZone& tz = Local) const; // get the number of seconds since the Unix epoch - returns (time_t)-1 // if the value is out of range inline time_t GetTicks() const; // get the year (returns Inv_Year if date is invalid) - int GetYear() const { return GetTm().year; } + int GetYear(const TimeZone& tz = Local) const + { return GetTm(tz).year; } // get the month (Inv_Month if date is invalid) - Month GetMonth() const { return (Month)GetTm().mon; } + Month GetMonth(const TimeZone& tz = Local) const + { return (Month)GetTm(tz).mon; } // get the month day (in 1..31 range, 0 if date is invalid) - wxDateTime_t GetDay() const { return GetTm().mday; } + wxDateTime_t GetDay(const TimeZone& tz = Local) const + { return GetTm(tz).mday; } // get the day of the week (Inv_WeekDay if date is invalid) - WeekDay GetWeekDay() const { return GetTm().GetWeekDay(); } + WeekDay GetWeekDay(const TimeZone& tz = Local) const + { return GetTm(tz).GetWeekDay(); } // get the hour of the day - wxDateTime_t GetHour() const { return GetTm().hour; } + wxDateTime_t GetHour(const TimeZone& tz = Local) const + { return GetTm(tz).hour; } // get the minute - wxDateTime_t GetMinute() const { return GetTm().min; } + wxDateTime_t GetMinute(const TimeZone& tz = Local) const + { return GetTm(tz).min; } // get the second - wxDateTime_t GetSecond() const { return GetTm().sec; } + wxDateTime_t GetSecond(const TimeZone& tz = Local) const + { return GetTm(tz).sec; } // get milliseconds - wxDateTime_t GetMillisecond() const { return m_time.GetLo() % 1000; } + wxDateTime_t GetMillisecond(const TimeZone& tz = Local) const + { return GetTm(tz).msec; } // get the day since the year start (1..366, 0 if date is invalid) - wxDateTime_t GetDayOfYear() const; + wxDateTime_t GetDayOfYear(const TimeZone& tz = Local) const; // get the week number since the year start (1..52, 0 if date is // invalid) - wxDateTime_t GetWeekOfYear() const; + wxDateTime_t GetWeekOfYear(const TimeZone& tz = Local) const; // is this date a work day? This depends on a country, of course, // because the holidays are different in different countries bool IsWorkDay(Country country = Country_Default, - TimeZone zone = Local) const; + const TimeZone& tz = Local) const; // is this date later than Gregorian calendar introduction for the // given country (see enum GregorianAdoption)? @@ -683,11 +690,12 @@ public: // adoption of the Gregorian calendar is simply unknown. bool IsGregorianDate(GregorianAdoption country = Gr_Standard) const; - // is daylight savings time in effect at this moment? + // is daylight savings time in effect at this moment according to the + // rules of the specified country? // // Return value is > 0 if DST is in effect, 0 if it is not and -1 if // the information is not available (this is compatible with ANSI C) - int IsDST(Country country = Country_Default, TimeZone zone = Local) const; + int IsDST(Country country = Country_Default) const; // comparison (see also functions below for operator versions) // ------------------------------------------------------------------------ @@ -761,7 +769,8 @@ public: // argument corresponds to the preferred date and time representation // for the current locale) and returns the string containing the // resulting text representation - wxString Format(const wxChar *format = _T("%c")) const; + wxString Format(const wxChar *format = _T("%c"), + const TimeZone& tz = Local) const; // preferred date representation for the current locale wxString FormatDate() const { return Format(_T("%x")); } // preferred time representation for the current locale @@ -780,7 +789,7 @@ public: static struct tm *GetTmNow() { time_t t = GetTimeNow(); - return gmtime(&t); + return localtime(&t); } private: diff --git a/include/wx/datetime.inl b/include/wx/datetime.inl index bf5eac24a8..5b1d4652e3 100644 --- a/include/wx/datetime.inl +++ b/include/wx/datetime.inl @@ -246,21 +246,11 @@ wxDateTime& wxDateTime::operator+=(const wxDateSpan& diff) // wxDateTime and timezones // ---------------------------------------------------------------------------- -wxDateTime wxDateTime::ToUTC() const -{ - return wxDateTime(*this).MakeUTC(); -} - wxDateTime wxDateTime::ToTimezone(const wxDateTime::TimeZone& tz) const { return wxDateTime(*this).MakeTimezone(tz); } -wxDateTime wxDateTime::ToLocalTime(const wxDateTime::TimeZone& tz) const -{ - return wxDateTime(*this).MakeLocalTime(tz); -} - // ---------------------------------------------------------------------------- // wxTimeSpan construction // ---------------------------------------------------------------------------- diff --git a/samples/console/console.cpp b/samples/console/console.cpp index ecbaeeda4f..1b29d30af2 100644 --- a/samples/console/console.cpp +++ b/samples/console/console.cpp @@ -30,12 +30,12 @@ // what to test? //#define TEST_ARRAYS -#define TEST_DIR +//#define TEST_DIR //#define TEST_LOG //#define TEST_MIME //#define TEST_STRINGS //#define TEST_THREADS -//#define TEST_TIME +#define TEST_TIME //#define TEST_LONGLONG // ============================================================================ @@ -152,6 +152,8 @@ static void TestMimeEnum() filetype->GetDescription(&desc); filetype->GetExtensions(exts); + filetype->GetIcon(NULL); + wxString extsAll; for ( size_t e = 0; e < exts.GetCount(); e++ ) { @@ -252,6 +254,63 @@ static void TestDivision() #include +// the test data +struct Date +{ + wxDateTime::wxDateTime_t day; + wxDateTime::Month month; + int year; + wxDateTime::wxDateTime_t hour, min, sec; + double jdn; + time_t gmticks, ticks; + + void Init(const wxDateTime::Tm& tm) + { + day = tm.mday; + month = tm.mon; + year = tm.year; + hour = tm.hour; + min = tm.min; + sec = tm.sec; + jdn = 0.0; + gmticks = ticks = -1; + } + + wxDateTime DT() const + { return wxDateTime(day, month, year, hour, min, sec); } + + wxString Format() const + { + wxString s; + s.Printf("%02d:%02d:%02d %10s %02d, %4d%s", + hour, min, sec, + wxDateTime::GetMonthName(month).c_str(), + day, + abs(wxDateTime::ConvertYearToBC(year)), + year > 0 ? "AD" : "BC"); + return s; + } +}; + +static const Date testDates[] = +{ + { 1, wxDateTime::Jan, 1970, 00, 00, 00, 2440587.5, 0, -3600 }, + { 21, wxDateTime::Jan, 2222, 00, 00, 00, 2532648.5, -1, -1 }, + { 29, wxDateTime::May, 1976, 12, 00, 00, 2442928.0, 202219200, 202212000 }, + { 29, wxDateTime::Feb, 1976, 00, 00, 00, 2442837.5, 194400000, 194396400 }, + { 1, wxDateTime::Jan, 1900, 12, 00, 00, 2415021.0, -1, -1 }, + { 1, wxDateTime::Jan, 1900, 00, 00, 00, 2415020.5, -1, -1 }, + { 15, wxDateTime::Oct, 1582, 00, 00, 00, 2299160.5, -1, -1 }, + { 4, wxDateTime::Oct, 1582, 00, 00, 00, 2299149.5, -1, -1 }, + { 1, wxDateTime::Mar, 1, 00, 00, 00, 1721484.5, -1, -1 }, + { 1, wxDateTime::Jan, 1, 00, 00, 00, 1721425.5, -1, -1 }, + { 31, wxDateTime::Dec, 0, 00, 00, 00, 1721424.5, -1, -1 }, + { 1, wxDateTime::Jan, 0, 00, 00, 00, 1721059.5, -1, -1 }, + { 12, wxDateTime::Aug, -1234, 00, 00, 00, 1270573.5, -1, -1 }, + { 12, wxDateTime::Aug, -4000, 00, 00, 00, 260313.5, -1, -1 }, + { 24, wxDateTime::Nov, -4713, 00, 00, 00, -0.5, -1, -1 }, +}; + // this test miscellaneous static wxDateTime functions static void TestTimeStatic() { @@ -300,10 +359,29 @@ static void TestTimeSet() { puts("\n*** wxDateTime construction test ***"); +#if 0 printf("Current time:\t%s\n", wxDateTime::Now().Format().c_str()); printf("Unix epoch:\t%s\n", wxDateTime((time_t)0).Format().c_str()); printf("Today noon:\t%s\n", wxDateTime(12, 0).Format().c_str()); printf("May 29, 1976:\t%s\n", wxDateTime(29, wxDateTime::May, 1976).Format().c_str()); + printf("Jan 1, 1900:\t%s\n", wxDateTime(1, wxDateTime::Jan, 1900).Format().c_str()); +#else + for ( size_t n = 0; n < WXSIZEOF(testDates); n++ ) + { + const Date& d1 = testDates[n]; + wxDateTime dt = d1.DT(); + + Date d2; + d2.Init(dt.GetTm()); + + wxString s1 = d1.Format(), + s2 = d2.Format(); + + printf("Date: %s == %s (%s)\n", + s1.c_str(), s2.c_str(), + s1 == s2 ? "ok" : "ERROR"); + } +#endif } // test time zones stuff @@ -313,11 +391,12 @@ static void TestTimeZones() wxDateTime now = wxDateTime::Now(); - printf("Current GMT time:\t%s\n", now.ToGMT().Format().c_str()); - printf("Unix epoch (GMT):\t%s\n", wxDateTime((time_t)0).MakeGMT().Format().c_str()); - printf("Current time in Paris:\t%s\n", now.ToTimezone(wxDateTime::CET).Format().c_str()); - printf(" Moscow:\t%s\n", now.ToTimezone(wxDateTime::MSK).Format().c_str()); - printf(" New York:\t%s\n", now.ToTimezone(wxDateTime::EST).Format().c_str()); + printf("Current GMT time:\t%s\n", now.Format("%c", wxDateTime::GMT0).c_str()); + printf("Unix epoch (GMT):\t%s\n", wxDateTime((time_t)0).Format("%c", wxDateTime::GMT0).c_str()); + printf("Unix epoch (EST):\t%s\n", wxDateTime((time_t)0).Format("%c", wxDateTime::EST).c_str()); + printf("Current time in Paris:\t%s\n", now.Format("%c", wxDateTime::CET).c_str()); + printf(" Moscow:\t%s\n", now.Format("%c", wxDateTime::MSK).c_str()); + printf(" New York:\t%s\n", now.Format("%c", wxDateTime::EST).c_str()); } // test some minimal support for the dates outside the standard range @@ -337,48 +416,58 @@ static void TestTimeRange() wxDateTime(29, wxDateTime::May, 2099).Format().c_str()); } -// test conversions to JDN &c -static void TestTimeJDN() +static void TestTimeTicks() { - puts("\n*** wxDateTime to JDN test ***"); + puts("\n*** wxDateTime ticks test ***"); - struct Date + for ( size_t n = 0; n < WXSIZEOF(testDates); n++ ) { - wxDateTime::wxDateTime_t day; - wxDateTime::Month month; - int year; - double jdn; - }; + const Date& d = testDates[n]; + if ( d.ticks == -1 ) + continue; - static const Date testDates[] = - { - { 21, wxDateTime::Jan, 2222, 2532648.5 }, - { 29, wxDateTime::May, 1976, 2442927.5 }, - { 1, wxDateTime::Jan, 1970, 2440587.5 }, - { 1, wxDateTime::Jan, 1900, 2415020.5 }, - { 15, wxDateTime::Oct, 1582, 2299160.5 }, - { 4, wxDateTime::Oct, 1582, 2299149.5 }, - { 1, wxDateTime::Mar, 1, 1721484.5 }, - { 1, wxDateTime::Jan, 1, 1721425.5 }, - { 31, wxDateTime::Dec, 0, 1721424.5 }, - { 1, wxDateTime::Jan, 0, 1721059.5 }, - { 12, wxDateTime::Aug, -1234, 1270573.5 }, - { 12, wxDateTime::Aug, -4000, 260313.5 }, - { 24, wxDateTime::Nov, -4713, -0.5 }, - }; + wxDateTime dt = d.DT(); + long ticks = (dt.GetValue() / 1000).ToLong(); + printf("Ticks of %s:\t% 10ld", d.Format().c_str(), ticks); + if ( ticks == d.ticks ) + { + puts(" (ok)"); + } + else + { + printf(" (ERROR: should be %ld, delta = %ld)\n", + d.ticks, ticks - d.ticks); + } + + dt = d.DT().ToTimezone(wxDateTime::GMT0); + ticks = (dt.GetValue() / 1000).ToLong(); + printf("GMtks of %s:\t% 10ld", d.Format().c_str(), ticks); + if ( ticks == d.gmticks ) + { + puts(" (ok)"); + } + else + { + printf(" (ERROR: should be %ld, delta = %ld)\n", + d.gmticks, ticks - d.gmticks); + } + } + + puts(""); +} + +// test conversions to JDN &c +static void TestTimeJDN() +{ + puts("\n*** wxDateTime to JDN test ***"); for ( size_t n = 0; n < WXSIZEOF(testDates); n++ ) { const Date& d = testDates[n]; - wxDateTime dt(d.day, d.month, d.year); + wxDateTime dt(d.day, d.month, d.year, d.hour, d.min, d.sec); double jdn = dt.GetJulianDayNumber(); - printf("JDN of %s %02d, %4d%s is:\t%f", - wxDateTime::GetMonthName(d.month).c_str(), - d.day, - wxDateTime::ConvertYearToBC(d.year), - d.year > 0 ? "AD" : "BC", - jdn); + printf("JDN of %s is:\t% 15.6f", d.Format().c_str(), jdn); if ( jdn == d.jdn ) { puts(" (ok)"); @@ -656,7 +745,7 @@ void PrintArray(const char* name, const wxArrayString& array) #include "wx/timer.h" -void TestString() +static void TestString() { wxStopWatch sw; @@ -681,7 +770,7 @@ void TestString() printf ("TestString elapsed time: %ld\n", sw.Time()); } -void TestPChar() +static void TestPChar() { wxStopWatch sw; @@ -704,6 +793,23 @@ void TestPChar() printf ("TestPChar elapsed time: %ld\n", sw.Time()); } +static void TestStringSub() +{ + wxString s("Hello, world!"); + + puts("*** Testing wxString substring extraction ***"); + + printf("String = '%s'\n", s.c_str()); + printf("Left(5) = '%s'\n", s.Left(5).c_str()); + printf("Right(6) = '%s'\n", s.Right(6).c_str()); + printf("Mid(3, 5) = '%s'\n", s(3, 5).c_str()); + printf("Mid(3) = '%s'\n", s.Mid(3).c_str()); + printf("substr(3, 5) = '%s'\n", s.substr(3, 5).c_str()); + printf("substr(3) = '%s'\n", s.substr(3).c_str()); + + puts(""); +} + #endif // TEST_STRINGS // ---------------------------------------------------------------------------- @@ -718,8 +824,12 @@ int main(int argc, char **argv) } #ifdef TEST_STRINGS - TestPChar(); - TestString(); + if ( 0 ) + { + TestPChar(); + TestString(); + } + TestStringSub(); #endif // TEST_STRINGS #ifdef TEST_ARRAYS @@ -809,11 +919,15 @@ int main(int argc, char **argv) #endif // TEST_MIME #ifdef TEST_TIME - TestTimeStatic(); TestTimeSet(); + if ( 0 ) + { + TestTimeStatic(); TestTimeZones(); TestTimeRange(); + TestTimeTicks(); TestTimeJDN(); + } #endif // TEST_TIME wxUninitialize(); diff --git a/src/common/datetime.cpp b/src/common/datetime.cpp index e623c60294..10f35b10fb 100644 --- a/src/common/datetime.cpp +++ b/src/common/datetime.cpp @@ -20,7 +20,8 @@ * Implementation notes: * * 1. the time is stored as a 64bit integer containing the signed number of - * milliseconds since Jan 1. 1970 (the Unix Epoch) + * milliseconds since Jan 1. 1970 (the Unix Epoch) - so it is always + * expressed in GMT. * * 2. the range is thus something about 580 million years, but due to current * algorithms limitations, only dates from Nov 24, 4714BC are handled @@ -33,6 +34,14 @@ * algorithm used by Scott E. Lee's code only works for positive JDNs, more * or less) * + * 5. the object constructed for the given DD-MM-YYYY HH:MM:SS corresponds to + * this moment in local time and may be converted to the object + * corresponding to the same date/time in another time zone by using + * ToTimezone() + * + * 6. the conversions to the current (or any other) timezone are done when the + * internal time representation is converted to the broken-down one in + * wxDateTime::Tm. */ // ============================================================================ @@ -244,7 +253,8 @@ wxDateTime::Tm::Tm() wday = wxDateTime::Inv_WeekDay; } -wxDateTime::Tm::Tm(const struct tm& tm) +wxDateTime::Tm::Tm(const struct tm& tm, const TimeZone& tz) + : m_tz(tz) { msec = 0; sec = tm.tm_sec; @@ -321,7 +331,9 @@ wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz) switch ( tz ) { case wxDateTime::Local: - // leave offset to be 0 + // get the offset from C RTL: it returns the difference GMT-local + // while we want to have the offset _from_ GMT, hence the '-' + m_offset = -GetTimeZone(); break; case wxDateTime::GMT_12: @@ -336,7 +348,7 @@ wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz) case wxDateTime::GMT_3: case wxDateTime::GMT_2: case wxDateTime::GMT_1: - m_offset = -60*(wxDateTime::GMT0 - tz); + m_offset = -3600*(wxDateTime::GMT0 - tz); break; case wxDateTime::GMT0: @@ -352,12 +364,12 @@ wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz) case wxDateTime::GMT10: case wxDateTime::GMT11: case wxDateTime::GMT12: - m_offset = 60*(tz - wxDateTime::GMT0); + m_offset = 3600*(tz - wxDateTime::GMT0); break; case wxDateTime::A_CST: // Central Standard Time in use in Australia = UTC + 9.5 - m_offset = 9*60 + 30; + m_offset = 60*(9*60 + 30); break; default: @@ -533,30 +545,14 @@ wxString wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday, bool abbr) // constructors and assignment operators // ---------------------------------------------------------------------------- -wxDateTime& wxDateTime::Set(const struct tm& tm1) +// the values in the tm structure contain the local time +wxDateTime& wxDateTime::Set(const struct tm& tm) { wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") ); - tm tm2(tm1); - - // we want the time in GMT, mktime() takes the local time, so use timegm() - // if it's available -#ifdef HAVE_TIMEGM - time_t timet = timegm(&tm2); -#else // !HAVE_TIMEGM - // FIXME this almost surely doesn't work - tm2.tm_sec -= GetTimeZone(); - + struct tm tm2(tm); time_t timet = mktime(&tm2); - if ( tm2.tm_isdst ) - { - tm2.tm_hour += 1; - - timet = mktime(&tm2); - } -#endif // HAVE_TIMEGM/!HAVE_TIMEGM - if ( timet == (time_t)(-1) ) { wxFAIL_MSG(_T("Invalid time")); @@ -584,7 +580,9 @@ wxDateTime& wxDateTime::Set(wxDateTime_t hour, // get the current date from system time_t timet = GetTimeNow(); - struct tm *tm = gmtime(&timet); + struct tm *tm = localtime(&timet); + + wxCHECK_MSG( tm, ms_InvDateTime, _T("localtime() failed") ); // adjust the time tm->tm_hour = hour; @@ -634,7 +632,7 @@ wxDateTime& wxDateTime::Set(wxDateTime_t day, tm.tm_hour = hour; tm.tm_min = minute; tm.tm_sec = second; - tm.tm_isdst = -1; // mktime() will guess it (wrongly, probably) + tm.tm_isdst = -1; // mktime() will guess it (void)Set(tm); @@ -651,7 +649,8 @@ wxDateTime& wxDateTime::Set(wxDateTime_t day, m_time -= EPOCH_JDN; m_time *= SECONDS_PER_DAY * TIME_T_FACTOR; - Add(wxTimeSpan(hour, minute, second, millisec)); + // JDN corresponds to GMT, we take localtime + Add(wxTimeSpan(hour, minute, second + GetTimeZone(), millisec)); } return *this; @@ -673,7 +672,7 @@ wxDateTime& wxDateTime::Set(double jdn) // time_t <-> broken down time conversions // ---------------------------------------------------------------------------- -wxDateTime::Tm wxDateTime::GetTm() const +wxDateTime::Tm wxDateTime::GetTm(const TimeZone& tz) const { wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") ); @@ -681,24 +680,36 @@ wxDateTime::Tm wxDateTime::GetTm() const if ( time != (time_t)-1 ) { // use C RTL functions - tm *tm = gmtime(&time); + tm *tm; + if ( tz.GetOffset() == -GetTimeZone() ) + { + // we are working with local time + tm = localtime(&time); + } + else + { + tm = gmtime(&time); + } // should never happen wxCHECK_MSG( tm, Tm(), _T("gmtime() failed") ); - return Tm(*tm); + return Tm(*tm, tz); } else { // remember the time and do the calculations with the date only - this // eliminates rounding errors of the floating point arithmetics - wxLongLong timeMidnight = m_time; + wxLongLong timeMidnight = m_time - GetTimeZone() * 1000; + + long timeOnly = (timeMidnight % MILLISECONDS_PER_DAY).ToLong(); - long timeOnly = (m_time % MILLISECONDS_PER_DAY).ToLong(); + // we want to always have positive time and timeMidnight to be really + // the midnight before it if ( timeOnly < 0 ) { - timeOnly = MILLISECONDS_PER_DAY - timeOnly; + timeOnly = MILLISECONDS_PER_DAY + timeOnly; } timeMidnight -= timeOnly; @@ -950,7 +961,8 @@ bool wxDateTime::SetToWeekDay(WeekDay weekday, double wxDateTime::GetJulianDayNumber() const { - Tm tm(GetTm()); + // JDN are always expressed for the GMT dates + Tm tm(ToTimezone(GMT0).GetTm(GMT0)); double result = GetTruncatedJDN(tm.mday, tm.mon, tm.year); @@ -968,31 +980,51 @@ double wxDateTime::GetRataDie() const } // ---------------------------------------------------------------------------- -// timezone stuff +// timezone and DST stuff // ---------------------------------------------------------------------------- -wxDateTime& wxDateTime::MakeUTC() +int wxDateTime::IsDST(wxDateTime::Country country) const { - return Add(wxTimeSpan::Seconds(GetTimeZone())); + wxCHECK_MSG( country == Country_Default, -1, + _T("country support not implemented") ); + + // use the C RTL for the dates in the standard range + time_t timet = GetTicks(); + if ( timet != (time_t)-1 ) + { + tm *tm = localtime(&timet); + + wxCHECK_MSG( tm, -1, _T("localtime() failed") ); + + return tm->tm_isdst; + } + else + { + // wxFAIL_MSG( _T("TODO") ); + + return -1; + } } wxDateTime& wxDateTime::MakeTimezone(const TimeZone& tz) { - int minDiff = GetTimeZone() / SECONDS_IN_MINUTE + tz.GetOffset(); - return Add(wxTimeSpan::Minutes(minDiff)); -} + int secDiff = GetTimeZone() + tz.GetOffset(); -wxDateTime& wxDateTime::MakeLocalTime(const TimeZone& tz) -{ - int minDiff = GetTimeZone() / SECONDS_IN_MINUTE + tz.GetOffset(); - return Substract(wxTimeSpan::Minutes(minDiff)); + // we need to know whether DST is or not in effect for this date + if ( IsDST() == 1 ) + { + // FIXME we assume that the DST is always shifted by 1 hour + secDiff -= 3600; + } + + return Substract(wxTimeSpan::Seconds(secDiff)); } // ---------------------------------------------------------------------------- // wxDateTime to/from text representations // ---------------------------------------------------------------------------- -wxString wxDateTime::Format(const wxChar *format) const +wxString wxDateTime::Format(const wxChar *format, const TimeZone& tz) const { wxCHECK_MSG( format, _T(""), _T("NULL format in wxDateTime::Format") ); @@ -1000,7 +1032,18 @@ wxString wxDateTime::Format(const wxChar *format) const if ( time != (time_t)-1 ) { // use strftime() - tm *tm = gmtime(&time); + tm *tm; + if ( tz.GetOffset() == -GetTimeZone() ) + { + // we are working with local time + tm = localtime(&time); + } + else + { + time += tz.GetOffset(); + + tm = gmtime(&time); + } // should never happen wxCHECK_MSG( tm, _T(""), _T("gmtime() failed") ); @@ -1018,7 +1061,7 @@ wxString wxDateTime::Format(const wxChar *format) const // the real year modulo 28 (so the week days coincide for them) // find the YEAR - int yearReal = GetYear(); + int yearReal = GetYear(tz); int year = 1970 + yearReal % 28; wxString strYear; @@ -1039,7 +1082,7 @@ wxString wxDateTime::Format(const wxChar *format) const // use strftime() to format the same date but in supported year wxDateTime dt(*this); dt.SetYear(year); - wxString str = dt.Format(format); + wxString str = dt.Format(format, tz); // now replace the occurence of 1999 with the real year wxString strYearReal; -- 2.45.2