private void DrawBox(CGContext context, CGRect trect, float fRadius)
{
float fWidth = (float)trect.Width;
float fHeight = (float)trect.Height;
if (fRadius > fWidth / 2.0f)
{
fRadius = fWidth / 2.0f;
}
if (fRadius > fHeight / 2.0f)
{
fRadius = fHeight / 2.0f;
}
float fMinX = (float)trect.GetMinX();
float fMidX = (float)trect.GetMidX();
float fMaxX = (float)trect.GetMaxX();
float fMinY = (float)trect.GetMinY();
float fMidY = (float)trect.GetMidY();
float fMaxY = (float)trect.GetMaxY();
context.MoveTo(fMinX, fMidY);
context.AddArcToPoint(fMinX, fMinY, fMidX / 2, fMinY, fRadius);
context.AddLineToPoint(fMidX - 5, fMinY);
context.AddLineToPoint(fMidX, fMinY - 5);
context.AddLineToPoint(fMidX + 5, fMinY);
context.AddArcToPoint(fMaxX, fMinY, fMaxX, fMidY, fRadius);
context.AddArcToPoint(fMaxX, fMaxY, fMidX, fMaxY, fRadius);
context.AddArcToPoint(fMinX, fMaxY, fMinX, fMidY, fRadius);
}
public static void AddRoundedRectangle(this CGContext context, float x, float y, float width, float height, float cornerRadius)
{
nfloat actualRadius = cornerRadius;
var rect = new CGRect(x, y, width, height);
if (actualRadius > rect.Width)
{
actualRadius = rect.Width / 2;
}
if (actualRadius > rect.Height)
{
actualRadius = rect.Height / 2;
}
var minX = rect.X;
var minY = rect.Y;
var maxX = minX + rect.Width;
var maxY = minY + rect.Height;
var midX = minX + rect.Width / 2;
var midY = minY + rect.Height / 2;
context.MoveTo(minX, midY);
context.AddArcToPoint(minX, minY, midX, minY, (float)actualRadius);
context.AddArcToPoint(maxX, minY, maxX, midY, (float)actualRadius);
context.AddArcToPoint(maxX, maxY, midX, maxY, (float)actualRadius);
context.AddArcToPoint(minX, maxY, minX, midY, (float)actualRadius);
context.ClosePath();
}
void AddClosedRoundRectanglePath(RectangleF rect, float radius)
{
float minx = rect.Left;
float midx = (rect.Left + rect.Right) / 2f;
float maxx = rect.Right;
float miny = rect.Top;
float midy = (rect.Top + rect.Bottom) / 2f;
float maxy = rect.Bottom;
context.MoveTo(minx, midy);
context.AddArcToPoint(minx, miny, midx, miny, radius);
context.AddArcToPoint(maxx, miny, maxx, midy, radius);
context.AddArcToPoint(maxx, maxy, midx, maxy, radius);
context.AddArcToPoint(minx, maxy, minx, midy, radius);
context.ClosePath();
}
public void SSDrawRoundedRect(CGContext context, RectangleF rect, float cornerRadius)
{
var minx = rect.GetMinX();
var midx = rect.GetMidX();
var maxx = rect.GetMaxX();
var miny = rect.GetMinY();
var midy = rect.GetMidY();
var maxy = rect.GetMaxY();
context.MoveTo(minx, midy);
context.AddArcToPoint(minx, miny, midx, miny, cornerRadius);
context.AddArcToPoint(maxx, miny, maxx, midy, cornerRadius);
context.AddArcToPoint(maxx, maxy, midx, maxy, cornerRadius);
context.AddArcToPoint(minx, maxy, minx, midy, cornerRadius);
context.ClosePath();
context.FillPath();
}
public static void AddRoundedRectToPath(CGContext context, RectangleF rect, float ovalWidth, float ovalHeight)
{
float fw, fh;
if (ovalWidth == 0 || ovalHeight == 0)
{
context.AddRect(rect);
return;
}
context.SaveState();
context.TranslateCTM(rect.GetMinX(), rect.GetMinY());
context.ScaleCTM(ovalWidth, ovalHeight);
fw = rect.Width / ovalWidth;
fh = rect.Height / ovalHeight;
context.MoveTo(fw, fh / 2);
context.AddArcToPoint(fw, fh, fw / 2, fh, 1);
context.AddArcToPoint(0, fh, 0, fh / 2, 1);
context.AddArcToPoint(0, 0, fw / 2, 0, 1);
context.AddArcToPoint(fw, 0, fw, fh / 2, 1);
context.ClosePath();
context.RestoreState();
}
//utility for drawing rectangle shape
public void DrawRectShapeInContext(CGContext ctx, CGRect rect)
{
ctx.SetFillColor(UIColor.FromRGBA(95.0f / 255.0f, 104.0f / 255.0f, 114.0f / 255.0f, 1.0f).CGColor);
ctx.SetStrokeColor(UIColor.FromRGBA(95.0f / 255.0f, 104.0f / 255.0f, 114.0f / 255.0f, 1.0f).CGColor);
ctx.StrokeRect(rect);
ctx.FillRect(rect);
// Add rounded rect over plain rect with 4 pixel below the origin y, so that it will visible only the bottom rounded corners
CGRect cornerRect = new CGRect(rect.X, rect.Y + 4, rect.Width, rect.Height);
nfloat radius = 4;
nfloat minx = cornerRect.GetMinX(), midx = cornerRect.GetMidX(), maxx = cornerRect.GetMaxX();
nfloat miny = cornerRect.GetMinY(), midy = cornerRect.GetMidY(), maxy = cornerRect.GetMaxY();
ctx.SaveState();
ctx.MoveTo(minx, miny);
ctx.AddArcToPoint(minx, miny, midx, miny, radius);
ctx.AddArcToPoint(maxx, miny, maxx, midy, radius);
ctx.AddArcToPoint(maxx, maxy, midx, maxy, radius);
ctx.AddArcToPoint(minx, maxy, minx, midy, radius);
ctx.ClosePath();
ctx.DrawPath(CGPathDrawingMode.FillStroke);
ctx.RestoreState();
}
public static void AddRoundedRectToPath(CGContext context, RectangleF rect, float ovalWidth, float ovalHeight)
{
float fw, fh;
if (ovalWidth == 0 || ovalHeight == 0)
{
context.AddRect(rect);
return;
}
context.SaveState();
context.TranslateCTM(rect.GetMinX(), rect.GetMinY());
context.ScaleCTM(ovalWidth, ovalHeight);
fw = rect.Width / ovalWidth;
fh = rect.Height / ovalHeight;
context.MoveTo(fw, fh / 2);
context.AddArcToPoint(fw, fh, fw / 2, fh, 1);
context.AddArcToPoint(0, fh, 0, fh / 2, 1);
context.AddArcToPoint(0, 0, fw / 2, 0, 1);
context.AddArcToPoint(fw, 0, fw, fh / 2, 1);
context.ClosePath();
context.RestoreState();
}
public void SSDrawRoundedRect(CGContext context, RectangleF rect, float cornerRadius)
{
var minx = rect.GetMinX();
var midx = rect.GetMidX();
var maxx = rect.GetMaxX();
var miny = rect.GetMinY();
var midy = rect.GetMidY();
var maxy = rect.GetMaxY();
context.MoveTo(minx, midy);
context.AddArcToPoint(minx, miny, midx, miny, cornerRadius);
context.AddArcToPoint(maxx, miny, maxx, midy, cornerRadius);
context.AddArcToPoint(maxx, maxy, midx, maxy, cornerRadius);
context.AddArcToPoint(minx, maxy, minx, midy, cornerRadius);
context.ClosePath();
context.FillPath();
}
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);
}
public override void DrawInContext(CGContext context)
{
// Drawing with a white stroke color
context.SetRGBStrokeColor(1, 1, 1, 1);
// And draw with a blue fill color
context.SetRGBFillColor(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 RectangleF(30, 30, 60, 60));
context.StrokePath();
// Stroke ellipse convenience that is equivalent to AddEllipseInRect(); StrokePath();
context.StrokeEllipseInRect(new RectangleF(30, 120, 60, 60));
// Fill rect convenience equivalent to AddEllipseInRect(); FillPath();
context.FillEllipseInRect(new RectangleF(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
PointF [] p =
{
new PointF(210, 30),
new PointF(210, 60),
new PointF(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.SetRGBStrokeColor(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.SetRGBStrokeColor(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 RectangleF(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.
float minx = rrect.X, midx = rrect.X + rrect.Width / 2, maxx = rrect.X + rrect.Width;
float 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);
}
