lottie-ios 3.2.0 → 3.4.0

package/{lottie-swift/src/Private/LayerContainers/Utility/TextLayer.swift → Sources/Private/MainThread/LayerContainers/Utility/CoreTextRenderLayer.swift}

@@ -5,10 +5,10 @@
 //  Created by Brandon Withrow on 8/3/20.
 //
 
-import Foundation
+import CoreGraphics
 import CoreText
+import Foundation
 import QuartzCore
-import CoreGraphics
 /// Needed for NSMutableParagraphStyle...
 #if os(OSX)
 import AppKit
@@ -16,132 +16,106 @@ import AppKit
 import UIKit
 #endif
 
-final class TextLayer: CALayer {
-  
+// MARK: - CoreTextRenderLayer
+
+/// A CALayer subclass that renders text content using CoreText
+final class CoreTextRenderLayer: CALayer {
+
+  // MARK: Public
+
   public var text: String? {
     didSet {
       needsContentUpdate = true
-      self.setNeedsLayout()
-      self.setNeedsDisplay()
+      setNeedsLayout()
+      setNeedsDisplay()
     }
   }
-  
+
   public var font: CTFont? {
     didSet {
       needsContentUpdate = true
-      self.setNeedsLayout()
-      self.setNeedsDisplay()
+      setNeedsLayout()
+      setNeedsDisplay()
     }
   }
-  
+
   public var alignment: NSTextAlignment = .left {
     didSet {
       needsContentUpdate = true
-      self.setNeedsLayout()
-      self.setNeedsDisplay()
+      setNeedsLayout()
+      setNeedsDisplay()
     }
   }
-  
+
   public var lineHeight: CGFloat = 0 {
     didSet {
       needsContentUpdate = true
-      self.setNeedsLayout()
-      self.setNeedsDisplay()
+      setNeedsLayout()
+      setNeedsDisplay()
     }
   }
-  
+
   public var tracking: CGFloat = 0 {
     didSet {
       needsContentUpdate = true
-      self.setNeedsLayout()
-      self.setNeedsDisplay()
+      setNeedsLayout()
+      setNeedsDisplay()
     }
   }
-  
+
   public var fillColor: CGColor? {
     didSet {
       needsContentUpdate = true
-      self.setNeedsLayout()
-      self.setNeedsDisplay()
+      setNeedsLayout()
+      setNeedsDisplay()
     }
   }
-  
+
   public var strokeColor: CGColor? {
     didSet {
       needsContentUpdate = true
-      self.setNeedsLayout()
-      self.setNeedsDisplay()
+      setNeedsLayout()
+      setNeedsDisplay()
     }
   }
-  
+
   public var strokeWidth: CGFloat = 0 {
     didSet {
       needsContentUpdate = true
-      self.setNeedsLayout()
-      self.setNeedsDisplay()
+      setNeedsLayout()
+      setNeedsDisplay()
     }
   }
-  
-  public var strokeOnTop: Bool = false {
+
+  public var strokeOnTop = false {
     didSet {
-      self.setNeedsLayout()
-      self.setNeedsDisplay()
+      setNeedsLayout()
+      setNeedsDisplay()
     }
   }
-  
+
   public var preferredSize: CGSize? {
     didSet {
       needsContentUpdate = true
-      self.setNeedsLayout()
-      self.setNeedsDisplay()
+      setNeedsLayout()
+      setNeedsDisplay()
     }
   }
-  
+
   public func sizeToFit() {
     updateTextContent()
     bounds = drawingRect
     anchorPoint = drawingAnchor
-    self.setNeedsLayout()
-    self.setNeedsDisplay()
+    setNeedsLayout()
+    setNeedsDisplay()
   }
-  
-  override func action(forKey event: String) -> CAAction? {
-    return nil
-  }
-  
-  // Draws Debug colors for the font alignment.
-  @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
-  private func drawDebug(_ ctx: CGContext) {
-    if let font = font {
-      let ascent = CTFontGetAscent(font)
-      let descent = CTFontGetDescent(font)
-      let capHeight = CTFontGetCapHeight(font)
-      let leading = CTFontGetLeading(font)
-      
-      // Ascent Red
-      ctx.setFillColor(CGColor(srgbRed: 1, green: 0, blue: 0, alpha: 0.5))
-      ctx.fill(CGRect(x:0, y:0, width:drawingRect.width, height:ascent))
-      
-      // Descent Blue
-      ctx.setFillColor(CGColor(srgbRed: 0, green: 0, blue: 1, alpha: 0.5))
-      ctx.fill(CGRect(x:0, y:ascent, width:drawingRect.width, height:descent))
-      
-      // Leading Yellow
-      ctx.setFillColor(CGColor(srgbRed: 1, green: 1, blue: 0, alpha: 0.5))
-      ctx.fill(CGRect(x:0, y:ascent+descent, width:drawingRect.width, height:leading))
-      
-      // Cap height Green
-      ctx.setFillColor(CGColor(srgbRed: 0, green: 1, blue: 0, alpha: 0.5))
-      ctx.fill(CGRect(x:0, y:ascent - capHeight, width:drawingRect.width, height:capHeight))
-      
-      if drawingRect.height - ascent+descent+leading > 0 {
-        // Remainder
-        ctx.setFillColor(CGColor(srgbRed: 0, green: 1, blue: 1, alpha: 0.5))
-        ctx.fill(CGRect(x:0, y:ascent+descent+leading, width:drawingRect.width, height:drawingRect.height - ascent+descent+leading))
-      }
-    }
+
+  // MARK: Internal
+
+  override func action(forKey _: String) -> CAAction? {
+    nil
   }
-  
+
   override func draw(in ctx: CGContext) {
     guard let attributedString = attributedString else { return }
     updateTextContent()
@@ -149,59 +123,98 @@ final class TextLayer: CALayer {
 
     ctx.textMatrix = .identity
     ctx.setAllowsAntialiasing(true)
-    ctx.setAllowsFontSmoothing(true)
     ctx.setAllowsFontSubpixelPositioning(true)
     ctx.setAllowsFontSubpixelQuantization(true)
 
     ctx.setShouldAntialias(true)
-    ctx.setShouldSmoothFonts(true)
     ctx.setShouldSubpixelPositionFonts(true)
     ctx.setShouldSubpixelQuantizeFonts(true)
 
-    ctx.translateBy(x: 0, y: drawingRect.height)
-    ctx.scaleBy(x: 1.0, y: -1.0)
+    if contentsAreFlipped() {
+      ctx.translateBy(x: 0, y: drawingRect.height)
+      ctx.scaleBy(x: 1.0, y: -1.0)
+    }
 
     let drawingPath = CGPath(rect: drawingRect, transform: nil)
-    
+
     let fillFrame: CTFrame?
     if let setter = fillFrameSetter {
       fillFrame = CTFramesetterCreateFrame(setter, CFRangeMake(0, attributedString.length), drawingPath, nil)
     } else {
       fillFrame = nil
     }
-    
+
     let strokeFrame: CTFrame?
     if let setter = strokeFrameSetter {
       strokeFrame = CTFramesetterCreateFrame(setter, CFRangeMake(0, attributedString.length), drawingPath, nil)
     } else {
       strokeFrame = nil
     }
-    
 
     if !strokeOnTop, let strokeFrame = strokeFrame {
       CTFrameDraw(strokeFrame, ctx)
     }
-    
+
     if let fillFrame = fillFrame {
       CTFrameDraw(fillFrame, ctx)
     }
-    
+
     if strokeOnTop, let strokeFrame = strokeFrame {
       CTFrameDraw(strokeFrame, ctx)
     }
   }
-  
+
+  // MARK: Private
+
   private var drawingRect: CGRect = .zero
   private var drawingAnchor: CGPoint = .zero
   private var fillFrameSetter: CTFramesetter?
   private var attributedString: NSAttributedString?
   private var strokeFrameSetter: CTFramesetter?
-  private var needsContentUpdate: Bool = false
-  
+  private var needsContentUpdate = false
+
+  // Draws Debug colors for the font alignment.
+  @available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, *)
+  private func drawDebug(_ ctx: CGContext) {
+    if let font = font {
+      let ascent = CTFontGetAscent(font)
+      let descent = CTFontGetDescent(font)
+      let capHeight = CTFontGetCapHeight(font)
+      let leading = CTFontGetLeading(font)
+
+      // Ascent Red
+      ctx.setFillColor(CGColor(srgbRed: 1, green: 0, blue: 0, alpha: 0.5))
+      ctx.fill(CGRect(x: 0, y: 0, width: drawingRect.width, height: ascent))
+
+      // Descent Blue
+      ctx.setFillColor(CGColor(srgbRed: 0, green: 0, blue: 1, alpha: 0.5))
+      ctx.fill(CGRect(x: 0, y: ascent, width: drawingRect.width, height: descent))
+
+      // Leading Yellow
+      ctx.setFillColor(CGColor(srgbRed: 1, green: 1, blue: 0, alpha: 0.5))
+      ctx.fill(CGRect(x: 0, y: ascent + descent, width: drawingRect.width, height: leading))
+
+      // Cap height Green
+      ctx.setFillColor(CGColor(srgbRed: 0, green: 1, blue: 0, alpha: 0.5))
+      ctx.fill(CGRect(x: 0, y: ascent - capHeight, width: drawingRect.width, height: capHeight))
+
+      if drawingRect.height - ascent + descent + leading > 0 {
+        // Remainder
+        ctx.setFillColor(CGColor(srgbRed: 0, green: 1, blue: 1, alpha: 0.5))
+        ctx
+          .fill(CGRect(
+            x: 0,
+            y: ascent + descent + leading,
+            width: drawingRect.width,
+            height: drawingRect.height - ascent + descent + leading))
+      }
+    }
+  }
+
   private func updateTextContent() {
     guard needsContentUpdate else { return }
     needsContentUpdate = false
-    guard let font = font, let text = text, text.count > 0, (fillColor != nil || strokeColor != nil) else {
+    guard let font = font, let text = text, text.count > 0, fillColor != nil || strokeColor != nil else {
       drawingRect = .zero
       drawingAnchor = .zero
       attributedString = nil
@@ -216,37 +229,37 @@ final class TextLayer: CALayer {
     let capHeight = CTFontGetCapHeight(font)
     let leading = CTFontGetLeading(font)
     let minLineHeight = -(ascent + descent + leading)
-    
+
     // Calculate line spacing
     let lineSpacing = max(CGFloat(minLineHeight) + lineHeight, CGFloat(minLineHeight))
     // Build Attributes
     let paragraphStyle = NSMutableParagraphStyle()
     paragraphStyle.lineSpacing = lineSpacing
     paragraphStyle.lineHeightMultiple = 1
-    paragraphStyle.maximumLineHeight = ascent+descent+leading
+    paragraphStyle.maximumLineHeight = ascent + descent + leading
     paragraphStyle.alignment = alignment
     paragraphStyle.lineBreakMode = NSLineBreakMode.byWordWrapping
-    var attributes: [NSAttributedString.Key : Any] = [
+    var attributes: [NSAttributedString.Key: Any] = [
       NSAttributedString.Key.ligature: 0,
       NSAttributedString.Key.font: font,
       NSAttributedString.Key.kern: tracking,
-      NSAttributedString.Key.paragraphStyle: paragraphStyle
+      NSAttributedString.Key.paragraphStyle: paragraphStyle,
     ]
-    
+
     if let fillColor = fillColor {
       attributes[NSAttributedString.Key.foregroundColor] = fillColor
     }
-    
+
     let attrString = NSAttributedString(string: text, attributes: attributes)
     attributedString = attrString
-    
+
     if fillColor != nil {
       let setter = CTFramesetterCreateWithAttributedString(attrString as CFAttributedString)
       fillFrameSetter = setter
     } else {
       fillFrameSetter = nil
     }
-    
+
     if let strokeColor = strokeColor {
       attributes[NSAttributedString.Key.foregroundColor] = nil
       attributes[NSAttributedString.Key.strokeWidth] = strokeWidth
@@ -257,26 +270,25 @@ final class TextLayer: CALayer {
       strokeFrameSetter = nil
       strokeWidth = 0
     }
-    
+
     guard let setter = fillFrameSetter ?? strokeFrameSetter else {
       return
     }
-    
+
     // Calculate drawing size and anchor offset
     let textAnchor: CGPoint
     if let preferredSize = preferredSize {
       drawingRect = CGRect(origin: .zero, size: preferredSize)
       drawingRect.size.height += (ascent - capHeight)
       drawingRect.size.height += descent
-      textAnchor = CGPoint(x: 0, y: (ascent-capHeight))
+      textAnchor = CGPoint(x: 0, y: ascent - capHeight)
     } else {
       let size = CTFramesetterSuggestFrameSizeWithConstraints(
         setter,
         CFRange(location: 0, length: attrString.length),
         nil,
         CGSize(width: CGFloat.greatestFiniteMagnitude, height: CGFloat.greatestFiniteMagnitude),
-        nil
-      )
+        nil)
       switch alignment {
       case .left:
         textAnchor = CGPoint(x: 0, y: ascent)
@@ -287,18 +299,22 @@ final class TextLayer: CALayer {
       default:
         textAnchor = .zero
       }
-      drawingRect = CGRect(x: 0, y: 0, width: ceil(size.width),
-                           height: ceil(size.height))
+      drawingRect = CGRect(
+        x: 0,
+        y: 0,
+        width: ceil(size.width),
+        height: ceil(size.height))
     }
-    
+
     // Now Calculate Anchor
-    drawingAnchor = CGPoint(x: textAnchor.x.remap(fromLow: 0, fromHigh: drawingRect.size.width, toLow: 0, toHigh: 1),
-                            y: textAnchor.y.remap(fromLow: 0, fromHigh: drawingRect.size.height, toLow: 0, toHigh: 1))
+    drawingAnchor = CGPoint(
+      x: textAnchor.x.remap(fromLow: 0, fromHigh: drawingRect.size.width, toLow: 0, toHigh: 1),
+      y: textAnchor.y.remap(fromLow: 0, fromHigh: drawingRect.size.height, toLow: 0, toHigh: 1))
 
     if fillFrameSetter != nil && strokeFrameSetter != nil {
       drawingRect.size.width += strokeWidth
       drawingRect.size.height += strokeWidth
     }
   }
-  
+
 }

package/{lottie-swift/src/Private → Sources/Private/MainThread}/LayerContainers/Utility/InvertedMatteLayer.swift

@@ -8,50 +8,51 @@
 import Foundation
 import QuartzCore
 
-/**
- A layer that inverses the alpha output of its input layer.
- 
- WARNING: This is experimental and probably not very performant.
- */
+/// A layer that inverses the alpha output of its input layer.
+///
+/// WARNING: This is experimental and probably not very performant.
 final class InvertedMatteLayer: CALayer, CompositionLayerDelegate {
-  
-  let inputMatte: CompositionLayer?
-  let wrapperLayer = CALayer()
-  
+
+  // MARK: Lifecycle
+
   init(inputMatte: CompositionLayer) {
     self.inputMatte = inputMatte
     super.init()
     inputMatte.layerDelegate = self
-    self.anchorPoint = .zero
-    self.bounds = inputMatte.bounds
-    self.setNeedsDisplay()
+    anchorPoint = .zero
+    bounds = inputMatte.bounds
+    setNeedsDisplay()
   }
-  
+
   override init(layer: Any) {
     guard let layer = layer as? InvertedMatteLayer else {
       fatalError("init(layer:) wrong class.")
     }
-    self.inputMatte = nil
+    inputMatte = nil
     super.init(layer: layer)
   }
-  
-  func frameUpdated(frame: CGFloat) {
-    self.setNeedsDisplay()
-    self.displayIfNeeded()
-  }
-  
-  required init?(coder aDecoder: NSCoder) {
+
+  required init?(coder _: NSCoder) {
     fatalError("init(coder:) has not been implemented")
   }
-  
+
+  // MARK: Internal
+
+  let inputMatte: CompositionLayer?
+  let wrapperLayer = CALayer()
+
+  func frameUpdated(frame _: CGFloat) {
+    displayIfNeeded()
+  }
+
   override func draw(in ctx: CGContext) {
     guard let inputMatte = inputMatte else { return }
     guard let fillColor = CGColor(colorSpace: CGColorSpaceCreateDeviceRGB(), components: [0, 0, 0, 1])
-      else { return }
+    else { return }
     ctx.setFillColor(fillColor)
     ctx.fill(bounds)
     ctx.setBlendMode(.destinationOut)
     inputMatte.render(in: ctx)
   }
-  
+
 }

package/Sources/Private/MainThread/LayerContainers/Utility/LayerFontProvider.swift

@@ -0,0 +1,41 @@
+//
+//  LayerFontProvider.swift
+//  Lottie
+//
+//  Created by Brandon Withrow on 8/5/20.
+//  Copyright © 2020 YurtvilleProds. All rights reserved.
+//
+
+import Foundation
+
+/// Connects a LottieFontProvider to a group of text layers
+final class LayerFontProvider {
+
+  // MARK: Lifecycle
+
+  init(fontProvider: AnimationFontProvider) {
+    self.fontProvider = fontProvider
+    textLayers = []
+    reloadTexts()
+  }
+
+  // MARK: Internal
+
+  private(set) var textLayers: [TextCompositionLayer]
+
+  var fontProvider: AnimationFontProvider {
+    didSet {
+      reloadTexts()
+    }
+  }
+
+  func addTextLayers(_ layers: [TextCompositionLayer]) {
+    textLayers += layers
+  }
+
+  func reloadTexts() {
+    textLayers.forEach {
+      $0.fontProvider = fontProvider
+    }
+  }
+}

package/{lottie-swift/src/Private → Sources/Private/MainThread}/LayerContainers/Utility/LayerImageProvider.swift

@@ -9,27 +9,31 @@ import Foundation
 
 /// Connects a LottieImageProvider to a group of image layers
 final class LayerImageProvider {
-  
-  var imageProvider: AnimationImageProvider {
-    didSet {
-      reloadImages()
-    }
-  }
-  
-  fileprivate(set) var imageLayers: [ImageCompositionLayer]
-  let imageAssets: [String : ImageAsset]
-  
-  init(imageProvider: AnimationImageProvider, assets: [String : ImageAsset]?) {
+
+  // MARK: Lifecycle
+
+  init(imageProvider: AnimationImageProvider, assets: [String: ImageAsset]?) {
     self.imageProvider = imageProvider
-    self.imageLayers = [ImageCompositionLayer]()
+    imageLayers = [ImageCompositionLayer]()
     if let assets = assets {
-      self.imageAssets = assets
+      imageAssets = assets
     } else {
-      self.imageAssets = [:]
+      imageAssets = [:]
     }
     reloadImages()
   }
-  
+
+  // MARK: Internal
+
+  private(set) var imageLayers: [ImageCompositionLayer]
+  let imageAssets: [String: ImageAsset]
+
+  var imageProvider: AnimationImageProvider {
+    didSet {
+      reloadImages()
+    }
+  }
+
   func addImageLayers(_ layers: [ImageCompositionLayer]) {
     for layer in layers {
       if imageAssets[layer.imageReferenceID] != nil {
@@ -38,7 +42,7 @@ final class LayerImageProvider {
       }
     }
   }
-  
+
   func reloadImages() {
     for imageLayer in imageLayers {
       if let asset = imageAssets[imageLayer.imageReferenceID] {

package/Sources/Private/MainThread/LayerContainers/Utility/LayerTextProvider.swift

@@ -0,0 +1,40 @@
+//
+//  LayerTextProvider.swift
+//  lottie-ios-iOS
+//
+//  Created by Alexandr Goncharov on 07/06/2019.
+//
+
+import Foundation
+
+/// Connects a LottieTextProvider to a group of text layers
+final class LayerTextProvider {
+
+  // MARK: Lifecycle
+
+  init(textProvider: AnimationTextProvider) {
+    self.textProvider = textProvider
+    textLayers = []
+    reloadTexts()
+  }
+
+  // MARK: Internal
+
+  private(set) var textLayers: [TextCompositionLayer]
+
+  var textProvider: AnimationTextProvider {
+    didSet {
+      reloadTexts()
+    }
+  }
+
+  func addTextLayers(_ layers: [TextCompositionLayer]) {
+    textLayers += layers
+  }
+
+  func reloadTexts() {
+    textLayers.forEach {
+      $0.textProvider = textProvider
+    }
+  }
+}