NEW FEATURE: Added optional middle position

VilemKurz · VilemKurz · commit 52bf01c894dc · 2018-07-12T00:06:46.000+02:00
diff --git a/Example/UIViewController-DisplayInDrawer/ContentViewController.swift b/Example/UIViewController-DisplayInDrawer/ContentViewController.swift
@@ -80,9 +80,14 @@ extension ContentViewController: DrawerConfiguration {
         return result
     }
 
+    func middlePositionY(for parentHeight: CGFloat) -> CGFloat? {
+        guard isViewLoaded else { return nil }
+        return parentHeight - separatorView.frame.minY
+    }
+
     func bottomPositionY(for parentHeight: CGFloat) -> CGFloat {
         guard isViewLoaded else { return 0 }
-        return parentHeight - separatorView.frame.minY
+        return parentHeight - 18
     }
 
     func setPanGestureTarget(_ target: Any, action: Selector) {
diff --git a/Example/UIViewController-DisplayInDrawer/MainViewController.swift b/Example/UIViewController-DisplayInDrawer/MainViewController.swift
@@ -1,6 +1,7 @@
 //  Copyright © 2018 Inloop. All rights reserved.
 
 import UIKit
+import UIViewController_DisplayInDrawer
 
 class MainViewController: UIViewController {
     @IBAction func push(_ sender: Any) {
@@ -12,7 +13,7 @@ class MainViewController: UIViewController {
     @IBAction func presentInDrawer(_ sender: Any) {
         let controller = makeContentViewController()
         controller.setup(for: .drawer)
-        navigationController?.displayInDrawer(controller, drawerPositionDelegate: nil)
+        navigationController?.displayInDrawer(controller, drawerPositionDelegate: self)
     }
 
     private func makeContentViewController() -> ContentViewController {
@@ -21,3 +22,25 @@ class MainViewController: UIViewController {
         return result
     }
 }
+
+extension MainViewController: DrawerPositionDelegate {
+    func didMoveDrawerToTopPosition() {
+        NSLog("did move drawer to top position")
+    }
+
+    func didMoveDrawerToMiddlePosition() {
+        NSLog("did move drawer to middle position")
+    }
+
+    func didMoveDrawerToBasePosition() {
+        NSLog("did move drawer to base position")
+    }
+    
+    func willDismissDrawer() {
+        NSLog("will dismiss drawer")
+    }
+
+    func didDismissDrawer() {
+        NSLog("did dismiss drawer")
+    }
+}
diff --git a/UIViewController-DisplayInDrawer/Classes/PanGestureTarget.swift b/UIViewController-DisplayInDrawer/Classes/PanGestureTarget.swift
@@ -8,6 +8,7 @@ final class PanGestureTarget {
      when view lands at the target drawer position
      */
     private let bounceVelocityThreshold: CGFloat = 100
+    private let skipMiddleVelocityThreshold: CGFloat = 1500
     private let animationDuration: TimeInterval = 0.25
     private let dampedAnimationDuration: TimeInterval = 0.4
     private let springAnimationDamping: CGFloat = 0.75
@@ -24,8 +25,9 @@ final class PanGestureTarget {
     private weak var drawerConfiguration: DrawerConfiguration?
     private weak var drawerPositionDelegate: DrawerPositionDelegate?
     private var initialDrawerCenterLocation: CGPoint = .zero
-    var basePositionY: CGFloat!
     var topPositionY: CGFloat!
+    var middlePositionY: CGFloat?
+    var bottomPositionY: CGFloat!
 
     init(canvasView: UIView,
          drawerContainerView: UIView,
@@ -41,8 +43,9 @@ final class PanGestureTarget {
     }
 
     internal func refreshDrawerPositions() {
-        basePositionY = drawerConfiguration?.bottomPositionY(for: canvasView.bounds.height) ?? 0
+        bottomPositionY = drawerConfiguration?.bottomPositionY(for: canvasView.bounds.height) ?? 0
         topPositionY = drawerConfiguration?.topPositionY(for: canvasView.bounds.height) ?? 0
+        middlePositionY = drawerConfiguration?.middlePositionY(for: canvasView.bounds.height)
     }
 
     deinit {
@@ -56,16 +59,13 @@ final class PanGestureTarget {
             performDrag(recognizer: recognizer)
         } else if recognizer.state == .ended || recognizer.state == .cancelled {
             let velocity = recognizer.velocity(in: canvasView)
-            if shouldFinishUp(recognizer: recognizer) {
-                animate(to: topPositionY, velocity: velocity)
-            } else {
-                animate(to: basePositionY, velocity: velocity)
-            }
+            let targetPositionY = self.targetPositionY(for: velocity)
+            animate(to: targetPositionY, velocity: velocity)
         }
     }
 
     private var isDraggedViewWithinAllowedArea: Bool {
-        return drawerContainerView.frame.minY > topPositionY && drawerContainerView.frame.minY < basePositionY
+        return drawerContainerView.frame.minY > topPositionY && drawerContainerView.frame.minY < bottomPositionY
     }
 
     private func performDrag(recognizer: UIPanGestureRecognizer) {
@@ -84,16 +84,20 @@ final class PanGestureTarget {
 
     private func updateDimming() {
         guard overDragAmount(drawerContainerView.center) == 0 else { return }
-        let currentDistanceToBasePosition = basePositionY - drawerContainerView.frame.minY
-        let totalDraggableDistance = basePositionY - topPositionY
-        let movementPercentage = currentDistanceToBasePosition / totalDraggableDistance
+        let currentDistanceToDimStartPosition = dimStartPosition - drawerContainerView.frame.minY
+        let totalDraggableDistance = dimStartPosition - topPositionY
+        let movementPercentage = currentDistanceToDimStartPosition / totalDraggableDistance
         dimmingView.alpha = movementPercentage * targetDimmingViewAlpha
     }
 
+    private var dimStartPosition: CGFloat {
+        return middlePositionY ?? bottomPositionY
+    }
+
     private func overDragAmount(_ newCenter: CGPoint) -> CGFloat {
         let newMinY = newCenter.y - drawerContainerView.frame.height/2
         let aboveTop = newMinY - topPositionY
-        let underBottom = newMinY - basePositionY
+        let underBottom = newMinY - bottomPositionY
         if aboveTop < 0 {
             return aboveTop
         } else if underBottom > 0 {
@@ -103,23 +107,46 @@ final class PanGestureTarget {
         }
     }
 
-    private func shouldFinishUp(recognizer: UIPanGestureRecognizer) -> Bool {
-        let velocity = recognizer.velocity(in: canvasView)
+    private func targetPositionY(for velocity: CGPoint) -> CGFloat {
+        let isDraggingQuickly = abs(velocity.y) > skipMiddleVelocityThreshold
         let isDraggingSlowly = abs(velocity.y) < bounceVelocityThreshold
-        if isDraggingSlowly {
-            return isInUpperHalfOfMovement()
+        let isDraggingUp = velocity.y < 0
+        if isDraggingQuickly && isDraggingUp {
+            return topPositionY
+        } else if isDraggingQuickly && !isDraggingUp {
+            return bottomPositionY
+        } else if isDraggingSlowly {
+            return nearestPosition(searchStyle: .nearest)
+        } else if isDraggingUp {
+            return nearestPosition(searchStyle: .higher)
+        } else if !isDraggingUp {
+            return nearestPosition(searchStyle: .lower)
         } else {
-            let isDraggingUp = velocity.y < 0
-            return isDraggingUp
+            fatalError()
         }
     }
 
-    private func isInUpperHalfOfMovement() -> Bool {
-        let allowedMovementMinY = topPositionY!
-        let allowedMovementMaxY = basePositionY!
-        let halfMovement = (allowedMovementMaxY - allowedMovementMinY) / 2
-        let movementMidY = allowedMovementMinY + halfMovement
-        return drawerContainerView.frame.minY < movementMidY
+    private enum NearestPositionSearchStyle {
+        case nearest, higher, lower
+    }
+
+    private func nearestPosition(searchStyle: NearestPositionSearchStyle) -> CGFloat {
+        let currentPosition = drawerContainerView.frame.minY
+        switch searchStyle {
+        case .nearest:
+            return positionsArray.min(by: { abs(currentPosition - $0) < abs(currentPosition - $1) })!
+        case .higher:
+            /* Keep in mind, that higher position means lower Y in UIView coordinate system */
+            return positionsArray.sorted(by: >).first(where: { currentPosition - $0 > 0 }) ?? topPositionY
+        case .lower:
+            /* Keep in mind, that lower position means higher Y in UIView coordinate system */
+            return positionsArray.sorted(by: <).first(where: { $0 - currentPosition > 0 }) ?? bottomPositionY
+        }
+    }
+
+    private var positionsArray: [CGFloat] {
+        guard let middlePositionY = middlePositionY else { return [bottomPositionY, topPositionY] }
+        return [bottomPositionY, middlePositionY, topPositionY]
     }
 
     private func animate(to minY: CGFloat, velocity: CGPoint) {
@@ -135,6 +162,8 @@ final class PanGestureTarget {
             guard finished else { return }
             if self.isOnTopPosition {
                 self.drawerPositionDelegate?.didMoveDrawerToTopPosition()
+            } else if self.isOnMiddlePosition {
+                self.drawerPositionDelegate?.didMoveDrawerToMiddlePosition()
             } else if self.isOnBasePosition {
                 self.drawerPositionDelegate?.didMoveDrawerToBasePosition()
             }
@@ -158,6 +187,16 @@ final class PanGestureTarget {
         }
     }
 
-    private var isOnTopPosition: Bool { return Int(drawerContainerView.frame.minY) == Int(topPositionY) }
-    private var isOnBasePosition: Bool { return Int(drawerContainerView.frame.minY) == Int(basePositionY) }
+    private var isOnTopPosition: Bool {
+        return Int(drawerContainerView.frame.minY) == Int(topPositionY)
+    }
+
+    private var isOnMiddlePosition: Bool {
+        guard let middlePositionY = middlePositionY else { return false }
+        return Int(drawerContainerView.frame.minY) == Int(middlePositionY)
+    }
+
+    private var isOnBasePosition: Bool {
+        return Int(drawerContainerView.frame.minY) == Int(bottomPositionY)
+    }
 }
diff --git a/UIViewController-DisplayInDrawer/Classes/UIViewController+PresentDrawerController.swift b/UIViewController-DisplayInDrawer/Classes/UIViewController+PresentDrawerController.swift
@@ -4,6 +4,8 @@ import UIKit
 
 public protocol DrawerConfiguration: class {
     func topPositionY(for parentHeight: CGFloat) -> CGFloat
+    ///If you return nil, there will only be two positions, top and bottom
+    func middlePositionY(for parentHeight: CGFloat) -> CGFloat?
     func bottomPositionY(for parentHeight: CGFloat) -> CGFloat
     /**
      drawerDismissClosure is injected by this lib.
@@ -25,8 +27,9 @@ public protocol DrawerConfiguration: class {
 }
 
 public protocol DrawerPositionDelegate: class {
-    func didMoveDrawerToBasePosition()
     func didMoveDrawerToTopPosition()
+    func didMoveDrawerToMiddlePosition()
+    func didMoveDrawerToBasePosition()
     func willDismissDrawer()
     func didDismissDrawer()
 }
@@ -84,7 +87,8 @@ extension UIViewController {
         return { [weak self, weak containerView, weak initialDisplayAnimator] in
             guard let strongSelf = self, let strongContainerView = containerView else { return }
             let oldTopPositionY = panGestureTarget.topPositionY!
-            let oldBasePositionY = panGestureTarget.basePositionY!
+            let oldMiddlePositionY = panGestureTarget.middlePositionY
+            let oldBasePositionY = panGestureTarget.bottomPositionY!
             panGestureTarget.refreshDrawerPositions()
             let newContainerHeight = strongSelf.view.bounds.height - panGestureTarget.topPositionY + bottomOverpullPaddingHeight
             if strongContainerView.frame.height != newContainerHeight {
@@ -95,19 +99,38 @@ extension UIViewController {
 
             let isOnOldTopPosition = Int(strongContainerView.frame.minY) == Int(oldTopPositionY)
             let newTopPositionIsDifferentThanOld = Int(panGestureTarget.topPositionY) != Int(oldTopPositionY)
+
+            let isOnOldMiddlePosition: Bool
+            let newMiddlePositionIsDifferentThanOld: Bool
+            if let oldMiddlePositionY = oldMiddlePositionY, let newMiddlePositionY = panGestureTarget.middlePositionY {
+                isOnOldMiddlePosition = Int(strongContainerView.frame.minY) == Int(oldMiddlePositionY)
+                newMiddlePositionIsDifferentThanOld = Int(newMiddlePositionY) != Int(oldMiddlePositionY)
+            } else {
+                isOnOldMiddlePosition = false
+                newMiddlePositionIsDifferentThanOld = false
+            }
+
             let isOnOldBottomPosition = Int(strongContainerView.frame.minY) == Int(oldBasePositionY)
-            let newBottomPositionIsDifferentThanOld = Int(panGestureTarget.basePositionY) != Int(oldBasePositionY)
+            let newBottomPositionIsDifferentThanOld = Int(panGestureTarget.bottomPositionY) != Int(oldBasePositionY)
+
             let isInitialDisplayAnimation = initialDisplayAnimator != nil
+
             if !isInitialDisplayAnimation && isOnOldTopPosition && newTopPositionIsDifferentThanOld {
                 self?.updateDrawerPosition(
                     inFlightAnimator: initialDisplayAnimator,
                     newTargetY: panGestureTarget.topPositionY,
                     containerView: strongContainerView
                 )
+            } else if !isInitialDisplayAnimation && isOnOldMiddlePosition && newMiddlePositionIsDifferentThanOld {
+                self?.updateDrawerPosition(
+                    inFlightAnimator: initialDisplayAnimator,
+                    newTargetY: panGestureTarget.middlePositionY ?? panGestureTarget.bottomPositionY,
+                    containerView: strongContainerView
+                )
             } else if isOnOldBottomPosition && newBottomPositionIsDifferentThanOld {
                 self?.updateDrawerPosition(
                     inFlightAnimator: initialDisplayAnimator,
-                    newTargetY: panGestureTarget.basePositionY,
+                    newTargetY: panGestureTarget.bottomPositionY,
                     containerView: strongContainerView
                 )
             }

Original file line number	Diff line number	Diff line change
`@@ -80,9 +80,14 @@ extension ContentViewController: DrawerConfiguration {`
`80`	`80`	`return result`
`81`	`81`	`}`
`82`	`82`
	`83`	`+ func middlePositionY(for parentHeight: CGFloat) -> CGFloat? {`
	`84`	`+ guard isViewLoaded else { return nil }`
	`85`	`+ return parentHeight - separatorView.frame.minY`
	`86`	`+ }`
	`87`	`+`
`83`	`88`	`func bottomPositionY(for parentHeight: CGFloat) -> CGFloat {`
`84`	`89`	`guard isViewLoaded else { return 0 }`
`85`		`- return parentHeight - separatorView.frame.minY`
	`90`	`+ return parentHeight - 18`
`86`	`91`	`}`
`87`	`92`
`88`	`93`	`func setPanGestureTarget(_ target: Any, action: Selector) {`