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; } } }); }