abcjs 6.0.0-beta.7 → 6.0.0

package/src/write/draw/text.js

@@ -0,0 +1,71 @@
+var roundNumber = require("./round-number");
+
+function renderText(renderer, params, alreadyInGroup) {
+	var y = params.y;
+	if (params.lane) {
+		var laneMargin = params.dim.font.size*0.25;
+		y += (params.dim.font.size + laneMargin) * params.lane;
+	}
+
+	var hash;
+	if (params.dim) {
+		hash = params.dim;
+		hash.attr.class = params.klass;
+	} else
+		 hash = renderer.controller.getFontAndAttr.calc(params.type, params.klass);
+	if (params.anchor)
+		hash.attr["text-anchor"] = params.anchor;
+	hash.attr.x = params.x;
+	hash.attr.y = y;
+	if (!params.centerVertically)
+		hash.attr.y += hash.font.size;
+	if (params.type === 'debugfont') {
+		console.log("Debug msg: " + params.text);
+		hash.attr.stroke = "#ff0000";
+	}
+	if (params.cursor) {
+		hash.attr.cursor = params.cursor;
+	}
+
+	var text = params.text.replace(/\n\n/g, "\n \n");
+	text = text.replace(/^\n/, "\xA0\n");
+
+	if (hash.font.box) {
+		if (!alreadyInGroup)
+			renderer.paper.openGroup({klass: hash.attr['class'], fill: renderer.foregroundColor, "data-name": params.name});
+		if (hash.attr["text-anchor"] === "end") {
+			hash.attr.x -= hash.font.padding;
+		} else if (hash.attr["text-anchor"] === "start") {
+			hash.attr.x += hash.font.padding;
+		}
+		hash.attr.y += hash.font.padding;
+		delete hash.attr['class'];
+	}
+	if (params.noClass)
+		delete hash.attr['class'];
+	hash.attr.x = roundNumber(hash.attr.x);
+	hash.attr.y = roundNumber(hash.attr.y);
+	if (params.name)
+		hash.attr["data-name"] = params.name;
+	var elem = renderer.paper.text(text, hash.attr);
+	if (hash.font.box) {
+		var size = elem.getBBox();
+
+		var delta = 0;
+		if (hash.attr["text-anchor"] === "middle") {
+		 	delta = size.width / 2 + hash.font.padding;
+		} else if (hash.attr["text-anchor"] === "end") {
+			delta = size.width + hash.font.padding * 2;
+		}
+		var deltaY = 0;
+		if (params.centerVertically) {
+			deltaY = size.height - hash.font.padding;
+		}
+		renderer.paper.rect({ "data-name": "box", x: Math.round(params.x - delta), y: Math.round(y - deltaY), width: Math.round(size.width + hash.font.padding*2), height: Math.round(size.height + hash.font.padding*2)});
+		if (!alreadyInGroup)
+			elem = renderer.paper.closeGroup();
+	}
+	return elem;
+}
+
+module.exports = renderText;

package/src/write/draw/tie.js

@@ -0,0 +1,97 @@
+var sprintf = require('./sprintf');
+var roundNumber = require("./round-number");
+
+function drawTie(renderer, params, linestartx, lineendx, selectables) {
+	layout(params, linestartx, lineendx);
+
+	var klass = '';
+	if (params.anchor1) {
+		klass += 'abcjs-start-m' + params.anchor1.parent.counters.measure + '-n' + params.anchor1.parent.counters.note;
+	} else
+		klass += 'abcjs-start-edge';
+	if (params.anchor2) {
+		klass += ' abcjs-end-m' + params.anchor2.parent.counters.measure + '-n' + params.anchor2.parent.counters.note;
+	} else
+		klass += ' abcjs-end-edge';
+	if (params.hint)
+		klass = "abcjs-hint";
+	var fudgeY =  params.fixedY ? 1.5 : 0; // TODO-PER: This just compensates for drawArc, which contains too much knowledge of ties and slurs.
+	var el = drawArc(renderer, params.startX, params.endX, params.startY+fudgeY, params.endY+fudgeY,  params.above, klass, params.isTie, params.dotted);
+	selectables.wrapSvgEl({ el_type: "slur", startChar: -1, endChar: -1 }, el);
+	return [el];
+}
+
+// TODO-PER: I think params part should have been done earlier in the layout pass.
+var layout = function (params, lineStartX, lineEndX) {
+	// We now have all of the input variables set, so we can figure out the start and ending x,y coordinates, and finalize the direction of the arc.
+
+	// Ties and slurs are handled a little differently, so do calculations for them separately.
+	if (!params.anchor1 || !params.anchor2)
+		params.isTie = true; // if the slur goes off the end of the line, then draw it like a tie
+	else if (params.anchor1.pitch === params.anchor2.pitch && params.internalNotes.length === 0)
+		params.isTie = true;
+	else
+		params.isTie = false;
+
+	if (params.isTie) {
+		params.calcTieDirection();
+		params.calcX(lineStartX, lineEndX);
+		params.calcTieY();
+
+	} else {
+		params.calcSlurDirection();
+		params.calcX(lineStartX, lineEndX);
+		params.calcSlurY();
+	}
+	params.avoidCollisionAbove();
+};
+
+var drawArc = function(renderer, x1, x2, pitch1, pitch2, above, klass, isTie, dotted) {
+	// If it is a tie vs. a slur, draw it shallower.
+	var spacing = isTie ? 1.2 : 1.5;
+
+	x1 = roundNumber(x1 + 6);
+	x2 = roundNumber(x2 + 4);
+	pitch1 = pitch1 + ((above)?spacing:-spacing);
+	pitch2 = pitch2 + ((above)?spacing:-spacing);
+	var y1 = roundNumber(renderer.calcY(pitch1));
+	var y2 = roundNumber(renderer.calcY(pitch2));
+
+	//unit direction vector
+	var dx = x2-x1;
+	var dy = y2-y1;
+	var norm= Math.sqrt(dx*dx+dy*dy);
+	var ux = dx/norm;
+	var uy = dy/norm;
+
+	var flatten = norm/3.5;
+	var maxFlatten = isTie ? 10 : 25;  // If it is a tie vs. a slur, draw it shallower.
+	var curve = ((above)?-1:1)*Math.min(maxFlatten, Math.max(4, flatten));
+
+	var controlx1 = roundNumber(x1+flatten*ux-curve*uy);
+	var controly1 = roundNumber(y1+flatten*uy+curve*ux);
+	var controlx2 = roundNumber(x2-flatten*ux-curve*uy);
+	var controly2 = roundNumber(y2-flatten*uy+curve*ux);
+	var thickness = 2;
+	if (klass)
+		klass += ' slur';
+	else
+		klass = 'slur';
+	klass += isTie ? ' tie' : ' legato';
+	var ret;
+	if (dotted) {
+		klass += ' dotted';
+		var pathString2 = sprintf("M %f %f C %f %f %f %f %f %f", x1, y1,
+			controlx1, controly1, controlx2, controly2, x2, y2);
+		ret = renderer.paper.path({path:pathString2, stroke:renderer.foregroundColor, fill:"none", 'stroke-dasharray': "5 5", 'class': renderer.controller.classes.generate(klass), "data-name": isTie ? "tie" : "slur"});
+	} else {
+		var pathString = sprintf("M %f %f C %f %f %f %f %f %f C %f %f %f %f %f %f z", x1, y1,
+			controlx1, controly1, controlx2, controly2, x2, y2,
+			roundNumber(controlx2 - thickness * uy), roundNumber(controly2 + thickness * ux), roundNumber(controlx1 - thickness * uy), roundNumber(controly1 + thickness * ux), x1, y1);
+		ret = renderer.paper.path({path:pathString, stroke:"none", fill:renderer.foregroundColor, 'class': renderer.controller.classes.generate(klass), "data-name": isTie ? "tie" : "slur"});
+	}
+
+	return ret;
+};
+
+module.exports = drawTie;

package/src/write/draw/triplet.js

@@ -0,0 +1,46 @@
+var sprintf = require('./sprintf');
+var renderText = require('./text');
+var printPath = require('./print-path');
+var roundNumber = require("./round-number");
+
+function drawTriplet(renderer, params, selectables) {
+	renderer.paper.openGroup({ klass: renderer.controller.classes.generate('triplet '+params.durationClass), "data-name": "triplet"});
+	if (!params.hasBeam) {
+		drawBracket(renderer, params.anchor1.x, params.startNote, params.anchor2.x + params.anchor2.w, params.endNote);
+	}
+	// HACK: adjust the position of "3". It is too high in all cases so we fudge it by subtracting 1 here.
+	renderText(renderer, {x: params.xTextPos, y: renderer.calcY(params.yTextPos - 1), text: "" + params.number, type: 'tripletfont', anchor: "middle", centerVertically: true, noClass: true, name: ""+params.number}, true);
+	var g = renderer.paper.closeGroup();
+	selectables.wrapSvgEl({ el_type: "triplet", startChar: -1, endChar: -1 }, g);
+	return g;
+}
+
+function drawLine(l, t, r, b) {
+	return sprintf("M %f %f L %f %f", roundNumber(l), roundNumber(t), roundNumber(r), roundNumber(b));
+}
+
+function drawBracket(renderer, x1, y1, x2, y2) {
+	y1 = renderer.calcY(y1);
+	y2 = renderer.calcY(y2);
+	var bracketHeight = 5;
+
+	// Draw vertical lines at the beginning and end
+	var pathString = "";
+	pathString += drawLine(x1, y1, x1, y1 + bracketHeight);
+	pathString += drawLine(x2, y2, x2, y2 + bracketHeight);
+
+	// figure out midpoints to draw the broken line.
+	var midX = x1 + (x2-x1)/2;
+	//var midY = y1 + (y2-y1)/2;
+	var gapWidth = 8;
+	var slope = (y2 - y1) / (x2 - x1);
+	var leftEndX = midX - gapWidth;
+	var leftEndY = y1 + (leftEndX - x1) * slope;
+	pathString += drawLine( x1, y1, leftEndX, leftEndY);
+	var rightStartX = midX + gapWidth;
+	var rightStartY = y1 + (rightStartX - x1) * slope;
+	pathString += drawLine( rightStartX, rightStartY, x2, y2);
+	printPath(renderer, {path: pathString, stroke: renderer.foregroundColor, "data-name": "triplet-bracket"});
+}
+
+module.exports = drawTriplet;

package/src/write/draw/voice.js

@@ -0,0 +1,102 @@
+var drawCrescendo = require('./crescendo');
+var drawDynamics = require('./dynamics');
+var drawTriplet = require('./triplet');
+var drawEnding = require('./ending');
+var drawTie = require('./tie');
+var drawBeam = require('./beam');
+var renderText = require('./text');
+var drawAbsolute = require('./absolute');
+
+function drawVoice(renderer, params, bartop, selectables, staffPos) {
+	var width = params.w-1;
+	renderer.staffbottom = params.staff.bottom;
+
+	if (params.header) { // print voice name
+		var textEl = renderText(renderer, {x: renderer.padding.left, y: renderer.calcY(params.headerPosition), text: params.header, type: 'voicefont', klass: 'staff-extra voice-name', anchor: 'start', centerVertically: true, name: "voice-name"}, true);
+		selectables.wrapSvgEl({ el_type: "voiceName", startChar: -1, endChar: -1, text: params.header }, textEl);
+	}
+
+	var i;
+	var child;
+	var foundNote = false;
+	for (i=0; i < params.children.length; i++) {
+		child = params.children[i];
+		if (child.type === 'note' || child.type === 'rest')
+			foundNote = true;
+		var justInitializedMeasureNumber = false;
+		if (child.type !== 'staff-extra' && !renderer.controller.classes.isInMeasure()) {
+			renderer.controller.classes.startMeasure();
+			justInitializedMeasureNumber = true;
+		}
+		switch (child.type) {
+			// case "tempo":
+			// 	child.elemset = drawTempo(renderer, child);
+			// 	break;
+			default:
+				if (params.staff.isTabStaff) {
+					child.invisible = false;
+  				if ( child.type == 'bar' ) {
+						if (child.abcelem.lastBar) {
+							bartop = params.topLine;
+						}
+					}
+				} 
+				drawAbsolute(renderer, child,(params.barto || i === params.children.length - 1) ? bartop : 0, selectables, staffPos);
+		}
+		if (child.type === 'note' || isNonSpacerRest(child))
+			renderer.controller.classes.incrNote();
+		if (child.type === 'bar' && !justInitializedMeasureNumber && foundNote) {
+			renderer.controller.classes.incrMeasure();
+		}
+	}
+
+	renderer.controller.classes.startMeasure();
+
+	for (i = 0; i < params.beams.length; i++) {
+		var beam = params.beams[i];
+		if (beam === 'bar') {
+			renderer.controller.classes.incrMeasure();
+		} else
+			drawBeam(renderer, beam, selectables); // beams must be drawn first for proper printing of triplets, slurs and ties.
+	}
+
+	renderer.controller.classes.startMeasure();
+	for (i = 0; i < params.otherchildren.length; i++) {
+		child = params.otherchildren[i];
+		if (child === 'bar') {
+			renderer.controller.classes.incrMeasure();
+		} else {
+			switch (child.type) {
+				case "CrescendoElem":
+					child.elemset = drawCrescendo(renderer, child, selectables);
+					break;
+				case "DynamicDecoration":
+					child.elemset = drawDynamics(renderer, child, selectables);
+					break;
+				case "TripletElem":
+					drawTriplet(renderer, child, selectables);
+					break;
+				case "EndingElem":
+					child.elemset = drawEnding(renderer, child, params.startx + 10, width, selectables);
+					break;
+				case "TieElem":
+					child.elemset = drawTie(renderer, child, params.startx + 10, width, selectables);
+					break;
+				default:
+					console.log(child);
+					drawAbsolute(renderer, child, params.startx + 10, width, selectables, staffPos);
+			}
+		}
+	}
+
+}
+
+function isNonSpacerRest(elem) {
+	if (elem.type !== 'rest')
+		return false;
+	if (elem.abcelem && elem.abcelem.rest && elem.abcelem.rest.type !== 'spacer')
+		return true;
+	return false;
+}
+
+module.exports = drawVoice;

package/src/write/format-jazz-chord.js

@@ -0,0 +1,15 @@
+function formatJazzChord(chordString) {
+	// This puts markers in the pieces of the chord that are read by the svg creator.
+	// After the main part of the chord (the letter, a sharp or flat, and "m") a marker is added. Before a slash a marker is added.
+	var lines = chordString.split("\n");
+	for (var i = 0; i < lines.length; i++) {
+		var chord = lines[i];
+		// If the chord isn't in a recognizable format then just skip the formatting.
+		var reg = chord.match(/^([ABCDEFG][♯♭]?)?([^\/]+)?(\/[ABCDEFG][#b]?)?/);
+		if (reg)
+			lines[i] = (reg[1]?reg[1]:'') + "\x03" + (reg[2]?reg[2]:'')  + "\x03" + (reg[3]?reg[3]:'');
+	}
+	return lines.join("\n");
+}
+
+module.exports = formatJazzChord;

package/src/write/free-text.js

@@ -0,0 +1,41 @@
+function FreeText(info, vskip, getFontAndAttr, paddingLeft, width, getTextSize) {
+	var text = info.text;
+	this.rows = [];
+	var size;
+	if (vskip)
+		this.rows.push({move: vskip});
+	var hash = getFontAndAttr.calc('textfont', 'defined-text');
+	if (text === "") {	// we do want to print out blank lines if they have been specified.
+		this.rows.push({move: hash.attr['font-size'] * 2}); // move the distance of the line, plus the distance of the margin, which is also one line.
+	} else if (typeof text === 'string') {
+		this.rows.push({move: hash.attr['font-size']/2}); // TODO-PER: move down some - the y location should be the top of the text, but we output text specifying the center line.
+		this.rows.push({left: paddingLeft, text: text, font: 'textfont', klass: 'defined-text', anchor: "start", startChar: info.startChar, endChar: info.endChar, absElemType: "freeText", name: "free-text"});
+		size = getTextSize.calc(text, 'textfont', 'defined-text');
+		this.rows.push({move: size.height});
+	} else if (text) {
+		var maxHeight = 0;
+		var leftSide = paddingLeft;
+		var currentFont = 'textfont';
+		for (var i = 0; i < text.length; i++) {
+			if (text[i].font) {
+				currentFont = text[i].font;
+			} else
+				currentFont = 'textfont';
+			this.rows.push({left: leftSide, text: text[i].text, font: currentFont, klass: 'defined-text', anchor: 'start', startChar: info.startChar, endChar: info.endChar, absElemType: "freeText", name: "free-text"});
+			size = getTextSize.calc(text[i].text, getFontAndAttr.calc(currentFont, 'defined-text').font, 'defined-text');
+			leftSide += size.width + size.height/2; // add a little padding to the right side. The height of the font is probably a close enough approximation.
+			maxHeight = Math.max(maxHeight, size.height)
+		}
+		this.rows.push({move: maxHeight});
+	} else {
+		// The structure is wrong here: it requires an array to do centering, but it shouldn't have.
+		if (info.length === 1) {
+			var x = width / 2;
+			this.rows.push({left: x, text: info[0].text, font: 'textfont', klass: 'defined-text', anchor: 'middle', startChar: info.startChar, endChar: info.endChar, absElemType: "freeText", name: "free-text"});
+			size = getTextSize.calc(info[0].text, 'textfont', 'defined-text');
+			this.rows.push({move: size.height});
+		}
+	}
+}
+
+module.exports = FreeText;

package/src/write/get-font-and-attr.js

@@ -0,0 +1,37 @@
+var GetFontAndAttr = function GetFontAndAttr(formatting, classes) {
+	this.formatting = formatting;
+	this.classes = classes;
+};
+
+GetFontAndAttr.prototype.updateFonts = function(fontOverrides) {
+	if (fontOverrides.gchordfont)
+		this.formatting.gchordfont = fontOverrides.gchordfont;
+	if (fontOverrides.tripletfont)
+		this.formatting.tripletfont = fontOverrides.tripletfont;
+	if (fontOverrides.annotationfont)
+		this.formatting.annotationfont = fontOverrides.annotationfont;
+	if (fontOverrides.vocalfont)
+		this.formatting.vocalfont = fontOverrides.vocalfont;
+};
+
+GetFontAndAttr.prototype.calc = function(type, klass) {
+	var font;
+	if (typeof type === 'string') {
+		font = this.formatting[type];
+		// Raphael deliberately changes the font units to pixels for some reason, so we need to change points to pixels here.
+		if (font)
+			font = {face: font.face, size: Math.round(font.size * 4 / 3), decoration: font.decoration, style: font.style, weight: font.weight, box: font.box};
+		else
+			font = {face: "Arial", size: Math.round(12 * 4 / 3), decoration: "underline", style: "normal", weight: "normal"};
+	} else
+		font = {face: type.face, size: Math.round(type.size * 4 / 3), decoration: type.decoration, style: type.style, weight: type.weight, box: type.box};
+	var paddingPercent = this.formatting.fontboxpadding ? this.formatting.fontboxpadding : 0.1
+	font.padding = font.size * paddingPercent;
+
+	var attr = {"font-size": font.size, 'font-style': font.style,
+		"font-family": font.face, 'font-weight': font.weight, 'text-decoration': font.decoration,
+		'class': this.classes.generate(klass) };
+	return { font: font, attr: attr };
+};
+
+module.exports = GetFontAndAttr;

package/src/write/get-text-size.js

@@ -0,0 +1,56 @@
+var GetTextSize = function GetTextSize(getFontAndAttr, svg) {
+	this.getFontAndAttr = getFontAndAttr;
+	this.svg = svg;
+};
+
+GetTextSize.prototype.updateFonts = function(fontOverrides) {
+	this.getFontAndAttr.updateFonts(fontOverrides);
+};
+
+GetTextSize.prototype.attr = function(type, klass) {
+	return this.getFontAndAttr.calc(type, klass);
+};
+
+GetTextSize.prototype.calc = function(text, type, klass, el) {
+	var hash;
+	// This can be passed in either a string or a font. If it is a string it names one of the standard fonts.
+	if (typeof type === 'string')
+		hash = this.attr(type, klass);
+	else {
+		hash = {
+			font: {
+				face: type.face,
+				size: type.size,
+				decoration: type.decoration,
+				style: type.style,
+				weight: type.weight
+			},
+			attr: {
+				"font-size": type.size,
+				"font-style": type.style,
+				"font-family": type.face,
+				"font-weight": type.weight,
+				"text-decoration": type.decoration,
+				"class": this.getFontAndAttr.classes.generate(klass)
+			}
+		}
+	}
+	var size = this.svg.getTextSize(text, hash.attr, el);
+	if (hash.font.box) {
+		// Add padding and an equal margin to each side.
+		return { height: size.height + hash.font.padding*4, width: size.width + hash.font.padding*4 };
+	}
+	return size;
+};
+
+GetTextSize.prototype.baselineToCenter = function(text, type, klass, index, total) {
+	// This is for the case where SVG wants to use the baseline of the first line as the Y coordinate.
+	// If there are multiple lines of text or there is an array of text then that will not be centered so this adjusts it.
+	var height = this.calc(text, type, klass).height;
+	var fontHeight = this.attr(type, klass).font.size;
+
+	return height * 0.5 + (total - index - 2) * fontHeight;
+};
+
+
+module.exports = GetTextSize;

package/src/write/highlight.js

@@ -0,0 +1,11 @@
+var setClass = require('./set-class');
+
+var highlight = function (klass, color) {
+	if (klass === undefined)
+		klass = "abcjs-note_selected";
+	if (color === undefined)
+		color = "#ff0000";
+	setClass(this.elemset, klass, "", color);
+};
+
+module.exports = highlight;

package/src/write/layout/VoiceElements.js

@@ -0,0 +1,121 @@
+var VoiceElement = function VoiceElements() {}
+
+VoiceElement.beginLayout = function (startx, voice) {
+	voice.i=0;
+	voice.durationindex=0;
+	//this.ii=this.children.length;
+	voice.startx=startx;
+	voice.minx=startx; // furthest left to where negatively positioned elements are allowed to go
+	voice.nextx=startx; // x position where the next element of this voice should be placed assuming no other voices and no fixed width constraints
+	voice.spacingduration=0; // duration left to be laid out in current iteration (omitting additional spacing due to other aspects, such as bars, dots, sharps and flats)
+};
+
+VoiceElement.layoutEnded = function (voice) {
+	return (voice.i>=voice.children.length);
+};
+
+VoiceElement.getNextX = function (voice) {
+	return Math.max(voice.minx, voice.nextx);
+};
+
+// number of spacing units expected for next positioning
+VoiceElement.getSpacingUnits = function (voice) {
+	return Math.sqrt(voice.spacingduration*8);
+};
+
+// Try to layout the element at index this.i
+// x - position to try to layout the element at
+// spacing - base spacing
+// can't call this function more than once per iteration
+VoiceElement.layoutOneItem = function (x, spacing, voice, minPadding, firstVoice) {
+	var child = voice.children[voice.i];
+	if (!child) return 0;
+	var er = x - voice.minx; // available extrawidth to the left
+	var pad = voice.durationindex + child.duration > 0 ? minPadding : 0; // only add padding to the items that aren't fixed to the left edge.
+	// See if this item overlaps the item in the first voice. If firstVoice is undefined then there's nothing to compare.
+	if (child.abcelem.el_type === "note" && !child.abcelem.rest && voice.voicenumber !== 0 && firstVoice) {
+		var firstChild = firstVoice.children[firstVoice.i];
+		// It overlaps if the either the child's top or bottom is inside the firstChild's or at least within 1
+		// A special case is if the element is on the same line then it can share a note head, if the notehead is the same
+		var overlaps = firstChild &&
+			((child.abcelem.maxpitch <= firstChild.abcelem.maxpitch+1 && child.abcelem.maxpitch >= firstChild.abcelem.minpitch-1) ||
+			(child.abcelem.minpitch <= firstChild.abcelem.maxpitch+1 && child.abcelem.minpitch >= firstChild.abcelem.minpitch-1))
+		// See if they can share a note head
+		if (overlaps && child.abcelem.minpitch === firstChild.abcelem.minpitch && child.abcelem.maxpitch === firstChild.abcelem.maxpitch &&
+		firstChild.heads && firstChild.heads.length > 0 && child.heads && child.heads.length > 0 &&
+		firstChild.heads[0].c === child.heads[0].c)
+			overlaps = false;
+		// If this note overlaps the note in the first voice and we haven't moved the note yet (this can be called multiple times)
+		if (overlaps) {
+			// I think that firstChild should always have at least one note head, but defensively make sure.
+			// There was a problem with this being called more than once so if a value is adjusted then it is saved so it is only adjusted once.
+			var firstChildNoteWidth = firstChild.heads && firstChild.heads.length > 0 ? firstChild.heads[0].realWidth : firstChild.fixed.w;
+			if (!child.adjustedWidth)
+				child.adjustedWidth = firstChildNoteWidth + child.w;
+			child.w = child.adjustedWidth
+			for (var j = 0; j < child.children.length; j++) {
+				var relativeChild = child.children[j];
+				if (relativeChild.name.indexOf("accidental") < 0) {
+					if (!relativeChild.adjustedWidth)
+						relativeChild.adjustedWidth = relativeChild.dx + firstChildNoteWidth;
+					relativeChild.dx = relativeChild.adjustedWidth
+				}
+			}
+
+		}
+	}
+	var extraWidth = getExtraWidth(child, pad);
+	if (er<extraWidth) { // shift right by needed amount
+		// There's an exception if a bar element is after a Part element, there is no shift.
+		if (voice.i === 0 || child.type !== 'bar' || (voice.children[voice.i-1].type !== 'part' && voice.children[voice.i-1].type !== 'tempo') )
+			x+=extraWidth-er;
+	}
+	child.setX(x);
+
+	voice.spacingduration = child.duration;
+	//update minx
+	voice.minx = x+getMinWidth(child); // add necessary layout space
+	if (voice.i!==voice.children.length-1) voice.minx+=child.minspacing; // add minimumspacing except on last elem
+
+	this.updateNextX(x, spacing, voice);
+
+	// contribute to staff y position
+	//this.staff.top = Math.max(child.top,this.staff.top);
+	//this.staff.bottom = Math.min(child.bottom,this.staff.bottom);
+
+	return x; // where we end up having placed the child
+};
+
+VoiceElement.shiftRight = function (dx, voice) {
+	var child = voice.children[voice.i];
+	if (!child) return;
+	child.setX(child.x+dx);
+	voice.minx+=dx;
+	voice.nextx+=dx;
+};
+
+// call when spacingduration has been updated
+VoiceElement.updateNextX = function (x, spacing, voice) {
+	voice.nextx= x + (spacing*Math.sqrt(voice.spacingduration*8));
+};
+
+VoiceElement.updateIndices = function (voice) {
+	if (!this.layoutEnded(voice)) {
+		voice.durationindex += voice.children[voice.i].duration;
+		if (voice.children[voice.i].type === 'bar') voice.durationindex = Math.round(voice.durationindex*64)/64; // everytime we meet a barline, do rounding to nearest 64th
+		voice.i++;
+	}
+};
+
+function getExtraWidth(child, minPadding) { // space needed to the left of the note
+	var padding = 0;
+	if (child.type === 'note' || child.type === 'bar')
+		padding = minPadding;
+	return -child.extraw + padding;
+}
+
+function getMinWidth(child) { // absolute space taken to the right of the note
+	return child.w;
+}
+
+module.exports = VoiceElement;