/* easy menus: Copyright 1987 Peter da Silva, all rights reserved.
 *
 *	Permission is granted to use this in any application, so long as
 *	this notice is retained in the source. Permission is granted to
 *	modify the code as you like, so long as this notice (between the
 *	first line beginning "easy menus" and the end of this paragraph,
 *	inclusive) is retained intact.
 *
 * Usage:
 *
 *	#include "menu.h"
 *
 *	struct MenuPtr menudata;
 *	struct MenuPtr *menuptr = &menudata;
 *
 *	init_menus(menuptr);	/ * Just zero menu pointer out * /
 *
 *	for(each menu item) {
 *		add_menu(menuptr, menu, item, subitem, flags);
 *	}
 *
 *  Flags:
 *    SUBITEM_NOCHECK	-- subitem does not require a checkmark.
 *    SUBITEM_SELECTOR	-- subitem is a 1 of n selector, use mutual-exclude.
 *    SUBITEM_TOGGLE	-- subitem is a toggled flag.
 *    SUBITEM_SELECTED	-- defaults to checked.
 *
 *
 *	SetMenuStrip(yourwindow, menuptr->MenuBar);
 *
 *	...
 *
 *	ClearMenuStrip(yourwindow);
 *
 *	trash_menus(menuptr);
 *
 * Notes:
 *
 *	if you don't want any subitems, use zero for the subitem value.
 *
 *	subitem is always initialised as a CHECKIT item with all the other
 *	subitems mutually excluded.
 *
 *	it is intended that the menu be set up with all action items in
 *	the first level of the menu, and all toggles in the second level...
 *	this is a piece of blatant authoritarianism on my part. I've seen
 *	too many menus with no rhyme or reason. Look at AmigaTerm (the term
 *	program that comes with the Amiga modem) some time. Baud rate has
 *	an item all by itself, but word size is hidden off in a menu with
 *	things like bell sound.
 *
 *	the appearance of the menus produced by this is (in my humble
 *	opinion) good. I took some care making text centered in menu boxes,
 *	for example.
 */
#include <exec/memory.h>
#include <intuition/intuition.h>
#include "menu.h"
#include "fonts.h"

/*
struct MenuPtr {
	struct Menu *MenuBar;
	struct Remember *MenuMemory;
};
*/

char *AllocRemember();

static struct Menu *new_menu();
static struct MenuItem *new_item(), *new_subitem();

#define TOMENUNUM(i,j,k) (SHIFTMENU(i)|SHIFTITEM(j)|SHIFTSUB(k))
#define TextLen(s) (strlen(s)*FONTWIDTH)

trash_menus(menuptr)
struct MenuPtr *menuptr;
{
	FreeRemember(&menuptr->MenuMemory, 1);
	menuptr->MenuMemory = 0;
	menuptr->MenuBar = 0;
}

init_menus(menuptr)
struct MenuPtr *menuptr;
{
	menuptr->MenuMemory = 0;
	menuptr->MenuBar = 0;
}

int add_menu(menuptr, menuname, itemname, subitemname, flags)
struct MenuPtr *menuptr;
char *menuname, *itemname, *subitemname;
long flags;
{
	int i, j, k;
	struct Menu *menu;
	struct MenuItem *item;
	struct MenuItem *subitem;

	if(menuptr->MenuBar) {
		for(i = 0, menu = menuptr->MenuBar;
		    menu;
			menu = menu->NextMenu, i++
		   )
			if(strcmp(menuname, menu->MenuName)==0)
				break;
		if(!menu)
			menu = new_menu(menuptr, menuname);
		if(!menu)
			return MENUNULL;
	} else {
		i = 0;
		menu = new_menu(menuptr, menuname);
		if(!menu)
			return MENUNULL;
	}
	for(j = 0, item = menu->FirstItem;
		item;
		item = item->NextItem, j++
	   ) {
		struct IntuiText *text;
		text = (struct IntuiText *)item->ItemFill;
		if(strcmp(itemname, text->IText) == 0)
			break;
	}
	if(subitemname) {
		if(!item)
			item = new_item(menuptr, menu, itemname);
		if(!item)
			return MENUNULL;
		for(k = 0, subitem = item->SubItem;
			subitem;
			subitem = subitem->NextItem, k++
		   ) {
			struct IntuiText *text;
			text = (struct IntuiText *)subitem->ItemFill;
			if(strcmp(subitemname, text->IText) == 0)
				break;
		}
		if(!subitem)
			subitem = new_subitem(menuptr, item, subitemname, flags);
		if(!subitem)
			return MENUNULL;
		return TOMENUNUM(i, j, k);
	} else {
		if(!item)
			item = new_item(menuptr, menu, itemname);
		if(!item)
			return MENUNULL;
		return TOMENUNUM(i, j, NOSUB);
	}
}

static struct Menu *
new_menu(menuptr, name)
struct MenuPtr *menuptr;
char *name;
{
	struct Menu *menu;

	menu = (struct Menu *)AllocRemember(
		&menuptr->MenuMemory,
		sizeof(struct Menu),
		MEMF_PUBLIC);
	if(!menu)
		return 0;
	menu->NextMenu = NULL;
	menu->LeftEdge = 0;
	menu->TopEdge = 0;
	menu->Width = TextLen(name)+FONTWIDTH;
	menu->Height = 0;
	menu->Flags = MENUENABLED;
	menu->MenuName = name;
	menu->FirstItem = 0;
	if(menuptr->MenuBar) {
		struct Menu *ptr, *prev;
		for(ptr = menuptr->MenuBar; ptr; ptr=ptr->NextMenu) {
			menu->LeftEdge += ptr->Width;
			prev = ptr;
		}
		prev->NextMenu = menu;
	} else {
		menuptr->MenuBar = menu;
	}

	return menu;
}

static struct item *
new_item(menuptr, menu, name)
struct MenuPtr *menuptr;
char *name;
struct Menu *menu;
{
	struct MenuItem *item;
	struct IntuiText *text;

	item = (struct MenuItem *)AllocRemember(
		&menuptr->MenuMemory,
		sizeof(struct MenuItem),
		MEMF_PUBLIC);
	if(!item)
		return 0;
	text = (struct IntuiText *)AllocRemember(
		&menuptr->MenuMemory,
		sizeof(struct IntuiText),
		MEMF_PUBLIC);
	if(!text)
		return 0;

	text->FrontPen = AUTOFRONTPEN;
	text->BackPen = AUTOBACKPEN;
	text->DrawMode = JAM2;
	text->LeftEdge = 1;
	text->TopEdge = 1;
	text->ITextFont = NULL;
	text->IText = name;
	text->NextText = NULL;

	item->NextItem = NULL;
	item->LeftEdge = 0;
	item->TopEdge = 0;
	item->Width = IntuiTextLength(text)+2;
	if(item->Width <= menu->Width)
		item->Width = menu->Width+1;
	item->Height = FONTHEIGHT+1;
	item->Flags = ITEMTEXT|HIGHCOMP|ITEMENABLED;
	item->MutualExclude = 0;
	item->ItemFill = text;
	item->SelectFill = NULL;
	item->Command = 0;
	item->SubItem = NULL;
	item->NextSelect = NULL;

	if(menu->FirstItem) {
		struct MenuItem *ptr, *prev;
		for(ptr = menu->FirstItem; ptr; ptr=ptr->NextItem) {
			if(item->Width > ptr->Width) {
				if(ptr->SubItem)
					nudge(ptr->SubItem, item->Width-ptr->Width);
				ptr->Width = item->Width;
			} else if(ptr->Width>item->Width)
				item->Width = ptr->Width;
			prev = ptr;
		}
		item->TopEdge = prev->TopEdge + prev->Height;
		prev->NextItem = item;
	} else {
		menu->FirstItem = item;
	}

	return item;
}

static nudge(item, delta)
struct MenuItem *item;
int delta;
{
	while(item) {
		item->LeftEdge += delta;
		item = item->NextItem;
	}
}

static struct item *
new_subitem(menuptr, item, name, flags)
struct MenuPtr *menuptr;
char *name;
struct MenuItem *item;
long flags;
{
	struct MenuItem *subitem;
	struct IntuiText *text;

	subitem = (struct MenuItem *)AllocRemember(
		&menuptr->MenuMemory,
		sizeof(struct MenuItem),
		MEMF_PUBLIC);
	if(!subitem)
		return 0;
	text = (struct IntuiText *)AllocRemember(
		&menuptr->MenuMemory,
		sizeof(struct IntuiText),
		MEMF_PUBLIC);
	if(!text)
		return 0;

	text->FrontPen = AUTOFRONTPEN;
	text->BackPen = AUTOBACKPEN;
	text->DrawMode = JAM2;
	text->LeftEdge = CHECKWIDTH+1;
	text->TopEdge = 1;
	text->ITextFont = NULL;
	text->IText = name;
	text->NextText = NULL;

	subitem->NextItem = NULL;
	subitem->LeftEdge = item->Width;
	subitem->TopEdge = 0;
	subitem->Width = IntuiTextLength(text)+2;
	if(flags != SUBITEM_NOCHECK) subitem->Width += CHECKWIDTH;
	subitem->Height = FONTHEIGHT+1;
	subitem->Flags = ITEMTEXT|ITEMENABLED|HIGHCOMP;
	subitem->MutualExclude = 0;
	if(flags != SUBITEM_NOCHECK) {
		subitem->Flags |= CHECKIT;
		if(flags & SUBITEM_TOGGLE) subitem->Flags |= MENUTOGGLE;
		if(flags & SUBITEM_SELECTED) subitem->Flags |= CHECKED;
	}
	subitem->ItemFill = text;
	subitem->SelectFill = NULL;
	subitem->Command = 0;
	subitem->SubItem = NULL;
	subitem->NextSelect = NULL;

	if(item->SubItem) {
		struct MenuItem *ptr, *prev;
		int i;
		for(i=0, ptr = item->SubItem; ptr; i++, ptr=ptr->NextItem) {
			if(subitem->Width > ptr->Width)
				ptr->Width = subitem->Width;
			else if(ptr->Width>subitem->Width)
				subitem->Width = ptr->Width;
			prev = ptr;
		}
		subitem->TopEdge = prev->TopEdge + prev->Height;
		if(flags & SUBITEM_SELECTOR)
			subitem->MutualExclude = ~(1<<i);
		prev->NextItem = subitem;
	} else {
		item->SubItem = subitem;
		if(flags & SUBITEM_SELECTOR)
			subitem->MutualExclude = ~1;
	}

	return subitem;
}