wxNotebook::HitTest() for wxMSW added (patch 748469)

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

diff --git a/include/wx/datetime.h b/include/wx/datetime.h
index 92398e53f2ae1e2893a897fa42d40de4a6e23c3f..c5cc70082697f5bf7dec8344faa4ec598274fe76 100644 (file)
--- a/include/wx/datetime.h
+++ b/include/wx/datetime.h
@@ -7,48 +7,54 @@
 // Created:     10.02.99
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Created:     10.02.99
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>

-// Licence:     wxWindows license
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_DATETIME_H
 #define _WX_DATETIME_H
 
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_DATETIME_H
 #define _WX_DATETIME_H
 

-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(__APPLE__)

     #pragma interface "datetime.h"
 #endif
 
     #pragma interface "datetime.h"
 #endif
 

+#include "wx/defs.h"
+
+#if wxUSE_DATETIME
+

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

-class WXDLLEXPORT wxDateTime;
-class WXDLLEXPORT wxTimeSpan;
-class WXDLLEXPORT wxDateSpan;
+class WXDLLIMPEXP_BASE wxDateTime;
+class WXDLLIMPEXP_BASE wxTimeSpan;
+class WXDLLIMPEXP_BASE 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)

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

     #undef inline
     #define inline
     #undef inline
     #define inline

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

 #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
 
 #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
+#if defined(__WXMAC__) && !defined(__DARWIN__) && __MSL__ < 0x6000

     #define WX_TIME_BASE_OFFSET ( 2082844800L + 126144000L )
 #else
     #define WX_TIME_BASE_OFFSET 0
 #endif
     #define WX_TIME_BASE_OFFSET ( 2082844800L + 126144000L )
 #else
     #define WX_TIME_BASE_OFFSET 0
 #endif

-#else
-    #define WX_TIME_BASE_OFFSET 0
-#endif

 /*
  * TODO
  *
 /*
  * TODO
  *


@@ -111,16 +117,16 @@ class WXDLLEXPORT wxDateSpan;
 // argument for arguments of type wxDateTime; it is also returned by all
 // functions returning wxDateTime on failure (this is why it is also called
 // wxInvalidDateTime)
 // argument for arguments of type wxDateTime; it is also returned by all
 // functions returning wxDateTime on failure (this is why it is also called
 // wxInvalidDateTime)

-class WXDLLEXPORT wxDateTime;
+class WXDLLIMPEXP_BASE wxDateTime;

 
 

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

 #define wxInvalidDateTime wxDefaultDateTime
 
 // ----------------------------------------------------------------------------
 // wxDateTime represents an absolute moment in the time
 // ----------------------------------------------------------------------------
 
 #define wxInvalidDateTime wxDefaultDateTime
 
 // ----------------------------------------------------------------------------
 // wxDateTime represents an absolute moment in the time
 // ----------------------------------------------------------------------------
 

-class WXDLLEXPORT wxDateTime
+class WXDLLIMPEXP_BASE wxDateTime

 {
 public:
     // types
 {
 public:
     // types


@@ -392,7 +398,7 @@ public:
 
         // a class representing a time zone: basicly, this is just an offset
         // (in seconds) from GMT
 
         // a class representing a time zone: basicly, this is just an offset
         // (in seconds) from GMT

-    class WXDLLEXPORT TimeZone
+    class WXDLLIMPEXP_BASE TimeZone

     {
     public:
         TimeZone(TZ tz);
     {
     public:
         TimeZone(TZ tz);


@@ -412,7 +418,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 WXDLLEXPORT Tm
+    struct WXDLLIMPEXP_BASE Tm

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


@@ -539,7 +545,7 @@ 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)
 #if (!(defined(__VISAGECPP__) && __IBMCPP__ >= 400))
 
         // from time_t: seconds since the Epoch 00:00:00 UTC, Jan 1, 1970)
 #if (!(defined(__VISAGECPP__) && __IBMCPP__ >= 400))


@@ -649,8 +655,10 @@ public:
     // ------------------------------------------------------------------------
 
         // set to the given week day in the same week as this one
     // ------------------------------------------------------------------------
 
         // set to the given week day in the same week as this one

-    wxDateTime& SetToWeekDayInSameWeek(WeekDay weekday);
-    inline wxDateTime GetWeekDayInSameWeek(WeekDay weekday) const;
+    wxDateTime& SetToWeekDayInSameWeek(WeekDay weekday,
+                                       WeekFlags flags = Monday_First);
+    inline wxDateTime GetWeekDayInSameWeek(WeekDay weekday,
+                                           WeekFlags flags = Monday_First) const;

 
         // set to the next week day following this one
     wxDateTime& SetToNextWeekDay(WeekDay weekday);
 
         // set to the next week day following this one
     wxDateTime& SetToNextWeekDay(WeekDay weekday);


@@ -684,8 +692,12 @@ public:
         // sets the date to the given day of the given week in the year,
         // returns TRUE on success and FALSE if given date doesn't exist (e.g.
         // numWeek is > 53)
         // sets the date to the given day of the given week in the year,
         // returns TRUE on success and FALSE if given date doesn't exist (e.g.
         // numWeek is > 53)

-    bool SetToTheWeek(wxDateTime_t numWeek, WeekDay weekday = Mon);
-    inline wxDateTime GetWeek(wxDateTime_t numWeek, WeekDay weekday = Mon) const;
+    bool SetToTheWeek(wxDateTime_t numWeek,
+                      WeekDay weekday = Mon,
+                      WeekFlags flags = Monday_First);
+    inline wxDateTime GetWeek(wxDateTime_t numWeek,
+                              WeekDay weekday = Mon,
+                              WeekFlags flags = Monday_First) const;

 
         // sets the date to the last day of the given (or current) month or the
         // given (or current) year
 
         // sets the date to the last day of the given (or current) month or the
         // given (or current) year


@@ -773,8 +785,7 @@ public:
     // result of timezone shift)
     // ------------------------------------------------------------------------
 
     // result of timezone shift)
     // ------------------------------------------------------------------------
 

-        // is the date valid? Note that this will return TRUE for non
-        // initialized objects but FALSE if *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
     inline bool IsValid() const { return m_time != wxInvalidDateTime.m_time; }
 
         // get the broken down date/time representation in the given timezone


@@ -836,6 +847,15 @@ 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;
 

+    // dos date and time format
+    // ------------------------------------------------------------------------
+
+        // set from the DOS packed format
+    wxDateTime& SetFromDOS(unsigned long ddt);
+
+        // pack the date in DOS format
+    unsigned long GetAsDOS() const;
+

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


@@ -985,7 +1005,7 @@ private:
 // objects of that class. See also wxDateSpan.
 // ----------------------------------------------------------------------------
 
 // objects of that class. See also wxDateSpan.
 // ----------------------------------------------------------------------------
 

-class WXDLLEXPORT wxTimeSpan
+class WXDLLIMPEXP_BASE wxTimeSpan

 {
 public:
     // constructors
 {
 public:
     // constructors


@@ -1154,12 +1174,18 @@ private:
 // Beware about weeks: if you specify both weeks and days, the total number of
 // days added will be 7*weeks + days! See also GetTotalDays() function.
 //
 // Beware about weeks: if you specify both weeks and days, the total number of
 // days added will be 7*weeks + days! See also GetTotalDays() function.
 //

+// Equality operators are defined for wxDateSpans. Two datespans are equal if
+// they both give the same target date when added to *every* source date.
+// Thus wxDateSpan::Months(1) is not equal to wxDateSpan::Days(30), because
+// they not give the same date when added to 1 Feb. But wxDateSpan::Days(14) is
+// equal to wxDateSpan::Weeks(2)
+//

 // Finally, notice that for adding hours, minutes &c you don't need this
 // class: wxTimeSpan will do the job because there are no subtleties
 // associated with those.
 // ----------------------------------------------------------------------------
 
 // Finally, notice that for adding hours, minutes &c you don't need this
 // class: wxTimeSpan will do the job because there are no subtleties
 // associated with those.
 // ----------------------------------------------------------------------------
 

-class WXDLLEXPORT wxDateSpan
+class WXDLLIMPEXP_BASE wxDateSpan

 {
 public:
     // constructors
 {
 public:
     // constructors


@@ -1261,7 +1287,7 @@ private:
 
 #include "wx/dynarray.h"
 
 
 #include "wx/dynarray.h"
 

-WX_DECLARE_EXPORTED_OBJARRAY(wxDateTime, wxDateTimeArray);
+WX_DECLARE_USER_EXPORTED_OBJARRAY(wxDateTime, wxDateTimeArray, WXDLLIMPEXP_BASE);

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


@@ -1272,11 +1298,13 @@ WX_DECLARE_EXPORTED_OBJARRAY(wxDateTime, wxDateTimeArray);
 //     virtual methods to work with the holidays they correspond to.
 // ----------------------------------------------------------------------------
 
 //     virtual methods to work with the holidays they correspond to.
 // ----------------------------------------------------------------------------
 

-class WXDLLEXPORT wxDateTimeHolidayAuthority;
-WX_DEFINE_EXPORTED_ARRAY(wxDateTimeHolidayAuthority *, wxHolidayAuthoritiesArray);
+class WXDLLIMPEXP_BASE wxDateTimeHolidayAuthority;
+WX_DEFINE_USER_EXPORTED_ARRAY(wxDateTimeHolidayAuthority *,
+                              wxHolidayAuthoritiesArray,
+                              class WXDLLIMPEXP_BASE);

 
 class wxDateTimeHolidaysModule;
 
 class wxDateTimeHolidaysModule;

-class WXDLLEXPORT wxDateTimeHolidayAuthority
+class WXDLLIMPEXP_BASE wxDateTimeHolidayAuthority

 {
 friend class wxDateTimeHolidaysModule;
 public:
 {
 friend class wxDateTimeHolidaysModule;
 public:


@@ -1296,6 +1324,9 @@ public:
     // wxDateTimeHolidayAuthority)
     static void AddAuthority(wxDateTimeHolidayAuthority *auth);
 
     // wxDateTimeHolidayAuthority)
     static void AddAuthority(wxDateTimeHolidayAuthority *auth);
 

+    // the base class must have a virtual dtor
+    virtual ~wxDateTimeHolidayAuthority();
+

 protected:
     // this function is called to determine whether a given day is a holiday
     virtual bool DoIsHoliday(const wxDateTime& dt) const = 0;
 protected:
     // this function is called to determine whether a given day is a holiday
     virtual bool DoIsHoliday(const wxDateTime& dt) const = 0;


@@ -1318,7 +1349,7 @@ private:
 };
 
 // the holidays for this class are all Saturdays and Sundays
 };
 
 // the holidays for this class are all Saturdays and Sundays

-class WXDLLEXPORT wxDateTimeWorkDays : public wxDateTimeHolidayAuthority
+class WXDLLIMPEXP_BASE wxDateTimeWorkDays : public wxDateTimeHolidayAuthority

 {
 protected:
     virtual bool DoIsHoliday(const wxDateTime& dt) const;
 {
 protected:
     virtual bool DoIsHoliday(const wxDateTime& dt) const;


@@ -1335,14 +1366,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


@@ -1357,31 +1390,31 @@ protected:
 
 // no need to check for validity - the member functions we call will do it
 
 
 // no need to check for validity - the member functions we call will do it
 

-inline wxDateTime WXDLLEXPORT operator+(const wxDateTime& dt,
+inline wxDateTime WXDLLIMPEXP_BASE operator+(const wxDateTime& dt,

                                         const wxTimeSpan& ts)
 {
     return dt.Add(ts);
 }
 
                                         const wxTimeSpan& ts)
 {
     return dt.Add(ts);
 }
 

-inline wxDateTime WXDLLEXPORT operator-(const wxDateTime& dt,
+inline wxDateTime WXDLLIMPEXP_BASE operator-(const wxDateTime& dt,

                                         const wxTimeSpan& ts)
 {
     return dt.Subtract(ts);
 }
 
                                         const wxTimeSpan& ts)
 {
     return dt.Subtract(ts);
 }
 

-inline wxDateTime WXDLLEXPORT operator+(const wxDateTime& dt,
+inline wxDateTime WXDLLIMPEXP_BASE operator+(const wxDateTime& dt,

                                         const wxDateSpan& ds)
 {
     return dt.Add(ds);
 }
 
                                         const wxDateSpan& ds)
 {
     return dt.Add(ds);
 }
 

-inline wxDateTime WXDLLEXPORT operator-(const wxDateTime& dt,
+inline wxDateTime WXDLLIMPEXP_BASE operator-(const wxDateTime& dt,

                                         const wxDateSpan& ds)
 {
     return dt.Subtract(ds);
 }
 
                                         const wxDateSpan& ds)
 {
     return dt.Subtract(ds);
 }
 

-inline wxTimeSpan WXDLLEXPORT operator-(const wxDateTime& dt1,
+inline wxTimeSpan WXDLLIMPEXP_BASE operator-(const wxDateTime& dt1,

                                         const wxDateTime& dt2)
 {
     return dt1.Subtract(dt2);
                                         const wxDateTime& dt2)
 {
     return dt1.Subtract(dt2);


@@ -1390,42 +1423,42 @@ inline wxTimeSpan WXDLLEXPORT operator-(const wxDateTime& dt1,
 // comparison
 // ----------
 
 // comparison
 // ----------
 

-inline bool WXDLLEXPORT operator<(const wxDateTime& t1, const wxDateTime& t2)
+inline bool WXDLLIMPEXP_BASE operator<(const wxDateTime& t1, const wxDateTime& t2)

 {
     wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") );
 
     return t1.GetValue() < t2.GetValue();
 }
 
 {
     wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") );
 
     return t1.GetValue() < t2.GetValue();
 }
 

-inline bool WXDLLEXPORT operator<=(const wxDateTime& t1, const wxDateTime& t2)
+inline bool WXDLLIMPEXP_BASE operator<=(const wxDateTime& t1, const wxDateTime& t2)

 {
     wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") );
 
     return t1.GetValue() <= t2.GetValue();
 }
 
 {
     wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") );
 
     return t1.GetValue() <= t2.GetValue();
 }
 

-inline bool WXDLLEXPORT operator>(const wxDateTime& t1, const wxDateTime& t2)
+inline bool WXDLLIMPEXP_BASE operator>(const wxDateTime& t1, const wxDateTime& t2)

 {
     wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") );
 
     return t1.GetValue() > t2.GetValue();
 }
 
 {
     wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") );
 
     return t1.GetValue() > t2.GetValue();
 }
 

-inline bool WXDLLEXPORT operator>=(const wxDateTime& t1, const wxDateTime& t2)
+inline bool WXDLLIMPEXP_BASE operator>=(const wxDateTime& t1, const wxDateTime& t2)

 {
     wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") );
 
     return t1.GetValue() >= t2.GetValue();
 }
 
 {
     wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") );
 
     return t1.GetValue() >= t2.GetValue();
 }
 

-inline bool WXDLLEXPORT operator==(const wxDateTime& t1, const wxDateTime& t2)
+inline bool WXDLLIMPEXP_BASE operator==(const wxDateTime& t1, const wxDateTime& t2)

 {
     wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") );
 
     return t1.GetValue() == t2.GetValue();
 }
 
 {
     wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") );
 
     return t1.GetValue() == t2.GetValue();
 }
 

-inline bool WXDLLEXPORT operator!=(const wxDateTime& t1, const wxDateTime& t2)
+inline bool WXDLLIMPEXP_BASE operator!=(const wxDateTime& t1, const wxDateTime& t2)

 {
     wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") );
 
 {
     wxASSERT_MSG( t1.IsValid() && t2.IsValid(), _T("invalid wxDateTime") );
 


@@ -1439,24 +1472,24 @@ inline bool WXDLLEXPORT operator!=(const wxDateTime& t1, const wxDateTime& t2)
 // arithmetics
 // -----------
 
 // arithmetics
 // -----------
 

-inline wxTimeSpan WXDLLEXPORT operator+(const wxTimeSpan& ts1,
+inline wxTimeSpan WXDLLIMPEXP_BASE operator+(const wxTimeSpan& ts1,

                                         const wxTimeSpan& ts2)
 {
     return wxTimeSpan(ts1.GetValue() + ts2.GetValue());
 }
 
                                         const wxTimeSpan& ts2)
 {
     return wxTimeSpan(ts1.GetValue() + ts2.GetValue());
 }
 

-inline wxTimeSpan WXDLLEXPORT operator-(const wxTimeSpan& ts1,
+inline wxTimeSpan WXDLLIMPEXP_BASE operator-(const wxTimeSpan& ts1,

                                         const wxTimeSpan& ts2)
 {
     return wxTimeSpan(ts1.GetValue() - ts2.GetValue());
 }
 
                                         const wxTimeSpan& ts2)
 {
     return wxTimeSpan(ts1.GetValue() - ts2.GetValue());
 }
 

-inline wxTimeSpan WXDLLEXPORT operator*(const wxTimeSpan& ts, int n)
+inline wxTimeSpan WXDLLIMPEXP_BASE operator*(const wxTimeSpan& ts, int n)

 {
     return wxTimeSpan(ts).Multiply(n);
 }
 
 {
     return wxTimeSpan(ts).Multiply(n);
 }
 

-inline wxTimeSpan WXDLLEXPORT operator*(int n, const wxTimeSpan& ts)
+inline wxTimeSpan WXDLLIMPEXP_BASE operator*(int n, const wxTimeSpan& ts)

 {
     return wxTimeSpan(ts).Multiply(n);
 }
 {
     return wxTimeSpan(ts).Multiply(n);
 }


@@ -1464,32 +1497,32 @@ inline wxTimeSpan WXDLLEXPORT operator*(int n, const wxTimeSpan& ts)
 // comparison
 // ----------
 
 // comparison
 // ----------
 

-inline bool WXDLLEXPORT operator<(const wxTimeSpan &t1, const wxTimeSpan &t2)
+inline bool WXDLLIMPEXP_BASE operator<(const wxTimeSpan &t1, const wxTimeSpan &t2)

 {
     return t1.GetValue() < t2.GetValue();
 }
 
 {
     return t1.GetValue() < t2.GetValue();
 }
 

-inline bool WXDLLEXPORT operator<=(const wxTimeSpan &t1, const wxTimeSpan &t2)
+inline bool WXDLLIMPEXP_BASE operator<=(const wxTimeSpan &t1, const wxTimeSpan &t2)

 {
     return t1.GetValue() <= t2.GetValue();
 }
 
 {
     return t1.GetValue() <= t2.GetValue();
 }
 

-inline bool WXDLLEXPORT operator>(const wxTimeSpan &t1, const wxTimeSpan &t2)
+inline bool WXDLLIMPEXP_BASE operator>(const wxTimeSpan &t1, const wxTimeSpan &t2)

 {
     return t1.GetValue() > t2.GetValue();
 }
 
 {
     return t1.GetValue() > t2.GetValue();
 }
 

-inline bool WXDLLEXPORT operator>=(const wxTimeSpan &t1, const wxTimeSpan &t2)
+inline bool WXDLLIMPEXP_BASE operator>=(const wxTimeSpan &t1, const wxTimeSpan &t2)

 {
     return t1.GetValue() >= t2.GetValue();
 }
 
 {
     return t1.GetValue() >= t2.GetValue();
 }
 

-inline bool WXDLLEXPORT operator==(const wxTimeSpan &t1, const wxTimeSpan &t2)
+inline bool WXDLLIMPEXP_BASE operator==(const wxTimeSpan &t1, const wxTimeSpan &t2)

 {
     return t1.GetValue() == t2.GetValue();
 }
 
 {
     return t1.GetValue() == t2.GetValue();
 }
 

-inline bool WXDLLEXPORT operator!=(const wxTimeSpan &t1, const wxTimeSpan &t2)
+inline bool WXDLLIMPEXP_BASE operator!=(const wxTimeSpan &t1, const wxTimeSpan &t2)

 {
     return t1.GetValue() != t2.GetValue();
 }
 {
     return t1.GetValue() != t2.GetValue();
 }


@@ -1498,10 +1531,28 @@ inline bool WXDLLEXPORT operator!=(const wxTimeSpan &t1, const wxTimeSpan &t2)
 // wxDateSpan
 // ----------------------------------------------------------------------------
 
 // wxDateSpan
 // ----------------------------------------------------------------------------
 

+// comparison
+// ----------
+
+// ds1 == d2 if and only if for every wxDateTime t t + ds1 == t + ds2
+inline WXDLLIMPEXP_BASE bool operator==(const wxDateSpan& ds1,
+                                   const wxDateSpan& ds2)
+{
+    return ds1.GetYears() == ds2.GetYears() &&
+           ds1.GetMonths() == ds2.GetMonths() &&
+           ds1.GetTotalDays() == ds2.GetTotalDays();
+}
+
+inline WXDLLIMPEXP_BASE bool operator!=(const wxDateSpan& ds1,
+                                   const wxDateSpan& ds2)
+{
+  return !(ds1 == ds2);
+}
+

 // arithmetics
 // -----------
 
 // arithmetics
 // -----------
 

-inline WXDLLEXPORT wxDateSpan operator+(const wxDateSpan& ds1,
+inline WXDLLIMPEXP_BASE wxDateSpan operator+(const wxDateSpan& ds1,

                                         const wxDateSpan& ds2)
 {
     return wxDateSpan(ds1.GetYears() + ds2.GetYears(),
                                         const wxDateSpan& ds2)
 {
     return wxDateSpan(ds1.GetYears() + ds2.GetYears(),


@@ -1510,7 +1561,7 @@ inline WXDLLEXPORT wxDateSpan operator+(const wxDateSpan& ds1,
                       ds1.GetDays() + ds2.GetDays());
 }
 
                       ds1.GetDays() + ds2.GetDays());
 }
 

-inline WXDLLEXPORT wxDateSpan operator-(const wxDateSpan& ds1,
+inline WXDLLIMPEXP_BASE wxDateSpan operator-(const wxDateSpan& ds1,

                                         const wxDateSpan& ds2)
 {
     return wxDateSpan(ds1.GetYears() - ds2.GetYears(),
                                         const wxDateSpan& ds2)
 {
     return wxDateSpan(ds1.GetYears() - ds2.GetYears(),


@@ -1519,12 +1570,12 @@ inline WXDLLEXPORT wxDateSpan operator-(const wxDateSpan& ds1,
                       ds1.GetDays() - ds2.GetDays());
 }
 
                       ds1.GetDays() - ds2.GetDays());
 }
 

-inline WXDLLEXPORT wxDateSpan operator*(const wxDateSpan& ds, int n)
+inline WXDLLIMPEXP_BASE wxDateSpan operator*(const wxDateSpan& ds, int n)

 {
     return wxDateSpan(ds).Multiply(n);
 }
 
 {
     return wxDateSpan(ds).Multiply(n);
 }
 

-inline WXDLLEXPORT wxDateSpan operator*(int n, const wxDateSpan& ds)
+inline WXDLLIMPEXP_BASE wxDateSpan operator*(int n, const wxDateSpan& ds)

 {
     return wxDateSpan(ds).Multiply(n);
 }
 {
     return wxDateSpan(ds).Multiply(n);
 }


@@ -1539,7 +1590,7 @@ inline WXDLLEXPORT wxDateSpan operator*(int n, const wxDateSpan& ds)
 //  for ( m = wxDateTime::Jan; m < wxDateTime::Inv_Month; wxNextMonth(m) )
 // ----------------------------------------------------------------------------
 
 //  for ( m = wxDateTime::Jan; m < wxDateTime::Inv_Month; wxNextMonth(m) )
 // ----------------------------------------------------------------------------
 

-inline WXDLLEXPORT void wxNextMonth(wxDateTime::Month& m)
+inline WXDLLIMPEXP_BASE void wxNextMonth(wxDateTime::Month& m)

 {
     wxASSERT_MSG( m < wxDateTime::Inv_Month, _T("invalid month") );
 
 {
     wxASSERT_MSG( m < wxDateTime::Inv_Month, _T("invalid month") );
 


@@ -1547,7 +1598,7 @@ inline WXDLLEXPORT void wxNextMonth(wxDateTime::Month& m)
     m = (wxDateTime::Month)(m + 1);
 }
 
     m = (wxDateTime::Month)(m + 1);
 }
 

-inline WXDLLEXPORT void wxPrevMonth(wxDateTime::Month& m)
+inline WXDLLIMPEXP_BASE void wxPrevMonth(wxDateTime::Month& m)

 {
     wxASSERT_MSG( m < wxDateTime::Inv_Month, _T("invalid month") );
 
 {
     wxASSERT_MSG( m < wxDateTime::Inv_Month, _T("invalid month") );
 


@@ -1555,7 +1606,7 @@ inline WXDLLEXPORT void wxPrevMonth(wxDateTime::Month& m)
                              : (wxDateTime::Month)(m - 1);
 }
 
                              : (wxDateTime::Month)(m - 1);
 }
 

-inline WXDLLEXPORT void wxNextWDay(wxDateTime::WeekDay& wd)
+inline WXDLLIMPEXP_BASE void wxNextWDay(wxDateTime::WeekDay& wd)

 {
     wxASSERT_MSG( wd < wxDateTime::Inv_WeekDay, _T("invalid week day") );
 
 {
     wxASSERT_MSG( wd < wxDateTime::Inv_WeekDay, _T("invalid week day") );
 


@@ -1563,7 +1614,7 @@ inline WXDLLEXPORT void wxNextWDay(wxDateTime::WeekDay& wd)
     wd = (wxDateTime::WeekDay)(wd + 1);
 }
 
     wd = (wxDateTime::WeekDay)(wd + 1);
 }
 

-inline WXDLLEXPORT void wxPrevWDay(wxDateTime::WeekDay& wd)
+inline WXDLLIMPEXP_BASE void wxPrevWDay(wxDateTime::WeekDay& wd)

 {
     wxASSERT_MSG( wd < wxDateTime::Inv_WeekDay, _T("invalid week day") );
 
 {
     wxASSERT_MSG( wd < wxDateTime::Inv_WeekDay, _T("invalid week day") );
 


@@ -1571,4 +1622,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