menu.c

ct952 source code use for Digital Frame Photo

#include "winav.h"
#ifdef SUPPORT_STB
#include "dvbcustm.h"
#endif
#include "gdi.h"
#include "fontindex.h"
#include "utl.h"
#include "osddsply.h"
#include "osdnd.h"
#include "input.h"
#include "menu.h"

MENU *_pMENUCurrentMenu[MAX_SUPPORT_MENU_HANDLE_NUM];
MENU *_pMENUSubMenu[MAX_SUPPORT_MENU_HANDLE_NUM];
HMENU _hMenuStack[MAX_SUPPORT_MENU_HANDLE_NUM] = {MENU_HANDLE_FREE, MENU_HANDLE_FREE, MENU_HANDLE_FREE, MENU_HANDLE_FREE, MENU_HANDLE_FREE};
CURSOR _Cursor[MAX_SUPPORT_MENU_HANDLE_NUM];
MENU_DISPLAY _MainMenuDisplay[MAX_SUPPORT_MENU_HANDLE_NUM];
MENU_DISPLAY _SubMenuDisplay[MAX_SUPPORT_MENU_HANDLE_NUM];
BYTE _bMENUBackgroundColor[MAX_SUPPORT_MENU_HANDLE_NUM];

WORD aMENUUpArrowSymbol[] = {1, CHAR_N_UP_16};
WORD aMENUDownArrowSymbol[] = {1, CHAR_N_DWN_16};
WORD aMENUCheckSymbol[] = {1, CHAR_N_CHECK};
WORD aMENUSubMenuSymbol[] = {1, CHAR_N_SUBMENU};

WORD __wMENUStringBuf[OSDUTL_STRING_LENGTH+1];
BYTE *_bMENUExitKey[MAX_SUPPORT_MENU_HANDLE_NUM];
//***************************************************************************
//  Function    :   _MENU_InitializeGDI
//  Abstract    :   Initialize the palette, etc.
//  Arguments   :   none.
//  Return      :   none.
//  Side Effect :   none.
//  Notes       :   
//***************************************************************************
void _MENU_InitializeGDI(void)
{
    GDI_ChangePALEntry(MENU_PALETTE_ENTRY_GENERAL_BACKGROUND, MENU_PALETTE_COLOR_GENERAL_BACKGROUND, FALSE);
    GDI_ChangePALEntry(MENU_PALETTE_ENTRY_NORMAL_FRAME_BRIGHT, MENU_PALETTE_COLOR_NORMAL_FRAME_BRIGHT, FALSE);
    GDI_ChangePALEntry(MENU_PALETTE_ENTRY_NORMAL_FRAME_DARK, MENU_PALETTE_COLOR_NORMAL_FRAME_DARK, FALSE);
    GDI_ChangePALEntry(MENU_PALETTE_ENTRY_NORMAL_FRAME_CENTER, MENU_PALETTE_COLOR_NORMAL_FRAME_CENTER, FALSE);
    GDI_ChangePALEntry(MENU_PALETTE_ENTRY_HIGHLIGHT, MENU_PALETTE_COLOR_HIGHLIGHT, FALSE);
    GDI_ChangePALEntry(MENU_PALETTE_ENTRY_ITEM_TEXT, MENU_PALETTE_COLOR_ITEM_TEXT, FALSE);
    GDI_ChangePALEntry(MENU_PALETTE_ENTRY_CURSOR_GRAYED, MENU_PALETTE_COLOR_CURSOR_GRAYED, FALSE);
    GDI_ChangePALEntry(MENU_PALETTE_ENTRY_ITEM_GRAYED, MENU_PALETTE_COLOR_ITEM_GRAYED, FALSE);

    GDI_WaitPaletteComplete();
}

HMENU MENU_CreateMenu(MENU *pMenu, BYTE bMaxVisibleItem, BYTE *bExitKey)
{
    HMENU hMenu;

    hMenu = _MENU_GetMenuHandle();

    if (hMenu != MENU_HANDLE_INVALID)
    {
        _pMENUCurrentMenu[hMenu] = pMenu;
        _pMENUSubMenu[hMenu] = (PMENU)(pMenu->pMenuItem[pMenu->bDefaultCursorPos].pSubMenu);

        //Set the cursor's position
        _Cursor[hMenu].bMainMenuIndex = _pMENUCurrentMenu[hMenu]->bDefaultCursorPos;
        _Cursor[hMenu].bPos = MENU_MAIN_MENU;

        if (_pMENUSubMenu[hMenu] == NULL)
        {
            _Cursor[hMenu].bSubMenuIndex = CURSOR_POS_INVALID;
        }
        else
        {
            _Cursor[hMenu].bSubMenuIndex = _pMENUSubMenu[hMenu]->bDefaultCursorPos;
        }

        //Set the menu display attribute
        _MainMenuDisplay[hMenu].bMaxVisibleItem = bMaxVisibleItem;
        _SubMenuDisplay[hMenu].bMaxVisibleItem = bMaxVisibleItem;

        //Main menu has "Up" mark?
        _MENU_SetMainMenuInitialDisplay(hMenu);

        if (_pMENUSubMenu[hMenu] != NULL)
        {
            //Sub-menu has "Up" mark?
            _MENU_SetSubMenuInitialDisplay(hMenu);
        }

		_bMENUExitKey[hMenu] = bExitKey;
    }
    
    return hMenu;
}

void MENU_ShowMenu(HMENU hMenu, BYTE bActive, BYTE bMenuBackgroundColor)
{   
    _MENU_InitializeGDI();

    _bMENUBackgroundColor[hMenu] = bMenuBackgroundColor;

    //draw main-menu
    _MENU_ShowMainMenu(hMenu);
    
    if (bActive)
    {
        MENU_SetMenuState(hMenu, TRUE);
    }
}

void MENU_SetMenuState(HMENU hMenu, BYTE bActive)
{
    if (MENU_AllDisableItems(hMenu))
        return;

    if (bActive)
    {
        if (_MENU_CheckMainMenuCursorState(hMenu) == TRUE)
        {
            //draw sub-menu
            _MENU_ShowSubMenu(hMenu);
        }
        
        //Update the cursor
        MENU_UpdateCursor(hMenu, CURSOR_STYLE_NORMAL); 
    }
    else    
    {
        //Clear current sub-menu.
        MENU_ClearMenuBackground(MENU_SUB_MENU, hMenu);

        //Update the cursor
        MENU_UpdateCursor(hMenu, CURSOR_STYLE_CLEAR); 
    }
}

void MENU_SetMenuItemState(HMENU hMenu, BYTE bMenuIndex, BYTE bEnable)
{
    PARM_DRAW_STRING MENUStringAttr;
    PARM_RECT MENURect;

    _MENU_GetMainMenuDisplayRect(hMenu, &MENURect);

    _pMENUCurrentMenu[hMenu]->pMenuItem[bMenuIndex].bAttribute = bEnable;

    if (bMenuIndex < _MainMenuDisplay[hMenu].bStartDrawItem)
    {
        return;
    }
    else if ((bMenuIndex-_MainMenuDisplay[hMenu].bStartDrawItem) >= (_SubMenuDisplay[hMenu].bStartDrawItem+_MainMenuDisplay[hMenu].bMaxVisibleItem))
    {
        return;  
    }

    //re-draw the menu.
    MENUStringAttr.bBackground = MENU_PALETTE_ENTRY_GENERAL_BACKGROUND; //PAL_ENTRY_COLOR_TRANSPARENT; //Set the color of background is the same as color key.
    MENUStringAttr.bColorKey = 0;
    MENUStringAttr.bShadow1 = PAL_ENTRY_COLOR_TRANSPARENT;
    MENUStringAttr.bShadow2 = PAL_ENTRY_COLOR_TRANSPARENT;

    MENUStringAttr.wX = _pMENUCurrentMenu[hMenu]->wStartX+MENU_STRING_DISTANCE_H;
    MENUStringAttr.wY = _pMENUCurrentMenu[hMenu]->wStartY + MENU_STRING_DISTANCE_V+(bMenuIndex-_MainMenuDisplay[hMenu].bStartDrawItem)*MENU_ITEM_HEIGHT;

    if (bEnable == MENU_ITEM_STATE_DISABLE)
    {
        //Set the color of the string to be disabled color
        MENUStringAttr.bTextColor = MENU_PALETTE_ENTRY_ITEM_GRAYED;
    }
    else
    {
        //Set the color of the string to be enabled color
        MENUStringAttr.bTextColor = MENU_PALETTE_ENTRY_ITEM_TEXT;
    }

    GDI_DrawString_909(0, &MENUStringAttr, _pMENUCurrentMenu[hMenu]->pMenuItem[bMenuIndex].pwItemText);

    if (_pMENUCurrentMenu[hMenu]->pMenuItem[bMenuIndex].pSubMenu != NULL)
    {
        MENUStringAttr.wX = MENURect.rect.wRight-MENU_STRING_DISTANCE_H-GDI_GetStringWidth_909(aMENUSubMenuSymbol);
        MENUStringAttr.wY = _pMENUCurrentMenu[hMenu]->wStartY+MENU_STRING_DISTANCE_V+(bMenuIndex-_MainMenuDisplay[hMenu].bStartDrawItem)*MENU_ITEM_HEIGHT+((MENU_ITEM_HEIGHT-GDI_GetStringHeight(aMENUSubMenuSymbol)) >> 1);
        GDI_DrawString_909(0, &MENUStringAttr, aMENUSubMenuSymbol);
    }
}

//***************************************************************************
//  Function    :   MENU_Processkey
//  Abstract    :   
//  Arguments   :   none.
//  Return      :   
//  Side Effect :   none.
//  Notes       :   
//***************************************************************************
DWORD MENU_ProcessKey(HMENU hMenu, BYTE bKey)
{
    BYTE bCount;
	BYTE bExitIndex;

    if (_pMENUCurrentMenu[hMenu] == NULL)
        return MENU_ACTION_NONE;

	if (_bMENUExitKey[hMenu] != NULL)
	{
        if (_Cursor[hMenu].bPos == MENU_MAIN_MENU)
		{
			for (bExitIndex = 0; bExitIndex < sizeof(_bMENUExitKey[hMenu])/sizeof(BYTE); bExitIndex++)
			{
				if (bKey == _bMENUExitKey[hMenu][bExitIndex])
				{
					if ((bKey != KEY_UP) && (bKey != KEY_DOWN) && (bKey != KEY_RIGHT))
					{
						MENU_SetMenuState(hMenu, FALSE);
						return (((DWORD)MENU_ACTION_EXIT) << 16);
					}
#ifndef SETUP_KEY_UP_DOWN_TOGGLE_OPTIONS
					else if ((bKey == KEY_UP) && (_Cursor[hMenu].bMainMenuIndex == 0))
					{
						MENU_SetMenuState(hMenu, FALSE);
						return (((DWORD)MENU_ACTION_EXIT) << 16);
					}
#endif //SETUP_KEY_UP_DOWN_TOGGLE_OPTIONS
				}
			}
		}
	}

    //Return the ID of the menu item. The control flow can do the exact action according to the ID.
    switch (bKey)
    {
    case KEY_LEFT:
		/*
#ifndef NO_TOOLBAR_SETUP_MENU		
        if (_Cursor[hMenu].bPos == MENU_MAIN_MENU)
        {
            MENU_SetMenuState(hMenu, FALSE);
            return (((DWORD)MENU_ACTION_EXIT) << 16);
        }
        else if (_Cursor[hMenu].bPos == MENU_SUB_MENU)
        {
            //return to the main menu
            MENU_UpdateCursor(hMenu, CURSOR_STYLE_CLEAR);              
            _Cursor[hMenu].bPos = MENU_MAIN_MENU;
            MENU_UpdateCursor(hMenu, CURSOR_STYLE_NORMAL);              
        }
#else //NO_TOOLBAR_SETUP_MENU
        if (_Cursor[hMenu].bPos == MENU_SUB_MENU)
        {
            //return to the main menu
            MENU_UpdateCursor(hMenu, CURSOR_STYLE_CLEAR);              
            _Cursor[hMenu].bPos = MENU_MAIN_MENU;
            MENU_UpdateCursor(hMenu, CURSOR_STYLE_NORMAL);              
        }
#endif //NO_TOOLBAR_SETUP_MENU
		*/

        if (_Cursor[hMenu].bPos == MENU_SUB_MENU)
        {
            //return to the main menu
            MENU_UpdateCursor(hMenu, CURSOR_STYLE_CLEAR);              
            _Cursor[hMenu].bPos = MENU_MAIN_MENU;
            MENU_UpdateCursor(hMenu, CURSOR_STYLE_NORMAL);              
        }
        break;
    case KEY_RIGHT:
        if (_Cursor[hMenu].bPos == MENU_MAIN_MENU)
        {
            if (_pMENUSubMenu[hMenu] != NULL)
            {
				if ((_pMENUSubMenu[hMenu]->bTotalItem != 0) && (!_MENU_AllDisableSubItems(hMenu))) //to prevent go to a "no item" sub-menu.
				{
					MENU_UpdateCursor(hMenu, CURSOR_STYLE_GRAYED);                
					
					//update the cursor to the sub-menu
					_Cursor[hMenu].bPos = MENU_SUB_MENU;
					MENU_UpdateCursor(hMenu, CURSOR_STYLE_NORMAL); 
				}
            }
        }
        break;        
    case KEY_UP:
        if (_Cursor[hMenu].bPos == MENU_MAIN_MENU)
        {
            if (_Cursor[hMenu].bMainMenuIndex == 0)
            {
#ifndef SETUP_KEY_UP_DOWN_TOGGLE_OPTIONS
                return MENU_ACTION_EXCEED_UP_MAIN_MENU;
#else

                _MENU_GoToMainMenuItem(hMenu, MENU_LAST_ITEM);
                return MENU_ACTION_UP_MAIN_MENU;

#endif //SETUP_KEY_UP_DOWN_TOGGLE_OPTIONS
            }
            else
            {
                //Check if there is any enabled items for "up" action.
                bCount = _MENU_GetCountForUpItem(_pMENUCurrentMenu[hMenu], _Cursor[hMenu].bMainMenuIndex);
                if (bCount == 0)
                {
#ifndef SETUP_KEY_UP_DOWN_TOGGLE_OPTIONS
                    return MENU_ACTION_EXCEED_UP_MAIN_MENU;
#else
                    _MENU_GoToMainMenuItem(hMenu, MENU_LAST_ITEM);
                    return MENU_ACTION_UP_MAIN_MENU;
#endif //SETUP_KEY_UP_DOWN_TOGGLE_OPTIONS
                }                
             
                //Clear current sub-menu.
                MENU_ClearMenuBackground(MENU_SUB_MENU, hMenu);
                
                //if ((_Cursor[hMenu].bMainMenuIndex-1) < _MainMenuDisplay[hMenu].bStartDrawItem)
                if ((_Cursor[hMenu].bMainMenuIndex-bCount) < _MainMenuDisplay[hMenu].bStartDrawItem)
                {                               
                    //scroll up
                    _Cursor[hMenu].bMainMenuIndex -= bCount;

                    if (_MainMenuDisplay[hMenu].bStartDrawItem >= bCount)
                    {
                        _MainMenuDisplay[hMenu].bStartDrawItem -= bCount;
                    }
                    else
                    {
                        _MainMenuDisplay[hMenu].bStartDrawItem = 0;
                    }
                    
                    //Note: Must clear the "up" region before re-draw the sub menu.
                    if (_MainMenuDisplay[hMenu].bStartDrawItem == 0)
                    {
                        //Clear "Up" mark
                        _MENU_ClearUpDownArrowBackground(MENU_MAIN_MENU, hMenu, MENU_ARROW_TYPE_UP);
                        _MainMenuDisplay[hMenu].bUpMark = FALSE;
                    }
                    
                    if ((_MainMenuDisplay[hMenu].bStartDrawItem+_MainMenuDisplay[hMenu].bMaxVisibleItem) < _pMENUCurrentMenu[hMenu]->bTotalItem)
                    {
                        _MainMenuDisplay[hMenu].bDownMark = TRUE;
                    }
                    
                    _MENU_ShowMainMenu(hMenu);
                }
                else
                {
                    //Update the cursor
                    MENU_UpdateCursor(hMenu, CURSOR_STYLE_CLEAR);                
                    _Cursor[hMenu].bMainMenuIndex -= bCount;
                }

                MENU_UpdateCursor(hMenu, CURSOR_STYLE_NORMAL);

                _pMENUSubMenu[hMenu] = _pMENUCurrentMenu[hMenu]->pMenuItem[_Cursor[hMenu].bMainMenuIndex].pSubMenu;                
                //Show sub-menu
                if ((_pMENUSubMenu[hMenu] != NULL) && (_pMENUSubMenu[hMenu]->bTotalItem != 0))
                {
                    _pMENUSubMenu[hMenu] = (PMENU)(_pMENUCurrentMenu[hMenu]->pMenuItem[_Cursor[hMenu].bMainMenuIndex].pSubMenu);
                    _MENU_SetSubMenuInitialDisplay(hMenu);
                    _Cursor[hMenu].bSubMenuIndex = _pMENUSubMenu[hMenu]->bDefaultCursorPos;
                    _MENU_ShowSubMenu(hMenu);
                }

                return MENU_ACTION_UP_MAIN_MENU;
            }
        }
        else if (_Cursor[hMenu].bPos == MENU_SUB_MENU)
        {
            if (_Cursor[hMenu].bSubMenuIndex == 0)
            {
#ifndef SETUP_KEY_UP_DOWN_TOGGLE_OPTIONS
                return MENU_ACTION_EXCEED_UP_SUB_MENU;
#else
                _MENU_GoToSubMenuItem(hMenu, MENU_LAST_ITEM);
                return MENU_ACTION_UP_SUB_MENU;

#endif //SETUP_KEY_UP_DOWN_TOGGLE_OPTIONS
            }
            else
            {
                bCount = _MENU_GetCountForUpItem(_pMENUSubMenu[hMenu], _Cursor[hMenu].bSubMenuIndex);
                if (bCount == 0)
                {
#ifndef SETUP_KEY_UP_DOWN_TOGGLE_OPTIONS
                    return MENU_ACTION_EXCEED_UP_SUB_MENU;
#else
                    _MENU_GoToSubMenuItem(hMenu, MENU_LAST_ITEM);
                    return MENU_ACTION_UP_SUB_MENU;
#endif //SETUP_KEY_UP_DOWN_TOGGLE_OPTIONS
                }             
                
                if ((_Cursor[hMenu].bSubMenuIndex-bCount) < _SubMenuDisplay[hMenu].bStartDrawItem)
                {
                    //scroll up
                    _Cursor[hMenu].bSubMenuIndex -= bCount;

                    if (_SubMenuDisplay[hMenu].bStartDrawItem >= bCount)
                    {
                        _SubMenuDisplay[hMenu].bStartDrawItem -= bCount;
                    }
                    else
                    {
                        _SubMenuDisplay[hMenu].bStartDrawItem = 0;
                    }

                    //Note: Must clear the "up" region before re-draw the sub menu.
                    if (_SubMenuDisplay[hMenu].bStartDrawItem == 0)
                    {
                        //Clear "Up" mark
                        _MENU_ClearUpDownArrowBackground(MENU_SUB_MENU, hMenu, MENU_ARROW_TYPE_UP);
                        _SubMenuDisplay[hMenu].bUpMark = FALSE;
                    }

                    if ((_SubMenuDisplay[hMenu].bStartDrawItem+_SubMenuDisplay[hMenu].bMaxVisibleItem) < _pMENUSubMenu[hMenu]->bTotalItem)
                    {
                        _SubMenuDisplay[hMenu].bDownMark = TRUE;
                    }

                    _MENU_ShowSubMenu(hMenu);
                }
                else
                {    
                    //Update the cursor
                    MENU_UpdateCursor(hMenu, CURSOR_STYLE_CLEAR);
                    _Cursor[hMenu].bSubMenuIndex -= bCount;                    
                }

                MENU_UpdateCursor(hMenu, CURSOR_STYLE_NORMAL);

                return MENU_ACTION_UP_SUB_MENU;
            }
        }
        break;
    case KEY_DOWN:
        if (_Cursor[hMenu].bPos == MENU_MAIN_MENU)
        {
            if (_Cursor[hMenu].bMainMenuIndex == (_pMENUCurrentMenu[hMenu]->bTotalItem-1))
            {
#ifndef SETUP_KEY_UP_DOWN_TOGGLE_OPTIONS
                return MENU_ACTION_EXCEED_DOWN_MAIN_MENU;
#else

                _MENU_GoToMainMenuItem(hMenu, MENU_FIRST_ITEM);
                return MENU_ACTION_UP_MAIN_MENU;