/********************************************************************
版权所有：	
文件版本： V1.00
文件名称： fmt.c
生成日期： 2007年04月26日
作    者：xxxxxx
使用范围：

功    能： 菜单内容格式分析
更新信息：
更新日志1：
修改者:
修改日期:
修改内容:
修改原因:
*********************************************************************/
#include <stdarg.h>  
#include  "head.h"
#ifdef LINUX_KERNEL_APP
#include <linux/inet.h>
#endif
MODIFY_DEF g_tModify;    /* 修改数据的结构*/

#ifdef LINUX_KERNEL_APP
int _in_aton_(char* str)
{
    int addr=0;
    unsigned char tmp[3],dat,i;
    char count;
    char* ptr=str;

    for(count=0,dat=0; count<4; count++)
    {
        memset(tmp,0,3);
        i=0;
        while((*ptr!='.')&&(i<3)&&(*ptr!='\0'))
        {
            tmp[i++]=*ptr-'0';
            ptr++;
        }
        if(i==1)
            dat=tmp[0];
        else if(i==2)
            dat=tmp[0]*10+tmp[1];
        else if(i==3)
            dat=tmp[0]*100+tmp[1]*10+tmp[2];
        addr|=dat<<(8*(4-count-1));
        ptr++;
    }
    return addr;
}
#endif

static void itoa1(short int value,char *pbuf)
{
	sprintf(pbuf,"%i",value);
}


/**************************************************************************
函数名称：itoa
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：完成函数itoa的功能，将整数转为字符串
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/


static void itoa2(int value,char *pbuf)
{
	// %i 输出整数
	sprintf(pbuf,"%i",value);
}
/**************************************************************************
函数名称：ltoa
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：将长整数转为字符串
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/
#if 0
static void ltoa(long value,char *pbuf)
{
	sprintf(pbuf,"%ld",value);
	
}
#endif
/**************************************************************************
函数名称：itostr
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：将长整数按格式转换为字符串
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/

static void itostr(unsigned int value,char *pbuf,char basetype)
{
    switch(basetype)
	{
	case 8:
		sprintf(pbuf,"%o",value);
		break;
	case 10:
		sprintf(pbuf,"%u",value);
		break;
	case 16:
		sprintf(pbuf,"%x",value);
		break;
	case 17:
		sprintf(pbuf,"%X",value);
		break;
	default:
		strcpy(pbuf,"Format  error!");		
		break;
	}  	
}
/**************************************************************************
函数名称：stostr
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：将短整数按格式转换为字符串
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/

static void stostr(unsigned short value,char *pbuf,char basetype)
{
    switch(basetype)
	{
	case 8:
		sprintf(pbuf,"%o",value);
		break;
	case 10:
		sprintf(pbuf,"%u",value);
		break;
	case 16:
		sprintf(pbuf,"%x",value);
		break;
	case 17:
		sprintf(pbuf,"%X",value);
		break;
	default:
		strcpy(pbuf,"Format  error!");		/**/
		break;
	}  	
}
/**************************************************************************
函数名称：ltostr
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：将无符号长整数按格式转换为字符串
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/

#if 0
static void ltostr(uint32_t int value,char *pbuf,char basetype)
{
	switch(basetype)
	{
	case 10:
		sprintf(pbuf,"%lu",value);
		break;
	case 16:
		sprintf(pbuf,"%lx",value);
		break;
	case 17:
		sprintf(pbuf,"%lX",value);
		break;
	default:
		sprintf(pbuf,"%lu",value);
		break;
	}   
}
#endif
/**************************************************************************
函数名称：ftoa
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：将浮点数按格式转换为字符串
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/

static void ftoa(float value,char *pbuf,char basetype,char precison)
{
	basetype=basetype;
	switch(precison)
	{
	case 0:
		sprintf(pbuf,"%.0f",value);/*Right?*/
		break;
	case 1:
		sprintf(pbuf,"%.1f",value);
		break;
	case 2:
		sprintf(pbuf,"%.2f",value);
		break;
	case 3:
		sprintf(pbuf,"%.3f",value);
		break;
	case 4:
		sprintf(pbuf,"%.4f",value);
		break;
	default:
		sprintf(pbuf,"%.3f",value);
		break;
	}   	
}
/**************************************************************************
函数名称：atof1
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：将字符串转为浮点数
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/
float atof1(char *str)  // 将字符串转为浮点数
{
	float ff;
	char fstr[20];
	int dot,dignum,num,divn;
	dot=-1;
	num=0;
	dignum=0;
	for(;*str!='\0';str++)
	{
		if(*str=='-'||*str=='+')
		{
			fstr[num++]=*str;
			if(num>19)break;
		}
		else if(*str>='0'&&*str<='9')
		{
			fstr[num++]=*str;
			dignum++;
			if(num>19)break;
		}
		else if(*str=='.')// 小数点位置
		{
			dot=dignum;
		}
	}
	fstr[num]=0;
	ff=(float)atol(fstr);  // 取得没有小数点的数字
	if(dot==-1||dot==dignum)  // 没有小数点或小数点在最后面
	{
		return ff;
	}
	divn=1;
	dot=dignum-dot;
	for(;dot>0;dot--)
	{
		divn*=10;
	}
	return (ff/divn);	
}

/***************************************************************************
** 功能: 对一个浮点数值的字符串进行转换后处理，即给任何格式(f,e,E,g,G)的 **
**       不带小数点的浮点数字符串加上小数点                              **
** 入口: TempPtr是被处理浮点数字符串的指针                               **
**       Precision是被处理浮点数字符串的显示精度                         **
** 出口: 处理后浮点数字符串的指针是TempPtr                               **
***************************************************************************/

static void AddDotsFloat(char *TempPtr,unsigned char Precision)
{
	char Temp;
	
	if(Precision==0){
		for(;*TempPtr!='e'&&*TempPtr!='E'&&*TempPtr!='\0';TempPtr++){}
		Temp=*TempPtr;
		for(;*TempPtr!='\0';TempPtr++){}
		*(TempPtr+1)='\0';
		for(;*TempPtr!=Temp;TempPtr--)
			*TempPtr=*(TempPtr-1);
		*TempPtr='.';
	}
}

/***************************************************************************
** 功能: 将一个任何格式(f,e,E,g,G)的显示精度为零的带小数点的浮点数字符串 **
**       的小数点删除                                                    **
** 入口: TempPtr是被处理浮点数字符串的指针                               **
** 出口: 处理后浮点数字符串的指针是TempPtr                               **
***************************************************************************/

static void DelDotsFloat(char *TempPtr)
{
	for(;*TempPtr!='e'&&*TempPtr!='E'&&*TempPtr!='\0';TempPtr++){}
	TempPtr--;
	if(*TempPtr=='.')
	{
		for(;*TempPtr!='\0';TempPtr++)
			*TempPtr=*(TempPtr+1);
		*TempPtr='\0';
	}
}

/***************************************************************************
**  功能: 将与带符号整数和浮点数相对应的具有缺省格式的字符串转变成给定格 **
**        式的字符串                                                     **
**  入口: Flags是标志字符序列指针                                        **
**        Width是输出字符串的最小宽度                                    **
**        TempStr是具有缺省格式的字符串的指针                            **
**  出口: 返回输出字符串的长度                                           ** 
**        输出字符串在TempStr指向的字符数组中                            **
***************************************************************************/

static void   SignedFormatOut(char *Flags,unsigned char Width,char *TempStr)
{
	char *TempPtr;
	char NFlags;
	int i;
	int ii;
	i=0;
	
	/*处理浮点数的小数点(在浮点数没有小数的时候)*/
	TempPtr=Flags;
	for(;*TempPtr!='#'&&*TempPtr!='\0';TempPtr++){}
	if(*TempPtr=='\0')
		DelDotsFloat(TempStr);
	
	/*预处理数值符号*/
	if(*TempStr=='-')
	{
		TempPtr=TempStr;
		for(ii=0;*TempPtr!='\0';TempPtr++,ii++)
			*TempPtr=*(TempPtr+1);
		*TempPtr='\0';
		ii--;
		NFlags=1;
	}
	else
	{
		TempPtr=TempStr;
		for(ii=0;*TempPtr!='\0';TempPtr++,ii++){}
		NFlags=0;
	}
	/*检查标志字符序列中是否有'+'*/
	TempPtr=Flags;
	for(;*TempPtr!='+'&&*TempPtr!='\0';TempPtr++){}
	if(*TempPtr=='+')
	{
		i=(int)Width-ii-1;
		if(i>0)
		{
			/*检查标志字符序列中是否有'*'*/
			TempPtr=Flags;
			for(;*TempPtr!='*'&&*TempPtr!='\0';TempPtr++){}
			if(*TempPtr=='*')
			{
				/*在临时字符串中写'0'*/
				TempPtr=TempStr;
				for(;*TempPtr!='\0';TempPtr++){}
				for(ii++;ii>0;ii--,TempPtr--)
					*(TempPtr+i)=*TempPtr;
				TempPtr++;
				for(ii=i;ii>0;ii--)
					*TempPtr++='0';
				/*在临时字符串中写符号标志*/
				TempPtr=TempStr;
				for(ii=0;*TempPtr!='\0';TempPtr++,ii++){}
				for(ii++;ii>0;ii--,TempPtr--)
					*(TempPtr+1)=*TempPtr;
				TempPtr++;
				if(NFlags)
					*TempPtr='-';
				else
					*TempPtr=' ';
			}
			else
			{
				/*在临时字符串中写符号标志*/
				TempPtr=TempStr;
				for(ii=0;*TempPtr!='\0';TempPtr++,ii++){}
				for(ii++;ii>0;ii--,TempPtr--)
					*(TempPtr+1)=*TempPtr;
				TempPtr++;
				if(NFlags)
					*TempPtr='-';
				else
					*TempPtr=' ';
				/*检查标志字符序列中是否有'-'*/
				TempPtr=Flags;
				for(;*TempPtr!='-'&&*TempPtr!='\0';TempPtr++){}
				if(*TempPtr=='-')
				{
					/*如果是左对齐，在临时字符串右端写' '*/
					TempPtr=TempStr;
					for(;*TempPtr!='\0';TempPtr++){}
					for(ii=i;ii>0;ii--)
						*TempPtr++=' ';
					*TempPtr='\0';
				}
				else
				{
					/*在临时字符串左端写' '*/
					TempPtr=TempStr;
					for(ii=0;*TempPtr!='\0';TempPtr++,ii++){}
					for(ii++;ii>0;ii--,TempPtr--)
						*(TempPtr+i)=*TempPtr;
					TempPtr++;
					for(ii=i;ii>0;ii--)
						*TempPtr++=' ';
				}
			}
		}
		else
		{
			/*在临时字符串中写符号标志*/
			TempPtr=TempStr;
			for(ii=0;*TempPtr!='\0';TempPtr++,ii++){}
			for(ii++;ii>0;ii--,TempPtr--)
				*(TempPtr+1)=*TempPtr;
			TempPtr++;
			if(NFlags)
				*TempPtr='-';
			else
				*TempPtr=' ';
		}
		i='+';
	}
	if(i!='+')
	{
		if(NFlags)
		{
			i=(int)Width-ii-1;
			if(i>0)
			{
				/*检查标志字符序列中是否有'*'*/
				TempPtr=Flags;
				for(;*TempPtr!='*'&&*TempPtr!='\0';TempPtr++){}
				if(*TempPtr=='*')
				{
					/*在临时字符串中写'-'和'0'*/
					TempPtr=TempStr;
					for(;*TempPtr!='\0';TempPtr++){}
					for(ii++;ii>0;ii--,TempPtr--)
						*(TempPtr+i+1)=*TempPtr;
					TempPtr++;
					*TempPtr++='-';
					for(ii=i;ii>0;ii--)
						*TempPtr++='0';
				}
				else
				{
					/*在临时字符串中填' '*/
					/*在临时字符串中写'-'*/
					TempPtr=TempStr;
					for(;*TempPtr!='\0';TempPtr++){}
					for(ii++;ii>0;ii--,TempPtr--)
						*(TempPtr+1)=*TempPtr;
					TempPtr++;
					*TempPtr='-';
					/*判断对齐方式*/
					TempPtr=Flags;
					for(;*TempPtr!='-'&&*TempPtr!='\0';TempPtr++){}
					if(*TempPtr=='-')
					{
						/*如果是左对齐，在临时字符串右端写' '*/
						TempPtr=TempStr;
						for(;*TempPtr!='\0';TempPtr++){}
						for(ii=i;ii>0;ii--)
							*TempPtr++=' ';
						*TempPtr='\0';
					}
					else
					{
						/*在临时字符串左端写' '*/
						TempPtr=TempStr;
						for(ii=0;*TempPtr!='\0';TempPtr++,ii++){}
						for(ii++;ii>0;ii--,TempPtr--)
							*(TempPtr+i)=*TempPtr;
						TempPtr++;
						for(ii=i;ii>0;ii--)
							*TempPtr++=' ';
					}
				}
			}
			else
			{
				/*在临时字符串中写'-'*/
				TempPtr=TempStr;
				for(;*TempPtr!='\0';TempPtr++){}
				for(ii++;ii>0;ii--,TempPtr--)
					*(TempPtr+1)=*TempPtr;
				TempPtr++;
				*TempPtr='-';
			}
		}
		else
		{
			i=(int)Width-ii;
			if(i>0)
			{
				/*检查标志字符序列中是否有'*'*/
				TempPtr=Flags;
				for(;*TempPtr!='*'&&*TempPtr!='\0';TempPtr++){}
				if(*TempPtr=='*')
				{
					/*在临时字符串中写'0'*/
					TempPtr=TempStr;
					for(;*TempPtr!='\0';TempPtr++){}
					for(ii++;ii>0;ii--,TempPtr--)
						*(TempPtr+i)=*TempPtr;
					TempPtr++;
					for(ii=i;ii>0;ii--)
						*TempPtr++='0';
				}
				else
				{
					/*在临时字符串中填' '*/
					/*判断对齐方式*/
					TempPtr=Flags;
					for(;*TempPtr!='-'&&*TempPtr!='\0';TempPtr++){}
					if(*TempPtr=='-')
					{
						/*如果是左对齐，在临时字符串右端写' '*/
						TempPtr=TempStr;
						for(;*TempPtr!='\0';TempPtr++){}
						for(ii=i;ii>0;ii--)
							*TempPtr++=' ';
						*TempPtr='\0';
					}
					else
					{
						/*在临时字符串左端写' '*/
						TempPtr=TempStr;
						for(ii=0;*TempPtr!='\0';TempPtr++,ii++){}
						for(ii++;ii>0;ii--,TempPtr--)
							*(TempPtr+i)=*TempPtr;
						TempPtr++;
						for(ii=i;ii>0;ii--)
							*TempPtr++=' ';
					}
				}
			}
		}
	}
	
	/*增加判断超出范围的的处理方法*/
	if(Width==0) /*没有长度限制	*/
	{
		TempPtr=TempStr;
		for(ii=0;*TempPtr!='\0';TempPtr++,ii++){}
	}
	else       /*有长度限制*/
	{
		TempPtr=TempStr;
		TempPtr[Width]='\0'; /*截断后面的显示*/
		i=Width;
	}
}


/***************************************************************************
**  功能: 将与无符号整数相对应的具有缺省格式的字符串转变成给定格式的     **
**        字符串                                                         **
**  入口: Flags是标志字符序列指针                                        **
**        Width是输出字符串的最小宽度                                    **
**        TempStr是具有缺省格式的字符串的指针                            **
**        CountBase数制计数基值                                          **
**  出口: 返回输出字符串的长度                                           **
**        输出字符串在TempStr指向的字符数组中                            **
***************************************************************************/

static void   UnsignedFormatOut(char *Flags,unsigned char Width,char *TempStr,unsigned char CountBase)
{
	char *TempPtr;
	int i;
	int ii;
	i=0;
	TempPtr=TempStr;
	for(ii=0;*TempPtr!='\0';TempPtr++,ii++){}
	/*检查标志字符序列中是否有'#'*/
	TempPtr=Flags;
	for(;*TempPtr!='#'&&*TempPtr!='\0';TempPtr++){}
	#if 0
	if(*TempPtr=='#')
	{
		i=(int)Width-ii-2;
		if(i>0)
		{
			/*检查标志字符序列中是否有'*'*/
			TempPtr=Flags;
			for(;*TempPtr!='*'&&*TempPtr!='\0';TempPtr++){}
			if(*TempPtr=='*')
			{
				/*在临时字符串中写'0'*/
				TempPtr=TempStr;
				for(;*TempPtr!='\0';TempPtr++){}
				for(ii++;ii>0;ii--,TempPtr--)
					*(TempPtr+i)=*TempPtr;
				TempPtr++;
				for(ii=i;ii>0;ii--)
					*TempPtr++='0';
				/*在临时字符串中写进位计数制头标志*/
				TempPtr=TempStr;
				for(ii=0;*TempPtr!='\0';TempPtr++,ii++){}
				if(CountBase==8)
				{
					/*在临时字符串中写'0o'*/
					for(ii++;ii>0;ii--,TempPtr--)
						*(TempPtr+2)=*TempPtr;
					TempPtr++;
					*TempPtr++='0';
					*TempPtr='o';
				}
				if(CountBase==16)
				{
					/*在临时字符串中写'0o'*/
					for(ii++;ii>0;ii--,TempPtr--)
						*(TempPtr+2)=*TempPtr;
					TempPtr++;
					*TempPtr++='0';
					*TempPtr='x';
				}
			}
			else
			{
				/*在临时字符串中写进位计数制头标志*/
				TempPtr=TempStr;
				for(ii=0;*TempPtr!='\0';TempPtr++,ii++){}
				if(CountBase==8)
				{
					/*在临时字符串中写'0o'*/
					for(ii++;ii>0;ii--,TempPtr--)
						*(TempPtr+2)=*TempPtr;
					TempPtr++;
					*TempPtr++='0';
					*TempPtr='o';
				}
				if(CountBase==16)
				{
					/*在临时字符串中写'0o'*/
					for(ii++;ii>0;ii--,TempPtr--)
						*(TempPtr+2)=*TempPtr;
					TempPtr++;
					*TempPtr++='0';
					*TempPtr='x';
				}
				/*检查标志字符序列中是否有'-'*/
				TempPtr=Flags;
				for(;*TempPtr!='-'&&*TempPtr!='\0';TempPtr++){}
				if(*TempPtr=='-')
				{
					/*如果是左对齐，在临时字符串右端写' '*/
					TempPtr=TempStr;
					for(;*TempPtr!='\0';TempPtr++){}
					for(ii=i;ii>0;ii--)
						*TempPtr++=' ';
					*TempPtr='\0';
				}
				else
				{
					/*在临时字符串中写'0'*/
					TempPtr=TempStr;
					for(ii=0;*TempPtr!='\0';TempPtr++,ii++){}
					for(ii++;ii>0;ii--,TempPtr--)
						*(TempPtr+i)=*TempPtr;
					TempPtr++;
					for(ii=i;ii>0;ii--)
						*TempPtr++=' ';
				}
			}
		}
		else
		{
			/*在临时字符串中写进位计数制头标志*/
			TempPtr=TempStr;
			for(ii=0;*TempPtr!='\0';TempPtr++,ii++){}
			if(CountBase==8)
			{
				/*在临时字符串中写'0o'*/
				for(ii++;ii>0;ii--,TempPtr--)
					*(TempPtr+2)=*TempPtr;
				TempPtr++;
				*TempPtr++='0';
				*TempPtr='o';
			}
			if(CountBase==16)
			{
				/*在临时字符串中写'0o'*/
				for(ii++;ii>0;ii--,TempPtr--)
					*(TempPtr+2)=*TempPtr;
				TempPtr++;
				*TempPtr++='0';
				*TempPtr='x';
			}
		}
		i='#';
	}
	#endif
	if(i!='#')
	{
		i=(int)Width-ii;
		if(i>0)
		{
			/*检查标志字符序列中是否有'*'*/
			TempPtr=Flags;
			for(;*TempPtr!='*'&&*TempPtr!='\0';TempPtr++){}
			if(*TempPtr=='*')
			{
				/*在临时字符串中写'0'*/
				TempPtr=TempStr;
				for(;*TempPtr!='\0';TempPtr++){}
				for(ii++;ii>0;ii--,TempPtr--)
					*(TempPtr+i)=*TempPtr;
				TempPtr++;
				for(ii=i;ii>0;ii--)
					*TempPtr++='0';
			}
			else
			{
				/*检查标志字符序列中是否有'-'*/
				TempPtr=Flags;
				for(;*TempPtr!='-'&&*TempPtr!='\0';TempPtr++){}
				if(*TempPtr=='-')
				{
					/*如果是左对齐，在临时字符串右端写' '*/
					TempPtr=TempStr;
					for(;*TempPtr!='\0';TempPtr++){}
					for(ii=i;ii>0;ii--)
						*TempPtr++=' ';
					*TempPtr='\0';
				}
				else
				{
					/*在临时字符串中写'0'*/
					TempPtr=TempStr;
					for(ii=0;*TempPtr!='\0';TempPtr++,ii++){}
					for(ii++;ii>0;ii--,TempPtr--)
						*(TempPtr+i)=*TempPtr;
					TempPtr++;
					for(ii=i;ii>0;ii--)
						*TempPtr++=' ';
				}
			}
		}
	}
	if(Width==0) /*没有长度限制	*/
	{
		TempPtr=TempStr;
		for(ii=0;*TempPtr!='\0';TempPtr++,ii++){}
	}
	else       /*有长度限制*/
	{
		TempPtr=TempStr;
		TempPtr[Width]='\0'; /*截断后面的显示*/
		i=Width;
	}
}


int  fmt_findchardot(u8 *buf,u8 *str,BYTE dot)
{
	u8 *ps;	
	int i,lenth=0;
	ps=strchr(buf,dot);
	if(ps)  // 存在','
	{
		lenth=ps-buf;
		for(i=0;i<lenth;i++)
		{
			str[i]=*buf++;
		}
		str[i]='\0';	
	}
	return lenth;
}

/***************************************************************************
**  功能: 将从参数表中取出的指针，并将它所指向的值转变成给定格式的字符串 **
**  入口: ap是参数表的参数指针，注意: 参数表中的参数均应为void *         **
**        FmtStr是输出字符串格式描述串的指针                             **
**        Str是输出字符串的指针                                          **
**  出口: 返回输出字符串的长度                                           **
**        输出字符串在Str指向的字符数组中                                **
***************************************************************************/
unsigned char ValuePtrToStr(char *Str,char *FmtStr,va_list  ap)
{
	char *TempPtr;
	char Temp[4];
	char TempStr[64];
	//xbtong char i;
	int i;
	
	/************************定义数据格式串的数据结构****************************/
	
	char Flags[5];		// 存放格式的标志	
	u8 Width=0;			// 存放格式的宽度
	u8 Precision=6;		// 存放格式的精度
	char Type[3];		// 存放格式的类型
	
	/*****************************分解数据格式串*********************************/
	// 格式字符串:%[标志][输入数据宽度][.精度][长度]类型
	/*分解出%号*/
	FmtStr++;	/*=%*/
	TempPtr=(char *)FmtStr;
	
	/*分解出标志字符序列*/
	for(; *TempPtr<'0'; TempPtr++){} /*+ - * # .*/
	for(i=0; FmtStr<TempPtr; Flags[i]=*FmtStr++,i++){}/*copy到Flags[]中*/
	Flags[i]='\0';
	
	/*分解出数据的显示宽度*/
	// 剔除0~9以外的内容
	for(; (*TempPtr<='9')&&(*TempPtr>='0'); TempPtr++){}/*0~9 change by sunxi old:(*TempPtr<':'&&*TempPtr>'/')*/
	for(i=0; FmtStr<TempPtr; Temp[i]=*FmtStr++,i++){}	/*copy到Temp[]中*/
	Temp[i]='\0';
	Width=(unsigned char)atoi(Temp);/*宽度*/
	
	/*分解出数据的显示精度*/
	if(*TempPtr=='.')
	{
		FmtStr++;
		TempPtr++;
		for(;*TempPtr<='9'&&*TempPtr>='0';TempPtr++){}/*0~9 change by sunxi */
		for(i=0;FmtStr<TempPtr;Temp[i]=*FmtStr++,i++){}
		Temp[i]='\0';
		Precision=(unsigned char)atoi(Temp);
	}
	
	/*分解出数据的类型*/
	for(;*TempPtr!='\0';TempPtr++){}
	for(i=0;FmtStr<TempPtr;Type[i]=*FmtStr++,i++){}
	
	/***************按类型将数值转换成给定格式的字符串****************************/
	switch(Type[0])
	{
	// va_arg获取可变参数的当前参数，返回指定类型并将指针指向下一参数（t参数描述了当前参数的类型）
	// 从实际效果可推导，应该是取出格式化字符串后的另一个参数，即定值指针
	// itoa2:将格式与定值内容对接，拼凑出按格式打印数据的效果
	case 'd': itoa2((int)(*(int *)va_arg(ap,void *)),TempStr);//变量,
		SignedFormatOut(Flags,Width,TempStr);
		break;
	// 整数
	case 'i': itoa2((int)(*(int *)va_arg(ap,void *)),TempStr);
		SignedFormatOut(Flags,Width,TempStr);
		break;
	case 'u': itostr((unsigned int)(*(unsigned int *)va_arg(ap,void *)),TempStr,10);
		UnsignedFormatOut(Flags,Width,TempStr,10);
		break;
	case 'x': itostr((unsigned int)(*(unsigned int *)va_arg(ap,void *)),TempStr,16);
		UnsignedFormatOut(Flags,Width,TempStr,16);
		break;
	case 'X': itostr((unsigned int)(*(unsigned int *)va_arg(ap,void *)),TempStr,17);
		UnsignedFormatOut(Flags,Width,TempStr,16);
		TempPtr=TempStr;
		for(;*TempPtr!='\0';TempPtr++)
			*TempPtr=LowerToUpper(*TempPtr);
		break;
	case 'f': 
	case 'F': 
		ftoa((float)(*(float *)va_arg(ap,void *)),TempStr,'f',Precision);
		AddDotsFloat(TempStr,Precision);
		SignedFormatOut(Flags,Width,TempStr);
		break;
	case 's': TempPtr=(char *)va_arg(ap,void *);
		for(i=0;*TempPtr!='\0';TempStr[i]=*TempPtr++,i++){}
		TempStr[i]='\0';

		break;
	case 'y': 
		{
			struct timespec ts;
			struct rtc_time_t rtc;
			ts.tv_sec=(unsigned int)(*(unsigned int *)va_arg(ap,void *));
			ts.tv_nsec=0;
			timespec_to_rtc(ts,&rtc,1);			
			sprintf(TempStr,"%02d-%02d-%02d",rtc.year,rtc.month,rtc.day);
		}

		break;
	case 'p': 
		{
			unsigned int ip;
			ip=(unsigned int)(*(unsigned int *)va_arg(ap,void *));
			sprintf(TempStr,"%03d.%03d.%03d.%03d",(ip>>24)&0xff,(ip>>16)&0xff,(ip>>8)&0xff,(ip>>0)&0xff);
		}
		break;		
		
	case 'h': switch(Type[1])	/*变量长度修饰符*/
			  {
				  /****************************************************
				  **这里取参数之所以使用int型关键字是因为short关键字**
				  **只从参数表中取出对应参数的一半字节数，而int型关 **
				  **键字从参数表中取出对应参数的全部字节数          **
				  ****************************************************/
				case 'd': itoa1((short int)(*(short int *)va_arg(ap,void *)),TempStr);
					SignedFormatOut(Flags,Width,TempStr);
					break;
				case 'i': itoa1((short int)(*(short int *)va_arg(ap,void *)),TempStr);
					SignedFormatOut(Flags,Width,TempStr);
					break;
				case 'u': stostr((unsigned short int)(*(unsigned short int *)va_arg(ap,void *)),TempStr,10);
					UnsignedFormatOut(Flags,Width,TempStr,10);
					break;
				case 'x': stostr((unsigned short int)(*(unsigned short int *)va_arg(ap,void *)),TempStr,16);
					UnsignedFormatOut(Flags,Width,TempStr,16);
					break;
				case 'X': stostr((unsigned short int)(*(unsigned short int *)va_arg(ap,void *)),TempStr,16);
					UnsignedFormatOut(Flags,Width,TempStr,17);
					TempPtr=TempStr;
					for(;*TempPtr!='\0';TempPtr++)
						*TempPtr=LowerToUpper(*TempPtr);
					break;
			  }
		break;
	default : return(0);
	}	
	
	/*将处理后的数值字符串输出并返回其长度*/
	TempPtr=TempStr;
	for(i=0;*TempPtr!='\0';Str++,i++)
		*Str=*TempPtr++;
	*Str='\0';
	return(i);
}


/***************************************************************************
**  功能: 将从参数表中取出的值转变成给定格式的字符串                     **
**  入口: Str是定值的字符串                                              **
**        FmtStr是输出字符串格式描述串的指针                             **
**  出口: 按格式将字符串转化为数字输出至Varible                          **
***************************************************************************/
void StrToValue(char *Str,char *FmtStr,void *Varible)
{
	char *TempPtr;
	char Temp[4];
	unsigned char i;
	
	/************************定义数据格式串的数据结构****************************/
	
	char Flags[5];
	unsigned char Width=0;
	unsigned char Precision=6;
	char Type[3];
	
	/*****************************分解数据格式串*********************************/	
	TempPtr=(char *)++FmtStr;
	/*分解出标志字符序列*/
	for(;*TempPtr<'0';TempPtr++){}
	for(i=0;FmtStr<TempPtr;Flags[i]=*FmtStr++,i++){}
	Flags[i]='\0';
	/*分解出数据的显示宽度*/
	for(;*TempPtr<':'&&*TempPtr>'/';TempPtr++){}
	for(i=0;FmtStr<TempPtr;Temp[i]=*FmtStr++,i++){}
	Temp[i]='\0';
	Width=(unsigned char)atoi(Temp);
	/*分解出数据的显示精度*/
	if(*TempPtr=='.')
	{
		FmtStr++;
		TempPtr++;
		for(;*TempPtr<':'&&*TempPtr>'/';TempPtr++){}
		for(i=0;FmtStr<TempPtr;Temp[i]=*FmtStr++,i++){}
		Temp[i]='\0';
		Precision=(unsigned char)atoi(Temp);
	}
	/*分解出数据的类型*/
	for(;*TempPtr!='\0';TempPtr++){}
	for(i=0;FmtStr<TempPtr&&i<2;Type[i]=*FmtStr++,i++){}
	/***************按类型将给定格式的字符串转换成数值****************************/
	
	switch(Type[0])
	{
	case 'd': *(int *)Varible=(int)atoi(Str);
		break;
	case 'i': *(int *)Varible=(int)atoi(Str);
		break;
	case 'o': *(unsigned int *)Varible=(unsigned int)strtoul(Str,0,8);
		break;
	case 'u': *(unsigned int *)Varible=(unsigned int)strtoul(Str,0,10);
		break;
	case 'x': *(unsigned int *)Varible=(unsigned int)strtoul(Str,0,16);
		break;
	case 'X': *(unsigned int *)Varible=(unsigned int)strtoul(Str,0,16);
		break;
	case 'f': 
	case 'F': 
		*((float *)Varible)=(float)atof1(Str);
		break;
	case 'c': *(char *)Varible=*Str;
		break;
	case 's': 
		{
			char *tmpstr=(char *)Varible;
			while(*Str!='\0')
			{
				*tmpstr++=*Str++;
			}
			*tmpstr='\0';
		}
		break;		
	case 'h': 
		switch(Type[1])
		{
			case 'd': *(short int *)Varible=(short int)atoi(Str);
				break;
			case 'i': *(short int *)Varible=(short int)atoi(Str);
				break;
			case 'o': *(unsigned short int *)Varible=(unsigned short int)strtoul(Str,0,8);
				break;
			case 'u': *(unsigned short int *)Varible=(unsigned short int)strtoul(Str,0,10);
				break;
			case 'x': *(unsigned short int *)Varible=(unsigned short int)strtoul(Str,0,16);
				break;
			case 'X': *(unsigned short int *)Varible=(unsigned short int)strtoul(Str,0,16);
				break;
		}
		break;
	case 'p':  // IP地址处理
#ifdef LINUX_KERNEL_APP	
			*((int *)Varible)=in_aton(Str);
#else
			*((int *)Varible)=inet_addr(Str);
#endif
			Swap_32(Varible);
		break;
	case 'y':  // 年月日 处理
		{
			struct rtc_time_t tm;
			struct timespec ts;
			char tstr[32];
			int lenth;			
			lenth=fmt_findchardot(Str,tstr,'-');
			if(lenth==0)return;
			tm.year=atoi(Str);	
			Str+=lenth+1;
			lenth=fmt_findchardot(Str,tstr,'-');
			if(lenth==0)return;
			tm.month=atoi(Str);
			Str+=lenth+1;			
			tm.day=atoi(Str);
			tm.hour=0;
			tm.min=0;
			tm.ms=0;
			rtc_to_timespec(&tm,&ts);
			*((int *)Varible)=ts.tv_sec;
		}
		break;
		
	}
	
}

/***************************************************************************
**  功能: 从给定的格式描述串中取出数据格式描述串                         **
**  入口: FmtStr是给定格式描述串的指针                                   **
**        Str是数据格式描述串的指针                                      **
**  出口: 返回数据格式描述串的长度                                       **
**        获取的数据格式描述串在Str指向的字符数组中                      **
***************************************************************************/
unsigned char ScanFmtStr(char *Type,const char *ScanPtr,char *FmtStr)
{
	unsigned char i;
	
	*FmtStr=*ScanPtr++;	/*%号*/
	FmtStr++;
	*Type='d';/*默认是无符号数*/
	
	for(i=1;i<34;i++)	/*值得体味*/
	{
		switch(*ScanPtr)
		{
		case '-':	/*对齐标志*/
		case '+':
		case '*':
		case '#':
		case '.':
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case 'h':
		case 'I': 
			*FmtStr=*ScanPtr++;
			FmtStr++;
			break;
		case 'L': 
			*FmtStr=*ScanPtr++;
			FmtStr++;
			break;
		case 'd': 
		case 'i': 
		case 'o': 
		case 'u': 
		case 'x': 
		case 'X': 
		case 'f': 
		case 'F': 
		case 'c': 
		case 's': 
		case 'B':
		case 'b':
		case 'y':  // 年月日模式 
		case 'p':  // IP模式 
			*Type=*ScanPtr;/*数据类型标志*/
			*FmtStr=*ScanPtr++;
			FmtStr++;
			*FmtStr='\0';
			return(++i);
		default : return(0);
		}
	}
	return 0;
}
/**************************************************************************
函数名称：fmt_Printf
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：按格式将字符串分析，并存入发送缓冲区
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/


void fmt_Printf(short sx,short sy,char Flags,const char *FmtStr,...)
{
	char     Code1;
	char     arrOutStr[44];
	char     TempFmtStr[40];
	short    x=sx,y=sy;
	char     *pstr; 
	int i;
	char postart=0;
	char position=0,datalenth=0;
	va_list  ap;
	va_start(ap,FmtStr);
	pstr=arrOutStr;	
	for(;*FmtStr!='\0';)
	{
		if(*FmtStr=='%')
		{
			position=postart;
			/*取数值格式描述串*/
			i=ScanFmtStr(&Code1,FmtStr,TempFmtStr);
			if(i)
			{
				/*从格式描述串中略过数值格式描述串*/
				FmtStr+=i;
				datalenth=ValuePtrToStr(pstr,TempFmtStr,ap);
				for(;*pstr!='\0';pstr++){}
			}
			else
			{
				/*将% 当成一个字符处理*/
				*pstr=*FmtStr++;
				pstr++;
				*pstr='\0';
			}
		}
		else
		{
			/*将字符输出到输出字符串中*/
			*pstr=*FmtStr++;
			pstr++;
			*pstr='\0';
		}
		postart++;
	}
	va_end(ap);	
	/*发给驱动板的数据*/
	{
		BYTE mode,len;
		BYTE *pd=(BYTE *)arrOutStr;		
		if(Flags==MMI_FOCUS_NORMAL)mode=1;
		else if(Flags==MMI_FOCUS_ASC5_7)mode=2;
		else mode=0;
		len=0;
		while(*pd++!='\0')len++;

		if(Flags==MMI_FOCUS_DATA)  /*只反显数据*/
		{			
			Add_Continue_Data(x,y,(BYTE *)arrOutStr,position, mode);
			Add_Continue_Data((x+position),y,(BYTE *)(arrOutStr+position),datalenth, 1); 
		}
		else
		{
			Add_Continue_Data(x,y,(BYTE *)arrOutStr,len, mode);
		}
	}
}
/**************************************************************************
函数名称：fmt_GetStrLenth
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：分析字符串格式，并取得字符串的长度
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/


short fmt_GetStrLenth(char * pd,char *FmtStr)
{
	char *TempPtr;
	char Temp[4];
	//xbtong char i;	
	int i;
	char Flags[5];
	char Type[3];
	unsigned char width=0;	
	short lenth=0;
	while(*FmtStr!='\0')
	{
		if(*FmtStr=='%')
		{
			FmtStr++;
			TempPtr=(char *)FmtStr;
			/*分解出标志字符序列*/
			for(;*TempPtr<'0';TempPtr++){}
			for(i=0;FmtStr<TempPtr;Flags[i]=*FmtStr++,i++){}
			Flags[i]='\0';
			/*分解出数据的显示宽度*/
			for(;*TempPtr<':'&&*TempPtr>'/';TempPtr++){}
			for(i=0;FmtStr<TempPtr;Temp[i]=*FmtStr++,i++){}
			Temp[i]='\0';
			width=(unsigned char)atoi(Temp);
			/*分解出数据的显示精度*/
			if(*TempPtr=='.')
			{
				FmtStr++;
				TempPtr++;
				for(;*TempPtr<':'&&*TempPtr>'/';TempPtr++,FmtStr++){}
			}
			/*分解出数据的类型	*/		
			Type[0]=*FmtStr;	
			if(Type[0]=='h')FmtStr++;	/*读到最后的描述字符为止	*/	
			if(Type[0]=='s')/*字符串显示 取字符串的长度*/
			{
				TempPtr=(char *)pd;
				lenth+=strlen(TempPtr);
			}
			else
			{
				lenth+=width;
			}
		}
		else  /*刷新整个字符串*/
		{
			lenth++;
		}
		FmtStr++;
	}
	return lenth;
}
/**************************************************************************
函数名称：fmt_StrPrintf
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：将字符串存入发送缓冲区
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/

void fmt_StrPrintf(short sx,short sy,short bytes,char model,const char *str)
{
	BYTE mode,len;
	BYTE *pd=(BYTE *)str;		
	if(model==MMI_FOCUS_NORMAL)mode=1;
	else mode=0;
	len=0;
	while(*pd++!='\0')len++;				
	Add_Continue_Data(sx,sy,(BYTE *)str, len, mode);
}	
/**************************************************************************
函数名称：fmt_InitModify
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：进入修改模式，初始化函数
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/
void fmt_InitModify(BYTE index,short x,short y,void *p,char flag,const char *FmtStr,...)
{
	int i;
	char postart=0; 
	bool bhave_no=true; /* %号只分析一次 */
	va_list  ap;		//定义字符指针
	MODIFY_DEF *pt=&g_tModify;
	
	pt->Fmtstr[0]='\0';
	pt->Valstr[0]='\0';
	pt->Type='u';
	pt->Current=0;
	pt->Lenth=0;
	pt->x=x;	
	pt->y=y;	
	pt->pValue=(void*)p;
	if(flag)pt->bModify=false; /*要不要编辑,标志位*/
	else pt->bModify=true;
	
	// 获取可变参数列表的第一个参数的地址（ap是类型为va_list的指针，FmtStr是可变参数最左边的参数）
	va_start(ap,FmtStr);
	for(;*FmtStr!='\0';)
	{
		if(*FmtStr=='%'&&bhave_no)
		{
			pt->x=x+postart;
			// 复制数值格式描述串,并获取描述所占长度
			i=ScanFmtStr(&pt->Type,FmtStr,pt->Fmtstr);
			
			if(index<0xff&&pt->Type=='f') 
			{
				pt->bFmtstr=true;
				pt->pFmtstr=(void*)FmtStr;
				pt->index=index;
			}
			else
			{
				pt->bFmtstr=false;
				pt->pFmtstr=NULL;
			}
			if(i)
			{
				// 从格式描述串中略过数值格式描述串,以便从list中取得定值指针
				FmtStr+=i;
				// 将格式描述与数据对接，获得按格式打印数据的效果，并将数据转为字符串存入Valstr，返回长度给Lenth
				pt->Lenth=ValuePtrToStr(pt->Valstr,pt->Fmtstr,ap);
			}
			bhave_no=false;
		}
		else
		{
			FmtStr++;
		}
		postart++;
	}
	
	// 清空va_list可变参数列表
	va_end(ap);	 

	// 要编辑符号的话，先跳过符号位,即正负位
	if(pt->Type=='f'||pt->Type=='d'||pt->Type=='i') 
	{
		pt->Current=1;
	}

	// 数据不要编辑,反显所有数据
	if(!g_tModify.bModify)  
	{
		pt->Current=0;
		fmt_StrPrintf(g_tModify.x,g_tModify.y,g_tModify.Lenth, MMI_FOCUS_NORMAL,g_tModify.Valstr);
	}
}
/**************************************************************************
函数名称：fmt_ClearCursor
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/
#if 0
static void fmt_ClearCursor(void)
{
#if 0
	short pointer;
	int i;
	char byte;
	pointer=g_tModify.y*BYTES_PER_LINE+g_tModify.x+g_tModify.Current;
	for(i=0;i<16;i++)
	{
		lcd_WriteRAM(pointer+BYTES_PER_LINE*i,lcd_ReadRAM(pointer+BYTES_PER_LINE*i)&0xFE);
	}
#endif

}
#endif
/**************************************************************************
函数名称：fmt_CursorOff
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：关闭光标显示
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/

void fmt_CursorOff(void)
{
	BYTE model=MMI_FOCUS_NORMAL;
	if(g_tModify.bModify)model=MMI_FOCUS_NO;
	fmt_StrPrintf(g_tModify.x,g_tModify.y,g_tModify.Lenth, model,g_tModify.Valstr);
}
/**************************************************************************
函数名称：fmt_CursorOn
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：打开光标显示
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/

void fmt_CursorOn(void)
{
	char str[3];
	if(!g_tModify.bModify)return;
	str[0]=g_tModify.Valstr[(int)g_tModify.Current];
	if(str[0]&0x80) /*汉字显示反显2个字节*/
	{
		str[1]=g_tModify.Valstr[g_tModify.Current+1];
		str[2]='\0';
		fmt_StrPrintf(g_tModify.x+g_tModify.Current,g_tModify.y,2, MMI_FOCUS_NORMAL,str);
	}
	else
	{
		str[1]='\0';
		fmt_StrPrintf(g_tModify.x+g_tModify.Current,g_tModify.y,1, MMI_FOCUS_NORMAL,str);
	}
}
/**************************************************************************
函数名称：fmt_CursorFlush
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：光标闪烁
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/

void fmt_CursorFlush(void)
{
#if 0
 	static bool bFlag=false;
	static char TimeCnt=0;
	short pointer;
	unsigned char byte;
	int i;
	if(!g_tModify.bModify)return;
	if(TimeCnt++<1) /*闪烁频率*/
	{
		return;
	}
	TimeCnt=0;
	bFlag=!bFlag;
	if(g_tModify.Valstr[g_tModify.Current]&0x80)/*汉字修改显示*/
	{
		pointer=g_tModify.y*BYTES_PER_LINE+g_tModify.x+g_tModify.Current+1;
	}
	else
	{
		pointer=g_tModify.y*BYTES_PER_LINE+g_tModify.x+g_tModify.Current;
	}
	for(i=0;i<16;i++)
	{
		byte=(lcd_ReadRAM(pointer+BYTES_PER_LINE*i)&0xFE)+bFlag;
		lcd_WriteRAM(pointer+BYTES_PER_LINE*i,byte);
	}
#endif
 }
/**************************************************************************
函数名称：fmt_CursorLeft
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：修改模式下，左键功能，编辑数据左移一位
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/


bool fmt_CursorLeft(void)
{
	if(!g_tModify.bModify)return true;
	if(g_tModify.Lenth<=0)return true;
	fmt_CursorOff();
	if(g_tModify.Current<=0)
	{

		g_tModify.Current=g_tModify.Lenth-1;
		if(g_tModify.Valstr[(int)g_tModify.Current]=='.'&&g_tModify.Type=='F')
		{
				g_tModify.Current-=1;
		}		
		if(g_tModify.Valstr[(int)g_tModify.Current]&0x80)g_tModify.Current-=1;
		fmt_CursorOn();
		return true;
	}
	else 
	{
		g_tModify.Current--;
		if(g_tModify.Valstr[(int)g_tModify.Current]=='.'&&g_tModify.Type=='F')
		{
			g_tModify.Current-=1;
		}
		if(g_tModify.Valstr[(int)g_tModify.Current]&0x80)/*当前还是汉字*/
			g_tModify.Current--;		
			
	}
	fmt_CursorOn();
	return false;
}
/**************************************************************************
函数名称：fmt_CursorRight
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：修改模式下，右键功能，编辑数据右移一位
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/

bool fmt_CursorRight(void)  /*到最右边，返回true;*/
{
	if(!g_tModify.bModify)return true;
	if(g_tModify.Lenth<=0)return true;
	fmt_CursorOff();	
	if(g_tModify.Valstr[(int)g_tModify.Current]&0x80)
	{
		if(g_tModify.Current>=g_tModify.Lenth-2)
		{
			g_tModify.Current=0;  /*到最右边*/
			fmt_CursorOn();
			return true;
		}
		else
		{
			g_tModify.Current+=2;
		}
	}
	else
	{
		if(g_tModify.Current>=g_tModify.Lenth-1)
		{
			g_tModify.Current=0;  /*到最右边*/
			fmt_CursorOn();
			return true;
		}
		else 
		{
			g_tModify.Current+=1;
			if(g_tModify.Valstr[(int)g_tModify.Current]=='.'&&g_tModify.Type=='F')
			{
				g_tModify.Current+=1;
			}
			
		}
	}
	fmt_CursorOn();
	return false;
}
/**************************************************************************
函数名称：fmt_IsHavePoint
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：判断是否有小数点
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/

static bool fmt_IsHavePoint(void)
{
	unsigned char cnt;
	for(cnt=0;cnt<g_tModify.Lenth;cnt++)
	{
		if(g_tModify.Valstr[cnt]=='.')
			return true;
	}
	return false;
}
/**************************************************************************
函数名称：fmt_MovePoint
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：移动小数点位
输入参数：bFlag 移动标志位，true 右移 false 左移
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/

static void fmt_MovePoint(bool bFlag)
{
	unsigned char point,cnt;
	char TempStr[40];
	char *p=TempStr;
	
	for(cnt=0;cnt<g_tModify.Lenth;cnt++)
	{
		if(g_tModify.Valstr[cnt]=='.')continue;
		*p++=g_tModify.Valstr[cnt];
	}
	point=g_tModify.Current;
    if(bFlag) /*小数点右移*/
	{
		if(point>=g_tModify.Lenth-1)point=1;  /*到最右边*/
		else point++;
	}
	else
	{
		if(point<=1)point=g_tModify.Lenth-1;  /*到最左边*/
		else point--;
	}
	p=TempStr;
	for(cnt=0;cnt<g_tModify.Lenth;cnt++)
	{
		if(cnt==point)g_tModify.Valstr[cnt]='.';
		else g_tModify.Valstr[cnt]=*p++;
	}
	g_tModify.Current=point;
	fmt_CursorOff();
}
/**************************************************************************
函数名称：fmt_CursorAdd
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：编辑模式下，加键功能
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/


void fmt_CursorAdd(void)
{
	char dat;
	if(!g_tModify.bModify)return;
	fmt_CursorOff();
	dat=g_tModify.Valstr[(int)g_tModify.Current]; /*取当前修改字符*/
	//if(g_tModify.Type!='s') /*不是汉字修改*/
	{
		switch(g_tModify.Type)
		{
		case 'o': 
			if(dat=='7')dat='0';else dat++;
			if(dat>'7')dat='0';
			break;
		case 'u': /*无符号数*/
			if(dat=='9')dat='0';else dat++;
			if(dat>'9')dat='0';
			break;
		case 'x':  /*16进制小写*/
			switch(dat)
			{
			case '9':	dat='a';	break;
			case 'f':	dat='0';	break;
			default:	dat++;		break;
			}
			break;
			case 'X':  /*16进制大写*/
				switch(dat)
				{
				case '9':	dat='A';	break;
				case 'F':	dat='0';	break;
				default:	dat++;		break;
				}
				break;
				case 'c': 
					if(dat=='9')dat='0';else dat++;
					if(dat>'9')dat='0';
					break;
				case 'B':
				case 'b':
				if(dat=='1')dat='0';else dat='1';
					break;
				case 'd':  /*有符号数*/
				case 'i': 
					if(g_tModify.Current==0)
					{
						dat=' ';
					}
					else
					{
						switch(dat)
						{
						case '9':   dat='0';break;
						default:	dat++;	break;
						}
						if(dat<'0'||dat>'9')dat='0';
					}
					break;
				case 'f':  /*浮点数*/
				case 'F':  /*浮点数*/
					if(g_tModify.Current==0)
					{
						dat=' ';
					}
					else
					{
						switch(dat)
						{
						case '9':
							if((g_tModify.Current==g_tModify.Lenth-1)&&(!fmt_IsHavePoint()))
							{
								dat='.';  /*防止没有小数点的情况出现*/
							}
							else
							{
								dat='0';
							}
							break;
						case '.':	fmt_MovePoint(1);break;
						default:
							if(dat>='0'&&dat<='9')dat++;
							else dat='0';							
							break;
						}
					}			
					break;
				case 'p': /*ip地址处理*/
					if(dat!='.')
					{
						if(dat=='9')dat='0';else dat++;
						if(dat>'9')dat='0';
					}
					break;
				case 'y': /*ip地址处理*/
					if(dat!='-')
					{
						if(dat=='9')dat='0';else dat++;
						if(dat>'9')dat='0';
					}
					break;

				case 's':  /*字符串*/
#ifdef PASSWORD_4_STR
					if(dat>='0'&&dat<'9')
					{
						dat++;
					}
					else if(dat=='9')
					{
						dat='0';
					}
					else
					{
						dat='0';
					}
#else
					if(dat>='0'&&dat<'9')
					{
						dat++;
					}
					else if(dat=='9')
					{
						dat='A';
					}
					else if(dat>='A'&&dat<'Z')
					{
						dat++;
					}
					else if(dat=='Z')
					{						
						dat='0';
					}
					else
					{
						dat='0';
					}

#endif
					break;
					
				default:
					dat='0';
					break;
		}
		if(dat!='.')g_tModify.Valstr[(int)g_tModify.Current]=dat; /*取当前修改字符*/
	}
	fmt_CursorOn();
} 
/**************************************************************************
函数名称：fmt_CursorSubb
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：编辑模式下，减键功能
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/


void fmt_CursorSubb(void)
{
	char dat;
	if(!g_tModify.bModify)return;
	fmt_CursorOff();
	dat=g_tModify.Valstr[(int)g_tModify.Current]; /*取当前修改字符*/
	//if(g_tModify.Type!='s') /*不是汉字修改*/
	{
		switch(g_tModify.Type)
		{
		case 'o': 
			if(dat=='0')dat='7';else dat--;
			if(dat>'7')dat='0';
			break;
		case 'u': /*无符号数*/
			if(dat=='0')dat='9';else dat--;
			if(dat>'9')dat='0';
			break;
		case 'x':  /*16进制小写*/
			switch(dat)
			{
			case 'a':	dat='9';	break;
			case '0':	dat='f';	break;
			default:	dat--;		break;
			}
			break;
			case 'X':  /*16进制大写*/
				switch(dat)
				{
				case 'A':	dat='9';	break;
				case '0':	dat='F';	break;
				default:	dat--;		break;
				}
				break;
				case 'c': 
					if(dat=='0')dat='9';else dat++;
					if(dat>'9')dat='0';
					break;
				case 'B':
				case 'b':
					if(dat=='1')dat='0';else dat='1';
					break;
				case 'd':  /*有符号数*/
				case 'i': 
					if(g_tModify.Current==0)
					{
						dat='-';						
					}
					else
					{
						switch(dat)
						{
						case '0':   dat='9';break;
						default:	dat--;	break;
						}
						if(dat<'0'||dat>'9')dat='0';
					}
					break;
				case 'f':  /*浮点数*/
				case 'F':  /*浮点数*/
					if(g_tModify.Current==0)
					{
						dat='-';						
					}
					else
					{
						switch(dat)
						{
						case '0':
							if((g_tModify.Current==g_tModify.Lenth-1)&&(!fmt_IsHavePoint()))
							{
								dat='.';  /*防止没有小数点的情况出现*/
							}
							else
							{
								dat='9';
							}
							break;
						case '.':	fmt_MovePoint(0);break;
						default:							
							if(dat>='0'&&dat<='9')dat--;
							else dat='0';
							break;
						}
					}
					break;
				case 'p': /*ip地址处理*/
					if(dat!='.')
					{
						if(dat=='0')dat='9';else dat--;
						if(dat>'9')dat='0';
					}
					break;
				case 'y': /*ip地址处理*/
					if(dat!='-')
					{
						if(dat=='0')dat='9';else dat--;
						if(dat>'9')dat='0';
					}
					break;	
				case 's':  /*字符串*/

#ifdef PASSWORD_4_STR
					if(dat>'0'&&dat<='9')
					{
						dat--;
					}
					else if(dat=='0')
					{
						dat='9';
					}
					else
					{
						dat='0';
					}
#else 
					if(dat>'0'&&dat<='9')
					{
						dat--;
					}
					else if(dat=='0')
					{
						dat='Z';
					}
					else if(dat>'A'&&dat<='Z')
					{
						dat--;
					}
					else if(dat=='A')
					{						
						dat='9';
					}
					else
					{
						dat='0';
					}
#endif
					break;				
				default:
					dat='0';
					break;
		}
		if(dat!='.')g_tModify.Valstr[(int)g_tModify.Current]=dat; /*取当前修改字符*/
	}
	fmt_CursorOn();
}
/**************************************************************************
函数名称：fmt_FmtstrPrecison
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：分析格式字符串内显示的数据精度
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/


static char * fmt_FmtstrPrecison(char *FmtStr,BYTE *len)
{
	char *TempPtr,*ret;
	char Temp[4];
	int i;
	char Precision=6;		
	FmtStr++;	/*=%*/
	/*分解出标志字符序列*/
	for(;*FmtStr<'0';FmtStr++){} /*+ - * # .*/
	/*分解出数据的显示宽度*/
	for(;(*FmtStr<='9')&&(*FmtStr>='0');FmtStr++){}/*0~9 change by sunxi old:(*TempPtr<':'&&*TempPtr>'/')*/
	/*分解出数据的显示精度*/
	if(*FmtStr=='.')
	{
		FmtStr++;
		TempPtr=(char *)FmtStr;
		ret=(char *)FmtStr;
		for(;*TempPtr<='9'&&*TempPtr>='0';TempPtr++){}/*0~9 change by sunxi */
		for(i=0;FmtStr<TempPtr;Temp[i]=*FmtStr++,i++){}
		Temp[i]='\0';
		Precision=(unsigned char)atoi(Temp);
	}
	else 
	{		
		ret=NULL;
	}
	return ret;	
}
/**************************************************************************
函数名称：fmt_GetModifyValue
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：分析编辑字符串的格式，并取得编辑状态下数据的值
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/

void fmt_GetModifyValue(void)
{	
	BYTE precison,len;
	char *p;

	len = 0;
	StrToValue(g_tModify.Valstr,g_tModify.Fmtstr,g_tModify.pValue);
	if(g_tModify.bFmtstr&&g_tModify.Type=='f')  /*小数点可变*/
	{
		precison=mmi_GetFloatFactor((void *)g_tModify.pValue); /*取得小数点后的位数*/
		p=fmt_FmtstrPrecison(g_tModify.pFmtstr,&len);
		if(len!=precison&&p!=NULL) /*小数点后有效位数不同*/
		{
			*p=precison+'0';
		}
		strcpy(g_tModify.Fmtstr,g_tModify.pFmtstr);
	}
}
/**************************************************************************
函数名称：fmt_GetModifyValue_Single
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：取得编辑的数据的值
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/
void fmt_GetModifyValue_Single(void)
{	
	StrToValue(g_tModify.Valstr,g_tModify.Fmtstr,g_tModify.pValue);
}

/**************************************************************************
函数名称：fmt_GetModifyType
函数版本：1.00 
作者：   
创建日期：2008.9.1     
函数功能说明：获取当前的编辑状态
输入参数：
输出参数：
返回值：

更新信息：
更新日志1：
日期：	  
修改者：	  
修改内容：  
修改原因：
***************************************************************************/
bool fmt_GetModifyType(void)
{				
	return (g_tModify.bModify);
}

/******************************************************************
								file end
******************************************************************/
