public override void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
global::alphatab.rendering.RenderingResources res = this.renderer.stave.staveGroup.layout.renderer.renderingResources;
canvas.setColor(res.mainGlyphColor);
double blockWidth = ( 4 * this.renderer.stave.staveGroup.layout.renderer.settings.scale );
int top = ( ( cy + this.y ) + this.renderer.getTopPadding() );
int bottom = ( ( ( cy + this.y ) + this.renderer.height ) - this.renderer.getBottomPadding() );
double left = ( ( cx + this.x ) + 0.5 );
int h = ( bottom - top );
canvas.fillRect(left, ((double) (top) ), blockWidth, ((double) (h) ));
left += ( ( blockWidth * 2 ) - 0.5 );
canvas.beginPath();
canvas.moveTo(left, ((double) (top) ));
canvas.lineTo(left, ((double) (bottom) ));
canvas.stroke();
left += ( 3 * this.renderer.stave.staveGroup.layout.renderer.settings.scale );
double circleSize = ( this._circleSize * this.renderer.stave.staveGroup.layout.renderer.settings.scale );
double middle = ( ((double) ((( top + bottom ))) ) / 2 );
canvas.beginPath();
canvas.circle(left, ( middle - ( circleSize * this._dotOffset ) ), circleSize);
canvas.circle(left, ( middle + ( circleSize * this._dotOffset ) ), circleSize);
canvas.fill();
}
}
public override void paint(global::java.awt.Graphics g)
{
// old school gradient :)
var h = this.getHeight();
var w = this.getWidth();
for (int i = 0; i < h; i++)
{
g.setColor(GetBlue(1 - (double)i / (double)h));
g.drawLine(0, i, w, i);
}
g.setColor(new Color(0xffffff));
g.drawString("C# To Java".WithBranding(), 16, 64);
}
public override void paint(global::java.awt.Graphics g)
{
// old school gradient :)
var h = this.getHeight();
var w = this.getWidth();
for (int i = 0; i < h; i++)
{
g.setColor(GetBlue(1 - (double)i / (double)h));
g.drawLine(0, i, w, i);
}
g.setColor(new Color(0xffffff));
g.drawString("This example will show how to write multithreaded applet.", 16, 64);
}
public override void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
global::alphatab.rendering.RenderingResources res = this.renderer.stave.staveGroup.layout.renderer.renderingResources;
canvas.setFont(this._font);
canvas.setColor(res.mainGlyphColor);
canvas.fillText(this._text, ((double) (( cx + this.x )) ), ((double) (( cy + this.y )) ));
}
}
public override void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
global::alphatab.rendering.RenderingResources res = this.renderer.stave.staveGroup.layout.renderer.renderingResources;
canvas.setColor(res.mainGlyphColor);
canvas.strokeRect(((double) (( cx + this.x )) ), ((double) (( cy + this.y )) ), ((double) (this.width) ), ( 20 * this.renderer.stave.staveGroup.layout.renderer.settings.scale ));
canvas.setFont(res.tablatureFont);
canvas.fillText(this._s, ((double) (( cx + this.x )) ), ((double) (( cy + this.y )) ));
}
}
public override void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
global::alphatab.rendering.RenderingResources res = this.renderer.stave.staveGroup.layout.renderer.renderingResources;
canvas.setFont(res.markerFont);
canvas.setColor(res.mainGlyphColor);
global::alphatab.rendering.glyphs.SvgGlyph symbol = new global::alphatab.rendering.glyphs.SvgGlyph(new global::haxe.lang.Null<int>(0, true), new global::haxe.lang.Null<int>(0, true), ((global::alphatab.rendering.glyphs.LazySvg) (global::alphatab.rendering.glyphs.MusicFont.Tempo) ), ((double) (1) ), ((double) (1) ));
symbol.renderer = this.renderer;
symbol.paint(( cx + this.x ), ( cy + this.y ), canvas);
canvas.fillText(global::haxe.lang.Runtime.concat("", global::haxe.lang.Runtime.toString(this._tempo)), ((double) (( ( cx + this.x ) + ((int) (( 30 * this.renderer.stave.staveGroup.layout.renderer.settings.scale )) ) )) ), ((double) (( ( cy + this.y ) + ((int) (( 7 * this.renderer.stave.staveGroup.layout.renderer.settings.scale )) ) )) ));
}
}
public override void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
global::alphatab.rendering.RenderingResources res = this.renderer.stave.staveGroup.layout.renderer.renderingResources;
canvas.setFont(res.markerFont);
canvas.setColor(res.mainGlyphColor);
double textw = canvas.measureText("tr");
canvas.fillText("tr", ((double) (( cx + this.x )) ), ((double) (( cy + this.y )) ));
double startX = textw;
double endX = ( this.width - startX );
double step = ( ( 11 * this.renderer.stave.staveGroup.layout.renderer.settings.scale ) * this._scale );
int loops = default(int);
{
double v = global::System.Math.Max(((double) (1) ), ((double) (( (( endX - startX )) / step )) ));
{
double x = global::System.Math.Floor(((double) (v) ));
loops = ((int) (x) );
}
}
int loopX = ((int) (startX) );
{
int _g = 0;
while (( _g < loops ))
{
int i = _g++;
global::alphatab.rendering.glyphs.SvgGlyph glyph = new global::alphatab.rendering.glyphs.SvgGlyph(new global::haxe.lang.Null<int>(loopX, true), new global::haxe.lang.Null<int>(0, true), ((global::alphatab.rendering.glyphs.LazySvg) (global::alphatab.rendering.glyphs.MusicFont.WaveHorizontal) ), ((double) (this._scale) ), ((double) (this._scale) ));
glyph.renderer = this.renderer;
int __temp_stmt607 = default(int);
{
double x1 = ( res.markerFont.getSize() / 2 );
__temp_stmt607 = ((int) (x1) );
}
glyph.paint(( cx + this.x ), ( ( cy + this.y ) + __temp_stmt607 ), canvas);
{
double x2 = global::System.Math.Floor(((double) (step) ));
loopX += ((int) (x2) );
}
}
}
}
}
public override void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
global::alphatab.rendering.RenderingResources res = this.renderer.stave.staveGroup.layout.renderer.renderingResources;
canvas.setColor(res.mainGlyphColor);
canvas.setFont(res.barNumberFont);
string s = global::haxe.lang.Runtime.concat("x", global::Std.@string(this._count));
int w = default(int);
{
double x = ( canvas.measureText(s) / 1.5 );
w = ((int) (x) );
}
canvas.fillText(s, ((double) (( ( cx + this.x ) - w )) ), ((double) (( cy + this.y )) ));
}
}
public static void __hx_ctor_alphatab_platform_cs_GdiCanvas(global::alphatab.platform.cs.GdiCanvas __temp_me16)
{
unchecked
{
__temp_me16._width = 1;
__temp_me16._height = 1;
__temp_me16._image = new global::System.Drawing.Bitmap(((int) (1) ), ((int) (1) ), ((global::System.Drawing.Imaging.PixelFormat) (global::System.Drawing.Imaging.PixelFormat.Format32bppArgb) ));
__temp_me16._graphics = global::System.Drawing.Graphics.FromImage(__temp_me16._image);
__temp_me16._graphics.SmoothingMode = global::System.Drawing.Drawing2D.SmoothingMode.HighQuality;
__temp_me16._graphics.TextRenderingHint = global::System.Drawing.Text.TextRenderingHint.AntiAlias;
__temp_me16._currentPath = new global::System.Drawing.Drawing2D.GraphicsPath(((global::System.Drawing.Drawing2D.FillMode) (global::System.Drawing.Drawing2D.FillMode.Winding) ));
__temp_me16._stringFormat = new global::System.Drawing.StringFormat();
__temp_me16._stringFormat.LineAlignment = global::System.Drawing.StringAlignment.Near;
__temp_me16._lineWidth = ((double) (1) );
__temp_me16._currentX = ((float) (0) );
__temp_me16._currentY = ((float) (0) );
__temp_me16._font = new global::System.Drawing.Font(global::haxe.lang.Runtime.toString("Arial"), ((float) (10) ), ((global::System.Drawing.GraphicsUnit) (global::System.Drawing.GraphicsUnit.Pixel) ));
__temp_me16._textAlign = global::alphatab.platform.model.TextAlign.Left;
__temp_me16._textBaseline = global::alphatab.model.TextBaseline.Top;
__temp_me16.setColor(new global::alphatab.platform.model.Color(((int) (255) ), ((int) (255) ), ((int) (255) ), ((global::haxe.lang.Null<int>) (default(global::haxe.lang.Null<int>)) )));
}
}
public override void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
if (( ( this._endNote == default(global::alphatab.model.Note) ) || ( this._startNote.beat.index != this._endNote.beat.index ) ))
{
return ;
}
global::alphatab.rendering.ScoreBarRenderer r = ((global::alphatab.rendering.ScoreBarRenderer) (this.renderer) );
global::alphatab.rendering.glyphs.BeatContainerGlyph parent = ((global::alphatab.rendering.glyphs.BeatContainerGlyph) (this._parent) );
int startX = ( cx + r.getNoteX(this._startNote, default(global::haxe.lang.Null<bool>)) );
int endX = default(int);
if (( this._endNote == default(global::alphatab.model.Note) ))
{
endX = ( ( ( cx + parent.x ) + parent.postNotes.x ) + parent.postNotes.width );
}
else
{
endX = ( cx + r.getNoteX(this._endNote, new global::haxe.lang.Null<bool>(false, true)) );
}
double startY = ( ( cy + r.getNoteY(this._startNote) ) + 4.5 );
double endY = default(double);
if (( this._endNote == default(global::alphatab.model.Note) ))
{
endY = startY;
}
else
{
endY = ( ( cy + r.getNoteY(this._endNote) ) + 4.5 );
}
global::alphatab.rendering.glyphs.TieGlyph.paintTie(canvas, this.renderer.stave.staveGroup.layout.renderer.settings.scale, ((double) (startX) ), startY, ((double) (endX) ), endY, new global::haxe.lang.Null<bool>(( r.getBeatDirection(this._startNote.beat) == global::alphatab.rendering.utils.BeamDirection.Down ), true));
canvas.setColor(this.renderer.stave.staveGroup.layout.renderer.renderingResources.mainGlyphColor);
canvas.fill();
}
}
public override void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
global::alphatab.rendering.RenderingResources res = this.renderer.stave.staveGroup.layout.renderer.renderingResources;
canvas.setColor(res.barSeperatorColor);
double blockWidth = ( 4 * this.renderer.stave.staveGroup.layout.renderer.settings.scale );
int top = ( ( cy + this.y ) + this.renderer.getTopPadding() );
int bottom = ( ( ( cy + this.y ) + this.renderer.height ) - this.renderer.getBottomPadding() );
double left = ((double) (( cx + this.x )) );
int h = ( bottom - top );
canvas.beginPath();
canvas.moveTo(left, ((double) (top) ));
canvas.lineTo(left, ((double) (bottom) ));
canvas.stroke();
if (this._isLast)
{
left += ( ( 3 * this.renderer.stave.staveGroup.layout.renderer.settings.scale ) + 0.5 );
canvas.fillRect(left, ((double) (top) ), blockWidth, ((double) (h) ));
}
}
}
public override void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
double height = ( 17 * this.renderer.stave.staveGroup.layout.renderer.settings.scale );
global::alphatab.rendering.RenderingResources res = this.renderer.stave.staveGroup.layout.renderer.renderingResources;
canvas.setColor(res.mainGlyphColor);
canvas.beginPath();
if (( this._crescendo == global::alphatab.rendering.glyphs.CrescendoType.Crescendo ))
{
canvas.moveTo(((double) (( ( cx + this.x ) + this.width )) ), ((double) (( cy + this.y )) ));
canvas.lineTo(((double) (( cx + this.x )) ), ((double) (( ( cy + this.y ) + ((int) (( height / 2 )) ) )) ));
canvas.lineTo(((double) (( ( cx + this.x ) + this.width )) ), ( ( cy + this.y ) + height ));
}
else
{
canvas.moveTo(((double) (( cx + this.x )) ), ((double) (( cy + this.y )) ));
canvas.lineTo(((double) (( ( cx + this.x ) + this.width )) ), ((double) (( ( cy + this.y ) + ((int) (( height / 2 )) ) )) ));
canvas.lineTo(((double) (( cx + this.x )) ), ( ( cy + this.y ) + height ));
}
canvas.stroke();
}
}
public override void paintBackground(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
global::alphatab.rendering.RenderingResources res = this.stave.staveGroup.layout.renderer.renderingResources;
canvas.setColor(res.staveLineColor);
int lineY = ( ( cy + this.y ) + this.getNumberOverflow() );
int startY = lineY;
{
int _g1 = 0;
int _g = this._bar.track.tuning.length;
while (( _g1 < _g ))
{
int i = _g1++;
if (( i > 0 ))
{
lineY += ((int) (( 11 * this.stave.staveGroup.layout.renderer.settings.scale )) );
}
canvas.beginPath();
canvas.moveTo(((double) (( cx + this.x )) ), ((double) (lineY) ));
canvas.lineTo(((double) (( ( cx + this.x ) + this.width )) ), ((double) (lineY) ));
canvas.stroke();
}
}
}
}
public override void paint(global::java.awt.Graphics g)
{
// old school gradient :)
var h = this.getHeight();
var w = this.getWidth();
for (int i = 0; i < h; i++)
{
g.setColor(GetBlue(1 - (double)i / (double)h));
g.drawLine(0, i, w, i);
}
g.setColor(new Color(0xffff00));
if (!string.IsNullOrEmpty(Error))
g.drawString(Error, 16, 64);
if (this.Maze != null)
{
try
{
int x, y;
int z = 12;
for (x = 1; x < Maze.Width - 1; x++)
for (y = 1; y < Maze.Height - 1; y++)
{
var v = Maze[x, y];
if ((v & 1) != 0) /* This cell has a top wall */
g.drawLine(x * z, y * z, x * z + z, y * z);
if ((v & 4) != 0) /* This cell has a left wall */
g.drawLine(x * z, y * z, x * z, y * z + z);
if ((v & 8) != 0) /* This cell has a right wall */
g.drawLine(x * z + z, y * z, x * z + z, y * z + z);
if ((v & 2) != 0) /* This cell has a bottom wall */
g.drawLine(x * z, y * z + z, x * z + z, y * z + z);
}
var offset = Maze.Width * z;
g.setColor(new Color(0x00ff00));
g.drawRect(offset + z, z, (Maze.Width - 2) * z, (Maze.Height - 2) * z);
for (x = 1; x < Maze.Width - 1; x++)
for (y = 1; y < Maze.Height - 1; y++)
{
var v = Maze[x, y];
var IsTop = (v & 1) != 0;
var IsLeft = (v & 4) != 0;
if (IsTop) /* This cell has a top wall */
g.fillRect(offset + x * z, y * z, z, z / 3);
if (IsLeft) /* This cell has a left wall */
g.fillRect(offset + x * z, y * z, z / 3, z);
var IsBottom = (v & 2) != 0;
var IsRight = (v & 8) != 0;
if (IsRight)
{
g.fillRect(offset + x * z + z - z / 3, y * z, z / 3, z);
}
if (IsBottom)
{
g.fillRect(offset + x * z, y * z + z - z / 3, z, z / 3);
}
}
}
catch
{
}
}
}
public override void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
global::alphatab.rendering.TabBarRenderer tabBarRenderer = ((global::alphatab.rendering.TabBarRenderer) (this.renderer) );
global::alphatab.model.Track track = this.renderer.stave.staveGroup.layout.renderer.track;
global::alphatab.rendering.RenderingResources res = this.renderer.stave.staveGroup.layout.renderer.renderingResources;
double startY = ( ( cy + this.y ) + ( ( 10 * this.renderer.stave.staveGroup.layout.renderer.settings.scale ) * 0.6 ) );
int endY = ( ( cy + this.y ) + tabBarRenderer.getTabY(track.tuning.length, new global::haxe.lang.Null<int>(-2, true)) );
double fontScale = ((double) (1) );
double correction = ((double) (0) );
{
int _g = track.tuning.length;
switch (_g)
{
case 4:
{
fontScale = 0.6;
break;
}
case 5:
{
fontScale = 0.8;
break;
}
case 6:
{
fontScale = 1.1;
correction = ((double) (1) );
break;
}
case 7:
{
fontScale = 1.15;
break;
}
case 8:
{
fontScale = 1.35;
break;
}
}
}
global::alphatab.platform.model.Font font = res.tabClefFont.clone();
font.setSize(( font.getSize() * fontScale ));
canvas.setColor(res.mainGlyphColor);
canvas.setFont(font);
canvas.setTextAlign(global::alphatab.platform.model.TextAlign.Center);
canvas.fillText("T", ((double) (( ( cx + this.x ) + ( this.width / 2 ) )) ), startY);
canvas.fillText("A", ((double) (( ( cx + this.x ) + ( this.width / 2 ) )) ), ( ( startY + font.getSize() ) - ((int) (( correction * this.renderer.stave.staveGroup.layout.renderer.settings.scale )) ) ));
canvas.fillText("B", ((double) (( ( cx + this.x ) + ( this.width / 2 ) )) ), ( startY + ( (( font.getSize() - ((int) (( correction * this.renderer.stave.staveGroup.layout.renderer.settings.scale )) ) )) * 2 ) ));
}
}
public override void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
if (( this._svg == default(global::alphatab.rendering.glyphs.LazySvg) ))
{
return ;
}
this._xScale = ( this._xGlyphScale * this.renderer.stave.staveGroup.layout.renderer.settings.scale );
this._yScale = ( this._yGlyphScale * this.renderer.stave.staveGroup.layout.renderer.settings.scale );
global::alphatab.rendering.RenderingResources res = this.renderer.stave.staveGroup.layout.renderer.renderingResources;
canvas.setColor(res.mainGlyphColor);
int startX = ( this.x + cx );
int startY = ( this.y + cy );
this._currentX = ((double) (startX) );
this._currentY = ((double) (startY) );
canvas.setColor(new global::alphatab.platform.model.Color(((int) (0) ), ((int) (0) ), ((int) (0) ), ((global::haxe.lang.Null<int>) (default(global::haxe.lang.Null<int>)) )));
canvas.beginPath();
{
int _g = 0;
global::haxe.root.Array<object> _g1 = this._svg.@get();
while (( _g < _g1.length ))
{
global::alphatab.rendering.glyphs.SvgCommand c = ((global::alphatab.rendering.glyphs.SvgCommand) (_g1[_g]) );
++ _g;
this.parseCommand(startX, startY, canvas, c);
}
}
canvas.fill();
}
}
public virtual void paintFooter(int cx, int cy, global::alphatab.platform.ICanvas canvas, global::alphatab.rendering.utils.BeamingHelper h)
{
unchecked
{
global::alphatab.model.Beat beat = ((global::alphatab.model.Beat) (h.beats[0]) );
if (( beat.duration == global::alphatab.model.Duration.Whole ))
{
return ;
}
bool isGrace = ( beat.graceType != global::alphatab.model.GraceType.None );
double scaleMod = default(double);
if (isGrace)
{
scaleMod = 0.7;
}
else
{
scaleMod = ((double) (1) );
}
int stemSize = this.getStemSize(h.maxDuration);
int correction = ((int) (( ( 9 * scaleMod ) / 2 )) );
int beatLineX = default(int);
{
double x = ( h.getBeatLineX(beat) + this.stave.staveGroup.layout.renderer.settings.scale );
beatLineX = ((int) (x) );
}
global::alphatab.rendering.utils.BeamDirection direction = h.getDirection();
int topY = this.getScoreY(this.getNoteLine(beat.maxNote()), new global::haxe.lang.Null<int>(correction, true));
int bottomY = this.getScoreY(this.getNoteLine(beat.minNote()), new global::haxe.lang.Null<int>(correction, true));
int beamY = default(int);
if (( direction == global::alphatab.rendering.utils.BeamDirection.Down ))
{
bottomY += ((int) (( stemSize * scaleMod )) );
beamY = bottomY;
}
else
{
topY -= ((int) (( stemSize * scaleMod )) );
beamY = topY;
}
canvas.setColor(this.stave.staveGroup.layout.renderer.renderingResources.mainGlyphColor);
canvas.beginPath();
canvas.moveTo(((double) (((int) (( ( cx + this.x ) + beatLineX )) )) ), ((double) (( ( cy + this.y ) + topY )) ));
canvas.lineTo(((double) (((int) (( ( cx + this.x ) + beatLineX )) )) ), ((double) (( ( cy + this.y ) + bottomY )) ));
canvas.stroke();
if (isGrace)
{
double graceSizeY = ( 15 * this.stave.staveGroup.layout.renderer.settings.scale );
double graceSizeX = ( 12 * this.stave.staveGroup.layout.renderer.settings.scale );
canvas.beginPath();
if (( direction == global::alphatab.rendering.utils.BeamDirection.Down ))
{
canvas.moveTo(((double) (((int) (( ( ( cx + this.x ) + beatLineX ) - ( graceSizeX / 2 ) )) )) ), ( ( ( cy + this.y ) + bottomY ) - graceSizeY ));
canvas.lineTo(((double) (((int) (( ( ( cx + this.x ) + beatLineX ) + ( graceSizeX / 2 ) )) )) ), ((double) (( ( cy + this.y ) + bottomY )) ));
}
else
{
canvas.moveTo(((double) (((int) (( ( ( cx + this.x ) + beatLineX ) - ( graceSizeX / 2 ) )) )) ), ( ( ( cy + this.y ) + topY ) + graceSizeY ));
canvas.lineTo(((double) (((int) (( ( ( cx + this.x ) + beatLineX ) + ( graceSizeX / 2 ) )) )) ), ((double) (( ( cy + this.y ) + topY )) ));
}
canvas.stroke();
}
int gx = ((int) (beatLineX) );
global::alphatab.rendering.glyphs.BeamGlyph glyph = new global::alphatab.rendering.glyphs.BeamGlyph(new global::haxe.lang.Null<int>(gx, true), new global::haxe.lang.Null<int>(beamY, true), ((global::alphatab.model.Duration) (beat.duration) ), ((global::alphatab.rendering.utils.BeamDirection) (direction) ), ((bool) (isGrace) ));
glyph.renderer = this;
glyph.doLayout();
glyph.paint(( cx + this.x ), ( cy + this.y ), canvas);
}
}
public override void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
if (( ( this._endNote == default(global::alphatab.model.Note) ) || ( this._startNote.beat.index != this._endNote.beat.index ) ))
{
return ;
}
global::alphatab.rendering.TabBarRenderer r = ((global::alphatab.rendering.TabBarRenderer) (this.renderer) );
global::alphatab.rendering.glyphs.TabBeatContainerGlyph parent = ((global::alphatab.rendering.glyphs.TabBeatContainerGlyph) (this._parent) );
global::alphatab.rendering.RenderingResources res = r.stave.staveGroup.layout.renderer.renderingResources;
int startX = ( cx + r.getNoteX(this._startNote, default(global::haxe.lang.Null<bool>)) );
int endX = default(int);
if (( this._endNote == default(global::alphatab.model.Note) ))
{
endX = ( ( ( cx + parent.x ) + parent.postNotes.x ) + parent.postNotes.width );
}
else
{
endX = ( cx + r.getNoteX(this._endNote, new global::haxe.lang.Null<bool>(false, true)) );
}
bool down = ( this._startNote.@string > 3 );
double offset = ( res.tablatureFont.getSize() / 2 );
if (down)
{
offset *= ((double) (-1) );
}
double startY = ( ( cy + r.getNoteY(this._startNote) ) + offset );
double endY = default(double);
if (( this._endNote == default(global::alphatab.model.Note) ))
{
endY = startY;
}
else
{
endY = ( ( cy + r.getNoteY(this._endNote) ) + offset );
}
global::alphatab.rendering.glyphs.TieGlyph.paintTie(canvas, this.renderer.stave.staveGroup.layout.renderer.settings.scale, ((double) (startX) ), startY, ((double) (endX) ), endY, new global::haxe.lang.Null<bool>(( this._startNote.@string > 3 ), true));
canvas.setColor(this.renderer.stave.staveGroup.layout.renderer.renderingResources.mainGlyphColor);
canvas.fill();
}
}
public override void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
global::alphatab.rendering.RenderingResources res = this.renderer.stave.staveGroup.layout.renderer.renderingResources;
global::alphatab.model.TextBaseline old = canvas.getTextBaseline();
canvas.setTextBaseline(global::alphatab.model.TextBaseline.Middle);
canvas.setColor(res.mainGlyphColor);
if (this._isGrace)
{
canvas.setFont(res.graceFont);
}
else
{
canvas.setFont(res.tablatureFont);
}
{
int _g = 0;
global::haxe.root.Array<object> _g1 = this._notes;
while (( _g < _g1.length ))
{
global::alphatab.rendering.glyphs.NoteNumberGlyph g = ((global::alphatab.rendering.glyphs.NoteNumberGlyph) (_g1[_g]) );
++ _g;
g.renderer = this.renderer;
g.paint(( cx + this.x ), ( cy + this.y ), canvas);
}
}
canvas.setTextBaseline(old);
{
object __temp_iterator450 = this.beatEffects.iterator();
while (((bool) (global::haxe.lang.Runtime.callField(__temp_iterator450, "hasNext", 407283053, default(global::haxe.root.Array))) ))
{
global::alphatab.rendering.Glyph g1 = ((global::alphatab.rendering.Glyph) (global::haxe.lang.Runtime.callField(__temp_iterator450, "next", 1224901875, default(global::haxe.root.Array))) );
g1.paint(( cx + this.x ), ( cy + this.y ), canvas);
}
}
}
}
public virtual void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
{
int _g = 0;
global::haxe.root.Array<object> _g1 = this.staves;
while (( _g < _g1.length ))
{
global::alphatab.rendering.staves.Stave s = ((global::alphatab.rendering.staves.Stave) (_g1[_g]) );
++ _g;
s.paint(( cx + this.x ), ( cy + this.y ), canvas);
}
}
global::alphatab.rendering.RenderingResources res = this.layout.renderer.renderingResources;
if (( this.staves.length > 0 ))
{
if (( ( this._firstStaveInAccolade != default(global::alphatab.rendering.staves.Stave) ) && ( this._lastStaveInAccolade != default(global::alphatab.rendering.staves.Stave) ) ))
{
int firstStart = ( ( ( ( ( cy + this.y ) + this._firstStaveInAccolade.y ) + this._firstStaveInAccolade.staveTop ) + this._firstStaveInAccolade.topSpacing ) + this._firstStaveInAccolade.getTopOverflow() );
int lastEnd = ( ( ( ( ( cy + this.y ) + this._lastStaveInAccolade.y ) + this._lastStaveInAccolade.topSpacing ) + this._lastStaveInAccolade.getTopOverflow() ) + this._lastStaveInAccolade.staveBottom );
canvas.setColor(res.barSeperatorColor);
canvas.beginPath();
canvas.moveTo(((double) (( ( cx + this.x ) + this._firstStaveInAccolade.x )) ), ((double) (firstStart) ));
canvas.lineTo(((double) (( ( cx + this.x ) + this._lastStaveInAccolade.x )) ), ((double) (lastEnd) ));
canvas.stroke();
int barSize = ((int) (( 3 * this.layout.renderer.settings.scale )) );
int barOffset = barSize;
int accoladeStart = ( firstStart - ( barSize * 4 ) );
int accoladeEnd = ( lastEnd + ( barSize * 4 ) );
canvas.fillRect(((double) (( ( ( cx + this.x ) - barOffset ) - barSize )) ), ((double) (accoladeStart) ), ((double) (barSize) ), ((double) (( accoladeEnd - accoladeStart )) ));
int spikeStartX = ( ( ( cx + this.x ) - barOffset ) - barSize );
int spikeEndX = ( ( cx + this.x ) + ( barSize * 2 ) );
canvas.beginPath();
canvas.moveTo(((double) (spikeStartX) ), ((double) (accoladeStart) ));
canvas.bezierCurveTo(((double) (spikeStartX) ), ((double) (accoladeStart) ), ((double) (this.x) ), ((double) (accoladeStart) ), ((double) (spikeEndX) ), ((double) (( accoladeStart - barSize )) ));
canvas.bezierCurveTo(((double) (( cx + this.x )) ), ((double) (( accoladeStart + barSize )) ), ((double) (spikeStartX) ), ((double) (( accoladeStart + barSize )) ), ((double) (spikeStartX) ), ((double) (( accoladeStart + barSize )) ));
canvas.closePath();
canvas.fill();
canvas.beginPath();
canvas.moveTo(((double) (spikeStartX) ), ((double) (accoladeEnd) ));
canvas.bezierCurveTo(((double) (spikeStartX) ), ((double) (accoladeEnd) ), ((double) (this.x) ), ((double) (accoladeEnd) ), ((double) (spikeEndX) ), ((double) (( accoladeEnd + barSize )) ));
canvas.bezierCurveTo(((double) (this.x) ), ((double) (( accoladeEnd - barSize )) ), ((double) (spikeStartX) ), ((double) (( accoladeEnd - barSize )) ), ((double) (spikeStartX) ), ((double) (( accoladeEnd - barSize )) ));
canvas.closePath();
canvas.fill();
}
}
}
}
public virtual void drawInfoGuide(global::alphatab.platform.ICanvas canvas, int cx, int cy, int y, global::alphatab.platform.model.Color c)
{
unchecked
{
canvas.setColor(c);
canvas.beginPath();
canvas.moveTo(((double) (( cx + this.x )) ), ((double) (( ( cy + this.y ) + y )) ));
canvas.lineTo(((double) (( ( cx + this.x ) + this.width )) ), ((double) (( ( cy + this.y ) + y )) ));
canvas.stroke();
}
}
public override void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
double step = ( 11 * this.renderer.stave.staveGroup.layout.renderer.settings.scale );
int loops = default(int);
{
double v = global::System.Math.Max(((double) (1) ), ((double) (( this.width / step )) ));
{
double x = global::System.Math.Floor(((double) (v) ));
loops = ((int) (x) );
}
}
global::alphatab.rendering.RenderingResources res = this.renderer.stave.staveGroup.layout.renderer.renderingResources;
canvas.setColor(res.mainGlyphColor);
canvas.setFont(res.effectFont);
canvas.setTextAlign(global::alphatab.platform.model.TextAlign.Left);
double textWidth = canvas.measureText(this._label);
canvas.fillText(this._label, ((double) (( cx + this.x )) ), ((double) (( cy + this.y )) ));
if (this._isExpanded)
{
int lineSpacing = ((int) (( 3 * this.renderer.stave.staveGroup.layout.renderer.settings.scale )) );
double startX = ( ( ( cx + this.x ) + textWidth ) + lineSpacing );
int endX = ( ( ( ( cx + this.x ) + this.width ) - lineSpacing ) - lineSpacing );
int lineY = ( ( cy + this.y ) + ((int) (( 8 * this.renderer.stave.staveGroup.layout.renderer.settings.scale )) ) );
int lineSize = ((int) (( 8 * this.renderer.stave.staveGroup.layout.renderer.settings.scale )) );
if (( endX > startX ))
{
double lineX = startX;
while (( lineX < endX ))
{
canvas.beginPath();
canvas.moveTo(lineX, ((double) (lineY) ));
int __temp_stmt606 = default(int);
{
double x1 = global::System.Math.Min(((double) (( lineX + lineSize )) ), ((double) (endX) ));
__temp_stmt606 = ((int) (x1) );
}
canvas.lineTo(((double) (__temp_stmt606) ), ((double) (lineY) ));
lineX += ((double) (( lineSize + lineSpacing )) );
canvas.stroke();
}
canvas.beginPath();
canvas.moveTo(((double) (endX) ), ((double) (( lineY - ((int) (( 6 * this.renderer.stave.staveGroup.layout.renderer.settings.scale )) ) )) ));
canvas.lineTo(((double) (endX) ), ((double) (( lineY + ((int) (( 6 * this.renderer.stave.staveGroup.layout.renderer.settings.scale )) ) )) ));
canvas.stroke();
}
}
}
}
public override void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
global::alphatab.rendering.ScoreBarRenderer r = ((global::alphatab.rendering.ScoreBarRenderer) (this.renderer) );
int sizeX = ((int) (( 12 * this.renderer.stave.staveGroup.layout.renderer.settings.scale )) );
int offsetX = ((int) (this.renderer.stave.staveGroup.layout.renderer.settings.scale) );
int startX = default(int);
int startY = default(int);
int endX = default(int);
int endY = default(int);
{
global::alphatab.model.SlideType _g = this._type;
switch (global::haxe.root.Type.enumIndex(_g))
{
case 1:case 2:
{
startX = ( ( cx + r.getNoteX(this._startNote, new global::haxe.lang.Null<bool>(true, true)) ) + offsetX );
startY = ( ( cy + r.getNoteY(this._startNote) ) + 4 );
if (( this._startNote.slideTarget != default(global::alphatab.model.Note) ))
{
endX = ( ( cx + r.getNoteX(this._startNote.slideTarget, new global::haxe.lang.Null<bool>(false, true)) ) - offsetX );
endY = ( ( cy + r.getNoteY(this._startNote.slideTarget) ) + 4 );
}
else
{
endX = ( ( ( cx + this._parent.x ) + this._parent.postNotes.x ) + this._parent.postNotes.width );
endY = startY;
}
break;
}
case 3:
{
endX = ( ( cx + r.getNoteX(this._startNote, new global::haxe.lang.Null<bool>(false, true)) ) - offsetX );
endY = ( ( cy + r.getNoteY(this._startNote) ) + 4 );
startX = ( endX - sizeX );
startY = ( ( cy + r.getNoteY(this._startNote) ) + 9 );
break;
}
case 4:
{
endX = ( ( cx + r.getNoteX(this._startNote, new global::haxe.lang.Null<bool>(false, true)) ) - offsetX );
endY = ( ( cy + r.getNoteY(this._startNote) ) + 4 );
startX = ( endX - sizeX );
startY = ( cy + r.getNoteY(this._startNote) );
break;
}
case 5:
{
startX = ( ( cx + r.getNoteX(this._startNote, new global::haxe.lang.Null<bool>(true, true)) ) + offsetX );
startY = ( ( cy + r.getNoteY(this._startNote) ) + 4 );
endX = ( startX + sizeX );
endY = ( cy + r.getNoteY(this._startNote) );
break;
}
case 6:
{
startX = ( ( cx + r.getNoteX(this._startNote, new global::haxe.lang.Null<bool>(true, true)) ) + offsetX );
startY = ( ( cy + r.getNoteY(this._startNote) ) + 4 );
endX = ( startX + sizeX );
endY = ( ( cy + r.getNoteY(this._startNote) ) + 9 );
break;
}
default:
{
return ;
}
}
}
canvas.setColor(this.renderer.stave.staveGroup.layout.renderer.renderingResources.mainGlyphColor);
canvas.beginPath();
canvas.moveTo(((double) (startX) ), ((double) (startY) ));
canvas.lineTo(((double) (endX) ), ((double) (endY) ));
canvas.stroke();
}
}
public override void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
if (this._hidden)
{
return ;
}
global::alphatab.rendering.RenderingResources res = this.renderer.stave.staveGroup.layout.renderer.renderingResources;
canvas.setColor(res.barNumberColor);
canvas.setFont(res.barNumberFont);
canvas.fillText(global::Std.@string(this._number), ((double) (( cx + this.x )) ), ((double) (( cy + this.y )) ));
}
}
public override void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
if (( this._endings.length > 0 ))
{
global::alphatab.rendering.RenderingResources res = this.stave.staveGroup.layout.renderer.renderingResources;
canvas.setColor(res.mainGlyphColor);
canvas.setFont(res.wordsFont);
canvas.moveTo(((double) (( cx + this.x )) ), ((double) (( ( cy + this.y ) + this.height )) ));
canvas.lineTo(((double) (( cx + this.x )) ), ((double) (( cy + this.y )) ));
canvas.lineTo(((double) (( ( cx + this.x ) + this.width )) ), ((double) (( cy + this.y )) ));
canvas.stroke();
canvas.fillText(this._endingsString, ((double) (((int) (( ( cx + this.x ) + ( 3 * this.stave.staveGroup.layout.renderer.settings.scale ) )) )) ), ((double) (((int) (( cy + ( this.y * this.stave.staveGroup.layout.renderer.settings.scale ) )) )) ));
}
}
}
public override void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
global::alphatab.rendering.ScoreBarRenderer scoreRenderer = ((global::alphatab.rendering.ScoreBarRenderer) (this.renderer) );
int effectY = default(int);
if (( this.beamingHelper.getDirection() == global::alphatab.rendering.utils.BeamDirection.Up ))
{
effectY = scoreRenderer.getScoreY(((int) (global::haxe.lang.Runtime.getField_f(this.maxNote, "line", 1202919412, true)) ), new global::haxe.lang.Null<int>(13, true));
}
else
{
effectY = scoreRenderer.getScoreY(((int) (global::haxe.lang.Runtime.getField_f(this.minNote, "line", 1202919412, true)) ), new global::haxe.lang.Null<int>(-9, true));
}
int effectSpacing = default(int);
if (( this.beamingHelper.getDirection() == global::alphatab.rendering.utils.BeamDirection.Up ))
{
effectSpacing = ((int) (( 7 * this.renderer.stave.staveGroup.layout.renderer.settings.scale )) );
}
else
{
effectSpacing = ((int) (( -7 * this.renderer.stave.staveGroup.layout.renderer.settings.scale )) );
}
{
object __temp_iterator448 = this.beatEffects.iterator();
while (((bool) (global::haxe.lang.Runtime.callField(__temp_iterator448, "hasNext", 407283053, default(global::haxe.root.Array))) ))
{
global::alphatab.rendering.Glyph g = ((global::alphatab.rendering.Glyph) (global::haxe.lang.Runtime.callField(__temp_iterator448, "next", 1224901875, default(global::haxe.root.Array))) );
g.y = effectY;
g.x = ( this.width / 2 );
g.paint(( cx + this.x ), ( cy + this.y ), canvas);
effectY += effectSpacing;
}
}
canvas.setColor(this.renderer.stave.staveGroup.layout.renderer.renderingResources.staveLineColor);
int linePadding = ((int) (( 3 * this.renderer.stave.staveGroup.layout.renderer.settings.scale )) );
if (this.hasTopOverflow())
{
int l = -1;
while (( global::haxe.lang.Runtime.compare(l, ((int) (global::haxe.lang.Runtime.getField_f(this.minNote, "line", 1202919412, true)) )) >= 0 ))
{
int lY = ( ( cy + this.y ) + scoreRenderer.getScoreY(( l + 1 ), new global::haxe.lang.Null<int>(-1, true)) );
canvas.beginPath();
canvas.moveTo(((double) (( ( cx + this.x ) - linePadding )) ), ((double) (lY) ));
canvas.lineTo(((double) (( ( ( cx + this.x ) + this.width ) + linePadding )) ), ((double) (lY) ));
canvas.stroke();
l -= 2;
}
}
if (this.hasBottomOverflow())
{
int l1 = 11;
while (( global::haxe.lang.Runtime.compare(l1, ((int) (global::haxe.lang.Runtime.getField_f(this.maxNote, "line", 1202919412, true)) )) <= 0 ))
{
int lY1 = ( ( cy + this.y ) + scoreRenderer.getScoreY(( l1 + 1 ), new global::haxe.lang.Null<int>(-1, true)) );
canvas.beginPath();
canvas.moveTo(((double) (( ( cx + this.x ) - linePadding )) ), ((double) (lY1) ));
canvas.lineTo(((double) (( ( ( cx + this.x ) + this.width ) + linePadding )) ), ((double) (lY1) ));
canvas.stroke();
l1 += 2;
}
}
if (( this._tremoloPicking != default(global::alphatab.rendering.Glyph) ))
{
this._tremoloPicking.paint(( cx + this.x ), ( cy + this.y ), canvas);
}
{
int _g = 0;
global::haxe.root.Array<object> _g1 = this._infos;
while (( _g < _g1.length ))
{
object g1 = _g1[_g];
++ _g;
((global::alphatab.rendering.Glyph) (global::haxe.lang.Runtime.getField(g1, "glyph", 369425836, true)) ).renderer = this.renderer;
((global::alphatab.rendering.Glyph) (global::haxe.lang.Runtime.getField(g1, "glyph", 369425836, true)) ).paint(( cx + this.x ), ( cy + this.y ), canvas);
}
}
}
}
public override void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
global::alphatab.rendering.TabBarRenderer tabBarRenderer = ((global::alphatab.rendering.TabBarRenderer) (this.renderer) );
global::alphatab.rendering.RenderingResources res = this.renderer.stave.staveGroup.layout.renderer.renderingResources;
int startY = default(int);
int __temp_stmt600 = default(int);
{
double x = ( tabBarRenderer.getNoteY(this._beat.maxNote()) - ( res.tablatureFont.getSize() / 2 ) );
__temp_stmt600 = ((int) (x) );
}
startY = ( ( cy + this.y ) + __temp_stmt600 );
double endY = ( ( ( cy + this.y ) + tabBarRenderer.getNoteY(this._beat.minNote()) ) + ( res.tablatureFont.getSize() / 2 ) );
int arrowX = ((int) (( ( cx + this.x ) + ( ((double) (this.width) ) / 2 ) )) );
double arrowSize = ( 8 * this.renderer.stave.staveGroup.layout.renderer.settings.scale );
canvas.setColor(res.mainGlyphColor);
if (( this._beat.brushType != global::alphatab.model.BrushType.None ))
{
if (( ( this._beat.brushType == global::alphatab.model.BrushType.BrushUp ) || ( this._beat.brushType == global::alphatab.model.BrushType.BrushDown ) ))
{
canvas.beginPath();
canvas.moveTo(((double) (arrowX) ), ((double) (startY) ));
canvas.lineTo(((double) (arrowX) ), endY);
canvas.stroke();
}
else
{
int size = ((int) (( 15 * this.renderer.stave.staveGroup.layout.renderer.settings.scale )) );
int steps = default(int);
{
double v = ( global::System.Math.Abs(((double) (( endY - startY )) )) / size );
{
double x1 = global::System.Math.Floor(((double) (v) ));
steps = ((int) (x1) );
}
}
{
int _g = 0;
while (( _g < ((int) (steps) ) ))
{
int i = _g++;
global::alphatab.rendering.glyphs.SvgGlyph arrow = new global::alphatab.rendering.glyphs.SvgGlyph(new global::haxe.lang.Null<int>(((int) (( 3 * this.renderer.stave.staveGroup.layout.renderer.settings.scale )) ), true), new global::haxe.lang.Null<int>(0, true), ((global::alphatab.rendering.glyphs.LazySvg) (global::alphatab.rendering.glyphs.MusicFont.WaveVertical) ), ((double) (1) ), ((double) (1) ));
arrow.renderer = this.renderer;
arrow.doLayout();
arrow.paint(( cx + this.x ), ( startY + ( i * size ) ), canvas);
}
}
}
if (( ( this._beat.brushType == global::alphatab.model.BrushType.BrushUp ) || ( this._beat.brushType == global::alphatab.model.BrushType.ArpeggioUp ) ))
{
canvas.beginPath();
canvas.moveTo(((double) (arrowX) ), endY);
canvas.lineTo(((double) (((int) (( arrowX + ( arrowSize / 2 ) )) )) ), ((double) (((int) (( endY - arrowSize )) )) ));
canvas.lineTo(((double) (((int) (( arrowX - ( arrowSize / 2 ) )) )) ), ((double) (((int) (( endY - arrowSize )) )) ));
canvas.closePath();
canvas.fill();
}
else
{
canvas.beginPath();
canvas.moveTo(((double) (arrowX) ), ((double) (startY) ));
canvas.lineTo(((double) (((int) (( arrowX + ( arrowSize / 2 ) )) )) ), ((double) (((int) (( startY + arrowSize )) )) ));
canvas.lineTo(((double) (((int) (( arrowX - ( arrowSize / 2 ) )) )) ), ((double) (((int) (( startY + arrowSize )) )) ));
canvas.closePath();
canvas.fill();
}
}
}
}
public override void paint(int cx, int cy, global::alphatab.platform.ICanvas canvas)
{
unchecked
{
global::alphatab.rendering.RenderingResources res = this.renderer.stave.staveGroup.layout.renderer.renderingResources;
canvas.setColor(res.mainGlyphColor);
global::haxe.root.Array<object> glyphs = default(global::haxe.root.Array<object>);
{
global::alphatab.model.DynamicValue _g = this._dynamics;
switch (global::haxe.root.Type.enumIndex(_g))
{
case 0:
{
glyphs = new global::haxe.root.Array<object>(new object[]{this.p(), this.p(), this.p()});
break;
}
case 1:
{
glyphs = new global::haxe.root.Array<object>(new object[]{this.p(), this.p()});
break;
}
case 2:
{
glyphs = new global::haxe.root.Array<object>(new object[]{this.p()});
break;
}
case 3:
{
glyphs = new global::haxe.root.Array<object>(new object[]{this.m(), this.p()});
break;
}
case 4:
{
glyphs = new global::haxe.root.Array<object>(new object[]{this.m(), this.f()});
break;
}
case 5:
{
glyphs = new global::haxe.root.Array<object>(new object[]{this.f()});
break;
}
case 6:
{
glyphs = new global::haxe.root.Array<object>(new object[]{this.f(), this.f()});
break;
}
case 7:
{
glyphs = new global::haxe.root.Array<object>(new object[]{this.f(), this.f(), this.f()});
break;
}
}
}
int glyphWidth = 0;
{
int _g1 = 0;
while (( _g1 < glyphs.length ))
{
global::alphatab.rendering.Glyph g = ((global::alphatab.rendering.Glyph) (glyphs[_g1]) );
++ _g1;
glyphWidth += g.width;
}
}
int startX = ( (( this.width - glyphWidth )) / 2 );
{
int _g2 = 0;
while (( _g2 < glyphs.length ))
{
global::alphatab.rendering.Glyph g1 = ((global::alphatab.rendering.Glyph) (glyphs[_g2]) );
++ _g2;
g1.x = startX;
g1.y = 0;
g1.renderer = this.renderer;
g1.paint(( cx + this.x ), ( cy + this.y ), canvas);
startX += g1.width;
}
}
}
}
public virtual void paintBar(int cx, int cy, global::alphatab.platform.ICanvas canvas, global::alphatab.rendering.utils.BeamingHelper h)
{
unchecked
{
int _g1 = 0;
int _g = h.beats.length;
while (( _g1 < _g ))
{
int i = _g1++;
global::alphatab.model.Beat beat = ((global::alphatab.model.Beat) (h.beats[i]) );
int correction = 4;
int beatLineX = default(int);
{
double x = ( h.getBeatLineX(beat) + this.stave.staveGroup.layout.renderer.settings.scale );
beatLineX = ((int) (x) );
}
global::alphatab.rendering.utils.BeamDirection direction = h.getDirection();
int y1 = default(int);
y1 = ( ( cy + this.y ) + (( (( direction == global::alphatab.rendering.utils.BeamDirection.Up )) ? (this.getScoreY(this.getNoteLine(beat.minNote()), new global::haxe.lang.Null<int>(( correction - 1 ), true))) : (this.getScoreY(this.getNoteLine(beat.maxNote()), new global::haxe.lang.Null<int>(( correction - 1 ), true))) )) );
int y2 = ( ( cy + this.y ) + this.calculateBeamY(h, beatLineX) );
canvas.setColor(this.stave.staveGroup.layout.renderer.renderingResources.mainGlyphColor);
canvas.beginPath();
canvas.moveTo(((double) (((int) (( ( cx + this.x ) + beatLineX )) )) ), ((double) (y1) ));
canvas.lineTo(((double) (((int) (( ( cx + this.x ) + beatLineX )) )) ), ((double) (y2) ));
canvas.stroke();
int brokenBarOffset = ((int) (( 6 * this.stave.staveGroup.layout.renderer.settings.scale )) );
int barSpacing = ((int) (( 6 * this.stave.staveGroup.layout.renderer.settings.scale )) );
int barSize = ((int) (( 3 * this.stave.staveGroup.layout.renderer.settings.scale )) );
int barCount = ( global::alphatab.model.ModelUtils.getDurationIndex(beat.duration) - 2 );
int barStart = ( cy + this.y );
if (( direction == global::alphatab.rendering.utils.BeamDirection.Down ))
{
barSpacing = - (barSpacing) ;
}
{
int _g2 = 0;
while (( _g2 < ((int) (barCount) ) ))
{
int barIndex = _g2++;
int barStartX = default(int);
int barEndX = default(int);
int barStartY = default(int);
int barEndY = default(int);
int barY = ( barStart + ( barIndex * barSpacing ) );
if (( i < ( h.beats.length - 1 ) ))
{
if (this.isFullBarJoin(beat, ((global::alphatab.model.Beat) (h.beats[( i + 1 )]) ), barIndex))
{
barStartX = beatLineX;
{
double x1 = ( h.getBeatLineX(((global::alphatab.model.Beat) (h.beats[( i + 1 )]) )) + this.stave.staveGroup.layout.renderer.settings.scale );
barEndX = ((int) (x1) );
}
}
else
{
if (( ( i == 0 ) || ! (this.isFullBarJoin(((global::alphatab.model.Beat) (h.beats[( i - 1 )]) ), beat, barIndex)) ))
{
barStartX = beatLineX;
barEndX = ( barStartX + brokenBarOffset );
}
else
{
continue;
}
}
{
double x2 = ((double) (( barY + this.calculateBeamY(h, barStartX) )) );
barStartY = ((int) (x2) );
}
{
double x3 = ((double) (( barY + this.calculateBeamY(h, barEndX) )) );
barEndY = ((int) (x3) );
}
global::alphatab.rendering.ScoreBarRenderer.paintSingleBar(canvas, ( ( cx + this.x ) + barStartX ), barStartY, ( ( cx + this.x ) + barEndX ), barEndY, barSize);
}
else
{
if (( ( i > 0 ) && ! (this.isFullBarJoin(beat, ((global::alphatab.model.Beat) (h.beats[( i - 1 )]) ), barIndex)) ))
{
barStartX = ( beatLineX - brokenBarOffset );
barEndX = beatLineX;
{
double x4 = ((double) (( barY + this.calculateBeamY(h, barStartX) )) );
barStartY = ((int) (x4) );
}
{
double x5 = ((double) (( barY + this.calculateBeamY(h, barEndX) )) );
barEndY = ((int) (x5) );
}
global::alphatab.rendering.ScoreBarRenderer.paintSingleBar(canvas, ( ( cx + this.x ) + barStartX ), barStartY, ( ( cx + this.x ) + barEndX ), barEndY, barSize);
}
}
}
}
}
}
}
