admin/ayanova7
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
ayanova7/archive/ayanova 1.9.4 CE final release db schema 171/sp/SimpleDate.cpp

1092 lines
31 KiB
C++
Raw Permalink Blame History

// SimpleDate.cpp: implementation of the CSimpleDate class.
//
// Most of the date alogrithms used in this class can be found at
// http://www.capecod.net/~pbaum/date/date0.htm
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "SimpleDate.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
#pragma message( "Compiling " __FILE__ )
#pragma message( "Last modified on " __TIMESTAMP__ )
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
static int monthtotals[]=
{ 0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 } ;
static char* daysofweek[] =
{
{ "Sun" },
{ "Mon" },
{ "Tue" },
{ "Wed" },
{ "Thu" },
{ "Fri" },
{ "Sat" },
} ;
static char* days_of_week[] =
{
{ "Sunday" },
{ "Monday" },
{ "Tuesday" },
{ "Wednesday" },
{ "Thursday" },
{ "Friday" },
{ "Saturday" },
} ;
static char* monthsofyear[] =
{
{ "" },
{ "Jan" },
{ "Feb" },
{ "Mar" },
{ "Apr" },
{ "May" },
{ "Jun" },
{ "Jul" },
{ "Aug" },
{ "Sep" },
{ "Oct" },
{ "Nov" },
{ "Dec" },
} ;
static char* months_of_year[] =
{
{ "" },
{ "January" },
{ "February" },
{ "March" },
{ "April" },
{ "May" },
{ "June" },
{ "July" },
{ "August" },
{ "September" },
{ "October" },
{ "November" },
{ "December" },
} ;
//--------------------------------------------------------------------
// Function name : CSimpleDate::CSimpleDate
// Description : Simple Constructor object is set to todays date
// Return type :
//--------------------------------------------------------------------
CSimpleDate::CSimpleDate(int FormatType)
{
m_Format=FormatType;
SetToday();
m_JulianDate=ConvertToJulian();
SetTime();
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::CSimpleDate
// Description : paramaterized constructor object is set to date in string. Parsing will be done based on formattype
// Return type :
// Argument : LPCSTR DateString
//--------------------------------------------------------------------
CSimpleDate::CSimpleDate(LPCSTR DateString,int FormatType)
{
m_Format=FormatType;
ParseDateString(DateString);
m_JulianDate=ConvertToJulian();
SetTime();
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::CSimpleDate
// Description :
// Return type :
// Argument : long JD
// Argument : int FormatType
//--------------------------------------------------------------------
CSimpleDate::CSimpleDate(long JD,int FormatType)
{
m_Format=FormatType;
m_JulianDate=JD;
ConvertFromJulian(); // note: m_JulianDate must be set prior to this call
SetTime();
}
//added constructor JC 10/05/00
CSimpleDate::CSimpleDate( int month,int day,int year,int FormatType)
{
m_Format=FormatType;
m_JulianDate=ConvertToJulian( month, day, year);
//// Added initialization /////
m_Year=year;
m_Month=month;
m_Day=day;
//////////////////////////////
SetTime();
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::~CSimpleDate
// Description :
// Return type :
//--------------------------------------------------------------------
CSimpleDate::~CSimpleDate()
{
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::SetToday
// Description :
// Return type : BOOL
//--------------------------------------------------------------------
BOOL CSimpleDate::SetToday()
{
long time_val ;
struct tm *tm_ptr ;
time( (time_t *)&time_val ) ;
tm_ptr = localtime( (time_t *)&time_val ) ;
m_Year=1900 + tm_ptr->tm_year;
m_Month=tm_ptr->tm_mon + 1;
m_Day=tm_ptr->tm_mday;
return TRUE;
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::IsValid
// Description : Hope that this is right and Y2K OK
// Return type : BOOL
//--------------------------------------------------------------------
BOOL CSimpleDate::IsValid()
{
int is_leap, month_days ;
is_leap = ( m_Year%4 == 0 && m_Year%100 != 0 || m_Year%400 == 0 ) ? 1 : 0 ;
if(m_Month > 12 || m_Day > 31)
return FALSE;
month_days = monthtotals[ m_Month+1 ] - monthtotals[ m_Month] ;
if ( m_Month == 2 ) month_days += is_leap ;
if ( m_Year < 0 ||
m_Month < 1 || m_Month > 12 ||
m_Day < 1 || m_Day > month_days )
return FALSE ;
return TRUE;
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::ParseDateString
// Description :
// Return type : BOOL
// Argument : LPCSTR TheDate
//--------------------------------------------------------------------
BOOL CSimpleDate::ParseDateString(LPCSTR TheDate)
{
ParseDateString(TheDate,m_Month,m_Day,m_Year);
return TRUE;
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::ParseDateString
// Description : See CParseIt class in Parseit.cpp for details
// Return type : BOOL
// Argument : LPCSTR date
// Argument : int& m
// Argument : int& d
// Argument : int& y
//--------------------------------------------------------------------
BOOL CSimpleDate::ParseDateString(LPCSTR date,int& m,int& d,int& y)
{
CParseIt ParseIt(date,"/.-");
ParseIt.Parse();
int one,two,three;
one=two=three=0;
int N=ParseIt.GetNumFields();
one=(int)ParseIt.GetField(1);
if(N > 1)
two=(int)ParseIt.GetField(2);
if(N > 2)
three=(int)ParseIt.GetField(3);
switch(m_Format)
{
case MMDDYY:
m=one;d=two;y=three;
if(y < 100) // ajust two digit year to the range of 1900-1999
y+=1900;
break;
case DDMMYY:
d=one;m=two;y=three;
if(y < 100)
y+=1900;
break;
case YYMMDD:
y=one;m=two;d=three;
if(y < 100)
y+=1900;
break;
case MMDDYYYY:
m=one;d=two;y=three;
if(y < 100)
y+=1900;
break;
case DDMMYYYY:
d=one;m=two;y=three;
if(y < 100)
y+=1900;
break;
case YYYYMMDD:
y=one;m=two;d=three;
if(y < 100)
y+=1900;
break;
default:
m=y=d=0;
}
return TRUE;
}
//--------------------------------------------------------------------
// JULIAN DATE CONVERSION BELOW
//--------------------------------------------------------------------
// Function name : CSimpleDate::ConvertToJulian
// Description :
// Return type : long
//--------------------------------------------------------------------
long CSimpleDate::ConvertToJulian()
{
return ConvertToJulian(m_Month,m_Day,m_Year);
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::ConvertToJulian
// Description : go to http://www.capecod.net/~pbaum/date/date0.htm for details
// Return type : long
// Argument : int month
// Argument : int day
// Argument : int year
//--------------------------------------------------------------------
long CSimpleDate::ConvertToJulian( int m,int d,int y)
{
if(m < 3)
{
m = m + 12;
y=y-1 ;
}
long jd = d + (153 * m - 457) / 5 + 365 * y + (y / 4) - (y / 100) + (y / 400) + 1721119;
return jd;
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::ConvertFromJulian
// Description :
// Return type : void
//--------------------------------------------------------------------
void CSimpleDate::ConvertFromJulian()
{
ConvertFromJulian(m_Month,m_Day,m_Year);
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::ConvertFromJulian
// Description : goto http://www.capecod.net/~pbaum/date/date0.htm for details
// Return type : void
// Argument : int Month
// Argument : int DAy
// Argument : int Year
//--------------------------------------------------------------------
void CSimpleDate::ConvertFromJulian(int& Month,int& Day,int& Year)
{
long L = m_JulianDate + 68569;
long N = (long) ((4*L)/146097) ;
L = L - ((long)((146097 * N + 3)/4) );
long I = (long) ((4000 *(L + 1)/1461001)) ;
L = L - (long)((1461*I)/4) + 31;
long J = (long)((80*L)/2447);
Day = L - (long)((2447*J)/80);
L=(long)(J/11) ;
Month = J + 2 - 12*L;
Year = 100*(N-49) + I + L ;
}
//--------------------------------------------------------------------
// JULIAN DATE CONVERSION ABOVE
//--------------------------------------------------------------------
//--------------------------------------------------------------------
// Function name : CSimpleDate::GetDayOfWeek
// Description : goto http://www.capecod.net/~pbaum/date/date0.htm for details
// Return type : int
//--------------------------------------------------------------------
int CSimpleDate::GetDayOfWeek()
{
if(!IsValid())
return 0;
int res= ((int) (m_JulianDate + 1.5)) % 7;
return res;
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::GetFullDateString
// Description :
// Return type : LPCSTR
//--------------------------------------------------------------------
LPCSTR CSimpleDate::GetFullDateString()
{
if(!IsValid())
return NULL;
m_DateString.Format("%s %s %02d %04d", daysofweek[GetDayOfWeek()],monthsofyear[m_Month],m_Day,m_Year);
return m_DateString;
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::GetFullDateStringLong
// Description :
// Return type : LPCSTR
//--------------------------------------------------------------------
LPCSTR CSimpleDate::GetFullDateStringLong()
{
if(!IsValid())
return NULL;
m_DateString.Format("%s %s %02d %04d", days_of_week[GetDayOfWeek()],months_of_year[m_Month],m_Day,m_Year);
return m_DateString;
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::GetJulianDate
// Description :
// Return type : long
//--------------------------------------------------------------------
long CSimpleDate::GetJulianDate()
{
if(!IsValid())
return 0L;
return m_JulianDate;
}
//--------------------------------------------------------------------
// overloaded operators and copy constructors here
//--------------------------------------------------------------------
// Function name : LPCSTR
// Description :
// Return type : CSimpleDate::operator return LPCSTR
//--------------------------------------------------------------------
CSimpleDate::operator LPCSTR()
{
if(!IsValid())
return (LPCSTR)0;
switch(m_Format)
{
case MMDDYY:
m_DateString.Format("%02d/%02d/%02d",m_Month,m_Day,m_Year > 99 ? m_Year-1900:m_Year);
return (LPCSTR)m_DateString;
case DDMMYY:
m_DateString.Format("%02d/%02d/%02d",m_Day,m_Month,m_Year > 99 ? m_Year-1900:m_Year);
return (LPCSTR)m_DateString;
case YYMMDD:
m_DateString.Format("%02d/%02d/%02d",m_Year > 99 ? m_Year-1900:m_Year,m_Month,m_Day);
return (LPCSTR)m_DateString;
case MMDDYYYY:
m_DateString.Format("%02d/%02d/%04d",m_Month,m_Day,m_Year );
return (LPCSTR)m_DateString;
case DDMMYYYY:
m_DateString.Format("%02d/%02d/%04d",m_Day,m_Month,m_Year);
return (LPCSTR)m_DateString;
case YYYYMMDD:
m_DateString.Format("%04d/%02d/%02d",m_Year ,m_Month,m_Day);
return (LPCSTR)m_DateString;
default:
return (LPCSTR)NULL;
}
}
//--------------------------------------------------------------------
// OPERATORS
//--------------------------------------------------------------------
// Function name : long
// Description :
// Return type : CSimpleDate::operator return long
//--------------------------------------------------------------------
CSimpleDate::operator long()
{
if(!IsValid())
return 0L;
return m_JulianDate;
}
//--------------------------------------------------------------------
// Function name : =
// Description :
// Return type : CSimpleDate::operator
//--------------------------------------------------------------------
const CSimpleDate& CSimpleDate::operator =(const CSimpleDate& Date)
{
if(*this==Date)
return *this; // self assignment
m_Year=Date.m_Year;
m_Month=Date.m_Month;
m_Day=Date.m_Day;
m_JulianDate=Date.m_JulianDate;
m_Format=Date.m_Format;
return *this;
}
//--------------------------------------------------------------------
// Function name : =
// Description :
// Return type : CSimpleDate::operator
//--------------------------------------------------------------------
const CSimpleDate& CSimpleDate::operator =(LPCSTR Date)
{
ParseDateString(Date);
m_JulianDate=ConvertToJulian();
return *this;
}
//--------------------------------------------------------------------
BOOL CSimpleDate::operator > (const CSimpleDate& Date)
{
if(!IsValid())
return FALSE;
return m_JulianDate > Date.m_JulianDate;
}
//--------------------------------------------------------------------
BOOL CSimpleDate::operator >= (const CSimpleDate& Date)
{
if(!IsValid())
return FALSE;
return m_JulianDate >= Date.m_JulianDate;
}
//--------------------------------------------------------------------
BOOL CSimpleDate::operator < (const CSimpleDate& Date)
{
if(!IsValid())
return FALSE;
return m_JulianDate < Date.m_JulianDate;
}
//--------------------------------------------------------------------
BOOL CSimpleDate::operator <= (const CSimpleDate& Date)
{
if(!IsValid())
return FALSE;
return m_JulianDate <= Date.m_JulianDate;
}
//--------------------------------------------------------------------
BOOL CSimpleDate::operator == (const CSimpleDate& Date)
{
if(!IsValid())
return FALSE;
return m_JulianDate == Date.m_JulianDate;
}
//--------------------------------------------------------------------
BOOL CSimpleDate::operator != (const CSimpleDate& Date)
{
if(!IsValid())
return FALSE;
return m_JulianDate != Date.m_JulianDate;
}
//--------------------------------------------------------------------
BOOL CSimpleDate::operator > (LPCSTR Date)
{
if(!IsValid())
return FALSE;
CSimpleDate TheDate(Date);
if(!TheDate.IsValid())
return FALSE;
return m_JulianDate > TheDate.m_JulianDate;
}
//--------------------------------------------------------------------
BOOL CSimpleDate::operator < (LPCSTR Date)
{
if(!IsValid())
return FALSE;
CSimpleDate TheDate(Date);
if(!TheDate.IsValid())
return FALSE;
return m_JulianDate < TheDate.m_JulianDate;
}
//--------------------------------------------------------------------
BOOL CSimpleDate::operator >= (LPCSTR Date)
{
if(!IsValid())
return FALSE;
CSimpleDate TheDate(Date);
if(!TheDate.IsValid())
return FALSE;
return m_JulianDate >= TheDate.m_JulianDate;
}
//--------------------------------------------------------------------
BOOL CSimpleDate::operator <= (LPCSTR Date)
{
if(!IsValid())
return FALSE;
CSimpleDate TheDate(Date);
if(!TheDate.IsValid())
return FALSE;
return m_JulianDate <= TheDate.m_JulianDate;
}
//--------------------------------------------------------------------
BOOL CSimpleDate::operator == (LPCSTR Date)
{
if(!IsValid())
return FALSE;
CSimpleDate TheDate(Date);
if(!TheDate.IsValid())
return FALSE;
return m_JulianDate == TheDate.m_JulianDate;
}
//--------------------------------------------------------------------
BOOL CSimpleDate::operator != (LPCSTR Date)
{
if(!IsValid())
return FALSE;
CSimpleDate TheDate(Date);
if(!TheDate.IsValid())
return FALSE;
return m_JulianDate != TheDate.m_JulianDate;
}
//--------------------------------------------------------------------
// Date Math routines
//--------------------------------------------------------------------
// Function name : CSimpleDate::YearsOld
// Description :
// Return type : int
//--------------------------------------------------------------------
int CSimpleDate::YearsOld()
{
if(!IsValid())
return 0;
CSimpleDate ToDay;
if(ToDay <= *this)
return 0;
long t=ToDay.GetJulianDate();
long b=GetJulianDate();
return (int)((t-b)/365.2425);
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::AddMonths
// Description :
// Return type : const CSimpleDate&
// Argument : int Mon
//--------------------------------------------------------------------
const CSimpleDate& CSimpleDate::AddMonths(int Mon)
{
if(!IsValid())
return *this;
m_Month+=Mon;
if(m_Month > 12)
{
while(m_Month > 12)
{
m_Month-=12;
++m_Year;
}
}
AdjustDays();
m_JulianDate=ConvertToJulian();
return *this;
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::SubtractMonths
// Description :
// Return type : const CSimpleDate&
// Argument : int Mon
//--------------------------------------------------------------------
const CSimpleDate& CSimpleDate::SubtractMonths(int Mon)
{
if(!IsValid())
return *this;
if(Mon > 12)
{
int t= Mon/12;
m_Year-=t;
Mon=Mon-(t*12);
}
m_Month-=Mon;
if(m_Month < 1)
{
--m_Year;
m_Month+=12;
}
AdjustDays();
m_JulianDate=ConvertToJulian();
return *this;
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::AddYears
// Description :
// Return type : const CSimpleDate&
// Argument : int Yrs
//--------------------------------------------------------------------
const CSimpleDate& CSimpleDate::AddYears(int Yrs)
{
if(!IsValid())
return *this;
m_Year+=Yrs;
AdjustDays();
m_JulianDate=ConvertToJulian();
return *this;
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::SubtractYears
// Description :
// Return type : const CSimpleDate&
// Argument : int Yrs
//--------------------------------------------------------------------
const CSimpleDate& CSimpleDate::SubtractYears(int Yrs)
{
if(!IsValid())
return *this;
m_Year-=Yrs;
AdjustDays();
m_JulianDate=ConvertToJulian();
return *this;
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::AddDays
// Description :
// Return type : const CSimpleDate&
// Argument : int Days
//--------------------------------------------------------------------
const CSimpleDate& CSimpleDate::AddDays(int Days)
{
if(!IsValid())
return *this;
m_JulianDate+=Days;
ConvertFromJulian(m_Month,m_Day,m_Year);
return *this;
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::SubtractDays
// Description :
// Return type : const CSimpleDate&
// Argument : int Days
//--------------------------------------------------------------------
const CSimpleDate& CSimpleDate::SubtractDays(int Days)
{
if(!IsValid())
return *this;
m_JulianDate-=Days;
ConvertFromJulian(m_Month,m_Day,m_Year);
return *this;
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::AdjustDays
// Description :
// Return type : void
//--------------------------------------------------------------------
void CSimpleDate::AdjustDays()
{
int is_leap, month_days ;
is_leap = ( m_Year%4 == 0 && m_Year%100 != 0 || m_Year%400 == 0 ) ? 1 : 0 ;
month_days = monthtotals[ m_Month+1 ] - monthtotals[ m_Month] ;
if ( m_Month == 2 ) month_days += is_leap ;
while(m_Day > month_days)
--m_Day;
}
//--------------------------------------------------------------------
// Time functions
//--------------------------------------------------------------------
// Function name : CSimpleDate::SetTime
// Description : The only time function: Sets the variables for later use
// Return type : void
//--------------------------------------------------------------------
void CSimpleDate::SetTime()
{
long time_val ;
struct tm *tm_ptr ;
time( (time_t *)&time_val) ;
tm_ptr = localtime( (time_t *)&time_val) ;
m_Hour=tm_ptr->tm_hour;
m_Min=tm_ptr->tm_min;
m_Second=tm_ptr->tm_sec;
if(m_Hour > 12)
{
m_bPM=TRUE;
m_Hour-=12;
}
else
m_bPM=FALSE;
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::GetTimeString
// Description :
// Return type : void
// Argument : CString& s
// Argument : BOOL AmPm
//--------------------------------------------------------------------
void CSimpleDate::GetTimeString(CString& s,BOOL AmPm)
{
if(!IsValid())
{
s.Empty();
return;
}
SetTime();
int Flag=0;
if(AmPm==TRUE)
{
if(m_bPM)
Flag=1;
else
Flag=2;
}
s.Format("%02d:%02d:%02d %s",m_Hour==0 ? 12:m_Hour,m_Min,m_Second,Flag==0 ? "":Flag==1 ? "PM":"AM");
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::GetTimeString
// Description :
// Return type : void
// Argument : LPSTR s
// Argument : int nLen
// Argument : BOOL AmPm
//--------------------------------------------------------------------
void CSimpleDate::GetTimeString(LPSTR s,int nLen,BOOL AmPm)
{
CString cs;
GetTimeString(cs,AmPm);
strncpy(s,cs,nLen);
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::GetTimeStringShort
// Description :
// Return type : void
// Argument : CString& s
// Argument : BOOL AmPm
//--------------------------------------------------------------------
void CSimpleDate::GetTimeStringShort(CString& s,BOOL AmPm)
{
if(!IsValid())
{
s.Empty();
return;
}
SetTime();
int Flag=0;
if(AmPm==TRUE)
{
if(m_bPM)
Flag=1;
else
Flag=2;
}
s.Format("%02d:%02d %s",m_Hour==0 ? 12:m_Hour,m_Min,Flag==0 ? "":Flag==1 ? "PM":"AM");
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::GetTimeStringShort
// Description :
// Return type : void
// Argument : LPSTR s
// Argument : int nLen
// Argument : BOOL AmPm
//--------------------------------------------------------------------
void CSimpleDate::GetTimeStringShort(LPSTR s,int nLen,BOOL AmPm)
{
CString cs;
GetTimeStringShort(cs,AmPm);
strncpy(s,cs,nLen);
}
//--------------------------------------------------------------------
// Static member functions
//--------------------------------------------------------------------
// Function name : CSimpleDate::FixDateFormat
// Description :
// Return type : BOOL
// Argument : LPSTR str
//--------------------------------------------------------------------
BOOL CSimpleDate::FixDateFormat(LPSTR str)
{
CString s;
s=str;
if(FixDateFormat(s))
{
strcpy(str,s);
return TRUE;
}
return FALSE;
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::FixDateFormat
// Description :
// Return type : BOOL
// Argument : CString& str
//--------------------------------------------------------------------
BOOL CSimpleDate::FixDateFormat(CString& str)
{
char Buff[20];
if(str.IsEmpty())
return FALSE;
if(str.GetLength() < 6 || str.GetLength() > 11)
return FALSE;
CParseIt ParseIt(str,"/.-");
ParseIt.Parse();
int N=ParseIt.GetNumFields();
if(N > 1)
return FALSE;
strcpy(Buff,str.Left(2));
strcat(Buff,"/");
strcat(Buff,str.Mid(2,2));
strcat(Buff,"/");
if(str.GetLength()==6)
strcat(Buff,str.Right(2));
else
strcat(Buff,str.Right(str.GetLength()-4));
str=Buff;
return TRUE;
}
//--------------------------------------------------------------------
// Function name : CSimpleDate::VerifyDateFormat
// Description :
// Return type : BOOL
// Argument : LPCSTR date
//--------------------------------------------------------------------
BOOL CSimpleDate::VerifyDateFormat(LPCSTR date)
{
BOOL HasSeperators=FALSE;
CString TheDate;
// allow blank dates
if(strlen(date)==0)
return TRUE;
// shortest possible date
if(strlen(date) < 6)
return FALSE;
// look for unacceptable characters
for(int x=0;x < (signed)strlen(date);++x)
{
if( date[x] !='/' && date[x] !='-' && date[x] !='.' && !isdigit(date[x]))
return FALSE;
}
for(x=0;x < (signed)strlen(date);++x)
{
if( date[x] =='/' || date[x] =='-' || date[x] =='.')
HasSeperators=TRUE;
}
TheDate=date;
if(!HasSeperators)
{
if(!FixDateFormat(TheDate))
return FALSE;
}
CSimpleDate s(TheDate);
return s.IsValid();
}
//--------------------------------------------------------------------
//--------------------------------------------------------------------
//--------------------------------------------------------------------
// NON CLASS MEMBER HELPER FUNCTIONS
//--------------------------------------------------------------------
///////////////////////////////////////////////////////////////////////////
// data input a validation for the CSimpleDate class. These routines will allow
// input of date strings into a C type string or a CString or a long and will verify that
// the data is correct and will supply formatting if none is provided.
///////////////////////////////////////////////////////////////////////////
//--------------------------------------------------------------------
//--------------------------------------------------------------------
//--------------------------------------------------------------------
//--------------------------------------------------------------------
// Function name : DDX_SimpleDate
// Description : This is not real efficient but works. Makes extensive use
// of static class members so speed is not the greatest
// Return type : void
// Argument : CDataExchange *pDX
// Argument : int nID
// Argument : LPSTR str
// Argument : int nLen
//--------------------------------------------------------------------
void DDX_SimpleDate(CDataExchange *pDX,int nID,LPSTR str,int nLen)
{
char buff[50];
pDX->PrepareEditCtrl(nID);
CEdit *ptr=(CEdit *)pDX->m_pDlgWnd->GetDlgItem(nID);
if(pDX->m_bSaveAndValidate)
{
pDX->m_pDlgWnd->GetDlgItem(nID)->GetWindowText(buff,50);
if(CSimpleDate::FixDateFormat(buff))
pDX->m_pDlgWnd->GetDlgItem(nID)->SetWindowText(buff);
if(ptr->LineLength() > nLen)
{
sprintf(buff,"Max Length is %d",nLen);
pDX->m_pDlgWnd->MessageBox(buff,"",MB_OK);
pDX->Fail();
}
pDX->m_pDlgWnd->GetDlgItem(nID)->GetWindowText(str,nLen+1);
if(CSimpleDate::VerifyDateFormat(str)==FALSE)
{
sprintf(buff,"Invalid Date or Format");
pDX->m_pDlgWnd->MessageBox(buff,"",MB_OK);
pDX->Fail();
}
}
else
{
ptr->LimitText(nLen);
pDX->m_pDlgWnd->GetDlgItem(nID)->SetWindowText(str);
}
}
//--------------------------------------------------------------------
// Function name : DDX_SimpleDate
// Description : This is not real efficient but works. Makes extensive use
// of static class members so speed is not the greatest
// Return type : void
// Argument : CDataExchange *pDX
// Argument : int nID
// Argument : CString& str
//--------------------------------------------------------------------
void DDX_SimpleDate(CDataExchange *pDX,int nID,CString& str)
{
char buff[50];
pDX->PrepareEditCtrl(nID);
if(pDX->m_bSaveAndValidate)
{
pDX->m_pDlgWnd->GetDlgItem(nID)->GetWindowText(str);
if(CSimpleDate::FixDateFormat(str))
pDX->m_pDlgWnd->GetDlgItem(nID)->SetWindowText(str);
if(CSimpleDate::VerifyDateFormat(str)==FALSE)
{
sprintf(buff,"Invalid Date or Format");
pDX->m_pDlgWnd->MessageBox(buff,"",MB_OK);
pDX->Fail();
}
else
pDX->m_pDlgWnd->GetDlgItem(nID)->GetWindowText(str);
}
else
{
pDX->m_pDlgWnd->GetDlgItem(nID)->SetWindowText(str);
}
}
//--------------------------------------------------------------------
// Function name : DDX_SimpleDate
// Description : This is not real efficient but works. Makes extensive use
// of static class members so speed is not the greatest
// Return type : void
// Argument : CDataExchange *pDX
// Argument : int nID
// Argument : long& jdate
//--------------------------------------------------------------------
void DDX_SimpleDate(CDataExchange *pDX,int nID,long& jdate)
{
char buff[50];
pDX->PrepareEditCtrl(nID);
if(jdate < 0) // just a precaution. This way we only check for a 0 value for init
jdate=0;
if(pDX->m_bSaveAndValidate)
{
pDX->m_pDlgWnd->GetDlgItem(nID)->GetWindowText(buff,50);
if(jdate > 0 && strlen(buff)==0) // program changed value not user input
{
CSimpleDate Date(jdate);
strcpy(buff,(LPCSTR)Date);
pDX->m_pDlgWnd->GetDlgItem(nID)->SetWindowText(buff);
}
if(CSimpleDate::FixDateFormat(buff))
pDX->m_pDlgWnd->GetDlgItem(nID)->SetWindowText(buff);
if(CSimpleDate::VerifyDateFormat(buff)==FALSE)
{
sprintf(buff,"Invalid Date or Format");
pDX->m_pDlgWnd->MessageBox(buff,"",MB_OK);
pDX->Fail();
}
CSimpleDate Date(buff);
jdate=(long)Date;
}
else
{
if(jdate==0) // had to be init value
strcpy(buff,"");
else
{
CSimpleDate Date(jdate);
strcpy(buff,(LPCSTR)Date);
}
pDX->m_pDlgWnd->GetDlgItem(nID)->SetWindowText(buff);
}
}
void CSimpleDate::SetDate( int month,int day,int year,int FormatType)
{
m_Format=FormatType;
m_JulianDate=ConvertToJulian( month, day, year);
//// Added initialization /////
m_Year=year;
m_Month=month;
m_Day=day;
//////////////////////////////
SetTime();
}
Reference in New Issue View Git Blame Copy Permalink