Merge pull request #35 from tomaskraina/enhancement/resizePanelByPointerScroll

Allow pointer scroll to resize/move panel

Author: schwmi

Aiolos/Aiolos/Sources/HorizontalPanGestureRecognizer.swift

@@ -5,4 +5,15 @@
 import UIKit
 
 /// UIPanGestureRecognizer that's being used for moving the panel horizontally
-public final class HorizontalPanGestureRecognizer: UIPanGestureRecognizer { }
+public final class HorizontalPanGestureRecognizer: UIPanGestureRecognizer {
+
+    // MARK: - Properties
+
+    public var detectsPointerScrolling: Bool = false {
+        didSet {
+            guard #available(iOS 13.4, *), NSClassFromString("UIPointerInteraction") != nil else { return }
+
+            self.allowedScrollTypesMask = self.detectsPointerScrolling ? .continuous : []
+        }
+    }
+}

Aiolos/Aiolos/Sources/PanGestureRecognizer.swift

@@ -9,28 +9,74 @@
 import UIKit
 
 
-/// GestureRecognizer that recognizes a pan gesture without any delay
-public final class PanGestureRecognizer: UIGestureRecognizer {
+/// Set of methods implemented by both UIPanGestureRecognizer and our own NoDelayPanGestureRecognizer
+@objc
+protocol PanGestureRecognizer: AnyObject {
+
+    // We need the @objc annotations because of `typealias PanOrScrollGestureRecognizer = UIGestureRecognizer & PanGestureRecognizer` in PanelGestures
+    // which makes the methods in our `NoDelayPanGestureRecognizer` to be called via objc bridging. If we don't have these annotations, we get crashes in runtime.
+    @objc(translationInView:)
+    func translation(in view: UIView?) -> CGPoint
+    @objc(setTranslation:inView:)
+    func setTranslation(_ translation: CGPoint, in view: UIView?)
+    @objc(velocityInView:)
+    func velocity(in view: UIView?) -> CGPoint
+}
+
+extension UIPanGestureRecognizer: PanGestureRecognizer { }
+
+
+// MARK: - PointerScrollGestureRecognizer
+
+/// A UIPanGestureRecognizer subclass that recognizes only pointer scroll gestures
+/// We won't need this after UIGestureRecognizer subclasses will be able to detect pointer scrolls (FB7733482)
+public final class PointerScrollGestureRecognizer: UIPanGestureRecognizer {
+
+    // MARK: - Lifecycle
 
-    enum StartMode: Equatable {
-        case onFixedArea
-        case onVerticallyScrollableArea(competingScrollView: UIScrollView)
+    /// As a non-failable initializer cannot be overwritten by a failable initializer, we mark this initializer as 'private' and use make() factory method from outside
+    private override init(target: Any?, action: Selector?) {
+        super.init(target: target, action: action)
     }
+}
+
+public extension PointerScrollGestureRecognizer {
+
+    static func make(withTarget target: Any?, action: Selector?) -> PointerScrollGestureRecognizer? {
+        guard #available(iOS 13.4, *), NSClassFromString("UIPointerInteraction") != nil else { return nil }
+
+        let gesture = PointerScrollGestureRecognizer(target: target, action: action)
+        gesture.allowedScrollTypesMask = .continuous
+        return gesture
+    }
+}
+
+// MARK: - UIGestureRecognizer+Subclass
+
+public extension PointerScrollGestureRecognizer {
+
+    @available(iOS 13.4, *)
+    override func shouldReceive(_ event: UIEvent) -> Bool {
+        guard event.type == .scroll else { return false }
+
+        return super.shouldReceive(event)
+    }
+}
+
+
+// MARK: - NoDelayPanGestureRecognizer
+
+/// A UIGestureRecognizer subclass that recognizes pan gestures without any delay but doesn't recognize scrolling with pointer
+public final class NoDelayPanGestureRecognizer: UIGestureRecognizer {
 
     private lazy var panForVelocity: UIPanGestureRecognizer = self.makeVelocityPan()
-    private var initialPoint: CGPoint?
     private var lastPoint: CGPoint?
     private var currentPoint: CGPoint?
-
-    // MARK: Properties
-
-    private(set) var didPan: Bool = false
-    var startMode: StartMode = .onFixedArea
 }
 
 // MARK: - UIGestureRecognizer+Subclass
 
-public extension PanGestureRecognizer {
+public extension NoDelayPanGestureRecognizer {
 
     override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent) {
         super.touchesBegan(touches, with: event)
@@ -50,11 +96,9 @@ public extension PanGestureRecognizer {
         guard let touch = touches.first else { return }
 
         let location = touch.location(in: self.view?.window)
-        self.initialPoint = location
         self.lastPoint = location
         self.currentPoint = location
         self.state = .began
-        self.didPan = false
     }
 
     override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent) {
@@ -65,17 +109,6 @@ public extension PanGestureRecognizer {
 
         let currentPoint = touch.location(in: self.view?.window)
         self.currentPoint = currentPoint
-
-        if self.totalTranslation.hypotenuse() > Constants.minTranslation && self.didPan == false {
-            self.didPan = true
-
-            // if we recognized a pan, make sure it can be considered a vertical pan
-            guard self.totalTranslation.direction() == .vertical else {
-                self.state = .cancelled
-                return
-            }
-        }
-
         self.state = .changed
     }
 
@@ -96,41 +129,36 @@ public extension PanGestureRecognizer {
     override func reset() {
         super.reset()
 
-        self.didPan = false
-        self.startMode = .onFixedArea
         self.panForVelocity = self.makeVelocityPan()
     }
 }
 
 // MARK: - PanGestureRecognizer
 
-extension PanGestureRecognizer {
+extension NoDelayPanGestureRecognizer: PanGestureRecognizer {
 
-    func translation(in view: UIView) -> CGPoint {
+    func translation(in view: UIView?) -> CGPoint {
         guard let lastPoint = self.lastPoint else { return .zero }
         guard let currentPoint = self.currentPoint else { return .zero }
+        guard let view = view ?? self.view?.window else { return .zero }
 
         return self.translation(from: lastPoint, to: currentPoint, in: view)
     }
 
-    func setTranslation(_ translation: CGPoint, in view: UIView) {
+    func setTranslation(_ translation: CGPoint, in view: UIView?) {
         guard let currentPoint = self.currentPoint else { return }
 
         self.lastPoint = currentPoint.applying(.init(translationX: -translation.x, y: -translation.y))
     }
 
-    func velocity(in view: UIView) -> CGPoint {
+    func velocity(in view: UIView?) -> CGPoint {
         return self.panForVelocity.velocity(in: view)
     }
 }
 
 // MARK: - Private
 
-private extension PanGestureRecognizer {
-
-    struct Constants {
-        static let minTranslation: CGFloat = 5.0
-    }
+private extension NoDelayPanGestureRecognizer {
 
     func makeVelocityPan() -> UIPanGestureRecognizer {
         let pan = UIPanGestureRecognizer(target: nil, action: nil)
@@ -140,39 +168,12 @@ private extension PanGestureRecognizer {
         return pan
     }
 
-    var totalTranslation: CGPoint {
-        guard let view = self.view else { return .zero }
-        guard let initialPoint = self.initialPoint else { return .zero }
-        guard let currentPoint = self.currentPoint else { return .zero }
-
-        return self.translation(from: initialPoint, to: currentPoint, in: view)
-    }
-
     func translation(from startPoint: CGPoint, to endPoint: CGPoint, in view: UIView) -> CGPoint {
-        guard let window = self.view?.window else { return .zero }
+        guard let window = view.window else { return .zero }
 
         let startPointInView = window.convert(startPoint, to: view)
         let endPointInView = window.convert(endPoint, to: view)
 
         return CGPoint(x: endPointInView.x - startPointInView.x, y: endPointInView.y - startPointInView.y)
     }
 }
-
-private extension CGPoint {
-
-    enum Direction {
-        case horizontal
-        case vertical
-    }
-
-    func hypotenuse() -> CGFloat {
-        return sqrt(self.x * self.x + self.y * self.y)
-    }
-
-    func direction() -> Direction {
-        let horizontalDiff = self.x * self.x
-        let verticalDiff = self.y * self.y
-
-        return horizontalDiff > verticalDiff ? .horizontal : .vertical
-    }
-}

Aiolos/Aiolos/Sources/PanelConfiguration.swift

@@ -17,7 +17,19 @@ public extension Panel {
         public typealias Edge = _PanelEdge
         public typealias Position = _PanelPosition
         public typealias PositionLogic = _PanelPositionLogic
-        public typealias GestureResizingMode = _PanelGestureResizingMode
+
+        public struct GestureResizingMode: OptionSet {
+            public let rawValue: Int
+
+            public init(rawValue: Int) {
+                self.rawValue = rawValue
+            }
+
+            public static let handle = GestureResizingMode(rawValue: 1 << 0)
+            public static let content = GestureResizingMode(rawValue: 1 << 1)
+            public static let byTouch = GestureResizingMode(rawValue: 1 << 2)
+            public static let byPointerScroll = GestureResizingMode(rawValue: 1 << 3)
+        }
 
         public enum ResizeHandleMode {
             case hidden
@@ -156,13 +168,6 @@ public enum _PanelPositionLogic: Int {
     }
 }
 
-@objc(PanelGestureResizingMode)
-public enum _PanelGestureResizingMode: Int {
-    case disabled
-    case excludingContent
-    case includingContent
-}
-
 extension _PanelPositionLogic {
 
     func applyingInsets(of view: UIView, to insets: NSDirectionalEdgeInsets, edge: Panel.Configuration.Edge) -> NSDirectionalEdgeInsets {
@@ -185,3 +190,11 @@ extension _PanelPositionLogic {
         return insets
     }
 }
+
+extension Panel.Configuration.GestureResizingMode {
+
+    public static let includingContent: Self = [.handle, .content, .byTouch, .byPointerScroll]
+    public static let excludingContent: Self = [.handle, .byTouch, .byPointerScroll]
+    var isPanningByTouchEnabled: Bool { self.contains(.byTouch) && (self.contains(.content) || self.contains(.handle)) }
+    var isScrollingByPointerEnabled: Bool { self.contains(.byPointerScroll) && (self.contains(.content) || self.contains(.handle)) }
+}