Merge pull request #6 from inloop/feature/add-third-position

Optional middle position

Author: Vilém Kurz

Example/UIViewController-DisplayInDrawer/ContentViewController.swift

@@ -68,21 +68,26 @@ class ContentViewController: UIViewController {
 }
 
 extension ContentViewController: DrawerConfiguration {
-    func topPositionY(in parentFrame: CGRect) -> CGFloat {
+    func topPositionY(for parentHeight: CGFloat) -> CGFloat {
         guard isViewLoaded else { return 0 }
         /*
          You can return constant, but this is a more dynamic example:
          How to avoid making the drawer unneccessarily larger than its content
          */
         let minimalTopPosition: CGFloat = 50
-        let idealTopPosition = parentFrame.height - contentDerivedHeight()
+        let idealTopPosition = parentHeight - contentDerivedHeight()
         let result = fmax(minimalTopPosition, idealTopPosition)
         return result
     }
 
-    var bottomPositionHeight: CGFloat {
+    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 separatorView.frame.minY
+        return parentHeight - 18
     }
 
     func setPanGestureTarget(_ target: Any, action: Selector) {

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")
+    }
+}

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,9 +25,9 @@ final class PanGestureTarget {
     private weak var drawerConfiguration: DrawerConfiguration?
     private weak var drawerPositionDelegate: DrawerPositionDelegate?
     private var initialDrawerCenterLocation: CGPoint = .zero
-    private var bottomPositionHeight: CGFloat!
-    var basePositionY: CGFloat { return canvasView.frame.height - bottomPositionHeight }
     var topPositionY: CGFloat!
+    var middlePositionY: CGFloat?
+    var bottomPositionY: CGFloat!
 
     init(canvasView: UIView,
          drawerContainerView: UIView,
@@ -42,8 +43,9 @@ final class PanGestureTarget {
     }
 
     internal func refreshDrawerPositions() {
-        bottomPositionHeight = drawerConfiguration?.bottomPositionHeight ?? 0
-        topPositionY = drawerConfiguration?.topPositionY(in: canvasView.bounds) ?? 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 {
@@ -57,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) {
@@ -85,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 {
@@ -104,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) {
@@ -136,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()
             }
@@ -159,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)
+    }
 }

UIViewController-DisplayInDrawer/Classes/UIViewController+PresentDrawerController.swift

@@ -3,8 +3,10 @@
 import UIKit
 
 public protocol DrawerConfiguration: class {
-    func topPositionY(in parentFrame: CGRect) -> CGFloat
-    var bottomPositionHeight: CGFloat { get }
+    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.
      You should not change it, and you should call it when user presses dismiss button in your content view controller.
@@ -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,17 +99,39 @@ 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)
-            if isOnOldTopPosition && newTopPositionIsDifferentThanOld {
-                self?.updateWithNewYPosition(panGestureTarget.topPositionY,
-                                             containerView: strongContainerView,
-                                             inFlightAnimator: initialDisplayAnimator
+            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?.updateWithNewYPosition(panGestureTarget.basePositionY,
-                                             containerView: strongContainerView,
-                                             inFlightAnimator: initialDisplayAnimator
+                self?.updateDrawerPosition(
+                    inFlightAnimator: initialDisplayAnimator,
+                    newTargetY: panGestureTarget.bottomPositionY,
+                    containerView: strongContainerView
                 )
             }
         }
@@ -122,10 +148,10 @@ extension UIViewController {
         controller.didMove(toParentViewController: self)
     }
 
-    private func updateWithNewYPosition(_ newY: CGFloat, containerView: UIView, inFlightAnimator: UIViewPropertyAnimator?) {
+    private func updateDrawerPosition(inFlightAnimator: UIViewPropertyAnimator?, newTargetY: CGFloat, containerView: UIView) {
         dLog("inFlightAnimator: \(String(describing: inFlightAnimator))")
         var newFrame = containerView.frame
-        newFrame.origin.y = newY
+        newFrame.origin.y = newTargetY
         if let animator = inFlightAnimator {
             animator.addAnimations { containerView.frame = newFrame }
         } else {
@@ -137,7 +163,7 @@ extension UIViewController {
                                             containerView: UIView,
                                             positionDelegate: DrawerPositionDelegate?) -> UIViewPropertyAnimator {
         var endFrame = containerView.frame
-        endFrame.origin.y = view.bounds.height - drawerConfiguration.bottomPositionHeight
+        endFrame.origin.y = drawerConfiguration.bottomPositionY(for: view.bounds.height)
         let animator = UIViewPropertyAnimator(duration: 0.25, curve: .easeInOut, animations: {
             containerView.frame = endFrame
         })
@@ -184,7 +210,7 @@ extension UIViewController {
 private extension UIView {
     func addContainerView(for drawerConfiguration: DrawerConfiguration, cornerRadius: CGFloat, bottomPaddingHeight: CGFloat) -> UIView {
         var startFrame = bounds
-        startFrame.size.height = bounds.height - drawerConfiguration.topPositionY(in: bounds) + bottomPaddingHeight
+        startFrame.size.height = bounds.height - drawerConfiguration.topPositionY(for: bounds.height) + bottomPaddingHeight
         startFrame.origin.y += bounds.height
         /*
          OutsideBoundsHittableView is used here so that we capture taps on dimmed background.