Example #1
0
        public static void Draw(SKCanvas skCanvas, SvgFragment svgFragment)
        {
            var size     = SvgModelExtensions.GetDimensions(svgFragment);
            var bounds   = Rect.Create(size);
            var drawable = DrawableFactory.Create(svgFragment, bounds, null, _assetLoader);

            if (drawable is { })
Example #2
0
        public static FragmentDrawable Create(SvgFragment svgFragment, SKRect skViewport, DrawableBase?parent, IAssetLoader assetLoader, HashSet <Uri>?references, DrawAttributes ignoreAttributes = DrawAttributes.None)
        {
            var drawable = new FragmentDrawable(assetLoader, references)
            {
                Element          = svgFragment,
                Parent           = parent,
                IgnoreAttributes = ignoreAttributes
            };

            drawable.IsDrawable = drawable.HasFeatures(svgFragment, drawable.IgnoreAttributes);

            if (!drawable.IsDrawable)
            {
                return(drawable);
            }

            var svgFragmentParent = svgFragment.Parent;

            var x = svgFragmentParent is null ? 0f : svgFragment.X.ToDeviceValue(UnitRenderingType.Horizontal, svgFragment, skViewport);
            var y = svgFragmentParent is null ? 0f : svgFragment.Y.ToDeviceValue(UnitRenderingType.Vertical, svgFragment, skViewport);

            var skSize = SvgExtensions.GetDimensions(svgFragment);

            if (skViewport.IsEmpty)
            {
                skViewport = SKRect.Create(x, y, skSize.Width, skSize.Height);
            }

            drawable.CreateChildren(svgFragment, skViewport, drawable, assetLoader, references, ignoreAttributes);

            drawable.Initialize(skViewport, x, y, skSize);

            return(drawable);
        }
Example #3
0
        public static SKPicture?ToPicture(SvgFragment svgFragment)
        {
            var skSize   = SvgExtensions.GetDimensions(svgFragment);
            var skBounds = SKRect.Create(skSize);

            using var drawable = DrawableFactory.Create(svgFragment, skBounds, null, null, Attributes.None);
            if (drawable == null)
            {
                return(null);
            }

            drawable.PostProcess();

            if (skBounds.IsEmpty)
            {
                skBounds = GetBounds(drawable);
            }

            using var skPictureRecorder = new SKPictureRecorder();
            using var skCanvas          = skPictureRecorder.BeginRecording(skBounds);
#if USE_EXPERIMENTAL_LINEAR_RGB
            // TODO:
            using var skPaint       = new SKPaint();
            using var skColorFilter = SKColorFilter.CreateTable(null, SvgPaintingExtensions.s_LinearRGBtoSRGB, SvgPaintingExtensions.s_LinearRGBtoSRGB, SvgPaintingExtensions.s_LinearRGBtoSRGB);
            using var skImageFilter = SKImageFilter.CreateColorFilter(skColorFilter);
            skPaint.ImageFilter     = skImageFilter;
            skCanvas.SaveLayer(skPaint);
#endif
            drawable?.Draw(skCanvas, 0f, 0f);
#if USE_EXPERIMENTAL_LINEAR_RGB
            // TODO:
            skCanvas.Restore();
#endif
            return(skPictureRecorder.EndRecording());
        }
        public SvgElement GetPresentation(double width, double height)
        {
            if (LayerClass.IconSvg == null)
            {
                return(null);
            }

            SvgFragment copy = (SvgFragment)LayerClass.IconSvg.DeepCopy();

            float imageAspectRatio        = copy.Bounds.Width / copy.Bounds.Height;
            float restrictionAspectRation = (float)(width / height);

            copy.ViewBox = copy.Bounds;

            if (imageAspectRatio > restrictionAspectRation)
            {
                //image shape is wider then restriction area.
                //thus width is effective restriction
                copy.Width  = (float)width;
                copy.Height = (float)(width / imageAspectRatio);
            }
            else
            {
                //hight is effective restiction
                copy.Width  = (float)(height * imageAspectRatio);
                copy.Height = (float)(height);
            }

            return(copy);
        }
Example #5
0
        public static void Draw(SKCanvas skCanvas, SvgFragment svgFragment)
        {
            var skSize   = SvgExtensions.GetDimensions(svgFragment);
            var skBounds = SKRect.Create(skSize);

            using var drawable = DrawableFactory.Create(svgFragment, skBounds, null, null, Attributes.None);
            drawable?.PostProcess();
            drawable?.Draw(skCanvas, 0f, 0f);
        }
Example #6
0
        public static Drawable?ToDrawable(SvgFragment svgFragment)
        {
            var skSize   = SvgExtensions.GetDimensions(svgFragment);
            var skBounds = SKRect.Create(skSize);
            var drawable = DrawableFactory.Create(svgFragment, skBounds, null, null, Attributes.None);

            drawable?.PostProcess();
            return(drawable);
        }
Example #7
0
        public static void Draw(SkiaSharp.SKCanvas skCanvas, SvgFragment svgFragment)
        {
            var references = new HashSet <Uri> {
                svgFragment.OwnerDocument.BaseUri
            };
            var size     = SvgExtensions.GetDimensions(svgFragment);
            var bounds   = SKRect.Create(size);
            var drawable = DrawableFactory.Create(svgFragment, bounds, null, s_assetLoader, references);

            if (drawable is { })
Example #8
0
        internal SKPicture Load(SvgFragment svgFragment)
        {
            var skSize   = SkiaUtil.GetDimensions(svgFragment);
            var cullRect = SKRect.Create(skSize);

            using (var skPictureRecorder = new SKPictureRecorder())
                using (var skCanvas = skPictureRecorder.BeginRecording(cullRect))
                    using (var renderer = new SKSvgRenderer(skCanvas, skSize))
                    {
                        renderer.DrawFragment(svgFragment, false);
                        return(skPictureRecorder.EndRecording());
                    }
        }
Example #9
0
        public Fragment(SvgFragment svgFragment)
        {
            x      = svgFragment.X.ToDeviceValue(null, UnitRenderingType.Horizontal, svgFragment);
            y      = svgFragment.Y.ToDeviceValue(null, UnitRenderingType.Vertical, svgFragment);
            width  = svgFragment.Width.ToDeviceValue(null, UnitRenderingType.Horizontal, svgFragment);
            height = svgFragment.Height.ToDeviceValue(null, UnitRenderingType.Vertical, svgFragment);
            bounds = SKRect.Create(x, y, width, height);

            matrix = SvgHelper.GetSKMatrix(svgFragment.Transforms);
            var viewBoxMatrix = SvgHelper.GetSvgViewBoxTransform(svgFragment.ViewBox, svgFragment.AspectRatio, x, y, width, height);

            SKMatrix.Concat(ref matrix, ref matrix, ref viewBoxMatrix);
        }
Example #10
0
 internal SKPicture Load(SvgFragment svgFragment)
 {
     using (var disposable = new CompositeDisposable())
     {
         float width    = svgFragment.Width.ToDeviceValue(null, UnitRenderingType.Horizontal, svgFragment);
         float height   = svgFragment.Height.ToDeviceValue(null, UnitRenderingType.Vertical, svgFragment);
         var   skSize   = new SKSize(width, height);
         var   cullRect = SKRect.Create(skSize);
         using (var skPictureRecorder = new SKPictureRecorder())
             using (var skCanvas = skPictureRecorder.BeginRecording(cullRect))
             {
                 SvgHelper.DrawSvgElement(skCanvas, skSize, svgFragment, disposable);
                 return(skPictureRecorder.EndRecording());
             }
     }
 }
Example #11
0
        public void TestGetAttribute()
        {
            var owner  = new SvgCircle();
            var parent = new SvgFragment();

            parent.Children.Add(owner);
            parent.Attributes["test"] = "parent";

            owner.Attributes["test"] = "owner";
            Assert.AreEqual("owner", owner.Attributes.GetAttribute <string>("test"));

            owner.Attributes["test"] = "inherit";
            Assert.AreEqual("inherit", owner.Attributes.GetAttribute <string>("test"));

            owner.Attributes.Remove("test");
            Assert.IsNull(owner.Attributes.GetAttribute <string>("test"));
        }
Example #12
0
 public static DrawableBase?Create(SvgElement svgElement, Rect skOwnerBounds, DrawableBase?parent, IAssetLoader assetLoader, Attributes ignoreAttributes = Attributes.None)
 {
     return(svgElement switch
     {
         SvgAnchor svgAnchor => AnchorDrawable.Create(svgAnchor, skOwnerBounds, parent, assetLoader, ignoreAttributes),
         SvgFragment svgFragment => FragmentDrawable.Create(svgFragment, skOwnerBounds, parent, assetLoader, ignoreAttributes),
         SvgImage svgImage => ImageDrawable.Create(svgImage, skOwnerBounds, parent, assetLoader, ignoreAttributes),
         SvgSwitch svgSwitch => SwitchDrawable.Create(svgSwitch, skOwnerBounds, parent, assetLoader, ignoreAttributes),
         SvgUse svgUse => UseDrawable.Create(svgUse, skOwnerBounds, parent, assetLoader, ignoreAttributes),
         SvgCircle svgCircle => CircleDrawable.Create(svgCircle, skOwnerBounds, parent, assetLoader, ignoreAttributes),
         SvgEllipse svgEllipse => EllipseDrawable.Create(svgEllipse, skOwnerBounds, parent, assetLoader, ignoreAttributes),
         SvgRectangle svgRectangle => RectangleDrawable.Create(svgRectangle, skOwnerBounds, parent, assetLoader, ignoreAttributes),
         SvgGroup svgGroup => GroupDrawable.Create(svgGroup, skOwnerBounds, parent, assetLoader, ignoreAttributes),
         SvgLine svgLine => LineDrawable.Create(svgLine, skOwnerBounds, parent, assetLoader, ignoreAttributes),
         SvgPath svgPath => PathDrawable.Create(svgPath, skOwnerBounds, parent, assetLoader, ignoreAttributes),
         SvgPolyline svgPolyline => PolylineDrawable.Create(svgPolyline, skOwnerBounds, parent, assetLoader, ignoreAttributes),
         SvgPolygon svgPolygon => PolygonDrawable.Create(svgPolygon, skOwnerBounds, parent, assetLoader, ignoreAttributes),
         SvgText svgText => TextDrawable.Create(svgText, skOwnerBounds, parent, assetLoader, ignoreAttributes),
         _ => null,
     });
Example #13
0
 public static Drawable?Create(SvgElement svgElement, SKRect skOwnerBounds, Drawable?root, Drawable?parent, Attributes ignoreAttributes = Attributes.None)
 {
     return(svgElement switch
     {
         SvgAnchor svgAnchor => new AnchorDrawable(svgAnchor, skOwnerBounds, root, parent, ignoreAttributes),
         SvgFragment svgFragment => new FragmentDrawable(svgFragment, skOwnerBounds, root, parent, ignoreAttributes),
         SvgImage svgImage => new ImageDrawable(svgImage, skOwnerBounds, root, parent, ignoreAttributes),
         SvgSwitch svgSwitch => new SwitchDrawable(svgSwitch, skOwnerBounds, root, parent, ignoreAttributes),
         SvgUse svgUse => new UseDrawable(svgUse, skOwnerBounds, root, parent, ignoreAttributes),
         SvgCircle svgCircle => new CircleDrawable(svgCircle, skOwnerBounds, root, parent, ignoreAttributes),
         SvgEllipse svgEllipse => new EllipseDrawable(svgEllipse, skOwnerBounds, root, parent, ignoreAttributes),
         SvgRectangle svgRectangle => new RectangleDrawable(svgRectangle, skOwnerBounds, root, parent, ignoreAttributes),
         SvgGroup svgGroup => new GroupDrawable(svgGroup, skOwnerBounds, root, parent, ignoreAttributes),
         SvgLine svgLine => new LineDrawable(svgLine, skOwnerBounds, root, parent, ignoreAttributes),
         SvgPath svgPath => new PathDrawable(svgPath, skOwnerBounds, root, parent, ignoreAttributes),
         SvgPolyline svgPolyline => new PolylineDrawable(svgPolyline, skOwnerBounds, root, parent, ignoreAttributes),
         SvgPolygon svgPolygon => new PolygonDrawable(svgPolygon, skOwnerBounds, root, parent, ignoreAttributes),
         SvgText svgText => new TextDrawable(svgText, skOwnerBounds, root, parent, ignoreAttributes),
         _ => null,
     });
Example #14
0
        public void TestGetInheritedAttribute()
        {
            var owner  = new SvgCircle();
            var parent = new SvgFragment();

            parent.Children.Add(owner);
            parent.Attributes["test"] = "parent";

            owner.Attributes["test"] = "owner";
            Assert.AreEqual("owner", owner.Attributes.GetInheritedAttribute("test", true, "default"));
            Assert.AreEqual("owner", owner.Attributes.GetInheritedAttribute("test", false, "default"));

            owner.Attributes["test"] = "inherit";
            Assert.AreEqual("parent", owner.Attributes.GetInheritedAttribute("test", true, "default"));
            Assert.AreEqual("parent", owner.Attributes.GetInheritedAttribute("test", false, "default"));

            owner.Attributes.Remove("test");
            Assert.AreEqual("parent", owner.Attributes.GetInheritedAttribute("test", true, "default"));
            Assert.AreEqual("default", owner.Attributes.GetInheritedAttribute("test", false, "default"));
        }
Example #15
0
        public static SKSize GetDimensions(SvgFragment svgFragment)
        {
            float w, h;
            var   isWidthperc  = svgFragment.Width.Type == SvgUnitType.Percentage;
            var   isHeightperc = svgFragment.Height.Type == SvgUnitType.Percentage;

            var bounds = new SKRect();

            if (isWidthperc || isHeightperc)
            {
                if (svgFragment.ViewBox.Width > 0 && svgFragment.ViewBox.Height > 0)
                {
                    bounds = new SKRect(svgFragment.ViewBox.MinX, svgFragment.ViewBox.MinY, svgFragment.ViewBox.Width, svgFragment.ViewBox.Height);
                }
                else
                {
                    // TODO: Calculate correct bounds using Children bounds.
                }
            }

            if (isWidthperc)
            {
                w = (bounds.Width + bounds.Left) * (svgFragment.Width.Value * 0.01f);
            }
            else
            {
                // NOTE: Pass bounds as SKRect.Empty because percentage case is handled before.
                w = svgFragment.Width.ToDeviceValue(UnitRenderingType.Horizontal, svgFragment, SKRect.Empty);
            }
            if (isHeightperc)
            {
                h = (bounds.Height + bounds.Top) * (svgFragment.Height.Value * 0.01f);
            }
            else
            {
                // NOTE: Pass bounds as SKRect.Empty because percentage case is handled before.
                h = svgFragment.Height.ToDeviceValue(UnitRenderingType.Vertical, svgFragment, SKRect.Empty);
            }

            return(new SKSize(w, h));
        }
Example #16
0
        // TODO:
        //public void DrawAnchor(SvgAnchor svgAnchor, bool ignoreDisplay)
        //{
        //    _skCanvas.Save();
        //
        //    var skMatrix = SkiaUtil.GetSKMatrix(svgAnchor.Transforms);
        //    SetTransform(skMatrix);
        //
        //    var skPaintOpacity = SetOpacity(svgAnchor, _disposable);
        //
        //    foreach (var svgElement in svgAnchor.Children)
        //    {
        //        Draw(svgElement, ignoreDisplay);
        //    }
        //
        //    if (skPaintOpacity != null)
        //    {
        //        _skCanvas.Restore();
        //    }
        //
        //    _skCanvas.Restore();
        //}

        public void DrawFragment(SvgFragment svgFragment, bool ignoreDisplay)
        {
            float x      = svgFragment.X.ToDeviceValue(null, UnitRenderingType.Horizontal, svgFragment);
            float y      = svgFragment.Y.ToDeviceValue(null, UnitRenderingType.Vertical, svgFragment);
            var   skSize = SkiaUtil.GetDimensions(svgFragment);

            _skCanvas.Save();

            switch (svgFragment.Overflow)
            {
            case SvgOverflow.Auto:
            case SvgOverflow.Visible:
            case SvgOverflow.Inherit:
                break;

            default:
                var skClipRect = SKRect.Create(x, y, skSize.Width, skSize.Height);
                _skCanvas.ClipRect(skClipRect, SKClipOperation.Intersect);
                break;
            }

            var skMatrixViewBox = SkiaUtil.GetSvgViewBoxTransform(svgFragment.ViewBox, svgFragment.AspectRatio, x, y, skSize.Width, skSize.Height);
            var skMatrix        = SkiaUtil.GetSKMatrix(svgFragment.Transforms);

            SKMatrix.PreConcat(ref skMatrix, ref skMatrixViewBox);
            SetTransform(skMatrix);

            var skPaintOpacity = SetOpacity(svgFragment, _disposable);

            foreach (var svgElement in svgFragment.Children)
            {
                Draw(svgElement, ignoreDisplay);
            }

            if (skPaintOpacity != null)
            {
                _skCanvas.Restore();
            }

            _skCanvas.Restore();
        }
Example #17
0
        public static SKPicture?ToPicture(SvgFragment svgFragment, out Drawable?drawable)
        {
            var skSize   = SvgExtensions.GetDimensions(svgFragment);
            var skBounds = SKRect.Create(skSize);

            drawable = DrawableFactory.Create(svgFragment, skBounds, null, null, Attributes.None);
            if (drawable == null)
            {
                return(null);
            }

            drawable.PostProcess();

            if (skBounds.IsEmpty)
            {
                skBounds = GetBounds(drawable);
            }

            using var skPictureRecorder = new SKPictureRecorder();
            using var skCanvas          = skPictureRecorder.BeginRecording(skBounds);
            drawable?.Draw(skCanvas, 0f, 0f);
            return(skPictureRecorder.EndRecording());
        }
Example #18
0
        public static SP.Picture?ToModel(SvgFragment svgFragment)
        {
            var size   = SvgExtensions.GetDimensions(svgFragment);
            var bounds = SP.Rect.Create(size);

            using var drawable = DrawableFactory.Create(svgFragment, bounds, null, Attributes.None);
            if (drawable == null)
            {
                return(null);
            }
            drawable.PostProcess();

            if (bounds.IsEmpty)
            {
                var drawableBounds = drawable.Bounds;
                bounds = SP.Rect.Create(
                    0f,
                    0f,
                    Math.Abs(drawableBounds.Left) + drawableBounds.Width,
                    Math.Abs(drawableBounds.Top) + drawableBounds.Height);
            }

            return(drawable.Snapshot(bounds));
        }
Example #19
0
        public static SvgDocument Generate(ISvgRenderableColumn[] columns, ILegendGroup[] legend)
        {
            //generating headers
            SvgGroup       headerGroup      = new SvgGroup();
            SvgPaintServer blackPaint       = new SvgColourServer(System.Drawing.Color.Black);
            double         horizontalOffset = 0.0;
            double         headerHeight     = 0;

            for (int i = 0; i < columns.Length; i++)
            {
                RenderedSvg  heading = columns[i].RenderHeader();
                SvgRectangle rect    = new SvgRectangle();
                headerHeight = heading.RenderedSize.Height;
                rect.Width   = Helpers.dtos(heading.RenderedSize.Width);
                rect.Height  = Helpers.dtos(heading.RenderedSize.Height);
                rect.X       = Helpers.dtos(horizontalOffset);
                rect.Y       = Helpers.dtos(0.0);
                rect.Stroke  = blackPaint;

                heading.SVG.Transforms.Add(new SvgTranslate((float)(horizontalOffset + heading.RenderedSize.Width * 0.5), (float)heading.RenderedSize.Height * 0.9f));
                heading.SVG.Transforms.Add(new SvgRotate((float)-90.0));

                headerGroup.Children.Add(rect);
                headerGroup.Children.Add(heading.SVG);
                horizontalOffset += heading.RenderedSize.Width;
            }
            //generating columns
            SvgGroup columnsGroup = new SvgGroup();
            double   columnHeight = 0.0;

            horizontalOffset = 0.0;
            columnsGroup.Transforms.Add(new SvgTranslate(0.0f, (float)headerHeight));
            for (int i = 0; i < columns.Length; i++)
            {
                RenderedSvg  column = columns[i].RenderColumn();
                SvgRectangle rect   = new SvgRectangle();
                columnHeight = column.RenderedSize.Height;
                rect.Width   = Helpers.dtos(column.RenderedSize.Width);
                rect.Height  = Helpers.dtos(column.RenderedSize.Height);
                rect.X       = Helpers.dtos(horizontalOffset);
                rect.Y       = Helpers.dtos(0.0);
                rect.Stroke  = blackPaint;

                column.SVG.Transforms.Add(new SvgTranslate((float)(horizontalOffset)));

                columnsGroup.Children.Add(rect);
                columnsGroup.Children.Add(column.SVG);

                horizontalOffset += column.RenderedSize.Width;
            }

            //generating legend group
            SvgGroup legendGroup = new SvgGroup();

            const float legendYGap    = 30.0f;
            const float legendXOffset = 10.0f;


            legendGroup.Transforms.Add(new SvgTranslate(legendXOffset, Helpers.dtos(headerHeight + columnHeight + legendYGap)));

            const float titleYoffset    = 60.0f;
            const float itemsYoffset    = 20.0f;
            const float itemYgap        = 20.0f;
            const float interGroupYgap  = 15.0f;
            const float itemImageWidth  = 64.0f;
            const float itemImageHeight = 32.0f;
            const float descrXoffset    = 150.0f;

            SvgText legendTitle = new SvgText("Условные обозначения");

            legendTitle.FontSize = 22;
            legendTitle.Fill     = new SvgColourServer(System.Drawing.Color.Black);
            legendTitle.Transforms.Add(new SvgTranslate(30.0f, Helpers.dtos(titleYoffset * 0.25f)));
            legendGroup.Children.Add(legendTitle);

            float currGroupOffset = 0.0f;
            int   k = 0;

            foreach (ILegendGroup group in legend)
            {
                //title
                SvgText groupTitle = new SvgText(group.GroupName);
                groupTitle.FontSize = new SvgUnit((float)18);
                groupTitle.Fill     = new SvgColourServer(System.Drawing.Color.Black);
                groupTitle.Transforms.Add(new SvgTranslate(0.0f, currGroupOffset + titleYoffset));
                legendGroup.Children.Add(groupTitle);

                //items
                var items = group.Items;

                int j = 0;

                SvgElement[] fragments = items.Select(item => item.GetPresentation(itemImageWidth, itemImageHeight)).ToArray();

                foreach (var item in items)
                {
                    if (fragments[j] == null)
                    {
                        continue;
                    }

                    float yOffset = currGroupOffset + titleYoffset + itemsYoffset + j * (itemYgap + itemImageHeight);

                    if (fragments[j] is SvgFragment)
                    {
                        SvgFragment fragment = (SvgFragment)fragments[j];
                        fragment.X = 0;
                        fragment.Y = yOffset;
                    }
                    else
                    {
                        fragments[j].Transforms.Add(new SvgTranslate(0, yOffset));
                    }

                    legendGroup.Children.Add(fragments[j]);

                    SvgText text = new SvgText(item.Description);
                    text.FontSize = new SvgUnit((float)14);
                    text.Fill     = new SvgColourServer(System.Drawing.Color.Black);
                    text.Transforms.Add(new SvgTranslate(descrXoffset, yOffset + itemImageHeight * 0.5f));
                    legendGroup.Children.Add(text);
                    j++;
                }
                currGroupOffset += titleYoffset + itemsYoffset + (itemYgap + itemImageHeight) * items.Length + interGroupYgap;
                k++;
            }


            //gathering definitions
            SvgDefinitionList allDefs = new SvgDefinitionList();

            for (int i = 0; i < columns.Length; i++)
            {
                SvgDefinitionList defs = columns[i].Definitions;
                foreach (SvgPatternServer def in defs.Children)
                {
                    //overridings tile size
                    allDefs.Children.Add(def);
                }
            }

            SvgDocument result = new SvgDocument();

            result.Children.Add(allDefs);
            result.Width  = Helpers.dtos(horizontalOffset);
            result.Height = Helpers.dtos((headerHeight + columnHeight + legendYGap + currGroupOffset));
            result.Fill   = new SvgColourServer(System.Drawing.Color.White);
            result.Children.Add(headerGroup);
            result.Children.Add(columnsGroup);
            result.Children.Add(legendGroup);

            return(result);
        }
Example #20
0
        public static SKPicture?ToPicture(SvgFragment svgFragment)
        {
            var picture = SvgModelExtensions.ToModel(svgFragment, _assetLoader);

            return(picture?.ToSKPicture());
        }
Example #21
0
        public SvgElement Paint(LayerVM vm, double availableWidth, double availableHeight)
        {
            if (vm is ClassificationLayerTextPresentingVM)
            {
                ClassificationLayerTextPresentingVM cltpVM = (ClassificationLayerTextPresentingVM)vm;
                if (cltpVM.Text != null)
                {
                    string[] spans = cltpVM.Text.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).ToArray();
                    SvgText  text  = new SvgText();
                    text.Transforms.Add(new Svg.Transforms.SvgTranslate((float)textXoffset, (float)(availableHeight * 0.5 + textYoffset)));
                    foreach (var span in spans)
                    {
                        SvgTextSpan tspan = new SvgTextSpan();
                        tspan.Text     = span;
                        tspan.FontSize = Helpers.dtos(fontSize);
                        tspan.Dy.Add(Helpers.dtos(fontSize * 1.2));
                        tspan.X.Add(0);
                        tspan.Fill = blackPaint;
                        text.Children.Add(tspan);
                    }
                    return(text);
                }
                else
                {
                    return(new SvgGroup());
                }
            }
            else if (vm is LengthLayerVM)
            {
                LengthLayerVM lrlcVM = (LengthLayerVM)vm;
                SvgText       text   = new SvgText(string.Format("{0:0.##} м", lrlcVM.RealLength));
                text.FontSize = Helpers.dtos(fontSize);
                text.Fill     = blackPaint;
                text.Transforms.Add(new Svg.Transforms.SvgTranslate((float)textXoffset, (float)(availableHeight * 0.5 + textYoffset)));
                return(text);
            }
            else if (vm is MultiClassificationLayerIconPresentingVM)
            {
                MultiClassificationLayerIconPresentingVM mclipVM = (MultiClassificationLayerIconPresentingVM)vm;
                SvgGroup group     = new SvgGroup();
                float    iconWidth = 32.0f;

                if (mclipVM.IconsSVG != null)
                {
                    SvgFragment[] fragments = mclipVM.IconsSVG.Where(f => f != null).ToArray();

                    if (fragments.Length == 0)
                    {
                        return(group);
                    }

                    float maxHeight = fragments.Select(f => f.Bounds.Height).Max();

                    float offset = (float)((availableWidth - fragments.Length * iconWidth) * 0.5);

                    foreach (var item in fragments)
                    {
                        SvgFragment copy = (SvgFragment)item.DeepCopy();

                        float aspectRatio = copy.Bounds.Width / copy.Bounds.Height;

                        copy.ViewBox = copy.Bounds;
                        copy.X      += offset;
                        copy.Y       = (float)(availableHeight - maxHeight) * 0.5f;
                        //copy.Transforms.Add(new Svg.Transforms.SvgScale(ratio));
                        copy.Width  = iconWidth;
                        copy.Height = iconWidth / aspectRatio;
                        group.Children.Add(copy);
                        offset += iconWidth;
                    }
                }
                return(group);
            }
            else
            {
                return(new SvgGroup());
            }
        }
Example #22
0
        public static SkiaSharp.SKPicture?ToPicture(SvgFragment svgFragment)
        {
            var picture = SvgExtensions.ToModel(svgFragment, s_assetLoader, out _, out _);

            return(picture?.ToSKPicture());
        }
Example #23
0
        public FragmentDrawable(SvgFragment svgFragment, SKRect skOwnerBounds, Drawable?root, Drawable?parent, Attributes ignoreAttributes = Attributes.None)
            : base(svgFragment, root, parent)
        {
            IgnoreAttributes = ignoreAttributes;
            IsDrawable       = HasFeatures(svgFragment, IgnoreAttributes);

            if (!IsDrawable)
            {
                return;
            }

            var svgFragmentParent = svgFragment.Parent;

            float x = svgFragmentParent == null ? 0f : svgFragment.X.ToDeviceValue(UnitRenderingType.Horizontal, svgFragment, skOwnerBounds);
            float y = svgFragmentParent == null ? 0f : svgFragment.Y.ToDeviceValue(UnitRenderingType.Vertical, svgFragment, skOwnerBounds);

            var skSize = SvgExtensions.GetDimensions(svgFragment);

            if (skOwnerBounds.IsEmpty)
            {
                skOwnerBounds = SKRect.Create(x, y, skSize.Width, skSize.Height);
            }

            CreateChildren(svgFragment, skOwnerBounds, this, this, ignoreAttributes);

            IsAntialias = SvgPaintingExtensions.IsAntialias(svgFragment);

            TransformedBounds = skOwnerBounds;

            CreateTransformedBounds();

            Transform = SvgTransformsExtensions.ToSKMatrix(svgFragment.Transforms);
            var skMatrixViewBox = SvgTransformsExtensions.ToSKMatrix(svgFragment.ViewBox, svgFragment.AspectRatio, x, y, skSize.Width, skSize.Height);

            SKMatrix.PreConcat(ref Transform, ref skMatrixViewBox);

            switch (svgFragment.Overflow)
            {
            case SvgOverflow.Auto:
            case SvgOverflow.Visible:
            case SvgOverflow.Inherit:
                break;

            default:
                if (skSize.IsEmpty)
                {
                    Overflow = SKRect.Create(
                        x,
                        y,
                        Math.Abs(TransformedBounds.Left) + TransformedBounds.Width,
                        Math.Abs(TransformedBounds.Top) + TransformedBounds.Height);
                }
                else
                {
                    Overflow = SKRect.Create(x, y, skSize.Width, skSize.Height);
                }
                break;
            }

            var clipPathUris = new HashSet <Uri>();
            var svgClipPath  = svgFragment.GetUriElementReference <SvgClipPath>("clip-path", clipPathUris);

            if (svgClipPath != null && svgClipPath.Children != null)
            {
                ClipPath = IgnoreAttributes.HasFlag(Attributes.ClipPath) ? null : SvgClippingExtensions.GetClipPath(svgClipPath, TransformedBounds, clipPathUris, _disposable);
            }
            else
            {
                ClipPath = null;
            }

            Fill   = null;
            Stroke = null;

            // TODO: Transform _skBounds using _skMatrix.
            SKMatrix.MapRect(ref Transform, out TransformedBounds, ref TransformedBounds);
        }
Example #24
0
        public static FragmentDrawable Create(SvgFragment svgFragment, Rect skOwnerBounds, DrawableBase?parent, IAssetLoader assetLoader, Attributes ignoreAttributes = Attributes.None)
        {
            var drawable = new FragmentDrawable(assetLoader)
            {
                Element          = svgFragment,
                Parent           = parent,
                IgnoreAttributes = ignoreAttributes
            };

            drawable.IsDrawable = drawable.HasFeatures(svgFragment, drawable.IgnoreAttributes);

            if (!drawable.IsDrawable)
            {
                return(drawable);
            }

            var svgFragmentParent = svgFragment.Parent;

            var x = svgFragmentParent is null ? 0f : svgFragment.X.ToDeviceValue(UnitRenderingType.Horizontal, svgFragment, skOwnerBounds);
            var y = svgFragmentParent is null ? 0f : svgFragment.Y.ToDeviceValue(UnitRenderingType.Vertical, svgFragment, skOwnerBounds);

            var skSize = SvgModelExtensions.GetDimensions(svgFragment);

            if (skOwnerBounds.IsEmpty)
            {
                skOwnerBounds = Rect.Create(x, y, skSize.Width, skSize.Height);
            }

            drawable.CreateChildren(svgFragment, skOwnerBounds, drawable, assetLoader, ignoreAttributes);

            drawable.IsAntialias = SvgModelExtensions.IsAntialias(svgFragment);

            drawable.TransformedBounds = skOwnerBounds;

            drawable.CreateTransformedBounds();

            drawable.Transform = SvgModelExtensions.ToMatrix(svgFragment.Transforms);
            var skMatrixViewBox = SvgModelExtensions.ToMatrix(svgFragment.ViewBox, svgFragment.AspectRatio, x, y, skSize.Width, skSize.Height);

            drawable.Transform = drawable.Transform.PreConcat(skMatrixViewBox);

            switch (svgFragment.Overflow)
            {
            case SvgOverflow.Auto:
            case SvgOverflow.Visible:
            case SvgOverflow.Inherit:
                break;

            default:
                if (skSize.IsEmpty)
                {
                    drawable.Overflow = Rect.Create(
                        x,
                        y,
                        Math.Abs(drawable.TransformedBounds.Left) + drawable.TransformedBounds.Width,
                        Math.Abs(drawable.TransformedBounds.Top) + drawable.TransformedBounds.Height);
                }
                else
                {
                    drawable.Overflow = Rect.Create(x, y, skSize.Width, skSize.Height);
                }
                break;
            }

            var clipPathUris = new HashSet <Uri>();
            var svgClipPath  = svgFragment.GetUriElementReference <SvgClipPath>("clip-path", clipPathUris);

            if (svgClipPath?.Children is { })