示例#1
0
 internal static void AddConic(IToolContext context, ConicShape conic, double dx, double dy, SKPath geometry)
 {
     geometry.MoveTo(ToSKPoint(conic.StartPoint, dx, dy));
     geometry.ConicTo(
         ToSKPoint(conic.Point1, dx, dy),
         ToSKPoint(conic.Point2, dx, dy),
         (float)conic.Weight);
 }
示例#2
0
        public void DrawConic(object dc, ConicShape conic, string styleId, double dx, double dy, double scale)
        {
            var geometry = new SKPath()
            {
                FillType = SKPathFillType.Winding
            };

            SkiaHelper.AddConic(null, conic, dx, dy, geometry);
            _rootNodes[_currentRootNode].Children.Add(new ChildNode(conic, styleId, dx, dy, scale, geometry));
        }
示例#3
0
 public void Draw(object dc, IShapeRenderer renderer, ConicShape conic, double dx, double dy, double scale)
 {
     DrawLine(dc, renderer, conic.StartPoint, conic.Point1, dx, dy, scale);
     DrawLine(dc, renderer, conic.Point1, conic.Point2, dx, dy, scale);
 }
示例#4
0
        internal static PathShape ToPathShape(IToolContext context, SKPath path, ShapeStyle style, IBaseShape pointTemplate)
        {
            var pathShape = new PathShape()
            {
                Points   = new ObservableCollection <IPointShape>(),
                Shapes   = new ObservableCollection <IBaseShape>(),
                FillType = ToPathFillType(path.FillType),
                Text     = new Text(),
                StyleId  = style.Title
            };

            var figureShape = default(FigureShape);

            using (var iterator = path.CreateRawIterator())
            {
                var points     = new SKPoint[4];
                var pathVerb   = SKPathVerb.Move;
                var firstPoint = new SKPoint();
                var lastPoint  = new SKPoint();

                while ((pathVerb = iterator.Next(points)) != SKPathVerb.Done)
                {
                    switch (pathVerb)
                    {
                    case SKPathVerb.Move:
                    {
                        figureShape = new FigureShape()
                        {
                            Points   = new ObservableCollection <IPointShape>(),
                            Shapes   = new ObservableCollection <IBaseShape>(),
                            IsFilled = true,
                            IsClosed = false
                        };
                        figureShape.Owner = pathShape;
                        pathShape.Shapes.Add(figureShape);
                        firstPoint = lastPoint = points[0];
                    }
                    break;

                    case SKPathVerb.Line:
                    {
                        var lastPointShape = pathShape.GetLastPoint();
                        if (lastPointShape == null)
                        {
                            lastPointShape = new PointShape(points[0].X, points[0].Y, pointTemplate);
                        }
                        var lineShape = new LineShape()
                        {
                            Points     = new ObservableCollection <IPointShape>(),
                            StartPoint = lastPointShape,
                            Point      = new PointShape(points[1].X, points[1].Y, pointTemplate),
                            Text       = new Text(),
                            StyleId    = style.Title
                        };
                        lineShape.Owner            = figureShape;
                        lineShape.StartPoint.Owner = lineShape;
                        lineShape.Point.Owner      = lineShape;
                        figureShape.Shapes.Add(lineShape);
                        lastPoint = points[1];
                    }
                    break;

                    case SKPathVerb.Cubic:
                    {
                        var lastPointShape = pathShape.GetLastPoint();
                        if (lastPointShape == null)
                        {
                            lastPointShape = new PointShape(points[0].X, points[0].Y, pointTemplate);
                        }
                        var cubicBezierShape = new CubicBezierShape()
                        {
                            Points     = new ObservableCollection <IPointShape>(),
                            StartPoint = lastPointShape,
                            Point1     = new PointShape(points[1].X, points[1].Y, pointTemplate),
                            Point2     = new PointShape(points[2].X, points[2].Y, pointTemplate),
                            Point3     = new PointShape(points[3].X, points[3].Y, pointTemplate),
                            Text       = new Text(),
                            StyleId    = style.Title
                        };
                        cubicBezierShape.Owner            = figureShape;
                        cubicBezierShape.StartPoint.Owner = cubicBezierShape;
                        cubicBezierShape.Point1.Owner     = cubicBezierShape;
                        cubicBezierShape.Point2.Owner     = cubicBezierShape;
                        cubicBezierShape.Point3.Owner     = cubicBezierShape;
                        figureShape.Shapes.Add(cubicBezierShape);
                        lastPoint = points[3];
                    }
                    break;

                    case SKPathVerb.Quad:
                    {
                        var lastPointShape = pathShape.GetLastPoint();
                        if (lastPointShape == null)
                        {
                            lastPointShape = new PointShape(points[0].X, points[0].Y, pointTemplate);
                        }
                        var quadraticBezierShape = new QuadraticBezierShape()
                        {
                            Points     = new ObservableCollection <IPointShape>(),
                            StartPoint = lastPointShape,
                            Point1     = new PointShape(points[1].X, points[1].Y, pointTemplate),
                            Point2     = new PointShape(points[2].X, points[2].Y, pointTemplate),
                            Text       = new Text(),
                            StyleId    = style.Title
                        };
                        quadraticBezierShape.Owner            = figureShape;
                        quadraticBezierShape.StartPoint.Owner = quadraticBezierShape;
                        quadraticBezierShape.Point1.Owner     = quadraticBezierShape;
                        quadraticBezierShape.Point2.Owner     = quadraticBezierShape;
                        figureShape.Shapes.Add(quadraticBezierShape);
                        lastPoint = points[2];
                    }
                    break;

                    case SKPathVerb.Conic:
                    {
                        var lastPointShape = pathShape.GetLastPoint();
                        if (lastPointShape == null)
                        {
                            lastPointShape = new PointShape(points[0].X, points[0].Y, pointTemplate);
                        }
                        var conicShape = new ConicShape()
                        {
                            Points     = new ObservableCollection <IPointShape>(),
                            StartPoint = lastPointShape,
                            Point1     = new PointShape(points[1].X, points[1].Y, pointTemplate),
                            Point2     = new PointShape(points[2].X, points[2].Y, pointTemplate),
                            Weight     = iterator.ConicWeight(),
                            Text       = new Text(),
                            StyleId    = style.Title
                        };
                        conicShape.Owner            = figureShape;
                        conicShape.StartPoint.Owner = conicShape;
                        conicShape.Point1.Owner     = conicShape;
                        conicShape.Point2.Owner     = conicShape;
                        figureShape.Shapes.Add(conicShape);
                        lastPoint = points[2];
                    }
                    break;

                    case SKPathVerb.Close:
                    {
#if USE_CLOSE_SHAPE
                        var line = new LineShape()
                        {
                            Points     = new ObservableCollection <IPointShape>(),
                            StartPoint = pathShape.GetLastPoint(),
                            Point      = pathShape.GetFirstPoint(),
                            Text       = new Text(),
                            StyleId    = style.Title
                        };
                        line.Owner            = figureShape;
                        line.StartPoint.Owner = line;
                        line.Point.Owner      = line;
                        figureShape.Shapes.Add(line);
#else
                        figureShape.IsClosed = true;
                        firstPoint           = lastPoint = new SKPoint(0, 0);
#endif
                    }
                    break;
                    }
                }
            }

            return(pathShape);
        }