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

diff --git a/include/wx/datetime.h b/include/wx/datetime.h
index 23909f3d6130d948bda6d2b2a05932956cf61ab5..c0091ce1424e765ea8a478960c6c0e60a2e1eae0 100644 (file)
--- a/include/wx/datetime.h
+++ b/include/wx/datetime.h
@@ -37,13 +37,14 @@ class WXDLLEXPORT wxDateSpan;
 /*
  * TODO Well, everything :-)
  *
 /*
  * 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
 
   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
     // ------------------------------------------------------------------------
 
     // 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
         // 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();
 
         // 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;
 
         // 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();
 
         // 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;
     };
 
         // 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
     // ------------------------------------------------------------------------
 
     // 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.
     // 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()!
     // ------------------------------------------------------------------------
 
         // 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
 
         //      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);
 
     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
 
     // 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; }
 
         // 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)
 
         // 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)
         // 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)
         // 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)
         // 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
         // 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
         // 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
         // get the second

-    wxDateTime_t GetSecond() const { return GetTm().sec; }
+    wxDateTime_t GetSecond(const TimeZone& tz = Local) const 
+            { return GetTm(tz).sec; }

         // get milliseconds
         // 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)
 
         // 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)
         // 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,
 
         // 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)?
 
         // 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;
 
         //     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)
         //
         // 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)
     // ------------------------------------------------------------------------
 
     // 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
         // 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
         // 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();
     static struct tm *GetTmNow()
     {
         time_t t = GetTimeNow();

-        return gmtime(&t);
+        return localtime(&t);

     }
 
 private:
     }
 
 private:

diff --git a/include/wx/datetime.inl b/include/wx/datetime.inl
index bf5eac24a8df91ba049852bc4b0aa9c0a3c6da6e..5b1d4652e3f853973d03c58d563e31d812733da4 100644 (file)
--- a/include/wx/datetime.inl
+++ b/include/wx/datetime.inl
@@ -246,21 +246,11 @@ wxDateTime& wxDateTime::operator+=(const wxDateSpan& diff)
 // wxDateTime and timezones
 // ----------------------------------------------------------------------------
 
 // 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::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
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxTimeSpan construction
 // ----------------------------------------------------------------------------

diff --git a/samples/console/console.cpp b/samples/console/console.cpp
index ecbaeeda4f704ac91f0ebc25c7a6dc45760d4b27..1b29d30af23b167fe6bc6731895895ba7dcb853b 100644 (file)
--- a/samples/console/console.cpp
+++ b/samples/console/console.cpp
@@ -30,12 +30,12 @@
 // what to test?
 
 //#define TEST_ARRAYS
 // 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_LOG
 //#define TEST_MIME
 //#define TEST_STRINGS
 //#define TEST_THREADS

-//#define TEST_TIME
+#define TEST_TIME

 //#define TEST_LONGLONG
 
 // ============================================================================
 //#define TEST_LONGLONG
 
 // ============================================================================


@@ -152,6 +152,8 @@ static void TestMimeEnum()
         filetype->GetDescription(&desc);
         filetype->GetExtensions(exts);
 
         filetype->GetDescription(&desc);
         filetype->GetExtensions(exts);
 

+        filetype->GetIcon(NULL);
+

         wxString extsAll;
         for ( size_t e = 0; e < exts.GetCount(); e++ )
         {
         wxString extsAll;
         for ( size_t e = 0; e < exts.GetCount(); e++ )
         {


@@ -252,6 +254,63 @@ static void TestDivision()
 
 #include <wx/datetime.h>
 
 
 #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()
 {
 // this test miscellaneous static wxDateTime functions
 static void TestTimeStatic()
 {


@@ -300,10 +359,29 @@ static void TestTimeSet()
 {
     puts("\n*** wxDateTime construction test ***");
 
 {
     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("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
 }
 
 // test time zones stuff


@@ -313,11 +391,12 @@ static void TestTimeZones()
 
     wxDateTime now = wxDateTime::Now();
 
 
     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
 }
 
 // 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());
 }
 
             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];
 
     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();
 
         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)");
         if ( jdn == d.jdn )
         {
             puts(" (ok)");


@@ -656,7 +745,7 @@ void PrintArray(const char* name, const wxArrayString& array)
 
 #include "wx/timer.h"
 
 
 #include "wx/timer.h"
 

-void TestString()
+static void TestString()

 {
     wxStopWatch sw;
 
 {
     wxStopWatch sw;
 


@@ -681,7 +770,7 @@ void TestString()
     printf ("TestString elapsed time: %ld\n", sw.Time());
 }
 
     printf ("TestString elapsed time: %ld\n", sw.Time());
 }
 

-void TestPChar()
+static void TestPChar()

 {
     wxStopWatch sw;
 
 {
     wxStopWatch sw;
 


@@ -704,6 +793,23 @@ void TestPChar()
     printf ("TestPChar elapsed time: %ld\n", sw.Time());
 }
 
     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
 
 // ----------------------------------------------------------------------------
 #endif // TEST_STRINGS
 
 // ----------------------------------------------------------------------------


@@ -718,8 +824,12 @@ int main(int argc, char **argv)
     }
 
 #ifdef TEST_STRINGS
     }
 
 #ifdef TEST_STRINGS

-    TestPChar();
-    TestString();
+    if ( 0 )
+    {
+        TestPChar();
+        TestString();
+    }
+    TestStringSub();

 #endif // TEST_STRINGS
 
 #ifdef TEST_ARRAYS
 #endif // TEST_STRINGS
 
 #ifdef TEST_ARRAYS


@@ -809,11 +919,15 @@ int main(int argc, char **argv)
 #endif // TEST_MIME
 
 #ifdef TEST_TIME
 #endif // TEST_MIME
 
 #ifdef TEST_TIME

-    TestTimeStatic();

     TestTimeSet();
     TestTimeSet();

+    if ( 0 )
+    {
+    TestTimeStatic();

     TestTimeZones();
     TestTimeRange();
     TestTimeZones();
     TestTimeRange();

+    TestTimeTicks();

     TestTimeJDN();
     TestTimeJDN();

+    }

 #endif // TEST_TIME
 
     wxUninitialize();
 #endif // TEST_TIME
 
     wxUninitialize();

diff --git a/src/common/datetime.cpp b/src/common/datetime.cpp
index e623c60294ca2ff3326aa19acc7d150ac3f12603..10f35b10fb442acf25bad6afb783b9b9be965eb2 100644 (file)
--- 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
  * 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
  *
  * 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)
  *
  *    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;
 }
 
     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;
 {
     msec = 0;
     sec = tm.tm_sec;


@@ -321,7 +331,9 @@ wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz)
     switch ( tz )
     {
         case wxDateTime::Local:
     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:
             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:
         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:
             break;
 
         case wxDateTime::GMT0:


@@ -352,12 +364,12 @@ wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz)
         case wxDateTime::GMT10:
         case wxDateTime::GMT11:
         case wxDateTime::GMT12:
         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
             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:
             break;
 
         default:


@@ -533,30 +545,14 @@ wxString wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday, bool abbr)
 // constructors and assignment operators
 // ----------------------------------------------------------------------------
 
 // 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") );
 
 {
     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);
 
     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"));
     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();
 
     // 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;
 
     // 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_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);
 
 
         (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;
 
         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;
     }
 
     return *this;


@@ -673,7 +672,7 @@ wxDateTime& wxDateTime::Set(double jdn)
 // time_t <-> broken down time conversions
 // ----------------------------------------------------------------------------
 
 // 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") );
 
 {
     wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
 


@@ -681,24 +680,36 @@ wxDateTime::Tm wxDateTime::GetTm() const
     if ( time != (time_t)-1 )
     {
         // use C RTL functions
     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") );
 
 
         // 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
 
     }
     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 )
         {
         if ( timeOnly < 0 )
         {

-            timeOnly = MILLISECONDS_PER_DAY - timeOnly;
+            timeOnly = MILLISECONDS_PER_DAY + timeOnly;

         }
 
         timeMidnight -= timeOnly;
         }
 
         timeMidnight -= timeOnly;


@@ -950,7 +961,8 @@ bool wxDateTime::SetToWeekDay(WeekDay weekday,
 
 double wxDateTime::GetJulianDayNumber() const
 {
 
 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);
 
 
     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)
 {
 }
 
 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
 // ----------------------------------------------------------------------------
 
 }
 
 // ----------------------------------------------------------------------------
 // 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") );
 
 {
     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()
     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") );
 
         // 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
         // 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;
         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);
         // 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;
 
         // now replace the occurence of 1999 with the real year
         wxString strYearReal;