private int FindStringForValue(Track track, Beat beat, int value)
{
// find strings which are already taken
var takenStrings = new FastDictionary<int, bool>();
for (int i = 0; i < beat.Notes.Count; i++)
{
var note = beat.Notes[i];
takenStrings[note.String] = true;
}
// find a string where the note matches into 0 to <upperbound>
// first try to find a string from 0-14 (more handy to play)
// then try from 0-20 (guitars with high frets)
// then unlimited
int[] steps = { 14, 20, int.MaxValue };
for (int i = 0; i < steps.Length; i++)
{
for (int j = 0; j < track.Tuning.Length; j++)
{
if (!takenStrings.ContainsKey(j))
{
var min = track.Tuning[j];
var max = track.Tuning[j] + steps[i];
if (value >= min && value <= max)
{
return track.Tuning.Length - j;
}
}
}
}
// will not happen
return 1;
}
public Beat FindBeat(Track track, int tick)
{
//
// some heuristics: try last found beat and it's next beat for lookup first
// try last beat or next beat of last beat first
if (_lastBeat != null && _lastBeat.NextBeat != null && _lastBeat.Voice.Bar.Track == track)
{
// check if tick is between _lastBeat and _lastBeat.nextBeat (still _lastBeat)
if (tick >= _lastBeat.AbsoluteStart && tick < _lastBeat.NextBeat.AbsoluteStart)
{
return _lastBeat;
}
// we need a upper-next beat to check the nextbeat range
// TODO: this logic does not apply properly for alternate endings and repeats, better "next beat" detection using
// "next bar" info
//if (_lastBeat.NextBeat.NextBeat != null && tick >= _lastBeat.NextBeat.AbsoluteStart && tick < _lastBeat.NextBeat.NextBeat.AbsoluteStart
// && !(_lastBeat.Index == _lastBeat.Voice.Beats.Count - 1 && _lastBeat.Voice.Bar.MasterBar.IsRepeatEnd))
//{
// _lastBeat = _lastBeat.NextBeat;
// return _lastBeat;
//}
}
//
// Global Search
// binary search within lookup
var lookup = FindBar(tick);
if (lookup == null) return null;
var masterBar = lookup.Bar;
var bar = track.Bars[masterBar.Index];
// remap tick to initial bar start
tick = (tick - lookup.Start + masterBar.Start);
// linear search beat within beats
Beat beat = null;
for (int i = 0, j = bar.Voices[0].Beats.Count; i < j; i++)
{
var b = bar.Voices[0].Beats[i];
// we search for the first beat which
// starts after the tick.
if (beat == null || b.AbsoluteStart <= tick)
{
beat = b;
}
else
{
break;
}
}
_lastBeat = beat;
return _lastBeat;
}
public BeamingHelper(Track track)
{
_track = track;
Beats = new FastList<Beat>();
_beatLineXPositions = new FastDictionary<int, BeatLinePositions>();
ShortestDuration = Duration.QuadrupleWhole;
}
private static Voice AddBarAndVoiceToTrack(Track track, Clef clef)
{
var bar = new Bar();
bar.Clef = clef;
track.AddBar(bar);
var voice = new Voice();
bar.AddVoice(voice);
return voice;
}
public static void CopyTo(Track src, Track dst)
{
dst.Capo = src.Capo;
dst.Index = src.Index;
dst.ShortName = src.ShortName;
dst.Tuning = Std.CloneArray(src.Tuning);
dst.Color.Raw = src.Color.Raw;
dst.IsPercussion = src.IsPercussion;
}
public Beat FindBeat(Track track, int tick)
{
//
// some heuristics: try last found beat and it's next beat for lookup first
// try last beat or next beat of last beat first
if (_lastBeat != null && _lastBeat.NextBeat != null && _lastBeat.Voice.Bar.Track == track)
{
// check if tick is between _lastBeat and _lastBeat.nextBeat (still _lastBeat)
if (tick >= _lastBeat.Start && tick < _lastBeat.NextBeat.Start)
{
return _lastBeat;
}
// we need a upper-next beat to check the nextbeat range
if (_lastBeat.NextBeat.NextBeat != null && tick >= _lastBeat.NextBeat.Start && tick < _lastBeat.NextBeat.NextBeat.Start)
{
_lastBeat = _lastBeat.NextBeat;
return _lastBeat;
}
}
//
// Global Search
// binary search within lookup
var lookup = FindBar(tick);
if (lookup == null) return null;
var masterBar = lookup.Bar;
var bar = track.Bars[masterBar.Index];
// remap tick to initial bar start
tick = (tick - lookup.Start + masterBar.Start);
// linear search beat within beats
Beat beat = null;
for (int i = 0, j = bar.Voices[0].Beats.Count; i < j; i++)
{
var b = bar.Voices[0].Beats[i];
// we search for the first beat which
// starts after the tick.
if (beat == null || b.Start <= tick)
{
beat = b;
}
else
{
break;
}
}
_lastBeat = beat;
return _lastBeat;
}
public TrackViewModel(Track track)
{
_track = track;
// general midi Programs
if (track.IsPercussion)
{
TrackType = TrackType.Drums;
}
else if (track.PlaybackInfo.Program >= 0 && track.PlaybackInfo.Program <= 6)
{
TrackType = TrackType.Piano;
}
else if (track.PlaybackInfo.Program >= 26 && track.PlaybackInfo.Program <= 31)
{
TrackType = TrackType.ElectricGuitar;
}
else if (track.PlaybackInfo.Program >= 32 && track.PlaybackInfo.Program <= 39)
{
TrackType = TrackType.BassGuitar;
}
else
{
TrackType = TrackType.Default;
}
// scan all bars if they have any note
_usedBars = new bool[track.Score.MasterBars.Count];
for (int s = 0; s < track.Staves.Count; s++)
{
var staff = track.Staves[s];
for (int barI = 0; barI < staff.Bars.Count; barI++)
{
Bar bar = staff.Bars[barI];
_usedBars[barI] = false;
for (int voiceI = 0; voiceI < bar.Voices.Count && (!_usedBars[barI]); voiceI++)
{
Voice voice = bar.Voices[voiceI];
for (int i = 0; i < voice.Beats.Count; i++)
{
var b = voice.Beats[i];
if (!b.IsRest)
{
_usedBars[barI] = true;
}
}
}
}
}
}
public void RenderMultiple(Track[] tracks)
{
if (tracks.Length == 0)
{
Score = null;
}
else
{
Score = tracks[0].Score;
}
Tracks = tracks;
Invalidate();
}
public TrackBarsControl(Track track)
{
SetStyle(ControlStyles.FixedHeight, true);
SetStyle(ControlStyles.DoubleBuffer, true);
SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
SetStyle(ControlStyles.ResizeRedraw, true);
SetStyle(ControlStyles.UserPaint, true);
base.DoubleBuffered = true;
base.BackColor = Color.FromArgb(93, 95, 94);
_usedBars = new bool[track.Score.MasterBars.Count];
for (int s = 0; s < track.Staves.Count; s++)
{
var staff = track.Staves[s];
for (int barI = 0; barI < staff.Bars.Count; barI++)
{
var bar = staff.Bars[barI];
_usedBars[barI] = false;
for (int voiceI = 0; voiceI < bar.Voices.Count && (!_usedBars[barI]); voiceI++)
{
Voice voice = bar.Voices[voiceI];
for (int i = 0; i < voice.Beats.Count; i++)
{
var b = voice.Beats[i];
if (!b.IsRest)
{
_usedBars[barI] = true;
}
}
}
}
}
PerformLayout();
Width = BlockSize.Width * _usedBars.Length;
Height = BlockSize.Height;
MinimumSize = BlockSize;
SetColor(track.Color);
}
private void ParseDiagramCollection(Track track, IXmlNode node)
{
var items = FindChildElement(node, "Items");
items.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "Item":
ParseDiagramItem(track, c);
break;
}
}
});
}
private void ParseTrackProperty(Track track, IXmlNode node)
{
var propertyName = node.Attributes.Get("name").Value;
switch (propertyName)
{
case "Tuning":
var tuningParts = GetValue(FindChildElement(node, "Pitches")).Split(' ');
var tuning = new int[tuningParts.Length];
for (int i = 0; i < tuning.Length; i++)
{
tuning[tuning.Length - 1 - i] = Std.ParseInt(tuningParts[i]);
}
track.Tuning = tuning;
break;
case "DiagramCollection":
ParseDiagramCollection(track, node);
break;
case "CapoFret":
track.Capo = Std.ParseInt(GetValue(FindChildElement(node, "Fret")));
break;
}
}
private void ParseScorePart(IXmlNode element)
{
string id = element.GetAttribute("id");
var track = new Track(1);
_trackById[id] = track;
_score.AddTrack(track);
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "part-name":
track.Name = Std.GetNodeValue(c.FirstChild);
break;
case "part-abbreviation":
track.ShortName = Std.GetNodeValue(c.FirstChild);
break;
case "midi-instrument":
ParseMidiInstrument(c, track);
break;
}
}
});
if (track.Tuning == null || track.Tuning.Length == 0)
{
track.Tuning = Tuning.GetDefaultTuningFor(6).Tunings;
}
}
private bool ParseNoteBeat(IXmlNode element, Track track, Bar bar, bool chord, bool isFirstBeat)
{
int voiceIndex = 0;
var voiceNodes = element.GetElementsByTagName("voice");
if (voiceNodes.Length > 0)
{
voiceIndex = Std.ParseInt(Std.GetNodeValue(voiceNodes[0])) - 1;
}
Beat beat;
var voice = GetOrCreateVoice(bar, voiceIndex);
if (chord || (isFirstBeat && voice.Beats.Count == 1))
{
beat = voice.Beats[voice.Beats.Count - 1];
}
else
{
beat = new Beat();
voice.AddBeat(beat);
}
var note = new Note();
beat.AddNote(note);
beat.IsEmpty = false;
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "grace":
//var slash = e.GetAttribute("slash");
//var makeTime = Std.ParseInt(e.GetAttribute("make-time"));
//var stealTimePrevious = Std.ParseInt(e.GetAttribute("steal-time-previous"));
//var stealTimeFollowing = Std.ParseInt(e.GetAttribute("steal-time-following"));
beat.GraceType = GraceType.BeforeBeat;
beat.Duration = Duration.ThirtySecond;
break;
case "duration":
beat.Duration = (Duration)Std.ParseInt(Std.GetNodeValue(c));
break;
case "tie":
ParseTied(c, note);
break;
case "cue":
// not supported
break;
case "instrument":
// not supported
break;
case "type":
switch (Std.GetNodeValue(c))
{
case "256th":
beat.Duration = Duration.TwoHundredFiftySixth;
break;
case "128th":
beat.Duration = Duration.OneHundredTwentyEighth;
break;
case "breve":
beat.Duration = Duration.DoubleWhole;
break;
case "long":
beat.Duration = Duration.QuadrupleWhole;
break;
case "64th":
beat.Duration = Duration.SixtyFourth;
break;
case "32nd":
beat.Duration = Duration.ThirtySecond;
break;
case "16th":
beat.Duration = Duration.Sixteenth;
break;
case "eighth":
beat.Duration = Duration.Eighth;
break;
case "quarter":
beat.Duration = Duration.Quarter;
break;
case "half":
beat.Duration = Duration.Half;
break;
case "whole":
beat.Duration = Duration.Whole;
break;
}
break;
case "dot":
note.IsStaccato = true;
break;
case "accidental":
ParseAccidental(c, note);
break;
case "time-modification":
ParseTimeModification(c, beat);
break;
case "stem":
// not supported
break;
case "notehead":
if (c.GetAttribute("parentheses") == "yes")
{
note.IsGhost = true;
}
break;
case "beam":
// not supported
break;
case "notations":
ParseNotations(c, beat, note);
break;
case "lyric":
// not supported
break;
// "full-note"
case "chord":
chord = true;
break;
case "pitch":
ParsePitch(c, track, beat, note);
break;
case "unpitched":
// TODO: not yet fully supported
note.String = 0;
note.Fret = 0;
break;
case "rest":
beat.IsEmpty = false;
break;
}
}
});
return chord;
}
private void ParseMeasure(IXmlNode element, Track track, bool isFirstMeasure)
{
var barIndex = 0;
if (isFirstMeasure)
{
_trackFirstMeasureNumber = Std.ParseInt(element.GetAttribute("number"));
barIndex = 0;
}
else
{
barIndex = Std.ParseInt(element.GetAttribute("number")) - _trackFirstMeasureNumber;
}
// create empty bars to the current index
Bar bar = null;
MasterBar masterBar = null;
for (int i = track.Staves[0].Bars.Count; i <= barIndex; i++)
{
bar = new Bar();
masterBar = GetOrCreateMasterBar(barIndex);
track.AddBarToStaff(0, bar);
for (int j = 0; j < _maxVoices; j++)
{
var emptyVoice = new Voice();
bar.AddVoice(emptyVoice);
var emptyBeat = new Beat { IsEmpty = true };
emptyVoice.AddBeat(emptyBeat);
}
}
bool chord = false;
bool isFirstBeat = true;
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "note":
chord = ParseNoteBeat(c, track, bar, chord, isFirstBeat);
isFirstBeat = false;
break;
case "forward":
break;
case "direction":
ParseDirection(c, masterBar);
break;
case "attributes":
ParseAttributes(c, bar, masterBar);
break;
case "harmony":
// TODO
break;
case "sound":
// TODO
break;
case "barline":
// TODO
break;
}
}
});
}
public StaveTrackGroup(StaveGroup staveGroup, Track track)
{
StaveGroup = staveGroup;
Track = track;
Staves = new FastList<Stave>();
}
private StaveTrackGroup GetStaveTrackGroup(Track track)
{
for (int i = 0, j = Staves.Count; i < j; i++)
{
var g = Staves[i];
if (g.Track == track)
{
return g;
}
}
return null;
}
public void AddStave(Track track, Stave stave)
{
var group = GetStaveTrackGroup(track);
if (group == null)
{
group = new StaveTrackGroup(this, track);
Staves.Add(group);
}
stave.StaveTrackGroup = group;
stave.StaveGroup = this;
stave.Index = _allStaves.Count;
_allStaves.Add(stave);
group.Staves.Add(stave);
if (stave.IsInAccolade)
{
if (_firstStaveInAccolade == null)
{
_firstStaveInAccolade = stave;
stave.IsFirstInAccolade = true;
}
if (group.FirstStaveInAccolade == null)
{
group.FirstStaveInAccolade = stave;
}
if (_lastStaveInAccolade == null)
{
_lastStaveInAccolade = stave;
stave.IsLastInAccolade = true;
}
if (_lastStaveInAccolade != null) { _lastStaveInAccolade.IsLastInAccolade = false; }
_lastStaveInAccolade = stave;
_lastStaveInAccolade.IsLastInAccolade = true;
group.LastStaveInAccolade = stave;
}
}
public void AddBars(Track[] tracks, int barIndex)
{
if (tracks.Length == 0) return;
var score = tracks[0].Score;
var masterBar = score.MasterBars[barIndex];
MasterBars.Add(masterBar);
Helpers.BuildHelpers(tracks, barIndex);
if (!_accoladeSpacingCalculated && Index == 0)
{
_accoladeSpacingCalculated = true;
var canvas = Layout.Renderer.Canvas;
var res = Layout.Renderer.RenderingResources.EffectFont;
canvas.Font = res;
for (var i = 0; i < tracks.Length; i++)
{
AccoladeSpacing = Math.Max(AccoladeSpacing, canvas.MeasureText(tracks[i].ShortName));
}
AccoladeSpacing += (2 * AccoladeLabelSpacing);
Width += AccoladeSpacing;
}
// add renderers
var maxSizes = new BarSizeInfo();
for (int i = 0, j = Staves.Count; i < j; i++)
{
var g = Staves[i];
for (int k = 0, l = g.Staves.Count; k < l; k++)
{
var s = g.Staves[k];
s.AddBar(g.Track.Bars[barIndex]);
s.BarRenderers[s.BarRenderers.Count - 1].RegisterMaxSizes(maxSizes);
}
}
// ensure same widths of new renderer
var realWidth = 0f;
for (int i = 0, j = _allStaves.Count; i < j; i++)
{
var s = _allStaves[i];
s.BarRenderers[s.BarRenderers.Count - 1].ApplySizes(maxSizes);
if (s.BarRenderers[s.BarRenderers.Count - 1].Width > realWidth)
{
realWidth = s.BarRenderers[s.BarRenderers.Count - 1].Width;
}
}
Width += realWidth;
}
public void ReadNoteEffects(Track track, Voice voice, Beat beat, Note note)
{
var flags = Data.ReadByte();
var flags2 = 0;
if (_versionNumber >= 400)
{
flags2 = Data.ReadByte();
}
if ((flags & 0x01) != 0)
{
ReadBend(note);
}
if ((flags & 0x10) != 0)
{
ReadGrace(voice, note);
}
if ((flags2 & 0x04) != 0)
{
ReadTremoloPicking(beat);
}
if ((flags2 & 0x08) != 0)
{
ReadSlide(note);
}
else if (_versionNumber < 400)
{
if ((flags & 0x04) != 0)
{
note.SlideType = SlideType.Shift;
}
}
if ((flags2 & 0x10) != 0)
{
ReadArtificialHarmonic(note);
}
else if (_versionNumber < 400)
{
if ((flags & 0x04) != 0)
{
note.HarmonicType = HarmonicType.Natural;
note.HarmonicValue = DeltaFretToHarmonicValue(note.Fret);
}
if ((flags & 0x08) != 0)
{
note.HarmonicType = HarmonicType.Artificial;
}
}
if ((flags2 & 0x20) != 0)
{
ReadTrill(note);
}
note.IsLetRing = (flags & 0x08) != 0;
note.IsHammerPullOrigin = (flags & 0x02) != 0;
if ((flags2 & 0x40) != 0)
{
note.Vibrato = VibratoType.Slight;
}
note.IsPalmMute = (flags2 & 0x02) != 0;
note.IsStaccato = (flags2 & 0x01) != 0;
}
public void ReadNote(Track track, Bar bar, Voice voice, Beat beat, int stringIndex)
{
var newNote = new Note();
newNote.String = track.Tuning.Length - stringIndex;
var flags = Data.ReadByte();
if ((flags & 0x02) != 0)
{
newNote.Accentuated = AccentuationType.Heavy;
}
else if ((flags & 0x40) != 0)
{
newNote.Accentuated = AccentuationType.Normal;
}
newNote.IsGhost = ((flags & 0x04) != 0);
if ((flags & 0x20) != 0)
{
var noteType = Data.ReadByte();
if (noteType == 3)
{
newNote.IsDead = true;
}
else if (noteType == 2)
{
newNote.IsTieDestination = true;
}
}
if ((flags & 0x01) != 0 && _versionNumber < 500)
{
Data.ReadByte(); // duration
Data.ReadByte(); // tuplet
}
if ((flags & 0x10) != 0)
{
var dynamicNumber = Data.ReadSignedByte();
newNote.Dynamic = ToDynamicValue(dynamicNumber);
beat.Dynamic = newNote.Dynamic;
}
if ((flags & 0x20) != 0)
{
newNote.Fret = Data.ReadSignedByte();
}
if ((flags & 0x80) != 0)
{
newNote.LeftHandFinger = (Fingers)Data.ReadSignedByte();
newNote.RightHandFinger = (Fingers)Data.ReadSignedByte();
newNote.IsFingering = true;
}
if (_versionNumber >= 500)
{
if ((flags & 0x01) != 0)
{
newNote.DurationPercent = ReadDouble();
}
var flags2 = Data.ReadByte();
newNote.AccidentalMode = (flags2 & 0x02) != 0
? NoteAccidentalMode.SwapAccidentals
: NoteAccidentalMode.Default;
}
beat.AddNote(newNote);
if ((flags & 0x08) != 0)
{
ReadNoteEffects(track, voice, beat, newNote);
}
}
private void ParseDiagramItem(Track track, IXmlNode node)
{
var chord = new Chord();
var chordId = node.Attributes.Get("id").Value;
chord.Name = node.Attributes.Get("name").Value;
track.Chords[chordId] = chord;
}
private void ParseGeneralMidi(Track track, IXmlNode node)
{
track.PlaybackInfo.Port = Std.ParseInt(GetValue(FindChildElement(node, "Port")));
track.PlaybackInfo.Program = Std.ParseInt(GetValue(FindChildElement(node, "Program")));
track.PlaybackInfo.PrimaryChannel = Std.ParseInt(GetValue(FindChildElement(node, "PrimaryChannel")));
track.PlaybackInfo.SecondaryChannel = Std.ParseInt(GetValue(FindChildElement(node, "SecondaryChannel")));
track.IsPercussion = (node.Attributes.Get("table") != null &&
node.Attributes.Get("table").Value == "Percussion");
}
public void SetNotes(GeneticMIDI.Representation.Track track)
{
if (track.Length < 1)
return;
var mel = track.GetMelodySequence();
//return;
score = new Score();
Track t = new Track();
MasterBar mb = new MasterBar();
score.AddMasterBar(mb);
mb.KeySignature = 2;
Bar b = new Bar();
t.AddBar(b);
score.AddTrack(t);
Voice v = new Voice();
b.AddVoice(v);
t.Name = track.Instrument.ToString().Replace("_", " ");
//t.IsPercussion = true;
if(t.IsPercussion)
{
b.Clef = Clef.Neutral;
}
int i = 0;
int qn_per_bar = 4;
int durs = 0;
int avg_octave = mel.CalculateAverageOctave();
int dist4 = 4 - avg_octave;
foreach (var n in mel.Notes)
{
Beat be = new Beat();
be.Index = i++;
GeneticMIDI.Representation.Durations dur;
int remainder;
n.GetClosestLowerDurationAndRemainder(out dur, out remainder);
int dots = n.GetNumberOfDots();
durs += n.Duration;
/* if(durs >= qn_per_bar * (int)GeneticMIDI.Representation.Durations.qn)
{
durs = 0;
b = new Bar();
t.AddBar(b);
v.Bar = b;
b.Finish();
}*/
switch (((GeneticMIDI.Representation.Durations)n.Duration))
{
case GeneticMIDI.Representation.Durations.bn:
be.Duration = AlphaTab.Model.Duration.Whole;
dots = 2;
break;
case GeneticMIDI.Representation.Durations.en:
be.Duration = AlphaTab.Model.Duration.Eighth;
break;
case GeneticMIDI.Representation.Durations.hn:
be.Duration = AlphaTab.Model.Duration.Half;
break;
case GeneticMIDI.Representation.Durations.qn:
be.Duration = AlphaTab.Model.Duration.Quarter;
break;
case GeneticMIDI.Representation.Durations.sn:
be.Duration = AlphaTab.Model.Duration.Sixteenth;
break;
case GeneticMIDI.Representation.Durations.tn:
be.Duration = AlphaTab.Model.Duration.ThirtySecond;
break;
case GeneticMIDI.Representation.Durations.wn:
be.Duration = AlphaTab.Model.Duration.Whole;
break;
default:
break;
}
be.Dots = dots;
Note note = new Note();
if (!n.IsRest())
{
note.Tone = n.NotePitch;
note.Octave = n.Octave + dist4;
be.AddNote(note);
be.IsEmpty = false;
}
if (n.IsRest() && n.Duration < 2)
{
}
else
v.AddBeat(be);
be.RefreshNotes();
}
v.Bar = b;
v.Finish();
b.Finish();
t.Finish();
score.Finish();
//TablatureControl
_renderer.Render(t);
return;
/*TablatureControl.Track = t;
TablatureControl.InvalidateVisual();
TablatureControl.InvalidateTrack(); */
}
private void ParseMidiInstrument(IXmlNode element, Track track)
{
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "midi-channel":
track.PlaybackInfo.PrimaryChannel = Std.ParseInt(Std.GetNodeValue(c.FirstChild));
break;
case "midi-program":
track.PlaybackInfo.Program = Std.ParseInt(Std.GetNodeValue(c.FirstChild));
break;
case "midi-volume":
track.PlaybackInfo.Volume = Std.ParseInt(Std.GetNodeValue(c.FirstChild));
break;
}
}
});
}
public void AddTrack(Track track)
{
track.Score = this;
track.Index = Tracks.Count;
Tracks.Add(track);
}
private void ApplyNoteStringFrets(Track track, Beat beat, Note note, int fullNoteValue)
{
note.String = FindStringForValue(track, beat, fullNoteValue);
note.Fret = fullNoteValue - Note.GetStringTuning(track, note.String);
}
private void ParseTrack(IXmlNode node)
{
var track = new Track(1);
var trackId = node.GetAttribute("id");
node.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "Name":
track.Name = GetValue(c);
break;
case "Instrument":
var instrumentName = c.GetAttribute("ref");
if (instrumentName.EndsWith("-gs") || instrumentName.EndsWith("GrandStaff"))
{
track.EnsureStaveCount(2);
}
break;
case "ShortName":
track.ShortName = GetValue(c);
break;
//TODO: case "Lyrics": parseLyrics(track, c);
case "Properties":
ParseTrackProperties(track, c);
break;
case "GeneralMidi":
ParseGeneralMidi(track, c);
break;
case "PlaybackState":
var state = GetValue(c);
track.PlaybackInfo.IsSolo = state == "Solo";
track.PlaybackInfo.IsMute = state == "Mute";
break;
}
}
});
_tracksById[trackId] = track;
}
private void ParsePitch(IXmlNode element, Track track, Beat beat, Note note)
{
string step = null;
int semitones = 0;
int octave = 0;
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "step":
step = Std.GetNodeValue(c);
break;
case "alter":
semitones = Std.ParseInt(Std.GetNodeValue(c));
break;
case "octave":
// 0-9, 4 for middle C
octave = Std.ParseInt(Std.GetNodeValue(c));
break;
}
}
});
var fullNoteName = step + octave;
var fullNoteValue = TuningParser.GetTuningForText(fullNoteName) + semitones;
ApplyNoteStringFrets(track, beat, note, fullNoteValue);
}
private void ParseTrack(IXmlNode node)
{
var track = new Track();
var trackId = node.Attributes.Get("id").Value;
node.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "Name":
track.Name = GetValue(c);
break;
case "ShortName":
track.ShortName = GetValue(c);
break;
//TODO: case "Lyrics": parseLyrics(track, c);
case "Properties":
ParseTrackProperties(track, c);
break;
case "GeneralMidi":
ParseGeneralMidi(track, c);
break;
case "PlaybackState":
var state = GetValue(c);
track.PlaybackInfo.IsSolo = state == "Solo";
track.PlaybackInfo.IsMute = state == "Mute";
break;
}
}
});
_tracksById[trackId] = track;
}
/// <summary>
/// Initializes the song with some required default values.
/// </summary>
/// <returns></returns>
private void CreateDefaultScore()
{
_score = new Score();
_score.Tempo = 120;
_score.TempoLabel = "";
_track = new Track();
_track.PlaybackInfo.Program = 25;
_track.PlaybackInfo.PrimaryChannel = TrackChannels[0];
_track.PlaybackInfo.SecondaryChannel = TrackChannels[1];
_track.Tuning = Tuning.GetDefaultTuningFor(6).Tunings;
_score.AddTrack(_track);
}
private void ParseTrackProperties(Track track, IXmlNode node)
{
node.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "Property":
ParseTrackProperty(track, c);
break;
}
}
});
}
