clock.~c

ct952 source code use for Digital Frame Photo

    RTC_TM Calendar;

    //Clear the region
    DateRect.bColor = PAL_ENTRY_COLOR_TRANSPARENT;
    DateRect.rect.wLeft = 0;
    DateRect.rect.wRight = DateRect.rect.wLeft + POWERPNMENU_WIDTH-1;
    DateRect.rect.wTop = CLOCK_DISPLAY_DATE_POS_START_Y;
    DateRect.rect.wBottom = DateRect.rect.wTop + POWERPNMENU_HEIGHT-1;
    GDI_FillRect(0, &DateRect);

    GDI_ChangePALEntry(CLOCK_PALETTE_ENTRY_DATE, CLOCK_PALETTE_COLOR_DATE, FALSE);

    DateStringAttr.bBackground = PAL_ENTRY_COLOR_TRANSPARENT;
    DateStringAttr.bColorKey = 0;
    DateStringAttr.bShadow1 = PAL_ENTRY_COLOR_TRANSPARENT;
    DateStringAttr.bShadow2 = PAL_ENTRY_COLOR_TRANSPARENT;
    DateStringAttr.bTextColor = CLOCK_PALETTE_ENTRY_DATE;     
    DateStringAttr.wY = CLOCK_DISPLAY_DATE_POS_START_Y;

//#ifdef CT951_PLATFORM
    RTC_GetTime(&Calendar);
    /*
#else
    Calendar.bYear = 6;
    Calendar.bMon = 1;
    Calendar.bDate = 1;
#endif //CT951_PLATFORM
    */

    OSDUTL_PrepareOutputString();
    switch (Calendar.bMon)
    {
    case 1:
        OSDUTL_CopyStringFromIndex(aMonthJanuary);
        break;
    case 2:
        OSDUTL_CopyStringFromIndex(aMonthFebruary);
        break;
    case 3:
        OSDUTL_CopyStringFromIndex(aMonthMarch);
        break;
    case 4:
        OSDUTL_CopyStringFromIndex(aMonthApril);
        break;
    case 5:
        OSDUTL_CopyStringFromIndex(aMonthMay);
        break;
    case 6:
        OSDUTL_CopyStringFromIndex(aMonthJune);
        break;
    case 7:
        OSDUTL_CopyStringFromIndex(aMonthJuly);
        break;
    case 8:
        OSDUTL_CopyStringFromIndex(aMonthAugust);
        break;
    case 9:
        OSDUTL_CopyStringFromIndex(aMonthSeptember);
        break;
    case 10:
        OSDUTL_CopyStringFromIndex(aMonthOctober);
        break;
    case 11:
        OSDUTL_CopyStringFromIndex(aMonthNovember);
        break;
    case 12:
        OSDUTL_CopyStringFromIndex(aMonthDecember);
        break;
    default:
        break;
    }

    OSDUTL_CopyStringFromIndex(aCLOCKDateDistance);
    OSDUTL_OutputNumFromIndex(Calendar.bDate);
    OSDUTL_CopyStringFromIndex(aCLOCKDateDistance);
    OSDUTL_OutputNumFromIndex(Calendar.bYear+2000);

    bDay = Calendar_SolarCalendar(Calendar.bYear+2000, Calendar.bMon, Calendar.bDate);
    OSDUTL_CopyStringFromIndex(aCLOCKDayDistance);

    switch (bDay)
    {
    case 0:
        OSDUTL_CopyStringFromIndex(aWeeklySunday);
        break;
    case 1:
        OSDUTL_CopyStringFromIndex(aWeeklyMonday);
        break;
    case 2:
        OSDUTL_CopyStringFromIndex(aWeeklyTuesday);
        break;
    case 3:
        OSDUTL_CopyStringFromIndex(aWeeklyWednesday);
        break;
    case 4:
        OSDUTL_CopyStringFromIndex(aWeeklyThursday);
        break;
    case 5:
        OSDUTL_CopyStringFromIndex(aWeeklyFriday);
        break;
    case 6:
        OSDUTL_CopyStringFromIndex(aWeeklySaturday);
        break;
    default:
        break;
    }

    DateStringAttr.wX = (POWERPNMENU_WIDTH-GDI_GetStringWidth(__pOSDUTLOutputString))>>1;
    GDI_DrawString_909(0, &DateStringAttr, __pOSDUTLOutputString);
}

//***************************************************************************
//  Function    :   _CLOCK_DisplayBigClock
//  Abstract    :   Display the big colock.
//  Arguments   :   none.
//  Return      :   none.
//  Side Effect :   none.
//  Notes       :   
//***************************************************************************
void _CLOCK_DisplayBigClock(void)
{
    RTC_TM RTCTime; 

//#ifdef NL_SOLUTION
    //DISP_DisplayCtrl(DISP_MAINVIDEO, FALSE);
//#endif //NL_SOLUTION
    POWERONMENU_ClearScreen();

    RTC_GetTime(&RTCTime); //Be called when system want to display current time, the query result will be stored in RTC_TM struct

    //Display hour
    _CLOCK_UpdateTimeNum(0, RTCTime.bHr/10);
    _CLOCK_UpdateTimeNum(1, RTCTime.bHr%10);

    //Display colon
    _CLOCK_DisplayBigClockColon(0);

    //Display minute
    _CLOCK_UpdateTimeNum(2, RTCTime.bMin/10);
    _CLOCK_UpdateTimeNum(3, RTCTime.bMin%10);

    //Display colon
    _CLOCK_DisplayBigClockColon(1);

    //Display second
    _CLOCK_UpdateTimeNum(4, RTCTime.bSec/10);
    _CLOCK_UpdateTimeNum(5, RTCTime.bSec%10);

    __bCLOCKShowClock = TRUE;
}

//  ***************************************************************************
//  Function    :   _CLOCK_ConfigOSDRegion
//  Description :   
//  Arguments   :   None.
//  Return      :   None.
//  Side Effect :
//  ***************************************************************************
void _CLOCK_ConfigOSDRegion(BYTE bMode)
{
    GDI_REGION_INFO RegionInfo;
#ifdef  BORROW_FRAME_BUFFER
    DWORD dwBufferAddr;
#endif //

    GDI_ClearRegion(0);

#ifdef  BORROW_FRAME_BUFFER

    if ((POWERPNMENU_WIDTH == __RegionList[0].wWidth) && (POWERPNMENU_HEIGHT <= __RegionList[0].wHeight) &&
        (bMode == __RegionList[0].bColorMode)) 
    {
        return;
    }
    else if (__RegionList[0].bColorMode != bMode)   // Thumbnail mode & preview mode
    {
        // Use Frame buffer 1 or 2
        dwBufferAddr = DISP_QueryAvailableBuffer();
        if (0 == dwBufferAddr)
        {
            RegionInfo.dwTAddr = DS_OSDFRAME_ST;
        }
        else
        {
            RegionInfo.dwTAddr = dwBufferAddr;
        }
    } 
    else
    {
        // Use OSD buffer and Frame buffer 0
        RegionInfo.dwTAddr = DS_OSDFRAME_ST;   // Use OSD buffer and Frame buffer 0 
    }
#else
    RegionInfo.dwTAddr = DS_OSDFRAME_ST;
#endif // #ifdef  BORROW_FRAME_BUFFER

    RegionInfo.wWidth = POWERPNMENU_WIDTH;
    RegionInfo.wHeight = POWERPNMENU_HEIGHT;
    RegionInfo.bColorMode = bMode;

#ifdef  BORROW_FRAME_BUFFER
    OSD_SetRegion(0, TRUE, &RegionInfo);
#else
    OSD_SetRegion(0, FALSE, &RegionInfo);
#endif
}

//*********************************************************************************************************
//  Function    :   CLOCK_Recover
//  Abstract    :   Call this function to do recovery.
//  Arguments   :   bRecoverRegion: OSD_RECOVER_UPPER_REGION/OSD_RECOVER_BOTTOM_REGION.
//  Return		:   TRUE: The region is recovered.
//              :   FALSE: The region doesn't need to be recovered in THUMB UI.
//  Side Effect :   none.
//  Notes       :
//*********************************************************************************************************
BYTE CLOCK_Recover(BYTE bRecoverRegion)
{
    //Show Clock menu.
    //Config the OSD to 4 bit mode.
    _CLOCK_ConfigOSDRegion(GDI_OSD_8B_MODE);

    switch (_bCLOCKMode)
    {
    case CLOCK_MODE_SHOW_CLOCK:
        _CLOCK_PrepareBigClock();
        _CLOCK_DisplayBigClock();
        break;
    case CLOCK_MODE_MENU:
        CLOCK_ShowMenu();
        break;
    case CLOCK_MODE_SET_TIME:
        CLOCK_ShowMenu();
        SETTIME_Recover(_hCLOCKSetTime);
        break;
    default:
        break;
    }

    return TRUE;
}

void CLOCK_Trigger(BYTE bType, WORD wTime)
{
    RTC_TM RTCTime;

    if (__bCLOCKShowClock)
    {
        if ((OS_GetSysTimer() - _dwCLOCKTriggerTime) > COUNT_500_MSEC)
        {
            RTC_GetTime(&RTCTime);
            
            if ((_CLOCKCurrnetRTCTime.bSec == RTCTime.bSec) &&
                (_CLOCKCurrnetRTCTime.bMin == RTCTime.bMin) &&
                (_CLOCKCurrnetRTCTime.bHr == RTCTime.bHr))
            {
                return;
            }
            else
            {            
                //Check the second.
                _CLOCK_UpdateTimeNum(5, RTCTime.bSec%10);
                
                if ((_CLOCKCurrnetRTCTime.bSec/10) != (RTCTime.bSec/10))
                {
                    //Display second
                    _CLOCK_UpdateTimeNum(4, RTCTime.bSec/10);
                }
                
                if ((_CLOCKCurrnetRTCTime.bMin/10) != (RTCTime.bMin/10))
                {
                    //Display minute
                    _CLOCK_UpdateTimeNum(2, RTCTime.bMin/10);
                }
                
                if ((_CLOCKCurrnetRTCTime.bMin%10) != (RTCTime.bMin%10))
                {
                    _CLOCK_UpdateTimeNum(3, RTCTime.bMin%10);
                }
                
                //Display hour
                if ((_CLOCKCurrnetRTCTime.bHr/10) != (RTCTime.bHr/10))
                {
                    //Display minute
                    _CLOCK_UpdateTimeNum(0, RTCTime.bHr/10);
                }
                
                if ((_CLOCKCurrnetRTCTime.bHr%10) != (RTCTime.bHr%10))
                {
                    _CLOCK_UpdateTimeNum(1, RTCTime.bHr%10);
                }

                //Update the date?
                if ((_CLOCKCurrnetRTCTime.bHr == 0) && (_CLOCKCurrnetRTCTime.bMin == 0) && (_CLOCKCurrnetRTCTime.bSec == 0))
                {
                    _CLOCK_DisplayDate();
                }
                
                _CLOCKCurrnetRTCTime.bSec = RTCTime.bSec;
                _CLOCKCurrnetRTCTime.bMin = RTCTime.bMin;
                _CLOCKCurrnetRTCTime.bHr = RTCTime.bHr;
                _CLOCKCurrnetRTCTime.bDate = RTCTime.bDate;
                _CLOCKCurrnetRTCTime.bMon = RTCTime.bMon;
                _CLOCKCurrnetRTCTime.bDay = RTCTime.bDay;
                _CLOCKCurrnetRTCTime.bYear = RTCTime.bYear;
            }
            
            _dwCLOCKTriggerTime = OS_GetSysTimer();
        }
    }
}

void CLOCK_Exit(BYTE bClearBackground)
{
    if (_hCLOCKMenu != MENU_HANDLE_INVALID)
    {
        MENU_DeleteMenu(_hCLOCKMenu, bClearBackground);
        _hCLOCKMenu = MENU_HANDLE_INVALID;
    }

    if (_hCLOCKSetTime != SETTIME_HANDLE_INVALID)
    {
        SETTIME_Exit(_hCLOCKSetTime, TRUE);
        _hCLOCKSetTime = MENU_HANDLE_INVALID;
    }

    __bCLOCKShowClock = FALSE;

//#ifdef NL_SOLUTION
    //DISP_DisplayCtrl(DISP_MAINVIDEO, TRUE);
//#endif //NL_SOLUTION
}