]> git.saurik.com Git - wxWidgets.git/blobdiff - include/wx/datetime.h
Define WXBUILDING in Xcode projects.
[wxWidgets.git] / include / wx / datetime.h
index aff804a9d28c721c56e3cb0082743e21958130ae..5b6804709a39982e8944acb9ffc649b0477e9e24 100644 (file)
@@ -19,7 +19,7 @@
 
 #ifdef __WXWINCE__
     #include "wx/msw/wince/time.h"
 
 #ifdef __WXWINCE__
     #include "wx/msw/wince/time.h"
-#elif !defined(__WXPALMOS5__)
+#else
     #include <time.h>
 #endif // OS
 
     #include <time.h>
 #endif // OS
 
@@ -31,7 +31,7 @@
 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 __WXMSW__
+#ifdef __WINDOWS__
 struct _SYSTEMTIME;
 #endif
 
 struct _SYSTEMTIME;
 #endif
 
@@ -53,27 +53,6 @@ struct _SYSTEMTIME;
  *   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:
 
@@ -128,8 +107,8 @@ 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 char *) wxDefaultDateTimeFormat;
-extern WXDLLIMPEXP_DATA_BASE(const char *) 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
@@ -139,33 +118,12 @@ extern WXDLLIMPEXP_DATA_BASE(const wxDateTime) wxDefaultDateTime;
 // conditional compilation
 // ----------------------------------------------------------------------------
 
 // conditional compilation
 // ----------------------------------------------------------------------------
 
-#if defined(HAVE_STRPTIME) && defined(__GLIBC__) && \
-        ((__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0))
-    // glibc 2.0.7 strptime() is broken - the following snippet causes it to
-    // crash (instead of just failing):
-    //
-    //      strncpy(buf, "Tue Dec 21 20:25:40 1999", 128);
-    //      strptime(buf, "%x", &tm);
-    //
-    // so don't use it
-    #undef HAVE_STRPTIME
-#endif // broken strptime()
-
-#if defined(HAVE_STRPTIME) && defined(__DARWIN__) && defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
-    // configure detects strptime as linkable because it's in the OS X
-    // System library but MSL headers don't declare it.
-
-//    char *strptime(const char *, const char *, struct tm *);
-    // However, we DON'T want to just provide it here because we would
-    // crash and/or overwrite data when strptime from OS X tries
-    // to fill in MW's struct tm which is two fields shorter (no TZ stuff)
-    // So for now let's just say we don't have strptime
-    #undef HAVE_STRPTIME
-#endif
-
-// everyone has strftime except Win CE unless VC8 is used
-#if !defined(__WXWINCE__) || defined(__VISUALC8__)
-    #define HAVE_STRFTIME
+// 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
 
 // ----------------------------------------------------------------------------
 #endif
 
 // ----------------------------------------------------------------------------
@@ -194,7 +152,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
 
@@ -268,7 +226,7 @@ public:
         // adoption of the Gregorian calendar (see IsGregorian())
         //
         // All data and comments taken verbatim from "The Calendar FAQ (v 2.0)"
         // adoption of the Gregorian calendar (see IsGregorian())
         //
         // All data and comments taken verbatim from "The Calendar FAQ (v 2.0)"
-        // by Claus Tndering, http://www.pip.dknet.dk/~c-t/calendar.html
+        // 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
         // except for the comments "we take".
         //
         // Symbol "->" should be read as "was followed by" in the comments
@@ -450,7 +408,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
     {
@@ -483,7 +441,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;
 
@@ -518,9 +478,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
@@ -645,7 +606,7 @@ 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 __WXMSW__
+#ifdef __WINDOWS__
     wxDateTime(const struct _SYSTEMTIME& st)
     {
         SetFromMSWSysTime(st);
     wxDateTime(const struct _SYSTEMTIME& st)
     {
         SetFromMSWSysTime(st);
@@ -732,7 +693,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.
     // ------------------------------------------------------------------------
 
@@ -967,14 +928,17 @@ public:
 
     // SYSTEMTIME format
     // ------------------------------------------------------------------------
 
     // SYSTEMTIME format
     // ------------------------------------------------------------------------
-#ifdef __WXMSW__
-
+#ifdef __WINDOWS__
     // convert SYSTEMTIME to wxDateTime
     // convert SYSTEMTIME to wxDateTime
-    wxDateTime& SetFromMSWSysTime(const struct _SYSTEMTIME&);
+    wxDateTime& SetFromMSWSysTime(const struct _SYSTEMTIME& st);
 
     // convert wxDateTime to SYSTEMTIME
 
     // convert wxDateTime to SYSTEMTIME
-    void GetAsMSWSysTime(struct _SYSTEMTIME*) const;
-#endif // __WXMSW__
+    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)
     // ------------------------------------------------------------------------
@@ -1006,37 +970,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();
     }
 
@@ -1099,6 +1063,8 @@ 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;
 
+    wxDateSpan DiffAsDateSpan(const wxDateTime& dt) const;
+
     // conversion to/from text
     // ------------------------------------------------------------------------
 
     // conversion to/from text
     // ------------------------------------------------------------------------
 
@@ -1241,6 +1207,52 @@ public:
                                      : wxAnyStrPtr();
     }
 
                                      : 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
     // ------------------------------------------------------------------------
 
@@ -1567,6 +1579,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
@@ -1743,7 +1757,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 */
@@ -1765,9 +1781,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;
 }
@@ -1803,7 +1826,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);
@@ -1834,14 +1857,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;
@@ -1909,21 +1932,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;
 }
@@ -1980,14 +2003,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();
 
@@ -2001,14 +2024,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();
 
@@ -2022,7 +2045,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());
 }
@@ -2103,9 +2126,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