private void DrawLyrics(ScoreRendererBase renderer, Note element)
{
double versePositionY = scoreService.CurrentLinePositions[4] + 10; //Default value if default-y is not set
foreach (Lyrics lyrics in element.Lyrics)
{
var textPosition = lyrics.DefaultYPosition.HasValue ?
scoreService.CurrentLinePositions[0] - renderer.TenthsToPixels(lyrics.DefaultYPosition.Value) :
versePositionY;
StringBuilder sBuilder = new StringBuilder();
sBuilder.Append(lyrics.Text);
//TODO: Dodać do kalkulacji wyliczoną szerokość stringa w poprzednim lyricu i odkomentować :)
//A, i jeszcze wtedy wywalić warunek na middleDistance.
//double middleDistanceBetweenTwoLyrics = (scoreService.CursorPositionX - renderer.State.LastNoteEndXPosition) / 2.0d;
// double hyphenXPosition = scoreService.CursorPositionX - middleDistanceBetweenTwoLyrics;
//if ((lyrics.Type == SyllableType.Middle || lyrics.Type == SyllableType.End) && middleDistanceBetweenTwoLyrics > 20)
//{
// renderer.DrawString("-", FontStyles.LyricsFont, hyphenXPosition, textPositionY, element);
//}
//else
if (lyrics.Type == SyllableType.Begin || lyrics.Type == SyllableType.Middle)
{
sBuilder.Append("-");
}
renderer.DrawString(sBuilder.ToString(), MusicFontStyles.LyricsFont, scoreService.CursorPositionX, textPosition, lyrics);
if (!lyrics.DefaultYPosition.HasValue)
{
versePositionY += 12; //Move down if default-y is not set
}
}
}
private void DrawOrnaments(ScoreRendererBase renderer, Note element, double notePositionY, FontProfile fontProfile)
{
foreach (Ornament ornament in element.Ornaments)
{
double yPosition;
if (ornament.DefaultYPosition.HasValue)
{
var yShift = renderer.TenthsToPixels(ornament.DefaultYPosition.Value);
yPosition = scoreService.CurrentLinePositions[0] + yShift;
}
else
{
yPosition = notePositionY + (ornament.Placement == VerticalPlacement.Above ? -20 : 20);
}
yPosition = CorrectOrnamentYPositionToAvoidIntersection(renderer, ornament.Placement, renderer.LinespacesToPixels(1), yPosition, element, notePositionY);
Mordent mordent = ornament as Mordent;
if (mordent != null)
{
if (renderer.IsSMuFLFont)
{
renderer.DrawCharacter(mordent.GetCharacter(fontProfile.MusicFont),
MusicFontStyles.MusicFont, scoreService.CursorPositionX - element.GetNoteheadWidthPx(renderer) / 2,
yPosition, element);
}
else
{
renderer.DrawCharacter(fontProfile.MusicFont.MordentShort, MusicFontStyles.GraceNoteFont, scoreService.CursorPositionX, yPosition, element);
renderer.DrawCharacter(fontProfile.MusicFont.Mordent, MusicFontStyles.GraceNoteFont, scoreService.CursorPositionX + 5.5, yPosition, element);
}
}
}
}
private void DrawOrnaments(ScoreRendererBase renderer, Note element, double notePositionY)
{
foreach (Ornament ornament in element.Ornaments)
{
double yPositionShift = ornament.DefaultYPosition.HasValue ? renderer.TenthsToPixels(ornament.DefaultYPosition.Value) * -1 : (ornament.Placement == VerticalPlacement.Above ? -20 : 20);
Mordent mordent = ornament as Mordent;
if (mordent != null)
{
renderer.DrawString(renderer.Settings.CurrentFont.MordentShort, MusicFontStyles.GraceNoteFont, scoreService.CursorPositionX - 2, notePositionY + yPositionShift, element);
renderer.DrawString(renderer.Settings.CurrentFont.Mordent, MusicFontStyles.GraceNoteFont, scoreService.CursorPositionX + 3.5, notePositionY + yPositionShift, element);
}
}
}
public override void Render(Direction element, ScoreRendererBase renderer)
{
//Performance directions / Wskazówki wykonawcze:
double dirPositionY = 0;
if (element.Placement == DirectionPlacementType.Custom)
{
dirPositionY = scoreService.CurrentStaffTop - renderer.TenthsToPixels(element.DefaultYPosition.Value);
}
else if (element.Placement == DirectionPlacementType.Above)
{
dirPositionY = 0;
}
else if (element.Placement == DirectionPlacementType.Below)
{
dirPositionY = 50;
}
var metronomeDirection = element as MetronomeDirection;
if (metronomeDirection != null)
{
var note = new Note(metronomeDirection.Tempo.BeatUnit);
renderer.DrawString(note.MusicalCharacter, MusicFontStyles.GraceNoteFont, scoreService.CursorPositionX, dirPositionY - 8, element);
if (metronomeDirection.Tempo.BeatUnit.Denominator > 1)
{
renderer.DrawLine(scoreService.CursorPositionX + 10, dirPositionY + 9, scoreService.CursorPositionX + 10, dirPositionY - 2, metronomeDirection);
if (metronomeDirection.Tempo.BeatUnit.Denominator > 4)
{
renderer.DrawString(note.NoteFlagCharacter, MusicFontStyles.GraceNoteFont, new Point(scoreService.CursorPositionX + 6, dirPositionY - 24), element);
}
}
renderer.DrawString($" = {metronomeDirection.Tempo.BeatsPerMinute}", MusicFontStyles.DirectionFont, scoreService.CursorPositionX + 12, dirPositionY, element);
return;
}
renderer.DrawString(element.Text, MusicFontStyles.DirectionFont, scoreService.CursorPositionX, dirPositionY, element);
}
/// <summary>
/// Renders a rest with specific score renderer
/// </summary>
/// <param name="element"></param>
/// <param name="renderer"></param>
public override void Render(Rest element, ScoreRendererBase renderer, FontProfile fontProfile)
{
var isOnlyElementInMeasure = element.Measure?.Elements?.OfType <NoteOrRest>().Count() == 1;
if (!renderer.Settings.IgnoreCustomElementPositions && element.DefaultXPosition.HasValue) //Jeśli ustalono default-x, to pozycjonuj wg default-x, a nie automatycznie
{
scoreService.CursorPositionX = measurementService.LastMeasurePositionX +
element.DefaultXPosition.Value * renderer.Settings.CustomElementPositionRatio;
}
else if (isOnlyElementInMeasure && (element.Measure?.Width.HasValue ?? false))
{
scoreService.CursorPositionX = measurementService.LastMeasurePositionX + (element.Measure.Width.Value / 2) * renderer.Settings.CustomElementPositionRatio;
}
if (scoreService.CurrentMeasure.FirstNoteInMeasureXPosition == 0)
{
scoreService.CurrentMeasure.FirstNoteInMeasureXPosition = scoreService.CursorPositionX;
}
//If it's second voice, rewind position to the beginning of measure (but only if default-x is not set or is ignored):
if (element.Voice > scoreService.CurrentVoice && (renderer.Settings.IgnoreCustomElementPositions || !element.DefaultXPosition.HasValue))
{
scoreService.CursorPositionX = scoreService.CurrentMeasure.FirstNoteInMeasureXPosition;
measurementService.LastNoteInMeasureEndXPosition = measurementService.LastNoteEndXPosition;
}
scoreService.CurrentVoice = element.Voice;
double restPositionY = scoreService.CurrentLinePositions[0] +
(element.DefaultYPosition.HasValue ? renderer.TenthsToPixels(element.DefaultYPosition.Value) : renderer.LinespacesToPixels(2));
renderer.DrawCharacter(element.GetCharacter(fontProfile.MusicFont), MusicFontStyles.MusicFont, scoreService.CursorPositionX, restPositionY, element);
measurementService.LastNotePositionX = scoreService.CursorPositionX;
element.TextBlockLocation = new Point(scoreService.CursorPositionX, restPositionY);
//Draw number of measures for multimeasure rests / Rysuj ilość taktów dla pauz wielotaktowych:
if (element.MultiMeasure > 1)
{
renderer.DrawString(Convert.ToString(element.MultiMeasure), MusicFontStyles.DirectionFont, scoreService.CursorPositionX + 6, restPositionY, element);
}
//Draw dots / Rysuj kropki:
if (element.NumberOfDots > 0)
{
scoreService.CursorPositionX += 16;
}
for (int i = 0; i < element.NumberOfDots; i++)
{
renderer.DrawCharacter(fontProfile.MusicFont.AugmentationDot, MusicFontStyles.MusicFont, scoreService.CursorPositionX, restPositionY, element);
scoreService.CursorPositionX += 6;
}
if (renderer.Settings.IgnoreCustomElementPositions || !element.DefaultXPosition.HasValue) //Pozycjonowanie automatyczne tylko, gdy nie określono default-x
{
if (element.Duration == RhythmicDuration.Whole)
{
scoreService.CursorPositionX += 48;
}
else if (element.Duration == RhythmicDuration.Half)
{
scoreService.CursorPositionX += 28;
}
else if (element.Duration == RhythmicDuration.Quarter)
{
scoreService.CursorPositionX += 17;
}
else if (element.Duration == RhythmicDuration.Eighth)
{
scoreService.CursorPositionX += 15;
}
else
{
scoreService.CursorPositionX += 14;
}
}
measurementService.LastNoteEndXPosition = scoreService.CursorPositionX;
}
private void DrawStems(ScoreRendererBase renderer, Note element, double notePositionY)
{
if (element.Duration == RhythmicDuration.Whole)
{
return;
}
double tmpStemPosY;
tmpStemPosY = scoreService.CurrentStaffTop + renderer.TenthsToPixels(element.StemDefaultY);
if (element.StemDirection == VerticalDirection.Down)
{
//Ogonki elementów akordów nie były dobrze wyświetlane, jeśli stosowałem
//default-y. Dlatego dla akordów zostawiam domyślne rysowanie ogonków.
//Stems of chord elements were displayed wrong when I used default-y
//so I left default stem drawing routine for chords.
if (element.IsUpperMemberOfChord)
{
beamingService.CurrentStemEndPositionY = notePositionY + 18;
}
else if (renderer.Settings.IgnoreCustomElementPositions || !element.HasCustomStemEndPosition)
{
beamingService.CurrentStemEndPositionY = notePositionY + 18;
}
else
{
beamingService.CurrentStemEndPositionY = tmpStemPosY - 4;
}
beamingService.CurrentStemPositionX = scoreService.CursorPositionX + 7 + (element.IsGraceNote || element.IsCueNote ? -0.5 : 0);
}
else
{
//Ogonki elementów akordów nie były dobrze wyświetlane, jeśli stosowałem
//default-y. Dlatego dla akordów zostawiam domyślne rysowanie ogonków.
//Stems of chord elements were displayed wrong when I used default-y
//so I left default stem drawing routine for chords.
if (element.IsUpperMemberOfChord)
{
beamingService.CurrentStemEndPositionY = notePositionY - 25 < beamingService.CurrentStemEndPositionY ? beamingService.CurrentStemEndPositionY : notePositionY - 25;
}
else if (renderer.Settings.IgnoreCustomElementPositions || !element.HasCustomStemEndPosition)
{
//var notesUnderBeam = beamingService.GetAllNotesUnderOneBeam(element);
//var maxDistance = notesUnderBeam == null || !notesUnderBeam.Any() ? 0 : GetMaxVertDistanceBetweenNotes(renderer, notesUnderBeam.ToArray());
//maxDistance *= 2;
beamingService.CurrentStemEndPositionY = notePositionY - 25;
}
else
{
beamingService.CurrentStemEndPositionY = tmpStemPosY - 6;
}
beamingService.CurrentStemPositionX = scoreService.CursorPositionX + 13 + (element.IsGraceNote || element.IsCueNote ? -2 : 0);
}
var uglyModifier = element.StemDirection == VerticalDirection.Down ? 3 : 7;
if (element.BeamList.Count > 0)
{
if ((element.BeamList[0] != NoteBeamType.Continue) || element.HasCustomStemEndPosition)
{
renderer.DrawLine(new Point(beamingService.CurrentStemPositionX, notePositionY - uglyModifier + 30),
new Point(beamingService.CurrentStemPositionX, beamingService.CurrentStemEndPositionY + 28), element);
}
}
element.StemEndLocation = new Point(beamingService.CurrentStemPositionX, beamingService.CurrentStemEndPositionY);
}
private void DrawStems(ScoreRendererBase renderer, Note element, double notePositionY, Note[] chord)
{
if (element.BaseDuration > RhythmicDuration.Half || element.IsUpperMemberOfChord)
{
return;
}
var additionalPlaceForFlag = Math.Log(element.BaseDuration.Denominator, 2) - 2;
if (additionalPlaceForFlag < 0)
{
additionalPlaceForFlag = 0;
}
if (additionalPlaceForFlag > 1)
{
additionalPlaceForFlag *= 0.8;
}
var defaultStemLengthLs = 3 + ((element.BeamList.Any(b => b == NoteBeamType.Single) ? additionalPlaceForFlag : 0)) * (element.IsCueNote || element.IsGraceNote ? 0.66 : 1);
var defaultStemLength = renderer.LinespacesToPixels(defaultStemLengthLs);
double customStemEndPosition = scoreService.CurrentStaffTop + renderer.TenthsToPixels(element.StemDefaultY);
double notePositionForCalculatingStemEnd = GetNotePositionForCalculatingStemEnd(renderer, element, notePositionY, chord);
double notePositionForCalculatingStemStart = GetNotePositionForCalculatingStemStart(renderer, element, notePositionY, chord);
if (element.StemDirection == VerticalDirection.Down)
{
if (renderer.Settings.IgnoreCustomElementPositions || !element.HasCustomStemEndPosition)
{
beamingService.CurrentStemEndPositionY = notePositionForCalculatingStemEnd + defaultStemLength;
}
else
{
beamingService.CurrentStemEndPositionY = customStemEndPosition - 4;
}
}
else
{
if (renderer.Settings.IgnoreCustomElementPositions || !element.HasCustomStemEndPosition)
{
beamingService.CurrentStemEndPositionY = notePositionForCalculatingStemEnd - defaultStemLength;
}
else
{
beamingService.CurrentStemEndPositionY = customStemEndPosition - 6;
}
}
if (renderer.IsSMuFLFont)
{
var cueNoteShift = element.StemDirection == VerticalDirection.Up ? -3 : 0;
beamingService.CurrentStemPositionX = scoreService.CursorPositionX +
element.GetNoteheadWidthPx(renderer) * (element.StemDirection == VerticalDirection.Down ? 0 : 1) +
(element.IsGraceNote || element.IsCueNote ? cueNoteShift : 0);
}
else
{
var polihymniaBadDesignFontFix = element.GetNoteheadWidthPx(renderer) * (element.IsCueNote || element.IsGraceNote ? 2 : 1) + 0.5;
beamingService.CurrentStemPositionX = scoreService.CursorPositionX +
polihymniaBadDesignFontFix +
(element.GetNoteheadWidthPx(renderer) / 2) * (element.StemDirection == VerticalDirection.Down ? -1 : 1) +
(element.IsGraceNote || element.IsCueNote ? -2 : 0);
}
if (element.BeamList.Count > 0 && (element.BeamList[0] != NoteBeamType.Continue || element.HasCustomStemEndPosition))
{
var stemPen = renderer.CreatePenFromDefaults(element, "stemThickness", s => s.DefaultStemThickness);
renderer.DrawLine(
new Point(beamingService.CurrentStemPositionX, notePositionForCalculatingStemStart),
new Point(beamingService.CurrentStemPositionX, beamingService.CurrentStemEndPositionY),
stemPen,
element);
}
element.StemEndLocation = new Point(beamingService.CurrentStemPositionX, beamingService.CurrentStemEndPositionY);
if (element.GraceNoteType == GraceNoteType.Slashed)
{
renderer.DrawLine(beamingService.CurrentStemPositionX - 5, notePositionY - 5,
beamingService.CurrentStemPositionX + 5, notePositionY - 5 - 6, element);
}
}
