public TimeSignature(TimeSignatureType sType, uint beats, uint beatType)
{
type = MusicSymbolType.TimeSignature;
NumberOfBeats = beats;
TypeOfBeats = beatType;
SignatureType = sType;
}
public TimeSignature(TimeSignatureType sType, uint beats, uint beatType)
{
type = MusicalSymbolType.TimeSignature;
numberOfBeats = beats;
typeOfBeats = beatType;
signatureType = sType;
}
public override void ParseElement(MusicXmlParserState state, Staff staff, XElement element)
{
int numberOfBeats = 4;
int beatType = 4;
TimeSignatureType sType = TimeSignatureType.Numbers;
element.IfElement("beats").HasValue <int>().Then(v => numberOfBeats = v);
element.IfElement("beat-type").HasValue <int>().Then(v => beatType = v);
element.IfAttribute("symbol").HasValue(new Dictionary <string, TimeSignatureType> {
{ "common", TimeSignatureType.Common },
{ "cut", TimeSignatureType.Cut }
}).Then(s => sType = s);
if (staff.Part != null && staff.Part.Staves.Any()) //If part contains many staves, add to all staves
{
foreach (var s in staff.Part.Staves)
{
var t = new TimeSignature(sType, numberOfBeats, beatType);
s.Elements.Add(t);
}
}
else
{
var t = new TimeSignature(sType, numberOfBeats, beatType);
staff.Elements.Add(t);
}
}
public TimeSignature(TimeSignatureType sType, int beats, int beatType)
{
numberValue = new Proportion(beats, beatType);
signatureType = sType;
}
public static bool ParseXml(IMusicalNotesViewer viewer) //Returns true if there are no errors
{
viewer.ClearMusicalIncipit();
XmlNodeList measures = viewer.XmlIncipit.SelectNodes("/score-partwise/part/measure");
int skipMeasures = 0;
string partID = "";
bool firstLoop = true;
int currentTempo = 120;
int currentDynamics = 80;
try
{
foreach (XmlNode measure in measures)
{
bool barlineAlreadyAdded = false;
if (measure.ParentNode.Name == "part") //Don't take the other voices than the upper into account / Nie uwzględniaj innych głosów niż górny
{
if (!firstLoop)
{
if (measure.ParentNode.Attributes["id"].Value != partID)
{
break;
}
}
else
{
partID = measure.ParentNode.Attributes["id"].Value;
}
}
if (skipMeasures > 0)
{
skipMeasures--; continue;
}
if (measure.HasChildNodes == false)
{
continue;
}
foreach (XmlNode symbol in measure.ChildNodes)
{
if (symbol.HasChildNodes == false)
{
continue;
}
if (symbol.Name == "attributes")
{
foreach (XmlNode attribute in symbol.ChildNodes)
{
if (attribute.Name == "clef")
{
ClefType typeOfClef = ClefType.GClef;
int line = 1;
foreach (XmlNode clefAttribute in attribute.ChildNodes)
{
if (clefAttribute.Name == "sign")
{
if (clefAttribute.InnerText.ToUpper() == "G")
{
typeOfClef = ClefType.GClef;
}
else if (clefAttribute.InnerText.ToUpper() == "C")
{
typeOfClef = ClefType.CClef;
}
else if (clefAttribute.InnerText.ToUpper() == "F")
{
typeOfClef = ClefType.FClef;
}
else
{
throw (new Exception("Unknown clef"));
}
}
if (clefAttribute.Name == "line")
{
line = Convert.ToInt16(clefAttribute.InnerText);
}
}
viewer.AddMusicalSymbol(new Clef(typeOfClef, line));
}
if (attribute.Name == "time")
{
uint numberOfBeats = 4;
uint beatType = 4;
TimeSignatureType sType = TimeSignatureType.Numbers;
foreach (XmlNode timeAttribute in attribute.ChildNodes)
{
if (timeAttribute.Name == "beats")
{
numberOfBeats = Convert.ToUInt32(timeAttribute.InnerText);
}
if (timeAttribute.Name == "beat-type")
{
beatType = Convert.ToUInt32(timeAttribute.InnerText);
}
}
if (attribute.Attributes.Count > 0)
{
foreach (XmlAttribute a in attribute.Attributes)
{
if (a.Name == "symbol")
{
if (a.Value == "common")
{
sType = TimeSignatureType.Common;
}
else if (a.Value == "cut")
{
sType = TimeSignatureType.Cut;
}
}
}
}
viewer.AddMusicalSymbol(new TimeSignature(sType, numberOfBeats, beatType));
}
if (attribute.Name == "key")
{
foreach (XmlNode keyAttribute in attribute.ChildNodes)
{
if (keyAttribute.Name == "fifths")
{
viewer.AddMusicalSymbol(new Key(Convert.ToInt16(keyAttribute.InnerText)));
}
}
}
if (attribute.Name == "measure-style")
{
foreach (XmlNode measureStyleAttribute in attribute.ChildNodes)
{
if (measureStyleAttribute.Name == "multiple-rest")
{
skipMeasures = Convert.ToInt32(measureStyleAttribute.InnerText) - 1;
}
}
}
}
}
else if (symbol.Name == "sound")
{
if (((XmlElement)symbol).HasAttribute("tempo"))
{
currentTempo = Convert.ToInt32(symbol.Attributes["tempo"].Value);
}
if (((XmlElement)symbol).HasAttribute("dynamics"))
{
currentDynamics = Convert.ToInt32(symbol.Attributes["dynamics"].Value);
}
}
else if (symbol.Name == "direction")
{
foreach (XmlNode direction in symbol.ChildNodes)
{
if (direction.Name == "sound")
{
if (((XmlElement)direction).HasAttribute("tempo"))
{
currentTempo = Convert.ToInt32(direction.Attributes["tempo"].Value);
}
if (((XmlElement)direction).HasAttribute("dynamics"))
{
currentDynamics = Convert.ToInt32(direction.Attributes["dynamics"].Value);
}
}
if (direction.Name == "direction-type")
{
foreach (XmlNode directionType in direction.ChildNodes)
{
if (directionType.Name == "dynamics")
{
DirectionPlacementType placement = DirectionPlacementType.Above;
int defaultY = 0;
string text = "";
if (((XmlElement)directionType).HasAttribute("default-y"))
{
defaultY = Convert.ToInt32(directionType.Attributes["default-y"].Value);
placement = DirectionPlacementType.Custom;
}
if (((XmlElement)directionType).HasAttribute("placement") &&
placement != DirectionPlacementType.Custom)
{
if (directionType.Attributes["placement"].Value == "above")
{
placement = DirectionPlacementType.Above;
}
else if (directionType.Attributes["placement"].Value == "below")
{
placement = DirectionPlacementType.Below;
}
}
foreach (XmlNode dynamicsType in directionType.ChildNodes)
{
text = dynamicsType.Name;
}
Direction dir = new Direction();
dir.DefaultY = defaultY;
dir.Placement = placement;
dir.Text = text;
viewer.AddMusicalSymbol(dir);
}
}
}
}
}
else if (symbol.Name == "note")
{
int octave = 0;
int alter = 0;
string step = "C";
bool isRest = false;
int numberOfDots = 0;
MusicalSymbolDuration duration = MusicalSymbolDuration.Whole;
NoteStemDirection stemDirection = NoteStemDirection.Up;
NoteTieType tieType = NoteTieType.None;
TupletType tuplet = TupletType.None;
List <NoteBeamType> beamList = new List <NoteBeamType>();
List <LyricsType> lyric = new List <LyricsType>();
List <string> lyricText = new List <string>();
ArticulationPlacementType articulationPlacement = ArticulationPlacementType.Below;
ArticulationType articulation = ArticulationType.None;
bool hasNatural = false;
bool isGraceNote = false;
bool isChordElement = false;
bool hasFermataSign = false;
float stemDefaultY = 28;
bool customStemEndPosition = false;
int tremoloLevel = 0;
NoteSlurType slur = NoteSlurType.None;
NoteTrillMark trillMark = NoteTrillMark.None;
int voice = 1;
foreach (XmlNode noteAttribute in symbol.ChildNodes)
{
if (noteAttribute.Name == "pitch")
{
foreach (XmlNode pitchAttribute in noteAttribute.ChildNodes)
{
if (pitchAttribute.Name == "step")
{
step = pitchAttribute.InnerText;
}
else if (pitchAttribute.Name == "octave")
{
octave = Convert.ToInt16(pitchAttribute.InnerText);
}
else if (pitchAttribute.Name == "alter")
{
alter = Convert.ToInt16(pitchAttribute.InnerText);
}
}
}
else if (noteAttribute.Name == "voice")
{
voice = Convert.ToInt32(noteAttribute.InnerText);
}
else if (noteAttribute.Name == "grace")
{
isGraceNote = true;
}
else if (noteAttribute.Name == "chord")
{
isChordElement = true;
}
else if (noteAttribute.Name == "type")
{
if (noteAttribute.InnerText == "whole")
{
duration = MusicalSymbolDuration.Whole;
}
else if (noteAttribute.InnerText == "half")
{
duration = MusicalSymbolDuration.Half;
}
else if (noteAttribute.InnerText == "quarter")
{
duration = MusicalSymbolDuration.Quarter;
}
else if (noteAttribute.InnerText == "eighth")
{
duration = MusicalSymbolDuration.Eighth;
}
else if (noteAttribute.InnerText == "16th")
{
duration = MusicalSymbolDuration.Sixteenth;
}
else if (noteAttribute.InnerText == "32nd")
{
duration = MusicalSymbolDuration.d32nd;
}
else if (noteAttribute.InnerText == "64th")
{
duration = MusicalSymbolDuration.d64th;
}
else if (noteAttribute.InnerText == "128th")
{
duration = MusicalSymbolDuration.d128th;
}
}
else if (noteAttribute.Name == "accidental")
{
if (noteAttribute.InnerText == "natural")
{
hasNatural = true;
}
}
else if (noteAttribute.Name == "tie")
{
if (noteAttribute.Attributes["type"].Value == "start")
{
if (tieType == NoteTieType.Stop)
{
tieType = NoteTieType.StopAndStartAnother;
}
else
{
tieType = NoteTieType.Start;
}
}
else
{
tieType = NoteTieType.Stop;
}
}
else if (noteAttribute.Name == "rest")
{
isRest = true;
}
else if (noteAttribute.Name == "dot")
{
numberOfDots++;
}
else if (noteAttribute.Name == "stem")
{
if (noteAttribute.InnerText == "down")
{
stemDirection = NoteStemDirection.Down;
}
else
{
stemDirection = NoteStemDirection.Up;
}
foreach (XmlAttribute xa in noteAttribute.Attributes)
{
if (xa.Name == "default-y")
{
stemDefaultY = float.Parse(xa.Value.Replace('.',
Convert.ToChar(NumberFormatInfo.CurrentInfo.CurrencyDecimalSeparator)));
customStemEndPosition = true;
}
}
}
else if (noteAttribute.Name == "beam")
{
if (noteAttribute.InnerText == "begin")
{
beamList.Add(NoteBeamType.Start);
}
else if (noteAttribute.InnerText == "end")
{
beamList.Add(NoteBeamType.End);
}
else if (noteAttribute.InnerText == "continue")
{
beamList.Add(NoteBeamType.Continue);
}
else if (noteAttribute.InnerText == "forward hook")
{
beamList.Add(NoteBeamType.ForwardHook);
}
else if (noteAttribute.InnerText == "backward hook")
{
beamList.Add(NoteBeamType.BackwardHook);
}
}
else if (noteAttribute.Name == "notations")
{
foreach (XmlNode notationAttribute in noteAttribute.ChildNodes)
{
if (notationAttribute.Name == "tuplet")
{
if (notationAttribute.Attributes["type"].Value == "start")
{
tuplet = TupletType.Start;
}
else if (notationAttribute.Attributes["type"].Value == "stop")
{
tuplet = TupletType.Stop;
}
}
if (notationAttribute.Name == "dynamics")
{
DirectionPlacementType placement = DirectionPlacementType.Above;
int defaultY = 0;
string text = "";
if (((XmlElement)notationAttribute).HasAttribute("default-y"))
{
defaultY = Convert.ToInt32(notationAttribute.Attributes["default-y"].Value);
placement = DirectionPlacementType.Custom;
}
if (((XmlElement)notationAttribute).HasAttribute("placement") &&
placement != DirectionPlacementType.Custom)
{
if (notationAttribute.Attributes["placement"].Value == "above")
{
placement = DirectionPlacementType.Above;
}
else if (notationAttribute.Attributes["placement"].Value == "below")
{
placement = DirectionPlacementType.Below;
}
}
foreach (XmlNode dynamicsType in notationAttribute.ChildNodes)
{
text = dynamicsType.Name;
}
Direction dir = new Direction();
dir.DefaultY = defaultY;
dir.Placement = placement;
dir.Text = text;
viewer.AddMusicalSymbol(dir);
}
else if (notationAttribute.Name == "articulations")
{
foreach (XmlNode articulationAttribute in notationAttribute.ChildNodes)
{
if (articulationAttribute.Name == "staccato")
{
articulation = ArticulationType.Staccato;
}
else if (articulationAttribute.Name == "accent")
{
articulation = ArticulationType.Accent;
}
if (articulationAttribute.Attributes["placement"].Value == "above")
{
articulationPlacement = ArticulationPlacementType.Above;
}
else if (articulationAttribute.Attributes["placement"].Value == "below")
{
articulationPlacement = ArticulationPlacementType.Below;
}
}
}
else if (notationAttribute.Name == "ornaments")
{
foreach (XmlNode ornamentAttribute in notationAttribute.ChildNodes)
{
if (ornamentAttribute.Name == "trill-mark")
{
if (ornamentAttribute.Attributes["placement"].Value == "above")
{
trillMark = NoteTrillMark.Above;
}
else if (ornamentAttribute.Attributes["placement"].Value == "below")
{
trillMark = NoteTrillMark.Below;
}
}
else if (ornamentAttribute.Name == "tremolo")
{
tremoloLevel = Convert.ToInt32(ornamentAttribute.InnerText);
}
}
}
else if (notationAttribute.Name == "slur")
{
if ((Convert.ToInt32(notationAttribute.Attributes["number"].Value)) != 1)
{
continue;
}
if (notationAttribute.Attributes["type"].Value == "start")
{
slur = NoteSlurType.Start;
}
else if (notationAttribute.Attributes["type"].Value == "stop")
{
slur = NoteSlurType.Stop;
}
}
else if (notationAttribute.Name == "fermata")
{
hasFermataSign = true;
}
else if (notationAttribute.Name == "sound")
{
if (((XmlElement)notationAttribute).HasAttribute("dynamics"))
{
currentDynamics = Convert.ToInt32(notationAttribute.Attributes["dynamics"].Value);
}
}
}
}
else if (noteAttribute.Name == "lyric")
{
foreach (XmlNode lyricAttribute in noteAttribute.ChildNodes)
{
if (lyricAttribute.Name == "syllabic")
{
if (lyricAttribute.InnerText == "begin")
{
lyric.Add(LyricsType.Begin);
}
else if (lyricAttribute.InnerText == "middle")
{
lyric.Add(LyricsType.Middle);
}
else if (lyricAttribute.InnerText == "end")
{
lyric.Add(LyricsType.End);
}
else if (lyricAttribute.InnerText == "single")
{
lyric.Add(LyricsType.Single);
}
}
else if (lyricAttribute.Name == "text")
{
lyricText.Add(lyricAttribute.InnerText);
}
}
}
}
if (beamList.Count == 0)
{
beamList.Add(NoteBeamType.Single);
}
if (!isRest)
{
Note nt = new Note(step, alter, octave, duration, stemDirection, tieType, beamList);
nt.NumberOfDots = numberOfDots;
nt.Tuplet = tuplet;
nt.Lyrics = lyric;
nt.LyricTexts = lyricText;
nt.Articulation = articulation;
nt.ArticulationPlacement = articulationPlacement;
nt.HasNatural = hasNatural;
nt.IsGraceNote = isGraceNote;
nt.IsChordElement = isChordElement;
nt.StemDefaultY = stemDefaultY;
nt.CustomStemEndPosition = customStemEndPosition;
nt.CurrentTempo = currentTempo;
nt.TrillMark = trillMark;
nt.Slur = slur;
nt.HasFermataSign = hasFermataSign;
nt.TremoloLevel = tremoloLevel;
nt.Voice = voice;
nt.Dynamics = currentDynamics;
viewer.AddMusicalSymbol(nt);
}
else
{
Rest rt = new Rest(duration);
rt.NumberOfDots = numberOfDots;
rt.Tuplet = tuplet;
rt.MultiMeasure = skipMeasures + 1;
rt.CurrentTempo = currentTempo;
rt.HasFermataSign = hasFermataSign;
rt.Voice = voice;
viewer.AddMusicalSymbol(rt);
}
}
else if (symbol.Name == "barline")
{
Barline b = new Barline();
foreach (XmlNode barlineAttribute in symbol.ChildNodes)
{
if (barlineAttribute.Name == "repeat")
{
if (((XmlElement)barlineAttribute).HasAttribute("direction"))
{
if (barlineAttribute.Attributes["direction"].Value == "forward")
{
b.RepeatSign = RepeatSignType.Forward;
}
else if (barlineAttribute.Attributes["direction"].Value == "backward")
{
b.RepeatSign = RepeatSignType.Backward;
}
viewer.AddMusicalSymbol(b);
barlineAlreadyAdded = true;
}
}
}
}
}
if (!barlineAlreadyAdded)
{
viewer.AddMusicalSymbol(new Barline());
}
firstLoop = false;
}
}
catch
{
return(false);
}
return(true);
}
public TimeSignatureModel(NoteModel note)
{
TypeTS = TimeSignatureType.Note;
Note = note;
Segments = null;
}
public TimeSignatureModel(TimeSignatureModel[] segment)
{
TypeTS = TimeSignatureType.None;
Segments = segment;
Note = null;
}
public Staff AddTimeSignature(TimeSignatureType type, int beats, int beatType)
{
Elements.Add(new TimeSignature(type, beats, beatType));
return(this);
}
/// <summary>
/// Decodes timing points.
/// </summary>
private void DecodeTimingPoints(string line)
{
try
{
string[] splits = line.Split(',');
float time = ParseUtils.ParseFloat(splits[0].Trim()) + offset;
float beatLength = ParseUtils.ParseFloat(splits[1].Trim());
float speedMultiplier = beatLength < 0 ? 100 / -beatLength : 1;
TimeSignatureType timeSignature = TimeSignatureType.Quadruple;
if (splits.Length >= 3)
{
timeSignature = splits[2][0] == '0' ? TimeSignatureType.Quadruple : (TimeSignatureType)ParseUtils.ParseInt(splits[2]);
}
SampleType sampleType = defaultSampleType;
if (splits.Length >= 4)
{
sampleType = (SampleType)ParseUtils.ParseInt(splits[3]);
}
string sampleTypeString = sampleType.ToString().ToLowerInvariant();
if (sampleTypeString.Equals("none", StringComparison.Ordinal))
{
sampleTypeString = "normal";
}
int sampleVariation = 0;
if (splits.Length >= 5)
{
sampleVariation = ParseUtils.ParseInt(splits[4]);
}
float sampleVolume = defaultSampleVolume;
if (splits.Length >= 6)
{
sampleVolume = ParseUtils.ParseFloat(splits[5]) / 100f;
}
bool isTimingChange = true;
if (splits.Length >= 7)
{
isTimingChange = splits[6][0] == '1';
}
bool isHighlight = false;
if (splits.Length >= 8)
{
int flags = ParseUtils.ParseInt(splits[7]);
isHighlight = (flags & (int)EffectFlagType.IsHighlight) != 0;
}
if (isTimingChange)
{
var timingPoint = CreateTimingPoint();
timingPoint.Time = time;
timingPoint.BeatLength = beatLength;
timingPoint.TimeSignature = timeSignature;
AddTimingPoint(timingPoint);
}
AddDifficultyPoint(new DifficultyControlPoint()
{
Time = time,
SpeedMultiplier = speedMultiplier
});
AddEffectPoint(new EffectControlPoint()
{
Time = time,
IsHighlight = isHighlight
});
AddSamplePoint(new SampleControlPoint()
{
Time = time,
Sample = sampleTypeString,
Variant = sampleVariation,
Volume = sampleVolume,
});
}
catch (Exception e)
{
throw e;
}
}