src/common/date.cpp

/////////////////////////////////////////////////////////////////////////////
// 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

#include "wx/setup.h"

#if wxUSE_TIMEDATE

#include "wx/date.h"
#include <wx/intl.h>

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#if wxUSE_IOSTREAMH
#include <iostream.h>
#else
#include <iostream>
#endif

#include <time.h>
#include <string.h>

#define ABBR_LENGTH 3

static const wxChar *dayname[] = {
    _T("Sunday"), _T("Monday"), _T("Tuesday"), _T("Wednesday"),
    _T("Thursday"), _T("Friday"), _T("Saturday")
};

static const wxChar *mname[] = {
    _T("January"), _T("February"), _T("March"), _T("April"), _T("May"), _T("June"),
    _T("July"), _T("August"), _T("September"), _T("October"), _T("November"), _T("December")
};

static int GauDays[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxDate, wxObject)
#endif

    ////////////////////////////////////////////////////////////
    // 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, _T("TODAY")) == 0 || wxStrcmp(dat, _T("today")) == 0)
    {
        // Sets the current date
        Set();
    }
    else
    {
        wxChar buf[100];
        wxStrcpy(buf, WXSTRINGCAST dat);

        wxChar *save_ptr, *token = wxStrtok(buf,_T("/-"),&save_ptr);
        month = wxAtoi(token);
        day   = wxAtoi(wxStrtok((wxChar *) NULL,_T("/-"),&save_ptr));
        year  = wxAtoi(wxStrtok((wxChar *) NULL,_T(" "),&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, _T("TODAY")) == 0 || wxStrcmp(dat, _T("today")) == 0)
    {
        // Sets the current date
        Set();
    }
    else
    {
        wxChar buf[100];
        wxStrcpy(buf, WXSTRINGCAST dat);

        wxChar *save_ptr, *token = wxStrtok(buf,_T("/-"),&save_ptr);
        month = wxAtoi(token);
        day   = wxAtoi(wxStrtok((wxChar *) NULL,_T("/-"),&save_ptr));
        year  = wxAtoi(wxStrtok((wxChar *) NULL,_T(" "),&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 );
}

////////////////////////////////////////////////////////////////
// Ostream operations
////////////////////////////////////////////////////////////////

ostream WXDLLEXPORT & operator << (ostream &os, const wxDate &dt)
{
    return os << dt.FormatDate().mb_str();
}

//////////////////////////////////////////////////////////////
// Conversion routines
//////////////////////////////////////////////////////////////

void wxDate::julian_to_wday (void)
{
    // Correction by Peter Stadel <peters@jetcity.com>
	day_of_week = ((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, _T(", "));
            wxStrncat( buf, wxGetTranslation(mname[month-1]),
		       (DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
            wxStrcat( buf, _T(" "));
            wxSprintf( buf+wxStrlen(buf), _T("%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,_T("%d "),  day);
            wxStrncat(buf, wxGetTranslation(mname[month-1]),
                    (DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
            wxSprintf( buf+wxStrlen(buf), _T(" %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), _T("%1d/%1d/%02d"), month, day,
			   (DisplayOptions & wxNO_CENTURY) && (abs(year) > 1899)
			   ? (abs(year) - (abs(year) / 100 * 100))
			   : (abs(year))  );
            return wxString(buf);
    }
    return wxString(_T(""));
}

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;
    }
    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
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: date.cpp
	3	// Purpose: wxDate class
	4	// Author:
	5	// Originally inspired by Steve Marcus (CIS 72007,1233) 6/16/91
	6	// Enhanced by Eric Simon (CIS 70540,1522) 6/29/91
	7	// Further Enhanced by Chris Hill (CIS 72030,2606) 7/11/91
	8	// Still Further Enhanced by Hill & Simon v3.10 8/05/91
	9	// Version 4 by Charles D. Price 6/27/92
	10	// Integrated into wxWindows by Julian Smart 9th July 1995
	11	// Modified by:
	12	// Created: 01/02/97
	13	// RCS-ID: $Id$
	14	// Copyright: (c) Julian Smart and Markus Holzem
	15	// Licence: wxWindows licence
	16	/////////////////////////////////////////////////////////////////////////////
	17
	18	#ifdef __GNUG__
	19	#pragma implementation "date.h"
	20	#endif
	21
	22	// For compilers that support precompilation, includes "wx.h".
	23	#include "wx/wxprec.h"
	24
	25	#ifdef __BORLANDC__
	26	#pragma hdrstop
	27	#endif
	28
	29	#include "wx/setup.h"
	30
	31	#if wxUSE_TIMEDATE
	32
	33	#include "wx/date.h"
	34	#include <wx/intl.h>
	35
	36	#include <stdio.h>
	37	#include <string.h>
	38	#include <stdlib.h>
	39
	40	#if wxUSE_IOSTREAMH
	41	#include <iostream.h>
	42	#else
	43	#include <iostream>
	44	#endif
	45
	46	#include <time.h>
	47	#include <string.h>
	48
	49	#define ABBR_LENGTH 3
	50
	51	static const wxChar *dayname[] = {
	52	_T("Sunday"), _T("Monday"), _T("Tuesday"), _T("Wednesday"),
	53	_T("Thursday"), _T("Friday"), _T("Saturday")
	54	};
	55
	56	static const wxChar *mname[] = {
	57	_T("January"), _T("February"), _T("March"), _T("April"), _T("May"), _T("June"),
	58	_T("July"), _T("August"), _T("September"), _T("October"), _T("November"), _T("December")
	59	};
	60
	61	static int GauDays[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	62
	63	#if !USE_SHARED_LIBRARY
	64	IMPLEMENT_DYNAMIC_CLASS(wxDate, wxObject)
	65	#endif
	66
	67	////////////////////////////////////////////////////////////
	68	// Constructors
	69	////////////////////////////////////////////////////////////
	70
	71	wxDate::wxDate()
	72	{
	73	DisplayFormat=wxMDY;
	74	DisplayOptions='\0';
	75	month = day = year = day_of_week = 0;
	76	julian = 0;
	77	}
	78
	79	wxDate::wxDate (long j) : julian(j)
	80	{
	81	DisplayFormat=wxMDY;
	82	DisplayOptions='\0';
	83	julian_to_mdy ();
	84	}
	85
	86	wxDate::wxDate (int m, int d, int y) : month(m), day(d), year(y)
	87	{
	88	DisplayFormat=wxMDY;
	89	DisplayOptions='\0';
	90	mdy_to_julian ();
	91	}
	92
	93	wxDate::wxDate (const wxString& dat)
	94	{
	95	DisplayFormat=wxMDY;
	96	DisplayOptions='\0';
	97	if (wxStrcmp(dat, _T("TODAY")) == 0 \|\| wxStrcmp(dat, _T("today")) == 0)
	98	{
	99	// Sets the current date
	100	Set();
	101	}
	102	else
	103	{
	104	wxChar buf[100];
	105	wxStrcpy(buf, WXSTRINGCAST dat);
	106
	107	wxChar save_ptr, token = wxStrtok(buf,_T("/-"),&save_ptr);
	108	month = wxAtoi(token);
	109	day = wxAtoi(wxStrtok((wxChar *) NULL,_T("/-"),&save_ptr));
	110	year = wxAtoi(wxStrtok((wxChar *) NULL,_T(" "),&save_ptr));
	111	}
	112
	113	mdy_to_julian ();
	114	}
	115
	116	wxDate::wxDate (const wxDate &dt)
	117	{
	118	DisplayFormat=dt.DisplayFormat;
	119	DisplayOptions=dt.DisplayOptions;
	120	month = dt.month;
	121	day = dt.day;
	122	year = dt.year;
	123	mdy_to_julian ();
	124	}
	125
	126	void wxDate::operator = (const wxDate &dt)
	127	{
	128	DisplayFormat=dt.DisplayFormat;
	129	DisplayOptions=dt.DisplayOptions;
	130	month = dt.month;
	131	day = dt.day;
	132	year = dt.year;
	133	mdy_to_julian (); // wxUSE_TIMEDATE
	134	}
	135
	136	void wxDate::operator = (const wxString& dat)
	137	{
	138	DisplayFormat=wxMDY;
	139	DisplayOptions='\0';
	140	if (wxStrcmp(dat, _T("TODAY")) == 0 \|\| wxStrcmp(dat, _T("today")) == 0)
	141	{
	142	// Sets the current date
	143	Set();
	144	}
	145	else
	146	{
	147	wxChar buf[100];
	148	wxStrcpy(buf, WXSTRINGCAST dat);
	149
	150	wxChar save_ptr, token = wxStrtok(buf,_T("/-"),&save_ptr);
	151	month = wxAtoi(token);
	152	day = wxAtoi(wxStrtok((wxChar *) NULL,_T("/-"),&save_ptr));
	153	year = wxAtoi(wxStrtok((wxChar *) NULL,_T(" "),&save_ptr));
	154	}
	155
	156	mdy_to_julian ();
	157	}
	158
	159	//////////////////////////////////////////////////////////////
	160	// Conversion operations
	161	//////////////////////////////////////////////////////////////
	162
	163	#ifndef __SALFORDC__
	164	wxDate::operator wxString( void )
	165	{
	166	return FormatDate();
	167	}
	168	#endif
	169
	170	//////////////////////////////////////////////////////////////
	171	// Date Arithmetic
	172	//////////////////////////////////////////////////////////////
	173
	174	wxDate wxDate::operator + (long i)
	175	{
	176	wxDate dp(julian + i);
	177	return dp;
	178	}
	179
	180	wxDate wxDate::operator + (int i)
	181	{
	182	wxDate dp(julian + (long)i);
	183	return dp;
	184	}
	185
	186	wxDate wxDate::operator - (long i)
	187	{
	188	wxDate dp(julian - i);
	189	return dp;
	190	}
	191
	192	wxDate wxDate::operator - (int i)
	193	{
	194	wxDate dp(julian - (long)i);
	195	return dp;
	196	}
	197
	198	long wxDate::operator - (const wxDate &dt)
	199	{
	200	return ( julian - dt.julian );
	201	}
	202
	203	wxDate &wxDate::operator += (long i)
	204	{
	205	julian += i;
	206	julian_to_mdy();
	207	return *this;
	208	}
	209
	210	wxDate &wxDate::operator -= (long i)
	211	{
	212	julian -= i;
	213	julian_to_mdy();
	214	return *this;
	215	}
	216
	217	wxDate &wxDate::operator ++()
	218	{
	219	julian++;
	220	julian_to_mdy();
	221	return *this;
	222	}
	223
	224	wxDate &wxDate::operator ++(int)
	225	{
	226	julian++;
	227	julian_to_mdy();
	228	return *this;
	229	}
	230
	231	wxDate &wxDate::operator --()
	232	{
	233	julian--;
	234	julian_to_mdy();
	235	return *this;
	236	}
	237
	238	wxDate &wxDate::operator --(int)
	239	{
	240	julian--;
	241	julian_to_mdy();
	242	return *this;
	243	}
	244
	245	//////////////////////////////////////////////////////////////
	246	// Date comparison
	247	//////////////////////////////////////////////////////////////
	248
	249	bool WXDLLEXPORT operator < (const wxDate &dt1, const wxDate &dt2)
	250	{
	251	return ( dt1.julian < dt2.julian );
	252	}
	253
	254	bool WXDLLEXPORT operator <= (const wxDate &dt1, const wxDate &dt2)
	255	{
	256	return ( (dt1.julian == dt2.julian) \|\| (dt1.julian < dt2.julian) );
	257	}
	258
	259	bool WXDLLEXPORT operator > (const wxDate &dt1, const wxDate &dt2)
	260	{
	261	return ( dt1.julian > dt2.julian );
	262	}
	263
	264	bool WXDLLEXPORT operator >= (const wxDate &dt1, const wxDate &dt2)
	265	{
	266	return ( (dt1.julian == dt2.julian) \|\| (dt1.julian > dt2.julian) );
	267	}
	268
	269	bool WXDLLEXPORT operator == (const wxDate &dt1, const wxDate &dt2)
	270	{
	271	return ( dt1.julian == dt2.julian );
	272	}
	273
	274	bool WXDLLEXPORT operator != (const wxDate &dt1, const wxDate &dt2)
	275	{
	276	return ( dt1.julian != dt2.julian );
	277	}
	278
	279	////////////////////////////////////////////////////////////////
	280	// Ostream operations
	281	////////////////////////////////////////////////////////////////
	282
	283	ostream WXDLLEXPORT & operator << (ostream &os, const wxDate &dt)
	284	{
	285	return os << dt.FormatDate().mb_str();
	286	}
	287
	288	//////////////////////////////////////////////////////////////
	289	// Conversion routines
	290	//////////////////////////////////////////////////////////////
	291
	292	void wxDate::julian_to_wday (void)
	293	{
	294	// Correction by Peter Stadel <peters@jetcity.com>
	295	day_of_week = ((julian - 2) % 7L);
	296	/*
	297	day_of_week = (int) ((julian + 2) % 7 + 1);
	298	*/
	299	}
	300
	301	void wxDate::julian_to_mdy ()
	302	{
	303	long a,b,c,d,e,z,alpha;
	304	z = julian+1;
	305	// dealing with Gregorian calendar reform
	306	if (z < 2299161L)
	307	a = z;
	308	else {
	309	alpha = (long) ((z-1867216.25) / 36524.25);
	310	a = z + 1 + alpha - alpha/4;
	311	}
	312	b = ( a > 1721423 ? a + 1524 : a + 1158 );
	313	c = (long) ((b - 122.1) / 365.25);
	314	d = (long) (365.25 * c);
	315	e = (long) ((b - d) / 30.6001);
	316	day = (int)(b - d - (long)(30.6001 * e));
	317	month = (int)((e < 13.5) ? e - 1 : e - 13);
	318	year = (int)((month > 2.5 ) ? (c - 4716) : c - 4715);
	319	julian_to_wday ();
	320	}
	321
	322	void wxDate::mdy_to_julian (void)
	323	{
	324	int a,b=0;
	325	int work_month=month, work_day=day, work_year=year;
	326	// correct for negative year
	327	if (work_year < 0)
	328	work_year++;
	329	if (work_month <= 2)
	330	{ work_year--; work_month +=12; }
	331
	332	// deal with Gregorian calendar
	333	if (work_year10000. + work_month100. + work_day >= 15821015.)
	334	{
	335	a = (int)(work_year/100.);
	336	b = 2 - a + a/4;
	337	}
	338	julian = (long) (365.25*work_year) +
	339	(long) (30.6001 * (work_month+1)) + work_day + 1720994L + b;
	340	julian_to_wday ();
	341	}
	342
	343	////////////////////////////////////////////////////////////////
	344	// Format routine
	345	////////////////////////////////////////////////////////////////
	346
	347	wxString wxDate::FormatDate (int type) const
	348	{
	349	int actualType = type;
	350	if (actualType == -1)
	351	actualType = DisplayFormat;
	352
	353	wxChar buf[40];
	354
	355	memset( buf, '\0', sizeof(buf) );
	356	switch ( actualType )
	357	{
	358	case wxDAY:
	359	if ( (day_of_week < 1) \|\| (day_of_week > 7) )
	360	wxStrcpy(buf, _("invalid day"));
	361	else
	362	wxStrncpy( buf, wxGetTranslation(dayname[day_of_week-1]),
	363	(DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
	364	return wxString(buf);
	365
	366	case wxMONTH:
	367	if ( (month < 1) \|\| (month > 12) )
	368	wxStrcpy(buf, _("invalid month"));
	369	else
	370	wxStrncpy( buf, wxGetTranslation(mname[month-1]),
	371	(DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
	372	return wxString(buf);
	373
	374	case wxFULL:
	375	if ( (month < 1) \|\| (month > 12) \|\| (day_of_week < 0) \|\|
	376	(day_of_week > 7) )
	377	{
	378	wxStrcpy(buf, _("invalid date"));
	379	return wxString(buf);
	380	}
	381	wxStrncpy( buf, wxGetTranslation(dayname[day_of_week-1]),
	382	(DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
	383	wxStrcat( buf, _T(", "));
	384	wxStrncat( buf, wxGetTranslation(mname[month-1]),
	385	(DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
	386	wxStrcat( buf, _T(" "));
	387	wxSprintf( buf+wxStrlen(buf), _T("%d, %d"), day, abs(year) );
	388	if (year < 0)
	389	wxStrcat(buf,_(" B.C."));
	390	return wxString(buf);
	391
	392	case wxEUROPEAN:
	393	if ( (month < 1) \|\| (month > 12) \|\| (day_of_week < 0) \|\|
	394	(day_of_week > 7) )
	395	{
	396	wxStrcpy(buf, _("invalid date"));
	397	return wxString(buf);
	398	}
	399	wxSprintf(buf,_T("%d "), day);
	400	wxStrncat(buf, wxGetTranslation(mname[month-1]),
	401	(DisplayOptions & wxDATE_ABBR) ? ABBR_LENGTH : 9);
	402	wxSprintf( buf+wxStrlen(buf), _T(" %d"), abs(year) );
	403	if (year < 0)
	404	wxStrcat(buf, _(" B.C."));
	405	return wxString(buf);
	406
	407	case wxMDY:
	408	default:
	409	if (day==0 \|\| month==0 \|\| year==0)
	410	wxStrcpy(buf, _("invalid date"));
	411	else
	412	wxSprintf( buf+wxStrlen(buf), _T("%1d/%1d/%02d"), month, day,
	413	(DisplayOptions & wxNO_CENTURY) && (abs(year) > 1899)
	414	? (abs(year) - (abs(year) / 100 * 100))
	415	: (abs(year)) );
	416	return wxString(buf);
	417	}
	418	return wxString(_T(""));
	419	}
	420
	421	void wxDate::SetFormat( int format )
	422	{
	423	DisplayFormat = format;
	424	}
	425
	426	int wxDate::SetOption( int option, bool action )
	427	{
	428	switch ( option )
	429	{
	430	case wxNO_CENTURY:
	431	if ( action )
	432	DisplayOptions \|= wxNO_CENTURY;
	433	else
	434	{
	435	DisplayOptions &= (~wxNO_CENTURY);
	436	}
	437	return 1;
	438	case wxDATE_ABBR:
	439	if ( action )
	440	DisplayOptions \|= wxDATE_ABBR;
	441	else
	442	{
	443	DisplayOptions &= (~wxDATE_ABBR);
	444	}
	445	return 1;
	446	default:
	447	return 0;
	448	}
	449	return 0;
	450	}
	451
	452	///////////////////////////////////////////////////////////////
	453	// Miscellaneous Routines
	454	///////////////////////////////////////////////////////////////
	455
	456	long wxDate::GetJulianDate( void ) const
	457	{
	458	return julian;
	459	}
	460
	461	int wxDate::GetDayOfYear( void ) const
	462	{
	463	wxDate temp( 1, 1, year );
	464
	465	return (int) (julian - temp.julian + 1);
	466	}
	467
	468
	469	bool wxDate::IsLeapYear( void ) const
	470	{
	471	return ( (year >= 1582) ?
	472	(year % 4 == 0 && year % 100 != 0 \|\| year % 400 == 0 ):
	473	(year % 4 == 0) );
	474	}
	475
	476	// Version 4.0 Extension to Public Interface - CDP
	477
	478	wxDate& wxDate::Set()
	479	{
	480	//#ifdef __WXMSW__
	481	#if 0
	482	struct _dosdate_t sDate;
	483	_dos_getdate(&sDate);
	484
	485	month = sDate.month;
	486	day = sDate.day;
	487	year = sDate.year;
	488
	489	mdy_to_julian();
	490	#else
	491	time_t now = time((time_t *) NULL);
	492	struct tm *localTime = localtime(&now);
	493
	494	month = localTime->tm_mon + 1;
	495	day = localTime->tm_mday;
	496	year = localTime->tm_year + 1900;
	497
	498	mdy_to_julian ();
	499	#endif
	500	return *this;
	501	}
	502
	503	wxDate& wxDate::Set(
	504	int nMonth,
	505	int nDay,
	506	int nYear)
	507	{
	508	month = nMonth;
	509	year = nYear < 0 ? 9999 : nYear;
	510	year = nYear > 9999 ? 0 : nYear;
	511	day = nDay < GetDaysInMonth() ? nDay : GetDaysInMonth();
	512
	513	mdy_to_julian();
	514	return *this;
	515	}
	516
	517	wxDate &
	518	wxDate::Set(long j)
	519	{
	520	julian = j;
	521
	522	julian_to_mdy();
	523	return *this;
	524	}
	525
	526
	527	int wxDate::GetDaysInMonth()
	528	{
	529	return GauDays[month-1] + (month==2 && IsLeapYear());
	530	}
	531
	532	int wxDate::GetFirstDayOfMonth() const
	533	{
	534	return wxDate(month, 1, year).GetDayOfWeek();
	535	}
	536
	537	int wxDate::GetDay() const
	538	{
	539	return day;
	540	}
	541
	542	int wxDate::GetDayOfWeek() const
	543	{
	544	return day_of_week;
	545	}
	546
	547	int wxDate::GetYear() const
	548	{
	549	return year;
	550	}
	551
	552	int wxDate::GetMonth() const
	553	{
	554	return month;
	555	}
	556
	557	wxDate& wxDate::AddWeeks(int nCount)
	558	{
	559	Set(julian + (long)nCount*7);
	560	return *this;
	561	}
	562
	563	wxDate& wxDate::AddMonths(int nCount)
	564	{
	565	month += nCount;
	566
	567	if (month < 1) {
	568	month = 12;
	569	year--;
	570	}
	571
	572	if (month > 12) {
	573	month = 1;
	574	year++;
	575	}
	576	mdy_to_julian();
	577	return *this;
	578	}
	579
	580	wxDate& wxDate::AddYears(int nCount)
	581	{
	582	year += nCount;
	583	mdy_to_julian();
	584	return *this;
	585	}
	586
	587	int wxDate::GetWeekOfMonth()
	588	{
	589	// Abs day includes the days from previous month that fills up
	590	// the begin. of the week.
	591	int nAbsDay = day + GetFirstDayOfMonth()-1;
	592	return (nAbsDay-GetDayOfWeek())/7 + 1;
	593	}
	594
	595	int wxDate::GetWeekOfYear()
	596	{
	597	wxDate doTemp(1, 1, year);
	598	return (int)(((julian - doTemp.julian+1)/7) + 1);
	599	}
	600
	601	wxDate wxDate::GetMonthStart()
	602	{
	603	return(wxDate(month, 1, year));
	604	}
	605
	606	wxDate wxDate::GetMonthEnd()
	607	{
	608	return(wxDate(month+1, 1, year)-1);
	609	}
	610
	611	wxDate wxDate::GetYearStart()
	612	{
	613	return(wxDate(1, 1, year));
	614	}
	615
	616	wxDate wxDate::GetYearEnd()
	617	{
	618	return(wxDate(1, 1, year+1)-1);
	619	}
	620
	621	wxString wxDate::GetMonthName()
	622	{
	623	return(FormatDate(wxMONTH));
	624	}
	625
	626	wxString wxDate::GetDayOfWeekName()
	627	{
	628	return(FormatDate(wxDAY));
	629	}
	630
	631	bool wxDate::IsBetween(const wxDate& first, const wxDate& second) const
	632	{
	633	return (julian >= first.julian && julian <= second.julian);
	634	}
	635
	636	// This function is from NIHCL
	637	wxDate wxDate::Previous(int dayOfWeek) const
	638	{
	639	int this_day_Of_Week, desired_day_Of_Week;
	640	long j;
	641
	642	// Set the desired and current day of week to start at 0 (Monday)
	643	// and end at 6 (Sunday).
	644
	645	desired_day_Of_Week = dayOfWeek - 1; // These functions return a value
	646	this_day_Of_Week = GetDayOfWeek() - 1; // from 1-7. Subtract 1 for 0-6.
	647	j = julian;
	648
	649	// Have to determine how many days difference from current day back to
	650	// desired, if any. Special calculation under the 'if' statement to
	651	// effect the wraparound counting from Monday (0) back to Sunday (6).
	652
	653	if (desired_day_Of_Week > this_day_Of_Week)
	654	this_day_Of_Week += 7 - desired_day_Of_Week;
	655	else
	656	this_day_Of_Week -= desired_day_Of_Week;
	657	j -= this_day_Of_Week; // Adjust j to set it at the desired day of week.
	658	return wxDate(j);
	659	}
	660
	661	#endif