OSX fix

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

diff --git a/include/wx/datetime.h b/include/wx/datetime.h
index e51a7934bf6c1ce706294aa061954aee77fe6029..017c226b8925a8f15cd3958364fed60adc668c92 100644 (file)
--- a/include/wx/datetime.h
+++ b/include/wx/datetime.h
@@ -17,6 +17,8 @@
     #pragma interface "datetime.h"
 #endif
 
     #pragma interface "datetime.h"
 #endif
 

+#if wxUSE_DATETIME
+

 #include <time.h>
 #include <limits.h>             // for INT_MIN
 
 #include <time.h>
 #include <limits.h>             // for INT_MIN
 


@@ -26,16 +28,37 @@ class WXDLLEXPORT wxDateTime;
 class WXDLLEXPORT wxTimeSpan;
 class WXDLLEXPORT wxDateSpan;
 
 class WXDLLEXPORT wxTimeSpan;
 class WXDLLEXPORT wxDateSpan;
 

-// don't use inline functions in debug builds - we don't care about
+// a hack: don't use inline functions in debug builds - we don't care about

 // performances and this only leads to increased rebuild time (because every
 // time an inline method is changed, all files including the header must be
 // rebuilt)
 // performances and this only leads to increased rebuild time (because every
 // time an inline method is changed, all files including the header must be
 // rebuilt)

-#ifdef __WXDEBUG__
+
+// For Mingw32, causes a link error. (VZ: why?)
+#if defined( __WXDEBUG__) && !defined(__MINGW32__)
+    #define wxDATETIME_DONT_INLINE
+
+    #undef inline

     #define inline
     #define inline

+#else
+    // just in case
+    #undef wxDATETIME_DONT_INLINE

 #endif // Debug
 
 #endif // Debug
 

+// not all c-runtimes are based on 1/1/1970 being (time_t) 0
+// set this to the corresponding value in seconds 1/1/1970 has on your
+// systems c-runtime
+
+#ifdef __WXMAC__
+#if __MSL__ < 0x6000
+    #define WX_TIME_BASE_OFFSET ( 2082844800L + 126144000L )
+#else
+    #define WX_TIME_BASE_OFFSET 0
+#endif
+#else
+    #define WX_TIME_BASE_OFFSET 0
+#endif

 /*
 /*

- * TODO Well, everything :-)
+ * TODO

  *
  * + 1. Time zones with minutes (make TimeZone a class)
  * ? 2. getdate() function like under Solaris
  *
  * + 1. Time zones with minutes (make TimeZone a class)
  * ? 2. getdate() function like under Solaris


@@ -63,7 +86,7 @@ class WXDLLEXPORT wxDateSpan;
   wxTimeSpan + wxTimeSpan = wxTimeSpan
   wxDateSpan + wxDateSpan = wxDateSpan
 
   wxTimeSpan + wxTimeSpan = wxTimeSpan
   wxDateSpan + wxDateSpan = wxDateSpan
 

-  substraction
+  subtraction

   ------------
   wxDateTime - wxDateTime = wxTimeSpan
   wxDateTime - wxTimeSpan = wxDateTime
   ------------
   wxDateTime - wxDateTime = wxTimeSpan
   wxDateTime - wxTimeSpan = wxDateTime


@@ -84,7 +107,7 @@ class WXDLLEXPORT wxDateSpan;
   -wxDateSpan = wxDateSpan
 
   For each binary operation OP (+, -, *) we have the following operatorOP=() as
   -wxDateSpan = wxDateSpan
 
   For each binary operation OP (+, -, *) we have the following operatorOP=() as

-  a method and the method with a symbolic name OPER (Add, Substract, Multiply)
+  a method and the method with a symbolic name OPER (Add, Subtract, Multiply)

   as a synonym for it and another const method with the same name which returns
   the changed copy of the object and operatorOP() as a global function which is
   implemented in terms of the const version of OPEN. For the unary - we have
   as a synonym for it and another const method with the same name which returns
   the changed copy of the object and operatorOP() as a global function which is
   implemented in terms of the const version of OPEN. For the unary - we have


@@ -98,7 +121,7 @@ class WXDLLEXPORT wxDateSpan;
 // wxInvalidDateTime)
 class WXDLLEXPORT wxDateTime;
 
 // wxInvalidDateTime)
 class WXDLLEXPORT wxDateTime;
 

-WXDLLEXPORT_DATA(extern wxDateTime&) wxDefaultDateTime;
+WXDLLEXPORT_DATA(extern const wxDateTime) wxDefaultDateTime;

 #define wxInvalidDateTime wxDefaultDateTime
 
 // ----------------------------------------------------------------------------
 #define wxInvalidDateTime wxDefaultDateTime
 
 // ----------------------------------------------------------------------------


@@ -397,7 +420,7 @@ public:
         // NB: this struct should always be kept normalized (i.e. mon should
         //     be < 12, 1 <= day <= 31 &c), so use AddMonths(), AddDays()
         //     instead of modifying the member fields directly!
         // NB: this struct should always be kept normalized (i.e. mon should
         //     be < 12, 1 <= day <= 31 &c), so use AddMonths(), AddDays()
         //     instead of modifying the member fields directly!

-    struct Tm
+    struct WXDLLEXPORT Tm

     {
         wxDateTime_t msec, sec, min, hour, mday;
         Month mon;
     {
         wxDateTime_t msec, sec, min, hour, mday;
         Month mon;


@@ -510,6 +533,10 @@ public:
         // return the wxDateTime object for the current time
     static inline wxDateTime Now();
 
         // return the wxDateTime object for the current time
     static inline wxDateTime Now();
 

+        // return the wxDateTime object for the current time with millisecond
+        // precision (if available on this platform)
+    static wxDateTime UNow();
+

         // return the wxDateTime object for today midnight: i.e. as Now() but
         // with time set to 0
     static inline wxDateTime Today();
         // return the wxDateTime object for today midnight: i.e. as Now() but
         // with time set to 0
     static inline wxDateTime Today();


@@ -520,10 +547,13 @@ public:
     // ------------------------------------------------------------------------
 
         // default ctor does not initialize the object, use Set()!
     // ------------------------------------------------------------------------
 
         // default ctor does not initialize the object, use Set()!

-    wxDateTime() { }
+    wxDateTime() { m_time = wxLongLong((long)ULONG_MAX, ULONG_MAX); }

 
         // from time_t: seconds since the Epoch 00:00:00 UTC, Jan 1, 1970)
 
         // from time_t: seconds since the Epoch 00:00:00 UTC, Jan 1, 1970)

+#if (!(defined(__VISAGECPP__) && __IBMCPP__ >= 400))
+// VA C++ confuses this with wxDateTime(double jdn) thinking it is a duplicate declaration

     inline wxDateTime(time_t timet);
     inline wxDateTime(time_t timet);

+#endif

         // from broken down time/date (only for standard Unix range)
     inline wxDateTime(const struct tm& tm);
         // from broken down time/date (any range)
         // from broken down time/date (only for standard Unix range)
     inline wxDateTime(const struct tm& tm);
         // from broken down time/date (any range)


@@ -539,7 +569,7 @@ public:
                       wxDateTime_t millisec = 0);
         // from separate values for each component with explicit date
     inline wxDateTime(wxDateTime_t day,             // day of the month
                       wxDateTime_t millisec = 0);
         // from separate values for each component with explicit date
     inline wxDateTime(wxDateTime_t day,             // day of the month

-                      Month        month = Inv_Month,
+                      Month        month,

                       int          year = Inv_Year, // 1999, not 99 please!
                       wxDateTime_t hour = 0,
                       wxDateTime_t minute = 0,
                       int          year = Inv_Year, // 1999, not 99 please!
                       wxDateTime_t hour = 0,
                       wxDateTime_t minute = 0,


@@ -558,8 +588,11 @@ public:
         // set to the current time
     inline wxDateTime& SetToCurrent();
 
         // set to the current time
     inline wxDateTime& SetToCurrent();
 

+#if (!(defined(__VISAGECPP__) && __IBMCPP__ >= 400))
+// VA C++ confuses this with wxDateTime(double jdn) thinking it is a duplicate declaration

         // set to given time_t value
     inline wxDateTime& Set(time_t timet);
         // set to given time_t value
     inline wxDateTime& Set(time_t timet);

+#endif

 
         // set to given broken down time/date
     wxDateTime& Set(const struct tm& tm);
 
         // set to given broken down time/date
     wxDateTime& Set(const struct tm& tm);


@@ -579,7 +612,7 @@ public:
         // from separate values for each component with explicit date
         // (defaults for month and year are the current values)
     wxDateTime& Set(wxDateTime_t day,
         // from separate values for each component with explicit date
         // (defaults for month and year are the current values)
     wxDateTime& Set(wxDateTime_t day,

-                    Month        month = Inv_Month,
+                    Month        month,

                     int          year = Inv_Year, // 1999, not 99 please!
                     wxDateTime_t hour = 0,
                     wxDateTime_t minute = 0,
                     int          year = Inv_Year, // 1999, not 99 please!
                     wxDateTime_t hour = 0,
                     wxDateTime_t minute = 0,


@@ -748,8 +781,8 @@ public:
     // result of timezone shift)
     // ------------------------------------------------------------------------
 
     // result of timezone shift)
     // ------------------------------------------------------------------------
 

-        // is the date valid (TRUE even for non initialized objects)?
-    inline bool IsValid() const { return this != &wxInvalidDateTime; }
+        // is the date valid?
+    inline bool IsValid() const { return m_time != wxInvalidDateTime.m_time; }

 
         // get the broken down date/time representation in the given timezone
         //
 
         // get the broken down date/time representation in the given timezone
         //


@@ -763,28 +796,28 @@ public:
     inline time_t GetTicks() const;
 
         // get the year (returns Inv_Year if date is invalid)
     inline time_t GetTicks() const;
 
         // get the year (returns Inv_Year if date is invalid)

-    int GetYear(const TimeZone& tz = Local) const 
+    int GetYear(const TimeZone& tz = Local) const

             { return GetTm(tz).year; }
         // get the month (Inv_Month if date is invalid)
             { return GetTm(tz).year; }
         // get the month (Inv_Month if date is invalid)

-    Month GetMonth(const TimeZone& tz = Local) const 
+    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)
             { return (Month)GetTm(tz).mon; }
         // get the month day (in 1..31 range, 0 if date is invalid)

-    wxDateTime_t GetDay(const TimeZone& tz = Local) const 
+    wxDateTime_t GetDay(const TimeZone& tz = Local) const

             { return GetTm(tz).mday; }
         // get the day of the week (Inv_WeekDay if date is invalid)
             { return GetTm(tz).mday; }
         // get the day of the week (Inv_WeekDay if date is invalid)

-    WeekDay GetWeekDay(const TimeZone& tz = Local) const 
+    WeekDay GetWeekDay(const TimeZone& tz = Local) const

             { return GetTm(tz).GetWeekDay(); }
         // get the hour of the day
             { return GetTm(tz).GetWeekDay(); }
         // get the hour of the day

-    wxDateTime_t GetHour(const TimeZone& tz = Local) const 
+    wxDateTime_t GetHour(const TimeZone& tz = Local) const

             { return GetTm(tz).hour; }
         // get the minute
             { return GetTm(tz).hour; }
         // get the minute

-    wxDateTime_t GetMinute(const TimeZone& tz = Local) const 
+    wxDateTime_t GetMinute(const TimeZone& tz = Local) const

             { return GetTm(tz).min; }
         // get the second
             { return GetTm(tz).min; }
         // get the second

-    wxDateTime_t GetSecond(const TimeZone& tz = Local) const 
+    wxDateTime_t GetSecond(const TimeZone& tz = Local) const

             { return GetTm(tz).sec; }
         // get milliseconds
             { return GetTm(tz).sec; }
         // get milliseconds

-    wxDateTime_t GetMillisecond(const TimeZone& tz = Local) const 
+    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)
             { return GetTm(tz).msec; }
 
         // get the day since the year start (1..366, 0 if date is invalid)


@@ -849,10 +882,10 @@ public:
     inline wxDateTime& operator+=(const wxTimeSpan& diff);
 
         // return the difference of the date with a time span
     inline wxDateTime& operator+=(const wxTimeSpan& diff);
 
         // return the difference of the date with a time span

-    inline wxDateTime Substract(const wxTimeSpan& diff) const;
-        // substract a time span (positive or negative)
-    inline wxDateTime& Substract(const wxTimeSpan& diff);
-        // substract a time span (positive or negative)
+    inline wxDateTime Subtract(const wxTimeSpan& diff) const;
+        // subtract a time span (positive or negative)
+    inline wxDateTime& Subtract(const wxTimeSpan& diff);
+        // subtract a time span (positive or negative)

     inline wxDateTime& operator-=(const wxTimeSpan& diff);
 
         // return the sum of the date with a date span
     inline wxDateTime& operator-=(const wxTimeSpan& diff);
 
         // return the sum of the date with a date span


@@ -863,14 +896,14 @@ public:
     inline wxDateTime& operator+=(const wxDateSpan& diff);
 
         // return the difference of the date with a date span
     inline wxDateTime& operator+=(const wxDateSpan& diff);
 
         // return the difference of the date with a date span

-    inline wxDateTime Substract(const wxDateSpan& diff) const;
-        // substract a date span (positive or negative)
-    inline wxDateTime& Substract(const wxDateSpan& diff);
-        // substract a date span (positive or negative)
+    inline wxDateTime Subtract(const wxDateSpan& diff) const;
+        // subtract a date span (positive or negative)
+    inline wxDateTime& Subtract(const wxDateSpan& diff);
+        // subtract a date span (positive or negative)

     inline wxDateTime& operator-=(const wxDateSpan& diff);
 
         // return the difference between two dates
     inline wxDateTime& operator-=(const wxDateSpan& diff);
 
         // return the difference between two dates

-    inline wxTimeSpan Substract(const wxDateTime& dt) const;
+    inline wxTimeSpan Subtract(const wxDateTime& dt) 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
 
     // conversion to/from text: all conversions from text return the pointer to
     // the next character following the date specification (i.e. the one where


@@ -955,7 +988,7 @@ private:
 
 // ----------------------------------------------------------------------------
 // This class contains a difference between 2 wxDateTime values, so it makes
 
 // ----------------------------------------------------------------------------
 // This class contains a difference between 2 wxDateTime values, so it makes

-// sense to add it to wxDateTime and it is the result of substraction of 2
+// sense to add it to wxDateTime and it is the result of subtraction of 2

 // objects of that class. See also wxDateSpan.
 // ----------------------------------------------------------------------------
 
 // objects of that class. See also wxDateSpan.
 // ----------------------------------------------------------------------------
 


@@ -966,23 +999,23 @@ public:
     // ------------------------------------------------------------------------
 
         // return the timespan for the given number of seconds
     // ------------------------------------------------------------------------
 
         // return the timespan for the given number of seconds

-    static wxTimeSpan Seconds(int sec) { return wxTimeSpan(0, 0, sec); }
+    static wxTimeSpan Seconds(long sec) { return wxTimeSpan(0, 0, sec); }

     static wxTimeSpan Second() { return Seconds(1); }
 
         // return the timespan for the given number of minutes
     static wxTimeSpan Second() { return Seconds(1); }
 
         // return the timespan for the given number of minutes

-    static wxTimeSpan Minutes(int min) { return wxTimeSpan(0, min, 0 ); }
+    static wxTimeSpan Minutes(long min) { return wxTimeSpan(0, min, 0 ); }

     static wxTimeSpan Minute() { return Minutes(1); }
 
         // return the timespan for the given number of hours
     static wxTimeSpan Minute() { return Minutes(1); }
 
         // return the timespan for the given number of hours

-    static wxTimeSpan Hours(int hours) { return wxTimeSpan(hours, 0, 0); }
+    static wxTimeSpan Hours(long hours) { return wxTimeSpan(hours, 0, 0); }

     static wxTimeSpan Hour() { return Hours(1); }
 
         // return the timespan for the given number of days
     static wxTimeSpan Hour() { return Hours(1); }
 
         // return the timespan for the given number of days

-    static wxTimeSpan Days(int days) { return Hours(24 * days); }
+    static wxTimeSpan Days(long days) { return Hours(24 * days); }

     static wxTimeSpan Day() { return Days(1); }
 
         // return the timespan for the given number of weeks
     static wxTimeSpan Day() { return Days(1); }
 
         // return the timespan for the given number of weeks

-    static wxTimeSpan Weeks(int days) { return Days(7 * days); }
+    static wxTimeSpan Weeks(long days) { return Days(7 * days); }

     static wxTimeSpan Week() { return Weeks(1); }
 
         // default ctor constructs the 0 time span
     static wxTimeSpan Week() { return Weeks(1); }
 
         // default ctor constructs the 0 time span


@@ -991,10 +1024,10 @@ public:
         // from separate values for each component, date set to 0 (hours are
         // not restricted to 0..24 range, neither are minutes, seconds or
         // milliseconds)
         // from separate values for each component, date set to 0 (hours are
         // not restricted to 0..24 range, neither are minutes, seconds or
         // milliseconds)

-    inline wxTimeSpan(int hours,
-                      int minutes = 0,
-                      int seconds = 0,
-                      int milliseconds = 0);
+    inline wxTimeSpan(long hours,
+                      long minutes = 0,
+                      long seconds = 0,
+                      long milliseconds = 0);

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


@@ -1011,11 +1044,11 @@ public:
     wxTimeSpan& operator+=(const wxTimeSpan& diff) { return Add(diff); }
 
         // return the difference of two timespans
     wxTimeSpan& operator+=(const wxTimeSpan& diff) { return Add(diff); }
 
         // return the difference of two timespans

-    inline wxTimeSpan Substract(const wxTimeSpan& diff) const;
-        // substract another timespan
-    inline wxTimeSpan& Substract(const wxTimeSpan& diff);
-        // substract another timespan
-    wxTimeSpan& operator-=(const wxTimeSpan& diff) { return Substract(diff); }
+    inline wxTimeSpan Subtract(const wxTimeSpan& diff) const;
+        // subtract another timespan
+    inline wxTimeSpan& Subtract(const wxTimeSpan& diff);
+        // subtract another timespan
+    wxTimeSpan& operator-=(const wxTimeSpan& diff) { return Subtract(diff); }

 
         // multiply timespan by a scalar
     inline wxTimeSpan Multiply(int n) const;
 
         // multiply timespan by a scalar
     inline wxTimeSpan Multiply(int n) const;


@@ -1088,11 +1121,7 @@ public:
         // resulting text representation. Notice that only some of format
         // specifiers valid for wxDateTime are valid for wxTimeSpan: hours,
         // minutes and seconds make sense, but not "PM/AM" string for example.
         // resulting text representation. Notice that only some of format
         // specifiers valid for wxDateTime are valid for wxTimeSpan: hours,
         // minutes and seconds make sense, but not "PM/AM" string for example.

-    wxString Format(const wxChar *format = _T("%c")) const;
-        // preferred date representation for the current locale
-    wxString FormatDate() const { return Format(_T("%x")); }
-        // preferred time representation for the current locale
-    wxString FormatTime() const { return Format(_T("%X")); }
+    wxString Format(const wxChar *format = _T("%H:%M:%S")) const;

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


@@ -1119,7 +1148,7 @@ private:
 // won't be changed unless the resulting date would be invalid: for example,
 // Jan 31 + 1 month will be Feb 28, not (non existing) Feb 31.
 //
 // won't be changed unless the resulting date would be invalid: for example,
 // Jan 31 + 1 month will be Feb 28, not (non existing) Feb 31.
 //

-// Because of this feature, adding and substracting back again the same
+// Because of this feature, adding and subtracting back again the same

 // wxDateSpan will *not*, in general give back the original date: Feb 28 - 1
 // month will be Jan 28, not Jan 31!
 //
 // wxDateSpan will *not*, in general give back the original date: Feb 28 - 1
 // month will be Jan 28, not Jan 31!
 //


@@ -1206,10 +1235,10 @@ public:
     inline wxDateSpan& operator+=(const wxDateSpan& other);
 
         // return difference of two date spans
     inline wxDateSpan& operator+=(const wxDateSpan& other);
 
         // return difference of two date spans

-    inline wxDateSpan Substract(const wxDateSpan& other) const;
-        // substract another wxDateSpan from us
-    inline wxDateSpan& Substract(const wxDateSpan& other);
-        // substract another wxDateSpan from us
+    inline wxDateSpan Subtract(const wxDateSpan& other) const;
+        // subtract another wxDateSpan from us
+    inline wxDateSpan& Subtract(const wxDateSpan& other);
+        // subtract another wxDateSpan from us

     inline wxDateSpan& operator-=(const wxDateSpan& other);
 
         // return a copy of this time span with changed sign
     inline wxDateSpan& operator-=(const wxDateSpan& other);
 
         // return a copy of this time span with changed sign


@@ -1239,7 +1268,7 @@ private:
 
 #include "wx/dynarray.h"
 
 
 #include "wx/dynarray.h"
 

-WX_DECLARE_OBJARRAY(wxDateTime, wxDateTimeArray);
+WX_DECLARE_EXPORTED_OBJARRAY(wxDateTime, wxDateTimeArray);

 
 // ----------------------------------------------------------------------------
 // wxDateTimeHolidayAuthority: an object of this class will decide whether a
 
 // ----------------------------------------------------------------------------
 // wxDateTimeHolidayAuthority: an object of this class will decide whether a


@@ -1251,10 +1280,12 @@ WX_DECLARE_OBJARRAY(wxDateTime, wxDateTimeArray);
 // ----------------------------------------------------------------------------
 
 class WXDLLEXPORT wxDateTimeHolidayAuthority;
 // ----------------------------------------------------------------------------
 
 class WXDLLEXPORT wxDateTimeHolidayAuthority;

-WX_DEFINE_ARRAY(wxDateTimeHolidayAuthority *, wxHolidayAuthoritiesArray);
+WX_DEFINE_EXPORTED_ARRAY(wxDateTimeHolidayAuthority *, wxHolidayAuthoritiesArray);

 
 

+class wxDateTimeHolidaysModule;

 class WXDLLEXPORT wxDateTimeHolidayAuthority
 {
 class WXDLLEXPORT wxDateTimeHolidayAuthority
 {

+friend class wxDateTimeHolidaysModule;

 public:
     // returns TRUE if the given date is a holiday
     static bool IsHoliday(const wxDateTime& dt);
 public:
     // returns TRUE if the given date is a holiday
     static bool IsHoliday(const wxDateTime& dt);


@@ -1311,14 +1342,16 @@ protected:
 // else than datetime.cpp in debug builds: this minimizes rebuilds if we change
 // some inline function and the performance doesn't matter in the debug builds.
 
 // else than datetime.cpp in debug builds: this minimizes rebuilds if we change
 // some inline function and the performance doesn't matter in the debug builds.
 

-#if !defined(__WXDEBUG__) || defined(wxDEFINE_TIME_CONSTANTS)
+#if !defined(wxDATETIME_DONT_INLINE) || defined(wxDEFINE_TIME_CONSTANTS)

     #define INCLUDED_FROM_WX_DATETIME_H
         #include "wx/datetime.inl"
     #undef INCLUDED_FROM_WX_DATETIME_H
 #endif
 
 // if we defined it to be empty above, restore it now
     #define INCLUDED_FROM_WX_DATETIME_H
         #include "wx/datetime.inl"
     #undef INCLUDED_FROM_WX_DATETIME_H
 #endif
 
 // if we defined it to be empty above, restore it now

-#undef inline
+#ifdef wxDATETIME_DONT_INLINE
+    #undef inline
+#endif

 
 // ============================================================================
 // binary operators
 
 // ============================================================================
 // binary operators


@@ -1342,7 +1375,7 @@ inline wxDateTime WXDLLEXPORT operator+(const wxDateTime& dt,
 inline wxDateTime WXDLLEXPORT operator-(const wxDateTime& dt,
                                         const wxTimeSpan& ts)
 {
 inline wxDateTime WXDLLEXPORT operator-(const wxDateTime& dt,
                                         const wxTimeSpan& ts)
 {

-    return dt.Substract(ts);
+    return dt.Subtract(ts);

 }
 
 inline wxDateTime WXDLLEXPORT operator+(const wxDateTime& dt,
 }
 
 inline wxDateTime WXDLLEXPORT operator+(const wxDateTime& dt,


@@ -1354,13 +1387,13 @@ inline wxDateTime WXDLLEXPORT operator+(const wxDateTime& dt,
 inline wxDateTime WXDLLEXPORT operator-(const wxDateTime& dt,
                                         const wxDateSpan& ds)
 {
 inline wxDateTime WXDLLEXPORT operator-(const wxDateTime& dt,
                                         const wxDateSpan& ds)
 {

-    return dt.Substract(ds);
+    return dt.Subtract(ds);

 }
 
 inline wxTimeSpan WXDLLEXPORT operator-(const wxDateTime& dt1,
                                         const wxDateTime& dt2)
 {
 }
 
 inline wxTimeSpan WXDLLEXPORT operator-(const wxDateTime& dt1,
                                         const wxDateTime& dt2)
 {

-    return dt1.Substract(dt2);
+    return dt1.Subtract(dt2);

 }
 
 // comparison
 }
 
 // comparison


@@ -1547,4 +1580,6 @@ inline WXDLLEXPORT void wxPrevWDay(wxDateTime::WeekDay& wd)
                                : (wxDateTime::WeekDay)(wd - 1);
 }
 
                                : (wxDateTime::WeekDay)(wd - 1);
 }
 

+#endif // wxUSE_DATETIME
+

 #endif // _WX_DATETIME_H
 #endif // _WX_DATETIME_H