Exemplo n.º 1
0
 TNode NodeFor(Wg.IGeometrySource2D obj) => _graph[obj].Canonical;
Exemplo n.º 2
0
 TC CanonicalObject <TC>(Wg.IGeometrySource2D obj) => (TC)NodeFor(obj).Object;
Exemplo n.º 3
0
        CanvasGeometry GetCanvasGeometry(Wg.IGeometrySource2D obj)
        {
            if (GetExistingCanvasGeometry((CanvasGeometry)obj, out CanvasGeometry result))
            {
                return(result);
            }

            var canvasGeometry = (CanvasGeometry)obj;

            switch (canvasGeometry.Type)
            {
            case CanvasGeometry.GeometryType.Combination:
            {
                var combination = (CanvasGeometry.Combination)canvasGeometry;
                result = GetCanvasGeometry(combination.A).CombineWith(
                    GetCanvasGeometry(combination.B),
                    combination.Matrix,
                    combination.CombineMode);
                break;
            }

            case CanvasGeometry.GeometryType.Ellipse:
                var ellipse = (CanvasGeometry.Ellipse)canvasGeometry;
                result = CanvasGeometry.CreateEllipse(
                    null,
                    ellipse.X,
                    ellipse.Y,
                    ellipse.RadiusX,
                    ellipse.RadiusY);
                break;

            case CanvasGeometry.GeometryType.Group:
                var group      = (CanvasGeometry.Group)canvasGeometry;
                var geometries = group.Geometries.Select(g => GetCanvasGeometry(g)).ToArray();
                result = CanvasGeometry.CreateGroup(null, geometries, group.FilledRegionDetermination);
                break;

            case CanvasGeometry.GeometryType.Path:
                using (var builder = new CanvasPathBuilder(null))
                {
                    var path = (CanvasGeometry.Path)canvasGeometry;

                    if (path.FilledRegionDetermination != CanvasFilledRegionDetermination.Alternate)
                    {
                        builder.SetFilledRegionDetermination(path.FilledRegionDetermination);
                    }

                    foreach (var command in path.Commands)
                    {
                        switch (command.Type)
                        {
                        case CanvasPathBuilder.CommandType.BeginFigure:
                            builder.BeginFigure(((CanvasPathBuilder.Command.BeginFigure)command).StartPoint);
                            break;

                        case CanvasPathBuilder.CommandType.EndFigure:
                            builder.EndFigure(((CanvasPathBuilder.Command.EndFigure)command).FigureLoop);
                            break;

                        case CanvasPathBuilder.CommandType.AddLine:
                            builder.AddLine(((CanvasPathBuilder.Command.AddLine)command).EndPoint);
                            break;

                        case CanvasPathBuilder.CommandType.AddCubicBezier:
                            var cb = (CanvasPathBuilder.Command.AddCubicBezier)command;
                            builder.AddCubicBezier(cb.ControlPoint1, cb.ControlPoint2, cb.EndPoint);
                            break;

                        default:
                            throw new InvalidOperationException();
                        }
                    }

                    result = CanvasGeometry.CreatePath(builder);
                }

                break;

            case CanvasGeometry.GeometryType.RoundedRectangle:
                var roundedRectangle = (CanvasGeometry.RoundedRectangle)canvasGeometry;
                result = CanvasGeometry.CreateRoundedRectangle(
                    null,
                    roundedRectangle.X,
                    roundedRectangle.Y,
                    roundedRectangle.W,
                    roundedRectangle.H,
                    roundedRectangle.RadiusX,
                    roundedRectangle.RadiusY);
                break;

            case CanvasGeometry.GeometryType.TransformedGeometry:
                var transformedGeometry = (CanvasGeometry.TransformedGeometry)canvasGeometry;
                result = GetCanvasGeometry(transformedGeometry.SourceGeometry).Transform(transformedGeometry.TransformMatrix);
                break;

            default:
                throw new InvalidOperationException();
            }

            InitializeIDescribable(canvasGeometry, result);
            CacheCanvasGeometry(canvasGeometry, result);

            return(result);
        }