Fixed expressions

src/MusicalScore/Exceptions.ts

@@ -19,3 +19,11 @@ export class ArgumentOutOfRangeException implements Error {
         this.message = message;
     }
 }
+
+export class InvalidEnumArgumentException implements Error {
+    public name: string;
+    public message: string;
+    constructor(message: string) {
+        this.message = message;
+    }
+}

src/MusicalScore/MusicParts/MusicPartManagerIterator.ts

@@ -10,12 +10,10 @@ import {VerticalSourceStaffEntryContainer} from "../VoiceData/VerticalSourceStaf
 import {RhythmInstruction} from "../VoiceData/Instructions/RhythmInstruction";
 import {AbstractNotationInstruction} from "../VoiceData/Instructions/AbstractNotationInstruction";
 import {RepetitionInstruction} from "../VoiceData/Instructions/RepetitionInstruction";
-
-// FIXME:
-type MultiTempoExpression = any;
-type ContinuousDynamicExpression = any;
-type InstantaniousDynamicExpression = any;
-type AbstractExpression = any;
+import {ContinuousDynamicExpression} from "../VoiceData/Expressions/ContinuousExpressions/continuousDynamicExpression";
+import {InstantaniousDynamicExpression} from "../VoiceData/Expressions/instantaniousDynamicExpression";
+import {MultiTempoExpression} from "../VoiceData/Expressions/multiTempoExpression";
+import {AbstractExpression} from "../VoiceData/Expressions/abstractExpression";
 
 export class MusicPartManagerIterator {
     constructor(manager: MusicPartManager, startTimestamp?: Fraction, endTimestamp?: Fraction) {
@@ -404,8 +402,8 @@ export class MusicPartManagerIterator {
             if (this.CurrentSourceTimestamp === dynamicsContainer.parMultiExpression().AbsoluteTimestamp) {
                 if (dynamicsContainer.ContinuousDynamicExpression !== undefined) {
                     this.activeDynamicExpressions[staffIndex] = dynamicsContainer.ContinuousDynamicExpression;
-                } else if (dynamicsContainer.InstantaniousDynamicExpression !== undefined) {
-                    this.activeDynamicExpressions[staffIndex] = dynamicsContainer.InstantaniousDynamicExpression;
+                } else if (dynamicsContainer.InstantaneousDynamicExpression !== undefined) {
+                    this.activeDynamicExpressions[staffIndex] = dynamicsContainer.InstantaneousDynamicExpression;
                 }
             }
             this.currentDynamicEntryIndex++;

src/MusicalScore/MusicSheet.ts

@@ -14,6 +14,7 @@ import {PartListEntry} from "./MusicSource/PartListEntry";
 import {VerticalSourceStaffEntryContainer} from "./VoiceData/VerticalSourceStaffEntryContainer";
 import {Voice} from "./VoiceData/Voice";
 import {MusicSheetErrors} from "../Common/DataObjects/MusicSheetErrors";
+import {MultiTempoExpression} from "./VoiceData/Expressions/multiTempoExpression";
 
 // FIXME
 //type MusicSheetParameters = any;
@@ -30,6 +31,11 @@ import {MusicSheetErrors} from "../Common/DataObjects/MusicSheetErrors";
 
 // FIXME Andrea: Commented out some things, have a look at (*)
 
+export class PlaybackSettings {
+    public Rhythm: Fraction;
+}
+
+
 export class MusicSheet /*implements ISettableMusicSheet, IComparable<MusicSheet>*/ {
     constructor() {
         // (*) try {
@@ -52,10 +58,10 @@ export class MusicSheet /*implements ISettableMusicSheet, IComparable<MusicSheet
     private repetitions: Repetition[] = [];
     private dynListStaves: DynamicsContainer[][] = [];
     private timestampSortedDynamicExpressionsList: DynamicsContainer[] = [];
-    // (*) private timestampSortedTempoExpressionsList: MultiTempoExpression[] = [];
+    private timestampSortedTempoExpressionsList: MultiTempoExpression[] = [];
     private instrumentalGroups: InstrumentalGroup[] = [];
     private instruments: Instrument[] = [];
-    // (*) private playbackSettings: PlaybackSettings;
+    private playbackSettings: PlaybackSettings;
     private path: string;
     private title: Label;
     private subtitle: Label;
@@ -99,10 +105,9 @@ export class MusicSheet /*implements ISettableMusicSheet, IComparable<MusicSheet
     public get DynListStaves(): DynamicsContainer[][] {
         return this.dynListStaves;
     }
-    // (*)
-    //public get TimestampSortedTempoExpressionsList(): MultiTempoExpression[] {
-    //    return this.timestampSortedTempoExpressionsList;
-    //}
+    public get TimestampSortedTempoExpressionsList(): MultiTempoExpression[] {
+        return this.timestampSortedTempoExpressionsList;
+    }
     public get TimestampSortedDynamicExpressionsList(): DynamicsContainer[] {
         return this.timestampSortedDynamicExpressionsList;
     }
@@ -112,12 +117,12 @@ export class MusicSheet /*implements ISettableMusicSheet, IComparable<MusicSheet
     public get Instruments(): Instrument[] {
         return this.instruments;
     }
-    // (*) public get SheetPlaybackSetting(): PlaybackSettings {
-    //    return this.playbackSettings;
-    //}
-    // (*) public set SheetPlaybackSetting(value: PlaybackSettings) {
-    //    this.playbackSettings = value;
-    //}
+     public get SheetPlaybackSetting(): PlaybackSettings {
+        return this.playbackSettings;
+    }
+     public set SheetPlaybackSetting(value: PlaybackSettings) {
+        this.playbackSettings = value;
+    }
     public get DrawErroneousMeasures(): boolean {
         return this.drawErroneousMeasures;
     }

src/MusicalScore/VoiceData/Expressions/ContinuousExpressions/continuousDynamicExpression.ts

@@ -1,26 +1,27 @@
 import {PlacementEnum, AbstractExpression} from "../abstractExpression";
 import {MultiExpression} from "../multiExpression";
 import {Fraction} from "../../../../Common/DataObjects/fraction";
+
 export class ContinuousDynamicExpression extends AbstractExpression {
-    constructor(placement: PlacementEnum, staffNumber: number, label: string) {
-        this.label = label;
-        this.placement = placement;
-        this.staffNumber = staffNumber;
-        this.startVolume = -1;
-        this.endVolume = -1;
-        this.setType();
-    }
-    constructor(dynamicType: ContDynamicEnum, placement: PlacementEnum, staffNumber: number) {
+    //constructor(placement: PlacementEnum, staffNumber: number, label: string) {
+    //    this.label = label;
+    //    this.placement = placement;
+    //    this.staffNumber = staffNumber;
+    //    this.startVolume = -1;
+    //    this.endVolume = -1;
+    //    this.setType();
+    //}
+    constructor(dynamicType: ContDynamicEnum, placement: PlacementEnum, staffNumber: number, label: string) {
         this.dynamicType = dynamicType;
-        this.label = null;
+        this.label = label;
         this.placement = placement;
         this.staffNumber = staffNumber;
         this.startVolume = -1;
         this.endVolume = -1;
     }
-    private static listContinuousDynamicIncreasing: Array<string> = __init(new Array<string>(), { "crescendo","cresc","cresc.","cres." });
-    private static listContinuousDynamicDecreasing: Array<string> = __init(new Array<string>(), { "decrescendo","decresc","decr.","diminuendo","dim.","dim" });
-    private static listContinuousDynamicGeneral: Array<string> = __init(new Array<string>(), { "subito","al niente","piu","meno" });
+    private static listContinuousDynamicIncreasing: string[] = ["crescendo", "cresc", "cresc.", "cres."];
+    private static listContinuousDynamicDecreasing: string[] = ["decrescendo", "decresc", "decr.", "diminuendo", "dim.", "dim"];
+    // private static listContinuousDynamicGeneral: string[] = ["subito","al niente","piu","meno"];
     private dynamicType: ContDynamicEnum;
     private startMultiExpression: MultiExpression;
     private endMultiExpression: MultiExpression;
@@ -29,6 +30,7 @@ export class ContinuousDynamicExpression extends AbstractExpression {
     private placement: PlacementEnum;
     private staffNumber: number;
     private label: string;
+
     public get DynamicType(): ContDynamicEnum {
         return this.dynamicType;
     }
@@ -80,9 +82,9 @@ export class ContinuousDynamicExpression extends AbstractExpression {
     public static isInputStringContinuousDynamic(inputString: string): boolean {
         if (inputString == null)
             return false;
-        if (isStringInStringList(ContinuousDynamicExpression.listContinuousDynamicIncreasing, inputString))
+        if (ContinuousDynamicExpression.listContinuousDynamicIncreasing.indexOf(inputString) !== -1)
             return true;
-        if (isStringInStringList(ContinuousDynamicExpression.listContinuousDynamicDecreasing, inputString))
+        if (ContinuousDynamicExpression.listContinuousDynamicDecreasing.indexOf(inputString) !== -1)
             return true;
         return false;
     }
@@ -99,23 +101,21 @@ export class ContinuousDynamicExpression extends AbstractExpression {
         if (currentAbsoluteTimestamp > continuousAbsoluteEndTimestamp)
             return -2;
         var interpolationRatio: number = (currentAbsoluteTimestamp - continuousAbsoluteStartTimestamp).RealValue / (continuousAbsoluteEndTimestamp - continuousAbsoluteStartTimestamp).RealValue;
-        var interpolatedVolume: number = Math.Max(0.0f, Math.Min(99.9f, this.startVolume + (this.endVolume - this.startVolume) * interpolationRatio));
+        var interpolatedVolume: number = Math.max(0.0, Math.min(99.9, this.startVolume + (this.endVolume - this.startVolume) * interpolationRatio));
         return <number>interpolatedVolume;
     }
     public isWedge(): boolean {
-        if (this.label != null)
-            return false;
-        return true;
+        return this.label === undefined;
     }
     private setType(): void {
-        if (isStringInStringList(ContinuousDynamicExpression.listContinuousDynamicIncreasing, this.label))
+        if (ContinuousDynamicExpression.listContinuousDynamicIncreasing.indexOf(this.label) !== -1)
             this.dynamicType = ContDynamicEnum.crescendo;
-        else if (isStringInStringList(ContinuousDynamicExpression.listContinuousDynamicDecreasing, this.label))
+        else if (ContinuousDynamicExpression.listContinuousDynamicDecreasing.indexOf(this.label) !== -1)
             this.dynamicType = ContDynamicEnum.diminuendo;
     }
 }
+
 export enum ContDynamicEnum {
     crescendo = 0,
-
     diminuendo = 1
-}
+}

src/MusicalScore/VoiceData/Expressions/ContinuousExpressions/continuousTempoExpression.ts

@@ -15,8 +15,9 @@ export class ContinuousTempoExpression extends AbstractTempoExpression {
     private tempoType: ContinuousTempoType;
     private startTempo: number;
     private endTempo: number;
-    private static listContinuousTempoFaster: Array<string> = __init(new Array<string>(), { "accelerando","piu mosso","poco piu","stretto" });
-    private static listContinuousTempoSlower: Array<string> = __init(new Array<string>(), { "poco meno","meno mosso","piu lento","calando","allargando","rallentando","ritardando","ritenuto","ritard.","ritard","rit.","rit","riten.","riten" });
+    private static listContinuousTempoFaster: string[] = ["accelerando","piu mosso","poco piu","stretto"];
+    private static listContinuousTempoSlower: string[] = ["poco meno","meno mosso","piu lento","calando","allargando","rallentando","ritardando","ritenuto","ritard.","ritard","rit.","rit","riten.","riten"];
+
     public get TempoType(): ContinuousTempoType {
         return this.tempoType;
     }
@@ -44,32 +45,32 @@ export class ContinuousTempoExpression extends AbstractTempoExpression {
     public static isInputStringContinuousTempo(inputString: string): boolean {
         if (inputString == null)
             return false;
-        if (isStringInStringList(ContinuousTempoExpression.listContinuousTempoFaster, inputString))
+        if (ContinuousTempoExpression.listContinuousTempoFaster.indexOf(inputString) !== -1)
             return true;
-        if (isStringInStringList(ContinuousTempoExpression.listContinuousTempoSlower, inputString))
+        if (ContinuousTempoExpression.listContinuousTempoSlower.indexOf(inputString) !== -1)
             return true;
         return false;
     }
     private setTempoType(): void {
-        if (isStringInStringList(ContinuousTempoExpression.listContinuousTempoFaster, label))
+        if (ContinuousTempoExpression.listContinuousTempoFaster.indexOf(this.label) !== -1)
             this.tempoType = ContinuousTempoType.accelerando;
-        else if (isStringInStringList(ContinuousTempoExpression.listContinuousTempoSlower, label))
+        else if (ContinuousTempoExpression.listContinuousTempoSlower.indexOf(this.label) !== -1)
             this.tempoType = ContinuousTempoType.ritardando;
     }
     public get AbsoluteTimestamp(): Fraction {
-        return (ParentMultiTempoExpression.AbsoluteTimestamp);
+        return this.ParentMultiTempoExpression.AbsoluteTimestamp;
     }
     public getAbsoluteFloatTimestamp(): number {
-        return (ParentMultiTempoExpression.AbsoluteTimestamp).RealValue;
+        return this.ParentMultiTempoExpression.AbsoluteTimestamp.RealValue;
     }
     public getInterpolatedTempo(currentAbsoluteTimestamp: Fraction): number {
-        var continuousAbsoluteStartTimestamp: Fraction = parentMultiTempoExpression.SourceMeasureParent.AbsoluteTimestamp + parentMultiTempoExpression.Timestamp;
-        if (currentAbsoluteTimestamp < continuousAbsoluteStartTimestamp)
+        var continuousAbsoluteStartTimestamp: Fraction = Fraction.plus(this.parentMultiTempoExpression.SourceMeasureParent.AbsoluteTimestamp, this.parentMultiTempoExpression.Timestamp);
+        if (currentAbsoluteTimestamp.lt(continuousAbsoluteStartTimestamp))
             return -1;
-        if (currentAbsoluteTimestamp > this.absoluteEndTimestamp)
+        if (currentAbsoluteTimestamp.lt(this.absoluteEndTimestamp))
             return -2;
-        var interpolationRatio: number = (currentAbsoluteTimestamp - continuousAbsoluteStartTimestamp).RealValue / (this.absoluteEndTimestamp - continuousAbsoluteStartTimestamp).RealValue;
-        var interpolatedTempo: number = Math.Max(0.0f, Math.Min(250.0f, this.startTempo + (this.endTempo - this.startTempo) * interpolationRatio));
+        var interpolationRatio: number = Fraction.minus(currentAbsoluteTimestamp, continuousAbsoluteStartTimestamp).RealValue / Fraction.minus(this.absoluteEndTimestamp, continuousAbsoluteStartTimestamp).RealValue;
+        var interpolatedTempo: number = Math.max(0.0, Math.min(250.0, this.startTempo + (this.endTempo - this.startTempo) * interpolationRatio));
         return <number>interpolatedTempo;
     }
     public static isIncreasingTempo(tempoType: ContinuousTempoType): boolean {

src/MusicalScore/VoiceData/Expressions/instantaniousDynamicExpression.ts

@@ -1,203 +1,177 @@
 import {PlacementEnum, AbstractExpression} from "./abstractExpression";
 import {MultiExpression} from "./multiExpression";
 import {DynamicExpressionSymbolEnum} from "./dynamicExpressionSymbolEnum";
+import {ArgumentOutOfRangeException} from "../../Exceptions";
+import {InvalidEnumArgumentException} from "../../Exceptions";
+import {logging} from "../../../Common/logging";
 
 export class InstantaniousDynamicExpression extends AbstractExpression {
     constructor(dynamicExpression: string, soundDynamics: number, placement: PlacementEnum, staffNumber: number) {
-        this.dynamicEnum = <DynamicEnum>Enum.Parse(/*typeof*/DynamicEnum, dynamicExpression.ToLower());
+        this.dynamicEnum = DynamicEnum[dynamicExpression.toLowerCase()];
         this.soundDynamic = soundDynamics;
         this.placement = placement;
         this.staffNumber = staffNumber;
     }
-    public static dynamicToRelativeVolumeDict: SortedDictionary<DynamicEnum, number> = __init(new SortedDictionary<DynamicEnum, number>(), { { DynamicEnum.ffffff, 127.0f / 127.0f },
-        { DynamicEnum.fffff, 126.0f / 127.0f },
-        { DynamicEnum.ffff, 125.0f / 127.0f },
-        { DynamicEnum.fff, 124.0f / 127.0f },
-        { DynamicEnum.ff, 108.0f / 127.0f },
-        { DynamicEnum.f, 92.0f / 127.0f },
-        { DynamicEnum.mf, 76.0f / 127.0f },
-        { DynamicEnum.mp, 60.0f / 127.0f },
-        { DynamicEnum.p, 44.0f / 127.0f },
-        { DynamicEnum.pp, 28.0f / 127.0f },
-        { DynamicEnum.ppp, 12.0f / 127.0f },
-        { DynamicEnum.pppp, 10.0f / 127.0f },
-        { DynamicEnum.ppppp, 8.0f / 127.0f },
-        { DynamicEnum.pppppp, 6.0f / 127.0f },
-        { DynamicEnum.sf, 0.5f },
-        { DynamicEnum.sfp, 0.5f },
-        { DynamicEnum.sfpp, 0.5f },
-        { DynamicEnum.fp, 0.5f },
-        { DynamicEnum.rf, 0.5f },
-        { DynamicEnum.rfz, 0.5f },
-        { DynamicEnum.sfz, 0.5f },
-        { DynamicEnum.sffz, 0.5f },
-        { DynamicEnum.fz, 0.5f } });
-private static weight: number;
-static private  listInstantaniousDynamics: Array < string >  =  __init(new Array<string>(), {
-    "pppppp","ppppp","pppp","ppp","pp","p",
-    "ffffff","fffff","ffff","fff","ff","f",
-    "mf","mp","sf","sp","spp","fp","rf","rfz","sfz","sffz","fz" });
-private multiExpression: MultiExpression;
-private dynamicEnum: DynamicEnum;
-private soundDynamic: number;
-private placement: PlacementEnum;
-private staffNumber: number;
-private length: number;
-public get ParentMultiExpression(): MultiExpression
-{
-    return this.multiExpression;
-}
-public set ParentMultiExpression(value: MultiExpression)
-{
-    this.multiExpression = value;
-}
-public get DynEnum(): DynamicEnum
-{
-    return this.dynamicEnum;
-}
-public set DynEnum(value: DynamicEnum)
-{
-    this.dynamicEnum = value;
-}
-public get SoundDynamic(): number
-{
-    return this.soundDynamic;
-}
-public set SoundDynamic(value: number)
-{
-    this.soundDynamic = value;
-}
-public get Placement(): PlacementEnum
-{
-    return this.placement;
-}
-public set Placement(value: PlacementEnum)
-{
-    this.placement = value;
-}
-public get StaffNumber(): number
-{
-    return this.staffNumber;
-}
-public set StaffNumber(value: number)
-{
-    this.staffNumber = value;
-}
-public get Length(): number
-{
-    if (Math.Abs(this.length - 0.0f) < 0.0001f)
-    this.length = this.calculateLength();
-    return this.length;
-}
-public get MidiVolume(): number
-{
-    return InstantaniousDynamicExpression.dynamicToRelativeVolumeDict[this.dynamicEnum] * 127f;
-}
-public static isInputStringInstantaniousDynamic(inputString:string): boolean
-{
-    if (inputString == null)
-        return false;
-    if (isStringInStringList(InstantaniousDynamicExpression.listInstantaniousDynamics, inputString))
-        return true;
-    return false;
-}
-public getInstantaniousDynamicSymbol(expressionSymbolEnum:DynamicExpressionSymbolEnum): FontInfo.MusicFontSymbol
-{
-    switch (expressionSymbolEnum) {
-        case DynamicExpressionSymbolEnum.p:
-            return FontInfo.MusicFontSymbol.P;
-        case DynamicExpressionSymbolEnum.f:
-            return FontInfo.MusicFontSymbol.F;
-        case DynamicExpressionSymbolEnum.s:
-            return FontInfo.MusicFontSymbol.S;
-        case DynamicExpressionSymbolEnum.z:
-            return FontInfo.MusicFontSymbol.Z;
-        case DynamicExpressionSymbolEnum.m:
-            return FontInfo.MusicFontSymbol.M;
-        case DynamicExpressionSymbolEnum.r:
-            return FontInfo.MusicFontSymbol.R;
-        default:
-            throw new ArgumentOutOfRangeException("expressionSymbolEnum");
+    public static dynamicToRelativeVolumeDict: { [_: string]: number; } = {
+        "ffffff": (127.0 / 127.0),
+        "fffff": (126.0 / 127.0) ,
+        "ffff": 125.0 / 127.0,
+        "fff": 124.0 / 127.0,
+        "ff": 108.0 / 127.0,
+        "f": 92.0 / 127.0,
+        "mf": 76.0 / 127.0,
+        "mp": 60.0 / 127.0,
+        "p": 44.0 / 127.0,
+        "pp": 28.0 / 127.0,
+        "ppp": 12.0 / 127.0,
+        "pppp": 10.0 / 127.0,
+        "ppppp": 8.0 / 127.0,
+        "pppppp": 6.0 / 127.0,
+        "sf": 0.5,
+        "sfp": 0.5,
+        "sfpp": 0.5,
+        "fp": 0.5,
+        "rf": 0.5,
+        "rfz": 0.5,
+        "sfz": 0.5,
+        "sffz": 0.5,
+        "fz": 0.5
+    };
+
+    private static weight: number;
+    private static listInstantaniousDynamics: string[] =  [
+        "pppppp", "ppppp", "pppp", "ppp", "pp", "p",
+        "ffffff", "fffff", "ffff", "fff", "ff", "f",
+        "mf", "mp", "sf", "sp", "spp", "fp", "rf", "rfz", "sfz", "sffz", "fz"
+    ];
+
+    private multiExpression: MultiExpression;
+    private dynamicEnum: DynamicEnum;
+    private soundDynamic: number;
+    private placement: PlacementEnum;
+    private staffNumber: number;
+    private length: number;
+
+    public get ParentMultiExpression(): MultiExpression {
+        return this.multiExpression;
     }
-}
-public getDynamicExpressionSymbol(c:string): DynamicExpressionSymbolEnum
-{
-    switch (c) {
-        case 'p':
-            return DynamicExpressionSymbolEnum.p;
-        case 'f':
-            return DynamicExpressionSymbolEnum.f;
-        case 's':
-            return DynamicExpressionSymbolEnum.s;
-        case 'z':
-            return DynamicExpressionSymbolEnum.z;
-        case 'm':
-            return DynamicExpressionSymbolEnum.m;
-        case 'r':
-            return DynamicExpressionSymbolEnum.r;
-        default:
-            throw new InvalidEnumArgumentException("unknown DynamicExpressionSymbolEnum: " + c);
+    public set ParentMultiExpression(value: MultiExpression) {
+        this.multiExpression = value;
+    }
+    public get DynEnum(): DynamicEnum {
+        return this.dynamicEnum;
+    }
+    public set DynEnum(value: DynamicEnum) {
+        this.dynamicEnum = value;
+    }
+    public get SoundDynamic(): number {
+        return this.soundDynamic;
+    }
+    public set SoundDynamic(value: number) {
+        this.soundDynamic = value;
+    }
+    public get Placement(): PlacementEnum {
+        return this.placement;
+    }
+    public set Placement(value: PlacementEnum) {
+        this.placement = value;
+    }
+    public get StaffNumber(): number {
+        return this.staffNumber;
+    }
+    public set StaffNumber(value: number) {
+        this.staffNumber = value;
+    }
+    public get Length(): number {
+        if (Math.abs(this.length) < 0.0001) {
+            this.length = this.calculateLength();
+        }
+        return this.length;
+    }
+    public get MidiVolume(): number {
+        return InstantaniousDynamicExpression.dynamicToRelativeVolumeDict[this.dynamicEnum] * 127;
+    }
+    public static isInputStringInstantaniousDynamic(inputString:string): boolean {
+        if (inputString === null) { return false; }
+            return false;
+        return (InstantaniousDynamicExpression.listInstantaniousDynamics.indexOf(inputString) !== -1);
+    }
+
+    //public getInstantaniousDynamicSymbol(expressionSymbolEnum:DynamicExpressionSymbolEnum): FontInfo.MusicFontSymbol {
+    //    switch (expressionSymbolEnum) {
+    //        case DynamicExpressionSymbolEnum.p:
+    //            return FontInfo.MusicFontSymbol.P;
+    //        case DynamicExpressionSymbolEnum.f:
+    //            return FontInfo.MusicFontSymbol.F;
+    //        case DynamicExpressionSymbolEnum.s:
+    //            return FontInfo.MusicFontSymbol.S;
+    //        case DynamicExpressionSymbolEnum.z:
+    //            return FontInfo.MusicFontSymbol.Z;
+    //        case DynamicExpressionSymbolEnum.m:
+    //            return FontInfo.MusicFontSymbol.M;
+    //        case DynamicExpressionSymbolEnum.r:
+    //            return FontInfo.MusicFontSymbol.R;
+    //        default:
+    //            throw new ArgumentOutOfRangeException("expressionSymbolEnum");
+    //    }
+    //}
+    public getDynamicExpressionSymbol(c:string): DynamicExpressionSymbolEnum  {
+        switch (c) {
+            case 'p':
+                return DynamicExpressionSymbolEnum.p;
+            case 'f':
+                return DynamicExpressionSymbolEnum.f;
+            case 's':
+                return DynamicExpressionSymbolEnum.s;
+            case 'z':
+                return DynamicExpressionSymbolEnum.z;
+            case 'm':
+                return DynamicExpressionSymbolEnum.m;
+            case 'r':
+                return DynamicExpressionSymbolEnum.r;
+            default:
+                throw new InvalidEnumArgumentException("unknown DynamicExpressionSymbolEnum: " + c);
+        }
     }
+    private calculateLength(): number {
+        //var length: number = 0.0;
+        //var dynamic: string = DynamicEnum[this.dynamicEnum];
+        //for (var idx: number = 0, len = dynamic.length; idx < len; ++idx) {
+        //    var c: string = dynamic[idx];
+        //    var dynamicExpressionSymbol: DynamicExpressionSymbolEnum = this.getDynamicExpressionSymbol(c);
+        //    var symbol: FontInfo.MusicFontSymbol = this.getInstantaniousDynamicSymbol(dynamicExpressionSymbol);
+        //    length += FontInfo.Info.getBoundingBox(symbol).Width;
+        //}
+        //return length;
+        logging.debug("[Andrea] instantaniousDynamicExpression: not implemented: calculateLength!");
+        return 0.0;
+    }
+
 }
-private calculateLength(): number
-{
-    var length: number = 0.0f;
-    var dynamic: string = this.dynamicEnum.ToString();
-    for (var idx: number = 0, len = dynamic.length; idx < len; ++idx) {
-        var c: string = dynamic[idx];
-        var dynamicExpressionSymbol: DynamicExpressionSymbolEnum = this.getDynamicExpressionSymbol(c);
-        var symbol: FontInfo.MusicFontSymbol = this.getInstantaniousDynamicSymbol(dynamicExpressionSymbol);
-        length += FontInfo.Info.getBoundingBox(symbol).Width;
-    }
-    return length;
-} 
-                }
+
 export enum DynamicEnum {
     pppppp = 0,
-
     ppppp = 1,
-
     pppp = 2,
-
     ppp = 3,
-
     pp = 4,
-
     p = 5,
-
     mp = 6,
-
     mf = 7,
-
     f = 8,
-
     ff = 9,
-
     fff = 10,
-
     ffff = 11,
-
     fffff = 12,
-
     ffffff = 13,
-
     sf = 14,
-
     sfp = 15,
-
     sfpp = 16,
-
     fp = 17,
-
     rf = 18,
-
     rfz = 19,
-
     sfz = 20,
-
     sffz = 21,
-
     fz = 22,
-
     other = 23
-}
+}

src/MusicalScore/VoiceData/Expressions/instantaniousTempoExpression.ts

@@ -12,60 +12,66 @@ export class InstantaniousTempoExpression extends AbstractTempoExpression {
         super.parentMultiTempoExpression = parentMultiTempoExpression;
         this.setTempoAndTempoType(soundTempo);
     }
+    
     private tempoEnum: TempoEnum;
     private tempoInBpm: number;
-    private findTempoEnum(inputString: string, pre: string, post: string): TempoEnum {
-        var result: TempoEnum = this.splitStringAfterInstructionWord(inputString, InstantaniousTempoExpression.listInstantaniousTempoLarghissimo, pre,
-            post);
-        if (result != TempoEnum.none)
-            return result;
-        result = this.splitStringAfterInstructionWord(inputString, InstantaniousTempoExpression.listInstantaniousTempoGrave, pre,
-            post);
-        if (result != TempoEnum.none)
-            return result;
-        return TempoEnum.none;
-    }
-    private splitStringAfterInstructionWord(inputString: string, instruction: KeyValuePair<Array<string>, TempoEnum>, pre: string, post: string): TempoEnum {
-        pre = null;
-        post = null;
-        for (var idx: number = 0, len = instruction.Key.Count; idx < len; ++idx) {
-            var instructionWord: string = instruction.Key[idx];
-            var separators: string[] = " " + instructionWord, instructionWord + " ","," + instructionWord, instructionWord + ",";
-            var splits: string[] = inputString.Split(separators, 2, StringSplitOptions.None);
-            if (splits.length > 1) {
-                pre = splits[0];
-                post = splits[1];
-                return instruction.Value;
-            }
-        }
-        return TempoEnum.none;
-    }
-    static private listInstantaniousTempoLarghissimo: KeyValuePair<Array<string>, TempoEnum> = new KeyValuePair<Array<string>, TempoEnum>(__init(new Array<string>(), { "Larghissimo","Sehr breit","very, very slow" }), TempoEnum.larghissimo);
-    static private listInstantaniousTempoGrave: KeyValuePair<Array<string>, TempoEnum> = new KeyValuePair<Array<string>, TempoEnum>(__init(new Array<string>(), { "Grave","Schwer","slow and solemn" }), TempoEnum.grave);
-    static private listInstantaniousTempoLento: KeyValuePair<Array<string>, TempoEnum> = new KeyValuePair<Array<string>, TempoEnum>(__init(new Array<string>(), { "Lento","Lent","Langsam","slowly" }), TempoEnum.lento);
-    static private listInstantaniousTempoLargo: KeyValuePair<Array<string>, TempoEnum> = new KeyValuePair<Array<string>, TempoEnum>(__init(new Array<string>(), { "Largo","Breit","broadly" }), TempoEnum.largo);
-    static private listInstantaniousTempoLarghetto: KeyValuePair<Array<string>, TempoEnum> = new KeyValuePair<Array<string>, TempoEnum>(__init(new Array<string>(), { "Larghetto","Etwas breit","rather broadly" }), TempoEnum.larghetto);
-    static private listInstantaniousTempoAdagio: KeyValuePair<Array<string>, TempoEnum> = new KeyValuePair<Array<string>, TempoEnum>(__init(new Array<string>(), { "Adagio","Langsam","Ruhig","slow and stately" }), TempoEnum.adagio);
-    static private listInstantaniousTempoAdagietto: KeyValuePair<Array<string>, TempoEnum> = new KeyValuePair<Array<string>, TempoEnum>(__init(new Array<string>(), { "Adagietto","Ziemlich ruhig","Ziemlich langsam","rather slow" }), TempoEnum.adagietto);
-    static private listInstantaniousTempoAndanteModerato: KeyValuePair<Array<string>, TempoEnum> = new KeyValuePair<Array<string>, TempoEnum>(__init(new Array<string>(), { "Andante moderato" }), TempoEnum.andanteModerato);
-    static private listInstantaniousTempoAndante: KeyValuePair<Array<string>, TempoEnum> = new KeyValuePair<Array<string>, TempoEnum>(__init(new Array<string>(), { "Andante","Gehend","Schreitend","at a walking pace" }), TempoEnum.andante);
-    static private listInstantaniousTempoAndantino: KeyValuePair<Array<string>, TempoEnum> = new KeyValuePair<Array<string>, TempoEnum>(__init(new Array<string>(), { "Andantino" }), TempoEnum.andantino);
-    static private listInstantaniousTempoModerato: KeyValuePair<Array<string>, TempoEnum> = new KeyValuePair<Array<string>, TempoEnum>(__init(new Array<string>(), { "Moderato","M��ig","Mod�r�","moderately" }), TempoEnum.moderato);
-    static private listInstantaniousTempoAllegretto: KeyValuePair<Array<string>, TempoEnum> = new KeyValuePair<Array<string>, TempoEnum>(__init(new Array<string>(), { "Allegretto","fast" }), TempoEnum.allegretto);
-    static private listInstantaniousTempoAllegroModerato: KeyValuePair<Array<string>, TempoEnum> = new KeyValuePair<Array<string>, TempoEnum>(__init(new Array<string>(), { "Allegro moderato" }), TempoEnum.allegroModerato);
-    static private listInstantaniousTempoAllegro: KeyValuePair<Array<string>, TempoEnum> = new KeyValuePair<Array<string>, TempoEnum>(__init(new Array<string>(), { "Allegro","Rapide","Vite","Rasch","Schnell","Fr�hlich" }), TempoEnum.allegro);
-    static private listInstantaniousTempoVivace: KeyValuePair<Array<string>, TempoEnum> = new KeyValuePair<Array<string>, TempoEnum>(__init(new Array<string>(), { "Vivace","Lebhaft","Lebendig","lively and fast" }), TempoEnum.vivace);
-    static private listInstantaniousTempoVivacissimo: KeyValuePair<Array<string>, TempoEnum> = new KeyValuePair<Array<string>, TempoEnum>(__init(new Array<string>(), { "Vivacissimo","Sehr lebhaft","Sehr lebendig" }), TempoEnum.vivacissimo);
-    static private listInstantaniousTempoAllegrissimo: KeyValuePair<Array<string>, TempoEnum> = new KeyValuePair<Array<string>, TempoEnum>(__init(new Array<string>(), { "Allegrissimo","very fast" }), TempoEnum.allegrissimo);
-    static private listInstantaniousTempoPresto: KeyValuePair<Array<string>, TempoEnum> = new KeyValuePair<Array<string>, TempoEnum>(__init(new Array<string>(), { "Presto","Sehr schnell","Geschwind" }), TempoEnum.presto);
-    static private listInstantaniousTempoPrestissimo: KeyValuePair<Array<string>, TempoEnum> = new KeyValuePair<Array<string>, TempoEnum>(__init(new Array<string>(), { "Prestissimo","�u�erst schnell" }), TempoEnum.prestissimo);
-    static private listInstantaniousTempoChangesGeneral: Array<string> = __init(new Array<string>(), {
+
+    // 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,
+    //        post);
+    //    if (result !== TempoEnum.none)
+    //        return result;
+    //    result = this.splitStringAfterInstructionWord(inputString, InstantaniousTempoExpression.listInstantaniousTempoGrave, TempoEnum.grave, pre,
+    //        post);
+    //    if (result !== TempoEnum.none)
+    //        return result;
+    //    return TempoEnum.none;
+    //}
+    //private splitStringAfterInstructionWord(inputString: string, instruction: string[], value: TempoEnum, pre: string, post: string): TempoEnum {
+    //    pre = undefined;
+    //    post = undefined;
+    //    for (let idx: number = 0, len = instruction.length; idx < len; ++idx) {
+    //        let instructionWord: string = instruction[idx];
+    //        let separators: string[] = [" " + instructionWord, instructionWord + " ", "," + instructionWord, instructionWord + ","];
+    //        for (let j: number = 0; j < 4; j++) {
+    //            let splits:string[] = inputString.split(separators[j], 2);
+    //            if (splits.length > 1) {
+    //                pre = splits[0];
+    //                post = splits[1];
+    //                return value;
+    //            }
+    //        }
+    //    }
+    //    return TempoEnum.none;
+    //}
+    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[] = [
         "tempo primo",
         "a tempo",
         "tempo i",
         "rubato",
-        "doppio movimento" });
-    static private listInstantaniousTempoAddons: Array<string> = __init(new Array<string>(), {
+        "doppio movimento"
+    ];
+    private static listInstantaniousTempoAddons: string[] = [
         "assai",
         "amoroso",
         "cantabile",
@@ -147,24 +153,26 @@ export class InstantaniousTempoExpression extends AbstractTempoExpression {
         "ein wenig",
         "alla marcia",
         "ad libitum",
-        "alla breve" });
+        "alla breve"
+    ];
+    
     public get Label(): string {
-        return label;
+        return this.label;
     }
     public set Label(value: string) {
-        label = value;
+        this.label = value;
     }
     public get Placement(): PlacementEnum {
-        return placement;
+        return this.placement;
     }
     public set Placement(value: PlacementEnum) {
-        placement = value;
+        this.placement = value;
     }
     public get StaffNumber(): number {
-        return staffNumber;
+        return this.staffNumber;
     }
     public set StaffNumber(value: number) {
-        staffNumber = value;
+        this.staffNumber = value;
     }
     public get Enum(): TempoEnum {
         return this.tempoEnum;
@@ -176,7 +184,7 @@ export class InstantaniousTempoExpression extends AbstractTempoExpression {
         this.tempoInBpm = value;
     }
     public get ParentMultiTempoExpression(): MultiTempoExpression {
-        return parentMultiTempoExpression;
+        return this.parentMultiTempoExpression;
     }
     public getAbsoluteTimestamp(): Fraction {
         return (this.ParentMultiTempoExpression.SourceMeasureParent.AbsoluteTimestamp + this.ParentMultiTempoExpression.Timestamp);
@@ -229,175 +237,178 @@ export class InstantaniousTempoExpression extends AbstractTempoExpression {
         }
     }
     public static isInputStringInstantaniousTempo(inputString: string): boolean {
-        if (inputString == null)
+        if (inputString === undefined)
             return false;
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoLarghissimo.Key, inputString))
-            return true;
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoGrave.Key, inputString))
-            return true;
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoLento.Key, inputString))
-            return true;
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoLargo.Key, inputString))
-            return true;
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoLarghetto.Key, inputString))
-            return true;
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAdagio.Key, inputString))
-            return true;
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAdagietto.Key, inputString))
-            return true;
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAndanteModerato.Key, inputString))
-            return true;
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAndante.Key, inputString))
-            return true;
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAndantino.Key, inputString))
-            return true;
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoModerato.Key, inputString))
-            return true;
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAllegretto.Key, inputString))
-            return true;
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAllegroModerato.Key, inputString))
-            return true;
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAllegro.Key, inputString))
-            return true;
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoVivace.Key, inputString))
-            return true;
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoVivacissimo.Key, inputString))
-            return true;
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAllegrissimo.Key, inputString))
-            return true;
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoPresto.Key, inputString))
-            return true;
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoPrestissimo.Key, inputString))
-            return true;
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoChangesGeneral, inputString))
-            return true;
-        return false;
+        return (
+            (InstantaniousTempoExpression.listInstantaniousTempoLarghissimo.indexOf(inputString) !== -1)
+            || (InstantaniousTempoExpression.listInstantaniousTempoGrave.indexOf(inputString) !== -1)
+            || (InstantaniousTempoExpression.listInstantaniousTempoLento.indexOf(inputString) !== -1)
+            || (InstantaniousTempoExpression.listInstantaniousTempoLargo.indexOf(inputString) !== -1)
+            || (InstantaniousTempoExpression.listInstantaniousTempoLarghetto.indexOf(inputString) !== -1)
+            || (InstantaniousTempoExpression.listInstantaniousTempoAdagio.indexOf(inputString) !== -1)
+            || (InstantaniousTempoExpression.listInstantaniousTempoAdagietto.indexOf(inputString) !== -1)
+            || (InstantaniousTempoExpression.listInstantaniousTempoAndanteModerato.indexOf(inputString) !== -1)
+            || (InstantaniousTempoExpression.listInstantaniousTempoAndante.indexOf(inputString) !== -1)
+            || (InstantaniousTempoExpression.listInstantaniousTempoAndantino.indexOf(inputString) !== -1)
+            || (InstantaniousTempoExpression.listInstantaniousTempoModerato.indexOf(inputString) !== -1)
+            || (InstantaniousTempoExpression.listInstantaniousTempoAllegretto.indexOf(inputString) !== -1)
+            || (InstantaniousTempoExpression.listInstantaniousTempoAllegroModerato.indexOf(inputString) !== -1)
+            || (InstantaniousTempoExpression.listInstantaniousTempoAllegro.indexOf(inputString) !== -1)
+            || (InstantaniousTempoExpression.listInstantaniousTempoVivace.indexOf(inputString) !== -1)
+            || (InstantaniousTempoExpression.listInstantaniousTempoVivacissimo.indexOf(inputString) !== -1)
+            || (InstantaniousTempoExpression.listInstantaniousTempoAllegrissimo.indexOf(inputString) !== -1)
+            || (InstantaniousTempoExpression.listInstantaniousTempoPresto.indexOf(inputString) !== -1)
+            || (InstantaniousTempoExpression.listInstantaniousTempoPrestissimo.indexOf(inputString) !== -1)
+            || (InstantaniousTempoExpression.listInstantaniousTempoChangesGeneral.indexOf(inputString) !== -1)
+        );
     }
     private setTempoAndTempoType(soundTempo: number): void {
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoLarghissimo.Key, label)) {
-            if (soundTempo == 0)
+        if (InstantaniousTempoExpression.listInstantaniousTempoLarghissimo.indexOf(this.label) !== -1) {
+            if (soundTempo === 0)
                 soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.larghissimo);
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.larghissimo;
+            return;
         }
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoGrave.Key, label)) {
-            if (soundTempo == 0)
+        if (InstantaniousTempoExpression.listInstantaniousTempoGrave.indexOf(this.label) !== -1) {
+            if (soundTempo === 0)
                 soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.grave);
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.grave;
+            return;
         }
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoLento.Key, label)) {
-            if (soundTempo == 0)
+        if (InstantaniousTempoExpression.listInstantaniousTempoLento.indexOf(this.label) !== -1) {
+            if (soundTempo === 0)
                 soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.lento);
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.lento;
+            return;
         }
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoLargo.Key, label)) {
-            if (soundTempo == 0)
+        if (InstantaniousTempoExpression.listInstantaniousTempoLargo.indexOf(this.label) !== -1) {
+            if (soundTempo === 0)
                 soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.largo);
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.largo;
+            return;
         }
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoLarghetto.Key, label)) {
-            if (soundTempo == 0)
+        if (InstantaniousTempoExpression.listInstantaniousTempoLarghetto.indexOf(this.label) !== -1) {
+            if (soundTempo === 0)
                 soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.larghetto);
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.larghetto;
+            return;
         }
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAdagio.Key, label)) {
-            if (soundTempo == 0)
+        if (InstantaniousTempoExpression.listInstantaniousTempoAdagio.indexOf(this.label) !== -1) {
+            if (soundTempo === 0)
                 soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.adagio);
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.adagio;
+            return;
         }
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAdagietto.Key, label)) {
-            if (soundTempo == 0)
+        if (InstantaniousTempoExpression.listInstantaniousTempoAdagietto.indexOf(this.label) !== -1) {
+            if (soundTempo === 0)
                 soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.adagietto);
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.adagietto;
+            return;
         }
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAndanteModerato.Key, label)) {
-            if (soundTempo == 0)
+        if (InstantaniousTempoExpression.listInstantaniousTempoAndanteModerato.indexOf(this.label) !== -1) {
+            if (soundTempo === 0)
                 soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.andanteModerato);
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.andanteModerato;
+            return;
         }
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAndante.Key, label)) {
-            if (soundTempo == 0)
+        if (InstantaniousTempoExpression.listInstantaniousTempoAndante.indexOf(this.label) !== -1) {
+            if (soundTempo === 0)
                 soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.andante);
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.andante;
+            return;
         }
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAndantino.Key, label)) {
-            if (soundTempo == 0)
+        if (InstantaniousTempoExpression.listInstantaniousTempoAndantino.indexOf(this.label) !== -1) {
+            if (soundTempo === 0)
                 soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.andantino);
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.andantino;
+            return;
         }
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoModerato.Key, label)) {
-            if (soundTempo == 0)
+        if (InstantaniousTempoExpression.listInstantaniousTempoModerato.indexOf(this.label) !== -1) {
+            if (soundTempo === 0)
                 soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.moderato);
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.moderato;
+            return;
         }
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAllegretto.Key, label)) {
-            if (soundTempo == 0)
+        if (InstantaniousTempoExpression.listInstantaniousTempoAllegretto.indexOf(this.label) !== -1) {
+            if (soundTempo === 0)
                 soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.allegretto);
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.allegretto;
+            return;
         }
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAllegroModerato.Key, label)) {
-            if (soundTempo == 0)
+        if (InstantaniousTempoExpression.listInstantaniousTempoAllegroModerato.indexOf(this.label) !== -1) {
+            if (soundTempo === 0)
                 soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.allegroModerato);
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.allegroModerato;
+            return;
         }
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAllegro.Key, label)) {
-            if (soundTempo == 0)
+        if (InstantaniousTempoExpression.listInstantaniousTempoAllegro.indexOf(this.label) !== -1) {
+            if (soundTempo === 0)
                 soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.allegro);
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.allegro;
+            return;
         }
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoVivace.Key, label)) {
-            if (soundTempo == 0)
+        if (InstantaniousTempoExpression.listInstantaniousTempoVivace.indexOf(this.label) !== -1) {
+            if (soundTempo === 0)
                 soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.vivace);
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.vivace;
+            return;
         }
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoVivacissimo.Key, label)) {
-            if (soundTempo == 0)
+        if (InstantaniousTempoExpression.listInstantaniousTempoVivacissimo.indexOf(this.label) !== -1) {
+            if (soundTempo === 0)
                 soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.vivacissimo);
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.vivacissimo;
+            return;
         }
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAllegrissimo.Key, label)) {
-            if (soundTempo == 0)
+        if (InstantaniousTempoExpression.listInstantaniousTempoAllegrissimo.indexOf(this.label) !== -1) {
+            if (soundTempo === 0)
                 soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.allegrissimo);
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.allegrissimo;
+            return;
         }
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoPresto.Key, label)) {
-            if (soundTempo == 0)
+        if (InstantaniousTempoExpression.listInstantaniousTempoPresto.indexOf(this.label) !== -1) {
+            if (soundTempo === 0)
                 soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.presto);
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.presto;
+            return;
         }
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoPrestissimo.Key, label)) {
-            if (soundTempo == 0)
+        if (InstantaniousTempoExpression.listInstantaniousTempoPrestissimo.indexOf(this.label) !== -1) {
+            if (soundTempo === 0)
                 soundTempo = InstantaniousTempoExpression.getDefaultValueForTempoType(TempoEnum.prestissimo);
             this.tempoInBpm = soundTempo;
             this.tempoEnum = TempoEnum.prestissimo;
+            return;
         }
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoAddons, label)) {
+        if (InstantaniousTempoExpression.listInstantaniousTempoAddons.indexOf(this.label) !== -1) {
             this.tempoInBpm = 0;
             this.tempoEnum = TempoEnum.addon;
+            return;
         }
-        if (isStringInStringList(InstantaniousTempoExpression.listInstantaniousTempoChangesGeneral, label)) {
+        if (InstantaniousTempoExpression.listInstantaniousTempoChangesGeneral.indexOf(this.label) !== -1) {
             this.tempoInBpm = 0;
             this.tempoEnum = TempoEnum.changes;
+            return;
         }
     }
 }
+
 export enum TempoEnum {
     none,
     larghissimo,
@@ -422,4 +433,4 @@ export enum TempoEnum {
     lastRealTempo,
     addon,
     changes
-}
+}

src/MusicalScore/VoiceData/Expressions/moodExpression.ts

@@ -1,4 +1,5 @@
 import {PlacementEnum, AbstractExpression} from "./abstractExpression";
+
 export class MoodExpression extends AbstractExpression {
     constructor(label: string, placement: PlacementEnum, staffNumber: number) {
         this.label = label;
@@ -6,44 +7,46 @@ export class MoodExpression extends AbstractExpression {
         this.staffNumber = staffNumber;
         this.setMoodType();
     }
+    
     private moodType: MoodEnum;
     private label: string;
     private staffNumber: number;
     private placement: PlacementEnum;
-    static private listMoodAffettuoso: Array<string> = __init(new Array<string>(), { "affettuoso" });
-    static private listMoodAgitato: Array<string> = __init(new Array<string>(), { "agitato" });
-    static private listMoodAppassionato: Array<string> = __init(new Array<string>(), { "appassionato" });
-    static private listMoodAnimato: Array<string> = __init(new Array<string>(), { "animato","lively" });
-    static private listMoodBrillante: Array<string> = __init(new Array<string>(), { "brillante" });
-    static private listMoodCantabile: Array<string> = __init(new Array<string>(), { "cantabile" });
-    static private listMoodDolce: Array<string> = __init(new Array<string>(), { "dolce" });
-    static private listMoodEnergico: Array<string> = __init(new Array<string>(), { "energico" });
-    static private listMoodEroico: Array<string> = __init(new Array<string>(), { "eroico" });
-    static private listMoodEspressivo: Array<string> = __init(new Array<string>(), { "espressivo" });
-    static private listMoodFurioso: Array<string> = __init(new Array<string>(), { "furioso" });
-    static private listMoodGiocoso: Array<string> = __init(new Array<string>(), { "giocoso" });
-    static private listMoodGioioso: Array<string> = __init(new Array<string>(), { "gioioso" });
-    static private listMoodLacrimoso: Array<string> = __init(new Array<string>(), { "lacrimoso" });
-    static private listMoodGrandioso: Array<string> = __init(new Array<string>(), { "grandioso" });
-    static private listMoodGrazioso: Array<string> = __init(new Array<string>(), { "grazioso" });
-    static private listMoodLeggiero: Array<string> = __init(new Array<string>(), { "leggiero" });
-    static private listMoodMaestoso: Array<string> = __init(new Array<string>(), { "maestoso" });
-    static private listMoodMalinconico: Array<string> = __init(new Array<string>(), { "malinconico" });
-    static private listMoodMarcato: Array<string> = __init(new Array<string>(), { "marcato" });
-    static private listMoodMarziale: Array<string> = __init(new Array<string>(), { "marziale" });
-    static private listMoodMesto: Array<string> = __init(new Array<string>(), { "mesto" });
-    static private listMoodMorendo: Array<string> = __init(new Array<string>(), { "morendo" });
-    static private listMoodNobilmente: Array<string> = __init(new Array<string>(), { "nobilmente" });
-    static private listMoodPatetico: Array<string> = __init(new Array<string>(), { "patetico" });
-    static private listMoodPesante: Array<string> = __init(new Array<string>(), { "pesante" });
-    static private listMoodSautille: Array<string> = __init(new Array<string>(), { "sautille" });
-    static private listMoodSaltando: Array<string> = __init(new Array<string>(), { "saltando" });
-    static private listMoodScherzando: Array<string> = __init(new Array<string>(), { "scherzando" });
-    static private listMoodSostenuto: Array<string> = __init(new Array<string>(), { "sostenuto" });
-    static private listMoodSpiccato: Array<string> = __init(new Array<string>(), { "spiccato" });
-    static private listMoodTenerezza: Array<string> = __init(new Array<string>(), { "tenerezza" });
-    static private listMoodTranquillamente: Array<string> = __init(new Array<string>(), { "tranquillamente" });
-    static private listMoodTrionfante: Array<string> = __init(new Array<string>(), { "trionfante" });
+    private static listMoodAffettuoso: string[] = ["affettuoso"];
+    private static listMoodAgitato: string[] = ["agitato"];
+    private static listMoodAppassionato: string[] = ["appassionato"];
+    private static listMoodAnimato: string[] = ["animato","lively"];
+    private static listMoodBrillante: string[] = ["brillante"];
+    private static listMoodCantabile: string[] = ["cantabile"];
+    private static listMoodDolce: string[] = ["dolce"];
+    private static listMoodEnergico: string[] = ["energico"];
+    private static listMoodEroico: string[] = ["eroico"];
+    private static listMoodEspressivo: string[] = ["espressivo"];
+    private static listMoodFurioso: string[] = ["furioso"];
+    private static listMoodGiocoso: string[] = ["giocoso"];
+    private static listMoodGioioso: string[] = ["gioioso"];
+    private static listMoodLacrimoso: string[] = ["lacrimoso"];
+    private static listMoodGrandioso: string[] = ["grandioso"];
+    private static listMoodGrazioso: string[] = ["grazioso"];
+    private static listMoodLeggiero: string[] = ["leggiero"];
+    private static listMoodMaestoso: string[] = ["maestoso"];
+    private static listMoodMalinconico: string[] = ["malinconico"];
+    private static listMoodMarcato: string[] = ["marcato"];
+    private static listMoodMarziale: string[] = ["marziale"];
+    private static listMoodMesto: string[] = ["mesto"];
+    private static listMoodMorendo: string[] = ["morendo"];
+    private static listMoodNobilmente: string[] = ["nobilmente"];
+    private static listMoodPatetico: string[] = ["patetico"];
+    private static listMoodPesante: string[] = ["pesante"];
+    private static listMoodSautille: string[] = ["sautille"];
+    private static listMoodSaltando: string[] = ["saltando"];
+    private static listMoodScherzando: string[] = ["scherzando"];
+    private static listMoodSostenuto: string[] = ["sostenuto"];
+    private static listMoodSpiccato: string[] = ["spiccato"];
+    private static listMoodTenerezza: string[] = ["tenerezza"];
+    private static listMoodTranquillamente: string[] = ["tranquillamente"];
+    private static listMoodTrionfante: string[] = ["trionfante"];
+
     public get Label(): string {
         return this.label;
     }
@@ -68,218 +71,186 @@ export class MoodExpression extends AbstractExpression {
     public set Placement(value: PlacementEnum) {
         this.placement = value;
     }
+
     public static isInputStringMood(inputString: string): boolean {
         if (inputString == null)
             return false;
-        if (isStringInStringList(MoodExpression.listMoodAffettuoso, inputString))
+        if (inputString === MoodExpression.listMoodAffettuoso[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodAgitato, inputString))
+        if (inputString === MoodExpression.listMoodAgitato[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodAnimato, inputString))
+        if (inputString === MoodExpression.listMoodAnimato[0] || inputString === MoodExpression.listMoodAnimato[1])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodAppassionato, inputString))
+        if (inputString === MoodExpression.listMoodAppassionato[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodBrillante, inputString))
+        if (inputString === MoodExpression.listMoodBrillante[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodCantabile, inputString))
+        if (inputString === MoodExpression.listMoodCantabile[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodDolce, inputString))
+        if (inputString === MoodExpression.listMoodDolce[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodEnergico, inputString))
+        if (inputString === MoodExpression.listMoodEnergico[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodEroico, inputString))
+        if (inputString === MoodExpression.listMoodEroico[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodEspressivo, inputString))
+        if (inputString === MoodExpression.listMoodEspressivo[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodFurioso, inputString))
+        if (inputString === MoodExpression.listMoodFurioso[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodGiocoso, inputString))
+        if (inputString === MoodExpression.listMoodGiocoso[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodGioioso, inputString))
+        if (inputString === MoodExpression.listMoodGioioso[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodGrandioso, inputString))
+        if (inputString === MoodExpression.listMoodGrandioso[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodGrazioso, inputString))
+        if (inputString === MoodExpression.listMoodGrazioso[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodLacrimoso, inputString))
+        if (inputString === MoodExpression.listMoodLacrimoso[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodLeggiero, inputString))
+        if (inputString === MoodExpression.listMoodLeggiero[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodMaestoso, inputString))
+        if (inputString === MoodExpression.listMoodMaestoso[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodMalinconico, inputString))
+        if (inputString === MoodExpression.listMoodMalinconico[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodMarcato, inputString))
+        if (inputString === MoodExpression.listMoodMarcato[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodMarziale, inputString))
+        if (inputString === MoodExpression.listMoodMarziale[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodMesto, inputString))
+        if (inputString === MoodExpression.listMoodMesto[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodMorendo, inputString))
+        if (inputString === MoodExpression.listMoodMorendo[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodNobilmente, inputString))
+        if (inputString === MoodExpression.listMoodNobilmente[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodPatetico, inputString))
+        if (inputString === MoodExpression.listMoodPatetico[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodPesante, inputString))
+        if (inputString === MoodExpression.listMoodPesante[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodSaltando, inputString))
+        if (inputString === MoodExpression.listMoodSaltando[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodSautille, inputString))
+        if (inputString === MoodExpression.listMoodSautille[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodScherzando, inputString))
+        if (inputString === MoodExpression.listMoodScherzando[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodSostenuto, inputString))
+        if (inputString === MoodExpression.listMoodSostenuto[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodSpiccato, inputString))
+        if (inputString === MoodExpression.listMoodSpiccato[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodTenerezza, inputString))
+        if (inputString === MoodExpression.listMoodTenerezza[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodTranquillamente, inputString))
+        if (inputString === MoodExpression.listMoodTranquillamente[0])
             return true;
-        if (isStringInStringList(MoodExpression.listMoodTrionfante, inputString))
+        if (inputString === MoodExpression.listMoodTrionfante[0])
             return true;
         return false;
     }
     private setMoodType(): void {
-        if (isStringInStringList(MoodExpression.listMoodAffettuoso, this.label))
+        if (this.label === MoodExpression.listMoodAffettuoso[0])
             this.moodType = MoodEnum.Affettuoso;
-        if (isStringInStringList(MoodExpression.listMoodAgitato, this.label))
+        if (this.label === MoodExpression.listMoodAgitato[0])
             this.moodType = MoodEnum.Agitato;
-        if (isStringInStringList(MoodExpression.listMoodAnimato, this.label))
+        if (this.label === MoodExpression.listMoodAnimato[0] || this.label === MoodExpression.listMoodAnimato[1])
             this.moodType = MoodEnum.Animato;
-        if (isStringInStringList(MoodExpression.listMoodAppassionato, this.label))
+        if (this.label === MoodExpression.listMoodAppassionato[0])
             this.moodType = MoodEnum.Appassionato;
-        if (isStringInStringList(MoodExpression.listMoodBrillante, this.label))
+        if (this.label === MoodExpression.listMoodBrillante[0])
             this.moodType = MoodEnum.Brillante;
-        if (isStringInStringList(MoodExpression.listMoodCantabile, this.label))
+        if (this.label === MoodExpression.listMoodCantabile[0])
             this.moodType = MoodEnum.Cantabile;
-        if (isStringInStringList(MoodExpression.listMoodDolce, this.label))
+        if (this.label === MoodExpression.listMoodDolce[0])
             this.moodType = MoodEnum.Dolce;
-        if (isStringInStringList(MoodExpression.listMoodEnergico, this.label))
+        if (this.label === MoodExpression.listMoodEnergico[0])
             this.moodType = MoodEnum.Energico;
-        if (isStringInStringList(MoodExpression.listMoodEroico, this.label))
+        if (this.label === MoodExpression.listMoodEroico[0])
             this.moodType = MoodEnum.Eroico;
-        if (isStringInStringList(MoodExpression.listMoodEspressivo, this.label))
+        if (this.label === MoodExpression.listMoodEspressivo[0])
             this.moodType = MoodEnum.Espressivo;
-        if (isStringInStringList(MoodExpression.listMoodFurioso, this.label))
+        if (this.label === MoodExpression.listMoodFurioso[0])
             this.moodType = MoodEnum.Furioso;
-        if (isStringInStringList(MoodExpression.listMoodGiocoso, this.label))
+        if (this.label === MoodExpression.listMoodGiocoso[0])
             this.moodType = MoodEnum.Giocoso;
-        if (isStringInStringList(MoodExpression.listMoodGioioso, this.label))
+        if (this.label === MoodExpression.listMoodGioioso[0])
             this.moodType = MoodEnum.Gioioso;
-        if (isStringInStringList(MoodExpression.listMoodGrandioso, this.label))
+        if (this.label === MoodExpression.listMoodGrandioso[0])
             this.moodType = MoodEnum.Grandioso;
-        if (isStringInStringList(MoodExpression.listMoodGrazioso, this.label))
+        if (this.label === MoodExpression.listMoodGrazioso[0])
             this.moodType = MoodEnum.Grazioso;
-        if (isStringInStringList(MoodExpression.listMoodLacrimoso, this.label))
+        if (this.label === MoodExpression.listMoodLacrimoso[0])
             this.moodType = MoodEnum.Lacrimoso;
-        if (isStringInStringList(MoodExpression.listMoodLeggiero, this.label))
+        if (this.label === MoodExpression.listMoodLeggiero[0])
             this.moodType = MoodEnum.Leggiero;
-        if (isStringInStringList(MoodExpression.listMoodMaestoso, this.label))
+        if (this.label === MoodExpression.listMoodMaestoso[0])
             this.moodType = MoodEnum.Maestoso;
-        if (isStringInStringList(MoodExpression.listMoodMalinconico, this.label))
+        if (this.label === MoodExpression.listMoodMalinconico[0])
             this.moodType = MoodEnum.Malinconico;
-        if (isStringInStringList(MoodExpression.listMoodMarcato, this.label))
+        if (this.label === MoodExpression.listMoodMarcato[0])
             this.moodType = MoodEnum.Marcato;
-        if (isStringInStringList(MoodExpression.listMoodMarziale, this.label))
+        if (this.label === MoodExpression.listMoodMarziale[0])
             this.moodType = MoodEnum.Marziale;
-        if (isStringInStringList(MoodExpression.listMoodMesto, this.label))
+        if (this.label === MoodExpression.listMoodMesto[0])
             this.moodType = MoodEnum.Mesto;
-        if (isStringInStringList(MoodExpression.listMoodMorendo, this.label))
+        if (this.label === MoodExpression.listMoodMorendo[0])
             this.moodType = MoodEnum.Morendo;
-        if (isStringInStringList(MoodExpression.listMoodNobilmente, this.label))
+        if (this.label === MoodExpression.listMoodNobilmente[0])
             this.moodType = MoodEnum.Nobilmente;
-        if (isStringInStringList(MoodExpression.listMoodPatetico, this.label))
+        if (this.label === MoodExpression.listMoodPatetico[0])
             this.moodType = MoodEnum.Patetico;
-        if (isStringInStringList(MoodExpression.listMoodPesante, this.label))
+        if (this.label === MoodExpression.listMoodPesante[0])
             this.moodType = MoodEnum.Pesante;
-        if (isStringInStringList(MoodExpression.listMoodSaltando, this.label))
+        if (this.label === MoodExpression.listMoodSaltando[0])
             this.moodType = MoodEnum.Saltando;
-        if (isStringInStringList(MoodExpression.listMoodSautille, this.label))
+        if (this.label === MoodExpression.listMoodSautille[0])
             this.moodType = MoodEnum.Sautille;
-        if (isStringInStringList(MoodExpression.listMoodScherzando, this.label))
+        if (this.label === MoodExpression.listMoodScherzando[0])
             this.moodType = MoodEnum.Scherzando;
-        if (isStringInStringList(MoodExpression.listMoodSostenuto, this.label))
+        if (this.label === MoodExpression.listMoodSostenuto[0])
             this.moodType = MoodEnum.Sostenuto;
-        if (isStringInStringList(MoodExpression.listMoodSpiccato, this.label))
+        if (this.label === MoodExpression.listMoodSpiccato[0])
             this.moodType = MoodEnum.Spiccato;
-        if (isStringInStringList(MoodExpression.listMoodTenerezza, this.label))
+        if (this.label === MoodExpression.listMoodTenerezza[0])
             this.moodType = MoodEnum.Tenerezza;
-        if (isStringInStringList(MoodExpression.listMoodTranquillamente, this.label))
+        if (this.label === MoodExpression.listMoodTranquillamente[0])
             this.moodType = MoodEnum.Tranquillamente;
-        if (isStringInStringList(MoodExpression.listMoodTrionfante, this.label))
+        if (this.label === MoodExpression.listMoodTrionfante[0])
             this.moodType = MoodEnum.Trionfante;
     }
 }
+
 export enum MoodEnum {
     Affettuoso = 0,
-
     Agitato = 1,
-
     Appassionato = 2,
-
     Animato = 3,
-
     Brillante = 4,
-
     Cantabile = 5,
-
     Dolce = 6,
-
     Energico = 7,
-
     Eroico = 8,
-
     Espressivo = 9,
-
     Furioso = 10,
-
     Giocoso = 11,
-
     Gioioso = 12,
-
     Lacrimoso = 13,
-
     Grandioso = 14,
-
     Grazioso = 15,
-
     Leggiero = 16,
-
     Maestoso = 17,
-
     Malinconico = 18,
-
     Marcato = 19,
-
     Marziale = 20,
-
     Mesto = 21,
-
     Morendo = 22,
-
     Nobilmente = 23,
-
     Patetico = 24,
-
     Pesante = 25,
-
     Sautille = 26,
-
     Saltando = 27,
-
     Scherzando = 28,
-
     Sostenuto = 29,
-
     Spiccato = 30,
-
     Tenerezza = 31,
-
     Tranquillamente = 32,
-
     Trionfante = 33,
-
     Vivace = 34
-}
+}

src/MusicalScore/VoiceData/HelperObjects/DynamicsContainer.ts

@@ -1,6 +1,6 @@
-type ContinuousDynamicExpression = any;
-type InstantaniousDynamicExpression = any;
-type MultiExpression = any;
+import {ContinuousDynamicExpression} from "../Expressions/ContinuousExpressions/continuousDynamicExpression";
+import {InstantaniousDynamicExpression} from "../Expressions/instantaniousDynamicExpression";
+import {MultiExpression} from "../Expressions/multiExpression";
 
 export class DynamicsContainer /*implements IComparable<DynamicsContainer>*/ {
     constructor(continuousDynamicExpression: ContinuousDynamicExpression, staffNumber: number) {
@@ -8,20 +8,20 @@ export class DynamicsContainer /*implements IComparable<DynamicsContainer>*/ {
         this.StaffNumber = staffNumber;
     }
     constructor(instantaniousDynamicExpression: InstantaniousDynamicExpression, staffNumber: number) {
-        this.InstantaniousDynamicExpression = instantaniousDynamicExpression;
+        this.InstantaneousDynamicExpression = instantaniousDynamicExpression;
         this.StaffNumber = staffNumber;
     }
 
     public ContinuousDynamicExpression: ContinuousDynamicExpression;
-    public InstantaneousDynamicExpression: InstantaneousDynamicExpression;
+    public InstantaneousDynamicExpression: InstantaniousDynamicExpression;
     public StaffNumber: number;
 
     public parMultiExpression(): MultiExpression {
         if (this.ContinuousDynamicExpression !== undefined) {
             return this.ContinuousDynamicExpression.StartMultiExpression;
         }
-        if (this.InstantaniousDynamicExpression !== undefined) {
-            return this.InstantaniousDynamicExpression.ParentMultiExpression;
+        if (this.InstantaneousDynamicExpression !== undefined) {
+            return this.InstantaneousDynamicExpression.ParentMultiExpression;
         }
         return undefined;
     }