Esempio n. 1
0
 public void Reset(View view)
 {
     BackgroundColor.Reset(view);
     BackgroundImage.Reset(view);
     BackgroundImageBorder.Reset(view);
     Color.Reset(view);
     Opacity.Reset(view);
     ImageShadow.Reset(view);
     BoxShadow.Reset(view);
     CornerRadius.Reset(view);
 }
        public override BoxShadows Interpolate(double progress, BoxShadows oldValue, BoxShadows newValue)
        {
            int cnt = progress >= 1d ? newValue.Count : oldValue.Count;

            if (cnt == 0)
            {
                return(new BoxShadows());
            }

            BoxShadow first;

            if (oldValue.Count > 0 && newValue.Count > 0)
            {
                first = s_boxShadowAnimator.Interpolate(progress, oldValue[0], newValue[0]);
            }
            else if (oldValue.Count > 0)
            {
                first = oldValue[0];
            }
            else
            {
                first = newValue[0];
            }

            if (cnt == 1)
            {
                return(new BoxShadows(first));
            }

            var rest = new BoxShadow[cnt - 1];

            for (var c = 0; c < rest.Length; c++)
            {
                var idx = c + 1;
                if (oldValue.Count > idx && newValue.Count > idx)
                {
                    rest[c] = s_boxShadowAnimator.Interpolate(progress, oldValue[idx], newValue[idx]);
                }
                else if (oldValue.Count > idx)
                {
                    rest[c] = oldValue[idx];
                }
                else
                {
                    rest[c] = newValue[idx];
                }
            }

            return(new BoxShadows(first, rest));
        }
Esempio n. 3
0
        public object ProvideValue(IServiceProvider serviceProvider)
        {
            var bx = new BoxShadow()
            {
                IsInset = IsInset,
                Blur    = BlurRadius,
                Spread  = SpreadRadius,
                Color   = ShadowColor,
                OffsetX = HorizontalLength,
                OffsetY = VerticalLength
            };

            return(new BoxShadows(bx));
        }
Esempio n. 4
0
            public static BoxShadowFilter Create(SKPaint paint, BoxShadow shadow, double opacity)
            {
                var ac = shadow.Color;

                SKImageFilter filter = null;

                filter = SKImageFilter.CreateBlur(SkBlurRadiusToSigma(shadow.Blur), SkBlurRadiusToSigma(shadow.Blur));
                var color = new SKColor(ac.R, ac.G, ac.B, (byte)(ac.A * opacity));

                paint.Reset();
                paint.IsAntialias = true;
                paint.Color       = color;
                paint.ImageFilter = filter;

                return(new BoxShadowFilter
                {
                    Paint = paint, _filter = filter,
                    ClipOperation = shadow.IsInset ? SKClipOperation.Intersect : SKClipOperation.Difference
                });
            }
Esempio n. 5
0
        public void BoxShadow_Should_Parse()
        {
            foreach (var extraSpaces in new[] { false, true })
            {
                foreach (var inset in new[] { false, true })
                {
                    for (var componentCount = 2; componentCount < 5; componentCount++)
                    {
                        var    s      = (inset ? "inset " : "") + "10 20";
                        double blur   = 0;
                        double spread = 0;
                        if (componentCount > 2)
                        {
                            s   += " 30";
                            blur = 30;
                        }

                        if (componentCount > 3)
                        {
                            s     += " 40";
                            spread = 40;
                        }

                        s += " red";

                        if (extraSpaces)
                        {
                            s = " " + s.Replace(" ", "  ") + "   ";
                        }

                        var parsed = BoxShadow.Parse(s);
                        Assert.Equal(inset, parsed.IsInset);
                        Assert.Equal(10, parsed.OffsetX);
                        Assert.Equal(20, parsed.OffsetY);
                        Assert.Equal(blur, parsed.Blur);
                        Assert.Equal(spread, parsed.Spread);
                        Assert.Equal(Colors.Red, parsed.Color);
                    }
                }
            }
        }