menu.c

新片介绍

"++++++....++++++"
"++++++...+++++++"
"++++++..++++++++"
"++++++.+++++++++"
"++++++++++++++++"
"++++++++++++++++"
;

#define MENUBMP_RADIO 1
#define MENUBMP_CHECK 2
#define MENUBMP_SUB   3

static PBITMAP mnuGetMenuItemBitmap (int id, BOOL hilite)
{
    int i, j;
    const char* menu_bmp;
    gal_pixel fg, bg;
   
    if (hilite) {
        fg = GetWindowElementColor (FGC_MENUITEM_HILITE);
        bg = GetWindowElementColor (BKC_MENUITEM_HILITE);
    }
    else {
        fg = GetWindowElementColor (FGC_MENUITEM_NORMAL);
        bg = GetWindowElementColor (BKC_MENUITEM_NORMAL);
    }

    switch (id) {
        case MENUBMP_RADIO:
                menu_bmp = menubmp_radio;
                break;
        case MENUBMP_CHECK:
                menu_bmp = menubmp_check;
                break;
        case MENUBMP_SUB:
                menu_bmp = menubmp_sub;
                break;
        default:
                return NULL;
    }

    for (i = 0; i < 12; i++) {
        for (j = 0; j < 16; j++) {
            if (*menu_bmp == '+')
                SetPixelInBitmap (&bmp_menuitem, j, i, bg);
            else
                SetPixelInBitmap (&bmp_menuitem, j, i, fg);

            menu_bmp ++;
        }
    }

    return &bmp_menuitem;
}

static PBITMAP mnuGetCheckBitmap (PMENUITEM pmi)
{
    if (pmi->mnutype & MFT_BMPSTRING) {
        if (pmi->mnustate & MFS_CHECKED)
            return pmi->hbmpChecked;
        else
            return pmi->hbmpUnchecked;
    }
    else if (!(pmi->mnustate & MFS_CHECKED))
        return NULL;

    // default system check bitmap
    if (pmi->mnutype & MFT_RADIOCHECK) {
        if (pmi->mnustate & MFS_HILITE)
            return mnuGetMenuItemBitmap (MENUBMP_RADIO, TRUE);
        return mnuGetMenuItemBitmap (MENUBMP_RADIO, FALSE);
    }
    else {
        if (pmi->mnustate & MFS_HILITE)
            return mnuGetMenuItemBitmap (MENUBMP_CHECK, TRUE);
        return mnuGetMenuItemBitmap (MENUBMP_CHECK, FALSE);
    }

    return NULL;
}

static PBITMAP mnuGetSubMenuBitmap (PMENUITEM pmi)
{
    if (pmi->mnustate & MFS_HILITE)
        return mnuGetMenuItemBitmap (MENUBMP_SUB, TRUE);
    return mnuGetMenuItemBitmap (MENUBMP_SUB, FALSE);
}

static int mnuShowPopupMenu (PTRACKMENUINFO ptmi)
{
    PMENUITEM pmi = ptmi->pmi;
    PMENUITEM psubmi;
    int x, y, offy;
    
    int inter;
    int mioffx;
    int marginlx, marginrx;
    int marginy;

    PBITMAP bmp;
    
    // save screen under this popup menu.
#ifdef _USE_NEWGAL
    memset (&ptmi->savedbox, 0, sizeof (BITMAP));
    if (!GetBitmapFromDC (HDC_SCREEN, ptmi->rc.left, ptmi->rc.top, 
                    RECTW (ptmi->rc), RECTH (ptmi->rc), &ptmi->savedbox))
        return -1;
#else
    ptmi->savedbox = SaveCoveredScreenBox (ptmi->rc.left, ptmi->rc.top, 
                    RECTW (ptmi->rc), RECTH (ptmi->rc));

    if (ptmi->savedbox == NULL)
        return -1;
#endif

    inter = GetMainWinMetrics (MWM_INTERMENUITEMY);
    mioffx = GetMainWinMetrics (MWM_MENUITEMOFFX);
    marginlx = GetMainWinMetrics (MWM_MENULEFTMARGIN);
    marginrx = GetMainWinMetrics (MWM_MENURIGHTMARGIN);
    marginy = GetMainWinMetrics (MWM_MENUTOPMARGIN);

    // draw background.
    x = ptmi->rc.left;
    y = ptmi->rc.top;
#ifdef _FLAT_WINDOW_STYLE
    SetBrushColor (HDC_SCREEN, GetWindowElementColor(BKC_MENUITEM_NORMAL));
    FillBox (HDC_SCREEN, ptmi->rc.left, ptmi->rc.top, 
                    RECTW (ptmi->rc) - 1, RECTH (ptmi->rc) - 1);
    SetPenColor (HDC_SCREEN, GetWindowElementColor (WEC_FLAT_BORDER));
    Rectangle (HDC_SCREEN, ptmi->rc.left, ptmi->rc.top, 
                               ptmi->rc.right - 2, ptmi->rc.bottom - 2);
#ifndef _GRAY_SCREEN
    MoveTo (HDC_SCREEN, ptmi->rc.left + 1, ptmi->rc.bottom - 1);
    LineTo (HDC_SCREEN, ptmi->rc.right - 1, ptmi->rc.bottom - 1);
    LineTo (HDC_SCREEN, ptmi->rc.right - 1,  ptmi->rc.top + 1);
#endif
#else
    Draw3DUpFrame (HDC_SCREEN, ptmi->rc.left, ptmi->rc.top, 
                               ptmi->rc.right, ptmi->rc.bottom, 
                               GetWindowElementColor(BKC_MENUITEM_NORMAL));
#endif
    
    x = ptmi->rc.left + marginlx;
    y = ptmi->rc.top  + marginy;
    if (pmi->mnutype & MFT_BITMAP) {
    
        if (pmi->mnustate & MFS_CHECKED)
            bmp = pmi->hbmpChecked;
        else
            bmp = pmi->hbmpUnchecked;
            
        FillBoxWithBitmap (HDC_SCREEN, x, y,
                        bmp->bmWidth, 
                        bmp->bmHeight, 
                        bmp);
    }
    else if (pmi->mnutype & MFT_SEPARATOR) {
    
        SetPenColor (HDC_SCREEN, GetWindowElementColor (WEC_3DFRAME_BOTTOM)); 
        MoveTo (HDC_SCREEN, 
            x, y + (pmi->h>>1) - inter + 1);
        LineTo (HDC_SCREEN, 
            ptmi->rc.right - marginrx, y + (pmi->h>>1) - inter + 1);

        SetPenColor (HDC_SCREEN, GetWindowElementColor (WEC_3DFRAME_TOP));
        MoveTo (HDC_SCREEN, 
            x, y + (pmi->h>>1) - inter + 2);
        LineTo (HDC_SCREEN, 
            ptmi->rc.right - marginrx, y + (pmi->h>>1) - inter + 2);
    }
    else if (pmi->mnutype & MFT_OWNERDRAW) {
    }
    else {

        SelectFont (HDC_SCREEN, GetSystemFont (SYSLOGFONT_MENU));
        SetBkColor (HDC_SCREEN, GetWindowElementColor(BKC_MENUITEM_NORMAL));
        
        if (pmi->type == TYPE_PPPMENU) {
            SetTextColor (HDC_SCREEN, GetWindowElementColor(FGC_PPPMENUTITLE));
            TextOut (HDC_SCREEN, x + mioffx, y + inter, 
                (char*)pmi->typedata);

            SetPenColor (HDC_SCREEN, GetWindowElementColor (FGC_MENUITEM_NORMAL));
            MoveTo (HDC_SCREEN, 
                x, 
                y + pmi->h - (inter<<1));
            LineTo (HDC_SCREEN, 
                ptmi->rc.right - marginrx, 
                y + pmi->h - (inter<<1));
            MoveTo (HDC_SCREEN, 
                x, 
                y + pmi->h - inter);
            LineTo (HDC_SCREEN,
                ptmi->rc.right - marginrx, 
                y + pmi->h - inter);
        }
        else {
            int old_mode, bmp_w = mioffx;

            // draw check bitmap
            bmp = mnuGetCheckBitmap (pmi);
            if (bmp) {
                offy = (pmi->h - bmp->bmHeight)>>1;
                FillBoxWithBitmap (HDC_SCREEN, x, y + offy,
                        bmp->bmWidth, pmi->h - (offy<<1), bmp);
                bmp_w = MAX (bmp->bmWidth, mioffx);
            }

            old_mode = SetBkMode (HDC_SCREEN, BM_TRANSPARENT);
            SetTextColor (HDC_SCREEN, GetWindowElementColor(FGC_MENUITEM_NORMAL));
            TextOut (HDC_SCREEN, x + bmp_w, y + inter, 
                (char*)pmi->typedata);
            SetBkMode (HDC_SCREEN, old_mode);

            if (pmi->submenu) {
                bmp = mnuGetSubMenuBitmap (pmi);
                offy = (pmi->h - bmp->bmHeight)>>1;
                FillBoxWithBitmap (HDC_SCREEN, 
                    ptmi->rc.right - mioffx - marginrx,
                    y + offy,
                    bmp->bmWidth, pmi->h - (offy<<1), bmp);
            }
        }
    }
    y += pmi->h;
    
    if (pmi->type == TYPE_PPPMENU)
        psubmi = pmi->submenu;
    else
        psubmi = pmi->next;

    while (psubmi) {

        if (psubmi->mnutype & MFT_BITMAP) {
    
            if (psubmi->mnustate & MFS_CHECKED)
                bmp = psubmi->hbmpChecked;
            else
                bmp = psubmi->hbmpUnchecked;
            
            FillBoxWithBitmap (HDC_SCREEN, x, y,
                        bmp->bmWidth, 
                        bmp->bmHeight,
                        bmp);
        }
        else if (psubmi->mnutype & MFT_SEPARATOR) {
    
            SetPenColor (HDC_SCREEN, GetWindowElementColor (WEC_3DFRAME_BOTTOM)); 
            MoveTo (HDC_SCREEN, 
                x, y + (psubmi->h>>1) - inter + 1);
            LineTo (HDC_SCREEN, 
                ptmi->rc.right - marginrx, y + (psubmi->h>>1) - inter + 1);
                
            SetPenColor (HDC_SCREEN, GetWindowElementColor (WEC_3DFRAME_TOP));
            MoveTo (HDC_SCREEN, 
                x, y + (psubmi->h>>1) - inter + 2);
            LineTo (HDC_SCREEN, 
                ptmi->rc.right - marginrx, y + (psubmi->h>>1) - inter + 2);
        }
        else if (pmi->mnutype & MFT_OWNERDRAW) {
        }
        else {
            int old_mode, bmp_w = mioffx;

            // draw check bitmap
            bmp = mnuGetCheckBitmap (psubmi);
            if (bmp) {
                offy = (psubmi->h - bmp->bmHeight)>>1;
                FillBoxWithBitmap (HDC_SCREEN, x, y + offy,
                        bmp->bmWidth, psubmi->h - (offy<<1), bmp);
                bmp_w = MAX (bmp->bmWidth, mioffx);
            }

            // draw text.
            SelectFont (HDC_SCREEN, GetSystemFont (SYSLOGFONT_MENU));
            SetBkColor (HDC_SCREEN, GetWindowElementColor(BKC_MENUITEM_NORMAL));
            old_mode = SetBkMode (HDC_SCREEN, BM_TRANSPARENT);
            if (psubmi->mnustate & MFS_DISABLED)
                SetTextColor (HDC_SCREEN, GetWindowElementColor(FGC_MENUITEM_DISABLED));
            else
                SetTextColor (HDC_SCREEN, GetWindowElementColor(FGC_MENUITEM_NORMAL));
            TextOut (HDC_SCREEN, x + bmp_w, y + inter, 
                (char*)psubmi->typedata);
            SetBkMode (HDC_SCREEN, old_mode);

            if (psubmi->submenu) {
                bmp = mnuGetSubMenuBitmap (psubmi);
                offy = (psubmi->h - bmp->bmHeight)>>1;
                FillBoxWithBitmap (HDC_SCREEN, 
                    ptmi->rc.right - mioffx - marginrx,
                    y + offy,
                    bmp->bmWidth, psubmi->h - (offy<<1), bmp);
            }
        }

        y += psubmi->h;

        psubmi = psubmi->next;
    }

    return 0;
}

static void mnuUnhiliteMenu (PMENUITEM pmi)
{
    if (pmi->type == TYPE_PPPMENU)
        pmi = pmi->submenu;
    else {
        if (pmi->mnustate & MFS_HILITE)
            pmi->mnustate &= ~MFS_HILITE;

        pmi = pmi->next;
    }

    while (pmi) {
        if (pmi->mnustate & MFS_HILITE)
            pmi->mnustate &= ~MFS_HILITE;

        pmi = pmi->next;
    }
}

static void mnuCloseMenu (PTRACKMENUINFO ptmi)
{
    PTRACKMENUINFO phead, plast, ptemp;
    HMENU hmnu;
    UINT flags;

    // menu bar info
    HWND hwnd;
    PMENUBAR pmb;
    int barPos;
    
    flags = ptmi->flags;
    hmnu = (HMENU)ptmi->pmi;

    // get first tracking menu.
    phead = ptmi;
    while (phead->prev) {
        phead = phead->prev;
    }
    pmb = phead->pmb;
    hwnd = phead->hwnd;
    barPos = phead->barPos;
    
    // get last tracking menu.
    plast = ptmi;
    while (plast->next) {
        plast = plast->next;
    }

    while (plast) {
        ptemp = plast->prev;

        mnuUnhiliteMenu (plast->pmi);
        SendMessage (HWND_DESKTOP, 
                        MSG_ENDTRACKMENU, 0, (LPARAM)plast);

        plast = ptemp;
    }

    if (pmb && barPos >= 0)
        HiliteMenuBarItem (hwnd, barPos, HMF_DEFAULT);
    
    if (flags & TPM_DESTROY)
        DestroyMenu (hmnu);
}

static PTRACKMENUINFO mnuHitTestMenu (PTRACKMENUINFO plast, int x, int y)
{
    PTRACKMENUINFO ptemp;
    
    // which popup menu mouse in.
    ptemp = plast;
    while (ptemp) {

        if ( PtInRect(&ptemp->rc, x, y))
            return ptemp;

        ptemp = ptemp->prev;
    }

    return NULL;
}

static PMENUITEM mnuHitTestMenuItem (PTRACKMENUINFO ptmi, int x, int y)
{
    PMENUITEM pmi = ptmi->pmi;
    PMENUITEM psubmi;
    RECT rc;
    
    rc.left = ptmi->rc.left;
    rc.right = ptmi->rc.right;
    rc.top = ptmi->rc.top + GetMainWinMetrics (MWM_MENUTOPMARGIN);
    rc.bottom = rc.top + pmi->h;

    if (PtInRect (&rc, x, y))
        return pmi;

    rc.top += pmi->h;
    if (pmi->type == TYPE_PPPMENU)
        psubmi = pmi->submenu;
    else
        psubmi = pmi->next;
   
    while (psubmi) {
        
        rc.bottom = rc.top + psubmi->h;

        if (PtInRect (&rc, x, y))
            return psubmi;

        rc.top = rc.bottom;
        psubmi = psubmi->next;
    }

    return NULL;
}

static void mnuHiliteMenuItem (PTRACKMENUINFO ptmi, PMENUITEM pmi, BOOL bHilite)
{
    RECT rc;
    PMENUITEM ptemp = ptmi->pmi;
    int inter;
    int mioffx;
    int marginlx, marginrx;
    int offy;

    PBITMAP bmp;
    
    if (pmi->type == TYPE_PPPMENU) return;

    inter = GetMainWinMetrics (MWM_INTERMENUITEMY);
    mioffx = GetMainWinMetrics (MWM_MENUITEMOFFX);
    marginlx = GetMainWinMetrics (MWM_MENULEFTMARGIN);
    marginrx = GetMainWinMetrics (MWM_MENURIGHTMARGIN);

    rc.left = ptmi->rc.left;
    rc.right = ptmi->rc.right;
    rc.top = ptmi->rc.top + GetMainWinMetrics (MWM_MENUTOPMARGIN);

    if (ptemp == pmi)
        ptemp = pmi;
    else {
        rc.top += ptemp->h;
        if (ptemp->type == TYPE_PPPMENU)
            ptemp = ptemp->submenu;
        else
            ptemp = ptemp->next;

        while (ptemp != pmi) {
            rc.top += ptemp->h;
            ptemp = ptemp->next;
        }
    }

    rc.bottom = rc.top + ptemp->h;

    if (ptemp->mnutype & MFT_SEPARATOR) return;

    if (bHilite)
        ptemp->mnustate |= MFS_HILITE;
    else
        ptemp->mnustate &= ~MFS_HILITE;

    SetBrushColor (HDC_SCREEN, 
        bHilite ? GetWindowElementColor(BKC_MENUITEM_HILITE)
                : GetWindowElementColor(BKC_MENUITEM_NORMAL));

    FillBox (HDC_SCREEN, rc.left + marginlx, rc.top, 
        RECTW (rc) - marginlx - marginrx, RECTH (rc)); 
#if defined(_FLAT_WINDOW_STYLE) && !defined(_GRAY_SCREEN)
    if (bHilite) {
	    SetPenColor(HDC_SCREEN, GetWindowElementColor(FGC_MENUITEM_FRAME));
	    Rectangle (HDC_SCREEN, rc.left + marginlx, rc.top, 
		rc.left + RECTW (rc) - marginrx, rc.top + RECTH (rc)); 
    }
    else {
	    SetPenColor(HDC_SCREEN, GetWindowElementColor(BKC_MENUITEM_NORMAL));
	    Rectangle (HDC_SCREEN, rc.left + marginlx, rc.top, 
		rc.left + RECTW (rc) - marginrx, rc.top + RECTH (rc)); 
    }
#endif
        
    if (ptemp->mnutype & MFT_BITMAP) {
    
        if (ptemp->mnustate & MFS_CHECKED)
            bmp = ptemp->hbmpChecked;
        else
            bmp = ptemp->hbmpUnchecked;
            
        FillBoxWithBitmap (HDC_SCREEN, rc.left + marginlx, rc.top,
                        bmp->bmWidth, 
                        bmp->bmHeight, 
                        bmp);
    }
    else if (ptemp->mnutype & MFT_OWNERDRAW) {
    }
    else {
        int old_mode, bmp_w = mioffx;

        // draw check bitmap
        bmp = mnuGetCheckBitmap (ptemp);
        if (bmp) {
            offy = (ptemp->h - bmp->bmHeight)>>1;
            FillBoxWithBitmap (HDC_SCREEN, rc.left + marginlx, rc.top + offy,
                    bmp->bmWidth, ptemp->h - (offy<<1), bmp);
            bmp_w = MAX (bmp->bmWidth, mioffx);
        }

        SelectFont (HDC_SCREEN, GetSystemFont (SYSLOGFONT_MENU));
        SetBkColor (HDC_SCREEN, 
                bHilite ? GetWindowElementColor(BKC_MENUITEM_HILITE)
                        : GetWindowElementColor(BKC_MENUITEM_NORMAL));
        old_mode = SetBkMode (HDC_SCREEN, BM_TRANSPARENT);
        if (ptemp->mnustate & MFS_DISABLED) {
            SetTextColor (HDC_SCREEN, GetWindowElementColor(FGC_MENUITEM_DISABLED));
        }