public static Barline CreateBarline(BarlineProperties bi)
{
ObjectFactory factory = new ObjectFactory();
Barline barline = factory.createBarline();
//create an ending
if (bi.EndingValue != "")
{
Ending ending = factory.createEnding();
ending.setType(StartStopDiscontinue.fromValue(bi.EndingType));
ending.setValue(bi.EndingValue);
barline.setEnding(ending);
}
//create a repeat
if (bi.RepeatTimes != "")
{
Repeat repeat = factory.createRepeat();
repeat.setTimes(new BigInteger(bi.RepeatTimes));
repeat.setDirection(BackwardForward.fromValue(bi.RepeatDirection));
barline.setRepeat(repeat);
}
//set bar line location
if (bi.Location != "")
{
barline.setLocation(RightLeftMiddle.fromValue(bi.Location));
}
return(barline);
}
/// <summary>
/// Parse the barline information given and create an appropriate label that can be put onto a canvas.
/// </summary>
/// <param name="barline">The Barline information to parse</param>
/// <param name="fontSize">The fontsize to use</param>
/// <returns>Label that holds the barline</returns>
public static FrameworkElement RenderBarline(Barline barline, double fontSize)
{
string barlineChar;
switch (barline.barStyle.Value)
{
case BarStyle.regular:
barlineChar = Constants.Barlines.REGULAR;
break;
case BarStyle.lightlight:
barlineChar = Constants.Barlines.LIGHT_LIGHT;
break;
case BarStyle.lightheavy:
barlineChar = Constants.Barlines.LIGHT_HEAVY;
break;
case BarStyle.heavylight:
barlineChar = Constants.Barlines.HEAVY_LIGHT;
break;
case BarStyle.dashed:
barlineChar = Constants.Barlines.DASHED;
break;
default:
barlineChar = Constants.Barlines.REGULAR;
break;
//todo: remainder of barlines
}
FrameworkElement barlineLabel = WPFRendering.GetMusicalLabel(barlineChar, fontSize);
WPFRendering.RecalculateSize(barlineLabel);
return barlineLabel;
}
protected override void AddBarline(PlaineAndEasieBarlineTypes barlineType)
{
var barlineStyle = barlineType != PlaineAndEasieBarlineTypes.Single ? BarlineStyle.LightHeavy : BarlineStyle.Regular;
var barline = new Barline(barlineStyle);
if (barlineType == PlaineAndEasieBarlineTypes.RepeatForward)
{
barline.RepeatSign = RepeatSignType.Forward;
}
else if (barlineType == PlaineAndEasieBarlineTypes.RepeatBackward)
{
barline.RepeatSign = RepeatSignType.Backward;
}
else if (barlineType == PlaineAndEasieBarlineTypes.RepeatBoth)
{
barline.RepeatSign = RepeatSignType.Backward;
}
output.FirstStaff.Add(barline);
if (barlineType == PlaineAndEasieBarlineTypes.RepeatBoth)
{
output.FirstStaff.Add(new Barline {
RepeatSign = RepeatSignType.Forward
});
}
}
private void HandleRepeat()
{
_repeat = (Repeat)_element;
_repeatGroup = 0;
_repeats = _repeat.Repeats;
_isCreatingRepeat = true;
HandleTime(_repeat.TimeSignature);
// Check and remove previous bar if it exists
var index = _symbols.Count - 1;
if (_symbols[index].Type is MusicalSymbolType.Barline)
{
_symbols.RemoveAt(_symbols.Count - 1);
}
// Add bar for repeat
var barLine = new Barline {
RepeatSign = RepeatSignType.Forward
};
_symbols.Add(barLine);
// Repeat block
RunActions(_repeat.Elements);
_isCreatingRepeat = false;
}
private void AddRepeat(Repeat repeat)
{
AddSymbolGroup(repeat.Alternatives.First());
if (_symbols.Last() is Barline)
{
_symbols.RemoveAt(_symbols.Count - 1);
}
if (repeat.Alternatives.Count > 1)
{
var index = _symbols.FindLastIndex(b => b is Barline);
_symbols[index] = new Barline {
AlternateRepeatGroup = 1
};
_symbols.Add(new Barline()
{
RepeatSign = RepeatSignType.Backward, AlternateRepeatGroup = 2
});
foreach (var alt in repeat.Alternatives.GetRange(1, repeat.Alternatives.Count - 1))
{
AddSymbolGroup(alt);
}
}
else
{
_symbols.Add(new Barline()
{
RepeatSign = RepeatSignType.Backward
});
}
}
private void HandleBar()
{
var barLine = new Barline();
if (_isCreatingAlternative)
{
barLine.AlternateRepeatGroup = _repeatGroup;
}
_symbols.Add(barLine);
}
public void ProcessToken(Barline barLine)
{
currentBarsOnLine++;
lilypondText.Append("| ");
if (currentBarsOnLine >= Constants.Lilypond.BARS_PER_LINE)
{
currentBarsOnLine = 0;
lilypondText.AppendLine();
}
}
public static void barlineToABC(StreamWriter file, Barline barline)
{
if (barline.Location != string.Empty)
{
if (barline.isSetStyle)
{
if (barline.isSetRepeat && barline.Repeat == "backward")
{
file.Write(" :");
}
if (barline.isSetStyle)
{
switch (barline.Style)
{
case "light-heavy":
file.Write("|]");
break;
case "heavy-light":
file.Write("[|");
break;
case "light-light":
file.Write("||");
break;
case "dotted":
file.Write(".|");
break;
default:
file.Write("|");
break;
}
}
}
if (barline.Location == "left")
{
if (barline.isSetRepeat && barline.Repeat == "forward")
{
file.Write(":");
}
if (barline.isSetEnding)
{
file.Write("[%s ", barline.Ending.Number);
}
}
if (barline.Location == "right" && barline.isSetEnding && barline.Ending.Type == "discontinue")
{
file.Write(" |");
}
}
}
private void DoBarline()
{
if (!ShouldDoBarline())
{
return;
}
Barline br = new Barline();
br.RepeatSign = RepeatSignType.None;
barlinecount = 0;
symbols.Add(br);
}
public override void ParseElement(MusicXmlParserState state, Staff staff, XElement element)
{
var b = new Barline();
element.IfAttribute("location").HasValue("left")
.Then(() => b.Location = HorizontalPlacement.Left)
.Otherwise(r => b.Location = HorizontalPlacement.Right);
element.IfElement("bar-style").HasValue("light-heavy").Then(() => b.Style = BarlineStyle.LightHeavy);
element.IfElement("bar-style").HasValue("none").Then(() => b.Style = BarlineStyle.None);
element.IfElement("bar-style").HasValue("dashed").Then(() => b.Style = BarlineStyle.Dashed);
var repeatAttribute = element.Elements().FirstOrDefault(e => e.Name == "repeat");
var attribute = repeatAttribute?.Attributes().FirstOrDefault(a => a.Name == "direction");
bool add = false;
if (attribute != null)
{
if (attribute.Value == "forward")
{
b.RepeatSign = RepeatSignType.Forward;
}
else if (attribute.Value == "backward")
{
b.RepeatSign = RepeatSignType.Backward;
state.BarlineAlreadyAdded = true;
}
add = true;
}
else if (b.Style != BarlineStyle.Regular)
{
state.BarlineAlreadyAdded = true;
add = true;
}
if (add)
{
if (staff.Part?.Staves.Any() ?? false) //If part contains many staves, add to all staves
{
foreach (var s in staff.Part.Staves)
{
s.Elements.Add(b);
}
}
else
{
staff.Elements.Add(b);
}
}
}
public void DoRepeat()
{
DomainModel.BarLine br = (DomainModel.BarLine)currentNote;
Barline b = new Barline();
if (br.Type == BarLine.TYPE.REPEAT)
{
int alt = 1;
Barline startAlt = new Barline();
startAlt.AlternateRepeatGroup = alt;
symbols.Add(startAlt);
for (int i = 0; i < br.Alternatives.Count; i++)
{
Symbol temp = br.Alternatives[i];
while (temp != null)
{
DomainModel.Note cr = (DomainModel.Note)temp;
PSAMControlLibrary.Note n = new PSAMControlLibrary.Note(cr.Pitch.ToUpper(), 0, 2 + cr.Octave, durriation[cr.Duration],
NoteStemDirection.Up, NoteTieType.None,
new List <NoteBeamType>()
{
NoteBeamType.Single
});
symbols.Add(n);
temp = temp.nextSymbol;
}
if (i == 0)
{
alt++;
Barline blt = new Barline();
blt.RepeatSign = RepeatSignType.Backward;
blt.AlternateRepeatGroup = alt;
symbols.Add(blt);
continue;
}
}
return;
}
b.RepeatSign = reapeatType[br.Type];
symbols.Add(b);
barlinecount = 0;
}
// Moves the next barline to the position immediately after the specified element. If there are no more barlines on
// the staff, creates a new one.
private Barline moveOrAddBarlineAfter(MusicalSymbol item)
{
var elems = item.Staff.Elements;
int itemPosition = elems.IndexOf(item);
Barline bar = (Barline)elems.FirstOrDefault(b => elems.IndexOf(b) > itemPosition && b.GetType() == typeof(Barline));
if (bar == null)
{
bar = new Barline();
}
else
{
item.Staff.Elements.Remove(bar);
}
item.Staff.Elements.Insert(itemPosition + 1, bar);
return(bar);
}
public override void ParseElement(MusicXmlParserState state, Staff staff, XElement element)
{
var b = new Barline();
element.IfAttribute("location").HasValue("left")
.Then(() => b.Location = HorizontalPlacement.Left)
.Otherwise(() => b.Location = HorizontalPlacement.Right);
element.IfElement("bar-style").HasValue("light-heavy").Then(() => b.Style = BarlineStyle.LightHeavy);
foreach (XElement barlineAttribute in element.Elements())
{
if (barlineAttribute.Name == "repeat")
{
var attribute = barlineAttribute.Attribute("direction");
if (attribute != null)
{
if (attribute.Value == "forward")
{
b.RepeatSign = RepeatSignType.Forward;
}
else if (attribute.Value == "backward")
{
b.RepeatSign = RepeatSignType.Backward;
state.BarlineAlreadyAdded = true;
}
//Usuń pojedynczą kreskę taktową, jeśli już taka została dodana:
//Barline existingBarline = staff.Elements.LastOrDefault() as Barline;
//if (existingBarline != null) staff.Elements.Remove(existingBarline);
if (staff.Part != null && staff.Part.Staves.Any()) //If part contains many staves, add to all staves
{
foreach (var s in staff.Part.Staves)
{
s.Elements.Add(b);
}
}
else
{
staff.Elements.Add(b);
}
}
}
}
}
private void CheckEndingRepeat()
{
if (_repeat == null || _isCreatingAlternative || _isCreatingRepeat)
{
return;
}
// Closing bar repeat
var barLineEnd = new Barline {
RepeatSign = RepeatSignType.Backward
};
_symbols.Add(barLineEnd);
_repeat = null;
_repeats = 0;
_repeatGroup = 0;
}
private Barline GetBarline(XmlNode barlineNode)
{
var barline = new Barline();
var styleNode = barlineNode.SelectSingleNode("barline-style");
if (styleNode != null)
{
barline.Style = styleNode.InnerText;
}
string location = barlineNode.Attributes["location"].ToString();
if (location != string.Empty)
{
barline.Location = location;
}
var ending = barlineNode.SelectSingleNode("ending");
if (ending != null)
{
string endingType = ending.Attributes["type"].ToString();
barline.Ending.Type = endingType;
barline.isSetEnding = true;
}
var repeat = barlineNode.SelectSingleNode("repeat");
if (repeat != null)
{
string direction = repeat.Attributes["direction"].ToString();
barline.isSetRepeat = true;
if (direction != string.Empty)
{
barline.Repeat = direction;
}
}
return(barline);
}
//Read the barline
public static BarlineProperties ReadBarline(int barnumber, ScorePartwise.Part.Measure measure)
{
if (getbarindex(barnumber, measure) != -1)
{
Barline barline = (Barline)measure.getNoteOrBackupOrForward().get(getbarindex(barnumber, measure));
BarlineProperties barprop = new BarlineProperties();
if (barline.getEnding() != null)
{
barprop.EndingType = barline.getEnding().getType().value();
barprop.EndingValue = barline.getEnding().getValue();
}
if (barline.getRepeat() != null)
{
barprop.RepeatTimes = barline.getRepeat().getTimes().intValue().ToString();
barprop.RepeatDirection = barline.getRepeat().getDirection().value();
}
barprop.Location = barline.getLocation().value();
return(barprop);
}
return(null);
}
public MidiBarLineEvent(MidiEvent barLineEvent, INote previousNote, ref bool startedNoteIsClosed, ref int previousNoteAbsoluteTicks, int division, TimeSignature timeSignature,
ref double percentageOfBarReached)
{
if (startedNoteIsClosed)
{
return;
}
// Finish the previous note with the length.
SetNoteLength(previousNoteAbsoluteTicks,
barLineEvent.AbsoluteTicks, division, timeSignature.BeatUnit,
timeSignature.BeatsPerBar, out double percentageOfBar, previousNote);
previousNoteAbsoluteTicks = barLineEvent.AbsoluteTicks;
percentageOfBarReached += percentageOfBar;
if (percentageOfBarReached >= 1)
{
BarLine = new Barline();
percentageOfBarReached -= 1;
}
startedNoteIsClosed = true;
}
/// <summary>
/// Parse the barline information given and create an appropriate label that can be put onto a canvas.
/// </summary>
/// <param name="barline">The Barline information to parse</param>
/// <param name="fontSize">The fontsize to use</param>
/// <returns>Label that holds the barline</returns>
public static FrameworkElement RenderBarline(Barline barline, double fontSize)
{
string barlineChar;
switch (barline.barStyle.Value)
{
case BarStyle.regular:
barlineChar = Constants.Barlines.REGULAR;
break;
case BarStyle.lightlight:
barlineChar = Constants.Barlines.LIGHT_LIGHT;
break;
case BarStyle.lightheavy:
barlineChar = Constants.Barlines.LIGHT_HEAVY;
break;
case BarStyle.heavylight:
barlineChar = Constants.Barlines.HEAVY_LIGHT;
break;
case BarStyle.dashed:
barlineChar = Constants.Barlines.DASHED;
break;
default:
barlineChar = Constants.Barlines.REGULAR;
break;
//todo: remainder of barlines
}
FrameworkElement barlineLabel = WPFRendering.GetMusicalLabel(barlineChar, fontSize);
WPFRendering.RecalculateSize(barlineLabel);
return(barlineLabel);
}
public void ProcessToken(Barline barline)
{
var staffBarline = new PSAMControlLibrary.Barline();
_symbols.Add(staffBarline);
}
public void ProcessToken(Barline barLine)
{
// do nothing
}
private void CreateAlternativesMusicBlock()
{
_currentAlternative++;
var musicBlock = (MusicBlock)_element;
HandleTime(musicBlock.TimeSignature);
// Get difference in octaves
var differenceOctaves = 0;
musicBlock.Elements.ForEach(e =>
{
if (!(e is MusicElement))
{
return;
}
var musicElement = (MusicElement)e;
differenceOctaves += musicElement.Octaves;
});
// Check runs
var runs = 1;
if (_currentAlternative == 1)
{
runs = 1 + _repeats - _alternatives;
}
// Do runs
for (var i = 1; i <= runs; i++)
{
// Create repeat group
_repeatGroup++;
// Opening bar
if (_symbols.Last() is Barline)
{
var bar = (Barline)_symbols.Last();
bar.AlternateRepeatGroup = _repeatGroup;
}
else
{
var barLine = new Barline {
AlternateRepeatGroup = _repeatGroup
};
_symbols.Add(barLine);
}
_remembedFirstOctaveAlternative = true;
// Elements in alternative
RunActions(musicBlock.Elements);
if (runs > 1 && i < runs)
{
_mustAlterOctave = true;
_alterOctave = _firstOctaveAlternative;
}
// Closing bar repeat if needed
if (_repeatGroup < _repeats)
{
var barLineEnd = new Barline {
RepeatSign = RepeatSignType.Backward
};
_symbols.Add(barLineEnd);
}
else
{
var barLineEnd = new Barline {
AlternateRepeatGroup = _repeatGroup
};
_symbols.Add(barLineEnd);
}
}
}
/// <summary>
/// Render a measure onto a canvas
/// </summary>
/// <param name="measure">The measure to render</param>
/// <param name="staff">The staff being rendered for</param>
/// <returns>A Framework Element with the measure rendered onto it</returns>
public static Panel RenderMeasure(ScorePartwisePartMeasure measure, int staff, double fontSize) //todo: not return canvas
{
//todo: stack/queue for tie
//todo: stack/queue for slur
//todo: stack/queue for beam
//todo: maybe approach this by doing all staves in render measure?
double left = 0; //todo: padding/margin
double top = 0; //todo: padding/margin
ICollection <object> itemList = measure.Items;
FrameworkElement element = null;
Panel grid = WPFRendering.CreateAutoSizingGrid();
grid.Margin = new Thickness(50, 50, 0, 0); //todo: proper margin
//todo: render each item
for (int i = 0; i < itemList.Count; i++)
{
object obj = itemList.ElementAt(i);
Type type = obj.GetType();
if (type == typeof(Attributes))
{
Attributes attributes = (Attributes)obj;
element = RenderAttributes(attributes, staff, fontSize);
}
else if (type == typeof(Note))
{
//todo: may need to use attributes from previous measure to figure out where to render
Note note = (Note)obj;
element = RenderNoteOrRest(note, fontSize);
}
else if (type == typeof(Barline))
{
Barline barline = (Barline)obj;
element = RenderBarline(barline, fontSize);
}
else if (type == typeof(Print))
{
//todo: complete this section
element = new Label();
}
else if (type == typeof(Direction))
{
//todo: complete this section
element = new Label();
}
if (element != null)
{
element.Margin = new Thickness(left, top, 0, 0);
grid.Children.Add(element);
left += element.ActualWidth + 0; //todo: margin
}
else
{
throw new NullMeasureElementException("Null element: " + obj.GetType() + "\n");
}
}
//todo: render multiple staves for multi-part instruments etc
// This should be as simple as rendering a second staff then putting the note onto that staff as required
// Then joining those two staves via a wrapper container
element = RenderStaff(Constants.Colors.DEFAULT_NOTE_COLOR, left, fontSize);
grid.Children.Add(element);
WPFRendering.RecalculateSize(grid);
return(grid);
}
public bool Equals(Barline obj)
{
return(obj != null);
}
/// <summary>
/// Adds a barline to the current measure if needed, and breaks the last note of the measure if it
/// exceeds the allowed beats/measure, inserting the remainder into the next measure. Then recursively calls
/// itself on subsequent measures until it hits a measure that does not overflow.
/// </summary>
/// <param name="m"></param>
/// <param name="ts"></param>
internal void fitMeasure(Measure m, TimeSignature ts) // Still need to add support for deletion
{
bool nextMeasureChanged = false;
Staff staff = m.Staff;
int measureIndex = staff.Measures.IndexOf(m);
foreach (MusicalSymbol item in m.Elements)
{
// If new time signature, update
if (item.GetType() == typeof(TimeSignature))
{
ts = (TimeSignature)item;
}
// Make sure that any cleffs and signatures are at the beginning of the measure, before notes and rests
if (item.GetType() == typeof(TimeSignature) || item.GetType() == typeof(Key) || item.GetType() == typeof(Clef))
{
NoteOrRest firstBeat = getFirstBeat(m);
if (m.Elements.IndexOf(firstBeat) < m.Elements.IndexOf(item))
{
swapPositions(staff, item, firstBeat);
}
}
}
// While the current measure is not full and is not the end of the song, steal the first beat from the next measure
// ****VERIFY THIS CODE ONCE NOTE DELETION IS IN PLACE****
while (getDurations(m).Sum() < ts.WholeNoteCapacity &&
m.Number < staff.Measures.Count &&
getFirstBeat(getNextMeasure(m)) != null)
{
Measure next = getNextMeasure(m);
NoteOrRest nr = getFirstBeat(next);
next.Elements.Remove(nr);
m.Elements.Add(nr); // This note might be longer than we have room for, but the next loop will take care of it
nextMeasureChanged = true;
}
// While the current measure has too many beats, push the extra into the next measure
while (getDurations(m).Sum() > ts.WholeNoteCapacity)
{
double overage = getOverage(m, ts); // How much the content of the current measure exceeds its alloted time
NoteOrRest lastNoteOrRest = (NoteOrRest)m.Elements.Last(e => e.GetType().IsSubclassOf(typeof(NoteOrRest))); // Last note or rest in measure
double lastDurationValue = lastNoteOrRest.Duration.ToDouble(); // Value of last note or rest in measure
int lastItemIndex = staff.Elements.IndexOf(lastNoteOrRest); // Index of last note or rest in the measure
NoteOrRest itemToMove = null; // The last note or portion thereof that doesn't fit in the current measure
// If the overage is because the last note is too big, break it into two notes
if (lastDurationValue > overage)
{
NoteOrRest itemInPlace; // Shortened version of lastNoteOrRest that fits in currrent measure
if (lastNoteOrRest.GetType() == typeof(Note))
{
itemInPlace = new Note(((Note)lastNoteOrRest).Pitch, toRhythmicDuration(lastDurationValue - overage));
itemToMove = new Note(((Note)lastNoteOrRest).Pitch, toRhythmicDuration(overage)); // Remaining note value
}
else
{
itemInPlace = new Rest(toRhythmicDuration(lastDurationValue - overage));
itemToMove = new Rest(toRhythmicDuration(overage));
}
// Have to remove lastNoteOrRest from both the staff and the measure
staff.Elements.Remove(lastNoteOrRest);
m.Elements.Remove(lastNoteOrRest);
// Replace with shortened version, automatically populates to measure when adding
staff.Elements.Insert(lastItemIndex, itemInPlace);
}
else
{
itemToMove = lastNoteOrRest;
staff.Elements.Remove(lastNoteOrRest);
m.Elements.Remove(lastNoteOrRest);
lastItemIndex--;
}
// Refresh the updated measure in the staff.measures collection
Barline bar = moveOrAddBarlineAfter(staff.Elements[lastItemIndex]);
// Add itemToMove after the barline
staff.Elements.Insert(lastItemIndex + 2, itemToMove);
// Add it to the measure as well if it's not already there
Measure nextMeasure = getNextMeasure(m);
if (!nextMeasure.Elements.Contains(itemToMove))
{
nextMeasure.Elements.Insert(0, itemToMove);
}
// set the flag to check the next measure
nextMeasureChanged = true;
}
// If there are changes to the next measure, fix it.
if (nextMeasureChanged)
{
fitMeasure(getNextMeasure(m), ts);
}
}
public void ProcessToken(Barline barLine)
{
barPercentage = 0;
}
public void BuildSequence_checkConversion()
{
foreach (Sequence testSequence in testList)
{
foreach (ObjectInSequence obj in testSequence.ObjectsInSequence)
{
Assert.AreNotEqual(obj.Evidence, Evidence.Invalid);
switch (obj.Type)
{
case ObjectType.Accidental:
Accidental accid = (Accidental)obj;
Assert.AreNotEqual(Model.AccidType.Null, accid.AccidentalType);
break;
case ObjectType.Barline:
Barline bl = (Barline)obj;
Assert.AreNotEqual(Model.BarlineType.Null, bl.BarlineType);
break;
case ObjectType.Clef:
Model.Clef clef = (Model.Clef)obj;
Assert.AreNotEqual(Model.Clefshape.Null, clef.Shape);
break;
case ObjectType.KeyAccidental:
KeyAccidental keyacc = (KeyAccidental)obj;
Assert.AreNotEqual(Model.AccidType.Null, keyacc.AccidentalType);
break;
case ObjectType.Mensur:
Model.Mensur mens = (Model.Mensur)obj;
Assert.AreNotEqual(0, mens.Tempus);
break;
case ObjectType.Note:
Model.Note note = (Model.Note)obj;
Assert.AreNotEqual(0, note.WrittenPitch);
Assert.AreNotEqual(Model.Duration.Null, note.Duration);
break;
case ObjectType.Proportion:
Proportion prop = (Proportion)obj;
Assert.AreNotEqual(0, prop.Num);
Assert.AreNotEqual(0, prop.Numbase);
break;
case ObjectType.Rest:
Model.Rest rest = (Model.Rest)obj;
Assert.AreNotEqual(Model.Duration.Null, rest.Duration);
break;
case ObjectType.Custos:
break;
case ObjectType.Dot:
break;
case ObjectType.Gap:
Model.Gap gap = (Model.Gap)obj;
Assert.AreNotEqual(Model.GapType.Null, gap.GapType);
break;
default:
Assert.Fail($"Test of {obj.Type} {obj.ID} failed!");
break;
}
}
}
}
public abstract void AddSymbol(Barline barLine);
