/***************************************************************************
 *     Copyright (c) 2003-2006, Broadcom Corporation
 *     All Rights Reserved
 *     Confidential Property of Broadcom Corporation
 *
 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
 *
 * $brcm_Workfile:  $
 * $brcm_Revision:  $
 * $brcm_Date: $
 *
 * Module Description:
 *
 * Revision History:
 *
 * $brcm_Log:  $
 *
 ***************************************************************************/

#include "bapp.h"
#include "bsettop_display.h"
#include "bstd.h"
#include "bapp_util.h"
#include "ministd.h"
#include "bgfx.h"
#include "chan_mgr.h"
#include "bscreen_status_str.c"
#include "bscreen.h"

BDBG_MODULE(bscreen_status);		 /* Register software module with debug interface */

static float power_level = 0.0;
#if 0
static bsettop_display_format_t s_temp_format;
static bool s_confirm_change = false;
#define CONFIRM_TIMEOUT_TICKS	MS_TO_TICKS(10 * 1000)
#endif
extern bool g_disable_fcc; 

int get_fraction(float val, bool *minus)
{
    int i;
    *minus = 0;

    if (val >= 0.0) {
        i = (val - (int)val) * 100;
    }
    else if (val >= -1.0) {
        i = 100 - ((1.0 - (int)val) + val) * 100;
        *minus = 1;
    }
    else {
        i = 100 - ((1.0 - (int)val) + val) * 100;
    }
    return i;
}

#define MAX_TSTR_LEN	128
typedef enum dbg_layout_t
{
	eINFO_X   		   = eSCREEN_ACTION_SAFE_X,
	eINFO_STATUS_X     = eSCREEN_ACTION_SAFE_X + 20,
	eINFO_STATUS_Y     = eSCREEN_ACTION_SAFE_Y,
	eINFO_COL_WIDTH    = eSCREEN_ACTION_SAFE_WIDTH/2,
	eINFO_COL_LABEL_WIDTH  = eINFO_COL_WIDTH,
	eINFO_ROW_HEIGHT   = 24,
	eINFO_HELP_Y       = (eSCREEN_ACTION_SAFE_HEIGHT + eSCREEN_ACTION_SAFE_Y - eINFO_ROW_HEIGHT),
	eCH_MAP_START_X    = eSCREEN_ACTION_SAFE_X,
	eCH_MAP_START_Y    = eSCREEN_ACTION_SAFE_Y,
	eCH_MAP_HDR_Y      = (eSCREEN_ACTION_SAFE_Y + eINFO_ROW_HEIGHT),
	eCH_MAP_ROW_Y      = eCH_MAP_HDR_Y,
	eCH_MAP_COL_WIDTH  = (eSCREEN_ACTION_SAFE_WIDTH/6),
	eCH_MAP_ROW_HEIGHT = 24,
	eCH_MAP_NUM_ROW    = (((eSCREEN_ACTION_SAFE_HEIGHT - 3*eINFO_ROW_HEIGHT)/eCH_MAP_ROW_HEIGHT) - 1),
	eDIAG_ROW_HEIGHT   = 24,
	eDIAG_START_X      = eSCREEN_ACTION_SAFE_X,
	eDIAG_MENU_X       = (eDIAG_START_X + 20),
	eDIAG_START_Y      = eSCREEN_ACTION_SAFE_Y,
	eDIAG_HELP_Y       = (eSCREEN_ACTION_SAFE_Y + eSCREEN_ACTION_SAFE_HEIGHT - eDIAG_ROW_HEIGHT),
	eDIAG_COL_WIDTH    = (eSCREEN_ACTION_SAFE_WIDTH),
}dbg_layout_t;

typedef enum sys_info_state_t
{
	eSYS_CODE_0,
	eSYS_CODE_1,
	eSYS_CODE_2,
	eSYS_CODE_MAX,
}sys_info_state_t;

typedef struct sys_info_t
{
	sys_info_state_t state;
	unsigned int code;
}sys_info_t;

static sys_info_t s_sys_info = { eSYS_CODE_0, 0};

static char ts_str[MAX_TSTR_LEN + 1];


static char* get_qam_mode_str(btuner_qam_mode mode)
{
	switch (mode)
	{
	default:
	case eQAM_16: break;
	case eQAM_64: return "QAM 64";
	case eQAM_256: return "QAM 256";
	}
	return "?";

}

/*
Summary:
	Handle special debug commands for test purposes or diagnostics.
*/

static void bscreen_sys_info_handler(bapp_t *p_app,bscreen_t *p_screen, bIR_codes_t code)
{
	static unsigned int s_timeout = 0;
	static chm_event_t evt;

	BDBG_WRN(("%s 0x%08x %d\n",__FUNCTION__,s_sys_info.code,s_sys_info.state));
	if (s_timeout < bos_getticks())
	{
		s_sys_info.code = 0;
		s_sys_info.state = 0;
	}
	s_sys_info.code |= (code & 0xFF) << (8 * s_sys_info.state);
	s_sys_info.state++;
	BDBG_WRN(("%s 0x%08x %d\n",__FUNCTION__,s_sys_info.code,s_sys_info.state));
	s_timeout = bos_getticks() + MS_TO_TICKS(BANNER_10_KEY_TIMEOUT);
#ifdef BCM_DEBUG
	if (s_sys_info.state == eSYS_CODE_MAX)
	{
		switch (s_sys_info.code)
		{
		case 0x00030303:
			{
				bscreen_event_t screen_event;
				bapp_reset_settings(p_app);
				screen_event.type = eS_EVENT_IR;
				screen_event.id = eIR_CHMAP;
				bapp_handle_event(p_app, &screen_event);
			}	
			break;
		case 0x00010203:
			{
				bscreen_event_t screen_event;
				bapp_reset_settings(p_app);
				p_app->settings.psi_scan = 0;
				p_app->chm.fe_type = eFREQ_TABLE_NORTH_AMERICA_QAM;
				screen_event.type = eS_EVENT_IR;
				screen_event.id = eIR_SCAN;
				bapp_handle_event(p_app, &screen_event);
			}
			break;
		case 0x00040506:
			{
				bscreen_event_t screen_event;
				bapp_reset_settings(p_app);
				screen_event.type = eS_EVENT_IR;
				screen_event.id = eIR_SETUP;
				bapp_handle_event(p_app, &screen_event);
			}
			break;
		case 0x00070809:
			{
				bscreen_event_t screen_event;
				bapp_reset_settings(p_app);
				p_app->settings.psi_scan = 1;
#ifdef CONFIG_DVB
				p_app->settings.dvb_scan = 0;
#endif
				screen_event.type = eS_EVENT_IR;
				screen_event.id = eIR_SCAN;
				bapp_handle_event(p_app, &screen_event);
			}
			break;
#ifdef CONFIG_DVB
		case 0x00090807:
			{
				bscreen_event_t screen_event;
				bapp_reset_settings(p_app);
				p_app->settings.psi_scan = 1;
				p_app->settings.dvb_scan = 1;
				screen_event.type = eS_EVENT_IR;
				screen_event.id = eIR_SCAN;
				bapp_handle_event(p_app, &screen_event);
			}
			break;
#endif
		case 0x00010101:
			evt.id = 1;
			evt.type = eCHM_EVT_ACTIVATION;
			bos_post_event(p_app->msg_queue,(b_event_t*)&evt);
			break;
		case 0x00020101:
			evt.id = 0;
			evt.type = eCHM_EVT_ACTIVATION;
			bos_post_event(p_app->msg_queue,(b_event_t*)&evt);
			break;
		case 0x00010102:
			evt.id = 0x1F;
			evt.type = eCHM_EVT_LOCATION;
			bos_post_event(p_app->msg_queue,(b_event_t*)&evt);
			break;
		case 0x00020102:
			evt.id = 0x2E;
			evt.type = eCHM_EVT_LOCATION;
			bos_post_event(p_app->msg_queue,(b_event_t*)&evt);
			break;
		case 0x00010103:
		case 0x00020103:
		case 0x00030103:
		case 0x00040103:
			evt.id = (s_sys_info.code >> 16) & 0xFF;
			evt.type = eCHM_EVT_RESET;
			bos_post_event(p_app->msg_queue,(b_event_t*)&evt);
			break;
		case 0x00010104:
			evt.id = 0;
			evt.type = eCHM_EVT_PHONENUMBER;
			strcpy(evt.data,"9228188");
			bos_post_event(p_app->msg_queue,(b_event_t*)&evt);
			break;
#ifdef	CONFIG_DYNAMIC_RFM_MODE
		case 0x00010006:	/* 601 */
			chm_toggle_comp_mode(&p_app->chm, true);
			break;
#endif
		case 0x00060606:
			evt.id = 0;
			evt.type = eCHM_EVT_DOWNLOAD;
			bos_post_event(p_app->msg_queue,(b_event_t*)&evt);
			break;
		default:
			break;
		}
		s_sys_info.state = eSYS_CODE_0;
		s_sys_info.code = 0;
	}
#endif
}
/*
Summary:
	Return the current DTA mode string.
*/

static void bscreen_get_dta_mode_str(bapp_t *p_app,
									 char *p_str	 /* On input the max length in words on output the actual size in characters. */
									)
{
	switch (p_app->state)
	{
	case eAPP_STATE_HUNT:
		strcpy(p_str,"Hunting");
		break;
	case eAPP_STATE_PENDING:
		strcpy(p_str,"Pending");
		break;
	case eAPP_STATE_NORMAL:
		strcpy(p_str,"Normal");
		break;
	case eAPP_STATE_DOWNLOAD:
		strcpy(p_str,"Downloading");
		break;
	case eAPP_STATE_FACTORY:
		strcpy(p_str,"Factory");
		break;
	case eAPP_STATE_DEFAULT:
	case eAPP_STATE_DONE:
		strcpy(p_str,"Default");
		break;
	}
	if (p_app->settings.av_mute)
	{
		strcpy(&(p_str[strlen(p_str)]),"(Standby)");
	}
}

/*
Summary:
	Return status strings.
*/

static void bscreen_general_info_str(bapp_t *p_app,
							  bscreen_t *p_screen,
							  int text_id,		 /* Text id */
							  unsigned int *p_uni_str,	  /* Buffer to put UNI string into */
							  unsigned int *str_len,	   /* On input the max length in words on output the actual size in characters. */
							  void *data				/* User data */
							 )
{
	unsigned char hw_address[5];
	unsigned char mac_address[6];
	get_hw_address(hw_address);
	get_mac_address(mac_address);
	*str_len = 0;

	switch (text_id)
	{
	case 0:  
		strcpy(ts_str,DEF_VENDOR_NAME);
		*str_len = strlen(ts_str);
		break;
	case 1:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X",DEF_VENDOR_ID); break;
	case 2:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X",DEF_HARDWARE_ID); break;
	case 3:  
		if (p_app->settings.CA_System_ID == 0x4749)
			*str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s",get_unit_address_str()); 
		else
			*str_len = snprintf(ts_str,MAX_TSTR_LEN,"%02X:%02X:%02X:%02X:%02X",hw_address[4],
						 hw_address[3],hw_address[2],hw_address[1],hw_address[0]); 
		printf("UNIT ADDR:  %s\n",get_unit_address_str());
		
				break;
	case 4:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%02X:%02X:%02X:%02X:%02X:%02X",mac_address[5],mac_address[4],
								 mac_address[3],mac_address[2],mac_address[1],mac_address[0]); break;

	}
	if (*str_len)
	{
		*str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
	}
}

/*
Summary:
	Return status strings.
*/

static void bscreen_msg_status_str(bapp_t *p_app,
							  bscreen_t *p_screen,
							  int text_id,		 /* Text id */
							  unsigned int *p_uni_str,	  /* Buffer to put UNI string into */
							  unsigned int *str_len,	   /* On input the max length in words on output the actual size in characters. */
							  void *data				/* User data */
							 )
{
	*str_len = 0;

	switch (text_id)
	{
	case 0:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"Count"); break;
	case 1:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.cds_cnt); break;
	case 2:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.mms_cnt); break;
	case 3:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.sns_cnt); break;
	case 4:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.dcm_cnt); break;
	case 5:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.vcm_cnt); break;
	case 6:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.stt_cnt); break;
	case 7:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.ops_cnt); break;
	case 8:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.cfg_cnt); break;
	case 9:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.eas_cnt); break;
	case 10:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.em_cnt); break;
	case 11:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d/%d",p_app->chm.cat_cnt,p_app->chm.system_id_errors); break;
	default:
		*str_len = 0;
		break;
	}
	if (*str_len)
	{
		*str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
	}
}

/*
Summary:
	Return status strings.
*/
#if 0
static void bscreen_code_objects_str(bapp_t *p_app,
							  bscreen_t *p_screen,
							  int text_id,		 /* Text id */
							  unsigned int *p_uni_str,	  /* Buffer to put UNI string into */
							  unsigned int *str_len,	   /* On input the max length in words on output the actual size in characters. */
							  void *data				/* User data */
							 )
{
	*str_len = 0;

	switch (text_id)
	{
	case 0:  
	default:
		*str_len = 0;
		break;
	}
	if (*str_len)
	{
		*str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
	}
}
#endif
/*
Summary:
	Return status strings.
*/

static void bscreen_code_download_str(bapp_t *p_app,
							  bscreen_t *p_screen,
							  int text_id,		 /* Text id */
							  unsigned int *p_uni_str,	  /* Buffer to put UNI string into */
							  unsigned int *str_len,	   /* On input the max length in words on output the actual size in characters. */
							  void *data				/* User data */
							 )
{
	*str_len = 0;

	switch (text_id)
	{
	case 0:  
	default:
		*str_len = 0;
		break;
	}
	if (*str_len)
	{
		*str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
	}
}

/*
Summary:
	Return status strings.
*/

static void bscreen_tuner_status_str(bapp_t *p_app,
							  bscreen_t *p_screen,
							  int text_id,		 /* Text id */
							  unsigned int *p_uni_str,	  /* Buffer to put UNI string into */
							  unsigned int *str_len,	   /* On input the max length in words on output the actual size in characters. */
							  void *data				/* User data */
							 )
{
	unsigned int freq_mhz;
	unsigned int frac_freq_mhz;
	vch_t vch;
	st_t    st;
	freq_t freq;
	bool valid, minus;
	*str_len = 0;

    int fraction;

    /* Get get power level - NEEDS TUNING FOR EACH BOARD DESIGN */
	power_level = ((int)p_app->power_level);
	power_level = power_level/256.0;
    
	fraction = get_fraction(power_level, &minus);
	freq_mhz = frac_freq_mhz = 0;
	valid = ch_map_get_current(bapp_cur_ch_map(p_app),&vch,&st,&freq);
	if (valid)
	{
	freq_mhz = freq.freq_khz/1000;
	frac_freq_mhz = freq.freq_khz - (freq_mhz * 1000);
	}
	else
	{
		freq_mhz = p_app->tuned_freq/1000000;
		frac_freq_mhz = (p_app->tuned_freq / 1000) - (freq_mhz * 1000);
	}

	switch (text_id)
	{
	case 0:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%03d.%03d",freq_mhz,frac_freq_mhz); break;
	case 1:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%c%d.%01d",(minus ? '-' : ' '), (int)power_level, fraction); break;
	case 2:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",p_app->snr); break;
	case 3:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s",(p_app->settings.has_CAT ? "Yes" : "No")); break;
	case 4:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X",p_app->settings.CA_System_ID); break;
	case 5:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X",p_app->settings.EMM_PID); break;
	case 6:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X",p_app->settings.EMM_Provider_ID); break;
	case 7:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s",(p_app->has_PAT ? "Yes" : "No")); break;
	case 8:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X",p_app->settings.network_PID); break;
	default:
		*str_len = 0;
		break;
	}
	if (*str_len)
	{
		*str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
	}
}
/*
Summary:
	Return status strings.
*/

static void bscreen_ch_status_str(bapp_t *p_app,
							  bscreen_t *p_screen,
							  int text_id,		 /* Text id */
							  unsigned int *p_uni_str,	  /* Buffer to put UNI string into */
							  unsigned int *str_len,	   /* On input the max length in words on output the actual size in characters. */
							  void *data				/* User data */
							 )
{
	unsigned int freq_mhz;
	unsigned int frac_freq_mhz;
	vch_t vch;
	st_t    st;
	freq_t freq;
	mms_t mms;
	bool valid;
	*str_len = 0;

	valid = ch_map_get_current(bapp_cur_ch_map(p_app),&vch,&st,&freq);

	if (valid)
	{
	freq_mhz = freq.freq_khz/1000;
	frac_freq_mhz = freq.freq_khz - (freq_mhz * 1000);
	
	ch_map_get_mms(bapp_cur_ch_map(p_app),vch.mms_idx,&mms);
	}
	else
	{
		freq_mhz = frac_freq_mhz = 0;
		memset(&vch,0,sizeof(vch));
		memset(&st,0,sizeof(st));
		memset(&freq,0,sizeof(freq));
		memset(&mms,0,sizeof(mms));
	}

	switch (text_id)
	{
	case 0:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",vch.ch_num); break;
	case 1:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%03d.%03d",freq_mhz,frac_freq_mhz); break;
	case 2:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s",get_qam_mode_str(mms.modulation)); break;
	case 3:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",vch.program_num); break;
	case 4:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X",vch.video_pid); break;
	case 5:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X%s",vch.audio_pid[0],(vch.cur_audio == 0) ? "*" : " "); break;
	case 6:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X%s",vch.audio_pid[1],(vch.cur_audio == 1) ? "*" : " "); break;
	case 7:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X%s",vch.audio_pid[2],(vch.cur_audio == 2) ? "*" : " "); break;
	case 8:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s",(p_app->audio_mute ? "Yes" : "No")); break;
	default:
		*str_len = 0;
		break;
	}
	if (*str_len)
	{
		*str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
	}
}
/*
Summary:
	Return status strings.
*/
static const char *s_mon_str[] =
{
	"Jan", "Feb", "Mar", "Apr", "May", "Jun",
	"Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
};

static void bscreen_dta_status_str(bapp_t *p_app,
							  bscreen_t *p_screen,
							  int text_id,		 /* Text id */
							  unsigned int *p_uni_str,	  /* Buffer to put UNI string into */
							  unsigned int *str_len,	   /* On input the max length in words on output the actual size in characters. */
							  void *data				/* User data */
							 )
{
	unsigned int turn_on_freq_mhz;
	unsigned int frac_turn_on_freq_mhz;
	int time_offset = p_app->settings.utc_offset;
	b_tm utc_time;

	*str_len = 0;
	turn_on_freq_mhz = p_app->settings.turn_on_freq_khz/1000;
	frac_turn_on_freq_mhz = p_app->settings.turn_on_freq_khz - (turn_on_freq_mhz * 1000);
	
	if ((p_app->system_time > p_app->settings.dst_entry) && (p_app->system_time < p_app->settings.dst_exit))
	{
		/* TODO Check p_app->settings.dst_delta per spec */
		time_offset += 3600;
	}
	utctime(p_app->system_time + time_offset,&utc_time);
	
	switch (text_id)
	{
	case 0:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s",p_app->settings.activated ? "Yes" : "No"); break;
	case 1:  
		*str_len = MAX_TSTR_LEN;
		bscreen_get_dta_mode_str(p_app,ts_str); 
		*str_len = strlen(ts_str);
		break;
	case 2:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d.%d",turn_on_freq_mhz,frac_turn_on_freq_mhz); break;
	case 3:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",p_app->settings.timeout); break;
	case 4:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",p_app->settings.timeout_cnt); break;
	case 5:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",p_app->settings.location_errors); break;
	case 6:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X",p_app->settings.location); break;
	case 7:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X",p_app->location); break;
	case 8:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%2d %s %4d %2d:%2d:%2d",
								 utc_time.tm_mday,s_mon_str[utc_time.tm_mon],utc_time.tm_year + 1980, 
								 utc_time.tm_hour,utc_time.tm_min,utc_time.tm_sec); break;
	case 9:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",(int)p_app->settings.utc_offset/3600); break;
	case 10:  
		utctime(p_app->settings.dst_entry,&utc_time);
		*str_len = snprintf(ts_str,MAX_TSTR_LEN,"%2d %s %4d %2d:%2d:%2d",
								 utc_time.tm_mday,s_mon_str[utc_time.tm_mon],utc_time.tm_year + 1980, 
								 utc_time.tm_hour,utc_time.tm_min,utc_time.tm_sec);
		break;
	case 11:  
		utctime(p_app->settings.dst_exit,&utc_time);
		*str_len = snprintf(ts_str,MAX_TSTR_LEN,"%2d %s %4d %2d:%2d:%2d",
								 utc_time.tm_mday,s_mon_str[utc_time.tm_mon],utc_time.tm_year + 1980, 
								 utc_time.tm_hour,utc_time.tm_min,utc_time.tm_sec);
		break;
	case 12:  
		utctime(p_app->settings.addressable_time + time_offset,&utc_time);
		*str_len = snprintf(ts_str,MAX_TSTR_LEN,"%2d %s %4d %2d:%2d:%2d",
								 utc_time.tm_mday,s_mon_str[utc_time.tm_mon],utc_time.tm_year + 1980, 
								 utc_time.tm_hour,utc_time.tm_min,utc_time.tm_sec);
		break;
	default:
		*str_len = 0;
		break;
	}
	if (*str_len)
	{
		*str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
	}
}

/*
Summary:
	Use the this function to get a UNI string.
*/
unsigned int g_acquire_ticks;
unsigned int g_tune_ticks;


static void bscreen_decoder_status_str(bapp_t *p_app,
						   bscreen_t *p_screen,
						   int text_id,		  /* Text id */
						   unsigned int *p_uni_str,	   /* Buffer to put UNI string into */
						   unsigned int *str_len,	/* On input the max length in words on output the actual size in characters. */
						   void *data)
{
	static bdecode_status status;
	static baudio_decode_status 	audio_status;
	baudio_decode_config aud_config;
	bool valid;
	vch_t vch;
	st_t    st;
	freq_t freq;
	baudio_decode_get_status(p_app->audio, &audio_status);
	bdecode_get_status(p_app->decode,&status);

	valid = ch_map_get_current(bapp_cur_ch_map(p_app),&vch,&st,&freq);
	bdecode_get_status(p_app->decode,&status);

	memset(&aud_config, 0, sizeof(aud_config));
	baudio_decode_get_config(p_app->audio, &aud_config);

	valid = ch_map_get_current(bapp_cur_ch_map(p_app),&vch,&st,&freq);

	switch (text_id)
	{
	case 0: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X, 0x%04X, 0x%04X",status.vPID,audio_status.pid,status.pcrPID); break;
	case 1: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X/0x%08X",status.video_stc,status.video_pts); break;
	case 2: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X/0x%08X",audio_status.stc,audio_status.pts); break;
	case 3: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",(int)audio_status.pts - (int)status.video_pts); break;
	case 4: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d,%d,%d",(int)audio_status.stc-(int)audio_status.pts); break;
	case 5: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d,%d,%d",(int)status.video_stc-(int)status.video_pts);  break;
	case 6: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d/%d,%d/%d",audio_status.fifo_depth,audio_status.fifo_size,status.video_fifo_depth,status.video_fifo_size); break;
	case 7: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d:%d(%s,%d)",status.source_width,status.source_height,(status.bStreamProgressive ? "P" : "I"),status.video_aspect_ratio); break;
	case 8: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",p_app->tune_ms); break;
	case 9: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d,%d",TICKS_TO_MS(g_tune_ticks),TICKS_TO_MS(g_acquire_ticks)); break;
	case 10: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d/%d/%d",p_app->si_ms,TICKS_TO_MS(status.seq_ticks),TICKS_TO_MS(status.first_pts_ticks)); break;
	case 11: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s", "stereo"); break;
	default:
		*str_len = 0;
		break;
	}

	if (*str_len)
	{
		*str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
	}
}

/*
Summary:
	Status screen drawing function.
*/
static void bscreen_diag_list_draw(bapp_t *p_app, 
									 bscreen_t *p_screen,
									 const unsigned char *p_title_str,
									 const unsigned char *p_label_str[],
									 get_str_t get_str_fcn,
	 								 bool track_selection
									)
{
	uint16_t x,y,y_off;
	unsigned int num_chars = 0;
	bcolor_idx_t text_color;
	int i;

	x = eINFO_STATUS_X;
	y = eINFO_STATUS_Y;

	i = 0;

	y += eINFO_ROW_HEIGHT + 6;

	while (*(p_label_str[i]) != '\0')
	{
		text_color = eCOLOR_WHITE;
		y_off = y + (i * eINFO_ROW_HEIGHT);
		if ((y_off + eINFO_ROW_HEIGHT) >= eHEIGHT)
		{
			BDBG_WRN(("%s too many rows %d, y = %d\n",__FUNCTION__,i,y_off));
			break;
		}
		bgfx_fill_rect(&p_app->surf,x,y_off,eWIDTH - x,eINFO_ROW_HEIGHT,eCOLOR_BLACK);
		num_chars = strlen(p_label_str[i]);
		num_chars = c_to_uni_str((unsigned char*)p_label_str[i],p_app->tmp_str,num_chars);

		if (track_selection && (i == p_screen->local_state))
		{
			text_color = eCOLOR_DK_YELLOW;
		}
		text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
				 x, y_off, eINFO_COL_LABEL_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, text_color,0);

		num_chars = SCREEN_MAX_STR_WIDTH;
		get_str_fcn(p_app,p_screen,i,p_app->tmp_str, &num_chars,NULL);
		text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
				 x + eINFO_COL_LABEL_WIDTH, y_off, eWIDTH - x - eINFO_COL_WIDTH, eINFO_ROW_HEIGHT, 
				 p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
		i++;
	}
}

/*
Summary:
	Status screen drawing function.
*/
static void bscreen_diag_draw(bapp_t *p_app, 
								bscreen_t *p_screen,
								const unsigned char *p_title_str,
								const unsigned char *p_help_str,
								const unsigned char *p_label_str[],
								get_str_t get_str_fcn,
  								bool track_selection
							   )
{
	uint16_t x,y;
	unsigned int num_chars = 0;
	int i,page;

	page = p_screen->local_state;
	x = eINFO_X;
	y = eINFO_STATUS_Y;

	bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);

	i = 0;
	bgfx_fill_rect(&p_app->surf,x,y,eWIDTH - x,eINFO_ROW_HEIGHT,eCOLOR_BLACK);
	num_chars = strlen(p_title_str);
	num_chars = c_to_uni_str((unsigned char*)p_title_str,p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_MED],
			 x, y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);

	bscreen_diag_list_draw(p_app,p_screen,p_title_str,p_label_str,get_str_fcn,track_selection);

	num_chars = strlen(p_help_str);
	num_chars = c_to_uni_str((unsigned char*)p_help_str,p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 x, eINFO_HELP_Y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);

}

int bscreen_diag_event(bapp_t *p_app, bscreen_t *p_screen, 
						 bscreen_event_t *p_event,
					     void (*draw_fcn)(void *v_app, void *v_screen),
					     int refresh)
{
	int result = 0;
	static int cnt = 0;

	switch (p_event->type)
	{
	case eS_EVENT_SETUP:
		p_screen->local_state = 0;
		bapp_enable_cc(p_app, 0);
		result = 1;
		break;

	case eS_EVENT_IDLE:
		if (refresh <= 0)
			break;
		if (cnt++ == 10)
		{
			cnt = 0;
			draw_fcn(p_app,p_screen);
			result = 1;
		}
		break;

	case eS_EVENT_IR:
		{
			BDBG_WRN(("%s:%d 0x%02x(%s)\n",__FUNCTION__,__LINE__,p_event->id,(p_event->id & 0x40000000) ? "up" : "down"));
			switch (p_event->id)
			{
			case eIR_INFO:
				bapp_set_current_screen(p_app, eSCREEN_BANNER, eSCREEN_MAX);
				result = 1;
				break;
			case eIR_PRECH:
				bapp_set_current_screen(p_app, eSCREEN_DIAG_MENU, eSCREEN_MAX);
				result = 1;
				break;
			default:
				break;
			}
			break;
		}
		break;
	default:
		result = bscreen_default_event(p_app,p_screen,p_event);
		break;
	}
	return result; /* always handle event */
}
/*
Summary:
	Status screen drawing function.
*/
void bscreen_sys_info_draw(void *v_app, void *v_screen)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_GENERAL_INFO],
						(unsigned char *)s_diag_help_simple,s_general_info_str,
						(get_str_t)bscreen_general_info_str,false);
}
/*
Summary:
	Status screen event handling function.
*/
int bscreen_sys_info_event(void *v_app, void *v_screen, 
						   bscreen_event_t *p_event)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	return bscreen_diag_event(p_app,p_screen,p_event,bscreen_sys_info_draw,-1);
}

/*
Summary:
	Status screen drawing function.
*/
void bscreen_dta_status_draw(void *v_app, void *v_screen)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_DTA_STATUS],
						(unsigned char *)s_diag_help_simple,s_dta_status_str,
						(get_str_t)bscreen_dta_status_str,false);
}
/*
Summary:
	Status screen event handling function.
*/
int bscreen_dta_status_event(void *v_app, void *v_screen, 
						   bscreen_event_t *p_event)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	return bscreen_diag_event(p_app,p_screen,p_event,bscreen_dta_status_draw,1);
}
/*
Summary:
	Status screen drawing function.
*/
void bscreen_tuner_status_draw(void *v_app, void *v_screen)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_TUNER_STATUS],
						(unsigned char *)s_diag_help_default,s_tuner_status_str,
						(get_str_t)bscreen_tuner_status_str,false);
}
/*
Summary:
	Status screen event handling function.
*/
int bscreen_tuner_status_event(void *v_app, void *v_screen,
						   bscreen_event_t *p_event)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	return bscreen_diag_event(p_app,p_screen,p_event,bscreen_tuner_status_draw,1);
}
/*
Summary:
	Status screen drawing function.
*/
void bscreen_decoder_status_draw(void *v_app, void *v_screen)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_DECODER_STATUS],
						(unsigned char *)s_diag_help_simple,s_decoder_status_str,
						(get_str_t)bscreen_decoder_status_str,false);
}
/*
Summary:
	Status screen event handling function.
*/
int bscreen_decoder_status_event(void *v_app, void *v_screen,
						   bscreen_event_t *p_event)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	return bscreen_diag_event(p_app,p_screen,p_event,bscreen_decoder_status_draw,1);
}

/*
Summary:
	Status screen drawing function.
*/
void bscreen_ch_status_draw(void *v_app, void *v_screen)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_CH_STATUS],
						(unsigned char *)s_diag_help_in_use,s_ch_status_str,
						(get_str_t)bscreen_ch_status_str,false);
}
/*
Summary:
	Status screen event handling function.
*/
int bscreen_ch_status_event(void *v_app, void *v_screen,
						   bscreen_event_t *p_event)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	return bscreen_diag_event(p_app,p_screen,p_event,bscreen_ch_status_draw,1);
}


int bscreen_diag_menu_event(void *v_app, void *v_screen, 
							bscreen_event_t *p_event)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	int result = 0;

	switch (p_event->type)
	{
	case eS_EVENT_SETUP:
		// Don't reset so we return with same item selectd p_screen->local_state = 0;
		s_sys_info.state = eSYS_CODE_0;
		bapp_enable_cc(p_app, 0);
		bapp_audio_do_mute(p_app, true);
		result = 1;
		break;
	case eS_EVENT_IDLE:
		{
			/* Do anything that requires periodic action here */
		}
		break;

	case eS_EVENT_IR:
		{
			BDBG_WRN(("%s:%d 0x%02x(%s)\n",__FUNCTION__,__LINE__,p_event->id,(p_event->id & 0x40000000) ? "up" : "down"));
			switch (p_event->id)
			{
			
			case eIR_CH_UP:
			case eIR_UP:
				p_screen->local_state -= 1;
				if ((int)p_screen->local_state <= 0)
					p_screen->local_state = 0;
				result = 1;
				break;
			case eIR_CH_DOWN:
			case eIR_DOWN:
				p_screen->local_state += 1;
				if (p_screen->local_state >= eMM_IDX_NUM)
					p_screen->local_state = eMM_IDX_NUM - 1;
				result = 1;
				break;
			case eIR_SELECT:
				switch (p_screen->local_state)
				{
				case 0:
					bapp_set_current_screen(p_app, eSCREEN_SYS_INFO, eSCREEN_MAX);
					result = 1;
					break;
				case 1:
					bapp_set_current_screen(p_app, eSCREEN_DTA_STATUS, eSCREEN_MAX);
					result = 1;
					break;
				case 2:
					bapp_set_current_screen(p_app, eSCREEN_MSO_INFO, eSCREEN_MAX);
					result = 1;
					break;
				case 3:
					bapp_set_current_screen(p_app, eSCREEN_TUNER_STATUS, eSCREEN_MAX);
					result = 1;
					break;
				case 4:
					bapp_set_current_screen(p_app, eSCREEN_CH_STATUS, eSCREEN_MAX);
					result = 1;
					break;
				case 5:
					bapp_set_current_screen(p_app, eSCREEN_CH_MAP_STATUS, eSCREEN_MAX);
					result = 1;
					break;
				case 6:
					bapp_set_current_screen(p_app, eSCREEN_MSG_STATUS, eSCREEN_MAX);
					result = 1;
					break;
				case 7:
					bapp_set_current_screen(p_app, eSCREEN_CODE_OBJECTS, eSCREEN_MAX);
					result = 1;
					break;
				case 8:
					bapp_set_current_screen(p_app, eSCREEN_CODE_DOWNLOAD, eSCREEN_MAX);
					result = 1;
					break;
				case 9:
					bapp_set_current_screen(p_app, eSCREEN_DECODER_STATUS, eSCREEN_MAX);
					result = 1;
					break;
				case 10:
					bapp_set_current_screen(p_app, eSCREEN_VIDEO_FORMAT, eSCREEN_MAX);
					result = 1;
					break;
				}
				break;
			case eIR_INFO:
				bapp_set_current_screen(p_app, eSCREEN_BANNER, eSCREEN_MAX);
				result = 1;
				break;
			case eIR_0:
			case eIR_1:
			case eIR_2:
			case eIR_3:
			case eIR_4:
			case eIR_5:
			case eIR_6:
			case eIR_7:
			case eIR_8:
			case eIR_9:
				bscreen_sys_info_handler(p_app,p_screen,p_event->id);
				if (s_sys_info.state == eSYS_CODE_0) {
					//int a = result;	
				}
				break;
			}
		}
		break;

	default:
		result = bscreen_default_event(v_app,v_screen,p_event);
		break;
	}
	return result; /* always handle event */
}

/*
Summary:
	Diag menu screen drawing function
*/

void bscreen_diag_menu_draw(void *v_app, void *v_screen)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	unsigned int num_chars;
	int yoff,row;

	bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);
	num_chars = strlen(s_menu_title);
	num_chars = c_to_uni_str((unsigned char*)s_menu_title,p_app->tmp_str,num_chars);
	yoff = eDIAG_START_Y;
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_MED],
			 eDIAG_START_X, yoff, eDIAG_COL_WIDTH, eDIAG_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);

	yoff += 6;

	for (row = 0; row < eMM_IDX_NUM; ++row)
	{
		yoff += eDIAG_ROW_HEIGHT;

		if (row == p_screen->local_state)
		{
			num_chars = strlen(s_arrow);
			num_chars = c_to_uni_str((unsigned char*)s_arrow,p_app->tmp_str,num_chars);
			text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
					 eDIAG_START_X, yoff, eDIAG_COL_WIDTH, eDIAG_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
		}
		num_chars = strlen(s_main_menu[row]);
		num_chars = c_to_uni_str((unsigned char*)s_main_menu[row],p_app->tmp_str,num_chars);
		text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
				 eDIAG_MENU_X, yoff, eDIAG_COL_WIDTH, eDIAG_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
	}
	num_chars = strlen(s_menu_help);
	num_chars = c_to_uni_str((unsigned char*)s_menu_help,p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 eDIAG_START_X, eDIAG_HELP_Y, eDIAG_COL_WIDTH, eDIAG_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
}


/*
Summary:
	Diag menu screen drawing function
*/
void bscreen_mso_info_draw(void *v_app, void *v_screen)
{
	uint16_t x,y;
	unsigned int num_chars = 0;
	int i;
	bapp_t *p_app = (bapp_t*)v_app;
	unsigned char *p_str;
	x = eINFO_X;
	y = eINFO_STATUS_Y;

	bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);
	i = 0;
	bgfx_fill_rect(&p_app->surf,x,y,eWIDTH - x,eINFO_ROW_HEIGHT,eCOLOR_BLACK);
	num_chars = strlen(s_main_menu[eMM_IDX_MSO_INFO]);
	num_chars = c_to_uni_str((unsigned char*)s_main_menu[eMM_IDX_MSO_INFO],p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_MED],
			 x, y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);

	x = eINFO_STATUS_X;
	y += eDIAG_ROW_HEIGHT + 6;

	num_chars = strlen(s_mso_info_str);
	num_chars = c_to_uni_str((unsigned char*)s_mso_info_str,p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 x, y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
	
	y += eDIAG_ROW_HEIGHT;

	p_str = p_app->settings.phonenumber;
	num_chars = strlen(p_str);
	if (num_chars == 0)
		p_str = (unsigned char *)s_800_comcast;
	num_chars = strlen(p_str);
	num_chars = c_to_uni_str((unsigned char*)p_str,p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 x, y, eSCREEN_ACTION_SAFE_WIDTH, 
			 eSCREEN_ACTION_SAFE_HEIGHT - y - eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);

	x = eINFO_X;
	num_chars = strlen(s_diag_help_default);
	num_chars = c_to_uni_str((unsigned char*)s_diag_help_default,p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 x, eINFO_HELP_Y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);

}
/*
Summary:
	Code download event handler
*/
int bscreen_mso_info_event(void *v_app, void *v_screen, 
						   bscreen_event_t *p_event)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	return bscreen_diag_event(p_app,p_screen,p_event,bscreen_mso_info_draw,1);
}

/*
Summary:
	Diag menu screen drawing function
*/
void bscreen_msg_status_draw(void *v_app, void *v_screen)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	unsigned int num_chars = 0;
	int time_offset = p_app->settings.utc_offset;
	b_tm utc_time;

	if ((p_app->system_time > p_app->settings.dst_entry) && (p_app->system_time < p_app->settings.dst_exit))
	{
		/* TODO Check p_app->settings.dst_delta per spec */
		time_offset += 3600;
	}

	
	
	bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_MSG_STATUS],
						(unsigned char *)s_diag_help_simple,s_msg_status_str,
						(get_str_t)bscreen_msg_status_str,false);

	num_chars = strlen(s_msg_last_addr);
	num_chars = c_to_uni_str((unsigned char*)s_msg_last_addr,p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 eINFO_X, eINFO_HELP_Y-(2*eDIAG_ROW_HEIGHT)+8, eSCREEN_ACTION_SAFE_WIDTH/2, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
	
	utctime(p_app->settings.addressable_time + time_offset,&utc_time);
	num_chars = snprintf(ts_str,MAX_TSTR_LEN,"%2d %s %4d %2d:%2d:%2d",
							 utc_time.tm_mday,s_mon_str[utc_time.tm_mon],utc_time.tm_year + 1980, 
							 utc_time.tm_hour,utc_time.tm_min,utc_time.tm_sec);
	
	num_chars = c_to_uni_str((unsigned char*)ts_str,p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
		 eINFO_X + 300, eINFO_HELP_Y-(2*eDIAG_ROW_HEIGHT)+8, eSCREEN_ACTION_SAFE_WIDTH/2, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);


	num_chars = strlen(s_diag_help_msg_1);
	num_chars = c_to_uni_str((unsigned char*)s_diag_help_msg_1,p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 eINFO_X, eINFO_HELP_Y-eDIAG_ROW_HEIGHT+4, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
}
/*
Summary:
	Code download event handler
*/
int bscreen_msg_status_event(void *v_app, void *v_screen, 
							 bscreen_event_t *p_event)
{
	int result = 0;
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;

	switch (p_event->type)
	{
	case eS_EVENT_IR:
		{
			switch (p_event->id)
			{
			case eIR_0:
				p_app->chm.cds_cnt = p_app->chm.mms_cnt = p_app->chm.sns_cnt = 0;
				p_app->chm.dcm_cnt = p_app->chm.vcm_cnt = p_app->chm.stt_cnt = 0;
				p_app->chm.ops_cnt = p_app->chm.cfg_cnt = p_app->chm.eas_cnt = 0;
				p_app->chm.em_cnt = p_app->chm.cat_cnt = p_app->chm.system_id_errors = 0;
			default:
				result = bscreen_diag_event(p_app,p_screen,p_event,bscreen_msg_status_draw,1);
				break;
			}
			break;
		}
		break;
	default:
		result = bscreen_diag_event(p_app,p_screen,p_event,bscreen_msg_status_draw,1);
		break;
	}
	return result; /* always handle event */
}
/*
Summary:
	Status screen drawing function.
*/
void bscreen_code_objects_draw(void *v_app, void *v_screen)
{
	bapp_t *p_app = (bapp_t*)v_app;
	unsigned int num_chars;
	int y;

	bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);

	y = eCH_MAP_START_Y;
	num_chars = strlen(s_main_menu[eMM_IDX_CODE_OBJECTS]);
	num_chars = c_to_uni_str((unsigned char*)s_main_menu[eMM_IDX_CODE_OBJECTS],p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_MED],
			 eINFO_X, eCH_MAP_START_Y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
	
	y += eDIAG_ROW_HEIGHT + 6;
	num_chars = strlen(s_code_objects_str);
	num_chars = c_to_uni_str((unsigned char*)s_code_objects_str,p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 eINFO_X, y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
	
	y += eDIAG_ROW_HEIGHT;
	num_chars = strlen(s_bankA_str);
	num_chars = c_to_uni_str((unsigned char*)s_bankA_str,p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 eINFO_X, y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
	
	y += eDIAG_ROW_HEIGHT;
	num_chars = strlen(s_bankB_str);
	num_chars = c_to_uni_str((unsigned char*)s_bankB_str,p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 eINFO_X, y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
	
	num_chars = strlen(s_diag_help_simple);
	num_chars = c_to_uni_str((unsigned char*)s_diag_help_simple,p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 eINFO_X, eINFO_HELP_Y-eDIAG_ROW_HEIGHT, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
}
/*
Summary:
	Status screen event handling function.
*/
int bscreen_code_objects_event(void *v_app, void *v_screen, 
						   bscreen_event_t *p_event)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	return bscreen_diag_event(p_app,p_screen,p_event,bscreen_code_objects_draw,-1);
}
/*
Summary:
	Status screen drawing function.
*/
void bscreen_code_download_draw(void *v_app, void *v_screen)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_CODE_DOWNLOAD],
						(unsigned char *)s_diag_help_simple,s_code_download_str,
						(get_str_t)bscreen_code_download_str,false);
}
/*
Summary:
	Status screen event handling function.
*/
int bscreen_code_download_event(void *v_app, void *v_screen, 
						   bscreen_event_t *p_event)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	return bscreen_diag_event(p_app,p_screen,p_event,bscreen_code_download_draw,1);
}

int bscreen_ch_map_status_event(void *v_app, void *v_screen, 
							bscreen_event_t *p_event)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	int result = 0;

	switch (p_event->type)
	{
	case eS_EVENT_SETUP:
		p_screen->local_state = 0;
		bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);
		break;
	case eS_EVENT_IDLE:
		{
			/* Do anything that requires periodic action here */
		}
		break;

	case eS_EVENT_IR:
		{
			BDBG_WRN(("%s:%d 0x%02x(%s)\n",__FUNCTION__,__LINE__,p_event->id,(p_event->id & 0x40000000) ? "up" : "down"));
			switch (p_event->id)
			{
			case eIR_CH_UP:
			case eIR_UP:
				p_screen->local_state -= eCH_MAP_NUM_ROW;
				if ((int)p_screen->local_state < 0)
					p_screen->local_state = 0;
				result = 1;
				break;
			case eIR_CH_DOWN:
			case eIR_DOWN:
				{
					unsigned short num_vch;
					ch_map_get_vch_num(bapp_cur_ch_map(p_app),&num_vch);
	
					if ((p_screen->local_state + eCH_MAP_NUM_ROW) < num_vch)
					{
						p_screen->local_state += eCH_MAP_NUM_ROW;
					}
					result = 1;
				}
				break;
			case eIR_INFO:
				bapp_set_current_screen(p_app, eSCREEN_BANNER, eSCREEN_MAX);
				result = 1;
				break;
			case eIR_PRECH:
				bapp_set_current_screen(p_app, eSCREEN_DIAG_MENU, eSCREEN_MAX);
				result = 1;
				break;
			}
		}
		break;

	default:
		result = bscreen_default_event(v_app,v_screen,p_event);
		break;
	}
	return result; /* always handle event */
}

/*
Summary:
	Draw the header row
	.
*/
void bscreen_ch_map_header(bapp_t *p_app, bscreen_t *p_screen)
{
	unsigned int num_chars;

	/* draw titles */
	num_chars = c_to_uni_str((unsigned char*)s_ch_map_status_header[0],p_app->tmp_str,strlen(s_ch_map_status_header[0]));
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 eCH_MAP_START_X+ (0*eCH_MAP_COL_WIDTH), eCH_MAP_HDR_Y, eCH_MAP_COL_WIDTH -30, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
	num_chars = c_to_uni_str((unsigned char*)s_ch_map_status_header[1],p_app->tmp_str,strlen(s_ch_map_status_header[1]));
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 eCH_MAP_START_X + (1*eCH_MAP_COL_WIDTH) -30, eCH_MAP_HDR_Y, eCH_MAP_COL_WIDTH, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
	num_chars = c_to_uni_str((unsigned char*)s_ch_map_status_header[2],p_app->tmp_str,strlen(s_ch_map_status_header[2]));
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 eCH_MAP_START_X + (2*eCH_MAP_COL_WIDTH) -30, eCH_MAP_HDR_Y, eCH_MAP_COL_WIDTH + 30, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
	num_chars = c_to_uni_str((unsigned char*)s_ch_map_status_header[3],p_app->tmp_str,strlen(s_ch_map_status_header[3]));
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 eCH_MAP_START_X + (3*eCH_MAP_COL_WIDTH), eCH_MAP_HDR_Y, eCH_MAP_COL_WIDTH, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
	num_chars = c_to_uni_str((unsigned char*)s_ch_map_status_header[4],p_app->tmp_str,strlen(s_ch_map_status_header[4]));
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 eCH_MAP_START_X + (4*eCH_MAP_COL_WIDTH), eCH_MAP_HDR_Y, eCH_MAP_COL_WIDTH, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
	num_chars = c_to_uni_str((unsigned char*)s_ch_map_status_header[5],p_app->tmp_str,strlen(s_ch_map_status_header[5]));
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 eCH_MAP_START_X + (5*eCH_MAP_COL_WIDTH), eCH_MAP_HDR_Y, eCH_MAP_COL_WIDTH, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
}
/*
Summary:
	Draw the row
	.
*/

void bscreen_ch_map_row(bapp_t *p_app, bscreen_t *p_screen, 
							vch_t *p_vch,
							st_t *p_st,
							freq_t *p_freq,
							int y)
{
	unsigned int num_chars;
	static char tmp_buf[64];
	unsigned int freq_mhz,frac_freq_mhz;
	mms_t mms;
	freq_mhz = p_freq->freq_khz/1000;
	frac_freq_mhz = p_freq->freq_khz - (freq_mhz * 1000);
	
	/* draw row */
	num_chars = snprintf(tmp_buf,64,"%d",p_vch->ch_num);
	num_chars = c_to_uni_str(tmp_buf,p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 eCH_MAP_START_X+ (0*eCH_MAP_COL_WIDTH), y, eCH_MAP_COL_WIDTH - 30, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
	num_chars = snprintf(tmp_buf,64,"%d",p_vch->source_id);
	num_chars = c_to_uni_str(tmp_buf,p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 eCH_MAP_START_X+ (1*eCH_MAP_COL_WIDTH) - 30, y, eCH_MAP_COL_WIDTH, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
	num_chars = snprintf(tmp_buf,64,"%11s",p_st->name);
	num_chars = c_to_uni_str(tmp_buf,p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 eCH_MAP_START_X+ (2*eCH_MAP_COL_WIDTH) - 30, y, eCH_MAP_COL_WIDTH + 30, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
	num_chars = snprintf(tmp_buf,64,"%d.%d",freq_mhz,frac_freq_mhz);
	num_chars = c_to_uni_str(tmp_buf,p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 eCH_MAP_START_X+ (3*eCH_MAP_COL_WIDTH), y, eCH_MAP_COL_WIDTH, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
	
	if (ch_map_get_mms(bapp_cur_ch_map(p_app),p_vch->mms_idx,&mms))
	{
		num_chars = snprintf(tmp_buf,64,"%s",(mms.modulation == eQAM_64) ? "64" : (mms.modulation == eQAM_256) ? "256" : "N/A" );
		num_chars = c_to_uni_str(tmp_buf,p_app->tmp_str,num_chars);
		text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
				 eCH_MAP_START_X+ (4*eCH_MAP_COL_WIDTH), y, eCH_MAP_COL_WIDTH, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
	}
	num_chars = snprintf(tmp_buf,64,"%d",p_vch->program_num);
	num_chars = c_to_uni_str(tmp_buf,p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 eCH_MAP_START_X+ (5*eCH_MAP_COL_WIDTH), y, eCH_MAP_COL_WIDTH, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
}

/*
Summary:
	Test screen drawing function
	.
*/
void bscreen_ch_map_status_draw(void *v_app, void *v_screen)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	unsigned int num_chars;
	unsigned short num_vch;
	unsigned char cur_ch;
	int idx,yoff,row,page,pages;
	vch_t vch;
	st_t    st;
	freq_t freq;
	ch_map_t *p_ch_map = bapp_cur_ch_map(p_app);
	
	
	bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);
	ch_map_get_vch_num(bapp_cur_ch_map(p_app),&num_vch);

	pages = num_vch/eCH_MAP_NUM_ROW + 1;
	page = p_screen->local_state/eCH_MAP_NUM_ROW + 1;

	num_chars = snprintf(ts_str,MAX_TSTR_LEN,s_ch_map_status_info,p_app->settings.VCT_ID,num_vch,page,pages);
	num_chars = c_to_uni_str((unsigned char*)ts_str,p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 eINFO_X, eCH_MAP_START_Y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);

	bscreen_ch_map_header(p_app,p_screen);

	if (!ch_map_get_current(p_ch_map,&vch,&st,&freq))
		return;

	cur_ch = vch.ch_num; /* save current channel number */
	p_ch_map->cur_ch = p_screen->local_state;
	idx = p_screen->local_state;
	yoff = eCH_MAP_ROW_Y;
	for (row = 0; row < eCH_MAP_NUM_ROW; ++row)
	{
		if (!ch_map_get_current(p_ch_map,&vch,&st,&freq))
			break;
		yoff += eCH_MAP_ROW_HEIGHT;

		if (idx < num_vch)
		{
			bscreen_ch_map_row(p_app,p_screen,&vch,&st,&freq,yoff);
		}
		idx++;
		ch_map_set_next(p_ch_map);
	}

	num_chars = strlen(s_diag_help_ch_map);
	num_chars = c_to_uni_str((unsigned char*)s_diag_help_ch_map,p_app->tmp_str,num_chars);
	text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
			 eINFO_X, eINFO_HELP_Y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);

	if (!ch_map_set_ch(p_ch_map,cur_ch))
		return;
}
/*
Summary:
	Return status strings.
*/

static void bscreen_video_format_str(bapp_t *p_app,
							  bscreen_t *p_screen,
							  int text_id,		 /* Text id */
							  unsigned int *p_uni_str,	  /* Buffer to put UNI string into */
							  unsigned int *str_len,	   /* On input the max length in words on output the actual size in characters. */
							  void *data				/* User data */
							 )
{
	char *ts_str;
	bdisplay_settings display_settings;

	*str_len = 0;
	bdisplay_get(p_app->display,&display_settings);
	
	if (display_settings.format == text_id)
	{
		ts_str = "*";
	}else
	{
		ts_str = " ";
	}

	if (*str_len)
	{
		*str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
	}
}

#if 0
/*
Summary:
	Video format screen drawing function.
*/
void bscreen_video_format_draw(void *v_app, void *v_screen)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_VIDEO_FORMAT],
						(unsigned char *)s_video_format_help,s_video_format_str,
						bscreen_video_format_str,true);
}
/*
Summary:
	Video format screen event handling function.
*/
int bscreen_video_format_event(void *v_app, void *v_screen,
						   bscreen_event_t *p_event)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	bdisplay_settings display_settings;
	int result = 0;

	switch (p_event->type)
	{
	case eS_EVENT_SETUP:
		bdisplay_get(p_app->display,&display_settings);
		BDBG_WRN(("%s:%d last_screen_id = %d, s_confirm_change = %d\n",__FUNCTION__,__LINE__,p_screen->last_screen_id,s_confirm_change));
		if ((p_screen->last_screen_id == eSCREEN_CONFIRM_CHANGE) && (!s_confirm_change))
		{
			BDBG_WRN(("%s:%d RESET VIDEO OUTPUT FORMAT FROM %d to %d\n",__FUNCTION__,__LINE__,display_settings.format,s_temp_format));

			display_settings.format = s_temp_format;
			if (bdisplay_set(p_app->display,&display_settings) != b_ok)
			{
				s_confirm_change = false;
				BDBG_WRN(("%s:%d RESET VIDEO OUTPUT FORMAT from %d to %d FAILED\n",__FUNCTION__,__LINE__,display_settings.format,s_temp_format));
			}
		}
		p_screen->local_state = display_settings.format;
		result = 1;
		break;
	case eS_EVENT_IDLE:
		{
			/* Do anything that requires periodic action here */
		}
		break;

	case eS_EVENT_IR:
		{
			BDBG_WRN(("%s:%d 0x%02x(%s)\n",__FUNCTION__,__LINE__,p_event->id,(p_event->id & 0x40000000) ? "up" : "down"));
			switch (p_event->id)
			{
			case eIR_CH_UP:
			case eIR_UP:
				p_screen->local_state--;
				if ((int)p_screen->local_state < 0)
					p_screen->local_state = 0;
				result = 1;
				break;
			case eIR_CH_DOWN:
			case eIR_DOWN:
				{	
					p_screen->local_state++;
					if (p_screen->local_state > bdisplay_format_1080i)
					{
						p_screen->local_state = 0;
					}
					result = 1;
				}
				break;
			case eIR_SELECT:
			case eIR_ENTER:
				{
					bdisplay_get(p_app->display,&display_settings);
					s_temp_format = display_settings.format;

					if (display_settings.format == p_screen->local_state)
						break;

					display_settings.format = p_screen->local_state;
					if (bdisplay_set(p_app->display,&display_settings) == b_ok)
					{
						s_confirm_change = false;
						p_screen->last_screen_id = eSCREEN_CONFIRM_CHANGE;
						bapp_set_current_screen(p_app, eSCREEN_CONFIRM_CHANGE, eSCREEN_MAX);
					}
					result = 1;
				}
				break;
			case eIR_PRECH:
				bapp_set_current_screen(p_app, eSCREEN_DIAG_MENU, eSCREEN_MAX);
				result = 1;
				break;
			}
		}
		break;

	default:
		result = bscreen_default_event(v_app,v_screen,p_event);
		break;
	}
	return result; /* always handle event */
}
/*
Summary:
	Status screen drawing function.
*/
void bscreen_confirm_change_draw(void *v_app, void *v_screen)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	bscreen_diag_draw(p_app,p_screen,s_confirm_change_title,
						(unsigned char *)s_confirm_change_help,s_confirm_change_str,
						bscreen_code_download_str,true);
}
/*
Summary:
	Status screen event handling function.
*/
int bscreen_confirm_change_event(void *v_app, void *v_screen, 
						   bscreen_event_t *p_event)
{
	bapp_t *p_app = (bapp_t*)v_app;
	bscreen_t *p_screen = (bscreen_t*)v_screen;
	int result = 0;
	static unsigned int s_timeout_ticks;

	switch (p_event->type)
	{
	case eS_EVENT_SETUP:
		p_screen->local_state = 1;
		s_timeout_ticks = bos_getticks() + CONFIRM_TIMEOUT_TICKS;
		result = 1;
		break;
	case eS_EVENT_IDLE:
		{
			/* Do anything that requires periodic action here */
			if (s_timeout_ticks < bos_getticks())
			{
				BDBG_WRN(("%s:%d CONFIRM_CHANGE TIMEOUT\n",__FUNCTION__,__LINE__));

				s_confirm_change = false;
				bapp_goto_last_screen(p_app);
				result = 1;
			}
		}
		break;

	case eS_EVENT_IR:
		{
			BDBG_WRN(("%s:%d 0x%02x(%s)\n",__FUNCTION__,__LINE__,p_event->id,(p_event->id & 0x40000000) ? "up" : "down"));
			switch (p_event->id)
			{
			case eIR_CH_UP:
			case eIR_UP:
				p_screen->local_state--;
				if ((int)p_screen->local_state < 0)
					p_screen->local_state = 0;
				result = 1;
				break;
			case eIR_CH_DOWN:
			case eIR_DOWN:
				{	
					p_screen->local_state++;
					if (p_screen->local_state > 1)
					{
						p_screen->local_state = 0;
					}
					result = 1;
				}
				break;
			case eIR_SELECT:
			case eIR_ENTER:
				{
					s_confirm_change = (p_screen->local_state == 0) ? true : false;
					bapp_goto_last_screen(p_app);
					result = 1;
				}
				break;
			case eIR_PRECH:
				s_confirm_change = false;
				bapp_goto_last_screen(p_app);
				result = 1;
				break;
			}
		}
		break;

	default:
		result = bscreen_default_event(v_app,v_screen,p_event);
		break;
	}
	return result; /* always handle event */
}
#endif