void FGAPIENTRY glutRemoveMenuItem(int num)
{
SFG_WinMenuItem *item, **prev;
int i;
if (fgMappedMenu)
menuModificationError();
i = fgCurrentMenu->Num;
prev = &fgCurrentMenu->List;
item = fgCurrentMenu->List;
while (item)
{
if (i == num)
{
/* Found the menu item in list to remove. */
fgCurrentMenu->Num--;
/* Patch up menu's item list. */
*prev = item->Next;
RemoveMenu(fgCurrentMenu->Handle, (UINT) i - 1, MF_BYPOSITION);
free(item->Label);
free(item);
return;
}
i--;
prev = &item->Next;
item = item->Next;
}
fgWarning("Current menu has no %d item.", num);
}
int APIENTRY
glutCreateMenu(GLUTselectCB selectFunc)
{
GLUTmenu *menu;
int menuid;
if (__glutMappedMenu) {
menuModificationError();
}
menuid = getUnusedMenuSlot();
menu = (GLUTmenu *) malloc(sizeof(GLUTmenu));
if (!menu) {
__glutFatalError("out of memory.");
}
menu->id = menuid;
menu->num = 0;
menu->submenus = 0;
menu->select = selectFunc;
menu->list = NULL;
menu->cascade = NULL;
menu->highlighted = NULL;
menu->anchor = NULL;
menu->win = (HWND) CreatePopupMenu();
menuList[menuid] = menu;
__glutSetMenu(menu);
return menuid + 1;
}
void APIENTRY
glutDestroyMenu(int menunum)
{
GLUTmenu *menu = __glutGetMenuByNum(menunum);
GLUTmenuItem *item, *next;
if (__glutMappedMenu) {
menuModificationError();
}
assert(menu->id == menunum - 1);
DestroyMenu( (HMENU) menu->win);
menuList[menunum - 1] = NULL;
/* free all menu entries */
item = menu->list;
while (item) {
assert(item->menu == menu);
next = item->next;
free(item->label);
free(item);
item = next;
}
if (__glutCurrentMenu == menu) {
__glutCurrentMenu = NULL;
}
free(menu);
}
void APIENTRY
glutRemoveMenuItem(int num)
{
GLUTmenuItem *item, **prev;
int i;
if (__glutMappedMenu) {
menuModificationError();
}
i = __glutCurrentMenu->num;
prev = &__glutCurrentMenu->list;
item = __glutCurrentMenu->list;
while (item) {
if (i == num) {
/* Found the menu item in list to remove. */
__glutCurrentMenu->num--;
/* Patch up menu's item list. */
*prev = item->next;
RemoveMenu((HMENU) __glutCurrentMenu->win, (UINT) i - 1, MF_BYPOSITION);
free(item->label);
free(item);
return;
}
i--;
prev = &item->next;
item = item->next;
}
__glutWarning("Current menu has no %d item.", num);
}
void FGAPIENTRY glutDestroyMenu(int menunum)
{
SFG_WinMenu *menu = fgGetMenuByNum(menunum);
SFG_WinMenuItem *item, *next;
if (fgMappedMenu)
menuModificationError();
assert(menu->ID == menunum - 1);
DestroyMenu(menu->Handle);
menuList[menunum - 1] = NULL;
/* free all menu entries */
item = menu->List;
while (item)
{
assert(item->Menu == menu);
next = item->Next;
free(item->Label);
free(item);
item = next;
}
if (fgCurrentMenu == menu)
fgCurrentMenu = NULL;
free(menu);
}
int FGAPIENTRY glutCreateMenu(FGCBMenu selectFunc)
{
SFG_WinMenu *menu;
int menuid;
if (fgMappedMenu)
menuModificationError();
menuid = getUnusedMenuSlot();
menu = (SFG_WinMenu *) malloc(sizeof(SFG_WinMenu));
if (!menu)
fgError("out of memory.");
menu->ID = menuid;
menu->Num = 0;
menu->SubMenus = 0;
menu->Select = selectFunc;
menu->List = NULL;
menu->Cascade = NULL;
menu->Highlighted = NULL;
menu->Anchor = NULL;
menu->Handle = CreatePopupMenu();
menuList[menuid] = menu;
fgSetMenu(menu);
return menuid + 1;
}
void FGAPIENTRY glutChangeToSubMenu(int num, const char *label, int menu)
{
SFG_WinMenu *popupmenu;
SFG_WinMenuItem *item;
int i;
#ifdef UNICODE
WCHAR *wlabel;
#endif
if (fgMappedMenu)
menuModificationError();
i = fgCurrentMenu->Num;
item = fgCurrentMenu->List;
while (item)
{
if (i == num)
{
if (!item->IsTrigger)
{
/* If changing a menu entry to as submenu trigger, we
need to account for submenus. */
item->Menu->SubMenus++;
}
free(item->Label);
item->Label = _strdup(label);
if (!item->Label)
fgError("out of memory");
item->IsTrigger = TRUE;
item->Len = (int) strlen(label);
item->Value = menu - 1;
item->Unique = UniqueMenuHandler++;
popupmenu = fgGetMenuByNum(menu);
if (popupmenu)
item->Handle = popupmenu->Handle;
#ifdef UNICODE
wlabel = (WCHAR*)malloc((item->Len + 1) * sizeof(WCHAR));
mbstowcs(wlabel, label, item->Len + 1);
#endif
RemoveMenu(fgCurrentMenu->Handle, (UINT) i - 1, MF_BYPOSITION);
InsertMenu(fgCurrentMenu->Handle, (UINT) i - 1, MF_BYPOSITION | MFT_STRING | MF_POPUP, (UINT)item->Handle,
#ifdef UNICODE
wlabel
#else
label
#endif
);
#ifdef UNICODE
free(wlabel);
#endif
return;
}
i--;
item = item->Next;
}
fgWarning("Current menu has no %d item.", num);
}
void FGAPIENTRY glutDetachMenu(int button)
{
if (fgMappedMenu)
menuModificationError();
if (fgStructure.Window->Menu[button] > 0)
{
fgStructure.Window->ButtonUses--;
fgStructure.Window->Menu[button] = 0;
}
}
void APIENTRY
glutDetachMenu(int button)
{
if (__glutMappedMenu) {
menuModificationError();
}
if (__glutCurrentWindow->menu[button] > 0) {
__glutCurrentWindow->buttonUses--;
__glutCurrentWindow->menu[button] = 0;
}
}
void FGAPIENTRY glutAttachMenu(int button)
{
/* if (fgStructure.Window->Window.Handle == fgGameModeWindow)
{
fgWarning("cannot attach menus in game mode.");
return;
}*/
if (fgMappedMenu)
menuModificationError();
if (fgStructure.Window->Menu[button] < 1)
fgStructure.Window->ButtonUses++;
fgStructure.Window->Menu[button] = fgCurrentMenu->ID + 1;
}
void APIENTRY
glutAttachMenu(int button)
{
if (__glutCurrentWindow == __glutGameModeWindow) {
__glutWarning("cannot attach menus in game mode.");
return;
}
if (__glutMappedMenu) {
menuModificationError();
}
if (__glutCurrentWindow->menu[button] < 1) {
__glutCurrentWindow->buttonUses++;
}
__glutCurrentWindow->menu[button] = __glutCurrentMenu->id + 1;
}
void FGAPIENTRY glutAddMenuEntry(const char *label, int value)
{
SFG_WinMenuItem *entry;
if (fgMappedMenu)
menuModificationError();
entry = (SFG_WinMenuItem *) malloc(sizeof(SFG_WinMenuItem));
if (!entry)
fgError("out of memory.");
entry->Menu = fgCurrentMenu;
setMenuItem(entry, label, value, FALSE);
fgCurrentMenu->Num++;
entry->Next = fgCurrentMenu->List;
fgCurrentMenu->List = entry;
}
void APIENTRY
glutAddMenuEntry(const char *label, int value)
{
GLUTmenuItem *entry;
if (__glutMappedMenu) {
menuModificationError();
}
entry = (GLUTmenuItem *) malloc(sizeof(GLUTmenuItem));
if (!entry) {
__glutFatalError("out of memory.");
}
entry->menu = __glutCurrentMenu;
setMenuItem(entry, label, value, FALSE);
__glutCurrentMenu->num++;
entry->next = __glutCurrentMenu->list;
__glutCurrentMenu->list = entry;
}
void APIENTRY
glutChangeToSubMenu(int num, const char *label, int menu)
{
GLUTmenu *popupmenu;
GLUTmenuItem *item;
int i;
if (__glutMappedMenu) {
menuModificationError();
}
i = __glutCurrentMenu->num;
item = __glutCurrentMenu->list;
while (item) {
if (i == num) {
if (!item->isTrigger) {
/* If changing a menu entry to as submenu trigger, we
need to account for submenus. */
item->menu->submenus++;
}
free(item->label);
item->label = strdup(label);
if (!item->label)
__glutFatalError("out of memory");
item->isTrigger = TRUE;
item->len = (int) strlen(label);
item->value = menu - 1;
item->unique = uniqueMenuHandler++;
popupmenu = __glutGetMenuByNum(menu);
if (popupmenu)
item->win = popupmenu->win;
RemoveMenu(__glutCurrentMenu->win, (UINT) i - 1, MF_BYPOSITION);
InsertMenu(__glutCurrentMenu->win, (UINT) i - 1, MF_BYPOSITION | MFT_STRING | MF_POPUP, (UINT)item->win, label);
return;
}
i--;
item = item->next;
}
__glutWarning("Current menu has no %d item.", num);
}
void APIENTRY
glutChangeToMenuEntry(int num, const char *label, int value)
{
GLUTmenuItem *item;
int i;
if (__glutMappedMenu) {
menuModificationError();
}
i = __glutCurrentMenu->num;
item = __glutCurrentMenu->list;
while (item) {
if (i == num) {
if (item->isTrigger) {
/* If changing a submenu trigger to a menu entry, we
need to account for submenus. */
item->menu->submenus--;
/* Nuke the Win32 menu. */
DestroyMenu((HMENU) item->win);
}
free(item->label);
item->label = strdup(label);
if (!item->label)
__glutFatalError("out of memory");
item->isTrigger = FALSE;
item->len = (int) strlen(label);
item->value = value;
item->unique = uniqueMenuHandler++;
ModifyMenu((HMENU) __glutCurrentMenu->win, (UINT) i - 1,
MF_BYPOSITION | MFT_STRING, item->unique, label);
return;
}
i--;
item = item->next;
}
__glutWarning("Current menu has no %d item.", num);
}
void FGAPIENTRY glutAddSubMenu(const char *label, int menu)
{
SFG_WinMenuItem *submenu;
SFG_WinMenu *popupmenu;
if (fgMappedMenu)
menuModificationError();
submenu = (SFG_WinMenuItem *) malloc(sizeof(SFG_WinMenuItem));
if (!submenu)
fgError("out of memory.");
fgCurrentMenu->SubMenus++;
submenu->Menu = fgCurrentMenu;
popupmenu = fgGetMenuByNum(menu);
if (popupmenu)
submenu->Handle = popupmenu->Handle;
setMenuItem(submenu, label, /* base 0 */ menu - 1, TRUE);
fgCurrentMenu->Num++;
submenu->Next = fgCurrentMenu->List;
fgCurrentMenu->List = submenu;
}
void APIENTRY
glutAddSubMenu(const char *label, int menu)
{
GLUTmenuItem *submenu;
GLUTmenu *popupmenu;
if (__glutMappedMenu) {
menuModificationError();
}
submenu = (GLUTmenuItem *) malloc(sizeof(GLUTmenuItem));
if (!submenu) {
__glutFatalError("out of memory.");
}
__glutCurrentMenu->submenus++;
submenu->menu = __glutCurrentMenu;
popupmenu = __glutGetMenuByNum(menu);
if (popupmenu) {
submenu->win = popupmenu->win;
}
setMenuItem(submenu, label, /* base 0 */ menu - 1, TRUE);
__glutCurrentMenu->num++;
submenu->next = __glutCurrentMenu->list;
__glutCurrentMenu->list = submenu;
}
