abcjs 6.0.0-beta.9 → 6.0.2

package/src/tablatures/instruments/string-patterns.js

@@ -0,0 +1,277 @@
+var TabNote = require('./tab-note');
+var TabNotes = require('./tab-notes');
+
+
+function buildCapo(self) {
+  var capoTuning = null;
+  var tuning = self.tuning;
+  if (self.capo > 0) {
+    capoTuning = [];
+    for (var iii = 0; iii < tuning.length; iii++) {
+      var curNote = new TabNote.TabNote(tuning[iii]);
+      for (var jjj = 0; jjj < self.capo; jjj++) {
+        curNote = curNote.nextNote();
+      }
+      capoTuning[iii] = curNote.emit();
+    }
+  }
+  return capoTuning;
+}
+
+function buildPatterns(self) {
+  var strings = [];
+  var tuning = self.tuning;
+  if (self.capo > 0) {
+    tuning = self.capoTuning;
+  }
+  var pos = tuning.length - 1;
+  for (var iii = 0; iii < tuning.length; iii++) {
+    var nextNote = self.highestNote; // highest handled note
+    if (iii != tuning.length - 1) {
+      nextNote = tuning[iii + 1];
+    }
+    var tabNotes = new TabNotes(tuning[iii],nextNote);
+    var stringNotes = tabNotes.build();
+    if (stringNotes.error) {
+      return stringNotes;
+    }
+    strings[pos--] = stringNotes;
+  }
+  return strings;
+}
+
+
+function buildSecond(first) {
+  var seconds = [];
+  seconds[0] = [];
+  var strings = first.strings;
+  for (var iii = 1; iii < strings.length; iii++) {
+    seconds[iii] = strings[iii - 1];
+  }
+  return seconds;
+}
+
+function sameString(self, chord) {
+  for (var jjjj = 0; jjjj < chord.length - 1; jjjj++) {
+    var curPos = chord[jjjj];
+    var nextPos = chord[jjjj + 1];
+    if (curPos.str == nextPos.str) {
+      // same String
+      // => change lower pos 
+      if (curPos.str == self.strings.length - 1) {
+        // Invalid tab Chord position for instrument
+        curPos.num = "?";
+        nextPos.num = "?"; 
+        return; 
+      }
+      // change lower pitch on lowest string
+      if (nextPos.num < curPos.num) {
+        nextPos.str++;
+        nextPos = noteToNumber(self,
+          nextPos.note,
+          nextPos.str,
+          self.secondPos,
+          self.strings[nextPos.str].length
+        );
+      } else {
+        curPos.str++;
+        curPos = noteToNumber(self,
+          curPos.note,
+          curPos.str,
+          self.secondPos,
+          self.strings[curPos.str].length
+        );
+      }
+      // update table
+      chord[jjjj] = curPos;
+      chord[jjjj + 1] = nextPos;
+    }
+  }
+  return null;
+}
+
+function handleChordNotes(self, notes) {
+  var retNotes = [];
+  for (var iiii = 0; iiii < notes.length; iiii++) {
+    var note = new TabNote.TabNote(notes[iiii].name);
+    var curPos = toNumber(self, note);
+    retNotes.push(curPos);
+  }
+  sameString(self, retNotes);
+  return retNotes;
+}
+
+function noteToNumber(self, note, stringNumber, secondPosition , firstSize) {
+  var strings = self.strings;
+  note.checkKeyAccidentals(self.accidentals) ;
+  if (secondPosition) {
+    strings = secondPosition;
+  }
+  var noteName = note.emitNoAccidentals();
+  var num = strings[stringNumber].indexOf(noteName);
+  var acc = note.acc;
+  if (num != -1) {
+    if (secondPosition) {
+      num += firstSize;
+    }
+    if ( (note.isFlat || note.acc == -1) && (num == 0)) {
+      // flat on 0 pos => previous string 7th position
+      var noteEquiv = note.getAccidentalEquiv();
+      stringNumber++;
+      num = strings[stringNumber].indexOf(noteEquiv.emit());
+      acc = 0;
+    }
+    return {
+      num: (num + acc),
+      str: stringNumber,
+      note: note
+    };
+  }
+  return null;
+}
+
+function toNumber(self, note) {
+  var num = null;
+  var str = 0;
+  var lowestString = self.strings[self.strings.length - 1];
+  var lowestNote = new TabNote.TabNote(lowestString[0]);
+  if (note.isLowerThan(lowestNote) ) {
+    return {
+      num: "?",
+      str: self.strings.length - 1,
+      note: note,
+      error: note.emit() + ': unexpected note for instrument' 
+    };
+  }
+  while (str < self.strings.length) {
+    num = noteToNumber(self, note, str);
+    if (num) {
+      return num;
+    }
+    str++;
+  }
+  return null; // not found
+}
+
+StringPatterns.prototype.stringToPitch = function (stringNumber) {
+  var startingPitch = 5.3;
+  var bottom = this.strings.length - 1;
+  return startingPitch + ((bottom - stringNumber) * this.linePitch);
+};
+
+function invalidNumber( retNotes , note ) {
+  var number = {
+    num: "?",
+    str: 0,
+    note: note
+  };
+  retNotes.push(number);
+  retNotes.error = note.emit() + ': unexpected note for instrument' ;
+} 
+
+StringPatterns.prototype.notesToNumber = function (notes, graces) {
+  var note;
+  var number;
+  var error = null; 
+  var retNotes = null;
+  if (notes) {
+    retNotes = [];
+    if (notes.length > 1) {
+      retNotes = handleChordNotes(this, notes);
+      if (retNotes.error) {
+        error = retNotes.error;
+      }
+    } else {
+      note = new TabNote.TabNote(notes[0].name);
+      number = toNumber(this, note);
+      if (number) {
+        retNotes.push(number);
+      } else {
+        invalidNumber(retNotes, note);
+        error = retNotes.error;
+      }
+    }
+  }  
+  if (error) return retNotes;
+  var retGraces = null;
+  if (graces) {
+    retGraces = [];
+    for (var iiii = 0; iiii < graces.length; iiii++) {
+      note = new TabNote.TabNote(graces[iiii].name);
+      number = toNumber(this, note);
+      if (number) {
+        retGraces.push(number);
+      } else {
+        invalidNumber(retGraces, note);
+        error = retNotes.error;
+      }
+    }
+  }
+    
+  return {
+    notes: retNotes,
+    graces: retGraces,
+    error: error
+  };
+};
+
+StringPatterns.prototype.toString = function () {
+  return this.tuning.join('').replaceAll(',', '').toUpperCase();
+};
+
+StringPatterns.prototype.tabInfos = function (plugin) {
+  var _super = plugin._super;
+  var name = _super.params.label;
+  if (name) {
+    var tunePos = name.indexOf('%T');
+    var tuning = "";
+    if (tunePos != -1) {
+      tuning = this.toString();
+      if (plugin.capo > 0) {
+        tuning += ' capo:' + plugin.capo;
+      }
+      name = name.replace('%T', tuning);
+    }
+    return name;
+  }
+  return '';
+};
+
+/**
+ * Common patterns for all string instruments
+ * @param {} plugin
+ * @param {} tuning
+ * @param {*} capo
+ * @param {*} highestNote 
+ */
+function StringPatterns(plugin) {
+  var tuning = plugin.tuning;
+  var capo = plugin.capo;
+  var highestNote = plugin._super.params.highestNote;
+  this.linePitch = plugin.linePitch;
+  this.highestNote = "a'";
+  if (highestNote) {
+    // override default
+    this.highestNote = highestNote;
+  }
+  this.capo = 0;
+  if (capo) {
+    this.capo = capo;
+  }
+  this.tuning = tuning;
+  if (this.capo > 0) {
+    this.capoTuning = buildCapo(this);
+  }
+  this.strings = buildPatterns(this);
+  if (this.strings.error) {
+    plugin._super.setError(this.strings.error);
+    plugin.inError = true;
+    return;
+  }
+  // second position pattern per string
+  this.secondPos = buildSecond(this);
+}
+
+
+
+module.exports = StringPatterns;

package/src/tablatures/instruments/string-tablature.js

@@ -0,0 +1,56 @@
+
+/**
+ * Layout tablature informations for draw
+ * @param {*} numLines 
+ * @param {*} lineSpace 
+ */
+
+function StringTablature(numLines, lineSpace) {
+  this.numLines = numLines;
+  this.lineSpace = lineSpace;
+  this.verticalSize = this.numLines * this.lineSpace;
+  var pitch = 3;
+  this.bar = {
+    pitch: pitch,
+    pitch2: lineSpace * numLines,
+    height: 5,
+  };
+}
+
+/**
+ * return true if current line should not produce a tab
+ * @param {} line 
+ */
+StringTablature.prototype.bypass = function (line) {
+  var voices = line.staffGroup.voices;
+  if (voices.length > 0) {
+    if (voices[0].isPercussion) return true;
+  }
+  return false;
+};  
+
+
+StringTablature.prototype.setRelative = function (child, relative, first) {
+  switch (child.type) {
+    case 'bar':
+      relative.pitch = this.bar.pitch;
+      relative.pitch2 = this.bar.pitch2;
+      relative.height = this.height;
+      break;
+    case 'symbol':
+      var top = this.bar.pitch2 / 2;
+      if (child.name == 'dots.dot') {
+        if (first) {
+          relative.pitch = top;
+          return false;
+        } else {
+          relative.pitch = top + this.lineSpace;
+          return true;
+        }
+      }
+      break;
+  }
+  return first;
+};
+
+module.exports = StringTablature;

package/src/tablatures/instruments/tab-note.js

@@ -0,0 +1,282 @@
+/**
+ * 
+ * Note structure for Tabs
+ * 
+ */
+var notes = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
+
+
+function TabNote(note) {
+  var isFlat = false;
+  var newNote = note;
+  var isSharp = false;
+  var isAltered = false;
+  var natural = null;
+  var quarter = null;
+  var isDouble = false;
+  var acc = 0;
+
+  if (note.startsWith('_')) {
+    isFlat = true;
+    acc = -1;
+    // check quarter flat
+    if (note[1] == '/') {
+      isFlat = false;
+      quarter = "v";
+      acc = 0;
+    } else if (note[1] == '_') {
+      // double flat
+      isDouble = true;
+      acc -= 1;
+    }
+  } else if (note.startsWith('^')) {
+    isSharp = true;
+    acc = +1;
+    // check quarter sharp
+    if (note[1] == '/') {
+      isSharp = false;
+      quarter = "^";
+      acc = 0;
+    } else if (note[1] == '^') {
+      // double sharp
+      isDouble = true;
+      acc += 1;
+    }
+  } else if (note.startsWith('=')) {
+    natural = true;
+    acc = 0;
+  }
+  isAltered = isFlat || isSharp || (quarter != null);
+  if (isAltered || natural) {
+    if ((quarter != null) || (isDouble)) {
+      newNote = note.slice(2);
+    } else {
+      newNote = note.slice(1);
+    }
+  }
+  var hasComma = (note.match(/,/g) || []).length;
+  var hasQuote = (note.match(/'/g) || []).length;
+
+  this.name = newNote;
+  this.acc = acc;
+  this.isSharp = isSharp;
+  this.isKeySharp = false;
+  this.isDouble = isDouble;
+  this.isAltered = isAltered;
+  this.isFlat = isFlat;
+  this.isKeyFlat = false;
+  this.natural = natural;
+  this.quarter = quarter;
+  this.isLower = (this.name == this.name.toLowerCase());
+  this.name = this.name[0].toUpperCase();
+  this.hasComma = hasComma;
+  this.isQuoted = hasQuote;
+}
+
+function cloneNote(self) {
+  var newNote = self.name;
+  var newTabNote = new TabNote(newNote);
+  newTabNote.hasComma = self.hasComma;
+  newTabNote.isLower = self.isLower;
+  newTabNote.isQuoted = self.isQuoted;
+  newTabNote.isSharp = self.isSharp;
+  newTabNote.isKeySharp = self.isKeySharp;
+  newTabNote.isFlat = self.isFlat;
+  newTabNote.isKeyFlat = self.isKeyFlat;
+  return newTabNote;
+} 
+TabNote.prototype.sameNoteAs = function (note) {
+  if ((this.name == note.name) &&
+    (this.hasComma == note.hasComma) &&
+    (this.isLower == note.isLower) &&
+    (this.isQuoted == note.isQuoted) &&
+    (this.isSharp == note.isSharp) &&
+    (this.isFlat == note.isFlat)) {
+    return true;
+  } else {
+    return false;
+  }
+};
+
+TabNote.prototype.isLowerThan = function (note) {
+  var noteComparator = ['C','D','E','F','G','A','B'];
+  if (this.hasComma > note.hasComma) return true;
+  if (note.hasComma > this.hasComma) return false;
+  if (this.isQuoted > note.isQuoted) return false;
+  if (note.isQuoted > this.isQuoted) return true;
+  if (this.isLower) {
+    if (!note.isLower) return false;
+  } else {
+    if (note.isLower) return true;
+  }
+  var noteName = note.name[0].toUpperCase();
+  var thisName = this.name[0].toUpperCase();
+  if (noteComparator.indexOf(thisName) < noteComparator.indexOf(noteName)) return true;
+  return false;
+};
+
+TabNote.prototype.checkKeyAccidentals = function(accidentals) {
+  if (accidentals) {
+    var curNote = this.name;
+    for (var iii = 0; iii < accidentals.length; iii++) {
+      var curAccidentals = accidentals[iii];
+      if (curNote == curAccidentals.note.toUpperCase()) {
+        if (curAccidentals.acc == 'flat') {
+          this.acc = -1;
+          this.isKeyFlat = true;
+        }
+        if (curAccidentals.acc == 'sharp') {
+          this.acc = +1;
+          this.isKeySharp = true;
+        }
+      }
+    }
+  }
+};
+
+TabNote.prototype.getAccidentalEquiv = function () {
+  var cloned = cloneNote(this);
+  if (cloned.isSharp || cloned.isKeySharp ) {
+    cloned = cloned.nextNote();
+    cloned.isFlat = true;
+    cloned.isSharp = false;
+    cloned.isKeySharp = false;
+  } else if (cloned.isFlat || cloned.isKeyFlat ) {
+    cloned = cloned.prevNote();
+    cloned.isSharp = true;
+    cloned.isFlat = false;
+    cloned.isKeyFlat = false;
+  }
+  return cloned;
+};
+
+
+TabNote.prototype.nextNote = function () {
+  var newTabNote = cloneNote(this);
+
+  if (!this.isSharp && !this.isKeySharp ) {
+    if (this.name != 'E' && this.name != 'B') {
+      newTabNote.isSharp = true;
+      return newTabNote;
+    }
+  } else {
+    // cleanup
+    newTabNote.isSharp = false; 
+    newTabNote.isKeySharp = false; 
+  }
+  var noteIndex = notes.indexOf(this.name);
+  if (noteIndex == notes.length - 1) {
+    noteIndex = 0;
+  } else {
+    noteIndex++;
+  }
+  newTabNote.name = notes[noteIndex];
+  if (newTabNote.name == 'C') {
+    if (newTabNote.hasComma > 0) {
+      newTabNote.hasComma--;
+    } else {
+      if (!newTabNote.isLower) {
+        newTabNote.isLower = true;
+      } else {
+        newTabNote.isQuoted = true;
+      }
+    }
+  }
+  return newTabNote;
+};
+
+TabNote.prototype.prevNote = function () {
+  var newTabNote = cloneNote(this);
+
+  if (this.isSharp) {
+    newTabNote.isSharp = false;
+    return newTabNote;
+  }
+  var noteIndex = notes.indexOf(this.name);
+  if (noteIndex == 0) {
+    noteIndex = notes.length - 1;
+  } else {
+    noteIndex--;
+  }
+  newTabNote.name = notes[noteIndex];
+  if (newTabNote.name == 'B') {
+    if (newTabNote.isLower) {
+      newTabNote.hasComma = 1;
+    } else {
+      if (newTabNote.hasComma > 0) {
+        newTabNote.hasComma++;
+      } else {
+        if (newTabNote.isQuoted > 0) {
+          newTabNote.isQuoted -= 1;
+        } else {
+          newTabNote.isLower = true;
+        }
+      }
+    }
+  }
+  if (this.isFlat) {
+    newTabNote.isFlat = false;
+    return newTabNote;
+  } else {
+    if (this.name != 'E' && this.name != 'B') {
+      newTabNote.isSharp = true;
+    }
+  }
+  return newTabNote;
+};
+
+TabNote.prototype.emitNoAccidentals = function (  ) {
+  var returned = this.name;
+  if (this.isLower) {
+    returned = returned.toLowerCase();
+  }
+  for (var ii = 0; ii < this.isQuoted; ii++) {
+    returned += "'";
+  }
+  for (var jj = 0; jj < this.hasComma; jj++) {
+    returned += ",";
+  }
+  return returned;
+};
+
+TabNote.prototype.emit = function () {
+  var returned = this.name;
+  if (this.isSharp || this.isKeySharp ) {
+    returned = '^' + returned;
+    if (this.isDouble) {
+      returned = '^' + returned;
+    }
+  }
+  if (this.isFlat || this.isKeyFlat) {
+    returned = '_' + returned;
+    if (this.isDouble) {
+      returned = '_' + returned;
+    }
+  }
+  if (this.quarter) {
+    if (this.quarter == "^") {
+      returned = "^/" + returned;
+    } else {
+      returned = "_/" + returned;
+    }
+  }
+  if (this.natural) {
+    returned = '=' + returned;
+  }
+  for (var ii = 1; ii <= this.hasComma; ii++) {
+    returned += ',';
+  }
+  
+  if (this.isLower) {
+    returned = returned.toLowerCase();
+    for (var jj = 1; jj <= this.isQuoted; jj++) {
+      returned += "'";
+    }
+  }
+  return returned;
+};
+
+module.exports = {
+  'TabNote': TabNote,
+  'notes': notes
+};

package/src/tablatures/instruments/tab-notes.js

@@ -0,0 +1,41 @@
+
+var TabNote = require('./tab-note');
+
+var notes = TabNote.notes;
+
+function TabNotes(fromNote, toNote) {
+  this.fromN = new TabNote.TabNote(fromNote);
+  this.toN = new TabNote.TabNote(toNote);
+}
+
+
+TabNotes.prototype.build = function () {
+  var fromN = this.fromN;
+  var toN = this.toN;
+  // check that toN is not lower than fromN
+  if (toN.isLowerThan(fromN)) {
+    var from = fromN.emit();
+    var tn = toN.emit();
+    return {
+      error: 'Invalid string Instrument tuning : ' +
+        tn + ' string lower than ' + from + ' string'
+    };
+  }
+  var buildReturned = [];
+  var startIndex = notes.indexOf(fromN.name);
+  var toIndex = notes.indexOf(toN.name);
+  if ((startIndex == -1) || (toIndex == -1)) {
+    return buildReturned;
+  }
+  var finished = false;
+  while (!finished) {
+    buildReturned.push(fromN.emit());
+    fromN = fromN.nextNote();
+    if (fromN.sameNoteAs(toN)) {
+      finished = true;
+    }
+  }
+  return buildReturned;
+};
+
+module.exports = TabNotes;

package/src/tablatures/instruments/violin/tab-violin.js

@@ -0,0 +1,47 @@
+
+var StringTablature = require('../string-tablature');
+var TabCommon = require('../../tab-common');
+var TabRenderer = require('../../tab-renderer');
+var ViolinPatterns = require('./violin-patterns');
+var setViolinFonts = require('./violin-fonts');
+
+
+/**
+ * upon init mainly store provided instances for later usage
+ * @param {*} abcTune  the parsed tune AST tree
+*  @param {*} tuneNumber  the parsed tune AST tree
+ * @param {*} params  complementary args provided to Tablature Plugin
+ */
+Plugin.prototype.init = function (abcTune, tuneNumber, params) {
+  var _super = new TabCommon(abcTune, tuneNumber, params);
+  this.abcTune = abcTune;
+  this._super = _super;
+  this.linePitch = 3;
+  this.nbLines = 4;
+  this.isTabBig = false;
+  this.capo = params.capo;
+  this.transpose = params.visualTranspose;
+  this.tablature = new StringTablature(this.nbLines,
+    this.linePitch);
+  var semantics = new ViolinPatterns(this);
+  this.semantics = semantics;
+};
+
+Plugin.prototype.render = function (renderer, line, staffIndex) {
+  if (this._super.inError) return;
+  if (this.tablature.bypass(line)) return;
+  setViolinFonts(this.abcTune);
+  var rndrer = new TabRenderer(this, renderer, line, staffIndex);
+  rndrer.doLayout();
+};
+
+function Plugin() {}
+
+//
+// Tablature plugin definition
+//
+var AbcViolinTab = function () {
+  return { name: 'ViolinTab', tablature: Plugin };
+};
+
+module.exports = AbcViolinTab;

package/src/tablatures/instruments/violin/violin-fonts.js

@@ -0,0 +1,19 @@
+
+/**
+ * Dedicated fonts for violin tabs
+ */
+
+/**
+ * Set here the fonts used by renderer/drawer 
+ * for the violin plugin
+ * @param {} tune 
+ */
+// eslint-disable-next-line no-unused-vars
+function setViolinFonts(tune) {
+  /* enhance or change instrument fonts here */
+  // tune.formatting.tabnumberfont = { face: "\"Times New Roman\"", size: 9, weight: "normal", style: "normal", decoration: "none" };
+  // tune.formatting.tabgracefont = { face: "\"Times New Roman\"", size: 7, weight: "normal", style: "normal", decoration: "none" };
+}
+
+module.exports = setViolinFonts;
+