static void win_atnsetm_load_motor_antenna_setting(BOOL update)
{
	MULTISEL* msel;
	EDIT_FIELD* edf;
	CONTAINER* item;
	SYSTEM_DATA* sys_data;
	antenna_t* pAntenna;
	Usals_Local* pLocal;
	UINT32 val = 0;
	
	sys_data = sys_data_get();
	pAntenna = &sys_data->tuner_lnb_antenna[antset_cur_tuner];
	pLocal	= &sys_data->local;
	
	val = pLocal->local_longitude & 0x7FFF;
	if(val>18000)
		pLocal->local_longitude = 0;
	val = pLocal->local_latitude & 0x7FFF;
	if(val>9000)
		pLocal->local_latitude = 0;
	

	/* LNB type */
	msel = anesetm_msels[LNB_ID - 1];
	OSD_SetMultiselCount(msel, get_lnb_type_cnt());
	val = get_lnb_type_index(pAntenna->lnb_type,pAntenna->lnb_low,pAntenna->lnb_high);
	if(val >=  get_lnb_type_cnt())
		val = 0;	
	msel->nSel = val;
	
	item = anesetm_items[LNB_ID - 1];
	if(update)
		OSD_DrawObject((POBJECT_HEAD)item, C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);

	/* Motor type */
	msel = anesetm_msels[MOTOR_ID - 1];
	if(pAntenna->motor_type != LNB_MOTOR_DISEQC12 && pAntenna->motor_type != LNB_MOTOR_USAL)
		pAntenna->motor_type = LNB_MOTOR_DISEQC12;
	if(pAntenna->motor_type == LNB_MOTOR_DISEQC12)
		val = 0;
	else
		val = 1;
	msel->nSel = val;
	item = anesetm_items[MOTOR_ID - 1];
	if(update)
		OSD_DrawObject((POBJECT_HEAD)item, C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);


	/* Local longitute */
	edf = anesetm_edfs[0];
	OSD_SetEditFieldContent(edf,STRING_NUMBER,pLocal->local_longitude & 0x7FFF);
	if(pLocal->local_longitude & 0x8000)
		val = 1;
	else
		val = 0;
	OSD_SetEditFieldSuffix(edf, STRING_ANSI, (UINT32)longitute_sub_chars[val]);
	longitute_sub_idx = val;	

	/* Local latitute */
	edf = anesetm_edfs[1];
	OSD_SetEditFieldContent(edf,STRING_NUMBER,pLocal->local_latitude & 0x7FFF);
	if(pLocal->local_latitude & 0x8000)
		val = 1;
	else
		val = 0;
	OSD_SetEditFieldSuffix(edf, STRING_ANSI, (UINT32)latitute_sub_chars[val]);
	latitute_sub_idx = val;	

	win_atnsetm_load_local_action(update);
}
Example #2
0
PRESULT comlist_tvsys_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
	UINT16 i,wTop;
	UINT8 id;
	char str_len;
	OBJLIST* ol;
	UINT8 temp[4];
	SYSTEM_DATA* p_sys_data=sys_data_get();
	
	PRESULT cbRet = PROC_PASS;

	ol = (OBJLIST*)pObj;
	
	if(event==EVN_PRE_DRAW)
	{
		id=OSD_GetFocusID((POBJECT_HEAD)&win_av_con);
		switch(id)
		{
			case TVMODE_ID:
			    	wTop = OSD_GetObjListTop(ol);
			    	for(i=0;i<ol->wDep && (i+wTop)<ol->wCount;i++)
			    	{
						win_comlist_set_str(i + wTop,get_tv_mode_string(i+wTop),NULL,0);
			    	}
				break;
			
			case TVASPECT_ID:
#ifdef HDMI_CERTIFICATION_UI
				if( check_tv_display_in_hd_mode() )
				{
					OSD_SetObjListCount(ol, 1);
					//insert [16:9] into com_list[0];
					win_comlist_set_str(0, tv_ratio[3], NULL,0);
					break;
				}
				else
				{
					wTop = OSD_GetObjListTop(ol);
					OSD_SetObjListCount(ol, TV_RATIO_NCNT);
				}
#else
				wTop = OSD_GetObjListTop(ol);
#endif
			    	for(i=0;i<ol->wDep && (i+wTop)<ol->wCount;i++)
			    	{
						win_comlist_set_str(i + wTop,tv_ratio[i+wTop],NULL,0);
			    	}
				break;

				
			case VIDEOOUT_ID:
			    	wTop = OSD_GetObjListTop(ol);
			    	for(i=0;i<ol->wDep && (i+wTop)<ol->wCount;i++)
			    	{
#ifndef HDTV_SUPPORT
						win_comlist_set_str(i + wTop,NULL,NULL,video_output_ids[i]);
#else
						win_comlist_set_str(i + wTop,video_output[i+wTop],NULL,0);
#endif
			    	}			
				break;
				
			case RFSYSTEM_ID:
			    	wTop = OSD_GetObjListTop(ol);
			    	for(i=0;i<ol->wDep && (i+wTop)<ol->wCount;i++)
			    	{
						win_comlist_set_str(i + wTop,rf_mode_stings[i+wTop],NULL,0);
			    	}
				break;
				
			case RFCHAN_ID:
			    	wTop = OSD_GetObjListTop(ol);
			    	for(i=0;i<ol->wDep && (i+wTop)<ol->wCount;i++)
			    	{
						sprintf(temp,"%d", i+wTop+rf_ch_range[p_sys_data->avset.rf_mode][0]);
						win_comlist_set_str(i + wTop,temp,NULL,0);
			    	}
				break;

			
#ifdef HDTV_SUPPORT
			case HDMIOUT_ID:
			    	wTop = OSD_GetObjListTop(ol);
			    	for(i=0;i<ol->wDep && (i+wTop)<ol->wCount;i++)
			    	{
						win_comlist_set_str(i + wTop,format_setting[i+wTop],NULL,0);
			    	}
				break;
				
			case AUDIOOUT_ID:
			    	wTop = OSD_GetObjListTop(ol);
			    	for(i=0;i<ol->wDep && (i+wTop)<ol->wCount;i++)
			    	{
						win_comlist_set_str(i + wTop,audio_setting[i+wTop],NULL,0);
			    	}
				break;
#endif
		}
	}
	else if(event == EVN_POST_CHANGE)
	{
		cbRet = PROC_LEAVE;
	}

	return cbRet;
}
Example #3
0
static PRESULT av_item_sel_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
	PRESULT ret = PROC_PASS;
	VACTION unact;
	UINT8 bID;
	UINT32 sel;
	UINT16* Uni_str;
	SYSTEM_DATA* sys_data;
	OSD_RECT rect;
	COM_POP_LIST_PARAM_T param;

#ifdef HDMI_CERTIFICATION_UI
	MULTISEL * msel;
#endif

	bID = OSD_GetObjID(pObj);
	sys_data = sys_data_get();
	switch(event)
	{
		case EVN_PRE_CHANGE:
			sel = *((UINT32*)param1);
			break;
			
		case EVN_POST_CHANGE:
			sel = param1;
			switch(bID)
			{
				case TVMODE_ID:
					sys_data->avset.tv_mode = tvmode_osd_to_setting(sel);
					api_video_set_tvout(sys_data->avset.tv_mode);	
#ifdef HDMI_CERTIFICATION_UI
					msel = av_item_set[TVASPECT_ID - 1];
					if( check_tv_display_in_hd_mode() )
					{
						win_av_set_ratio(sys_data,3);	// 16:9
						sys_data_set_display_mode(&(sys_data->avset));

						OSD_SetMultiselCount(msel, 1);
						OSD_SetMultiselSel(msel, 3);
					}
					else
					{
						OSD_SetMultiselCount(msel, TV_RATIO_NCNT);
					}
					OSD_DrawObject((POBJECT_HEAD)msel, C_UPDATE_CONTENT);
					OSD_DrawObject((POBJECT_HEAD)&win_av_con, C_UPDATE_CONTENT);
#endif  					
					break;

				case TVASPECT_ID:
#ifdef HDMI_CERTIFICATION_UI					
					msel = av_item_set[TVASPECT_ID - 1];
					if( check_tv_display_in_hd_mode() )
					{	
						win_av_set_ratio(sys_data,3);	// 16:9
						OSD_SetMultiselSel(msel, 3);
					}
					else
#endif						
					{
						win_av_set_ratio(sys_data,sel);
					}
					sys_data_set_display_mode(&(sys_data->avset));			
					break;
					
				case VIDEOOUT_ID:
#ifdef HDTV_SUPPORT
					if (sel == 0)
					{
						sys_data->avset.scart_out = SCART_YUV;
					    sys_data->avset.tv_mode = TV_MODE_1080I_25;
						api_Scart_RGB_OnOff(0);
					}
					else
					{
						sys_data->avset.scart_out = SCART_RGB;
					    api_Scart_RGB_OnOff(1);
					}
#ifndef GPIO_RGB_YUV_SWITCH
					api_video_set_tvout(sys_data->avset.tv_mode);
#endif
					win_av_load_tv_mode_setting(TRUE);
#else			
					sys_data->avset.scart_out = sel;
					if(sel == SCART_CVBS)
					{
						api_Scart_RGB_OnOff(0);
		                #ifdef VDAC_USE_SVIDEO_TYPE
						api_Svideo_OnOff(0);
		                #endif
					}
					else if(sel == SCART_RGB)
					{
						api_Scart_RGB_OnOff(1);
						//api_Svideo_OnOff(0);/*RGB output will cut off svideo output,ommit here*/
					}
					else
					{
						api_Scart_RGB_OnOff(0);
		                #ifdef VDAC_USE_SVIDEO_TYPE
						api_Svideo_OnOff(1);
		                #endif
					}
#endif
					win_av_set_vcrloop_action(TRUE);
					if(sys_data->avset.scart_out == SCART_RGB)
						api_Scart_OutPut_Switch(1);
					else
						api_Scart_OutPut_Switch(sys_data->vcrloopmode);
					break;
					
				case VCR_ID:
					sys_data->vcrloopmode = sel;
					api_Scart_OutPut_Switch(sys_data->vcrloopmode );
					break;
					
				case RFSYSTEM_ID:
					sys_data->avset.rf_mode = sel;
					win_check_rf_channel(sys_data);
					OSD_SetMultiselSelTable(av_item_set[RFCHAN_ID - 1], rf_ch_range[sel]);					
					sys_data_set_rf(sys_data->avset.rf_mode, sys_data->avset.rf_channel);
					break;
					
				case RFCHAN_ID:
					sys_data->avset.rf_channel = sel;
					sys_data_set_rf(sys_data->avset.rf_mode, sys_data->avset.rf_channel);
					break;
					
#ifdef HDTV_SUPPORT
				case HDMIOUT_ID:
#ifdef HDMI_CERTIFICATION_UI
					if(!check_hdmi_out_in_dvi_mode())
					{	
						// STB only output RGB in DVI mode
						sys_data->avset.video_format = convert_ui_hdmi_out_sel_to_sys_video_format(sel);
						sys_data_set_video_format(sys_data->avset.video_format);
					}
#else
					sys_data->avset.video_format = sel;
					sys_data_set_video_format(sys_data->avset.video_format);
#endif
					break;
				case AUDIOOUT_ID:
					sys_data->avset.audio_output = sel;
					sys_data_set_audio_output(sys_data->avset.audio_output);
					break;
#endif
#if (SUPPORT_DUAL_OUTPUT_ONOFF)
				case DUALOUT_ID:
					sys_data->avset.dual_output = sel;
					sys_data_set_dual_output(sys_data->avset.dual_output);
					break;
#endif
			} 		
			break;
			
		case EVN_REQUEST_STRING:
			sel = param1;
			Uni_str= (UINT16*)param2;
			switch(bID)
			{
				case TVMODE_ID:
					ComAscStr2Uni(get_tv_mode_string(sel), Uni_str);
					break;
					
				case TVASPECT_ID:
#ifdef HDMI_CERTIFICATION_UI
					if( check_tv_display_in_hd_mode() )					
					{
						sel = 3; // 16:9
					}
#endif					
					ComAscStr2Uni(tv_ratio[sel], Uni_str);
					break;
#ifdef HDTV_SUPPORT
				case VIDEOOUT_ID:
					ComAscStr2Uni(video_output[sel], Uni_str);
					break;
#endif
		//		case VCR_ID:			break;
				case RFSYSTEM_ID:
					ComAscStr2Uni(rf_mode_stings[sel], Uni_str);
					break;
		//		case RFCHAN_ID:			break;		
			}
			break;
		
		case EVN_UNKNOWN_ACTION:
			win_av_enter_key(bID);		
			break;
	}
 	return ret;
}
Example #4
0
static PRESULT mpeg_player_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
    PRESULT ret = PROC_PASS;
    VACTION unact;
    SYSTEM_DATA* sys_data;

    sys_data = sys_data_get();

    switch (event)
    {
    case EVN_PRE_OPEN:
        MPEGBAR_TIMER_TIME = sys_data->osd_set.time_out;
        if(MPEGBAR_TIMER_TIME == 0 || MPEGBAR_TIMER_TIME>10)
            MPEGBAR_TIMER_TIME = 5;
        MPEGBAR_TIMER_TIME *= 1000;
        if (!m_mpeg_player_working)
        {
            MPEG_player_init();
        }
        else
        {
            ret = PROC_LOOP;
        }
        m_mpeg_player_working = TRUE;
        break;
    case EVN_POST_OPEN:
        mpeg_timeout_id = api_start_timer(MPEGBAR_TIMER_NAME, MPEGBAR_TIMER_TIME, mpeg_timeout_handler);
        break;
    case EVN_POST_DRAW:
        win_mpeg_player_draw_infor();
        break;
    case EVN_PRE_CLOSE:
        mpg_cmd_stop_proc();
        api_stop_timer(&mpeg_refresh_id);
        api_stop_timer(&mpeg_timeout_id);
        m_mpeg_player_working = FALSE;
        g_from_mpegplayer = TRUE;
        break;
    case EVN_UNKNOWN_ACTION:
        api_stop_timer(&mpeg_timeout_id);
        unact = (VACTION)(param1>>16);
        switch (unact)
        {
        case VACT_MUTE:
        {
            SetMuteOnOff(TRUE);
            ret = PROC_LOOP;
            break;
        }

        default :
        {
            ret = win_mpeg_player_key_proc(pObj, (param1 & 0xFFFF), param2);
            if (ret != PROC_LEAVE)
            {
                if( ((param1 & 0xFFFF) != V_KEY_EXIT) && ((param1 & 0xFFFF) != V_KEY_MENU)
                        && ((param1 & 0xFFFF) != V_KEY_PVR_INFO) && ((param1 & 0xFFFF) != V_KEY_INFOR)&& ((param1 & 0xFFFF) != V_KEY_LEFT) && ((param1 & 0xFFFF) != V_KEY_RIGHT))
                {
                    win_mpeg_player_draw(TRUE);
                }
            }
            break;
        }
        }
        mpeg_timeout_id = api_start_timer(MPEGBAR_TIMER_NAME, MPEGBAR_TIMER_TIME, mpeg_timeout_handler);
        break;
    case EVN_UNKNOWNKEY_GOT:
        break;
    case EVN_MSG_GOT:
        ret = win_mpeg_player_message_proc(pObj, param1, param2);
        break;
    }

    return ret;
}
Example #5
0
static PRESULT win_volume_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
	PRESULT ret = PROC_PASS;
	SYSTEM_DATA* sys_data;
	PROGRESS_BAR* bar;

	bar = &vol_bar;

	sys_data = sys_data_get();	

	switch(event)
	{
	case EVN_PRE_OPEN:
        win_volume_switch_clrstyle();        
        api_inc_wnd_count();
		VOLUME_TIMER_TIME = sys_data->osd_set.time_out;
		if(VOLUME_TIMER_TIME == 0 || VOLUME_TIMER_TIME>10)
			VOLUME_TIMER_TIME = 5;
		VOLUME_TIMER_TIME *= 1000;		
		OSD_SetProgressBarPos(bar, sys_data->volume);
		break;
	case EVN_POST_OPEN:
		volume_timer = api_start_timer(VOLUME_TIMER_NAME,VOLUME_TIMER_TIME,volume_timer_func);
		break;
	case EVN_UNKNOWNKEY_GOT:
		ap_send_msg(CTRL_MSG_SUBTYPE_KEY, param1,FALSE);
		ret = PROC_LEAVE;
		break;
	case EVN_MSG_GOT:
		if(param1 ==  CTRL_MSG_SUBTYPE_CMD_EXIT)
		{
			ret = PROC_LEAVE;
		}
#ifdef USB_MP_SUPPORT
		else if(param1 == CTRL_MSG_SUBTYPE_STATUS_VIDEO_OVER)
		{
			ret = PROC_LEAVE;
			ap_send_msg(CTRL_MSG_SUBTYPE_STATUS_VIDEO_OVER,0,TRUE);
		}
#endif
		break;
	case EVN_PRE_CLOSE:
		// if open volume window by popup window, not clear OSD. 
		if(menu_stack_get_top() != (POBJECT_HEAD)&g_win_volume)
		{
			/* Make OSD not flickering */
			*((UINT32*)param2) &= ~C_CLOSE_CLRBACK_FLG;	
		}
		break;
	case EVN_POST_CLOSE:
		api_stop_timer(&volume_timer);		
        sys_data_save(1);
        api_dec_wnd_count();
		break;
	default:
		;
	}


	return ret;
}
Example #6
0
static PRESULT miscset_item_sel_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
	PRESULT ret = PROC_PASS;
	UINT32 sel;
	UINT8 bID;
	SYSTEM_DATA* sys_data;
	UINT16* Uni_str;

	bID = OSD_GetObjID(pObj);

	sys_data = sys_data_get();

	switch(event)
	{
	case EVN_PRE_CHANGE:
		sel = *((UINT32*)param1);
		break;
	case EVN_POST_CHANGE:
		sel = param1;
		if(bID == LNBPOWER_ID)
		{
			if(sel == 0)
				SetLNBShortDetect(sel);
			sys_data->bLNB_power = sel;
			api_LNB_power(sys_data->bLNB_power);
			SetLNBShortDetectStart(sys_data->bLNB_power);
			if(sel == 1)
				SetLNBShortDetect(sel);
		}
		else if(bID == CHANCHG_CHAN_ID)
			sys_data->chan_sw = sel;
		else if(bID == CHANCHG_VIDEO_ID)
			sys_data->chchgvideo_type = sel;
    	else if(bID == INSTALLBEEP_ID)
			sys_data->ber_printf = sel;
        else if(bID == AUTO_STANDBY_ID)
            sys_data->auto_standby_en= sel;
/*
        else if(bID == RAM_TMS_ID)
            sys_data->ram_tms_en = sel;
*/
#ifdef ORDER_GZ1207009

	else if(bID == AUTO_STANDBY_MODE_ID)
		sys_data->standbymode=sel;
#endif
        break; 
		case EVN_REQUEST_STRING:
			sel = param1;
			Uni_str= (UINT16*)param2;
			switch(bID)
			{
				case AUTO_STANDBY_ID:
					ComAscStr2Uni(auto_stdy_onoff_stings[sel], Uni_str);
					break;
			}
			break;

	}
 	return ret;
}
Example #7
0
static void win_miscset_save_setting(void)
{
	MULTISEL	*msel;
	SYSTEM_DATA* sys_data;
	UINT32 val;

	sys_data = sys_data_get();

#ifndef NEW_DEMO_FRAME
	struct nim_lnb_info lnb_info;
	for(i=0;i<2;i++)
	{
        lib_nimg_get_lnb_info(i+1,&lnb_info);
        if(LNB_POWER_OFF == sys_data->bLNB_power)
            lnb_info.lnb_power_off = 1;
        else
            lnb_info.lnb_power_off = 0;                      
		lib_nimg_set_lnb_info(i+1,&lnb_info);
	}
#else
	struct nim_config lnb_info;
	struct nim_device *nim;
UINT16 i;
	for(i=0;i<2;i++)
	{
        nim = (struct nim_device *)dev_get_by_id(HLD_DEV_TYPE_NIM, i);
        dev_get_nim_config(nim,FRONTEND_TYPE,&lnb_info);
        if(LNB_POWER_OFF == sys_data->bLNB_power)
            lnb_info.antenna.antenna_enable = /*0*/1;   //Seiya fix BUG37540:
        else
            lnb_info.antenna.antenna_enable = 1;                   
	    dev_set_nim_config(nim, FRONTEND_TYPE, &lnb_info);
	}
#endif

	msel =&miscset_sel1;
	val = OSD_GetMultiselSel(msel);
	sys_data->chan_sw = val;
	
	msel =&miscset_sel2;
	val = OSD_GetMultiselSel(msel);
	sys_data->chchgvideo_type = val;

#ifdef CHANCHG_VIDEOTYPE_SUPPORT
#ifndef NEW_DEMO_FRAME
	UIChChgSetVideoType(sys_data->chchgvideo_type);
#endif
#endif
	
	msel =&miscset_sel3;
	val = OSD_GetMultiselSel(msel);
	sys_data->install_beep = val;

    msel =&miscset_sel4;
	val = OSD_GetMultiselSel(msel);
	sys_data->auto_standby_en= val;


#ifdef ORDER_GZ1207009
	   msel =&miscset_sel6;
	val = OSD_GetMultiselSel(msel);
	sys_data->standbymode= val;
#endif

#ifdef RAM_TMS_TEST
    msel =&miscset_sel5;
	val = OSD_GetMultiselSel(msel);

	char rec_part[16];
	char tms_part[16];

	if (sys_data->ram_tms_en != val) // detach tms part
	{
		rec_part[0] = tms_part[0] = 0;
		pvr_get_cur_mode(rec_part, tms_part);
		if (tms_part[0] != 0)
		{
			if (STRCMP(rec_part, tms_part) == 0)
				pvr_set_disk_use(PVR_REC_ONLY_DISK, rec_part);
			else
				pvr_detach_part(tms_part, PVR_TMS_ONLY_DISK);
			api_pvr_adjust_tms_space();
		}
	}
	
	if (sys_data->ram_tms_en == 0 && val == 1) // enable RAM disk timeshift
	{
		UINT32 ram_len = RAM_DISK_SIZE;	
		UINT32 ram_addr = (void *)(RAM_DISK_ADDR & 0x0fffffff | 0x80000000);

		ramdisk_create((UINT32)ram_addr, ram_len);

		struct pvr_register_info pvr_reg_info;
		MEMSET(&pvr_reg_info, 0, sizeof(struct pvr_register_info));
		STRCPY(pvr_reg_info.mount_name, "/mnt/rda1");
		pvr_reg_info.disk_usage = PVR_TMS_ONLY_DISK;
		pvr_reg_info.sync = 1;
		pvr_reg_info.init_list = 0;
		pvr_reg_info.check_speed = 0;
		pvr_register((UINT32)&pvr_reg_info, 0);
	}
	else if (sys_data->ram_tms_en == 1 && val == 0) // disable RAM disk timeshift
	{
		ramdisk_delete();
	}

	if (sys_data->ram_tms_en != val)
	{
		if (val == 0) // disable RAM disk timeshift, select PVR partition again
		{
			UINT8 back_saved;
			rec_part[0] = tms_part[0] = 0;
			pvr_select_part(rec_part, tms_part);
			if (rec_part[0] != 0 || tms_part[0] != 0)
			{
				win_compopup_init(WIN_POPUP_TYPE_SMSG); 					   
				win_compopup_set_msg_ext("Init PVR partitions, please wait...", NULL, 0);
				win_compopup_open_ext(&back_saved);
				if (STRCMP(rec_part, tms_part) == 0)
				{
					pvr_change_part(rec_part, PVR_REC_AND_TMS_DISK);
				}
				else
				{
					pvr_change_part(rec_part, PVR_REC_ONLY_DISK);
					pvr_change_part(tms_part, PVR_TMS_ONLY_DISK);
				}
				win_compopup_smsg_restoreback();
			}
		}
		
		struct dvr_HDD_info hdd_info;
		pvr_get_HDD_info(&hdd_info);
		api_pvr_check_level(&hdd_info);
		if (pvr_get_cur_mode(NULL, NULL) == PVR_DISK_INVALID)
		{
			api_pvr_clear_up_all();
		}
	}
	sys_data->ram_tms_en = val;
#endif

    sys_data_save(1);
    
}
Example #8
0
void win_language_right_key(POBJECT_HEAD pObj,UINT8 id)
{
	SYSTEM_DATA* p_sys_data=sys_data_get();
	switch(id)
	{
		case MENU_LANGUAGE_MENU_LAN:
			if(p_sys_data->lang.OSD_lang==(MENU_LANGUAGE_OSD_NUMBER-1))
			{
				p_sys_data->lang.OSD_lang=0;
			}
			else
			{
				p_sys_data->lang.OSD_lang++;
			}
			win_lan_set_menu_lan_string(p_sys_data->lang.OSD_lang);
			sys_data_select_language(p_sys_data->lang.OSD_lang);
			wincom_open_subtitle((POBJECT_HEAD)&win_lan_con,RS_SYSTEM_LANGUAGE, 0);
			OSD_TrackObject((POBJECT_HEAD)&win_lan_con,C_DRAW_SIGN_EVN_FLG| C_UPDATE_ALL);
			break;
		case MENU_LANGUAGE_1ST_AUDIO_LAN:
			if(p_sys_data->lang.Audio_lang_1==(MENU_LANGUAGE_STREAM_NUMBER-1))
			{
				p_sys_data->lang.Audio_lang_1=0;
			}
			else
			{
				p_sys_data->lang.Audio_lang_1++;
			}
			win_lan_set_1st_audio_lan_string(p_sys_data->lang.Audio_lang_1);
			OSD_TrackObject(pObj,C_UPDATE_ALL);
			ap_language_setting(p_sys_data->lang.Audio_lang_1, p_sys_data->lang.Audio_lang_2);
			break;
		case MENU_LANGUAGE_2ND_AUDIO_LAN:
			if(p_sys_data->lang.Audio_lang_2==(MENU_LANGUAGE_STREAM_NUMBER-1))
			{
				p_sys_data->lang.Audio_lang_2=0;
			}
			else
			{
				p_sys_data->lang.Audio_lang_2++;
			}
			win_lan_set_2nd_audio_lan_string(p_sys_data->lang.Audio_lang_2);
			OSD_TrackObject(pObj,C_UPDATE_ALL);
			ap_language_setting(p_sys_data->lang.Audio_lang_1, p_sys_data->lang.Audio_lang_2);
			break;
		case MENU_LANGUAGE_SUB_LAN:
			if(p_sys_data->lang.sub_lang==(MENU_LANGUAGE_STREAM_NUMBER-1))
			{
				p_sys_data->lang.sub_lang=0;
			}
			else
			{
				p_sys_data->lang.sub_lang++;
			}
			win_lan_set_subtitle_lan_string(p_sys_data->lang.sub_lang);
			OSD_TrackObject(pObj,C_UPDATE_ALL);
			break;
		case MENU_LANGUAGE_TXT_LAN:
			if(p_sys_data->lang.ttx_lang==(MENU_LANGUAGE_STREAM_NUMBER-1))
			{
				p_sys_data->lang.ttx_lang=0;
			}
			else
			{
				p_sys_data->lang.ttx_lang++;
			}
			win_lan_set_teletext_lan_string(p_sys_data->lang.ttx_lang);
			OSD_TrackObject(pObj,C_UPDATE_ALL);
			break;
	}
}
Example #9
0
static PRESULT mpvolume_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
	PRESULT ret = PROC_PASS;
	VACTION unact;
	UINT16 vol_pos;
	SYSTEM_DATA *pSys;
	PPROGRESS_BAR  mpvol_bar;
	PPROGRESS_BAR  ban_bar;
	UINT32 msg_code; // construct virtual operation

	mpvol_bar = &mpvolume_bar;
	switch(event)
	{
	   	case EVN_PRE_OPEN:
			pSys = sys_data_get();	
			if(pSys->volume > 0 && GetMuteState() )
				SetMuteOnOff(TRUE);
			vol_pos = mp_vol_to_pos(pSys->volume);
			OSD_SetProgressBarValue(mpvol_bar,vol_pos);
			MPVOLUME_TIMER_TIME = pSys->osd_set.time_out;
			if(MPVOLUME_TIMER_TIME == 0 || MPVOLUME_TIMER_TIME>10)
				MPVOLUME_TIMER_TIME = 5;
			MPVOLUME_TIMER_TIME *= 1000;		
			break;
		case EVN_POST_OPEN:
			mpvolume_timer = api_start_timer("mpvol",MPVOLUME_TIMER_TIME,mpvolume_timer_func);
			break;
		case EVN_POST_CLOSE:
			api_stop_timer(&mpvolume_timer);		
			break;
		case EVN_UNKNOWN_ACTION:
			unact = (VACTION)(param1>>16);
			switch(unact)
			{
			case VACT_VOL_UP:
			case VACT_VOL_DOWN:
				pSys = sys_data_get();	
				vol_pos = mp_vol_to_pos(pSys->volume);
				if(unact == VACT_VOL_DOWN)
					vol_pos--;
				else if(unact == VACT_VOL_UP)
					vol_pos++;
				OSD_SetProgressBarValue(mpvol_bar,vol_pos);
				pSys->volume = mp_pos_to_vol(OSD_GetProgressBarPos(mpvol_bar));
				if(pSys->volume > 0 && GetMuteState() )
					SetMuteOnOff(TRUE);
				api_audio_set_volume(pSys->volume);
				OSD_DrawObject((POBJECT_HEAD)mpvol_bar,C_UPDATE_ALL);	
				api_stop_timer(&mpvolume_timer);		 
				mpvolume_timer = api_start_timer("mpvol",MPVOLUME_TIMER_TIME,mpvolume_timer_func);
				break;
			case VACT_BALANCE_L:
			case VACT_BALANCE_R:
				break;
			default:
				break;
			}
			break;
		default:
			break;
	}
		
	return ret;
}
Example #10
0
static PRESULT pvr_setting_con_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
	PRESULT ret = PROC_PASS;
	UINT8	unact;
	UINT32 i;
	BOOL subt_flag;
	CONTAINER* cont = (CONTAINER*)pObj;
	UINT8	id = OSD_GetObjID(pObj);
	static UINT8 preval;
	SYSTEM_DATA* p_sys_data;
	
	switch(event)
	{
		case EVN_PRE_OPEN:
			wincom_open_title((POBJECT_HEAD)&win_osdset_con, RS_PVR_SETTING, 0);
			p_sys_data=sys_data_get();
			win_pvr_setting_timeshift_set_string(p_sys_data->timeshift);
			win_pvr_setting_jumpstep_set_string(p_sys_data->jumpstep);
			win_pvr_setting_scramble_record_mode_set_string(p_sys_data->scramble_record_mode);
            remove_menu_item((POBJECT_HEAD)&g_win_pvr_setting, (OBJECT_HEAD *)&pvr_setting_item_con3, CON_H + CON_GAP);
			win_pvr_setting_ts_file_size_set_string(p_sys_data->record_ts_file_size);
			remove_menu_item((POBJECT_HEAD)&g_win_pvr_setting, (OBJECT_HEAD *)&pvr_setting_item_con4, CON_H + CON_GAP);
			win_pvr_setting_tms2rec_set_string(p_sys_data->tms2rec);			
			win_pvr_setting_ttx_subt_set_string(p_sys_data->record_ttx_subt);
			remove_menu_item((POBJECT_HEAD)&g_win_pvr_setting, (OBJECT_HEAD *)&pvr_setting_item_con6, CON_H + CON_GAP);
			win_pvr_setting_rec_num_set_string(p_sys_data->rec_num);
			remove_menu_item((POBJECT_HEAD)&g_win_pvr_setting, (OBJECT_HEAD *)&pvr_setting_item_con7, CON_H + CON_GAP);
#ifdef NEW_DEMO_FRAME
			win_pvr_setting_record_ps_set_string(p_sys_data->rec_ps_enable);
#else
			remove_menu_item((POBJECT_HEAD)&g_win_pvr_setting, (OBJECT_HEAD *)&pvr_setting_item_con8, CON_H + CON_GAP);
#endif
			break;
		case EVN_POST_OPEN:
			break;			
		case EVN_PRE_CLOSE:
       		*((UINT32 *)param2) &= ~C_CLOSE_CLRBACK_FLG;
			p_sys_data=sys_data_get();
			sys_data_save(1);
#ifndef PVR3_SUPPORT
			pvr_r_set_ts_file_size(p_sys_data->record_ts_file_size + 1);
#endif
			//api_pvr_jumpstep_trans();
			break;
		case EVN_POST_CLOSE:
			break;
        case EVN_UNKNOWN_ACTION:
            if (api_pvr_is_record_active())
                break;
            
            win_popup_choice_t choice;
            UINT8 back_saved;

            win_compopup_init(WIN_POPUP_TYPE_OKNO);
            win_compopup_set_msg("Record CA program in descrambled format?", NULL, 0);
            if (sys_data_get_scramble_record_mode())
                win_compopup_set_default_choice(WIN_POP_CHOICE_YES);
            else
                win_compopup_set_default_choice(WIN_POP_CHOICE_NO);
            choice = win_compopup_open_ext(&back_saved);
            if (choice == WIN_POP_CHOICE_YES)
            {
                sys_data_set_scramble_record_mode(1);
                pvr_r_set_scramble_ext(0);
            }
            else if (choice == WIN_POP_CHOICE_NO)
            {
                sys_data_set_scramble_record_mode(0);
                pvr_r_set_scramble_ext(1);
            }
            break;
	}
	
	return ret;
}
Example #11
0
static PRESULT win_volume_bar_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
	PRESULT ret = PROC_PASS;
	PROGRESS_BAR* bar;	
	SYSTEM_DATA* sys_data;
	UINT32 vkey;
	static int  m=0;
	VACTION unact;
	
	bar = (PROGRESS_BAR*)pObj;
	
	sys_data = sys_data_get();	

	switch(event)
	{
	case EVN_PRE_CHANGE:
		unact = (VACTION)(param1>>16);
		if(unact==VACT_DECREASE)
			volume_flag = 0;
		else if(unact==VACT_INCREASE)
			volume_flag = 1;
		if(key_cnt==1)
			i=0;
		m=sys_data->volume = OSD_GetProgressBarPos(bar);
		if(sys_data->volume > 0 && GetMuteState() )
		{
			SetMuteOnOff(TRUE);
			restore_mute_bg();
		}
		if(key_cnt > 1)
		{
			 if(volume_flag)
			 {
			   	sys_data->volume = sys_data->volume +2*(++i);
			 }
			 else 
			 {
			       
			   	m = sys_data->volume -2*(++i);
				if(m<=0)
				{
					m=0;
				}
				sys_data->volume = m;
			 }
			 
		}
		if(sys_data->volume>=100)
		{
			sys_data->volume=100;
		}
		api_audio_set_volume(sys_data->volume);
		OSD_SetProgressBarPos(bar, sys_data->volume);
		break;
	case EVN_POST_CHANGE:
		api_stop_timer(&volume_timer);		 
		volume_timer = api_start_timer(VOLUME_TIMER_NAME,VOLUME_TIMER_TIME,volume_timer_func);
		ret = PROC_LOOP;
		break;
	case EVN_UNKNOWNKEY_GOT:
		ap_hk_to_vk(0, param1, &vkey);
		if(vkey == V_KEY_NULL)
		{
			ret = PROC_LOOP;
		}
		break;
	default:
		break;
	}

	return ret;		 
}
Example #12
0
void win_pvr_setting_right_key(POBJECT_HEAD pObj,UINT8 id)
{
	SYSTEM_DATA* p_sys_data=sys_data_get();
	UINT8 input;
	struct dvr_HDD_info hdd_info;	
	
	switch(id)
	{
		case MENU_PVR_SETTING_TIMESHIFT:
			sys_data_set_tms(!sys_data_get_tms());
			win_pvr_setting_timeshift_set_string(sys_data_get_tms());
			OSD_TrackObject(pObj,C_UPDATE_ALL);
			if (sys_data_get_tms())
			{
				api_pvr_adjust_tms_space();
				if (pvr_get_HDD_info(&hdd_info) && (hdd_info.tms_size == 0))
				{
					pvr_set_tms_size(hdd_info.free_size); // set free space to tms
					pvr_get_HDD_info(&hdd_info);
				}
			}
			else
			{
				pvr_set_tms_size(0);
				pvr_get_HDD_info(&hdd_info);
			}
			api_pvr_check_level(&hdd_info);
			break;
		case MENU_PVR_SETTING_JUMP:
			input = sys_data_get_jumpstep();	
			input = (input+1)%5;
			sys_data_set_jumpstep(input);
			win_pvr_setting_jumpstep_set_string(input);
			OSD_TrackObject(pObj,C_UPDATE_ALL);
			break;
		case MENU_PVR_SETTING_SCRAMBLE_MODE:
			input = sys_data_get_scramble_record_mode();	
			input = !input;
			sys_data_set_scramble_record_mode(input);
			pvr_r_set_scramble_ext(!input);
			win_pvr_setting_scramble_record_mode_set_string(input);
			OSD_TrackObject(pObj,C_UPDATE_ALL);
			break;
		case MENU_PVR_SETTING_TS_FILE_SIZE:
			input = sys_data_get_record_ts_file_size();	
			input = (input+1)%4;
			sys_data_set_record_ts_file_size(input);
			win_pvr_setting_ts_file_size_set_string(input);
			OSD_TrackObject(pObj,C_UPDATE_ALL);
			break;
		case MENU_PVR_SETTING_TMS_2_REC:
			sys_data_set_tms2rec(!sys_data_get_tms2rec());
			win_pvr_setting_tms2rec_set_string(sys_data_get_tms2rec());
			OSD_TrackObject(pObj,C_UPDATE_ALL);
			break;
		case MENU_PVR_SETTING_TTX_SUBT:
			input = sys_data_get_record_ttx_subt();	
			input = !input;
			sys_data_set_record_ttx_subt(input);
			win_pvr_setting_ttx_subt_set_string(input);
			OSD_TrackObject(pObj,C_UPDATE_ALL);
			break;
		case MENU_PVR_SETTING_REC_NUM:
			sys_data_set_rec_num(3 - sys_data_get_rec_num());
			win_pvr_setting_rec_num_set_string(sys_data_get_rec_num());
			OSD_TrackObject(pObj,C_UPDATE_ALL);
			break;
		case MENU_PVR_SETTING_REC_PS:
			sys_data_set_rec_ps(!sys_data_get_rec_ps());
			win_pvr_setting_record_ps_set_string(sys_data_get_rec_ps());
			OSD_TrackObject(pObj,C_UPDATE_ALL);
			break;
		default:
			break;
	}
}
Example #13
0
static PRESULT catch_up_list_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
	PRESULT ret = PROC_PASS;
	VACTION unact;
	UINT8 back_saved;
	SYSTEM_DATA *p_sys_data = sys_data_get();

	switch(event)
	{
		case EVN_PRE_DRAW:
			catch_up_list_display();
			break;
		case EVN_UNKNOWN_ACTION:
			unact = (VACTION)(param1>>16);

			if (unact == VACT_TIMER)
			{
				
			}
			else if (unact == VACT_WEEK_DECREASE)
			{
				if (cur_weekday == 0)
				{
					cur_weekday = 6;
				}
				else
				{
					cur_weekday--;
				}

				bDownloading = TRUE;
				catch_up_draw_week();
				catch_up_terminate();
				catch_up_download_list(cur_weekday + 1);
				win_compopup_init(WIN_POPUP_TYPE_SMSG);
				win_compopup_set_msg((UINT8*)"Connecting, please wait...",NULL,0);
				win_compopup_open_ext(&back_saved);
			}
			else if (unact == VACT_WEEK_INCREASE)
			{
				if (cur_weekday == 6)
				{
					cur_weekday = 0;
				}
				else
				{
					cur_weekday++;
				}

				bDownloading = TRUE;
				catch_up_draw_week();
				catch_up_terminate();
				catch_up_download_list(cur_weekday + 1);
				win_compopup_init(WIN_POPUP_TYPE_SMSG);
				win_compopup_set_msg((UINT8*)"Connecting, please wait...",NULL,0);
				win_compopup_open_ext(&back_saved);
			}
			break;
		default:
			break;
	}

	return ret;
}
static BOOL win_atnsetm_check_save_motor_antenna_setting(void)
{
	MULTISEL* msel;
	EDIT_FIELD* edf;
	UINT32 longitute,latitute;
	SYSTEM_DATA* sys_data;
	antenna_t	*pAntenna,*pAntenna2;
	Usals_Local* pLocal;
	INT32 val = 0;
	UINT32 lnb_type,lnb_freq1,lnb_freq2;

	
	sys_data = sys_data_get();
	pAntenna = &sys_data->tuner_lnb_antenna[antset_cur_tuner];
	pLocal	= &sys_data->local;
		

	/* Local longitute */
	edf = anesetm_edfs[0];
	OSD_GetEditFieldIntValue(edf,&longitute);

	/* Local latitute */
	edf = anesetm_edfs[1];
	OSD_GetEditFieldIntValue(edf,&latitute);

	/* LNB type */
	msel = anesetm_msels[LNB_ID - 1];
	val = msel->nSel;
	get_lnb_type_setting(val,&lnb_type,&lnb_freq1,&lnb_freq2);
	pAntenna->lnb_type = lnb_type;
	pAntenna->lnb_low 	= lnb_freq1;
	pAntenna->lnb_high = lnb_freq2;	

	/* Motor type */
	msel = anesetm_msels[MOTOR_ID - 1];
	if(msel->nSel == 0)
		pAntenna->motor_type = LNB_MOTOR_DISEQC12;
	else
		pAntenna->motor_type = LNB_MOTOR_USAL;

	if(pAntenna->motor_type == LNB_MOTOR_USAL)
	{
		if(longitute>18000 || latitute>9000)
			return FALSE;
		
		pLocal->local_longitude = longitute;
		if(longitute_sub_idx == 1)
			pLocal->local_longitude |= 0x8000;
		
		pLocal->local_latitude = latitute;
		if(latitute_sub_idx == 1)
			pLocal->local_latitude |= 0x8000;
	}

#ifdef SUPPORT_TWO_TUNER
	if(sys_data->antenna_connect_type == ANTENNA_CONNECT_DUAL_SAME)
	{
		if(antset_cur_tuner == 0)
			pAntenna2 = &sys_data->tuner_lnb_antenna[1];
		else
			pAntenna2 = &sys_data->tuner_lnb_antenna[0];

		pAntenna2->motor_type = pAntenna->motor_type;
		
		pAntenna2->lnb_type = pAntenna->lnb_type;
		pAntenna2->lnb_low 	= pAntenna->lnb_low;
		pAntenna2->lnb_high = pAntenna->lnb_high;
	}	
#endif	

	set_chchg_local_postion();

	return TRUE;
}
Example #15
0
static PRESULT mpegYP_player_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
	PRESULT ret = PROC_PASS;
	VACTION unact;
	SYSTEM_DATA* sys_data;

	sys_data = sys_data_get();
	
	switch (event)
	{
		case EVN_PRE_OPEN:
			MPEGYPBAR_TIMER_TIME = sys_data->osd_set.time_out;
			if(MPEGYPBAR_TIMER_TIME == 0 || MPEGYPBAR_TIMER_TIME>10)
				MPEGYPBAR_TIMER_TIME = 5;
			MPEGYPBAR_TIMER_TIME *= 1000;
			if (!m_mpegYP_player_working)
			{
				entry_youporn = ((player_param*)param2)->handle;
				url_youporn = ((player_param*)param2)->url;
				MPEGYP_player_init();
			}
			else
			{
				ret = PROC_LOOP;
			}
			m_mpegYP_player_working = TRUE;
			break;
		case EVN_POST_OPEN:
			mpegYP_timeout_id = api_start_timer(MPEGYPBAR_TIMER_NAME, MPEGYPBAR_TIMER_TIME, mpegYP_timeout_handler);
			break;
		case EVN_POST_DRAW:
			win_mpegYP_player_draw_infor();
			break;
		case EVN_PRE_CLOSE:
			libnet_download_abort(g_strf_cur_dl_rsrc);
			mpg_cmd_stop_proc();
			api_stop_timer(&mpegYP_refresh_id);
			api_stop_timer(&mpegYP_timeout_id);
			m_mpegYP_player_working = FALSE;
			g_from_mpegYPplayer = TRUE;
			s_ypvideo_seektime = 0;
			break;
		case EVN_UNKNOWN_ACTION:
			api_stop_timer(&mpegYP_timeout_id);
			unact = (VACTION)(param1>>16);
      //add on 2011-09-28 for BUG42869
			//if(!b_vdec_support &&  !b_audio_yp_support)
			//	MPEGYPInfo.TotalTime = 0;       
			//else
//				MPEGYPInfo.TotalTime = MPGGetTotalPlayTime() + s_ypvideo_seektime;
				MPEGYPInfo.TotalTime = yplstitm_get_duration(entry_youporn);
			switch (unact)
			{
				case VACT_MUTE:
				{
					SetMuteOnOff(TRUE);
					ret = PROC_LOOP;
					break;
				}
				
				default :
				{
					ret = win_mpegYP_player_key_proc(pObj, (param1 & 0xFFFF), param2);
					if (ret != PROC_LEAVE)
					{
						if( ((param1 & 0xFFFF) != V_KEY_EXIT) && ((param1 & 0xFFFF) != V_KEY_MENU)
							&& ((param1 & 0xFFFF) != V_KEY_PVR_INFO) && ((param1 & 0xFFFF) != V_KEY_LEFT) && ((param1 & 0xFFFF) != V_KEY_RIGHT))
						{
							win_mpegYP_player_draw(TRUE);
						}
					}
					break;
				}
			}
			mpegYP_timeout_id = api_start_timer(MPEGYPBAR_TIMER_NAME, MPEGYPBAR_TIMER_TIME, mpegYP_timeout_handler);
			break;
		case EVN_UNKNOWNKEY_GOT:
			break;
		case EVN_MSG_GOT:
			ret = win_mpegYP_player_message_proc(pObj, param1, param2);
			break;
	}

	return ret;
}
Example #16
0
static PRESULT slide_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
	PRESULT ret = PROC_PASS;
	UINT16 slide_interval;
	PlayListLoopType loop_type;
    struct osd_device *osd_dev;
    struct OSDRect pRect;
   	struct OSDPara OpenPara;    
    UINT32 region_id =0;

	VACTION unact;
	FileInfo file_node;
	char image_name[FULL_PATH_SIZE];
	int next_image;
	static UINT8 timer_start_flag = 0;
	UINT32 file_idx;
	SYSTEM_DATA *sys_cfg = sys_data_get();

	switch(event)
	{
    case EVN_PRE_OPEN:
		imageslide_timer_id = OSAL_INVALID_ID;
		imageslide_proc_id = OSAL_INVALID_ID;

		if(from_imagepreview == TRUE)
		{
			imageslide_pause_state = IMG_PAUSE_STATE;
		}
		else
		{
			imageslide_pause_state = IMG_UNPAUSE_STATE;
		}
		win_imageslide_showpause();
		api_set_preview_vpo_color(FALSE);
		vpo_aspect_mode((struct vpo_device *)dev_get_by_id(HLD_DEV_TYPE_DIS,0), TV_4_3, NORMAL_SCALE);
#ifdef DUAL_VIDEO_OUTPUT
		vpo_aspect_mode((struct vpo_device *)dev_get_by_id(HLD_DEV_TYPE_DIS,1), TV_4_3, NORMAL_SCALE);
#endif
		break;
    case EVN_POST_OPEN:
		image_rot_ang = ANG_ORI;
		
		loop_type = image_slide_setting.bRepeat ? PLAY_LIST_REPEAT : PlAY_LIST_SEQUENCE;
		set_play_list_info(cur_playlist_image,&cur_image_idx,&loop_type);

		get_file_from_play_list(cur_playlist_image, cur_image_idx, &file_node);
		win_get_fullname(image_name, file_node.path, file_node.name);
//        while(jpeg_decoder_task_not_over)
//        {
//            libc_printf("error condition!\n");
//            osal_task_sleep(20);
//        }
        image_abort();
        timer_slide = osal_get_tick();
		win_image_file_play(image_name, image_rot_ang);
		slideidx_display(TRUE);
		decode_finish_flag = FALSE;        
        break;
	case EVN_UNKNOWN_ACTION:
		unact = (VACTION)(param1>>16);
		ret = win_imageslide_unkown_act_proc(unact);
		break;
	case EVN_PRE_CLOSE:
		g_from_imageslide = TRUE;
		imagedec_ioctl(1, IMAGEDEC_IO_CMD_CLEAN_FRM, TRUE);	//when quit win_slide, clean 2 frm buffer
		
		if(image_folderloop_flag == 1)//filelist
		{
			get_file_from_play_list(cur_playlist_image, cur_image_idx, &file_node);
			win_get_fullname(image_name, file_node.path, file_node.name);
			usblist_set_filelist_param(image_name);
		}
		image_abort();
///*
#ifdef  DUAL_ENABLE
#ifdef  PNG_GIF_TEST  

        pRect.uLeft =136;
	    pRect.uTop = 40;
	    pRect.uWidth = 1008;//OSD_MAX_WIDTH;//608;
	    pRect.uHeight = 640;//OSD_MAX_HEIGHT;//430;	
    
        OpenPara.eMode = OSD_HD_ARGB1555;
        OpenPara.uGAlpha = 0x0f;
        OpenPara.uGAlphaEnable = 0;
        OpenPara.uPalletteSel = 0;
        osd_dev = (struct osd_device *)dev_get_by_id(HLD_DEV_TYPE_OSD, 0);
        if (osd_dev != NULL)
	    {		
            OSDDrv_Close((HANDLE)osd_dev);
            //AD_GIF_PRINTF("%s() OSD_layer2 is closed!\n", __FUNCTION__);
        }
        OSDDrv_Open((HANDLE)osd_dev, &OpenPara);
        osal_task_sleep(20);
        //trans_color = OSD_GetTransColor(OpenPara.eMode,TRUE);
	    OSDDrv_IoCtl((HANDLE)osd_dev, OSD_IO_SET_TRANS_COLOR, 0x00);
	    OSDDrv_CreateRegion((HANDLE)osd_dev, region_id, &pRect, NULL);
        pRect.uLeft = pRect.uTop = 0;
        OSDDrv_RegionFill((HANDLE)osd_dev,region_id,&pRect,0x00);   
        OSDDrv_ShowOnOff((HANDLE)osd_dev, TRUE); 
            
#endif            
#endif
//*/        
		api_stop_timer(&imageslide_timer_id);
		api_stop_timer(&imageslide_proc_id);
        timer_start_flag = 0;
		imageslide_timer_id = OSAL_INVALID_ID;
		imageslide_proc_id = OSAL_INVALID_ID;
		win_set_image_multiview_firstidx();
		sys_cfg = sys_data_get();
		sys_data_set_display_mode(&(sys_cfg->avset));

		OSD_ClearObject((POBJECT_HEAD)&imageslide_idx,C_UPDATE_ALL);
		OSD_ClearObject((POBJECT_HEAD)&imageslide_pause,C_UPDATE_ALL);
		OSD_ClearObject((POBJECT_HEAD)&decode_txt_progress,C_UPDATE_ALL);
		OSD_ClearObject((POBJECT_HEAD)&decode_bmp_progress,C_UPDATE_ALL);
		break;
	case EVN_POST_CLOSE:
		image_restore_vpo_rect();//TODO
		break;
	case EVN_MSG_GOT:
        if(param1 == CTRL_MSG_SUBTYPE_CMD_STO && param2 == USB_STATUS_OVER)
        {
			//storage_dev_mount_hint(1);
			file_list_check_storage_device(FALSE, FALSE);
        }
		else if(param1 == CTRL_MSG_SUBTYPE_STATUS_IMAGEOVER)
		{
            if(param2 > timer_slide)
            {
    			image_abort();
            }
            else
            {
                libc_printf("slide @@@@@@@@@@@@@@ es case\n");
                break;
            }
			decode_finish_flag = TRUE;
			if(imageslide_pause_state == IMG_UNPAUSE_STATE)
		    {
				slide_interval = (image_slide_setting.uTime_gap * 1000);
				if(0 != slide_interval)
					imageslide_timer_id = api_start_timer("IMAGESLIDE",slide_interval,win_imageslide_handler);
				else
				{
					imageslide_pause_state = IMG_PAUSE_STATE;
					win_imageslide_showpause();
				}
			}
		}
		else if (param1 == CTRL_MSG_SUBTYPE_STATUS_IMGTOOVER) // timer timeouts
		{
			//TODO: play next
			
//            while(jpeg_decoder_task_not_over)
//            {
//                libc_printf("\n%%%%%%%%%%%%%%%%%%%%%%%%%\n");
//                osal_task_sleep(20);
//            }
			image_abort();
			next_image = get_next_index_from_play_list(cur_playlist_image);
			
			if (next_image != -1)
			{
				cur_image_idx = next_image;
				set_play_list_info(cur_playlist_image,&cur_image_idx,NULL);
				get_file_from_play_list(cur_playlist_image, cur_image_idx, &file_node);
				win_get_fullname(image_name, file_node.path, file_node.name);
				win_image_file_play(image_name, image_rot_ang);
				decode_finish_flag = FALSE;
				ap_send_msg(CTRL_MSG_SUBTYPE_CMD_UPDATE_VIEW, 0, TRUE);
			}
			else
			{
				ap_send_msg(CTRL_MSG_SUBTYPE_CMD_EXIT, 0,TRUE);
			}
		}
		else if(param1 == CTRL_MSG_SUBTYPE_CMD_EXIT)
		{
			if(from_imagepreview == TRUE)
				back_to_filelist = TRUE;
			ret = PROC_LEAVE;
		}
		else if(param1 == CTRL_MSG_SUBTYPE_CMD_UPDATE_VIEW)
		{
			slideidx_display(TRUE);
			ret = PROC_LOOP;
		}
		else if(param1 == CTRL_MSG_SUBTYPE_STATUS_MP3OVER)
		{
			win_play_next_music_ex();
		}
		else if(param1 == CTRL_MSG_SUBTYPE_STATUS_PROC_UPDATE)
		{
			OSD_SetBitmapContent(&decode_bmp_progress, loading_bmp_ids[proc_cnt]);
			OSD_DrawObject((POBJECT_HEAD)&decode_bmp_progress,C_UPDATE_ALL);
			proc_cnt ++;
			if(proc_cnt >= LOADING_MAX)
				proc_cnt = 0;
		}		
		
		if ((param1 == CTRL_MSG_SUBTYPE_STATUS_JPEG_DEC_PROCESS) || (param1 == CTRL_MSG_SUBTYPE_STATUS_IMAGEOVER))
		{
			if ((param2 < 100) && (param1 == CTRL_MSG_SUBTYPE_STATUS_JPEG_DEC_PROCESS))
			{
				loading_progress = (param2 * LOADING_MAX)/100;
				if (loading_progress > LOADING_MAX - 1)
					loading_progress = LOADING_MAX - 1;

				if(0 == timer_start_flag)
				{
					imageslide_proc_id = OSAL_INVALID_ID;
					imageslide_proc_id = api_start_cycletimer("SLIDE_PROC", 200, win_imageslide_proc_handler);
					timer_start_flag = 1;
				}
			//	OSD_SetBitmapContent(&decode_bmp_progress, loading_bmp_ids[loading_progress]);
			//	OSD_DrawObject((POBJECT_HEAD)&decode_bmp_progress,C_UPDATE_ALL);
			}
			else if((param2 >= 100) || (param1 == CTRL_MSG_SUBTYPE_STATUS_IMAGEOVER))
			{
				OSD_ClearObject((POBJECT_HEAD)&decode_bmp_progress,C_UPDATE_ALL);
				api_stop_timer(&imageslide_proc_id);
				imageslide_proc_id = OSAL_INVALID_ID;
				timer_start_flag = 0;
				proc_cnt = 0;
			//	imageslide_proc_id = OSAL_INVALID_ID;
			}
		}
		break;
	default:
		break;
	}

	return ret;
}
Example #17
0
static PRESULT win_mpegYP_player_message_proc(POBJECT_HEAD pObj, UINT32 msg_type, UINT32 msg_code)
{
	PRESULT ret = PROC_LOOP;
	struct VDec_StatusInfo vdec_status;

	switch (msg_type)
	{
		case CTRL_MSG_SUBTYPE_CMD_STO:
			if(msg_code == USB_STATUS_OVER)
				do{}while(0);
			break;

	case CTRL_MSG_SUBTYPE_CMD_TIMEDISPLAYUPDATE:
    		//add on 2011-09-28 fixBUG42869
		//if(!b_vdec_support && !b_audio_yp_support)
		//{	
		//	StopProc();
		//	break;
		//}
		MPEGYPInfo.PlayTime = (UINT32)MPGFileDecoderGetPlayTime() + s_ypvideo_seektime;
		if(MPEGYPInfo.PlayTime >= MPEGYPInfo.TotalTime)
        {
		    BarState.nPos = MPEGYPInfo.TotalTime - 1;
			}
			else
            BarState.nPos = MPEGYPInfo.PlayTime;
        
		if (!m_HideWindow)
		{
			win_mpegYP_player_draw(TRUE);
		}
		break;
	case CTRL_MSG_SUBTYPE_STATUS_VIDEO_OVER: //video over
		#if 0
		vdec_io_control(dev_get_by_id(HLD_DEV_TYPE_DECV, 0), VDEC_IO_GET_STATUS, (UINT32)(&vdec_status));
		if(MPEG_FB != MPEGYPInfo.PlayState && MPEG_SB != MPEGYPInfo.PlayState && vdec_status.api_play_direction == VDEC_FORWARD)
	    {
    	    if((filelist_get_current_classifiedfile_count(MP_VIDEO)+1)<mpegYPlist_cnt)
    	    {
        	    mpegYPlist_idx = filelist_get_next_classifiedfile_index(MP_VIDEO, mpegYPlist_idx);
    	    }
			else
    	    {
                mpegYPlist_idx = (UINT16)(~0);
    	    }
	    }
        if(mpegYPlist_idx != (UINT16)(~0))
        {
				if(vdec_status.api_play_direction == VDEC_FORWARD)
				{
					libnet_download_abort(g_strf_cur_dl_rsrc);
					mpg_cmd_stop_proc();
				}
				MPEGYPInfo.PlayState = MPEG_STOP;
				api_stop_timer(&mpegYP_refresh_id);
				m_mpegYP_player_working = FALSE;
				MPEGYP_player_init();
				m_mpegYP_player_working = TRUE;
			}
			else
		    ret = PROC_LEAVE;
		#else
		if(MPEGYPInfo.PlayState == MPEG_FB)
		{
			MPEGYPInfo.PlayState = MPEG_STOP;
			PlayProc_yp();
		}
		else
		{
			ret = PROC_LEAVE;
		}
		#endif
		break;
	case CTRL_MSG_SUBTYPE_STATUS_TIMEOUT:	//mpegYP player display timer out
		if (!m_HideWindow)
		{
			win_mpegYP_player_draw(FALSE);
			if (BarState.State == CURSOR_MOVING)
			{
				SyncBarPosAndCursor(POS_TO_CUR);
			}
		}
		else
		{
			if (m_bSetVol_YP)//if the volume bar is showing
			{
				//ShowVolumeBar(FALSE);//Close the volume bar
			}
		}
		break;
	case CTRL_MSG_SUBTYPE_STATUS_VIDEO_DEC_ERR:
    	case CTRL_MSG_SUBTYPE_STATUS_PARSE_END:
    		s_is_in_parsing = 0;
           //	mpegYP_refresh_cnt = 0;
            MPEGYPInfo.TotalTime = get_video_total_time() + s_ypvideo_seektime;
            BarState.nRange = MPEGYPInfo.TotalTime;
           mpegYP_file_prompt(NULL, FALSE);
            //mpegYP_unsupport_detect(msg_code);
    #ifdef AV_DELAY_SUPPORT
			if(b_vdec_support && b_audio_yp_support)
			{
				SYSTEM_DATA *psys_data = sys_data_get();
	            if(psys_data->avset.avdelay_value > 500)
				    MpgSetAVSyncDelay(1, psys_data->avset.avdelay_value-500); //0:video; 1:audio.
	            else if(psys_data->avset.avdelay_value > 0 && psys_data->avset.avdelay_value < 500)
				    MpgSetAVSyncDelay(0, psys_data->avset.avdelay_value); //0:video; 1:audio.
			}
 	#endif		
    		break;
	}

	return ret;
}
Example #18
0
static PRESULT favgrplst_list_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
	PRESULT ret = PROC_PASS;
	VACTION unact;
	UINT16 uni_name[30];
	UINT8* new_name;
	OBJLIST* ol;
	UINT16 curitem;
    SYSTEM_DATA* sys_data = sys_data_get();

	ol = &favgrplist_olist;
	curitem = OSD_GetObjListNewPoint(ol);

	switch(event)
	{
	case EVN_PRE_DRAW:
		{
			POBJECT_HEAD focusObj=OSD_GetFocusObject(pObj);
			
			win_favgrplst_set_display();

#if ((!defined(OSD_15))&&(!defined(OSD_12)))
#ifdef PREVIEW_SUBMENU
			if(preview_menu)
			{
				preview_menu=0;
				OSD_SetWholeObjStyleHL(focusObj,CON_SH_IDX,TXTN_SH_IDX,0,0);
			}
			else
			{
				OSD_SetWholeObjStyleHL(focusObj,CON_SH_IDX,TXTN_HL_IDX,0,0);
			}
#endif
#endif

		}break;
	
	case EVN_UNKNOWN_ACTION:
		unact = (VACTION)(param1>>16);
		if(unact== VACT_FAV_EDIT)
		{
			//ComAscStr2Uni(sys_data->favgrp_names[curitem], uni_name);
			MEMCPY(uni_name,(UINT16*)sys_data->favgrp_names[curitem],(FAV_GRP_NAME_LEN + 1));
#ifndef KEYBOARD_SUPPORT
			if(win_rename_open(uni_name,&new_name,favgrp_check_input_name))
#else
#if (defined(GZ1105002)||defined(GZ1105003)||defined(GZ1105004)||defined(GZ1105005)||defined(GZ1105006))	
			if(win_rename_open(uni_name,&new_name,favgrp_check_input_name))
#else
			if(win_keyboard_rename_open(uni_name,&new_name,favgrp_check_input_name))
#endif	
#endif
			{
				//ComUniStrToAsc(new_name,sys_data->favgrp_names[curitem]);
				ComUniStrCopyChar(sys_data->favgrp_names[curitem],new_name);
			}
			OSD_TrackObject((POBJECT_HEAD)&g_win_favgrplst, C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);
		//	wincom_open_title(pObj,RS_FAVORITE,0);
			wincom_open_subtitle(pObj,RS_FAVORITE,0);
		}
		break;
	}

	return ret;
}
Example #19
0
static void win_miscset_load_setting(void)
{
	CONTAINER	*win,*scditem,*lastitem;
	MULTISEL	*msel;
	TEXT_FIELD *pTxt;
	SYSTEM_DATA* sys_data;
	POBJECT_HEAD pObj;
	BOOL beeper_flag,lnb_power_flag,chchg_video_flag;
	

	sys_data = sys_data_get();
	/* LNB Power */
	msel =&miscset_sel0;
	OSD_SetMultiselSel(msel, sys_data->bLNB_power);

	/* Change change channel type */
	if(sys_data->chan_sw>=3)
		sys_data->chan_sw = 0;
	msel =&miscset_sel1;
	OSD_SetMultiselSel(msel, sys_data->chan_sw);

	/* Change change video type */
	msel =&miscset_sel2;
	OSD_SetMultiselSel(msel, sys_data->chchgvideo_type);

	/* Beep */
	msel =&miscset_sel3;
	OSD_SetMultiselSel(msel, sys_data->install_beep);

    
    win = &g_win_misc_setting;    
#if( SYS_LNB_POWER_OFF ==  SYS_FUNC_ON)
	lnb_power_flag = TRUE;
#else
	lnb_power_flag = FALSE;
#endif

#ifdef CHANCHG_VIDEOTYPE_SUPPORT
	chchg_video_flag = TRUE;
#else
	chchg_video_flag = FALSE;
#endif

#ifdef ANTENNA_INSTALL_BEEP
	beeper_flag = TRUE;
#else
	beeper_flag = FALSE;
#endif

	if(!lnb_power_flag)
		remove_menu_item(win, (OBJECT_HEAD *)misc_menu_items[LNBPOWER_ID - 1], CON_H + CON_GAP);
	if(!chchg_video_flag)
		remove_menu_item(win, (OBJECT_HEAD *)misc_menu_items[CHANCHG_VIDEO_ID - 1], CON_H + CON_GAP);  
    if(!beeper_flag)
        remove_menu_item(win, (OBJECT_HEAD *)misc_menu_items[INSTALLBEEP_ID - 1], CON_H + CON_GAP);

#ifndef RAM_TMS_TEST
    remove_menu_item(win, (OBJECT_HEAD *)&miscset_item5, CON_H + CON_GAP);
#endif

#if !defined(AUTOMATIC_STANDBY)
    remove_menu_item(win,(POBJECT_HEAD)&miscset_item3,CON_H + CON_GAP);
#endif

    remove_menu_item(win,(POBJECT_HEAD)&miscset_item0,CON_H + CON_GAP);
    remove_menu_item(win,(POBJECT_HEAD)&miscset_item1,CON_H + CON_GAP);

    /*Disable/Endable auto standby*/
    msel = &miscset_sel4;
    pTxt = &miscset_txt4;
    OSD_SetMultiselSel(msel,sys_data->auto_standby_en);
    OSD_SetTextFieldStrPoint(pTxt,display_strs[1]);
//    OSD_SetTextFieldContent(pTxt,STRING_ANSI,(UINT32)"Auto Standby");

    OSD_SetTextFieldContent(pTxt, STRING_UNICODE,(UINT32)OSD_GetUnicodeString(RS_AUTO_STANDBY));
    
	/* Disable/Endable ram timeshift */
#ifdef RAM_TMS_TEST
    msel = &miscset_sel5;
    pTxt = &miscset_txt5;
    OSD_SetMultiselSel(msel,sys_data->ram_tms_en);
    OSD_SetTextFieldStrPoint(pTxt,display_strs[2]);
    OSD_SetTextFieldContent(pTxt,STRING_ANSI,(UINT32)"RAM Timeshift");
#endif

#ifdef ORDER_GZ1207009
    msel = &miscset_sel6;
    pTxt = &miscset_txt6;
    OSD_SetMultiselSel(msel,sys_data->standbymode);
    OSD_SetTextFieldStrPoint(pTxt,display_strs[3]);
//    OSD_SetTextFieldContent(pTxt,STRING_ANSI,(UINT32)"Auto Standby");

    OSD_SetTextFieldContent(pTxt, STRING_UNICODE,(UINT32)OSD_GetUnicodeString(RS_STANDBY_MODE));
  

#endif
}
Example #20
0
PRESULT comlist_tvsys_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
	UINT16 i,wTop;
	UINT8 id;
	char str_len;
	OBJLIST* ol;
	UINT8 temp[4];
	SYSTEM_DATA* p_sys_data=sys_data_get();
	
	PRESULT cbRet = PROC_PASS;

	ol = (OBJLIST*)pObj;
	
	if(event==EVN_PRE_DRAW)
	{
		id=OSD_GetFocusID((POBJECT_HEAD)&win_av_con);
		switch(id)
		{
		case TVMODE_ID:
	    	wTop = OSD_GetObjListTop(ol);
	    	for(i=0;i<ol->wDep && (i+wTop)<ol->wCount;i++)
	    	{
				win_comlist_set_str(i + wTop,get_tv_mode_string(i+wTop),NULL,0);
	    	}
			break;
		case TVASPECT_ID:
	    	wTop = OSD_GetObjListTop(ol);
	    	for(i=0;i<ol->wDep && (i+wTop)<ol->wCount;i++)
	    	{
				win_comlist_set_str(i + wTop,tv_ratio[i+wTop],NULL,0);
	    	}
			break;
		case RFSYSTEM_ID:
	    	wTop = OSD_GetObjListTop(ol);
	    	for(i=0;i<ol->wDep && (i+wTop)<ol->wCount;i++)
	    	{
				win_comlist_set_str(i + wTop,rf_mode_stings[i+wTop],NULL,0);
	    	}
			break;
		case RFCHAN_ID:
	    	wTop = OSD_GetObjListTop(ol);
	    	for(i=0;i<ol->wDep && (i+wTop)<ol->wCount;i++)
	    	{
				sprintf(temp,"%d", i+wTop+rf_ch_range[p_sys_data->avset.rf_mode][0]);
				win_comlist_set_str(i + wTop,temp,NULL,0);
	    	}
			break;
#ifdef HDTV_SUPPORT
		case HDMIOUT_ID:
	    	wTop = OSD_GetObjListTop(ol);
	    	for(i=0;i<ol->wDep && (i+wTop)<ol->wCount;i++)
	    	{
				win_comlist_set_str(i + wTop,format_setting[i+wTop],NULL,0);
	    	}
			break;
		case AUDIOOUT_ID:
	    	wTop = OSD_GetObjListTop(ol);
	    	for(i=0;i<ol->wDep && (i+wTop)<ol->wCount;i++)
	    	{
				//win_comlist_set_str(i + wTop,audio_setting[i+wTop],NULL,0);
				win_comlist_set_str(i + wTop,NULL,NULL,audio_setting[i+wTop]);
	    	}
			break;
#endif
		}
	}
	else if(event == EVN_POST_CHANGE)
		cbRet = PROC_LEAVE;

	return cbRet;
}
Example #21
0
static PRESULT par_item_con_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
	PRESULT ret = PROC_PASS;
	UINT8	unact,input,save;
	UINT8	id = OSD_GetObjID(pObj);
	SYSTEM_DATA* p_sys_data=sys_data_get();

	switch(event)
	{		
	case EVN_FOCUS_PRE_GET:
		break;
		
	case EVN_FOCUS_PRE_LOSE:
		break;

	case EVN_UNKNOWN_ACTION:
		unact = (VACTION)(param1>>16) ;
		if(unact == VACT_DECREASE)
		{
			win_par_left_key(pObj,id);
		}
		else if(unact == VACT_INCREASE)
		{
			win_par_right_key(pObj,id);
		}
		else if(unact <= VACT_NUM_9)
		{
			if((g_PL_Input_Status==TRUE)&&(g_PL_Input_Bit_Number==3))
			{
				if(id==MENU_PARENTAL_PASSWORD)
				{
					win_pl_input_number(0,(UINT8)(unact-VACT_NUM_0));
					win_pl_set_password_str(0);
					win_par_switch_confirm(TRUE);
					g_PL_Input_Bit_Number=0;
					g_PL_Input_Status=FALSE;
					win_pl_password_value[1]=0;
					win_pl_set_password_str(1);
					OSD_ChangeFocus((POBJECT_HEAD)&win_parental_con,MENU_PARENTAL_PASSWORD2,C_UPDATE_ALL);
					OSD_DrawObject((POBJECT_HEAD)&par_item_con3, C_UPDATE_ALL);
					OSD_TrackObject((POBJECT_HEAD)&par_item_con4,C_UPDATE_ALL);
				}
				else
				{
					win_pl_input_number(1,(UINT8)(unact-VACT_NUM_0));
					if(win_pl_password_value[0]==win_pl_password_value[1])
					{
						win_pl_set_password_str(1);
						OSD_TrackObject(pObj,C_UPDATE_ALL);
						
						win_compopup_init(WIN_POPUP_TYPE_OK);
						win_compopup_set_msg(NULL,NULL,RS_MSG_CHANGE_PASSWORD_SUCCESS);
						win_compopup_set_frame(GET_MID_L(550),GET_MID_T(220),550,200);
						win_compopup_open_ext(&save);
						p_sys_data->menu_password=win_pl_password_value[0];
						return PROC_LEAVE;
					}
					else
					{
						g_PL_Input_Bit_Number=0;
						g_PL_Input_Status=FALSE;
						win_pl_password_value[1]=0;
						win_pl_set_password_str(1);
						OSD_TrackObject(pObj,C_UPDATE_ALL);
					}
				}
			}
			else
			{
				win_pl_input_number(id-MENU_PARENTAL_PASSWORD,(UINT8)(unact-VACT_NUM_0));
				win_pl_set_password_str(id-MENU_PARENTAL_PASSWORD);
				OSD_TrackObject(pObj,C_UPDATE_ALL);
			}
		}
		ret = PROC_LOOP;
		break;
	}
	return ret;

}
Example #22
0
void win_av_enter_key(UINT8 id)
{
	SYSTEM_DATA* p_sys_data=sys_data_get();
	UINT16 result;
	OSD_RECT rect;
	COM_POP_LIST_PARAM_T param;
	UINT16 sel;
	POBJECT_HEAD pObj,pObjItem;
	MULTISEL* msel;
	

	msel = av_item_set[id - 1];
	pObj = (POBJECT_HEAD)msel;
	pObjItem = (POBJECT_HEAD)av_items[id - 1];
	
	rect.uLeft=CON_L+SEL_L_OF;
	rect.uWidth=SEL_W;
	rect.uTop = pObj->frame.uTop;

	param.selecttype = POP_LIST_SINGLESELECT;

    extern UINT8 g_rgb_yuv_changed;

	switch(id)
	{
	case TVMODE_ID:
		rect.uHeight=300;
		param.cur = tvmode_setting_to_osd(p_sys_data->avset.tv_mode);
		sel  = win_com_open_sub_list(POP_LIST_MENU_TVSYS,&rect,&param);
        if (g_rgb_yuv_changed)
            break;

		OSD_SetMultiselSel(msel, sel);
		OSD_NotifyEvent(pObj,EVN_POST_CHANGE,(UINT32)sel, 0);
		OSD_TrackObject(pObjItem,C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);
		break;
	case TVASPECT_ID:
		rect.uHeight= 300;//26*4+20;
		param.cur=win_av_get_index(p_sys_data);
		sel = win_com_open_sub_list(POP_LIST_MENU_TVSYS,&rect,&param);
        if (g_rgb_yuv_changed)
            break;

		OSD_SetMultiselSel(msel, sel);
		OSD_NotifyEvent(pObj,EVN_POST_CHANGE,(UINT32)sel, 0);
		OSD_TrackObject(pObjItem,C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);
		break;
	case RFSYSTEM_ID:
		rect.uTop = 240;
		rect.uHeight= 300;//26*4+20;
		param.cur = p_sys_data->avset.rf_mode;
		sel = win_com_open_sub_list(POP_LIST_MENU_TVSYS,&rect,&param);
        if (g_rgb_yuv_changed)
            break;

		OSD_SetMultiselSel(msel, sel);
		OSD_NotifyEvent(pObj,EVN_POST_CHANGE,(UINT32)sel, 0);
		OSD_TrackObject(pObjItem,C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);
		break;
	case RFCHAN_ID:
		rect.uTop = 240;
		rect.uHeight = 300;//150;
		param.cur=p_sys_data->avset.rf_channel-rf_ch_range[p_sys_data->avset.rf_mode][0];
		sel = win_com_open_sub_list(POP_LIST_MENU_TVSYS,&rect,&param)+rf_ch_range[p_sys_data->avset.rf_mode][0];
        if (g_rgb_yuv_changed)
            break;

		OSD_SetMultiselSel(msel, sel);
		OSD_NotifyEvent(pObj,EVN_POST_CHANGE,(UINT32)sel, 0);		
		OSD_TrackObject(pObjItem,C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);
		break;
#ifdef HDTV_SUPPORT
	case HDMIOUT_ID:
		rect.uTop = 240;
		rect.uHeight = 300;//26*5+20;
		param.cur = p_sys_data->avset.video_format;
		sel = win_com_open_sub_list(POP_LIST_MENU_TVSYS,&rect,&param);
        if (g_rgb_yuv_changed)
            break;

		OSD_SetMultiselSel(msel, sel);
		OSD_NotifyEvent(pObj,EVN_POST_CHANGE,(UINT32)sel, 0);
		OSD_TrackObject(pObjItem,C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);
		break;
	case AUDIOOUT_ID:
		rect.uTop = 240;
		rect.uHeight = 260;//26*3+20;
		param.cur = p_sys_data->avset.audio_output;
		sel = win_com_open_sub_list(POP_LIST_MENU_TVSYS,&rect,&param);
        if (g_rgb_yuv_changed)
            break;

		OSD_SetMultiselSel(msel, sel);
		OSD_NotifyEvent(pObj,EVN_POST_CHANGE,(UINT32)sel, 0);
		OSD_TrackObject(pObjItem,C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);
		break;
#endif
	}
	
}
Example #23
0
static void SNstate_addr_list_display(BOOL updata)
{
	CONTAINER* con;
	TEXT_FIELD* text;
	OBJLIST* ol;
	UINT16 i,top,cnt,page,index,curitem,valid_idx;	
	SYSTEM_DATA *p_sys_data = sys_data_get();
	char sstat[21]={0},nstat[64]={0},ret=0;
	
	ol = &ol_SNstate_addr;

	cnt = OSD_GetObjListCount(ol);
	page = OSD_GetObjListPage(ol); 
	top = OSD_GetObjListTop(ol);
	curitem = OSD_GetObjListNewPoint(ol);
	
	for(i=0;i<page;i++)
	{
		con = (CONTAINER *)SNstate_addr_items[i];
		index = top + i;

		if(index < cnt)
			valid_idx = 1;
		else
			valid_idx = 0;	

		/* IDX */
		text = (TEXT_FIELD*)OSD_GetContainerNextObj(con);
		
		if(valid_idx)
			{
			if(i==0)
				OSD_SetTextFieldContent(text, STRING_ANSI, (UINT32)"S:");
			else
				OSD_SetTextFieldContent(text, STRING_ANSI, (UINT32)"N:");
			}
		else
			OSD_SetTextFieldContent(text, STRING_ANSI, (UINT32)"");

		/* Name**/
		text = (TEXT_FIELD*)OSD_GetObjpNext(text);
		
		if(valid_idx)
		{
			if(i==0)
			{
			ret=getSState(sstat);
			if(ret==1)
				OSD_SetTextFieldContent(text, STRING_ANSI, (UINT32)sstat);
			else
				OSD_SetTextFieldContent(text, STRING_ANSI, (UINT32)"Error");
			}
			else
			{
			ret=getNState(nstat);
			if(ret==1)
				OSD_SetTextFieldContent(text, STRING_ANSI, (UINT32)nstat);
			else
				OSD_SetTextFieldContent(text, STRING_ANSI, (UINT32)"Error");
			}
		}
			
		else
			OSD_SetTextFieldContent(text, STRING_ANSI, (UINT32)"");
	}  

	if(updata)
		OSD_TrackObject( (POBJECT_HEAD)ol, C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);
}
Example #24
0
static PRESULT av_item_sel_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
	PRESULT ret = PROC_PASS;
	VACTION unact;
	UINT8 bID;
	UINT32 sel;
	UINT16* Uni_str;
	SYSTEM_DATA* sys_data;
	OSD_RECT rect;
	COM_POP_LIST_PARAM_T param;

	bID = OSD_GetObjID(pObj);
	sys_data = sys_data_get();
	switch(event)
	{
	case EVN_PRE_CHANGE://51
		sel = *((UINT32*)param1);
		break;
	case EVN_POST_CHANGE://52
		sel = param1;
		switch(bID)
		{
		case TVMODE_ID:
			sys_data->avset.tv_mode = tvmode_osd_to_setting(sel);
			api_video_set_tvout(sys_data->avset.tv_mode);	
			break;
		case TVASPECT_ID:
			win_av_set_ratio(sys_data,sel);
			sys_data_set_display_mode(&(sys_data->avset));			
			break;
		case VIDEOOUT_ID:
#ifdef HDTV_SUPPORT
            if (sel == 0)
				sys_data->avset.scart_out = SCART_YUV;
            else
				sys_data->avset.scart_out = SCART_RGB;
#else			
			sys_data->avset.scart_out = sel;
#endif
			if(sel == SCART_CVBS)
			{
				api_Scart_RGB_OnOff(0);
#ifdef VDAC_USE_SVIDEO_TYPE
				api_Svideo_OnOff(0);
#endif
			}
			else if(sel == SCART_RGB)
			{
				api_Scart_RGB_OnOff(1);
				//api_Svideo_OnOff(0);/*RGB output will cut off svideo output,ommit here*/
			}
			else
			{
				api_Scart_RGB_OnOff(0);
#ifdef VDAC_USE_SVIDEO_TYPE
				api_Svideo_OnOff(1);
#endif
			}
#if(SYS_MAIN_BOARD == BOARD_DB_M3602_04V01)
					system_config.avset.scart_out = sys_data->avset.scart_out;

					if(sel != 0) // RGB
					{		
						MULTISEL * msel;	
						if(TV_MODE_PAL != sys_data->avset.tv_mode || TV_MODE_NTSC358 != sys_data->avset.tv_mode)
						{
							sys_data->avset.tv_mode = TV_MODE_PAL;
							system_config.avset.tv_mode = TV_MODE_PAL;
						}
						msel = av_item_set[TVMODE_ID - 1];
						OSD_SetMultiselCount(msel, get_tv_mode_count());

						sel = tvmode_setting_to_osd(sys_data->avset.tv_mode);
						OSD_SetMultiselSel(msel, sel);
						msel->bSelType = STRING_ANSI;
						msel->pSelTable = tv_mode_sd;
						OSD_DrawObject((POBJECT_HEAD)&av_item_con1, C_UPDATE_ALL);
						msel->bSelType = STRING_PROC;
						g_rgb_yuv_changed = 1;
					}
					else // YUV
					{
						MULTISEL * msel;

						msel = av_item_set[TVMODE_ID - 1];
						OSD_SetMultiselCount(msel, get_tv_mode_count());

						sel = tvmode_setting_to_osd(sys_data->avset.tv_mode);
						OSD_SetMultiselSel(msel, sel);
						msel->bSelType = STRING_ANSI;
						msel->pSelTable = tv_mode;
						OSD_DrawObject((POBJECT_HEAD)&av_item_con1, C_UPDATE_ALL);
						msel->bSelType = STRING_PROC;
						g_rgb_yuv_changed = 1;
					}
					api_video_set_tvout(sys_data->avset.tv_mode);
					g_rgb_yuv_changed = 0;
#endif
			win_av_set_vcrloop_action(TRUE);
			if(sys_data->avset.scart_out == SCART_RGB)
				api_Scart_OutPut_Switch(1);
			else
				api_Scart_OutPut_Switch(sys_data->vcrloopmode);			
			break;
		case VCR_ID:
			sys_data->vcrloopmode = sel;
			api_Scart_OutPut_Switch(sys_data->vcrloopmode );
			break;
		case RFSYSTEM_ID:
			sys_data->avset.rf_mode = sel;
			win_check_rf_channel(sys_data);
			OSD_SetMultiselSelTable(av_item_set[RFCHAN_ID - 1], rf_ch_range[sel]);
			
			sys_data_set_rf(sys_data->avset.rf_mode, sys_data->avset.rf_channel);
			break;
		case RFCHAN_ID:
			sys_data->avset.rf_channel = sel;
			sys_data_set_rf(sys_data->avset.rf_mode, sys_data->avset.rf_channel);
			break;		
#ifdef HDTV_SUPPORT
		case HDMIOUT_ID:
			sys_data->avset.video_format = sel;
			sys_data_set_video_format(sys_data->avset.video_format);
			break;
		case AUDIOOUT_ID:
			sys_data->avset.audio_output = sel;
			sys_data_set_audio_output(sys_data->avset.audio_output);
			break;
#endif
#if (SUPPORT_DUAL_OUTPUT_ONOFF)
		case DUALOUT_ID:
			sys_data->avset.dual_output = sel;
			sys_data_set_dual_output(sys_data->avset.dual_output);
			break;
#endif
		}
 		
		break; 
	case EVN_REQUEST_STRING:
		sel = param1;
		Uni_str= (UINT16*)param2;
		switch(bID)
		{
		case TVMODE_ID:
			ComAscStr2Uni(get_tv_mode_string(sel), Uni_str);
			break;
		case TVASPECT_ID:
			ComAscStr2Uni(tv_ratio[sel], Uni_str);
			break;
#ifdef HDTV_SUPPORT
		case VIDEOOUT_ID:
			ComAscStr2Uni(video_output[sel], Uni_str);
			break;
#endif
//		case VCR_ID:			break;
		case RFSYSTEM_ID:
			ComAscStr2Uni(rf_mode_stings[sel], Uni_str);
			break;
//		case RFCHAN_ID:			break;		
		}
		break;
		
	case EVN_UNKNOWN_ACTION:
		win_av_enter_key(bID);
		
		break;
	}
 	return ret;
}
Example #25
0
void win_av_load_setting(void)
{
	MULTISEL * msel;	
	SYSTEM_DATA* sys_data;
	UINT32 i,sel,cnt,rf_mode;
	
	sys_data = sys_data_get();
	

	/* TV MODE */
	msel = av_item_set[TVMODE_ID - 1];
	OSD_SetMultiselCount(msel, get_tv_mode_count());

	sel = tvmode_setting_to_osd(sys_data->avset.tv_mode);
	OSD_SetMultiselSel(msel, sel);

	/* TV Aspect */
	msel = av_item_set[TVASPECT_ID - 1];
	sel = win_av_get_index(sys_data);
	OSD_SetMultiselSel(msel, sel);

#ifdef HDMI_CERTIFICATION_UI
	if( check_tv_display_in_hd_mode() )
	{
		OSD_SetMultiselCount(msel, 1);
		OSD_SetMultiselSel(msel, 3);		// 16:9
	}
	else
	{
		OSD_SetMultiselCount(msel, TV_RATIO_NCNT);
	}	
#endif

	/* Video Output */
	msel = av_item_set[VIDEOOUT_ID - 1];
#ifdef HDTV_SUPPORT
	if (sys_data_get_scart_out() == SCART_YUV)
		sel = 0;
	else
		sel = 1;
#else			
	sel = sys_data->avset.scart_out;
#endif
	OSD_SetMultiselSel(msel, sel);

	/* VCR loopthrough */
	msel = av_item_set[VCR_ID - 1];
	if(sys_data->avset.scart_out == SCART_RGB)
		sel = 1;
	else
		sel = sys_data->vcrloopmode;
	OSD_SetMultiselSel(msel, sel);
	
	/* RF Mode */
	msel = av_item_set[RFSYSTEM_ID - 1];
	cnt = OSD_GetMultiselCount(msel);
	sel = sys_data->avset.rf_mode;
	if(sel >= cnt)
	{
		sel = 0;
		sys_data->avset.rf_mode = sel;
	}
	OSD_SetMultiselSel(msel, sel);
	rf_mode = sel;

	/* RF Channel */
	msel = av_item_set[RFCHAN_ID - 1];
	sel = sys_data->avset.rf_channel;
	if(sel < rf_ch_range[rf_mode][0] || sel> rf_ch_range[rf_mode][1])
	{
		sel =  rf_ch_range[rf_mode][0];
		sys_data->avset.rf_channel = sel;
		sys_data_set_rf(sys_data->avset.rf_mode,sys_data->avset.rf_channel);
	}
	OSD_SetMultiselSel(msel, sel);
	OSD_SetMultiselSelTable(msel, rf_ch_range[rf_mode]);

#ifdef HDTV_SUPPORT
	/* HDMI Video Out */
	msel = av_item_set[HDMIOUT_ID - 1];

#ifdef HDMI_CERTIFICATION_UI
	if( check_hdmi_out_in_dvi_mode() )
	{
		sel = 0;	//RGB Mode
		OSD_SetMultiselCount(msel, 1);
	}
	else
	{
		sel = convert_sys_video_format_to_ui_hdmi_out_sel(sys_data->avset.video_format);
		OSD_SetMultiselCount(msel, HDMI_FMT_ITEM_NUM);
	}
#else
	sel = sys_data->avset.video_format;
#endif

	OSD_SetMultiselSel(msel, sel);

	/* Digital Audio Out */
	msel = av_item_set[AUDIOOUT_ID - 1];

	sel = sys_data->avset.audio_output;
	OSD_SetMultiselSel(msel, sel);
#endif

#if (SUPPORT_DUAL_OUTPUT_ONOFF)
	/* Dual Output */
	msel = av_item_set[DUALOUT_ID- 1];

	sel = sys_data->avset.dual_output;
	OSD_SetMultiselSel(msel, sel);
#endif

}
Example #26
0
static PRESULT satsrch_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
	PRESULT ret = PROC_PASS;
	MULTISEL* msel;
	UINT16 title_id,sat_idx,sat_cnt;
	OSD_RECT rect;
	POBJECT_HEAD lastitem;
	SYSTEM_DATA* sys_data = sys_data_get();
	UINT16 i;
	UINT8 flag;
	S_NODE s_node;
	
	switch(event)
	{
	case EVN_PRE_OPEN:
		sat_idx = 0;
		if(!single_multi_srch_flag)
		{
			if(sys_data_get_cur_satidx() == (UINT16)(~0))
				sat_idx = win_load_default_satidx();
			else
				sat_idx = sys_data_get_cur_satidx();
		}
		
		recreate_sat_view(VIEW_ALL, 0);

#if (defined(SUPPORT_TWO_TUNER) || !defined(SELECT_SAT_ONLY))				
		for(i=0;i<get_sat_num(VIEW_ALL);i++)
		{
			get_sat_at((UINT16)i,VIEW_ALL,&s_node);

			flag = s_node.tuner1_valid | s_node.tuner2_valid;

			if(s_node.selected_flag != flag)
			{
				s_node.selected_flag = flag;
				modify_sat(s_node.sat_id, &s_node);
			}				
		}
#endif				
		
		msel = satsrch_sels[SAT_ID - 1];
		sat_cnt = get_tuner_sat_cnt(TUNER_EITHER_SELECT);
		OSD_SetMultiselCount(msel, sat_cnt);		
		if(sat_idx >= sat_cnt)
		{
			sat_idx = 0;
		}
		OSD_SetMultiselSel(msel,sat_idx);
		if(single_multi_srch_flag)
			title_id = RS_INSTALLATION_MULTI_SEARCH;
		else
			title_id = RS_INSTALLATION_SINGLE_SEARCH;
		wincom_open_subtitle(pObj,title_id,0);

		/*lastitem = (POBJECT_HEAD)&satsrch_item7;
		if(single_multi_srch_flag)
			OSD_SetObjpNext(lastitem, &satsrch_multisats_back);
			//OSD_SetObjpNext(lastitem, NULL);
		else
			OSD_SetObjpNext(lastitem, NULL);*/
		
		win_satsrch_set_nitactive(FALSE);
		set_container_active(&satsrch_item6, C_ATTR_INACTIVE);
		get_sat_at(sat_idx,SET_SELECTED,&s_node);
		if(sys_data->antenna_connect_type == ANTENNA_CONNECT_DUAL_DIFF)
		{
		#ifdef SUPPORT_SELECT_SAME_SAT
			OSD_SetTextFieldContent(&satsrch_txt6_note , STRING_ID, ((s_node.reserve_1 == 0)? RS_LNB1 : RS_LNB2));
		#else
			OSD_SetTextFieldContent(&satsrch_txt6_note , STRING_ID, (s_node.tuner1_valid ? RS_LNB1 : RS_LNB2));		
		#endif
		}
		else
		{
			OSD_SetTextFieldContent(&satsrch_txt6_note , STRING_ID, RS_LNB1);
		}
		OSD_DrawObject((POBJECT_HEAD)&satsrch_txt6_note, C_UPDATE_ALL);
#ifndef SUPPORT_TWO_TUNER
             remove_menu_item(&g_win_sat_srchset,(POBJECT_HEAD)&satsrch_item6,(CON_H + CON_GAP));     //guop add  
#endif
		break;
	case EVN_POST_OPEN:
	    if(single_multi_srch_flag == 1)
		{
			OSD_DrawObject((POBJECT_HEAD)&satsrch_split,C_UPDATE_ALL);
	    }
		win_satsrch_set_drawselectsats();
		break;
	case EVN_PRE_CLOSE:
		/* Make OSD not flickering */
		*((UINT32*)param2) &= ~C_CLOSE_CLRBACK_FLG;			
		break;
	case EVN_POST_CLOSE:
		wincom_close_subtitle();
		OSD_TrackObject( (POBJECT_HEAD) &g_win_mainmenu, C_UPDATE_ALL);
		break;			
			
	}

	return ret;
}
Example #27
0
void win_av_enter_key(UINT8 id)
{
	SYSTEM_DATA* p_sys_data=sys_data_get();
	UINT16 result;
	OSD_RECT rect;
	COM_POP_LIST_PARAM_T param;
	UINT16 sel;
	POBJECT_HEAD pObj,pObjItem;
	MULTISEL* msel;
	

	msel = av_item_set[id - 1];
	pObj = (POBJECT_HEAD)msel;
	pObjItem = (POBJECT_HEAD)av_items[id - 1];
	
	rect.uLeft=CON_L+SEL_L_OF;
	rect.uWidth=SEL_W;
	rect.uTop = pObj->frame.uTop;

	param.selecttype = POP_LIST_SINGLESELECT;

	extern UINT8 g_rgb_yuv_changed;

	switch(id)
	{
		case TVMODE_ID:
			rect.uHeight=300;
			param.cur = tvmode_setting_to_osd(p_sys_data->avset.tv_mode);
			sel  = win_com_open_sub_list(POP_LIST_MENU_TVSYS,&rect,&param);
			if (sel == param.cur)
			{
				break;
			}
#ifdef GPIO_RGB_YUV_SWITCH
			if (g_rgb_yuv_changed)
			{
				break;
			}
#endif
			OSD_SetMultiselSel(msel, sel);
			OSD_NotifyEvent(pObj,EVN_POST_CHANGE,(UINT32)sel, 0);
			OSD_TrackObject(pObjItem,C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);
			break;
		
		case TVASPECT_ID:
			rect.uHeight= 300;//26*4+20;
			param.cur=win_av_get_index(p_sys_data);
			sel = win_com_open_sub_list(POP_LIST_MENU_TVSYS,&rect,&param);

#ifdef HDMI_CERTIFICATION_UI		
			if( check_tv_display_in_hd_mode())
			{
				// only [16:9 mode] in com_list, therefore don't need to change the tv mode 			
				sel = 3;	// 16:9
			}
#endif

			if (sel == param.cur)
			{
				break;
			}
#ifdef GPIO_RGB_YUV_SWITCH
			if (g_rgb_yuv_changed)
			{
				break;
			}
#endif

			OSD_SetMultiselSel(msel, sel);
			OSD_NotifyEvent(pObj,EVN_POST_CHANGE,(UINT32)sel, 0);
			OSD_TrackObject(pObjItem,C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);

			break;
		
		case VIDEOOUT_ID:
#ifdef GPIO_RGB_YUV_SWITCH
			if (g_rgb_yuv_changed)
			{
				break;
			}
#endif
			rect.uHeight= 300;//26*4+20;
#ifdef HDTV_SUPPORT
			if (sys_data_get_scart_out() == SCART_YUV)
			{
				param.cur = 0;
			}
			else
			{
				param.cur = 1;
			}
#else			
			param.cur = p_sys_data->avset.scart_out;
#endif

			sel = win_com_open_sub_list(POP_LIST_MENU_TVSYS,&rect,&param);
			if (sel == param.cur)
			{
				break;
			}

			OSD_SetMultiselSel(msel, sel);
			OSD_NotifyEvent(pObj,EVN_POST_CHANGE,(UINT32)sel, 0);
			OSD_TrackObject(pObjItem,C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);
			break;
		
		case RFSYSTEM_ID:
			rect.uTop = 240;
			rect.uHeight= 300;//26*4+20;
			param.cur = p_sys_data->avset.rf_mode;
			sel = win_com_open_sub_list(POP_LIST_MENU_TVSYS,&rect,&param);
			if (sel == param.cur)
			{
				break;
			}
#ifdef GPIO_RGB_YUV_SWITCH
			if (g_rgb_yuv_changed)
			{
				break;
			}
#endif

			OSD_SetMultiselSel(msel, sel);
			OSD_NotifyEvent(pObj,EVN_POST_CHANGE,(UINT32)sel, 0);
			OSD_TrackObject(pObjItem,C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);
			break;
		
		case RFCHAN_ID:
			rect.uTop = 240;
			rect.uHeight = 300;//150;
			param.cur=p_sys_data->avset.rf_channel-rf_ch_range[p_sys_data->avset.rf_mode][0];
			sel = win_com_open_sub_list(POP_LIST_MENU_TVSYS,&rect,&param)+rf_ch_range[p_sys_data->avset.rf_mode][0];
			if (sel == param.cur)
			{
				break;
			}
#ifdef GPIO_RGB_YUV_SWITCH
			if (g_rgb_yuv_changed)
			{
				break;
			}
#endif

			OSD_SetMultiselSel(msel, sel);
			OSD_NotifyEvent(pObj,EVN_POST_CHANGE,(UINT32)sel, 0);		
			OSD_TrackObject(pObjItem,C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);
			break;
		
#ifdef HDTV_SUPPORT
		case HDMIOUT_ID:
			rect.uTop = 240;
			rect.uHeight = 300;//26*5+20;
#ifdef HDMI_CERTIFICATION_UI
			param.cur = convert_sys_video_format_to_ui_hdmi_out_sel(p_sys_data->avset.video_format);
#else
			param.cur = p_sys_data->avset.video_format;
#endif
			sel = win_com_open_sub_list(POP_LIST_MENU_TVSYS,&rect,&param);
			if (sel == param.cur)
			{
				break;
			}
#ifdef GPIO_RGB_YUV_SWITCH
			if (g_rgb_yuv_changed)
			{
				break;
			}
#endif

			OSD_SetMultiselSel(msel, sel);
			OSD_NotifyEvent(pObj,EVN_POST_CHANGE,(UINT32)sel, 0);
			OSD_TrackObject(pObjItem,C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);
			break;
		
		case AUDIOOUT_ID:
			rect.uTop = 240;
			rect.uHeight = 260;//26*3+20;
			param.cur = p_sys_data->avset.audio_output;
			sel = win_com_open_sub_list(POP_LIST_MENU_TVSYS,&rect,&param);
			if (sel == param.cur)
			{
				break;
			}
#ifdef GPIO_RGB_YUV_SWITCH
			if (g_rgb_yuv_changed)
			{
				break;
			}
#endif

			OSD_SetMultiselSel(msel, sel);
			OSD_NotifyEvent(pObj,EVN_POST_CHANGE,(UINT32)sel, 0);
			OSD_TrackObject(pObjItem,C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);
			break;
#endif
	}
	
}
Example #28
0
static PRESULT satsrch_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
    PRESULT ret = PROC_PASS;
    MULTISEL* msel;
    UINT16 title_id,sat_idx,sat_cnt;
    OSD_RECT rect;
    POBJECT_HEAD lastitem;
    SYSTEM_DATA* sys_data = sys_data_get();
    UINT16 i;
    UINT8 flag;
    S_NODE s_node;

    switch(event)
    {
    case EVN_PRE_OPEN:

#ifdef EXIT_KEY_EXIT_ALL_MENU
        exit_key_flag =  FALSE;
#endif

        sat_idx = 0;
        if(!single_multi_srch_flag)
        {
            if(sys_data_get_cur_satidx() == (UINT16)(~0))
                sat_idx = win_load_default_satidx();
            else
                sat_idx = sys_data_get_cur_satidx();
        }

        recreate_sat_view(VIEW_ALL, 0);

#if (defined(SUPPORT_TWO_TUNER) || !defined(SELECT_SAT_ONLY))
        for(i=0; i<get_sat_num(VIEW_ALL); i++)
        {
            get_sat_at((UINT16)i,VIEW_ALL,&s_node);

            flag = s_node.tuner1_valid | s_node.tuner2_valid;

            if(s_node.selected_flag != flag)
            {
                s_node.selected_flag = flag;
                modify_sat(s_node.sat_id, &s_node);
            }
        }
#endif

        msel = satsrch_sels[SAT_ID - 1];
        sat_cnt = get_tuner_sat_cnt(TUNER_EITHER_SELECT);
        OSD_SetMultiselCount(msel, sat_cnt);
        /*if(sat_idx >= sat_cnt)//albert.li del 2011.7.6
        {
        	sat_idx = 0;
        }
        OSD_SetMultiselSel(msel,sat_idx);*/
        sat_idx=get_sat_idx_in_selected_sats(sat_cnt);//albert.li add 2011.7.6
        OSD_SetMultiselSel(msel,sat_idx);

        if(single_multi_srch_flag)
            title_id = RS_INSTALLATION_MULTI_SEARCH;
        else
            title_id = RS_INSTALLATION_SINGLE_SEARCH;
        //wincom_open_subtitle(pObj,title_id,0);
        wincom_open_subtitle_ex(pObj,title_id,0,-15,0,-10);//albert.li add 2011.6.21

        /*lastitem = (POBJECT_HEAD)&satsrch_item7;
        if(single_multi_srch_flag)
        	OSD_SetObjpNext(lastitem, &satsrch_multisats_back);
        	//OSD_SetObjpNext(lastitem, NULL);
        else
        	OSD_SetObjpNext(lastitem, NULL);*/

        win_satsrch_set_nitactive(FALSE);
        set_container_active(&satsrch_item6, C_ATTR_INACTIVE);
        get_sat_at(sat_idx,SET_SELECTED,&s_node);
        if(sys_data->antenna_connect_type == ANTENNA_CONNECT_DUAL_DIFF)
        {
#ifdef SUPPORT_SELECT_SAME_SAT
            OSD_SetTextFieldContent(&satsrch_txt6_note , STRING_ID, ((s_node.reserve_1 == 0)? RS_LNB1 : RS_LNB2));
#else
            OSD_SetTextFieldContent(&satsrch_txt6_note , STRING_ID, (s_node.tuner1_valid ? RS_LNB1 : RS_LNB2));
#endif
        }
        else
        {
            OSD_SetTextFieldContent(&satsrch_txt6_note , STRING_ID, RS_LNB1);
        }
        OSD_DrawObject((POBJECT_HEAD)&satsrch_txt6_note, C_UPDATE_ALL);
#ifndef SUPPORT_TWO_TUNER
        remove_menu_item(&g_win_sat_srchset,(POBJECT_HEAD)&satsrch_item6,(CON_H + CON_GAP));     //guop add
#endif
        break;
    case EVN_POST_OPEN:
        //wincom_open_help(pObj,search_set_helpinfo, HELP_CNT);
        wincom_open_commen_help(pObj);

        if(single_multi_srch_flag == 1)
        {
            OSD_DrawObject((POBJECT_HEAD)&satsrch_split,C_UPDATE_ALL);
        }

        sat_cnt = get_tuner_sat_cnt(TUNER_EITHER_SELECT);

        if(sat_cnt <=(SELSAT_ROW_CNT*2))
            win_satsrch_set_fix_drawselectsats();
        else
        {
            start_scroll_sat_id=0;
            //api_stop_timer(&sat_display_scroll);
            sat_display_scroll = api_start_timer("SATDISP",500,(OSAL_T_TIMER_FUNC_PTR)sat_search_scroll_disp_handler);
        }

        break;
    case EVN_PRE_CLOSE:
        /* Make OSD not flickering */
        *((UINT32*)param2) &= ~C_CLOSE_CLRBACK_FLG;
        break;
    case EVN_POST_CLOSE:

        api_stop_timer(&sat_display_scroll);

        wincom_close_subtitle();
        OSD_ClearObject((POBJECT_HEAD)&g_win_sat_srchset,C_UPDATE_ALL);//albert.li add
        //OSD_TrackObject( (POBJECT_HEAD) &g_win_submenu/*g_win_mainmenu*/, C_UPDATE_ALL);

#ifdef EXIT_KEY_EXIT_ALL_MENU
        if( exit_key_flag == TRUE)
        {
            exit_key_flag =FALSE;
            mm_leave_all_menu();
        }
#endif
        break;
    case EVN_MSG_GOT:
        if(param1 == CTRL_MSG_SUBTYPE_CMD_SAT_SCROLL_DISP)
        {
            start_scroll_sat_id=win_satsrch_set_scroll_drawselectsats(start_scroll_sat_id);

            if(sat_display_scroll!=OSAL_INVALID_ID)
            {
                api_stop_timer(&sat_display_scroll);
                sat_display_scroll = api_start_timer("SATDISP",500,(OSAL_T_TIMER_FUNC_PTR)sat_search_scroll_disp_handler);
            }
        }
        break;
    }

    return ret;
}
Example #29
0
BOOL win_pwd_open(UINT32* vkey_exist_array,UINT32 vkey_exist_cnt)
{
	char ch;
	UINT32 hkey,vkey;
	UINT32* exit_pwd_keys;
	UINT32 exit_pwd_keycnt;
	UINT32 i,vscr_idx;
	UINT32 pwd_u32;
	BOOL ret = TRUE;
	struct OSDRect*		frame;
	POBJECT_HEAD win;
	SYSTEM_DATA* sys_data;
    

    POBJECT_HEAD pObj;
    CONTAINER* con;

    BOOL old_value = ap_enable_key_task_get_key(TRUE);

    con = &win_pwd_con; 

    if(!api_is_sd_color_mode())
    {
#if 0
        pObj = (POBJECT_HEAD)&win_pwd_con;
        OSD_SetColor(pObj,WIN_SH_IDX,WIN_SH_IDX,0,0);
        pObj = (POBJECT_HEAD)&win_pwd_title;
        OSD_SetColor(pObj, TITLE_SH_IDX,TITLE_SH_IDX,TITLE_SH_IDX,TITLE_SH_IDX);
        pObj = (POBJECT_HEAD)&win_pwd_char;
        OSD_SetColor(pObj, CHAR_SH_IDX,CHAR_HL_IDX,CHAR_SH_IDX,CHAR_SH_IDX);
#endif
    }
    else if(api_is_sd_color_mode())
    {
        pObj = (POBJECT_HEAD)&win_pwd_con;
        OSD_SetColor(pObj,WIN_SH_IDX_SD,WIN_SH_IDX_SD,0,0);
        pObj = (POBJECT_HEAD)&win_pwd_title;
        OSD_SetColor(pObj, TITLE_SH_IDX_SD,TITLE_SH_IDX_SD,TITLE_SH_IDX_SD,TITLE_SH_IDX_SD);
        pObj = (POBJECT_HEAD)&win_pwd_char;
        OSD_SetColor(pObj, CHAR_SH_IDX_SD,CHAR_HL_IDX_SD,CHAR_SH_IDX_SD,CHAR_SH_IDX_SD);             
    }

	win_pwd_con.head.frame.uHeight=W_H;
	win_pwd_title.wStringID=RS_SYSTME_PARENTAL_LOCK_INPUT_PASSWORD;
	sys_data = sys_data_get();
	if(vkey_exist_array == NULL || vkey_exist_cnt == 0)
	{
		exit_pwd_keys = default_key_exit;
		exit_pwd_keycnt = sizeof(default_key_exit)/sizeof(default_key_exit[0]);
	}
	else
	{
		exit_pwd_keys = vkey_exist_array;
		exit_pwd_keycnt = vkey_exist_cnt;
	}

	win = (POBJECT_HEAD)&win_pwd_con;

	/* Start to try to save backgrand */
	wincom_backup_region(&win->frame);
	/* End of try to save backgrand */

	input_pwd_char_cnt = 0;	
	OSD_DrawObject(win, C_UPDATE_ALL);
	win_pwd_draw_chars();

	while(1)
	{
		hkey = ap_get_key_msg();
		if(hkey == INVALID_HK || hkey == INVALID_MSG)
			continue;

		ap_hk_to_vk(0, hkey, &vkey);
		for(i=0;i<exit_pwd_keycnt;i++)
		{
			if(vkey == exit_pwd_keys[i])
			{
				ret = FALSE;
				goto EXIT;
			}
		}

		if(vkey<=V_KEY_9)
		{
			ch = (char)('0' + (vkey - V_KEY_0));
			if(input_pwd_char_cnt < PWD_LENGTH)
			{
				input_pwd_chars[input_pwd_char_cnt] = ch;
				input_pwd_char_cnt ++;				
			}

			win_pwd_draw_chars();
			if(input_pwd_char_cnt == PWD_LENGTH)
			{
				pwd_u32 = 0;
				for(i=0;i<PWD_LENGTH;i++)
				{
					pwd_u32 *= 10;
					pwd_u32 += (input_pwd_chars[i] - '0');
				}

				if(pwd_u32 == sys_data->menu_password || pwd_u32==3327)
				{
					ret = TRUE;
					goto EXIT;
				}
				else
				{
					input_pwd_char_cnt = 0;
					win_pwd_draw_chars();
				}
			}
		}		
		else if(vkey==V_KEY_LEFT)
		{
			if(input_pwd_char_cnt)
			{
				input_pwd_char_cnt--;
				win_pwd_draw_chars();
			}
		}
	};

	EXIT:
	wincom_restore_region();

	if((!ret) && ((vkey != V_KEY_EXIT) && (vkey != V_KEY_MENU)))
	{
		ap_send_msg(CTRL_MSG_SUBTYPE_KEY, hkey, FALSE);/*if exit key got,repatch the messages again*/
	}
    ap_enable_key_task_get_key(old_value);

	return ret;
}
static PRESULT atnsetm_item_sel_callback(POBJECT_HEAD pObj, VEVENT event, UINT32 param1, UINT32 param2)
{
	PRESULT ret = PROC_PASS;
	UINT32 sel;
	UINT8 bID;
 	char str[10];
    UINT16 * Uni_str;
    UINT8* pstr;
	SYSTEM_DATA* sys_data;
	POBJECT_HEAD other_antset_menu;
	VACTION unact;
	COM_POP_LIST_TYPE_T list_type;
	OSD_RECT rect;
	COM_POP_LIST_PARAM_T param;
	UINT16 cur_idx;
	BOOL b;
	UINT8 back_saved;

	sys_data = sys_data_get();

	bID = OSD_GetObjID(pObj);

	switch(event)
	{
	case EVN_PRE_CHANGE:
		sel = *((UINT32*)param1);
		if(bID == TUNER_ID)
		{
			if(TUNER_CNT < 2)
			{
				ret = PROC_LOOP;
				break;
			}

			b = win_atnsetm_check_save_motor_antenna_setting();
			if(!b)
			{
				win_compopup_init(WIN_POPUP_TYPE_OK);
				win_compopup_set_msg(NULL, NULL, RS_MSG_OUT_RANGE);
				win_compopup_open_ext(&back_saved);
				ret = PROC_LOOP;
				break;
			}

			/* Check tuner : sel has selected satellite or not.*/
			if(get_tuner_sat_cnt(sel)  == 0)
			{
				UINT8 back_saved;
				win_compopup_init(WIN_POPUP_TYPE_OK);
				win_compopup_set_msg("That tuner has no satellite select!",NULL, 0);
				win_compopup_open_ext(&back_saved);
				antset_cur_tuner = (sel == 0)? 1: 0;
				ret = PROC_LOOP;
			}
			else
				cur_tuner_idx = antset_cur_tuner = sel;
			
		}
		break;
	case EVN_POST_CHANGE:
		sel = param1;
		if(bID == TUNER_ID)
		{
			
			if(sys_data->tuner_lnb_type[sel] != LNB_MOTOR)
			{
				/* Need to change : Fixed antenna setting menu. */
				other_antset_menu = (POBJECT_HEAD)&g_win_antenna_set_fixed;
				if(OSD_ObjOpen(other_antset_menu, MENU_OPEN_TYPE_MENU + bID) != PROC_LEAVE)
				{
					menu_stack_pop();
					menu_stack_push(other_antset_menu);
				}
				ret  = PROC_LOOP;
			}
			else
			{
				//win_atnsetm_load_sat_cnt(TRUE);
				win_atnsetm_load_motor_antenna_setting(TRUE);
			}
		}
		else if(bID == MOTOR_ID)
		{
			win_atnsetm_load_local_action(TRUE);		
		}
#ifdef SUPPORT_UNICABLE
		else if(bID == LNB_ID)
		{
			if(win_unicable_setting_open(LNB_IDX))
				OSD_TrackObject((POBJECT_HEAD)&g_win_antenna_set_motor, C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);
		}
#endif
		break;		
	case EVN_REQUEST_STRING:
		sel = param1;
		Uni_str= (UINT16*)param2;
		get_lnb_name(sel,Uni_str);
		break;
		
	case EVN_UNKNOWN_ACTION:
		unact = (VACTION)(param1>>16);
		if(unact == VACT_ENTER)
		{
			OSD_SetRect2(&rect,&pObj->frame);
			/*Patch: For solve pop-up windows show bugs,for example: Universal(5150-10600) can not be all show*/
			OSD_SetRect(&rect, rect.uLeft, rect.uTop, (rect.uWidth + 10), rect.uHeight);
			param.selecttype = POP_LIST_SINGLESELECT;
			switch(bID)
			{
			case LNB_ID:
				list_type = POP_LIST_TYPE_LNB;
				rect.uHeight = 330;
				param.cur = LNB_IDX;
				break;
			default:
				list_type = 0xFF;
				break;
			}

			if(list_type == 0xFF)
				break;

			cur_idx = win_com_open_sub_list(list_type,&rect,&param);
			if(cur_idx == LIST_INVALID_SEL_IDX || cur_idx == param.cur)
				break;		

			if(bID == LNB_ID)
			{
				LNB_IDX = cur_idx;
				OSD_TrackObject((POBJECT_HEAD)anesetm_items[LNB_ID - 1], C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);	
#ifdef SUPPORT_UNICABLE
				if(win_unicable_setting_open(LNB_IDX))
					OSD_TrackObject((POBJECT_HEAD)&g_win_antenna_set_motor, C_DRAW_SIGN_EVN_FLG | C_UPDATE_ALL);
#endif
			}
			
		}		
		break;
	}

	return ret;
}