additional StaffMeasure -> GraphicalMeasure renames

compiles and demo works again (this time for real)

src/MusicalScore/Graphical/MusicSheetCalculator.ts

@@ -230,7 +230,7 @@ export abstract class MusicSheetCalculator {
     /**
      * Called for every source measure when generating the list of staff measures for it.
      */
-    protected initStaffMeasuresCreation(): void {
+    protected initGraphicalMeasuresCreation(): void {
         throw new Error("abstract, not implemented");
     }
 
@@ -611,15 +611,15 @@ export abstract class MusicSheetCalculator {
         // visible 2D-MeasureList
         const visibleMeasureList: GraphicalMeasure[][] = [];
         for (let idx: number = 0, len: number = allMeasures.length; idx < len; ++idx) {
-            const staffMeasures: GraphicalMeasure[] = allMeasures[idx];
-            const visibleStaffMeasures: GraphicalMeasure[] = [];
-            for (let idx2: number = 0, len2: number = staffMeasures.length; idx2 < len2; ++idx2) {
-                const staffMeasure: GraphicalMeasure = allMeasures[idx][idx2];
-                if (staffMeasure.isVisible()) {
-                    visibleStaffMeasures.push(staffMeasure);
+            const graphicalMeasures: GraphicalMeasure[] = allMeasures[idx];
+            const visiblegraphicalMeasures: GraphicalMeasure[] = [];
+            for (let idx2: number = 0, len2: number = graphicalMeasures.length; idx2 < len2; ++idx2) {
+                const graphicalMeasure: GraphicalMeasure = allMeasures[idx][idx2];
+                if (graphicalMeasure.isVisible()) {
+                    visiblegraphicalMeasures.push(graphicalMeasure);
                 }
             }
-            visibleMeasureList.push(visibleStaffMeasures);
+            visibleMeasureList.push(visiblegraphicalMeasures);
         }
 
         // find out how many StaffLine Instances we need
@@ -857,7 +857,7 @@ export abstract class MusicSheetCalculator {
         return;
     }
 
-    protected staffMeasureCreatedCalculations(measure: GraphicalMeasure): void {
+    protected graphicalMeasureCreatedCalculations(measure: GraphicalMeasure): void {
         return;
     }
 
@@ -1293,7 +1293,7 @@ export abstract class MusicSheetCalculator {
     private createGraphicalMeasuresForSourceMeasure(sourceMeasure: SourceMeasure, accidentalCalculators: AccidentalCalculator[],
                                                     openLyricWords: LyricWord[],
                                                     openOctaveShifts: OctaveShiftParams[], activeClefs: ClefInstruction[]): GraphicalMeasure[] {
-        this.initStaffMeasuresCreation();
+        this.initGraphicalMeasuresCreation();
         const verticalMeasureList: GraphicalMeasure[] = [];
         const openBeams: Beam[] = [];
         const openTuplets: Tuplet[] = [];
@@ -1303,7 +1303,7 @@ export abstract class MusicSheetCalculator {
                 sourceMeasure, openTuplets, openBeams,
                 accidentalCalculators[staffIndex], activeClefs, openOctaveShifts, openLyricWords, staffIndex, staffEntryLinks
             );
-            this.staffMeasureCreatedCalculations(measure);
+            this.graphicalMeasureCreatedCalculations(measure);
             verticalMeasureList.push(measure);
         }
         this.graphicalMusicSheet.sourceToGraphicalMeasureLinks.setValue(sourceMeasure, verticalMeasureList);
@@ -1315,7 +1315,7 @@ export abstract class MusicSheetCalculator {
                                    openOctaveShifts: OctaveShiftParams[], openLyricWords: LyricWord[], staffIndex: number,
                                    staffEntryLinks: StaffEntryLink[]): GraphicalMeasure {
         const staff: Staff = this.graphicalMusicSheet.ParentMusicSheet.getStaffFromIndex(staffIndex);
-        const measure: GraphicalMeasure = MusicSheetCalculator.symbolFactory.createStaffMeasure(sourceMeasure, staff);
+        const measure: GraphicalMeasure = MusicSheetCalculator.symbolFactory.createGraphicalMeasure(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) {
@@ -1769,8 +1769,8 @@ export abstract class MusicSheetCalculator {
             const startX: number = startStaffEntry.parentMeasure.PositionAndShape.RelativePosition.x +
                 startStaffEntry.PositionAndShape.RelativePosition.x +
                 lyricEntry.GraphicalLabel.PositionAndShape.BorderMarginRight;
-            const lastStaffMeasure: GraphicalMeasure = startStaffLine.Measures[startStaffLine.Measures.length - 1];
-            const endX: number = lastStaffMeasure.PositionAndShape.RelativePosition.x + lastStaffMeasure.PositionAndShape.Size.width;
+            const lastGraphicalMeasure: GraphicalMeasure = startStaffLine.Measures[startStaffLine.Measures.length - 1];
+            const endX: number = lastGraphicalMeasure.PositionAndShape.RelativePosition.x + lastGraphicalMeasure.PositionAndShape.Size.width;
             let y: number = lyricEntry.GraphicalLabel.PositionAndShape.RelativePosition.y;
 
             // calculate Dashes for the first StaffLine

src/MusicalScore/Graphical/MusicSystem.ts

@@ -186,7 +186,7 @@ export abstract class MusicSystem extends GraphicalObject {
         return this.StaffLines[0].PositionAndShape.AbsolutePosition.x + this.StaffLines[0].StaffLines[0].End.x;
     }
 
-    public AddStaffMeasures(graphicalMeasures: GraphicalMeasure[]): void {
+    public AddGraphicalMeasures(graphicalMeasures: GraphicalMeasure[]): void {
         for (let idx: number = 0, len: number = graphicalMeasures.length; idx < len; ++idx) {
             const graphicalMeasure: GraphicalMeasure = graphicalMeasures[idx];
             graphicalMeasure.parentMusicSystem = this;

src/MusicalScore/Graphical/MusicSystemBuilder.ts

@@ -81,11 +81,11 @@ 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: GraphicalMeasure[] = this.measureList[this.measureListIndex];
-            for (let idx: number = 0, len: number = staffMeasures.length; idx < len; ++idx) {
-                staffMeasures[idx].resetLayout();
+            const graphicalMeasures: GraphicalMeasure[] = this.measureList[this.measureListIndex];
+            for (let idx: number = 0, len: number = graphicalMeasures.length; idx < len; ++idx) {
+                graphicalMeasures[idx].resetLayout();
             }
-            const sourceMeasure: SourceMeasure = staffMeasures[0].parentSourceMeasure;
+            const sourceMeasure: SourceMeasure = graphicalMeasures[0].parentSourceMeasure;
             const sourceMeasureEndsSystem: boolean = sourceMeasure.BreakSystemAfter;
             const isSystemStartMeasure: boolean = this.currentSystemParams.IsSystemStartMeasure();
             const isFirstSourceMeasure: boolean = sourceMeasure === this.graphicalMusicSheet.ParentMusicSheet.getFirstSourceMeasure();
@@ -98,41 +98,41 @@ export class MusicSystemBuilder {
             // 2. the staff entries (= notes) and
             // 3. the end instructions (actually only clefs)
             const measureStartLine: SystemLinesEnum = this.getMeasureStartLine();
-            currentMeasureBeginInstructionsWidth += this.getLineWidth(staffMeasures[0], measureStartLine, isSystemStartMeasure);
+            currentMeasureBeginInstructionsWidth += this.getLineWidth(graphicalMeasures[0], measureStartLine, isSystemStartMeasure);
             if (!this.leadSheet) {
-                currentMeasureBeginInstructionsWidth += this.addBeginInstructions(staffMeasures, isSystemStartMeasure, isFirstSourceMeasure);
-                currentMeasureEndInstructionsWidth += this.addEndInstructions(staffMeasures);
+                currentMeasureBeginInstructionsWidth += this.addBeginInstructions(graphicalMeasures, isSystemStartMeasure, isFirstSourceMeasure);
+                currentMeasureEndInstructionsWidth += this.addEndInstructions(graphicalMeasures);
             }
             let currentMeasureVarWidth: number = 0;
             for (let i: number = 0; i < this.numberOfVisibleStaffLines; i++) {
-                currentMeasureVarWidth = Math.max(currentMeasureVarWidth, staffMeasures[i].minimumStaffEntriesWidth);
+                currentMeasureVarWidth = Math.max(currentMeasureVarWidth, graphicalMeasures[i].minimumStaffEntriesWidth);
             }
 
             // take into account the LineWidth after each Measure
             const measureEndLine: SystemLinesEnum = this.getMeasureEndLine();
-            currentMeasureEndInstructionsWidth += this.getLineWidth(staffMeasures[0], measureEndLine, isSystemStartMeasure);
+            currentMeasureEndInstructionsWidth += this.getLineWidth(graphicalMeasures[0], measureEndLine, isSystemStartMeasure);
             let nextMeasureBeginInstructionWidth: number = this.rules.MeasureLeftMargin;
 
             // Check if there are key or rhythm change instructions within the next measure:
             if (this.measureListIndex + 1 < this.measureList.length) {
-                const nextStaffMeasures: GraphicalMeasure[] = this.measureList[this.measureListIndex + 1];
-                const nextSourceMeasure: SourceMeasure = nextStaffMeasures[0].parentSourceMeasure;
+                const nextGraphicalMeasures: GraphicalMeasure[] = this.measureList[this.measureListIndex + 1];
+                const nextSourceMeasure: SourceMeasure = nextGraphicalMeasures[0].parentSourceMeasure;
                 if (nextSourceMeasure.hasBeginInstructions()) {
-                    nextMeasureBeginInstructionWidth += this.addBeginInstructions(nextStaffMeasures, false, false);
+                    nextMeasureBeginInstructionWidth += this.addBeginInstructions(nextGraphicalMeasures, false, false);
                 }
             }
             const totalMeasureWidth: number = currentMeasureBeginInstructionsWidth + currentMeasureEndInstructionsWidth + currentMeasureVarWidth;
             const measureFitsInSystem: boolean = this.currentSystemParams.currentWidth + totalMeasureWidth + nextMeasureBeginInstructionWidth < systemMaxWidth;
             if (isSystemStartMeasure || measureFitsInSystem) {
                 this.addMeasureToSystem(
-                    staffMeasures, measureStartLine, measureEndLine, totalMeasureWidth,
+                    graphicalMeasures, measureStartLine, measureEndLine, totalMeasureWidth,
                     currentMeasureBeginInstructionsWidth, currentMeasureVarWidth, currentMeasureEndInstructionsWidth
                 );
-                this.updateActiveClefs(sourceMeasure, staffMeasures);
+                this.updateActiveClefs(sourceMeasure, graphicalMeasures);
                 this.measureListIndex++;
             } else {
                 // finalize current system and prepare a new one
-                this.finalizeCurrentAndCreateNewSystem(staffMeasures, previousMeasureEndsSystem);
+                this.finalizeCurrentAndCreateNewSystem(graphicalMeasures, previousMeasureEndsSystem);
                 // don't increase measure index to check this measure now again
             }
             previousMeasureEndsSystem = sourceMeasureEndsSystem;
@@ -142,14 +142,14 @@ export class MusicSystemBuilder {
 
     /**
      * Set the Width of the staff-Measures of one source measure.
-     * @param staffMeasures
+     * @param graphicalMeasures
      * @param width
      * @param beginInstrWidth
      * @param endInstrWidth
      */
-    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: GraphicalMeasure = staffMeasures[idx];
+    private setMeasureWidth(graphicalMeasures: GraphicalMeasure[], width: number, beginInstrWidth: number, endInstrWidth: number): void {
+        for (let idx: number = 0, len: number = graphicalMeasures.length; idx < len; ++idx) {
+            const measure: GraphicalMeasure = graphicalMeasures[idx];
             measure.setWidth(width);
             if (beginInstrWidth > 0) {
                 measure.beginInstructionsWidth = beginInstrWidth;
@@ -218,14 +218,14 @@ export class MusicSystemBuilder {
     }
 
     private addMeasureToSystem(
-        staffMeasures: GraphicalMeasure[], measureStartLine: SystemLinesEnum, measureEndLine: SystemLinesEnum,
+        graphicalMeasures: GraphicalMeasure[], measureStartLine: SystemLinesEnum, measureEndLine: SystemLinesEnum,
         totalMeasureWidth: number, currentMeasureBeginInstructionsWidth: number, currentVarWidth: number, currentMeasureEndInstructionsWidth: number
     ): void {
         this.currentSystemParams.systemMeasures.push({beginLine: measureStartLine, endLine: measureEndLine});
         this.setMeasureWidth(
-            staffMeasures, totalMeasureWidth, currentMeasureBeginInstructionsWidth, currentMeasureEndInstructionsWidth
+            graphicalMeasures, totalMeasureWidth, currentMeasureBeginInstructionsWidth, currentMeasureEndInstructionsWidth
         );
-        this.addStaveMeasuresToSystem(staffMeasures);
+        this.addStaveMeasuresToSystem(graphicalMeasures);
         this.currentSystemParams.currentWidth += totalMeasureWidth;
         this.currentSystemParams.currentSystemFixWidth += currentMeasureBeginInstructionsWidth + currentMeasureEndInstructionsWidth;
         this.currentSystemParams.currentSystemVarWidth += currentVarWidth;
@@ -520,10 +520,10 @@ export class MusicSystemBuilder {
      * This has to be done after the measure is added to a system
      * (otherwise already the check if the measure fits to the system would update the active clefs..)
      * @param measure
-     * @param staffMeasures
+     * @param graphicalMeasures
      */
-    private updateActiveClefs(measure: SourceMeasure, staffMeasures: GraphicalMeasure[]): void {
-        for (let visStaffIdx: number = 0, len: number = staffMeasures.length; visStaffIdx < len; visStaffIdx++) {
+    private updateActiveClefs(measure: SourceMeasure, graphicalMeasures: GraphicalMeasure[]): void {
+        for (let visStaffIdx: number = 0, len: number = graphicalMeasures.length; visStaffIdx < len; visStaffIdx++) {
             const staffIndex: number = this.visibleStaffIndices[visStaffIdx];
             const firstEntry: SourceStaffEntry = measure.FirstInstructionsStaffEntries[staffIndex];
             if (firstEntry !== undefined) {
@@ -610,7 +610,7 @@ export class MusicSystemBuilder {
     private addExtraInstructionMeasure(visStaffIdx: number, keyInstruction: KeyInstruction, rhythmInstruction: RhythmInstruction): number {
         const currentSystem: MusicSystem = this.currentSystemParams.currentSystem;
         const measures: GraphicalMeasure[] = [];
-        const measure: GraphicalMeasure = MusicSheetCalculator.symbolFactory.createExtraStaffMeasure(currentSystem.StaffLines[visStaffIdx]);
+        const measure: GraphicalMeasure = MusicSheetCalculator.symbolFactory.createExtraGraphicalMeasure(currentSystem.StaffLines[visStaffIdx]);
         measures.push(measure);
         if (keyInstruction !== undefined) {
             measure.addKeyAtBegin(keyInstruction, this.activeKeys[visStaffIdx], this.activeClefs[visStaffIdx]);
@@ -629,13 +629,13 @@ export class MusicSystemBuilder {
 
     /**
      * Add all current vertical Measures to currentSystem.
-     * @param staffMeasures
+     * @param graphicalMeasures
      */
-    private addStaveMeasuresToSystem(staffMeasures: GraphicalMeasure[]): void {
-        if (staffMeasures[0] !== undefined) {
+    private addStaveMeasuresToSystem(graphicalMeasures: GraphicalMeasure[]): void {
+        if (graphicalMeasures[0] !== undefined) {
             const gmeasures: GraphicalMeasure[] = [];
-            for (let i: number = 0; i < staffMeasures.length; i++) {
-                gmeasures.push(staffMeasures[i]);
+            for (let i: number = 0; i < graphicalMeasures.length; i++) {
+                gmeasures.push(graphicalMeasures[i]);
             }
             const currentSystem: MusicSystem = this.currentSystemParams.currentSystem;
             for (let visStaffIdx: number = 0; visStaffIdx < this.numberOfVisibleStaffLines; visStaffIdx++) {
@@ -643,7 +643,7 @@ export class MusicSystemBuilder {
                 currentSystem.StaffLines[visStaffIdx].Measures.push(measure);
                 measure.ParentStaffLine = currentSystem.StaffLines[visStaffIdx];
             }
-            currentSystem.AddStaffMeasures(gmeasures);
+            currentSystem.AddGraphicalMeasures(gmeasures);
         }
     }
 

src/MusicalScore/Graphical/VexFlow/VexFlowGraphicalSymbolFactory.ts

@@ -49,12 +49,12 @@ export class VexFlowGraphicalSymbolFactory implements IGraphicalSymbolFactory {
     }
 
     /**
-     * Construct an empty staffMeasure from the given source measure and staff.
+     * Construct an empty graphicalMeasure from the given source measure and staff.
      * @param sourceMeasure
      * @param staff
      * @returns {VexFlowMeasure}
      */
-    public createStaffMeasure(sourceMeasure: SourceMeasure, staff: Staff): GraphicalMeasure {
+    public createGraphicalMeasure(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): GraphicalMeasure {
+    public createExtraGraphicalMeasure(staffLine: StaffLine): GraphicalMeasure {
         return new VexFlowMeasure(staffLine.ParentStaff, staffLine);
     }
 

src/MusicalScore/Interfaces/IGraphicalSymbolFactory.ts

@@ -22,9 +22,9 @@ export interface IGraphicalSymbolFactory {
 
     createStaffLine(parentSystem: MusicSystem, parentStaff: Staff): StaffLine;
 
-    createStaffMeasure(sourceMeasure: SourceMeasure, staff: Staff): GraphicalMeasure;
+    createGraphicalMeasure(sourceMeasure: SourceMeasure, staff: Staff): GraphicalMeasure;
 
-    createExtraStaffMeasure(staffLine: StaffLine): GraphicalMeasure;
+    createExtraGraphicalMeasure(staffLine: StaffLine): GraphicalMeasure;
 
     createStaffEntry(sourceStaffEntry: SourceStaffEntry, measure: GraphicalMeasure): GraphicalStaffEntry;
 

src/MusicalScore/ScoreIO/MusicSheetReader.ts

@@ -373,8 +373,8 @@ export class MusicSheetReader /*implements IMusicSheetReader*/ {
             ) {
                 const firstStaffIndexOfInstrument: number = this.musicSheet.getGlobalStaffIndexOfFirstStaff(this.musicSheet.Instruments[i]);
                 for (let staffIndex: number = 0; staffIndex < this.musicSheet.Instruments[i].Staves.length; staffIndex++) {
-                    if (!this.staffMeasureIsEmpty(firstStaffIndexOfInstrument + staffIndex)) {
-                        this.currentMeasure.setErrorInStaffMeasure(firstStaffIndexOfInstrument + staffIndex, true);
+                    if (!this.graphicalMeasureIsEmpty(firstStaffIndexOfInstrument + staffIndex)) {
+                        this.currentMeasure.setErrorInGraphicalMeasure(firstStaffIndexOfInstrument + staffIndex, true);
                         const errorMsg: string = ITextTranslation.translateText("ReaderErrorMessages/MissingNotesError",
                                                                                 "Given Notes don't correspond to measure duration.");
                         this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
@@ -432,7 +432,7 @@ export class MusicSheetReader /*implements IMusicSheetReader*/ {
         return (counter === instrumentsDurations.length && maxInstrumentDuration !== new Fraction(0, 1));
     }
 
-    private staffMeasureIsEmpty(index: number): boolean {
+    private graphicalMeasureIsEmpty(index: number): boolean {
         let counter: number = 0;
         for (let i: number = 0; i < this.currentMeasure.VerticalSourceStaffEntryContainers.length; i++) {
             if (this.currentMeasure.VerticalSourceStaffEntryContainers[i].StaffEntries[index] === undefined) {

src/MusicalScore/VoiceData/SourceMeasure.ts

@@ -33,7 +33,7 @@ export class SourceMeasure extends BaseIdClass {
         this.firstInstructionsStaffEntries = new Array(completeNumberOfStaves);
         this.lastInstructionsStaffEntries = new Array(completeNumberOfStaves);
         for (let i: number = 0; i < completeNumberOfStaves; i++) {
-            this.staffMeasureErrors.push(false);
+            this.graphicalMeasureErrors.push(false);
             this.staffLinkedExpressions.push([]);
         }
     }
@@ -56,7 +56,7 @@ export class SourceMeasure extends BaseIdClass {
     private verticalSourceStaffEntryContainers: VerticalSourceStaffEntryContainer[] = [];
     private implicitMeasure: boolean;
     private breakSystemAfter: boolean;
-    private staffMeasureErrors: boolean[] = [];
+    private graphicalMeasureErrors: boolean[] = [];
     private firstInstructionsStaffEntries: SourceStaffEntry[];
     private lastInstructionsStaffEntries: SourceStaffEntry[];
     private firstRepetitionInstructions: RepetitionInstruction[] = [];
@@ -135,11 +135,11 @@ export class SourceMeasure extends BaseIdClass {
     }
 
     public getErrorInMeasure(staffIndex: number): boolean {
-        return this.staffMeasureErrors[staffIndex];
+        return this.graphicalMeasureErrors[staffIndex];
     }
 
-    public setErrorInStaffMeasure(staffIndex: number, hasError: boolean): void {
-        this.staffMeasureErrors[staffIndex] = hasError;
+    public setErrorInGraphicalMeasure(staffIndex: number, hasError: boolean): void {
+        this.graphicalMeasureErrors[staffIndex] = hasError;
     }
 
     public getNextMeasure(measures: SourceMeasure[]): SourceMeasure {