wxRTC: fixed guidelines overwriting adjacent cell borders; corrected capitalisation...

[wxWidgets.git] / include / wx / datetime.h

diff --git a/include/wx/datetime.h b/include/wx/datetime.h
index 4d78cf7ffc9ea4763b08f95f5990eb016fae7528..f500985f288569071d7984fac4034266faf43880 100644 (file)
--- a/include/wx/datetime.h
+++ b/include/wx/datetime.h
@@ -5,7 +5,6 @@
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     10.02.99
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     10.02.99

-// RCS-ID:      $Id$

 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////


@@ -17,19 +16,23 @@
 
 #if wxUSE_DATETIME
 
 
 #if wxUSE_DATETIME
 

-#ifndef __WXWINCE__
-#include <time.h>
+#ifdef __WXWINCE__
+    #include "wx/msw/wince/time.h"

 #else
 #else

-#include "wx/msw/wince/time.h"
-#endif
+    #include <time.h>
+#endif // OS

 
 #include <limits.h>             // for INT_MIN
 
 #include "wx/longlong.h"
 
 #include <limits.h>             // for INT_MIN
 
 #include "wx/longlong.h"

+#include "wx/anystr.h"

 
 class WXDLLIMPEXP_FWD_BASE wxDateTime;
 class WXDLLIMPEXP_FWD_BASE wxTimeSpan;
 class WXDLLIMPEXP_FWD_BASE wxDateSpan;
 
 class WXDLLIMPEXP_FWD_BASE wxDateTime;
 class WXDLLIMPEXP_FWD_BASE wxTimeSpan;
 class WXDLLIMPEXP_FWD_BASE wxDateSpan;

+#ifdef __WINDOWS__
+struct _SYSTEMTIME;
+#endif

 
 #include "wx/dynarray.h"
 
 
 #include "wx/dynarray.h"
 


@@ -49,27 +52,6 @@ class WXDLLIMPEXP_FWD_BASE wxDateSpan;
  *   5. wxDateTimeHolidayAuthority for Easter and other christian feasts
  */
 
  *   5. wxDateTimeHolidayAuthority for Easter and other christian feasts
  */
 

-/* Two wrapper functions for thread safety */
-#ifdef HAVE_LOCALTIME_R
-#define wxLocaltime_r localtime_r
-#else
-WXDLLIMPEXP_BASE struct tm *wxLocaltime_r(const time_t*, struct tm*);
-#if wxUSE_THREADS && !defined(__WINDOWS__) && !defined(__WATCOMC__)
-     // On Windows, localtime _is_ threadsafe!
-#warning using pseudo thread-safe wrapper for localtime to emulate localtime_r
-#endif
-#endif
-
-#ifdef HAVE_GMTIME_R
-#define wxGmtime_r gmtime_r
-#else
-WXDLLIMPEXP_BASE struct tm *wxGmtime_r(const time_t*, struct tm*);
-#if wxUSE_THREADS && !defined(__WINDOWS__) && !defined(__WATCOMC__)
-     // On Windows, gmtime _is_ threadsafe!
-#warning using pseudo thread-safe wrapper for gmtime to emulate gmtime_r
-#endif
-#endif
-

 /*
   The three (main) classes declared in this header represent:
 
 /*
   The three (main) classes declared in this header represent:
 


@@ -124,12 +106,25 @@ WXDLLIMPEXP_BASE struct tm *wxGmtime_r(const time_t*, struct tm*);
 // wxInvalidDateTime)
 class WXDLLIMPEXP_FWD_BASE wxDateTime;
 
 // wxInvalidDateTime)
 class WXDLLIMPEXP_FWD_BASE wxDateTime;
 

-extern WXDLLIMPEXP_DATA_BASE(const wxChar*) wxDefaultDateTimeFormat;
-extern WXDLLIMPEXP_DATA_BASE(const wxChar*) wxDefaultTimeSpanFormat;
+extern WXDLLIMPEXP_DATA_BASE(const char) wxDefaultDateTimeFormat[];
+extern WXDLLIMPEXP_DATA_BASE(const char) wxDefaultTimeSpanFormat[];

 extern WXDLLIMPEXP_DATA_BASE(const wxDateTime) wxDefaultDateTime;
 
 #define wxInvalidDateTime wxDefaultDateTime
 
 extern WXDLLIMPEXP_DATA_BASE(const wxDateTime) wxDefaultDateTime;
 
 #define wxInvalidDateTime wxDefaultDateTime
 

+
+// ----------------------------------------------------------------------------
+// conditional compilation
+// ----------------------------------------------------------------------------
+
+// if configure detected strftime(), we have it too
+#ifdef HAVE_STRFTIME
+    #define wxHAS_STRFTIME
+// suppose everyone else has strftime except Win CE unless VC8 is used
+#elif !defined(__WXWINCE__) || defined(__VISUALC8__)
+    #define wxHAS_STRFTIME
+#endif
+

 // ----------------------------------------------------------------------------
 // wxDateTime represents an absolute moment in the time
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxDateTime represents an absolute moment in the time
 // ----------------------------------------------------------------------------


@@ -156,7 +151,7 @@ public:
         // the time in the current time zone
         Local,
 
         // the time in the current time zone
         Local,
 

-        // zones from GMT (= Greenwhich Mean Time): they're guaranteed to be
+        // zones from GMT (= Greenwich Mean Time): they're guaranteed to be

         // consequent numbers, so writing something like `GMT0 + offset' is
         // safe if abs(offset) <= 12
 
         // consequent numbers, so writing something like `GMT0 + offset' is
         // safe if abs(offset) <= 12
 


@@ -226,124 +221,6 @@ public:
         // TODO Hebrew, Chinese, Maya, ... (just kidding) (or then may be not?)
     };
 
         // TODO Hebrew, Chinese, Maya, ... (just kidding) (or then may be not?)
     };
 

-        // these values only are used to identify the different dates of
-        // adoption of the Gregorian calendar (see IsGregorian())
-        //
-        // All data and comments taken verbatim from "The Calendar FAQ (v 2.0)"
-        // by Claus Tøndering, http://www.pip.dknet.dk/~c-t/calendar.html
-        // except for the comments "we take".
-        //
-        // Symbol "->" should be read as "was followed by" in the comments
-        // which follow.
-    enum GregorianAdoption
-    {
-        Gr_Unknown,    // no data for this country or it's too uncertain to use
-        Gr_Standard,   // on the day 0 of Gregorian calendar: 15 Oct 1582
-
-        Gr_Alaska,             // Oct 1867 when Alaska became part of the USA
-        Gr_Albania,            // Dec 1912
-
-        Gr_Austria = Gr_Unknown,    // Different regions on different dates
-        Gr_Austria_Brixen,          // 5 Oct 1583 -> 16 Oct 1583
-        Gr_Austria_Salzburg = Gr_Austria_Brixen,
-        Gr_Austria_Tyrol = Gr_Austria_Brixen,
-        Gr_Austria_Carinthia,       // 14 Dec 1583 -> 25 Dec 1583
-        Gr_Austria_Styria = Gr_Austria_Carinthia,
-
-        Gr_Belgium,            // Then part of the Netherlands
-
-        Gr_Bulgaria = Gr_Unknown, // Unknown precisely (from 1915 to 1920)
-        Gr_Bulgaria_1,         //      18 Mar 1916 -> 1 Apr 1916
-        Gr_Bulgaria_2,         //      31 Mar 1916 -> 14 Apr 1916
-        Gr_Bulgaria_3,         //      3 Sep 1920 -> 17 Sep 1920
-
-        Gr_Canada = Gr_Unknown,   // Different regions followed the changes in
-                               // Great Britain or France
-
-        Gr_China = Gr_Unknown,    // Different authorities say:
-        Gr_China_1,            //      18 Dec 1911 -> 1 Jan 1912
-        Gr_China_2,            //      18 Dec 1928 -> 1 Jan 1929
-
-        Gr_Czechoslovakia,     // (Bohemia and Moravia) 6 Jan 1584 -> 17 Jan 1584
-        Gr_Denmark,            // (including Norway) 18 Feb 1700 -> 1 Mar 1700
-        Gr_Egypt,              // 1875
-        Gr_Estonia,            // 1918
-        Gr_Finland,            // Then part of Sweden
-
-        Gr_France,             // 9 Dec 1582 -> 20 Dec 1582
-        Gr_France_Alsace,      //      4 Feb 1682 -> 16 Feb 1682
-        Gr_France_Lorraine,    //      16 Feb 1760 -> 28 Feb 1760
-        Gr_France_Strasbourg,  // February 1682
-
-        Gr_Germany = Gr_Unknown,  // Different states on different dates:
-        Gr_Germany_Catholic,   //      1583-1585 (we take 1584)
-        Gr_Germany_Prussia,    //      22 Aug 1610 -> 2 Sep 1610
-        Gr_Germany_Protestant, //      18 Feb 1700 -> 1 Mar 1700
-
-        Gr_GreatBritain,       // 2 Sep 1752 -> 14 Sep 1752 (use 'cal(1)')
-
-        Gr_Greece,             // 9 Mar 1924 -> 23 Mar 1924
-        Gr_Hungary,            // 21 Oct 1587 -> 1 Nov 1587
-        Gr_Ireland = Gr_GreatBritain,
-        Gr_Italy = Gr_Standard,
-
-        Gr_Japan = Gr_Unknown,    // Different authorities say:
-        Gr_Japan_1,            //      19 Dec 1872 -> 1 Jan 1873
-        Gr_Japan_2,            //      19 Dec 1892 -> 1 Jan 1893
-        Gr_Japan_3,            //      18 Dec 1918 -> 1 Jan 1919
-
-        Gr_Latvia,             // 1915-1918 (we take 1915)
-        Gr_Lithuania,          // 1915
-        Gr_Luxemburg,          // 14 Dec 1582 -> 25 Dec 1582
-        Gr_Netherlands = Gr_Belgium, // (including Belgium) 1 Jan 1583
-
-        // this is too weird to take into account: the Gregorian calendar was
-        // introduced twice in Groningen, first time 28 Feb 1583 was followed
-        // by 11 Mar 1583, then it has gone back to Julian in the summer of
-        // 1584 and then 13 Dec 1700 -> 12 Jan 1701 - which is
-        // the date we take here
-        Gr_Netherlands_Groningen,  // 13 Dec 1700 -> 12 Jan 1701
-        Gr_Netherlands_Gelderland, // 30 Jun 1700 -> 12 Jul 1700
-        Gr_Netherlands_Utrecht,    // (and Overijssel) 30 Nov 1700->12 Dec 1700
-        Gr_Netherlands_Friesland,  // (and Drenthe) 31 Dec 1700 -> 12 Jan 1701
-
-        Gr_Norway = Gr_Denmark,       // Then part of Denmark
-        Gr_Poland = Gr_Standard,
-        Gr_Portugal = Gr_Standard,
-        Gr_Romania,                // 31 Mar 1919 -> 14 Apr 1919
-        Gr_Russia,                 // 31 Jan 1918 -> 14 Feb 1918
-        Gr_Scotland = Gr_GreatBritain,
-        Gr_Spain = Gr_Standard,
-
-        // Sweden has a curious history. Sweden decided to make a gradual
-        // change from the Julian to the Gregorian calendar. By dropping every
-        // leap year from 1700 through 1740 the eleven superfluous days would
-        // be omitted and from 1 Mar 1740 they would be in sync with the
-        // Gregorian calendar. (But in the meantime they would be in sync with
-        // nobody!)
-        //
-        // So 1700 (which should have been a leap year in the Julian calendar)
-        // was not a leap year in Sweden. However, by mistake 1704 and 1708
-        // became leap years. This left Sweden out of synchronisation with
-        // both the Julian and the Gregorian world, so they decided to go back
-        // to the Julian calendar. In order to do this, they inserted an extra
-        // day in 1712, making that year a double leap year! So in 1712,
-        // February had 30 days in Sweden.
-        //
-        // Later, in 1753, Sweden changed to the Gregorian calendar by
-        // dropping 11 days like everyone else.
-        Gr_Sweden = Gr_Finland,       // 17 Feb 1753 -> 1 Mar 1753
-
-        Gr_Switzerland = Gr_Unknown,// Different cantons used different dates
-        Gr_Switzerland_Catholic,    //      1583, 1584 or 1597 (we take 1584)
-        Gr_Switzerland_Protestant,  //      31 Dec 1700 -> 12 Jan 1701
-
-        Gr_Turkey,                 // 1 Jan 1927
-        Gr_USA = Gr_GreatBritain,
-        Gr_Wales = Gr_GreatBritain,
-        Gr_Yugoslavia              // 1919
-    };
-

         // the country parameter is used so far for calculating the start and
         // the end of DST period and for deciding whether the date is a work
         // day or not
         // the country parameter is used so far for calculating the start and
         // the end of DST period and for deciding whether the date is a work
         // day or not


@@ -412,7 +289,7 @@ public:
     // helper classes
     // ------------------------------------------------------------------------
 
     // helper classes
     // ------------------------------------------------------------------------
 

-        // a class representing a time zone: basicly, this is just an offset
+        // a class representing a time zone: basically, this is just an offset

         // (in seconds) from GMT
     class WXDLLIMPEXP_BASE TimeZone
     {
         // (in seconds) from GMT
     class WXDLLIMPEXP_BASE TimeZone
     {


@@ -445,7 +322,9 @@ public:
         //     instead of modifying the member fields directly!
     struct WXDLLIMPEXP_BASE Tm
     {
         //     instead of modifying the member fields directly!
     struct WXDLLIMPEXP_BASE Tm
     {

-        wxDateTime_t msec, sec, min, hour, mday;
+        wxDateTime_t msec, sec, min, hour,
+                     mday,  // Day of the month in 1..31 range.
+                     yday;  // Day of the year in 0..365 range.

         Month mon;
         int year;
 
         Month mon;
         int year;
 


@@ -480,9 +359,10 @@ public:
         // the timezone we correspond to
         TimeZone m_tz;
 
         // 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;
+        // This value can only be accessed via GetWeekDay() and not directly
+        // because it's not always computed when creating this object and may
+        // need to be calculated on demand.
+        wxDateTime_t wday;

     };
 
     // static methods
     };
 
     // static methods


@@ -525,16 +405,25 @@ public:
                                         int year = Inv_Year,
                                         Calendar cal = Gregorian);
 
                                         int year = Inv_Year,
                                         Calendar cal = Gregorian);
 

+

         // get the full (default) or abbreviated month name in the current
         // locale, returns empty string on error
     static wxString GetMonthName(Month month,
                                  NameFlags flags = Name_Full);
 
         // get the full (default) or abbreviated month name in the current
         // locale, returns empty string on error
     static wxString GetMonthName(Month month,
                                  NameFlags flags = Name_Full);
 

+        // get the standard English full (default) or abbreviated month name
+    static wxString GetEnglishMonthName(Month month,
+                                        NameFlags flags = Name_Full);
+

         // get the full (default) or abbreviated weekday name in the current
         // locale, returns empty string on error
     static wxString GetWeekDayName(WeekDay weekday,
                                    NameFlags flags = Name_Full);
 
         // get the full (default) or abbreviated weekday name in the current
         // locale, returns empty string on error
     static wxString GetWeekDayName(WeekDay weekday,
                                    NameFlags flags = Name_Full);
 

+        // get the standard English full (default) or abbreviated weekday name
+    static wxString GetEnglishWeekDayName(WeekDay weekday,
+                                          NameFlags flags = Name_Full);
+

         // get the AM and PM strings in the current locale (may be empty)
     static void GetAmPmStrings(wxString *am, wxString *pm);
 
         // get the AM and PM strings in the current locale (may be empty)
     static void GetAmPmStrings(wxString *am, wxString *pm);
 


@@ -598,6 +487,12 @@ public:
                       wxDateTime_t minute = 0,
                       wxDateTime_t second = 0,
                       wxDateTime_t millisec = 0);
                       wxDateTime_t minute = 0,
                       wxDateTime_t second = 0,
                       wxDateTime_t millisec = 0);

+#ifdef __WINDOWS__
+    wxDateTime(const struct _SYSTEMTIME& st)
+    {
+        SetFromMSWSysTime(st);
+    }
+#endif

 
         // default copy ctor ok
 
 
         // default copy ctor ok
 


@@ -679,7 +574,7 @@ public:
         // default assignment operator is ok
 
     // calendar calculations (functions which set the date only leave the time
         // default assignment operator is ok
 
     // calendar calculations (functions which set the date only leave the time

-    // unchanged, e.g. don't explictly zero it): SetXXX() functions modify the
+    // unchanged, e.g. don't explicitly zero it): SetXXX() functions modify the

     // object itself, GetXXX() ones return a new object.
     // ------------------------------------------------------------------------
 
     // object itself, GetXXX() ones return a new object.
     // ------------------------------------------------------------------------
 


@@ -697,7 +592,7 @@ public:
     wxDateTime& SetToPrevWeekDay(WeekDay weekday);
     inline wxDateTime GetPrevWeekDay(WeekDay weekday) const;
 
     wxDateTime& SetToPrevWeekDay(WeekDay weekday);
     inline wxDateTime GetPrevWeekDay(WeekDay weekday) const;
 

-        // set to Nth occurence of given weekday in the given month of the
+        // set to Nth occurrence of given weekday in the given month of the

         // given year (time is set to 0), return true on success and false on
         // failure. n may be positive (1..5) or negative to count from the end
         // of the month (see helper function SetToLastWeekDay())
         // given year (time is set to 0), return true on success and false on
         // failure. n may be positive (1..5) or negative to count from the end
         // of the month (see helper function SetToLastWeekDay())


@@ -895,14 +790,6 @@ public:
         // because the holidays are different in different countries
     bool IsWorkDay(Country country = Country_Default) const;
 
         // because the holidays are different in different countries
     bool IsWorkDay(Country country = Country_Default) const;
 

-        // is this date later than Gregorian calendar introduction for the
-        // given country (see enum GregorianAdoption)?
-        //
-        // NB: this function shouldn't be considered as absolute authority in
-        //     the matter. Besides, for some countries the exact date of
-        //     adoption of the Gregorian calendar is simply unknown.
-    bool IsGregorianDate(GregorianAdoption country = Gr_Standard) const;
-

     // dos date and time format
     // ------------------------------------------------------------------------
 
     // dos date and time format
     // ------------------------------------------------------------------------
 


@@ -912,6 +799,20 @@ public:
         // pack the date in DOS format
     unsigned long GetAsDOS() const;
 
         // pack the date in DOS format
     unsigned long GetAsDOS() const;
 

+    // SYSTEMTIME format
+    // ------------------------------------------------------------------------
+#ifdef __WINDOWS__
+    // convert SYSTEMTIME to wxDateTime
+    wxDateTime& SetFromMSWSysTime(const struct _SYSTEMTIME& st);
+
+    // convert wxDateTime to SYSTEMTIME
+    void GetAsMSWSysTime(struct _SYSTEMTIME* st) const;
+
+    // same as above but only take date part into account, time is always zero
+    wxDateTime& SetFromMSWSysDate(const struct _SYSTEMTIME& st);
+    void GetAsMSWSysDate(struct _SYSTEMTIME* st) const;
+#endif // __WINDOWS__
+

     // comparison (see also functions below for operator versions)
     // ------------------------------------------------------------------------
 
     // comparison (see also functions below for operator versions)
     // ------------------------------------------------------------------------
 


@@ -942,37 +843,37 @@ public:
 
     inline bool operator<(const wxDateTime& dt) const
     {
 
     inline bool operator<(const wxDateTime& dt) const
     {

-        wxASSERT_MSG( IsValid() && dt.IsValid(), _T("invalid wxDateTime") );
+        wxASSERT_MSG( IsValid() && dt.IsValid(), wxT("invalid wxDateTime") );

         return GetValue() < dt.GetValue();
     }
 
     inline bool operator<=(const wxDateTime& dt) const
     {
         return GetValue() < dt.GetValue();
     }
 
     inline bool operator<=(const wxDateTime& dt) const
     {

-        wxASSERT_MSG( IsValid() && dt.IsValid(), _T("invalid wxDateTime") );
+        wxASSERT_MSG( IsValid() && dt.IsValid(), wxT("invalid wxDateTime") );

         return GetValue() <= dt.GetValue();
     }
 
     inline bool operator>(const wxDateTime& dt) const
     {
         return GetValue() <= dt.GetValue();
     }
 
     inline bool operator>(const wxDateTime& dt) const
     {

-        wxASSERT_MSG( IsValid() && dt.IsValid(), _T("invalid wxDateTime") );
+        wxASSERT_MSG( IsValid() && dt.IsValid(), wxT("invalid wxDateTime") );

         return GetValue() > dt.GetValue();
     }
 
     inline bool operator>=(const wxDateTime& dt) const
     {
         return GetValue() > dt.GetValue();
     }
 
     inline bool operator>=(const wxDateTime& dt) const
     {

-        wxASSERT_MSG( IsValid() && dt.IsValid(), _T("invalid wxDateTime") );
+        wxASSERT_MSG( IsValid() && dt.IsValid(), wxT("invalid wxDateTime") );

         return GetValue() >= dt.GetValue();
     }
 
     inline bool operator==(const wxDateTime& dt) const
     {
         return GetValue() >= dt.GetValue();
     }
 
     inline bool operator==(const wxDateTime& dt) const
     {

-        wxASSERT_MSG( IsValid() && dt.IsValid(), _T("invalid wxDateTime") );
+        wxASSERT_MSG( IsValid() && dt.IsValid(), wxT("invalid wxDateTime") );

         return GetValue() == dt.GetValue();
     }
 
     inline bool operator!=(const wxDateTime& dt) const
     {
         return GetValue() == dt.GetValue();
     }
 
     inline bool operator!=(const wxDateTime& dt) const
     {

-        wxASSERT_MSG( IsValid() && dt.IsValid(), _T("invalid wxDateTime") );
+        wxASSERT_MSG( IsValid() && dt.IsValid(), wxT("invalid wxDateTime") );

         return GetValue() != dt.GetValue();
     }
 
         return GetValue() != dt.GetValue();
     }
 


@@ -1035,29 +936,81 @@ public:
     inline wxTimeSpan Subtract(const wxDateTime& dt) const;
     inline wxTimeSpan operator-(const wxDateTime& dt2) const;
 
     inline wxTimeSpan Subtract(const wxDateTime& dt) const;
     inline wxTimeSpan operator-(const wxDateTime& dt2) const;
 

-    // conversion to/from text: all conversions from text return the pointer to
-    // the next character following the date specification (i.e. the one where
-    // the scan had to stop) or NULL on failure.
+    wxDateSpan DiffAsDateSpan(const wxDateTime& dt) const;
+
+    // conversion to/from text

     // ------------------------------------------------------------------------
 
     // ------------------------------------------------------------------------
 

+    // all conversions functions return true to indicate whether parsing
+    // succeeded or failed and fill in the provided end iterator, which must
+    // not be NULL, with the location of the character where the parsing
+    // stopped (this will be end() of the passed string if everything was
+    // parsed)
+

         // parse a string in RFC 822 format (found e.g. in mail headers and
         // having the form "Wed, 10 Feb 1999 19:07:07 +0100")
         // parse a string in RFC 822 format (found e.g. in mail headers and
         // having the form "Wed, 10 Feb 1999 19:07:07 +0100")

-    const wxChar *ParseRfc822Date(const wxChar* date);
+    bool ParseRfc822Date(const wxString& date,
+                         wxString::const_iterator *end);
+

         // parse a date/time in the given format (see strptime(3)), fill in
         // the missing (in the string) fields with the values of dateDef (by
         // default, they will not change if they had valid values or will
         // default to Today() otherwise)
         // parse a date/time in the given format (see strptime(3)), fill in
         // the missing (in the string) fields with the values of dateDef (by
         // default, they will not change if they had valid values or will
         // default to Today() otherwise)

-    const wxChar *ParseFormat(const wxChar *date,
-                              const wxString& format = wxDefaultDateTimeFormat,
-                              const wxDateTime& dateDef = wxDefaultDateTime);
+    bool ParseFormat(const wxString& date,
+                     const wxString& format,
+                     const wxDateTime& dateDef,
+                     wxString::const_iterator *end);
+
+    bool ParseFormat(const wxString& date,
+                     const wxString& format,
+                     wxString::const_iterator *end)
+    {
+        return ParseFormat(date, format, wxDefaultDateTime, end);
+    }
+
+    bool ParseFormat(const wxString& date,
+                     wxString::const_iterator *end)
+    {
+        return ParseFormat(date, wxDefaultDateTimeFormat, wxDefaultDateTime, end);
+    }
+
+        // parse a string containing date, time or both in ISO 8601 format
+        //
+        // notice that these functions are new in wx 3.0 and so we don't
+        // provide compatibility overloads for them
+    bool ParseISODate(const wxString& date)
+    {
+        wxString::const_iterator end;
+        return ParseFormat(date, wxS("%Y-%m-%d"), &end) && end == date.end();
+    }
+
+    bool ParseISOTime(const wxString& time)
+    {
+        wxString::const_iterator end;
+        return ParseFormat(time, wxS("%H:%M:%S"), &end) && end == time.end();
+    }
+
+    bool ParseISOCombined(const wxString& datetime, char sep = 'T')
+    {
+        wxString::const_iterator end;
+        const wxString fmt = wxS("%Y-%m-%d") + wxString(sep) + wxS("%H:%M:%S");
+        return ParseFormat(datetime, fmt, &end) && end == datetime.end();
+    }
+

         // parse a string containing the date/time in "free" format, this
         // function will try to make an educated guess at the string contents
         // parse a string containing the date/time in "free" format, this
         // function will try to make an educated guess at the string contents

-    const wxChar *ParseDateTime(const wxChar *datetime);
+    bool ParseDateTime(const wxString& datetime,
+                       wxString::const_iterator *end);
+

         // parse a string containing the date only in "free" format (less
         // flexible than ParseDateTime)
         // parse a string containing the date only in "free" format (less
         // flexible than ParseDateTime)

-    const wxChar *ParseDate(const wxChar *date);
+    bool ParseDate(const wxString& date,
+                   wxString::const_iterator *end);
+

         // parse a string containing the time only in "free" format
         // parse a string containing the time only in "free" format

-    const wxChar *ParseTime(const wxChar *time);
+    bool ParseTime(const wxString& time,
+                   wxString::const_iterator *end);
+

 
         // this function accepts strftime()-like format string (default
         // argument corresponds to the preferred date and time representation
 
         // this function accepts strftime()-like format string (default
         // argument corresponds to the preferred date and time representation


@@ -1066,15 +1019,112 @@ public:
     wxString Format(const wxString& format = wxDefaultDateTimeFormat,
                     const TimeZone& tz = Local) const;
         // preferred date representation for the current locale
     wxString Format(const wxString& format = wxDefaultDateTimeFormat,
                     const TimeZone& tz = Local) const;
         // preferred date representation for the current locale

-    wxString FormatDate() const { return Format(_T("%x")); }
+    wxString FormatDate() const { return Format(wxS("%x")); }

         // preferred time representation for the current locale
         // preferred time representation for the current locale

-    wxString FormatTime() const { return Format(_T("%X")); }
+    wxString FormatTime() const { return Format(wxS("%X")); }

         // returns the string representing the date in ISO 8601 format
         // (YYYY-MM-DD)
         // returns the string representing the date in ISO 8601 format
         // (YYYY-MM-DD)

-    wxString FormatISODate() const { return Format(_T("%Y-%m-%d")); }
+    wxString FormatISODate() const { return Format(wxS("%Y-%m-%d")); }

         // returns the string representing the time in ISO 8601 format
         // (HH:MM:SS)
         // returns the string representing the time in ISO 8601 format
         // (HH:MM:SS)

-    wxString FormatISOTime() const { return Format(_T("%H:%M:%S")); }
+    wxString FormatISOTime() const { return Format(wxS("%H:%M:%S")); }
+        // return the combined date time representation in ISO 8601 format; the
+        // separator character should be 'T' according to the standard but it
+        // can also be useful to set it to ' '
+    wxString FormatISOCombined(char sep = 'T') const
+        { return FormatISODate() + sep + FormatISOTime(); }
+
+
+    // backwards compatible versions of the parsing functions: they return an
+    // object representing the next character following the date specification
+    // (i.e. the one where the scan had to stop) or a special NULL-like object
+    // on failure
+    //
+    // they're not deprecated because a lot of existing code uses them and
+    // there is no particular harm in keeping them but you should still prefer
+    // the versions above in the new code
+    wxAnyStrPtr ParseRfc822Date(const wxString& date)
+    {
+        wxString::const_iterator end;
+        return ParseRfc822Date(date, &end) ? wxAnyStrPtr(date, end)
+                                           : wxAnyStrPtr();
+    }
+
+    wxAnyStrPtr ParseFormat(const wxString& date,
+                            const wxString& format = wxDefaultDateTimeFormat,
+                            const wxDateTime& dateDef = wxDefaultDateTime)
+    {
+        wxString::const_iterator end;
+        return ParseFormat(date, format, dateDef, &end) ? wxAnyStrPtr(date, end)
+                                                        : wxAnyStrPtr();
+    }
+
+    wxAnyStrPtr ParseDateTime(const wxString& datetime)
+    {
+        wxString::const_iterator end;
+        return ParseDateTime(datetime, &end) ? wxAnyStrPtr(datetime, end)
+                                             : wxAnyStrPtr();
+    }
+
+    wxAnyStrPtr ParseDate(const wxString& date)
+    {
+        wxString::const_iterator end;
+        return ParseDate(date, &end) ? wxAnyStrPtr(date, end)
+                                     : wxAnyStrPtr();
+    }
+
+    wxAnyStrPtr ParseTime(const wxString& time)
+    {
+        wxString::const_iterator end;
+        return ParseTime(time, &end) ? wxAnyStrPtr(time, end)
+                                     : wxAnyStrPtr();
+    }
+
+    // In addition to wxAnyStrPtr versions above we also must provide the
+    // overloads for C strings as we must return a pointer into the original
+    // string and not inside a temporary wxString which would have been created
+    // if the overloads above were used.
+    //
+    // And then we also have to provide the overloads for wxCStrData, as usual.
+    // Unfortunately those ones can't return anything as we don't have any
+    // sufficiently long-lived wxAnyStrPtr to return from them: any temporary
+    // strings it would point to would be destroyed when this function returns
+    // making it impossible to dereference the return value. So we just don't
+    // return anything from here which at least allows to keep compatibility
+    // with the code not testing the return value. Other uses of this method
+    // need to be converted to use one of the new bool-returning overloads
+    // above.
+    void ParseRfc822Date(const wxCStrData& date)
+        { ParseRfc822Date(wxString(date)); }
+    const char* ParseRfc822Date(const char* date);
+    const wchar_t* ParseRfc822Date(const wchar_t* date);
+
+    void ParseFormat(const wxCStrData& date,
+                     const wxString& format = wxDefaultDateTimeFormat,
+                     const wxDateTime& dateDef = wxDefaultDateTime)
+        { ParseFormat(wxString(date), format, dateDef); }
+    const char* ParseFormat(const char* date,
+                            const wxString& format = wxDefaultDateTimeFormat,
+                            const wxDateTime& dateDef = wxDefaultDateTime);
+    const wchar_t* ParseFormat(const wchar_t* date,
+                               const wxString& format = wxDefaultDateTimeFormat,
+                               const wxDateTime& dateDef = wxDefaultDateTime);
+
+    void ParseDateTime(const wxCStrData& datetime)
+        { ParseDateTime(wxString(datetime)); }
+    const char* ParseDateTime(const char* datetime);
+    const wchar_t* ParseDateTime(const wchar_t* datetime);
+
+    void ParseDate(const wxCStrData& date)
+        { ParseDate(wxString(date)); }
+    const char* ParseDate(const char* date);
+    const wchar_t* ParseDate(const wchar_t* date);
+
+    void ParseTime(const wxCStrData& time)
+        { ParseTime(wxString(time)); }
+    const char* ParseTime(const char* time);
+    const wchar_t* ParseTime(const wchar_t* time);
+

 
     // implementation
     // ------------------------------------------------------------------------
 
     // implementation
     // ------------------------------------------------------------------------


@@ -1086,7 +1136,7 @@ public:
     inline wxLongLong GetValue() const;
 
     // a helper function to get the current time_t
     inline wxLongLong GetValue() const;
 
     // a helper function to get the current time_t

-    static time_t GetTimeNow() { return time((time_t *)NULL); }
+    static time_t GetTimeNow() { return time(NULL); }

 
     // another one to get the current time broken down
     static struct tm *GetTmNow()
 
     // another one to get the current time broken down
     static struct tm *GetTmNow()


@@ -1243,7 +1293,7 @@ public:
         // compare two timestamps: works with the absolute values, i.e. 1
         // hour is shorter than -2 hours. Also, it will return false if the
         // timespans are equal in absolute value.
         // compare two timestamps: works with the absolute values, i.e. 1
         // hour is shorter than -2 hours. Also, it will return false if the
         // timespans are equal in absolute value.

-    bool IsShorterThan(const wxTimeSpan& t) const { return !IsLongerThan(t); }
+    bool IsShorterThan(const wxTimeSpan& t) const;

 
     inline bool operator<(const wxTimeSpan &ts) const
     {
 
     inline bool operator<(const wxTimeSpan &ts) const
     {


@@ -1402,6 +1452,8 @@ public:
     int GetYears() const { return m_years; }
         // get number of months
     int GetMonths() const { return m_months; }
     int GetYears() const { return m_years; }
         // get number of months
     int GetMonths() const { return m_months; }

+        // returns 12*GetYears() + GetMonths()
+    int GetTotalMonths() const { return 12*m_years + m_months; }

         // get number of weeks
     int GetWeeks() const { return m_weeks; }
         // get number of days
         // get number of weeks
     int GetWeeks() const { return m_weeks; }
         // get number of days


@@ -1578,7 +1630,9 @@ protected:
 
 inline bool wxDateTime::IsInStdRange() const
 {
 
 inline bool wxDateTime::IsInStdRange() const
 {

-    return m_time >= 0l && (m_time / TIME_T_FACTOR) < LONG_MAX;
+    // currently we don't know what is the real type of time_t so prefer to err
+    // on the safe side and limit it to 32 bit values which is safe everywhere
+    return m_time >= 0l && (m_time / TIME_T_FACTOR) < wxINT32_MAX;

 }
 
 /* static */
 }
 
 /* static */


@@ -1600,9 +1654,16 @@ inline wxDateTime wxDateTime::Today()
 #if (!(defined(__VISAGECPP__) && __IBMCPP__ >= 400))
 inline wxDateTime& wxDateTime::Set(time_t timet)
 {
 #if (!(defined(__VISAGECPP__) && __IBMCPP__ >= 400))
 inline wxDateTime& wxDateTime::Set(time_t timet)
 {

-    // assign first to avoid long multiplication overflow!
-    m_time = timet - WX_TIME_BASE_OFFSET ;
-    m_time *= TIME_T_FACTOR;
+    if ( timet == (time_t)-1 )
+    {
+        m_time = wxInvalidDateTime.m_time;
+    }
+    else
+    {
+        // assign first to avoid long multiplication overflow!
+        m_time = timet - WX_TIME_BASE_OFFSET;
+        m_time *= TIME_T_FACTOR;
+    }

 
     return *this;
 }
 
     return *this;
 }


@@ -1638,7 +1699,7 @@ inline wxDateTime::wxDateTime(double jdn)
 
 inline wxDateTime& wxDateTime::Set(const Tm& tm)
 {
 
 inline wxDateTime& wxDateTime::Set(const Tm& tm)
 {

-    wxASSERT_MSG( tm.IsValid(), _T("invalid broken down date/time") );
+    wxASSERT_MSG( tm.IsValid(), wxT("invalid broken down date/time") );

 
     return Set(tm.mday, (Month)tm.mon, tm.year,
                tm.hour, tm.min, tm.sec, tm.msec);
 
     return Set(tm.mday, (Month)tm.mon, tm.year,
                tm.hour, tm.min, tm.sec, tm.msec);


@@ -1669,14 +1730,14 @@ inline wxDateTime::wxDateTime(wxDateTime_t day,
 
 inline wxLongLong wxDateTime::GetValue() const
 {
 
 inline wxLongLong wxDateTime::GetValue() const
 {

-    wxASSERT_MSG( IsValid(), _T("invalid wxDateTime"));
+    wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime"));

 
     return m_time;
 }
 
 inline time_t wxDateTime::GetTicks() const
 {
 
     return m_time;
 }
 
 inline time_t wxDateTime::GetTicks() const
 {

-    wxASSERT_MSG( IsValid(), _T("invalid wxDateTime"));
+    wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime"));

     if ( !IsInStdRange() )
     {
         return (time_t)-1;
     if ( !IsInStdRange() )
     {
         return (time_t)-1;


@@ -1744,21 +1805,21 @@ inline wxDateTime wxDateTime::GetYearDay(wxDateTime_t yday) const
 
 inline bool wxDateTime::IsEqualTo(const wxDateTime& datetime) const
 {
 
 inline bool wxDateTime::IsEqualTo(const wxDateTime& datetime) const
 {

-    wxASSERT_MSG( IsValid() && datetime.IsValid(), _T("invalid wxDateTime"));
+    wxASSERT_MSG( IsValid() && datetime.IsValid(), wxT("invalid wxDateTime"));

 
     return m_time == datetime.m_time;
 }
 
 inline bool wxDateTime::IsEarlierThan(const wxDateTime& datetime) const
 {
 
     return m_time == datetime.m_time;
 }
 
 inline bool wxDateTime::IsEarlierThan(const wxDateTime& datetime) const
 {

-    wxASSERT_MSG( IsValid() && datetime.IsValid(), _T("invalid wxDateTime"));
+    wxASSERT_MSG( IsValid() && datetime.IsValid(), wxT("invalid wxDateTime"));

 
     return m_time < datetime.m_time;
 }
 
 inline bool wxDateTime::IsLaterThan(const wxDateTime& datetime) const
 {
 
     return m_time < datetime.m_time;
 }
 
 inline bool wxDateTime::IsLaterThan(const wxDateTime& datetime) const
 {

-    wxASSERT_MSG( IsValid() && datetime.IsValid(), _T("invalid wxDateTime"));
+    wxASSERT_MSG( IsValid() && datetime.IsValid(), wxT("invalid wxDateTime"));

 
     return m_time > datetime.m_time;
 }
 
     return m_time > datetime.m_time;
 }


@@ -1815,14 +1876,14 @@ inline bool wxDateTime::IsEqualUpTo(const wxDateTime& dt,
 
 inline wxDateTime wxDateTime::Add(const wxTimeSpan& diff) const
 {
 
 inline wxDateTime wxDateTime::Add(const wxTimeSpan& diff) const
 {

-    wxASSERT_MSG( IsValid(), _T("invalid wxDateTime"));
+    wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime"));

 
     return wxDateTime(m_time + diff.GetValue());
 }
 
 inline wxDateTime& wxDateTime::Add(const wxTimeSpan& diff)
 {
 
     return wxDateTime(m_time + diff.GetValue());
 }
 
 inline wxDateTime& wxDateTime::Add(const wxTimeSpan& diff)
 {

-    wxASSERT_MSG( IsValid(), _T("invalid wxDateTime"));
+    wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime"));

 
     m_time += diff.GetValue();
 
 
     m_time += diff.GetValue();
 


@@ -1836,14 +1897,14 @@ inline wxDateTime& wxDateTime::operator+=(const wxTimeSpan& diff)
 
 inline wxDateTime wxDateTime::Subtract(const wxTimeSpan& diff) const
 {
 
 inline wxDateTime wxDateTime::Subtract(const wxTimeSpan& diff) const
 {

-    wxASSERT_MSG( IsValid(), _T("invalid wxDateTime"));
+    wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime"));

 
     return wxDateTime(m_time - diff.GetValue());
 }
 
 inline wxDateTime& wxDateTime::Subtract(const wxTimeSpan& diff)
 {
 
     return wxDateTime(m_time - diff.GetValue());
 }
 
 inline wxDateTime& wxDateTime::Subtract(const wxTimeSpan& diff)
 {

-    wxASSERT_MSG( IsValid(), _T("invalid wxDateTime"));
+    wxASSERT_MSG( IsValid(), wxT("invalid wxDateTime"));

 
     m_time -= diff.GetValue();
 
 
     m_time -= diff.GetValue();
 


@@ -1857,7 +1918,7 @@ inline wxDateTime& wxDateTime::operator-=(const wxTimeSpan& diff)
 
 inline wxTimeSpan wxDateTime::Subtract(const wxDateTime& datetime) const
 {
 
 inline wxTimeSpan wxDateTime::Subtract(const wxDateTime& datetime) const
 {

-    wxASSERT_MSG( IsValid() && datetime.IsValid(), _T("invalid wxDateTime"));
+    wxASSERT_MSG( IsValid() && datetime.IsValid(), wxT("invalid wxDateTime"));

 
     return wxTimeSpan(GetValue() - datetime.GetValue());
 }
 
     return wxTimeSpan(GetValue() - datetime.GetValue());
 }


@@ -1938,9 +1999,9 @@ inline wxLongLong wxTimeSpan::GetSeconds() const
 
 inline int wxTimeSpan::GetMinutes() const
 {
 
 inline int wxTimeSpan::GetMinutes() const
 {

-    // explicit cast to int suppresses a warning with CodeWarrior and possibly
-    // others (changing the return type to long from int is impossible in 2.8)
-    return (int)((GetSeconds() / 60l).GetLo());
+    // For compatibility, this method (and the other accessors) return int,
+    // even though GetLo() actually returns unsigned long with greater range.
+    return static_cast<int>((GetSeconds() / 60l).GetLo());

 }
 
 inline int wxTimeSpan::GetHours() const
 }
 
 inline int wxTimeSpan::GetHours() const


@@ -2013,6 +2074,11 @@ inline bool wxTimeSpan::IsLongerThan(const wxTimeSpan& ts) const
     return GetValue().Abs() > ts.GetValue().Abs();
 }
 
     return GetValue().Abs() > ts.GetValue().Abs();
 }
 

+inline bool wxTimeSpan::IsShorterThan(const wxTimeSpan& ts) const
+{
+    return GetValue().Abs() < ts.GetValue().Abs();
+}
+

 // ----------------------------------------------------------------------------
 // wxDateSpan
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxDateSpan
 // ----------------------------------------------------------------------------