Update for Swift 3.0 syntax

Author: traviskirton

C4/Core/EventSource.swift

@@ -31,21 +31,22 @@ public protocol EventSource {
     ///
     /// - parameter notificationName: The notification name to listen for
     /// - parameter executionBlock:   A block of code to run when the receiver "hears" the specified notification name
-    func on(event notificationName: String, run: (Void) -> Void) -> AnyObject
+    func on(event notificationName: String, run: @escaping (Void) -> Void) -> AnyObject
 
     ///  Register an action to run when an event is triggered by the specified sender. Returns an observer handle you can use to cancel the action.
     ///
     /// - parameter notificationName: The notification name to listen for
     /// - parameter sender:           The object from which to listen for the notification
     /// - parameter executionBlock:   A block of code to run when the receiver "hears" the specified notification name
-    func on(event notificationName: String, from sender: AnyObject?, run executionBlock: (Void) -> Void) -> AnyObject
+    func on(event notificationName: String, from sender: AnyObject?, run executionBlock: @escaping () -> Void) -> AnyObject
 
     /// Cancel a previously registered action from an observer handle.
     func cancel(_ observer: AnyObject)
 }
 
 /// This extension allows any NSObject to post and listen for events in the same way as C4 objects.
 extension NSObject : EventSource {
+
     /// Posts a new notification originating from the receiver.
     ///
     /// ````
@@ -56,7 +57,7 @@ extension NSObject : EventSource {
     ///
     /// - parameter event: The notification name for the event
     public func post(_ event: String) {
-        NotificationCenter.default().post(name: Notification.Name(rawValue: event), object: self)
+        NotificationCenter.default.post(name: Notification.Name(rawValue: event), object: self)
     }
 
     /// An action to run on receipt of a given event.
@@ -70,8 +71,7 @@ extension NSObject : EventSource {
     /// - parameter event: The notification name to listen for
     /// - parameter run:   A block of code to run when the receiver "hears" the specified event name
     /// - returns: A token to use for cancelling the action.
-    @discardableResult
-    public func on(event notificationName: String, run executionBlock: (Void) -> Void) -> AnyObject {
+    public func on(event notificationName: String, run executionBlock: @escaping (Void) -> Void) -> AnyObject {
         return on(event: notificationName, from: nil, run: executionBlock)
     }
 
@@ -87,9 +87,9 @@ extension NSObject : EventSource {
     /// - parameter sender:           The object from which to listen for the notification
     /// - parameter executionBlock:   A block of code to run when the receiver "hears" the specified notification name
     /// - returns: A token to use for cancelling the action.
-    public func on(event notificationName: String, from sender: AnyObject?, run executionBlock: (Void) -> Void) -> AnyObject {
-        let nc = NotificationCenter.default()
-        return nc.addObserver(forName: NSNotification.Name(rawValue: notificationName), object: sender, queue: OperationQueue.current(), using: { notification in
+    public func on(event notificationName: String, from sender: AnyObject?, run executionBlock: @escaping (Void) -> Void) -> AnyObject {
+        let nc = NotificationCenter.default
+        return nc.addObserver(forName: NSNotification.Name(rawValue: notificationName), object: sender, queue: OperationQueue.current, using: { notification in
             executionBlock()
         })
     }
@@ -102,7 +102,7 @@ extension NSObject : EventSource {
     ///
     /// - parameter token: A token returned from a call to `on(event:run:)` method
     public func cancel(_ token: AnyObject) {
-        let nc = NotificationCenter.default()
+        let nc = NotificationCenter.default
         nc.removeObserver(token)
     }
 }

C4/Core/Foundation.swift

@@ -44,9 +44,9 @@ public func C4Log<T>(_ value: T) {
 /// - returns: The smallest CGRect that contains all of the points in the specified array
 public func CGRectMakeFromPoints(_ points: [CGPoint]) -> CGRect {
     let path = CGMutablePath()
-    path.moveTo(nil, x: points[0].x, y: points[0].y)
+    path.move(to: points[0])
     for i in 1..<points.count {
-        path.addLineTo(nil, x: points[i].x, y: points[i].y)
+        path.addLine(to: points[i])
     }
     return path.boundingBox
 }
@@ -61,6 +61,6 @@ public func CGRectMakeFromPoints(_ points: [CGPoint]) -> CGRect {
 ///
 /// - parameter delay:  The amount of time in seconds to wait before executing the block of code.
 /// - parameter action: A block of code to perform after the delay.
-public func wait(_ seconds: Double, action: ()->()) {
-    DispatchQueue.main.after(walltime: DispatchWallTime.now() + seconds, execute: action)
+public func wait(_ seconds: Double, action: @escaping ()->()) {
+    DispatchQueue.main.asyncAfter(wallDeadline: DispatchWallTime.now() + seconds, execute: action)
 }

C4/Core/Path.swift

@@ -25,12 +25,12 @@ public enum FillRule {
     /// Specifies the non-zero winding rule. Count each left-to-right path as +1 and each right-to-left path as -1. If the
     /// sum of all crossings is 0, the point is outside the path. If the sum is nonzero, the point is inside the path and
     /// the region containing it is filled.
-    case nonZero
+    case NonZero
 
     /// Specifies the even-odd winding rule. Count the total number of path crossings. If the number of crossings is even,
     /// the point is outside the path. If the number of crossings is odd, the point is inside the path and the region
     /// containing it should be filled.
-    case evenOdd
+    case EvenOdd
 }
 
 
@@ -42,7 +42,7 @@ public class Path: Equatable {
     ///  Initializes an empty Path.
     public init() {
         internalPath = CGMutablePath()
-        internalPath.moveTo(nil, x: 0, y: 0)
+        internalPath.move(to: CGPoint())
     }
 
     ///  Initializes a new Path from an existing CGPathRef.
@@ -73,8 +73,9 @@ public class Path: Equatable {
     /// - parameter point: The point to test.
     /// - parameter fillRule: The fill rule to use when testing for containment.
     /// - returns: `true` if `point` is inside the path, `false` otherwise.
-    public func containsPoint(_ point: Point, fillRule: FillRule = .nonZero) -> Bool {
-        return internalPath.containsPoint(nil, point: CGPoint(point), eoFill: fillRule == .evenOdd)
+    public func containsPoint(_ point: Point, fillRule: FillRule = .NonZero) -> Bool {
+        let rule = fillRule == .EvenOdd ? CGPathFillRule.evenOdd : CGPathFillRule.winding
+        return internalPath.contains(CGPoint(point), using: rule, transform: CGAffineTransform.identity)
     }
 
     /// Create a copy of the path
@@ -96,7 +97,7 @@ public class Path: Equatable {
 /// - parameter right: the second path to compare
 /// - returns: a boolean, `true` if the patrhs are equal, otherwise `false`
 public func == (left: Path, right: Path) -> Bool {
-    return left.internalPath.equalTo(right.internalPath)
+    return left.internalPath == right.internalPath
 }
 
 extension Path {
@@ -114,21 +115,21 @@ extension Path {
     /// Move the current point of the current subpath.
     /// - parameter point: A Point
     public func moveToPoint(_ point: Point) {
-        internalPath.moveTo(nil, x: CGFloat(point.x), y: CGFloat(point.y))
+        internalPath.move(to: CGPoint(point))
     }
 
     /// Append a straight-line segment fron the current point to `point` and move the current point to `point`.
     /// - parameter point: A Point
     public func addLineToPoint(_ point: Point) {
-        internalPath.addLineTo(nil, x: CGFloat(point.x), y: CGFloat(point.y))
+        internalPath.addLine(to: CGPoint(point))
     }
 
     /// Append a quadratic curve from the current point to `point` with control point `control` and move the current
     /// point to `point`.
     /// - parameter control: A Point used to shape the curve
     /// - parameter point: A Point
     public func addQuadCurveToPoint(_ point: Point, control: Point) {
-        internalPath.addQuadCurve(nil, cpx: CGFloat(control.x), cpy: CGFloat(control.y), endingAtX: CGFloat(point.x), y: CGFloat(point.y))
+        internalPath.addQuadCurve(to: CGPoint(point), control: CGPoint(control))
     }
 
     /// Append a cubic Bézier curve from the current point to `point` with control points `control1` and `control2`
@@ -137,7 +138,7 @@ extension Path {
     /// - parameter control2: A Point used to shape the curve
     /// - parameter point: A Point
     public func addCurveToPoint(_ point: Point, control1: Point, control2: Point) {
-        internalPath.addCurve(nil, cp1x: CGFloat(control1.x), cp1y: CGFloat(control1.y), cp2x: CGFloat(control2.x), cp2y: CGFloat(control2.y), endingAtX: CGFloat(point.x), y: CGFloat(point.y))
+        internalPath.addCurve(to: CGPoint(point), control1: CGPoint(control1), control2: CGPoint(control2))
     }
 
     /// Append a line from the current point to the starting point of the current subpath and end the subpath.
@@ -148,7 +149,7 @@ extension Path {
     /// Add a rectangle to the path.
     /// - parameter rect: a Rect to add to the path
     public func addRect(_ rect: Rect) {
-        internalPath.addRect(nil, rect: CGRect(rect))
+        internalPath.addRect(CGRect(rect))
     }
 
     /// Add a rounded rectangle to the path. The rounded rectangle coincides with the edges of `rect`. Each corner consists
@@ -159,7 +160,7 @@ extension Path {
     /// - parameter cornerWidth: the width of the shape's rounded corners
     /// - parameter cornerHeight: the width of the shape's rounded corners
     public func addRoundedRect(_ rect: Rect, cornerWidth: Double, cornerHeight: Double) {
-        internalPath.addRoundedRect(nil, rect: CGRect(rect), cornerWidth: CGFloat(cornerWidth), cornerHeight: CGFloat(cornerHeight))
+        internalPath.addRoundedRect(in: CGRect(rect), cornerWidth: CGFloat(cornerWidth), cornerHeight: CGFloat(cornerHeight))
     }
 
     /// Add an ellipse (an oval) inside `rect`. The ellipse is approximated by a sequence of Bézier curves. The center of
@@ -169,7 +170,7 @@ extension Path {
     /// a "move to" and ends with a "close subpath" --- oriented in the clockwise direction.
     /// - parameter rect: a Rect into which an ellipse will be created and added to the path
     public func addEllipse(_ rect: Rect) {
-        internalPath.addEllipseIn(nil, rect: CGRect(rect))
+        internalPath.addEllipse(in: CGRect(rect))
     }
 
     /// Add an arc of a circle, possibly preceded by a straight line segment. The arc is approximated by a sequence of
@@ -182,7 +183,7 @@ extension Path {
     /// - parameter delta:      The angle between `startAngle` and the second endpoint of the arc, in radians. If `delta' is positive,
     ///                         then the arc is drawn counter-clockwise; if negative, clockwise.
     public func addRelativeArc(_ center: Point, radius: Double, startAngle: Double, delta: Double) {
-        internalPath.addRelativeArc(matrix: nil, x: CGFloat(center.x), y: CGFloat(center.y), radius: CGFloat(radius), startAngle: CGFloat(startAngle), delta: CGFloat(delta))
+        internalPath.addRelativeArc(center: CGPoint(center), radius: CGFloat(radius), startAngle: CGFloat(startAngle), delta: CGFloat(delta))
     }
 
     /// Add an arc of a circle, possibly preceded by a straight line segment. The arc is approximated by a sequence of
@@ -203,7 +204,7 @@ extension Path {
     /// - parameter endAngle:   The angle to the second endpoint of the arc.
     /// - parameter clockwise:  If true the arc is drawn clockwise.
     public func addArc(_ center: Point, radius: Double, startAngle: Double, endAngle: Double, clockwise: Bool) {
-        internalPath.addArc(nil, x: CGFloat(center.x), y: CGFloat(center.y), radius: CGFloat(radius), startAngle: CGFloat(startAngle), endAngle: CGFloat(endAngle), clockwise: clockwise)
+        internalPath.addArc(center: CGPoint(center), radius: CGFloat(radius), startAngle: CGFloat(startAngle), endAngle: CGFloat(endAngle), clockwise: clockwise)
     }
 
     /// Add an arc of a circle, possibly preceded by a straight line segment. The arc is approximated by a sequence of
@@ -213,14 +214,14 @@ extension Path {
     /// - parameter point2: the end point of the arc
     /// - parameter radius: the radius of the arc
     public func addArcToPoint(_ point1: Point, point2: Point, radius: Double) {
-        internalPath.addArc(nil, x1: CGFloat(point1.x), y1: CGFloat(point1.y), x2: CGFloat(point2.x), y2: CGFloat(point2.y), radius: CGFloat(radius))
+        internalPath.addArc(tangent1End: CGPoint(point1), tangent2End: CGPoint(point2), radius: CGFloat(radius))
     }
 
     /// Append a path.
     ///
     /// - parameter path:      A new Path that is added to the end of the receiver.
     public func addPath(_ path: Path) {
-        internalPath.addPath(nil, path: path.internalPath)
+        internalPath.addPath(path.internalPath)
     }
 
     /// Transform a path.

C4/Core/Transform.swift

@@ -25,7 +25,7 @@ import QuartzCore
 ///
 ///  Transform can translate, rotate, scale.
 public struct Transform: Equatable {
-    private var matrix = [Double](repeating: 0, count: 16)
+    var matrix = [Double](repeating: 0, count: 16)
 
     public subscript(row: Int, col: Int) -> Double {
         get {

C4/Core/Vector.swift

@@ -142,7 +142,7 @@ public struct Vector: Equatable, CustomStringConvertible {
     /// - parameter vec: The vector used to calcuate the angle to the receiver
     /// - returns: The angle, measured in radians, between the receiver and `vec`
     public func angleTo(_ vec: Vector) -> Double {
-        return acos(self ⋅ vec / (self.magnitude * vec.magnitude))
+        return acos(self ⋅ (vec / (self.magnitude * vec.magnitude)))
     }
 
     /// The angle between two vectors, based on a provided point
@@ -162,7 +162,7 @@ public struct Vector: Equatable, CustomStringConvertible {
         vecA -= basedOn
         vecB -= basedOn
 
-        return acos(vecA ⋅ vecB / (vecA.magnitude * vecB.magnitude))
+        return acos(vecA ⋅ (vecB / (vecA.magnitude * vecB.magnitude)))
     }
 
     /// Return the dot product. **You should use the ⋅ operator instead.**
@@ -320,7 +320,7 @@ public func - (lhs: Vector, rhs: Vector) -> Vector {
     return Vector(x: lhs.x - rhs.x, y: lhs.y - rhs.y, z: lhs.z - rhs.z)
 }
 
-infix operator ⋅ { associativity left precedence 150 }
+infix operator ⋅
 
 /// Returns a new vector that is the dot product of the both input vectors. **Use this instead of v.dot(v)**
 ///

C4/UI/Animation.swift

@@ -31,13 +31,13 @@ public class Animation {
     ///  ````
     public enum Curve {
         /// A linear animation curve causes an animation to occur evenly over its duration.
-        case linear
+        case Linear
         /// An ease-out curve causes the animation to begin quickly, and then slow down as it completes.
-        case easeOut
+        case EaseOut
         /// An ease-in curve causes the animation to begin slowly, and then speed up as it progresses.
-        case easeIn
+        case EaseIn
         /// An ease-in ease-out curve causes the animation to begin slowly, accelerate through the middle of its duration, and then slow again before completing. This is the default curve for most animations.
-        case easeInOut
+        case EaseInOut
     }
 
     /// Determines if the animation plays in the reverse upon completion.
@@ -64,7 +64,7 @@ public class Animation {
     public var duration: TimeInterval = 1
 
     /// The animation curve that the receiver will apply to the changes it is supposed to animate.
-    public var curve: Curve = .easeInOut
+    public var curve: Curve = .EaseInOut
 
     private var completionObservers: [AnyObject] = []
     private var cancelObservers: [AnyObject] = []
@@ -81,7 +81,7 @@ public class Animation {
     }
 
     deinit {
-        let nc = NotificationCenter.default()
+        let nc = NotificationCenter.default
         for observer in completionObservers {
             nc.removeObserver(observer)
         }
@@ -100,9 +100,9 @@ public class Animation {
     /// - parameter action: a block of code to be executed at the end of an animation.
     ///
     /// - returns: the observer object.
-    public func addCompletionObserver(_ action: () -> Void) -> AnyObject {
-        let nc = NotificationCenter.default()
-        let observer = nc.addObserver(forName: NSNotification.Name(rawValue: AnimationCompletedEvent), object: self, queue: OperationQueue.current(), using: { notification in
+    public func addCompletionObserver(_ action: @escaping () -> Void) -> AnyObject {
+        let nc = NotificationCenter.default
+        let observer = nc.addObserver(forName: NSNotification.Name(rawValue: AnimationCompletedEvent), object: self, queue: OperationQueue.current, using: { notification in
             action()
         })
         completionObservers.append(observer)
@@ -113,7 +113,7 @@ public class Animation {
     ///
     /// - parameter observer: the observer object to remove.
     public func removeCompletionObserver(_ observer: AnyObject) {
-        let nc = NotificationCenter.default()
+        let nc = NotificationCenter.default
         nc.removeObserver(observer, name: NSNotification.Name(rawValue: AnimationCompletedEvent), object: self)
     }
 
@@ -122,7 +122,7 @@ public class Animation {
     ///  This method is triggered when an animation completes. This can be used in place of `addCompletionObserver` for objects outside the scope of the context in which the animation is created.
     public func postCompletedEvent() {
         DispatchQueue.main.async {
-            NotificationCenter.default().post(name: Notification.Name(rawValue: AnimationCompletedEvent), object: self)
+            NotificationCenter.default.post(name: Notification.Name(rawValue: AnimationCompletedEvent), object: self)
         }
     }
 
@@ -133,9 +133,9 @@ public class Animation {
     /// - parameter action: a block of code to be executed when an animation is canceled.
     ///
     /// - returns: the observer object.
-    public func addCancelObserver(_ action: () -> Void) -> AnyObject {
-        let nc = NotificationCenter.default()
-        let observer = nc.addObserver(forName: NSNotification.Name(rawValue: AnimationCancelledEvent), object: self, queue: OperationQueue.current(), using: { notification in
+    public func addCancelObserver(_ action: @escaping () -> Void) -> AnyObject {
+        let nc = NotificationCenter.default
+        let observer = nc.addObserver(forName: NSNotification.Name(rawValue: AnimationCancelledEvent), object: self, queue: OperationQueue.current, using: { notification in
             action()
         })
         cancelObservers.append(observer)
@@ -146,7 +146,7 @@ public class Animation {
     ///
     /// - parameter observer: the cancel observer object to remove.
     public func removeCancelObserver(_ observer: AnyObject) {
-        let nc = NotificationCenter.default()
+        let nc = NotificationCenter.default
         nc.removeObserver(observer, name: NSNotification.Name(rawValue: AnimationCancelledEvent), object: self)
     }
 
@@ -155,7 +155,7 @@ public class Animation {
     ///  This method is triggered when an animation is canceled. This can be used in place of `addCancelObserver` for objects outside the scope of the context in which the animation is created.
     public func postCancelledEvent() {
         DispatchQueue.main.async {
-            NotificationCenter.default().post(name: Notification.Name(rawValue: AnimationCancelledEvent), object: self)
+            NotificationCenter.default.post(name: Notification.Name(rawValue: AnimationCancelledEvent), object: self)
         }
     }
 }

C4/UI/Arc.swift

@@ -52,7 +52,7 @@ public class Arc: Shape {
         super.init()
 
         let arc = CGMutablePath()
-        arc.addArc(nil, x: CGFloat(center.x), y: CGFloat(center.y), radius: CGFloat(radius), startAngle: CGFloat(start), endAngle: CGFloat(end), clockwise: !clockwise)
+        arc.addArc(center: CGPoint(center), radius: CGFloat(radius), startAngle: CGFloat(start), endAngle: CGFloat(end), clockwise: !clockwise)
         path = Path(path: arc)
         adjustToFitPath()
     }