source: svn/newcon3bcm2_21bu/nexus/app/dta/bscreen_status.c

Last change on this file was 76, checked in by megakiss, 10 years ago

1W 대기전력을 만족시키기 위하여 POWEROFF시 튜너를 Standby 상태로 함
  • Property svn:executable set to *
File size: 46.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 "bapp_util.h"
24#include "bapp_palette.h"
25#include "bgfx.h"
26#include "chan_mgr.h"
27#include "bscreen_status_str.c"
28#include "si_nit_mms.h"
29BDBG_MODULE(bscreen_status);             /* Register software module with debug interface */
30
31static float power_level = 0.0;
32
33int get_fraction(float val, bool *minus)
34{
35    int i;
36    *minus = 0;
37
38    if (val >= 0.0) {
39        i = (val - (int)val) * 100;
40    }
41    else if (val >= -1.0) {
42        i = 100 - ((1.0 - (int)val) + val) * 100;
43        *minus = 1;
44    }
45    else {
46        i = 100 - ((1.0 - (int)val) + val) * 100;
47    }
48    return i;
49}
50
51#define MAX_TSTR_LEN    128
52#define eINFO_X                    (eSCREEN_ACTION_SAFE_X)
53#define eINFO_STATUS_X     (eSCREEN_ACTION_SAFE_X + 20)
54#define eINFO_STATUS_Y     (eSCREEN_ACTION_SAFE_Y)
55#define eINFO_COL_WIDTH    (eSCREEN_ACTION_SAFE_WIDTH/2)
56#define eINFO_COL_LABEL_WIDTH  (eINFO_COL_WIDTH)
57#define eINFO_ROW_HEIGHT   (24)
58#define eINFO_HELP_Y       ((eSCREEN_ACTION_SAFE_HEIGHT + eSCREEN_ACTION_SAFE_Y - eINFO_ROW_HEIGHT))
59#define eCH_MAP_START_X    (eSCREEN_ACTION_SAFE_X)
60#define eCH_MAP_START_Y    (eSCREEN_ACTION_SAFE_Y)
61#define eCH_MAP_HDR_Y      ((eSCREEN_ACTION_SAFE_Y + eINFO_ROW_HEIGHT))
62#define eCH_MAP_ROW_Y      (eCH_MAP_HDR_Y)
63#define eCH_MAP_COL_WIDTH  ((eSCREEN_ACTION_SAFE_WIDTH/6))
64#define eCH_MAP_ROW_HEIGHT (24)
65#define eCH_MAP_NUM_ROW    ((((eSCREEN_ACTION_SAFE_HEIGHT - 3*eINFO_ROW_HEIGHT)/eCH_MAP_ROW_HEIGHT) - 1))
66#define eDIAG_ROW_HEIGHT   (24)
67#define eDIAG_START_X      (eSCREEN_ACTION_SAFE_X)
68#define eDIAG_MENU_X       ((eDIAG_START_X + 20))
69#define eDIAG_START_Y      (eSCREEN_ACTION_SAFE_Y)
70#define eDIAG_HELP_Y       ((eSCREEN_ACTION_SAFE_Y + eSCREEN_ACTION_SAFE_HEIGHT - eDIAG_ROW_HEIGHT))
71#define eDIAG_COL_WIDTH    ((eSCREEN_ACTION_SAFE_WIDTH))
72
73typedef enum sys_info_state_t
74{
75        eSYS_CODE_0,
76        eSYS_CODE_1,
77        eSYS_CODE_2,
78        eSYS_CODE_MAX,
79}sys_info_state_t;
80
81typedef struct sys_info_t
82{
83        sys_info_state_t state;
84        unsigned int code;
85}sys_info_t;
86
87static sys_info_t s_sys_info = { eSYS_CODE_0, 0};
88
89static char ts_str[MAX_TSTR_LEN + 1];
90
91
92typedef void (*get_str_t)(bapp_t *p_app,
93                                                  bscreen_t *p_screen,
94                                                  int text_id,           /* Text id */
95                                                  unsigned int *p_uni_str,        /* Buffer to put UNI string into */
96                                                  unsigned int *str_len,           /* On input the max length in words on output the actual size in characters. */
97                                                  void *data                            /* User data */
98                                                 );
99
100
101static char* get_qam_mode_str(int mode)
102{
103        switch (mode)
104        {
105        default:
106        case MOD_QAM16: break;
107        case MOD_QAM64: return "QAM 64";
108        case MOD_QAM256: return "QAM 256";
109        }
110        return "?";
111
112}
113
114/*
115Summary:
116        Handle special debug commands for test purposes or diagnostics.
117*/
118
119static void bscreen_sys_info_handler(bapp_t *p_app,bscreen_t *p_screen, bIR_codes_t code)
120{
121        static unsigned int s_timeout = 0;
122        static chm_event_t evt;
123
124        BDBG_WRN(("%s 0x%08x %d\n",__FUNCTION__,s_sys_info.code,s_sys_info.state));
125        if (s_timeout < bapp_task_getticks())
126        {
127                s_sys_info.code = 0;
128                s_sys_info.state = 0;
129        }
130        s_sys_info.code |= (code & 0xFF) << (8 * s_sys_info.state);
131        s_sys_info.state++;
132        BDBG_WRN(("%s 0x%08x %d\n",__FUNCTION__,s_sys_info.code,s_sys_info.state));
133        s_timeout = bapp_task_getticks() + MS_TO_TICKS(BANNER_10_KEY_TIMEOUT);
134
135        if (s_sys_info.state == eSYS_CODE_MAX)
136        {
137                switch (s_sys_info.code)
138                {
139                case 0x00030303:
140                        /* JPF TODO */
141                        break;
142                case 0x00010203:
143                        bapp_reset_settings(p_app);
144                        /* JPF TODO */
145                        break;
146                case 0x00040506:
147                        bapp_reset_settings(p_app);
148                        /* JPF TODO */
149                        break;
150                case 0x00070809:
151                        bapp_reset_settings(p_app);
152                        p_app->settings.psi_scan = 1;
153                        /* JPF TODO */
154                        break;
155                case 0x00010101:
156                        evt.id = 1;
157                        evt.type = eCHM_EVT_ACTIVATION;
158                        bapp_task_post_event(p_app->msg_queue,(bapp_task_event_t)&evt);
159                        break;
160                case 0x00020101:
161                        evt.id = 0;
162                        evt.type = eCHM_EVT_ACTIVATION;
163                        bapp_task_post_event(p_app->msg_queue,(bapp_task_event_t)&evt);
164                        break;
165                case 0x00010102:
166                        evt.id = 0x1F;
167                        evt.type = eCHM_EVT_LOCATION;
168                        bapp_task_post_event(p_app->msg_queue,(bapp_task_event_t)&evt);
169                        break;
170                case 0x00020102:
171                        evt.id = 0x2E;
172                        evt.type = eCHM_EVT_LOCATION;
173                        bapp_task_post_event(p_app->msg_queue,(bapp_task_event_t)&evt);
174                        break;
175                case 0x00010103:
176                case 0x00020103:
177                case 0x00030103:
178                case 0x00040103:
179                        evt.id = (s_sys_info.code >> 16) & 0xFF;
180                        evt.type = eCHM_EVT_RESET;
181                        bapp_task_post_event(p_app->msg_queue,(bapp_task_event_t)&evt);
182                        break;
183                case 0x00010104:
184                        evt.id = 0;
185                        evt.type = eCHM_EVT_PHONENUMBER;
186                        strcpy(evt.data,"9228188");
187                        bapp_task_post_event(p_app->msg_queue,(bapp_task_event_t)&evt);
188                        break;
189#ifdef  CONFIG_DYNAMIC_RFM_MODE
190                case 0x00010006:        /* 601 */
191                        chm_toggle_comp_mode(&p_app->chm, true);
192                        break;
193#endif
194                case 0x00060606:
195                        evt.id = 0;
196                        evt.type = eCHM_EVT_DOWNLOAD;
197                        bapp_task_post_event(p_app->msg_queue,(bapp_task_event_t)&evt);
198                        break;
199                default:
200                        break;
201                }
202                s_sys_info.state = eSYS_CODE_0;
203                s_sys_info.code = 0;
204        }
205}
206/*
207Summary:
208        Return the current DTA mode string.
209*/
210
211static void bscreen_get_dta_mode_str(bapp_t *p_app,
212                                                                         char *p_str     /* On input the max length in words on output the actual size in characters. */
213                                                                        )
214{
215        switch (p_app->state)
216        {
217        case eAPP_STATE_HUNT:
218                strcpy(p_str,"Hunting");
219                break;
220        case eAPP_STATE_PENDING:
221                strcpy(p_str,"Pending");
222                break;
223        case eAPP_STATE_NORMAL:
224                strcpy(p_str,"Normal");
225                break;
226        case eAPP_STATE_DOWNLOAD:
227                strcpy(p_str,"Downloading");
228                break;
229        case eAPP_STATE_FACTORY:
230                strcpy(p_str,"Factory");
231                break;
232        case eAPP_STATE_DEFAULT:
233        case eAPP_STATE_DONE:
234                strcpy(p_str,"Default");
235                break;
236        }
237        if (p_app->settings.av_mute)
238        {
239                strcpy(&(p_str[bapp_util_strlen(p_str)]),"(Standby)");
240        }
241}
242
243/*
244Summary:
245        Return status strings.
246*/
247
248static void bscreen_general_info_str(bapp_t *p_app,
249                                                          bscreen_t *p_screen,
250                                                          int text_id,           /* Text id */
251                                                          unsigned int *p_uni_str,        /* Buffer to put UNI string into */
252                                                          unsigned int *str_len,           /* On input the max length in words on output the actual size in characters. */
253                                                          void *data                            /* User data */
254                                                         )
255{
256        vch_t vch;
257        st_t    st;
258        freq_t freq;
259        bool valid;
260        unsigned char hw_address[5];
261        unsigned char mac_address[6];
262
263        valid = ch_map_get_current(bapp_cur_ch_map(p_app),&vch,&st,&freq);
264        get_hw_address(hw_address);
265        get_mac_address(mac_address);
266        *str_len = 0;
267
268        switch (text_id)
269        {
270        case 0: 
271                strcpy(ts_str,DEF_VENDOR_NAME);
272                *str_len = bapp_util_strlen(ts_str);
273                break;
274        case 1:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X",DEF_VENDOR_ID); break;
275        case 2:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X",DEF_HARDWARE_ID); break;
276        case 3: 
277                if (p_app->settings.CA_System_ID == 0x4749)
278                        *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s",get_unit_address_str()); 
279                else
280                        *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%02X:%02X:%02X:%02X:%02X",hw_address[4],
281                                                 hw_address[3],hw_address[2],hw_address[1],hw_address[0]); 
282                printf("UNIT ADDR:  %s\n",get_unit_address_str());
283               
284                                break;
285        case 4:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%02X:%02X:%02X:%02X:%02X:%02X",mac_address[5],mac_address[4],
286                                                                 mac_address[3],mac_address[2],mac_address[1],mac_address[0]); break;
287
288        }
289        if (*str_len)
290        {
291                *str_len = c_to_uni_str((unsigned char*)ts_str,p_uni_str,*str_len);
292        }
293}
294
295/*
296Summary:
297        Return status strings.
298*/
299
300static void bscreen_msg_status_str(bapp_t *p_app,
301                                                          bscreen_t *p_screen,
302                                                          int text_id,           /* Text id */
303                                                          unsigned int *p_uni_str,        /* Buffer to put UNI string into */
304                                                          unsigned int *str_len,           /* On input the max length in words on output the actual size in characters. */
305                                                          void *data                            /* User data */
306                                                         )
307{
308        *str_len = 0;
309
310        switch (text_id)
311        {
312        case 0:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"Count"); break;
313        case 1:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.cds_cnt); break;
314        case 2:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.mms_cnt); break;
315        case 3:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.sns_cnt); break;
316        case 4:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.dcm_cnt); break;
317        case 5:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.vcm_cnt); break;
318        case 6:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.stt_cnt); break;
319        case 7:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.ops_cnt); break;
320        case 8:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.cfg_cnt); break;
321        case 9:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.eas_cnt); break;
322        case 10:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d",p_app->chm.em_cnt); break;
323        case 11:  *str_len = snprintf(ts_str,MAX_TSTR_LEN," %d/%d",p_app->chm.cat_cnt,p_app->chm.system_id_errors); break;
324        default:
325                *str_len = 0;
326                break;
327        }
328        if (*str_len)
329        {
330                *str_len = c_to_uni_str((unsigned char*)ts_str,p_uni_str,*str_len);
331        }
332}
333
334/*
335Summary:
336        Return status strings.
337*/
338
339static void bscreen_code_objects_str(bapp_t *p_app,
340                                                          bscreen_t *p_screen,
341                                                          int text_id,           /* Text id */
342                                                          unsigned int *p_uni_str,        /* Buffer to put UNI string into */
343                                                          unsigned int *str_len,           /* On input the max length in words on output the actual size in characters. */
344                                                          void *data                            /* User data */
345                                                         )
346{
347        *str_len = 0;
348
349        switch (text_id)
350        {
351        case 0: 
352        default:
353                *str_len = 0;
354                break;
355        }
356        if (*str_len)
357        {
358                *str_len = c_to_uni_str((unsigned char*)ts_str,p_uni_str,*str_len);
359        }
360}
361
362/*
363Summary:
364        Return status strings.
365*/
366
367static void bscreen_code_download_str(bapp_t *p_app,
368                                                          bscreen_t *p_screen,
369                                                          int text_id,           /* Text id */
370                                                          unsigned int *p_uni_str,        /* Buffer to put UNI string into */
371                                                          unsigned int *str_len,           /* On input the max length in words on output the actual size in characters. */
372                                                          void *data                            /* User data */
373                                                         )
374{
375        *str_len = 0;
376
377        switch (text_id)
378        {
379        case 0: 
380        default:
381                *str_len = 0;
382                break;
383        }
384        if (*str_len)
385        {
386                *str_len = c_to_uni_str((unsigned char*)ts_str,p_uni_str,*str_len);
387        }
388}
389
390/*
391Summary:
392        Return status strings.
393*/
394
395static void bscreen_tuner_status_str(bapp_t *p_app,
396                                                          bscreen_t *p_screen,
397                                                          int text_id,           /* Text id */
398                                                          unsigned int *p_uni_str,        /* Buffer to put UNI string into */
399                                                          unsigned int *str_len,           /* On input the max length in words on output the actual size in characters. */
400                                                          void *data                            /* User data */
401                                                         )
402{
403        unsigned int freq_mhz;
404        unsigned int frac_freq_mhz;
405        vch_t vch;
406        st_t    st;
407        freq_t freq;
408        bool valid, minus;
409    int fraction;
410       
411        *str_len = 0;
412
413        power_level = p_app->power;
414   
415        fraction = get_fraction(power_level, &minus);
416
417        valid = ch_map_get_current(bapp_cur_ch_map(p_app),&vch,&st,&freq);
418        freq_mhz = freq.freq_khz/1000;
419        frac_freq_mhz = freq.freq_khz - (freq_mhz * 1000);
420
421        switch (text_id)
422        {
423        case 0:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d.%d",freq_mhz,frac_freq_mhz); break;
424        case 1: 
425                if (p_app->snr)
426                        *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d dBmV", (int)power_level);
427                else
428                        *str_len = snprintf(ts_str,MAX_TSTR_LEN,"Not locked");
429                break;
430        case 2:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",p_app->snr); break;
431        case 3:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s",(p_app->settings.has_CAT ? "Yes" : "No")); break;
432        case 4:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X",p_app->settings.CA_System_ID); break;
433        case 5:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X",p_app->settings.EMM_PID); break;
434        case 6:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X",p_app->settings.EMM_Provider_ID); break;
435        case 7:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s",(p_app->has_PAT ? "Yes" : "No")); break;
436        case 8:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X",p_app->settings.network_PID); break;
437        default:
438                *str_len = 0;
439                break;
440        }
441        if (*str_len)
442        {
443                *str_len = c_to_uni_str((unsigned char*)ts_str,p_uni_str,*str_len);
444        }
445}
446/*
447Summary:
448        Return status strings.
449*/
450
451static void bscreen_ch_status_str(bapp_t *p_app,
452                                                          bscreen_t *p_screen,
453                                                          int text_id,           /* Text id */
454                                                          unsigned int *p_uni_str,        /* Buffer to put UNI string into */
455                                                          unsigned int *str_len,           /* On input the max length in words on output the actual size in characters. */
456                                                          void *data                            /* User data */
457                                                         )
458{
459        unsigned int freq_mhz;
460        unsigned int frac_freq_mhz;
461        vch_t vch;
462        st_t    st;
463        freq_t freq;
464        mms_t mms;
465        bool valid;
466        *str_len = 0;
467
468        valid = ch_map_get_current(bapp_cur_ch_map(p_app),&vch,&st,&freq);
469        freq_mhz = freq.freq_khz/1000;
470        frac_freq_mhz = freq.freq_khz - (freq_mhz * 1000);
471       
472        if ((!valid) && (text_id < 8))
473                return;
474
475        ch_map_get_mms(bapp_cur_ch_map(p_app),vch.mms_idx,&mms);
476
477        switch (text_id)
478        {
479        case 0:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",vch.ch_num); break;
480        case 1:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d.%d",freq_mhz,frac_freq_mhz); break;
481        case 2:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s",get_qam_mode_str(mms.modulation)); break;
482        case 3:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",vch.program_num); break;
483        case 4:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X",vch.video_pid); break;
484        case 5:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X%s",vch.audio_pid[0],(vch.cur_audio == 0) ? "*" : " "); break;
485        case 6:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X%s",vch.audio_pid[1],(vch.cur_audio == 1) ? "*" : " "); break;
486        case 7:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X%s",vch.audio_pid[2],(vch.cur_audio == 2) ? "*" : " "); break;
487        case 8:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s",(p_app->audio_mute ? "Yes" : "No")); break;
488        default:
489                *str_len = 0;
490                break;
491        }
492        if (*str_len)
493        {
494                *str_len = c_to_uni_str((unsigned char*)ts_str,p_uni_str,*str_len);
495        }
496}
497/*
498Summary:
499        Return status strings.
500*/
501static const char *s_mon_str[] =
502{
503        "Jan", "Feb", "Mar", "Apr", "May", "Jun",
504        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
505};
506
507static void bscreen_dta_status_str(bapp_t *p_app,
508                                                          bscreen_t *p_screen,
509                                                          int text_id,           /* Text id */
510                                                          unsigned int *p_uni_str,        /* Buffer to put UNI string into */
511                                                          unsigned int *str_len,           /* On input the max length in words on output the actual size in characters. */
512                                                          void *data                            /* User data */
513                                                         )
514{
515        unsigned int turn_on_freq_mhz;
516        unsigned int frac_turn_on_freq_mhz;
517        int time_offset = p_app->settings.utc_offset;
518        struct tm utc_time;
519
520        *str_len = 0;
521        turn_on_freq_mhz = p_app->settings.turn_on_freq_khz/1000;
522        frac_turn_on_freq_mhz = p_app->settings.turn_on_freq_khz - (turn_on_freq_mhz * 1000);
523       
524        if ((p_app->system_time > p_app->settings.dst_entry) && (p_app->system_time < p_app->settings.dst_exit))
525        {
526                /* TODO Check p_app->settings.dst_delta per spec */
527                time_offset += 3600;
528        }
529        utctime(p_app->system_time + time_offset,&utc_time);
530       
531        switch (text_id)
532        {
533        case 0:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s",p_app->settings.activated ? "Yes" : "No"); break;
534        case 1: 
535                *str_len = MAX_TSTR_LEN;
536                bscreen_get_dta_mode_str(p_app,ts_str); 
537                *str_len = bapp_util_strlen(ts_str);
538                break;
539        case 2:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d.%d",turn_on_freq_mhz,frac_turn_on_freq_mhz); break;
540        case 3:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",p_app->settings.timeout); break;
541        case 4:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",p_app->settings.timeout_cnt); break;
542        case 5:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",p_app->settings.location_errors); break;
543        case 6:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X",p_app->settings.location); break;
544        case 7:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X",p_app->location); break;
545        case 8:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%2d %s %4d %2d:%2d:%2d",
546                                                                 utc_time.tm_mday,s_mon_str[utc_time.tm_mon],utc_time.tm_year + 1980, 
547                                                                 utc_time.tm_hour,utc_time.tm_min,utc_time.tm_sec); break;
548        case 9:  *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",(int)p_app->settings.utc_offset/3600); break;
549        case 10: 
550                utctime(p_app->settings.dst_entry,&utc_time);
551                *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%2d %s %4d %2d:%2d:%2d",
552                                                                 utc_time.tm_mday,s_mon_str[utc_time.tm_mon],utc_time.tm_year + 1980, 
553                                                                 utc_time.tm_hour,utc_time.tm_min,utc_time.tm_sec);
554                break;
555        case 11: 
556                utctime(p_app->settings.dst_exit,&utc_time);
557                *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%2d %s %4d %2d:%2d:%2d",
558                                                                 utc_time.tm_mday,s_mon_str[utc_time.tm_mon],utc_time.tm_year + 1980, 
559                                                                 utc_time.tm_hour,utc_time.tm_min,utc_time.tm_sec);
560                break;
561        case 12: 
562                utctime(p_app->settings.addressable_time + time_offset,&utc_time);
563                *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%2d %s %4d %2d:%2d:%2d",
564                                                                 utc_time.tm_mday,s_mon_str[utc_time.tm_mon],utc_time.tm_year + 1980, 
565                                                                 utc_time.tm_hour,utc_time.tm_min,utc_time.tm_sec);
566                break;
567        default:
568                *str_len = 0;
569                break;
570        }
571        if (*str_len)
572        {
573                *str_len = c_to_uni_str((unsigned char*)ts_str,p_uni_str,*str_len);
574        }
575}
576
577/*
578Summary:
579        Use the this function to get a UNI string.
580*/
581#if defined(RAM_BUILD)
582extern unsigned int g_acquire_ticks;
583extern unsigned int g_tune_ticks;
584#else
585unsigned int g_acquire_ticks = 0;
586unsigned int g_tune_ticks = 0;
587#endif
588
589
590static void bscreen_decoder_status_str(bapp_t *p_app,
591                                                   bscreen_t *p_screen,
592                                                   int text_id,           /* Text id */
593                                                   unsigned int *p_uni_str,        /* Buffer to put UNI string into */
594                                                   unsigned int *str_len,       /* On input the max length in words on output the actual size in characters. */
595                                                   void *data)
596{
597        bool valid;
598        vch_t vch;
599        st_t    st;
600        freq_t freq;
601
602        valid = ch_map_get_current(bapp_cur_ch_map(p_app),&vch,&st,&freq);
603
604        switch (text_id)
605        {
606#if 0
607        case 0: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%04X, 0x%04X, 0x%04X",status.vPID,status.aPID,status.pcrPID); break;
608        case 1: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X/0x%08X",status.video_stc,status.video_pts); break;
609        case 2: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"0x%08X/0x%08X",status.audio_stc,status.audio_pts); break;
610        case 3: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",(int)status.audio_pts - (int)status.video_pts); break;
611        case 4: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d,%d,%d",(int)status.audio_stc-(int)status.audio_pts); break;
612        case 5: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d,%d,%d",(int)status.video_stc-(int)status.video_pts);  break;
613        case 6: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d/%d,%d/%d",status.audio_fifo_depth,status.audio_fifo_size,status.video_fifo_depth,status.video_fifo_size); break;
614        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;
615        case 8: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d",p_app->tune_ms); break;
616        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;
617        case 10: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%d/%d/%d",p_app->si_ms,status.seq_header_ms,status.first_pts_ms); break;
618        case 11: *str_len = snprintf(ts_str,MAX_TSTR_LEN,"%s%s, cm=%d", aud_config.tone != 0xffffffff ? "tone, " : "", aud_config.mono ? "mono" : "stereo", aud_config.comp_mode); break;
619#endif 
620        default:
621                *str_len = 0;
622                break;
623        }
624
625        if (*str_len)
626        {
627                *str_len = c_to_uni_str((unsigned char*)ts_str,p_uni_str,*str_len);
628        }
629}
630
631/*
632Summary:
633        Status screen drawing function.
634*/
635static void bscreen_diag_list_draw(bapp_t *p_app, 
636                                                                         bscreen_t *p_screen,
637                                                                         const char *p_title_str,
638                                                                         const char *p_label_str[],
639                                                                         get_str_t get_str_fcn
640                                                                        )
641{
642        uint16_t x,y,y_off;
643        unsigned int num_chars = 0;
644        int i;
645
646        x = eINFO_STATUS_X;
647        y = eINFO_STATUS_Y;
648
649        i = 0;
650
651        y += eINFO_ROW_HEIGHT + 6;
652
653        while (*(p_label_str[i]) != '\0')
654        {
655                y_off = y + (i * eINFO_ROW_HEIGHT);
656                if ((y_off + eINFO_ROW_HEIGHT) >= eHEIGHT)
657                {
658                        BDBG_WRN(("%s too many rows %d, y = %d\n",__FUNCTION__,i,y_off));
659                        break;
660                }
661                bgfx_fill_rect(&p_app->surf,x,y_off,eWIDTH - x,eINFO_ROW_HEIGHT,eCOLOR_BLACK);
662                num_chars = bapp_util_strlen((char*)p_label_str[i]);
663                num_chars = c_to_uni_str((unsigned char*)p_label_str[i],p_app->tmp_str,num_chars);
664                text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
665                                 x, y_off, eINFO_COL_LABEL_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
666
667                num_chars = SCREEN_MAX_STR_WIDTH;
668                get_str_fcn(p_app,p_screen,i,p_app->tmp_str, &num_chars,NULL);
669                text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
670                                 x + eINFO_COL_LABEL_WIDTH, y_off, eWIDTH - x - eINFO_COL_WIDTH, eINFO_ROW_HEIGHT, 
671                                 p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
672                i++;
673        }
674}
675
676/*
677Summary:
678        Status screen drawing function.
679*/
680static void bscreen_diag_draw(bapp_t *p_app, 
681                                                                bscreen_t *p_screen,
682                                                                const char *p_title_str,
683                                                                const char *p_help_str,
684                                                                const char *p_label_str[],
685                                                                get_str_t get_str_fcn
686                                                           )
687{
688        uint16_t x,y;
689        unsigned int num_chars = 0;
690        int i,page;
691
692        page = p_screen->local_state;
693        x = eINFO_X;
694        y = eINFO_STATUS_Y;
695
696        i = 0;
697        bgfx_fill_rect(&p_app->surf,x,y,eWIDTH - x,eINFO_ROW_HEIGHT,eCOLOR_BLACK);
698        num_chars = bapp_util_strlen(p_title_str);
699        num_chars = c_to_uni_str((unsigned char*)p_title_str,p_app->tmp_str,num_chars);
700        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_MED],
701                         x, y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
702
703        bscreen_diag_list_draw(p_app,p_screen,p_title_str,p_label_str,get_str_fcn);
704
705        num_chars = bapp_util_strlen(p_help_str);
706        num_chars = c_to_uni_str((unsigned char*)p_help_str,p_app->tmp_str,num_chars);
707        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
708                         x, eINFO_HELP_Y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
709
710}
711
712int bscreen_diag_event(bapp_t *p_app, bscreen_t *p_screen, 
713                                                 bscreen_event_t *p_event,
714                                             void (*draw_fcn)(void *v_app, void *v_screen),
715                                             int refresh)
716{
717        int result = 0;
718        static int cnt = 0;
719
720        switch (p_event->type)
721        {
722        case eS_EVENT_SETUP:
723                p_screen->local_state = 0;
724                bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);
725                bapp_enable_cc(p_app, 0);
726                break;
727
728        case eS_EVENT_IDLE:
729                if (refresh <= 0)
730                        break;
731                if (cnt++ == 10)
732                {
733                        cnt = 0;
734                        bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);
735                        draw_fcn(p_app,p_screen);
736                        result = 1;
737                }
738                break;
739
740        case eS_EVENT_IR:
741                {
742                        BDBG_WRN(("%s:%d 0x%02x(%s)\n",__FUNCTION__,__LINE__,p_event->id,(p_event->id & 0x40000000) ? "up" : "down"));
743                        switch (p_event->id)
744                        {
745                        case eIR_INFO:
746                                bapp_set_current_screen(p_app, eSCREEN_BANNER, eSCREEN_MAX);
747                                result = 1;
748                                break;
749                        case eIR_PRECH:
750                        case eIR_DOT:
751                                bapp_set_current_screen(p_app, eSCREEN_DIAG_MENU, eSCREEN_MAX);
752                                result = 1;
753                                break;
754                        default:
755                                break;
756                        }
757                        break;
758                }
759                break;
760        default:
761                result = bscreen_default_event(p_app,p_screen,p_event);
762                break;
763        }
764        return result; /* always handle event */
765}
766/*
767Summary:
768        Status screen drawing function.
769*/
770void bscreen_sys_info_draw(void *v_app, void *v_screen)
771{
772        bapp_t *p_app = (bapp_t*)v_app;
773        bscreen_t *p_screen = (bscreen_t*)v_screen;
774        bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_GENERAL_INFO],
775                                                s_diag_help_simple,s_general_info_str,
776                                                bscreen_general_info_str);
777}
778/*
779Summary:
780        Status screen event handling function.
781*/
782int bscreen_sys_info_event(void *v_app, void *v_screen, 
783                                                   bscreen_event_t *p_event)
784{
785        bapp_t *p_app = (bapp_t*)v_app;
786        bscreen_t *p_screen = (bscreen_t*)v_screen;
787        return bscreen_diag_event(p_app,p_screen,p_event,bscreen_sys_info_draw,-1);
788}
789
790/*
791Summary:
792        Status screen drawing function.
793*/
794void bscreen_dta_status_draw(void *v_app, void *v_screen)
795{
796        bapp_t *p_app = (bapp_t*)v_app;
797        bscreen_t *p_screen = (bscreen_t*)v_screen;
798        bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_DTA_STATUS],
799                                                s_diag_help_simple,s_dta_status_str,
800                                                bscreen_dta_status_str);
801}
802/*
803Summary:
804        Status screen event handling function.
805*/
806int bscreen_dta_status_event(void *v_app, void *v_screen, 
807                                                   bscreen_event_t *p_event)
808{
809        bapp_t *p_app = (bapp_t*)v_app;
810        bscreen_t *p_screen = (bscreen_t*)v_screen;
811        return bscreen_diag_event(p_app,p_screen,p_event,bscreen_dta_status_draw,1);
812}
813/*
814Summary:
815        Status screen drawing function.
816*/
817void bscreen_tuner_status_draw(void *v_app, void *v_screen)
818{
819        bapp_t *p_app = (bapp_t*)v_app;
820        bscreen_t *p_screen = (bscreen_t*)v_screen;
821        bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_TUNER_STATUS],
822                                                s_diag_help_default,s_tuner_status_str,
823                                                bscreen_tuner_status_str);
824}
825/*
826Summary:
827        Status screen event handling function.
828*/
829int bscreen_tuner_status_event(void *v_app, void *v_screen,
830                                                   bscreen_event_t *p_event)
831{
832        bapp_t *p_app = (bapp_t*)v_app;
833        bscreen_t *p_screen = (bscreen_t*)v_screen;
834        return bscreen_diag_event(p_app,p_screen,p_event,bscreen_tuner_status_draw,1);
835}
836/*
837Summary:
838        Status screen drawing function.
839*/
840void bscreen_decoder_status_draw(void *v_app, void *v_screen)
841{
842        bapp_t *p_app = (bapp_t*)v_app;
843        bscreen_t *p_screen = (bscreen_t*)v_screen;
844        bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_DECODER_STATUS],
845                                                s_diag_help_simple,s_decoder_status_str,
846                                                bscreen_decoder_status_str);
847}
848/*
849Summary:
850        Status screen event handling function.
851*/
852int bscreen_decoder_status_event(void *v_app, void *v_screen,
853                                                   bscreen_event_t *p_event)
854{
855        bapp_t *p_app = (bapp_t*)v_app;
856        bscreen_t *p_screen = (bscreen_t*)v_screen;
857        return bscreen_diag_event(p_app,p_screen,p_event,bscreen_decoder_status_draw,1);
858}
859
860/*
861Summary:
862        Status screen drawing function.
863*/
864void bscreen_ch_status_draw(void *v_app, void *v_screen)
865{
866        bapp_t *p_app = (bapp_t*)v_app;
867        bscreen_t *p_screen = (bscreen_t*)v_screen;
868        bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_CH_STATUS],
869                                                s_diag_help_in_use,s_ch_status_str,
870                                                bscreen_ch_status_str);
871}
872/*
873Summary:
874        Status screen event handling function.
875*/
876int bscreen_ch_status_event(void *v_app, void *v_screen,
877                                                   bscreen_event_t *p_event)
878{
879        bapp_t *p_app = (bapp_t*)v_app;
880        bscreen_t *p_screen = (bscreen_t*)v_screen;
881        return bscreen_diag_event(p_app,p_screen,p_event,bscreen_ch_status_draw,1);
882}
883
884
885int bscreen_diag_menu_event(void *v_app, void *v_screen, 
886                                                        bscreen_event_t *p_event)
887{
888        bapp_t *p_app = (bapp_t*)v_app;
889        bscreen_t *p_screen = (bscreen_t*)v_screen;
890        int result = 0;
891
892        switch (p_event->type)
893        {
894        case eS_EVENT_SETUP:
895                /* Don't reset so we return with same item selectd p_screen->local_state = 0;  */
896                bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);
897                s_sys_info.state = eSYS_CODE_0;
898                bapp_enable_cc(p_app, 0);
899                break;
900        case eS_EVENT_IDLE:
901                {
902                        /* Do anything that requires periodic action here */
903                }
904                break;
905
906        case eS_EVENT_IR:
907                {
908                        BDBG_WRN(("%s:%d 0x%02x(%s)\n",__FUNCTION__,__LINE__,p_event->id,(p_event->id & 0x40000000) ? "up" : "down"));
909                        switch (p_event->id)
910                        {
911                       
912                        case eIR_CH_UP:
913                        case eIR_UP:
914                                p_screen->local_state -= 1;
915                                if ((int)p_screen->local_state <= 0)
916                                        p_screen->local_state = 0;
917                                result = 1;
918                                break;
919                        case eIR_CH_DOWN:
920                        case eIR_DOWN:
921                                p_screen->local_state += 1;
922                                if (p_screen->local_state >= eMM_IDX_NUM)
923                                        p_screen->local_state = eMM_IDX_NUM - 1;
924                                result = 1;
925                                break;
926                        case eIR_SELECT:
927                                switch (p_screen->local_state)
928                                {
929                                case 0:
930                                        bapp_set_current_screen(p_app, eSCREEN_SYS_INFO, eSCREEN_MAX);
931                                        result = 1;
932                                        break;
933                                case 1:
934                                        bapp_set_current_screen(p_app, eSCREEN_DTA_STATUS, eSCREEN_MAX);
935                                        result = 1;
936                                        break;
937                                case 2:
938                                        bapp_set_current_screen(p_app, eSCREEN_MSO_INFO, eSCREEN_MAX);
939                                        result = 1;
940                                        break;
941                                case 3:
942                                        bapp_set_current_screen(p_app, eSCREEN_TUNER_STATUS, eSCREEN_MAX);
943                                        result = 1;
944                                        break;
945                                case 4:
946                                        bapp_set_current_screen(p_app, eSCREEN_CH_STATUS, eSCREEN_MAX);
947                                        result = 1;
948                                        break;
949                                case 5:
950                                        bapp_set_current_screen(p_app, eSCREEN_CH_MAP_STATUS, eSCREEN_MAX);
951                                        result = 1;
952                                        break;
953                                case 6:
954                                        bapp_set_current_screen(p_app, eSCREEN_MSG_STATUS, eSCREEN_MAX);
955                                        result = 1;
956                                        break;
957                                case 7:
958                                        bapp_set_current_screen(p_app, eSCREEN_CODE_OBJECTS, eSCREEN_MAX);
959                                        result = 1;
960                                        break;
961                                case 8:
962                                        bapp_set_current_screen(p_app, eSCREEN_CODE_DOWNLOAD, eSCREEN_MAX);
963                                        result = 1;
964                                        break;
965                                case 9:
966                                        bapp_set_current_screen(p_app, eSCREEN_DECODER_STATUS, eSCREEN_MAX);
967                                        result = 1;
968                                        break;
969                                }
970                                break;
971                        case eIR_INFO:
972                                bapp_set_current_screen(p_app, eSCREEN_BANNER, eSCREEN_MAX);
973                                result = 1;
974                                break;
975                        case eIR_0:
976                        case eIR_1:
977                        case eIR_2:
978                        case eIR_3:
979                        case eIR_4:
980                        case eIR_5:
981                        case eIR_6:
982                        case eIR_7:
983                        case eIR_8:
984                        case eIR_9:
985                                bscreen_sys_info_handler(p_app,p_screen,p_event->id);
986                                break;
987                        }
988                }
989                break;
990
991        default:
992                result = bscreen_default_event(v_app,v_screen,p_event);
993                break;
994        }
995        return result; /* always handle event */
996}
997
998/*
999Summary:
1000        Diag menu screen drawing function
1001*/
1002
1003void bscreen_diag_menu_draw(void *v_app, void *v_screen)
1004{
1005        bapp_t *p_app = (bapp_t*)v_app;
1006        bscreen_t *p_screen = (bscreen_t*)v_screen;
1007        unsigned int num_chars;
1008        int yoff,row;
1009
1010        bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);
1011        num_chars = bapp_util_strlen(s_menu_title);
1012        num_chars = c_to_uni_str((unsigned char*)s_menu_title,p_app->tmp_str,num_chars);
1013        yoff = eDIAG_START_Y;
1014        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_MED],
1015                         eDIAG_START_X, yoff, eDIAG_COL_WIDTH, eDIAG_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1016
1017        yoff += 6;
1018
1019        for (row = 0; row < eMM_IDX_NUM; ++row)
1020        {
1021                yoff += eDIAG_ROW_HEIGHT;
1022
1023                if (row == p_screen->local_state)
1024                {
1025                        num_chars = bapp_util_strlen(s_arrow);
1026                        num_chars = c_to_uni_str((unsigned char*)s_arrow,p_app->tmp_str,num_chars);
1027                        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1028                                         eDIAG_START_X, yoff, eDIAG_COL_WIDTH, eDIAG_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1029                }
1030                num_chars = bapp_util_strlen(s_main_menu[row]);
1031                num_chars = c_to_uni_str((unsigned char*)s_main_menu[row],p_app->tmp_str,num_chars);
1032                text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1033                                 eDIAG_MENU_X, yoff, eDIAG_COL_WIDTH, eDIAG_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1034        }
1035        num_chars = bapp_util_strlen(s_menu_help);
1036        num_chars = c_to_uni_str((unsigned char*)s_menu_help,p_app->tmp_str,num_chars);
1037        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1038                         eDIAG_START_X, eDIAG_HELP_Y, eDIAG_COL_WIDTH, eDIAG_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1039}
1040
1041
1042/*
1043Summary:
1044        Diag menu screen drawing function
1045*/
1046void bscreen_mso_info_draw(void *v_app, void *v_screen)
1047{
1048        uint16_t x,y;
1049        unsigned int num_chars = 0;
1050        int i;
1051        bapp_t *p_app = (bapp_t*)v_app;
1052        unsigned char *p_str;
1053        x = eINFO_X;
1054        y = eINFO_STATUS_Y;
1055
1056        i = 0;
1057        bgfx_fill_rect(&p_app->surf,x,y,eWIDTH - x,eINFO_ROW_HEIGHT,eCOLOR_BLACK);
1058        num_chars = bapp_util_strlen(s_main_menu[eMM_IDX_MSO_INFO]);
1059        num_chars = c_to_uni_str((unsigned char*)s_main_menu[eMM_IDX_MSO_INFO],p_app->tmp_str,num_chars);
1060        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_MED],
1061                         x, y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1062
1063        x = eINFO_STATUS_X;
1064        y += eDIAG_ROW_HEIGHT + 6;
1065
1066        num_chars = bapp_util_strlen(s_mso_info_str);
1067        num_chars = c_to_uni_str((unsigned char*)s_mso_info_str,p_app->tmp_str,num_chars);
1068        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1069                         x, y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1070       
1071        y += eDIAG_ROW_HEIGHT;
1072
1073        p_str = p_app->settings.phonenumber;
1074        num_chars = bapp_util_strlen(p_str);
1075        if (num_chars == 0)
1076                p_str = (unsigned char *)s_800_comcast;
1077        num_chars = bapp_util_strlen(p_str);
1078        num_chars = c_to_uni_str((unsigned char*)p_str,p_app->tmp_str,num_chars);
1079        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1080                         x, y, eSCREEN_ACTION_SAFE_WIDTH, 
1081                         eSCREEN_ACTION_SAFE_HEIGHT - y - eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1082
1083        x = eINFO_X;
1084        num_chars = bapp_util_strlen(s_diag_help_default);
1085        num_chars = c_to_uni_str((unsigned char*)s_diag_help_default,p_app->tmp_str,num_chars);
1086        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1087                         x, eINFO_HELP_Y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1088
1089}
1090/*
1091Summary:
1092        Code download event handler
1093*/
1094int bscreen_mso_info_event(void *v_app, void *v_screen, 
1095                                                   bscreen_event_t *p_event)
1096{
1097        bapp_t *p_app = (bapp_t*)v_app;
1098        bscreen_t *p_screen = (bscreen_t*)v_screen;
1099        return bscreen_diag_event(p_app,p_screen,p_event,bscreen_mso_info_draw,1);
1100}
1101
1102/*
1103Summary:
1104        Diag menu screen drawing function
1105*/
1106void bscreen_msg_status_draw(void *v_app, void *v_screen)
1107{
1108        bapp_t *p_app = (bapp_t*)v_app;
1109        bscreen_t *p_screen = (bscreen_t*)v_screen;
1110        unsigned int num_chars = 0;
1111        int time_offset = p_app->settings.utc_offset;
1112        struct tm utc_time;
1113
1114        if ((p_app->system_time > p_app->settings.dst_entry) && (p_app->system_time < p_app->settings.dst_exit))
1115        {
1116                /* TODO Check p_app->settings.dst_delta per spec */
1117                time_offset += 3600;
1118        }
1119
1120       
1121       
1122        bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_MSG_STATUS],
1123                                                s_diag_help_simple,s_msg_status_str,
1124                                                bscreen_msg_status_str);
1125
1126        num_chars = bapp_util_strlen(s_msg_last_addr);
1127        num_chars = c_to_uni_str((unsigned char*)s_msg_last_addr,p_app->tmp_str,num_chars);
1128        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1129                         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);
1130       
1131        utctime(p_app->settings.addressable_time + time_offset,&utc_time);
1132        num_chars = snprintf(ts_str,MAX_TSTR_LEN,"%2d %s %4d %2d:%2d:%2d",
1133                                                         utc_time.tm_mday,s_mon_str[utc_time.tm_mon],utc_time.tm_year + 1980, 
1134                                                         utc_time.tm_hour,utc_time.tm_min,utc_time.tm_sec);
1135       
1136        num_chars = c_to_uni_str((unsigned char*)ts_str,p_app->tmp_str,num_chars);
1137        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1138                 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);
1139
1140
1141        num_chars = bapp_util_strlen(s_diag_help_msg_1);
1142        num_chars = c_to_uni_str((unsigned char*)s_diag_help_msg_1,p_app->tmp_str,num_chars);
1143        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1144                         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);
1145}
1146/*
1147Summary:
1148        Code download event handler
1149*/
1150int bscreen_msg_status_event(void *v_app, void *v_screen, 
1151                                                         bscreen_event_t *p_event)
1152{
1153        int result = 0;
1154        bapp_t *p_app = (bapp_t*)v_app;
1155        bscreen_t *p_screen = (bscreen_t*)v_screen;
1156
1157        switch (p_event->type)
1158        {
1159        case eS_EVENT_IR:
1160                {
1161                        switch (p_event->id)
1162                        {
1163                        case eIR_0:
1164                                p_app->chm.cds_cnt = p_app->chm.mms_cnt = p_app->chm.sns_cnt = 0;
1165                                p_app->chm.dcm_cnt = p_app->chm.vcm_cnt = p_app->chm.stt_cnt = 0;
1166                                p_app->chm.ops_cnt = p_app->chm.cfg_cnt = p_app->chm.eas_cnt = 0;
1167                                p_app->chm.em_cnt = p_app->chm.cat_cnt = p_app->chm.system_id_errors = 0;
1168                        default:
1169                                result = bscreen_diag_event(p_app,p_screen,p_event,bscreen_msg_status_draw,1);
1170                                break;
1171                        }
1172                        break;
1173                }
1174                break;
1175        default:
1176                result = bscreen_diag_event(p_app,p_screen,p_event,bscreen_msg_status_draw,1);
1177                break;
1178        }
1179        return result; /* always handle event */
1180}
1181/*
1182Summary:
1183        Status screen drawing function.
1184*/
1185void bscreen_code_objects_draw(void *v_app, void *v_screen)
1186{
1187        bapp_t *p_app = (bapp_t*)v_app;
1188        unsigned int num_chars;
1189        int y;
1190
1191        bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);
1192
1193        y = eCH_MAP_START_Y;
1194        num_chars = bapp_util_strlen(s_main_menu[eMM_IDX_CODE_OBJECTS]);
1195        num_chars = c_to_uni_str((unsigned char*)s_main_menu[eMM_IDX_CODE_OBJECTS],p_app->tmp_str,num_chars);
1196        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_MED],
1197                         eINFO_X, eCH_MAP_START_Y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1198       
1199        y += eDIAG_ROW_HEIGHT + 6;
1200        num_chars = bapp_util_strlen(s_code_objects_str);
1201        num_chars = c_to_uni_str((unsigned char*)s_code_objects_str,p_app->tmp_str,num_chars);
1202        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1203                         eINFO_X, y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1204       
1205        y += eDIAG_ROW_HEIGHT;
1206        num_chars = bapp_util_strlen(s_bankA_str);
1207        num_chars = c_to_uni_str((unsigned char*)s_bankA_str,p_app->tmp_str,num_chars);
1208        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1209                         eINFO_X, y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1210       
1211        y += eDIAG_ROW_HEIGHT;
1212        num_chars = bapp_util_strlen(s_bankB_str);
1213        num_chars = c_to_uni_str((unsigned char*)s_bankB_str,p_app->tmp_str,num_chars);
1214        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1215                         eINFO_X, y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1216       
1217        num_chars = bapp_util_strlen(s_diag_help_simple);
1218        num_chars = c_to_uni_str((unsigned char*)s_diag_help_simple,p_app->tmp_str,num_chars);
1219        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1220                         eINFO_X, eINFO_HELP_Y-eDIAG_ROW_HEIGHT, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1221}
1222/*
1223Summary:
1224        Status screen event handling function.
1225*/
1226int bscreen_code_objects_event(void *v_app, void *v_screen, 
1227                                                   bscreen_event_t *p_event)
1228{
1229        bapp_t *p_app = (bapp_t*)v_app;
1230        bscreen_t *p_screen = (bscreen_t*)v_screen;
1231        return bscreen_diag_event(p_app,p_screen,p_event,bscreen_code_objects_draw,-1);
1232}
1233/*
1234Summary:
1235        Status screen drawing function.
1236*/
1237void bscreen_code_download_draw(void *v_app, void *v_screen)
1238{
1239        bapp_t *p_app = (bapp_t*)v_app;
1240        bscreen_t *p_screen = (bscreen_t*)v_screen;
1241        bscreen_diag_draw(p_app,p_screen,s_main_menu[eMM_IDX_CODE_DOWNLOAD],
1242                                                s_diag_help_simple,s_code_download_str,
1243                                                bscreen_code_download_str);
1244}
1245/*
1246Summary:
1247        Status screen event handling function.
1248*/
1249int bscreen_code_download_event(void *v_app, void *v_screen, 
1250                                                   bscreen_event_t *p_event)
1251{
1252        bapp_t *p_app = (bapp_t*)v_app;
1253        bscreen_t *p_screen = (bscreen_t*)v_screen;
1254        return bscreen_diag_event(p_app,p_screen,p_event,bscreen_code_download_draw,1);
1255}
1256
1257int bscreen_ch_map_status_event(void *v_app, void *v_screen, 
1258                                                        bscreen_event_t *p_event)
1259{
1260        bapp_t *p_app = (bapp_t*)v_app;
1261        bscreen_t *p_screen = (bscreen_t*)v_screen;
1262        int result = 0;
1263
1264        switch (p_event->type)
1265        {
1266        case eS_EVENT_SETUP:
1267                p_screen->local_state = 0;
1268                bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);
1269                break;
1270        case eS_EVENT_IDLE:
1271                {
1272                        /* Do anything that requires periodic action here */
1273                }
1274                break;
1275
1276        case eS_EVENT_IR:
1277                {
1278                        BDBG_WRN(("%s:%d 0x%02x(%s)\n",__FUNCTION__,__LINE__,p_event->id,(p_event->id & 0x40000000) ? "up" : "down"));
1279                        switch (p_event->id)
1280                        {
1281                        case eIR_CH_UP:
1282                        case eIR_UP:
1283                                p_screen->local_state -= eCH_MAP_NUM_ROW;
1284                                if ((int)p_screen->local_state < 0)
1285                                        p_screen->local_state = 0;
1286                                result = 1;
1287                                break;
1288                        case eIR_CH_DOWN:
1289                        case eIR_DOWN:
1290                                {
1291                                        unsigned short num_vch;
1292                                        ch_map_get_vch_num(bapp_cur_ch_map(p_app),&num_vch);
1293       
1294                                        if ((p_screen->local_state + eCH_MAP_NUM_ROW) < num_vch)
1295                                        {
1296                                                p_screen->local_state += eCH_MAP_NUM_ROW;
1297                                        }
1298                                        result = 1;
1299                                }
1300                                break;
1301                        case eIR_INFO:
1302                                bapp_set_current_screen(p_app, eSCREEN_BANNER, eSCREEN_MAX);
1303                                result = 1;
1304                                break;
1305                        case eIR_PRECH:
1306                        case eIR_DOT:
1307                                bapp_set_current_screen(p_app, eSCREEN_DIAG_MENU, eSCREEN_MAX);
1308                                result = 1;
1309                                break;
1310                        }
1311                }
1312                break;
1313
1314        default:
1315                result = bscreen_default_event(v_app,v_screen,p_event);
1316                break;
1317        }
1318        return result; /* always handle event */
1319}
1320
1321/*
1322Summary:
1323        Draw the header row
1324        .
1325*/
1326void bscreen_ch_map_header(bapp_t *p_app, bscreen_t *p_screen)
1327{
1328        unsigned int num_chars;
1329
1330        /* draw titles */
1331        num_chars = c_to_uni_str((unsigned char*)s_ch_map_status_header[0],p_app->tmp_str,bapp_util_strlen(s_ch_map_status_header[0]));
1332        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1333                         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);
1334        num_chars = c_to_uni_str((unsigned char*)s_ch_map_status_header[1],p_app->tmp_str,bapp_util_strlen(s_ch_map_status_header[1]));
1335        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1336                         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);
1337        num_chars = c_to_uni_str((unsigned char*)s_ch_map_status_header[2],p_app->tmp_str,bapp_util_strlen(s_ch_map_status_header[2]));
1338        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1339                         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);
1340        num_chars = c_to_uni_str((unsigned char*)s_ch_map_status_header[3],p_app->tmp_str,bapp_util_strlen(s_ch_map_status_header[3]));
1341        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1342                         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);
1343        num_chars = c_to_uni_str((unsigned char*)s_ch_map_status_header[4],p_app->tmp_str,bapp_util_strlen(s_ch_map_status_header[4]));
1344        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1345                         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);
1346        num_chars = c_to_uni_str((unsigned char*)s_ch_map_status_header[5],p_app->tmp_str,bapp_util_strlen(s_ch_map_status_header[5]));
1347        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1348                         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);
1349}
1350/*
1351Summary:
1352        Draw the row
1353        .
1354*/
1355
1356void bscreen_ch_map_row(bapp_t *p_app, bscreen_t *p_screen, 
1357                                                        vch_t *p_vch,
1358                                                        st_t *p_st,
1359                                                        freq_t *p_freq,
1360                                                        int y)
1361{
1362        unsigned int num_chars;
1363        static char tmp_buf[64];
1364        unsigned int freq_mhz,frac_freq_mhz;
1365        mms_t mms;
1366        freq_mhz = p_freq->freq_khz/1000;
1367        frac_freq_mhz = p_freq->freq_khz - (freq_mhz * 1000);
1368       
1369        /* draw row */
1370        num_chars = snprintf(tmp_buf,64,"%d",p_vch->ch_num);
1371        num_chars = c_to_uni_str(tmp_buf,p_app->tmp_str,num_chars);
1372        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1373                         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);
1374        num_chars = snprintf(tmp_buf,64,"%d",p_vch->source_id);
1375        num_chars = c_to_uni_str(tmp_buf,p_app->tmp_str,num_chars);
1376        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1377                         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);
1378        num_chars = snprintf(tmp_buf,64,"%11s",p_st->name);
1379        num_chars = c_to_uni_str(tmp_buf,p_app->tmp_str,num_chars);
1380        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1381                         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);
1382        num_chars = snprintf(tmp_buf,64,"%d.%d",freq_mhz,frac_freq_mhz);
1383        num_chars = c_to_uni_str(tmp_buf,p_app->tmp_str,num_chars);
1384        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1385                         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);
1386       
1387        if (ch_map_get_mms(bapp_cur_ch_map(p_app),p_vch->mms_idx,&mms))
1388        {
1389                num_chars = snprintf(tmp_buf,64,"%s",(mms.modulation == MOD_QAM64) ? "64" : (mms.modulation == MOD_QAM256) ? "256" : "N/A" );
1390                num_chars = c_to_uni_str(tmp_buf,p_app->tmp_str,num_chars);
1391                text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1392                                 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);
1393        }
1394        num_chars = snprintf(tmp_buf,64,"%d",p_vch->program_num);
1395        num_chars = c_to_uni_str(tmp_buf,p_app->tmp_str,num_chars);
1396        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1397                         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);
1398}
1399
1400/*
1401Summary:
1402        Test screen drawing function
1403        .
1404*/
1405void bscreen_ch_map_status_draw(void *v_app, void *v_screen)
1406{
1407        bapp_t *p_app = (bapp_t*)v_app;
1408        bscreen_t *p_screen = (bscreen_t*)v_screen;
1409        unsigned int num_chars;
1410        unsigned short num_vch;
1411        unsigned char cur_ch;
1412        int idx,yoff,row,page,pages;
1413        vch_t vch;
1414        st_t    st;
1415        freq_t freq;
1416        ch_map_t *p_ch_map = bapp_cur_ch_map(p_app);
1417       
1418       
1419        bgfx_fill_rect(&p_app->surf,0,0,eWIDTH,eHEIGHT,eCOLOR_BLACK);
1420        ch_map_get_vch_num(bapp_cur_ch_map(p_app),&num_vch);
1421
1422        pages = num_vch/eCH_MAP_NUM_ROW + 1;
1423        page = p_screen->local_state/eCH_MAP_NUM_ROW + 1;
1424
1425        num_chars = snprintf(ts_str,MAX_TSTR_LEN,s_ch_map_status_info,p_app->settings.VCT_ID,num_vch,page,pages);
1426        num_chars = c_to_uni_str((unsigned char*)ts_str,p_app->tmp_str,num_chars);
1427        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1428                         eINFO_X, eCH_MAP_START_Y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1429
1430        bscreen_ch_map_header(p_app,p_screen);
1431
1432        if (!ch_map_get_current(p_ch_map,&vch,&st,&freq))
1433                return;
1434
1435        cur_ch = vch.ch_num; /* save current channel number */
1436        p_ch_map->cur_ch = p_screen->local_state;
1437        idx = p_screen->local_state;
1438        yoff = eCH_MAP_ROW_Y;
1439        for (row = 0; row < eCH_MAP_NUM_ROW; ++row)
1440        {
1441                if (!ch_map_get_current(p_ch_map,&vch,&st,&freq))
1442                        break;
1443                yoff += eCH_MAP_ROW_HEIGHT;
1444
1445                if (idx < num_vch)
1446                {
1447                        bscreen_ch_map_row(p_app,p_screen,&vch,&st,&freq,yoff);
1448                }
1449                idx++;
1450                ch_map_set_next(p_ch_map);
1451        }
1452
1453        num_chars = bapp_util_strlen(s_diag_help_ch_map);
1454        num_chars = c_to_uni_str((unsigned char*)s_diag_help_ch_map,p_app->tmp_str,num_chars);
1455        text_box(&p_app->surf, p_app->p_font[eLANG_ENGLISH][eFONT_SIZE_SMALL],
1456                         eINFO_X, eINFO_HELP_Y, eSCREEN_ACTION_SAFE_WIDTH, eINFO_ROW_HEIGHT, p_app->tmp_str, num_chars, eCOLOR_WHITE,0);
1457
1458        if (!ch_map_set_ch(p_ch_map,cur_ch))
1459                return;
1460}
1461
1462
Note: See TracBrowser for help on using the repository browser.