Renamed StaffMeasure to GraphicalMeasure (#264)

added package-lock.json to .gitignore

.gitignore

@@ -57,3 +57,4 @@ node_modules/
 # Private key for GH pages deploy
 bin/gh_pages_deploy_key
 bin/gh_pages_deploy_key.pub
+package-lock.json

src/MusicalScore/Graphical/StaffMeasure.ts → src/MusicalScore/Graphical/GraphicalMeasure.ts

@@ -17,7 +17,7 @@ import {PointF2D} from "../../Common/DataObjects/PointF2D";
 /**
  * Represents a measure in the music sheet (one measure in one staff line)
  */
-export abstract class StaffMeasure extends GraphicalObject {
+export abstract class GraphicalMeasure extends GraphicalObject {
     protected firstInstructionStaffEntry: GraphicalStaffEntry;
     protected lastInstructionStaffEntry: GraphicalStaffEntry;
 

src/MusicalScore/Graphical/GraphicalMusicSheet.ts

@@ -1,6 +1,6 @@
 import {MusicSheet} from "../MusicSheet";
 import {SourceMeasure} from "../VoiceData/SourceMeasure";
-import {StaffMeasure} from "./StaffMeasure";
+import {GraphicalMeasure} from "./GraphicalMeasure";
 import {GraphicalMusicPage} from "./GraphicalMusicPage";
 import {VerticalGraphicalStaffEntryContainer} from "./VerticalGraphicalStaffEntryContainer";
 import {GraphicalLabel} from "./GraphicalLabel";
@@ -32,17 +32,17 @@ export class GraphicalMusicSheet {
         this.musicSheet = musicSheet;
         this.numberOfStaves = this.musicSheet.Staves.length;
         this.calculator = calculator;
-        this.sourceToGraphicalMeasureLinks = new Dictionary<SourceMeasure, StaffMeasure[]>();
+        this.sourceToGraphicalMeasureLinks = new Dictionary<SourceMeasure, GraphicalMeasure[]>();
         this.calculator.initialize(this);
     }
 
-    public sourceToGraphicalMeasureLinks: Dictionary<SourceMeasure, StaffMeasure[]>;
+    public sourceToGraphicalMeasureLinks: Dictionary<SourceMeasure, GraphicalMeasure[]>;
 
     private musicSheet: MusicSheet;
     //private fontInfo: FontInfo = FontInfo.Info;
     private calculator: MusicSheetCalculator;
     private musicPages: GraphicalMusicPage[] = [];
-    private measureList: StaffMeasure[][] = [];
+    private measureList: GraphicalMeasure[][] = [];
     private verticalGraphicalStaffEntryContainers: VerticalGraphicalStaffEntryContainer[] = [];
     private title: GraphicalLabel;
     private subtitle: GraphicalLabel;
@@ -76,11 +76,11 @@ export class GraphicalMusicSheet {
     //    return this.fontInfo;
     //}
 
-    public get MeasureList(): StaffMeasure[][] {
+    public get MeasureList(): GraphicalMeasure[][] {
         return this.measureList;
     }
 
-    public set MeasureList(value: StaffMeasure[][]) {
+    public set MeasureList(value: GraphicalMeasure[][]) {
         this.measureList = value;
     }
 
@@ -214,7 +214,7 @@ export class GraphicalMusicSheet {
      */
     public findGraphicalStaffEntryFromMeasureList(staffIndex: number, measureIndex: number, sourceStaffEntry: SourceStaffEntry): GraphicalStaffEntry {
         for (let i: number = measureIndex; i < this.measureList.length; i++) {
-            const graphicalMeasure: StaffMeasure = this.measureList[i][staffIndex];
+            const graphicalMeasure: GraphicalMeasure = this.measureList[i][staffIndex];
             for (let idx: number = 0, len: number = graphicalMeasure.staffEntries.length; idx < len; ++idx) {
                 const graphicalStaffEntry: GraphicalStaffEntry = graphicalMeasure.staffEntries[idx];
                 if (graphicalStaffEntry.sourceStaffEntry === sourceStaffEntry) {
@@ -233,12 +233,12 @@ export class GraphicalMusicSheet {
      * @returns {any}
      */
     public findNextGraphicalStaffEntry(staffIndex: number, measureIndex: number, graphicalStaffEntry: GraphicalStaffEntry): GraphicalStaffEntry {
-        const graphicalMeasure: StaffMeasure = graphicalStaffEntry.parentMeasure;
+        const graphicalMeasure: GraphicalMeasure = graphicalStaffEntry.parentMeasure;
         const graphicalStaffEntryIndex: number = graphicalMeasure.staffEntries.indexOf(graphicalStaffEntry);
         if (graphicalStaffEntryIndex < graphicalMeasure.staffEntries.length - 1) {
             return graphicalMeasure.staffEntries[graphicalStaffEntryIndex + 1];
         } else if (measureIndex < this.measureList.length - 1) {
-            const nextMeasure: StaffMeasure = this.measureList[measureIndex + 1][staffIndex];
+            const nextMeasure: GraphicalMeasure = this.measureList[measureIndex + 1][staffIndex];
             if (nextMeasure.staffEntries.length > 0) {
                 return nextMeasure.staffEntries[0];
             }
@@ -246,8 +246,8 @@ export class GraphicalMusicSheet {
         return undefined;
     }
 
-    public getFirstVisibleMeasuresListFromIndeces(start: number, end: number): StaffMeasure[] {
-        const graphicalMeasures: StaffMeasure[] = [];
+    public getFirstVisibleMeasuresListFromIndeces(start: number, end: number): GraphicalMeasure[] {
+        const graphicalMeasures: GraphicalMeasure[] = [];
         const numberOfStaves: number = this.measureList[0].length;
         for (let i: number = start; i <= end; i++) {
             for (let j: number = 0; j < numberOfStaves; j++) {
@@ -260,9 +260,9 @@ export class GraphicalMusicSheet {
         return graphicalMeasures;
     }
 
-    public orderMeasuresByStaffLine(measures: StaffMeasure[]): StaffMeasure[][] {
-        const orderedMeasures: StaffMeasure[][] = [];
-        let mList: StaffMeasure[] = [];
+    public orderMeasuresByStaffLine(measures: GraphicalMeasure[]): GraphicalMeasure[][] {
+        const orderedMeasures: GraphicalMeasure[][] = [];
+        let mList: GraphicalMeasure[] = [];
         orderedMeasures.push(mList);
         for (let i: number = 0; i < measures.length; i++) {
             if (i === 0) {
@@ -426,11 +426,11 @@ export class GraphicalMusicSheet {
      * @param visibleMeasures
      * @returns {number[]}
      */
-    public getVisibleStavesIndecesFromSourceMeasure(visibleMeasures: StaffMeasure[]): number[] {
+    public getVisibleStavesIndecesFromSourceMeasure(visibleMeasures: GraphicalMeasure[]): number[] {
         const visibleInstruments: Instrument[] = [];
         const visibleStavesIndeces: number[] = [];
         for (let idx: number = 0, len: number = visibleMeasures.length; idx < len; ++idx) {
-            const graphicalMeasure: StaffMeasure = visibleMeasures[idx];
+            const graphicalMeasure: GraphicalMeasure = visibleMeasures[idx];
             const instrument: Instrument = graphicalMeasure.ParentStaff.ParentInstrument;
             if (visibleInstruments.indexOf(instrument) === -1) {
                 visibleInstruments.push(instrument);
@@ -452,7 +452,7 @@ export class GraphicalMusicSheet {
      * @param index
      * @returns {any}
      */
-    public getGraphicalMeasureFromSourceMeasureAndIndex(sourceMeasure: SourceMeasure, index: number): StaffMeasure {
+    public getGraphicalMeasureFromSourceMeasureAndIndex(sourceMeasure: SourceMeasure, index: number): GraphicalMeasure {
         for (let i: number = 0; i < this.measureList.length; i++) {
             if (this.measureList[i][0].parentSourceMeasure === sourceMeasure) {
                 return this.measureList[i][index];
@@ -461,12 +461,12 @@ export class GraphicalMusicSheet {
         return undefined;
     }
 
-    public getMeasureIndex(graphicalMeasure: StaffMeasure, measureIndex: number, inListIndex: number): boolean {
+    public getMeasureIndex(graphicalMeasure: GraphicalMeasure, measureIndex: number, inListIndex: number): boolean {
         measureIndex = 0;
         inListIndex = 0;
         for (; measureIndex < this.measureList.length; measureIndex++) {
             for (let idx: number = 0, len: number = this.measureList[measureIndex].length; idx < len; ++idx) {
-                const measure: StaffMeasure = this.measureList[measureIndex][idx];
+                const measure: GraphicalMeasure = this.measureList[measureIndex][idx];
                 if (measure === graphicalMeasure) {
                     return true;
                 }
@@ -868,12 +868,12 @@ export class GraphicalMusicSheet {
         return followedInstrumentCount;
     }
 
-    public GetGraphicalFromSourceMeasure(sourceMeasure: SourceMeasure): StaffMeasure[] {
+    public GetGraphicalFromSourceMeasure(sourceMeasure: SourceMeasure): GraphicalMeasure[] {
         return this.sourceToGraphicalMeasureLinks.getValue(sourceMeasure);
     }
 
     public GetGraphicalFromSourceStaffEntry(sourceStaffEntry: SourceStaffEntry): GraphicalStaffEntry {
-        const graphicalMeasure: StaffMeasure = this.GetGraphicalFromSourceMeasure(sourceStaffEntry.VerticalContainerParent.ParentMeasure)
+        const graphicalMeasure: GraphicalMeasure = this.GetGraphicalFromSourceMeasure(sourceStaffEntry.VerticalContainerParent.ParentMeasure)
             [sourceStaffEntry.ParentStaff.idInMusicSheet];
         return graphicalMeasure.findGraphicalStaffEntryFromTimestamp(sourceStaffEntry.Timestamp);
     }

src/MusicalScore/Graphical/GraphicalStaffEntry.ts

@@ -8,7 +8,7 @@ import {Voice} from "../VoiceData/Voice";
 import {VoiceEntry} from "../VoiceData/VoiceEntry";
 import {GraphicalTie} from "./GraphicalTie";
 import {GraphicalObject} from "./GraphicalObject";
-import {StaffMeasure} from "./StaffMeasure";
+import {GraphicalMeasure} from "./GraphicalMeasure";
 import {GraphicalNote} from "./GraphicalNote";
 import {GraphicalChordSymbolContainer} from "./GraphicalChordSymbolContainer";
 import {GraphicalLyricEntry} from "./GraphicalLyricEntry";
@@ -22,7 +22,7 @@ import { MusicSheetCalculator } from "./MusicSheetCalculator";
  * The graphical counterpart of a [[SourceStaffEntry]].
  */
 export abstract class GraphicalStaffEntry extends GraphicalObject {
-    constructor(parentMeasure: StaffMeasure, sourceStaffEntry: SourceStaffEntry = undefined, staffEntryParent: GraphicalStaffEntry = undefined) {
+    constructor(parentMeasure: GraphicalMeasure, sourceStaffEntry: SourceStaffEntry = undefined, staffEntryParent: GraphicalStaffEntry = undefined) {
         super();
         this.parentMeasure = parentMeasure;
         this.graphicalVoiceEntries = [];
@@ -47,7 +47,7 @@ export abstract class GraphicalStaffEntry extends GraphicalObject {
     // Extra member needed, as tie notes have no direct source entry with the right time stamp.
     public relInMeasureTimestamp: Fraction;
     public sourceStaffEntry: SourceStaffEntry;
-    public parentMeasure: StaffMeasure;
+    public parentMeasure: GraphicalMeasure;
     public graphicalVoiceEntries: GraphicalVoiceEntry[];
     public graceStaffEntriesBefore: GraphicalStaffEntry[];
     public graceStaffEntriesAfter: GraphicalStaffEntry[];

src/MusicalScore/Graphical/MusicSheetCalculator.ts

@@ -6,7 +6,7 @@ import {Tie} from "../VoiceData/Tie";
 import {Fraction} from "../../Common/DataObjects/Fraction";
 import {Note} from "../VoiceData/Note";
 import {MusicSheet} from "../MusicSheet";
-import {StaffMeasure} from "./StaffMeasure";
+import {GraphicalMeasure} from "./GraphicalMeasure";
 import {ClefInstruction} from "../VoiceData/Instructions/ClefInstruction";
 import {LyricWord} from "../VoiceData/Lyrics/LyricsWord";
 import {SourceMeasure} from "../VoiceData/SourceMeasure";
@@ -88,9 +88,9 @@ export abstract class MusicSheetCalculator {
         return this.graphicalMusicSheet.LeadSheet;
     }
 
-    private static setMeasuresMinStaffEntriesWidth(measures: StaffMeasure[], minimumStaffEntriesWidth: number): void {
+    private static setMeasuresMinStaffEntriesWidth(measures: GraphicalMeasure[], minimumStaffEntriesWidth: number): void {
         for (let idx: number = 0, len: number = measures.length; idx < len; ++idx) {
-            const measure: StaffMeasure = measures[idx];
+            const measure: GraphicalMeasure = measures[idx];
             measure.minimumStaffEntriesWidth = minimumStaffEntriesWidth;
         }
     }
@@ -119,7 +119,7 @@ export abstract class MusicSheetCalculator {
         this.staffLinesWithGraphicalExpressions = [];
 
         this.graphicalMusicSheet.Initialize();
-        const measureList: StaffMeasure[][] = this.graphicalMusicSheet.MeasureList;
+        const measureList: GraphicalMeasure[][] = this.graphicalMusicSheet.MeasureList;
 
         // one AccidentalCalculator for each Staff (regardless of Instrument)
         const accidentalCalculators: AccidentalCalculator[] = this.createAccidentalCalculators();
@@ -143,7 +143,7 @@ export abstract class MusicSheetCalculator {
         // go through all SourceMeasures (taking into account normal SourceMusicParts and Repetitions)
         for (let idx: number = 0, len: number = musicSheet.SourceMeasures.length; idx < len; ++idx) {
             const sourceMeasure: SourceMeasure = musicSheet.SourceMeasures[idx];
-            const graphicalMeasures: StaffMeasure[] = this.createGraphicalMeasuresForSourceMeasure(
+            const graphicalMeasures: GraphicalMeasure[] = this.createGraphicalMeasuresForSourceMeasure(
                 sourceMeasure,
                 accidentalCalculators,
                 lyricWords,
@@ -197,7 +197,7 @@ export abstract class MusicSheetCalculator {
         let minLength: number = 0;
         const maxInstructionsLength: number = this.rules.MaxInstructionsConstValue;
         if (this.graphicalMusicSheet.MeasureList.length > 0) {
-            let measures: StaffMeasure[] = this.graphicalMusicSheet.MeasureList[0];
+            let measures: GraphicalMeasure[] = this.graphicalMusicSheet.MeasureList[0];
             let minimumStaffEntriesWidth: number = this.calculateMeasureXLayout(measures);
             MusicSheetCalculator.setMeasuresMinStaffEntriesWidth(measures, minimumStaffEntriesWidth);
             minLength = minimumStaffEntriesWidth * 1.2 + maxInstrNameLabelLength + maxInstructionsLength;
@@ -219,7 +219,7 @@ export abstract class MusicSheetCalculator {
      * All staff entries are x-aligned throughout all the measures.
      * @param measures - The minimum required x width of the source measure
      */
-    protected calculateMeasureXLayout(measures: StaffMeasure[]): number {
+    protected calculateMeasureXLayout(measures: GraphicalMeasure[]): number {
         throw new Error("abstract, not implemented");
     }
 
@@ -335,7 +335,7 @@ export abstract class MusicSheetCalculator {
         /// <param name="measure"></param>
         /// <param name="staffLine"></param>
         /// <param name="musicSystem"></param>
-        private calculateSingleMeasureNumberPlacement(measure: StaffMeasure, staffLine: StaffLine, musicSystem: MusicSystem): void {
+        private calculateSingleMeasureNumberPlacement(measure: GraphicalMeasure, staffLine: StaffLine, musicSystem: MusicSystem): void {
             const labelNumber: string = measure.MeasureNumber.toString();
             const graphicalLabel: GraphicalLabel = new GraphicalLabel(new Label(labelNumber), this.rules.MeasureNumberLabelHeight,
                                                                       TextAlignment.LeftBottom);
@@ -415,7 +415,7 @@ export abstract class MusicSheetCalculator {
         // first find maximum Ycoordinate for the whole StaffLine
         let len: number = staffLine.Measures.length;
         for (let idx: number = 0; idx < len; ++idx) {
-            const measure: StaffMeasure = staffLine.Measures[idx];
+            const measure: GraphicalMeasure = staffLine.Measures[idx];
             const measureRelativePosition: PointF2D = measure.PositionAndShape.RelativePosition;
             const len2: number = measure.staffEntries.length;
             for (let idx2: number = 0; idx2 < len2; ++idx2) {
@@ -603,18 +603,18 @@ export abstract class MusicSheetCalculator {
             return;
         }
 
-        const allMeasures: StaffMeasure[][] = this.graphicalMusicSheet.MeasureList;
+        const allMeasures: GraphicalMeasure[][] = this.graphicalMusicSheet.MeasureList;
         if (allMeasures === undefined) {
             return;
         }
 
         // visible 2D-MeasureList
-        const visibleMeasureList: StaffMeasure[][] = [];
+        const visibleMeasureList: GraphicalMeasure[][] = [];
         for (let idx: number = 0, len: number = allMeasures.length; idx < len; ++idx) {
-            const staffMeasures: StaffMeasure[] = allMeasures[idx];
-            const visibleStaffMeasures: StaffMeasure[] = [];
+            const staffMeasures: GraphicalMeasure[] = allMeasures[idx];
+            const visibleStaffMeasures: GraphicalMeasure[] = [];
             for (let idx2: number = 0, len2: number = staffMeasures.length; idx2 < len2; ++idx2) {
-                const staffMeasure: StaffMeasure = allMeasures[idx][idx2];
+                const staffMeasure: GraphicalMeasure = allMeasures[idx][idx2];
                 if (staffMeasure.isVisible()) {
                     visibleStaffMeasures.push(staffMeasure);
                 }
@@ -626,7 +626,7 @@ export abstract class MusicSheetCalculator {
         let numberOfStaffLines: number = 0;
 
         for (let idx: number = 0, len: number = visibleMeasureList.length; idx < len; ++idx) {
-            const gmlist: StaffMeasure[] = visibleMeasureList[idx];
+            const gmlist: GraphicalMeasure[] = visibleMeasureList[idx];
             numberOfStaffLines = Math.max(gmlist.length, numberOfStaffLines);
             break;
         }
@@ -797,7 +797,7 @@ export abstract class MusicSheetCalculator {
      * @param measure
      */
     protected layoutMeasureWithWholeRest(rest: GraphicalNote, gse: GraphicalStaffEntry,
-                                         measure: StaffMeasure): void {
+                                         measure: GraphicalMeasure): void {
         return;
     }
 
@@ -847,7 +847,7 @@ export abstract class MusicSheetCalculator {
      * @param leftOpen
      * @param rightOpen
      */
-    protected layoutSingleRepetitionEnding(start: StaffMeasure, end: StaffMeasure, numberText: string,
+    protected layoutSingleRepetitionEnding(start: GraphicalMeasure, end: GraphicalMeasure, numberText: string,
                                            offset: number, leftOpen: boolean, rightOpen: boolean): void {
         return;
     }
@@ -857,7 +857,7 @@ export abstract class MusicSheetCalculator {
         return;
     }
 
-    protected staffMeasureCreatedCalculations(measure: StaffMeasure): void {
+    protected staffMeasureCreatedCalculations(measure: GraphicalMeasure): void {
         return;
     }
 
@@ -869,7 +869,7 @@ export abstract class MusicSheetCalculator {
                 for (let idx3: number = 0, len3: number = musicSystem.StaffLines.length; idx3 < len3; ++idx3) {
                     const staffLine: StaffLine = musicSystem.StaffLines[idx3];
                     for (let idx4: number = 0, len4: number = staffLine.Measures.length; idx4 < len4; ++idx4) {
-                        const graphicalMeasure: StaffMeasure = staffLine.Measures[idx4];
+                        const graphicalMeasure: GraphicalMeasure = staffLine.Measures[idx4];
                         if (graphicalMeasure.FirstInstructionStaffEntry !== undefined) {
                             const index: number = graphicalMeasure.PositionAndShape.ChildElements.indexOf(
                                 graphicalMeasure.FirstInstructionStaffEntry.PositionAndShape
@@ -1039,7 +1039,7 @@ export abstract class MusicSheetCalculator {
                 for (let idx3: number = 0, len3: number = musicSystem.StaffLines.length; idx3 < len3; ++idx3) {
                     const staffLine: StaffLine = musicSystem.StaffLines[idx3];
                     for (let idx4: number = 0, len4: number = staffLine.Measures.length; idx4 < len4; ++idx4) {
-                        const measure: StaffMeasure = staffLine.Measures[idx4];
+                        const measure: GraphicalMeasure = staffLine.Measures[idx4];
                         if (measure.staffEntries.length === 1) {
                             const gse: GraphicalStaffEntry = measure.staffEntries[0];
                             if (gse.graphicalVoiceEntries.length > 0 && gse.graphicalVoiceEntries[0].notes.length === 1) {
@@ -1055,7 +1055,7 @@ export abstract class MusicSheetCalculator {
         }
     }
 
-    protected optimizeRestNotePlacement(graphicalStaffEntry: GraphicalStaffEntry, measure: StaffMeasure): void {
+    protected optimizeRestNotePlacement(graphicalStaffEntry: GraphicalStaffEntry, measure: GraphicalMeasure): void {
         if (graphicalStaffEntry.graphicalVoiceEntries.length === 0) {
             return;
         }
@@ -1270,7 +1270,7 @@ export abstract class MusicSheetCalculator {
         const numberOfEntries: number = this.graphicalMusicSheet.MeasureList[0].length;
         for (let i: number = 0; i < this.graphicalMusicSheet.MeasureList.length; i++) {
             for (let j: number = 0; j < numberOfEntries; j++) {
-                const measure: StaffMeasure = this.graphicalMusicSheet.MeasureList[i][j];
+                const measure: GraphicalMeasure = this.graphicalMusicSheet.MeasureList[i][j];
                 for (let idx: number = 0, len: number = measure.staffEntries.length; idx < len; ++idx) {
                     const graphicalStaffEntry: GraphicalStaffEntry = measure.staffEntries[idx];
                     const verticalContainer: VerticalGraphicalStaffEntryContainer =
@@ -1292,14 +1292,14 @@ export abstract class MusicSheetCalculator {
 
     private createGraphicalMeasuresForSourceMeasure(sourceMeasure: SourceMeasure, accidentalCalculators: AccidentalCalculator[],
                                                     openLyricWords: LyricWord[],
-                                                    openOctaveShifts: OctaveShiftParams[], activeClefs: ClefInstruction[]): StaffMeasure[] {
+                                                    openOctaveShifts: OctaveShiftParams[], activeClefs: ClefInstruction[]): GraphicalMeasure[] {
         this.initStaffMeasuresCreation();
-        const verticalMeasureList: StaffMeasure[] = [];
+        const verticalMeasureList: GraphicalMeasure[] = [];
         const openBeams: Beam[] = [];
         const openTuplets: Tuplet[] = [];
         const staffEntryLinks: StaffEntryLink[] = [];
         for (let staffIndex: number = 0; staffIndex < sourceMeasure.CompleteNumberOfStaves; staffIndex++) {
-            const measure: StaffMeasure = this.createGraphicalMeasure(
+            const measure: GraphicalMeasure = this.createGraphicalMeasure(
                 sourceMeasure, openTuplets, openBeams,
                 accidentalCalculators[staffIndex], activeClefs, openOctaveShifts, openLyricWords, staffIndex, staffEntryLinks
             );
@@ -1313,9 +1313,9 @@ export abstract class MusicSheetCalculator {
     private createGraphicalMeasure(sourceMeasure: SourceMeasure, openTuplets: Tuplet[], openBeams: Beam[],
                                    accidentalCalculator: AccidentalCalculator, activeClefs: ClefInstruction[],
                                    openOctaveShifts: OctaveShiftParams[], openLyricWords: LyricWord[], staffIndex: number,
-                                   staffEntryLinks: StaffEntryLink[]): StaffMeasure {
+                                   staffEntryLinks: StaffEntryLink[]): GraphicalMeasure {
         const staff: Staff = this.graphicalMusicSheet.ParentMusicSheet.getStaffFromIndex(staffIndex);
-        const measure: StaffMeasure = MusicSheetCalculator.symbolFactory.createStaffMeasure(sourceMeasure, staff);
+        const measure: GraphicalMeasure = MusicSheetCalculator.symbolFactory.createStaffMeasure(sourceMeasure, staff);
         measure.hasError = sourceMeasure.getErrorInMeasure(staffIndex);
         if (sourceMeasure.FirstInstructionsStaffEntries[staffIndex] !== undefined) {
             for (let idx: number = 0, len: number = sourceMeasure.FirstInstructionsStaffEntries[staffIndex].Instructions.length; idx < len; ++idx) {
@@ -1478,9 +1478,9 @@ export abstract class MusicSheetCalculator {
 
     private handleStaffEntries(): void {
         for (let idx: number = 0, len: number = this.graphicalMusicSheet.MeasureList.length; idx < len; ++idx) {
-            const measures: StaffMeasure[] = this.graphicalMusicSheet.MeasureList[idx];
+            const measures: GraphicalMeasure[] = this.graphicalMusicSheet.MeasureList[idx];
             for (let idx2: number = 0, len2: number = measures.length; idx2 < len2; ++idx2) {
-                const measure: StaffMeasure = measures[idx2];
+                const measure: GraphicalMeasure = measures[idx2];
                 for (const graphicalStaffEntry of measure.staffEntries) {
                     if (graphicalStaffEntry.parentMeasure !== undefined
                         && graphicalStaffEntry.graphicalVoiceEntries.length > 0
@@ -1514,7 +1514,7 @@ export abstract class MusicSheetCalculator {
                 for (let idx3: number = 0, len3: number = musicSystem.StaffLines.length; idx3 < len3; ++idx3) {
                     const staffLine: StaffLine = musicSystem.StaffLines[idx3];
                     for (let idx4: number = 0, len4: number = staffLine.Measures.length; idx4 < len4; ++idx4) {
-                        const measure: StaffMeasure = staffLine.Measures[idx4];
+                        const measure: GraphicalMeasure = staffLine.Measures[idx4];
                         for (let idx5: number = 0, len5: number = measure.staffEntries.length; idx5 < len5; ++idx5) {
                             const staffEntry: GraphicalStaffEntry = measure.staffEntries[idx5];
                             this.layoutBeams(staffEntry);
@@ -1533,7 +1533,7 @@ export abstract class MusicSheetCalculator {
                 for (let idx3: number = 0, len3: number = system.StaffLines.length; idx3 < len3; ++idx3) {
                     const line: StaffLine = system.StaffLines[idx3];
                     for (let idx4: number = 0, len4: number = line.Measures.length; idx4 < len4; ++idx4) {
-                        const measure: StaffMeasure = line.Measures[idx4];
+                        const measure: GraphicalMeasure = line.Measures[idx4];
                         for (let idx5: number = 0, len5: number = measure.staffEntries.length; idx5 < len5; ++idx5) {
                             const graphicalStaffEntry: GraphicalStaffEntry = measure.staffEntries[idx5];
                             for (let idx6: number = 0, len6: number = graphicalStaffEntry.sourceStaffEntry.VoiceEntries.length; idx6 < len6; ++idx6) {
@@ -1557,7 +1557,7 @@ export abstract class MusicSheetCalculator {
                 for (let idx3: number = 0, len3: number = system.StaffLines.length; idx3 < len3; ++idx3) {
                     const line: StaffLine = system.StaffLines[idx3];
                     for (let idx4: number = 0, len4: number = line.Measures.length; idx4 < len4; ++idx4) {
-                        const measure: StaffMeasure = line.Measures[idx4];
+                        const measure: GraphicalMeasure = line.Measures[idx4];
                         for (let idx5: number = 0, len5: number = measure.staffEntries.length; idx5 < len5; ++idx5) {
                             const graphicalStaffEntry: GraphicalStaffEntry = measure.staffEntries[idx5];
                             for (let idx6: number = 0, len6: number = graphicalStaffEntry.sourceStaffEntry.VoiceEntries.length; idx6 < len6; ++idx6) {
@@ -1587,7 +1587,7 @@ export abstract class MusicSheetCalculator {
                 for (let idx3: number = 0, len3: number = system.StaffLines.length; idx3 < len3; ++idx3) {
                     const line: StaffLine = system.StaffLines[idx3];
                     for (let idx4: number = 0, len4: number = line.Measures.length; idx4 < len4; ++idx4) {
-                        const measure: StaffMeasure = line.Measures[idx4];
+                        const measure: GraphicalMeasure = line.Measures[idx4];
                         for (let idx5: number = 0, len5: number = measure.staffEntries.length; idx5 < len5; ++idx5) {
                             const graphicalStaffEntry: GraphicalStaffEntry = measure.staffEntries[idx5];
                             this.optimizeRestNotePlacement(graphicalStaffEntry, measure);
@@ -1662,7 +1662,7 @@ export abstract class MusicSheetCalculator {
                 for (let idx3: number = 0, len3: number = musicSystem.StaffLines.length; idx3 < len3; ++idx3) {
                     const staffLine: StaffLine = musicSystem.StaffLines[idx3];
                     for (let idx4: number = 0, len5: number = staffLine.Measures.length; idx4 < len5; ++idx4) {
-                        const measure: StaffMeasure = staffLine.Measures[idx4];
+                        const measure: GraphicalMeasure = staffLine.Measures[idx4];
                         for (let idx6: number = 0, len6: number = measure.staffEntries.length; idx6 < len6; ++idx6) {
                             const staffEntry: GraphicalStaffEntry = measure.staffEntries[idx6];
                             const graphicalTies: GraphicalTie[] = staffEntry.GraphicalTies;
@@ -1769,7 +1769,7 @@ export abstract class MusicSheetCalculator {
             const startX: number = startStaffEntry.parentMeasure.PositionAndShape.RelativePosition.x +
                 startStaffEntry.PositionAndShape.RelativePosition.x +
                 lyricEntry.GraphicalLabel.PositionAndShape.BorderMarginRight;
-            const lastStaffMeasure: StaffMeasure = startStaffLine.Measures[startStaffLine.Measures.length - 1];
+            const lastStaffMeasure: GraphicalMeasure = startStaffLine.Measures[startStaffLine.Measures.length - 1];
             const endX: number = lastStaffMeasure.PositionAndShape.RelativePosition.x + lastStaffMeasure.PositionAndShape.Size.width;
             let y: number = lyricEntry.GraphicalLabel.PositionAndShape.RelativePosition.y;
 

src/MusicalScore/Graphical/MusicSheetDrawer.ts

@@ -15,7 +15,7 @@ import {ArgumentOutOfRangeException} from "../Exceptions";
 import {SelectionStartSymbol} from "./SelectionStartSymbol";
 import {SelectionEndSymbol} from "./SelectionEndSymbol";
 import {MusicSystem} from "./MusicSystem";
-import {StaffMeasure} from "./StaffMeasure";
+import {GraphicalMeasure} from "./GraphicalMeasure";
 import {StaffLine} from "./StaffLine";
 import {SystemLine} from "./SystemLine";
 import {MusicSymbol} from "./MusicSymbol";
@@ -227,7 +227,7 @@ export abstract class MusicSheetDrawer {
         // empty
     }
 
-    protected drawMeasure(measure: StaffMeasure): void {
+    protected drawMeasure(measure: GraphicalMeasure): void {
         throw new Error("not implemented");
     }
 

src/MusicalScore/Graphical/MusicSystem.ts

@@ -7,7 +7,7 @@ import {InstrumentalGroup} from "../InstrumentalGroup";
 import {TextAlignment} from "../../Common/Enums/TextAlignment";
 import {GraphicalMusicPage} from "./GraphicalMusicPage";
 import {GraphicalLabel} from "./GraphicalLabel";
-import {StaffMeasure} from "./StaffMeasure";
+import {GraphicalMeasure} from "./GraphicalMeasure";
 import {GraphicalObject} from "./GraphicalObject";
 import {EngravingRules} from "./EngravingRules";
 import {PointF2D} from "../../Common/DataObjects/PointF2D";
@@ -28,7 +28,7 @@ export abstract class MusicSystem extends GraphicalObject {
     protected parent: GraphicalMusicPage;
     protected id: number;
     protected staffLines: StaffLine[] = [];
-    protected graphicalMeasures: StaffMeasure[][] = [];
+    protected graphicalMeasures: GraphicalMeasure[][] = [];
     protected labels: Dictionary<GraphicalLabel, Instrument> = new Dictionary<GraphicalLabel, Instrument>();
     protected measureNumberLabels: GraphicalLabel[] = [];
     protected maxLabelLength: number;
@@ -66,7 +66,7 @@ export abstract class MusicSystem extends GraphicalObject {
         return this.staffLines;
     }
 
-    public get GraphicalMeasures(): StaffMeasure[][] {
+    public get GraphicalMeasures(): GraphicalMeasure[][] {
         return this.graphicalMeasures;
     }
 
@@ -116,8 +116,8 @@ export abstract class MusicSystem extends GraphicalObject {
         if (this === this.parent.MusicSystems[0] && this.parent === this.parent.Parent.MusicPages[0]) {
             xPosition = this.maxLabelLength + systemLabelsRightMargin - lineWidth / 2;
         }
-        const top: StaffMeasure = this.staffLines[0].Measures[0];
-        let bottom: StaffMeasure = undefined;
+        const top: GraphicalMeasure = this.staffLines[0].Measures[0];
+        let bottom: GraphicalMeasure = undefined;
         if (this.staffLines.length > 1) {
             bottom = this.staffLines[this.staffLines.length - 1].Measures[0];
         }
@@ -142,13 +142,13 @@ export abstract class MusicSystem extends GraphicalObject {
      * @param measure
      */
     public createVerticalLineForMeasure(xPosition: number, lineWidth: number, lineType: SystemLinesEnum, linePosition: SystemLinePosition,
-                                        measureIndex: number, measure: StaffMeasure): void {
+                                        measureIndex: number, measure: GraphicalMeasure): void {
         const staffLine: StaffLine = measure.ParentStaffLine;
         const staffLineRelative: PointF2D = new PointF2D(staffLine.PositionAndShape.RelativePosition.x,
                                                          staffLine.PositionAndShape.RelativePosition.y);
         const staves: Staff[] = staffLine.ParentStaff.ParentInstrument.Staves;
         if (staffLine.ParentStaff === staves[0]) {
-            let bottomMeasure: StaffMeasure = undefined;
+            let bottomMeasure: GraphicalMeasure = undefined;
             if (staves.length > 1) {
                 bottomMeasure = this.getBottomStaffLine(staffLine).Measures[measureIndex];
             }
@@ -186,9 +186,9 @@ export abstract class MusicSystem extends GraphicalObject {
         return this.StaffLines[0].PositionAndShape.AbsolutePosition.x + this.StaffLines[0].StaffLines[0].End.x;
     }
 
-    public AddStaffMeasures(graphicalMeasures: StaffMeasure[]): void {
+    public AddStaffMeasures(graphicalMeasures: GraphicalMeasure[]): void {
         for (let idx: number = 0, len: number = graphicalMeasures.length; idx < len; ++idx) {
-            const graphicalMeasure: StaffMeasure = graphicalMeasures[idx];
+            const graphicalMeasure: GraphicalMeasure = graphicalMeasures[idx];
             graphicalMeasure.parentMusicSystem = this;
         }
         this.graphicalMeasures.push(graphicalMeasures);
@@ -339,7 +339,7 @@ export abstract class MusicSystem extends GraphicalObject {
         let second: boolean = false;
         for (let i: number = 0; i < this.staffLines.length - 1; i++) {
             for (let idx: number = 0, len: number = this.staffLines[i].Measures.length; idx < len; ++idx) {
-                const measure: StaffMeasure = this.staffLines[i].Measures[idx];
+                const measure: GraphicalMeasure = this.staffLines[i].Measures[idx];
                 for (let idx2: number = 0, len2: number = measure.staffEntries.length; idx2 < len2; ++idx2) {
                     const staffEntry: GraphicalStaffEntry = measure.staffEntries[idx2];
                     if (staffEntry.sourceStaffEntry.Link !== undefined) {
@@ -348,7 +348,7 @@ export abstract class MusicSystem extends GraphicalObject {
                 }
             }
             for (let idx: number = 0, len: number = this.staffLines[i + 1].Measures.length; idx < len; ++idx) {
-                const measure: StaffMeasure = this.staffLines[i + 1].Measures[idx];
+                const measure: GraphicalMeasure = this.staffLines[i + 1].Measures[idx];
                 for (let idx2: number = 0, len2: number = measure.staffEntries.length; idx2 < len2; ++idx2) {
                     const staffEntry: GraphicalStaffEntry = measure.staffEntries[idx2];
                     if (staffEntry.sourceStaffEntry.Link !== undefined) {
@@ -386,7 +386,7 @@ export abstract class MusicSystem extends GraphicalObject {
      * @param bottomMeasure
      */
     protected createSystemLine(xPosition: number, lineWidth: number, lineType: SystemLinesEnum, linePosition: SystemLinePosition,
-                               musicSystem: MusicSystem, topMeasure: StaffMeasure, bottomMeasure: StaffMeasure = undefined): SystemLine {
+                               musicSystem: MusicSystem, topMeasure: GraphicalMeasure, bottomMeasure: GraphicalMeasure = undefined): SystemLine {
         throw new Error("not implemented");
     }
 

src/MusicalScore/Graphical/MusicSystemBuilder.ts

@@ -1,4 +1,4 @@
-import {StaffMeasure} from "./StaffMeasure";
+import {GraphicalMeasure} from "./GraphicalMeasure";
 import {GraphicalMusicPage} from "./GraphicalMusicPage";
 import {EngravingRules} from "./EngravingRules";
 import {RhythmInstruction} from "../VoiceData/Instructions/RhythmInstruction";
@@ -22,7 +22,7 @@ import {CollectionUtil} from "../../Util/CollectionUtil";
 import {SystemLinePosition} from "./SystemLinePosition";
 
 export class MusicSystemBuilder {
-    private measureList: StaffMeasure[][];
+    private measureList: GraphicalMeasure[][];
     private graphicalMusicSheet: GraphicalMusicSheet;
     private currentMusicPage: GraphicalMusicPage;
     private currentPageHeight: number;
@@ -42,7 +42,7 @@ export class MusicSystemBuilder {
     private leadSheet: boolean = false;
 
     public initialize(
-        graphicalMusicSheet: GraphicalMusicSheet, measureList: StaffMeasure[][], numberOfStaffLines: number): void {
+        graphicalMusicSheet: GraphicalMusicSheet, measureList: GraphicalMeasure[][], numberOfStaffLines: number): void {
         this.leadSheet = graphicalMusicSheet.LeadSheet;
         this.graphicalMusicSheet = graphicalMusicSheet;
         this.rules = this.graphicalMusicSheet.ParentMusicSheet.rules;
@@ -81,7 +81,7 @@ export class MusicSystemBuilder {
 
         // go through measures and add to system until system gets too long -> finish system and start next system.
         while (this.measureListIndex < numberOfMeasures) {
-            const staffMeasures: StaffMeasure[] = this.measureList[this.measureListIndex];
+            const staffMeasures: GraphicalMeasure[] = this.measureList[this.measureListIndex];
             for (let idx: number = 0, len: number = staffMeasures.length; idx < len; ++idx) {
                 staffMeasures[idx].resetLayout();
             }
@@ -115,7 +115,7 @@ export class MusicSystemBuilder {
 
             // Check if there are key or rhythm change instructions within the next measure:
             if (this.measureListIndex + 1 < this.measureList.length) {
-                const nextStaffMeasures: StaffMeasure[] = this.measureList[this.measureListIndex + 1];
+                const nextStaffMeasures: GraphicalMeasure[] = this.measureList[this.measureListIndex + 1];
                 const nextSourceMeasure: SourceMeasure = nextStaffMeasures[0].parentSourceMeasure;
                 if (nextSourceMeasure.hasBeginInstructions()) {
                     nextMeasureBeginInstructionWidth += this.addBeginInstructions(nextStaffMeasures, false, false);
@@ -147,9 +147,9 @@ export class MusicSystemBuilder {
      * @param beginInstrWidth
      * @param endInstrWidth
      */
-    private setMeasureWidth(staffMeasures: StaffMeasure[], width: number, beginInstrWidth: number, endInstrWidth: number): void {
+    private setMeasureWidth(staffMeasures: GraphicalMeasure[], width: number, beginInstrWidth: number, endInstrWidth: number): void {
         for (let idx: number = 0, len: number = staffMeasures.length; idx < len; ++idx) {
-            const measure: StaffMeasure = staffMeasures[idx];
+            const measure: GraphicalMeasure = staffMeasures[idx];
             measure.setWidth(width);
             if (beginInstrWidth > 0) {
                 measure.beginInstructionsWidth = beginInstrWidth;
@@ -166,7 +166,7 @@ export class MusicSystemBuilder {
      * @param measures
      * @param isPartEndingSystem
      */
-    private finalizeCurrentAndCreateNewSystem(measures: StaffMeasure[], isPartEndingSystem: boolean = false): void {
+    private finalizeCurrentAndCreateNewSystem(measures: GraphicalMeasure[], isPartEndingSystem: boolean = false): void {
         this.adaptRepetitionLineWithIfNeeded();
         if (!isPartEndingSystem) {
             this.checkAndCreateExtraInstructionMeasure(measures);
@@ -201,7 +201,7 @@ export class MusicSystemBuilder {
     private adaptRepetitionLineWithIfNeeded(): void {
         const systemMeasures: MeasureBuildParameters[] = this.currentSystemParams.systemMeasures;
         if (systemMeasures.length >= 1) {
-            const measures: StaffMeasure[] =
+            const measures: GraphicalMeasure[] =
                 this.currentSystemParams.currentSystem.GraphicalMeasures[this.currentSystemParams.currentSystem.GraphicalMeasures.length - 1];
             const measureParams: MeasureBuildParameters = systemMeasures[systemMeasures.length - 1];
             let diff: number = 0.0;
@@ -211,14 +211,14 @@ export class MusicSystemBuilder {
             }
             this.currentSystemParams.currentSystemFixWidth -= diff;
             for (let idx: number = 0, len: number = measures.length; idx < len; ++idx) {
-                const measure: StaffMeasure = measures[idx];
+                const measure: GraphicalMeasure = measures[idx];
                 measure.endInstructionsWidth -= diff;
             }
         }
     }
 
     private addMeasureToSystem(
-        staffMeasures: StaffMeasure[], measureStartLine: SystemLinesEnum, measureEndLine: SystemLinesEnum,
+        staffMeasures: GraphicalMeasure[], measureStartLine: SystemLinesEnum, measureEndLine: SystemLinesEnum,
         totalMeasureWidth: number, currentMeasureBeginInstructionsWidth: number, currentVarWidth: number, currentMeasureEndInstructionsWidth: number
     ): void {
         this.currentSystemParams.systemMeasures.push({beginLine: measureStartLine, endLine: measureEndLine});
@@ -363,13 +363,14 @@ export class MusicSystemBuilder {
      * Initialize the active Instructions from the first [[SourceMeasure]] of first [[SourceMusicPart]].
      * @param measureList
      */
-    private initializeActiveInstructions(measureList: StaffMeasure[]): void {
+    private initializeActiveInstructions(measureList: GraphicalMeasure[]): void {
         const firstSourceMeasure: SourceMeasure = this.graphicalMusicSheet.ParentMusicSheet.getFirstSourceMeasure();
         if (firstSourceMeasure !== undefined) {
             this.visibleStaffIndices = this.graphicalMusicSheet.getVisibleStavesIndecesFromSourceMeasure(measureList);
             for (let i: number = 0, len: number = this.visibleStaffIndices.length; i < len; i++) {
                 const staffIndex: number = this.visibleStaffIndices[i];
-                const graphicalMeasure: StaffMeasure = this.graphicalMusicSheet.getGraphicalMeasureFromSourceMeasureAndIndex(firstSourceMeasure, staffIndex);
+                const graphicalMeasure: GraphicalMeasure = this.graphicalMusicSheet
+                    .getGraphicalMeasureFromSourceMeasureAndIndex(firstSourceMeasure, staffIndex);
                 this.activeClefs[i] = <ClefInstruction>firstSourceMeasure.FirstInstructionsStaffEntries[staffIndex].Instructions[0];
                 let keyInstruction: KeyInstruction = KeyInstruction.copy(
                     <KeyInstruction>firstSourceMeasure.FirstInstructionsStaffEntries[staffIndex].Instructions[1]);
@@ -380,7 +381,7 @@ export class MusicSystemBuilder {
         }
     }
 
-    private transposeKeyInstruction(keyInstruction: KeyInstruction, graphicalMeasure: StaffMeasure): KeyInstruction {
+    private transposeKeyInstruction(keyInstruction: KeyInstruction, graphicalMeasure: GraphicalMeasure): KeyInstruction {
         if (this.graphicalMusicSheet.ParentMusicSheet.Transpose !== 0
             && graphicalMeasure.ParentStaff.ParentInstrument.MidiInstrumentId !== MidiInstrument.Percussion
             && MusicSheetCalculator.transposeCalculator !== undefined
@@ -400,7 +401,7 @@ export class MusicSystemBuilder {
      * @param isFirstSourceMeasure
      * @returns {number}
      */
-    private addBeginInstructions(measures: StaffMeasure[], isSystemFirstMeasure: boolean, isFirstSourceMeasure: boolean): number {
+    private addBeginInstructions(measures: GraphicalMeasure[], isSystemFirstMeasure: boolean, isFirstSourceMeasure: boolean): number {
         const measureCount: number = measures.length;
         if (measureCount === 0) {
             return 0;
@@ -408,7 +409,7 @@ export class MusicSystemBuilder {
         let totalBeginInstructionLengthX: number = 0.0;
         const sourceMeasure: SourceMeasure = measures[0].parentSourceMeasure;
         for (let idx: number = 0; idx < measureCount; ++idx) {
-            const measure: StaffMeasure = measures[idx];
+            const measure: GraphicalMeasure = measures[idx];
             const staffIndex: number = this.visibleStaffIndices[idx];
             const beginInstructionsStaffEntry: SourceStaffEntry = sourceMeasure.FirstInstructionsStaffEntries[staffIndex];
             const beginInstructionLengthX: number = this.AddInstructionsAtMeasureBegin(
@@ -426,7 +427,7 @@ export class MusicSystemBuilder {
      * @param measures
      * @returns {number}
      */
-    private addEndInstructions(measures: StaffMeasure[]): number {
+    private addEndInstructions(measures: GraphicalMeasure[]): number {
         const measureCount: number = measures.length;
         if (measureCount === 0) {
             return 0;
@@ -434,7 +435,7 @@ export class MusicSystemBuilder {
         let totalEndInstructionLengthX: number = 0.5;
         const sourceMeasure: SourceMeasure = measures[0].parentSourceMeasure;
         for (let idx: number = 0; idx < measureCount; idx++) {
-            const measure: StaffMeasure = measures[idx];
+            const measure: GraphicalMeasure = measures[idx];
             const staffIndex: number = this.visibleStaffIndices[idx];
             const endInstructionsStaffEntry: SourceStaffEntry = sourceMeasure.LastInstructionsStaffEntries[staffIndex];
             const endInstructionLengthX: number = this.addInstructionsAtMeasureEnd(endInstructionsStaffEntry, measure);
@@ -443,7 +444,7 @@ export class MusicSystemBuilder {
         return totalEndInstructionLengthX;
     }
 
-    private AddInstructionsAtMeasureBegin(firstEntry: SourceStaffEntry, measure: StaffMeasure,
+    private AddInstructionsAtMeasureBegin(firstEntry: SourceStaffEntry, measure: GraphicalMeasure,
                                           visibleStaffIdx: number, isFirstSourceMeasure: boolean, isSystemStartMeasure: boolean): number {
         let instructionsLengthX: number = 0;
         let currentClef: ClefInstruction = undefined;
@@ -500,7 +501,7 @@ export class MusicSystemBuilder {
         return instructionsLengthX;
     }
 
-    private addInstructionsAtMeasureEnd(lastEntry: SourceStaffEntry, measure: StaffMeasure): number {
+    private addInstructionsAtMeasureEnd(lastEntry: SourceStaffEntry, measure: GraphicalMeasure): number {
         if (lastEntry === undefined || lastEntry.Instructions === undefined || lastEntry.Instructions.length === 0) {
             return 0;
         }
@@ -521,7 +522,7 @@ export class MusicSystemBuilder {
      * @param measure
      * @param staffMeasures
      */
-    private updateActiveClefs(measure: SourceMeasure, staffMeasures: StaffMeasure[]): void {
+    private updateActiveClefs(measure: SourceMeasure, staffMeasures: GraphicalMeasure[]): void {
         for (let visStaffIdx: number = 0, len: number = staffMeasures.length; visStaffIdx < len; visStaffIdx++) {
             const staffIndex: number = this.visibleStaffIndices[visStaffIdx];
             const firstEntry: SourceStaffEntry = measure.FirstInstructionsStaffEntries[staffIndex];
@@ -566,11 +567,11 @@ export class MusicSystemBuilder {
      * Check if an extra Instruction [[Measure]] is needed.
      * @param measures
      */
-    private checkAndCreateExtraInstructionMeasure(measures: StaffMeasure[]): void {
+    private checkAndCreateExtraInstructionMeasure(measures: GraphicalMeasure[]): void {
         const firstStaffEntries: SourceStaffEntry[] = measures[0].parentSourceMeasure.FirstInstructionsStaffEntries;
         const visibleInstructionEntries: SourceStaffEntry[] = [];
         for (let idx: number = 0, len: number = measures.length; idx < len; ++idx) {
-            const measure: StaffMeasure = measures[idx];
+            const measure: GraphicalMeasure = measures[idx];
             visibleInstructionEntries.push(firstStaffEntries[measure.ParentStaff.idInMusicSheet]);
         }
         let maxMeasureWidth: number = 0;
@@ -608,8 +609,8 @@ export class MusicSystemBuilder {
 
     private addExtraInstructionMeasure(visStaffIdx: number, keyInstruction: KeyInstruction, rhythmInstruction: RhythmInstruction): number {
         const currentSystem: MusicSystem = this.currentSystemParams.currentSystem;
-        const measures: StaffMeasure[] = [];
-        const measure: StaffMeasure = MusicSheetCalculator.symbolFactory.createExtraStaffMeasure(currentSystem.StaffLines[visStaffIdx]);
+        const measures: GraphicalMeasure[] = [];
+        const measure: GraphicalMeasure = MusicSheetCalculator.symbolFactory.createExtraStaffMeasure(currentSystem.StaffLines[visStaffIdx]);
         measures.push(measure);
         if (keyInstruction !== undefined) {
             measure.addKeyAtBegin(keyInstruction, this.activeKeys[visStaffIdx], this.activeClefs[visStaffIdx]);
@@ -630,15 +631,15 @@ export class MusicSystemBuilder {
      * Add all current vertical Measures to currentSystem.
      * @param staffMeasures
      */
-    private addStaveMeasuresToSystem(staffMeasures: StaffMeasure[]): void {
+    private addStaveMeasuresToSystem(staffMeasures: GraphicalMeasure[]): void {
         if (staffMeasures[0] !== undefined) {
-            const gmeasures: StaffMeasure[] = [];
+            const gmeasures: GraphicalMeasure[] = [];
             for (let i: number = 0; i < staffMeasures.length; i++) {
                 gmeasures.push(staffMeasures[i]);
             }
             const currentSystem: MusicSystem = this.currentSystemParams.currentSystem;
             for (let visStaffIdx: number = 0; visStaffIdx < this.numberOfVisibleStaffLines; visStaffIdx++) {
-                const measure: StaffMeasure = gmeasures[visStaffIdx];
+                const measure: GraphicalMeasure = gmeasures[visStaffIdx];
                 currentSystem.StaffLines[visStaffIdx].Measures.push(measure);
                 measure.ParentStaffLine = currentSystem.StaffLines[visStaffIdx];
             }
@@ -688,7 +689,7 @@ export class MusicSystemBuilder {
      * @param isSystemStartMeasure
      * @returns {number}
      */
-    private getLineWidth(measure: StaffMeasure, systemLineEnum: SystemLinesEnum, isSystemStartMeasure: boolean): number {
+    private getLineWidth(measure: GraphicalMeasure, systemLineEnum: SystemLinesEnum, isSystemStartMeasure: boolean): number {
         let width: number = measure.getLineWidth(systemLineEnum);
         if (systemLineEnum === SystemLinesEnum.DotsBoldBoldDots) {
             width /= 2;
@@ -704,7 +705,7 @@ export class MusicSystemBuilder {
             return false;
         }
         for (let idx: number = 0, len: number = this.measureList[this.measureListIndex - 1].length; idx < len; ++idx) {
-            const measure: StaffMeasure = this.measureList[this.measureListIndex - 1][idx];
+            const measure: GraphicalMeasure = this.measureList[this.measureListIndex - 1][idx];
             if (measure.endsWithLineRepetition()) {
                 return true;
             }
@@ -718,7 +719,7 @@ export class MusicSystemBuilder {
      */
     private thisMeasureBeginsLineRepetition(): boolean {
         for (let idx: number = 0, len: number = this.measureList[this.measureListIndex].length; idx < len; ++idx) {
-            const measure: StaffMeasure = this.measureList[this.measureListIndex][idx];
+            const measure: GraphicalMeasure = this.measureList[this.measureListIndex][idx];
             if (measure.beginsWithLineRepetition()) {
                 return true;
             }
@@ -736,7 +737,7 @@ export class MusicSystemBuilder {
             return false;
         }
         for (let idx: number = 0, len: number = this.measureList[nextMeasureIndex].length; idx < len; ++idx) {
-            const measure: StaffMeasure = this.measureList[nextMeasureIndex][idx];
+            const measure: GraphicalMeasure = this.measureList[nextMeasureIndex][idx];
             if (measure.beginsWithLineRepetition()) {
                 return true;
             }
@@ -750,7 +751,7 @@ export class MusicSystemBuilder {
      */
     private thisMeasureEndsLineRepetition(): boolean {
         for (let idx: number = 0, len: number = this.measureList[this.measureListIndex].length; idx < len; ++idx) {
-            const measure: StaffMeasure = this.measureList[this.measureListIndex][idx];
+            const measure: GraphicalMeasure = this.measureList[this.measureListIndex][idx];
             if (measure.endsWithLineRepetition()) {
                 return true;
             }
@@ -768,7 +769,7 @@ export class MusicSystemBuilder {
             return false;
         }
         for (let idx: number = 0, len: number = this.measureList[nextMeasureIndex].length; idx < len; ++idx) {
-            const measure: StaffMeasure = this.measureList[nextMeasureIndex][idx];
+            const measure: GraphicalMeasure = this.measureList[nextMeasureIndex][idx];
             if (measure.beginsWithWordRepetition()) {
                 return true;
             }
@@ -782,7 +783,7 @@ export class MusicSystemBuilder {
      */
     private thisMeasureEndsWordRepetition(): boolean {
         for (let idx: number = 0, len: number = this.measureList[this.measureListIndex].length; idx < len; ++idx) {
-            const measure: StaffMeasure = this.measureList[this.measureListIndex][idx];
+            const measure: GraphicalMeasure = this.measureList[this.measureListIndex][idx];
             if (measure.endsWithWordRepetition()) {
                 return true;
             }
@@ -844,7 +845,7 @@ export class MusicSystemBuilder {
             const staffLine: StaffLine = currentSystem.StaffLines[visStaffIdx];
             let currentXPosition: number = 0.0;
             for (let measureIndex: number = 0; measureIndex < staffLine.Measures.length; measureIndex++) {
-                const measure: StaffMeasure = staffLine.Measures[measureIndex];
+                const measure: GraphicalMeasure = staffLine.Measures[measureIndex];
                 measure.setPositionInStaffline(currentXPosition);
                 measure.setWidth(measure.beginInstructionsWidth + measure.minimumStaffEntriesWidth * scalingFactor + measure.endInstructionsWidth);
                 if (measureIndex < this.currentSystemParams.systemMeasures.length) {

src/MusicalScore/Graphical/StaffLine.ts

@@ -4,7 +4,7 @@ import {Instrument} from "../Instrument";
 import {GraphicalLine} from "./GraphicalLine";
 import {GraphicalStaffEntry} from "./GraphicalStaffEntry";
 import {GraphicalObject} from "./GraphicalObject";
-import {StaffMeasure} from "./StaffMeasure";
+import {GraphicalMeasure} from "./GraphicalMeasure";
 import {MusicSystem} from "./MusicSystem";
 import {StaffLineActivitySymbol} from "./StaffLineActivitySymbol";
 import {PointF2D} from "../../Common/DataObjects/PointF2D";
@@ -15,7 +15,7 @@ import {GraphicalLabel} from "./GraphicalLabel";
  * (one instrument, one line, until a line break)
  */
 export abstract class StaffLine extends GraphicalObject {
-    protected measures: StaffMeasure[] = [];
+    protected measures: GraphicalMeasure[] = [];
     protected staffLines: GraphicalLine[] = new Array(5);
     protected parentMusicSystem: MusicSystem;
     protected parentStaff: Staff;
@@ -31,11 +31,11 @@ export abstract class StaffLine extends GraphicalObject {
         this.boundingBox = new BoundingBox(this, parentSystem.PositionAndShape);
     }
 
-    public get Measures(): StaffMeasure[] {
+    public get Measures(): GraphicalMeasure[] {
         return this.measures;
     }
 
-    public set Measures(value: StaffMeasure[]) {
+    public set Measures(value: GraphicalMeasure[]) {
         this.measures = value;
     }
 
@@ -128,7 +128,7 @@ export abstract class StaffLine extends GraphicalObject {
     public findClosestStaffEntry(xPosition: number): GraphicalStaffEntry {
         let closestStaffentry: GraphicalStaffEntry = undefined;
         for (let idx: number = 0, len: number = this.Measures.length; idx < len; ++idx) {
-            const graphicalMeasure: StaffMeasure = this.Measures[idx];
+            const graphicalMeasure: GraphicalMeasure = this.Measures[idx];
             for (let idx2: number = 0, len2: number = graphicalMeasure.staffEntries.length; idx2 < len2; ++idx2) {
                 const graphicalStaffEntry: GraphicalStaffEntry = graphicalMeasure.staffEntries[idx2];
                 if (

src/MusicalScore/Graphical/SystemLine.ts

@@ -1,4 +1,4 @@
-import {StaffMeasure} from "./StaffMeasure";
+import {GraphicalMeasure} from "./GraphicalMeasure";
 import {StaffLine} from "./StaffLine";
 import {MusicSystem} from "./MusicSystem";
 import {SystemLinePosition} from "./SystemLinePosition";
@@ -10,7 +10,7 @@ import {EngravingRules} from "./EngravingRules";
 export class SystemLine extends GraphicalObject {
 
     constructor(lineType: SystemLinesEnum, linePosition: SystemLinePosition, musicSystem: MusicSystem,
-                topMeasure: StaffMeasure, bottomMeasure: StaffMeasure = undefined) {
+                topMeasure: GraphicalMeasure, bottomMeasure: GraphicalMeasure = undefined) {
         super();
         this.lineType = lineType;
         this.linePosition = linePosition;
@@ -25,8 +25,8 @@ export class SystemLine extends GraphicalObject {
     public linePosition: SystemLinePosition;
     public parentMusicSystem: MusicSystem;
     public parentTopStaffLine: StaffLine;
-    public topMeasure: StaffMeasure;
-    public bottomMeasure: StaffMeasure;
+    public topMeasure: GraphicalMeasure;
+    public bottomMeasure: GraphicalMeasure;
 
     /**
      * Return the width of the SystemLinesContainer for the given SystemLineType.

src/MusicalScore/Graphical/VexFlow/VexFlowGraphicalSymbolFactory.ts

@@ -6,7 +6,7 @@ import {Staff} from "../../VoiceData/Staff";
 import {StaffLine} from "../StaffLine";
 import {VexFlowStaffLine} from "./VexFlowStaffLine";
 import {SourceMeasure} from "../../VoiceData/SourceMeasure";
-import {StaffMeasure} from "../StaffMeasure";
+import {GraphicalMeasure} from "../GraphicalMeasure";
 import {VexFlowMeasure} from "./VexFlowMeasure";
 import {SourceStaffEntry} from "../../VoiceData/SourceStaffEntry";
 import {GraphicalStaffEntry} from "../GraphicalStaffEntry";
@@ -54,7 +54,7 @@ export class VexFlowGraphicalSymbolFactory implements IGraphicalSymbolFactory {
      * @param staff
      * @returns {VexFlowMeasure}
      */
-    public createStaffMeasure(sourceMeasure: SourceMeasure, staff: Staff): StaffMeasure {
+    public createStaffMeasure(sourceMeasure: SourceMeasure, staff: Staff): GraphicalMeasure {
         return new VexFlowMeasure(staff, undefined, sourceMeasure);
     }
 
@@ -63,7 +63,7 @@ export class VexFlowGraphicalSymbolFactory implements IGraphicalSymbolFactory {
      * @param staffLine
      * @returns {VexFlowMeasure}
      */
-    public createExtraStaffMeasure(staffLine: StaffLine): StaffMeasure {
+    public createExtraStaffMeasure(staffLine: StaffLine): GraphicalMeasure {
         return new VexFlowMeasure(staffLine.ParentStaff, staffLine);
     }
 
@@ -73,7 +73,7 @@ export class VexFlowGraphicalSymbolFactory implements IGraphicalSymbolFactory {
      * @param measure
      * @returns {VexFlowStaffEntry}
      */
-    public createStaffEntry(sourceStaffEntry: SourceStaffEntry, measure: StaffMeasure): GraphicalStaffEntry {
+    public createStaffEntry(sourceStaffEntry: SourceStaffEntry, measure: GraphicalMeasure): GraphicalStaffEntry {
         return new VexFlowStaffEntry(<VexFlowMeasure>measure, sourceStaffEntry, undefined);
     }
 
@@ -85,7 +85,7 @@ export class VexFlowGraphicalSymbolFactory implements IGraphicalSymbolFactory {
      * @param measure
      * @returns {VexFlowStaffEntry}
      */
-    public createGraceStaffEntry(staffEntryParent: GraphicalStaffEntry, measure: StaffMeasure): GraphicalStaffEntry {
+    public createGraceStaffEntry(staffEntryParent: GraphicalStaffEntry, measure: GraphicalMeasure): GraphicalStaffEntry {
         return new VexFlowStaffEntry(<VexFlowMeasure>measure, undefined, <VexFlowStaffEntry>staffEntryParent);
     }
 

src/MusicalScore/Graphical/VexFlow/VexFlowMeasure.ts

@@ -1,5 +1,5 @@
 import Vex = require("vexflow");
-import {StaffMeasure} from "../StaffMeasure";
+import {GraphicalMeasure} from "../GraphicalMeasure";
 import {SourceMeasure} from "../../VoiceData/SourceMeasure";
 import {Staff} from "../../VoiceData/Staff";
 import {StaffLine} from "../StaffLine";
@@ -25,7 +25,7 @@ import {VexFlowVoiceEntry} from "./VexFlowVoiceEntry";
 import {Fraction} from "../../../Common/DataObjects/Fraction";
 import { Voice } from "../../VoiceData/Voice";
 
-export class VexFlowMeasure extends StaffMeasure {
+export class VexFlowMeasure extends GraphicalMeasure {
     constructor(staff: Staff, staffLine: StaffLine = undefined, sourceMeasure: SourceMeasure = undefined) {
         super(staff, sourceMeasure, staffLine);
         this.minimumStaffEntriesWidth = -1;

src/MusicalScore/Graphical/VexFlow/VexFlowMusicSheetCalculator.ts

@@ -1,6 +1,6 @@
 import {MusicSheetCalculator} from "../MusicSheetCalculator";
 import {VexFlowGraphicalSymbolFactory} from "./VexFlowGraphicalSymbolFactory";
-import {StaffMeasure} from "../StaffMeasure";
+import {GraphicalMeasure} from "../GraphicalMeasure";
 import {StaffLine} from "../StaffLine";
 import {VoiceEntry} from "../../VoiceData/VoiceEntry";
 import {MusicSystem} from "../MusicSystem";
@@ -77,7 +77,7 @@ export class VexFlowMusicSheetCalculator extends MusicSheetCalculator {
    * @param measures
    * @returns the minimum required x width of the source measure (=list of staff measures)
    */
-  protected calculateMeasureXLayout(measures: StaffMeasure[]): number {
+  protected calculateMeasureXLayout(measures: GraphicalMeasure[]): number {
     // Finalize beams
     /*for (let measure of measures) {
      (measure as VexFlowMeasure).finalizeBeams();
@@ -137,7 +137,7 @@ export class VexFlowMusicSheetCalculator extends MusicSheetCalculator {
     return;
   }
 
-  protected staffMeasureCreatedCalculations(measure: StaffMeasure): void {
+  protected staffMeasureCreatedCalculations(measure: GraphicalMeasure): void {
     (measure as VexFlowMeasure).staffMeasureCreatedCalculations();
   }
 

src/MusicalScore/Graphical/VexFlow/VexFlowMusicSystem.ts

@@ -2,7 +2,7 @@ import {MusicSystem} from "../MusicSystem";
 import {GraphicalMusicPage} from "../GraphicalMusicPage";
 import {SystemLinesEnum} from "../SystemLinesEnum";
 import {SystemLinePosition} from "../SystemLinePosition";
-import {StaffMeasure} from "../StaffMeasure";
+import {GraphicalMeasure} from "../GraphicalMeasure";
 import {SystemLine} from "../SystemLine";
 import {VexFlowStaffLine} from "./VexFlowStaffLine";
 import {VexFlowMeasure} from "./VexFlowMeasure";
@@ -39,7 +39,7 @@ export class VexFlowMusicSystem extends MusicSystem {
      * @param bottomMeasure
      */
     protected createSystemLine(xPosition: number, lineWidth: number, lineType: SystemLinesEnum, linePosition: SystemLinePosition,
-                               musicSystem: MusicSystem, topMeasure: StaffMeasure, bottomMeasure: StaffMeasure = undefined): SystemLine {
+                               musicSystem: MusicSystem, topMeasure: GraphicalMeasure, bottomMeasure: GraphicalMeasure = undefined): SystemLine {
         const vfMeasure: VexFlowMeasure = topMeasure as VexFlowMeasure;
         vfMeasure.addMeasureLine(lineType, linePosition);
         if (bottomMeasure) {

src/MusicalScore/Interfaces/IGraphicalSymbolFactory.ts

@@ -11,7 +11,7 @@ import {SourceMeasure} from "../VoiceData/SourceMeasure";
 import {SourceStaffEntry} from "../VoiceData/SourceStaffEntry";
 import {Staff} from "../VoiceData/Staff";
 import {StaffLine} from "../Graphical/StaffLine";
-import {StaffMeasure} from "../Graphical/StaffMeasure";
+import {GraphicalMeasure} from "../Graphical/GraphicalMeasure";
 import { TechnicalInstruction } from "../VoiceData/Instructions/TechnicalInstruction";
 import { GraphicalVoiceEntry } from "../Graphical/GraphicalVoiceEntry";
 import { VoiceEntry } from "../VoiceData/VoiceEntry";
@@ -22,13 +22,13 @@ export interface IGraphicalSymbolFactory {
 
     createStaffLine(parentSystem: MusicSystem, parentStaff: Staff): StaffLine;
 
-    createStaffMeasure(sourceMeasure: SourceMeasure, staff: Staff): StaffMeasure;
+    createStaffMeasure(sourceMeasure: SourceMeasure, staff: Staff): GraphicalMeasure;
 
-    createExtraStaffMeasure(staffLine: StaffLine): StaffMeasure;
+    createExtraStaffMeasure(staffLine: StaffLine): GraphicalMeasure;
 
-    createStaffEntry(sourceStaffEntry: SourceStaffEntry, measure: StaffMeasure): GraphicalStaffEntry;
+    createStaffEntry(sourceStaffEntry: SourceStaffEntry, measure: GraphicalMeasure): GraphicalStaffEntry;
 
-    createGraceStaffEntry(staffEntryParent: GraphicalStaffEntry, measure: StaffMeasure): GraphicalStaffEntry;
+    createGraceStaffEntry(staffEntryParent: GraphicalStaffEntry, measure: GraphicalMeasure): GraphicalStaffEntry;
 
     createVoiceEntry(parentVoiceEntry: VoiceEntry, parentStaffEntry: GraphicalStaffEntry): GraphicalVoiceEntry;
 

test/MusicalScore/Graphical/VexFlow/VexFlowMeasure_Test.ts

@@ -6,7 +6,7 @@ import {VexFlowMusicSheetCalculator} from "../../../../src/MusicalScore/Graphica
 import {TestUtils} from "../../../Util/TestUtils";
 import {SourceMeasure} from "../../../../src/MusicalScore/VoiceData/SourceMeasure";
 import {SourceStaffEntry} from "../../../../src/MusicalScore/VoiceData/SourceStaffEntry";
-import {StaffMeasure} from "../../../../src/MusicalScore/Graphical/StaffMeasure";
+import {GraphicalMeasure} from "../../../../src/MusicalScore/Graphical/GraphicalMeasure";
 import {MusicSheetCalculator} from "../../../../src/MusicalScore/Graphical/MusicSheetCalculator";
 
 /* tslint:disable:no-unused-expression */
@@ -34,7 +34,7 @@ describe("VexFlow Measure", () => {
       const gms: GraphicalMusicSheet = new GraphicalMusicSheet(sheet, calc);
       chai.expect(gms.MeasureList.length).to.equal(1);
       chai.expect(gms.MeasureList[0].length).to.equal(1);
-      const gm: StaffMeasure = gms.MeasureList[0][0];
+      const gm: GraphicalMeasure = gms.MeasureList[0][0];
       console.log(gm);
       done();
    });