Пример #1
0
        protected override void OnDraw(Android.Graphics.Canvas canvas)
        {
            var linearGradient = new Styles.Color.LinearGradient(
                new Styles.IRgb[] { ColorSwatches.FlatMint, ColorSwatches.FlatBlue },
                45
                );

            var radialGradient = new Styles.Color.RadialGradient(
                new Styles.IRgb[] { ColorSwatches.FlatMint, ColorSwatches.FlatBlue },
                .5f, .5f
                );

            var ellipticalGradient = new Styles.Color.EllipticalGradient(
                new Styles.IRgb[] { ColorSwatches.FlatMint, ColorSwatches.FlatBlue, ColorSwatches.DeepPurple },
                .5f, .5f
                );

            ellipticalGradient.SetScale(1f, 2f);
            ellipticalGradient.Rotation = 45;

            var bounds = canvas.ClipBounds;
            var shader = ellipticalGradient.Draw(new RectF(bounds.Left, bounds.Top, bounds.Right, bounds.Bottom));

            var paint = new Paint();

            paint.SetShader(shader);

            canvas.DrawPaint(paint);
        }
 public static GradientView ToNativeView(this EllipticalGradient target, CGRect frame)
 {
     return(new GradientView(target)
     {
         Frame = frame
     });
 }
        public static void Draw(this EllipticalGradient target, CGContext ctx, CGRect bounds)
        {
            target.Update();

            CGRect clippingBounds = bounds;

            if (!target.Frame.IsEmpty)
            {
                bounds = new CGRect(target.Frame.X, target.Frame.Y, target.Frame.Width, target.Frame.Height);
            }

            var gradColors   = GenerateGradientColors(target.Colors);
            var colorSpace   = CGColorSpace.CreateDeviceRGB();
            var grad         = new CGGradient(colorSpace, gradColors, ConvertToNativeArray(target.Locations));
            var gradCenter   = new CGPoint((bounds.Width * target.Center.X), (bounds.Height * target.Center.Y));
            var gradRadius   = (nfloat)Math.Min(bounds.Size.Width / 2, bounds.Size.Height / 2);
            var drawingFlags = GetGradientFlags(target);
            var scaleT       = CGAffineTransform.MakeScale(target.Scale.X, target.Scale.Y);

            ctx.SaveState();
            if (!target.Frame.IsEmpty)
            {
                ctx.ClipToRect(new CGRect(bounds.X + clippingBounds.X, bounds.Y + clippingBounds.Y, clippingBounds.Width, clippingBounds.Height));
            }

            ctx.TranslateCTM(bounds.X + gradCenter.X, bounds.Y + gradCenter.Y);
            ctx.RotateCTM((nfloat)(target.Rotation * (Math.PI / 180)));
            ctx.ScaleCTM(scaleT.xx, scaleT.yy);
            ctx.DrawRadialGradient(grad, CGPoint.Empty, 0, CGPoint.Empty, gradRadius, drawingFlags);
            ctx.RestoreState();

            grad.Dispose();
            colorSpace.Dispose();
        }
 public static CALayer ToNativeLayer(this EllipticalGradient target, CGRect frame)
 {
     return(new GradientLayer(target)
     {
         Frame = frame
     });
 }
        public static Shader Draw(this EllipticalGradient target, RectF bounds)
        {
            target.Update();

            var center = new PointF((bounds.Width() * target.Center.X), (bounds.Height() * target.Center.Y));
            var radius = (float)Math.Min(bounds.Width() / 2f, bounds.Height() / 2f);

            var grad = new Android.Graphics.RadialGradient(
                center.X, center.Y, radius,
                target.Colors.ToInt(),
                target.Locations,
                Shader.TileMode.Clamp
                );

            Matrix matrix = new Matrix();

            matrix.SetScale(target.Scale.X, target.Scale.Y, center.X, center.Y);
            matrix.PostRotate((float)target.Rotation, center.X, center.Y);
            grad.SetLocalMatrix(matrix);

            return(grad);
        }
Пример #6
0
 public GradientLayer(EllipticalGradient gradient)
 {
     this.ellipticalGradient = gradient;
     Type = GradientType.Ellipse;
     Initalize();
 }
Пример #7
0
 public GradientView(EllipticalGradient gradient)
 {
     this.ellipticalGradient = gradient;
     Type            = GradientType.Ellipse;
     BackgroundColor = UIColor.Clear;
 }