public override void Draw(CoreGraphics.CGRect rect)
{
base.Draw(rect);
using (CGContext g = UIGraphics.GetCurrentContext())
{
if (points != null)
{
CGPath currentPath = new CGPath();
currentPath.AddLines(points);
g.AddPath(currentPath);
g.SetLineWidth(2);
if (invertColors)
{
g.SetStrokeColor(UIColor.FromRGB(255, 255, 255).CGColor);
}
else
{
g.SetStrokeColor(UIColor.FromRGB(0, 0, 0).CGColor);
}
g.AddLineToPoint(rect.Right, rect.Bottom);
g.AddLineToPoint(rect.Left, rect.Bottom);
g.ClosePath();
if (displayPoints)
{
g.SetAlpha(.7f);
g.SetFillColor(UIColor.FromRGB(100, 100, 100).CGColor);
}
else if (invertColors)
{
g.SetFillColor(UIColor.FromRGB(255, 255, 255).CGColor);
}
else
{
g.SetFillColor(UIColor.FromRGB(0, 0, 0).CGColor);
}
g.DrawPath(CGPathDrawingMode.FillStroke);
g.SetAlpha(1f);
if (displayPoints)
{
nfloat smallRadius = Frame.Width * .01f;
nfloat bigRadius = Frame.Width * .03f;
foreach (CGPoint point in points)
{
g.SetFillColor(UIColor.FromRGB(0, 0, 0).CGColor);
g.SetAlpha(.3f);
g.AddArc(point.X, point.Y, bigRadius, 0.0f, (float)Math.PI * 2.0f, true);
g.FillPath();
g.SetAlpha(1f);
g.AddArc(point.X, point.Y, smallRadius, 0.0f, (float)Math.PI * 2.0f, true);
g.FillPath();
}
}
}
}
}
protected virtual void HandleShapeDraw(CGContext currentContext, RectangleF rect)
{
// Only used for circles
var centerX = rect.X + (rect.Width / 2);
var centerY = rect.Y + (rect.Height / 2);
var radius = rect.Width / 2;
var startAngle = 0;
var endAngle = (float)(Math.PI * 2);
switch (Element.ShapeType)
{
case ShapeType.Box:
HandleStandardDraw(currentContext, rect, () => {
if (Element.CornerRadius > 0)
{
var path = UIBezierPath.FromRoundedRect(rect, Element.CornerRadius);
currentContext.AddPath(path.CGPath);
}
else
{
currentContext.AddRect(rect);
}
});
break;
case ShapeType.Circle:
HandleStandardDraw(currentContext, rect, () => currentContext.AddArc(centerX, centerY, radius, startAngle, endAngle, true));
break;
case ShapeType.CircleIndicator:
HandleStandardDraw(currentContext, rect, () => currentContext.AddArc(centerX, centerY, radius, startAngle, endAngle, true));
HandleStandardDraw(currentContext, rect, () => currentContext.AddArc(centerX, centerY, radius, QuarterTurnCounterClockwise, (float)(Math.PI * 2 * (Element.IndicatorPercentage / 100)) + QuarterTurnCounterClockwise, false), Element.StrokeWidth + 3);
break;
}
}
private void DrawCircles(CGContext ctx, int x, int y)
{
ctx.SetFillColor(PipColor);
ctx.AddArc(x, y, PIP_RADIUS, 0, (float)(2 * Math.PI), true);
ctx.DrawPath(CGPathDrawingMode.Fill);
ctx.AddArc(x, y + 150, PIP_RADIUS, 0, (float)(2 * Math.PI), true);
ctx.DrawPath(CGPathDrawingMode.Fill);
}
public void DrawArc(float cx, float cy, float radius, float startAngle, float endAngle, float w)
{
if (float.IsNaN(cx) || float.IsNaN(cy) || float.IsNaN(radius) || float.IsNaN(startAngle) || float.IsNaN(endAngle) || float.IsNaN(w))
{
System.Diagnostics.Debug.WriteLine("NaN in CoreGraphicsGraphics.DrawArc");
return;
}
_c.SetLineWidth(w);
_c.AddArc(cx, cy, radius, -startAngle, -endAngle, true);
_c.StrokePath();
}
private void DrawArc(CGContext context, CGRect rect)
{
var radius = rect.GetMaxY() * badgeCornerRoundness;
var puffer = new nfloat(Padding(rect));
var maxX = rect.GetMaxX() - puffer;
var maxY = rect.GetMaxY() - puffer;
var minX = rect.GetMinX() + puffer;
var minY = rect.GetMinY() + puffer;
double pi = Math.PI;
context.AddArc(new nfloat(maxX - radius), new nfloat(minY + radius), new nfloat(radius), new nfloat(pi + (pi / 2)), 0, false);
context.AddArc(new nfloat(maxX - radius), new nfloat(minY - radius), new nfloat(radius), 0, new nfloat(pi / 2), false);
}
private void FillRoundedRect(RectangleF rect, CGContext context)
{
float radius = 10.0f;
context.BeginPath();
context.SetGrayFillColor(0.0f, Opacity);
context.MoveTo(rect.GetMinX() + radius, rect.GetMinY());
context.AddArc(rect.GetMaxX() - radius, rect.GetMinY() + radius, radius, (float)(3 * Math.PI / 2), 0f, false);
context.AddArc(rect.GetMaxX() - radius, rect.GetMaxY() - radius, radius, 0, (float)(Math.PI / 2), false);
context.AddArc(rect.GetMinX() + radius, rect.GetMaxY() - radius, radius, (float)(Math.PI / 2), (float)Math.PI, false);
context.AddArc(rect.GetMinX() + radius, rect.GetMinY() + radius, radius, (float)Math.PI, (float)(3 * Math.PI / 2), false);
context.ClosePath();
context.FillPath();
}
void FillRoundedRect(RectangleF rect, CGContext context)
{
float radius = 10.0f;
context.BeginPath();
//context.SetGrayFillColor (0.0f, this.Opacity);
context.MoveTo(rect.GetMinX() + radius, rect.GetMinY());
context.AddArc(rect.GetMaxX() - radius, rect.GetMinY() + radius, radius, (float)(3 * Math.PI / 2), 0f, false);
context.AddArc(rect.GetMaxX() - radius, rect.GetMaxY() - radius, radius, 0, (float)(Math.PI / 2), false);
context.AddArc(rect.GetMinX() + radius, rect.GetMaxY() - radius, radius, (float)(Math.PI / 2), (float)Math.PI, false);
context.AddArc(rect.GetMinX() + radius, rect.GetMinY() + radius, radius, (float)Math.PI, (float)(3 * Math.PI / 2), false);
context.ClosePath();
context.SetFillColorWithColor(this.RectangleColor.CGColor);
context.FillPath();
context.SetStrokeColorWithColor(RectangleBorderColor.CGColor);
context.BeginPath();
//context.SetGrayFillColor (0.0f, this.Opacity);
context.MoveTo(rect.GetMinX() + radius, rect.GetMinY());
context.AddArc(rect.GetMaxX() - radius, rect.GetMinY() + radius, radius, (float)(3 * Math.PI / 2), 0f, false);
context.AddArc(rect.GetMaxX() - radius, rect.GetMaxY() - radius, radius, 0, (float)(Math.PI / 2), false);
context.AddArc(rect.GetMinX() + radius, rect.GetMaxY() - radius, radius, (float)(Math.PI / 2), (float)Math.PI, false);
context.AddArc(rect.GetMinX() + radius, rect.GetMinY() + radius, radius, (float)Math.PI, (float)(3 * Math.PI / 2), false);
context.ClosePath();
context.StrokePath();
}
static void addPath(CGContext context, CGRect rect, float radius, RoundedCorner cornerMask)
{
context.MoveTo(rect.X, rect.Y + radius);
context.AddLineToPoint(rect.X, rect.Y + rect.Height - radius);
if (((int)cornerMask & (int)RoundedCorner.BottomLeft) != 0) {
context.AddArc(rect.X + radius, rect.Y + rect.Height - radius,
radius, (nfloat)Math.PI, (nfloat)Math.PI / 2, true);
}
else {
context.AddLineToPoint(rect.X, rect.Y + rect.Height);
context.AddLineToPoint(rect.X + radius, rect.Y + rect.Height);
}
context.AddLineToPoint(rect.X + rect.Width - radius,
rect.Y + rect.Height);
if (((int)cornerMask & (int)RoundedCorner.BottomRight) != 0) {
context.AddArc(rect.X + rect.Width - radius,
rect.Y + rect.Height - radius, radius, (nfloat)Math.PI / 2, 0.0f, true);
}
else {
context.AddLineToPoint(rect.X + rect.Width, rect.Y + rect.Height);
context.AddLineToPoint(rect.X + rect.Width, rect.Y + rect.Height - radius);
}
context.AddLineToPoint(rect.X + rect.Width, rect.Y + radius);
if (((int)cornerMask & (int)RoundedCorner.TopRight) != 0) {
context.AddArc(rect.X + rect.Width - radius, rect.Y + radius,
radius, 0, -(nfloat)Math.PI / 2, true);
}
else {
context.AddLineToPoint(rect.X + rect.Width, rect.Y);
context.AddLineToPoint(rect.X + rect.Width - radius, rect.Y);
}
context.AddLineToPoint(rect.X + radius, rect.Y);
if (((int)cornerMask & (int)RoundedCorner.TopLeft) != 0) {
context.AddArc(rect.X + radius, rect.Y + radius, radius,
-(nfloat)Math.PI / 2, (nfloat)Math.PI, true);
}
else {
context.AddLineToPoint(rect.X, rect.Y);
context.AddLineToPoint(rect.X, rect.Y + radius);
}
context.ClosePath();
}
public static void AddBottomRoundedRect(this CGContext c, RectangleF b, float r)
{
c.MoveTo(b.Left, b.Top + r);
c.AddLineToPoint(b.Left, b.Bottom - r);
c.AddArc(b.Left + r, b.Bottom - r, r, (float)(Math.PI), (float)(Math.PI / 2), true);
c.AddLineToPoint(b.Right - r, b.Bottom);
c.AddArc(b.Right - r, b.Bottom - r, r, (float)(-3 * Math.PI / 2), (float)(0), true);
c.AddLineToPoint(b.Right, b.Top);
c.AddLineToPoint(b.Left, b.Top);
}
public override void Draw(CGRect rect)
{
using (CGContext g = UIGraphics.GetCurrentContext())
{
g.AddArc((nfloat)Element.X, (nfloat)Element.Y, (nfloat)Element.RX, 0, (nfloat)Element.SweepAngle, true);
}
}
public override void Draw(RectangleF rect)
{
RectangleF allRect = this.Bounds;
RectangleF circleRect = new RectangleF(allRect.Location.X + 2, allRect.Location.Y + 2, allRect.Size.Width - 4, allRect.Size.Height - 4);
CGContext context = UIGraphics.GetCurrentContext();
// Draw background
context.SetRGBStrokeColor(1.0f, 1.0f, 1.0f, 1.0f);
// white
context.SetRGBFillColor(1.0f, 1.0f, 1.0f, 0.1f);
// translucent white
context.SetLineWidth(2.0f);
context.FillEllipseInRect(circleRect);
context.StrokeEllipseInRect(circleRect);
// Draw progress
float x = (allRect.Size.Width / 2);
float y = (allRect.Size.Height / 2);
context.SetRGBFillColor(1.0f, 1.0f, 1.0f, 1.0f);
// white
context.MoveTo(x, y);
context.AddArc(x, y, (allRect.Size.Width - 4) / 2, -(float)(Math.PI / 2), (float)(this.Progress * 2 * Math.PI) - (float)(Math.PI / 2), false);
context.ClosePath();
context.FillPath();
}
public override void Draw(CGRect rect)
{
// Load image
UIImage image = new UIImage("logo.png");
// Get drawing context
CGContext ctx = UIGraphics.GetCurrentContext();
// get view bounds
CGRect bounds = this.Bounds;
// Find the center of view
CGPoint center = new CGPoint();
center.X = bounds.X + bounds.Width / 2;
center.Y = bounds.Y + bounds.Height / 2;
// Compute the max radius of the circle
float maxRadius = (float)Math.Sqrt(Math.Pow(bounds.Size.Width, 2) + Math.Pow(bounds.Size.Height, 2)) / 3.0f;
ctx.SaveState();
// draw outline circle with 1 pt black shadow
ctx.AddArc(center.X, center.Y, maxRadius, 0, (float)(Math.PI * 2), true);
CGSize offset = new CGSize(0, 1);
CGColor shadowColor = UIColor.Black.CGColor;
ctx.SetShadow(offset, 2, shadowColor);
ctx.DrawPath(CGPathDrawingMode.Stroke);
// clear shadow
ctx.RestoreState();
// set clipping circle
ctx.AddArc(center.X, center.Y, maxRadius, 0, (float)(Math.PI * 2), true);
ctx.Clip();
// Draw the image in the circle
image.Draw(bounds);
CGColorSpace colorSpace = CGColorSpace.CreateDeviceRGB();
nfloat[] components = new nfloat[8] {
0.8f, 0.8f, 1, 1, 0.8f, 0.8f, 1, 0
};
nfloat[] locations = new nfloat[2] {
0.0f, 1
};
CGGradient gradient = new CGGradient(colorSpace, components, locations);
ctx.DrawLinearGradient(gradient, new CGPoint(bounds.Width / 2, 0), new CGPoint(bounds.Width / 2, bounds.Height / 2), 0);
}
public void draw(CGContext context)
{
double radius = Math.Sqrt(Math.Pow((this.center.X - this.point2.X) / 2, 2) + Math.Pow((this.center.Y - this.point2.Y) / 2, 2));
context.AddArc(this.center.X, this.center.Y, (float)radius, 0.0f, (float)Math.PI * 2, true);
_color.SetStroke();
context.StrokePath();
}
protected virtual void HandleShapeDraw(CGContext currentContext, RectangleF rect)
{
var centerX = rect.X + (rect.Width / 2);
var centerY = rect.Y + (rect.Height / 2);
var radius = rect.Width / 2;
var startAngle = 0;
var endAngle = (float)(Math.PI * 2);
HandleStandardDraw(currentContext, rect, () => currentContext.AddArc(centerX, centerY, radius, startAngle, endAngle, true));
}
private void DrawCurrentTouch(CGContext ctx)
{
if (mCurrTouch == PointF.Empty)
{
return;
}
var parentDIV = (DrawingImageView)Superview;
var grandParentDISV = (DrawingImageScrollView)parentDIV.Superview;
var zoomScale = grandParentDISV.ZoomScale;
// circle
try
{
ctx.SaveState();
ctx.BeginPath();
ctx.SetStrokeColorWithColor(LineColor);
ctx.SetLineWidth(9f / zoomScale);
var rad = CurrentTouchRadius / zoomScale;
ctx.AddArc(mCurrTouch.X, mCurrTouch.Y, rad, 0.0f, 2.0f * (float)Math.PI, true);
}
finally
{
ctx.StrokePath();
ctx.RestoreState();
}
// crosshairs
try
{
ctx.SaveState();
ctx.BeginPath();
ctx.SetStrokeColorWithColor(LineColor);
ctx.SetLineWidth(1f / zoomScale);
// horizontal line
ctx.MoveTo(0f, mCurrTouch.Y);
ctx.AddLineToPoint(Frame.Right, mCurrTouch.Y);
// vertical line
ctx.MoveTo(mCurrTouch.X, 0f);
ctx.AddLineToPoint(mCurrTouch.X, Frame.Bottom);
}
finally
{
ctx.StrokePath();
ctx.RestoreState();
}
}
private nfloat MakePath(CGContext context, CGRect rect)
{
var radius = rect.Bottom * this._cornerRoundness;
var puffer = rect.Bottom * 0.12f;
var maxX = rect.Right - (puffer * 2f);
var maxY = rect.Bottom - puffer;
var minX = rect.Left + (puffer * 2f);
var minY = rect.Top + puffer;
if (maxX - minX < 20f)
{
maxX = rect.Right - puffer;
minX = rect.Left + puffer;
}
context.AddArc(maxX - radius, minY + radius, radius, (float)(Math.PI + (Math.PI / 2)), 0f, false);
context.AddArc(maxX - radius, maxY - radius, radius, 0, (float)(Math.PI / 2), false);
context.AddArc(minX + radius, maxY - radius, radius, (float)(Math.PI / 2), (float)Math.PI, false);
context.AddArc(minX + radius, minY + radius, radius, (float)Math.PI, (float)(Math.PI + Math.PI / 2), false);
return(maxY);
}
public static void AddRoundedRect(this CGContext c, RectangleF b, float r)
{
var x = b.X;
var y = b.Y;
var w = b.Width;
var h = b.Height;
if (w < 0)
{
x += w;
w = Math.Abs(w);
}
if (h < 0)
{
y += h;
h = Math.Abs(h);
}
var ri = x + w;
var bo = y + h;
c.MoveTo(x, y + r);
c.AddLineToPoint(x, bo - r);
c.AddArc(x + r, bo - r, r, (float)(Math.PI), (float)(Math.PI / 2), true);
c.AddLineToPoint(ri - r, bo);
c.AddArc(ri - r, bo - r, r, (float)(-3 * Math.PI / 2), (float)(0), true);
c.AddLineToPoint(ri, y + r);
c.AddArc(ri - r, y + r, r, (float)(0), (float)(-Math.PI / 2), true);
c.AddLineToPoint(x + r, y);
c.AddArc(x + r, y + r, r, (float)(-Math.PI / 2), (float)(Math.PI), true);
}
private void DrawCircles(CGContext ctx, int x, int y)
{
ctx.SetFillColor(new CGColor(ApplicationDefaults.DefaultPipColors
.GetItem <NSArray <NSNumber> >((System.nuint)_pipCount - 1)
.GetItem <NSNumber>(0).FloatValue,
ApplicationDefaults.DefaultPipColors
.GetItem <NSArray <NSNumber> >((System.nuint)_pipCount - 1)
.GetItem <NSNumber>(1).FloatValue,
ApplicationDefaults.DefaultPipColors
.GetItem <NSArray <NSNumber> >((System.nuint)_pipCount - 1)
.GetItem <NSNumber>(2).FloatValue));
ctx.AddArc(x + 50, y + 38, PIP_RADIUS, 0, (float)(2 * Math.PI), true);
ctx.DrawPath(CGPathDrawingMode.Fill);
}
public override void DrawInContext(CGContext ctx)
{
base.DrawInContext(ctx);
var bounds = Bounds;
var c = new PointF(bounds.GetMidX(), bounds.GetMidY());
ctx.BeginPath();
ctx.MoveTo(c.X, c.Y);
ctx.AddLineToPoint(bounds.Right, c.Y);
ctx.AddArc(c.X, c.Y, bounds.Width / 2, (float)0, (float)Angle, false);
ctx.AddLineToPoint(c.X, c.Y);
ctx.SetFillColor(otherColor);
ctx.FillPath();
ctx.BeginPath();
ctx.MoveTo(c.X, c.Y);
ctx.AddLineToPoint(bounds.Right, c.Y);
ctx.AddArc(c.X, c.Y, bounds.Width / 2, (float)0, (float)(1e-7 + Angle), true);
ctx.AddLineToPoint(c.X, c.Y);
ctx.SetFillColor(color);
ctx.FillPath();
}
public override void Draw(CGRect rect)
{
base.Draw(rect);
using (CGContext context = UIGraphics.GetCurrentContext())
{
_circleColor.SetFill();
context.FillEllipseInRect(_circleRect);
_arcColor.SetFill();
context.AddArc(_centerX, _centerY, _radius, _startAngle, _endAngle, true);
context.AddLineToPoint(_centerX, _centerY);
context.FillPath();
}
}
private void _chart_OnDrawCircle(object sender, Charting.Controls.Chart.DrawEventArgs <Events.SingleDrawingData> e)
{
using (CGContext g = UIGraphics.GetCurrentContext())
{
g.SetLineWidth(2);
Colors[e.Data.SeriesNo].SetFill();
Colors[e.Data.SeriesNo].SetStroke();
float startAngle = -((float)Math.PI / 2);
float endAngle = ((2 * (float)Math.PI) + startAngle);
g.AddArc((float)e.Data.X, (float)e.Data.Y, (float)e.Data.Size, startAngle, endAngle, true);
g.DrawPath(CGPathDrawingMode.FillStroke);
}
}
public override void DrawLayer(CALayer layer, CGContext context)
{
var radius = (float)FormsButton.WidthRequest / 2;
var offset = BorderThickness / 2;
float angle = (FormsButton.Completion + .75f) * 2 * (float)Math.PI;
context.AddEllipseInRect(CGRect.FromLTRB(offset, offset, (float)FormsButton.WidthRequest - offset, (float)FormsButton.HeightRequest - offset));
context.SetStrokeColor(UIColor.White.CGColor);
context.SetLineWidth(BorderThickness);
context.StrokePath();
context.SetStrokeColor(UIColor.Red.CGColor);
context.AddArc(radius, radius, radius - offset, 1.5f * (float)Math.PI, angle, false);
context.StrokePath();
}
public static void drawUnfilledArcInContext(CGContext ctx, CGPoint center, nfloat radius, nfloat lineWidth, nfloat fromAngleFromNorth, nfloat toAngleFromNorth)
{
var cartesianFromAngle = (nfloat)CompassToCartesian(ConvertToRadians(fromAngleFromNorth));
var cartesianToAngle = (nfloat)CompassToCartesian(ConvertToRadians(toAngleFromNorth));
ctx.AddArc(center.X, // arc start point x
center.Y, // arc start point y
radius, // arc radius from center
cartesianFromAngle, cartesianToAngle,
false); // iOS flips the y coordinate so anti-clockwise (specified here by 0) becomes clockwise (desired)!
ctx.SetLineWidth(lineWidth);
ctx.SetLineCap(CGLineCap.Butt);
ctx.DrawPath(CGPathDrawingMode.Stroke);
}
public override void DrawInContext (CGContext ctx)
{
base.DrawInContext (ctx);
var bounds = Bounds;
var c = new PointF (bounds.GetMidX (), bounds.GetMidY ());
ctx.BeginPath ();
ctx.MoveTo (c.X, c.Y);
ctx.AddLineToPoint (bounds.Right, c.Y);
ctx.AddArc (c.X, c.Y, bounds.Width/2, (float)0, (float)Angle, false);
ctx.AddLineToPoint (c.X, c.Y);
ctx.SetFillColor (otherColor);
ctx.FillPath ();
ctx.BeginPath ();
ctx.MoveTo (c.X, c.Y);
ctx.AddLineToPoint (bounds.Right, c.Y);
ctx.AddArc (c.X, c.Y, bounds.Width/2, (float)0, (float)(1e-7 + Angle), true);
ctx.AddLineToPoint (c.X, c.Y);
ctx.SetFillColor (color);
ctx.FillPath ();
}
public static void RoundRectPath(CGContext cr, CGRect rect, float[] cornerRadii)
{
if (cornerRadii == null || cornerRadii.Length != 4)
{
throw new ArgumentOutOfRangeException("cornerRadii", "cornerRadii count must be 4.");
}
cr.BeginPath();
float radius = cornerRadii[0];
cr.AddArc(rect.X + radius, rect.Y + radius, radius, (float)Math.PI, (float)(3.0f * Math.PI / 2.0f), false);
radius = cornerRadii[1];
cr.AddArc(rect.X + rect.Width - radius, rect.Y + radius, radius, (float)(3.0f * Math.PI / 2.0f), 2.0f * (float)Math.PI, false);
radius = cornerRadii[2];
cr.AddArc(rect.X + rect.Width - radius, rect.Y + rect.Height - radius, radius, (float)(2 * Math.PI), 5.0f * ((float)Math.PI / 2.0f), false);
radius = cornerRadii[3];
cr.AddArc(rect.X + radius, rect.Y + rect.Height - radius, radius, (float)(5.0f * Math.PI / 2.0f), (float)(3.0f * Math.PI), false);
cr.ClosePath();
}
private void _chart_OnDrawPie(object sender, Charting.Controls.Chart.DrawEventArgs <Events.PieDrawingData> e)
{
double totalDegrees = 0;
for (int i = 0; i < e.Data.Percentages.Length; i++)
{
double degrees = e.Data.Percentages[i];
using (CGContext g = UIGraphics.GetCurrentContext())
{
g.SetLineWidth(2);
Colors[i].SetFill();
Colors[i].SetStroke();
g.AddArc((float)e.Data.X, (float)e.Data.Y, (float)e.Data.Size, (float)(Math.PI / 180 * totalDegrees), (float)(Math.PI / 180 * degrees), true);
g.DrawPath(CGPathDrawingMode.FillStroke);
}
totalDegrees += degrees;
}
}
public override void Draw(CGRect rect)
{
base.Draw(rect);
CGContext context = UIGraphics.GetCurrentContext();
CGRect bounds = rect;
CGPoint center = new CGPoint();
center.X = (nfloat)(bounds.Size.Width / 2.0);
center.Y = (nfloat)(bounds.Size.Height / 2.0);
context.SaveState();
context.SetFillColor(UIColor.Blue.CGColor);
context.AddArc(center.X, center.Y, _radius, 0, GetRadians(300), false);
context.AddLineToPoint(center.X, center.Y);
context.AddLineToPoint(rect.Width, center.Y);
context.DrawPath(CGPathDrawingMode.Fill);
}
public override void Draw(CGRect rect)
{
base.Draw(rect);
using (CGContext g = UIGraphics.GetCurrentContext()) {
g.SetFillColor((UIColor.FromPatternImage(UIImage.FromBundle(ImageFileName)).CGColor));
if (ScratchViewShape == Shape.Rectangle)
{
g.FillRect(rect);
}
else
{
g.AddArc(rect.Width / 2, rect.Height / 2, rect.Width / 2, 0, (float)Math.PI * 2.0f, true);
g.FillPath();
}
if (!initialPoint.IsEmpty)
{
g.SetLineWidth(20);
g.SetBlendMode(CGBlendMode.Clear);
UIColor.Clear.SetColor();
if (path.IsEmpty || startNewPath)
{
path.AddLines(new CGPoint[] { initialPoint, latestPoint });
startNewPath = false;
}
else
{
path.AddLineToPoint(latestPoint);
}
g.SetLineCap(CGLineCap.Round);
g.AddPath(path);
g.DrawPath(CGPathDrawingMode.Stroke);
}
}
}
private void drawArc(CGContext context, CGRect rect)
{
var radius = rect.GetMaxY() * badgeCornerRoundness;
var puffer = new nfloat(Padding(rect));
var maxX = rect.GetMaxX() - puffer;
var maxY = rect.GetMaxY() - puffer;
var minX = rect.GetMinX() + puffer;
var minY = rect.GetMinY() + puffer;
double pi = Math.PI;
context.AddArc(new nfloat(maxX - radius), new nfloat(minY + radius), new nfloat(radius), new nfloat(pi + (pi / 2)), 0, false);
context.AddArc(new nfloat(maxX - radius), new nfloat(minY - radius), new nfloat(radius), 0, new nfloat(pi / 2), false);
}
public override void Draw(RectangleF rect)
{
float x = 105;
float y = 105;
float r = 100;
float twopi = (2f * (float)Math.PI) * -1f;
CGContext ctx = UIGraphics.GetCurrentContext();
//base circle
UIColor.FromRGB(137, 136, 133).SetColor();
ctx.AddArc(x, y, r + 3, 0, twopi, true);
ctx.FillPath();
//border circle
UIColor.FromRGB(231, 231, 231).SetColor();
ctx.AddArc(x, y, r, 0, twopi, true);
ctx.FillPath();
//Center circle
UIColor.White.SetColor();
ctx.AddArc(x, y, r / 1.2f, 0, twopi, true);
ctx.FillPath();
UIColor.Black.SetFill();
//Slow
SizeF stringSize = StringSize("Fast", font10);
DrawString("Fast", new PointF(105 - r + 7, 105 + r / 2 - 28), stringSize.Width, font10, UILineBreakMode.TailTruncation);
//fast
stringSize = StringSize("Slow", font10);
DrawString("Slow", new PointF(105 + r - 25, 105 - r / 2 + 20), stringSize.Width, font10, UILineBreakMode.TailTruncation);
//pubnub
UIColor.Red.SetFill();
stringSize = StringSize("PubNub", font18b);
DrawString("PubNub", new PointF((r * 2 - stringSize.Width) / 2 + 5, y - r / 2f), stringSize.Width, font18b, UILineBreakMode.TailTruncation);
//needle
//double percentFromMaxValue = max / 100.0d;
max = 1000;
double percentFromMaxValue = max / 100.0d;
if (lag > max)
{
lag = max;
}
//angle
double invertLag = ((max - min) / 2 - lag) * 2 + lag;
//Debug.WriteLine("lag: "+ lag.ToString() + " invlag:" + invLag.ToString());
double angle = 360 - Math.Round((double)invertLag / percentFromMaxValue * (90 / 100.0f)) * Math.PI / 180.0;
//double angle2 = 360 - Math.Round((double)lag / percentFromMaxValue* (90 / 100.0f)) * Math.PI / 180.0;;
//Debug.WriteLine("lagangle: "+ angle.ToString() + " invLagangle" + angle2.ToString());
//double angle = WrapValue(lag, max);
float distance = 80;
PointF p = new PointF(distance * (float)Math.Cos(angle), distance * (float)Math.Sin(angle));
UIColor.Brown.SetStroke();
CGPath path1 = new CGPath();
ctx.SetLineWidth(3);
PointF newPoint = new PointF(105 - p.X, 105 - p.Y);
PointF[] linePoints = new PointF[] {
newPoint,
new PointF(105, 105)
};
path1.AddLines(linePoints);
path1.CloseSubpath();
ctx.AddPath(path1);
ctx.DrawPath(CGPathDrawingMode.FillStroke);
//caliberate
UIColor.Brown.SetColor();
double theta = 0.0;
for (int i = 0; i < 360; i++)
{
float bx4 = (float)(x - 4 + (r - 10) * (Math.Cos(theta * Math.PI / 180)));
float by4 = (float)(y - 15 + (r - 10) * (Math.Sin(theta * Math.PI / 180)));
if ((theta > 160) && (theta < 350))
{
UIColor.Black.SetColor();
DrawString(".", new PointF(bx4, by4), StringSize(".", font18b).Width, font18b, UILineBreakMode.TailTruncation);
}
else if (((theta >= 0) && (theta < 40)) || ((theta >= 350) && (theta <= 360)))
{
//redline
UIColor.Red.SetColor();
DrawString(".", new PointF(bx4, by4), StringSize(".", font18b).Width, font18b, UILineBreakMode.TailTruncation);
}
theta += 10.0;
}
//small circle
UIColor.FromRGB(220, 214, 194).SetColor();
//ctx.AddArc (x, y+y*.33f, r/1.5f, 0, twopi, true );
ctx.AddArc(x, y + r / 2f, r / 2f, 0, twopi, true);
ctx.FillPath();
//speed in small circle
UIColor.Black.SetFill();
stringSize = StringSize(Convert.ToInt32(lag).ToString(), font18b);
DrawString(Convert.ToInt32(lag).ToString(), new PointF((r * 2 - stringSize.Width) / 2 + 4, y + r / 2f - 15), stringSize.Width, font18b, UILineBreakMode.TailTruncation);
//ms
UIColor.Black.SetFill();
stringSize = StringSize("MS", font18b);
DrawString("MS", new PointF((r - stringSize.Width) / 2 + 55, y + r / 2f + 10), stringSize.Width, font18b, UILineBreakMode.TailTruncation);
}
void FillRoundedRect (RectangleF rect, CGContext context)
{
float radius = 10.0f;
context.BeginPath ();
context.SetGrayFillColor (0.0f, this.Opacity);
context.MoveTo (rect.GetMinX () + radius, rect.GetMinY ());
context.AddArc (rect.GetMaxX () - radius, rect.GetMinY () + radius, radius, (float)(3 * Math.PI / 2), 0f, false);
context.AddArc (rect.GetMaxX () - radius, rect.GetMaxY () - radius, radius, 0, (float)(Math.PI / 2), false);
context.AddArc (rect.GetMinX () + radius, rect.GetMaxY () - radius, radius, (float)(Math.PI / 2), (float)Math.PI, false);
context.AddArc (rect.GetMinX () + radius, rect.GetMinY () + radius, radius, (float)Math.PI, (float)(3 * Math.PI / 2), false);
context.ClosePath ();
context.FillPath ();
}
public static void drawUnfilledArcInContext(CGContext ctx, CGPoint center, nfloat radius, nfloat lineWidth, nfloat fromAngleFromNorth, nfloat toAngleFromNorth)
{
var cartesianFromAngle = (nfloat)CompassToCartesian(ConvertToRadians(fromAngleFromNorth));
var cartesianToAngle = (nfloat)CompassToCartesian(ConvertToRadians(toAngleFromNorth));
ctx.AddArc(center.X, // arc start point x
center.Y, // arc start point y
radius, // arc radius from center
cartesianFromAngle, cartesianToAngle,
false); // iOS flips the y coordinate so anti-clockwise (specified here by 0) becomes clockwise (desired)!
ctx.SetLineWidth(lineWidth);
ctx.SetLineCap(CGLineCap.Butt);
ctx.DrawPath(CGPathDrawingMode.Stroke);
}
public void draw(CGContext context)
{
double radius = Math.Sqrt(Math.Pow((this.center.X - this.point2.X)/2, 2) + Math.Pow((this.center.Y - this.point2.Y)/2, 2));
context.AddArc(this.center.X, this.center.Y, (float)radius, 0.0f, (float)Math.PI * 2, true);
_color.SetStroke();
context.StrokePath();
}
public void DrawPath(IEnumerable <PathOp> ops, Pen pen = null, Brush brush = null)
{
if (pen == null && brush == null)
{
return;
}
DrawElement(() => {
var bb = new BoundingBoxBuilder();
foreach (var op in ops)
{
var mt = op as MoveTo;
if (mt != null)
{
var p = mt.Point;
if (!IsValid(p.X) || !IsValid(p.Y))
{
continue;
}
context.MoveTo((nfloat)p.X, (nfloat)p.Y);
bb.Add(p);
continue;
}
var lt = op as LineTo;
if (lt != null)
{
var p = lt.Point;
if (!IsValid(p.X) || !IsValid(p.Y))
{
continue;
}
context.AddLineToPoint((nfloat)p.X, (nfloat)p.Y);
bb.Add(p);
continue;
}
var at = op as ArcTo;
if (at != null)
{
var p = at.Point;
if (!IsValid(p.X) || !IsValid(p.Y))
{
continue;
}
var pp = Conversions.GetPoint(context.GetPathCurrentPoint());
if (pp == p)
{
continue;
}
Point c1, c2;
at.GetCircles(pp, out c1, out c2);
var circleCenter = (at.LargeArc ^ at.SweepClockwise) ? c1 : c2;
var startAngle = (float)Math.Atan2(pp.Y - circleCenter.Y, pp.X - circleCenter.X);
var endAngle = (float)Math.Atan2(p.Y - circleCenter.Y, p.X - circleCenter.X);
if (!IsValid(circleCenter.X) || !IsValid(circleCenter.Y) || !IsValid(startAngle) || !IsValid(endAngle))
{
context.MoveTo((nfloat)p.X, (nfloat)p.Y);
continue;
}
var clockwise = !at.SweepClockwise;
context.AddArc((nfloat)circleCenter.X, (nfloat)circleCenter.Y, (nfloat)at.Radius.Min, startAngle, endAngle, clockwise);
bb.Add(p);
continue;
}
var ct = op as CurveTo;
if (ct != null)
{
var p = ct.Point;
if (!IsValid(p.X) || !IsValid(p.Y))
{
continue;
}
var c1 = ct.Control1;
var c2 = ct.Control2;
if (!IsValid(c1.X) || !IsValid(c1.Y) || !IsValid(c2.X) || !IsValid(c2.Y))
{
context.MoveTo((nfloat)p.X, (nfloat)p.Y);
continue;
}
context.AddCurveToPoint((nfloat)c1.X, (nfloat)c1.Y, (nfloat)c2.X, (nfloat)c2.Y, (nfloat)p.X, (nfloat)p.Y);
bb.Add(p);
bb.Add(c1);
bb.Add(c2);
continue;
}
var cp = op as ClosePath;
if (cp != null)
{
context.ClosePath();
continue;
}
throw new NotSupportedException("Path Op " + op);
}
return(bb.BoundingBox);
}, pen, brush);
}
public override void DrawInContext (CGContext context)
{
// Drawing with a white stroke color
context.SetStrokeColor (1, 1, 1, 1);
// And draw with a blue fill color
context.SetFillColor (0, 0, 1, 1);
// Draw them with a 2 stroke width so they are a bit more visible.
context.SetLineWidth (2);
// Add an ellipse circumscribed in the given rect to the current path, then stroke it
context.AddEllipseInRect (new CGRect (30, 30, 60, 60));
context.StrokePath ();
// Stroke ellipse convenience that is equivalent to AddEllipseInRect(); StrokePath();
context.StrokeEllipseInRect (new CGRect (30, 120, 60, 60));
// Fill rect convenience equivalent to AddEllipseInRect(); FillPath();
context.FillEllipseInRect (new CGRect (30, 210, 60, 60));
// Stroke 2 seperate arcs
context.AddArc (150, 60, 30, 0, (float)Math.PI / 2, false);
context.StrokePath ();
context.AddArc (150, 60, 30, (float)(3 * Math.PI / 2), (float)Math.PI, true);
context.StrokePath ();
// Stroke 2 arcs together going opposite directions.
context.AddArc (150, 150, 30, 0, (float)Math.PI / 2, false);
context.AddArc (150, 150, 30, (float)(3 * Math.PI / 2), (float)Math.PI, true);
context.StrokePath ();
// Stroke 2 arcs together going the same direction..
context.AddArc (150, 240, 30, 0, (float)(Math.PI / 2), false);
context.AddArc (150, 240, 30, (float)Math.PI, (float)(3 * Math.PI / 2), false);
context.StrokePath ();
// Stroke an arc using AddArcToPoint
CGPoint[] p = {
new CGPoint (210, 30),
new CGPoint (210, 60),
new CGPoint (240, 60),
};
context.MoveTo (p [0].X, p [0].Y);
context.AddArcToPoint (p [1].X, p [1].Y, p [2].X, p [2].Y, 30);
context.StrokePath ();
// Show the two segments that are used to determine the tangent lines to draw the arc.
context.SetStrokeColor (1, 0, 0, 1);
context.AddLines (p);
context.StrokePath ();
// As a bonus, we'll combine arcs to create a round rectangle!
// Drawing with a white stroke color
context.SetStrokeColor (1, 1, 1, 1);
// If you were making this as a routine, you would probably accept a rectangle
// that defines its bounds, and a radius reflecting the "rounded-ness" of the rectangle.
var rrect = new CGRect (210, 90, 60, 60);
var radius = 10;
// NOTE: At this point you may want to verify that your radius is no more than half
// the width and height of your rectangle, as this technique degenerates for those cases.
// In order to draw a rounded rectangle, we will take advantage of the fact that
// context.AddArcToPoint will draw straight lines past the start and end of the arc
// in order to create the path from the current position and the destination position.
// In order to create the 4 arcs correctly, we need to know the min, mid and max positions
// on the x and y lengths of the given rectangle.
nfloat minx = rrect.X, midx = rrect.X + rrect.Width / 2, maxx = rrect.X + rrect.Width;
nfloat miny = rrect.Y, midy = rrect.Y + rrect.Height / 2, maxy = rrect.Y + rrect.Height;
// Next, we will go around the rectangle in the order given by the figure below.
// minx midx maxx
// miny 2 3 4
// midy 1 9 5
// maxy 8 7 6
// Which gives us a coincident start and end point, which is incidental to this technique, but still doesn't
// form a closed path, so we still need to close the path to connect the ends correctly.
// Thus we start by moving to point 1, then adding arcs through each pair of points that follows.
// You could use a similar tecgnique to create any shape with rounded corners.
// Start at 1
context.MoveTo (minx, midy);
// Add an arc through 2 to 3
context.AddArcToPoint (minx, miny, midx, miny, radius);
// Add an arc through 4 to 5
context.AddArcToPoint (maxx, miny, maxx, midy, radius);
// Add an arc through 6 to 7
context.AddArcToPoint (maxx, maxy, midx, maxy, radius);
// Add an arc through 8 to 9
context.AddArcToPoint (minx, maxy, minx, midy, radius);
// Close the path
context.ClosePath ();
// Fill & stroke the path
context.DrawPath (CGPathDrawingMode.FillStroke);
}
void DrawArcInContext(CGContext context, PointF center, float radius, float startAngle, float endAngle, CGColor color, bool cgClockwise)
{
context.BeginPath();
context.MoveTo(center.X, center.Y);
context.AddArc(center.X, center.Y, radius, startAngle, endAngle, cgClockwise);
context.SetFillColor(color);
context.FillPath();
}
public override void ArcNegative(object backend, double xc, double yc, double radius, double angle1, double angle2)
{
CGContext ctx = ((CGContextBackend)backend).Context;
ctx.AddArc((float)xc, (float)yc, (float)radius, (float)(angle1 * degrees), (float)(angle2 * degrees), true);
}
public override void DrawRect(CGRect dirtyRect)
{
// Don't draw if we don't have a font or a title.
if (Font == null || Title == string.Empty)
{
return;
}
// Initialize the text matrix to a known value
CGContext context = NSGraphicsContext.CurrentContext.GraphicsPort;
context.TextMatrix = CGAffineTransform.MakeIdentity();
// Draw a white background
NSColor.White.Set();
context.FillRect(dirtyRect);
CTLine line = new CTLine(AttributedString);
int glyphCount = (int)line.GlyphCount;
if (glyphCount == 0)
{
return;
}
GlyphArcInfo[] glyphArcInfo = new GlyphArcInfo[glyphCount];
PrepareGlyphArcInfo(line, glyphCount, glyphArcInfo);
// Move the origin from the lower left of the view nearer to its center.
context.SaveState();
context.TranslateCTM(dirtyRect.GetMidX(), dirtyRect.GetMidY() - Radius / 2);
// Stroke the arc in red for verification.
context.BeginPath();
context.AddArc(0, 0, Radius, (float)Math.PI, 0, true);
context.SetStrokeColor(1, 0, 0, 1);
context.StrokePath();
// Rotate the context 90 degrees counterclockwise.
context.RotateCTM((float)PI_2);
/*
* Now for the actual drawing. The angle offset for each glyph relative to the previous
* glyph has already been calculated; with that information in hand, draw those glyphs
* overstruck and centered over one another, making sure to rotate the context after each
* glyph so the glyphs are spread along a semicircular path.
*/
CGPoint textPosition = new CGPoint(0, Radius);
context.TextPosition = textPosition;
var runArray = line.GetGlyphRuns();
var runCount = runArray.Count();
var glyphOffset = 0;
var runIndex = 0;
for (; runIndex < runCount; runIndex++)
{
var run = runArray [runIndex];
var runGlyphCount = run.GlyphCount;
bool drawSubstitutedGlyphsManually = false;
CTFont runFont = run.GetAttributes().Font;
// Determine if we need to draw substituted glyphs manually. Do so if the runFont is not
// the same as the overall font.
var description = NSFontDescriptor.FromNameSize(runFont.FamilyName, runFont.Size);
NSFont rrunFont = NSFont.FromDescription(description, runFont.Size);
// used for comparison
if (DimsSubstitutedGlyphs && Font != rrunFont)
{
drawSubstitutedGlyphsManually = true;
}
var runGlyphIndex = 0;
for (; runGlyphIndex < runGlyphCount; runGlyphIndex++)
{
var glyphRange = new NSRange(runGlyphIndex, 1);
context.RotateCTM(-(glyphArcInfo [runGlyphIndex + glyphOffset].angle));
// Center this glyph by moving left by half its width.
var glyphWidth = glyphArcInfo [runGlyphIndex + glyphOffset].width;
var halfGlyphWidth = glyphWidth / 2.0;
var positionForThisGlyph = new CGPoint(textPosition.X - (float)halfGlyphWidth, textPosition.Y);
// Glyphs are positioned relative to the text position for the line, so offset text position leftwards by this glyph's
// width in preparation for the next glyph.
textPosition.X -= glyphWidth;
CGAffineTransform textMatrix = run.TextMatrix;
textMatrix.x0 = positionForThisGlyph.X;
textMatrix.y0 = positionForThisGlyph.Y;
context.TextMatrix = textMatrix;
if (!drawSubstitutedGlyphsManually)
{
run.Draw(context, glyphRange);
}
else
{
// We need to draw the glyphs manually in this case because we are effectively applying a graphics operation by
// setting the context fill color. Normally we would use kCTForegroundColorAttributeName, but this does not apply
// as we don't know the ranges for the colors in advance, and we wanted demonstrate how to manually draw.
var cgFont = runFont.ToCGFont();
var glyph = run.GetGlyphs(glyphRange);
var position = run.GetPositions(glyphRange);
context.SetFont(cgFont);
context.SetFontSize(runFont.Size);
context.SetFillColor(0.25f, 0.25f, 0.25f, 1);
context.ShowGlyphsAtPositions(glyph, position, 1);
}
// Draw the glyph bounds
if (ShowsGlyphBounds)
{
var glyphBounds = run.GetImageBounds(context, glyphRange);
context.SetStrokeColor(0, 0, 1, 1);
context.StrokeRect(glyphBounds);
}
// Draw the bounding boxes defined by the line metrics
if (ShowsLineMetrics)
{
var lineMetrics = new CGRect();
nfloat ascent = 0;
nfloat descent = 0;
nfloat leading = 0;
run.GetTypographicBounds(glyphRange, out ascent, out descent, out leading);
// The glyph is centered around the y-axis
lineMetrics.Location = new CGPoint(-(float)halfGlyphWidth, positionForThisGlyph.Y - descent);
lineMetrics.Size = new CGSize(glyphWidth, ascent + descent);
context.SetStrokeColor(0, 1, 0, 1);
context.StrokeRect(lineMetrics);
}
}
glyphOffset += (int)runGlyphCount;
}
context.RestoreState();
}
void drawSlicesSeparators(CGContext contextRef, SizeF viewSize, PointF center)
{
int outerDiameter = (int)Math.Min(viewSize.Width, viewSize.Height);
double outerRadius = outerDiameter / 2.0 - internalPadding;
int innerDiameter = (int)(outerDiameter - Theme.Thickness);
double innerRadius = innerDiameter / 2.0;
int sliceCount = (int)ProgressTotal;
double sliceAngle = (2 * M_PI) / sliceCount;
contextRef.SetLineWidth(Theme.SliceDividerThickness);
contextRef.SetStrokeColor(Theme.SliceDividerColor.CGColor);
contextRef.MoveTo(center.X, center.Y);
for (int i = 0; i < sliceCount; i++) {
contextRef.BeginPath();
double startAngle = sliceAngle * i - M_PI_2;
double endAngle = sliceAngle * (i + 1) - M_PI_2;
contextRef.AddArc(center.X, center.Y, (float)outerRadius, (float)startAngle, (float)endAngle, false);
contextRef.AddArc(center.X, center.Y, (float)innerRadius, (float)endAngle, (float)startAngle, true);
contextRef.StrokePath();
}
}
void drawSlicesWithRadius(float radius, PointF center, CGContext contextRef)
{
bool cgClockwise = !Clockwise;
uint startingSlice = StartingSlice - 1;
if (ProgressCounter == 0 && Theme.DrawIncompleteArcIfNoProgress)
{
DrawArcInContext(contextRef, center, radius, 0, M_PI * 2, Theme.IncompletedColor.CGColor, cgClockwise);
return;
}
if (!Theme.SliceDividerHidden && Theme.SliceDividerThickness > 0)
{
float sliceAngle = (2 * M_PI) / ProgressTotal;
for (int i =0; i < ProgressTotal; i++) {
float startValue = (sliceAngle * i) + sliceAngle * startingSlice;
float startAngle, endAngle;
if (Clockwise)
{
startAngle = -M_PI_2 + startValue;
endAngle = startAngle + sliceAngle;
}
else
{
startAngle = -M_PI_2 - startValue;
endAngle = startAngle - sliceAngle;
}
contextRef.BeginPath();
contextRef.MoveTo(center.X, center.Y);
contextRef.AddArc(center.X, center.Y, radius, startAngle, endAngle, cgClockwise);
CGColor color = Theme.IncompletedColor.CGColor;
if (i < ProgressCounter)
{
color = Theme.CompletedColor.CGColor;
}
contextRef.SetFillColor(color);
contextRef.FillPath();
}
}
else
{
double originAngle, endAngle;
double sliceAngle = (2 * M_PI) / ProgressTotal;
double startingAngle = sliceAngle * startingSlice;
double progressAngle = sliceAngle * ProgressCounter;
if (Clockwise) {
originAngle = - M_PI_2 + startingAngle;
endAngle = originAngle + progressAngle;
} else {
originAngle = - M_PI_2 - startingAngle;
endAngle = originAngle - progressAngle;
}
DrawArcInContext(contextRef, center, radius, (float)originAngle, (float)endAngle, Theme.CompletedColor.CGColor, cgClockwise);
if (ProgressCounter < ProgressTotal)
{
DrawArcInContext(contextRef, center, radius, (float)endAngle, (float)originAngle, Theme.IncompletedColor.CGColor, cgClockwise);
}
}
}
private float MakePath(CGContext context, RectangleF rect)
{
var radius = rect.Bottom * this.cornerRoundness;
var puffer = rect.Bottom * 0.12f;
var maxX = rect.Right - (puffer * 2f);
var maxY = rect.Bottom - puffer;
var minX = rect.Left + (puffer * 2f);
var minY = rect.Top + puffer;
if (maxX - minX < 20f) {
maxX = rect.Right - puffer;
minX = rect.Left + puffer;
}
context.AddArc (maxX - radius, minY + radius, radius, (float)(Math.PI + (Math.PI / 2)), 0f, false);
context.AddArc (maxX - radius, maxY - radius, radius, 0, (float)(Math.PI / 2), false);
context.AddArc (minX + radius, maxY - radius, radius, (float)(Math.PI / 2), (float)Math.PI, false);
context.AddArc (minX + radius, minY + radius, radius, (float)Math.PI, (float)(Math.PI + Math.PI / 2), false);
return maxY;
}
