Release v1.4.0

Improve the operability

Examples/Samples/Sources/ViewController.swift

@@ -726,10 +726,24 @@ class ModalSecondLayout: FloatingPanelLayout {
 
 class TabBarViewController: UITabBarController {}
 
-class TabBarContentViewController: UIViewController, FloatingPanelControllerDelegate {
+class TabBarContentViewController: UIViewController {
+    enum Tab3Mode {
+        case changeOffset
+        case changeAutoLayout
+        var label: String {
+            switch self {
+            case .changeAutoLayout: return "Use AutoLayout(OK)"
+            case .changeOffset: return "Use ContentOffset(NG)"
+            }
+        }
+    }
     var fpc: FloatingPanelController!
     var consoleVC: DebugTextViewController!
 
+    var threeLayout: ThreeTabBarPanelLayout!
+    var tab3Mode: Tab3Mode = .changeAutoLayout
+    var switcherLabel: UILabel!
+
     override func viewWillAppear(_ animated: Bool) {
         super.viewWillAppear(animated)
         // Initialize FloatingPanelController
@@ -743,11 +757,47 @@ class TabBarContentViewController: UIViewController, FloatingPanelControllerDele
         // Set a content view controller and track the scroll view
         let consoleVC = storyboard?.instantiateViewController(withIdentifier: "ConsoleViewController") as! DebugTextViewController
         fpc.set(contentViewController: consoleVC)
+        consoleVC.textView.delegate = self // MUST call it before fpc.track(scrollView:)
         fpc.track(scrollView: consoleVC.textView)
         self.consoleVC = consoleVC
 
         //  Add FloatingPanel to self.view
         fpc.addPanel(toParent: self)
+
+
+        if tabBarItem.tag == 2 {
+            let switcher = UISwitch()
+            fpc.view.addSubview(switcher)
+            switcher.translatesAutoresizingMaskIntoConstraints = false
+            NSLayoutConstraint.activate([
+                switcher.bottomAnchor.constraint(equalTo: fpc.surfaceView.topAnchor, constant: -16.0),
+                switcher.rightAnchor.constraint(equalTo: fpc.surfaceView.rightAnchor, constant: -16.0),
+                ])
+            switcher.isOn = true
+            switcher.tintColor = .white
+            switcher.backgroundColor = .white
+            switcher.layer.cornerRadius = 16.0
+            switcher.addTarget(self,
+                               action: #selector(changeTab3Mode(_:)),
+                               for: .valueChanged)
+            let label = UILabel()
+            label.text = tab3Mode.label
+            fpc.view.addSubview(label)
+            switcherLabel = label
+            label.translatesAutoresizingMaskIntoConstraints = false
+            NSLayoutConstraint.activate([
+                label.centerYAnchor.constraint(equalTo: switcher.centerYAnchor, constant: 0.0),
+                label.rightAnchor.constraint(equalTo: switcher.leftAnchor, constant: -16.0),
+                ])
+
+            // Turn off the mask instead of content inset change
+            consoleVC.textView.clipsToBounds = false
+        }
+    }
+
+    override func viewDidAppear(_ animated: Bool) {
+        super.viewDidAppear(animated)
+        fpc.updateLayout()
     }
 
     override func viewWillDisappear(_ animated: Bool) {
@@ -756,6 +806,34 @@ class TabBarContentViewController: UIViewController, FloatingPanelControllerDele
         fpc.removePanelFromParent(animated: false)
     }
 
+    // MARK: - Action
+
+    @IBAction func close(sender: UIButton) {
+        dismiss(animated: true, completion: nil)
+    }
+
+    // MAKR: - Private
+
+    @objc
+    private func changeTab3Mode(_ sender: UISwitch) {
+        if sender.isOn {
+            tab3Mode = .changeAutoLayout
+        } else {
+            tab3Mode = .changeOffset
+        }
+        switcherLabel.text = tab3Mode.label
+    }
+}
+
+extension TabBarContentViewController: UITextViewDelegate {
+    func scrollViewDidScroll(_ scrollView: UIScrollView) {
+        guard self.tabBarItem.tag == 2 else { return }
+    }
+}
+
+extension TabBarContentViewController: FloatingPanelControllerDelegate {
+    // MARK: - FloatingPanel
+
     func floatingPanel(_ vc: FloatingPanelController, layoutFor newCollection: UITraitCollection) -> FloatingPanelLayout? {
         switch self.tabBarItem.tag {
         case 0:
@@ -763,7 +841,8 @@ class TabBarContentViewController: UIViewController, FloatingPanelControllerDele
         case 1:
             return TwoTabBarPanelLayout()
         case 2:
-            return ThreeTabBarPanelLayout()
+            threeLayout = ThreeTabBarPanelLayout(parent: self)
+            return threeLayout
         default:
             return nil
         }
@@ -772,51 +851,80 @@ class TabBarContentViewController: UIViewController, FloatingPanelControllerDele
     func floatingPanelDidMove(_ vc: FloatingPanelController) {
         guard self.tabBarItem.tag == 2 else { return }
 
-        /* Solution 1: Manipulate scoll content inset */
-        /*
-        guard let scrollView = consoleVC.textView else { return }
-        var insets = vc.adjustedContentInsets
-        if vc.surfaceView.frame.minY < vc.layoutInsets.top {
-            insets.top = vc.layoutInsets.top - vc.surfaceView.frame.minY
-        } else {
-            insets.top = 0.0
-        }
-        scrollView.contentInset = insets
-         */
+        switch tab3Mode {
+        case .changeAutoLayout:
+            /* Good solution: Manipulate top constraint */
+            assert(consoleVC.textViewTopConstraint != nil)
+            if vc.surfaceView.frame.minY + threeLayout.topPadding < vc.layoutInsets.top {
+                consoleVC.textViewTopConstraint?.constant = vc.layoutInsets.top - vc.surfaceView.frame.minY
+            } else {
+                consoleVC.textViewTopConstraint?.constant = threeLayout.topPadding
+            }
+        case .changeOffset:
+            /*
+             Bad solution: Manipulate scoll content inset
 
-        // Solution 2: Manipulate top constraint
-        assert(consoleVC.textViewTopConstraint != nil)
-        if vc.surfaceView.frame.minY + 17.0 < vc.layoutInsets.top {
-            consoleVC.textViewTopConstraint?.constant = vc.layoutInsets.top - vc.surfaceView.frame.minY
-        } else {
-            consoleVC.textViewTopConstraint?.constant = 17.0
+             FloatingPanelController keeps a content offset in moving a panel
+             so that changing content inset or offset causes a buggy behavior.
+             */
+            guard let scrollView = consoleVC.textView else { return }
+            var insets = vc.adjustedContentInsets
+            if vc.surfaceView.frame.minY < vc.layoutInsets.top {
+                insets.top = vc.layoutInsets.top - vc.surfaceView.frame.minY
+            } else {
+                insets.top = 0.0
+            }
+            scrollView.contentInset = insets
+
+            if vc.surfaceView.frame.minY > 0 {
+                scrollView.contentOffset = CGPoint(x: 0.0,
+                                                   y: 0.0 - scrollView.contentInset.top)
+            }
         }
-        consoleVC.view.layoutIfNeeded()
+
+        if vc.surfaceView.frame.minY > vc.originYOfSurface(for: .half) {
+            let progress = (vc.surfaceView.frame.minY - vc.originYOfSurface(for: .half)) / (vc.originYOfSurface(for: .tip) - vc.originYOfSurface(for: .half))
+            threeLayout.leftConstraint.constant = max(min(progress, 1.0), 0.0) * threeLayout.sideMargin
+            threeLayout.rightConstraint.constant = -max(min(progress, 1.0), 0.0) * threeLayout.sideMargin
+        } else {
+            threeLayout.leftConstraint.constant = 0.0
+            threeLayout.rightConstraint.constant = 0.0
+        }
+
+        vc.view.layoutIfNeeded() // MUST
     }
 
     func floatingPanelDidChangePosition(_ vc: FloatingPanelController) {
         guard self.tabBarItem.tag == 2 else { return }
 
-        /* Solution 1: Manipulate scoll content inset */
-        /*
-        guard let scrollView = consoleVC.textView else { return }
-        var insets = vc.adjustedContentInsets
-        insets.top = (vc.position == .full) ? vc.layoutInsets.top : 0.0
-        scrollView.contentInset = insets
-        if scrollView.contentOffset.y - scrollView.contentInset.top < 0.0  {
-            scrollView.contentOffset = CGPoint(x: 0.0,
-                                               y: 0.0 - scrollView.contentInset.top)
+        switch tab3Mode {
+        case .changeAutoLayout:
+            /* Good Solution: Manipulate top constraint */
+            assert(consoleVC.textViewTopConstraint != nil)
+            consoleVC.textViewTopConstraint?.constant = (vc.position == .full) ? vc.layoutInsets.top : 17.0
+
+        case .changeOffset:
+            /* Bad Solution: Manipulate scoll content inset */
+            guard let scrollView = consoleVC.textView else { return }
+            var insets = vc.adjustedContentInsets
+            insets.top = (vc.position == .full) ? vc.layoutInsets.top : 0.0
+            scrollView.contentInset = insets
+            if scrollView.contentOffset.y - scrollView.contentInset.top < 0.0  {
+                scrollView.contentOffset = CGPoint(x: 0.0,
+                                                   y: 0.0 - scrollView.contentInset.top)
+            }
         }
-         */
 
-        // Solution 2: Manipulate top constraint
-        assert(consoleVC.textViewTopConstraint != nil)
-        consoleVC.textViewTopConstraint?.constant = (vc.position == .full) ? vc.layoutInsets.top : 17.0
-        consoleVC.view.layoutIfNeeded()
-    }
-
-    @IBAction func close(sender: UIButton) {
-        dismiss(animated: true, completion: nil)
+        if vc.position == .tip {
+            threeLayout.leftConstraint.constant = threeLayout.sideMargin
+            threeLayout.rightConstraint.constant = -threeLayout.sideMargin
+        } else {
+            threeLayout.leftConstraint.constant = 0.0
+            threeLayout.rightConstraint.constant = 0.0
+        }
+        // Can call it, but it's not necessary because it will be also called
+        // by FloatingPanelController after the delegate method
+        vc.view.layoutIfNeeded()
     }
 }
 
@@ -874,22 +982,47 @@ class TwoTabBarPanelLayout: FloatingPanelLayout {
 }
 
 class ThreeTabBarPanelLayout: FloatingPanelFullScreenLayout {
+    weak var parentVC: UIViewController!
+
+    var leftConstraint: NSLayoutConstraint!
+    var rightConstraint: NSLayoutConstraint!
+
+    let topPadding: CGFloat = 17.0
+    let sideMargin: CGFloat = 16.0
+
+    init(parent: UIViewController) {
+        parentVC = parent
+    }
+
+    var bottomInteractionBuffer: CGFloat = 44.0
+
     var initialPosition: FloatingPanelPosition {
         return .half
     }
     var supportedPositions: Set<FloatingPanelPosition> {
-        return [.full, .half]
+        return [.full, .half, .tip]
     }
     func insetFor(position: FloatingPanelPosition) -> CGFloat? {
         switch position {
         case .full: return 0.0
-        case .half: return 261.0
+        case .half: return 261.0 + parentVC.layoutInsets.bottom
+        case .tip: return 88.0 + parentVC.layoutInsets.bottom
         default: return nil
         }
     }
     func backdropAlphaFor(position: FloatingPanelPosition) -> CGFloat {
         return 0.3
     }
+    func prepareLayout(surfaceView: UIView, in view: UIView) -> [NSLayoutConstraint] {
+        if #available(iOS 11.0, *) {
+            leftConstraint = surfaceView.leftAnchor.constraint(equalTo: view.safeAreaLayoutGuide.leftAnchor, constant: 0.0)
+            rightConstraint = surfaceView.rightAnchor.constraint(equalTo: view.safeAreaLayoutGuide.rightAnchor, constant: 0.0)
+        } else {
+            leftConstraint = surfaceView.leftAnchor.constraint(equalTo: view.leftAnchor, constant: 0.0)
+            rightConstraint = surfaceView.rightAnchor.constraint(equalTo: view.rightAnchor, constant: 0.0)
+        }
+        return [ leftConstraint, rightConstraint ]
+    }
 }
 
 class SettingsViewController: InspectableViewController {

FloatingPanel.podspec

@@ -1,7 +1,7 @@
 Pod::Spec.new do |s|
 
   s.name                = "FloatingPanel"
-  s.version             = "1.3.5"
+  s.version             = "1.4.0"
   s.summary             = "FloatingPanel is a clean and easy-to-use UI component of a floating panel interface."
   s.description         = <<-DESC
 FloatingPanel is a clean and easy-to-use UI component for a new interface introduced in Apple Maps, Shortcuts and Stocks app.

Framework/Sources/FloatingPanel.swift

@@ -9,7 +9,7 @@ import UIKit.UIGestureRecognizerSubclass // For Xcode 9.4.1
 /// FloatingPanel presentation model
 ///
 class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate {
-    // MUST be a weak reference to prevent UI freeze on the presentaion modally
+    // MUST be a weak reference to prevent UI freeze on the presentation modally
     weak var viewcontroller: FloatingPanelController!
 
     let surfaceView: FloatingPanelSurfaceView
@@ -41,14 +41,15 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
 
     fileprivate var animator: UIViewPropertyAnimator?
     private var initialFrame: CGRect = .zero
-    private var initialScrollOffset: CGPoint = .zero
-    private var initialScrollInset: UIEdgeInsets = .zero
-    private var transOffsetY: CGFloat = 0
+    private var initialTranslationY: CGFloat = 0
+    private var initialLocation: CGPoint = .nan
 
     var interactionInProgress: Bool = false
     var isDecelerating: Bool = false
 
     // Scroll handling
+    private var initialScrollOffset: CGPoint = .zero
+    private var initialScrollFrame: CGRect = .zero
     private var stopScrollDeceleration: Bool = false
     private var scrollBouncable = false
     private var scrollIndictorVisible = false
@@ -93,6 +94,7 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
         if to != .full {
             lockScrollView()
         }
+        tearDownActiveInteraction()
 
         if animated {
             let animator: UIViewPropertyAnimator
@@ -108,8 +110,8 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
             animator.addAnimations { [weak self] in
                 guard let `self` = self else { return }
 
-                self.updateLayout(to: to)
                 self.state = to
+                self.updateLayout(to: to)
             }
             animator.addCompletion { [weak self] _ in
                 guard let `self` = self else { return }
@@ -119,8 +121,8 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
             self.animator = animator
             animator.startAnimation()
         } else {
-            self.updateLayout(to: to)
             self.state = to
+            self.updateLayout(to: to)
             completion?()
         }
     }
@@ -132,7 +134,7 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
     }
 
     private func getBackdropAlpha(with translation: CGPoint) -> CGFloat {
-        let currentY = getCurrentY(from: initialFrame, with: translation)
+        let currentY = surfaceView.frame.minY
 
         let next = directionalPosition(at: currentY, with: translation)
         let pre = redirectionalPosition(at: currentY, with: translation)
@@ -217,7 +219,7 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
             // Do not begin the pan gesture until these gestures fail
             return true
         default:
-            // Should begin the pan gesture witout waiting tap/long press gestures fail
+            // Should begin the pan gesture without waiting tap/long press gestures fail
             return false
         }
     }
@@ -231,33 +233,41 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
     }
 
     // MARK: - Gesture handling
-    private let offsetThreshold: CGFloat = 5.0 // Optimal value from testing
     @objc func handle(panGesture: UIPanGestureRecognizer) {
-        log.debug("Gesture >>>>", panGesture)
         let velocity = panGesture.velocity(in: panGesture.view)
 
         switch panGesture {
         case scrollView?.panGestureRecognizer:
             guard let scrollView = scrollView else { return }
 
-            log.debug("SrollPanGesture ScrollView.contentOffset >>>", scrollView.contentOffset.y, scrollView.contentSize, scrollView.bounds.size)
+            let location = panGesture.location(in: surfaceView)
 
-            // Prevent scoll slip by the top bounce when the scroll view's height is
-            // less than the content's height
-            if scrollView.isDecelerating == false, scrollView.contentSize.height > scrollView.bounds.height {
-                scrollView.bounces = (scrollView.contentOffset.y > offsetThreshold)
-            }
+            let belowTop = surfaceView.frame.minY > layoutAdapter.topY
 
-            if surfaceView.frame.minY > layoutAdapter.topY {
+            log.debug("scroll gesture(\(state):\(panGesture.state)) --",
+                "belowTop = \(belowTop),",
+                "interactionInProgress = \(interactionInProgress),",
+                "scroll offset = \(scrollView.contentOffset.y),",
+                "location = \(location.y), velocity = \(velocity.y)")
+
+            if belowTop {
+                // Scroll offset pinning
                 switch state {
                 case .full:
-                    let point = panGesture.location(in: surfaceView)
-                    if grabberAreaFrame.contains(point) {
-                        // Preserve the current content offset in moving from full.
-                        scrollView.contentOffset.y = initialScrollOffset.y
+                    if interactionInProgress {
+                        log.debug("settle offset --", initialScrollOffset.y)
+                        scrollView.setContentOffset(initialScrollOffset, animated: false)
                     } else {
-                        // Prevent over scrolling in moving from full.
-                        scrollView.contentOffset.y = scrollView.contentOffsetZero.y
+                        if grabberAreaFrame.contains(location) {
+                            // Preserve the current content offset in moving from full.
+                            scrollView.contentOffset.y = initialScrollOffset.y
+                        } else {
+                            if scrollView.contentOffset.y < 0 {
+                                fitToBounds(scrollView: scrollView)
+                                let translation = panGesture.translation(in: panGestureRecognizer.view!.superview)
+                                startInteraction(with: translation, at: location)
+                            }
+                        }
                     }
                 case .half, .tip:
                     guard scrollView.isDecelerating == false else {
@@ -267,9 +277,9 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
                         return
                     }
                     // Fix the scroll offset in moving the panel from half and tip.
-                    scrollView.contentOffset.y = initialScrollOffset.y + (initialScrollInset.top - scrollView.contentInset.top)
+                    scrollView.contentOffset.y = initialScrollOffset.y
                 case .hidden:
-                    fatalError("Now .hidden must not be used for a user interaction")
+                    break
                 }
 
                 // Always hide a scroll indicator at the non-top.
@@ -280,36 +290,52 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
                 // Always show a scroll indicator at the top.
                 if interactionInProgress {
                     unlockScrollView()
+                } else {
+                    if state == .full, scrollView.contentOffset.y < 0, velocity.y > 0 {
+                        fitToBounds(scrollView: scrollView)
+                        let translation = panGesture.translation(in: panGestureRecognizer.view!.superview)
+                        startInteraction(with: translation, at: location)
+                    }
                 }
             }
         case panGestureRecognizer:
-            let translation = panGesture.translation(in: panGesture.view!.superview)
+            let translation = panGesture.translation(in: panGestureRecognizer.view!.superview)
             let location = panGesture.location(in: panGesture.view)
 
-            log.debug(panGesture.state, ">>>", "translation: \(translation.y), velocity: \(velocity.y)")
+            log.debug("panel gesture(\(state):\(panGesture.state)) --",
+                "translation =  \(translation.y), location = \(location.y), velocity = \(velocity.y)")
+
+            if let animator = self.animator {
+                if animator.isInterruptible {
+                    animator.stopAnimation(false)
+                    animator.finishAnimation(at: .current)
+                }
+                self.animator = nil
+            }
+
+            if interactionInProgress == false,
+                viewcontroller.delegate?.floatingPanelShouldBeginDragging(viewcontroller) == false {
+                return
+            }
+
+            if panGesture.state == .began {
+                panningBegan(at: location)
+                return
+            }
 
             if shouldScrollViewHandleTouch(scrollView, point: location, velocity: velocity) {
                 return
             }
 
-            if let animator = self.animator {
-                if animator.isInterruptible {
-                    animator.stopAnimation(true)
-                }
-                self.animator = nil
-            }
-
             switch panGesture.state {
-            case .began:
-                panningBegan()
             case .changed:
                 if interactionInProgress == false {
-                    startInteraction(with: translation)
+                    startInteraction(with: translation, at: location)
                 }
                 panningChange(with: translation)
             case .ended, .cancelled, .failed:
                 panningEnd(with: translation, velocity: velocity)
-            case .possible:
+            default:
                 break
             }
         default:
@@ -335,17 +361,30 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
 
         guard
             state == .full,                   // When not .full, don't scroll.
-            interactionInProgress == false,   // When interaction already in progress, don't scroll.
-            scrollView.frame.contains(point), // When point not in scrollView, don't scroll.
-            !grabberAreaFrame.contains(point) // When point within grabber area, don't scroll.
+            interactionInProgress == false    // When interaction already in progress, don't scroll.
         else {
             return false
         }
 
-        log.debug("ScrollView.contentOffset >>>", scrollView.contentOffset.y)
+        // When the current and initial point within grabber area, do scroll.
+        if grabberAreaFrame.contains(point), !grabberAreaFrame.contains(initialLocation) {
+            return true
+        }
+
+        guard
+            scrollView.frame.contains(initialLocation), // When initialLocation not in scrollView, don't scroll.
+            !grabberAreaFrame.contains(point)           // When point within grabber area, don't scroll.
+        else {
+            return false
+        }
 
         let offset = scrollView.contentOffset.y - scrollView.contentOffsetZero.y
-        if  abs(offset) > offsetThreshold {
+        // 10 pt is introduced from my testing(there might be better one)
+        // It should be low as possible because a user scroll view frame will
+        // change as far as the specified value temporarily.
+        // The zero offset is an exception because the offset is usually zero
+        // when a panel moves from half or tip position to full.
+        if  offset > -10.0, offset != 0.0 {
             return true
         }
         if scrollView.isDecelerating {
@@ -358,42 +397,104 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
         return false
     }
 
-    private func panningBegan() {
+    private func panningBegan(at location: CGPoint) {
         // A user interaction does not always start from Began state of the pan gesture
         // because it can be recognized in scrolling a content in a content view controller.
-        // So do nothing here.
-        log.debug("panningBegan")
+        // So here just preserve the current state if needed.
+        log.debug("panningBegan -- location = \(location.y)")
+        initialLocation = location
+        switch state {
+        case .full:
+            if let scrollView = scrollView {
+                initialScrollFrame = scrollView.frame
+            }
+        default:
+            if let scrollView = scrollView {
+                initialScrollOffset = scrollView.contentOffset
+            }
+        }
     }
 
     private func panningChange(with translation: CGPoint) {
-        log.debug("panningChange")
+        log.debug("panningChange -- translation = \(translation.y)")
+        let pre = surfaceView.frame.minY
+        let dy = translation.y - initialTranslationY
 
-        let currentY = getCurrentY(from: initialFrame, with: translation)
+        layoutAdapter.updateInteractiveTopConstraint(diff: dy,
+                                                     allowsTopBuffer: allowsTopBuffer(for: dy))
 
-        var frame = initialFrame
-        frame.origin.y = currentY
-        surfaceView.frame = frame
         backdropView.alpha = getBackdropAlpha(with: translation)
+        preserveContentVCLayoutIfNeeded()
+
+        let didMove = (pre != surfaceView.frame.minY)
+        guard didMove else { return }
 
         viewcontroller.delegate?.floatingPanelDidMove(viewcontroller)
     }
 
-    private func panningEnd(with translation: CGPoint, velocity: CGPoint) {
-        log.debug("panningEnd")
+    private func allowsTopBuffer(for translationY: CGFloat) -> Bool {
+        let preY = surfaceView.frame.minY
+        let nextY = initialFrame.offsetBy(dx: 0.0, dy: translationY).minY
+        if let scrollView = scrollView, scrollView.panGestureRecognizer.state == .changed,
+            preY > 0 && preY > nextY {
+            return false
+        } else {
+            return true
+        }
+    }
 
-        guard state != .hidden else {
+    private var disabledBottomAutoLayout = false
+    // Prevent stretching a view having a constraint to SafeArea.bottom in an overflow
+    // from the full position because SafeArea is global in a screen.
+    private func preserveContentVCLayoutIfNeeded() {
+        // Must include topY
+        if (surfaceView.frame.minY <= layoutAdapter.topY) {
+            if !disabledBottomAutoLayout {
+                viewcontroller.contentViewController?.view?.constraints.forEach({ (const) in
+                    switch viewcontroller.contentViewController?.layoutGuide.bottomAnchor {
+                    case const.firstAnchor:
+                        (const.secondItem as? UIView)?.disableAutoLayout()
+                        const.isActive = false
+                    case const.secondAnchor:
+                        (const.firstItem as? UIView)?.disableAutoLayout()
+                        const.isActive = false
+                    default:
+                        break
+                    }
+                })
+            }
+            disabledBottomAutoLayout = true
+        } else {
+            if disabledBottomAutoLayout {
+                viewcontroller.contentViewController?.view?.constraints.forEach({ (const) in
+                    switch viewcontroller.contentViewController?.layoutGuide.bottomAnchor {
+                    case const.firstAnchor:
+                        (const.secondItem as? UIView)?.enableAutoLayout()
+                        const.isActive = true
+                    case const.secondAnchor:
+                        (const.firstItem as? UIView)?.enableAutoLayout()
+                        const.isActive = true
+                    default:
+                        break
+                    }
+                })
+            }
+            disabledBottomAutoLayout = false
+        }
+    }
+
+    private func panningEnd(with translation: CGPoint, velocity: CGPoint) {
+        log.debug("panningEnd -- translation = \(translation.y), velocity = \(velocity.y)")
+
+        if state == .hidden {
             log.debug("Already hidden")
             return
         }
 
-        if interactionInProgress == false {
-            initialFrame = surfaceView.frame
-        }
-
         stopScrollDeceleration = (surfaceView.frame.minY > layoutAdapter.topY) // Projecting the dragging to the scroll dragging or not
 
-        let targetPosition = self.targetPosition(with: translation, velocity: velocity)
-        let distance = self.distance(to: targetPosition, with: translation)
+        let targetPosition = self.targetPosition(with: velocity)
+        let distance = self.distance(to: targetPosition)
 
         endInteraction(for: targetPosition)
 
@@ -401,9 +502,7 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
             let velocityVector = (distance != 0) ? CGVector(dx: 0,
                                                             dy: min(fabs(velocity.y)/distance, behavior.removalVelocity)) : .zero
 
-
-
-            if shouldStartRemovalAnimation(with: translation, velocityVector: velocityVector) {
+            if shouldStartRemovalAnimation(with: velocityVector) {
 
                 viewcontroller.delegate?.floatingPanelDidEndDraggingToRemove(viewcontroller, withVelocity: velocity)
                 self.startRemovalAnimation(with: velocityVector) { [weak self] in
@@ -418,20 +517,19 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
         }
 
         viewcontroller.delegate?.floatingPanelDidEndDragging(viewcontroller, withVelocity: velocity, targetPosition: targetPosition)
-        viewcontroller.delegate?.floatingPanelWillBeginDecelerating(viewcontroller)
 
         startAnimation(to: targetPosition, at: distance, with: velocity)
     }
 
-    private func shouldStartRemovalAnimation(with translation: CGPoint, velocityVector: CGVector) -> Bool {
+    private func shouldStartRemovalAnimation(with velocityVector: CGVector) -> Bool {
         let posY = layoutAdapter.positionY(for: state)
-        let currentY = getCurrentY(from: initialFrame, with: translation)
-        let safeAreaBottomY = layoutAdapter.safeAreaBottomY
+        let currentY = surfaceView.frame.minY
+        let bottomMaxY = layoutAdapter.bottomMaxY
         let vth = behavior.removalVelocity
         let pth = max(min(behavior.removalProgress, 1.0), 0.0)
 
         let num = (currentY - posY)
-        let den = (safeAreaBottomY - posY)
+        let den = (bottomMaxY - posY)
 
         guard num >= 0, den != 0, (num / den >= pth || velocityVector.dy == vth)
         else { return false }
@@ -453,108 +551,69 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
         animator.startAnimation()
     }
 
-    private func startInteraction(with translation: CGPoint) {
+    private func startInteraction(with translation: CGPoint, at location: CGPoint) {
         /* Don't lock a scroll view to show a scroll indicator after hitting the top */
-        log.debug("startInteraction")
+        log.debug("startInteraction  -- translation = \(translation.y), location = \(location.y)")
+        guard interactionInProgress == false else { return }
+
         initialFrame = surfaceView.frame
-        if let scrollView = scrollView {
-            initialScrollOffset = scrollView.contentOffset
-            initialScrollInset = scrollView.contentInset
+        if state == .full, let scrollView = scrollView {
+            if grabberAreaFrame.contains(location) {
+                initialScrollOffset = scrollView.contentOffset
+            } else {
+                settle(scrollView: scrollView)
+                initialScrollOffset = scrollView.contentOffsetZero
+            }
+            log.debug("initial scroll offset --", initialScrollOffset)
         }
-        transOffsetY = translation.y
+
+        initialTranslationY = translation.y
 
         viewcontroller.delegate?.floatingPanelWillBeginDragging(viewcontroller)
 
-        if state == .full {
-            viewcontroller.contentViewController?.view?.constraints.forEach({ (const) in
-                switch viewcontroller.contentViewController?.layoutGuide.bottomAnchor {
-                case const.firstAnchor:
-                    (const.secondItem as? UIView)?.disableAutoLayout()
-                    const.isActive = false
-                case const.secondAnchor:
-                    (const.firstItem as? UIView)?.disableAutoLayout()
-                    const.isActive = false
-                default:
-                    break
-                }
-            })
-        }
+        layoutAdapter.startInteraction(at: state)
 
         interactionInProgress = true
     }
 
     private func endInteraction(for targetPosition: FloatingPanelPosition) {
-        log.debug("endInteraction for \(targetPosition)")
+        log.debug("endInteraction to \(targetPosition)")
+
+        if let scrollView = scrollView {
+            log.debug("endInteraction -- scroll offset = \(scrollView.contentOffset)")
+        }
+
         interactionInProgress = false
 
-        // Prevent to keep a scoll view indicator visible at the half/tip position
+        // Prevent to keep a scroll view indicator visible at the half/tip position
         if targetPosition != .full {
             lockScrollView()
         }
 
-        if state == .full {
-            viewcontroller.contentViewController?.view?.constraints.forEach({ (const) in
-                switch viewcontroller.contentViewController?.layoutGuide.bottomAnchor {
-                case const.firstAnchor:
-                    (const.secondItem as? UIView)?.enableAutoLayout()
-                    const.isActive = true
-                case const.secondAnchor:
-                    (const.firstItem as? UIView)?.enableAutoLayout()
-                    const.isActive = true
-                default:
-                    break
-                }
-            })
-        }
+        layoutAdapter.endInteraction(at: targetPosition)
     }
 
-    private func getCurrentY(from rect: CGRect, with translation: CGPoint) -> CGFloat {
-        let dy = translation.y - transOffsetY
-        let y = rect.offsetBy(dx: 0.0, dy: dy).origin.y
-
-        let topY = layoutAdapter.topY
-        let topBuffer = layoutAdapter.layout.topInteractionBuffer
-        let bottomY = layoutAdapter.bottomY
-        let bottomBuffer = layoutAdapter.layout.bottomInteractionBuffer
-        let topMax = layoutAdapter.topMaxY
-        let bottomMax = layoutAdapter.bottomMaxY
-        
-        if let scrollView = scrollView, scrollView.panGestureRecognizer.state == .changed {
-            let preY = surfaceView.frame.origin.y
-            if preY > 0 && preY > y {
-                return max(max(topY, topMax), min(min(bottomY + bottomBuffer, bottomMax), y))
-            }
-        }
-        return max(max(topY - topBuffer, topMax), min(min(bottomY + bottomBuffer, bottomMax), y))
+    private func tearDownActiveInteraction() {
+        // Cancel the pan gesture so that panningEnd(with:velocity:) is called
+        panGestureRecognizer.isEnabled = false
+        panGestureRecognizer.isEnabled = true
     }
 
     private func startAnimation(to targetPosition: FloatingPanelPosition, at distance: CGFloat, with velocity: CGPoint) {
-        log.debug("startAnimation", targetPosition, distance, velocity)
-        let targetY = layoutAdapter.positionY(for: targetPosition)
+        log.debug("startAnimation to \(targetPosition) -- distance = \(distance), velocity = \(velocity.y)")
 
         isDecelerating = true
+        viewcontroller.delegate?.floatingPanelWillBeginDecelerating(viewcontroller)
 
         let velocityVector = (distance != 0) ? CGVector(dx: 0, dy: min(fabs(velocity.y)/distance, 30.0)) : .zero
         let animator = behavior.interactionAnimator(self.viewcontroller, to: targetPosition, with: velocityVector)
         animator.addAnimations { [weak self] in
             guard let `self` = self else { return }
-            if self.state == targetPosition {
-                self.surfaceView.frame.origin.y = targetY
-                self.layoutAdapter.setBackdropAlpha(of: targetPosition)
-            } else {
-                self.updateLayout(to: targetPosition)
-            }
             self.state = targetPosition
+            self.updateLayout(to: targetPosition)
         }
         animator.addCompletion { [weak self] pos in
             guard let `self` = self else { return }
-            self.isDecelerating = false
-            guard
-                self.interactionInProgress == false,
-                animator == self.animator,
-                pos == .end
-                else { return }
-            self.animator = nil
             self.finishAnimation(at: targetPosition)
         }
         self.animator = animator
@@ -562,9 +621,16 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
     }
 
     private func finishAnimation(at targetPosition: FloatingPanelPosition) {
-        log.debug("finishAnimation \(targetPosition)")
+        log.debug("finishAnimation to \(targetPosition)")
+        self.isDecelerating = false
+        self.animator = nil
+
         self.viewcontroller.delegate?.floatingPanelDidEndDecelerating(self.viewcontroller)
 
+        if let scrollView = scrollView {
+            log.debug("finishAnimation -- scroll offset = \(scrollView.contentOffset)")
+        }
+
         stopScrollDeceleration = false
         // Don't unlock scroll view in animating view when presentation layer != model layer
         if targetPosition == .full {
@@ -572,11 +638,11 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
         }
     }
 
-    private func distance(to targetPosition: FloatingPanelPosition, with translation: CGPoint) -> CGFloat {
+    private func distance(to targetPosition: FloatingPanelPosition) -> CGFloat {
         let topY = layoutAdapter.topY
         let middleY = layoutAdapter.middleY
         let bottomY = layoutAdapter.bottomY
-        let currentY = getCurrentY(from: initialFrame, with: translation)
+        let currentY = surfaceView.frame.minY
 
         switch targetPosition {
         case .full:
@@ -623,13 +689,12 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
 
     // Distance travelled after decelerating to zero velocity at a constant rate.
     // Refer to the slides p176 of [Designing Fluid Interfaces](https://developer.apple.com/videos/play/wwdc2018/803/)
-    private func project(initialVelocity: CGFloat) -> CGFloat {
-        let decelerationRate = UIScrollViewDecelerationRateNormal
+    private func project(initialVelocity: CGFloat, decelerationRate: CGFloat = UIScrollViewDecelerationRateNormal) -> CGFloat {
         return (initialVelocity / 1000.0) * decelerationRate / (1.0 - decelerationRate)
     }
 
-    private func targetPosition(with translation: CGPoint, velocity: CGPoint) -> (FloatingPanelPosition) {
-        let currentY = getCurrentY(from: initialFrame, with: translation)
+    private func targetPosition(with velocity: CGPoint) -> (FloatingPanelPosition) {
+        let currentY = surfaceView.frame.minY
         let supportedPositions = layoutAdapter.supportedPositions
 
         if supportedPositions.count == 1 {
@@ -684,30 +749,56 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
                 th2 = bottomY - (bottomY - middleY) * redirectionalProgress
             }
 
+            let decelerationRate = behavior.momentumProjectionRate(viewcontroller)
+
+            let baseY = abs(bottomY - topY)
+            let vecY = velocity.y / baseY
+            let pY = project(initialVelocity: vecY, decelerationRate: decelerationRate) * baseY + currentY
+
             switch currentY {
             case ..<th1:
-                if project(initialVelocity: velocity.y) >= (middleY - currentY) {
+                switch pY {
+                case bottomY...:
+                    return behavior.shouldProjectMomentum(viewcontroller, for: .tip) ? .tip : .half
+                case middleY...:
                     return .half
-                } else {
+                case topY...:
+                    return .full
+                default:
                     return .full
                 }
             case ...middleY:
-                if project(initialVelocity: velocity.y) <= (topY - currentY) {
-                    return .full
-                } else {
+                switch pY {
+                case bottomY...:
+                    return behavior.shouldProjectMomentum(viewcontroller, for: .tip) ? .tip : .half
+                case middleY...:
                     return .half
+                case topY...:
+                    return .half
+                default:
+                    return .full
                 }
             case ..<th2:
-                if project(initialVelocity: velocity.y) >= (bottomY - currentY) {
+                switch pY {
+                case bottomY...:
                     return .tip
-                } else {
+                case middleY...:
                     return .half
+                case topY...:
+                    return .half
+                default:
+                    return behavior.shouldProjectMomentum(viewcontroller, for: .full) ? .full : .half
                 }
             default:
-                if project(initialVelocity: velocity.y) <= (middleY - currentY) {
-                    return .half
-                } else {
+                switch pY {
+                case bottomY...:
                     return .tip
+                case middleY...:
+                    return .tip
+                case topY...:
+                    return .half
+                default:
+                    return behavior.shouldProjectMomentum(viewcontroller, for: .full) ? .full : .half
                 }
             }
         }
@@ -727,15 +818,18 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
 
         let th = topY + (bottomY - topY) * redirectionalProgress
 
+        let decelerationRate = behavior.momentumProjectionRate(viewcontroller)
+        let pY = project(initialVelocity: velocity.y, decelerationRate: decelerationRate) + currentY
+
         switch currentY {
         case ..<th:
-            if project(initialVelocity: velocity.y) >= (bottomY - currentY) {
+            if pY >= bottomY {
                 return bottom
             } else {
                 return top
             }
         default:
-            if project(initialVelocity: velocity.y) <= (topY - currentY) {
+            if pY <= topY {
                 return top
             } else {
                 return bottom
@@ -761,6 +855,28 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
         scrollView.showsVerticalScrollIndicator = scrollIndictorVisible
     }
 
+    private func fitToBounds(scrollView: UIScrollView) {
+        log.debug("fit scroll view to bounds -- scroll offset =", scrollView.contentOffset.y)
+
+        surfaceView.frame.origin.y = layoutAdapter.topY - scrollView.contentOffset.y
+        scrollView.transform = CGAffineTransform.identity.translatedBy(x: 0.0,
+                                                                       y: scrollView.contentOffset.y)
+        scrollView.scrollIndicatorInsets = UIEdgeInsets(top: -scrollView.contentOffset.y,
+                                                        left: 0.0,
+                                                        bottom: 0.0,
+                                                        right: 0.0)
+    }
+
+    private func settle(scrollView: UIScrollView) {
+        log.debug("settle scroll view")
+
+        surfaceView.transform = .identity
+        scrollView.transform = .identity
+        scrollView.frame = initialScrollFrame
+        scrollView.contentOffset = scrollView.contentOffsetZero
+        scrollView.scrollIndicatorInsets = .zero
+    }
+
 
     // MARK: - UIScrollViewDelegate Intermediation
     override func responds(to aSelector: Selector!) -> Bool {
@@ -775,13 +891,6 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate, UIScrollViewDelegate
         }
     }
 
-    func scrollViewDidEndScrollingAnimation(_ scrollView: UIScrollView) {
-        if state != .full {
-            initialScrollOffset = scrollView.contentOffset
-        }
-        userScrollViewDelegate?.scrollViewDidEndScrollingAnimation?(scrollView)
-    }
-
     func scrollViewWillEndDragging(_ scrollView: UIScrollView, withVelocity velocity: CGPoint, targetContentOffset: UnsafeMutablePointer<CGPoint>) {
         if stopScrollDeceleration {
             targetContentOffset.pointee = scrollView.contentOffset

Framework/Sources/FloatingPanelBehavior.swift

@@ -6,7 +6,18 @@
 import UIKit
 
 public protocol FloatingPanelBehavior {
-    /// Returns the progress to redirect to the previous position
+    /// Asks the behavior object if the floating panel should project a momentum of a user interaction to move the proposed position.
+    ///
+    /// The default implementation of this method returns true. This method is called for a layout to support all positions(tip, half and full).
+    /// Therfore, `proposedTargetPosition` can only be `FloatingPanelPosition.tip` or `FloatingPanelPosition.full`.
+    func shouldProjectMomentum(_ fpc: FloatingPanelController, for proposedTargetPosition: FloatingPanelPosition) -> Bool
+
+    /// Returns a deceleration rate to calculate a target position projected a dragging momentum.
+    ///
+    /// The default implementation of this method returns the normal deceleration rate of UIScrollView.
+    func momentumProjectionRate(_ fpc: FloatingPanelController) -> CGFloat
+
+    /// Returns the progress to redirect to the previous position.
     ///
     /// The progress is represented by a floating-point value between 0.0 and 1.0, inclusive, where 1.0 indicates the floating panel is impossible to move to the next posiiton. The default value is 0.5. Values less than 0.0 and greater than 1.0 are pinned to those limits.
     func redirectionalProgress(_ fpc: FloatingPanelController, from: FloatingPanelPosition, to: FloatingPanelPosition) -> CGFloat
@@ -49,10 +60,29 @@ public protocol FloatingPanelBehavior {
 }
 
 public extension FloatingPanelBehavior {
+    func shouldProjectMomentum(_ fpc: FloatingPanelController, for proposedTargetPosition: FloatingPanelPosition) -> Bool {
+        switch (fpc.position, proposedTargetPosition) {
+        case (.full, .tip):
+            return false
+        case (.tip,  .full):
+            return false
+        default:
+            return true
+        }
+    }
+
+    func momentumProjectionRate(_ fpc: FloatingPanelController) -> CGFloat {
+        return UIScrollViewDecelerationRateNormal
+    }
+
     func redirectionalProgress(_ fpc: FloatingPanelController, from: FloatingPanelPosition, to: FloatingPanelPosition) -> CGFloat {
         return 0.5
     }
 
+    public func interactionAnimator(_ fpc: FloatingPanelController, to targetPosition: FloatingPanelPosition, with velocity: CGVector) -> UIViewPropertyAnimator {
+        return defaultBehavior.interactionAnimator(fpc, to: targetPosition, with: velocity)
+    }
+
     func addAnimator(_ fpc: FloatingPanelController, to: FloatingPanelPosition) -> UIViewPropertyAnimator {
         return UIViewPropertyAnimator(duration: 0.25, curve: .easeInOut)
     }
@@ -82,8 +112,12 @@ public extension FloatingPanelBehavior {
     }
 }
 
-class FloatingPanelDefaultBehavior: FloatingPanelBehavior {
-    func interactionAnimator(_ fpc: FloatingPanelController, to targetPosition: FloatingPanelPosition, with velocity: CGVector) -> UIViewPropertyAnimator {
+private let defaultBehavior = FloatingPanelDefaultBehavior()
+
+public class FloatingPanelDefaultBehavior: FloatingPanelBehavior {
+    public init() { }
+
+    public func interactionAnimator(_ fpc: FloatingPanelController, to targetPosition: FloatingPanelPosition, with velocity: CGVector) -> UIViewPropertyAnimator {
         let timing = timeingCurve(with: velocity)
         let animator = UIViewPropertyAnimator(duration: 0, timingParameters: timing)
         animator.isInterruptible = false

Framework/Sources/FloatingPanelController.swift

@@ -14,7 +14,10 @@ public protocol FloatingPanelControllerDelegate: class {
 
     func floatingPanelDidChangePosition(_ vc: FloatingPanelController) // changed the settled position in the model layer
 
-    func floatingPanelDidMove(_ vc: FloatingPanelController) // any offset changes
+    /// Asks the delegate if dragging should begin by the pan gesture recognizer.
+    func floatingPanelShouldBeginDragging(_ vc: FloatingPanelController) -> Bool
+
+    func floatingPanelDidMove(_ vc: FloatingPanelController) // any surface frame changes in dragging
 
     // called on start of dragging (may require some time and or distance to move)
     func floatingPanelWillBeginDragging(_ vc: FloatingPanelController)
@@ -28,7 +31,10 @@ public protocol FloatingPanelControllerDelegate: class {
     // called when its views are removed from a parent view controller
     func floatingPanelDidEndRemove(_ vc: FloatingPanelController)
 
-    func floatingPanel(_ vc: FloatingPanelController, shouldRecognizeSimultaneouslyWith gestureRecognizer: UIGestureRecognizer) -> Bool
+    /// Asks the delegate if the other gesture recognizer should be allowed to recognize the gesture in parallel.
+    ///
+    /// By default, any tap and long gesture recognizers are allowed to recognize gestures simultaneously.
+    func floatingPanel(_ vc: FloatingPanelController, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool
 }
 
 public extension FloatingPanelControllerDelegate {
@@ -39,6 +45,9 @@ public extension FloatingPanelControllerDelegate {
         return nil
     }
     func floatingPanelDidChangePosition(_ vc: FloatingPanelController) {}
+    func floatingPanelShouldBeginDragging(_ vc: FloatingPanelController) -> Bool {
+        return true
+    }
     func floatingPanelDidMove(_ vc: FloatingPanelController) {}
     func floatingPanelWillBeginDragging(_ vc: FloatingPanelController) {}
     func floatingPanelDidEndDragging(_ vc: FloatingPanelController, withVelocity velocity: CGPoint, targetPosition: FloatingPanelPosition) {}
@@ -48,7 +57,9 @@ public extension FloatingPanelControllerDelegate {
     func floatingPanelDidEndDraggingToRemove(_ vc: FloatingPanelController, withVelocity velocity: CGPoint) {}
     func floatingPanelDidEndRemove(_ vc: FloatingPanelController) {}
 
-    func floatingPanel(_ vc: FloatingPanelController, shouldRecognizeSimultaneouslyWith gestureRecognizer: UIGestureRecognizer) -> Bool { return false }
+    func floatingPanel(_ vc: FloatingPanelController, shouldRecognizeSimultaneouslyWith gestureRecognizer: UIGestureRecognizer) -> Bool {
+        return false
+    }
 }
 
 
@@ -233,10 +244,8 @@ public class FloatingPanelController: UIViewController, UIScrollViewDelegate, UI
     }
 
     private func update(safeAreaInsets: UIEdgeInsets) {
-        // Don't re-layout the surface on SafeArea.Bottom enabled/disabled in interaction progress
         guard
             floatingPanel.layoutAdapter.safeAreaInsets != safeAreaInsets,
-            self.floatingPanel.interactionInProgress == false,
             self.floatingPanel.isDecelerating == false
             else { return }
 
@@ -381,7 +390,7 @@ public class FloatingPanelController: UIViewController, UIScrollViewDelegate, UI
             vc.willMove(toParentViewController: nil)
             vc.view.removeFromSuperview()
             vc.removeFromParentViewController()
-            
+
             if let scrollView = floatingPanel.scrollView,
                 let delegate = floatingPanel.userScrollViewDelegate,
                 vc.view.subviews.contains(scrollView) {
@@ -417,10 +426,22 @@ public class FloatingPanelController: UIViewController, UIScrollViewDelegate, UI
 
     /// Tracks the specified scroll view to correspond with the scroll.
     ///
+    /// - Parameters:
+    ///     - scrollView: Specify a scroll view to continuously and seamlessly work in concert with interactions of the surface view or nil to cancel it.
     /// - Attention:
     ///     The specified scroll view must be already assigned to the delegate property because the controller intermediates between the various delegate methods.
-    ///
-    public func track(scrollView: UIScrollView) {
+    public func track(scrollView: UIScrollView?) {
+        if let trackingScrollView = floatingPanel.scrollView,
+            let delegate = floatingPanel.userScrollViewDelegate {
+            trackingScrollView.delegate = delegate // restore delegate
+            floatingPanel.userScrollViewDelegate = nil
+        }
+
+        guard let scrollView = scrollView else {
+            floatingPanel.scrollView = nil
+            return
+        }
+
         floatingPanel.scrollView = scrollView
         if scrollView.delegate !== floatingPanel {
             floatingPanel.userScrollViewDelegate = scrollView.delegate

Framework/Sources/FloatingPanelLayout.swift

@@ -7,7 +7,7 @@ import UIKit
 
 /// FloatingPanelFullScreenLayout
 ///
-/// Use the layout protocol if you want to configure a full inset from Superview.Top, not SafeArea.Top.
+/// Use the layout protocol if you configure full, half and tip insets from the superview, not the safe area.
 /// It can't be used with FloatingPanelIntrinsicLayout.
 public protocol FloatingPanelFullScreenLayout: FloatingPanelLayout { }
 
@@ -95,6 +95,8 @@ public extension FloatingPanelLayout {
 }
 
 public class FloatingPanelDefaultLayout: FloatingPanelLayout {
+    public init() { }
+
     public var initialPosition: FloatingPanelPosition {
         return .half
     }
@@ -110,6 +112,8 @@ public class FloatingPanelDefaultLayout: FloatingPanelLayout {
 }
 
 public class FloatingPanelDefaultLandscapeLayout: FloatingPanelLayout {
+    public init() { }
+
     public var initialPosition: FloatingPanelPosition {
         return .tip
     }
@@ -140,12 +144,16 @@ class FloatingPanelLayoutAdapter {
 
     var safeAreaInsets: UIEdgeInsets = .zero
 
+    private var initialConst: CGFloat = 0.0
+
     private var fixedConstraints: [NSLayoutConstraint] = []
     private var fullConstraints: [NSLayoutConstraint] = []
     private var halfConstraints: [NSLayoutConstraint] = []
     private var tipConstraints: [NSLayoutConstraint] = []
     private var offConstraints: [NSLayoutConstraint] = []
-    private var heightConstraints: [NSLayoutConstraint] = []
+    private var interactiveTopConstraint: NSLayoutConstraint?
+
+    private var heightConstraint: NSLayoutConstraint?
 
     private var fullInset: CGFloat {
         if layout is FloatingPanelIntrinsicLayout {
@@ -186,12 +194,20 @@ class FloatingPanelLayoutAdapter {
     }
 
     var middleY: CGFloat {
-        return surfaceView.superview!.bounds.height - (safeAreaInsets.bottom + halfInset)
+        if layout is FloatingPanelFullScreenLayout {
+            return surfaceView.superview!.bounds.height - halfInset
+        } else{
+            return surfaceView.superview!.bounds.height - (safeAreaInsets.bottom + halfInset)
+        }
     }
 
     var bottomY: CGFloat {
         if supportedPositions.contains(.tip) {
-            return surfaceView.superview!.bounds.height - (safeAreaInsets.bottom + tipInset)
+            if layout is FloatingPanelFullScreenLayout {
+                return surfaceView.superview!.bounds.height - tipInset
+            } else{
+                return surfaceView.superview!.bounds.height - (safeAreaInsets.bottom + tipInset)
+            }
         } else {
             return middleY
         }
@@ -201,14 +217,17 @@ class FloatingPanelLayoutAdapter {
         return surfaceView.superview!.bounds.height
     }
 
-    var safeAreaBottomY: CGFloat {
-        return surfaceView.superview!.bounds.height - (safeAreaInsets.bottom + hiddenInset)
-    }
-
     var topMaxY: CGFloat {
         return layout is FloatingPanelFullScreenLayout ? 0.0 : safeAreaInsets.top
     }
-    var bottomMaxY: CGFloat { return safeAreaBottomY }
+
+    var bottomMaxY: CGFloat {
+        if layout is FloatingPanelFullScreenLayout{
+            return surfaceView.superview!.bounds.height - hiddenInset
+        } else {
+            return surfaceView.superview!.bounds.height - (safeAreaInsets.bottom + hiddenInset)
+        }
+    }
 
     var adjustedContentInsets: UIEdgeInsets {
         return UIEdgeInsets(top: 0.0,
@@ -275,63 +294,98 @@ class FloatingPanelLayoutAdapter {
 
         fixedConstraints = surfaceConstraints + backdropConstraints
 
-        // Flexible surface constarints for full, half, tip and off
+        // Flexible surface constraints for full, half, tip and off
+        let topAnchor: NSLayoutYAxisAnchor = {
+            if layout is FloatingPanelFullScreenLayout {
+                return vc.view.topAnchor
+            } else {
+                return vc.layoutGuide.topAnchor
+            }
+        }()
+
         switch layout {
         case is FloatingPanelIntrinsicLayout:
             // Set up on updateHeight()
             break
-        case is FloatingPanelFullScreenLayout:
-            fullConstraints = [
-                surfaceView.topAnchor.constraint(equalTo: vc.view.topAnchor,
-                                                 constant: fullInset),
-            ]
         default:
             fullConstraints = [
-                surfaceView.topAnchor.constraint(equalTo: vc.layoutGuide.topAnchor,
+                surfaceView.topAnchor.constraint(equalTo: topAnchor,
                                                  constant: fullInset),
             ]
         }
 
+        let bottomAnchor: NSLayoutYAxisAnchor = {
+            if layout is FloatingPanelFullScreenLayout {
+                return vc.view.bottomAnchor
+            } else {
+                return vc.layoutGuide.bottomAnchor
+            }
+        }()
+
         halfConstraints = [
-            surfaceView.topAnchor.constraint(equalTo: vc.layoutGuide.bottomAnchor,
+            surfaceView.topAnchor.constraint(equalTo: bottomAnchor,
                                              constant: -halfInset),
         ]
         tipConstraints = [
-            surfaceView.topAnchor.constraint(equalTo: vc.layoutGuide.bottomAnchor,
+            surfaceView.topAnchor.constraint(equalTo: bottomAnchor,
                                              constant: -tipInset),
         ]
+
         offConstraints = [
-            surfaceView.topAnchor.constraint(equalTo: vc.view.bottomAnchor,
+            surfaceView.topAnchor.constraint(equalTo:vc.view.bottomAnchor,
                                              constant: -hiddenInset),
         ]
     }
 
+    func startInteraction(at state: FloatingPanelPosition) {
+        NSLayoutConstraint.deactivate(fullConstraints + halfConstraints + tipConstraints + offConstraints)
+
+        let interactiveTopConstraint: NSLayoutConstraint
+        switch layout {
+        case is FloatingPanelIntrinsicLayout,
+             is FloatingPanelFullScreenLayout:
+            initialConst = surfaceView.frame.minY
+            interactiveTopConstraint = surfaceView.topAnchor.constraint(equalTo: vc.view.topAnchor,
+                                                                        constant: initialConst)
+        default:
+            initialConst = surfaceView.frame.minY - safeAreaInsets.top
+            interactiveTopConstraint = surfaceView.topAnchor.constraint(equalTo: vc.layoutGuide.topAnchor,
+                                                                        constant: initialConst)
+        }
+        NSLayoutConstraint.activate([interactiveTopConstraint])
+        self.interactiveTopConstraint = interactiveTopConstraint
+    }
+
+    func endInteraction(at state: FloatingPanelPosition) {
+        // Don't deactivate `interactiveTopConstraint` here because it leads to
+        // unsatisfiable constraints
+    }
+
     // The method is separated from prepareLayout(to:) for the rotation support
     // It must be called in FloatingPanelController.traitCollectionDidChange(_:)
     func updateHeight() {
         guard let vc = vc else { return }
 
-        NSLayoutConstraint.deactivate(heightConstraints)
+        if let const = self.heightConstraint {
+            NSLayoutConstraint.deactivate([const])
+        }
+
+        let heightConstraint: NSLayoutConstraint
 
         switch layout {
         case is FloatingPanelIntrinsicLayout:
             updateIntrinsicHeight()
-            heightConstraints = [
-                surfaceView.heightAnchor.constraint(equalToConstant: intrinsicHeight + safeAreaInsets.bottom),
-            ]
+            heightConstraint = surfaceView.heightAnchor.constraint(equalToConstant: intrinsicHeight + safeAreaInsets.bottom)
         case is FloatingPanelFullScreenLayout:
-            heightConstraints = [
-                surfaceView.heightAnchor.constraint(equalTo: vc.view.heightAnchor,
-                                                    constant: -fullInset),
-            ]
+            heightConstraint =  surfaceView.heightAnchor.constraint(equalTo: vc.view.heightAnchor,
+                                                                    constant: -fullInset)
         default:
-            heightConstraints = [
-                surfaceView.heightAnchor.constraint(equalTo: vc.view.heightAnchor,
-                                                    constant: -(safeAreaInsets.top + fullInset)),
-            ]
+            heightConstraint = surfaceView.heightAnchor.constraint(equalTo: vc.view.heightAnchor,
+                                                                   constant: -(safeAreaInsets.top + fullInset))
         }
 
-        NSLayoutConstraint.activate(heightConstraints)
+        NSLayoutConstraint.activate([heightConstraint])
+        self.heightConstraint = heightConstraint
 
         surfaceView.bottomOverflow = vc.view.bounds.height + layout.topInteractionBuffer
 
@@ -344,6 +398,40 @@ class FloatingPanelLayoutAdapter {
         }
     }
 
+    func updateInteractiveTopConstraint(diff: CGFloat, allowsTopBuffer: Bool) {
+        defer {
+            surfaceView.superview!.layoutIfNeeded() // MUST call here to update `surfaceView.frame`
+        }
+
+        let minY: CGFloat = {
+            var ret: CGFloat = 0.0
+            switch layout {
+            case is FloatingPanelIntrinsicLayout:
+                ret = topY
+            default:
+                ret = fullInset
+            }
+            if allowsTopBuffer {
+                ret -= layout.topInteractionBuffer
+            }
+            return max(ret, 0.0) // The top boundary is equal to the related topAnchor.
+        }()
+        let maxY: CGFloat = {
+            var ret: CGFloat = 0.0
+            switch layout {
+            case is FloatingPanelIntrinsicLayout, is FloatingPanelFullScreenLayout:
+                ret = bottomY
+            default:
+                ret = bottomY - safeAreaInsets.top
+            }
+            ret += layout.bottomInteractionBuffer
+            return min(ret, bottomMaxY)
+        }()
+        let const = initialConst + diff
+
+        interactiveTopConstraint?.constant = max(minY, min(maxY, const))
+    }
+
     func activateLayout(of state: FloatingPanelPosition) {
         defer {
             surfaceView.superview!.layoutIfNeeded()
@@ -353,6 +441,11 @@ class FloatingPanelLayoutAdapter {
 
         setBackdropAlpha(of: state)
 
+        // Must deactivate `interactiveTopConstraint` here
+        if let interactiveTopConstraint = interactiveTopConstraint {
+            NSLayoutConstraint.deactivate([interactiveTopConstraint])
+            self.interactiveTopConstraint = nil
+        }
         NSLayoutConstraint.activate(fixedConstraints)
 
         if supportedPositions.union([.hidden]).contains(state) == false {
@@ -372,7 +465,7 @@ class FloatingPanelLayoutAdapter {
         }
     }
 
-    func setBackdropAlpha(of target: FloatingPanelPosition) {
+    private func setBackdropAlpha(of target: FloatingPanelPosition) {
         if target == .hidden {
             self.backdropView.alpha = 0.0
         } else {

Framework/Sources/FloatingPanelSurfaceView.swift

@@ -13,7 +13,7 @@ public class FloatingPanelSurfaceView: UIView {
     /// A GrabberHandleView object displayed at the top of the surface view.
     ///
     /// To use a custom grabber handle, hide this and then add the custom one
-    /// to the surface view at appropirate coordinates.
+    /// to the surface view at appropriate coordinates.
     public var grabberHandle: GrabberHandleView!
 
     /// The height of the grabber bar area
@@ -59,7 +59,8 @@ public class FloatingPanelSurfaceView: UIView {
     /// The color of the surface border.
     public var borderWidth: CGFloat = 0.0  { didSet { setNeedsLayout() } }
 
-    private var backgroundLayer: CAShapeLayer!  { didSet { setNeedsLayout() } }
+    private var backgroundView: UIView!
+    private var backgroundHeightConstraint: NSLayoutConstraint!
 
     private struct Default {
         public static let grabberTopPadding: CGFloat = 6.0
@@ -79,9 +80,19 @@ public class FloatingPanelSurfaceView: UIView {
         super.backgroundColor = .clear
         self.clipsToBounds = false
 
-        let backgroundLayer = CAShapeLayer()
-        layer.insertSublayer(backgroundLayer, at: 0)
-        self.backgroundLayer = backgroundLayer
+        let backgroundView = UIView()
+        addSubview(backgroundView)
+        self.backgroundView = backgroundView
+
+        backgroundView.translatesAutoresizingMaskIntoConstraints = false
+        backgroundHeightConstraint = backgroundView.heightAnchor.constraint(equalTo: heightAnchor, multiplier: 1.0)
+        NSLayoutConstraint.activate([
+            backgroundView.topAnchor.constraint(equalTo: topAnchor, constant: 0.0),
+            backgroundView.leftAnchor.constraint(equalTo: leftAnchor, constant: 0.0),
+            backgroundView.rightAnchor.constraint(equalTo: rightAnchor, constant: 0.0),
+            backgroundHeightConstraint,
+            ])
+
 
         let grabberHandle = GrabberHandleView()
         addSubview(grabberHandle)
@@ -96,9 +107,14 @@ public class FloatingPanelSurfaceView: UIView {
             ])
     }
 
+    public override func updateConstraints() {
+        super.updateConstraints()
+        backgroundHeightConstraint.constant = bottomOverflow
+    }
+
     public override func layoutSubviews() {
         super.layoutSubviews()
-        log.debug("SurfaceView frame", frame)
+        log.debug("surface view frame = \(frame)")
 
         updateLayers()
         updateContentViewMask()
@@ -109,16 +125,10 @@ public class FloatingPanelSurfaceView: UIView {
     }
 
     private func updateLayers() {
-        log.debug("SurfaceView bounds", bounds)
-        
-        var rect = bounds
-        rect.size.height += bottomOverflow // Expand the height for overflow buffer
-        let path = UIBezierPath(roundedRect: rect,
-                                byRoundingCorners: [.topLeft, .topRight],
-                                cornerRadii: CGSize(width: cornerRadius, height: cornerRadius))
-        backgroundLayer.path = path.cgPath
-        backgroundLayer.fillColor = color?.cgColor
-		
+        backgroundView.backgroundColor = color
+        backgroundView.layer.masksToBounds = true
+        backgroundView.layer.cornerRadius = cornerRadius
+
         if shadowHidden == false {
             layer.shadowColor = shadowColor.cgColor
             layer.shadowOffset = shadowOffset
@@ -130,16 +140,11 @@ public class FloatingPanelSurfaceView: UIView {
     private func updateContentViewMask() {
         if #available(iOS 11, *) {
             // Don't use `contentView.clipToBounds` because it prevents content view from expanding the height of a subview of it
-            // for the bottom overflow like Auto Layout settings of UIVisualEffectView in Main.storyborad of Example/Maps.
+            // for the bottom overflow like Auto Layout settings of UIVisualEffectView in Main.storyboard of Example/Maps.
             // Because the bottom of contentView must be fit to the bottom of a screen to work the `safeLayoutGuide` of a content VC.
-            let maskLayer = CAShapeLayer()
-            var rect = bounds
-            rect.size.height += bottomOverflow
-            let path = UIBezierPath(roundedRect: rect,
-                                    byRoundingCorners: [.topLeft, .topRight],
-                                    cornerRadii: CGSize(width: cornerRadius, height: cornerRadius))
-            maskLayer.path = path.cgPath
-            contentView?.layer.mask = maskLayer
+            contentView?.layer.masksToBounds = true
+            contentView?.layer.cornerRadius = cornerRadius
+            contentView?.layer.maskedCorners = [.layerMinXMinYCorner, .layerMaxXMinYCorner]
         } else {
             // Don't use `contentView.layer.mask` because of a UIVisualEffectView issue in iOS 10, https://forums.developer.apple.com/thread/50854
             // Instead, a user can mask the content view manually in an application.

Framework/Sources/FloatingPanelTransitioning.swift

@@ -24,7 +24,7 @@ class FloatingPanelModalTransition: NSObject, UIViewControllerTransitioningDeleg
 class FloatingPanelPresentationController: UIPresentationController {
     override func presentationTransitionWillBegin() {
         // Must call here even if duplicating on in containerViewWillLayoutSubviews()
-        // Because it let the floating panel present correclty with the presentation animation
+        // Because it let the floating panel present correctly with the presentation animation
         addFloatingPanel()
     }
 
@@ -52,14 +52,14 @@ class FloatingPanelPresentationController: UIPresentationController {
 
         /*
          * Layout the views managed by `FloatingPanelController` here for the
-         * sake of the presentation and disimissal modally from the controller.
+         * sake of the presentation and dismissal modally from the controller.
          */
         addFloatingPanel()
 
         // Forward touch events to the presenting view controller
         (fpc.view as? FloatingPanelPassThroughView)?.eventForwardingView = presentingViewController.view
 
-        // Set tap-to-dimiss in the backdrop view
+        // Set tap-to-dismiss in the backdrop view
         let tapGesture = UITapGestureRecognizer(target: self, action: #selector(handleBackdrop(tapGesture:)))
         fpc.backdropView.addGestureRecognizer(tapGesture)
     }

Framework/Sources/Logger.swift

@@ -10,11 +10,12 @@ var log = {
     return Logger()
 }()
 
+#if __FP_LOG
 struct Logger {
     private let osLog: OSLog
     private let s = DispatchSemaphore(value: 1)
 
-    enum Level: Int, Comparable {
+    private enum Level: Int, Comparable {
         case debug = 0
         case info = 1
         case warning = 2
@@ -55,17 +56,16 @@ struct Logger {
             }
         }
 
-        public static func < (lhs: Logger.Level, rhs: Logger.Level) -> Bool {
+        static func < (lhs: Logger.Level, rhs: Logger.Level) -> Bool {
             return lhs.rawValue < rhs.rawValue
         }
     }
 
-    init() {
+    fileprivate init() {
         osLog = OSLog(subsystem: "com.scenee.FloatingPanel", category: "FloatingPanel")
     }
 
     private func log(_ level: Level, _ message: Any, _ arguments: [Any], function: String, line: UInt) {
-        #if __FP_LOG
         _ = s.wait(timeout: .now() + 0.033)
         defer { s.signal() }
 
@@ -73,7 +73,6 @@ struct Logger {
         let log = "\(level.shortName) \(message) \(extraMessage) (\(function):\(line))"
 
         os_log("%@", log: osLog, type: level.osLogType, log)
-        #endif
     }
 
     private func getPrettyFunction(_ function: String, _ file: String) -> String {
@@ -104,3 +103,12 @@ struct Logger {
         self.log(.fault, log, arguments, function: getPrettyFunction(function, file), line: line)
     }
 }
+#else
+struct Logger {
+    func debug(_ log: Any, _ arguments: Any...) { }
+    func info(_ log: Any, _ arguments: Any...) { }
+    func warning(_ log: Any, _ arguments: Any...) { }
+    func error(_ log: Any, _ arguments: Any...) { }
+    func fault(_ log: Any, _ arguments: Any...) { }
+}
+#endif

Framework/Sources/UIExtensions.swift

@@ -77,12 +77,12 @@ extension UIView {
 extension UIGestureRecognizerState: CustomDebugStringConvertible {
     public var debugDescription: String {
         switch self {
-        case .began: return "Began"
-        case .changed: return "Changed"
-        case .failed: return "Failed"
-        case .cancelled: return "Cancelled"
-        case .ended: return "Endeded"
-        case .possible: return "Possible"
+        case .began: return "began"
+        case .changed: return "changed"
+        case .failed: return "failed"
+        case .cancelled: return "cancelled"
+        case .ended: return "endeded"
+        case .possible: return "possible"
         }
     }
 }
@@ -101,3 +101,10 @@ extension UISpringTimingParameters {
         self.init(mass: mass, stiffness: stiffness, damping: damp, initialVelocity: initialVelocity)
     }
 }
+
+extension CGPoint {
+    static var nan: CGPoint {
+        return CGPoint(x: CGFloat.nan,
+                       y: CGFloat.nan)
+    }
+}

README.md

@@ -251,7 +251,7 @@ class FloatingPanelLandscapeLayout: FloatingPanelLayout {
 
     public func prepareLayout(surfaceView: UIView, in view: UIView) -> [NSLayoutConstraint] {
         return [
-            surfaceView.leftAnchor.constraint(equalTo: view.safeAreaLayoutGuid.leftAnchor, constant: 8.0),
+            surfaceView.leftAnchor.constraint(equalTo: view.safeAreaLayoutGuide.leftAnchor, constant: 8.0),
             surfaceView.widthAnchor.constraint(equalToConstant: 291),
         ]
     }