menu.c

ct952 source code use for Digital Frame Photo

#endif //SETUP_KEY_UP_DOWN_TOGGLE_OPTIONS
            }
            else
            {
                //Check if there is any enabled items for "Down" action.
                bCount = _MENU_GetCountForDownItem(_pMENUCurrentMenu[hMenu], _Cursor[hMenu].bMainMenuIndex);
                if (bCount == 0)
                {
#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;
#endif //SETUP_KEY_UP_DOWN_TOGGLE_OPTIONS
                    
                }                

                //Clear current sub-menu.
                MENU_ClearMenuBackground(MENU_SUB_MENU, hMenu);

                //if ((_Cursor[hMenu].bMainMenuIndex-_MainMenuDisplay[hMenu].bStartDrawItem+1) >= _MainMenuDisplay[hMenu].bMaxVisibleItem)
                if ((_Cursor[hMenu].bMainMenuIndex-_MainMenuDisplay[hMenu].bStartDrawItem+bCount) >= _MainMenuDisplay[hMenu].bMaxVisibleItem)
                {
                    //scroll down
                    _Cursor[hMenu].bMainMenuIndex += bCount;
                    //_MainMenuDisplay[hMenu].bStartDrawItem += bCount;
                    _MainMenuDisplay[hMenu].bStartDrawItem = _Cursor[hMenu].bMainMenuIndex-_MainMenuDisplay[hMenu].bMaxVisibleItem+1;
                    _MainMenuDisplay[hMenu].bDownMark = TRUE;
                    
                    //Note: Must clear the "Down" region before re-draw the sub menu.
                    if ((_MainMenuDisplay[hMenu].bStartDrawItem+_MainMenuDisplay[hMenu].bMaxVisibleItem) == _pMENUCurrentMenu[hMenu]->bTotalItem)
                    {
                        //Clear "Down" mark
                        _MENU_ClearUpDownArrowBackground(MENU_MAIN_MENU, hMenu, MENU_ARROW_TYPE_DOWN);
                        _MainMenuDisplay[hMenu].bDownMark = FALSE;
                    }
                    
                    if (_MainMenuDisplay[hMenu].bStartDrawItem != 0)
                    {
                        _MainMenuDisplay[hMenu].bUpMark = 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_DOWN_MAIN_MENU;
            }
        }
        else if (_Cursor[hMenu].bPos == MENU_SUB_MENU)
        {
            if (_Cursor[hMenu].bSubMenuIndex == (_pMENUSubMenu[hMenu]->bTotalItem-1))
            {
#ifndef SETUP_KEY_UP_DOWN_TOGGLE_OPTIONS
                return MENU_ACTION_EXCEED_DOWN_SUB_MENU;
#else
                _MENU_GoToSubMenuItem(hMenu, MENU_FIRST_ITEM);
                return MENU_ACTION_DOWN_SUB_MENU;
#endif //SETUP_KEY_UP_DOWN_TOGGLE_OPTIONS
            }
            else
            {
                bCount = _MENU_GetCountForDownItem(_pMENUSubMenu[hMenu], _Cursor[hMenu].bSubMenuIndex);
                if (bCount == 0)
                {
#ifndef SETUP_KEY_UP_DOWN_TOGGLE_OPTIONS
                    return MENU_ACTION_EXCEED_DOWN_SUB_MENU;
#else
                    _MENU_GoToSubMenuItem(hMenu, MENU_FIRST_ITEM);
                    return MENU_ACTION_DOWN_SUB_MENU;
#endif //SETUP_KEY_UP_DOWN_TOGGLE_OPTIONS
                    
                }                

                if ((_Cursor[hMenu].bSubMenuIndex-_SubMenuDisplay[hMenu].bStartDrawItem+bCount) >= _SubMenuDisplay[hMenu].bMaxVisibleItem)
                {
                    //scroll down
                    _Cursor[hMenu].bSubMenuIndex += bCount;
                    _SubMenuDisplay[hMenu].bStartDrawItem++;
                    _SubMenuDisplay[hMenu].bDownMark = TRUE;
                    
                    //Note: Must clear the "Down" region before re-draw the sub menu.
                    if ((_SubMenuDisplay[hMenu].bStartDrawItem+_SubMenuDisplay[hMenu].bMaxVisibleItem) == _pMENUSubMenu[hMenu]->bTotalItem)
                    {
                        //Clear "Down" mark
                        _MENU_ClearUpDownArrowBackground(MENU_SUB_MENU, hMenu, MENU_ARROW_TYPE_DOWN);
                        _SubMenuDisplay[hMenu].bDownMark = FALSE;
                    }

                    if (_SubMenuDisplay[hMenu].bStartDrawItem != 0)
                    {
                        _SubMenuDisplay[hMenu].bUpMark = 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_DOWN_SUB_MENU;
            }
        }
        break;
    case KEY_PLAY:
    case KEY_ENTER:
        if (_Cursor[hMenu].bPos == MENU_MAIN_MENU)
        {
            if (_pMENUSubMenu[hMenu] != NULL)
            {
				if (_pMENUSubMenu[hMenu]->bTotalItem != 0) //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);
				}
            }
            else
            {
                //return the ID to do exact action.
                return ((((DWORD)MENU_ACTION_PROCESS_MENU_ITEM) << 16) | _pMENUCurrentMenu[hMenu]->pMenuItem[_Cursor[hMenu].bMainMenuIndex].bID);
            }
        }
        else if (_Cursor[hMenu].bPos == MENU_SUB_MENU)
        {
            if (_pMENUSubMenu[hMenu]->bCheckMenuItemPos != MENU_ITEM_NO_CHECKED_ITEM) //CoCo2.38
            {
                _pMENUSubMenu[hMenu]->bCheckMenuItemPos = _Cursor[hMenu].bSubMenuIndex;
                _pMENUSubMenu[hMenu]->bDefaultCursorPos = _pMENUSubMenu[hMenu]->bCheckMenuItemPos;
            }
            printf("\n go to menu processkey menu sub menu");
            //Recover the cursor to normal state in the sub-menu and re-draw the check item.
            _MENU_ShowSubMenu(hMenu);

            //Return to main menu
            _Cursor[hMenu].bPos = MENU_MAIN_MENU;
            MENU_UpdateCursor(hMenu, CURSOR_STYLE_NORMAL);                              
            
            if (_pMENUSubMenu[hMenu]->bMenuType == MENU_TYPE_NUM)
            {
                return (MENU_ACTION_PROCESS_NUN_ITEM) | (((DWORD)(_pMENUCurrentMenu[hMenu]->pMenuItem[_Cursor[hMenu].bMainMenuIndex].bID)) << 16) | _Cursor[hMenu].bSubMenuIndex;
            }
            else
            {
                return (((DWORD)MENU_ACTION_PROCESS_MENU_ITEM << 16) | _pMENUSubMenu[hMenu]->pMenuItem[(_Cursor[hMenu].bSubMenuIndex)].bID);                
            }
        }
        break;
    default:
        break;
    }

    return MENU_ACTION_NONE;
}

//***************************************************************************
//  Function    :   MENU_DeleteMenu
//  Abstract    :   
//  Arguments   :   none.
//  Return      :   
//  Side Effect :   none.
//  Notes       :   
//***************************************************************************
void MENU_DeleteMenu(HMENU hMenu, BYTE bClearBackground)
{
    //clear menu
    if (_pMENUCurrentMenu[hMenu] != NULL)
    {
        if (bClearBackground)
        {
            MENU_ClearMenuBackground(MENU_MAIN_MENU, hMenu);
        }
    }

    if (_pMENUSubMenu[hMenu] != NULL)
    {
        if (bClearBackground)
        {
            MENU_ClearMenuBackground(MENU_SUB_MENU, hMenu);
        }
    }

    _pMENUCurrentMenu[hMenu] = NULL;
    _pMENUSubMenu[hMenu] = NULL;
    _hMenuStack[hMenu] = MENU_HANDLE_FREE;
}


HMENU _MENU_GetMenuHandle(void)
{
    BYTE i;
    for (i = 0; i < MAX_SUPPORT_MENU_HANDLE_NUM; i++)
    {
        if (_hMenuStack[i] == MENU_HANDLE_FREE)
        {
            _hMenuStack[i] = i;
            return _hMenuStack[i];
        }
    }

    return MENU_HANDLE_INVALID;
}

WORD _MENU_GetMenuWidth(MENU *pMenu)
{
    BYTE bItemIndex;
    WORD wMaxWidth = 0;
    WORD wStringWidth;

    if (pMenu == NULL)
        return 0;
    
    if (pMenu->wWidth != MENU_WIDTH_OPTIMIZED)
        return pMenu->wWidth;

    for (bItemIndex = 0; bItemIndex < pMenu->bTotalItem; bItemIndex++)
    {        
        if (pMenu->bMenuType == MENU_TYPE_NUM)
        {
            OSDUTL_PrepareOutputString();
            OSDUTL_OutputNumFromIndex(pMenu->wStartNum+bItemIndex);

            wStringWidth = GDI_GetStringWidth_909(__pOSDUTLOutputString);

            if (wMaxWidth < wStringWidth)
                wMaxWidth = wStringWidth;
        }
        else
        {
            wStringWidth = GDI_GetStringWidth_909(pMenu->pMenuItem[bItemIndex].pwItemText);            

            if (wMaxWidth < wStringWidth)
                wMaxWidth = wStringWidth;
        }
    }

    wMaxWidth += MENU_STRING_DISTANCE_H*2;

    if (pMenu->bCheckMenuItemPos != MENU_ITEM_NO_CHECKED_ITEM)
    {
        wMaxWidth += GDI_GetStringWidth_909(aMENUCheckSymbol);
        wMaxWidth += MENU_CHECK_SYMBOL_DISTANCE_H;
    }

    if (_MENU_CheckIfAnyItemHasSubMenu(pMenu))
    {
        wMaxWidth += GDI_GetStringWidth_909(aMENUSubMenuSymbol);
        wMaxWidth += MENU_SUBMENU_SYMBOL_DISTANCE_H;
    }

    return wMaxWidth;
}

WORD _MENU_GetStringStartH(BYTE bMenuMode, HMENU hMenu, WORD *pString)
{
    WORD wStringWidth;
    WORD wMenuWidth;
    MENU *pMenu = NULL;
    WORD wStartH;
    WORD wCheckSymbolWidth = 0;
    WORD wSubMenuSymbolWidth = 0;
    PARM_RECT MENURect;

    if (bMenuMode == MENU_MAIN_MENU)
    {
        pMenu = _pMENUCurrentMenu[hMenu];
        _MENU_GetMainMenuDisplayRect(hMenu, &MENURect);
    }
    else if (bMenuMode == MENU_SUB_MENU)
    {
        pMenu = _pMENUSubMenu[hMenu];
        _MENU_GetSubMenuDisplayRect(hMenu, &MENURect);
    }

    wMenuWidth = _MENU_GetMenuWidth(pMenu);

    wStringWidth = GDI_GetStringWidth_909(pString);

    wStartH = MENURect.rect.wLeft+MENU_STRING_DISTANCE_H;
    if (pMenu->bCheckMenuItemPos != MENU_ITEM_NO_CHECKED_ITEM)
    {
        wCheckSymbolWidth = GDI_GetStringWidth_909(aMENUCheckSymbol) + MENU_CHECK_SYMBOL_DISTANCE_H;
    }

    if (_MENU_CheckIfAnyItemHasSubMenu(pMenu))
    {
        wSubMenuSymbolWidth = GDI_GetStringWidth_909(aMENUSubMenuSymbol)+MENU_SUBMENU_SYMBOL_DISTANCE_H;
    }

    switch (pMenu->bAlignment)
    {
    case MENU_ITEM_ALIGNMENT_CENTER:
        wStartH = wStartH+wCheckSymbolWidth+((wMenuWidth-wCheckSymbolWidth-wSubMenuSymbolWidth-MENU_STRING_DISTANCE_H*2-wStringWidth)>>1);                
        break;
    case MENU_ITEM_ALIGNMENT_RIGHT:
        wStartH = MENURect.rect.wLeft+wMenuWidth-MENU_STRING_DISTANCE_H-wSubMenuSymbolWidth-wStringWidth;
        break;
    case MENU_ITEM_ALIGNMENT_LEFT:
        wStartH += wCheckSymbolWidth;
        break;
    default:
        break;
    }

    return wStartH;
}

void MENU_UpdateCursor(HMENU hMenu, BYTE bCursorStyle)
{
    PARM_RECT MENURect;
    PARM_DRAW_STRING MENUStringAttr;
    MENU *pMenu;
    BYTE bCursorIndex;

    if (_Cursor[hMenu].bPos == MENU_MAIN_MENU)
    {
        pMenu = _pMENUCurrentMenu[hMenu];
        bCursorIndex = _Cursor[hMenu].bMainMenuIndex;
        MENURect.rect.wLeft = pMenu->wStartX;
        MENURect.rect.wTop = pMenu->wStartY+(bCursorIndex-_MainMenuDisplay[hMenu].bStartDrawItem)*MENU_ITEM_HEIGHT+MENU_STRING_DISTANCE_V;
    }
    else if (_Cursor[hMenu].bPos == MENU_SUB_MENU)
    {
        pMenu = _pMENUSubMenu[hMenu];
        bCursorIndex = _Cursor[hMenu].bSubMenuIndex;
        MENURect.rect.wLeft = _MENU_GetSubMenuNormalStartH(hMenu);
        MENURect.rect.wTop = _MENU_GetSubMenuNormalStartV(hMenu)+(bCursorIndex-_SubMenuDisplay[hMenu].bStartDrawItem)*MENU_ITEM_HEIGHT+MENU_STRING_DISTANCE_V;        
    }
    else
        return;

    //Draw the cursor
    if (bCursorStyle == CURSOR_STYLE_NORMAL)
    {
        MENURect.bColor = MENU_PALETTE_ENTRY_HIGHLIGHT;
    }
    else if (bCursorStyle == CURSOR_STYLE_CLEAR)
    {
        MENURect.bColor = MENU_PALETTE_ENTRY_GENERAL_BACKGROUND;
    }
    else if (bCursorStyle == CURSOR_STYLE_GRAYED)
    {
        MENURect.bColor = MENU_PALETTE_ENTRY_CURSOR_GRAYED;
    }

    MENURect.rect.wRight = MENURect.rect.wLeft + _MENU_GetMenuWidth(pMenu) - 1;
    MENURect.rect.wBottom = MENURect.rect.wTop+MENU_ITEM_HEIGHT-1;
     
    GDI_FillRect(0, &MENURect);

    //Draw the menu item string
    MENUStringAttr.bTextColor = MENU_PALETTE_ENTRY_ITEM_TEXT;
    MENUStringAttr.bColorKey = 0;
    MENUStringAttr.bBackground = MENURect.bColor;
     
    if (pMenu->bMenuType == MENU_TYPE_NUM)
    {            
        OSDUTL_PrepareOutputString();
        OSDUTL_OutputNumFromIndex(pMenu->wStartNum+bCursorIndex);
        _MENU_CopyString();
        
        MENUStringAttr.wX = _MENU_GetStringStartH(_Cursor[hMenu].bPos, hMenu, __pOSDUTLOutputString);
        MENUStringAttr.wY = MENURect.rect.wTop+((MENU_ITEM_HEIGHT-GDI_GetStringHeight(__pOSDUTLOutputString)) >> 1);        
        GDI_DrawString_909(0, &MENUStringAttr, __wMENUStringBuf);
    }
    else
    {                        
        MENUStringAttr.wX = _MENU_GetStringStartH(_Cursor[hMenu].bPos, hMenu, pMenu->pMenuItem[bCursorIndex].pwItemText);                
        MENUStringAttr.wY = MENURect.rect.wTop+((MENU_ITEM_HEIGHT-GDI_GetStringHeight(pMenu->pMenuItem[bCursorIndex].pwItemText)) >> 1);
        GDI_DrawString_909(0, &MENUStringAttr, pMenu->pMenuItem[bCursorIndex].pwItemText);
    }

    //Draw Check symbol
    if (_Cursor[hMenu].bPos == MENU_SUB_MENU)
    {
        if (pMenu->bCheckMenuItemPos != MENU_ITEM_NO_CHECKED_ITEM)
        {
            if (bCursorIndex == pMenu->bCheckMenuItemPos)
            {
                MENUStringAttr.wX = MENURect.rect.wLeft + MENU_STRING_DISTANCE_H;
                MENUStringAttr.wY = MENURect.rect.wTop+((MENU_ITEM_HEIGHT-GDI_GetStringHeight(aMENUCheckSymbol)) >> 1);
                GDI_DrawString_909(0, &MENUStringAttr, aMENUCheckSymbol);
            }
        }
    }

    if (_Cursor[hMenu].bPos == MENU_MAIN_MENU)
    {
        if (pMenu->pMenuItem[bCursorIndex].pSubMenu != NULL)
        {
            MENUStringAttr.wX = MENURect.rect.wRight-MENU_STRING_DISTANCE_H-GDI_GetStringWidth_909(aMENUSubMenuSymbol);
            MENUStringAttr.wY = MENURect.rect.wTop+((MENU_ITEM_HEIGHT-GDI_GetStringHeight(aMENUSubMenuSymbol)) >> 1);
           GDI_DrawString_909(0, &MENUStringAttr, aMENUSubMenuSymbol);
        }
    }
}

void _MENU_ShowSubMenu(HMENU hMenu)
{
    BYTE bCount = 0;
    BYTE bMenuIndex;
    PARM_RECT MENURect;
    PARM_DRAW_STRING MENUStringAttr;
    WORD wMenuWidth;
    BYTE bDisplayItemNum;

    if (_pMENUSubMenu[hMenu] != NULL)
    {      
        //CoCo1.13
        if (_pMENUSubMenu[hMenu]->pMenuItem[_Cursor[hMenu].bSubMenuIndex].bAttribute == MENU_ITEM_STATE_DISABLE)
        {
            bCount = _MENU_GetCountForDownItem(_pMENUSubMenu[hMenu], _Cursor[hMenu].bSubMenuIndex);