Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

more timezone stuff - it's a miracle, but it seems to work

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4896 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
1999-12-10 20:44:37 +00:00
parent e4b8154a65
commit 299fcbfe98
4 changed files with 316 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files

121
include/wx/datetime.h
View File

@@ -37,13 +37,14 @@ class WXDLLEXPORT wxDateSpan;
/*
* TODO Well, everything :-)
*
* 1. Time zones with minutes (make wxTimeZone a class)
* + 1. Time zones with minutes (make TimeZone a class)
* 2. getdate() function like under Solaris
* 3. text conversion for wxDateSpan
* + 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:

10
include/wx/datetime.inl
View File

@@ -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
// ----------------------------------------------------------------------------

198
samples/console/console.cpp
View File

@@ -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 <wx/datetime.h>
// 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());
}
static void TestTimeTicks()
{
puts("\n*** wxDateTime ticks test ***");
for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
{
const Date& d = testDates[n];
if ( d.ticks == -1 )
continue;
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 ***");
struct Date
{
wxDateTime::wxDateTime_t day;
wxDateTime::Month month;
int year;
double jdn;
};
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 },
};
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
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();

141
src/common/datetime.cpp
View File

@@ -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 = (m_time % MILLISECONDS_PER_DAY).ToLong();
long timeOnly = (timeMidnight % 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;