abcjs-rails 1.11 → 2.0

data/app/assets/javascripts/abcjs/write/abc_staff_group_element.js

@@ -35,8 +35,6 @@ if (!window.ABCJS.write)
 // Members:
 // staffs: an array of all the staves in this group. Each staff contains the following elements:
 //    { top, bottom, highest, lowest, y }
-// stafflines: an array of the same length as staffs. It contains an integer with the number of lines.
-//   TODO-PER: stafflines should actually be an element of staffs, I think.
 // voices: array of VoiceElement objects. This is mostly passed in, but the VoiceElement objects are modified here.
 //
 // spacingunits: number of relative x-units in the line. Used by the calling function to pass back in as the "spacing" input parameter.
@@ -54,18 +52,148 @@ if (!window.ABCJS.write)
 ABCJS.write.StaffGroupElement = function() {
 	this.voices = [];
 	this.staffs = [];
-	this.stafflines = [];
+};
+
+ABCJS.write.StaffGroupElement.prototype.setLimit = function(member, voice) {
+	if (!voice.specialY[member]) return;
+	if (!voice.staff.specialY[member])
+		voice.staff.specialY[member] = voice.specialY[member];
+	else
+		voice.staff.specialY[member] = Math.max(voice.staff.specialY[member], voice.specialY[member]);
 };
 
 ABCJS.write.StaffGroupElement.prototype.addVoice = function (voice, staffnumber, stafflines) {
-	this.voices[this.voices.length] = voice;
-	if (!this.staffs[staffnumber]) {
-		this.staffs[this.staffs.length] = {top:0, highest: 7, lowest: 7};
-		this.stafflines[this.stafflines.length] = stafflines;
+	var voiceNum = this.voices.length;
+	this.voices[voiceNum] = voice;
+	if (this.staffs[staffnumber])
+		this.staffs[staffnumber].voices.push(voiceNum);
+	else {
+		// TODO-PER: how does the min/max change when stafflines is not 5?
+		this.staffs[this.staffs.length] = {
+			top: 10,
+			bottom: 2,
+			lines: stafflines,
+			voices: [voiceNum],
+			specialY: {
+				tempoHeightAbove: 0,
+				partHeightAbove: 0,
+				volumeHeightAbove: 0,
+				dynamicHeightAbove: 0,
+				endingHeightAbove: 0,
+				chordHeightAbove: 0,
+				lyricHeightAbove: 0,
+
+				lyricHeightBelow: 0,
+				chordHeightBelow: 0,
+				volumeHeightBelow: 0,
+				dynamicHeightBelow: 0
+			}
+		};
 	}
 	voice.staff = this.staffs[staffnumber];
 };
 
+ABCJS.write.StaffGroupElement.prototype.setStaffLimits = function (voice) {
+	voice.staff.top = Math.max(voice.staff.top, voice.top);
+	voice.staff.bottom = Math.min(voice.staff.bottom, voice.bottom);
+	this.setLimit('tempoHeightAbove', voice);
+	this.setLimit('partHeightAbove', voice);
+	this.setLimit('volumeHeightAbove', voice);
+	this.setLimit('dynamicHeightAbove', voice);
+	this.setLimit('endingHeightAbove', voice);
+	this.setLimit('chordHeightAbove', voice);
+	this.setLimit('lyricHeightAbove', voice);
+	this.setLimit('lyricHeightBelow', voice);
+	this.setLimit('chordHeightBelow', voice);
+	this.setLimit('volumeHeightBelow', voice);
+	this.setLimit('dynamicHeightBelow', voice);
+};
+
+ABCJS.write.StaffGroupElement.prototype.setUpperAndLowerElements = function(renderer) {
+	// 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 < this.staffs.length; i++) {
+		var staff = this.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 (ABCJS.write.debugPlacement) {
+			staff.originalTop = staff.top; // This is just being stored for debugging purposes.
+			staff.originalBottom = staff.bottom; // This is just being stored for debugging purposes.
+		}
+
+		if (staff.specialY.lyricHeightAbove) { staff.top += staff.specialY.lyricHeightAbove; positionY.lyricHeightAbove = staff.top; }
+		if (staff.specialY.chordHeightAbove) { staff.top += staff.specialY.chordHeightAbove; positionY.chordHeightAbove = staff.top; }
+		if (staff.specialY.endingHeightAbove) {
+			if (staff.specialY.chordHeightAbove)
+				staff.top += 2;
+			else
+				staff.top += staff.specialY.endingHeightAbove;
+			positionY.endingHeightAbove = staff.top;
+		}
+		if (staff.specialY.dynamicHeightAbove && staff.specialY.volumeHeightAbove) {
+			staff.top += Math.max(staff.specialY.dynamicHeightAbove, staff.specialY.volumeHeightAbove);
+			positionY.dynamicHeightAbove = staff.top;
+			positionY.volumeHeightAbove = staff.top;
+		} else if (staff.specialY.dynamicHeightAbove) {
+			staff.top += staff.specialY.dynamicHeightAbove; positionY.dynamicHeightAbove = staff.top;
+		} else if (staff.specialY.volumeHeightAbove) { staff.top += staff.specialY.volumeHeightAbove; positionY.volumeHeightAbove = staff.top; }
+		if (staff.specialY.partHeightAbove) { staff.top += staff.specialY.partHeightAbove; positionY.partHeightAbove = staff.top; }
+		if (staff.specialY.tempoHeightAbove) { staff.top += staff.specialY.tempoHeightAbove; positionY.tempoHeightAbove = staff.top; }
+
+		if (staff.specialY.lyricHeightBelow) { positionY.lyricHeightBelow = staff.bottom; staff.bottom -= staff.specialY.lyricHeightBelow; }
+		if (staff.specialY.chordHeightBelow) { positionY.chordHeightBelow = staff.bottom; staff.bottom -= staff.specialY.chordHeightBelow; }
+		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);
+		} else if (staff.specialY.volumeHeightBelow) {
+			positionY.volumeHeightBelow = staff.bottom; staff.bottom -= staff.specialY.volumeHeightBelow;
+		} else if (staff.specialY.dynamicHeightBelow) {
+			positionY.dynamicHeightBelow = staff.bottom; staff.bottom -= staff.specialY.dynamicHeightBelow;
+		}
+
+		if (ABCJS.write.debugPlacement)
+			staff.positionY = positionY; // This is just being stored for debugging purposes.
+
+		for (var j = 0; j < staff.voices.length; j++) {
+			var voice = this.voices[staff.voices[j]];
+			voice.setUpperAndLowerElements(positionY);
+		}
+		// 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/ABCJS.write.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);
+};
+
 ABCJS.write.StaffGroupElement.prototype.finished = function() {
 	for (var i=0;i<this.voices.length;i++) {
 		if (!this.voices[i].layoutEnded()) return false;
@@ -73,21 +201,36 @@ ABCJS.write.StaffGroupElement.prototype.finished = function() {
 	return true;
 };
 
+<<<<<<< HEAD
+ABCJS.write.StaffGroupElement.prototype.layout = function(spacing, renderer, debug) {
+	this.spacingunits = 0; // number of times we will have ended up using the spacing distance (as opposed to fixed width distances)
+	this.minspace = 1000; // a big number to start off with - used to find out what the smallest space between two notes is -- GD 2014.1.7
+	var x = renderer.padding.left;
+=======
 ABCJS.write.StaffGroupElement.prototype.layout = function(spacing, controller, debug) {
 	this.spacingunits = 0; // number of times we will have ended up using the spacing distance (as opposed to fixed width distances)
 	this.minspace = 1000; // a big number to start off with - used to find out what the smallest space between two notes is -- GD 2014.1.7
 	var x = controller.paddingleft*controller.scale;
+>>>>>>> origin/master
 
 	// find out how much space will be taken up by voice headers
 	var voiceheaderw = 0;
 	for (var i=0;i<this.voices.length;i++) {
 		if(this.voices[i].header) {
-			var t = controller.paper.text(100*controller.scale, -10*controller.scale, this.voices[i].header).attr({"font-size":12*controller.scale, "font-family":"serif", 'font-weight':'bold'}); // code duplicated below  // don't scale this as we ask for the bbox
+<<<<<<< HEAD
+			var size = renderer.getTextSize(this.voices[i].header, 'voicefont', '');
+			voiceheaderw = Math.max(voiceheaderw,size.width);
+		}
+	}
+	x=x+voiceheaderw*1.1; // When there is no voice header, 110% of 0 is 0
+=======
+			var t = controller.renderText(100, this.y-10, this.voices[i].header, 'voicefont', ''); // code duplicated below  // don't scale this as we ask for the bbox
 			voiceheaderw = Math.max(voiceheaderw,t.getBBox().width);
 			t.remove();
 		}
 	}
 	x=x+voiceheaderw*(1/controller.scale)*1.1; // 10% of 0 is 0
+>>>>>>> origin/master
 	this.startx=x;
 
 	var currentduration = 0;
@@ -124,12 +267,14 @@ ABCJS.write.StaffGroupElement.prototype.layout = function(spacing, controller, d
 		spacingunit = 0; // number of spacingunits coming from the previously laid out element to this one
 		var spacingduration = 0;
 		for (i=0;i<currentvoices.length;i++) {
+			//console.log("greatest spacing unit", x, currentvoices[i].getNextX(), currentvoices[i].getSpacingUnits(), currentvoices[i].spacingduration);
 			if (currentvoices[i].getNextX()>x) {
 				x=currentvoices[i].getNextX();
 				spacingunit=currentvoices[i].getSpacingUnits();
 				spacingduration = currentvoices[i].spacingduration;
 			}
 		}
+		//console.log("new spacingunit", spacingunit, this.spacingunits, "="+(spacingunit+ this.spacingunits));
 		this.spacingunits+=spacingunit;
 		this.minspace = Math.min(this.minspace,spacingunit);
 
@@ -165,6 +310,7 @@ ABCJS.write.StaffGroupElement.prototype.layout = function(spacing, controller, d
 			spacingunit=this.voices[i].getSpacingUnits();
 		}
 	}
+	//console.log("greatest remaining",spacingunit,x);
 	this.spacingunits+=spacingunit;
 	this.w = x;
 
@@ -173,6 +319,18 @@ ABCJS.write.StaffGroupElement.prototype.layout = function(spacing, controller, d
 	}
 };
 
+<<<<<<< HEAD
+ABCJS.write.StaffGroupElement.prototype.calcHeight = function () {
+	// 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<this.voices.length;i++) {
+		var staff = this.voices[i].staff;
+		if (!this.voices[i].duplicate) {
+			height += staff.top;
+			if (staff.bottom < 0)
+				height += -staff.bottom;
+=======
 ABCJS.write.StaffGroupElement.prototype.draw = function (renderer, y) {
 
 	this.y = y;
@@ -192,10 +350,59 @@ ABCJS.write.StaffGroupElement.prototype.draw = function (renderer, y) {
 			if (this.stafflines[i] === undefined)
 				this.stafflines[i] = 5;
 			renderer.printStave(this.startx, this.w, this.stafflines[i]);
+>>>>>>> origin/master
 		}
 	}
-	this.height = y-this.y;
+	return height;
+};
 
+<<<<<<< HEAD
+ABCJS.write.StaffGroupElement.prototype.draw = function (renderer) {
+	// We enter this method with renderer.y pointing to the topmost coordinate that we're allowed to draw.
+	// All of the children that will be drawn have a relative "pitch" set, where zero is the first ledger line below the staff.
+	// renderer.y will be offset at the beginning of each staff by the amount required to make the relative pitch work.
+	// If there are multiple staves, then renderer.y will be incremented for each new staff.
+
+	var debugPrint;
+	var colorIndex;
+	if (ABCJS.write.debugPlacement) {
+		var colors = [ "rgba(207,27,36,0.4)", "rgba(168,214,80,0.4)", "rgba(110,161,224,0.4)", "rgba(191,119,218,0.4)", "rgba(195,30,151,0.4)",
+			"rgba(31,170,177,0.4)", "rgba(220,166,142,0.4)" ];
+		debugPrint = function(staff, key) {
+			if (staff.positionY[key]) {
+				//renderer.printHorizontalLine(50, renderer.calcY(staff.positionY[key]), key.substr(0, 4) + " " + Math.round(staff.positionY[key]));
+				var height = staff.specialY[key] * ABCJS.write.spacing.STEP;
+				renderer.printShadedBox(renderer.padding.left, renderer.calcY(staff.positionY[key]), renderer.controller.width, height,colors[colorIndex], key.substr(0, 4));
+				colorIndex += 1; if (colorIndex > 6) colorIndex = 0;
+			}
+		};
+	}
+
+	var startY = renderer.y; // So that it can be restored after we're done.
+	// Set the absolute Y position for each staff here, so the voice drawing below can just use if.
+	for (var j = 0; j < this.staffs.length; j++) {
+		var staff1 = this.staffs[j];
+		//renderer.printHorizontalLine(50, renderer.y, "start");
+		renderer.moveY(ABCJS.write.spacing.STEP, staff1.top);
+		staff1.absoluteY = renderer.y;
+		if (ABCJS.write.debugPlacement) {
+			colorIndex = 0;
+			renderer.printShadedBox(renderer.padding.left, renderer.calcY(staff1.originalTop), renderer.controller.width, renderer.calcY(staff1.originalBottom)-renderer.calcY(staff1.originalTop),"rgba(0,0,0,0.1)");
+			debugPrint(staff1, 'chordHeightAbove');
+			debugPrint(staff1, 'chordHeightBelow');
+			debugPrint(staff1, 'dynamicHeightAbove');
+			debugPrint(staff1, 'dynamicHeightBelow');
+			debugPrint(staff1, 'endingHeightAbove');
+			debugPrint(staff1, 'lyricHeightAbove');
+			debugPrint(staff1, 'lyricHeightBelow');
+			debugPrint(staff1, 'partHeightAbove');
+			debugPrint(staff1, 'tempoHeightAbove');
+			debugPrint(staff1, 'volumeHeightAbove');
+			debugPrint(staff1, 'volumeHeightBelow');
+		}
+		if (staff1.bottom < 0)
+			renderer.moveY(ABCJS.write.spacing.STEP, -staff1.bottom);
+=======
 	var bartop = 0;
 	renderer.measureNumber = null;
 	for (i=0;i<this.voices.length;i++) {
@@ -210,8 +417,35 @@ ABCJS.write.StaffGroupElement.prototype.draw = function (renderer, y) {
 		renderer.y = this.staffs[this.staffs.length-1].y;
 		var bottom = renderer.calcY(2);
 		renderer.printStem(this.startx, 0.6, top, bottom);
+>>>>>>> origin/master
 	}
+	var topLine; // these are to connect multiple staves. We need to remember where they are.
+	var bottomLine;
 
+<<<<<<< HEAD
+	var bartop = 0;
+	renderer.measureNumber = null;
+	for (var i=0;i<this.voices.length;i++) {
+		var staff = this.voices[i].staff;
+		renderer.y = staff.absoluteY;
+		//renderer.y = staff.y;
+		// offset for starting the counting at middle C
+		if (!this.voices[i].duplicate) {
+//			renderer.moveY(ABCJS.write.spacing.STEP, staff.top);
+			if (!topLine) topLine  = renderer.calcY(10);
+			bottomLine  = renderer.calcY(2);
+			if (staff.lines !== 0)
+				renderer.printStave(this.startx, this.w, staff.lines);
+		}
+		this.voices[i].draw(renderer, bartop);
+		if (!this.voices[i].duplicate) {
+			bartop = renderer.calcY(2); // This connects the bar lines between two different staves.
+//			if (staff.bottom < 0)
+//				renderer.moveY(ABCJS.write.spacing.STEP, -staff.bottom);
+		}
+	}
+	renderer.measureNumber = null;
+=======
 //	for (i=0;i<this.staffs.length;i++) {
 //		if (this.stafflines[i] === 0) continue;
 //		renderer.y = this.staffs[i].y;
@@ -220,6 +454,12 @@ ABCJS.write.StaffGroupElement.prototype.draw = function (renderer, y) {
 //			this.stafflines[i] = 5;
 //		renderer.printStave(this.startx,this.w, this.stafflines[i]);
 //	}
+>>>>>>> origin/master
 
+	// connect all the staves together with a vertical line
+	if (this.staffs.length>1) {
+		renderer.printStem(this.startx, 0.6, topLine, bottomLine);
+	}
+	renderer.y = startY;
 };
 

data/app/assets/javascripts/abcjs/write/abc_tempo_element.js

@@ -0,0 +1,104 @@
+//    abc_tempo_element.js: Definition of the TempoElement class.
+//    Copyright (C) 2014 Gregory Dyke (gregdyke at gmail dot com) and Paul Rosen
+//
+//    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/>.
+
+/*globals ABCJS */
+
+if (!window.ABCJS)
+	window.ABCJS = {};
+
+if (!window.ABCJS.write)
+	window.ABCJS.write = {};
+
+(function() {
+	"use strict";
+	var totalHeightInPitches = 5;
+
+	ABCJS.write.TempoElement = function(tempo) {
+		this.tempo = tempo;
+		this.tempoHeightAbove = totalHeightInPitches;
+		this.pitch = undefined; // This will be set later
+	};
+
+	ABCJS.write.TempoElement.prototype.setUpperAndLowerElements = function(positionY) { // TODO-PER: This might not be called.
+		this.pitch = positionY.tempoHeightAbove;
+	};
+
+	ABCJS.write.TempoElement.prototype.setX = function (x) {
+		this.x = x;
+	};
+
+	ABCJS.write.TempoElement.prototype.draw = function(renderer) {
+		var x = this.x;
+		if (this.pitch === undefined)
+			window.console.error("Tempo Element y-coordinate not set.");
+
+		var y = renderer.calcY(this.pitch);
+		var text;
+		if (this.tempo.preString) {
+			text = renderer.renderText(x, y, this.tempo.preString, 'tempofont', 'tempo', "start");
+			var preWidth = text.getBBox().width;
+			var charWidth = preWidth / this.tempo.preString.length; // Just get some average number to increase the spacing.
+			x += preWidth + charWidth;
+		}
+		if (this.tempo.duration) {
+			var temposcale = 0.75;
+			var tempopitch = this.pitch - totalHeightInPitches + 1; // The pitch we receive is the top of the allotted area: change that to practically the bottom.
+			var duration = this.tempo.duration[0]; // TODO when multiple durations
+			var abselem = new ABCJS.write.AbsoluteElement(this.tempo, duration, 1, 'tempo');
+			var durlog = Math.floor(Math.log(duration) / Math.log(2));
+			var dot = 0;
+			for (var tot = Math.pow(2, durlog), inc = tot / 2; tot < duration; dot++, tot += inc, inc /= 2);
+			var c = renderer.engraver.chartable.note[-durlog];
+			var flag = renderer.engraver.chartable.uflags[-durlog];
+			var temponote = renderer.engraver.createNoteHead(abselem, // TODO-PER: This seems late to be creating this element. Shouldn't it happen before draw?
+				c,
+				{verticalPos: tempopitch},
+				"up",
+				0,
+				0,
+				flag,
+				dot,
+				0,
+				temposcale
+			);
+			abselem.addHead(temponote);
+			var stem;
+			if (duration < 1) {
+				var p1 = tempopitch + 1 / 3 * temposcale;
+				var p2 = tempopitch + 7 * temposcale;
+				var dx = temponote.dx + temponote.w;
+				var width = -0.6;
+				stem = new ABCJS.write.RelativeElement(null, dx, 0, p1, {"type": "stem", "pitch2": p2, linewidth: width});
+				stem.setX(x);
+				abselem.addExtra(stem);
+			}
+			abselem.x = x;
+			temponote.setX(x);
+			temponote.draw(renderer, x);
+			if (stem)
+				stem.draw(renderer, x);
+			x += (abselem.w + 5);
+			var str = "= " + this.tempo.bpm;
+			text = renderer.renderText(x, y, str, 'tempofont', 'tempo', "start");
+			var postWidth = text.getBBox().width;
+			var charWidth2 = postWidth / str.length; // Just get some average number to increase the spacing.
+			x += postWidth + charWidth2;
+		}
+		if (this.tempo.postString) {
+			renderer.renderText(x, y, this.tempo.postString, 'tempofont', 'tempo', "start");
+		}
+	};
+})();