From 50518c8c97cf2d7c67be8ef140f4c04b070080f0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robin=EF=A3=BF?= <1933549736@qq.com>
Date: Thu, 23 Nov 2017 12:02:23 +0800
Subject: [PATCH 1/2] create develop branch and to develop new version

---
 .DS_Store                                     | Bin 0 -> 6148 bytes
 AnimatedPaths.xcodeproj/project.pbxproj       |  22 +-
 .../contents.xcworkspacedata                  |   7 +
 AnimatedPaths/RCAnimatedPath.swift            | 355 ++++++++++++++++++
 AnimatedPaths/ViewController.swift            |  27 +-
 5 files changed, 397 insertions(+), 14 deletions(-)
 create mode 100644 .DS_Store
 create mode 100644 AnimatedPaths.xcodeproj/project.xcworkspace/contents.xcworkspacedata
 create mode 100644 AnimatedPaths/RCAnimatedPath.swift

diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..af7a2b9a4e0202a93901a3666069e61c5191548c
GIT binary patch
literal 6148
zcmeHK%}N774E|z!D2ULT9_Il>>>I45-i3VuOIuo{-Cf!$9``|fSiel-PjNknAR-A&
zzU)kroqVt}8vrtXn2&%VfB}c1sL>%h-MMt+&OM^!98>JEz#KQ2b|m_XQ@ZyPT%p1p
zHr)05{`Xj6_gHSLbzLp3LY#i>i3>bohMLtc&|pjJe!U!(vwG85;pfl9Z)Rv#A2VE9
zqR_!WFc1s`1Hr&g7~q|)GB`F29Sj5m!N3~>dOjo$#lo>Q%tr@RZUKmWPG_O5y@bXj
z$HK8S<O)SBlxU&iErwV)=ac&tj;*1EL%jJAfAeeeBKhsipRzloFbo|G1OtZ*XzxoI
z>ivJsPo}fU&n}^YfneajG9dj)IT^D$zgs`msdsJSxaCk$zg7(j?Sr2HKIl1emKSY3
asZGDau{G2zI-kRd@gtB42^9?d0s}9{nJ%ON

literal 0
HcmV?d00001

diff --git a/AnimatedPaths.xcodeproj/project.pbxproj b/AnimatedPaths.xcodeproj/project.pbxproj
index f6a5bcf..bb6c994 100644
--- a/AnimatedPaths.xcodeproj/project.pbxproj
+++ b/AnimatedPaths.xcodeproj/project.pbxproj
@@ -7,6 +7,7 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
+		009F0CBC1FC67E060096B0E3 /* RCAnimatedPath.swift in Sources */ = {isa = PBXBuildFile; fileRef = 009F0CBB1FC67E060096B0E3 /* RCAnimatedPath.swift */; };
 		00B299751C7C413400521D96 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 00B299741C7C413400521D96 /* AppDelegate.swift */; };
 		00B299771C7C413400521D96 /* ViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = 00B299761C7C413400521D96 /* ViewController.swift */; };
 		00B2997A1C7C413400521D96 /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 00B299781C7C413400521D96 /* Main.storyboard */; };
@@ -15,6 +16,7 @@
 /* End PBXBuildFile section */
 
 /* Begin PBXFileReference section */
+		009F0CBB1FC67E060096B0E3 /* RCAnimatedPath.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = RCAnimatedPath.swift; sourceTree = "<group>"; };
 		00B299711C7C413400521D96 /* AnimatedPaths.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = AnimatedPaths.app; sourceTree = BUILT_PRODUCTS_DIR; };
 		00B299741C7C413400521D96 /* AppDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = "<group>"; };
 		00B299761C7C413400521D96 /* ViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ViewController.swift; sourceTree = "<group>"; };
@@ -55,6 +57,7 @@
 			isa = PBXGroup;
 			children = (
 				00B299741C7C413400521D96 /* AppDelegate.swift */,
+				009F0CBB1FC67E060096B0E3 /* RCAnimatedPath.swift */,
 				00B299761C7C413400521D96 /* ViewController.swift */,
 				00B299781C7C413400521D96 /* Main.storyboard */,
 				00B2997B1C7C413400521D96 /* Assets.xcassets */,
@@ -98,7 +101,7 @@
 						CreatedOnToolsVersion = 7.2.1;
 						DevelopmentTeam = W7YDEDGW4E;
 						LastSwiftMigration = 0820;
-						ProvisioningStyle = Manual;
+						ProvisioningStyle = Automatic;
 					};
 				};
 			};
@@ -140,6 +143,7 @@
 			files = (
 				00B299771C7C413400521D96 /* ViewController.swift in Sources */,
 				00B299751C7C413400521D96 /* AppDelegate.swift in Sources */,
+				009F0CBC1FC67E060096B0E3 /* RCAnimatedPath.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -252,14 +256,16 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
-				DEVELOPMENT_TEAM = W7YDEDGW4E;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				CODE_SIGN_STYLE = Automatic;
+				DEVELOPMENT_TEAM = "";
 				INFOPLIST_FILE = AnimatedPaths/Info.plist;
 				IPHONEOS_DEPLOYMENT_TARGET = 9.0;
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
 				PRODUCT_BUNDLE_IDENTIFIER = com.Robin.AnimatedPaths;
 				PRODUCT_NAME = "$(TARGET_NAME)";
-				PROVISIONING_PROFILE = "3a51cda8-3387-4c26-a945-c8fb51508664";
-				PROVISIONING_PROFILE_SPECIFIER = "Development: Wildcard";
+				PROVISIONING_PROFILE = "";
+				PROVISIONING_PROFILE_SPECIFIER = "";
 				SWIFT_VERSION = 3.0;
 				TARGETED_DEVICE_FAMILY = 1;
 			};
@@ -269,14 +275,16 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
-				DEVELOPMENT_TEAM = W7YDEDGW4E;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				CODE_SIGN_STYLE = Automatic;
+				DEVELOPMENT_TEAM = "";
 				INFOPLIST_FILE = AnimatedPaths/Info.plist;
 				IPHONEOS_DEPLOYMENT_TARGET = 9.0;
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
 				PRODUCT_BUNDLE_IDENTIFIER = com.Robin.AnimatedPaths;
 				PRODUCT_NAME = "$(TARGET_NAME)";
-				PROVISIONING_PROFILE = "3a51cda8-3387-4c26-a945-c8fb51508664";
-				PROVISIONING_PROFILE_SPECIFIER = "Development: Wildcard";
+				PROVISIONING_PROFILE = "";
+				PROVISIONING_PROFILE_SPECIFIER = "";
 				SWIFT_VERSION = 3.0;
 				TARGETED_DEVICE_FAMILY = 1;
 			};
diff --git a/AnimatedPaths.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/AnimatedPaths.xcodeproj/project.xcworkspace/contents.xcworkspacedata
new file mode 100644
index 0000000..919434a
--- /dev/null
+++ b/AnimatedPaths.xcodeproj/project.xcworkspace/contents.xcworkspacedata
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:">
+   </FileRef>
+</Workspace>
diff --git a/AnimatedPaths/RCAnimatedPath.swift b/AnimatedPaths/RCAnimatedPath.swift
new file mode 100644
index 0000000..dbf7806
--- /dev/null
+++ b/AnimatedPaths/RCAnimatedPath.swift
@@ -0,0 +1,355 @@
+//
+//  RCAnimatedPath.swift
+//  AnimatedPaths
+//
+//  Created by Robin on 17/11/23.
+//  Copyright © 2017年 Robin. All rights reserved.
+//
+
+import UIKit
+import QuartzCore
+import CoreText
+import CoreGraphics
+
+
+
+class RCAnimatedPath
+{
+    ////////////////////////
+    // CREATE A SINGLETON //
+    
+    class var shared: RCAnimatedPath
+    {
+        struct Singleton
+        {
+            static let instance = RCAnimatedPath()
+        }
+        return Singleton.instance
+    }
+    
+    // CREATE A SINGLETON //
+    ////////////////////////
+    
+    
+    
+    var animationLayer: CALayer?
+    var pathLayer: CAShapeLayer?
+    
+    private var inputPath: CGPath!
+    private var inputDuration: CFTimeInterval = 10
+    private var inputLineWidth: CGFloat = 10
+    private var inputLineColor = UIColor.black
+    
+    private var inputRotationAngle: CGFloat = 0
+    private var inputPolygonSidesNumber: Int = 6
+    private var inputCornerRadius: Float = 8
+    
+    private var inputText = ""
+    private var inputFontSize: CGFloat = 20
+    private var inputFontName = "PingFangSC-Bold"
+    
+
+    
+    func drawAnimatedCustomPath(in view: UIView, path: CGPath, duration: CFTimeInterval, lineWidth: CGFloat, lineColor: UIColor)
+    {
+        self.inputDuration = duration
+        self.inputLineWidth = lineWidth
+        self.inputLineColor = lineColor
+        self.inputPath = path
+        
+        animationLayer = CALayer()
+        
+        animationLayer?.frame = CGRect(x: 0, y: 0, width: view.layer.bounds.width, height: view.layer.bounds.height)
+        view.layer.addSublayer(animationLayer!)
+        view.clipsToBounds = true
+        
+        setupDrawingLayer()
+        startAnimation()
+    }
+    
+    func drawAnimatedRectanglePath(in view: UIView, duration: CFTimeInterval, lineWidth: CGFloat, lineColor: UIColor)
+    {
+        self.inputDuration = duration
+        self.inputLineWidth = lineWidth
+        self.inputLineColor = lineColor
+        
+        self.inputPath = rectanglePath(view: view)
+        
+        animationLayer = CALayer()
+        
+        animationLayer?.frame = CGRect(x: 0, y: 0, width: view.layer.bounds.width, height: view.layer.bounds.height)
+        view.layer.addSublayer(animationLayer!)
+        view.clipsToBounds = true
+        
+        setupDrawingLayer()
+        startAnimation()
+    }
+    
+    func drawAnimatedPolygonPath(in view: UIView, numberOfSides polygonSidesNumber: Int?, rotationAngle: CGFloat?, polygonCornerRadius: Float?, duration: CFTimeInterval, lineWidth: CGFloat, lineColor: UIColor)
+    {
+        self.inputDuration = duration
+        self.inputLineWidth = lineWidth
+        self.inputLineColor = lineColor
+        if let _rotationAngle = rotationAngle
+        {
+            self.inputRotationAngle = _rotationAngle
+        }
+        if let _polygonSidesNumber = polygonSidesNumber
+        {
+            self.inputPolygonSidesNumber = _polygonSidesNumber
+        }
+        if let _polygonCornerRadius = polygonCornerRadius
+        {
+            self.inputCornerRadius = _polygonCornerRadius
+        }
+        
+        self.inputPath = polygonPath(view: view)
+        
+        
+        animationLayer = CALayer()
+        animationLayer?.frame = CGRect(x: 0, y: 0, width: view.layer.bounds.width, height: view.layer.bounds.height)
+        view.layer.addSublayer(animationLayer!)
+        
+        setupDrawingLayer()
+        startAnimation()
+    }
+    
+    func drawAnimatedText(in view: UIView, with text: String, duration: CFTimeInterval, lineWidth: CGFloat, textColor: UIColor, fontName: String?, fontSize: CGFloat?)
+    {
+        self.inputText = text
+        self.inputDuration = duration
+        self.inputLineWidth = lineWidth
+        self.inputLineColor = textColor
+        if let _fontSize = fontSize
+        {
+            self.inputFontSize = _fontSize
+        }
+        if let _fontName = fontName
+        {
+            self.inputFontName = _fontName
+        }
+        
+        animationLayer = CALayer()
+        animationLayer?.frame = CGRect(x: 0, y: 0, width: view.layer.bounds.width, height: view.layer.bounds.height)
+        view.layer.addSublayer(animationLayer!)
+        
+        setupTextLayer(in: view)
+        startAnimation()
+    }
+    
+    
+    func setupDrawingLayer()
+    {
+        clearLayer()
+        
+        if let _ = animationLayer
+        {
+            let pathRect: CGRect = animationLayer!.bounds
+            
+            
+            let pathShapeLayer = CAShapeLayer()
+            pathShapeLayer.frame = animationLayer!.bounds
+            pathShapeLayer.bounds = pathRect
+            pathShapeLayer.isGeometryFlipped = true
+            pathShapeLayer.path = inputPath
+            pathShapeLayer.strokeColor = inputLineColor.cgColor
+            pathShapeLayer.fillColor = nil
+            pathShapeLayer.lineWidth = inputLineWidth
+            pathShapeLayer.lineJoin = kCALineJoinBevel
+            
+            animationLayer!.addSublayer(pathShapeLayer)
+            
+            pathLayer = pathShapeLayer
+        }
+    }
+    
+    func setupTextLayer(in view: UIView)
+    {
+        clearLayer()
+        
+        if let _ = animationLayer
+        {
+            let font = CTFontCreateWithName(inputFontName as CFString?, inputFontSize, nil)
+            let attrStr = NSAttributedString(string: inputText, attributes: [kCTFontAttributeName as String: font])
+            let line = CTLineCreateWithAttributedString(attrStr)
+            let runArray = CTLineGetGlyphRuns(line)
+            
+            let letters = CGMutablePath()
+            
+            for runIndex in 0..<CFArrayGetCount(runArray) {
+                let runUnsafe: UnsafeRawPointer = CFArrayGetValueAtIndex(runArray, runIndex)
+                let run = unsafeBitCast(runUnsafe, to: CTRun.self)
+                
+                for runGlyphIndex in 0..<CTRunGetGlyphCount(run) {
+                    let thisGlyphRange = CFRangeMake(runGlyphIndex, 1)
+                    var glyph: CGGlyph = CGGlyph()
+                    var position: CGPoint = CGPoint()
+                    CTRunGetGlyphs(run, thisGlyphRange, &glyph)
+                    CTRunGetPositions(run, thisGlyphRange, &position)
+                    
+                    let letter = CTFontCreatePathForGlyph(font, glyph, nil)
+                    let t = CGAffineTransform(translationX: position.x, y: position.y);
+                    
+                    if letter == nil {
+                        continue
+                    }
+                    
+                    letters.addPath(letter!, transform:t)
+                }
+            }
+            
+            let path = UIBezierPath()
+            path.move(to: CGPoint.zero)
+            path.append(UIBezierPath(cgPath: letters))
+            
+            
+            let layer = CAShapeLayer()
+            layer.frame = CGRect(x: 0, y: 0, width: view.layer.bounds.width, height: view.layer.bounds.height)
+            layer.isGeometryFlipped = true
+            layer.path = path.cgPath
+            layer.strokeColor = inputLineColor.cgColor
+            layer.fillColor = nil
+            layer.lineWidth = inputLineWidth
+            layer.lineJoin = kCALineJoinBevel
+            
+            animationLayer!.addSublayer(layer)
+            
+            pathLayer = layer
+        }
+        
+    }
+    
+    private func startAnimation()
+    {
+        pathLayer?.removeAllAnimations()
+        
+        let pathAnimation = CABasicAnimation(keyPath: "strokeEnd")
+        pathAnimation.duration = inputDuration
+        pathAnimation.fromValue = 0.0
+        pathAnimation.toValue = 1.0
+        pathLayer?.add(pathAnimation, forKey: "strokeEnd")
+    }
+    
+        //freezes the animation until clearLayer() is called
+    func stopAnimatingWithPause()
+    {
+        if let pausedTime = pathLayer?.convertTime(CACurrentMediaTime(), from: nil)
+        {
+            pathLayer?.speed = 0.0
+            pathLayer?.timeOffset = pausedTime
+        }
+    }
+    
+        //clears the animation layers
+    func stopAnimatingWithClear()
+    {
+        clearLayer()
+    }
+    
+    func clearLayer()
+    {
+        if let _ = pathLayer
+        {
+            pathLayer?.removeFromSuperlayer()
+            pathLayer = nil
+        }
+    }
+    
+    
+    /// CREATE PATH ///
+    
+    private func rectanglePath(view: UIView) -> CGPath
+    {
+            //start point - left-down corner
+        var point = CGPoint(x: inputLineWidth/2, y: 0)
+        let path = UIBezierPath()
+        path.move(to: point)
+            //left-up corner
+        point = CGPoint(x: inputLineWidth/2, y: view.frame.height)
+        path.addLine(to: point)
+        path.move(to: CGPoint(x: inputLineWidth/2, y: view.frame.height - inputLineWidth/2))
+            //right-up corner
+        point = CGPoint(x: view.frame.width, y: view.frame.height - inputLineWidth/2)
+        path.addLine(to: point)
+        path.move(to: CGPoint(x: view.frame.width - inputLineWidth/2, y: view.frame.height - inputLineWidth/2))
+            //right-down corner
+        point = CGPoint(x: view.frame.width - inputLineWidth/2, y: 0)
+        path.addLine(to: point)
+        path.move(to: CGPoint(x: view.frame.width - inputLineWidth/2, y: inputLineWidth/2))
+            //start point - left-down corner
+        point = CGPoint(x: 0, y: inputLineWidth/2)
+        path.addLine(to: point)
+        
+        path.close()
+        
+        return path.cgPath
+    }
+    
+    private func polygonPath(view: UIView) -> CGPath
+    {
+        let path = UIBezierPath()
+        
+        let theta = Float(2.0 * .pi) / Float(inputPolygonSidesNumber)
+        let offset = inputCornerRadius * tanf(theta / 2.0)
+        let squareWidth = Float(min(view.frame.size.width, view.frame.size.height))
+        
+        var length = squareWidth - Float(inputLineWidth)
+        
+        if inputPolygonSidesNumber % 4 != 0
+        {
+            length = length * cosf(theta / 2.0) + offset / 2.0
+        }
+        
+        let sideLength = length * tanf(theta / 2.0)
+        
+        var point = CGPoint(x: CGFloat((squareWidth / 2.0) + (sideLength / 2.0) - offset), y: CGFloat(squareWidth - (squareWidth - length) / 2.0))
+        var angle = Float(Double.pi)
+        path.move(to: point)
+        
+        for _ in 0 ..< inputPolygonSidesNumber
+        {
+            
+            let x = Float(point.x) + (sideLength - offset * 2.0) * cosf(angle)
+            let y = Float(point.y) + (sideLength - offset * 2.0) * sinf(angle)
+            
+            point = CGPoint(x: CGFloat(x), y: CGFloat(y))
+            path.addLine(to: point)
+            
+            let centerX = Float(point.x) + inputCornerRadius * cosf(angle + Float(Double.pi/2))
+            let centerY = Float(point.y) + inputCornerRadius * sinf(angle + Float(Double.pi/2))
+            
+            let center = CGPoint(x: CGFloat(centerX), y: CGFloat(centerY))
+            
+            let startAngle = CGFloat(angle) - CGFloat(Double.pi/2)
+            let endAngle = CGFloat(angle) + CGFloat(theta) - CGFloat(Double.pi/2)
+            
+            path.addArc(withCenter: center, radius: CGFloat(inputCornerRadius), startAngle: startAngle, endAngle: endAngle, clockwise: true)
+            
+            point = path.currentPoint
+            angle += theta
+        }
+        
+        path.close()
+        
+        
+        // ROTATE
+        //get the center and transform the path so it's centered at the origin
+        let bounds = path.cgPath.boundingBox
+        let center = CGPoint(x:bounds.midX, y:bounds.midY)
+        
+        let toOrigin = CGAffineTransform(translationX: -center.x, y: -center.y)
+        path.apply(toOrigin)
+        
+        //rotate around the origin
+        let rotAngle = inputRotationAngle * CGFloat(Double.pi) / 180
+        let rotation = CGAffineTransform(rotationAngle: CGFloat(rotAngle))
+        path.apply(rotation)
+        
+        //translate back to the origin
+        let fromOrigin = CGAffineTransform(translationX: center.x, y: center.y)
+        path.apply(fromOrigin)
+        
+        return path.cgPath
+    }
+    
+}//end of class
diff --git a/AnimatedPaths/ViewController.swift b/AnimatedPaths/ViewController.swift
index 220261e..9f47f15 100644
--- a/AnimatedPaths/ViewController.swift
+++ b/AnimatedPaths/ViewController.swift
@@ -21,12 +21,25 @@ class ViewController: UIViewController, CAAnimationDelegate {
         super.viewDidLoad()
         // Do any additional setup after loading the view, typically from a nib.
         
-        animationLayer = CALayer()
-        animationLayer?.frame = CGRect(x: 20.0, y: 40.0, width: self.view.layer.bounds.width - 40.0, height: self.view.layer.bounds.height - 84.0)
-        self.view.layer.addSublayer(animationLayer!)
+        let targetView: UIView = self.view
         
-        setupDrawingLayer()
-        startAnimation()
+        RCAnimatedPath().drawAnimatedRectanglePath(in: targetView, duration: 10, lineWidth: 20, lineColor: UIColor.red)
+
+        RCAnimatedPath().drawAnimatedPolygonPath(in: targetView, numberOfSides: 8, rotationAngle: 30, polygonCornerRadius: 8, duration: 10, lineWidth: 5, lineColor: UIColor.gray)
+
+        RCAnimatedPath().drawAnimatedText(in: targetView, with: "K E G", duration: 10, lineWidth: 2, textColor: UIColor.blue, fontName: "anyFontName", fontSize: 50)
+
+//        RCAnimatedPath().drawAnimatedCustomPath(in: targetView, path: myPath, duration: 15, lineWidth: 5, lineColor: UIColor.blue)
+
+        RCAnimatedPath.shared.drawAnimatedRectanglePath(in: targetView, duration: 10, lineWidth: 20, lineColor: UIColor.red)
+
+        
+//        animationLayer = CALayer()
+//        animationLayer?.frame = CGRect(x: 20.0, y: 40.0, width: self.view.layer.bounds.width - 40.0, height: self.view.layer.bounds.height - 84.0)
+//        self.view.layer.addSublayer(animationLayer!)
+//
+//        setupDrawingLayer()
+//        startAnimation()
     }
     
     func clearLayer() {
@@ -96,8 +109,8 @@ class ViewController: UIViewController, CAAnimationDelegate {
     func setupTextLayer() {
         clearLayer() 
 
-        let font = CTFontCreateWithName("STHeitiSC-Light" as CFString, 120, nil)
-        let attrStr = NSAttributedString(string: "你好Swift", attributes: [kCTFontAttributeName as String: font])
+        let font = CTFontCreateWithName("PingFangSC-Light" as CFString, 120, nil)
+        let attrStr = NSAttributedString(string: "Hello Swift", attributes: [kCTFontAttributeName as String: font])
         let line = CTLineCreateWithAttributedString(attrStr)
         let runArray = CTLineGetGlyphRuns(line)
         

From e0982b12ffd887785ec6bc11945ced746a2c7bc2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Robin=EF=A3=BF?= <1933549736@qq.com>
Date: Thu, 23 Nov 2017 18:03:07 +0800
Subject: [PATCH 2/2] Refactoring code all code

---
 .../Base.lproj/LaunchScreen.storyboard        |  16 +-
 AnimatedPaths/Base.lproj/Main.storyboard      |  34 +--
 AnimatedPaths/RCAnimatedPath.swift            |  91 +++----
 AnimatedPaths/ViewController.swift            | 243 +++++-------------
 4 files changed, 135 insertions(+), 249 deletions(-)

diff --git a/AnimatedPaths/Base.lproj/LaunchScreen.storyboard b/AnimatedPaths/Base.lproj/LaunchScreen.storyboard
index 2e721e1..22ff8e4 100644
--- a/AnimatedPaths/Base.lproj/LaunchScreen.storyboard
+++ b/AnimatedPaths/Base.lproj/LaunchScreen.storyboard
@@ -1,7 +1,12 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="8150" systemVersion="15A204g" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES" initialViewController="01J-lp-oVM">
+<?xml version="1.0" encoding="UTF-8"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="13529" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES" colorMatched="YES" initialViewController="01J-lp-oVM">
+    <device id="retina4_7" orientation="portrait">
+        <adaptation id="fullscreen"/>
+    </device>
     <dependencies>
-        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="8122"/>
+        <deployment identifier="iOS"/>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="13527"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
     </dependencies>
     <scenes>
         <!--View Controller-->
@@ -13,10 +18,9 @@
                         <viewControllerLayoutGuide type="bottom" id="xb3-aO-Qok"/>
                     </layoutGuides>
                     <view key="view" contentMode="scaleToFill" id="Ze5-6b-2t3">
-                        <rect key="frame" x="0.0" y="0.0" width="600" height="600"/>
+                        <rect key="frame" x="0.0" y="0.0" width="375" height="667"/>
                         <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
-                        <animations/>
-                        <color key="backgroundColor" white="1" alpha="1" colorSpace="custom" customColorSpace="calibratedWhite"/>
+                        <color key="backgroundColor" red="1" green="1" blue="1" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
                     </view>
                 </viewController>
                 <placeholder placeholderIdentifier="IBFirstResponder" id="iYj-Kq-Ea1" userLabel="First Responder" sceneMemberID="firstResponder"/>
diff --git a/AnimatedPaths/Base.lproj/Main.storyboard b/AnimatedPaths/Base.lproj/Main.storyboard
index 3e7afb4..9e9193c 100644
--- a/AnimatedPaths/Base.lproj/Main.storyboard
+++ b/AnimatedPaths/Base.lproj/Main.storyboard
@@ -1,8 +1,12 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="9532" systemVersion="15D21" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" useTraitCollections="YES" initialViewController="BYZ-38-t0r">
+<?xml version="1.0" encoding="UTF-8"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="13529" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" useTraitCollections="YES" colorMatched="YES" initialViewController="BYZ-38-t0r">
+    <device id="retina4_7" orientation="portrait">
+        <adaptation id="fullscreen"/>
+    </device>
     <dependencies>
         <deployment identifier="iOS"/>
-        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="9530"/>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="13527"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
     </dependencies>
     <scenes>
         <!--View Controller-->
@@ -14,28 +18,25 @@
                         <viewControllerLayoutGuide type="bottom" id="wfy-db-euE"/>
                     </layoutGuides>
                     <view key="view" contentMode="scaleToFill" id="8bC-Xf-vdC">
-                        <rect key="frame" x="0.0" y="0.0" width="600" height="600"/>
+                        <rect key="frame" x="0.0" y="0.0" width="375" height="667"/>
                         <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
                         <subviews>
                             <toolbar opaque="NO" clearsContextBeforeDrawing="NO" contentMode="scaleToFill" translatesAutoresizingMaskIntoConstraints="NO" id="hic-yA-ytg">
-                                <rect key="frame" x="0.0" y="20" width="600" height="44"/>
+                                <rect key="frame" x="0.0" y="20" width="375" height="44"/>
                                 <constraints>
                                     <constraint firstAttribute="height" constant="44" id="DcU-ST-XUj"/>
                                 </constraints>
                                 <items>
-                                    <barButtonItem title="Replay" id="l0K-l3-84B">
-                                        <connections>
-                                            <action selector="replayAction:" destination="BYZ-38-t0r" id="KlL-8q-nne"/>
-                                        </connections>
-                                    </barButtonItem>
                                     <barButtonItem style="plain" systemItem="flexibleSpace" id="Ylx-2F-BQB"/>
                                     <barButtonItem style="plain" id="XDF-ou-h4x">
-                                        <segmentedControl key="customView" opaque="NO" contentMode="scaleToFill" contentHorizontalAlignment="left" contentVerticalAlignment="top" segmentControlStyle="bar" selectedSegmentIndex="0" id="S6v-6g-7Iz">
-                                            <rect key="frame" x="200" y="7" width="200" height="30"/>
+                                        <segmentedControl key="customView" opaque="NO" contentMode="scaleToFill" contentHorizontalAlignment="left" contentVerticalAlignment="top" segmentControlStyle="bar" id="S6v-6g-7Iz">
+                                            <rect key="frame" x="16" y="6.5" width="343" height="31"/>
                                             <autoresizingMask key="autoresizingMask" flexibleMaxX="YES" flexibleMaxY="YES"/>
                                             <segments>
-                                                <segment title="Drawing"/>
+                                                <segment title="Rectangle"/>
+                                                <segment title="Polygon"/>
                                                 <segment title="Text"/>
+                                                <segment title="Custom"/>
                                             </segments>
                                             <connections>
                                                 <action selector="drawingTypeSelector:" destination="BYZ-38-t0r" eventType="valueChanged" id="WpK-RX-UYa"/>
@@ -46,17 +47,20 @@
                                 </items>
                             </toolbar>
                         </subviews>
-                        <color key="backgroundColor" white="1" alpha="1" colorSpace="custom" customColorSpace="calibratedWhite"/>
+                        <color key="backgroundColor" red="1" green="1" blue="1" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
                         <constraints>
                             <constraint firstItem="hic-yA-ytg" firstAttribute="leading" secondItem="8bC-Xf-vdC" secondAttribute="leading" id="LUh-j3-2jp"/>
                             <constraint firstAttribute="trailing" secondItem="hic-yA-ytg" secondAttribute="trailing" id="OHa-ks-ccF"/>
                             <constraint firstItem="hic-yA-ytg" firstAttribute="top" secondItem="y3c-jy-aDJ" secondAttribute="bottom" id="P8C-6K-yHl"/>
                         </constraints>
                     </view>
+                    <connections>
+                        <outlet property="Segment" destination="S6v-6g-7Iz" id="rLD-eX-lmk"/>
+                    </connections>
                 </viewController>
                 <placeholder placeholderIdentifier="IBFirstResponder" id="dkx-z0-nzr" sceneMemberID="firstResponder"/>
             </objects>
-            <point key="canvasLocation" x="-2" y="268"/>
+            <point key="canvasLocation" x="-420" y="-36.431784107946029"/>
         </scene>
     </scenes>
 </document>
diff --git a/AnimatedPaths/RCAnimatedPath.swift b/AnimatedPaths/RCAnimatedPath.swift
index dbf7806..c320515 100644
--- a/AnimatedPaths/RCAnimatedPath.swift
+++ b/AnimatedPaths/RCAnimatedPath.swift
@@ -13,25 +13,15 @@ import CoreGraphics
 
 
 
-class RCAnimatedPath
-{
-    ////////////////////////
-    // CREATE A SINGLETON //
+class RCAnimatedPath{
     
-    class var shared: RCAnimatedPath
-    {
-        struct Singleton
-        {
+    class var shared: RCAnimatedPath{
+        struct Singleton{
             static let instance = RCAnimatedPath()
         }
         return Singleton.instance
     }
     
-    // CREATE A SINGLETON //
-    ////////////////////////
-    
-    
-    
     var animationLayer: CALayer?
     var pathLayer: CAShapeLayer?
     
@@ -50,15 +40,13 @@ class RCAnimatedPath
     
 
     
-    func drawAnimatedCustomPath(in view: UIView, path: CGPath, duration: CFTimeInterval, lineWidth: CGFloat, lineColor: UIColor)
-    {
+    func drawAnimatedCustomPath(in view: UIView, path: CGPath, duration: CFTimeInterval, lineWidth: CGFloat, lineColor: UIColor){
         self.inputDuration = duration
         self.inputLineWidth = lineWidth
         self.inputLineColor = lineColor
         self.inputPath = path
         
         animationLayer = CALayer()
-        
         animationLayer?.frame = CGRect(x: 0, y: 0, width: view.layer.bounds.width, height: view.layer.bounds.height)
         view.layer.addSublayer(animationLayer!)
         view.clipsToBounds = true
@@ -67,8 +55,7 @@ class RCAnimatedPath
         startAnimation()
     }
     
-    func drawAnimatedRectanglePath(in view: UIView, duration: CFTimeInterval, lineWidth: CGFloat, lineColor: UIColor)
-    {
+    func drawAnimatedRectanglePath(in view: UIView, duration: CFTimeInterval, lineWidth: CGFloat, lineColor: UIColor){
         self.inputDuration = duration
         self.inputLineWidth = lineWidth
         self.inputLineColor = lineColor
@@ -85,8 +72,7 @@ class RCAnimatedPath
         startAnimation()
     }
     
-    func drawAnimatedPolygonPath(in view: UIView, numberOfSides polygonSidesNumber: Int?, rotationAngle: CGFloat?, polygonCornerRadius: Float?, duration: CFTimeInterval, lineWidth: CGFloat, lineColor: UIColor)
-    {
+    func drawAnimatedPolygonPath(in view: UIView, numberOfSides polygonSidesNumber: Int?, rotationAngle: CGFloat?, polygonCornerRadius: Float?, duration: CFTimeInterval, lineWidth: CGFloat, lineColor: UIColor){
         self.inputDuration = duration
         self.inputLineWidth = lineWidth
         self.inputLineColor = lineColor
@@ -114,8 +100,7 @@ class RCAnimatedPath
         startAnimation()
     }
     
-    func drawAnimatedText(in view: UIView, with text: String, duration: CFTimeInterval, lineWidth: CGFloat, textColor: UIColor, fontName: String?, fontSize: CGFloat?)
-    {
+    func drawAnimatedText(in view: UIView, with text: String, duration: CFTimeInterval, lineWidth: CGFloat, textColor: UIColor, fontName: String?, fontSize: CGFloat?){
         self.inputText = text
         self.inputDuration = duration
         self.inputLineWidth = lineWidth
@@ -138,14 +123,12 @@ class RCAnimatedPath
     }
     
     
-    func setupDrawingLayer()
-    {
+    func setupDrawingLayer(){
         clearLayer()
         
         if let _ = animationLayer
         {
-            let pathRect: CGRect = animationLayer!.bounds
-            
+            let pathRect: CGRect = animationLayer!.bounds.insetBy(dx: 100.0, dy: 100.0)
             
             let pathShapeLayer = CAShapeLayer()
             pathShapeLayer.frame = animationLayer!.bounds
@@ -163,8 +146,7 @@ class RCAnimatedPath
         }
     }
     
-    func setupTextLayer(in view: UIView)
-    {
+    func setupTextLayer(in view: UIView){
         clearLayer()
         
         if let _ = animationLayer
@@ -219,20 +201,34 @@ class RCAnimatedPath
         
     }
     
-    private func startAnimation()
-    {
+    private func startAnimation(){
         pathLayer?.removeAllAnimations()
         
-        let pathAnimation = CABasicAnimation(keyPath: "strokeEnd")
-        pathAnimation.duration = inputDuration
-        pathAnimation.fromValue = 0.0
-        pathAnimation.toValue = 1.0
-        pathLayer?.add(pathAnimation, forKey: "strokeEnd")
+//        let pathAnimation = CABasicAnimation(keyPath: "strokeEnd")
+//        pathAnimation.duration = inputDuration
+//        pathAnimation.fromValue = 0.0
+//        pathAnimation.toValue = 1.0
+//        pathLayer?.add(pathAnimation, forKey: "strokeEnd")
+        
+        
+        
+        let animation = CABasicAnimation(keyPath: "strokeEnd")
+        
+        animation.fromValue = 0.0
+        animation.byValue = 1.0
+        animation.toValue = 1.0
+        animation.duration = inputDuration
+        
+        animation.fillMode = kCAFillModeForwards
+        animation.isRemovedOnCompletion = false
+        
+        pathLayer?.add(animation, forKey: "drawLineAnimation")
+
+        
     }
     
         //freezes the animation until clearLayer() is called
-    func stopAnimatingWithPause()
-    {
+    func stopAnimatingWithPause(){
         if let pausedTime = pathLayer?.convertTime(CACurrentMediaTime(), from: nil)
         {
             pathLayer?.speed = 0.0
@@ -241,13 +237,11 @@ class RCAnimatedPath
     }
     
         //clears the animation layers
-    func stopAnimatingWithClear()
-    {
+    func stopAnimatingWithClear(){
         clearLayer()
     }
     
-    func clearLayer()
-    {
+    func clearLayer(){
         if let _ = pathLayer
         {
             pathLayer?.removeFromSuperlayer()
@@ -255,11 +249,7 @@ class RCAnimatedPath
         }
     }
     
-    
-    /// CREATE PATH ///
-    
-    private func rectanglePath(view: UIView) -> CGPath
-    {
+    private func rectanglePath(view: UIView) -> CGPath{
             //start point - left-down corner
         var point = CGPoint(x: inputLineWidth/2, y: 0)
         let path = UIBezierPath()
@@ -285,8 +275,7 @@ class RCAnimatedPath
         return path.cgPath
     }
     
-    private func polygonPath(view: UIView) -> CGPath
-    {
+    private func polygonPath(view: UIView) -> CGPath{
         let path = UIBezierPath()
         
         let theta = Float(2.0 * .pi) / Float(inputPolygonSidesNumber)
@@ -295,8 +284,7 @@ class RCAnimatedPath
         
         var length = squareWidth - Float(inputLineWidth)
         
-        if inputPolygonSidesNumber % 4 != 0
-        {
+        if inputPolygonSidesNumber % 4 != 0{
             length = length * cosf(theta / 2.0) + offset / 2.0
         }
         
@@ -306,8 +294,7 @@ class RCAnimatedPath
         var angle = Float(Double.pi)
         path.move(to: point)
         
-        for _ in 0 ..< inputPolygonSidesNumber
-        {
+        for _ in 0 ..< inputPolygonSidesNumber{
             
             let x = Float(point.x) + (sideLength - offset * 2.0) * cosf(angle)
             let y = Float(point.y) + (sideLength - offset * 2.0) * sinf(angle)
diff --git a/AnimatedPaths/ViewController.swift b/AnimatedPaths/ViewController.swift
index 9f47f15..6e4b202 100644
--- a/AnimatedPaths/ViewController.swift
+++ b/AnimatedPaths/ViewController.swift
@@ -7,202 +7,93 @@
 //
 
 import UIKit
-import QuartzCore
-import CoreText
-import CoreGraphics
 
-class ViewController: UIViewController, CAAnimationDelegate {
-    
-    var animationLayer: CALayer?
-    var pathLayer: CAShapeLayer?
-    var penLayer: CALayer?
+class ViewController: UIViewController { 
 
+    @IBOutlet weak var Segment: UISegmentedControl!
+    
     override func viewDidLoad() {
         super.viewDidLoad()
         // Do any additional setup after loading the view, typically from a nib.
-        
-        let targetView: UIView = self.view
-        
-        RCAnimatedPath().drawAnimatedRectanglePath(in: targetView, duration: 10, lineWidth: 20, lineColor: UIColor.red)
-
-        RCAnimatedPath().drawAnimatedPolygonPath(in: targetView, numberOfSides: 8, rotationAngle: 30, polygonCornerRadius: 8, duration: 10, lineWidth: 5, lineColor: UIColor.gray)
-
-        RCAnimatedPath().drawAnimatedText(in: targetView, with: "K E G", duration: 10, lineWidth: 2, textColor: UIColor.blue, fontName: "anyFontName", fontSize: 50)
-
-//        RCAnimatedPath().drawAnimatedCustomPath(in: targetView, path: myPath, duration: 15, lineWidth: 5, lineColor: UIColor.blue)
-
-        RCAnimatedPath.shared.drawAnimatedRectanglePath(in: targetView, duration: 10, lineWidth: 20, lineColor: UIColor.red)
-
-        
-//        animationLayer = CALayer()
-//        animationLayer?.frame = CGRect(x: 20.0, y: 40.0, width: self.view.layer.bounds.width - 40.0, height: self.view.layer.bounds.height - 84.0)
-//        self.view.layer.addSublayer(animationLayer!)
-//
-//        setupDrawingLayer()
-//        startAnimation()
-    }
-    
-    func clearLayer() {
-        if let _ = pathLayer{
-            penLayer?.removeFromSuperlayer()
-            pathLayer?.removeFromSuperlayer()
-            penLayer = nil
-            pathLayer = nil
-        }
     }
-    
-    func setupPenLayer() {
-        let penImage = UIImage(named: "noun_project_347_2")!
-        let pensLayer = CALayer()
-        pensLayer.contents = penImage.cgImage
-        pensLayer.anchorPoint = CGPoint.zero
-        pensLayer.frame = CGRect(x: 0.0, y: 0.0, width: penImage.size.width, height: penImage.size.height)
-        pathLayer?.addSublayer(pensLayer)
-        
-        penLayer = pensLayer
-
-    }
-    
-    func setupDrawingLayer() {
-    
-        clearLayer()
-        
-        if let _ = animationLayer{
-            let pathRect: CGRect = animationLayer!.bounds.insetBy(dx: 100.0, dy: 100.0)
-            let bottomLeft = CGPoint(x: pathRect.minX, y: pathRect.minY)
-            let topLeft = CGPoint(x: pathRect.minX, y: pathRect.minY + pathRect.height * 2.0 / 3.0)
-            let bottomRight = CGPoint(x: pathRect.maxX, y: pathRect.minY)
-            let topRight = CGPoint(x: pathRect.maxX, y: pathRect.minY + pathRect.height * 2.0 / 3.0)
-            let roofTip = CGPoint(x: pathRect.midX, y: pathRect.maxY)
-            
-            let path = UIBezierPath()
-            path.move(to: bottomLeft)
-            path.addLine(to: topLeft)
-            path.addLine(to: roofTip)
-            path.addLine(to: topRight)
-            path.addLine(to: topLeft)
-            path.addLine(to: bottomRight)
-            path.addLine(to: topRight)
-            path.addLine(to: bottomLeft)
-            path.addLine(to: bottomRight)
-            
-            let pathShapeLayer = CAShapeLayer()
-            pathShapeLayer.frame = animationLayer!.bounds
-            pathShapeLayer.bounds = pathRect
-            pathShapeLayer.isGeometryFlipped = true
-            pathShapeLayer.path = path.cgPath
-            pathShapeLayer.strokeColor = UIColor.black.cgColor
-            pathShapeLayer.fillColor = nil
-            pathShapeLayer.lineWidth = 10.0
-            pathShapeLayer.lineJoin = kCALineJoinBevel
-            
-            animationLayer!.addSublayer(pathShapeLayer)
-            
-            pathLayer = pathShapeLayer
-        }
-        
-        setupPenLayer()
-    }
-    
-    
-    
-    func setupTextLayer() {
-        clearLayer() 
-
-        let font = CTFontCreateWithName("PingFangSC-Light" as CFString, 120, nil)
-        let attrStr = NSAttributedString(string: "Hello Swift", attributes: [kCTFontAttributeName as String: font])
-        let line = CTLineCreateWithAttributedString(attrStr)
-        let runArray = CTLineGetGlyphRuns(line)
-        
-        let letters = CGMutablePath()
-        
-        for runIndex in 0..<CFArrayGetCount(runArray) {
-            let runUnsafe: UnsafeRawPointer = CFArrayGetValueAtIndex(runArray, runIndex)
-            let run = unsafeBitCast(runUnsafe, to: CTRun.self)
-
-            
-            for runGlyphIndex in 0..<CTRunGetGlyphCount(run) {
-                let thisGlyphRange = CFRangeMake(runGlyphIndex, 1)
-                var glyph: CGGlyph = CGGlyph()
-                var position: CGPoint = CGPoint()
-                CTRunGetGlyphs(run, thisGlyphRange, &glyph)
-                CTRunGetPositions(run, thisGlyphRange, &position)
-                
-                let letter = CTFontCreatePathForGlyph(font, glyph, nil)
-                let t = CGAffineTransform(translationX: position.x, y: position.y);
-                
-                letters.addPath(letter!, transform:t)
-            }
-        }
-        
-        let path = UIBezierPath()
-        path.move(to: CGPoint.zero)
-        path.append(UIBezierPath(cgPath: letters))
-        
-        
-        let layer = CAShapeLayer()
-        layer.frame = CGRect(x: 10, y: 120, width: self.view.layer.bounds.width - 20, height: 100)
-        layer.isGeometryFlipped = true
-        layer.path = path.cgPath
-        layer.strokeColor = UIColor.red.cgColor
-        layer.fillColor = nil
-        layer.lineWidth = 3.0
-        layer.lineJoin = kCALineJoinBevel
-        
-        animationLayer?.addSublayer(layer)
-        
-        pathLayer = layer
-        
-        setupPenLayer()
-    }
-    
-    func startAnimation() {
-        penLayer?.removeAllAnimations()
-        pathLayer?.removeAllAnimations()
-        
-        penLayer?.isHidden = false
-        
-        let pathAnimation = CABasicAnimation(keyPath: "strokeEnd")
-        pathAnimation.duration = 10.0
-        pathAnimation.fromValue = 0.0
-        pathAnimation.toValue = 1.0
-        pathLayer?.add(pathAnimation, forKey: "strokeEnd")
-        
-        let penAnimation = CAKeyframeAnimation(keyPath: "position")
-        penAnimation.duration = 10.0
-        penAnimation.path = pathLayer?.path
-        penAnimation.calculationMode = kCAAnimationPaced
-        penAnimation.delegate = self
-        penLayer?.add(penAnimation, forKey: "position")
-    }
-    
-    
-    public func animationDidStop(_ anim: CAAnimation, finished flag: Bool){
-         penLayer?.isHidden = true
-    }
-    
 
     override func didReceiveMemoryWarning() {
         super.didReceiveMemoryWarning()
         // Dispose of any resources that can be recreated.
     }
- 
-    
-    @IBAction func replayAction(_ sender: AnyObject) {
-        startAnimation()
-    }
+  
 
     @IBAction func drawingTypeSelector(_ sender: AnyObject) {
+        let targetView: UIView = self.view
+
+        RCAnimatedPath.shared.stopAnimatingWithClear()
         
         switch sender.selectedSegmentIndex {
         case 0:
-            setupDrawingLayer()
+            RCAnimatedPath.shared.drawAnimatedRectanglePath(in: targetView, duration: 3, lineWidth: 5, lineColor: UIColor.red)
         case 1:
-            setupTextLayer()
+            RCAnimatedPath.shared.drawAnimatedPolygonPath(in: targetView, numberOfSides: 8, rotationAngle: 10, polygonCornerRadius: 4, duration: 3, lineWidth: 5, lineColor: UIColor.gray)
+        case 2:
+            RCAnimatedPath.shared.drawAnimatedText(in: targetView, with: "Hello Swift!", duration: 3, lineWidth: 2, textColor: UIColor.blue, fontName: "PingFangSC-Bold", fontSize: 50)
+        case 3:
+            RCAnimatedPath.shared.drawAnimatedCustomPath(in: targetView, path: ringPath.cgPath, duration: 3, lineWidth: 2, lineColor: UIColor.black)
         default:
             break
         }
-        startAnimation()
+    }
+    
+    var ringPath: UIBezierPath{
+        let bezierPath = UIBezierPath()
+        let arcCenter = CGPoint(x: 185, y: 110)
+        bezierPath.addArc(withCenter: arcCenter, radius: 66.0, startAngle: 0, endAngle: CGFloat(2 * Double.pi), clockwise: true)
+        return bezierPath
+    }
+    
+    // FIXME:  I don't know why the result is up-down error?????
+    /// Apple logo bezier path generated from Paintcode.
+    var applePath: UIBezierPath{
+        
+        let bezierPath = UIBezierPath()
+        bezierPath.move(to: CGPoint(x:185.37, y:151.25))
+        bezierPath.addCurve(to: CGPoint(x:176.66, y:166.91), controlPoint1: CGPoint(x:182.92, y:156.91), controlPoint2: CGPoint(x:180.02, y:162.12))
+        bezierPath.addCurve(to: CGPoint(x:165.44, y:180.47), controlPoint1: CGPoint(x:172.08, y:173.44), controlPoint2: CGPoint(x:168.33, y:177.96))
+        bezierPath.addCurve(to: CGPoint(x:151.02, y:186.82), controlPoint1: CGPoint(x:160.96, y:184.59), controlPoint2: CGPoint(x:156.16, y:186.7))
+        bezierPath.addCurve(to: CGPoint(x:137.7, y:183.64), controlPoint1: CGPoint(x:147.33, y:186.82), controlPoint2: CGPoint(x:142.88, y:185.77))
+        bezierPath.addCurve(to: CGPoint(x:123.36, y:180.47), controlPoint1: CGPoint(x:132.5, y:181.52), controlPoint2: CGPoint(x:127.73, y:180.47))
+        bezierPath.addCurve(to: CGPoint(x:108.61, y:183.64), controlPoint1: CGPoint(x:118.78, y:180.47), controlPoint2: CGPoint(x:113.87, y:181.52))
+        bezierPath.addCurve(to: CGPoint(x:95.87, y:186.99), controlPoint1: CGPoint(x:103.35, y:185.77), controlPoint2: CGPoint(x:99.11, y:186.88))
+        bezierPath.addCurve(to: CGPoint(x:81.13, y:180.47), controlPoint1: CGPoint(x:90.94, y:187.2), controlPoint2: CGPoint(x:86.03, y:185.03))
+        bezierPath.addCurve(to: CGPoint(x:69.39, y:166.43), controlPoint1: CGPoint(x:78, y:177.74), controlPoint2: CGPoint(x:74.08, y:173.06))
+        bezierPath.addCurve(to: CGPoint(x:56.98, y:141.78), controlPoint1: CGPoint(x:64.36, y:159.35), controlPoint2: CGPoint(x:60.22, y:151.14))
+        bezierPath.addCurve(to: CGPoint(x:51.77, y:112.4), controlPoint1: CGPoint(x:53.51, y:131.67), controlPoint2: CGPoint(x:51.77, y:121.88))
+        bezierPath.addCurve(to: CGPoint(x:58.81, y:84.33), controlPoint1: CGPoint(x:51.77, y:101.54), controlPoint2: CGPoint(x:54.12, y:92.18))
+        bezierPath.addCurve(to: CGPoint(x:73.57, y:69.41), controlPoint1: CGPoint(x:62.51, y:78.03), controlPoint2: CGPoint(x:67.42, y:73.06))
+        bezierPath.addCurve(to: CGPoint(x:93.52, y:63.78), controlPoint1: CGPoint(x:79.72, y:65.76), controlPoint2: CGPoint(x:86.36, y:63.9))
+        bezierPath.addCurve(to: CGPoint(x:108.95, y:67.37), controlPoint1: CGPoint(x:97.43, y:63.78), controlPoint2: CGPoint(x:102.57, y:64.99))
+        bezierPath.addCurve(to: CGPoint(x:121.18, y:70.97), controlPoint1: CGPoint(x:115.31, y:69.76), controlPoint2: CGPoint(x:119.39, y:70.97))
+        bezierPath.addCurve(to: CGPoint(x:134.75, y:66.73), controlPoint1: CGPoint(x:122.52, y:70.97), controlPoint2: CGPoint(x:127.06, y:69.55))
+        bezierPath.addCurve(to: CGPoint(x:153.2, y:63.46), controlPoint1: CGPoint(x:142.03, y:64.11), controlPoint2: CGPoint(x:148.17, y:63.03))
+        bezierPath.addCurve(to: CGPoint(x:183.88, y:79.61), controlPoint1: CGPoint(x:166.83, y:64.56), controlPoint2: CGPoint(x:177.07, y:69.93))
+        bezierPath.addCurve(to: CGPoint(x:165.78, y:110.61), controlPoint1: CGPoint(x:171.69, y:86.99), controlPoint2: CGPoint(x:165.66, y:97.34))
+        bezierPath.addCurve(to: CGPoint(x:177.01, y:136.38), controlPoint1: CGPoint(x:165.89, y:120.95), controlPoint2: CGPoint(x:169.64, y:129.55))
+        bezierPath.addCurve(to: CGPoint(x:188.23, y:143.74), controlPoint1: CGPoint(x:180.35, y:139.55), controlPoint2: CGPoint(x:184.08, y:142))
+        bezierPath.addCurve(to: CGPoint(x:185.37, y:151.25), controlPoint1: CGPoint(x:187.33, y:146.35), controlPoint2: CGPoint(x:186.38, y:148.85))
+        bezierPath.close()
+        bezierPath.move(to: CGPoint(x:154.11, y:28.24))
+        bezierPath.addCurve(to: CGPoint(x:145.25, y:50.91), controlPoint1: CGPoint(x:154.11, y:36.34), controlPoint2: CGPoint(x:151.15, y:43.91))
+        bezierPath.addCurve(to: CGPoint(x:120.18, y:63.28), controlPoint1: CGPoint(x:138.13, y:59.23), controlPoint2: CGPoint(x:129.52, y:64.04))
+        bezierPath.addCurve(to: CGPoint(x:119.99, y:60.21), controlPoint1: CGPoint(x:120.06, y:62.31), controlPoint2: CGPoint(x:119.99, y:61.29))
+        bezierPath.addCurve(to: CGPoint(x:129.39, y:37.31), controlPoint1: CGPoint(x:119.99, y:52.44), controlPoint2: CGPoint(x:123.38, y:44.11))
+        bezierPath.addCurve(to: CGPoint(x:140.84, y:28.71), controlPoint1: CGPoint(x:132.39, y:33.86), controlPoint2: CGPoint(x:136.21, y:30.99))
+        bezierPath.addCurve(to: CGPoint(x:153.94, y:25), controlPoint1: CGPoint(x:145.46, y:26.46), controlPoint2: CGPoint(x:149.83, y:25.21))
+        bezierPath.addCurve(to: CGPoint(x:154.11, y:28.24), controlPoint1: CGPoint(x:154.06, y:26.08), controlPoint2: CGPoint(x:154.11, y:27.17))
+        bezierPath.close()
+        bezierPath.miterLimit = 4;
+        
+        let rotation = CGAffineTransform(rotationAngle: 90)
+        bezierPath.apply(rotation)
+        
+        return bezierPath
     }
 }