menu.c

在ｅｃｏｓ 下mingui 的移植开发

// $Id: menu.c,v 1.17 2000/11/17 07:02:01 ymwei Exp $
//
// menu.c: The Menu module.
//
// Copyright (C) 1999, Mr. Wei Yongming.
//
// Current maintainer: Wei Yongming.

/*
**  This library is free software; you can redistribute it and/or
**  modify it under the terms of the GNU Library General Public
**  License as published by the Free Software Foundation; either
**  version 2 of the License, or (at your option) any later version.
**
**  This library is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
**  Library General Public License for more details.
**
**  You should have received a copy of the GNU Library General Public
**  License along with this library; if not, write to the Free
**  Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
**  MA 02111-1307, USA
*/

// Create date: 1999.04.09
//
// Used abbreviations:
// Menu: mnu
// Popup: ppp
// Identifier: id
// Mnemonic: mnic
// Normal: nml
// Item: itm
// Modify records:
//
//  Who             When        Where       For What                Status
//-----------------------------------------------------------------------------
//  WEI Yongming    2000/2/21   Wudaokou    MSG_ACTIVEMENU message  Done
//
// TODO:
// 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <semaphore.h>


#include "common.h"
#include "minigui.h"
#include "gdi.h"
#include "window.h"
#include "cliprect.h"
#include "gal.h"
#include "internals.h"
#include "menu.h"

#ifndef lint
static char fileid[] = "$Id: menu.c,v 1.17 2000/11/17 07:02:01 ymwei Exp $";
#endif

BOOL InitMenu(void);
void TerminateMenu(void);

static FREEMILIST FreeMIList;
static FREEMBLIST FreeMBList;
static FREETMILIST FreeTMIList;

/************************* MENUBAR allocation ********************************/
static BOOL InitFreeMBList(void)
{
    if( !(FreeMBList.heap = calloc (SIZE_MB_HEAP, sizeof(MENUBAR)))) 
        return FALSE;
        
    FreeMBList.free = 0;

    pthread_mutex_init (&FreeMBList.lock, NULL);
    FreeMBList.head = FreeMBList.tail = NULL;
    FreeMBList.nr = 0;

    return TRUE;
}

static PMENUBAR MenuBarAlloc(void)
{
    PMENUBAR pmb;

    pthread_mutex_lock (&FreeMBList.lock);

    if (FreeMBList.head) {
        pmb = FreeMBList.head;
        FreeMBList.head = pmb->next;
        FreeMBList.nr --;
    }
    else {
        if (FreeMBList.free < SIZE_MB_HEAP) {
            pmb = FreeMBList.heap + FreeMBList.free;
            pmb->fromheap = TRUE;
            FreeMBList.free ++;
        }
        else {
            pmb = malloc (sizeof(MENUBAR));
            if (pmb == NULL)
                fprintf (stderr, "MENU error: alloc menu bar failure!\n");
            else
                pmb->fromheap = FALSE;
        }
    }

    pthread_mutex_unlock (&FreeMBList.lock);

    return pmb;
}

static void FreeMenuBar(PMENUBAR pmb)
{
    pthread_mutex_lock (&FreeMBList.lock);

    pmb->next = NULL;
    if (FreeMBList.head) {
        FreeMBList.tail->next = pmb;
        FreeMBList.tail = pmb;
    }
    else {
        FreeMBList.head = FreeMBList.tail = pmb; 
    }

    FreeMBList.nr++;
    pthread_mutex_unlock (&FreeMBList.lock);
}

static void EmptyFreeMBList(void)
{
    PMENUBAR pmb, pTemp;

    pthread_mutex_lock (&FreeMBList.lock);

    pmb = FreeMBList.head;

    while (pmb) {
        pTemp = pmb->next;
        
        if (!pmb->fromheap)
            free (pmb);

        pmb = pTemp;
    }

    FreeMBList.head = FreeMBList.tail = NULL;
    FreeMBList.nr = 0;
    FreeMBList.free = 0;

    pthread_mutex_unlock (&FreeMBList.lock);
}

static void DestroyFreeMBList(void)
{
    EmptyFreeMBList ();
    free (FreeMBList.heap);
}

/************************* MENUITEM allocation *******************************/
static BOOL InitFreeMIList(void)
{
    if( !(FreeMIList.heap = calloc (SIZE_MI_HEAP, sizeof(MENUITEM)))) 
        return FALSE;
        
    FreeMIList.free = 0;

    pthread_mutex_init (&FreeMIList.lock, NULL);
    FreeMIList.head = FreeMIList.tail = NULL;
    FreeMIList.nr = 0;

    return TRUE;
}

static PMENUITEM MenuItemAlloc(void)
{
    PMENUITEM pmi;

    pthread_mutex_lock (&FreeMIList.lock);

    if (FreeMIList.head) {
        pmi = FreeMIList.head;
        FreeMIList.head = pmi->next;
        FreeMIList.nr --;
    }
    else {
        if (FreeMIList.free < SIZE_MI_HEAP) {
            pmi = FreeMIList.heap + FreeMIList.free;
            pmi->fromheap = TRUE;
            FreeMIList.free ++;
        }
        else {
            pmi = malloc (sizeof(MENUITEM));
            if (pmi == NULL)
                fprintf (stderr, "MENU error: alloc menu item failure!\n");
            else
                pmi->fromheap = FALSE;
        }
    }

    pthread_mutex_unlock (&FreeMIList.lock);

    return pmi;
}

static void FreeMenuItem(MENUITEM* pmi)
{
    pthread_mutex_lock (&FreeMIList.lock);

    pmi->next = NULL;
    if (FreeMIList.head) {
        FreeMIList.tail->next = pmi;
        FreeMIList.tail = pmi;
    }
    else {
        FreeMIList.head = FreeMIList.tail = pmi;
    }

    FreeMIList.nr++;
    pthread_mutex_unlock (&FreeMIList.lock);
}

static void EmptyFreeMIList(void)
{
    PMENUITEM pmi, pTemp;

    pthread_mutex_lock (&FreeMIList.lock);

    pmi = FreeMIList.head;

    while (pmi) {
        pTemp = pmi->next;
        
        if (!pmi->fromheap)
            free (pmi);

        pmi = pTemp;
    }

    FreeMIList.head = FreeMIList.tail = NULL;
    FreeMIList.nr = 0;
    FreeMIList.free = 0;

    pthread_mutex_unlock (&FreeMIList.lock);
}

static void DestroyFreeMIList(void)
{
    EmptyFreeMIList ();
    free (FreeMIList.heap);
}

/************************* TRACKMENUITEM heap *******************************/
static BOOL InitFreeTMIList(void)
{
    if( !(FreeTMIList.heap = calloc (SIZE_TMI_HEAP, sizeof(TRACKMENUINFO)))) 
        return FALSE;
        
    FreeTMIList.free = 0;

    pthread_mutex_init (&FreeTMIList.lock, NULL);
    FreeTMIList.head = FreeTMIList.tail = NULL;
    FreeTMIList.nr = 0;

    return TRUE;
}

static PTRACKMENUINFO TrackMenuInfoAlloc(void)
{
    PTRACKMENUINFO ptmi;

    pthread_mutex_lock (&FreeTMIList.lock);

    if (FreeTMIList.head) {
        ptmi = FreeTMIList.head;
        FreeTMIList.head = ptmi->next;
        FreeTMIList.nr --;
    }
    else {
        if (FreeTMIList.free < SIZE_TMI_HEAP) {
            ptmi = FreeTMIList.heap + FreeTMIList.free;
            ptmi->fromheap = TRUE;
            FreeTMIList.free ++;
        }
        else {
            ptmi = malloc (sizeof(TRACKMENUINFO));
            if (ptmi == NULL)
                fprintf (stderr, "MENU error: alloc tmi failure!\n");
            else
                ptmi->fromheap = FALSE;
        }
    }

    pthread_mutex_unlock (&FreeTMIList.lock);

    return ptmi;
}

static void FreeTrackMenuInfo(TRACKMENUINFO* ptmi)
{
    pthread_mutex_lock (&FreeTMIList.lock);

    ptmi->next = NULL;
    if (FreeTMIList.head) {
        FreeTMIList.tail->next = ptmi;
        FreeTMIList.tail = ptmi;
    }
    else {
        FreeTMIList.head = FreeTMIList.tail = ptmi;
    }

    FreeTMIList.nr++;

    pthread_mutex_unlock (&FreeTMIList.lock);
}

static void EmptyFreeTMIList(void)
{
    PTRACKMENUINFO ptmi, pTemp;

    pthread_mutex_lock (&FreeTMIList.lock);

    ptmi = FreeTMIList.head;

    while (ptmi) {
        pTemp = ptmi->next;
        
        if (!ptmi->fromheap)
            free (ptmi);

        ptmi = pTemp;
    }

    FreeTMIList.head = FreeTMIList.tail = NULL;
    FreeTMIList.nr = 0;
    FreeTMIList.free = 0;

    pthread_mutex_unlock (&FreeTMIList.lock);
}

static void DestroyFreeTMIList(void)
{
    EmptyFreeTMIList ();
    free (FreeTMIList.heap);
}

/************************* Module initialization *****************************/

// this function defined in Desktop module
BOOL LoadSystemBitmap (PBITMAP pBitmap, const char* szItemName);

#define BKC_MENUBAR_NORMAL      PIXEL_lightgray
#define FGC_MENUBAR_NORMAL      PIXEL_black
#define BKC_MENUBAR_HILITE      PIXEL_darkblue
#define FGC_MENUBAR_HILITE      PIXEL_lightwhite
#define FGC_MENUBAR_DISABLED    PIXEL_darkgray

#define BKC_MENUITEM_NORMAL     PIXEL_lightgray
#define FGC_MENUITEM_NORMAL     PIXEL_black
#define BKC_MENUITEM_HILITE     PIXEL_darkblue
#define FGC_MENUITEM_HILITE     PIXEL_lightwhite
#define FGC_MENUITEM_DISABLED   PIXEL_darkgray
#define BKC_PPPMENUTITLE        PIXEL_lightgray
#define FGC_PPPMENUTITLE        PIXEL_blue

// default bitmap on menu.
static BITMAP bmpSubMenu[4]; // normal, normal hilite, disabled, disable hilite
static BITMAP bmpCheck[4];
static BITMAP bmpRadio[4];

BOOL mnuLoadBitmap (void)
{
    if (!LoadSystemBitmap (bmpSubMenu,     "submenu1")) return FALSE;
    ReplaceBitmapColor(HDC_SCREEN, bmpSubMenu, PIXEL_green, BKC_MENUITEM_NORMAL);
    
    if (!LoadSystemBitmap (bmpSubMenu + 1, "submenu2")) return FALSE;
    ReplaceBitmapColor(HDC_SCREEN, bmpSubMenu + 1, PIXEL_green, BKC_MENUITEM_HILITE);
    
    if (!LoadSystemBitmap (bmpSubMenu + 2, "submenu3")) return FALSE;
    ReplaceBitmapColor(HDC_SCREEN, bmpSubMenu + 2, PIXEL_green, BKC_MENUITEM_NORMAL);
    
    if (!LoadSystemBitmap (bmpSubMenu + 3, "submenu3")) return FALSE;
    ReplaceBitmapColor(HDC_SCREEN, bmpSubMenu + 3, PIXEL_green, BKC_MENUITEM_HILITE);

    if (!LoadSystemBitmap (bmpCheck,     "check1")) return FALSE;
    ReplaceBitmapColor(HDC_SCREEN, bmpCheck, PIXEL_green, BKC_MENUITEM_NORMAL);

    if (!LoadSystemBitmap (bmpCheck + 1, "check2")) return FALSE;
    ReplaceBitmapColor(HDC_SCREEN, bmpCheck + 1, PIXEL_green, BKC_MENUITEM_HILITE);

    if (!LoadSystemBitmap (bmpCheck + 2, "check3")) return FALSE;
    ReplaceBitmapColor(HDC_SCREEN, bmpCheck + 2, PIXEL_green, BKC_MENUITEM_NORMAL);
    
    if (!LoadSystemBitmap (bmpCheck + 3, "check3")) return FALSE;
    ReplaceBitmapColor(HDC_SCREEN, bmpCheck + 3, PIXEL_green, BKC_MENUITEM_HILITE);
    
    if (!LoadSystemBitmap (bmpRadio,     "radio1")) return FALSE;
    ReplaceBitmapColor(HDC_SCREEN, bmpRadio, PIXEL_green, BKC_MENUITEM_NORMAL);

    if (!LoadSystemBitmap (bmpRadio + 1, "radio2")) return FALSE;
    ReplaceBitmapColor(HDC_SCREEN, bmpRadio + 1, PIXEL_green, BKC_MENUITEM_HILITE);

    if (!LoadSystemBitmap (bmpRadio + 2, "radio3")) return FALSE;
    ReplaceBitmapColor(HDC_SCREEN, bmpRadio + 2, PIXEL_green, BKC_MENUITEM_NORMAL);

    if (!LoadSystemBitmap (bmpRadio + 3, "radio3")) return FALSE;
    ReplaceBitmapColor(HDC_SCREEN, bmpRadio + 3, PIXEL_green, BKC_MENUITEM_HILITE);

    return TRUE;
}

BOOL InitMenu (void)
{
    if (!InitFreeMBList ()) return FALSE;

    if (!InitFreeMIList ()) return FALSE;

    if (!InitFreeTMIList ()) return FALSE;


    return mnuLoadBitmap ();
}

/************************* Module termination *******************************/
void TerminateMenu (void)
{
    int i;
    
    DestroyFreeTMIList ();
    DestroyFreeMBList ();
    DestroyFreeMIList ();

    for (i=0; i<4; i++) {
        UnloadBitmap (bmpSubMenu + i);
        UnloadBitmap (bmpCheck + i);
        UnloadBitmap (bmpRadio + i);
    }
}

/***************************** Menu creation *******************************/
HMENU GUIAPI LoadMenuFromFile (const char* filename, int id)
{
    return 0;
}

HMENU GUIAPI CreateMenu (void)
{
    PMENUBAR pmb;

    if (!(pmb = MenuBarAlloc ()))
        return 0;
    
    pmb->class = TYPE_HMENU;
    pmb->type = TYPE_MENUBAR;
    pmb->head = NULL;

    return (HMENU)pmb;
}

HMENU GUIAPI CreatePopupMenu (PMENUITEMINFO pmii)
{
    PMENUITEM pmi;
    
    if (!(pmi = MenuItemAlloc ()))
        return 0;
   
    pmi->class = TYPE_HMENU;
    pmi->type = TYPE_PPPMENU;
    pmi->next = NULL;
    pmi->submenu = NULL;

    pmi->mnutype         = pmii->type;
    pmi->mnustate        = pmii->state;
    pmi->id              = pmii->id;
    pmi->hbmpChecked     = pmii->hbmpChecked;
    pmi->hbmpUnchecked   = pmii->hbmpUnchecked;
    pmi->itemdata        = pmii->itemdata;

    // copy string.
    if (pmii->type == MFT_STRING) {
        pmi->typedata = (DWORD)FixStrAlloc (strlen ((char*)pmii->typedata));
        strcpy ((char*)pmi->typedata, (char*)pmii->typedata);
    }
    else
        pmi->typedata = pmii->typedata;

    return (HMENU)pmi;
}

HMENU GUIAPI CreateSystemMenu (HWND hwnd, DWORD dwStyle)
{
    HMENU hmnu;
    MENUITEMINFO mii;

    memset (&mii, 0, sizeof(MENUITEMINFO));
    mii.type        = MFT_STRING;
    mii.id          = 0;
    mii.typedata    = (DWORD)GetSysText(SysText[5]);

    hmnu = CreatePopupMenu (&mii);

    memset (&mii, 0, sizeof(MENUITEMINFO));

    if (dwStyle & WS_MINIMIZEBOX) {
        mii.type        = MFT_STRING;
        mii.state       = 0;
        mii.id          = SC_MINIMIZE;
        mii.typedata    = (DWORD)GetSysText(SysText[6]);
        InsertMenuItem(hmnu, 0, TRUE, &mii);
    }

    if (dwStyle & WS_MAXIMIZEBOX) {
        mii.type        = MFT_STRING;
        if (dwStyle & WS_MAXIMIZE)
            mii.state   = MFS_DISABLED;
        else
            mii.state   = 0;
        mii.id          = SC_MAXIMIZE;
        mii.typedata    = (DWORD)GetSysText(SysText[7]);
        InsertMenuItem(hmnu, 1, TRUE, &mii);