diff -rNu melys-0.0.4/ChangeLog melys-0.0.5/ChangeLog
--- melys-0.0.4/ChangeLog	Fri Jul 30 00:35:41 1999
+++ melys-0.0.5/ChangeLog	Mon Aug  9 00:31:54 1999
@@ -1,6 +1,68 @@
+1999-08-08  Steve Ratcliffe  <steve@ariel>
+
+	* files/mdmlread.m, gui/main.m, gui/menus.m, md/mdutil.m,
+	programs/melys.m, song/song.m, util/util.m, widgets/melystrack.m,
+	widgets/melystrackinfo.m, widgets/melystransport.m: First stage of
+	track based view complete The left pane is starting to be
+	operational.  The sliders do not do anything yet though.
+
+1999-08-07  Steve Ratcliffe  <steve@ariel>
+
+	* util/util.m: debuging routines added
+
+	* files/.cvsignore, md/.cvsignore, programs/.cvsignore,
+	seq/.cvsignore, util/.cvsignore:
+	include compressed mdml in ignore
+
+	* gui/main.m, midi/record.m, song/song.m, seq/seqlib.m:
+	Fixed bug where record was not being freed and there
+	was a problem with freeing subcontexts.
+
+	* help/C/melys.sgml: a little more text
+
+1999-08-06  Steve Ratcliffe  <steve@ariel>
+
+	* help/C/Makefile: added
+
+	* help/C/melys.sgml: Added
+
+	* widgets/melystrack.m, widgets/melystrackdisplay.m,
+	widgets/melystrackinfo.m, ChangeLog, gui/main.m,
+	gui/menus.m, mlib/PROJECT/mgtk.py, programs/.cvsignore,
+	programs/melys.m, song/song.m:
+	Slipped and checked in too much stuff and don't know what
+	the changes were.  Nothing too important.
+	Fixed the order of arguments in the 4 arg case
+
+	* midi/play.m, midi/record.m: Reference count mdroot so
+	we can always free it, instead of trying to remember who
+	owns it.
+
+	* md/elements.m, md/mdutil.m, doc/mdml.dtd:
+	The name attribute added to track and part
+
+	* files/format.m, files/mdmlread.m, files/mdmlwrite.m:
+	Track and part now have a name property
+
+1999-08-04  Steve Ratcliffe  <steve@ariel>
+
+	* files/mdmlread.m: Fix negative durations on empty container elements
+
+1999-08-02  Steve Ratcliffe  <steve@ariel>
+
+	* files/midiread.m:
+	There may be more than one on event for an off event.  (Probably
+	could be concidered a bug in the midi file, but they do exist)
+
+	* md/mdutil.m: Fix initial tempo to be 120
+
+1999-07-30  Steve Ratcliffe  <steve@ariel>
+
+	* mlib/PROJECT/mgtk.py: Improved and fixed the gtk object generation
+
 1999-07-29  Steve Ratcliffe  <steve@ariel>
 
-	* README: Updated the README a little
+	* README: Updated the README a little (REL-0-0-4)
 
 	* programs/showseq.m:
 	Modify output slightly to put user/kernel in brackets
diff -rNu melys-0.0.4/config/.cvsignore melys-0.0.5/config/.cvsignore
--- melys-0.0.4/config/.cvsignore	Fri Jul 30 00:43:11 1999
+++ melys-0.0.5/config/.cvsignore	Mon Aug  9 00:51:26 1999
@@ -1,5 +1,4 @@
 ports.c
 Makefile
-*.mdml
-*.mid
+*.mdml *.mdml.gz *.mid
 .cvsignore
diff -rNu melys-0.0.4/config/ports.m melys-0.0.5/config/ports.m
--- melys-0.0.4/config/ports.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/config/ports.m	Tue Jul 27 10:01:42 1999
@@ -0,0 +1,68 @@
+>>name ports.m - Port configuration
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+>>header <stdlib.h>
+>>header linux/asequencer.h
+>>header seqlib.h
+>>headerdef --decl config.h
+
+>>function conf_get_input_ports
+int
+snd_seq_addr_t **addrp;  Address returned here
+
+>>description
+Get the input ports that have been configured for use.
+
+>>code
+	char *portdesc;
+	int naddr;
+
+	/* At present there is no configuration of course */
+	portdesc = getenv("ALSA_INPUT_PORTS");
+	if (portdesc == NULL) {
+		ethrow(debugError, "ALSA_INPUT_PORTS not set in environment");
+		return 0;
+	}
+
+	naddr = seq_get_ports_from_desc(portdesc, addrp);
+
+	return naddr;
+
+
+>>function conf_get_output_ports
+int
+snd_seq_addr_t **addrp;  Address returned here
+
+>>description
+Get the output ports that have been configured.
+
+>>code
+	char *portdesc;
+	int naddr;
+
+	/* At present there is no configuration of course */
+	portdesc = getenv("ALSA_OUTPUT_PORTS");
+	if (portdesc == NULL) {
+		/* Old name, for compatability */
+		portdesc = getenv("ALSA_OUT_PORT");
+		if (portdesc == NULL) {
+			ethrow(debugError, "ALSA_OUTPUT_PORTS not set in environment");
+			return 0;
+		}
+	}
+
+	naddr = seq_get_ports_from_desc(portdesc, addrp);
+
+	return naddr;
+
+
diff -rNu melys-0.0.4/doc/mdml.dtd melys-0.0.5/doc/mdml.dtd
--- melys-0.0.4/doc/mdml.dtd	Sat Jul 24 11:03:11 1999
+++ melys-0.0.5/doc/mdml.dtd	Fri Aug  6 11:54:42 1999
@@ -1,3 +1,12 @@
+<!--
+	 This is version 1.1 of the MDML specification.
+
+	 Copyright (C) 1998, 1999 Steve Ratcliffe <steve@parabola.demon.co.uk>
+
+	 MDML is an XML representation of musical data for sequencers and
+	 similar programs.
+
+-->
 
 <!-- The events that go into the tempo map -->
 <!ENTITY % events.tempo "tempo | timesignature | keysignature | smpteoffset">
@@ -33,17 +42,28 @@
 <!ATTLIST track
 	%att.common;
 	duration    CDATA       #IMPLIED
+	name        CDATA       #IMPLIED
 	>
 
 <!-- The 'part' element is used for spitting up tracks.
+	 The ability to nest parts was removed from the dtd, but as the
+	 code already allows it, then this has been returned.
+
+	 Parts can be named and, in a future revision of this
+	 specification, be refered to by name elsewhere in the
+	 composition.
+
+	 It is possible that this will be redifined to allow events and
+	 parts to be mixed.  At present you must either have a set
+	 of sub-parts or a set of events.
 -->
-<!ELEMENT part ((%events.track;)* | take+)>
+<!ELEMENT part ((%events.track;)* | take+ | part+)>
 <!ATTLIST part
 	%att.common;
 	duration    CDATA       #IMPLIED
+	name        CDATA       #IMPLIED
 	><!--
 	Will include:
-	  name        to allow others to reference
 	  ref         to allow this to reference others
 	  transpose
 	  velocity.offset
diff -rNu melys-0.0.4/files/.cvsignore melys-0.0.5/files/.cvsignore
--- melys-0.0.4/files/.cvsignore	Fri Jul 30 00:43:12 1999
+++ melys-0.0.5/files/.cvsignore	Mon Aug  9 00:51:27 1999
@@ -4,6 +4,5 @@
 midiread.c
 midiwrite.c
 Makefile
-*.mdml
-*.mid
+*.mdml *.mdml.gz *.mid
 .cvsignore
diff -rNu melys-0.0.4/files/format.c melys-0.0.5/files/format.c
--- melys-0.0.4/files/format.c	Fri Jul 30 00:43:17 1999
+++ melys-0.0.5/files/format.c	Mon Aug  9 00:51:33 1999
@@ -54,6 +54,7 @@
 		{".mid", "midi"},
 		{".smf", "midi"},
 		{".mdml", "mdml"},
+		{".mdml.gz", "mdml"},
 	};
 	struct exttable *ep;
 
diff -rNu melys-0.0.4/files/format.m melys-0.0.5/files/format.m
--- melys-0.0.4/files/format.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/files/format.m	Fri Aug  6 11:53:31 1999
@@ -0,0 +1,160 @@
+>>name format.m - Routines to deal with different file formats
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+>>header <stdio.h>
+>>header util.h
+>>header mdrw.h
+>>header midi.h
+>>extern
+
+struct typefuncs {
+	char *type;	/* Type of file */
+	fileReadFunc read; /* Read function */
+	fileWriteFunc write; /* Write function */
+};
+struct typefuncs typefuncs[] = {
+	{"midi", midi_read_file, midi_write_file},
+	{"mdml", mdml_read_file, mdml_write_file},
+};
+
+>>headerdef --decl format.h
+
+typedef struct rootElement *(*fileReadFunc)(char *name);
+typedef void (*fileWriteFunc)(char *name, struct rootElement *root, int flags);
+
+>>function file_guess_type
+char *
+char *filename; Filename to guess the type of
+
+>>description
+Take the filename and guess the type of the file.
+First will look at the extension and then may use magic
+numbers in the file to deduce the type.
+
+>>code
+	static struct exttable {
+		char *ext;  /* Extension */
+		char *type; /* Type */
+	} exttable[] = {
+		{".mid", "midi"},
+		{".smf", "midi"},
+		{".mdml", "mdml"},
+		{".mdml.gz", "mdml"},
+	};
+	struct exttable *ep;
+
+	for (ep = exttable; ep < exttable+NELEM(exttable); ep++) {
+		int  off;
+
+		off = strlen(filename) - strlen(ep->ext);
+		if (off > 0)
+			if (strcmp(filename+off, ep->ext) == 0)
+				return ep->type;
+	}
+
+	return NULL;
+
+
+
+>>function file_get_read_func
+fileReadFunc
+char *type;  Type of file to be read
+>>description
+Returns the function used to read the file of a specified type.
+>>code
+	struct typefuncs *tp;
+
+	if (type == NULL)
+		return NULL;
+
+	for (tp = typefuncs; tp < typefuncs+NELEM(typefuncs); tp++) {
+		if (strcmp(tp->type, type) == 0)
+			return tp->read;
+	}
+	return NULL;
+
+>>function file_get_write_func
+fileWriteFunc
+char *type;  Type of file to be written
+>>description
+Return the function used to read the file of the specified type.
+>>code
+	struct typefuncs *tp;
+
+	if (type == NULL)
+		return NULL;
+
+	for (tp = typefuncs; tp < typefuncs+NELEM(typefuncs); tp++) {
+		if (strcmp(tp->type, type) == 0)
+			return tp->write;
+	}
+	return NULL;
+
+>>function file_guess_read_func
+fileReadFunc
+char *filename;   Filename to be read
+>>description
+Returns read function based on the filename.
+>>code
+	char *type;
+
+	type = file_guess_type(filename);
+	return file_get_read_func(type);
+
+>>function file_guess_write_func
+fileWriteFunc
+char *filename;   Filename to be writen
+>>description
+Returns write function based on the filename.
+>>code
+	char *type;
+
+	type = file_guess_type(filename);
+	return file_get_write_func(type);
+
+
+>>function file_guess_read_with_msg
+struct rootElement *
+char *filename;      File to read
+char **errmsg;        An error message to be displayed.
+
+>>description
+Read in the file
+.A filename .
+On error NULL is returned and a message is returned into
+.A errmsg .
+
+>>code
+	char *type;
+	struct rootElement *root;
+	fileReadFunc readfn;
+
+	*errmsg = NULL;
+
+	type = file_guess_type(filename);
+	if (type == NULL) {
+		*errmsg = _("Unrecognised file type");
+		return NULL;
+	}
+
+	readfn = file_get_read_func(type);
+	if (readfn == NULL) {
+		*errmsg = _("Unrecognised file type");
+		return NULL;
+	}
+
+	root = readfn(filename);
+
+	if (root == NULL)
+		*errmsg = _("Could not read file");
+		
+	return root;
diff -rNu melys-0.0.4/files/mdmlread.c melys-0.0.5/files/mdmlread.c
--- melys-0.0.4/files/mdmlread.c	Fri Jul 30 00:43:17 1999
+++ melys-0.0.5/files/mdmlread.c	Mon Aug  9 00:51:33 1999
@@ -52,7 +52,7 @@
 static double get_double(xmlNodePtr node, char *name);
 static int get_note(xmlNodePtr node, char *name);
 static unsigned char *get_hex_data(char *hexchars, int *lenp);
-static void init_sax_handler();
+static void init_sax_handler(void);
 
 
 /*
@@ -78,6 +78,9 @@
 	init_sax_handler();
 	doc = xmlSAXParseFile(NULL, filename, 0);
 
+	if (doc == NULL)
+		return NULL;
+
 	root = MD_ROOT(node_to_md(&mstate, doc->root));
 	xmlFreeDoc(doc);
 
@@ -182,10 +185,13 @@
 		msp->head->comment = xmlNodeGetContent(node);
 
 	} else if (strcmp(name, "track") == 0) {
+		struct trackElement *tp;
 		msp->currtime = 0;
 		msp->maxtime = 0;
 		msp->devchan = 0;
-		retel = MD_ELEMENT(md_track_new());
+		tp = md_track_new();
+		tp->name = xmlGetProp(node, "name");
+		retel = MD_ELEMENT(tp);
 
 	} else if (strcmp(name, "tempomap") == 0) {
 		struct tempomapElement *tmap;
@@ -195,6 +201,7 @@
 	} else if (strcmp(name, "part") == 0) {
 		struct partElement *pp;
 		pp = md_part_new();
+		pp->name = xmlGetProp(node, "name");
 		retel = MD_ELEMENT(pp);
 
 	} else if (strcmp(name, "tempo") == 0) {
@@ -305,11 +312,13 @@
 	}
 
 	if (retel && iscontainer(retel)) {
-		unsigned long dur;
-		dur = msp->maxtime - retel->element_time;
+		unsigned long dur = 0;
+
+		if (msp->maxtime > retel->element_time)
+			dur = msp->maxtime - retel->element_time;
 		if (MD_CONTAINER(retel)->duration > dur)
 			dur = MD_CONTAINER(retel)->duration;
-		//msp->currtime = msp->maxtime;
+
 		MD_CONTAINER(retel)->duration = dur;
 		msp->currtime = msp->starttime + dur;
 		msp->starttime = ostart;
@@ -503,7 +512,7 @@
  * 
  */
 static void 
-init_sax_handler()
+init_sax_handler(void)
 {
 
 #if 0
diff -rNu melys-0.0.4/files/mdmlread.m melys-0.0.5/files/mdmlread.m
--- melys-0.0.4/files/mdmlread.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/files/mdmlread.m	Mon Aug  9 00:05:59 1999
@@ -0,0 +1,509 @@
+>>name mdmlread.m Read in a mdml file
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+TODO: libxml 1.1.0 now has a working SAX parser, so this could
+      all be moved over to use that.
+
+>>extern
+>>header <stdio.h>
+>>header <gnome-xml/tree.h>
+>>header <gnome-xml/parser.h>
+>>header <string.h>
+>>header md.h
+
+xmlSAXHandler  SAXhandler;
+
+struct mdmlstate {
+	int  currtime;	/* Previous time */
+	int  starttime;	/* Start time for this sub-part */
+	int  maxtime;	/* Max time for this sub-part */
+	int  devchan;	/* Current dev/channel */
+	struct rootElement *root; /* Pointer to root of MD tree */
+	struct headElement *head; /* Pointer to head element */
+	GArray *toffsets;	/* Time offsets for each container level */
+	int  level;		/* Container level */
+};
+
+>>headerdef --decl mdrw.h
+
+>>function mdml_read_file
+struct rootElement *
+char *filename;  Filename to be read in
+
+>>description
+Read in an mdml file given the filename.
+A pointer to a rootElement is returned.
+This really needs to use a SAX parser.
+At present it builds an extremely large document tree which is 
+simply thrown away, but not before it has expanded the memory
+usage of the program beyond reasonable bounds for large files.
+>>code
+	xmlDocPtr doc;
+	struct rootElement *root;
+	struct mdmlstate mstate;
+
+	memset(&mstate, 0, sizeof(mstate));
+	mstate.toffsets = g_array_new(0, 0, sizeof(unsigned long));
+
+	init_sax_handler();
+	doc = xmlSAXParseFile(NULL, filename, 0);
+
+	if (doc == NULL)
+		return NULL;
+
+	root = MD_ROOT(node_to_md(&mstate, doc->root));
+	xmlFreeDoc(doc);
+
+	return root;
+
+>>header <stdlib.h>
+>>header midi.h
+>>function node_to_md
+static struct element *
+struct mdmlstate *msp;  Mdml write state
+xmlNodePtr node;  XML document to convert, or subnode in it
+
+>>description
+Take an XML document tree and convert it to an MD tree.
+Will be converted to use the SAX interface when that is ready.
+
+>>code
+	struct element *retel = NULL;
+	xmlNodePtr child;
+	const char *name;
+	unsigned long ostart = 0;
+
+	if (node->type != XML_ELEMENT_NODE)
+		return NULL;
+
+	name = node->name;
+
+	/*
+	 * Its slightly important to have the most likely
+	 * matches appear at the top.
+	 */
+	if (strcmp(name, "note") == 0) {
+		struct noteElement *note;
+		int  off;
+
+		note = md_note_new(get_note(node, "n"), get_int(node, "v"),
+			get_int(node, "len"));
+		off = get_int(node, "off");
+		if (off > 0)
+			note->offvel = off;
+
+		retel = MD_ELEMENT(note);
+
+	} else if (strcmp(name, "control") == 0) {
+		retel = MD_ELEMENT(md_control_new(get_int(node, "n"),
+				  get_int(node, "v")));
+
+	} else if (strcmp(name, "program") == 0) {
+		retel = MD_ELEMENT(md_program_new(get_int(node, "program")));
+
+	} else if (strcmp(name, "pitch") == 0) {
+		retel = MD_ELEMENT(md_pitch_new(get_int(node, "p")));
+
+	} else if (strcmp(name, "keytouch") == 0) {
+		retel = MD_ELEMENT(
+			md_keytouch_new(get_int(node, "n"), get_int(node, "v")));
+
+	} else if (strcmp(name, "pressure") == 0) {
+		retel = MD_ELEMENT( md_pressure_new(get_int(node, "v")));
+
+	} else if (strcmp(name, "sysex") == 0) {
+		struct sysexElement *sep;
+		unsigned char *data;
+		int  len;
+
+		data = get_hex_data(xmlNodeGetContent(node->childs), &len);
+		sep = md_sysex_new(data[0], data+1, len - 1);
+
+		retel = MD_ELEMENT(sep);
+
+	} else if (strcmp(name, "mdml") == 0) {
+		struct rootElement *root;
+		root = md_root_new();
+		msp->root = root;
+		retel = MD_ELEMENT(root);
+
+	} else if (strcmp(name, "head") == 0) {
+		msp->head = md_head_new();
+		msp->root->head = msp->head;
+		retel = MD_ELEMENT(msp->head);
+
+	} else if (strcmp(name, "version") == 0) {
+		msp->head->ver_major = get_int(node, "major");
+		msp->head->ver_minor = get_int(node, "minor");
+
+	} else if (strcmp(name, "format") == 0) {
+		msp->head->format = get_int(node, "type");
+
+	} else if (strcmp(name, "timebase") == 0) {
+		msp->head->time_base = get_int(node, "division");
+
+	} else if (strcmp(name, "COPYRIGHT") == 0) {
+		msp->head->copyright = g_strdup(xmlNodeGetContent(node));
+
+	} else if (strcmp(name, "title") == 0) {
+		msp->head->title = xmlNodeGetContent(node);
+
+	} else if (strcmp(name, "author") == 0) {
+		msp->head->author = xmlNodeGetContent(node);
+
+	} else if (strcmp(name, "comment") == 0) {
+		msp->head->comment = xmlNodeGetContent(node);
+
+	} else if (strcmp(name, "track") == 0) {
+		struct trackElement *tp;
+		msp->currtime = 0;
+		msp->maxtime = 0;
+		msp->devchan = 0;
+		tp = md_track_new();
+		tp->name = xmlGetProp(node, "name");
+		retel = MD_ELEMENT(tp);
+
+	} else if (strcmp(name, "tempomap") == 0) {
+		struct tempomapElement *tmap;
+		tmap = md_tempomap_new();
+		retel = MD_ELEMENT(tmap);
+
+	} else if (strcmp(name, "part") == 0) {
+		struct partElement *pp;
+		pp = md_part_new();
+		pp->name = xmlGetProp(node, "name");
+		retel = MD_ELEMENT(pp);
+
+	} else if (strcmp(name, "tempo") == 0) {
+		struct tempoElement *tp;
+		int  us;
+		double bpm;
+		bpm = get_double(node, "bpm");
+		if (bpm) {
+			us = 60000000/bpm;
+			tp = md_tempo_new(us);
+			retel = MD_ELEMENT(tp);
+		}
+
+	} else if (strcmp(name, "timesignature") == 0) {
+		struct timesigElement *tsp;
+		int  top, bottom;
+		int  clocks, n32pq;
+		CHAR *prop;
+
+		prop = xmlGetProp(node, "signature");
+		sscanf(prop, "%d/%d", &top, &bottom);
+		clocks = get_int(node, "clocks");
+		n32pq = get_int(node, "n32PerQuarter");
+
+		tsp = md_timesig_new(top, bottom, clocks, n32pq);
+		retel = MD_ELEMENT(tsp);
+		
+	} else if (strcmp(name, "keysignature") == 0) {
+		struct keysigElement *ksp;
+		CHAR *key;
+		CHAR *mode;
+		int  m;
+
+		key = xmlGetProp(node, "key");
+		mode = xmlGetProp(node, "mode");
+		if (mode && strcmp(mode, "minor") == 0)
+			m = 1;
+		else
+			m = 0;
+
+		ksp = md_keysig_new(atoi(key), m);
+		retel = MD_ELEMENT(ksp);
+
+	} else if (strcmp(name, "smpte") == 0) {
+		CHAR *off;
+		struct smpteoffsetElement *sp;
+		int  hours, minutes, seconds, frames, subframes;
+
+		off = xmlGetProp(node, "offset");
+		if (off == NULL)
+			ethrow(formatError, "No offset property for smpte element");
+
+		sscanf(off, "%d:%d:%d:%d:%d", &hours, &minutes, &seconds, &frames,
+			&subframes);
+
+		sp = md_smpteoffset_new(hours, minutes, seconds, frames, subframes);
+		retel = MD_ELEMENT(sp);
+
+	} else if (strcmp(name, "text") == 0) {
+		retel = MD_ELEMENT(md_text_new(MIDI_META_TEXT,
+			xmlNodeGetContent(node)));
+
+	} else if (strcmp(name, "copyright") == 0) {
+		retel = MD_ELEMENT(md_text_new(MIDI_META_COPYRIGHT,
+			xmlNodeGetContent(node)));
+
+	} else if (strcmp(name, "trackname") == 0) {
+		retel = MD_ELEMENT(md_text_new(MIDI_META_TRACKNAME,
+			xmlNodeGetContent(node)));
+
+	} else if (strcmp(name, "instrument") == 0) {
+		retel = MD_ELEMENT(md_text_new(MIDI_META_INSTRUMENT,
+			xmlNodeGetContent(node)));
+
+	} else if (strcmp(name, "lyric") == 0) {
+		retel = MD_ELEMENT(md_text_new(MIDI_META_LYRIC,
+			xmlNodeGetContent(node)));
+
+	} else if (strcmp(name, "marker") == 0) {
+		retel = MD_ELEMENT(md_text_new(MIDI_META_MARKER,
+			xmlNodeGetContent(node)));
+
+	} else if (strcmp(name, "cuepoint") == 0) {
+		retel = MD_ELEMENT(md_text_new(MIDI_META_CUE,
+			xmlNodeGetContent(node)));
+
+	} else {
+		printf("Unknown node name %s\n", name);
+		return NULL;
+	}
+
+	/* Set common attributes like time */
+	common_atts(msp, node, retel);	
+
+	if (retel && iscontainer(retel)) {
+		ostart = msp->starttime;
+		msp->starttime = msp->currtime;
+		msp->maxtime = 0;
+	}
+
+	for (child = node->childs; child; child = child->next) {
+		struct element *el;
+
+		el = node_to_md(msp, child);
+		if (el == NULL)
+			continue;
+		md_add(MD_CONTAINER(retel), el);
+	}
+
+	if (retel && iscontainer(retel)) {
+		unsigned long dur = 0;
+
+		if (msp->maxtime > retel->element_time)
+			dur = msp->maxtime - retel->element_time;
+		if (MD_CONTAINER(retel)->duration > dur)
+			dur = MD_CONTAINER(retel)->duration;
+
+		MD_CONTAINER(retel)->duration = dur;
+		msp->currtime = msp->starttime + dur;
+		msp->starttime = ostart;
+	}
+
+	return retel;
+
+
+>>function common_atts
+static void
+struct mdmlstate *msp;
+xmlNodePtr node; Node to examine for attributes
+struct element *el; Element to set attributes
+
+>>description
+Extract common attributes from the node.
+These are things like time and channel that can apply
+to almost any element.
+
+>>code
+	int  ival;
+	unsigned long t;
+
+	if (node == NULL || el == NULL)
+		return;
+
+	ival = get_int(node, "t");
+	if (ival == -1)
+		ival = msp->currtime;
+	else
+		msp->currtime = msp->starttime + ival;
+	el->element_time = msp->currtime;
+
+	/*
+	 * Update the max time for this container.
+	 */
+	t = el->element_time;
+	if (el->type == MD_TYPE_NOTE)
+		t += MD_NOTE(el)->length; /* Add the length */
+	if (t > msp->maxtime)
+		msp->maxtime = t;
+
+	ival = get_int(node, "channel");
+	if (ival == -1)
+		ival = msp->devchan+1;
+	else
+		msp->devchan = ival-1;
+	el->device_channel = ival-1;
+
+	ival = get_int(node, "duration");
+	if (ival != -1)
+		MD_CONTAINER(el)->duration = ival;
+
+>>function get_int
+static int
+xmlNodePtr node; Node to be examined
+char *name; Name of attribute
+
+>>description
+Return an attribute, converted to an integer.
+If the attribute does not exist then -1 is returned.
+
+>>code
+	CHAR *cp;
+
+	cp = xmlGetProp(node, name);
+	if (cp == NULL)
+		return -1;
+
+	return atoi(cp);
+
+>>function get_double
+static double
+xmlNodePtr node;  Node to get property from
+char  *name;      Name of property to get
+>>description
+Get a property from a node and convert it to a double value.
+
+>>code
+	CHAR *cp;
+
+	cp = xmlGetProp(node, name);
+	if (cp == NULL)
+		return 0.0;
+
+	return strtod(cp, NULL);
+
+
+>>function get_note
+static int
+xmlNodePtr node;  Node for this note
+char *name;       Name of property to get
+>>description
+Get the note value from the specified note name.
+
+>>code
+	CHAR *note;
+	int  base;
+	int  oct;
+	CHAR *cp;
+
+	note = xmlGetProp(node, name);
+	if (note == NULL)
+		return 0;
+
+	switch (note[0]) {
+	case 'A': case 'a':
+		base = 9;
+		break;
+	case 'B': case 'b':
+		base = 11;
+		break;
+	case 'C': case 'c':
+		base = 0;
+		break;
+	case 'D': case 'd':
+		base = 2;
+		break;
+	case 'E': case 'e':
+		base = 4;
+		break;
+	case 'F': case 'f':
+		base = 5;
+		break;
+	case 'G': case 'g':
+		base = 7;
+		break;
+	case '0': case '1': case '2': case '3': case '4':
+	case '5': case '6': case '7': case '8': case '9':
+		// This is not really a name at all
+		return atoi(note);
+	default:
+		base = 0;
+		break;
+	}
+	
+	cp = note;
+	cp++;
+	if (*cp == '#') {
+		base++;
+		cp++;
+	}
+	oct = atoi(cp);
+
+	return base + oct*12;
+
+
+>>function get_hex_data
+static unsigned char *
+char *hexchars;  Input ascii hex characters
+int  *lenp;	     Length of returned array
+
+>>description
+Parse the text representation of the sysex and return a newly
+allocated buffer containing the data.
+
+>>code
+	GByteArray *ba;
+	guint8 uc;
+	unsigned char *val;
+	char *cp;
+
+	ba = g_byte_array_new();
+
+	for (cp = strtok(hexchars, " \t,"); cp; cp = strtok(NULL, " \t,")) {
+		uc = (guint8)strtol(cp, NULL, 16);
+		g_byte_array_append(ba, &uc, 1);
+	}
+	val = ba->data;
+	*lenp = ba->len;
+	g_byte_array_free(ba, 0);
+
+	return val;
+
+
+>># --- SAX handler functions
+
+>>function init_sax_handler
+static void
+
+>>description
+Initialise the SAX handler callback set.
+This only needs to be done once.
+
+There seems to be no point in doing this.
+The whole point of using an event driver interface is to avoid building
+up a tree in memory, but gnome-xml appears to do this anyway.
+So we may as well just traverse that.
+
+>>code
+
+#if 0
+    SAXhandler.resolveEntity = NULL;
+    SAXhandler.notationDecl = NULL;
+    SAXhandler.unparsedEntityDecl = NULL;
+    SAXhandler.setDocumentLocator = NULL;
+    SAXhandler.startDocument = NULL;
+    SAXhandler.endDocument = NULL;
+    SAXhandler.startElement = NULL;
+    SAXhandler.endElement = NULL;
+    SAXhandler.attribute = NULL;
+    SAXhandler.characters = NULL;
+    SAXhandler.ignorableWhitespace = NULL;
+    SAXhandler.processingInstruction = NULL;
+    SAXhandler.warning = NULL;
+    SAXhandler.error = NULL;
+    SAXhandler.fatalError = NULL;
+#endif
diff -rNu melys-0.0.4/files/mdmlwrite.c melys-0.0.5/files/mdmlwrite.c
--- melys-0.0.4/files/mdmlwrite.c	Fri Jul 30 00:43:17 1999
+++ melys-0.0.5/files/mdmlwrite.c	Mon Aug  9 00:51:33 1999
@@ -46,9 +46,10 @@
  *  Arguments:
  *    fp        - File stream to write to
  *    root      - Tree to write
+ *    flags     - Compressed etc.
  */
 void 
-mdml_write(FILE *fp, struct rootElement *root)
+mdml_write(FILE *fp, struct rootElement *root, int flags)
 {
 	xmlDocPtr doc;
 	xmlNodePtr node;
@@ -107,6 +108,8 @@
 			mstate.devchan  = 0;
 			xtrack = xmlNewChild(doc->root, 0, "track", 0);
 			set_prop_int(xtrack, "duration", MD_CONTAINER(el)->duration);
+			if (MD_TRACK(el)->name)
+				xmlSetProp(xtrack, "name", MD_TRACK(el)->name);
 			mstate.starttime = 0;
 			build_section(&mstate, xtrack, MD_CONTAINER(el));
 			break;
@@ -158,7 +161,7 @@
 	if (fp == NULL)
 		ethrow(ioError, _("Could not open file"));
 
-	mdml_write(fp, root);
+	mdml_write(fp, root, flags);
 
 	fclose(fp);
 }
@@ -277,6 +280,8 @@
 		case MD_TYPE_PART:
 			node = xmlNewChild(base, 0, "part", 0);
 			set_prop_int(node, "duration", MD_CONTAINER(el)->duration);
+			if (MD_PART(el)->name)
+				xmlSetProp(node, "name", MD_PART(el)->name);
 			build_section(msp, node, MD_CONTAINER(el));
 			break;
 		default:
diff -rNu melys-0.0.4/files/mdmlwrite.m melys-0.0.5/files/mdmlwrite.m
--- melys-0.0.4/files/mdmlwrite.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/files/mdmlwrite.m	Fri Aug  6 11:53:31 1999
@@ -0,0 +1,364 @@
+>>name mdmlwrite.m
+
+File: mdmlwrite.m - Write out the current song in mdml format.
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+>>extern
+
+struct mdmlstate {
+	unsigned long  lasttime;	/* Last event time */
+	int  devchan;	/* Current device channel */
+	unsigned long  starttime;	/* Use to do relative times */
+};
+
+>>header <stdio.h>
+
+>>headerdef --decl mdrw.h
+
+>>function mdml_write
+void
+  FILE *fp;		// File stream to write to
+  struct rootElement *root;	// Tree to write
+  int flags;    Compressed etc.
+
+>>description
+Writes the MDML representation of the specified MD tree to
+the specified file stream.
+>>header gnome-xml/tree.h
+>>code
+	xmlDocPtr doc;
+	xmlNodePtr node;
+	xmlNodePtr head;
+	xmlNodePtr xtrack;
+	struct mdmlstate mstate;
+	struct element *el;
+	struct containerElement *c;
+	int  i;
+
+	mstate.lasttime = 0;
+	mstate.devchan  = 0;
+
+	doc = xmlNewDoc("1.0");
+	node = xmlNewDocNode(doc, 0, "mdml", 0);
+	doc->root = node;
+
+	/* Now build all the top level elements */
+	c = MD_CONTAINER(root);
+	for (i = 0; i < c->elements->len; i++) {
+		el = g_ptr_array_index(c->elements, i);
+
+		switch (el->type) {
+		case MD_TYPE_HEAD:
+			{
+			struct headElement *headel;
+
+			headel = MD_HEAD(el);
+
+			/* Build the <head> element */
+			head = xmlNewChild(node, 0, "head", 0);
+			if (headel->copyright)
+				node = xmlNewChild(head, 0, "COPYRIGHT", headel->copyright);
+
+			node = xmlNewChild(head, 0, "version", 0);
+			set_prop_int(node, "major", MDML_VERSION_MAJOR);
+			set_prop_int(node, "minor", MDML_VERSION_MINOR);
+
+			node = xmlNewChild(head, 0, "format", 0);
+			set_prop_int(node, "type", headel->format);
+			node = xmlNewChild(head, 0, "timebase", 0);
+			set_prop_int(node, "division", headel->time_base);
+
+			if (headel->title)
+				node = xmlNewChild(head, 0, "title", headel->title);
+			if (headel->author)
+				node = xmlNewChild(head, 0, "author", headel->author);
+			if (headel->comment)
+				node = xmlNewChild(head, 0, "comment", headel->comment);
+
+			}
+			break;
+
+		case MD_TYPE_TRACK:
+			mstate.lasttime = 0;
+			mstate.devchan  = 0;
+			xtrack = xmlNewChild(doc->root, 0, "track", 0);
+			set_prop_int(xtrack, "duration", MD_CONTAINER(el)->duration);
+			if (MD_TRACK(el)->name)
+				xmlSetProp(xtrack, "name", MD_TRACK(el)->name);
+			mstate.starttime = 0;
+			build_section(&mstate, xtrack, MD_CONTAINER(el));
+			break;
+		case MD_TYPE_TEMPOMAP:
+			xtrack = xmlNewChild(doc->root, 0, "tempomap", 0);
+			mstate.starttime = 0;
+			build_section(&mstate, xtrack, MD_CONTAINER(el));
+			break;
+		default:
+			ethrow(debugError, "Unknown element type (%d) in @func_name",
+				el->type);
+			break;
+		}
+	}
+
+#define XML_MEM_LEAK_BUG
+#ifdef XML_MEM_LEAK_BUG
+	{
+	CHAR *mem;
+	int  size;
+
+	xmlDocDumpMemory(doc, &mem, &size);
+	fwrite(mem, size, 1, fp);
+	g_free(mem);
+	}
+#else
+	/* There is a bad memory leak with this, re-instate when fixed
+	 * in gnome
+	 */
+	xmlDocDump(fp, doc);
+#endif
+	xmlFreeDoc(doc);
+
+>>function mdml_write_file
+void
+  char *name;		// File name to write to
+  struct rootElement *root;	// Tree to write
+  int  flags;   Flags to control write
+>>description
+Writes the MDML representation of the MD tree to the
+specified file
+.A name .
+>>code
+	FILE *fp;
+
+	fp = fopen(name, "w");
+	if (fp == NULL)
+		ethrow(ioError, _("Could not open file"));
+
+	mdml_write(fp, root, flags);
+
+	fclose(fp);
+
+
+>>function build_section
+static void
+struct mdmlstate *msp;  // Current state
+xmlNodePtr base;	// Base of xml tree
+struct containerElement *c;	// md tree for a track
+
+>>description
+Deal with one track from a MD tree.
+The xml tree is built under the given
+.A base .
+
+>>code
+	int  i;
+	int  elind;
+	xmlNodePtr node;
+	struct element *el;
+	unsigned long ostart;
+
+	ostart = msp->starttime;
+	msp->starttime = MD_ELEMENT(c)->element_time;
+
+	for (elind = 0; elind < c->elements->len; elind++) {
+		el = g_ptr_array_index(c->elements, elind);
+
+		node = NULL;
+		switch (el->type) {
+		case MD_TYPE_NOTE:
+			node = xmlNewChild(base, 0, "note", 0);
+			set_prop_and_free(node, "n", note_name(MD_NOTE(el)->note));
+			set_prop_int(node, "v", MD_NOTE(el)->vel);
+			set_prop_int(node, "len", MD_NOTE(el)->length);
+			if (MD_NOTE(el)->offvel > 0)
+				set_prop_int(node, "off", MD_NOTE(el)->offvel);
+			break;
+		case MD_TYPE_CONTROL:
+			node = xmlNewChild(base, 0, "control", 0);
+			set_prop_int(node, "n", MD_CONTROL(el)->control);
+			set_prop_int(node, "v", MD_CONTROL(el)->value);
+			break;
+		case MD_TYPE_PROGRAM:
+			node = xmlNewChild(base, 0, "program", 0);
+			set_prop_int(node, "program", MD_PROGRAM(el)->program);
+			break;
+		case MD_TYPE_PITCH:
+			node = xmlNewChild(base, 0, "pitch", 0);
+			set_prop_int(node, "p", MD_PITCH(el)->pitch);
+			break;
+		case MD_TYPE_KEYTOUCH:
+			node = xmlNewChild(base, 0, "keytouch", 0);
+			set_prop_int(node, "n", MD_KEYTOUCH(el)->note);
+			set_prop_int(node, "v", MD_KEYTOUCH(el)->velocity);
+			break;
+		case MD_TYPE_PRESSURE:
+			node = xmlNewChild(base, 0, "pressure", 0);
+			set_prop_int(node, "v", MD_PRESSURE(el)->velocity);
+			break;
+		case MD_TYPE_TEXT:	
+			node = xmlNewChild(base, 0, MD_TEXT(el)->name, MD_TEXT(el)->text);
+			break;
+		case MD_TYPE_SMPTEOFFSET:
+			node = xmlNewChild(base, 0, "smpte", 0);
+			set_prop_and_free(node, "offset",
+				g_strdup_printf("%d:%d:%d:%d:%d",
+				MD_SMPTEOFFSET(el)->hours,
+				MD_SMPTEOFFSET(el)->minutes,
+				MD_SMPTEOFFSET(el)->seconds,
+				MD_SMPTEOFFSET(el)->frames,
+				MD_SMPTEOFFSET(el)->subframes
+				));
+			break;
+		case MD_TYPE_TEMPO:
+			{
+			double bpm;
+
+			node = xmlNewChild(base, 0, "tempo", 0);
+			bpm = (double)60000000 / MD_TEMPO(el)->micro_tempo;
+			set_prop_and_free(node, "bpm", g_strdup_printf("%.1f", bpm));
+			}
+			break;
+		case MD_TYPE_TIMESIG:
+			node = xmlNewChild(base, 0, "timesignature", 0);
+			set_prop_and_free(node, "signature",
+				g_strdup_printf("%d/%d",
+					MD_TIMESIG(el)->top, MD_TIMESIG(el)->bottom));
+			set_prop_int(node, "clocks", MD_TIMESIG(el)->clocks);
+			set_prop_int(node, "n32PerQuarter", MD_TIMESIG(el)->n32pq);
+			break;
+		case MD_TYPE_KEYSIG:
+			node = xmlNewChild(base, 0, "keysignature", 0);
+			set_prop_int(node, "key", MD_KEYSIG(el)->key);
+			xmlSetProp(node, "mode", MD_KEYSIG(el)->minor? "minor": "major");
+			break;
+		case MD_TYPE_SYSEX:
+			{
+			struct sysexElement *se = MD_SYSEX(el);
+			GString *s = g_string_new("");
+			gchar *status = g_strdup_printf("%02x", se->status);
+			gchar *stmp;
+
+			g_string_append(s, status);
+			g_free(status);
+			for (i = 0; i < se->length; i++) {
+				stmp = g_strdup_printf(" %02x", se->data[i]);
+				g_string_append(s, stmp);
+				g_free(stmp);
+			}
+			node = xmlNewChild(base, 0, "sysex", s->str);
+			g_string_free(s, 0);
+			}
+			break;
+		case MD_TYPE_PART:
+			node = xmlNewChild(base, 0, "part", 0);
+			set_prop_int(node, "duration", MD_CONTAINER(el)->duration);
+			if (MD_PART(el)->name)
+				xmlSetProp(node, "name", MD_PART(el)->name);
+			build_section(msp, node, MD_CONTAINER(el));
+			break;
+		default:
+			printf("Unimplemented %d element in @func_name\n", el->type);
+			break;
+		}
+
+		if (node)
+			set_time_chan(msp, node, el);
+	}
+
+	msp->starttime = ostart;
+
+>>function set_time_chan
+static void
+struct mdmlstate *msp;  Current state including current time and channel
+xmlNodePtr node;	The xml node to set the attribute on
+struct element *el; the md element with time and channel info.
+
+>>description
+Fills in the time and channel attributes.
+These attributes do not appear it they are the same as the previous
+values.
+This applies completely across the file, including track changes etc.
+
+>>code
+	unsigned long t;
+
+	t = el->element_time - msp->starttime;
+	//if (t != msp->lasttime) {
+		set_prop_int(node, "t", t);
+		msp->lasttime = t;
+	//}
+	if (el->device_channel != msp->devchan) {
+		set_prop_int(node, "channel", el->device_channel+1);
+		msp->devchan = el->device_channel;
+	}
+
+>>function set_prop_int
+static void
+xmlNodePtr node; // the xml node
+char *name;	// Name of property
+int  n;		// value of property
+>>description
+Set a property from an integer value.
+>>code
+	gchar *cp;
+
+	cp = g_strdup_printf("%d", n);
+	xmlSetProp(node, name, cp);
+	g_free(cp);
+
+>>function set_prop_and_free
+static void
+xmlNodePtr node; // the xml node
+char *name;	// Name of property
+char  *cp;	// value of property and will be freed
+>>description
+Set a property from a string and free the string.
+>>code
+
+	xmlSetProp(node, name, cp);
+	g_free(cp);
+
+
+>>function note_name
+static char *
+int  note;	// Note number
+>>description
+Return a text representation of a note given the midi note
+number.
+There are different naming schemes around, this one gives C0 for note 0.
+This result will be of the form G4, C#3 etc.
+>>code
+	char *note_names = "CCDDEFFGGAAB";
+	char *sharps = " # #  # # # ";
+	GString *s;
+	char ch;
+	char *octave;
+	char *ret;
+
+	/* Base note */
+	s = g_string_new("");
+	g_string_append_c(s, note_names[note % 12]);
+
+	/* Add a sharp sign if needed */
+	ch = sharps[note % 12];
+	if (ch == '#')
+		g_string_append_c(s, '#');
+
+	/* Add the octave number */
+	octave = g_strdup_printf("%d", note/12);
+	g_string_append(s, octave);
+	g_free(octave);
+
+	ret = s->str;
+	g_string_free(s, 0);
+
+	return ret;
diff -rNu melys-0.0.4/files/midiread.c melys-0.0.5/files/midiread.c
--- melys-0.0.4/files/midiread.c	Fri Jul 30 00:43:17 1999
+++ melys-0.0.5/files/midiread.c	Mon Aug  9 00:51:34 1999
@@ -601,7 +601,8 @@
 				n->length = 0;
 			}
 			g_ptr_array_remove_index_fast(notes, i);
-			break;
+
+			/* Do not break here, there may be more than one */
 		}
 	}
 }
diff -rNu melys-0.0.4/files/midiread.m melys-0.0.5/files/midiread.m
--- melys-0.0.4/files/midiread.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/files/midiread.m	Mon Aug  2 15:36:09 1999
@@ -0,0 +1,621 @@
+>>name midiread.m
+
+File: midiread.m - Read in a midi file.
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+>>extern
+
+>>header <stdio.h>
+
+>>headerdef --decl midi.h
+/*
+ * Midi status byte values.
+ */
+#define MIDI_NOTE_OFF	0x80
+#define MIDI_NOTE_ON	0x90
+#define MIDI_KEY_AFTERTOUCH	0xa0
+#define MIDI_CONTROLER	0xb0
+#define MIDI_PATCH	0xc0
+#define MIDI_CHANNEL_AFTERTOUCH	0xd0
+#define MIDI_PITCH_WHEEL	0xe0
+#define MIDI_SYSEX	0xf0
+#define MIDI_META	0xff
+
+/* Meta event defines */
+#define MIDI_META_SEQUENCE   0
+/* The text type meta events */
+#define MIDI_META_TEXT       1
+#define MIDI_META_COPYRIGHT  2
+#define MIDI_META_TRACKNAME  3
+#define MIDI_META_INSTRUMENT 4
+#define MIDI_META_LYRIC      5
+#define MIDI_META_MARKER     6
+#define MIDI_META_CUE        7
+/* More meta events */
+#define MIDI_META_CHANNEL      0x20
+#define MIDI_META_PORT         0x21
+#define MIDI_META_EOT          0x2f
+#define MIDI_META_TEMPO        0x51
+#define MIDI_META_SMPTE_OFFSET 0x54
+#define MIDI_META_TIME         0x58
+#define MIDI_META_KEY          0x59
+#define MIDI_META_PROP         0x7f
+
+/** The maximum of the midi defined text types */
+#define MIDI_MAX_TEXT_TYPE    7
+
+#define MIDI_HEAD_MAGIC 0x4d546864
+#define MIDI_TRACK_MAGIC  0x4d54726b
+
+>>extern
+
+/*
+ * This structure is used to keep track of the state while
+ * reading in a midi file.
+ */
+struct midistate {
+	FILE *fp;		/* File being read */
+	int  current_time;	/* Current midi time */
+	int  port;		/* Midi port number */
+	int  device;	/* Midi device number */
+	int  num_chunks;	/* Count of chunks */
+	int  chunk_size;	/* Size of current chunk */
+	int  chunk_count;	/* Count within current chunk */
+	GPtrArray *notes;	/* Currently on notes */
+	unsigned long track_duration; /* Track duration */
+
+	struct tempomapElement *tempo_map;	/* The tempo map */
+	struct headElement *head;	/* Pointer into head element */
+	struct rootElement *root;	/* Pointer into the root */
+};
+
+>>function midi_read
+struct rootElement *
+FILE *fp;	// Input file pointer
+
+>>description
+Read in a midi file from the specified open file pointer,
+.A fp
+and return an
+.M mtree
+structure tree representing the file.
+
+>>code
+	struct midistate mState;
+	struct midistate *msp;
+	struct rootElement *root;
+	struct element *el;
+	int  i;
+
+	msp = &mState;
+	msp->fp = fp;
+	msp->tempo_map = md_tempomap_new();
+	msp->notes = g_ptr_array_new();
+	msp->port = 0;
+
+	root = read_head(msp);
+	md_add(MD_CONTAINER(root), MD_ELEMENT(msp->tempo_map));
+
+	msp->root->tracks = 0;  /* Is re-calculated when tracks are added */
+
+	for (i = 0; i < msp->num_chunks; i++) {
+		el = MD_ELEMENT(read_track(msp));
+
+		/* If format 1 then the first track is really the tempo map */
+		if (msp->head->format == 1 && i == 0) {
+			/* It will be added after the loop */
+			md_free(el);
+			continue;
+		}
+
+		md_add(MD_CONTAINER(root), el);
+	}
+
+	//g_ptr_array_index(MD_CONTAINER(root)->elements, 1) = msp->tempo_map;
+	msp->tempo_map = NULL;
+
+	g_ptr_array_free(msp->notes, 1);
+
+	return root;
+
+>>function midi_read_file
+struct rootElement *
+char *name;		// File name to read
+
+>>description
+Read in a midi file from the specified file name.
+
+>>code
+	FILE *fp;
+	struct rootElement *root;
+
+	fp = fopen(name, "rb");
+	if (fp == NULL)
+		ethrow(ioError, _("Could not open file %s"), name);
+
+	root = midi_read(fp);
+
+	fclose(fp);
+
+	return root;
+
+>>function read_head
+static struct rootElement *
+struct midistate *msp;	// current midi state
+
+>>description
+Read the header information from a midi file
+
+>>code
+	guint32  magic;
+	int  length;
+	struct rootElement *root;
+	struct headElement *head;
+
+	root = md_root_new();
+	head = md_head_new();
+	md_add(MD_CONTAINER(root), MD_ELEMENT(head));
+	root->head = head;
+	msp->root = root;
+	msp->head = head;
+
+	/* The first word just identifies the file as a midi file */
+	magic = read_int(msp, 4);
+	if (magic != MIDI_HEAD_MAGIC)
+		ethrow(formatError, _("Bad header (%x), probably not a real midi file"),
+			magic);
+
+	/* The header chunk should be 6 bytes, (perhaps longer in the future) */
+	length = read_int(msp, 4);
+	if (length < 6)
+		ethrow(formatError, _("Bad header length, probably not a real midi file"));
+
+	head->format = read_int(msp, 2);
+	msp->num_chunks = read_int(msp, 2);
+	head->time_base = read_int(msp, 2);
+
+	/* Should skip any extra bytes, (may not be seekable) */
+	while (length > 6) {
+		length--;
+		(void) getc(msp->fp);
+	}
+
+	return root;
+
+>>function read_track
+static struct trackElement *
+struct midistate *msp;	// Midi state
+
+>>description
+Read in one track from the file, and return an element tree
+describing it.
+Only the part element is allowed under track so one will
+be created at the same time as the track.
+
+>>code
+	int  status, laststatus;
+	int  head;
+	int  length;
+	int  delta_time;
+	struct trackElement *track;
+	struct partElement *part;
+	int  i;
+
+	laststatus = 0;
+	head = read_int(msp, 4);
+	if (head != MIDI_TRACK_MAGIC)
+		ethrow(formatError,
+			_("Bad track header (%x), probably not a midi file"),
+			head);
+
+	length = read_int(msp, 4);
+	msp->chunk_size = length;
+	msp->chunk_count = 0;	/* nothing read yet */
+
+	track = md_track_new();
+	part = md_part_new();
+	md_add(MD_CONTAINER(track), MD_ELEMENT(part));
+
+	msp->current_time = 0;
+	while (msp->chunk_count < msp->chunk_size) {
+
+		delta_time = read_var(msp);
+		msp->current_time += delta_time;
+
+		status = read_int(msp, 1);
+		if ((status & 0x80) == 0) {
+			
+			/*
+			 * This is not a status byte and so running status is being
+			 * used.  Re-use the previous status and push back this byte.
+			 */
+			put_back(msp, status);
+			status = laststatus;
+		} else {
+			laststatus = status;
+		}
+
+		handle_status(msp, part, status);
+	}
+
+  restart:
+	for (i = 0; i < msp->notes->len; i++) {
+		struct noteElement *ns;
+		ns = g_ptr_array_index(msp->notes, i);
+		msp->device = MD_ELEMENT(ns)->device_channel;
+		finish_note(msp, ns->note, 0);
+		goto restart;
+	}
+
+	MD_CONTAINER(track)->duration = msp->track_duration;
+	msp->track_duration = 0;
+
+	return track;
+
+>>function handle_status
+static void
+struct midistate *msp;		// Current midi file status
+struct partElement *part;	// Current part (track)
+int status;		// Status byte, ie. current command
+
+>>description
+Complete the reading of the status byte.
+The parsed midi command will be added to the specified
+.A part .
+
+>>code
+	int  ch;
+	int  type;
+	int  device;
+	int  length;
+	short note, vel, control, val;
+	unsigned char *data;
+	struct element *el;
+
+	ch = status & 0x0f;
+	type = status & 0xf0;
+
+	/*
+	 * Do not set the device if the type is 0xf0 as these commands are
+	 * not channel specific
+	 */
+	device = 0;
+	if (type != 0xf0)
+		device = (msp->port<<4) + ch;
+	msp->device = device;
+
+	el = NULL;
+
+	switch (type) {	
+	case MIDI_NOTE_OFF:
+		note = read_int(msp, 1);
+		vel = read_int(msp, 1);
+
+		finish_note(msp, note, vel);
+		break;
+
+	case MIDI_NOTE_ON:
+		note = read_int(msp, 1);
+		vel = read_int(msp, 1);
+
+		if (vel == 0) {
+			/* This is really a note off */
+			finish_note(msp, note, vel);
+		} else {
+			/* Save the start, so it can be matched with the note off */
+			el = save_note(msp, note, vel);
+		}
+		break;
+
+	case MIDI_KEY_AFTERTOUCH:
+		note = read_int(msp, 1);
+		vel = read_int(msp, 1);
+
+		/* new aftertouchElement */
+		el = MD_ELEMENT(md_keytouch_new(note, vel));
+		break;
+
+	case MIDI_CONTROLER:
+		control = read_int(msp, 1);
+		val = read_int(msp, 1);
+		el = MD_ELEMENT(md_control_new(control, val));
+
+		break;
+	
+	case MIDI_PATCH:
+		val = read_int(msp, 1);
+		el = MD_ELEMENT(md_program_new(val));
+		break;
+
+	case MIDI_CHANNEL_AFTERTOUCH:
+		val = read_int(msp, 1);
+		el = MD_ELEMENT(md_pressure_new(val));
+		break;
+	case MIDI_PITCH_WHEEL:
+		val = read_int(msp, 1);
+		val |= read_int(msp, 1) << 7;
+		val -= 0x2000;	/* Center it around zero */
+		el = MD_ELEMENT(md_pitch_new(val));
+		break;
+
+	/* Now for all the non-channel specific ones */
+	case 0xf0:
+		/* Deal with the end of track event first */
+		if (ch == 0x0f) {
+			type = read_int(msp, 1);
+			if (type == 0x2f) {
+
+				/* End of track - skip to end of real track */
+				msp->track_duration =
+					msp->current_time - MD_ELEMENT(part)->element_time;
+
+				MD_CONTAINER(part)->duration = msp->track_duration;
+
+				skip_chunk(msp);
+				return;
+			}
+		}
+
+		/* Get the length of the following data */
+		length = read_var(msp);
+		data = read_data(msp, length);
+		if (ch == 0x0f) {
+			el = (struct element *)handle_meta(msp, type, data);
+		} else {
+			el = (struct element *)md_sysex_new(status, data, length);
+		}
+		break;
+	default:
+		ethrow(formatError, _("Bad status type 0x%x"), type);
+		/*NOTREACHED*/
+	}
+
+	if (el != NULL) {
+		el->element_time = msp->current_time;
+		el->device_channel = device;
+
+		md_add(MD_CONTAINER(part), el);
+	}
+
+>>function handle_meta
+static struct metaElement *
+struct midistate *msp;	// The midi file state
+int  type;	// The meta event type
+unsigned char *data;	// The data for the event
+
+>>description
+Do extra handling of meta events.
+We want to save time signature and key for use elsewhere, for example.
+This routine create the correct type of class and returns it.
+
+>>code
+	struct metaElement *el = NULL;
+	struct mapElement *map = NULL;
+	int  micro_tempo;
+
+	switch (type) {
+	case MIDI_META_TEMPO:
+		micro_tempo = ((data[0]<<16) & 0xff0000)
+			+ ((data[1]<<8) & 0xff00) + (data[2] & 0xff);
+		map = MD_MAP(md_tempo_new(micro_tempo));
+		g_free(data);
+		break;
+	case MIDI_META_TIME:
+		map = MD_MAP(md_timesig_new(data[0], 1<<data[1],
+			data[2], data[3]));
+		g_free(data);
+		break;
+	case MIDI_META_KEY:
+		map = MD_MAP(md_keysig_new(data[0], (data[1]==1)? 1: 0));
+		g_free(data);
+		break;
+	case MIDI_META_PORT:
+		msp->port = data[0];
+		g_free(data);
+		break;
+	case MIDI_META_TEXT:
+	case MIDI_META_COPYRIGHT:
+	case MIDI_META_TRACKNAME:
+	case MIDI_META_INSTRUMENT:
+	case MIDI_META_LYRIC:
+	case MIDI_META_MARKER:
+	case MIDI_META_CUE:
+		/* Text based events */
+		el = MD_META(md_text_new(type, data));
+		break;
+	case MIDI_META_SMPTE_OFFSET:
+		el = MD_META(md_smpteoffset_new(data[0], data[1], data[2], data[3],
+			data[4]));
+		break;
+	case MIDI_META_PROP:
+		/* Proprietry sequencer specific event */
+		/* Just throw it out */
+		break;
+	case MIDI_META_SEQUENCE:
+	default:
+		g_warning(_("Meta event %d not implemented\n"), type);
+		break;
+	}
+
+	/* If this affected the tempo map then add it */
+	if (map) {
+		MD_ELEMENT(map)->element_time = msp->current_time;
+		md_add(MD_CONTAINER(msp->tempo_map), MD_ELEMENT(map));
+	}
+
+	return el;
+
+>>function read_int
+static int
+struct midistate *msp;	// Midi file state
+int  n;			// Number of bytes to read
+
+>>description
+Reads an interger from the midi file.
+The number of bytes to be read is specified in
+.A n .
+
+>>code
+	int  val;
+	int  c;
+	int  i;
+
+	val = 0;
+
+	for (i = 0; i < n; i++) {
+		val <<= 8;
+		c = getc(msp->fp);
+		msp->chunk_count++;
+		if (c == -1)
+			ethrow(formatError, _("Unexpected end of file"));
+
+		val |= c;
+	}
+
+	return val;
+
+>>function read_data
+static unsigned char *
+struct midistate *msp;// Midifile state
+int  length;	// Length of data to read
+
+>>description
+Read in a specified amount of data from the file.
+The return is allocated data which must be freed by the caller.
+An extra null byte is appended for the sake of text events.
+>>code
+
+	unsigned char *data = g_malloc(length+1);
+
+	if (fread(data, length, 1, msp->fp) == 1) {
+		msp->chunk_count += length;
+		data[length] = '\0';
+		return data;
+	} else {
+		ethrow(formatError, _("Unexpected end of file"));
+		/*NOTREACHED*/
+	}
+	return NULL;
+
+>>function read_var
+static gint32
+struct midistate *msp;	// Midi file state
+
+>>description
+Read a variable length integer from the midifile and return it.
+Returns an int32 so cannot really deal with more than four bytes.
+
+>>code
+	int  val;
+	int  c;
+
+	val = 0;
+	do {
+		c = getc(msp->fp);
+		msp->chunk_count++;
+		if (c == -1)
+			ethrow(formatError, _("Unexpected end of file"));
+		val <<= 7;
+		val |= (c & 0x7f);
+	} while ((c & 0x80) == 0x80);
+
+	return val;
+
+>>function put_back
+static void
+struct midistate *msp;	Midi input state
+char  c;   Character to push back
+>>description
+Push back a character.
+Have to also keep track of the chunk_count.
+>>code
+
+	ungetc(c, msp->fp);
+	msp->chunk_count--;
+
+>>function save_note
+static struct element *
+
+struct midistate *msp;	// Midi file state
+int  note;	// Note number
+int  vel;	// Velocity
+
+>>description
+Save the initial note-on message.
+This will later be paired with a note off message.
+We have to keep track of channel and device that the
+note-on is for so that it can be correctly matched.
+
+>>code
+	struct noteElement *n;
+
+	/* Create a new note and set its length to -1
+	 * this will be filled in later, when the note-off arrives
+	 */
+	n = md_note_new(note, vel, -1); 
+
+	/* Save it so that we match up with the note off */
+	g_ptr_array_add(msp->notes, n);
+
+	return MD_ELEMENT(n);
+
+>>function finish_note
+static void
+struct midistate *msp;	Midi file state
+int  note;		Note number
+int  offvel;	Note off velocity
+
+>>description
+Called when a note off is seen.
+Finds the corresponding note on and constructs a note element.
+
+>>code
+	int  i;
+	GPtrArray *notes;
+	struct noteElement *n;
+	int  len;
+
+	notes = msp->notes;
+	n = NULL;
+	for (i = notes->len-1; i >= 0; i--) {
+		n = g_ptr_array_index(notes, i);
+		if (n->note == note && MD_ELEMENT(n)->device_channel == msp->device) {
+			len = msp->current_time - MD_ELEMENT(n)->element_time;
+			n->offvel = offvel;
+			n->length = len;
+			if (n->length < 0) {
+				printf("Len neg: msp->time%d, s->time%d, note=%d, s.vel%d\n",
+					msp->current_time, MD_ELEMENT(n)->element_time,
+					note, n->vel);
+				n->length = 0;
+			}
+			g_ptr_array_remove_index_fast(notes, i);
+
+			/* Do not break here, there may be more than one */
+		}
+	}
+
+>>function skip_chunk
+static void
+struct midistate *msp;	// Midi file state
+
+>>description
+Skip to the end of the chunk.
+Note that the input may not be seekable, so we just read bytes
+until at the end of the chunk.
+
+>>code
+
+	while (msp->chunk_count < msp->chunk_size)
+		(void) read_int(msp, 1);
+
diff -rNu melys-0.0.4/files/midiwrite.m melys-0.0.5/files/midiwrite.m
--- melys-0.0.4/files/midiwrite.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/files/midiwrite.m	Fri Jul 30 00:09:28 1999
@@ -0,0 +1,518 @@
+>>name midiwrite.m
+File: midiwrite.m - write out to a file in MIDI format
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+>>header <stdio.h>
+>>header md.h
+>>headerdef --decl midi.h
+
+/* Flags for writing midi files */ 
+#define MIDI_FILE_RUNNING_STATUS  0x001
+#define MIDI_FILE_COMPRESSED	  0x002
+
+>>extern
+struct midiwstate {
+	FILE *fp;
+	int  track_start;	/* Offset at the start of the track */
+	int  out_offset;	/* Current write offset */
+	int  prev_status;	/* Previous status byte */
+	int  prev_time;		/* Previous time */
+	int  port;			/* Current output port */
+	int  flags;			/* File format flags */
+	struct rootElement *root; /* Pointer to the root */
+	GByteArray *out;	/* Output buffer */
+	GSList  *notes;	/* Pending off notes */
+	int  inQ;		/* Running through the notes queue */
+};
+
+
+>>function midi_write_file
+void
+char *name;  File name to write to
+struct rootElement *root;  the data to write
+int  flags;	 Write flags
+>>description
+Write out the specified file.
+>>code
+	FILE *fp;
+
+	fp = fopen(name, "wb");
+	if (fp == NULL)
+		ethrow(ioError, _("Can not open file %s"), name);
+
+	midi_write(fp, root, flags);
+
+	fclose(fp);
+
+
+>>function midi_write
+void
+FILE *fp;	File stream to write to
+struct rootElement *root;  The data to write
+int  flags;	 Write flags
+>>description
+Write the md tree as a midi file to the specified file stream.
+>>code
+	struct midiwstate *msp;
+	unsigned long inittime;
+
+	msp = g_new0(struct midiwstate, 1);
+	msp->fp = fp;
+	msp->root = root;
+	msp->out = g_byte_array_new();
+	msp->notes = NULL;
+	msp->flags = flags;
+	inittime = 0;
+
+	md_walk(MD_CONTAINER(root), write_elem, msp, 0);
+
+	fwrite(msp->out->data, msp->out->len, 1, fp);
+	g_byte_array_free(msp->out, TRUE);
+	g_slist_free(msp->notes);
+	g_free(msp);
+
+>>function write_elem
+static void
+struct element *el;	Element to write out
+void *arg;	Our private data
+int  flags;	Start/end etc
+
+>>description
+Write out an element to the midi file.
+We don't actually write to the file at this point, just to
+memory structures.
+This is because we don't want to require that the stream
+be seekable.
+
+>>code
+	struct midiwstate *msp;
+
+	msp = (struct midiwstate *)arg;
+
+	switch (el->type) {
+	case MD_TYPE_ROOT:
+		if (flags & MD_WALK_START) {
+			int  nchunks;
+
+			put_int(msp, 4, MIDI_HEAD_MAGIC);
+			put_int(msp, 4, 6);	/* Header length, always 6 */
+			put_int(msp, 2, msp->root->head->format);
+			nchunks = msp->root->tracks;
+			if (msp->root->head->format == 1)
+				nchunks++;
+			put_int(msp, 2, nchunks);
+			put_int(msp, 2, msp->root->head->time_base);
+		}
+		break;
+	case MD_TYPE_TRACK:
+	case MD_TYPE_TEMPOMAP:
+		if (flags & MD_WALK_START) {
+			put_int(msp, 4, MIDI_TRACK_MAGIC);
+			put_int(msp, 4, 0);	/* Leave space for the length */
+			msp->track_start = msp->out_offset;
+			msp->prev_time = 0;
+			msp->prev_status = 0;
+			msp->port = 0;
+		} else {
+			struct trackElement *tr;
+			struct containerElement *ce;
+			int  size;
+
+			/* do pending events */
+			run_queue(msp, G_MAXINT);
+
+			tr = MD_TRACK(el);
+			ce = MD_CONTAINER(el);
+			if (ce->duration > 0
+			  && (el->element_time + ce->duration) >= msp->prev_time)
+				put_time(msp, el->element_time + ce->duration);
+			else
+				put_int(msp, 1, 0);
+
+			/* Put out the end of track message */
+			put_status(msp, MIDI_META, 0);
+			put_int(msp, 1, 0x2f);
+			put_int(msp, 1, 0);
+
+			/* Calculate the track length */
+			size = msp->out_offset - msp->track_start;
+			put_int_at(msp, 4, msp->track_start - 4, size);  /* In header */
+		}
+		break;
+	case MD_TYPE_PART:
+		break;
+	case MD_TYPE_NOTE:
+		put_time(msp, el->element_time);
+		put_status(msp, MIDI_NOTE_ON, el->device_channel);
+		put_int(msp, 1, MD_NOTE(el)->note);
+		put_int(msp, 1, MD_NOTE(el)->vel);
+		/* save for note off */
+		msp->notes = g_slist_insert_sorted(msp->notes, el, noteoff_cmp);
+		break;
+	case MD_TYPE_CONTROL:
+		put_time(msp, el->element_time);
+		put_status(msp, MIDI_CONTROLER, el->device_channel);
+		put_int(msp, 1, MD_CONTROL(el)->control);
+		put_int(msp, 1, MD_CONTROL(el)->value);
+		break;
+		
+	case MD_TYPE_KEYTOUCH:
+		put_time(msp, el->element_time);
+		put_status(msp, MIDI_KEY_AFTERTOUCH, el->device_channel);
+		put_int(msp, 1, MD_KEYTOUCH(el)->note);
+		put_int(msp, 1, MD_KEYTOUCH(el)->velocity);
+		break;
+	case MD_TYPE_PITCH:
+		{
+		int  val;
+
+		put_time(msp, el->element_time);
+		put_status(msp, MIDI_PITCH_WHEEL, el->device_channel);
+		val = MD_PITCH(el)->pitch;
+		val += 0x2000;
+		put_int(msp, 1, val & 0x7f);
+		put_int(msp, 1, (val>>7) & 0x7f);
+		}
+		break;
+	case MD_TYPE_PRESSURE:
+		put_time(msp, el->element_time);
+		put_status(msp, MIDI_CHANNEL_AFTERTOUCH, el->device_channel);
+		put_int(msp, 1, MD_PRESSURE(el)->velocity);
+		break;
+	case MD_TYPE_PROGRAM:
+		put_time(msp, el->element_time);
+		put_status(msp, MIDI_PATCH, el->device_channel);
+		/* XXX TODO: modify for bank/program combinations */
+		put_int(msp, 1, MD_PROGRAM(el)->program);
+		break;
+
+	case MD_TYPE_SYSEX:
+		put_time(msp, el->element_time);
+		/* Status can be either f0 or f7 */
+		put_status(msp, MD_SYSEX(el)->status, 0);
+		put_var(msp, MD_SYSEX(el)->length);
+		put_data(msp, MD_SYSEX(el)->data, MD_SYSEX(el)->length);
+		break;
+
+	case MD_TYPE_TEMPO:
+		{
+		int mt;
+
+		put_time(msp, el->element_time);
+		put_status(msp, MIDI_META, el->device_channel);
+		put_byte(msp, MIDI_META_TEMPO);
+		/* 3 bytes to follow */
+		put_byte(msp, 3);
+
+		mt = MD_TEMPO(el)->micro_tempo;
+		put_byte(msp, (mt>>16) & 0xff);
+		put_byte(msp, (mt>>8) & 0xff);
+		put_byte(msp, (mt) & 0xff);
+		}
+		break;
+	case MD_TYPE_TIMESIG:
+		put_time(msp, el->element_time);
+		put_status(msp, MIDI_META, el->device_channel);
+		put_byte(msp, MIDI_META_TIME);
+
+		{
+		int bot;
+			for (bot = 0; bot < 32; bot++)
+				if ((MD_TIMESIG(el)->bottom >> bot) == 0)
+					break;
+			bot--;
+
+			put_byte(msp, 4);	/* 4 to follow */
+			put_byte(msp, MD_TIMESIG(el)->top);
+			put_byte(msp, bot);
+			put_byte(msp, MD_TIMESIG(el)->clocks);
+			put_byte(msp, MD_TIMESIG(el)->n32pq);
+		}
+		break;
+
+	case MD_TYPE_KEYSIG:
+		put_time(msp, el->element_time);
+		put_status(msp, MIDI_META, el->device_channel);
+		put_byte(msp, MIDI_META_KEY);
+
+		put_byte(msp, 2); /* Bytes to follow */
+		put_byte(msp, MD_KEYSIG(el)->key);
+		put_byte(msp, MD_KEYSIG(el)->minor? 1: 0);
+		break;
+	case MD_TYPE_SMPTEOFFSET:
+		put_time(msp, el->element_time);
+		put_status(msp, MIDI_META, el->device_channel);
+		put_byte(msp, MIDI_META_SMPTE_OFFSET);
+		put_byte(msp, 5);	/* 5 to follow */
+		put_byte(msp, MD_SMPTEOFFSET(el)->hours);
+		put_byte(msp, MD_SMPTEOFFSET(el)->minutes);
+		put_byte(msp, MD_SMPTEOFFSET(el)->seconds);
+		put_byte(msp, MD_SMPTEOFFSET(el)->frames);
+		put_byte(msp, MD_SMPTEOFFSET(el)->subframes);
+		break;
+	case MD_TYPE_TEXT:
+		put_time(msp, el->element_time);
+		put_status(msp, MIDI_META, el->device_channel);
+		put_byte(msp, MD_TEXT(el)->type);
+		put_var(msp, MD_TEXT(el)->length);
+		put_data(msp, MD_TEXT(el)->text, MD_TEXT(el)->length);
+		break;
+	case MD_TYPE_HEAD:
+		break;
+	default:
+		ethrow(formatError, "Unknown MD type %d", el->type);
+		break;
+	}
+
+>>function put_int
+static void
+struct midiwstate *msp;   Midi write state
+int  n;   Number of bytes to write
+int  val; Value of integer
+>>description
+Write out an integer 
+.A val
+of size
+.A n
+to the output stream.
+>>code
+#define WRITE_BUF_SIZE 10
+	guint8 data[WRITE_BUF_SIZE];
+
+	set_int(data, n, val);
+	g_byte_array_append(msp->out, data, n);
+	msp->out_offset += n;
+
+
+>>function put_byte
+static void
+struct midiwstate *msp;   Midi write state
+int  val;	Value to write
+>>description
+Put out a single byte.
+>>code
+	guint8 data[1];
+	data[0] = val & 0xff;
+
+	g_byte_array_append(msp->out, data, 1);
+	msp->out_offset++;
+
+
+
+>>function put_int_at
+static void
+struct midiwstate *msp;   Midi write state
+int  n;   Number of bytes in integer
+int  pos; Position to write at
+int  val; Value of integer
+>>description
+Write an
+.A n
+byte integer at the place specified in the output stream.
+This is only used to re-writing the track size.
+>>code
+
+	g_return_if_fail(pos < msp->out->len);
+
+	set_int(msp->out->data+pos, n, val);
+
+>>function set_int
+static void
+guint8 *data; Buffer to write into
+int  n;   Number of bytes to write
+int  val; Value of integer
+>>description
+Take the integer value
+.A val
+of length
+.A n
+and place a byte representation into
+.A buf ,
+high byte first.
+>>code
+	int  i;
+
+	for (i = 0; i < n; i++) {
+		data[n - i - 1] = val & 0xff;
+		val >>= 8;
+	}
+
+
+>>function put_time
+static void
+struct midiwstate *msp;   Midi write state
+int  time;                Midi time
+>>description
+Put out the time.
+The time is stored as a change from the previous time, in
+the variable length format.
+>>code
+	int delta_time;
+	/*
+	 * If there are any pending off-notes then do them now.
+	 */
+	if (!msp->inQ) {
+		run_queue(msp, time);
+	}
+
+	delta_time = time - msp->prev_time;
+	if (delta_time < 0)
+		ethrow(formatError, "Negative time difference (%d) writing midi file",
+			delta_time);
+
+
+	put_var(msp, delta_time);
+	msp->prev_time = time;
+
+>>function put_status
+static void
+struct midiwstate *msp;   Midi write state
+int  status;	Midi status byte to write (or not)
+int  devchan;   Midi device and channel
+>>description
+Write the status byte.
+If running status is in effect, then the status is not output
+if it is the same as the previous one and isn't 0xf?.
+>>code
+	gboolean isSys = FALSE;
+	int  port;
+
+	status &= 0xff;	/* Make sure no extra bits set */
+	if ((status & 0xf0) == 0xf0)
+		isSys = TRUE;
+
+	port = (devchan>>4);
+	if (port != msp->port) {
+		msp->port = port;
+		//put_time(msp, msp->prev_time);
+		put_status(msp, MIDI_META, port<<4);
+		put_byte(msp, MIDI_META_PORT);
+		put_byte(msp, 1); /* Bytes to follow */
+		put_byte(msp, port);
+		put_time(msp, msp->prev_time);	/* Re-put the time */
+	}
+
+	if (!isSys)
+		status |= (devchan & 0x0f);
+
+	/*
+	 * We put out the status byte if it is a system message, or
+	 * is different to the last one, or if we are not doing
+	 * running status.
+	 */
+	if (isSys || (msp->flags & MIDI_FILE_RUNNING_STATUS) == 0 ||
+		   status != msp->prev_status) {
+		put_int(msp, 1, status);
+	}
+
+	if (isSys)
+		msp->prev_status = 0;
+	else
+		msp->prev_status = status;
+
+>>function put_var
+static void
+struct midiwstate *msp;  Midi write state
+int  val;                Value to put
+>>description
+Write a variable length quantity.
+It is split into 7bit quantities and all but the last have
+the high bit set when written to the file.
+>>code
+	int  pos;
+	int  b;
+
+	g_assert(val >= 0);
+
+	for (pos = 28; pos > 0; pos -= 7) {
+		b = (val >> pos) & 0x7f;
+		if (b > 0)
+			put_int(msp, 1, 0x80 | b);
+	}
+	/* Deal with the last 7bits, will not have the high bit set */
+	b = val & 0x7f;
+	put_int(msp, 1, b);
+
+
+>>function put_data
+static void
+struct midiwstate *msp;  Midi write state
+guint8 *data;  Data to write
+int  length;   Length of data
+>>description
+Write out a buffer of data with the specified size.
+>>code
+	int  i;
+
+	for (i = 0; i < length; i++)
+		put_byte(msp, data[i]);
+
+>>function noteoff_cmp
+static gint
+gconstpointer item1;  first to compare
+gconstpointer item2;  second to compare
+>>description
+Compare the elements based on the note off time.
+That is element_time + length
+>>code
+	struct element *el1 = MD_ELEMENT(item1);
+	struct element *el2 = MD_ELEMENT(item2);
+	int  time1 = el1->element_time + MD_NOTE(el1)->length;
+	int  time2 = el2->element_time + MD_NOTE(el2)->length;
+
+	if (time1 == time2)
+		return 0;
+	else if (time1 < time2)
+		return -1;
+	else
+		return 1;
+
+
+>>function run_queue
+static void
+struct midiwstate *msp; Midi write state
+unsigned long time;     Dequeue events at and before this time
+
+>>description
+Run the queue of pending events that need to be pushed out before
+the specified time.
+
+>>code
+
+	GSList *litem;
+	struct element *el;
+	struct noteElement *ne;
+
+	msp->inQ = 1;
+	litem = msp->notes;
+	while (litem && litem->data) {
+		el = MD_ELEMENT(litem->data);
+		ne = MD_NOTE(el);
+		if (el->element_time + ne->length <= time) {
+			int  status = MIDI_NOTE_OFF;
+
+			put_time(msp, el->element_time+ne->length);
+			if (ne->offvel == 0)
+				status = MIDI_NOTE_ON;
+
+			put_status(msp, status, el->device_channel);
+			put_int(msp, 1, MD_NOTE(el)->note);
+			put_int(msp, 1, MD_NOTE(el)->offvel);
+			litem = g_slist_remove(msp->notes, el);
+			msp->notes = litem;
+		} else {
+			break;	/* No more to do */
+		}
+	}
+	msp->notes = litem;
+	msp->inQ = 0;
diff -rNu melys-0.0.4/gui/.cvsignore melys-0.0.5/gui/.cvsignore
--- melys-0.0.4/gui/.cvsignore	Fri Jul 30 00:43:12 1999
+++ melys-0.0.5/gui/.cvsignore	Mon Aug  9 00:51:28 1999
@@ -1,6 +1,5 @@
 main.c
 menus.c
 Makefile
-*.mdml
-*.mid
+*.mdml *.mdml.gz *.mid
 .cvsignore
diff -rNu melys-0.0.4/gui/main.c melys-0.0.5/gui/main.c
--- melys-0.0.4/gui/main.c	Fri Jul 30 00:43:19 1999
+++ melys-0.0.5/gui/main.c	Mon Aug  9 00:51:35 1999
@@ -24,10 +24,14 @@
 #include "melreg.h"
 #include "melmidi.h"
 #include "song.h"
+#include "melys.h"
+#include "melystrackinfo.h"
+#include "melystrackdisplay.h"
+#include "melystrack.h"
 #include "melgui.h"
 #include "intl.h"
 
-GtkWidget *GlobalNewView; /* XXX */
+static GtkWidget *create_view(GnomeMDIChild *child, gpointer data);
 static int add_view_cb(GtkObject *mdi, GtkWidget *widget, gpointer user_data);
 
 
@@ -43,10 +47,10 @@
 {
 	GnomeMDI *mdi;
 	GnomeMDIGenericChild *child;
-	int  *child_count;
 	struct song *song;
 
-	gnome_init("melys", "0.0.1", argc, argv);
+	argc = 1; /* We currently do our own processing */
+	gnome_init("melys", MELYS_VERSION_STRING, argc, argv);
 
 	mdi = GNOME_MDI(gnome_mdi_new("melys", _("The Melys sequencer")));
 
@@ -65,18 +69,15 @@
 
 	song_open_file(song, NULL);
 
-	/* Get warning, will all be changed anyway */
-	gnome_mdi_generic_child_set_view_creator(child, create_view, "FOO");
 	gnome_mdi_add_child(mdi, GNOME_MDI_CHILD(child));
-	gnome_mdi_add_toplevel_view(mdi, GNOME_MDI_CHILD(child));
+
+	mel_initial_view((GtkObject *)mdi, (GtkObject *)child, song->mdroot, TRUE);
 
 	/*
 	 * Set up the child count, (would prefer to get this directly from
 	 * the mdi if possible)
 	 */
-	child_count = g_new(int, 1);
-	*child_count = 1;
-	gtk_object_set_data(GTK_OBJECT(mdi), MEL_MDI_CHILD_COUNT, child_count);
+	set_child_count((GtkObject *)mdi, 1);
 
 	return 0;
 }
@@ -104,21 +105,23 @@
 }
 
 /*
- * Get the child count.
+ * Get the child count. It would be better to use a public
+ * interface for this, but there doesn't appear to be one.
  *  Arguments:
- *    mdi       - MDI to set count on
+ *    mdi       - MDI to get child count of
  */
 int 
 get_child_count(GtkObject *mdi)
 {
-	int *ip;
+	gpointer data;
 
-	ip = (int*)gtk_object_get_data(GTK_OBJECT(mdi), MEL_MDI_CHILD_COUNT);
-	return *ip;
+	data = gtk_object_get_data(GTK_OBJECT(mdi), MEL_MDI_CHILD_COUNT);
+	return GPOINTER_TO_INT(data);
 }
 
 /*
- * Set the child count.
+ * Set the child count. Would not be needed if you could get the
+ * number of children via a public interface.
  *  Arguments:
  *    mdi       - MDI to set count on
  *    count     - The new count to set
@@ -126,10 +129,9 @@
 void 
 set_child_count(GtkObject *mdi, int count)
 {
-	int  *ip;
 
-	ip = (int*)gtk_object_get_data(GTK_OBJECT(mdi), MEL_MDI_CHILD_COUNT);
-	*ip = count;
+	gtk_object_set_data(GTK_OBJECT(mdi),
+		MEL_MDI_CHILD_COUNT, GINT_TO_POINTER(count));
 }
 
 /*
@@ -163,29 +165,78 @@
 }
 
 /*
- * TEMPORARY. This is just junk
+ * Add the view to the child. We have to go in a very round about
+ * way of doing this...
+ * 
+ *  Arguments:
+ *    toplevel  - True if toplevel view required
  */
-/*XXX static*/GtkWidget *
-create_view(GtkObject *child, gpointer data)
+void 
+mel_add_view(GtkObject *mdi, GtkObject *child, GtkWidget *view, 
+        gboolean toplevel)
 {
-	GtkWidget *new;
-	GtkWidget *lab;
-	struct song *sd;
-	char *labtxt;
 
-	mel_debug_print_type("child", GTK_OBJECT(child));
-	sd = song_get_data(GTK_OBJECT(child));
+	gtk_object_set_data(child, MEL_NEW_VIEW, view);
+
+	gnome_mdi_generic_child_set_view_creator
+		(GNOME_MDI_GENERIC_CHILD(child), create_view, NULL);
+
+	if (toplevel)
+		gnome_mdi_add_toplevel_view(GNOME_MDI(mdi), GNOME_MDI_CHILD(child));
+	else
+		gnome_mdi_add_view(GNOME_MDI(mdi), GNOME_MDI_CHILD(child));
+}
+
+/*
+ * Create the initial view on a file.
+ * 
+ *  Arguments:
+ *    toplevel  - True if toplevel view required
+ */
+void 
+mel_initial_view(GtkObject *mdi, GtkObject *child, struct rootElement *root, 
+        gboolean toplevel)
+{
+	GtkWidget *w;
+
+	/* Our initial view is the track based view */
+	w = melys_track_new(root);
+
+	if (toplevel) {
+		gtk_widget_set_usize
+			(w, 70*gdk_screen_width()/100, 70*gdk_screen_height()/100);
+	}
+
+	mel_add_view(mdi, child, w, toplevel);
+
+	while (gtk_events_pending())
+		gtk_main_iteration();
+
+	gnome_mdi_set_active_view(GNOME_MDI(mdi), w);
+}
+
+/*
+ * The view add interface to Gnome MDI is inside out, so we have
+ * to set a function into the child to create views. What we want
+ * to be able to do is create a view and then add it. Too simple? So
+ * we get round this by having our routine that adds the view
+ * save it as a property on the child. All this routine does is
+ * retreives it and returns it back into the depths of MDI.
+ * 
+ */
+static GtkWidget *
+create_view(GnomeMDIChild *child, gpointer data)
+{
+	GtkWidget *w;
+
+	w = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(child), MEL_NEW_VIEW);
 
-	new = gtk_frame_new("label");
-	labtxt = g_strdup_printf("This is a null view of the file\n"
-		"%s\n", sd->filename? g_basename(sd->filename): "");
-	lab = gtk_label_new(labtxt);
-	gtk_container_add(GTK_CONTAINER(new), lab);
-	g_free(labtxt);
+	if (w == NULL)
+		ethrow(debugError, "create_view: NEW_VIEW not set up");
 
-	gtk_widget_set_usize(new, 600, 400);
+	gtk_object_set_data(GTK_OBJECT(child), MEL_NEW_VIEW, 0);
 
-	return new;
+	return w;
 }
 
 /*
@@ -201,8 +252,7 @@
 add_view_cb(GtkObject *mdi, GtkWidget *widget, gpointer user_data)
 {
 
-	//gnome_mdi_set_active_view(mdi, widget);
-	GlobalNewView = widget;
+	dprintf1("add_view_cb: View Added (NOT IMPLEMENTED)");
 
 	return TRUE;
 }
diff -rNu melys-0.0.4/gui/main.m melys-0.0.5/gui/main.m
--- melys-0.0.4/gui/main.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/gui/main.m	Mon Aug  9 00:05:59 1999
@@ -0,0 +1,253 @@
+>>name main.m The main screen
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+>>header menus.h
+>>header elements.h
+>>header melreg.h
+>>header melmidi.h
+>>header song.h
+>>header melys.h
+>>header melystrackinfo.h
+>>header melystrackdisplay.h
+>>header melystrack.h
+>>headerdef --decl melgui.h
+
+>>function melys_app
+int
+int  argc;	 The program argument count
+char **argv; The program arguments
+
+>>description
+Initialise the application and set up the initial screen.
+
+>>code
+	GnomeMDI *mdi;
+	GnomeMDIGenericChild *child;
+	struct song *song;
+
+	argc = 1; /* We currently do our own processing */
+	gnome_init("melys", MELYS_VERSION_STRING, argc, argv);
+
+	mdi = GNOME_MDI(gnome_mdi_new("melys", _("The Melys sequencer")));
+
+	mel_init_menus(mdi);
+
+	/* Set to notebook mode */
+	gnome_mdi_set_mode(mdi, GNOME_MDI_NOTEBOOK);
+	mdi->tab_pos = GTK_POS_BOTTOM;
+
+	gtk_signal_connect(GTK_OBJECT(mdi), "add-view"
+		, GTK_SIGNAL_FUNC(add_view_cb), NULL);
+
+	/* Create the first child */
+	child = gnome_mdi_generic_child_new(_("Untitled"));
+	song = song_new(GTK_OBJECT(mdi), GTK_OBJECT(child));
+
+	song_open_file(song, NULL);
+
+	gnome_mdi_add_child(mdi, GNOME_MDI_CHILD(child));
+
+	mel_initial_view((GtkObject *)mdi, (GtkObject *)child, song->mdroot, TRUE);
+
+	/*
+	 * Set up the child count, (would prefer to get this directly from
+	 * the mdi if possible)
+	 */
+	set_child_count((GtkObject *)mdi, 1);
+
+	return 0;
+
+>>function get_song_from_mdi
+struct song *
+GtkObject *mdi;	The MDI to find the active child
+
+>>description
+Get the child info data from the specified MDI.
+The active child is found.
+If the data does not exist on the child then it is created.
+>>code
+	struct song *sd;
+	GnomeMDIChild *child;
+
+	child = gnome_mdi_get_active_child(GNOME_MDI(mdi));
+	if (child == NULL)
+		ethrow(debugError, "No active child");
+
+	sd = song_get_data(GTK_OBJECT(child));
+
+	return sd;
+
+>>function get_child_count
+int
+GtkObject *mdi;	MDI to get child count of
+>>description
+Get the child count.
+It would be better to use a public interface for this, but
+there doesn't appear to be one.
+>>code
+	gpointer data;
+
+	data = gtk_object_get_data(GTK_OBJECT(mdi), MEL_MDI_CHILD_COUNT);
+	return GPOINTER_TO_INT(data);
+
+>>function set_child_count
+void
+GtkObject *mdi;	MDI to set count on
+int  count;     The new count to set
+>>description
+Set the child count.
+Would not be needed if you could get the number of children via
+a public interface.
+>>code
+
+	gtk_object_set_data(GTK_OBJECT(mdi),
+		MEL_MDI_CHILD_COUNT, GINT_TO_POINTER(count));
+
+
+>>function mel_ui_error
+void
+struct song *sd;
+char *msg;			The message to place in the dialog box
+GtkObject *parent;	The parent that the dialog 'belongs' to
+
+>>description
+Put up an error box.
+There can only be one error box active for a file at once although they
+are not modal.
+Another message will just cause the original to go away.
+If
+.A parent
+is supplied then when that object is destroyed or unmapped
+the dialog will be destroyed to.
+
+>>code
+	GtkWidget *dialog;
+
+	/* Destroy any old one */
+	reg_destroy(sd->dialog);
+
+	/* Create the gnome dialog */
+	dialog = gnome_error_dialog(msg);
+
+	sd->dialog = reg_object(GTK_OBJECT(dialog), (GtkObject*)parent);
+
+	/* Destroy dialog when the parent is hidden as well */
+	if (parent)
+		gtk_signal_connect_object_while_alive(GTK_OBJECT(parent), "hide"
+			, gtk_widget_destroy, GTK_OBJECT(dialog));
+
+
+
+>>function mel_add_view
+void
+GtkObject  *mdi;
+GtkObject  *child;
+GtkWidget  *view;
+gboolean   toplevel;  True if toplevel view required
+>>description
+Add the view to the child.
+We have to go in a very round about way of doing this...
+
+>>code
+
+	gtk_object_set_data(child, MEL_NEW_VIEW, view);
+
+	gnome_mdi_generic_child_set_view_creator
+		(GNOME_MDI_GENERIC_CHILD(child), create_view, NULL);
+
+	if (toplevel)
+		gnome_mdi_add_toplevel_view(GNOME_MDI(mdi), GNOME_MDI_CHILD(child));
+	else
+		gnome_mdi_add_view(GNOME_MDI(mdi), GNOME_MDI_CHILD(child));
+
+
+>>function mel_initial_view
+void
+GtkObject *mdi;
+GtkObject *child;
+struct rootElement *root;
+gboolean toplevel;  True if toplevel view required
+>>description
+Create the initial view on a file.
+
+>>code
+	GtkWidget *w;
+
+	/* Our initial view is the track based view */
+	w = melys_track_new(root);
+
+	if (toplevel) {
+		gtk_widget_set_usize
+			(w, 70*gdk_screen_width()/100, 70*gdk_screen_height()/100);
+	}
+
+	mel_add_view(mdi, child, w, toplevel);
+
+	while (gtk_events_pending())
+		gtk_main_iteration();
+
+	gnome_mdi_set_active_view(GNOME_MDI(mdi), w);
+
+>>function create_view
+static GtkWidget *
+GnomeMDIChild *child;
+gpointer data;
+
+>>description
+The view add interface to Gnome MDI is inside out, so we have
+to set a function into the child to create views.
+What we want to be able to do is create a view and then add it.
+Too simple?
+So we get round this by having our routine that adds the view
+save it as a property on the child.
+All this routine does is retreives it and returns it back
+into the depths of MDI.
+
+>>code
+	GtkWidget *w;
+
+	w = (GtkWidget*)gtk_object_get_data(GTK_OBJECT(child), MEL_NEW_VIEW);
+
+	if (w == NULL)
+		ethrow(debugError, "@func_name: NEW_VIEW not set up");
+
+	gtk_object_set_data(GTK_OBJECT(child), MEL_NEW_VIEW, 0);
+
+	return w;
+
+>>function add_view_cb
+static int
+GtkObject *mdi;       The mdi object
+GtkWidget *widget;   The newly added view
+gpointer user_data;  User data
+
+>>description
+Called when a view is added to a child of the mdi.
+XXX doesn't work anyway.
+
+>>code
+
+	dprintf1("@func_name: View Added (NOT IMPLEMENTED)");
+
+	return TRUE;
+
+
+>>function mel_debug_print_type
+void
+char *msg;     Message to print first
+GtkObject *o;  Object to print type of
+>>description
+Print out the type of the specified object.
+>>code
+
+	g_message("%s: %s\n", msg, gtk_type_name(GTK_OBJECT_TYPE(o)));
diff -rNu melys-0.0.4/gui/menus.c melys-0.0.5/gui/menus.c
--- melys-0.0.4/gui/menus.c	Fri Jul 30 00:43:19 1999
+++ melys-0.0.5/gui/menus.c	Mon Aug  9 00:51:35 1999
@@ -19,13 +19,14 @@
 #include "except.h"
 #include "util.h"
 #include "gnome.h"
-#include "melgui.h"
 #include "format.h"
 #include "melreg.h"
 #include "seqlib.h"
 #include "elements.h"
 #include "melmidi.h"
 #include "song.h"
+#include "melys.h"
+#include "melgui.h"
 #include "menus.h"
 #include "intl.h"
 
@@ -42,6 +43,7 @@
 static void stop_cb(GtkWidget *w, gpointer data);
 static void record_cb(GtkWidget *w, gpointer data);
 static void record_stop_cb(GtkWidget *w, gpointer data);
+static void about_cb(GtkWidget *w, gpointer data);
 
 
 /* The file menu */
@@ -108,6 +110,7 @@
 /* The help menu */
 GnomeUIInfo helpmenu[] = {
 	GNOMEUIINFO_HELP("melys"),
+	GNOMEUIINFO_MENU_ABOUT_ITEM(about_cb, NULL),
 	GNOMEUIINFO_END
 };
 
@@ -195,6 +198,7 @@
 	gchar *basename;
 	char *filename;
 	int  open_id;
+	int  count;
 
 	/* Get the filename that the user selected */
 	open_id = sd->open_dialog;
@@ -224,54 +228,34 @@
 		return;
 	}
 
+	gtk_widget_hide(GTK_WIDGET(sel));
+
 	mdi = sd->mdi;
 
 	/*
-	 * If this child already has a file or music data, then we need
-	 * to create a new file.  This will usually be the case except
-	 * after the first open.
+	 * Create a new child.  If the current one has not been
+	 * used, then it could be destroyed.
 	 */
-	if (sd->mdroot || sd->filename) {
-		int  count;
-
-		basename = g_basename(filename);
-		child = (GtkObject*)gnome_mdi_generic_child_new(basename);
-
-		sd = song_new(GTK_OBJECT(mdi), GTK_OBJECT(child));
-		sd->filename = filename;
-		sd->open_dialog = open_id;
-
-		count = get_child_count(mdi);
-		set_child_count(mdi, ++count);
-
-		gnome_mdi_generic_child_set_view_creator
-			(GNOME_MDI_GENERIC_CHILD(child), create_view, "FOO");
-		gnome_mdi_add_child(GNOME_MDI(mdi), GNOME_MDI_CHILD(child));
-		gnome_mdi_add_view(GNOME_MDI(mdi), GNOME_MDI_CHILD(child));
-	} else {
+	basename = g_basename(filename);
+	child = (GtkObject*)gnome_mdi_generic_child_new(basename);
 
-		/*
-		 * Destroy the existing child and replace with a new one
-		 * with the correct filename (TEMP code)
-		 */
-		basename = g_basename(filename);
-		gnome_mdi_child_set_name(GNOME_MDI_CHILD(child), basename);
-	}
+	sd = song_new(GTK_OBJECT(mdi), GTK_OBJECT(child));
+	sd->filename = filename;
 
-	{/* HACK alert, works but will be completely changed later */
-	extern GtkWidget *GlobalNewView;
+	/* Want to use the same open dialog, but not same save */
+	sd->open_dialog = open_id;
 
-	/* !!! need this */
-	while (gtk_events_pending())
-		gtk_main_iteration();
+	/* Add child and increase count */
+	gnome_mdi_add_child(GNOME_MDI(mdi), GNOME_MDI_CHILD(child));
 
-	gnome_mdi_set_active_view(GNOME_MDI(mdi), GlobalNewView);
-	}
-
-	gtk_widget_hide(GTK_WIDGET(sel));
+	count = get_child_count(mdi);
+	set_child_count(mdi, ++count);
 
 	/* read in the file */
 	song_open_file(sd, filename);
+
+	/* Create a track view (or users first choice view) of the song */
+	mel_initial_view(mdi, child, sd->mdroot, FALSE);
 }
 
 /*
@@ -295,9 +279,7 @@
 	child = sd->child;
 
 	/* Get a new file selection dialog or re-use the old one */
-	w = NULL;
-	if (sd->save_dialog)
-		w = reg_get_widget(sd->save_dialog);
+	w = reg_get_widget(sd->save_dialog);
 
 	if (w == NULL) {
 		w = gtk_file_selection_new(_("Select the file name to write to..."));
@@ -504,4 +486,33 @@
 	sd = get_song_from_mdi(mdi);
 	
 	song_record_stop(sd);
+}
+
+/*
+ * Show a dialog black on a dark background, only visible by
+ * vampires. None of the information is useful anyway so it
+ * doesn't matter much.
+ * 
+ *  Arguments:
+ *    w         - Widget event received on
+ *    data      - The mdi object
+ */
+static void 
+about_cb(GtkWidget *w, gpointer data)
+{
+	GtkWidget *about;
+	const gchar *authors[] = {
+		"Steve Ratcliffe <steve@parabola.demon.co.uk>",
+		NULL,
+	};
+
+	about = gnome_about_new("Melys",
+		MELYS_VERSION_STRING,
+		_("Copyright Steve Ratcliffe (C) 1999"),
+		authors,
+		_("Melys is a sequencer application for ALSA"),
+		NULL /* Logo */
+		);
+
+	gtk_widget_show(about);
 }
diff -rNu melys-0.0.4/gui/menus.m melys-0.0.5/gui/menus.m
--- melys-0.0.4/gui/menus.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/gui/menus.m	Mon Aug  9 00:05:59 1999
@@ -0,0 +1,504 @@
+>>name menus.m - Code for the menus.
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+>>header format.h
+>>header melreg.h
+>>header seqlib.h
+>>header elements.h
+>>header melmidi.h
+>>header song.h
+>>header melys.h
+>>header melgui.h
+>>headerdef --decl menus.h
+
+>>extern -a
+
+/* The file menu */
+GnomeUIInfo filemenu[] = {
+	GNOMEUIINFO_MENU_OPEN_ITEM(open_cb, NULL),
+	GNOMEUIINFO_MENU_CLOSE_ITEM(close_cb, NULL),
+	GNOMEUIINFO_MENU_SAVE_AS_ITEM(save_as_cb, NULL),
+	GNOMEUIINFO_SEPARATOR,
+	GNOMEUIINFO_MENU_EXIT_ITEM(exit_cb, NULL),
+	GNOMEUIINFO_END
+};
+
+/*
+ * The windows menu that allows you to switch between the different
+ * open files.  This is created empty of file names but will be
+ * filled in at run time
+ */
+GnomeUIInfo windowmenu[] = {
+	{GNOME_APP_UI_ITEM, N_("_Close all"), N_("Close all open windows"),
+		close_all_cb, (gpointer)0, (gpointer)0, /* Callback and data */
+		(GnomeUIPixmapType)0, NULL, /* Pixmap and info */
+		0, (GdkModifierType)0,  /* Accel */
+		(GtkWidget*)0 },
+	GNOMEUIINFO_SEPARATOR,
+	GNOMEUIINFO_END
+};
+
+/* The play menu */
+/* NOTE add accelerators later */
+GnomeUIInfo actionmenu[] = {
+	{GNOME_APP_UI_ITEM, N_("_Start"), N_("Start playing"),
+		start_cb, (gpointer)0, (gpointer)0, /* Callback and data */
+		GNOME_APP_PIXMAP_FILENAME, "../pixmaps/mplay.png", /* Pixmap */
+		GDK_Return, (GdkModifierType)0,  /* Accel */
+		(GtkWidget*)0 },
+		
+	{GNOME_APP_UI_ITEM, N_("_Pause"), N_("Pause playing"),
+		pause_cb, (gpointer)0, (gpointer)0, /* Callback and data */
+		GNOME_APP_PIXMAP_FILENAME, "../pixmaps/mpause.png", /* Pixmap */
+		'p', (GdkModifierType)0,  /* Accel */
+		(GtkWidget*)0 },
+
+	{GNOME_APP_UI_ITEM, N_("S_top"), N_("Stop and return to beginning"),
+		stop_cb, (gpointer)0, (gpointer)0, /* Callback and data */
+		GNOME_APP_PIXMAP_FILENAME, "../pixmaps/mstop.png", /* Pixmap */
+		' ', (GdkModifierType)0,  /* Accel */
+		(GtkWidget*)0 },
+
+	{GNOME_APP_UI_ITEM, N_("_Record"), N_("Start recording"),
+		record_cb, (gpointer)0, (gpointer)0, /* Callback and data */
+		GNOME_APP_PIXMAP_FILENAME, "../pixmaps/mb3.png", /* Pixmap */
+		GDK_KP_Add, (GdkModifierType)0,  /* Accel */
+		(GtkWidget*)0 },
+
+	{GNOME_APP_UI_ITEM, N_("Record stop"), N_("Stop recording"),
+		record_stop_cb, (gpointer)0, (gpointer)0, /* Callback and data */
+		0, NULL, /* Pixmap */
+		GDK_KP_Subtract, (GdkModifierType)0,  /* Accel */
+		(GtkWidget*)0 },
+
+	GNOMEUIINFO_END
+};
+
+/* The help menu */
+GnomeUIInfo helpmenu[] = {
+	GNOMEUIINFO_HELP("melys"),
+	GNOMEUIINFO_MENU_ABOUT_ITEM(about_cb, NULL),
+	GNOMEUIINFO_END
+};
+
+/* The menubar, made up of the file menu etc */
+GnomeUIInfo menubar[] = {
+	GNOMEUIINFO_MENU_FILE_TREE(filemenu),
+	GNOMEUIINFO_SUBTREE(N_("_Actions"), actionmenu),
+	GNOMEUIINFO_MENU_WINDOWS_TREE(windowmenu),
+	GNOMEUIINFO_MENU_HELP_TREE(helpmenu),
+	GNOMEUIINFO_END
+};
+
+
+>>function mel_init_menus
+void
+GnomeMDI *mdi;      MDI widget
+>>description
+Initialise the menus for the application.
+
+>>code
+
+	gnome_mdi_set_menubar_template(mdi, menubar);
+	gnome_mdi_set_child_list_path(mdi, "Windows/<Separator>");
+
+
+>>#  Callback functions.
+
+>>function open_cb
+static void
+GtkWidget *wid;  widget event received on
+gpointer  data;  This will be the mdi widget
+
+>>description
+Bring up a file dialog.
+It is either re-used or created from scratch.
+This function is called when the user selects open from
+the menu.
+
+There is no gnome dialog yet, but it will be used when there is
+one.
+
+>>code
+	GtkObject *mdi = data;
+	GtkObject *child;
+	struct song *sd;
+	GtkWidget *w;
+	GtkFileSelection *sel;
+
+	sd = get_song_from_mdi(mdi);
+	child = sd->child;
+
+	/* Get a new file selection dialog or re-use the old one */
+	w = NULL;
+	if (sd->open_dialog)
+		w = reg_get_widget(sd->open_dialog);
+
+	if (w == NULL) {
+		w = gtk_file_selection_new(_("Select the file to read in..."));
+		sel = GTK_FILE_SELECTION(w);
+		sd->open_dialog = reg_object(GTK_OBJECT(sel), GTK_OBJECT(child));
+
+		gtk_signal_connect(GTK_OBJECT(sel->ok_button), "clicked",
+			open_ok_cb, child);
+		gtk_signal_connect(GTK_OBJECT(sel->cancel_button), "clicked",
+			file_cancel_cb, sel);
+	} else {
+
+		/* Else reuse it, and ensure raised */
+		gdk_window_raise(w->window);
+	}
+	gtk_widget_show(w);
+
+
+>>function open_ok_cb
+static void
+GtkWidget *button;
+gpointer  data;
+
+>>description
+Open a file.
+A new child window will be created if necessary.
+
+>>code
+	GtkObject  *mdi;
+	GtkObject *child = GTK_OBJECT(data);
+	struct song *sd = song_get_data(child);
+	GtkFileSelection *sel;
+	fileReadFunc readfn;
+	gchar *basename;
+	char *filename;
+	int  open_id;
+	int  count;
+
+	/* Get the filename that the user selected */
+	open_id = sd->open_dialog;
+	sel = (GtkFileSelection*)reg_get(open_id);
+	if (sel == NULL) {
+		printf("NO sel\n");
+		return;
+	}
+	filename = gtk_file_selection_get_filename(sel);
+
+	/* Try to guess its type */
+	readfn = file_guess_read_func(filename);
+	if (readfn == NULL) {
+		char *msg;
+
+		/* Failed so put up a message for the user */
+		msg = g_strdup_printf(_("The file %s\n"
+			"does not have a known extension.\n"
+			"Please select a file with an\n"
+			"extension of .mid or .mdml"
+			), filename);
+
+		mel_ui_error(sd, msg, GTK_OBJECT(sel));
+
+		g_free(msg);
+
+		return;
+	}
+
+	gtk_widget_hide(GTK_WIDGET(sel));
+
+	mdi = sd->mdi;
+
+	/*
+	 * Create a new child.  If the current one has not been
+	 * used, then it could be destroyed.
+	 */
+	basename = g_basename(filename);
+	child = (GtkObject*)gnome_mdi_generic_child_new(basename);
+
+	sd = song_new(GTK_OBJECT(mdi), GTK_OBJECT(child));
+	sd->filename = filename;
+
+	/* Want to use the same open dialog, but not same save */
+	sd->open_dialog = open_id;
+
+	/* Add child and increase count */
+	gnome_mdi_add_child(GNOME_MDI(mdi), GNOME_MDI_CHILD(child));
+
+	count = get_child_count(mdi);
+	set_child_count(mdi, ++count);
+
+	/* read in the file */
+	song_open_file(sd, filename);
+
+	/* Create a track view (or users first choice view) of the song */
+	mel_initial_view(mdi, child, sd->mdroot, FALSE);
+
+
+
+>>function save_as_cb
+static void
+GtkWidget *mi;    The menu item selected
+gpointer  data;   The mdi object
+
+>>description
+Bring up a save-as dialog and write the song to the selected file.
+
+>>code
+	GtkObject *mdi = data;
+	GtkObject *child;
+	struct song *sd;
+	GtkWidget *w;
+	GtkFileSelection *sel;
+
+	sd = get_song_from_mdi(mdi);
+	child = sd->child;
+
+	/* Get a new file selection dialog or re-use the old one */
+	w = reg_get_widget(sd->save_dialog);
+
+	if (w == NULL) {
+		w = gtk_file_selection_new(_("Select the file name to write to..."));
+		sel = GTK_FILE_SELECTION(w);
+		sd->save_dialog = reg_object(GTK_OBJECT(sel), GTK_OBJECT(child));
+
+		gtk_signal_connect(GTK_OBJECT(sel->ok_button), "clicked",
+			save_ok_cb, child);
+		gtk_signal_connect(GTK_OBJECT(sel->cancel_button), "clicked",
+			file_cancel_cb, sel);
+	} else {
+
+		/* Else reuse it, and ensure raised */
+		gdk_window_raise(w->window);
+	}
+	gtk_widget_show(w);
+
+
+>>function save_ok_cb
+static void
+GtkWidget *button;
+gpointer  data;
+
+>>description
+User has selected a file to write to.
+All we now have to do is write it out!
+
+>>code
+	GtkObject  *mdi;
+	GtkObject *child = GTK_OBJECT(data);
+	struct song *sd = song_get_data(child);
+	GtkFileSelection *sel;
+	fileWriteFunc writefn;
+	char *filename;
+	int  save_id;
+
+	/* Get the filename that the user selected */
+	save_id = sd->save_dialog;
+	sel = (GtkFileSelection*)reg_get(save_id);
+	if (sel == NULL) {
+		printf("NO sel\n");
+		return;
+	}
+	filename = gtk_file_selection_get_filename(sel);
+
+	/* Try to guess its type */
+	writefn = file_guess_write_func(filename);
+	if (writefn == NULL) {
+		char *msg;
+
+		/* Failed so put up a message for the user */
+		msg = g_strdup_printf(_("The file %s\n"
+			"does not have a known extension.\n"
+			"Please select a file with an\n"
+			"extension of .mid or .mdml"
+			), filename);
+
+		mel_ui_error(sd, msg, GTK_OBJECT(sel));
+
+		g_free(msg);
+
+		return;
+	}
+
+	mdi = sd->mdi;
+
+	gtk_widget_hide(GTK_WIDGET(sel));
+
+	/* write out the file */
+	writefn(filename, sd->mdroot, 0);
+
+
+
+
+>>function file_cancel_cb
+static void
+GtkWidget *button;
+gpointer  data;
+>>description
+Cancel has been clicked, so just hide the dialog.
+Allows you to carry on from where you left off after a cancel.
+
+>>code
+	GtkWidget *w = GTK_WIDGET(data);
+
+	gtk_widget_hide(w);
+
+
+>>function close_cb
+static void
+GtkWidget *w;    Widget event received on
+gpointer  data; This will be the mdi widget
+
+>>description
+This function is called when the user clicks on the close
+menu item.
+
+>>code
+	GtkObject *mdi = GTK_OBJECT(data);
+	struct song *sd = get_song_from_mdi(mdi);
+	int  count;
+
+	count = get_child_count(mdi);
+	if (count > 1 && sd->child) {
+		gnome_mdi_remove_child(GNOME_MDI(mdi), GNOME_MDI_CHILD(sd->child), 0);
+		set_child_count(mdi, --count);
+	}
+
+>>function close_all_cb
+static void
+GtkWidget *w;    Widget event received on
+gpointer  data;  This will be the mdi widget
+>>description
+Close all the open windows.
+
+>>code
+	GnomeMDI *mdi = GNOME_MDI(data);
+	
+	g_warning("Close all not fully implemented yet");
+	gnome_mdi_remove_all(mdi, 0);
+
+>>function exit_cb
+static void
+GtkWidget *w;   widget event received on
+gpointer  data; This will be the mdi widget
+
+>>description
+This function is called when the user clicks on the close
+menu item.
+
+>>code
+	GnomeMDI *mdi = GNOME_MDI(data);
+
+	/* TODO: check for unsaved stuff */
+
+	/* Make some attempt to clean up to help in memleak detection */
+	gnome_mdi_remove_all(mdi, FALSE);
+	gtk_object_destroy(GTK_OBJECT(mdi));
+
+	while (gtk_events_pending())
+		gtk_main_iteration();
+
+	gtk_main_quit();
+
+
+>>function start_cb
+static void
+GtkWidget *w;    Widget event received on
+gpointer  data;  The mdi object
+
+>>description
+Start playing the song.
+
+>>code
+	GtkObject *mdi = GTK_OBJECT(data);
+	struct song *sd;
+
+	sd = get_song_from_mdi(mdi);
+	
+	song_play_start(sd);
+
+>>function pause_cb
+static void
+GtkWidget *w;    Widget event received on
+gpointer  data;  The mdi object
+>>code
+	GtkObject *mdi = GTK_OBJECT(data);
+	struct song *sd;
+
+	sd = get_song_from_mdi(mdi);
+	
+	song_play_pause(sd);
+
+>>function stop_cb
+static void
+GtkWidget *w;    Widget event received on
+gpointer  data;  The mdi object
+
+>>code
+	GtkObject *mdi = GTK_OBJECT(data);
+	struct song *sd;
+
+	sd = get_song_from_mdi(mdi);
+	
+	song_play_stop(sd);
+
+
+>>function record_cb
+static void
+GtkWidget *w;    Widget event received on
+gpointer  data;  The mdi object
+
+>>code
+	GtkObject *mdi = GTK_OBJECT(data);
+	struct song *sd;
+
+	sd = get_song_from_mdi(mdi);
+	
+	song_record_start(sd);
+
+
+>>function record_stop_cb
+static void
+GtkWidget *w;    Widget event received on
+gpointer  data;  The mdi object
+
+>>code
+	GtkObject *mdi = GTK_OBJECT(data);
+	struct song *sd;
+
+	sd = get_song_from_mdi(mdi);
+	
+	song_record_stop(sd);
+
+
+
+
+>>function about_cb
+static void
+GtkWidget *w;   Widget event received on
+gpointer  data; The mdi object
+
+>>description
+Show a dialog black on a dark background, only visible by vampires.
+None of the information is useful anyway so it doesn't matter much.
+
+>>code
+	GtkWidget *about;
+	const gchar *authors[] = {
+		"Steve Ratcliffe <steve@{@}parabola.demon.co.uk>",
+		NULL,
+	};
+
+	about = gnome_about_new("Melys",
+		MELYS_VERSION_STRING,
+		_("Copyright Steve Ratcliffe (C) 1999"),
+		authors,
+		_("Melys is a sequencer application for ALSA"),
+		NULL /* Logo */
+		);
+
+	gtk_widget_show(about);
diff -rNu melys-0.0.4/help/C/Makefile melys-0.0.5/help/C/Makefile
--- melys-0.0.4/help/C/Makefile	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/help/C/Makefile	Fri Aug  6 22:09:01 1999
@@ -0,0 +1,7 @@
+
+# Stuff that gets created and needs removing.
+#
+JUNKFILES = melys.tex melys.junk melys.log melys.aux melys.dvi
+
+clean:
+	rm -rf $(JUNKFILES) core
diff -rNu melys-0.0.4/help/C/melys.sgml melys-0.0.5/help/C/melys.sgml
--- melys-0.0.4/help/C/melys.sgml	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/help/C/melys.sgml	Sat Aug  7 01:04:16 1999
@@ -0,0 +1,183 @@
+<!DOCTYPE BOOK PUBLIC "-//Davenport//DTD DocBook V3.0//EN" [
+<!entity mel "Melys">
+<!entity mdml "<command/MDML/">
+<!ENTITY GNOME-APPS SYSTEM "melys.sgml">] >
+
+<Book id="melys">
+
+<title>Melys User's Guide</title>
+
+<bookinfo>
+
+<authorgroup>
+<author>
+	<firstname>Steve</firstname><surname>Ratcliffe</surname>
+</author>
+</authorgroup>
+
+<legalnotice>
+<para>
+This document can be freely redistributed according to the
+terms of the GNU General Public License.</para>
+</legalnotice>
+
+<copyright>
+<year>1999</year>
+<holder>Steve Ratcliffe</holder>
+</copyright>
+
+<address>
+<city>London</city>
+<email>steve@parabola.demon.co.uk</email>
+</address>
+
+</bookinfo>
+
+<toc></toc>
+  
+<chapter id="menus">
+<title>Menus</title>
+
+<para>
+	This section deals with all the title bar menus
+	that can be used in Melys.
+	Many of the features can also be driven by the keyboard
+	and in most cases this is the best way to work.
+	Keyboard short-cuts are shown to the right on each
+	menu entry.
+
+<sect1><title>Title bar menus
+<sect2><title><GUImenu/File/
+<para>
+	This is the standard file menu that allows you to open and
+	save files and exit the application.
+
+<variablelist>
+
+<varlistentry>
+<term><GUImenuItem/Open/
+<listitem>
+<para>
+	This will bring up a dialog box that will allow you to
+	select a file to read.
+	You may select any file type that &mel; knows how to read.
+	At the current time this includes MIDI files ending
+	in <filename/.mid/ or <filename/.smf/ and &mdml; files
+	ending in <filename/.mdml/.
+	It will also read compressed &mdml;, files that are compressed
+	with gzip and have a <filename/.mdml.gz/ ending.
+
+	<para>
+
+	You can have several files open at once, unlike many sequencer
+	programs.
+	They appear in a notebook format and you can select the current
+	file by clicking on the notebook tabs.
+	It is also possible to drag the notebook tabs off the
+	the application window, this will create a new top level
+	window, containing that file.
+
+<varlistentry>
+<term><GUImenuitem/Close/
+<listitem><para>
+	This will close the current file.
+	If the file is playing it will stop.
+</para>
+<warning>
+<para>
+	There are currently no warnings if it has not been saved.
+</warning>
+
+<!--
+<varlistentry>
+<term><GUImenuitem/New/
+<listitem><para>
+-->
+
+<varlistentry>
+<term><GUImenuitem/Save as.../
+<listitem><para>
+	Save the current file with a specified filename.
+	A dialog box is brought up to allow the name to be specified.
+
+<varlistentry>
+<term><GUImenuitem/Exit/
+<listitem><para>
+	Exits &mel;.
+	<warning><para>There is currently no warning if files are not saved.
+	</warning>
+
+</variablelist>
+
+<sect2><title><GUImenu/Actions/
+<variablelist>
+
+<varlistentry>
+<term><GUImenuitem/Play/
+<listitem><para>
+	Starts the current file playing.
+	Has no effect if the file is already playing.
+	It is (currently) possible to start another file at the same
+	time that another is playing.
+	This will probably be disallowed or modified in future.
+
+<varlistentry>
+<term><GUImenuitem/Pause/
+<listitem><para>
+	The playing file is stopped temporarily.
+	If <GUImenuitem/play/ is later selected the song
+	will continue from the same point that it stopped at.
+
+<varlistentry>
+<term><GUImenuitem/Stop/
+<listitem><para>
+	The playing file is stopped.
+	If the file is re started it will begin playing from the beginning.
+
+<varlistentry>
+<term><GUImenuitem/Record/
+<listitem><para>
+	Recording starts.
+	If the file is not already playing, then it will start to play.
+	A new part will be created that contains all midi events received
+	until <GUImenuitem/Record stop/ or <GUImenuitem/Stop/ is selected.
+	<para>
+	Currently you can only record to a new track.
+	The new track can have several parts though.
+
+<varlistentry>
+<term><GUImenuitem/Record stop/
+<listitem><para>
+	Recording is stopped.
+	The song will continue playing if it has not already
+	finished and recording will be restarted by selecting
+	<GUImenuitem/Record/ again.
+
+</variablelist>
+
+<sect2><title><GUImenu/Windows/
+<para>
+	This menu contains an entry for each open file.
+	Any file can be selected from this menu and it will be brought
+	to the front.
+	This will work even if the file is in another window.
+
+	<para>
+
+	In addition there are the following entries.
+
+<variablelist>
+<varlistentry>
+<term><GUImenuitem/Close all/
+<listitem><para>
+	This will close all open windows.
+	Not currently useful - next operation will exit the sequencer.
+
+</variablelist>
+
+<sect2><title><GUImenu/Help/
+<para>
+This menu contains the usual useless information.
+
+</chapter>
+</book>
diff -rNu melys-0.0.4/include/elements.h melys-0.0.5/include/elements.h
--- melys-0.0.4/include/elements.h	Fri Jul 30 00:43:14 1999
+++ melys-0.0.5/include/elements.h	Mon Aug  9 00:51:30 1999
@@ -52,6 +52,7 @@
 	struct containerElement parent;
 	struct headElement *head;	/* Pointer to the head information */
 	short  tracks;		/* Number of tracks */
+	int    refcount;	/* Reference count of users */
 };
 #define MD_ROOT(e) \
 	((struct rootElement *)md_check_cast((struct element *)(e), MD_TYPE_ROOT))
@@ -74,6 +75,7 @@
 
 struct trackElement {
 	struct containerElement parent;
+	char *name;	/* Name of track */
 };
 #define MD_TRACK(e) \
 	((struct trackElement *)md_check_cast((struct element *)(e), MD_TYPE_TRACK))
@@ -99,6 +101,7 @@
 
 struct partElement {
 	struct containerElement parent;
+	char *name;		/* Part name */
 };
 #define MD_PART(e) \
 	((struct partElement *)md_check_cast((struct element *)(e), MD_TYPE_PART))
@@ -228,12 +231,12 @@
 	((struct smpteoffsetElement *)md_check_cast((struct element *)(e), MD_TYPE_SMPTEOFFSET))
 	
 
-struct element *md_element_new();
-struct containerElement *md_container_new();
+struct element *md_element_new(void);
+struct containerElement *md_container_new(void);
 struct rootElement *md_root_new(void);
 struct headElement *md_head_new(void);
 struct trackElement *md_track_new(void);
-struct tempomapElement *md_tempomap_new();
+struct tempomapElement *md_tempomap_new(void);
 struct noteElement *md_note_new(char note, char vel, short length);
 struct partElement *md_part_new(void);
 struct takeElement *md_take_new(void);
@@ -243,8 +246,8 @@
 struct pressureElement *md_pressure_new(int vel);
 struct pitchElement *md_pitch_new(int val);
 struct sysexElement *md_sysex_new(int status, unsigned char *data, int len);
-struct metaElement *md_meta_new();
-struct mapElement *md_map_new();
+struct metaElement *md_meta_new(void);
+struct mapElement *md_map_new(void);
 struct keysigElement *md_keysig_new(short key, short minor);
 struct timesigElement *md_timesig_new(short top, short bottom, short clocks, 
         short n32pq);
diff -rNu melys-0.0.4/include/md.h melys-0.0.5/include/md.h
--- melys-0.0.4/include/md.h	Fri Jul 30 00:43:14 1999
+++ melys-0.0.5/include/md.h	Mon Aug  9 00:51:30 1999
@@ -50,4 +50,5 @@
 struct element *md_sequence_next(struct sequenceState *seq);
 void md_sequence_end(struct sequenceState *seq);
 unsigned long md_sequence_duration(struct sequenceState *seq);
-struct rootElement *md_empty();
+struct rootElement *md_empty(void);
+struct trackElement *md_track_nth(struct rootElement *root, int n);
diff -rNu melys-0.0.4/include/mdrw.h melys-0.0.5/include/mdrw.h
--- melys-0.0.4/include/mdrw.h	Fri Jul 30 00:43:14 1999
+++ melys-0.0.5/include/mdrw.h	Mon Aug  9 00:51:30 1999
@@ -19,5 +19,5 @@
 
 struct rootElement *mdml_read_file(char *filename);
 
-void mdml_write(FILE *fp, struct rootElement *root);
+void mdml_write(FILE *fp, struct rootElement *root, int flags);
 void mdml_write_file(char *name, struct rootElement *root, int flags);
diff -rNu melys-0.0.4/include/melgui.h melys-0.0.5/include/melgui.h
--- melys-0.0.4/include/melgui.h	Fri Jul 30 00:43:15 1999
+++ melys-0.0.5/include/melgui.h	Mon Aug  9 00:51:30 1999
@@ -19,5 +19,8 @@
 int get_child_count(GtkObject *mdi);
 void set_child_count(GtkObject *mdi, int count);
 void mel_ui_error(struct song *sd, char *msg, GtkObject *parent);
-/*XXX static*/GtkWidget *create_view(GtkObject *child, gpointer data);
+void mel_add_view(GtkObject *mdi, GtkObject *child, GtkWidget *view, 
+        gboolean toplevel);
+void mel_initial_view(GtkObject *mdi, GtkObject *child, 
+        struct rootElement *root, gboolean toplevel);
 void mel_debug_print_type(char *msg, GtkObject *o);
diff -rNu melys-0.0.4/include/melmidi.h melys-0.0.5/include/melmidi.h
--- melys-0.0.4/include/melmidi.h	Fri Jul 30 00:43:15 1999
+++ melys-0.0.5/include/melmidi.h	Mon Aug  9 00:51:31 1999
@@ -19,11 +19,10 @@
 struct play;
 struct seq_context;
 
-struct play *play_new();
+struct play *play_new(void);
 void play_free(struct play *play);
 void play_set_mdroot(struct play *play, struct rootElement *root);
 void play_set_ports(struct play *play);
-void XXX_REMOVE_play_open_ports(struct play *play);
 void play_start(struct play *play);
 void play_pause(struct play *play);
 void play_stop(struct play *play);
diff -rNu melys-0.0.4/include/melys.h melys-0.0.5/include/melys.h
--- melys-0.0.4/include/melys.h	Fri Jul 30 00:43:15 1999
+++ melys-0.0.5/include/melys.h	Mon Aug  9 00:51:31 1999
@@ -17,4 +17,5 @@
 
 #define PACKAGE "melys"
 #define LOCALEDIR "foo"
+#define MELYS_VERSION_STRING "0.0.4"
 
diff -rNu melys-0.0.4/include/melystrack.h melys-0.0.5/include/melystrack.h
--- melys-0.0.4/include/melystrack.h	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/include/melystrack.h	Mon Aug  9 00:51:31 1999
@@ -0,0 +1,53 @@
+/*
+ * 
+ * Copyright (C) 1999 Steve Ratcliffe
+ * 
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ * 
+ *  This program 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 General Public License for more details.
+ * 
+ * 
+ * 
+ */
+
+#define MELYS_TRACK(obj) GTK_CHECK_CAST(obj, melys_track_get_type(), MelysTrack)
+#define MELYS_TRACK_CLASS(klass) GTK_CHECK_CLASS_CAST(klass, melys_track_get_type(), MelysTrackClass)
+#define IS_MELYS_TRACK(obj) GTK_CHECK_TYPE(obj, melys_track_get_type())
+
+typedef struct _MelysTrack   MelysTrack;
+typedef struct _MelysTrackClass   MelysTrackClass;
+
+
+struct _MelysTrack {
+	GtkVBox vbox;
+
+	GtkAdjustment *vadj;
+	GtkAdjustment *hadj;
+
+	MelysTrackInfo *info;
+	MelysTrackDisplay *display;
+
+	struct rootElement *mdroot;
+};
+
+struct _MelysTrackClass {
+	GtkVBoxClass parent_class;
+	// XXX class definition here
+};
+
+/*
+ * Definitions that are shared between the two panes
+ */
+#define TRACK_DEF_HEIGHT    16
+#define TRACK_SEPARATION     2
+#define TRACK_TITLE_HEIGHT  20
+
+
+guint melys_track_get_type(void);
+GtkWidget *melys_track_new(struct rootElement *root);
+void melys_track_set_md_root(MelysTrack *mtrack, struct rootElement *root);
diff -rNu melys-0.0.4/include/melystrackdisplay.h melys-0.0.5/include/melystrackdisplay.h
--- melys-0.0.4/include/melystrackdisplay.h	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/include/melystrackdisplay.h	Mon Aug  9 00:51:31 1999
@@ -0,0 +1,36 @@
+/*
+ * 
+ * Copyright (C) 1999 Steve Ratcliffe
+ * 
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ * 
+ *  This program 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 General Public License for more details.
+ * 
+ * 
+ */
+
+#define MELYS_TRACK_DISPLAY(obj) GTK_CHECK_CAST(obj, melys_track_display_get_type(), MelysTrackDisplay)
+#define MELYS_TRACK_DISPLAY_CLASS(klass) GTK_CHECK_CLASS_CAST(klass, melys_track_display_get_type(), MelysTrackDisplayClass)
+#define IS_MELYS_TRACK_DISPLAY(obj) GTK_CHECK_TYPE(obj, melys_track_display_get_type())
+
+typedef struct _MelysTrackDisplay   MelysTrackDisplay;
+typedef struct _MelysTrackDisplayClass   MelysTrackDisplayClass;
+
+
+struct _MelysTrackDisplay {
+	GtkVBox vbox;
+	// XXX object definition here
+};
+
+struct _MelysTrackDisplayClass {
+	GtkVBoxClass parent_class;
+	// XXX class definition here
+};
+
+guint melys_track_display_get_type(void);
+GtkWidget *melys_track_display_new(void);
diff -rNu melys-0.0.4/include/melystrackinfo.h melys-0.0.5/include/melystrackinfo.h
--- melys-0.0.4/include/melystrackinfo.h	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/include/melystrackinfo.h	Mon Aug  9 00:51:31 1999
@@ -0,0 +1,82 @@
+/*
+ * 
+ * Copyright (C) 1999 Steve Ratcliffe
+ * 
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ * 
+ *  This program 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 General Public License for more details.
+ * 
+ * 
+ */
+
+#define MELYS_TRACK_INFO(obj) GTK_CHECK_CAST(obj, melys_track_info_get_type(), MelysTrackInfo)
+#define MELYS_TRACK_INFO_CLASS(klass) GTK_CHECK_CLASS_CAST(klass, melys_track_info_get_type(), MelysTrackInfoClass)
+#define IS_MELYS_TRACK_INFO(obj) GTK_CHECK_TYPE(obj, melys_track_info_get_type())
+
+typedef struct _MelysTrackInfo   MelysTrackInfo;
+typedef struct _MelysTrackInfoClass   MelysTrackInfoClass;
+
+
+#define MAX_COLUMNS 30
+
+
+struct _MelysTrackInfo {
+	GtkWidget widget;
+
+	/* The adjustment for vertical scrolling */
+	GtkAdjustment *vadj;
+
+	/* Amount of vertical scrolling, in tracks (you never see half a track) */
+	int  voffset;
+
+	/* The titles are drawn in their own window (do we really need this?) */
+	GdkWindow *title_window;
+
+	/*
+	 * The columns are configurable in terms of which ones exist and
+	 * which order they appear in (or will be).
+	 * The following variables hold the current configuration.
+	 */
+	struct col_info *col_infos;	/* Columns in use */
+	gint   col_used;	/* Number of columns in use */
+
+	/*
+	 * The amount of vertical space used by tracks is under control of
+	 * the parent MelysTrack widget.  This is because we must be in
+	 * sync between MelysTrackInfo and MelysTrackDisplay.
+	 */
+
+	/* The amount of vertical space that a track takes up */
+	int  vspace;
+	int  height;	/* without separation */
+	int  htitle;	/* Title height */
+	int  vtitle;	/* Title vertical space */
+
+	/* The offset from the top of allocated space to text baseline */
+	int  vtextoffset;
+
+	/* Allocated area that track information is being displayed in */
+	GdkRectangle track_area;
+
+	/* The actual composition that is being displayed */
+	struct rootElement *mdroot;
+};
+
+struct _MelysTrackInfoClass {
+	GtkWidgetClass parent_class;
+	// XXX class definition here
+};
+
+guint melys_track_info_get_type(void);
+GtkWidget *melys_track_info_new(GtkAdjustment *vadj);
+void melys_track_info_set_height(MelysTrackInfo *minfo, int height, 
+        int htitle);
+void melys_track_info_set_md_root(MelysTrackInfo *minfo, 
+        struct rootElement *root);
+int y_to_track(MelysTrackInfo *minfo, int ypix);
+char *get_info_string(MelysTrackInfo *minfo, int itype, int ntrack);
diff -rNu melys-0.0.4/include/melystransport.h melys-0.0.5/include/melystransport.h
--- melys-0.0.4/include/melystransport.h	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/include/melystransport.h	Mon Aug  9 00:51:31 1999
@@ -0,0 +1,36 @@
+/*
+ * 
+ * Copyright (C) 1999 Steve Ratcliffe
+ * 
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ * 
+ *  This program 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 General Public License for more details.
+ * 
+ * 
+ */
+
+#define MELYS_TRANSPORT(obj) GTK_CHECK_CAST(obj, melys_transport_get_type(), MelysTransport)
+#define MELYS_TRANSPORT_CLASS(klass) GTK_CHECK_CLASS_CAST(klass, melys_transport_get_type(), MelysTransportClass)
+#define IS_MELYS_TRANSPORT(obj) GTK_CHECK_TYPE(obj, melys_transport_get_type())
+
+typedef struct _MelysTransport   MelysTransport;
+typedef struct _MelysTransportClass   MelysTransportClass;
+
+
+struct _MelysTransport {
+	GtkDrawingArea drawing_area;
+	// XXX object definition here
+};
+
+struct _MelysTransportClass {
+	GtkDrawingAreaClass parent_class;
+	// XXX class definition here
+};
+
+guint melys_transport_get_type(void);
+GtkWidget *melys_transport_new(void);
diff -rNu melys-0.0.4/include/song.h melys-0.0.5/include/song.h
--- melys-0.0.4/include/song.h	Fri Jul 30 00:43:13 1999
+++ melys-0.0.5/include/song.h	Mon Aug  9 00:51:29 1999
@@ -22,6 +22,7 @@
  * The following are properties that can be set on the mdi child
  */
 #define MEL_SONG_DATA    "SONG_DATA"
+#define MEL_NEW_VIEW     "NEW_VIEW"
 
 
 /*
@@ -51,8 +52,8 @@
 
 
 void song_open_file(struct song *song, char *filename);
-void song_set_echo();
-void song_reset_echo();
+void song_set_echo(void);
+void song_reset_echo(void);
 void song_play_start(struct song *song);
 void song_play_pause(struct song *song);
 void song_play_stop(struct song *song);
diff -rNu melys-0.0.4/include/util.h melys-0.0.5/include/util.h
--- melys-0.0.4/include/util.h	Fri Jul 30 00:43:15 1999
+++ melys-0.0.5/include/util.h	Mon Aug  9 00:51:30 1999
@@ -22,3 +22,80 @@
 
 /* End of an array for use in loops */
 #define ENDOF(a) ((a) + NELEM(a))
+
+#define DEBUG /* XXX */
+#ifdef DEBUG
+
+/*
+ * Debugging stuff.
+ */
+
+extern int  DBlevel;
+
+#ifdef	__GNUC__
+#define	dprintf(level, format, args...) mel_debug_printf(level, format, ##args)
+#define dprintf1(format, args...) mel_debug_printf(1, format, ##args)
+#define dprintf2(format, args...) mel_debug_printf(2, format, ##args)
+
+#else	/* !__GNUC__ */
+
+/* Sorry, this doesn't look too good */
+static void
+dprintf(int level, const gchar *format, ...)
+{
+  va_list args;
+  if (DBlevel < level)
+  	return;
+
+  va_start (args, format);
+  fvprintf(stderr, format, args);
+  va_end (args);
+  fprintf(stderr, "\n");
+}
+static void
+dprintf1(const gchar *format, ...)
+{
+  va_list args;
+  if (DBlevel < 1)
+  	return;
+
+  va_start (args, format);
+  fvprintf(stderr, format, args);
+  va_end (args);
+  fprintf(stderr, "\n");
+}
+static void
+dprintf2(const gchar *format, ...)
+{
+  va_list args;
+  if (DBlevel < 2)
+  	return;
+
+  va_start (args, format);
+  fvprintf(stderr, format, args);
+  va_end (args);
+  fprintf(stderr, "\n");
+}
+
+#endif
+
+#else /* !DEBUG */
+
+#ifdef	__GNUC__
+#define	dprintf(level, format, args...)
+#define dprintf1(format, args...)
+#define dprintf2(format, args...)
+
+#else	/* !__GNUC__ */
+
+/* NB: expression may still be evaluated */
+#define	dprintf  (void)
+#define dprintf1 (void)
+#define dprintf2 (void)
+
+#endif
+
+#endif /* DEBUG */
+
+
+void mel_debug_printf(int level, char *fmt, ...);
diff -rNu melys-0.0.4/md/.cvsignore melys-0.0.5/md/.cvsignore
--- melys-0.0.4/md/.cvsignore	Fri Jul 30 00:43:12 1999
+++ melys-0.0.5/md/.cvsignore	Mon Aug  9 00:51:27 1999
@@ -1,6 +1,5 @@
 elements.c
 mdutil.c
 Makefile
-*.mdml
-*.mid
+*.mdml *.mdml.gz *.mid
 .cvsignore
diff -rNu melys-0.0.4/md/elements.c melys-0.0.5/md/elements.c
--- melys-0.0.4/md/elements.c	Fri Jul 30 00:43:18 1999
+++ melys-0.0.5/md/elements.c	Mon Aug  9 00:51:34 1999
@@ -34,7 +34,7 @@
  * Create and initialise a element element.
  */
 struct element *
-md_element_new()
+md_element_new(void)
 {
 	struct element *  new;
 
@@ -47,7 +47,7 @@
  * Create and initialise a container element.
  */
 struct containerElement *
-md_container_new()
+md_container_new(void)
 {
 	struct containerElement *  new;
 
@@ -82,6 +82,7 @@
 	MD_ELEMENT(new)->type = MD_TYPE_ROOT;
 	md_container_init(MD_CONTAINER(new));
 	new->head = NULL;
+	new->refcount = 1;
 	return new;
 }
 
@@ -114,6 +115,7 @@
 	new = g_malloc0(sizeof(*new));
 	MD_ELEMENT(new)->type = MD_TYPE_TRACK;
 	md_container_init(MD_CONTAINER(new));
+	new->name = NULL;
 	return new;
 }
 
@@ -121,7 +123,7 @@
  * Create and initialise a tempomap element.
  */
 struct tempomapElement *
-md_tempomap_new()
+md_tempomap_new(void)
 {
 	struct tempomapElement *  new;
 
@@ -159,6 +161,7 @@
 	new = g_malloc0(sizeof(*new));
 	MD_ELEMENT(new)->type = MD_TYPE_PART;
 	md_container_init(MD_CONTAINER(new));
+	new->name = NULL;
 	return new;
 }
 
@@ -273,7 +276,7 @@
  * Create and initialise a meta element.
  */
 struct metaElement *
-md_meta_new()
+md_meta_new(void)
 {
 	struct metaElement *  new;
 
@@ -286,7 +289,7 @@
  * Create and initialise a map element.
  */
 struct mapElement *
-md_map_new()
+md_map_new(void)
 {
 	struct mapElement *  new;
 
@@ -432,6 +435,11 @@
 	struct containerElement *c;
 	int  i;
 	
+	if (el->type == MD_TYPE_ROOT) {
+		if (--MD_ROOT(el)->refcount > 0)
+			return;
+	}
+
 	if (el->type >= MD_CONTAINER_BEGIN) {
 		c = MD_CONTAINER(el);
 		for (i = 0; i < c->elements->len; i++) {
diff -rNu melys-0.0.4/md/elements.m melys-0.0.5/md/elements.m
--- melys-0.0.4/md/elements.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/md/elements.m	Fri Aug  6 11:55:29 1999
@@ -0,0 +1,325 @@
+>>name elements.m
+
+File: elements.m - Operation on all elements
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+>>header glib.h
+
+
+>>header md.h
+>>header except.h
+
+>>headerdef --decls elements.h
+
+/* The version number of mdml */
+#define MDML_VERSION_MAJOR  1
+#define MDML_VERSION_MINOR  0
+
+#define MD_CONTAINER_BEGIN  50  /* Begining of container types */
+
+/*
+ * The basic element type.  All elements have a time associated with
+ * them and most use the device and channel field.
+ * This should be kept as small as possible.
+ */
+>>elementdef element
+	guint32 element_time;	/* Time for this element */
+	short type;		/* Element type */
+	short device_channel;	/* Device/channel for this element */
+
+/*
+ * An element that holds others.  This includes tracks, parts and the
+ * tempo map.
+ */
+>>elementdef container element
+	GPtrArray *elements;	/* List of elements */
+	guint32 duration;	/* duration time for this container */
+init
+	e->elements = g_ptr_array_new();
+	e->duration = 0;
+
+/*
+ * The top element, used to hold all the other elements.
+ * Also holds some information that is used when
+ * reading and writing to files.
+ */
+>>elementdef root container
+	struct headElement *head;	/* Pointer to the head information */
+	short  tracks;		/* Number of tracks */
+	int    refcount;	/* Reference count of users */
+new  
+	new->head = NULL;
+	new->refcount = 1;
+
+>>elementdef head container
+	short  ver_major;	/* Major part of version number */
+	short  ver_minor;	/* Minor part of version number */
+	short  format;		/* Midi format */
+	short  time_base;	/* Time base value */
+	char *copyright;	/* A copyright message */
+	char *author;		/* Author information */
+	char *title;		/* The title of the piece */
+	char *comment;		/* Comments/notes about the piece */
+new
+	new->copyright = NULL;
+	new->author = NULL;
+	new->title = NULL;
+	new->comment = NULL;
+
+>>elementdef track container
+	char *name;	/* Name of track */
+new
+	new->name = NULL;
+
+>>elementdef tempomap container
+
+>># This should be kept as small as possible as they will soon
+>># begin to eat up memory.
+>>#
+>>elementdef note element
+	char  note;	/* Note number */
+	char  vel;	/* Velocity */
+	char  offvel;	/* Note Off velocity */
+	short  length;	/* Length of note */
+new  char note, char vel, short length
+	new->note = note;
+	new->vel  = vel;
+	new->length = length;
+	new->offvel = 0;
+
+
+>>elementdef part container
+	char *name;		/* Part name */
+new
+	new->name = NULL;
+
+>>elementdef take container
+new
+
+>># As with note should be kept as small as possible
+>>elementdef control element
+	char  control;	/* Controller number */
+	char  value;	/* Controller value */
+new  char control, char value
+	new->control = control;
+	new->value = value;
+
+>>elementdef program element
+	int  program;	/* Program number */
+new  int  program
+	new->program = program;
+
+>>elementdef keytouch element
+	int  note;
+	int  velocity;
+new  int  note, int vel
+	new->note = note;
+	new->velocity = vel;
+
+>>elementdef pressure element
+	int  velocity;
+new  int vel
+	new->velocity = vel;
+
+>>elementdef pitch element
+	int  pitch;
+new  int val
+	new->pitch = val;
+
+>>elementdef sysex element
+	int  status;
+	unsigned char *data;
+	int  length;
+new  int status, unsigned char *data, int len
+	{
+	unsigned char *dp;
+
+	dp = g_malloc(len);
+
+	new->data = dp;
+	memcpy(dp, data, len);
+	}
+	new->status = status;
+	new->length = len;
+free
+	g_free(e->data);
+
+>>elementdef meta element
+
+>>elementdef map meta
+
+>>elementdef keysig map
+	char key;		/* Key signature */
+	char minor;		/* Is this a minor key or not */
+new  short key, short minor
+	new->key = key;
+	new->minor = minor != 0? 1: 0;
+
+>>elementdef timesig map
+	short top;		/* 'top' of timesignature */
+	short bottom;	/* 'bottom' of timesignature */
+	short clocks;	/* Can't remember what this is */
+	short n32pq;	/* Thirtysecond notes per quarter */
+new  short top, short bottom, short clocks, short n32pq
+	new->top = top;
+	new->bottom = bottom;
+	new->clocks = clocks;
+	new->n32pq = n32pq;
+
+>>elementdef tempo map
+	int  micro_tempo;	/* The tempo in microsec per quarter note */
+new  int m
+	new->micro_tempo = m;
+
+>>elementdef text element
+	int  type;	/* Type of text (lyric, copyright etc) */
+	char *name;	/* Type as text */
+	char *text; /* actual text */
+	int  length; /* length of the text (including a null?) */
+new  int type, char *text
+	{
+	static char *typenames[] = {
+		"",
+		"text",
+		"copyright",
+		"trackname",
+		"instrument",
+		"lyric",
+		"marker",
+		"cuepoint",
+	};
+	new->type = type;
+	new->name = typenames[type];
+	new->text = g_strdup(text);
+	if (text)
+		new->length = strlen(text);
+	else
+		new->length = 0;
+	}
+free
+	g_free(e->text);
+
+>>elementdef smpteoffset element
+	short  hours;
+	short  minutes;
+	short  seconds;
+	short  frames;
+	short  subframes;
+new  short hours, short minutes, short seconds, short frames, short subframes
+	new->hours = hours;
+	new->minutes = minutes;
+	new->seconds = seconds;
+	new->frames = frames;
+	new->subframes = subframes;
+
+
+>>function md_add
+void
+struct containerElement *c;
+struct element *e;
+>>description
+Add an element to a container element.
+
+>>code
+	unsigned long t;
+
+	if (!e)
+		return;
+
+	g_ptr_array_add(c->elements, e);
+
+	t = e->element_time;
+	if (e->type == MD_TYPE_NOTE) {
+		t += MD_NOTE(e)->length;
+	} else if (e->type == MD_TYPE_TRACK) {
+		MD_ROOT(c)->tracks++;
+	} else if (iscontainer(e)) {
+		t += MD_CONTAINER(e)->duration;
+	}
+
+	t -= MD_ELEMENT(c)->element_time;
+	if (t > c->duration)
+		c->duration = t;
+
+>>function md_free
+void
+struct element *el;		// Element tree to free
+
+>>description
+Free a complete element tree.
+
+>>code
+	struct containerElement *c;
+	int  i;
+	
+	if (el->type == MD_TYPE_ROOT) {
+		if (--MD_ROOT(el)->refcount > 0)
+			return;
+	}
+
+	if (el->type >= MD_CONTAINER_BEGIN) {
+		c = MD_CONTAINER(el);
+		for (i = 0; i < c->elements->len; i++) {
+			struct element *p = g_ptr_array_index(c->elements, i);
+			md_free(p);
+		}
+		g_ptr_array_free(c->elements, 1);
+	}
+	switch (el->type) {
+	case MD_TYPE_TEXT:
+		g_free(MD_TEXT(el)->text);
+		break;
+	case MD_TYPE_SYSEX:
+		g_free(MD_SYSEX(el)->data);
+		break;
+	}
+	g_free(el);
+
+>>function md_check_cast
+struct element *
+struct element *el;	// Element to be casted
+int  type;          // type to cast to
+>>description
+Check that the given element can be casted to the given type.
+This is mainly for debugging as mismatches will not happen
+in proper use.
+In particular do not use this routine to check types unless you
+want the program to exit if the check fails.
+>>code
+
+	switch (type) {
+	case MD_TYPE_CONTAINER:
+		if (!iscontainer(el))
+			ethrow(debugError, "Cast to container from %d", el->type);
+		return el;
+	case MD_TYPE_ELEMENT:
+		/* Anything can be cast to an element */
+		if (el->type > 100 || el->type < 0)
+			break;	/* Sanity check */
+		return el;
+	case MD_TYPE_META:
+	case MD_TYPE_MAP:
+		/* TEMP: this is a parent type */
+		return el;
+	case MD_TYPE_TRACK:
+		if (el->type == MD_TYPE_TEMPOMAP)
+			return el;
+		break;
+	}
+
+	if (type == el->type)
+		return el;
+
+	ethrow(debugError, "Cast from %d to %d not allowed", el->type, type);
+	return NULL;/* not reached */
+
diff -rNu melys-0.0.4/md/mdutil.c melys-0.0.5/md/mdutil.c
--- melys-0.0.4/md/mdutil.c	Fri Jul 30 00:43:18 1999
+++ melys-0.0.5/md/mdutil.c	Mon Aug  9 00:51:34 1999
@@ -249,7 +249,7 @@
  * 
  */
 struct rootElement *
-md_empty()
+md_empty(void)
 {
 	struct rootElement *root;
 	struct headElement *head;
@@ -272,7 +272,7 @@
 
 	map = md_tempomap_new();
 
-	tempo = md_tempo_new(50000);
+	tempo = md_tempo_new(500000);
 	md_add(MD_CONTAINER(map), MD_ELEMENT(tempo));
 
 	md_add(MD_CONTAINER(root), MD_ELEMENT(map));
@@ -284,6 +284,31 @@
 }
 
 /*
+ * Get the nth track of the composition. Track numbers start at
+ * 1.
+ * 
+ */
+struct trackElement *
+md_track_nth(struct rootElement *root, int n)
+{
+	GPtrArray *p;
+	struct trackElement *track = NULL;
+
+	if (root == NULL)
+		return NULL;
+
+	/* Allow for head and tempomap and starting at 1 */
+	n += 1;
+
+	p = MD_CONTAINER(root)->elements;
+
+	if (n < p->len)
+		track = (struct trackElement *)g_ptr_array_index(p, n);
+
+	return track;
+}
+
+/*
  * Push a new set of pointers for this container. We can then
  * sequence through the container and pick up with the
  * containing one when finished. The new top of stack is
@@ -380,6 +405,8 @@
 	while (iscontainer(el)) {
 		tp = push_track_info(sp, MD_CONTAINER(el));
 		el = curr_element(tp);
+		if (!el)
+			break;
 #if 0 /* not yet */
 		if (el && el->type == MD_TYPE_TAKE) {
 			if (MD_TAKE(el)->selected == FALSE) {
@@ -408,5 +435,7 @@
 curr_element(struct trackPos *tp)
 {
 
+	if (tp->len == 0)
+		return NULL;
 	return *tp->currel;
 }
diff -rNu melys-0.0.4/md/mdutil.m melys-0.0.5/md/mdutil.m
--- melys-0.0.4/md/mdutil.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/md/mdutil.m	Mon Aug  9 00:05:59 1999
@@ -0,0 +1,444 @@
+>>name mdutil.m
+File: mdutil.m - Utility routines for manipulating MD
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+>>header "seqlib.h"
+>>header "stdlib.h"
+>>headerdef --decl md.h
+
+/* Defines for md_walk() */
+#define MD_WALK_ALL	1	/* Include all elements including deleted, hidden*/
+
+/* Defines for walk callback flags */
+#define MD_WALK_START 0x001	/* This is a start element */
+#define MD_WALK_END   0x002	/* This is the end of an element */
+#define MD_WALK_EMPTY (MD_WALK_START|MD_WALK_END) /* Empty element */
+
+/* Typedef for md_walk callback function */
+typedef void (*walkFunc)(struct element *, void *, int);
+
+>>function md_walk
+void
+struct containerElement *c;  Container to be walked
+walkFunc fn;   Callback function to call on each element
+void *arg;     Argument passed to fn
+int  flags;    Flags eg. include all elements or just current ones.
+>>description
+Given a container
+.A c
+then @func_name iterates through all elements and calls
+.A fn
+for each one with the following arguments:
+
+   fn(element, arg, start-end-flags)
+
+The flag MD_WALK_START is set if this is an element start
+and MD_WALK_END is set if this is an element end.
+Both are set for empty elements (also can use MD_WALK_EMPTY)
+
+>>code
+	struct element *el;
+	GPtrArray *ar;
+	int  i;
+
+	fn(MD_ELEMENT(c), arg, MD_WALK_START);
+
+	ar = c->elements;
+	for (i = 0; i < ar->len; i++) {
+		el = g_ptr_array_index(ar, i);
+		if (iscontainer(el)) {
+			md_walk(MD_CONTAINER(el), fn, arg, flags);
+		} else {
+			fn(el, arg, MD_WALK_EMPTY);
+		}
+	}
+
+	fn(MD_ELEMENT(c), arg, MD_WALK_END);
+
+>>function iscontainer
+int
+struct element *el;   Element to be tested
+>>description
+Return true if the element is some kind of container.
+>>code
+
+	if (el->type >= MD_CONTAINER_BEGIN)
+		return 1;
+	else
+		return 0;
+
+
+>>headerdef md.h
+
+/*
+ * Structure to keep track of the position on each track that
+ * is being merged.
+ */
+struct sequenceState {
+	int  nmerge;	/* Number of tracks in trackPos to merge */
+	GPtrArray **track_ptrs; /* Position pointers */
+	struct rootElement *root; /* Root to be returned first */
+	struct headElement *head; /* Head to be returned next */
+	unsigned long duration;	/* End time */
+};
+struct trackPos {
+	int  len;	/* Total length of this container element */
+	int  count;	/* Current position count */
+	struct element **currel; /* Pointer to current position */
+};
+
+>>function md_sequence_init
+struct sequenceState *
+struct rootElement *root; Root to sequence over
+
+>>description
+Return an object that can be passed to
+.F md_sequence_next
+to iterate over all the elements in a tree in time sequenced order.
+This is what you want if you actually want to play the song
+for example.
+The elements in the container must already be in sorted order within
+their own tracks or subcontainers.
+
+>>code
+	struct sequenceState *state;
+	int  nchild;
+	int  ntracks;
+	int  i;
+
+	state = g_new(struct sequenceState, 1);
+
+	nchild = MD_CONTAINER(root)->elements->len;
+	state->track_ptrs = g_new(GPtrArray *, nchild);
+	state->root = root;
+	state->duration = 0;
+
+	/* Initialise the pointers */
+	ntracks = 0;
+	for (i = 0; i < nchild; i++) {
+		struct containerElement *c;
+
+		/* c is a track or a tempo element */
+		c = MD_CONTAINER(MD_CONTAINER(root)->elements->pdata[i]);
+		if (MD_ELEMENT(c)->type == MD_TYPE_HEAD) {
+			/* Save so that it can be given to the user */
+			state->head = MD_HEAD(c);
+			continue;
+		}
+
+		/* This is a track or tempo map */
+		state->track_ptrs[ntracks] = g_ptr_array_new();
+		push_track_info(state->track_ptrs[ntracks], c);
+		ntracks++;
+		if (MD_ELEMENT(c)->type == MD_TYPE_TRACK)
+			if (c->duration > state->duration)
+				state->duration = c->duration;
+	}
+
+	state->nmerge = ntracks;
+
+	return state;
+
+
+>>function md_sequence_next
+struct element *
+struct sequenceState *seq; Sequence state information
+
+>>description
+Return the next element as sorted by time.
+The root and head elements are returned, but otherwise
+just leaf elements are returned.
+
+>>code
+	struct element *el;
+	unsigned long leasttime;
+	struct trackPos *besttp;
+	struct trackPos *tp;
+	int  i;
+
+	if (seq == NULL)
+		return NULL;
+
+	if (seq->root) {
+		/* The first time we return the root element */
+		el = MD_ELEMENT(seq->root);
+		seq->root = NULL;
+		return el;
+	}
+	if (seq->head) {
+		/* Next we return the head element */
+		el = MD_ELEMENT(seq->head);
+		seq->head = NULL;
+		return el;
+	}
+
+	leasttime = -1;
+	besttp = NULL;
+
+	/*
+	 * Now look at the next element in each track and see which
+	 * one should come first.
+	 */
+	for (i = 0; i < seq->nmerge; i++) {
+		tp = track_info_top(seq->track_ptrs[i]);
+		if (tp == NULL)
+			continue;
+
+		el = get_current(seq->track_ptrs[i], tp);
+		if (el == NULL)
+			continue;
+
+		/* XXX get_current changes what tp should point to */
+		tp = track_info_top(seq->track_ptrs[i]);
+		if (leasttime == -1 || el->element_time < leasttime) {
+			leasttime = el->element_time;
+			besttp = tp;
+		}
+	}
+
+	/* We found the next one so return it */
+	if (besttp) {
+		el = *besttp->currel;
+		besttp->count++;
+		besttp->currel++;
+		return el;
+	}
+
+	/* Nothing left */
+	return NULL;
+
+
+>>function md_sequence_end
+void
+struct sequenceState *seq; Sequence state information
+
+>>description
+Finish with a sequence object.
+Frees all resources.
+The object cannot be used any more.
+>>code
+	int  i;
+
+	if (!seq)
+		return;
+	if (seq->track_ptrs) {
+		for (i = 0; i < seq->nmerge; i++) {
+			if (seq->track_ptrs[i])
+				g_ptr_array_free(seq->track_ptrs[i], 1);
+		}
+		g_free(seq->track_ptrs);
+	}
+	g_free(seq);
+
+>>function md_sequence_duration
+unsigned long
+struct sequenceState *seq; Sequence state information
+>>description
+Get the final time for the song.
+>>code
+
+	return seq->duration;
+
+
+>>function md_empty
+struct rootElement *
+
+>>description
+Create a new empty md tree.
+
+>>code
+	struct rootElement *root;
+	struct headElement *head;
+	struct tempomapElement *map;
+	//struct trackElement *track;
+	struct tempoElement *tempo;
+
+	root = md_root_new();
+	head = md_head_new();
+
+	root->head = head;
+	root->tracks = 0;
+
+	head->ver_major = MDML_VERSION_MAJOR;
+	head->ver_major = MDML_VERSION_MINOR;
+	head->format = 1;
+	head->time_base = 96;
+
+	md_add(MD_CONTAINER(root), MD_ELEMENT(head));
+
+	map = md_tempomap_new();
+
+	tempo = md_tempo_new(500000);
+	md_add(MD_CONTAINER(map), MD_ELEMENT(tempo));
+
+	md_add(MD_CONTAINER(root), MD_ELEMENT(map));
+
+	//track = md_track_new();
+	//md_add(MD_CONTAINER(root), MD_ELEMENT(track));
+
+	return root;
+
+
+>>function md_track_nth
+struct trackElement *
+struct rootElement *root;
+int  n;
+
+>>description
+Get the nth track of the composition.
+Track numbers start at 1.
+
+>>code
+	GPtrArray *p;
+	struct trackElement *track = NULL;
+
+	if (root == NULL)
+		return NULL;
+
+	/* Allow for head and tempomap and starting at 1 */
+	n += 1;
+
+	p = MD_CONTAINER(root)->elements;
+
+	if (n < p->len)
+		track = (struct trackElement *)g_ptr_array_index(p, n);
+
+	return track;
+
+
+>>#  ### Static functions ####
+>>function push_track_info
+static struct trackPos *
+GPtrArray *sp;         The stack of track position structures
+struct containerElement *c;   The container to be sequenced over
+
+>>description
+Push a new set of pointers for this container.
+We can then sequence through the container and pick up with
+the containing one when finished.
+The new top of stack is returned.
+
+>>code
+	struct trackPos *tp;
+	
+	tp = g_new(struct trackPos, 1);
+
+	tp->len = c->elements->len;
+	tp->count = 0;
+	tp->currel = (struct element**)c->elements->pdata;
+
+	g_ptr_array_add(sp, tp);
+
+	return tp;
+
+>>function pop_track_info
+static struct trackPos *
+GPtrArray *sp;   Track position stack
+
+>>description
+Pop off the top element from the track position stack.
+The new top of stack is returned (not the one that was
+popped).
+
+>>code
+	struct trackPos *tp;
+
+	tp = track_info_top(sp);
+	if (tp)
+		g_ptr_array_remove(sp, tp);
+
+	/* return new top */
+	return track_info_top(sp);
+
+>>function track_info_top
+static struct trackPos *
+GPtrArray *sp;   Track position stack
+
+>>description
+Get the top element from the track position stack and 
+return it.
+
+>>code
+	struct trackPos *tp;
+
+	if (sp->len <= 0)
+		return NULL;
+
+	tp = sp->pdata[sp->len - 1];
+	return tp;
+
+
+>>function get_current
+static struct element *
+GPtrArray *sp;          Stack of track position pointers
+struct trackPos *tp;    Track position information
+
+>>description
+Get the current music event on this track.
+If the current one is a container then it will be skipped
+and the data structures set up so that a normal element is
+at the top.
+
+>>code
+	struct element *el;
+
+	/* While finished, pop down to lower layers */
+	while (tp && tp->count >= tp->len) {
+		tp = pop_track_info(sp);
+		if (tp) {
+			tp->count++;
+			tp->currel++;
+		}
+	}
+
+	if (tp == NULL)
+		return NULL;
+
+	el = curr_element(tp);
+	g_assert(el != NULL);
+
+	while (iscontainer(el)) {
+		tp = push_track_info(sp, MD_CONTAINER(el));
+		el = curr_element(tp);
+		if (!el)
+			break;
+#if 0 /* not yet */
+		if (el && el->type == MD_TYPE_TAKE) {
+			if (MD_TAKE(el)->selected == FALSE) {
+				/*
+				 * Not selected so this is no good, pop off
+				 * straight away should get back to part so
+				 * we can loop to the next take.
+				 */
+				tp = pop_track_info(sp);
+				el = curr_element(tp);
+			}
+		}
+#endif
+	}
+
+	return el;
+
+
+>>function curr_element
+static struct element *
+struct trackPos *tp;    Track position
+
+>>description
+Step to the next element in the container.
+
+>>code
+
+	if (tp->len == 0)
+		return NULL;
+	return *tp->currel;
diff -rNu melys-0.0.4/midi/.cvsignore melys-0.0.5/midi/.cvsignore
--- melys-0.0.4/midi/.cvsignore	Fri Jul 30 00:43:13 1999
+++ melys-0.0.5/midi/.cvsignore	Mon Aug  9 00:51:28 1999
@@ -1,6 +1,5 @@
 play.c
 record.c
 Makefile
-*.mdml
-*.mid
+*.mdml *.mdml.gz *.mid
 .cvsignore
diff -rNu melys-0.0.4/midi/play.c melys-0.0.5/midi/play.c
--- melys-0.0.4/midi/play.c	Fri Jul 30 00:43:19 1999
+++ melys-0.0.5/midi/play.c	Mon Aug  9 00:51:36 1999
@@ -81,7 +81,7 @@
  * 
  */
 struct play *
-play_new()
+play_new(void)
 {
 	struct play *play;
 
@@ -120,7 +120,8 @@
 	if (play->seq)
 		(void) md_sequence_end(play->seq);
 
-	/* NB: mdroot does not belong to us, freed elsewhere */
+	if (play->mdroot)
+		md_free(play->mdroot);
 
 	if (play->ctxp)
 		seq_context_free(play->ctxp);
@@ -143,9 +144,7 @@
 play_set_mdroot(struct play *play, struct rootElement *root)
 {
 
-	if (play->mdroot)
-		ethrow(debugError, "mdroot already set in play_set_mdroot");
-
+	root->refcount++;
 	play->mdroot = root;
 
 	return;
@@ -166,21 +165,6 @@
 
 	n = conf_get_output_ports(&addrs);
 	seq_set_addresses(play->ctxp, SEQ_ADDR_OUTPUT, addrs, n);
-}
-
-/*
- * Open all the sequencer ports that will be needed for this
- * song.
- * 
- */
-void 
-XXX_REMOVE_play_open_ports(struct play *play)
-{
-
-	if (play->mdroot == NULL)
-		ethrow(debugError, "No md root set in XXX_REMOVE_play_open_ports");
-
-	//play->ctxp = seq_md_open_ports(play->mdroot);
 }
 
 /*
diff -rNu melys-0.0.4/midi/play.m melys-0.0.5/midi/play.m
--- melys-0.0.4/midi/play.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/midi/play.m	Fri Aug  6 11:56:05 1999
@@ -0,0 +1,587 @@
+>>name play.m - Routines to manage midi playing.
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+>>header <stdlib.h>
+>>header <string.h>
+>>header <stdio.h>
+>>header <sys/asoundlib.h>
+>>header seqlib.h
+>>header elements.h
+>>header md.h
+>>header config.h
+>>header gdk/gdk.h
+
+>>headerdef --decl melmidi.h
+
+/* Opaque type to save all playing state */
+struct play;
+struct seq_context;
+
+>>extern
+
+#define ECHO_NOOP      0
+#define ECHO_ENDSONG   1
+
+#define INPUT_ALL (GDK_INPUT_READ | GDK_INPUT_WRITE)
+
+struct play {
+	int  isplaying:1,	/* True if playing now */
+	     ispaused:1,	/* True if paused */
+	     isfinish:1,		/* True if sequence is finished */
+	     isecho_on:1,	/* True if midi echo is active */
+	     isrecording:1,	/* True if recording */
+	     isended:1 	/* True if song ended */
+	     ;
+	guint write_id;              /* ID of write handler */
+	guint read_id;               /* ID of read handler */
+
+	seq_context_t *ctxp;         /* Sequencer context */
+	struct rootElement *mdroot;  /* Midi song to play */
+	struct sequenceState *seq;   /* To hold current sequence position */
+	struct element *pend_element;/* Element that is pending play */
+
+	GArray *echolist;			/* Midi echo list */
+};
+
+#define ADDR_PARTS 4
+#define SEP        ", \t\n"
+
+>>function play_new
+struct play *
+
+>>description
+Return a newly allocated play structure.
+
+>>code
+	struct play *play;
+
+	play = g_new0(struct play, 1);
+
+	play->isplaying = 0;
+	play->ispaused = 0;
+	play->isfinish = 0;
+	play->isecho_on = 0;
+	play->isended = 0;
+
+	play->mdroot  = NULL;
+	play->pend_element = NULL;
+	play->ctxp = seq_context_new("Melys sequencer");
+	snd_seq_block_mode(seq_handle(play->ctxp), 0);
+	play->seq = NULL;
+	play->write_id = 0;
+	play->read_id = 0;
+
+	play->echolist = g_array_new(0, 0, sizeof(struct echo_data));
+
+	return play;
+
+
+>>function play_free
+void
+struct play *play;    The play object to free
+
+>>description
+Free all resources.
+
+>>code
+
+	remove_io_cb(play, INPUT_ALL);
+	if (play->seq)
+		(void) md_sequence_end(play->seq);
+
+	if (play->mdroot)
+		md_free(play->mdroot);
+
+	if (play->ctxp)
+		seq_context_free(play->ctxp);
+
+	if (play->echolist)
+		g_array_free(play->echolist, 1);
+
+	g_free(play);
+
+>>function play_set_mdroot
+void
+struct play *play;         The play object
+struct rootElement *root;  Root of the md tree to use
+
+>>description
+Sets the md root for this play structure.
+It is an error to set it if one is already set.
+
+>>code
+
+	root->refcount++;
+	play->mdroot = root;
+
+	return;
+
+>>function play_set_ports
+void
+struct play *play;
+>>description
+Set the port addresses from the configuration and any
+information from the current song.
+>>code
+	int  n;
+	snd_seq_addr_t *addrs;
+
+	n = conf_get_input_ports(&addrs);
+	seq_set_addresses(play->ctxp, SEQ_ADDR_INPUT, addrs, n);
+
+	n = conf_get_output_ports(&addrs);
+	seq_set_addresses(play->ctxp, SEQ_ADDR_OUTPUT, addrs, n);
+
+
+>>function play_start
+void
+struct play *play;    The play object
+
+>>description
+Start playing the midi.
+If one is not set then nothing happens.
+XXX some warning/error?
+
+>>code
+
+	if (play->isplaying || play->mdroot == NULL)
+		return;
+
+	/* Init the sequence */
+	if (play->ispaused) {
+		seq_timer_continue(play->ctxp);
+	} else {
+		play->isfinish = FALSE;
+		play->isended = FALSE;
+		play->seq = md_sequence_init(play->mdroot);
+		play->pend_element = NULL;
+
+		/* Need to flush the whole queue, just re-open at present TEMP */
+		seq_drain_output(play->ctxp);
+		seq_connect_addresses(play->ctxp, SEQ_ADDR_OUTPUT);
+
+		/* Reset timer */
+		seq_timer_start(play->ctxp);
+		seq_timer_stop(play->ctxp);
+	}
+
+	/* set playing */
+	play->isplaying = TRUE;
+
+	add_io_cb(play, INPUT_ALL);
+
+	/*
+	 * ALSA bug 19 Jul 1999, select does not return write possible
+	 * until after at least one write has been done.
+	 * Therefore kick it off with an echo.
+	 *
+	 * Remove this code in about 6 months, when all have the fix.
+	 */
+	seq_midi_send_echo(play->ctxp, 0, ECHO_NOOP);
+
+>>function play_pause
+void
+struct play *play;    The play object
+
+>>description
+Stop playing.
+If start is called after the song will be restarted from where it
+was stopped.
+Use
+.F play_stop
+to stop and play from the beginning.
+
+>>code
+	seq_context_t *ctxp;
+	snd_seq_event_t ev;
+	int  i;
+
+	if (play->isplaying == FALSE || play->mdroot == NULL)
+		return;
+
+	play->isplaying = FALSE;
+	play->ispaused  = TRUE;
+
+	remove_io_cb(play, INPUT_ALL);
+
+	ctxp = play->ctxp;
+
+	for (i = 0; i < 16; i++) {
+		seq_midi_event_init(ctxp, &ev, 0, i);
+		seq_midi_control(ctxp, &ev, SND_MCTL_ALL_SOUNDS_OFF, 0);
+		seq_control_write(ctxp, &ev);
+	}
+	seq_timer_stop(ctxp);
+
+>>function play_stop
+void
+struct play *play;   The play object to stop and rewind
+
+>>description
+Rewind the song back to the beginning.
+The next start will play the song from the beginning.
+
+>>code
+
+	play_pause(play);
+
+	if (play->seq)
+		(void) md_sequence_end(play->seq);
+	play->seq = NULL;
+
+	play->ispaused = FALSE;
+
+
+>>function play_set_record
+void
+struct play *play;
+int  recmode;       True if recording is started
+>>description
+Sets a flag to say if recording is active or not.
+Needed because if recording we must not stop the timer
+at the end of the song as it should be extended instead.
+
+>>code
+
+	if (recmode == 0 && play->isrecording && play->isended) {
+		play_pause(play);
+
+		play->isplaying = FALSE;
+		play->ispaused  = FALSE;
+	}
+
+	play->isrecording = recmode;
+
+
+>>function play_get_context
+struct seq_context *
+struct play *play;   Will return play->ctxp
+
+>>description
+Get the sequencer context.
+>>code
+	return play->ctxp;
+
+
+
+>>extern
+/* Data for midi echo */
+struct echo_data {
+	snd_seq_addr_t inaddr;	/* Input address */
+	int  inchan;		/* Input channel to receive on */
+	snd_seq_addr_t outaddr;	/* Output address */
+	int  outchan;		/* Output channel to send event to */
+};
+
+>>function XX_play_add_midi_echo
+void
+struct play *play;     Play state
+int  indev; 	Events from this device...              
+int  inchan;	Channel to accept, or -1 for all
+int  outdev;	Are echoed to this device/channel
+int  outchan;	Channel to send event to
+
+>>description
+Set up a midi echo.
+Events arriving on one port are immediately output to the corresponding
+output port.
+In a complete system there may be multiple inputs that all
+need to go to a different output.
+Conversely in another complete system this routine may not
+be needed at all as the echo function could be handled
+by a separate kernel client.
+
+Is this really needed?
+
+>>code
+	struct echo_data edata;
+	snd_seq_addr_t *addr;
+
+
+	/*
+	 * There is a list of echo routes.  Although we will just be
+	 * using one to begin with.
+	 */
+
+	/* Save actual address, rather than device to avoid constant lookups */
+	addr = seq_dev_addr(play->ctxp, indev, SEQ_ADDR_INPUT);
+	if (!addr)
+		return;
+	edata.inaddr = *addr;
+
+	/* Now the output */
+	addr = seq_dev_addr(play->ctxp, outdev, SEQ_ADDR_OUTPUT);
+	if (!addr)
+		return;
+	edata.outaddr = *addr;
+
+	edata.inchan = inchan;
+	edata.outchan = outchan;
+
+	g_array_append_val(play->echolist, edata);
+
+	play->isecho_on = TRUE;
+
+
+>>function run_events
+static void
+gpointer vplay;      This will be a play object
+gint  fd;            The file descriptor that is ready
+GdkInputCondition  cond;  The condition that matched
+
+>>description
+This is called when the front end is not busy and is
+used to control the interaction between the front end and
+the midi engine.
+It is possible that this will be done in a separate thread
+in future, but there still has to be an interface between threads
+and this is it.
+
+>>code
+	struct play *play = vplay;
+	struct element *el;
+	unsigned long end;
+	int  status;
+
+	if (play->isplaying == FALSE)
+		ethrow(debugError, "Not playing in @func_name");
+
+	/* Push out any pending element */
+	if (play->pend_element) {
+		status = send_element(play->ctxp, play->pend_element);
+		if (status < 0)
+			return;
+
+		play->pend_element = NULL;
+	}
+
+	/* Try and push out next items in the sequence */
+	while ((el = md_sequence_next(play->seq)) != NULL) {
+		status = send_element(play->ctxp, el);
+		if (status < 0) {
+			play->pend_element = el;
+			break;
+		}
+	}
+
+	/* Detect the end of the sequence */
+	if (el == NULL && play->isfinish == FALSE) {
+
+		end = md_sequence_duration(play->seq);
+		play->seq = NULL;
+
+		play->isfinish = 1;
+
+		/* MMM this could fail */
+		seq_midi_send_echo(play->ctxp, end, ECHO_ENDSONG); /* XXX */
+	}
+
+	status = snd_seq_flush_output(seq_handle(play->ctxp));
+	if (status == 0 && play->isfinish)
+		remove_io_cb(play, GDK_INPUT_WRITE);
+
+	return;
+
+
+>>function get_events
+static void
+gpointer vplay;      Play object to be used
+gint  fd;            The file descriptor that is ready
+GdkInputCondition  cond;  The condition that matched
+
+>>description
+Get and process the available events.
+
+>>code
+	struct play *play = vplay;
+	snd_seq_event_t *ep;
+
+	/*
+	 * Because events are buffered within the library then we
+	 * must read all available events or arrange to have ourselves
+	 * called by some mechanism other than select().
+	 */
+	while ((ep = seq_read(play->ctxp)) != NULL) {
+
+		switch (ep->type) {
+		case SND_SEQ_EVENT_ECHO:
+			do_special(play, ep->data.raw32.d[0]);
+			break;
+		default:
+			printf("Event NOT ECHO type %d revceived\n", ep->type);
+			break;
+		}
+
+		snd_seq_free_event(ep);
+	}
+
+>>function do_special
+static void
+struct play *play;   The play object
+int  type;           Type of echo event
+
+>>description
+Deal with an echo event, which are used to schedule events within
+melys that are related to the song being played.
+For example when it ends: this is not an absolute time as
+it may be paused, have its tempo changed etc.
+
+>>code
+
+	switch (type) {
+	case ECHO_NOOP:
+		break;
+
+	case ECHO_ENDSONG:
+
+		if (!play->isrecording) {
+			play_pause(play);
+
+			play->isplaying = FALSE;
+			play->ispaused  = FALSE;
+		}
+
+		play->isended = TRUE;
+		play->seq = NULL;
+		break;
+
+	default:
+		printf("Unknown echo event %d\n", type);
+		break;
+	}
+
+
+
+>>function send_element
+static int
+struct seq_context *ctxp;    Sequence state
+struct element *el;     Element to send to sequencer
+
+>>description
+The element is converted into an event and sent to the sequencer.
+
+>>code
+	snd_seq_event_t ev;
+	int  status = 0;
+
+	conv_event(ctxp, el, &ev);
+
+	if (ev.type != 0)
+		status = seq_write(ctxp, &ev);
+
+	seq_event_data_free(&ev);
+
+	return status;
+
+
+>>function conv_event
+static void
+struct seq_context *ctxp;   Sequencer context
+struct element *el;    Element to be converted
+snd_seq_event_t *ep;   Event is written here
+
+>>description
+Convert an element to an event.
+Pass in the address of an event to be completed.
+
+>>code
+
+	seq_midi_event_init(ctxp, ep, el->element_time, el->device_channel);
+	switch (el->type) {
+	case MD_TYPE_ROOT:
+		break;
+	case MD_TYPE_HEAD:
+		seq_init_tempo(ctxp, MD_HEAD(el)->time_base, 120, 1);
+		seq_timer_start(ctxp);
+		break;
+	case MD_TYPE_NOTE:
+		seq_midi_note(ctxp, ep, MD_NOTE(el)->note, MD_NOTE(el)->vel,
+			MD_NOTE(el)->length);
+		break;
+	case MD_TYPE_CONTROL:
+		seq_midi_control(ctxp, ep, MD_CONTROL(el)->control,
+			MD_CONTROL(el)->value);
+		break;
+	case MD_TYPE_PROGRAM:
+		seq_midi_program(ctxp, ep, MD_PROGRAM(el)->program);
+		break;
+	case MD_TYPE_TEMPO:
+		seq_midi_tempo(ctxp, ep, MD_TEMPO(el)->micro_tempo);
+		break;
+	case MD_TYPE_PITCH:
+		seq_midi_pitchbend(ctxp, ep, MD_PITCH(el)->pitch);
+		break;
+	case MD_TYPE_PRESSURE:
+		seq_midi_chanpress(ctxp, ep, MD_PRESSURE(el)->velocity);
+		break;
+	case MD_TYPE_KEYTOUCH:
+		seq_midi_keypress(ctxp, ep, MD_KEYTOUCH(el)->note,
+			MD_KEYTOUCH(el)->velocity);
+		break;
+	case MD_TYPE_SYSEX:
+		seq_midi_sysex(ctxp, ep, MD_SYSEX(el)->status, MD_SYSEX(el)->data,
+			MD_SYSEX(el)->length);
+		break;
+	case MD_TYPE_TEXT:
+	case MD_TYPE_KEYSIG:
+	case MD_TYPE_TIMESIG:
+	case MD_TYPE_SMPTEOFFSET:
+	case MD_TYPE_PART:
+		/* Ones that have no sequencer action */
+		break;
+	default:
+		printf("WARNING: play: not implemented yet %d\n", el->type);
+		break;
+	}
+
+>>function add_io_cb
+static void
+struct play *play;    The play object
+int    which;         Which callbacks to add
+
+>>description
+Add the io callbacks.
+
+>>code
+	/* Set up callbacks for IO activity */
+
+	if (which & GDK_INPUT_WRITE)
+		play->write_id = gdk_input_add(seq_descriptor(play->ctxp),
+			GDK_INPUT_WRITE, run_events, play);
+	
+	if (which & GDK_INPUT_READ)
+		play->read_id = gdk_input_add(seq_descriptor(play->ctxp),
+			GDK_INPUT_READ, get_events, play);
+
+
+>>function remove_io_cb
+static void
+struct play *play;    The play object
+int  which;           Which callbacks to remove
+
+>>description
+Remove the io callbacks.
+
+>>code
+	/* Set up callbacks for IO activity */
+
+	if ((which & GDK_INPUT_WRITE) && play->write_id) {
+		gdk_input_remove(play->write_id);
+		play->write_id = 0;
+	}
+	if ((which & GDK_INPUT_READ) && play->read_id) {
+		gdk_input_remove(play->read_id);
+		play->read_id = 0;
+	}
+
+
diff -rNu melys-0.0.4/midi/record.c melys-0.0.5/midi/record.c
--- melys-0.0.4/midi/record.c	Fri Jul 30 00:43:20 1999
+++ melys-0.0.5/midi/record.c	Mon Aug  9 00:51:36 1999
@@ -36,8 +36,6 @@
 	seq_context_t *ctxp;		/* Record context */
 	struct rootElement *mdroot;	/* The current song */
 
-	struct takeElement *take;	/* To save recorded events */
-
 	int   echo_devchan;	/* Echo device channel */
 
 	guint write_id;		/* ID of write handler */
@@ -83,7 +81,6 @@
 	seq_set_client_name(record->ctxp, _("Melys sequencer (record)"));
 
 	snd_seq_block_mode(seq_handle(record->ctxp), 0);
-	record->take = md_take_new();
 
 	record->notes = g_ptr_array_new();
 
@@ -96,8 +93,13 @@
 
 	remove_io_cb(record, INPUT_ALL);
 
-	seq_context_free(record->ctxp);
-	md_free(MD_ELEMENT(record->take));
+	if (record->ctxp)
+		seq_context_free(record->ctxp);
+
+	if (record->mdroot)
+		md_free(MD_ELEMENT(record->mdroot));
+
+	record->ctxp = NULL;
 
 	g_ptr_array_free(record->notes, 1);
 	g_free(record);
@@ -107,6 +109,7 @@
 record_set_mdroot(struct record *record, struct rootElement *root)
 {
 
+	root->refcount++;
 	record->mdroot = root;
 }
 
diff -rNu melys-0.0.4/midi/record.m melys-0.0.5/midi/record.m
--- melys-0.0.4/midi/record.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/midi/record.m	Sat Aug  7 11:21:32 1999
@@ -0,0 +1,448 @@
+>>name record.m - Recording midi.
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+>>header seqlib.h
+>>header elements.h
+>>header config.h
+>>header md.h
+>>header gdk/gdk.h
+
+>>headerdef --decl melmidi.h
+
+/* Opaque type to store all record state */
+struct record;
+
+>>extern
+
+struct record {
+
+	int  	isrecording:1 	/* Recording events */
+			;
+
+	seq_context_t *ctxp;		/* Record context */
+	struct rootElement *mdroot;	/* The current song */
+
+	int   echo_devchan;	/* Echo device channel */
+
+	guint write_id;		/* ID of write handler */
+	guint read_id;		/* ID of read handler */
+
+	struct trackElement *curtrack;	/* Current track */
+	struct partElement *newpart;	/* New part being recorded  */
+	int  curchan;		/* Current recording channel */
+
+	GPtrArray *notes;	/* To save pending off notes */
+};
+
+#define INPUT_ALL  (GDK_INPUT_READ|GDK_INPUT_WRITE)
+
+>>function record_new
+struct record *
+struct seq_context *ctxp;   The seq context
+
+>>description
+Allocate and initialise a record state.
+A new sequencer context is created that will receive the incoming
+midi events.
+
+>>code
+	struct record *record;
+
+	record = g_new0(struct record, 1);
+
+	record->ctxp = seq_add_subcontext(ctxp);
+	seq_set_client_name(record->ctxp, _("Melys sequencer (record)"));
+
+	snd_seq_block_mode(seq_handle(record->ctxp), 0);
+
+	record->notes = g_ptr_array_new();
+
+	return record;
+
+>>function record_free
+void
+struct record *record;   The record state
+
+>>code
+
+	remove_io_cb(record, INPUT_ALL);
+
+	if (record->ctxp)
+		seq_context_free(record->ctxp);
+
+	if (record->mdroot)
+		md_free(MD_ELEMENT(record->mdroot));
+
+	record->ctxp = NULL;
+
+	g_ptr_array_free(record->notes, 1);
+	g_free(record);
+
+
+>>function record_set_mdroot
+void
+struct record *record;     The record state
+struct rootElement *root;  Root to set
+
+>>code
+
+	root->refcount++;
+	record->mdroot = root;
+
+
+>>function record_set_ports
+void
+struct record *record;
+>>description
+Set the port addresses from the configuration and any
+information from the current song.
+>>code
+	int  n;
+	snd_seq_addr_t *addrs;
+
+	n = conf_get_input_ports(&addrs);
+	seq_set_addresses(record->ctxp, SEQ_ADDR_INPUT, addrs, n);
+
+	n = conf_get_output_ports(&addrs);
+	seq_set_addresses(record->ctxp, SEQ_ADDR_OUTPUT, addrs, n);
+
+	seq_connect_addresses(record->ctxp, SEQ_ADDR_INPUT);
+	add_io_cb(record, INPUT_ALL);
+
+>>function XXrecord_open_ports
+void
+struct record *record;       The record object
+
+>>description
+Open all the sequencer ports that will be needed for this song.
+XXX is this needed?
+We should have a copy of the destination list on
+the subcontext.
+There will be no actual connection but this does not matter
+as we can send the events anyway.
+
+>>code
+
+	if (record->mdroot == NULL)
+		ethrow(debugError, "No md root set in @func_name");
+
+	//record->ctxp = seq_md_open_ports(record->mdroot);
+
+
+>>function record_set_track
+void
+struct record *record;
+struct trackElement *track;
+int  devchan;    Channel for this track
+>>description
+Set the current track that we are recording on.
+
+>>code
+
+	record->curtrack = track;
+	record->curchan = devchan;
+
+
+>>function record_start
+void
+struct record *record;     Record state
+
+>>description
+Start recording.
+Events are saved and added to the current take.
+
+>>code
+	unsigned long t;
+
+	record->isrecording = TRUE;
+	record->newpart = md_part_new();
+
+	t = seq_get_time(record->ctxp);
+	MD_ELEMENT(record->newpart)->element_time = t;
+
+>>function record_stop
+void
+struct record *record;     Record state
+
+>>description
+Stop recording.
+
+>>code
+	unsigned long endtime;
+	struct element *el;
+	int  i;
+
+	if (!record->isrecording)
+		return;
+
+	record->isrecording = FALSE;
+
+	if (record->curtrack == NULL || record->newpart == NULL)
+		return;
+
+	endtime = seq_get_time(record->ctxp);
+
+	/*
+	 * Must finish off any note that is not released.
+	 */
+	for (i = 0; i < record->notes->len; i++) {
+		el = (struct element *)g_ptr_array_index(record->notes, i);
+		MD_NOTE(el)->length = endtime - el->element_time;
+	}
+	g_ptr_array_set_size(record->notes, 0);
+
+	endtime -= MD_ELEMENT(record->newpart)->element_time;
+	MD_CONTAINER(record->newpart)->duration = endtime;
+
+	md_add(MD_CONTAINER(record->curtrack), MD_ELEMENT(record->newpart));
+	record->newpart = NULL;
+
+>>function run_events
+static void
+gpointer vrecord;      This will be a record object
+gint  fd;            The file descriptor that is ready
+GdkInputCondition  cond;  The condition that matched
+>>description
+Read and save the incoming events.
+
+>>code
+	snd_seq_event_t *ep;
+	struct record *record = vrecord;
+
+	while ((ep = seq_read(record->ctxp)) != NULL) {
+		int n;
+		//if (ep->type != 50) g_message("Got event %d", ep->type);
+		ep->flags &= ~SND_SEQ_TIME_MODE_REL;
+
+		if (record->isrecording)
+			save_event(record, ep);
+
+		n = seq_sendto_now(record->ctxp, ep, 0, 15); /* XXX from set dev/chan */
+		if (n != 0) {
+			g_message("Mmm n is %d", n);
+			add_io_cb(record, GDK_INPUT_WRITE);
+		}
+
+	}
+
+
+>>extern
+#define EPTR struct element *
+
+>>function save_event
+static void
+struct record *record;
+snd_seq_event_t *ep;    Event to save
+>>description
+Save the event in the current part that is being recorded.
+>>code
+	struct element *el;
+	unsigned long time;
+	int  devchan;
+
+	time = ep->time.tick; /* What if REAL and not TICK? */
+	devchan = record->curchan;
+
+	// devchan |= (input dev << 4); xxx
+
+	el = NULL;
+
+	switch (ep->type) {
+	case SND_SEQ_EVENT_NOTE:
+		/* Don't expect to see this from realy midi devices */
+		el = (EPTR)md_note_new(ep->data.note.note, ep->data.note.velocity,
+			ep->data.note.duration);
+		//el->element_time = time;
+		//el->devchan = devchan;
+		break;
+	case SND_SEQ_EVENT_NOTEON:
+		if (ep->data.note.velocity == 0)
+			/* Really a note off */
+			finish_note(record, devchan, time, ep);
+		else
+			el = save_note(record, devchan, time, ep);
+		break;
+	case SND_SEQ_EVENT_NOTEOFF:
+		finish_note(record, devchan, time, ep);
+		break;
+	case SND_SEQ_EVENT_KEYPRESS:
+		el = (EPTR) md_keytouch_new(ep->data.control.param,
+			ep->data.control.value);
+		break;
+	case SND_SEQ_EVENT_CONTROLLER:
+		el = (EPTR) md_control_new(ep->data.control.param,
+			ep->data.control.value);
+		break;
+	case SND_SEQ_EVENT_PGMCHANGE:
+		el = (EPTR) md_program_new(ep->data.control.value);
+		break;
+	case SND_SEQ_EVENT_CHANPRESS:
+		el = (EPTR) md_pressure_new(ep->data.control.value);
+		break;
+	case SND_SEQ_EVENT_PITCHBEND:
+		el = (EPTR) md_pitch_new(ep->data.control.value);
+		break;
+	case SND_SEQ_EVENT_SYSEX:
+		el = (EPTR) md_sysex_new(*(guchar *)ep->data.ext.ptr,
+			((guchar *)ep->data.ext.ptr)+1, ep->data.ext.len-1);
+		break;
+
+	case SND_SEQ_EVENT_HEARTBEAT:
+		/* Ignore these */
+		break;
+
+	case SND_SEQ_EVENT_CONTROL14:
+	case SND_SEQ_EVENT_NONREGPARAM:
+	case SND_SEQ_EVENT_REGPARAM:
+	case SND_SEQ_EVENT_SONGPOS:
+	case SND_SEQ_EVENT_SONGSEL:
+	case SND_SEQ_EVENT_CLOCK:
+	case SND_SEQ_EVENT_START:
+	case SND_SEQ_EVENT_CONTINUE:
+	case SND_SEQ_EVENT_STOP:
+	case SND_SEQ_EVENT_QFRAME:
+	case SND_SEQ_EVENT_TICK:
+	case SND_SEQ_EVENT_TEMPO:
+	case SND_SEQ_EVENT_TIMESIGN:
+	case SND_SEQ_EVENT_KEYSIGN:
+	case SND_SEQ_EVENT_SYSTEM:
+		/* We may want to do something with these or may want to
+		 * ignore them.  Will decide when they actually start happening.
+		 */
+		g_warning("Event type %d seen in @func_name", ep->type);
+		break;
+	}
+
+	if (el) {
+		el->element_time = time;
+		el->device_channel = devchan;
+
+		md_add(MD_CONTAINER(record->newpart), el);
+	}
+
+
+>>function push_events
+static void
+gpointer vrecord;      This will be a record object
+gint  fd;            The file descriptor that is ready
+GdkInputCondition  cond;  The condition that matched
+
+>>description
+Push out the events waiting to be written to the sequencer.
+Not needed!
+
+>>code
+	int  n;
+	struct record *record = vrecord;
+
+	n = snd_seq_flush_output(seq_handle(record->ctxp));
+//g_message("push event %d\n", n);
+	if (n == 0)
+		remove_io_cb(record, GDK_INPUT_WRITE);
+
+
+>>function add_io_cb
+static void
+struct record *record;    The record object
+int    which;         Which callbacks to add
+
+>>description
+Add the io callbacks.
+
+>>code
+	/* Set up callbacks for IO activity */
+
+	if ((which & GDK_INPUT_WRITE) && !record->write_id)
+		record->write_id = gdk_input_add(seq_descriptor(record->ctxp),
+			GDK_INPUT_WRITE, push_events, record);
+	
+	if ((which & GDK_INPUT_READ) && !record->read_id)
+		record->read_id = gdk_input_add(seq_descriptor(record->ctxp),
+			GDK_INPUT_READ, run_events, record);
+
+
+>>function remove_io_cb
+static void
+struct record *record;    The record object
+int  which;           Which callbacks to remove
+
+>>description
+Remove the io callbacks.
+
+>>code
+	/* Remove callbacks for IO activity */
+
+	if ((which & GDK_INPUT_WRITE) && record->write_id) {
+		gdk_input_remove(record->write_id);
+		record->write_id = 0;
+	}
+	if ((which & GDK_INPUT_READ) && record->read_id) {
+		gdk_input_remove(record->read_id);
+		record->read_id = 0;
+	}
+
+
+>>function save_note
+static struct element *
+struct record *record;
+int  dev;  The device/channel this note arrived on
+unsigned long time;  The current song time
+snd_seq_event_t *ep; The note event
+>>description
+Allocate a note element and save it for when
+the off note arrives.
+Sorry this is just about a duplicate of routine in midiread.c
+>>code
+	struct element *el;
+
+	el = (struct element *)md_note_new
+		(ep->data.note.note, ep->data.note.velocity, -1);
+
+	g_ptr_array_add(record->notes, el);
+
+	return el;
+
+
+>>function finish_note
+static void
+struct record *record;
+int  devchan;      The device/channel note arrived on
+unsigned long time;   The time of the off note
+snd_seq_event_t *ep;  The off note
+
+>>description
+Called when a note off is seen.
+Finds the corresponding note on and constructs a note element.
+
+>>code
+	int  i;
+	GPtrArray *notes;
+	struct noteElement *n;
+	int  len;
+
+	notes = record->notes;
+	n = NULL;
+	for (i = notes->len-1; i >= 0; i--) {
+		n = g_ptr_array_index(notes, i);
+		if (n->note == ep->data.note.note
+			    && MD_ELEMENT(n)->device_channel == devchan) {
+			len = time - MD_ELEMENT(n)->element_time;
+			n->offvel = ep->data.note.velocity;
+			n->length = len;
+			if (n->length < 0) {
+				n->length = 0;
+			}
+			g_ptr_array_remove_index_fast(notes, i);
+			break;
+		}
+	}
Binary files melys-0.0.4/mlib/PROJECT/__init__.pyo and melys-0.0.5/mlib/PROJECT/__init__.pyo differ
Binary files melys-0.0.4/mlib/PROJECT/base.pyo and melys-0.0.5/mlib/PROJECT/base.pyo differ
Binary files melys-0.0.4/mlib/PROJECT/cmds.pyo and melys-0.0.5/mlib/PROJECT/cmds.pyo differ
Binary files melys-0.0.4/mlib/PROJECT/code.pyo and melys-0.0.5/mlib/PROJECT/code.pyo differ
Binary files melys-0.0.4/mlib/PROJECT/header.pyo and melys-0.0.5/mlib/PROJECT/header.pyo differ
Binary files melys-0.0.4/mlib/PROJECT/make.pyo and melys-0.0.5/mlib/PROJECT/make.pyo differ
diff -rNu melys-0.0.4/mlib/PROJECT/mgtk.py melys-0.0.5/mlib/PROJECT/mgtk.py
--- melys-0.0.4/mlib/PROJECT/mgtk.py	Sat Jul 17 20:06:42 1999
+++ melys-0.0.5/mlib/PROJECT/mgtk.py	Fri Aug  6 11:58:36 1999
@@ -17,8 +17,8 @@
 # Usage:
 # In the mfile you simple do this:
 #
-#	>>gtkobject objname objprefix parentname parentprefix
-#	>>gtkobject MelysButton melys_button GtkButton gtk_button
+#	>>gtkobject objprefix objname parentprefix parentname
+#	>>gtkobject melys_button MelysButton gtk_button GtkButton
 #
 # If the capitalisation is regular then you can just say
 #	>>gtkobject melys_button gtk_button
@@ -47,6 +47,7 @@
 >>headerdef --decl %(lowername)s.h
 
 #define %(OBJPREFIX)s(obj) GTK_CHECK_CAST(obj, %(objprefix)s_get_type(), %(objname)s)
+#define %(OBJPREFIX)s_CLASS(klass) GTK_CHECK_CLASS_CAST(klass, %(objprefix)s_get_type(), %(objname)sClass)
 #define IS_%(OBJPREFIX)s(obj) GTK_CHECK_TYPE(obj, %(objprefix)s_get_type())
 
 typedef struct _%(objname)s   %(objname)s;
@@ -91,6 +92,7 @@
 >>headerdef @header
 
 struct _%(objname)s {
+	%(parentname)s %(parentshortprefix)s;
 	// XXX object definition here
 };
 
@@ -121,26 +123,36 @@
 %(objname)s *XXX;   The %(objname)s to init
 >>description
 Initialise the %(objname)s.
+>>code
+	// XXX add any children etc.
 
 
 >>function %(objprefix)s_class_init
 static void
-%(objname)sClass *class;   The class to initialise
+%(objname)sClass *klass;   The class to initialise
 
 >>description
 Initialize the class.
 
 >>code
 	GtkObjectClass *object_class;
-	// XXX %(parentname)sClass *super_class;
+	%(parentname)sClass *%(parentshortprefix)s_class;
+
+	object_class = (GtkObjectClass *)klass;
+	%(parentshortprefix)s_class = (%(parentname)sClass *)klass;
+
+	parent_class = gtk_type_class(%(parentprefix)s_get_type());
+
+	// XXX Add args
+
+	// XXX Create signals
 
-	object_class = (GtkObjectClass*)class;
-	// XXX super_class = %(PARENTPREFIX)s_CLASS(class);
 	gtk_object_class_add_signals(object_class, %(objprefix)s_signals, LAST_SIGNAL);
 
 	// XXX all the overrides come here
 
-	parent_class = gtk_type_class(%(parentprefix)s_get_type());
+	// XXX Our functions
+
 
 """
 
@@ -168,10 +180,10 @@
 						str = str + c
 			return str
 
-		nargs[0] = mod_str(args[0])
-		nargs[1] = args[0]
-		nargs[2] = mod_str(args[1])
-		nargs[3] = args[1]
+		nargs[0] = args[0]
+		nargs[1] = mod_str(args[0])
+		nargs[2] = args[1]
+		nargs[3] = mod_str(args[1])
 
 		args = nargs
 
@@ -180,13 +192,19 @@
 			"Usage: >>gtkobject objname objprefix parentname parentprefix\n"
 			+ "or: >>gtkobject objprefix parentprefix\n")
 
-	vardict = {"objname": args[0],
-		 "objprefix": args[1],
-		 "parentname": args[2],
-		 "parentprefix": args[3],
-		 "OBJPREFIX": string.upper(args[1]),
-		 "PARENTPREFIX": string.upper(args[3]),
-		 "lowername": string.lower(args[0]),
+	if args[2][:4] == "gtk_":
+		parentshortprefix = args[2][4:]
+	else:
+		parentshortprefix = args[2]
+
+	vardict = {"objname": args[1],
+		 "objprefix": args[0],
+		 "parentname": args[3],
+		 "parentprefix": args[2],
+		 "parentshortprefix": parentshortprefix,
+		 "OBJPREFIX": string.upper(args[0]),
+		 "PARENTPREFIX": string.upper(args[2]),
+		 "lowername": string.lower(args[1]),
 		}
 	str = mskeleton % (vardict)
 
Binary files melys-0.0.4/mlib/PROJECT/mgtk.pyo and melys-0.0.5/mlib/PROJECT/mgtk.pyo differ
diff -rNu melys-0.0.4/programs/.cvsignore melys-0.0.5/programs/.cvsignore
--- melys-0.0.4/programs/.cvsignore	Fri Jul 30 00:43:13 1999
+++ melys-0.0.5/programs/.cvsignore	Mon Aug  9 00:51:29 1999
@@ -7,6 +7,5 @@
 pmidi
 showseq
 Makefile
-*.mdml
-*.mid
+*.mdml *.mdml.gz *.mid
 .cvsignore
diff -rNu melys-0.0.4/programs/Makefile melys-0.0.5/programs/Makefile
--- melys-0.0.4/programs/Makefile	Fri Jul 30 00:43:13 1999
+++ melys-0.0.5/programs/Makefile	Mon Aug  9 00:51:29 1999
@@ -29,12 +29,15 @@
 	../files/mdmlread.o ../files/mdmlwrite.o \
 	../files/format.o \
 	../seq/seqlib.o ../seq/seqmidi.o ../seq/sequtil.o \
-	../util/except.o ../md/elements.o ../md/mdutil.o \
+	../util/except.o ../util/util.o \
+	../md/elements.o ../md/mdutil.o \
 	../gui/main.o ../gui/menus.o \
 	../widgets/register.o \
 	../midi/play.o ../midi/record.o \
 	../song/song.o \
-	../config/ports.o
+	../config/ports.o \
+	../widgets/melystrack.o ../widgets/melystrackinfo.o \
+	../widgets/melystrackdisplay.o
 
 PMIDIOBJS =  \
 	pmidi.o \
diff -rNu melys-0.0.4/programs/mdmlconv.c melys-0.0.5/programs/mdmlconv.c
--- melys-0.0.4/programs/mdmlconv.c	Fri Jul 30 00:43:20 1999
+++ melys-0.0.5/programs/mdmlconv.c	Mon Aug  9 00:51:36 1999
@@ -39,7 +39,7 @@
 	{"output-file", HAS_ARG, NULL, 'o'},
 	{0, 0, 0, 0},
 };
-static void show_usage();
+static void show_usage(void);
 
 
 /*
@@ -154,7 +154,7 @@
  * 
  */
 static void 
-show_usage()
+show_usage(void)
 {
 char **cpp;
 static char *msg[] = {
diff -rNu melys-0.0.4/programs/mdmlconv.m melys-0.0.5/programs/mdmlconv.m
--- melys-0.0.4/programs/mdmlconv.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/programs/mdmlconv.m	Tue Jul 20 11:42:16 1999
@@ -0,0 +1,174 @@
+>>name mdmlconv.m - convert between midi and mdml files.
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+---
+Program to convert between midi and MDML files.
+
+>>target mdmlconv
+>># TEMP
+>>make --objects mdmlconv.o
+>>make --objects ../files/midiread.o ../files/midiwrite.o ../files/mdmlread.o
+>>make --objects ../files/mdmlwrite.o ../files/format.o ../md/elements.o
+>>make --objects ../md/mdutil.o ../util/except.o
+
+>>extern
+>>header <stdlib.h>
+>>header <unistd.h>
+>>header <getopt.h>
+>>header util.h
+>>header format.h
+>>header elements.h
+
+/* Options for the command */
+#define HAS_ARG 1
+static struct option long_opts[] = {
+	{"input-type", HAS_ARG, NULL, 'I'},
+	{"output-type", HAS_ARG, NULL, 'O'},
+	{"output-file", HAS_ARG, NULL, 'o'},
+	{0, 0, 0, 0},
+};
+
+
+>>function main
+int
+int  argc;  number of arguments
+char **argv; argument vector
+
+>>description
+Usage:
+
+ mdmlconv [-I input-type] [-O output-type] -o out-file input-file
+ Recognised types are:
+   midi   midi
+   midi0  midi format 0
+   midi1  midi format 1
+   mdml   mdml format
+
+If you do not specify a type it defaults by guessing from the file
+extension or by looking for magic numbers in the file.
+
+>>code
+	int  c;
+	char *cp;
+	char opts[NELEM(long_opts) * 2 + 1];
+	struct option *op;
+	char *outputfile = NULL;
+	char *inputfile = NULL;
+	char *inputtype = NULL;
+	char *outputtype = NULL;
+	struct rootElement *root;
+	fileReadFunc readfn;
+	fileWriteFunc writefn;
+
+	/* Build up the short option string */
+	cp = opts;
+	for (op = long_opts; op < &long_opts[NELEM(long_opts)]; op++) {
+		*cp++ = op->val;
+		if (op->has_arg)
+			*cp++ = ':';
+	}
+
+	/* Deal with the options */
+	for (;;) {
+		c = getopt_long(argc, argv, opts, long_opts, NULL);
+		if (c == -1)
+			break;
+
+		switch(c) {
+		case 'I':
+			inputtype = optarg;
+			break;
+		case 'O':
+			outputtype = optarg;
+			break;
+		case 'o':
+			outputfile = optarg;
+			break;
+		case '?':
+			show_usage();
+			break;
+		}
+	}
+
+	if (outputfile == NULL) {
+		fprintf(stderr, "No output filename supplied\n");
+		exit(1);
+	}
+
+	if (argc - optind != 1) {
+		fprintf(stderr, "One input file name must be supplied\n");
+		exit(1);
+	}
+
+	inputfile = argv[optind];
+
+	if (inputtype == NULL)
+		inputtype = file_guess_type(inputfile);
+	if (outputtype == NULL)
+		outputtype = file_guess_type(outputfile);
+
+	if (inputtype == NULL || outputtype == NULL) {
+		fprintf(stderr, "Could not determine input and output types\n");
+		fprintf(stderr, "   Use the -O and -I options to specify types\n");
+		exit(1);
+	}
+
+	/* Get and call function to read in the file */
+	readfn = file_get_read_func(inputtype);
+	if (!readfn) {
+		fprintf(stderr, "Do not know how to read %s\n", inputfile);
+		exit(1);
+	}
+	root = readfn(inputfile);
+
+	/* Get and call function to write out file */
+	writefn = file_get_write_func(outputtype);
+	if (!writefn) {
+		fprintf(stderr, "Do not know how to write %s (type %s)\n",
+			outputfile, outputtype);
+		exit(1);
+	}
+	writefn(outputfile, root, 0);
+
+	md_free(MD_ELEMENT(root));
+
+	return 0;
+
+
+>>function show_usage
+static void
+
+>>description
+Print a usage message and exit.
+
+>>code
+>>header <stdio.h>
+char **cpp;
+static char *msg[] = {
+"Usage:",
+"",
+" mdmlconv [-I input-type] [-O output-type] -o out-file input-file",
+" Recognised types are:",
+"   midi   midi",
+"   midi0  midi format 0 (notyet)",
+"   midi1  midi format 1 (notyet)",
+"   mdml   mdml format",
+"",
+"If you do not specify a type it defaults by guessing from the file",
+"extension [or by looking for magic numbers in the file. (not implemented)]",
+};
+
+	for (cpp = msg; cpp < msg+NELEM(msg); cpp++) {
+		fprintf(stderr, "%s\n", *cpp);
+	}
+	exit(1);
diff -rNu melys-0.0.4/programs/melys.c melys-0.0.5/programs/melys.c
--- melys-0.0.4/programs/melys.c	Fri Jul 30 00:43:20 1999
+++ melys-0.0.5/programs/melys.c	Mon Aug  9 00:51:37 1999
@@ -37,11 +37,12 @@
 /* Options for the command */
 #define HAS_ARG 1
 static struct option long_opts[] = {
+	{"debug", 1, NULL, 'x'},
 	{0, 0, 0, 0},
 };
 
 extern int melys_app(int argc, char **argv);
-static void showusage();
+static void showusage(void);
 
 
 /*
@@ -77,6 +78,9 @@
 			break;
 
 		switch(c) {
+		case 'x':
+			DBlevel = atoi(optarg);
+			break;
 		case '?':
 			showusage();
 			exit(1);
@@ -102,8 +106,17 @@
  * 
  */
 static void 
-showusage()
+showusage(void)
 {
+	char **cpp;
+	static char *msg[] = {
+
+	N_("Usage: melys [-x level]"),
+	"",
+	N_("  -x, --debug=LEVEL  Set debuging level"),
+
+	};
 
-	fprintf(stderr, "There are no options even yet\n");
+	for (cpp = msg; cpp < ENDOF(msg); cpp++)
+		fprintf(stderr, "%s\n", _(*cpp));
 }
diff -rNu melys-0.0.4/programs/melys.m melys-0.0.5/programs/melys.m
--- melys-0.0.4/programs/melys.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/programs/melys.m	Mon Aug  9 00:05:59 1999
@@ -0,0 +1,131 @@
+>>name melys.m A sequencer program
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+>>target melys
+>>make --objects melys.o
+>>make --objects ../files/midiread.o ../files/midiwrite.o
+>>make --objects ../files/mdmlread.o ../files/mdmlwrite.o
+>>make --objects ../files/format.o
+>>make --objects ../seq/seqlib.o ../seq/seqmidi.o ../seq/sequtil.o
+>>make --objects ../util/except.o ../util/util.o
+>>make --objects ../md/elements.o ../md/mdutil.o
+>>make --objects ../gui/main.o ../gui/menus.o
+>>make --objects ../widgets/register.o
+>>make --objects ../midi/play.o ../midi/record.o
+>>make --objects ../song/song.o
+>>make --objects ../config/ports.o
+>>make --objects ../widgets/melystrack.o ../widgets/melystrackinfo.o
+>>make --objects ../widgets/melystrackdisplay.o
+
+>>header <stdio.h>
+>>header <stdlib.h>
+>>header <unistd.h>
+>>header <getopt.h>
+>>header <locale.h>
+>>header gtk/gtkmain.h
+
+>>headerdef melys.h
+
+#define PACKAGE "melys"
+#define LOCALEDIR "foo"
+#define MELYS_VERSION_STRING "0.0.4"
+
+>>extern
+/*
+ * Start the melys sequencer
+ *	melys [options (none yet)]
+ *
+ */
+
+/* Options for the command */
+#define HAS_ARG 1
+static struct option long_opts[] = {
+	{"debug", 1, NULL, 'x'},
+	{0, 0, 0, 0},
+};
+
+extern int melys_app(int argc, char **argv);
+
+>>function main
+int
+int argc;    arg count
+char **argv; arg vector
+
+>>description
+>>code
+	char opts[NELEM(long_opts) * 2 + 1];
+	char *cp;
+	int  c;
+	struct option *op;
+
+	setlocale(LC_ALL, "");
+	//bindtextdomain(PACKAGE, LOCALEDIR);
+	textdomain(PACKAGE);
+
+
+	/* Build up the short option string */
+	cp = opts;
+	for (op = long_opts; op < &long_opts[NELEM(long_opts)]; op++) {
+		*cp++ = op->val;
+		if (op->has_arg)
+			*cp++ = ':';
+	}
+
+	/* Deal with the options */
+	for (;;) {
+		c = getopt_long(argc, argv, opts, long_opts, NULL);
+		if (c == -1)
+			break;
+
+		switch(c) {
+		case 'x':
+			DBlevel = atoi(optarg);
+			break;
+		case '?':
+			showusage();
+			exit(1);
+		}
+	}
+
+	melys_app(argc, argv);
+
+	gtk_main();
+
+	{
+	void *p;
+
+		p = malloc(1); /* Only used to get db malloc package linked in */
+		free(p);
+	}
+
+	return 0;
+
+
+>>function showusage
+static void
+
+>>description
+Show a usage message.
+
+>>code
+	char **cpp;
+	static char *msg[] = {
+
+	N_("Usage: melys [-x level]"),
+	"",
+	N_("  -x, --debug=LEVEL  Set debuging level"),
+
+	};
+
+	for (cpp = msg; cpp < ENDOF(msg); cpp++)
+		fprintf(stderr, "%s\n", _(*cpp));
+
diff -rNu melys-0.0.4/programs/pmidi.c melys-0.0.5/programs/pmidi.c
--- melys-0.0.4/programs/pmidi.c	Fri Jul 30 00:43:20 1999
+++ melys-0.0.5/programs/pmidi.c	Mon Aug  9 00:51:37 1999
@@ -56,8 +56,8 @@
 #define SEP ", \t"	/* Separators for port description */
 static seq_context_t *openports(char *portdesc);
 static void playfile(seq_context_t *ctxp, char *filename);
-static void showlist();
-static void showusage();
+static void showlist(void);
+static void showusage(void);
 static void play(void *arg, struct element *el);
 
 
@@ -254,7 +254,7 @@
  * 
  */
 static void 
-showlist()
+showlist(void)
 {
 	snd_seq_client_info_t cinfo;
 	snd_seq_port_info_t pinfo;
@@ -299,7 +299,7 @@
  * Show a usage message
  */
 static void 
-showusage()
+showusage(void)
 {
 char **cpp;
 static char *msg[] = {
diff -rNu melys-0.0.4/programs/pmidi.m melys-0.0.5/programs/pmidi.m
--- melys-0.0.4/programs/pmidi.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/programs/pmidi.m	Thu Jul 29 14:21:42 1999
@@ -0,0 +1,365 @@
+>>name pmidi.m A play midi program
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+>>target pmidi
+>>make --objects pmidi.o
+>>make --objects ../files/midiread.o ../seq/seqlib.o ../seq/seqmidi.o
+>>make --objects ../util/except.o ../md/elements.o ../md/mdutil.o
+
+>>extern
+/*
+ * Play a midi file
+ *	pmidi [-p client:port,... ] [-l] [-d delay] file ...
+ *
+ *	  -p client:port  - A alsa client and port number to send midi to
+ *	  -l              - List possible output ports that could be used
+ *	  -d delay        - Delay after song ends (default 2 sec)
+ */
+>>header <stdlib.h>
+>>header <stdio.h>
+>>header <unistd.h>
+>>header <getopt.h>
+>>header <sys/asoundlib.h>
+>>header seqlib.h
+>>header elements.h
+>>header midi.h
+>>header md.h
+
+/* Options for the command */
+#define HAS_ARG 1
+static struct option long_opts[] = {
+	{"port", HAS_ARG, NULL, 'p'},
+	{"list", 0, NULL, 'l'},
+	{"delay", HAS_ARG, NULL, 'd'},
+	{0, 0, 0, 0},
+};
+
+/* Delay at the end of a song */
+static int  delay = 2;
+
+#define ADDR_PARTS 4 /* Number of part in a port description addr 1:2:3:4 */
+#define SEP ", \t"	/* Separators for port description */
+
+>>function main
+int
+int argc;    arg count
+char **argv; arg vector
+
+>>description
+Play a midi file
+  pmidi [-p client:port ...] [-l] [-d delay] file ...
+
+  -p, --port=client:port  - An ALSA client and port number to use
+  -l, --list              - List possible output ports that could be used
+  -d, --delay=SECS        - Delay after song ends (default 2 sec)
+>>code
+	char opts[NELEM(long_opts) * 2 + 1];
+	char *portdesc;
+	seq_context_t *ctxp;
+	char *cp;
+	int  c;
+	struct option *op;
+
+	/* Build up the short option string */
+	cp = opts;
+	for (op = long_opts; op < &long_opts[NELEM(long_opts)]; op++) {
+		*cp++ = op->val;
+		if (op->has_arg)
+			*cp++ = ':';
+	}
+
+	portdesc = NULL;
+
+	/* Deal with the options */
+	for (;;) {
+		c = getopt_long(argc, argv, opts, long_opts, NULL);
+		if (c == -1)
+			break;
+
+		switch(c) {
+		case 'p':
+			portdesc = optarg;
+			break;
+		case 'd':
+			delay = atoi(optarg);
+			break;
+		case 'l':
+			showlist();
+			exit(0);
+			break;
+		case '?':
+			showusage();
+			exit(1);
+		}
+	}
+
+	if (portdesc == NULL) {
+		portdesc = getenv("ALSA_OUT_PORT");
+		if (portdesc == NULL) {
+			fprintf(stderr, "No client/port specified.\n"
+				"You must supply one with the -p option or with the\n"
+				"environment variable ALSA_OUT_PORT\n"
+				);
+			exit(1);
+		}
+	}
+
+	ctxp = openports(portdesc);
+	if (ctxp == NULL)
+		return 1;
+
+	/* Now play all the files */
+	for (; optind < argc; optind++)
+		playfile(ctxp, argv[optind]);
+
+	seq_context_free(ctxp);
+	return 0;
+
+>>header <string.h>
+>>function openports
+static seq_context_t *
+char *portdesc;
+
+>>description
+Read a list of client/port specifications and return an array of
+.M snd_seq_addr_t
+that describes them.
+
+>>code
+	char *astr;
+	char *cp;
+	seq_context_t *ctxp;
+	snd_seq_addr_t *addr;
+	snd_seq_addr_t *ap;
+	int a[ADDR_PARTS];
+	int count, naddr;
+	int i;
+
+	if (portdesc == NULL)
+		return NULL;
+
+	ctxp = seq_context_new("pmidi");
+
+	addr = g_new(snd_seq_addr_t, strlen(portdesc));
+
+	naddr = 0;
+	ap = addr;
+
+	for (astr = strtok(portdesc, SEP); astr; astr = strtok(NULL, SEP)) {
+		for (cp = astr, count = 0; cp && *cp; cp++) {
+			if (count < ADDR_PARTS)
+				a[count++] = atoi(cp);
+			cp = strchr(cp, ':');
+			if (cp == NULL)
+				break;
+		}
+
+		switch (count) {
+		case 2:
+			ap->client = a[0];
+			ap->port = a[1];
+			break;
+		default:
+			printf("Addresses in %d parts not supported yet\n", count);
+			break;
+		}
+		ap++;
+		naddr++;
+	}
+
+	count = 0;
+	for (i = 0; i < naddr; i++) {
+		int  err = 0;
+		
+		//XXX err = seq_connect_add(ctxp, addr[i].client, addr[i].port);
+		printf("@func_name need seq_connect_add\n");
+		if (err < 0) {
+			fprintf(stderr, _("Could not connect to port %d:%d\n"),
+				addr[i].client, addr[i].port);
+		} else
+			count++;
+	}
+
+	g_free(addr);
+
+	if (count == 0) {
+		seq_context_free(ctxp);
+		return NULL;
+	}
+
+	return ctxp;
+
+>>function playfile
+static void
+seq_context_t *ctxp;
+char *filename;
+>>description
+Play a single file.
+>>code
+	struct rootElement *root;
+	struct sequenceState *seq;
+	struct element *el;
+	unsigned long end;
+	snd_seq_event_t *ep;
+
+	root = midi_read_file(filename);
+	if (!root)
+		return;
+
+	/* Loop through all the elements in the song and play them */
+	seq = md_sequence_init(root);
+	while ((el = md_sequence_next(seq)) != NULL) {
+		play(ctxp, el);
+	}
+
+	/* Get the end time for the tracks and echo an event to
+	 * wake us up at that time
+	 */
+	end = md_sequence_duration(seq);
+	seq_midi_send_echo(ctxp, end, 0);
+
+	/* Wait for all the events to be played */
+	snd_seq_event_input(seq_handle(ctxp), &ep);
+
+	/* Wait some extra time to allow for note to decay etc */
+	sleep(delay);
+	seq_timer_stop(ctxp);
+
+	md_free(MD_ELEMENT(root));
+
+
+>>function showlist
+static void
+
+>>description
+Show a list of possible output ports that midi could
+be sent to.
+
+>>header <errno.h>
+>>code
+	snd_seq_client_info_t cinfo;
+	snd_seq_port_info_t pinfo;
+	snd_seq_system_info_t sysinfo;
+	int  client;
+	int  port;
+	int  err;
+	snd_seq_t *handle;
+
+	err = snd_seq_open(&handle, SND_SEQ_OPEN);
+	if (err < 0)
+		ethrow(ioError, _("Could not open sequencer %s"), snd_strerror(errno));
+
+	err = snd_seq_system_info(handle, &sysinfo);
+	if (err < 0)
+		ethrow(ioError, _("Could not get sequencer information %s"),
+			snd_strerror(err));
+
+	printf(_(" Port     %-30.30s    %s\n"), _("Client name"), _("Port name"));
+	for (client = 0; client < sysinfo.clients; client++) {
+		err = snd_seq_get_any_client_info(handle, client, &cinfo);
+		if (err < 0)
+			continue;
+
+		for (port = 0; port < sysinfo.ports; port++) {
+			int  cap;
+
+			err = snd_seq_get_any_port_info(handle, client, port, &pinfo);		
+			if (err < 0)
+				continue;
+
+			cap = (SND_SEQ_PORT_CAP_SUBSCRIPTION|SND_SEQ_PORT_CAP_OUT);
+			if ((pinfo.capability & cap) == cap) {
+				printf("%3d:%-3d   %-30.30s    %s\n",
+					pinfo.client, pinfo.port, cinfo.name, pinfo.name);
+			}
+		}
+	}
+
+
+>>function showusage
+static void
+>>description
+Show a usage message
+>>code
+>>header <stdio.h>
+char **cpp;
+static char *msg[] = {
+N_("Usage: pmidi [-p client:port ...] [-l] [-d delay] file ..."),
+"",
+N_("  -p client:port  - A alsa client and port number to send midi to"),
+N_("  -l              - List possible output ports that could be used"),
+N_("  -d delay        - Delay after song ends (default 2 sec)"),
+};
+
+	for (cpp = msg; cpp < msg+NELEM(msg); cpp++) {
+		fprintf(stderr, "%s\n", _(*cpp));
+	}
+
+
+>>function play
+static void
+void *arg;
+struct element *el;
+
+>>code
+	seq_context_t *ctxp = arg;
+	snd_seq_event_t ev;
+	
+	seq_midi_event_init(ctxp, &ev, el->element_time, el->device_channel);
+	switch (el->type) {
+	case MD_TYPE_HEAD:
+		seq_init_tempo(ctxp, MD_HEAD(el)->time_base, 120, 1);
+		seq_timer_start(ctxp);
+		return;
+	case MD_TYPE_NOTE:
+		seq_midi_note(ctxp, &ev, MD_NOTE(el)->note, MD_NOTE(el)->vel,
+			MD_NOTE(el)->length);
+		break;
+	case MD_TYPE_CONTROL:
+		seq_midi_control(ctxp, &ev, MD_CONTROL(el)->control,
+			MD_CONTROL(el)->value);
+		break;
+	case MD_TYPE_PROGRAM:
+		seq_midi_program(ctxp, &ev, MD_PROGRAM(el)->program);
+		break;
+	case MD_TYPE_TEMPO:
+		seq_midi_tempo(ctxp, &ev, MD_TEMPO(el)->micro_tempo);
+		break;
+	case MD_TYPE_PITCH:
+		seq_midi_pitchbend(ctxp, &ev, MD_PITCH(el)->pitch);
+		break;
+	case MD_TYPE_PRESSURE:
+		seq_midi_chanpress(ctxp, &ev, MD_PRESSURE(el)->velocity);
+		break;
+	case MD_TYPE_KEYTOUCH:
+		seq_midi_keypress(ctxp, &ev, MD_KEYTOUCH(el)->note,
+			MD_KEYTOUCH(el)->velocity);
+		break;
+	case MD_TYPE_SYSEX:
+		seq_midi_sysex(ctxp, &ev, MD_SYSEX(el)->status, MD_SYSEX(el)->data,
+			MD_SYSEX(el)->length);
+		break;
+
+	case MD_TYPE_ROOT:
+	case MD_TYPE_TEXT:
+	case MD_TYPE_KEYSIG:
+	case MD_TYPE_TIMESIG:
+	case MD_TYPE_SMPTEOFFSET:
+	case MD_TYPE_PART:
+		/* Ones that have no sequencer action */
+		return;
+	default:
+		printf("WARNING: play: not implemented yet %d\n", el->type);
+		return;
+	}
+
+	seq_write(ctxp, &ev);
diff -rNu melys-0.0.4/programs/showseq.c melys-0.0.5/programs/showseq.c
--- melys-0.0.4/programs/showseq.c	Fri Jul 30 00:43:20 1999
+++ melys-0.0.5/programs/showseq.c	Mon Aug  9 00:51:37 1999
@@ -37,8 +37,8 @@
 
 #define ADDR_PARTS 4 /* Number of part in a port description addr 1:2:3:4 */
 #define SEP ", \t"	/* Separators for port description */
-static void showlist();
-static void showusage();
+static void showlist(void);
+static void showusage(void);
 
 
 /*
@@ -91,7 +91,7 @@
  * 
  */
 static void 
-showlist()
+showlist(void)
 {
 	snd_seq_client_info_t cinfo;
 	snd_seq_port_info_t pinfo;
@@ -158,7 +158,7 @@
  * Show a usage message
  */
 static void 
-showusage()
+showusage(void)
 {
 char **cpp;
 static char *msg[] = {
diff -rNu melys-0.0.4/programs/showseq.m melys-0.0.5/programs/showseq.m
--- melys-0.0.4/programs/showseq.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/programs/showseq.m	Fri Jul 30 00:10:30 1999
@@ -0,0 +1,165 @@
+>>name showseq.m - Print out the ALSA ports
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+>>target showseq
+>>make --objects showseq.o
+>>make --objects ../seq/seqlib.o 
+>>make --objects ../util/except.o 
+
+>>extern
+>>header <stdlib.h>
+>>header <stdio.h>
+>>header <unistd.h>
+>>header <getopt.h>
+>>header <sys/asoundlib.h>
+>>header seqlib.h
+
+/* Options for the command */
+#define HAS_ARG 1
+static struct option long_opts[] = {
+	{0, 0, 0, 0},
+};
+
+#define ADDR_PARTS 4 /* Number of part in a port description addr 1:2:3:4 */
+#define SEP ", \t"	/* Separators for port description */
+
+>>function main
+int
+int argc;    arg count
+char **argv; arg vector
+
+>>description
+Show all ALSA sequencer ports.
+   showseq
+
+>>code
+	char opts[NELEM(long_opts) * 2 + 1];
+	char *portdesc;
+	char *cp;
+	int  c;
+	struct option *op;
+
+	/* Build up the short option string */
+	cp = opts;
+	for (op = long_opts; op < &long_opts[NELEM(long_opts)]; op++) {
+		*cp++ = op->val;
+		if (op->has_arg)
+			*cp++ = ':';
+	}
+
+	portdesc = NULL;
+
+	/* Deal with the options */
+	for (;;) {
+		c = getopt_long(argc, argv, opts, long_opts, NULL);
+		if (c == -1)
+			break;
+
+		switch(c) {
+		case '?':
+			showusage();
+			exit(1);
+		}
+	}
+
+	showlist();
+	return 0;
+
+
+>>function showlist
+static void
+
+>>description
+Show a list of possible output ports that midi could
+be sent to.
+
+>>header <errno.h>
+>>code
+	snd_seq_client_info_t cinfo;
+	snd_seq_port_info_t pinfo;
+	snd_seq_system_info_t sysinfo;
+	int  client;
+	int  port;
+	int  err;
+	snd_seq_t *handle;
+
+	err = snd_seq_open(&handle, SND_SEQ_OPEN);
+	if (err < 0)
+		ethrow(ioError, _("Could not open sequencer %s"), snd_strerror(errno));
+
+	err = snd_seq_system_info(handle, &sysinfo);
+	if (err < 0)
+		ethrow(ioError, _("Could not get sequencer information %s"),
+			snd_strerror(err));
+
+	printf(_(" %4s %-30.30s\n"), _("Port"), _("Port name"));
+	for (client = 0; client < sysinfo.clients; client++) {
+		err = snd_seq_get_any_client_info(handle, client, &cinfo);
+		if (err < 0)
+			continue;
+
+		printf("%d: %s ", cinfo.client, cinfo.name);
+		switch (cinfo.type) {
+		case NO_CLIENT:
+			printf("[none] ");
+			break;
+		case USER_CLIENT:
+			printf("[user] ");
+			break;
+		case KERNEL_CLIENT:
+			printf("[kernel] ");
+			break;
+		}
+		printf("\n");
+		for (port = 0; port < sysinfo.ports; port++) {
+
+			err = snd_seq_get_any_port_info(handle, client, port, &pinfo);		
+			if (err < 0)
+				continue;
+
+			printf("  %-3d %-30.30s  ",
+				pinfo.port, pinfo.name);
+			if (pinfo.capability & SND_SEQ_PORT_CAP_IN)
+				printf("in ");
+			if (pinfo.capability & SND_SEQ_PORT_CAP_OUT)
+				printf("out ");
+			if (pinfo.capability & SND_SEQ_PORT_CAP_SUBSCRIPTION)
+				printf("sub ");
+			if (pinfo.capability & SND_SEQ_PORT_CAP_SYNC_IN)
+				printf("sync-in ");
+			if (pinfo.capability & SND_SEQ_PORT_CAP_SYNC_OUT)
+				printf("sync-out ");
+			if (pinfo.capability & SND_SEQ_PORT_CAP_DUPLEX)
+				printf("duplex ");
+			printf("\n");
+		}
+	}
+
+
+>>function showusage
+static void
+>>description
+Show a usage message
+>>code
+>>header <stdio.h>
+char **cpp;
+static char *msg[] = {
+N_("Usage: showseq"),
+"",
+};
+
+	for (cpp = msg; cpp < msg+NELEM(msg); cpp++) {
+		fprintf(stderr, "%s\n", _(*cpp));
+	}
+
+
diff -rNu melys-0.0.4/seq/.cvsignore melys-0.0.5/seq/.cvsignore
--- melys-0.0.4/seq/.cvsignore	Fri Jul 30 00:43:11 1999
+++ melys-0.0.5/seq/.cvsignore	Mon Aug  9 00:51:27 1999
@@ -2,6 +2,5 @@
 seqmidi.c
 sequtil.c
 Makefile
-*.mdml
-*.mid
+*.mdml *.mdml.gz *.mid
 .cvsignore
diff -rNu melys-0.0.4/seq/seqlib.c melys-0.0.5/seq/seqlib.c
--- melys-0.0.4/seq/seqlib.c	Fri Jul 30 00:43:16 1999
+++ melys-0.0.5/seq/seqlib.c	Mon Aug  9 00:51:33 1999
@@ -152,7 +152,9 @@
 		return;
 
 	/* Freeing a sub-context just closes the seq connection */
-	snd_seq_close(ctxp->handle);
+	if (ctxp->handle)
+		snd_seq_close(ctxp->handle);
+	ctxp->handle = NULL;
 
 	if (ctxp->main == ctxp) {
 		/* This is the main context */
@@ -658,7 +660,8 @@
 	/* Since there is not yet a proper flush call we will just
 	 * close and re-open.  Not ideal...
 	 */
-	snd_seq_close(ctxp->handle);
+	if (ctxp->handle)
+		snd_seq_close(ctxp->handle);
 	snd_seq_open(&ctxp->handle, SND_SEQ_OPEN);
 	ctxp->client = snd_seq_client_id(ctxp->handle);
 	snd_seq_block_mode(ctxp->handle, 0); /* XXX */
diff -rNu melys-0.0.4/seq/seqlib.m melys-0.0.5/seq/seqlib.m
--- melys-0.0.4/seq/seqlib.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/seq/seqlib.m	Sat Aug  7 11:21:26 1999
@@ -0,0 +1,783 @@
+>>name seqlib.m
+File: seqlib.m - Interface to the alsa sequencer library.
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+
+---------
+This file is a set of interfaces to provide a little
+higher level view of the sequencer.  It is mainly experimental
+to investigate new approaches.  If successful they will be proposed
+as additions/replacements to the existing seq lib.
+
+>>header <stdio.h>
+>>header <errno.h>
+>>header <string.h>
+
+>>headerdef --decl seqlib.h
+#include <sys/asoundlib.h>
+
+typedef struct seq_context seq_context_t;
+
+>>headerdef --local seqpriv.h
+
+struct seq_context {
+	snd_seq_t *handle; /* The snd_seq handle to /dev/snd/seq */
+	int  client;/* The client associated with this context */
+	int  queue; /* The queue to use for all operations */
+	snd_seq_addr_t  source;	/* Source for events */
+
+	GArray  *destlist;	/* Destination list */
+	GArray  *srclist;	/* Source address list */
+
+	char  timer_started;	/* True if timer is running */
+	int   port_count;		/* Ports allocated */
+
+	struct seq_context *main; /* Pointer to the main context */
+	struct seq_context *control; /* Pointer to the control context */
+
+	struct seq_context *next; /* Next context in chain */
+
+	/* Flags */
+	unsigned int inconnected:1,
+		outconnected:1
+		;
+};
+
+>>function seq_context_new
+seq_context_t *
+char *name;      Name of the client.
+>>description
+Create a main client for an application.
+A queue is allocated and a client is created.
+>>code
+	seq_context_t *ctxp;
+	snd_seq_queue_client_t qclient;
+	int  q;
+
+	ctxp = g_new0(seq_context_t, 1);
+	ctxp->main = ctxp; /* This is the main context */
+	ctxp->next = NULL;
+
+	/* Allocate client */
+	if (snd_seq_open(&ctxp->handle, SND_SEQ_OPEN) < 0)
+		ethrow(ioError, _("Could not open sequencer: %s"), snd_strerror(errno));
+
+	ctxp->client = snd_seq_client_id(ctxp->handle);
+
+	ctxp->destlist = g_array_new(0, 0, sizeof(snd_seq_addr_t));
+	ctxp->srclist = g_array_new(0, 0, sizeof(snd_seq_addr_t));
+
+	/* Fill in source address */
+	ctxp->source.client = ctxp->client;
+	ctxp->source.port = 0;
+	ctxp->source.channel = 0;
+
+	/* Create a control client for important messages */
+	ctxp->control = seq_add_subcontext(ctxp);
+
+	/* Control port is always in non-blocking mode, but it never should */
+	snd_seq_block_mode(ctxp->control->handle, 0);
+
+	/*
+	 * Allocate the application queue. The control client has
+	 * to own it as only the owner can start stop the queue
+	 */
+	q = snd_seq_alloc_queue(ctxp->control->handle);
+	ctxp->queue = q;
+	ctxp->source.queue = q;
+	//q = snd_seq_alloc_queue(ctxp->control->handle);
+	ctxp->control->queue = q;
+	ctxp->control->source.queue = q;
+
+	snd_seq_get_queue_client(ctxp->control->handle, q, &qclient);
+	snd_seq_set_queue_client(ctxp->handle, q, &qclient);
+
+	ctxp->inconnected = 0;
+	ctxp->outconnected = 0;
+
+	/* Always need at least one port */
+	seq_new_port(ctxp);
+
+	seq_set_client_name(ctxp, name);
+
+	return ctxp;
+
+
+>>function seq_add_subcontext
+seq_context_t *
+seq_context_t *ctxp;
+
+>>description
+Create another client context based on the specified context.
+The same queue will be used for both clients.
+
+>>code
+	seq_context_t *nctxp;
+	snd_seq_queue_client_t qclient;
+
+	nctxp = g_new(seq_context_t, 1);
+
+	/* Most members need to be copied */
+	*nctxp = *ctxp;
+
+	nctxp->main = ctxp; /* Back link to the main context */
+
+	/* Link in */
+	nctxp->next = ctxp->next;
+	ctxp->next = nctxp;
+
+	if (snd_seq_open(&nctxp->handle, SND_SEQ_OPEN) < 0)
+		ethrow(ioError, _("Could not open sequencer: %s"), snd_strerror(errno));
+
+	nctxp->client = snd_seq_client_id(nctxp->handle);
+	nctxp->source.client = nctxp->client;
+
+	/* Get qclient info from control and set it on the new client */
+	if (ctxp->control) {
+		snd_seq_get_queue_client(ctxp->control->handle, ctxp->queue, &qclient);
+		snd_seq_set_queue_client(nctxp->handle, ctxp->queue, &qclient);
+	}
+
+	seq_new_port(nctxp);
+
+	return nctxp;
+
+
+>>function seq_context_free
+void
+seq_context_t *ctxp;
+>>description
+Free a context and any associated data and resources.
+If the main context is freed then the sequencer is closed.
+TODO: link all together so can all be closed at once.
+>>code
+	seq_context_t *ncp;
+
+	if (ctxp == NULL)
+		return;
+
+	/* Freeing a sub-context just closes the seq connection */
+	if (ctxp->handle)
+		snd_seq_close(ctxp->handle);
+	ctxp->handle = NULL;
+
+	if (ctxp->main == ctxp) {
+		/* This is the main context */
+		snd_seq_free_queue(ctxp->control->handle, ctxp->queue);
+
+		g_array_free(ctxp->destlist, 1);
+		g_array_free(ctxp->srclist, 1);
+		ctxp->destlist = NULL;
+		ctxp->srclist = NULL;
+
+		/* Free all subcontext's */
+		for (ctxp = ctxp->next; ctxp; ctxp = ncp) {
+			ncp = ctxp->next;
+
+			seq_context_free(ctxp);
+			g_free(ctxp);
+		}
+
+		g_free(ctxp);
+	}
+
+
+
+>>function seq_new_port
+int
+seq_context_t *ctxp; // Context to create the port for
+>>description
+Creates a new port on the specified context and returns the port
+number.
+>>code
+	snd_seq_port_info_t info;
+	int  ret;
+
+	memset(&info, 0, sizeof(info));
+	info.capability = SND_SEQ_PORT_CAP_OUT
+		| SND_SEQ_PORT_CAP_SUBSCRIPTION | SND_SEQ_PORT_CAP_IN;
+	info.type =  SND_SEQ_PORT_TYPE_MIDI_GENERIC;
+	info.midi_channels = 16;
+	info.out_use = 1;
+	info.in_use = 1;
+	info.kernel = NULL;
+
+	ret = snd_seq_create_port(ctxp->handle, &info);
+	if (ret < 0) {
+		ethrow(ioError, _("Error (%s) creating sequencer port\n"),
+			snd_strerror(errno));
+		return -1;
+	}
+	ctxp->port_count++;
+	ctxp->source.port = info.port;
+
+	return info.port;/*XXX*/
+
+
+>>function seq_destroy_port
+void
+seq_context_t *ctxp; // Application context
+int  port;	// Port number to destroy
+
+>>code
+
+	g_warning("@func_name is not implemented yet");
+
+
+>>function seq_set_client_name
+void
+seq_context_t *ctxp;
+char  *name;   The client name to set
+
+>>description
+The name of the directly associated client on the context is set.
+
+>>code
+	snd_seq_client_info_t info;
+#define INFO_NAME_LEN 64  /* Hard coded in the header file */
+
+	if (name == NULL)
+		return;
+
+	snd_seq_get_client_info(ctxp->handle, &info);
+	memset(info.name, '\0', INFO_NAME_LEN);
+	strncpy(info.name, name, INFO_NAME_LEN-1);
+	snd_seq_set_client_info(ctxp->handle, &info);
+
+	if (ctxp->main == ctxp) {
+		gchar *ctlname;
+
+		ctlname = g_strconcat(name, " (control)", NULL);
+		seq_set_client_name(ctxp->control, ctlname);
+		g_free(ctlname);
+	}
+
+>>headerdef seqlib.h
+
+/*
+ * Defines to indicate whether input or output address are
+ * to be dealt with.
+ */
+enum addrtype {
+	SEQ_ADDR_INPUT,
+	SEQ_ADDR_OUTPUT
+};
+
+>>function seq_set_addresses
+void
+seq_context_t *ctxp;
+enum addrtype inout;	Whether in or out
+snd_seq_addr_t *addrlist;	The list of addresses
+int  n;		The size of the list
+
+>>description
+Set one of the address lists on the context.
+This will define the logical devices for this context.
+In other words the first address in the list is logical device 0.
+A copy is made of the list.
+
+>>code
+	GArray *list;
+	int  i;
+
+	list = get_addr_list(ctxp, inout);
+	if (!list)
+		return;
+
+	for (i = 0; i < n; i++) {
+		addrlist[i].queue = ctxp->queue;
+	}
+
+	g_array_set_size(list, 0);
+	g_array_append_vals(list, addrlist, n);
+
+
+>>function seq_connect_addresses
+int
+seq_context_t *ctxp;
+int    inout;      Whether in or out
+
+>>description
+Actually connect the addresses in one of the address lists.
+Its not esential to connect the output list, but has the advantage
+that disconnecting will disable the device.
+
+>>code
+	snd_seq_port_subscribe_t subs;
+	snd_seq_addr_t addr;
+	GArray *list;
+	int  ret = 0;
+	int  i;
+
+	list = get_addr_list(ctxp, inout);
+	if (!list)
+		return -EINVAL;
+
+	if (inout == SEQ_ADDR_INPUT && ctxp->inconnected)
+		return 0;
+	if (inout == SEQ_ADDR_OUTPUT && ctxp->outconnected)
+		return 0;
+
+	memset(&subs, 0, sizeof(subs));
+	for (i = 0; i < list->len; i++) {
+
+		addr = g_array_index(list, snd_seq_addr_t, i);
+
+		addr.queue = ctxp->queue;
+
+		if (inout == SEQ_ADDR_INPUT) {
+			ctxp->inconnected = 1;
+			subs.dest = ctxp->source;
+			subs.sender = addr;
+		} else {
+			ctxp->outconnected = 1;
+			subs.sender = ctxp->source;
+			subs.dest = addr;
+		}
+
+#if 0
+printf("Connect from %s to %s\n",
+			seq_addr_string(&subs.sender),
+			seq_addr_string(&subs.dest));
+#endif
+
+		subs.realtime = 0; /* XXX */
+		subs.exclusive = 0;
+		ret = snd_seq_subscribe_port(ctxp->handle, &subs);
+		if (ret < 0)
+			g_warning("subscribe failed %s", snd_strerror(ret));
+	}
+	return ret;
+
+
+>>function seq_disconnect_addresses
+int
+seq_context_t *ctxp;
+int    inout;      Whether in or out
+
+>>description
+Disconnect either input or output.
+For input this means that no more events will be received
+from those addresses.
+
+>>code
+	snd_seq_port_subscribe_t subs;
+	snd_seq_addr_t addr;
+	GArray *list;
+	int  ret = 0;
+	int  i;
+
+	list = get_addr_list(ctxp, inout);
+	if (!list)
+		return -EINVAL;
+
+	for (i = 0; i < list->len; i++) {
+
+		addr = g_array_index(list, snd_seq_addr_t, i);
+
+		addr.queue = ctxp->queue;
+
+		if (inout == SEQ_ADDR_INPUT) {
+			ctxp->inconnected = 0;
+			subs.dest = ctxp->source;
+			subs.sender = addr;
+		} else {
+			ctxp->outconnected = 0;
+			subs.sender = ctxp->source;
+			subs.dest = addr;
+		}
+
+#if 0
+printf("disconnect from %s to %s\n",
+			seq_addr_string(&subs.sender),
+			seq_addr_string(&subs.dest));
+#endif
+
+		subs.realtime = 0; /* XXX */
+		subs.exclusive = 0;
+		ret = snd_seq_unsubscribe_port(ctxp->handle, &subs);
+	}
+
+	return ret;
+
+
+>>function seq_dev_addr
+snd_seq_addr_t *
+seq_context_t *ctxp;
+int  dev;  Device to get the address of.
+int  inout;  Input or output device
+
+>>description
+Return the address corresponding to the specified
+logical device.
+
+>>code
+	GArray *list;
+	snd_seq_addr_t *addr;
+
+	list = get_addr_list(ctxp, inout);
+
+	if (dev >= list->len)
+		return NULL;
+
+	addr = &g_array_index(list, snd_seq_addr_t, dev);
+
+	return addr;
+
+
+>>function seq_init_tempo
+int
+seq_context_t *ctxp; // Application context
+int  resolution;	// Ticks per quarter note or realtime resolution
+int  tempo;		// Beats per minute
+int  realtime;  // True if absolute time base
+
+>>description
+Set the initial time base and tempo.
+This should only be used for initialisation when there is nothing
+playing.
+To change the tempo during a song tempo change events are used.
+If
+.A realtime
+is false the resolution is in ticks per quarter note.
+If true, the the resolution is microseconds.
+There is a macro XXX to convert from SMPTE codes.
+
+>>code
+	snd_seq_queue_tempo_t qtempo;
+	int  ret;
+
+	qtempo.queue = ctxp->queue;
+	qtempo.ppq = resolution;
+	qtempo.tempo = 60*1000000/tempo;
+
+	ret = snd_seq_set_queue_tempo(ctxp->control->handle, ctxp->queue, &qtempo);
+
+	return ret;
+
+
+>>function seq_set_queue
+void
+seq_context_t *ctxp;  Context to modify
+int  q;	              The queue number
+
+>>description
+Set the context to use the specified queue.
+All events sent on this context will now use this queue.
+The special values SND_SEQ_ADDRESS_SUBSCRIBERS can be used to
+send to all subscribed clients.
+
+>>code
+
+	ctxp->queue = q;
+
+
+>>function seq_sendto
+int
+seq_context_t *ctxp;  Client context
+snd_seq_event_t *ep;  Event to send
+int  dev;	Logical device to send to
+int  chan;	Channel on device
+
+>>description
+Send the event to the specified client and port.
+
+>>code
+
+	ep->source = ctxp->source;
+	ep->dest = *seq_dev_addr(ctxp, dev, SEQ_ADDR_OUTPUT);
+	ep->dest.channel = chan;
+#if 0
+	printf("send from %s to %s, event type %d time %d",
+		seq_addr_string(&ep->source), seq_addr_string(&ep->dest),
+		ep->type, ep->time.tick);
+	if (ep->flags & SND_SEQ_TIME_STAMP_REAL)
+		printf(" real");
+	if (ep->flags & SND_SEQ_TIME_MODE_REL)
+		printf(" rel");
+	printf("\n");
+#endif
+	return seq_write(ctxp, ep);
+
+>>function seq_sendto_now
+int
+seq_context_t *ctxp;  Client context
+snd_seq_event_t *ep;  Event to send
+int  dev;	Logical device to send to
+int  chan;	Channel on device
+>>description
+Just like
+.F seq_sendto
+but zeros the time field first so that the event will be
+processed straight away even if the timer is stopped.
+As long as the file descriptor is not blocked that is...
+Queue is flushed out.
+>>code
+
+	ep->time.tick = 0;
+	(void) seq_sendto(ctxp, ep, dev, chan);
+	return snd_seq_flush_output(ctxp->handle);
+
+>># ----- Timer functions
+>>function seq_timer_start
+void
+seq_context_t *ctxp;
+>>description
+Start the timer.
+(What about timers other than the system one?)
+>>code
+
+	seq_control_timer(ctxp, SND_SEQ_EVENT_START);
+
+>>function seq_timer_stop
+void
+seq_context_t *ctxp;
+>>description
+Stop the timer.
+(What about timers other than the system one?)
+>>code
+
+	seq_control_timer(ctxp, SND_SEQ_EVENT_STOP);
+
+>>function seq_timer_continue
+void
+seq_context_t *ctxp;
+>>description
+Continue the timer after pausing.
+>>code
+
+	seq_control_timer(ctxp, SND_SEQ_EVENT_CONTINUE);
+
+
+>>function seq_control_timer
+void
+seq_context_t *ctxp; // The seq context
+int  onoff;	// SND_SEQ_EVENT_START or ...STOP
+>>code
+	snd_seq_event_t ev;
+
+	ev.dest.queue = ctxp->queue;
+	ev.dest.client = SND_SEQ_CLIENT_SYSTEM;	/* system */
+	ev.dest.port = SND_SEQ_PORT_SYSTEM_TIMER;	/* timer */
+	ev.dest.channel = 0;	/* don't care */
+
+	ev.flags = SND_SEQ_TIME_STAMP_REAL | SND_SEQ_TIME_MODE_REL;
+	ev.time.real.tv_sec = 0;
+	ev.time.real.tv_nsec = 0;
+
+	ev.type = onoff;
+
+	snd_seq_event_output(ctxp->control->handle, &ev);
+	snd_seq_flush_output(ctxp->control->handle);
+
+
+>>function seq_get_time
+unsigned long
+seq_context_t *ctxp;
+>>description
+Get the current song time in ticks.
+>>code
+
+	snd_seq_queue_status_t qstatus;
+	snd_seq_get_queue_status(ctxp->handle, ctxp->queue, &qstatus);
+
+	return qstatus.tick;
+
+
+>>function seq_write
+int
+seq_context_t *ctxp; Application context
+snd_seq_event_t *ep; Event to be written
+
+>>description
+Write out the event.
+Returns zero if the event could be written without any
+blocking.
+Non zero if there is a queue inside the library.
+
+>>code
+	int  n;
+
+	if (ep->type == SND_SEQ_EVENT_TEMPO)
+		return seq_control_write(ctxp, ep);
+
+	n = snd_seq_event_output(ctxp->handle, ep);
+	if (n < 0)
+		return n;
+
+	n = snd_seq_flush_output(ctxp->handle);
+
+	return n;
+
+
+>>function seq_control_write
+int
+seq_context_t *ctxp; Application context
+snd_seq_event_t *ep; Event to be written
+
+>>description
+Write out the event, on the control client.
+This is used as a way of ensuring that we can always send important
+events like all-notes-off even when the main client would block.
+Returns zero if the event could be written without any
+blocking.
+Non zero if there is a queue inside the library.
+
+>>code
+	int  n;
+
+	n = snd_seq_event_output(ctxp->control->handle, ep);
+	if (n < 0)
+		return n;
+
+	n = snd_seq_flush_output(ctxp->control->handle);
+
+	/*
+	 * The whole point of using the control port is so that it is always
+	 * available for use and never blocked.  Therefore if it would block
+	 * then you are doing something wrong.  Find out what it is and stop it.
+	 */
+	if (n == -EAGAIN)
+		ethrow(debugError, "Control port would have blocked");
+
+	return n;
+
+
+>>function seq_read
+snd_seq_event_t *
+seq_context_t *ctxp;    The application context
+
+>>description
+Return the next event.
+Returns NULL if none.
+
+>>code
+	snd_seq_event_t *ep;
+	int ret;
+
+	ret = snd_seq_event_input(ctxp->handle, &ep);
+
+	if (ret < 0)
+		ep = NULL;
+
+	return ep;
+
+
+>>function seq_drain_output
+void
+seq_context_t *ctxp;
+
+>>description
+Flush the output queue so that there are no events left in it.
+
+>>code
+	snd_seq_queue_client_t qclient;
+
+	/* Since there is not yet a proper flush call we will just
+	 * close and re-open.  Not ideal...
+	 */
+	if (ctxp->handle)
+		snd_seq_close(ctxp->handle);
+	snd_seq_open(&ctxp->handle, SND_SEQ_OPEN);
+	ctxp->client = snd_seq_client_id(ctxp->handle);
+	snd_seq_block_mode(ctxp->handle, 0); /* XXX */
+
+	if (ctxp->inconnected)
+		seq_connect_addresses(ctxp, SEQ_ADDR_INPUT);
+	if (ctxp->outconnected)
+		seq_connect_addresses(ctxp, SEQ_ADDR_OUTPUT);
+
+	snd_seq_get_queue_client(ctxp->control->handle, ctxp->queue, &qclient);
+	snd_seq_set_queue_client(ctxp->handle, ctxp->queue, &qclient);
+
+	/* Always need at least one port */
+	seq_new_port(ctxp);
+
+>>function seq_event_data_free
+void
+snd_seq_event_t *ep;
+
+>>description
+Free any variable length extension data that may be on the
+event.
+The event itself is not freed.
+Assume data allocated with g_malloc.
+
+>>code
+
+	if ((ep->flags & SND_SEQ_EVENT_LENGTH_MASK) == SND_SEQ_EVENT_LENGTH_VARIABLE) {
+		g_free(ep->data.ext.ptr);
+		ep->data.ext.ptr = 0;
+		ep->data.ext.len = 0;
+
+		ep->flags &= ~SND_SEQ_EVENT_LENGTH_MASK;
+	}
+
+
+>>function seq_handle
+void *
+seq_context_t *ctxp; // Application context
+
+>>description
+Return the handle to the underlying snd_seq stream.
+
+>>code
+
+	return ctxp->handle;
+
+>>function seq_descriptor
+int
+seq_context_t *ctxp;  Application context
+
+>>description
+Return the underlying file descriptor.
+
+>>code
+
+	return snd_seq_file_descriptor(ctxp->handle);
+
+
+>>function seq_addr_string
+char *
+snd_seq_addr_t *addr;  Address to convert to string
+
+>>description
+Convert an address to a string.
+The string should be freed after use.
+
+>>code
+	char *str;
+
+	str = g_strdup_printf("%d:%d:%d:%d", addr->queue, addr->client,
+		addr->port, addr->channel);
+
+	return str;
+
+
+>>function get_addr_list
+static GArray *
+seq_context_t *ctxp;
+int  inout;
+>>description
+Get the correct list to use from the type.
+>>code
+	GArray *list = NULL;
+
+	if (inout == SEQ_ADDR_INPUT)
+		list = ctxp->srclist;
+	else if (inout == SEQ_ADDR_OUTPUT)
+		list = ctxp->destlist;
+	else
+		ethrow(debugError, "Unrecognised type to @func_name");
+
+	return list;
diff -rNu melys-0.0.4/seq/seqmidi.m melys-0.0.5/seq/seqmidi.m
--- melys-0.0.4/seq/seqmidi.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/seq/seqmidi.m	Thu Jul 29 14:21:42 1999
@@ -0,0 +1,256 @@
+>>name seqmidi.m Routines to write midi events.
+File: seqmidi.m - XXX
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+>>header <string.h>
+>>header seqlib.h
+>>header seqpriv.h
+
+>>headerdef --decl seqlib.h
+
+>>function seq_midi_event_init
+void
+seq_context_t *ctxp;	Client application
+snd_seq_event_t *ep;	Event to init
+unsigned long  time;	Midi time
+int  devchan;	Midi channel
+
+>>description
+Initialize a midi event from the context.
+The source and destination addresses will be set from
+the information stored in the context, which depends on the
+previous connection calls.
+In addition the time and channel are set.
+This should be called first before any of the following functions.
+
+>>code
+	int  dev;
+	int  channel;
+
+	dev = devchan >> 4;
+	channel = devchan & 0xf;
+
+	/*
+	 * If insufficient output devices have been registered, then we
+	 * just scale the device back to fit in the correct range.  This
+	 * is not necessarily what you want.
+	 */
+	if (ctxp->destlist && dev >= ctxp->destlist->len)
+		dev = dev % ctxp->destlist->len;
+	
+	memset(ep, '\0', sizeof(*ep));
+	ep->flags = SND_SEQ_TIME_STAMP_TICK | SND_SEQ_TIME_MODE_ABS;
+	ep->time.tick = time;
+	ep->source = ctxp->source;
+	if (ctxp->destlist->len > 0)
+		ep->dest = g_array_index(ctxp->destlist, snd_seq_addr_t, dev);
+	ep->dest.channel = channel;
+
+>>function seq_midi_note
+void
+seq_context_t *ctxp; Client context
+snd_seq_event_t *ep; Event template
+int  note;
+int  vel;
+int  length;
+>>description
+Send a note event.
+>>code
+
+	ep->type = SND_SEQ_EVENT_NOTE;
+
+	ep->data.note.note = note;
+	ep->data.note.velocity = vel;
+	ep->data.note.duration = length;
+
+
+>>function seq_midi_note_on
+void
+seq_context_t *ctxp; Client context
+snd_seq_event_t *ep; Event template
+int  note;
+int  vel;
+int  length;
+>>description
+Send a note on event.
+>>code
+
+	ep->type = SND_SEQ_EVENT_NOTEON;
+
+	ep->data.note.note = note;
+	ep->data.note.velocity = vel;
+	ep->data.note.duration = length;
+
+
+
+>>function seq_midi_note_off
+void
+seq_context_t *ctxp; Client context
+snd_seq_event_t *ep; Event template
+int  note;
+int  vel;
+int  length;
+>>description
+Send a note off event.
+>>code
+
+	ep->type = SND_SEQ_EVENT_NOTEOFF;
+	ep->data.note.note = note;
+	ep->data.note.velocity = vel;
+	ep->data.note.duration = length;
+
+
+>>function seq_midi_keypress
+void
+seq_context_t *ctxp;  Application context
+snd_seq_event_t *ep;  Event template
+int  note;  Note to be altered
+int  value; Pressure value
+>>description
+Send a key pressure event.
+>>code
+
+	ep->type = SND_SEQ_EVENT_KEYPRESS;
+
+	ep->data.control.param = note;
+	ep->data.control.value = value;
+
+
+>>function seq_midi_control
+void
+seq_context_t *ctxp;  Application context
+snd_seq_event_t *ep;  Event template
+int  control;  Controller to change
+int  value;    Value to set it to
+>>description
+Send a control event.
+>>code
+
+	ep->type = SND_SEQ_EVENT_CONTROLLER;
+
+	ep->data.control.param = control;
+	ep->data.control.value = value;
+
+
+>>function seq_midi_program
+void
+seq_context_t *ctxp;  Application context
+snd_seq_event_t *ep;  Event template
+int  program;  Program to set
+>>description
+Send a program change event.
+>>code
+
+	ep->type = SND_SEQ_EVENT_PGMCHANGE;
+
+	ep->data.control.value = program;
+
+
+>>function seq_midi_chanpress
+void
+seq_context_t *ctxp;  Application context
+snd_seq_event_t *ep;  Event template
+int  pressure;  Pressure value
+>>description
+Send a channel pressure event.
+>>code
+
+	ep->type = SND_SEQ_EVENT_CHANPRESS;
+
+	ep->data.control.value = pressure;
+
+
+>>function seq_midi_pitchbend
+void
+seq_context_t *ctxp;  Application context
+snd_seq_event_t *ep;  Event template
+int  bend;  Bend value, centered on zero.
+>>description
+Send a pitchbend message.  The
+.A bend
+parameter is centered on zero, negative values mean a lower pitch.
+>>code
+
+	ep->type = SND_SEQ_EVENT_PITCHBEND;
+
+	ep->data.control.value = bend;
+
+
+>>function seq_midi_tempo
+void
+seq_context_t *ctxp;  Application context
+snd_seq_event_t *ep;  Event template
+int  tempo;  New tempo in usec per beat
+>>description
+Send a tempo event.
+The tempo parameter is in microseconds per beat.
+>>code
+
+	ep->type = SND_SEQ_EVENT_TEMPO;
+
+	ep->data.control.value = tempo;
+	ep->dest.client = SND_SEQ_PORT_SYSTEM_TIMER;
+
+
+>>function seq_midi_sysex
+void
+seq_context_t *ctxp;  Application context
+snd_seq_event_t *ep;  Event template
+int  status;          Status byte for sysex
+unsigned char *data;  Data to send
+int  length;          Length of data
+>>description
+Prepare a sysex event.
+The status byte is to distiguish continuation sysex messages.
+>>code
+	unsigned char *ndata;
+	int  nlen;
+
+	ep->type = SND_SEQ_EVENT_SYSEX;
+	ep->flags &= ~SND_SEQ_EVENT_LENGTH_MASK;
+	ep->flags |= SND_SEQ_EVENT_LENGTH_VARIABLE;
+
+	ndata = g_malloc(length + 1);
+	nlen = length +1;
+
+	ndata[0] = status;
+	memcpy(ndata+1, data, length);
+
+	ep->data.ext.ptr = ndata;
+	ep->data.ext.len = nlen;
+
+
+>>function seq_midi_send_echo
+void
+seq_context_t *ctxp;  Application context
+unsigned long time;   Time of event
+int  type;            A piece of data that will be placed in the event
+>>description
+Send an echo event back to the source client at the specified time.
+You can use the type parameter to destinguish between different
+echo events.
+This is not supposed to be overused.
+
+>>code
+	snd_seq_event_t ev;
+	int  n;
+
+	seq_midi_event_init(ctxp, &ev, time, 0);
+	ev.type = SND_SEQ_EVENT_ECHO;
+
+	/* Loop back */
+	ev.dest = ctxp->source;
+	ev.data.raw32.d[0] = type;
+
+	n = seq_write(ctxp, &ev);
+	n = snd_seq_flush_output(ctxp->handle);
diff -rNu melys-0.0.4/seq/sequtil.m melys-0.0.5/seq/sequtil.m
--- melys-0.0.4/seq/sequtil.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/seq/sequtil.m	Thu Jul 29 14:21:42 1999
@@ -0,0 +1,96 @@
+>>name sequtil.m - Sequencer based utility routines.
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+>>header <stdlib.h>
+>>header <string.h>
+>>header <stdio.h>
+>>header elements.h
+>>headerdef --decl seqlib.h
+
+struct rootElement;
+>>extern
+#define ADDR_PARTS  4         /* Number of parts in an address */
+#define SEP         " ,\t\n"  /* Separators between addresses */
+
+>>function seq_get_ports_from_desc
+int
+char *portdesc;    String containing port descriptions
+snd_seq_addr_t **addrp;   Returned array
+
+>>description
+Parse the client/port description given in
+.A portdesc
+and construct an array of addresses.
+The array is returned
+into the argument
+.A addrp
+and should be freed by the caller.
+The number of valid elements in the array is returned.
+
+>>code
+	char *astr;
+	char *cp;
+	snd_seq_addr_t *addr;
+	snd_seq_addr_t *ap;
+	gchar **plist;
+	int a[ADDR_PARTS];
+	int count, naddr;
+	int i;
+
+	if (portdesc == NULL)
+		return 0;
+
+	addr = g_new(snd_seq_addr_t, strlen(portdesc));
+	naddr = 0;
+	ap = addr;
+
+	/*
+	 * Loop though all the ports given in portdesc.
+	 */
+	portdesc = g_strdelimit(portdesc, SEP, ' ');
+	plist = g_strsplit(portdesc, " ", 0);
+	for (i = 0, astr = plist[0]; astr; i++, astr = plist[i]) {
+
+		for (cp = astr, count = 0; cp && *cp; cp++) {
+			if (count < ADDR_PARTS)
+				a[count++] = atoi(cp);
+			cp = strchr(cp, ':');
+			if (cp == NULL)
+				break;
+		}
+
+		/* Depending on how many colons were present, we split up the address */
+		switch (count) {
+		case 1:
+			ap->client = a[0];
+			ap->port   = 0;
+			break;
+		case 2:
+			ap->client = a[0];
+			ap->port = a[1];
+			break;
+		default:
+			printf("Addresses in %d parts not supported yet\n", count);
+			break;
+		}
+		ap++;
+		naddr++;
+	}
+
+	g_strfreev(plist);
+
+	*addrp = addr;
+	return naddr;
+
+
+
diff -rNu melys-0.0.4/song/.cvsignore melys-0.0.5/song/.cvsignore
--- melys-0.0.4/song/.cvsignore	Fri Jul 30 00:43:11 1999
+++ melys-0.0.5/song/.cvsignore	Mon Aug  9 00:51:26 1999
@@ -1,5 +1,4 @@
 song.c
 Makefile
-*.mdml
-*.mid
+*.mdml *.mdml.gz *.mid
 .cvsignore
diff -rNu melys-0.0.4/song/song.c melys-0.0.5/song/song.c
--- melys-0.0.4/song/song.c	Fri Jul 30 00:43:16 1999
+++ melys-0.0.5/song/song.c	Mon Aug  9 00:51:32 1999
@@ -70,7 +70,6 @@
 	record_set_mdroot(song->record, root);
 
 	play_set_ports(song->play);
-	//play_set_ports(song->echo);
 	record_set_ports(song->record);
 
 	song->newtrack = md_track_new();
@@ -85,7 +84,7 @@
  * 
  */
 void 
-song_set_echo()
+song_set_echo(void)
 {
 }
 
@@ -95,7 +94,7 @@
  * 
  */
 void 
-song_reset_echo()
+song_reset_echo(void)
 {
 }
 
@@ -241,6 +240,8 @@
 	struct song *sd;
 	GtkWidget *w;
 
+	dprintf1("song_destroy");
+
 	sd = data;
 
 	/* Destroy all resources */
@@ -259,6 +260,10 @@
 		if (w)
 			gtk_widget_destroy(w);
 	}
+
+	/* Record (and any other subcontext) must be freed first */
+	if (sd->record)
+		record_free(sd->record);
 
 	if (sd->play)
 		play_free(sd->play);
diff -rNu melys-0.0.4/song/song.m melys-0.0.5/song/song.m
--- melys-0.0.4/song/song.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/song/song.m	Mon Aug  9 00:05:59 1999
@@ -0,0 +1,301 @@
+>>name song.m - Functions to deal with a complete song midi/audio
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+>>extern
+
+>>header gtk/gtkwidget.h
+>>header elements.h
+>>header md.h
+>>header melmidi.h
+>>header melreg.h
+>>header format.h
+
+>>header <stdio.h>
+>>header mdrw.h
+
+>>headerdef --decl song.h
+
+/*
+ * Properties for the parent MDI
+ */
+#define MEL_MDI_CHILD_COUNT "MDI_CHILD_COUNT"
+
+/*
+ * The following are properties that can be set on the mdi child
+ */
+#define MEL_SONG_DATA    "SONG_DATA"
+#define MEL_NEW_VIEW     "NEW_VIEW"
+
+
+/*
+ * A structure that contains all the information that is particular to
+ * a song.  It is placed as a property on the MDI child.
+ */
+struct song {
+	struct rootElement *mdroot; /* MD root */
+	char   *filename;	/* File that this song is associated with */
+
+	GtkObject	*mdi;	/* Back pointer to the parent MDI */
+	GtkObject	*child;	/* Back pointer to the MDI child */
+
+	int  open_dialog;	/* Open dialog box */
+	int  save_dialog;	/* Save dialog box */
+	int  dialog;		/* Set if a dialog is in action */
+
+	struct play *play;  /* Play data */
+	//struct play *echo;	/* Midi echo data */
+	struct record *record; /* Record data */
+
+
+	/* Somewhat temporary recording of track */
+	struct trackElement *newtrack; /* Track being recorded */
+	int  tracknum;		/* The output dev/channel */
+};
+
+>>header melgui.h
+
+>>function song_open_file
+void
+struct song *song;
+char *filename;
+
+>>description
+Open the file specified by
+.A filename
+and read it into the song structure as an MD tree.
+If filename is NULL, then an empty new song is created.
+
+>>code
+	struct rootElement *root;
+	char *errmsg;
+
+	if (filename) {
+		root = file_guess_read_with_msg(filename, &errmsg);
+	} else {
+		root = md_empty();
+		filename = "";
+	}
+
+	if (root == NULL) {
+		char *msg;
+
+		if (errmsg == NULL)
+			errmsg = "";
+
+		msg = g_strdup_printf(_("Could not read file %s\n" "%s\n"),
+			g_basename(filename), errmsg);
+		mel_ui_error(song, msg, NULL);
+
+		g_free(msg);
+		return;
+	}
+
+	song->mdroot = root;
+	play_set_mdroot(song->play, root);
+	record_set_mdroot(song->record, root);
+
+	play_set_ports(song->play);
+	record_set_ports(song->record);
+
+	song->newtrack = md_track_new();
+	song->tracknum = MD_CONTAINER(root)->elements->len - 2; /* xxx temp */
+
+
+>>function song_set_echo
+void
+>>description
+Set up the midi echo to reflect the currently selected track.
+If the current track is associated with channel 6 on logical
+device 2, for example,
+then midi events must be echoed there.
+XXX shouldn't be here
+
+>>function song_reset_echo
+void
+>>description
+Disable the midi echo.
+This is usually done before switching to another track.
+XXX shouldn't be here
+
+>>function song_play_start
+void
+struct song *song;
+>>description
+Start up audio and midi streams to start playing.
+>>code
+
+	play_start(song->play);
+
+
+>>function song_play_pause
+void
+struct song *song;
+>>description
+Pause the audio and midi streams.
+The next play will resume playing from the same point.
+>>code
+
+	play_pause(song->play);
+
+
+>>function song_play_stop
+void
+struct song *song;
+>>description
+Stop and rewind the audio and midi streams.
+Also stop recording if recording is active.
+The next play will start playing from the beginning.
+>>code
+
+	record_stop(song->record);
+
+	play_set_record(song->play, 0);
+	play_stop(song->play);
+
+	/*
+	 * This is all temporary.  If events have been recorded on the
+	 * newtrack then add the track to the song.
+	 */
+	if (MD_CONTAINER(song->newtrack)->elements->len) {
+		g_message("adding the new track");
+		md_add(MD_CONTAINER(song->mdroot), MD_ELEMENT(song->newtrack));
+
+		song->newtrack = md_track_new();
+		song->tracknum++;
+	}
+
+
+>>function song_record_start
+void
+struct song *song;
+>>description
+Start recording.
+This may be called while already playing, 
+or while not playing, in which case playing must be started
+as well.
+
+>>code
+
+	/* Depends on what kind of track we have selected audio/midi */
+	/* Only midi exists at present... */
+	play_set_record(song->play, 1);
+	play_start(song->play);
+
+	record_set_track(song->record, song->newtrack, song->tracknum);
+	record_start(song->record);
+
+
+>>function song_record_stop
+void
+struct song *song;
+
+>>description
+Stop recording only.
+If the song is playing (as it will be if not
+ended) then it will carry on playing.
+
+>>code
+
+	record_stop(song->record);
+	play_set_record(song->play, 0);
+
+
+>>function song_get_data
+struct song *
+GtkObject *child;	Child to get data from
+>>description
+Get the child info data from the specified child.
+If it does not exist then this is an error, you are meant
+to access it from the parent mdi first.
+>>code
+	struct song *sd;
+
+	sd = gtk_object_get_data(child, MEL_SONG_DATA);
+	if (sd == NULL)
+		ethrow(debugError, "No child data in @func_name");
+
+	return sd;
+
+
+>>function song_new
+struct song *
+GtkObject *mdi;	The parent MDI
+GtkObject *child;	Child on which to create the data
+
+>>description
+Create and initialise the child data.
+The newly created data is returned.
+
+>>code
+	struct song *sd;
+
+	sd = g_new0(struct song, 1);
+	sd->mdi = mdi;
+	sd->child = child;
+	sd->filename = NULL;
+	sd->mdroot   = NULL;
+	sd->open_dialog = 0;
+	sd->save_dialog = 0;
+	sd->dialog = 0;
+	sd->play = play_new();
+	//sd->echo = play_new();
+	sd->record = record_new(play_get_context(sd->play));
+
+	gtk_object_set_data_full(GTK_OBJECT(child), MEL_SONG_DATA,
+		sd, song_destroy);
+
+	return sd;
+
+
+>>function song_destroy
+void
+gpointer data;
+
+>>description
+Destroy the child data structure and any resourse allocated off it.
+This will be called automatically when the child is destroyed.
+
+>>code
+	struct song *sd;
+	GtkWidget *w;
+
+	dprintf1("@func_name");
+
+	sd = data;
+
+	/* Destroy all resources */
+	if (sd->mdroot) {
+		md_free(MD_ELEMENT(sd->mdroot));
+		sd->mdroot = NULL;
+	}
+
+	if (sd->open_dialog) {
+		w = reg_get_widget(sd->open_dialog);
+		if (w)
+			gtk_widget_destroy(w);
+	}
+	if (sd->save_dialog) {
+		w = reg_get_widget(sd->save_dialog);
+		if (w)
+			gtk_widget_destroy(w);
+	}
+
+	/* Record (and any other subcontext) must be freed first */
+	if (sd->record)
+		record_free(sd->record);
+
+	if (sd->play)
+		play_free(sd->play);
+
+	/* Free the data itself */
+	g_free(sd);
+
diff -rNu melys-0.0.4/util/.cvsignore melys-0.0.5/util/.cvsignore
--- melys-0.0.4/util/.cvsignore	Fri Jul 30 00:43:12 1999
+++ melys-0.0.5/util/.cvsignore	Mon Aug  9 00:51:27 1999
@@ -1,6 +1,5 @@
 except.c
 util.c
 Makefile
-*.mdml
-*.mid
+*.mdml *.mdml.gz *.mid
 .cvsignore
diff -rNu melys-0.0.4/util/except.m melys-0.0.5/util/except.m
--- melys-0.0.4/util/except.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/util/except.m	Mon Jul 19 22:06:19 1999
@@ -0,0 +1,66 @@
+>>name except.m
+
+except.m - XXX
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+>>extern
+>>header <stdarg.h>
+>>header stdio.h
+
+>>headerdef --decls except.h
+
+#include <setjmp.h>
+
+struct except {
+	int  set;
+	sigjmp_buf  buf;
+};
+
+extern struct except *formatError;	/* Bad file format */
+extern struct except *ioError;	/* Error reading/writing file */
+extern struct except *valueError;	/* Value error */
+extern struct except *debugError;	/* Debugging 'shouldn't happen' errors */
+
+>>extern
+
+static struct except format;
+static struct except io;
+static struct except value;
+static struct except debug;
+
+struct except *formatError = &format;	/* Bad file format */
+struct except *ioError = &io;	/* I/o error to file */
+struct except *valueError = &value;	/* Value type error */
+struct except *debugError = &debug;	/* Debugging 'shouldn't happen' errors */
+
+>>function ethrow
+void
+struct except *e;	// Exception thrown
+char *message;	// Reason message 
+...	// Takes variable number of arguments
+
+>>description
+Deal with errors.
+At present just exit, will allow error recovery in the future.
+>>code
+	va_list ap;
+
+	va_start(ap, message);
+	vfprintf(stderr, message, ap);
+	va_end(ap);
+	putc('\n', stderr);
+
+#ifdef DEBUG
+	g_on_error_stack_trace("a.out");
+#endif
+	exit(1);
diff -rNu melys-0.0.4/util/util.c melys-0.0.5/util/util.c
--- melys-0.0.4/util/util.c	Fri Jul 30 00:43:19 1999
+++ melys-0.0.5/util/util.c	Mon Aug  9 00:51:35 1999
@@ -19,7 +19,40 @@
 #include "glib.h"
 #include "except.h"
 #include "util.h"
+#include <stdio.h>
+#include <stdarg.h>
 #include "intl.h"
 
 
+#ifdef DEBUG
 
+int  DBlevel = 0;
+
+#endif
+
+
+/*
+ * A routine for conditionally printing out debugging
+ * information. If the level argument is greater than or equal
+ * to the debugging level, the message will be printed.
+ * 
+ *  Arguments:
+ *    level     - Debuging level to print at
+ *    fmt       - Printf format
+ */
+void 
+mel_debug_printf(int level, char *fmt, ...)
+{
+#ifdef DEBUG
+	va_list args;
+
+	if (DBlevel < level)
+		return;
+
+	fprintf(stderr, "DEBUG %d: ", level);
+	va_start (args, fmt);
+	vfprintf(stderr, fmt, args);
+	va_end (args);
+	fprintf(stderr, "\n");
+#endif
+}
diff -rNu melys-0.0.4/util/util.m melys-0.0.5/util/util.m
--- melys-0.0.4/util/util.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/util/util.m	Mon Aug  9 00:34:19 1999
@@ -0,0 +1,135 @@
+>>name util.m Useful utility functions and macros
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+
+>>header <stdio.h>
+>>header <stdarg.h>
+>>headerdef --decl util.h
+
+/* Useful macros */
+
+/* The number of elements in an array */
+#define NELEM(a) ( sizeof(a)/ sizeof((a)[0]))
+
+/* End of an array for use in loops */
+#define ENDOF(a) ((a) + NELEM(a))
+
+#define DEBUG /* XXX */
+#ifdef DEBUG
+
+/*
+ * Debugging stuff.
+ */
+
+extern int  DBlevel;
+
+#ifdef	__GNUC__
+#define	dprintf(level, format, args...) mel_debug_printf(level, format, ##args)
+#define dprintf1(format, args...) mel_debug_printf(1, format, ##args)
+#define dprintf2(format, args...) mel_debug_printf(2, format, ##args)
+
+#else	/* !__GNUC__ */
+
+/* Sorry, this doesn't look too good */
+static void
+dprintf(int level, const gchar *format, ...)
+{
+  va_list args;
+  if (DBlevel < level)
+  	return;
+
+  va_start (args, format);
+  fvprintf(stderr, format, args);
+  va_end (args);
+  fprintf(stderr, "\n");
+}
+static void
+dprintf1(const gchar *format, ...)
+{
+  va_list args;
+  if (DBlevel < 1)
+  	return;
+
+  va_start (args, format);
+  fvprintf(stderr, format, args);
+  va_end (args);
+  fprintf(stderr, "\n");
+}
+static void
+dprintf2(const gchar *format, ...)
+{
+  va_list args;
+  if (DBlevel < 2)
+  	return;
+
+  va_start (args, format);
+  fvprintf(stderr, format, args);
+  va_end (args);
+  fprintf(stderr, "\n");
+}
+
+#endif
+
+#else /* !DEBUG */
+
+#ifdef	__GNUC__
+#define	dprintf(level, format, args...)
+#define dprintf1(format, args...)
+#define dprintf2(format, args...)
+
+#else	/* !__GNUC__ */
+
+/* NB: expression may still be evaluated */
+#define	dprintf  (void)
+#define dprintf1 (void)
+#define dprintf2 (void)
+
+#endif
+
+#endif /* DEBUG */
+
+
+>>extern
+
+#ifdef DEBUG
+
+int  DBlevel = 0;
+
+#endif
+
+>>function mel_debug_printf
+void
+int  level;   Debuging level to print at
+char *fmt;    Printf format
+...
+
+>>description
+A routine for conditionally printing out debugging information.
+If the
+.A level
+argument is greater than or equal to the debugging level, the message
+will be printed.
+
+>>code
+#ifdef DEBUG
+	va_list args;
+
+	if (DBlevel < level)
+		return;
+
+	fprintf(stderr, "DEBUG %d: ", level);
+	va_start (args, fmt);
+	vfprintf(stderr, fmt, args);
+	va_end (args);
+	fprintf(stderr, "\n");
+#endif
diff -rNu melys-0.0.4/widgets/.cvsignore melys-0.0.5/widgets/.cvsignore
--- melys-0.0.4/widgets/.cvsignore	Fri Jul 30 00:43:12 1999
+++ melys-0.0.5/widgets/.cvsignore	Mon Aug  9 00:51:28 1999
@@ -1,5 +1,8 @@
+melystrack.c
+melystrackdisplay.c
+melystrackinfo.c
+melystransport.c
 register.c
 Makefile
-*.mdml
-*.mid
+*.mdml *.mdml.gz *.mid
 .cvsignore
diff -rNu melys-0.0.4/widgets/Makefile melys-0.0.5/widgets/Makefile
--- melys-0.0.4/widgets/Makefile	Fri Jul 30 00:43:12 1999
+++ melys-0.0.5/widgets/Makefile	Mon Aug  9 00:51:28 1999
@@ -4,9 +4,21 @@
 include $(TOP)/make.conf
 
 TARGETS = 
-OBJS =	register.o
-GENCFILES = register.c
-GENHFILES = ../include/melreg.h
+OBJS =	melystrack.o \
+	melystrackdisplay.o \
+	melystrackinfo.o \
+	melystransport.o \
+	register.o
+GENCFILES = melystrack.c \
+	melystrackdisplay.c \
+	melystrackinfo.c \
+	melystransport.c \
+	register.c
+GENHFILES = ../include/melystrack.h \
+	../include/melystrackdisplay.h \
+	../include/melystrackinfo.h \
+	../include/melystransport.h \
+	../include/melreg.h
 
 
 
diff -rNu melys-0.0.4/widgets/melystrack.c melys-0.0.5/widgets/melystrack.c
--- melys-0.0.4/widgets/melystrack.c	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/widgets/melystrack.c	Mon Aug  9 00:51:35 1999
@@ -0,0 +1,237 @@
+/*
+ * 
+ * Copyright (C) 1999 Steve Ratcliffe
+ * 
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ * 
+ *  This program 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 General Public License for more details.
+ * 
+ * 
+ * 
+ */
+
+
+#include "glib.h"
+#include "except.h"
+#include "util.h"
+#include "gtk/gtk.h"
+#include "elements.h"
+#include "melystrackinfo.h"
+#include "melystrackdisplay.h"
+#include "melystrack.h"
+#include "intl.h"
+
+enum {
+	// XXX symbols for all signals here
+	LAST_SIGNAL
+};
+static void melys_track_init(MelysTrack *mtp);
+static void melys_track_class_init(MelysTrackClass *klass);
+static void destroy(GtkObject *object);
+
+
+static gint melys_track_signals[LAST_SIGNAL];
+
+static GtkVBoxClass *parent_class = NULL;
+
+/*
+ * Return a unique integer that represents the object type.
+ */
+guint 
+melys_track_get_type(void)
+{
+	static guint mtype = 0;
+
+	if (!mtype) {
+		GtkTypeInfo minfo = {
+			"MelysTrack",
+			sizeof(MelysTrack),
+			sizeof(MelysTrackClass),
+			(GtkClassInitFunc) melys_track_class_init,
+			(GtkObjectInitFunc) melys_track_init,
+			(GtkArgSetFunc) NULL,
+			(GtkArgGetFunc) NULL,
+			(GtkClassInitFunc) NULL,
+		};
+
+		mtype = gtk_type_unique(gtk_vbox_get_type(), &minfo);
+	}
+
+	return mtype;
+}
+
+/*
+ * Create a new MelysTrack object.
+ *  Arguments:
+ *    root      - Root for view
+ */
+GtkWidget *
+melys_track_new(struct rootElement *root)
+{
+	GtkWidget *mtrack = GTK_WIDGET(gtk_type_new(melys_track_get_type()));
+
+	melys_track_set_md_root((MelysTrack *)mtrack, root);
+
+	return mtrack;
+}
+
+/*
+ * Initialise the MelysTrack.
+ *  Arguments:
+ *    mtp       - The MelysTrack to init
+ */
+static void 
+melys_track_init(MelysTrack *mtp)
+{
+	GtkAdjustment *hadj;
+	GtkAdjustment *vadj;
+	GtkHScrollbar *hscroll;
+	GtkVScrollbar *vscroll;
+	GtkHPaned *hpan;
+	GtkTable *tab;
+	MelysTrackInfo *info;
+	MelysTrackDisplay *disp;
+
+	tab = (GtkTable*)gtk_table_new(4, 4, FALSE);
+
+	gtk_container_add(GTK_CONTAINER(mtp), GTK_WIDGET(tab));
+
+	hadj = (GtkAdjustment*)gtk_adjustment_new(0.0,
+		0.0, 256.0,
+		1.0, 16.0,
+		32.0
+		);
+	vadj = (GtkAdjustment*)gtk_adjustment_new(0.0,
+		0.0, 256.0,
+		1.0, 16.0,
+		32.0
+		);
+
+	hscroll = (GtkHScrollbar*)gtk_hscrollbar_new(hadj);
+	vscroll = (GtkVScrollbar*)gtk_vscrollbar_new(vadj);
+
+	info = (MelysTrackInfo*)melys_track_info_new(vadj);
+	disp = (MelysTrackDisplay*)melys_track_display_new();
+	hpan = (GtkHPaned*)gtk_hpaned_new();
+	gtk_paned_add1(GTK_PANED(hpan), GTK_WIDGET(info));
+	gtk_paned_add2(GTK_PANED(hpan), GTK_WIDGET(disp));
+	gtk_widget_show(GTK_WIDGET(info));
+	gtk_widget_show(GTK_WIDGET(disp));
+
+	gtk_table_attach(tab, GTK_WIDGET(hpan), 0, 1, 0, 1,
+		GTK_FILL|GTK_SHRINK|GTK_EXPAND,
+		GTK_FILL|GTK_SHRINK|GTK_EXPAND,
+		0, 0
+		);
+
+	gtk_table_attach(tab, GTK_WIDGET(vscroll), 1, 2, 0, 1,
+		0,
+		GTK_FILL|GTK_SHRINK|GTK_EXPAND,
+		0, 0
+		);
+	gtk_table_attach(tab, GTK_WIDGET(hscroll), 0, 1, 1, 2,
+		GTK_FILL|GTK_SHRINK|GTK_EXPAND,
+		0,
+		0, 0
+		);
+
+	gtk_widget_show(GTK_WIDGET(hscroll));
+	gtk_widget_show(GTK_WIDGET(vscroll));
+	gtk_widget_show(GTK_WIDGET(hpan));
+	gtk_widget_show(GTK_WIDGET(tab));
+
+	mtp->vadj = vadj;
+	mtp->hadj = hadj;
+	gtk_object_ref((GtkObject*)vadj);
+	gtk_object_ref((GtkObject*)hadj);
+
+	mtp->info = info;
+	mtp->display = disp;
+}
+
+/*
+ * Initialize the class.
+ * 
+ *  Arguments:
+ *    klass     - The class to initialise
+ */
+static void 
+melys_track_class_init(MelysTrackClass *klass)
+{
+	GtkObjectClass *object_class;
+	GtkVBoxClass *vbox_class;
+	MelysTrackClass *mtrack_class;
+
+	object_class = (GtkObjectClass *)klass;
+	vbox_class = (GtkVBoxClass *)klass;
+	mtrack_class = (MelysTrackClass *)klass; 
+
+	parent_class = gtk_type_class(gtk_vbox_get_type());
+
+	// XXX Add args
+
+	// XXX Create signals
+
+	gtk_object_class_add_signals(object_class, melys_track_signals, LAST_SIGNAL);
+
+	// XXX all the overrides come here
+	object_class->destroy = destroy;
+
+	// XXX Our functions
+}
+
+/*
+ * Set the root for this track view.
+ * 
+ */
+void 
+melys_track_set_md_root(MelysTrack *mtrack, struct rootElement *root)
+{
+
+	dprintf1("melys_track_set_md_root: Setting mdroot %p", root);
+	if (root == NULL)
+		return;
+
+	root->refcount++;
+	mtrack->mdroot = root;
+
+	melys_track_info_set_md_root(mtrack->info, root);
+	//melys_track_display_set_md_root(mtrack->info, root);
+}
+
+/*
+ * Destroy the MelysTrack and all its resourses.
+ * 
+ *  Arguments:
+ *    object    - The Melys track object to be destroyed
+ */
+static void 
+destroy(GtkObject *object)
+{
+	MelysTrack *mtp;
+
+	g_return_if_fail(object != NULL);
+	g_return_if_fail(IS_MELYS_TRACK(object));
+
+	mtp = MELYS_TRACK(object);
+
+	if (mtp->mdroot)
+		md_free(MD_ELEMENT(mtp->mdroot));
+
+	if (mtp->vadj) {
+		gtk_object_unref(GTK_OBJECT(mtp->vadj));
+		mtp->vadj = NULL;
+	}
+	if (mtp->hadj) {
+		gtk_object_unref(GTK_OBJECT(mtp->hadj));
+		mtp->hadj = NULL;
+	}
+
+	if (GTK_OBJECT_CLASS(parent_class)->destroy)
+		(GTK_OBJECT_CLASS(parent_class)->destroy)(object);
+}
diff -rNu melys-0.0.4/widgets/melystrack.m melys-0.0.5/widgets/melystrack.m
--- melys-0.0.4/widgets/melystrack.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/widgets/melystrack.m	Mon Aug  9 00:05:59 1999
@@ -0,0 +1,219 @@
+>>name melystrack.m - Track view widget
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+>>header gtk/gtk.h
+>>header elements.h
+>>header melystrackinfo.h
+>>header melystrackdisplay.h
+
+>># Base on a vertical packing box.
+>># This allows stuff to be put allong the top.
+>>gtkobject melys_track MelysTrack gtk_vbox GtkVBox
+
+>>headerdef @header
+
+struct _MelysTrack {
+	GtkVBox vbox;
+
+	GtkAdjustment *vadj;
+	GtkAdjustment *hadj;
+
+	MelysTrackInfo *info;
+	MelysTrackDisplay *display;
+
+	struct rootElement *mdroot;
+};
+
+struct _MelysTrackClass {
+	GtkVBoxClass parent_class;
+	// XXX class definition here
+};
+
+/*
+ * Definitions that are shared between the two panes
+ */
+#define TRACK_DEF_HEIGHT    16
+#define TRACK_SEPARATION     2
+#define TRACK_TITLE_HEIGHT  20
+
+
+>>extern
+enum {
+	// XXX symbols for all signals here
+	LAST_SIGNAL
+};
+
+>>function melys_track_new
+GtkWidget *
+struct rootElement *root;  Root for view
+
+>>description
+Create a new MelysTrack object.
+>>code
+	GtkWidget *mtrack = GTK_WIDGET(gtk_type_new(melys_track_get_type()));
+
+	melys_track_set_md_root((MelysTrack *)mtrack, root);
+
+	return mtrack;
+
+>>function melys_track_init
+static void
+MelysTrack *mtp;   The MelysTrack to init
+>>description
+Initialise the MelysTrack.
+>>code
+	GtkAdjustment *hadj;
+	GtkAdjustment *vadj;
+	GtkHScrollbar *hscroll;
+	GtkVScrollbar *vscroll;
+	GtkHPaned *hpan;
+	GtkTable *tab;
+	MelysTrackInfo *info;
+	MelysTrackDisplay *disp;
+
+	tab = (GtkTable*)gtk_table_new(4, 4, FALSE);
+
+	gtk_container_add(GTK_CONTAINER(mtp), GTK_WIDGET(tab));
+
+	hadj = (GtkAdjustment*)gtk_adjustment_new(0.0,
+		0.0, 256.0,
+		1.0, 16.0,
+		32.0
+		);
+	vadj = (GtkAdjustment*)gtk_adjustment_new(0.0,
+		0.0, 256.0,
+		1.0, 16.0,
+		32.0
+		);
+
+	hscroll = (GtkHScrollbar*)gtk_hscrollbar_new(hadj);
+	vscroll = (GtkVScrollbar*)gtk_vscrollbar_new(vadj);
+
+	info = (MelysTrackInfo*)melys_track_info_new(vadj);
+	disp = (MelysTrackDisplay*)melys_track_display_new();
+	hpan = (GtkHPaned*)gtk_hpaned_new();
+	gtk_paned_add1(GTK_PANED(hpan), GTK_WIDGET(info));
+	gtk_paned_add2(GTK_PANED(hpan), GTK_WIDGET(disp));
+	gtk_widget_show(GTK_WIDGET(info));
+	gtk_widget_show(GTK_WIDGET(disp));
+
+	gtk_table_attach(tab, GTK_WIDGET(hpan), 0, 1, 0, 1,
+		GTK_FILL|GTK_SHRINK|GTK_EXPAND,
+		GTK_FILL|GTK_SHRINK|GTK_EXPAND,
+		0, 0
+		);
+
+	gtk_table_attach(tab, GTK_WIDGET(vscroll), 1, 2, 0, 1,
+		0,
+		GTK_FILL|GTK_SHRINK|GTK_EXPAND,
+		0, 0
+		);
+	gtk_table_attach(tab, GTK_WIDGET(hscroll), 0, 1, 1, 2,
+		GTK_FILL|GTK_SHRINK|GTK_EXPAND,
+		0,
+		0, 0
+		);
+
+	gtk_widget_show(GTK_WIDGET(hscroll));
+	gtk_widget_show(GTK_WIDGET(vscroll));
+	gtk_widget_show(GTK_WIDGET(hpan));
+	gtk_widget_show(GTK_WIDGET(tab));
+
+	mtp->vadj = vadj;
+	mtp->hadj = hadj;
+	gtk_object_ref((GtkObject*)vadj);
+	gtk_object_ref((GtkObject*)hadj);
+
+	mtp->info = info;
+	mtp->display = disp;
+
+>>function melys_track_class_init
+static void
+MelysTrackClass *klass;   The class to initialise
+
+>>description
+Initialize the class.
+
+>>code
+	GtkObjectClass *object_class;
+	GtkVBoxClass *vbox_class;
+	MelysTrackClass *mtrack_class;
+
+	object_class = (GtkObjectClass *)klass;
+	vbox_class = (GtkVBoxClass *)klass;
+	mtrack_class = (MelysTrackClass *)klass; 
+
+	parent_class = gtk_type_class(gtk_vbox_get_type());
+
+	// XXX Add args
+
+	// XXX Create signals
+
+	gtk_object_class_add_signals(object_class, melys_track_signals, LAST_SIGNAL);
+
+	// XXX all the overrides come here
+	object_class->destroy = destroy;
+
+	// XXX Our functions
+
+
+>>function melys_track_set_md_root
+void
+MelysTrack *mtrack;
+struct rootElement *root;
+
+>>description
+Set the root for this track view.
+
+>>code
+
+	dprintf1("@func_name: Setting mdroot %p", root);
+	if (root == NULL)
+		return;
+
+	root->refcount++;
+	mtrack->mdroot = root;
+
+	melys_track_info_set_md_root(mtrack->info, root);
+	//melys_track_display_set_md_root(mtrack->info, root);
+
+>>function destroy
+static void
+GtkObject *object;  The Melys track object to be destroyed
+>>description
+Destroy the MelysTrack and all its resourses.
+
+>>code
+	MelysTrack *mtp;
+
+	g_return_if_fail(object != NULL);
+	g_return_if_fail(IS_MELYS_TRACK(object));
+
+	mtp = MELYS_TRACK(object);
+
+	if (mtp->mdroot)
+		md_free(MD_ELEMENT(mtp->mdroot));
+
+	if (mtp->vadj) {
+		gtk_object_unref(GTK_OBJECT(mtp->vadj));
+		mtp->vadj = NULL;
+	}
+	if (mtp->hadj) {
+		gtk_object_unref(GTK_OBJECT(mtp->hadj));
+		mtp->hadj = NULL;
+	}
+
+	if (GTK_OBJECT_CLASS(parent_class)->destroy)
+		(GTK_OBJECT_CLASS(parent_class)->destroy)(object);
+
+
diff -rNu melys-0.0.4/widgets/melystrackdisplay.c melys-0.0.5/widgets/melystrackdisplay.c
--- melys-0.0.4/widgets/melystrackdisplay.c	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/widgets/melystrackdisplay.c	Mon Aug  9 00:51:35 1999
@@ -0,0 +1,113 @@
+/*
+ * 
+ * Copyright (C) 1999 Steve Ratcliffe
+ * 
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ * 
+ *  This program 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 General Public License for more details.
+ * 
+ * 
+ */
+
+
+#include "glib.h"
+#include "except.h"
+#include "util.h"
+#include "gtk/gtkvbox.h"
+#include "melystrackdisplay.h"
+#include "intl.h"
+
+enum {
+	// XXX symbols for all signals here
+	LAST_SIGNAL
+};
+static void melys_track_display_init(MelysTrackDisplay *XXX);
+static void melys_track_display_class_init(MelysTrackDisplayClass *klass);
+
+
+static gint melys_track_display_signals[LAST_SIGNAL];
+
+static GtkVBoxClass *parent_class = NULL;
+
+/*
+ * Return a unique integer that represents the object type.
+ */
+guint 
+melys_track_display_get_type(void)
+{
+	static guint mtype = 0;
+
+	if (!mtype) {
+		GtkTypeInfo minfo = {
+			"MelysTrackDisplay",
+			sizeof(MelysTrackDisplay),
+			sizeof(MelysTrackDisplayClass),
+			(GtkClassInitFunc) melys_track_display_class_init,
+			(GtkObjectInitFunc) melys_track_display_init,
+			(GtkArgSetFunc) NULL,
+			(GtkArgGetFunc) NULL,
+			(GtkClassInitFunc) NULL,
+		};
+
+		mtype = gtk_type_unique(gtk_vbox_get_type(), &minfo);
+	}
+
+	return mtype;
+}
+
+/*
+ * Create a new MelysTrackDisplay object.
+ */
+GtkWidget *
+melys_track_display_new(void)
+{
+	GtkWidget *XXX = GTK_WIDGET(gtk_type_new(melys_track_display_get_type()));
+
+	// XXX Fill in here or replace previous line
+
+	return XXX;
+}
+
+/*
+ * Initialise the MelysTrackDisplay.
+ *  Arguments:
+ *    XXX       - The MelysTrackDisplay to init
+ */
+static void 
+melys_track_display_init(MelysTrackDisplay *XXX)
+{
+	// XXX add any children etc.
+}
+
+/*
+ * Initialize the class.
+ * 
+ *  Arguments:
+ *    klass     - The class to initialise
+ */
+static void 
+melys_track_display_class_init(MelysTrackDisplayClass *klass)
+{
+	GtkObjectClass *object_class;
+	GtkVBoxClass *vbox_class;
+
+	object_class = (GtkObjectClass *)klass;
+	vbox_class = (GtkVBoxClass *)klass;
+
+	parent_class = gtk_type_class(gtk_vbox_get_type());
+
+	// XXX Add args
+
+	// XXX Create signals
+
+	gtk_object_class_add_signals(object_class, melys_track_display_signals, LAST_SIGNAL);
+
+	// XXX all the overrides come here
+
+	// XXX Our functions
+}
diff -rNu melys-0.0.4/widgets/melystrackdisplay.m melys-0.0.5/widgets/melystrackdisplay.m
--- melys-0.0.4/widgets/melystrackdisplay.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/widgets/melystrackdisplay.m	Fri Aug  6 11:58:37 1999
@@ -0,0 +1,81 @@
+>>name melystrackdisplay.m - XXX
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+>>header gtk/gtkvbox.h
+>>gtkobject melys_track_display MelysTrackDisplay gtk_vbox GtkVBox
+
+>>headerdef @header
+
+struct _MelysTrackDisplay {
+	GtkVBox vbox;
+	// XXX object definition here
+};
+
+struct _MelysTrackDisplayClass {
+	GtkVBoxClass parent_class;
+	// XXX class definition here
+};
+
+>>extern
+enum {
+	// XXX symbols for all signals here
+	LAST_SIGNAL
+};
+
+>>function melys_track_display_new
+GtkWidget *
+>>description
+Create a new MelysTrackDisplay object.
+>>code
+	GtkWidget *XXX = GTK_WIDGET(gtk_type_new(melys_track_display_get_type()));
+
+	// XXX Fill in here or replace previous line
+
+	return XXX;
+
+>>function melys_track_display_init
+static void
+MelysTrackDisplay *XXX;   The MelysTrackDisplay to init
+>>description
+Initialise the MelysTrackDisplay.
+>>code
+	// XXX add any children etc.
+
+
+>>function melys_track_display_class_init
+static void
+MelysTrackDisplayClass *klass;   The class to initialise
+
+>>description
+Initialize the class.
+
+>>code
+	GtkObjectClass *object_class;
+	GtkVBoxClass *vbox_class;
+
+	object_class = (GtkObjectClass *)klass;
+	vbox_class = (GtkVBoxClass *)klass;
+
+	parent_class = gtk_type_class(gtk_vbox_get_type());
+
+	// XXX Add args
+
+	// XXX Create signals
+
+	gtk_object_class_add_signals(object_class, melys_track_display_signals, LAST_SIGNAL);
+
+	// XXX all the overrides come here
+
+	// XXX Our functions
+
+
diff -rNu melys-0.0.4/widgets/melystrackinfo.c melys-0.0.5/widgets/melystrackinfo.c
--- melys-0.0.4/widgets/melystrackinfo.c	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/widgets/melystrackinfo.c	Mon Aug  9 00:51:36 1999
@@ -0,0 +1,627 @@
+/*
+ * 
+ * Copyright (C) 1999 Steve Ratcliffe
+ * 
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ * 
+ *  This program 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 General Public License for more details.
+ * 
+ * 
+ */
+
+
+#include "glib.h"
+#include "except.h"
+#include "util.h"
+#include "gtk/gtk.h"
+#include "elements.h"
+#include "md.h"
+#include "melystrackinfo.h"
+#include "melystrackdisplay.h"
+#include "melystrack.h"
+#include "intl.h"
+
+
+enum {
+	// XXX symbols for all signals here
+	LAST_SIGNAL
+};
+
+enum column_type {
+	NUMBER,
+	NAME,
+	PROGRAM,
+	PATCH,
+	//MUTE,
+	//SOLO,
+	//RECORD,
+	LAST_COLUMN_TYPE
+};
+
+static struct col_info {
+	enum column_type type;
+	char *title;
+	int  width;
+	gboolean present;
+} def_col_info[] = {
+	{NUMBER, "", 20, TRUE},
+	{NAME, "Name", 100, TRUE},
+	{PROGRAM, "Prog", 60, TRUE},
+	{PATCH, "Patch", 200, FALSE},
+};
+
+/* A border to the protect the column lines */
+#define BORDER 2
+
+#define COL_PADDING  2
+
+/* Padding to avoid overwriting the pan handle (gtk bug?) */
+#define PAN_PADDING 2
+
+
+#define TMP_BUF_SIZE  100
+static void melys_track_info_init(MelysTrackInfo *minfo);
+static void melys_track_info_class_init(MelysTrackInfoClass *klass);
+static void track_info_realise(GtkWidget *widget);
+static void track_info_unrealise(GtkWidget *widget);
+static void track_info_destroy(GtkObject *object);
+static void track_info_size_request(GtkWidget *widget, GtkRequisition *req);
+static void track_info_size_allocate(GtkWidget *widget, 
+        GtkAllocation *allocation);
+static void track_info_draw(GtkWidget *widget, GdkRectangle *area);
+static int track_info_expose(GtkWidget *widget, GdkEventExpose *event);
+static int track_to_y(MelysTrackInfo *minfo, int n);
+
+
+static gint melys_track_info_signals[LAST_SIGNAL];
+
+static GtkWidgetClass *parent_class = NULL;
+
+/*
+ * Return a unique integer that represents the object type.
+ */
+guint 
+melys_track_info_get_type(void)
+{
+	static guint mtype = 0;
+
+	if (!mtype) {
+		GtkTypeInfo minfo = {
+			"MelysTrackInfo",
+			sizeof(MelysTrackInfo),
+			sizeof(MelysTrackInfoClass),
+			(GtkClassInitFunc) melys_track_info_class_init,
+			(GtkObjectInitFunc) melys_track_info_init,
+			(GtkArgSetFunc) NULL,
+			(GtkArgGetFunc) NULL,
+			(GtkClassInitFunc) NULL,
+		};
+
+		mtype = gtk_type_unique(gtk_widget_get_type(), &minfo);
+	}
+
+	return mtype;
+}
+
+/*
+ * Create a new MelysTrackInfo object.
+ *  Arguments:
+ *    vadj      - Vertical adjustment
+ */
+GtkWidget *
+melys_track_info_new(GtkAdjustment *vadj)
+{
+	GtkWidget *w = GTK_WIDGET(gtk_type_new(melys_track_info_get_type()));
+	MelysTrackInfo *minfo;
+
+	minfo = (MelysTrackInfo*)w;
+
+	minfo->vadj = vadj;
+	gtk_object_ref((GtkObject*)vadj);
+	// XXX? gtk_object_sink((GtkObject*)vadj);
+
+	return w;
+}
+
+/*
+ * Initialise the MelysTrackInfo.
+ *  Arguments:
+ *    minfo     - The MelysTrackInfo to init
+ */
+static void 
+melys_track_info_init(MelysTrackInfo *minfo)
+{
+	int  i;
+	int  used;
+	struct col_info *cinfo;
+
+	minfo->vadj = NULL;
+	minfo->title_window = NULL;
+
+	used = 0;
+	minfo->col_infos = g_new0(struct col_info, MAX_COLUMNS);
+
+	for (i = 0; i < NELEM(def_col_info); i++) {
+		cinfo = def_col_info+i;
+
+		if (cinfo->present) {
+
+			minfo->col_infos[used] = *cinfo;
+			used++;
+		}
+	}
+
+	minfo->col_used = used;
+
+	minfo->height = TRACK_DEF_HEIGHT;
+	minfo->vspace = TRACK_DEF_HEIGHT + TRACK_SEPARATION;
+
+	minfo->htitle = TRACK_TITLE_HEIGHT;
+	minfo->vtitle = TRACK_TITLE_HEIGHT + 2*TRACK_SEPARATION;
+
+	minfo->mdroot = NULL;
+		
+}
+
+/*
+ * Initialize the class.
+ * 
+ *  Arguments:
+ *    klass     - The class to initialise
+ */
+static void 
+melys_track_info_class_init(MelysTrackInfoClass *klass)
+{
+	GtkObjectClass *object_class;
+	GtkWidgetClass *widget_class;
+
+	object_class = (GtkObjectClass *)klass;
+	widget_class = (GtkWidgetClass *)klass;
+
+	parent_class = gtk_type_class(gtk_widget_get_type());
+
+	// XXX Add args
+
+	// XXX Create signals
+
+	gtk_object_class_add_signals
+		(object_class, melys_track_info_signals, LAST_SIGNAL);
+
+	/* Set up all the overrides */
+	object_class->destroy = track_info_destroy;
+
+	widget_class->realize = track_info_realise;
+	widget_class->size_request = track_info_size_request;
+	widget_class->size_allocate = track_info_size_allocate;
+	widget_class->unrealize = track_info_unrealise;
+	widget_class->draw = track_info_draw;
+	widget_class->expose_event = track_info_expose;
+
+	// XXX Our functions
+}
+
+/*
+ * Set the height of the track and of the title. In addition
+ * there will be a separation distance. This function is
+ * called by MelysTrack.
+ *  Arguments:
+ *    height    - New track height
+ *    htitle    - The title height
+ */
+void 
+melys_track_info_set_height(MelysTrackInfo *minfo, int height, int htitle)
+{
+
+	minfo->height = height;
+	minfo->vspace = height + TRACK_SEPARATION;
+
+	minfo->htitle = htitle;
+	minfo->vtitle = htitle + TRACK_SEPARATION;
+
+	if (GTK_WIDGET_REALIZED(minfo)) {
+
+		/* This doesn't actually change at present, but would if
+		 * it were middle aligned for example
+		 */
+		minfo->vtextoffset = GTK_WIDGET(minfo)->style->font->ascent + 1.5;
+	}
+}
+
+/*
+ * Set a new mdroot, freeing any existing one. The widget is
+ * redrawn after this.
+ * 
+ */
+void 
+melys_track_info_set_md_root(MelysTrackInfo *minfo, struct rootElement *root)
+{
+
+	dprintf1("Setting mdroot %p", root);
+
+	if (root == NULL)
+		return;
+
+	if (minfo->mdroot)
+		md_free((struct element *)minfo->mdroot);
+
+	root->refcount++;
+	minfo->mdroot = root;
+
+	track_info_draw(GTK_WIDGET(minfo), &minfo->track_area);
+}
+
+/*
+ * Create the windows for this widget. The main window itself
+ * is not mapped, but any subwindows are shown.
+ * 
+ */
+static void 
+track_info_realise(GtkWidget *widget)
+{
+	MelysTrackInfo *minfo;
+	GdkWindowAttr attributes;
+	gint attributes_mask;
+
+	dprintf1("track_info_realise called");
+	g_return_if_fail (widget != NULL);
+	g_return_if_fail (IS_MELYS_TRACK_INFO(widget));
+
+	minfo = MELYS_TRACK_INFO(widget);
+
+	GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
+
+	attributes.window_type = GDK_WINDOW_CHILD;
+	attributes.x = widget->allocation.x;
+	attributes.y = widget->allocation.y;
+	attributes.width = widget->allocation.width;
+	attributes.height = widget->allocation.height;
+	attributes.wclass = GDK_INPUT_OUTPUT;
+	attributes.visual = gtk_widget_get_visual(widget);
+	attributes.colormap = gtk_widget_get_colormap(widget);
+	attributes.event_mask = gtk_widget_get_events(widget);
+	attributes.event_mask |= (GDK_EXPOSURE_MASK |
+		GDK_BUTTON_PRESS_MASK |
+		GDK_BUTTON_RELEASE_MASK
+		///* XXX not sure about keys */GDK_KEY_PRESS_MASK |
+		//GDK_KEY_RELEASE_MASK
+		);
+	attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+
+	/* main window */
+	widget->window = gdk_window_new(gtk_widget_get_parent_window(widget),
+		&attributes, attributes_mask);
+	gdk_window_set_user_data(widget->window, minfo);
+
+	widget->style = gtk_style_attach(widget->style, widget->window);
+	gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL);
+
+	/* The title window */
+	attributes.x = 0;
+	attributes.y = 0;
+	attributes.height = 12;
+	minfo->title_window = gdk_window_new(widget->window,
+		&attributes, attributes_mask);
+
+	gdk_window_set_user_data(minfo->title_window, minfo);
+
+	widget->style = gtk_style_attach(widget->style, minfo->title_window);
+	gtk_style_set_background(widget->style, minfo->title_window,
+		GTK_STATE_NORMAL);
+
+	gdk_window_show(minfo->title_window);
+
+	minfo->vtextoffset = GTK_WIDGET(minfo)->style->font->ascent + 1.5;
+}
+
+static void 
+track_info_unrealise(GtkWidget *widget)
+{
+
+	GTK_WIDGET_UNSET_FLAGS(widget, GTK_MAPPED);
+
+	dprintf2("track_info_unrealise: before");
+	if (GTK_WIDGET_CLASS(parent_class)->unrealize)
+		(GTK_WIDGET_CLASS(parent_class)->unrealize)(widget);
+	dprintf2("track_info_unrealise: after");
+}
+
+static void 
+track_info_destroy(GtkObject *object)
+{
+	MelysTrackInfo *minfo;
+
+	g_return_if_fail(IS_MELYS_TRACK_INFO(object));
+
+	minfo = (MelysTrackInfo*)object;
+
+	gdk_window_destroy(minfo->title_window);
+	minfo->title_window = NULL;
+
+	g_free(minfo->col_infos);
+
+	if (minfo->vadj) {
+		gtk_object_unref(GTK_OBJECT(minfo->vadj));
+		minfo->vadj = NULL;
+	}
+
+	if (minfo->mdroot) {
+		md_free(MD_ELEMENT(minfo->mdroot));
+		minfo->mdroot = NULL;
+	}
+
+	minfo->col_used = 0;
+
+	if (GTK_OBJECT_CLASS(parent_class)->destroy)
+		(GTK_OBJECT_CLASS(parent_class)->destroy)(object);
+}
+
+static void 
+track_info_size_request(GtkWidget *widget, GtkRequisition *req)
+{
+	MelysTrackInfo *minfo;
+	int  i;
+	int  tot;
+
+	g_return_if_fail(IS_MELYS_TRACK_INFO(widget));
+
+	minfo = (MelysTrackInfo*)widget;
+
+	req->width = 0;
+	req->height = 0;
+
+	tot = 0;
+	for (i = 0; i < minfo->col_used; i++) {
+		tot += minfo->col_infos[i].width;
+		tot += widget->style->klass->xthickness;
+	}
+
+	dprintf1("requested width %d", tot);
+	req->width = tot;
+}
+
+static void 
+track_info_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
+{
+	MelysTrackInfo *minfo;
+
+	g_return_if_fail(widget != NULL);
+	g_return_if_fail(IS_MELYS_TRACK_INFO(widget));
+	g_return_if_fail(allocation != NULL);
+
+	minfo = (MelysTrackInfo*)widget;
+	widget->allocation = *allocation;
+
+	dprintf1("track_info_size_allocate: alloced (%d, %d) %dx%d",
+		allocation->x, allocation->y, allocation->width, allocation->height);
+
+	if (GTK_WIDGET_REALIZED (widget)) {
+
+		minfo->track_area.x = allocation->x;
+		minfo->track_area.y = allocation->y + minfo->vtitle;
+		minfo->track_area.width = allocation->width - PAN_PADDING;
+		minfo->track_area.height = allocation->height;
+
+		gdk_window_move_resize(widget->window,
+			allocation->x, allocation->y,
+			allocation->width - PAN_PADDING, allocation->height);
+
+		gdk_window_move_resize(minfo->title_window,
+			0, 0, allocation->width, minfo->vtitle);
+	}
+}
+
+static void 
+track_info_draw(GtkWidget *widget, GdkRectangle *area)
+{
+	MelysTrackInfo *minfo;
+	GtkStyle *style;
+	GdkGC *fg_gc;
+	GdkRectangle clip_rectangle;
+	int  offset;
+	int  start, end;
+	int  i;
+	int  ntrack;
+
+	g_return_if_fail(widget != NULL);
+	g_return_if_fail(IS_MELYS_TRACK_INFO(widget));
+	g_return_if_fail(area != NULL);
+
+	if (!GTK_WIDGET_DRAWABLE (widget))
+		return;
+
+	style = widget->style;
+	fg_gc = widget->style->fg_gc[GTK_STATE_NORMAL];
+
+	minfo = (MelysTrackInfo*)widget;
+
+	dprintf(2, "track_info_draw: (%d, %d) %dx%d", area->x, area->y,
+		area->width, area->height);
+
+	gtk_draw_shadow(widget->style, widget->window,
+		GTK_STATE_NORMAL, GTK_SHADOW_IN,
+		0, 0,
+		minfo->track_area.width, minfo->track_area.height);
+
+	/* Have to draw in the title box as well, the bottom is not meant to draw*/
+	gtk_draw_shadow(widget->style, minfo->title_window,
+		GTK_STATE_NORMAL, GTK_SHADOW_IN,
+		0, 0,
+		minfo->track_area.width, minfo->vtitle + 10);
+
+	offset = COL_PADDING;
+	for (i = 0; i < minfo->col_used; i++) {
+
+		clip_rectangle.x = offset;
+		clip_rectangle.y = 0;
+		clip_rectangle.width = minfo->col_infos[i].width;
+		clip_rectangle.height = minfo->vtitle;
+
+		dprintf2("offset %d, name %s", offset, minfo->col_infos[i].title);
+
+		gdk_gc_set_clip_rectangle(fg_gc, &clip_rectangle);
+		gdk_draw_string(minfo->title_window, style->font,
+			fg_gc,
+			offset,
+			minfo->htitle - widget->style->font->descent - 1,
+			minfo->col_infos[i].title);
+		gdk_gc_set_clip_rectangle(fg_gc, NULL);
+
+		offset += minfo->col_infos[i].width + COL_PADDING;
+		gtk_draw_vline(widget->style, minfo->title_window, GTK_STATE_NORMAL,
+			0, minfo->vtitle, offset);
+
+		/* Do the main window while we are here */
+		gtk_draw_vline(widget->style, widget->window, GTK_STATE_ACTIVE,
+			area->y, area->height, offset);
+
+		offset += style->klass->xthickness + COL_PADDING;
+	}
+
+	gdk_draw_line(minfo->title_window, fg_gc,
+		0, minfo->htitle,
+		area->width, minfo->htitle);
+
+	start = y_to_track(minfo, area->y);
+	end   = y_to_track(minfo, area->y + area->height);
+	if (end > minfo->mdroot->tracks)
+		end = minfo->mdroot->tracks;
+
+	for (ntrack = start; ntrack < end+1; ntrack++) {
+		char *str;
+		struct col_info *col;
+
+		offset = COL_PADDING;
+		for (i = 0; i < minfo->col_used; i++) {
+
+			col = minfo->col_infos+i;
+
+			/* This clips the text to fit, don't care about the height */
+			clip_rectangle.x = offset;
+			clip_rectangle.y = minfo->track_area.y;
+			clip_rectangle.width = col->width;
+			clip_rectangle.height = minfo->track_area.height;
+
+			str = get_info_string(minfo, col->type, ntrack);
+			dprintf(3, "offset %d, string %s", offset, str);
+
+			/* Now draw it */
+			gdk_gc_set_clip_rectangle(fg_gc, &clip_rectangle);
+			gdk_draw_string(widget->window, style->font, fg_gc,
+				offset, track_to_y(minfo, ntrack), str);
+			gdk_gc_set_clip_rectangle(fg_gc, NULL);
+
+			offset += col->width + COL_PADDING;
+			offset += style->klass->xthickness + COL_PADDING;
+		}
+		
+	}
+}
+
+/*
+ * Handle expose events. We just call the draw routine with a
+ * suitable arg. This means that we always re-draw some lines
+ * even when not necessary. But so what.
+ * 
+ */
+static int 
+track_info_expose(GtkWidget *widget, GdkEventExpose *event)
+{
+	MelysTrackInfo *minfo;
+
+	if (!GTK_WIDGET_DRAWABLE (widget))
+		return FALSE;
+
+	minfo = MELYS_TRACK_INFO(widget);
+
+	track_info_draw(minfo, &event->area);
+
+	return FALSE; /* XXX what does this mean */
+}
+
+/*
+ * Given a y position within the widget window, return the
+ * track number that belongs to that co-ordintate. Track
+ * numbers start at 1.
+ * 
+ *  Arguments:
+ *    minfo     - The widget
+ *    ypix      - Y pixel widget co-ordinate
+ */
+int 
+y_to_track(MelysTrackInfo *minfo, int ypix)
+{
+	int  n;
+
+	n = (ypix - minfo->vtitle);
+	if (n < 0)
+		n = 0;
+
+	n /= minfo->vspace;
+
+	n += 1;
+
+	dprintf(3, "Y %d, track %d", ypix, n);
+
+	return n;
+}
+
+/*
+ * Given a track number, return the top y co-ord for that track.
+ * 
+ *  Arguments:
+ *    n         - Track number
+ */
+static int 
+track_to_y(MelysTrackInfo *minfo, int n)
+{
+	int ypix;
+
+	ypix = (n * minfo->vspace) + minfo->vtitle;
+	return ypix;
+}
+
+/*
+ * Return a text string which is the correct contents for the
+ * given track and column type.
+ * 
+ */
+char *
+get_info_string(MelysTrackInfo *minfo, int itype, int ntrack)
+{
+	enum column_type type = itype;
+	struct trackElement *track;
+	/* I keep typing defbug, I think its trying to tell be something... */
+	static char defbuf[TMP_BUF_SIZE];
+	char *str;
+
+	str = "N/A";
+
+	switch (type) {
+	case NUMBER:
+		g_snprintf(defbuf, TMP_BUF_SIZE, "%2d", ntrack);
+		str = defbuf;
+		break;
+	case NAME:
+		track = md_track_nth(minfo->mdroot, ntrack);
+		if (track && track->name) {
+			str = track->name;
+		} else {
+			g_snprintf(defbuf, TMP_BUF_SIZE, "Track %d", ntrack);
+			str = defbuf;
+		}
+		break;
+	case PROGRAM:
+		//g_snprintf(defbuf, "%d", TMP_BUF_SIZE, track->program);
+		//str = defbuf;
+		break;
+	default:
+		break;
+	}
+
+	return str;
+}
diff -rNu melys-0.0.4/widgets/melystrackinfo.m melys-0.0.5/widgets/melystrackinfo.m
--- melys-0.0.4/widgets/melystrackinfo.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/widgets/melystrackinfo.m	Mon Aug  9 00:05:59 1999
@@ -0,0 +1,639 @@
+>>name melystrackinfo.m - XXX
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+>>header gtk/gtk.h
+>>header elements.h
+>>header md.h
+>>gtkobject melys_track_info gtk_widget
+
+>>headerdef @header
+
+#define MAX_COLUMNS 30
+
+
+struct _MelysTrackInfo {
+	GtkWidget widget;
+
+	/* The adjustment for vertical scrolling */
+	GtkAdjustment *vadj;
+
+	/* Amount of vertical scrolling, in tracks (you never see half a track) */
+	int  voffset;
+
+	/* The titles are drawn in their own window (do we really need this?) */
+	GdkWindow *title_window;
+
+	/*
+	 * The columns are configurable in terms of which ones exist and
+	 * which order they appear in (or will be).
+	 * The following variables hold the current configuration.
+	 */
+	struct col_info *col_infos;	/* Columns in use */
+	gint   col_used;	/* Number of columns in use */
+
+	/*
+	 * The amount of vertical space used by tracks is under control of
+	 * the parent MelysTrack widget.  This is because we must be in
+	 * sync between MelysTrackInfo and MelysTrackDisplay.
+	 */
+
+	/* The amount of vertical space that a track takes up */
+	int  vspace;
+	int  height;	/* without separation */
+	int  htitle;	/* Title height */
+	int  vtitle;	/* Title vertical space */
+
+	/* The offset from the top of allocated space to text baseline */
+	int  vtextoffset;
+
+	/* Allocated area that track information is being displayed in */
+	GdkRectangle track_area;
+
+	/* The actual composition that is being displayed */
+	struct rootElement *mdroot;
+};
+
+struct _MelysTrackInfoClass {
+	GtkWidgetClass parent_class;
+	// XXX class definition here
+};
+
+>>header melystrackdisplay.h
+>>header melystrack.h
+>>extern
+
+enum {
+	// XXX symbols for all signals here
+	LAST_SIGNAL
+};
+
+enum column_type {
+	NUMBER,
+	NAME,
+	PROGRAM,
+	PATCH,
+	//MUTE,
+	//SOLO,
+	//RECORD,
+	LAST_COLUMN_TYPE
+};
+
+static struct col_info {
+	enum column_type type;
+	char *title;
+	int  width;
+	gboolean present;
+} def_col_info[] = {
+	{NUMBER, "", 20, TRUE},
+	{NAME, "Name", 100, TRUE},
+	{PROGRAM, "Prog", 60, TRUE},
+	{PATCH, "Patch", 200, FALSE},
+};
+
+/* A border to the protect the column lines */
+#define BORDER 2
+
+#define COL_PADDING  2
+
+/* Padding to avoid overwriting the pan handle (gtk bug?) */
+#define PAN_PADDING 2
+
+>>function melys_track_info_new
+GtkWidget *
+GtkAdjustment *vadj;  Vertical adjustment
+>>description
+Create a new MelysTrackInfo object.
+>>code
+	GtkWidget *w = GTK_WIDGET(gtk_type_new(melys_track_info_get_type()));
+	MelysTrackInfo *minfo;
+
+	minfo = (MelysTrackInfo*)w;
+
+	minfo->vadj = vadj;
+	gtk_object_ref((GtkObject*)vadj);
+	// XXX? gtk_object_sink((GtkObject*)vadj);
+
+	return w;
+
+>>function melys_track_info_init
+static void
+MelysTrackInfo *minfo;   The MelysTrackInfo to init
+>>description
+Initialise the MelysTrackInfo.
+>>code
+	int  i;
+	int  used;
+	struct col_info *cinfo;
+
+	minfo->vadj = NULL;
+	minfo->title_window = NULL;
+
+	used = 0;
+	minfo->col_infos = g_new0(struct col_info, MAX_COLUMNS);
+
+	for (i = 0; i < NELEM(def_col_info); i++) {
+		cinfo = def_col_info+i;
+
+		if (cinfo->present) {
+
+			minfo->col_infos[used] = *cinfo;
+			used++;
+		}
+	}
+
+	minfo->col_used = used;
+
+	minfo->height = TRACK_DEF_HEIGHT;
+	minfo->vspace = TRACK_DEF_HEIGHT + TRACK_SEPARATION;
+
+	minfo->htitle = TRACK_TITLE_HEIGHT;
+	minfo->vtitle = TRACK_TITLE_HEIGHT + 2*TRACK_SEPARATION;
+
+	minfo->mdroot = NULL;
+		
+>>function melys_track_info_class_init
+static void
+MelysTrackInfoClass *klass;   The class to initialise
+
+>>description
+Initialize the class.
+
+>>code
+	GtkObjectClass *object_class;
+	GtkWidgetClass *widget_class;
+
+	object_class = (GtkObjectClass *)klass;
+	widget_class = (GtkWidgetClass *)klass;
+
+	parent_class = gtk_type_class(gtk_widget_get_type());
+
+	// XXX Add args
+
+	// XXX Create signals
+
+	gtk_object_class_add_signals
+		(object_class, melys_track_info_signals, LAST_SIGNAL);
+
+	/* Set up all the overrides */
+	object_class->destroy = track_info_destroy;
+
+	widget_class->realize = track_info_realise;
+	widget_class->size_request = track_info_size_request;
+	widget_class->size_allocate = track_info_size_allocate;
+	widget_class->unrealize = track_info_unrealise;
+	widget_class->draw = track_info_draw;
+	widget_class->expose_event = track_info_expose;
+
+	// XXX Our functions
+
+
+>>function melys_track_info_set_height
+void
+MelysTrackInfo *minfo;
+int  height;	New track height
+int  htitle;	The title height
+>>description
+Set the height of the track and of the title.
+In addition there will be a separation distance.
+This function is called by MelysTrack.
+>>code
+
+	minfo->height = height;
+	minfo->vspace = height + TRACK_SEPARATION;
+
+	minfo->htitle = htitle;
+	minfo->vtitle = htitle + TRACK_SEPARATION;
+
+	if (GTK_WIDGET_REALIZED(minfo)) {
+
+		/* This doesn't actually change at present, but would if
+		 * it were middle aligned for example
+		 */
+		minfo->vtextoffset = GTK_WIDGET(minfo)->style->font->ascent + 1.5;
+	}
+
+
+>>function melys_track_info_set_md_root
+void
+MelysTrackInfo *minfo;
+struct rootElement *root;
+
+>>description
+Set a new mdroot, freeing any existing one.
+The widget is redrawn after this.
+
+>>code
+
+	dprintf1("Setting mdroot %p", root);
+
+	if (root == NULL)
+		return;
+
+	if (minfo->mdroot)
+		md_free((struct element *)minfo->mdroot);
+
+	root->refcount++;
+	minfo->mdroot = root;
+
+	track_info_draw(GTK_WIDGET(minfo), &minfo->track_area);
+
+
+>>function track_info_realise
+static void
+GtkWidget *widget;
+>>description
+Create the windows for this widget.
+The main window itself is not mapped, but any subwindows are shown.
+
+>>code
+	MelysTrackInfo *minfo;
+	GdkWindowAttr attributes;
+	gint attributes_mask;
+
+	dprintf1("@func_name called");
+	g_return_if_fail (widget != NULL);
+	g_return_if_fail (IS_MELYS_TRACK_INFO(widget));
+
+	minfo = MELYS_TRACK_INFO(widget);
+
+	GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
+
+	attributes.window_type = GDK_WINDOW_CHILD;
+	attributes.x = widget->allocation.x;
+	attributes.y = widget->allocation.y;
+	attributes.width = widget->allocation.width;
+	attributes.height = widget->allocation.height;
+	attributes.wclass = GDK_INPUT_OUTPUT;
+	attributes.visual = gtk_widget_get_visual(widget);
+	attributes.colormap = gtk_widget_get_colormap(widget);
+	attributes.event_mask = gtk_widget_get_events(widget);
+	attributes.event_mask |= (GDK_EXPOSURE_MASK |
+		GDK_BUTTON_PRESS_MASK |
+		GDK_BUTTON_RELEASE_MASK
+		///* XXX not sure about keys */GDK_KEY_PRESS_MASK |
+		//GDK_KEY_RELEASE_MASK
+		);
+	attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+
+	/* main window */
+	widget->window = gdk_window_new(gtk_widget_get_parent_window(widget),
+		&attributes, attributes_mask);
+	gdk_window_set_user_data(widget->window, minfo);
+
+	widget->style = gtk_style_attach(widget->style, widget->window);
+	gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL);
+
+	/* The title window */
+	attributes.x = 0;
+	attributes.y = 0;
+	attributes.height = 12;
+	minfo->title_window = gdk_window_new(widget->window,
+		&attributes, attributes_mask);
+
+	gdk_window_set_user_data(minfo->title_window, minfo);
+
+	widget->style = gtk_style_attach(widget->style, minfo->title_window);
+	gtk_style_set_background(widget->style, minfo->title_window,
+		GTK_STATE_NORMAL);
+
+	gdk_window_show(minfo->title_window);
+
+	minfo->vtextoffset = GTK_WIDGET(minfo)->style->font->ascent + 1.5;
+
+
+>>function track_info_unrealise
+static void
+GtkWidget *widget;
+>>code
+
+	GTK_WIDGET_UNSET_FLAGS(widget, GTK_MAPPED);
+
+	dprintf2("@func_name: before");
+	if (GTK_WIDGET_CLASS(parent_class)->unrealize)
+		(GTK_WIDGET_CLASS(parent_class)->unrealize)(widget);
+	dprintf2("@func_name: after");
+
+
+>>function track_info_destroy
+static void
+GtkObject *object;
+
+>>code
+	MelysTrackInfo *minfo;
+
+	g_return_if_fail(IS_MELYS_TRACK_INFO(object));
+
+	minfo = (MelysTrackInfo*)object;
+
+	gdk_window_destroy(minfo->title_window);
+	minfo->title_window = NULL;
+
+	g_free(minfo->col_infos);
+
+	if (minfo->vadj) {
+		gtk_object_unref(GTK_OBJECT(minfo->vadj));
+		minfo->vadj = NULL;
+	}
+
+	if (minfo->mdroot) {
+		md_free(MD_ELEMENT(minfo->mdroot));
+		minfo->mdroot = NULL;
+	}
+
+	minfo->col_used = 0;
+
+	if (GTK_OBJECT_CLASS(parent_class)->destroy)
+		(GTK_OBJECT_CLASS(parent_class)->destroy)(object);
+
+>>function track_info_size_request
+static void
+GtkWidget *widget;
+GtkRequisition *req;  Fill in with the size that we want
+
+>>code
+	MelysTrackInfo *minfo;
+	int  i;
+	int  tot;
+
+	g_return_if_fail(IS_MELYS_TRACK_INFO(widget));
+
+	minfo = (MelysTrackInfo*)widget;
+
+	req->width = 0;
+	req->height = 0;
+
+	tot = 0;
+	for (i = 0; i < minfo->col_used; i++) {
+		tot += minfo->col_infos[i].width;
+		tot += widget->style->klass->xthickness;
+	}
+
+	dprintf1("requested width %d", tot);
+	req->width = tot;
+
+
+>>function track_info_size_allocate
+static void
+GtkWidget *widget;
+GtkAllocation *allocation;
+
+>>code
+	MelysTrackInfo *minfo;
+
+	g_return_if_fail(widget != NULL);
+	g_return_if_fail(IS_MELYS_TRACK_INFO(widget));
+	g_return_if_fail(allocation != NULL);
+
+	minfo = (MelysTrackInfo*)widget;
+	widget->allocation = *allocation;
+
+	dprintf1("@func_name: alloced (%d, %d) %dx%d",
+		allocation->x, allocation->y, allocation->width, allocation->height);
+
+	if (GTK_WIDGET_REALIZED (widget)) {
+
+		minfo->track_area.x = allocation->x;
+		minfo->track_area.y = allocation->y + minfo->vtitle;
+		minfo->track_area.width = allocation->width - PAN_PADDING;
+		minfo->track_area.height = allocation->height;
+
+		gdk_window_move_resize(widget->window,
+			allocation->x, allocation->y,
+			allocation->width - PAN_PADDING, allocation->height);
+
+		gdk_window_move_resize(minfo->title_window,
+			0, 0, allocation->width, minfo->vtitle);
+	}
+
+
+>>function track_info_draw
+static void
+GtkWidget *widget;
+GdkRectangle *area;  Area to draw within
+
+>>code
+	MelysTrackInfo *minfo;
+	GtkStyle *style;
+	GdkGC *fg_gc;
+	GdkRectangle clip_rectangle;
+	int  offset;
+	int  start, end;
+	int  i;
+	int  ntrack;
+
+	g_return_if_fail(widget != NULL);
+	g_return_if_fail(IS_MELYS_TRACK_INFO(widget));
+	g_return_if_fail(area != NULL);
+
+	if (!GTK_WIDGET_DRAWABLE (widget))
+		return;
+
+	style = widget->style;
+	fg_gc = widget->style->fg_gc[GTK_STATE_NORMAL];
+
+	minfo = (MelysTrackInfo*)widget;
+
+	dprintf(2, "@func_name: (%d, %d) %dx%d", area->x, area->y,
+		area->width, area->height);
+
+	gtk_draw_shadow(widget->style, widget->window,
+		GTK_STATE_NORMAL, GTK_SHADOW_IN,
+		0, 0,
+		minfo->track_area.width, minfo->track_area.height);
+
+	/* Have to draw in the title box as well, the bottom is not meant to draw*/
+	gtk_draw_shadow(widget->style, minfo->title_window,
+		GTK_STATE_NORMAL, GTK_SHADOW_IN,
+		0, 0,
+		minfo->track_area.width, minfo->vtitle + 10);
+
+	offset = COL_PADDING;
+	for (i = 0; i < minfo->col_used; i++) {
+
+		clip_rectangle.x = offset;
+		clip_rectangle.y = 0;
+		clip_rectangle.width = minfo->col_infos[i].width;
+		clip_rectangle.height = minfo->vtitle;
+
+		dprintf2("offset %d, name %s", offset, minfo->col_infos[i].title);
+
+		gdk_gc_set_clip_rectangle(fg_gc, &clip_rectangle);
+		gdk_draw_string(minfo->title_window, style->font,
+			fg_gc,
+			offset,
+			minfo->htitle - widget->style->font->descent - 1,
+			minfo->col_infos[i].title);
+		gdk_gc_set_clip_rectangle(fg_gc, NULL);
+
+		offset += minfo->col_infos[i].width + COL_PADDING;
+		gtk_draw_vline(widget->style, minfo->title_window, GTK_STATE_NORMAL,
+			0, minfo->vtitle, offset);
+
+		/* Do the main window while we are here */
+		gtk_draw_vline(widget->style, widget->window, GTK_STATE_ACTIVE,
+			area->y, area->height, offset);
+
+		offset += style->klass->xthickness + COL_PADDING;
+	}
+
+	gdk_draw_line(minfo->title_window, fg_gc,
+		0, minfo->htitle,
+		area->width, minfo->htitle);
+
+	start = y_to_track(minfo, area->y);
+	end   = y_to_track(minfo, area->y + area->height);
+	if (end > minfo->mdroot->tracks)
+		end = minfo->mdroot->tracks;
+
+	for (ntrack = start; ntrack < end+1; ntrack++) {
+		char *str;
+		struct col_info *col;
+
+		offset = COL_PADDING;
+		for (i = 0; i < minfo->col_used; i++) {
+
+			col = minfo->col_infos+i;
+
+			/* This clips the text to fit, don't care about the height */
+			clip_rectangle.x = offset;
+			clip_rectangle.y = minfo->track_area.y;
+			clip_rectangle.width = col->width;
+			clip_rectangle.height = minfo->track_area.height;
+
+			str = get_info_string(minfo, col->type, ntrack);
+			dprintf(3, "offset %d, string %s", offset, str);
+
+			/* Now draw it */
+			gdk_gc_set_clip_rectangle(fg_gc, &clip_rectangle);
+			gdk_draw_string(widget->window, style->font, fg_gc,
+				offset, track_to_y(minfo, ntrack), str);
+			gdk_gc_set_clip_rectangle(fg_gc, NULL);
+
+			offset += col->width + COL_PADDING;
+			offset += style->klass->xthickness + COL_PADDING;
+		}
+		
+	}
+
+
+
+
+>>function track_info_expose
+static int
+GtkWidget *widget;
+GdkEventExpose *event;
+
+>>description
+Handle expose events.
+We just call the draw routine with a suitable arg.
+This means that we always re-draw some lines even when
+not necessary.
+But so what.
+
+>>code
+	MelysTrackInfo *minfo;
+
+	if (!GTK_WIDGET_DRAWABLE (widget))
+		return FALSE;
+
+	minfo = MELYS_TRACK_INFO(widget);
+
+	track_info_draw(minfo, &event->area);
+
+	return FALSE; /* XXX what does this mean */
+
+>>function y_to_track
+int
+MelysTrackInfo *minfo; The widget
+int  ypix;   Y pixel widget co-ordinate
+
+>>description
+Given a y position within the widget window, return
+the track number that belongs to that co-ordintate.
+Track numbers start at 1.
+
+>>code
+	int  n;
+
+	n = (ypix - minfo->vtitle);
+	if (n < 0)
+		n = 0;
+
+	n /= minfo->vspace;
+
+	n += 1;
+
+	dprintf(3, "Y %d, track %d", ypix, n);
+
+	return n;
+
+>>function track_to_y
+static int
+MelysTrackInfo *minfo;
+int  n;   Track number
+>>description
+Given a track number, return the top y co-ord for that track.
+
+>>code
+	int ypix;
+
+	ypix = (n * minfo->vspace) + minfo->vtitle;
+	return ypix;
+
+
+>>extern
+
+#define TMP_BUF_SIZE  100
+
+>>function get_info_string
+char *
+MelysTrackInfo *minfo;
+int   itype;
+int   ntrack;
+
+>>description
+Return a text string which is the correct contents for the
+given track and column type.
+
+>>code
+	enum column_type type = itype;
+	struct trackElement *track;
+	/* I keep typing defbug, I think its trying to tell be something... */
+	static char defbuf[TMP_BUF_SIZE];
+	char *str;
+
+	str = "N/A";
+
+	switch (type) {
+	case NUMBER:
+		g_snprintf(defbuf, TMP_BUF_SIZE, "%2d", ntrack);
+		str = defbuf;
+		break;
+	case NAME:
+		track = md_track_nth(minfo->mdroot, ntrack);
+		if (track && track->name) {
+			str = track->name;
+		} else {
+			g_snprintf(defbuf, TMP_BUF_SIZE, "Track %d", ntrack);
+			str = defbuf;
+		}
+		break;
+	case PROGRAM:
+		//g_snprintf(defbuf, "%d", TMP_BUF_SIZE, track->program);
+		//str = defbuf;
+		break;
+	default:
+		break;
+	}
+
+	return str;
diff -rNu melys-0.0.4/widgets/melystransport.c melys-0.0.5/widgets/melystransport.c
--- melys-0.0.4/widgets/melystransport.c	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/widgets/melystransport.c	Mon Aug  9 00:51:36 1999
@@ -0,0 +1,113 @@
+/*
+ * 
+ * Copyright (C) 1999 Steve Ratcliffe
+ * 
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ * 
+ *  This program 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 General Public License for more details.
+ * 
+ * 
+ */
+
+
+#include "glib.h"
+#include "except.h"
+#include "util.h"
+#include "gtk/gtkdrawingarea.h"
+#include "melystransport.h"
+#include "intl.h"
+
+enum {
+	// XXX symbols for all signals here
+	LAST_SIGNAL
+};
+static void melys_transport_init(MelysTransport *XXX);
+static void melys_transport_class_init(MelysTransportClass *klass);
+
+
+static gint melys_transport_signals[LAST_SIGNAL];
+
+static GtkDrawingAreaClass *parent_class = NULL;
+
+/*
+ * Return a unique integer that represents the object type.
+ */
+guint 
+melys_transport_get_type(void)
+{
+	static guint mtype = 0;
+
+	if (!mtype) {
+		GtkTypeInfo minfo = {
+			"MelysTransport",
+			sizeof(MelysTransport),
+			sizeof(MelysTransportClass),
+			(GtkClassInitFunc) melys_transport_class_init,
+			(GtkObjectInitFunc) melys_transport_init,
+			(GtkArgSetFunc) NULL,
+			(GtkArgGetFunc) NULL,
+			(GtkClassInitFunc) NULL,
+		};
+
+		mtype = gtk_type_unique(gtk_drawing_area_get_type(), &minfo);
+	}
+
+	return mtype;
+}
+
+/*
+ * Create a new MelysTransport object.
+ */
+GtkWidget *
+melys_transport_new(void)
+{
+	GtkWidget *XXX = GTK_WIDGET(gtk_type_new(melys_transport_get_type()));
+
+	// XXX Fill in here or replace previous line
+
+	return XXX;
+}
+
+/*
+ * Initialise the MelysTransport.
+ *  Arguments:
+ *    XXX       - The MelysTransport to init
+ */
+static void 
+melys_transport_init(MelysTransport *XXX)
+{
+	// XXX add any children etc.
+}
+
+/*
+ * Initialize the class.
+ * 
+ *  Arguments:
+ *    klass     - The class to initialise
+ */
+static void 
+melys_transport_class_init(MelysTransportClass *klass)
+{
+	GtkObjectClass *object_class;
+	GtkDrawingAreaClass *drawing_area_class;
+
+	object_class = (GtkObjectClass *)klass;
+	drawing_area_class = (GtkDrawingAreaClass *)klass;
+
+	parent_class = gtk_type_class(gtk_drawing_area_get_type());
+
+	// XXX Add args
+
+	// XXX Create signals
+
+	gtk_object_class_add_signals(object_class, melys_transport_signals, LAST_SIGNAL);
+
+	// XXX all the overrides come here
+
+	// XXX Our functions
+}
diff -rNu melys-0.0.4/widgets/melystransport.m melys-0.0.5/widgets/melystransport.m
--- melys-0.0.4/widgets/melystransport.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/widgets/melystransport.m	Mon Aug  9 00:05:59 1999
@@ -0,0 +1,18 @@
+>>name melystransport.m - XXX
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+>>header gtk/gtkdrawingarea.h
+>>set gtktemplate 1
+>>gtkobject melys_transport gtk_drawing_area
+>>unset gtktemplate
+
diff -rNu melys-0.0.4/widgets/register.m melys-0.0.5/widgets/register.m
--- melys-0.0.4/widgets/register.m	Thu Jan  1 00:00:00 1970
+++ melys-0.0.5/widgets/register.m	Tue Jul 27 10:01:42 1999
@@ -0,0 +1,160 @@
+>>name register.m - XXX
+
+Copyright (C) 1999 Steve Ratcliffe
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License version 2 as
+ published by the Free Software Foundation.
+
+ This program 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 General Public License for more details.
+
+>>header gtk/gtk.h
+>>headerdef --decl melreg.h
+
+typedef int  regid_t;
+
+>>extern
+
+/*
+ * This is the list of things we have registered.  Don't expect that
+ * many but obviously if this changes then a hash table may be better.
+ */
+static GSList *regobjs = NULL;
+
+/* The structure that saves the ids */
+struct regid {
+	int       id;
+	GtkObject *obj;
+};
+
+/* The id generator, start at 1 as 0 is the invalid value */
+static int  nextId = 1;
+
+>>function reg_object
+int
+GtkObject *obj;      Object to be registered
+GtkObject *parent;   If given obj will be destroyed when parent is
+
+>>description
+Register the object and return an integer that can be used to
+identify it in the future by calling
+.F reg_get .
+When the object is destroyed its reference will be too.
+This saves you having to keep track of the object which can
+be tricky if using a non-modal dialog and the user deletes
+the window manually.
+
+As an added convenience if you pass in
+.A parent
+it will be set up to destroy
+.A obj
+when the parent dies.
+
+>>code
+	struct regid *idp;
+	int  id;
+
+	id = nextId++;
+
+	/* Get a save struct for the data */
+	idp = g_new(struct regid, 1);
+	idp->id = id;
+	idp->obj = obj;
+
+	/* connect signals to unsave when destroyed */
+	gtk_signal_connect(obj, "destroy", destroy_cb, GINT_TO_POINTER(idp->id));
+
+	/* Save it */
+	regobjs = g_slist_append(regobjs, (gpointer)idp);
+
+	/* Set up for the parent if required */
+	if (parent) {
+		gtk_signal_connect_object_while_alive
+			(parent, "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroy), obj);
+	}
+
+	return id;
+
+>>function reg_get
+GtkObject *
+int  id;     The ID of the object to recover
+
+>>description
+Get the object corresponding to a saved ID.
+If the object has been destroyed then it will not be found
+and NULL will be returned.
+
+>>code
+	GSList *lp;
+	struct regid *idp;
+
+	for (lp = regobjs; lp; lp = lp->next) {
+		idp = (struct regid *)lp->data;
+		if (idp->id == id)
+			return idp->obj;
+	}
+
+	/* Not found, normal if it has been destroyed */
+	return NULL;
+
+>>function reg_get_widget
+GtkWidget *
+int  id;     The ID of the object to recover
+
+>>description
+As for
+.F reg_get
+except that it returns a widget type.
+Obviously it must have been saved as a widget.
+
+>>code
+	GtkObject  *obj;
+
+	obj = reg_get(id);
+
+	if (obj)
+		return GTK_WIDGET(obj);
+	else
+		return NULL;
+
+>>function reg_destroy
+void
+int  id;   Register id of widget to destroy
+
+>>description
+The object corresponding to the specified id is destroyed if
+it hasn't already been.
+
+>>code
+	GtkObject *obj;
+
+	obj = reg_get(id);
+	if (obj)
+		gtk_object_destroy(obj);
+
+
+>>function destroy_cb
+static void
+GtkObject *obj;   The destroyed object
+gpointer data;    Its id
+
+>>description
+Clean up when one of the register objects is destroyed.
+The record will be removed.
+
+>>code
+	GSList *lp;
+	struct regid *idp;
+
+	for (lp = regobjs; lp; lp = lp->next) {
+		idp = (struct regid *)lp->data;
+		if (idp->id == GPOINTER_TO_INT(data)) {
+			regobjs = g_slist_remove_link(regobjs, lp);
+			return;
+		}
+	}
+
+