public EffectBarRenderer(Bar bar, IEffectBarRendererInfo info)
: base(bar)
{
_info = info;
_uniqueEffectGlyphs = new FastList<FastList<EffectGlyph>>();
_effectGlyphs = new FastList<FastDictionary<int, EffectGlyph>>();
}
public GroupedBarRenderer(Bar bar)
: base(bar)
{
_preBeatGlyphs = new FastList<Glyph>();
_voiceContainers = new FastDictionary<int, VoiceContainerGlyph>();
_postBeatGlyphs = new FastList<Glyph>();
}
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 BarRendererBase(Bar bar)
{
Bar = bar;
IsEmpty = true;
_preBeatGlyphs = new LeftToRightLayoutingGlyphGroup();
_preBeatGlyphs.Renderer = this;
_voiceContainers = new FastDictionary<int, VoiceContainerGlyph>();
_postBeatGlyphs = new LeftToRightLayoutingGlyphGroup();
_postBeatGlyphs.Renderer = this;
}
public void AddBar(Bar bar)
{
var bars = Bars;
bar.Track = this;
bar.Index = Bars.Count;
if (bars.Count > 0)
{
bar.PreviousBar = bars[bars.Count - 1];
bar.PreviousBar.NextBar = bar;
}
bars.Add(bar);
}
public AlternateEndingsBarRenderer(Bar bar)
: base(bar)
{
var alternateEndings = Bar.MasterBar.AlternateEndings;
_endings = new FastList<int>();
for (var i = 0; i < MasterBar.MaxAlternateEndings; i++)
{
if ((alternateEndings & (0x01 << i)) != 0)
{
_endings.Add(i);
}
}
}
public ScoreBarRenderer(Bar bar)
: base(bar)
{
AccidentalHelper = new AccidentalHelper();
}
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);
}
}
public override BarRendererBase Create(Bar bar)
{
return new ScoreBarRenderer(bar);
}
public BarRendererBase(Bar bar)
{
Bar = bar;
IsEmpty = true;
}
public void ReadBeat(Track track, Bar bar, Voice voice)
{
var newBeat = new Beat();
var flags = Data.ReadByte();
if ((flags & 0x01) != 0)
{
newBeat.Dots = 1;
}
if ((flags & 0x40) != 0)
{
var type = Data.ReadByte();
newBeat.IsEmpty = (type & 0x02) == 0;
}
voice.AddBeat(newBeat);
var duration = Data.ReadSignedByte();
switch (duration)
{
case -2:
newBeat.Duration = Duration.Whole;
break;
case -1:
newBeat.Duration = Duration.Half;
break;
case 0:
newBeat.Duration = Duration.Quarter;
break;
case 1:
newBeat.Duration = Duration.Eighth;
break;
case 2:
newBeat.Duration = Duration.Sixteenth;
break;
case 3:
newBeat.Duration = Duration.ThirtySecond;
break;
case 4:
newBeat.Duration = Duration.SixtyFourth;
break;
default:
newBeat.Duration = Duration.Quarter;
break;
}
if ((flags & 0x20) != 0)
{
newBeat.TupletNumerator = ReadInt32();
switch (newBeat.TupletNumerator)
{
case 1:
newBeat.TupletDenominator = 1;
break;
case 3:
newBeat.TupletDenominator = 2;
break;
case 5:
case 6:
case 7:
newBeat.TupletDenominator = 4;
break;
case 9:
case 10:
case 11:
case 12:
case 13:
newBeat.TupletDenominator = 8;
break;
case 2:
case 4:
case 8:
break;
default:
newBeat.TupletNumerator = 1;
newBeat.TupletDenominator = 1;
break;
}
}
if ((flags & 0x02) != 0)
{
ReadChord(newBeat);
}
if ((flags & 0x04) != 0)
{
newBeat.Text = ReadStringIntUnused();
}
if ((flags & 0x08) != 0)
{
ReadBeatEffects(newBeat);
}
if ((flags & 0x10) != 0)
{
ReadMixTableChange(newBeat);
}
var stringFlags = Data.ReadByte();
for (int i = 6; i >= 0; i--)
{
if ((stringFlags & (1 << i)) != 0 && (6 - i) < track.Tuning.Length)
{
ReadNote(track, bar, voice, newBeat, (6 - i));
}
}
if (_versionNumber >= 500)
{
Data.ReadByte();
var flag = Data.ReadByte();
if ((flag & 0x08) != 0)
{
Data.ReadByte();
}
}
}
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;
}
}
});
}
private void BarMeta(Bar bar)
{
var master = bar.MasterBar;
while (_sy == AlphaTexSymbols.MetaCommand)
{
var syData = _syData.ToString().ToLower();
if (syData == "ts")
{
NewSy();
if (_sy != AlphaTexSymbols.Number)
{
Error("timesignature-numerator", AlphaTexSymbols.Number);
}
master.TimeSignatureNumerator = (int)_syData;
NewSy();
if (_sy != AlphaTexSymbols.Number)
{
Error("timesignature-denominator", AlphaTexSymbols.Number);
}
master.TimeSignatureDenominator = (int)_syData;
}
else if (syData == "ro")
{
master.IsRepeatStart = true;
}
else if (syData == "rc")
{
NewSy();
if (_sy != AlphaTexSymbols.Number)
{
Error("repeatclose", AlphaTexSymbols.Number);
}
master.RepeatCount = ((int)_syData) - 1;
}
else if (syData == "ks")
{
NewSy();
if (_sy != AlphaTexSymbols.String)
{
Error("keysignature", AlphaTexSymbols.String);
}
master.KeySignature = ParseKeySignature(_syData.ToString().ToLower());
}
else if (syData == "clef")
{
NewSy();
if (_sy != AlphaTexSymbols.String && _sy != AlphaTexSymbols.Tuning)
{
Error("clef", AlphaTexSymbols.String);
}
bar.Clef = ParseClef(_syData.ToString().ToLower());
}
else if (syData == "tempo")
{
NewSy();
if (_sy != AlphaTexSymbols.Number)
{
Error("tempo", AlphaTexSymbols.Number);
}
var tempoAutomation = new Automation();
tempoAutomation.IsLinear = true;
tempoAutomation.Type = AutomationType.Tempo;
tempoAutomation.Value = (float)_syData;
master.TempoAutomation = tempoAutomation;
}
else
{
Error("measure-effects", AlphaTexSymbols.String, false);
}
NewSy();
}
}
private void ParseBar(IXmlNode node)
{
var bar = new Bar();
var barId = node.Attributes.Get("id").Value;
node.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "Voices":
_voicesOfBar[barId] = GetValue(c).Split(' ');
break;
case "Clef":
switch (GetValue(c))
{
case "Neutral":
bar.Clef = Clef.Neutral;
break;
case "G2":
bar.Clef = Clef.G2;
break;
case "F4":
bar.Clef = Clef.F4;
break;
case "C4":
bar.Clef = Clef.C4;
break;
case "C3":
bar.Clef = Clef.C3;
break;
}
break;
// case "SimileMark":
}
}
});
_barsById[barId] = bar;
}
private void ParseAttributes(IXmlNode element, Bar bar, MasterBar masterBar)
{
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "key":
ParseKey(c, masterBar);
break;
case "time":
ParseTime(c, masterBar);
break;
case "clef":
ParseClef(c, bar);
break;
}
}
});
}
private void Bar(Bar bar)
{
BarMeta(bar);
Voice(bar.Voices[0]);
}
public TabBarRenderer(Bar bar)
: base(bar)
{
}
private void BarMeta(Bar bar)
{
var masterBar = bar.MasterBar;
if (masterBar.Index > 0)
{
var previousMasterBar = masterBar.PreviousMasterBar;
var previousBar = bar.PreviousBar;
if (previousMasterBar.TimeSignatureDenominator != masterBar.TimeSignatureDenominator || previousMasterBar.TimeSignatureNumerator != masterBar.TimeSignatureNumerator)
{
_builder.Append("\\ts ");
_builder.Append(masterBar.TimeSignatureNumerator);
_builder.Append(" ");
_builder.Append(masterBar.TimeSignatureDenominator);
_builder.AppendLine();
}
if (previousMasterBar.KeySignature != masterBar.KeySignature)
{
_builder.Append("\\ks ");
switch (masterBar.KeySignature)
{
case -7:
_builder.Append("cb");
break;
case -6:
_builder.Append("gb");
break;
case -5:
_builder.Append("db");
break;
case -4:
_builder.Append("ab");
break;
case -3:
_builder.Append("eb");
break;
case -2:
_builder.Append("bb");
break;
case -1:
_builder.Append("f");
break;
case 0:
_builder.Append("c");
break;
case 1:
_builder.Append("g");
break;
case 2:
_builder.Append("d");
break;
case 3:
_builder.Append("a");
break;
case 4:
_builder.Append("e");
break;
case 5:
_builder.Append("b");
break;
case 6:
_builder.Append("f#");
break;
case 7:
_builder.Append("c#");
break;
}
_builder.AppendLine();
}
if (bar.Clef != previousBar.Clef)
{
_builder.Append("\\clef ");
switch (bar.Clef)
{
case Clef.Neutral:
_builder.Append("n");
break;
case Clef.C3:
_builder.Append("c3");
break;
case Clef.C4:
_builder.Append("c4");
break;
case Clef.F4:
_builder.Append("f4");
break;
case Clef.G2:
_builder.Append("g2");
break;
}
_builder.AppendLine();
}
if (masterBar.TempoAutomation != null)
{
_builder.Append("\\tempo ");
_builder.Append(masterBar.TempoAutomation.Value);
_builder.AppendLine();
}
}
if (masterBar.IsRepeatStart)
{
_builder.Append("\\ro ");
_builder.AppendLine();
}
if (masterBar.IsRepeatEnd)
{
_builder.Append("\\rc ");
_builder.Append(masterBar.RepeatCount + 1);
_builder.AppendLine();
}
}
public void GenerateBar(Bar bar, int barStartTick)
{
for (int i = 0, j = bar.Voices.Count; i < j; i++)
{
GenerateVoice(bar.Voices[i], barStartTick);
}
}
public RhythmBarRenderer(Bar bar, BeamDirection direction)
: base(bar)
{
_direction = direction;
}
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(); */
}
public Score JsObjectToScore(Score score)
{
var score2 = new Score();
Score.CopyTo(score, score2);
#region MasterBars
for (var i = 0;i < score.MasterBars.Count; i++)
{
var masterBar = score.MasterBars[i];
var masterBar2 = new MasterBar();
MasterBar.CopyTo(masterBar, masterBar2);
if (masterBar.TempoAutomation != null)
{
masterBar2.TempoAutomation = new Automation();
Automation.CopyTo(masterBar.TempoAutomation, masterBar2.TempoAutomation);
}
if (masterBar.VolumeAutomation != null)
{
masterBar2.VolumeAutomation = new Automation();
Automation.CopyTo(masterBar.VolumeAutomation, masterBar2.VolumeAutomation);
}
if (masterBar.Section != null)
{
masterBar2.Section = new Section();
Section.CopyTo(masterBar.Section, masterBar2.Section);
}
score2.AddMasterBar(masterBar2);
}
#endregion
#region Tracks
for (int t = 0; t < score.Tracks.Count; t++)
{
var track = score.Tracks[t];
var track2 = new Track();
Track.CopyTo(track, track2);
score2.AddTrack(track2);
PlaybackInformation.CopyTo(track.PlaybackInfo, track2.PlaybackInfo);
foreach (var key in track.Chords.Keys)
{
var chord = track.Chords[key];
var chord2 = new Chord();
Chord.CopyTo(chord, chord2);
track2.Chords[key] = chord2;
}
#region Bars
for (int b = 0; b < track.Bars.Count; b++)
{
var bar = track.Bars[b];
var bar2 = new Bar();
Bar.CopyTo(bar, bar2);
track2.AddBar(bar2);
#region Voices
for (int v = 0; v < bar.Voices.Count; v++)
{
var voice = bar.Voices[v];
var voice2 = new Voice();
Voice.CopyTo(voice, voice2);
bar2.AddVoice(voice2);
#region Beats
for (int bb = 0; bb < voice.Beats.Count; bb++)
{
var beat = voice.Beats[bb];
var beat2 = new Beat();
Beat.CopyTo(beat, beat2);
voice2.AddBeat(beat2);
for (int a = 0; a < beat.Automations.Count; a++)
{
var automation = new Automation();
Automation.CopyTo(beat.Automations[a], automation);
beat2.Automations.Add(automation);
}
for (int i = 0; i < beat.WhammyBarPoints.Count; i++)
{
var point = new BendPoint();
BendPoint.CopyTo(beat.WhammyBarPoints[i], point);
beat2.WhammyBarPoints.Add(point);
}
#region Notes
for (int n = 0; n < beat.Notes.Count; n++)
{
var note = beat.Notes[n];
var note2 = new Note();
Note.CopyTo(note, note2);
beat2.AddNote(note2);
for (int i = 0; i < note.BendPoints.Count; i++)
{
var point = new BendPoint();
BendPoint.CopyTo(note.BendPoints[i], point);
note2.AddBendPoint(point);
}
}
#endregion
}
#endregion
}
#endregion
}
#endregion
}
#endregion
score2.Finish();
return score2;
}
private Voice GetOrCreateVoice(Bar bar, int index)
{
if (index < bar.Voices.Count)
{
return bar.Voices[index];
}
for (int i = bar.Voices.Count; i <= index; i++)
{
bar.AddVoice(new Voice());
}
_maxVoices = Math.Max(_maxVoices, bar.Voices.Count);
return bar.Voices[index];
}
public BarHelpers(Bar bar)
{
BeamHelpers = new FastList<FastList<BeamingHelper>>();
BeamHelperLookup = new FastList<FastDictionary<int, BeamingHelper>>();
TupletHelpers = new FastList<FastList<TupletHelper>>();
BeamingHelper currentBeamHelper = null;
TupletHelper currentTupletHelper = null;
for (int i = 0, j = bar.Voices.Count; i < j; i++)
{
var v = bar.Voices[i];
BeamHelpers.Add(new FastList<BeamingHelper>());
BeamHelperLookup.Add(new FastDictionary<int, BeamingHelper>());
TupletHelpers.Add(new FastList<TupletHelper>());
for (int k = 0, l = v.Beats.Count; k < l; k++)
{
var b = v.Beats[k];
var newBeamingHelper = false;
if (!b.IsRest)
{
// try to fit beam to current beamhelper
if (currentBeamHelper == null || !currentBeamHelper.CheckBeat(b))
{
// if not possible, create the next beaming helper
currentBeamHelper = new BeamingHelper(bar.Track);
currentBeamHelper.CheckBeat(b);
BeamHelpers[v.Index].Add(currentBeamHelper);
newBeamingHelper = true;
}
}
if (b.HasTuplet)
{
// try to fit tuplet to current tuplethelper
// TODO: register tuplet overflow
var previousBeat = b.PreviousBeat;
// don't group if the previous beat isn't in the same voice
if (previousBeat != null && previousBeat.Voice != b.Voice) previousBeat = null;
// if a new beaming helper was started, we close our tuplet grouping as well
if (newBeamingHelper && currentTupletHelper != null)
{
currentTupletHelper.Finish();
}
if (previousBeat == null || currentTupletHelper == null || !currentTupletHelper.Check(b))
{
currentTupletHelper = new TupletHelper(v.Index);
currentTupletHelper.Check(b);
TupletHelpers[v.Index].Add(currentTupletHelper);
}
}
BeamHelperLookup[v.Index][b.Index] = currentBeamHelper;
}
currentBeamHelper = null;
currentTupletHelper = null;
}
}
private void ParseClef(IXmlNode element, Bar bar)
{
string sign = null;
string line = null;
element.IterateChildren(c =>
{
if (c.NodeType == XmlNodeType.Element)
{
switch (c.LocalName)
{
case "sign":
sign = Std.GetNodeValue(c);
break;
case "line":
line = Std.GetNodeValue(c);
break;
}
}
});
var clef = sign + line;
switch (clef)
{
case "G2":
bar.Clef = Clef.G2;
break;
case "F4":
bar.Clef = Clef.F4;
break;
case "C3":
bar.Clef = Clef.C3;
break;
case "C4":
bar.Clef = Clef.C4;
break;
}
}
public void ReadVoice(Track track, Bar bar)
{
var beatCount = ReadInt32();
if (beatCount == 0)
{
return;
}
var newVoice = new Voice();
bar.AddVoice(newVoice);
for (int i = 0; i < beatCount; i++)
{
ReadBeat(track, bar, newVoice);
}
}
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;
}
public void ReadBar(Track track)
{
var newBar = new Bar();
if (track.IsPercussion)
{
newBar.Clef = Clef.Neutral;
}
track.AddBarToStaff(0, newBar);
var voiceCount = 1;
if (_versionNumber >= 500)
{
Data.ReadByte();
voiceCount = 2;
}
for (int v = 0; v < voiceCount; v++)
{
ReadVoice(track, newBar);
}
}
private void Bar()
{
var master = new MasterBar();
_score.AddMasterBar(master);
var bar = new Bar();
_track.AddBar(bar);
if (master.Index > 0)
{
master.KeySignature = master.PreviousMasterBar.KeySignature;
master.TimeSignatureDenominator = master.PreviousMasterBar.TimeSignatureDenominator;
master.TimeSignatureNumerator = master.PreviousMasterBar.TimeSignatureNumerator;
bar.Clef = bar.PreviousBar.Clef;
}
BarMeta(bar);
var voice = new Voice();
bar.AddVoice(voice);
while (_sy != AlphaTexSymbols.Pipe && _sy != AlphaTexSymbols.Eof)
{
Beat(voice);
}
if (voice.Beats.Count == 0)
{
var emptyBeat = new Beat();
emptyBeat.IsEmpty = true;
voice.AddBeat(emptyBeat);
}
}
private void Button_Click(object sender, RoutedEventArgs e)
{
var comp = GeneticMIDI.Representation.Composition.LoadFromMIDI(@"C:\Users\1gn1t0r\Documents\git\GeneticMIDI\GeneticMIDI\bin\Debug\test\harry.mid");
var mel = comp.Tracks[0].GetMainSequence() as GeneticMIDI.Representation.MelodySequence;
Score score = new Score();
Track t = new Track();
var pc = t.IsPercussion;
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);
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 = Model.Duration.Whole;
dots = 2;
break;
case GeneticMIDI.Representation.Durations.en:
be.Duration = Model.Duration.Eighth;
break;
case GeneticMIDI.Representation.Durations.hn:
be.Duration = Model.Duration.Half;
break;
case GeneticMIDI.Representation.Durations.qn:
be.Duration = Model.Duration.Quarter;
break;
case GeneticMIDI.Representation.Durations.sn:
be.Duration = Model.Duration.Sixteenth;
break;
case GeneticMIDI.Representation.Durations.tn:
be.Duration = Model.Duration.ThirtySecond;
break;
case GeneticMIDI.Representation.Durations.wn:
be.Duration = 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();
viewModel.Score = score;
viewModel.CurrentTrackIndex = 0;
}
