Merge pull request #251 from OriTheElf/master

lucdion · web-flow · commit 676ef4f124f2 · 2022-06-07T08:38:01.000-04:00
Fix issue #234
diff --git a/Sources/Extensions/CALayer+PinLayout.swift b/Sources/Extensions/CALayer+PinLayout.swift
@@ -20,7 +20,7 @@
 import QuartzCore
 
 extension CALayer: Layoutable {
-    public typealias View = CALayer
+    public typealias PinView = CALayer
 
     public var superview: CALayer? {
         return superlayer
@@ -58,7 +58,7 @@ extension CALayer: Layoutable {
     }
 
     public func setRect(_ rect: CGRect, keepTransform: Bool) {
-        let adjustedRect = Coordinates<View>.adjustRectToDisplayScale(rect)
+        let adjustedRect = Coordinates<PinView>.adjustRectToDisplayScale(rect)
 
         if keepTransform {
             /*
diff --git a/Sources/Extensions/NSView+PinLayout.swift b/Sources/Extensions/NSView+PinLayout.swift
@@ -23,7 +23,7 @@ import Foundation
 import AppKit
 
 extension NSView: Layoutable {
-    public typealias View = NSView
+    public typealias PinView = NSView
 
     public var pin: PinLayout<NSView> {
         return PinLayout(view: self, keepTransform: true)
@@ -48,7 +48,7 @@ extension NSView: Layoutable {
     }
 
     public func setRect(_ rect: CGRect, keepTransform: Bool) {
-        let adjustedRect = Coordinates<View>.adjustRectToDisplayScale(rect)
+        let adjustedRect = Coordinates<PinView>.adjustRectToDisplayScale(rect)
 
         if let superview = superview, !superview.isFlipped {
             var flippedRect = adjustedRect
diff --git a/Sources/Extensions/UIView+PinLayout.swift b/Sources/Extensions/UIView+PinLayout.swift
@@ -23,7 +23,7 @@ import Foundation
 import UIKit
 
 extension UIView: Layoutable, SizeCalculable {
-    public typealias View = UIView
+    public typealias PinView = UIView
 
     public var pin: PinLayout<UIView> {
         return PinLayout(view: self, keepTransform: true)
@@ -59,7 +59,7 @@ extension UIView: Layoutable, SizeCalculable {
     }
 
     public func setRect(_ rect: CGRect, keepTransform: Bool) {
-        let adjustedRect = Coordinates<View>.adjustRectToDisplayScale(rect)
+        let adjustedRect = Coordinates<PinView>.adjustRectToDisplayScale(rect)
 
         if keepTransform {
             /*
@@ -118,8 +118,8 @@ extension UIView: AutoSizeCalculable {
     }
 
     public func setAutoSizingRect(_ rect: CGRect, margins: PEdgeInsets) {
-        self.autoSizingRect = Coordinates<View>.adjustRectToDisplayScale(rect)
-        self.autoSizingRectWithMargins = Coordinates<View>.adjustRectToDisplayScale(rect.inset(by: margins))
+        self.autoSizingRect = Coordinates<PinView>.adjustRectToDisplayScale(rect)
+        self.autoSizingRectWithMargins = Coordinates<PinView>.adjustRectToDisplayScale(rect.inset(by: margins))
     }
 
     public func autoSizeThatFits(_ size: CGSize, layoutClosure: () -> Void) -> CGSize {
diff --git a/Sources/Impl/Coordinates.swift b/Sources/Impl/Coordinates.swift
@@ -34,58 +34,58 @@ public func _pinlayoutSetUnitTest(scale: CGFloat?) {
     }
 }
 
-final class Coordinates<View: Layoutable> {
-    static func hCenter(_ view: View, keepTransform: Bool) -> CGFloat {
+final class Coordinates<PinView: Layoutable> {
+    static func hCenter(_ view: PinView, keepTransform: Bool) -> CGFloat {
         let rect = view.getRect(keepTransform: keepTransform)
         return rect.minX + (rect.width / 2)
     }
 
-    static func vCenter(_ view: View, keepTransform: Bool) -> CGFloat {
+    static func vCenter(_ view: PinView, keepTransform: Bool) -> CGFloat {
         let rect = view.getRect(keepTransform: keepTransform)
         return rect.minY + (rect.height / 2)
     }
 
-    static func topLeft(_ view: View, keepTransform: Bool) -> CGPoint {
+    static func topLeft(_ view: PinView, keepTransform: Bool) -> CGPoint {
         let rect = view.getRect(keepTransform: keepTransform)
         return CGPoint(x: rect.minX, y: rect.minY)
     }
 
-    static func topCenter(_ view: View, keepTransform: Bool) -> CGPoint {
+    static func topCenter(_ view: PinView, keepTransform: Bool) -> CGPoint {
         let rect = view.getRect(keepTransform: keepTransform)
         return CGPoint(x: rect.minX + (rect.width / 2), y: rect.minY)
     }
 
-    static func topRight(_ view: View, keepTransform: Bool) -> CGPoint {
+    static func topRight(_ view: PinView, keepTransform: Bool) -> CGPoint {
         let rect = view.getRect(keepTransform: keepTransform)
         return CGPoint(x: rect.minX + rect.width, y: rect.minY)
     }
 
-    static func centerLeft(_ view: View, keepTransform: Bool) -> CGPoint {
+    static func centerLeft(_ view: PinView, keepTransform: Bool) -> CGPoint {
         let rect = view.getRect(keepTransform: keepTransform)
         return CGPoint(x: rect.minX, y: rect.minY + (rect.height / 2))
     }
     
-    static func center(_ view: View, keepTransform: Bool) -> CGPoint {
+    static func center(_ view: PinView, keepTransform: Bool) -> CGPoint {
         let rect = view.getRect(keepTransform: keepTransform)
         return CGPoint(x: rect.minX + (rect.width / 2), y: rect.minY + (rect.height / 2))
     }
 
-    static func centerRight(_ view: View, keepTransform: Bool) -> CGPoint {
+    static func centerRight(_ view: PinView, keepTransform: Bool) -> CGPoint {
         let rect = view.getRect(keepTransform: keepTransform)
         return CGPoint(x: rect.minX + rect.width, y: rect.minY + (rect.height / 2))
     }
     
-    static func bottomLeft(_ view: View, keepTransform: Bool) -> CGPoint {
+    static func bottomLeft(_ view: PinView, keepTransform: Bool) -> CGPoint {
         let rect = view.getRect(keepTransform: keepTransform)
         return CGPoint(x: rect.minX, y: rect.minY + rect.height)
     }
 
-    static func bottomCenter(_ view: View, keepTransform: Bool) -> CGPoint {
+    static func bottomCenter(_ view: PinView, keepTransform: Bool) -> CGPoint {
         let rect = view.getRect(keepTransform: keepTransform)
         return CGPoint(x: rect.minX + (rect.width / 2), y: rect.minY + rect.height)
     }
 
-    static func bottomRight(_ view: View, keepTransform: Bool) -> CGPoint {
+    static func bottomRight(_ view: PinView, keepTransform: Bool) -> CGPoint {
         let rect = view.getRect(keepTransform: keepTransform)
         return CGPoint(x: rect.minX + rect.width, y: rect.minY + rect.height)
     }
diff --git a/Sources/Impl/PinLayout+Coordinates.swift b/Sources/Impl/PinLayout+Coordinates.swift
@@ -361,26 +361,26 @@ extension PinLayout {
         }
     }
     
-    private func computeCoordinates(_ point: CGPoint, _ layoutSuperview: View, _ referenceSuperview: View) -> CGPoint {
+    private func computeCoordinates(_ point: CGPoint, _ layoutSuperview: PinView, _ referenceSuperview: PinView) -> CGPoint {
         if layoutSuperview == referenceSuperview {
             return point   // same superview => no coordinates conversion required.
-        } else if referenceSuperview == layoutSuperview.superview as? View {
+        } else if referenceSuperview == layoutSuperview.superview as? PinView {
             let layoutSuperviewRect = layoutSuperview.getRect(keepTransform: keepTransform)
             return CGPoint(x: point.x - layoutSuperviewRect.origin.x,
                            y: point.y - layoutSuperviewRect.origin.y)
         // TOOD: Handle all cases. computeCoordinates should compute coordinates using only untransformed
         //       coordinates, but UIView.convert(...) below use transformed coordinates!
         //       Currently we only support 1 and 2 levels.
         } else {
-            return referenceSuperview.convert(point, to: layoutSuperview as? View.View)
+            return referenceSuperview.convert(point, to: layoutSuperview as? PinView.PinView)
         }
     }
     
     internal  func computeCoordinates(forAnchors anchors: [Anchor], _ context: Context) -> [CGPoint]? {
         guard let layoutSuperview = layoutSuperview(context) else { return nil }
         var results: [CGPoint] = []
         anchors.forEach({ (anchor) in
-            let anchor = anchor as! AnchorImpl<View>
+            let anchor = anchor as! AnchorImpl<PinView>
             if let referenceSuperview = referenceSuperview(anchor.view, context) {
                 results.append(computeCoordinates(anchor.point(keepTransform: keepTransform),
                                                   layoutSuperview, referenceSuperview))
@@ -392,7 +392,7 @@ extension PinLayout {
     }
     
     internal func computeCoordinate(forEdge edge: HorizontalEdge, _ context: Context) -> CGFloat? {
-        let edge = edge as! HorizontalEdgeImpl<View>
+        let edge = edge as! HorizontalEdgeImpl<PinView>
         guard let layoutSuperview = layoutSuperview(context) else { return nil }
         guard let referenceSuperview = referenceSuperview(edge.view, context) else { return nil }
         
@@ -401,7 +401,7 @@ extension PinLayout {
     }
     
     internal func computeCoordinate(forEdge edge: VerticalEdge, _ context: Context) -> CGFloat? {
-        let edge = edge as! VerticalEdgeImpl<View>
+        let edge = edge as! VerticalEdgeImpl<PinView>
         guard let layoutSuperview = layoutSuperview(context) else { return nil }
         guard let referenceSuperview = referenceSuperview(edge.view, context) else { return nil }
         
diff --git a/Sources/Impl/PinLayout+Layouting.swift b/Sources/Impl/PinLayout+Layouting.swift
@@ -45,7 +45,7 @@ extension PinLayout {
         isLayouted = true
     }
     
-    private func apply(onView view: View) {
+    private func apply(onView view: PinView) {
         displayLayoutWarnings()
         
         var newRect = view.getRect(keepTransform: keepTransform)
diff --git a/Sources/Impl/PinLayout+Warning.swift b/Sources/Impl/PinLayout+Warning.swift
@@ -36,17 +36,17 @@ extension PinLayout {
     }
     
     internal func relativeEdgeContext(method: String, edge: VerticalEdge) -> String {
-        let edge = edge as! VerticalEdgeImpl<View>
+        let edge = edge as! VerticalEdgeImpl<PinView>
         return "\(method)(to: .\(edge.type.rawValue), of: \(viewDescription(edge.view)))"
     }
     
     internal func relativeEdgeContext(method: String, edge: HorizontalEdge) -> String {
-        let edge = edge as! HorizontalEdgeImpl<View>
+        let edge = edge as! HorizontalEdgeImpl<PinView>
         return "\(method)(to: .\(edge.type.rawValue), of: \(viewDescription(edge.view))"
     }
     
     internal func relativeAnchorContext(method: String, anchor: Anchor) -> String {
-        let anchor = anchor as! AnchorImpl<View>
+        let anchor = anchor as! AnchorImpl<PinView>
         return "\(method)(to: .\(anchor.type.rawValue), of: \(viewDescription(anchor.view)))"
     }
     
@@ -114,20 +114,20 @@ extension PinLayout {
         }
     }
 
-    internal func viewDescription(_ view: View) -> String {
+    internal func viewDescription(_ view: PinView) -> String {
         let rect = view.getRect(keepTransform: keepTransform)
         return "(\(viewName(view)), Frame: \(rect))"
     }
     
-    internal func viewName(_ view: View) -> String {
+    internal func viewName(_ view: PinView) -> String {
         return "\(type(of: view))"
     }
 
     internal func insetsDescription(_ insets: PEdgeInsets) -> String {
         return "UIEdgeInsets(top: \(insets.top), left: \(insets.left), bottom: \(insets.bottom), right: \(insets.right))"
     }
 
-    internal func pinLayoutDisplayConsoleWarning(_ text: String, _ view: View) {
+    internal func pinLayoutDisplayConsoleWarning(_ text: String, _ view: PinView) {
         var displayText = "\n👉 \(text)"
 
         let rect = view.getRect(keepTransform: keepTransform)
@@ -142,7 +142,7 @@ extension PinLayout {
         var hierarchy: [String] = []
         while let parent = currentView.superview {
             hierarchy.insert("\(type(of: parent))", at: 0)
-            currentView = parent as! View
+            currentView = parent as! PinView
         }
         if hierarchy.count > 0 {
             #if swift(>=4.1)
diff --git a/Sources/Impl/TypesImpl.swift b/Sources/Impl/TypesImpl.swift
@@ -32,10 +32,10 @@ struct Size {
     var height: CGFloat?
 }
 
-class EdgeListImpl<View: Layoutable>: EdgeList {
-    internal let view: View
+class EdgeListImpl<PinView: Layoutable>: EdgeList {
+    internal let view: PinView
 
-    init(view: View) {
+    init(view: PinView) {
         self.view = view
     }
 
@@ -52,14 +52,14 @@ class EdgeListImpl<View: Layoutable>: EdgeList {
     var end: HorizontalEdge { return view.isLTR() ? right : left }
 }
 
-class HorizontalEdgeImpl<View: Layoutable>: HorizontalEdge {
+class HorizontalEdgeImpl<PinView: Layoutable>: HorizontalEdge {
     enum EdgeType: String {
         case left
         case hCenter
         case right
     }
 
-    let view: View
+    let view: PinView
     let type: EdgeType
 
     func x(keepTransform: Bool) -> CGFloat {
@@ -72,20 +72,20 @@ class HorizontalEdgeImpl<View: Layoutable>: HorizontalEdge {
         }
     }
 
-    internal init(view: View, type: EdgeType) {
+    internal init(view: PinView, type: EdgeType) {
         self.view = view
         self.type = type
     }
 }
 
-class VerticalEdgeImpl<View: Layoutable>: VerticalEdge {
+class VerticalEdgeImpl<PinView: Layoutable>: VerticalEdge {
     enum EdgeType: String {
         case top
         case vCenter
         case bottom
     }
     
-    internal let view: View
+    internal let view: PinView
     internal let type: EdgeType
 
     func y(keepTransform: Bool) -> CGFloat {
@@ -99,16 +99,16 @@ class VerticalEdgeImpl<View: Layoutable>: VerticalEdge {
         }
     }
 
-    internal init(view: View, type: EdgeType) {
+    internal init(view: PinView, type: EdgeType) {
         self.view = view
         self.type = type
     }
 }
 
-class AnchorListImpl<View: Layoutable>: AnchorList {
-    internal let view: View
+class AnchorListImpl<PinView: Layoutable>: AnchorList {
+    internal let view: PinView
 
-    internal init(view: View) {
+    internal init(view: PinView) {
         self.view = view
     }
 
@@ -143,8 +143,8 @@ enum AnchorType: String {
     case bottomRight
 }
 
-class AnchorImpl<View: Layoutable>: Anchor {
-    let view: View
+class AnchorImpl<PinView: Layoutable>: Anchor {
+    let view: PinView
     let type: AnchorType
 
     func point(keepTransform: Bool) -> CGPoint {
@@ -161,7 +161,7 @@ class AnchorImpl<View: Layoutable>: Anchor {
         }
     }
 
-    fileprivate init(view: View, type: AnchorType) {
+    fileprivate init(view: PinView, type: AnchorType) {
         self.view = view
         self.type = type
     }
diff --git a/Sources/Layoutable+PinLayout.swift b/Sources/Layoutable+PinLayout.swift
@@ -21,10 +21,10 @@ import Foundation
 
 extension Layoutable {
     public var anchor: AnchorList {
-        return AnchorListImpl(view: self as! View)
+        return AnchorListImpl(view: self as! PinView)
     }
 
     public var edge: EdgeList {
-        return EdgeListImpl(view: self as! View)
+        return EdgeListImpl(view: self as! PinView)
     }
 }
diff --git a/Sources/Layoutable.swift b/Sources/Layoutable.swift
@@ -24,15 +24,15 @@ import AppKit
 #endif
 
 public protocol Layoutable: AnyObject, Equatable, CustomDebugStringConvertible {
-    associatedtype View: Layoutable
+    associatedtype PinView: Layoutable
 
-    var superview: View? { get }
-    var subviews: [View] { get }
+    var superview: PinView? { get }
+    var subviews: [PinView] { get }
 
     func getRect(keepTransform: Bool) -> CGRect
     func setRect(_ rect: CGRect, keepTransform: Bool)
 
-    func convert(_ point: CGPoint, to view: View?) -> CGPoint
+    func convert(_ point: CGPoint, to view: PinView?) -> CGPoint
 
     func isLTR() -> Bool
 }
diff --git a/Sources/PinLayout+Between.swift b/Sources/PinLayout+Between.swift
diff --git a/Sources/PinLayout+Relative.swift b/Sources/PinLayout+Relative.swift
diff --git a/Sources/PinLayout+Size.swift b/Sources/PinLayout+Size.swift
diff --git a/Sources/PinLayout.swift b/Sources/PinLayout.swift

Original file line number	Diff line number	Diff line change
`@@ -34,58 +34,58 @@ public func _pinlayoutSetUnitTest(scale: CGFloat?) {`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`
`37`		`-final class Coordinates<View: Layoutable> {`
`38`		`- static func hCenter(_ view: View, keepTransform: Bool) -> CGFloat {`
	`37`	`+final class Coordinates<PinView: Layoutable> {`
	`38`	`+ static func hCenter(_ view: PinView, keepTransform: Bool) -> CGFloat {`
`39`	`39`	`let rect = view.getRect(keepTransform: keepTransform)`
`40`	`40`	`return rect.minX + (rect.width / 2)`
`41`	`41`	`}`
`42`	`42`
`43`		`- static func vCenter(_ view: View, keepTransform: Bool) -> CGFloat {`
	`43`	`+ static func vCenter(_ view: PinView, keepTransform: Bool) -> CGFloat {`
`44`	`44`	`let rect = view.getRect(keepTransform: keepTransform)`
`45`	`45`	`return rect.minY + (rect.height / 2)`
`46`	`46`	`}`
`47`	`47`
`48`		`- static func topLeft(_ view: View, keepTransform: Bool) -> CGPoint {`
	`48`	`+ static func topLeft(_ view: PinView, keepTransform: Bool) -> CGPoint {`
`49`	`49`	`let rect = view.getRect(keepTransform: keepTransform)`
`50`	`50`	`return CGPoint(x: rect.minX, y: rect.minY)`
`51`	`51`	`}`
`52`	`52`
`53`		`- static func topCenter(_ view: View, keepTransform: Bool) -> CGPoint {`
	`53`	`+ static func topCenter(_ view: PinView, keepTransform: Bool) -> CGPoint {`
`54`	`54`	`let rect = view.getRect(keepTransform: keepTransform)`
`55`	`55`	`return CGPoint(x: rect.minX + (rect.width / 2), y: rect.minY)`
`56`	`56`	`}`
`57`	`57`
`58`		`- static func topRight(_ view: View, keepTransform: Bool) -> CGPoint {`
	`58`	`+ static func topRight(_ view: PinView, keepTransform: Bool) -> CGPoint {`
`59`	`59`	`let rect = view.getRect(keepTransform: keepTransform)`
`60`	`60`	`return CGPoint(x: rect.minX + rect.width, y: rect.minY)`
`61`	`61`	`}`
`62`	`62`
`63`		`- static func centerLeft(_ view: View, keepTransform: Bool) -> CGPoint {`
	`63`	`+ static func centerLeft(_ view: PinView, keepTransform: Bool) -> CGPoint {`
`64`	`64`	`let rect = view.getRect(keepTransform: keepTransform)`
`65`	`65`	`return CGPoint(x: rect.minX, y: rect.minY + (rect.height / 2))`
`66`	`66`	`}`
`67`	`67`
`68`		`- static func center(_ view: View, keepTransform: Bool) -> CGPoint {`
	`68`	`+ static func center(_ view: PinView, keepTransform: Bool) -> CGPoint {`
`69`	`69`	`let rect = view.getRect(keepTransform: keepTransform)`
`70`	`70`	`return CGPoint(x: rect.minX + (rect.width / 2), y: rect.minY + (rect.height / 2))`
`71`	`71`	`}`
`72`	`72`
`73`		`- static func centerRight(_ view: View, keepTransform: Bool) -> CGPoint {`
	`73`	`+ static func centerRight(_ view: PinView, keepTransform: Bool) -> CGPoint {`
`74`	`74`	`let rect = view.getRect(keepTransform: keepTransform)`
`75`	`75`	`return CGPoint(x: rect.minX + rect.width, y: rect.minY + (rect.height / 2))`
`76`	`76`	`}`
`77`	`77`
`78`		`- static func bottomLeft(_ view: View, keepTransform: Bool) -> CGPoint {`
	`78`	`+ static func bottomLeft(_ view: PinView, keepTransform: Bool) -> CGPoint {`
`79`	`79`	`let rect = view.getRect(keepTransform: keepTransform)`
`80`	`80`	`return CGPoint(x: rect.minX, y: rect.minY + rect.height)`
`81`	`81`	`}`
`82`	`82`
`83`		`- static func bottomCenter(_ view: View, keepTransform: Bool) -> CGPoint {`
	`83`	`+ static func bottomCenter(_ view: PinView, keepTransform: Bool) -> CGPoint {`
`84`	`84`	`let rect = view.getRect(keepTransform: keepTransform)`
`85`	`85`	`return CGPoint(x: rect.minX + (rect.width / 2), y: rect.minY + rect.height)`
`86`	`86`	`}`
`87`	`87`
`88`		`- static func bottomRight(_ view: View, keepTransform: Bool) -> CGPoint {`
	`88`	`+ static func bottomRight(_ view: PinView, keepTransform: Bool) -> CGPoint {`
`89`	`89`	`let rect = view.getRect(keepTransform: keepTransform)`
`90`	`90`	`return CGPoint(x: rect.minX + rect.width, y: rect.minY + rect.height)`
`91`	`91`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ extension PinLayout {`
`45`	`45`	`isLayouted = true`
`46`	`46`	`}`
`47`	`47`
`48`		`- private func apply(onView view: View) {`
	`48`	`+ private func apply(onView view: PinView) {`
`49`	`49`	`displayLayoutWarnings()`
`50`	`50`
`51`	`51`	`var newRect = view.getRect(keepTransform: keepTransform)`
Original file line number	Diff line number	Diff line change
`@@ -36,17 +36,17 @@ extension PinLayout {`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`internal func relativeEdgeContext(method: String, edge: VerticalEdge) -> String {`
`39`		`- let edge = edge as! VerticalEdgeImpl<View>`
	`39`	`+ let edge = edge as! VerticalEdgeImpl<PinView>`
`40`	`40`	`return "\(method)(to: .\(edge.type.rawValue), of: \(viewDescription(edge.view)))"`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`internal func relativeEdgeContext(method: String, edge: HorizontalEdge) -> String {`
`44`		`- let edge = edge as! HorizontalEdgeImpl<View>`
	`44`	`+ let edge = edge as! HorizontalEdgeImpl<PinView>`
`45`	`45`	`return "\(method)(to: .\(edge.type.rawValue), of: \(viewDescription(edge.view))"`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`internal func relativeAnchorContext(method: String, anchor: Anchor) -> String {`
`49`		`- let anchor = anchor as! AnchorImpl<View>`
	`49`	`+ let anchor = anchor as! AnchorImpl<PinView>`
`50`	`50`	`return "\(method)(to: .\(anchor.type.rawValue), of: \(viewDescription(anchor.view)))"`
`51`	`51`	`}`
`52`	`52`
`@@ -114,20 +114,20 @@ extension PinLayout {`
`114`	`114`	`}`
`115`	`115`	`}`
`116`	`116`
`117`		`- internal func viewDescription(_ view: View) -> String {`
	`117`	`+ internal func viewDescription(_ view: PinView) -> String {`
`118`	`118`	`let rect = view.getRect(keepTransform: keepTransform)`
`119`	`119`	`return "(\(viewName(view)), Frame: \(rect))"`
`120`	`120`	`}`
`121`	`121`
`122`		`- internal func viewName(_ view: View) -> String {`
	`122`	`+ internal func viewName(_ view: PinView) -> String {`
`123`	`123`	`return "\(type(of: view))"`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`internal func insetsDescription(_ insets: PEdgeInsets) -> String {`
`127`	`127`	`return "UIEdgeInsets(top: \(insets.top), left: \(insets.left), bottom: \(insets.bottom), right: \(insets.right))"`
`128`	`128`	`}`
`129`	`129`
`130`		`- internal func pinLayoutDisplayConsoleWarning(_ text: String, _ view: View) {`
	`130`	`+ internal func pinLayoutDisplayConsoleWarning(_ text: String, _ view: PinView) {`
`131`	`131`	`var displayText = "\n👉 \(text)"`
`132`	`132`
`133`	`133`	`let rect = view.getRect(keepTransform: keepTransform)`
`@@ -142,7 +142,7 @@ extension PinLayout {`
`142`	`142`	`var hierarchy: [String] = []`
`143`	`143`	`while let parent = currentView.superview {`
`144`	`144`	`hierarchy.insert("\(type(of: parent))", at: 0)`
`145`		`- currentView = parent as! View`
	`145`	`+ currentView = parent as! PinView`
`146`	`146`	`}`
`147`	`147`	`if hierarchy.count > 0 {`
`148`	`148`	`#if swift(>=4.1)`
Original file line number	Diff line number	Diff line change
`@@ -32,10 +32,10 @@ struct Size {`
`32`	`32`	`var height: CGFloat?`
`33`	`33`	`}`
`34`	`34`
`35`		`-class EdgeListImpl<View: Layoutable>: EdgeList {`
`36`		`- internal let view: View`
	`35`	`+class EdgeListImpl<PinView: Layoutable>: EdgeList {`
	`36`	`+ internal let view: PinView`
`37`	`37`
`38`		`- init(view: View) {`
	`38`	`+ init(view: PinView) {`
`39`	`39`	`self.view = view`
`40`	`40`	`}`
`41`	`41`
`@@ -52,14 +52,14 @@ class EdgeListImpl<View: Layoutable>: EdgeList {`
`52`	`52`	`var end: HorizontalEdge { return view.isLTR() ? right : left }`
`53`	`53`	`}`
`54`	`54`
`55`		`-class HorizontalEdgeImpl<View: Layoutable>: HorizontalEdge {`
	`55`	`+class HorizontalEdgeImpl<PinView: Layoutable>: HorizontalEdge {`
`56`	`56`	`enum EdgeType: String {`
`57`	`57`	`case left`
`58`	`58`	`case hCenter`
`59`	`59`	`case right`
`60`	`60`	`}`
`61`	`61`
`62`		`- let view: View`
	`62`	`+ let view: PinView`
`63`	`63`	`let type: EdgeType`
`64`	`64`
`65`	`65`	`func x(keepTransform: Bool) -> CGFloat {`
`@@ -72,20 +72,20 @@ class HorizontalEdgeImpl<View: Layoutable>: HorizontalEdge {`
`72`	`72`	`}`
`73`	`73`	`}`
`74`	`74`
`75`		`- internal init(view: View, type: EdgeType) {`
	`75`	`+ internal init(view: PinView, type: EdgeType) {`
`76`	`76`	`self.view = view`
`77`	`77`	`self.type = type`
`78`	`78`	`}`
`79`	`79`	`}`
`80`	`80`
`81`		`-class VerticalEdgeImpl<View: Layoutable>: VerticalEdge {`
	`81`	`+class VerticalEdgeImpl<PinView: Layoutable>: VerticalEdge {`
`82`	`82`	`enum EdgeType: String {`
`83`	`83`	`case top`
`84`	`84`	`case vCenter`
`85`	`85`	`case bottom`
`86`	`86`	`}`
`87`	`87`
`88`		`- internal let view: View`
	`88`	`+ internal let view: PinView`
`89`	`89`	`internal let type: EdgeType`
`90`	`90`
`91`	`91`	`func y(keepTransform: Bool) -> CGFloat {`
`@@ -99,16 +99,16 @@ class VerticalEdgeImpl<View: Layoutable>: VerticalEdge {`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`
`102`		`- internal init(view: View, type: EdgeType) {`
	`102`	`+ internal init(view: PinView, type: EdgeType) {`
`103`	`103`	`self.view = view`
`104`	`104`	`self.type = type`
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`
`108`		`-class AnchorListImpl<View: Layoutable>: AnchorList {`
`109`		`- internal let view: View`
	`108`	`+class AnchorListImpl<PinView: Layoutable>: AnchorList {`
	`109`	`+ internal let view: PinView`
`110`	`110`
`111`		`- internal init(view: View) {`
	`111`	`+ internal init(view: PinView) {`
`112`	`112`	`self.view = view`
`113`	`113`	`}`
`114`	`114`
`@@ -143,8 +143,8 @@ enum AnchorType: String {`
`143`	`143`	`case bottomRight`
`144`	`144`	`}`
`145`	`145`
`146`		`-class AnchorImpl<View: Layoutable>: Anchor {`
`147`		`- let view: View`
	`146`	`+class AnchorImpl<PinView: Layoutable>: Anchor {`
	`147`	`+ let view: PinView`
`148`	`148`	`let type: AnchorType`
`149`	`149`
`150`	`150`	`func point(keepTransform: Bool) -> CGPoint {`
`@@ -161,7 +161,7 @@ class AnchorImpl<View: Layoutable>: Anchor {`
`161`	`161`	`}`
`162`	`162`	`}`
`163`	`163`
`164`		`- fileprivate init(view: View, type: AnchorType) {`
	`164`	`+ fileprivate init(view: PinView, type: AnchorType) {`
`165`	`165`	`self.view = view`
`166`	`166`	`self.type = type`
`167`	`167`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,10 +21,10 @@ import Foundation`
`21`	`21`
`22`	`22`	`extension Layoutable {`
`23`	`23`	`public var anchor: AnchorList {`
`24`		`- return AnchorListImpl(view: self as! View)`
	`24`	`+ return AnchorListImpl(view: self as! PinView)`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`public var edge: EdgeList {`
`28`		`- return EdgeListImpl(view: self as! View)`
	`28`	`+ return EdgeListImpl(view: self as! PinView)`
`29`	`29`	`}`
`30`	`30`	`}`