abcjs 6.0.0-beta.9 → 6.0.2

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

@@ -0,0 +1,23 @@
+var StringPatterns = require('../string-patterns');
+
+function ViolinPatterns(plugin) {
+  this.tuning = plugin._super.params.tuning;
+  if (!this.tuning) {
+    this.tuning = ['G,', 'D', 'A', 'e'];
+  }
+  plugin.tuning = this.tuning;
+  this.strings = new StringPatterns(plugin);
+}
+
+ViolinPatterns.prototype.notesToNumber = function (notes, graces) {
+  var converter = this.strings;
+  return converter.notesToNumber(notes, graces);
+};
+
+ViolinPatterns.prototype.stringToPitch = function (stringNumber) {
+  var converter = this.strings;
+  return converter.stringToPitch(stringNumber);
+};
+
+
+module.exports = ViolinPatterns;

package/src/tablatures/tab-absolute-elements.js

@@ -0,0 +1,310 @@
+/**
+ * Tablature Absolute elements factory
+ */
+var AbsoluteElement = require('../write/abc_absolute_element');
+var RelativeElement = require('../write/abc_relative_element');
+var Transposer = require('./transposer');
+
+function isObject(a) { return a != null && a.constructor === Object; }
+function cloneObject(dest, src) {
+  for (var prop in src) {
+    if (src.hasOwnProperty(prop)) {
+      if (!(Array.isArray(src[prop]) || isObject(src[prop]))) {
+        dest[prop] = src[prop];
+      }
+    }
+  }
+}
+
+function cloneAbsolute(absSrc) {
+  var returned = new AbsoluteElement('', 0, 0, '', 0);
+  cloneObject(returned, absSrc);
+  returned.top = 0;
+  returned.bottom = -1;
+  if (absSrc.abcelem) {
+    returned.abcelem = {};
+    cloneObject(returned.abcelem, absSrc.abcelem);
+    if (returned.abcelem.el_type === "note")
+      returned.abcelem.el_type = 'tabNumber';
+  }
+  return returned;
+}
+
+function cloneAbsoluteAndRelatives(absSrc, plugin) {
+  var returned = cloneAbsolute(absSrc);
+  if (plugin) {
+    var children = absSrc.children;
+    // proceed with relative as well
+    var first = true;
+    for (var ii = 0; ii < children.length; ii++) {
+      var child = children[ii];
+      var relative = new RelativeElement('', 0, 0, 0, '');
+      cloneObject(relative, child);
+      first = plugin.tablature.setRelative(child, relative, first);
+      returned.children.push(relative);
+    }
+  }
+  return returned;
+}
+
+function buildTabAbsolute(plugin, absX, relX) {
+  var tabIcon = 'tab.tiny';
+  var tabYPos = 7.5;
+  if (plugin.isTabBig) {
+    tabIcon = 'tab.big';
+    tabYPos = 10;
+  }
+  var element = {
+    el_type: "tab",
+    icon: tabIcon,
+    Ypos: tabYPos
+  };
+  var tabAbsolute = new AbsoluteElement(element, 0, 0, "symbol", 0);
+  tabAbsolute.x = absX;
+  var tabRelative = new RelativeElement(tabIcon, 0, 0, 7.5, "tab");
+  tabRelative.x = relX;
+  tabAbsolute.children.push(tabRelative);
+  if (tabAbsolute.abcelem.el_type == 'tab') {
+    tabRelative.pitch = tabYPos;
+  }
+  return tabAbsolute;
+}
+
+function lyricsDim(abs) {
+  if (abs.extra) {
+    for (var ii = 0; ii < abs.extra.length; ii++) {
+      var extra = abs.extra[ii];
+      if (extra.type == 'lyric') {
+        return {
+          bottom: extra.bottom,
+          height: extra.height
+        };
+      }
+    }
+  }
+  return null;
+}
+function TabAbsoluteElements() {
+  this.accidentals = null;
+}
+
+function getInitialStaffSize(staffGroup) {
+  var returned = 0;
+  for (var ii = 0; ii < staffGroup.length; ii++) {
+    if (!staffGroup[ii].tabNameInfos) returned++;
+  }
+  return returned;
+}
+
+function buildRelativeTabNote(plugin, relX, def, curNote, isGrace) {
+  var strNote = curNote.num;
+  if (curNote.note.quarter != null) {
+    // add tab quarter => needs to string conversion then 
+    strNote = strNote.toString();
+    strNote += curNote.note.quarter;
+  }
+  var pitch = plugin.semantics.stringToPitch(curNote.str);
+  def.notes.push({ num: strNote, str: curNote.str, pitch: curNote.note.emit() });
+  var opt = {
+    type: 'tabNumber'
+  };
+  var tabNoteRelative = new RelativeElement(
+    strNote, 0, 0, pitch+0.3, opt);
+  tabNoteRelative.x = relX;
+  tabNoteRelative.isGrace = isGrace;
+  tabNoteRelative.isAltered = curNote.note.isAltered;
+  return tabNoteRelative;
+}
+
+function getXGrace(abs, index) {
+  var found = 0;
+  if (abs.extra) {
+    for (var ii = 0; ii < abs.extra.length; ii++) {
+      if (abs.extra[ii].c.indexOf('noteheads') >= 0) {
+        if (found === index) {
+          return abs.extra[ii].x + abs.extra[ii].w/2;
+        } else {
+          found++;
+        }
+      }
+    }
+  }
+  return -1;
+}
+
+function graceInRest( absElem ) {
+  if (absElem.abcelem) {
+    var elem = absElem.abcelem; 
+    if (elem.rest) {
+      return elem.gracenotes;
+    }
+  }
+  return null;
+}
+
+function checkTransposition(plugin, transposer ,pitches, graceNotes) {
+  if (plugin.transpose) {
+    //transposer.transpose(plugin.transpose);
+    for (var jj = 0; jj < pitches.length; jj++) {
+      pitches[jj] = transposer.transposeNote(pitches[jj]);
+    }
+    if (graceNotes) {
+      for (var kk = 0; kk < graceNotes.length; kk++) {
+        graceNotes[kk] = transposer.transposeNote(graceNotes[kk]);
+      }
+    }
+  }
+}
+
+function convertToNumber(plugin, pitches, graceNotes) {
+  var tabPos = plugin.semantics.notesToNumber(pitches, graceNotes);
+  if (tabPos.error) {
+    plugin._super.setError(tabPos.error);
+    return tabPos; // give up on error here
+  }
+  if (tabPos.graces && tabPos.notes) {
+    // add graces to last note in notes
+    var posNote = tabPos.notes.length - 1;
+    tabPos.notes[posNote].graces = tabPos.graces;
+  }
+  return tabPos;
+}
+
+function buildGraceRelativesForRest(plugin,abs,absChild,graceNotes,tabVoice) {
+  for (var mm = 0; mm < graceNotes.length; mm++) {
+    var defGrace = { el_type: "note", startChar: absChild.abcelem.startChar, endChar: absChild.abcelem.endChar, notes: [], grace: true };
+    var graceX = getXGrace(absChild, mm);
+    var curGrace = graceNotes[mm];
+    var tabGraceRelative = buildRelativeTabNote(plugin, graceX, defGrace, curGrace, true);
+    abs.children.push(tabGraceRelative);
+    tabVoice.push(defGrace);
+  }
+}
+
+/**
+ * Build tab absolutes by scanning current staff line absolute array
+ * @param {*} staffAbsolute
+ */
+TabAbsoluteElements.prototype.build = function (plugin,
+  staffAbsolute,
+  tabVoice,
+  voiceIndex,
+  staffIndex,
+  keySig ) {
+  var staffSize = getInitialStaffSize(staffAbsolute);
+  var source = staffAbsolute[staffIndex+voiceIndex];
+  var dest = staffAbsolute[staffSize+staffIndex+voiceIndex];
+  var transposer = null;
+  var tabPos = null;
+  var defNote = null;
+  if (source.children[0].abcelem.el_type != 'clef') {
+    // keysig missing => provide one for tabs
+    if (keySig != 'none') {
+      source.children.splice(0, 0, keySig);
+    }  
+  }
+  for (var ii = 0; ii < source.children.length; ii++) {
+    var absChild = source.children[ii];
+    var absX = absChild.x;
+    var relX = absX;
+    // if (absChild.children.length > 0) {
+    //   relX = absChild.children[0].x;
+    // }
+    if ( (absChild.isClef) ) {
+      dest.children.push(buildTabAbsolute(plugin, absX, relX));
+    }
+    switch (absChild.type) {
+      case 'staff-extra key-signature':
+        // refresh key accidentals
+        this.accidentals = absChild.abcelem.accidentals;
+        plugin.semantics.strings.accidentals = this.accidentals;
+        if (plugin.transpose) {
+          transposer = new Transposer(
+            absChild.abcelem.accidentals,
+            plugin.transpose 
+          );
+        }
+        break;
+      case 'bar':
+        var lastBar = false;
+        if (ii === source.children.length-1) {
+          // used for final line bar drawing
+          // for multi tabs / multi staves
+          lastBar = true;
+        }
+        var cloned = cloneAbsoluteAndRelatives(absChild, plugin);
+        if (cloned.abcelem.barNumber) {
+          delete cloned.abcelem.barNumber;
+          for (var bn = 0; bn < cloned.children.length; bn++) {
+            if (cloned.children[bn].type === "barNumber" ) {
+              cloned.children.splice(bn, 1);
+              break;
+            }
+          }
+        }
+        cloned.abcelem.lastBar = lastBar;
+        dest.children.push(cloned);
+        tabVoice.push({
+          el_type: absChild.abcelem.el_type,
+          type: absChild.abcelem.type,
+          endChar: absChild.abcelem.endChar,
+          startChar: absChild.abcelem.startChar,
+          abselem: cloned
+        });
+        break;
+      case 'rest':
+        var restGraces = graceInRest(absChild);
+        if (restGraces) {
+          // check transpose
+          checkTransposition(plugin, transposer, null, restGraces);
+          // to number conversion 
+          tabPos = convertToNumber(plugin, null, restGraces);
+          if (tabPos.error) return;
+          // build relative for grace
+          defGrace = { el_type: "note", startChar: absChild.abcelem.startChar, endChar: absChild.abcelem.endChar, notes: [], grace: true };
+          buildGraceRelativesForRest(plugin, abs, absChild, tabPos.graces, tabVoice);
+       }
+        break;
+      case 'note':
+        var abs = cloneAbsolute(absChild);
+        abs.x = absChild.heads[0].x + absChild.heads[0].w / 2; // center the number
+        abs.lyricDim = lyricsDim(absChild);
+        var pitches = absChild.abcelem.pitches;
+        var graceNotes = absChild.abcelem.gracenotes;
+        // check transpose
+        abs.type = 'tabNumber';
+        checkTransposition(plugin, transposer, pitches, graceNotes);
+        // to number conversion 
+        tabPos = convertToNumber(plugin, pitches, graceNotes);   
+        if (tabPos.error) return;
+        if (tabPos.graces) {
+          // add graces to last note in notes
+          var posNote = tabPos.notes.length - 1;
+          tabPos.notes[posNote].graces = tabPos.graces;
+        }
+        // build relative
+        defNote = { el_type: "note", startChar: absChild.abcelem.startChar, endChar: absChild.abcelem.endChar, notes: [] };
+        for (var ll = 0; ll < tabPos.notes.length; ll++) {
+          var curNote = tabPos.notes[ll];
+          if (curNote.graces) {
+            for (var mm = 0; mm < curNote.graces.length; mm++) {
+              var defGrace = { el_type: "note", startChar: absChild.abcelem.startChar, endChar: absChild.abcelem.endChar, notes: [], grace: true };
+              var graceX = getXGrace(absChild , mm);
+              var curGrace = curNote.graces[mm];
+              var tabGraceRelative = buildRelativeTabNote(plugin, graceX, defGrace, curGrace, true);
+              abs.children.push(tabGraceRelative);
+              tabVoice.push(defGrace);
+            }
+          }
+          var tabNoteRelative = buildRelativeTabNote(plugin, abs.x+absChild.heads[ll].dx, defNote, curNote, false);
+          abs.children.push(tabNoteRelative);
+        }
+        defNote.abselem = abs;
+        tabVoice.push(defNote);
+        dest.children.push(abs);
+        break;
+    }
+  }
+};
+
+module.exports = TabAbsoluteElements;

package/src/tablatures/tab-common.js

@@ -0,0 +1,29 @@
+/**
+ *
+ * Common Class/Method available for all instruments
+ *
+ */
+
+function TabCommon(abcTune, tuneNumber, params) {
+  this.tune = abcTune;
+  this.params = params;
+  this.tuneNumber = tuneNumber;
+  this.inError = false;
+}
+
+
+TabCommon.prototype.setError = function (error) {
+  var tune = this.tune;
+  if (error) {
+    this.error = error;
+    this.inError = true;
+    if (tune.warnings) {
+      tune.warnings.push(error);
+    } else {
+      tune.warnings = [error];
+    }
+  }
+};
+
+
+module.exports = TabCommon;

package/src/tablatures/tab-renderer.js

@@ -0,0 +1,243 @@
+/* eslint-disable no-debugger */
+var VoiceElement = require('../write/abc_voice_element');
+var TabAbsoluteElements = require('./tab-absolute-elements');
+var spacing = require('../write/abc_spacing');
+
+function initSpecialY() {
+  return {
+    tempoHeightAbove: 0,
+    partHeightAbove: 0,
+    volumeHeightAbove: 0,
+    dynamicHeightAbove: 0,
+    endingHeightAbove: 0,
+    chordHeightAbove: 0,
+    lyricHeightAbove: 0,
+    lyricHeightBelow: 0,
+    chordHeightBelow: 0,
+    volumeHeightBelow: 0,
+    dynamicHeightBelow: 0
+  };
+}
+
+function getLyricHeight(voice) {
+  var maxLyricHeight = 0;
+  for (var ii = 0; ii < voice.children.length; ii++) {
+    var curAbs = voice.children[ii];
+    if (curAbs.specialY) {
+      if (curAbs.specialY.lyricHeightBelow > maxLyricHeight) {
+        maxLyricHeight = curAbs.specialY.lyricHeightBelow;
+      }
+    }
+  }
+  return maxLyricHeight; // add spacing
+}
+
+function buildTabName(self, dest) {
+  var stringSemantics = self.plugin.semantics.strings;
+  var controller = self.renderer.controller;
+  var textSize = controller.getTextSize;
+  var tabName = stringSemantics.tabInfos(self.plugin);
+  var size = textSize.calc(tabName, 'tablabelfont', 'text instrumentname');
+  dest.tabNameInfos = {
+    textSize: size,
+    name: tabName
+  };
+  return size.height;
+}
+
+/**
+ * Laying out tabs
+ * @param {*} renderer
+ * @param {*} line
+ * @param {*} staffIndex
+ * @param {*} tablatureLayout
+ */
+function TabRenderer(plugin, renderer, line, staffIndex) {
+  this.renderer = renderer;
+  this.plugin = plugin;
+  this.line = line;
+  this.absolutes = new TabAbsoluteElements();
+  this.staffIndex = staffIndex ;
+  this.tabStaff = {
+    clef: {
+      type: 'TAB'
+    }
+  };
+  this.tabSize = (plugin.linePitch * plugin.nbLines);
+}
+
+function islastTabInStaff(index, staffGroup) {
+  if (staffGroup[index].isTabStaff) {
+    if (index === staffGroup.length - 1) return true;
+    if (staffGroup[index + 1].isTabStaff) {
+      return false; 
+    } else {
+      return true;
+    }
+  }
+  return false;
+}
+
+function getStaffNumbers(staffs) {
+  var nbStaffs = 0; 
+  for (var ii = 0; ii < staffs.length; ii++) {
+    if (!staffs[ii].isTabStaff) {
+      nbStaffs++;
+    }
+  }
+  return nbStaffs;
+}
+
+function getParentStaffIndex(staffs, index) {
+  for (var ii = index; ii >= 0; ii--) {
+    if (!staffs[ii].isTabStaff) {
+      return ii;
+    }
+  }
+  return -1;
+}
+
+
+function linkStaffAndTabs(staffs) {
+  for (var ii = 0; ii < staffs.length; ii++) {
+    if (staffs[ii].isTabStaff) {
+      // link to parent staff
+      var parentIndex = getParentStaffIndex(staffs, ii);
+      staffs[ii].hasStaff = staffs[parentIndex];
+      if (!staffs[parentIndex].hasTab) staffs[parentIndex].hasTab = [];
+      staffs[parentIndex].hasTab.push(staffs[ii]);
+    }
+  }
+}
+
+function isMultiVoiceSingleStaff(staffs , parent) {
+  if ( getStaffNumbers(staffs) === 1) {
+    if (parent.voices.length > 1) return true;
+  }
+  return false;
+}
+
+
+function getNextTabPos(self,staffGroup) {
+  var tabIndex = self.staffIndex;
+  var startIndex = 0;
+  var handledVoices = 0;
+  var inProgress = true;
+  var nbVoices = 0;
+  while (inProgress) {
+    //for (var ii = 0; ii < staffGroup.length; ii++) {
+    if (!staffGroup[startIndex])
+      return -1;
+    if (!staffGroup[startIndex].isTabStaff) {
+      nbVoices = staffGroup[startIndex].voices.length; // get number of staff voices
+    }
+    if (staffGroup[startIndex].isTabStaff) {
+      handledVoices++;
+      if (islastTabInStaff(startIndex, staffGroup)) {
+        if (handledVoices < nbVoices) return startIndex + 1;
+      }
+    } else {
+      handledVoices = 0;
+      if (startIndex >= tabIndex) {
+        if (startIndex+1 == staffGroup.length) return startIndex +1;
+        if (!staffGroup[startIndex + 1].isTabStaff) return startIndex + 1;
+      }
+    }
+    startIndex++;
+    // out of space case
+    if (startIndex > staffGroup.length) return -1;
+  }
+}
+
+function getLastStaff(staffs, lastTab) {
+  for (var ii = lastTab; ii >= 0 ; ii-- ) {
+    if (!staffs[ii].isTabStaff) {
+      return staffs[ii];
+    }
+  }
+  return null; 
+}
+
+function checkVoiceKeySig(voices, ii) {
+  var curVoice = voices[ii];
+  // on multivoice multistaff only the first voice has key signature
+  // folling consecutive do not have one => we should provide the first voice key sig back then
+  var elem0 = curVoice.children[0].abcelem;
+  if (elem0.el_type === 'clef') return null;
+  if (ii == 0) {
+    // not found => clef=none case
+    return 'none';
+  }
+  return voices[ii-1].children[0];
+}
+
+TabRenderer.prototype.doLayout = function () {
+  var staffs = this.line.staff;
+  if (staffs) {
+    // give up on staffline=0 in key 
+    var firstStaff = staffs[0];
+    if (firstStaff) {
+      if (firstStaff.clef) {
+        if (firstStaff.clef.stafflines == 0) {
+          this.plugin._super.setError("No tablatures when stafflines=0");
+          return; 
+        }
+      }
+    }
+    staffs.splice(
+      staffs.length, 0,
+      this.tabStaff
+    );
+  }
+  var staffGroup = this.line.staffGroup;
+
+  var voices = staffGroup.voices;
+  var firstVoice = voices[0];
+  // take lyrics into account if any
+  var lyricsHeight = getLyricHeight(firstVoice);
+  var padd = 3;
+  var prevIndex = this.staffIndex;
+  var previousStaff = staffGroup.staffs[prevIndex];
+  var tabTop = previousStaff.top + padd + lyricsHeight;
+  if (previousStaff.isTabStaff) {
+    tabTop = previousStaff.top;
+  }
+  var staffGroupInfos = {
+    bottom: -1,
+    isTabStaff: true,
+    specialY: initSpecialY(),
+    lines: this.plugin.nbLines,
+    linePitch: this.plugin.linePitch,
+    dy: 0.15,
+    top: tabTop,
+  };
+  var nextTabPos = getNextTabPos(this,staffGroup.staffs);
+  if (nextTabPos === -1)
+    return;
+  staffGroupInfos.parentIndex = nextTabPos - 1;
+  staffGroup.staffs.splice(nextTabPos, 0, staffGroupInfos);
+  // staffGroup.staffs.push(staffGroupInfos);
+  staffGroup.height += this.tabSize + padd;
+  var parentStaff = getLastStaff(staffGroup.staffs, nextTabPos); 
+  var nbVoices = 1;
+  if (isMultiVoiceSingleStaff(staffGroup.staffs,parentStaff)) {
+    nbVoices = parentStaff.voices.length;
+  }  
+  // build from staff
+  this.tabStaff.voices = [];
+  for (var ii = 0; ii < nbVoices; ii++) {
+    var tabVoice = new VoiceElement(0, 0);
+    var nameHeight = buildTabName(this, tabVoice) / spacing.STEP;
+    staffGroup.staffs[this.staffIndex].top += nameHeight;
+    staffGroup.height += nameHeight * spacing.STEP;
+    tabVoice.staff = staffGroupInfos;
+    voices.splice(voices.length, 0, tabVoice);
+    var keySig = checkVoiceKeySig(voices, ii + this.staffIndex);
+    this.tabStaff.voices[ii] = [];
+    this.absolutes.build(this.plugin, voices, this.tabStaff.voices[ii], ii , this.staffIndex ,keySig);
+  }
+  linkStaffAndTabs(staffGroup.staffs); // crossreference tabs and staff
+};
+
+
+module.exports = TabRenderer;

package/src/tablatures/transposer.js

@@ -0,0 +1,110 @@
+/**
+ *
+ * generic transposer
+ *
+ */
+var TabNote = require('./instruments/tab-note');
+
+
+
+function buildAccEquiv(acc,note) {
+  var equiv = note.getAccidentalEquiv();
+  if (acc.note.toUpperCase() == equiv.name.toUpperCase()) {
+    equiv.isSharp = false;
+    equiv.isFlat = false;
+    return equiv;
+  }
+  return note;
+}
+
+function adjustNoteToKey(acc, note) {
+  if (acc.acc == 'sharp') {
+    if (note.isFlat) {
+      return buildAccEquiv(acc, note);
+    } else if (note.isSharp) {
+      if (acc.note.toUpperCase() == note.name.toUpperCase()) {
+        note.isSharp = false;
+        note.isKeySharp = true;
+      } else {
+        if (acc.note.toUpperCase() == note.name.toUpperCase()) {
+          note.natural = true;
+        }
+      }
+    }
+  } else if (acc.acc == 'flat') {
+    if (note.isSharp) {
+      return buildAccEquiv(acc, note);
+    } else if (note.isFlat) {
+      if (acc.note.toUpperCase() == note.name.toUpperCase()) {
+        note.isFlat = false;
+        note.isKeyFlat = true;
+      }
+    } else {
+      if (acc.note.toUpperCase() == note.name.toUpperCase()) {
+        note.natural = true;
+      }
+    }
+  }
+  return note;
+}
+
+
+function replaceNote(self, newNote, start, end) {
+  if (self.lastEnd) {
+    while (start > self.lastEnd) {
+      self.updatedSrc.push(self.abcSrc[self.lastEnd]);
+      self.lastEnd++;
+    }
+  }
+  var nNote = newNote.split('');
+  for (var ii = 0; ii < nNote.length; ii++) {
+    self.updatedSrc.push(nNote[ii]);
+  }
+  var curPos = start + ii;
+  while (end >= curPos) {
+    self.updatedSrc.push(nNote[curPos]);
+    curPos++;
+  }
+  self.lastEnd = end;
+}
+
+
+function checkKeys(self, note) {
+  var accs = self.transposedKey;
+  for (var ii = 0; ii < accs.length; ii++) {
+    note = adjustNoteToKey(accs[ii], note);
+  }
+  return note;
+}
+
+Transposer.prototype.transposeNote = function (note) {
+  var returned = note;
+  var curNote = new TabNote.TabNote(returned.name);
+  if (this.transposeBy > 0) {
+    for (var ii = 0; ii < this.transposeBy; ii++) {
+      curNote = checkKeys(this,curNote.nextNote());
+    }  
+    
+  } else if ( this.transposeBy < 0) {
+    for (var jj = this.transposeBy; jj < 0; jj++) {
+      curNote = checkKeys(this,curNote.prevNote());
+    }
+  }
+  returned.name = curNote.emit();
+  return returned;
+};
+
+Transposer.prototype.upgradeSource = function (note, startChar, endChar ) {
+  var n = new TabNote.TabNote(note.name);
+  var newNote = n.emit();
+  replaceNote(this, newNote, startChar, endChar-1);
+};
+
+function Transposer(transposedKey , transposeBy ) {
+  this.transposeBy = transposeBy;
+  this.transposedKey = transposedKey;
+  this.lastEnd = this.kEnd+1;
+}
+
+
+module.exports = Transposer;