Temp

submodules/TelegramUI/Sources/RadialProgressNode.swift

@@ -0,0 +1,369 @@
+import Foundation
+import UIKit
+import AsyncDisplayKit
+import SwiftSignalKit
+import Display
+import LegacyComponents
+
+private class RadialProgressParameters: NSObject {
+    let theme: RadialProgressTheme
+    let diameter: CGFloat
+    let state: RadialProgressState
+    
+    init(theme: RadialProgressTheme, diameter: CGFloat, state: RadialProgressState) {
+        self.theme = theme
+        self.diameter = diameter
+        self.state = state
+        
+        super.init()
+    }
+}
+
+private class RadialProgressOverlayParameters: NSObject {
+    let theme: RadialProgressTheme
+    let diameter: CGFloat
+    let state: RadialProgressState
+    
+    init(theme: RadialProgressTheme, diameter: CGFloat, state: RadialProgressState) {
+        self.theme = theme
+        self.diameter = diameter
+        self.state = state
+        
+        super.init()
+    }
+}
+
+private class RadialProgressOverlayNode: ASDisplayNode {
+    var theme: RadialProgressTheme
+    
+    var previousProgress: Float?
+    var effectiveProgress: Float = 0.0 {
+        didSet {
+            if oldValue != self.effectiveProgress {
+                self.setNeedsDisplay()
+            }
+        }
+    }
+    
+    var progressAnimationCompleted: (() -> Void)?
+    
+    var state: RadialProgressState = .None {
+        didSet {
+            if case let .Fetching(progress) = oldValue {
+                let animation = POPBasicAnimation()
+                animation.property = (POPAnimatableProperty.property(withName: "progress", initializer: { property in
+                    property?.readBlock = { node, values in
+                        values?.pointee = CGFloat((node as! RadialProgressOverlayNode).effectiveProgress)
+                    }
+                    property?.writeBlock = { node, values in
+                        (node as! RadialProgressOverlayNode).effectiveProgress = Float(values!.pointee)
+                    }
+                    property?.threshold = 0.01
+                }) as! POPAnimatableProperty)
+                animation.fromValue = CGFloat(effectiveProgress) as NSNumber
+                animation.toValue = CGFloat(progress) as NSNumber
+                animation.timingFunction = CAMediaTimingFunction(name: CAMediaTimingFunctionName.linear)
+                animation.duration = 0.2
+                animation.completionBlock = { [weak self] _, _ in
+                    self?.progressAnimationCompleted?()
+                }
+                self.pop_removeAnimation(forKey: "progress")
+                self.pop_add(animation, forKey: "progress")
+            }
+            self.setNeedsDisplay()
+        }
+    }
+    
+    init(theme: RadialProgressTheme) {
+        self.theme = theme
+        
+        super.init()
+        
+        self.isOpaque = false
+        self.displaysAsynchronously = true
+    }
+    
+    func updateTheme(_ theme: RadialProgressTheme) {
+        self.theme = theme
+        self.setNeedsDisplay()
+    }
+    
+    override func drawParameters(forAsyncLayer layer: _ASDisplayLayer) -> NSObjectProtocol? {
+        var updatedState = self.state
+        if case .Fetching = updatedState {
+            updatedState = .Fetching(progress: self.effectiveProgress)
+        }
+        return RadialProgressOverlayParameters(theme: self.theme, diameter: self.frame.size.width, state: updatedState)
+    }
+    
+    @objc override class func draw(_ bounds: CGRect, withParameters parameters: Any?, isCancelled: () -> Bool, isRasterizing: Bool) {
+        let context = UIGraphicsGetCurrentContext()!
+        
+        if !isRasterizing {
+            context.setBlendMode(.copy)
+            context.setFillColor(UIColor.clear.cgColor)
+            context.fill(bounds)
+        }
+        
+        if let parameters = parameters as? RadialProgressOverlayParameters {
+            context.setStrokeColor(parameters.theme.foregroundColor.cgColor)
+            //CGContextSetLineWidth(context, 2.5)
+            //CGContextSetLineCap(context, .Round)
+            
+            switch parameters.state {
+                case .None, .Remote, .Play, .Pause, .Icon, .Image:
+                    break
+                case let .Fetching(progress):
+                    let startAngle = -CGFloat.pi / 2.0
+                    let endAngle = CGFloat(progress) * 2.0 * CGFloat.pi + startAngle
+                    
+                    let pathDiameter = parameters.diameter - 2.25 - 2.5 * 2.0
+                    
+                    let path = UIBezierPath(arcCenter: CGPoint(x: parameters.diameter / 2.0, y: parameters.diameter / 2.0), radius: pathDiameter / 2.0, startAngle: startAngle, endAngle:endAngle, clockwise:true)
+                    path.lineWidth = 2.25;
+                    path.lineCapStyle = .round;
+                    path.stroke()
+            }
+        }
+    }
+    
+    override func willEnterHierarchy() {
+        super.willEnterHierarchy()
+        
+        let basicAnimation = CABasicAnimation(keyPath: "transform.rotation.z")
+        basicAnimation.timingFunction = CAMediaTimingFunction(name: CAMediaTimingFunctionName.easeInEaseOut)
+        basicAnimation.duration = 2.0
+        basicAnimation.fromValue = NSNumber(value: Float(0.0))
+        basicAnimation.toValue = NSNumber(value: Float.pi * 2.0)
+        basicAnimation.repeatCount = Float.infinity
+        basicAnimation.timingFunction = CAMediaTimingFunction(name: CAMediaTimingFunctionName.linear)
+        
+        self.layer.add(basicAnimation, forKey: "progressRotation")
+    }
+    
+    override func didExitHierarchy() {
+        super.didExitHierarchy()
+        
+        self.layer.removeAnimation(forKey: "progressRotation")
+    }
+}
+
+public enum RadialProgressState {
+    case None
+    case Remote
+    case Fetching(progress: Float)
+    case Play
+    case Pause
+    case Icon
+    case Image(UIImage)
+}
+
+public struct RadialProgressTheme {
+    public let backgroundColor: UIColor
+    public let foregroundColor: UIColor
+    public let icon: UIImage?
+}
+
+class RadialProgressNode: ASControlNode {
+    private var theme: RadialProgressTheme
+    private let overlay: RadialProgressOverlayNode
+    
+    var state: RadialProgressState = .None {
+        didSet {
+            self.overlay.state = self.state
+            if case .Fetching = self.state {
+                if self.overlay.supernode == nil {
+                    self.addSubnode(self.overlay)
+                }
+            } else {
+                if self.overlay.supernode != nil {
+                    /*if case let .Fetching(progress) = oldValue {
+                        let overlay = self.overlay
+                        overlay.state = .Fetching(progress: 1.0)
+                        overlay.progressAnimationCompleted = { [weak overlay] in
+                            overlay?.removeFromSupernode()
+                        }
+                    } else {*/
+                        self.overlay.removeFromSupernode()
+                    //}
+                }
+            }
+            switch oldValue {
+                case .Fetching:
+                    switch self.state {
+                        case .Fetching:
+                            break
+                        default:
+                            self.setNeedsDisplay()
+                    }
+                case .Remote:
+                    switch self.state {
+                        case .Remote:
+                            break
+                        default:
+                            self.setNeedsDisplay()
+                    }
+                case .None:
+                    switch self.state {
+                        case .None:
+                            break
+                        default:
+                            self.setNeedsDisplay()
+                    }
+                case .Play:
+                    switch self.state {
+                        case .Play:
+                            break
+                        default:
+                            self.setNeedsDisplay()
+                    }
+                case .Pause:
+                    switch self.state {
+                        case .Pause:
+                            break
+                        default:
+                            self.setNeedsDisplay()
+                    }
+                case .Icon:
+                    switch self.state {
+                        case .Icon:
+                            break
+                        default:
+                            self.setNeedsDisplay()
+                    }
+                case let .Image(lhsImage):
+                    if case let .Image(rhsImage) = self.state, lhsImage === rhsImage {
+                        break
+                    } else {
+                        self.setNeedsDisplay()
+                    }
+            }
+        }
+    }
+    
+    init(theme: RadialProgressTheme) {
+        self.theme = theme
+        self.overlay = RadialProgressOverlayNode(theme: theme)
+        
+        super.init()
+        
+        self.isOpaque = false
+    }
+    
+    func updateTheme(_ theme: RadialProgressTheme) {
+        self.theme = theme
+        self.setNeedsDisplay()
+        self.overlay.updateTheme(theme)
+    }
+    
+    override var frame: CGRect {
+        get {
+            return super.frame
+        } set(value) {
+            let redraw = value.size != self.frame.size
+            super.frame = value
+            
+            if redraw {
+                self.overlay.frame = CGRect(origin: CGPoint(), size: value.size)
+                self.setNeedsDisplay()
+                self.overlay.setNeedsDisplay()
+            }
+        }
+    }
+    
+    override func drawParameters(forAsyncLayer layer: _ASDisplayLayer) -> NSObjectProtocol? {
+        return RadialProgressParameters(theme: self.theme, diameter: self.frame.size.width, state: self.state)
+    }
+    
+    @objc override class func draw(_ bounds: CGRect, withParameters parameters: Any?, isCancelled: () -> Bool, isRasterizing: Bool) {
+        let context = UIGraphicsGetCurrentContext()!
+        
+        if !isRasterizing {
+            context.setBlendMode(.copy)
+            context.setFillColor(UIColor.clear.cgColor)
+            context.fill(bounds)
+        }
+        
+        if let parameters = parameters as? RadialProgressParameters {
+            context.setFillColor(parameters.theme.backgroundColor.cgColor)
+            context.fillEllipse(in: CGRect(origin: CGPoint(), size: CGSize(width: parameters.diameter, height: parameters.diameter)))
+            
+            switch parameters.state {
+                case .None:
+                    break
+                case .Fetching:
+                    context.setStrokeColor(parameters.theme.foregroundColor.cgColor)
+                    context.setLineWidth(2.0)
+                    context.setLineCap(.round)
+                    
+                    let crossSize: CGFloat = 14.0
+                    context.move(to: CGPoint(x: parameters.diameter / 2.0 - crossSize / 2.0, y: parameters.diameter / 2.0 - crossSize / 2.0))
+                    context.addLine(to: CGPoint(x: parameters.diameter / 2.0 + crossSize / 2.0, y: parameters.diameter / 2.0 + crossSize / 2.0))
+                    context.strokePath()
+                    context.move(to: CGPoint(x: parameters.diameter / 2.0 + crossSize / 2.0, y: parameters.diameter / 2.0 - crossSize / 2.0))
+                    context.addLine(to: CGPoint(x: parameters.diameter / 2.0 - crossSize / 2.0, y: parameters.diameter / 2.0 + crossSize / 2.0))
+                    context.strokePath()
+                case .Remote:
+                    context.setStrokeColor(parameters.theme.foregroundColor.cgColor)
+                    context.setLineWidth(2.0)
+                    context.setLineCap(.round)
+                    context.setLineJoin(.round)
+            
+                    let arrowHeadSize: CGFloat = 15.0
+                    let arrowLength: CGFloat = 18.0
+                    let arrowHeadOffset: CGFloat = 1.0
+            
+                    context.move(to: CGPoint(x: parameters.diameter / 2.0, y: parameters.diameter / 2.0 - arrowLength / 2.0 + arrowHeadOffset))
+                    context.addLine(to: CGPoint(x: parameters.diameter / 2.0, y: parameters.diameter / 2.0 + arrowLength / 2.0 - 1.0 + arrowHeadOffset))
+                    context.strokePath()
+            
+                    context.move(to: CGPoint(x: parameters.diameter / 2.0 - arrowHeadSize / 2.0, y: parameters.diameter / 2.0 + arrowLength / 2.0 - arrowHeadSize / 2.0 + arrowHeadOffset))
+                    context.addLine(to: CGPoint(x: parameters.diameter / 2.0, y: parameters.diameter / 2.0 + arrowLength / 2.0 + arrowHeadOffset))
+                    context.addLine(to: CGPoint(x: parameters.diameter / 2.0 + arrowHeadSize / 2.0, y: parameters.diameter / 2.0 + arrowLength / 2.0 - arrowHeadSize / 2.0 + arrowHeadOffset))
+                    context.strokePath()
+                case .Icon:
+                    if let icon = parameters.theme.icon {
+                        icon.draw(at: CGPoint(x: floor((parameters.diameter - icon.size.width) / 2.0), y: floor((parameters.diameter - icon.size.height) / 2.0)))
+                    }
+                case .Play:
+                    context.setFillColor(parameters.theme.foregroundColor.cgColor)
+                    
+                    let size = CGSize(width: 15.0, height: 18.0)
+                    context.translateBy(x: (parameters.diameter - size.width) / 2.0 + 1.5, y: (parameters.diameter - size.height) / 2.0)
+                    if (parameters.diameter < 40.0) {
+                        context.translateBy(x: size.width / 2.0, y: size.height / 2.0)
+                        context.scaleBy(x: 0.8, y: 0.8)
+                        context.translateBy(x: -size.width / 2.0, y: -size.height / 2.0)
+                    }
+                    let _ = try? drawSvgPath(context, path: "M1.71891969,0.209353049 C0.769586558,-0.350676705 0,0.0908839327 0,1.18800046 L0,16.8564753 C0,17.9569971 0.750549162,18.357187 1.67393713,17.7519379 L14.1073836,9.60224049 C15.0318735,8.99626906 15.0094718,8.04970371 14.062401,7.49100858 L1.71891969,0.209353049 ")
+                    context.fillPath()
+                    if (parameters.diameter < 40.0) {
+                        context.translateBy(x: size.width / 2.0, y: size.height / 2.0)
+                        context.scaleBy(x: 1.0 / 0.8, y: 1.0 / 0.8)
+                        context.translateBy(x: -size.width / 2.0, y: -size.height / 2.0)
+                    }
+                    context.translateBy(x: -(parameters.diameter - size.width) / 2.0 - 1.5, y: -(parameters.diameter - size.height) / 2.0)
+                case .Pause:
+                    context.setFillColor(parameters.theme.foregroundColor.cgColor)
+                    
+                    let size = CGSize(width: 15.0, height: 16.0)
+                    context.translateBy(x: (parameters.diameter - size.width) / 2.0, y: (parameters.diameter - size.height) / 2.0)
+                    if (parameters.diameter < 40.0) {
+                        context.translateBy(x: size.width / 2.0, y: size.height / 2.0)
+                        context.scaleBy(x: 0.8, y: 0.8)
+                        context.translateBy(x: -size.width / 2.0, y: -size.height / 2.0)
+                    }
+                    let _ = try? drawSvgPath(context, path: "M0,1.00087166 C0,0.448105505 0.443716645,0 0.999807492,0 L4.00019251,0 C4.55237094,0 5,0.444630861 5,1.00087166 L5,14.9991283 C5,15.5518945 4.55628335,16 4.00019251,16 L0.999807492,16 C0.447629061,16 0,15.5553691 0,14.9991283 L0,1.00087166 Z M10,1.00087166 C10,0.448105505 10.4437166,0 10.9998075,0 L14.0001925,0 C14.5523709,0 15,0.444630861 15,1.00087166 L15,14.9991283 C15,15.5518945 14.5562834,16 14.0001925,16 L10.9998075,16 C10.4476291,16 10,15.5553691 10,14.9991283 L10,1.00087166 ")
+                    context.fillPath()
+                    if (parameters.diameter < 40.0) {
+                        context.translateBy(x: size.width / 2.0, y: size.height / 2.0)
+                        context.scaleBy(x: 1.0 / 0.8, y: 1.0 / 0.8)
+                        context.translateBy(x: -size.width / 2.0, y: -size.height / 2.0)
+                    }
+                    context.translateBy(x: -(parameters.diameter - size.width) / 2.0, y: -(parameters.diameter - size.height) / 2.0)
+                case let .Image(image):
+                    image.draw(at: CGPoint(x: floor((parameters.diameter - image.size.width) / 2.0), y: floor((parameters.diameter - image.size.height) / 2.0)))
+            }
+        }
+    }
+}