clock.~c

ct952 source code use for Digital Frame Photo

#define CLOCK_MAIN_FILE

#include "winav.h"
#include "gdi.h"
#include "cc.h"
#include "osd.h"
#include "oswrap.h"
#include "input.h"
#include "poweronmenu.h"
#include "menu.h"
#include "mainmenu.h"
#include "clock.h"
#include "rtcdrv.h"
#include "setup.h"
#include "disp.h"
#include "calenui.h"
#include "osd.h"
#include "osdnd.h"
#include "fontindex.h"

const DWORD _aCLOCK_0[]=
{
#include "bmp/0.txt"
};

const DWORD _aCLOCK_1[]=
{
#include "bmp/1.txt"
};

const DWORD _aCLOCK_2[]=
{
#include "bmp/2.txt"
};

const DWORD _aCLOCK_3[]=
{
#include "bmp/3.txt"
};

const DWORD _aCLOCK_4[]=
{
#include "bmp/4.txt"
};

const DWORD _aCLOCK_5[]=
{
#include "bmp/5.txt"
};

const DWORD _aCLOCK_6[]=
{
#include "bmp/6.txt"
};

const DWORD _aCLOCK_7[]=
{
#include "bmp/7.txt"
};

const DWORD _aCLOCK_8[]=
{
#include "bmp/8.txt"
};

const DWORD _aCLOCK_9[]=
{
#include "bmp/9.txt"
};

const DWORD _aCLOCK_Colon[]=
{
#include "bmp/colon.txt"
};

const DWORD _aCLOCK_Palette[]=
{
#include "bmp/palNumber.txt"       
};

const DWORD *_aCLOCKBMPArray[CLOCK_BITMAP_NUM] = {
    _aCLOCK_0,
    _aCLOCK_1,
    _aCLOCK_2,
    _aCLOCK_3,
    _aCLOCK_4,
    _aCLOCK_5,
    _aCLOCK_6,
    _aCLOCK_7,
    _aCLOCK_8,
    _aCLOCK_9,
    _aCLOCK_Colon,
};

WORD aCLOCKDateDistance[] = {3, CHAR_SPACE, CHAR_HYPHEN_MINUS, CHAR_SPACE};
WORD aCLOCKDayDistance[] = {2, CHAR_SPACE, CHAR_SPACE};

DWORD _dwCLOCKTriggerTime;
RTC_TM _CLOCKCurrnetRTCTime; 
BYTE __bCLOCKShowClock = FALSE;
HMENU _hCLOCKMenu = MENU_HANDLE_INVALID;
HSETTIME _hCLOCKSetTime = SETTIME_HANDLE_INVALID;
BYTE _bCLOCKExitKey[] = {KEY_LEFT};
BYTE _bCLOCKMode;

extern BYTE _bPOWERONMENUSubUIMode;
//*********************************************************************************************************
//  Function    :   CLOCK_Entry
//  Abstract    :   This is the entry function of the clock.
//  Arguments   :   none.
//  Return		:   
//  Side Effect :   none.
//  Notes       :
//*********************************************************************************************************
void CLOCK_Entry(void)
{
    _hCLOCKMenu = MENU_HANDLE_INVALID;
    __bCLOCKShowClock = FALSE;

    _bCLOCKMode = CLOCK_MODE_MENU;
    
    _dwCLOCKTriggerTime = OS_GetSysTimer();
    RTC_GetTime(&_CLOCKCurrnetRTCTime);

#ifdef NL_SOLUTION
    _bCLOCKMode = CLOCK_MODE_SHOW_CLOCK;
    _CLOCK_PrepareBigClock();
    _CLOCK_DisplayBigClock();
#else
    
    //Show Clock menu.
    //Config the OSD to 4 bit mode.
    _CLOCK_ConfigOSDRegion(GDI_OSD_8B_MODE);
    
    CLOCK_ShowMenu();
    
#endif //NL_SOLUTION
}


//*********************************************************************************************************
//  Function    :   CLOCK_ProcessKey
//  Abstract    :   Call this function to process the keys.
//  Arguments   :   none.
//  Return		:   KEY_NO_KEY: The input key is processed.
//              :   INVALID_KEY: The input key is not allowed.
//              :   KEY_BYPASS: Will not process this key and pass it to main flow to process it.
//              :   KEY_XXX: The main program need do more process for the key.
//  Side Effect :   none.
//  Notes       :
//*********************************************************************************************************
BYTE CLOCK_ProcessKey(void)
{
    WORD wMenuAction;
    DWORD dwMenuReturn;

    if (__bKey == KEY_FUNCTION)
    {
        CLOCK_Exit(FALSE);
        POWERONMENU_BackToMainMenu();            
    }

    switch (_bCLOCKMode)
    {
    case CLOCK_MODE_MENU:
        dwMenuReturn = MENU_ProcessKey(_hCLOCKMenu, __bKey);
        wMenuAction = HIWORD(dwMenuReturn);
        
        if (HIWORD(dwMenuReturn) == MENU_ACTION_EXIT)
        {
            CLOCK_Exit(FALSE);
            POWERONMENU_BackToMainMenu();                        
        }
        else if (wMenuAction == MENU_ACTION_PROCESS_MENU_ITEM)
        {
            _CLOCK_ProcessMenuItem(LOWORD(dwMenuReturn));
        }
        break;
    case CLOCK_MODE_SHOW_CLOCK:
        break;
    case CLOCK_MODE_SET_TIME:
        SETTIME_ProcessKey(_hCLOCKSetTime, __bKey);
        break;
    default:
        break;
    }

    return KEY_NO_KEY;
}

void CLOCK_ShowMenu(void)
{    
    MAINMENU_InitializeGDI(__SetupInfo.bUIStyle-SETUP_CUSTOM_UI_STYLE_BEGIN);
    MAINMENU_DrawMainBackground();
    MAINMENU_DrawSelectionHelp(FALSE, FALSE);
    
    //Draw the title
    MAINMENU_DrawTitleString(aCLOCKClockSetting, NULL, NULL);
    
    if (_hCLOCKMenu == MENU_HANDLE_INVALID)
    {
        _hCLOCKMenu = MENU_CreateMenu(&_MENU_CLOCK, CLOCK_MAX_VISIBLE_MENU_ITEM_NUM, _bCLOCKExitKey);
    }
    
    MENU_ShowMenu(_hCLOCKMenu, TRUE, MAINMENU_PALETTE_ENTRY_CONTENT_REGION);        
}

void _CLOCK_ProcessMenuItem(BYTE bID)
{
    switch (bID)
    {
    case CLOCK_DISPLAY_BIG_CLOCK:
        _bCLOCKMode = CLOCK_MODE_SHOW_CLOCK;
        _CLOCK_PrepareBigClock();
        _CLOCK_DisplayBigClock();
        break;
    case CLOCK_DISPLAY_CLOCK_CALENDAR:
        CLOCK_Exit(FALSE);
        _bPOWERONMENUSubUIMode = POWERONMENU_SUB_UI_CALENDAR;
        __bCLOCKShowClock = TRUE;
        CALENDAR_Entry(CALENDAR_MODE_DISPLAY_CLOCK_AND_TIME);
        break;
    case CLOCK_MAIN_EXIT:
        CLOCK_Exit(FALSE);
        POWERONMENU_BackToMainMenu();                        
        break;
    case CLOCK_MAIN_SET_TIME:
        _bCLOCKMode = CLOCK_MODE_SET_TIME;
        RTC_GetTime(&_CLOCKCurrnetRTCTime);
        _CLOCK_SET_TIME.bHour = _CLOCKCurrnetRTCTime.bHr;
        _CLOCK_SET_TIME.bMinute = _CLOCKCurrnetRTCTime.bMin;
        _CLOCK_SET_TIME.bSecond = _CLOCKCurrnetRTCTime.bSec;
        _hCLOCKSetTime  = SETTIME_Create(&_CLOCK_SET_TIME, &_CLOCK_SET_TIME_Action);
        if (_hCLOCKSetTime != SETTIME_HANDLE_INVALID)
        {
            SETTIME_Show(_hCLOCKSetTime, MAINMENU_PALETTE_ENTRY_CONTENT_REGION, __SetupInfo.bUIStyle-SETUP_CUSTOM_UI_STYLE_BEGIN);
        }
        break;
    default:
        break;
    }
}

void CLOCK_SetTime(BYTE bHour, BYTE bMinute, BYTE bSecond)
{
    _CLOCKCurrnetRTCTime.bHr = bHour;
    _CLOCKCurrnetRTCTime.bMin = bMinute;
    _CLOCKCurrnetRTCTime.bSec = bSecond;

    RTC_SetTime(&_CLOCKCurrnetRTCTime);

    SETTIME_Exit(_hCLOCKSetTime, TRUE);
    MENU_ShowMenu(_hCLOCKMenu, TRUE, MAINMENU_PALETTE_ENTRY_CONTENT_REGION); 

    _bCLOCKMode = CLOCK_MODE_MENU;
}

void CLOCK_CancelSetTime(void)
{
    SETTIME_Exit(_hCLOCKSetTime, TRUE);
    MENU_ShowMenu(_hCLOCKMenu, TRUE, MAINMENU_PALETTE_ENTRY_CONTENT_REGION); 

    _bCLOCKMode = CLOCK_MODE_MENU;
}

void _CLOCK_PrepareBigClock(void)
{
    //Load palette for Navigaor's icons.
    GDI_PALETTE_INFO    PaletteInfo_Clock = {CLOCK_BITMAP_PALETTE_INDEX_START,  PAL_ADDR, _aCLOCK_Palette};    

    //Config the OSD to 4 bit mode.
    _CLOCK_ConfigOSDRegion(GDI_OSD_4B_MODE);

    GDI_LoadPalette(&PaletteInfo_Clock);
    //GDI_LoadBMP(_aCLOCKBMPArray, CLOCK_BITMAP_NUM);
    
    GDI_ChangePALEntry(CLOCK_BITMAP_BACKGROUND_PALETTE_INDEX, 0x5a000000, FALSE);
    
    GDI_WaitPaletteComplete();
}

//***************************************************************************
//  Function    :   _CLOCK_UpdateTimeNum
//  Abstract    :   Display the big colock.
//  Arguments   :   none.
//  Return      :   none.
//  Side Effect :   none.
//  Notes       :   
//***************************************************************************
void _CLOCK_UpdateTimeNum(BYTE bNumIndex, BYTE bNumer)
{
    PARM_DRAW_BITMAP DrawBitmap;
    
    DrawBitmap.bBitmapID = bNumer;
    
    DrawBitmap.wDestX = CLOCK_DISPLAY_NUMBER_POS_START_X+bNumIndex*CLOCK_NUMBER_BITMAP_WIDTH+(bNumIndex/2)*CLOCK_COLON_BITMAP_WIDTH;
    DrawBitmap.wDestY = CLOCK_DISPLAY_NUMBER_POS_START_Y;
    
    DrawBitmap.bDestRegion = 0;
    GDI_DrawBitmapBySW(&DrawBitmap, _aCLOCKBMPArray); 
}

//***************************************************************************
//  Function    :   _CLOCK_DisplayBigClockColon
//  Abstract    :   Display the colon.
//  Arguments   :   none.
//  Return      :   none.
//  Side Effect :   none.
//  Notes       :   
//***************************************************************************
void _CLOCK_DisplayBigClockColon(BYTE bIndex)
{
    PARM_DRAW_BITMAP DrawBitmap;
    
    DrawBitmap.bBitmapID = 10;
    
    DrawBitmap.wDestX = CLOCK_DISPLAY_NUMBER_POS_START_X+(bIndex+1)*(CLOCK_NUMBER_BITMAP_WIDTH*2)+bIndex*CLOCK_COLON_BITMAP_WIDTH;
    DrawBitmap.wDestY = CLOCK_DISPLAY_NUMBER_POS_START_Y;
    
    DrawBitmap.bDestRegion = 0;
    GDI_DrawBitmapBySW(&DrawBitmap, _aCLOCKBMPArray); 

//#ifdef NL_SOLUTION
    _CLOCK_DisplayDate();
//#endif //NL_SOLUTION
}

void _CLOCK_DisplayDate(void)
{
    BYTE bDay;
    PARM_DRAW_STRING DateStringAttr;
    PARM_RECT DateRect;