ui_flow_menu.c

其乐达(Cheertek)LCD驱动芯片(CT675)的C51源代码

#include "..\INC\SYS_DECLARE.H"
#include "..\INC\SYS_GLOBAL.H"
#include "..\INC\SYS_INITIAL.H"
#include "..\INC\SYS_KEY.H"

#include "..\API\INC\API_IIC.H"
#include "..\API\INC\API_EEPROM.H"
#include "..\API\INC\API_OSD.H"
#include "..\API\INC\API_CTRL.H"
#include "..\API\INC\API_PANEL.H"

#include "INC\UI_OSD.H"
#include "INC\UI_FLOW_CTRL.H"

/****************************************************************************
 * UI Menu function - common routine: control
 ****************************************************************************/
void _PositionCtrl(BOOL fType)
{
    if(fType)   // adjust window
    {
        if(gScalerPara.fAspectType)     // 4:3
        {
            API_OSD_SetPosition(0x06, 0xb8);
        }
        else                            // 16:9
        {
            API_OSD_SetPosition(0x38, 0xb8);
        }
    }
    else        // menu window
    {
        API_OSD_SetPosition(0x06, 0x00);
    }
}

/****************************************************************************
 * UI Menu function - common routine: adjust window
 ****************************************************************************/
BYTE code _ICheckedStr0[] = { _O, _F, _F, _EOF };
BYTE code _ICheckedStr1[] = { _O, _N, __, _EOF };

BYTE code * code _ICheckedStr[] =
{
    _ICheckedStr0,
    _ICheckedStr1
};

void _ItemWindowInit(BYTE code *pStr)
{
    _PositionCtrl(1);

    UI_OSD_SetAreaRowAttr(0, 2, 0x00, 0x14);
    API_OSD_ClearRow(0, 15, OSD_BLACK);
    UI_OSD_DrawFrame(0, 2, 0, 30);
    API_OSD_Window(0, OsdItemWindow, OSD_YELLOW_1);

    API_OSD_PrintString(1, 1, OSD_BLACK, pStr);
}

/***************************************************************************/
void _ItemWindowExit(void)
{
    gfKeyRepeat = 0;
    API_OSD_DisableWindow(0);
    API_OSD_ClearRow(0, 15, OSD_BLACK);
    _PositionCtrl(0);
    UI_FLC_ReturnLastState();
}

/***************************************************************************/
void _AdjItemWindowInit(BYTE code *pStr, BYTE bVal)
{
    _ItemWindowInit(pStr);
    UI_OSD_DrawProgressBar(1, 15, bVal, gSysInfo.fFactoryMode);
}

/***************************************************************************/
BYTE _AdjItemWindowProc(BYTE bKey, BYTE bStep, BYTE bVal)
{
    switch(bKey)
    {
        case KEY_LEFT:
            if(bVal > 0)
            {
                gfKeyRepeat = 1;
                bVal = (bVal > bStep) ? (bVal - bStep) : 0;
                UI_OSD_DrawProgressBar(1, 15, bVal, gSysInfo.fFactoryMode);
            }
            else
                gfKeyRepeat = 0;
            break;

        case KEY_RIGHT:
            if(bVal < 255)
            {
                gfKeyRepeat = 1;
                bVal = ((255-bVal) > bStep) ? (bVal + bStep) : 255;
                UI_OSD_DrawProgressBar(1, 15, bVal, gSysInfo.fFactoryMode);
            }
            else
                gfKeyRepeat = 0;
            break;

        default:
            break;
    }

    return bVal;
}

/***************************************************************************/
void _CheckedItemWindowInit(BYTE code *pStr, BOOL fChecked)
{
    _ItemWindowInit(pStr);

    API_OSD_PrintString(1, 15, fChecked ? OSD_GRAY_2 : OSD_BLUE,   _ICheckedStr0);
    API_OSD_PrintString(1, 20, fChecked ? OSD_BLUE   : OSD_GRAY_2, _ICheckedStr1);
}

/***************************************************************************/
BOOL _CheckedItemWindowProc(BOOL fChecked)
{
    gfKeyRepeat = 0;
    fChecked = ~fChecked;

    API_OSD_PrintString(1, 15, fChecked ? OSD_GRAY_2 : OSD_BLUE,   _ICheckedStr0);
    API_OSD_PrintString(1, 20, fChecked ? OSD_BLUE   : OSD_GRAY_2, _ICheckedStr1);

    return fChecked;
}
/****************************************************************************
 * UI Menu function - Normal play (No OSD menu)
 ****************************************************************************/
BYTE code MVideoSubSystemStr0[] = { _S, _E, _C, _A, _M, _EOF }; // SECAM
BYTE code MVideoSubSystemStr1[] = { _N, _T, _S, _C, __, _EOF }; // NTSC 50
BYTE code MVideoSubSystemStr2[] = { _P, _A, _L, __, __, _EOF }; // PAL BG
BYTE code MVideoSubSystemStr3[] = { _P, _A, _L, __, __, _EOF }; // PAL N
BYTE code MVideoSubSystemStr4[] = { _N, _T, _S, _C, __, _EOF }; // NTSC 60
BYTE code MVideoSubSystemStr5[] = { _N, _T, _S, _C, __, _EOF }; // NTSC M
BYTE code MVideoSubSystemStr6[] = { _P, _A, _L, __, __, _EOF }; // PAL 60
BYTE code MVideoSubSystemStr7[] = { _P, _A, _L, __, __, _EOF }; // PAL M

BYTE code * code MVideoSubSystemStr[] =
{
    MVideoSubSystemStr0,
    MVideoSubSystemStr1,
    MVideoSubSystemStr2,
    MVideoSubSystemStr3,
    MVideoSubSystemStr4,
    MVideoSubSystemStr5,
    MVideoSubSystemStr6,
    MVideoSubSystemStr7
};

void UI_FL_NormalPlayInit(void)
{
    BYTE it;

#if(UART_DEBUG_MSG)
    printf("...normal_play_init\n");
#endif // UART_DEBUG_MSG

    API_OSD_ClearRow(0, 15, OSD_BLACK);      // Clear OSD

    for(it = 0; it < 15; it++)
        API_OSD_SetRowAttr(it, 0x00, 0x34);
    API_OSD_SetRowAttr(it, 0x00, 0x35);

    gfDisplayOsdTitle = 1;
    gbOsdPromptTimer = 6;   // 6 sec
}

/***************************************************************************/
void UI_FL_NormalPlayProc(BYTE bKey)
{
#if(UART_DEBUG_MSG)
    if(bKey != KEY_NO_KEY)  printf("...normal_play_proc(%02X)\n", (int)bKey);
#endif // UART_DEBUG_MSG

    switch(bKey)
    {
        case KEY_LOAD_DEFAULT:
            API_EEPROM_LoadAllDefault();
            break;

        case KEY_POWER:
            BACKLIGHT_PIN = ~BACKLIGHT_PIN;
            break;

        case KEY_MENU:
            UI_FLC_EnterNewState(FS_MENU_MAIN);
            break;

        case KEY_UP:
            if(gSysInfo.bInputSource != EN_INPUT_SVIDEO)
                API_CTRL_SwitchSource(gSysInfo.bInputSource + 1);
            else
                API_CTRL_SwitchSource(EN_INPUT_CVBS);
            break;

        case KEY_NO_KEY:
            if(gfDisplayOsdTitle)
            {
                if(gbOsdPromptTimer != 0)
                {
                    API_OSD_PrintString(0, 0, OSD_GREEN,  MInputItemStr[gSysInfo.bInputSource]);

                    if(gSysInfo.bVideoLines != EN_VIDEO_FREERUN)
                        API_OSD_PrintString(1, 0, OSD_GRAY_2, MVideoSubSystemStr[gSysInfo.bVideoStandard]);
                    else
                        API_OSD_ClearRow(1, 1, OSD_BLACK);

                    // treat as a timer to trigger SAR ADC
                    if(gScalerPara.fBatteryDetect)
                    {
                        UI_OSD_DrawBatteryStatus(3, 0, API_CTRL_GetSarAdcValue(0), OSD_BLUE);
                    }
                }
                else
                {
                    gfDisplayOsdTitle = 0;
                    API_OSD_ClearRow(0, 15, OSD_BLACK);
                }
            }
            break;

        default:
            break;
    }
}

/****************************************************************************
 * UI Menu function - Main Menu
 ****************************************************************************/
BYTE code MMenuItemStr1[] = { _P, _I, _C, _T, _U, _R, _E, _EOF };
BYTE code MMenuItemStr2[] = { _I, _N, _P, _U, _T, __, __, _EOF };
//BYTE code MMenuItemStr3[] = { _T, _V, __, __, __, __, __, _EOF };
BYTE code MMenuItemStr4[] = { _F, _A, _C, _T, _0, _R, _Y, _EOF };

BYTE code * code MMenuItemStr[] =
{
    MMenuItemStr1,
    MMenuItemStr2,
    //MMenuItemStr3,
    MMenuItemStr4
};

/***************************************************************************/
void UI_FL_MainDrawItem(BYTE bIndex, BYTE bColor)
{
    API_OSD_PrintString(bIndex+1, 1, bColor, MMenuItemStr[bIndex]);
}

/***************************************************************************/
void UI_FL_MainInit(void)
{
    BYTE i;

#if(UART_DEBUG_MSG)
    printf("...main_menu_init\n");
#endif // UART_DEBUG_MSG

    UI_OSD_SetAreaRowAttr(0, MAIN_MENU_ITEM_MAX + 1, 0x00, 0x14);
    UI_OSD_DrawFrame(0, MAIN_MENU_ITEM_MAX + 1, 0, 8);
    gbFocusItemIdx = 0;

    for(i = 0; i < MAIN_MENU_ITEM_MAX; i++)
        UI_FL_MainDrawItem(i, ( (i == gbFocusItemIdx) ? FOCUS_COLOR : UNFOCUS_COLOR ) );
}

/***************************************************************************/
void UI_FL_MainProc(BYTE bKey)
{
#if(UART_DEBUG_MSG)
    printf("...main_menu_proc(%02X)\n", (int)bKey);
#endif // UART_DEBUG_MSG

    switch(bKey)
    {
        case KEY_LEFT:
        case KEY_EXIT:
            API_EEPROM_StoreAllPara();
            UI_FLC_ReturnLastState();
            break;

        case KEY_UP:
            UI_FL_MainDrawItem(gbFocusItemIdx, UNFOCUS_COLOR);

            if(gbFocusItemIdx)  gbFocusItemIdx--;
            else                gbFocusItemIdx = MAIN_MENU_ITEM_MAX - 1;

            UI_FL_MainDrawItem(gbFocusItemIdx, FOCUS_COLOR);
            break;

        case KEY_DOWN:
            UI_FL_MainDrawItem(gbFocusItemIdx, UNFOCUS_COLOR);

            gbFocusItemIdx++;
            if(gbFocusItemIdx == MAIN_MENU_ITEM_MAX)    gbFocusItemIdx = 0;

            UI_FL_MainDrawItem(gbFocusItemIdx, FOCUS_COLOR);
            break;

        case KEY_RIGHT:
        case KEY_MENU:
            UI_FLC_EnterNewState(FS_MENU_PICTURE + gbFocusItemIdx);
            break;

        default:
            break;
    }
}

/****************************************************************************
 * UI Menu function - Picture sub-menu
 ****************************************************************************/
BYTE code MPictureItemStr1[] = { _B, _R, _I, _G, _H, _T, _N, _E, _S, _S, _EOF };
BYTE code MPictureItemStr2[] = { _C, _0, _N, _T, _R, _A, _S, _T, __, __, _EOF };
BYTE code MPictureItemStr3[] = { _H, _U, _E, __, __, __, __, __, __, __, _EOF };
BYTE code MPictureItemStr4[] = { _S, _A, _T, _U, _R, _A, _T, _I, _O, _N, _EOF };
BYTE code MPictureItemStr5[] = { _S, _H, _A, _R, _P, _N, _E, _S, _S, __, _EOF };
BYTE code MPictureItemStr6[] = { _Z, _O, _O, _M, __, __, __, __, __, __, _EOF };
BYTE code MPictureItemStr7[] = { _F, _L, _I, _P, __, __, __, __, __, __, _EOF };

BYTE code * code MPictureItemStr[] =
{
    MPictureItemStr1,
    MPictureItemStr2,
    MPictureItemStr3,
    MPictureItemStr4,
    MPictureItemStr5,
    MPictureItemStr6,
    MPictureItemStr7
};

/***************************************************************************/
void UI_FL_PictureDrawItem(BYTE bIndex, BYTE bColor)
{
    API_OSD_PrintString(bIndex+1, 1, bColor, MPictureItemStr[bIndex]);
}

/***************************************************************************/
void UI_FL_PictureInit(void)
{
    BYTE i;

#if(UART_DEBUG_MSG)
    printf("...menu_picture_init\n");
#endif // UART_DEBUG_MSG

#if(MAIN_MENU_ITEM_MAX < MENU_PICTURE_ITEM_MAX)
    UI_OSD_SetAreaRowAttr(0, MENU_PICTURE_ITEM_MAX + 1, 0x00, 0x14);
#endif // MAIN_MENU_ITEM_MAX < MENU_PICTURE_ITEM_MAX

    API_OSD_ClearRow(0, 15, OSD_BLACK);
    UI_OSD_DrawFrame(0, MENU_PICTURE_ITEM_MAX + 1, 0, 11);