[wxWidgets.git] / 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

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