menu.c

libminigui-1.3.0.tar.gz。 miniGUI的库函数源代码！

                mnuDeleteMenuItem (ptmpmi);
                return phead;
            }

            pmi = pmi->next;
        }
    }

    return phead;
}

int GUIAPI DeleteMenu (HMENU hmnu, int item, UINT flags)
{
    PMENUBAR pmb;
    PMENUITEM pmi;

    pmb = (PMENUBAR) hmnu;

    if (pmb->category != TYPE_HMENU)
        return ERR_INVALID_HANDLE;
    
    if (pmb->type == TYPE_MENUBAR)
        pmb->head = mnuDeleteMenu (pmb->head, item, 
            flags & MF_BYPOSITION);
    else if (pmb->type == TYPE_PPPMENU) {
        pmi = (PMENUITEM) hmnu;
        pmi->submenu = mnuDeleteMenu (pmi->submenu, item, 
            flags & MF_BYPOSITION);
    }
    else
        return ERR_INVALID_HMENU;   // this is a normal menu item. 

    return 0;
}

int GUIAPI DestroyMenu (HMENU hmnu)
{
    PMENUBAR pmb;
    PMENUITEM pmi, ptmpmi;

    pmb = (PMENUBAR) hmnu;

    if (pmb->category != TYPE_HMENU)
        return ERR_INVALID_HANDLE;
    
    if (pmb->type == TYPE_MENUBAR) {
        pmi = pmb->head;
        while (pmi) {
            ptmpmi = pmi->next;
            mnuDeleteMenuItem (pmi);
            pmi = ptmpmi;
        }

        FreeMenuBar (pmb);
    }
    else
        mnuDeleteMenuItem ((PMENUITEM)hmnu);

    return 0;
}

int GUIAPI IsMenu (HMENU hmnu)
{
    PMENUBAR pMenu = (PMENUBAR)hmnu;

    if (pMenu->category != TYPE_HMENU) return 0;

    return pMenu->type;
}

/*************************** Menu properties support *************************/
int GUIAPI GetMenuItemCount (HMENU hmnu)
{
    PMENUBAR pmb;
    PMENUITEM pmi;
    int count;

    pmb = (PMENUBAR) hmnu;

    if (pmb->category != TYPE_HMENU)
        return ERR_INVALID_HANDLE;
    
    if (pmb->type == TYPE_MENUBAR)
        pmi = pmb->head;
    else if (pmb->type == TYPE_PPPMENU) {
        pmi = (PMENUITEM) hmnu;
        pmi = pmi->submenu;
    }
    else
        pmi = (PMENUITEM) hmnu;
    
    count = 0;
    while (pmi) {
        count ++;
        pmi = pmi->next;
    }
    
    return count;
}

static PMENUITEM mnuGetMenuItem (HMENU hmnu, int item, BOOL flag)
{
    PMENUBAR pmb;
    PMENUITEM pmi;
    int index;

    pmb = (PMENUBAR) hmnu;

    if (pmb->category != TYPE_HMENU)
        return NULL; 
    
    if (pmb->type == TYPE_MENUBAR)
        pmi = pmb->head;
    else if (pmb->type == TYPE_PPPMENU) {
        pmi = (PMENUITEM) hmnu;
        pmi = pmi->submenu;
    }
    else
        pmi = (PMENUITEM) hmnu;

    if (flag) {
        index = 0;
        while (pmi) {
            if (index == item)
                return pmi;

            index ++;
            pmi = pmi->next;
        }
    }
    else {
        while (pmi) {
            if (pmi->id == item)
                return pmi;

            pmi = pmi->next;
        }
    }

    return NULL; 
}

int GUIAPI GetMenuItemID (HMENU hmnu, int pos)
{
    PMENUBAR pmb;
    PMENUITEM pmi;
    int index;

    pmb = (PMENUBAR) hmnu;

    if (pmb->category != TYPE_HMENU)
        return ERR_INVALID_HANDLE;
    
    if (pmb->type == TYPE_MENUBAR)
        pmi = pmb->head;
    else if (pmb->type == TYPE_PPPMENU) {
        pmi = (PMENUITEM) hmnu;
        pmi = pmi->submenu;
    }
    else
        pmi = (PMENUITEM) hmnu;
    
    index = 0;
    while (pmi) {

        if (index == pos)
            return pmi->id;

        index ++;
        pmi = pmi->next;
    }
    
    return ERR_INVALID_POS;
}

HMENU GUIAPI GetPopupSubMenu (HMENU hpppmnu)
{
    PMENUITEM pmi;

    pmi = (PMENUITEM) hpppmnu;

    if (pmi->category != TYPE_HMENU)
        return 0;
    
    if (pmi->type != TYPE_PPPMENU)
        return 0;

    return (HMENU)(pmi->submenu);
}

HMENU GUIAPI StripPopupHead (HMENU hpppmnu)
{
    PMENUITEM pmi;
    HMENU hsubmenu;

    pmi = (PMENUITEM) hpppmnu;

    if (pmi->category != TYPE_HMENU)
        return 0;
    
    if (pmi->type != TYPE_PPPMENU)
        return 0;

    hsubmenu = (HMENU)(pmi->submenu);

    if (pmi->mnutype == MFT_STRING || pmi->mnutype == MFT_BMPSTRING)
        FreeFixStr ((void*)pmi->typedata);
    FreeMenuItem (pmi);

    return hsubmenu;
}

HMENU GUIAPI GetSubMenu (HMENU hmnu, int pos)
{
    PMENUBAR pmb;
    PMENUITEM pmi;
    int index;

    pmb = (PMENUBAR) hmnu;

    if (pmb->category != TYPE_HMENU)
        return 0;
    
    if (pmb->type == TYPE_MENUBAR)
        pmi = pmb->head;
    else if (pmb->type == TYPE_PPPMENU) {
        pmi = (PMENUITEM) hmnu;
        pmi = pmi->submenu;
    }
    else
        return 0;   // this is a normal menu item. 
    
    index = 0;
    while (pmi) {

        if (index == pos)
            return (HMENU)(pmi->submenu);

        index ++;
        pmi = pmi->next;
    }
    
    return 0;
}

int GUIAPI GetMenuItemInfo (HMENU hmnu, int item, 
                            BOOL flag, PMENUITEMINFO pmii)
{
    PMENUITEM pmi;

    if (!(pmi = mnuGetMenuItem (hmnu, item, flag))) return ERR_INVALID_HMENU;

    if (pmii->mask & MIIM_CHECKMARKS) {
        pmii->hbmpChecked   = pmi->hbmpChecked;
        pmii->hbmpUnchecked = pmi->hbmpUnchecked;
    }

    if (pmii->mask & MIIM_DATA) {
        pmii->itemdata      = pmi->itemdata;
    }

    if (pmii->mask & MIIM_ID) {
        pmii->id            = pmi->id;
    }

    if (pmii->mask & MIIM_STATE) {
        pmii->state         = pmi->mnustate;
    }

    if (pmii->mask & MIIM_SUBMENU) {
        pmii->hsubmenu      = (HMENU)(pmi->submenu);
    }

    if (pmii->mask & MIIM_TYPE) {
        pmii->type          = pmi->mnutype;
        if (pmii->type == MFT_STRING)
            strncpy ((char*)(pmii->typedata), (char*)(pmi->typedata), 
                pmii->cch);
        else
            pmii->typedata  = pmi->typedata;
    }

    return 0;
}

int GUIAPI SetMenuItemInfo (HMENU hmnu, int item, 
                            BOOL flag, PMENUITEMINFO pmii)
{
    PMENUITEM pmi;

    if (!(pmi = mnuGetMenuItem (hmnu, item, flag))) return ERR_INVALID_HMENU;

    if (pmii->mask & MIIM_CHECKMARKS) {
        pmi->hbmpChecked   = pmii->hbmpChecked;
        pmi->hbmpUnchecked = pmii->hbmpUnchecked;
    }

    if (pmii->mask & MIIM_DATA) {
        pmi->itemdata      = pmii->itemdata;
    }

    if (pmii->mask & MIIM_ID) {
        pmi->id            = pmii->id;
    }

    if (pmii->mask & MIIM_STATE) {
        pmi->mnustate         = pmii->state;
    }

    if (pmii->mask & MIIM_SUBMENU) {
        pmi->submenu      = (PMENUITEM)(pmii->hsubmenu);
    }

    if (pmii->mask & MIIM_TYPE) {

        if (pmi->mnutype == MFT_STRING || pmi->mnutype == MFT_BMPSTRING)
            FreeFixStr ((char*) pmi->typedata);
        
        pmi->mnutype          = pmii->type;
        if (pmi->mnutype == MFT_STRING || pmi->mnutype == MFT_BMPSTRING) {
            int len = strlen ((char*)pmii->typedata);
            pmi->typedata = (DWORD)FixStrAlloc (len);
            if (len > 0)
                strcpy ((char*)pmi->typedata, (char*)pmii->typedata);
        }
        else
            pmi->typedata = pmii->typedata;
    }

    return 0;
}

UINT GUIAPI EnableMenuItem (HMENU hmnu, int item, UINT flags)
{
    PMENUITEM pmi;
    UINT prevstate = 0xFFFFFFFF; 

    if (!(pmi = mnuGetMenuItem (hmnu, item, flags & MF_BYPOSITION)))
        return prevstate;

    prevstate = 0x0000000F & pmi->mnustate;

    pmi->mnustate = (0xFFFFFFF0 & pmi->mnustate) | flags;

    return prevstate;
}

int GUIAPI CheckMenuRadioItem (HMENU hmnu, int first, int last, 
                            int checkitem, UINT flags)
{
    PMENUITEM pmi;
    int index;

    if (!(pmi = mnuGetMenuItem (hmnu, first, flags & MF_BYPOSITION)))
        return ERR_INVALID_HMENU;

    index = first;
    if (flags & MF_BYPOSITION) {
        while (pmi) {
            pmi->mnutype |= MFT_RADIOCHECK;

            if (index == checkitem)
                pmi->mnustate = (0xFFFFFFF0 & pmi->mnustate) | MFS_CHECKED;
            else
                pmi->mnustate = (0xFFFFFFF0 & pmi->mnustate) | MFS_UNCHECKED;
            
            if (index == last)
                break;

            index ++;
            pmi = pmi->next;
        }
    }
    else {
        while (pmi) {
            pmi->mnutype |= MFT_RADIOCHECK;
        
            if (pmi->id == checkitem)
                pmi->mnustate = (0xFFFFFFF0 & pmi->mnustate) | MFS_CHECKED;
            else
                pmi->mnustate = (0xFFFFFFF0 & pmi->mnustate) | MFS_UNCHECKED;
            
            if (pmi->id == last)
                break;

            pmi = pmi->next;
        }
    }

    return 0;
}

int GUIAPI SetMenuItemBitmaps (HMENU hmnu, int item, UINT flags, 
                            PBITMAP hBmpUnchecked, PBITMAP hBmpChecked)
{
    PMENUITEM pmi;

    if (!(pmi = mnuGetMenuItem (hmnu, item, flags & MF_BYPOSITION)))
        return ERR_INVALID_HMENU;

    pmi->hbmpChecked = hBmpChecked;
    pmi->hbmpUnchecked = hBmpUnchecked;

    return 0;
}

#ifdef _DEBUG

void mnuDumpMenuItem (PMENUITEM pmi)
{
    PMENUITEM ptmpmi;
    
    printf ("Menu Item (0x%p) Information:\n", pmi);

    printf ("\tdata category:      %d\n", pmi->category);
    printf ("\tdata type:       %d\n", pmi->type);
    printf ("\tmenu type:       %#x\n", pmi->mnutype);
    printf ("\tmenu state:      %#x\n", pmi->mnustate);
    printf ("\tmenu id:         %d\n", pmi->id);
    printf ("\tchecked bitmap:  0x%p\n", pmi->hbmpChecked);
    printf ("\tunchecked bitmap: 0x%p\n", pmi->hbmpUnchecked);
    printf ("\titem data:       %lu\n", pmi->itemdata);
    if (pmi->mnutype == MFT_STRING)
        printf ("\tstring:         %s\n", (char*)pmi->typedata);
    else
        printf ("\ttype data:      %lu\n", pmi->typedata);
    printf ("\tnext item:       0x%p\n", pmi->next);
    
    if (pmi->submenu) {
        ptmpmi = pmi->submenu;
        while (ptmpmi) {
            mnuDumpMenuItem (ptmpmi);
            ptmpmi = ptmpmi->next;
        }
    }

    printf ("End of Info of Menu Item: 0x%p\n", pmi);
}

void DumpMenu (HMENU hmnu)
{
    PMENUBAR pmb;
    PMENUITEM pmi;

    pmb = (PMENUBAR) hmnu;
    if (pmb->category != TYPE_HMENU) {
        printf ("hmnu is not a valid menu handle.\n");
        return;
    }
    
    if (pmb->type == TYPE_MENUBAR) {
        printf ("hmnu is a menu bar.\n");
        
        pmi = pmb->head;
        while (pmi) {
            mnuDumpMenuItem (pmi);
            pmi = pmi->next;
        }
    }
    else if (pmb->type == TYPE_PPPMENU) {
        printf ("hmnu is a popup menu.\n");
        pmi = (PMENUITEM)hmnu;
        mnuDumpMenuItem (pmi);
    }
    else {
        printf ("hmnu is a normal menu item.\n");
        pmi = (PMENUITEM)hmnu;
        mnuDumpMenuItem (pmi);
    }
}
#endif  // _DEBUG

/***************************** Menu owner ***********************************/
// Global function defined in Desktop module.

HMENU GUIAPI SetMenu (HWND hwnd, HMENU hmnu)
{
    PMAINWIN pWin;
    HMENU hOld;

    if (!(pWin = CheckAndGetMainWindowPtr (hwnd))) return 0;

    hOld = pWin->hMenu;
    pWin->hMenu = hmnu;

    ((PMENUBAR)hmnu)->hwnd = hwnd;

    return hOld;
}

HMENU GUIAPI GetMenu (HWND hwnd)
{
    PMAINWIN pWin;

    if (!(pWin = CheckAndGetMainWindowPtr (hwnd))) return 0;

    return pWin->hMenu;
}

HMENU GUIAPI GetSystemMenu (HWND hwnd, BOOL flag)
{
    PMAINWIN pWin;

    if (!(pWin = CheckAndGetMainWindowPtr (hwnd))) return 0;

    return pWin->hSysMenu;
}

/**************************** Menu drawing support ***************************/
static void mnuGetMenuBarItemSize (PMENUITEM pmi, SIZE* size)
{
    if (pmi->mnutype & MFT_BITMAP) {
        size->cx = pmi->hbmpChecked->bmWidth;
    }
    else if (pmi->mnutype & MFT_SEPARATOR) {
        size->cx = GetMainWinMetrics (MWM_MENUSEPARATORX); 
    }
    else if (pmi->mnutype & MFT_OWNERDRAW) {