source: svn/branches/kctv/newcon3bcm2_21bu/nexus/app/dta/bguide.c @ 43

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

1.phkim

  1. revision copy newcon3sk r27
  • Property svn:executable set to *
File size: 24.6 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#define MAX_GUIDE_ENTRIES   9
23
24/* Define to test guide drawing and selection control without PSIP guide data */
25/*
26#define STATIC_GUIDE_TEST
27*/
28
29#define GUIDE_MIN(x,y)      ((x < y) ? x : y)
30#define eSCREEN_GUIDE_X                 82
31#define eSCREEN_GUIDE_Y_OFF             130
32#define eSCREEN_GUIDE_HEIGHT            30
33#define eSCREEN_GUIDE_CH_WIDTH          55
34#ifdef CONFIG_CH_HIDDEN
35#define eSCREEN_GUIDE_CALLSIGN_WIDTH    60
36#else
37#define eSCREEN_GUIDE_CALLSIGN_WIDTH    90
38#endif
39#define eSCREEN_GUIDE_CH_NAME_X         138
40#define eSCREEN_GUIDE_CH_NAME_WIDTH     30
41#define eSCREEN_GUIDE_NEXT_X            445
42#ifdef CONFIG_CH_HIDDEN
43static const int eSCREEN_GUIDE_CUR_X[3] = {280,304,302};
44static const int eSCREEN_GUIDE_NAME_WIDTH[3] = {168,168,158};
45static const int eSCREEN_GUIDE_HIDDEN_WIDTH[3] = {84,100,98};
46#else
47#define eSCREEN_GUIDE_CUR_X             235
48#define eSCREEN_GUIDE_NAME_WIDTH        196
49#endif
50#define eSCREEN_GUIDE_SPACING           30
51
52#if 1
53    #define guide_text_box(s,f,x,y,w,h,m,l,cf,cb,o,lsp)  text_box(s,f,x,y,w,h,m,l,cf,lsp)
54#else
55    #define guide_text_box  text_box_shadow
56#endif
57static void draw_guide_entry(bapp_t *p_app, bscreen_t *p_screen, guide_state_t *p_gs,
58                             int idx, chm_info_t *p_info, bool selected);
59static chm_info_t* screen_guide_get_info(bapp_t *p_app, int idx);
60
61guide_state_t g_guide_state = 
62{
63    0,
64    0,
65        1,
66    "",
67    { eS_EVENT_MAX, 0, 0 },
68    0,
69    0,
70    0
71};
72/*
73Summary:
74    Guide event handling. return 0 if no redrawing should
75    be done.
76    .
77*/
78int screen_guide_move(bapp_t *p_app, bscreen_t *p_screen, 
79                               int up)
80{
81    int start_idx,end_idx,num_disp,result,old_sel;
82    guide_state_t *p_gs;
83    p_gs = (guide_state_t*)p_screen->local_state;
84    chm_info_t *p_info;
85    chm_info_t *p_old_info;
86    BDBG_ASSERT(p_gs);
87
88    result = 0;
89
90    if (p_app->settings.num_channels < 2)
91        return result;
92
93    start_idx = p_gs->offset;
94    end_idx = GUIDE_MIN((p_app->settings.num_channels - 1),
95                                        (p_gs->offset + (MAX_GUIDE_ENTRIES - 1)));
96    num_disp = (end_idx - start_idx + 1);
97
98    old_sel = p_gs->selection;
99    /* If moving selection up */
100    if (up > 0)
101    {
102        if (p_gs->selection == 0)
103        {
104            /* already at top */
105        }
106        else
107        if (up >= MAX_GUIDE_ENTRIES)
108        {
109            /* jump one page up */
110            start_idx -= MAX_GUIDE_ENTRIES;
111            p_gs->selection -= MAX_GUIDE_ENTRIES;
112            if (start_idx < 0)
113            {
114                BDBG_ERR(("start_idx = %d < 0\n", start_idx));
115                start_idx = 0;
116                p_gs->selection = start_idx;
117            }
118
119            p_gs->offset = start_idx;
120            result = 1;
121        }
122        else
123        if (p_gs->selection > start_idx)
124        {
125            p_gs->selection--;
126            result = 1;
127        }
128        else if (start_idx > 0)
129        {
130            start_idx -= MAX_GUIDE_ENTRIES;
131            if (start_idx < 0)
132            {
133                BDBG_ERR(("start_idx = %d < 0\n", start_idx));
134                start_idx = 0;
135                p_gs->selection = start_idx;
136            }
137            p_gs->offset = start_idx;
138            p_gs->selection--;
139            result = 1;
140        }
141        else
142        {
143            /* Do nothing */
144        }
145    }
146    else /* moving selection down */
147    {
148        if (p_gs->selection == (p_app->settings.num_channels - 1))
149        {
150            /* already at bottom */
151        }
152        else
153        if (up <= -MAX_GUIDE_ENTRIES) 
154        {
155            /* jump one page down */
156            p_gs->offset += MAX_GUIDE_ENTRIES;
157            p_gs->selection += MAX_GUIDE_ENTRIES;
158            if (p_gs->offset >= p_app->settings.num_channels) 
159            {
160                BDBG_ERR(("p_gs->offset = %d >= %d\n", p_gs->offset,p_app->settings.num_channels));
161                p_gs->offset -= MAX_GUIDE_ENTRIES;
162            }
163
164            if (p_gs->selection >= p_app->settings.num_channels)
165            {
166                BDBG_ERR(("p_gs->selection = %d >= %d\n", p_gs->selection,p_app->settings.num_channels));
167                p_gs->selection = p_app->settings.num_channels - 1;
168            }
169
170            result = 1;
171        }
172        else
173        if (p_gs->selection < end_idx)
174        {
175            p_gs->selection++;
176            result = 1;
177        }
178        else 
179        if ((end_idx == p_app->settings.num_channels) ||
180            (num_disp < MAX_GUIDE_ENTRIES)) 
181        {
182            /* do nothing */
183        }
184        else
185        {
186            p_gs->offset += MAX_GUIDE_ENTRIES;
187            p_gs->selection++;
188            if (p_gs->offset >= p_app->settings.num_channels)
189            {
190                BDBG_ERR(("p_gs->offset = %d >= %d\n", p_gs->offset,p_app->settings.num_channels));
191                p_gs->offset -= MAX_GUIDE_ENTRIES;
192                p_gs->selection = p_app->settings.num_channels - 1;
193            }
194            result = 1;
195        }
196    }
197    return result;
198}
199
200/*
201Summary:
202    Guide event handling
203    .
204*/
205int screen_guide_event(void *v_app, void *v_screen, 
206                               bscreen_event_t *p_event)
207{
208    bapp_t *p_app = (bapp_t*)v_app;
209    bscreen_t *p_screen = (bscreen_t*)v_screen;
210    guide_state_t *p_gs;
211    int result = 0;
212        chm_info_t *p_info;
213
214    p_gs = (guide_state_t*)p_screen->local_state;
215    BDBG_ASSERT(p_gs);
216
217    switch (p_event->type)
218    {
219    case eS_EVENT_SETUP:
220        {
221            bscreen_default_setup(v_app,v_screen);
222                        p_gs->column = 1;
223            if (p_app->cur_ch_num)
224            {
225                p_gs->offset = (p_app->cur_ch_num/MAX_GUIDE_ENTRIES) * MAX_GUIDE_ENTRIES;
226                p_gs->selection = p_app->cur_ch_num;
227            }
228            else
229            {
230                p_gs->selection = 0;
231                p_gs->offset = 0;
232            }
233            memset(&p_gs->event,0,sizeof(p_gs->event));
234            p_gs->repeat_rate = 1;
235            p_gs->repeat_timeout = DEFAULT_REPEAT_TIMEOUT/p_gs->repeat_rate;
236            result = 1; /* always handle event */
237
238            if (p_app->settings.num_channels == 0)
239            {
240                /* set update progress to done since there are no channels */
241                p_gs->update_progress = 100;
242            }
243            else
244            {
245                chm_cmd(&p_app->chm,eCHM_GUIDE);
246                bos_sleep(20); /* give time for command to be processed */
247            }
248        }
249        break;
250    case eS_EVENT_SETUP_DONE:
251        {
252        }
253        break;
254    case eS_EVENT_PROGRESS:
255        {
256            p_gs->update_progress = p_event->id;
257
258            if (p_gs->update_progress < 100)
259            {
260                int num_chars = SCREEN_MAX_STR_WIDTH;
261                                int w = 0;
262                                int h = 0;
263
264                /* draw progress text */
265                bscreen_get_string(p_app->lang,eTEXT_GUIDE_DL_PROGRESS, p_app->tmp_str, &num_chars);
266                                bgfx_string_info(p_app->p_font[p_app->lang][eFONT_SIZE_SMALL],(const unsigned long *)p_app->tmp_str,num_chars,&w,&h);
267                text_box_shadow(&p_app->surf, p_app->p_font[p_app->lang][eFONT_SIZE_SMALL],
268                                        ePROGRESS_GUIDE_X - w - 7, ePROGRESS_GUIDE_TEXT_Y,
269                                        w + 3, ePROGRESS_GUIDE_TEXT_HEIGHT,  p_app->tmp_str,
270                    num_chars, eCOLOR_MED_YELLOW,eCOLOR_BLACK, eMENU_TEXT_DROPSHADOW ,100);
271
272                bscreen_draw_progress(v_app, ePROGRESS_GUIDE_X, ePROGRESS_GUIDE_Y, ePROGRESS_GUIDE_WIDTH, ePROGRESS_GUIDE_HEIGHT, 
273                                      eBUTTON_VOL_PROGRESS_BORDER, eCOLOR_WHITE, eCOLOR_DRK_BLUE, p_gs->update_progress);
274            }
275            else
276            {
277                bgfx_fill_rect(&p_app->surf,ePROGRESS_GUIDE_TEXT_X,ePROGRESS_GUIDE_Y,
278                               ePROGRESS_GUIDE_X+ePROGRESS_GUIDE_WIDTH-ePROGRESS_GUIDE_TEXT_X+3,ePROGRESS_GUIDE_HEIGHT+3,eCOLOR_LT_BLUE);
279            }
280               
281            result = 1;
282        }
283        break;
284    case eS_EVENT_REDRAW:
285        {
286            result = 1;
287        }
288        break;
289    case eS_EVENT_IR:
290        {
291            switch (p_event->id)
292            {
293                        case eIR_SELECT:
294
295                                if (p_gs->column == 1)
296                                {
297                                        chm_cmd(&p_app->chm,eCHM_CANCEL);
298                                        BDBG_WRN(("Current Selection %d\n", p_gs->selection));
299                                        bos_sleep(500); /* Give chance for cancel to take effect - JPF are we sure this is necessary??? */
300                                        bapp_set_channel(p_app, 
301                                                                         p_app->settings.ch[p_gs->selection].major, 
302                                                                         p_app->settings.ch[p_gs->selection].minor);
303                                        bapp_set_current_screen(p_app,eSCREEN_BANNER_SMALL,eSCREEN_NULL);
304#ifdef CONFIG_CH_HIDDEN
305                                        if (!p_app->settings.wiz_completed)
306                                        {
307                                                p_app->settings.wiz_completed = true;
308                                                /* select exits to live tv so we must clear all the button selection history for all screens */
309                                                bapp_clear_screen_selection_history(p_app);
310                                        }
311#endif
312                                }
313                                else
314                                {
315#ifdef CONFIG_CH_HIDDEN
316                                        /* add/remove channel from ch+/- list */
317                                        if (p_gs->selection < p_app->settings.num_channels)
318                                                p_app->settings.ch[p_gs->selection].hidden = !p_app->settings.ch[p_gs->selection].hidden; 
319                                        p_app->settings_dirty = 1;
320#endif
321                                }
322                result = 1;
323                break;
324#ifdef CONFIG_CH_HIDDEN
325                        case eIR_LEFT:
326                                {
327                                        if (p_gs->column != 0)
328                                        {
329
330                                                p_gs->column = 0;
331                                                result = 1;
332                                        }
333                                }
334                                break;
335                        case eIR_RIGHT:
336                                {
337                                        if (p_gs->column != 1)
338                                        {
339                                                result = 1;
340                                                p_gs->column = 1;
341                                        }
342                                }
343                                break;
344#endif
345            case eIR_MENU:
346            case eIR_GUIDE:
347                chm_cmd(&p_app->chm,eCHM_CANCEL);
348                BDBG_WRN(("Current Selection %d\n", p_gs->selection));
349                bos_sleep(500); /* Give chance for cancel to take effect */
350/*                p_app->cur_ch_num = p_gs->selection;*/
351                bapp_goto_last_screen(p_app);
352                bapp_tune(p_app);
353                result = 1;
354                break;
355            case eIR_CH_UP:
356                result = screen_guide_move(p_app,p_screen,MAX_GUIDE_ENTRIES);
357                break;
358            case eIR_UP:
359                result = screen_guide_move(p_app,p_screen,1);
360                break;
361            case eIR_CH_DOWN:
362                result = screen_guide_move(p_app,p_screen,-MAX_GUIDE_ENTRIES);
363                break;
364            case eIR_DOWN:
365                result = screen_guide_move(p_app,p_screen,0);
366                break;
367            default:
368                break;
369            }
370            p_gs->event = *p_event;
371            p_gs->repeat_rate = 1;
372            p_gs->repeat_timeout = bos_getticks() + (DEFAULT_REPEAT_TIMEOUT/p_gs->repeat_rate);
373        }
374        break;
375    case eS_EVENT_IDLE:
376        {
377            if (p_gs->repeat_timeout < bos_getticks())
378            {
379                /* Handle repeating when key is held down */
380                if (p_gs->event.type == eS_EVENT_IR)
381                {
382                    switch (p_gs->event.id)
383                    {
384                    case eIR_UP:
385                    case eIR_CH_UP:
386                        result = screen_guide_move(p_app,p_screen,1);
387                        break;
388                    case eIR_DOWN:
389                    case eIR_CH_DOWN:
390                        result = screen_guide_move(p_app,p_screen,0);
391                        break;
392                    default: break;
393                    }
394                }
395   
396                if (p_gs->repeat_rate < MAX_REPEAT_ACCEL)
397                {
398                    p_gs->repeat_rate += REPEAT_INC;
399                }
400                p_gs->repeat_timeout = bos_getticks() + (DEFAULT_REPEAT_TIMEOUT/p_gs->repeat_rate);
401            }
402           
403            if (!result)
404                result = bscreen_default_idle(v_app,v_screen);
405        }
406        break;
407    default:
408        {
409            result = bscreen_default_event(v_app,v_screen,p_event);
410        }
411        break;
412    }
413    return result;
414}
415
416/*
417Summary:
418    Draw the guide entry
419    .
420*/
421
422static void draw_guide_entry(bapp_t *p_app, bscreen_t *p_screen, guide_state_t *p_gs,
423                             int idx, chm_info_t *p_info, bool selected)
424{
425    int x,y,num_chars,w,h,str_y,l_idx;
426    int bkgnd_color = eCOLOR_MED_BLUE;
427    int offset = 4;
428        int guide_width;
429    l_idx = idx;
430
431    if (p_app->settings.num_channels == 0)
432            return;
433
434    /* alternate medium and lt blue background */
435    bkgnd_color = ((l_idx % 2) ? eCOLOR_MED_BLUE : eCOLOR_LT_BLUE);
436    bgfx_fill_rect(&p_app->surf,eSCREEN_ACTION_SAFE_X+offset,eSCREEN_GUIDE_Y_OFF + (eSCREEN_GUIDE_HEIGHT * (l_idx % MAX_GUIDE_ENTRIES)),
437                   eSCREEN_ACTION_SAFE_WIDTH - (2*offset), eSCREEN_GUIDE_HEIGHT,bkgnd_color);
438
439    /* String for channel column */
440    num_chars = snprintf(p_gs->ch_num_str,24,"%d.%d", 
441             p_app->settings.ch[idx].major,
442             p_app->settings.ch[idx].minor);
443   
444    num_chars = c_to_uni_str(p_gs->ch_num_str,p_app->tmp_str,num_chars);
445    bgfx_string_info(p_app->p_font[p_app->lang][eFONT_SIZE_SMALL],
446                     (const unsigned long *)p_app->tmp_str,num_chars,&w,&h);
447   
448    /* draw channel number column */
449    if ( l_idx >= MAX_GUIDE_ENTRIES)
450        l_idx = (l_idx % MAX_GUIDE_ENTRIES);
451    x = eSCREEN_GUIDE_X;
452    y = eSCREEN_GUIDE_Y_OFF + (eSCREEN_GUIDE_HEIGHT * l_idx);
453
454    str_y = y + (eSCREEN_GUIDE_HEIGHT - h)/2;
455    guide_text_box(&p_app->surf, p_app->p_font[p_app->lang][eFONT_SIZE_SMALL],
456        x, str_y, eSCREEN_GUIDE_CH_WIDTH, eSCREEN_GUIDE_HEIGHT, 
457        p_app->tmp_str, num_chars, eCOLOR_WHITE,eCOLOR_BLACK, eMENU_TEXT_DROPSHADOW ,eSCREEN_GUIDE_SPACING);
458
459    /* String for channel short name column */
460#ifdef CONFIG_CH_HIDDEN
461        /* limit to 4 callsign chars to make room for add/remove checkbox*/
462    num_chars = utf16_to_uni_str(p_app->settings.ch[idx].ch_name,p_app->tmp_str,4);
463#else
464    num_chars = utf16_to_uni_str(p_app->settings.ch[idx].ch_name,p_app->tmp_str,MAX_CH_NAME_CHARS);
465#endif
466
467    if (num_chars == 0)
468    {
469        num_chars = MAX_CH_NAME_CHARS;
470        bscreen_get_string(p_app->lang,eTEXT_NA_GUIDE_CH, p_app->tmp_str, &num_chars);
471    }
472    /* draw channel short name column */
473    x = eSCREEN_GUIDE_CH_NAME_X;
474    bgfx_fill_rect(&p_app->surf,x, y, eSCREEN_GUIDE_CALLSIGN_WIDTH,eSCREEN_GUIDE_HEIGHT,bkgnd_color);
475    guide_text_box(&p_app->surf, p_app->p_font[p_app->lang][eFONT_SIZE_SMALL],
476        x, str_y, eSCREEN_GUIDE_CALLSIGN_WIDTH, eSCREEN_GUIDE_HEIGHT, 
477        p_app->tmp_str, num_chars, eCOLOR_WHITE,eCOLOR_BLACK, eMENU_TEXT_DROPSHADOW ,eSCREEN_GUIDE_SPACING);
478
479#ifdef CONFIG_CH_HIDDEN
480#ifdef CONFIG_CH_HIDDEN_CHECKBOX
481        /* add/remove channel checkbox */
482    {
483                uint16_t check_x = x + eSCREEN_GUIDE_CALLSIGN_WIDTH + eBUTTON_RADIO_BOX_MARGIN_X - 5;
484                uint16_t check_y = y + (eBUTTON_RADIO_BOX_WIDTH / 4);
485
486        if ((idx < p_app->settings.num_channels) && (!p_app->settings.ch[idx].hidden))
487        {
488                        /* draw BLACK outline */
489                        bgfx_fill_rect(&p_app->surf,check_x,check_y,
490                                                   eBUTTON_RADIO_BOX_WIDTH,eBUTTON_RADIO_BOX_WIDTH,eCOLOR_BLACK);
491
492                        /* draw GREEN checkbox background */
493                        bgfx_fill_rect(&p_app->surf,check_x + eBUTTON_RADIO_BOX_BORDER,check_y + eBUTTON_RADIO_BOX_BORDER,
494                                                   eBUTTON_RADIO_BOX_WIDTH - (2 * eBUTTON_RADIO_BOX_BORDER),
495                                                   eBUTTON_RADIO_BOX_WIDTH - (2 * eBUTTON_RADIO_BOX_BORDER),eCOLOR_NEON_GREEN);
496                        /* draw dot in middle for colorblind users */
497                        bgfx_fill_rect(&p_app->surf,check_x + (eBUTTON_RADIO_BOX_WIDTH / 2) - (eBUTTON_RADIO_BOX_DOT_WIDTH / 2),
498                                                   check_y + (eBUTTON_RADIO_BOX_WIDTH / 2) - (eBUTTON_RADIO_BOX_DOT_WIDTH / 2),
499                                                   eBUTTON_RADIO_BOX_DOT_WIDTH, eBUTTON_RADIO_BOX_DOT_WIDTH, eCOLOR_BLACK);
500        } else
501        {
502                        /* draw BLACK outline */
503                        bgfx_fill_rect(&p_app->surf,check_x,check_y,
504                                                   eBUTTON_RADIO_BOX_WIDTH,eBUTTON_RADIO_BOX_WIDTH,eCOLOR_BLACK);
505
506                        /* draw WHITE checkbox background */
507                        bgfx_fill_rect(&p_app->surf,check_x + eBUTTON_RADIO_BOX_BORDER,check_y + eBUTTON_RADIO_BOX_BORDER,
508                                                   eBUTTON_RADIO_BOX_WIDTH - (2 * eBUTTON_RADIO_BOX_BORDER),
509                                                   eBUTTON_RADIO_BOX_WIDTH - (2 * eBUTTON_RADIO_BOX_BORDER),eCOLOR_WHITE);
510        }
511    }
512#else
513    {
514                x += eSCREEN_GUIDE_CALLSIGN_WIDTH;
515                if ((idx < p_app->settings.num_channels) && (!p_app->settings.ch[idx].hidden))
516                {
517                        num_chars = SCREEN_MAX_STR_WIDTH;
518                        bscreen_get_string(p_app->lang,eTEXT_STORED, p_app->tmp_str, &num_chars);
519                } else
520                {
521                        num_chars = SCREEN_MAX_STR_WIDTH;
522                        bscreen_get_string(p_app->lang,eTEXT_SKIPPED, p_app->tmp_str, &num_chars);
523                }
524                bgfx_string_info(p_app->p_font[p_app->lang][eFONT_SIZE_SMALL],
525                                                 (const unsigned long *)p_app->tmp_str,num_chars,&w,&h);
526
527                if (selected && (p_gs->column == 0))
528                {
529                        bbutton_t button;
530                        button.text_id = eTEXT_MAX;
531                        button.desc_text_id = eTEXT_MAX;
532                        button.type = eBUTTON_MENU;
533                        button.x = x-offset;
534                        button.y = y;
535                        button.width = eSCREEN_GUIDE_HIDDEN_WIDTH[p_app->lang];
536                        button.height = eSCREEN_GUIDE_HEIGHT;
537
538                        bscreen_draw_button_str(p_app,&button,selected,0,p_app->tmp_str,
539                                                                        num_chars,NULL,0,eFONT_SIZE_SMALL,0);
540                }
541                else
542                {
543
544                        guide_text_box(&p_app->surf, p_app->p_font[p_app->lang][eFONT_SIZE_SMALL],
545                                x, str_y, eSCREEN_GUIDE_HIDDEN_WIDTH[p_app->lang], eSCREEN_GUIDE_HEIGHT, 
546                                p_app->tmp_str, num_chars, eCOLOR_WHITE,eCOLOR_BLACK, eMENU_TEXT_DROPSHADOW ,eSCREEN_GUIDE_SPACING);
547                }
548        }
549#endif
550#endif
551
552    /* String channel name column */
553    if (p_info)
554        num_chars = c_to_uni_str(p_info->eit_info[EIT_CURRENT].prog_title,p_app->tmp_str,MAX_TITLE_CHARS);
555    else
556        num_chars = 0;
557
558    if (num_chars == 0)
559    {
560/*        num_chars = snprintf(p_gs->ch_num_str,31,"Channel - %d.%d", */
561/*                 p_app->settings.ch[idx].major,*/
562/*                 p_app->settings.ch[idx].minor);*/
563/*        num_chars = c_to_uni_str(p_gs->ch_num_str,p_app->tmp_str,num_chars);*/
564
565        num_chars = SCREEN_MAX_STR_WIDTH;
566        bscreen_get_string(p_app->lang,eTEXT_NO_GUIDE_DATA, p_app->tmp_str, &num_chars);
567    }
568
569#ifdef CONFIG_CH_HIDDEN
570    x = eSCREEN_GUIDE_CUR_X[p_app->lang];
571        guide_width = eSCREEN_GUIDE_NAME_WIDTH[p_app->lang];
572#else
573    x = eSCREEN_GUIDE_CUR_X;
574        guide_width = eSCREEN_GUIDE_NAME_WIDTH;
575#endif
576
577    bgfx_fill_rect(&p_app->surf,x-1, y-1, guide_width + 2,eSCREEN_GUIDE_HEIGHT + 2,bkgnd_color);
578    if (selected && (p_gs->column == 1))
579    {
580        bbutton_t button;
581        button.text_id = eTEXT_MAX;
582        button.desc_text_id = eTEXT_MAX;
583        button.type = eBUTTON_MENU;
584        button.x = x-offset;
585        button.y = y;
586        button.width = guide_width+offset;
587        button.height = eSCREEN_GUIDE_HEIGHT;
588
589        bscreen_draw_button_str(p_app,&button,selected,0,p_app->tmp_str,
590                                num_chars,NULL,0,eFONT_SIZE_SMALL,0);
591    }
592    else
593    {
594        /* draw channel name column */
595        guide_text_box(&p_app->surf, p_app->p_font[p_app->lang][eFONT_SIZE_SMALL],
596            x, str_y, guide_width, eSCREEN_GUIDE_HEIGHT, 
597            p_app->tmp_str, num_chars, eCOLOR_WHITE,eCOLOR_BLACK, eMENU_TEXT_DROPSHADOW ,eSCREEN_GUIDE_SPACING);
598    }
599
600    /* String for current column */
601    if (p_info)
602        num_chars = c_to_uni_str(p_info->eit_info[EIT_NEXT].prog_title,p_app->tmp_str,MAX_TITLE_CHARS);
603    else
604        num_chars = 0;
605
606    if (num_chars == 0)
607    {
608        num_chars = SCREEN_MAX_STR_WIDTH;
609        bscreen_get_string(p_app->lang,eTEXT_NO_GUIDE_DATA, p_app->tmp_str, &num_chars);
610    }
611    /* draw channel column */
612    x = eSCREEN_GUIDE_NEXT_X;
613    bgfx_fill_rect(&p_app->surf,x, y, guide_width,eSCREEN_GUIDE_HEIGHT,bkgnd_color);
614    guide_text_box(&p_app->surf, p_app->p_font[p_app->lang][eFONT_SIZE_SMALL],
615        x, str_y, guide_width, eSCREEN_GUIDE_HEIGHT, 
616        p_app->tmp_str, num_chars, eCOLOR_WHITE,eCOLOR_BLACK, eMENU_TEXT_DROPSHADOW ,eSCREEN_GUIDE_SPACING);
617}
618
619/*
620Summary:
621    Get the guide info for this entry.
622*/
623static chm_info_t* screen_guide_get_info(bapp_t *p_app, int idx)
624{
625    chm_info_t          *p_info;
626
627    if (idx >= p_app->chm.max_info_num)
628    {
629        BDBG_MSG(("No memory available for guide entry %d\n", idx));
630        return NULL;       
631    }
632    p_info = &(p_app->chm.p_info[idx]);
633   
634#ifdef STATIC_GUIDE_TEST
635    memset(p_info,0,sizeof(chm_info_t));
636
637    p_info->ch_name[0] = 'A';p_info->ch_name[1] = 'B';p_info->ch_name[2] = 'C';p_info->ch_name[3] = 'D';
638    snprintf(p_info->eit_info[EIT_CURRENT].prog_title, 32,"Program-%d",idx);
639    snprintf(p_info->eit_info[EIT_NEXT].prog_title, 32,"Next Program-%d",idx);
640#endif
641   
642    return p_info;
643}
644
645/*
646Summary:
647    Guide screen drawing function
648    .
649*/
650void bscreen_guide_draw(void *v_app, void *v_screen)
651{
652    bapp_t *p_app = (bapp_t*)v_app;
653    bscreen_t *p_screen = (bscreen_t*)v_screen;
654    guide_state_t *p_gs;
655    unsigned int num_chars;
656    chm_info_t          *p_info;
657    int idx;
658   
659    p_gs = (guide_state_t*)p_screen->local_state;
660    BDBG_ASSERT(p_gs);
661
662    bscreen_draw_background(v_app, &p_app->surf, p_screen->top_banner_height);
663   
664    /* draw title */
665    num_chars = SCREEN_MAX_STR_WIDTH;
666    bscreen_get_string(p_app->lang,p_screen->title_text_id, p_app->tmp_str, &num_chars);
667    text_box_shadow(&p_app->surf, p_app->p_font[p_app->lang][eFONT_SIZE_LARGE],
668        eMENU_TITLE_TEXT_X, eMENU_TITLE_TEXT_Y,
669        eMENU_TITLE_TEXT_WIDTH, eMENU_TITLE_TEXT_HEIGHT,  p_app->tmp_str,
670        num_chars, eCOLOR_MED_YELLOW,eCOLOR_BLACK, eMENU_TEXT_DROPSHADOW ,eSCREEN_GUIDE_SPACING);
671
672    /* draw guide data update progress */
673    if (p_gs->update_progress < 100)
674    {
675        int num_chars = SCREEN_MAX_STR_WIDTH;
676                int w = 0;
677                int h = 0;
678
679        /* draw progress text */
680        bscreen_get_string(p_app->lang,eTEXT_GUIDE_DL_PROGRESS, p_app->tmp_str, &num_chars);
681                bgfx_string_info(p_app->p_font[p_app->lang][eFONT_SIZE_SMALL],(const unsigned long *)p_app->tmp_str,num_chars,&w,&h);
682        text_box_shadow(&p_app->surf, p_app->p_font[p_app->lang][eFONT_SIZE_SMALL],
683            ePROGRESS_GUIDE_X - w - 7, ePROGRESS_GUIDE_TEXT_Y,
684            w + 3, ePROGRESS_GUIDE_TEXT_HEIGHT,  p_app->tmp_str,
685            num_chars, eCOLOR_MED_YELLOW,eCOLOR_BLACK, eMENU_TEXT_DROPSHADOW ,100);
686
687        bscreen_draw_progress(v_app, ePROGRESS_GUIDE_X, ePROGRESS_GUIDE_Y, ePROGRESS_GUIDE_WIDTH, ePROGRESS_GUIDE_HEIGHT, 
688                              eBUTTON_VOL_PROGRESS_BORDER, eCOLOR_WHITE, eCOLOR_DRK_BLUE, p_gs->update_progress);
689    }
690    else
691    {
692        bgfx_fill_rect(&p_app->surf,ePROGRESS_GUIDE_TEXT_X,ePROGRESS_GUIDE_Y,
693                       ePROGRESS_GUIDE_TEXT_WIDTH+ePROGRESS_GUIDE_WIDTH,ePROGRESS_GUIDE_HEIGHT,eCOLOR_LT_BLUE);
694    }
695
696    /* draw column header bar */
697    bgfx_fill_rect(&p_app->surf,eSCREEN_ACTION_SAFE_X+4,
698        eMENU_TITLE_TEXT_Y + eMENU_TITLE_TEXT_HEIGHT + 2,
699                   eSCREEN_ACTION_SAFE_WIDTH-8,eINFO_AREA_HEIGHT - 6,eCOLOR_DRK_BLUE);
700
701    /* draw column header */
702    num_chars = SCREEN_MAX_STR_WIDTH;
703    bscreen_get_string(p_app->lang,eTEXT_GUIDE_HEADER, p_app->tmp_str, &num_chars);
704    text_box_shadow(&p_app->surf, p_app->p_font[p_app->lang][eFONT_SIZE_SMALL],
705        eSCREEN_GUIDE_X, eMENU_TITLE_TEXT_Y + eMENU_TITLE_TEXT_HEIGHT + 6 ,
706        eWIDTH, eINFO_AREA_HEIGHT,  p_app->tmp_str,
707        num_chars, eCOLOR_WHITE,eCOLOR_BLACK, eMENU_TEXT_DROPSHADOW ,eSCREEN_GUIDE_SPACING);
708
709    if (p_app->settings.num_channels > 0)
710    {
711        /* Draw the guide entries */
712        for (idx = p_gs->offset; 
713             idx < GUIDE_MIN(p_app->settings.num_channels,
714                             (p_gs->offset + MAX_GUIDE_ENTRIES)); ++idx)
715        {
716            p_info = screen_guide_get_info(p_app,idx);
717            draw_guide_entry(p_app,p_screen,p_gs, idx,p_info, 
718                                 (idx == p_gs->selection) ? true : false);
719        }
720    }
721    else
722    {
723        int w = 0;
724        int h = 0;
725        /* No channels in channel map so show "No Programs Available" */
726        num_chars = SCREEN_MAX_STR_WIDTH;
727        bscreen_get_string(p_app->lang,eTEXT_NO_GUIDE_DATA, p_app->tmp_str, &num_chars);
728        bgfx_string_info(p_app->p_font[p_app->lang][eFONT_SIZE_SMALL],(const unsigned long *)p_app->tmp_str,num_chars,&w,&h);
729        text_box_shadow(&p_app->surf, p_app->p_font[p_app->lang][eFONT_SIZE_SMALL],
730            eSCREEN_GUIDE_X+((eWIDTH-(2*eSCREEN_GUIDE_X))/2)-(w/2), 
731            eSCREEN_ACTION_SAFE_Y + eSCREEN_ACTION_SAFE_HEIGHT/2,
732            w+5, h, p_app->tmp_str,
733            num_chars, eCOLOR_WHITE,eCOLOR_BLACK, eMENU_TEXT_DROPSHADOW ,eSCREEN_GUIDE_SPACING);
734    }
735
736        draw_navigation_hints(v_app, v_screen);
737}
Note: See TracBrowser for help on using the repository browser.