/*
 * Quick Menu Package -- An easy way to make simple (but nice) menus.
 *
 * The client programmer will generally use the GenMenu()/FreeMenu() 
 * interface which creates and frees a whole menu strip.  A menu strip
 * -- both the main strip and menu item strips -- is defined by a
 * NewMenu struct.  Each NewMenu struct (defined in qmenu.h) is just a
 * pointer to an array of strings and a pointer to an array of
 * NewMenu's.  The elements of the array of NewMenu's are paired with the
 * strings in the array and represent the sub menus for that string.
 * The string array is terminated with a null pointer.
 *
 * The package tries to do nice things, like automatically formatting
 * the menu strings into blocks with their command keys, and placing
 * markers pointing to subitem stips.  The strings for the menu items
 * can contain special control codes to control the optional 
 * characteristics of items.  Special codes come at the front of item
 * strings and are delimited with a special character (SPECIAL,
 * defined as '!' by default) and are listed briefly below:
 *
 *	c	Checkmark item
 *	t	Checkmark toggle
 *	+	Checkmark checked
 *	b	Highlight box
 *	n	Highlight none
 *	d	Disabled
 *	=C	Set command key to "C"
 *	0101...	Set item exclude mask
 *
 * Any number of 1's and 0's after the special character will set the
 * Mutual exclude bits for that item in the order they occur.  So the
 * first 1 or 0 will set bit 0 of the exclude mask, the second will
 * set bit 1, etc.  Any unset will be 0.
 *
 * Additionally, if the item string is "-", the item will be 
 * a non-selectable horizontal line (a "rule") that can be used to 
 * visually group similar items in the menu strip.  There only need
 * to be NewMenu structs in the array for text menu items, not rules,
 * but don't forget to account for rules when counting MenuItem's
 * since they take a slot.
 *
 *
 * GenMenu() takes a pointer to a NewMenu struct and will create a main
 * Menu strip from the strings in the struct, with menu items from the
 * associated NewMenu's.  It returns a pointer to a Menu struct which is
 * the first element in the list for this strip.
 *
 * GenStrip() takes a pointer to an array of strings and creates a
 * top-level set of Menu structs for the main menu strip.
 *
 * FreeMenu() frees a Menu strip created with either GenMenu() or
 * GenStrip().
 *
 * GenItems() takes a pointer to a NewMenu struct and creates a single
 * list of MenuItem's from the description.  It also takes an X and Y
 * offset for all the elements in the list.
 *
 * FreeMItem() frees structures created by the above function.
 *
 * AttachSubMenu() takes a single MenuItem and a NewMenu struct and
 * attaches the MenuItems created from that NewMenu struct to the
 * parent MenuItem.  The parent should also have been created with
 * GenItems() in order to work correctly.  AttachSubMenu() places a
 * little maker on the parent item to show that it has subitems.  It
 * returns 1 for sucess and 0 for failure.
 *
 * -- WARNING:
 *
 * The client programmer is completely responsible for keeping the
 * menus within the bounds of the screen and for keeping within the
 * limits of Intuition.  The menu structures will not adjust as they
 * hit the borders of the screen (which might be a nice enhancement).
 * The strings in the NewMenu structures cannot be changed or deleted
 * while the Menus are in use, although they can be used to create
 * multiple Menus from the same strings.
 *
 **
 * This code can be used and modified freely.  Do let me know of any
 * improvements or enhancements you may add, and be sure to give credit
 * where credit is due (in the comments) if you redistribute this code.
 *
 *	Stuart Ferguson		1/89
 *	(shf@well.UUCP)
 */
#include <intuition/intuition.h>
#include "qmenu.h"

/*
 * Some useful macros for allocating and freeing structures and
 * arrays of structures.
 */
#define NEW(typ)	(typ*)AllocMem((long)sizeof(typ),0L)
#define FREI(p)		FreeMem(p,(long)sizeof(*p))

#define NEW_N(typ,n)	(typ*)AllocMem((long)((n)*sizeof(typ)),0L)
#define FREI_N(p,n)	FreeMem(p,(long)((n)*sizeof(*p)))

char * AllocMem();

/*
 * Definitions for formatting the menus.  Glossary:
 *
 *	TEXTCOLOR	- color of the text items in the menus.
 *	MARKCOLOR	- color of the subitem marker.
 *	RULECOLOR	- color of the horizontal lines in the menus.
 *	RULEHEIGHT	- vertical thickness of the horizontal rules.
 *	RULEGAP		- vertical blank space around the rules.
 *	RULEMARGIN	- horizontal blank space around the rules.
 *	TEXTGAP		- vertical blank space around the text items.
 *	TEXTMARGIN	- horizontal blank space around the text items.
 *	MAINWID		- width of the text font on the main menu.
 *	MAINGAP		- spacing between items on the main menu strip.
 *	SUBINDENT	- overlap between items and their subitems.
 *	SUBDOWN		- vertical shift between items and their subitems.
 */
#define TEXTCOLOR	2
#define MARKCOLOR	3
#define RULECOLOR	0
#define RULEHEIGHT	2
#define RULEGAP		4
#define RULEMARGIN	10
#define TEXTGAP		2
#define TEXTMARGIN	4
#define MAINWID		10
#define MAINGAP		10
#define SUBINDENT	18
#define SUBDOWN		0

/*
 * Escape character for special control codes in text items strings.
 */
#define SPECIAL		'!'

/*
 * The extern "ta" is set by the client program for
 * the font to use for these menus.
 */
extern struct TextAttr ta;

/*
 * Generic templates to use for creating the dynamic menu structures. 
 */
static struct IntuiText
  generic_itext = {TEXTCOLOR, 0, JAM1, TEXTMARGIN/2, TEXTGAP/2, &ta,NULL,NULL},
  /*
  generic_smark = {MARKCOLOR, 0, JAM1, 0, TEXTGAP/2, &ta, (UBYTE *) ";", NULL};
  */
  generic_smark = {MARKCOLOR, 0, JAM1, 0, TEXTGAP/2, &ta, (UBYTE *) ">>", NULL}


static struct Menu
  generic_main = {NULL, 0, 0, 0, 10, MENUENABLED, NULL, NULL};

static struct MenuItem
  generic_mitem = {
	 NULL, 0, 0, 0, 0,
	 ITEMTEXT | ITEMENABLED | HIGHCOMP,
	 0, NULL, NULL, 0, NULL, 0
};

/* Image struct with no imagery for the horizontal lines.
 */
static struct Image
  generic_hrule = {0, 0, 1, RULEHEIGHT, 2, NULL, 0, RULECOLOR, NULL};

static struct MenuItem
  generic_hitem = {
	 NULL, RULEMARGIN/2, 0, 0, 0,
	 ITEMENABLED | HIGHNONE,
	 0, NULL, NULL, 0, NULL, 0
};


/*
 * Takes an array of strings and associated array of NewMenu structs
 * (as a single NewMenu struct) and constructs a menu strip from the
 * descripton.  This is the main high-level call that most clients
 * will make.
 */
struct Menu * GenMenu (nmen)
	register struct NewMenu *nmen;
{
	register short  i, ok, n;
	register struct Menu *mm;
	register struct MenuItem *mi;

	/* Count menus to be generated and create top level structure.
	 */
	for (n = 0; nmen->str[n]; n++) ;
	mm = GenStrip (nmen->str);
	if (!mm) return NULL;

	/* Create the item strip for each main menu and attach to the
	 * top level Menu structure.  Any failure causes the whole
	 * thing to crumble to dust.
	 */
	ok = 1;
	nmen = nmen->submenu;
	for (i = 0; i < n; i++) {
		if (nmen->str) {
			mi = GenItems (nmen, 0L, 0L);
			mm[i].FirstItem = mi;
			ok &= (mi != NULL);
		}
		nmen ++;
	}
	if (!ok) {
		FreeMenu (mm);
		return NULL;
	}
	return mm;
}


/*
 * Generate a menu strip.  Just creates the top level Menu structures,
 * linked together and intialized.  Takes an array of pointers to
 * strings.
 */
struct Menu * GenStrip (str)
	char **str;
{
	register short  i, x, num;
	register struct Menu *mm, *m;

	/*
	 * Create enough struct Menu's for the menu strip. 
	 */
	for (num = 0; str[num]; num++) ;
	mm = NEW_N (struct Menu, num);
	if (!mm) return NULL;

	/*
	 * Init the structures using the generic Menu struct as a template.
	 * NOTE: the size of the font for these item labels is unknown for
	 *       windows on the Workbench screen, so a size should be used
	 *       that will work with 60 & 80 column fonts. 
	 */
	x = 0;
	for (i = 0; i < num; i++) {
		m = &mm[i];
		*m = generic_main;
		m->LeftEdge = x;
		m->Width = strlen (str[i]) * MAINWID + TEXTMARGIN;
		x += m->Width + MAINGAP;
		m->MenuName = str[i];
		m->NextMenu = m + 1;
	}
	mm[num - 1].NextMenu = NULL;
	return mm;
}


/*
 * Attach a submenu to a MenuItem.  Takes the parent MenuItem and a
 * NewMenu structure that will be attached as a sub-menu.  
 * Attaches a ";" mark at the end of the parent item and calls
 * GenItems() to create the sub-menu strip.
 */
BOOL AttachSubMenu (mi, nmen)
	register struct MenuItem	*mi;
	struct NewMenu			*nmen;
{
	register struct IntuiText *it;

	/* Create an IntuiText with the marker and position it
	 * at the right edge of the item.
	 */
	if (!(it = NEW (struct IntuiText))) return FALSE;
	*it = generic_smark;
	it->LeftEdge = mi->Width - IntuiTextLength (it) - 2;

	/* Create the subitem structure and attach to the main item.
	 */
	if (!(mi->SubItem = GenItems
	      (nmen, (LONG) (mi->Width - SUBINDENT), (LONG) SUBDOWN))) {
		FREI (it);
		return FALSE;
	}

	/* Only if it all worked attach the new text structure.
	 */
	((struct IntuiText *) mi->ItemFill)->NextText = it;
	return TRUE;
}


/*
 * Takes the given menu text item and skips past the special control
 * codes while adjusting the associated MenuItem appropriately.
 * Special codes are in the form of "!x", where "x" is:
 *
 *	c	Checkmark item
 *	t	Checkmark toggle
 *	b	Highlight box
 *	n	Highlight none
 *	d	Disabled
 *	+	Checkmark checked
 *	=C	Set command key to "C"
 *	1010...	Set item exclude mask
 *
 * Takes the mostly defined MenuItem and diddles it.  Returns a pointer
 * to the item text with control codes stripped.
 */
static UBYTE * ProcessSpecialStuff (str, mi)
	char *str;
	struct MenuItem *mi;
{
	register LONG	x;
	register int	i;

	while (*str == SPECIAL) {
		switch (*++str) {
		    case 'c':
			mi->Flags |= CHECKIT;
			break;
		    case 't':
			mi->Flags |= CHECKIT | MENUTOGGLE;
			break;
		    case 'b':
			mi->Flags &= ~HIGHFLAGS;
			mi->Flags |= HIGHBOX;
			break;
		    case 'n':
			mi->Flags &= ~HIGHFLAGS;
			mi->Flags |= HIGHNONE;
			break;
		    case 'd':
			mi->Flags &= ~ITEMENABLED;
			break;
		    case '+':
			mi->Flags |= CHECKIT | CHECKED;
			break;
		    case '=':
			mi->Flags |= COMMSEQ;
			mi->Command = *++str;
			break;
		    case '0':
		    case '1':
			x = 0;
			i = 0;
			while (*str == '0' || *str == '1')
				x += (*str++ - '0') << (i++);
			mi->MutualExclude = x;
			str--;
			break;
		}
		str++;
	}
	return (UBYTE*) str;
}


/*
 * Construct a basic item list for a menu.  Takes a NewMenu structure
 * which contains a pointer to an array of pointers to strings and a 
 * pointer to an array of NewMenu structures.  The strings contain the
 * item text for each menu plus optional special control codes.  If the
 * string is "-", the item will be a horizontal rule rather than a text
 * item.  The NewMenu structures, if not NULL, are the sub-menu's for
 * each menu in the array.
 * "x" and "y" are the horizontal and vertical offsets of this set of
 * MenuItems.  These are set by AttachSubMenu() for positioning submenus
 * under their parent items.
 */
struct MenuItem *GenItems (nmen, x, y)
	struct NewMenu *nmen;
	LONG	x, y;
{
	register struct MenuItem *mi, *cmi;
	register struct IntuiText *itext;
	struct Image   *img;
	register short  i, len, max;
	short           n;
	struct NewMenu *sub;

	/* Count menu items (n) and allocate an array for the strip.
	 */
	for (n = 0; nmen->str[n]; n++) ;
	if (!(mi = NEW_N (struct MenuItem, n))) return NULL;

	/* Counts the number of rules in the menu ("-" strings)
	 * and allocates the structures for the lines and the text items.
	 */
	max = 0;
	for (i = 0; i < n; i++) max += (*nmen->str[i] == '-');
	if (n - max)
		if (!(itext = NEW_N (struct IntuiText, n - max))) {
			FREI_N (mi, n);
			return NULL;
		}
	if (max)
		if (!(img = NEW_N (struct Image, max))) {
			FREI_N (mi, n);
			if (n - max) FREI_N (itext, n - max);
			return NULL;
		}

	/* Loop through text menu items and initialize the
	 * associated IntuiText structures.  Compute the maximum
	 * width of the menu taking command keys into account while
	 * assigning all the other parts of the text MenuItem's.
	 */
	max = 0;
	for (i = 0; i < n; i++) {
		if (*nmen->str[i] == '-') continue;	/* skip rules */

		/* Init the text MenuItem to point to the assocd IntuiText.
		 */
		cmi = &mi[i];
		*cmi = generic_mitem;
		cmi->ItemFill = (APTR) itext;

		/* Init the IntuiText and adjust the MenuItem from the
		 * flags set in the menu text string.
		 */
		*itext = generic_itext;
		itext->IText = ProcessSpecialStuff (nmen->str[i], cmi);

		/* Make a first cut at measuring the length of the item.
		 */
		len = IntuiTextLength (itext) + TEXTMARGIN;

		/* If command key set, add to length.
		 */
		if (cmi->Flags & COMMSEQ) len += COMMWIDTH + MAINWID;

		/* If this is a checkmark item, shift the text over to
		 * make room and add that to the length.
		 * Compute the max length.
		 */
		if (cmi->Flags & CHECKIT) {
			itext->LeftEdge += CHECKWIDTH;
			len += CHECKWIDTH;
		}
		if (len > max) max = len;
		itext ++;
	}

	/* Secondary assignment loop.  Position the text MenuItems and
	 * init the horizontal lines.
	 */
	for (i = 0; i < n; i++) {
		cmi = &mi[i];

		if (*nmen->str[i] != '-') {
			cmi->LeftEdge = x;
			cmi->TopEdge = y;
			cmi->Width = max;
			cmi->Height = ta.ta_YSize + TEXTGAP;
			y += cmi->Height;
		} else {

			/* Rule items point to their Image structure
			 * and are just a little narrower than the
			 * menu itself.
			 */
			*img = generic_hrule;
			img->Width = max - RULEMARGIN;
			*cmi = generic_hitem;
			cmi->TopEdge = y + RULEGAP/2;
			y += RULEHEIGHT + RULEGAP;
			cmi->ItemFill = (APTR) img;
			img ++;
		}
		cmi->NextItem = cmi + 1;
	}
	mi[n - 1].NextItem = NULL;

	/* Attach submenu's, if any.
	 */
	if (!(sub = nmen->submenu)) return mi;

	/* Use "max" as a flag for the success of the attachments.
	 */
	max = 1;
	for (i = 0; i < n; i++) {
		if (*nmen->str[i] == '-') continue;
		if (sub->str)
			max &= AttachSubMenu (&mi[i], sub);
		sub ++;
	}
	if (!max) {
		FreeMItem (mi);
		return NULL;
	}
	return mi;
}


/*
 * Free a Menu structure created by GenStrip() that has items 
 * created with GenItems().
 */
void FreeMenu (mm)
	struct Menu    *mm;
{
	register short  i;
	register struct Menu *t;

	i = 0;
	for (t = mm; t; t = t->NextMenu) {
		if (t->FirstItem) FreeMItem (t->FirstItem);
		i++;
	}
	FREI_N (mm, i);
}


/*
 * Free a MenuItem structure created by GenItems().
 */
void FreeMItem (mi)
	register struct MenuItem *mi;
{
	register short  nit, nimg;
	register struct MenuItem *c;
	register struct IntuiText *it = NULL, *it1;
	struct Image   *img = NULL;

	/* Scan the MenuItem structures and count the number of images
	 * and IntuiText structures.  Find the pointer to the first of
	 * each structure in the set.  That will be the first element
	 * in the array that was allocated as a unit.
	 */
	nit = nimg = 0;
	for (c = mi; c; c = c->NextItem) {
		if (c->SubItem) FreeMItem (c->SubItem);
		if (c->Flags & ITEMTEXT) {
			it1 = (struct IntuiText *) c->ItemFill;
			if (!it) it = it1;
			nit++;

			/* Free the subitem marker, if any.
			 */
			if (it1->NextText) FREI (it1->NextText);
		} else {
			if (!img) img = (struct Image *) c->ItemFill;
			nimg++;
		}
	}

	/* Free the arrays of structures of images and texts, as
	 * well as the main array of MenuItem structures themselves.
	 */
	if (nit) FREI_N (it, nit);
	if (nimg) FREI_N (img, nimg);
	FREI_N (mi, nit + nimg);
}