refactor(Formatting): formatting order and methods overhauled

preparation for lyrics spacing calculations

src/MusicalScore/Graphical/MusicSheetCalculator.ts

@@ -89,7 +89,7 @@ export abstract class MusicSheetCalculator {
         return this.graphicalMusicSheet.LeadSheet;
     }
 
-    private static setMeasuresMinStaffEntriesWidth(measures: GraphicalMeasure[], minimumStaffEntriesWidth: number): void {
+    protected static setMeasuresMinStaffEntriesWidth(measures: GraphicalMeasure[], minimumStaffEntriesWidth: number): void {
         for (let idx: number = 0, len: number = measures.length; idx < len; ++idx) {
             const measure: GraphicalMeasure = measures[idx];
             measure.minimumStaffEntriesWidth = minimumStaffEntriesWidth;
@@ -193,13 +193,16 @@ export abstract class MusicSheetCalculator {
         let minLength: number = 0;
         const maxInstructionsLength: number = this.rules.MaxInstructionsConstValue;
         if (this.graphicalMusicSheet.MeasureList.length > 0) {
+            /** list of vertical measures */
             let measures: GraphicalMeasure[] = this.graphicalMusicSheet.MeasureList[0];
             let minimumStaffEntriesWidth: number = this.calculateMeasureXLayout(measures);
+            minimumStaffEntriesWidth = this.calculateMeasureWidthFromLyrics(measures, minimumStaffEntriesWidth);
             MusicSheetCalculator.setMeasuresMinStaffEntriesWidth(measures, minimumStaffEntriesWidth);
             minLength = minimumStaffEntriesWidth * 1.2 + maxInstrNameLabelLength + maxInstructionsLength;
             for (let i: number = 1; i < this.graphicalMusicSheet.MeasureList.length; i++) {
                 measures = this.graphicalMusicSheet.MeasureList[i];
                 minimumStaffEntriesWidth = this.calculateMeasureXLayout(measures);
+                minimumStaffEntriesWidth = this.calculateMeasureWidthFromLyrics(measures, minimumStaffEntriesWidth);
                 MusicSheetCalculator.setMeasuresMinStaffEntriesWidth(measures, minimumStaffEntriesWidth);
                 minLength = Math.max(minLength, minimumStaffEntriesWidth * 1.2 + maxInstructionsLength);
             }
@@ -207,6 +210,10 @@ export abstract class MusicSheetCalculator {
         this.graphicalMusicSheet.MinAllowedSystemWidth = minLength;
     }
 
+    public calculateMeasureWidthFromLyrics(measuresVertical: GraphicalMeasure[], oldMinimumStaffEntriesWidth: number): number {
+        throw new Error("abstract, not implemented");
+    }
+
     protected formatMeasures(): void {
         throw new Error("abstract, not implemented");
     }
@@ -670,6 +677,8 @@ export abstract class MusicSheetCalculator {
         musicSystemBuilder.initialize(this.graphicalMusicSheet, visibleMeasureList, numberOfStaffLines);
         musicSystemBuilder.buildMusicSystems();
 
+        this.formatMeasures();
+
         // check for Measures with only WholeRestNotes and correct their X-Position (middle of Measure)
         this.checkMeasuresForWholeRestNotes();
         if (!this.leadSheet) {
@@ -725,8 +734,6 @@ export abstract class MusicSheetCalculator {
             this.calculateTempoExpressions();
         }
 
-        this.formatMeasures();
-
         // calculate all LyricWords Positions
         this.calculateLyricsPosition();
 

src/MusicalScore/Graphical/VexFlow/VexFlowMusicSheetCalculator.ts

@@ -48,16 +48,19 @@ export class VexFlowMusicSheetCalculator extends MusicSheetCalculator {
     }
   }
 
-    protected formatMeasures(): void {
-        for (const graphicalMeasures of this.graphicalMusicSheet.MeasureList) {
-            for (const graphicalMeasure of graphicalMeasures) {
-                (<VexFlowMeasure>graphicalMeasure).format();
-                for (const staffEntry of graphicalMeasure.staffEntries) {
-                    (<VexFlowStaffEntry>staffEntry).calculateXPosition();
-                }
-            }
+  protected formatMeasures(): void {
+      for (const verticalMeasureList of this.graphicalMusicSheet.MeasureList) {
+        const graphicalMeasure: VexFlowMeasure = verticalMeasureList[0] as VexFlowMeasure;
+        graphicalMeasure.formatVoices(graphicalMeasure.minimumStaffEntriesWidth);
+        for (const gM of verticalMeasureList) {
+          (<VexFlowMeasure>gM).format();
         }
-    }
+        for (const staffEntry of graphicalMeasure.staffEntries) {
+          (<VexFlowStaffEntry>staffEntry).calculateXPosition();
+        }
+        graphicalMeasure.PositionAndShape.calculateAbsolutePositionsOfChildren();
+      }
+  }
 
   //protected clearSystemsAndMeasures(): void {
   //    for (let measure of measures) {
@@ -109,8 +112,8 @@ export class VexFlowMusicSheetCalculator extends MusicSheetCalculator {
         // firstMeasure.formatVoices = (w: number) => {
         //     formatter.format(allVoices, w);
         // };
+        MusicSheetCalculator.setMeasuresMinStaffEntriesWidth(measures, width);
         for (const measure of measures) {
-            measure.minimumStaffEntriesWidth = width;
             if (measure !== measures[0]) {
         (measure as VexFlowMeasure).formatVoices = undefined;
             } else {
@@ -120,9 +123,21 @@ export class VexFlowMusicSheetCalculator extends MusicSheetCalculator {
             }
         }
     }
+
+    for (const graphicalMeasure of measures) {
+      for (const staffEntry of graphicalMeasure.staffEntries) {
+        (<VexFlowStaffEntry>staffEntry).calculateXPosition();
+      }
+      graphicalMeasure.PositionAndShape.calculateAbsolutePositionsOfChildren();
+    }
     return width;
   }
 
+  public calculateMeasureWidthFromLyrics(measuresVertical: GraphicalMeasure[], oldMinimumStaffEntriesWidth: number): number {
+    // throw new Error("abstract, not implemented");
+    return oldMinimumStaffEntriesWidth * 2;
+}
+
   protected createGraphicalTie(tie: Tie, startGse: GraphicalStaffEntry, endGse: GraphicalStaffEntry,
                                startNote: GraphicalNote, endNote: GraphicalNote): GraphicalTie {
     return new GraphicalTie(tie, startNote, endNote);

src/MusicalScore/Graphical/VexFlow/VexFlowMusicSheetDrawer.ts

@@ -180,7 +180,7 @@ export class VexFlowMusicSheetDrawer extends MusicSheetDrawer {
             this.drawLabel(staffEntry.graphicalChordContainer.GetGraphicalLabel, <number>GraphicalLayers.Notes);
         }
         if (staffEntry.LyricsEntries.length > 0) {
-            this.drawLyrics(staffEntry.LyricsEntries, <number>GraphicalLayers.Notes);
+            this.drawLyrics(staffEntry.LyricsEntries, <number>GraphicalLayers.Notes, staffEntry);
         }
     }
 
@@ -189,8 +189,10 @@ export class VexFlowMusicSheetDrawer extends MusicSheetDrawer {
      * @param lyricEntries Array of lyric entries to be drawn
      * @param layer Number of the layer that the lyrics should be drawn in
      */
-    private drawLyrics(lyricEntries: GraphicalLyricEntry[], layer: number): void {
+    private drawLyrics(lyricEntries: GraphicalLyricEntry[], layer: number, staffEntry: GraphicalStaffEntry): void {
+        //lyricEntries.forEach(lyricsEntry => this.drawLabel(lyricsEntry.GraphicalLabel, layer, lyricsEntry.GetLyricsEntry.Parent.Notes, staffEntry));
         lyricEntries.forEach(lyricsEntry => this.drawLabel(lyricsEntry.GraphicalLabel, layer));
+        // ((staffEntry.graphicalVoiceEntries[0] as VexFlowVoiceEntry).vfStaveNote as Vex.Flow.Note).setWidth(100);
     }
 
     protected drawInstrumentBrace(brace: GraphicalObject, system: MusicSystem): void {

src/MusicalScore/Graphical/VexFlow/VexFlowTextMeasurer.ts

@@ -13,6 +13,8 @@ export class VexFlowTextMeasurer implements ITextMeasurer {
     }
     // The context of a canvas used internally to compute font sizes
     private context: CanvasRenderingContext2D;
+    public fontSize: number = 20;
+    public fontSizeStandard: number = this.fontSize;
 
     /**
      *
@@ -21,8 +23,13 @@ export class VexFlowTextMeasurer implements ITextMeasurer {
      * @param style
      * @returns {number}
      */
-    public computeTextWidthToHeightRatio(text: string, font: Fonts, style: FontStyles): number {
-        this.context.font = VexFlowConverter.font(20, style, font);
-        return this.context.measureText(text).width / 20;
+    public computeTextWidthToHeightRatio(text: string, font: Fonts, style: FontStyles, fontSize: number = this.fontSize): number {
+        this.context.font = VexFlowConverter.font(fontSize, style, font);
+        return this.context.measureText(text).width / fontSize;
+    }
+
+    public setFontSize(fontSize: number = this.fontSizeStandard): number {
+        this.fontSize = fontSize;
+        return fontSize;
     }
 }

src/MusicalScore/Graphical/VexFlow/VexFlowVoiceEntry.ts

@@ -1,6 +1,7 @@
 import { VoiceEntry } from "../../VoiceData/VoiceEntry";
 import { GraphicalVoiceEntry } from "../GraphicalVoiceEntry";
 import { GraphicalStaffEntry } from "../GraphicalStaffEntry";
+import { LyricsEntry } from "../../VoiceData/Lyrics/LyricsEntry";
 
 export class VexFlowVoiceEntry extends GraphicalVoiceEntry {
     constructor(parentVoiceEntry: VoiceEntry, parentStaffEntry: GraphicalStaffEntry) {
@@ -8,4 +9,5 @@ export class VexFlowVoiceEntry extends GraphicalVoiceEntry {
     }
 
     public vfStaveNote: Vex.Flow.StemmableNote;
+    public lyricsEntry: LyricsEntry;
 }

src/MusicalScore/Interfaces/ITextMeasurer.ts

@@ -2,5 +2,8 @@ import {Fonts} from "../../Common/Enums/Fonts";
 import {FontStyles} from "../../Common/Enums/FontStyles";
 
 export interface ITextMeasurer {
+    fontSize: number;
+    fontSizeStandard: number;
     computeTextWidthToHeightRatio(text: string, font: Fonts, style: FontStyles): number;
+    setFontSize(fontSize: number): number;
 }