winclock.c

AMLOGIC DPF source code

/*****************************************************************
**                                                             	**
**  Copyright (C) 2004 Amlogic,Inc.                            	**
**  All rights reserved                                        	**
**        Filename : WinClock.c /Project:AVOS		       **
**        Revision : 1.0                                       	**
**                                                             	**
*****************************************************************/
#include "../menu.h"
#include "WinClockEvent.h"
#include "user.h"
#ifdef ENABLE_CLOCK
INT32S WinClockMsgProc(PHWND hwnd, INT32U msg_type, INT32S lpParam)
{
    switch( msg_type){
        case WM_SHOWWINDOW:
            CreateMenuWinClock();
            return WinClockOnShow(hwnd, lpParam) ;
        case WM_KEYDOWN:
            return WinClockOnKeyPress(hwnd, lpParam) ;
    }
    return 0 ;
}

void SetWinClockPalette(void)
{
    YUVENTRY mask_para[4] = {0,2730,2730,4095};
    AWSetAlphaMask(0,4, mask_para);
    YUVENTRY palette_para[16] = {0x8000 | 16392,0x8000 | 17512,0x8000 | 18055,0x8000 | 17841,18312,15098,9578,9418,9259,9083,8907,17512,14845,12986,18424,31333};
    AWSetPalette(0,16, palette_para);
    return ;
}

void SetWinClockPos(HWND* pControl, INT8U CurOsdSize)
{
    switch(CurOsdSize){
        case STANDARD:
            SetWinClockPalette();
            RECT StandardWindowRect = {80,0,330,230};
            pControl->winrect = StandardWindowRect;
            CREATEWINDOWPARAM StandardWindowPara = {3,{{96,0,300,32},
            {80,80,330,80},
            {210,190,200,40},
            {0,0,0,0}},
            {PF_PALETTE_16,PF_PALETTE_16,PF_PALETTE_16,0},SetWinClockPalette};
            AWSendMessage(pControl, WM_WINDOW_RESET_DRAW_AREA, (INT32S)&StandardWindowPara);
            break ;
    }//end of switch
    return;
}

HWND *CreateControlWinClock(HWND* pParent)
{
    HWND* pNewControl;
    SetWinClockPalette();
    CREATEWINDOWPARAM window_para = {3,{{96,0,300,32},
        {80,80,330,80},
        {210,190,200,40},
        {0,0,0,0}},
        {PF_PALETTE_16,PF_PALETTE_16,PF_PALETTE_16,0},SetWinClockPalette};
    //Create Menu Window -- 0
    pNewControl = AWCreateWinControl("TWindow","WinClock",WS_OVERLAPPEDWINDOW,
		         80,0,330,230,NULL, (INT32S)&window_para,WinClockMsgProc) ;
    pNewControl->win_id = 0 ;
    return pNewControl;
}

void SetWinTimeClockPos(HWND* pControl, INT8U CurOsdSize)
{
    int iLoop;
    switch(CurOsdSize){
        case STANDARD:
            pControl->winrect.top = pControl->parent->winrect.top + 80;
            pControl->winrect.left = pControl->parent->winrect.left + 0;
            pControl->winrect.width = 330;
            pControl->winrect.height = 80;
            pControl->draw_info_num = 6;
            RECT StandardDrawRect[6] = {
            {pControl->winrect.left + 259,pControl->winrect.top + 0,70,74},
            {pControl->winrect.left + 0,pControl->winrect.top + 0,56,74},
            {pControl->winrect.left + 58,pControl->winrect.top + 0,56,74},
            {pControl->winrect.left + 115,pControl->winrect.top + 0,29,74},
            {pControl->winrect.left + 144,pControl->winrect.top + 0,56,74},
            {pControl->winrect.left + 202,pControl->winrect.top + 0,56,74},
            };
            for(iLoop=0; iLoop < 6; iLoop++)
                memcpy(&(pControl->draw_info[iLoop]), &StandardDrawRect[iLoop], sizeof(RECT));
            break ;
    }//end of switch
    return;
}

INT32S WinTimeClockMsgProc(PHWND hwnd, INT32U msg_type, INT32S lpParam)
{
    switch( msg_type){
        case WM_SHOWWINDOW:
            return WinTimeClockOnShow(hwnd, lpParam) ;
    }
    return 0 ;
}

HWND *CreateControlWinTimeClock(HWND *pParent)
{
    //Create Control -- WinTimeClock
    HWND *pNewControl = AWCreateWinControl("TControl","WinTimeClock",(WS_CHILDWINDOW | WS_CHILDWINDOW),
		         0,80,330,80,pParent,0,WinTimeClockMsgProc) ;
    pNewControl->win_id = 1 ;
    pNewControl->draw_info_num = 6;
    pNewControl->draw_info = (PDRAWINFO)AVMem_umalloc(sizeof(DRAWINFO) * pNewControl->draw_info_num) ;
    DRAWINFO DrawDatas[6] = {
        {0,0,0,0,(INT32U)ICON_CALENDAR_AM,DT_RLE_BMP_DATA},
        {0,0,0,0,(INT32U)ICON_0_CALENDAR,DT_RLE_BMP_DATA},
        {0,0,0,0,(INT32U)ICON_0_CALENDAR,DT_RLE_BMP_DATA},
        {0,0,0,0,(INT32U)ICON_P,DT_RLE_BMP_DATA},
        {0,0,0,0,(INT32U)ICON_0_CALENDAR,DT_RLE_BMP_DATA},
        {0,0,0,0,(INT32U)ICON_0_CALENDAR,DT_RLE_BMP_DATA}};
    memcpy(pNewControl->draw_info, DrawDatas, sizeof(DRAWINFO) * pNewControl->draw_info_num) ;

    return pNewControl;
}

void SetWinAlarmPos(HWND* pControl, INT8U CurOsdSize)
{
    int iLoop;
    switch(CurOsdSize){
        case STANDARD:
            pControl->winrect.top = pControl->parent->winrect.top + 192;
            pControl->winrect.left = pControl->parent->winrect.left + 134;
            pControl->winrect.width = 31;
            pControl->winrect.height = 37;
            pControl->draw_info_num = 1;
            RECT StandardDrawRect[1] = {
            {pControl->winrect.left + 0,pControl->winrect.top + 0,31,37},
            };
            for(iLoop=0; iLoop < 1; iLoop++)
                memcpy(&(pControl->draw_info[iLoop]), &StandardDrawRect[iLoop], sizeof(RECT));
            break ;
    }//end of switch
    return;
}

INT32S WinAlarmMsgProc(PHWND hwnd, INT32U msg_type, INT32S lpParam)
{
    switch( msg_type){
        case WM_SHOWWINDOW:
            return WinAlarmOnShow(hwnd, lpParam) ;
    }
    return 0 ;
}

HWND *CreateControlWinAlarm(HWND *pParent)
{
    //Create Control -- WinAlarm
    HWND *pNewControl = AWCreateWinControl("TControl","WinAlarm",(WS_CHILDWINDOW | WS_CHILDWINDOW),
		         134,192,31,37,pParent,0,WinAlarmMsgProc) ;
    pNewControl->win_id = 2 ;
    pNewControl->draw_info_num = 1;
    pNewControl->draw_info = (PDRAWINFO)AVMem_umalloc(sizeof(DRAWINFO) * pNewControl->draw_info_num) ;
    DRAWINFO DrawDatas[1] = {
        {0,0,0,0,(INT32U)ALARM_OFF_ICON,DT_RLE_BMP_DATA}};
    memcpy(pNewControl->draw_info, DrawDatas, sizeof(DRAWINFO) * pNewControl->draw_info_num) ;

    return pNewControl;
}

void SetWinAlarmClockPos(HWND* pControl, INT8U CurOsdSize)
{
    int iLoop;
    switch(CurOsdSize){
        case STANDARD:
            pControl->winrect.top = pControl->parent->winrect.top + 198;
            pControl->winrect.left = pControl->parent->winrect.left + 168;
            pControl->winrect.width = 140;
            pControl->winrect.height = 30;
            pControl->draw_info_num = 6;
            RECT StandardDrawRect[6] = {
            {pControl->winrect.left + 103,pControl->winrect.top + 4,28,22},
            {pControl->winrect.left + 0,pControl->winrect.top + 0,20,26},
            {pControl->winrect.left + 20,pControl->winrect.top + 0,20,26},
            {pControl->winrect.left + 40,pControl->winrect.top + 0,20,26},
            {pControl->winrect.left + 60,pControl->winrect.top + 0,20,26},
            {pControl->winrect.left + 80,pControl->winrect.top + 0,20,26},
            };
            for(iLoop=0; iLoop < 6; iLoop++)
                memcpy(&(pControl->draw_info[iLoop]), &StandardDrawRect[iLoop], sizeof(RECT));
            break ;
    }//end of switch
    return;
}

INT32S WinAlarmClockMsgProc(PHWND hwnd, INT32U msg_type, INT32S lpParam)
{
    switch( msg_type){
        case WM_SHOWWINDOW:
            return WinAlarmClockOnShow(hwnd, lpParam) ;
    }
    return 0 ;
}

HWND *CreateControlWinAlarmClock(HWND *pParent)
{
    //Create Control -- WinAlarmClock
    HWND *pNewControl = AWCreateWinControl("TControl","WinAlarmClock",(WS_CHILDWINDOW | WS_CHILDWINDOW),
		         168,198,140,30,pParent,0,WinAlarmClockMsgProc) ;
    pNewControl->win_id = 3 ;
    pNewControl->draw_info_num = 6;
    pNewControl->draw_info = (PDRAWINFO)AVMem_umalloc(sizeof(DRAWINFO) * pNewControl->draw_info_num) ;
    DRAWINFO DrawDatas[6] = {
        {0,0,0,0,(INT32U)ICON_ALARM_AM,DT_RLE_BMP_DATA},
        {0,0,0,0,(INT32U)ICON_0_ALARM,DT_RLE_BMP_DATA},
        {0,0,0,0,(INT32U)ICON_0_ALARM,DT_RLE_BMP_DATA},
        {0,0,0,0,(INT32U)ICON_ALARM_P,DT_RLE_BMP_DATA},
        {0,0,0,0,(INT32U)ICON_0_ALARM,DT_RLE_BMP_DATA},
        {0,0,0,0,(INT32U)ICON_0_ALARM,DT_RLE_BMP_DATA}};
    memcpy(pNewControl->draw_info, DrawDatas, sizeof(DRAWINFO) * pNewControl->draw_info_num) ;

    return pNewControl;
}

void SetWinClockKeyHintPos(HWND* pControl, INT8U CurOsdSize)
{
    int iLoop;
    switch(CurOsdSize){
        case STANDARD:
            pControl->winrect.top = pControl->parent->winrect.top + 0;
            pControl->winrect.left = pControl->parent->winrect.left + 16;
            pControl->winrect.width = 300;
            pControl->winrect.height = 32;
            pControl->draw_info_num = 1;
            RECT StandardDrawRect[1] = {
            {pControl->winrect.left + 0,pControl->winrect.top + 0,300,32},
            };
            for(iLoop=0; iLoop < 1; iLoop++)
                memcpy(&(pControl->draw_info[iLoop]), &StandardDrawRect[iLoop], sizeof(RECT));
            break ;
    }//end of switch
    return;
}

INT32S WinClockKeyHintMsgProc(PHWND hwnd, INT32U msg_type, INT32S lpParam)
{
    switch( msg_type){
        default:
            return WinClockKeyHintOnOtherEvent(hwnd, msg_type, lpParam) ;
    }
    return 0 ;
}

HWND *CreateControlWinClockKeyHint(HWND *pParent)
{
    //Create Control -- WinClockKeyHint
    HWND *pNewControl = AWCreateWinControl("TControl","WinClockKeyHint",(WS_CHILDWINDOW | WS_CHILDWINDOW),
		         16,0,300,32,pParent,0,WinClockKeyHintMsgProc) ;
    pNewControl->win_id = 4 ;
    pNewControl->draw_info_num = 1;
    pNewControl->draw_info = (PDRAWINFO)AVMem_umalloc(sizeof(DRAWINFO) * pNewControl->draw_info_num) ;
    DRAWINFO DrawDatas[1] = {
        {0,0,0,0,(INT32U)CLOCKHINT_ICON,DT_RLE_BMP_DATA}};
    memcpy(pNewControl->draw_info, DrawDatas, sizeof(DRAWINFO) * pNewControl->draw_info_num) ;

    return pNewControl;
}

HWND* CreateMenuWinClock(void)
{
    HWND *pNewControl ;
    TWINDOWS *pWin;
    HWND *pWinClock = CreateControlWinClock(NULL);
    SetWinClockPos(pWinClock,CurrentOsdSize);

    pNewControl= CreateControlWinTimeClock(pWinClock);
    SetWinTimeClockPos(pNewControl,CurrentOsdSize);

    pNewControl= CreateControlWinAlarm(pWinClock);
    SetWinAlarmPos(pNewControl,CurrentOsdSize);

    pNewControl= CreateControlWinAlarmClock(pWinClock);
    SetWinAlarmClockPos(pNewControl,CurrentOsdSize);

    pNewControl= CreateControlWinClockKeyHint(pWinClock);
    SetWinClockKeyHintPos(pNewControl,CurrentOsdSize);

    pWin = (TWINDOWS *)pWinClock;
    pWin->pFocusControl = AWFindWinCtrlByName("WinClockKeyHint");
    return pWinClock;
}

void WinResetWinClockControlsPos(HWND *pControl, INT8U CurOsdSize)
{
    switch(pControl->win_id){
        case 0://WinClock
            SetWinClockPos(pControl,CurOsdSize) ;
            break ;
        case 1://WinTimeClock
            SetWinTimeClockPos(pControl,CurOsdSize) ;
            break ;
        case 2://WinAlarm
            SetWinAlarmPos(pControl,CurOsdSize) ;
            break ;
        case 3://WinAlarmClock
            SetWinAlarmClockPos(pControl,CurOsdSize) ;
            break ;
        case 4://WinClockKeyHint
            SetWinClockKeyHintPos(pControl,CurOsdSize) ;
            break ;
    }//end of switch
}
void WinResetWinClockPos(HWND *pControl, INT8U CurOsdSize)
{
    HWND *pChildControl;
    if(pControl == NULL)
        pControl = AWFindWinCtrlByName("WinClock");
    if(pControl == NULL) return ;

    WinResetWinClockControlsPos(pControl, CurOsdSize) ;
    pChildControl = pControl->children ;
    while(pChildControl != NULL){
    	WinResetWinClockPos(pChildControl, CurOsdSize) ;
    	pChildControl = pChildControl->siblings ;
	}
	return ;
}
#endif