abcjs-rails 1.1.0 → 1.1.1

data/app/assets/javascripts/abcjs/parse/abc_parse_key_voice.js

@@ -0,0 +1,781 @@
+/*global window */
+
+if (!window.ABCJS)
+	window.ABCJS = {};
+
+if (!window.ABCJS.parse)
+	window.ABCJS.parse = {};
+
+window.ABCJS.parse.parseKeyVoice = {};
+
+(function() {
+	var tokenizer;
+	var warn;
+	var multilineVars;
+	var tune;
+	window.ABCJS.parse.parseKeyVoice.initialize = function(tokenizer_, warn_, multilineVars_, tune_) {
+		tokenizer = tokenizer_;
+		warn = warn_;
+		multilineVars = multilineVars_;
+		tune = tune_;
+	};
+
+	window.ABCJS.parse.parseKeyVoice.standardKey = function(keyName) {
+		var key1sharp = {acc: 'sharp', note: 'f'};
+		var key2sharp = {acc: 'sharp', note: 'c'};
+		var key3sharp = {acc: 'sharp', note: 'g'};
+		var key4sharp = {acc: 'sharp', note: 'd'};
+		var key5sharp = {acc: 'sharp', note: 'A'};
+		var key6sharp = {acc: 'sharp', note: 'e'};
+		var key7sharp = {acc: 'sharp', note: 'B'};
+		var key1flat = {acc: 'flat', note: 'B'};
+		var key2flat = {acc: 'flat', note: 'e'};
+		var key3flat = {acc: 'flat', note: 'A'};
+		var key4flat = {acc: 'flat', note: 'd'};
+		var key5flat = {acc: 'flat', note: 'G'};
+		var key6flat = {acc: 'flat', note: 'c'};
+		var key7flat = {acc: 'flat', note: 'F'};
+
+		var keys = {
+			'C#': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp, key7sharp ],
+			'A#m': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp, key7sharp ],
+			'G#Mix': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp, key7sharp ],
+			'D#Dor': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp, key7sharp ],
+			'E#Phr': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp, key7sharp ],
+			'F#Lyd': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp, key7sharp ],
+			'B#Loc': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp, key7sharp ],
+
+			'F#': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp ],
+			'D#m': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp ],
+			'C#Mix': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp ],
+			'G#Dor': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp ],
+			'A#Phr': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp ],
+			'BLyd': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp ],
+			'E#Loc': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp ],
+
+			'B': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp ],
+			'G#m': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp ],
+			'F#Mix': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp ],
+			'C#Dor': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp ],
+			'D#Phr': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp ],
+			'ELyd': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp ],
+			'A#Loc': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp ],
+
+			'E': [ key1sharp, key2sharp, key3sharp, key4sharp ],
+			'C#m': [ key1sharp, key2sharp, key3sharp, key4sharp ],
+			'BMix': [ key1sharp, key2sharp, key3sharp, key4sharp ],
+			'F#Dor': [ key1sharp, key2sharp, key3sharp, key4sharp ],
+			'G#Phr': [ key1sharp, key2sharp, key3sharp, key4sharp ],
+			'ALyd': [ key1sharp, key2sharp, key3sharp, key4sharp ],
+			'D#Loc': [ key1sharp, key2sharp, key3sharp, key4sharp ],
+
+			'A': [ key1sharp, key2sharp, key3sharp ],
+			'F#m': [ key1sharp, key2sharp, key3sharp ],
+			'EMix': [ key1sharp, key2sharp, key3sharp ],
+			'BDor': [ key1sharp, key2sharp, key3sharp ],
+			'C#Phr': [ key1sharp, key2sharp, key3sharp ],
+			'DLyd': [ key1sharp, key2sharp, key3sharp ],
+			'G#Loc': [ key1sharp, key2sharp, key3sharp ],
+
+			'D': [ key1sharp, key2sharp ],
+			'Bm': [ key1sharp, key2sharp ],
+			'AMix': [ key1sharp, key2sharp ],
+			'EDor': [ key1sharp, key2sharp ],
+			'F#Phr': [ key1sharp, key2sharp ],
+			'GLyd': [ key1sharp, key2sharp ],
+			'C#Loc': [ key1sharp, key2sharp ],
+
+			'G': [ key1sharp ],
+			'Em': [ key1sharp ],
+			'DMix': [ key1sharp ],
+			'ADor': [ key1sharp ],
+			'BPhr': [ key1sharp ],
+			'CLyd': [ key1sharp ],
+			'F#Loc': [ key1sharp ],
+
+			'C': [],
+			'Am': [],
+			'GMix': [],
+			'DDor': [],
+			'EPhr': [],
+			'FLyd': [],
+			'BLoc': [],
+
+			'F': [ key1flat ],
+			'Dm': [ key1flat ],
+			'CMix': [ key1flat ],
+			'GDor': [ key1flat ],
+			'APhr': [ key1flat ],
+			'BbLyd': [ key1flat ],
+			'ELoc': [ key1flat ],
+
+			'Bb': [ key1flat, key2flat ],
+			'Gm': [ key1flat, key2flat ],
+			'FMix': [ key1flat, key2flat ],
+			'CDor': [ key1flat, key2flat ],
+			'DPhr': [ key1flat, key2flat ],
+			'EbLyd': [ key1flat, key2flat ],
+			'ALoc': [ key1flat, key2flat ],
+
+			'Eb': [ key1flat, key2flat, key3flat ],
+			'Cm': [ key1flat, key2flat, key3flat ],
+			'BbMix': [ key1flat, key2flat, key3flat ],
+			'FDor': [ key1flat, key2flat, key3flat ],
+			'GPhr': [ key1flat, key2flat, key3flat ],
+			'AbLyd': [ key1flat, key2flat, key3flat ],
+			'DLoc': [ key1flat, key2flat, key3flat ],
+
+			'Ab': [ key1flat, key2flat, key3flat, key4flat ],
+			'Fm': [ key1flat, key2flat, key3flat, key4flat ],
+			'EbMix': [ key1flat, key2flat, key3flat, key4flat ],
+			'BbDor': [ key1flat, key2flat, key3flat, key4flat ],
+			'CPhr': [ key1flat, key2flat, key3flat, key4flat ],
+			'DbLyd': [ key1flat, key2flat, key3flat, key4flat ],
+			'GLoc': [ key1flat, key2flat, key3flat, key4flat ],
+
+			'Db': [ key1flat, key2flat, key3flat, key4flat, key5flat ],
+			'Bbm': [ key1flat, key2flat, key3flat, key4flat, key5flat ],
+			'AbMix': [ key1flat, key2flat, key3flat, key4flat, key5flat ],
+			'EbDor': [ key1flat, key2flat, key3flat, key4flat, key5flat ],
+			'FPhr': [ key1flat, key2flat, key3flat, key4flat, key5flat ],
+			'GbLyd': [ key1flat, key2flat, key3flat, key4flat, key5flat ],
+			'CLoc': [ key1flat, key2flat, key3flat, key4flat, key5flat ],
+
+			'Gb': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat ],
+			'Ebm': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat ],
+			'DbMix': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat ],
+			'AbDor': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat ],
+			'BbPhr': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat ],
+			'CbLyd': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat ],
+			'FLoc': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat ],
+
+			'Cb': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat, key7flat ],
+			'Abm': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat, key7flat ],
+			'GbMix': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat, key7flat ],
+			'DbDor': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat, key7flat ],
+			'EbPhr': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat, key7flat ],
+			'FbLyd': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat, key7flat ],
+			'BbLoc': [ key1flat, key2flat, key3flat, key4flat, key5flat, key6flat, key7flat ],
+
+			// The following are not in the 2.0 spec, but seem normal enough.
+			// TODO-PER: These SOUND the same as what's written, but they aren't right
+			'A#': [ key1flat, key2flat ],
+			'B#': [],
+			'D#': [ key1flat, key2flat, key3flat ],
+			'E#': [ key1flat ],
+			'G#': [ key1flat, key2flat, key3flat, key4flat ],
+			'Gbm': [ key1sharp, key2sharp, key3sharp, key4sharp, key5sharp, key6sharp, key7sharp ]
+		};
+
+		return keys[keyName];
+	};
+
+	var calcMiddle = function(clef, oct) {
+		var mid = 0;
+		switch(clef) {
+			case 'treble':
+			case 'perc':
+			case 'none':
+			case 'treble+8':
+			case 'treble-8':
+				break;
+			case 'bass3':
+			case 'bass':
+			case 'bass+8':
+			case 'bass-8':
+			case 'bass+16':
+			case 'bass-16':
+				mid = -12;
+				break;
+			case 'tenor':
+				mid = -8;
+				break;
+			case 'alto2':
+			case 'alto1':
+			case 'alto':
+			case 'alto+8':
+			case 'alto-8':
+				mid = -6;
+				break;
+		}
+		return mid+oct;
+	};
+
+	window.ABCJS.parse.parseKeyVoice.deepCopyKey = function(key) {
+		var ret = { accidentals: [], root: key.root, acc: key.acc, mode: key.mode };
+		window.ABCJS.parse.each(key.accidentals, function(k) {
+		ret.accidentals.push(window.ABCJS.parse.clone(k));
+		});
+		return ret;
+	};
+
+	var pitches = {A: 5, B: 6, C: 0, D: 1, E: 2, F: 3, G: 4, a: 12, b: 13, c: 7, d: 8, e: 9, f: 10, g: 11};
+
+	window.ABCJS.parse.parseKeyVoice.addPosToKey = function(clef, key) {
+		// Shift the key signature from the treble positions to whatever position is needed for the clef.
+		// This may put the key signature unnaturally high or low, so if it does, then shift it.
+		var mid = clef.verticalPos;
+		window.ABCJS.parse.each(key.accidentals, function(acc) {
+			var pitch = pitches[acc.note];
+			pitch = pitch - mid;
+			acc.verticalPos = pitch;
+		});
+		if (key.impliedNaturals)
+			window.ABCJS.parse.each(key.impliedNaturals, function(acc) {
+				var pitch = pitches[acc.note];
+				pitch = pitch - mid;
+				acc.verticalPos = pitch;
+			});
+
+		if (mid < -10) {
+			window.ABCJS.parse.each(key.accidentals, function(acc) {
+				acc.verticalPos -= 7;
+				if (acc.verticalPos >= 11 || (acc.verticalPos === 10 && acc.acc === 'flat'))
+					acc.verticalPos -= 7;
+				if (acc.note === 'A' && acc.acc === 'sharp' )
+					acc.verticalPos -=7;
+				if ((acc.note === 'G' || acc.note === 'F') && acc.acc === 'flat' )
+					acc.verticalPos -=7;
+			});
+			if (key.impliedNaturals)
+				window.ABCJS.parse.each(key.impliedNaturals, function(acc) {
+					acc.verticalPos -= 7;
+					if (acc.verticalPos >= 11 || (acc.verticalPos === 10 && acc.acc === 'flat'))
+						acc.verticalPos -= 7;
+					if (acc.note === 'A' && acc.acc === 'sharp' )
+						acc.verticalPos -=7;
+					if ((acc.note === 'G' || acc.note === 'F') && acc.acc === 'flat' )
+						acc.verticalPos -=7;
+				});
+		} else if (mid < -4) {
+			window.ABCJS.parse.each(key.accidentals, function(acc) {
+				acc.verticalPos -= 7;
+				if (mid === -8 && (acc.note === 'f' || acc.note === 'g') && acc.acc === 'sharp' )
+					acc.verticalPos -=7;
+			});
+			if (key.impliedNaturals)
+				window.ABCJS.parse.each(key.impliedNaturals, function(acc) {
+					acc.verticalPos -= 7;
+					if (mid === -8 && (acc.note === 'f' || acc.note === 'g') && acc.acc === 'sharp' )
+						acc.verticalPos -=7;
+				});
+		} else if (mid >= 7) {
+			window.ABCJS.parse.each(key.accidentals, function(acc) {
+				acc.verticalPos += 7;
+			});
+			if (key.impliedNaturals)
+				window.ABCJS.parse.each(key.impliedNaturals, function(acc) {
+					acc.verticalPos += 7;
+				});
+		}
+	};
+
+	window.ABCJS.parse.parseKeyVoice.fixKey = function(clef, key) {
+		var fixedKey = window.ABCJS.parse.clone(key);
+		window.ABCJS.parse.parseKeyVoice.addPosToKey(clef, fixedKey);
+		return fixedKey;
+	};
+
+	var parseMiddle = function(str) {
+	  var mid = pitches[str.charAt(0)];
+		for (var i = 1; i < str.length; i++) {
+			if (str.charAt(i) === ',') mid -= 7;
+			else if (str.charAt(i) === ',') mid += 7;
+			else break;
+		}
+		return { mid: mid - 6, str: str.substring(i) };	// We get the note in the middle of the staff. We want the note that appears as the first ledger line below the staff.
+	};
+
+	var normalizeAccidentals = function(accs) {
+		for (var i = 0; i < accs.length; i++) {
+			if (accs[i].note === 'b')
+				accs[i].note = 'B';
+			else if (accs[i].note === 'a')
+				accs[i].note = 'A';
+			else if (accs[i].note === 'F')
+				accs[i].note = 'f';
+			else if (accs[i].note === 'E')
+				accs[i].note = 'e';
+			else if (accs[i].note === 'D')
+				accs[i].note = 'd';
+			else if (accs[i].note === 'C')
+				accs[i].note = 'c';
+			else if (accs[i].note === 'G' && accs[i].acc === 'sharp')
+				accs[i].note = 'g';
+			else if (accs[i].note === 'g' && accs[i].acc === 'flat')
+				accs[i].note = 'G';
+		}
+	};
+
+	window.ABCJS.parse.parseKeyVoice.parseKey = function(str)	// (and clef)
+	{
+		// returns:
+		//		{ foundClef: true, foundKey: true }
+		// Side effects:
+		//		calls warn() when there is a syntax error
+		//		sets these members of multilineVars:
+		//			clef
+		//			key
+		//			style
+		//
+		// The format is:
+		// K: [⟨key⟩] [⟨modifiers⟩*]
+		// modifiers are any of the following in any order:
+		//  [⟨clef⟩] [middle=⟨pitch⟩] [transpose=[-]⟨number⟩] [stafflines=⟨number⟩] [staffscale=⟨number⟩][style=⟨style⟩]
+		// key is none|HP|Hp|⟨specified_key⟩
+		// clef is [clef=] [⟨clef type⟩] [⟨line number⟩] [+8|-8]
+		// specified_key is ⟨pitch⟩[#|b][mode(first three chars are significant)][accidentals*]
+		if (str.length === 0) {
+			// an empty K: field is the same as K:none
+			str = 'none';
+		}
+		var tokens = tokenizer.tokenize(str, 0, str.length);
+		var ret = {};
+
+		// first the key
+		switch (tokens[0].token) {
+			case 'HP':
+				window.ABCJS.parse.parseDirective.addDirective("bagpipes");
+				multilineVars.key = { root: "HP", accidentals: [], acc: "", mode: "" };
+				ret.foundKey = true;
+				tokens.shift();
+				break;
+			case 'Hp':
+				window.ABCJS.parse.parseDirective.addDirective("bagpipes");
+				multilineVars.key = { root: "Hp", accidentals: [{acc: 'natural', note: 'g'}, {acc: 'sharp', note: 'f'}, {acc: 'sharp', note: 'c'}], acc: "", mode: "" };
+				ret.foundKey = true;
+				tokens.shift();
+				break;
+			case 'none':
+				// we got the none key - that's the same as C to us
+				multilineVars.key = { root: "none", accidentals: [], acc: "", mode: "" };
+				ret.foundKey = true;
+				tokens.shift();
+				break;
+			default:
+				var retPitch = tokenizer.getKeyPitch(tokens[0].token);
+				if (retPitch.len > 0) {
+					ret.foundKey = true;
+					var acc = "";
+					var mode = "";
+					// The accidental and mode might be attached to the pitch, so we might want to just remove the first character.
+					if (tokens[0].token.length > 1)
+						tokens[0].token = tokens[0].token.substring(1);
+					else
+						tokens.shift();
+					var key = retPitch.token;
+					// We got a pitch to start with, so we might also have an accidental and a mode
+					if (tokens.length > 0) {
+						var retAcc = tokenizer.getSharpFlat(tokens[0].token);
+						if (retAcc.len > 0) {
+							if (tokens[0].token.length > 1)
+								tokens[0].token = tokens[0].token.substring(1);
+							else
+								tokens.shift();
+							key += retAcc.token;
+							acc = retAcc.token;
+						}
+						if (tokens.length > 0) {
+							var retMode = tokenizer.getMode(tokens[0].token);
+							if (retMode.len > 0) {
+								tokens.shift();
+								key += retMode.token;
+								mode = retMode.token;
+							}
+						}
+					}
+					// We need to do a deep copy because we are going to modify it
+					var oldKey = window.ABCJS.parse.parseKeyVoice.deepCopyKey(multilineVars.key);
+					multilineVars.key = window.ABCJS.parse.parseKeyVoice.deepCopyKey({accidentals: window.ABCJS.parse.parseKeyVoice.standardKey(key)});
+					multilineVars.key.root = retPitch.token;
+					multilineVars.key.acc = acc;
+					multilineVars.key.mode = mode;
+					if (oldKey) {
+						// Add natural in all places that the old key had an accidental.
+						var kk;
+						for (var k = 0; k < multilineVars.key.accidentals.length; k++) {
+							for (kk = 0; kk < oldKey.accidentals.length; kk++) {
+								if (oldKey.accidentals[kk].note && multilineVars.key.accidentals[k].note.toLowerCase() === oldKey.accidentals[kk].note.toLowerCase())
+									oldKey.accidentals[kk].note = null;
+							}
+						}
+						for (kk = 0; kk < oldKey.accidentals.length; kk++) {
+							if (oldKey.accidentals[kk].note) {
+								if (!multilineVars.key.impliedNaturals)
+									multilineVars.key.impliedNaturals = [];
+								multilineVars.key.impliedNaturals.push({ acc: 'natural', note: oldKey.accidentals[kk].note });
+							}
+						}
+					}
+				}
+				break;
+		}
+
+		// There are two special cases of deprecated syntax. Ignore them if they occur
+		if (tokens.length === 0) return ret;
+		if (tokens[0].token === 'exp') tokens.shift();
+		if (tokens.length === 0) return ret;
+		if (tokens[0].token === 'oct') tokens.shift();
+
+		// now see if there are extra accidentals
+		if (tokens.length === 0) return ret;
+		var accs = tokenizer.getKeyAccidentals2(tokens);
+		if (accs.warn)
+			warn(accs.warn, str, 0);
+		// If we have extra accidentals, first replace ones that are of the same pitch before adding them to the end.
+		if (accs.accs) {
+			if (!ret.foundKey) {		// if there are only extra accidentals, make sure this is set.
+				ret.foundKey = true;
+				multilineVars.key = { root: "none", acc: "", mode: "", accidentals: [] };
+			}
+			normalizeAccidentals(accs.accs);
+			for (var i = 0; i < accs.accs.length; i++) {
+				var found = false;
+				for (var j = 0; j < multilineVars.key.accidentals.length && !found; j++) {
+					if (multilineVars.key.accidentals[j].note === accs.accs[i].note) {
+						found = true;
+						multilineVars.key.accidentals[j].acc = accs.accs[i].acc;
+					}
+				}
+				if (!found) {
+					multilineVars.key.accidentals.push(accs.accs[i]);
+					if (multilineVars.key.impliedNaturals) {
+						for (var kkk = 0; kkk < multilineVars.key.impliedNaturals.length; kkk++) {
+							if (multilineVars.key.impliedNaturals[kkk].note === accs.accs[i].note)
+								multilineVars.key.impliedNaturals.splice(kkk, 1);
+						}
+					}
+				}
+			}
+		}
+
+		// Now see if any optional parameters are present. They have the form "key=value", except that "clef=" is optional
+		var token;
+		while (tokens.length > 0) {
+			switch (tokens[0].token) {
+				case "m":
+				case "middle":
+					tokens.shift();
+					if (tokens.length === 0) { warn("Expected = after middle", str, 0); return ret; }
+					token = tokens.shift();
+					if (token.token !== "=") { warn("Expected = after middle", str, token.start); break; }
+					if (tokens.length === 0) { warn("Expected parameter after middle=", str, 0); return ret; }
+					var pitch = tokenizer.getPitchFromTokens(tokens);
+					if (pitch.warn)
+						warn(pitch.warn, str, 0);
+					if (pitch.position)
+						multilineVars.clef.verticalPos = pitch.position - 6;	// we get the position from the middle line, but want to offset it to the first ledger line.
+					break;
+				case "transpose":
+					tokens.shift();
+					if (tokens.length === 0) { warn("Expected = after transpose", str, 0); return ret; }
+					token = tokens.shift();
+					if (token.token !== "=") { warn("Expected = after transpose", str, token.start); break; }
+					if (tokens.length === 0) { warn("Expected parameter after transpose=", str, 0); return ret; }
+					if (tokens[0].type !== 'number') { warn("Expected number after transpose", str, tokens[0].start); break; }
+					multilineVars.clef.transpose = tokens[0].intt;
+					tokens.shift();
+					break;
+				case "stafflines":
+					tokens.shift();
+					if (tokens.length === 0) { warn("Expected = after stafflines", str, 0); return ret; }
+					token = tokens.shift();
+					if (token.token !== "=") { warn("Expected = after stafflines", str, token.start); break; }
+					if (tokens.length === 0) { warn("Expected parameter after stafflines=", str, 0); return ret; }
+					if (tokens[0].type !== 'number') { warn("Expected number after stafflines", str, tokens[0].start); break; }
+					multilineVars.clef.stafflines = tokens[0].intt;
+					tokens.shift();
+					break;
+				case "staffscale":
+					tokens.shift();
+					if (tokens.length === 0) { warn("Expected = after staffscale", str, 0); return ret; }
+					token = tokens.shift();
+					if (token.token !== "=") { warn("Expected = after staffscale", str, token.start); break; }
+					if (tokens.length === 0) { warn("Expected parameter after staffscale=", str, 0); return ret; }
+					if (tokens[0].type !== 'number') { warn("Expected number after staffscale", str, tokens[0].start); break; }
+					multilineVars.clef.staffscale = tokens[0].floatt;
+					tokens.shift();
+					break;
+				case "style":
+					tokens.shift();
+					if (tokens.length === 0) { warn("Expected = after style", str, 0); return ret; }
+					token = tokens.shift();
+					if (token.token !== "=") { warn("Expected = after style", str, token.start); break; }
+					if (tokens.length === 0) { warn("Expected parameter after style=", str, 0); return ret; }
+					switch (tokens[0].token) {
+						case "normal":
+						case "harmonic":
+						case "rhythm":
+						case "x":
+							multilineVars.style = tokens[0].token;
+							tokens.shift();
+							break;
+						default:
+							warn("error parsing style element: " + tokens[0].token, str, tokens[0].start);
+							break;
+					}
+					break;
+				case "clef":
+					tokens.shift();
+					if (tokens.length === 0) { warn("Expected = after clef", str, 0); return ret; }
+					token = tokens.shift();
+					if (token.token !== "=") { warn("Expected = after clef", str, token.start); break; }
+					if (tokens.length === 0) { warn("Expected parameter after clef=", str, 0); return ret; }
+					//break; yes, we want to fall through. That allows "clef=" to be optional.
+				case "treble":
+				case "bass":
+				case "alto":
+				case "tenor":
+				case "perc":
+					// clef is [clef=] [⟨clef type⟩] [⟨line number⟩] [+8|-8]
+					var clef = tokens.shift();
+					switch (clef.token) {
+						case 'treble':
+						case 'tenor':
+						case 'alto':
+						case 'bass':
+						case 'perc':
+						case 'none':
+							break;
+						case 'C': clef.token = 'alto'; break;
+						case 'F': clef.token = 'bass'; break;
+						case 'G': clef.token = 'treble'; break;
+						case 'c': clef.token = 'alto'; break;
+						case 'f': clef.token = 'bass'; break;
+						case 'g': clef.token = 'treble'; break;
+						default:
+							warn("Expected clef name. Found " + clef.token, str, clef.start);
+							break;
+					}
+					if (tokens.length > 0 && tokens[0].type === 'number') {
+						clef.token += tokens[0].token;
+						tokens.shift();
+					}
+					if (tokens.length > 1 && (tokens[0].token === '-' || tokens[0].token === '+') && tokens[1].token === '8') {
+						clef.token += tokens[0].token + tokens[1].token;
+						tokens.shift();
+						tokens.shift();
+					}
+					multilineVars.clef = {type: clef.token, verticalPos: calcMiddle(clef.token, 0)};
+					ret.foundClef = true;
+					break;
+				default:
+					warn("Unknown parameter: " + tokens[0].token, str, tokens[0].start);
+					tokens.shift();
+			}
+		}
+		return ret;
+	};
+
+	var setCurrentVoice = function(id) {
+		multilineVars.currentVoice = multilineVars.voices[id];
+		tune.setCurrentVoice(multilineVars.currentVoice.staffNum, multilineVars.currentVoice.index);
+	};
+
+	window.ABCJS.parse.parseKeyVoice.parseVoice = function(line, i, e) {
+		//First truncate the string to the first non-space character after V: through either the
+		//end of the line or a % character. Then remove trailing spaces, too.
+		var ret = tokenizer.getMeat(line, i, e);
+		var start = ret.start;
+		var end = ret.end;
+		//The first thing on the line is the ID. It can be any non-space string and terminates at the
+		//first space.
+		var id = tokenizer.getToken(line, start, end);
+		if (id.length === 0) {
+			warn("Expected a voice id", line, start);
+			return;
+		}
+		var isNew = false;
+		if (multilineVars.voices[id] === undefined) {
+			multilineVars.voices[id] = {};
+			isNew = true;
+			if (multilineVars.score_is_present)
+				warn("Can't have an unknown V: id when the %score directive is present", line, start);
+		}
+		start += id.length;
+		start += tokenizer.eatWhiteSpace(line, start);
+
+		var staffInfo = {startStaff: isNew};
+		var addNextTokenToStaffInfo = function(name) {
+			var attr = tokenizer.getVoiceToken(line, start, end);
+			if (attr.warn !== undefined)
+				warn("Expected value for " + name + " in voice: " + attr.warn, line, start);
+			else if (attr.token.length === 0 && line.charAt(start) !== '"')
+				warn("Expected value for " + name + " in voice", line, start);
+			else
+				staffInfo[name] = attr.token;
+			start += attr.len;
+		};
+		var addNextTokenToVoiceInfo = function(id, name, type) {
+			var attr = tokenizer.getVoiceToken(line, start, end);
+			if (attr.warn !== undefined)
+				warn("Expected value for " + name + " in voice: " + attr.warn, line, start);
+			else if (attr.token.length === 0 && line.charAt(start) !== '"')
+				warn("Expected value for " + name + " in voice", line, start);
+			else {
+				if (type === 'number')
+					attr.token = parseFloat(attr.token);
+				multilineVars.voices[id][name] = attr.token;
+			}
+			start += attr.len;
+		};
+
+		//Then the following items can occur in any order:
+		while (start < end) {
+			var token = tokenizer.getVoiceToken(line, start, end);
+			start += token.len;
+
+			if (token.warn) {
+				warn("Error parsing voice: " + token.warn, line, start);
+			} else {
+				var attr = null;
+				switch (token.token) {
+					case 'clef':
+					case 'cl':
+						addNextTokenToStaffInfo('clef');
+						// TODO-PER: check for a legal clef; do octavizing
+						var oct = 0;
+	//							for (var ii = 0; ii < staffInfo.clef.length; ii++) {
+	//								if (staffInfo.clef[ii] === ',') oct -= 7;
+	//								else if (staffInfo.clef[ii] === "'") oct += 7;
+	//							}
+						if (staffInfo.clef !== undefined) {
+						  staffInfo.clef = staffInfo.clef.replace(/[',]/g, ""); //'//comment for emacs formatting of regexp
+							if (staffInfo.clef.indexOf('+16') !== -1) {
+								oct += 14;
+								staffInfo.clef = staffInfo.clef.replace('+16', '');
+							}
+							staffInfo.verticalPos = calcMiddle(staffInfo.clef, oct);
+						}
+						break;
+					case 'treble':
+					case 'bass':
+					case 'tenor':
+					case 'alto':
+					case 'none':
+					case 'treble\'':
+					case 'bass\'':
+					case 'tenor\'':
+					case 'alto\'':
+					case 'none\'':
+					case 'treble\'\'':
+					case 'bass\'\'':
+					case 'tenor\'\'':
+					case 'alto\'\'':
+					case 'none\'\'':
+					case 'treble,':
+					case 'bass,':
+					case 'tenor,':
+					case 'alto,':
+					case 'none,':
+					case 'treble,,':
+					case 'bass,,':
+					case 'tenor,,':
+					case 'alto,,':
+					case 'none,,':
+						// TODO-PER: handle the octave indicators on the clef by changing the middle property
+						var oct2 = 0;
+	//							for (var iii = 0; iii < token.token.length; iii++) {
+	//								if (token.token[iii] === ',') oct2 -= 7;
+	//								else if (token.token[iii] === "'") oct2 += 7;
+	//							}
+											  staffInfo.clef = token.token.replace(/[',]/g, ""); //'//comment for emacs formatting of regexp
+						staffInfo.verticalPos = calcMiddle(staffInfo.clef, oct2);
+						break;
+					case 'staves':
+					case 'stave':
+					case 'stv':
+						addNextTokenToStaffInfo('staves');
+						break;
+					case 'brace':
+					case 'brc':
+						addNextTokenToStaffInfo('brace');
+						break;
+					case 'bracket':
+					case 'brk':
+						addNextTokenToStaffInfo('bracket');
+						break;
+					case 'name':
+					case 'nm':
+						addNextTokenToStaffInfo('name');
+						break;
+					case 'subname':
+					case 'sname':
+					case 'snm':
+						addNextTokenToStaffInfo('subname');
+						break;
+					case 'merge':
+						staffInfo.startStaff = false;
+						break;
+					case 'stems':
+						attr = tokenizer.getVoiceToken(line, start, end);
+						if (attr.warn !== undefined)
+							warn("Expected value for stems in voice: " + attr.warn, line, start);
+						else if (attr.token === 'up' || attr.token === 'down')
+							multilineVars.voices[id].stem = attr.token;
+						else
+							warn("Expected up or down for voice stem", line, start);
+						start += attr.len;
+						break;
+					case 'up':
+					case 'down':
+						multilineVars.voices[id].stem = token.token;
+						break;
+					case 'middle':
+					case 'm':
+						addNextTokenToStaffInfo('verticalPos');
+						staffInfo.verticalPos = parseMiddle(staffInfo.verticalPos).mid;
+						break;
+					case 'gchords':
+					case 'gch':
+						multilineVars.voices[id].suppressChords = true;
+						break;
+					case 'space':
+					case 'spc':
+						addNextTokenToStaffInfo('spacing');
+						break;
+					case 'scale':
+						addNextTokenToVoiceInfo(id, 'scale', 'number');
+						break;
+					case 'transpose':
+						addNextTokenToVoiceInfo(id, 'transpose', 'number');
+						break;
+				}
+			}
+			start += tokenizer.eatWhiteSpace(line, start);
+		}
+
+		// now we've filled up staffInfo, figure out what to do with this voice
+		// TODO-PER: It is unclear from the standard and the examples what to do with brace, bracket, and staves, so they are ignored for now.
+		if (staffInfo.startStaff || multilineVars.staves.length === 0) {
+			multilineVars.staves.push({index: multilineVars.staves.length, meter: multilineVars.origMeter});
+			if (!multilineVars.score_is_present)
+				multilineVars.staves[multilineVars.staves.length-1].numVoices = 0;
+		}
+		if (multilineVars.voices[id].staffNum === undefined) {
+			// store where to write this for quick access later.
+			multilineVars.voices[id].staffNum = multilineVars.staves.length-1;
+			var vi = 0;
+			for(var v in multilineVars.voices) {
+				if(multilineVars.voices.hasOwnProperty(v)) {
+					if (multilineVars.voices[v].staffNum === multilineVars.voices[id].staffNum)
+						vi++;
+				}
+			}
+			multilineVars.voices[id].index = vi-1;
+		}
+		var s = multilineVars.staves[multilineVars.voices[id].staffNum];
+		if (!multilineVars.score_is_present)
+			s.numVoices++;
+		if (staffInfo.clef) s.clef = {type: staffInfo.clef, verticalPos: staffInfo.verticalPos};
+		if (staffInfo.spacing) s.spacing_below_offset = staffInfo.spacing;
+		if (staffInfo.verticalPos) s.verticalPos = staffInfo.verticalPos;
+
+		if (staffInfo.name) {if (s.name) s.name.push(staffInfo.name); else s.name = [ staffInfo.name ];}
+		if (staffInfo.subname) {if (s.subname) s.subname.push(staffInfo.subname); else s.subname = [ staffInfo.subname ];}
+
+		setCurrentVoice(id);
+	};
+
+})();
+