abcjs 6.0.0-beta.9 → 6.0.0

package/src/write/layout/beam.js

@@ -0,0 +1,213 @@
+var RelativeElement = require('../abc_relative_element');
+var spacing = require('../abc_spacing');
+var getBarYAt = require('./getBarYAt');
+
+var layoutBeam = function(beam) {
+	if (beam.elems.length === 0 || beam.allrests) return;
+
+	var dy = calcDy(beam.stemsUp, beam.isgrace); // This is the width of the beam line.
+
+	// create the main beam
+	var firstElement = beam.elems[0];
+	var lastElement = beam.elems[beam.elems.length - 1];
+	var minStemHeight = 0; // The following is to leave space for "!///!" marks.
+	var referencePitch = beam.stemsUp ? firstElement.abcelem.maxpitch : firstElement.abcelem.minpitch;
+	minStemHeight = minStem(firstElement, beam.stemsUp, referencePitch, minStemHeight);
+	minStemHeight = minStem(lastElement, beam.stemsUp, referencePitch, minStemHeight);
+	minStemHeight = Math.max(beam.stemHeight, minStemHeight + 3); // TODO-PER: The 3 is the width of a 16th beam. The actual height of the beam should be used instead.
+	var yPos = calcYPos(beam.average, beam.elems.length, minStemHeight, beam.stemsUp, firstElement.abcelem.averagepitch, lastElement.abcelem.averagepitch, beam.isflat, beam.min, beam.max, beam.isgrace);
+	var xPos = calcXPos(beam.stemsUp, firstElement, lastElement);
+	beam.addBeam({ startX: xPos[0], endX: xPos[1], startY: yPos[0], endY: yPos[1], dy: dy });
+
+	// create the rest of the beams (in the case of 1/16th notes, etc.
+	var beams = createAdditionalBeams(beam.elems, beam.stemsUp, beam.beams[0], beam.isgrace, dy);
+	for (var i = 0; i < beams.length; i++)
+		beam.addBeam(beams[i]);
+
+	// Now that the main beam is defined, we know how tall the stems should be, so create them and attach them to the original notes.
+	createStems(beam.elems, beam.stemsUp, beam.beams[0], dy, beam.mainNote);
+};
+
+var getDurlog = function(duration) {
+	// TODO-PER: This is a hack to prevent a Chrome lockup. Duration should have been defined already,
+	// but there's definitely a case where it isn't. [Probably something to do with triplets.]
+	if (duration === undefined) {
+		return 0;
+	}
+	//        console.log("getDurlog: " + duration);
+	return Math.floor(Math.log(duration)/Math.log(2));
+};
+
+//
+// private functions
+//
+function minStem(element, stemsUp, referencePitch, minStemHeight) {
+	if (!element.children)
+		return minStemHeight;
+	for (var i = 0; i < element.children.length; i++) {
+		var elem = element.children[i];
+		if (stemsUp && elem.top !== undefined && elem.c === "flags.ugrace")
+			minStemHeight = Math.max(minStemHeight, elem.top - referencePitch);
+		else if (!stemsUp && elem.bottom !== undefined && elem.c === "flags.ugrace")
+			minStemHeight = Math.max(minStemHeight, referencePitch - elem.bottom + 7); // The extra 7 is because we are measuring the slash from the top.
+	}
+	return minStemHeight;
+}
+
+function calcSlant(leftAveragePitch, rightAveragePitch, numStems, isFlat) {
+	if (isFlat)
+		return 0;
+	var slant = leftAveragePitch - rightAveragePitch;
+	var maxSlant = numStems / 2;
+
+	if (slant > maxSlant) slant = maxSlant;
+	if (slant < -maxSlant) slant = -maxSlant;
+	return slant;
+}
+
+function calcDy(asc, isGrace) {
+	var dy = (asc) ? spacing.STEP : -spacing.STEP;
+	if (isGrace) dy = dy * 0.4;
+	return dy;
+}
+
+function calcXPos(asc, firstElement, lastElement) {
+	var starthead = firstElement.heads[asc ? 0 : firstElement.heads.length - 1];
+	var endhead = lastElement.heads[asc ? 0 : lastElement.heads.length - 1];
+	var startX = starthead.x;
+	if (asc) startX += starthead.w - 0.6;
+	var endX = endhead.x;
+	endX += (asc) ? endhead.w : 0.6;
+	return [ startX, endX ];
+}
+
+function calcYPos(average, numElements, stemHeight, asc, firstAveragePitch, lastAveragePitch, isFlat, minPitch, maxPitch, isGrace) {
+	var barpos = stemHeight - 2; // (isGrace)? 5:7;
+	var barminpos = stemHeight - 2;
+	var pos = Math.round(asc ? Math.max(average + barpos, maxPitch + barminpos) : Math.min(average - barpos, minPitch - barminpos));
+
+	var slant = calcSlant(firstAveragePitch, lastAveragePitch, numElements, isFlat);
+	var startY = pos + Math.floor(slant / 2);
+	var endY = pos + Math.floor(-slant / 2);
+
+	// If the notes are too high or too low, make the beam go down to the middle
+	if (!isGrace) {
+		if (asc && pos < 6) {
+			startY = 6;
+			endY = 6;
+		} else if (!asc && pos > 6) {
+			startY = 6;
+			endY = 6;
+		}
+	}
+
+	return [ startY, endY];
+}
+
+function createStems(elems, asc, beam, dy, mainNote) {
+	for (var i = 0; i < elems.length; i++) {
+		var elem = elems[i];
+		if (elem.abcelem.rest)
+			continue;
+		// TODO-PER: This is odd. If it is a regular beam then elems is an array of AbsoluteElements, if it is a grace beam then it is an array of objects , so we directly attach the element to the parent. We tell it if is a grace note because they are passed in as a generic object instead of an AbsoluteElement.
+		var isGrace = elem.addExtra ? false : true;
+		var parent = isGrace ? mainNote : elem;
+		var furthestHead = elem.heads[(asc) ? 0 : elem.heads.length - 1];
+		var ovalDelta = 1 / 5;//(isGrace)?1/3:1/5;
+		var pitch = furthestHead.pitch + ((asc) ? ovalDelta : -ovalDelta);
+		var dx = asc ? furthestHead.w : 0; // down-pointing stems start on the left side of the note, up-pointing stems start on the right side, so we offset by the note width.
+		if (!isGrace)
+			dx += furthestHead.dx;
+		var x = furthestHead.x + dx; // this is now the actual x location in pixels.
+		var bary = getBarYAt(beam.startX, beam.startY, beam.endX, beam.endY, x);
+		var lineWidth = (asc) ? -0.6 : 0.6;
+		if (!asc)
+			bary -= (dy / 2) / spacing.STEP;	// TODO-PER: This is just a fudge factor so the down-pointing stems don't overlap.
+		if (isGrace)
+			dx += elem.heads[0].dx;
+		// TODO-PER-HACK: One type of note head has a different placement of the stem. This should be more generically calculated:
+		if (furthestHead.c === 'noteheads.slash.quarter') {
+			if (asc)
+				pitch += 1;
+			else
+				pitch -= 1;
+		}
+		var stem = new RelativeElement(null, dx, 0, pitch, {
+			"type": "stem",
+			"pitch2": bary,
+			linewidth: lineWidth
+		});
+		stem.setX(parent.x); // This is after the x coordinates were set, so we have to set it directly.
+		parent.addRight(stem);
+	}
+
+}
+
+function createAdditionalBeams(elems, asc, beam, isGrace, dy) {
+	var beams = [];
+	var auxBeams = [];  // auxbeam will be {x, y, durlog, single} auxbeam[0] should match with durlog=-4 (16th) (j=-4-durlog)
+	for (var i = 0; i < elems.length; i++) {
+		var elem = elems[i];
+		if (elem.abcelem.rest)
+			continue;
+		var furthestHead = elem.heads[(asc) ? 0 : elem.heads.length - 1];
+		var x = furthestHead.x + ((asc) ? furthestHead.w : 0);
+		var bary = getBarYAt(beam.startX, beam.startY, beam.endX, beam.endY, x);
+
+		var sy = (asc) ? -1.5 : 1.5;
+		if (isGrace) sy = sy * 2 / 3; // This makes the second beam on grace notes closer to the first one.
+		var duration = elem.abcelem.duration; // get the duration via abcelem because of triplets
+		if (duration === 0) duration = 0.25; // if this is stemless, then we use quarter note as the duration.
+		for (var durlog = getDurlog(duration); durlog < -3; durlog++) {
+			var index = -4 - durlog;
+			if (auxBeams[index]) {
+				auxBeams[index].single = false;
+			} else {
+				auxBeams[index] = {
+					x: x + ((asc) ? -0.6 : 0), y: bary + sy * (index + 1),
+					durlog: durlog, single: true
+				};
+			}
+			if (i > 0 && elem.abcelem.beambr && elem.abcelem.beambr <= (index+1)) {
+				if (!auxBeams[index].split)
+					auxBeams[index].split = [auxBeams[index].x];
+				var xPos = calcXPos(asc, elems[i-1], elem);
+				if (auxBeams[index].split[auxBeams[index].split.length-1] >= xPos[0]) {
+					// the reduction in beams leaves a note unattached so create a small flag for it.
+					xPos[0] += elem.w;
+				}
+				auxBeams[index].split.push(xPos[0]);
+				auxBeams[index].split.push(xPos[1]);
+			}
+		}
+
+		for (var j = auxBeams.length - 1; j >= 0; j--) {
+			if (i === elems.length - 1 || getDurlog(elems[i + 1].abcelem.duration) > (-j - 4)) {
+
+				var auxBeamEndX = x;
+				var auxBeamEndY = bary + sy * (j + 1);
+
+
+				if (auxBeams[j].single) {
+					auxBeamEndX = (i === 0) ? x + 5 : x - 5;
+					auxBeamEndY = getBarYAt(beam.startX, beam.startY, beam.endX, beam.endY, auxBeamEndX) + sy * (j + 1);
+				}
+				var b = { startX: auxBeams[j].x, endX: auxBeamEndX, startY: auxBeams[j].y, endY: auxBeamEndY, dy: dy }
+				if (auxBeams[j].split !== undefined) {
+					var split = auxBeams[j].split;
+					if (b.endX <= split[split.length-1]) {
+						// the reduction in beams leaves the last note by itself, so create a little flag for it
+						split[split.length-1] -= elem.w;
+					}
+					split.push(b.endX);
+					b.split = auxBeams[j].split;
+				}
+				beams.push(b);
+				auxBeams = auxBeams.slice(0, j);
+			}
+		}
+	}
+	return beams;
+}
+
+module.exports = layoutBeam;

package/src/write/layout/get-left-edge-of-staff.js

@@ -0,0 +1,56 @@
+function getLeftEdgeOfStaff(renderer, getTextSize, voices, brace, bracket) {
+	var x = renderer.padding.left;
+
+	// find out how much space will be taken up by voice headers
+	var voiceheaderw = 0;
+	var i;
+	var size;
+	for (i=0;i<voices.length;i++) {
+		if(voices[i].header) {
+			size = getTextSize.calc(voices[i].header, 'voicefont', '');
+			voiceheaderw = Math.max(voiceheaderw,size.width);
+		}
+	}
+	voiceheaderw = addBraceSize(voiceheaderw, brace, getTextSize);
+	voiceheaderw = addBraceSize(voiceheaderw, bracket, getTextSize);
+
+	if (voiceheaderw) {
+		// Give enough spacing to the right - we use the width of an A for the amount of spacing.
+		var sizeW = getTextSize.calc("A", 'voicefont', '');
+		voiceheaderw += sizeW.width;
+	}
+	x += voiceheaderw;
+
+	var ofs = 0;
+	ofs = setBraceLocation(brace, x, ofs);
+	ofs = setBraceLocation(bracket, x, ofs);
+	return x + ofs;
+}
+
+function addBraceSize(voiceheaderw, brace, getTextSize) {
+	if (brace) {
+		for (var i = 0; i < brace.length; i++) {
+			if (brace[i].header) {
+				var size = getTextSize.calc(brace[i].header, 'voicefont', '');
+				voiceheaderw = Math.max(voiceheaderw,size.width);
+			}
+		}
+	}
+	return voiceheaderw;
+}
+
+function setBraceLocation(brace, x, ofs) {
+	if (brace) {
+		for (var i = 0; i < brace.length; i++) {
+			setLocation(x, brace[i]);
+			ofs = Math.max(ofs, brace[i].getWidth());
+		}
+	}
+	return ofs;
+}
+
+function setLocation(x, element) {
+	element.x = x;
+}
+
+module.exports = getLeftEdgeOfStaff;

package/src/write/layout/getBarYAt.js

@@ -0,0 +1,6 @@
+function getBarYAt(startx, starty, endx, endy, x) {
+	return starty + (endy - starty) / (endx - startx) * (x - startx);
+}
+
+module.exports = getBarYAt;
+

package/src/write/layout/layout.js

@@ -0,0 +1,94 @@
+var layoutVoice = require('./voice');
+var setUpperAndLowerElements = require('./setUpperAndLowerElements');
+var layoutStaffGroup = require('./staffGroup');
+var getLeftEdgeOfStaff = require('./get-left-edge-of-staff');
+
+var layout = function (renderer, abctune, width, space) {
+		var i;
+		var abcLine;
+		// Adjust the x-coordinates to their absolute positions
+		var maxWidth = width;
+		for(i=0; i<abctune.lines.length; i++) {
+			abcLine = abctune.lines[i];
+			if (abcLine.staff) {
+				setXSpacing(renderer, width, space, abcLine.staffGroup, abctune.formatting, i === abctune.lines.length - 1, false);
+				if (abcLine.staffGroup.w > maxWidth) maxWidth = abcLine.staffGroup.w;
+			}
+		}
+
+		// Layout the beams and add the stems to the beamed notes.
+		for(i=0; i<abctune.lines.length; i++) {
+			abcLine = abctune.lines[i];
+			if (abcLine.staffGroup && abcLine.staffGroup.voices) {
+				for (var j = 0; j < abcLine.staffGroup.voices.length; j++)
+					layoutVoice(abcLine.staffGroup.voices[j]);
+				setUpperAndLowerElements(renderer, abcLine.staffGroup);
+			}
+		}
+
+		// Set the staff spacing
+		// TODO-PER: we should have been able to do this by the time we called setUpperAndLowerElements, but for some reason the "bottom" element seems to be set as a side effect of setting the X spacing.
+		for(i=0; i<abctune.lines.length; i++) {
+			abcLine = abctune.lines[i];
+			if (abcLine.staffGroup) {
+				abcLine.staffGroup.setHeight();
+			}
+		}
+		return maxWidth;
+	}
+	// Do the x-axis positioning for a single line (a group of related staffs)
+	var setXSpacing = function (renderer, width, space, staffGroup, formatting, isLastLine, debug) {
+		var leftEdge = getLeftEdgeOfStaff(renderer, staffGroup.getTextSize, staffGroup.voices, staffGroup.brace, staffGroup.bracket);
+		var newspace = space;
+		for (var it = 0; it < 8; it++) { // TODO-PER: shouldn't need multiple passes, but each pass gets it closer to the right spacing. (Only affects long lines: normal lines break out of this loop quickly.)
+			var ret = layoutStaffGroup(newspace, renderer, debug, staffGroup, leftEdge);
+			newspace = calcHorizontalSpacing(isLastLine, formatting.stretchlast, width+renderer.padding.left, staffGroup.w, newspace, ret.spacingUnits, ret.minSpace, renderer.padding.left+renderer.padding.right);
+			if (debug)
+				console.log("setXSpace", it, staffGroup.w, newspace, staffGroup.minspace);
+			if (newspace === null) break;
+		}
+		centerWholeRests(staffGroup.voices);
+	};
+
+	function calcHorizontalSpacing(isLastLine, stretchLast, targetWidth, lineWidth, spacing, spacingUnits, minSpace, padding) {
+		if (isLastLine) {
+			if (stretchLast === undefined) {
+				if (lineWidth / targetWidth < 0.66) return null; // keep this for backward compatibility. The break isn't quite the same for some reason.
+			} else {
+				// "Stretch the last music line of a tune when it lacks less than the float fraction of the page width."
+				var lack = 1 - (lineWidth+padding) / targetWidth;
+				var stretch = lack < stretchLast;
+				if (!stretch) return null; // don't stretch last line too much
+			}
+		}
+		if (Math.abs(targetWidth-lineWidth) < 2) return null; // if we are already near the target width, we're done.
+		var relSpace = spacingUnits * spacing;
+		var constSpace = lineWidth - relSpace;
+		if (spacingUnits > 0) {
+			spacing = (targetWidth - constSpace) / spacingUnits;
+			if (spacing * minSpace > 50) {
+				spacing = 50 / minSpace;
+			}
+			return spacing;
+		}
+		return null;
+	}
+
+	function centerWholeRests(voices) {
+		// whole rests are a special case: if they are by themselves in a measure, then they should be centered.
+		// (If they are not by themselves, that is probably a user error, but we'll just center it between the two items to either side of it.)
+		for (var i = 0; i < voices.length; i++) {
+			var voice = voices[i];
+			// Look through all of the elements except for the first and last. If the whole note appears there then there isn't anything to center it between anyway.
+			for (var j = 1; j < voice.children.length-1; j++) {
+				var absElem = voice.children[j];
+				if (absElem.abcelem.rest && (absElem.abcelem.rest.type === 'whole' || absElem.abcelem.rest.type === 'multimeasure')) {
+					var before = voice.children[j-1];
+					var after = voice.children[j+1];
+					absElem.center(before, after);
+				}
+			}
+		}
+	}
+
+module.exports = layout;

package/src/write/layout/setUpperAndLowerElements.js

@@ -0,0 +1,232 @@
+var spacing = require('../abc_spacing');
+
+var setUpperAndLowerElements = function(renderer, staffGroup) {
+	// Each staff already has the top and bottom set, now we see if there are elements that are always on top and bottom, and resolve their pitch.
+	// Also, get the overall height of all the staves in this group.
+	var lastStaffBottom;
+	for (var i = 0; i < staffGroup.staffs.length; i++) {
+		var staff = staffGroup.staffs[i];
+		// the vertical order of elements that are above is: tempo, part, volume/dynamic, ending/chord, lyric
+		// the vertical order of elements that are below is: lyric, chord, volume/dynamic
+		var positionY = {
+			tempoHeightAbove: 0,
+			partHeightAbove: 0,
+			volumeHeightAbove: 0,
+			dynamicHeightAbove: 0,
+			endingHeightAbove: 0,
+			chordHeightAbove: 0,
+			lyricHeightAbove: 0,
+
+			lyricHeightBelow: 0,
+			chordHeightBelow: 0,
+			volumeHeightBelow: 0,
+			dynamicHeightBelow: 0
+		};
+
+		if (renderer.showDebug && renderer.showDebug.indexOf("box") >= 0) {
+			staff.originalTop = staff.top; // This is just being stored for debugging purposes.
+			staff.originalBottom = staff.bottom; // This is just being stored for debugging purposes.
+		}
+
+		incTop(staff, positionY, 'lyricHeightAbove');
+		incTop(staff, positionY, 'chordHeightAbove', staff.specialY.chordLines.above);
+		if (staff.specialY.endingHeightAbove) {
+			if (staff.specialY.chordHeightAbove)
+				staff.top += 2;
+			else
+				staff.top += staff.specialY.endingHeightAbove + margin;
+			positionY.endingHeightAbove = staff.top;
+		}
+		if (staff.specialY.dynamicHeightAbove && staff.specialY.volumeHeightAbove) {
+			staff.top += Math.max(staff.specialY.dynamicHeightAbove, staff.specialY.volumeHeightAbove) + margin;
+			positionY.dynamicHeightAbove = staff.top;
+			positionY.volumeHeightAbove = staff.top;
+		} else {
+			incTop(staff, positionY, 'dynamicHeightAbove');
+			incTop(staff, positionY, 'volumeHeightAbove');
+		}
+		incTop(staff, positionY, 'partHeightAbove');
+		incTop(staff, positionY, 'tempoHeightAbove');
+
+		if (staff.specialY.lyricHeightBelow) {
+			staff.specialY.lyricHeightBelow += renderer.spacing.vocal/spacing.STEP;
+			positionY.lyricHeightBelow = staff.bottom;
+			staff.bottom -= (staff.specialY.lyricHeightBelow + margin);
+		}
+		if (staff.specialY.chordHeightBelow) {
+			positionY.chordHeightBelow = staff.bottom;
+			var hgt = staff.specialY.chordHeightBelow;
+			if (staff.specialY.chordLines.below)
+				hgt *= staff.specialY.chordLines.below;
+			staff.bottom -= (hgt + margin);
+		}
+		if (staff.specialY.volumeHeightBelow && staff.specialY.dynamicHeightBelow) {
+			positionY.volumeHeightBelow = staff.bottom;
+			positionY.dynamicHeightBelow = staff.bottom;
+			staff.bottom -= (Math.max(staff.specialY.volumeHeightBelow, staff.specialY.dynamicHeightBelow) + margin);
+		} else if (staff.specialY.volumeHeightBelow) {
+			positionY.volumeHeightBelow = staff.bottom; staff.bottom -= (staff.specialY.volumeHeightBelow + margin);
+		} else if (staff.specialY.dynamicHeightBelow) {
+			positionY.dynamicHeightBelow = staff.bottom; staff.bottom -= (staff.specialY.dynamicHeightBelow + margin);
+		}
+
+		if (renderer.showDebug && renderer.showDebug.indexOf("box") >= 0)
+			staff.positionY = positionY; // This is just being stored for debugging purposes.
+
+		for (var j = 0; j < staff.voices.length; j++) {
+			var voice = staffGroup.voices[staff.voices[j]];
+			setUpperAndLowerVoiceElements(positionY, voice, renderer.spacing);
+		}
+		// We might need a little space in between staves if the staves haven't been pushed far enough apart by notes or extra vertical stuff.
+		// Only try to put in extra space if this isn't the top staff.
+		if (lastStaffBottom !== undefined) {
+			var thisStaffTop = staff.top - 10;
+			var forcedSpacingBetween = lastStaffBottom + thisStaffTop;
+			var minSpacingInPitches = renderer.spacing.systemStaffSeparation/spacing.STEP;
+			var addedSpace = minSpacingInPitches - forcedSpacingBetween;
+			if (addedSpace > 0)
+				staff.top += addedSpace;
+		}
+		lastStaffBottom = 2 - staff.bottom; // the staff starts at position 2 and the bottom variable is negative. Therefore to find out how large the bottom is, we reverse the sign of the bottom, and add the 2 in.
+
+		// Now we need a little margin on the top, so we'll just throw that in.
+		//staff.top += 4;
+		//console.log("Staff Y: ",i,heightInPitches,staff.top,staff.bottom);
+	}
+	//console.log("Staff Height: ",heightInPitches,this.height);
+};
+
+var margin = 1;
+function incTop(staff, positionY, item, count) {
+	if (staff.specialY[item]) {
+		var height = staff.specialY[item];
+		if (count)
+			height *= count;
+		staff.top += height + margin;
+		positionY[item] = staff.top;
+	}
+}
+
+function setUpperAndLowerVoiceElements(positionY, voice, spacing) {
+	var i;
+	var abselem;
+	for (i = 0; i < voice.children.length; i++) {
+		abselem = voice.children[i];
+		setUpperAndLowerAbsoluteElements(positionY, abselem, spacing);
+	}
+	for (i = 0; i < voice.otherchildren.length; i++) {
+		abselem = voice.otherchildren[i];
+		switch (abselem.type) {
+			case 'CrescendoElem':
+				setUpperAndLowerCrescendoElements(positionY, abselem);
+				break;
+			case 'DynamicDecoration':
+				setUpperAndLowerDynamicElements(positionY, abselem);
+				break;
+			case 'EndingElem':
+				setUpperAndLowerEndingElements(positionY, abselem);
+				break;
+		}
+	}
+}
+
+// For each of the relative elements that can't be placed in advance (because their vertical placement depends on everything
+// else on the line), this iterates through them and sets their pitch. By the time this is called, specialYResolved contains a
+// hash with the vertical placement (in pitch units) for each type.
+// TODO-PER: I think this needs to be separated by "above" and "below". How do we know that for dynamics at the point where they are being defined, though? We need a pass through all the relative elements to set "above" and "below".
+function setUpperAndLowerAbsoluteElements(specialYResolved, element, spacing) {
+	// specialYResolved contains the actual pitch for each of the classes of elements.
+	for (var i = 0; i < element.children.length; i++) {
+		var child = element.children[i];
+		for (var key in element.specialY) { // for each class of element that needs to be placed vertically
+			if (element.specialY.hasOwnProperty(key)) {
+				if (child[key]) { // If this relative element has defined a height for this class of element
+					child.pitch = specialYResolved[key];
+					if (child.top === undefined) { // TODO-PER: HACK! Not sure this is the right place to do this.
+						if (child.type === 'TempoElement') {
+							setUpperAndLowerTempoElement(specialYResolved, child);
+						} else {
+							setUpperAndLowerRelativeElements(specialYResolved, child, spacing);
+						}
+						element.pushTop(child.top);
+						element.pushBottom(child.bottom);
+					}
+				}
+			}
+		}
+	}
+}
+
+function setUpperAndLowerCrescendoElements(positionY, element) {
+	if (element.dynamicHeightAbove)
+		element.pitch = positionY.dynamicHeightAbove;
+	else
+		element.pitch = positionY.dynamicHeightBelow;
+}
+
+function setUpperAndLowerDynamicElements(positionY, element) {
+	if (element.volumeHeightAbove)
+		element.pitch = positionY.volumeHeightAbove;
+	else
+		element.pitch = positionY.volumeHeightBelow;
+}
+
+function setUpperAndLowerEndingElements(positionY, element) {
+	element.pitch = positionY.endingHeightAbove - 2;
+}
+
+function setUpperAndLowerTempoElement(positionY, element) {
+	element.pitch = positionY.tempoHeightAbove;
+	element.top = positionY.tempoHeightAbove;
+	element.bottom = positionY.tempoHeightAbove;
+	if (element.note) {
+		var tempoPitch = element.pitch - element.totalHeightInPitches + 1; // The pitch we receive is the top of the allotted area: change that to practically the bottom.
+		element.note.top = tempoPitch;
+		element.note.bottom = tempoPitch;
+		for (var i = 0; i < element.note.children.length; i++) {
+			var child = element.note.children[i];
+			child.top += tempoPitch;
+			child.bottom += tempoPitch;
+			child.pitch += tempoPitch;
+			if (child.pitch2 !== undefined)
+				child.pitch2 += tempoPitch;
+		}
+	}
+}
+
+function setUpperAndLowerRelativeElements(positionY, element, renderSpacing) {
+	switch(element.type) {
+		case "part":
+			element.top = positionY.partHeightAbove + element.height;
+			element.bottom = positionY.partHeightAbove;
+			break;
+		case "text":
+		case "chord":
+			if (element.chordHeightAbove) {
+				element.top = positionY.chordHeightAbove;
+				element.bottom = positionY.chordHeightAbove;
+			} else {
+				element.top = positionY.chordHeightBelow;
+				element.bottom = positionY.chordHeightBelow;
+			}
+			break;
+		case "lyric":
+			if (element.lyricHeightAbove) {
+				element.top = positionY.lyricHeightAbove;
+				element.bottom = positionY.lyricHeightAbove;
+			} else {
+				element.top = positionY.lyricHeightBelow + renderSpacing.vocal/spacing.STEP;
+				element.bottom = positionY.lyricHeightBelow + renderSpacing.vocal/spacing.STEP;
+				element.pitch -= renderSpacing.vocal/spacing.STEP;
+			}
+			break;
+		case "debug":
+			element.top = positionY.chordHeightAbove;
+			element.bottom = positionY.chordHeightAbove;
+			break;
+	}
+	if (element.pitch === undefined || element.top === undefined)
+		console.error("RelativeElement position not set.", element.type, element.pitch, element.top, positionY);
+}
+
+module.exports = setUpperAndLowerElements;