This commit was manufactured by cvs2svn to create tag

'OLD_DATE_AND_TIME'.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/OLD_DATE_AND_TIME@5023 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

build/aclocal/cppunit.m4

@@ -1,80 +0,0 @@
-dnl
-dnl AM_PATH_CPPUNIT(MINIMUM-VERSION, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
-dnl
-AC_DEFUN(AM_PATH_CPPUNIT,
-[
-
-AC_ARG_WITH(cppunit-prefix,[  --with-cppunit-prefix=PFX   Prefix where CppUnit is installed (optional)],
-            cppunit_config_prefix="$withval", cppunit_config_prefix="")
-AC_ARG_WITH(cppunit-exec-prefix,[  --with-cppunit-exec-prefix=PFX  Exec prefix where CppUnit is installed (optional)],
-            cppunit_config_exec_prefix="$withval", cppunit_config_exec_prefix="")
-
-  if test x$cppunit_config_exec_prefix != x ; then
-     cppunit_config_args="$cppunit_config_args --exec-prefix=$cppunit_config_exec_prefix"
-     if test x${CPPUNIT_CONFIG+set} != xset ; then
-        CPPUNIT_CONFIG=$cppunit_config_exec_prefix/bin/cppunit-config
-     fi
-  fi
-  if test x$cppunit_config_prefix != x ; then
-     cppunit_config_args="$cppunit_config_args --prefix=$cppunit_config_prefix"
-     if test x${CPPUNIT_CONFIG+set} != xset ; then
-        CPPUNIT_CONFIG=$cppunit_config_prefix/bin/cppunit-config
-     fi
-  fi
-
-  AC_PATH_PROG(CPPUNIT_CONFIG, cppunit-config, no)
-  cppunit_version_min=$1
-
-  AC_MSG_CHECKING(for Cppunit - version >= $cppunit_version_min)
-  no_cppunit=""
-  if test "$CPPUNIT_CONFIG" = "no" ; then
-    no_cppunit=yes
-  else
-    CPPUNIT_CFLAGS=`$CPPUNIT_CONFIG --cflags`
-    CPPUNIT_LIBS=`$CPPUNIT_CONFIG --libs`
-    cppunit_version=`$CPPUNIT_CONFIG --version`
-
-    cppunit_major_version=`echo $cppunit_version | \
-           sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'`
-    cppunit_minor_version=`echo $cppunit_version | \
-           sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'`
-    cppunit_micro_version=`echo $cppunit_version | \
-           sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'`
-
-    cppunit_major_min=`echo $cppunit_version_min | \
-           sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'`
-    cppunit_minor_min=`echo $cppunit_version_min | \
-           sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'`
-    cppunit_micro_min=`echo $cppunit_version_min | \
-           sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'`
-
-    cppunit_version_proper=`expr \
-        $cppunit_major_version \> $cppunit_major_min \| \
-        $cppunit_major_version \= $cppunit_major_min \& \
-        $cppunit_minor_version \> $cppunit_minor_min \| \
-        $cppunit_major_version \= $cppunit_major_min \& \
-        $cppunit_minor_version \= $cppunit_minor_min \& \
-        $cppunit_micro_version \>= $cppunit_micro_min `
-
-    if test "$cppunit_version_proper" = "1" ; then
-      AC_MSG_RESULT([$cppunit_major_version.$cppunit_minor_version.$cppunit_micro_version])
-    else
-      AC_MSG_RESULT(no)
-      no_cppunit=yes
-    fi
-  fi
-
-  if test "x$no_cppunit" = x ; then
-     ifelse([$2], , :, [$2])     
-  else
-     CPPUNIT_CFLAGS=""
-     CPPUNIT_LIBS=""
-     ifelse([$3], , :, [$3])
-  fi
-
-  AC_SUBST(CPPUNIT_CFLAGS)
-  AC_SUBST(CPPUNIT_LIBS)
-])
-
-
-

include/wx/date.h

@@ -0,0 +1,146 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        date.h
+// Purpose:     wxDate class
+// Author:      Julian Smart, Steve Marcus, Eric Simon, Chris Hill,
+//              Charles D. Price
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id$
+// Copyright:   (c)
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_DATE_H_
+#define _WX_DATE_H_
+
+#ifdef __GNUG__
+#pragma interface "date.h"
+#endif
+
+#include "wx/object.h"
+#include "wx/string.h"
+
+#if wxUSE_TIMEDATE
+// These lines necessary to stop VC++ 6 being confused about namespaces
+class WXDLLEXPORT wxDate;
+bool WXDLLEXPORT operator<(const wxDate &dt1, const wxDate &dt2);
+bool WXDLLEXPORT operator<(const wxDate &dt1, const wxDate &dt2);
+bool WXDLLEXPORT operator <= (const wxDate &dt1, const wxDate &dt2);
+bool WXDLLEXPORT operator >  (const wxDate &dt1, const wxDate &dt2);
+bool WXDLLEXPORT operator >= (const wxDate &dt1, const wxDate &dt2);
+bool WXDLLEXPORT operator == (const wxDate &dt1, const wxDate &dt2);
+bool WXDLLEXPORT operator != (const wxDate &dt1, const wxDate &dt2);
+
+enum wxdate_format_type {wxMDY, wxDAY, wxMONTH, wxFULL, wxEUROPEAN};
+
+#define wxNO_CENTURY  0x02
+#define wxDATE_ABBR   0x04
+
+class WXDLLEXPORT wxDate : public wxObject
+{
+DECLARE_DYNAMIC_CLASS(wxDate)
+
+protected:
+    unsigned long julian; // see julDate();  days since 1/1/4713 B.C.
+    int month;            // see NMonth()
+    int day;              // see Day()
+    int year;             // see NYear4()
+    int day_of_week;      // see NDOW();  1 = Sunday, ... 7 = Saturday
+
+private:
+    int       DisplayFormat;
+    unsigned char DisplayOptions;
+
+    void julian_to_mdy ();         // convert julian day to mdy
+    void julian_to_wday ();        // convert julian day to day_of_week
+    void mdy_to_julian ();         // convert mdy to julian day
+
+public:
+    wxDate ();
+    wxDate (long j);
+    wxDate (int m, int d, int y);
+    wxDate (const wxString& dat);
+    wxDate (const wxDate &dt);
+
+#ifndef __SALFORDC__
+    operator wxString  (void);
+#endif
+
+    void operator =   (const wxDate& date);
+    void operator =   (const wxString& date);
+
+    wxDate operator +  (long i);
+    wxDate operator +  (int  i);
+
+    wxDate operator -  (long i);
+    wxDate operator -  (int  i);
+
+    long operator -  (const wxDate &dt);
+
+    wxDate &operator += (long i);
+    wxDate &operator -= (long i);
+
+    wxDate &operator ++ ();     // Prefix increment
+    wxDate &operator ++ (int);  // Postfix increment
+    wxDate &operator -- ();     // Prefix decrement
+    wxDate &operator -- (int);  // Postfix decrement
+
+    friend bool WXDLLEXPORT operator <  (const wxDate &dt1, const wxDate &dt2);
+    friend bool WXDLLEXPORT operator <= (const wxDate &dt1, const wxDate &dt2);
+    friend bool WXDLLEXPORT operator >  (const wxDate &dt1, const wxDate &dt2);
+    friend bool WXDLLEXPORT operator >= (const wxDate &dt1, const wxDate &dt2);
+    friend bool WXDLLEXPORT operator == (const wxDate &dt1, const wxDate &dt2);
+    friend bool WXDLLEXPORT operator != (const wxDate &dt1, const wxDate &dt2);
+
+#if wxUSE_STD_IOSTREAM
+    friend ostream WXDLLEXPORT & operator << (ostream &os, const wxDate &dt);
+#endif
+
+    wxString FormatDate      (int type=-1) const;
+    void  SetFormat (int format);
+    int   SetOption (int option, bool enable=TRUE);
+
+    long  GetJulianDate() const;  // returns julian date
+    int   GetDayOfYear()  const;  // returns relative date since Jan. 1
+    bool  IsLeapYear()    const;  // returns TRUE if leap year, FALSE if not
+
+    // Version 4.0 Extension to Public Interface - CDP
+
+    // These 'Set's modify the date object and actually SET it
+    // They all return a reference to self (*this)
+
+    wxDate &Set();            // Sets to current system date
+    wxDate &Set(long lJulian);
+    wxDate &Set(int nMonth, int nDay, int nYear);
+
+    wxDate &AddWeeks(int nCount = 1);  //
+    wxDate &AddMonths(int nCount = 1); // May also pass neg# to decrement
+    wxDate &AddYears(int nCount = 1);  //
+
+    int   GetDay() const;      // Numeric Day of date object
+    int   GetDaysInMonth();    // Number of days in month (1..31)
+    int   GetFirstDayOfMonth() const; // First Day Of Month  (1..7)
+
+    wxString GetDayOfWeekName();       // Character Day Of Week ('Sunday'..'Saturday')
+    int   GetDayOfWeek() const;     // (1..7)
+
+    int   GetWeekOfMonth();            // Numeric Week Of Month  (1..6)
+    int   GetWeekOfYear();            // Numeric Week Of Year   (1..52)
+
+    wxString GetMonthName();            // Character Month name
+    int   GetMonth() const;          // Month Number (1..12)
+    wxDate  GetMonthStart();         // First Date Of Month
+    wxDate  GetMonthEnd();           // Last Date Of Month
+
+    int   GetYear() const;           // eg. 1992
+    wxDate  GetYearStart();          // First Date Of Year
+    wxDate  GetYearEnd();            // Last Date Of Year
+
+    bool IsBetween(const wxDate& first, const wxDate& second) const;
+
+    wxDate Previous(int dayOfWeek) const;
+};
+
+#endif // wxUSE_TIMEDATE
+#endif
+    // _WX_DATE_H_

include/wx/time.h

@@ -0,0 +1,112 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        time.h
+// Purpose:     wxTime class, from NIHCL
+// Author:      Julian Smart, after K. E. Gorlen
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart and Markus Holzem
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_TIMEH__
+#define _WX_TIMEH__
+
+#include "wx/object.h"
+
+#if wxUSE_TIMEDATE
+
+#ifdef __GNUG__
+#pragma interface "time.h"
+#endif
+
+class WXDLLEXPORT wxDate;
+
+typedef unsigned short hourTy;
+typedef unsigned short minuteTy;
+typedef unsigned short secondTy;
+typedef unsigned long clockTy;
+
+class WXDLLEXPORT wxTime: public wxObject
+{
+        DECLARE_DYNAMIC_CLASS(wxTime)
+        
+public:                 // type definitions
+    enum tFormat { wx12h, wx24h };
+    enum tPrecision { wxStdMinSec, wxStdMin };
+private:
+    static tFormat      Format;
+    static tPrecision   Precision;
+
+    clockTy    sec;        /* seconds since 1/1/1901 */
+
+    bool IsDST() const;
+    wxTime GetLocalTime() const;
+private:        // static member functions
+    static wxTime GetLocalTime(const wxDate& date, hourTy h=0, minuteTy m=0, secondTy s=0);
+    static wxTime GetBeginDST(unsigned year);
+    static wxTime GetEndDST(unsigned year);
+public:
+    wxTime();             // current time 
+    wxTime(clockTy s)         { sec = s; }
+    void operator=(const wxTime& t)     { sec = t.sec; } // Ordering required for some compilers
+    wxTime(const wxTime& t)         { (*this) = t ; }
+    wxTime(hourTy h, minuteTy m, secondTy s =0, bool dst =FALSE);
+    wxTime(const wxDate&, hourTy h =0, minuteTy m =0, secondTy s=0, bool dst =FALSE);
+
+    // Convert to string
+#ifndef __SALFORDC__
+    operator wxChar * (void);
+    operator wxDate() const;
+#endif
+
+    bool operator<(const wxTime& t) const     { return sec < t.sec; }
+    bool operator<=(const wxTime& t) const    { return sec <= t.sec; }
+    bool operator>(const wxTime& t) const     { return sec > t.sec; }
+    bool operator>=(const wxTime& t) const    { return sec >= t.sec; }
+    bool operator==(const wxTime& t) const    { return sec == t.sec; }
+    bool operator!=(const wxTime& t) const    { return sec != t.sec; }
+    friend wxTime operator+(const wxTime& t, long s)    { return wxTime(t.sec+s); }
+    friend wxTime operator+(long s, const wxTime& t)    { return wxTime(t.sec+s); }
+    long operator-(const wxTime& t) const     { return sec - t.sec; }
+    wxTime operator-(long s) const    { return wxTime(sec-s); }
+    void operator+=(long s)     { sec += s; }
+    void operator-=(long s)     { sec -= s; }
+    bool IsBetween(const wxTime& a, const wxTime& b) const;
+
+    /// Get day
+    int GetDay() const;
+    /// Get month
+    int GetMonth() const;
+    /// Get year
+    int GetYear() const;
+    /// Get day of week (0=Sunday 6=Saturday)
+    int GetDayOfWeek() const;
+
+    hourTy GetHour() const;        // hour in local time
+    hourTy GetHourGMT() const;     // hour in GMT
+    minuteTy GetMinute() const;    // minute in local time
+    minuteTy GetMinuteGMT() const;     // minute in GMT
+    secondTy GetSecond() const;    // second in local time or GMT
+    clockTy GetSeconds() const     { return sec; }
+    secondTy GetSecondGMT() const ;
+    wxTime Max(const wxTime&) const;
+    wxTime Min(const wxTime&) const;
+    static void SetFormat(const tFormat lFormat = wx12h,
+                  const tPrecision lPrecision = wxStdMinSec);
+    wxChar *FormatTime() const;
+/*
+    virtual int compare(const Object&) const;
+    virtual void deepenShallowCopy();       // {}
+    virtual unsigned hash() const;
+    virtual bool isEqual(const Object&) const;
+    virtual void printOn(ostream& strm =cout) const;
+    virtual const Class* species() const;
+*/
+};
+
+#endif
+  // wxUSE_TIMEDATE
+#endif
+    // _WX_TIMEH__
+

src/common/date.cpp

@@ -0,0 +1,656 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        date.cpp
+// Purpose:     wxDate class
+// Author:
+//    Originally inspired by Steve Marcus (CIS 72007,1233)  6/16/91
+//    Enhanced by Eric Simon (CIS 70540,1522)               6/29/91
+//    Further Enhanced by Chris Hill (CIS 72030,2606)       7/11/91
+//    Still Further Enhanced by Hill & Simon  v3.10         8/05/91
+//    Version 4 by Charles D. Price                         6/27/92
+//    Integrated into wxWindows by Julian Smart             9th July 1995
+// Modified by:
+// Created:     01/02/97
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart and Markus Holzem
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "date.h"
+#endif
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+  #pragma hdrstop
+#endif
+
+#if wxUSE_TIMEDATE
+
+#include "wx/date.h"
+#include "wx/intl.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "wx/ioswrap.h"
+
+#include <time.h>
+#include <string.h>
+
+#define ABBR_LENGTH 3
+
+static const wxChar *dayname[] = {
+    wxT("Sunday"), wxT("Monday"), wxT("Tuesday"), wxT("Wednesday"),
+    wxT("Thursday"), wxT("Friday"), wxT("Saturday")
+};
+
+static const wxChar *mname[] = {
+    wxT("January"), wxT("February"), wxT("March"), wxT("April"), wxT("May"), wxT("June"),
+    wxT("July"), wxT("August"), wxT("September"), wxT("October"), wxT("November"), wxT("December")
+};
+
+static int GauDays[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+
+IMPLEMENT_DYNAMIC_CLASS(wxDate, wxObject)
+
+    ////////////////////////////////////////////////////////////
+    // Constructors
+    ////////////////////////////////////////////////////////////
+
+wxDate::wxDate()
+{
+    DisplayFormat=wxMDY;
+    DisplayOptions='\0';
+    month = day = year = day_of_week = 0;
+    julian = 0;
+}
+
+wxDate::wxDate (long j) : julian(j)
+{
+    DisplayFormat=wxMDY;
+    DisplayOptions='\0';
+    julian_to_mdy ();
+}
+
+wxDate::wxDate (int m, int d, int y) : month(m), day(d), year(y)
+{
+    DisplayFormat=wxMDY;
+    DisplayOptions='\0';
+    mdy_to_julian ();
+}
+
+wxDate::wxDate (const wxString& dat)
+{
+    DisplayFormat=wxMDY;
+    DisplayOptions='\0';
+    if (wxStrcmp(dat, wxT("TODAY")) == 0 || wxStrcmp(dat, wxT("today")) == 0)
+    {
+        // Sets the current date
+        Set();
+    }
+    else
+    {
+        wxChar buf[100];
+        wxStrcpy(buf, dat);
+
+        wxChar *save_ptr, *token = wxStrtok(buf,wxT("/-"),&save_ptr);
+        month = wxAtoi(token);
+        day   = wxAtoi(wxStrtok((wxChar *) NULL,wxT("/-"),&save_ptr));
+        year  = wxAtoi(wxStrtok((wxChar *) NULL,wxT(" "),&save_ptr));
+    }
+
+    mdy_to_julian ();
+}
+
+wxDate::wxDate (const wxDate &dt)
+{
+    DisplayFormat=dt.DisplayFormat;
+    DisplayOptions=dt.DisplayOptions;
+    month = dt.month;
+    day   = dt.day;
+    year  = dt.year;
+    mdy_to_julian ();
+}
+
+void wxDate::operator = (const wxDate &dt)
+{
+    DisplayFormat=dt.DisplayFormat;
+    DisplayOptions=dt.DisplayOptions;
+    month = dt.month;
+    day   = dt.day;
+    year  = dt.year;
+    mdy_to_julian (); // wxUSE_TIMEDATE
+}
+
+void wxDate::operator = (const wxString& dat)
+{
+    DisplayFormat=wxMDY;
+    DisplayOptions='\0';
+    if (wxStrcmp(dat, wxT("TODAY")) == 0 || wxStrcmp(dat, wxT("today")) == 0)
+    {
+        // Sets the current date
+        Set();
+    }
+    else
+    {
+        wxChar buf[100];
+        wxStrcpy(buf, dat);
+
+        wxChar *save_ptr, *token = wxStrtok(buf,wxT("/-"),&save_ptr);
+        month = wxAtoi(token);
+        day   = wxAtoi(wxStrtok((wxChar *) NULL,wxT("/-"),&save_ptr));
+        year  = wxAtoi(wxStrtok((wxChar *) NULL,wxT(" "),&save_ptr));
+    }
+
+    mdy_to_julian ();
+}
+
+//////////////////////////////////////////////////////////////
+// Conversion operations
+//////////////////////////////////////////////////////////////
+
+#ifndef __SALFORDC__
+wxDate::operator wxString( void )
+{
+    return FormatDate();
+}
+#endif
+
+//////////////////////////////////////////////////////////////
+// Date Arithmetic
+//////////////////////////////////////////////////////////////
+
+wxDate wxDate::operator + (long i)
+{
+    wxDate dp(julian + i);
+    return dp;
+}
+
+wxDate wxDate::operator + (int i)
+{
+    wxDate dp(julian + (long)i);
+    return dp;
+}
+
+wxDate wxDate::operator - (long i)
+{
+    wxDate dp(julian - i);
+    return dp;
+}
+
+wxDate wxDate::operator - (int i)
+{
+    wxDate dp(julian - (long)i);
+    return dp;
+}
+
+long wxDate::operator - (const wxDate &dt)
+{
+    return ( julian - dt.julian );
+}
+
+wxDate &wxDate::operator += (long i)
+{
+    julian += i;
+    julian_to_mdy();
+    return *this;
+}
+
+wxDate &wxDate::operator -= (long i)
+{
+    julian -= i;
+    julian_to_mdy();
+    return *this;
+}
+
+wxDate &wxDate::operator ++()
+{
+    julian++;
+    julian_to_mdy();
+    return *this;
+}
+
+wxDate &wxDate::operator ++(int)
+{
+    julian++;
+    julian_to_mdy();
+    return *this;
+}
+
+wxDate &wxDate::operator --()
+{
+    julian--;
+    julian_to_mdy();
+    return *this;
+}
+
+wxDate &wxDate::operator --(int)
+{
+    julian--;
+    julian_to_mdy();
+    return *this;
+}
+
+//////////////////////////////////////////////////////////////
+// Date comparison
+//////////////////////////////////////////////////////////////
+
+bool WXDLLEXPORT operator <  (const wxDate &dt1, const wxDate &dt2)
+{
+    return ( dt1.julian < dt2.julian );
+}
+
+bool WXDLLEXPORT operator <= (const wxDate &dt1, const wxDate &dt2)
+{
+    return ( (dt1.julian == dt2.julian) || (dt1.julian < dt2.julian) );
+}
+
+bool WXDLLEXPORT operator >  (const wxDate &dt1, const wxDate &dt2)
+{
+    return ( dt1.julian > dt2.julian );
+}
+
+bool WXDLLEXPORT operator >= (const wxDate &dt1, const wxDate &dt2)
+{
+    return ( (dt1.julian == dt2.julian) || (dt1.julian > dt2.julian) );
+}
+
+bool WXDLLEXPORT operator == (const wxDate &dt1, const wxDate &dt2)
+{
+    return ( dt1.julian == dt2.julian );
+}
+
+bool WXDLLEXPORT operator != (const wxDate &dt1, const wxDate &dt2)
+{
+    return ( dt1.julian != dt2.julian );
+}
+
+
+#if wxUSE_STD_IOSTREAM
+
+////////////////////////////////////////////////////////////////
+// Ostream operations
+////////////////////////////////////////////////////////////////
+
+ostream WXDLLEXPORT & operator << (ostream &os, const wxDate &dt)
+{
+    return os << dt.FormatDate().mb_str();
+}
+
+#endif
+
+//////////////////////////////////////////////////////////////
+// Conversion routines
+//////////////////////////////////////////////////////////////
+
+void wxDate::julian_to_wday (void)
+{
+    // Correction by Peter Stadel <peters@jetcity.com>
+    day_of_week = (int)((julian - 2) % 7L);
+/*
+    day_of_week = (int) ((julian + 2) % 7 + 1);
+*/
+}
+
+void wxDate::julian_to_mdy ()
+{
+    long a,b,c,d,e,z,alpha;
+    z = julian+1;
+    // dealing with Gregorian calendar reform
+    if (z < 2299161L)
+        a = z;
+    else {
+        alpha = (long) ((z-1867216.25) / 36524.25);
+        a = z + 1 + alpha - alpha/4;
+    }
+    b = ( a > 1721423 ? a + 1524 : a + 1158 );
+    c = (long) ((b - 122.1) / 365.25);
+    d = (long) (365.25 * c);
+    e = (long) ((b - d) / 30.6001);
+    day = (int)(b - d - (long)(30.6001 * e));
+    month = (int)((e < 13.5) ? e - 1 : e - 13);
+    year = (int)((month > 2.5 ) ? (c - 4716) : c - 4715);
+    julian_to_wday ();
+}
+
+void wxDate::mdy_to_julian (void)
+{
+    int a,b=0;
+    int work_month=month, work_day=day, work_year=year;
+    // correct for negative year
+    if (work_year < 0)
+        work_year++;
+    if (work_month <= 2)
+    { work_year--; work_month +=12; }
+
+    // deal with Gregorian calendar
+    if (work_year*10000. + work_month*100. + work_day >= 15821015.)
+    {
+        a = (int)(work_year/100.);
+        b = 2 - a + a/4;
+    }
+    julian = (long) (365.25*work_year) +
+        (long) (30.6001 * (work_month+1))  +  work_day + 1720994L + b;
+    julian_to_wday ();
+}
+
+////////////////////////////////////////////////////////////////
+// Format routine
+////////////////////////////////////////////////////////////////
+
+wxString wxDate::FormatDate (int type) const
+{
+    int actualType = type;
+    if (actualType == -1)
+        actualType = DisplayFormat;
+
+    wxChar buf[40];
+
+    memset( buf, '\0', sizeof(buf) );
+    switch ( actualType )
+    {
+        case wxDAY:
+            if ( (day_of_week < 1) || (day_of_week > 7) )
+                wxStrcpy(buf, _("invalid day"));
+            else
+                wxStrncpy( buf, wxGetTranslation(dayname[day_of_week-1]),
+               (DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
+            return wxString(buf);
+
+        case wxMONTH:
+            if ( (month < 1) || (month > 12) )
+                wxStrcpy(buf, _("invalid month"));
+            else
+                wxStrncpy( buf, wxGetTranslation(mname[month-1]),
+               (DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
+            return wxString(buf);
+
+        case wxFULL:
+            if ( (month < 1) || (month > 12) || (day_of_week < 0) ||
+                    (day_of_week > 7) )
+            {
+                wxStrcpy(buf, _("invalid date"));
+                return wxString(buf);
+            }
+            wxStrncpy( buf, wxGetTranslation(dayname[day_of_week-1]),
+               (DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
+            wxStrcat( buf, wxT(", "));
+            wxStrncat( buf, wxGetTranslation(mname[month-1]),
+               (DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
+            wxStrcat( buf, wxT(" "));
+            wxSprintf( buf+wxStrlen(buf), wxT("%d, %d"), day, abs(year) );
+            if (year < 0)
+                wxStrcat(buf,_(" B.C."));
+            return wxString(buf);
+
+        case wxEUROPEAN:
+            if ( (month < 1) || (month > 12) || (day_of_week < 0) ||
+                    (day_of_week > 7) )
+            {
+                wxStrcpy(buf, _("invalid date"));
+                return wxString(buf);
+            }
+            wxSprintf(buf,wxT("%d "),  day);
+            wxStrncat(buf, wxGetTranslation(mname[month-1]),
+                    (DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
+            wxSprintf( buf+wxStrlen(buf), wxT(" %d"), abs(year) );
+            if (year < 0)
+                wxStrcat(buf, _(" B.C."));
+            return wxString(buf);
+
+        case wxMDY:
+        default:
+            if (day==0 || month==0 || year==0)
+                wxStrcpy(buf, _("invalid date"));
+            else
+                wxSprintf( buf+wxStrlen(buf), wxT("%1d/%1d/%02d"), month, day,
+               (DisplayOptions & wxNO_CENTURY) && (abs(year) > 1899)
+               ? (abs(year) - (abs(year) / 100 * 100))
+               : (abs(year))  );
+            return wxString(buf);
+    }
+}
+
+void wxDate::SetFormat( int format )
+{
+    DisplayFormat = format;
+}
+
+int wxDate::SetOption( int option, bool action )
+{
+    switch ( option )
+    {
+        case wxNO_CENTURY:
+            if ( action )
+                DisplayOptions |= wxNO_CENTURY;
+            else
+            {
+                DisplayOptions &= (~wxNO_CENTURY);
+            }
+            return 1;
+        case wxDATE_ABBR:
+            if ( action )
+                DisplayOptions |= wxDATE_ABBR;
+            else
+            {
+                DisplayOptions &= (~wxDATE_ABBR);
+            }
+            return 1;
+        default:
+            return 0;
+    }
+}
+
+///////////////////////////////////////////////////////////////
+//  Miscellaneous Routines
+///////////////////////////////////////////////////////////////
+
+long wxDate::GetJulianDate( void ) const
+{
+    return julian;
+}
+
+int wxDate::GetDayOfYear( void ) const
+{
+    wxDate temp( 1, 1, year );
+
+    return (int) (julian - temp.julian + 1);
+}
+
+
+bool wxDate::IsLeapYear( void ) const
+{
+    return  ( (year >= 1582) ?
+            (year % 4 == 0  &&  year % 100 != 0  ||  year % 400 == 0 ):
+            (year % 4 == 0) );
+}
+
+// Version 4.0 Extension to Public Interface - CDP
+
+wxDate& wxDate::Set()
+{
+    //#ifdef __WXMSW__
+#if 0
+    struct _dosdate_t sDate;
+    _dos_getdate(&sDate);
+
+    month = sDate.month;
+    day   = sDate.day;
+    year  = sDate.year;
+
+    mdy_to_julian();
+#else
+    time_t now = time((time_t *) NULL);
+    struct tm *localTime = localtime(&now);
+
+    month = localTime->tm_mon + 1;
+    day = localTime->tm_mday;
+    year = localTime->tm_year + 1900;
+
+    mdy_to_julian ();
+#endif
+    return *this;
+}
+
+wxDate& wxDate::Set(
+        int  nMonth,
+        int  nDay,
+        int  nYear)
+{
+    month = nMonth;
+    year  = nYear < 0 ? 9999 : nYear;
+    year  = nYear > 9999 ? 0 : nYear;
+    day   = nDay < GetDaysInMonth() ? nDay : GetDaysInMonth();
+
+    mdy_to_julian();
+    return *this;
+}
+
+wxDate &
+wxDate::Set(long j)
+{
+    julian = j;
+
+    julian_to_mdy();
+    return *this;
+}
+
+
+int wxDate::GetDaysInMonth()
+{
+    return GauDays[month-1] + (month==2 && IsLeapYear());
+}
+
+int wxDate::GetFirstDayOfMonth() const
+{
+    return wxDate(month, 1, year).GetDayOfWeek();
+}
+
+int wxDate::GetDay() const
+{
+    return day;
+}
+
+int wxDate::GetDayOfWeek() const
+{
+    return day_of_week;
+}
+
+int wxDate::GetYear() const
+{
+    return year;
+}
+
+int wxDate::GetMonth() const
+{
+    return month;
+}
+
+wxDate& wxDate::AddWeeks(int nCount)
+{
+    Set(julian + (long)nCount*7);
+    return *this;
+}
+
+wxDate& wxDate::AddMonths(int nCount)
+{
+    month += nCount;
+
+    if (month < 1) {
+        month = 12;
+        year--;
+    }
+
+    if (month > 12) {
+        month = 1;
+        year++;
+    }
+    mdy_to_julian();
+    return *this;
+}
+
+wxDate& wxDate::AddYears(int nCount)
+{
+    year += nCount;
+    mdy_to_julian();
+    return *this;
+}
+
+int wxDate::GetWeekOfMonth()
+{
+    // Abs day includes the days from previous month that fills up
+    // the begin. of the week.
+    int nAbsDay = day + GetFirstDayOfMonth()-1;
+    return (nAbsDay-GetDayOfWeek())/7 + 1;
+}
+
+int wxDate::GetWeekOfYear()
+{
+    wxDate   doTemp(1, 1, year);
+    return (int)(((julian - doTemp.julian+1)/7) + 1);
+}
+
+wxDate wxDate::GetMonthStart()
+{
+    return(wxDate(month, 1, year));
+}
+
+wxDate wxDate::GetMonthEnd()
+{
+    return(wxDate(month+1, 1, year)-1);
+}
+
+wxDate wxDate::GetYearStart()
+{
+    return(wxDate(1, 1, year));
+}
+
+wxDate wxDate::GetYearEnd()
+{
+    return(wxDate(1, 1, year+1)-1);
+}
+
+wxString wxDate::GetMonthName()
+{
+    return(FormatDate(wxMONTH));
+}
+
+wxString wxDate::GetDayOfWeekName()
+{
+    return(FormatDate(wxDAY));
+}
+
+bool wxDate::IsBetween(const wxDate& first, const wxDate& second) const
+{
+    return (julian >= first.julian && julian <= second.julian);
+}
+
+// This function is from NIHCL
+wxDate wxDate::Previous(int dayOfWeek) const
+{
+    int this_day_Of_Week, desired_day_Of_Week;
+    long j;
+
+    //      Set the desired and current day of week to start at 0 (Monday)
+    //      and end at 6 (Sunday).
+
+    desired_day_Of_Week = dayOfWeek - 1; // These functions return a value
+    this_day_Of_Week    = GetDayOfWeek() - 1;            // from 1-7.  Subtract 1 for 0-6.
+    j = julian;
+
+    //      Have to determine how many days difference from current day back to
+    //      desired, if any.  Special calculation under the 'if' statement to
+    //      effect the wraparound counting from Monday (0) back to Sunday (6).
+
+    if (desired_day_Of_Week > this_day_Of_Week)
+        this_day_Of_Week += 7 - desired_day_Of_Week;
+    else
+        this_day_Of_Week -= desired_day_Of_Week;
+    j -= this_day_Of_Week; // Adjust j to set it at the desired day of week.
+    return wxDate(j);
+}
+
+#endif

src/common/time.cpp

@@ -0,0 +1,447 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        time.cpp
+// Purpose:     wxTime class, from NIHCL
+// Author:      Julian Smart, after K. E. Gorlen
+// Modified by:
+// Created:     04/01/98
+// RCS-ID:      $Id$
+// Copyright:   (c) Julian Smart and Markus Holzem
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifdef __GNUG__
+#pragma implementation "time.h"
+#endif
+
+/*
+Provides an object that represents a Time, stored as the number of
+seconds since January 1, 1901, GMT.
+*/
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include "wx/setup.h"
+
+#if wxUSE_TIMEDATE
+
+#include "wx/time.h"
+#include "wx/date.h"
+#include "wx/utils.h"
+#include "wx/intl.h"
+
+#if wxUSE_STD_IOSTREAM
+    #include "wx/ioswrap.h"
+    #if wxUSE_IOSTREAMH
+        #include <iomanip.h>
+    #else
+        #include <iomanip>
+    #endif
+#endif
+
+#include <string.h>
+#include <time.h>
+
+IMPLEMENT_DYNAMIC_CLASS(wxTime, wxObject)
+
+
+#ifndef WX_TIMEZONE
+    #define WX_TIMEZONE _timezone
+#endif
+
+extern long wxGetUTCTime(void);
+bool wxGetTZandDST(long *timeZone, int *dstObserved)
+{
+  time_t now;
+  struct tm *tm;
+
+  now = time((time_t *) NULL);
+
+  if (now != (time_t)-1)
+  {
+    tm = localtime(&now);
+
+    if ((tm) && (tm->tm_isdst > 0))
+      *dstObserved = 1;
+  }
+  *timeZone = WX_TIMEZONE;
+
+  return TRUE;
+}
+
+
+static long TIME_ZONE;          /* seconds west of GMT */
+static int DST_OBSERVED;        /* flags U.S. daylight saving time observed */
+
+static bool wxTimeInitialized = FALSE;
+
+wxTime::tFormat    wxTime::Format    = wxTime::wx12h;
+wxTime::tPrecision wxTime::Precision  = wxTime::wxStdMinSec;
+
+static const unsigned long seconds_in_day = 24*60*60L;
+static const wxDate refDate(1,1,1901);
+// static const wxDate maxDate(49709L);      /* ((2**32)-1)/seconds_in_day -1 */
+
+wxTime wxTime::GetLocalTime(const wxDate& date, hourTy h, minuteTy m, secondTy s)
+/*
+      Return a local wxTime for the specified Standard Time date, hour, minute,
+      and second.
+*/
+{
+  if (!wxTimeInitialized)
+  {
+   wxGetTZandDST(&TIME_ZONE, &DST_OBSERVED);
+   wxTimeInitialized = TRUE;
+  }
+/*
+      if (!date.IsBetween(refDate,maxDate))
+           setError(NIHCL_DATERANGE,DEFAULT,
+                date.dayOfMonth(),date.nameOfMonth(),date.year());
+*/
+  // The following line causes an error in GCC 2.1
+//   long daysBetween = date-refDate;
+  // ... but this seems to get round it.
+  wxDate tmp1(date);
+  wxDate tmp2(refDate);
+  long daysBetween = tmp1 - tmp2;
+
+  return wxTime(seconds_in_day*daysBetween + 60*60L*h + 60*m + s);
+}
+
+wxTime::wxTime()
+/*
+      Construct a wxTime for this instant.
+*/
+{
+  if (!wxTimeInitialized)
+  {
+   wxGetTZandDST(&TIME_ZONE, &DST_OBSERVED);
+   wxTimeInitialized = TRUE;
+  }
+  sec = wxGetUTCTime();
+#ifdef __SALFORDC__
+  sec += (unsigned long) 2177452800;     /* seconds from 1/1/01 to 1/1/70 */
+#else
+  sec += 2177452800UL;     /* seconds from 1/1/01 to 1/1/70 */
+#endif
+}
+
+wxTime::wxTime(hourTy h, minuteTy m, secondTy s, bool dst)
+/*
+      Construct a wxTime for today at the specified (local) hour, minute, and
+      second.
+*/
+{
+  if (!wxTimeInitialized)
+  {
+   wxGetTZandDST(&TIME_ZONE, &DST_OBSERVED);
+   wxTimeInitialized = TRUE;
+  }
+
+  sec = wxTime(wxDate(),h,m,s,dst).sec;
+}
+
+
+wxTime::wxTime(const wxDate& date, hourTy h, minuteTy m, secondTy s, bool dst)
+/*
+        Construct a wxTime for the specified (local) Date, hour, minute, and
+        second.
+*/
+{
+  if (!wxTimeInitialized)
+  {
+    wxGetTZandDST(&TIME_ZONE, &DST_OBSERVED);
+   wxTimeInitialized = TRUE;
+  }
+  sec = GetLocalTime(date,h,m,s).sec-3600;
+  if (IsDST())
+  {
+    sec += 3600;
+    if (IsDST() || dst) sec -= 3600;
+  }
+  else
+  {
+    sec += 3600;
+/*
+                if (IsDST()) setError(NIHCL_BADTIME,DEFAULT,
+                date.dayOfMonth(),date.nameOfMonth(),date.year(),
+                h,m,s,(dst?_("DST"):""));
+*/
+  }
+  sec += TIME_ZONE;                               // adjust to GMT
+}
+
+#ifndef __SALFORDC__
+wxTime::operator wxDate() const
+/*
+      Convert a wxTime to a local wxDate
+*/
+{
+//      return wxDate((int)(GetLocalTime().sec/seconds_in_day));     4.2 cc bug
+      long daycount = (long)(GetLocalTime().sec/seconds_in_day);
+
+        wxDate date(1,1,1901);
+        date += daycount;
+        return date;
+}
+#endif
+
+bool wxTime::IsBetween(const wxTime& a, const wxTime& b) const
+{
+        return *this >= a && *this <= b;
+}
+
+hourTy wxTime::GetHour() const
+/*
+      Return the hour of this wxTime in local time; i.e., adjust for
+        time zone and Daylight Savings Time.
+*/
+{
+      return GetLocalTime().GetHourGMT();
+}
+
+hourTy wxTime::GetHourGMT() const
+/*
+        Return the hour of this Time in GMT.
+*/
+{
+      return (hourTy)((sec % 86400) / 3600);
+}
+
+wxTime wxTime::GetBeginDST(unsigned year)
+/*
+      Return the local Standard Time at which Daylight Savings Time
+        begins in the specified year.
+*/
+{
+        // Previous Sunday
+        wxTime DSTtime(GetLocalTime(wxDate(3,31,year).Previous(1)+7,2));
+        if (year<=1986) {
+                // Previous Sunday
+           DSTtime = GetLocalTime(wxDate(4,30,year).Previous(1),2);
+           if (year==1974) DSTtime = GetLocalTime(wxDate(1,6,1974),2);
+                if (year==1975) DSTtime = GetLocalTime(wxDate(2,23,1975),2);
+        }
+        return DSTtime;
+}
+
+wxTime wxTime::GetEndDST(unsigned year)
+/*
+        Return the local Standard Time at which Daylight Savings Time
+        ends in the specified year.
+*/
+{
+      wxTime STDtime(GetLocalTime(wxDate(10,31,year).Previous(1),2-1));
+      return STDtime;
+}
+
+bool wxTime::IsDST() const
+/*
+        Return TRUE if this local Standard Time should be adjusted
+        for Daylight Savings Time.
+*/
+{
+        long daycount = (long)(sec/seconds_in_day);
+
+        // At this point, daycount is the number of days from 1/1/1901.
+      // Need to convert to julian date (which starts at 1/1/4713 B.C.)
+      wxDate date(1,1,1901);
+        date += daycount;
+
+        unsigned year = date.GetYear();
+      if (DST_OBSERVED)
+        {
+                if (*this >= GetBeginDST(year))
+                        if (*this < GetEndDST(year)) return TRUE;
+        }
+        return FALSE;
+}
+
+wxTime wxTime::GetLocalTime() const
+/*
+        Adjusts this GM Time for local time zone and Daylight Savings Time.
+*/
+{
+      wxTime local_time(sec-TIME_ZONE);
+        if (local_time.IsDST()) local_time.sec += 3600;
+        return local_time;
+}
+
+minuteTy wxTime::GetMinute() const
+/*
+        Return the minute of this wxTime in local time; i.e., adjust
+      for time zone and Daylight Savings Time.
+*/
+{
+        return GetLocalTime().GetMinuteGMT();
+}
+
+minuteTy wxTime::GetMinuteGMT() const
+/*
+        Return the minute of this wxTime in GMT.
+*/
+{
+      return (minuteTy)(((sec % 86400) % 3600) / 60);
+}
+
+secondTy wxTime::GetSecond() const
+/*
+        Return the second of this wxTime.
+*/
+{
+      return (secondTy)(((sec % 86400) % 3600) % 60);
+}
+
+secondTy wxTime::GetSecondGMT() const
+/*
+        Return the minute of this wxTime in GMT.
+*/
+{
+        return (secondTy)(((sec % 86400) % 3600) % 60);
+}
+
+int wxTime::GetDay() const
+{
+    wxDate da((wxDate) *this);
+    return da.GetDay();
+}
+
+int wxTime::GetDayOfWeek() const
+{
+    wxDate da((wxDate) *this);
+    return da.GetDayOfWeek();
+}
+
+int wxTime::GetMonth() const
+{
+    wxDate da((wxDate) *this);
+    return da.GetMonth();
+}
+
+int wxTime::GetYear() const
+{
+    wxDate da((wxDate) *this);
+    return da.GetYear();
+}
+
+wxTime wxTime::Max(const wxTime& t) const
+{
+        if (t < *this) return *this;
+        return t;
+}
+
+wxTime wxTime::Min(const wxTime& t) const
+{
+        if (t > *this) return *this;
+      return t;
+}
+
+#ifndef __SALFORDC__
+wxTime::operator wxChar *(void)
+{
+  return FormatTime();
+}
+#endif
+
+void wxTime::SetFormat(const wxTime::tFormat lFormat,
+                const wxTime::tPrecision lPrecision) {
+
+  wxTime::Format    = lFormat;
+  wxTime::Precision  = lPrecision;
+}
+
+wxChar *wxTime::FormatTime() const {
+  static wxChar  timeBuf[30];
+  unsigned    hh(GetHour());
+
+  switch (Format) {
+  case wx12h:
+    hh  -= 12;
+    break;
+  case wx24h:
+    break;
+  }
+
+  switch (Precision) {
+  case wxStdMinSec:
+    wxSprintf(timeBuf,wxT("%2d:%02d:%02d"),hh,GetMinute(),GetSecond());
+    break;
+  case wxStdMin:
+    wxSprintf(timeBuf,wxT("%2d:%02d"),hh,GetMinute());
+    break;
+  }
+
+  if (Format == wx12h)
+    if (GetHour() <= 12)
+      wxStrcat(timeBuf,_("am"));
+    else
+      wxStrcat(timeBuf,_("pm"));
+
+  return timeBuf;
+}
+
+/*
+int wxTime::compare(const Object& ob) const
+{
+      assertArgSpecies(ob,classDesc,"compare");
+        register clockTy t = castdown(ob).sec;
+        if (sec < t) return -1;
+        if (sec > t) return 1;
+        return 0;
+}
+
+void wxTime::deepenShallowCopy()  {}
+
+unsigned wxTime::hash() const     { return sec; }
+
+bool wxTime::isEqual(const Object& ob) const
+{
+        return ob.isSpecies(classDesc) && *this==castdown(ob);
+}
+
+const Class* wxTime::species() const { return &classDesc; }
+
+void wxTime::printOn(ostream& strm) const
+{
+        register unsigned hh = GetHour();
+        wxDate(*this).printOn(strm);
+        strm << ' ' << ((hh <= 12) ? hh : hh-12) << ':'
+             << setfill('0') << setw(2) << GetMinute() << ':'
+         << setfill('0') << setw(2) << GetSecond() << ' ';
+        if (hh < 12) strm << _("am");
+        else strm << _("pm");
+}
+
+wxTime::wxTime(OIOin& strm)
+      : BASE(strm)
+{
+      unsigned long usec;
+      strm >> sec >> usec;
+}
+
+void wxTime::storer(OIOout& strm) const
+{
+        BASE::storer(strm);
+        strm << sec << 0l;
+}
+
+
+wxTime::wxTime(OIOifd& fd)
+      : BASE(fd)
+{
+      unsigned long usec;
+      fd >> sec >> usec;
+}
+
+void wxTime::storer(OIOofd& fd) const
+{
+      BASE::storer(fd);
+      fd << sec << 0l;
+}
+*/
+
+#endif