/*
* 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
// 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
// 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;
// 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
// ------------------------------------------------------------------------
// 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()!
// 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
// 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)?
// 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)
// ------------------------------------------------------------------------
// 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
static struct tm *GetTmNow()
{
time_t t = GetTimeNow();
- return gmtime(&t);
+ return localtime(&t);
}
private:
// 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
// ----------------------------------------------------------------------------
// 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
// ============================================================================
filetype->GetDescription(&desc);
filetype->GetExtensions(exts);
+ filetype->GetIcon(NULL);
+
wxString extsAll;
for ( size_t e = 0; e < exts.GetCount(); e++ )
{
#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()
{
{
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
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
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)");
#include "wx/timer.h"
-void TestString()
+static void TestString()
{
wxStopWatch sw;
printf ("TestString elapsed time: %ld\n", sw.Time());
}
-void TestPChar()
+static void TestPChar()
{
wxStopWatch sw;
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
// ----------------------------------------------------------------------------
}
#ifdef TEST_STRINGS
- TestPChar();
- TestString();
+ if ( 0 )
+ {
+ TestPChar();
+ TestString();
+ }
+ TestStringSub();
#endif // TEST_STRINGS
#ifdef TEST_ARRAYS
#endif // TEST_MIME
#ifdef TEST_TIME
- TestTimeStatic();
TestTimeSet();
+ if ( 0 )
+ {
+ TestTimeStatic();
TestTimeZones();
TestTimeRange();
+ TestTimeTicks();
TestTimeJDN();
+ }
#endif // TEST_TIME
wxUninitialize();
* 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
* 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.
*/
// ============================================================================
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;
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:
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:
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:
// 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"));
// 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;
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);
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;
// 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") );
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;
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);
}
// ----------------------------------------------------------------------------
-// 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") );
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") );
// 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;
// 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;
projects / wxWidgets.git / commitdiff
