calendarconvert.cpp

mytoolpad 源码

#include "stdafx.h"
#include "CalendarConvert.h"


/***************    本类调用规则    ******************
******************************************************

1.	使用下面的函数来制作日历结构
	MakeCalendar(CALENDAR *m_cal,int y,int m,int d);//填充日期结构的年月日

2.	使用本函数来检验日历是否合法
	BOOL GongDataIsValid(CALENDAR m_date);		   //判断公历日期是否在界内
	BOOL NongDataIsValid(CALENDAR m_date);		   //判断农历日期是否在界内

3.   将合法日历进行公农历相互转换
	CALENDAR ConvertToGongLi(CALENDAR m_nongli);	   //将农历日期转化为公历日期
	CALENDAR ConvertToNongLi(CALENDAR m_gongli);	   //将公历日期转化为农历日期

4.	其他辅助函数：获取星期；获取公历日期之间天数；获取农历日期之间天数
	int  GetWeekInfo(CALENDAR m_gongli);		   //根据公历日期计算星期
	int  GetGongDays(CALENDAR m_start,CALENDAR m_end);//获取公历两个日期之间的天数
	int  GetNongDays(CALENDAR m_start,CALENDAR m_end);//获取农历两个日期之间的天数
	int  CompareTwoDate(CALENDAR m_fir,CALENDAR m_sec);//比较两个日期的大小
	CALENDAR GetCurGongDate();					//将当前公历日期合成为结构
	CString GetGanZhi(int m_nongyear);				//获取农历年份的干支名称

******************************************************
***************    调用规则结束    ******************/





CCalendarConvert::CCalendarConvert()
{
	m_minyear=1950;
	m_maxyear=2050;

	unsigned char data[100][3]=
	{
		{0x2f,0x6c,0xa0},{0x24,0xb5,0x50},{0xda,0x53,0x55},{0x2c,0x4d,0xa0},
		{0x21,0xa5,0xb0},{0x57,0x45,0x73},{0xaa,0x52,0xb0},{0x1e,0xa9,0xa8},
		{0x30,0xe9,0x50},{0x26,0x6a,0xa0},{0x9b,0xae,0xa6},{0x2d,0xab,0x50},
		{0x23,0x4b,0x60},{0x18,0xaa,0xe4},{0xab,0xa5,0x70},{0x20,0x52,0x60},
		{0x14,0xf2,0x63},{0x27,0xd9,0x50},{0x9d,0x5b,0x57},{0x2f,0x56,0xa0},

		{0x24,0x96,0xd0},{0x1a,0x4d,0xd5},{0xad,0x4a,0xd0},{0x21,0xa4,0xd0},
		{0x16,0xd4,0xd4},{0x29,0xd2,0x50},{0x9e,0xd5,0x58},{0x30,0xb5,0x40},
		{0x25,0xb6,0xa0},{0x5b,0x95,0xa6},{0xae,0x95,0xb0},{0x23,0x49,0xb0},
		{0x18,0xa9,0x74},{0x2b,0xa4,0xb0},{0xa0,0xb2,0x7a},{0x32,0x6a,0x50},
		{0x27,0x6d,0x40},{0x1c,0xaf,0x46},{0xaf,0xab,0x60},{0x24,0x95,0x70},

		{0x1a,0x4a,0xf5},{0x2d,0x49,0x70},{0xa2,0x64,0xb0},{0x16,0x74,0xa3},
		{0x28,0xea,0x50},{0x1e,0x6b,0x58},{0xb1,0x5a,0xc0},{0x25,0xab,0x60},
		{0x1b,0x96,0xd5},{0x2e,0x92,0xe0},{0xa3,0xc9,0x60},{0x17,0xd9,0x54},
		{0x2a,0xd4,0xa0},{0x1f,0xda,0x50},{0x95,0x75,0x52},{0x27,0x56,0xa0},
		{0x1c,0xab,0xb7},{0x30,0x25,0xd0},{0xa5,0x92,0xd0},{0x19,0xca,0xb5},

		{0x2c,0xa9,0x50},{0x21,0xb4,0xa0},{0x96,0xba,0xa4},{0x28,0xad,0x50},
		{0x1e,0x55,0xd9},{0x31,0x4b,0xa0},{0xa6,0xa5,0xb0},{0x5b,0x51,0x76},
		{0x2e,0x52,0xb0},{0x23,0xa9,0x30},{0x98,0x79,0x54},{0x2a,0x6a,0xa0},
		{0x1f,0xad,0x50},{0x15,0x5b,0x52},{0xa8,0x4b,0x60},{0x1c,0xa6,0xe6},
		{0x2f,0xa4,0xe0},{0x24,0xd2,0x60},{0x99,0xea,0x65},{0x2b,0xd5,0x30},

		{0x21,0x5a,0xa0},{0x16,0x76,0xa3},{0xa9,0x96,0xd0},{0x1e,0x4a,0xfb},
		{0x31,0x4a,0xd0},{0x26,0xa4,0xd0},{0xdb,0xd0,0xb6},{0x2d,0xd2,0x50},
		{0x22,0xd5,0x20},{0x17,0xdd,0x45},{0xaa,0xb5,0xa0},{0x1f,0x56,0xd0},
		{0x15,0x55,0xb2},{0x28,0x49,0xb0},{0x9d,0xa5,0x77},{0x2f,0xa4,0xb0},
		{0x24,0xaa,0x50},{0x59,0xb2,0x55},{0xac,0x6d,0x20},{0x20,0xad,0xa0}
	};
	CalendarData=new char*[100];
	for(int i=0;i<100;i++)
	{
		CalendarData[i]=new char[3];
		for(int j=0;j<3;j++)
			CalendarData[i][j]=data[i][j];
	}
}
CCalendarConvert::~CCalendarConvert()
{
	for(int i=0;i<100;i++)
		delete[] CalendarData[i];
	delete[] CalendarData;
}

//判断公历日期是否在界内
BOOL CCalendarConvert::GongDataIsValid(CALENDAR m_date)
{
	if(m_date.year>1950 && m_date.year<2050)
		return TRUE;
	else
	{
		if(m_date.year==1950)
		{
			if(m_date.month>2)
				return TRUE;
			else
			{
				if(m_date.month==2)
				{
					if(m_date.day>16)
						return TRUE;
				}
			}
		}
	}
	return FALSE;
}

//判断农历日期是否在界内
BOOL CCalendarConvert::NongDataIsValid(CALENDAR m_date)
{
	if(m_date.year>1949 && m_date.year<2049)
		return TRUE;
	else
	{
		if(m_date.year==2049)
		{
			if(m_date.month<12)
				return TRUE;
			else
			{
				if(m_date.month==12)
				{
					if(m_date.day<8)
						return TRUE;
				}
			}
		}
	}
	return FALSE;
}

//将农历日期转化为公历日期
CALENDAR CCalendarConvert::ConvertToGongLi(CALENDAR m_nongli)
{
	int days=DaysFromSpringDay(m_nongli); //计算农历当前日期到春节的天数
	days+=GetDaysFromStart(m_nongli.year);//加上春节到元旦的天数(以元旦为基准)
	int year=m_nongli.year;			   //默认年份相同
	int alldays=GetGongYearDays(m_nongli.year);//计算农历年的公历天数
	if(days>alldays)				   //公历年份超前
	{
		days-=alldays;
		year++;
	}
	CALENDAR result=CalGongDate(year,days);//根据以元旦为基准的天数来确定日期
	result.week=GetWeekInfo(result);
	return result;
}

//将公历日期转化为农历日期
CALENDAR CCalendarConvert::ConvertToNongLi(CALENDAR m_gongli)
{
	int days=DaysFromNewYear(m_gongli);    //公历日期到元旦的天数
	int alldays=GetDaysFromStart(m_gongli.year);//春节到元旦的天数

	int year=m_gongli.year;			    //默认农历年与公历年相同
	if(days<=alldays)				    //农历年滞后
	{
		year--;
		days+=GetGongYearDays(year);	    //再加上公历年的整年天数
	}
	days-=GetDaysFromStart(year);	         //减去春节到元旦天数得到以春节为基准的天数
	CALENDAR result=CalNongDate(year,days);//根据农历年和以春节为基准的天数计算公历日期
	result.week=GetWeekInfo(m_gongli);
	return result;
}

//根据公历日期计算星期
int  CCalendarConvert::GetWeekInfo(CALENDAR m_gongli)
{
	int left=0;
	for(int i=m_minyear;i<m_gongli.year;i++)//1950年元旦为星期六
	{
		left+=YearIsRunNian(i)?2:1;
		left%=7;
	}
	for(i=1;i<m_gongli.month;i++)
	{
		left+=GetGongMonthDays(m_gongli.year,i);
		left%=7;
	}
	left+=(m_gongli.day+6);
	left%=7;
	return left;
}

//当前公历日期后N天的公历日期
CALENDAR CCalendarConvert::GetDateAfterDays(CALENDAR m_first,int m_days)
{
	int m_firstdays=DaysFromNewYear(m_first)+m_days;
	return CalGongDate(m_first.year,m_firstdays);
}

//根据给定年份并且以元旦为基准的天数来确定公历日期
CALENDAR CCalendarConvert::CalGongDate(int year,int days)
{
	CALENDAR result;
	int caldays=0;
	result.year=year;

	for(int i=1;i<13;i++)
	{
		caldays+=GetGongMonthDays(year,i);
		if(caldays>=days)
		{
			caldays-=GetGongMonthDays(year,i);
			result.month=i;
			result.day=days-caldays;
			break;
		}
	}
	return result;
}

//根据农历年和以春节为基准的天数计算公历日期
CALENDAR CCalendarConvert::CalNongDate(int year,int days)
{
	CALENDAR result;
	int caldays=0;
	result.year=year;
	result.isrunyue=FALSE;

	for(int i=1;i<13;i++)
	{
		caldays+=GetNongMonthDays(year,i);		//计算春节以来月天数累加和
		if(caldays>=days)					//天数超过总天数，月份已到
		{
			caldays-=GetNongMonthDays(year,i);	//减去多算的一个月
			result.month=i;
			result.day=days-caldays;
			result.isrunyue=FALSE;
			break;
		}
		else
		{
			if(GetNongRunYue(year)==i)         //考虑闰月
			{
				caldays+=GetNongRunYueDays(year);
				if(caldays>=days)
				{
					caldays-=GetNongRunYueDays(year);
					result.month=i;
					result.day=days-caldays;
					result.isrunyue=TRUE;
					break;
				}
			}
		}
	}
	return result;
}

//填充日期结构的年月日
void CCalendarConvert::MakeCalendar(CALENDAR *m_cal,int y,int m,int d)
{
	m_cal->year=y;
	m_cal->month=m;
	m_cal->day=d;
}

//获取公历月的天数
int  CCalendarConvert::GetGongMonthDays(int year,int month)
{
	int ret=30;
	if(month==2)
		ret=YearIsRunNian(year)?29:28;
	else
		ret=GongMonthIsLarge(month)?31:30;
	return ret;
}

//获取农历月的天数
int  CCalendarConvert::GetNongMonthDays(int year,int month)
{
	int days=NongMonthIsLarge(year,month)?30:29;
	return days;
}

//获取农历月的天数
int  CCalendarConvert::GetNongMonthDays(int year,int month,BOOL m_run)
{
	int days=0;
	if(m_run)
		days=GetNongRunYueDays(year);
	else
		days=GetNongMonthDays(year,month);
	return days;
}

//获取公历年的天数
int  CCalendarConvert::GetGongYearDays(int year)
{
	int days=YearIsRunNian(year)?366:365;
	return days;
}

//获取农历年的天数
int  CCalendarConvert::GetNongYearDays(int year)
{
	int days=0;
	for(int i=1;i<13;i++)
		days+=GetNongMonthDays(year,i);
	days+=GetNongRunYueDays(year);
	return days;
}

//获取农历年闰月天数
int  CCalendarConvert::GetNongRunYueDays(int year)
{
	if(GetNongRunYue(year)==0)
		return 0;
	int days=RunYueIsLarge(year)?30:29;
	return days;
}

//获取农历闰月
int  CCalendarConvert::GetNongRunYue(int year)
{
	return (CalendarData[year-m_minyear][2] & 0x0f);
}

//公历日期到元旦的天数
int  CCalendarConvert::DaysFromNewYear(CALENDAR m_day)
{
	int days=0;
	for(int i=1;i<m_day.month;i++)
		days+=GetGongMonthDays(m_day.year,i);
	days+=m_day.day;
	return days;
}

//农历日期到春节的天数
int  CCalendarConvert::DaysFromSpringDay(CALENDAR m_day)
{
	int days=0;
	int month=GetNongRunYue(m_day.year);//处理闰月
	if(month<m_day.month)			 //闰月小于日期月份
		days+=GetNongRunYueDays(m_day.year);
	else
	{
		if((month==m_day.month) && m_day.isrunyue)//日期月份是闰月
			days+=GetNongRunYueDays(m_day.year);
	}
	for(int i=1;i<m_day.month;i++)
		days+=GetNongMonthDays(m_day.year,i);
	days+=m_day.day;
	return days;
}

//公历年是否闰年
BOOL CCalendarConvert::YearIsRunNian(int year)
{
	return (CalendarData[year-m_minyear][0] & 0x80);
}


//判断闰月是否为大月
BOOL CCalendarConvert::RunYueIsLarge(int year)
{
	return (CalendarData[year-m_minyear][0]&0x40);
}


//计算2的N次方
int  CCalendarConvert::Cal2N(int n)
{
	int ret=1;
	for(int i=0;i<n;i++)
		ret*=2;
	return ret;
}

//判断农历年的月份是否为大月
BOOL CCalendarConvert::NongMonthIsLarge(int year,int month)
{
	BOOL ret=FALSE;
	if(month<9)
	{
		if(CalendarData[year-m_minyear][1] & Cal2N(8-month))
			ret=TRUE;
	}
	else
	{
		unsigned char ch=Cal2N(12-month);
		ch<<=4;
		if(CalendarData[year-m_minyear][2] & ch)
			ret=TRUE;
	}
	return ret;
}

//判断公历月份是否为大月(二月除外)
BOOL CCalendarConvert::GongMonthIsLarge(int month)
{
	BOOL ret=FALSE;
	if(month<8)
	{
		if(month%2)
			ret=TRUE;
	}
	else
	{
		if(!(month%2))
			ret=TRUE;
	}
	return ret;
}

//农历大年初一到元旦的天数
int  CCalendarConvert::GetDaysFromStart(int year)
{
	return (CalendarData[year-m_minyear][0]&0x3f);
}


/*********暂时没有用到的成员函数***********/
//判断是否是闰月
BOOL CCalendarConvert::MonthIsRunYue(int year,int month)
{
	return (month==GetNongRunYue(year));
}

//获取公历两个日期之间的天数
int  CCalendarConvert::GetGongDays(CALENDAR m_start,CALENDAR m_end)
{
	int days=0;
	for(int i=m_start.year;i<m_end.year;i++)
		days+=GetGongYearDays(i);
	days-=DaysFromNewYear(m_start);
	days+=DaysFromNewYear(m_end);
	return days;
}

//获取农历两个日期之间的天数
int  CCalendarConvert::GetNongDays(CALENDAR m_start,CALENDAR m_end)
{
	int days=0;
	for(int i=m_start.year;i<m_end.year;i++)
		days+=GetNongYearDays(i);
	days-=DaysFromSpringDay(m_start);
	days+=DaysFromSpringDay(m_end);
	return days;
}

//将当前公历日期合成为结构
CALENDAR CCalendarConvert::GetCurGongDate()
{
	CALENDAR m_cal;
	SYSTEMTIME m_time;
	GetLocalTime(&m_time);
	m_cal.year=(int)m_time.wYear;
	m_cal.month=(int)m_time.wMonth;
	m_cal.day=(int)m_time.wDay;
	m_cal.week=(int)m_time.wDayOfWeek;
	return m_cal;
}

//比较两个日期的大小
int  CCalendarConvert::CompareTwoDate(CALENDAR m_fir,CALENDAR m_sec)
{
	int m_state=0;

	if(m_fir.year>m_sec.year)
		m_state=1;
	else
	{
		if(m_fir.year<m_sec.year)
			m_state=-1;
		else
		{
			if(m_fir.month>m_sec.month)
				m_state=1;
			else
			{
				if(m_fir.month<m_sec.month)
					m_state=-1;
				else
				{
					if(m_fir.day>m_sec.day)
						m_state=1;
					else
					{
						if(m_fir.day<m_sec.day)
							m_state=-1;
						else
							m_state=0;
					}
				}
			}
		}
	}

	return m_state;
}

//获取60年中的第N年的天干地支名称
CString CCalendarConvert::GetNNameIn60(int index)
{
	char ShengXiao[25]="鼠牛虎兔龙蛇马羊猴鸡狗猪";
	char TianGan[21]="甲乙丙丁戊己庚辛壬癸";
	char DiZhi[25]="子丑寅卯辰巳午未申酉戌亥";
	char buffer[20];
	memset(buffer,0,20);
	strcpy(buffer,"农历");
	
	int m_cur=0,m_this=0;
	int tian=0,di=0;
	for(int i=0;i<60;i++)
	{
		tian=i%10;
		di=i%12;
		if(m_this==index)
		{
			strncpy(&buffer[4],&TianGan[tian*2],2);
			strncpy(&buffer[6],&DiZhi[di*2],2);
			strcat(buffer,"年，");
			strncpy(&buffer[12],&ShengXiao[di*2],2);
			strcat(buffer,"年");
		}
		m_this++;
	}
	return CString(buffer);
}


//获取农历年份的干支名称
CString CCalendarConvert::GetGanZhi(int m_nongyear)
{	   
	int m_index=(m_nongyear-1924)%60;
	return GetNNameIn60(m_index);
}

//将农历年的月份注入组合框
void CCalendarConvert::NongMonthToList(int m_nongyear,CComboBox & m_list)
{
	m_list.ResetContent();
	int m_run=GetNongRunYue(m_nongyear);
	char m_buffer[12][7]={"一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"};
	if(m_run==0)
	{
		for(int i=0;i<12;i++)
			m_list.AddString(m_buffer[i]);
	}
	else	
	{
		for(int i=0;i<m_run;i++)
			m_list.AddString(m_buffer[i]);
		char m_name[10]="闰";
		strcat(m_name,m_buffer[i-1]);
		m_list.AddString(m_name);
		for(i=m_run;i<12;i++)
			m_list.AddString(m_buffer[i]);
	}
}