Ejemplo n.º 1
0
        public override ShapeBorder lerpTo(ShapeBorder b, float t)
        {
            if (b is RoundedRectangleBorder rectBorder)
            {
                return(new _RoundedRectangleToCircleBorder(
                           side: BorderSide.lerp(side, rectBorder.side, t),
                           borderRadius: BorderRadius.lerp(borderRadius, rectBorder.borderRadius, t),
                           circleness: circleness * (1.0f - t)
                           ));
            }

            if (b is CircleBorder circleBorder)
            {
                return(new _RoundedRectangleToCircleBorder(
                           side: BorderSide.lerp(side, circleBorder.side, t),
                           borderRadius: borderRadius,
                           circleness: circleness + (1.0f - circleness) * t
                           ));
            }

            if (b is _RoundedRectangleToCircleBorder border)
            {
                return(new _RoundedRectangleToCircleBorder(
                           side: BorderSide.lerp(side, border.side, t),
                           borderRadius: BorderRadius.lerp(borderRadius, border.borderRadius, t),
                           circleness: MathUtils.lerpNullableFloat(circleness, border.circleness, t)
                           ));
            }

            return(base.lerpTo(b, t));
        }
Ejemplo n.º 2
0
        public override ShapeBorder lerpFrom(ShapeBorder a, float t)
        {
            if (a is StadiumBorder stadiumBorder)
            {
                return(new _StadiumToRoundedRectangleBorder(
                           side: BorderSide.lerp(stadiumBorder.side, side, t),
                           borderRadius: borderRadius,
                           rectness: rectness * t
                           ));
            }

            if (a is RoundedRectangleBorder rectBorder)
            {
                return(new _StadiumToRoundedRectangleBorder(
                           side: BorderSide.lerp(rectBorder.side, side, t),
                           borderRadius: borderRadius,
                           rectness: rectness + (1.0f - rectness) * (1.0f - t)
                           ));
            }

            if (a is _StadiumToRoundedRectangleBorder border)
            {
                return(new _StadiumToRoundedRectangleBorder(
                           side: BorderSide.lerp(border.side, side, t),
                           borderRadius: BorderRadius.lerp(border.borderRadius, borderRadius, t),
                           rectness: MathUtils.lerpNullableFloat(border.rectness, rectness, t)
                           ));
            }

            return(base.lerpFrom(a, t));
        }
Ejemplo n.º 3
0
 public override ShapeBorder lerpFrom(ShapeBorder a, double t)
 {
     if (a is StadiumBorder stadiumBorder)
     {
         return(new _StadiumToRoundedRectangleBorder(
                    side: BorderSide.lerp(stadiumBorder.side, this.side, t),
                    borderRadius: this.borderRadius,
                    rectness: this.rectness * t
                    ));
     }
     if (a is RoundedRectangleBorder rectBorder)
     {
         return(new _StadiumToRoundedRectangleBorder(
                    side: BorderSide.lerp(rectBorder.side, this.side, t),
                    borderRadius: this.borderRadius,
                    rectness: this.rectness + (1.0 - this.rectness) * (1.0 - t)
                    ));
     }
     if (a is _StadiumToRoundedRectangleBorder border)
     {
         return(new _StadiumToRoundedRectangleBorder(
                    side: BorderSide.lerp(border.side, this.side, t),
                    borderRadius: BorderRadius.lerp(border.borderRadius, this.borderRadius, t),
                    rectness: MathUtils.lerpDouble(border.rectness, this.rectness, t)
                    ));
     }
     return(base.lerpFrom(a, t));
 }
Ejemplo n.º 4
0
        public override ShapeBorder lerpFrom(ShapeBorder a, float t)
        {
            if (a is RoundedRectangleBorder rectBorder)
            {
                return(new _RoundedRectangleToCircleBorder(
                           side: BorderSide.lerp(rectBorder.side, this.side, t),
                           borderRadius: BorderRadius.lerp(rectBorder.borderRadius, this.borderRadius, t),
                           circleness: this.circleness * t
                           ));
            }

            if (a is CircleBorder circleBorder)
            {
                return(new _RoundedRectangleToCircleBorder(
                           side: BorderSide.lerp(circleBorder.side, this.side, t),
                           borderRadius: this.borderRadius,
                           circleness: this.circleness + (1.0f - this.circleness) * (1.0f - t)
                           ));
            }

            if (a is _RoundedRectangleToCircleBorder border)
            {
                return(new _RoundedRectangleToCircleBorder(
                           side: BorderSide.lerp(border.side, this.side, t),
                           borderRadius: BorderRadius.lerp(border.borderRadius, this.borderRadius, t),
                           circleness: MathUtils.lerpFloat(border.circleness, this.circleness, t)
                           ));
            }

            return(base.lerpFrom(a, t));
        }
Ejemplo n.º 5
0
        public override ShapeBorder lerpTo(ShapeBorder b, double t)
        {
            if (b is RoundedRectangleBorder rectBorder)
            {
                return(new _RoundedRectangleToCircleBorder(
                           side: BorderSide.lerp(this.side, rectBorder.side, t),
                           borderRadius: BorderRadius.lerp(this.borderRadius, rectBorder.borderRadius, t),
                           circleness: this.circleness * (1.0 - t)
                           ));
            }

            if (b is CircleBorder circleBorder)
            {
                return(new _RoundedRectangleToCircleBorder(
                           side: BorderSide.lerp(this.side, circleBorder.side, t),
                           borderRadius: this.borderRadius,
                           circleness: this.circleness + (1.0 - this.circleness) * t
                           ));
            }

            if (b is _RoundedRectangleToCircleBorder border)
            {
                return(new _RoundedRectangleToCircleBorder(
                           side: BorderSide.lerp(this.side, border.side, t),
                           borderRadius: BorderRadius.lerp(this.borderRadius, border.borderRadius, t),
                           circleness: MathUtils.lerpDouble(this.circleness, border.circleness, t)
                           ));
            }

            return(base.lerpTo(b, t));
        }
Ejemplo n.º 6
0
        public override ShapeBorder lerpTo(ShapeBorder b, float t)
        {
            if (b is StadiumBorder stadiumBorder)
            {
                return(new _StadiumToRoundedRectangleBorder(
                           side: BorderSide.lerp(this.side, stadiumBorder.side, t),
                           borderRadius: this.borderRadius,
                           rectness: this.rectness * (1.0f - t)
                           ));
            }

            if (b is RoundedRectangleBorder rectBorder)
            {
                return(new _StadiumToRoundedRectangleBorder(
                           side: BorderSide.lerp(this.side, rectBorder.side, t),
                           borderRadius: this.borderRadius,
                           rectness: this.rectness + (1.0f - this.rectness) * t
                           ));
            }

            if (b is _StadiumToRoundedRectangleBorder border)
            {
                return(new _StadiumToRoundedRectangleBorder(
                           side: BorderSide.lerp(this.side, border.side, t),
                           borderRadius: BorderRadius.lerp(this.borderRadius, border.borderRadius, t),
                           rectness: MathUtils.lerpFloat(this.rectness, border.rectness, t)
                           ));
            }

            return(base.lerpTo(b, t));
        }
Ejemplo n.º 7
0
 BorderRadius _adjustBorderRadius(Rect rect)
 {
     return(BorderRadius.lerp(
                this.borderRadius,
                BorderRadius.all(Radius.circular(rect.shortestSide / 2.0f)),
                1.0f - this.rectness
                ));
 }
Ejemplo n.º 8
0
 public override ShapeBorder lerpTo(ShapeBorder b, double t)
 {
     if (b is BeveledRectangleBorder border)
     {
         return(new BeveledRectangleBorder(
                    side: BorderSide.lerp(this.side, border.side, t),
                    borderRadius: BorderRadius.lerp(this.borderRadius, border.borderRadius, t)
                    ));
     }
     return(base.lerpTo(b, t));
 }
Ejemplo n.º 9
0
        BorderRadius _adjustBorderRadius(Rect rect)
        {
            BorderRadius resolvedRadius = this.borderRadius;

            if (this.circleness == 0.0f)
            {
                return(resolvedRadius);
            }

            return(BorderRadius.lerp(resolvedRadius, BorderRadius.circular(rect.shortestSide / 2.0f), this.circleness));
        }
Ejemplo n.º 10
0
        BorderRadius _adjustBorderRadius(Rect rect, TextDirection?textDirection)
        {
            BorderRadius resolvedRadius = borderRadius.resolve(textDirection);

            if (circleness == 0.0f)
            {
                return(resolvedRadius);
            }

            return(BorderRadius.lerp(resolvedRadius, BorderRadius.circular(rect.shortestSide / 2.0f), circleness));
        }
Ejemplo n.º 11
0
 public override ShapeBorder lerpFrom(ShapeBorder a, double t)
 {
     if (a is BeveledRectangleBorder border)
     {
         return(new BeveledRectangleBorder(
                    side: BorderSide.lerp(border.side, this.side, t),
                    borderRadius: BorderRadius.lerp(border.borderRadius, this.borderRadius, t)
                    ));
     }
     return(base.lerpFrom(a, t));
 }
 public override ShapeBorder lerpTo(ShapeBorder b, float t)
 {
     if (b is ContinuousRectangleBorder)
     {
         return(new ContinuousRectangleBorder(
                    side: BorderSide.lerp(this.side, (b as ContinuousRectangleBorder).side, t),
                    borderRadius: BorderRadius.lerp(this.borderRadius,
                                                    (b as ContinuousRectangleBorder).borderRadius, t)
                    ));
     }
     return(base.lerpTo(b, t));
 }
 public override ShapeBorder lerpFrom(ShapeBorder a, float t)
 {
     if (a is ContinuousRectangleBorder)
     {
         return(new ContinuousRectangleBorder(
                    side: BorderSide.lerp((a as ContinuousRectangleBorder).side, this.side, t),
                    borderRadius: BorderRadius.lerp((a as ContinuousRectangleBorder).borderRadius,
                                                    this.borderRadius, t)
                    ));
     }
     return(base.lerpFrom(a, t));
 }
 public BoxDecoration scale(float factor)
 {
     return(new BoxDecoration(
                color: Color.lerp(null, this.color, factor),
                image: this.image,
                border: Border.lerp(null, this.border, factor),
                borderRadius: BorderRadius.lerp(null, this.borderRadius, factor),
                boxShadow: BoxShadow.lerpList(null, this.boxShadow, factor),
                gradient: this.gradient?.scale(factor),
                backgroundBlendMode: this.backgroundBlendMode,
                shape: this.shape
                ));
 }
Ejemplo n.º 15
0
        public override ShapeBorder lerpFrom(ShapeBorder a, float t)
        {
            if (a is RoundedRectangleBorder border)
            {
                return(new RoundedRectangleBorder(
                           side: BorderSide.lerp(border.side, side, t),
                           borderRadius: BorderRadius.lerp(border.borderRadius, borderRadius, t)
                           ));
            }

            if (a is CircleBorder circleBorder)
            {
                return(new _RoundedRectangleToCircleBorder(
                           side: BorderSide.lerp(circleBorder.side, side, t),
                           borderRadius: borderRadius,
                           circleness: 1.0f - t
                           ));
            }

            return(base.lerpFrom(a, t));
        }
Ejemplo n.º 16
0
        public override ShapeBorder lerpTo(ShapeBorder b, float t)
        {
            if (b is RoundedRectangleBorder border)
            {
                return(new RoundedRectangleBorder(
                           side: BorderSide.lerp(side, border.side, t),
                           borderRadius: BorderRadius.lerp(borderRadius, border.borderRadius, t)
                           ));
            }

            if (b is CircleBorder circleBorder)
            {
                return(new _RoundedRectangleToCircleBorder(
                           side: BorderSide.lerp(side, circleBorder.side, t),
                           borderRadius: borderRadius,
                           circleness: t
                           ));
            }

            return(base.lerpTo(b, t));
        }
        public static BoxDecoration lerp(BoxDecoration a, BoxDecoration b, float t)
        {
            if (a == null && b == null)
            {
                return(null);
            }

            if (a == null)
            {
                return(b.scale(t));
            }

            if (b == null)
            {
                return(a.scale(1.0f - t));
            }

            if (t == 0.0)
            {
                return(a);
            }

            if (t == 1.0)
            {
                return(b);
            }

            return(new BoxDecoration(
                       color: Color.lerp(a.color, b.color, t),
                       image: t < 0.5 ? a.image : b.image,
                       border: Border.lerp(a.border, b.border, t),
                       borderRadius: BorderRadius.lerp(a.borderRadius, b.borderRadius, t),
                       boxShadow: BoxShadow.lerpList(a.boxShadow, b.boxShadow, t),
                       gradient: Gradient.lerp(a.gradient, b.gradient, t),
                       backgroundBlendMode: t < 0.5 ? a.backgroundBlendMode : b.backgroundBlendMode,
                       shape: t < 0.5 ? a.shape : b.shape
                       ));
        }