// Grabbed from: https://github.com/cbpowell/MarqueeLabel-Swift/blob/cd331f3cfc3f9d7114ffa5aa4f243f1d5eda9d0d/Classes/MarqueeLabel.swift // License: MIT License // // MarqueeLabel.swift // // Created by Charles Powell on 8/6/14. // Copyright (c) 2015 Charles Powell. All rights reserved. // import UIKit import QuartzCore @IBDesignable open class MarqueeLabel: UILabel, CAAnimationDelegate { /** An enum that defines the types of `MarqueeLabel` scrolling - Left: Scrolls left after the specified delay, and does not return to the original position. - LeftRight: Scrolls left first, then back right to the original position. - Right: Scrolls right after the specified delay, and does not return to the original position. - RightLeft: Scrolls right first, then back left to the original position. - Continuous: Continuously scrolls left (with a pause at the original position if animationDelay is set). - ContinuousReverse: Continuously scrolls right (with a pause at the original position if animationDelay is set). */ public enum MarqueeType { case left case leftRight case right case rightLeft case continuous case continuousReverse } // // MARK: - Public properties // /** Defines the direction and method in which the `MarqueeLabel` instance scrolls. `MarqueeLabel` supports six default types of scrolling: `Left`, `LeftRight`, `Right`, `RightLeft`, `Continuous`, and `ContinuousReverse`. Given the nature of how text direction works, the options for the `type` property require specific text alignments and will set the textAlignment property accordingly. - `LeftRight` and `Left` types are ONLY compatible with a label text alignment of `NSTextAlignmentLeft`. - `RightLeft` and `Right` types are ONLY compatible with a label text alignment of `NSTextAlignmentRight`. - `Continuous` does not require a text alignment (it is effectively centered). - `ContinuousReverse` does not require a text alignment (it is effectively centered). Defaults to `Continuous`. - SeeAlso: textAlignment */ open var type: MarqueeType = .continuous { didSet { if type == oldValue { return } updateAndScroll() } } /** An optional custom scroll "sequence", defined by an array of `ScrollStep` or `FadeStep` instances. A sequence defines a single scroll/animation loop, which will continue to be automatically repeated like the default types. A `type` value is still required when using a custom sequence. The `type` value defines the `home` and `away` values used in the `ScrollStep` instances, and the `type` value determines which way the label will scroll. When a custom sequence is not supplied, the default sequences are used per the defined `type`. `ScrollStep` steps are the primary step types, and define the position of the label at a given time in the sequence. `FadeStep` steps are secondary steps that define the edge fade state (leading, trailing, or both) around the `ScrollStep` steps. Defaults to nil. - Attention: Use of the `scrollSequence` property requires understanding of how MarqueeLabel works for effective use. As a reference, it is suggested to review the methodology used to build the sequences for the default types. - SeeAlso: type - SeeAlso: ScrollStep - SeeAlso: FadeStep */ open var scrollSequence: Array? /** Specifies the animation curve used in the scrolling motion of the labels. Allowable options: - `UIViewAnimationOptionCurveEaseInOut` - `UIViewAnimationOptionCurveEaseIn` - `UIViewAnimationOptionCurveEaseOut` - `UIViewAnimationOptionCurveLinear` Defaults to `UIViewAnimationOptionCurveEaseInOut`. */ open var animationCurve: UIView.AnimationCurve = .linear /** A boolean property that sets whether the `MarqueeLabel` should behave like a normal `UILabel`. When set to `true` the `MarqueeLabel` will behave and look like a normal `UILabel`, and will not begin any scrolling animations. Changes to this property take effect immediately, removing any in-flight animation as well as any edge fade. Note that `MarqueeLabel` will respect the current values of the `lineBreakMode` and `textAlignment`properties while labelized. To simply prevent automatic scrolling, use the `holdScrolling` property. Defaults to `false`. - SeeAlso: holdScrolling - SeeAlso: lineBreakMode - Note: The label will not automatically scroll when this property is set to `true`. - Warning: The UILabel default setting for the `lineBreakMode` property is `NSLineBreakByTruncatingTail`, which truncates the text adds an ellipsis glyph (...). Set the `lineBreakMode` property to `NSLineBreakByClipping` in order to avoid the ellipsis, especially if using an edge transparency fade. */ @IBInspectable open var labelize: Bool = false { didSet { if labelize != oldValue { updateAndScroll() } } } /** A boolean property that sets whether the `MarqueeLabel` should hold (prevent) automatic label scrolling. When set to `true`, `MarqueeLabel` will not automatically scroll even its text is larger than the specified frame, although the specified edge fades will remain. To set `MarqueeLabel` to act like a normal UILabel, use the `labelize` property. Defaults to `false`. - Note: The label will not automatically scroll when this property is set to `true`. - SeeAlso: labelize */ @IBInspectable open var holdScrolling: Bool = false { didSet { if holdScrolling != oldValue { if oldValue == true && !(awayFromHome || labelize || tapToScroll ) && labelShouldScroll() { updateAndScroll(true) } } } } /** A boolean property that sets whether the `MarqueeLabel` should only begin a scroll when tapped. If this property is set to `true`, the `MarqueeLabel` will only begin a scroll animation cycle when tapped. The label will not automatically being a scroll. This setting overrides the setting of the `holdScrolling` property. Defaults to `false`. - Note: The label will not automatically scroll when this property is set to `false`. - SeeAlso: holdScrolling */ @IBInspectable open var tapToScroll: Bool = false { didSet { if tapToScroll != oldValue { if tapToScroll { let tapRecognizer = UITapGestureRecognizer(target: self, action: #selector(MarqueeLabel.labelWasTapped(_:))) self.addGestureRecognizer(tapRecognizer) isUserInteractionEnabled = true } else { if let recognizer = self.gestureRecognizers!.first as UIGestureRecognizer? { self.removeGestureRecognizer(recognizer) } isUserInteractionEnabled = false } } } } /** A read-only boolean property that indicates if the label's scroll animation has been paused. - SeeAlso: pauseLabel - SeeAlso: unpauseLabel */ open var isPaused: Bool { return (sublabel.layer.speed == 0.0) } /** A boolean property that indicates if the label is currently away from the home location. The "home" location is the traditional location of `UILabel` text. This property essentially reflects if a scroll animation is underway. */ open var awayFromHome: Bool { if let presentationLayer = sublabel.layer.presentation() { return !(presentationLayer.position.x == homeLabelFrame.origin.x) } return false } /** The `MarqueeLabel` scrolling speed may be defined by one of two ways: - Rate(CGFloat): The speed is defined by a rate of motion, in units of points per second. - Duration(CGFloat): The speed is defined by the time to complete a scrolling animation cycle, in units of seconds. Each case takes an associated `CGFloat` value, which is the rate/duration desired. */ public enum SpeedLimit { case rate(CGFloat) case duration(CGFloat) var value: CGFloat { switch self { case .rate(let rate): return rate case .duration(let duration): return duration } } } /** Defines the speed of the `MarqueeLabel` scrolling animation. The speed is set by specifying a case of the `SpeedLimit` enum along with an associated value. - SeeAlso: SpeedLimit */ open var speed: SpeedLimit = .duration(7.0) { didSet { switch (speed, oldValue) { case (.rate(let a), .rate(let b)) where a == b: return case (.duration(let a), .duration(let b)) where a == b: return default: updateAndScroll() } } } @available(*, deprecated : 2.6, message : "Use speed property instead") @IBInspectable open var scrollDuration: CGFloat { get { switch speed { case .duration(let duration): return duration case .rate: return 0.0 } } set { speed = .duration(newValue) } } @available(*, deprecated : 2.6, message : "Use speed property instead") @IBInspectable open var scrollRate: CGFloat { get { switch speed { case .duration: return 0.0 case .rate(let rate): return rate } } set { speed = .rate(newValue) } } /** A buffer (offset) between the leading edge of the label text and the label frame. This property adds additional space between the leading edge of the label text and the label frame. The leading edge is the edge of the label text facing the direction of scroll (i.e. the edge that animates offscreen first during scrolling). Defaults to `0`. - Note: The value set to this property affects label positioning at all times (including when `labelize` is set to `true`), including when the text string length is short enough that the label does not need to scroll. - Note: For Continuous-type labels, the smallest value of `leadingBuffer`, `trailingBuffer`, and `fadeLength` is used as spacing between the two label instances. Zero is an allowable value for all three properties. - SeeAlso: trailingBuffer */ @IBInspectable open var leadingBuffer: CGFloat = 0.0 { didSet { if leadingBuffer != oldValue { updateAndScroll() } } } /** A buffer (offset) between the trailing edge of the label text and the label frame. This property adds additional space (buffer) between the trailing edge of the label text and the label frame. The trailing edge is the edge of the label text facing away from the direction of scroll (i.e. the edge that animates offscreen last during scrolling). Defaults to `0`. - Note: The value set to this property has no effect when the `labelize` property is set to `true`. - Note: For Continuous-type labels, the smallest value of `leadingBuffer`, `trailingBuffer`, and `fadeLength` is used as spacing between the two label instances. Zero is an allowable value for all three properties. - SeeAlso: leadingBuffer */ @IBInspectable open var trailingBuffer: CGFloat = 0.0 { didSet { if trailingBuffer != oldValue { updateAndScroll() } } } /** The length of transparency fade at the left and right edges of the frame. This propery sets the size (in points) of the view edge transparency fades on the left and right edges of a `MarqueeLabel`. The transparency fades from an alpha of 1.0 (fully visible) to 0.0 (fully transparent) over this distance. Values set to this property will be sanitized to prevent a fade length greater than 1/2 of the frame width. Defaults to `0`. */ @IBInspectable open var fadeLength: CGFloat = 0.0 { didSet { if fadeLength != oldValue { applyGradientMask(fadeLength, animated: true) updateAndScroll() } } } /** The length of delay in seconds that the label pauses at the completion of a scroll. */ @IBInspectable open var animationDelay: CGFloat = 1.0 /** The read-only duration of the scroll animation (not including delay). The value of this property is calculated from the value set to the `speed` property. If a .duration value is used to set the label animation speed, this value will be equivalent. */ private(set) public var animationDuration: CGFloat = 0.0 // // MARK: - Class Functions and Helpers // /** Convenience method to restart all `MarqueeLabel` instances that have the specified view controller in their next responder chain. - Parameter controller: The view controller for which to restart all `MarqueeLabel` instances. - Warning: View controllers that appear with animation (such as from underneath a modal-style controller) can cause some `MarqueeLabel` text position "jumping" when this method is used in `viewDidAppear` if scroll animations are already underway. Use this method inside `viewWillAppear:` instead to avoid this problem. - Warning: This method may not function properly if passed the parent view controller when using view controller containment. - SeeAlso: restartLabel - SeeAlso: controllerViewDidAppear: - SeeAlso: controllerViewWillAppear: */ open class func restartLabelsOfController(_ controller: UIViewController) { MarqueeLabel.notifyController(controller, message: .Restart) } /** Convenience method to restart all `MarqueeLabel` instances that have the specified view controller in their next responder chain. Alternative to `restartLabelsOfController`. This method is retained for backwards compatibility and future enhancements. - Parameter controller: The view controller that will appear. - SeeAlso: restartLabel - SeeAlso: controllerViewDidAppear */ open class func controllerViewWillAppear(_ controller: UIViewController) { MarqueeLabel.restartLabelsOfController(controller) } /** Convenience method to restart all `MarqueeLabel` instances that have the specified view controller in their next responder chain. Alternative to `restartLabelsOfController`. This method is retained for backwards compatibility and future enhancements. - Parameter controller: The view controller that did appear. - SeeAlso: restartLabel - SeeAlso: controllerViewWillAppear */ open class func controllerViewDidAppear(_ controller: UIViewController) { MarqueeLabel.restartLabelsOfController(controller) } /** Labelizes all `MarqueeLabel` instances that have the specified view controller in their next responder chain. The `labelize` property of all recognized `MarqueeLabel` instances will be set to `true`. - Parameter controller: The view controller for which all `MarqueeLabel` instances should be labelized. - SeeAlso: labelize */ open class func controllerLabelsLabelize(_ controller: UIViewController) { MarqueeLabel.notifyController(controller, message: .Labelize) } /** De-labelizes all `MarqueeLabel` instances that have the specified view controller in their next responder chain. The `labelize` property of all recognized `MarqueeLabel` instances will be set to `false`. - Parameter controller: The view controller for which all `MarqueeLabel` instances should be de-labelized. - SeeAlso: labelize */ open class func controllerLabelsAnimate(_ controller: UIViewController) { MarqueeLabel.notifyController(controller, message: .Animate) } // // MARK: - Initialization // /** Returns a newly initialized `MarqueeLabel` instance with the specified scroll rate and edge transparency fade length. - Parameter frame: A rectangle specifying the initial location and size of the view in its superview's coordinates. Text (for the given font, font size, etc.) that does not fit in this frame will automatically scroll. - Parameter pixelsPerSec: A rate of scroll for the label scroll animation. Must be non-zero. Note that this will be the peak (mid-transition) rate for ease-type animation. - Parameter fadeLength: A length of transparency fade at the left and right edges of the `MarqueeLabel` instance's frame. - Returns: An initialized `MarqueeLabel` object or nil if the object couldn't be created. - SeeAlso: fadeLength */ public init(frame: CGRect, rate: CGFloat, fadeLength fade: CGFloat) { speed = .rate(rate) fadeLength = CGFloat(min(fade, frame.size.width/2.0)) super.init(frame: frame) setup() } /** Returns a newly initialized `MarqueeLabel` instance with the specified scroll rate and edge transparency fade length. - Parameter frame: A rectangle specifying the initial location and size of the view in its superview's coordinates. Text (for the given font, font size, etc.) that does not fit in this frame will automatically scroll. - Parameter scrollDuration: A scroll duration the label scroll animation. Must be non-zero. This will be the duration that the animation takes for one-half of the scroll cycle in the case of left-right and right-left marquee types, and for one loop of a continuous marquee type. - Parameter fadeLength: A length of transparency fade at the left and right edges of the `MarqueeLabel` instance's frame. - Returns: An initialized `MarqueeLabel` object or nil if the object couldn't be created. - SeeAlso: fadeLength */ public init(frame: CGRect, duration: CGFloat, fadeLength fade: CGFloat) { speed = .duration(duration) fadeLength = CGFloat(min(fade, frame.size.width/2.0)) super.init(frame: frame) setup() } required public init?(coder aDecoder: NSCoder) { super.init(coder: aDecoder) setup() } /** Returns a newly initialized `MarqueeLabel` instance. The default scroll duration of 7.0 seconds and fade length of 0.0 are used. - Parameter frame: A rectangle specifying the initial location and size of the view in its superview's coordinates. Text (for the given font, font size, etc.) that does not fit in this frame will automatically scroll. - Returns: An initialized `MarqueeLabel` object or nil if the object couldn't be created. */ convenience public override init(frame: CGRect) { self.init(frame: frame, duration: 7.0, fadeLength: 0.0) } private func setup() { // Create sublabel sublabel = UILabel(frame: self.bounds) sublabel.tag = 700 sublabel.layer.anchorPoint = CGPoint.zero // Add sublabel addSubview(sublabel) // Configure self super.clipsToBounds = true super.numberOfLines = 1 // Add notification observers // Custom class notifications NotificationCenter.default.addObserver(self, selector: #selector(MarqueeLabel.restartForViewController(_:)), name: NSNotification.Name(rawValue: MarqueeKeys.Restart.rawValue), object: nil) NotificationCenter.default.addObserver(self, selector: #selector(MarqueeLabel.labelizeForController(_:)), name: NSNotification.Name(rawValue: MarqueeKeys.Labelize.rawValue), object: nil) NotificationCenter.default.addObserver(self, selector: #selector(MarqueeLabel.animateForController(_:)), name: NSNotification.Name(rawValue: MarqueeKeys.Animate.rawValue), object: nil) // UIApplication state notifications NotificationCenter.default.addObserver(self, selector: #selector(MarqueeLabel.restartLabel), name: NSNotification.Name.OWSApplicationDidBecomeActive, object: nil) NotificationCenter.default.addObserver(self, selector: #selector(MarqueeLabel.shutdownLabel), name: NSNotification.Name.OWSApplicationDidEnterBackground, object: nil) } override open func awakeFromNib() { super.awakeFromNib() forwardPropertiesToSublabel() } override open func prepareForInterfaceBuilder() { super.prepareForInterfaceBuilder() forwardPropertiesToSublabel() } private func forwardPropertiesToSublabel() { /* Note that this method is currently ONLY called from awakeFromNib, i.e. when text properties are set via a Storyboard. As the Storyboard/IB doesn't currently support attributed strings, there's no need to "forward" the super attributedString value. */ // Since we're a UILabel, we actually do implement all of UILabel's properties. // We don't care about these values, we just want to forward them on to our sublabel. let properties = ["baselineAdjustment", "enabled", "highlighted", "highlightedTextColor", "minimumFontSize", "shadowOffset", "textAlignment", "userInteractionEnabled", "adjustsFontSizeToFitWidth", "lineBreakMode", "numberOfLines", "contentMode"] // Iterate through properties sublabel.text = super.text sublabel.font = super.font sublabel.textColor = super.textColor sublabel.backgroundColor = super.backgroundColor ?? UIColor.clear sublabel.shadowColor = super.shadowColor sublabel.shadowOffset = super.shadowOffset for prop in properties { let value = super.value(forKey: prop) sublabel.setValue(value, forKeyPath: prop) } } // // MARK: - MarqueeLabel Heavy Lifting // override open func layoutSubviews() { super.layoutSubviews() updateAndScroll(true) } override open func willMove(toWindow newWindow: UIWindow?) { if newWindow == nil { shutdownLabel() } } override open func didMoveToWindow() { if self.window == nil { shutdownLabel() } else { updateAndScroll() } } private func updateAndScroll() { updateAndScroll(true) } private func updateAndScroll(_ shouldBeginScroll: Bool) { // Check if scrolling can occur if !labelReadyForScroll() { return } // Calculate expected size let expectedLabelSize = sublabelSize() // Invalidate intrinsic size invalidateIntrinsicContentSize() // Move label to home returnLabelToHome() // Check if label should scroll // Note that the holdScrolling propery does not affect this if !labelShouldScroll() { // Set text alignment and break mode to act like a normal label sublabel.textAlignment = super.textAlignment sublabel.lineBreakMode = super.lineBreakMode let labelFrame: CGRect switch type { case .continuousReverse, .rightLeft: labelFrame = bounds.divided(atDistance: leadingBuffer, from: CGRectEdge.maxXEdge).remainder.integral default: labelFrame = CGRect(x: leadingBuffer, y: 0.0, width: bounds.size.width - leadingBuffer, height: bounds.size.height).integral } homeLabelFrame = labelFrame awayOffset = 0.0 // Remove an additional sublabels (for continuous types) repliLayer?.instanceCount = 1 // Set the sublabel frame to calculated labelFrame sublabel.frame = labelFrame // Remove fade, as by definition none is needed in this case removeGradientMask() return } // Label DOES need to scroll // Recompute the animation duration animationDuration = { switch self.speed { case .rate(let rate): return CGFloat(abs(self.awayOffset) / rate) case .duration(let duration): return duration } }() // Spacing between primary and second sublabel must be at least equal to leadingBuffer, and at least equal to the fadeLength let minTrailing = max(max(leadingBuffer, trailingBuffer), fadeLength) // Determine positions and generate scroll steps let sequence: [MarqueeStep] switch type { case .continuous, .continuousReverse: if (type == .continuous) { homeLabelFrame = CGRect(x: leadingBuffer, y: 0.0, width: expectedLabelSize.width, height: bounds.size.height).integral awayOffset = -(homeLabelFrame.size.width + minTrailing) } else { // .ContinuousReverse homeLabelFrame = CGRect(x: bounds.size.width - (expectedLabelSize.width + leadingBuffer), y: 0.0, width: expectedLabelSize.width, height: bounds.size.height).integral awayOffset = (homeLabelFrame.size.width + minTrailing) } // Find when the lead label will be totally offscreen let offsetDistance = awayOffset let offscreenAmount = homeLabelFrame.size.width let startFadeFraction = abs(offscreenAmount / offsetDistance) // Find when the animation will hit that point let startFadeTimeFraction = timingFunctionForAnimationCurve(animationCurve).durationPercentageForPositionPercentage(startFadeFraction, duration: (animationDelay + animationDuration)) let startFadeTime = startFadeTimeFraction * animationDuration sequence = scrollSequence ?? [ ScrollStep(timeStep: 0.0, position: .home, edgeFades: .trailing), // Starting point, at home, with trailing fade ScrollStep(timeStep: animationDelay, position: .home, edgeFades: .trailing), // Delay at home, maintaining fade state FadeStep(timeStep: 0.2, edgeFades: [.leading, .trailing]), // 0.2 sec after scroll start, fade leading edge in as well FadeStep(timeStep: (startFadeTime - animationDuration), // Maintain fade state until just before reaching end of scroll animation edgeFades: [.leading, .trailing]), ScrollStep(timeStep: animationDuration, timingFunction: animationCurve, // Ending point (back at home), with animationCurve transition, with trailing fade position: .away, edgeFades: .trailing) ] // Set frame and text sublabel.frame = homeLabelFrame // Configure replication repliLayer?.instanceCount = 2 repliLayer?.instanceTransform = CATransform3DMakeTranslation(-awayOffset, 0.0, 0.0) case .leftRight, .left, .rightLeft, .right: if (type == .leftRight || type == .left) { homeLabelFrame = CGRect(x: leadingBuffer, y: 0.0, width: expectedLabelSize.width, height: bounds.size.height).integral awayOffset = bounds.size.width - (expectedLabelSize.width + leadingBuffer + trailingBuffer) // Enforce text alignment for this type sublabel.textAlignment = NSTextAlignment.left } else { homeLabelFrame = CGRect(x: bounds.size.width - (expectedLabelSize.width + leadingBuffer), y: 0.0, width: expectedLabelSize.width, height: bounds.size.height).integral awayOffset = (expectedLabelSize.width + trailingBuffer + leadingBuffer) - bounds.size.width // Enforce text alignment for this type sublabel.textAlignment = NSTextAlignment.right } // Set frame and text sublabel.frame = homeLabelFrame // Remove any replication repliLayer?.instanceCount = 1 if (type == .leftRight || type == .rightLeft) { sequence = scrollSequence ?? [ ScrollStep(timeStep: 0.0, position: .home, edgeFades: .trailing), // Starting point, at home, with trailing fade ScrollStep(timeStep: animationDelay, position: .home, edgeFades: .trailing), // Delay at home, maintaining fade state FadeStep(timeStep: 0.2, edgeFades: [.leading, .trailing]), // 0.2 sec after delay ends, fade leading edge in as well FadeStep(timeStep: -0.2, edgeFades: [.leading, .trailing]), // Maintain fade state until 0.2 sec before reaching away position ScrollStep(timeStep: animationDuration, timingFunction: animationCurve, // Away position, using animationCurve transition, with only leading edge faded in position: .away, edgeFades: .leading), ScrollStep(timeStep: animationDelay, position: .away, edgeFades: .leading), // Delay at away, maintaining fade state (leading only) FadeStep(timeStep: 0.2, edgeFades: [.leading, .trailing]), // 0.2 sec after delay ends, fade trailing edge back in as well FadeStep(timeStep: -0.2, edgeFades: [.leading, .trailing]), // Maintain fade state until 0.2 sec before reaching home position ScrollStep(timeStep: animationDuration, timingFunction: animationCurve, // Ending point, back at home, with only trailing fade position: .home, edgeFades: .trailing) ] } else { // .left or .right sequence = scrollSequence ?? [ ScrollStep(timeStep: 0.0, position: .home, edgeFades: .trailing), // Starting point, at home, with trailing fade ScrollStep(timeStep: animationDelay, position: .home, edgeFades: .trailing), // Delay at home, maintaining fade state FadeStep(timeStep: 0.2, edgeFades: [.leading, .trailing]), // 0.2 sec after delay ends, fade leading edge in as well FadeStep(timeStep: -0.2, edgeFades: [.leading, .trailing]), // Maintain fade state until 0.2 sec before reaching away position ScrollStep(timeStep: animationDuration, timingFunction: animationCurve, // Away position, using animationCurve transition, with only leading edge faded in position: .away, edgeFades: .leading), ScrollStep(timeStep: 60*60*24*365.0, // "Delay" at away, for huge time to effectie stay at away permanently position: .away, edgeFades: .leading) ] } } // Configure gradient for current condition applyGradientMask(fadeLength, animated: !self.labelize) if !tapToScroll && !holdScrolling && shouldBeginScroll { beginScroll(sequence) } } private func sublabelSize() -> CGSize { // Bound the expected size let maximumLabelSize = CGSize(width: CGFloat.greatestFiniteMagnitude, height: CGFloat.greatestFiniteMagnitude) // Calculate the expected size var expectedLabelSize = sublabel.sizeThatFits(maximumLabelSize) #if os(tvOS) // Sanitize width to 16384.0 (largest width a UILabel will draw on tvOS) expectedLabelSize.width = min(expectedLabelSize.width, 16384.0) #else // Sanitize width to 5461.0 (largest width a UILabel will draw on an iPhone 6S Plus) expectedLabelSize.width = min(expectedLabelSize.width, 5461.0) #endif // Adjust to own height (make text baseline match normal label) expectedLabelSize.height = bounds.size.height return expectedLabelSize } override open func sizeThatFits(_ size: CGSize) -> CGSize { var fitSize = sublabel.sizeThatFits(size) fitSize.width += leadingBuffer return fitSize } // // MARK: - Animation Handling // open func labelShouldScroll() -> Bool { // Check for nil string if sublabel.text == nil { return false } // Check for empty string if sublabel.text!.isEmpty { return false } // Check if the label string fits let labelTooLarge = (sublabelSize().width + leadingBuffer) > self.bounds.size.width + CGFloat.ulpOfOne let animationHasDuration = speed.value > 0.0 return (!labelize && labelTooLarge && animationHasDuration) } private func labelReadyForScroll() -> Bool { // Check if we have a superview if superview == nil { return false } // Check if we are attached to a window if window == nil { return false } // Check if our view controller is ready let viewController = firstAvailableViewController() if viewController != nil { if !viewController!.isViewLoaded { return false } } return true } private func returnLabelToHome() { // Remove any gradient animation maskLayer?.removeAllAnimations() // Remove all sublabel position animations sublabel.layer.removeAllAnimations() // Remove completion block scrollCompletionBlock = nil } private func beginScroll(_ sequence: [MarqueeStep]) { let scroller = generateScrollAnimation(sequence) let fader = generateGradientAnimation(sequence, totalDuration: scroller.duration) scroll(scroller, fader: fader) } private func scroll(_ scroller: MLAnimation, fader: MLAnimation?) { // Check for conditions which would prevent scrolling if !labelReadyForScroll() { return } // Convert fader to var var fader = fader // Call pre-animation hook labelWillBeginScroll() // Start animation transactions CATransaction.begin() CATransaction.setAnimationDuration(TimeInterval(scroller.duration)) // Create gradient animation, if needed let gradientAnimation: CAKeyframeAnimation? // Check for IBDesignable #if !TARGET_INTERFACE_BUILDER if fadeLength > 0.0 { // Remove any setup animation, but apply final values if let setupAnim = maskLayer?.animation(forKey: "setupFade") as? CABasicAnimation, let finalColors = setupAnim.toValue as? [CGColor] { maskLayer?.colors = finalColors } maskLayer?.removeAnimation(forKey: "setupFade") // Generate animation if needed if let previousAnimation = fader?.anim { gradientAnimation = previousAnimation } else { gradientAnimation = nil } // Apply fade animation maskLayer?.add(gradientAnimation!, forKey: "gradient") } else { // No animation needed fader = nil } #else fader = nil #endif scrollCompletionBlock = { [weak self] (finished: Bool) -> Void in guard finished else { // Do not continue into the next loop return } guard (self != nil) else { return } // Call returned home function self!.labelReturnedToHome(true) // Check to ensure that: // 1) We don't double fire if an animation already exists // 2) The instance is still attached to a window - this completion block is called for // many reasons, including if the animation is removed due to the view being removed // from the UIWindow (typically when the view controller is no longer the "top" view) guard self!.window != nil else { return } guard self!.sublabel.layer.animation(forKey: "position") == nil else { return } // Begin again, if conditions met if (self!.labelShouldScroll() && !self!.tapToScroll && !self!.holdScrolling) { // Perform completion callback self!.scroll(scroller, fader: fader) } } // Perform scroll animation scroller.anim.setValue(true, forKey: MarqueeKeys.CompletionClosure.rawValue) scroller.anim.delegate = self sublabel.layer.add(scroller.anim, forKey: "position") CATransaction.commit() } private func generateScrollAnimation(_ sequence: [MarqueeStep]) -> MLAnimation { // Create scroller, which defines the animation to perform let homeOrigin = homeLabelFrame.origin let awayOrigin = offsetCGPoint(homeLabelFrame.origin, offset: awayOffset) let scrollSteps = sequence.filter({ $0 is ScrollStep }) as! [ScrollStep] let totalDuration = scrollSteps.reduce(0.0) { $0 + $1.timeStep } // Build scroll data var totalTime: CGFloat = 0.0 var scrollKeyTimes = [NSNumber]() var scrollKeyValues = [NSValue]() var scrollTimingFunctions = [CAMediaTimingFunction]() for (offset, step) in scrollSteps.enumerated() { // Scroll Times totalTime += step.timeStep scrollKeyTimes.append(NSNumber(value: Float(totalTime/totalDuration))) // Scroll Values let scrollPosition: CGPoint switch step.position { case .home: scrollPosition = homeOrigin case .away: scrollPosition = awayOrigin case .partial(let frac): scrollPosition = offsetCGPoint(homeOrigin, offset: awayOffset*frac) } scrollKeyValues.append(NSValue(cgPoint: scrollPosition)) // Scroll Timing Functions // Only need n-1 timing functions, so discard the first value as it's unused if offset == 0 { continue } scrollTimingFunctions.append(timingFunctionForAnimationCurve(step.timingFunction)) } // Create animation let animation = CAKeyframeAnimation(keyPath: "position") // Set values animation.keyTimes = scrollKeyTimes animation.values = scrollKeyValues animation.timingFunctions = scrollTimingFunctions return (anim: animation, duration: totalDuration) } private func generateGradientAnimation(_ sequence: [MarqueeStep], totalDuration: CGFloat) -> MLAnimation { // Setup var totalTime: CGFloat = 0.0 var stepTime: CGFloat = 0.0 var fadeKeyValues = [[CGColor]]() var fadeKeyTimes = [NSNumber]() var fadeTimingFunctions = [CAMediaTimingFunction]() let transp = UIColor.clear.cgColor let opaque = UIColor.black.cgColor // Filter to get only scroll steps and valid precedent/subsequent fade steps let fadeSteps = sequence.enumerated().filter { (arg: (offset: Int, element: MarqueeStep)) -> Bool in let (offset, element) = arg // Include all Scroll Steps if element is ScrollStep { return true } // Include all Fade Steps that have a directly preceding or subsequent Scroll Step // Exception: Fade Step cannot be first step if offset == 0 { return false } // Subsequent step if 1) positive/zero time step and 2) follows a Scroll Step let subsequent = element.timeStep >= 0 && (sequence[max(0, offset - 1)] is ScrollStep) // Precedent step if 1) negative time step and 2) precedes a Scroll Step let precedent = element.timeStep < 0 && (sequence[min(sequence.count - 1, offset + 1)] is ScrollStep) return (precedent || subsequent) } for (offset, step) in fadeSteps { // Fade times if (step is ScrollStep) { totalTime += step.timeStep stepTime = totalTime } else { if step.timeStep >= 0 { // Is a Subsequent stepTime = totalTime + step.timeStep } else { // Is a Precedent, grab next step stepTime = totalTime + fadeSteps[offset + 1].element.timeStep + step.timeStep } } fadeKeyTimes.append(NSNumber(value: Float(stepTime/totalDuration))) // Fade Values let values: [CGColor] let leading = step.edgeFades.contains(.leading) ? transp : opaque let trailing = step.edgeFades.contains(.trailing) ? transp : opaque switch type { case .leftRight, .left, .continuous: values = [leading, opaque, opaque, trailing] case .rightLeft, .right, .continuousReverse: values = [trailing, opaque, opaque, leading] } fadeKeyValues.append(values) // Fade Timing Function // Only need n-1 timing functions, so discard the first value as it's unused if offset == 0 { continue } fadeTimingFunctions.append(timingFunctionForAnimationCurve(step.timingFunction)) } // Create new animation let animation = CAKeyframeAnimation(keyPath: "colors") animation.values = fadeKeyValues animation.keyTimes = fadeKeyTimes animation.timingFunctions = fadeTimingFunctions return (anim: animation, duration: max(totalTime, totalDuration)) } private func applyGradientMask(_ fadeLength: CGFloat, animated: Bool, firstStep: MarqueeStep? = nil) { // Remove any in-flight animations maskLayer?.removeAllAnimations() // Check for zero-length fade if (fadeLength <= 0.0) { removeGradientMask() return } // Configure gradient mask without implicit animations CATransaction.begin() CATransaction.setDisableActions(true) // Determine if gradient mask needs to be created let gradientMask: CAGradientLayer if let currentMask = self.maskLayer { // Mask layer already configured gradientMask = currentMask } else { // No mask exists, create new mask gradientMask = CAGradientLayer() gradientMask.shouldRasterize = true gradientMask.rasterizationScale = UIScreen.main.scale gradientMask.startPoint = CGPoint(x: 0.0, y: 0.5) gradientMask.endPoint = CGPoint(x: 1.0, y: 0.5) } // Check if there is a mask to layer size mismatch if gradientMask.bounds != self.layer.bounds { // Adjust stops based on fade length let leftFadeStop = fadeLength/self.bounds.size.width let rightFadeStop = 1.0 - fadeLength/self.bounds.size.width gradientMask.locations = [0.0, leftFadeStop, rightFadeStop, 1.0].map { NSNumber(value: Float($0)) } } gradientMask.bounds = self.layer.bounds gradientMask.position = CGPoint(x: self.bounds.midX, y: self.bounds.midY) // Set up colors let transparent = UIColor.clear.cgColor let opaque = UIColor.black.cgColor // Set mask self.layer.mask = gradientMask // Determine colors for non-scrolling label (i.e. at home) let adjustedColors: [CGColor] let trailingFadeNeeded = self.labelShouldScroll() switch type { case .continuousReverse, .rightLeft: adjustedColors = [(trailingFadeNeeded ? transparent : opaque), opaque, opaque, opaque] // .Continuous, .LeftRight default: adjustedColors = [opaque, opaque, opaque, (trailingFadeNeeded ? transparent : opaque)] } // Check for IBDesignable #if TARGET_INTERFACE_BUILDER gradientMask.colors = adjustedColors CATransaction.commit() return #endif if (animated) { // Finish transaction CATransaction.commit() // Create animation for color change let colorAnimation = GradientSetupAnimation(keyPath: "colors") colorAnimation.fromValue = gradientMask.colors colorAnimation.toValue = adjustedColors colorAnimation.fillMode = CAMediaTimingFillMode.forwards colorAnimation.isRemovedOnCompletion = false colorAnimation.delegate = self gradientMask.add(colorAnimation, forKey: "setupFade") } else { gradientMask.colors = adjustedColors CATransaction.commit() } } private func removeGradientMask() { self.layer.mask = nil } private func timingFunctionForAnimationCurve(_ curve: UIView.AnimationCurve) -> CAMediaTimingFunction { let timingFunction: CAMediaTimingFunctionName switch curve { case .easeIn: timingFunction = .easeIn case .easeInOut: timingFunction = .easeInEaseOut case .easeOut: timingFunction = .easeOut default: timingFunction = .linear } return CAMediaTimingFunction(name: timingFunction) } private func transactionDurationType(_ labelType: MarqueeType, interval: CGFloat, delay: CGFloat) -> TimeInterval { switch labelType { case .leftRight, .rightLeft: return TimeInterval(2.0 * (delay + interval)) default: return TimeInterval(delay + interval) } } public func animationDidStop(_ anim: CAAnimation, finished flag: Bool) { if let setupAnim = anim as? GradientSetupAnimation { if let finalColors = setupAnim.toValue as? [CGColor] { maskLayer?.colors = finalColors } // Remove regardless, since we set removeOnCompletion = false maskLayer?.removeAnimation(forKey: "setupFade") } else { scrollCompletionBlock?(flag) } } // // MARK: - Private details // private var sublabel = UILabel() fileprivate var homeLabelFrame = CGRect.zero fileprivate var awayOffset: CGFloat = 0.0 override open class var layerClass: AnyClass { return CAReplicatorLayer.self } fileprivate var repliLayer: CAReplicatorLayer? { return self.layer as? CAReplicatorLayer } fileprivate var maskLayer: CAGradientLayer? { return self.layer.mask as! CAGradientLayer? } fileprivate var scrollCompletionBlock: MLAnimationCompletionBlock? override open func draw(_ layer: CALayer, in ctx: CGContext) { // Do NOT call super, to prevent UILabel superclass from drawing into context // Label drawing is handled by sublabel and CAReplicatorLayer layer class // Draw only background color if let bgColor = backgroundColor { ctx.setFillColor(bgColor.cgColor) ctx.fill(layer.bounds) } } fileprivate enum MarqueeKeys: String { case Restart = "MLViewControllerRestart" case Labelize = "MLShouldLabelize" case Animate = "MLShouldAnimate" case CompletionClosure = "MLAnimationCompletion" } class fileprivate func notifyController(_ controller: UIViewController, message: MarqueeKeys) { NotificationCenter.default.post(name: Notification.Name(rawValue: message.rawValue), object: nil, userInfo: ["controller": controller]) } @objc public func restartForViewController(_ notification: Notification) { if let controller = (notification as NSNotification).userInfo?["controller"] as? UIViewController { if controller === self.firstAvailableViewController() { self.restartLabel() } } } @objc public func labelizeForController(_ notification: Notification) { if let controller = (notification as NSNotification).userInfo?["controller"] as? UIViewController { if controller === self.firstAvailableViewController() { self.labelize = true } } } @objc public func animateForController(_ notification: Notification) { if let controller = (notification as NSNotification).userInfo?["controller"] as? UIViewController { if controller === self.firstAvailableViewController() { self.labelize = false } } } // // MARK: - Label Control // /** Overrides any non-size condition which is preventing the receiver from automatically scrolling, and begins a scroll animation. Currently the only non-size conditions which can prevent a label from scrolling are the `tapToScroll` and `holdScrolling` properties. This method will not force a label with a string that fits inside the label bounds (i.e. that would not automatically scroll) to begin a scroll animation. Upon the completion of the first forced scroll animation, the receiver will not automatically continue to scroll unless the conditions preventing scrolling have been removed. - Note: This method has no effect if called during an already in-flight scroll animation. - SeeAlso: restartLabel */ public func triggerScrollStart() { if labelShouldScroll() && !awayFromHome { updateAndScroll() } } /** Immediately resets the label to the home position, cancelling any in-flight scroll animation, and restarts the scroll animation if the appropriate conditions are met. - SeeAlso: resetLabel - SeeAlso: triggerScrollStart */ @objc public func restartLabel() { // Shutdown the label shutdownLabel() // Restart scrolling if appropriate if labelShouldScroll() && !tapToScroll && !holdScrolling { updateAndScroll() } } /** Resets the label text, recalculating the scroll animation. The text is immediately returned to the home position, and the scroll animation positions are cleared. Scrolling will not resume automatically after a call to this method. To re-initiate scrolling, use either a call to `restartLabel` or make a change to a UILabel property such as text, bounds/frame, font, font size, etc. - SeeAlso: restartLabel */ public func resetLabel() { returnLabelToHome() homeLabelFrame = CGRect.null awayOffset = 0.0 } /** Immediately resets the label to the home position, cancelling any in-flight scroll animation. The text is immediately returned to the home position. Scrolling will not resume automatically after a call to this method. To re-initiate scrolling use a call to `restartLabel` or `triggerScrollStart`, or make a change to a UILabel property such as text, bounds/frame, font, font size, etc. - SeeAlso: restartLabel - SeeAlso: triggerScrollStart */ @objc public func shutdownLabel() { // Bring label to home location returnLabelToHome() // Apply gradient mask for home location applyGradientMask(fadeLength, animated: false) } /** Pauses the text scrolling animation, at any point during an in-progress animation. - Note: This method has no effect if a scroll animation is NOT already in progress. To prevent automatic scrolling on a newly-initialized label prior to its presentation onscreen, see the `holdScrolling` property. - SeeAlso: holdScrolling - SeeAlso: unpauseLabel */ public func pauseLabel() { // Prevent pausing label while not in scrolling animation, or when already paused guard (!isPaused && awayFromHome) else { return } // Pause sublabel position animations let labelPauseTime = sublabel.layer.convertTime(CACurrentMediaTime(), from: nil) sublabel.layer.speed = 0.0 sublabel.layer.timeOffset = labelPauseTime // Pause gradient fade animation let gradientPauseTime = maskLayer?.convertTime(CACurrentMediaTime(), from: nil) maskLayer?.speed = 0.0 maskLayer?.timeOffset = gradientPauseTime! } /** Un-pauses a previously paused text scrolling animation. This method has no effect if the label was not previously paused using `pauseLabel`. - SeeAlso: pauseLabel */ public func unpauseLabel() { // Only unpause if label was previously paused guard (isPaused) else { return } // Unpause sublabel position animations let labelPausedTime = sublabel.layer.timeOffset sublabel.layer.speed = 1.0 sublabel.layer.timeOffset = 0.0 sublabel.layer.beginTime = 0.0 sublabel.layer.beginTime = sublabel.layer.convertTime(CACurrentMediaTime(), from: nil) - labelPausedTime // Unpause gradient fade animation let gradientPauseTime = maskLayer?.timeOffset maskLayer?.speed = 1.0 maskLayer?.timeOffset = 0.0 maskLayer?.beginTime = 0.0 maskLayer?.beginTime = maskLayer!.convertTime(CACurrentMediaTime(), from: nil) - gradientPauseTime! } @objc public func labelWasTapped(_ recognizer: UIGestureRecognizer) { if labelShouldScroll() && !awayFromHome { updateAndScroll() } } /** Called when the label animation is about to begin. The default implementation of this method does nothing. Subclasses may override this method in order to perform any custom actions just as the label animation begins. This is only called in the event that the conditions for scrolling to begin are met. */ open func labelWillBeginScroll() { // Default implementation does nothing - override to customize return } /** Called when the label animation has finished, and the label is at the home position. The default implementation of this method does nothing. Subclasses may override this method in order to perform any custom actions jas as the label animation completes, and before the next animation would begin (assuming the scroll conditions are met). - Parameter finished: A Boolean that indicates whether or not the scroll animation actually finished before the completion handler was called. - Warning: This method will be called, and the `finished` parameter will be `NO`, when any property changes are made that would cause the label scrolling to be automatically reset. This includes changes to label text and font/font size changes. */ open func labelReturnedToHome(_ finished: Bool) { // Default implementation does nothing - override to customize return } // // MARK: - Modified UILabel Functions/Getters/Setters // #if os(iOS) override open func forBaselineLayout() -> UIView { // Use subLabel view for handling baseline layouts return sublabel } override open var forLastBaselineLayout: UIView { // Use subLabel view for handling baseline layouts return sublabel } #endif override open var text: String? { get { return sublabel.text } set { if sublabel.text == newValue { return } sublabel.text = newValue updateAndScroll() super.text = text } } override open var attributedText: NSAttributedString? { get { return sublabel.attributedText } set { if sublabel.attributedText == newValue { return } sublabel.attributedText = newValue updateAndScroll() super.attributedText = attributedText } } override open var font: UIFont! { get { return sublabel.font } set { if sublabel.font == newValue { return } sublabel.font = newValue super.font = newValue updateAndScroll() } } override open var textColor: UIColor! { get { return sublabel.textColor } set { sublabel.textColor = newValue super.textColor = newValue } } override open var backgroundColor: UIColor? { get { return sublabel.backgroundColor } set { sublabel.backgroundColor = newValue super.backgroundColor = newValue } } override open var shadowColor: UIColor? { get { return sublabel.shadowColor } set { sublabel.shadowColor = newValue super.shadowColor = newValue } } override open var shadowOffset: CGSize { get { return sublabel.shadowOffset } set { sublabel.shadowOffset = newValue super.shadowOffset = newValue } } override open var highlightedTextColor: UIColor? { get { return sublabel.highlightedTextColor } set { sublabel.highlightedTextColor = newValue super.highlightedTextColor = newValue } } override open var isHighlighted: Bool { get { return sublabel.isHighlighted } set { sublabel.isHighlighted = newValue super.isHighlighted = newValue } } override open var isEnabled: Bool { get { return sublabel.isEnabled } set { sublabel.isEnabled = newValue super.isEnabled = newValue } } override open var numberOfLines: Int { get { return super.numberOfLines } set { // By the nature of MarqueeLabel, this is 1 super.numberOfLines = 1 } } override open var adjustsFontSizeToFitWidth: Bool { get { return super.adjustsFontSizeToFitWidth } set { // By the nature of MarqueeLabel, this is false super.adjustsFontSizeToFitWidth = false } } override open var minimumScaleFactor: CGFloat { get { return super.minimumScaleFactor } set { super.minimumScaleFactor = 0.0 } } override open var baselineAdjustment: UIBaselineAdjustment { get { return sublabel.baselineAdjustment } set { sublabel.baselineAdjustment = newValue super.baselineAdjustment = newValue } } override open var intrinsicContentSize: CGSize { var content = sublabel.intrinsicContentSize content.width += leadingBuffer return content } override open var tintColor: UIColor! { get { return sublabel.tintColor } set { sublabel.tintColor = newValue super.tintColor = newValue } } override open func tintColorDidChange() { super.tintColorDidChange() sublabel.tintColorDidChange() } override open var contentMode: UIView.ContentMode { get { return sublabel.contentMode } set { super.contentMode = contentMode sublabel.contentMode = newValue } } // // MARK: - Support // fileprivate func offsetCGPoint(_ point: CGPoint, offset: CGFloat) -> CGPoint { return CGPoint(x: point.x + offset, y: point.y) } // // MARK: - Deinit // deinit { NotificationCenter.default.removeObserver(self) } } // // MARK: - Support // public protocol MarqueeStep { var timeStep: CGFloat { get } var timingFunction: UIView.AnimationCurve { get } var edgeFades: EdgeFade { get } } /** `ScrollStep` types define the label position at a specified time delta since the last `ScrollStep` step, as well as the animation curve to that position and edge fade state at the position */ public struct ScrollStep: MarqueeStep { /** An enum that provides the possible positions defined by a ScrollStep - `home`: The starting, default position of the label - `away`: The calculated position that results in the entirety of the label scrolling past. - `partial(CGFloat)`: A fractional value, specified by the associated CGFloat value, between the `home` and `away` positions (must be between 0.0 and 1.0). The `away` position depends on the MarqueeLabel `type` value. - For `left`, `leftRight`, `right`, and `rightLeft` types, the `away` position means the trailing edge of the label is visible. For `leftRight` and `rightLeft` default types, the scroll animation reverses direction after reaching this point and returns to the `home` position. - For `continuous` and `continuousReverse` types, the `away` position is the location such that if the scroll is completed at this point (i.e. the animation is removed), there will be no visible change in the label appearance. */ public enum Position { case home case away case partial(CGFloat) } /** The desired time between this step and the previous `ScrollStep` in a sequence. */ public let timeStep: CGFloat /** The animation curve to utilize between the previous `ScrollStep` in a sequence and this step. - Note: The animation curve value for the first `ScrollStep` in a sequence has no effect. */ public let timingFunction: UIView.AnimationCurve /** The position of the label for this scroll step. - SeeAlso: Position */ public let position: Position /** The option set defining the edge fade state for this scroll step. Possible options include `.leading` and `.trailing`, corresponding to the leading edge of the label scrolling (i.e. the direction of scroll) and trailing edge of the label. */ public let edgeFades: EdgeFade public init(timeStep: CGFloat, timingFunction: UIView.AnimationCurve = .linear, position: Position, edgeFades: EdgeFade) { self.timeStep = timeStep self.position = position self.edgeFades = edgeFades self.timingFunction = timingFunction } } /** `FadeStep` types allow additional edge fade state definitions, around the states defined by the `ScrollStep` steps of a sequence. `FadeStep` steps are defined by the time delta to the preceding or subsequent `ScrollStep` step and the timing function to their edge fade state. - Note: A `FadeStep` cannot be the first step in a sequence. A `FadeStep` defined as such will be ignored. */ public struct FadeStep: MarqueeStep { /** The desired time between this `FadeStep` and the preceding or subsequent `ScrollStep` in a sequence. `FadeSteps` with a negative `timeStep` value will be associated _only_ with an immediately-subsequent `ScrollStep` step in the sequence. `FadeSteps` with a positive `timeStep` value will be associated _only_ with an immediately-prior `ScrollStep` step in the sequence. - Note: A `FadeStep` with a `timeStep` value of 0.0 will have no effect, and is the same as defining the fade state with a `ScrollStep`. */ public let timeStep: CGFloat /** The animation curve to utilize between the previous fade state in a sequence and this step. */ public let timingFunction: UIView.AnimationCurve /** The option set defining the edge fade state for this fade step. Possible options include `.leading` and `.trailing`, corresponding to the leading edge of the label scrolling (i.e. the direction of scroll) and trailing edge of the label. As an Option Set type, both edge fade states may be defined using an array literal: `[.leading, .trailing]`. */ public let edgeFades: EdgeFade public init(timeStep: CGFloat, timingFunction: UIView.AnimationCurve = .linear, edgeFades: EdgeFade) { self.timeStep = timeStep self.timingFunction = timingFunction self.edgeFades = edgeFades } } public struct EdgeFade: OptionSet { public let rawValue: Int public static let leading = EdgeFade(rawValue: 1 << 0) public static let trailing = EdgeFade(rawValue: 1 << 1) public init(rawValue: Int) { self.rawValue = rawValue } } // Define helpful typealiases private typealias MLAnimationCompletionBlock = (_ finished: Bool) -> Void private typealias MLAnimation = (anim: CAKeyframeAnimation, duration: CGFloat) private class GradientSetupAnimation: CABasicAnimation { } fileprivate extension UIResponder { // Thanks to Phil M // http://stackoverflow.com/questions/1340434/get-to-uiviewcontroller-from-uiview-on-iphone func firstAvailableViewController() -> UIViewController? { // convenience function for casting and to "mask" the recursive function return self.traverseResponderChainForFirstViewController() } func traverseResponderChainForFirstViewController() -> UIViewController? { if let nextResponder = self.next { if nextResponder is UIViewController { return nextResponder as? UIViewController } else if nextResponder is UIView { return nextResponder.traverseResponderChainForFirstViewController() } else { return nil } } return nil } } fileprivate extension CAMediaTimingFunction { func durationPercentageForPositionPercentage(_ positionPercentage: CGFloat, duration: CGFloat) -> CGFloat { // Finds the animation duration percentage that corresponds with the given animation "position" percentage. // Utilizes Newton's Method to solve for the parametric Bezier curve that is used by CAMediaAnimation. let controlPoints = self.controlPoints() let epsilon: CGFloat = 1.0 / (100.0 * CGFloat(duration)) // Find the t value that gives the position percentage we want let t_found = solveTforY(positionPercentage, epsilon: epsilon, controlPoints: controlPoints) // With that t, find the corresponding animation percentage let durationPercentage = XforCurveAt(t_found, controlPoints: controlPoints) return durationPercentage } func solveTforY(_ y_0: CGFloat, epsilon: CGFloat, controlPoints: [CGPoint]) -> CGFloat { // Use Newton's Method: http://en.wikipedia.org/wiki/Newton's_method // For first guess, use t = y (i.e. if curve were linear) var t0 = y_0 var t1 = y_0 var f0, df0: CGFloat for _ in 0..<15 { // Base this iteration of t1 calculated from last iteration t0 = t1 // Calculate f(t0) f0 = YforCurveAt(t0, controlPoints: controlPoints) - y_0 // Check if this is close (enough) if (abs(f0) < epsilon) { // Done! return t0 } // Else continue Newton's Method df0 = derivativeCurveYValueAt(t0, controlPoints: controlPoints) // Check if derivative is small or zero ( http://en.wikipedia.org/wiki/Newton's_method#Failure_analysis ) if (abs(df0) < 1e-6) { break } // Else recalculate t1 t1 = t0 - f0/df0 } // Give up - shouldn't ever get here...I hope print("MarqueeLabel: Failed to find t for Y input!") return t0 } func YforCurveAt(_ t: CGFloat, controlPoints: [CGPoint]) -> CGFloat { let P0 = controlPoints[0] let P1 = controlPoints[1] let P2 = controlPoints[2] let P3 = controlPoints[3] // Per http://en.wikipedia.org/wiki/Bezier_curve#Cubic_B.C3.A9zier_curves let y0 = (pow((1.0 - t), 3.0) * P0.y) let y1 = (3.0 * pow(1.0 - t, 2.0) * t * P1.y) let y2 = (3.0 * (1.0 - t) * pow(t, 2.0) * P2.y) let y3 = (pow(t, 3.0) * P3.y) return y0 + y1 + y2 + y3 } func XforCurveAt(_ t: CGFloat, controlPoints: [CGPoint]) -> CGFloat { let P0 = controlPoints[0] let P1 = controlPoints[1] let P2 = controlPoints[2] let P3 = controlPoints[3] // Per http://en.wikipedia.org/wiki/Bezier_curve#Cubic_B.C3.A9zier_curves let x0 = (pow((1.0 - t), 3.0) * P0.x) let x1 = (3.0 * pow(1.0 - t, 2.0) * t * P1.x) let x2 = (3.0 * (1.0 - t) * pow(t, 2.0) * P2.x) let x3 = (pow(t, 3.0) * P3.x) return x0 + x1 + x2 + x3 } func derivativeCurveYValueAt(_ t: CGFloat, controlPoints: [CGPoint]) -> CGFloat { let P0 = controlPoints[0] let P1 = controlPoints[1] let P2 = controlPoints[2] let P3 = controlPoints[3] let dy0 = (P0.y + 3.0 * P1.y + 3.0 * P2.y - P3.y) * -3.0 let dy1 = t * (6.0 * P0.y + 6.0 * P2.y) let dy2 = (-3.0 * P0.y + 3.0 * P1.y) return dy0 * pow(t, 2.0) + dy1 + dy2 } func controlPoints() -> [CGPoint] { // Create point array to point to var point: [Float] = [0.0, 0.0] var pointArray = [CGPoint]() for i in 0...3 { self.getControlPoint(at: i, values: &point) pointArray.append(CGPoint(x: CGFloat(point[0]), y: CGFloat(point[1]))) } return pointArray } }