Skip to content

M
Material
Commit 486cab29 by Daniel Dahan
Options

development: refactors Animation class

parent c97e64b6
Showing with 340 additions and 209 deletions
Sources/iOS/Animation.swift
......@@ -57,20 +57,21 @@ public func AnimationFillModeToValue(mode: AnimationFillMode) -> String {
@objc(AnimationTimingFunction)
public enum AnimationTimingFunction: Int {
case liner
case linear
case easeIn
case easeOut
case easeInEaseOut
case systemDefault
case `default`
}
/**
Converts the AnimationTimingFunction enum value to a corresponding CAMediaTimingFunction.
- Parameter function: An AnimationTimingFunction enum value.
- Returns: A CAMediaTimingFunction.
*/
public func AnimationTimingFunctionToValue(function: AnimationTimingFunction) -> CAMediaTimingFunction {
switch function {
case .liner:
case .linear:
return CAMediaTimingFunction(name: kCAMediaTimingFunctionLinear)
case .easeIn:
return CAMediaTimingFunction(name: kCAMediaTimingFunctionEaseIn)
......@@ -78,18 +79,23 @@ public func AnimationTimingFunctionToValue(function: AnimationTimingFunction) ->
return CAMediaTimingFunction(name: kCAMediaTimingFunctionEaseOut)
case .easeInEaseOut:
return CAMediaTimingFunction(name: kCAMediaTimingFunctionEaseInEaseOut)
case .systemDefault:
case .default:
return CAMediaTimingFunction(name: kCAMediaTimingFunctionDefault)
}
}
public typealias AnimationDelayCancelBlock = (Bool) -> Void
public struct Animation {
/// Delay helper method.
/**
Executes a block of code after a time delay.
- Parameter duration: An animation duration time.
- Parameter animations: An animation block.
- Parameter execute block: A completion block that is executed once
the animations have completed.
*/
@discardableResult
public static func delay(time: TimeInterval, completion: @escaping () -> Void) -> AnimationDelayCancelBlock? {
public static func delay(time: TimeInterval, execute block: @escaping () -> Void) -> AnimationDelayCancelBlock? {
func asyncAfter(completion: @escaping () -> Void) {
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + time, execute: completion)
......@@ -97,10 +103,11 @@ public struct Animation {
var cancelable: AnimationDelayCancelBlock?
let delayed: AnimationDelayCancelBlock = { (cancel) in
if !cancel {
DispatchQueue.main.async(execute: completion)
let delayed: AnimationDelayCancelBlock = {
if !$0 {
DispatchQueue.main.async(execute: block)
}
cancelable = nil
}
......@@ -114,24 +121,30 @@ public struct Animation {
}
/**
:name: delayCancel
*/
public static func delayCancel(completion: AnimationDelayCancelBlock) {
Cancels the delayed AnimationDelayCancelBlock.
- Parameter delayed completion: An AnimationDelayCancelBlock.
*/
public static func cancel(delayed completion: AnimationDelayCancelBlock) {
completion(true)
}
/**
:name: animationDisabled
*/
public static func animationDisabled(animations: (() -> Void)) {
animateWithDuration(duration: 0, animations: animations)
Disables the default animations set on CALayers.
- Parameter animations: A callback that wraps the animations to disable.
*/
public static func disable(animations: (() -> Void)) {
animate(duration: 0, animations: animations)
}
/**
:name: animateWithDuration
*/
public static func animateWithDuration(duration: CFTimeInterval, animations: (() -> Void), completion: (() -> Void)? = nil) {
Runs an animation with a specified duration.
- Parameter duration: An animation duration time.
- Parameter animations: An animation block.
- Parameter completion: A completion block that is executed once
the animations have completed.
*/
public static func animate(duration: CFTimeInterval, animations: (() -> Void), completion: (() -> Void)? = nil) {
CATransaction.begin()
CATransaction.setAnimationDuration(duration)
CATransaction.setCompletionBlock(completion)
......@@ -141,9 +154,12 @@ public struct Animation {
}
/**
:name: animationGroup
*/
public static func animationGroup(animations: [CAAnimation], duration: CFTimeInterval = 0.5) -> CAAnimationGroup {
Creates a CAAnimationGroup.
- Parameter animations: An Array of CAAnimation objects.
- Parameter duration: An animation duration time for the group.
- Returns: A CAAnimationGroup.
*/
public static func animate(group animations: [CAAnimation], duration: CFTimeInterval = 0.5) -> CAAnimationGroup {
let group: CAAnimationGroup = CAAnimationGroup()
group.fillMode = AnimationFillModeToValue(mode: .forwards)
group.isRemovedOnCompletion = false
......@@ -154,11 +170,16 @@ public struct Animation {
}
/**
:name: animateWithDelay
*/
public static func animateWithDelay(delay d: CFTimeInterval, duration: CFTimeInterval, animations: @escaping (() -> Void), completion: (() -> Void)? = nil) {
delay(time: d) {
animateWithDuration(duration: duration, animations: animations, completion: completion)
Executes an animation block with a given delay and duration.
- Parameter delay time: A CFTimeInterval.
- Parameter duration: An animation duration time.
- Parameter animations: An animation block.
- Parameter completion: A completion block that is executed once
the animations have completed.
*/
public static func animate(delay time: CFTimeInterval, duration: CFTimeInterval, animations: @escaping (() -> Void), completion: (() -> Void)? = nil) {
delay(time: time) {
animate(duration: duration, animations: animations, completion: completion)
}
}
}
Sources/iOS/BasicAnimation.swift
......@@ -30,159 +30,213 @@
import UIKit
public enum AnimationKey: String {
public enum AnimationKeyPath: String {
case backgroundColor
case cornerRadius
case transform
case transformRotation = "transform.rotation"
case transformRotationX = "transform.rotation.x"
case transformRotationY = "transform.rotation.y"
case transformRotationZ = "transform.rotation.z"
case transformScale = "transform.scale"
case transformScaleX = "transform.scale.x"
case transformScaleY = "transform.scale.y"
case transformScaleZ = "transform.scale.z"
case transformTranslation = "transform.translation"
case transformTranslationX = "transform.translation.x"
case transformTranslationY = "transform.translation.y"
case transformTranslationZ = "transform.translation.z"
case rotation = "transform.rotation"
case rotationX = "transform.rotation.x"
case rotationY = "transform.rotation.y"
case rotationZ = "transform.rotation.z"
case scale = "transform.scale"
case scaleX = "transform.scale.x"
case scaleY = "transform.scale.y"
case scaleZ = "transform.scale.z"
case translation = "transform.translation"
case translationX = "transform.translation.x"
case translationY = "transform.translation.y"
case translationZ = "transform.translation.z"
case position
case shadowPath
}
extension CABasicAnimation {
convenience init(keyPath key: AnimationKey) {
self.init(keyPath: key.rawValue)
/**
A convenience initializer that takes a given AnimationKeyPath.
- Parameter keyPath: An AnimationKeyPath.
*/
public convenience init(keyPath: AnimationKeyPath) {
self.init(keyPath: keyPath.rawValue)
}
}
extension Animation {
/**
:name: backgroundColor
*/
Creates a CABasicAnimation for the backgroundColor key path.
- Parameter color: A UIColor.
- Parameter duration: An animation time duration.
- Returns: A CABasicAnimation.
*/
public static func backgroundColor(color: UIColor, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .backgroundColor)
animation.toValue = color.cgColor
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.isRemovedOnCompletion = false
animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
if let v = duration {
if let v = duration {
animation.duration = v
}
return animation
return animation
}
/**
:name: cornerRadius
*/
public static func cornerRadius(radius: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
/**
Creates a CABasicAnimation for the cornerRadius key path.
- Parameter radius: A CGFloat.
- Parameter duration: An animation time duration.
- Returns: A CABasicAnimation.
*/
public static func cornerRadius(radius: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .cornerRadius)
animation.toValue = radius
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.isRemovedOnCompletion = false
animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
if let v = duration {
if let v = duration {
animation.duration = v
}
return animation
return animation
}
/**
:name: translation
*/
public static func transform(transform: CATransform3D, duration: CFTimeInterval? = nil) -> CABasicAnimation {
/**
Creates a CABasicAnimation for the transform key path.
- Parameter transform: A CATransform3D object.
- Parameter duration: An animation time duration.
- Returns: A CABasicAnimation.
*/
public static func transform(transform: CATransform3D, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .transform)
animation.toValue = NSValue(caTransform3D: transform)
animation.toValue = NSValue(caTransform3D: transform)
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.isRemovedOnCompletion = false
animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
if let v = duration {
if let v = duration {
animation.duration = v
}
return animation
return animation
}
/**
:name: rotate
*/
public static func rotate(angle: CGFloat? = nil, rotation: CGFloat? = nil, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .transformRotation)
if let v: CGFloat = angle {
/**
Creates a CABasicAnimation for the transform.rotation key path.
- Parameter angle: An optional CGFloat.
- Parameter rotation: An optional CGFloat.
- Parameter duration: An animation time duration.
- Returns: A CABasicAnimation.
*/
public static func rotate(angle: CGFloat? = nil, rotation: CGFloat? = nil, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .rotation)
if let v = angle {
animation.toValue = (CGFloat(M_PI) * v / 180) as NSNumber
} else if let v: CGFloat = rotation {
} else if let v = rotation {
animation.toValue = (CGFloat(M_PI * 2) * v) as NSNumber
}
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.isRemovedOnCompletion = false
animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
if let v = duration {
if let v = duration {
animation.duration = v
}
return animation
}
/**
:name: rotateX
*/
public static func rotateX(angle: CGFloat? = nil, rotation: CGFloat? = nil, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .transformRotationX)
if let v: CGFloat = angle {
/**
Creates a CABasicAnimation for the transform.rotation.x key path.
- Parameter angle: An optional CGFloat.
- Parameter rotation: An optional CGFloat.
- Parameter duration: An animation time duration.
- Returns: A CABasicAnimation.
*/
public static func rotateX(angle: CGFloat? = nil, rotation: CGFloat? = nil, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .rotationX)
if let v: CGFloat = angle {
animation.toValue = (CGFloat(M_PI) * v / 180) as NSNumber
} else if let v: CGFloat = rotation {
animation.toValue = (CGFloat(M_PI * 2) * v) as NSNumber
}
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.isRemovedOnCompletion = false
animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
if let v = duration {
if let v = duration {
animation.duration = v
}
return animation
return animation
}
/**
:name: rotateY
*/
public static func rotateY(angle: CGFloat? = nil, rotation: CGFloat? = nil, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .transformRotationY)
if let v: CGFloat = angle {
/**
Creates a CABasicAnimation for the transform.rotation.y key path.
- Parameter angle: An optional CGFloat.
- Parameter rotation: An optional CGFloat.
- Parameter duration: An animation time duration.
- Returns: A CABasicAnimation.
*/
public static func rotateY(angle: CGFloat? = nil, rotation: CGFloat? = nil, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .rotationY)
if let v: CGFloat = angle {
animation.toValue = (CGFloat(M_PI) * v / 180) as NSNumber
} else if let v: CGFloat = rotation {
animation.toValue = (CGFloat(M_PI * 2) * v) as NSNumber
}
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.isRemovedOnCompletion = false
animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
if let v = duration {
if let v = duration {
animation.duration = v
}
return animation
return animation
}
/**
:name: rotateZ
*/
public static func rotateZ(angle: CGFloat? = nil, rotation: CGFloat? = nil, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .transformRotationZ)
if let v: CGFloat = angle {
/**
Creates a CABasicAnimation for the transform.rotation.z key path.
- Parameter angle: An optional CGFloat.
- Parameter rotation: An optional CGFloat.
- Parameter duration: An animation time duration.
- Returns: A CABasicAnimation.
*/
public static func rotateZ(angle: CGFloat? = nil, rotation: CGFloat? = nil, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .rotationZ)
if let v: CGFloat = angle {
animation.toValue = (CGFloat(M_PI) * v / 180) as NSNumber
} else if let v: CGFloat = rotation {
animation.toValue = (CGFloat(M_PI * 2) * v) as NSNumber
}
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.isRemovedOnCompletion = false
animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
if let v = duration {
if let v = duration {
animation.duration = v
}
return animation
return animation
}
/**
:name: scale
*/
public static func scale(scale: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .transformScale)
/**
Creates a CABasicAnimation for the transform.scale key path.
- Parameter by scale: A CGFloat.
- Parameter duration: An animation time duration.
- Returns: A CABasicAnimation.
*/
public static func scale(by scale: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .scale)
animation.toValue = scale as NSNumber
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.isRemovedOnCompletion = false
......@@ -193,11 +247,14 @@ extension Animation {
return animation
}
/**
:name: scaleX
*/
public static func scaleX(scale: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .transformScaleX)
/**
Creates a CABasicAnimation for the transform.scale.x key path.
- Parameter by scale: A CGFloat.
- Parameter duration: An animation time duration.
- Returns: A CABasicAnimation.
*/
public static func scaleX(by scale: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .scaleX)
animation.toValue = scale as NSNumber
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.isRemovedOnCompletion = false
......@@ -208,11 +265,14 @@ extension Animation {
return animation
}
/**
:name: scaleY
*/
public static func scaleY(scale: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .transformScaleY)
/**
Creates a CABasicAnimation for the transform.scale.y key path.
- Parameter by scale: A CGFloat.
- Parameter duration: An animation time duration.
- Returns: A CABasicAnimation.
*/
public static func scaleY(by scale: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .scaleY)
animation.toValue = scale as NSNumber
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.isRemovedOnCompletion = false
......@@ -223,11 +283,14 @@ extension Animation {
return animation
}
/**
:name: scaleZ
*/
public static func scaleZ(scale: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .transformScaleZ)
/**
Creates a CABasicAnimation for the transform.scale.z key path.
- Parameter by scale: A CGFloat.
- Parameter duration: An animation time duration.
- Returns: A CABasicAnimation.
*/
public static func scaleZ(by scale: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .scaleZ)
animation.toValue = scale as NSNumber
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.isRemovedOnCompletion = false
......@@ -238,90 +301,123 @@ extension Animation {
return animation
}
/**
:name: translate
*/
public static func translate(translation: CGSize, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .transformTranslation)
animation.toValue = NSValue(cgSize: translation)
/**
Creates a CABasicAnimation for the transform.translation key path.
- Parameter size: A CGSize.
- Parameter duration: An animation time duration.
- Returns: A CABasicAnimation.
*/
public static func translation(size: CGSize, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .translation)
animation.toValue = NSValue(cgSize: size)
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.isRemovedOnCompletion = false
animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
if let v = duration {
if let v = duration {
animation.duration = v
}
return animation
return animation
}
/**
:name: translateX
*/
public static func translateX(translation: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .transformTranslationX)
/**
Creates a CABasicAnimation for the transform.translation.x key path.
- Parameter by translation: A CGFloat.
- Parameter duration: An animation time duration.
- Returns: A CABasicAnimation.
*/
public static func translationX(by translation: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .translationX)
animation.toValue = translation as NSNumber
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.isRemovedOnCompletion = false
animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
if let v = duration {
if let v = duration {
animation.duration = v
}
return animation
return animation
}
/**
:name: translateY
*/
public static func translateY(translation: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .transformTranslationY)
/**
Creates a CABasicAnimation for the transform.translation.y key path.
- Parameter by translation: A CGFloat.
- Parameter duration: An animation time duration.
- Returns: A CABasicAnimation.
*/
public static func translationY(by translation: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .translationY)
animation.toValue = translation as NSNumber
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.isRemovedOnCompletion = false
animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
if let v = duration {
if let v = duration {
animation.duration = v
}
return animation
return animation
}
/**
:name: translateZ
*/
public static func translateZ(translation: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .transformTranslationZ)
/**
Creates a CABasicAnimation for the transform.translation.z key path.
- Parameter by translation: A CGFloat.
- Parameter duration: An animation time duration.
- Returns: A CABasicAnimation.
*/
public static func translationZ(by translation: CGFloat, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .translationZ)
animation.toValue = translation as NSNumber
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.isRemovedOnCompletion = false
animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
if let v = duration {
if let v = duration {
animation.duration = v
}
return animation
return animation
}
/**
:name: position
*/
public static func position(point: CGPoint, duration: CFTimeInterval? = nil) -> CABasicAnimation {
/**
Creates a CABasicAnimation for the position key path.
- Parameter to point: A CGPoint.
- Parameter duration: An animation time duration.
- Returns: A CABasicAnimation.
*/
public static func position(to point: CGPoint, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .position)
animation.toValue = NSValue(cgPoint: point)
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.isRemovedOnCompletion = false
animation.timingFunction = AnimationTimingFunctionToValue(function: .easeInEaseOut)
if let v = duration {
if let v = duration {
animation.duration = v
}
return animation
return animation
}
public static func shadowPath(path: CGPath, duration: CFTimeInterval? = nil) -> CABasicAnimation {
/**
Creates a CABasicAnimation for the shadowPath key path.
- Parameter to path: A CGPath.
- Parameter duration: An animation time duration.
- Returns: A CABasicAnimation.
*/
public static func shadowPath(to path: CGPath, duration: CFTimeInterval? = nil) -> CABasicAnimation {
let animation = CABasicAnimation(keyPath: .shadowPath)
animation.toValue = path
animation.fillMode = AnimationFillModeToValue(mode: .forwards)
animation.isRemovedOnCompletion = false
animation.timingFunction = AnimationTimingFunctionToValue(function: .liner)
if let v = duration {
animation.timingFunction = AnimationTimingFunctionToValue(function: .linear)
if let v = duration {
animation.duration = v
}
return animation
return animation
}
}
Sources/iOS/Capture/Capture.swift
......@@ -629,7 +629,7 @@ open class Capture: View, UIGestureRecognizerDelegate {
/// Animates the tap and layer.
private func animateTap(view: UIView, point: CGPoint) {
// Animation.animationDisabled { [weak layer] in
// Animation.disable { [weak layer] in
// guard let v = layer else {
// return
// }
......@@ -644,7 +644,7 @@ open class Capture: View, UIGestureRecognizerDelegate {
// v.transform = CATransform3DMakeScale(0.5, 0.5, 1)
// }) {
// Animation.delay(time: 0.4) { [weak layer] in
// Animation.animationDisabled { [weak layer] in
// Animation.disable { [weak layer] in
// guard let v = layer else {
// return
// }
......
Sources/iOS/KeyframeAnimation.swift
......@@ -32,19 +32,21 @@ import UIKit
@objc(AnimationRotationMode)
public enum AnimationRotationMode: Int {
case none
case `default`
case auto
case autoReverse
}
/**
:name: AnimationRotationModeToValue
*/
Converts an AnimationRotationMode to a corresponding CAAnimationRotate key.
- Parameter mode: An AnimationRotationMode.
- Returns: An optional CAAnimationRotate key String.
*/
public func AnimationRotationModeToValue(mode: AnimationRotationMode) -> String? {
switch mode {
case .none:
return nil
case .auto:
case .default:
return nil
case .auto:
return kCAAnimationRotateAuto
case .autoReverse:
return kCAAnimationRotateAutoReverse
......@@ -53,11 +55,15 @@ public func AnimationRotationModeToValue(mode: AnimationRotationMode) -> String?
extension Animation {
/**
:name: path
*/
Creates a CAKeyframeAnimation.
- Parameter bezierPath: A UIBezierPath.
- Parameter mode: An AnimationRotationMode.
- Parameter duration: An animation duration time.
- Returns: A CAKeyframeAnimation.
*/
public static func path(bezierPath: UIBezierPath, mode: AnimationRotationMode = .auto, duration: CFTimeInterval? = nil) -> CAKeyframeAnimation {
let animation: CAKeyframeAnimation = CAKeyframeAnimation()
animation.keyPath = AnimationKey.position.rawValue
let animation = CAKeyframeAnimation()
animation.keyPath = AnimationKeyPath.position.rawValue
animation.path = bezierPath.cgPath
animation.rotationMode = AnimationRotationModeToValue(mode: mode)
if let v = duration {
......
Sources/iOS/Material+CALayer.swift
......@@ -321,7 +321,7 @@ extension CALayer {
} else if nil == shadowPath {
shadowPath = UIBezierPath(roundedRect: bounds, cornerRadius: cornerRadius).cgPath
} else {
let a = Animation.shadowPath(path: UIBezierPath(roundedRect: bounds, cornerRadius: cornerRadius).cgPath)
let a = Animation.shadowPath(to: UIBezierPath(roundedRect: bounds, cornerRadius: cornerRadius).cgPath)
a.fromValue = shadowPath
animate(animation: a)
}
......
Sources/iOS/PulseAnimation.swift
......@@ -71,7 +71,7 @@ internal extension Animation {
visualLayer.masksToBounds = !(.centerRadialBeyondBounds == pulse.animation || .radialBeyondBounds == pulse.animation)
Animation.animationDisabled(animations: { [visualLayer = visualLayer, pulse = pulse] in
Animation.disable(animations: { [visualLayer = visualLayer, pulse = pulse] in
bLayer.frame = visualLayer.bounds
pLayer.bounds = CGRect(x: 0, y: 0, width: n, height: n)
......@@ -99,7 +99,7 @@ internal extension Animation {
switch pulse.animation {
case .center, .centerWithBacking, .centerRadialBeyondBounds, .radialBeyondBounds, .point, .pointWithBacking:
pLayer.add(Animation.scale(scale: 1, duration: duration), forKey: nil)
pLayer.add(Animation.scale(by: 1, duration: duration), forKey: nil)
default:break
}
......@@ -138,8 +138,8 @@ internal extension Animation {
switch pulse.animation {
case .center, .centerWithBacking, .centerRadialBeyondBounds, .radialBeyondBounds, .point, .pointWithBacking:
pLayer.add(Animation.animationGroup(animations: [
Animation.scale(scale: .center == pulse.animation ? 1 : 1.325),
pLayer.add(Animation.animate(group: [
Animation.scale(by: .center == pulse.animation ? 1 : 1.325),
Animation.backgroundColor(color: pulse.color.withAlphaComponent(0))
], duration: duration), forKey: nil)
default:break
......
Sources/iOS/TransitionAnimation.swift
......@@ -30,70 +30,78 @@
import UIKit
public typealias AnimationTransitionType = String
public typealias AnimationTransitionSubTypeType = String
@objc(AnimationTransition)
public enum AnimationTransition: Int {
case Fade
case MoveIn
case Push
case Reveal
case fade
case moveIn
case push
case reveal
}
@objc(AnimationTransitionSubType)
public enum AnimationTransitionSubType: Int {
case Right
case Left
case Top
case Bottom
@objc(AnimationTransitionDirection)
public enum AnimationTransitionDirection: Int {
case `default`
case right
case left
case top
case bottom
}
/**
:name: AnimationTransitionToValue
*/
public func AnimationTransitionToValue(transition: AnimationTransition) -> AnimationTransitionType {
switch transition {
case .Fade:
Converts an AnimationTransition to a corresponding CATransition key.
- Parameter transition: An AnimationTransition.
- Returns: A CATransition key String.
*/
public func AnimationTransitionToValue(transition type: AnimationTransition) -> String {
switch type {
case .fade:
return kCATransitionFade
case .MoveIn:
case .moveIn:
return kCATransitionMoveIn
case .Push:
case .push:
return kCATransitionPush
case .Reveal:
case .reveal:
return kCATransitionReveal
}
}
/**
:name: AnimationTransitionSubTypeToValue
*/
public func AnimationTransitionSubTypeToValue(direction: AnimationTransitionSubType) -> AnimationTransitionSubTypeType {
Converts an AnimationTransitionDirection to a corresponding CATransition direction key.
- Parameter direction: An AnimationTransitionDirection.
- Returns: An optional CATransition direction key String.
*/
public func AnimationTransitionDirectionToValue(direction: AnimationTransitionDirection) -> String? {
switch direction {
case .Right:
case .default:
return nil
case .right:
return kCATransitionFromRight
case .Left:
case .left:
return kCATransitionFromLeft
case .Top:
case .top:
return kCATransitionFromBottom
case .Bottom:
case .bottom:
return kCATransitionFromTop
}
}
extension Animation {
/**
:name: transition
*/
public static func transition(type: AnimationTransition, direction: AnimationTransitionSubType? = nil, duration: CFTimeInterval? = nil) -> CATransition {
let animation: CATransition = CATransition()
Creates a CATransition animation.
- Parameter type: An AnimationTransition.
- Parameter direction: An optional AnimationTransitionDirection.
- Parameter duration: An optional duration time.
- Returns: A CATransition.
*/
public static func transition(type: AnimationTransition, direction: AnimationTransitionDirection = .default, duration: CFTimeInterval? = nil) -> CATransition {
let animation = CATransition()
animation.type = AnimationTransitionToValue(transition: type)
if let d = direction {
animation.subtype = AnimationTransitionSubTypeToValue(direction: d)
}
if let v: CFTimeInterval = duration {
animation.subtype = AnimationTransitionDirectionToValue(direction: direction)
if let v = duration {
animation.duration = v
}
return animation
return animation
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment