public void RoundedRectangle(Rectangle rectangle, double cornerRadius)
{
if (Filling)
{
// adjust corner radius if we do stroke afterwards.
var filledCornerRadius = Stroking
? Math.Max(0, cornerRadius - _state.StrokeWeight / 2)
: cornerRadius;
var roundedRect = new RoundedRect
{
Rect = fillRect(rectangle),
RadiusX = filledCornerRadius.import(),
RadiusY = filledCornerRadius.import()
};
_target.FillRoundedRectangle(roundedRect, _fillBrush.Brush);
}
if (Stroking)
{
var roundedRect = new RoundedRect
{
Rect = strokeAlignedRect(rectangle),
RadiusX = cornerRadius.import(),
RadiusY = cornerRadius.import()
};
_target.DrawRoundedRectangle(roundedRect, _strokeBrush.Brush, StrokeWeight);
}
}
RectangleF fillRect(Rectangle rectangle)
{
if (!Stroking)
{
return(new RectangleF(rectangle.X.import(), rectangle.Y.import(), rectangle.Right.import(), rectangle.Bottom.import()));
}
return(_state.StrokeFillBounds(rectangle).import());
}
public void Arc(Rectangle rectangle, double start, double stop)
{
if (Stroking)
{
var r = strokeAlignedRect(rectangle);
var currentPoint = ArcGeometry.pointOn(r, start);
drawOpenPath(currentPoint, sink => ArcGeometry.add(r, start, stop, sink));
}
}
public void Rectangle(Rectangle rectangle)
{
if (Filling)
{
var r = fillRect(rectangle);
_target.FillRectangle(r, _fillBrush.Brush);
}
if (Stroking)
{
var r = strokeAlignedRect(rectangle);
_target.DrawRectangle(r, _strokeBrush.Brush, StrokeWeight);
}
}
public void Ellipse(Rectangle rectangle)
{
if (Filling)
{
var r = fillRect(rectangle);
var ellipse = new Ellipse(Import.Point(r.Left + r.Width / 2, r.Top + r.Height / 2), r.Width / 2, r.Height / 2);
_target.FillEllipse(ellipse, _fillBrush.Brush);
}
if (Stroking)
{
var r = strokeAlignedRect(rectangle);
var ellipse = new Ellipse(Import.Point(r.Left + r.Width / 2, r.Top + r.Height / 2), r.Width / 2, r.Height / 2);
_target.DrawEllipse(ellipse, _strokeBrush.Brush, StrokeWeight);
}
}
public static RectangleF Rectangle(Rectangle r)
{
return(new RectangleF(r.X.import(), r.Y.import(), r.Right.import(), r.Bottom.import()));
}
public void Arc(Rectangle rectangle, double start, double stop)
{
if (Stroking)
{
var r = strokeAlignedRect(rectangle);
var currentPoint = ArcGeometry.pointOn(r, start);
drawOpenPath(currentPoint, sink => ArcGeometry.add(r, start, stop, sink));
}
}
RectangleF strokeAlignedRect(Rectangle rectangle)
{
return _state.StrokeAlignedBounds(rectangle).import();
}
RectangleF fillRect(Rectangle rectangle)
{
if (!Stroking)
{
return new RectangleF(rectangle.X.import(), rectangle.Y.import(), rectangle.Width.import(), rectangle.Height.import());
}
return _state.StrokeFillBounds(rectangle).import();
}
public void RoundedRectangle(Rectangle rectangle, Size cornerRadius)
{
if (Filling)
{
// adjust corner radius if we do stroke afterwards.
var filledCornerRadiusX = Stroking
? Math.Max(0, cornerRadius.Width - _state.StrokeWeight/2)
: cornerRadius.Width;
var filledCornerRadiusY = Stroking
? Math.Max(0, cornerRadius.Height - _state.StrokeWeight / 2)
: cornerRadius.Height;
var roundedRect = new RoundedRectangle
{
Rect = fillRect(rectangle),
RadiusX = filledCornerRadiusX.import(),
RadiusY = filledCornerRadiusY.import()
};
_target.FillRoundedRectangle(roundedRect, _fillBrush.Brush);
}
if (Stroking)
{
var roundedRect = new RoundedRectangle
{
Rect = strokeAlignedRect(rectangle),
RadiusX = cornerRadius.Width.import(),
RadiusY = cornerRadius.Height.import()
};
_target.DrawRoundedRectangle(roundedRect, _strokeBrush.Brush, StrokeWeight);
}
}
public void Rectangle(Rectangle rectangle)
{
if (Filling)
{
var r = fillRect(rectangle);
_target.FillRectangle(r, _fillBrush.Brush);
}
if (Stroking)
{
var r = strokeAlignedRect(rectangle);
_target.DrawRectangle(r, _strokeBrush.Brush, StrokeWeight);
}
}
public void Ellipse(Rectangle rectangle)
{
if (Filling)
{
var r = fillRect(rectangle);
var ellipse = new Ellipse(Import.Point(r.Left + r.Width/2, r.Top + r.Height/2), r.Width/2, r.Height/2);
_target.FillEllipse(ellipse, _fillBrush.Brush);
}
if (Stroking)
{
var r = strokeAlignedRect(rectangle);
var ellipse = new Ellipse(Import.Point(r.Left + r.Width / 2, r.Top + r.Height / 2), r.Width / 2, r.Height / 2);
_target.DrawEllipse(ellipse, _strokeBrush.Brush, StrokeWeight);
}
}
RectangleF strokeAlignedRect(Rectangle rectangle)
{
return(_state.StrokeAlignedBounds(rectangle).import());
}
public static RectangleF Rectangle(Rectangle r)
{
return new RectangleF(r.X.import(), r.Y.import(), r.Width.import(), r.Height.import());
}
