Avoid var parameters - which will be deprecated with Swift 3.0

Added colorLerpMode

KDCircularProgress.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name = 'KDCircularProgress'
-  s.version = '1.0'
+  s.version = '1.3.4'
   s.license = 'MIT'
   s.summary = 'A circular progress view with gradients written in Swift'
   s.homepage = 'https://github.com/kaandedeoglu/KDCircularProgress'
@@ -11,4 +11,4 @@ Pod::Spec.new do |s|
 
   s.source_files = 'KDCircularProgress/*.swift'
   s.requires_arc = true
-end
+end

KDCircularProgress/KDCircularProgress.swift

@@ -37,6 +37,28 @@ public class KDCircularProgress: UIView {
             }
         }
         
+        static func InverseLerp(value: CGFloat, minMax: (CGFloat, CGFloat)) -> CGFloat {
+            return (value - minMax.0) / (minMax.1 - minMax.0)
+        }
+        
+        static func Lerp(value: CGFloat, minMax: (CGFloat, CGFloat)) -> CGFloat {
+            return (minMax.1 - minMax.0) * value + minMax.0
+        }
+        
+        static func ColorLerp(value: CGFloat, minMax: (UIColor, UIColor)) -> UIColor {
+            let clampedValue = Clamp(value, minMax: (0, 1))
+            
+            let zero: CGFloat = 0
+            
+            var (r0, g0, b0, a0) = (zero, zero, zero, zero)
+            minMax.0.getRed(&r0, green: &g0, blue: &b0, alpha: &a0)
+            
+            var (r1, g1, b1, a1) = (zero, zero, zero, zero)
+            minMax.1.getRed(&r1, green: &g1, blue: &b1, alpha: &a1)
+            
+            return UIColor(red: Lerp(clampedValue, minMax: (r0, r1)), green: Lerp(clampedValue, minMax: (g0, g1)), blue: Lerp(clampedValue, minMax: (b0, b1)), alpha: Lerp(clampedValue, minMax: (a0, a1)))
+        }
+        
         static func Mod(value: Int, range: Int, minMax: (Int, Int)) -> Int {
             let (min, max) = minMax
             assert(abs(range) <= abs(max - min), "range should be <= than the interval")
@@ -91,6 +113,12 @@ public class KDCircularProgress: UIView {
         }
     }
     
+    @IBInspectable public var lerpColorMode: Bool = false {
+        didSet {
+            progressLayer.lerpColorMode = lerpColorMode
+        }
+    }
+    
     @IBInspectable public var gradientRotateSpeed: CGFloat = 0 {
         didSet {
             progressLayer.gradientRotateSpeed = gradientRotateSpeed
@@ -130,6 +158,16 @@ public class KDCircularProgress: UIView {
         }
     }
     
+    @IBInspectable public var progressInsideFillColor: UIColor? = nil {
+        didSet {
+            if let color = progressInsideFillColor {
+                progressLayer.progressInsideFillColor = color
+            } else {
+                progressLayer.progressInsideFillColor = UIColor.clearColor()
+            }
+        }
+    }
+    
     @IBInspectable public var progressColors: [UIColor]! {
         get {
             return progressLayer.colorsArray
@@ -142,9 +180,9 @@ public class KDCircularProgress: UIView {
     
     //These are used only from the Interface-Builder. Changing these from code will have no effect.
     //Also IB colors are limited to 3, whereas programatically we can have an arbitrary number of them.
-    @IBInspectable public var IBColor1: UIColor?
-    @IBInspectable public var IBColor2: UIColor?
-    @IBInspectable public var IBColor3: UIColor?
+    @objc @IBInspectable private var IBColor1: UIColor?
+    @objc @IBInspectable private var IBColor2: UIColor?
+    @objc @IBInspectable private var IBColor3: UIColor?
     
     
     private var animationCompletionBlock: ((Bool) -> Void)?
@@ -161,23 +199,28 @@ public class KDCircularProgress: UIView {
         self.init(frame: frame)
         setColors(colors)
     }
-
+    
     required public init(coder aDecoder: NSCoder) {
-		super.init(coder: aDecoder)
-		setTranslatesAutoresizingMaskIntoConstraints(false)
-		userInteractionEnabled = false
-		setInitialValues()
+        super.init(coder: aDecoder)!
+        translatesAutoresizingMaskIntoConstraints = false
+        userInteractionEnabled = false
+        setInitialValues()
         refreshValues()
-	}
+    }
     
     public override func awakeFromNib() {
         checkAndSetIBColors()
     }
-	
+    
     override public class func layerClass() -> AnyClass {
         return KDCircularProgressViewLayer.self
     }
     
+    public override func layoutSubviews() {
+        super.layoutSubviews()
+        radius = (frame.size.width/2.0) * 0.8
+    }
+    
     private func setInitialValues() {
         radius = (frame.size.width/2.0) * 0.8 //We always apply a 20% padding, stopping glows from being clipped
         backgroundColor = .clearColor()
@@ -189,6 +232,7 @@ public class KDCircularProgress: UIView {
         progressLayer.startAngle = UtilityFunctions.Mod(startAngle, range: 360, minMax: (0,360))
         progressLayer.clockwise = clockwise
         progressLayer.roundedCorners = roundedCorners
+        progressLayer.lerpColorMode = lerpColorMode
         progressLayer.gradientRotateSpeed = gradientRotateSpeed
         progressLayer.glowAmount = UtilityFunctions.Clamp(glowAmount, minMax: (0, 1))
         progressLayer.glowMode = glowMode
@@ -213,15 +257,24 @@ public class KDCircularProgress: UIView {
         progressLayer.setNeedsDisplay()
     }
     
-    public func animateFromAngle(fromAngle: Int, toAngle: Int, duration: NSTimeInterval, completion: ((Bool) -> Void)?) {
+    public func animateFromAngle(fromAngle: Int, toAngle: Int, duration: NSTimeInterval, relativeDuration: Bool = true, completion: ((Bool) -> Void)?) {
         if isAnimating() {
             pauseAnimation()
         }
-
+        
+        let animationDuration: NSTimeInterval
+        if relativeDuration {
+            animationDuration = duration
+        } else {
+            let traveledAngle = UtilityFunctions.Mod(toAngle - fromAngle, range: 360, minMax: (0, 360))
+            let scaledDuration = (NSTimeInterval(traveledAngle) * duration) / 360
+            animationDuration = scaledDuration
+        }
+        
         let animation = CABasicAnimation(keyPath: "angle")
         animation.fromValue = fromAngle
         animation.toValue = toAngle
-        animation.duration = duration
+        animation.duration = animationDuration
         animation.delegate = self
         angle = toAngle
         animationCompletionBlock = completion
@@ -229,15 +282,15 @@ public class KDCircularProgress: UIView {
         progressLayer.addAnimation(animation, forKey: "angle")
     }
     
-    public func animateToAngle(toAngle: Int, duration: NSTimeInterval, completion: ((Bool) -> Void)?) {
+    public func animateToAngle(toAngle: Int, duration: NSTimeInterval, relativeDuration: Bool = true, completion: ((Bool) -> Void)?) {
         if isAnimating() {
             pauseAnimation()
         }
-        animateFromAngle(angle, toAngle: toAngle, duration: duration, completion: completion)
+        animateFromAngle(angle, toAngle: toAngle, duration: duration, relativeDuration: relativeDuration, completion: completion)
     }
     
     public func pauseAnimation() {
-        let presentationLayer = progressLayer.presentationLayer() as! KDCircularProgressViewLayer
+        guard let presentationLayer = progressLayer.presentationLayer() as? KDCircularProgressViewLayer else { return }
         let currentValue = presentationLayer.angle
         progressLayer.removeAllAnimations()
         animationCompletionBlock = nil
@@ -245,7 +298,6 @@ public class KDCircularProgress: UIView {
     }
     
     public func stopAnimation() {
-        let presentationLayer = progressLayer.presentationLayer() as! KDCircularProgressViewLayer
         progressLayer.removeAllAnimations()
         angle = 0
     }
@@ -254,7 +306,7 @@ public class KDCircularProgress: UIView {
         return progressLayer.animationForKey("angle") != nil
     }
     
-    override public func animationDidStop(anim: CAAnimation!, finished flag: Bool) {
+    override public func animationDidStop(anim: CAAnimation, finished flag: Bool) {
         if let completionBlock = animationCompletionBlock {
             completionBlock(flag)
             animationCompletionBlock = nil
@@ -282,27 +334,42 @@ public class KDCircularProgress: UIView {
     
     private class KDCircularProgressViewLayer: CALayer {
         @NSManaged var angle: Int
-        var radius: CGFloat!
+        var radius: CGFloat! {
+            didSet {
+                invalidateGradientCache()
+            }
+        }
         var startAngle: Int!
-        var clockwise: Bool!
+        var clockwise: Bool! {
+            didSet {
+                if clockwise != oldValue {
+                    invalidateGradientCache()
+                }
+            }
+        }
         var roundedCorners: Bool!
-        var gradientRotateSpeed: CGFloat!
+        var lerpColorMode: Bool!
+        var gradientRotateSpeed: CGFloat! {
+            didSet {
+                invalidateGradientCache()
+            }
+        }
         var glowAmount: CGFloat!
         var glowMode: KDCircularProgressGlowMode!
         var progressThickness: CGFloat!
         var trackThickness: CGFloat!
         var trackColor: UIColor!
+        var progressInsideFillColor: UIColor = UIColor.clearColor()
         var colorsArray: [UIColor]! {
             didSet {
-                gradientCache = nil
-                locationsCache = nil
+                invalidateGradientCache()
             }
         }
-        var gradientCache: CGGradientRef?
-        var locationsCache: [CGFloat]?
+        private var gradientCache: CGGradientRef?
+        private var locationsCache: [CGFloat]?
         
-        struct GlowConstants {
-            static let sizeToGlowRatio: CGFloat = 0.00015
+        private struct GlowConstants {
+            private static let sizeToGlowRatio: CGFloat = 0.00015
             static func glowAmountForAngle(angle: Int, glowAmount: CGFloat, glowMode: KDCircularProgressGlowMode, size: CGFloat) -> CGFloat {
                 switch glowMode {
                 case .Forward:
@@ -317,11 +384,11 @@ public class KDCircularProgress: UIView {
             }
         }
         
-        override class func needsDisplayForKey(key: String!) -> Bool {
+        override class func needsDisplayForKey(key: String) -> Bool {
             return key == "angle" ? true : super.needsDisplayForKey(key)
         }
         
-        override init!(layer: AnyObject!) {
+        override init(layer: AnyObject) {
             super.init(layer: layer)
             let progressLayer = layer as! KDCircularProgressViewLayer
             radius = progressLayer.radius
@@ -329,6 +396,7 @@ public class KDCircularProgress: UIView {
             startAngle = progressLayer.startAngle
             clockwise = progressLayer.clockwise
             roundedCorners = progressLayer.roundedCorners
+            lerpColorMode = progressLayer.lerpColorMode
             gradientRotateSpeed = progressLayer.gradientRotateSpeed
             glowAmount = progressLayer.glowAmount
             glowMode = progressLayer.glowMode
@@ -336,17 +404,18 @@ public class KDCircularProgress: UIView {
             trackThickness = progressLayer.trackThickness
             trackColor = progressLayer.trackColor
             colorsArray = progressLayer.colorsArray
+            progressInsideFillColor = progressLayer.progressInsideFillColor
         }
-
-        override init!() {
+        
+        override init() {
             super.init()
         }
-
-        required init(coder aDecoder: NSCoder) {
+        
+        required init?(coder aDecoder: NSCoder) {
             super.init(coder: aDecoder)
         }
         
-        override func drawInContext(ctx: CGContext!) {
+        override func drawInContext(ctx: CGContext) {
             UIGraphicsPushContext(ctx)
             let rect = bounds
             let size = rect.size
@@ -356,10 +425,12 @@ public class KDCircularProgress: UIView {
             let arcRadius = max(radius - trackLineWidth/2, radius - progressLineWidth/2)
             CGContextAddArc(ctx, CGFloat(size.width/2.0), CGFloat(size.height/2.0), arcRadius, 0, CGFloat(M_PI * 2), 0)
             trackColor.set()
+            CGContextSetStrokeColorWithColor(ctx, trackColor.CGColor)
+            CGContextSetFillColorWithColor(ctx, progressInsideFillColor.CGColor)
             CGContextSetLineWidth(ctx, trackLineWidth)
-            CGContextSetLineCap(ctx, kCGLineCapButt)
-            CGContextDrawPath(ctx, kCGPathStroke)
-
+            CGContextSetLineCap(ctx, CGLineCap.Butt)
+            CGContextDrawPath(ctx, .FillStroke)
+            
             UIGraphicsBeginImageContextWithOptions(size, false, 0.0)
             let imageCtx = UIGraphicsGetCurrentContext()
             let reducedAngle = UtilityFunctions.Mod(angle, range: 360, minMax: (0, 360))
@@ -370,18 +441,18 @@ public class KDCircularProgress: UIView {
             if glowValue > 0 {
                 CGContextSetShadowWithColor(imageCtx, CGSizeZero, glowValue, UIColor.blackColor().CGColor)
             }
-            CGContextSetLineCap(imageCtx, roundedCorners == true ? kCGLineCapRound : kCGLineCapButt)
+            CGContextSetLineCap(imageCtx, roundedCorners == true ? .Round : .Butt)
             CGContextSetLineWidth(imageCtx, progressLineWidth)
-            CGContextDrawPath(imageCtx, kCGPathStroke)
+            CGContextDrawPath(imageCtx, .Stroke)
             
-            let drawMask: CGImageRef = CGBitmapContextCreateImage(UIGraphicsGetCurrentContext())
+            let drawMask: CGImageRef = CGBitmapContextCreateImage(UIGraphicsGetCurrentContext())!
             UIGraphicsEndImageContext()
             
             CGContextSaveGState(ctx)
             CGContextClipToMask(ctx, bounds, drawMask)
             
             //Gradient - Fill
-            if colorsArray.count > 1 {
+            if !lerpColorMode && colorsArray.count > 1 {
                 var componentsArray: [CGFloat] = []
                 let rgbColorsArray: [UIColor] = colorsArray.map {c in // Make sure every color in colors array is in RGB color space
                     if CGColorGetNumberOfComponents(c.CGColor) == 2 {
@@ -394,35 +465,54 @@ public class KDCircularProgress: UIView {
                 
                 for color in rgbColorsArray {
                     let colorComponents: UnsafePointer<CGFloat> = CGColorGetComponents(color.CGColor)
-                    componentsArray.extend([colorComponents[0],colorComponents[1],colorComponents[2],1.0])
+                    componentsArray.appendContentsOf([colorComponents[0],colorComponents[1],colorComponents[2],1.0])
                 }
                 
                 drawGradientWithContext(ctx, componentsArray: componentsArray)
             } else {
-                if colorsArray.count == 1 {
-                    fillRectWithContext(ctx, color: colorsArray[0])
+                
+                var color: UIColor! = nil
+                if colorsArray.count == 0 {
+                    color = UIColor.whiteColor()
+                } else if colorsArray.count == 1 {
+                    color = colorsArray[0]
                 } else {
-                    fillRectWithContext(ctx, color: UIColor(red: 1.0, green: 1.0, blue: 1.0, alpha: 1.0))
+                    
+                    // lerpColorMode is true
+                    
+                    let t = CGFloat(reducedAngle) / 360
+                    let steps = colorsArray.count - 1;
+                    let step = 1 / CGFloat(steps);
+                    for i in 1...steps {
+                        let fi = CGFloat(i)
+                        if (t <= fi * step || i == steps) {
+                            let colorT = UtilityFunctions.InverseLerp(t, minMax: ((fi - 1) * step, fi * step))
+                            color = UtilityFunctions.ColorLerp(colorT, minMax: (colorsArray[i - 1], colorsArray[i]));
+                            break;
+                        }
+                    }
                 }
+                
+                fillRectWithContext(ctx, color: color)
             }
             CGContextRestoreGState(ctx)
             UIGraphicsPopContext()
         }
         
-        func fillRectWithContext(ctx: CGContext!, color: UIColor) {
+        private func fillRectWithContext(ctx: CGContext!, color: UIColor) {
             CGContextSetFillColorWithColor(ctx, color.CGColor)
             CGContextFillRect(ctx, bounds)
         }
         
-        func drawGradientWithContext(ctx: CGContext!, componentsArray: [CGFloat]) {
+        private func drawGradientWithContext(ctx: CGContext!, componentsArray: [CGFloat]) {
             let baseSpace = CGColorSpaceCreateDeviceRGB()
             let locations = locationsCache ?? gradientLocationsFromColorCount(componentsArray.count/4, gradientWidth: bounds.size.width)
             let gradient: CGGradient
-
+            
             if let g = self.gradientCache {
                 gradient = g
             } else {
-                let g = CGGradientCreateWithColorComponents(baseSpace, componentsArray, locations,componentsArray.count / 4)
+                guard let g = CGGradientCreateWithColorComponents(baseSpace, componentsArray, locations,componentsArray.count / 4) else { return }
                 self.gradientCache = g
                 gradient = g
             }
@@ -431,15 +521,15 @@ public class KDCircularProgress: UIView {
             let floatPi = CGFloat(M_PI)
             let rotateSpeed = clockwise == true ? gradientRotateSpeed : gradientRotateSpeed * -1
             let angleInRadians = ConversionFunctions.DegreesToRadians(rotateSpeed * CGFloat(angle) - 90)
-            var oppositeAngle = angleInRadians > floatPi ? angleInRadians - floatPi : angleInRadians + floatPi
+            let oppositeAngle = angleInRadians > floatPi ? angleInRadians - floatPi : angleInRadians + floatPi
             
             let startPoint = CGPoint(x: (cos(angleInRadians) * halfX) + halfX, y: (sin(angleInRadians) * halfX) + halfX)
             let endPoint = CGPoint(x: (cos(oppositeAngle) * halfX) + halfX, y: (sin(oppositeAngle) * halfX) + halfX)
             
-            CGContextDrawLinearGradient(ctx, gradient, startPoint, endPoint, 0)
+            CGContextDrawLinearGradient(ctx, gradient, startPoint, endPoint, .DrawsBeforeStartLocation)
         }
         
-        func gradientLocationsFromColorCount(colorCount: Int, gradientWidth: CGFloat) -> [CGFloat] {
+        private func gradientLocationsFromColorCount(colorCount: Int, gradientWidth: CGFloat) -> [CGFloat] {
             if colorCount == 0 || gradientWidth == 0 {
                 return []
             } else {
@@ -457,5 +547,10 @@ public class KDCircularProgress: UIView {
                 return result
             }
         }
+        
+        private func invalidateGradientCache() {
+            gradientCache = nil
+            locationsCache = nil
+        }
     }
 }

KDCircularProgressExample/KDCircularProgressExample.xcodeproj/project.pbxproj

@@ -168,6 +168,7 @@
 		BC9E757E1A8CE4A500B1DF3D /* Project object */ = {
 			isa = PBXProject;
 			attributes = {
+				LastSwiftUpdateCheck = 0700;
 				LastUpgradeCheck = 0610;
 				ORGANIZATIONNAME = "Kaan Dedeoglu";
 				TargetAttributes = {
@@ -418,6 +419,7 @@
 				BC9E75A71A8CE4A500B1DF3D /* Release */,
 			);
 			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
 		};
 		BC9E75A81A8CE4A500B1DF3D /* Build configuration list for PBXNativeTarget "KDCircularProgressExampleTests" */ = {
 			isa = XCConfigurationList;
@@ -426,6 +428,7 @@
 				BC9E75AA1A8CE4A500B1DF3D /* Release */,
 			);
 			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
 		};
 /* End XCConfigurationList section */
 	};

KDCircularProgressExample/KDCircularProgressExample/Base.lproj/Main.storyboard

@@ -1,7 +1,8 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="7706" systemVersion="14D136" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" initialViewController="vXZ-lx-hvc">
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="8191" systemVersion="15A284" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" initialViewController="vXZ-lx-hvc">
     <dependencies>
-        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="7703"/>
+        <deployment identifier="iOS"/>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="8154"/>
         <capability name="Aspect ratio constraints" minToolsVersion="5.1"/>
     </dependencies>
     <scenes>
@@ -19,6 +20,7 @@
                         <subviews>
                             <slider opaque="NO" contentMode="scaleToFill" contentHorizontalAlignment="center" contentVerticalAlignment="center" minValue="0.0" maxValue="360" translatesAutoresizingMaskIntoConstraints="NO" id="BHN-x6-Zsx">
                                 <rect key="frame" x="61" y="478" width="198" height="31"/>
+                                <animations/>
                                 <constraints>
                                     <constraint firstAttribute="height" constant="30" id="6DH-hv-h4S"/>
                                     <constraint firstAttribute="width" constant="194" id="oTI-kD-sOa"/>
@@ -29,6 +31,7 @@
                             </slider>
                             <button opaque="NO" contentMode="scaleToFill" contentHorizontalAlignment="center" contentVerticalAlignment="center" buttonType="roundedRect" lineBreakMode="middleTruncation" translatesAutoresizingMaskIntoConstraints="NO" id="5M2-Yi-RuL">
                                 <rect key="frame" x="112" y="523" width="96" height="30"/>
+                                <animations/>
                                 <constraints>
                                     <constraint firstAttribute="width" constant="96" id="T9z-qf-POZ"/>
                                     <constraint firstAttribute="height" constant="30" id="h5a-bV-EMl"/>
@@ -42,6 +45,7 @@
                             </button>
                             <view contentMode="scaleToFill" translatesAutoresizingMaskIntoConstraints="NO" id="wev-Tz-pfW" customClass="KDCircularProgress" customModule="KDCircularProgressExample" customModuleProvider="target">
                                 <rect key="frame" x="60" y="20" width="200" height="200"/>
+                                <animations/>
                                 <color key="backgroundColor" white="1" alpha="1" colorSpace="calibratedWhite"/>
                                 <constraints>
                                     <constraint firstAttribute="width" constant="200" id="191-H5-EIc"/>
@@ -80,6 +84,7 @@
                                 </userDefinedRuntimeAttributes>
                             </view>
                         </subviews>
+                        <animations/>
                         <color key="backgroundColor" red="0.4736600907821229" green="0.4736600907821229" blue="0.4736600907821229" alpha="1" colorSpace="calibratedRGB"/>
                         <constraints>
                             <constraint firstAttribute="centerX" secondItem="BHN-x6-Zsx" secondAttribute="centerX" id="Arq-5P-YRp"/>
@@ -96,9 +101,4 @@
             <point key="canvasLocation" x="410" y="396"/>
         </scene>
     </scenes>
-    <simulatedMetricsContainer key="defaultSimulatedMetrics">
-        <simulatedStatusBarMetrics key="statusBar"/>
-        <simulatedOrientationMetrics key="orientation"/>
-        <simulatedScreenMetrics key="destination" type="retina4"/>
-    </simulatedMetricsContainer>
 </document>

KDCircularProgressExample/KDCircularProgressExample/ViewController.swift

@@ -35,11 +35,11 @@ class ViewController: UIViewController {
     }
     
     @IBAction func animateButtonTapped(sender: UIButton) {
-        progress.animateToAngle(360, duration: 5) { completed in
+        progress.animateFromAngle(0, toAngle: 360, duration: 5) { completed in
             if completed {
-                println("animation stopped, completed")
+                print("animation stopped, completed")
             } else {
-                println("animation stopped, was interrupted")
+                print("animation stopped, was interrupted")
             }
         }
     }

README.md

@@ -1,11 +1,16 @@
 # KDCircularProgress
-`KDCircularProgress` is a circular progress view written in Swift. It makes it possible to have gradients in the progress view, along with glows and animations. Here's an example
+`KDCircularProgress` is a circular progress view written in Swift. It makes it possible to have gradients in the progress view, along with glows and animations. 
+
+KDCircularProgress also has `IBInspectable` and `IBDesignable` support, so you can configure and preview inside the `Interface Builder`. 
+
+Here's an example
 
 [Youtube Link](http://youtu.be/iIdas72MXOg)
 
 
-[![Screenshot](https://raw.githubusercontent.com/kaandedeoglu/KDCircularProgress/master/screenshot.png)](http://youtu.be/iIdas72MXOg)
+![Screenshot](https://raw.githubusercontent.com/kaandedeoglu/KDCircularProgress/master/screenshot.gif)
 
+![Screenshot](https://raw.githubusercontent.com/kaandedeoglu/KDCircularProgress/master/screenshot.png)
 ![Screenshot](https://raw.githubusercontent.com/kaandedeoglu/KDCircularProgress/master/screenshot2.jpg)
 ![Screenshot](https://raw.githubusercontent.com/kaandedeoglu/KDCircularProgress/master/screenshot3.jpg)
 ![Screenshot](https://raw.githubusercontent.com/kaandedeoglu/KDCircularProgress/master/screenshot4.jpg)
@@ -29,11 +34,14 @@ view.addSubview(progress)
 ```
 
 ## Installation
-- It's on Cocoapods under the name (you guessed it!) KDCircularProgress
+- It's on CocoaPods under the name (you guessed it!) KDCircularProgress
 - Just drag `KDCircularProgress.swift` into your project. `Carthage` support is on To-do list.
 
 ## Properties
 
+####progressColors: `[UIColor]`
+The colors used to generate the gradient of the progress. You can also set this using the variadic `setColors(UIColor...)` method. A gradient is used only if there is more than one color. A fill is used otherwise. The default is a white fill.
+
 ####angle: `Int`
 The angle of the progress. Between 0 and 360 (inclusive). Simply change its value in order to change the visual progress of the component. Default is 0.
 
@@ -47,7 +55,7 @@ Clockwise if true, Counter-clockwise if false. Default is true.
 When true, the ends of the progress track will be drawn with a half circle radius. Default is false.
 
 ####gradientRotateSpeed: `CGFloat`
-Describes how many times the underlying gradient will turn for each full cycle of the progress. Integer values recommended. Default is 0.
+Describes how many times the underlying gradient will perform a 2π rotation for each full cycle of the progress. Integer values recommended. Default is 0.
 
 ####glowAmount: `CGFloat`
 The intensity of the glow. Between 0 and 1.0. Default is 1.0.
@@ -70,10 +78,10 @@ The thickness of the progress. Between 0 and 1. Default is 0.4
 The thickness of the background track. Between 0 and 1. Default is 0.5
 
 ####trackColor: `UIColor`
-The color of the background track. Default is black.
+The color of the background track. Default is `UIColor.blackColor()`.
 
-####progressColors: `[UIColor]`
-The colors used to generate the gradient of the progress. You can also set this using the variadic setColors(UIColor...) method. A gradient is used only if there is more than one color. A fill is used otherwise. The default is a white fill.
+####progressInsideFillColor: `UIColor`
+The color of the center of the circle. Default is `UIColor.clearColor()`.
 
 ##Methods
 ```swift 
@@ -93,11 +101,13 @@ public func setColors(colors: UIColor...)
 Set the colors for the progress gradient.
 
 ```swift
-public func animateFromAngle(fromAngle: Int, toAngle: Int, duration: NSTimeInterval, completion: ((Bool) -> Void)?)
+public func animateFromAngle(fromAngle: Int, toAngle: Int, duration: NSTimeInterval, relativeDuration: Bool = true, completion: ((Bool) -> Void)?)
 ```
 
 Animate the progress from an initial value to a final value, with a completion block that fires after the animation is done.
 
+`relativeDuration` - specify if the duration is for the specific animation or is the duration that would make a full turn.
+
 ```swift
 public func animateToAngle(toAngle: Int, duration: NSTimeInterval, completion: ((Bool) -> Void)?)
 ```
@@ -122,8 +132,8 @@ Prefering light colors in the gradients gives better results. As mentioned befor
 ##To-Do
 - [x] Add example project
 - [ ] Carthage Support
-- [x] Cocoapods Support
-- [ ] IBDesignable/IBInspectable support
+- [x] CocoaPods Support
+- [x] IBDesignable/IBInspectable support
 - [ ] Adding a `progress` property as an alternative to `angle`
 - [ ] Clean up