abcjs 6.0.0-beta.33 → 6.0.0-beta.37

package/src/api/abc_timing_callbacks.js

@@ -25,6 +25,7 @@ var TimingCallbacks = function(target, params) {
 		self.currentBeat = 0;
 		self.currentEvent = 0;
 		self.currentLine = 0;
+		self.currentTime = 0;
 		self.isPaused = false;
 		self.isRunning = false;
 		self.pausedPercent = null;
@@ -53,41 +54,41 @@ var TimingCallbacks = function(target, params) {
 		}
 
 		if (!self.isPaused && self.isRunning) {
-			var currentTime = timestamp - self.startTime;
-			currentTime += 16; // Add a little slop because this function isn't called exactly.
-			while (self.noteTimings.length > self.currentEvent && self.noteTimings[self.currentEvent].milliseconds < currentTime) {
+			self.currentTime = timestamp - self.startTime;
+			self.currentTime += 16; // Add a little slop because this function isn't called exactly.
+			while (self.noteTimings.length > self.currentEvent && self.noteTimings[self.currentEvent].milliseconds < self.currentTime) {
 				if (self.eventCallback && self.noteTimings[self.currentEvent].type === 'event') {
 					var thisStartTime = self.startTime; // the event callback can call seek and change the position from beneath us.
 					self.eventCallback(self.noteTimings[self.currentEvent]);
 					if (thisStartTime !== self.startTime) {
-						currentTime = timestamp - self.startTime;
+						self.currentTime = timestamp - self.startTime;
 					}
 				}
 				self.currentEvent++;
 			}
-			if (self.lineEndCallback && self.lineEndTimings.length > self.currentLine && self.lineEndTimings[self.currentLine].milliseconds < currentTime && self.currentEvent < self.noteTimings.length) {
-				var leftEvent = self.noteTimings[self.currentEvent].milliseconds === currentTime ? self.noteTimings[self.currentEvent] : self.noteTimings[self.currentEvent-1]
-				self.lineEndCallback(self.lineEndTimings[self.currentLine], leftEvent, { line: self.currentLine, endTimings: self.lineEndTimings, currentTime: currentTime });
+			if (self.lineEndCallback && self.lineEndTimings.length > self.currentLine && self.lineEndTimings[self.currentLine].milliseconds < self.currentTime && self.currentEvent < self.noteTimings.length) {
+				var leftEvent = self.noteTimings[self.currentEvent].milliseconds === self.currentTime ? self.noteTimings[self.currentEvent] : self.noteTimings[self.currentEvent-1]
+				self.lineEndCallback(self.lineEndTimings[self.currentLine], leftEvent, { line: self.currentLine, endTimings: self.lineEndTimings, currentTime: self.currentTime });
 				self.currentLine++;
 			}
-			if (currentTime < self.lastMoment) {
+			if (self.currentTime < self.lastMoment) {
 				requestAnimationFrame(self.doTiming);
-				if (self.currentBeat * self.millisecondsPerBeat < currentTime) {
+				if (self.currentBeat * self.millisecondsPerBeat < self.currentTime) {
 					var ret = self.doBeatCallback(timestamp);
 					if (ret !== null)
-						currentTime = ret;
+						self.currentTime = ret;
 				}
 			} else if (self.currentBeat <= self.totalBeats) {
 				// Because of timing issues (for instance, if the browser tab isn't active), the beat callbacks might not have happened when they are supposed to. To keep the client programs from having to deal with that, this will keep calling the loop until all of them have been sent.
 				if (self.beatCallback) {
 					var ret2 = self.doBeatCallback(timestamp);
 					if (ret2 !== null)
-						currentTime = ret2;
+						self.currentTime = ret2;
 					requestAnimationFrame(self.doTiming);
 				}
 			}
 
-			if (currentTime >= self.lastMoment) {
+			if (self.currentTime >= self.lastMoment) {
 				if (self.eventCallback) {
 					// At the end, the event callback can return "continue" to keep from stopping.
 					// The event callback can either be a promise or not.
@@ -203,7 +204,7 @@ var TimingCallbacks = function(target, params) {
 		}
 	};
 
-	self.start = function(offsetPercent) {
+	self.start = function(offsetPercent, units) {
 		self.isRunning = true;
 		if (self.isPaused) {
 			self.isPaused = false;
@@ -211,13 +212,13 @@ var TimingCallbacks = function(target, params) {
 				self.justUnpaused = true;
 		}
 		if (offsetPercent) {
-			self.setProgress(offsetPercent);
+			self.setProgress(offsetPercent, units);
 		} else if (offsetPercent === 0) {
 			self.reset();
 		} else if (self.pausedPercent !== null) {
 			var now = performance.now();
-			var currentTime = self.lastMoment * self.pausedPercent;
-			self.startTime = now - currentTime;
+			self.currentTime = self.lastMoment * self.pausedPercent;
+			self.startTime = now - self.currentTime;
 			self.pausedPercent = null;
 			self.reportNext = true;
 		}
@@ -234,6 +235,9 @@ var TimingCallbacks = function(target, params) {
 			self.joggerTimer = null;
 		}
 	};
+	self.currentMillisecond = function() {
+		return self.currentTime;
+	};
 	self.reset = function() {
 		self.currentBeat = 0;
 		self.currentEvent = 0;
@@ -247,20 +251,19 @@ var TimingCallbacks = function(target, params) {
 	};
 	self.setProgress = function(position, units) {
 		// the effect of this function is to move startTime so that the callbacks happen correctly for the new seek.
-		var currentTime;
 		var percent;
 		switch (units) {
 			case "seconds":
-				currentTime = position * 1000;
-				if (currentTime < 0) currentTime = 0;
-				if (currentTime > self.lastMoment) currentTime = self.lastMoment;
-				percent = currentTime / self.lastMoment;
+				self.currentTime = position * 1000;
+				if (self.currentTime < 0) self.currentTime = 0;
+				if (self.currentTime > self.lastMoment) self.currentTime = self.lastMoment;
+				percent = self.currentTime / self.lastMoment;
 				break;
 			case "beats":
-				currentTime = position * self.millisecondsPerBeat * self.beatSubdivisions;
-				if (currentTime < 0) currentTime = 0;
-				if (currentTime > self.lastMoment) currentTime = self.lastMoment;
-				percent = currentTime / self.lastMoment;
+				self.currentTime = position * self.millisecondsPerBeat * self.beatSubdivisions;
+				if (self.currentTime < 0) self.currentTime = 0;
+				if (self.currentTime > self.lastMoment) self.currentTime = self.lastMoment;
+				percent = self.currentTime / self.lastMoment;
 				break;
 			default:
 				// this is "percent" or any illegal value
@@ -268,7 +271,7 @@ var TimingCallbacks = function(target, params) {
 				percent = position;
 				if (percent < 0) percent = 0;
 				if (percent > 1) percent = 1;
-				currentTime = self.lastMoment * percent;
+				self.currentTime = self.lastMoment * percent;
 				break;
 		}
 
@@ -276,25 +279,25 @@ var TimingCallbacks = function(target, params) {
 			self.pausedPercent = percent;
 
 		var now = performance.now();
-		self.startTime = now - currentTime;
+		self.startTime = now - self.currentTime;
 
 		var oldEvent = self.currentEvent;
 		self.currentEvent = 0;
-		while (self.noteTimings.length > self.currentEvent && self.noteTimings[self.currentEvent].milliseconds < currentTime) {
+		while (self.noteTimings.length > self.currentEvent && self.noteTimings[self.currentEvent].milliseconds < self.currentTime) {
 			self.currentEvent++;
 		}
 
 		if (self.lineEndCallback) {
 			self.currentLine = 0;
-			while (self.lineEndTimings.length > self.currentLine && self.lineEndTimings[self.currentLine].milliseconds + self.lineEndAnticipation < currentTime) {
+			while (self.lineEndTimings.length > self.currentLine && self.lineEndTimings[self.currentLine].milliseconds + self.lineEndAnticipation < self.currentTime) {
 				self.currentLine++;
 			}
 		}
 
 		var oldBeat = self.currentBeat;
-		self.currentBeat = Math.floor(currentTime / self.millisecondsPerBeat);
+		self.currentBeat = Math.floor(self.currentTime / self.millisecondsPerBeat);
 		if (self.beatCallback && oldBeat !== self.currentBeat) // If the movement caused the beat to change, then immediately report it to the client.
-			self.doBeatCallback(self.startTime+currentTime);
+			self.doBeatCallback(self.startTime+self.currentTime);
 
 		if (self.eventCallback && self.currentEvent >= 0 && self.noteTimings[self.currentEvent].type === 'event')
 			self.eventCallback(self.noteTimings[self.currentEvent]);

package/src/api/abc_tunebook.js

@@ -2,6 +2,8 @@
 
 var Parse = require('../parse/abc_parse');
 var bookParser = require('../parse/abc_parse_book');
+var tablatures = require('./abc_tablatures');
+
 
 var tunebook = {};
 
@@ -81,6 +83,13 @@ var tunebook = {};
 				if (currentTune >= 0 && currentTune < book.tunes.length) {
 					abcParser.parse(book.tunes[currentTune].abc, params, book.tunes[currentTune].startPos - book.header.length);
 					var tune = abcParser.getTune();
+					//
+					// Init tablatures plugins
+					//
+					if (params.tablature) {
+						tablatures.init();
+						tune.tablatures = tablatures.preparePlugins(tune, currentTune, params);
+					}
 					var warnings = abcParser.getWarnings();
 					if (warnings)
 						tune.warnings = warnings;
@@ -93,7 +102,7 @@ var tunebook = {};
 			}
 			currentTune++;
 		}
-		return ret;
+	  return ret;
 	};
 
 	function flattenTune(tuneObj) {

package/src/api/abc_tunebook_svg.js

@@ -5,6 +5,8 @@ var EngraverController = require('../write/abc_engraver_controller');
 var Parse = require('../parse/abc_parse');
 var wrap = require('../parse/wrap_lines');
 var parseCommon = require("../parse/abc_common");
+// var tablatures = require('./abc_tablatures');
+
 
 var resizeDivs = {};
 function resizeOuter() {
@@ -26,7 +28,7 @@ try {
     // if we aren't in a browser, this code will crash, but it is not needed then either.
 }
 
-function renderOne(div, tune, params, tuneNumber) {
+function renderOne(div, tune, params, tuneNumber, lineOffset) {
     if (params.viewportHorizontal) {
         // Create an inner div that holds the music, so that the passed in div will be the viewport.
         div.innerHTML = '<div class="abcjs-inner"></div>';
@@ -48,7 +50,7 @@ function renderOne(div, tune, params, tuneNumber) {
     else
 	    div.innerHTML = "";
     var engraver_controller = new EngraverController(div, params);
-    engraver_controller.engraveABC(tune, tuneNumber);
+    engraver_controller.engraveABC(tune, tuneNumber, lineOffset);
     tune.engraver = engraver_controller;
     if (params.viewportVertical || params.viewportHorizontal) {
         // If we added a wrapper around the div, then we need to size the wrapper, too.
@@ -63,8 +65,6 @@ function renderEachLineSeparately(div, tune, params, tuneNumber) {
         obj.formatting = tune.formatting;
         obj.media = tune.media;
         obj.version = tune.version;
-        obj.metaText = {};
-        obj.lines = [];
         return obj;
     }
 
@@ -80,14 +80,7 @@ function renderEachLineSeparately(div, tune, params, tuneNumber) {
 
         if (i === 0) {
             // These items go on top of the music
-            tuneLine.metaText.tempo = tune.metaText.tempo;
-            tuneLine.metaText.title = tune.metaText.title;
-            tuneLine.metaText.header = tune.metaText.header;
-            tuneLine.metaText.rhythm = tune.metaText.rhythm;
-            tuneLine.metaText.origin = tune.metaText.origin;
-            tuneLine.metaText.composer = tune.metaText.composer;
-            tuneLine.metaText.author = tune.metaText.author;
-            tuneLine.metaText.partOrder = tune.metaText.partOrder;
+            tuneLine.copyTopInfo(tune);
         }
 
         // push the lines until we get to a music line
@@ -106,17 +99,7 @@ function renderEachLineSeparately(div, tune, params, tuneNumber) {
 
     // These items go below the music
     tuneLine = tunes[tunes.length-1];
-    tuneLine.metaText.unalignedWords = tune.metaText.unalignedWords;
-    tuneLine.metaText.book = tune.metaText.book;
-    tuneLine.metaText.source = tune.metaText.source;
-    tuneLine.metaText.discography = tune.metaText.discography;
-    tuneLine.metaText.notes = tune.metaText.notes;
-    tuneLine.metaText.transcription = tune.metaText.transcription;
-    tuneLine.metaText.history = tune.metaText.history;
-    tuneLine.metaText['abc-copyright'] = tune.metaText['abc-copyright'];
-    tuneLine.metaText['abc-creator'] = tune.metaText['abc-creator'];
-    tuneLine.metaText['abc-edited-by'] = tune.metaText['abc-edited-by'];
-    tuneLine.metaText.footer = tune.metaText.footer;
+    tuneLine.copyBottomInfo(tune);
 
     // Now create sub-divs and render each line. Need to copy the params to change the padding for the interior slices.
     var ep = {};
@@ -127,7 +110,10 @@ function renderEachLineSeparately(div, tune, params, tuneNumber) {
     }
     var origPaddingTop = ep.paddingtop;
     var origPaddingBottom = ep.paddingbottom;
+    var currentScrollY = div.parentNode.scrollTop; // If there is scrolling it will be lost during the redraw so remember it.
+    var currentScrollX = div.parentNode.scrollLeft;
     div.innerHTML = "";
+    var lineCount = 0;
     for (var k = 0; k < tunes.length; k++) {
         var lineEl = document.createElement("div");
         div.appendChild(lineEl);
@@ -145,9 +131,10 @@ function renderEachLineSeparately(div, tune, params, tuneNumber) {
         if (k < tunes.length-1) {
             // If it is not the last line, force stretchlast. If it is, stretchlast might have been set by the input parameters.
             tunes[k].formatting = parseCommon.clone(tunes[k].formatting);
-            tunes[k].formatting.stretchlast = true
+            tunes[k].formatting.stretchlast = true;
         }
-        renderOne(lineEl, tunes[k], ep, tuneNumber);
+        renderOne(lineEl, tunes[k], ep, tuneNumber, lineCount);
+        lineCount += tunes[k].lines.length;
         if (k === 0)
             tune.engraver = tunes[k].engraver;
         else {
@@ -157,6 +144,9 @@ function renderEachLineSeparately(div, tune, params, tuneNumber) {
                 tune.engraver.staffgroups.push(tunes[k].engraver.staffgroups[0]);
         }
     }
+    if (currentScrollX || currentScrollY) {
+        div.parentNode.scrollTo(currentScrollX, currentScrollY);
+    }
 }
 
 // A quick way to render a tune from javascript when interactivity is not required.
@@ -186,6 +176,9 @@ var renderAbc = function(output, abc, parserParams, engraverParams, renderParams
                 params[key] = parserParams[key];
             }
         }
+        if (params.warnings_id && params.tablature) {
+            params.tablature.warning_id = params.warnings_id;
+        }
     }
     if (engraverParams) {
         for (key in engraverParams) {
@@ -222,7 +215,7 @@ var renderAbc = function(output, abc, parserParams, engraverParams, renderParams
 	        return tune;
         }
         else if (removeDiv || !params.oneSvgPerLine || tune.lines.length < 2)
-            renderOne(div, tune, params, tuneNumber);
+            renderOne(div, tune, params, tuneNumber, 0);
         else
             renderEachLineSeparately(div, tune, params, tuneNumber);
         if (removeDiv)
@@ -242,9 +235,12 @@ function doLineWrapping(div, tune, tuneNumber, abcString, params) {
         var abcParser = new Parse();
         abcParser.parse(abcString, ret.revisedParams);
         tune = abcParser.getTune();
+        var warnings = abcParser.getWarnings();
+        if (warnings)
+            tune.warnings = warnings;
     }
     if (!params.oneSvgPerLine || tune.lines.length < 2)
-        renderOne(div, tune, ret.revisedParams, tuneNumber);
+        renderOne(div, tune, ret.revisedParams, tuneNumber, 0);
     else
         renderEachLineSeparately(div, tune, ret.revisedParams, tuneNumber);
 	tune.explanation = ret.explanation;

package/src/data/abc_tune.js

@@ -12,6 +12,48 @@ var delineTune = require("./deline-tune");
  * @alternateClassName ABCJS.Tune
  */
 var Tune = function() {
+	this.reset = function () {
+		this.version = "1.1.0";
+		this.media = "screen";
+		this.metaText = {};
+		this.metaTextInfo = {};
+		this.formatting = {};
+		this.lines = [];
+		this.staffNum = 0;
+		this.voiceNum = 0;
+		this.lineNum = 0;
+		this.runningFonts = {};
+		delete this.visualTranspose;
+	};
+	this.reset();
+
+	function copy(dest, src, prop, attrs) {
+		for (var i = 0; i < attrs.length; i++)
+			dest[prop][attrs[i]] = src[prop][attrs[i]];
+	}
+
+	this.copyTopInfo = function(src) {
+		var attrs = ['tempo', 'title', 'header', 'rhythm', 'origin', 'composer', 'author', 'partOrder'];
+		copy(this, src, "metaText", attrs);
+		copy(this, src, "metaTextInfo", attrs);
+	};
+
+	this.copyBottomInfo = function(src) {
+		var attrs = ['unalignedWords',
+			'book',
+			'source',
+			'discography',
+			'notes',
+			'transcription',
+			'history',
+			'abc-copyright',
+			'abc-creator',
+			'abc-edited-by',
+			'footer']
+		copy(this, src, "metaText", attrs);
+		copy(this, src, "metaTextInfo", attrs);
+	};
+
 	// The structure consists of a hash with the following two items:
 	// metaText: a hash of {key, value}, where key is one of: title, author, rhythm, source, transcription, unalignedWords, etc...
 	// tempo: { noteLength: number (e.g. .125), bpm: number }
@@ -346,30 +388,32 @@ var Tune = function() {
 		var tempos = {};
 		for (var line = 0; line < this.engraver.staffgroups.length; line++) {
 			var group = this.engraver.staffgroups[line];
-			var firstStaff = group.staffs[0];
-			var middleC = firstStaff.absoluteY;
-			var top = middleC - firstStaff.top * spacing.STEP;
-			var lastStaff = group.staffs[group.staffs.length - 1];
-			middleC = lastStaff.absoluteY;
-			var bottom = middleC - lastStaff.bottom * spacing.STEP;
-			var height = bottom - top;
-
-			var voices = group.voices;
-			for (var v = 0; v < voices.length; v++) {
-				var noteFound = false;
-				if (!voicesArr[v])
-					voicesArr[v] = [];
-				if (measureNumber[v] === undefined)
-					measureNumber[v] = 0;
-				var elements = voices[v].children;
-				for (var elem = 0; elem < elements.length; elem++) {
-					if (elements[elem].type === "tempo")
-						tempos[measureNumber[v]] = this.getBpm(elements[elem].abcelem);
-					voicesArr[v].push({top: top, height: height, line: group.line, measureNumber: measureNumber[v], elem: elements[elem]});
-					if (elements[elem].type === 'bar' && noteFound) // Count the measures by counting the bar lines, but skip a bar line that appears at the left of the music, before any notes.
-						measureNumber[v]++;
-					if (elements[elem].type === 'note' || elements[elem].type === 'rest')
-						noteFound = true;
+			if (group && group.staffs && group.staffs.length > 0) {
+				var firstStaff = group.staffs[0];
+				var middleC = firstStaff.absoluteY;
+				var top = middleC - firstStaff.top * spacing.STEP;
+				var lastStaff = group.staffs[group.staffs.length - 1];
+				middleC = lastStaff.absoluteY;
+				var bottom = middleC - lastStaff.bottom * spacing.STEP;
+				var height = bottom - top;
+
+				var voices = group.voices;
+				for (var v = 0; v < voices.length; v++) {
+					var noteFound = false;
+					if (!voicesArr[v])
+						voicesArr[v] = [];
+					if (measureNumber[v] === undefined)
+						measureNumber[v] = 0;
+					var elements = voices[v].children;
+					for (var elem = 0; elem < elements.length; elem++) {
+						if (elements[elem].type === "tempo")
+							tempos[measureNumber[v]] = this.getBpm(elements[elem].abcelem);
+						voicesArr[v].push({top: top, height: height, line: group.line, measureNumber: measureNumber[v], elem: elements[elem]});
+						if (elements[elem].type === 'bar' && noteFound) // Count the measures by counting the bar lines, but skip a bar line that appears at the left of the music, before any notes.
+							measureNumber[v]++;
+						if (elements[elem].type === 'note' || elements[elem].type === 'rest')
+							noteFound = true;
+					}
 				}
 			}
 		}

package/src/edit/abc_editor.js

@@ -82,6 +82,17 @@ function gatherAbcParams(params) {
 			}
 		}
 	}
+	/*
+	if (params.tablature_options) {
+		abcjsParams['tablatures'] = params.tablature_options;
+	}
+	*/
+	if (abcjsParams.tablature) {
+		if (params.warnings_id) {
+			// store for plugin error handling
+			abcjsParams.tablature.warnings_id = params.warnings_id;
+		}
+	}
 	return abcjsParams;
 }
 
@@ -123,7 +134,7 @@ var Editor = function(editarea, params) {
 		    el: params.synth.el,
 		    cursorControl: params.synth.cursorControl,
 		    options: params.synth.options
-	    }
+	    };
     }
   }
 	// If the user wants midi, then store the elements that it will be written to. The element could either be passed in as an id,
@@ -219,16 +230,23 @@ Editor.prototype.redrawMidi = function() {
 Editor.prototype.modelChanged = function() {
   if (this.bReentry)
     return; // TODO is this likely? maybe, if we rewrite abc immediately w/ abc2abc
-  this.bReentry = true;
-  this.timerId = null;
-  if (this.synth && this.synth.synthControl)
-	  this.synth.synthControl.disable(true);
-
-  this.tunes = renderAbc(this.div, this.currentAbc, this.abcjsParams);
-  if (this.tunes.length > 0) {
-	  this.warnings = this.tunes[0].warnings;
-  }
-	this.redrawMidi();
+	this.bReentry = true;
+	try {
+		this.timerId = null;
+		if (this.synth && this.synth.synthControl)
+			this.synth.synthControl.disable(true);
+
+		this.tunes = renderAbc(this.div, this.currentAbc, this.abcjsParams);
+		if (this.tunes.length > 0) {
+			this.warnings = this.tunes[0].warnings;
+		}
+		this.redrawMidi();
+	} catch(error) {
+		console.error("ABCJS error: ", error);
+		if (!this.warnings)
+			this.warnings = [];
+		this.warnings.push(error.message);
+	}
 
   if (this.warningsdiv) {
     this.warningsdiv.innerHTML = (this.warnings) ? this.warnings.join("<br />") : "No errors";
@@ -251,6 +269,8 @@ Editor.prototype.paramChanged = function(engraverParams) {
 };
 
 Editor.prototype.synthParamChanged = function(options) {
+	if (!this.synth)
+		return;
 	this.synth.options = {};
 	if (options) {
 		for (var key in options) {
@@ -371,6 +391,8 @@ Editor.prototype.pause = function(shouldPause) {
 };
 
 Editor.prototype.millisecondsPerMeasure = function() {
+	if (!this.synth || !this.synth.synthControl || !this.synth.synthControl.visualObj)
+		return 0;
 	return this.synth.synthControl.visualObj.millisecondsPerMeasure();
 };
 

package/src/midi/abc_midi_create.js

@@ -19,6 +19,8 @@ var create;
 			title = title.substring(0,124) + '...';
 		var key = abcTune.getKeySignature();
 		var time = abcTune.getMeterFraction();
+		var beatsPerSecond = commands.tempo / 60;
+		//var beatLength = abcTune.getBeatLength();
 		midi.setGlobalInfo(commands.tempo, title, key, time);
 
 		for (var i = 0; i < commands.tracks.length; i++) {
@@ -38,9 +40,11 @@ var create;
 						midi.setInstrument(event.instrument);
 						break;
 					case 'note':
+						var gapLengthInBeats = event.gap * beatsPerSecond;
 						var start = event.start;
-						var end = start + event.duration;
-						// TODO: end is affected by event.gap, too.
+						// The staccato and legato are indicated by event.gap.
+						// event.gap is in seconds but the durations are in whole notes.
+						var end = start + event.duration - gapLengthInBeats;
 						if (!notePlacement[start])
 							notePlacement[start] = [];
 						notePlacement[start].push({ pitch: event.pitch, volume: event.volume, cents: event.cents });

package/src/parse/abc_parse.js

@@ -24,6 +24,7 @@ var Parse = function() {
 			lines: tune.lines,
 			media: tune.media,
 			metaText: tune.metaText,
+			metaTextInfo: tune.metaTextInfo,
 			version: tune.version,
 
 			addElementToEvents: tune.addElementToEvents,
@@ -137,8 +138,10 @@ var Parse = function() {
 			};
 			for (var i = 0; i < this.inTie.length; i++) {
 				this.endingHoldOver.inTie.push([]);
-				for (var j = 0; j < this.inTie[i].length; j++) {
-					this.endingHoldOver.inTie[i].push(this.inTie[i][j]);
+				if (this.inTie[i]) { // if a voice is suppressed there might be a gap in the array.
+					for (var j = 0; j < this.inTie[i].length; j++) {
+						this.endingHoldOver.inTie[i].push(this.inTie[i][j]);
+					}
 				}
 			}
 			for (var key in this.inTieChord) {
@@ -188,9 +191,7 @@ var Parse = function() {
 		var bad_char = line.charAt(col_num);
 		if (bad_char === ' ')
 			bad_char = "SPACE";
-		var clean_line = encode(line.substring(0, col_num)) +
-			'<span style="text-decoration:underline;font-size:1.3em;font-weight:bold;">' + bad_char + '</span>' +
-			encode(line.substring(col_num+1));
+		var clean_line = encode(line.substring(col_num - 64, col_num)) + '<span style="text-decoration:underline;font-size:1.3em;font-weight:bold;">' + bad_char + '</span>' + encode(line.substring(col_num + 1).substring(0,64));
 		addWarning("Music Line:" + tokenizer.lineIndex + ":" + (col_num+1) + ': ' + str + ":  " + clean_line);
 		addWarningObject({message:str, line:line, startChar: multilineVars.iChar + col_num, column: col_num});
 	};
@@ -473,7 +474,7 @@ var Parse = function() {
 		// switches.transpose: change the key signature, chords, and notes by a number of half-steps.
 		if (!switches) switches = {};
 		if (!startPos) startPos = 0;
-		tuneBuilder.reset();
+		tune.reset();
 
 		// Take care of whatever line endings come our way
 		// Tack on newline temporarily to make the last line continuation work