/******************************************************************************
版权所有：	深圳市金宏威实业发展有限公司
文件名称：	menudesc.c
文件版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
功能说明：	菜单结构	
其它说明：
修改记录：
*/
/*------------------------------- 头文件 --------------------------------------
*/
#include "head.h"
 
/*------------------------------- 宏定义 --------------------------------------
*/
// 一行显示可显示菜单、开入、测量、定值
#define 	LINE_MENU		2
#define		LINE_KR			1
#define		LINE_AC			1

#define		SET_LINE		2

#define 	STR_LEN_MENU    4   //4=4chars, 8=8chars

// 时间的显示方式
enum
{
	LINE_MD,
	PAGE_MD,
};
/*------------------------------ 类型结构 -------------------------------------
*/

/*------------------------------ 全局变量 -------------------------------------
*/
// zhl add start
u8 m_setgroup[GROUP_NUM];
u8 bPubSetMenuShow[SET_PUB_NUM];
u8 bSwSetMenuShow[SET_NUM];
u8 bParaSetMenuShow[PARA_NUM];
u8 bCstSetMenuShow[CSTSET_NUM];
typedef struct MENU_MEA
{
	u8      index[MEA_MENU_MAX];
	u8      num;
	
}MENU_MEA;
MENU_MEA tMenuMea;
u8 g_lcd_size = 4;
bool g_bVipSoe_show = false;
// zhl add end

extern unsigned short	m_CodeCrc; 

//固定菜单定义
const struct menu_table menu_base_table[MENU_NUM]=
{
	{0,		 0,		0},
	{"菜单",   0,		0},
	{"运行状态", 0,		0},
	{"系统设置", 0,		0},
	{"系统记录", 0,		0},
	{"装置维护", 0,		0},
	{"信息参数", 0,    0},
	{"点表信息", 0,    0},

	{"遥信", 0,		0},
	{"遥测", 0,		0},
	{"标志", 0,		0},
	{"时间", 0,		0},
#if ((SWITCH_NUM_MAX == 16) ||  (SWITCH_NUM_MAX == 4) ||  (SWITCH_NUM_MAX == 6) || (SWITCH_NUM_MAX == 1)) 
	{"定值参数", 1,		0},
#endif	
	{"装置参数", 0x1,	1},
	{"系统时间", 0x1,	1},
	{"电池参数", 0,		0},
	{"运行参数", 0x1,  1},
	{"故障复归", 0x1,  1},
#if ((SWITCH_NUM_MAX == 16) ||  (SWITCH_NUM_MAX == 4) ||  (SWITCH_NUM_MAX == 6) || (SWITCH_NUM_MAX == 1)) 
	{"公共",   0,		1},
	{"开关01", 0,		0},
#if ((SWITCH_NUM_MAX == 16) ||  (SWITCH_NUM_MAX == 4) ||  (SWITCH_NUM_MAX == 6)) 	
	{"开关02", 0,		0},
	{"开关03", 0,		0},
	{"开关04", 0,		0},
#endif	
#if ((SWITCH_NUM_MAX == 16) ||  (SWITCH_NUM_MAX == 6)) 	
	{"开关05", 0,		0},
	{"开关06", 0,		0},
#endif	
#if SWITCH_NUM_MAX == 16	
	{"开关07", 0,		0},
	{"开关08", 0,		0},
	{"开关09", 0,		0},
	{"开关10", 0,		0},
	{"开关11", 0,		0},
	{"开关12", 0,		0},
	{"开关13", 0,		0},
	{"开关14", 0,		0},
	{"开关15", 0,		0},
	{"开关16", 0,		0},
#endif	
#endif	
	{"事件", 0,		0},
	{"操作", 0,		0},
    {"固有参数", 0,     0},
    {"通讯参数", 0,     0},
	{"遥信点表", 0,     0},
    {"遥测点表", 0,     0},
	{"测试", 0x2,	0},
	{"校准", 0x2,	0},
	{"遥控", 0x2,	0},
	{"设置", 0x2,	1},
	{"密码", 0x1,	1},
	{"清除", 0x2,	0},
	{"信息", 0,		0},
	{"开出", 0,		0},
	{"人机", 0,		0},
	{"交流", 0,		0},
	{"直流", 0,		0},
	{"版本", 0,		0},
	{"配置", 0,		0},
	{"错误", 0,		0},
	{"调试", 0,		0},
	{"GPRS", 0,		0},

	{"保护压板", 0,     1},
	{"过流保护", 0,     1},
	{"零序保护", 0,     1},
	{"接地保护", 0,     1},
	{"重合闸  ", 0,     1},
	{"后加速  ", 0,     1},
	{"电流越限", 0,     1},

	{"公共遥信", 0,     0},
	{"开关遥信", 0,     0},
	{"公共遥测", 0,     0},
	{"开关遥测", 0,     0},

	{"重合闸", 0,     0},
	{"遥控器", 0,     0},


};

// 固定实体定义
struct item_table item_base_table[ITEM_NUM]=
{
	{"版本", 	 0, 	(u8 *)&g_board_info[0].version},
	{"CRC", 	 SET_H, (u8 *)&m_CodeCrc},
	{"装置资源", SET_H, (u8 *)&g_crc_rsc},
	{"板卡资源", SET_H, (u8 *)&g_crc_brd_res},
	{"通道配置", SET_H, (u8 *)&g_crc_equ_cfg},
	{"转发点表", SET_H, (u8 *)&g_crc_rectable},
	{"定值描述", SET_H, (u8 *)&g_crc_set_desc},
	{"定值数据", SET_H, (u8 *)&g_crc_set_data},
	{"LCD测试",  0, 	0},
	{"LED测试",  0, 	0},
	{"清除事件", 0, 	0},
	{"清除操作", 0, 	0},	
	{"100V 5A 正序", 0, 0},
	{"1.输入10V",0, 	0},
	{"2.输入50V",0, 	0},	
	{"保存",	 0,		0},			
	{"确认",	 0,		0},		
	{"取消",	 0,		0},
	{"遥控器A",  0,		(u8 *)&g_run_stu.rmt_A},
	{"遥控器B",  0,		(u8 *)&g_run_stu.rmt_B},
	{"遥控器C",  0,		(u8 *)&g_run_stu.rmt_C},
	{"遥控器D",  0,		(u8 *)&g_run_stu.rmt_D},
	// {"重合充电", 0,		(u8 *)&g_disp_flag.chz_cd}, // TODO: 需要后续完善
	{"遥控配对", 0, 	0},
	{"清除配对", 0, 	0},
	// {"小电流重合充电", 0,(u8 *)&g_disp_flag.xdl_chz_cd}, // TODO: 需要后续完善
};

// 主菜单
struct item main_disp[]=
{
	{MENU_TYPE,	MENU_RUNSTU, 	0,	0},
	{MENU_TYPE,	MENU_SET, 		0,	0},
	{MENU_TYPE,	MENU_SOE, 		0,	0},
	{MENU_TYPE,	MENU_DEBUG, 	0,	0},
    {MENU_TYPE, MENU_INFO_PARA, 0,  0},
	{MENU_TYPE, MENU_TABLE_INFO, 0,  0},
};
#define MainNum	sizeof(main_disp)/sizeof(struct item)

// 工况菜单
struct item run_disp[]=
{
	{MENU_TYPE,MENU_KR, 		0,	0},
	{MENU_TYPE,MENU_AC, 		0,	0},
	{MENU_TYPE,MENU_FLAG, 		0,	0},
	{MENU_TYPE,MENU_TIME, 		0,	0},
};
#define RunNum	sizeof(run_disp)/sizeof(struct item)

// 设置菜单
struct item set_disp[]=
{
	{MENU_TYPE, MENU_FIX,        0,  0},
	{MENU_TYPE, MENU_PARA,       0,  0},
	{MENU_TYPE, MENU_TIMESET,    0,  0},
	{MENU_TYPE, MENU_BAT,        0,  0},
	{MENU_TYPE, MENU_RUN_PARA,   0,  0},
	{MENU_TYPE, MENU_FAULT_RESET,0,  0},
};
#define SetNum	sizeof(set_disp)/sizeof(struct item)

// 间隔菜单
struct item sw_x_disp[]=
{
	{MENU_TYPE, MENU_BH_STATUS, 0,  0},
    {MENU_TYPE, MENU_GLBH,      0,  0},
    {MENU_TYPE, MENU_LXBH,      0,  0},
    {MENU_TYPE, MENU_JDBH,      0,  0},
    {MENU_TYPE, MENU_RECLOSE,   0,  0},
	{MENU_TYPE, MENU_HJS, 		0,  0},
	{MENU_TYPE, MENU_DLYX, 		0,  0},
};
#define SWxNum  sizeof(sw_x_disp)/sizeof(struct item)

const u8 sw_menu_num = SWxNum;

#if SWITCH_NUM_MAX == 16
// 设置菜单
struct item setsw_disp[]=
{
	{MENU_TYPE,	MENU_FIX_PUB, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW1, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW2, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW3, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW4, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW5, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW6, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW7, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW8, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW9, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW10, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW11, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW12, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW13, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW14, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW15, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW16, 	0,	0},
};
#define SetswNum	sizeof(setsw_disp)/sizeof(struct item)

#elif SWITCH_NUM_MAX == 8

// 设置菜单
struct item setsw_disp[]=
{
	{MENU_TYPE,	MENU_FIX_PUB, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW1, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW2, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW3, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW4, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW5, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW6, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW7, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW8, 	0,	0},
};
#define SetswNum	sizeof(setsw_disp)/sizeof(struct item)
#elif SWITCH_NUM_MAX == 6

// 设置菜单
struct item setsw_disp[]=
{
	{MENU_TYPE,	MENU_FIX_PUB, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW1, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW2, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW3, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW4, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW5, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW6, 	0,	0},
};
#define SetswNum	sizeof(setsw_disp)/sizeof(struct item)
#elif SWITCH_NUM_MAX == 4

// 设置菜单
struct item setsw_disp[]=
{
	{MENU_TYPE,	MENU_FIX_PUB, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW1, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW2, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW3, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW4, 	0,	0},
};
#define SetswNum	sizeof(setsw_disp)/sizeof(struct item)
#elif SWITCH_NUM_MAX == 1
// 设置菜单
struct item setsw_disp[]=
{
	{MENU_TYPE,	MENU_FIX_PUB, 	0,	0},
	{MENU_TYPE,	MENU_FIX_SW1, 	0,	0},
};
#define SetswNum	sizeof(setsw_disp)/sizeof(struct item)
#endif

// 遥信菜单
struct item kr_disp[]=
{
	{MENU_TYPE,MENU_PUB_YX, 	0,	0},
	{MENU_TYPE,MENU_SW_YX, 		0,	0},
};
#define kr_dispNum	sizeof(kr_disp)/sizeof(struct item)

struct item ac_disp[]=
{
	{MENU_TYPE,MENU_PUB_YC, 	0,	0},
	{MENU_TYPE,MENU_SW_YC, 		0,	0},
};
#define ac_dispNum	sizeof(ac_disp)/sizeof(struct item)
//标志菜单
struct item others_flag_disp[]=
{
	{QUERY_FLAG,ITEM_RMT_A, 		0,	0},
	{QUERY_FLAG,ITEM_RMT_B, 		0,	0},
	{QUERY_FLAG,ITEM_RMT_C, 		0,	0},
	{QUERY_FLAG,ITEM_RMT_D, 		0,	0},
	// {QUERY_FLAG,ITEM_CHZ_CD, 		0,	0},
	// {QUERY_FLAG,ITEM_XDL_CHZ_CD, 	0,	0},
};
#define othersflagNum	sizeof(others_flag_disp)/sizeof(struct item)

// 标志菜单
struct item flag_disp[]=
{
	{MENU_TYPE,MENU_CHZ_FLAG, 		0,	0},
	{MENU_TYPE,MENU_OTHERS_FLAG, 	0,	0},
};
#define flagNum	sizeof(flag_disp)/sizeof(struct item)

// 记录菜单
struct item soe_disp[]=
{
	{MENU_TYPE,MENU_SJSOE, 		0,	0},
	{MENU_TYPE,MENU_CZSOE, 		0,	0},
};
#define SoeNum	sizeof(soe_disp)/sizeof(struct item)

// 维护菜单
struct item debug_disp[]=
{
	{MENU_TYPE,	MENU_TEST, 		0,	0},
	{MENU_TYPE,	MENU_ADJUST, 	0,	0},
	{MENU_TYPE,	MENU_RMT, 		0,	0},
	{MENU_TYPE,	MENU_INFIX,		0,	0},
	{MENU_TYPE,	MENU_CODE, 		0,	0},
	{MENU_TYPE,	MENU_CLR, 		0,	0},
	{MENU_TYPE,	MENU_INFO, 		0,	0},
};
#define DebugNum	sizeof(debug_disp)/sizeof(struct item)

// 信息参数
struct item info_para_disp[]=
{
    {MENU_TYPE, MENU_INFO_EQU,     0,  0},
    {MENU_TYPE, MENU_COMM_PARA,    0,  0},
};
#define InfoParaNum    sizeof(info_para_disp)/sizeof(struct item)

// 点表信息
struct item info_table_disp[]=
{
    {MENU_TYPE, MENU_INFO_YX,     0,  0},
    {MENU_TYPE, MENU_INFO_YC,     0,  0},
};
#define InfoTableNum    sizeof(info_table_disp)/sizeof(struct item)

// 测试菜单
struct item test_disp[]=
{
	{MENU_TYPE,MENU_TEST_KC, 	0,	0},
	{MENU_TYPE,MENU_TEST_HMI, 	0,	0},
};
#define TestNum	sizeof(test_disp)/sizeof(struct item)

// 校准菜单
struct item adjust_disp[]=
{
	{MENU_TYPE,MENU_ADJUST_AC, 0,	0},
	{MENU_TYPE,MENU_ADJUST_DC, 0,	0},
};
#define AdjustNum	sizeof(adjust_disp)/sizeof(struct item)

// 遥控器菜单
struct item rmt_disp[]=
{
	{ACTION_RMT_PAIR,ITEM_RMT_PAIR, 	0,	0},
	{ACTION_DEL_PAIR,ITEM_DEL_PAIR, 	0,	0},
};
#define RmtNum	sizeof(rmt_disp)/sizeof(struct item)

// 用户密码设置
struct item item_code[]=
{
	// {SETTYPE_4INT,	CODE,		0,	0}, 
    {SETTYPE_6INT,  CODE,       0,  0},
};
#define CodeNum		sizeof(item_code)/sizeof(struct item)

// 清除事件记录
struct item clr_soe[]=
{
	{ACTION_CLR_SOE,	ITEM_CLR_SJ,		0,	0},
	{ACTION_CLR_SOE,	ITEM_CLR_CZ,		0,	0},
};
#define clrsoeNum		sizeof(clr_soe)/sizeof(struct item)

// 信息菜单
struct item item_info[]=
{
	{MENU_TYPE,	MENU_INFO_VER,		0,	0},
	{MENU_TYPE,	MENU_INFO_CFG,		0,	0},
	{MENU_TYPE,	MENU_INFO_ERR,		0,	0},
	{MENU_TYPE,	MENU_INFO_DEBUG,	0,	0},
	{MENU_TYPE,	MENU_INFO_GPRS,		0,	0},
};
#define InfoNum		sizeof(item_info)/sizeof(struct item)

// 版本信息菜单
struct item ver_info[]=
{
	{QUERY_VER,	ITEM_VER,		0,	0},
	{QUERY_VER,	ITEM_CRC,		0,	0},
};
#define InfoVerNum		sizeof(ver_info)/sizeof(struct item)

// 配置信息菜单
struct item cfg_info[]=
{
	{QUERY_CFG,	ITEM_EQU,		0,	0},
	{QUERY_CFG,	ITEM_BRD,		0,	0},
	{QUERY_CFG,	ITEM_CFG,		0,	0},
	{QUERY_CFG,	ITEM_IECTABLE,	0,	0},
	{QUERY_CFG,	ITEM_SETDESC,	0,	0},
	{QUERY_CFG,	ITEM_SETDATA,	0,	0},
};
#define InfoCfgNum		sizeof(cfg_info)/sizeof(struct item)

// HMI测试菜单
struct item hmi_test[]=
{
	{ACTION_TEST_LCD,	ITEM_TEST_LCD,		0,	0},
	{ACTION_TEST_LED,	ITEM_TEST_LED,		0,	0},
};
#define hmitestNum		sizeof(hmi_test)/sizeof(struct item)

// 交流校准
struct item adjust_ac[]=
{
	{ACTION_ADJUST_AC,	ITEM_ADJUST_AC,		0,	0},
};
#define adjustacNum		sizeof(adjust_ac)/sizeof(struct item)

// 直流校准
struct item adjust_dc[]=
{
	{ACTION_ADJUST_DC10,ITEM_ADJUST_DC10,	0,	0},
	{ACTION_ADJUST_DC50,ITEM_ADJUST_DC50,	0,	0},
};
#define adjustdcNum		sizeof(adjust_dc)/sizeof(struct item)

// 是否保存
struct item is_save[]=
{
	{ACTION_SAVE,		ITEM_SAVE_OK,		0,	0},
	{ACTION_SAVE,		ITEM_SAVE_NOK,		0,	0},
};
#define is_saveNum		sizeof(is_save)/sizeof(struct item)

struct item *item_pub_kr;	// 公共开入查询
struct item *item_sw_kr;	// 开关开入查询
struct item *item_pub_ac;	// 公共测量查询
struct item *item_sw_ac;	// 开关测量查询
struct item *item_flag;		// 标志查询
struct item *item_time;		// 时间查询

struct item *item_fix;		// 定值设置
struct item *item_fix_GLBH;  // 定值设置
struct item *item_fix_LXBH;  // 定值设置
struct item *item_fix_JDBH;  // 定值设置
struct item *item_fix_CHZ;   // 定值设置
struct item *item_fix_BH_sts;// 保护状态
struct item *item_fix_DLYX_sts;// 电流越限
struct item *item_fix_HJS_sts;// 后加速

struct item *item_para;		// 装置参数设置
struct item *item_run_para; // 运行参数设置
struct item *item_fault_reset; //故障复归
struct item *item_infix;	// 内部定值设置
struct item *item_timeset;	// 时间设置
struct item *item_chz_flag;	// 重合闸标志

struct item *item_sjsoe;	// 事件记录
struct item *item_czsoe;	// 操作记录
struct item *item_info_equ; // 装置信息 (固有参数)
struct item *item_comm_para;// 通讯参数
struct item *item_info_yx; // 遥信点表
struct item *item_info_yc;// 遥测点表

struct item *item_test_kc;	// 开出测试

struct item *item_bat;		// 电池
	
struct item *item_info_err;	// 错误信息
struct item *item_info_debug;//调试信息
struct item *item_info_gprs;// GPRS信息

struct item *item_password;	// 输入密码
struct item *item_passerr;	// 输入密码错误
struct item *item_saveresult;// 保存结果
struct item *item_setrange;	// 定值范围
struct item *item_adjustresult;	//校准结果	

struct item *item_event;	// 突发事件
struct item *item_rmtpair;	// 遥控器配对
struct item *item_delpair;	// 遥控器配对清除
const struct slave slave_table[]=
{
	{MENU_MAIN, 	{MENU_RUNSTU, 	MENU_SET, 		MENU_SOE, 		MENU_DEBUG, MENU_INFO_PARA, MENU_TABLE_INFO, 	MENU_NULL}},
	{MENU_RUNSTU, 	{MENU_KR, 		MENU_AC, 		MENU_FLAG, 		MENU_TIME, 	MENU_NULL, 	    MENU_NULL, 			MENU_NULL}},
	{MENU_SET, 		{MENU_FIX, 		MENU_PARA, 		MENU_TIMESET,	MENU_BAT, 	MENU_RUN_PARA,	MENU_FAULT_RESET, 	MENU_NULL}},
#if SWITCH_NUM_MAX == 16
	{MENU_FIX, 		{MENU_FIX_PUB, 	MENU_FIX_SW1, 	MENU_FIX_SW2,	MENU_FIX_SW3, 	MENU_FIX_SW4,	MENU_FIX_SW5, 	MENU_FIX_SW6,
					MENU_FIX_SW7,	MENU_FIX_SW8,	MENU_FIX_SW9,	MENU_FIX_SW10,	MENU_FIX_SW11,	MENU_FIX_SW12,	MENU_FIX_SW13,
					MENU_FIX_SW14,	MENU_FIX_SW15,	MENU_FIX_SW16}},

    {MENU_FIX_SW1,   {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
    {MENU_FIX_SW2,   {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
    {MENU_FIX_SW3,   {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
    {MENU_FIX_SW4,   {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
    {MENU_FIX_SW5,   {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
    {MENU_FIX_SW6,   {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
    {MENU_FIX_SW7,   {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
    {MENU_FIX_SW8,   {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
    {MENU_FIX_SW9,   {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
    {MENU_FIX_SW10,  {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
    {MENU_FIX_SW11,  {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
    {MENU_FIX_SW12,  {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
    {MENU_FIX_SW13,  {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
    {MENU_FIX_SW14,  {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
    {MENU_FIX_SW15,  {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
    {MENU_FIX_SW16,  {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
#elif SWITCH_NUM_MAX == 6
	{MENU_FIX, 		{MENU_FIX_PUB, 	MENU_FIX_SW1, 	MENU_FIX_SW2,	MENU_FIX_SW3, 	MENU_FIX_SW4,	MENU_FIX_SW5, 	MENU_FIX_SW6}},
 	{MENU_FIX_SW1,  {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
    {MENU_FIX_SW2,  {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
    {MENU_FIX_SW3,  {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
    {MENU_FIX_SW4,  {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
    {MENU_FIX_SW5,  {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
    {MENU_FIX_SW6,  {MENU_BH_STATUS,MENU_GLBH,      MENU_LXBH,      MENU_JDBH,      MENU_RECLOSE,   MENU_HJS,  MENU_DLYX}},
#elif SWITCH_NUM_MAX == 4
	{MENU_FIX, 		{MENU_FIX_PUB, 	MENU_FIX_SW1, 	MENU_FIX_SW2,	MENU_FIX_SW3, 	MENU_FIX_SW4}},
#elif SWITCH_NUM_MAX == 1	
	{MENU_FIX, 		{MENU_FIX_PUB, 	MENU_FIX_SW1}},
#endif
	{MENU_SOE, 		{MENU_SJSOE, 	MENU_CZSOE, 	MENU_NULL, 		MENU_NULL, 	MENU_NULL, 	MENU_NULL, 	MENU_NULL}},

	{MENU_DEBUG, 	{MENU_TEST, 	MENU_ADJUST, 	MENU_RMT,		MENU_INFIX, MENU_CODE, 	MENU_CLR,	MENU_INFO}},
	{MENU_INFO_PARA,{MENU_INFO_EQU, MENU_COMM_PARA, MENU_NULL,      MENU_NULL,  MENU_NULL,  MENU_NULL,  MENU_NULL}},
	{MENU_TABLE_INFO,{MENU_INFO_YX, MENU_INFO_YC, MENU_NULL,      MENU_NULL,  MENU_NULL,  MENU_NULL,  MENU_NULL}},
	
	{MENU_TEST, 	{MENU_TEST_KC, 	MENU_TEST_HMI, 	MENU_NULL, 		MENU_NULL, 	MENU_NULL, 	MENU_NULL, 	MENU_NULL}},
	{MENU_ADJUST, 	{MENU_ADJUST_AC,MENU_ADJUST_DC, MENU_NULL, 		MENU_NULL, 	MENU_NULL, 	MENU_NULL, 	MENU_NULL}},
	{MENU_INFO, 	{MENU_INFO_VER, MENU_INFO_CFG, 	MENU_INFO_ERR, 	MENU_INFO_DEBUG, MENU_INFO_GPRS, MENU_NULL, MENU_NULL}},

	{MENU_KR, 	{MENU_PUB_YX, MENU_SW_YX, 	MENU_NULL, 	MENU_NULL, MENU_NULL, MENU_NULL, MENU_NULL}},
	{MENU_AC, 	{MENU_PUB_YC, MENU_SW_YC, 	MENU_NULL, 	MENU_NULL, MENU_NULL, MENU_NULL, MENU_NULL}},
	{MENU_FLAG, {MENU_CHZ_FLAG,MENU_OTHERS_FLAG,MENU_NULL,MENU_NULL,MENU_NULL,MENU_NULL, MENU_NULL}}
};
const int slave_menu_num = sizeof(slave_table)/sizeof(struct slave);

// 液晶尺寸相关定义
struct lcdsize g_lcdsize;			// 当前液晶的尺寸
struct lcdsize lcd_size_default[]=	// 默认液晶尺寸
{
	{128, 32},
	{128, 64},
	{128, 64},
	{160, 160},
};
int lcdtype;						// 液晶尺寸类型
int g_hmi_type;						// 面板类型

int disp_pub_ac_index[PUB_AC_NUM_ALL][2];					// 配置或计算测量的索引
int disp_sw_ac_index[SW_AC_NUM_ALL*SWITCH_NUM_MAX+SWITCH_NUM_MAX*9][2];		// 配置或计算测量的索引 (SWITCH_NUM_MAX*9填充补偿,一个开关的遥测一页可以显示完，剩余的空行显示空白，避免偏移溢出，增加数组补偿)
struct 	page_st g_page_cur;			// 当前页面
struct 	page_st g_page_set;			// 当前设置页面
	
struct item_update g_item_update;	// 实体更新标志
struct cfg_index g_cfg_index;		
struct page_dis g_page_dis;			// 用于页面类查询显示
struct set_dis g_set_dis[5];		// 用于定值设置显示,预设最大支持一屏显示5个定值
struct action g_action;
struct disp_flag g_disp_flag;		// 菜单内的标志

/*------------------------------ 函数声明 -------------------------------------
*/
int _lcd_size_check(struct lcdsize *lcd);
int _wnd_item_init(struct page_st *ipage, struct lcdsize *isize, u8 lcd, u8 menutype,u8 menu_num);
void _page_menu_disp(u8 ifocus, u8 icur_wnd, u8 icur_wnd_item, struct item *ipage_item);
void _page_set_disp(u8 ifocus, u8 icur_wnd, u8 icur_wnd_item, struct item *ipage_item);
void _page_query_line_disp(u8 ifocus, u8 icur_wnd, u8 icur_wnd_item, struct item *ipage_item);
void _page_query_page_disp(u8 ifocus, u8 icur_wnd, u8 icur_wnd_item, struct item *ipage_item);
void _page_action_disp(u8 ifocus, u8 icur_wnd, u8 icur_wnd_item, struct item *ipage_item);
int _equ_di_index_init(void);
int _equ_do_index_init(void);
int _rtc_printf(u8 mode, char *str1, char *str2);
int _set_value_dis_init(u8 no, u8 y);
int _set_cursor_flash(u8 no, u8 x, u8 y, u8 mode);

/*------------------------------ 外部函数 -------------------------------------
外部函数供其它实体文件引用，必须仔细检查传入参数的合法性.
*/
//总菜单定义
struct page_st page_table[]=
{
//	当前菜单		父菜单		菜单类型	实体数	  屏数  屏实体数  屏号	聚焦  标题 时间 实体索引	回调函数
	{MENU_NULL,		0,0,	0,	0,		0,0,		0,	0,		0,	0,	0,	0},
	// 主菜单
	{MENU_MAIN,		MENU_MAIN,	MENU_TYPE_CH8,	MainNum,	0,		0,0,		0,	0,		0,	0,	main_disp,	_page_menu_disp},
	
	// 工况菜单(运行状态)
	{MENU_RUNSTU,	MENU_MAIN,	MENU_TYPE,		RunNum,		0,		0,0,		0,	0,		0,	0,	run_disp,	_page_menu_disp},
	// 设置菜单(系统设置)
	{MENU_SET,		MENU_MAIN,	MENU_TYPE_CH8,	SetNum,		0,		0,0,		0,	0,		0,	0,	set_disp,	_page_menu_disp},
	// 记录菜单(系统记录)
	{MENU_SOE,		MENU_MAIN,	MENU_TYPE,	    SoeNum,		0,		0,0,		0,	0,		0,	0,	soe_disp,	_page_menu_disp},
	// 维护菜单(装置维护)
	{MENU_DEBUG,	MENU_MAIN,	MENU_TYPE,   	DebugNum,	0,		0,0,		0,	0,		0,	0,	debug_disp,	_page_menu_disp},
    // 信息参数
    {MENU_INFO_PARA,MENU_MAIN,  MENU_TYPE_CH8, InfoParaNum, 0,      0,0,        0,  0,      0,  0,  info_para_disp, _page_menu_disp},
	// 点表信息
    {MENU_TABLE_INFO,MENU_MAIN,  MENU_TYPE_CH8, InfoTableNum, 0,      0,0,        0,  0,      0,  0,  info_table_disp, _page_menu_disp},

	// 开入查看
	{MENU_KR,		MENU_RUNSTU,MENU_TYPE_CH8,	kr_dispNum,	0,		0,0,		0,	0,		0,	0,	kr_disp,	_page_menu_disp},
	// 测量查看
	{MENU_AC,		MENU_RUNSTU,MENU_TYPE_CH8,	ac_dispNum,	0,		0,0,		0,	0,		0,	0,	ac_disp,	_page_menu_disp},
	// 标志查看
	{MENU_FLAG,		MENU_RUNSTU,MENU_TYPE_CH8,	flagNum,	0,		0,0,		0,	0,		0,	0,	flag_disp,	_page_menu_disp},
	// 时间查看
	{MENU_TIME,		MENU_RUNSTU,QUERY_PAGE_TYPE,	0,	0,		0,0,		0,	0,		0,	0,	0,			_page_query_page_disp},

	// 定值设置
//#if SWITCH_NUM_MAX == 1
//	{MENU_FIX,		MENU_SET,	SET_TYPE,	0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
//#else
	{MENU_FIX,		MENU_SET,	MENU_TYPE,	SetswNum,	0,		0,0,		0,	0,		0,	0,	setsw_disp,	_page_menu_disp},
//#endif
	// 装置参数
	{MENU_PARA,		MENU_SET,	SET_TYPE,	0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
	// 时间设置
	{MENU_TIMESET,	MENU_SET,	SET_TYPE,	0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
	// 电池
	{MENU_BAT,		MENU_SET,	ACTION_TYPE,0,			0,		0,0,		0,	0,		0,	0,	0,			_page_action_disp},
    // 运行参数
    {MENU_RUN_PARA, MENU_SET,   SET_TYPE,   0,          0,      0,0,        0,  0,      0,  0,  0,          _page_set_disp},
    // 故障复归
    {MENU_FAULT_RESET, MENU_SET,SET_TYPE,   0,          0,      0,0,        0,  0,      0,  0,  0,          _page_set_disp},
	// 公共、线路定值
#if SWITCH_NUM_MAX == 16
	{MENU_FIX_PUB,	MENU_FIX,	SET_TYPE,	    0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
	{MENU_FIX_SW1,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,		0,		0,0,		0,	0,		0,	0,	sw_x_disp,	_page_menu_disp},
	{MENU_FIX_SW2,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,     0,      0,0,        0,  0,      0,  0,  sw_x_disp,  _page_menu_disp},
	{MENU_FIX_SW3,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,     0,      0,0,        0,  0,      0,  0,  sw_x_disp,  _page_menu_disp},
	{MENU_FIX_SW4,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,     0,      0,0,        0,  0,      0,  0,  sw_x_disp,  _page_menu_disp},
	{MENU_FIX_SW5,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,     0,      0,0,        0,  0,      0,  0,  sw_x_disp,  _page_menu_disp},
	{MENU_FIX_SW6,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,     0,      0,0,        0,  0,      0,  0,  sw_x_disp,  _page_menu_disp},
	{MENU_FIX_SW7,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,     0,      0,0,        0,  0,      0,  0,  sw_x_disp,  _page_menu_disp},
	{MENU_FIX_SW8,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,     0,      0,0,        0,  0,      0,  0,  sw_x_disp,  _page_menu_disp},
	{MENU_FIX_SW9,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,     0,      0,0,        0,  0,      0,  0,  sw_x_disp,  _page_menu_disp},
	{MENU_FIX_SW10,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,     0,      0,0,        0,  0,      0,  0,  sw_x_disp,  _page_menu_disp},
	{MENU_FIX_SW11,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,     0,      0,0,        0,  0,      0,  0,  sw_x_disp,  _page_menu_disp},
	{MENU_FIX_SW12,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,     0,      0,0,        0,  0,      0,  0,  sw_x_disp,  _page_menu_disp},
	{MENU_FIX_SW13,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,     0,      0,0,        0,  0,      0,  0,  sw_x_disp,  _page_menu_disp},
	{MENU_FIX_SW14,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,     0,      0,0,        0,  0,      0,  0,  sw_x_disp,  _page_menu_disp},
	{MENU_FIX_SW15,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,     0,      0,0,        0,  0,      0,  0,  sw_x_disp,  _page_menu_disp},
	{MENU_FIX_SW16,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,     0,      0,0,        0,  0,      0,  0,  sw_x_disp,  _page_menu_disp},
#elif SWITCH_NUM_MAX == 8
	{MENU_FIX_PUB,	MENU_FIX,	SET_TYPE,	0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
	{MENU_FIX_SW1,	MENU_FIX,	SET_TYPE,	0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
	{MENU_FIX_SW2,	MENU_FIX,	SET_TYPE,	0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
	{MENU_FIX_SW3,	MENU_FIX,	SET_TYPE,	0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
	{MENU_FIX_SW4,	MENU_FIX,	SET_TYPE,	0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
	{MENU_FIX_SW5,	MENU_FIX,	SET_TYPE,	0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
	{MENU_FIX_SW6,	MENU_FIX,	SET_TYPE,	0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
	{MENU_FIX_SW7,	MENU_FIX,	SET_TYPE,	0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
	{MENU_FIX_SW8,	MENU_FIX,	SET_TYPE,	0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
#elif SWITCH_NUM_MAX == 6
	{MENU_FIX_PUB,	MENU_FIX,	SET_TYPE,	    0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
	{MENU_FIX_SW1,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,		0,		0,0,		0,	0,		0,	0,	sw_x_disp,	_page_menu_disp},
	{MENU_FIX_SW2,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,     0,      0,0,        0,  0,      0,  0,  sw_x_disp,  _page_menu_disp},
	{MENU_FIX_SW3,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,     0,      0,0,        0,  0,      0,  0,  sw_x_disp,  _page_menu_disp},
	{MENU_FIX_SW4,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,     0,      0,0,        0,  0,      0,  0,  sw_x_disp,  _page_menu_disp},
	{MENU_FIX_SW5,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,     0,      0,0,        0,  0,      0,  0,  sw_x_disp,  _page_menu_disp},
	{MENU_FIX_SW6,	MENU_FIX,	MENU_TYPE_CH8,	SWxNum,     0,      0,0,        0,  0,      0,  0,  sw_x_disp,  _page_menu_disp},
#elif SWITCH_NUM_MAX == 4
	{MENU_FIX_PUB,	MENU_FIX,	SET_TYPE,	0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
	{MENU_FIX_SW1,	MENU_FIX,	SET_TYPE,	0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
	{MENU_FIX_SW2,	MENU_FIX,	SET_TYPE,	0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
	{MENU_FIX_SW3,	MENU_FIX,	SET_TYPE,	0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
	{MENU_FIX_SW4,	MENU_FIX,	SET_TYPE,	0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
#elif SWITCH_NUM_MAX == 1
	{MENU_FIX_PUB,	MENU_FIX,	SET_TYPE,	0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
	{MENU_FIX_SW1,	MENU_FIX,	SET_TYPE,	0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
#endif

	// 事件查看
	{MENU_SJSOE,	MENU_SOE,	QUERY_PAGE_TYPE,	0,	0,		0,0,		0,	0,		0,	0,	0,			_page_query_page_disp},
	// 操作查看
	{MENU_CZSOE,	MENU_SOE,	QUERY_PAGE_TYPE,	0,	0,		0,0,		0,	0,		0,	0,	0,			_page_query_page_disp},

    // 固有参数
    {MENU_INFO_EQU, MENU_INFO_PARA, QUERY_PAGE_TYPE,      0,  0,      0,0,        0,  0,      0,  0,  0,    _page_query_page_disp},
    // 通讯参数
    {MENU_COMM_PARA,MENU_INFO_PARA, QUERY_PAGE_TYPE,      0,  0,      0,0,        0,  0,      0,  0,  0,    _page_query_page_disp},
	// 遥信点表
    {MENU_INFO_YX, MENU_TABLE_INFO, QUERY_PAGE_TYPE,      0,  0,      0,0,        0,  0,      0,  0,  0,    _page_query_page_disp},
    // 遥测点表
    {MENU_INFO_YC,MENU_TABLE_INFO, QUERY_PAGE_TYPE,      0,  0,      0,0,        0,  0,      0,  0,  0,    _page_query_page_disp},

	// 测试菜单
	{MENU_TEST,		MENU_DEBUG,	MENU_TYPE,	TestNum,	0,		0,0,		0,	0,		0,	0,	test_disp,	_page_menu_disp},
	// 校准菜单
	{MENU_ADJUST,	MENU_DEBUG,	MENU_TYPE,	AdjustNum,	0,		0,0,		0,	0,		0,	0,	adjust_disp,_page_menu_disp},
	// 遥控器菜单
	{MENU_RMT,		MENU_DEBUG,	ACTION_TYPE,RmtNum,		0,		0,0,		0,	0,		0,	0,	rmt_disp,	_page_action_disp},
	// 内部定值
	{MENU_INFIX,	MENU_DEBUG,	SET_TYPE,	0,			0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
	// 用户密码修改
	{MENU_CODE,		MENU_DEBUG,	SET_TYPE,	CodeNum,	0,		0,0,		0,	0,		0,	0,	item_code,	_page_set_disp},
	// 操作清除
	{MENU_CLR,		MENU_DEBUG,	ACTION_TYPE,clrsoeNum,	0,		0,0,		0,	0,		0,	0,	clr_soe,	_page_action_disp},
	// 信息查看
	{MENU_INFO,		MENU_DEBUG,	MENU_TYPE,	InfoNum,	0,		0,0,		0,	0,		0,	0,	item_info,	_page_menu_disp},

	// 开出测试
	{MENU_TEST_KC,	MENU_TEST,	ACTION_TYPE,0,			0,		0,0,		0,	0,		0,	0,	0,			_page_action_disp},
	// 人机测试
	{MENU_TEST_HMI,	MENU_TEST,	ACTION_TYPE,hmitestNum,	0,		0,0,		0,	0,		0,	0,	hmi_test,	_page_action_disp},

	// 交流校准
	{MENU_ADJUST_AC,MENU_ADJUST,ACTION_TYPE,adjustacNum,0,		0,0,		0,	0,		0,	0,	adjust_ac,	_page_action_disp},
	// 直流校准
	{MENU_ADJUST_DC,MENU_ADJUST,ACTION_TYPE,adjustdcNum,0,		0,0,		0,	0,		0,	0,	adjust_dc,	_page_action_disp},

	// 版本信息
	{MENU_INFO_VER,	MENU_INFO,	QUERY_1LINE_TYPE,InfoVerNum,0,	0,0,		0,	0,		0,	0,	ver_info,	_page_query_line_disp},
	// 配置信息
	{MENU_INFO_CFG,	MENU_INFO,	QUERY_1LINE_TYPE,InfoCfgNum,0,	0,0,		0,	0,		0,	0,	cfg_info,	_page_query_line_disp},
	// 错误信息
	{MENU_INFO_ERR,	MENU_INFO,	QUERY_PAGE_TYPE,0,		0,		0,0,		0,	0,		0,	0,	0,			_page_query_page_disp},
	// 调试信息
	{MENU_INFO_DEBUG,MENU_INFO,	QUERY_PAGE_TYPE,0,		0,		0,0,		0,	0,		0,	0,	0,			_page_query_page_disp},
	// GPRS信息
	{MENU_INFO_GPRS,MENU_INFO,	QUERY_PAGE_TYPE,0,		0,		0,0,		0,	0,		0,	0,	0,			_page_query_page_disp},

	//保护状态
	{MENU_BH_STATUS, MENU_FIX, SET_TYPE,0,     0,      0,0,        0,  0,      0,  0,  0,        _page_set_disp},

    //过流保护
    {MENU_GLBH, MENU_FIX,   SET_TYPE,0,      0,      0,0,        0,  0,      0,  0,  0,          _page_set_disp},

    //零序保护
    {MENU_LXBH, MENU_FIX,   SET_TYPE,0,      0,      0,0,        0,  0,      0,  0,  0,          _page_set_disp},

    //接地保护
    {MENU_JDBH, MENU_FIX,   SET_TYPE,0,      0,      0,0,        0,  0,      0,  0,  0,          _page_set_disp},

    //重合闸
    {MENU_RECLOSE, MENU_FIX, SET_TYPE,0,     0,      0,0,        0,  0,      0,  0,  0,          _page_set_disp},  

	//后加速
	{MENU_HJS, 	MENU_FIX, 	 SET_TYPE,0,     0,      0,0,        0,  0,      0,  0,  0,        _page_set_disp},

	//电流越限
	{MENU_DLYX, 	 MENU_FIX, SET_TYPE,0,     0,      0,0,        0,  0,      0,  0,  0,        _page_set_disp},
	
	//公共遥信
	{MENU_PUB_YX, 	 MENU_KR, QUERY_1LINE_TYPE,0,     0,      0,0,        0,  0,      0,  0,  0,        _page_query_line_disp},
	//开关遥信
	{MENU_SW_YX, 	 MENU_KR, QUERY_1LINE_TYPE,0,     0,      0,0,        0,  0,      0,  0,  0,        _page_query_line_disp},

	//公共遥测
	{MENU_PUB_YC, 	 MENU_AC, QUERY_1LINE_TYPE,0,     0,      0,0,        0,  0,      0,  0,  0,        _page_query_line_disp},
	//开关遥测
	{MENU_SW_YC, 	 MENU_AC, QUERY_1LINE_TYPE,0,     0,      0,0,        0,  0,      0,  0,  0,        _page_query_line_disp},

	//重合闸标志
	{MENU_CHZ_FLAG, 	 MENU_FLAG, QUERY_1LINE_TYPE,0,     0,      0,0,        0,  0,      0,  0,  0,  _page_query_line_disp},
	//其它标志
	{MENU_OTHERS_FLAG, 	 MENU_FLAG, QUERY_1LINE_TYPE,othersflagNum, 0,0,0,0,0,  0,  0,  others_flag_disp,_page_query_line_disp},
	
	// 输入密码
	{MENU_PASSWORD,	MENU_NULL,	SET_TYPE,		0,		0,		0,0,		0,	0,		0,	0,	0,			_page_set_disp},
	// 密码错误
	{MENU_PASSERR,	MENU_NULL,	QUERY_PAGE_TYPE,0,		0,		0,0,		0,	0,		0,	0,	0,			_page_query_page_disp},

	// 退出保存
	{MENU_SAVE,		MENU_NULL,	ACTION_TYPE,is_saveNum,	0,		0,0,		0,	0,		0,	0,	is_save,	_page_action_disp},
	// 保存结果
	{MENU_SAVE_RESULT,MENU_NULL,QUERY_PAGE_TYPE,0,		0,		0,0,		0,	0,		0,	0,	0,			_page_query_page_disp},

	// 定值范围
	{MENU_SET_RANGE,MENU_NULL,	QUERY_PAGE_TYPE,0,		0,		0,0,		0,	0,		0,	0,	0,			_page_query_page_disp},

	//校准结果
	{MENU_ADJUST_RESULT,MENU_ADJUST_AC,QUERY_PAGE_TYPE,	0,		0,	0,0,	0,	0,		0,	0,	0,			_page_query_page_disp},//xj 2015.5.9
	
	// 突发事件
	{MENU_EVENT,	MENU_RUNSTU,QUERY_PAGE_TYPE,0,		0,		0,0,		0,	0,		0,	0,	0,			_page_query_page_disp},

	// 遥控配对
	{MENU_RMT_PAIR,	MENU_RMT,	QUERY_PAGE_TYPE,0,		0,		0,0,		0,	0,		0,	0,	0,			_page_query_page_disp},
	// 遥控清除配对
	{MENU_DEL_PAIR,	MENU_RMT,	QUERY_PAGE_TYPE,0,		0,		0,0,		0,	0,		0,	0,	0,			_page_query_page_disp},
};
/******************************************************************************
函数名称：	menudesc_init
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	菜单初始化。
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
int menudesc_init(u8 lcd_size)
{
	int i, sw, num;
	int index_begin;
	int occupy_line=0; 	// 被占用的行，以字符行为单位，16点
	int write_line = 0;
	u8 remainder = 0;
	u8 extend_part[2][SWITCH_NUM_MAX] = {{0},{0}};

	g_lcd_size = lcd_size;
	g_lcdsize.x = lcd_size_default[lcd_size-1].x;
	g_lcdsize.y = lcd_size_default[lcd_size-1].y;
	// 获取液晶类型
	lcdtype = _lcd_size_check(&g_lcdsize);
	if (lcdtype < 0)
	{
		rt_printf("lcd_x = %d, lcd_y = %d\r\n",g_lcdsize.x, g_lcdsize.y);
		g_lcdsize.x = 128;
		g_lcdsize.y = 64;
	}

	/**********************开入查询初始化**********************/
	//公共
	num=0;
	for(i=0;i<PUB_DI_NUM;i++)
	{
		if((short)g_sw_pub.di_cfg_index[i]!=INDEX_INVALLID)  //此遥信有配置
		{
			num++;
		}
	}

	item_pub_kr = rt_malloc(num * sizeof(struct item));
	if(item_pub_kr == NULL)
	{
		return -2; 	
	}	
	// 获取内容
	for (i=0; i<num; i++)
	{
		item_pub_kr[i].type = QUERY_PUB_KR;
		item_pub_kr[i].no = i;
	}
		
	page_table[MENU_PUB_YX].item_num = num;
	page_table[MENU_PUB_YX].page_item = item_pub_kr;

	//开关
	//开关遥信作特殊处理 modify by ew 20231113
	if(lcdtype == MID || lcdtype == BIG)
	{
		//屏幕类型是MID或BIG的话就增加标题
		//2*8标题汉字占用一行
		occupy_line = 2;
		//每屏可以容纳的实体数
		write_line = (g_lcdsize.y/8 - occupy_line)/2;
	}

	num=0;
	for(sw=0; sw<g_sw_num; sw++)
	{
		for(i=0;i<SW_DI_NUM;i++)
		{
			if((short)g_sw[sw].di_cfg_index[i]!=INDEX_INVALLID)  //此遥信有配置
			{				
				num++;
			}
		}
		remainder = (num % write_line);
		extend_part[0][sw] = num;
		if(remainder !=0 )
		{
			num += (write_line-remainder);
		}
		extend_part[1][sw] = num;
	}

	item_sw_kr = rt_malloc(num * sizeof(struct item));
	if(item_sw_kr == NULL)
	{
		return -2; 	
	}	

	// 获取内容
	sw = 0;
	for (i=0; i<num; i++)
	{
		if(i < extend_part[0][sw])
		{
			item_sw_kr[i].type = QUERY_SW_KR;	
		}
		else
		{
			if(i < extend_part[1][sw])
				item_sw_kr[i].type = QUERY_NUM;//遥信特殊处理，不显示
			else
			{
				sw++;
				if(i < extend_part[0][sw])
				{
					item_sw_kr[i].type = QUERY_SW_KR;
				}
			}
		}
		item_sw_kr[i].no = i;
	}
		
	page_table[MENU_SW_YX].item_num = num;
	page_table[MENU_SW_YX].page_item = item_sw_kr;
	/**********************采样查询初始化**********************/
	memset(disp_pub_ac_index, 0, sizeof(disp_pub_ac_index));
	num=0;
	for(i=0; i<PUB_AC_NUM; i++)
	{
		if ((g_ui[i].chn_index!=CFG_ADC_CHANNEL_ZERO)  
			|| (g_ui[i].ui_base_make!=-1))
		{
			disp_pub_ac_index[num][0] = 0;
			disp_pub_ac_index[num][1] = i;
			num++;
		}
	}
	
	for(i=PUB_AC_NUM; i<PUB_AC_NUM+7; i++)
	{
		//DTUv4不在液晶显示
		if(i == PUB_AC_IN_V_UNBALANCE1 || i == PUB_AC_IN_V_UNBALANCE2 \
		|| i == PUB_AC_IN_UZ1 || i == PUB_AC_IN_UZ2 || i == PUB_AC_IN_F2)
			continue;

		disp_pub_ac_index[num][0] = 0;
		disp_pub_ac_index[num][1] = i;
		num++;
	}
	
	item_pub_ac = rt_malloc(num * sizeof(struct item));
	if(item_pub_ac == NULL)
	{
		return -3; 	
	}	
	// 获取内容
	for (i=0; i<num; i++)
	{
		item_pub_ac[i].type = QUERY_PUB_AC;
		item_pub_ac[i].no = i;
	}
	page_table[MENU_PUB_YC].item_num = num;
	page_table[MENU_PUB_YC].page_item = item_pub_ac;

	memset(disp_sw_ac_index, 0, sizeof(disp_sw_ac_index));
	num = 0;
	for(sw=0; sw<g_sw_num; sw++)
	{
		index_begin = UI_SW_INDEX_BEGIN(sw);
		for(i=0; i<SW_AC_NUM+4; i++)
		{
			if (i<SW_AC_NUM)
			{
				if ((g_ui[index_begin+i].chn_index!=CFG_ADC_CHANNEL_ZERO)
					|| (g_ui[index_begin+i].ui_base_make!=-1))
				{				
					disp_sw_ac_index[num][0] = sw+1;
					disp_sw_ac_index[num][1] = i;
					num++;
				}
			}
			else
			{
				disp_sw_ac_index[num][0] = sw+1;
				disp_sw_ac_index[num][1] = i;
				num++;				
			}
		}
		remainder = (num % write_line);
		extend_part[0][sw] = num;
		if(remainder !=0 )
		{
			num += (write_line-remainder);
		}
		extend_part[1][sw] = num;
	}	


	item_sw_ac = rt_malloc(num * sizeof(struct item));
	if(item_sw_ac == NULL)
	{
		return -3; 	
	}	
	// 获取内容
	sw = 0;
	for (i=0; i<num; i++)
	{
		if(i < extend_part[0][sw])
		{
			item_sw_ac[i].type = QUERY_SW_AC;	
		}
		else
		{
			if(i < extend_part[1][sw])
				item_sw_ac[i].type = QUERY_NUM;//遥测特殊处理，不显示
			else
			{
				sw++;
				if(i < extend_part[0][sw])
				{
					item_sw_ac[i].type = QUERY_SW_AC;
				}
			}
		}

		item_sw_ac[i].no = i;
	}
	page_table[MENU_SW_YC].item_num = num;
	page_table[MENU_SW_YC].page_item = item_sw_ac;
	/**********************时间查询初始化**********************/
	item_time = rt_malloc(TIME_NUM * sizeof(struct item));
	if(item_time == NULL)
	{
		return -4; 	
	}	
	// 获取内容
	for (i=0; i<TIME_NUM; i++)
	{
		item_time[i].type = QUERY_TIME;
		item_time[i].no = i;
	}
	page_table[MENU_TIME].item_num = TIME_NUM;
	page_table[MENU_TIME].page_item = item_time;

	/**********************定值初始化**********************/
	// 分配内存

	// 公共定值
	item_fix = rt_malloc(g_pub_setdisp.num * sizeof(struct item));
	if(item_fix == NULL)
	{
		return -5; 	
	}
	//公共定值
	for (i=0; i<g_pub_setdisp.num; i++)
	{
		item_fix[i].type = 0; 
		item_fix[i].no = i;
	}	
	page_table[MENU_FIX_PUB].item_num = g_pub_setdisp.num;
	page_table[MENU_FIX_PUB].page_item = item_fix;

	//过流保护
	num = class_GLBH.num;
	item_fix_GLBH = rt_malloc(num * sizeof(struct item));
	if(item_fix_GLBH == NULL)
	{
		return -5; 	
	}
	// 获取内容
	for (i=0; i<num; i++)
	{
	    item_fix_GLBH[i].type = 0;
	    item_fix_GLBH[i].no = i;
	}	
	page_table[MENU_GLBH].item_num  = num;
	page_table[MENU_GLBH].page_item = item_fix_GLBH;
	
    //零序保护
    num = class_LXBH.num;
    item_fix_LXBH = rt_malloc(num * sizeof(struct item));
    if(item_fix_LXBH == NULL)
    {
        return -5;
    }
    // 获取内容
    for (i=0; i<num; i++)
    {
        item_fix_LXBH[i].type = 0;
        item_fix_LXBH[i].no = i;
    }
    page_table[MENU_LXBH].item_num  = num;
    page_table[MENU_LXBH].page_item = item_fix_LXBH;

    //接地保护
    num = class_JDBH.num;
    item_fix_JDBH = rt_malloc(num * sizeof(struct item));
    if(item_fix_JDBH == NULL)
    {
        return -5;
    }
    // 获取内容
    for (i=0; i<num; i++)
    {
        item_fix_JDBH[i].type = 0;
        item_fix_JDBH[i].no = i;
    }
    page_table[MENU_JDBH].item_num  = num;
    page_table[MENU_JDBH].page_item = item_fix_JDBH;

    //重合闸
    num = class_reclose.num;
    item_fix_CHZ = rt_malloc(num * sizeof(struct item));
    if(item_fix_CHZ == NULL)
    {
        return -5;
    }
    // 获取内容
    for (i=0; i<num; i++)
    {
        item_fix_CHZ[i].type = 0;
        item_fix_CHZ[i].no = i;
    }
    page_table[MENU_RECLOSE].item_num  = num;
    page_table[MENU_RECLOSE].page_item = item_fix_CHZ;

	// 保护状态
    num = class_BH_sts.num;
    item_fix_BH_sts = rt_malloc(num * sizeof(struct item));
    if(item_fix_BH_sts == NULL)
    {
        return -5;
    }
    // 获取内容
    for (i=0; i<num; i++)
    {
    	item_fix_BH_sts[i].type = 0;
    	item_fix_BH_sts[i].no = i;
    }
    page_table[MENU_BH_STATUS].item_num  = num;
    page_table[MENU_BH_STATUS].page_item = item_fix_BH_sts;

	//电流越限
    num = class_DLYX.num;
    item_fix_DLYX_sts = rt_malloc(num * sizeof(struct item));
    if(item_fix_DLYX_sts == NULL)
    {
        return -5;
    }
    // 获取内容
    for (i=0; i<num; i++)
    {
    	item_fix_DLYX_sts[i].type = 0;
    	item_fix_DLYX_sts[i].no = i;
    }
    page_table[MENU_DLYX].item_num  = num;
    page_table[MENU_DLYX].page_item = item_fix_DLYX_sts;

	//后加速
    num = class_HJS.num;
    item_fix_HJS_sts = rt_malloc(num * sizeof(struct item));
    if(item_fix_HJS_sts == NULL)
    {
        return -5;
    }
    // 获取内容
    for (i=0; i<num; i++)
    {
    	item_fix_HJS_sts[i].type = 0;
    	item_fix_HJS_sts[i].no = i;
    }
    page_table[MENU_HJS].item_num  = num;
    page_table[MENU_HJS].page_item = item_fix_HJS_sts;



	/**********************装置参数初始化**********************/
	// 分配内存
	item_para = rt_malloc(EQUIP_PARA_NUMBER * sizeof(struct item));
	if(item_para == NULL)
	{
		return -6; 	
	}
	// 获取内容
	for (i=0; i<EQUIP_PARA_NUMBER; i++)
	{
		item_para[i].type = tEquipParaTable[i].wType;
		item_para[i].no = i;
	}	
	page_table[MENU_PARA].item_num  = EQUIP_PARA_NUMBER;
	page_table[MENU_PARA].page_item = item_para;

    /**********************运行参数初始化**********************/
    // 分配内存
	item_run_para = rt_malloc(g_rmt_para_disp.total * sizeof(struct item));
    if(item_run_para == NULL)
    {
        return -23;
    }

    // 获取内容
    for (i=0; i<g_rmt_para_disp.total; i++)
    {
        item_run_para[i].type = 0; 
        item_run_para[i].no = i;
    }
    page_table[MENU_RUN_PARA].item_num  = g_rmt_para_disp.total;
    page_table[MENU_RUN_PARA].page_item = item_run_para;
    /**********************故障复归初始化**********************/
    // 分配内存
    item_fault_reset = rt_malloc(g_faultRst_setdisp.num * sizeof(struct item));
    if(item_fault_reset == NULL)
    {
        return -24;
    }

    // 获取内容
    for (i=0; i<g_faultRst_setdisp.num; i++)
    {
        item_fault_reset[i].type = 0;
        item_fault_reset[i].no = i;
    }
    page_table[MENU_FAULT_RESET].item_num  = g_faultRst_setdisp.num;
    page_table[MENU_FAULT_RESET].page_item = item_fault_reset;
	
	/**********************内部定值初始化**********************/
	// 分配内存
	item_infix = rt_malloc(CSTSET_NUMBER * sizeof(struct item));
	if(item_infix == NULL)
	{
		return -7; 	
	}
	// 获取内容
	for (i=0; i<CSTSET_NUMBER; i++)
	{
		item_infix[i].type = tCstSetTable[i].wType;
		item_infix[i].no = i;
	}	
	page_table[MENU_INFIX].item_num = CSTSET_NUMBER;
	page_table[MENU_INFIX].page_item = item_infix;
	
	/**********************时间初始化**********************/
	// 分配内存
	item_timeset = rt_malloc(TIME_SET_NUMBER * sizeof(struct item));
	if(item_timeset == NULL)
	{
		return -8; 	
	}
	// 获取内容
	for (i=0; i<TIME_SET_NUMBER; i++)
	{
	    item_timeset[i].type = tTimeTable[i].wType;
	    item_timeset[i].no = i;
	}	
	page_table[MENU_TIMESET].item_num = TIME_SET_NUMBER;
	page_table[MENU_TIMESET].page_item = item_timeset;

	/**********************重合闸充电标志**********************/
	// 分配内存
	// 根据开关数动态分配
	item_chz_flag = rt_malloc(g_sw_num * sizeof(struct item));
	if(item_chz_flag == NULL)
	{
		return -25; 	
	}
	// 获取内容
	for (i=0; i<g_sw_num; i++)
	{
	    item_chz_flag[i].type = QUERY_CHZ_FLAG;
	    item_chz_flag[i].no = i;
	}	
	page_table[MENU_CHZ_FLAG].item_num = g_sw_num;
	page_table[MENU_CHZ_FLAG].page_item = item_chz_flag;

	/**********************事件查询初始化**********************/
	// 以一个事件为一页面，实体数量由EVENT_SHOW结构的str预分配
	item_sjsoe = rt_malloc(8*sizeof(struct item));
	if(item_sjsoe == NULL)
	{
		return -9; 	
	}	
	// 获取内容
	for (i=0; i<8; i++)
	{
		item_sjsoe[i].type = QUERY_SJSOE;
		item_sjsoe[i].no = i;
	}
	page_table[MENU_SJSOE].item_num = 8;
	page_table[MENU_SJSOE].page_item = item_sjsoe;	

	/**********************操作查询初始化**********************/
	// 以一个事件为一页面，实体数量由EVENT_SHOW结构的str预分配
	item_czsoe = rt_malloc(8 * sizeof(struct item));
	if(item_czsoe == NULL)
	{
		return -10; 	
	}	
	// 获取内容
	for (i=0; i<8; i++)
	{
		item_czsoe[i].type = QUERY_CZSOE;
		item_czsoe[i].no = i;
	}
	page_table[MENU_CZSOE].item_num = 8;
	page_table[MENU_CZSOE].page_item = item_czsoe;	
	
	/**********************开出测试初始化**********************/
	num=0;
	for(i=0;i<PUB_DO_NUM;i++)
	{
		if((short)g_sw_pub.do_cfg_index[i]!=INDEX_INVALLID)  //有配置
		{
			num++;
		}
	}
	for(sw=0; sw<SWITCH_NUM_MAX; sw++)
	{
		for(i=0;i<SW_DO_NUM;i++)
		{
			if((short)g_sw[sw].do_cfg_index[i]!=INDEX_INVALLID)  //有配置
			{				
				num++;
			}
		}
	}
	item_test_kc = rt_malloc(num * sizeof(struct item));
	if(item_test_kc == NULL)
	{
		return -12; 	
	}	
	// 获取内容
	for (i=0; i<num; i++)
	{
		item_test_kc[i].type = ACTION_TEST_KC;
		item_test_kc[i].no = i;
	}
	page_table[MENU_TEST_KC].item_num = num;
	page_table[MENU_TEST_KC].page_item = item_test_kc;
	
	/**********************电池测试初始化**********************/
	num=0;
	for(i=PUB_DO_DCHH;i<PUB_DO_HHTC+1;i++)
	{
		if((short)g_sw_pub.do_cfg_index[PUB_DO_DCHH]!=INDEX_INVALLID)  //此有配置
		{
			num++;
		}
	}
	item_bat = rt_malloc(num * sizeof(struct item));
	if(item_bat == NULL)
	{
		return -12; 	
	}	
	// 获取内容
	for (i=0; i<num; i++)
	{
		item_bat[i].type = ACTION_BAT;
		item_bat[i].no = i;
	}
	page_table[MENU_BAT].item_num = num;
	page_table[MENU_BAT].page_item = item_bat;
	/**********************错误信息初始化**********************/
	// 以所有错误信息为一页面，页面实体为8，即支持8个错误
	item_info_err = rt_malloc(INFO_ERR_QUERY*sizeof(struct item));
	if(item_info_err == NULL)
	{
		return -13; 	
	}	
	// 获取内容
	for (i=0; i<INFO_ERR_QUERY; i++)
	{
		item_info_err[i].type = QUERY_ERR;
		item_info_err[i].no = i;
	}
	page_table[MENU_INFO_ERR].item_num = INFO_ERR_QUERY;
	page_table[MENU_INFO_ERR].page_item = item_info_err;	

	/**********************调试信息初始化**********************/
	// 以所有调试信息为一页面，页面实体为6，即支持6个调试信息，一个占两行
	item_info_debug = rt_malloc(INFO_DEBUG_QUERY*sizeof(struct item));
	if(item_info_debug == NULL)
	{
		return -14; 	
	}	
	// 获取内容
	for (i=0; i<INFO_DEBUG_QUERY; i++)
	{
		item_info_debug[i].type = QUERY_DEBUG;
		item_info_debug[i].no = i;
	}
	page_table[MENU_INFO_DEBUG].item_num = INFO_DEBUG_QUERY;
	page_table[MENU_INFO_DEBUG].page_item = item_info_debug;	

	/**********************GPRS信息初始化**********************/
	// 以所有GPRS信息为一页面，页面实体为16，即支持16个调试信息，一个占两行
	item_info_gprs = rt_malloc(INFO_GPRS_QUERY*sizeof(struct item));
	if(item_info_gprs == NULL)
	{
		return -14; 	
	}	
	// 获取内容
	for (i=0; i<INFO_GPRS_QUERY; i++)
	{
		item_info_gprs[i].type = QUERY_GPRS;
		item_info_gprs[i].no = i;
	}
	page_table[MENU_INFO_GPRS].item_num = INFO_GPRS_QUERY;
	page_table[MENU_INFO_GPRS].page_item = item_info_gprs;	

	/**********************装置信息初始化**********************/
    // 以所有装置信息为一页面， 一条占两行
	item_info_equ = rt_malloc(MAX_LINE_PER_PAGE*sizeof(struct item));
    if(item_info_equ == NULL)
    {
        return -21;
    }
    // 获取内容
    for (i=0; i<MAX_LINE_PER_PAGE; i++)
    {
        item_info_equ[i].type = QUERY_EQU;
        item_info_equ[i].no   = i;
    }
    page_table[MENU_INFO_EQU].item_num  = MAX_LINE_PER_PAGE;
    page_table[MENU_INFO_EQU].page_item = item_info_equ;

    /**********************通讯参数初始化**********************/
    // 以所有装置信息为一页面， 一条占两行
    item_comm_para = rt_malloc(MAX_LINE_PER_PAGE*sizeof(struct item));
    if(item_comm_para == NULL)
    {
        return -22;
    }
    // 获取内容
    for (i=0; i<MAX_LINE_PER_PAGE; i++)
    {
        item_comm_para[i].type = QUERY_COMM_PARA;
        item_comm_para[i].no   = i;
    }
    page_table[MENU_COMM_PARA].item_num  = MAX_LINE_PER_PAGE;
    page_table[MENU_COMM_PARA].page_item = item_comm_para;

	/**********************遥信点表初始化**********************/
    // 以所有遥信信息为一页面， 一条占两行
	item_info_yx = rt_malloc(MAX_LINE_PER_PAGE*sizeof(struct item));
    if(item_info_yx == NULL)
    {
        return -21;
    }
    // 获取内容
    for (i=0; i<MAX_LINE_PER_PAGE; i++)
    {
        item_info_yx[i].type = QUERY_YX;
        item_info_yx[i].no   = i;
    }
    page_table[MENU_INFO_YX].item_num  = MAX_LINE_PER_PAGE;
    page_table[MENU_INFO_YX].page_item = item_info_yx;

    /**********************遥测点表初始化**********************/
    // 以所有遥测信息为一页面， 一条占两行
    item_info_yc = rt_malloc(MAX_LINE_PER_PAGE*sizeof(struct item));
    if(item_info_yc == NULL)
    {
        return -22;
    }
    // 获取内容
    for (i=0; i<MAX_LINE_PER_PAGE; i++)
    {
        item_info_yc[i].type = QUERY_YC;
        item_info_yc[i].no   = i;
    }
    page_table[MENU_INFO_YC].item_num  = MAX_LINE_PER_PAGE;
    page_table[MENU_INFO_YC].page_item = item_info_yc;

	/**********************输入密码初始化**********************/
	// 分配内存
	item_password = rt_malloc(1 * sizeof(struct item));
	if(item_password == NULL)
	{
		return -15; 	
	}
	// 获取内容
	item_password[0].type = tCodeTable[0].wType;
	item_password[0].no = 0;
	
	page_table[MENU_PASSWORD].item_num = 1;
	page_table[MENU_PASSWORD].page_item = item_password;

	/**********************密码错误初始化**********************/
	// 以所有错误信息为一页面，页面占用2行
	item_passerr = rt_malloc(2 * sizeof(struct item));
	if(item_passerr == NULL)
	{
		return -16; 	
	}
	// 获取内容
	for (i=0; i<2; i++)
	{
		item_passerr[i].type = QUERY_PASSERR;
		item_passerr[i].no = 0;
	}
	page_table[MENU_PASSERR].item_num = 2;
	page_table[MENU_PASSERR].page_item = item_passerr;

	/**********************保存结果初始化**********************/
	// 以保存结果信息为一页面，页面占用1行
	item_saveresult = rt_malloc(1 * sizeof(struct item));
	if(item_saveresult == NULL)
	{
		return -17; 	
	}
	// 获取内容
	for (i=0; i<1; i++)
	{
		item_saveresult[i].type = QUERY_SAVERESULT;
		item_saveresult[i].no = 0;
	}
	page_table[MENU_SAVE_RESULT].item_num = 1;
	page_table[MENU_SAVE_RESULT].page_item = item_saveresult;

	/**********************定值范围初始化**********************/
	// 以保存结果信息为一页面，页面占用2行
	item_setrange = rt_malloc(2 * sizeof(struct item));
	if(item_setrange == NULL)
	{
		return -18; 	
	}
	// 获取内容
	for (i=0; i<2; i++)
	{
		item_setrange[i].type = QUERY_SETRANGE;
		item_setrange[i].no = 0;
	}
	page_table[MENU_SET_RANGE].item_num = 2;
	page_table[MENU_SET_RANGE].page_item = item_setrange;

	/**********************突发事件查询初始化**********************/
	// 以一个事件为一页面，实体数量由EVENT_SHOW结构的str预分配
	item_event = rt_malloc(8*sizeof(struct item));
	if(item_event == NULL)
	{
		return -19; 	
	}	
	// 获取内容
	for (i=0; i<8; i++)
	{
		item_event[i].type = QUERY_EVENT;
		item_event[i].no = i;
	}
	page_table[MENU_EVENT].item_num = 8;
	page_table[MENU_EVENT].page_item = item_event;	

	/**********************遥控器配对查询初始化**********************/
	item_rmtpair = rt_malloc(2*sizeof(struct item));
	if(item_rmtpair == NULL)
	{
		return -20; 	
	}	
	// 获取内容
	for (i=0; i<2; i++)
	{
		item_rmtpair[i].type = QUERY_RMTPAIR;
		item_rmtpair[i].no = i;
	}
	page_table[MENU_RMT_PAIR].item_num = 2;
	page_table[MENU_RMT_PAIR].page_item = item_rmtpair;	

	/**********************遥控器配对查询初始化**********************/
	item_delpair = rt_malloc(2*sizeof(struct item));
	if(item_delpair == NULL)
	{
		return -20; 	
	}	
	// 获取内容
	for (i=0; i<2; i++)
	{
		item_delpair[i].type = QUERY_DELPAIR;
		item_delpair[i].no = i;
	}
	page_table[MENU_DEL_PAIR].item_num = 2;
	page_table[MENU_DEL_PAIR].page_item = item_delpair;	
	
	/**********************校准结果初始化**********************/
	// 以校准结果信息为一页面，页面占用2行
	item_adjustresult = rt_malloc(1 * sizeof(struct item));	
	if(item_adjustresult == NULL)
	{
		return -20;
	}
	
	for (i=0; i<1; i++)
	{
		item_adjustresult[i].type = QUERY_ADJUSTRESULT;
		item_adjustresult[i].no = 0;
	}

	page_table[MENU_ADJUST_RESULT].item_num = 1;
	page_table[MENU_ADJUST_RESULT].page_item = item_adjustresult;

	// 窗体、实体初始化
	for (i=0; i<MENU_NUM; i++)
	{
		if (page_table[i].item_num != 0)
		{
			_wnd_item_init(&page_table[i], &g_lcdsize, lcdtype, page_table[i].pagetype,i);
		}
	}	

	memset(&g_cfg_index,0,sizeof(g_cfg_index));
	memset(&g_disp_flag,0,sizeof(g_disp_flag));
	
	_equ_di_index_init();
	_equ_do_index_init();

	g_page_cur = page_table[MENU_MAIN];
	check_cur_wnd_item();
	
	reset_update_flag();

	g_item_update.time_dly = dTCounter;
	g_item_update.title_dly = dTCounter;

	for (i=0; i<10; i++)
	{
		g_item_update.kr_dly[i] = dTCounter;
		g_item_update.ac_dly[i] = dTCounter;
		g_item_update.zf_dly[i] = dTCounter;
		g_item_update.name_dly[i] = dTCounter;
	}

	memset(g_action.action, 0, 10);

	led_init_hmi();

	return 0;
}

/******************************************************************************
函数名称：	menudesc_exit
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	菜单退出。
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
int menudesc_exit(void)
{
	rt_free(item_pub_kr);
	rt_free(item_sw_kr);
	rt_free(item_pub_ac);
	rt_free(item_sw_ac);
	rt_free(item_flag);
	rt_free(item_time);
	rt_free(item_fix);
	rt_free(item_fix_GLBH);
	rt_free(item_fix_LXBH);
	rt_free(item_fix_JDBH);
	rt_free(item_fix_CHZ);
	rt_free(item_fix_BH_sts);
	rt_free(item_fix_DLYX_sts);
	rt_free(item_fix_HJS_sts);
	rt_free(item_para);
    rt_free(item_run_para);
	rt_free(item_infix);
	rt_free(item_timeset);
	rt_free(item_sjsoe);
	rt_free(item_czsoe);
	rt_free(item_test_kc);
	rt_free(item_info_err);
	rt_free(item_info_debug);
	rt_free(item_info_gprs);
	rt_free(item_password);
	rt_free(item_passerr);
	rt_free(item_info_equ);
	rt_free(item_comm_para);
	rt_free(item_info_yx);
	rt_free(item_info_yc);
	rt_free(item_saveresult);
	rt_free(item_setrange);
	rt_free(item_event);
	rt_free(item_chz_flag);
	return 0;
}

/******************************************************************************
函数名称：	menu_disp
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	页面处理
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
int menu_disp(void)
{
#if 0
	static unsigned long us0;
	static int flag=TRUE;

	if (flag)
	{
		us0 = ustimer_get_origin();
		flag = FALSE;
	}

	if(ustimer_get_duration(us0) >= 1000*USTIMER_MS)
	{
		rt_printf("\r\nmenu_cur=%d, menu_m=%d, pagetype=%d, item_num=%d,wnd_num=%d, wnd_item=%d, cur_wnd_item=%d, cur_wnd=%d, cur_focus=%d, title=%d, time=%d\r\n",
			g_page_cur.menu_cur,
			g_page_cur.menu_m,
			g_page_cur.pagetype,
			g_page_cur.item_num,
			g_page_cur.wnd_num,
			g_page_cur.wnd_item,
			g_page_cur.cur_wnd_item,
			g_page_cur.cur_wnd,
			g_page_cur.cur_focus,
			g_page_cur.title,
			g_page_cur.time
			);
		flag = TRUE;
	}
#endif
	g_page_cur.DispFun(g_page_cur.cur_focus, g_page_cur.cur_wnd, g_page_cur.cur_wnd_item,g_page_cur.page_item);

	return 0;
}

/******************************************************************************
函数名称：	reset_update_flag
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	重建实体更新标志
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
void reset_update_flag(void)
{
	u8 i;
	u8 tmp = 0;
	u32 tmp_time = 0;
	tmp = g_item_update.autoback;
	tmp_time = g_item_update.autoback_dly;
	memset(&g_item_update, 0, sizeof(g_item_update));
	g_item_update.title = 1;
	g_item_update.time = 1;
	g_item_update.time_dly = dTCounter;
	g_item_update.title_dly = dTCounter;
	g_item_update.flash_dly = dTCounter;
	//以下两个特定情况刷新
	g_item_update.autoback = tmp;
	g_item_update.autoback_dly = tmp_time;

	for (i=0; i<10; i++)
	{
		g_item_update.name[i] = 1;
		g_item_update.data[i] = 1;
		g_item_update.flash[i] = 1;
		g_item_update.kr_dly[i] = dTCounter;
		g_item_update.ac_dly[i] = dTCounter;
		g_item_update.zf_dly[i] = dTCounter;
		g_item_update.name_dly[i] = dTCounter;
	}
}

/*------------------------------ 内部函数 -------------------------------------
内部函数以下划线‘_’开头，不需要检查参数的合法性.
*/
/******************************************************************************
函数名称：	_page_menu_disp
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	菜单类页面处理
参数说明：	ifocus:当前聚焦点
			icur_wnd:当前屏
			icur_wnd_item:当前屏分配的实体数
			ipage_item:当前页面
返回值：  	成功返回0.
修改记录：	
*/
void _page_menu_disp(u8 ifocus, u8 icur_wnd, u8 icur_wnd_item, struct item *ipage_item)
{
	int index=0, i=0, flag=0;
	int x=0, y=0;
	char str[22]={0};
	char *pname = NULL;
	int  title_len = STR_LEN_MENU;

	g_lcdsize.x = lcd_size_default[g_lcd_size-1].x;
	g_lcdsize.y = lcd_size_default[g_lcd_size-1].y;

	// 当前屏首个实体在页面中的实体序号
	if (icur_wnd > 0)
	{
		index = g_page_cur.wnd_item * icur_wnd;
	}

	// 打印标题
	if (g_page_cur.title && g_item_update.title)
	{
	    pname = menu_base_table[g_page_cur.menu_cur].name;
	    title_len = strlen(pname);

		// 坐标
		x = (g_lcdsize.x - title_len *8) / 2;
		y = 0;

		// 打印
		if(pname != (char *)0)
		    fmt_Printf(x, y, MMI_FOCUS_NO, pname);

		g_item_update.title = 0;
	}
	
	// 打印菜单
	for (i=0; i<icur_wnd_item; i++)
	{
		// 根据聚焦区分正显和反显
		if (i == ifocus)
		{
			flag = MMI_FOCUS_NORMAL;
		}
		else
		{
			flag = MMI_FOCUS_NO;
		}
		if(dTCounter-g_item_update.name_dly[i] > (T_1s*10))
		{	
			g_item_update.name[i] = 1;
			g_item_update.name_dly[i] = dTCounter;
		}
		if (g_item_update.name[i])
		{
		    pname = menu_base_table[ipage_item[index+i].no].name;
		    if(pname != (char *)0)
		        fmt_Printf(ipage_item[index+i].x, ipage_item[index+i].y, flag, pname);

			g_item_update.name[i] = 0;
		}
	}
	if(dTCounter-g_item_update.time_dly > T_1s)
	{	
		g_item_update.time = 1;
		g_item_update.time_dly = dTCounter;
	}
	if(dTCounter-g_item_update.title_dly > (T_1s*10))
	{	
		g_item_update.title = 1;
		g_item_update.title_dly = dTCounter;
	}

	// 打印时间 
	if (g_page_cur.time && g_item_update.time)
	{
		_rtc_printf(LINE_MD, str, 0);
		fmt_Printf(0, g_lcdsize.y-16, MMI_FOCUS_NO, str);		
		g_item_update.time = 0;
	}
}

/******************************************************************************
函数名称：	_page_set_disp
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	设置类页面处理
参数说明：	ifocus:当前聚焦点
			icur_wnd:当前屏
			icur_wnd_item:当前屏分配的实体数
			ipage_item:当前页面
			修改定值时，屏幕刷新后，名称不重复刷新，数字仅光标闪烁，以及设置引起的变化内容刷新
返回值：  	成功返回0.
修改记录：	
*/
void _page_set_disp(u8 ifocus, u8 icur_wnd, u8 icur_wnd_item, struct item *ipage_item)
{
	int index=0, i=0;
	static int flag=0;
	int x=0,y=0;
	int  title_len = STR_LEN_MENU;
	char title_str[20]={0};
	char page_num_str[10]={0};

	// 当前屏首个实体在页面中的实体序号
	if (icur_wnd > 0)
	{
		index = g_page_cur.wnd_item * icur_wnd;
	}

		// 打印标题
	if (g_page_cur.title && g_item_update.title&&g_page_cur.menu_cur != MENU_PASSWORD)
	{
	    // pname = menu_base_table[g_page_cur.menu_cur].name;
		if(g_page_cur.menu_cur == MENU_GLBH || g_page_cur.menu_cur == MENU_LXBH
		|| g_page_cur.menu_cur == MENU_JDBH|| g_page_cur.menu_cur == MENU_RECLOSE
		|| g_page_cur.menu_cur == MENU_BH_STATUS|| g_page_cur.menu_cur == MENU_DLYX
		|| g_page_cur.menu_cur == MENU_HJS)
		{
			strncpy(title_str,menu_base_table[MENU_FIX_SW1 + class_GLBH.sw_idx].name,20);
		}
		else
		{
			strncpy(title_str,menu_base_table[g_page_cur.menu_cur].name,20);
		}
	    title_len = strlen(title_str);
		//页码
		sprintf(page_num_str,"<%02d/%02d>",g_page_cur.cur_wnd+1,g_page_cur.wnd_num);
		// strncat(title_str,page_num_str,(20 - title_len));
		title_len = strlen(title_str);
		// 坐标
		x = (g_lcdsize.x - title_len *8) / 2;

		// 打印
		// if(pname != (char *)0)
		if(title_len != 0)
		    fmt_Printf(x, 0, MMI_FOCUS_NO, title_str);

		title_len = strlen(page_num_str);
		x = (g_lcdsize.x - title_len *8) / 2;
		if(title_len != 0)
			fmt_Printf(x, g_lcdsize.y-16, MMI_FOCUS_NO, page_num_str);

		g_item_update.title = 0;
	}

	for (i=0; i<icur_wnd_item; i++)
	{
		// 打印名称
		if (g_item_update.name[i])
		{
			if (g_page_cur.menu_cur == MENU_PASSWORD)
			{
				x = (g_lcdsize.x - (STR_LEN_MENU*16)) / 2;
				y = (g_lcdsize.y - 2*16) / 2;
			}
			else
			{
				x = 0;
				y = ipage_item[index+i].y;
			}
			fmt_Printf(x, y, MMI_FOCUS_NO, g_set_dis[i].str[SET_NAME]);
			g_item_update.name[i] = 0;
		}

		// 打印数据
		if (g_item_update.data[i])
		{
			if (i == g_page_cur.cur_focus)
			{
				flag = MMI_FOCUS_NORMAL;
			}
			else
			{
				flag = MMI_FOCUS_NO;
			}

			if (g_page_cur.menu_cur == MENU_PASSWORD)
			{
				// x = (g_lcdsize.x - 4*8) / 2;
				x = (g_lcdsize.x - 6*8) / 2;			// 密码使用6位
				y = (g_lcdsize.y - 2*16) / 2 + 16;
			}
			else if (g_set_dis[i].spcl_type == DISP_IP)
			{
				x = 2*8;
				y = ipage_item[index+i].y+16;
			}
			else
			{
				x = 6*8;
				y = ipage_item[index+i].y+16;
			}

			fmt_StrPrintf ( x, 
							y, 
							g_set_dis[i].lenth, 
							flag, 
							g_set_dis[i].str[SET_DATA]);

			fmt_StrPrintf ( x+g_set_dis[i].lenth*8, 
							y, 
							g_set_dis[i].len, 
							MMI_FOCUS_NO, 
							g_set_dis[i].str[SET_UNIT]);
			g_item_update.data[i] = 0;			
		}

		// 闪烁定时器
		if(dTCounter-g_item_update.flash_dly > T_500ms)
		{
			if (i == ifocus)
			{
				if (flag==MMI_FOCUS_NO)
				{
					flag = MMI_FOCUS_NORMAL;
				}
				else
				{
					flag = MMI_FOCUS_NO;
				}
				g_item_update.flash[i] = 1;
				g_item_update.flash_dly = dTCounter;
			}
		}

		// 设置项闪烁
		if (g_item_update.flash[i])
		{
			if (g_set_dis[i].modify)
			{
				if (g_page_cur.menu_cur == MENU_PASSWORD)
				{
					// x = (g_lcdsize.x - 4*8) / 2;
					x = (g_lcdsize.x - 6*8) / 2;			// 密码使用6位
					y = (g_lcdsize.y - 2*16) / 2 + 16;
				}
				else if (g_set_dis[i].spcl_type == DISP_IP)
				{
					x = g_set_dis[i].x+2*8;
					y = ipage_item[index+i].y+16;
				}
				else
				{
					x = g_set_dis[i].x+6*8;
					y = ipage_item[index+i].y+16;
				}
				_set_cursor_flash(i, x, y, flag);
			}
			g_item_update.flash[i] = 0;			
		}
	}
}

/******************************************************************************
函数名称：	_page_query_line_disp
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	查询类页面处理
参数说明：	ifocus:当前聚焦点
			icur_wnd:当前屏
			icur_wnd_item:当前屏分配的实体数
			ipage_item:当前页面
返回值：  	成功返回0.
修改记录：	
*/
void _page_query_line_disp(u8 ifocus, u8 icur_wnd, u8 icur_wnd_item, struct item *ipage_item)
{
	int index=0, i=0;
	char strname[20]={0};
	char strdata[20]={0};
	int x=0;
	// char *pname = NULL;
	int  title_len = STR_LEN_MENU;
	char title_str[20]={0};
	char page_num_str[10]={0};
	bool ban_display = false;

	// 当前屏首个实体在页面中的实体序号
	if (icur_wnd > 0)
	{
		index = g_page_cur.wnd_item * icur_wnd;
		
	}

	// 打印标题
	if (g_page_cur.title && g_item_update.title)
	{
	    // pname = menu_base_table[g_page_cur.menu_cur].name;
		strncpy(title_str,menu_base_table[g_page_cur.menu_cur].name,20);
	    title_len = strlen(title_str);
		//页码
		sprintf(page_num_str,"<%02d/%02d>",g_page_cur.cur_wnd+1,g_page_cur.wnd_num);
		strncat(title_str,page_num_str,(20 - title_len));
		title_len = strlen(title_str);
		// 坐标
		x = (g_lcdsize.x - title_len *8) / 2;

		// 打印
		// if(pname != (char *)0)
		if(title_len != 0)
		    fmt_Printf(x, 0, MMI_FOCUS_NO, title_str);

		if(g_page_cur.menu_cur == MENU_CHZ_FLAG)
		{
			sprintf(title_str,"●:充电完成○:未充电");
			fmt_Printf(0, g_lcdsize.y-16, MMI_FOCUS_NO, title_str);
		}

		g_item_update.title = 0;
	}

	// 打印实体
	for (i=0; i<icur_wnd_item; i++)
	{
		ban_display = false;
		switch(ipage_item[i+index].type)
		{			
			case QUERY_PUB_KR:
			case QUERY_SW_KR:
			{
				struct equ_config_di *ecd = NULL;

				if(ipage_item[i+index].type == QUERY_PUB_KR)
				{
					ecd = &g_equ_config_di[g_cfg_index.pub_di[i + index]];
				}
				else
				{
					ecd = &g_equ_config_di[g_cfg_index.sw_di[i + index]];
				}

				// 开入的更新时间
				if(dTCounter-g_item_update.kr_dly[i] > T_500ms)
				{	
					g_item_update.data[i] = 1;
					g_item_update.kr_dly[i] = dTCounter;
				}
				if(dTCounter-g_item_update.name_dly[i] > (T_1s*10))
				{	
					g_item_update.name[i] = 1;
					g_item_update.name_dly[i] = dTCounter;
				}
				if (g_item_update.name[i])
				{
					// 获取开入名称
					strcpy(strname, ecd->name);
				}
				if (g_item_update.data[i])
				{				
					// 获取开入状态
					if(dido_di_is_on(ecd->slot,ecd->index))
					{
						strcpy(strdata,"合");
					}
					else
					{
						strcpy(strdata,"分");
					}	

					// 数据的坐标
					x = g_lcdsize.x-16;
				}
			}
			break;

			case QUERY_PUB_AC:
			case QUERY_SW_AC:
			{
				char strtmp[12]={0};
				int no;
				int len = 0;

				no = i+index;				

				// 开入的更新时间
				if(dTCounter-g_item_update.ac_dly[i] > T_500ms)
				{	
					g_item_update.data[i] = 1;
					g_item_update.ac_dly[i] = dTCounter;
				}
				if(dTCounter-g_item_update.name_dly[i] > (T_1s*10))
				{	
					g_item_update.name[i] = 1;
					g_item_update.name_dly[i] = dTCounter;
				}
				
				if (ipage_item[i+index].type == QUERY_PUB_AC)
				{
					if (g_item_update.name[i])
					{
						// 获取测量名称
						strcpy(strname, g_pub_ac_desc[disp_pub_ac_index[no][1]].name);
					}
					if (g_item_update.data[i])
					{
						// 获取测量数值
						FreshMeaPub(lMeaVal,lMeaAng,lMeaCal);
						FUC_Get_LongValue_String(lMeaVal[disp_pub_ac_index[no][1]],strtmp);						
						sprintf(strdata,"%-6.6s%s",strtmp,g_unit[g_pub_ac_desc[disp_pub_ac_index[no][1]].unit].name);  //幅值
					}
				}
				else
				{
					if (g_item_update.name[i])
					{
						// 获取测量名称
						#if SWITCH_NUM_MAX != 1
						{
							sprintf(strname,"开关%d ",disp_sw_ac_index[no][0]);
							len = strlen(strname);
						}
						#endif
						
						strcpy(&strname[len], g_sw_ac_desc[disp_sw_ac_index[no][1]].name);
					}
					if (g_item_update.data[i])
					{
						// 获取测量数值
						FreshMeaSw(lMeaVal,lMeaAng,lMeaCal,disp_sw_ac_index[no][0]);
						FUC_Get_LongValue_String(lMeaVal[disp_sw_ac_index[no][1]],strtmp);
						sprintf(strdata,"%-6.6s%s",strtmp,g_unit[g_sw_ac_desc[disp_sw_ac_index[no][1]].unit].name);  //幅值
					}
				}

				// 数据的坐标
				x = g_lcdsize.x-9*8;
			}
			break;

			case QUERY_VER:
			{
				u32 ver;
				if (g_item_update.name[i])
				{
					// 获取版本名称
					strcpy(strname, item_base_table[ipage_item[i+index].no].name);
				}
				if (g_item_update.data[i])
				{
					// 获取版本内容
					if (ipage_item[i+index].no == ITEM_VER)
					{
						ver = *(u32 *)(item_base_table[ipage_item[i+index].no].fstdata);
						//sprintf (strdata,"%01X.%02X.%02x", (BYTE)(ver>>16),(BYTE)(ver>>8),(BYTE)(ver>>0));
						sprintf(strdata, "SV%02d.%03d",(VER_NUM>>16)&0XFF,VER_NUM&0XFFF);
					}
					if (ipage_item[i+index].no == ITEM_CRC)
					{
						sprintf (strdata,"%04X", *(u16 *)(item_base_table[ipage_item[i+index].no].fstdata));
						strcat(strdata, SetUints[item_base_table[ipage_item[i+index].no].unit]);
					}
				}
				// 数据的坐标
				x = g_lcdsize.x - 8*8;
			}
			break;

			case QUERY_CFG:
			{
				if (g_item_update.name[i])
				{
					// 获取版本名称
					strcpy(strname, item_base_table[ipage_item[i+index].no].name);
				}
				
				if (g_item_update.data[i])
				{
					// 获取版本内容
					sprintf (strdata,"%04X", *(u16 *)(item_base_table[ipage_item[i+index].no].fstdata));
					strcat(strdata, SetUints[item_base_table[ipage_item[i+index].no].unit]);			
				}
				// 数据的坐标
				x = g_lcdsize.x - 5*8;
			}
			break;

			case QUERY_FLAG:
			{
				if (g_item_update.name[i])
				{
					// 获取版本名称
					strcpy(strname, item_base_table[ipage_item[i+index].no].name);
				}
				
				// 标志更新时间
				if(dTCounter-g_item_update.kr_dly[i] > T_500ms)
				{	
					g_item_update.data[i] = 1;
					g_item_update.kr_dly[i] = dTCounter;
				}

				if (g_item_update.data[i])
				{
					// 获取标志状态
					if(*(u32 *)item_base_table[ipage_item[i+index].no].fstdata)
					{
						strcpy(strdata,"●");
					}
					else
					{
						strcpy(strdata,"○");
					}	
					// 数据的坐标
					x = g_lcdsize.x-16;
				}
			}
			break;

			case QUERY_CHZ_FLAG:
				if (g_item_update.name[i])
				{
					// 获取版本名称
					sprintf(strname,"开关%d重合闸充电",(i+index+1));
				}
				
				// 标志更新时间
				if(dTCounter-g_item_update.kr_dly[i] > T_500ms)
				{	
					g_item_update.data[i] = 1;
					g_item_update.kr_dly[i] = dTCounter;
				}

				if (g_item_update.data[i])
				{
					// 获取标志状态
					if((g_disp_flag.chz_cd>>(i+index))&0x01)
					{
						strcpy(strdata,"●");
					}
					else
					{
						strcpy(strdata,"○");
					}	
					// 数据的坐标
					x = g_lcdsize.x-16;
				}
			break;

			default:
			ban_display = true;
			break;

		}
		
		if(!ban_display)
		{
			// 打印实体名称
			if (g_item_update.name[i])
			{
				fmt_Printf(ipage_item[index+i].x, ipage_item[index+i].y, MMI_FOCUS_NO, strname);
				g_item_update.name[i] = 0;
			}

			// 打印实体数据
			if (g_item_update.data[i])
			{
				fmt_Printf(x, ipage_item[index+i].y, MMI_FOCUS_NO, strdata);
				g_item_update.data[i] = 0;
			}
		}
	}
	
}

/******************************************************************************
函数版本：   01.01
创建作者：   康文广
创建日期：   2021-6-15
函数说明：   根据给定长度截断字符串
参数说明：   pin_str:截断前的字符串
             pout_str:截断后的字符串 (含结束符)
             cutoff_len: 截断长度
返回值：     返回截断后的字符串长度
修改记录：
*/
static u8 _menu_cutoff_string(char *pin_str, char *pout_str, u8 cutoff_len)
{
    u8  i=0;
    u8  cnt=0;

    i=0;
    while((i < cutoff_len) && (pin_str[i] !=0)) {
        if((u8)pin_str[i] > 0x80) {
            if(i+2 <= cutoff_len){
                pout_str[cnt++] = pin_str[i];
                pout_str[cnt++] = pin_str[i+1];
                i += 2;
            }else{  //half
                break;
            }
        }else{
            pout_str[cnt++] = pin_str[i];
            i++;
        }
    }
    pout_str[cnt] = 0;

    return  cnt;
}

static int _menu_info_table_init(int tbl_i,u8 menu_no, u8 wnd_no)
{
	u8   idx=0;
    // u8   item_line=2;
    // u8   len=0;
    u8   cutoff_len;
    u8   val;
	u32  obj_num = 0;
    char buf[64] ={0};
	char strtmp[128]={0};

	if (menu_no==QUERY_YX)
	{
		obj_num = g_table_head->di_num;
	}
	else if (menu_no==QUERY_YC)
	{
		obj_num = g_table_head->ac_num;
	}

    while(idx <= MAX_LINE_PER_PAGE) {
        if((tbl_i >=0) && (tbl_i < obj_num)) {
            //prejudge
			if (menu_no==QUERY_YX)
			{
				tbl_getname(RES_TYPE_YX, tbl_i, buf);
			}
			else if (menu_no==QUERY_YC)
			{
				tbl_getname(RES_TYPE_YC, tbl_i, buf);
			}
           
		   #if 0
            len = strlen(buf);
            if(len >= 18)
                item_line = 3;  //need 3 lines space
            else
                item_line = 2;  //need 2 lines space

            if(idx + item_line > MAX_LINE_PER_PAGE){
                break;
            }
			#endif

            //cp and value
			if (menu_no==QUERY_YX)
			{
				val = tbl_get_yx(tbl_i, tRunPara.bDPI);
				sprintf(g_page_dis.str[idx], "YX[%04X]:     值: %d", g_di_table[tbl_i].cp, val);
				idx++;
			}
			else if (menu_no==QUERY_YC)
			{
				float rate,fval;
				long lmeaval;
				BYTE no=g_ac_table[tbl_i].indexno;	
				if (no>0)
				{
					no -= 1;
					rate=(float)g_ac_table[tbl_i].rate/65536.0;
					lmeaval=GetRmtMeaVal(g_ac_table[tbl_i].owner,no,NULL);
					fval=((float)lmeaval)/65536.0*rate; //转为浮点数
				}
				else
				{
					lmeaval = 0;
					fval=0;
				}
				if (fval > 9999999999.00)
				{
					sprintf(strtmp,"------");
				}
				else
				{
					sprintf(strtmp,"%.2f", fval);
				}
				
				sprintf(g_page_dis.str[idx], "[%04X]%-13.13s", g_ac_table[tbl_i].cp, strtmp);
				idx++;
			}
			
            //name
            cutoff_len = _menu_cutoff_string(buf, g_page_dis.str[idx], 18);
            g_page_dis.str[idx][cutoff_len] = 0;
            idx++;
			
			#if 0
            if(len >= max_line_char) {
                cutoff_len = _menu_cutoff_string(buf+cutoff_len, (char *)g_page_dis.str[idx], max_line_char);
                g_page_dis.str[idx][cutoff_len] = 0;
                idx++;
            }
			#endif
            tbl_i++;

        }else{
            tbl_i = 0;
            break;
        }
    }

    g_page_cur.item_num = obj_num *2;  //最大2倍, 不再动态调整当前屏号 
    g_page_cur.wnd_item = MAX_LINE_PER_PAGE;
	// 页面分配的总屏数
	if (g_page_cur.item_num <= g_page_cur.wnd_item)
	{
		g_page_cur.wnd_num = 1;
	}
	else
	{
		g_page_cur.wnd_num = g_page_cur.item_num / g_page_cur.wnd_item;
		if (g_page_cur.item_num % g_page_cur.wnd_item != 0)
		{
			g_page_cur.wnd_num++;
		}
	}
	// 获取当前屏分配的实体数
	check_cur_wnd_item();
    g_page_cur.cur_wnd_item = idx;   //当前屏分配的实体数

	return 0;
}

/******************************************************************************
函数名称：	_page_query_page_disp
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	查询类页面处理
参数说明：	ifocus:当前聚焦点
			icur_wnd:当前屏
			icur_wnd_item:当前屏分配的实体数
			ipage_item:当前页面
返回值：  	成功返回0.
修改记录：	
*/
void _page_query_page_disp(u8 ifocus, u8 icur_wnd, u8 icur_wnd_item, struct item *ipage_item)
{
	int index=0, i=0;
	int x=0, y=0;
	char str1[18]={0}, str2[18]={0};

	// 当前屏首个实体在页面中的实体序号
	if (icur_wnd > 0)
	{
		if (ipage_item[i].type == QUERY_YX || ipage_item[i].type == QUERY_YC)
		{
			index = (g_page_cur.wnd_item/2) * icur_wnd;
		}
		else
		{
			index = g_page_cur.wnd_item * icur_wnd;
		}
	}

	// 打印实体
	switch(ipage_item[i].type)
	{			
		case QUERY_TIME:
		{
			if(dTCounter-g_item_update.time_dly > T_100ms)
			{	
				g_item_update.time = 1;
				g_item_update.time_dly = dTCounter;
			}
			if (g_item_update.time)
			{
				_rtc_printf(PAGE_MD, str1, str2);

				x = (g_lcdsize.x - (strlen(str1)*8)) / 2;
				y = (g_lcdsize.y - 2*16) / 2;	
				fmt_Printf(x, y, MMI_FOCUS_NO, str1);

				x = (g_lcdsize.x - (strlen(str2)*8)) / 2;
				y += 16;	
				fmt_Printf(x, y, MMI_FOCUS_NO, str2);
				
				g_item_update.time = 0;
			}
		}
		break;

		case QUERY_SJSOE:
		case QUERY_CZSOE:
		case QUERY_ERR:
		case QUERY_DEBUG:
		case QUERY_GPRS:
		case QUERY_PASSERR:
		case QUERY_SAVERESULT:
		case QUERY_EVENT:
		case QUERY_RMTPAIR:
		case QUERY_DELPAIR:
		case QUERY_ADJUSTRESULT:
		{
			// 获取打印内容
			// 打印实体
			x = 0;
			y = 0;

			if (ipage_item[i].type == QUERY_PASSERR)
			{
				x = (g_lcdsize.x - 16*8) / 2;
				y = (g_lcdsize.y - 2*16) / 2;
			}
			else if (ipage_item[i].type == QUERY_SAVERESULT)
			{
				x = (g_lcdsize.x - 4*16)/2;
				y = (g_lcdsize.y - 1*16)/2;
			}
			else if ((ipage_item[i].type == QUERY_RMTPAIR)
					|| (ipage_item[i].type == QUERY_DELPAIR))
			{
				y = (g_lcdsize.y - 2*16)/2;
			}	
			else if(ipage_item[i].type == QUERY_ADJUSTRESULT)//xj 2015.5.11
			{
				x = (g_lcdsize.x - 8*strlen(g_page_dis.str[0]))/2;
				y = g_lcdsize.y/2;
			}		
			
			for (i=0; i<icur_wnd_item; i++)
			{
				if (g_item_update.name[i])
				{
					fmt_Printf(x, y, MMI_FOCUS_NO, g_page_dis.str[index+i]);  //如果index>=16 会越界
					y += 16;
					g_item_update.name[i] = 0;
				}
			}
		}
		break;

		case QUERY_EQU:
		case QUERY_COMM_PARA:
            for (i=0; i<icur_wnd_item; i++)
            {
                if (g_item_update.name[i])
                {
                    fmt_Printf(x, y, MMI_FOCUS_NO, g_page_dis.str[i]);
                    y += 16;
                    g_item_update.name[i] = 0;
                }
            }
		break;
		case QUERY_YX:
		{
			int ret = -1;
			ret = _menu_info_table_init(index,QUERY_YX, icur_wnd);
			if (ret == 0)
			{
				for (i=0; i<icur_wnd_item; i++)
				{
					int mx=0, my=0,nx=0, ny=0;
					// 标志更新时间
					if(dTCounter-g_item_update.zf_dly[i] > T_1s)
					{	
						g_item_update.data[i] = 1;
						g_item_update.zf_dly[i] = dTCounter;
					}
					if(dTCounter-g_item_update.name_dly[i] > (T_1s*10))
					{	
						g_item_update.name[i] = 1;
						g_item_update.name_dly[i] = dTCounter;
					}

					if (g_item_update.name[i])
					{
						ny += 16*i;
						fmt_Printf(nx, ny, MMI_FOCUS_NO, g_page_dis.str[i]);
						g_item_update.name[i] = 0;
					}

					if (g_item_update.data[i])
					{
						if (i%2==0)
						{
							my += 16*i;
							fmt_Printf(mx, my, MMI_FOCUS_NO, g_page_dis.str[i]);
						}
						g_item_update.data[i] = 0;
					}
				}
			}
		}
		break;
		case QUERY_YC:
		{
			int ret = -1;
			ret = _menu_info_table_init(index,QUERY_YC, icur_wnd);
			if (ret == 0)
			{
				for (i=0; i<icur_wnd_item; i++)
				{
					int mx=0, my=0,nx=0, ny=0;
					// 标志更新时间
					if(dTCounter-g_item_update.zf_dly[i] > T_1s)
					{	
						g_item_update.data[i] = 1;
						g_item_update.zf_dly[i] = dTCounter;
					}
					if(dTCounter-g_item_update.name_dly[i] > (T_1s*10))
					{	
						g_item_update.name[i] = 1;
						g_item_update.name_dly[i] = dTCounter;
					}

					if (g_item_update.name[i])
					{
						ny += 16*i;
						fmt_Printf(nx, ny, MMI_FOCUS_NO, g_page_dis.str[i]);
						g_item_update.name[i] = 0;
					}

					if (g_item_update.data[i])
					{
						if (i%2==0)
						{
							my += 16*i;
							fmt_Printf(mx, my, MMI_FOCUS_NO, g_page_dis.str[i]);
						}
						g_item_update.data[i] = 0;
					}
				}
			}
		}
		break;
	}
	
}

/******************************************************************************
函数名称：	_page_action_disp
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	动作类页面处理
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
void _page_action_disp(u8 ifocus, u8 icur_wnd, u8 icur_wnd_item, struct item *ipage_item)
{
	int index=0, i=0, flag=0, isel=0;
	int x=0, y=0;
	char strname[20]={0};
	char strdata[20]={0};

	// 当前屏首个实体在页面中的实体序号
	if (icur_wnd > 0)
	{
		index = g_page_cur.wnd_item * icur_wnd;
	}

	// 打印标题
	if (g_page_cur.title && g_item_update.title)
	{
		// 坐标
		if (g_page_cur.menu_cur == MENU_SAVE)
		{
			x = (g_lcdsize.x - 32) / 2;
			y = (g_lcdsize.y - 2*16) / 2;
			isel = ITEM_SAVE;
		}
		else if (g_page_cur.menu_cur == MENU_ADJUST_AC)
		{
			x = (g_lcdsize.x - 8*12) / 2;
			y = (g_lcdsize.y - 2*16) / 2;
			isel = ITEM_ADJUST_AC;
		}
		else
		{
			x = (g_lcdsize.x - 32) / 2;
			y = 0;
		}		
		// 打印
		fmt_Printf(x, y, MMI_FOCUS_NO, item_base_table[isel].name);	


		g_item_update.title = 0;
	}
	
	// 打印菜单
	for (i=0; i<icur_wnd_item; i++)
	{
		switch(ipage_item[index+i].type)
		{
			case ACTION_SAVE:
			{
				x = ipage_item[index+i].x + 8;		// 针对160*160液晶做出调整
				y = (g_lcdsize.y - 2*16) / 2;
				strcpy(strdata, item_base_table[ipage_item[index+i].no].name);
				g_item_update.name[i] = 0;
			}
			break;

			case ACTION_TEST_KC:
			{
				struct equ_config_do *ecd = &g_equ_config_do[g_cfg_index.kc[index + i][0]];

				if (g_item_update.name[i])
				{
					// 获取开出名称
					strcpy(strname, ecd->name);
				}
				if (g_item_update.data[i])
				{				
					// 获取开出状态
					if (g_action.action[i] == 0)
					{
						strcpy(strdata,"动作");
					}
					else
					{
						strcpy(strdata,"返回");
					}
					// 数据的坐标
					x = g_lcdsize.x-32;
				}
			}
			break;

			case ACTION_BAT:
			{
				struct equ_config_do *ecd = &g_equ_config_do[g_cfg_index.kc[index + i + PUB_DO_DCHH][0]];

				if (g_item_update.name[i])
				{
					// 获取开出名称
					strcpy(strname, ecd->name);
				}
				if (g_item_update.data[i])
				{				
					// 获取开出状态
					if (g_action.action[i] == 0)
					{
						strcpy(strdata,"动作");
					}
					else
					{
						strcpy(strdata,"返回");
					}
					// 数据的坐标
					x = g_lcdsize.x-32;
				}
			}
			break;
			
			case ACTION_CLR_SOE:
			case ACTION_TEST_LCD:
			case ACTION_TEST_LED:
			{
				if (g_item_update.name[i])
				{
					// 获取名称
					strcpy(strname, item_base_table[ipage_item[index+i].no].name);
				}
				if (g_item_update.data[i])
				{				
					// 获取状态
					if (g_action.action[i] == 0)
					{
						strcpy(strdata,"动作");
					}
					else
					{
						strcpy(strdata,"返回");
					}
					// 数据的坐标
					x = g_lcdsize.x-32;
				}
			}
			break;

			case ACTION_ADJUST_AC:
			{
				y = (g_lcdsize.y - 2*16) / 2;
				g_item_update.name[i] = 0;

				if (g_item_update.data[i])
				{				
					// 获取状态
					if (g_action.action[i] == 0)
					{
						strcpy(strdata,"校准");
					}
					else if (g_action.action[i] == 1)
					{
						strcpy(strdata,"成功");
					}
					else if (g_action.action[i] == 2)
					{
						strcpy(strdata,"失败");
					}
					// 数据的坐标
					x = (g_lcdsize.x - 16*2) / 2;
				}
			}
			break;

			case ACTION_ADJUST_DC10:
			case ACTION_ADJUST_DC50:
			{
				if (g_item_update.name[i])
				{
					// 获取名称
					strcpy(strname, item_base_table[ipage_item[index+i].no].name);
				}
				if (g_item_update.data[i])
				{				
					// 获取状态
					if (g_action.action[i] == 0)
					{
						strcpy(strdata,"校准");
					}
					else if (g_action.action[i] == 1)
					{
						strcpy(strdata,"成功");
					}
					else if (g_action.action[i] == 2)
					{
						strcpy(strdata,"失败");
					}
					// 数据的坐标
					x = g_lcdsize.x-32;
				}
			}
			break;
			
			case ACTION_RMT_PAIR:
			case ACTION_DEL_PAIR:
			{
				if (g_item_update.name[i])
				{
					// 获取名称
					strcpy(strname, item_base_table[ipage_item[index+i].no].name);
				}
				if (g_item_update.data[i])
				{				
					// 获取状态
					if (g_action.action[i] == 0)
					{
						strcpy(strdata,"启动");
					}
					else
					{
						strcpy(strdata,"返回");
					}
					// 数据的坐标
					x = g_lcdsize.x-32;
				}
			}
			break;

		}
		// 根据聚焦区分正显和反显
		if (i == ifocus)
		{
			flag = MMI_FOCUS_NORMAL;
		}
		else
		{
			flag = MMI_FOCUS_NO;
		}
		// 打印实体名称
		if (g_item_update.name[i])
		{
			fmt_Printf(ipage_item[index+i].x, ipage_item[index+i].y, MMI_FOCUS_NO, strname);
			g_item_update.name[i] = 0;
		}

		// 打印实体数据
		if (g_item_update.data[i])
		{
			fmt_Printf(x, ipage_item[index+i].y+y, flag, strdata);
			g_item_update.data[i] = 0;
		}
	}
}

/******************************************************************************
函数名称：	_wnd_item_init
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	页面及实体初始化
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
int _wnd_item_init(struct page_st *ipage, struct lcdsize *isize, u8 lcd, u8 menutype,u8 menu_num)
{
	int i=0,loop=0;
	int occupy_line=0; 	// 被占用的行，以字符行为单位，16点
	int write_line=0;		// 剩下可写的行，以液晶行为单位，8点
	int item_line=0;		// 需要写的总行数，以字符行为单位，16点
	int interval_line=0;	// 间隔总行数，以液晶行为单位，8点
	struct lcdsize strart_coord={0};	// 起始坐标,以液晶行为单位，8点
 	struct lcdsize interval={0};		// 实体间的间隔,以液晶行为单位，8点
 	int  menu_char_num = STR_LEN_MENU;
	
	switch(menutype)
	{
		case MENU_TYPE:
		case MENU_TYPE_CH8:
		    if(menutype == MENU_TYPE_CH8)
		        menu_char_num = STR_LEN_MENU*2;

			switch(lcd)
			{
				case SMALL:
					ipage->title = 0;
					ipage->time = 0;
					occupy_line = 0;
				break;

				case MID:
					ipage->title = 1;
					ipage->time = 0;
					occupy_line = 2;
				break;

				case BIG:
					ipage->title = 1;
					ipage->time = 1;
					occupy_line = 4;
				break;
			}
			// 以行为显示，每行显示2个实体，有行间隔
			
			// 一屏可写的行数
			write_line = isize->y/8 - occupy_line;

			// 实体需占用的总行数,一行可显示2个菜单
			item_line = ipage->item_num/2;
			if (ipage->item_num % 2 != 0)
			{
				item_line++;
			}

			// 计算起始y坐标和行间隔
			if (item_line > write_line/2)
			{
				interval.y = 0;
				strart_coord.y = interval.y + ipage->title*2;	
				interval_line = 0;
			}
			else
			{	
				if ((write_line - item_line*2) > (item_line*2))
				{
					interval.y = (write_line-item_line*2) / (item_line*2+1);
					strart_coord.y = interval.y + ipage->title*2;
					interval_line = item_line*2+1;
				}
				else if ((write_line - item_line*2) == (item_line*2))
				{
					interval.y = 2;
					strart_coord.y = interval.y + ipage->title*2 - 1;
					interval_line = item_line*2;				
				}
				else
				{
					interval.y = 0;
					strart_coord.y = interval.y + ipage->title*2;
					interval_line = write_line - item_line*2;
				}
			}

			// 计算起始x坐标和列间隔
			interval.x = (isize->x - (menu_char_num*8*LINE_MENU)) / 3;
			strart_coord.x = interval.x - 1;
			
			// 每屏可容纳的最多实体数
			ipage->wnd_item = (write_line/2 - interval_line/2) * 2;

			// 页面分配的总屏数
			if (ipage->item_num <= ipage->wnd_item)
			{
				ipage->wnd_num = 1;
			}
			else
			{
				ipage->wnd_num = ipage->item_num / ipage->wnd_item;
				if (ipage->item_num % ipage->wnd_item != 0)
				{
					ipage->wnd_num++;
				}
			}

			// 实体坐标赋值
			for(i=0; i<ipage->item_num; i+=ipage->wnd_item)
			{				
				// 当切换屏时，重新从起始坐标开始
				for (loop=0; loop<ipage->wnd_item; loop+=2)
				{
					if ((i+loop) < ipage->item_num)
					{
						ipage->page_item[i+loop].x = strart_coord.x;
						ipage->page_item[i+loop].y = strart_coord.y*8 + loop/2*16 + loop/2*interval.y*8;
					}
					if ((i+loop+1) < ipage->item_num)
					{
						ipage->page_item[i+loop+1].x = interval.x*2 + menu_char_num*8 - 1;
						ipage->page_item[i+loop+1].y = ipage->page_item[i+loop].y;
					}
				}
			}
		break;

		case SET_TYPE:
			// 以2行为显示，每2行显示1个实体，无行间隔

			switch(lcd)
			{
				case SMALL:
					ipage->title = 0;
					ipage->time = 0;
					occupy_line = 0;
				break;

				case MID:
				case BIG:
					ipage->title = 1;
					ipage->time = 0;
					occupy_line = 4;
				break;
			}

			// 一屏可写的行数
			write_line = isize->y/8 - occupy_line;

			// 实体需占用的总行数
			item_line = ipage->item_num * 2;

			// 计算起始y坐标和行间隔
			interval.y = 0;
			strart_coord.y = ipage->title*2;;	
			interval_line = 0;

			// 计算起始x坐标和列间隔
			interval.x = 0;
			strart_coord.x = 0;
			
			// 每屏可容纳的最多实体数
			ipage->wnd_item = ((write_line/2) / 2);

			// 页面分配的总屏数
			if (ipage->item_num <= ipage->wnd_item)
			{
				ipage->wnd_num = 1;
			}
			else
			{
				ipage->wnd_num = ipage->item_num / ipage->wnd_item;
				if (ipage->item_num % ipage->wnd_item != 0)
				{
					ipage->wnd_num++;
				}
			}

			// 实体坐标赋值
			for(i=0; i<ipage->item_num; i+=ipage->wnd_item)
			{				
				// 当切换屏时，重新从起始坐标开始
				for (loop=0; loop<ipage->wnd_item; loop++)
				{
					if ((i+loop) < ipage->item_num)
					{
						ipage->page_item[i+loop].x = strart_coord.x;
						ipage->page_item[i+loop].y = strart_coord.y*8 + loop*SET_LINE*16;
					}
				}
			}
		break;

		case QUERY_PAGE_TYPE:
			// 一屏可写的行数
			write_line = isize->y/8;
			// 计算起始y坐标和行间隔
			interval.y = 0;
			strart_coord.y = 0;	
			interval_line = 0;
			// 计算起始x坐标和列间隔
			interval.x = 0;
			strart_coord.x = 0;
			// 每屏可容纳的最多实体数
			ipage->wnd_item = write_line/2;
		break;

		case QUERY_1LINE_TYPE:
			switch(lcd)
			{
				case SMALL:
					ipage->title = 0;
					ipage->time = 0;
					occupy_line = 0;
				break;

				case MID:
				case BIG:
					ipage->title = 1;
					ipage->time = 0;
					occupy_line = 2;
					if(menu_num == MENU_CHZ_FLAG)
					{	
						//最底下一行用来显示注释，所以数据显示减少一行
						occupy_line = 4;
					}
				break;
			}
		
			// 一屏可写的行数
			write_line = isize->y/8 - occupy_line;

			// 实体需占用的总行数
			item_line = ipage->item_num;

			// 计算起始y坐标和行间隔
			interval.y = 0;
			strart_coord.y = ipage->title*2;
			interval_line = 0;

			// 计算起始x坐标和列间隔
			interval.x = 0;
			strart_coord.x = 0;
			
			// 每屏可容纳的最多实体数
			ipage->wnd_item = write_line/2;

			// 页面分配的总屏数
			if (ipage->item_num <= ipage->wnd_item)
			{
				ipage->wnd_num = 1;
			}
			else
			{
				ipage->wnd_num = ipage->item_num / ipage->wnd_item;
				if (ipage->item_num % ipage->wnd_item != 0)
				{
					ipage->wnd_num++;
				}
			}

			// 实体坐标赋值
			for(i=0; i<ipage->item_num; i+=ipage->wnd_item)
			{				
				// 当切换屏时，重新从起始坐标开始
				for (loop=0; loop<ipage->wnd_item; loop++)
				{
					if ((i+loop) < ipage->item_num)
					{
						ipage->page_item[i+loop].x = strart_coord.x;
						ipage->page_item[i+loop].y = strart_coord.y*8 + loop*16;
					}
				}
			}
		break;


		case ACTION_TYPE:
		{
			u8 num=0;
			// 一屏可写的行数
			write_line = isize->y/8;

			if(ipage->page_item[0].type == ACTION_SAVE)
			{
				ipage->title = 1;
				// 实体需占用的总行数
				item_line = ipage->item_num / 2;
				interval.x = (isize->x - (STR_LEN_MENU*8*LINE_MENU)) / 3;
				interval.y = 0;
				strart_coord.x = interval.x - 1;
				strart_coord.y = ipage->title*2;
				num = 2;
			}
			else if(ipage->page_item[0].type == ACTION_ADJUST_AC)
			{
				ipage->title = 1;
				// 实体需占用的总行数
				item_line = ipage->item_num;
				interval.x = 0;
				interval.y = 0;
				strart_coord.x = interval.x - 1;
				strart_coord.y = ipage->title*2;
				num = 1;
			}
			/*else if(ipage->page_item[0].type == ACTION_RMT_PAIR)
			{
				ipage->title = 1;
				// 实体需占用的总行数
				item_line = ipage->item_num;
				interval.x = (isize->x - (16*4)) / 2;;
				interval.y = 0;
				strart_coord.x = interval.x - 1;
				strart_coord.y = ipage->title*2;
				num = 1;
			}*/
			else
			{
				// 无标题
				ipage->title = 0;

				// 实体需占用的总行数
				item_line = ipage->item_num;

				// 计算起始y坐标和行间隔
				interval.y = 0;
				strart_coord.y = 0;	
				interval_line = 0;

				// 计算起始x坐标和列间隔
				interval.x = 0;
				strart_coord.x = 0;

				num = 1;
			}

			// 计算起始y坐标和行间隔
			
			interval_line = 0;
			

			// 计算起始x坐标和列间隔
			
			

			// 每屏可容纳的最多实体数
			ipage->wnd_item = write_line/2;

			// 页面分配的总屏数
			if (ipage->item_num <= ipage->wnd_item)
			{
				ipage->wnd_num = 1;
			}
			else
			{
				ipage->wnd_num = ipage->item_num / ipage->wnd_item;
				if (ipage->item_num % ipage->wnd_item != 0)
				{
					ipage->wnd_num++;
				}
			}

			// 实体坐标赋值
			for(i=0; i<ipage->item_num; i+=ipage->wnd_item*num)
			{				
				// 当切换屏时，重新从起始坐标开始
				for (loop=0; loop<ipage->wnd_item; loop+=num)
				{
					if ((i+loop) < ipage->item_num)
					{
						ipage->page_item[i+loop].x = strart_coord.x;
						ipage->page_item[i+loop].y = strart_coord.y*8 + (loop/num)*16;
					}
					if (num == 2)
					{
						if ((i+loop+1) < ipage->item_num)
						{
							ipage->page_item[i+loop+1].x = interval.x*2 + STR_LEN_MENU*8 - 1;
							ipage->page_item[i+loop+1].y = ipage->page_item[i+loop].y;
						}
					}
				}
			}
		}
		break;



	}

	return 0;
}


/******************************************************************************
函数名称：	_rtc_printf
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	打印实时时钟
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
int _rtc_printf(u8 mode, char *str1, char *str2)
{
	char tmpstr[6]={0};
	struct timespec ts={0};
	struct rtc_time_t rtc={0};

	clk_time_get(&ts);
	timespec_to_rtc(ts,&rtc,1);
	
	sprintf(tmpstr, "20%02d-", rtc.year);
	strcat(str1, tmpstr);
	
	sprintf(tmpstr, "%02d-", rtc.month);
	strcat(str1, tmpstr);
	
	sprintf(tmpstr, "%02d", rtc.day);
	strcat(str1, tmpstr);

	switch (mode)
	{
		case LINE_MD:
			sprintf(tmpstr, "  %02d:", rtc.hour);
			strcat(str1, tmpstr);
			
			sprintf(tmpstr, "%02d:", rtc.min);
			strcat(str1, tmpstr);
			
			sprintf(tmpstr, "%02d", rtc.ms/1000);
			strcat(str1, tmpstr);
		break;

		case PAGE_MD:
			sprintf(tmpstr, "%02d:", rtc.hour);
			strcat(str2, tmpstr);
			
			sprintf(tmpstr, "%02d:", rtc.min);
			strcat(str2, tmpstr);
			
			sprintf(tmpstr, "%02d", rtc.ms/1000);
			strcat(str2, tmpstr);
		break;
	}	

	return 0;
}

/**************************************************************************
函数名称：	_set_cursor_flash
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	光标闪烁
参数说明：	no: 当前屏内哪一项显示
			y: 纵坐标，即第几行
返回值：  	成功返回0.
修改记录：	
*/
int _set_cursor_flash(u8 no, u8 x, u8 y, u8 mode)
{
	u8 len;
	char str[21];
	
	// 取出光标对应的数据位
	if (g_set_dis[no].list)
	{
		len = g_set_dis[no].lenth;
		memcpy(str, g_set_dis[no].str[SET_DATA], len);
		str[len] = '\0';		
	}
	else
	{
		str[0] = g_set_dis[no].str[SET_DATA][g_set_dis[no].cursor];
		str[1] = '\0';
		len = 1;
	}
	fmt_StrPrintf(x + g_set_dis[no].cursor*8, y, len, mode, str);

	return 0;
}
/******************************************************************************
函数名称：	_equ_di_index_init
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	检索di的配置对应关系
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
int _equ_di_index_init(void)
{
	int i,sw;
	int index=0;
	u8 remainder = 0;

	for(i=0;i<PUB_DI_NUM;i++)
	{
		if((short)g_sw_pub.di_cfg_index[i]!=INDEX_INVALLID)  //此遥信有配置
		{				
			g_cfg_index.pub_di[index] = g_sw_pub.di_cfg_index[i];
			index++;
		}
	}

	index = 0;
	for(sw=0; sw<SWITCH_NUM_MAX; sw++)
	{
		for(i=0;i<SW_DI_NUM;i++)
		{
			if((short)g_sw[sw].di_cfg_index[i]!=INDEX_INVALLID)  //此遥信有配置
			{				
				g_cfg_index.sw_di[index] = g_sw[sw].di_cfg_index[i];
				index++;
			}
		}
		//此处这样处理是为了当一个开关的开入显示完了之后不接着显示下一个开关的开入，而是零流留空白，等到换页之后才显示下一个开关的开入
		if(index != 0)
		{
			//有配置才处理
			remainder = (index % page_table[MENU_SW_YX].wnd_item);
			if(remainder != 0)
				index += (page_table[MENU_SW_YX].wnd_item - remainder);
		}
	}	

	return 0; 
}

/******************************************************************************
函数名称：	_equ_do_index_init
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	检索do的配置对应关系
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
int _equ_do_index_init(void)
{
	int i,sw;
	int index=0;
	
	for(i=0;i<PUB_DO_NUM;i++)
	{
		if((short)g_sw_pub.do_cfg_index[i]!=INDEX_INVALLID)  //此开出有配置
		{				
			g_cfg_index.kc[index][0] = g_sw_pub.do_cfg_index[i];
			g_cfg_index.kc[index][1] = i;
			index++;
		}
	}

	for(sw=0; sw<g_sw_num; sw++)
	{
		for(i=0;i<SW_DO_NUM;i++)
		{
			if((short)g_sw[sw].do_cfg_index[i]!=INDEX_INVALLID)  //此开出有配置
			{				
				g_cfg_index.kc[index][0] = g_sw[sw].do_cfg_index[i];
				g_cfg_index.kc[index][1] = i;
				index++;
			}
		}
	}	

	return 0; 
}

/******************************************************************************
函数名称：	_lcd_size_check
函数版本：	01.01
创建作者：	钟务贵
创建日期：	2014-12-16
函数说明：	液晶尺寸自动判断
参数说明：	无
返回值：  	成功返回0.
修改记录：	
*/
int _lcd_size_check(struct lcdsize *lcd)
{
	int i;

	if ((lcd->x < 128) || (lcd->y < 32))
	{
		return -1;
	}
	
	for (i=0; i<SIZE_NUM-1; i++)
	{
		if ((lcd->x <= lcd_size_default[i].x)
			&& (lcd->y <= lcd_size_default[i].y))
		{
			return i+1;
		}
	}

	return -2;
}


/*------------------------------ 测试函数 -------------------------------------
一个实体文件必须带一个本模块的测试函数来进行单元测试，如果的确不方便在本模块中
进行单元测试，必须在此注明实际的测试位置（例如在哪个实体文件中使用哪个测试函数）.
*/


/*------------------------------ 文件结束 -------------------------------------
*/