abcjs 6.1.9 → 6.2.1

package/src/write/creation/add-chord.js

@@ -0,0 +1,102 @@
+var RelativeElement = require('./elements/relative-element');
+var spacing = require('../helpers/spacing');
+const translateChord = require("./translate-chord");
+
+var addChord = function (getTextSize, abselem, elem, roomTaken, roomTakenRight, noteheadWidth, jazzchords, germanAlphabet) {
+	for (var i = 0; i < elem.chord.length; i++) {
+		var pos = elem.chord[i].position;
+		var rel_position = elem.chord[i].rel_position;
+		var chords = elem.chord[i].name.split("\n");
+		for (var j = chords.length - 1; j >= 0; j--) { // parse these in opposite order because we place them from bottom to top.
+			var chord = chords[j];
+			var x = 0;
+			var y;
+			var font;
+			var klass;
+			if (pos === "left" || pos === "right" || pos === "below" || pos === "above" || !!rel_position) {
+				font = 'annotationfont';
+				klass = "annotation";
+			} else {
+				font = 'gchordfont';
+				klass = "chord";
+				chord = translateChord(chord, jazzchords, germanAlphabet);
+			}
+			var attr = getTextSize.attr(font, klass);
+			var dim = getTextSize.calc(chord, font, klass);
+			var chordWidth = dim.width;
+			var chordHeight = dim.height / spacing.STEP;
+			switch (pos) {
+				case "left":
+					roomTaken += chordWidth + 7;
+					x = -roomTaken;        // TODO-PER: This is just a guess from trial and error
+					y = elem.averagepitch;
+					abselem.addExtra(new RelativeElement(chord, x, chordWidth + 4, y, {
+						type: "text",
+						height: chordHeight,
+						dim: attr,
+						position: "left"
+					}));
+					break;
+				case "right":
+					roomTakenRight += 4;
+					x = roomTakenRight;// TODO-PER: This is just a guess from trial and error
+					y = elem.averagepitch;
+					abselem.addRight(new RelativeElement(chord, x, chordWidth + 4, y, {
+						type: "text",
+						height: chordHeight,
+						dim: attr,
+						position: "right"
+					}));
+					break;
+				case "below":
+					// setting the y-coordinate to undefined for now: it will be overwritten later on, after we figure out what the highest element on the line is.
+					abselem.addRight(new RelativeElement(chord, 0, 0, undefined, {
+						type: "text",
+						position: "below",
+						height: chordHeight,
+						dim: attr,
+						realWidth: chordWidth
+					}));
+					break;
+				case "above":
+					// setting the y-coordinate to undefined for now: it will be overwritten later on, after we figure out what the highest element on the line is.
+					abselem.addRight(new RelativeElement(chord, 0, 0, undefined, {
+						type: "text",
+						position: "above",
+						height: chordHeight,
+						dim: attr,
+						realWidth: chordWidth
+					}));
+					break;
+				default:
+					if (rel_position) {
+						var relPositionY = rel_position.y + 3 * spacing.STEP; // TODO-PER: this is a fudge factor to make it line up with abcm2ps
+						abselem.addRight(new RelativeElement(chord, x + rel_position.x, 0, elem.minpitch + relPositionY / spacing.STEP, {
+							position: "relative",
+							type: "text",
+							height: chordHeight,
+							dim: attr
+						}));
+					} else {
+						// setting the y-coordinate to undefined for now: it will be overwritten later on, after we figure out what the highest element on the line is.
+						var pos2 = 'above';
+						if (elem.positioning && elem.positioning.chordPosition)
+							pos2 = elem.positioning.chordPosition;
+
+						if (pos2 !== 'hidden') {
+							abselem.addCentered(new RelativeElement(chord, noteheadWidth / 2, chordWidth, undefined, {
+								type: "chord",
+								position: pos2,
+								height: chordHeight,
+								dim: attr,
+								realWidth: chordWidth
+							}));
+						}
+					}
+			}
+		}
+	}
+	return { roomTaken: roomTaken, roomTakenRight: roomTakenRight };
+};
+
+module.exports = addChord;

package/src/write/{add-text-if.js → creation/add-text-if.js}

@@ -4,11 +4,11 @@ function addTextIf(rows, params, getTextSize) {
 	if (!params.marginLeft) params.marginLeft = 0;
 	if (!params.klass) params.klass = '';
 	if (!params.anchor) params.anchor = 'start';
-	if (!params.info) params.info = { startChar: -2, endChar: -2}
+	if (!params.info) params.info = { startChar: -2, endChar: -2 }
 
 	if (params.marginTop)
-		rows.push({move: params.marginTop});
-	var attr = {left: params.marginLeft, text: params.text, font: params.font, anchor: params.anchor, startChar: params.info.startChar, endChar: params.info.endChar};
+		rows.push({ move: params.marginTop });
+	var attr = { left: params.marginLeft, text: params.text, font: params.font, anchor: params.anchor, startChar: params.info.startChar, endChar: params.info.endChar };
 	if (params.absElemType)
 		attr.absElemType = params.absElemType;
 	if (!params.inGroup)
@@ -20,13 +20,13 @@ function addTextIf(rows, params, getTextSize) {
 	// If there are blank lines they won't be counted by getTextSize, so just get the height of one line and multiply
 	var size = getTextSize.calc("A", params.font, params.klass);
 	var numLines = params.text.split("\n").length;
-	if (params.text[params.text.length-1] === '\n')
+	if (params.text[params.text.length - 1] === '\n')
 		numLines--; // If there is a new line at the end of the string, then an extra line will be counted.
 	if (!params.noMove) {
 		var h = (size.height * 1.1) * numLines;
-		rows.push({move: Math.round(h)});
+		rows.push({ move: Math.round(h) });
 		if (params.marginBottom)
-			rows.push({move: params.marginBottom});
+			rows.push({ move: params.marginBottom });
 	}
 }
 

package/src/write/{calcHeight.js → creation/calc-height.js}

@@ -2,12 +2,12 @@ var calcHeight = function (staffGroup) {
 	// the height is calculated here in a parallel way to the drawing below in hopes that both of these functions will be modified together.
 	// TODO-PER: also add the space between staves. (That's systemStaffSeparation, which is the minimum distance between the staff LINES.)
 	var height = 0;
-	for (var i=0;i<staffGroup.voices.length;i++) {
+	for (var i = 0; i < staffGroup.voices.length; i++) {
 		var staff = staffGroup.voices[i].staff;
 		if (!staffGroup.voices[i].duplicate) {
 			height += staff.top;
 			//if (staff.bottom < 0)
-				height += -staff.bottom;
+			height += -staff.bottom;
 		}
 	}
 	return height;

package/src/write/creation/create-clef.js

@@ -0,0 +1,72 @@
+//    abc_create_clef.js
+
+var AbsoluteElement = require('./elements/absolute-element');
+var glyphs = require('./glyphs');
+var RelativeElement = require('./elements/relative-element');
+
+var createClef = function (elem, tuneNumber) {
+	var clef;
+	var octave = 0;
+	elem.el_type = "clef";
+	var abselem = new AbsoluteElement(elem, 0, 10, 'staff-extra clef', tuneNumber);
+	abselem.isClef = true;
+	switch (elem.type) {
+		case "treble": clef = "clefs.G"; break;
+		case "tenor": clef = "clefs.C"; break;
+		case "alto": clef = "clefs.C"; break;
+		case "bass": clef = "clefs.F"; break;
+		case 'treble+8': clef = "clefs.G"; octave = 1; break;
+		case 'tenor+8': clef = "clefs.C"; octave = 1; break;
+		case 'bass+8': clef = "clefs.F"; octave = 1; break;
+		case 'alto+8': clef = "clefs.C"; octave = 1; break;
+		case 'treble-8': clef = "clefs.G"; octave = -1; break;
+		case 'tenor-8': clef = "clefs.C"; octave = -1; break;
+		case 'bass-8': clef = "clefs.F"; octave = -1; break;
+		case 'alto-8': clef = "clefs.C"; octave = -1; break;
+		case 'none': return null;
+		case 'perc': clef = "clefs.perc"; break;
+		default: abselem.addFixed(new RelativeElement("clef=" + elem.type, 0, 0, undefined, { type: "debug" }));
+	}
+	// if (elem.verticalPos) {
+	// pitch = elem.verticalPos;
+	// }
+	var dx = 5;
+	if (clef) {
+		var height = glyphs.symbolHeightInPitches(clef);
+		var ofs = clefOffsets(clef);
+		abselem.addRight(new RelativeElement(clef, dx, glyphs.getSymbolWidth(clef), elem.clefPos, { top: height + elem.clefPos + ofs, bottom: elem.clefPos + ofs }));
+
+		if (octave !== 0) {
+			var scale = 2 / 3;
+			var adjustspacing = (glyphs.getSymbolWidth(clef) - glyphs.getSymbolWidth("8") * scale) / 2;
+			var pitch = (octave > 0) ? abselem.top + 3 : abselem.bottom - 1;
+			var top = (octave > 0) ? abselem.top + 3 : abselem.bottom - 3;
+			var bottom = top - 2;
+			if (elem.type === "bass-8") {
+				// The placement for bass octave is a little different. It should hug the clef.
+				pitch = 3;
+				adjustspacing = 0;
+			}
+			abselem.addRight(new RelativeElement("8", dx + adjustspacing, glyphs.getSymbolWidth("8") * scale, pitch, {
+				scalex: scale,
+				scaley: scale,
+				top: top,
+				bottom: bottom
+			}));
+			//abselem.top += 2;
+		}
+	}
+	return abselem;
+};
+
+function clefOffsets(clef) {
+	switch (clef) {
+		case "clefs.G": return -5;
+		case "clefs.C": return -4;
+		case "clefs.F": return -4;
+		case "clefs.perc": return -2;
+		default: return 0;
+	}
+}
+
+module.exports = createClef;

package/src/write/creation/create-key-signature.js

@@ -0,0 +1,31 @@
+//    abc_create_key_signature.js
+
+var AbsoluteElement = require('./elements/absolute-element');
+var glyphs = require('./glyphs');
+var RelativeElement = require('./elements/relative-element');
+
+var createKeySignature = function (elem, tuneNumber) {
+	elem.el_type = "keySignature";
+	if (!elem.accidentals || elem.accidentals.length === 0)
+		return null;
+	var abselem = new AbsoluteElement(elem, 0, 10, 'staff-extra key-signature', tuneNumber);
+	abselem.isKeySig = true;
+	var dx = 0;
+	elem.accidentals.forEach(function (acc) {
+		var symbol;
+		var fudge = 0;
+		switch (acc.acc) {
+			case "sharp": symbol = "accidentals.sharp"; fudge = -3; break;
+			case "natural": symbol = "accidentals.nat"; break;
+			case "flat": symbol = "accidentals.flat"; fudge = -1.2; break;
+			case "quartersharp": symbol = "accidentals.halfsharp"; fudge = -2.5; break;
+			case "quarterflat": symbol = "accidentals.halfflat"; fudge = -1.2; break;
+			default: symbol = "accidentals.flat";
+		}
+		abselem.addRight(new RelativeElement(symbol, dx, glyphs.getSymbolWidth(symbol), acc.verticalPos, { thickness: glyphs.symbolHeightInPitches(symbol), top: acc.verticalPos + glyphs.symbolHeightInPitches(symbol) + fudge, bottom: acc.verticalPos + fudge }));
+		dx += glyphs.getSymbolWidth(symbol) + 2;
+	}, this);
+	return abselem;
+};
+
+module.exports = createKeySignature;

package/src/write/creation/create-note-head.js

@@ -0,0 +1,107 @@
+var glyphs = require('./glyphs');
+var RelativeElement = require('./elements/relative-element');
+
+var createNoteHead = function (abselem, c, pitchelem, options) {
+	if (!options) options = {};
+	var dir = (options.dir !== undefined) ? options.dir : null;
+	var headx = (options.headx !== undefined) ? options.headx : 0;
+	var extrax = (options.extrax !== undefined) ? options.extrax : 0;
+	var flag = (options.flag !== undefined) ? options.flag : null;
+	var dot = (options.dot !== undefined) ? options.dot : 0;
+	var dotshiftx = (options.dotshiftx !== undefined) ? options.dotshiftx : 0;
+	var scale = (options.scale !== undefined) ? options.scale : 1;
+	var accidentalSlot = (options.accidentalSlot !== undefined) ? options.accidentalSlot : [];
+	var shouldExtendStem = (options.shouldExtendStem !== undefined) ? options.shouldExtendStem : false;
+	var printAccidentals = (options.printAccidentals !== undefined) ? options.printAccidentals : true;
+
+	// TODO scale the dot as well
+	var pitch = pitchelem.verticalPos;
+	var notehead;
+	var accidentalshiftx = 0;
+	var newDotShiftX = 0;
+	var extraLeft = 0;
+	if (c === undefined)
+		abselem.addFixed(new RelativeElement("pitch is undefined", 0, 0, 0, { type: "debug" }));
+	else if (c === "") {
+		notehead = new RelativeElement(null, 0, 0, pitch);
+	} else {
+		var shiftheadx = headx;
+		if (pitchelem.printer_shift) {
+			var adjust = (pitchelem.printer_shift === "same") ? 1 : 0;
+			shiftheadx = (dir === "down") ? -glyphs.getSymbolWidth(c) * scale + adjust : glyphs.getSymbolWidth(c) * scale - adjust;
+		}
+		var opts = { scalex: scale, scaley: scale, thickness: glyphs.symbolHeightInPitches(c) * scale, name: pitchelem.name };
+		notehead = new RelativeElement(c, shiftheadx, glyphs.getSymbolWidth(c) * scale, pitch, opts);
+		notehead.stemDir = dir;
+		if (flag) {
+			var pos = pitch + ((dir === "down") ? -7 : 7) * scale;
+			// if this is a regular note, (not grace or tempo indicator) then the stem will have been stretched to the middle line if it is far from the center.
+			if (shouldExtendStem) {
+				if (dir === "down" && pos > 6)
+					pos = 6;
+				if (dir === "up" && pos < 6)
+					pos = 6;
+			}
+			//if (scale===1 && (dir==="down")?(pos>6):(pos<6)) pos=6;
+			var xdelta = (dir === "down") ? headx : headx + notehead.w - 0.6;
+			abselem.addRight(new RelativeElement(flag, xdelta, glyphs.getSymbolWidth(flag) * scale, pos, { scalex: scale, scaley: scale }));
+		}
+		newDotShiftX = notehead.w + dotshiftx - 2 + 5 * dot;
+		for (; dot > 0; dot--) {
+			var dotadjusty = (1 - Math.abs(pitch) % 2); //PER: take abs value of the pitch. And the shift still happens on ledger lines.
+			abselem.addRight(new RelativeElement("dots.dot", notehead.w + dotshiftx - 2 + 5 * dot, glyphs.getSymbolWidth("dots.dot"), pitch + dotadjusty));
+		}
+	}
+	if (notehead)
+		notehead.highestVert = pitchelem.highestVert;
+
+	if (printAccidentals && pitchelem.accidental) {
+		var symb;
+		switch (pitchelem.accidental) {
+			case "quartersharp":
+				symb = "accidentals.halfsharp";
+				break;
+			case "dblsharp":
+				symb = "accidentals.dblsharp";
+				break;
+			case "sharp":
+				symb = "accidentals.sharp";
+				break;
+			case "quarterflat":
+				symb = "accidentals.halfflat";
+				break;
+			case "flat":
+				symb = "accidentals.flat";
+				break;
+			case "dblflat":
+				symb = "accidentals.dblflat";
+				break;
+			case "natural":
+				symb = "accidentals.nat";
+		}
+		// if a note is at least a sixth away, it can share a slot with another accidental
+		var accSlotFound = false;
+		var accPlace = extrax;
+		for (var j = 0; j < accidentalSlot.length; j++) {
+			if (pitch - accidentalSlot[j][0] >= 6) {
+				accidentalSlot[j][0] = pitch;
+				accPlace = accidentalSlot[j][1];
+				accSlotFound = true;
+				break;
+			}
+		}
+		if (accSlotFound === false) {
+			accPlace -= (glyphs.getSymbolWidth(symb) * scale + 2);
+			accidentalSlot.push([pitch, accPlace]);
+			accidentalshiftx = (glyphs.getSymbolWidth(symb) * scale + 2);
+		}
+		var h = glyphs.symbolHeightInPitches(symb);
+		abselem.addExtra(new RelativeElement(symb, accPlace, glyphs.getSymbolWidth(symb), pitch, { scalex: scale, scaley: scale, top: pitch + h / 2, bottom: pitch - h / 2 }));
+		extraLeft = glyphs.getSymbolWidth(symb) / 2; // TODO-PER: We need a little extra width if there is an accidental, but I'm not sure why it isn't the full width of the accidental.
+	}
+
+	return { notehead: notehead, accidentalshiftx: accidentalshiftx, dotshiftx: newDotShiftX, extraLeft: extraLeft };
+
+};
+
+module.exports = createNoteHead;

package/src/write/creation/create-time-signature.js

@@ -0,0 +1,55 @@
+//    abc_create_time_signature.js
+
+var AbsoluteElement = require('./elements/absolute-element');
+var glyphs = require('./glyphs');
+var RelativeElement = require('./elements/relative-element');
+
+var createTimeSignature = function (elem, tuneNumber) {
+	elem.el_type = "timeSignature";
+	var abselem = new AbsoluteElement(elem, 0, 10, 'staff-extra time-signature', tuneNumber);
+	if (elem.type === "specified") {
+		var x = 0;
+		for (var i = 0; i < elem.value.length; i++) {
+			if (i !== 0) {
+				abselem.addRight(new RelativeElement('+', x + 1, glyphs.getSymbolWidth("+"), 6, { thickness: glyphs.symbolHeightInPitches("+") }));
+				x += glyphs.getSymbolWidth("+") + 2;
+			}
+			if (elem.value[i].den) {
+				var numWidth = 0;
+				for (var i2 = 0; i2 < elem.value[i].num.length; i2++)
+					numWidth += glyphs.getSymbolWidth(elem.value[i].num[i2]);
+				var denWidth = 0;
+				for (i2 = 0; i2 < elem.value[i].num.length; i2++)
+					denWidth += glyphs.getSymbolWidth(elem.value[i].den[i2]);
+				var maxWidth = Math.max(numWidth, denWidth);
+				abselem.addRight(new RelativeElement(elem.value[i].num, x + (maxWidth - numWidth) / 2, numWidth, 8, { thickness: glyphs.symbolHeightInPitches(elem.value[i].num[0]) }));
+				abselem.addRight(new RelativeElement(elem.value[i].den, x + (maxWidth - denWidth) / 2, denWidth, 4, { thickness: glyphs.symbolHeightInPitches(elem.value[i].den[0]) }));
+				x += maxWidth
+			} else {
+				var thisWidth = 0;
+				for (var i3 = 0; i3 < elem.value[i].num.length; i3++)
+					thisWidth += glyphs.getSymbolWidth(elem.value[i].num[i3]);
+				abselem.addRight(new RelativeElement(elem.value[i].num, x, thisWidth, 6, { thickness: glyphs.symbolHeightInPitches(elem.value[i].num[0]) }));
+				x += thisWidth;
+			}
+		}
+	} else if (elem.type === "common_time") {
+		abselem.addRight(new RelativeElement("timesig.common", 0, glyphs.getSymbolWidth("timesig.common"), 6, { thickness: glyphs.symbolHeightInPitches("timesig.common") }));
+
+	} else if (elem.type === "cut_time") {
+		abselem.addRight(new RelativeElement("timesig.cut", 0, glyphs.getSymbolWidth("timesig.cut"), 6, { thickness: glyphs.symbolHeightInPitches("timesig.cut") }));
+	} else if (elem.type === "tempus_imperfectum") {
+		abselem.addRight(new RelativeElement("timesig.imperfectum", 0, glyphs.getSymbolWidth("timesig.imperfectum"), 6, { thickness: glyphs.symbolHeightInPitches("timesig.imperfectum") }));
+	} else if (elem.type === "tempus_imperfectum_prolatio") {
+		abselem.addRight(new RelativeElement("timesig.imperfectum2", 0, glyphs.getSymbolWidth("timesig.imperfectum2"), 6, { thickness: glyphs.symbolHeightInPitches("timesig.imperfectum2") }));
+	} else if (elem.type === "tempus_perfectum") {
+		abselem.addRight(new RelativeElement("timesig.perfectum", 0, glyphs.getSymbolWidth("timesig.perfectum"), 6, { thickness: glyphs.symbolHeightInPitches("timesig.perfectum") }));
+	} else if (elem.type === "tempus_perfectum_prolatio") {
+		abselem.addRight(new RelativeElement("timesig.perfectum2", 0, glyphs.getSymbolWidth("timesig.perfectum2"), 6, { thickness: glyphs.symbolHeightInPitches("timesig.perfectum2") }));
+	} else {
+		console.log("time signature:", elem);
+	}
+	return abselem;
+};
+
+module.exports = createTimeSignature;