UTS6710/aps/application/s2tek/formal/sys_common_guiobj/sc_menu.c

//**************************************************************************************************
// (c) Copyright SiS Software Ltd. - ALL RIGHTS RESERVED
// This document is the CONFIDENTIAL property of SiS Software Ltd.
//**************************************************************************************************
//
// File Name:     sc_menu.c
//
// Description:   Main menu screens
//
// Project:
//
// Creation Date:  20140912
//
// Author :Gordon.Hsu.
//**************************************************************************************************
#include "gobj_datastruct.h"
#include "app_event.h"
#include "app_atv_event.h"
#include "al_fw.h"
#include "sysapp_if.h"
#include "sysapp_table.h"
#include "app_gui.h"
#include "app_data_setting.h"
#include "app_audio.h"
#include "app_video.h"
#include "app_guiobj_monitor_mainmenu.h"
#include "app_usermenu.h"
#include "app_guiobj_sleeptimer.h"
#include "app_systime.h"
#include <sys/ioctl.h>

#include "app_area_info.h"
#include "app_global.h"
#include "app_area_info.h"

#include "app_factory_flash_access.h"
#include "app_video.h"
#include "app_menumgr.h"

//for io control
#include "kmf_ioctl.h"
#include "vip2_ioctl.h"
#include "hdmi_ioctl.h"
#include "ap_extern.h"
//Restore
#include "app_sysset.h"
#include "main_app.h"
#include "atv_guiobj_table.h"

#define DECLARE_MENU_NODE
#include "app_guiobj_menutree.h"
#undef DECLARE_MENU_NODE

//usb upgrade
#include "app_usb_upgrade.h"
#include "mid_upgrade.h"

#include "mid_partition_list.h"

//pc setting
//#include "app_guiobj_atv_pcsetup.h"
#include "mid_tvfe.h"

#include "atv_app.h"

#define APP_GUIOBJ_MENU_DEBUG
#ifdef APP_GUIOBJ_MENU_DEBUG
#undef    MENU_DEBF
#define	MENU_DEBF(fmt, arg...)	UMFDBG(0,"[Menu] [MENU DBG] %s %d \n"fmt, __func__,__LINE__,##arg)

#else
#define	MENU_DEBF(fmt, arg...)
#endif



/*macro define*/
#define APP_GUIOBJ_HDMILINK_DEBUG
#ifdef APP_GUIOBJ_HDMILINK_DEBUG
#undef	HDMILINKEDEBF
#define	HDMILINKEDEBF(fmt, arg...)	UMFDBG(0,fmt, ##arg)
#else
#define	HDMILINKEDEBF(fmt, arg...)
#endif

#define NUM_LAYER0 6
#define REFRESH_MEDIA_TIME 4

#define _CHECK_VAULE(value,max, min) \
	if (value>max) \
		value = max; \
	else if (value < min) \
		value = min;

enum {
    MENU_CHOICE_AUTO_MODE = 0,
    MENU_CHOICE_INPUT_MODE = 1,
};
typedef struct {
    BOOLEAN show_mode;          //auto , input
    int value;
    int digital_max;
    int enter_count;
    BOOLEAN enter_mode;         //
} _Menu_Choice_Item;

enum {
    MENU_LAYER_0,
    MENU_LAYER_1,
    MENU_LAYER_2,
    MENU_LAYER_3,
    MENU_LAYER_4,
    MENU_LAYER_5,
    MENU_LAYER_END,
};

static RegionHandle_t g_dRegionHandle;

static MENU_NODE_ID Current_HeadNodeId = ID_Root;
static MENU_NODE_ID Current_NodeId = ID_Root;

static MENU_NODE_ID Current_Node_Array[MONITOR_MAINMENU_MAX_NODENUM]; //suppose  items are no more than 32
static int Current_Node_Num = 0;

static INT32 g_arMenuLayerString[MONITOR_MAINMENU_MAX_ITEM + 1] = { 0 };

static INT32 g_arTextItemString[MONITOR_MAINMENU_MAX_ITEM][2];

#ifdef USE_SLIDER_INMENU
static Alignment_e ComoText_alignment = MID_CENTER; //MID_RIGHT;
#endif
//static int scroll_total_count[MAINMENU_MAX_ITEM];
//static int scroll_current_value[MAINMENU_MAX_ITEM];
//static int scroll_page_count[MAINMENU_MAX_ITEM];

static int g_menu_cur_layer = MENU_LAYER_0;

static int g_Menu_Start_Offset[MENU_LAYER_END] = { 0 };

static char **g_ppRightSide_DynamicString[MONITOR_MAINMENU_MAX_ITEM] = { NULL };

static bool g_bCloseAllFlag = TRUE;
static UINT32 g_u32Timer = 0;

static bool g_Current_Item_Selected = FALSE;

static UINT8 g_TimingString[MAX_TIMINGINFO_LEN];

//static _Menu_Choice_Item g_NetworkId_choice_item = { MENU_CHOICE_AUTO_MODE, 0, 6, 0, FALSE };
//static _Menu_Choice_Item g_frequency_choice_item = { MENU_CHOICE_AUTO_MODE, 0, 6, 0, FALSE };
//static _Menu_Choice_Item g_Symbol_choice_item = { MENU_CHOICE_AUTO_MODE, 0, 4, 0, FALSE };

#if 0
static INT32 g_AnimationOriy1[NUM_LAYER0] = { 0 };
static INT32 g_AnimationOriy2[NUM_LAYER0] = { 0 };

static BOOLEAN animation_vector = 0;
#endif
extern bool g_bAutoNetID;
static bool g_bRestoreDefaultStatus = FALSE;

void APP_GUIOBJ_Menu_UpdateArrowByType(HWND * phGuiArr, UINT8 *pCount, UINT32 type, UINT8 nIdx, ParamType_e eParamType);

/*Function declare*/
static INT32 _APP_GUIOBJ_Menu_OnCreate(void **pPrivateData, UINT32 dParameter);
static INT32 _APP_GUIOBJ_Menu_OnRelease(void *pPrivateData);
static INT32 _APP_GUIOBJ_Menu_OnFocused(void *pPrivateData);
static INT32 _APP_GUIOBJ_Menu_OnLoseFocus(void *pPrivateData);
static INT32 _APP_GUIOBJ_Menu_OnTimerUpdate(void *pPrivateData, InteractiveData_t * pPostEventData);
static INT32 _APP_GUIOBJ_Menu_OnEvent(UINT32 dEventID, UINT32 dParam, void *pPrivateData,
                                      InteractiveData_t * pPostEventData);

static U32BIT APP_Menu_GetChildNodeNums(MENU_NODE_ID NodeId);
static BOOLEAN IsNodeSkip(MENU_NODE_ID NodeId);
static BOOLEAN IsNodeDisabled(MENU_NODE_ID NodeId);
static void APP_Menu_UpdateContent(HWND * phGuiArr, UINT8 *pCount);
static INT32 APP_Menu_GetNodeID(void);

#ifdef USE_SLIDER_INMENU
static void _APP_GUIOBJ_Menu_Set_Current_Slider(UINT8 index, int nMin, int nMax, int current_value, HWND * phGuiArr, UINT8 *pCount);
#endif
void APP_GUIOBJ_Menu_Update_Items_Arrow(HWND * phGuiArr, UINT8 *pCount);
//void APP_GUIOBJ_Menu_Update_HelpBar(MenuHelp_t nsel);
void APP_GUIOBJ_Menu_Update_ItemByListView(HWND * phGuiArr, UINT8 *pCount);
static INT32 APP_GUIOBJ_Menu_LeftRightControl(UINT32 dEventID, InteractiveData_t * pPostEventData, HWND * phGuiArr, UINT8 *pCount);
void _APP_GUIOBJ_Menu_Reset_Content(HWND * phGuiArr, UINT8 *pCount);
void SetAudioData(UINT32 cmd, INT8 value, BOOLEAN bSetHW);
INT8 GetAudioData(UINT32 Cmd);
int GetAudioDataDuplication(Sound_Data_t * stUISoundData);
int GetEqualizerModeBassTreble(UINT32 cmd);
void APP_GUIOBJ_Menu_Set_Data_Day(UINT8 u8Day, HWND * phGuiArr, UINT8 *pCount);
void APP_GUIOBJ_Menu_Set_Data_Momth(UINT8 u8Month, HWND * phGuiArr, UINT8 *pCount);
void APP_GUIOBJ_Menu_Set_Data_Year(UINT16 u16Year, HWND * phGuiArr, UINT8 *pCount);
void APP_GUIOBJ_Menu_Set_Time_Hour(UINT16 u8Hour, HWND * phGuiArr, UINT8 *pCount);
void APP_GUIOBJ_Menu_Set_Time_Minute(UINT16 u8Minute, HWND * phGuiArr, UINT8 *pCount);
//static void _APP_GUIOBJ_Menu_UpdateTimeEditItemState(HWND * phGuiArr, UINT8 *pCount);
extern INT32 APP_GUIOBJ_TimeZone_SetTimeZone(UINT32 u32TimeZone);

#ifdef CONFIG_ITALY_WITHOUT_PVR
extern Boolean Wizard_GetCountryIsItalyFromWizard(void);
#endif
#ifdef CONFIG_DVB_SYSTEM_DVBS_SUPPORT
static INT32 _APP_GUIOBJ_Menu_DVBS_Auto_CalSearchMode(INT32 mode, SEARCH_MODE_t * eSearchMode);
static void _APP_GUIOBJ_Menu_DVBS_Auto_InitialSatData(void);
static void _APP_GUIOBJ_Menu_DVBS_Auto_FreeSatData(void);
UINT32 APP_GUIOBJ_Menu_DVB_SatSys_GetTotalSat(void);

#define MAX_SATNAME_LEN  	(80)
#endif
#ifdef CONFIG_SUPPORT_INDONESIA_EWS
static void MenuInputNumber(UINT32 dEventID);
static BOOL MenuIsInputNumberMode(void);
static double MenuGetInputNumber(void);
static void MenuSetInputNumberMode(BOOL bStatus);
static void APP_Update_AreaCodeSliderTypeNode(UINT32 NodeId, BOOL SetMode, HWND * phGuiArr, UINT8 *pCount);
#endif
BOOL IsPasswordNode(INT32 nNodeID);
static INT32 APP_GUIOBJ_Menu_PW_Handle(UINT32 dEventID, UINT32 dParam, void *pPrivateData,
                                       InteractiveData_t * pPostEventData, HWND * phGuiArr, UINT8 *pCount);
void APP_GUIOBJ_Menu_UpdataTitleText(String_id_t title_string_id, HWND * phGuiArr, UINT8 *pCount);
static void APP_Menu_UpdateArrayID(MENU_NODE_ID ParentId, U8BIT nSel, HWND * phGuiArr, UINT8 *pCount); //update the node array by parentid  and focus on nSel
//static void APP_GUIOBJ_Menu_UpdateHelpBarByType(UINT32 type, HWND * phGuiArr, UINT8 *pCount);
UINT32 APP_Menu_GetStringWidth(TV_enString_id_t current_string);

/*variable*/
const GUI_Object_Definition_t stAPPGuiObjMainMenu = {
    GUI_OBJ_CAN_BE_FOCUSED,
    GUI_OBJ_UPDATE_PERIOD * 1,  //100 ms
    _APP_GUIOBJ_Menu_OnCreate,
    _APP_GUIOBJ_Menu_OnRelease,
    _APP_GUIOBJ_Menu_OnFocused,
    _APP_GUIOBJ_Menu_OnLoseFocus,
    _APP_GUIOBJ_Menu_OnTimerUpdate,
    _APP_GUIOBJ_Menu_OnEvent,
};

MENU_NODE_ID APP_MENU_GetCurrentNode(void)
{
    return Current_NodeId;
}

BOOLEAN APP_MENU_IsMenuOpened(void)
{
    return g_bCloseAllFlag;
}
#if 0
static UINT16 APP_Menu_FindMenuNodeIndex(UINT16 MenuId)
{
    int first_id = MenuNode[MenuNode[MenuId].parentID].childID;

    int nowid = first_id;
    int index = 0;

    while (nowid != MenuId)
    {
        nowid = MenuNode[nowid].nextID;
        if (nowid == ID_NULL)
            break;
        index++;
    }
    MENU_DEBF("[MENU DBG] %s %d index=%d  \n", __func__, __LINE__, index);
    return (index - g_Menu_Start_Offset[g_menu_cur_layer]);
}
#endif
#ifdef CONFIG_DTV_SUPPORT
static INT32 GetNodeIdNowValue(INT32 Nodeid, HWND * phGuiArr, UINT8 *pCount)
{
    INT32 Current_Value = 0;
    NODE_FUNCTION *pFunc = MenuNode[Nodeid].pThis;

    if (pFunc)
    {
        if (pFunc->MenuSettingFun)
            (*pFunc->MenuSettingFun) (FALSE, 0, &Current_Value, FALSE, phGuiArr, pCount);

    }
    return Current_Value;
}
#endif
#if 0
static void Menu_ChoiceInput_Flow(_Menu_Choice_Item * choice_item, BOOL bSet, BOOL reset_count, int *pValue,
                                  BOOL change_mode)
{

    //static _Menu_Choice_Item choice_item ={MENU_CHOICE_AUTO_MODE,0,4,0,FALSE};//Is_Node_Auto , Input_Symbolrate ,4,enter_count ,new
    _Menu_Choice_Item *tmp_choice = ((_Menu_Choice_Item *) pValue);

    //oice_item.digital_max = (_Menu_Choice_Item*)pValue->digital_max;//(_Menu_Choice_Item)(*pValue).digital_max;


    if (reset_count)
    {
        choice_item->enter_count = 0;
        choice_item->enter_mode = FALSE;
    }

    if (change_mode)
    {
        if (choice_item->show_mode == MENU_CHOICE_AUTO_MODE)
        {
            choice_item->show_mode = MENU_CHOICE_INPUT_MODE;
        }
        else
        {
            choice_item->show_mode = MENU_CHOICE_AUTO_MODE;
        }
        choice_item->enter_mode = FALSE;

        MENU_DEBF("\n \
choice_item->show_mode:%d   \n \
choice_item->value:%d \n \
choice_item->digital_max:%d \n \
choice_item->enter_count:%d \n \
choice_item->enter_mode:%d  \n \
\n	", choice_item->show_mode, choice_item->value, choice_item->digital_max, choice_item->enter_count, choice_item->enter_mode);


        tmp_choice->show_mode = choice_item->show_mode;
        //tmp_choice->value = choice_item->value;
        //tmp_choice->digital_max = choice_item->digital_max;
        tmp_choice->enter_count = choice_item->enter_count;
        tmp_choice->enter_mode = choice_item->enter_mode;
        //return;
    }

    if (bSet)
    {
        if (choice_item->enter_count == 0)
        {
            choice_item->value = tmp_choice->value;
        }
        else
        {
            choice_item->value = choice_item->value * 10 + tmp_choice->value;
        }
        choice_item->enter_count++;
        choice_item->enter_count %= choice_item->digital_max;
        choice_item->enter_mode = TRUE;

        if (reset_count)
        {
            choice_item->enter_count = 0;
            choice_item->enter_mode = FALSE;
        }
    }

    INT32 i32CurrentIndex = 0;
	HWND handle = NULL;

	GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_LIST_ListView_MenuLayerText, &handle));
    GUI_FUNC_CALL(GEL_GetParam(handle, PARAM_CURRENT_INDEX, &i32CurrentIndex));
    tmp_choice->show_mode = choice_item->show_mode;
    tmp_choice->value = choice_item->value;
    tmp_choice->digital_max = choice_item->digital_max;
    tmp_choice->enter_count = choice_item->enter_count;
    tmp_choice->enter_mode = choice_item->enter_mode;

}

void _APP_GUIOBJ_Menu_Reset_ChoiceInput(HWND * phGuiArr, UINT8 *pCount)
{
    INT32 i32CurrentIndex = 0;
	HWND handle = NULL;

	GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_LIST_ListView_MenuLayerText, &handle));
    GUI_FUNC_CALL(GEL_GetParam(handle, PARAM_CURRENT_INDEX, &i32CurrentIndex));
    INT32 cur_id = Current_Node_Array[i32CurrentIndex + g_Menu_Start_Offset[g_menu_cur_layer]];

    NODE_FUNCTION *pFunc = MenuNode[cur_id].pThis;
	GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_COMBO_ComboBox_MenuLayer_Item0 + i32CurrentIndex, &handle));

    if (pFunc)
    {
        if ((pFunc->type == MENU_CTRL_TYPE_CHOICEINPUT))
        {
            INT32 string_last = STRING_LAST;

            _Menu_Choice_Item *choice_item;

            choice_item = malloc(sizeof(_Menu_Choice_Item));
            memset(choice_item, 0, (sizeof(_Menu_Choice_Item)));
            if (pFunc->MenuSettingFun)
            {
                (*pFunc->MenuSettingFun) (FALSE, TRUE, (int *) (choice_item), FALSE, phGuiArr, pCount);
            }
            else
            {
                free(choice_item);
                return;
            }

            if (choice_item->show_mode == MENU_CHOICE_AUTO_MODE)
            {
                g_arTextItemString[i32CurrentIndex][0] = TV_IDS_String_Auto;
                g_arTextItemString[i32CurrentIndex][1] = STRING_LAST;
                GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_STATIC_STRING, &g_arTextItemString[i32CurrentIndex]));
            }
            else
            {
                if (g_ppRightSide_DynamicString[i32CurrentIndex])
                {
                    GL_MemFree(g_ppRightSide_DynamicString[i32CurrentIndex][0]);
                    GL_MemFree(g_ppRightSide_DynamicString[i32CurrentIndex][1]);
                    GL_MemFree(g_ppRightSide_DynamicString[i32CurrentIndex]);
                    g_ppRightSide_DynamicString[i32CurrentIndex] = NULL;
                }

                g_ppRightSide_DynamicString[i32CurrentIndex] = (char **) GL_MemAlloc((1 + 1) * sizeof(char *));
                g_ppRightSide_DynamicString[i32CurrentIndex][0] = (char *) GL_MemAlloc(5);
                g_ppRightSide_DynamicString[i32CurrentIndex][1] = (char *) GL_MemAlloc(sizeof(STRING_LAST));
                memcpy(g_ppRightSide_DynamicString[i32CurrentIndex][1], &string_last, sizeof(STRING_LAST));
                MENU_CHOICE_INPUT *pChoice = (MENU_CHOICE_INPUT *) pFunc->leaves;

                if (choice_item->value > pChoice->max)
                {
                    choice_item->value = pChoice->max;
                    (*pFunc->MenuSettingFun) (TRUE, TRUE, (int *) (choice_item), FALSE, phGuiArr, pCount);
                }
                else if (choice_item->value < pChoice->min)
                {
                    choice_item->value = pChoice->min;
                    (*pFunc->MenuSettingFun) (TRUE, TRUE, (int *) (choice_item), FALSE, phGuiArr, pCount);

                }
#ifdef CONFIG_DTV_SUPPORT
                if (APP_Menu_FindMenuNodeIndex(ID_CableAdvFrequency) == i32CurrentIndex
                    || APP_Menu_FindMenuNodeIndex(ID_CableAdvSymbolRate) == i32CurrentIndex)
                {
                    sprintf(g_ppRightSide_DynamicString[i32CurrentIndex][0], "%d k", choice_item->value);
                }
                else
#endif
                {
                    sprintf(g_ppRightSide_DynamicString[i32CurrentIndex][0], "%d", choice_item->value);
                }

                //sprintf(g_ppRightSide_DynamicString[i32CurrentIndex][0],"%d",choice_item->value);

                GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_DYNAMIC_STRING,(void *) g_ppRightSide_DynamicString[i32CurrentIndex]));
            }

            free(choice_item);
			APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, handle);
        }

    }

}
#endif
static void _APP_GUIOBJ_Menu_Set_PageScrollBar(HWND * phGuiArr, UINT8 *pCount)
{
	
}

static void _APP_GUIOBJ_Menu_OpenPop(PopmsgType_t poptype, int subtype, UINT16 exitkey)
{
    PopmsgParam_t stPopup;

    memset(&stPopup, 0x0, sizeof(PopmsgParam_t));

    stPopup.eType = poptype;
    stPopup.u16Exitkeys = exitkey;
    stPopup.u16ReturnType = GUI_OBJECT_POST_EVENT;
    stPopup.u32GuiObjID = APP_GUIOBJ_MAINMENU;

    if (poptype == POPMSG_TYPE_CONFIRM)
    {

        stPopup.extend.stConfirm.eConfirmType = subtype;
        stPopup.extend.stConfirm.u8Default = POPMSG_NO;

    }
    else if (poptype == POPMSG_TYPE_PROMPT)
    {
        stPopup.extend.stPrompt.ePromptType = subtype;
        stPopup.extend.stPrompt.iTimeout = 1;
    }

    APP_MenuMgr_SchedulePopup(stPopup);
}

static INT32 APP_GUIOBJ_Menu_EnterControl(UINT32 dEventID, InteractiveData_t * pPostEventData, HWND * phGuiArr, UINT8 *pCount)
{
	INT32 i32CurrentIndex = 0;
    INT32 i = 0;
    INT32 ret = GUI_OBJECT_NO_POST_ACTION;
    NODE_FUNCTION *pFunc;
    HWND handle = NULL;

    pFunc = MenuNode[APP_Menu_GetNodeID()].pThis;
    if (pFunc && MenuNode[Current_NodeId].childID == ID_NULL) //normal nodes, have pfunc
    {
        if (pFunc->type == MENU_CTRL_TYPE_PUSHBUTTON)
        {
            _APP_GUIOBJ_Menu_Reset_Content(phGuiArr, pCount);
			if (Current_Node_Num > 0)
			{
				GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_LIST_ListView_MenuLayerText1, &handle));
				GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_SETINVISIBLE, NULL));
				APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, handle);
			}
            for (i = 0; i < MONITOR_MAINMENU_MAX_ITEM; i++)
            {
                if (i < Current_Node_Num)
                {
                	GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_COMBO_ComboBox_MenuLayer_Item01 + i, &handle));
                    GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_SETINVISIBLE, NULL));
					APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, handle);
					GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_BTN_Button_Arrow01 + i, &handle));
                    GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_SETINVISIBLE, NULL));
					APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, handle);
                }
            }

            MENU_PUSH_BUTTON *pPush = (MENU_PUSH_BUTTON *) pFunc->leaves;

            if (pPush->Push_Type == PUSH_NON_DESTROY_MENU)
                g_bCloseAllFlag = FALSE;
            else                //PUSH_DESTROY_MENU
                g_bCloseAllFlag = TRUE;

            if (pFunc->MenuSettingFun)
            {
                (*pFunc->MenuSettingFun) (TRUE, 0, (int *) pPostEventData, FALSE, phGuiArr, pCount);
            }
            
            return GUI_OBJECT_POST_EVENT;

        }
        else if (pFunc->type == MENU_CTRL_TYPE_POPBUTTON)
        {
            MENU_POP_BUTTON *pPop = (MENU_POP_BUTTON *) pFunc->leaves;

            _APP_GUIOBJ_Menu_OpenPop(pPop->poptype, pPop->subtype, pPop->exitkey);
            //MENU_DEBF("POPMSG_CONFIRM_RESET_DATABASE_TO_DEFAULT=%d \n",POPMSG_CONFIRM_RESET_DATABASE_TO_DEFAULT);
            if (pPop->poptype == POPMSG_TYPE_PROMPT)
            {
                if (pFunc->MenuSettingFun)
                {
                    (*pFunc->MenuSettingFun) (TRUE, 0, NULL, FALSE, phGuiArr, pCount);
                }
            }
            //Open the confirm dialog~~(Yes/no)

            //_APP_GUIOBJ_Menu_Reset_Content();
            return GUI_OBJECT_POST_EVENT;

        }
        else if(pFunc->type == MENU_CTRL_TYPE_RADIOBUTTON)
        {
            if(dEventID == UI_EVENT_ENTER)
            {
                if(g_Current_Item_Selected == FALSE)
                {
                    g_Current_Item_Selected = TRUE;
                }
                else
                {
                    g_Current_Item_Selected = FALSE;    
                }
                APP_GUIOBJ_Menu_Update_ItemByListView(phGuiArr, pCount);
            }
            else
            {
                if(g_Current_Item_Selected)
                {
                    ret = APP_GUIOBJ_Menu_LeftRightControl(dEventID, pPostEventData, phGuiArr, pCount);
                    return ret;
                }
            }
            return GUI_OBJECT_NO_POST_ACTION;
        }
        else if(pFunc->type == MENU_CTRL_TYPE_SLIDER_LEAVE)
        {
            if(dEventID == UI_EVENT_ENTER)
            {
                if(g_Current_Item_Selected == FALSE)
                {
                    g_Current_Item_Selected = TRUE;
                }
                else
                {
                    g_Current_Item_Selected = FALSE;    
                }
                APP_GUIOBJ_Menu_Update_ItemByListView(phGuiArr, pCount);
            }
            else
            {
                if(g_Current_Item_Selected)
                {
                    ret = APP_GUIOBJ_Menu_LeftRightControl(dEventID, pPostEventData, phGuiArr, pCount);
                    return ret;
                }
            }
            return GUI_OBJECT_NO_POST_ACTION;
        }
        else if (dEventID == UI_EVENT_RIGHT)
        {
            ret = APP_GUIOBJ_Menu_LeftRightControl(dEventID, pPostEventData, phGuiArr, pCount);
            return ret;
        }
    }
	else
    {
        if (MenuNode[Current_NodeId].childID != ID_NULL && Current_NodeId != Current_HeadNodeId)
        {
            g_menu_cur_layer++;
            Current_HeadNodeId = Current_NodeId;
            i32CurrentIndex = 0;
            APP_GUIOBJ_Menu_UpdataTitleText(MenuNode[Current_NodeId].strID, phGuiArr, pCount);
            APP_Menu_UpdateArrayID(Current_HeadNodeId, 0, phGuiArr, pCount);
			GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_LIST_ListView_MenuLayerText1, &handle));
            GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_CURRENT_INDEX, &i32CurrentIndex));
            APP_GUIOBJ_Menu_Update_ItemByListView(phGuiArr, pCount);
        }
        return GUI_OBJECT_NO_POST_ACTION;
    }
    return GUI_OBJECT_NO_POST_ACTION;
}

static INT32 APP_GUIOBJ_Menu_LeftRightControl(UINT32 dEventID, InteractiveData_t * pPostEventData, HWND * phGuiArr, UINT8 *pCount)
{
    INT32 i32CurrentIndex = 0, nIdx = 0, nOldIdx = 0, nValue = 0, i, value;
	HWND handle = NULL;
    NODE_FUNCTION *pFunc;

    pFunc = MenuNode[APP_Menu_GetNodeID()].pThis;

    if (pFunc)                  //normal nodes, have pfunc
    {
        switch (pFunc->type)
        {
          case MENU_CTRL_TYPE_CHOICEINPUT:
              {

                  MENU_CHOICE_INPUT *pSlider = (MENU_CHOICE_INPUT *) pFunc->leaves;

                  if (pSlider)
                  {
                      _Menu_Choice_Item *choice_item;

                      choice_item = malloc(sizeof(_Menu_Choice_Item));
                      memset(choice_item, 0, (sizeof(_Menu_Choice_Item)));
                      AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
                                      sizeof(APP_SETTING_Channel_t), &(g_stChannelData));
					  GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_LIST_ListView_MenuLayerText1, &handle));
                      GUI_FUNC_CALL(GEL_GetParam(handle, PARAM_CURRENT_INDEX,&i32CurrentIndex));
                      if (pFunc->MenuSettingFun)
                      {
                          (*pFunc->MenuSettingFun) (TRUE, TRUE, (int *) (choice_item), TRUE, phGuiArr, pCount); //change mode
                      }
                      free(choice_item);
                  }
                  break;
              }
          case MENU_CTRL_TYPE_SLIDER:
              {
                  MENU_SLIDER *pSlider = (MENU_SLIDER *) pFunc->leaves;
				  GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_LIST_ListView_MenuLayerText1, &handle));
                  GUI_FUNC_CALL(GEL_GetParam(handle, PARAM_CURRENT_INDEX,&i32CurrentIndex));

                  //Get current slider value from flash
                  if (pFunc->MenuSettingFun)
                      (*pFunc->MenuSettingFun) (FALSE, 0, &value, FALSE, phGuiArr, pCount);

                  //adjust slider value
                  if (UI_EVENT_LEFT == dEventID)
                      value--;
                  else
                      value++;

                  //chack the range of slider value
                  if (value > pSlider->nMax || value < pSlider->nMin)
                      break;

                  // Set the current value to flash and set to driver
                  if (pFunc->MenuSettingFun)
                      (*pFunc->MenuSettingFun) (TRUE, 0, &value, FALSE, phGuiArr, pCount);
                  //GUI_FUNC_CALL(GEL_UpdateOSD());
                  break;
              }
          case MENU_CTRL_TYPE_SLIDER_LEAVE:
              {
                  MENU_SLIDER *pSlider = (MENU_SLIDER *) pFunc->leaves;

                  if(!g_Current_Item_Selected)
                  {
                      return GUI_OBJECT_NO_POST_ACTION;
                  }
                  pPostEventData->dEventID = GUI_OBJECT_SWITCH;
                  pPostEventData->dParam1 = APP_GUIOBJ_ADJUST;
                  pPostEventData->dParam2 = pSlider->AdjustItem;
                  g_bCloseAllFlag = FALSE;
                  return GUI_OBJECT_POST_EVENT;
              }
          case MENU_CTRL_TYPE_RADIOBUTTON:
              {
                  MENU_RADIO_BUTTON *pRadio = (MENU_RADIO_BUTTON *) pFunc->leaves;
                  if(!g_Current_Item_Selected)
                  {
                      return GUI_OBJECT_POST_EVENT;
                  }

                  if (pFunc->MenuSettingFun)
                  {
                      (*pFunc->MenuSettingFun) (FALSE, 0, &value, FALSE, phGuiArr, pCount);
                  }

                  for (i = 0; i < (int) pFunc->nItems; i++)
                  {
                      if (value == pRadio[i].value)
                      {
                          nOldIdx = i;
                          break;
                      }
                  }

                  if (UI_EVENT_LEFT == dEventID)
                  {
                      if (APP_Menu_GetNodeID() == ID_ImageRatio)
                      {
                          UINT8 u8Index = 0xFF;
                          nIdx = nOldIdx;
                          do
                          {
                              nIdx = nIdx - 1;
                              if (nIdx < 0)
                              {
                                  nIdx = pFunc->nItems - 1;
                              }
                              u8Index = 0xFF;
                              u8Index = APP_Video_AspectRatioTypeMappingToIndex(pRadio[nIdx].value);
                          }while(u8Index == 0xFF);
                      }
                      else
                      {
                          nIdx = nOldIdx - 1;
                          if (nIdx < 0)
                          {
                              nIdx = pFunc->nItems - 1;
                          }
                      }
                  }
                  else          //right
                  {
                      if (APP_Menu_GetNodeID() == ID_ImageRatio)
                      {
                          UINT8 u8Index = 0xFF;
                          nIdx = nOldIdx;
                          do
                          {
                              nIdx = nIdx + 1;
                              if (nIdx > (int) pFunc->nItems - 1)
                              {
                                  nIdx = 0;
                              }
                              u8Index = 0xFF;
                              u8Index = APP_Video_AspectRatioTypeMappingToIndex(pRadio[nIdx].value);
                          }while(u8Index == 0xFF);
                      }
                      else
                      {
                          nIdx = nOldIdx + 1;
                          if (nIdx > (int) pFunc->nItems - 1)
                          {
                              nIdx = 0;
                          }
                       }
                  }
     
                  if (nIdx != nOldIdx)
                  {
                      nValue = pRadio[nIdx].value;
                      if (pFunc->MenuSettingFun)
                      {
                          (*pFunc->MenuSettingFun) (TRUE, 0, &nValue, FALSE, phGuiArr, pCount);
                      }

                  }

                  //****Special case for mode setting (Home/Store)****//
                  /*this is for eu home/store mode special case
                   * if(g_Menu_HomeorStore_ModeSettingFlag)
                   * return GUI_OBJECT_NO_POST_ACTION;
                   */
                  GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_LIST_ListView_MenuLayerText1, &handle));
                  GUI_FUNC_CALL(GEL_GetParam(handle, PARAM_CURRENT_INDEX,&i32CurrentIndex));
                  g_arTextItemString[i32CurrentIndex][0] = pRadio[nIdx].strID;
                  g_arTextItemString[i32CurrentIndex][1] = STRING_LAST;
				  GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_COMBO_ComboBox_MenuLayer_Item01 + i32CurrentIndex, &handle));
                  GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_STATIC_STRING, &g_arTextItemString[i32CurrentIndex]));
                  break;
              }
          case MENU_CTRL_TYPE_DATETIME:
              {
                  break;
              }
            case MENU_CTRL_TYPE_DAYNAMICSTRING:
                break;
        }
    }
    else if (UI_EVENT_LEFT != dEventID) //this node have childs, push right key to the next layer
    {

        if (MenuNode[Current_NodeId].childID != ID_NULL && Current_NodeId != Current_HeadNodeId)
        {
            g_menu_cur_layer++;

            Current_HeadNodeId = Current_NodeId;

            i32CurrentIndex = 0;
            APP_Menu_UpdateArrayID(Current_HeadNodeId, 0, phGuiArr, pCount);
			GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_LIST_ListView_MenuLayerText1, &handle));
            GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_CURRENT_INDEX, &i32CurrentIndex));
        }
    }
    if (pFunc && pFunc->type != MENU_CTRL_TYPE_DATETIME)
	{
        APP_GUIOBJ_Menu_Update_ItemByListView(phGuiArr, pCount);
	}

	tv_SetNewControlValue(2);
    return GUI_OBJECT_NO_POST_ACTION;
}

static void APP_GUIOBJ_Menu_UpDownControl(UINT32 dEventID, HWND * phGuiArr, UINT8 *pCount)
{
	INT32 i32CurrentIndex = 0;
	int i = 0;
	INT32 Org_offset = g_Menu_Start_Offset[g_menu_cur_layer];
	HWND handle = NULL;

	GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_LIST_ListView_MenuLayerText1, &handle));
	GUI_FUNC_CALL(GEL_GetParam(handle, PARAM_CURRENT_INDEX, &i32CurrentIndex));
	i32CurrentIndex = i32CurrentIndex + g_Menu_Start_Offset[g_menu_cur_layer]; // real index
	//_APP_GUIOBJ_Menu_Reset_ChoiceInput(phGuiArr, pCount);
	if (UI_EVENT_DOWN == dEventID)
	{
		if (i32CurrentIndex < Current_Node_Num - 1)
			i32CurrentIndex++;
		else
		{
 			i32CurrentIndex = 0;
			g_Menu_Start_Offset[g_menu_cur_layer] = 0;
		}
		while (IsNodeDisabled(Current_Node_Array[i32CurrentIndex]))
		{
			i32CurrentIndex++;
			if (i32CurrentIndex == Current_Node_Num)
			{
				i32CurrentIndex = 0;
				g_Menu_Start_Offset[g_menu_cur_layer] = 0;
			}
		}

		if (i32CurrentIndex >= MONITOR_MAINMENU_MAX_ITEM - 1)
		{
			if (i32CurrentIndex == Current_Node_Num - 1)
			{
				g_Menu_Start_Offset[g_menu_cur_layer] = i32CurrentIndex - MONITOR_MAINMENU_MAX_ITEM + 1;
				i32CurrentIndex = MONITOR_MAINMENU_MAX_ITEM - 1;
			}
			else
			{
				INT32 cur_index = 0;
				GUI_FUNC_CALL(GEL_GetParam(handle, PARAM_CURRENT_INDEX, &cur_index));
				if ((cur_index < MONITOR_MAINMENU_MAX_ITEM - 2) && (i32CurrentIndex < MONITOR_MAINMENU_MAX_ITEM - 1))
				{
					i32CurrentIndex -= g_Menu_Start_Offset[g_menu_cur_layer];
				}
				else
				{
					g_Menu_Start_Offset[g_menu_cur_layer] = i32CurrentIndex - MONITOR_MAINMENU_MAX_ITEM + 2;
					i32CurrentIndex = MONITOR_MAINMENU_MAX_ITEM - 2;
				}
				MENU_DEBF("[%d] i32CurrentIndex=%d layer=%d  \n", __LINE__, i32CurrentIndex, g_Menu_Start_Offset[g_menu_cur_layer]);
			}
			i32CurrentIndex %= MONITOR_MAINMENU_MAX_ITEM;
			GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_SETFOCUSED, NULL));
			GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_CURRENT_INDEX, &i32CurrentIndex));
		}
		else
		{
			//g_Menu_Start_Offset[g_menu_cur_layer] = 0;
			if (g_Menu_Start_Offset[g_menu_cur_layer] != 0)
			{
				if (i32CurrentIndex)
					i32CurrentIndex -= g_Menu_Start_Offset[g_menu_cur_layer];
				else
				{
					g_Menu_Start_Offset[g_menu_cur_layer] = 0;
				}
			}
			GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_SETFOCUSED, NULL));
			GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_CURRENT_INDEX, &i32CurrentIndex));
		}
		//APP_Menu_UpdateContent(phGuiArr, pCount);
		if (Org_offset != g_Menu_Start_Offset[g_menu_cur_layer])
		{
			APP_Menu_UpdateContent(phGuiArr, pCount);
			GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_CURRENT_INDEX, &i32CurrentIndex));
		}
	}
	else if (dEventID == UI_EVENT_UP)
	{
		if (i32CurrentIndex > 0)
			i32CurrentIndex--;
		else
			i32CurrentIndex = Current_Node_Num - 1;

		while (IsNodeDisabled(Current_Node_Array[i32CurrentIndex]))
		{
			i32CurrentIndex--;
			if (i32CurrentIndex < 0)
			{
				i32CurrentIndex = Current_Node_Num - 1;
			}
			if (Current_Node_Num > MONITOR_MAINMENU_MAX_ITEM)
			{
				if (i32CurrentIndex >= MONITOR_MAINMENU_MAX_ITEM)
				{
					g_Menu_Start_Offset[g_menu_cur_layer] = i32CurrentIndex - MONITOR_MAINMENU_MAX_ITEM + 1;
				}
			}
		}

		if (g_Menu_Start_Offset[g_menu_cur_layer] != 0)
		{
			if (i32CurrentIndex == Current_Node_Num - 1)
			{
				if (Current_Node_Num > MONITOR_MAINMENU_MAX_ITEM - 1)
				{
					g_Menu_Start_Offset[g_menu_cur_layer] = i32CurrentIndex - MONITOR_MAINMENU_MAX_ITEM + 1;

					i32CurrentIndex = MONITOR_MAINMENU_MAX_ITEM - 1;
				}
				else
					i32CurrentIndex = Current_Node_Num - 1;
			}
			else
			{
				for (i = 0; i < MONITOR_MAINMENU_MAX_ITEM; i++)
				{
					if (Current_Node_Array[i + g_Menu_Start_Offset[g_menu_cur_layer]] == Current_Node_Array[i32CurrentIndex])
					{
						break;
					}
				}

				if (i == MONITOR_MAINMENU_MAX_ITEM)
				{
					if (i32CurrentIndex >= MONITOR_MAINMENU_MAX_ITEM - 1)
						g_Menu_Start_Offset[g_menu_cur_layer] = i32CurrentIndex - MONITOR_MAINMENU_MAX_ITEM + 2;
					else
						g_Menu_Start_Offset[g_menu_cur_layer] = i32CurrentIndex;

					i32CurrentIndex = 0;
				}
				else
					i32CurrentIndex = (i32CurrentIndex - g_Menu_Start_Offset[g_menu_cur_layer]) % MONITOR_MAINMENU_MAX_ITEM;

			}

			GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_SETFOCUSED, NULL));
			GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_CURRENT_INDEX, &i32CurrentIndex));
		}
		else
		{
	//     if(i32CurrentIndex==Current_Node_Num-1 )
			if (i32CurrentIndex > MONITOR_MAINMENU_MAX_ITEM - 1)
			{
				if (Current_Node_Num > MONITOR_MAINMENU_MAX_ITEM - 1)
				{
					if (i32CurrentIndex + MONITOR_MAINMENU_MAX_ITEM > Current_Node_Num)
						g_Menu_Start_Offset[g_menu_cur_layer] = Current_Node_Num - MONITOR_MAINMENU_MAX_ITEM;
					else
						g_Menu_Start_Offset[g_menu_cur_layer] = i32CurrentIndex - MONITOR_MAINMENU_MAX_ITEM + 1;
					MENU_DEBF("[MENU DBG] i32CurrentIndex=%d  g_Menu_Start_Offset[g_menu_cur_layer]=%d   \n", i32CurrentIndex, g_Menu_Start_Offset[g_menu_cur_layer]);
					i32CurrentIndex = (i32CurrentIndex - g_Menu_Start_Offset[g_menu_cur_layer]) % MONITOR_MAINMENU_MAX_ITEM;

					//g_Menu_Start_Offset[g_menu_cur_layer] = i32CurrentIndex-MONITOR_MAINMENU_MAX_ITEM+1;
					//i32CurrentIndex = MONITOR_MAINMENU_MAX_ITEM-1;
				}
				else
					i32CurrentIndex = Current_Node_Num - 1;
			}

			GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_SETFOCUSED, NULL));
			GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_CURRENT_INDEX, &i32CurrentIndex));
		}

		if (Org_offset != g_Menu_Start_Offset[g_menu_cur_layer])
		{
			APP_Menu_UpdateContent(phGuiArr, pCount);
			GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_CURRENT_INDEX, &i32CurrentIndex));
		}
	}
}




void APP_GUIOBJ_Menu_Update_ItemByListView(HWND * phGuiArr, UINT8 *pCount)
{
	INT32 i32CurrentIndex = 0;
	HWND h_MenuLayer_Listview_Handle = NULL;
	HWND h_MainMenu_TextItem_Handle[MONITOR_MAINMENU_MAX_ITEM] = {NULL};
#ifdef USE_SLIDER_INMENU
	HWND h_ScrollBar[MONITOR_MAINMENU_MAX_ITEM] = {NULL};
	HWND h_ScrollBarBg[MONITOR_MAINMENU_MAX_ITEM] = {NULL};
#endif
	GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_LIST_ListView_MenuLayerText1, &h_MenuLayer_Listview_Handle));
	GUI_FUNC_CALL(GEL_GetParam(h_MenuLayer_Listview_Handle, PARAM_CURRENT_INDEX, &i32CurrentIndex));
	INT32 i = 0;

	for (i = 0; i < MONITOR_MAINMENU_MAX_ITEM; i++)
	{
		GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_COMBO_ComboBox_MenuLayer_Item01 + i, &(h_MainMenu_TextItem_Handle[i])));
#ifdef USE_SLIDER_INMENU
		GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_PROG_ProgressBar_1 + i, &(h_ScrollBar[i])));
		GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_BG_ScrollBg1 + i, &(h_ScrollBarBg[i])));
#endif
		//APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_MainMenu_TextItem_Handle[i]);
		INT32 cur_id = Current_Node_Array[i + g_Menu_Start_Offset[g_menu_cur_layer]];

		if (cur_id == ID_NULL)
			break;
		if (i == i32CurrentIndex && (g_menu_cur_layer != MENU_LAYER_0))
		{
			if (IsNodeDisabled(cur_id))
			{
				i32CurrentIndex++;
				GUI_FUNC_CALL(GEL_SetParam(h_MenuLayer_Listview_Handle, PARAM_CURRENT_INDEX, &i32CurrentIndex));
				continue;
			}
			// Focused Item
			if(g_Current_Item_Selected)
			{
				GUI_FUNC_CALL(GEL_SetParam(h_MenuLayer_Listview_Handle, PARAM_SETCLICKED, NULL));
			}
			else
			{
				GUI_FUNC_CALL(GEL_SetParam(h_MenuLayer_Listview_Handle, PARAM_SETFOCUSED, NULL));
			}
			if(g_Current_Item_Selected == FALSE)
			{
				GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_TextItem_Handle[i], PARAM_SETFOCUSED, NULL));
			}
			else
			{
				GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_TextItem_Handle[i], PARAM_SETCLICKED, NULL));
			}
				
			if (IsNodeDisabled(cur_id))
			{
			}
		}
		else
		{
			if (IsNodeDisabled(cur_id))
			{
				GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_TextItem_Handle[i], PARAM_SETDISABLED, NULL));
				GUI_FUNC_CALL(GEL_SetParam(h_MenuLayer_Listview_Handle, PARAM_ITEM_DISABLE, &i));

				APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_MainMenu_TextItem_Handle[i]);
			}
			else
			{
				GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_TextItem_Handle[i], PARAM_SETNORMAL, NULL));
				GUI_FUNC_CALL(GEL_SetParam(h_MenuLayer_Listview_Handle, PARAM_ITEM_ENABLE, &i));
				APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_MainMenu_TextItem_Handle[i]);
 			}
		}
	}

	APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_MenuLayer_Listview_Handle);

	INT32 cur_id = Current_Node_Array[i32CurrentIndex + g_Menu_Start_Offset[g_menu_cur_layer]];
	NODE_FUNCTION * pFunc = MenuNode[cur_id].pThis;

	if (pFunc)
	{
		if ((pFunc->type == MENU_CTRL_TYPE_CHOICEINPUT))
		{
			INT32 string_last = STRING_LAST;

			_Menu_Choice_Item *choice_item;

			choice_item = malloc(sizeof(_Menu_Choice_Item));
			memset(choice_item, 0, (sizeof(_Menu_Choice_Item)));
			if (pFunc->MenuSettingFun)
			{
				(*pFunc->MenuSettingFun) (FALSE, 0, (int *) (choice_item), FALSE, phGuiArr, pCount);
			}
			if (choice_item->show_mode == MENU_CHOICE_AUTO_MODE)
			{
				g_arTextItemString[i32CurrentIndex][0] = TV_IDS_String_Auto;
				g_arTextItemString[i32CurrentIndex][1] = STRING_LAST;
				GUI_FUNC_CALL(GEL_SetParam
                              	(h_MainMenu_TextItem_Handle[i32CurrentIndex], PARAM_STATIC_STRING,
                               	&g_arTextItemString[i32CurrentIndex]));
			}
			else
			{
				if (g_ppRightSide_DynamicString[i32CurrentIndex])
				{
					GL_MemFree(g_ppRightSide_DynamicString[i32CurrentIndex][0]);
					GL_MemFree(g_ppRightSide_DynamicString[i32CurrentIndex][1]);
					GL_MemFree(g_ppRightSide_DynamicString[i32CurrentIndex]);
					g_ppRightSide_DynamicString[i32CurrentIndex] = NULL;
				}

				g_ppRightSide_DynamicString[i32CurrentIndex] = (char **) GL_MemAlloc((1 + 1) * sizeof(char *));
				g_ppRightSide_DynamicString[i32CurrentIndex][0] = (char *) GL_MemAlloc(5);
				g_ppRightSide_DynamicString[i32CurrentIndex][1] = (char *) GL_MemAlloc(sizeof(STRING_LAST));
				memcpy(g_ppRightSide_DynamicString[i32CurrentIndex][1], &string_last, sizeof(STRING_LAST));
                
				sprintf(g_ppRightSide_DynamicString[i32CurrentIndex][0], "%d", choice_item->value);

				if (choice_item->enter_mode)
				{
					int tmp_count = choice_item->enter_count;

					for (; tmp_count < choice_item->digital_max && tmp_count; tmp_count++)
					{
						strcat(g_ppRightSide_DynamicString[i32CurrentIndex][0], "_");
					}
					if (tmp_count == 0)
					{
						MENU_CHOICE_INPUT *pChoice = (MENU_CHOICE_INPUT *) pFunc->leaves;

						if (choice_item->value > pChoice->max)
						{
							choice_item->value = pChoice->max;
							(*pFunc->MenuSettingFun) (TRUE, TRUE, (int *) (choice_item), FALSE, phGuiArr, pCount);
						}
 						else if (choice_item->value < pChoice->min)
						{
							choice_item->value = pChoice->min;
							(*pFunc->MenuSettingFun) (TRUE, TRUE, (int *) (choice_item), FALSE, phGuiArr, pCount);
						}
					}
				}

				GUI_FUNC_CALL(GEL_SetParam
					(h_MainMenu_TextItem_Handle[i32CurrentIndex], PARAM_DYNAMIC_STRING,
    					(void *) g_ppRightSide_DynamicString[i32CurrentIndex]));
			}

			free(choice_item);
		}
		else if ((pFunc->type == MENU_CTRL_TYPE_SLIDER) || (pFunc->type == MENU_CTRL_TYPE_SLIDER_LEAVE)) //(pFunc->type ==MENU_CTRL_TYPE_SILDERNUMBERINPUT)
		{
			INT32 string_last = STRING_LAST;
			INT32 value = 0;

			if (pFunc->MenuSettingFun)
			{
				(*pFunc->MenuSettingFun) (FALSE, 0, &value, FALSE, phGuiArr, pCount);
			}

			if (g_ppRightSide_DynamicString[i32CurrentIndex])
			{
				GL_MemFree(g_ppRightSide_DynamicString[i32CurrentIndex][0]);
				GL_MemFree(g_ppRightSide_DynamicString[i32CurrentIndex][1]);
				GL_MemFree(g_ppRightSide_DynamicString[i32CurrentIndex]);
				g_ppRightSide_DynamicString[i32CurrentIndex] = NULL;
			}

			g_ppRightSide_DynamicString[i32CurrentIndex] = (char **) GL_MemAlloc((1 + 1) * sizeof(char *));
			g_ppRightSide_DynamicString[i32CurrentIndex][0] = (char *) GL_MemAlloc(5);
			g_ppRightSide_DynamicString[i32CurrentIndex][1] = (char *) GL_MemAlloc(sizeof(STRING_LAST));
			memcpy(g_ppRightSide_DynamicString[i32CurrentIndex][1], &string_last, sizeof(STRING_LAST));

			sprintf(g_ppRightSide_DynamicString[i32CurrentIndex][0], "%d", value);
			GUI_FUNC_CALL(GEL_SetParam
				(h_MainMenu_TextItem_Handle[i32CurrentIndex], PARAM_DYNAMIC_STRING,
				(void *) g_ppRightSide_DynamicString[i32CurrentIndex]));

#ifdef USE_SLIDER_INMENU
			MENU_SLIDER *pSlider = (MENU_SLIDER *) (pFunc->leaves);
			_APP_GUIOBJ_Menu_Set_Current_Slider(i32CurrentIndex, pSlider->nMin, pSlider->nMax, (int) value, phGuiArr, pCount);
#endif
		}
	}

	APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_MainMenu_TextItem_Handle[i32CurrentIndex]);
#ifdef USE_SLIDER_INMENU
	//APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_ScrollBarBg[i32CurrentIndex]);
	//APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_ScrollBar[i32CurrentIndex]);
#endif
	APP_GUIOBJ_Menu_Update_Items_Arrow(phGuiArr, pCount);
#if 0
	if(g_menu_cur_layer == MENU_LAYER_0)
	{
		APP_GUIOBJ_Menu_UpdateHelpBarByType(MENU_CTRL_TYPE_NONE, phGuiArr, pCount);
	}
	else if(pFunc)
	{
		APP_GUIOBJ_Menu_UpdateHelpBarByType(pFunc->type, phGuiArr, pCount);
	}
	else
	{
		APP_GUIOBJ_Menu_UpdateHelpBarByType(MENU_CTRL_TYPE_PUSHBUTTON, phGuiArr, pCount);
	}
#endif
}

void APP_GUIOBJ_Menu_UpdateArrowByType(HWND * phGuiArr, UINT8 *pCount, UINT32 type, UINT8 nIdx, ParamType_e eParamType)
{
	HWND h_MainMenu_Left_Arrow = NULL;
	HWND h_MainMenu_Right_Arrow = NULL;

	GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control,TV_E_IDC_BTN_Button_Arrow01 + nIdx, &h_MainMenu_Right_Arrow));
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control,TV_E_IDC_BTN_Button_ArrowL01 + nIdx, &h_MainMenu_Left_Arrow));

    switch (type)
    {

      case MENU_CTRL_TYPE_SLIDER_LEAVE:
      case MENU_CTRL_TYPE_SLIDER:
#ifdef USE_SLIDER_INMENU
          GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Left_Arrow, PARAM_SETINVISIBLE, NULL));
          GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Right_Arrow, PARAM_SETINVISIBLE, NULL));
          break;
#else
          GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Left_Arrow, eParamType, NULL));
          GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Right_Arrow, eParamType, NULL));
          break;
#endif
          //else use the left right arrow
      case MENU_CTRL_TYPE_CHOICEINPUT:
      case MENU_CTRL_TYPE_RADIOBUTTON:
          GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Left_Arrow, eParamType, NULL));
          GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Right_Arrow, eParamType, NULL));
          break;
      case MENU_CTRL_TYPE_PUSHBUTTON:
      case MENU_CTRL_TYPE_POPBUTTON:
          GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Left_Arrow, PARAM_SETINVISIBLE, NULL));
          GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Right_Arrow, eParamType, NULL));
          break;
      case MENU_CTRL_TYPE_PASSWD_INPUT:
          GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Left_Arrow, PARAM_SETINVISIBLE, NULL));
          GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Right_Arrow, PARAM_SETINVISIBLE, NULL));
          break;
      default:
          GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Left_Arrow, PARAM_SETINVISIBLE, NULL));
          GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Right_Arrow, PARAM_SETINVISIBLE, NULL));
          break;
    }
	APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_MainMenu_Left_Arrow);
	APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_MainMenu_Right_Arrow);

}

void APP_GUIOBJ_Menu_Update_Single_Item_Arrow(HWND * phGuiArr, UINT8 *pCount, UINT8 nIdx, BOOL bFocused)
{
	State_e ListViewState = NORMAL_STATE;
	State_e ItemState = NORMAL_STATE;
	HWND handle = NULL;
	HWND h_MainMenu_Left_Arrow = NULL;
	HWND h_MainMenu_Right_Arrow = NULL;
	UINT32 cur_id = Current_Node_Array[nIdx + g_Menu_Start_Offset[g_menu_cur_layer]];

	GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_LIST_ListView_MenuLayerText1, &handle));
	GUI_FUNC_CALL(GEL_GetParam(handle, PARAM_STATE, &ListViewState));
	GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control,TV_E_IDC_COMBO_ComboBox_MenuLayer_Item01 + nIdx, &handle));
	GUI_FUNC_CALL(GEL_GetParam(handle, PARAM_STATE, &ItemState));
	GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_BTN_Button_ArrowL01 + nIdx, &h_MainMenu_Left_Arrow));
	GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_BTN_Button_Arrow01 + nIdx, &h_MainMenu_Right_Arrow));
	if (bFocused && ((ListViewState == FOCUS_STATE) || (ListViewState == CLICK_STATE)))
	{
		NODE_FUNCTION *pFunc = MenuNode[cur_id].pThis;
		if((ListViewState == FOCUS_STATE))
		{
			if (pFunc)
			{
				APP_GUIOBJ_Menu_UpdateArrowByType(phGuiArr, pCount, pFunc->type, nIdx, PARAM_SETFOCUSED);
			}
			else
			{
				// Have next level
				GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Left_Arrow, PARAM_SETINVISIBLE, NULL));
				GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Right_Arrow, PARAM_SETFOCUSED, NULL));
				APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount,h_MainMenu_Left_Arrow);
				APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount,h_MainMenu_Right_Arrow);
			}
		}
		else
		{
			if (pFunc)
			{
				APP_GUIOBJ_Menu_UpdateArrowByType(phGuiArr, pCount, pFunc->type, nIdx, PARAM_SETCLICKED);
			}
			else
			{
				// Have next level
				GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Left_Arrow, PARAM_SETINVISIBLE, NULL));
				GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Right_Arrow, PARAM_SETCLICKED, NULL));
				APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount,h_MainMenu_Left_Arrow);
				APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount,h_MainMenu_Right_Arrow);
			}
		}

	}
	else
	{
		if(cur_id == ID_NULL)
		{
			GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Left_Arrow, PARAM_SETINVISIBLE, NULL));		
			GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Right_Arrow, PARAM_SETINVISIBLE, NULL));
			APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount,h_MainMenu_Left_Arrow);
			APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount,h_MainMenu_Right_Arrow);
		}
		else
		{
			NODE_FUNCTION *pFunc = MenuNode[cur_id].pThis;
			if(pFunc)
			{
				if(ItemState == DISABLED_STATE)
					APP_GUIOBJ_Menu_UpdateArrowByType(phGuiArr, pCount, pFunc->type, nIdx, PARAM_SETINVISIBLE);
				else
					APP_GUIOBJ_Menu_UpdateArrowByType(phGuiArr, pCount, pFunc->type, nIdx, PARAM_SETNORMAL);
			}
			else
			{
				GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Left_Arrow, PARAM_SETINVISIBLE, NULL));				
				if(ItemState == DISABLED_STATE)
				{
					GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Right_Arrow, PARAM_SETINVISIBLE, NULL));
				}
				else
				{
					GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Right_Arrow, PARAM_SETNORMAL, NULL));
				}
				APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount,h_MainMenu_Left_Arrow);
				APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount,h_MainMenu_Right_Arrow);
			}
		}
	}
}

void APP_GUIOBJ_Menu_Update_Items_Arrow(HWND * phGuiArr, UINT8 *pCount)
{
	MENU_DEBF();

	INT32 i32List_Index;
	HWND handle = NULL;

	GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_LIST_ListView_MenuLayerText1, &handle));
	GUI_FUNC_CALL(GEL_GetParam(handle, PARAM_CURRENT_INDEX, &i32List_Index));

	INT32 i;

	for (i = 0; i < MONITOR_MAINMENU_MAX_ITEM; i++)
	{
		if (i != i32List_Index)
		{
			APP_GUIOBJ_Menu_Update_Single_Item_Arrow(phGuiArr, pCount, i, FALSE);
		}
		else
		{
			APP_GUIOBJ_Menu_Update_Single_Item_Arrow(phGuiArr, pCount, i, TRUE);
		}
	}
	MENU_DEBF();
}

#define DAY_AND_TIME_STRING_MAX (5)
#define DAY_MAX (31)
char strDay[DAY_AND_TIME_STRING_MAX] = { 0 };

void APP_GUIOBJ_Menu_Set_Data_Day(UINT8 u8Day, HWND * phGuiArr, UINT8 *pCount)
{
    
}

#define MONTH_MAX (12)
char strMonth[DAY_AND_TIME_STRING_MAX] = { 0 };

void APP_GUIOBJ_Menu_Set_Data_Momth(UINT8 u8Month, HWND * phGuiArr, UINT8 *pCount)
{
    
}

#define YEAR_MIN (2000)
#define YEAR_MAX (2037)
char strYear[DAY_AND_TIME_STRING_MAX] = { 0 };

void APP_GUIOBJ_Menu_Set_Data_Year(UINT16 u16Year, HWND * phGuiArr, UINT8 *pCount)
{
   
}

#define HOUR_MAX (24)
char strHour[DAY_AND_TIME_STRING_MAX] = { 0 };

void APP_GUIOBJ_Menu_Set_Time_Hour(UINT16 u8Hour, HWND * phGuiArr, UINT8 *pCount)
{
    
}

#define MINUTE_MAX (60)
char strMinute[DAY_AND_TIME_STRING_MAX] = { 0 };

void APP_GUIOBJ_Menu_Set_Time_Minute(UINT16 u8Minute, HWND * phGuiArr, UINT8 *pCount)
{
    
}
#if 0
static void _APP_GUIOBJ_Menu_UpdateTimeEditItemState(HWND * phGuiArr, UINT8 *pCount)
{
	
}
#endif
//void APP_Mainmenu_UpdateTheFocused_Arrow(Help_t nSel, HWND * phGuiArr, UINT8 *pCount) //0: Invisible all arrow
void APP_Mainmenu_UpdateTheFocused_Arrow(HWND * phGuiArr, UINT8 *pCount) //0: Invisible all arrow

{
    INT32 i;
    INT32 i32List_Index;
    HWND h_MenuLayer_Listview_Handle = NULL;
    HWND h_MainMenu_Right_Arrow[MONITOR_MAINMENU_MAX_ITEM] = {NULL};
    HWND h_MainMenu_Left_Arrow[MONITOR_MAINMENU_MAX_ITEM] = {NULL};
#ifdef USE_SLIDER_INMENU
    State_e nowState = NORMAL_STATE;
    HWND h_ScrollBar = NULL;
#endif
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_LIST_ListView_MenuLayerText1, &(h_MenuLayer_Listview_Handle)));
    GUI_FUNC_CALL(GEL_GetParam(h_MenuLayer_Listview_Handle, PARAM_CURRENT_INDEX, &i32List_Index));

    for (i = 0; i < MONITOR_MAINMENU_MAX_ITEM; i++)
    {
    	GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_BTN_Button_Arrow0 + i, &(h_MainMenu_Right_Arrow[i])));
        GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control,TV_E_IDC_BTN_Button_ArrowL01 + i,&(h_MainMenu_Left_Arrow[i])));
        GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Left_Arrow[i], PARAM_SETINVISIBLE, NULL));
        GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Right_Arrow[i], PARAM_SETINVISIBLE, NULL));
		APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_MainMenu_Left_Arrow[i]);
		APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_MainMenu_Right_Arrow[i]);
    }
#ifdef USE_SLIDER_INMENU
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_PROG_ProgressBar_1 + i32List_Index % MONITOR_MAINMENU_MAX_ITEM, &h_ScrollBar));
    GUI_FUNC_CALL(GEL_GetParam(h_ScrollBar, PARAM_STATE, &nowState));
#endif
#if 0
    if (nowState == INVISIBLE_STATE)
    {
        if (nSel == HELP_RADIO_SEL)
        {
            GUI_FUNC_CALL(GEL_SetParam
                          (h_MainMenu_Left_Arrow[i32List_Index % MONITOR_MAINMENU_MAX_ITEM],
                           PARAM_SETFOCUSED, NULL));
            GUI_FUNC_CALL(GEL_SetParam
                          (h_MainMenu_Right_Arrow[i32List_Index % MONITOR_MAINMENU_MAX_ITEM],
                           PARAM_SETFOCUSED, NULL));
        }
        else if (nSel == HELP_PUSH_SEL)
        {
            GUI_FUNC_CALL(GEL_SetParam
                          (h_MainMenu_Right_Arrow[i32List_Index % MONITOR_MAINMENU_MAX_ITEM],
                           PARAM_SETFOCUSED, NULL));
        }
    }
#endif
}

void APP_SetHelpNowStatus(Help_t nSel, HWND * phGuiArr, UINT8 *pCount) //Help_t
{
}
#if 0
static void APP_GUIOBJ_Menu_UpdateHelpBarByType(UINT32 type, HWND * phGuiArr, UINT8 *pCount)
{
    switch(type)
    {
        case MENU_CTRL_TYPE_SLIDER_LEAVE:
        case MENU_CTRL_TYPE_SLIDER:
            APP_SetHelpNowStatus(HELP_RADIO_SEL, phGuiArr, pCount);
            break;
        case MENU_CTRL_TYPE_CHOICEINPUT:
        case MENU_CTRL_TYPE_RADIOBUTTON:
            APP_SetHelpNowStatus(HELP_RADIO_SEL, phGuiArr, pCount);
            break;
        case MENU_CTRL_TYPE_PUSHBUTTON:
        case MENU_CTRL_TYPE_POPBUTTON:
            APP_SetHelpNowStatus(HELP_PUSH_SEL, phGuiArr, pCount);
            break;
        case MENU_CTRL_TYPE_PASSWD_INPUT:
            APP_SetHelpNowStatus(HELP_PASSWORD_SEL, phGuiArr, pCount);
            break;
        default:
            APP_SetHelpNowStatus(HELP_MAIN_MENU_SEL, phGuiArr, pCount);
            break;
    }
}
#endif

void APP_GUIOBJ_Menu_UpdataTitleText(String_id_t title_string_id, HWND * phGuiArr, UINT8 *pCount)
{
    HWND handle = NULL;

    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control, TV_E_IDC_TEXT_TextBox_MainPage_Title1, &handle));
    GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_STATIC_STRING, &title_string_id));
    APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, handle);

    return;
}

static void _APP_GUIOBJ_Menu_UpdateTitleFocus(HWND * phGuiArr, UINT8 *pCount)
{
    INT32 i32CurrentIndex = 0;
    int i = 0;
    HWND handle = NULL;
    HWND h_MainMenu_TitleBitmap[MONITOR_MAINMENU_MAX_ITEM] = {NULL};

    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control, TV_E_IDC_BTNG_GroupButton_MonitorPage_Layer, &handle));
    GUI_FUNC_CALL(GEL_GetParam(handle, PARAM_CURRENT_INDEX, &i32CurrentIndex));

    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control, TV_E_IDC_BTN_Background_MainPage_Luminance, &(h_MainMenu_TitleBitmap[0])));
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control, TV_E_IDC_BTN_Background_MainPage_ImageSetup, &(h_MainMenu_TitleBitmap[1])));
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control, TV_E_IDC_BTN_Background_MainPage_ColorTempSetup, &(h_MainMenu_TitleBitmap[2])));
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control, TV_E_IDC_BTN_Background_MainPage_ColorBoost, &(h_MainMenu_TitleBitmap[3])));
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control,TV_E_IDC_BTN_Background_MainPage_OSDSetup, &(h_MainMenu_TitleBitmap[4])));
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control,TV_E_IDC_BTN_Background_MainPage_Extra, &(h_MainMenu_TitleBitmap[5])));

    for (i = 0; i < MONITOR_MAINMENU_MAX_ITEM; i++)
    {

        if (i == i32CurrentIndex)
        {
            GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_TitleBitmap[i], PARAM_SETFOCUSED, NULL));
            //APP_GUIOBJ_Menu_UpdataTitleText(MenuNode[i+ID_Picture].strID);
            APP_GUIOBJ_Menu_UpdataTitleText(MenuNode[Current_HeadNodeId].strID, phGuiArr,pCount);
        }
        else
        {
            GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_TitleBitmap[i], PARAM_SETNORMAL, NULL));
        }
        APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_MainMenu_TitleBitmap[i]);
    }
}

#ifdef USE_SLIDER_INMENU
static void _APP_GUIOBJ_SetMENU_COmBOBoxText_Aligment(Alignment_e aligment_combo_text, UINT8 which_Combo_text)
{
	HWND handle = NULL;
    ComoText_alignment = aligment_combo_text;

	GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_COMBO_ComboBox_MenuLayer_Item01 + which_Combo_text, &handle));
    GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_TEXT_ALIGNMENT, &ComoText_alignment));
}
#endif
void _APP_GUIOBJ_Menu_Reset_Content(HWND * phGuiArr, UINT8 *pCount)
{
    int i;
    HWND h_MenuLayer_Listview_Handle = NULL;
    HWND h_MainMenu_TextItem_Handle[MONITOR_MAINMENU_MAX_ITEM] = {NULL};
#ifdef USE_SLIDER_INMENU
    HWND h_ScrollBar[MONITOR_MAINMENU_MAX_ITEM] = {NULL};
#endif
    HWND h_Handle = NULL;
    //HWND h_ScrollBarBg[MONITOR_MAINMENU_MAX_ITEM] = {NULL};

	// 1) listview
	GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_LIST_ListView_MenuLayerText1, &(h_MenuLayer_Listview_Handle)));
	APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_MenuLayer_Listview_Handle);

    for (i = 0; i < MONITOR_MAINMENU_MAX_ITEM; i++)
    {
#ifdef USE_SLIDER_INMENU
        _APP_GUIOBJ_SetMENU_COmBOBoxText_Aligment(MID_CENTER, i);
#endif
		// 2-1) Text
		GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_COMBO_ComboBox_MenuLayer_Item01 + i, &(h_MainMenu_TextItem_Handle[i])));
        GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_TextItem_Handle[i], PARAM_DYNAMIC_STRING, NULL));
        g_arTextItemString[i][0] = TV_IDS_String_NULL;
        g_arTextItemString[i][1] = STRING_LAST;
        GUI_FUNC_CALL(GEL_SetParam
                      (h_MainMenu_TextItem_Handle[i], PARAM_STATIC_STRING, &g_arTextItemString[i]));
        GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_TextItem_Handle[i], PARAM_SETINVISIBLE, NULL));
		APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_MainMenu_TextItem_Handle[i]);

#ifdef USE_SLIDER_INMENU
#if 0
        // 2-2) Scoll bar back ground
        GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_BG_ScrollBg1 + i, &(h_ScrollBarBg[i])));
        GUI_FUNC_CALL(GEL_SetParam(h_ScrollBarBg[i], PARAM_SETINVISIBLE, NULL));
		APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_ScrollBarBg[i]);
#endif
        // 2-3) Scroll bar
        GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_PROG_ProgressBar_1 + i, &(h_ScrollBar[i])));
        GUI_FUNC_CALL(GEL_SetParam(h_ScrollBar[i], PARAM_SETINVISIBLE, NULL));
		APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_ScrollBar[i]);
#endif

        g_arMenuLayerString[i] = TV_IDS_String_NULL;
    }
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_TEXT_MainLayer_Text_Push, &h_Handle));
    GUI_FUNC_CALL(GEL_SetParam(h_Handle, PARAM_SETINVISIBLE, NULL));
    APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_Handle);
}

#ifdef USE_SLIDER_INMENU
static void _APP_GUIOBJ_Menu_Set_Current_Slider(UINT8 index, int nMin, int nMax, int current_value, HWND * phGuiArr, UINT8 *pCount)
{
	HWND handle = NULL;
	int nValue = current_value;
	GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_PROG_ProgressBar_1 + index, &handle));
	//GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_TOTAL_COUNT, &nTotalCont));
	GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_MIN_VALUE, &nMin));
	GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_MAX_VALUE, &nMax));
	GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_CURRENT_VALUE, &nValue));
	APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, handle);

	_APP_GUIOBJ_SetMENU_COmBOBoxText_Aligment(MID_CENTER, index);
	GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_COMBO_ComboBox_MenuLayer_Item01 + index, &handle));
	APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, handle);
	//GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_BG_ScrollBg1 + index, &handle));
	//APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, handle);
}
#endif

static void APP_Menu_UpdateMenuTree(void)
{
#ifndef CONFIG_SUPPORT_MONITOR
    APP_Source_Type_t eCurrSource = APP_SOURCE_MAX;
    MID_InputInfo_t stTimingInfo;
    Boolean bIsHdmiNeedOverScan = TRUE;

    APP_GUIOBJ_Source_GetCurrSource(&eCurrSource);
    MID_DISP_DTVGetTimingInfo(&stTimingInfo);

    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_CHANNEL, 0,
                    sizeof(APP_SETTING_Channel_t), &(g_stChannelData));

    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO, 0,
                    sizeof(APP_SETTING_SystemInfo_t), &(g_stSysInfoData));
#ifdef CONFIG_DTV_SUPPORT
    if (g_stChannelData.TV_Connection == APP_RF_TYPE_DVB_C)
    {
        MenuNode[ID_AutoScan].nextID = ID_DTVC_Start;
    }
    else
    {
        MenuNode[ID_AutoScan].nextID = ID_DTVT_Start;
    }
#endif
#ifndef CONFIG_SUPPORT_MONITOR
    if (b_ever_enter_right_password || (g_stLocksystemData.LockEnable == FALSE))
    {
#ifdef CONFIG_DTV_SUPPORT
        MenuNode[ID_AutoScan].childID = ID_AntennaType;
#else
        MenuNode[ID_AutoScan].childID = ID_NULL;
        MenuNode[ID_AutoScan].pThis = &Fun_ScanStart;
#endif
#ifdef CONFIG_DTV_SUPPORT
        MenuNode[ID_ManualScan].childID = ID_DigitalManualScan;
#else
        MenuNode[ID_ManualScan].childID = ID_NULL; //ID_AnalogManualScan;
        MenuNode[ID_ManualScan].pThis = &Fun_AnalogScan;
#endif
        MenuNode[ID_ProgrammeEdit].childID = ID_NULL;
#ifdef CONFIG_SUPPORT_FIRST_TIME_SETUP
        MenuNode[ID_FirstTimeSetup].childID = ID_NULL;
#endif
        MenuNode[ID_Reset].childID = ID_NULL;
#ifdef CONFIG_DVB_SYSTEM_DVBS_SUPPORT
        MenuNode[ID_SatSystem].childID = ID_NULL;
        MenuNode[ID_SatAutoScan].childID = ID_SatCountry;
#endif
    }
    else
    {
        MenuNode[ID_AutoScan].childID = ID_ScanEnterPassword;
        MenuNode[ID_ManualScan].childID = ID_ManualScanEnterPassword;
#ifndef CONFIG_DTV_SUPPORT
        MenuNode[ID_ScanEnterPassword].childID = ID_NULL;
        MenuNode[ID_ManualScanEnterPassword].childID = ID_NULL;
#endif
        MenuNode[ID_ProgrammeEdit].childID = ID_ProgrameEditEnterPassword;
#ifdef CONFIG_SUPPORT_FIRST_TIME_SETUP
        MenuNode[ID_FirstTimeSetup].childID = ID_FirstTimeSetupPassword;
#endif
        MenuNode[ID_Reset].childID = ID_RestoreEnterPassword;
#ifdef CONFIG_DVB_SYSTEM_DVBS_SUPPORT
        MenuNode[ID_SatSystem].childID = ID_SatelliteSystemPassword;
        MenuNode[ID_SatAutoScan].childID = ID_SatAutoScanPassword;
#endif
    }
#endif
#ifndef CONFIG_DTV_SUPPORT
#ifdef CONFIG_PDP
    if (eCurrSource == APP_SOURCE_PC
        || (eCurrSource >= APP_SOURCE_HDMI && eCurrSource <= APP_SOURCE_HDMI2
            && (stTimingInfo.eSourceDVIMode == MID_DVI_MODE || !stTimingInfo.bIsHdmiNeedOverScan
                || stTimingInfo.uiTimingIndex == PLF_VIDEO_TIMING_ID_NON_VIDEO_TIMING))
        || (eCurrSource == APP_SOURCE_MEDIA && MM_HomePage_GetFileType() == EBOOK_FILETYPE))
    {
        MenuNode[ID_AdvancedSettings].childID = ID_PDP;
    }
    else
    {
        MenuNode[ID_AdvancedSettings].childID = ID_XContrast;
    }
#endif
#endif
    //MenuNode[ID_ColorTemp].nextID = ID_NULL;
    switch (eCurrSource)
    {
      case APP_SOURCE_DTV:
          {
#ifdef CONFIG_DTV_SUPPORT
              MenuNode[ID_XContrast].nextID = ID_AspectRatio;
#ifdef CONFIG_CI_SUPPORT
              MenuNode[ID_ProgrammeEdit].nextID = ID_CommonInterface;
#else
              MenuNode[ID_ProgrammeEdit].nextID = ID_SignalInformation;
#endif
#ifdef CONFIG_DVB_SYSTEM_DVBS_SUPPORT
              if (g_stChannelData.TV_Connection == APP_RF_TYPE_DVB_S)
              {
                  MenuNode[ID_Channel].childID = ID_SatSystem;
                  MenuNode[ID_SatSystem].nextID = ID_SatAutoScan;
                  MenuNode[ID_SatAutoScan].nextID = ID_ProgrammeEdit;
              }
              else
              {
                  MenuNode[ID_Channel].childID = ID_AutoScan;
                  MenuNode[ID_AutoScan].nextID = ID_ManualScan;
                  MenuNode[ID_ManualScan].nextID = ID_ProgrammeEdit;
              }
#else
              MenuNode[ID_AutoScan].nextID = ID_ManualScan;
#endif
#endif
          }
          break;
      case APP_SOURCE_ATV:
          {
#ifdef CONFIG_ATV_SUPPORT
              if (g_stSysInfoData.WSS == 0)
                  MenuNode[ID_ColorTemp].nextID = ID_AspectRatio;
              else
                  MenuNode[ID_ColorTemp].nextID = ID_AspectRatio;

#ifdef CONFIG_DVB_SYSTEM_DVBS_SUPPORT
              if (g_stChannelData.TV_Connection == APP_RF_TYPE_DVB_S)
              {
                  MenuNode[ID_Channel].childID = ID_SatAutoScan;
                  MenuNode[ID_SatAutoScan].nextID = ID_ManualScan;
                  MenuNode[ID_ManualScan].nextID = ID_ProgrammeEdit;
              }
              else
              {
                  MenuNode[ID_Channel].childID = ID_AutoScan;
                  MenuNode[ID_AutoScan].nextID = ID_ManualScan;
                  MenuNode[ID_ManualScan].nextID = ID_ProgrammeEdit;
              }
#endif


              //MenuNode[ID_ProgrammeEdit].nextID = ID_NULL;
              MenuNode[ID_FavoriteManager].nextID = ID_NULL;
#endif
          }
          break;
      case APP_SOURCE_PC:
          {
               MenuNode[ID_ColorTemp].nextID = ID_AspectRatio;
              //MenuNode[ID_ColorTemp].nextID = ID_PCSetting;
          }
          break;
      case APP_SOURCE_HDMI:
      case APP_SOURCE_HDMI1:
      case APP_SOURCE_HDMI2:
          {
              MID_DISP_DTVGetTimingInfo(&stTimingInfo);
              bIsHdmiNeedOverScan = stTimingInfo.bIsHdmiNeedOverScan;
              if (bIsHdmiNeedOverScan == FALSE || stTimingInfo.uiTimingIndex == PLF_VIDEO_TIMING_ID_NON_VIDEO_TIMING)
                  MenuNode[ID_ColorTemp].nextID = ID_AspectRatio;
              else
                  MenuNode[ID_ColorTemp].nextID = ID_AspectRatio;


          }
          break;
      case APP_SOURCE_AV:
      case APP_SOURCE_AV1:
      case APP_SOURCE_AV2:
      case APP_SOURCE_SCART:
      case APP_SOURCE_SCART1:
      case APP_SOURCE_SVIDEO:
      case APP_SOURCE_SVIDEO1:
      case APP_SOURCE_SVIDEO2:
          {
              MenuNode[ID_ColorTemp].nextID = ID_AspectRatio;
          }
          break;
      case APP_SOURCE_YPBPR:
      case APP_SOURCE_YPBPR1:
      case APP_SOURCE_YPBPR2:
          {
              MenuNode[ID_ColorTemp].nextID = ID_AspectRatio;
          }
          break;
      default:
          {
              MenuNode[ID_ColorTemp].nextID = ID_AspectRatio;
          }
          break;

    }

#endif
}

static void APP_Menu_UpdateContent(HWND * phGuiArr, UINT8 *pCount)
{
    int i, cur_id, value, j;
    NODE_FUNCTION *pFunc = NULL;
    INT32 string_last = STRING_LAST;
	HWND h_MenuLayer_Listview_Handle = NULL;
	HWND h_MainMenu_TextItem_Handle[MONITOR_MAINMENU_MAX_ITEM] = {NULL};
#ifdef USE_SLIDER_INMENU
	HWND h_ScrollBar[MONITOR_MAINMENU_MAX_ITEM] = {NULL};
#endif
    //HWND h_ScrollBarBg[MONITOR_MAINMENU_MAX_ITEM] = {NULL};

    _APP_GUIOBJ_Menu_Reset_Content(phGuiArr, pCount);
    //char slider_tmp_buf[2][10];
    _APP_GUIOBJ_Menu_Set_PageScrollBar(phGuiArr, pCount);
    //Set left text, update the list view
    for (i = 0; i < MONITOR_MAINMENU_MAX_ITEM; i++)
    {
        if (i >= Current_Node_Num)
            break;

        //Get current node id
        cur_id = Current_Node_Array[i + g_Menu_Start_Offset[g_menu_cur_layer]];
        g_arMenuLayerString[i] = MenuNode[cur_id].strID;
    }
    g_arMenuLayerString[i] = STRING_LAST;
	GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control,TV_E_IDC_LIST_ListView_MenuLayerText1,&(h_MenuLayer_Listview_Handle)));
    GUI_FUNC_CALL(GEL_SetParam(h_MenuLayer_Listview_Handle, PARAM_STATIC_STRING, g_arMenuLayerString));
    // Left side end

    //right side
    for (i = 0; i < MONITOR_MAINMENU_MAX_ITEM; i++)
    {
        if (i >= Current_Node_Num)
            break;

        //Get current node id
        cur_id = Current_Node_Array[i + g_Menu_Start_Offset[g_menu_cur_layer]];
        //Get the current node function
        pFunc = MenuNode[cur_id].pThis;

        //Set left side text
        //g_arMenuLayerString[i] = MenuNode[cur_id].strID;
        GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_COMBO_ComboBox_MenuLayer_Item01 + i,&(h_MainMenu_TextItem_Handle[i])));
#ifdef USE_SLIDER_INMENU
        GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_PROG_ProgressBar_1 + i,&(h_ScrollBar[i])));
#endif
        //GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_BG_ScrollBg1 + i, &(h_ScrollBarBg[i])));

        if (pFunc)
        {
            //Set right side text
            switch (pFunc->type)
            {
              case MENU_CTRL_TYPE_PASSWD_INPUT:
                  {
#ifndef CONFIG_SUPPORT_MONITOR
                      INT32 i32DisplayMode = TRUE;
                      RECT stChangePassword;

                      AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_FACTUSER, 0,
                                      sizeof(APP_SETTING_FactoryUser_t), &(g_stFactoryUserData));
                      GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Password_Handle[0], PARAM_SETNORMAL, NULL));
                      GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Password_Handle[0], PARAM_DISPLAY_MODE,
                                     &i32DisplayMode));

                      if (cur_id == ID_PasswordChange || cur_id == ID_HotelMode_PasswordChange)
                      {
                          if(IsNodeDisabled(cur_id))
                          {
                              GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Password_Handle[1], PARAM_SETDISABLED, NULL));
                              GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Password_Handle[1], PARAM_DISPLAY_MODE,
                                     &i32DisplayMode));
                          }
                          else
                          {
                              GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Password_Handle[1], PARAM_SETNORMAL, NULL));
                              GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Password_Handle[1], PARAM_DISPLAY_MODE,
                                     &i32DisplayMode));
                          }
                      }

                      if (cur_id == ID_PasswordChange)
                      {
                          GUI_FUNC_CALL(GEL_GetParam(h_MainMenu_Password_Handle[1], PARAM_AREA,&stChangePassword));
                          if (g_stFactoryUserData.HotelModeOnMenu == FALSE)
                              stChangePassword.y = 429;
                          else
                              stChangePassword.y = 454;
                          GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_Password_Handle[1], PARAM_AREA,&stChangePassword));
                      }

					  APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_MainMenu_Password_Handle[0]);
					  APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_MainMenu_Password_Handle[1]);
#endif			
                      break;
                  }
              case MENU_CTRL_TYPE_RADIOBUTTON:
                  {
                      MENU_RADIO_BUTTON *pRadio = (MENU_RADIO_BUTTON *) pFunc->leaves;
                      int nIdx = -1;

                      value = 0;

                      if (pFunc->MenuSettingFun)
                          (*pFunc->MenuSettingFun) (FALSE, 0, &value, FALSE, phGuiArr, pCount);
#ifndef CONFIG_SUPPORT_MONITOR
                      if (cur_id == ID_SleepTimer)
                      {
                          if (value != APP_SLEEPTIMER_OFF)
                          {
                              if (g_ppRightSide_DynamicString[i])
                              {
                                  GL_MemFree(g_ppRightSide_DynamicString[i][0]);
                                  GL_MemFree(g_ppRightSide_DynamicString[i][1]);
                                  GL_MemFree(g_ppRightSide_DynamicString[i]);
                                  g_ppRightSide_DynamicString[i] = NULL;
                              }

                              g_ppRightSide_DynamicString[i] = (char **) GL_MemAlloc((1 + 1) * sizeof(char *));
                              g_ppRightSide_DynamicString[i][0] = (char *) GL_MemAlloc(5);
                              g_ppRightSide_DynamicString[i][1] = (char *) GL_MemAlloc(sizeof(STRING_LAST));
                              memcpy(g_ppRightSide_DynamicString[i][1], &string_last, sizeof(STRING_LAST));

                              UINT8 *bTerminativeStr = NULL;
                              UINT32 u32leftsleeptimer = 0;

                              APP_GUIOBJ_SleepTimer_GetCurrentSleepTimerValue(&u32leftsleeptimer);
                              GUI_FUNC_CALL(GEL_GetStr(TV_IDS_String_Minns, &bTerminativeStr));
                              sprintf(g_ppRightSide_DynamicString[i][0], "%d %s\n", u32leftsleeptimer, bTerminativeStr);
                              GUI_FUNC_CALL(GEL_SetParam
                                            (h_MainMenu_TextItem_Handle[i], PARAM_DYNAMIC_STRING,
                                             (void *) g_ppRightSide_DynamicString[i]));
                              break;
                          }
                      }
#endif
                      for (j = 0; j < (int) pFunc->nItems; j++)
                      {
                          if (value == pRadio[j].value)
                          {
                              nIdx = j;
                              break;
                          }
                      }
                      if (nIdx == -1)
                          nIdx = 0;

                      g_arTextItemString[i][0] = pRadio[nIdx].strID;
                      g_arTextItemString[i][1] = STRING_LAST;
                      GUI_FUNC_CALL(GEL_SetParam
                                    (h_MainMenu_TextItem_Handle[i], PARAM_STATIC_STRING,
                                     &g_arTextItemString[i]));
                      break;
                  }
              case MENU_CTRL_TYPE_CHOICEINPUT:
                  {
#ifndef CONFIG_SUPPORT_MONITOR
                      //MENU_CHOICE_INPUT * pChoice = (MENU_CHOICE_INPUT *)pFunc->leaves;
                      _Menu_Choice_Item *choice_item;

                      choice_item = malloc(sizeof(_Menu_Choice_Item));
                      memset(choice_item, 0, (sizeof(_Menu_Choice_Item)));
                      if (pFunc->MenuSettingFun)
                          (*pFunc->MenuSettingFun) (FALSE, TRUE, (int *) (choice_item), FALSE, phGuiArr, pCount);

                      if (choice_item->show_mode == MENU_CHOICE_AUTO_MODE)
                      {
                          g_arTextItemString[i][0] = TV_IDS_String_Auto;
                          g_arTextItemString[i][1] = STRING_LAST;
                          GUI_FUNC_CALL(GEL_SetParam
                                        (h_MainMenu_TextItem_Handle[i], PARAM_STATIC_STRING,
                                         &g_arTextItemString[i]));
                      }
                      else
                      {
                          //value = 40;
                          if (g_ppRightSide_DynamicString[i])
                          {
                              GL_MemFree(g_ppRightSide_DynamicString[i][0]);
                              GL_MemFree(g_ppRightSide_DynamicString[i][1]);
                              GL_MemFree(g_ppRightSide_DynamicString[i]);
                              g_ppRightSide_DynamicString[i] = NULL;
                          }

                          g_ppRightSide_DynamicString[i] = (char **) GL_MemAlloc((1 + 1) * sizeof(char *));
                          g_ppRightSide_DynamicString[i][0] = (char *) GL_MemAlloc(5);
                          g_ppRightSide_DynamicString[i][1] = (char *) GL_MemAlloc(sizeof(STRING_LAST));
                          memcpy(g_ppRightSide_DynamicString[i][1], &string_last, sizeof(STRING_LAST));

                          //strcat(g_pcSymbolRate[0], &g_pcToBeInput[strlen(g_pcSymbolRate[0]) + 1]);
#ifdef CONFIG_DTV_SUPPORT
                          if (APP_Menu_FindMenuNodeIndex(ID_CableAdvFrequency) == i
                              || APP_Menu_FindMenuNodeIndex(ID_CableAdvSymbolRate) == i)
                          {
                              sprintf(g_ppRightSide_DynamicString[i][0], "%d k", choice_item->value);
                          }
                          else
#endif
                          {
                              sprintf(g_ppRightSide_DynamicString[i][0], "%d", choice_item->value);
                          }
                          GUI_FUNC_CALL(GEL_SetParam
                                        (h_MainMenu_TextItem_Handle[i], PARAM_DYNAMIC_STRING,
                                         (void *) g_ppRightSide_DynamicString[i]));
                      }
                      free(choice_item);
#endif
                      break;
                  }
              case MENU_CTRL_TYPE_SLIDER:
              case MENU_CTRL_TYPE_SLIDER_LEAVE:
                  {
                      if (pFunc->MenuSettingFun)
                          (*pFunc->MenuSettingFun) (FALSE, 0, &value, FALSE, phGuiArr, pCount);

                      if (g_ppRightSide_DynamicString[i])
                      {
                          GL_MemFree(g_ppRightSide_DynamicString[i][0]);
                          GL_MemFree(g_ppRightSide_DynamicString[i][1]);
                          GL_MemFree(g_ppRightSide_DynamicString[i]);
                          g_ppRightSide_DynamicString[i] = NULL;
                      }

                      g_ppRightSide_DynamicString[i] = (char **) GL_MemAlloc((1 + 1) * sizeof(char *));
                      g_ppRightSide_DynamicString[i][0] = (char *) GL_MemAlloc(5);
                      g_ppRightSide_DynamicString[i][1] = (char *) GL_MemAlloc(sizeof(STRING_LAST));
                      memcpy(g_ppRightSide_DynamicString[i][1], &string_last, sizeof(STRING_LAST));

                      sprintf(g_ppRightSide_DynamicString[i][0], "%d", value);
                      GUI_FUNC_CALL(GEL_SetParam
                                    (h_MainMenu_TextItem_Handle[i], PARAM_DYNAMIC_STRING,
                                     (void *) g_ppRightSide_DynamicString[i]));

#ifdef USE_SLIDER_INMENU
                      MENU_SLIDER *pSlider = (MENU_SLIDER *) (pFunc->leaves);

                      _APP_GUIOBJ_Menu_Set_Current_Slider(i, pSlider->nMin, pSlider->nMax, (int) value, phGuiArr, pCount);

                      if (IsNodeDisabled(cur_id))
                      {
                          //GUI_FUNC_CALL(GEL_SetParam(h_ScrollBarBg[i], PARAM_SETDISABLED, NULL));
                          GUI_FUNC_CALL(GEL_SetParam(h_ScrollBar[i], PARAM_SETDISABLED, NULL));
                      }
                      else
                      {
                          //GUI_FUNC_CALL(GEL_SetParam(h_ScrollBarBg[i], PARAM_SETNORMAL, NULL));
                          GUI_FUNC_CALL(GEL_SetParam(h_ScrollBar[i], PARAM_SETNORMAL, NULL));
                      }

					  //APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_ScrollBarBg[i]);
					  APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_ScrollBar[i]);
#endif
                      break;
                  }
#ifdef CONFIG_SUPPORT_INDONESIA_EWS
              case MENU_CTRL_TYPE_SILDERNUMBERINPUT:

                  if (pFunc->MenuSettingFun)
                      (*pFunc->MenuSettingFun) (FALSE, 0, &value, FALSE, phGuiArr, pCount);

                  if (g_ppRightSide_DynamicString[i])
                  {
                      GL_MemFree(g_ppRightSide_DynamicString[i][0]);
                      GL_MemFree(g_ppRightSide_DynamicString[i][1]);
                      GL_MemFree(g_ppRightSide_DynamicString[i]);
                      g_ppRightSide_DynamicString[i] = NULL;
                  }

                  g_ppRightSide_DynamicString[i] = (char **) GL_MemAlloc((1 + 1) * sizeof(char *));
                  g_ppRightSide_DynamicString[i][0] = (char *) GL_MemAlloc(5);
                  g_ppRightSide_DynamicString[i][1] = (char *) GL_MemAlloc(sizeof(STRING_LAST));
                  memcpy(g_ppRightSide_DynamicString[i][1], &string_last, sizeof(STRING_LAST));

                  char areacode_arr[] = { '0', '0', '0', '0', '0', '\0' };
                  UINT32 i_area;

                  for (i_area = 0; i_area < areacode_length; i_area++)
                  {
                      UINT32 j_area = 1;
                      int z_area;

                      for (z_area = i_area; z_area > (-1); z_area--)
                      {
                          j_area = 10 * j_area;
                      }
                      UINT32 x_area = j_area / 10;

                      areacode_arr[areacode_length - 1 - i_area] =
                          (char) ((((value % j_area) - (value % (x_area))) / x_area) + (int) ('0'));
                  }
                  sprintf(g_ppRightSide_DynamicString[i][0], "%s", areacode_arr);
                  GUI_FUNC_CALL(GEL_SetParam
                                (h_MainMenu_TextItem_Handle[i], PARAM_DYNAMIC_STRING,
                                 (void *) g_ppRightSide_DynamicString[i]));

                  static RECT stMove;

                  GUI_FUNC_CALL(GEL_GetParam(h_MainMenu_TextItem_Handle[i], PARAM_AREA, &stMove));
                  stMove.y = 714;
                  GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_TextItem_Handle[i], PARAM_AREA, &stMove));

                  break;
#endif
              case MENU_CTRL_TYPE_DATETIME:
                  {

                  }
                  break;
              case MENU_CTRL_TYPE_TIMESETTING:
                  {
                  }
                  break;
              case MENU_CTRL_TYPE_DAYNAMICSTRING:
                  {
                      //GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control,TV_E_IDC_TEXT_MainLayer_Text_Push,&(TV_E_IDC_TEXT_MainLayer_Text_Push)));
                      if (pFunc->MenuSettingFun)
                          (*pFunc->MenuSettingFun) (FALSE, 0, &value, FALSE, phGuiArr, pCount);
                      g_arTextItemString[i][0] = TV_IDS_String_NULL;
                      g_arTextItemString[i][1] = STRING_LAST;
                      GUI_FUNC_CALL(GEL_SetParam
                                    (h_MainMenu_TextItem_Handle[i], PARAM_STATIC_STRING,
                                     &g_arTextItemString[i]));
                      break;
                  }
              default:
                  {
                      g_arTextItemString[i][0] = TV_IDS_String_NULL;
                      g_arTextItemString[i][1] = STRING_LAST;
                      GUI_FUNC_CALL(GEL_SetParam
                                    (h_MainMenu_TextItem_Handle[i], PARAM_STATIC_STRING,
                                     &g_arTextItemString[i]));
                      break;
                  }
            }
        }
        else
        {
            g_arTextItemString[i][0] = TV_IDS_String_NULL;
            g_arTextItemString[i][1] = STRING_LAST;
            GUI_FUNC_CALL(GEL_SetParam
                          (h_MainMenu_TextItem_Handle[i], PARAM_STATIC_STRING,
                           &g_arTextItemString[i]));
        }

        //disabled items
        if (IsNodeDisabled(cur_id))
        {
            GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_TextItem_Handle[i], PARAM_SETDISABLED, NULL));
            GUI_FUNC_CALL(GEL_SetParam(h_MenuLayer_Listview_Handle, PARAM_ITEM_DISABLE, &i));
        }
        else
        {
            if(cur_id == ID_Infomation_detail)
            {
                GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_TextItem_Handle[i], PARAM_SETINVISIBLE, NULL));
                GUI_FUNC_CALL(GEL_SetParam(h_MenuLayer_Listview_Handle, PARAM_SETINVISIBLE, &i));
            }
            else
            {
                GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_TextItem_Handle[i], PARAM_SETNORMAL, NULL));
                GUI_FUNC_CALL(GEL_SetParam(h_MenuLayer_Listview_Handle, PARAM_SETNORMAL, &i));
            }
        }

		APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, h_MainMenu_TextItem_Handle[i]);
    }
}

static void APP_Menu_UpdateArrayID(MENU_NODE_ID ParentId, U8BIT nSel, HWND * phGuiArr, UINT8 *pCount) //update the node array by parentid  and focus on nSel
{
    MENU_NODE_ID NodeId;

    //NODE_FUNCTION * pFunc;
    int i;                      //,value=0,nIdx,nDefault,j,nEnabled;

    APP_Menu_UpdateMenuTree();
    if (ParentId >= MENU_NODE_NUM)
    {
        return;
    }
    for (i = 0; i < MONITOR_MAINMENU_MAX_NODENUM; i++)
    {
        Current_Node_Array[i] = ID_NULL;
    }

    Current_Node_Num = APP_Menu_GetChildNodeNums(ParentId);
    Current_Node_Array[Current_Node_Num] = ID_NULL;
    if (Current_Node_Num > 0)
    {
        NodeId = MenuNode[ParentId].childID;

        for (i = 0; i < Current_Node_Num; i++)
        {
            if (ID_NULL == NodeId)
            {
                Current_Node_Array[i] = NodeId;
                break;
            }

            if (IsNodeSkip(NodeId))
            {
                i--;
                NodeId = MenuNode[NodeId].nextID;
                continue;
            }
            else
            {
                Current_Node_Array[i] = NodeId;
                NodeId = MenuNode[NodeId].nextID;
            }
            MENU_DEBF("[MENU DBG] Current_Node_Array[%d]=%d \n ",i,Current_Node_Array[i]);
        }
        APP_Menu_UpdateContent(phGuiArr, pCount);
    }
    APP_GUIOBJ_Menu_Update_Items_Arrow(phGuiArr, pCount);
}

static BOOLEAN IsNodeSkip(MENU_NODE_ID NodeId)
{
    switch (NodeId)
    {
        case ID_ColorTemp_Red:
        case ID_ColorTemp_Green:
        case ID_ColorTemp_Blue:
        {
            if(APP_UserMenu_GetColorTemp() != MID_COLORTEMP_USER)
                return TRUE;
        }
            break;
        default:
            break;
    }
    return FALSE;
}

static BOOLEAN IsNodeDisabled(UINT32 NodeId)
{
    APP_Source_Type_t eCurrSource = APP_SOURCE_MAX;
    APP_GUIOBJ_Source_GetCurrSource(&eCurrSource);
    switch (NodeId)
    {
        case ID_Contrast:
        case ID_Brightness:
        {
            if(APP_UserMenu_GetPictureMode() != APP_VIDEO_PQ_MODE_STANDARD)
                return TRUE;
            if(APP_UserMenu_GetDynamicContrast() == MID_ON)
                return TRUE;
            if(APP_UserMenu_GetColorTemp() == MID_COLORTEMP_sRGB)
                return TRUE;
            break;
        }
        case ID_EcoMode:
        {
                if(APP_UserMenu_GetDynamicContrast() == MID_ON)
                    return TRUE;
                if(APP_UserMenu_GetColorTemp() == MID_COLORTEMP_sRGB)
                    return TRUE;
                break;
        }
        case ID_BlueLight:
        {
                if(APP_UserMenu_GetDynamicContrast() == MID_ON)
                    return TRUE;
                break;
        }          
        case ID_Clock:
        case ID_Phase:
        case ID_ImageHPosition:
        case ID_ImageVPosition:
        case ID_ImageRatio:
        {
            if(eCurrSource == APP_SOURCE_HDMI || eCurrSource == APP_SOURCE_HDMI1 || eCurrSource == APP_SOURCE_HDMI2)
                return TRUE;
            break;
        }        
        default:
            break;
    }

    return FALSE;
}

static INT32 ChangeFocusedLayerform0to1(BOOLEAN top, HWND * phGuiArr, UINT8 *pCount)
{

    INT32 i32CurrentIndex = 0;

    //MENU_LAYER_1
    if (!top)                   //Focus to the last node
    {
        g_menu_cur_layer = MENU_LAYER_1;
        if (Current_Node_Num > MONITOR_MAINMENU_MAX_ITEM)
        {
            g_Menu_Start_Offset[g_menu_cur_layer] = Current_Node_Num - MONITOR_MAINMENU_MAX_ITEM;
            i32CurrentIndex = MONITOR_MAINMENU_MAX_ITEM - 1;
        }
        else
            i32CurrentIndex = Current_Node_Num - 1;

        i32CurrentIndex = i32CurrentIndex + g_Menu_Start_Offset[g_menu_cur_layer];

        while (IsNodeDisabled(Current_Node_Array[i32CurrentIndex]))
        {
            i32CurrentIndex--;

            if (i32CurrentIndex < 0)
            {
                g_Menu_Start_Offset[g_menu_cur_layer] = 0;
                g_menu_cur_layer = MENU_LAYER_0;
                return GUI_OBJECT_NO_POST_ACTION;
            }
        }
    }
    else
    {
        while (IsNodeDisabled(Current_Node_Array[i32CurrentIndex]))
        {
            i32CurrentIndex++;

            if (i32CurrentIndex > Current_Node_Num - 1)
            {
                return GUI_OBJECT_NO_POST_ACTION;
            }
        }
    }
    g_menu_cur_layer = MENU_LAYER_1;


    if (i32CurrentIndex >= MONITOR_MAINMENU_MAX_ITEM)
    {
        if (i32CurrentIndex == Current_Node_Num - 1)
        {
            g_Menu_Start_Offset[g_menu_cur_layer] = i32CurrentIndex - MONITOR_MAINMENU_MAX_ITEM + 1;
            i32CurrentIndex = MONITOR_MAINMENU_MAX_ITEM - 1;
        }
        else
        {
            g_Menu_Start_Offset[g_menu_cur_layer] = i32CurrentIndex - MONITOR_MAINMENU_MAX_ITEM + 2;
            i32CurrentIndex = MONITOR_MAINMENU_MAX_ITEM - 2;
        }
        APP_Menu_UpdateContent(phGuiArr, pCount);
    }
    i32CurrentIndex %= MONITOR_MAINMENU_MAX_ITEM;
	HWND h_MenuLayer_Listview_Handle = NULL;
	GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control,TV_E_IDC_LIST_ListView_MenuLayerText1,&h_MenuLayer_Listview_Handle));
    GUI_FUNC_CALL(GEL_SetParam(h_MenuLayer_Listview_Handle, PARAM_SETFOCUSED, NULL));
    GUI_FUNC_CALL(GEL_SetParam(h_MenuLayer_Listview_Handle, PARAM_CURRENT_INDEX, &i32CurrentIndex));

    if (!top)
        APP_Menu_UpdateContent(phGuiArr, pCount);

    APP_GUIOBJ_Menu_Update_ItemByListView(phGuiArr, pCount);
    return GUI_OBJECT_NO_POST_ACTION;
}

static int APP_Get_Menu_Layer0Focuesd()
{
    int i, j;
	HWND h_MainPage_Group_Handle = NULL;

	GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control,TV_E_IDC_BTNG_GroupButton_MonitorPage_Layer,&h_MainPage_Group_Handle));

    for (i = ID_Luminance; i <= ID_Extra; i++)
    {
        if (IsNodeDisabled(i))  //from channel to Lock
        {
            j = i - ID_Luminance;
            GUI_FUNC_CALL(GEL_SetParam(h_MainPage_Group_Handle, PARAM_ITEM_DISABLE, &j));
        }

    }

    for (i = ID_Luminance; i <= ID_Extra; i++)
    {
        if (!IsNodeDisabled(i))
        {
            return i;
            break;
        }

    }
    return ID_Luminance;
}

static U32BIT APP_Menu_GetChildNodeNums(MENU_NODE_ID NodeId)
{
    U32BIT nCount = 0;
    MENU_NODE_ID ChildNodeId;

    if (NodeId < MENU_NODE_NUM)
    {
        ChildNodeId = MenuNode[NodeId].childID;
        while (ChildNodeId != ID_NULL && IsNodeSkip(ChildNodeId) && ChildNodeId < MENU_NODE_NUM)
        {
            ChildNodeId = MenuNode[ChildNodeId].nextID;
        }

        if (ChildNodeId < MENU_NODE_NUM)
        {
            nCount++;
            while (ChildNodeId != ID_NULL && MenuNode[ChildNodeId].nextID < MENU_NODE_NUM && ChildNodeId < MENU_NODE_NUM)
            {
                ChildNodeId = MenuNode[ChildNodeId].nextID;
                while (ChildNodeId != ID_NULL && IsNodeSkip(ChildNodeId) && ChildNodeId < MENU_NODE_NUM)
                {
                    ChildNodeId = MenuNode[ChildNodeId].nextID;
                }
                if (ChildNodeId != ID_NULL && (!IsNodeSkip(ChildNodeId)) && ChildNodeId < MENU_NODE_NUM)
                {
                    nCount++;
                }
            }
        }
    }

    return nCount;
}

static INT32 APP_Menu_GetNodeID(void)
{
    int i32CurrentIndex, cur_id;
	HWND h_MenuLayer_Listview_Handle = NULL;
	GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control,TV_E_IDC_LIST_ListView_MenuLayerText1,&h_MenuLayer_Listview_Handle));
    //Get current node id
    GUI_FUNC_CALL(GEL_GetParam(h_MenuLayer_Listview_Handle, PARAM_CURRENT_INDEX, &i32CurrentIndex));
    cur_id = Current_Node_Array[i32CurrentIndex + g_Menu_Start_Offset[g_menu_cur_layer]];
    Current_NodeId = cur_id;

    return Current_NodeId;
}

UINT32 APP_Menu_GetStringWidth(TV_enString_id_t current_string)
{
	int StringWidth = 0;
	if (current_string >=TV_STR_ID_LAST)
	{
		return 0;
	}
	HWND  h_MainPage_Text_push = NULL;
	TV_enString_id_t eStringId = current_string;
	GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control,TV_E_IDC_TEXT_MainPage_Text_Push,&h_MainPage_Text_push));
	GUI_FUNC_CALL(GEL_SetParam(h_MainPage_Text_push, PARAM_STATIC_STRING, &eStringId));
	GUI_FUNC_CALL(GEL_GetParam(h_MainPage_Text_push, PARAM_STRING_WIDTH, (void *)&StringWidth));
	return StringWidth;
}

/*****************************************************************************
** FUNCTION : APP_GUIOBJ_MainMenu_GetRegionHandle
**
** DESCRIPTION :
**				Get current region handle
**
** PARAMETERS :
**				dRegionHandle: current region handle
**
** RETURN VALUES:
**				None
*****************************************************************************/
INT32 APP_GUIOBJ_MainMenu_GetRegionHandle(RegionHandle_t * pRegionHandle)
{
    if (pRegionHandle != NULL)
    {
        *pRegionHandle = g_dRegionHandle;
    }

    return 0;
}

/*****************************************************************************
** FUNCTION : _APP_GUIOBJ_Menu_OnCreate
**
** DESCRIPTION :
**				Menu Gui Object Create
**
** PARAMETERS :
**				pPrivateData   - User Data
**				dParameter   - Special Parameter
**
** RETURN VALUES:
**				SP_SUCCESS
*****************************************************************************/

static INT32 _APP_GUIOBJ_Menu_OnCreate(void **pPrivateData, UINT32 dParameter)
{
    MENU_DEBF();

    g_u32Timer = 0;
    g_bRestoreDefaultStatus = FALSE;
    g_Current_Item_Selected = FALSE;

    int i = 0;
    INT32 i32Group_Index = 0, i32CurrentIndex = 0;
    APP_Source_Type_t eCurrSource = APP_SOURCE_MAX;

    APP_GUIOBJ_Source_GetCurrSource(&eCurrSource);
    INT32 i32Groupindex = 0;
    UINT32 NowFocused = ID_Luminance;

	APP_UserMenu_GetOSDPosition();

    for (i = 0; i < MONITOR_MAINMENU_MAX_ITEM; i++)
    {
        if (g_ppRightSide_DynamicString[i])
        {
            GL_MemFree(g_ppRightSide_DynamicString[i][0]);
            GL_MemFree(g_ppRightSide_DynamicString[i][1]);
            GL_MemFree(g_ppRightSide_DynamicString[i]);
            g_ppRightSide_DynamicString[i] = NULL;
        }
    }
    
    if (dParameter >= ID_Luminance && dParameter <= ID_Extra /*ID_Locksystem */ )
    {
        //b_ever_enter_right_password = FALSE;
        g_dRegionHandle = APP_GuiMgr_ActivateRegion(IDM_MainPage_window, OSD_TVPROJECT, FALSE);
        GUI_FUNC_CALL(GEL_CreateMenu(IDM_MainPage_window, g_dRegionHandle));
        GUI_FUNC_CALL(GEL_CreateMenu(IDM_MenuLayer_window, g_dRegionHandle));

        NowFocused = APP_Get_Menu_Layer0Focuesd();
        g_bCloseAllFlag = TRUE;

        i32Group_Index = dParameter - 1;
        i32CurrentIndex = Current_NodeId - Current_Node_Array[g_Menu_Start_Offset[g_menu_cur_layer]];
        HWND h_MainPage_Group_Handle = NULL;
        GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control,TV_E_IDC_BTNG_GroupButton_MonitorPage_Layer,&h_MainPage_Group_Handle));
        GUI_FUNC_CALL(GEL_SetParam(h_MainPage_Group_Handle, PARAM_CURRENT_INDEX, &i32Group_Index));
        GUI_FUNC_CALL(GEL_SendMsg(h_MainPage_Group_Handle, WM_SETCLICK, 0));
        _APP_GUIOBJ_Menu_UpdateTitleFocus(NULL, NULL);
        APP_Menu_UpdateContent(NULL, NULL);

        HWND h_MenuLayer_Listview_Handle = NULL;
        GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control,TV_E_IDC_LIST_ListView_MenuLayerText1,&h_MenuLayer_Listview_Handle));
        GUI_FUNC_CALL(GEL_SetParam(h_MenuLayer_Listview_Handle, PARAM_CURRENT_INDEX, &i32CurrentIndex));

        APP_GUIOBJ_Menu_Update_ItemByListView(NULL, NULL);
    }
    else if (dParameter > ID_Extra && dParameter < MENU_NODE_NUM)
    {

        INT32 i32Groupindex = 0;
        MENU_NODE_ID Layer0Id = ID_Luminance;

        g_bCloseAllFlag = TRUE;
        Current_Node_Num = 0;
        Current_HeadNodeId = MenuNode[dParameter].parentID;
        g_dRegionHandle = APP_GuiMgr_ActivateRegion(IDM_MainPage_window, OSD_TVPROJECT, FALSE);
        GUI_FUNC_CALL(GEL_CreateMenu(IDM_MainPage_window, g_dRegionHandle));
        GUI_FUNC_CALL(GEL_CreateMenu(IDM_MenuLayer_window, g_dRegionHandle));
        NowFocused = APP_Get_Menu_Layer0Focuesd();

        _APP_GUIOBJ_Menu_Reset_Content(NULL, NULL);
        Layer0Id = Current_HeadNodeId;
        while (Layer0Id > ID_Extra && Layer0Id != ID_Root)
        {
            Layer0Id = MenuNode[Layer0Id].parentID;
        }
        i32Groupindex = Layer0Id - ID_Luminance;
		HWND h_MainPage_Group_Handle = NULL;
		GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control,TV_E_IDC_BTNG_GroupButton_MonitorPage_Layer,&h_MainPage_Group_Handle));
        GUI_FUNC_CALL(GEL_SetParam(h_MainPage_Group_Handle, PARAM_CURRENT_INDEX, &i32Groupindex));
        GUI_FUNC_CALL(GEL_SetParam(h_MainPage_Group_Handle, PARAM_SETFOCUSED, NULL));
        _APP_GUIOBJ_Menu_UpdateTitleFocus(NULL, NULL);
        APP_Menu_UpdateArrayID(Current_HeadNodeId, 0, NULL, NULL);
        if (g_menu_cur_layer > MENU_LAYER_0)
        {
            for (i = 0; i < Current_Node_Num; i++)
            {
                if (Current_Node_Array[i] == dParameter)
                    break;
                // Current_Node_Array[i32CurrentIndex+g_Menu_Start_Offset[g_menu_cur_layer]];
            }

            if (i > g_Menu_Start_Offset[g_menu_cur_layer])
                i32CurrentIndex = i - g_Menu_Start_Offset[g_menu_cur_layer];
            else
                i32CurrentIndex = i;

            if (IsNodeDisabled(dParameter))
                i32CurrentIndex = 0; //for common interface

			HWND h_MenuLayer_Listview_Handle = NULL;
			GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control,TV_E_IDC_LIST_ListView_MenuLayerText1,&h_MenuLayer_Listview_Handle));
            GUI_FUNC_CALL(GEL_SetParam(h_MenuLayer_Listview_Handle, PARAM_SETFOCUSED, NULL));
            GUI_FUNC_CALL(GEL_SetParam(h_MenuLayer_Listview_Handle, PARAM_CURRENT_INDEX, &i32CurrentIndex));
            APP_GUIOBJ_Menu_Update_ItemByListView(NULL, NULL);
        }

        //APP_GUIOBJ_Menu_Update_HelpBar(MENU_HELP_MAIN_MENU_SEL);
    }
    else                        // 0
    {
        for (i = 0; i < MENU_LAYER_END; i++)
        {
            g_Menu_Start_Offset[i] = 0;
        }
        g_bCloseAllFlag = TRUE;
        g_menu_cur_layer = MENU_LAYER_0;
        Current_Node_Num = 0;

        g_dRegionHandle = APP_GuiMgr_ActivateRegion(IDM_MainPage_window, OSD_TVPROJECT, FALSE);
        GUI_FUNC_CALL(GEL_CreateMenu(IDM_MainPage_window, g_dRegionHandle));
        GUI_FUNC_CALL(GEL_CreateMenu(IDM_MenuLayer_window, g_dRegionHandle));
        NowFocused = APP_Get_Menu_Layer0Focuesd();
        _APP_GUIOBJ_Menu_Reset_Content(NULL, NULL);
		HWND h_MainPage_Group_Handle = NULL;
		GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control,TV_E_IDC_BTNG_GroupButton_MonitorPage_Layer,&h_MainPage_Group_Handle));
        GUI_FUNC_CALL(GEL_SetParam(h_MainPage_Group_Handle, PARAM_SETFOCUSED, NULL));
        Current_HeadNodeId = NowFocused;
        i32Groupindex = NowFocused - 1;
        GUI_FUNC_CALL(GEL_SetParam(h_MainPage_Group_Handle, PARAM_CURRENT_INDEX, &i32Groupindex));

        _APP_GUIOBJ_Menu_UpdateTitleFocus(NULL, NULL);
        APP_Menu_UpdateArrayID(Current_HeadNodeId, 0, NULL, NULL);
        //APP_SetHelpNowStatus(HELP_MAIN_MENU_SEL, NULL, NULL);

    }

    GUI_FUNC_CALL(GEL_ShowMenu(IDM_MainPage_window));
    GUI_FUNC_CALL(GEL_ShowMenu(IDM_MenuLayer_window));
    GUI_FUNC_CALL(GEL_UpdateOSD());
    return SP_SUCCESS;
}


/*****************************************************************************
** FUNCTION : _APP_GUIOBJ_Menu_OnRelease
**
** DESCRIPTION :
**				Menu Gui Object Destroy
**
** PARAMETERS :
**				pPrivateData   -  User Data
**
** RETURN VALUES:
**				SP_SUCCESS
*****************************************************************************/
static INT32 _APP_GUIOBJ_Menu_OnRelease(void *pPrivateData)
{
    MENU_DEBF();
    INT32 eStringId = 0;
    g_bRestoreDefaultStatus = FALSE;
    g_Current_Item_Selected = FALSE;
    APP_GUIOBJ_MainMenu_SetPopVolumeState(FALSE); //Leaving mainmenu UI, reset the vol state.
    if (g_bCloseAllFlag)
    {
        GUI_FUNC_CALL(GEL_DestroyMenu(IDM_MenuLayer_window, TRUE));
        GUI_FUNC_CALL(GEL_DestroyMenu(IDM_MainPage_window, TRUE));
    }
    else
    {
        HWND handle = NULL;
        INT32 i = 0;
        for (i = 0; i < MONITOR_MAINMENU_MAX_ITEM; i++)
        {
            if (i < Current_Node_Num)
            {
                GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control,TV_E_IDC_BTN_Button_Arrow01 + i,&handle));
                GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_SETINVISIBLE, NULL));
                GUI_FUNC_CALL(GEL_RGNBUF_RenderControl(handle));
                GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control,TV_E_IDC_BTN_Button_ArrowL01 + i,&handle));
                GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_SETINVISIBLE, NULL));
                GUI_FUNC_CALL(GEL_RGNBUF_RenderControl(handle));
                GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control,TV_E_IDC_COMBO_ComboBox_MenuLayer_Item01 + i,&handle));
                GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_SETINVISIBLE, NULL));
                GUI_FUNC_CALL(GEL_RGNBUF_RenderControl(handle));

            }
        }
        GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control, TV_E_IDC_TEXT_TextBox_MainPage_Title1, &handle));
        eStringId= TV_IDS_String_NULL;
        GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_STATIC_STRING, &eStringId));
        GUI_FUNC_CALL(GEL_RGNBUF_RenderControl(handle));
        GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control,TV_E_IDC_LIST_ListView_MenuLayerText1,&handle));
        GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_SETINVISIBLE, NULL));
        GUI_FUNC_CALL(GEL_RGNBUF_RenderControl(handle));
    }
    AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0, sizeof(APP_SETTING_Setup_t));
    AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 0, sizeof(APP_SETTING_Picture_t));
    AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO, 0, sizeof(APP_SETTING_SystemInfo_t));
    AL_Setting_Store(APP_Data_UserSetting_Handle(), SYS_SET_ID_SOUND, 0, sizeof(APP_SETTING_Sound_t));

    return SP_SUCCESS;
}

/*****************************************************************************
** FUNCTION : _APP_GUIOBJ_Menu_OnFocused
**
** DESCRIPTION :
**				Menu Gui Object Focused
**
** PARAMETERS :
**				pPrivateData   - User Data
**
** RETURN VALUES:
**				SP_SUCCESS
*****************************************************************************/
static INT32 _APP_GUIOBJ_Menu_OnFocused(void *pPrivateData)
{
    MENU_DEBF();
    //g_bCloseAllFlag = TRUE;
    return SP_SUCCESS;
}



/*****************************************************************************
** FUNCTION : _APP_GUIOBJ_Menu_OnLoseFocus
**
** DESCRIPTION :
**				Menu Gui Object Lose Focused
**
** PARAMETERS :
**				pPrivateData   - User Data
**
** RETURN VALUES:
**				SP_SUCCESS
*****************************************************************************/
static INT32 _APP_GUIOBJ_Menu_OnLoseFocus(void *pPrivateData)
{
    MENU_DEBF();
    /*this is for eu home/store mode special case
     * g_Menu_HomeorStore_ModeSettingFlag=FALSE;
     */
    return SP_SUCCESS;
}

/*****************************************************************************
** FUNCTION : _APP_GUIOBJ_Menu_OnTimerUpdate
**
** DESCRIPTION :
**				Menu Gui Object Timer Update
**
** PARAMETERS :
**				pPrivateData   - User Data
**				pPostEventData   -
**
** RETURN VALUES:
**				SP_SUCCESS
*****************************************************************************/
static INT32 _APP_GUIOBJ_Menu_OnTimerUpdate(void *pPrivateData, InteractiveData_t * pPostEventData)
{
    //MENU_DEBF();
    UINT32 u32TimerValue = 0;

    u32TimerValue = (double) APP_Setup_GetOSDTimer();
    if (u32TimerValue == 0)
        u32TimerValue = 0xffffffff;

    u32TimerValue *= 10;
    /*if(stAPPGuiObjMenu.dUpdatePeriod!=10 && u32TimerValue!=0xffffffff)
     * {
     * u32TimerValue/= (double)(stAPPGuiObjMenu.dUpdatePeriod/10);
     * } */

    if (1)
    {
#if 0
        UpdateLayer0_Animation(FALSE);
#endif
    }

    g_u32Timer++;

    if ((g_u32Timer >= u32TimerValue) && (g_u32Timer < 0xffffffff))
    {
        g_u32Timer = 0;
        UINT32 dIndex = 0;

        if (MAIN_APP_SUCCESS == MAINAPP_GetActiveSystemAppIndex(&dIndex))
        {
            SYSAPP_IF_SendGlobalEventWithIndex(dIndex, UI_EVENT_EXIT, 0);
        }
        else
        {

        }
    }
    return SP_SUCCESS;
}

/*****************************************************************************
** FUNCTION : _APP_GUIOBJ_Menu_OnEvent
**
** DESCRIPTION :
**				Menu Gui Object dispose Event
**
** PARAMETERS :
**				dEventID   - Event ID
**				dParam   - The Param of the Event
**				pPrivateData   - User Data
**				pPostEventData   -
**
** RETURN VALUES:
**				SP_SUCCESS
*****************************************************************************/
static INT32 _APP_GUIOBJ_Menu_OnEvent(UINT32 dEventID, UINT32 dParam, void *pPrivateData,
                                      InteractiveData_t * pPostEventData)
{
	MENU_DEBF("[%s,%d],dEventID = 0x%x++++++++++++\n",__FUNCTION__,__LINE__,dEventID);
    UINT32 i32CurrentIndex;
    INT32 ret = GUI_OBJECT_NO_POST_ACTION;
	UINT8 count = 0;
    HWND buffer[100] = { NULL };
	HWND h_MainPage_Group_Handle = NULL;
	HWND h_MenuLayer_Listview_Handle = NULL;
	HWND handle = NULL;
	UINT32 u32Event = 0;

    if (dEventID & PASS_TO_SYSAPP)
    {
        if (((UI_EVENT_FACTORY | PASS_TO_SYSAPP) == dEventID || ((UI_EVENT_FAC_HOTEL | PASS_TO_SYSAPP) == dEventID))
#ifdef CONFIG_SUPPORT_HOTKEY_DISPLAY_PIC
            || ((UI_EVENT_FAC_SHOWPIC | PASS_TO_SYSAPP) == dEventID)
#endif
#ifdef CONFIG_SUPPORT_HOTKEY_SHOW_VERSIONINFO
            || ((UI_EVENT_FAC_SHOWVERSION | PASS_TO_SYSAPP) == dEventID)
#endif
#ifdef CONFIG_SUPPORT_HOTKEY_SOURCE_LOCK
            || ((UI_EVENT_FAC_SOURCE_LOCK | PASS_TO_SYSAPP) == dEventID)
#endif
            )
        {

            if (g_menu_cur_layer == 0)
            {
                return GUI_OBJECT_EVENT_BYPASS;
            }
            else
            {
                //transform the event to original
                if ((UI_EVENT_FACTORY | PASS_TO_SYSAPP) == dEventID)
                {
                    dEventID = UI_EVENT_7;
                }
                else if (((UI_EVENT_FAC_HOTEL | PASS_TO_SYSAPP) == dEventID))
                {
                    dEventID = UI_EVENT_6;
                }
#ifdef CONFIG_SUPPORT_HOTKEY_DISPLAY_PIC
                else if (((UI_EVENT_FAC_SHOWPIC | PASS_TO_SYSAPP) == dEventID))
                {
                    dEventID = UI_EVENT_4;
                }
#endif
#ifdef CONFIG_SUPPORT_HOTKEY_SHOW_VERSIONINFO
                else if (((UI_EVENT_FAC_SHOWVERSION | PASS_TO_SYSAPP) == dEventID))
                {
                    dEventID = UI_EVENT_0;
                }
#endif
#if 0
                else if (((UI_EVENT_FACTORY_HAIER | PASS_TO_SYSAPP) == dEventID))
                {
                    dEventID = UI_EVENT_3;
                }
#endif
            }
        }
        else if ((((FW_MONITOR_STREAM_NO_DATA | PASS_TO_SYSAPP) == dEventID)
#ifdef CONFIG_DTV_SUPPORT
                  || ((APP_DVB_GLOBAL_EVENT_SET_UNMUTE | PASS_TO_SYSAPP) == dEventID)
#endif
                 ))
        {
            dEventID = (dEventID & ~PASS_TO_SYSAPP);
        }
        else
        {
            return GUI_OBJECT_EVENT_BYPASS;
        }
    }



    if (dEventID < UI_IR_EVENT_END)
    {
        g_u32Timer = 0;
    }

    if (IsPasswordNode(APP_Menu_GetNodeID()))
    {
        ret = APP_GUIOBJ_Menu_PW_Handle(dEventID, dParam, pPrivateData, pPostEventData, buffer, &count);
        if (ret == GUI_OBJECT_NO_POST_ACTION || GUI_OBJECT_EVENT_BYPASS == ret)
        {
        	APP_GuiMgr_RegionBufferControl(buffer, count);
			GUI_FUNC_CALL(GEL_UpdateOSD());
            return ret;
        }
        else if (ret == -1)
            return GUI_OBJECT_POST_EVENT;
    }
    /*this is for eu home/store mode special case
     * if(g_Menu_HomeorStore_ModeSettingFlag)
     * {
     * if(UI_EVENT_ENTER == dEventID)
     * {
     * _APP_Disable_Menu_ModeSettingDlg(TRUE);
     * return GUI_OBJECT_NO_POST_ACTION;
     * }
     * else
     * {
     * switch (dEventID)
     * {
     * case  UI_EVENT_KEYPAD_MIN...UI_EVENT_KEYPAD_POWER_UPGRADE:
     * {
     * _APP_Disable_Menu_ModeSettingDlg(FALSE);
     * return GUI_OBJECT_NO_POST_ACTION;
     * }
     *
     * }
     * }
     * }
     */
    switch (dEventID)
    {
      case UI_EVENT_VOL_UP:
      case UI_EVENT_VOL_DN:
          break;
      case UI_EVENT_0 ... UI_EVENT_9:
          {
              NODE_FUNCTION *pFunc;

              _Menu_Choice_Item *choice_item;

              choice_item = malloc(sizeof(_Menu_Choice_Item));
              memset(choice_item, 0, (sizeof(_Menu_Choice_Item)));
              INT32 u8KeyValue = dEventID - UI_EVENT_0;

              pFunc = MenuNode[APP_Menu_GetNodeID()].pThis;
              choice_item->value = u8KeyValue;
              if (pFunc && pFunc->type == MENU_CTRL_TYPE_CHOICEINPUT)
              {
                  (*pFunc->MenuSettingFun) (TRUE, 0, (int *) (choice_item), FALSE, buffer, &count);
              }

              //For slider bar input number.
#ifdef CONFIG_SUPPORT_INDONESIA_EWS
              if (pFunc && pFunc->type == MENU_CTRL_TYPE_SILDERNUMBERINPUT)
              {
                  // only allow number input under slider type
                  MenuInputNumber(dEventID);

                  // Update UI
                  APP_Update_AreaCodeSliderTypeNode(APP_Menu_GetNodeID(), TRUE, buffer, &count);
              }
              else
              {
                  // Clean input number mode
                  MenuSetInputNumberMode(FALSE);
              }
#endif
              MENU_DEBF
                  ("choice_item.show_mode=%d choice_item.show_mode=%d choice_item.value=%d choice_item.digital_max=%d ",
                   choice_item->show_mode, choice_item->show_mode, choice_item->value, choice_item->digital_max);
              APP_GUIOBJ_Menu_Update_ItemByListView(buffer, &count);
			  APP_GuiMgr_RegionBufferControl(buffer, count);
              GUI_FUNC_CALL(GEL_UpdateOSD());
              free(choice_item);
              break;
          }
      case APP_GLOBAL_EVENT_POPMSG_YES:
      case APP_GLOBAL_EVENT_POPMSG_NO:
          {
              MENU_DEBF();
              NODE_FUNCTION *pFunc;

              pFunc = MenuNode[APP_Menu_GetNodeID()].pThis;

              if (pFunc && pFunc->type == MENU_CTRL_TYPE_POPBUTTON)
              {
                  if (pFunc->MenuSettingFun)
                  {
                      if (APP_GLOBAL_EVENT_POPMSG_YES == dEventID)
                          (*pFunc->MenuSettingFun) (TRUE, 0, (int *) pPostEventData, FALSE, buffer, &count);
                      else      //No
                          (*pFunc->MenuSettingFun) (FALSE, 0, (int *) pPostEventData, FALSE, buffer, &count);
                  }
				  APP_GuiMgr_RegionBufferControl(buffer, count);
                  return GUI_OBJECT_POST_EVENT;
              }
          }
          break;
      case UI_EVENT_LEFT:
      case UI_EVENT_ENTER:
      case UI_EVENT_RIGHT:
          {
              if (g_menu_cur_layer == MENU_LAYER_0)
              {
                  if (UI_EVENT_ENTER == dEventID || UI_EVENT_RIGHT == dEventID)
                  {
                      ret = ChangeFocusedLayerform0to1(TRUE, buffer, &count);
                  }
              }
              else              //Layer 1~ layer4
              {
                  if (UI_EVENT_ENTER == dEventID || UI_EVENT_RIGHT == dEventID)
                  {
                      ret = APP_GUIOBJ_Menu_EnterControl(dEventID, pPostEventData, buffer, &count);
                  }
                  else
                  {
                      ret = APP_GUIOBJ_Menu_LeftRightControl(dEventID, pPostEventData, buffer, &count);
                  }

              }
			  APP_GuiMgr_RegionBufferControl(buffer, count);
              if (GUI_OBJECT_POST_EVENT != ret)
                  GUI_FUNC_CALL(GEL_UpdateOSD());
          }
          return ret;
      case UI_EVENT_UP:
      case UI_EVENT_DOWN:
          {
              if(g_Current_Item_Selected)
              {
                  if(dEventID== UI_EVENT_UP)
                      u32Event = UI_EVENT_RIGHT;
                  else
                      u32Event = UI_EVENT_LEFT;
                  ret = APP_GUIOBJ_Menu_LeftRightControl(u32Event, pPostEventData, buffer, &count);
                  APP_GuiMgr_RegionBufferControl(buffer, count);
                  if (GUI_OBJECT_POST_EVENT != ret)
                      GUI_FUNC_CALL(GEL_UpdateOSD());
                  return ret;
              }
                  
              if (g_menu_cur_layer == MENU_LAYER_0)
              {
                  GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control,TV_E_IDC_BTNG_GroupButton_MonitorPage_Layer,&h_MainPage_Group_Handle));
		    GUI_FUNC_CALL(GEL_GetParam
                                (h_MainPage_Group_Handle, PARAM_CURRENT_INDEX,
                                 &i32CurrentIndex));
                  if (UI_EVENT_DOWN == dEventID)
                  {
                      GUI_FUNC_CALL(GEL_SendMsg(h_MainPage_Group_Handle, WM_SELECT_NEXT, 0));
                  }
                  else
                  {
                      GUI_FUNC_CALL(GEL_SendMsg(h_MainPage_Group_Handle, WM_SELECT_PREV, 0));
                  }

                  GUI_FUNC_CALL(GEL_GetParam
                                (h_MainPage_Group_Handle, PARAM_CURRENT_INDEX,
                                 &i32CurrentIndex));
                  Current_HeadNodeId = i32CurrentIndex + ID_Luminance;
                  _APP_GUIOBJ_Menu_UpdateTitleFocus(buffer, &count);
                  APP_Menu_UpdateArrayID(Current_HeadNodeId, 0, buffer, &count);
              }
              else
              {
                  APP_GUIOBJ_Menu_UpDownControl(dEventID, buffer, &count);
                  APP_GUIOBJ_Menu_Update_ItemByListView(buffer, &count);
              }//Layer 1~ layer4

              APP_GuiMgr_RegionBufferControl(buffer, count);
              GUI_FUNC_CALL(GEL_UpdateOSD());

          }
          break;
      case UI_EVENT_RETURN:
      case UI_EVENT_MENU:
          {
#ifdef CONFIG_SUPPORT_INDONESIA_EWS
              if (MenuIsInputNumberMode())
              {
                  MenuSetInputNumberMode(FALSE);
                  areacode_index = 0;
              }
#endif
            if(g_Current_Item_Selected)
            {
                g_Current_Item_Selected = FALSE;
                GUI_FUNC_CALL(GEL_RGNBUF_RenderControl(handle));
                GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_LIST_ListView_MenuLayerText1, &handle));
                GUI_FUNC_CALL(GEL_GetParam(handle, PARAM_CURRENT_INDEX,&i32CurrentIndex));
                GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_SETFOCUSED, NULL));
                APP_GuiMgr_AddRegionBuffer(buffer, &count, handle);
                GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_COMBO_ComboBox_MenuLayer_Item01 + i32CurrentIndex, &handle));
                GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_SETFOCUSED, NULL));
                APP_GuiMgr_AddRegionBuffer(buffer, &count, handle);
                GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_BTN_Button_Arrow01 + i32CurrentIndex, &handle));
                GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_SETFOCUSED, NULL));
                APP_GuiMgr_AddRegionBuffer(buffer, &count, handle);
                GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_BTN_Button_ArrowL01 + i32CurrentIndex, &handle));
                GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_SETFOCUSED, NULL));
                APP_GuiMgr_AddRegionBuffer(buffer, &count, handle);
                APP_GuiMgr_RegionBufferControl(buffer, count);
                GUI_FUNC_CALL(GEL_UpdateOSD());
            }
            else
            {
                  if (g_menu_cur_layer == MENU_LAYER_0)
                  {
                      //pPostEventData->dEventID = GUI_OBJECT_CLOSE;
                      //return GUI_OBJECT_POST_EVENT;
                      return GUI_OBJECT_EVENT_BYPASS;
                  }
                  else              //Layer 1~ layer4
                  {
                      if (g_Menu_Start_Offset[g_menu_cur_layer] != 0)
                          g_Menu_Start_Offset[g_menu_cur_layer] = 0;

                      if (g_menu_cur_layer == MENU_LAYER_1)
                      {
                          //MENU_LAYER_1
                          g_menu_cur_layer--;
                          g_Menu_Start_Offset[g_menu_cur_layer] = 0;
                          APP_Menu_UpdateContent(buffer, &count);
                          GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control,TV_E_IDC_LIST_ListView_MenuLayerText1,&h_MenuLayer_Listview_Handle));
                          GUI_FUNC_CALL(GEL_SetParam(h_MenuLayer_Listview_Handle, PARAM_SETNORMAL, NULL));
                      }
                      else          //return to the last layer
                      {
                          //update eh current layer
                          g_menu_cur_layer--;
                          //update the current array Id
                          APP_Menu_UpdateArrayID(MenuNode[Current_HeadNodeId].parentID, Current_HeadNodeId, buffer, &count);

                          //focused the last node position in listview
                          for (i32CurrentIndex = 0; i32CurrentIndex < MONITOR_MAINMENU_MAX_ITEM; i32CurrentIndex++)
                          {
                              if (Current_HeadNodeId ==
                                  Current_Node_Array[i32CurrentIndex + g_Menu_Start_Offset[g_menu_cur_layer]])
                              {
                                  GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control,TV_E_IDC_LIST_ListView_MenuLayerText1,&h_MenuLayer_Listview_Handle));
                                  GUI_FUNC_CALL(GEL_SetParam(h_MenuLayer_Listview_Handle, PARAM_CURRENT_INDEX,&i32CurrentIndex));
                                  break;
                              }
                          }

                          //update the current node id
                          Current_HeadNodeId = MenuNode[Current_HeadNodeId].parentID;
                          APP_GUIOBJ_Menu_UpdataTitleText(MenuNode[Current_HeadNodeId].strID, buffer, &count);
                      }

                      APP_Menu_UpdateMenuTree();
                      APP_GUIOBJ_Menu_Update_ItemByListView(buffer, &count);
                    }
                }
                APP_GuiMgr_RegionBufferControl(buffer, count);
                GUI_FUNC_CALL(GEL_UpdateOSD());
            }
            break;
      case UI_EVENT_CH_DN:
      case UI_EVENT_CH_UP:
          {
#ifdef CONFIG_SUPPORT_PVR
              int u8MidRecState = MID_RecorderState();
              UINT32 dSysAppIdx = 0;

              if (u8MidRecState != MID_REC_STATUS_STOP)
              {
                  if (MAIN_APP_SUCCESS == MAINAPP_GetActiveSystemAppIndex(&dSysAppIdx))
                      SYSAPP_GOBJ_DestroyGUIObject(dSysAppIdx, APP_GUIOBJ_MAINMENU);
              }
#endif
          }
      case UI_EVENT_EXIT:
          {
#ifdef CONFIG_SUPPORT_INDONESIA_EWS
              if (MenuIsInputNumberMode())
              {
                  MenuSetInputNumberMode(FALSE);
              }
#endif
              return GUI_OBJECT_EVENT_BYPASS;
          }
      case UI_EVENT_DISPLAY:
      case UI_EVENT_SOURCE:
      case UI_EVENT_MUTE:
          {
              return GUI_OBJECT_EVENT_BYPASS;
          }

       case APP_GLOBAL_EVENT_POPMSG_TIMEOUT:
       case APP_GLOBAL_EVENT_POPMSG_EXIT_KEY_MATCH:
          {
              NODE_FUNCTION *pFunc;

              pFunc = MenuNode[APP_Menu_GetNodeID()].pThis;
              if (pFunc && pFunc->type == MENU_CTRL_TYPE_POPBUTTON)
              {
                  MENU_POP_BUTTON *pPop = (MENU_POP_BUTTON *) pFunc->leaves;

                  if (pPop->subtype == POPMSG_PROMPT_AUTO_ADJUST)
                  {
                      APP_Menu_UpdateContent(buffer, &count);
                      APP_GUIOBJ_Menu_Update_ItemByListView(buffer, &count);
    				  APP_GuiMgr_RegionBufferControl(buffer, count);
                      GUI_FUNC_CALL(GEL_UpdateOSD());
                  }
              }
          }
          break;
      default:
          if ((dEventID >= UI_EVENT_KEYPAD_MIN && dEventID < UI_EVENT_KEYPAD_MAX)
              || (dEventID >= UI_IR_EVENT_START && dEventID < UI_IR_EVENT_END))
          {
             //MENU_POP_BUTTON Pop = {POPMSG_TYPE_PROMPT, POPMSG_PROMPT_NOT_AVAILABLE, POPMSG_EXIT_ANY_KEY};
             //_APP_GUIOBJ_Menu_OpenPop(Pop.poptype, Pop.subtype, Pop.exitkey);
          }
          break;
    }

    return GUI_OBJECT_NO_POST_ACTION;
}

BOOL IsPasswordNode(INT32 nNodeID)
{
    return FALSE;
}

BOOL IsPasswordInputCompleted(char *strPAssword)
{
    return FALSE;
}

int APP_GUIOBJ_Menu_PW_Checker(char *pInput)
{
    return FAILURE;
}

int APP_GUIOBJ_Menu_Modied_PW_Checker(char *pInput)
{
    return FAILURE;
}

void APP_GUIOBJ_Menu_Modied_PW_Wrtieback(char *pInput)
{
}


void APP_GUIOBJ_Menu_Set_Password_Status_OK(BOOL bShow)
{
}

void APP_GUIOBJ_Menu_Set_Password_Status_Fail(BOOL bShow)
{
}

void APP_GUIOBJ_Menu_Set_Password_Status_All_Clear(void)
{
}

void APP_GUIOBJ_Menu_PW_Reset(int nNodeID)
{

}

static INT32 APP_GUIOBJ_Menu_PW_Handle(UINT32 dEventID, UINT32 dParam, void *pPrivateData,
                                       InteractiveData_t * pPostEventData, HWND * phGuiArr, UINT8 *pCount)
{
	return GUI_OBJECT_NO_POST_ACTION;
}

//ID_PictureMode Picture/Picture Mode
void Menu_PictureMode(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {
        
    }
    else
    {

    }

}

//ID_Brightness Picture/Brightness
void Menu_Brightness(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    APP_Source_Type_t eSourType = APP_SOURCE_MAX;
    UINT32 u32TempValue = APP_VIDEO_PQ_MODE_MAX;
    APP_GUIOBJ_Source_GetCurrSource(&eSourType);
    if (bSet)
    {
 
    }
    else
    {
        u32TempValue = APP_UserMenu_GetPictureMode();
        switch(u32TempValue)
        {
            case APP_VIDEO_PQ_MODE_STANDARD:
                *pValue = g_stPictureData.PictureMode[eSourType].stStandardTab.Backlight;
                break;
            case APP_VIDEO_PQ_MODE_TEXT:
                *pValue = g_stPictureData.PictureMode[eSourType].stTextTab.Backlight;
                break;
            case APP_VIDEO_PQ_MODE_INTERNET:
                *pValue = g_stPictureData.PictureMode[eSourType].stInternetTab.Backlight;
                break;
            case APP_VIDEO_PQ_MODE_GAME:
                *pValue = g_stPictureData.PictureMode[eSourType].stGameTab.Backlight;
                break;
            case APP_VIDEO_PQ_MODE_MOVIE:
                *pValue = g_stPictureData.PictureMode[eSourType].stMovieTab.Backlight;
                break;
            case APP_VIDEO_PQ_MODE_SPORTS:
                *pValue = g_stPictureData.PictureMode[eSourType].stSportsTab.Backlight;
                break;
            default:
                *pValue = g_stPictureData.PictureMode[eSourType].stStandardTab.Backlight;
                break;
        }
    }
}

//ID_Contrast  Picture/Contrast
void Menu_Contrast(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    APP_Source_Type_t eSourType = APP_SOURCE_MAX;
    UINT32 u32TempValue = APP_VIDEO_PQ_MODE_MAX;
    APP_GUIOBJ_Source_GetCurrSource(&eSourType);
    if (bSet)
    {
       
    }
    else
    {
        u32TempValue = APP_UserMenu_GetPictureMode();
        switch(u32TempValue)
        {
            case APP_VIDEO_PQ_MODE_STANDARD:
                *pValue = g_stPictureData.PictureMode[eSourType].stStandardTab.Contrast;
                break;
            case APP_VIDEO_PQ_MODE_TEXT:
                *pValue = g_stPictureData.PictureMode[eSourType].stTextTab.Contrast;
                break;
            case APP_VIDEO_PQ_MODE_INTERNET:
                *pValue = g_stPictureData.PictureMode[eSourType].stInternetTab.Contrast;
                break;
            case APP_VIDEO_PQ_MODE_GAME:
                *pValue = g_stPictureData.PictureMode[eSourType].stGameTab.Contrast;
                break;
            case APP_VIDEO_PQ_MODE_MOVIE:
                *pValue = g_stPictureData.PictureMode[eSourType].stMovieTab.Contrast;
                break;
            case APP_VIDEO_PQ_MODE_SPORTS:
                *pValue = g_stPictureData.PictureMode[eSourType].stSportsTab.Contrast;
                break;
            default:
                *pValue = g_stPictureData.PictureMode[eSourType].stStandardTab.Contrast;
                break;
        }
    }
}

//ID_Sharpness  Picture/Sharpness
void Menu_Sharpness(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {
        
    }
    else
    {
       
    }
}

//ID_Color  Picture/Saturation
void Menu_Color(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {
        
    }
    else
    {
        
    }
}

//ID_Tint  Picture/Hue
void Menu_Tint(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {
        
    }
    else
    {
        
    }
}

void Menu_EcoMode(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {
        if(*pValue != APP_VIDEO_PQ_MODE_STANDARD)
        {
            APP_UserMenu_SetDynamicContrast(MID_OFF);
            APP_UserMenu_SetBlueLight(MID_BL_OFF);
            APP_UserMenu_SetColorBoostMode(APP_VIDEO_COLOR_BOOST_FULLENHANCE, MID_OFF);
            APP_UserMenu_SetColorBoostMode(APP_VIDEO_COLOR_BOOST_NATURESKIN, MID_OFF);
            APP_UserMenu_SetColorBoostMode(APP_VIDEO_COLOR_BOOST_GREENFIELD, MID_OFF);
            APP_UserMenu_SetColorBoostMode(APP_VIDEO_COLOR_BOOST_SKYBLUE, MID_OFF);
            APP_UserMenu_SetColorBoostMode(APP_VIDEO_COLOR_BOOST_AUTODETECT, MID_OFF);
        }
        APP_UserMenu_SetPictureMode(*pValue);
        APP_Menu_UpdateContent(phGuiArr, pCount);
    }
    else
    {
        *pValue = APP_UserMenu_GetPictureMode();
    }
}

void Menu_DynamicContrast(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    { 
        if(*pValue == MID_ON)
        {
            APP_UserMenu_SetPictureMode(APP_VIDEO_PQ_MODE_STANDARD);
            APP_UserMenu_SetBlueLight(MID_BL_OFF);
            APP_UserMenu_SetColorBoostMode(APP_VIDEO_COLOR_BOOST_FULLENHANCE, MID_OFF);
            APP_UserMenu_SetColorBoostMode(APP_VIDEO_COLOR_BOOST_NATURESKIN, MID_OFF);
            APP_UserMenu_SetColorBoostMode(APP_VIDEO_COLOR_BOOST_GREENFIELD, MID_OFF);
            APP_UserMenu_SetColorBoostMode(APP_VIDEO_COLOR_BOOST_SKYBLUE, MID_OFF);
            APP_UserMenu_SetColorBoostMode(APP_VIDEO_COLOR_BOOST_AUTODETECT, MID_OFF);
            APP_Menu_UpdateContent(phGuiArr, pCount);
        }
        APP_UserMenu_SetDynamicContrast(*pValue);
    }
    else
    {
    	 *pValue = APP_UserMenu_GetDynamicContrast();
    }
}

void Menu_BlueLight(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {     
        if(*pValue != MID_BL_OFF)
        {
            APP_UserMenu_SetPictureMode(APP_VIDEO_PQ_MODE_STANDARD);
            APP_UserMenu_SetDynamicContrast(MID_OFF); 
            APP_UserMenu_SetColorTemp(MID_COLORTEMP_USER);
            APP_UserMenu_SetColorBoostMode(APP_VIDEO_COLOR_BOOST_FULLENHANCE, MID_OFF);
            APP_UserMenu_SetColorBoostMode(APP_VIDEO_COLOR_BOOST_NATURESKIN, MID_OFF);
            APP_UserMenu_SetColorBoostMode(APP_VIDEO_COLOR_BOOST_GREENFIELD, MID_OFF);
            APP_UserMenu_SetColorBoostMode(APP_VIDEO_COLOR_BOOST_SKYBLUE, MID_OFF);
            APP_UserMenu_SetColorBoostMode(APP_VIDEO_COLOR_BOOST_AUTODETECT, MID_OFF);           
            APP_Menu_UpdateContent(phGuiArr, pCount);
        }
        APP_UserMenu_SetBlueLight(*pValue);
    }
    else
    {
        *pValue = APP_UserMenu_GetBlueLight();
    }
}



//ID_PCAspectRatio  Picture/Aspect Ratio
void Menu_MediaAspectRatio(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {
    }
    else
    {

    }
}

//ID_Phase
void Menu_PcPhase(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    UINT16 usTimingTblIdx = 0;
    UINT8 u8Phase = 0;

    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO, 0,
                    sizeof(APP_SETTING_SystemInfo_t), &(g_stSysInfoData));
    APP_UserMenu_Picture_GetPCAutoTuneIdx(&usTimingTblIdx);

    if (bSet)
    {
        g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].Phase = *pValue;
        #ifdef CONFIG_DDC_CI_SUPPORT
        Cmd_AdcAdjust(ADC_CMD_DDCCI_OSD_PHASE, *pValue);
        #endif
        u8Phase =
            APP_UserMenu_ATV_PCSetup_OSDValueMappingtoPhase(g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].Phase);
        Cmd_AdcAdjust(ADC_CMD_PHASE, u8Phase);
        AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO,
                         ITEM_OFFSET(APP_SETTING_SystemInfo_t, stPC_AutoTune[usTimingTblIdx].Phase),
                         sizeof(g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].Phase),
                         &(g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].Phase));
    }
    else
    {
        *pValue = g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].Phase;
    }
}

//ID_Clock
void Menu_PcClock(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    UINT16 usTimingTblIdx = 0;
    UINT32 u32HTotal = 0;
    UINT32 u32RegVal = 0;

    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO, 0,
                    sizeof(APP_SETTING_SystemInfo_t), &(g_stSysInfoData));
    APP_UserMenu_Picture_GetPCAutoTuneIdx(&usTimingTblIdx);

    if (bSet)
    {
        u32HTotal = Cmd_VipGetAdcHTotal();
        u32RegVal = *pValue + u32HTotal;
        Cmd_VipAdjust(VIP_CLOCK, u32RegVal);
        #ifdef CONFIG_DDC_CI_SUPPORT
        Cmd_AdcAdjust(ADC_CMD_DDCCI_OSD_CLOCK, *pValue);
        #endif
        g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8ClockOffset = *pValue;
        AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO,
                         ITEM_OFFSET(APP_SETTING_SystemInfo_t, stPC_AutoTune[usTimingTblIdx].i8ClockOffset),
                         sizeof(g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8ClockOffset),
                         &(g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8ClockOffset));
    }
    else
    {
        *pValue = g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8ClockOffset;
    }
}

//ID_ImageHPosition
void Menu_ImageHPosition(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    UINT16 usTimingTblIdx = 0;

    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO, 0,
                    sizeof(APP_SETTING_SystemInfo_t), &(g_stSysInfoData));
    APP_UserMenu_Picture_GetPCAutoTuneIdx(&usTimingTblIdx);

    if (bSet)
    {
        MID_DISP_DTVSetCropWindowHStartOffset(0, (*pValue - APP_PC_HPOS_DEF));
        g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8HpositionOffset = *pValue;
        AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO,
                         ITEM_OFFSET(APP_SETTING_SystemInfo_t, stPC_AutoTune[usTimingTblIdx].i8HpositionOffset),
                         sizeof(g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8HpositionOffset),
                         &(g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8HpositionOffset));
    }
    else
    {
        *pValue = g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8HpositionOffset;
    }
}

//ID_ImageVPosition
void Menu_ImageVPosition(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    UINT16 usTimingTblIdx = 0;

    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO, 0,
                    sizeof(APP_SETTING_SystemInfo_t), &(g_stSysInfoData));
    APP_UserMenu_Picture_GetPCAutoTuneIdx(&usTimingTblIdx);

    if (bSet)
    {
        MID_DISP_DTVSetCropWindowVStartOffset(0, (*pValue - APP_PC_VPOS_DEF));
        g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8VpositionOffset = *pValue;
        AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_SYSINFO,
                         ITEM_OFFSET(APP_SETTING_SystemInfo_t, stPC_AutoTune[usTimingTblIdx].i8VpositionOffset),
                         sizeof(g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8VpositionOffset),
                         &(g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8VpositionOffset));
    }
    else
    {
        *pValue = g_stSysInfoData.stPC_AutoTune[usTimingTblIdx].i8VpositionOffset;
    }
}

//ID_ImageRatio
void Menu_ImageRatio(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    APP_Source_Type_t eSourType = APP_SOURCE_MAX;

    APP_GUIOBJ_Source_GetCurrSource(&eSourType);


    if (bSet)
    {
        MENU_DEBF("\e[32m%s %d  [Menu_PictureMode] *pValue=%d\e[0m\n", __func__, __LINE__, *pValue);
        APP_Video_AspectSystemSetWrite(APP_Video_AspectRatioTypeMappingToIndex((UINT8) * pValue));
        APP_Video_Set_AspectRatio(*pValue);
    }
    else
    {
        APP_Video_AspectSystemSetRead((UINT8 *) pValue);
        *pValue = (int) APP_Video_AspectRatioIndexMappingToType((*pValue));
        MENU_DEBF("\e[32m%s %d  [Menu_PictureMode] *pValue=%d\e[0m\n", __func__, __LINE__, *pValue);
    }
}

//ID_PcAutoAdjust  Picture/PC Setup/Auto Adjust
void Menu_PcAutoAdjust(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {
        
    }
    else
    {
    }
}

//ID_MediaAspectRatio  Picture/Color Temp
void Menu_ColorTemp(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    APP_Source_Type_t eSourType = APP_SOURCE_MAX;
    APP_GUIOBJ_Source_GetCurrSource(&eSourType);
    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE, 0,
			sizeof(APP_SETTING_Picture_t), &(g_stPictureData));
    if (bSet)
    {
        APP_UserMenu_SetColorTemp(*pValue);
        if(*pValue == MID_COLORTEMP_sRGB)
        {
            g_stPictureData.PictureMode[eSourType].stStandardTab.Backlight = 90;
            g_stPictureData.PictureMode[eSourType].stStandardTab.Contrast = 50;
            AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
				ITEM_OFFSET(APP_SETTING_Picture_t, PictureMode[eSourType].stStandardTab.Backlight),
				sizeof(g_stPictureData.PictureMode[eSourType].stStandardTab.Backlight),
				&(g_stPictureData.PictureMode[eSourType].stStandardTab.Backlight));
           AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_PICTURE,
				ITEM_OFFSET(APP_SETTING_Picture_t, PictureMode[eSourType].stStandardTab.Contrast),
				sizeof(g_stPictureData.PictureMode[eSourType].stStandardTab.Contrast),
				&(g_stPictureData.PictureMode[eSourType].stStandardTab.Contrast));
            
            APP_UserMenu_SetPictureMode(APP_VIDEO_PQ_MODE_STANDARD);
            APP_UserMenu_SetDynamicContrast(MID_OFF);
            APP_UserMenu_SetBlueLight(MID_BL_OFF);
        }
        else if(*pValue != MID_COLORTEMP_USER)
        {
            APP_UserMenu_SetBlueLight(MID_BL_OFF);
        }
        APP_Menu_UpdateArrayID(Current_HeadNodeId, 0, phGuiArr, pCount);
    }
    else
    {
        *pValue = APP_UserMenu_GetColorTemp();
    }
}

void Menu_ColorTemp_Red(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    int Mode = (INT32)AL_FLASH_GetWBMode();
    APP_SETTING_ColorTemp_t stColorTempValue;
    AL_FLASH_GetWBTemperature(Mode,&stColorTempValue);
    if (bSet)
    {

    }
    else
    {       
        *pValue = (stColorTempValue.u16RGain * 100 + 1024) / 2048;
    }
}

void Menu_ColorTemp_Green(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    int Mode = (INT32)AL_FLASH_GetWBMode();
    APP_SETTING_ColorTemp_t stColorTempValue;
    AL_FLASH_GetWBTemperature(Mode,&stColorTempValue);
    if (bSet)
    {

    }
    else
    {       
        *pValue = (stColorTempValue.u16GGain * 100 + 1024) / 2048;
    }
}

void Menu_ColorTemp_Blue(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    int Mode = (INT32)AL_FLASH_GetWBMode();
    APP_SETTING_ColorTemp_t stColorTempValue;
    AL_FLASH_GetWBTemperature(Mode,&stColorTempValue);
    if (bSet)
    {

    }
    else
    {       
        *pValue = (stColorTempValue.u16BGain * 100 + 1024) / 2048;
    }
}

void Menu_FullEnhance(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {
        if(*pValue == MID_ON)
        {
            APP_UserMenu_SetPictureMode(APP_VIDEO_PQ_MODE_STANDARD);
            APP_UserMenu_SetDynamicContrast(MID_OFF);
            APP_UserMenu_SetBlueLight(MID_BL_OFF);
        }
        MID_TVFE_SetPictureDynamicContrastEnable(0);
        APP_UserMenu_SetColorBoostMode(APP_VIDEO_COLOR_BOOST_FULLENHANCE, *pValue);
        APP_Menu_UpdateContent(phGuiArr, pCount);
    }
    else
    {
        *pValue = APP_UserMenu_GetColorBoostMode(APP_VIDEO_COLOR_BOOST_FULLENHANCE);
    }
}

void Menu_NatureSkin(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    int Mode = (INT32)AL_FLASH_GetWBMode();
    APP_SETTING_ColorTemp_t stColorTempValue;
    
    if (bSet)
    {
        if(*pValue == MID_ON)
        {
            APP_UserMenu_SetPictureMode(APP_VIDEO_PQ_MODE_STANDARD);
            APP_UserMenu_SetDynamicContrast(MID_OFF);
            APP_UserMenu_SetBlueLight(MID_BL_OFF);
        }
        MID_TVFE_SetPictureDynamicContrastEnable(0);
        APP_UserMenu_SetColorBoostMode(APP_VIDEO_COLOR_BOOST_NATURESKIN, *pValue);
        if(*pValue == 0)
        {
            AL_FLASH_GetWBTemperature(Mode,&stColorTempValue);
            MID_TVFE_SetColorTmpRGain(stColorTempValue.u16RGain);
        }
        else
        {
            AL_FLASH_GetWBTemperature(MID_COLORTEMP_USER,&stColorTempValue);
            MID_TVFE_SetColorTmpRGain(stColorTempValue.u16RGain);
        }

        APP_Menu_UpdateContent(phGuiArr, pCount);
    }
    else
    {
        *pValue = APP_UserMenu_GetColorBoostMode(APP_VIDEO_COLOR_BOOST_NATURESKIN);
    }
}

void Menu_GreenField(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    int Mode = (INT32)AL_FLASH_GetWBMode();
    APP_SETTING_ColorTemp_t stColorTempValue;
    if (bSet)
    {
        if(*pValue == MID_ON)
        {
            APP_UserMenu_SetPictureMode(APP_VIDEO_PQ_MODE_STANDARD);
            APP_UserMenu_SetDynamicContrast(MID_OFF);
            APP_UserMenu_SetBlueLight(MID_BL_OFF);
        }
        MID_TVFE_SetPictureDynamicContrastEnable(0);
        APP_UserMenu_SetColorBoostMode(APP_VIDEO_COLOR_BOOST_GREENFIELD, *pValue);
        if(*pValue == 0)
        {
            AL_FLASH_GetWBTemperature(Mode,&stColorTempValue);
            MID_TVFE_SetColorTmpGGain(stColorTempValue.u16GGain);
        }
        else
        {
            AL_FLASH_GetWBTemperature(MID_COLORTEMP_USER,&stColorTempValue);
            MID_TVFE_SetColorTmpGGain(stColorTempValue.u16GGain);
        }     
        APP_Menu_UpdateContent(phGuiArr, pCount);
    }
    else
    {
        *pValue = APP_UserMenu_GetColorBoostMode(APP_VIDEO_COLOR_BOOST_GREENFIELD);
    }
}

void Menu_SkyBlue(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    int Mode = (INT32)AL_FLASH_GetWBMode();
    APP_SETTING_ColorTemp_t stColorTempValue;
    if (bSet)
    {
        if(*pValue == MID_ON)
        {
            APP_UserMenu_SetPictureMode(APP_VIDEO_PQ_MODE_STANDARD);
            APP_UserMenu_SetDynamicContrast(MID_OFF);
            APP_UserMenu_SetBlueLight(MID_BL_OFF);
        }
        MID_TVFE_SetPictureDynamicContrastEnable(0);
        APP_UserMenu_SetColorBoostMode(APP_VIDEO_COLOR_BOOST_SKYBLUE, *pValue);
        if(*pValue == 0)
        {
            AL_FLASH_GetWBTemperature(Mode,&stColorTempValue);
            MID_TVFE_SetColorTmpBGain(stColorTempValue.u16BGain);
        }
        else
        {
            AL_FLASH_GetWBTemperature(MID_COLORTEMP_USER,&stColorTempValue);
            MID_TVFE_SetColorTmpBGain(stColorTempValue.u16BGain);
        } 
        APP_Menu_UpdateContent(phGuiArr, pCount);
    }
    else
    {
        *pValue = APP_UserMenu_GetColorBoostMode(APP_VIDEO_COLOR_BOOST_SKYBLUE);
    }
}

void Menu_AutoDetect(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {
        if(*pValue == MID_ON)
        {
            APP_UserMenu_SetPictureMode(APP_VIDEO_PQ_MODE_STANDARD);
            APP_UserMenu_SetDynamicContrast(MID_OFF);
            APP_UserMenu_SetBlueLight(MID_BL_OFF);
        }
        MID_TVFE_SetPictureDynamicContrastEnable(0);
        APP_UserMenu_SetColorBoostMode(APP_VIDEO_COLOR_BOOST_AUTODETECT, *pValue);
        APP_Menu_UpdateContent(phGuiArr, pCount);
    }
    else
    {
        *pValue = APP_UserMenu_GetColorBoostMode(APP_VIDEO_COLOR_BOOST_AUTODETECT);
    }
}
#if 0
void Menu_Demo(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {

    }
    else
    {

    }
}
#endif
void Menu_Volume(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_VARIATIONAL, 0,
				sizeof(APP_SETTING_Variational_t), &(g_stVariationalData));
    if (bSet)
    {
		//uOsdHPosition = *pValue;
    }
    else
    {
		*pValue = g_stVariationalData.Volume;
    }
}

void Menu_OsdHPosition(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {
		//uOsdHPosition = *pValue;
    }
    else
    {
		//*pValue = TV_IDM_MainPage_BG1_window.y;
		*pValue = APP_UserMenu_GetOSDSetup(APP_OSD_HPOSITION);
    }
}

void Menu_OsdVPosition(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {
		//uOsdVPosition = *pValue;
    }
    else
    {
		*pValue = APP_UserMenu_GetOSDSetup(APP_OSD_VPOSITION);
    }
}

void Menu_OsdTimeout(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    //UINT32 u32TempValue = 0;
    if (bSet)
    {
        //u32TempValue = *pValue;
        //APP_Setup_SetOSDTimer(u32TempValue, FALSE);
    }
    else
    {
        *pValue = APP_Setup_GetOSDTimer();
    }
}

void Menu_OsdLanguage(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {
        APP_UserMenu_Language_SetOsdLanguage(*pValue);
        APP_UserMenu_Language_GetOsdLanguage((UINT32 *) pValue);
        GUI_FUNC_CALL(GEL_SetGlobalLang(APP_GuiMgr_GetCurFontLangIndex((UINT32 *) pValue, OSD_TVPROJECT)));
        APP_GUIOBJ_Menu_UpdataTitleText(MenuNode[ID_Extra + ID_Luminance].strID, phGuiArr,pCount);
        _APP_GUIOBJ_Menu_UpdateTitleFocus(phGuiArr,pCount);
        APP_Menu_UpdateContent(phGuiArr,pCount);
    }
    else
        *pValue = APP_Language_GetOSDLang();
}

void Menu_InputSelect(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
	AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
                            sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
	if (bSet)
	{
#ifdef CONFIG_SUPPORT_NOSIGNAL_AUTO_CHANGE_SOURCE
		ATVApp_SetCheckSignalTimes(0xFF, FALSE);
#endif
		if(*pValue == APP_MENUSOURCETYPE_HDMI)
		{
			APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_HDMI);
		}
		else if(*pValue == APP_MENUSOURCETYPE_PC)
		{
			APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_PC);
		}
		else if(*pValue == APP_MENUSOURCETYPE_AV)
		{
			APP_GUIOBJ_Source_SetAppSource(APP_SOURCE_AV);
		}
		else
		{
#ifdef CONFIG_SUPPORT_NOSIGNAL_AUTO_CHANGE_SOURCE
			ATVApp_SetCheckSignalTimes(0, TRUE);
#endif
		}
		g_stSetupData.MenuSourceType = *pValue;
		AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP,
                         ITEM_OFFSET(APP_SETTING_Setup_t, MenuSourceType),
                         sizeof(g_stSetupData.MenuSourceType),
                         &(g_stSetupData.MenuSourceType));
	}
	else
	{
		*pValue = g_stSetupData.MenuSourceType;
	}
}

void Menu_DDCCI(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {
#ifdef CONFIG_DDC_CI_SUPPORT
        tv_SetDDCCIEnable(*pValue);
#endif
        g_stSetupData.DDCCI_Enable = *pValue;
        AL_Setting_Write(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP,
                ITEM_OFFSET(APP_SETTING_Setup_t, DDCCI_Enable),
                sizeof(g_stSetupData.DDCCI_Enable),
                &(g_stSetupData.DDCCI_Enable));
    }
    else
    {
        *pValue = g_stSetupData.DDCCI_Enable;
    }
}

void Menu_OffTimer(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
	UINT32 u32SleepTimer = APP_SLEEPTIMER_OFF;
    if (bSet)
    {
    	//printf("pValue=%d-------%d---------\n",*pValue,__LINE__);
		//APP_SleepTimer_SetDetectFlag(TRUE);
		//APP_GUIOBJ_SleepTimer_Set(*pValue);
    }
    else
    {
		APP_GUIOBJ_SleepTimer_GetSleepTimer(&u32SleepTimer, NULL);
		*pValue = u32SleepTimer;
		//printf("pValue=%d-------%d---------\n",*pValue,__LINE__);
    }
}

void Menu_Reset_No(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    UINT32 i32CurrentIndex;
    HWND h_MenuLayer_Listview_Handle = NULL;
    if(bSet)
    {
        g_menu_cur_layer--;
        APP_Menu_UpdateArrayID(MenuNode[Current_HeadNodeId].parentID, Current_HeadNodeId, phGuiArr, pCount);

        //focused the last node position in listview
        for (i32CurrentIndex = 0; i32CurrentIndex < MONITOR_MAINMENU_MAX_ITEM; i32CurrentIndex++)
        {
            if (Current_HeadNodeId ==
                    Current_Node_Array[i32CurrentIndex + g_Menu_Start_Offset[g_menu_cur_layer]])
            {
                GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control,TV_E_IDC_LIST_ListView_MenuLayerText1,&h_MenuLayer_Listview_Handle));
                GUI_FUNC_CALL(GEL_SetParam(h_MenuLayer_Listview_Handle, PARAM_CURRENT_INDEX,&i32CurrentIndex));
                break;
            }
        }

        //update the current node id
        Current_HeadNodeId = MenuNode[Current_HeadNodeId].parentID;
        APP_GUIOBJ_Menu_UpdataTitleText(MenuNode[Current_HeadNodeId].strID, phGuiArr, pCount);

        APP_Menu_UpdateMenuTree();
        APP_GUIOBJ_Menu_Update_ItemByListView(phGuiArr, pCount);

        APP_GuiMgr_RegionBufferControl(phGuiArr, *pCount);
        GUI_FUNC_CALL(GEL_UpdateOSD());
        g_bCloseAllFlag = TRUE;
    }
    else
    {
	
    }
}

void Menu_RestoreFactoryDefault(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    INT8 i8Mute = 0;
    HWND handle = NULL;
    HWND h_MenuLayer_Listview_Handle = NULL;
    UINT32 i32CurrentIndex = 0;
    UINT32 u32OSDHValue = 0;
    UINT32 u32OSDVValue = 0;
    INT32 eStringId = 0;
    if (bSet)
    {
        APP_Source_Type_t eSourType = APP_SOURCE_MAX;
        APP_GUIOBJ_Source_GetCurrSource(&eSourType);

        AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
					sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
        i8Mute = g_stUserInfoData.Mute;
        GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_TEXT_MainLayer_Text_Push, &handle));
        eStringId = TV_IDS_String_Resetting;
        GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_STATIC_STRING, &eStringId));
        GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_SETNORMAL, NULL));
        APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, handle);
        APP_GuiMgr_RegionBufferControl(phGuiArr, *pCount);
        GUI_FUNC_CALL(GEL_UpdateOSD());
        
        APP_Sysset_Reset(APP_SYSSET_RESET_USER_SETTING);
        if(eSourType == APP_SOURCE_PC)
            ATVApp_ResetGeometrySetting();

#ifdef SUPPORT_CEC_TV
        APP_HDMILink_Init();
#endif
        if (APP_Audio_Get_HPStatus() == APP_Audio_Headphone_PlugOut)
            APP_Audio_SetVolume(APP_GetVolume());
        else
            APP_Audio_SetHPVolume(APP_GetVolume());
        
        if(i8Mute == TRUE && APP_Video_GetCurrSignalStatus())
        {
            APP_Audio_SetMute(FALSE,TRUE,APP_MUTE_MODE_SIGNAL_DETECT,eSourType);
        }
        
        g_bRestoreDefaultStatus = TRUE;
        
        GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_TEXT_MainLayer_Text_Push, &handle));
        GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_SETINVISIBLE, NULL));
        APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, handle);
        
        g_menu_cur_layer--;
        APP_Menu_UpdateArrayID(MenuNode[Current_HeadNodeId].parentID, Current_HeadNodeId, phGuiArr, pCount);
        
        //focused the last node position in listview
        for (i32CurrentIndex = 0; i32CurrentIndex < MONITOR_MAINMENU_MAX_ITEM; i32CurrentIndex++)
        {
            if (Current_HeadNodeId ==
                Current_Node_Array[i32CurrentIndex + g_Menu_Start_Offset[g_menu_cur_layer]])
            {
                GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control,TV_E_IDC_LIST_ListView_MenuLayerText1,&h_MenuLayer_Listview_Handle));
                GUI_FUNC_CALL(GEL_SetParam(h_MenuLayer_Listview_Handle, PARAM_CURRENT_INDEX,&i32CurrentIndex));
                break;
        	}
        }
        
        //update the current node id
        Current_HeadNodeId = MenuNode[Current_HeadNodeId].parentID;
        APP_GUIOBJ_Menu_UpdataTitleText(MenuNode[Current_HeadNodeId].strID, phGuiArr, pCount);

        APP_Menu_UpdateMenuTree();
        APP_GUIOBJ_Menu_Update_ItemByListView(phGuiArr, pCount);
        
        APP_GuiMgr_RegionBufferControl(phGuiArr, *pCount);
        
        AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,			
            sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
        u32OSDHValue = (g_stSetupData.stOSDSetup.OSDHPosition*MAINMENU_MOVE_BUFFER_WIDTH+99)/100;
        u32OSDVValue = (g_stSetupData.stOSDSetup.OSDVPosition*MAINMENU_MOVE_BUFFER_HIEGHT+99)/100;
        GUI_FUNC_CALL(GEL_SetMenuXY(IDM_MainPage_window, u32OSDHValue,u32OSDVValue));
        GUI_FUNC_CALL(GEL_SetMenuXY(IDM_MenuLayer_window, u32OSDHValue, u32OSDVValue));
        TV_IDM_Adjust_HD_window.x = u32OSDHValue;
        TV_IDM_Adjust_HD_window.y = u32OSDVValue;
        GUI_FUNC_CALL(GEL_ShowMenu(IDM_MainPage_window));
        GUI_FUNC_CALL(GEL_ShowMenu(IDM_MenuLayer_window));

#ifdef CONFIG_DDC_CI_SUPPORT
        tv_SetDDCCIEnable(g_stSetupData.DDCCI_Enable);
#endif	

        GUI_FUNC_CALL(GEL_UpdateOSD());
        g_bCloseAllFlag = TRUE;
    }
    else
    {

    }
}


void Menu_Infomation(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    APP_Source_Type_t eSourType = APP_SOURCE_MAX;
    SRCTYPE_t eVipSourceType = SRCTYPE_RESERVED;
    MID_InputInfo_t TimingInfo;
    HWND handle_text = NULL;
    
    char ucInterlaceMode = 'I';
    APP_GUIOBJ_Source_GetCurrSource(&eSourType);
    APP_GUIOBJ_Source_GetVipSourceType(eSourType, &eVipSourceType);
    if (bSet)
    {
          
    }
    else
    {
        MID_TVFE_GetCurrentVideoInfo(&TimingInfo,NULL);

        if (eVipSourceType == SRCTYPE_PC)
        {
            snprintf((char *)g_TimingString, MAX_TIMINGINFO_LEN, "%dx%d\n%02dHz  %02dHz", TimingInfo.wHactive, TimingInfo.wVactive, TimingInfo.wHsfreq, TimingInfo.wVsfreq);
        }
        else if (eVipSourceType == SRCTYPE_HDMI)
        {
            if ((TimingInfo.wVactive >= 480) && (TimingInfo.wVactive <= 490))
            {
                TimingInfo.wVactive = 480;
            }
            if(TimingInfo.uiTimingIndex == PLF_VIDEO_TIMING_ID_NON_VIDEO_TIMING || TimingInfo.eSourceDVIMode) //(TimingInfo.eSourceDVIMode)
            {	
                if(TimingInfo.bIsHScalerDown)
                {
                    if(TimingInfo.wHsfreq == 0)
                        snprintf((char *)g_TimingString, MAX_TIMINGINFO_LEN, "%dx%d\n%02dHz", (TimingInfo.wHactive)*2, TimingInfo.wVactive, TimingInfo.wVsfreq);
                    else
                        snprintf((char *)g_TimingString, MAX_TIMINGINFO_LEN, "%dx%d\n%02dHz  %02dHz", (TimingInfo.wHactive)*2, TimingInfo.wVactive, TimingInfo.wHsfreq, TimingInfo.wVsfreq);
                }
                else
                {
                    if(TimingInfo.wHsfreq == 0)
                        snprintf((char *)g_TimingString, MAX_TIMINGINFO_LEN, "%dx%d\n%02dHz", TimingInfo.wHactive, TimingInfo.wVactive, TimingInfo.wVsfreq);
                    else
                        snprintf((char *)g_TimingString, MAX_TIMINGINFO_LEN, "%dx%d\n%02dHz  %02dHz", TimingInfo.wHactive, TimingInfo.wVactive, TimingInfo.wHsfreq, TimingInfo.wVsfreq);
                }
            }
            else
            {
                if (TimingInfo.eInterlace == 0)
                {
                    ucInterlaceMode = 'p';
                }
                else
                {
                    ucInterlaceMode = 'i';
                }
                if(TimingInfo.wHsfreq == 0)
                    snprintf((char *)g_TimingString, MAX_TIMINGINFO_LEN, "%dx%d%c\n%02dHz", TimingInfo.wHactive, TimingInfo.wVactive, ucInterlaceMode, TimingInfo.wVsfreq);
                else
                    snprintf((char *)g_TimingString, MAX_TIMINGINFO_LEN, "%dx%d%c\n%02dHz  %02dHz", TimingInfo.wHactive, TimingInfo.wVactive, ucInterlaceMode, TimingInfo.wHsfreq, TimingInfo.wVsfreq);
            }
        }
        GUI_FUNC_CALL(GEL_GetHandle(IDM_MenuLayer_control, TV_E_IDC_TEXT_MainLayer_Text_Push, &handle_text));
        GUI_FUNC_CALL(GEL_SetParam(handle_text, PARAM_SETNORMAL, NULL));
        GUI_FUNC_CALL(GEL_SetParam(handle_text, PARAM_DYNAMIC_STRING, g_TimingString));
        APP_GuiMgr_AddRegionBuffer(phGuiArr, pCount, handle_text);
    }
}

void Menu_NoActivePowerOff(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {

    }
    else
    {

    }
}

void Menu_UsbUpdate(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {
        app_data_upgrade_status_e ret;
#ifdef CONFIG_SUPPORT_DETECT_USBPLL
		UINT8 data = 0;
		Cmd_NVMRead(ENVMPurposeIDUSBPLLFailFlag, FALSE, sizeof(UINT8), &data);
		if(data == 1)
		{
			printf("\e[31m USB  PLL Fail , do not upgrade \e[0m\n");
			return;
		}
#endif	

        ret = App_Data_USB_Upgrade_CheckFile(BUILD_NAME);
        if (ret == APP_DATA_CHECK_OK)
        {
            UINT32 dMessage;
            UINT32 dActiveSysApp;
            Upgrade_attr_type_e ReserveBOOT;

            ReserveBOOT = Upgrade_attr_type_FALSE;
            Mid_CmnUpgradeSetAttri(ReserveBOOT, Upgrade_attr_type_MAX, Upgrade_attr_type_MAX);

            if (MAINAPP_GetActiveSystemAppIndex(&dActiveSysApp) == MAIN_APP_SUCCESS)
            {
                SYSAPP_IF_SendGlobalEventWithIndex(dActiveSysApp, UI_EVENT_EXIT, 0);
                dMessage = APP_GLOBAL_EVENT_USB_UPGRADE | PASS_TO_SYSAPP;
                SYSAPP_IF_SendGlobalEventWithIndex(dActiveSysApp, dMessage, 1);

                //pValue->nItem = 1; // Done
            }
            else
            {
                //pValue->nItem = 2; //No act. sys.
            }
        }
        else
        {

        }
    }
    else
    {

    }
}

#ifdef SISCONFIG_CEC
void Menu_CecCtrl(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
#ifdef SUPPORT_CEC_TV
    UINT8 g_u8AmpPort = 0;
    if (bSet)
    {
        APP_Source_Type_t eCurrSourceType = APP_SOURCE_MAX;

        AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
                        sizeof(APP_SETTING_Setup_t), &(g_stSetupData));
        AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
                        sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));

        APP_GUIOBJ_Source_GetCurrSource(&eCurrSourceType);

        switch (*pValue)
        {
          case APP_SWITCH_ON:
              APP_CEC_SetCECSetting(CEC_ControlOnOff, *pValue, FALSE);
              APP_CEC_SetCECSetting(CEC_AutoPowerOn, *pValue, TRUE);

              CECTV_SetCECEnable(CECTV_ENABLE);
              APP_GUIOBJ_Source_SetCECRefreshListFlag(TRUE);
              CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_SET_CECENABLE, CECTV_ENABLE);
              CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_SET_AUTOPOWERON, TRUE);

#ifdef SUPPORT_HDMI_ARC
              if (APP_CEC_GetCECSetting(CEC_ARCOnOff) == APP_SWITCH_ON)
              {
			  	  CECTV_SetAudioARC(TRUE);
			  	  CECTV_SetSpeakerPreference(TRUE);
                  AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SOUND, 0,
                                  sizeof(APP_SETTING_Sound_t), &(g_stSoundData));
                  if (g_stSoundData.Spdif == APP_AUDIO_SPDIF_OFF)
                  {
                      SetAudioData(AUDIO_SPDIF, APP_AUDIO_SPDIF_PCM, FALSE);
                  }

#ifdef CONFIG_SUPPORT_ARC_DDPLUS
                  APP_GUIOBJ_HDMILink_SetSpdif(TRUE);
#endif
                  g_u8AmpPort = APP_Audio_GetAmplifierPort();

                  if (g_u8AmpPort == APP_Audio_GetARCAmplifierPort() && g_u8AmpPort != 0)
                  {
                      //APP_SetTVSpeakersStatus(FALSE); //wait for report audio mode
                      CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_REQUEST_ARC_INITIATION, 0);
                      if (g_stUserInfoData.Mute == TRUE && APP_Get_HDMICEC_AMP_Mute_Status() == FALSE)
                      {
                          APP_GUIOBJ_Mute_MuteKeyHandler();
                      }
                      else if (g_stUserInfoData.Mute == FALSE && APP_Get_HDMICEC_AMP_Mute_Status() == TRUE)
                      {
                          APP_GUIOBJ_Mute_MuteKeyHandler();
                      }
                  }
              }
#endif
              if ((eCurrSourceType == APP_SOURCE_HDMI) || (eCurrSourceType == APP_SOURCE_HDMI1)
                  || (eCurrSourceType == APP_SOURCE_HDMI2))
              {
                  tv_source_t eCECPort;

                  APP_Video_GetCECAPPSourceMapping(&eCECPort, eCurrSourceType);
                  CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_CHGSRC_TO_HDMI, eCECPort);
              }
              else
              {
                  CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_CHGSRC_OUT_HDMI, SRC_OTHERS);
              }
              break;

          case APP_SWITCH_OFF:
#ifdef CONFIG_SUPPORT_ARC_DDPLUS
               Cmd_Hdmi_SetHDMIEDIDAtmosCmd(FALSE);
#endif
		  	  CECTV_SetSpeakerPreference(FALSE);
              APP_CEC_SetCECSetting(CEC_ControlOnOff, *pValue, FALSE);
              APP_CEC_SetCECSetting(CEC_AutoPowerOn, *pValue, TRUE);

              CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_SET_CECENABLE, CECTV_DISABLE);
              CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_SET_AUTOPOWERON, FALSE);

#ifdef SUPPORT_HDMI_ARC
              if (APP_CEC_GetCECSetting(CEC_ARCOnOff) == APP_SWITCH_ON)
              {
                  CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_SET_ARC_OPTION_DISABLE, 0);
                  APP_SetTVSpeakersStatus(TRUE);

#ifdef CONFIG_SUPPORT_ARC_DDPLUS
                  APP_GUIOBJ_HDMILink_SetSpdif(FALSE);
#endif
              }
#endif
              CECTV_SetCECEnable(CECTV_DISABLE);
              break;

          default:
              break;
        }

    }
    else
    {
        *pValue = APP_CEC_GetCECSetting(CEC_ControlOnOff);
    }
#endif
}

void Menu_CecDevAutoPowerOff(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {

    }
    else
    {

    }
}

void Menu_CecTvAutoPowerOn(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {

    }
    else
    {

    }
}

void Menu_CecMenuControl(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
#ifdef SUPPORT_CEC_TV
    InteractiveData_t *pPostEventData = (InteractiveData_t *) pValue;

    if (bSet)
    {
        pPostEventData->dEventID = GUI_OBJECT_SWITCH;
        pPostEventData->dParam1 = APP_GUIOBJ_CEC_MENU_CONTROL;
        pPostEventData->dParam2 = CEC_MENUCONTROL_FROM_HDMICEC;
    }
    else
    {

    }
#endif
}

void Menu_CecDevList(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
#ifdef SUPPORT_CEC_TV
    InteractiveData_t *pPostEventData = (InteractiveData_t *) pValue;

    if (bSet)
    {
        pPostEventData->dEventID = GUI_OBJECT_SWITCH;
        pPostEventData->dParam1 = APP_GUIOBJ_SOURCE_CEC; //APP_GUIOBJ_CEC_DEVICE_LIST;
        pPostEventData->dParam2 = CEC_DEVICELIST_FROM_HDMICEC;
    }
    else
    {

    }
#endif
}

void Menu_CecSystemAudio(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {

    }
    else
    {

    }
}

void Menu_CecARCControl(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
#ifdef SUPPORT_CEC_TV

    AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_USERINFO, 0,
                    sizeof(APP_SETTING_UserInfo_t), &(g_stUserInfoData));
    if (bSet)
    {
        switch (*pValue)
        {
          case APP_SWITCH_ON:
#ifdef CONFIG_BT_RDA5856
        if (*pValue == APP_SWITCH_ON)
        {
            AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SETUP, 0,
                        sizeof(APP_SETTING_Setup_t), &(g_stSetupData));

            if(g_stSetupData.BTSetting.BTMode == BT_MODE_SEND)
            {
                APP_UserMenu_BT_SetBTMode(TV_IDS_String_Off);
            }
        }
#endif
              HDMILINKEDEBF("\n\n===============A:Send CEC Request ARC Initiation===============\n\n");
			  CECTV_SetSpeakerPreference(TRUE);
			  CECTV_SetAudioARC(TRUE);
#ifdef CONFIG_SUPPORT_ARC_DDPLUS
              APP_GUIOBJ_HDMILink_SetSpdif(TRUE);
#endif
              if (CECTV_CheckARCDevice()
                  && APP_Audio_GetAmplifierPort() == APP_Audio_GetARCAmplifierPort()
                  && APP_Audio_GetAmplifierPort() != 0)
              {
                  //APP_SetTVSpeakersStatus(FALSE); //wait for report audio mode
                  CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_REQUEST_ARC_INITIATION, 0);
                  if (g_stUserInfoData.Mute == TRUE && APP_Get_HDMICEC_AMP_Mute_Status() == FALSE)
                  {
                   //   APP_GUIOBJ_Mute_MuteKeyHandler();
                  }
                  else if (g_stUserInfoData.Mute == FALSE && APP_Get_HDMICEC_AMP_Mute_Status() == TRUE)
                  {
                   //   APP_GUIOBJ_Mute_MuteKeyHandler();
                  }
              }
              else
              {
                  CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_REQUEST_ARC_TERMINATION, 0);
                  APP_SetTVSpeakersStatus(TRUE);
              }
              AL_Setting_Read(APP_Data_UserSetting_Handle(), SYS_SET_ID_SOUND, 0,
                              sizeof(APP_SETTING_Sound_t), &(g_stSoundData));
              if (g_stSoundData.Spdif == APP_AUDIO_SPDIF_OFF)
              {
                  SetAudioData(AUDIO_SPDIF, APP_AUDIO_SPDIF_PCM, FALSE);
              }
              break;

          case APP_SWITCH_OFF:
              HDMILINKEDEBF("\n\n===============A:Send CEC Request ARC Termination===============\n\n");
			  //CECTV_SetSpeakerPreference(FALSE);
			  CECTV_SetAudioARC(FALSE);
              CECTV_SendCmd(CECTV_SINGLE_ACT_CMD_SET_ARC_OPTION_DISABLE, 0);
#ifdef CONFIG_SUPPORT_ARC_DDPLUS
              APP_GUIOBJ_HDMILink_SetSpdif(FALSE);
#endif
              APP_SetTVSpeakersStatus(TRUE);
              break;

          default:
              break;
        }
        APP_CEC_SetCECSetting(CEC_ARCOnOff, *pValue, TRUE);
    }
    else
    {
        *pValue = APP_CEC_GetCECSetting(CEC_ARCOnOff);
    }
#endif
}

void Menu_CecCecRootMenu(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {

    }
    else
    {

    }

}

void Menu_CecOptionMenu(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {

    }
    else
    {

    }

}

void Menu_CecContentMenu(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
    if (bSet)
    {

    }
    else
    {

    }
}
#endif

void Menu_FirstTimeSetup(BOOL bSet, BOOL path, int *pValue, BOOL bDefault, HWND * phGuiArr, UINT8 *pCount)
{
#ifdef CONFIG_SUPPORT_FIRST_TIME_SETUP
    InteractiveData_t *pPostEventData = (InteractiveData_t *) pValue;

    if (bSet)
    {
        pPostEventData->dEventID = GUI_OBJECT_SWITCH;
        pPostEventData->dParam1 = APP_GUIOBJ_INITINSTALL;
        pPostEventData->dParam2 = INSTALL_FROM_SETUP;
    }
    else
    {

    }
#endif
}

UINT8 _APP_GUIOBJ_Menu_GetRestoreDefaultStatus(void)
{
    return g_bRestoreDefaultStatus;
}

void APP_GUIOBJ_MainMenu_OpenMenu(void)
{
    int i = 0;
    INT32 i32CurrentIndex = 2;
    HWND handle = NULL;
    HWND h_MainMenu_TitleBitmap[MONITOR_MAINMENU_MAX_ITEM] = {NULL};
    //INT32 String[2];
    //HWND h_MainPage_Help_Bar[HELP_BAR_MAX] = {NULL};
    //HWND h_PageScrollBar = NULL;
    //INT32 string_x=0;
    //INT32 helpBar_Enter_x;
    //RECT stHelpRect;

    g_dRegionHandle = APP_GuiMgr_ActivateRegion(IDM_MainPage_window, OSD_TVPROJECT, FALSE);
    GUI_FUNC_CALL(GEL_CreateMenu(IDM_MainPage_window, g_dRegionHandle));
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control, TV_E_IDC_BTNG_GroupButton_MonitorPage_Layer, &handle));
    GUI_FUNC_CALL(GEL_SetParam(handle, PARAM_CURRENT_INDEX, &i32CurrentIndex));
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control, TV_E_IDC_BTN_Background_MainPage_Luminance, &(h_MainMenu_TitleBitmap[0])));
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control, TV_E_IDC_BTN_Background_MainPage_ImageSetup, &(h_MainMenu_TitleBitmap[1])));
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control, TV_E_IDC_BTN_Background_MainPage_ColorTempSetup, &(h_MainMenu_TitleBitmap[2])));
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control, TV_E_IDC_BTN_Background_MainPage_ColorBoost, &(h_MainMenu_TitleBitmap[3])));
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control,TV_E_IDC_BTN_Background_MainPage_OSDSetup, &(h_MainMenu_TitleBitmap[4])));
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control,TV_E_IDC_BTN_Background_MainPage_Extra, &(h_MainMenu_TitleBitmap[5])));

    for (i = 0; i < MONITOR_MAINMENU_MAX_ITEM; i++)
    {
        if (i == i32CurrentIndex)
        {
            GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_TitleBitmap[i], PARAM_SETFOCUSED, NULL));
        }
        else
        {
            GUI_FUNC_CALL(GEL_SetParam(h_MainMenu_TitleBitmap[i], PARAM_SETNORMAL, NULL));
        }
    }
#if 0
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control, TV_E_IDC_BTN_Button_MainPage_Move, &(h_MainPage_Help_Bar[HELP_BAR_MOVE])));
    GUI_FUNC_CALL(GEL_GetParam(h_MainPage_Help_Bar[HELP_BAR_MOVE],PARAM_AREA,&stHelpRect));
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control,TV_E_IDC_BTN_Button_MainPage_Choise,&(h_MainPage_Help_Bar[HELP_BAR_CHOICE])));
    string_x=APP_Menu_GetStringWidth(TV_IDS_String_Move);
    stHelpRect.x=stHelpRect.x+string_x+25+10;  //pic:25
    GUI_FUNC_CALL(GEL_SetParam(h_MainPage_Help_Bar[HELP_BAR_CHOICE],PARAM_AREA,&stHelpRect));
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control,TV_E_IDC_BTN_Button_MainPage_Exit,&(h_MainPage_Help_Bar[HELP_BAR_EXIT])));
    string_x=APP_Menu_GetStringWidth(TV_IDS_String_EXIT1);
    stHelpRect.x=940-string_x;   //help bar rightlight:930 - string_Exit width
    GUI_FUNC_CALL(GEL_SetParam(h_MainPage_Help_Bar[HELP_BAR_EXIT],PARAM_AREA,&stHelpRect));
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control,TV_E_IDC_BTN_Button_MainPage_Return ,&(h_MainPage_Help_Bar[HELP_BAR_RETURN])));
    string_x=APP_Menu_GetStringWidth(TV_IDS_String_MenuReturn);
    stHelpRect.x=stHelpRect.x-string_x+10;
    GUI_FUNC_CALL(GEL_SetParam(h_MainPage_Help_Bar[HELP_BAR_RETURN],PARAM_AREA,&stHelpRect));
    helpBar_Enter_x=stHelpRect.x;
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control,TV_E_IDC_BTN_Button_MainPage_Enter, &(h_MainPage_Help_Bar[HELP_BAR_ENTER])));
    string_x=APP_Menu_GetStringWidth(TV_IDS_String_OkSelect);
    stHelpRect.x=helpBar_Enter_x-string_x-20;
    GUI_FUNC_CALL(GEL_SetParam(h_MainPage_Help_Bar[HELP_BAR_ENTER],PARAM_AREA,&stHelpRect));
    GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control,TV_E_IDC_BTN_Button_MainPage_09,&(h_MainPage_Help_Bar[HELP_BAR_0_9])));
    string_x=APP_Menu_GetStringWidth(TV_IDS_String_Digital_Input);
    stHelpRect.x=helpBar_Enter_x-string_x-20;
    GUI_FUNC_CALL(GEL_SetParam(h_MainPage_Help_Bar[HELP_BAR_0_9],PARAM_AREA,&stHelpRect));
	GUI_FUNC_CALL(GEL_GetHandle(IDM_MainPage_control, TV_E_IDC_SCROL_PageScrollBar2, &h_PageScrollBar));
    GUI_FUNC_CALL(GEL_SetParam
                (h_MainPage_Help_Bar[HELP_BAR_MOVE], PARAM_SETFOCUSED, NULL));
    GUI_FUNC_CALL(GEL_SetParam
                (h_MainPage_Help_Bar[HELP_BAR_CHOICE], PARAM_SETINVISIBLE, NULL));
    GUI_FUNC_CALL(GEL_SetParam
                (h_MainPage_Help_Bar[HELP_BAR_ENTER], PARAM_SETNORMAL, NULL));
    GUI_FUNC_CALL(GEL_SetParam
                (h_MainPage_Help_Bar[HELP_BAR_0_9], PARAM_SETINVISIBLE, NULL));
    String[0] = TV_IDS_String_MenuReturn;
    GUI_FUNC_CALL(GEL_SetParam
                (h_MainPage_Help_Bar[HELP_BAR_RETURN], PARAM_SETNORMAL, NULL));
    GUI_FUNC_CALL(GEL_SetParam
                (h_MainPage_Help_Bar[HELP_BAR_RETURN], PARAM_STATIC_STRING, &String));
#endif
    GUI_FUNC_CALL(GEL_ShowMenu(IDM_MainPage_window));
}

//**************************************************************************************************
// End of File
//**************************************************************************************************