/// <summary>
/// Reloads the layer.
/// </summary>
private void ReloadLayer()
{
CATransaction.Begin();
CATransaction.AnimationDuration = kAnimationDuration;
// ------------------------------- Animate Colors
if ((mDragged && mDraggingTowardsOn) || (!mDragged && mOn))
{
mBackgroundLayer.BorderColor = this.TintColor.CGColor;
mBackgroundLayer.BackgroundColor = this.TintColor.CGColor;
}
else
{
mBackgroundLayer.BorderColor = kDisabledBorderColor.CGColor;
mBackgroundLayer.BackgroundColor = kDisabledBackgroundColor.CGColor;
}
// ------------------------------- Animate Enabled-Disabled state
mRootLayer.Opacity = (Enabled) ? kEnabledOpacity : kDisabledOpacity;
// ------------------------------- Animate Frame
if (!mDragged)
{
var function = CAMediaTimingFunction.FromControlPoints(0.25f, 1.5f, 0.5f, 1.0f);
CATransaction.AnimationTimingFunction = function;
}
mKnobLayer.Frame = RectForKnob();
mKnobInsideLayer.Frame = mKnobLayer.Bounds;
CATransaction.Commit();
}
private void StartAnimatingTransaction()
{
CATransaction.Begin();
float M_PI_2 = ((float)(Math.PI)) / 2.0f;
CGAffineTransform tnull = CGAffineTransform.MakeIdentity();
CGPath circlePath = new CGPath();
circlePath.MoveToPoint(tnull, Frame.Width / 2.0f, Frame.Height - circleSize / 2.0f);
circlePath.AddArc(tnull, Frame.Width / 2.0f, Frame.Height / 2.0f, radius - 15 / 2, M_PI_2, -M_PI_2 * 3, false);
for (int i = 0; i < Layer.Sublayers.Length; i++)
{
CALayer circleLayer = Layer.Sublayers[i];
CAKeyFrameAnimation circleAnimation = CAKeyFrameAnimation.GetFromKeyPath("position");
circleAnimation.BeginTime = CAAnimation.CurrentMediaTime() + 0.2f * i;
circleAnimation.Duration = 1.5;
circleAnimation.TimingFunction = CAMediaTimingFunction.FromControlPoints(0.15f, 0.60f, 0.85f, 0.4f);
circleAnimation.CalculationMode = CAKeyFrameAnimation.AnimationPaced;
circleAnimation.Path = circlePath;
circleAnimation.RepeatCount = float.MaxValue;
if (circleLayer == this.Layer.Sublayers[Layer.Sublayers.Length - 1])
{
circleAnimation.WeakDelegate = this;
}
circleLayer.AddAnimation(circleAnimation, "circleAnimation");
}
//CGPathRelease(circlePath);
CATransaction.Commit();
}
public void HideAnimated(bool animated, Action completion)
{
CATransaction.Begin();
{
CATransaction.CompletionBlock = () =>
{
completion?.Invoke();
Layer.Transform = CATransform3D.Identity;
};
if (animated)
{
Layer.AnimateKey(new NSString("transform"), null,
NSValue.FromCATransform3D(CATransform3D.MakeScale(0.5f, 0.5f, 1)),
(animation) =>
{
animation.Duration = 0.55;
animation.TimingFunction = CAMediaTimingFunction.FromControlPoints(0.1f, -2, 0.3f, 3);
});
Layer.AnimateKey(new NSString("opacity"), null,
NSObject.FromObject(0.0), (animation) =>
{
animation.Duration = 0.75;
});
}
else // not animated - just set opacity to 0.0
{
Layer.Opacity = 0.0f;
}
}
CATransaction.Commit();
}
public void ShowAnimated(bool animated)
{
if (!animated)
{
Layer.Opacity = 1.0f;
return;
}
CATransaction.Begin();
{
// start the transform animation from scale 0.5, or its current value if it's already running
NSObject fromValue = Layer.AnimationForKey("transform") != null
? Layer.PresentationLayer.ValueForKey(new NSString("transform"))
: NSValue.FromCATransform3D(CATransform3D.MakeScale(0.5f, 0.5f, 1));
Layer.AnimateKey(new NSString("transform"),
fromValue,
NSValue.FromCATransform3D(CATransform3D.Identity),
(animation) =>
{
animation.Duration = 0.4;
animation.TimingFunction = CAMediaTimingFunction.FromControlPoints(0.8f, 2.5f, 0.35f, 0.5f);
});
Layer.AnimateKey(new NSString("opacity"), null, NSObject.FromObject(1.0), (animation) =>
{
animation.Duration = 0.1;
});
}
CATransaction.Commit();
}
public void GetControlPoint()
{
using (CAMediaTimingFunction mtf = CAMediaTimingFunction.FromControlPoints(0.1f, 0.2f, 0.3f, 0.4f)) {
Assert.Throws <ArgumentOutOfRangeException> (delegate { mtf.GetControlPoint(-1); });
Assert.That(mtf.GetControlPoint(0), Is.EqualTo(new PointF(0.0f, 0.0f)), "0");
Assert.That(mtf.GetControlPoint(1), Is.EqualTo(new PointF(0.1f, 0.2f)), "1");
Assert.That(mtf.GetControlPoint(2), Is.EqualTo(new PointF(0.3f, 0.4f)), "2");
Assert.That(mtf.GetControlPoint(3), Is.EqualTo(new PointF(1.0f, 1.0f)), "3");
Assert.Throws <ArgumentOutOfRangeException> (delegate { mtf.GetControlPoint(4); });
}
}
private void Setup()
{
bounceView = new BounceView();
AddSubview(bounceView);
WaveBounceDuration = 0.8;
BallSize = 36f;
PullDistance = 96f;
BendDistance = 40f;
BallMovementTimingFunction = CAMediaTimingFunction.FromControlPoints(0.49f, 0.13f, 0.29f, 1.61f);
BallMoveUpDuration = 0.25;
}
private static CAMediaTimingFunction GetSineTimingFunction(EasingMode easingMode)
{
switch (easingMode)
{
case EasingMode.EaseIn:
return(CAMediaTimingFunction.FromControlPoints(0.47f, 0.0f, 0.745f, 0.715f));
case EasingMode.EaseOut:
return(CAMediaTimingFunction.FromControlPoints(0.39f, 0.575f, 0.565f, 1.0f));
case EasingMode.EaseInOut:
return(CAMediaTimingFunction.FromControlPoints(0.445f, 0.05f, 0.55f, 0.95f));
}
return(GetDefaultTimingFunction());
}
private static CAMediaTimingFunction GetQuinticTimingFunction(EasingMode easingMode)
{
switch (easingMode)
{
case EasingMode.EaseIn:
return(CAMediaTimingFunction.FromControlPoints(0.755f, 0.05f, 0.855f, 0.06f));
case EasingMode.EaseOut:
return(CAMediaTimingFunction.FromControlPoints(0.23f, 1.0f, 0.320f, 1.0f));
case EasingMode.EaseInOut:
return(CAMediaTimingFunction.FromControlPoints(0.86f, 0.0f, 0.07f, 1.0f));
}
return(GetDefaultTimingFunction());
}
public static void Rotate(this UIView view, float duration, float rotations = 1.0f, bool repeat = false, bool bounce = false)
{
var animation = CABasicAnimation.FromKeyPath("transform.rotation.z");
animation.To = NSNumber.FromFloat((float)Math.PI * 2.0f * rotations * duration);
animation.Duration = duration;
animation.Cumulative = true;
animation.RepeatCount = rotations;
if (bounce)
{
animation.TimingFunction = CAMediaTimingFunction.FromControlPoints(0.5f, 1.8f, 0.5f, 0.8f);
}
view.Layer.AddAnimation(animation, "rotationAnimation");
}
private static CAMediaTimingFunction GetBackTimingFunction(EasingMode easingMode)
{
switch (easingMode)
{
case EasingMode.EaseIn:
return(CAMediaTimingFunction.FromControlPoints(0.6f, -0.28f, 0.735f, 0.045f));
case EasingMode.EaseOut:
return(CAMediaTimingFunction.FromControlPoints(0.175f, 0.885f, 0.320f, 1.275f));
case EasingMode.EaseInOut:
return(CAMediaTimingFunction.FromControlPoints(0.68f, -0.55f, 0.265f, 1.55f));
}
return(GetDefaultTimingFunction());
}
private static CAMediaTimingFunction GetQuarticTimingFunction(EasingMode easingMode)
{
switch (easingMode)
{
case EasingMode.EaseIn:
return(CAMediaTimingFunction.FromControlPoints(0.895f, 0.03f, 0.685f, 0.22f));
case EasingMode.EaseOut:
return(CAMediaTimingFunction.FromControlPoints(0.165f, 0.84f, 0.44f, 1.0f));
case EasingMode.EaseInOut:
return(CAMediaTimingFunction.FromControlPoints(0.77f, 0.0f, 0.175f, 1.0f));
}
return(GetDefaultTimingFunction());
}
private static CAMediaTimingFunction GetCubicTimingFunction(EasingMode easingMode)
{
switch (easingMode)
{
case EasingMode.EaseIn:
return(CAMediaTimingFunction.FromControlPoints(0.55f, 0.055f, 0.675f, 0.19f));
case EasingMode.EaseOut:
return(CAMediaTimingFunction.FromControlPoints(0.215f, 0.61f, 0.355f, 1.0f));
case EasingMode.EaseInOut:
return(CAMediaTimingFunction.FromControlPoints(0.645f, 0.045f, 0.355f, 1.0f));
}
return(GetDefaultTimingFunction());
}
private static CAMediaTimingFunction GetQuadraticTimingFunction(EasingMode easingMode)
{
switch (easingMode)
{
case EasingMode.EaseIn:
return(CAMediaTimingFunction.FromControlPoints(0.55f, 0.085f, 0.68f, 0.53f));
case EasingMode.EaseOut:
return(CAMediaTimingFunction.FromControlPoints(0.25f, 0.46f, 0.45f, 0.94f));
case EasingMode.EaseInOut:
return(CAMediaTimingFunction.FromControlPoints(0.455f, 0.03f, 0.515f, 0.955f));
}
return(GetDefaultTimingFunction());
}
void SetupLayers()
{
if (view == null || view.Bounds.Size.IsEmpty)
{
return;
}
RemoveLayers();
var width = view.Bounds.Width;
var distance = width / 5.0f / (float)shapeCount;
// replicator layer
replicatorLayer = new CAReplicatorLayer();
replicatorLayer.Frame = new CGRect(0, 0, view.Bounds.Width * 2, view.Bounds.Height);
replicatorLayer.PreservesDepth = false;
replicatorLayer.InstanceCount = (nint)shapeCount;
replicatorLayer.InstanceTransform = CATransform3D.MakeTranslation(distance, 0, 0);
replicatorLayer.InstanceDelay = -0.06f;
if (view.Layer == null)
{
view.Layer = new CALayer();
}
view.Layer.AddSublayer(replicatorLayer);
view.WantsLayer = true;
// instance layer
var dotSize = view.Bounds.Height;
var instanceLayer = new CALayer();
instanceLayer.Frame = new CGRect(-(shapeCount * distance / 2.0f) - dotSize, 0, dotSize, dotSize);
instanceLayer.BackgroundColor = shapeColor.CGColor;
instanceLayer.Bounds = new CGRect(0, 0, dotSize, dotSize);
instanceLayer.CornerRadius = dotSize / 2.0f;
replicatorLayer.AddSublayer(instanceLayer);
var runAnimation = CABasicAnimation.FromKeyPath("transform.translation.x");
runAnimation.From = NSNumber.FromDouble(-2f * width);
runAnimation.To = NSNumber.FromDouble(3f * width);
runAnimation.Duration = duration;
runAnimation.RepeatCount = float.PositiveInfinity;
runAnimation.TimingFunction = CAMediaTimingFunction.FromControlPoints(0, 1.0f - easeFactor, 1, easeFactor);
instanceLayer.AddAnimation(runAnimation, "RunAnimation");
}
/// <summary>
/// Based on information found at :
/// https://github.com/bfolder/UIView-Visuals/blob/master/CAMediaTimingFunction%2BAdditionalEquations.m
/// Those easing function try to use a bezier to best match the equivalent easing function
/// </summary>
internal static CAMediaTimingFunction GetTimingFunction(this IEasingFunction easingFunction)
{
switch (easingFunction)
{
case QuadraticEase quadraticEase:
return(GetQuadraticTimingFunction(quadraticEase.EasingMode));
case CubicEase cubicEase:
return(GetCubicTimingFunction(cubicEase.EasingMode));
case QuarticEase quarticEase:
return(GetQuarticTimingFunction(quarticEase.EasingMode));
case QuinticEase quinticEase:
return(GetQuinticTimingFunction(quinticEase.EasingMode));
case SineEase sineEase:
return(GetSineTimingFunction(sineEase.EasingMode));
case BackEase backEase:
return(GetBackTimingFunction(backEase.EasingMode));
case PowerEase powerEase:
return(GetPowerTimingFunction(powerEase.Power, powerEase.EasingMode));
// Fallback for unsupported base function
case EasingFunctionBase ease:
return(GetDefaultTimingFunction(ease.EasingMode));
case SplineEasingFunction splineEase:
var cp1 = splineEase.KeySpline.ControlPoint1;
var cp2 = splineEase.KeySpline.ControlPoint2;
return(CAMediaTimingFunction.FromControlPoints((float)cp1.X, (float)cp1.Y, (float)cp2.X, (float)cp2.Y));
default:
return(GetDefaultTimingFunction());
}
}
public void UpdateBadgeValueAnimated(bool animated)
{
// Bounce animation on badge if value changed and if animation authorized
if (animated && ShouldAnimate && Badge.Text != BadgeValue)
{
CABasicAnimation animation = new CABasicAnimation()
{
KeyPath = "transform.scale",
From = NSNumber.FromDouble(1.5),
To = NSNumber.FromDouble(1),
Duration = .2,
TimingFunction = CAMediaTimingFunction.FromControlPoints((float)0.4, (float).3, 1, 1)
};
Badge.Layer.AddAnimation(animation, "bounceAnimation");
}
// Set the new value
Badge.Text = BadgeValue;
// Animate the size modification if needed
//NSTimeInterval duration = animated ? 0.2 : 0;
//[UIView animateWithDuration:duration animations:^{
UpdateBadgeFrame();
//}]; // this animation breaks the rounded corners in iOS 9
}
void StartInkAtPoint(CGPoint point, bool animated)
{
nfloat radius = FinalRadius;
if (MaxRippleRadius > 0)
{
radius = MaxRippleRadius;
}
CGRect ovalRect = new CGRect(Bounds.Width / 2 - radius,
Bounds.Height / 2 - radius,
radius * 2,
radius * 2);
UIBezierPath circlePath = UIBezierPath.FromOval(ovalRect);
Path = circlePath.CGPath;
FillColor = InkColor.CGColor;
if (!animated)
{
Opacity = 1;
Position = new CGPoint(Bounds.Width / 2, Bounds.Height / 2);
}
else
{
Opacity = 0;
Position = point;
_startAnimationActive = true;
CAMediaTimingFunction materialTimingFunction = CAMediaTimingFunction.FromControlPoints(0.4f, 0, 0.2f, 1.0f);
nfloat scaleStart = (nfloat)(Math.Min(Bounds.Width, Bounds.Height) / MDCInkLayerScaleDivisor);
if (scaleStart < MDCInkLayerScaleStartMin)
{
scaleStart = MDCInkLayerScaleStartMin;
}
else if (scaleStart > MDCInkLayerScaleStartMax)
{
scaleStart = MDCInkLayerScaleStartMax;
}
CABasicAnimation scaleAnim = new CABasicAnimation
{
KeyPath = MDCInkLayerScaleString,
From = new NSNumber(scaleStart),
To = new NSNumber(1.0f),
Duration = MDCInkLayerStartScalePositionDuration,
BeginTime = MDCInkLayerCommonDuration,
TimingFunction = materialTimingFunction,
FillMode = CAFillMode.Forwards,
RemovedOnCompletion = true
};
UIBezierPath centerPath = new UIBezierPath();
CGPoint startPoint = point;
CGPoint endPoint = new CGPoint(Bounds.Width / 2, Bounds.Height / 2);
centerPath.MoveTo(startPoint);
centerPath.AddLineTo(endPoint);
centerPath.ClosePath();
CAKeyFrameAnimation positionAnim = new CAKeyFrameAnimation
{
KeyPath = MDCInkLayerPositionString,
Path = centerPath.CGPath,
KeyTimes = new NSNumber[] { 0, 1.0f },
Values = new NSNumber[] { 0, 1.0f },
Duration = MDCInkLayerStartScalePositionDuration,
BeginTime = MDCInkLayerCommonDuration,
TimingFunction = materialTimingFunction,
FillMode = CAFillMode.Forwards,
RemovedOnCompletion = false
};
CABasicAnimation fadeInAnim = new CABasicAnimation();
fadeInAnim.KeyPath = MDCInkLayerOpacityString;
fadeInAnim.From = new NSNumber(0);
fadeInAnim.To = new NSNumber(1.0f);
fadeInAnim.Duration = MDCInkLayerCommonDuration;
fadeInAnim.BeginTime = MDCInkLayerCommonDuration;
fadeInAnim.TimingFunction = CAMediaTimingFunction.FromName(CAMediaTimingFunction.Linear);
fadeInAnim.FillMode = CAFillMode.Forwards;
fadeInAnim.RemovedOnCompletion = false;
CATransaction.Begin();
CAAnimationGroup animGroup = new CAAnimationGroup();
animGroup.Animations = new CAAnimation[] { scaleAnim, positionAnim, fadeInAnim };
animGroup.Duration = MDCInkLayerStartScalePositionDuration;
animGroup.FillMode = CAFillMode.Forwards;
animGroup.RemovedOnCompletion = false;
CATransaction.CompletionBlock = new Action(() => { _startAnimationActive = false; });
AddAnimation(animGroup, null);
CATransaction.Commit();
}
//if (AnimationDelegate respondsToSelector: @selector(inkLayerAnimationDidStart:))
//{
// [self.animationDelegate inkLayerAnimationDidStart:self];
//}
}
private CAMediaTimingFunction LogDecelerateEasing()
{
// This bezier curve is an approximation of a log curve.
return(CAMediaTimingFunction.FromControlPoints(0.157f, 0.72f, 0.386f, 0.987f));
}
