void DrawFillPath(ICanvas canvas, RectF dirtyRect, PathF path) { if (ShapeView == null || ShapeView.Shape == null) { return; } if (!path.Closed) { return; } canvas.SaveState(); ClipPath(canvas, path); // Set Fill var fillPaint = ShapeView.Fill; canvas.SetFillPaint(fillPaint, dirtyRect); canvas.FillPath(path); canvas.RestoreState(); }
void DrawBoxView(ICanvas canvas, RectangleF dirtyRect, PathF path) { if (BoxView == null) { return; } if (!path.Closed) { return; } canvas.SaveState(); // Set BackgroundColor if (BoxView.Color != null) { canvas.FillColor = BoxView.Color; } else { canvas.SetFillPaint(BoxView.Background, dirtyRect); } canvas.FillPath(path); canvas.RestoreState(); }
public void Draw(ICanvas canvas, RectangleF dirtyRect) { var rect = dirtyRect; var path = new PathF(); float x = dirtyRect.X; float y = dirtyRect.Y; float w = dirtyRect.Width; float h = dirtyRect.Height; float topLeftCornerRadius = 0; float topRightCornerRadius = 0; float bottomLeftCornerRadius = 0; float bottomRightCornerRadius = 0; if (BoxView?.CornerRadius != null) { topLeftCornerRadius = (float)BoxView.CornerRadius.TopLeft; topRightCornerRadius = (float)BoxView.CornerRadius.TopRight; bottomLeftCornerRadius = (float)BoxView.CornerRadius.BottomLeft; bottomRightCornerRadius = (float)BoxView.CornerRadius.BottomRight; } path.AppendRoundedRectangle(x, y, w, h, topLeftCornerRadius, topRightCornerRadius, bottomLeftCornerRadius, bottomRightCornerRadius); DrawBoxView(canvas, rect, path); }
void ApplyTransform(PathF path) { if (RenderTransform == null) { return; } path.Transform(RenderTransform.Value); }
public static PathF AsScaledPath( this PathF target, float scale) { var scaledPath = new PathF(target); var transform = AffineTransform.GetScaleInstance(scale, scale); scaledPath.Transform(transform); return(scaledPath); }
public PathF(PathF path) : this() { _operations.AddRange(path._operations); _points = new List <PointF>(path._points); _arcAngles.AddRange(path._arcAngles); _arcClockwise.AddRange(path._arcClockwise); _subPathCount = path._subPathCount; _subPathsClosed = new List <bool>(path._subPathsClosed); }
void DrawStrokePath(ICanvas canvas, RectF dirtyRect, PathF path) { if (ShapeView == null || ShapeView.Shape == null || ShapeView.StrokeThickness <= 0 || ShapeView.Stroke == null) { return; } canvas.SaveState(); // Set StrokeThickness float strokeThickness = (float)ShapeView.StrokeThickness; canvas.StrokeSize = strokeThickness; // Set Stroke var stroke = ShapeView.Stroke; // TODO: Add Paint support for Stroke in Microsoft.Maui.Graphics. // For now, only support a solid color. canvas.StrokeColor = stroke.ToColor(); // Set StrokeLineCap var strokeLineCap = ShapeView.StrokeLineCap; canvas.StrokeLineCap = strokeLineCap; // Set StrokeLineJoin var strokeLineJoin = ShapeView.StrokeLineJoin; canvas.StrokeLineJoin = strokeLineJoin; // Set StrokeDashPattern var strokeDashPattern = ShapeView.StrokeDashPattern; canvas.StrokeDashPattern = strokeDashPattern; // Set StrokeDashOffset var strokeDashOffset = ShapeView.StrokeDashOffset; canvas.StrokeDashOffset = strokeDashOffset; // Set StrokeMiterLimit var strokeMiterLimit = ShapeView.StrokeMiterLimit; canvas.MiterLimit = strokeMiterLimit; canvas.DrawPath(path); canvas.RestoreState(); }
public static string ToDefinitionString(this PathF path, float ppu = 1) { var writer = new StringWriter(); for (var i = 0; i < path.OperationCount; i++) { var type = path.GetSegmentType(i); var points = path.GetPointsForSegment(i); if (type == PathOperation.Move) { writer.Write("M"); WritePoint(writer, points[0], ppu); } else if (type == PathOperation.Line) { writer.Write(" L"); WritePoint(writer, points[0], ppu); } else if (type == PathOperation.Quad) { writer.Write(" Q"); WritePoint(writer, points[0], ppu); writer.Write(" "); WritePoint(writer, points[1], ppu); } else if (type == PathOperation.Cubic) { writer.Write(" C"); WritePoint(writer, points[0], ppu); writer.Write(" "); WritePoint(writer, points[1], ppu); writer.Write(" "); WritePoint(writer, points[2], ppu); } else if (type == PathOperation.Close) { writer.Write(" Z "); } } return(writer.ToString()); }
private void ArcTo(bool isRelative) { var startPoint = _relativePoint ?? default; var rx = NextValue; var ry = NextValue; var r = NextValue; var largeArcFlag = NextBoolValue; var sweepFlag = NextBoolValue; var endPoint = NewPoint(NextValue, NextValue, isRelative, false); var arcPath = new PathF(startPoint); arcPath.SVGArcTo(rx, ry, r, largeArcFlag, sweepFlag, endPoint.X, endPoint.Y, startPoint.X, startPoint.Y); for (int s = 0; s < arcPath.OperationCount; s++) { var segmentType = arcPath.GetSegmentType(s); var pointsInSegment = arcPath.GetPointsForSegment(s); if (segmentType == PathOperation.Move) { // do nothing } else if (segmentType == PathOperation.Line) { _path.LineTo(pointsInSegment[0]); } else if (segmentType == PathOperation.Cubic) { _path.CurveTo(pointsInSegment[0], pointsInSegment[1], pointsInSegment[2]); } else if (segmentType == PathOperation.Quad) { _path.QuadTo(pointsInSegment[0], pointsInSegment[1]); } } _relativePoint = _path.LastPoint; }
public RectangleF GetPathBounds(PathF path) { throw new NotImplementedException(); }
void ClipPath(ICanvas canvas, PathF path) { canvas.ClipPath(path, WindingMode); }
public void DrawPath(PathF path) { _commands.Add(canvas => canvas.DrawPath(path)); }
protected abstract void NativeDrawPath(PathF path);
public void FillPath(PathF path, WindingMode windingMode) { _commands.Add(canvas => canvas.FillPath(path, windingMode)); }
public List <PathF> ConvertToPaths(PathF aPath, string text, ITextAttributes textAttributes, float ppu, float zoom) { return(new List <PathF>()); }
public void ClipPath(PathF path, WindingMode windingMode = WindingMode.NonZero) { _commands.Add(canvas => canvas.ClipPath(path, windingMode)); }
public bool PointIsOnPathSegment(PathF path, int segmentIndex, PointF point, float ppu, float zoom, float strokeWidth) { throw new NotImplementedException(); }
public bool PathContainsPoint(PathF path, PointF point, float ppu, float zoom, float strokeWidth) { throw new NotImplementedException(); }
public static void SVGArcTo(this PathF aTarget, float rx, float ry, float angle, bool largeArcFlag, bool sweepFlag, float x, float y, float lastPointX, float lastPointY) { float[] vValues = ComputeSvgArc(rx, ry, angle, largeArcFlag, sweepFlag, x, y, lastPointX, lastPointY); DrawArc(vValues[0], vValues[1], vValues[2], vValues[3], vValues[4], vValues[5], vValues[6], aTarget); }
public PathF BuildPath(string pathAsString) { try { _lastCommand = '~'; _lastCurveControlPoint = null; _path = null; _commandStack.Clear(); _relativePoint = new PointF(0, 0); _closeWhenDone = false; #if DEBUG_PATH Logger.Debug(aPathString); #endif pathAsString = pathAsString.Replace("Infinity", "0"); pathAsString = Regex.Replace(pathAsString, "([a-zA-Z])", " $1 "); pathAsString = pathAsString.Replace("-", " -"); pathAsString = pathAsString.Replace(" E -", "E-"); pathAsString = pathAsString.Replace(" e -", "e-"); #if DEBUG_PATH Logger.Debug(aPathString); #endif string[] args = pathAsString.Split(new[] { ' ', '\r', '\n', '\t', ',' }, StringSplitOptions.RemoveEmptyEntries); for (int i = args.Length - 1; i >= 0; i--) { string entry = args[i]; char c = entry[0]; if (char.IsLetter(c)) { if (entry.Length > 1) { entry = entry.Substring(1); if (char.IsLetter(entry[0])) { if (entry.Length > 1) { _commandStack.Push(entry.Substring(1)); #if DEBUG_PATH Logger.Debug(vEntry.Substring(1)); #endif } _commandStack.Push(entry[0].ToInvariantString()); #if DEBUG_PATH Logger.Debug(vEntry[0].ToString()); #endif } else { _commandStack.Push(entry); #if DEBUG_PATH Logger.Debug(vEntry); #endif } } _commandStack.Push(c.ToInvariantString()); #if DEBUG_PATH Logger.Debug(vChar.ToString()); #endif } else { _commandStack.Push(entry); #if DEBUG_PATH Logger.Debug(vEntry); #endif } } while (_commandStack.Count > 0) { if (_path == null) { _path = new PathF(); } string topCommand = _commandStack.Pop(); var firstLetter = topCommand[0]; if (IsCommand(firstLetter)) { HandleCommand(topCommand); } else { _commandStack.Push(topCommand); HandleCommand(_lastCommand.ToString()); } } if (_path != null && !_path.Closed) { if (_closeWhenDone) { _path.Close(); } } } catch (Exception exc) { #if DEBUG Logger.Debug("=== An error occured parsing the path. ===", exc); Logger.Debug(pathAsString); throw; #endif } return(_path); }
public void LayoutText(PathF path, string text, ITextAttributes textAttributes, LayoutLine callback) { // Do nothing }
public RectangleF GetPathBoundsWhenRotated(PointF center, PathF path, float angle) { throw new NotImplementedException(); }
/** * Draws an arc of type "open" only. Accepts an optional x axis rotation value **/ public static void DrawArc(float x, float y, float startAngle, float arc, float radius, float yRadius, float xAxisRotation, PathF aPath) { // Circumvent drawing more than is needed if (Math.Abs(arc) > 360) { arc = 360; } // Draw in a maximum of 45 degree segments. First we calculate how many // segments are needed for our arc. float segs = (float)Math.Ceiling(Math.Abs(arc) / 45); // Now calculate the sweep of each segment float segAngle = arc / segs; float theta = Geometry.DegreesToRadians(segAngle); float angle = Geometry.DegreesToRadians(startAngle); // Draw as 45 degree segments if (segs > 0) { float beta = Geometry.DegreesToRadians(xAxisRotation); float sinbeta = (float)Math.Sin(beta); float cosbeta = (float)Math.Cos(beta); // Loop for drawing arc segments for (int i = 0; i < segs; i++) { angle += theta; float sinangle = (float)Math.Sin(angle - theta / 2); float cosangle = (float)Math.Cos(angle - theta / 2); float div = (float)Math.Cos(theta / 2); float cx = x + (radius * cosangle * cosbeta - yRadius * sinangle * sinbeta) / div; //Why divide by Math.cos(theta/2)? - FIX THIS float cy = y + (radius * cosangle * sinbeta + yRadius * sinangle * cosbeta) / div; //Why divide by Math.cos(theta/2)? - FIX THIS sinangle = (float)Math.Sin(angle); cosangle = (float)Math.Cos(angle); float x1 = x + (radius * cosangle * cosbeta - yRadius * sinangle * sinbeta); float y1 = y + (radius * cosangle * sinbeta + yRadius * sinangle * cosbeta); aPath.QuadTo(cx, cy, x1, y1); } } }