source: svn/newcon3bcm2_21bu/dst/app/src/kview/OSD/App_OSD_Epg.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: 43.8 KB
Line 
1/****************************************************************************
2* NAME: App_OSD_Epg.c
3*----------------------------------------------------------------------------
4* Copyright (c) DIGITAL STREAM Technology Inc.
5*----------------------------------------------------------------------------
6* CREATED_BY: Do Gon Lee
7* CREATION_DATE: 2009/08/25
8* $Author: foxhunt $
9* $Revision: 1.0 $
10* $Date: 2009/08/25 16:20:41 $
11*----------------------------------------------------------------------------
12* PURPOSE:
13* - EPG OSD implement
14*****************************************************************************/
15
16/*_____ I N C L U D E __________________________________________*/
17
18#include "App_Main.h"
19#include "App_OSD_Common.h"
20
21#include "DLIB_PSI_Utils.h"
22
23#include "App_Fnc_Common.h"
24#include "App_Fnc_ChTune.h"
25#include "App_Fnc_Time.h"
26
27#include "App_OSD_Banner.h"
28#include "App_OSD_Epg.h"
29#include "App_Res_Resources.h"
30
31
32
33
34/*_____ D E F I N I T I O N ____________________________________*/
35
36#if COMMENT
37_____DbgPrint_____(){}
38#endif
39
40DHL_MODULE("@o_epg", 0);
41
42
43
44
45
46#if COMMENT
47_____Config_____(){}
48#endif
49
50/* EPG coordinates define */
51#define EPG_BOX_X         64
52#define EPG_BOX_Y         48
53#define EPG_BOX_W         592
54#define EPG_BOX_H         384
55
56#define EPG_CH_BG_X       82
57#define EPG_CH_BG_Y       66
58#define EPG_CH_BG_W       555
59#define EPG_CH_BG_H       72
60
61#define EPG_DETAIL_BOX_Y  207
62#define EPG_DETAIL_BOX_H1 140
63#define EPG_DETAIL_BOX_H2 166
64
65#define EPG_DETAIL_CH_INFO_Y 135
66#define EPG_DETAIL_CH_INFO_W 500
67#define EPG_DETAIL_TIME_INFO_Y 166
68#define EPG_DETAIL_TIME_INFO_W 300
69
70#define EPG_CH_DTV_ICON_X 90
71#define EPG_CH_DTV_ICON_Y 109
72
73#define EPG_CH_TEXT_X 127
74#define EPG_CH_TEXT_Y 108
75
76#define EPG_DTV_ICON_X    90
77#define EPG_DTV_ICON_Y    148
78
79#define EPG_CUR_TIME_X          402
80#define EPG_CUR_TIME_Y          74
81#define EPG_CUR_TIME_W          223
82#define EPG_CUR_TIME_H          30
83
84#define EPG_CH_INFO_TEXT_X              90
85#define EPG_CH_INFO_TEXT_Y              140
86#define EPG_CH_INFO_TEXT_W              243
87#define EPG_CH_INFO_TEXT_H              30
88#define EPG_TIME_INFO_TEXT_X    (351-1)
89#define EPG_TIME_INFO_TEXT_W    (257+3)
90
91#define EPG_CH_INFO_BOX_X               82
92#define EPG_CH_INFO_BOX_Y               138
93#define EPG_CH_INFO_BOX_W               259
94#define EPG_TIME_INFO_BOX_X     342
95#define EPG_TIME_INFO_BOX_W             271
96#define EPG_INFO_H                              34
97#define EPG_INFO_GAP                    34
98
99#define EPG_MENU_KEY_X  103
100#define EPG_MENU_KEY_Y  392
101#if 0
102#define EPG_MENU_KEY_W  104
103#else
104#define EPG_MENU_KEY_W  208
105#endif
106#define EPG_MENU_KEY_H  20
107#define EPG_OK_KEY_X    252
108#define EPG_OK_KEY_W    250//116
109
110/* EPG event information position */
111#define EPG_INFO_X        73    // EPG event information X position
112#define EPG_INFO_Y        125   // EPG event information Y position
113#define EPG_INFO_W        275   // EPG event information entire width
114//#define EPG_INFO_H        37   // EPG event information entire height (2 line height)
115
116
117/* EPG detail banner position */
118#define EPG_DINFO_X       90    // EPG detail banner X position
119#define EPG_DINFO_Y       110   // EPG detail banner Y position
120#define EPG_DINFO_W       415   // EPG event information entire width
121
122/* EPG scroll position */
123#define EPG_SCROLL_UP_X         615   // EPG scroll image X position (À§ÂÊ È­»ìÇ¥ XÁÂÇ¥)
124#define EPG_SCROLL_UP_Y         139   // EPG scroll image Y position (À§ÂÊ È­»ìÇ¥ YÁÂÇ¥)
125#define EPG_SCROLL_DOWN_Y       355   // EPG detail scroll imgae Y position
126
127#define EPG_SCROLL_BG_X         612
128#define EPG_SCROLL_BG_Y         138
129#define EPG_SCROLL_BG_W         25    // EPG scroll pointer width (scroll À̹ÌÁö Áß Á¦ÀÏ ³ÐÀº °Í ±âÁØ)
130#define EPG_SCROLL_BG_H         238   // EPG scroll entire area height (scroll ±¸¿ª Àüü ±æÀÌ)
131#define EPG_SCROLL_BG_MID_H     194
132
133#define EPG_SCROLL_POINT_X      615
134#define EPG_SCROLL_POINT_Y      159
135#define EPG_SCROLL_POINT_H      34
136
137#define C_EPG_TITLE             0xFF1E3C5F
138#define C_EPG_DATA              0xFF8CE1FF
139#define C_EPG_HIGHLIGHT 0xFF000000
140#define C_EPG_MENUKEY1  0xFFD7E8F7
141#define C_EPG_MENUKEY2  0xFFB2E0F8
142
143
144
145
146#if COMMENT
147_____Types_____(){}
148#endif
149
150
151
152
153
154#if COMMENT
155_____Variables_____(){}
156#endif
157
158
159
160
161
162/*_____ F U N C T I O N ________________________________________*/
163
164#if COMMENT
165___EPG_Base___() {}
166#endif
167
168/******************************************************************************************
169FUNCTION:
170  - App_OSD_DrawEpgBase
171
172Purpose:
173  - epg ¹è°æÀ̹ÌÁö, °íÁ¤ ÅؽºÆ®°¡ ±×·ÁÁø´Ù.
174  - consist of draw, erase, backup, restore.
175******************************************************************************************/
176void App_OSD_DrawEpgBase()
177{
178        int i, orig_font_size;
179        orig_font_size=DMG_GetFontSize();
180        DMG_SetFontSize(22); // 18 Epg OSD Default font size : 16
181       
182        /* EPG default background image */
183        App_OSD_CommonBox1(EPG_BOX_X, EPG_BOX_Y, EPG_BOX_W, EPG_BOX_H, 6, 2, CHEDIT_BG_COLOR_1, CHEDIT_BG_COLOR_3, CHEDIT_BG_COLOR_2);
184       
185        /* EPG CH info. background image */
186        App_OSD_CommonBox2(EPG_CH_BG_X, EPG_CH_BG_Y, EPG_CH_BG_W, EPG_CH_BG_H, 2, CHEDIT_BG_COLOR_7, CHEDIT_BG_COLOR_5, CHEDIT_BG_COLOR_4);
187
188        /* EPG event info. background image */
189        for (i = 0; i < 7; i++)
190        {
191                App_OSD_CommonBox2(EPG_CH_INFO_BOX_X, EPG_CH_INFO_BOX_Y+(i*EPG_INFO_GAP)/*-4*/, EPG_CH_INFO_BOX_W, EPG_INFO_H, 2, CHEDIT_BG_COLOR_8, CHEDIT_BG_COLOR_5, CHEDIT_BG_COLOR_4);
192                App_OSD_CommonBox2(EPG_TIME_INFO_BOX_X, EPG_CH_INFO_BOX_Y+(i*EPG_INFO_GAP), EPG_TIME_INFO_BOX_W, EPG_INFO_H, 2, CHEDIT_BG_COLOR_8, CHEDIT_BG_COLOR_5, CHEDIT_BG_COLOR_4);
193        }
194
195        /* EPG scroll background image */
196        App_OSD_CommonBox2(EPG_SCROLL_BG_X, EPG_SCROLL_BG_Y, EPG_SCROLL_BG_W, EPG_SCROLL_BG_H, 2, CHEDIT_BG_COLOR_8, CHEDIT_BG_COLOR_8, CHEDIT_BG_COLOR_4);
197        App_OSD_CommonBox3(EPG_TIME_INFO_BOX_X+EPG_TIME_INFO_BOX_W-1, EPG_SCROLL_BG_Y+EPG_SCROLL_BG_H-2, 2, 2, CHEDIT_BG_COLOR_4);
198        App_OSD_CommonBox3(EPG_SCROLL_BG_X+EPG_SCROLL_BG_W-2, EPG_SCROLL_BG_Y, 2, 2, CHEDIT_BG_COLOR_4);
199       
200        /* bottom description : MENU: Back ... */
201#if 0
202        PRINT_STR_EX(EPG_MENU_KEY_X, EPG_MENU_KEY_Y, EPG_MENU_KEY_W, EPG_MENU_KEY_H, EPG_BOTTOM1, C_EPG_MENUKEY1, DMG_OPT_A_LT);
203        PRINT_STR_EX(EPG_MENU_KEY_X+70, EPG_MENU_KEY_Y, EPG_MENU_KEY_W, EPG_MENU_KEY_H, EPG_BOTTOM2, C_EPG_MENUKEY2, DMG_OPT_A_LT);
204#else
205        PRINT_STR_EX(EPG_MENU_KEY_X, EPG_MENU_KEY_Y, EPG_MENU_KEY_W, EPG_MENU_KEY_H, EPG_BOTTOM1, C_EPG_MENUKEY1, DMG_OPT_A_LT);
206#endif
207        /* bottom description : Pre/Next... */
208        PRINT_STR_EX(EPG_OK_KEY_X, EPG_MENU_KEY_Y, EPG_OK_KEY_W, EPG_MENU_KEY_H, EPG_BOTTOM3, C_EPG_MENUKEY1, DMG_OPT_A_LT);
209        PRINT_STR_EX(EPG_OK_KEY_X+50, EPG_MENU_KEY_Y, EPG_OK_KEY_W, EPG_MENU_KEY_H, EPG_BOTTOM4, C_EPG_MENUKEY2, DMG_OPT_A_LT);
210
211        /* backup plane for BLT - óÀ½ À̹ÌÁö¸¦ back-upÇØ¾ß ÇϹǷÎ, EPG_BG ´ÙÀ½¿¡ È£ÃâµÇ¾î¾ß ÇÑ´Ù.*/
212        App_OSD_BackupScreen(EPG_BOX_X, EPG_BOX_Y, EPG_BOX_W, EPG_BOX_H);
213        App_OSD_BackupScreen(EPG_CH_INFO_BOX_X, EPG_CH_INFO_BOX_Y, EPG_CH_INFO_BOX_W+EPG_TIME_INFO_BOX_W, EPG_CH_INFO_BOX_Y+(7*EPG_INFO_GAP));  //backup event info
214        App_OSD_BackupScreen(EPG_SCROLL_BG_X, EPG_SCROLL_BG_Y, EPG_SCROLL_BG_W, EPG_SCROLL_BG_H);       // backup scroll
215        App_OSD_BackupScreen(EPG_MENU_KEY_X, EPG_MENU_KEY_Y, EPG_MENU_KEY_W+EPG_OK_KEY_W, EPG_MENU_KEY_H);      // backup bottom description
216
217        DMG_SetFontSize(orig_font_size);
218}
219
220
221/******************************************************************************************
222FUNCTION:
223  - p_erase_epgbase
224
225Purpose:
226  - ¼³Á¤µÈ ÁÂÇ¥ÀÇ EPG Base È­¸éÀ» Áö¿î´Ù.
227******************************************************************************************/
228void p_erase_epgbase()
229{
230        DMG_EraseRect(EPG_BOX_X, EPG_BOX_Y, EPG_BOX_W, EPG_BOX_H, 0x0);
231}
232
233
234/******************************************************************************************
235FUNCTION:
236  - p_backup_epgbase
237
238Purpose:
239  - ÇöÀç »ç¿ëÁßÀÎ EPG È­¸éÀ» back-up
240  - EPG detail box pop-up ¶ç¿ì±â Àü¿¡ »ç¿ëÇÑ´Ù.
241******************************************************************************************/
242void p_backup_epgbase()
243{
244        App_OSD_BackupScreen(EPG_BOX_X, EPG_BOX_Y, EPG_BOX_W, EPG_BOX_H);
245}
246
247
248/******************************************************************************************
249FUNCTION:
250  - p_restore_epgbase / App_OSD_RestoreEpgBase
251
252Purpose:
253  - p_backup_epgbase¿¡¼­ ¹é¾÷ÇصРEPG Base È­¸éÀ» º¹±¸ÇÑ´Ù.
254******************************************************************************************/
255void p_restore_epgbase()
256{
257        App_OSD_RestoreScreen(EPG_BOX_X, EPG_BOX_Y, EPG_BOX_W, EPG_BOX_H);
258}
259
260
261#if COMMENT
262___EPG_Time___() {}
263#endif
264
265/******************************************************************************************
266FUNCTION:
267  - App_OSD_DrawEpgCurrentTime
268
269Purpose:
270  - display current time in epg content
271  - consist of draw, erase, backup, restore.
272******************************************************************************************/
273void App_OSD_DrawEpgCurrentTime(APP_TIME_T nCurTime, BOOL bModify)
274{
275        char str[20];
276        AppTime_GetCurTime(&nCurTime, 1);
277       
278        if(bModify)
279        {
280                p_erase_current_time();                                                    // erase current time
281                App_OSD_RestoreScreen(EPG_CUR_TIME_X, EPG_CUR_TIME_Y, EPG_CUR_TIME_W, EPG_CUR_TIME_H);
282        }
283
284        DMG_SetFontSize(20);
285        App_MakeDateTimeString(str, nCurTime, 3);   // [Sun] 1/10
286        DMG_PrintStrEx(EPG_CUR_TIME_X, EPG_CUR_TIME_Y, EPG_CUR_TIME_W, EPG_CUR_TIME_H, str, C_EPG_TITLE, DMG_OPT_A_RT);
287}
288
289
290void p_erase_current_time()
291{       // Time, Date, AM/PM Àüü ¿µ¿ª erase
292        DMG_EraseRect(EPG_CUR_TIME_X, EPG_CUR_TIME_Y, EPG_CUR_TIME_W, EPG_CUR_TIME_H, 0x0);
293}
294
295
296
297
298
299#if COMMENT
300___EPG_Time_Ruler___() {}
301#endif
302
303/******************************************************************************************
304FUNCTION:
305  - App_OSD_EpgTimeRuler
306
307Purpose:
308  - epg »óÀ§ °¡·ÎÁÙ ÇÁ·¹ÀÓÀÇ Date¿Í TimeRuler¸¦ ±×¸®´Â ÇÔ¼ö
309  - consist of draw, erase, backup, restore.
310******************************************************************************************/
311#if 0
312void App_OSD_EpgTimeRuler(APP_TIME_T nCurTime, UINT32 nPageStartTime, BOOL bModify)
313{
314        int i, nX;
315        char str[20];
316        APP_TIME_T tmpTime;
317        UINT32 tmpPageTime;
318        DMG_SetFontSize(16);  // Time Ruler font size : 16
319       
320        AppTime_GetCurTime(&nCurTime, 1); // 2009.11.30 foxhunt X:29, X:59·Î º¸ÀÌ´Â ¹®Á¦ °ü·Ã ÀÓ½Ãó¹æ
321       
322        if(bModify)
323        {
324                p_erase_timeruler();                                                        // erase time ruler
325                App_OSD_RestoreScreen(EPG_RULER_DX, EPG_RULER_Y, EPG_RULER_W, EPG_RULER_H); // restore time ruler
326        }
327       
328       
329        /* Draw Current Time Arrow */
330        App_OSD_EpgCurArrow(nCurTime, nPageStartTime, FALSE);
331       
332       
333        /* Print Date */
334        tmpPageTime = nPageStartTime;
335        AppTime_GetTimeFromGPS(tmpPageTime, &tmpTime);
336        App_MakeDateTimeString(str, tmpTime, 3);    // Jan.10(SUN)
337        DMG_PrintStrEx(EPG_RULER_DX, EPG_RULER_Y+5, EPG_RULER_DW, 20, str, EPG_FC_DATE, DMG_OPT_A_CT);
338       
339        /* Print Time */
340        for(i=0; i<4; i++)
341        {
342                AppTime_GetTimeFromGPS(tmpPageTime+i*30*60, &tmpTime);
343                App_MakeDateTimeString(str, tmpTime, 6);  // 12:30 PM
344                nX = (EPG_RULER_TX+17) + i*(EPG_RULER_TW+2);
345               
346                if(i%2 != 0)    // 1,3 ¹ø° tab¿¡¸¸ Ãâ·ÂÇÑ´Ù. (for design)
347                        DMG_PrintStrEx(nX+2, EPG_RULER_Y, EPG_RULER_TW, 20, str, EPG_FC_DATE, DMG_OPT_A_LT);
348        }
349       
350}
351
352
353void p_erase_timeruler()
354{       // time ruler Àüü ¿µ¿ª erase
355        DMG_EraseRect(EPG_RULER_DX, EPG_RULER_Y, EPG_RULER_W, EPG_RULER_H, 0x0);
356}
357
358
359/******************************************************************************************
360FUNCTION:
361  - App_OSD_EpgCurArrow
362
363Purpose:
364  - time rulerÀ§ÀÇ ½Ç½Ã°£À» ¾Ë·ÁÁÖ´Â ºÐÈ«»ö È­»ìÇ¥
365  - consist of draw, erase, backup, restore.
366******************************************************************************************/
367void App_OSD_EpgCurArrow(APP_TIME_T nCurTime, UINT32 nPageStartTime, BOOL bModify)
368{
369        int i, nX, nY;
370        AppTime_GetCurTime(&nCurTime, 1);
371       
372        if(bModify)
373        {
374                p_erase_curarrow();                                                                // erase cur arrow
375                App_OSD_RestoreScreen(EPG_CARROW_X-9, EPG_CARROW_Y, EPG_CARROW_W+18, EPG_CARROW_H);// restore cur arrow
376        }
377       
378        /* ÇöÀç ½Ã°£ Áöħǥ. ÇöÀç ½Ã°£ÀÌ Æ÷ÇÔµÈ ÆäÀÌÁö¿¡¼­¸¸ Ç¥½ÃÇÑ´Ù. */
379        if(nCurTime.sys_time >= nPageStartTime && nCurTime.sys_time <= nPageStartTime+7200)
380        {
381                // ÇöÀç ½Ã°£ÀÌ Æ÷ÇԵǾî ÀÖ´Â Time RulerÀÇ ½ÃÀÛ ÁÂÇ¥
382                if(nCurTime.sys_time >= nPageStartTime + 5400)
383                        nX = EPG_CARROW_X + (EPG_RULER_TW+2)*3;
384                else if(nCurTime.sys_time >= nPageStartTime + 3600)
385                        nX = EPG_CARROW_X + (EPG_RULER_TW+2)*2;
386                else if(nCurTime.sys_time >= nPageStartTime + 1800)
387                        nX = EPG_CARROW_X + (EPG_RULER_TW+2);
388                else
389                        nX = EPG_CARROW_X;              // EPG_CUR_POINTER default X ÁÂÇ¥ (ºÐÈ«»ö È­»ìÇ¥)
390               
391                nX = nX + nCurTime.minute%30*(EPG_RULER_TW)/30 - 9;
392                nY = EPG_CARROW_Y;                      // EPG_CUR_POINTER default Y ÁÂÇ¥ (ºÐÈ«»ö È­»ìÇ¥)
393               
394                DRAW_IMAGE(nX, nY, EPG_CUR_POINTER);    // ÇöÀç ¹æ¼ÛÀÇ ½Ç½Ã°£ À§Ä¡¸¦ Ç¥½Ã
395        }
396       
397}
398
399
400void p_erase_curarrow()
401{       // time ruler Àüü ¿µ¿ª erase
402        DMG_EraseRect(EPG_CARROW_X-9, EPG_CARROW_Y, EPG_CARROW_W+18, EPG_CARROW_H, 0x0);
403}
404#endif
405
406
407
408
409#if COMMENT
410___EPG_Channel___() {}
411#endif
412
413/******************************************************************************************
414FUNCTION:
415  - App_OSD_DrawEpgChNum
416
417Purpose:
418  - display scaned channel list in left side.
419******************************************************************************************/
420void App_OSD_DrawEpgChNum(ChListInfo *EPGChList, UINT16 nCurChIdx, BOOL bModify)
421{
422        char major[10], minor[10];
423        tApp_UcmShortInfo chinfo;
424
425        memset(major, 0 , sizeof(major));
426        memset(minor, 0 , sizeof(minor));       
427       
428        DMG_SetFontSize(18);  // Channel number font size : 16
429       
430        if(bModify)
431        {
432                p_erase_chnum();                                                            // erase channel number
433                App_OSD_RestoreScreen(EPG_CH_BG_X, EPG_CH_BG_Y, EPG_CH_BG_W/2, EPG_CH_BG_H);// restore channel number
434        }
435
436        sprintf(major, "%d ", EPGChList[nCurChIdx].ListMajor);
437                       
438        if (EPGChList[nCurChIdx].ListMinor != 1024)
439        {
440                strcat(major, "- ");
441                sprintf(minor, "%d", EPGChList[nCurChIdx].ListMinor);
442                strcat(major, minor);
443        }
444       
445        App_GetUcmShortInfo(EPGChList[nCurChIdx].ListUID, &chinfo);
446       
447        if(chinfo.vid_pid==0 && chinfo.aud_pid) { //audio only
448                DRAW_IMAGE(EPG_CH_DTV_ICON_X, EPG_CH_DTV_ICON_Y, EPG_DTV_ICON_AUD1);
449        }
450        else {                 
451                // Draw focused DTV icon
452                switch(chinfo.video_format) {
453                        case eDHL_DISP_1920x1080i:
454                        case eDHL_DISP_1280x720p:       
455                                DRAW_IMAGE(EPG_CH_DTV_ICON_X, EPG_CH_DTV_ICON_Y, EPG_DTV_ICON_HD2);                                     
456                                break;
457                       
458                        default:
459                                DRAW_IMAGE(EPG_CH_DTV_ICON_X, EPG_CH_DTV_ICON_Y, EPG_DTV_ICON_SD2);
460                }
461        }
462       
463        return;
464}
465
466
467void p_erase_chnum()
468{       // channel number Àüü ¿µ¿ª erase
469        DMG_EraseRect(EPG_CH_BG_X, EPG_CH_BG_Y, EPG_CH_BG_W/2, EPG_CH_BG_H, 0x0);
470}
471
472
473
474
475
476#if COMMENT
477___EPG_Contents___() {}
478#endif
479/******************************************************************************************
480FUNCTION:
481  - App_OSD_DrawEpgContents
482
483Purpose:
484  - draw epg contents
485  - consist of draw, backup, erase, restore
486******************************************************************************************/
487#if 0
488void App_OSD_DrawEpgContents(UINT16 num_ch, int nIdx, UINT8 nEvent, strEPG_Data **PageEvent,
489                                        UINT8 *NumEvent)
490{
491        int i, j;
492        UINT16 nPageChannelNum = 0;      // ÇöÀç ÆäÀÌÁöÀÇ Ã¤³Î °¹¼ö
493       
494        // Calculate Channel List
495        nPageChannelNum = min(num_ch, 6);
496       
497        for(i=0; i<nPageChannelNum; i++)
498        {
499                for(j=0; j<NumEvent[i]; j++)
500                {
501                        { // event Àüü¸¦ ±×¸². ´ë°³ ´ÙÀ½ ÆäÀÌÁö¸¦ ±×¸± ¶§ »ç¿ë.
502                                if(i == nIdx && j == nEvent) // focus
503                                        App_OSD_DrawEventBox(1, i, PageEvent[i][j]);
504                                else                         // not focus
505                                        App_OSD_DrawEventBox(0, i, PageEvent[i][j]);
506                        }
507                } // end 'j' for
508        }   // end 'i' for
509       
510}
511
512
513void p_backup_event_entire()
514{       // EPG event Àüü ¿µ¿ª backup / ¿À¸¥ÂÊ EPG_LINEÀ» Áö¿ì°í º¹±¸Çϱâ À§ÇØ EPG_EVENT_W+2·Î º¯°æ
515        App_OSD_BackupScreen(EPG_EVENT_X, EPG_EVENT_Y, EPG_EVENT_W+2, (EPG_EVENT_H-1)*6);
516}
517
518
519void p_erase_event_entire()
520{       // EPG event Àüü ¿µ¿ª erase / ¿À¸¥ÂÊ EPG_LINEÀ» Áö¿ì°í º¹±¸Çϱâ À§ÇØ EPG_EVENT_W+2·Î º¯°æ
521        DMG_EraseRect(EPG_EVENT_X, EPG_EVENT_Y, EPG_EVENT_W+2, (EPG_EVENT_H-1)*6, 0x0);
522}
523
524
525void p_restore_event_entire()
526{       // EPG event Àüü ¿µ¿ª restore / ¿À¸¥ÂÊ EPG_LINEÀ» Áö¿ì°í º¹±¸Çϱâ À§ÇØ EPG_EVENT_W+2·Î º¯°æ
527        App_OSD_RestoreScreen(EPG_EVENT_X, EPG_EVENT_Y, EPG_EVENT_W+2, (EPG_EVENT_H-1)*6);
528}
529#endif
530
531/*********************************************************************************************
532FUNCTION:
533  - App_OSD_MakeEpgContents
534
535Purpose:
536  - make epg contents
537  - pNumEvent : ½ÇÁ¦ À̺¥Æ® °¹¼ö
538  - NumEvent : È­¸é¿¡ º¸ÀÏ À̺¥Æ® °¹¼ö
539**********************************************************************************************/
540void App_OSD_MakeEpgContents(APP_TIME_T nCurTime, UINT32 nPageStartTime, ChListInfo *EPGChList, 
541          UINT16 nStartChIdx, strEPG_Data **PageEvent, UINT8 *NumEvent, UINT8 *pNumEvent)
542{
543        DmcEpgStatus scan_stat;
544       
545        int i, l, m, pIndex;
546        int event_num, valid_event_num;
547        int NumTemp;
548        int validNumTemp = 0;
549        UINT32 StartTap = 0;
550        DMW_EpgEventPtr event;
551        BOOL bTocken = FALSE;
552        UINT32 duration;
553        UINT32 flag = GET_EVENT_TITLE | 0x000032;
554        BOOL bNeedToWaitMore;
555       
556        dprint(3, "////////// [%s] //////////\n\n", __FUNCTION__);
557       
558        for(i=0; i<6; i++)      // 6°³ ¹Ú½º°¡ ±×·ÁÁöÁö ¾Ê¾Æ °­Á¦·Î 6À¸·Î ¼³Á¤ÇÏ¿´´Ù.
559        {
560                pIndex = 0;
561                valid_event_num = 0;  // ValidÇÑ À̺¥Æ® ¼ö (< NumTemp)
562                event_num = 0;        // Àüü À̺¥Æ® ¼ö
563                m = 0;
564                bTocken = FALSE;
565                StartTap = nPageStartTime;
566               
567                // Erase previous EVENT.
568                while(TRUE)
569                {
570                        if(pNumEvent[i]>0 && (!(PageEvent[i][m].StatusFlag & Program_EMPTY)) )
571                        {
572                                dprint(1, "[[EpgEvents Free!]] PageEvent[%d][%d].StatusFlag : %d\n", i, m, PageEvent[i][m].StatusFlag);
573                                if(PageEvent[i][m].EPG_event)
574                                {
575                                        dprint(3, "PageEvent[%d][%d].EPG_event is exist\n", i, m);
576                                        dprint(3, "PageEvent[%d][%d]: %s\n", i, m, PageEvent[i][m].EPG_event->titleText);
577                                }                               
578                                else
579                                        dprint(3, "PageEvent[%d][%d].EPG_event is not exist\n", i, m);
580                               
581                                DMW_EPG_FreeEpgEvents(PageEvent[i][m].EPG_event, pNumEvent[i]);
582                                break;
583                        }
584                        m++;
585                        if(m > NumEvent[i]-1)
586                        {
587                                break;
588                        }
589                }
590               
591               
592                /* ?? */
593                DMW_EPG_GetScanStatus(EPGChList[i+nStartChIdx].ListUID, &scan_stat);
594                if(scan_stat.cStatus==EPG_STATUS_SUBCH_COMPLETE || scan_stat.cStatus==EPG_STATUS_CH_COMPLETE)
595                {
596                        bNeedToWaitMore = FALSE;        // "no info available"
597                }
598                else if(scan_stat.nElapsedSec > 6)
599                {
600                        bNeedToWaitMore = FALSE;        // "no info available"
601                }
602                else
603                        bNeedToWaitMore = TRUE;         // "no info acquired"
604               
605                dprint(5, "info : bNeedToWaitMore -> %d\n", bNeedToWaitMore);
606               
607                if(EPGChList[i+nStartChIdx].VctFlag)
608                {
609                        NumTemp = 0;
610                        duration = 86400-59-1;
611                        if(DMW_EPG_GetEventsInRange(EPGChList[i+nStartChIdx].ListUID, 
612                                                                nPageStartTime+59, duration, &event, &NumTemp, flag)==statusOK)
613                        {
614                                dprint(1, "[DEBUG] UID: %d, Event Number : %d\n", EPGChList[i+nStartChIdx].ListUID, NumTemp);
615                                if(NumTemp > 0)
616                                {
617                                        bTocken = TRUE;
618                                        validNumTemp = NumTemp;
619                                }
620                                else
621                                        pNumEvent[i] = 0;
622                        }
623                       
624                        if(bTocken)
625                        {
626                                pNumEvent[i] = NumTemp;
627                               
628                                while(TRUE)
629                                {
630                                        if(valid_event_num==NumTemp)    // ÇÑÆäÀÌÁö°¡ ³¡³ª±â Àü¿¡ event°¡ ³¡³ª ¹ö·È´Ù.
631                                        {
632                                                PageEvent[i][event_num].nX = EPG_EVENT_X + (StartTap-nPageStartTime)*EPG_EVENT_W/86400;
633                                                PageEvent[i][event_num].StatusFlag = Program_EMPTY;
634                                                PageEvent[i][event_num].StatusFlag |= (bNeedToWaitMore ? Program_EMPTY_NotYet : 0);
635                                                StartTap = nPageStartTime+86400;
636                                                event_num++; 
637                                        }
638                                        else
639                                        {
640                                                PageEvent[i][event_num].nX = EPG_EVENT_X + (StartTap-nPageStartTime)*EPG_EVENT_W/86400;
641                                                if(event == NULL)
642                                                        dprint(1, "\n\n[%s] : event Null\n\n", __FUNCTION__);   
643                                               
644                                                if(1/*event[pIndex].startTime <= StartTap+60*/) // 1ºÐÁ¤µµ Â÷ÀÌ´Â ¹«½ÃÇÑ´Ù.
645                                                {
646                                                       
647                                                        if(0/*(pIndex > 0 && event[pIndex].startTime <= StartTap &&
648                                                                                                event[pIndex].startTime+event[pIndex].programLength <= StartTap)*/)
649                                                        { // 04.05.17. mini. ¿ÏÀü overlap µÇ°Å³ª À̺¥Æ®ÀÇ ³¡³ª´Â ½Ã°£ÀÌ ÆäÀÌÁö ½ÃÀ۽ð£°úÀÇ
650                                                                // Â÷ÀÌ°¡ 1ºÐ ¹Ì¸¸ÀÎ °æ¿ì ÆäÀÌÁö¿¡ Æ÷ÇÔ½ÃÅ°Áö ¾Ê´Â´Ù.
651                                                                dprint(0, "############    Invalid Event!!!\n");
652                                                                valid_event_num++;
653                                                                validNumTemp--;
654                                                                pNumEvent[i] = validNumTemp;
655                                                                if(valid_event_num<NumTemp)
656                                                                        pIndex++;
657                                                        }
658                                                        else
659                                                        {
660                                                                PageEvent[i][event_num].EPG_event = &(event[pIndex]);
661                                                                PageEvent[i][event_num].StatusFlag = Program_Normal;
662                                                                                                                       
663                                                                StartTap = PageEvent[i][event_num].EPG_event->startTime + PageEvent[i][event_num].EPG_event->programLength;
664                                                               
665                                                                if(StartTap < nCurTime.sys_time)
666                                                                {
667                                                                        PageEvent[i][event_num].StatusFlag |= Program_PastEvent;
668                                                                }
669                                                               
670                                                                event_num++;
671                                                                valid_event_num++;
672                                                                if(valid_event_num < NumTemp)
673                                                                        pIndex++;
674                                                        }
675                                                }
676                                                else
677                                                {
678                                                        PageEvent[i][event_num].StatusFlag = Program_EMPTY;
679                                                        PageEvent[i][event_num].StatusFlag |= (bNeedToWaitMore ? Program_EMPTY_NotYet : 0);
680                                                        StartTap = event[pIndex].startTime;
681       
682                                                        if(StartTap < nCurTime.sys_time)
683                                                                PageEvent[i][event_num].StatusFlag |= Program_PastEvent;
684                                                       
685                                                        event_num++;
686                                                }
687                                        }
688       
689                                        if(StartTap >= nPageStartTime + 86400-1)
690                                        {
691                                                NumEvent[i]= event_num;
692                                                break;
693                                        }
694                                }//end while
695                               
696                        }
697                        else // event°¡ ¾øÀ» ¶§ .......
698                        {
699                                pNumEvent[i] = 0; 
700                               
701                                PageEvent[i][event_num].nX = EPG_EVENT_X;
702                                PageEvent[i][event_num].nW = EPG_EVENT_W;               
703                                PageEvent[i][event_num].StatusFlag = Program_EMPTY;
704                                PageEvent[i][event_num].StatusFlag |= (bNeedToWaitMore ? Program_EMPTY_NotYet : 0);
705                                NumEvent[i]= 1;
706                        }
707                }
708                else   // PSIP°¡ ¾øÀ» ¶§ ........
709                {
710                        pNumEvent[i] = 0;
711                       
712                        PageEvent[i][event_num].nX = EPG_EVENT_X;
713                        PageEvent[i][event_num].nW = EPG_EVENT_W;
714                        PageEvent[i][event_num].StatusFlag = Program_EMPTY;
715                        NumEvent[i]= 1;
716                }
717
718                for(l=0; l<NumEvent[i]; l++)
719                {
720                        if(l == NumEvent[i]-1)
721                                PageEvent[i][l].nW = EPG_EVENT_X+EPG_EVENT_W+1 - PageEvent[i][l].nX;
722                        else
723                                PageEvent[i][l].nW = PageEvent[i][l+1].nX - PageEvent[i][l].nX;
724                }
725                for(l=0; l<event_num; l++)
726                {
727                        dprint(3, "================================================================\n");
728                        dprint(3, "PageEvent[%d][%d] : (x, w) = (%3d, %3d)\n", i, l, PageEvent[i][l].nX, PageEvent[i][l].nW);
729                }
730        } //end of for
731       
732        return; 
733}
734
735
736/******************************************************************************************
737FUNCTION:
738  - App_OSD_DrawEventLine
739
740Purpose:
741  - draw epg event line (not focus)
742  - App_OSD_DrawEpgContents wrapping function
743  - consist of draw, backup, erase, restore
744******************************************************************************************/
745#if 0
746void App_OSD_DrawEventLine(UINT16 num_ch, int nIdx, strEPG_Data **PageEvent, UINT8 *NumEvent)
747{
748        int i, j;
749        UINT16 nPageChannelNum = 0;  // ÇöÀç ÆäÀÌÁöÀÇ Ã¤³Î °¹¼ö
750       
751        // Calculate Channel List
752        nPageChannelNum = min(num_ch, 6);
753
754        for(i=0; i<nPageChannelNum; i++)
755        { // eventÀÇ ÇÑ ¶óÀÎÀ» ±×¸°´Ù. left, right, up, down À̵¿½Ã »ç¿ë.
756                if(i == nIdx)
757                        for(j=0; j<NumEvent[i]; j++)
758                        {
759                                App_OSD_DrawEventBox(0, i, PageEvent[i][j]);
760                        }
761        }
762}
763
764
765void p_backup_event_line(int y)
766{       // EPG event ÇÑÁÙ ¿µ¿ª backup / ¿À¸¥ÂÊ EPG_LINEÀ» Áö¿ì°í º¹±¸Çϱâ À§ÇØ EPG_EVENT_W+2·Î º¯°æ
767        App_OSD_BackupScreen(EPG_EVENT_X, y, EPG_EVENT_W+2, EPG_EVENT_H);
768}
769
770
771void p_erase_event_line(int y)
772{       // EPG event ÇÑÁÙ ¿µ¿ª erase / ¿À¸¥ÂÊ EPG_LINEÀ» Áö¿ì°í º¹±¸Çϱâ À§ÇØ EPG_EVENT_W+2·Î º¯°æ
773        DMG_EraseRect(EPG_EVENT_X, y, EPG_EVENT_W+2, EPG_EVENT_H, 0x0);
774}
775
776
777void p_restore_event_line(int y)
778{       // EPG event ÇÑÁÙ ¿µ¿ª restore / ¿À¸¥ÂÊ EPG_LINEÀ» Áö¿ì°í º¹±¸Çϱâ À§ÇØ EPG_EVENT_W+2·Î º¯°æ
779        App_OSD_RestoreScreen(EPG_EVENT_X, y, EPG_EVENT_W+2, EPG_EVENT_H);
780}
781
782
783/******************************************************************************************
784FUNCTION:
785  - App_OSD_DrawEventBox
786
787Purpose:
788  - draw event box in event list.
789        - mode : 0 => normal, 1 => focus
790******************************************************************************************/
791void App_OSD_DrawEventBox(int mode, UINT16 nY, strEPG_Data PageEvent)
792{
793        int i;
794        int width;              // width : 1pixel * w - 16pixel
795        UINT16 x, y, w;
796        UINT16 titleLen = 0;    // event title length
797        UINT16 pTitle[100];      // event title
798        char *str;             // alert message
799        SINT32 PrgmWidth;
800        SINT32 title_x, title_y, title_h, title_w, tmp_w1, tmp_w2;
801        BOOLEAN bTitle = FALSE; // title yes or no
802       
803        DMG_SetFontSize(18);    // font size in event box : 16
804       
805       
806        /* Event Box Position */
807        x = PageEvent.nX;
808        y = EPG_EVENT_Y + (EPG_EVENT_H-1)*nY;
809        w = PageEvent.nW;
810       
811       
812        /* ¿¹¿Üó¸® */
813        if( x+w > EPG_EVENT_X+EPG_EVENT_W )
814                w -= ( x+w - EPG_EVENT_X-EPG_EVENT_W );
815        dprint(3, "[%s] PageEvent.nX : %d, PageEvent.nW : %d\n", __FUNCTION__, PageEvent.nX, PageEvent.nW);
816       
817       
818        /* Event string ä¿ì±â */
819        memset(pTitle, 0, sizeof(UINT16)*100);
820        if(!(PageEvent.StatusFlag & Program_EMPTY))
821        {
822                if(PageEvent.EPG_event->titleTextLength > 8)
823                {
824                        titleLen = DLIB_PSI_DecodeMultipleStringStructure(PageEvent.EPG_event->titleTextLength,
825                                                        PageEvent.EPG_event->titleText, "eng", 100, pTitle);
826                        dprint(3, "[%s/%d] titleLen : %d, pTitle : %s\n", __FUNCTION__, __LINE__, titleLen, pTitle);
827                        bTitle = TRUE;
828                       
829                        if(titleLen < 100)
830                                pTitle[titleLen] = 0;
831                        else
832                                pTitle[100-1] = 0;
833                }
834                else
835                        GET_STR(str, EPG_NO_INFO_AVAILABLE);
836        }
837        else
838        {
839                if (PageEvent.StatusFlag & Program_EMPTY_NotYet) {
840                        GET_STR(str, EPG_NO_INFO_ACQUIRED);
841                }
842                else {
843                        GET_STR(str, EPG_NO_INFO_AVAILABLE);
844                }
845        }
846       
847        PrgmWidth = EPG_EVENT_W+1;
848       
849        if(PrgmWidth != w)
850        {
851                if(bTitle) // title exist
852                {
853                        DMG_PrintUStrEx(x, y+5, w, 20, pTitle, EPG_FC_NOR, DMG_OPT_A_CT);
854                       
855                        // bTitleÀÌ ÀÖ´Â event ¾ç ¿·¿¡´Â ±¸ºÐ¼±À» µÐ´Ù.
856                        DRAW_IMAGE(x, y+2, EPG_LINE);
857                        DRAW_IMAGE(x+w, y+2, EPG_LINE);
858                }
859                else       // title not exist
860                        DMG_PrintStrEx(x, y+5, w, 20, str, EPG_FC_NOR, DMG_OPT_A_CT);
861               
862                if(mode == 1) // focus event
863                {
864                        width = EPG_BAR_SEG * w - 2*(EPG_BAR_BOTHENDS);                                                                    // cal event width
865                       
866                        if(w == 0);
867                        else if(w == 1) {
868                                DRAW_IMAGE(x+1, y, EPG_BAR_MIDDLE);
869                        }
870                        else if(w == 2) {
871                                DRAW_IMAGE(x+1, y, EPG_BAR_MIDDLE);
872                                DRAW_IMAGE(x+2, y, EPG_BAR_MIDDLE);
873                        }
874                        else if(w < 4)
875                        { // event ±æÀÌ°¡ 4Çȼ¿ ÀÌÇÏÀÎ °æ¿ì ±×¸®´Â mini focus bar
876                                DRAW_IMAGE(x+1, y, EPG_BAR_MINI);                         // mini focus image (3pixel)
877                                dprint(3, "[%s/%d] w : %d \n", __FUNCTION__, __LINE__, w);
878                        }
879                        else if(w > 4 && w < 8)
880                        {
881                                DRAW_IMAGE(x, y, EPG_BAR_LEFT);                           // focus bar left
882                                for(i=0; i<width; i++)
883                                {
884                                        DRAW_IMAGE((x+EPG_BAR_BOTHENDS)+i, y, EPG_BAR_MIDDLE);  // focus bar center
885                                }
886                                DRAW_IMAGE((x+EPG_BAR_BOTHENDS)+i, y, EPG_BAR_RIGHT);     // focus bar right
887                                dprint(3, "[%s/%d] w : %d \n", __FUNCTION__, __LINE__, w);
888                        }
889                        else
890                        { // EPG_LINE ¾È¿¡ focus¸¦ ±×¸®±â À§ÇØ +1À» ÇØÁØ´Ù.
891                                DRAW_IMAGE(x+1, y, EPG_BAR_LEFT);                         // focus bar left
892                                for(i=0; i<width; i++)
893                                { // EPG_LINE ¾È¿¡ focus¸¦ ±×¸®±â À§ÇØ +1À» ÇØÁØ´Ù.
894                                        DRAW_IMAGE((x+1+EPG_BAR_BOTHENDS)+i, y, EPG_BAR_MIDDLE);// focus bar center
895                                }
896                                DRAW_IMAGE((x+EPG_BAR_BOTHENDS)+i, y, EPG_BAR_RIGHT);     // focus bar right
897                                dprint(3, "[%s/%d] w : %d \n", __FUNCTION__, __LINE__, w);
898                        }
899                       
900                        if(bTitle)
901                        {
902                                DMG_PrintUStrEx(x, y+5, w, 20, pTitle, EPG_FC_HL, DMG_OPT_A_CT);
903                                bTitle = FALSE;
904                        }
905                        else
906                                DMG_PrintStrEx(x, y+5, w, 20, str, EPG_FC_HL, DMG_OPT_A_CT);
907                }// end of "if(mode == 1)"
908        }  // end of "if(PrgmWidth != w)"
909       
910}
911#endif
912
913/******************************************************************************************
914FUNCTION:
915  - App_OSD_DrawEpgEventInfo
916
917Purpose:
918  - ¼±ÅÃÇÑ À̺¥Æ®ÀÇ ¼³¸íÀ» °£·«È÷ Ç¥±âÇÑ´Ù.
919  - mode == 0 : EPG Main¿¡¼­ ¾²ÀÌ´Â ÁÂÇ¥
920        mode == 1 : EPG Detail Banner ¿¡¼­ ¾²ÀÌ´Â ÁÂÇ¥
921******************************************************************************************/
922void App_OSD_DrawEpgEventInfo(int mode, int column, int cursorIdx, int CurColumn, int numEvent, ChListInfo EPGChList, DMW_EpgEventPtr event, BOOL bModify)
923{
924        int scroll_pos = 0;
925        APP_TIME_T startT, endT;// Event info start/end time
926        DmcEpgStatus scan_stat; // epg status
927       
928        UINT16 Name[12];         // Short Name
929        UINT16 textLen = 0;
930        UINT16 uni_str[100];     // Event Title
931        UINT16 ch_size;         // channel number string size : chNum ´ÙÀ½ÀÇ XÁÂÇ¥ ¾ò±â À§ÇØ
932        UINT16 sn_size;         // short name unicode string size : Name ´ÙÀ½ÀÇ XÁÂÇ¥ ¾ò±â À§ÇØ
933        UINT16 tmp_x;           // EPG_INFO_X+40 + (ch_size+6) + (sn_size+6)
934        char *str;             // alert comment
935        int index;
936        char chNum[16], tmpStr[16], date[64];
937       
938        tApp_UcmShortInfo chinfo;
939       
940        BOOLEAN bUni = FALSE;
941        BOOL bNeedToWaitMore;
942       
943        DMG_SetFontSize(20);    // Epg Event Information font size : 16
944       
945        if(bModify)
946        {
947                p_erase_event_info();                                                  // erase event info
948                App_OSD_RestoreScreen(EPG_BOX_X, EPG_BOX_Y, EPG_BOX_W/2, 40);   // restore Ch. No.
949                App_OSD_RestoreScreen(EPG_INFO_X, EPG_INFO_Y, EPG_INFO_W*2, EPG_INFO_H*5); // restore event info
950                App_OSD_CommonBox2(EPG_CH_INFO_BOX_X+2, EPG_CH_INFO_BOX_Y+2+(34*column), EPG_CH_INFO_BOX_W-4, EPG_INFO_H-4, 1, EPG_BG_COLOR_1, EPG_BG_COLOR_1, EPG_BG_COLOR_1);
951                App_OSD_CommonBox2(EPG_TIME_INFO_BOX_X+2, EPG_CH_INFO_BOX_Y+2+(34*column), EPG_TIME_INFO_BOX_W-4, EPG_INFO_H-4, 1, EPG_BG_COLOR_1, EPG_BG_COLOR_1, EPG_BG_COLOR_1);
952        }
953       
954        /* DTV icon, channel number */
955        dprint(3, "Enter (%s), %d-%d\n", __FUNCTION__, EPGChList.ListMajor, EPGChList.ListMinor);
956        sprintf(tmpStr, "%d", EPGChList.ListMajor);
957        strcpy(chNum, tmpStr);
958        if(EPGChList.ListMinor != 1024)
959        {
960                strcat(chNum, "-");
961                sprintf(tmpStr, "%d", EPGChList.ListMinor);
962                strcat(chNum, tmpStr);
963        }
964       
965        ch_size = DMG_GetStrWidth(chNum);               // ³Êºñ¸¦ ¼³Á¤Çϱâ À§ÇÑ chNumÀÇ string ±æÀ̸¦ ¾ò´Â´Ù.
966       
967        App_GetUcmShortInfo(EPGChList.ListUID, &chinfo); 
968        if(mode == 0)
969                DMG_PrintStrEx(EPG_CH_TEXT_X, EPG_CH_TEXT_Y-2, ch_size, 30, chNum, C_EPG_TITLE, DMG_OPT_A_LT);
970        else if(mode == 1)
971                DMG_PrintStrEx(EPG_CH_TEXT_X, EPG_CH_TEXT_Y-2, ch_size, 30, chNum, C_EPG_TITLE, DMG_OPT_A_LT);
972       
973        /* Short Name */
974        DMW_MSC_LockUcm();
975        index = DMW_MSC_Uid2Index(EPGChList.ListUID);
976        DMW_MSC_UnlockUcm();
977        if(index >= 0)
978        {
979                memset(Name, 0, sizeof(UINT16)*8);
980                memcpy(Name, g_UCM[index].ShortName, sizeof(UINT16)*7);
981               
982                if(Name[0]=='K' && Name[1]=='o' && Name[2]=='r' && Name[3]=='e' && Name[4]=='a'
983                        && Name[5]=='V' && Name[6]=='i') {
984                        Name[7]='e';
985                        Name[8]='w';
986                        Name[9]=0;
987                }
988               
989                sn_size = DMG_GetUStrWidth(Name);               // ³Êºñ¸¦ ¼³Á¤Çϱâ À§ÇÑ NameÀÇ string ±æÀ̸¦ ¾ò´Â´Ù.
990                // X : DTV icon³Êºñ(40) + ä³Î(ch_size+6)
991                if(mode == 0)
992                        DMG_PrintUStrEx(EPG_CH_TEXT_X+(ch_size+6), EPG_CH_TEXT_Y-2, EPG_INFO_W, 30, Name, C_EPG_TITLE, DMG_OPT_A_LT);
993                else if(mode == 1)
994                        DMG_PrintUStrEx(EPG_CH_TEXT_X+(ch_size+6), EPG_CH_TEXT_Y-2, EPG_INFO_W, 30, Name, C_EPG_TITLE, DMG_OPT_A_LT);
995        }
996        else
997        {
998                dprint(1, "[%s] Invalid UID\n", __FUNCTION__);
999        }
1000       
1001        /* ?? */
1002        DMW_EPG_GetScanStatus(EPGChList.ListUID, &scan_stat);
1003       
1004        if (scan_stat.cStatus==EPG_STATUS_SUBCH_COMPLETE || scan_stat.cStatus==EPG_STATUS_CH_COMPLETE)
1005        {
1006                bNeedToWaitMore = FALSE;        // "no info available"
1007        }
1008        else if (scan_stat.nElapsedSec > 6)
1009        {
1010                bNeedToWaitMore = FALSE;
1011        }
1012        else
1013        {
1014                bNeedToWaitMore = TRUE;         // "no info acquired"
1015        }
1016       
1017        dprint(5, "info : bNeedToWaitMore -> %d\n", bNeedToWaitMore);
1018               
1019        /* Event Title */
1020        memset(uni_str, 0, sizeof(UINT16)*100);
1021        if(event)
1022        {
1023                if(event->titleTextLength > 8)
1024                {
1025                        textLen = DLIB_PSI_DecodeMultipleStringStructure(event->titleTextLength, event->titleText, 
1026                                                        "eng", 100, uni_str);
1027                        dprint(3, "[%s/%d] titleLen : %d, pTitle : %s\n", __FUNCTION__, __LINE__, textLen, uni_str);
1028                                                       
1029                        if(textLen < 100)
1030                                uni_str[textLen] = 0;
1031                        else
1032                                uni_str[100-1] = 0;
1033                               
1034                        bUni = TRUE;
1035                }
1036        }
1037        else
1038        {
1039                /* ?? */
1040        }
1041
1042        DMG_SetFontSize(20);
1043        if(bUni)
1044        {
1045                if(mode == 0)
1046                        DMG_PrintUStrEx(EPG_CH_INFO_TEXT_X, EPG_CH_INFO_TEXT_Y+(EPG_INFO_GAP*column), EPG_CH_INFO_TEXT_W, EPG_CH_INFO_TEXT_H, uni_str, (column==cursorIdx) ? C_EPG_HIGHLIGHT : C_EPG_DATA, DMG_OPT_A_LT);
1047                else if(mode == 1)
1048                        DMG_PrintUStrEx(EPG_CH_INFO_TEXT_X+(ch_size+6), EPG_DETAIL_CH_INFO_Y, EPG_DETAIL_CH_INFO_W, EPG_CH_INFO_TEXT_H, uni_str, C_EPG_TITLE, DMG_OPT_A_LT);
1049                       
1050                bUni = FALSE;
1051        }
1052        else
1053        {
1054                GET_STR(str, EPG_NO_INFO_AVAILABLE);
1055                if(mode == 0)
1056                        DMG_PrintStrEx(EPG_CH_INFO_TEXT_X, EPG_CH_INFO_TEXT_Y+(EPG_INFO_GAP*column), EPG_CH_INFO_TEXT_W, EPG_CH_INFO_TEXT_H, str, (column==cursorIdx) ? C_EPG_HIGHLIGHT : C_EPG_DATA, DMG_OPT_A_LT);
1057                else if(mode == 1)
1058                        DMG_PrintUStrEx(EPG_CH_INFO_TEXT_X+(ch_size+6), EPG_DETAIL_CH_INFO_Y, EPG_DETAIL_CH_INFO_W, EPG_CH_INFO_TEXT_H, uni_str, (column==cursorIdx) ? C_EPG_HIGHLIGHT : C_EPG_DATA, DMG_OPT_A_LT);
1059        }
1060       
1061       
1062        /* Event Start/End Time */
1063        if(event)
1064        {
1065                AppTime_GetTimeFromGPS(event->startTime, &startT);
1066                AppTime_GetTimeFromGPS(event->startTime+event->programLength, &endT);
1067                /* Date */
1068                App_MakeDateTimeString(tmpStr, startT, 12);  // Jan.10(Sun)
1069                strcpy(date, tmpStr);
1070                strcat(date," ");
1071                /* Start Time */
1072                App_MakeDateTimeString(tmpStr, startT, 7);  // 12:30PM
1073                strcat(date, tmpStr);
1074                strcat(date, "~");
1075                /* End Time */
1076                App_MakeDateTimeString(tmpStr, endT, 7);    // 12:30PM
1077                strcat(date, tmpStr);
1078               
1079                // xÁÂÇ¥ = DTV icon³Êºñ(40) + ä³Î(ch_size+6) + Short Name(sn_size+6)
1080                if(mode == 0)
1081                {       // width        : (EPG_CTIME_X-6) - tmp_x ±îÁö Á¦ÇÑÇÑ´Ù. (Áï, current time ¾Õ 6Çȼ¿±îÁö¸¦ ³Êºñ·Î ÁöÁ¤)
1082                        DMG_SetFontSize(18);
1083                        tmp_x = EPG_INFO_X+40+(ch_size+6)+(sn_size+6);
1084                        DMG_PrintStrEx(EPG_TIME_INFO_TEXT_X, EPG_CH_INFO_TEXT_Y+(EPG_INFO_GAP*column), EPG_TIME_INFO_TEXT_W, EPG_CH_INFO_TEXT_H, date, (column==cursorIdx) ? C_EPG_HIGHLIGHT : C_EPG_DATA, DMG_OPT_A_LT);
1085                }
1086                else if(mode == 1)
1087                {       // current timeÀÌ ¾øÀ¸¹Ç·Î spec´ë·Î..
1088                        DMG_SetFontSize(20);
1089                        tmp_x = EPG_DINFO_X+40+(ch_size+6)+(sn_size+6);
1090                        DMG_PrintStrEx(EPG_CH_INFO_TEXT_X+(ch_size+6), EPG_DETAIL_TIME_INFO_Y, EPG_DETAIL_TIME_INFO_W, EPG_CH_INFO_TEXT_H, date, C_EPG_TITLE, DMG_OPT_A_LT);
1091                }
1092                dprint(3, "[%s/%d] tmp_x : %d\n\n", __FUNCTION__, __LINE__, tmp_x);
1093        }
1094
1095        // scroll
1096        if (mode == 0)
1097        {
1098                if (column == cursorIdx)
1099                {
1100                        if (CurColumn+cursorIdx+1 == numEvent)
1101                                scroll_pos = EPG_SCROLL_BG_MID_H-EPG_SCROLL_POINT_H;
1102                        else
1103                                scroll_pos = (EPG_SCROLL_BG_MID_H-EPG_SCROLL_POINT_H) * (CurColumn+cursorIdx) / (numEvent-1);
1104                }
1105
1106                // scroll up
1107                DRAW_IMAGE(EPG_SCROLL_UP_X, EPG_SCROLL_UP_Y, DST_scroll_arrow_up_480);
1108
1109                // scroll down
1110                DRAW_IMAGE(EPG_SCROLL_UP_X, EPG_SCROLL_DOWN_Y, DST_scroll_arrow_down_480);
1111
1112                if ((numEvent > 8) && (column == cursorIdx))
1113                        DRAW_IMAGE(EPG_SCROLL_POINT_X, EPG_SCROLL_POINT_Y+scroll_pos, DST_scroll_arrow_bar_480);
1114        }
1115}
1116
1117
1118void p_erase_event_info()
1119{       // EPG event information Àüü ¿µ¿ª erase
1120        DMG_EraseRect(EPG_CH_INFO_BOX_X, EPG_CH_INFO_BOX_Y, EPG_CH_INFO_BOX_W+EPG_TIME_INFO_BOX_W, EPG_CH_INFO_BOX_Y+(7*EPG_INFO_GAP), 0x0);
1121//                      EPG_INFO_X, EPG_INFO_Y, EPG_INFO_W*2, EPG_INFO_H*5, 0x0);
1122}
1123
1124
1125
1126
1127
1128#if COMMENT
1129___EPG_Detail_Box___() {}
1130#endif
1131
1132/******************************************************************************************
1133FUNCTION:
1134  - App_OSD_DrawEpgDetailBanner
1135
1136Purpose:
1137  - ¼±ÅÃµÈ À̺¥Æ®¸¦ Ŭ¸¯½Ã, ÀÚ¼¼ÇÑ Á¤º¸¸¦ º¸¿©ÁÖ´Â ¹è³Ê
1138******************************************************************************************/
1139void App_OSD_DrawEpgDetailBanner()
1140{
1141        int orig_font_size;
1142        orig_font_size=DMG_GetFontSize();
1143        DMG_SetFontSize(22);  // Epg Detail Banner font size : 16
1144       
1145        /* Epg Detail Banner Window */
1146        DMG_EraseRect(EPG_BOX_X, EPG_BOX_Y, EPG_BOX_W, EPG_BOX_H, 0x0);
1147       
1148        App_OSD_CommonBox1(EPG_BOX_X, EPG_BOX_Y, EPG_BOX_W, EPG_BOX_H, 6, 2, CHEDIT_BG_COLOR_1, CHEDIT_BG_COLOR_3, CHEDIT_BG_COLOR_2);
1149       
1150        App_OSD_CommonBox2(EPG_CH_BG_X, EPG_CH_BG_Y, EPG_CH_BG_W, EPG_DETAIL_BOX_H1, 2, CHEDIT_BG_COLOR_7, CHEDIT_BG_COLOR_5, CHEDIT_BG_COLOR_4);
1151
1152        App_OSD_CommonBox2(EPG_CH_BG_X, EPG_DETAIL_BOX_Y, EPG_CH_BG_W, EPG_DETAIL_BOX_H2, 2, CHEDIT_BG_COLOR_8, CHEDIT_BG_COLOR_5, CHEDIT_BG_COLOR_4);
1153
1154        /* Default command */
1155#if 0
1156        PRINT_STR_EX(EPG_MENU_KEY_X, EPG_MENU_KEY_Y, EPG_MENU_KEY_W, EPG_MENU_KEY_H, EPG_BOTTOM1, C_EPG_MENUKEY1, DMG_OPT_A_LT);
1157        PRINT_STR_EX(EPG_MENU_KEY_X+50, EPG_MENU_KEY_Y, EPG_MENU_KEY_W, EPG_MENU_KEY_H, EPG_BOTTOM2, C_EPG_MENUKEY2, DMG_OPT_A_LT);
1158#else
1159        PRINT_STR_EX(EPG_MENU_KEY_X, EPG_MENU_KEY_Y, EPG_MENU_KEY_W, EPG_MENU_KEY_H, EPG_BOTTOM1, C_EPG_MENUKEY1, DMG_OPT_A_LT);
1160#endif
1161        DMG_SetFontSize(orig_font_size);
1162}
1163
1164
1165
1166
1167
1168
1169#if COMMENT
1170___EPG_Scroll___() {}
1171#endif
1172
1173/******************************************************************************************
1174FUNCTION:
1175  - App_OSD_EpgScroll
1176
1177Purpose:
1178  - epg scroll wrapper function (App_OSD_DrawScroll in App_OSD_Common.c)
1179  - mode == 1 : epg scroll
1180        mode == 2 : epg detail information scroll
1181******************************************************************************************/
1182#if 0
1183void App_OSD_EpgScroll(int mode, int num_pos, int cur_pos, BOOL bsel, BOOL bModify)
1184{
1185        if(mode == 1)
1186        {
1187                if(bModify)
1188                {
1189                        p_erase_epg_scroll1();
1190                        App_OSD_RestoreScreen(EPG_SCROLL_X-6, EPG_SCROLL_Y-8, EPG_SCROLL_W, EPG_SCROLL_H);
1191                }
1192                App_OSD_DrawScroll(EPG_SCROLL_X, EPG_SCROLL_Y, 1, num_pos, cur_pos, bsel);
1193                dprint(3, "[%s] mode:%d, num_pos:%d, cur_pos:%d, bsel:%d\n", __FUNCTION__,
1194                                                        mode, num_pos, cur_pos, bsel);
1195        }
1196        else if(mode == 2)
1197        {
1198                if(bModify)
1199                {
1200                        p_erase_epg_scroll2();
1201                        App_OSD_RestoreScreen(EPG_SCROLL_X-4, EPG_SCROLL_Y2, EPG_SCROLL_W-2, EPG_SCROLL_H2);
1202                }
1203                App_OSD_DrawScroll(EPG_SCROLL_X, EPG_SCROLL_Y2, 2, num_pos, cur_pos, bsel);
1204                dprint(3, "[%s] mode:%d, num_pos:%d, cur_pos:%d, bsel:%d\n", __FUNCTION__,
1205                                                        mode, num_pos, cur_pos, bsel);
1206        }
1207}
1208
1209
1210void p_erase_epg_scroll1()
1211{       // epg scroll Àüü¿µ¿ª erase
1212        DMG_EraseRect(EPG_SCROLL_X-6, EPG_SCROLL_Y-8, EPG_SCROLL_W, EPG_SCROLL_H, 0x0);
1213}
1214
1215
1216void p_erase_epg_scroll2()
1217{       // epg detail banner scroll Àüü¿µ¿ª erase
1218        DMG_EraseRect(EPG_SCROLL_X-4, EPG_SCROLL_Y2, EPG_SCROLL_W-2, EPG_SCROLL_H2, 0x0);
1219}
1220
1221
1222
1223
1224#if COMMENT
1225___EPG_Banner___() {}
1226#endif
1227
1228/******************************************************************************************
1229FUNCTION:
1230  - App_OSD_DrawEpgWaitBanner   (EPG_DrawWaitingBanner)
1231
1232Purpose:
1233  - EPG Update µ¿¾È º¸¿©Áú Waiting banner
1234******************************************************************************************/
1235void App_OSD_DrawEpgWaitBanner(BOOLEAN bDraw, BOOL bModify)
1236{
1237        /* TO DO : µðÀÚÀÎ ¹× ±â´É ¾øÀ½. */
1238        dprint(6, "[%s] ===== testtestteset =====\n", __FUNCTION__);
1239}
1240#endif
1241
1242/******************************************************************************************
1243FUNCTION:
1244  - App_OSD_DrawEpgNotiBanner   (EPG_Draw_ChEdit_NotiBanner)
1245
1246Purpose:
1247  - ä³Î µ¥ÀÌÅÍ°¡ ¾øÀ» ¶§ ¶ç¿ì´Â °æ°í ¹è³Ê
1248  - Warpping APP_OSD_DrawWarningBanner
1249******************************************************************************************/
1250void App_OSD_DrawEpgNotiBanner()
1251{
1252        APP_OSD_DrawWarningBanner(2, FALSE);
1253}
1254
1255
1256
1257
1258
1259#if COMMENT
1260___Util_Function___() {}
1261#endif
1262
1263/******************************************************************************************
1264FUNCTION:
1265  - App_OSD_RefreshEpg
1266
1267Purpose:
1268  - EPG ¿ë refresh ÇÔ¼ö. dmw¿¡¼­ ¾²´Â °Í°ú µ¿ÀÏ
1269******************************************************************************************/
1270void App_OSD_RefreshEpg()
1271{
1272        DMG_AutoRefresh();
1273}
1274
1275
1276/******************************************************************************************
1277FUNCTION:
1278  - p_epg_sort_list     (EpgSortList)
1279
1280Purpose:
1281  - epg sorting function
1282******************************************************************************************/
1283void p_epg_sort_list(ChListInfo *EPGChList, int num)
1284{
1285        ChListInfo TempList;
1286        int i,j;
1287       
1288        for(i=0; i<num-1; i++)
1289        {
1290                for(j=i; j<num; j++)
1291                {
1292                        if(EPGChList[i].ListMajor > EPGChList[j].ListMajor)
1293                        {
1294                                TempList.ListUID                = EPGChList[i].ListUID;
1295                                TempList.ListMajor      = EPGChList[i].ListMajor;
1296                                TempList.ListMinor      = EPGChList[i].ListMinor;
1297                                TempList.ListRF                 = EPGChList[i].ListRF;
1298                                TempList.VctFlag                = EPGChList[i].VctFlag;
1299                               
1300                                EPGChList[i].ListUID            = EPGChList[j].ListUID;
1301                                EPGChList[i].ListMajor  = EPGChList[j].ListMajor;
1302                                EPGChList[i].ListMinor  = EPGChList[j].ListMinor;
1303                                EPGChList[i].ListRF             = EPGChList[j].ListRF;
1304                                EPGChList[i].VctFlag            = EPGChList[j].VctFlag;
1305
1306                                EPGChList[j].ListUID            = TempList.ListUID;
1307                                EPGChList[j].ListMajor  = TempList.ListMajor;
1308                                EPGChList[j].ListMinor  = TempList.ListMinor;
1309                                EPGChList[j].ListRF             = TempList.ListRF;
1310                                EPGChList[j].VctFlag            = TempList.VctFlag;
1311                        }
1312                        if(EPGChList[i].ListMajor==EPGChList[j].ListMajor && EPGChList[i].ListMinor>EPGChList[j].ListMinor)
1313                        {
1314                                TempList.ListUID                = EPGChList[i].ListUID;
1315                                TempList.ListMajor      = EPGChList[i].ListMajor;
1316                                TempList.ListMinor      = EPGChList[i].ListMinor;
1317                                TempList.ListRF                 = EPGChList[i].ListRF;
1318                                TempList.VctFlag                = EPGChList[i].VctFlag;
1319                               
1320                                EPGChList[i].ListUID            = EPGChList[j].ListUID;
1321                                EPGChList[i].ListMajor  = EPGChList[j].ListMajor;
1322                                EPGChList[i].ListMinor  = EPGChList[j].ListMinor;
1323                                EPGChList[i].ListRF             = EPGChList[j].ListRF;
1324                                EPGChList[i].VctFlag            = EPGChList[j].VctFlag;
1325
1326                                EPGChList[j].ListUID            = TempList.ListUID;
1327                                EPGChList[j].ListMajor  = TempList.ListMajor;
1328                                EPGChList[j].ListMinor  = TempList.ListMinor;
1329                                EPGChList[j].ListRF             = TempList.ListRF;
1330                                EPGChList[j].VctFlag            = TempList.VctFlag;
1331                        }       // if end
1332                }               // for "j" end
1333        }                       // for "i" end
1334}
1335
1336
1337/******************************************************************************************
1338FUNCTION:
1339  - p_find_curIndex     (FindCurIndex)
1340
1341Purpose:
1342  - find current position in epg
1343******************************************************************************************/
1344UINT16 p_find_curIndex(ChListInfo       *EPGChList, int num, UINT16 Major)
1345{
1346        UINT16 i;
1347        for(i=0;i<num;i++)
1348        {
1349                if(     EPGChList[i].ListMajor == Major)
1350                        return i;
1351        }
1352        return 0;       
1353}
1354
1355
1356/******************************************************************************************
1357FUNCTION:
1358  - p_epg_tuneChannel   (EPG_TuneChannel)
1359
1360Purpose:
1361  - epg ¾È¿¡¼­ À̵¿½Ã ä³Î ÀÚµ¿ Æ©´× : epg ä³Î Æ©´×
1362******************************************************************************************/
1363void p_epg_tuneChannel(int uid)
1364{
1365        App_TuneChannelByUid(uid);
1366}
1367
1368
1369/******************************************************************************************
1370FUNCTION:
1371  - p_cut_second        (CutSecond)
1372
1373Purpose:
1374  -
1375******************************************************************************************/
1376UINT32 p_cut_second(UINT32 TimeGPS)
1377{
1378        APP_TIME_T tmpTime;
1379        UINT32 nTemp;
1380        BOOLEAN    g_bSetByStt;
1381        int g_nGPS_UTC_offset;
1382       
1383        g_bSetByStt = TRUE;                     // STT¿¡¼­ ½Ã°£À» ÀÐ¾î ¿Â´Ù.
1384       
1385        dprint(3, "[%s] Start!! !\n", __FUNCTION__);
1386        g_nGPS_UTC_offset = 13; //DMW_GetGPS_UTC_offset(stc);
1387       
1388        dprint(3, "[%s] g_bSetByStt is %s\n", __FUNCTION__, g_bSetByStt?"TRUE":"FALSE");
1389        if(!g_bSetByStt)
1390        {
1391                dprint(1, "[%s] No Set by STT!!!\n", __FUNCTION__);
1392                nTemp = TimeGPS - (TimeGPS-g_nGPS_UTC_offset)%60;
1393        }
1394        else
1395        {
1396                dprint(1, "[%s] Set by STT!!!\n", __FUNCTION__);
1397                AppTime_GetTimeFromGPS(TimeGPS,&tmpTime);
1398                nTemp = TimeGPS - tmpTime.second;
1399        }
1400               
1401        return nTemp;
1402}
1403
1404
1405/******************************************************************************************
1406FUNCTION:
1407  - p_catch_event_position      (CatchEventByPosition)
1408
1409Purpose:
1410  - catch the event X position
1411******************************************************************************************/
1412UINT8 p_catch_event_position(strEPG_Data **PageEvent, UINT8 index, UINT8 nMax, UINT16 nX)
1413{
1414        int j = 0;
1415
1416        if(nMax == 1)
1417                return 0;
1418        else
1419        {
1420                while(TRUE)
1421                {
1422                        if(PageEvent[index][j].nX <= nX && (PageEvent[index][j].nX+PageEvent[index][j].nW) > nX)
1423                                return j;
1424                               
1425                        j++;
1426                       
1427                        if(j==nMax)
1428                                break;
1429                }
1430        }               
1431        dprint(0, "[ERROR] p_catch_event_position error!!! \n");
1432       
1433        return 0;
1434}
1435
1436/* end of file */
Note: See TracBrowser for help on using the repository browser.