protected override void PaintGrouped(float cx, float cy, float endX, ICanvas canvas)
{
PaintNonGrouped(cx, cy, canvas);
var lineSpacing = LineSpacing * Scale;
var textWidth = canvas.MeasureText(_label);
var startX = cx + X + textWidth + lineSpacing;
var lineY = cy + Y + (LineTopPadding * Scale);
var lineSize = LineSize * Scale;
if (endX > startX)
{
var lineX = startX;
while (lineX < endX)
{
canvas.BeginPath();
canvas.MoveTo(lineX, (int)lineY);
canvas.LineTo(Math.Min(lineX + lineSize, endX), (int)lineY);
lineX += lineSize + lineSpacing;
canvas.Stroke();
}
canvas.BeginPath();
canvas.MoveTo(endX, (int)(lineY - LineTopOffset * Scale));
canvas.LineTo(endX, (int)(lineY + LineTopOffset * Scale));
canvas.Stroke();
}
}
protected override void PaintGrouped(float cx, float cy, float endX, ICanvas canvas)
{
PaintNonGrouped(cx, cy, canvas);
var lineSpacing = LineSpacing * Scale;
var textWidth = canvas.MeasureText(_label);
var startX = cx + X + textWidth + lineSpacing;
var lineY = cy + Y + (LineTopPadding * Scale);
var lineSize = LineSize * Scale;
if (endX > startX)
{
var lineX = startX;
while (lineX < endX)
{
canvas.BeginPath();
canvas.MoveTo(lineX, (int)lineY);
canvas.LineTo(Math.Min(lineX + lineSize, endX), (int)lineY);
lineX += lineSize + lineSpacing;
canvas.Stroke();
}
canvas.BeginPath();
canvas.MoveTo(endX, (int)(lineY - LineTopOffset * Scale));
canvas.LineTo(endX, (int)(lineY + LineTopOffset * Scale));
canvas.Stroke();
}
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var scoreBarRenderer = (ScoreBarRenderer)Renderer;
var lineSize = scoreBarRenderer.LineOffset;
var topY = cy + Y + scoreBarRenderer.GetNoteY(_beat.MaxNote);
var bottomY = cy + Y + scoreBarRenderer.GetNoteY(_beat.MinNote) + lineSize;
var arrowX = cx + X + Width / 2;
var arrowSize = 8 * Scale;
if (_beat.BrushType == BrushType.ArpeggioUp || _beat.BrushType == BrushType.ArpeggioDown)
{
var size = 14 * Scale;
var waveTop = topY;
var waveBottom = bottomY;
if (_beat.BrushType == BrushType.ArpeggioUp)
{
waveTop -= lineSize;
waveBottom -= arrowSize;
var steps = Math.Floor((waveBottom - waveTop) / size);
for (var i = 0; i < steps; i++)
{
canvas.FillMusicFontSymbol(cx + X + (2 * Scale), waveBottom - ((i + 1) * size), 1, MusicFontSymbol.WaveVertical);
}
}
else
{
waveTop += arrowSize;
waveBottom += lineSize;
var steps = Math.Floor((waveBottom - waveTop) / size);
for (var i = 0; i < steps; i++)
{
canvas.FillMusicFontSymbol(cx + X + (2 * Scale), waveTop + (i * size), 1, MusicFontSymbol.WaveVertical);
}
}
if (_beat.BrushType == BrushType.ArpeggioUp)
{
canvas.BeginPath();
canvas.MoveTo(arrowX, bottomY);
canvas.LineTo(arrowX + arrowSize / 2, bottomY - arrowSize);
canvas.LineTo(arrowX - arrowSize / 2, bottomY - arrowSize);
canvas.ClosePath();
canvas.Fill();
}
else if (_beat.BrushType == BrushType.ArpeggioDown)
{
canvas.BeginPath();
canvas.MoveTo(arrowX, topY);
canvas.LineTo(arrowX + arrowSize / 2, topY + arrowSize);
canvas.LineTo(arrowX - arrowSize / 2, topY + arrowSize);
canvas.ClosePath();
canvas.Fill();
}
}
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
//TODO: Create webfont version
var scoreBarRenderer = (ScoreBarRenderer)Renderer;
var lineSize = scoreBarRenderer.LineOffset;
var startY = cy + Y + (scoreBarRenderer.GetNoteY(_beat.MaxNote) - lineSize);
var endY = cy + Y + scoreBarRenderer.GetNoteY(_beat.MinNote) + lineSize;
var arrowX = cx + X + Width / 2;
var arrowSize = 8 * Scale;
if (_beat.BrushType != BrushType.None)
{
if (_beat.BrushType == BrushType.ArpeggioUp)
{
var lineStartY = startY - arrowSize;
var lineEndY = endY - arrowSize;
canvas.BeginRotate(cx + X + 2 * Scale, lineEndY, -90);
var glyph = new NoteVibratoGlyph(0, 0, VibratoType.Slight);
glyph.Renderer = Renderer;
glyph.DoLayout();
glyph.Width = Math.Abs(lineEndY - lineStartY);
glyph.Paint(0, 0, canvas);
canvas.EndRotate();
canvas.BeginPath();
canvas.MoveTo(arrowX, endY);
canvas.LineTo(arrowX + arrowSize / 2, endY - arrowSize);
canvas.LineTo(arrowX - arrowSize / 2, endY - arrowSize);
canvas.ClosePath();
canvas.Fill();
}
else if (_beat.BrushType == BrushType.ArpeggioDown)
{
var lineStartY = startY + arrowSize;
var lineEndY = endY + arrowSize;
canvas.BeginRotate(cx + X + 7 * Scale, lineStartY, 90);
var glyph = new NoteVibratoGlyph(0, 0, VibratoType.Slight);
glyph.Renderer = Renderer;
glyph.DoLayout();
glyph.Width = Math.Abs(lineEndY - lineStartY);
glyph.Paint(0, 0, canvas);
canvas.EndRotate();
canvas.BeginPath();
canvas.MoveTo(arrowX, startY);
canvas.LineTo(arrowX + arrowSize / 2, startY + arrowSize);
canvas.LineTo(arrowX - arrowSize / 2, startY + arrowSize);
canvas.ClosePath();
canvas.Fill();
}
}
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
// TODO: Create webfont version
var tabBarRenderer = (TabBarRenderer)Renderer;
var res = Renderer.Resources;
var startY = cy + X + (tabBarRenderer.GetNoteY(_beat.MaxNote) - res.TablatureFont.Size / 2);
var endY = cy + Y + tabBarRenderer.GetNoteY(_beat.MinNote) + res.TablatureFont.Size / 2;
var arrowX = (int)(cx + X + Width / 2);
var arrowSize = 8 * Scale;
if (_beat.BrushType != BrushType.None)
{
if (_beat.BrushType == BrushType.BrushUp || _beat.BrushType == BrushType.BrushDown)
{
canvas.BeginPath();
canvas.MoveTo(arrowX, startY);
canvas.LineTo(arrowX, endY);
canvas.Stroke();
}
else
{
//var size = 15 * Scale;
//var steps = Math.Abs(endY - startY) / size;
//for (var i = 0; i < steps; i++)
//{
// canvas.FillMusicFontSymbol(cx + X + (3 * Scale), 1, startY + (i * size), MusicFontSymbol.WaveVertical);
//}
}
if (_beat.BrushType == BrushType.BrushUp || _beat.BrushType == BrushType.ArpeggioUp)
{
canvas.BeginPath();
canvas.MoveTo(arrowX, endY);
canvas.LineTo(arrowX + arrowSize / 2, endY - arrowSize);
canvas.LineTo(arrowX - arrowSize / 2, endY - arrowSize);
canvas.ClosePath();
canvas.Fill();
}
else
{
canvas.BeginPath();
canvas.MoveTo(arrowX, startY);
canvas.LineTo(arrowX + arrowSize / 2, startY + arrowSize);
canvas.LineTo(arrowX - arrowSize / 2, startY + arrowSize);
canvas.ClosePath();
canvas.Fill();
}
}
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var tabBarRenderer = (TabBarRenderer)Renderer;
var res = Renderer.Resources;
var startY = cy + X + (tabBarRenderer.GetNoteY(_beat.MaxNote) - res.TablatureFont.Size / 2);
var endY = cy + Y + tabBarRenderer.GetNoteY(_beat.MinNote) + res.TablatureFont.Size / 2;
var arrowX = (int)(cx + X + Width / 2);
var arrowSize = 8 * Scale;
if (_beat.BrushType != BrushType.None)
{
if (_beat.BrushType == BrushType.BrushUp || _beat.BrushType == BrushType.BrushDown)
{
canvas.BeginPath();
canvas.MoveTo(arrowX, startY);
canvas.LineTo(arrowX, endY);
canvas.Stroke();
}
else
{
var size = 15 * Scale;
var steps = Math.Abs(endY - startY) / size;
for (var i = 0; i < steps; i++)
{
canvas.FillMusicFontSymbol(cx + X + (3 * Scale), 1, startY + (i * size), MusicFontSymbol.WaveVertical);
}
}
if (_beat.BrushType == BrushType.BrushUp || _beat.BrushType == BrushType.ArpeggioUp)
{
canvas.BeginPath();
canvas.MoveTo(arrowX, endY);
canvas.LineTo(arrowX + arrowSize / 2, endY - arrowSize);
canvas.LineTo(arrowX - arrowSize / 2, endY - arrowSize);
canvas.ClosePath();
canvas.Fill();
}
else
{
canvas.BeginPath();
canvas.MoveTo(arrowX, startY);
canvas.LineTo(arrowX + arrowSize / 2, startY + arrowSize);
canvas.LineTo(arrowX - arrowSize / 2, startY + arrowSize);
canvas.ClosePath();
canvas.Fill();
}
}
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var blockWidth = 4 * Scale;
var top = cy + Y + Renderer.TopPadding;
var bottom = cy + Y + Renderer.Height - Renderer.BottomPadding;
var left = cx + X + 0.5f;
// big bar
var h = bottom - top;
canvas.FillRect(left, top, blockWidth, h);
// line
left += (blockWidth * 2) - 0.5f;
canvas.BeginPath();
canvas.MoveTo(left, top);
canvas.LineTo(left, bottom);
canvas.Stroke();
//circles
left += 3 * Scale;
var circleSize = _circleSize * Scale;
var middle = (top + bottom) / 2;
canvas.FillCircle(left, middle - (circleSize * _dotOffset), circleSize);
canvas.FillCircle(left, middle + (circleSize * _dotOffset), circleSize);
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
// calculate offsets per step
var dX = Width / BendPoint.MaxPosition;
var maxValue = 0;
for (int i = 0, j = _note.BendPoints.Count; i < j; i++)
{
if (_note.BendPoints[i].Value > maxValue)
{
maxValue = _note.BendPoints[i].Value;
}
}
cx += X;
cy += Y;
canvas.BeginPath();
for (int i = 0, j = _note.BendPoints.Count - 1; i < j; i++)
{
var firstPt = _note.BendPoints[i];
var secondPt = _note.BendPoints[i + 1];
// draw pre-bend if previous
if (i == 0 && firstPt.Value != 0 && !_note.IsTieDestination)
{
PaintBend(new BendPoint(), firstPt, cx, cy, dX, canvas);
}
// don't draw a line if there's no offset and it's the last point
if (firstPt.Value == secondPt.Value && i == _note.BendPoints.Count - 2) continue;
PaintBend(firstPt, secondPt, cx, cy, dX, canvas);
}
}
//private static readonly Random Random = new Random();
protected override void PaintBackground(float cx, float cy, ICanvas canvas)
{
var res = Resources;
//var c = new Color((byte)Random.Next(255),
// (byte)Random.Next(255),
// (byte)Random.Next(255),
// 100);
//canvas.Color = c;
//canvas.FillRect(cx + X, cy + Y, Width, Height);
//
// draw string lines
//
canvas.Color = res.StaveLineColor;
var lineY = cy + Y + GlyphOverflow;
for (var i = 0; i < 5; i++)
{
if (i > 0)
{
lineY += LineOffset;
}
canvas.BeginPath();
canvas.MoveTo(cx + X, (int)lineY);
canvas.LineTo(cx + X + Width, (int)lineY);
canvas.Stroke();
}
canvas.Color = res.MainGlyphColor;
}
private void PaintFooter(float cx, float cy, ICanvas canvas, BeamingHelper h)
{
var beat = h.Beats[0];
if (beat.Duration == Duration.Whole)
{
return;
}
//
// draw line
//
var beatLineX = h.GetBeatLineX(beat) + Scale;
const float topY = 0;
var bottomY = Height;
float beamY = _direction == BeamDirection.Down ? bottomY : topY;
canvas.BeginPath();
canvas.MoveTo(cx + X + beatLineX, cy + Y + topY);
canvas.LineTo(cx + X + beatLineX, cy + Y + bottomY);
canvas.Stroke();
//
// Draw beam
//
var glyph = new BeamGlyph(beatLineX, beamY, beat.Duration, _direction, false);
glyph.Renderer = this;
glyph.DoLayout();
glyph.Paint(cx + X, cy + Y, canvas);
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var blockWidth = 4 * Scale;
var top = cy + Y + Renderer.TopPadding;
var bottom = cy + Y + Renderer.Height - Renderer.BottomPadding;
var left = cx + X + 0.5f;
// big bar
var h = bottom - top;
canvas.FillRect(left, top, blockWidth, h);
// line
left += (blockWidth * 2) - 0.5f;
canvas.BeginPath();
canvas.MoveTo(left, top);
canvas.LineTo(left, bottom);
canvas.Stroke();
//circles
left += 3 * Scale;
var circleSize = _circleSize * Scale;
var middle = (top + bottom) / 2;
canvas.FillCircle(left, middle - (circleSize * _dotOffset), circleSize);
canvas.FillCircle(left, middle + (circleSize * _dotOffset), circleSize);
}
protected override void PaintBackground(float cx, float cy, ICanvas canvas)
{
base.PaintBackground(cx, cy, canvas);
var res = Resources;
//
// draw string lines
//
canvas.Color = res.StaveLineColor;
var lineY = cy + Y + NumberOverflow;
for (int i = 0, j = Bar.Staff.Track.Tuning.Length; i < j; i++)
{
if (i > 0)
{
lineY += LineOffset;
}
canvas.BeginPath();
canvas.MoveTo(cx + X, (int)lineY);
canvas.LineTo(cx + X + Width, (int)lineY);
canvas.Stroke();
}
canvas.Color = res.MainGlyphColor;
// Info guides for debugging
//DrawInfoGuide(canvas, cx, cy, 0, new Color(255, 0, 0)); // top
//DrawInfoGuide(canvas, cx, cy, stave.StaveTop, new Color(0, 255, 0)); // stavetop
//DrawInfoGuide(canvas, cx, cy, stave.StaveBottom, new Color(0,255,0)); // stavebottom
//DrawInfoGuide(canvas, cx, cy, Height, new Color(255, 0, 0)); // bottom
}
/// <summary>
/// paints a tie between the two given points
/// </summary>
/// <param name="canvas"></param>
/// <param name="scale"></param>
/// <param name="x1"></param>
/// <param name="y1"></param>
/// <param name="x2"></param>
/// <param name="y2"></param>
/// <param name="down"></param>
public static void PaintTie(ICanvas canvas, float scale, float x1, float y1, float x2, float y2,
bool down = false)
{
if (x1 == x2 && y1 == y2)
{
return;
}
// ensure endX > startX
if (x2 < x1)
{
var t = x1;
x1 = x2;
x2 = t;
t = y1;
y1 = y2;
y2 = t;
}
//
// calculate control points
//
var offset = 22 * scale;
var size = 4 * scale;
// normal vector
var normalVectorX = (y2 - y1);
var normalVectorY = (x2 - x1);
var length = (float)Math.Sqrt((normalVectorX * normalVectorX) + (normalVectorY * normalVectorY));
if (down)
{
normalVectorX *= -1;
}
else
{
normalVectorY *= -1;
}
// make to unit vector
normalVectorX /= length;
normalVectorY /= length;
// center of connection
var centerX = (x2 + x1) / 2;
var centerY = (y2 + y1) / 2;
// control points
var cp1X = centerX + (offset * normalVectorX);
var cp1Y = centerY + (offset * normalVectorY);
var cp2X = centerX + ((offset - size) * normalVectorX);
var cp2Y = centerY + ((offset - size) * normalVectorY);
canvas.BeginPath();
canvas.MoveTo(x1, y1);
canvas.QuadraticCurveTo(cp1X, cp1Y, x2, y2);
canvas.QuadraticCurveTo(cp2X, cp2Y, x1, y1);
canvas.ClosePath();
}
private static void PaintSingleBar(ICanvas canvas, float x1, float y1, float x2, float y2, float size)
{
canvas.BeginPath();
canvas.MoveTo(x1, y1);
canvas.LineTo(x2, y2);
canvas.LineTo(x2, y2 - size);
canvas.LineTo(x1, y1 - size);
canvas.ClosePath();
canvas.Fill();
}
private static void PaintSingleBar(ICanvas canvas, float x1, float y1, float x2, float y2, float size)
{
canvas.BeginPath();
canvas.MoveTo(x1, y1);
canvas.LineTo(x2, y2);
canvas.LineTo(x2, y2 - size);
canvas.LineTo(x1, y1 - size);
canvas.ClosePath();
canvas.Fill();
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
//TODO: Create webfont version
var scoreBarRenderer = (ScoreBarRenderer)Renderer;
var lineSize = scoreBarRenderer.LineOffset;
var startY = cy + Y + (scoreBarRenderer.GetNoteY(_beat.MaxNote) - lineSize / 2);
var endY = cy + Y + scoreBarRenderer.GetNoteY(_beat.MinNote) + lineSize;
var arrowX = cx + X + Width / 2;
var arrowSize = 8 * Scale;
if (_beat.BrushType != BrushType.None)
{
//if (_beat.BrushType == BrushType.ArpeggioUp || _beat.BrushType == BrushType.ArpeggioDown)
//{
// var size = 15 * Scale;
// var steps = Math.Abs(endY - startY) / size;
// for (var i = 0; i < steps; i++)
// {
// canvas.FillMusicFontSymbol(cx + X + (3 * Scale), 1, startY + (i * size), MusicFontSymbol.WaveVertical);
// }
//}
if (_beat.BrushType == BrushType.ArpeggioUp)
{
canvas.BeginPath();
canvas.MoveTo(arrowX, endY);
canvas.LineTo(arrowX + arrowSize / 2, endY - arrowSize);
canvas.LineTo(arrowX - arrowSize / 2, endY - arrowSize);
canvas.ClosePath();
canvas.Fill();
}
else if (_beat.BrushType == BrushType.ArpeggioDown)
{
canvas.BeginPath();
canvas.MoveTo(arrowX, startY);
canvas.LineTo(arrowX + arrowSize / 2, startY + arrowSize);
canvas.LineTo(arrowX - arrowSize / 2, startY + arrowSize);
canvas.ClosePath();
canvas.Fill();
}
}
}
private void PaintFooter(float cx, float cy, ICanvas canvas, BeamingHelper h)
{
foreach (var beat in h.Beats)
{
if (beat.Duration == Duration.Whole || beat.Duration == Duration.DoubleWhole || beat.Duration == Duration.QuadrupleWhole)
{
return;
}
//
// draw line
//
var beatLineX = h.GetBeatLineX(beat);
var y1 = cy + Y;
var y2 = cy + Y + Height;
var startGlyph = (TabBeatGlyph)GetOnNotesGlyphForBeat(beat);
if (startGlyph.NoteNumbers == null)
{
y1 += Height - RhythmHeight;
}
else
{
y1 += startGlyph.NoteNumbers.GetNoteY(startGlyph.NoteNumbers.MinStringNote) + LineOffset / 2;
}
if (h.Direction == BeamDirection.Up)
{
beatLineX -= startGlyph.Width / 2f;
}
else
{
beatLineX += startGlyph.Width / 2f;
}
canvas.BeginPath();
canvas.MoveTo(cx + X + beatLineX, y1);
canvas.LineTo(cx + X + beatLineX, y2);
canvas.Stroke();
//
// Draw beam
//
if (beat.Duration > Duration.Quarter)
{
var glyph = new BeamGlyph(0, 0, beat.Duration, BeamDirection.Down, false);
glyph.Renderer = this;
glyph.DoLayout();
glyph.Paint(cx + X + beatLineX, y2, canvas);
}
}
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var size = 6 * Scale;
canvas.BeginPath();
canvas.MoveTo(cx + X, cy + Y);
canvas.QuadraticCurveTo(cx + X + (Width / 2), cy + Y, cx + X + Width, cy + Y - size);
canvas.MoveTo(cx + X, cy + Y);
canvas.QuadraticCurveTo(cx + X + (Width / 2), cy + Y, cx + X + Width, cy + Y + size);
canvas.Stroke();
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var size = 6 * Scale;
canvas.BeginPath();
canvas.MoveTo(cx + X, cy + Y);
canvas.QuadraticCurveTo(cx + X + (Width / 2), cy + Y, cx + X + Width, cy + Y - size);
canvas.MoveTo(cx + X, cy + Y);
canvas.QuadraticCurveTo(cx + X + (Width / 2), cy + Y, cx + X + Width, cy + Y + size);
canvas.Stroke();
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var scoreBarRenderer = (ScoreBarRenderer)Renderer;
var lineSize = scoreBarRenderer.LineOffset;
var startY = cy + Y + (scoreBarRenderer.GetNoteY(_beat.MaxNote) - lineSize / 2);
var endY = cy + Y + scoreBarRenderer.GetNoteY(_beat.MinNote) + lineSize;
var arrowX = cx + X + Width / 2;
var arrowSize = 8 * Scale;
if (_beat.BrushType != BrushType.None)
{
if (_beat.BrushType == BrushType.ArpeggioUp || _beat.BrushType == BrushType.ArpeggioDown)
{
var size = 15 * Scale;
var steps = Math.Abs(endY - startY) / size;
for (var i = 0; i < steps; i++)
{
canvas.FillMusicFontSymbol(cx + X + (3 * Scale), 1, startY + (i * size), MusicFontSymbol.WaveVertical);
}
}
if (_beat.BrushType == BrushType.ArpeggioUp)
{
canvas.BeginPath();
canvas.MoveTo(arrowX, endY);
canvas.LineTo(arrowX + arrowSize / 2, endY - arrowSize);
canvas.LineTo(arrowX - arrowSize / 2, endY - arrowSize);
canvas.ClosePath();
canvas.Fill();
}
else if (_beat.BrushType == BrushType.ArpeggioDown)
{
canvas.BeginPath();
canvas.MoveTo(arrowX, startY);
canvas.LineTo(arrowX + arrowSize / 2, startY + arrowSize);
canvas.LineTo(arrowX - arrowSize / 2, startY + arrowSize);
canvas.ClosePath();
canvas.Fill();
}
}
}
protected override void PaintGrouped(float cx, float cy, float endX, ICanvas canvas)
{
var size = PaintOttava(cx, cy, canvas);
var lineSpacing = LineRangedGlyph.LineSpacing * Scale;
var startX = cx + X + size + lineSpacing;
var lineY = cy + Y;
lineY += _aboveStaff ? 2 * Scale : Height - 2 * Scale;
var lineSize = LineRangedGlyph.LineSize * Scale;
if (endX > startX)
{
var lineX = startX;
while (lineX < endX)
{
canvas.BeginPath();
canvas.MoveTo(lineX, (int)lineY);
canvas.LineTo(Math.Min(lineX + lineSize, endX), (int)lineY);
lineX += lineSize + lineSpacing;
canvas.Stroke();
}
canvas.BeginPath();
if (_aboveStaff)
{
canvas.MoveTo(endX, lineY);
canvas.LineTo(endX, cy + Y + Height);
}
else
{
canvas.MoveTo(endX, lineY);
canvas.LineTo(endX, cy + Y);
}
canvas.Stroke();
}
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var size = 6 * Scale;
var width = Math.Max(Width, 14*Scale);
var offset = Renderer.Height/2;
canvas.BeginPath();
canvas.MoveTo(cx + X, cy + Y + offset);
canvas.QuadraticCurveTo(cx + X + (width / 2), cy + Y + offset, cx + X + width, cy + Y + offset - size);
canvas.MoveTo(cx + X, cy + Y + offset);
canvas.QuadraticCurveTo(cx + X + (width / 2), cy + Y + offset, cx + X + width, cy + Y + offset + size);
canvas.Stroke();
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var size = 6 * Scale;
var width = Math.Max(Width, 14 * Scale);
var offset = Renderer.Height / 2;
canvas.BeginPath();
canvas.MoveTo(cx + X, cy + Y + offset);
canvas.QuadraticCurveTo(cx + X + (width / 2), cy + Y + offset, cx + X + width, cy + Y + offset - size);
canvas.MoveTo(cx + X, cy + Y + offset);
canvas.QuadraticCurveTo(cx + X + (width / 2), cy + Y + offset, cx + X + width, cy + Y + offset + size);
canvas.Stroke();
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var res = Renderer.Resources;
canvas.Font = res.EffectFont;
canvas.TextAlign = TextAlign.Left;
var textWidth = canvas.MeasureText(_label);
canvas.FillText(_label, cx + X, cy + Y);
// check if we need lines
if (_isExpanded)
{
var lineSpacing = LineSpacing * Scale;
var startX = cx + X + textWidth + lineSpacing;
var endX = cx + X + Width - lineSpacing - lineSpacing;
var lineY = cy + Y + (LineTopPadding * Scale);
var lineSize = LineSize * Scale;
if (endX > startX)
{
var lineX = startX;
while (lineX < endX)
{
canvas.BeginPath();
canvas.MoveTo(lineX, (int)lineY);
canvas.LineTo(Math.Min(lineX + lineSize, endX), (int)lineY);
lineX += lineSize + lineSpacing;
canvas.Stroke();
}
canvas.BeginPath();
canvas.MoveTo(endX, (int)(lineY - LineTopOffset * Scale));
canvas.LineTo(endX, (int)(lineY + LineTopOffset * Scale));
canvas.Stroke();
}
}
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var res = Renderer.Resources;
canvas.Font = res.EffectFont;
canvas.TextAlign = TextAlign.Left;
var textWidth = canvas.MeasureText(_label);
canvas.FillText(_label, cx + X, cy + Y);
// check if we need lines
if (_isExpanded)
{
var lineSpacing = LineSpacing * Scale;
var startX = cx + X + textWidth + lineSpacing;
var endX = cx + X + Width - lineSpacing - lineSpacing;
var lineY = cy + Y + (LineTopPadding * Scale);
var lineSize = LineSize * Scale;
if (endX > startX)
{
var lineX = startX;
while (lineX < endX)
{
canvas.BeginPath();
canvas.MoveTo(lineX, (int)lineY);
canvas.LineTo(Math.Min(lineX + lineSize, endX), (int)lineY);
lineX += lineSize + lineSpacing;
canvas.Stroke();
}
canvas.BeginPath();
canvas.MoveTo(endX, (int)(lineY - LineTopOffset * Scale));
canvas.LineTo(endX, (int)(lineY + LineTopOffset * Scale));
canvas.Stroke();
}
}
}
protected void DrawBendSlur(ICanvas canvas, float x1, float y1, float x2, float y2, bool down, float scale, string slurText = null)
{
var normalVectorX = (y2 - y1);
var normalVectorY = (x2 - x1);
var length = (float)Math.Sqrt((normalVectorX * normalVectorX) + (normalVectorY * normalVectorY));
if (down)
{
normalVectorX *= -1;
}
else
{
normalVectorY *= -1;
}
// make to unit vector
normalVectorX /= length;
normalVectorY /= length;
// center of connection
// TODO: should be 1/3
var centerX = (x2 + x1) / 2;
var centerY = (y2 + y1) / 2;
var offset = SlurHeight * scale;
if (x2 - x1 < 20)
{
offset /= 2;
}
var cp1X = centerX + (offset * normalVectorX);
var cp1Y = centerY + (offset * normalVectorY);
canvas.BeginPath();
canvas.MoveTo(x1, y1);
canvas.LineTo(cp1X, cp1Y);
canvas.LineTo(x2, y2);
canvas.Stroke();
if (!string.IsNullOrEmpty(slurText))
{
var w = canvas.MeasureText(slurText);
var textOffset = down ? 0 : -canvas.Font.Size;
canvas.FillText(slurText, cp1X - w / 2, cp1Y + textOffset);
}
}
protected override void PaintGrouped(float cx, float cy, float endX, ICanvas canvas)
{
var startX = cx + X;
var width = endX - startX;
var loops = (int)Math.Max(1, width / _stepSize);
canvas.BeginPath();
canvas.MoveTo(startX, cy + Y);
for (int i = 0; i < loops; i++)
{
canvas.LineTo(startX + _stepSize / 2, cy + Y + Height);
canvas.LineTo(startX + _stepSize, cy + Y);
startX += _stepSize;
}
canvas.Stroke();
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var height = Height * Scale;
canvas.BeginPath();
if (_crescendo == CrescendoType.Crescendo)
{
canvas.MoveTo(cx + X + Width, cy + Y);
canvas.LineTo(cx + X, cy + Y + (height / 2));
canvas.LineTo(cx + X + Width, cy + Y + height);
}
else
{
canvas.MoveTo(cx + X, cy + Y);
canvas.LineTo(cx + X + Width, cy + Y + (height / 2));
canvas.LineTo(cx + X, cy + Y + height);
}
canvas.Stroke();
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var height = Height * Scale;
canvas.BeginPath();
if (_crescendo == CrescendoType.Crescendo)
{
canvas.MoveTo(cx + X + Width, cy + Y);
canvas.LineTo(cx + X, cy + Y + (height / 2));
canvas.LineTo(cx + X + Width, cy + Y + height);
}
else
{
canvas.MoveTo(cx + X, cy + Y);
canvas.LineTo(cx + X + Width, cy + Y + (height / 2));
canvas.LineTo(cx + X, cy + Y + height);
}
canvas.Stroke();
}
protected override void PaintGrouped(float cx, float cy, float endX, ICanvas canvas)
{
var startX = cx + X;
var height = Height * Scale;
canvas.BeginPath();
if (_crescendo == CrescendoType.Crescendo)
{
canvas.MoveTo(endX, cy + Y);
canvas.LineTo(startX, cy + Y + height / 2);
canvas.LineTo(endX, cy + Y + height);
}
else
{
canvas.MoveTo(cx + X, cy + Y);
canvas.LineTo(endX, cy + Y + (height / 2));
canvas.LineTo(cx + X, cy + Y + height);
}
canvas.Stroke();
}
protected override void PaintGrouped(float cx, float cy, float endX, ICanvas canvas)
{
var startX = cx + X;
var height = Height * Scale;
canvas.BeginPath();
if (_crescendo == CrescendoType.Crescendo)
{
canvas.MoveTo(endX, cy + Y);
canvas.LineTo(startX, cy + Y + height / 2);
canvas.LineTo(endX, cy + Y + height);
}
else
{
canvas.MoveTo(cx + X, cy + Y);
canvas.LineTo(endX, cy + Y + (height / 2));
canvas.LineTo(cx + X, cy + Y + height);
}
canvas.Stroke();
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var blockWidth = 4 * Scale;
var top = cy + Y + Renderer.TopPadding;
var bottom = cy + Y + Renderer.Height - Renderer.BottomPadding;
var left = (int)(cx + X);
var h = bottom - top;
// line
canvas.BeginPath();
canvas.MoveTo(left, top);
canvas.LineTo(left, bottom);
canvas.Stroke();
if (_isLast)
{
// big bar
left += (int)((3 * Scale) + 0.5f);
canvas.FillRect(left, top, blockWidth, h);
}
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var blockWidth = 4 * Scale;
var top = cy + Y + Renderer.TopPadding;
var bottom = cy + Y + Renderer.Height - Renderer.BottomPadding;
var left = (int)(cx + X);
var h = bottom - top;
// line
canvas.BeginPath();
canvas.MoveTo(left, top);
canvas.LineTo(left, bottom);
canvas.Stroke();
if (_isLast)
{
// big bar
left += (int)((3 * Scale) + 0.5f);
canvas.FillRect(left, top, blockWidth, h);
}
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
// calculate offsets per step
var dX = Width / BendPoint.MaxPosition;
var maxValue = 0;
for (int i = 0, j = _note.BendPoints.Count; i < j; i++)
{
if (_note.BendPoints[i].Value > maxValue)
{
maxValue = _note.BendPoints[i].Value;
}
}
cx += X;
cy += Y;
canvas.BeginPath();
for (int i = 0, j = _note.BendPoints.Count - 1; i < j; i++)
{
var firstPt = _note.BendPoints[i];
var secondPt = _note.BendPoints[i + 1];
// draw pre-bend if previous
if (i == 0 && firstPt.Value != 0 && !_note.IsTieDestination)
{
PaintBend(new BendPoint(), firstPt, cx, cy, dX, canvas);
}
// don't draw a line if there's no offset and it's the last point
if (firstPt.Value == secondPt.Value && i == _note.BendPoints.Count - 2)
{
continue;
}
PaintBend(firstPt, secondPt, cx, cy, dX, canvas);
}
}
private void RenderTriplet(float cx, float cy, ICanvas canvas)
{
cy += 2 * Scale;
var font = Renderer.Resources.EffectFont;
canvas.Font = new Font(font.Family, font.Size * 0.8f, font.Style);
var rightX = cx + NoteSeparation * Scale + 3 * Scale;
canvas.BeginPath();
canvas.MoveTo(cx, cy + (3 * Scale));
canvas.LineTo(cx, cy);
canvas.LineTo(cx + (5 * Scale), cy);
canvas.MoveTo(rightX + (5 * Scale), cy + (3 * Scale));
canvas.LineTo(rightX + (5 * Scale), cy);
canvas.LineTo(rightX, cy);
canvas.Stroke();
canvas.FillText("3", cx + (7 * Scale), cy - (10 * Scale));
canvas.Font = font;
}
private void PaintBar(float cx, float cy, ICanvas canvas, BeamingHelper h)
{
for (int i = 0, j = h.Beats.Count; i < j; i++)
{
var beat = h.Beats[i];
var correction = NoteHeadGlyph.NoteHeadHeight / 2;
//
// draw line
//
var beatLineX = h.GetBeatLineX(beat) + Scale;
var direction = h.Direction;
var y1 = cy + Y + (direction == BeamDirection.Up
? GetScoreY(GetNoteLine(beat.MinNote), correction - 1)
: GetScoreY(GetNoteLine(beat.MaxNote), correction - 1));
var y2 = cy + Y + CalculateBeamY(h, beatLineX);
canvas.BeginPath();
canvas.MoveTo(cx + X + beatLineX, y1);
canvas.LineTo(cx + X + beatLineX, y2);
canvas.Stroke();
var brokenBarOffset = 6 * Scale;
var barSpacing = 6 * Scale;
var barSize = 3 * Scale;
var barCount = beat.Duration.GetIndex() - 2;
var barStart = cy + Y;
if (direction == BeamDirection.Down)
{
barSpacing = -barSpacing;
barSize = -barSize;
}
for (var barIndex = 0; barIndex < barCount; barIndex++)
{
float barStartX;
float barEndX;
float barStartY;
float barEndY;
var barY = barStart + (barIndex * barSpacing);
//
// Bar to Next?
//
if (i < h.Beats.Count - 1)
{
// full bar?
if (IsFullBarJoin(beat, h.Beats[i + 1], barIndex))
{
barStartX = beatLineX;
barEndX = h.GetBeatLineX(h.Beats[i + 1]) + Scale;
}
// broken bar?
else if (i == 0 || !IsFullBarJoin(h.Beats[i - 1], beat, barIndex))
{
barStartX = beatLineX;
barEndX = barStartX + brokenBarOffset;
}
else
{
continue;
}
barStartY = barY + CalculateBeamY(h, barStartX);
barEndY = barY + CalculateBeamY(h, barEndX);
PaintSingleBar(canvas, cx + X + barStartX, barStartY, cx + X + barEndX, barEndY, barSize);
}
//
// Broken Bar to Previous?
//
else if (i > 0 && !IsFullBarJoin(beat, h.Beats[i - 1], barIndex))
{
barStartX = beatLineX - brokenBarOffset;
barEndX = beatLineX;
barStartY = barY + CalculateBeamY(h, barStartX);
barEndY = barY + CalculateBeamY(h, barEndX);
PaintSingleBar(canvas, cx + X + barStartX, barStartY, cx + X + barEndX, barEndY, barSize);
}
}
}
}
private void PaintTupletHelper(float cx, float cy, ICanvas canvas, TupletHelper h)
{
var res = Resources;
var oldAlign = canvas.TextAlign;
canvas.TextAlign = TextAlign.Center;
// check if we need to paint simple footer
if (h.Beats.Count == 1 || !h.IsFull)
{
for (int i = 0, j = h.Beats.Count; i < j; i++)
{
var beat = h.Beats[i];
var beamingHelper = _helpers.BeamHelperLookup[h.VoiceIndex][beat.Index];
if (beamingHelper == null)
{
continue;
}
var direction = beamingHelper.Direction;
var tupletX = beamingHelper.GetBeatLineX(beat) + Scale;
var tupletY = cy + Y + CalculateBeamY(beamingHelper, tupletX);
var offset = direction == BeamDirection.Up
? res.EffectFont.Size * 1.8f
: -3 * Scale;
canvas.Font = res.EffectFont;
canvas.FillText(h.Tuplet.ToString(), cx + X + tupletX, tupletY - offset);
}
}
else
{
var firstBeat = h.Beats[0];
var lastBeat = h.Beats[h.Beats.Count - 1];
var beamingHelper = _helpers.BeamHelperLookup[h.VoiceIndex][firstBeat.Index];
if (beamingHelper != null)
{
var direction = beamingHelper.Direction;
//
// Calculate the overall area of the tuplet bracket
var startX = beamingHelper.GetBeatLineX(firstBeat) + Scale;
var endX = beamingHelper.GetBeatLineX(lastBeat) + Scale;
//
// Calculate how many space the text will need
canvas.Font = res.EffectFont;
var s = h.Tuplet.ToString();
var sw = canvas.MeasureText(s);
var sp = 3 * Scale;
//
// Calculate the offsets where to break the bracket
var middleX = (startX + endX) / 2;
var offset1X = middleX - sw / 2 - sp;
var offset2X = middleX + sw / 2 + sp;
//
// calculate the y positions for our bracket
var startY = CalculateBeamY(beamingHelper, startX);
var offset1Y = CalculateBeamY(beamingHelper, offset1X);
var middleY = CalculateBeamY(beamingHelper, middleX);
var offset2Y = CalculateBeamY(beamingHelper, offset2X);
var endY = CalculateBeamY(beamingHelper, endX);
var offset = 10 * Scale;
var size = 5 * Scale;
if (direction == BeamDirection.Down)
{
offset *= -1;
size *= -1;
}
//
// draw the bracket
canvas.BeginPath();
canvas.MoveTo(cx + X + startX, (int)(cy + Y + startY - offset));
canvas.LineTo(cx + X + startX, (int)(cy + Y + startY - offset - size));
canvas.LineTo(cx + X + offset1X, (int)(cy + Y + offset1Y - offset - size));
canvas.Stroke();
canvas.BeginPath();
canvas.MoveTo(cx + X + offset2X, (int)(cy + Y + offset2Y - offset - size));
canvas.LineTo(cx + X + endX, (int)(cy + Y + endY - offset - size));
canvas.LineTo(cx + X + endX, (int)(cy + Y + endY - offset));
canvas.Stroke();
//
// Draw the string
canvas.FillText(s, cx + X + middleX, cy + Y + middleY - offset - size - res.EffectFont.Size);
}
}
canvas.TextAlign = oldAlign;
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var scoreRenderer = (ScoreBarRenderer)Renderer;
//
// Note Effects only painted once
//
var effectY = BeamingHelper.Direction == BeamDirection.Up
? scoreRenderer.GetScoreY(MaxNote.Line, 1.5f * NoteHeadGlyph.NoteHeadHeight)
: scoreRenderer.GetScoreY(MinNote.Line, -1.0f * NoteHeadGlyph.NoteHeadHeight);
// TODO: take care of actual glyph height
var effectSpacing = (BeamingHelper.Direction == BeamDirection.Up)
? 7 * Scale
: -7 * Scale;
foreach (var effectKey in BeatEffects)
{
var g = BeatEffects[effectKey];
g.Y = effectY;
g.X = Width / 2;
g.Paint(cx + X, cy + Y, canvas);
effectY += effectSpacing;
}
canvas.Color = Renderer.Layout.Renderer.RenderingResources.StaveLineColor;
// TODO: Take care of beateffects in overflow
var linePadding = 3 * Scale;
if (HasTopOverflow)
{
var l = -1;
while (l >= MinNote.Line)
{
// + 1 Because we want to place the line in the center of the note, not at the top
var lY = cy + Y + scoreRenderer.GetScoreY(l);
canvas.BeginPath();
canvas.MoveTo(cx + X - linePadding, lY);
canvas.LineTo(cx + X + Width + linePadding, lY);
canvas.Stroke();
l -= 2;
}
}
if (HasBottomOverflow)
{
var l = 12;
while (l <= MaxNote.Line)
{
var lY = cy + Y + scoreRenderer.GetScoreY(l);
canvas.BeginPath();
canvas.MoveTo(cx + X - linePadding, lY);
canvas.LineTo(cx + X + Width + linePadding, lY);
canvas.Stroke();
l += 2;
}
}
canvas.Color = Beat.Voice.Index == 0
? Renderer.Layout.Renderer.RenderingResources.MainGlyphColor
: Renderer.Layout.Renderer.RenderingResources.SecondaryGlyphColor;
if (_tremoloPicking != null)
_tremoloPicking.Paint(cx + X, cy + Y, canvas);
for (int i = 0, j = _infos.Count; i < j; i++)
{
var g = _infos[i];
g.Glyph.Renderer = Renderer;
g.Glyph.Paint(cx + X + _noteHeadPadding, cy + Y, canvas);
}
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var r = (ScoreBarRenderer)Renderer;
cx += r.X;
cy += r.Y;
var sizeX = 12 * Scale;
var offsetX = 1 * Scale;
float startX;
float startY;
float endX;
float endY;
switch (_type)
{
case SlideType.Shift:
case SlideType.Legato:
startX = cx + r.GetNoteX(_startNote) + offsetX;
startY = cy + r.GetNoteY(_startNote) + NoteHeadGlyph.NoteHeadHeight / 2;
if (_startNote.SlideTarget != null)
{
endX = cx + r.GetNoteX(_startNote.SlideTarget, false) - offsetX;
endY = cy + r.GetNoteY(_startNote.SlideTarget) + NoteHeadGlyph.NoteHeadHeight / 2;
}
else
{
endX = cx + _parent.X;
endY = startY;
}
break;
case SlideType.IntoFromBelow:
endX = cx + r.GetNoteX(_startNote, false) - offsetX;
endY = cy + r.GetNoteY(_startNote) + NoteHeadGlyph.NoteHeadHeight / 2;
startX = endX - sizeX;
startY = cy + r.GetNoteY(_startNote) + NoteHeadGlyph.NoteHeadHeight;
break;
case SlideType.IntoFromAbove:
endX = cx + r.GetNoteX(_startNote, false) - offsetX;
endY = cy + r.GetNoteY(_startNote) + NoteHeadGlyph.NoteHeadHeight / 2;
startX = endX - sizeX;
startY = cy + r.GetNoteY(_startNote);
break;
case SlideType.OutUp:
startX = cx + r.GetNoteX(_startNote) + offsetX;
startY = cy + r.GetNoteY(_startNote) + NoteHeadGlyph.NoteHeadHeight / 2;
endX = startX + sizeX;
endY = cy + r.GetNoteY(_startNote);
break;
case SlideType.OutDown:
startX = cx + r.GetNoteX(_startNote) + offsetX;
startY = cy + r.GetNoteY(_startNote) + NoteHeadGlyph.NoteHeadHeight / 2;
endX = startX + sizeX;
endY = cy + r.GetNoteY(_startNote) + NoteHeadGlyph.NoteHeadHeight;
break;
default:
return;
}
canvas.BeginPath();
canvas.MoveTo(startX, startY);
canvas.LineTo(endX, endY);
canvas.Stroke();
}
private void PaintBar(float cx, float cy, ICanvas canvas, BeamingHelper h)
{
for (int i = 0, j = h.Beats.Count; i < j; i++)
{
var beat = h.Beats[i];
if (h.HasBeatLineX(beat))
{
//
// draw line
//
var beatLineX = h.GetBeatLineX(beat) + Scale;
var y1 = cy + Y;
var y2 = cy + Y + Height;
canvas.BeginPath();
canvas.MoveTo(cx + X + beatLineX, y1);
canvas.LineTo(cx + X + beatLineX, y2);
canvas.Stroke();
var brokenBarOffset = (6 * Scale);
var barSpacing = (6 * Scale);
var barSize = (3 * Scale);
var barCount = beat.Duration.GetIndex() - 2;
var barStart = cy + Y;
if (_direction == BeamDirection.Down)
{
barSpacing = -barSpacing;
barStart += Height;
}
for (int barIndex = 0; barIndex < barCount; barIndex++)
{
float barStartX;
float barEndX;
float barStartY;
float barEndY;
var barY = barStart + (barIndex * barSpacing);
//
// Broken Bar to Next
//
if (h.Beats.Count == 1)
{
barStartX = beatLineX;
barEndX = beatLineX + brokenBarOffset;
barStartY = barY;
barEndY = barY;
PaintSingleBar(canvas, cx + X + barStartX, barStartY, cx + X + barEndX, barEndY, barSize);
}
//
// Bar to Next?
//
else if (i < h.Beats.Count - 1)
{
// full bar?
if (IsFullBarJoin(beat, h.Beats[i + 1], barIndex))
{
barStartX = beatLineX;
barEndX = h.GetBeatLineX(h.Beats[i + 1]) + Scale;
}
// broken bar?
else if (i == 0 || !IsFullBarJoin(h.Beats[i - 1], beat, barIndex))
{
barStartX = beatLineX;
barEndX = barStartX + brokenBarOffset;
}
else
{
continue;
}
barStartY = barY;
barEndY = barY;
PaintSingleBar(canvas, cx + X + barStartX, barStartY, cx + X + barEndX, barEndY, barSize);
}
//
// Broken Bar to Previous?
//
else if (i > 0 && !IsFullBarJoin(beat, h.Beats[i - 1], barIndex))
{
barStartX = beatLineX - brokenBarOffset;
barEndX = beatLineX;
barStartY = barY;
barEndY = barY;
PaintSingleBar(canvas, cx + X + barStartX, barStartY, cx + X + barEndX, barEndY, barSize);
}
}
}
}
}
private void PaintFooter(float cx, float cy, ICanvas canvas, BeamingHelper h)
{
var beat = h.Beats[0];
if (beat.Duration == Duration.Whole || beat.Duration == Duration.DoubleWhole)
{
return;
}
//
// draw line
//
var beatLineX = h.GetBeatLineX(beat) + Scale;
const float topY = 0;
var bottomY = Height;
float beamY = _direction == BeamDirection.Down ? bottomY : topY;
canvas.BeginPath();
canvas.MoveTo(cx + X + beatLineX, cy + Y + topY);
canvas.LineTo(cx + X + beatLineX, cy + Y + bottomY);
canvas.Stroke();
//
// Draw beam
//
var glyph = new BeamGlyph(beatLineX, beamY, beat.Duration, _direction, false);
glyph.Renderer = this;
glyph.DoLayout();
glyph.Paint(cx + X, cy + Y, canvas);
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var tabBarRenderer = (TabBarRenderer)Renderer;
var res = Renderer.Resources;
var startX = cx + X + _parent.OnNotes.Width / 2;
var endX = _beat.NextBeat == null || _beat.Voice != _beat.NextBeat.Voice
? cx + X + _parent.OnNotes.Width / 2 + _parent.PostNotes.Width
: cx + tabBarRenderer.GetBeatX(_beat.NextBeat);
var startY = cy + X;
var textOffset = 3 * Scale;
var sizeY = WhammyMaxOffset * Scale;
var old = canvas.TextAlign;
canvas.TextAlign = TextAlign.Center;
if (_beat.WhammyBarPoints.Count >= 2)
{
var dx = (endX - startX) / Beat.WhammyBarMaxPosition;
var dy = sizeY / Beat.WhammyBarMaxValue;
canvas.BeginPath();
for (int i = 0, j = _beat.WhammyBarPoints.Count - 1; i < j; i++)
{
var pt1 = _beat.WhammyBarPoints[i];
var pt2 = _beat.WhammyBarPoints[i + 1];
if (pt1.Value == pt2.Value && i == _beat.WhammyBarPoints.Count - 2)
{
continue;
}
var pt1X = startX + (dx * pt1.Offset);
var pt1Y = startY - (dy * pt1.Value);
var pt2X = startX + (dx * pt2.Offset);
var pt2Y = startY - (dy * pt2.Value);
canvas.MoveTo(pt1X, pt1Y);
canvas.LineTo(pt2X, pt2Y);
if (pt2.Value != 0)
{
var dv = pt2.Value / 4.0;
var up = (pt2.Value - pt1.Value) >= 0;
var s = "";
if (dv < 0)
{
s += "-";
}
if (dv >= 1 || dv <= -1)
{
s += Math.Abs(dv) + " ";
}
dv -= (int)dv;
if (dv == 0.25)
{
s += "1/4";
}
else if (dv == 0.5)
{
s += "1/2";
}
else if (dv == 0.75)
{
s += "3/4";
}
canvas.Font = res.GraceFont;
//var size = canvas.MeasureText(s);
var sy = up
? pt2Y - res.GraceFont.Size - textOffset
: pt2Y + textOffset;
var sx = pt2X;
canvas.FillText(s, sx, sy);
}
}
canvas.Stroke();
}
canvas.TextAlign = old;
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var r = (TabBarRenderer)Renderer;
var sizeX = 12 * Scale;
var sizeY = 3 * Scale;
float startX;
float startY;
float endX;
float endY;
switch (_type)
{
case SlideType.Shift:
case SlideType.Legato:
float startOffsetY;
float endOffsetY;
if (_startNote.SlideTarget == null)
{
startOffsetY = 0;
endOffsetY = 0;
}
else if (_startNote.SlideTarget.Fret > _startNote.Fret)
{
startOffsetY = sizeY;
endOffsetY = sizeY * -1;
}
else
{
startOffsetY = sizeY * -1;
endOffsetY = sizeY;
}
startX = cx + r.GetNoteX(_startNote);
startY = cy + r.GetNoteY(_startNote) + startOffsetY;
if (_startNote.SlideTarget != null)
{
endX = cx + r.GetNoteX(_startNote.SlideTarget, false);
endY = cy + r.GetNoteY(_startNote.SlideTarget) + endOffsetY;
}
else
{
endX = cx + _parent.X + _parent.PostNotes.X + _parent.PostNotes.Width;
endY = startY;
}
break;
case SlideType.IntoFromBelow:
endX = cx + r.GetNoteX(_startNote, false);
endY = cy + r.GetNoteY(_startNote);
startX = endX - sizeX;
startY = cy + r.GetNoteY(_startNote) + sizeY;
break;
case SlideType.IntoFromAbove:
endX = cx + r.GetNoteX(_startNote, false);
endY = cy + r.GetNoteY(_startNote);
startX = endX - sizeX;
startY = cy + r.GetNoteY(_startNote) - sizeY;
break;
case SlideType.OutUp:
startX = cx + r.GetNoteX(_startNote);
startY = cy + r.GetNoteY(_startNote);
endX = startX + sizeX;
endY = cy + r.GetNoteY(_startNote) - sizeY;
break;
case SlideType.OutDown:
startX = cx + r.GetNoteX(_startNote);
startY = cy + r.GetNoteY(_startNote);
endX = startX + sizeX;
endY = cy + r.GetNoteY(_startNote) + sizeY;
break;
default:
return;
}
canvas.BeginPath();
canvas.MoveTo(startX, startY);
canvas.LineTo(endX, endY);
canvas.Stroke();
}
/// <summary>
/// paints a tie between the two given points
/// </summary>
/// <param name="canvas"></param>
/// <param name="scale"></param>
/// <param name="x1"></param>
/// <param name="y1"></param>
/// <param name="x2"></param>
/// <param name="y2"></param>
/// <param name="down"></param>
public static void PaintTie(ICanvas canvas, float scale, float x1, float y1, float x2, float y2,
bool down = false)
{
// ensure endX > startX
if (x2 > x1)
{
var t = x1;
x1 = x2;
x2 = t;
t = y1;
y1 = y2;
y2 = t;
}
//
// calculate control points
//
var offset = 15 * scale;
var size = 4 * scale;
// normal vector
var normalVectorX = (y2 - y1);
var normalVectorY = (x2 - x1);
var length = (float)Math.Sqrt((normalVectorX * normalVectorX) + (normalVectorY * normalVectorY));
if (down)
normalVectorX *= -1;
else
normalVectorY *= -1;
// make to unit vector
normalVectorX /= length;
normalVectorY /= length;
// center of connection
var centerX = (x2 + x1) / 2;
var centerY = (y2 + y1) / 2;
// control points
var cp1X = centerX + (offset * normalVectorX);
var cp1Y = centerY + (offset * normalVectorY);
var cp2X = centerX + ((offset - size) * normalVectorX);
var cp2Y = centerY + ((offset - size) * normalVectorY);
canvas.BeginPath();
canvas.MoveTo(x1, y1);
canvas.QuadraticCurveTo(cp1X, cp1Y, x2, y2);
canvas.QuadraticCurveTo(cp2X, cp2Y, x1, y1);
canvas.ClosePath();
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var tabBarRenderer = (TabBarRenderer)Renderer;
var res = Renderer.Resources;
var startX = cx + X + _parent.OnNotes.Width / 2;
var endX = _beat.NextBeat == null || _beat.Voice != _beat.NextBeat.Voice
? cx + X + _parent.Width
: cx + tabBarRenderer.GetBeatX(_beat.NextBeat);
var startY = cy + X;
var textOffset = 3 * Scale;
var sizeY = WhammyMaxOffset * Scale;
var old = canvas.TextAlign;
canvas.TextAlign = TextAlign.Center;
if (_beat.WhammyBarPoints.Count >= 2)
{
var dx = (endX - startX) / Beat.WhammyBarMaxPosition;
var dy = sizeY / Beat.WhammyBarMaxValue;
canvas.BeginPath();
for (int i = 0, j = _beat.WhammyBarPoints.Count - 1; i < j; i++)
{
var pt1 = _beat.WhammyBarPoints[i];
var pt2 = _beat.WhammyBarPoints[i + 1];
if (pt1.Value == pt2.Value && i == _beat.WhammyBarPoints.Count - 2) continue;
var pt1X = startX + (dx * pt1.Offset);
var pt1Y = startY - (dy * pt1.Value);
var pt2X = startX + (dx * pt2.Offset);
var pt2Y = startY - (dy * pt2.Value);
canvas.MoveTo(pt1X, pt1Y);
canvas.LineTo(pt2X, pt2Y);
if (pt2.Value != 0)
{
var dv = pt2.Value / 4.0;
var up = (pt2.Value - pt1.Value) >= 0;
var s = "";
if (dv < 0) s += "-";
if (dv >= 1 || dv <= -1)
s += Math.Abs(dv) + " ";
dv -= (int)dv;
if (dv == 0.25)
s += "1/4";
else if (dv == 0.5)
s += "1/2";
else if (dv == 0.75)
s += "3/4";
canvas.Font = res.GraceFont;
//var size = canvas.MeasureText(s);
var sy = up
? pt2Y - res.GraceFont.Size - textOffset
: pt2Y + textOffset;
var sx = pt2X;
canvas.FillText(s, sx, sy);
}
}
canvas.Stroke();
}
canvas.TextAlign = old;
}
private void PaintFooter(float cx, float cy, ICanvas canvas, BeamingHelper h)
{
var beat = h.Beats[0];
var isGrace = beat.GraceType != GraceType.None;
var scaleMod = isGrace ? NoteHeadGlyph.GraceScale : 1;
//
// draw line
//
var stemSize = GetFooterStemSize(h.ShortestDuration);
var beatLineX = h.GetBeatLineX(beat) + Scale;
var direction = h.Direction;
var topY = GetScoreY(GetNoteLine(beat.MaxNote));
var bottomY = GetScoreY(GetNoteLine(beat.MinNote));
float beamY;
float fingeringY;
if (direction == BeamDirection.Down)
{
bottomY += stemSize * scaleMod;
beamY = bottomY;
fingeringY = cy + Y + bottomY;
}
else
{
topY -= stemSize * scaleMod;
beamY = topY;
fingeringY = cy + Y + topY;
}
PaintFingering(canvas, beat, cx + X + beatLineX, direction, fingeringY);
if (beat.Duration == Duration.Whole || beat.Duration == Duration.DoubleWhole)
{
return;
}
canvas.BeginPath();
canvas.MoveTo(cx + X + beatLineX, cy + Y + topY);
canvas.LineTo(cx + X + beatLineX, cy + Y + bottomY);
canvas.Stroke();
if (isGrace)
{
var graceSizeY = 15 * Scale;
var graceSizeX = 12 * Scale;
canvas.BeginPath();
if (direction == BeamDirection.Down)
{
canvas.MoveTo(cx + X + beatLineX - (graceSizeX / 2), cy + Y + bottomY - graceSizeY);
canvas.LineTo(cx + X + beatLineX + (graceSizeX / 2), cy + Y + bottomY);
}
else
{
canvas.MoveTo(cx + X + beatLineX - (graceSizeX / 2), cy + Y + topY + graceSizeY);
canvas.LineTo(cx + X + beatLineX + (graceSizeX / 2), cy + Y + topY);
}
canvas.Stroke();
}
//
// Draw beam
//
if (beat.Duration > Duration.Quarter)
{
var glyph = new BeamGlyph(beatLineX - Scale / 2f, beamY, beat.Duration, direction, isGrace);
glyph.Renderer = this;
glyph.DoLayout();
glyph.Paint(cx + X, cy + Y, canvas);
}
}
private void PaintBar(float cx, float cy, ICanvas canvas, BeamingHelper h)
{
for (int i = 0, j = h.Beats.Count; i < j; i++)
{
var beat = h.Beats[i];
//
// draw line
//
var beatLineX = h.GetBeatLineX(beat) + Scale;
var direction = h.Direction;
var y1 = cy + Y + (direction == BeamDirection.Up
? GetScoreY(GetNoteLine(beat.MinNote))
: GetScoreY(GetNoteLine(beat.MaxNote)));
var y2 = cy + Y + CalculateBeamY(h, beatLineX);
canvas.BeginPath();
canvas.MoveTo(cx + X + beatLineX, y1);
canvas.LineTo(cx + X + beatLineX, y2);
canvas.Stroke();
float fingeringY = y2;
if (direction == BeamDirection.Down)
{
fingeringY += canvas.Font.Size * 2f;
}
else if (i != 0)
{
fingeringY -= canvas.Font.Size * 1.5f;
}
PaintFingering(canvas, beat, cx + X + beatLineX, direction, fingeringY);
var brokenBarOffset = 6 * Scale;
var barSpacing = 6 * Scale;
var barSize = 3 * Scale;
var barCount = beat.Duration.GetIndex() - 2;
var barStart = cy + Y;
if (direction == BeamDirection.Down)
{
barSpacing = -barSpacing;
barSize = -barSize;
}
for (var barIndex = 0; barIndex < barCount; barIndex++)
{
float barStartX;
float barEndX;
float barStartY;
float barEndY;
var barY = barStart + (barIndex * barSpacing);
//
// Bar to Next?
//
if (i < h.Beats.Count - 1)
{
// full bar?
if (IsFullBarJoin(beat, h.Beats[i + 1], barIndex))
{
barStartX = beatLineX;
barEndX = h.GetBeatLineX(h.Beats[i + 1]) + Scale;
}
// broken bar?
else if (i == 0 || !IsFullBarJoin(h.Beats[i - 1], beat, barIndex))
{
barStartX = beatLineX;
barEndX = barStartX + brokenBarOffset;
}
else
{
continue;
}
barStartY = barY + CalculateBeamY(h, barStartX);
barEndY = barY + CalculateBeamY(h, barEndX);
PaintSingleBar(canvas, cx + X + barStartX, barStartY, cx + X + barEndX, barEndY, barSize);
}
//
// Broken Bar to Previous?
//
else if (i > 0 && !IsFullBarJoin(beat, h.Beats[i - 1], barIndex))
{
barStartX = beatLineX - brokenBarOffset;
barEndX = beatLineX;
barStartY = barY + CalculateBeamY(h, barStartX);
barEndY = barY + CalculateBeamY(h, barEndX);
PaintSingleBar(canvas, cx + X + barStartX, barStartY, cx + X + barEndX, barEndY, barSize);
}
}
}
}
//private static readonly Random Random = new Random();
protected override void PaintBackground(float cx, float cy, ICanvas canvas)
{
base.PaintBackground(cx, cy, canvas);
var res = Resources;
//var c = new Color((byte)Std.Random(255),
// (byte)Std.Random(255),
// (byte)Std.Random(255),
// 100);
//canvas.Color = c;
//canvas.FillRect(cx + X, cy + Y, Width, Height);
//
// draw string lines
//
canvas.Color = res.StaveLineColor;
var lineY = cy + Y + TopPadding;
for (var i = 0; i < 5; i++)
{
if (i > 0) lineY += LineOffset;
canvas.BeginPath();
canvas.MoveTo(cx + X, (int)lineY);
canvas.LineTo(cx + X + Width, (int)lineY);
canvas.Stroke();
}
canvas.Color = res.MainGlyphColor;
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var r = (ScoreBarRenderer)Renderer;
var sizeX = 12 * Scale;
var offsetX = 1 * Scale;
float startX;
float startY;
float endX;
float endY;
switch (_type)
{
case SlideType.Shift:
case SlideType.Legato:
startX = cx + r.GetNoteX(_startNote) + offsetX;
startY = cy + r.GetNoteY(_startNote) + NoteHeadGlyph.NoteHeadHeight / 2;
if (_startNote.SlideTarget != null)
{
endX = cx + r.GetNoteX(_startNote.SlideTarget, false) - offsetX;
endY = cy + r.GetNoteY(_startNote.SlideTarget) + NoteHeadGlyph.NoteHeadHeight / 2;
}
else
{
endX = cx + _parent.X;
endY = startY;
}
break;
case SlideType.IntoFromBelow:
endX = cx + r.GetNoteX(_startNote, false) - offsetX;
endY = cy + r.GetNoteY(_startNote) + NoteHeadGlyph.NoteHeadHeight / 2;
startX = endX - sizeX;
startY = cy + r.GetNoteY(_startNote) + NoteHeadGlyph.NoteHeadHeight;
break;
case SlideType.IntoFromAbove:
endX = cx + r.GetNoteX(_startNote, false) - offsetX;
endY = cy + r.GetNoteY(_startNote) + NoteHeadGlyph.NoteHeadHeight / 2;
startX = endX - sizeX;
startY = cy + r.GetNoteY(_startNote);
break;
case SlideType.OutUp:
startX = cx + r.GetNoteX(_startNote) + offsetX;
startY = cy + r.GetNoteY(_startNote) + NoteHeadGlyph.NoteHeadHeight / 2;
endX = startX + sizeX;
endY = cy + r.GetNoteY(_startNote);
break;
case SlideType.OutDown:
startX = cx + r.GetNoteX(_startNote) + offsetX;
startY = cy + r.GetNoteY(_startNote) + NoteHeadGlyph.NoteHeadHeight / 2;
endX = startX + sizeX;
endY = cy + r.GetNoteY(_startNote) + NoteHeadGlyph.NoteHeadHeight;
break;
default:
return;
}
canvas.BeginPath();
canvas.MoveTo(startX, startY);
canvas.LineTo(endX, endY);
canvas.Stroke();
}
private void PaintFooter(float cx, float cy, ICanvas canvas, BeamingHelper h)
{
var beat = h.Beats[0];
if (beat.Duration == Duration.Whole)
{
return;
}
var isGrace = beat.GraceType != GraceType.None;
var scaleMod = isGrace ? NoteHeadGlyph.GraceScale : 1;
//
// draw line
//
var stemSize = GetStemSize(h.MaxDuration);
var correction = ((NoteHeadGlyph.NoteHeadHeight * scaleMod) / 2);
var beatLineX = h.GetBeatLineX(beat) + Scale;
var direction = h.Direction;
var topY = GetScoreY(GetNoteLine(beat.MaxNote), correction);
var bottomY = GetScoreY(GetNoteLine(beat.MinNote), correction);
float beamY;
if (direction == BeamDirection.Down)
{
bottomY += stemSize * scaleMod;
beamY = bottomY;
}
else
{
topY -= stemSize * scaleMod;
beamY = topY;
}
canvas.BeginPath();
canvas.MoveTo(cx + X + beatLineX, cy + Y + topY);
canvas.LineTo(cx + X + beatLineX, cy + Y + bottomY);
canvas.Stroke();
if (isGrace)
{
var graceSizeY = 15 * Scale;
var graceSizeX = 12 * Scale;
canvas.BeginPath();
if (direction == BeamDirection.Down)
{
canvas.MoveTo(cx + X + beatLineX - (graceSizeX / 2), cy + Y + bottomY - graceSizeY);
canvas.LineTo(cx + X + beatLineX + (graceSizeX / 2), cy + Y + bottomY);
}
else
{
canvas.MoveTo(cx + X + beatLineX - (graceSizeX / 2), cy + Y + topY + graceSizeY);
canvas.LineTo(cx + X + beatLineX + (graceSizeX / 2), cy + Y + topY);
}
canvas.Stroke();
}
//
// Draw beam
//
if (beat.Duration > Duration.Quarter)
{
var glyph = new BeamGlyph(beatLineX, beamY, beat.Duration, direction, isGrace);
glyph.Renderer = this;
glyph.DoLayout();
glyph.Paint(cx + X, cy + Y, canvas);
}
}
private void PaintBend(BendPoint firstPt, BendPoint secondPt, float cx, float cy, float dX, ICanvas canvas)
{
var r = (TabBarRenderer)Renderer;
var res = Renderer.Resources;
var overflowOffset = r.LineOffset / 2;
var x1 = cx + (dX * firstPt.Offset);
var y1 = cy - (_bendValueHeight * firstPt.Value);
if (firstPt.Value == 0)
{
y1 += r.GetNoteY(_note);
}
else
{
y1 += overflowOffset;
}
var x2 = cx + (dX * secondPt.Offset);
var y2 = cy - (_bendValueHeight * secondPt.Value);
if (secondPt.Value == 0)
{
y2 += r.GetNoteY(_note);
}
else
{
y2 += overflowOffset;
}
// what type of arrow? (up/down)
var arrowOffset = 0f;
var arrowSize = 6 * Scale;
if (secondPt.Value > firstPt.Value)
{
canvas.BeginPath();
canvas.MoveTo(x2, y2);
canvas.LineTo(x2 - arrowSize * 0.5f, y2 + arrowSize);
canvas.LineTo(x2 + arrowSize * 0.5f, y2 + arrowSize);
canvas.ClosePath();
canvas.Fill();
arrowOffset = arrowSize;
}
else if (secondPt.Value != firstPt.Value)
{
canvas.BeginPath();
canvas.MoveTo(x2, y2);
canvas.LineTo(x2 - arrowSize * 0.5f, y2 - arrowSize);
canvas.LineTo(x2 + arrowSize * 0.5f, y2 - arrowSize);
canvas.ClosePath();
canvas.Fill();
arrowOffset = -arrowSize;
}
canvas.Stroke();
if (firstPt.Value == secondPt.Value)
{
// draw horizontal line
canvas.MoveTo(x1, y1);
canvas.LineTo(x2, y2);
canvas.Stroke();
}
else
{
if (x2 > x1)
{
// draw bezier lien from first to second point
canvas.MoveTo(x1, y1);
canvas.BezierCurveTo(x2, y1, x2, y2 + arrowOffset, x2, y2 + arrowOffset);
canvas.Stroke();
}
else
{
canvas.MoveTo(x1, y1);
canvas.LineTo(x2, y2);
canvas.Stroke();
}
}
if (secondPt.Value != 0)
{
var dV = secondPt.Value;
var up = secondPt.Value > firstPt.Value;
dV = Math.Abs(dV);
// calculate label
var s = "";
// Full Steps
if (dV == 4 && up)
{
s = "full";
dV -= 4;
}
else if (dV >= 4)
{
int steps = dV / 4;
s += steps;
// Quaters
dV -= steps * 4;
}
if (dV > 0)
{
s += GetFractionSign(dV);
}
if (s != "")
{
if (!up)
{
s = "-" + s;
}
// draw label
canvas.Font = res.TablatureFont;
var size = canvas.MeasureText(s);
var y = up ? y2 - res.TablatureFont.Size - (2 * Scale) : y2 + (2 * Scale);
var x = x2 - size / 2;
canvas.FillText(s, x, y);
}
}
}
private void PaintBar(float cx, float cy, ICanvas canvas, BeamingHelper h)
{
for (int i = 0, j = h.Beats.Count; i < j; i++)
{
var beat = h.Beats[i];
if (h.HasBeatLineX(beat))
{
//
// draw line
//
var beatLineX = h.GetBeatLineX(beat);
var y1 = cy + Y;
var y2 = cy + Y + Height;
var startGlyph = (TabBeatGlyph)GetOnNotesGlyphForBeat(beat);
if (startGlyph.NoteNumbers == null)
{
y1 += Height - RhythmHeight;
}
else
{
y1 += startGlyph.NoteNumbers.GetNoteY(startGlyph.NoteNumbers.MinStringNote) + LineOffset / 2;
}
if (h.Direction == BeamDirection.Up)
{
beatLineX -= startGlyph.Width / 2f;
}
else
{
beatLineX += startGlyph.Width / 2f;
}
canvas.BeginPath();
canvas.MoveTo(cx + X + beatLineX, y1);
canvas.LineTo(cx + X + beatLineX, y2);
canvas.Stroke();
var brokenBarOffset = (6 * Scale);
var barSpacing = (6 * Scale);
var barSize = (3 * Scale);
var barCount = beat.Duration.GetIndex() - 2;
var barStart = cy + Y;
barSpacing = -barSpacing;
barStart += Height;
for (int barIndex = 0; barIndex < barCount; barIndex++)
{
float barStartX;
float barEndX;
float barStartY;
float barEndY;
var barY = barStart + (barIndex * barSpacing);
//
// Broken Bar to Next
//
if (h.Beats.Count == 1)
{
barStartX = beatLineX;
barEndX = beatLineX + brokenBarOffset;
barStartY = barY;
barEndY = barY;
PaintSingleBar(canvas, cx + X + barStartX, barStartY, cx + X + barEndX, barEndY, barSize);
}
//
// Bar to Next?
//
else if (i < h.Beats.Count - 1)
{
// full bar?
if (BeamingHelper.IsFullBarJoin(beat, h.Beats[i + 1], barIndex))
{
barStartX = beatLineX;
barEndX = h.GetBeatLineX(h.Beats[i + 1]) + Scale;
var endGlyph = GetOnNotesGlyphForBeat(h.Beats[i + 1]);
if (h.Direction == BeamDirection.Up)
{
barEndX -= endGlyph.Width / 2f;
}
else
{
barEndX += endGlyph.Width / 2f;
}
}
// broken bar?
else if (i == 0 || !BeamingHelper.IsFullBarJoin(h.Beats[i - 1], beat, barIndex))
{
barStartX = beatLineX;
barEndX = barStartX + brokenBarOffset;
}
else
{
continue;
}
barStartY = barY;
barEndY = barY;
PaintSingleBar(canvas, cx + X + barStartX, barStartY, cx + X + barEndX, barEndY, barSize);
}
//
// Broken Bar to Previous?
//
else if (i > 0 && !BeamingHelper.IsFullBarJoin(beat, h.Beats[i - 1], barIndex))
{
barStartX = beatLineX - brokenBarOffset;
barEndX = beatLineX;
barStartY = barY;
barEndY = barY;
PaintSingleBar(canvas, cx + X + barStartX, barStartY, cx + X + barEndX, barEndY, barSize);
}
}
}
}
}
public override void Paint(float cx, float cy, ICanvas canvas)
{
var r = (TabBarRenderer)Renderer;
var res = Renderer.Resources;
// calculate offsets per step
var dX = Width / BendPoint.MaxPosition;
var maxValue = 0;
for (int i = 0, j = _note.BendPoints.Count; i < j; i++)
{
if (_note.BendPoints[i].Value > maxValue)
{
maxValue = _note.BendPoints[i].Value;
}
}
var dY = maxValue == 0 ? 0 : _height / maxValue;
var xx = cx + X;
var yy = cy + Y + r.GetNoteY(_note);
canvas.BeginPath();
for (int i = 0, j = _note.BendPoints.Count - 1; i < j; i++)
{
var firstPt = _note.BendPoints[i];
var secondPt = _note.BendPoints[i + 1];
// don't draw a line if there's no offset and it's the last point
if (firstPt.Value == secondPt.Value && i == _note.BendPoints.Count - 2) continue;
var x1 = xx + (dX * firstPt.Offset);
var y1 = yy - (dY * firstPt.Value);
var x2 = xx + (dX * secondPt.Offset);
var y2 = yy - (dY * secondPt.Value);
if (firstPt.Value == secondPt.Value)
{
// draw horizontal line
canvas.MoveTo(x1, y1);
canvas.LineTo(x2, y2);
canvas.Stroke();
}
else
{
// draw bezier lien from first to second point
var hx = x1 + (x2 - x1);
var hy = yy - (dY * firstPt.Value);
canvas.MoveTo(x1, y1);
canvas.BezierCurveTo(hx, hy, x2, y2, x2, y2);
canvas.Stroke();
}
// what type of arrow? (up/down)
var arrowSize = 6 * Scale;
if (secondPt.Value > firstPt.Value)
{
canvas.BeginPath();
canvas.MoveTo(x2, y2);
canvas.LineTo(x2 - arrowSize * 0.5f, y2 + arrowSize);
canvas.LineTo(x2 + arrowSize * 0.5f, y2 + arrowSize);
canvas.ClosePath();
canvas.Fill();
}
else if (secondPt.Value != firstPt.Value)
{
canvas.BeginPath();
canvas.MoveTo(x2, y2);
canvas.LineTo(x2 - arrowSize * 0.5f, y2 - arrowSize);
canvas.LineTo(x2 + arrowSize * 0.5f, y2 - arrowSize);
canvas.ClosePath();
canvas.Fill();
}
canvas.Stroke();
if (secondPt.Value != 0)
{
var dV = (secondPt.Value - firstPt.Value);
var up = dV > 0;
dV = Math.Abs(dV);
// calculate label
var s = "";
// Full Steps
if (dV == 4)
{
s = "full";
dV -= 4;
}
else if (dV > 4)
{
s += dV / 4 + " ";
// Quaters
dV -= dV / 4;
}
if (dV > 0)
{
s += dV + "/4";
}
if (s != "")
{
if (!up)
{
s = "-" + s;
}
// draw label
canvas.Font = res.TablatureFont;
var size = canvas.MeasureText(s);
var y = up ? y2 - res.TablatureFont.Size - (2 * Scale) : y2 + (2 * Scale);
var x = x2 - size / 2;
canvas.FillText(s, x, y);
}
}
}
}
protected override void PaintBackground(float cx, float cy, ICanvas canvas)
{
base.PaintBackground(cx, cy, canvas);
var res = Resources;
//
// draw string lines
//
canvas.Color = res.StaveLineColor;
var lineY = cy + Y + TopPadding;
for (int i = 0, j = Bar.Staff.Track.Tuning.Length; i < j; i++)
{
if (i > 0) lineY += LineOffset;
canvas.BeginPath();
canvas.MoveTo(cx + X, (int)lineY);
canvas.LineTo(cx + X + Width, (int)lineY);
canvas.Stroke();
}
canvas.Color = res.MainGlyphColor;
// Info guides for debugging
//DrawInfoGuide(canvas, cx, cy, 0, new Color(255, 0, 0)); // top
//DrawInfoGuide(canvas, cx, cy, stave.StaveTop, new Color(0, 255, 0)); // stavetop
//DrawInfoGuide(canvas, cx, cy, stave.StaveBottom, new Color(0,255,0)); // stavebottom
//DrawInfoGuide(canvas, cx, cy, Height, new Color(255, 0, 0)); // bottom
}
private void PaintTupletHelper(float cx, float cy, ICanvas canvas, TupletHelper h)
{
var res = Resources;
var oldAlign = canvas.TextAlign;
canvas.TextAlign = TextAlign.Center;
// check if we need to paint simple footer
if (h.Beats.Count == 1 || !h.IsFull)
{
for (int i = 0, j = h.Beats.Count; i < j; i++)
{
var beat = h.Beats[i];
var beamingHelper = Helpers.BeamHelperLookup[h.VoiceIndex][beat.Index];
if (beamingHelper == null) continue;
var direction = beamingHelper.Direction;
var tupletX = beamingHelper.GetBeatLineX(beat) + Scale;
var tupletY = cy + Y + CalculateBeamY(beamingHelper, tupletX);
var offset = direction == BeamDirection.Up
? res.EffectFont.Size * 1.8f
: -3 * Scale;
canvas.Font = res.EffectFont;
canvas.FillText(h.Tuplet.ToString(), cx + X + tupletX, tupletY - offset);
}
}
else
{
var firstBeat = h.Beats[0];
var lastBeat = h.Beats[h.Beats.Count - 1];
var firstBeamingHelper = Helpers.BeamHelperLookup[h.VoiceIndex][firstBeat.Index];
var lastBeamingHelper = Helpers.BeamHelperLookup[h.VoiceIndex][lastBeat.Index];
if (firstBeamingHelper != null && lastBeamingHelper != null)
{
var direction = firstBeamingHelper.Direction;
//
// Calculate the overall area of the tuplet bracket
var startX = firstBeamingHelper.GetBeatLineX(firstBeat) + Scale;
var endX = lastBeamingHelper.GetBeatLineX(lastBeat) + Scale;
//
// Calculate how many space the text will need
canvas.Font = res.EffectFont;
var s = h.Tuplet.ToString();
var sw = canvas.MeasureText(s);
var sp = 3 * Scale;
//
// Calculate the offsets where to break the bracket
var middleX = (startX + endX) / 2;
var offset1X = middleX - sw / 2 - sp;
var offset2X = middleX + sw / 2 + sp;
//
// calculate the y positions for our bracket
var startY = CalculateBeamY(firstBeamingHelper, startX);
var offset1Y = CalculateBeamY(firstBeamingHelper, offset1X);
var middleY = CalculateBeamY(firstBeamingHelper, middleX);
var offset2Y = CalculateBeamY(lastBeamingHelper, offset2X);
var endY = CalculateBeamY(lastBeamingHelper, endX);
var offset = 10 * Scale;
var size = 5 * Scale;
if (direction == BeamDirection.Down)
{
offset *= -1;
size *= -1;
}
//
// draw the bracket
canvas.BeginPath();
canvas.MoveTo(cx + X + startX, (int)(cy + Y + startY - offset));
canvas.LineTo(cx + X + startX, (int)(cy + Y + startY - offset - size));
canvas.LineTo(cx + X + offset1X, (int)(cy + Y + offset1Y - offset - size));
canvas.Stroke();
canvas.BeginPath();
canvas.MoveTo(cx + X + offset2X, (int)(cy + Y + offset2Y - offset - size));
canvas.LineTo(cx + X + endX, (int)(cy + Y + endY - offset - size));
canvas.LineTo(cx + X + endX, (int)(cy + Y + endY - offset));
canvas.Stroke();
//
// Draw the string
canvas.FillText(s, cx + X + middleX, cy + Y + middleY - offset - size - res.EffectFont.Size);
}
}
canvas.TextAlign = oldAlign;
}
public void Paint(float cx, float cy, ICanvas canvas)
{
for (int i = 0, j = _allStaves.Count; i < j; i++)
{
_allStaves[i].Paint(cx + X, cy + Y, canvas);
}
var res = Layout.Renderer.RenderingResources;
if (Staves.Count > 0)
{
//
// Draw start grouping
//
if (_firstStaveInAccolade != null && _lastStaveInAccolade != null)
{
//
// draw grouping line for all staves
//
var firstStart = cy + Y + _firstStaveInAccolade.Y + _firstStaveInAccolade.StaveTop + _firstStaveInAccolade.TopSpacing + _firstStaveInAccolade.TopOverflow;
var lastEnd = cy + Y + _lastStaveInAccolade.Y + _lastStaveInAccolade.TopSpacing + _lastStaveInAccolade.TopOverflow
+ _lastStaveInAccolade.StaveBottom;
var acooladeX = cx + X + _firstStaveInAccolade.X;
canvas.Color = res.BarSeperatorColor;
canvas.BeginPath();
canvas.MoveTo(acooladeX, firstStart);
canvas.LineTo(acooladeX, lastEnd);
canvas.Stroke();
}
//
// Draw accolade for each track group
//
canvas.Font = res.EffectFont;
for (int i = 0, j = Staves.Count; i < j; i++)
{
var g = Staves[i];
var firstStart = cy + Y + g.FirstStaveInAccolade.Y + g.FirstStaveInAccolade.StaveTop + g.FirstStaveInAccolade.TopSpacing + g.FirstStaveInAccolade.TopOverflow;
var lastEnd = cy + Y + g.LastStaveInAccolade.Y + g.LastStaveInAccolade.TopSpacing + g.LastStaveInAccolade.TopOverflow
+ g.LastStaveInAccolade.StaveBottom;
var acooladeX = cx + X + g.FirstStaveInAccolade.X;
var barSize = (3 * Layout.Renderer.Settings.Scale);
var barOffset = barSize;
var accoladeStart = firstStart - (barSize * 4);
var accoladeEnd = lastEnd + (barSize * 4);
// text
if (Index == 0)
{
canvas.FillText(g.Track.ShortName, cx + X + (AccoladeLabelSpacing * Layout.Scale), firstStart);
}
// rect
canvas.FillRect(acooladeX - barOffset - barSize, accoladeStart, barSize, accoladeEnd - accoladeStart);
var spikeStartX = acooladeX - barOffset - barSize;
var spikeEndX = acooladeX + barSize * 2;
// top spike
canvas.BeginPath();
canvas.MoveTo(spikeStartX, accoladeStart);
canvas.BezierCurveTo(spikeStartX, accoladeStart, spikeStartX, accoladeStart, spikeEndX, accoladeStart - barSize);
canvas.BezierCurveTo(acooladeX, accoladeStart + barSize, spikeStartX, accoladeStart + barSize, spikeStartX, accoladeStart + barSize);
canvas.ClosePath();
canvas.Fill();
// bottom spike
canvas.BeginPath();
canvas.MoveTo(spikeStartX, accoladeEnd);
canvas.BezierCurveTo(spikeStartX, accoladeEnd, acooladeX, accoladeEnd, spikeEndX, accoladeEnd + barSize);
canvas.BezierCurveTo(acooladeX, accoladeEnd - barSize, spikeStartX, accoladeEnd - barSize, spikeStartX, accoladeEnd - barSize);
canvas.ClosePath();
canvas.Fill();
}
}
}
public void Paint(float cx, float cy, ICanvas canvas)
{
for (int i = 0, j = _allStaves.Count; i < j; i++)
{
_allStaves[i].Paint(cx + X, cy + Y, canvas);
}
var res = Layout.Renderer.RenderingResources;
if (Staves.Count > 0)
{
//
// Draw start grouping
//
if (_firstStaveInAccolade != null && _lastStaveInAccolade != null)
{
//
// draw grouping line for all staves
//
var firstStart = cy + Y + _firstStaveInAccolade.Y + _firstStaveInAccolade.StaveTop + _firstStaveInAccolade.TopSpacing + _firstStaveInAccolade.TopOverflow;
var lastEnd = cy + Y + _lastStaveInAccolade.Y + _lastStaveInAccolade.TopSpacing + _lastStaveInAccolade.TopOverflow
+ _lastStaveInAccolade.StaveBottom;
var acooladeX = cx + X + _firstStaveInAccolade.X;
canvas.Color = res.BarSeperatorColor;
canvas.BeginPath();
canvas.MoveTo(acooladeX, firstStart);
canvas.LineTo(acooladeX, lastEnd);
canvas.Stroke();
}
//
// Draw accolade for each track group
//
canvas.Font = res.EffectFont;
for (int i = 0, j = Staves.Count; i < j; i++)
{
var g = Staves[i];
var firstStart = cy + Y + g.FirstStaveInAccolade.Y + g.FirstStaveInAccolade.StaveTop + g.FirstStaveInAccolade.TopSpacing + g.FirstStaveInAccolade.TopOverflow;
var lastEnd = cy + Y + g.LastStaveInAccolade.Y + g.LastStaveInAccolade.TopSpacing + g.LastStaveInAccolade.TopOverflow
+ g.LastStaveInAccolade.StaveBottom;
var acooladeX = cx + X + g.FirstStaveInAccolade.X;
var barSize = (3 * Layout.Renderer.Settings.Scale);
var barOffset = barSize;
var accoladeStart = firstStart - (barSize * 4);
var accoladeEnd = lastEnd + (barSize * 4);
// text
if (Index == 0)
{
canvas.FillText(g.Track.ShortName, cx + X + (AccoladeLabelSpacing * Layout.Scale), firstStart);
}
// rect
canvas.FillRect(acooladeX - barOffset - barSize, accoladeStart, barSize, accoladeEnd - accoladeStart);
var spikeStartX = acooladeX - barOffset - barSize;
var spikeEndX = acooladeX + barSize * 2;
// top spike
canvas.BeginPath();
canvas.MoveTo(spikeStartX, accoladeStart);
canvas.BezierCurveTo(spikeStartX, accoladeStart, spikeStartX, accoladeStart, spikeEndX, accoladeStart - barSize);
canvas.BezierCurveTo(acooladeX, accoladeStart + barSize, spikeStartX, accoladeStart + barSize, spikeStartX, accoladeStart + barSize);
canvas.ClosePath();
canvas.Fill();
// bottom spike
canvas.BeginPath();
canvas.MoveTo(spikeStartX, accoladeEnd);
canvas.BezierCurveTo(spikeStartX, accoladeEnd, acooladeX, accoladeEnd, spikeEndX, accoladeEnd + barSize);
canvas.BezierCurveTo(acooladeX, accoladeEnd - barSize, spikeStartX, accoladeEnd - barSize, spikeStartX, accoladeEnd - barSize);
canvas.ClosePath();
canvas.Fill();
}
}
}
private void RenderTriplet(float cx, float cy, ICanvas canvas)
{
cy += 2*Scale;
var font = Renderer.Resources.EffectFont;
canvas.Font = new Font(font.Family, font.Size * 0.8f, font.Style);
var rightX = cx + NoteSeparation * Scale + 3 * Scale;
canvas.BeginPath();
canvas.MoveTo(cx, cy + (3 * Scale));
canvas.LineTo(cx, cy);
canvas.LineTo(cx + (5 * Scale), cy);
canvas.MoveTo(rightX + (5 * Scale), cy + (3 * Scale));
canvas.LineTo(rightX + (5 * Scale), cy);
canvas.LineTo(rightX, cy);
canvas.Stroke();
canvas.FillText("3", cx + (7 * Scale), cy - (10 * Scale));
canvas.Font = font;
}