abcjs-rails 1.8 → 1.11

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

@@ -0,0 +1,163 @@
+//    abc_absolute_element.js: Definition of the AbsoluteElement class.
+//    Copyright (C) 2010,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 = {};
+
+// duration - actual musical duration - different from notehead duration in triplets. refer to abcelem to get the notehead duration
+// minspacing - spacing which must be taken on top of the width defined by the duration
+// type is a meta-type for the element. It is not necessary for drawing, but it is useful to make semantic sense of the element. For instance, it can be used in the element's class name.
+ABCJS.write.AbsoluteElement = function(abcelem, duration, minspacing, type) {
+	this.abcelem = abcelem;
+	this.duration = duration;
+	this.minspacing = minspacing || 0;
+	this.x = 0;
+	this.children = [];
+	this.heads = [];
+	this.extra = [];
+	this.extraw = 0;
+	//this.decs = [];
+	this.w = 0;
+	this.right = [];
+	this.invisible = false;
+	this.bottom = 7;
+	this.top = 7;
+	this.type = type;
+};
+
+ABCJS.write.AbsoluteElement.prototype.getMinWidth = function () { // absolute space taken to the right of the note
+	return this.w;
+};
+
+ABCJS.write.AbsoluteElement.prototype.getExtraWidth = function () { // space needed to the left of the note
+	return -this.extraw;
+};
+
+ABCJS.write.AbsoluteElement.prototype.addExtra = function (extra) {
+	if (extra.dx<this.extraw) this.extraw = extra.dx;
+	this.extra[this.extra.length] = extra;
+	this.addChild(extra);
+};
+
+ABCJS.write.AbsoluteElement.prototype.addHead = function (head) {
+	if (head.dx<this.extraw) this.extraw = head.dx;
+	this.heads[this.heads.length] = head;
+	this.addRight(head);
+};
+
+ABCJS.write.AbsoluteElement.prototype.addRight = function (right) {
+	if (right.dx+right.w>this.w) this.w = right.dx+right.w;
+	this.right[this.right.length] = right;
+	this.addChild(right);
+};
+
+ABCJS.write.AbsoluteElement.prototype.addChild = function (child) {
+	child.parent = this;
+	this.children[this.children.length] = child;
+	this.pushTop(child.top);
+	this.pushBottom(child.bottom);
+};
+
+ABCJS.write.AbsoluteElement.prototype.pushTop = function (top) {
+	this.top = Math.max(top, this.top);
+};
+
+ABCJS.write.AbsoluteElement.prototype.pushBottom = function (bottom) {
+	this.bottom = Math.min(bottom, this.bottom);
+};
+
+ABCJS.write.AbsoluteElement.prototype.draw = function (renderer, bartop) {
+	this.elemset = renderer.paper.set();
+	if (this.invisible) return;
+	renderer.beginGroup();
+	for (var i=0; i<this.children.length; i++) {
+		this.elemset.push(this.children[i].draw(renderer,this.x, bartop));
+	}
+	this.elemset.push(renderer.endGroup(this.type));
+	if (this.klass)
+		this.setClass("mark", "", "#00ff00");
+	var self = this;
+	this.elemset.mouseup(function () {
+		renderer.notifySelect(self);
+	});
+	this.abcelem.abselem = this;
+
+	var spacing = ABCJS.write.spacing.STEP*renderer.scale;
+
+	var start = function () {
+			// storing original relative coordinates
+			this.dy = 0;
+		},
+		move = function (dx, dy) {
+			// move will be called with dx and dy
+			dy = Math.round(dy/spacing)*spacing;
+			this.translate(0, -this.dy);
+			this.dy = dy;
+			this.translate(0,this.dy);
+		},
+		up = function () {
+			var delta = -Math.round(this.dy/spacing);
+			self.abcelem.pitches[0].pitch += delta;
+			self.abcelem.pitches[0].verticalPos += delta;
+			renderer.notifyChange();
+		};
+	if (this.abcelem.el_type==="note" && renderer.editable)
+		this.elemset.drag(move, start, up);
+};
+
+ABCJS.write.AbsoluteElement.prototype.isIE=/*@cc_on!@*/false;//IE detector
+
+ABCJS.write.AbsoluteElement.prototype.setClass = function (addClass, removeClass, color) {
+	if (color !== null)
+		this.elemset.attr({fill:color});
+	if (!this.isIE) {
+		for (var i = 0; i < this.elemset.length; i++) {
+			if (this.elemset[i][0].setAttribute) {
+				var kls = this.elemset[i][0].getAttribute("class");
+				if (!kls) kls = "";
+				kls = kls.replace(removeClass, "");
+				kls = kls.replace(addClass, "");
+				if (addClass.length > 0) {
+					if (kls.length > 0 && kls.charAt(kls.length-1) !== ' ') kls += " ";
+					kls += addClass;
+				}
+				this.elemset[i][0].setAttribute("class", kls);
+			}
+		}
+	}
+};
+
+ABCJS.write.AbsoluteElement.prototype.highlight = function (klass, color) {
+	if (klass === undefined)
+		klass = "note_selected";
+	if (color === undefined)
+		color = "#ff0000";
+	this.setClass(klass, "", color);
+};
+
+ABCJS.write.AbsoluteElement.prototype.unhighlight = function (klass, color) {
+	if (klass === undefined)
+		klass = "note_selected";
+	if (color === undefined)
+		color = "#000000";
+	this.setClass("", klass, color);
+};
+

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

@@ -0,0 +1,162 @@
+//    abc_beam_element.js: Definition of the BeamElem class.
+//    Copyright (C) 2010,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 = {};
+
+ABCJS.write.BeamElem = function(type, flat) {
+	this.isflat = (flat);
+	this.isgrace = (type && type==="grace");
+	this.forceup = (type && type==="up");
+	this.forcedown = (type && type==="down");
+	this.elems = []; // all the ABCJS.write.AbsoluteElements
+	this.total = 0;
+	this.dy = (this.asc)?ABCJS.write.spacing.STEP*1.2:-ABCJS.write.spacing.STEP*1.2;
+	if (this.isgrace) this.dy = this.dy*0.4;
+	this.allrests = true;
+};
+
+ABCJS.write.BeamElem.prototype.add = function(abselem) {
+	var pitch = abselem.abcelem.averagepitch;
+	if (pitch===undefined) return; // don't include elements like spacers in beams
+	this.allrests = this.allrests && abselem.abcelem.rest;
+	abselem.beam = this;
+	this.elems.push(abselem);
+	//var pitch = abselem.abcelem.averagepitch;
+	this.total += pitch; // TODO CHORD (get pitches from abselem.heads)
+	if (!this.min || abselem.abcelem.minpitch<this.min) {
+		this.min = abselem.abcelem.minpitch;
+	}
+	if (!this.max || abselem.abcelem.maxpitch>this.max) {
+		this.max = abselem.abcelem.maxpitch;
+	}
+};
+
+ABCJS.write.BeamElem.prototype.average = function() {
+	try {
+		return this.total/this.elems.length;
+	} catch (e) {
+		return 0;
+	}
+};
+
+ABCJS.write.BeamElem.prototype.draw = function(renderer) {
+	if (this.elems.length === 0 || this.allrests) return;
+	this.drawBeam(renderer);
+	this.drawStems(renderer);
+};
+
+ABCJS.write.BeamElem.prototype.calcDir = function() {
+	var average = this.average();
+	//	var barpos = (this.isgrace)? 5:7;
+	this.asc = (this.forceup || this.isgrace || average<6) && (!this.forcedown); // hardcoded 6 is B
+	return this.asc;
+};
+
+ABCJS.write.BeamElem.prototype.drawBeam = function(renderer) {
+	var average = this.average();
+	var barpos = (this.isgrace)? 5:7;
+	this.calcDir();
+
+	var barminpos = this.asc ? 5 : 8;	//PER: I just bumped up the minimum height for notes with descending stems to clear a rest in the middle of them.
+	this.pos = Math.round(this.asc ? Math.max(average+barpos,this.max+barminpos) : Math.min(average-barpos,this.min-barminpos));
+	var slant = this.elems[0].abcelem.averagepitch-this.elems[this.elems.length-1].abcelem.averagepitch;
+	if (this.isflat) slant=0;
+	var maxslant = this.elems.length/2;
+
+	if (slant>maxslant) slant = maxslant;
+	if (slant<-maxslant) slant = -maxslant;
+	this.starty = renderer.calcY(this.pos+Math.floor(slant/2));
+	this.endy = renderer.calcY(this.pos+Math.floor(-slant/2));
+
+	var starthead = this.elems[0].heads[(this.asc)? 0: this.elems[0].heads.length-1];
+	var endhead = this.elems[this.elems.length-1].heads[(this.asc)? 0: this.elems[this.elems.length-1].heads.length-1];
+	this.startx = starthead.x;
+	if(this.asc) this.startx+=starthead.w-0.6;
+	this.endx = endhead.x;
+	if(this.asc) this.endx+=endhead.w;
+
+	// PER: if the notes are too high or too low, make the beam go down to the middle
+	if (this.asc && this.pos < 6) {
+		this.starty = renderer.calcY(6);
+		this.endy = renderer.calcY(6);
+	} else if (!this.asc && this.pos > 6) {
+		this.starty = renderer.calcY(6);
+		this.endy = renderer.calcY(6);
+	}
+
+	var pathString = "M"+this.startx+" "+this.starty+" L"+this.endx+" "+this.endy+
+		"L"+this.endx+" "+(this.endy+this.dy) +" L"+this.startx+" "+(this.starty+this.dy)+"z";
+	renderer.printPath({path:pathString, stroke:"none", fill:"#000000", 'class': renderer.addClasses('beam-elem')});
+};
+
+ABCJS.write.BeamElem.prototype.drawStems = function(renderer) {
+	var auxbeams = [];  // auxbeam will be {x, y, durlog, single} auxbeam[0] should match with durlog=-4 (16th) (j=-4-durlog)
+	renderer.beginGroup();
+	for (var i=0,ii=this.elems.length; i<ii; i++) {
+		if (this.elems[i].abcelem.rest)
+			continue;
+		var furthesthead = this.elems[i].heads[(this.asc)? 0: this.elems[i].heads.length-1];
+		var ovaldelta = (this.isgrace)?1/3:1/5;
+		var pitch = furthesthead.pitch + ((this.asc) ? ovaldelta : -ovaldelta);
+		var y = renderer.calcY(pitch);
+		var x = furthesthead.x + ((this.asc) ? furthesthead.w: 0);
+		var bary=this.getBarYAt(x);
+		var dx = (this.asc) ? -0.6 : 0.6;
+		renderer.printStem(x,dx,y,bary);
+
+		var sy = (this.asc) ? 1.5*ABCJS.write.spacing.STEP: -1.5*ABCJS.write.spacing.STEP;
+		if (this.isgrace) sy = sy*2/3;
+		for (var durlog=ABCJS.write.getDurlog(this.elems[i].abcelem.duration); durlog<-3; durlog++) { // get the duration via abcelem because of triplets
+			if (auxbeams[-4-durlog]) {
+				auxbeams[-4-durlog].single = false;
+			} else {
+				auxbeams[-4-durlog] = {x:x+((this.asc)?-0.6:0), y:bary+sy*(-4-durlog+1),
+					durlog:durlog, single:true};
+			}
+		}
+
+		for (var j=auxbeams.length-1;j>=0;j--) {
+			if (i===ii-1 || ABCJS.write.getDurlog(this.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 = this.getBarYAt(auxbeamendx) + sy*(j+1);
+				}
+				// TODO I think they are drawn from front to back, hence the small x difference with the main beam
+
+				var pathString ="M"+auxbeams[j].x+" "+auxbeams[j].y+" L"+auxbeamendx+" "+auxbeamendy+
+					"L"+auxbeamendx+" "+(auxbeamendy+this.dy) +" L"+auxbeams[j].x+" "+(auxbeams[j].y+this.dy)+"z";
+				renderer.printPath({path:pathString, stroke:"none", fill:"#000000", 'class': renderer.addClasses('beam-elem')});
+				auxbeams = auxbeams.slice(0,j);
+			}
+		}
+	}
+	renderer.endGroup('beam-elem');
+};
+
+ABCJS.write.BeamElem.prototype.getBarYAt = function(x) {
+	return this.starty + (this.endy-this.starty)/(this.endx-this.startx)*(x-this.startx);
+};

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

@@ -0,0 +1,46 @@
+//    abc_crescendo_element.js: Definition of the CrescendoElem class.
+//    Copyright (C) 2010,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 = {};
+
+ABCJS.write.CrescendoElem = function(anchor1, anchor2, dir) {
+	this.anchor1 = anchor1; // must have a .x and a .parent property or be null (means starts at the "beginning" of the line - after keysig)
+	this.anchor2 = anchor2; // must have a .x property or be null (means ends at the end of the line)
+	this.dir = dir; // either "<" or ">"
+};
+
+ABCJS.write.CrescendoElem.prototype.draw = function (renderer) {
+	if (this.dir === "<") {
+		this.drawLine(renderer, 0, -4);
+		this.drawLine(renderer, 0, 4);
+	} else {
+		this.drawLine(renderer, -4, 0);
+		this.drawLine(renderer, 4, 0);
+	}
+};
+
+ABCJS.write.CrescendoElem.prototype.drawLine = function (renderer, y1, y2) {
+	var ypos = renderer.layouter.minY - 7;
+	var pathString = ABCJS.write.sprintf("M %f %f L %f %f",
+		this.anchor1.x, renderer.calcY(ypos)+y1-4, this.anchor2.x, renderer.calcY(ypos)+y2-4);
+	renderer.printPath({path:pathString, stroke:"#000000", 'class': renderer.addClasses('decoration')});
+};

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

@@ -0,0 +1,36 @@
+//    abc_dynamic_decoration.js: Definition of the DynamicDecoration class.
+//    Copyright (C) 2010,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 = {};
+
+ABCJS.write.DynamicDecoration = function(anchor, dec) {
+	this.anchor = anchor;
+	this.dec = dec;
+};
+
+ABCJS.write.DynamicDecoration.prototype.draw = function(renderer, linestartx, lineendx) {
+	var ypos = renderer.layouter.minY - 7;
+	var scalex = 1; // TODO-PER: do the scaling
+	var scaley = 1;
+	renderer.printSymbol(this.anchor.x, ypos, this.dec, scalex, scaley, renderer.addClasses('decoration'));
+};
+

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

@@ -0,0 +1,53 @@
+//    abc_ending_element.js: Definition of the EndingElement class.
+//    Copyright (C) 2010,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 = {};
+
+ABCJS.write.EndingElem = function(text, anchor1, anchor2) {
+	this.text = text; // text to be displayed top left
+	this.anchor1 = anchor1; // must have a .x property or be null (means starts at the "beginning" of the line - after keysig)
+	this.anchor2 = anchor2; // must have a .x property or be null (means ends at the end of the line)
+};
+
+ABCJS.write.EndingElem.prototype.draw = function (renderer, linestartx, lineendx) {
+	var pathString;
+	if (this.anchor1) {
+		linestartx = this.anchor1.x+this.anchor1.w;
+		pathString = ABCJS.write.sprintf("M %f %f L %f %f",
+			linestartx, renderer.y, linestartx, renderer.y+10);
+		renderer.printPath({path:pathString, stroke:"#000000", fill:"#000000", 'class': renderer.addClasses('ending')}); //TODO scale
+		renderer.printText(linestartx+5*renderer.scale, 18.5, this.text, "start", 'ending').attr({"font-size":""+10*renderer.scale+"px"});
+	}
+
+	if (this.anchor2) {
+		lineendx = this.anchor2.x;
+		pathString = ABCJS.write.sprintf("M %f %f L %f %f",
+			lineendx, renderer.y, lineendx, renderer.y+10);
+		renderer.printPath({path:pathString, stroke:"#000000", fill:"#000000", 'class': renderer.addClasses('ending')}); // TODO scale
+	}
+
+
+	pathString = ABCJS.write.sprintf("M %f %f L %f %f",
+		linestartx, renderer.y, lineendx, renderer.y);
+	renderer.printPath({path:pathString, stroke:"#000000", fill:"#000000", 'class': renderer.addClasses('ending')});  // TODO scale
+};
+