abcjs 6.0.0-beta.9 → 6.0.2

package/src/data/deline-tune.js

@@ -0,0 +1,199 @@
+function delineTune(inputLines, options) {
+	if (!options) options = {};
+	var lineBreaks = !!options.lineBreaks;
+	var outputLines = [];
+	var inMusicLine = false;
+	var currentMeter = [];
+	var currentKey = [];
+	var currentClef = [];
+	var currentVocalFont = [];
+	var currentGChordFont = [];
+	var currentTripletFont = [];
+	var currentAnnotationFont = [];
+	for (var i = 0; i < inputLines.length; i++) {
+		var inputLine = inputLines[i];
+		if (inputLine.staff) {
+			if (inMusicLine && !inputLine.vskip) {
+				var outputLine = outputLines[outputLines.length-1];
+				//findMismatchKeys(inputLine, outputLine, ["staff", "staffGroup"], "line", i)
+				for (var s = 0; s < outputLine.staff.length; s++) {
+					var inputStaff = inputLine.staff[s];
+					var outputStaff = outputLine.staff[s];
+					if (inputStaff) {
+						if (!objEqual(inputStaff.meter, currentMeter[s])) {
+							// The meter changed for this line, otherwise it wouldn't have been set
+							addMeterToVoices(inputStaff.meter, inputStaff.voices)
+							currentMeter[s] = inputStaff.meter;
+							delete inputStaff.meter;
+						}
+						if (!objEqual(inputStaff.key, currentKey[s])) {
+							addKeyToVoices(inputStaff.key, inputStaff.voices);
+							currentKey[s] = inputStaff.key;
+							delete inputStaff.key;
+						}
+						if (inputStaff.title)
+							outputStaff.abbrevTitle = inputStaff.title;
+						if (!objEqual(inputStaff.clef, currentClef[s])) {
+							addClefToVoices(inputStaff.clef, inputStaff.voices);
+							currentClef[s] = inputStaff.clef;
+							delete inputStaff.clef;
+						}
+						if (!objEqual(inputStaff.vocalfont, currentVocalFont[s])) {
+							addFontToVoices(inputStaff.vocalfont, inputStaff.voices, 'vocalfont')
+							currentVocalFont[s] = inputStaff.vocalfont;
+							delete inputStaff.vocalfont;
+						}
+						if (!objEqual(inputStaff.gchordfont, currentGChordFont[s])) {
+							addFontToVoices(inputStaff.gchordfont, inputStaff.voices, 'gchordfont')
+							currentGChordFont[s] = inputStaff.gchordfont;
+							delete inputStaff.gchordfont;
+						}
+						if (!objEqual(inputStaff.tripletfont, currentTripletFont[s])) {
+							addFontToVoices(inputStaff.tripletfont, inputStaff.voices, 'tripletfont')
+							currentTripletFont[s] = inputStaff.tripletfont;
+							delete inputStaff.tripletfont;
+						}
+						if (!objEqual(inputStaff.annotationfont, currentAnnotationFont[s])) {
+							addFontToVoices(inputStaff.annotationfont, inputStaff.voices, 'annotationfont')
+							currentAnnotationFont[s] = inputStaff.annotationfont;
+							delete inputStaff.annotationfont;
+						}
+					}
+					//findMismatchKeys(inputStaff, outputStaff, ["voices", "title", "abbrevTitle", "barNumber", "meter", "key", "clef", "vocalfont", "gchordfont", "tripletfont", "annotationfont"], "staff", i + ' ' + s)
+					if (inputStaff) {
+						for (var v = 0; v < outputStaff.voices.length; v++) {
+							var outputVoice = outputStaff.voices[v];
+							var inputVoice = inputStaff.voices[v];
+							if (lineBreaks)
+								outputVoice.push({el_type: "break"});
+							if (inputVoice)
+								outputStaff.voices[v] = outputVoice.concat(inputVoice)
+						}
+					}
+				}
+			} else {
+				for (var ii = 0; ii < inputLine.staff.length; ii++) {
+					currentKey[ii] = inputLine.staff[ii].key;
+					currentMeter[ii] = inputLine.staff[ii].meter;
+					currentClef[ii] = inputLine.staff[ii].clef;
+				}
+				// copy this because we are going to change it and we don't want to change the original.
+				outputLines.push(cloneLine(inputLine));
+			}
+			inMusicLine = true;
+		} else {
+			inMusicLine = false;
+			outputLines.push(inputLine);
+		}
+	}
+	return outputLines;
+}
+// function findMismatchKeys(input, output, ignore, context, context2) {
+// 	if (!input) {
+// 		return;
+// 	}
+// 	var outputKeys = Object.keys(output);
+// 	var inputKeys = Object.keys(input);
+// 	for (var ii = 0; ii < ignore.length; ii++) {
+// 		if (outputKeys.indexOf(ignore[ii]) >= 0) {
+// 			outputKeys.splice(outputKeys.indexOf(ignore[ii]), 1);
+// 		}
+// 		if (inputKeys.indexOf(ignore[ii]) >= 0) {
+// 			inputKeys.splice(inputKeys.indexOf(ignore[ii]), 1);
+// 		}
+// 	}
+// 	if (inputKeys.join(",") !== outputKeys.join(",")) {
+// 		console.log("keys mismatch "+context + ' ' + context2, input, output);
+// 	}
+// 	for (var k = 0; k < inputKeys.length; k++) {
+// 		var key = inputKeys[k];
+// 		if (ignore.indexOf(key) < 0) {
+// 			var inputValue = JSON.stringify(input[key], replacer);
+// 			var outputValue = JSON.stringify(output[key], replacer);
+// 			if (inputValue !== outputValue)
+// 				console.log("value mismatch "+context + ' ' + context2 + ' ' + key, inputValue, outputValue)
+// 		}
+// 	}
+// }
+function replacer(key, value) {
+	// Filtering out properties
+	if (key === 'abselem') {
+		return 'abselem';
+	}
+	return value;
+}
+
+function addMeterToVoices(meter, voices) {
+	meter.el_type = "meter";
+	meter.startChar = -1;
+	meter.endChar = -1;
+	for (var i = 0; i < voices.length; i++) {
+		voices[i].unshift(meter);
+	}
+}
+
+function addKeyToVoices(key, voices) {
+	key.el_type = "key";
+	key.startChar = -1;
+	key.endChar = -1;
+	for (var i = 0; i < voices.length; i++) {
+		voices[i].unshift(key);
+	}
+}
+
+function addClefToVoices(clef, voices) {
+	clef.el_type = "clef";
+	clef.startChar = -1;
+	clef.endChar = -1;
+	for (var i = 0; i < voices.length; i++) {
+		voices[i].unshift(clef);
+	}
+}
+
+function addFontToVoices(font, voices, type) {
+	font.el_type = "font";
+	font.type = type;
+	font.startChar = -1;
+	font.endChar = -1;
+	for (var i = 0; i < voices.length; i++) {
+		voices[i].unshift(font);
+	}
+}
+
+function objEqual(input, output) {
+	if (!input)
+		return true; // the default is whatever the old output is.
+	var inputValue = JSON.stringify(input, replacer);
+	var outputValue = JSON.stringify(output, replacer);
+	return inputValue === outputValue;
+}
+
+function cloneLine(line) {
+	var output = {};
+	var keys = Object.keys(line);
+	for (var i = 0; i < keys.length; i++) {
+		if (keys[i] !== "staff")
+			output[keys[i]] = line[keys[i]];
+		else {
+			output.staff = [];
+			for (var j = 0; j < line.staff.length; j++) {
+				var staff = {};
+				var keys2 = Object.keys(line.staff[j]);
+				for (var k = 0; k < keys2.length; k++) {
+					if (keys2[k] !== "voices")
+						staff[keys2[k]] = line.staff[j][keys2[k]];
+					else {
+						staff.voices = [];
+						for (var v = 0; v < line.staff[j].voices.length; v++) {
+							staff.voices.push([].concat(line.staff[j].voices[v]));
+						}
+					}
+				}
+				output.staff.push(staff)
+			}
+		}
+	}
+	return output;
+}
+
+module.exports = delineTune;

package/src/edit/abc_editarea.js

@@ -0,0 +1,112 @@
+// abc_editor.js
+
+// window.ABCJS.Editor is the interface class for the area that contains the ABC text. It is responsible for
+// holding the text of the tune and calling the parser and the rendering engines.
+//
+// EditArea is an example of using a textarea as the control that is shown to the user. As long as
+// the same interface is used, window.ABCJS.Editor can use a different type of object.
+//
+// EditArea:
+// - constructor(textareaid)
+//		This contains the id of a textarea control that will be used.
+// - addSelectionListener(listener)
+//		A callback class that contains the entry point fireSelectionChanged()
+// - addChangeListener(listener)
+//		A callback class that contains the entry point fireChanged()
+// - getSelection()
+//		returns the object { start: , end: } with the current selection in characters
+// - setSelection(start, end)
+//		start and end are the character positions that should be selected.
+// - getString()
+//		returns the ABC text that is currently displayed.
+// - setString(str)
+//		sets the ABC text that is currently displayed, and resets the initialText variable
+// - getElem()
+//		returns the textarea element
+// - string initialText
+//		Contains the starting text. This can be compared against the current text to see if anything changed.
+//
+
+// Polyfill for CustomEvent for old IE versions
+try {
+	if (typeof window.CustomEvent !== "function") {
+		var CustomEvent = function (event, params) {
+			params = params || {bubbles: false, cancelable: false, detail: undefined};
+			var evt = document.createEvent('CustomEvent');
+			evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
+			return evt;
+		};
+		CustomEvent.prototype = window.Event.prototype;
+		window.CustomEvent = CustomEvent;
+	}
+} catch (e) {
+	// if we aren't in a browser, this code will crash, but it is not needed then either.
+}
+
+var EditArea = function(textareaid) {
+  this.textarea = document.getElementById(textareaid);
+  this.initialText = this.textarea.value;
+  this.isDragging = false;
+}
+
+EditArea.prototype.addSelectionListener = function(listener) {
+  this.textarea.onmousemove = function(ev) {
+	  if (this.isDragging)
+	    listener.fireSelectionChanged();
+  };
+};
+
+EditArea.prototype.addChangeListener = function(listener) {
+  this.changelistener = listener;
+  this.textarea.onkeyup = function() {
+    listener.fireChanged();
+  };
+  this.textarea.onmousedown = function() {
+	this.isDragging = true;
+    listener.fireSelectionChanged();
+  };
+  this.textarea.onmouseup = function() {
+	this.isDragging = false;
+    listener.fireChanged();
+  };
+  this.textarea.onchange = function() {
+    listener.fireChanged();
+  };
+};
+
+//TODO won't work under IE?
+EditArea.prototype.getSelection = function() {
+  return {start: this.textarea.selectionStart, end: this.textarea.selectionEnd};
+};
+
+EditArea.prototype.setSelection = function(start, end) {
+	if(this.textarea.setSelectionRange)
+	   this.textarea.setSelectionRange(start, end);
+	else if(this.textarea.createTextRange) {
+		// For IE8
+	   var e = this.textarea.createTextRange();
+	   e.collapse(true);
+	   e.moveEnd('character', end);
+	   e.moveStart('character', start);
+	   e.select();
+	}
+  this.textarea.focus();
+};
+
+EditArea.prototype.getString = function() {
+  return this.textarea.value;
+};
+
+EditArea.prototype.setString = function(str) {
+  this.textarea.value = str;
+  this.initialText = this.getString();
+  if (this.changelistener) {
+    this.changelistener.fireChanged();
+  }
+};
+
+EditArea.prototype.getElem = function() {
+  return this.textarea;
+};
+
+module.exports = EditArea;