vertical formatting, score transpose feature

Author: AaronDavidNewman

src/application/exports.ts

@@ -42,6 +42,7 @@ import { cardKeysHtmlEn, cardNotesLetterHtmlEn, cardNotesChromaticHtmlEn, cardNo
 // Dialogs
 import { SuiDialogBase } from '../ui/dialogs/dialog';
 import { SuiModifierDialogFactory } from '../ui/dialogs/factory';
+import { SuiTransposeScoreDialog, SuiTransposeScoreAdapter } from '../ui/dialogs/transposeScore';
 import { SuiMeasureDialog } from '../ui/dialogs/measureFormat';
 import { SuiInsertMeasures } from '../ui/dialogs/addMeasure';
 import { SuiInstrumentDialog } from '../ui/dialogs/instrument';
@@ -175,7 +176,8 @@ export const Smo = {
     // Dialogs
     SuiTempoDialog, SuiInstrumentDialog, SuiModifierDialogFactory, SuiLibraryDialog,
     SuiTextBracketDialog,
-    SuiScoreViewDialog, SuiGlobalLayoutDialog, SuiScoreIdentificationDialog,
+    SuiScoreViewDialog, SuiGlobalLayoutDialog, SuiScoreIdentificationDialog, SuiTransposeScoreAdapter,
+    SuiTransposeScoreDialog,
     SuiScoreFontDialog, SuiPageLayoutDialog, SuiMeasureDialog, SuiInsertMeasures,
     SuiTimeSignatureDialog,SuiTextBlockDialog, SuiLyricDialog, SuiChordChangeDialog,
     SuiSlurAttributesDialog, SuiTieAttributesDialog, SuiVoltaAttributeDialog,

src/render/sui/formatter.ts

@@ -643,17 +643,23 @@ export class SuiLayoutFormatter {
       }
     }
   }
-  // ### _highestLowestHead
-  // highest value is actually the one lowest on the page
+  /**
+   * highest value is actually the one lowest on the page
+   * @param measure 
+   * @param note 
+   * @returns 
+   */
   static _highestLowestHead(measure: SmoMeasure, note: SmoNote) {
-    const hilo = { hi: 0, lo: 9999999 };
-    note.pitches.forEach((pitch) => {
-      // 10 pixels per line
-      const ledger = SmoMusic.pitchToLedgerLine(measure.clef, pitch);
-      const noteHeight = ledger > 0 ? 10 : -10;
-      const px = (10 * ledger) + noteHeight;
-      hilo.lo = Math.min(hilo.lo, px);
-      hilo.hi = Math.max(hilo.hi, px);
+    // note...er warning: Notes always have at least 1 pitch, even a rest
+    // or glyph has a pitch to indicate the placement
+    const hilo = { hi: 0, lo: 99999999 };    
+    note.pitches.forEach((pitch) => {            
+      const line = 5 - SmoMusic.pitchToStaffLine(measure.clef, pitch);
+      // TODO: use actual note head/rest/glyph.  10 px is space between staff lines
+      const noteHeight = 10;
+      const px = (noteHeight * line);
+      hilo.lo = Math.min(hilo.lo, px - noteHeight / 2);
+      hilo.hi = Math.max(hilo.hi, px + noteHeight / 2);
     });
     return hilo;
   }
@@ -752,7 +758,9 @@ export class SuiLayoutFormatter {
     if (measure.svg.forceTempo) {
       yTop = Math.min(-1 * vexGlyph.tempo.yTop, yTop);
     }
-    measure.voices.forEach((voice) => {
+    let yBottomOffset = 0;
+    let yBottomVoiceZero = 0;
+    measure.voices.forEach((voice, voiceIx) => {
       voice.notes.forEach((note) => {
         const bg = SuiLayoutFormatter._beamGroupForNote(measure, note);
         flag = SmoNote.flagStates.auto;
@@ -766,11 +774,16 @@ export class SuiLayoutFormatter {
           }
         }  else {
           flag = note.flagState;
+          // odd-numbered voices flip default up/down
+          const voiceMod = voiceIx % 2;
           // an  auto-flag note is up if the 1st note is middle line
           if (flag === SmoNote.flagStates.auto) {
             const pitch = note.pitches[0];
             flag = SmoMusic.pitchToStaffLine(measure.clef, pitch)
-              >= 3 ? SmoNote.flagStates.up : SmoNote.flagStates.down;
+              >= 3 ? SmoNote.flagStates.down : SmoNote.flagStates.up;
+            if (voiceMod === 1) {
+              flag = (flag === SmoNote.flagStates.down) ? SmoNote.flagStates.up : SmoNote.flagStates.down;
+            }
           }
         }
         const hiloHead = SuiLayoutFormatter._highestLowestHead(measure, note);
@@ -784,7 +797,21 @@ export class SuiLayoutFormatter {
         // Lyrics will be rendered below the lowest thing on the staff, so add to
         // belowBaseline value based on the max number of verses and font size
         // it will extend
+        });
+        // Vex won't adjust for music in voices > 0 when placing lyrics.  
+        // So we need to adjust here, if voices > 0 have music below lyrics. 
+        if (voiceIx > 0 && yBottomVoiceZero < yBottom) {
+          yBottomOffset = yBottom - yBottomVoiceZero;
+        } else {
+          yBottomVoiceZero = yBottom;
+        }
+      });
+      let lyricsToAdjust: SmoLyric[] = [];
+      // get the lowest music part, then consider the lyrics
+      measure.voices.forEach((voice, voiceIx) => {
+        voice.notes.forEach((note) => {
         const lyrics = note.getTrueLyrics();
+        lyricsToAdjust = lyricsToAdjust.concat(lyrics);
         if (lyrics.length) {
           const maxLyric = lyrics.reduce((a, b) => a.verse > b.verse ? a : b);
           const fontInfo = SuiLayoutFormatter.textFont(maxLyric);
@@ -812,6 +839,11 @@ export class SuiLayoutFormatter {
       });
     });
     yBottom += lyricOffset;
+    if (lyricsToAdjust.length > 0) {
+      lyricsToAdjust.forEach((lyric: SmoLyric) => {
+        lyric.musicYOffset = yBottomOffset;
+      });
+    }
     return { belowBaseline: yBottom, aboveBaseline: yTop };
   }
 }

src/render/sui/scoreViewOperations.ts

@@ -614,7 +614,13 @@ export class SuiScoreViewOperations extends SuiScoreView {
     this._renderChangedMeasures(measureSelections);
     return this.renderer.updatePromise();
   }
-
+  transposeScore(offset: number): Promise<void> {
+    this._undoScore('transpose score');
+    SmoOperation.transposeScore(this.score, offset);
+    SmoOperation.transposeScore(this.storeScore, offset);
+    this.renderer.rerenderAll();
+    return this.renderer.updatePromise();
+  }
   /**
    * transpose selected notes
    * @param offset 1/2 steps

src/render/vex/glyphDimensions.ts

@@ -3,8 +3,6 @@
 import { SmoBarline } from '../../smo/data/measureModifiers';
 import { SmoMusic } from '../../smo/data/music';
 import { VexFlow, GlyphInfo, getGlyphWidth } from '../../common/vex';
-const VF = VexFlow;
-
 
 export class vexGlyph {
   static width(smoGlyph: GlyphInfo) {

src/render/vex/vxSystem.ts

@@ -118,14 +118,14 @@ export class VxSystem {
         verseLyrics.forEach((lyric: SmoLyric) => {
           if (lyric.logicalBox) {
             // 'lowest' Y on screen is Y with largest value...
-            lowestY = Math.max(lyric.logicalBox.y, lowestY);
+            lowestY = Math.max(lyric.logicalBox.y + lyric.musicYOffset, lowestY);
           }
         });
         // second offset all to that point
         verseLyrics.forEach((lyric: SmoLyric) => {
           if (lyric.logicalBox) {
             const offset = Math.max(0, lowestY - lyric.logicalBox.y);
-            lyric.adjY = offset + lyric.translateY;   
+            lyric.adjY = offset + lyric.translateY;
           }
         });
       } else {
@@ -141,7 +141,7 @@ export class VxSystem {
         verseLyrics.forEach((lyric: SmoLyric)=> {
           if (lyric.logicalBox) {
             const offset = Math.max(0, lowestY - lyric.logicalBox.y);
-            lyric.adjY = offset + lyric.translateY;   
+            lyric.adjY = offset + lyric.translateY;
           }
         });
       }

src/smo/data/music.ts

@@ -11,7 +11,6 @@ import { Pitch, PitchKey, Clef, PitchLetter, TickAccidental,
 import { SmoMicrotone } from './noteModifiers';
 import { VexFlow, pitchToLedgerLine, vexCanonicalNotes } from '../../common/vex';
 
-const VF = VexFlow;
 /**
  * Used for xml clef conversion
  */
@@ -97,6 +96,8 @@ export class SmoAudioPitch {
  * base note lengths + dots)
  */
 export interface SimpleDuration {
+  index: number,  
+  ticks: number,
   baseTicks: number,
   dots: number
 }
@@ -268,7 +269,14 @@ export class SmoMusic {
     }
     ];
   }
-  static getLineFromSmoPitch(clef: string, smoPitch: Pitch): number {
+  /**
+   * Return the number of lines above first ledger line below the staff.
+   * e.g. middle c in treble clef returns 0.  Top line f in treble returns 5.
+   * @param clef
+   * @param pitch
+   * @returns number where 0 is the first ledger line below
+   */
+  static pitchToStaffLine(clef: string, smoPitch: Pitch): number {
     const octave = smoPitch.octave * 7 - 4 * 7;
     const keyTable = smoPitch.letter + smoPitch.accidental;
     let line = (SmoMusic.noteValues[keyTable].root_index + octave) / 2;
@@ -390,7 +398,7 @@ export class SmoMusic {
    */
   static pitchToLedgerLine(clef: Clef, pitch: Pitch): number {
     // return the distance from the top ledger line, as 0.5 per line/space
-    const line = SmoMusic.getLineFromSmoPitch(clef, pitch);
+    const line = SmoMusic.pitchToStaffLine(clef, pitch);
     if (line > 5) {
       return -1 * (line - 5);
     }
@@ -399,16 +407,7 @@ export class SmoMusic {
     }
     return 0;
   }
-  /**
-   * Return the number of ledger lines based on the pitch and clef
-   * @param clef
-   * @param pitch
-   * @returns number where 0 is the top staff line
-   */
-   static pitchToStaffLine(clef: Clef, pitch: Pitch): number {
-    // return the distance from the top ledger line, as 0.5 per line/space
-    return SmoMusic.getLineFromSmoPitch(clef, pitch);
-  }
+
   /**
    * return flag state (up === 1 or down === 2) based on pitch and clef if auto
    * */
@@ -455,6 +454,17 @@ export class SmoMusic {
       'subbass':  7,
       'french': -1
     }
+    static scaleTones: string[] = ['tonic', '2', '3', '4', '5', '6', '7'];
+    static getScaleTonesForKey(keySignature: string): Record<string, string> {
+      const key = SmoMusic.enharmonicRoles[keySignature];
+      const rv: Record<string, string> = {};
+      key.forEach((role) => {
+        if (SmoMusic.scaleTones.indexOf(role.role) >= 0) {
+          rv[role.letter] = role.letter + role.accidental;
+        }
+      });
+      return rv;
+    }
   /**
    * The purpose of this table is to keep consistent enharmonic spelling when transposing 
    * instruments in different keys.  It is not theoritically complete, e.g.
@@ -1115,7 +1125,8 @@ export class SmoMusic {
     const flatKey = keySignature.indexOf('b') >= 0;
     const ar = SmoMusic.getEnharmonics(SmoMusic.pitchToVexKey(smoPitch));
     rv = SmoMusic.stripVexOctave(SmoMusic.pitchToVexKey(smoPitch));
-    const scaleMap: Record<string, string> = new VF.Music().createScaleMap(keySignature);
+    const scaleMap: Record<string, string> = SmoMusic.getScaleTonesForKey(keySignature);
+    // new VF.Music().createScaleMap(keySignature);
     ar.forEach((vexKey) => {
       if (vexKey.length === 1) {
         vexKey += 'n';
@@ -1159,8 +1170,7 @@ export class SmoMusic {
   static getKeyFriendlyEnharmonic(letter: string, keySignature: string): string {
     let rv: string = letter;
     let i = 0;
-    const muse = new VF.Music();
-    const scale: string[] = Object.values(muse.createScaleMap(keySignature));
+    const scale: string[] = Object.values(SmoMusic.getScaleTonesForKey(keySignature));
     let prop: string = SmoMusic.getEnharmonic(letter.toLowerCase());
     while (prop.toLowerCase() !== letter.toLowerCase()) {
       for (i = 0; i < scale.length; ++i) {
@@ -1185,8 +1195,8 @@ export class SmoMusic {
    * @returns
    */
   static getKeySignatureKey(letter: PitchLetter, keySignature: string): string {
-    const km = new VF.KeyManager(keySignature);
-    return (km as any).scaleMap[letter];
+    const scaleMap = SmoMusic.getScaleTonesForKey(keySignature);
+    return scaleMap[letter];
   }
 
   static getAccidentalForKeySignature(smoPitch: Pitch, keySignature: string): string {
@@ -1465,23 +1475,28 @@ export class SmoMusic {
     }
     if (SmoMusic._validDurations === null) {
       SmoMusic._validDurations = {};
+      let index = 0;
       for (var i = 0; i < SmoMusic.durationsDescending.length; ++i) {
         const baseTicks = SmoMusic.durationsDescending[i];
         for (var j = 3; j >= 1; --j) {
           const { dottedValue, minDot } = computeDots(baseTicks, j);
           if (dottedValue < SmoMusic.highestDuration && minDot > SmoMusic.lowestDuration) {
             SmoMusic._validDurations[dottedValue] = {
+              index: SmoMusic._validDurationKeys.length,
+              ticks: dottedValue,
               baseTicks,
               dots: j
             }
             SmoMusic._validDurationKeys.push(dottedValue);
           }
         }
-        SmoMusic._validDurationKeys.push(baseTicks);
         SmoMusic._validDurations[baseTicks] = {
+          index: SmoMusic._validDurationKeys.length,
+          ticks: baseTicks,
           baseTicks,
           dots: 0
         };
+        SmoMusic._validDurationKeys.push(baseTicks);
       }
     }
     return SmoMusic._validDurations;
@@ -1690,11 +1705,9 @@ export class SmoMusic {
   // Get ticks for this note with an added dot.  Return
   // identity if that is not a supported value.
   static getNextDottedLevel(ticks: number): number {
-    const ttd = SmoMusic.ticksToDuration;
-    const vals = Object.values(ttd);
-    const ix = vals.indexOf(ttd[ticks]);
-    if (ix >= 0 && ix < vals.length && vals[ix][0] === vals[ix + 1][0]) {
-      return SmoMusic.durationToTicks(vals[ix + 1]);
+    const ticksOrNull = SmoMusic.closestSmoDurationFromTicks(ticks);
+    if (ticksOrNull && ticksOrNull.index > 0) {
+      return SmoMusic.validDurations[SmoMusic._validDurationKeys[ticksOrNull.index - 1]].ticks;
     }
     return ticks;
   }
@@ -1703,36 +1716,12 @@ export class SmoMusic {
   // Get ticks for this note with one fewer dot.  Return
   // identity if that is not a supported value.
   static getPreviousDottedLevel(ticks: number): number {
-    const ttd = SmoMusic.ticksToDuration;
-    const vals = Object.values(ttd);
-    const ix = vals.indexOf(ttd[ticks]);
-    if (ix > 0 && vals[ix][0] === vals[ix - 1][0]) {
-      return SmoMusic.durationToTicks(vals[ix - 1]);
+    const ticksOrNull = SmoMusic.closestSmoDurationFromTicks(ticks);
+    if (ticksOrNull && ticksOrNull.index < SmoMusic._validDurationKeys.length + 1) {
+      return SmoMusic.validDurations[SmoMusic._validDurationKeys[ticksOrNull.index + 1]].ticks;
     }
     return ticks;
   }
- 
-
-  // ### durationToTicks
-  // Uses VF.durationToTicks, but handles dots.
-  static durationToTicks(duration: string): number {
-    let split = 0;
-    let i = 0;
-    let vfDuration = 0;
-    let dots = duration.indexOf('d');
-    if (dots < 0) {
-      return VF.durationToTicks(duration) as number;
-    } else {
-      vfDuration = VF.durationToTicks(duration.substring(0, dots)) as number;
-      dots = duration.length - dots; // number of dots
-      split = vfDuration / 2;
-      for (i = 0; i < dots; ++i) {
-        vfDuration += split;
-        split = split / 2;
-      }
-      return vfDuration;
-    }
-  }
 
   /**
    * break the duration up into an array of durations, to split a long

src/smo/data/noteModifiers.ts

@@ -802,8 +802,11 @@ export class SmoLyric extends SmoNoteModifierBase {
   translateX: number = 0;
   translateY: number = 0;
   classes: string = '';
+  // used by the renderer to calculate offsets for aligning lyrics
   adjX: number = 0;
   adjY: number = 0;
+  // used by the renderer to calculate the y offset for music that goes below the staff
+  musicYOffset: number = 0;
   hyphenX: number = 0;
   deleted: boolean = false;
 

src/smo/xform/operations.ts

@@ -414,6 +414,21 @@ export class SmoOperation {
     });
   }
 
+  static transposeScore(score: SmoScore, offset: number) {
+    score.staves.forEach((staff, staffIx) => {
+      staff.measures.forEach((measure, measureIx) => {
+        measure.voices.forEach((voice, voiceIx) => {
+          voice.notes.forEach((note, tickIx) => {
+            const selection = SmoSelection.noteSelection(
+              score,staffIx, measureIx, voiceIx, tickIx);
+            if (selection) {
+              this.transpose(selection, offset);
+            }
+          });
+        });
+      });
+    });
+  }
   // ## transpose
   // ## Description
   // Transpose the selected note, trying to find a key-signature friendly value