abcjs-rails 1.8 → 1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7dbac8c0a5ad9f76a40c25b8c005af7e252d3511
-  data.tar.gz: 0577ccedd11d130f22d2b6c2c3c89506f61e9dcb
+  metadata.gz: 69dc7543800ee59c97f476146e4d23392cf201f0
+  data.tar.gz: f36703aa7021da85d79ca7e8e287749f28db1b24
 SHA512:
-  metadata.gz: ede96b70bf4fd02a9594fee34e9dae661b5fd2bb5e05dbc0770b57ae4c5e889876d70c3552b26cf956e7589ca437a46944faaaeae3c2ee6451c64ccb11e7856f
-  data.tar.gz: 94f0fba0cab72e74cf8ab2c1e581250f334a974c19ebd9a5a0a954673b011967d509075886448132c3240e0513181784ee22566c7fcc3409f32fcfa8b7e10f99
+  metadata.gz: ab12f67b09329ba8245b574c226519cb6fc8e202bf8cd9b6c6323662cedbfca851e1abde4b94d8d02961dd007aa19389043a7f7ed9dd6fc92ed6cb2bd4d0e39d
+  data.tar.gz: 6228eac5b18e3cc8d6ce3b56545c29d8c12f741f321da6cf95a55a8e92994273dc4763931eba3836199f11b5625522c540f2211aa193151adb839cebe735f219

data/README.md

@@ -23,7 +23,7 @@ To include abcjs in your Rails app, add this line to application.js:
 
 	//= require abcjs-rails
 
-See http://code.google.com/p/abcjs/wiki/InstallationDocumentation?tm=6 for complete
+See https://github.com/paulrosen/abcjs for complete
 usage of abcjs. There is no additional functionality supplied by this gem.
 
 Here is a cheatsheet for using the functionality:

data/app/assets/javascripts/abcjs/api/abc_animation.js

@@ -0,0 +1,224 @@
+//    abc_animation.js: handles animating the music in real time.
+//    Copyright (C) 2014 Paul Rosen (paul at paulrosen dot net)
+//
+//    This program is free software: you can redistribute it and/or modify
+//    it under the terms of the GNU General Public License as published by
+//    the Free Software Foundation, either version 3 of the License, or
+//    (at your option) any later version.
+//
+//    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.
+//
+//    You should have received a copy of the GNU General Public License
+//    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+/*global ABCJS, console */
+
+if (!window.ABCJS)
+	window.ABCJS = {};
+
+(function() {
+
+	function hasClass(element, cls) {
+		var elClass = element.getAttribute("class");
+		var rclass = /[\t\r\n\f]/g;
+		var className = " " + cls + " ";
+		return (element.nodeType === 1 && (" " + elClass + " ").replace(rclass, " ").indexOf(className) >= 0);
+	}
+
+	function getAllElementsByClasses(startingEl, class1, class2) {
+		var els = startingEl.getElementsByClassName(class1);
+		var ret = [];
+		for (var i = 0; i < els.length; i++) {
+			if (hasClass(els[i], class2))
+				ret.push(els[i]);
+		}
+		return ret;
+	}
+
+	function getBeatsPerMinute(tune, options) {
+		// We either want to run the timer once per measure or once per beat. If we run it once per beat we need a multiplier for the measures.
+		// So, first we figure out the beats per minute and the beats per measure, then depending on the type of animation, we can
+		// calculate the desired interval (ret.tick) and the number of ticks before we want to run the measure
+		var bpm;
+		if (options.bpm)
+			bpm = options.bpm;
+		else {
+			if (tune && tune.metaText && tune.metaText.tempo && tune.metaText.tempo.bpm)
+				bpm = tune.metaText.tempo.bpm;
+			else
+				bpm = 120; // Just set it to something. The user should have set this.
+		}
+		return bpm;
+	}
+
+	// This is a way to manipulate the written music on a timer. Their are two ways to manipulate the music: turn off each measure as it goes by,
+	// and put a vertical cursor before the next note to play. The timer works at the speed of the original tempo of the music unless it is overwritten
+	// in the options parameter.
+	//
+	// parameters:
+	// paper: the output div that the music is in.
+	// tune: the tune object returned by renderAbc.
+	// options: a hash containing the following:
+	//    hideFinishedMeasures: true or false [ false is the default ]
+	//    showCursor: true or false [ false is the default ]
+	//    bpm: number of beats per minute [ the default is whatever is in the Q: field ]
+	var stopNextTime = false;
+	var cursor;
+	ABCJS.startAnimation = function(paper, tune, options) {
+		if (paper.getElementsByClassName === undefined) {
+			console.error("ABCJS.startAnimation: The first parameter must be a regular DOM element. (Did you pass a jQuery object or an ID?)");
+			return;
+		}
+		if (tune.getBeatLength === undefined) {
+			console.error("ABCJS.startAnimation: The second parameter must be a single tune. (Did you pass the entire array of tunes?)");
+			return;
+		}
+		if (options.showCursor) {
+			cursor = $('<div class="cursor" style="position: absolute;"></div>');
+			$(paper).append(cursor);
+		}
+
+		stopNextTime = false;
+		var beatsPerMinute = getBeatsPerMinute(tune, options);
+		var beatsPerMillisecond = beatsPerMinute / 60000;
+		var beatLength = tune.getBeatLength(); // This is the same units as the duration is stored in.
+
+		var startTime;
+
+		function processMeasureHider(lineNum, measureNum) {
+			var els = getAllElementsByClasses(paper, "l"+lineNum, "m"+measureNum);
+
+			if (els.length > 0) {
+				for (var i = 0; i < els.length; i++) {
+					var el = els[i];
+					if (!hasClass(el, "bar"))
+						el.style.display = "none";
+				}
+			}
+		}
+
+		function makeSortedArray(hash) {
+			var arr = [];
+			for (var k in hash) {
+				if (hash.hasOwnProperty(k))
+					arr.push(hash[k]);
+			}
+			arr = arr.sort(function(a,b) {
+				return a.time - b.time;
+			});
+			return arr;
+		}
+
+		var timingEvents = [];
+		function setupEvents(engraver) {
+			var eventHash = {};
+			// The time is the number of measures from the beginning of the piece.
+			var time = 0;
+			var isTiedState = false;
+			for (var line=0;line<engraver.staffgroups.length; line++) {
+				var group = engraver.staffgroups[line];
+				var voices = group.voices;
+				var top = group.y;
+				var height = group.height;
+				var maxVoiceTime = 0;
+				// Put in the notes for all voices, then sort them, then remove duplicates
+				for (var v = 0; v < voices.length; v++) {
+					var voiceTime = time;
+					var elements = voices[v].children;
+					for (var elem=0; elem<elements.length; elem++) {
+						var element = elements[elem];
+						if (element.duration > 0) {
+							// There are 3 possibilities here: the note could stand on its own, the note could be tied to the next,
+							// the note could be tied to the previous, and the note could be tied on both sides.
+							var isTiedToNext = element.startTie;
+							if (isTiedState) {
+								if (!isTiedToNext)
+									isTiedState = false;
+								// If the note is tied on both sides it can just be ignored.
+							} else {
+								// the last note wasn't tied.
+								eventHash["event"+voiceTime] = { type: "event", time: voiceTime, top: top, height: height, left: element.x, width: element.w };
+								if (isTiedToNext)
+									isTiedState = true;
+							}
+							voiceTime += element.duration;
+						}
+						if (element.type === 'bar') {
+							if (timingEvents.length === 0 || timingEvents[timingEvents.length-1] !== 'bar') {
+								if (element.elemset && element.elemset.length > 0 && element.elemset[0].attrs) {
+									var klass = element.elemset[0].attrs['class'];
+									var arr = klass.split(' ');
+									var lineNum;
+									var measureNum;
+									for (var i = 0; i < arr.length; i++) {
+										var match = /m(\d+)/.exec(arr[i]);
+										if (match)
+											measureNum = match[1];
+										match = /l(\d+)/.exec(arr[i]);
+										if (match)
+											lineNum = match[1];
+									}
+									eventHash["bar"+voiceTime] = { type: "bar", time: voiceTime, lineNum: lineNum, measureNum: measureNum };
+								}
+							}
+						}
+					}
+					maxVoiceTime = Math.max(maxVoiceTime, voiceTime);
+				}
+				time = maxVoiceTime;
+			}
+			// now we have all the events, but if there are multiple voices then there may be events out of order or duplicated, so normalize it.
+			timingEvents = makeSortedArray(eventHash);
+		}
+		setupEvents(tune.engraver);
+
+		function processShowCursor() {
+			var currentNote = timingEvents.shift();
+			if (!currentNote) {
+				stopNextTime = true;
+				return 0;
+			}
+			if (currentNote.type === "bar") {
+				if (options.hideFinishedMeasures)
+					processMeasureHider(currentNote.lineNum, currentNote.measureNum);
+				return processShowCursor();
+			}
+			if (options.showCursor)
+				cursor.css({ left: currentNote.left + "px", top: currentNote.top + "px", width: currentNote.width + "px", height: currentNote.height + "px" });
+			if (timingEvents.length > 0)
+				return timingEvents[0].time / beatLength;
+			stopNextTime = true;
+			return 0;
+		}
+
+		function processNext() {
+			if (stopNextTime) {
+				ABCJS.stopAnimation();
+				return;
+			}
+			var nextTimeInBeats = processShowCursor();
+			var nextTimeInMilliseconds = nextTimeInBeats / beatsPerMillisecond;
+			var currentTime = new Date();
+			currentTime = currentTime.getTime();
+			var interval = startTime + nextTimeInMilliseconds - currentTime;
+			if (interval <= 0)
+				processNext();
+			else
+				setTimeout(processNext, interval);
+		}
+		startTime = new Date();
+		startTime = startTime.getTime();
+		processNext();
+	};
+
+	ABCJS.stopAnimation = function() {
+		stopNextTime = true;
+		if (cursor) {
+			cursor.remove();
+			cursor = null;
+		}
+	};
+})();

data/app/assets/javascripts/abcjs/api/abc_tunebook.js

@@ -15,175 +15,179 @@
 //    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 /*global document, Raphael */
-/*global window */
+/*global window, ABCJS, console */
 
 if (!window.ABCJS)
 	window.ABCJS = {};
 
 (function() {
-ABCJS.numberOfTunes = function(abc) {
-	var tunes = abc.split("\nX:");
-	var num = tunes.length;
-	if (num === 0) num = 1;
-	return num;
-};
-
-ABCJS.TuneBook = function(book) {
-	var This = this;
-	var directives = "";
-	book = window.ABCJS.parse.strip(book);
-	var tunes = book.split("\nX:");
-	for (var i = 1; i < tunes.length; i++)	// Put back the X: that we lost when splitting the tunes.
-		tunes[i] = "X:" + tunes[i];
-	// Keep track of the character position each tune starts with.
-	var pos = 0;
-	This.tunes = [];
-	window.ABCJS.parse.each(tunes, function(tune) {
-		This.tunes.push({ abc: tune, startPos: pos});
-		pos += tune.length;
-	});
-	if (This.tunes.length > 1 && !window.ABCJS.parse.startsWith(This.tunes[0].abc, 'X:')) {	// If there is only one tune, the X: might be missing, otherwise assume the top of the file is "intertune"
-		// There could be file-wide directives in this, if so, we need to insert it into each tune. We can probably get away with
-		// just looking for file-wide directives here (before the first tune) and inserting them at the bottom of each tune, since
-		// the tune is parsed all at once. The directives will be seen before the printer begins processing.
-		var dir = This.tunes.shift();
-		var arrDir = dir.abc.split('\n');
-		window.ABCJS.parse.each(arrDir, function(line) {
-			if (window.ABCJS.parse.startsWith(line, '%%'))
-				directives += line + '\n';
+	ABCJS.numberOfTunes = function(abc) {
+		var tunes = abc.split("\nX:");
+		var num = tunes.length;
+		if (num === 0) num = 1;
+		return num;
+	};
+
+	ABCJS.TuneBook = function(book) {
+		var This = this;
+		var directives = "";
+		book = window.ABCJS.parse.strip(book);
+		var tunes = book.split("\nX:");
+		for (var i = 1; i < tunes.length; i++)	// Put back the X: that we lost when splitting the tunes.
+			tunes[i] = "X:" + tunes[i];
+		// Keep track of the character position each tune starts with.
+		var pos = 0;
+		This.tunes = [];
+		window.ABCJS.parse.each(tunes, function(tune) {
+			This.tunes.push({ abc: tune, startPos: pos});
+			pos += tune.length;
 		});
-	}
-	This.header = directives;
-
-	// Now, the tune ends at a blank line, so truncate it if needed. There may be "intertune" stuff.
-	window.ABCJS.parse.each(This.tunes, function(tune) {
-		var end = tune.abc.indexOf('\n\n');
-		if (end > 0)
-			tune.abc = tune.abc.substring(0, end);
-		tune.pure = tune.abc;
-		tune.abc = directives + tune.abc;
-
-		// for the user's convenience, parse and store the title separately. The title is between the first T: and the next \n
-		var title = tune.pure.split("T:");
-		if (title.length > 1) {
-			title = title[1].split("\n");
-			tune.title = title[0].replace(/^\s+|\s+$/g, '');;
-		} else
-			tune.title = "";
-
-		// for the user's convenience, parse and store the id separately. The id is between the first X: and the next \n
-		var id = tune.pure.substring(2,tune.pure.indexOf("\n"));
-		tune.id = id.replace(/^\s+|\s+$/g, '');
-	});
-};
-
-ABCJS.TuneBook.prototype.getTuneById = function (id) {
-	for (var i = 0; i < this.tunes.length; i++) {
-		if (this.tunes[i].id === id)
-			return this.tunes[i];
-	}
-	return null;
-};
+		if (This.tunes.length > 1 && !window.ABCJS.parse.startsWith(This.tunes[0].abc, 'X:')) {	// If there is only one tune, the X: might be missing, otherwise assume the top of the file is "intertune"
+			// There could be file-wide directives in this, if so, we need to insert it into each tune. We can probably get away with
+			// just looking for file-wide directives here (before the first tune) and inserting them at the bottom of each tune, since
+			// the tune is parsed all at once. The directives will be seen before the engraver begins processing.
+			var dir = This.tunes.shift();
+			var arrDir = dir.abc.split('\n');
+			window.ABCJS.parse.each(arrDir, function(line) {
+				if (window.ABCJS.parse.startsWith(line, '%%'))
+					directives += line + '\n';
+			});
+		}
+		This.header = directives;
+
+		// Now, the tune ends at a blank line, so truncate it if needed. There may be "intertune" stuff.
+		window.ABCJS.parse.each(This.tunes, function(tune) {
+			var end = tune.abc.indexOf('\n\n');
+			if (end > 0)
+				tune.abc = tune.abc.substring(0, end);
+			tune.pure = tune.abc;
+			tune.abc = directives + tune.abc;
+
+			// for the user's convenience, parse and store the title separately. The title is between the first T: and the next \n
+			var title = tune.pure.split("T:");
+			if (title.length > 1) {
+				title = title[1].split("\n");
+				tune.title = title[0].replace(/^\s+|\s+$/g, '');
+			} else
+				tune.title = "";
+
+			// for the user's convenience, parse and store the id separately. The id is between the first X: and the next \n
+			var id = tune.pure.substring(2, tune.pure.indexOf("\n"));
+			tune.id = id.replace(/^\s+|\s+$/g, '');
+		});
+	};
 
-ABCJS.TuneBook.prototype.getTuneByTitle = function (title) {
-	for (var i = 0; i < this.tunes.length; i++) {
-		if (this.tunes[i].title === title)
-			return this.tunes[i];
-	}
-	return null;
-};
+	ABCJS.TuneBook.prototype.getTuneById = function(id) {
+		for (var i = 0; i < this.tunes.length; i++) {
+			if (this.tunes[i].id === id)
+				return this.tunes[i];
+		}
+		return null;
+	};
 
-function renderEngine(callback, output, abc, parserParams, renderParams) {
-	var isArray = function(testObject) {
-		return testObject && !(testObject.propertyIsEnumerable('length')) && typeof testObject === 'object' && typeof testObject.length === 'number';
+	ABCJS.TuneBook.prototype.getTuneByTitle = function(title) {
+		for (var i = 0; i < this.tunes.length; i++) {
+			if (this.tunes[i].title === title)
+				return this.tunes[i];
+		}
+		return null;
 	};
 
-	// check and normalize input parameters
-	if (output === undefined || abc === undefined)
-		return;
-	if (!isArray(output))
-		output = [ output ];
-	if (parserParams === undefined)
-		parserParams = {};
-	if (renderParams === undefined)
-		renderParams = {};
-	var currentTune = renderParams.startingTune ? renderParams.startingTune : 0;
-
-	// parse the abc string
-	var book = new ABCJS.TuneBook(abc);
-	var abcParser = new window.ABCJS.parse.Parse();
-
-	// output each tune, if it exists. Otherwise clear the div.
-	for (var i = 0; i < output.length; i++) {
-		var div = output[i];
-		if (typeof(div) === "string")
-			div = document.getElementById(div);
-		if (div) {
-			div.innerHTML = "";
-			if (currentTune < book.tunes.length) {
-				abcParser.parse(book.tunes[currentTune].abc, parserParams);
-				var tune = abcParser.getTune();
-				callback(div, tune);
+	function renderEngine(callback, output, abc, parserParams, renderParams) {
+		var ret = [];
+		var isArray = function(testObject) {
+			return testObject && !(testObject.propertyIsEnumerable('length')) && typeof testObject === 'object' && typeof testObject.length === 'number';
+		};
+
+		// check and normalize input parameters
+		if (output === undefined || abc === undefined)
+			return;
+		if (!isArray(output))
+			output = [ output ];
+		if (parserParams === undefined)
+			parserParams = {};
+		if (renderParams === undefined)
+			renderParams = {};
+		var currentTune = renderParams.startingTune ? renderParams.startingTune : 0;
+
+		// parse the abc string
+		var book = new ABCJS.TuneBook(abc);
+		var abcParser = new window.ABCJS.parse.Parse();
+
+		// output each tune, if it exists. Otherwise clear the div.
+		for (var i = 0; i < output.length; i++) {
+			var div = output[i];
+			if (typeof(div) === "string")
+				div = document.getElementById(div);
+			if (div) {
+				div.innerHTML = "";
+				if (currentTune < book.tunes.length) {
+					abcParser.parse(book.tunes[currentTune].abc, parserParams);
+					var tune = abcParser.getTune();
+					ret.push(tune);
+					callback(div, tune);
+				}
 			}
+			currentTune++;
 		}
-		currentTune++;
+		return ret;
 	}
-}
 
-// A quick way to render a tune from javascript when interactivity is not required.
-// This is used when a javascript routine has some abc text that it wants to render
-// in a div or collection of divs. One tune or many can be rendered.
-//
-// parameters:
-//		output: an array of divs that the individual tunes are rendered to.
-//			If the number of tunes exceeds the number of divs in the array, then
-//			only the first tunes are rendered. If the number of divs exceeds the number
-//			of tunes, then the unused divs are cleared. The divs can be passed as either
-//			elements or strings of ids. If ids are passed, then the div MUST exist already.
-//			(if a single element is passed, then it is an implied array of length one.)
-//			(if a null is passed for an element, or the element doesn't exist, then that tune is skipped.)
-//		abc: text representing a tune or an entire tune book in ABC notation.
-//		renderParams: hash of:
-//			startingTune: an index, starting at zero, representing which tune to start rendering at.
-//				(If this element is not present, then rendering starts at zero.)
-//			width: 800 by default. The width in pixels of the output paper
-ABCJS.renderAbc = function(output, abc, parserParams, printerParams, renderParams) {
-	function callback(div, tune) {
-		var width = renderParams ? renderParams.width ? renderParams.width : 800 : 800;
-		var paper = Raphael(div, width, 400);
-		if (printerParams === undefined)
-			printerParams = {};
-		var printer = new ABCJS.write.Printer(paper, printerParams);
-		printer.printABC(tune);
-	}
+	// A quick way to render a tune from javascript when interactivity is not required.
+	// This is used when a javascript routine has some abc text that it wants to render
+	// in a div or collection of divs. One tune or many can be rendered.
+	//
+	// parameters:
+	//		output: an array of divs that the individual tunes are rendered to.
+	//			If the number of tunes exceeds the number of divs in the array, then
+	//			only the first tunes are rendered. If the number of divs exceeds the number
+	//			of tunes, then the unused divs are cleared. The divs can be passed as either
+	//			elements or strings of ids. If ids are passed, then the div MUST exist already.
+	//			(if a single element is passed, then it is an implied array of length one.)
+	//			(if a null is passed for an element, or the element doesn't exist, then that tune is skipped.)
+	//		abc: text representing a tune or an entire tune book in ABC notation.
+	//		renderParams: hash of:
+	//			startingTune: an index, starting at zero, representing which tune to start rendering at.
+	//				(If this element is not present, then rendering starts at zero.)
+	//			width: 800 by default. The width in pixels of the output paper
+	ABCJS.renderAbc = function(output, abc, parserParams, engraverParams, renderParams) {
+		function callback(div, tune) {
+			var width = renderParams ? renderParams.width ? renderParams.width : 800 : 800;
+			/* jshint -W064 */ var paper = Raphael(div, width, 400); /* jshint +W064 */
+			if (engraverParams === undefined)
+				engraverParams = {};
+			var engraver_controller = new ABCJS.write.Printer(paper, engraverParams);
+			engraver_controller.printABC(tune);
+			tune.engraver = engraver_controller;
+		}
 
-	renderEngine(callback, output, abc, parserParams, renderParams);
-};
+		return renderEngine(callback, output, abc, parserParams, renderParams);
+	};
 
-// A quick way to render a tune from javascript when interactivity is not required.
-// This is used when a javascript routine has some abc text that it wants to render
-// in a div or collection of divs. One tune or many can be rendered.
-//
-// parameters:
-//		output: an array of divs that the individual tunes are rendered to.
-//			If the number of tunes exceeds the number of divs in the array, then
-//			only the first tunes are rendered. If the number of divs exceeds the number
-//			of tunes, then the unused divs are cleared. The divs can be passed as either
-//			elements or strings of ids. If ids are passed, then the div MUST exist already.
-//			(if a single element is passed, then it is an implied array of length one.)
-//			(if a null is passed for an element, or the element doesn't exist, then that tune is skipped.)
-//		abc: text representing a tune or an entire tune book in ABC notation.
-//		renderParams: hash of:
-//			startingTune: an index, starting at zero, representing which tune to start rendering at.
-//				(If this element is not present, then rendering starts at zero.)
-ABCJS.renderMidi = function(output, abc, parserParams, midiParams, renderParams) {
-	function callback(div, tune) {
-		if (midiParams === undefined)
-			midiParams = {};
-		var midiwriter = new ABCJS.midi.MidiWriter(div, midiParams);
-		midiwriter.writeABC(tune);
-	}
+	// A quick way to render a tune from javascript when interactivity is not required.
+	// This is used when a javascript routine has some abc text that it wants to render
+	// in a div or collection of divs. One tune or many can be rendered.
+	//
+	// parameters:
+	//		output: an array of divs that the individual tunes are rendered to.
+	//			If the number of tunes exceeds the number of divs in the array, then
+	//			only the first tunes are rendered. If the number of divs exceeds the number
+	//			of tunes, then the unused divs are cleared. The divs can be passed as either
+	//			elements or strings of ids. If ids are passed, then the div MUST exist already.
+	//			(if a single element is passed, then it is an implied array of length one.)
+	//			(if a null is passed for an element, or the element doesn't exist, then that tune is skipped.)
+	//		abc: text representing a tune or an entire tune book in ABC notation.
+	//		renderParams: hash of:
+	//			startingTune: an index, starting at zero, representing which tune to start rendering at.
+	//				(If this element is not present, then rendering starts at zero.)
+	ABCJS.renderMidi = function(output, abc, parserParams, midiParams, renderParams) {
+		function callback(div, tune) {
+			if (midiParams === undefined)
+				midiParams = {};
+			var midiwriter = new ABCJS.midi.MidiWriter(div, midiParams);
+			midiwriter.writeABC(tune);
+		}
 
-	renderEngine(callback, output, abc, parserParams, renderParams);
-};
+		return renderEngine(callback, output, abc, parserParams, renderParams);
+	};
 })();