menu.c

新片介绍

        else {
            SetTextColor (HDC_SCREEN, 
                bHilite ? GetWindowElementColor(FGC_MENUITEM_HILITE)
                        : GetWindowElementColor(FGC_MENUITEM_NORMAL));
        }
        TextOut (HDC_SCREEN, rc.left + bmp_w + marginlx, rc.top + inter,
            (char*)ptemp->typedata);
        SetBkMode (HDC_SCREEN, old_mode);
        
        if (ptemp->submenu) {
            bmp = mnuGetSubMenuBitmap (ptemp);
            offy = (ptemp->h - bmp->bmHeight)>>1;
            FillBoxWithBitmap (HDC_SCREEN, 
                rc.right - mioffx - marginrx,
                rc.top + offy,
                bmp->bmWidth, ptemp->h - (offy<<1), bmp);
        }
    }
}

static int mnuOpenNewSubMenu (PTRACKMENUINFO ptmi, PMENUITEM pmi, 
                int x, int y)
{
    PTRACKMENUINFO pnewtmi;

    pnewtmi = TrackMenuInfoAlloc ();
    
    pnewtmi->rc.left = x;
    pnewtmi->rc.top  = y;
    pnewtmi->pmi = pmi;
    pnewtmi->pmb = ptmi->pmb;
    pnewtmi->philite = NULL;
    pnewtmi->hwnd = ptmi->hwnd;
    pnewtmi->flags = ptmi->flags;
    pnewtmi->next = NULL;
    pnewtmi->prev = NULL;
   
    return SendMessage (HWND_DESKTOP, MSG_TRACKPOPUPMENU,
                    0, (LPARAM)(pnewtmi));
}

static PMENUITEM mnuGetNextMenuItem (PTRACKMENUINFO ptmi, PMENUITEM pmi)
{
    PMENUITEM head = ptmi->pmi;
    PMENUITEM next;

    if (head->type == TYPE_PPPMENU)
        head = head->submenu;

    if (pmi == NULL)
        next = head;
    else if (pmi->next)
        next = pmi->next;
    else
        next = head;

    while (next && next->mnutype & MFT_SEPARATOR)
        next = next->next;

    if (next == NULL)
        next = head;

    while (next && next->mnutype & MFT_SEPARATOR)
        next = next->next;

    return next;
}

static PMENUITEM mnuGetPrevItem (PMENUITEM head, PMENUITEM pmi)
{
    if (head == pmi)
        return NULL;

    while (head) {
        if (head->next == pmi)
            return head;

        head = head->next;
    }

    return NULL;
}

static PMENUITEM mnuGetPrevMenuItem (PTRACKMENUINFO ptmi, PMENUITEM pmi)
{
    PMENUITEM head = ptmi->pmi, tail;
    PMENUITEM prev;

    if (head->type == TYPE_PPPMENU)
        head = head->submenu;

    prev = pmi;

    do {
        prev = mnuGetPrevItem (head, prev);

        if (prev) {
            if (prev->mnutype & MFT_SEPARATOR)
                continue;
            else
                return prev;
        }
        else
            break;
    }while (TRUE);

    tail = head;
    while (tail && tail->next)
        tail = tail->next;

    prev = tail;
    do {
        if (prev) {
            if (!(prev->mnutype & MFT_SEPARATOR))
                return prev;
        }
        else
            break;
            
        prev = mnuGetPrevItem (head, prev);
    }while (TRUE);

    return NULL;
}

static int mnuGetMenuItemY (PTRACKMENUINFO ptmi, PMENUITEM pmi)
{
    PMENUITEM head = ptmi->pmi;
    int y = ptmi->rc.top + GetMainWinMetrics (MWM_MENUTOPMARGIN);

    if (pmi == head) return y;
    
    y += head->h;
    
    if (head->type == TYPE_PPPMENU)
        head = head->submenu;
    else
        head = head->next;

    while (head) {
        if (head == pmi)
            return y;

        y += head->h;

        head = head->next;
    }

    return 0;
}

static void mnuTrackMenuWithKey (PTRACKMENUINFO ptmi, 
                                int message, int scan, DWORD status)
{
    PTRACKMENUINFO phead, pcurtmi, pprevtmi;
    PMENUITEM pcurmi, pnewmi;
    HWND hwnd;
    HMENU hmnu;
    UINT flags;
    int barItem;
    int id;
    
    flags = ptmi->flags;
    hmnu = (HMENU)ptmi->pmi;
    
    phead = ptmi;
    while (phead->prev) {
        phead = phead->prev;
    }
    
    // get last tracking menu, the last menu is the current menu.
    pcurtmi = ptmi;
    while (pcurtmi->next) {
        pcurtmi = pcurtmi->next;
    }

    pprevtmi = pcurtmi->prev;

    pcurmi = pcurtmi->philite;

    if (message == MSG_KEYDOWN) {
        switch (scan) {
            case SCANCODE_CURSORBLOCKDOWN:
            case SCANCODE_CURSORBLOCKUP:
                if (scan == SCANCODE_CURSORBLOCKDOWN)
                    pnewmi = mnuGetNextMenuItem (pcurtmi, pcurmi);
                else
                    pnewmi = mnuGetPrevMenuItem (pcurtmi, pcurmi);

                if (pnewmi != pcurmi) {
                    if (pcurmi) 
                        mnuHiliteMenuItem (pcurtmi, pcurmi, FALSE);
                    if (pnewmi) {
                        mnuHiliteMenuItem (pcurtmi, pnewmi, TRUE);
                        pcurtmi->philite = pnewmi;
                    }
                }
                break;
                
                break;
                
            case SCANCODE_CURSORBLOCKRIGHT:
                if (pcurmi && pcurmi->submenu)
                    mnuOpenNewSubMenu (pcurtmi, 
                                pcurmi->submenu, 
                                pcurtmi->rc.right,
                                mnuGetMenuItemY (pcurtmi, pcurmi));
                else {
                    if (phead->pmb) {
                        barItem  = mnuGetNextMenuBarItem (phead->pmb, 
                                                          phead->barPos);
                        if (barItem != phead->barPos) {
                            hwnd = phead->hwnd;

                            // close current popup menu.
                            SendMessage (HWND_DESKTOP, MSG_CLOSEMENU, 0, 0);

                            // open new popup menu.
                            TrackMenuBar (hwnd, barItem);
                        }
                    }
                }
                break;
                
            case SCANCODE_ESCAPE:
                if (pprevtmi)
                    SendMessage (HWND_DESKTOP, 
                        MSG_ENDTRACKMENU, 0, (LPARAM)pcurtmi);
                break;

            case SCANCODE_CURSORBLOCKLEFT:
                if (pprevtmi)
                    SendMessage (HWND_DESKTOP, 
                        MSG_ENDTRACKMENU, 0, (LPARAM)pcurtmi);
                else {
                    if (phead->pmb) {
                        barItem  = mnuGetPrevMenuBarItem (phead->pmb, 
                                                          phead->barPos);
                        if (barItem != phead->barPos) {
                            hwnd = phead->hwnd;

                            // close current popup menu.
                            SendMessage (HWND_DESKTOP, MSG_CLOSEMENU, 0, 0);

                            // open new popup menu.
                            TrackMenuBar (hwnd, barItem);
                        }
                    }
                }
                break;
                
            case SCANCODE_ENTER:
                if (pcurmi == NULL) return;
                if (pcurmi->mnutype & MFT_SEPARATOR) return;
                if (pcurmi->mnustate & MFS_DISABLED) return;
                
                if (pcurmi->submenu) {
                    mnuOpenNewSubMenu (pcurtmi, 
                                pcurmi->submenu, 
                                pcurtmi->rc.right,
                                mnuGetMenuItemY (pcurtmi, pcurmi));
                    return;
                }

                if (pcurmi && pcurmi->type != TYPE_PPPMENU &&
                    pcurmi->submenu == NULL) {

                    hwnd = ptmi->hwnd;
                    id = pcurmi->id;
        
                    SendMessage (HWND_DESKTOP, MSG_CLOSEMENU, 0, 1);
       
                    if (flags & TPM_SYSCMD)
                        SendNotifyMessage (hwnd, MSG_SYSCOMMAND, id, 0);
                    else
                        SendNotifyMessage (hwnd, MSG_COMMAND, id, 0);

                    if (flags & TPM_DESTROY)
                        DestroyMenu (hmnu);
                }
                break;
        }
    }
    else if (message == MSG_KEYUP) {
        switch (scan) {
            case SCANCODE_LEFTALT:
            case SCANCODE_RIGHTALT:
                SendMessage (HWND_DESKTOP, MSG_CLOSEMENU, 0, 1);

                if (flags & TPM_DESTROY)
                    DestroyMenu (hmnu);
                break;
        }
    }
}

static void mnuTrackMenu (PTRACKMENUINFO ptmi, int x, int y)
{
    PTRACKMENUINFO phead, plast;
    PTRACKMENUINFO pcurtmi, pclose, ptemp;
    PMENUITEM pcurmi;
    PMENUITEM philite;
    int barItem;
    HWND hwnd;
    
    // get first tracking menu.
    phead = ptmi;
    while (phead->prev) {
        phead = phead->prev;
    }
        
    // get last tracking menu.
    plast = ptmi;
    while (plast->next) {
        plast = plast->next;
    }

    pcurtmi = mnuHitTestMenu (plast, x, y);

    if (pcurtmi == NULL) {
        if (plast->philite)
            mnuHiliteMenuItem (plast, plast->philite, FALSE);

        // check to see if move to the other sub menu of menu bar.
        if (phead->pmb) {
            barItem = MenuBarHitTest (phead->hwnd, x, y);
            if (barItem >= 0 && barItem != phead->barPos) {
                    
                hwnd = phead->hwnd;

                // close current popup menu.
                SendMessage (HWND_DESKTOP, MSG_CLOSEMENU, 0, 0);

                // open new popup menu.
                TrackMenuBar (hwnd, barItem);
            }
        }
            
        return;
    }

    pcurmi = mnuHitTestMenuItem (pcurtmi, x, y);

    if (pcurtmi != plast) {
        pclose = pcurtmi->next->next;
       
        if (pclose != NULL) {
            while (pclose != plast) {
                ptemp = plast->prev;
                SendMessage (HWND_DESKTOP, MSG_ENDTRACKMENU, 0, (LPARAM)plast);
                plast = ptemp;
            }
            SendMessage (HWND_DESKTOP, MSG_ENDTRACKMENU, 0, (LPARAM)plast);
            plast = pcurtmi->next;
        }
            
        if (plast->philite) {
            mnuHiliteMenuItem (plast, plast->philite, FALSE);
            plast->philite = NULL;
        }
    }

    philite = pcurtmi->philite;
    if (pcurmi == philite) return;

    // current hilite menu item is a bottom most item.
    if (philite) {
        if (pcurtmi != plast)
            SendMessage (HWND_DESKTOP, MSG_ENDTRACKMENU, 0, (LPARAM)plast);
        mnuHiliteMenuItem (pcurtmi, philite, FALSE);
    }

    pcurtmi->philite = pcurmi;
    if (pcurmi == NULL) return;
    if (pcurmi->type == TYPE_PPPMENU) return;

    mnuHiliteMenuItem (pcurtmi, pcurmi, TRUE);

    if (pcurmi->submenu)
        mnuOpenNewSubMenu (pcurtmi, pcurmi->submenu, 
            pcurtmi->rc.right, mnuGetMenuItemY (pcurtmi, pcurmi));
}

static int mnuTrackMenuOnButtonDown (PTRACKMENUINFO ptmi, 
        int message, int x, int y)
{
    PTRACKMENUINFO plast, phead;
    PTRACKMENUINFO pcurtmi;
    HMENU hmnu;
    UINT flags;
    int barItem;
    
    flags = ptmi->flags;
    hmnu = (HMENU)ptmi->pmi;
    
    // get first tracking menu.
    phead = ptmi;
    while (phead->prev) {
        phead = phead->prev;
    }

    // get last tracking menu.
    plast = ptmi;
    while (plast->next) {
        plast = plast->next;
    }

    pcurtmi = mnuHitTestMenu (plast, x, y);

    if (pcurtmi == NULL) {      // close menu.
    
        if (phead->pmb) {
            barItem = MenuBarHitTest (phead->hwnd, x, y);
            if (barItem == phead->barPos)
                return 0;
        }

        SendMessage (HWND_DESKTOP, MSG_CLOSEMENU, 0, 1);

        if (flags & TPM_DESTROY)
            DestroyMenu (hmnu);

        return -1;
    }


    return 0;
}

static int mnuTrackMenuOnButtonUp (PTRACKMENUINFO ptmi, 
        int message, int x, int y)
{
    PTRACKMENUINFO plast;
    PTRACKMENUINFO pcurtmi;
    PMENUITEM pcurmi;
    HWND hwnd;
    UINT flags;
    int  id;
    HMENU hmnu;
    
    // get last tracking menu.
    plast = ptmi;
    while (plast->next) {
        plast = plast->next;
    }

    pcurtmi = mnuHitTestMenu (plast, x, y);

    if (pcurtmi == NULL) return 0;

    pcurmi = mnuHitTestMenuItem (pcurtmi, x, y);

    if (pcurmi == NULL) return 0;
    if (pcurmi->mnutype & MFT_SEPARATOR) return 0;
    if (pcurmi->mnustate & MFS_DISABLED) return 0;
        
    if (pcurmi->type != TYPE_PPPMENU &&
        pcurmi->submenu == NULL)
    {
        hwnd = ptmi->hwnd;
        flags = ptmi->flags;
        id = pcurmi->id;
        hmnu = (HMENU)ptmi->pmi;
        
        SendMessage (HWND_DESKTOP, MSG_CLOSEMENU, 0, 1);
       
        if (flags & TPM_SYSCMD)
            SendNotifyMessage (hwnd, MSG_SYSCOMMAND, id, 0);
        else
            SendNotifyMessage (hwnd, MSG_COMMAND, id, 0);

        if (flags & TPM_DESTROY)
            DestroyMenu (hmnu);
            
        return id;
    }

    return 0;
}

int PopupMenuTrackProc (PTRACKMENUINFO ptmi, 
    int message, WPARAM wParam, LPARAM lParam)
{
    switch (message) {
        case MSG_INITMENU:
            mnuGetPopupMenuExtent (ptmi);
        break;

        case MSG_SHOWMENU:
            if (GetCurrentCursor() != GetSystemCursor(IDC_ARROW))
                SetCursor(GetSystemCursor(IDC_ARROW));
            return mnuShowPopupMenu (ptmi); 
        break;

        case MSG_HIDEMENU:
            mnuUnhiliteMenu (ptmi->pmi);
#ifdef _USE_NEWGAL
            FillBoxWithBitmap (HDC_SCREEN, ptmi->rc.left, ptmi->rc.top,
                        RECTW (ptmi->rc), RECTH (ptmi->rc), &ptmi->savedbox);
#else
            PutSavedBoxOnScreen (ptmi->rc.left, ptmi->rc.top,
                        RECTW (ptmi->rc), RECTH (ptmi->rc), ptmi->savedbox);
#endif
        break;

        case MSG_ENDTRACKMENU:
#ifdef _USE_NEWGAL
            free (ptmi->savedbox.bmBits);
#else
            free (ptmi->savedbox);
#endif
            if (ptmi->hwnd != HWND_DESKTOP)
                SendNotifyMessage (ptmi->hwnd, MSG_ENDTRACKMENU, 
                            (WPARAM)ptmi->pmi, (LPARAM)ptmi->pmb);
            FreeTrackMenuInfo (ptmi);