source: svn/trunk/newcon3bcm2_21bu/dta/src/app/nanotv/bscreen_status.c

Last change on this file was 2, checked in by phkim, 11 years ago

1.phkim

  1. revision copy newcon3sk r27
  • Property svn:executable set to *
File size: 53.0 KB
Line 
1/***************************************************************************
2 *     Copyright (c) 2003-2006, Broadcom Corporation
3 *     All Rights Reserved
4 *     Confidential Property of Broadcom Corporation
5 *
6 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
7 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
8 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
9 *
10 * $brcm_Workfile:  $
11 * $brcm_Revision:  $
12 * $brcm_Date: $
13 *
14 * Module Description:
15 *
16 * Revision History:
17 *
18 * $brcm_Log:  $
19 *
20 ***************************************************************************/
21
22#include "bapp.h"
23#include "bsettop_display.h"
24#include "bstd.h"
25#include "bapp_util.h"
26#include "ministd.h"
27#include "bgfx.h"
28#include "chan_mgr.h"
29#include "bscreen_status_str.c"
30#include "bscreen.h"
31
32BDBG_MODULE(bscreen_status);             /* Register software module with debug interface */
33
34static float power_level = 0.0;
35#if 0
36static bsettop_display_format_t s_temp_format;
37static bool s_confirm_change = false;
38#define CONFIRM_TIMEOUT_TICKS   MS_TO_TICKS(10 * 1000)
39#endif
40extern bool g_disable_fcc; 
41
42int get_fraction(float val, bool *minus)
43{
44    int i;
45    *minus = 0;
46
47    if (val >= 0.0) {
48        i = (val - (int)val) * 100;
49    }
50    else if (val >= -1.0) {
51        i = 100 - ((1.0 - (int)val) + val) * 100;
52        *minus = 1;
53    }
54    else {
55        i = 100 - ((1.0 - (int)val) + val) * 100;
56    }
57    return i;
58}
59
60#define MAX_TSTR_LEN    128
61typedef enum dbg_layout_t
62{
63        eINFO_X                    = eSCREEN_ACTION_SAFE_X,
64        eINFO_STATUS_X     = eSCREEN_ACTION_SAFE_X + 20,
65        eINFO_STATUS_Y     = eSCREEN_ACTION_SAFE_Y,
66        eINFO_COL_WIDTH    = eSCREEN_ACTION_SAFE_WIDTH/2,
67        eINFO_COL_LABEL_WIDTH  = eINFO_COL_WIDTH,
68        eINFO_ROW_HEIGHT   = 24,
69        eINFO_HELP_Y       = (eSCREEN_ACTION_SAFE_HEIGHT + eSCREEN_ACTION_SAFE_Y - eINFO_ROW_HEIGHT),
70        eCH_MAP_START_X    = eSCREEN_ACTION_SAFE_X,
71        eCH_MAP_START_Y    = eSCREEN_ACTION_SAFE_Y,
72        eCH_MAP_HDR_Y      = (eSCREEN_ACTION_SAFE_Y + eINFO_ROW_HEIGHT),
73        eCH_MAP_ROW_Y      = eCH_MAP_HDR_Y,
74        eCH_MAP_COL_WIDTH  = (eSCREEN_ACTION_SAFE_WIDTH/6),
75        eCH_MAP_ROW_HEIGHT = 24,
76        eCH_MAP_NUM_ROW    = (((eSCREEN_ACTION_SAFE_HEIGHT - 3*eINFO_ROW_HEIGHT)/eCH_MAP_ROW_HEIGHT) - 1),
77        eDIAG_ROW_HEIGHT   = 24,
78        eDIAG_START_X      = eSCREEN_ACTION_SAFE_X,
79        eDIAG_MENU_X       = (eDIAG_START_X + 20),
80        eDIAG_START_Y      = eSCREEN_ACTION_SAFE_Y,
81        eDIAG_HELP_Y       = (eSCREEN_ACTION_SAFE_Y + eSCREEN_ACTION_SAFE_HEIGHT - eDIAG_ROW_HEIGHT),
82        eDIAG_COL_WIDTH    = (eSCREEN_ACTION_SAFE_WIDTH),
83}dbg_layout_t;
84
85typedef enum sys_info_state_t
86{
87        eSYS_CODE_0,
88        eSYS_CODE_1,
89        eSYS_CODE_2,
90        eSYS_CODE_MAX,
91}sys_info_state_t;
92
93typedef struct sys_info_t
94{
95        sys_info_state_t state;
96        unsigned int code;
97}sys_info_t;
98
99static sys_info_t s_sys_info = { eSYS_CODE_0, 0};
100
101static char ts_str[MAX_TSTR_LEN + 1];
102
103
104static char* get_qam_mode_str(btuner_qam_mode mode)
105{
106        switch (mode)
107        {
108        default:
109        case eQAM_16: break;
110        case eQAM_64: return "QAM 64";
111        case eQAM_256: return "QAM 256";
112        }
113        return "?";
114
115}
116
117/*
118Summary:
119        Handle special debug commands for test purposes or diagnostics.
120*/
121
122static void bscreen_sys_info_handler(bapp_t *p_app,bscreen_t *p_screen, bIR_codes_t code)
123{
124        static unsigned int s_timeout = 0;
125        static chm_event_t evt;
126
127        BDBG_WRN(("%s 0x%08x %d\n",__FUNCTION__,s_sys_info.code,s_sys_info.state));
128        if (s_timeout < bos_getticks())
129        {
130                s_sys_info.code = 0;
131                s_sys_info.state = 0;
132        }
133        s_sys_info.code |= (code & 0xFF) << (8 * s_sys_info.state);
134        s_sys_info.state++;
135        BDBG_WRN(("%s 0x%08x %d\n",__FUNCTION__,s_sys_info.code,s_sys_info.state));
136        s_timeout = bos_getticks() + MS_TO_TICKS(BANNER_10_KEY_TIMEOUT);
137#ifdef BCM_DEBUG
138        if (s_sys_info.state == eSYS_CODE_MAX)
139        {
140                switch (s_sys_info.code)
141                {
142                case 0x00030303:
143                        {
144                                bscreen_event_t screen_event;
145                                bapp_reset_settings(p_app);
146                                screen_event.type = eS_EVENT_IR;
147                                screen_event.id = eIR_CHMAP;
148                                bapp_handle_event(p_app, &screen_event);
149                        }       
150                        break;
151                case 0x00010203:
152                        {
153                                bscreen_event_t screen_event;
154                                bapp_reset_settings(p_app);
155                                p_app->settings.psi_scan = 0;
156                                p_app->chm.fe_type = eFREQ_TABLE_NORTH_AMERICA_QAM;
157                                screen_event.type = eS_EVENT_IR;
158                                screen_event.id = eIR_SCAN;
159                                bapp_handle_event(p_app, &screen_event);
160                        }
161                        break;
162                case 0x00040506:
163                        {
164                                bscreen_event_t screen_event;
165                                bapp_reset_settings(p_app);
166                                screen_event.type = eS_EVENT_IR;
167                                screen_event.id = eIR_SETUP;
168                                bapp_handle_event(p_app, &screen_event);
169                        }
170                        break;
171                case 0x00070809:
172                        {
173                                bscreen_event_t screen_event;
174                                bapp_reset_settings(p_app);
175                                p_app->settings.psi_scan = 1;
176#ifdef CONFIG_DVB
177                                p_app->settings.dvb_scan = 0;
178#endif
179                                screen_event.type = eS_EVENT_IR;
180                                screen_event.id = eIR_SCAN;
181                                bapp_handle_event(p_app, &screen_event);
182                        }
183                        break;
184#ifdef CONFIG_DVB
185                case 0x00090807:
186                        {
187                                bscreen_event_t screen_event;
188                                bapp_reset_settings(p_app);
189                                p_app->settings.psi_scan = 1;
190                                p_app->settings.dvb_scan = 1;
191                                screen_event.type = eS_EVENT_IR;
192                                screen_event.id = eIR_SCAN;
193                                bapp_handle_event(p_app, &screen_event);
194                        }
195                        break;
196#endif
197                case 0x00010101:
198                        evt.id = 1;
199                        evt.type = eCHM_EVT_ACTIVATION;
200                        bos_post_event(p_app->msg_queue,(b_event_t*)&evt);
201                        break;
202                case 0x00020101:
203                        evt.id = 0;
204                        evt.type = eCHM_EVT_ACTIVATION;
205                        bos_post_event(p_app->msg_queue,(b_event_t*)&evt);
206                        break;
207                case 0x00010102:
208                        evt.id = 0x1F;
209                        evt.type = eCHM_EVT_LOCATION;
210                        bos_post_event(p_app->msg_queue,(b_event_t*)&evt);
211                        break;
212                case 0x00020102:
213                        evt.id = 0x2E;
214                        evt.type = eCHM_EVT_LOCATION;
215                        bos_post_event(p_app->msg_queue,(b_event_t*)&evt);
216                        break;
217                case 0x00010103:
218                case 0x00020103:
219                case 0x00030103:
220                case 0x00040103:
221                        evt.id = (s_sys_info.code >> 16) & 0xFF;
222                        evt.type = eCHM_EVT_RESET;
223                        bos_post_event(p_app->msg_queue,(b_event_t*)&evt);
224                        break;
225                case 0x00010104:
226                        evt.id = 0;
227                        evt.type = eCHM_EVT_PHONENUMBER;
228                        strcpy(evt.data,"9228188");
229                        bos_post_event(p_app->msg_queue,(b_event_t*)&evt);
230                        break;
231#ifdef  CONFIG_DYNAMIC_RFM_MODE
232                case 0x00010006:        /* 601 */
233                        chm_toggle_comp_mode(&p_app->chm, true);
234                        break;
235#endif
236                case 0x00060606:
237                        evt.id = 0;
238                        evt.type = eCHM_EVT_DOWNLOAD;
239                        bos_post_event(p_app->msg_queue,(b_event_t*)&evt);
240                        break;
241                default:
242                        break;
243                }
244                s_sys_info.state = eSYS_CODE_0;
245                s_sys_info.code = 0;
246        }
247#endif
248}
249/*
250Summary:
251        Return the current DTA mode string.
252*/
253
254static void bscreen_get_dta_mode_str(bapp_t *p_app,
255                                                                         char *p_str     /* On input the max length in words on output the actual size in characters. */
256                                                                        )
257{
258        switch (p_app->state)
259        {
260        case eAPP_STATE_HUNT:
261                strcpy(p_str,"Hunting");
262                break;
263        case eAPP_STATE_PENDING:
264                strcpy(p_str,"Pending");
265                break;
266        case eAPP_STATE_NORMAL:
267                strcpy(p_str,"Normal");
268                break;
269        case eAPP_STATE_DOWNLOAD:
270                strcpy(p_str,"Downloading");
271                break;
272        case eAPP_STATE_FACTORY:
273                strcpy(p_str,"Factory");
274                break;
275        case eAPP_STATE_DEFAULT:
276        case eAPP_STATE_DONE:
277                strcpy(p_str,"Default");
278                break;
279        }
280        if (p_app->settings.av_mute)
281        {
282                strcpy(&(p_str[strlen(p_str)]),"(Standby)");
283        }
284}
285
286/*
287Summary:
288        Return status strings.
289*/
290
291static void bscreen_general_info_str(bapp_t *p_app,
292                                                          bscreen_t *p_screen,
293                                                          int text_id,           /* Text id */
294                                                          unsigned int *p_uni_str,        /* Buffer to put UNI string into */
295                                                          unsigned int *str_len,           /* On input the max length in words on output the actual size in characters. */
296                                                          void *data                            /* User data */
297                                                         )
298{
299        unsigned char hw_address[5];
300        unsigned char mac_address[6];
301        get_hw_address(hw_address);
302        get_mac_address(mac_address);
303        *str_len = 0;
304
305        switch (text_id)
306        {
307        case 0: 
308                strcpy(ts_str,DEF_VENDOR_NAME);
309                *str_len = strlen(ts_str);
310                break;
311        case 1:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X",DEF_VENDOR_ID); break;
312        case 2:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X",DEF_HARDWARE_ID); break;
313        case 3: 
314                if (p_app->settings.CA_System_ID == 0x4749)
315                        *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s",get_unit_address_str()); 
316                else
317                        *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%02X:%02X:%02X:%02X:%02X",hw_address[4],
318                                                 hw_address[3],hw_address[2],hw_address[1],hw_address[0]); 
319                printf("UNIT ADDR:  %s\n",get_unit_address_str());
320               
321                                break;
322        case 4:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%02X:%02X:%02X:%02X:%02X:%02X",mac_address[5],mac_address[4],
323                                                                 mac_address[3],mac_address[2],mac_address[1],mac_address[0]); break;
324
325        }
326        if (*str_len)
327        {
328                *str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
329        }
330}
331
332/*
333Summary:
334        Return status strings.
335*/
336
337static void bscreen_msg_status_str(bapp_t *p_app,
338                                                          bscreen_t *p_screen,
339                                                          int text_id,           /* Text id */
340                                                          unsigned int *p_uni_str,        /* Buffer to put UNI string into */
341                                                          unsigned int *str_len,           /* On input the max length in words on output the actual size in characters. */
342                                                          void *data                            /* User data */
343                                                         )
344{
345        *str_len = 0;
346
347        switch (text_id)
348        {
349        case 0:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"Count"); break;
350        case 1:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.cds_cnt); break;
351        case 2:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.mms_cnt); break;
352        case 3:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.sns_cnt); break;
353        case 4:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.dcm_cnt); break;
354        case 5:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.vcm_cnt); break;
355        case 6:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.stt_cnt); break;
356        case 7:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.ops_cnt); break;
357        case 8:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.cfg_cnt); break;
358        case 9:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.eas_cnt); break;
359        case 10:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.em_cnt); break;
360        case 11:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d/%d",p_app->chm.cat_cnt,p_app->chm.system_id_errors); break;
361        default:
362                *str_len = 0;
363                break;
364        }
365        if (*str_len)
366        {
367                *str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
368        }
369}
370
371/*
372Summary:
373        Return status strings.
374*/
375#if 0
376static void bscreen_code_objects_str(bapp_t *p_app,
377                                                          bscreen_t *p_screen,
378                                                          int text_id,           /* Text id */
379                                                          unsigned int *p_uni_str,        /* Buffer to put UNI string into */
380                                                          unsigned int *str_len,           /* On input the max length in words on output the actual size in characters. */
381                                                          void *data                            /* User data */
382                                                         )
383{
384        *str_len = 0;
385
386        switch (text_id)
387        {
388        case 0: 
389        default:
390                *str_len = 0;
391                break;
392        }
393        if (*str_len)
394        {
395                *str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
396        }
397}
398#endif
399/*
400Summary:
401        Return status strings.
402*/
403
404static void bscreen_code_download_str(bapp_t *p_app,
405                                                          bscreen_t *p_screen,
406                                                          int text_id,           /* Text id */
407                                                          unsigned int *p_uni_str,        /* Buffer to put UNI string into */
408                                                          unsigned int *str_len,           /* On input the max length in words on output the actual size in characters. */
409                                                          void *data                            /* User data */
410                                                         )
411{
412        *str_len = 0;
413
414        switch (text_id)
415        {
416        case 0: 
417        default:
418                *str_len = 0;
419                break;
420        }
421        if (*str_len)
422        {
423                *str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
424        }
425}
426
427/*
428Summary:
429        Return status strings.
430*/
431
432static void bscreen_tuner_status_str(bapp_t *p_app,
433                                                          bscreen_t *p_screen,
434                                                          int text_id,           /* Text id */
435                                                          unsigned int *p_uni_str,        /* Buffer to put UNI string into */
436                                                          unsigned int *str_len,           /* On input the max length in words on output the actual size in characters. */
437                                                          void *data                            /* User data */
438                                                         )
439{
440        unsigned int freq_mhz;
441        unsigned int frac_freq_mhz;
442        vch_t vch;
443        st_t    st;
444        freq_t freq;
445        bool valid, minus;
446        *str_len = 0;
447
448    int fraction;
449
450    /* Get get power level - NEEDS TUNING FOR EACH BOARD DESIGN */
451        power_level = ((int)p_app->power_level);
452        power_level = power_level/256.0;
453   
454        fraction = get_fraction(power_level, &minus);
455        freq_mhz = frac_freq_mhz = 0;
456        valid = ch_map_get_current(bapp_cur_ch_map(p_app),&vch,&st,&freq);
457        if (valid)
458        {
459        freq_mhz = freq.freq_khz/1000;
460        frac_freq_mhz = freq.freq_khz - (freq_mhz * 1000);
461        }
462        else
463        {
464                freq_mhz = p_app->tuned_freq/1000000;
465                frac_freq_mhz = (p_app->tuned_freq / 1000) - (freq_mhz * 1000);
466        }
467
468        switch (text_id)
469        {
470        case 0:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%03d.%03d",freq_mhz,frac_freq_mhz); break;
471        case 1:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%c%d.%01d",(minus ? '-' : ' '), (int)power_level, fraction); break;
472        case 2:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",p_app->snr); break;
473        case 3:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s",(p_app->settings.has_CAT ? "Yes" : "No")); break;
474        case 4:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X",p_app->settings.CA_System_ID); break;
475        case 5:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X",p_app->settings.EMM_PID); break;
476        case 6:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X",p_app->settings.EMM_Provider_ID); break;
477        case 7:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s",(p_app->has_PAT ? "Yes" : "No")); break;
478        case 8:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X",p_app->settings.network_PID); break;
479        default:
480                *str_len = 0;
481                break;
482        }
483        if (*str_len)
484        {
485                *str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
486        }
487}
488/*
489Summary:
490        Return status strings.
491*/
492
493static void bscreen_ch_status_str(bapp_t *p_app,
494                                                          bscreen_t *p_screen,
495                                                          int text_id,           /* Text id */
496                                                          unsigned int *p_uni_str,        /* Buffer to put UNI string into */
497                                                          unsigned int *str_len,           /* On input the max length in words on output the actual size in characters. */
498                                                          void *data                            /* User data */
499                                                         )
500{
501        unsigned int freq_mhz;
502        unsigned int frac_freq_mhz;
503        vch_t vch;
504        st_t    st;
505        freq_t freq;
506        mms_t mms;
507        bool valid;
508        *str_len = 0;
509
510        valid = ch_map_get_current(bapp_cur_ch_map(p_app),&vch,&st,&freq);
511
512        if (valid)
513        {
514        freq_mhz = freq.freq_khz/1000;
515        frac_freq_mhz = freq.freq_khz - (freq_mhz * 1000);
516       
517        ch_map_get_mms(bapp_cur_ch_map(p_app),vch.mms_idx,&mms);
518        }
519        else
520        {
521                freq_mhz = frac_freq_mhz = 0;
522                memset(&vch,0,sizeof(vch));
523                memset(&st,0,sizeof(st));
524                memset(&freq,0,sizeof(freq));
525                memset(&mms,0,sizeof(mms));
526        }
527
528        switch (text_id)
529        {
530        case 0:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",vch.ch_num); break;
531        case 1:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%03d.%03d",freq_mhz,frac_freq_mhz); break;
532        case 2:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s",get_qam_mode_str(mms.modulation)); break;
533        case 3:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",vch.program_num); break;
534        case 4:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X",vch.video_pid); break;
535        case 5:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X%s",vch.audio_pid[0],(vch.cur_audio == 0) ? "*" : " "); break;
536        case 6:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X%s",vch.audio_pid[1],(vch.cur_audio == 1) ? "*" : " "); break;
537        case 7:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X%s",vch.audio_pid[2],(vch.cur_audio == 2) ? "*" : " "); break;
538        case 8:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s",(p_app->audio_mute ? "Yes" : "No")); break;
539        default:
540                *str_len = 0;
541                break;
542        }
543        if (*str_len)
544        {
545                *str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
546        }
547}
548/*
549Summary:
550        Return status strings.
551*/
552static const char *s_mon_str[] =
553{
554        "Jan", "Feb", "Mar", "Apr", "May", "Jun",
555        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
556};
557
558static void bscreen_dta_status_str(bapp_t *p_app,
559                                                          bscreen_t *p_screen,
560                                                          int text_id,           /* Text id */
561                                                          unsigned int *p_uni_str,        /* Buffer to put UNI string into */
562                                                          unsigned int *str_len,           /* On input the max length in words on output the actual size in characters. */
563                                                          void *data                            /* User data */
564                                                         )
565{
566        unsigned int turn_on_freq_mhz;
567        unsigned int frac_turn_on_freq_mhz;
568        int time_offset = p_app->settings.utc_offset;
569        b_tm utc_time;
570
571        *str_len = 0;
572        turn_on_freq_mhz = p_app->settings.turn_on_freq_khz/1000;
573        frac_turn_on_freq_mhz = p_app->settings.turn_on_freq_khz - (turn_on_freq_mhz * 1000);
574       
575        if ((p_app->system_time > p_app->settings.dst_entry) && (p_app->system_time < p_app->settings.dst_exit))
576        {
577                /* TODO Check p_app->settings.dst_delta per spec */
578                time_offset += 3600;
579        }
580        utctime(p_app->system_time + time_offset,&utc_time);
581       
582        switch (text_id)
583        {
584        case 0:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s",p_app->settings.activated ? "Yes" : "No"); break;
585        case 1: 
586                *str_len = MAX_TSTR_LEN;
587                bscreen_get_dta_mode_str(p_app,ts_str); 
588                *str_len = strlen(ts_str);
589                break;
590        case 2:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d.%d",turn_on_freq_mhz,frac_turn_on_freq_mhz); break;
591        case 3:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",p_app->settings.timeout); break;
592        case 4:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",p_app->settings.timeout_cnt); break;
593        case 5:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",p_app->settings.location_errors); break;
594        case 6:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X",p_app->settings.location); break;
595        case 7:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X",p_app->location); break;
596        case 8:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%2d %s %4d %2d:%2d:%2d",
597                                                                 utc_time.tm_mday,s_mon_str[utc_time.tm_mon],utc_time.tm_year + 1980, 
598                                                                 utc_time.tm_hour,utc_time.tm_min,utc_time.tm_sec); break;
599        case 9:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",(int)p_app->settings.utc_offset/3600); break;
600        case 10: 
601                utctime(p_app->settings.dst_entry,&utc_time);
602                *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%2d %s %4d %2d:%2d:%2d",
603                                                                 utc_time.tm_mday,s_mon_str[utc_time.tm_mon],utc_time.tm_year + 1980, 
604                                                                 utc_time.tm_hour,utc_time.tm_min,utc_time.tm_sec);
605                break;
606        case 11: 
607                utctime(p_app->settings.dst_exit,&utc_time);
608                *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%2d %s %4d %2d:%2d:%2d",
609                                                                 utc_time.tm_mday,s_mon_str[utc_time.tm_mon],utc_time.tm_year + 1980, 
610                                                                 utc_time.tm_hour,utc_time.tm_min,utc_time.tm_sec);
611                break;
612        case 12: 
613                utctime(p_app->settings.addressable_time + time_offset,&utc_time);
614                *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%2d %s %4d %2d:%2d:%2d",
615                                                                 utc_time.tm_mday,s_mon_str[utc_time.tm_mon],utc_time.tm_year + 1980, 
616                                                                 utc_time.tm_hour,utc_time.tm_min,utc_time.tm_sec);
617                break;
618        default:
619                *str_len = 0;
620                break;
621        }
622        if (*str_len)
623        {
624                *str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
625        }
626}
627
628/*
629Summary:
630        Use the this function to get a UNI string.
631*/
632unsigned int g_acquire_ticks;
633unsigned int g_tune_ticks;
634
635
636static void bscreen_decoder_status_str(bapp_t *p_app,
637                                                   bscreen_t *p_screen,
638                                                   int text_id,           /* Text id */
639                                                   unsigned int *p_uni_str,        /* Buffer to put UNI string into */
640                                                   unsigned int *str_len,       /* On input the max length in words on output the actual size in characters. */
641                                                   void *data)
642{
643        static bdecode_status status;
644        static baudio_decode_status     audio_status;
645        baudio_decode_config aud_config;
646        bool valid;
647        vch_t vch;
648        st_t    st;
649        freq_t freq;
650        baudio_decode_get_status(p_app->audio, &audio_status);
651        bdecode_get_status(p_app->decode,&status);
652
653        valid = ch_map_get_current(bapp_cur_ch_map(p_app),&vch,&st,&freq);
654        bdecode_get_status(p_app->decode,&status);
655
656        memset(&aud_config, 0, sizeof(aud_config));
657        baudio_decode_get_config(p_app->audio, &aud_config);
658
659        valid = ch_map_get_current(bapp_cur_ch_map(p_app),&vch,&st,&freq);
660
661        switch (text_id)
662        {
663        case 0: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X, 0x%04X, 0x%04X",status.vPID,audio_status.pid,status.pcrPID); break;
664        case 1: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X/0x%08X",status.video_stc,status.video_pts); break;
665        case 2: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X/0x%08X",audio_status.stc,audio_status.pts); break;
666        case 3: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",(int)audio_status.pts - (int)status.video_pts); break;
667        case 4: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d,%d,%d",(int)audio_status.stc-(int)audio_status.pts); break;
668        case 5: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d,%d,%d",(int)status.video_stc-(int)status.video_pts);  break;
669        case 6: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d/%d,%d/%d",audio_status.fifo_depth,audio_status.fifo_size,status.video_fifo_depth,status.video_fifo_size); break;
670        case 7: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d:%d(%s,%d)",status.source_width,status.source_height,(status.bStreamProgressive ? "P" : "I"),status.video_aspect_ratio); break;
671        case 8: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",p_app->tune_ms); break;
672        case 9: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d,%d",TICKS_TO_MS(g_tune_ticks),TICKS_TO_MS(g_acquire_ticks)); break;
673        case 10: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d/%d/%d",p_app->si_ms,TICKS_TO_MS(status.seq_ticks),TICKS_TO_MS(status.first_pts_ticks)); break;
674        case 11: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s", "stereo"); break;
675        default:
676                *str_len = 0;
677                break;
678        }
679
680        if (*str_len)
681        {
682                *str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
683        }
684}
685
686/*
687Summary:
688        Status screen drawing function.
689*/
690static void bscreen_diag_list_draw(bapp_t *p_app, 
691                                                                         bscreen_t *p_screen,
692                                                                         const unsigned char *p_title_str,
693                                                                         const unsigned char *p_label_str[],
694                                                                         get_str_t get_str_fcn,
695                                                                         bool track_selection
696                                                                        )
697{
698        uint16_t x,y,y_off;
699        unsigned int num_chars = 0;
700        bcolor_idx_t text_color;
701        int i;
702
703        x = eINFO_STATUS_X;
704        y = eINFO_STATUS_Y;
705
706        i = 0;
707
708        y += eINFO_ROW_HEIGHT + 6;
709
710        while (*(p_label_str[i]) != '\0')
711        {
712                text_color = eCOLOR_WHITE;
713                y_off = y + (i * eINFO_ROW_HEIGHT);
714                if ((y_off + eINFO_ROW_HEIGHT) >= eHEIGHT)
715                {
716                        BDBG_WRN(("%s too many rows %d, y = %d\n",__FUNCTION__,i,y_off));
717                        break;
718                }
719                bgfx_fill_rect(&p_app->surf,x,y_off,eWIDTH - x,eINFO_ROW_HEIGHT,eCOLOR_BLACK);
720                num_chars = strlen(p_label_str[i]);
721                num_chars = c_to_uni_str((unsigned char*)p_label_str[i],p_app->tmp_str,num_chars);
722
723                if (track_selection && (i == p_screen->local_state))
724                {
725                        text_color = eCOLOR_DK_YELLOW;
726                }
727                text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
728                                 x, y_off, eINFO_COL_LABEL_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, text_color,0);
729
730                num_chars = SCREEN_MAX_STR_WIDTH;
731                get_str_fcn(p_app,p_screen,i,p_app->tmp_str, &num_chars,NULL);
732                text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
733                                 x + eINFO_COL_LABEL_WIDTH, y_off, eWIDTH - x - eINFO_COL_WIDTH, eINFO_ROW_HEIGHT, 
734                                 p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
735                i++;
736        }
737}
738
739/*
740Summary:
741        Status screen drawing function.
742*/
743static void bscreen_diag_draw(bapp_t *p_app, 
744                                                                bscreen_t *p_screen,
745                                                                const unsigned char *p_title_str,
746                                                                const unsigned char *p_help_str,
747                                                                const unsigned char *p_label_str[],
748                                                                get_str_t get_str_fcn,
749                                                                bool track_selection
750                                                           )
751{
752        uint16_t x,y;
753        unsigned int num_chars = 0;
754        int i,page;
755
756        page = p_screen->local_state;
757        x = eINFO_X;
758        y = eINFO_STATUS_Y;
759
760        bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);
761
762        i = 0;
763        bgfx_fill_rect(&p_app->surf,x,y,eWIDTH - x,eINFO_ROW_HEIGHT,eCOLOR_BLACK);
764        num_chars = strlen(p_title_str);
765        num_chars = c_to_uni_str((unsigned char*)p_title_str,p_app->tmp_str,num_chars);
766        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_MED],
767                         x, y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
768
769        bscreen_diag_list_draw(p_app,p_screen,p_title_str,p_label_str,get_str_fcn,track_selection);
770
771        num_chars = strlen(p_help_str);
772        num_chars = c_to_uni_str((unsigned char*)p_help_str,p_app->tmp_str,num_chars);
773        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
774                         x, eINFO_HELP_Y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
775
776}
777
778int bscreen_diag_event(bapp_t *p_app, bscreen_t *p_screen, 
779                                                 bscreen_event_t *p_event,
780                                             void (*draw_fcn)(void *v_app, void *v_screen),
781                                             int refresh)
782{
783        int result = 0;
784        static int cnt = 0;
785
786        switch (p_event->type)
787        {
788        case eS_EVENT_SETUP:
789                p_screen->local_state = 0;
790                bapp_enable_cc(p_app, 0);
791                result = 1;
792                break;
793
794        case eS_EVENT_IDLE:
795                if (refresh <= 0)
796                        break;
797                if (cnt++ == 10)
798                {
799                        cnt = 0;
800                        draw_fcn(p_app,p_screen);
801                        result = 1;
802                }
803                break;
804
805        case eS_EVENT_IR:
806                {
807                        BDBG_WRN(("%s:%d 0x%02x(%s)\n",__FUNCTION__,__LINE__,p_event->id,(p_event->id & 0x40000000) ? "up" : "down"));
808                        switch (p_event->id)
809                        {
810                        case eIR_INFO:
811                                bapp_set_current_screen(p_app, eSCREEN_BANNER, eSCREEN_MAX);
812                                result = 1;
813                                break;
814                        case eIR_PRECH:
815                                bapp_set_current_screen(p_app, eSCREEN_DIAG_MENU, eSCREEN_MAX);
816                                result = 1;
817                                break;
818                        default:
819                                break;
820                        }
821                        break;
822                }
823                break;
824        default:
825                result = bscreen_default_event(p_app,p_screen,p_event);
826                break;
827        }
828        return result; /* always handle event */
829}
830/*
831Summary:
832        Status screen drawing function.
833*/
834void bscreen_sys_info_draw(void *v_app, void *v_screen)
835{
836        bapp_t *p_app = (bapp_t*)v_app;
837        bscreen_t *p_screen = (bscreen_t*)v_screen;
838        bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_GENERAL_INFO],
839                                                (unsigned char *)s_diag_help_simple,s_general_info_str,
840                                                (get_str_t)bscreen_general_info_str,false);
841}
842/*
843Summary:
844        Status screen event handling function.
845*/
846int bscreen_sys_info_event(void *v_app, void *v_screen, 
847                                                   bscreen_event_t *p_event)
848{
849        bapp_t *p_app = (bapp_t*)v_app;
850        bscreen_t *p_screen = (bscreen_t*)v_screen;
851        return bscreen_diag_event(p_app,p_screen,p_event,bscreen_sys_info_draw,-1);
852}
853
854/*
855Summary:
856        Status screen drawing function.
857*/
858void bscreen_dta_status_draw(void *v_app, void *v_screen)
859{
860        bapp_t *p_app = (bapp_t*)v_app;
861        bscreen_t *p_screen = (bscreen_t*)v_screen;
862        bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_DTA_STATUS],
863                                                (unsigned char *)s_diag_help_simple,s_dta_status_str,
864                                                (get_str_t)bscreen_dta_status_str,false);
865}
866/*
867Summary:
868        Status screen event handling function.
869*/
870int bscreen_dta_status_event(void *v_app, void *v_screen, 
871                                                   bscreen_event_t *p_event)
872{
873        bapp_t *p_app = (bapp_t*)v_app;
874        bscreen_t *p_screen = (bscreen_t*)v_screen;
875        return bscreen_diag_event(p_app,p_screen,p_event,bscreen_dta_status_draw,1);
876}
877/*
878Summary:
879        Status screen drawing function.
880*/
881void bscreen_tuner_status_draw(void *v_app, void *v_screen)
882{
883        bapp_t *p_app = (bapp_t*)v_app;
884        bscreen_t *p_screen = (bscreen_t*)v_screen;
885        bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_TUNER_STATUS],
886                                                (unsigned char *)s_diag_help_default,s_tuner_status_str,
887                                                (get_str_t)bscreen_tuner_status_str,false);
888}
889/*
890Summary:
891        Status screen event handling function.
892*/
893int bscreen_tuner_status_event(void *v_app, void *v_screen,
894                                                   bscreen_event_t *p_event)
895{
896        bapp_t *p_app = (bapp_t*)v_app;
897        bscreen_t *p_screen = (bscreen_t*)v_screen;
898        return bscreen_diag_event(p_app,p_screen,p_event,bscreen_tuner_status_draw,1);
899}
900/*
901Summary:
902        Status screen drawing function.
903*/
904void bscreen_decoder_status_draw(void *v_app, void *v_screen)
905{
906        bapp_t *p_app = (bapp_t*)v_app;
907        bscreen_t *p_screen = (bscreen_t*)v_screen;
908        bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_DECODER_STATUS],
909                                                (unsigned char *)s_diag_help_simple,s_decoder_status_str,
910                                                (get_str_t)bscreen_decoder_status_str,false);
911}
912/*
913Summary:
914        Status screen event handling function.
915*/
916int bscreen_decoder_status_event(void *v_app, void *v_screen,
917                                                   bscreen_event_t *p_event)
918{
919        bapp_t *p_app = (bapp_t*)v_app;
920        bscreen_t *p_screen = (bscreen_t*)v_screen;
921        return bscreen_diag_event(p_app,p_screen,p_event,bscreen_decoder_status_draw,1);
922}
923
924/*
925Summary:
926        Status screen drawing function.
927*/
928void bscreen_ch_status_draw(void *v_app, void *v_screen)
929{
930        bapp_t *p_app = (bapp_t*)v_app;
931        bscreen_t *p_screen = (bscreen_t*)v_screen;
932        bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_CH_STATUS],
933                                                (unsigned char *)s_diag_help_in_use,s_ch_status_str,
934                                                (get_str_t)bscreen_ch_status_str,false);
935}
936/*
937Summary:
938        Status screen event handling function.
939*/
940int bscreen_ch_status_event(void *v_app, void *v_screen,
941                                                   bscreen_event_t *p_event)
942{
943        bapp_t *p_app = (bapp_t*)v_app;
944        bscreen_t *p_screen = (bscreen_t*)v_screen;
945        return bscreen_diag_event(p_app,p_screen,p_event,bscreen_ch_status_draw,1);
946}
947
948
949int bscreen_diag_menu_event(void *v_app, void *v_screen, 
950                                                        bscreen_event_t *p_event)
951{
952        bapp_t *p_app = (bapp_t*)v_app;
953        bscreen_t *p_screen = (bscreen_t*)v_screen;
954        int result = 0;
955
956        switch (p_event->type)
957        {
958        case eS_EVENT_SETUP:
959                // Don't reset so we return with same item selectd p_screen->local_state = 0;
960                s_sys_info.state = eSYS_CODE_0;
961                bapp_enable_cc(p_app, 0);
962                bapp_audio_do_mute(p_app, true);
963                result = 1;
964                break;
965        case eS_EVENT_IDLE:
966                {
967                        /* Do anything that requires periodic action here */
968                }
969                break;
970
971        case eS_EVENT_IR:
972                {
973                        BDBG_WRN(("%s:%d 0x%02x(%s)\n",__FUNCTION__,__LINE__,p_event->id,(p_event->id & 0x40000000) ? "up" : "down"));
974                        switch (p_event->id)
975                        {
976                       
977                        case eIR_CH_UP:
978                        case eIR_UP:
979                                p_screen->local_state -= 1;
980                                if ((int)p_screen->local_state <= 0)
981                                        p_screen->local_state = 0;
982                                result = 1;
983                                break;
984                        case eIR_CH_DOWN:
985                        case eIR_DOWN:
986                                p_screen->local_state += 1;
987                                if (p_screen->local_state >= eMM_IDX_NUM)
988                                        p_screen->local_state = eMM_IDX_NUM - 1;
989                                result = 1;
990                                break;
991                        case eIR_SELECT:
992                                switch (p_screen->local_state)
993                                {
994                                case 0:
995                                        bapp_set_current_screen(p_app, eSCREEN_SYS_INFO, eSCREEN_MAX);
996                                        result = 1;
997                                        break;
998                                case 1:
999                                        bapp_set_current_screen(p_app, eSCREEN_DTA_STATUS, eSCREEN_MAX);
1000                                        result = 1;
1001                                        break;
1002                                case 2:
1003                                        bapp_set_current_screen(p_app, eSCREEN_MSO_INFO, eSCREEN_MAX);
1004                                        result = 1;
1005                                        break;
1006                                case 3:
1007                                        bapp_set_current_screen(p_app, eSCREEN_TUNER_STATUS, eSCREEN_MAX);
1008                                        result = 1;
1009                                        break;
1010                                case 4:
1011                                        bapp_set_current_screen(p_app, eSCREEN_CH_STATUS, eSCREEN_MAX);
1012                                        result = 1;
1013                                        break;
1014                                case 5:
1015                                        bapp_set_current_screen(p_app, eSCREEN_CH_MAP_STATUS, eSCREEN_MAX);
1016                                        result = 1;
1017                                        break;
1018                                case 6:
1019                                        bapp_set_current_screen(p_app, eSCREEN_MSG_STATUS, eSCREEN_MAX);
1020                                        result = 1;
1021                                        break;
1022                                case 7:
1023                                        bapp_set_current_screen(p_app, eSCREEN_CODE_OBJECTS, eSCREEN_MAX);
1024                                        result = 1;
1025                                        break;
1026                                case 8:
1027                                        bapp_set_current_screen(p_app, eSCREEN_CODE_DOWNLOAD, eSCREEN_MAX);
1028                                        result = 1;
1029                                        break;
1030                                case 9:
1031                                        bapp_set_current_screen(p_app, eSCREEN_DECODER_STATUS, eSCREEN_MAX);
1032                                        result = 1;
1033                                        break;
1034                                case 10:
1035                                        bapp_set_current_screen(p_app, eSCREEN_VIDEO_FORMAT, eSCREEN_MAX);
1036                                        result = 1;
1037                                        break;
1038                                }
1039                                break;
1040                        case eIR_INFO:
1041                                bapp_set_current_screen(p_app, eSCREEN_BANNER, eSCREEN_MAX);
1042                                result = 1;
1043                                break;
1044                        case eIR_0:
1045                        case eIR_1:
1046                        case eIR_2:
1047                        case eIR_3:
1048                        case eIR_4:
1049                        case eIR_5:
1050                        case eIR_6:
1051                        case eIR_7:
1052                        case eIR_8:
1053                        case eIR_9:
1054                                bscreen_sys_info_handler(p_app,p_screen,p_event->id);
1055                                if (s_sys_info.state == eSYS_CODE_0) {
1056                                        //int a = result;       
1057                                }
1058                                break;
1059                        }
1060                }
1061                break;
1062
1063        default:
1064                result = bscreen_default_event(v_app,v_screen,p_event);
1065                break;
1066        }
1067        return result; /* always handle event */
1068}
1069
1070/*
1071Summary:
1072        Diag menu screen drawing function
1073*/
1074
1075void bscreen_diag_menu_draw(void *v_app, void *v_screen)
1076{
1077        bapp_t *p_app = (bapp_t*)v_app;
1078        bscreen_t *p_screen = (bscreen_t*)v_screen;
1079        unsigned int num_chars;
1080        int yoff,row;
1081
1082        bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);
1083        num_chars = strlen(s_menu_title);
1084        num_chars = c_to_uni_str((unsigned char*)s_menu_title,p_app->tmp_str,num_chars);
1085        yoff = eDIAG_START_Y;
1086        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_MED],
1087                         eDIAG_START_X, yoff, eDIAG_COL_WIDTH, eDIAG_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1088
1089        yoff += 6;
1090
1091        for (row = 0; row < eMM_IDX_NUM; ++row)
1092        {
1093                yoff += eDIAG_ROW_HEIGHT;
1094
1095                if (row == p_screen->local_state)
1096                {
1097                        num_chars = strlen(s_arrow);
1098                        num_chars = c_to_uni_str((unsigned char*)s_arrow,p_app->tmp_str,num_chars);
1099                        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1100                                         eDIAG_START_X, yoff, eDIAG_COL_WIDTH, eDIAG_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1101                }
1102                num_chars = strlen(s_main_menu[row]);
1103                num_chars = c_to_uni_str((unsigned char*)s_main_menu[row],p_app->tmp_str,num_chars);
1104                text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1105                                 eDIAG_MENU_X, yoff, eDIAG_COL_WIDTH, eDIAG_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1106        }
1107        num_chars = strlen(s_menu_help);
1108        num_chars = c_to_uni_str((unsigned char*)s_menu_help,p_app->tmp_str,num_chars);
1109        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1110                         eDIAG_START_X, eDIAG_HELP_Y, eDIAG_COL_WIDTH, eDIAG_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1111}
1112
1113
1114/*
1115Summary:
1116        Diag menu screen drawing function
1117*/
1118void bscreen_mso_info_draw(void *v_app, void *v_screen)
1119{
1120        uint16_t x,y;
1121        unsigned int num_chars = 0;
1122        int i;
1123        bapp_t *p_app = (bapp_t*)v_app;
1124        unsigned char *p_str;
1125        x = eINFO_X;
1126        y = eINFO_STATUS_Y;
1127
1128        bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);
1129        i = 0;
1130        bgfx_fill_rect(&p_app->surf,x,y,eWIDTH - x,eINFO_ROW_HEIGHT,eCOLOR_BLACK);
1131        num_chars = strlen(s_main_menu[eMM_IDX_MSO_INFO]);
1132        num_chars = c_to_uni_str((unsigned char*)s_main_menu[eMM_IDX_MSO_INFO],p_app->tmp_str,num_chars);
1133        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_MED],
1134                         x, y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1135
1136        x = eINFO_STATUS_X;
1137        y += eDIAG_ROW_HEIGHT + 6;
1138
1139        num_chars = strlen(s_mso_info_str);
1140        num_chars = c_to_uni_str((unsigned char*)s_mso_info_str,p_app->tmp_str,num_chars);
1141        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1142                         x, y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1143       
1144        y += eDIAG_ROW_HEIGHT;
1145
1146        p_str = p_app->settings.phonenumber;
1147        num_chars = strlen(p_str);
1148        if (num_chars == 0)
1149                p_str = (unsigned char *)s_800_comcast;
1150        num_chars = strlen(p_str);
1151        num_chars = c_to_uni_str((unsigned char*)p_str,p_app->tmp_str,num_chars);
1152        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1153                         x, y, eSCREEN_ACTION_SAFE_WIDTH, 
1154                         eSCREEN_ACTION_SAFE_HEIGHT - y - eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1155
1156        x = eINFO_X;
1157        num_chars = strlen(s_diag_help_default);
1158        num_chars = c_to_uni_str((unsigned char*)s_diag_help_default,p_app->tmp_str,num_chars);
1159        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1160                         x, eINFO_HELP_Y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1161
1162}
1163/*
1164Summary:
1165        Code download event handler
1166*/
1167int bscreen_mso_info_event(void *v_app, void *v_screen, 
1168                                                   bscreen_event_t *p_event)
1169{
1170        bapp_t *p_app = (bapp_t*)v_app;
1171        bscreen_t *p_screen = (bscreen_t*)v_screen;
1172        return bscreen_diag_event(p_app,p_screen,p_event,bscreen_mso_info_draw,1);
1173}
1174
1175/*
1176Summary:
1177        Diag menu screen drawing function
1178*/
1179void bscreen_msg_status_draw(void *v_app, void *v_screen)
1180{
1181        bapp_t *p_app = (bapp_t*)v_app;
1182        bscreen_t *p_screen = (bscreen_t*)v_screen;
1183        unsigned int num_chars = 0;
1184        int time_offset = p_app->settings.utc_offset;
1185        b_tm utc_time;
1186
1187        if ((p_app->system_time > p_app->settings.dst_entry) && (p_app->system_time < p_app->settings.dst_exit))
1188        {
1189                /* TODO Check p_app->settings.dst_delta per spec */
1190                time_offset += 3600;
1191        }
1192
1193       
1194       
1195        bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_MSG_STATUS],
1196                                                (unsigned char *)s_diag_help_simple,s_msg_status_str,
1197                                                (get_str_t)bscreen_msg_status_str,false);
1198
1199        num_chars = strlen(s_msg_last_addr);
1200        num_chars = c_to_uni_str((unsigned char*)s_msg_last_addr,p_app->tmp_str,num_chars);
1201        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1202                         eINFO_X, eINFO_HELP_Y-(2*eDIAG_ROW_HEIGHT)+8, eSCREEN_ACTION_SAFE_WIDTH/2, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1203       
1204        utctime(p_app->settings.addressable_time + time_offset,&utc_time);
1205        num_chars = snprintf(ts_str,MAX_TSTR_LEN,"%2d %s %4d %2d:%2d:%2d",
1206                                                         utc_time.tm_mday,s_mon_str[utc_time.tm_mon],utc_time.tm_year + 1980, 
1207                                                         utc_time.tm_hour,utc_time.tm_min,utc_time.tm_sec);
1208       
1209        num_chars = c_to_uni_str((unsigned char*)ts_str,p_app->tmp_str,num_chars);
1210        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1211                 eINFO_X + 300, eINFO_HELP_Y-(2*eDIAG_ROW_HEIGHT)+8, eSCREEN_ACTION_SAFE_WIDTH/2, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1212
1213
1214        num_chars = strlen(s_diag_help_msg_1);
1215        num_chars = c_to_uni_str((unsigned char*)s_diag_help_msg_1,p_app->tmp_str,num_chars);
1216        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1217                         eINFO_X, eINFO_HELP_Y-eDIAG_ROW_HEIGHT+4, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1218}
1219/*
1220Summary:
1221        Code download event handler
1222*/
1223int bscreen_msg_status_event(void *v_app, void *v_screen, 
1224                                                         bscreen_event_t *p_event)
1225{
1226        int result = 0;
1227        bapp_t *p_app = (bapp_t*)v_app;
1228        bscreen_t *p_screen = (bscreen_t*)v_screen;
1229
1230        switch (p_event->type)
1231        {
1232        case eS_EVENT_IR:
1233                {
1234                        switch (p_event->id)
1235                        {
1236                        case eIR_0:
1237                                p_app->chm.cds_cnt = p_app->chm.mms_cnt = p_app->chm.sns_cnt = 0;
1238                                p_app->chm.dcm_cnt = p_app->chm.vcm_cnt = p_app->chm.stt_cnt = 0;
1239                                p_app->chm.ops_cnt = p_app->chm.cfg_cnt = p_app->chm.eas_cnt = 0;
1240                                p_app->chm.em_cnt = p_app->chm.cat_cnt = p_app->chm.system_id_errors = 0;
1241                        default:
1242                                result = bscreen_diag_event(p_app,p_screen,p_event,bscreen_msg_status_draw,1);
1243                                break;
1244                        }
1245                        break;
1246                }
1247                break;
1248        default:
1249                result = bscreen_diag_event(p_app,p_screen,p_event,bscreen_msg_status_draw,1);
1250                break;
1251        }
1252        return result; /* always handle event */
1253}
1254/*
1255Summary:
1256        Status screen drawing function.
1257*/
1258void bscreen_code_objects_draw(void *v_app, void *v_screen)
1259{
1260        bapp_t *p_app = (bapp_t*)v_app;
1261        unsigned int num_chars;
1262        int y;
1263
1264        bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);
1265
1266        y = eCH_MAP_START_Y;
1267        num_chars = strlen(s_main_menu[eMM_IDX_CODE_OBJECTS]);
1268        num_chars = c_to_uni_str((unsigned char*)s_main_menu[eMM_IDX_CODE_OBJECTS],p_app->tmp_str,num_chars);
1269        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_MED],
1270                         eINFO_X, eCH_MAP_START_Y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1271       
1272        y += eDIAG_ROW_HEIGHT + 6;
1273        num_chars = strlen(s_code_objects_str);
1274        num_chars = c_to_uni_str((unsigned char*)s_code_objects_str,p_app->tmp_str,num_chars);
1275        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1276                         eINFO_X, y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1277       
1278        y += eDIAG_ROW_HEIGHT;
1279        num_chars = strlen(s_bankA_str);
1280        num_chars = c_to_uni_str((unsigned char*)s_bankA_str,p_app->tmp_str,num_chars);
1281        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1282                         eINFO_X, y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1283       
1284        y += eDIAG_ROW_HEIGHT;
1285        num_chars = strlen(s_bankB_str);
1286        num_chars = c_to_uni_str((unsigned char*)s_bankB_str,p_app->tmp_str,num_chars);
1287        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1288                         eINFO_X, y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1289       
1290        num_chars = strlen(s_diag_help_simple);
1291        num_chars = c_to_uni_str((unsigned char*)s_diag_help_simple,p_app->tmp_str,num_chars);
1292        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1293                         eINFO_X, eINFO_HELP_Y-eDIAG_ROW_HEIGHT, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1294}
1295/*
1296Summary:
1297        Status screen event handling function.
1298*/
1299int bscreen_code_objects_event(void *v_app, void *v_screen, 
1300                                                   bscreen_event_t *p_event)
1301{
1302        bapp_t *p_app = (bapp_t*)v_app;
1303        bscreen_t *p_screen = (bscreen_t*)v_screen;
1304        return bscreen_diag_event(p_app,p_screen,p_event,bscreen_code_objects_draw,-1);
1305}
1306/*
1307Summary:
1308        Status screen drawing function.
1309*/
1310void bscreen_code_download_draw(void *v_app, void *v_screen)
1311{
1312        bapp_t *p_app = (bapp_t*)v_app;
1313        bscreen_t *p_screen = (bscreen_t*)v_screen;
1314        bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_CODE_DOWNLOAD],
1315                                                (unsigned char *)s_diag_help_simple,s_code_download_str,
1316                                                (get_str_t)bscreen_code_download_str,false);
1317}
1318/*
1319Summary:
1320        Status screen event handling function.
1321*/
1322int bscreen_code_download_event(void *v_app, void *v_screen, 
1323                                                   bscreen_event_t *p_event)
1324{
1325        bapp_t *p_app = (bapp_t*)v_app;
1326        bscreen_t *p_screen = (bscreen_t*)v_screen;
1327        return bscreen_diag_event(p_app,p_screen,p_event,bscreen_code_download_draw,1);
1328}
1329
1330int bscreen_ch_map_status_event(void *v_app, void *v_screen, 
1331                                                        bscreen_event_t *p_event)
1332{
1333        bapp_t *p_app = (bapp_t*)v_app;
1334        bscreen_t *p_screen = (bscreen_t*)v_screen;
1335        int result = 0;
1336
1337        switch (p_event->type)
1338        {
1339        case eS_EVENT_SETUP:
1340                p_screen->local_state = 0;
1341                bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);
1342                break;
1343        case eS_EVENT_IDLE:
1344                {
1345                        /* Do anything that requires periodic action here */
1346                }
1347                break;
1348
1349        case eS_EVENT_IR:
1350                {
1351                        BDBG_WRN(("%s:%d 0x%02x(%s)\n",__FUNCTION__,__LINE__,p_event->id,(p_event->id & 0x40000000) ? "up" : "down"));
1352                        switch (p_event->id)
1353                        {
1354                        case eIR_CH_UP:
1355                        case eIR_UP:
1356                                p_screen->local_state -= eCH_MAP_NUM_ROW;
1357                                if ((int)p_screen->local_state < 0)
1358                                        p_screen->local_state = 0;
1359                                result = 1;
1360                                break;
1361                        case eIR_CH_DOWN:
1362                        case eIR_DOWN:
1363                                {
1364                                        unsigned short num_vch;
1365                                        ch_map_get_vch_num(bapp_cur_ch_map(p_app),&num_vch);
1366       
1367                                        if ((p_screen->local_state + eCH_MAP_NUM_ROW) < num_vch)
1368                                        {
1369                                                p_screen->local_state += eCH_MAP_NUM_ROW;
1370                                        }
1371                                        result = 1;
1372                                }
1373                                break;
1374                        case eIR_INFO:
1375                                bapp_set_current_screen(p_app, eSCREEN_BANNER, eSCREEN_MAX);
1376                                result = 1;
1377                                break;
1378                        case eIR_PRECH:
1379                                bapp_set_current_screen(p_app, eSCREEN_DIAG_MENU, eSCREEN_MAX);
1380                                result = 1;
1381                                break;
1382                        }
1383                }
1384                break;
1385
1386        default:
1387                result = bscreen_default_event(v_app,v_screen,p_event);
1388                break;
1389        }
1390        return result; /* always handle event */
1391}
1392
1393/*
1394Summary:
1395        Draw the header row
1396        .
1397*/
1398void bscreen_ch_map_header(bapp_t *p_app, bscreen_t *p_screen)
1399{
1400        unsigned int num_chars;
1401
1402        /* draw titles */
1403        num_chars = c_to_uni_str((unsigned char*)s_ch_map_status_header[0],p_app->tmp_str,strlen(s_ch_map_status_header[0]));
1404        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1405                         eCH_MAP_START_X+ (0*eCH_MAP_COL_WIDTH), eCH_MAP_HDR_Y, eCH_MAP_COL_WIDTH -30, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1406        num_chars = c_to_uni_str((unsigned char*)s_ch_map_status_header[1],p_app->tmp_str,strlen(s_ch_map_status_header[1]));
1407        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1408                         eCH_MAP_START_X + (1*eCH_MAP_COL_WIDTH) -30, eCH_MAP_HDR_Y, eCH_MAP_COL_WIDTH, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1409        num_chars = c_to_uni_str((unsigned char*)s_ch_map_status_header[2],p_app->tmp_str,strlen(s_ch_map_status_header[2]));
1410        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1411                         eCH_MAP_START_X + (2*eCH_MAP_COL_WIDTH) -30, eCH_MAP_HDR_Y, eCH_MAP_COL_WIDTH + 30, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1412        num_chars = c_to_uni_str((unsigned char*)s_ch_map_status_header[3],p_app->tmp_str,strlen(s_ch_map_status_header[3]));
1413        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1414                         eCH_MAP_START_X + (3*eCH_MAP_COL_WIDTH), eCH_MAP_HDR_Y, eCH_MAP_COL_WIDTH, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1415        num_chars = c_to_uni_str((unsigned char*)s_ch_map_status_header[4],p_app->tmp_str,strlen(s_ch_map_status_header[4]));
1416        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1417                         eCH_MAP_START_X + (4*eCH_MAP_COL_WIDTH), eCH_MAP_HDR_Y, eCH_MAP_COL_WIDTH, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1418        num_chars = c_to_uni_str((unsigned char*)s_ch_map_status_header[5],p_app->tmp_str,strlen(s_ch_map_status_header[5]));
1419        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1420                         eCH_MAP_START_X + (5*eCH_MAP_COL_WIDTH), eCH_MAP_HDR_Y, eCH_MAP_COL_WIDTH, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1421}
1422/*
1423Summary:
1424        Draw the row
1425        .
1426*/
1427
1428void bscreen_ch_map_row(bapp_t *p_app, bscreen_t *p_screen, 
1429                                                        vch_t *p_vch,
1430                                                        st_t *p_st,
1431                                                        freq_t *p_freq,
1432                                                        int y)
1433{
1434        unsigned int num_chars;
1435        static char tmp_buf[64];
1436        unsigned int freq_mhz,frac_freq_mhz;
1437        mms_t mms;
1438        freq_mhz = p_freq->freq_khz/1000;
1439        frac_freq_mhz = p_freq->freq_khz - (freq_mhz * 1000);
1440       
1441        /* draw row */
1442        num_chars = snprintf(tmp_buf,64,"%d",p_vch->ch_num);
1443        num_chars = c_to_uni_str(tmp_buf,p_app->tmp_str,num_chars);
1444        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1445                         eCH_MAP_START_X+ (0*eCH_MAP_COL_WIDTH), y, eCH_MAP_COL_WIDTH - 30, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1446        num_chars = snprintf(tmp_buf,64,"%d",p_vch->source_id);
1447        num_chars = c_to_uni_str(tmp_buf,p_app->tmp_str,num_chars);
1448        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1449                         eCH_MAP_START_X+ (1*eCH_MAP_COL_WIDTH) - 30, y, eCH_MAP_COL_WIDTH, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1450        num_chars = snprintf(tmp_buf,64,"%11s",p_st->name);
1451        num_chars = c_to_uni_str(tmp_buf,p_app->tmp_str,num_chars);
1452        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1453                         eCH_MAP_START_X+ (2*eCH_MAP_COL_WIDTH) - 30, y, eCH_MAP_COL_WIDTH + 30, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1454        num_chars = snprintf(tmp_buf,64,"%d.%d",freq_mhz,frac_freq_mhz);
1455        num_chars = c_to_uni_str(tmp_buf,p_app->tmp_str,num_chars);
1456        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1457                         eCH_MAP_START_X+ (3*eCH_MAP_COL_WIDTH), y, eCH_MAP_COL_WIDTH, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1458       
1459        if (ch_map_get_mms(bapp_cur_ch_map(p_app),p_vch->mms_idx,&mms))
1460        {
1461                num_chars = snprintf(tmp_buf,64,"%s",(mms.modulation == eQAM_64) ? "64" : (mms.modulation == eQAM_256) ? "256" : "N/A" );
1462                num_chars = c_to_uni_str(tmp_buf,p_app->tmp_str,num_chars);
1463                text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1464                                 eCH_MAP_START_X+ (4*eCH_MAP_COL_WIDTH), y, eCH_MAP_COL_WIDTH, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1465        }
1466        num_chars = snprintf(tmp_buf,64,"%d",p_vch->program_num);
1467        num_chars = c_to_uni_str(tmp_buf,p_app->tmp_str,num_chars);
1468        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1469                         eCH_MAP_START_X+ (5*eCH_MAP_COL_WIDTH), y, eCH_MAP_COL_WIDTH, eCH_MAP_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1470}
1471
1472/*
1473Summary:
1474        Test screen drawing function
1475        .
1476*/
1477void bscreen_ch_map_status_draw(void *v_app, void *v_screen)
1478{
1479        bapp_t *p_app = (bapp_t*)v_app;
1480        bscreen_t *p_screen = (bscreen_t*)v_screen;
1481        unsigned int num_chars;
1482        unsigned short num_vch;
1483        unsigned char cur_ch;
1484        int idx,yoff,row,page,pages;
1485        vch_t vch;
1486        st_t    st;
1487        freq_t freq;
1488        ch_map_t *p_ch_map = bapp_cur_ch_map(p_app);
1489       
1490       
1491        bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);
1492        ch_map_get_vch_num(bapp_cur_ch_map(p_app),&num_vch);
1493
1494        pages = num_vch/eCH_MAP_NUM_ROW + 1;
1495        page = p_screen->local_state/eCH_MAP_NUM_ROW + 1;
1496
1497        num_chars = snprintf(ts_str,MAX_TSTR_LEN,s_ch_map_status_info,p_app->settings.VCT_ID,num_vch,page,pages);
1498        num_chars = c_to_uni_str((unsigned char*)ts_str,p_app->tmp_str,num_chars);
1499        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1500                         eINFO_X, eCH_MAP_START_Y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1501
1502        bscreen_ch_map_header(p_app,p_screen);
1503
1504        if (!ch_map_get_current(p_ch_map,&vch,&st,&freq))
1505                return;
1506
1507        cur_ch = vch.ch_num; /* save current channel number */
1508        p_ch_map->cur_ch = p_screen->local_state;
1509        idx = p_screen->local_state;
1510        yoff = eCH_MAP_ROW_Y;
1511        for (row = 0; row < eCH_MAP_NUM_ROW; ++row)
1512        {
1513                if (!ch_map_get_current(p_ch_map,&vch,&st,&freq))
1514                        break;
1515                yoff += eCH_MAP_ROW_HEIGHT;
1516
1517                if (idx < num_vch)
1518                {
1519                        bscreen_ch_map_row(p_app,p_screen,&vch,&st,&freq,yoff);
1520                }
1521                idx++;
1522                ch_map_set_next(p_ch_map);
1523        }
1524
1525        num_chars = strlen(s_diag_help_ch_map);
1526        num_chars = c_to_uni_str((unsigned char*)s_diag_help_ch_map,p_app->tmp_str,num_chars);
1527        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1528                         eINFO_X, eINFO_HELP_Y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1529
1530        if (!ch_map_set_ch(p_ch_map,cur_ch))
1531                return;
1532}
1533/*
1534Summary:
1535        Return status strings.
1536*/
1537
1538static void bscreen_video_format_str(bapp_t *p_app,
1539                                                          bscreen_t *p_screen,
1540                                                          int text_id,           /* Text id */
1541                                                          unsigned int *p_uni_str,        /* Buffer to put UNI string into */
1542                                                          unsigned int *str_len,           /* On input the max length in words on output the actual size in characters. */
1543                                                          void *data                            /* User data */
1544                                                         )
1545{
1546        char *ts_str;
1547        bdisplay_settings display_settings;
1548
1549        *str_len = 0;
1550        bdisplay_get(p_app->display,&display_settings);
1551       
1552        if (display_settings.format == text_id)
1553        {
1554                ts_str = "*";
1555        }else
1556        {
1557                ts_str = " ";
1558        }
1559
1560        if (*str_len)
1561        {
1562                *str_len = c_to_uni_str(ts_str,p_uni_str,*str_len);
1563        }
1564}
1565
1566#if 0
1567/*
1568Summary:
1569        Video format screen drawing function.
1570*/
1571void bscreen_video_format_draw(void *v_app, void *v_screen)
1572{
1573        bapp_t *p_app = (bapp_t*)v_app;
1574        bscreen_t *p_screen = (bscreen_t*)v_screen;
1575        bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_VIDEO_FORMAT],
1576                                                (unsigned char *)s_video_format_help,s_video_format_str,
1577                                                bscreen_video_format_str,true);
1578}
1579/*
1580Summary:
1581        Video format screen event handling function.
1582*/
1583int bscreen_video_format_event(void *v_app, void *v_screen,
1584                                                   bscreen_event_t *p_event)
1585{
1586        bapp_t *p_app = (bapp_t*)v_app;
1587        bscreen_t *p_screen = (bscreen_t*)v_screen;
1588        bdisplay_settings display_settings;
1589        int result = 0;
1590
1591        switch (p_event->type)
1592        {
1593        case eS_EVENT_SETUP:
1594                bdisplay_get(p_app->display,&display_settings);
1595                BDBG_WRN(("%s:%d last_screen_id = %d, s_confirm_change = %d\n",__FUNCTION__,__LINE__,p_screen->last_screen_id,s_confirm_change));
1596                if ((p_screen->last_screen_id == eSCREEN_CONFIRM_CHANGE) && (!s_confirm_change))
1597                {
1598                        BDBG_WRN(("%s:%d RESET VIDEO OUTPUT FORMAT FROM %d to %d\n",__FUNCTION__,__LINE__,display_settings.format,s_temp_format));
1599
1600                        display_settings.format = s_temp_format;
1601                        if (bdisplay_set(p_app->display,&display_settings) != b_ok)
1602                        {
1603                                s_confirm_change = false;
1604                                BDBG_WRN(("%s:%d RESET VIDEO OUTPUT FORMAT from %d to %d FAILED\n",__FUNCTION__,__LINE__,display_settings.format,s_temp_format));
1605                        }
1606                }
1607                p_screen->local_state = display_settings.format;
1608                result = 1;
1609                break;
1610        case eS_EVENT_IDLE:
1611                {
1612                        /* Do anything that requires periodic action here */
1613                }
1614                break;
1615
1616        case eS_EVENT_IR:
1617                {
1618                        BDBG_WRN(("%s:%d 0x%02x(%s)\n",__FUNCTION__,__LINE__,p_event->id,(p_event->id & 0x40000000) ? "up" : "down"));
1619                        switch (p_event->id)
1620                        {
1621                        case eIR_CH_UP:
1622                        case eIR_UP:
1623                                p_screen->local_state--;
1624                                if ((int)p_screen->local_state < 0)
1625                                        p_screen->local_state = 0;
1626                                result = 1;
1627                                break;
1628                        case eIR_CH_DOWN:
1629                        case eIR_DOWN:
1630                                {       
1631                                        p_screen->local_state++;
1632                                        if (p_screen->local_state > bdisplay_format_1080i)
1633                                        {
1634                                                p_screen->local_state = 0;
1635                                        }
1636                                        result = 1;
1637                                }
1638                                break;
1639                        case eIR_SELECT:
1640                        case eIR_ENTER:
1641                                {
1642                                        bdisplay_get(p_app->display,&display_settings);
1643                                        s_temp_format = display_settings.format;
1644
1645                                        if (display_settings.format == p_screen->local_state)
1646                                                break;
1647
1648                                        display_settings.format = p_screen->local_state;
1649                                        if (bdisplay_set(p_app->display,&display_settings) == b_ok)
1650                                        {
1651                                                s_confirm_change = false;
1652                                                p_screen->last_screen_id = eSCREEN_CONFIRM_CHANGE;
1653                                                bapp_set_current_screen(p_app, eSCREEN_CONFIRM_CHANGE, eSCREEN_MAX);
1654                                        }
1655                                        result = 1;
1656                                }
1657                                break;
1658                        case eIR_PRECH:
1659                                bapp_set_current_screen(p_app, eSCREEN_DIAG_MENU, eSCREEN_MAX);
1660                                result = 1;
1661                                break;
1662                        }
1663                }
1664                break;
1665
1666        default:
1667                result = bscreen_default_event(v_app,v_screen,p_event);
1668                break;
1669        }
1670        return result; /* always handle event */
1671}
1672/*
1673Summary:
1674        Status screen drawing function.
1675*/
1676void bscreen_confirm_change_draw(void *v_app, void *v_screen)
1677{
1678        bapp_t *p_app = (bapp_t*)v_app;
1679        bscreen_t *p_screen = (bscreen_t*)v_screen;
1680        bscreen_diag_draw(p_app,p_screen,s_confirm_change_title,
1681                                                (unsigned char *)s_confirm_change_help,s_confirm_change_str,
1682                                                bscreen_code_download_str,true);
1683}
1684/*
1685Summary:
1686        Status screen event handling function.
1687*/
1688int bscreen_confirm_change_event(void *v_app, void *v_screen,
1689                                                   bscreen_event_t *p_event)
1690{
1691        bapp_t *p_app = (bapp_t*)v_app;
1692        bscreen_t *p_screen = (bscreen_t*)v_screen;
1693        int result = 0;
1694        static unsigned int s_timeout_ticks;
1695
1696        switch (p_event->type)
1697        {
1698        case eS_EVENT_SETUP:
1699                p_screen->local_state = 1;
1700                s_timeout_ticks = bos_getticks() + CONFIRM_TIMEOUT_TICKS;
1701                result = 1;
1702                break;
1703        case eS_EVENT_IDLE:
1704                {
1705                        /* Do anything that requires periodic action here */
1706                        if (s_timeout_ticks < bos_getticks())
1707                        {
1708                                BDBG_WRN(("%s:%d CONFIRM_CHANGE TIMEOUT\n",__FUNCTION__,__LINE__));
1709
1710                                s_confirm_change = false;
1711                                bapp_goto_last_screen(p_app);
1712                                result = 1;
1713                        }
1714                }
1715                break;
1716
1717        case eS_EVENT_IR:
1718                {
1719                        BDBG_WRN(("%s:%d 0x%02x(%s)\n",__FUNCTION__,__LINE__,p_event->id,(p_event->id & 0x40000000) ? "up" : "down"));
1720                        switch (p_event->id)
1721                        {
1722                        case eIR_CH_UP:
1723                        case eIR_UP:
1724                                p_screen->local_state--;
1725                                if ((int)p_screen->local_state < 0)
1726                                        p_screen->local_state = 0;
1727                                result = 1;
1728                                break;
1729                        case eIR_CH_DOWN:
1730                        case eIR_DOWN:
1731                                {       
1732                                        p_screen->local_state++;
1733                                        if (p_screen->local_state > 1)
1734                                        {
1735                                                p_screen->local_state = 0;
1736                                        }
1737                                        result = 1;
1738                                }
1739                                break;
1740                        case eIR_SELECT:
1741                        case eIR_ENTER:
1742                                {
1743                                        s_confirm_change = (p_screen->local_state == 0) ? true : false;
1744                                        bapp_goto_last_screen(p_app);
1745                                        result = 1;
1746                                }
1747                                break;
1748                        case eIR_PRECH:
1749                                s_confirm_change = false;
1750                                bapp_goto_last_screen(p_app);
1751                                result = 1;
1752                                break;
1753                        }
1754                }
1755                break;
1756
1757        default:
1758                result = bscreen_default_event(v_app,v_screen,p_event);
1759                break;
1760        }
1761        return result; /* always handle event */
1762}
1763#endif
Note: See TracBrowser for help on using the repository browser.