XML Parsing problem...

src/Common/DataObjects/MusicSheetErrors.ts

@@ -1,33 +1,25 @@
 // skeleton by Andrea
 
 export class MusicSheetErrors {
-    public measureErrors: { [n: number]: string[] };
+    public measureErrors: { [n: number]: string[] } = {};
 
-    private errors: string[];
-    private tempErrors: string[];
+    private errors: string[] = [];
+    private tempErrors: string[] = [];
 
-    public TransferTempErrorsToDict(measureNumber: number): void {
-        for (let errorString of this.tempErrors) {
-            this.addErrorMessageAtIndex(measureNumber, errorString);
+    public finalizeMeasure(measureNumber: number): void {
+        let list: string[] = this.measureErrors[measureNumber];
+        if (list === undefined) {
+            list = [];
         }
+        this.measureErrors[measureNumber] = list.concat(this.tempErrors);
         this.tempErrors = [];
     }
 
-    // Add an error message to the temporary errors list
-    public pushTemp(errorMsg: string): void {
+    public pushMeasureError(errorMsg: string): void {
         this.tempErrors.push(errorMsg);
     }
 
     public push(errorMsg: string): void {
         this.errors.push(errorMsg);
     }
-
-    private addErrorMessageAtIndex(measureNumber: number, errorString: string): void {
-        let list: string[] = this.measureErrors[measureNumber];
-        if (list === undefined) {
-            this.measureErrors[measureNumber] = [errorString];
-        } else {
-            list.push(errorString);
-        }
-    }
 }

src/Common/FileIO/Xml.ts

@@ -12,7 +12,7 @@ export class IXmlElement {
 
   constructor(elem: Element) {
     this.elem = elem;
-    this.name = elem.nodeName;
+    this.name = elem.nodeName.toLowerCase();
 
     if (elem.hasAttributes()) {
       this.hasAttributes = true;
@@ -20,10 +20,7 @@ export class IXmlElement {
       }
     this.hasElements = elem.hasChildNodes();
     // Look for a value
-    if (
-      elem.childNodes.length === 1 &&
-      elem.childNodes[0].nodeType === Node.TEXT_NODE
-    ) {
+    if (elem.childNodes.length === 1 && elem.childNodes[0].nodeType === Node.TEXT_NODE) {
       this.value = elem.childNodes[0].nodeValue;
     }
   }
@@ -53,12 +50,14 @@ export class IXmlElement {
     let ret: IXmlElement[] = [];
     let nameUnset: boolean = nodeName === undefined;
     if (!nameUnset) {
-      nodeName = nodeName.toUpperCase();
+      nodeName = nodeName.toLowerCase();
     }
+    console.log("-", nodes.length, this.elem.childElementCount);
     for (let i: number = 0; i < nodes.length; i += 1) {
       let node: Node = nodes[i];
+      console.log("node: ", this.elem.nodeName, ">>", node.nodeName, node.nodeType === Node.ELEMENT_NODE);
       if (node.nodeType === Node.ELEMENT_NODE &&
-        (nameUnset || node.nodeName.toUpperCase() === nodeName)) {
+        (nameUnset || node.nodeName.toLowerCase() === nodeName)) {
           ret.push(new IXmlElement(node as Element));
         }
     }

src/MusicalScore/Calculation/MeasureSizeCalculator.ts

@@ -68,7 +68,7 @@ export class MeasureSizeCalculator {
     }
 
     for (let i: number = 0, len: number = outline.length; i < len; i += 3) {
-      console.log(i, outline[i]);
+      //console.log(i, outline[i]);
       switch (<string> outline[i]) {
         case "m": update(i); break;
         case "l": update(i); break;

src/MusicalScore/ScoreIO/InstrumentReader.ts

@@ -84,6 +84,7 @@ export class InstrumentReader {
   private currentVoiceGenerator: VoiceGenerator;
   //private openSlurDict: { [n: number]: Slur; } = {};
   private maxTieNoteFraction: Fraction;
+
   public get ActiveKey(): KeyInstruction {
     return this.activeKey;
   }
@@ -112,24 +113,22 @@ export class InstrumentReader {
     let lastNoteWasGrace: boolean = false;
     try {
       let xmlMeasureListArr: IXmlElement[] = this.xmlMeasureList[this.currentXmlMeasureIndex].elements();
-      for (let idx: number = 0, len: number = xmlMeasureListArr.length; idx < len; ++idx) {
-        let xmlNode: IXmlElement = xmlMeasureListArr[idx];
+      for (let xmlNode of xmlMeasureListArr) {
         if (xmlNode.name === "note") {
-          if ((xmlNode.hasAttributes && xmlNode.attribute("print-object") !== undefined && xmlNode.attribute("print-spacing") !== undefined)) {
+          if (xmlNode.hasAttributes && xmlNode.attribute("print-object") !== undefined && xmlNode.attribute("print-spacing") !== undefined) {
             continue;
           }
           let noteStaff: number = 1;
           if (this.instrument.Staves.length > 1) {
-            try {
-              if (xmlNode.element("staff") !== undefined) {
-                noteStaff = parseInt(xmlNode.element("staff").value, 10);
+            if (xmlNode.element("staff") !== undefined) {
+              noteStaff = parseInt(xmlNode.element("staff").value, 10);
+              if (isNaN(noteStaff)) {
+                Logging.debug("InstrumentReader.readNextXmlMeasure.get staff number");
+                noteStaff = 1;
               }
-            } catch (ex) {
-              Logging.debug("InstrumentReader.readNextXmlMeasure.get staff number", ex);
-              noteStaff = 1;
             }
-
           }
+
           this.currentStaff = this.instrument.Staves[noteStaff - 1];
           let isChord: boolean = xmlNode.element("chord") !== undefined;
           if (xmlNode.element("voice") !== undefined) {
@@ -156,7 +155,7 @@ export class InstrumentReader {
               }
             } catch (ex) {
               let errorMsg: string = ITextTranslation.translateText("ReaderErrorMessages/NoteDurationError", "Invalid Note Duration.");
-              this.musicSheet.SheetErrors.pushTemp(errorMsg);
+              this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
               Logging.debug("InstrumentReader.readNextXmlMeasure", errorMsg, ex);
               continue;
             }
@@ -361,12 +360,12 @@ export class InstrumentReader {
         throw new MusicSheetReadingException(e.Message);
       }
       let errorMsg: string = ITextTranslation.translateText("ReaderErrorMessages/MeasureError", "Error while reading Measure.");
-      this.musicSheet.SheetErrors.pushTemp(errorMsg);
+      this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
       Logging.debug("InstrumentReader.readNextXmlMeasure", errorMsg, e);
     }
 
     this.previousMeasure = this.currentMeasure;
-    this.currentXmlMeasureIndex++;
+    this.currentXmlMeasureIndex += 1;
     return true;
   }
   public doCalculationsAfterDurationHasBeenSet(): void {
@@ -527,7 +526,7 @@ export class InstrumentReader {
               "ReaderErrorMessages/ClefLineError",
               "Invalid clef line given -> using default clef line."
             );
-            this.musicSheet.SheetErrors.pushTemp(errorMsg);
+            this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
             line = 2;
             Logging.debug("InstrumentReader.addAbstractInstruction", errorMsg, ex);
           }
@@ -545,7 +544,7 @@ export class InstrumentReader {
                 "ReaderErrorMessages/ClefError",
                 "Unsupported clef found -> using default clef."
               );
-              this.musicSheet.SheetErrors.pushTemp(errorMsg);
+              this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
               clefEnum = ClefEnum.G;
               line = 2;
             }
@@ -554,7 +553,7 @@ export class InstrumentReader {
               "ReaderErrorMessages/ClefError",
               "Invalid clef found -> using default clef."
             );
-            this.musicSheet.SheetErrors.pushTemp(errorMsg);
+            this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
             clefEnum = ClefEnum.G;
             line = 2;
             Logging.debug("InstrumentReader.addAbstractInstruction", errorMsg, e);
@@ -570,7 +569,7 @@ export class InstrumentReader {
               "ReaderErrorMessages/ClefOctaveError",
               "Invalid clef octave found -> using default clef octave."
             );
-            this.musicSheet.SheetErrors.pushTemp(errorMsg);
+            this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
             clefOctaveOffset = 0;
           }
 
@@ -583,7 +582,7 @@ export class InstrumentReader {
               "ReaderErrorMessages/ClefError",
               "Invalid clef found -> using default clef."
             );
-            this.musicSheet.SheetErrors.pushTemp(errorMsg);
+            this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
             staffNumber = 1;
           }
         }
@@ -603,7 +602,7 @@ export class InstrumentReader {
             "ReaderErrorMessages/KeyError",
             "Invalid key found -> set to default."
           );
-          this.musicSheet.SheetErrors.pushTemp(errorMsg);
+          this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
           key = 0;
           Logging.debug("InstrumentReader.addAbstractInstruction", errorMsg, ex);
         }
@@ -620,7 +619,7 @@ export class InstrumentReader {
             "ReaderErrorMessages/KeyError",
             "Invalid key found -> set to default."
           );
-          this.musicSheet.SheetErrors.pushTemp(errorMsg);
+          this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
           keyEnum = KeyEnum.major;
           Logging.debug("InstrumentReader.addAbstractInstruction", errorMsg, ex);
         }
@@ -693,7 +692,7 @@ export class InstrumentReader {
           }
         } catch (ex) {
           errorMsg = ITextTranslation.translateText("ReaderErrorMessages/RhythmError", "Invalid rhythm found -> set to default.");
-          this.musicSheet.SheetErrors.pushTemp(errorMsg);
+          this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
           num = 4;
           denom = 4;
           Logging.debug("InstrumentReader.addAbstractInstruction", errorMsg, ex);

src/MusicalScore/ScoreIO/MusicSheetReader.ts

@@ -50,6 +50,29 @@ export class MusicSheetReader /*implements IMusicSheetReader*/ {
     }
   }
 
+  public createMusicSheet(root: IXmlElement, path: string): MusicSheet {
+    try {
+      return this._createMusicSheet(root, path);
+    } catch (e) {
+      Logging.log("MusicSheetReader.CreateMusicSheet", e);
+    }
+  }
+
+  private _removeFromArray(list: any[], elem: any): void {
+    let i: number = list.indexOf(elem);
+    if (i !== -1) {
+      list.splice(i, 1);
+    }
+  }
+  // Trim from a string also newlines
+  private trimString(str: string): string {
+    return str.replace(/^\s+|\s+$/g, "");
+  }
+
+  private _lastElement<T>(list: T[]): T {
+    return list[list.length - 1];
+  }
+
   //public SetPhonicScoreInterface(phonicScoreInterface: IPhonicScoreInterface): void {
   //  this.phonicScoreInterface = phonicScoreInterface;
   //}
@@ -76,106 +99,91 @@ export class MusicSheetReader /*implements IMusicSheetReader*/ {
   //  }
   //  return sheetObject;
   //}
-  public createMusicSheet(root: IXmlElement, path: string): MusicSheet {
-    try {
-      return this._createMusicSheet(root, path);
-    } catch (e) {
-      Logging.log("MusicSheetReader.CreateMusicSheet", e);
-    }
-
-  }
-  //public CreateIMusicSheet(root: IXmlElement, path: string): IMusicSheet {
-  //  return this.createMusicSheet(root, path);
-  //}
-
-  private _removeFromArray(list: any[], elem: any): void {
-    let i: number = list.indexOf(elem);
-    if (i !== -1) {
-      list.splice(i, 1);
-    }
-  }
 
   private _createMusicSheet(root: IXmlElement, path: string): MusicSheet {
     let instrumentReaders: InstrumentReader[] = [];
     let sourceMeasureCounter: number = 0;
     this.musicSheet = new MusicSheet();
     this.musicSheet.Path = path;
-    try {
-      if (root !== undefined) {
-        this.pushSheetLabels(root, path);
-        let partlistNode: IXmlElement = root.element("part-list");
-        if (partlistNode !== undefined) {
-          let partInst: IXmlElement[] = root.elements("part");
-          let partList: IXmlElement[] = partlistNode.elements();
-          this.initializeReading(partList, partInst, instrumentReaders);
-          let couldReadMeasure: boolean = true;
-          this.currentFraction = new Fraction(0, 1);
-          let guitarPro: boolean = false;
-          let encoding: IXmlElement = root.element("identification");
-          if (encoding !== undefined) {
-            encoding = encoding.element("encoding");
-          }
-          if (encoding !== undefined) {
-            encoding = encoding.element("software");
-          }
-          if (encoding !== undefined && encoding.value === "Guitar Pro 5") {
-            guitarPro = true;
-          }
-          while (couldReadMeasure) {
-            if (this.currentMeasure !== undefined && this.currentMeasure.endsPiece) {
-              sourceMeasureCounter = 0;
-            }
-            this.currentMeasure = new SourceMeasure(this.completeNumberOfStaves);
-            for (let instrumentReader of instrumentReaders) {
-              try {
-                couldReadMeasure = instrumentReader.readNextXmlMeasure(this.currentMeasure, this.currentFraction, guitarPro);
-              } catch (e) {
-                let errorMsg: string = ITextTranslation.translateText("ReaderErrorMessages/InstrumentError", "Error while reading instruments.");
-                throw new MusicSheetReadingException(errorMsg, e);
-              }
+    if (root === undefined) {
+      throw new MusicSheetReadingException("Undefined root element");
+    }
+    this.pushSheetLabels(root, path);
+    let partlistNode: IXmlElement = root.element("part-list");
+    if (partlistNode === undefined) {
+      throw new MusicSheetReadingException("Undefined partListNode");
+    }
 
-            }
-            if (couldReadMeasure) {
-              this.musicSheet.addMeasure(this.currentMeasure);
-              this.checkIfRhythmInstructionsAreSetAndEqual(instrumentReaders);
-              this.checkSourceMeasureForundefinedEntries();
-              this.setSourceMeasureDuration(instrumentReaders, sourceMeasureCounter);
-              MusicSheetReader.doCalculationsAfterDurationHasBeenSet(instrumentReaders);
-              this.currentMeasure.AbsoluteTimestamp = this.currentFraction.clone();
-              this.musicSheet.SheetErrors.TransferTempErrorsToDict(this.currentMeasure.MeasureNumber);
-              this.currentFraction.Add(this.currentMeasure.Duration);
-              this.previousMeasure = this.currentMeasure;
-            }
-          }
+    let partInst: IXmlElement[] = root.elements("part");
+    console.log(partInst.length + " parts");
+    let partList: IXmlElement[] = partlistNode.elements();
+    Logging.debug("Starting initializeReading");
+    this.initializeReading(partList, partInst, instrumentReaders);
+    Logging.debug("Done initializeReading");
+    let couldReadMeasure: boolean = true;
+    this.currentFraction = new Fraction(0, 1);
+    let guitarPro: boolean = false;
+    let encoding: IXmlElement = root.element("identification");
+    if (encoding !== undefined) {
+      encoding = encoding.element("encoding");
+    }
+    if (encoding !== undefined) {
+      encoding = encoding.element("software");
+    }
+    if (encoding !== undefined && encoding.value === "Guitar Pro 5") {
+      guitarPro = true;
+    }
+
+    while (couldReadMeasure) {
+      Logging.debug("+couldReadMeasure");
+      if (this.currentMeasure !== undefined && this.currentMeasure.endsPiece) {
+        sourceMeasureCounter = 0;
+      }
+      this.currentMeasure = new SourceMeasure(this.completeNumberOfStaves);
+      for (let instrumentReader of instrumentReaders) {
+        try {
+          couldReadMeasure = couldReadMeasure && instrumentReader.readNextXmlMeasure(this.currentMeasure, this.currentFraction, guitarPro);
+        } catch (e) {
+          let errorMsg: string = ITextTranslation.translateText("ReaderErrorMessages/InstrumentError", "Error while reading instruments.");
+          throw new MusicSheetReadingException(errorMsg, e);
         }
+
+      }
+      if (couldReadMeasure) {
+        //Logging.debug("couldReadMeasure: 1");
+        this.musicSheet.addMeasure(this.currentMeasure);
+        //Logging.debug("couldReadMeasure: 2");
+        this.checkIfRhythmInstructionsAreSetAndEqual(instrumentReaders);
+        //Logging.debug("couldReadMeasure: 3");
+        this.checkSourceMeasureForundefinedEntries();
+        //Logging.debug("couldReadMeasure: 4");
+        this.setSourceMeasureDuration(instrumentReaders, sourceMeasureCounter);
+        //Logging.debug("couldReadMeasure: 5");
+        MusicSheetReader.doCalculationsAfterDurationHasBeenSet(instrumentReaders);
+        //Logging.debug("couldReadMeasure: 6");
+        this.currentMeasure.AbsoluteTimestamp = this.currentFraction.clone();
+        this.musicSheet.SheetErrors.finalizeMeasure(this.currentMeasure.MeasureNumber);
+        this.currentFraction.Add(this.currentMeasure.Duration);
+        this.previousMeasure = this.currentMeasure;
+        //Logging.debug("couldReadMeasure: 7");
       }
-      //if (this.repetitionInstructionReader !== undefined) {
-      //  this.repetitionInstructionReader.removeRedundantInstructions();
-      //  if (this.repetitionCalculator !== undefined) {
-      //    this.repetitionCalculator.calculateRepetitions(this.musicSheet, this.repetitionInstructionReader.RepetitionInstructions);
-      //  }
-      //}
-      this.musicSheet.checkForInstrumentWithNoVoice();
-      this.musicSheet.fillStaffList();
-      //this.musicSheet.DefaultStartTempoInBpm = this.musicSheet.SheetPlaybackSetting.BeatsPerMinute;
-      //for (let idx: number = 0, len: number = this.afterSheetReadingModules.length; idx < len; ++idx) {
-      //  let afterSheetReadingModule: IAfterSheetReadingModule = this.afterSheetReadingModules[idx];
-      //  afterSheetReadingModule.calculate(this.musicSheet);
-      //}
-    } catch (e) {
-      Logging.log("MusicSheetReader._createMusicSheet", e);
     }
 
-    return this.musicSheet;
-  }
+    //if (this.repetitionInstructionReader !== undefined) {
+    //  this.repetitionInstructionReader.removeRedundantInstructions();
+    //  if (this.repetitionCalculator !== undefined) {
+    //    this.repetitionCalculator.calculateRepetitions(this.musicSheet, this.repetitionInstructionReader.RepetitionInstructions);
+    //  }
+    //}
+    this.musicSheet.checkForInstrumentWithNoVoice();
+    this.musicSheet.fillStaffList();
+    //this.musicSheet.DefaultStartTempoInBpm = this.musicSheet.SheetPlaybackSetting.BeatsPerMinute;
+    //for (let idx: number = 0, len: number = this.afterSheetReadingModules.length; idx < len; ++idx) {
+    //  let afterSheetReadingModule: IAfterSheetReadingModule = this.afterSheetReadingModules[idx];
+    //  afterSheetReadingModule.calculate(this.musicSheet);
+    //}
 
-  // Trim from a string also newlines
-  private trimString(str: string): string {
-    return str.replace(/^\s+|\s+$/g, "");
-  }
-
-  private _lastElement<T>(list: T[]): T {
-    return list[list.length - 1];
+    return this.musicSheet;
   }
 
   private initializeReading(
@@ -190,35 +198,30 @@ export class MusicSheetReader /*implements IMusicSheetReader*/ {
       this.previousMeasure = undefined;
     }
     let counter: number = 0;
-    let partInstArr: IXmlElement[] = partInst.slice();
-    for (let idx: number = 0, len: number = partInstArr.length; idx < len; ++idx) {
-      let node: IXmlElement = partInstArr[idx];
-      if (node.attribute("id") !== undefined) {
-        let idNode: IXmlAttribute = node.attribute("id");
-        if (idNode !== undefined) {
-          let partInstId: string = idNode.value;
-          let currentInstrument: Instrument = instrumentDict[partInstId];
-          let xmlMeasureList: IXmlElement[] = node.elements("measure");
-          let instrumentNumberOfStaves: number = 1;
-          try {
-            instrumentNumberOfStaves = this.getInstrumentNumberOfStavesFromXml(node);
-          } catch (err) {
-            let errorMsg: string = ITextTranslation.translateText(
+    for (let node of partInst) {
+      let idNode: IXmlAttribute = node.attribute("id");
+      if (idNode !== undefined) {
+        let currentInstrument: Instrument = instrumentDict[idNode.value];
+        let xmlMeasureList: IXmlElement[] = node.elements("measure");
+        console.log("Measures; ", xmlMeasureList.length);
+        let instrumentNumberOfStaves: number = 1;
+        try {
+          instrumentNumberOfStaves = this.getInstrumentNumberOfStavesFromXml(node);
+        } catch (err) {
+          let errorMsg: string = ITextTranslation.translateText(
               "ReaderErrorMessages/InstrumentStavesNumberError",
               "Invalid number of staves at instrument: "
-            );
-            this.musicSheet.SheetErrors.push(errorMsg + currentInstrument.Name);
-            continue;
-          }
-
-          currentInstrument.createStaves(instrumentNumberOfStaves);
-          let instrumentReader: InstrumentReader = new InstrumentReader(this.repetitionInstructionReader, xmlMeasureList, currentInstrument);
-          instrumentReaders.push(instrumentReader);
-          //if (this.repetitionInstructionReader !== undefined) {
-          //  this.repetitionInstructionReader.XmlMeasureList[counter] = xmlMeasureList;
-          //}
-          counter++;
+          );
+          this.musicSheet.SheetErrors.push(errorMsg + currentInstrument.Name);
+          continue;
         }
+
+        currentInstrument.createStaves(instrumentNumberOfStaves);
+        instrumentReaders.push(new InstrumentReader(this.repetitionInstructionReader, xmlMeasureList, currentInstrument));
+        //if (this.repetitionInstructionReader !== undefined) {
+        //  this.repetitionInstructionReader.XmlMeasureList[counter] = xmlMeasureList;
+        //}
+        counter++;
       }
     }
   }
@@ -356,7 +359,7 @@ export class MusicSheetReader /*implements IMusicSheetReader*/ {
           if (!this.staffMeasureIsEmpty(firstStaffIndexOfInstrument + staffIndex)) {
             this.currentMeasure.setErrorInStaffMeasure(firstStaffIndexOfInstrument + staffIndex, true);
             let errorMsg: string = ITextTranslation.translateText("ReaderErrorMessages/MissingNotesError", "Given Notes don't correspond to measure duration.");
-            this.musicSheet.SheetErrors.pushTemp(errorMsg);
+            this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
           }
         }
       }
@@ -746,9 +749,7 @@ export class MusicSheetReader /*implements IMusicSheetReader*/ {
   }
   private getCompleteNumberOfStavesFromXml(partInst: IXmlElement[]): number {
     let num: number = 0;
-    let partInstArr: IXmlElement[] = partInst;
-    for (let idx: number = 0, len: number = partInstArr.length; idx < len; ++idx) {
-      let partNode: IXmlElement = partInstArr[idx];
+    for (let partNode of partInst) {
       let xmlMeasureList: IXmlElement[] = partNode.elements("measure");
       if (xmlMeasureList !== undefined) {
         let xmlMeasure: IXmlElement = xmlMeasureList[0];
@@ -765,7 +766,7 @@ export class MusicSheetReader /*implements IMusicSheetReader*/ {
         }
       }
     }
-    if (num <= 0) {
+    if (isNaN(num) || num <= 0) {
       let errorMsg: string = ITextTranslation.translateText(
         "ReaderErrorMessages/StaffError", "Invalid number of staves."
       );
@@ -788,7 +789,7 @@ export class MusicSheetReader /*implements IMusicSheetReader*/ {
         num = parseInt(staves.value, 10);
       }
     }
-    if (num <= 0) {
+    if (isNaN(num) || num <= 0) {
       let errorMsg: string = ITextTranslation.translateText(
         "ReaderErrorMessages/StaffError", "Invalid number of Staves."
       );

src/MusicalScore/ScoreIO/VoiceGenerator.ts

@@ -134,7 +134,7 @@ export class VoiceGenerator {
             let errorMsg: string = ITextTranslation.translateText(
                 "ReaderErrorMessages/NoteError", "Ignored erroneous Note."
             );
-            this.musicSheet.SheetErrors.pushTemp(errorMsg);
+            this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
         }
 
         return this.currentNote;
@@ -284,7 +284,7 @@ export class VoiceGenerator {
                                         "ReaderErrorMessages/NotePitchError",
                                         "Invalid pitch while reading note."
                                     );
-                                    this.musicSheet.SheetErrors.pushTemp(errorMsg);
+                                    this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
                                     throw new MusicSheetReadingException(errorMsg, undefined);
                                 }
                             } else if (pitchElement.name === "alter") {
@@ -293,7 +293,7 @@ export class VoiceGenerator {
                                     let errorMsg: string = ITextTranslation.translateText(
                                         "ReaderErrorMessages/NoteAlterationError", "Invalid alteration while reading note."
                                     );
-                                    this.musicSheet.SheetErrors.pushTemp(errorMsg);
+                                    this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
                                     throw new MusicSheetReadingException(errorMsg, undefined);
                                 }
 
@@ -303,7 +303,7 @@ export class VoiceGenerator {
                                     let errorMsg: string = ITextTranslation.translateText(
                                         "ReaderErrorMessages/NoteOctaveError", "Invalid octave value while reading note."
                                     );
-                                    this.musicSheet.SheetErrors.pushTemp(errorMsg);
+                                    this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
                                     throw new MusicSheetReadingException(errorMsg, undefined);
                                 }
                             }
@@ -420,7 +420,7 @@ export class VoiceGenerator {
             let errorMsg: string = ITextTranslation.translateText(
                 "ReaderErrorMessages/BeamError", "Error while reading beam."
             );
-            this.musicSheet.SheetErrors.pushTemp(errorMsg);
+            this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
             throw new MusicSheetReadingException("", e);
         }
 
@@ -474,7 +474,7 @@ export class VoiceGenerator {
                     let errorMsg: string = ITextTranslation.translateText(
                         "ReaderErrorMessages/NoteDurationError", "Invalid note duration."
                     );
-                    this.musicSheet.SheetErrors.pushTemp(errorMsg);
+                    this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
                     throw new MusicSheetReadingException(errorMsg, e);
                 }
 
@@ -537,7 +537,7 @@ export class VoiceGenerator {
                                 let errorMsg: string = ITextTranslation.translateText(
                                     "ReaderErrorMessages/TupletNoteDurationError", "Invalid tuplet note duration."
                                 );
-                                this.musicSheet.SheetErrors.pushTemp(errorMsg);
+                                this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
                                 throw new MusicSheetReadingException(errorMsg, undefined);
                             }
 
@@ -602,7 +602,7 @@ export class VoiceGenerator {
                             let errorMsg: string = ITextTranslation.translateText(
                                 "ReaderErrorMessages/TupletNoteDurationError", "Invalid tuplet note duration."
                             );
-                            this.musicSheet.SheetErrors.pushTemp(errorMsg);
+                            this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
                             throw new MusicSheetReadingException(errorMsg);
                         }
 
@@ -664,7 +664,7 @@ export class VoiceGenerator {
                 let errorMsg: string = ITextTranslation.translateText(
                     "ReaderErrorMessages/TupletNumberError", "Invalid tuplet number."
                 );
-                this.musicSheet.SheetErrors.pushTemp(errorMsg);
+                this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
                 throw ex;
             }
 
@@ -771,7 +771,7 @@ export class VoiceGenerator {
                         }
                     } catch (err) {
                         let errorMsg: string = ITextTranslation.translateText("ReaderErrorMessages/TieError", "Error while reading tie.");
-                        this.musicSheet.SheetErrors.pushTemp(errorMsg);
+                        this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
                     }
 
                 }
@@ -854,7 +854,7 @@ export class VoiceGenerator {
                     return this.getNoteDurationFromType(type);
                 } catch (e) {
                     let errorMsg: string = ITextTranslation.translateText("ReaderErrorMessages/NoteDurationError", "Invalid note duration.");
-                    this.musicSheet.SheetErrors.pushTemp(errorMsg);
+                    this.musicSheet.SheetErrors.pushMeasureError(errorMsg);
                     throw new MusicSheetReadingException("", e);
                 }
 

test/MusicalScore/Calculation/MeasureSizeCalculator.ts

@@ -77,7 +77,7 @@ describe("Measure Size Calculator Tests", () => {
           clef.setStave(stave2);
           let bb: Vex.Flow.BoundingBox =
               MeasureSizeCalculator.getClefBoundingBox(clef);
-          console.log(bb);
+          //console.log(bb);
           ctx.rect(bb.getX(), bb.getY(), bb.getW(), bb.getH());
           ctx.stroke();
         }

test/MusicalScore/ScoreIO/MusicSheetReader.ts

@@ -27,10 +27,20 @@ describe("Music Sheet Reader Tests", () => {
         chai.expect(documentElement.elements("score-partwise").length).to.equal(1);
         let root: IXmlElement = documentElement.element("score-partwise");
         chai.expect(root).to.not.be.undefined;
+        chai.expect(root.elements("part").length).to.equal(2);
+        chai.expect(root.element("part").elements("measure").length).to.equal(38);
         let sheet: MusicSheet = reader.createMusicSheet(root, path);
         chai.expect(sheet.TitleString).to.equal("Sonatina Op.36 No 1 Teil 1 Allegro");
         chai.expect(sheet.ComposerString).to.equal("Muzio Clementi");
-        console.log("Sheet Object:", sheet);
+        //console.log("Sheet Object:", sheet);
+        console.log(reader.CompleteNumberOfStaves);
+        console.log(sheet.SheetErrors);
+        //console.log(container);
+        chai.expect(sheet.Instruments.length).to.equal(2);
+        chai.expect(sheet.Instruments[0].Name).to.equal("Piano (right)");
+        chai.expect(sheet.Instruments[1].Name).to.equal("Piano (left)");
+        chai.expect(sheet.InstrumentalGroups.length).to.equal(2);
+        chai.expect(sheet.SourceMeasures.length).to.equal(38);
         done();
     });