refactor(Renamed instantanious to instantaneos.): Because it's correcter

src/MusicalScore/Graphical/EngravingRules.ts

@@ -112,7 +112,7 @@ export class EngravingRules {
     private slurTangentMinAngle: number;
     private slurTangentMaxAngle: number;
     private slursStartingAtSameStaffEntryYOffset: number;
-    private instantaniousTempoTextHeight: number;
+    private instantaneousTempoTextHeight: number;
     private continuousDynamicTextHeight: number;
     private moodTextHeight: number;
     private unknownTextHeight: number;
@@ -280,7 +280,7 @@ export class EngravingRules {
         this.minimumDistanceBetweenDashes = 10;
 
         // expressions variables
-        this.instantaniousTempoTextHeight = 2.3;
+        this.instantaneousTempoTextHeight = 2.3;
         this.continuousDynamicTextHeight = 2.3;
         this.moodTextHeight = 2.3;
         this.unknownTextHeight = 2.0;
@@ -961,11 +961,11 @@ export class EngravingRules {
     public set SlursStartingAtSameStaffEntryYOffset(value: number) {
         this.slursStartingAtSameStaffEntryYOffset = value;
     }
-    public get InstantaniousTempoTextHeight(): number {
-        return this.instantaniousTempoTextHeight;
+    public get InstantaneousTempoTextHeight(): number {
+        return this.instantaneousTempoTextHeight;
     }
-    public set InstantaniousTempoTextHeight(value: number) {
-        this.instantaniousTempoTextHeight = value;
+    public set InstantaneousTempoTextHeight(value: number) {
+        this.instantaneousTempoTextHeight = value;
     }
     public get ContinuousDynamicTextHeight(): number {
         return this.continuousDynamicTextHeight;

src/MusicalScore/Graphical/GraphicalInstantaniousDynamicExpression.ts → src/MusicalScore/Graphical/GraphicalInstantaneousDynamicExpression.ts

@@ -1,18 +1,18 @@
 import { GraphicalObject } from "./GraphicalObject";
 import { StaffLine } from "./StaffLine";
-import { InstantaniousDynamicExpression } from "../VoiceData/Expressions/InstantaniousDynamicExpression";
+import { InstantaneousDynamicExpression } from "../VoiceData/Expressions/InstantaneousDynamicExpression";
 import { GraphicalMeasure } from "./GraphicalMeasure";
 import { BoundingBox } from "./BoundingBox";
 
-export class GraphicalInstantaniousDynamicExpression extends GraphicalObject {
-    protected mInstantaniousDynamicExpression: InstantaniousDynamicExpression;
+export class GraphicalInstantaneousDynamicExpression extends GraphicalObject {
+    protected mInstantaneousDynamicExpression: InstantaneousDynamicExpression;
     protected mParentStaffLine: StaffLine;
     protected mMeasure: GraphicalMeasure;
 
-    constructor(instantaniousDynamic: InstantaniousDynamicExpression, staffLine: StaffLine, measure: GraphicalMeasure) {
+    constructor(instantaneousDynamic: InstantaneousDynamicExpression, staffLine: StaffLine, measure: GraphicalMeasure) {
         super();
         this.boundingBox = new BoundingBox(this, staffLine.PositionAndShape);
-        this.mInstantaniousDynamicExpression = instantaniousDynamic;
+        this.mInstantaneousDynamicExpression = instantaneousDynamic;
         this.mParentStaffLine = staffLine;
         this.mMeasure = measure;
     }

src/MusicalScore/Graphical/MusicSheetCalculator.ts

@@ -717,7 +717,7 @@ export abstract class MusicSheetCalculator {
         // calculate StaffEntry ChordSymbols
         this.calculateChordSymbols();
         if (!this.leadSheet) {
-            // calculate all Instantanious/Continuous Dynamics Expressions
+            // calculate all Instantaneous/Continuous Dynamics Expressions
             this.calculateDynamicExpressions();
             // place neighbouring DynamicExpressions at the same height
             this.optimizeStaffLineDynamicExpressionsPositions();
@@ -1966,7 +1966,7 @@ export abstract class MusicSheetCalculator {
             for (let j: number = 0; j < sourceMeasure.StaffLinkedExpressions.length; j++) {
                 if (this.graphicalMusicSheet.MeasureList[i][j].ParentStaff.ParentInstrument.Visible) {
                     for (let k: number = 0; k < sourceMeasure.StaffLinkedExpressions[j].length; k++) {
-                        if (sourceMeasure.StaffLinkedExpressions[j][k].InstantaniousDynamic !== undefined ||
+                        if (sourceMeasure.StaffLinkedExpressions[j][k].InstantaneousDynamic !== undefined ||
                             (sourceMeasure.StaffLinkedExpressions[j][k].StartingContinuousDynamic !== undefined &&
                                 sourceMeasure.StaffLinkedExpressions[j][k].StartingContinuousDynamic.StartMultiExpression ===
                                 sourceMeasure.StaffLinkedExpressions[j][k] && sourceMeasure.StaffLinkedExpressions[j][k].UnknownList.length === 0)

src/MusicalScore/Graphical/MusicSheetDrawer.ts

@@ -354,7 +354,7 @@ export abstract class MusicSheetDrawer {
 
         this.drawOctaveShifts(staffLine);
 
-        this.drawInstantaniousDynamic(staffLine);
+        this.drawInstantaneousDynamic(staffLine);
 
         if (this.skyLineVisible) {
             this.drawSkyLine(staffLine);
@@ -425,7 +425,7 @@ export abstract class MusicSheetDrawer {
     //         drawLineAsVerticalRectangle(ending.Right, absolutePosition, <number>GraphicalLayers.Notes);
     //     this.drawLabel(ending.Label, <number>GraphicalLayers.Notes);
     // }
-    protected drawInstantaniousDynamic(staffline: StaffLine): void {
+    protected drawInstantaneousDynamic(staffline: StaffLine): void {
         // expression.ExpressionSymbols.forEach(function (expressionSymbol) {
         //     let position: PointF2D = expressionSymbol.PositionAndShape.AbsolutePosition;
         //     let symbol: MusicSymbol = expressionSymbol.GetSymbol;

src/MusicalScore/Graphical/VexFlow/VexFlowInstantaniousDynamicExpression.ts → src/MusicalScore/Graphical/VexFlow/VexFlowInstantaneousDynamicExpression.ts

@@ -1,5 +1,5 @@
-import { GraphicalInstantaniousDynamicExpression } from "../GraphicalInstantaniousDynamicExpression";
-import { InstantaniousDynamicExpression, DynamicEnum } from "../../VoiceData/Expressions/InstantaniousDynamicExpression";
+import { GraphicalInstantaneousDynamicExpression } from "../GraphicalInstantaneousDynamicExpression";
+import { InstantaneousDynamicExpression, DynamicEnum } from "../../VoiceData/Expressions/InstantaneousDynamicExpression";
 import { GraphicalLabel } from "../GraphicalLabel";
 import { Label } from "../../Label";
 import { TextAlignment } from "../../../Common/Enums/TextAlignment";
@@ -8,11 +8,11 @@ import { FontStyles } from "../../../Common/Enums/FontStyles";
 import { StaffLine } from "../StaffLine";
 import { GraphicalMeasure } from "../GraphicalMeasure";
 
-export class VexFlowInstantaniousDynamicExpression extends GraphicalInstantaniousDynamicExpression {
+export class VexFlowInstantaneousDynamicExpression extends GraphicalInstantaneousDynamicExpression {
     private mLabel: GraphicalLabel;
 
-    constructor(instantaniousDynamicExpression: InstantaniousDynamicExpression, staffLine: StaffLine, measure: GraphicalMeasure) {
-        super(instantaniousDynamicExpression, staffLine, measure);
+    constructor(instantaneousDynamicExpression: InstantaneousDynamicExpression, staffLine: StaffLine, measure: GraphicalMeasure) {
+        super(instantaneousDynamicExpression, staffLine, measure);
 
         this.mLabel = new GraphicalLabel(new Label(this.Expression),
                                          EngravingRules.Rules.ContinuousDynamicTextHeight,
@@ -24,12 +24,12 @@ export class VexFlowInstantaniousDynamicExpression extends GraphicalInstantaniou
         this.PositionAndShape.calculateBoundingBox();
     }
 
-    get InstantaniousDynamic(): InstantaniousDynamicExpression {
-        return this.mInstantaniousDynamicExpression;
+    get InstantaneousDynamic(): InstantaneousDynamicExpression {
+        return this.mInstantaneousDynamicExpression;
     }
 
     get Expression(): string {
-        return DynamicEnum[this.mInstantaniousDynamicExpression.DynEnum];
+        return DynamicEnum[this.mInstantaneousDynamicExpression.DynEnum];
     }
 
     get Label(): GraphicalLabel {

src/MusicalScore/Graphical/VexFlow/VexFlowMeasure.ts

@@ -26,7 +26,7 @@ import {GraphicalVoiceEntry} from "../GraphicalVoiceEntry";
 import {VexFlowVoiceEntry} from "./VexFlowVoiceEntry";
 import {Fraction} from "../../../Common/DataObjects/Fraction";
 import { Voice } from "../../VoiceData/Voice";
-import { VexFlowInstantaniousDynamicExpression } from "./VexFlowInstantaniousDynamicExpression";
+import { VexFlowInstantaneousDynamicExpression } from "./VexFlowInstantaneousDynamicExpression";
 import { LinkedVoice } from "../../VoiceData/LinkedVoice";
 
 export class VexFlowMeasure extends GraphicalMeasure {
@@ -47,7 +47,7 @@ export class VexFlowMeasure extends GraphicalMeasure {
     /** The repetition instructions given as words or symbols (coda, dal segno..) */
     public vfRepetitionWords: Vex.Flow.Repetition[] = [];
     /** Instant dynamics */
-    public instantaniousDynamics: VexFlowInstantaniousDynamicExpression[] = [];
+    public instantaneousDynamics: VexFlowInstantaneousDynamicExpression[] = [];
     /** The VexFlow Stave (= one measure in a staffline) */
     private stave: Vex.Flow.Stave;
     /** VexFlow StaveConnectors (vertical lines) */
@@ -87,7 +87,7 @@ export class VexFlowMeasure extends GraphicalMeasure {
         this.connectors = [];
         // Clean up instructions
         this.resetLayout();
-        this.instantaniousDynamics = [];
+        this.instantaneousDynamics = [];
     }
 
     /**

src/MusicalScore/Graphical/VexFlow/VexFlowMusicSheetCalculator.ts

@@ -31,12 +31,12 @@ import {LyricsEntry} from "../../VoiceData/Lyrics/LyricsEntry";
 import {GraphicalLyricWord} from "../GraphicalLyricWord";
 import {VexFlowStaffEntry} from "./VexFlowStaffEntry";
 import { VexFlowOctaveShift } from "./VexFlowOctaveShift";
-import { VexFlowInstantaniousDynamicExpression } from "./VexFlowInstantaniousDynamicExpression";
+import { VexFlowInstantaneousDynamicExpression } from "./VexFlowInstantaneousDynamicExpression";
 import {BoundingBox} from "../BoundingBox";
 import { EngravingRules } from "../EngravingRules";
-import { InstantaniousDynamicExpression } from "../../VoiceData/Expressions/InstantaniousDynamicExpression";
+import { InstantaneousDynamicExpression } from "../../VoiceData/Expressions/InstantaneousDynamicExpression";
 import { PointF2D } from "../../../Common/DataObjects/PointF2D";
-import { GraphicalInstantaniousDynamicExpression } from "../GraphicalInstantaniousDynamicExpression";
+import { GraphicalInstantaneousDynamicExpression } from "../GraphicalInstantaneousDynamicExpression";
 import { SkyBottomLineCalculator } from "../SkyBottomLineCalculator";
 import { PlacementEnum } from "../../VoiceData/Expressions/AbstractExpression";
 import { Staff } from "../../VoiceData/Staff";
@@ -362,8 +362,8 @@ export class VexFlowMusicSheetCalculator extends MusicSheetCalculator {
     const measures: GraphicalMeasure[] = this.graphicalMusicSheet.MeasureList[measureIndex];
     const staffLine: StaffLine = measures[staffIndex].ParentStaffLine;
 
-    if (multiExpression.InstantaniousDynamic) {
-        const instantaniousDynamic: InstantaniousDynamicExpression = multiExpression.InstantaniousDynamic;
+    if (multiExpression.InstantaneousDynamic) {
+        const instantaneousDynamic: InstantaneousDynamicExpression = multiExpression.InstantaneousDynamic;
 
         const startPosInStaffline: PointF2D = this.getRelativePositionInStaffLineFromTimestamp(
           absoluteTimestamp,
@@ -374,35 +374,35 @@ export class VexFlowMusicSheetCalculator extends MusicSheetCalculator {
           startPosInStaffline.x = measures[staffIndex].beginInstructionsWidth + this.rules.RhythmRightMargin;
         }
         const measure: GraphicalMeasure = this.graphicalMusicSheet.MeasureList[measureIndex][staffIndex];
-        const graphicalInstantaniousDynamic: VexFlowInstantaniousDynamicExpression = new VexFlowInstantaniousDynamicExpression(
-          instantaniousDynamic,
+        const graphicalInstantaneousDynamic: VexFlowInstantaneousDynamicExpression = new VexFlowInstantaneousDynamicExpression(
+          instantaneousDynamic,
           staffLine,
           measure);
-        (measure as VexFlowMeasure).instantaniousDynamics.push(graphicalInstantaniousDynamic);
-        this.calculateSingleGraphicalInstantaniousDynamicExpression(graphicalInstantaniousDynamic, staffLine, startPosInStaffline);
+        (measure as VexFlowMeasure).instantaneousDynamics.push(graphicalInstantaneousDynamic);
+        this.calculateSingleGraphicalInstantaneousDynamicExpression(graphicalInstantaneousDynamic, staffLine, startPosInStaffline);
     }
   }
 
-  public calculateSingleGraphicalInstantaniousDynamicExpression(graphicalInstantaniousDynamic: VexFlowInstantaniousDynamicExpression,
+  public calculateSingleGraphicalInstantaneousDynamicExpression(graphicalInstantaneousDynamic: VexFlowInstantaneousDynamicExpression,
                                                                 staffLine: StaffLine,
                                                                 relative: PointF2D): void {
     // // add to StaffLine and set PSI relations
-    staffLine.AbstractExpressions.push(graphicalInstantaniousDynamic);
-    staffLine.PositionAndShape.ChildElements.push(graphicalInstantaniousDynamic.PositionAndShape);
+    staffLine.AbstractExpressions.push(graphicalInstantaneousDynamic);
+    staffLine.PositionAndShape.ChildElements.push(graphicalInstantaneousDynamic.PositionAndShape);
     if (this.staffLinesWithGraphicalExpressions.indexOf(staffLine) === -1) {
         this.staffLinesWithGraphicalExpressions.push(staffLine);
     }
 
     // get Margin Dimensions
-    const left: number = relative.x + graphicalInstantaniousDynamic.PositionAndShape.BorderLeft;
-    const right: number = relative.x + graphicalInstantaniousDynamic.PositionAndShape.BorderRight;
+    const left: number = relative.x + graphicalInstantaneousDynamic.PositionAndShape.BorderLeft;
+    const right: number = relative.x + graphicalInstantaneousDynamic.PositionAndShape.BorderRight;
     const skyBottomLineCalculator: SkyBottomLineCalculator = staffLine.SkyBottomLineCalculator;
 
     // get possible previous Dynamic
-    let previousExpression: GraphicalInstantaniousDynamicExpression = undefined;
-    const expressionIndex: number = staffLine.AbstractExpressions.indexOf(graphicalInstantaniousDynamic);
+    let previousExpression: GraphicalInstantaneousDynamicExpression = undefined;
+    const expressionIndex: number = staffLine.AbstractExpressions.indexOf(graphicalInstantaneousDynamic);
     if (expressionIndex > 0) {
-        previousExpression = (staffLine.AbstractExpressions[expressionIndex - 1] as GraphicalInstantaniousDynamicExpression);
+        previousExpression = (staffLine.AbstractExpressions[expressionIndex - 1] as GraphicalInstantaneousDynamicExpression);
     }
 
     // TODO: Not yet implemented
@@ -413,20 +413,20 @@ export class VexFlowMusicSheetCalculator extends MusicSheetCalculator {
     //         (GraphicalContinuousDynamicExpression)previousExpression;
 
     //     optimizeFormerContDynamicXPositionForInstDynamic(staffLine, skyBottomLineCalculator,
-    //                                                      graphicalInstantaniousDynamic,
+    //                                                      graphicalInstantaneousDynamic,
     //                                                      formerGraphicalContinuousDynamic, left, right);
     // }
-    // // is previous a instantaniousDynamic?
+    // // is previous a instantaneousDynamic?
     // else
-    if (previousExpression && previousExpression instanceof GraphicalInstantaniousDynamicExpression) {
-        //const formerGraphicalInstantaniousDynamic: GraphicalInstantaniousDynamicExpression = previousExpression;
+    if (previousExpression && previousExpression instanceof GraphicalInstantaneousDynamicExpression) {
+        //const formerGraphicalInstantaneousDynamic: GraphicalInstantaneousDynamicExpression = previousExpression;
 
-        // optimizeFormerInstDynamicXPositionForInstDynamic(formerGraphicalInstantaniousDynamic,
-        //                                                  graphicalInstantaniousDynamic, ref relative, ref left, ref right);
+        // optimizeFormerInstDynamicXPositionForInstDynamic(formerGraphicalInstantaneousDynamic,
+        //                                                  graphicalInstantaneousDynamic, ref relative, ref left, ref right);
     }// End x-positioning overlap check
 
     // calculate yPosition according to Placement
-    if (graphicalInstantaniousDynamic.InstantaniousDynamic.Placement === PlacementEnum.Above) {
+    if (graphicalInstantaneousDynamic.InstantaneousDynamic.Placement === PlacementEnum.Above) {
         const skyLineValue: number = skyBottomLineCalculator.getSkyLineMinInRange(left, right);
         let yPosition: number = 0;
 
@@ -440,15 +440,15 @@ export class VexFlowMusicSheetCalculator extends MusicSheetCalculator {
             if (skyLineValue > -difference / 2) {
                 yPosition = -difference / 2;
             } else {
-                yPosition = skyLineValue - graphicalInstantaniousDynamic.PositionAndShape.BorderBottom;
+                yPosition = skyLineValue - graphicalInstantaneousDynamic.PositionAndShape.BorderBottom;
             }
         } else {
-            yPosition = skyLineValue - graphicalInstantaniousDynamic.PositionAndShape.BorderBottom;
+            yPosition = skyLineValue - graphicalInstantaneousDynamic.PositionAndShape.BorderBottom;
         }
 
-        graphicalInstantaniousDynamic.PositionAndShape.RelativePosition = new PointF2D(relative.x, yPosition);
-        skyBottomLineCalculator.updateSkyLineInRange(left, right, yPosition + graphicalInstantaniousDynamic.PositionAndShape.BorderTop);
-    } else if (graphicalInstantaniousDynamic.InstantaniousDynamic.Placement === PlacementEnum.Below) {
+        graphicalInstantaneousDynamic.PositionAndShape.RelativePosition = new PointF2D(relative.x, yPosition);
+        skyBottomLineCalculator.updateSkyLineInRange(left, right, yPosition + graphicalInstantaneousDynamic.PositionAndShape.BorderTop);
+    } else if (graphicalInstantaneousDynamic.InstantaneousDynamic.Placement === PlacementEnum.Below) {
         const bottomLineValue: number = skyBottomLineCalculator.getBottomLineMaxInRange(left, right);
         let yPosition: number = 0;
 
@@ -458,20 +458,20 @@ export class VexFlowMusicSheetCalculator extends MusicSheetCalculator {
             const nextStaffLine: StaffLine = staffLine.ParentMusicSystem.StaffLines[staffLine.ParentMusicSystem.StaffLines.indexOf(staffLine) + 1];
             const difference: number = nextStaffLine.PositionAndShape.RelativePosition.y -
                                staffLine.PositionAndShape.RelativePosition.y - this.rules.StaffHeight;
-            const border: number = graphicalInstantaniousDynamic.PositionAndShape.BorderBottom;
+            const border: number = graphicalInstantaneousDynamic.PositionAndShape.BorderBottom;
 
             // take always into account the size of the Dynamic
             if (bottomLineValue + border < this.rules.StaffHeight + difference / 2) {
                 yPosition = this.rules.StaffHeight + difference / 2;
             } else {
-                yPosition = bottomLineValue - graphicalInstantaniousDynamic.PositionAndShape.BorderTop;
+                yPosition = bottomLineValue - graphicalInstantaneousDynamic.PositionAndShape.BorderTop;
             }
         } else {
-            yPosition = bottomLineValue - graphicalInstantaniousDynamic.PositionAndShape.BorderTop;
+            yPosition = bottomLineValue - graphicalInstantaneousDynamic.PositionAndShape.BorderTop;
         }
 
-        graphicalInstantaniousDynamic.PositionAndShape.RelativePosition = new PointF2D(relative.x, yPosition);
-        skyBottomLineCalculator.updateBottomLineInRange(left, right, yPosition + graphicalInstantaniousDynamic.PositionAndShape.BorderBottom);
+        graphicalInstantaneousDynamic.PositionAndShape.RelativePosition = new PointF2D(relative.x, yPosition);
+        skyBottomLineCalculator.updateBottomLineInRange(left, right, yPosition + graphicalInstantaneousDynamic.PositionAndShape.BorderBottom);
     }
 }
 

src/MusicalScore/Graphical/VexFlow/VexFlowMusicSheetDrawer.ts

@@ -11,7 +11,7 @@ import {GraphicalLayers} from "../DrawingEnums";
 import {GraphicalStaffEntry} from "../GraphicalStaffEntry";
 import {VexFlowBackend} from "./VexFlowBackend";
 import {VexFlowOctaveShift} from "./VexFlowOctaveShift";
-import {VexFlowInstantaniousDynamicExpression} from "./VexFlowInstantaniousDynamicExpression";
+import {VexFlowInstantaneousDynamicExpression} from "./VexFlowInstantaneousDynamicExpression";
 import {VexFlowInstrumentBracket} from "./VexFlowInstrumentBracket";
 import {VexFlowInstrumentBrace} from "./VexFlowInstrumentBrace";
 import {GraphicalLyricEntry} from "../GraphicalLyricEntry";
@@ -219,9 +219,9 @@ export class VexFlowMusicSheetDrawer extends MusicSheetDrawer {
         }
     }
 
-    protected drawInstantaniousDynamic(staffline: StaffLine): void {
+    protected drawInstantaneousDynamic(staffline: StaffLine): void {
         for (const m of staffline.Measures as VexFlowMeasure[]) {
-            for (const idx of m.instantaniousDynamics as VexFlowInstantaniousDynamicExpression[]) {
+            for (const idx of m.instantaneousDynamics as VexFlowInstantaneousDynamicExpression[]) {
                 this.drawLabel(idx.Label, <number>GraphicalLayers.Notes);
             }
         }

src/MusicalScore/MusicParts/MusicPartManagerIterator.ts

@@ -11,7 +11,7 @@ import {RhythmInstruction} from "../VoiceData/Instructions/RhythmInstruction";
 import {AbstractNotationInstruction} from "../VoiceData/Instructions/AbstractNotationInstruction";
 import {RepetitionInstruction} from "../VoiceData/Instructions/RepetitionInstruction";
 import {ContinuousDynamicExpression} from "../VoiceData/Expressions/ContinuousExpressions/ContinuousDynamicExpression";
-import {InstantaniousDynamicExpression} from "../VoiceData/Expressions/InstantaniousDynamicExpression";
+import {InstantaneousDynamicExpression} from "../VoiceData/Expressions/InstantaneousDynamicExpression";
 import {MultiTempoExpression} from "../VoiceData/Expressions/MultiTempoExpression";
 import {AbstractExpression} from "../VoiceData/Expressions/AbstractExpression";
 import * as log from "loglevel";
@@ -39,9 +39,9 @@ export class MusicPartManagerIterator {
                             <ContinuousDynamicExpression>this.activeDynamicExpressions[staffIndex];
                         this.currentDynamicChangingExpressions.push(new DynamicsContainer(continuousDynamic, staffIndex));
                     } else {
-                        const instantaniousDynamic: InstantaniousDynamicExpression =
-                            <InstantaniousDynamicExpression>this.activeDynamicExpressions[staffIndex];
-                        this.currentDynamicChangingExpressions.push(new DynamicsContainer(instantaniousDynamic, staffIndex));
+                        const instantaneousDynamic: InstantaneousDynamicExpression =
+                            <InstantaneousDynamicExpression>this.activeDynamicExpressions[staffIndex];
+                        this.currentDynamicChangingExpressions.push(new DynamicsContainer(instantaneousDynamic, staffIndex));
                     }
                 }
             }
@@ -446,9 +446,9 @@ export class MusicPartManagerIterator {
                         this.currentDynamicChangingExpressions.push(new DynamicsContainer(continuousDynamic, staffIndex));
                     }
                 } else {
-                    const instantaniousDynamic: InstantaniousDynamicExpression = <InstantaniousDynamicExpression>this.activeDynamicExpressions[staffIndex];
-                    if (this.CurrentSourceTimestamp.Equals(instantaniousDynamic.ParentMultiExpression.AbsoluteTimestamp)) {
-                        this.currentDynamicChangingExpressions.push(new DynamicsContainer(instantaniousDynamic, staffIndex));
+                    const instantaneousDynamic: InstantaneousDynamicExpression = <InstantaneousDynamicExpression>this.activeDynamicExpressions[staffIndex];
+                    if (this.CurrentSourceTimestamp.Equals(instantaneousDynamic.ParentMultiExpression.AbsoluteTimestamp)) {
+                        this.currentDynamicChangingExpressions.push(new DynamicsContainer(instantaneousDynamic, staffIndex));
                     }
                 }
             }

src/MusicalScore/MusicSheet.ts

@@ -408,8 +408,8 @@ export class MusicSheet /*implements ISettableMusicSheet, IComparable<MusicSheet
     //public GetExpressionsStartTempoInBPM(): number {
     //    if (this.TimestampSortedTempoExpressionsList.length > 0) {
     //        let me: MultiTempoExpression = this.TimestampSortedTempoExpressionsList[0];
-    //        if (me.InstantaniousTempo !== undefined) {
-    //            return me.InstantaniousTempo.TempoInBpm;
+    //        if (me.InstantaneousTempo !== undefined) {
+    //            return me.InstantaneousTempo.TempoInBpm;
     //        } else if (me.ContinuousTempo !== undefined) {
     //            return me.ContinuousTempo.StartTempo;
     //        }

src/MusicalScore/ScoreIO/MusicSymbolModules/ExpressionReader.ts

@@ -3,13 +3,13 @@ import {Fraction} from "../../../Common/DataObjects/Fraction";
 import {MultiTempoExpression} from "../../VoiceData/Expressions/MultiTempoExpression";
 import {ContDynamicEnum, ContinuousDynamicExpression} from "../../VoiceData/Expressions/ContinuousExpressions/ContinuousDynamicExpression";
 import {ContinuousTempoExpression} from "../../VoiceData/Expressions/ContinuousExpressions/ContinuousTempoExpression";
-import {DynamicEnum, InstantaniousDynamicExpression} from "../../VoiceData/Expressions/InstantaniousDynamicExpression";
+import {DynamicEnum, InstantaneousDynamicExpression} from "../../VoiceData/Expressions/InstantaneousDynamicExpression";
 import {OctaveShift} from "../../VoiceData/Expressions/ContinuousExpressions/OctaveShift";
 import {Instrument} from "../../Instrument";
 import {MultiExpression} from "../../VoiceData/Expressions/MultiExpression";
 import {IXmlAttribute, IXmlElement} from "../../../Common/FileIO/Xml";
 import {SourceMeasure} from "../../VoiceData/SourceMeasure";
-import {InstantaniousTempoExpression} from "../../VoiceData/Expressions/InstantaniousTempoExpression";
+import {InstantaneousTempoExpression} from "../../VoiceData/Expressions/InstantaneousTempoExpression";
 import {MoodExpression} from "../../VoiceData/Expressions/MoodExpression";
 import {UnknownExpression} from "../../VoiceData/Expressions/UnknownExpression";
 import {TextAlignment} from "../../../Common/Enums/TextAlignment";
@@ -34,7 +34,7 @@ export class ExpressionReader {
     private currentMultiTempoExpression: MultiTempoExpression;
     private openContinuousDynamicExpression: ContinuousDynamicExpression;
     private openContinuousTempoExpression: ContinuousTempoExpression;
-    private activeInstantaniousDynamic: InstantaniousDynamicExpression;
+    private activeInstantaneousDynamic: InstantaneousDynamicExpression;
     private openOctaveShift: OctaveShift;
     constructor(musicSheet: MusicSheet, instrument: Instrument, staffNumber: number) {
         this.musicSheet = musicSheet;
@@ -174,14 +174,14 @@ export class ExpressionReader {
                 }
                 const bpmNumber: number = parseInt(bpm.value, 10);
                 this.createNewTempoExpressionIfNeeded(currentMeasure);
-                const instantaniousTempoExpression: InstantaniousTempoExpression =
-                    new InstantaniousTempoExpression(text,
+                const instantaneousTempoExpression: InstantaneousTempoExpression =
+                    new InstantaneousTempoExpression(text,
                                                      this.placement,
                                                      this.staffNumber,
                                                      bpmNumber,
                                                      this.currentMultiTempoExpression,
                                                      true);
-                this.currentMultiTempoExpression.addExpression(instantaniousTempoExpression, "");
+                this.currentMultiTempoExpression.addExpression(instantaneousTempoExpression, "");
                 this.currentMultiTempoExpression.CombinedExpressionsText = text;
             }
             return;
@@ -190,7 +190,7 @@ export class ExpressionReader {
         dirContentNode = dirNode.element("dynamics");
         if (dirContentNode !== undefined) {
             const fromNotation: boolean = directionNode.element("notations") !== undefined;
-            this.interpretInstantaniousDynamics(dirContentNode, currentMeasure, inSourceMeasureCurrentFraction, fromNotation);
+            this.interpretInstantaneousDynamics(dirContentNode, currentMeasure, inSourceMeasureCurrentFraction, fromNotation);
             return;
         }
 
@@ -199,9 +199,9 @@ export class ExpressionReader {
             if (isTempoInstruction) {
                 this.createNewTempoExpressionIfNeeded(currentMeasure);
                 this.currentMultiTempoExpression.CombinedExpressionsText = dirContentNode.value;
-                const instantaniousTempoExpression: InstantaniousTempoExpression =
-                    new InstantaniousTempoExpression(dirContentNode.value, this.placement, this.staffNumber, this.soundTempo, this.currentMultiTempoExpression);
-                this.currentMultiTempoExpression.addExpression(instantaniousTempoExpression, "");
+                const instantaneousTempoExpression: InstantaneousTempoExpression =
+                    new InstantaneousTempoExpression(dirContentNode.value, this.placement, this.staffNumber, this.soundTempo, this.currentMultiTempoExpression);
+                this.currentMultiTempoExpression.addExpression(instantaneousTempoExpression, "");
             } else if (!isDynamicInstruction) {
                 this.interpretWords(dirContentNode, currentMeasure, inSourceMeasureCurrentFraction);
             }
@@ -296,7 +296,7 @@ export class ExpressionReader {
         }
 
     }
-    private interpretInstantaniousDynamics(dynamicsNode: IXmlElement,
+    private interpretInstantaneousDynamics(dynamicsNode: IXmlElement,
                                            currentMeasure: SourceMeasure,
                                            inSourceMeasureCurrentFraction: Fraction,
                                            fromNotation: boolean): void {
@@ -315,8 +315,8 @@ export class ExpressionReader {
                     return;
                 }
 
-                if (this.activeInstantaniousDynamic === undefined ||
-                    (this.activeInstantaniousDynamic !== undefined && this.activeInstantaniousDynamic.DynEnum !== dynamicEnum)) {
+                if (this.activeInstantaneousDynamic === undefined ||
+                    (this.activeInstantaneousDynamic !== undefined && this.activeInstantaneousDynamic.DynEnum !== dynamicEnum)) {
                     if (!fromNotation) {
                         this.createNewMultiExpressionIfNeeded(currentMeasure);
                     } else { this.createNewMultiExpressionIfNeeded(currentMeasure, Fraction.createFromFraction(inSourceMeasureCurrentFraction)); }
@@ -324,15 +324,15 @@ export class ExpressionReader {
                         this.openContinuousDynamicExpression.StartMultiExpression !== this.getMultiExpression) {
                         this.closeOpenContinuousDynamic();
                     }
-                    const instantaniousDynamicExpression: InstantaniousDynamicExpression = new InstantaniousDynamicExpression(name,
+                    const instantaneousDynamicExpression: InstantaneousDynamicExpression = new InstantaneousDynamicExpression(name,
                                                                                                                               this.soundDynamic,
                                                                                                                               this.placement,
                                                                                                                               this.staffNumber);
-                    this.getMultiExpression.addExpression(instantaniousDynamicExpression, "");
+                    this.getMultiExpression.addExpression(instantaneousDynamicExpression, "");
                     this.initialize();
-                    if (this.activeInstantaniousDynamic !== undefined) {
-                        this.activeInstantaniousDynamic.DynEnum = instantaniousDynamicExpression.DynEnum;
-                    } else { this.activeInstantaniousDynamic = new InstantaniousDynamicExpression(name, 0, PlacementEnum.NotYetDefined, 1); }
+                    if (this.activeInstantaneousDynamic !== undefined) {
+                        this.activeInstantaneousDynamic.DynEnum = instantaneousDynamicExpression.DynEnum;
+                    } else { this.activeInstantaneousDynamic = new InstantaneousDynamicExpression(name, 0, PlacementEnum.NotYetDefined, 1); }
                 }
             }
         }
@@ -392,9 +392,9 @@ export class ExpressionReader {
                     this.openContinuousDynamicExpression = continuousDynamicExpression;
                     this.getMultiExpression.StartingContinuousDynamic = continuousDynamicExpression;
                     continuousDynamicExpression.StartMultiExpression = this.getMultiExpression;
-                    if (this.activeInstantaniousDynamic !== undefined &&
-                        this.activeInstantaniousDynamic.StaffNumber === continuousDynamicExpression.StaffNumber) {
-                        this.activeInstantaniousDynamic = undefined;
+                    if (this.activeInstantaneousDynamic !== undefined &&
+                        this.activeInstantaneousDynamic.StaffNumber === continuousDynamicExpression.StaffNumber) {
+                        this.activeInstantaneousDynamic = undefined;
                     }
                 } else if (type === "stop") {
                     if (this.openContinuousDynamicExpression !== undefined) {
@@ -450,28 +450,28 @@ export class ExpressionReader {
     */
     private createExpressionFromString(prefix: string, stringTrimmed: string,
                                        currentMeasure: SourceMeasure, inputString: string): boolean {
-        if (InstantaniousTempoExpression.isInputStringInstantaniousTempo(stringTrimmed) ||
+        if (InstantaneousTempoExpression.isInputStringInstantaneousTempo(stringTrimmed) ||
             ContinuousTempoExpression.isInputStringContinuousTempo(stringTrimmed)) {
             // first check if there is already a tempo expression with the same function
             if (currentMeasure.TempoExpressions.length > 0) {
                 for (let idx: number = 0, len: number = currentMeasure.TempoExpressions.length; idx < len; ++idx) {
                     const multiTempoExpression: MultiTempoExpression = currentMeasure.TempoExpressions[idx];
                     if (multiTempoExpression.Timestamp === this.directionTimestamp &&
-                        multiTempoExpression.InstantaniousTempo !== undefined &&
-                        multiTempoExpression.InstantaniousTempo.Label.indexOf(stringTrimmed) !== -1) {
+                        multiTempoExpression.InstantaneousTempo !== undefined &&
+                        multiTempoExpression.InstantaneousTempo.Label.indexOf(stringTrimmed) !== -1) {
                         return false;
                     }
                 }
             }
             this.createNewTempoExpressionIfNeeded(currentMeasure);
             this.currentMultiTempoExpression.CombinedExpressionsText = inputString;
-            if (InstantaniousTempoExpression.isInputStringInstantaniousTempo(stringTrimmed)) {
-                const instantaniousTempoExpression: InstantaniousTempoExpression = new InstantaniousTempoExpression(  stringTrimmed,
+            if (InstantaneousTempoExpression.isInputStringInstantaneousTempo(stringTrimmed)) {
+                const instantaneousTempoExpression: InstantaneousTempoExpression = new InstantaneousTempoExpression(  stringTrimmed,
                                                                                                                       this.placement,
                                                                                                                       this.staffNumber,
                                                                                                                       this.soundTempo,
                                                                                                                       this.currentMultiTempoExpression);
-                this.currentMultiTempoExpression.addExpression(instantaniousTempoExpression, prefix);
+                this.currentMultiTempoExpression.addExpression(instantaneousTempoExpression, prefix);
                 return true;
             }
             if (ContinuousTempoExpression.isInputStringContinuousTempo(stringTrimmed)) {
@@ -483,18 +483,18 @@ export class ExpressionReader {
                 return true;
             }
         }
-        if (InstantaniousDynamicExpression.isInputStringInstantaniousDynamic(stringTrimmed) ||
+        if (InstantaneousDynamicExpression.isInputStringInstantaneousDynamic(stringTrimmed) ||
             ContinuousDynamicExpression.isInputStringContinuousDynamic(stringTrimmed)) {
             this.createNewMultiExpressionIfNeeded(currentMeasure);
-            if (InstantaniousDynamicExpression.isInputStringInstantaniousDynamic(stringTrimmed)) {
+            if (InstantaneousDynamicExpression.isInputStringInstantaneousDynamic(stringTrimmed)) {
                 if (this.openContinuousDynamicExpression !== undefined && this.openContinuousDynamicExpression.EndMultiExpression === undefined) {
                     this.closeOpenContinuousDynamic();
                 }
-                const instantaniousDynamicExpression: InstantaniousDynamicExpression = new InstantaniousDynamicExpression(stringTrimmed,
+                const instantaneousDynamicExpression: InstantaneousDynamicExpression = new InstantaneousDynamicExpression(stringTrimmed,
                                                                                                                           this.soundDynamic,
                                                                                                                           this.placement,
                                                                                                                           this.staffNumber);
-                this.getMultiExpression.addExpression(instantaniousDynamicExpression, prefix);
+                this.getMultiExpression.addExpression(instantaneousDynamicExpression, prefix);
                 return true;
             }
             if (ContinuousDynamicExpression.isInputStringContinuousDynamic(stringTrimmed)) {
@@ -505,8 +505,8 @@ export class ExpressionReader {
                 if (this.openContinuousDynamicExpression !== undefined && this.openContinuousDynamicExpression.EndMultiExpression === undefined) {
                     this.closeOpenContinuousDynamic();
                 }
-                if (this.activeInstantaniousDynamic !== undefined && this.activeInstantaniousDynamic.StaffNumber === continuousDynamicExpression.StaffNumber) {
-                    this.activeInstantaniousDynamic = undefined;
+                if (this.activeInstantaneousDynamic !== undefined && this.activeInstantaneousDynamic.StaffNumber === continuousDynamicExpression.StaffNumber) {
+                    this.activeInstantaneousDynamic = undefined;
                 }
                 this.openContinuousDynamicExpression = continuousDynamicExpression;
                 continuousDynamicExpression.StartMultiExpression = this.getMultiExpression;
@@ -527,7 +527,7 @@ export class ExpressionReader {
             for (let idx: number = 0, len: number = currentMeasure.TempoExpressions.length; idx < len; ++idx) {
                 const multiTempoExpression: MultiTempoExpression = currentMeasure.TempoExpressions[idx];
                 if (multiTempoExpression.Timestamp === this.directionTimestamp &&
-                    multiTempoExpression.InstantaniousTempo !== undefined &&
+                    multiTempoExpression.InstantaneousTempo !== undefined &&
                     multiTempoExpression.EntriesList.length > 0 &&
                     !this.hasDigit(stringTrimmed)) {
                     if (this.globalStaffIndex > 0) {

src/MusicalScore/VoiceData/Expressions/InstantaniousDynamicExpression.ts → src/MusicalScore/VoiceData/Expressions/InstantaneousDynamicExpression.ts

@@ -5,7 +5,7 @@ import {DynamicExpressionSymbolEnum} from "./DynamicExpressionSymbolEnum";
 import {InvalidEnumArgumentException} from "../../Exceptions";
 import * as log from "loglevel";
 
-export class InstantaniousDynamicExpression extends AbstractExpression {
+export class InstantaneousDynamicExpression extends AbstractExpression {
     constructor(dynamicExpression: string, soundDynamics: number, placement: PlacementEnum, staffNumber: number) {
         super();
         this.dynamicEnum = DynamicEnum[dynamicExpression.toLowerCase()];
@@ -40,7 +40,7 @@ export class InstantaniousDynamicExpression extends AbstractExpression {
     };
 
     //private static weight: number;
-    private static listInstantaniousDynamics: string[] =  [
+    private static listInstantaneousDynamics: string[] =  [
         "pppppp", "ppppp", "pppp", "ppp", "pp", "p",
         "ffffff", "fffff", "ffff", "fff", "ff", "f",
         "mf", "mp", "sf", "sp", "spp", "fp", "rf", "rfz", "sfz", "sffz", "fz",
@@ -90,14 +90,14 @@ export class InstantaniousDynamicExpression extends AbstractExpression {
         return this.length;
     }
     public get MidiVolume(): number {
-        return InstantaniousDynamicExpression.dynamicToRelativeVolumeDict[this.dynamicEnum] * 127;
+        return InstantaneousDynamicExpression.dynamicToRelativeVolumeDict[this.dynamicEnum] * 127;
     }
-    public static isInputStringInstantaniousDynamic(inputString: string): boolean {
+    public static isInputStringInstantaneousDynamic(inputString: string): boolean {
         if (inputString === undefined) { return false; }
-        return InstantaniousDynamicExpression.isStringInStringList(InstantaniousDynamicExpression.listInstantaniousDynamics, inputString);
+        return InstantaneousDynamicExpression.isStringInStringList(InstantaneousDynamicExpression.listInstantaneousDynamics, inputString);
     }
 
-    //public getInstantaniousDynamicSymbol(expressionSymbolEnum:DynamicExpressionSymbolEnum): FontInfo.MusicFontSymbol {
+    //public getInstantaneousDynamicSymbol(expressionSymbolEnum:DynamicExpressionSymbolEnum): FontInfo.MusicFontSymbol {
     //    switch (expressionSymbolEnum) {
     //        case DynamicExpressionSymbolEnum.p:
     //            return FontInfo.MusicFontSymbol.P;
@@ -139,11 +139,11 @@ export class InstantaniousDynamicExpression extends AbstractExpression {
         //for (let idx: number = 0, len: number = dynamic.length; idx < len; ++idx) {
         //    let c: string = dynamic[idx];
         //    let dynamicExpressionSymbol: DynamicExpressionSymbolEnum = this.getDynamicExpressionSymbol(c);
-        //    let symbol: FontInfo.MusicFontSymbol = this.getInstantaniousDynamicSymbol(dynamicExpressionSymbol);
+        //    let symbol: FontInfo.MusicFontSymbol = this.getInstantaneousDynamicSymbol(dynamicExpressionSymbol);
         //    length += FontInfo.Info.getBoundingBox(symbol).Width;
         //}
         //return length;
-        log.debug("[Andrea] instantaniousDynamicExpression: not implemented: calculateLength!");
+        log.debug("[Andrea] instantaneousDynamicExpression: not implemented: calculateLength!");
         return 0.0;
     }
 

src/MusicalScore/VoiceData/Expressions/InstantaniousTempoExpression.ts → src/MusicalScore/VoiceData/Expressions/InstantaneousTempoExpression.ts

@@ -4,39 +4,39 @@ import {ArgumentOutOfRangeException} from "../../Exceptions";
 import {Fraction} from "../../../Common/DataObjects/Fraction";
 import {MultiTempoExpression} from "./MultiTempoExpression";
 
-export class InstantaniousTempoExpression extends AbstractTempoExpression {
+export class InstantaneousTempoExpression extends AbstractTempoExpression {
     constructor(label: string, placement: PlacementEnum, staffNumber: number,
                 soundTempo: number, parentMultiTempoExpression: MultiTempoExpression, isMetronomeMark: boolean = false) {
         super(label, placement, staffNumber, parentMultiTempoExpression);
         this.setTempoAndTempoType(soundTempo);
     }
-    private static listInstantaniousTempoLarghissimo: string[] = ["Larghissimo", "Sehr breit", "very, very slow"]; // }), TempoEnum.larghissimo);
-    private static listInstantaniousTempoGrave: string[] = ["Grave", "Schwer", "slow and solemn"]; //  }), TempoEnum.grave);
-    private static listInstantaniousTempoLento: string[] = ["Lento", "Lent", "Langsam", "slowly"]; //  }), TempoEnum.lento);
-    private static listInstantaniousTempoLargo: string[] = ["Largo", "Breit", "broadly"]; //  }), TempoEnum.largo);
-    private static listInstantaniousTempoLarghetto: string[] = ["Larghetto", "Etwas breit", "rather broadly"]; //  }), TempoEnum.larghetto);
-    private static listInstantaniousTempoAdagio: string[] = ["Adagio", "Langsam", "Ruhig", "slow and stately"]; // }), TempoEnum.adagio);
-    private static listInstantaniousTempoAdagietto: string[] = ["Adagietto", "Ziemlich ruhig", "Ziemlich langsam", "rather slow"]; //  }), TempoEnum.adagietto);
-    private static listInstantaniousTempoAndanteModerato: string[] = ["Andante moderato"]; //  }), TempoEnum.andanteModerato);
-    private static listInstantaniousTempoAndante: string[] = ["Andante", "Gehend", "Schreitend", "at a walking pace"]; //  }), TempoEnum.andante);
-    private static listInstantaniousTempoAndantino: string[] = ["Andantino"]; //  }), TempoEnum.andantino);
-    private static listInstantaniousTempoModerato: string[] = ["Moderato", "M��ig", "Mod�r�", "moderately"]; //  }), TempoEnum.moderato);
-    private static listInstantaniousTempoAllegretto: string[] = ["Allegretto", "fast"]; //  }), TempoEnum.allegretto);
-    private static listInstantaniousTempoAllegroModerato: string[] = ["Allegro moderato"]; //  }), TempoEnum.allegroModerato);
-    private static listInstantaniousTempoAllegro: string[] = ["Allegro", "Rapide", "Vite", "Rasch", "Schnell", "Fr�hlich"]; //  }), TempoEnum.allegro);
-    private static listInstantaniousTempoVivace: string[] = ["Vivace", "Lebhaft", "Lebendig", "lively and fast"]; //  }), TempoEnum.vivace);
-    private static listInstantaniousTempoVivacissimo: string[] = ["Vivacissimo", "Sehr lebhaft", "Sehr lebendig"]; //  }), TempoEnum.vivacissimo);
-    private static listInstantaniousTempoAllegrissimo: string[] = ["Allegrissimo", "very fast"]; //  }), TempoEnum.allegrissimo);
-    private static listInstantaniousTempoPresto: string[] = ["Presto", "Sehr schnell", "Geschwind"]; //  }), TempoEnum.presto);
-    private static listInstantaniousTempoPrestissimo: string[] = ["Prestissimo", "�u�erst schnell"]; //  }), TempoEnum.prestissimo);
-    private static listInstantaniousTempoChangesGeneral: string[] = [
+    private static listInstantaneousTempoLarghissimo: string[] = ["Larghissimo", "Sehr breit", "very, very slow"]; // }), TempoEnum.larghissimo);
+    private static listInstantaneousTempoGrave: string[] = ["Grave", "Schwer", "slow and solemn"]; //  }), TempoEnum.grave);
+    private static listInstantaneousTempoLento: string[] = ["Lento", "Lent", "Langsam", "slowly"]; //  }), TempoEnum.lento);
+    private static listInstantaneousTempoLargo: string[] = ["Largo", "Breit", "broadly"]; //  }), TempoEnum.largo);
+    private static listInstantaneousTempoLarghetto: string[] = ["Larghetto", "Etwas breit", "rather broadly"]; //  }), TempoEnum.larghetto);
+    private static listInstantaneousTempoAdagio: string[] = ["Adagio", "Langsam", "Ruhig", "slow and stately"]; // }), TempoEnum.adagio);
+    private static listInstantaneousTempoAdagietto: string[] = ["Adagietto", "Ziemlich ruhig", "Ziemlich langsam", "rather slow"]; //  }), TempoEnum.adagietto);
+    private static listInstantaneousTempoAndanteModerato: string[] = ["Andante moderato"]; //  }), TempoEnum.andanteModerato);
+    private static listInstantaneousTempoAndante: string[] = ["Andante", "Gehend", "Schreitend", "at a walking pace"]; //  }), TempoEnum.andante);
+    private static listInstantaneousTempoAndantino: string[] = ["Andantino"]; //  }), TempoEnum.andantino);
+    private static listInstantaneousTempoModerato: string[] = ["Moderato", "M��ig", "Mod�r�", "moderately"]; //  }), TempoEnum.moderato);
+    private static listInstantaneousTempoAllegretto: string[] = ["Allegretto", "fast"]; //  }), TempoEnum.allegretto);
+    private static listInstantaneousTempoAllegroModerato: string[] = ["Allegro moderato"]; //  }), TempoEnum.allegroModerato);
+    private static listInstantaneousTempoAllegro: string[] = ["Allegro", "Rapide", "Vite", "Rasch", "Schnell", "Fr�hlich"]; //  }), TempoEnum.allegro);
+    private static listInstantaneousTempoVivace: string[] = ["Vivace", "Lebhaft", "Lebendig", "lively and fast"]; //  }), TempoEnum.vivace);
+    private static listInstantaneousTempoVivacissimo: string[] = ["Vivacissimo", "Sehr lebhaft", "Sehr lebendig"]; //  }), TempoEnum.vivacissimo);
+    private static listInstantaneousTempoAllegrissimo: string[] = ["Allegrissimo", "very fast"]; //  }), TempoEnum.allegrissimo);
+    private static listInstantaneousTempoPresto: string[] = ["Presto", "Sehr schnell", "Geschwind"]; //  }), TempoEnum.presto);
+    private static listInstantaneousTempoPrestissimo: string[] = ["Prestissimo", "�u�erst schnell"]; //  }), TempoEnum.prestissimo);
+    private static listInstantaneousTempoChangesGeneral: string[] = [
         "tempo primo",
         "a tempo",
         "tempo i",
         "rubato",
         "doppio movimento",
     ];
-    private static listInstantaniousTempoAddons: string[] = [
+    private static listInstantaneousTempoAddons: string[] = [
         "assai",
         "amoroso",
         "cantabile",
@@ -127,11 +127,11 @@ export class InstantaniousTempoExpression extends AbstractTempoExpression {
     // Must refactor: In c# use 'out' arguments
     //private findTempoEnum(inputString: string, pre: string, post: string): TempoEnum {
     //    let result: TempoEnum = this.splitStringAfterInstructionWord(inputString,
-    // InstantaniousTempoExpression.listInstantaniousTempoLarghissimo, TempoEnum.larghissimo, pre,
+    // InstantaneousTempoExpression.listInstantaneousTempoLarghissimo, TempoEnum.larghissimo, pre,
     //        post);
     //    if (result !== TempoEnum.none)
     //        return result;
-    //    result = this.splitStringAfterInstructionWord(inputString, InstantaniousTempoExpression.listInstantaniousTempoGrave, TempoEnum.grave, pre,
+    //    result = this.splitStringAfterInstructionWord(inputString, InstantaneousTempoExpression.listInstantaneousTempoGrave, TempoEnum.grave, pre,
     //        post);
     //    if (result !== TempoEnum.none)
     //        return result;
@@ -198,29 +198,29 @@ export class InstantaniousTempoExpression extends AbstractTempoExpression {
                 throw new ArgumentOutOfRangeException("tempoEnum");
         }
     }
-    public static isInputStringInstantaniousTempo(inputString: string): boolean {
+    public static isInputStringInstantaneousTempo(inputString: string): boolean {
         if (inputString === undefined) { return false; }
         return (
-            (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoLarghissimo, inputString))
-            || (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoGrave, inputString))
-            || (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoLento, inputString))
-            || (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoLargo, inputString))
-            || (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoLarghetto, inputString))
-            || (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAdagio, inputString))
-            || (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAdagietto, inputString))
-            || (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAndanteModerato, inputString))
-            || (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAndante, inputString))
-            || (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAndantino, inputString))
-            || (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoModerato, inputString))
-            || (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAllegretto, inputString))
-            || (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAllegroModerato, inputString))
-            || (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAllegro, inputString))
-            || (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoVivace, inputString))
-            || (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoVivacissimo, inputString))
-            || (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAllegrissimo, inputString))
-            || (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoPresto, inputString))
-            || (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoPrestissimo, inputString))
-            || (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoChangesGeneral, inputString))
+            (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoLarghissimo, inputString))
+            || (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoGrave, inputString))
+            || (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoLento, inputString))
+            || (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoLargo, inputString))
+            || (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoLarghetto, inputString))
+            || (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoAdagio, inputString))
+            || (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoAdagietto, inputString))
+            || (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoAndanteModerato, inputString))
+            || (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoAndante, inputString))
+            || (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoAndantino, inputString))
+            || (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoModerato, inputString))
+            || (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoAllegretto, inputString))
+            || (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoAllegroModerato, inputString))
+            || (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoAllegro, inputString))
+            || (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoVivace, inputString))
+            || (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoVivacissimo, inputString))
+            || (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoAllegrissimo, inputString))
+            || (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoPresto, inputString))
+            || (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoPrestissimo, inputString))
+            || (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoChangesGeneral, inputString))
         );
     }
 
@@ -261,164 +261,164 @@ export class InstantaniousTempoExpression extends AbstractTempoExpression {
         return Fraction.plus(this.ParentMultiTempoExpression.SourceMeasureParent.AbsoluteTimestamp, this.ParentMultiTempoExpression.Timestamp).RealValue;
     }
     private setTempoAndTempoType(soundTempo: number): void {
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoLarghissimo, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoLarghissimo, this.label)) {
             if (soundTempo === 0) {
-                soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.larghissimo);
+                soundTempo = InstantaneousTempoExpression.getDefaultValueForTempoType(TempoEnum.larghissimo);
             }
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.larghissimo;
             return;
         }
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoGrave, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoGrave, this.label)) {
             if (soundTempo === 0) {
-                soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.grave);
+                soundTempo = InstantaneousTempoExpression.getDefaultValueForTempoType(TempoEnum.grave);
             }
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.grave;
             return;
         }
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoLento, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoLento, this.label)) {
             if (soundTempo === 0) {
-                soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.lento);
+                soundTempo = InstantaneousTempoExpression.getDefaultValueForTempoType(TempoEnum.lento);
             }
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.lento;
             return;
         }
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoLargo, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoLargo, this.label)) {
             if (soundTempo === 0) {
-                soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.largo);
+                soundTempo = InstantaneousTempoExpression.getDefaultValueForTempoType(TempoEnum.largo);
             }
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.largo;
             return;
         }
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoLarghetto, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoLarghetto, this.label)) {
             if (soundTempo === 0) {
-                soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.larghetto);
+                soundTempo = InstantaneousTempoExpression.getDefaultValueForTempoType(TempoEnum.larghetto);
             }
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.larghetto;
             return;
         }
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAdagio, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoAdagio, this.label)) {
             if (soundTempo === 0) {
-                soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.adagio);
+                soundTempo = InstantaneousTempoExpression.getDefaultValueForTempoType(TempoEnum.adagio);
             }
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.adagio;
             return;
         }
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAdagietto, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoAdagietto, this.label)) {
             if (soundTempo === 0) {
-                soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.adagietto);
+                soundTempo = InstantaneousTempoExpression.getDefaultValueForTempoType(TempoEnum.adagietto);
             }
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.adagietto;
             return;
         }
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAndanteModerato, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoAndanteModerato, this.label)) {
             if (soundTempo === 0) {
-                soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.andanteModerato);
+                soundTempo = InstantaneousTempoExpression.getDefaultValueForTempoType(TempoEnum.andanteModerato);
             }
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.andanteModerato;
             return;
         }
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAndante, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoAndante, this.label)) {
             if (soundTempo === 0) {
-                soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.andante);
+                soundTempo = InstantaneousTempoExpression.getDefaultValueForTempoType(TempoEnum.andante);
             }
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.andante;
             return;
         }
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAndantino, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoAndantino, this.label)) {
             if (soundTempo === 0) {
-                soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.andantino);
+                soundTempo = InstantaneousTempoExpression.getDefaultValueForTempoType(TempoEnum.andantino);
             }
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.andantino;
             return;
         }
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoModerato, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoModerato, this.label)) {
             if (soundTempo === 0) {
-                soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.moderato);
+                soundTempo = InstantaneousTempoExpression.getDefaultValueForTempoType(TempoEnum.moderato);
             }
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.moderato;
             return;
         }
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAllegretto, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoAllegretto, this.label)) {
             if (soundTempo === 0) {
-                soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.allegretto);
+                soundTempo = InstantaneousTempoExpression.getDefaultValueForTempoType(TempoEnum.allegretto);
             }
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.allegretto;
             return;
         }
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAllegroModerato, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoAllegroModerato, this.label)) {
             if (soundTempo === 0) {
-                soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.allegroModerato);
+                soundTempo = InstantaneousTempoExpression.getDefaultValueForTempoType(TempoEnum.allegroModerato);
             }
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.allegroModerato;
             return;
         }
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAllegro, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoAllegro, this.label)) {
             if (soundTempo === 0) {
-                soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.allegro);
+                soundTempo = InstantaneousTempoExpression.getDefaultValueForTempoType(TempoEnum.allegro);
             }
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.allegro;
             return;
         }
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoVivace, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoVivace, this.label)) {
             if (soundTempo === 0) {
-                soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.vivace);
+                soundTempo = InstantaneousTempoExpression.getDefaultValueForTempoType(TempoEnum.vivace);
             }
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.vivace;
             return;
         }
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoVivacissimo, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoVivacissimo, this.label)) {
             if (soundTempo === 0) {
-                soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.vivacissimo);
+                soundTempo = InstantaneousTempoExpression.getDefaultValueForTempoType(TempoEnum.vivacissimo);
             }
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.vivacissimo;
             return;
         }
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAllegrissimo, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoAllegrissimo, this.label)) {
             if (soundTempo === 0) {
-                soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.allegrissimo);
+                soundTempo = InstantaneousTempoExpression.getDefaultValueForTempoType(TempoEnum.allegrissimo);
             }
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.allegrissimo;
             return;
         }
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoPresto, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoPresto, this.label)) {
             if (soundTempo === 0) {
-                soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.presto);
+                soundTempo = InstantaneousTempoExpression.getDefaultValueForTempoType(TempoEnum.presto);
             }
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.presto;
             return;
         }
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoPrestissimo, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoPrestissimo, this.label)) {
             if (soundTempo === 0) {
-                soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.prestissimo);
+                soundTempo = InstantaneousTempoExpression.getDefaultValueForTempoType(TempoEnum.prestissimo);
             }
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.prestissimo;
             return;
         }
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAddons, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoAddons, this.label)) {
             this.tempoInBpm = 0;
             this.tempoEnum = TempoEnum.addon;
             return;
         }
-        if (InstantaniousTempoExpression.isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoChangesGeneral, this.label)) {
+        if (InstantaneousTempoExpression.isStringInStringList(InstantaneousTempoExpression.listInstantaneousTempoChangesGeneral, this.label)) {
             this.tempoInBpm = 0;
             this.tempoEnum = TempoEnum.changes;
             return;

src/MusicalScore/VoiceData/Expressions/MultiExpression.ts

@@ -1,6 +1,6 @@
 import {SourceMeasure} from "../SourceMeasure";
 import {Fraction} from "../../../Common/DataObjects/Fraction";
-import {InstantaniousDynamicExpression} from "./InstantaniousDynamicExpression";
+import {InstantaneousDynamicExpression} from "./InstantaneousDynamicExpression";
 import {ContinuousDynamicExpression} from "./ContinuousExpressions/ContinuousDynamicExpression";
 import {OctaveShift} from "./ContinuousExpressions/OctaveShift";
 import {MoodExpression} from "./MoodExpression";
@@ -18,7 +18,7 @@ export class MultiExpression /*implements IComparable<MultiExpression>*/ {
     private sourceMeasure: SourceMeasure;
     private staffNumber: number;
     private timestamp: Fraction;
-    private instantaniousDynamic: InstantaniousDynamicExpression;
+    private instantaneousDynamic: InstantaneousDynamicExpression;
     private endingContinuousDynamic: ContinuousDynamicExpression;
     private startingContinuousDynamic: ContinuousDynamicExpression;
     private unknownList: UnknownExpression[] = [];
@@ -49,11 +49,11 @@ export class MultiExpression /*implements IComparable<MultiExpression>*/ {
     public get AbsoluteTimestamp(): Fraction {
         return Fraction.plus(this.timestamp, this.sourceMeasure.AbsoluteTimestamp);
     }
-    public get InstantaniousDynamic(): InstantaniousDynamicExpression {
-        return this.instantaniousDynamic;
+    public get InstantaneousDynamic(): InstantaneousDynamicExpression {
+        return this.instantaneousDynamic;
     }
-    public set InstantaniousDynamic(value: InstantaniousDynamicExpression) {
-        this.instantaniousDynamic = value;
+    public set InstantaneousDynamic(value: InstantaneousDynamicExpression) {
+        this.instantaneousDynamic = value;
     }
     public get EndingContinuousDynamic(): ContinuousDynamicExpression {
         return this.endingContinuousDynamic;
@@ -97,8 +97,8 @@ export class MultiExpression /*implements IComparable<MultiExpression>*/ {
     public getPlacementOfFirstEntry(): PlacementEnum {
         let placement: PlacementEnum = PlacementEnum.Above;
         if (this.expressions.length > 0) {
-            if (this.expressions[0].expression instanceof InstantaniousDynamicExpression) {
-                placement = (<InstantaniousDynamicExpression>(this.expressions[0].expression)).Placement;
+            if (this.expressions[0].expression instanceof InstantaneousDynamicExpression) {
+                placement = (<InstantaneousDynamicExpression>(this.expressions[0].expression)).Placement;
             } else if (this.expressions[0].expression instanceof ContinuousDynamicExpression) {
                 placement = (<ContinuousDynamicExpression>(this.expressions[0].expression)).Placement;
             } else if (this.expressions[0].expression instanceof MoodExpression) {
@@ -124,7 +124,7 @@ export class MultiExpression /*implements IComparable<MultiExpression>*/ {
     //}
     //public getFirstEntry(staffLine: StaffLine, graphLabel: GraphicalLabel): AbstractGraphicalExpression {
     //    let indexOfFirstNotInstDynExpr: number = 0;
-    //    if (this.expressions[0].expression instanceof InstantaniousDynamicExpression)
+    //    if (this.expressions[0].expression instanceof InstantaneousDynamicExpression)
     //        indexOfFirstNotInstDynExpr = 1;
     //    if (this.expressions.length > 0) {
     //        if (this.expressions[indexOfFirstNotInstDynExpr].expression instanceof ContinuousDynamicExpression)
@@ -139,12 +139,12 @@ export class MultiExpression /*implements IComparable<MultiExpression>*/ {
     //    else return undefined;
     //}
     public addExpression(abstractExpression: AbstractExpression, prefix: string): void {
-        if (abstractExpression instanceof InstantaniousDynamicExpression) {
-            if (this.instantaniousDynamic !== undefined) {
-                this.removeExpressionFromEntryList(this.InstantaniousDynamic);
+        if (abstractExpression instanceof InstantaneousDynamicExpression) {
+            if (this.instantaneousDynamic !== undefined) {
+                this.removeExpressionFromEntryList(this.InstantaneousDynamic);
             }
-            this.instantaniousDynamic = <InstantaniousDynamicExpression>abstractExpression;
-            this.instantaniousDynamic.ParentMultiExpression = this;
+            this.instantaneousDynamic = <InstantaneousDynamicExpression>abstractExpression;
+            this.instantaneousDynamic.ParentMultiExpression = this;
         } else if (abstractExpression instanceof ContinuousDynamicExpression) {
             this.startingContinuousDynamic = <ContinuousDynamicExpression>abstractExpression;
         } else if (abstractExpression instanceof MoodExpression) {

src/MusicalScore/VoiceData/Expressions/MultiTempoExpression.ts

@@ -1,6 +1,6 @@
 import {Fraction} from "../../../Common/DataObjects/Fraction";
 import {SourceMeasure} from "../SourceMeasure";
-import {InstantaniousTempoExpression} from "./InstantaniousTempoExpression";
+import {InstantaneousTempoExpression} from "./InstantaneousTempoExpression";
 import {PlacementEnum} from "./AbstractExpression";
 import {FontStyles} from "../../../Common/Enums/FontStyles";
 import {AbstractTempoExpression} from "./AbstractTempoExpression";
@@ -15,7 +15,7 @@ export class MultiTempoExpression /*implements IComparable<MultiTempoExpression>
 
     private timestamp: Fraction;
     private sourceMeasure: SourceMeasure;
-    private instantaneousTempo: InstantaniousTempoExpression;
+    private instantaneousTempo: InstantaneousTempoExpression;
     private continuousTempo: ContinuousTempoExpression;
     private expressions: TempoExpressionEntry[] = [];
     private combinedExpressionsText: string;
@@ -32,7 +32,7 @@ export class MultiTempoExpression /*implements IComparable<MultiTempoExpression>
     public set SourceMeasureParent(value: SourceMeasure) {
         this.sourceMeasure = value;
     }
-    public get InstantaniousTempo(): InstantaniousTempoExpression {
+    public get InstantaneousTempo(): InstantaneousTempoExpression {
         return this.instantaneousTempo;
     }
     public get ContinuousTempo(): ContinuousTempoExpression {
@@ -50,8 +50,8 @@ export class MultiTempoExpression /*implements IComparable<MultiTempoExpression>
     public getPlacementOfFirstEntry(): PlacementEnum {
         let placement: PlacementEnum = PlacementEnum.Above;
         if (this.expressions.length > 0) {
-            if (this.expressions[0].expression instanceof InstantaniousTempoExpression) {
-                placement = (<InstantaniousTempoExpression>(this.expressions[0].expression)).Placement;
+            if (this.expressions[0].expression instanceof InstantaneousTempoExpression) {
+                placement = (<InstantaneousTempoExpression>(this.expressions[0].expression)).Placement;
             } else if (this.expressions[0].expression instanceof ContinuousTempoExpression) {
                 placement = (<ContinuousTempoExpression>(this.expressions[0].expression)).Placement;
             }
@@ -60,7 +60,7 @@ export class MultiTempoExpression /*implements IComparable<MultiTempoExpression>
     }
     public getFontstyleOfFirstEntry(): FontStyles {
         let fontStyle: FontStyles = FontStyles.Regular;
-        if (this.expressions[0].expression instanceof InstantaniousTempoExpression) {
+        if (this.expressions[0].expression instanceof InstantaneousTempoExpression) {
             fontStyle = FontStyles.Bold;
         } else if (this.expressions[0].expression instanceof ContinuousTempoExpression) {
             fontStyle = FontStyles.Italic;
@@ -70,9 +70,9 @@ export class MultiTempoExpression /*implements IComparable<MultiTempoExpression>
     //public getFirstEntry(graphicalLabel: GraphicalLabel): AbstractGraphicalExpression {
     //    let indexOfFirstNotInstDynExpr: number = 0;
     //    if (this.expressions.length > 0) {
-    //        if (this.expressions[indexOfFirstNotInstDynExpr].expression instanceof InstantaniousTempoExpression)
-    //            return new GraphicalInstantaniousTempoExpression(
-    // <InstantaniousTempoExpression>(this.expressions[indexOfFirstNotInstDynExpr].expression), graphicalLabel);
+    //        if (this.expressions[indexOfFirstNotInstDynExpr].expression instanceof InstantaneousTempoExpression)
+    //            return new GraphicalInstantaneousTempoExpression(
+    // <InstantaneousTempoExpression>(this.expressions[indexOfFirstNotInstDynExpr].expression), graphicalLabel);
     //        else if (this.expressions[indexOfFirstNotInstDynExpr].expression instanceof ContinuousTempoExpression)
     //            return new GraphicalContinuousTempoExpression(
     // <ContinuousTempoExpression>(this.expressions[indexOfFirstNotInstDynExpr].expression), graphicalLabel);
@@ -81,8 +81,8 @@ export class MultiTempoExpression /*implements IComparable<MultiTempoExpression>
     //    return undefined;
     //}
     public addExpression(abstractTempoExpression: AbstractTempoExpression, prefix: string): void {
-        if (abstractTempoExpression instanceof InstantaniousTempoExpression) {
-            this.instantaneousTempo = <InstantaniousTempoExpression>abstractTempoExpression;
+        if (abstractTempoExpression instanceof InstantaneousTempoExpression) {
+            this.instantaneousTempo = <InstantaneousTempoExpression>abstractTempoExpression;
         } else if (abstractTempoExpression instanceof ContinuousTempoExpression) {
             this.continuousTempo = <ContinuousTempoExpression>abstractTempoExpression;
         }

src/MusicalScore/VoiceData/HelperObjects/DynamicsContainer.ts

@@ -1,19 +1,19 @@
 import {ContinuousDynamicExpression} from "../Expressions/ContinuousExpressions/ContinuousDynamicExpression";
-import {InstantaniousDynamicExpression} from "../Expressions/InstantaniousDynamicExpression";
+import {InstantaneousDynamicExpression} from "../Expressions/InstantaneousDynamicExpression";
 import {MultiExpression} from "../Expressions/MultiExpression";
 
 export class DynamicsContainer /*implements IComparable<DynamicsContainer>*/ {
-    constructor(dynamicExpression: ContinuousDynamicExpression|InstantaniousDynamicExpression, staffNumber: number) {
+    constructor(dynamicExpression: ContinuousDynamicExpression|InstantaneousDynamicExpression, staffNumber: number) {
         if (dynamicExpression instanceof ContinuousDynamicExpression) {
             this.continuousDynamicExpression = dynamicExpression;
-        } else if (dynamicExpression instanceof InstantaniousDynamicExpression) {
+        } else if (dynamicExpression instanceof InstantaneousDynamicExpression) {
             this.instantaneousDynamicExpression = dynamicExpression;
         }
         this.staffNumber = staffNumber;
     }
 
     public continuousDynamicExpression: ContinuousDynamicExpression;
-    public instantaneousDynamicExpression: InstantaniousDynamicExpression;
+    public instantaneousDynamicExpression: InstantaneousDynamicExpression;
     public staffNumber: number;
 
     public parMultiExpression(): MultiExpression {