Release v1.6.4

The panel(surface view) could stop b/w anchors if the pan gesture doesn't
pass through `.changed` state after an interruptible animator is interrupted.

The possible reason is the constraints have never changed since the last animation
is committed so that `surfaceView.superview!.layoutIfNeeded()` doesn't trigger
a layout update by the constraint-based layout system in
`FloatingPanelLayoutAdapter.activateLayout(of:)`.

Thus the inserted code changes a panel interactive constraint by the least
positive number. It allows the constraint-based layout system to update the
surface layout expectedly.

.travis.yml

@@ -36,6 +36,17 @@ jobs:
     osx_image: xcode10.2
     name: "iPhone X (iOS 12.2)"
 
+  - stage: Build examples
+    osx_image: xcode10.2
+    script: xcodebuild -scheme Maps -sdk iphonesimulator clean build
+    name: "Maps"
+  - script: xcodebuild -scheme Stocks -sdk iphonesimulator clean build
+    osx_image: xcode10.2
+    name: "Stocks"
+  - script: xcodebuild -scheme Samples -sdk iphonesimulator clean build
+    osx_image: xcode10.2
+    name: "Samples"
+
   - stage: Carthage
     osx_image: xcode10.2
     before_install:
@@ -47,16 +58,5 @@ jobs:
   - stage: CocoaPods
     osx_image: xcode10.2
     script:
-    - pod spec lint
-    - pod lib lint
-
-  - stage: Build examples
-    osx_image: xcode10.2
-    script: xcodebuild -scheme Maps -sdk iphonesimulator clean build
-    name: "Maps"
-  - script: xcodebuild -scheme Stocks -sdk iphonesimulator clean build
-    osx_image: xcode10.2
-    name: "Stocks"
-  - script: xcodebuild -scheme Samples -sdk iphonesimulator clean build
-    osx_image: xcode10.2
-    name: "Samples"
+    - pod spec lint --allow-warnings
+    - pod lib lint --allow-warnings

Examples/Samples/Sources/ViewController.swift

@@ -677,6 +677,10 @@ class DebugTableViewController: InspectableViewController {
         //  Remove FloatingPanel from a view
         (self.parent as! FloatingPanelController).removePanelFromParent(animated: true, completion: nil)
     }
+
+    func scrollViewDidScroll(_ scrollView: UIScrollView) {
+        print("TableView --- ", scrollView.contentOffset, scrollView.contentInset)
+    }
 }
 
 extension DebugTableViewController: UITableViewDataSource {
@@ -933,7 +937,7 @@ extension TabBarContentViewController: UITextViewDelegate {
         // Using KVO of `scrollView.contentOffset`). Because it can lead to an
         // infinite loop if a user also resets a content offset as below and,
         // in the situation, a user has to modify the library.
-        if fpc.position != .full, fpc.surfaceView.frame.minY < fpc.originYOfSurface(for: .full) {
+        if fpc.position != .full, fpc.surfaceView.frame.minY > fpc.originYOfSurface(for: .full) {
             scrollView.contentOffset = .zero
         }
     }

FloatingPanel.podspec

@@ -1,7 +1,7 @@
 Pod::Spec.new do |s|
 
   s.name                = "FloatingPanel"
-  s.version             = "1.6.2"
+  s.version             = "1.6.4"
   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/FloatingPanel.xcodeproj/project.pbxproj

@@ -18,6 +18,7 @@
 		545DB9DE215118C800CA77B8 /* UIExtensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 545DB9DD215118C800CA77B8 /* UIExtensions.swift */; };
 		545DB9E021511AC100CA77B8 /* FloatingPanelController.swift in Sources */ = {isa = PBXBuildFile; fileRef = 545DB9DF21511AC100CA77B8 /* FloatingPanelController.swift */; };
 		545DBA2B2152383100CA77B8 /* GrabberHandleView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 545DBA2A2152383100CA77B8 /* GrabberHandleView.swift */; };
+		549E944522CF295D0050AECF /* FloatingPanelPositionTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 549E944422CF295D0050AECF /* FloatingPanelPositionTests.swift */; };
 		54A6B6B122968B530077F348 /* FloatingPanelTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 54A6B6B022968B530077F348 /* FloatingPanelTests.swift */; };
 		54A6B6B622968F710077F348 /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 54A6B6B522968F710077F348 /* LaunchScreen.storyboard */; };
 		54A6B6B82296A8520077F348 /* FloatingPanelSurfaceViewTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 54A6B6B72296A8520077F348 /* FloatingPanelSurfaceViewTests.swift */; };
@@ -61,6 +62,7 @@
 		545DB9DD215118C800CA77B8 /* UIExtensions.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UIExtensions.swift; sourceTree = "<group>"; };
 		545DB9DF21511AC100CA77B8 /* FloatingPanelController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FloatingPanelController.swift; sourceTree = "<group>"; };
 		545DBA2A2152383100CA77B8 /* GrabberHandleView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GrabberHandleView.swift; sourceTree = "<group>"; };
+		549E944422CF295D0050AECF /* FloatingPanelPositionTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FloatingPanelPositionTests.swift; sourceTree = "<group>"; };
 		54A6B6B022968B530077F348 /* FloatingPanelTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FloatingPanelTests.swift; sourceTree = "<group>"; };
 		54A6B6B522968F710077F348 /* LaunchScreen.storyboard */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; path = LaunchScreen.storyboard; sourceTree = "<group>"; };
 		54A6B6B72296A8520077F348 /* FloatingPanelSurfaceViewTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FloatingPanelSurfaceViewTests.swift; sourceTree = "<group>"; };
@@ -144,9 +146,10 @@
 			isa = PBXGroup;
 			children = (
 				54A6B6B022968B530077F348 /* FloatingPanelTests.swift */,
+				545DB9CF2151169500CA77B8 /* FloatingPanelControllerTests.swift */,
 				542753C522C49A6E00D17955 /* FloatingPanelLayoutTests.swift */,
 				54A6B6B72296A8520077F348 /* FloatingPanelSurfaceViewTests.swift */,
-				545DB9CF2151169500CA77B8 /* FloatingPanelControllerTests.swift */,
+				549E944422CF295D0050AECF /* FloatingPanelPositionTests.swift */,
 				542753C722C49A8F00D17955 /* Utils.swift */,
 				545DB9D12151169500CA77B8 /* Info.plist */,
 			);
@@ -325,6 +328,7 @@
 			files = (
 				54A6B6B122968B530077F348 /* FloatingPanelTests.swift in Sources */,
 				545DB9D02151169500CA77B8 /* FloatingPanelControllerTests.swift in Sources */,
+				549E944522CF295D0050AECF /* FloatingPanelPositionTests.swift in Sources */,
 				542753C622C49A6E00D17955 /* FloatingPanelLayoutTests.swift in Sources */,
 				54A6B6B82296A8520077F348 /* FloatingPanelSurfaceViewTests.swift in Sources */,
 			);

Framework/Sources/FloatingPanel.swift

@@ -51,7 +51,6 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
 
     // 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 +92,7 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
     }
 
     private func move(from: FloatingPanelPosition, to: FloatingPanelPosition, animated: Bool, completion: (() -> Void)? = nil) {
+        assert(layoutAdapter.isValid(to), "Can't move to '\(to)' position because it's not valid in the layout")
         guard let vc = viewcontroller else {
             completion?()
             return
@@ -149,11 +149,15 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
         self.layoutAdapter.activateLayout(of: target)
     }
 
-    private func getBackdropAlpha(with translation: CGPoint) -> CGFloat {
-        let currentY = surfaceView.frame.minY
+    func getBackdropAlpha(at currentY: CGFloat, with translation: CGPoint) -> CGFloat {
+        let forwardY = (translation.y >= 0)
+        let segment = layoutAdapter.segument(at: currentY, forward: forwardY)
+        let lowerPos = segment.lower ?? layoutAdapter.topMostState
+        let upperPos = segment.upper ?? layoutAdapter.bottomMostState
+
+        let pre = forwardY ? lowerPos : upperPos
+        let next = forwardY ? upperPos : lowerPos
 
-        let next = directionalPosition(at: currentY, with: translation)
-        let pre = redirectionalPosition(at: currentY, with: translation)
         let nextY = layoutAdapter.positionY(for: next)
         let preY = layoutAdapter.positionY(for: pre)
 
@@ -260,14 +264,16 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
 
             let location = panGesture.location(in: surfaceView)
 
-            let belowTop = surfaceView.frame.minY > layoutAdapter.topY
+            let belowTop = surfaceView.presentationFrame.minY > layoutAdapter.topY
+            let offset = scrollView.contentOffset.y - scrollView.contentOffsetZero.y
 
             log.debug("scroll gesture(\(state):\(panGesture.state)) --",
                 "belowTop = \(belowTop),",
                 "interactionInProgress = \(interactionInProgress),",
-                "scroll offset = \(scrollView.contentOffset.y),",
+                "scroll offset = \(offset),",
                 "location = \(location.y), velocity = \(velocity.y)")
 
+
             if belowTop {
                 // Scroll offset pinning
                 if state == layoutAdapter.topMostState {
@@ -284,22 +290,43 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
                     scrollView.setContentOffset(initialScrollOffset, animated: false)
                 }
 
-                // Always hide a scroll indicator at the non-top.
+                // Hide a scroll indicator at the non-top in dragging.
                 if interactionInProgress {
                     lockScrollView()
-                }
-            } else {
-                let offset = scrollView.contentOffset.y - scrollView.contentOffsetZero.y
-                // Always show a scroll indicator at the top.
-                if interactionInProgress {
-                    if offset > 0 {
+                } else {
+                    if state == layoutAdapter.topMostState, self.animator == nil,
+                        offset > 0, velocity.y < 0 {
                         unlockScrollView()
                     }
+                }
+            } else {
+                if interactionInProgress {
+                    // Show a scroll indicator at the top in dragging.
+                    if offset >= 0, velocity.y <= 0 {
+                        unlockScrollView()
+                    } else {
+                        if state == layoutAdapter.topMostState {
+                            // Adjust a small gap of the scroll offset just after swiping down starts in the grabber area.
+                            if grabberAreaFrame.contains(location), grabberAreaFrame.contains(initialLocation) {
+                                scrollView.setContentOffset(initialScrollOffset, animated: false)
+                            }
+                        }
+                    }
                 } else {
-                    // Hide a scroll indicator just before starting an interaction by swiping a panel down.
-                    if state == layoutAdapter.topMostState,
-                        offset < 0, velocity.y > 0 {
-                        lockScrollView()
+                    if state == layoutAdapter.topMostState {
+                        // Hide a scroll indicator just before starting an interaction by swiping a panel down.
+                        if offset < 0, velocity.y > 0 {
+                            lockScrollView()
+                        }
+                        // Show a scroll indicator when an animation is interrupted at the top and content is scrolled up
+                        if offset > 0, velocity.y < 0 {
+                            unlockScrollView()
+                        }
+
+                        // Adjust a small gap of the scroll offset just before swiping down starts in the grabber area,
+                        if grabberAreaFrame.contains(location), grabberAreaFrame.contains(initialLocation) {
+                            scrollView.setContentOffset(initialScrollOffset, animated: false)
+                        }
                     }
                 }
             }
@@ -310,24 +337,26 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
             log.debug("panel gesture(\(state):\(panGesture.state)) --",
                 "translation =  \(translation.y), location = \(location.y), velocity = \(velocity.y)")
 
-            if let animator = self.animator {
-                log.debug("panel animation interrupted!!!")
-                if animator.isInterruptible {
-                    animator.stopAnimation(false)
-                    animator.finishAnimation(at: .current)
-                }
-                self.animator = nil
-
-                // A user can stop a panel at the nearest Y of a target position
-                if abs(surfaceView.frame.minY - layoutAdapter.topY) < 1.0 {
-                    surfaceView.frame.origin.y = layoutAdapter.topY
-                }
+            if interactionInProgress == false, isDecelerating == false,
+                let vc = viewcontroller, vc.delegate?.floatingPanelShouldBeginDragging(vc) == false {
+                return
             }
 
-            if interactionInProgress == false,
-                let vc = viewcontroller,
-                vc.delegate?.floatingPanelShouldBeginDragging(vc) == false {
-                return
+            if let animator = self.animator {
+                guard surfaceView.presentationFrame.minY >= layoutAdapter.topMaxY else { return }
+                log.debug("panel animation(interruptible: \(animator.isInterruptible)) interrupted!!!")
+                if animator.isInterruptible {
+                    animator.stopAnimation(false)
+                    // A user can stop a panel at the nearest Y of a target position so this fine-tunes
+                    // the a small gap between the presentation layer frame and model layer frame
+                    // to unlock scroll view properly at finishAnimation(at:)
+                    if abs(surfaceView.frame.minY - layoutAdapter.topY) <= 1.0 {
+                        surfaceView.frame.origin.y = layoutAdapter.topY
+                    }
+                    animator.finishAnimation(at: .current)
+                } else {
+                    self.animator = nil
+                }
             }
 
             if panGesture.state == .began {
@@ -346,6 +375,15 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
                 }
                 panningChange(with: translation)
             case .ended, .cancelled, .failed:
+                if interactionInProgress == false {
+                    startInteraction(with: translation, at: location)
+                    // Workaround: Prevent stopping the surface view b/w anchors if the pan gesture
+                    // doesn't pass through .changed state after an interruptible animator is interrupted.
+                    let dy = translation.y - .leastNonzeroMagnitude
+                    layoutAdapter.updateInteractiveTopConstraint(diff: dy,
+                                                                 allowsTopBuffer: true,
+                                                                 with: behavior)
+                }
                 panningEnd(with: translation, velocity: velocity)
             default:
                 break
@@ -413,30 +451,31 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
         // So here just preserve the current state if needed.
         log.debug("panningBegan -- location = \(location.y)")
         initialLocation = location
+
+        guard let scrollView = scrollView else { return }
         if state == layoutAdapter.topMostState {
-            if let scrollView = scrollView {
-                initialScrollFrame = scrollView.frame
-            }
-        } else {
-            if let scrollView = scrollView {
+            if grabberAreaFrame.contains(location) {
                 initialScrollOffset = scrollView.contentOffset
             }
+        } else {
+            initialScrollOffset = scrollView.contentOffset
         }
     }
 
     private func panningChange(with translation: CGPoint) {
         log.debug("panningChange -- translation = \(translation.y)")
-        let pre = surfaceView.frame.minY
+        let preY = surfaceView.frame.minY
         let dy = translation.y - initialTranslationY
 
         layoutAdapter.updateInteractiveTopConstraint(diff: dy,
                                                      allowsTopBuffer: allowsTopBuffer(for: dy),
                                                      with: behavior)
 
-        backdropView.alpha = getBackdropAlpha(with: translation)
+        let currentY = surfaceView.frame.minY
+        backdropView.alpha = getBackdropAlpha(at: currentY, with: translation)
         preserveContentVCLayoutIfNeeded()
 
-        let didMove = (pre != surfaceView.frame.minY)
+        let didMove = (preY != currentY)
         guard didMove else { return }
 
         if let vc = viewcontroller {
@@ -456,6 +495,7 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
     }
 
     private var disabledBottomAutoLayout = false
+    private var disabledAutoLayoutItems: Set<NSLayoutConstraint> = []
     // 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() {
@@ -463,14 +503,17 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
         // Must include topY
         if (surfaceView.frame.minY <= layoutAdapter.topY) {
             if !disabledBottomAutoLayout {
+                disabledAutoLayoutItems.removeAll()
                 vc.contentViewController?.view?.constraints.forEach({ (const) in
                     switch vc.contentViewController?.layoutGuide.bottomAnchor {
                     case const.firstAnchor:
                         (const.secondItem as? UIView)?.disableAutoLayout()
                         const.isActive = false
+                        disabledAutoLayoutItems.insert(const)
                     case const.secondAnchor:
                         (const.firstItem as? UIView)?.disableAutoLayout()
                         const.isActive = false
+                        disabledAutoLayoutItems.insert(const)
                     default:
                         break
                     }
@@ -479,7 +522,7 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
             disabledBottomAutoLayout = true
         } else {
             if disabledBottomAutoLayout {
-                vc.contentViewController?.view?.constraints.forEach({ (const) in
+                disabledAutoLayoutItems.forEach({ (const) in
                     switch vc.contentViewController?.layoutGuide.bottomAnchor {
                     case const.firstAnchor:
                         (const.secondItem as? UIView)?.enableAutoLayout()
@@ -491,6 +534,7 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
                         break
                     }
                 })
+                disabledAutoLayoutItems.removeAll()
             }
             disabledBottomAutoLayout = false
         }
@@ -512,18 +556,19 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
             }
         }
 
-        let targetPosition = self.targetPosition(with: velocity)
+        let currentY = surfaceView.frame.minY
+        let targetPosition = self.targetPosition(from: currentY, with: velocity)
         let distance = self.distance(to: targetPosition)
 
         endInteraction(for: targetPosition)
 
         if isRemovalInteractionEnabled, isBottomState {
-            let velocityVector = (distance != 0) ? CGVector(dx: 0,
-                                                            dy: min(abs(velocity.y)/distance, behavior.removalVelocity)) : .zero
-
+            let velocityVector = (distance != 0) ? CGVector(dx: 0, dy: min(velocity.y/distance, behavior.removalVelocity)) : .zero
+            // `velocityVector` will be replaced by just a velocity(not vector) when FloatingPanelRemovalInteraction will be added.
             if shouldStartRemovalAnimation(with: velocityVector), let vc = viewcontroller {
                 vc.delegate?.floatingPanelDidEndDraggingToRemove(vc, withVelocity: velocity)
-                startRemovalAnimation(vc, with: velocityVector) { [weak self] in
+                let animationVector = CGVector(dx: abs(velocityVector.dx), dy: abs(velocityVector.dy))
+                startRemovalAnimation(vc, with: animationVector) { [weak self] in
                     self?.finishRemovalAnimation()
                 }
                 return
@@ -534,6 +579,15 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
             vc.delegate?.floatingPanelDidEndDragging(vc, withVelocity: velocity, targetPosition: targetPosition)
         }
 
+        if scrollView != nil, !stopScrollDeceleration,
+            surfaceView.frame.minY == layoutAdapter.topY,
+            targetPosition == layoutAdapter.topMostState {
+            self.state = targetPosition
+            self.updateLayout(to: targetPosition)
+            self.unlockScrollView()
+            return
+        }
+
         // Workaround: Disable a tracking scroll to prevent bouncing a scroll content in a panel animating
         let isScrollEnabled = scrollView?.isScrollEnabled
         if let scrollView = scrollView, targetPosition != .full {
@@ -552,12 +606,12 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
     private func shouldStartRemovalAnimation(with velocityVector: CGVector) -> Bool {
         let posY = layoutAdapter.positionY(for: state)
         let currentY = surfaceView.frame.minY
-        let bottomMaxY = layoutAdapter.bottomMaxY
+        let hiddenY = layoutAdapter.positionY(for: .hidden)
         let vth = behavior.removalVelocity
         let pth = max(min(behavior.removalProgress, 1.0), 0.0)
 
         let num = (currentY - posY)
-        let den = (bottomMaxY - posY)
+        let den = (hiddenY - posY)
 
         guard num >= 0, den != 0, (num / den >= pth || velocityVector.dy == vth)
         else { return false }
@@ -591,13 +645,15 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
         log.debug("startInteraction  -- translation = \(translation.y), location = \(location.y)")
         guard interactionInProgress == false else { return }
 
+        var offset: CGPoint = .zero
+
         initialFrame = surfaceView.frame
         if state == layoutAdapter.topMostState, let scrollView = scrollView {
             if grabberAreaFrame.contains(location) {
                 initialScrollOffset = scrollView.contentOffset
             } else {
-                fitToBounds(scrollView: scrollView)
-                settle(scrollView: scrollView)
+                // Fit the surface bounds to a scroll offset content by startInteraction(at:offset:)
+                offset = CGPoint(x: -scrollView.contentOffset.x, y: -scrollView.contentOffset.y)
                 initialScrollOffset = scrollView.contentOffsetZero
             }
             log.debug("initial scroll offset --", initialScrollOffset)
@@ -609,9 +665,11 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
             vc.delegate?.floatingPanelWillBeginDragging(vc)
         }
 
-        layoutAdapter.startInteraction(at: state)
+        layoutAdapter.startInteraction(at: state, offset: offset)
 
         interactionInProgress = true
+
+        lockScrollView()
     }
 
     private func endInteraction(for targetPosition: FloatingPanelPosition) {
@@ -624,7 +682,7 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
         interactionInProgress = false
 
         // Prevent to keep a scroll view indicator visible at the half/tip position
-        if state != layoutAdapter.topMostState {
+        if targetPosition != layoutAdapter.topMostState {
             lockScrollView()
         }
 
@@ -645,7 +703,7 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
 
         vc.delegate?.floatingPanelWillBeginDecelerating(vc)
 
-        let velocityVector = (distance != 0) ? CGVector(dx: 0, dy: min(abs(velocity.y)/distance, 30.0)) : .zero
+        let velocityVector = (distance != 0) ? CGVector(dx: 0, dy: abs(velocity.y)/distance) : .zero
         let animator = behavior.interactionAnimator(vc, to: targetPosition, with: velocityVector)
         animator.addAnimations { [weak self] in
             guard let `self` = self else { return }
@@ -653,7 +711,9 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
             self.updateLayout(to: targetPosition)
         }
         animator.addCompletion { [weak self] pos in
-            guard let `self` = self else { return }
+            // Prevent calling `finishAnimation(at:)` by the old animator whose `isInterruptive` is false
+            // when a new animator has been started after the old one is interrupted.
+            guard let `self` = self, self.animator == animator else { return }
             self.finishAnimation(at: targetPosition)
         }
         self.animator = animator
@@ -675,8 +735,9 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
         }
 
         stopScrollDeceleration = false
-        // Don't unlock scroll view in animating view when presentation layer != model layer
-        if state == layoutAdapter.topMostState {
+
+        log.debug("finishAnimation -- state = \(state) surface.minY = \(surfaceView.presentationFrame.minY) topY = \(layoutAdapter.topY)")
+        if state == layoutAdapter.topMostState, abs(surfaceView.presentationFrame.minY - layoutAdapter.topY) <= 1.0 {
             unlockScrollView()
         }
     }
@@ -687,187 +748,63 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
         return CGFloat(abs(currentY - targetY))
     }
 
-    private func directionalPosition(at currentY: CGFloat, with translation: CGPoint) -> FloatingPanelPosition {
-        return getPosition(at: currentY, with: translation, directional: true)
-    }
-
-    private func redirectionalPosition(at currentY: CGFloat, with translation: CGPoint) -> FloatingPanelPosition {
-        return getPosition(at: currentY, with: translation, directional: false)
-    }
-
-    private func getPosition(at currentY: CGFloat, with translation: CGPoint, directional: Bool) -> FloatingPanelPosition {
-        let supportedPositions: Set = layoutAdapter.supportedPositions
-        if supportedPositions.count == 1 {
-            return state
-        }
-        let isForwardYAxis = (translation.y >= 0)
-        switch supportedPositions {
-        case [.full, .half]:
-            return (isForwardYAxis == directional) ? .half : .full
-        case [.half, .tip]:
-            return (isForwardYAxis == directional) ? .tip : .half
-        case [.full, .tip]:
-            return (isForwardYAxis == directional) ? .tip : .full
-        default:
-            let middleY = layoutAdapter.middleY
-            if currentY > middleY {
-                return (isForwardYAxis == directional) ? .tip : .half
-            } else {
-                return (isForwardYAxis == directional) ? .half : .full
-            }
-        }
-    }
-
     // 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, decelerationRate: CGFloat) -> CGFloat {
         return (initialVelocity / 1000.0) * decelerationRate / (1.0 - decelerationRate)
     }
 
-    private func targetPosition(with velocity: CGPoint) -> (FloatingPanelPosition) {
+    func targetPosition(from currentY: CGFloat, with velocity: CGPoint) -> (FloatingPanelPosition) {
         guard let vc = viewcontroller else { return state }
-        let currentY = surfaceView.frame.minY
         let supportedPositions = layoutAdapter.supportedPositions
 
-        if supportedPositions.count == 1 {
+        guard supportedPositions.count > 1 else {
             return state
         }
 
-        switch supportedPositions {
-        case [.full, .half]:
-            return targetPosition(from: [.full, .half], at: currentY, velocity: velocity)
-        case [.half, .tip]:
-            return targetPosition(from: [.half, .tip], at: currentY, velocity: velocity)
-        case [.full, .tip]:
-            return targetPosition(from: [.full, .tip], at: currentY, velocity: velocity)
-        default:
-            /*
-             [topY|full]---[th1]---[middleY|half]---[th2]---[bottomY|tip]
-             */
-            let topY = layoutAdapter.topY
-            let middleY = layoutAdapter.middleY
-            let bottomY = layoutAdapter.bottomY
-
-            let nextState: FloatingPanelPosition
-            let forwardYDirection: Bool
-
-            /*
-             full <-> half <-> tip
-             */
-            switch state {
-            case .full:
-                nextState = .half
-                forwardYDirection = true
-            case .half:
-                nextState = (currentY > middleY) ? .tip : .full
-                forwardYDirection = (currentY > middleY)
-            case .tip:
-                nextState = .half
-                forwardYDirection = false
-            case .hidden:
-                fatalError("Now .hidden must not be used for a user interaction")
-            }
-
-            let redirectionalProgress = max(min(behavior.redirectionalProgress(vc, from: state, to: nextState), 1.0), 0.0)
-
-            let th1: CGFloat
-            let th2: CGFloat
-
-            if forwardYDirection {
-                th1 = topY + (middleY - topY) * redirectionalProgress
-                th2 = middleY + (bottomY - middleY) * redirectionalProgress
-            } else {
-                th1 = middleY - (middleY - topY) * redirectionalProgress
-                th2 = bottomY - (bottomY - middleY) * redirectionalProgress
-            }
-
-            let decelerationRate = behavior.momentumProjectionRate(vc)
-
-            let baseY = abs(bottomY - topY)
-            let vecY = velocity.y / baseY
-            let pY = project(initialVelocity: vecY, decelerationRate: decelerationRate) * baseY + currentY
-
-            switch currentY {
-            case ..<th1:
-                switch pY {
-                case bottomY...:
-                    return behavior.shouldProjectMomentum(vc, for: .tip) ? .tip : .half
-                case middleY...:
-                    return .half
-                case topY...:
-                    return .full
-                default:
-                    return .full
-                }
-            case ...middleY:
-                switch pY {
-                case bottomY...:
-                    return behavior.shouldProjectMomentum(vc, for: .tip) ? .tip : .half
-                case middleY...:
-                    return .half
-                case topY...:
-                    return .half
-                default:
-                    return .full
-                }
-            case ..<th2:
-                switch pY {
-                case bottomY...:
-                    return .tip
-                case middleY...:
-                    return .half
-                case topY...:
-                    return .half
-                default:
-                    return behavior.shouldProjectMomentum(vc, for: .full) ? .full : .half
-                }
-            default:
-                switch pY {
-                case bottomY...:
-                    return .tip
-                case middleY...:
-                    return .tip
-                case topY...:
-                    return .half
-                default:
-                    return behavior.shouldProjectMomentum(vc, for: .full) ? .full : .half
-                }
-            }
-        }
-    }
-
-    private func targetPosition(from positions: [FloatingPanelPosition], at currentY: CGFloat, velocity: CGPoint) -> FloatingPanelPosition {
-        guard let vc = viewcontroller else { return state }
-        assert(positions.count == 2)
-
-        let top = positions[0]
-        let bottom = positions[1]
-
-        let topY = layoutAdapter.positionY(for: top)
-        let bottomY = layoutAdapter.positionY(for: bottom)
-
-        let target = top == state ? bottom : top
-        let redirectionalProgress = max(min(behavior.redirectionalProgress(vc, from: state, to: target), 1.0), 0.0)
-
-        let th = topY + (bottomY - topY) * redirectionalProgress
+        let sortedPositions = Array(supportedPositions).sorted(by: { $0.rawValue < $1.rawValue })
 
+        // Projection
         let decelerationRate = behavior.momentumProjectionRate(vc)
-        let pY = project(initialVelocity: velocity.y, decelerationRate: decelerationRate) + currentY
+        let baseY = abs(layoutAdapter.positionY(for: layoutAdapter.bottomMostState) - layoutAdapter.positionY(for: layoutAdapter.topMostState))
+        let vecY = velocity.y / baseY
+        var pY = project(initialVelocity: vecY, decelerationRate: decelerationRate) * baseY + currentY
 
-        switch currentY {
-        case ..<th:
-            if pY >= bottomY {
-                return bottom
-            } else {
-                return top
+        let forwardY = velocity.y == 0 ? (currentY - layoutAdapter.positionY(for: state) > 0) : velocity.y > 0
+
+        let segment = layoutAdapter.segument(at: pY, forward: forwardY)
+
+        var fromPos: FloatingPanelPosition
+        var toPos: FloatingPanelPosition
+
+        let (lowerPos, upperPos) = (segment.lower ?? sortedPositions.first!, segment.upper ?? sortedPositions.last!)
+        (fromPos, toPos) = forwardY ? (lowerPos, upperPos) : (upperPos, lowerPos)
+
+        if behavior.shouldProjectMomentum(vc, for: toPos) == false {
+            let segment = layoutAdapter.segument(at: currentY, forward: forwardY)
+            var (lowerPos, upperPos) = (segment.lower ?? sortedPositions.first!, segment.upper ?? sortedPositions.last!)
+            // Equate the segment out of {top,bottom} most state to the {top,bottom} most segment
+            if lowerPos == upperPos {
+                if forwardY {
+                    upperPos = lowerPos.next(in: sortedPositions)
+                } else {
+                    lowerPos = upperPos.pre(in: sortedPositions)
+                }
             }
-        default:
-            if pY <= topY {
-                return top
+            (fromPos, toPos) = forwardY ? (lowerPos, upperPos) : (upperPos, lowerPos)
+            // Block a projection to a segment over the next from the current segment
+            // (= Trim pY with the current segment)
+            if forwardY {
+                pY = max(min(pY, layoutAdapter.positionY(for: toPos.next(in: sortedPositions))), layoutAdapter.positionY(for: fromPos))
             } else {
-                return bottom
+                pY = max(min(pY, layoutAdapter.positionY(for: fromPos)), layoutAdapter.positionY(for: toPos.pre(in: sortedPositions)))
             }
         }
+
+        // Redirection
+        let redirectionalProgress = max(min(behavior.redirectionalProgress(vc, from: fromPos, to: toPos), 1.0), 0.0)
+        let progress = abs(pY - layoutAdapter.positionY(for: fromPos)) / abs(layoutAdapter.positionY(for: fromPos) - layoutAdapter.positionY(for: toPos))
+        return progress > redirectionalProgress ? toPos : fromPos
     }
 
     // MARK: - ScrollView handling
@@ -879,6 +816,7 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
             log.debug("Already scroll locked.")
             return
         }
+        log.debug("lock scroll view")
 
         scrollBouncable = scrollView.bounces
         scrollIndictorVisible = scrollView.showsVerticalScrollIndicator
@@ -890,36 +828,13 @@ class FloatingPanel: NSObject, UIGestureRecognizerDelegate {
 
     private func unlockScrollView() {
         guard let scrollView = scrollView, scrollView.isLocked else { return }
+        log.debug("unlock scroll view")
 
         scrollView.isDirectionalLockEnabled = false
         scrollView.bounces = scrollBouncable
         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")
-        let frame = surfaceView.layer.presentation()?.frame ?? surfaceView.frame
-        surfaceView.transform = .identity
-        surfaceView.frame = frame
-        scrollView.transform = .identity
-        scrollView.frame = initialScrollFrame
-        scrollView.contentOffset = scrollView.contentOffsetZero
-        scrollView.scrollIndicatorInsets = .zero
-    }
-
-
     private func stopScrollingWithDeceleration(at contentOffset: CGPoint) {
         // Must use setContentOffset(_:animated) to force-stop deceleration
         scrollView?.setContentOffset(contentOffset, animated: false)

Framework/Sources/FloatingPanelBehavior.swift

@@ -23,6 +23,11 @@ public protocol FloatingPanelBehavior {
     func redirectionalProgress(_ fpc: FloatingPanelController, from: FloatingPanelPosition, to: FloatingPanelPosition) -> CGFloat
 
     /// Returns a UIViewPropertyAnimator object to project a floating panel to a position on finger up if the user dragged.
+    ///
+    /// - Attention:
+    /// By default, it returns a non-interruptible animator to prevent a propagation of the animation to a content view.
+    /// However returning an interruptible animator is working well depending on a content view and it can be better
+    /// than using a non-interruptible one.
     func interactionAnimator(_ fpc: FloatingPanelController, to targetPosition: FloatingPanelPosition, with velocity: CGVector) -> UIViewPropertyAnimator
 
     /// Returns a UIViewPropertyAnimator object to add a floating panel to a position.
@@ -67,14 +72,7 @@ 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
-        }
+        return false
     }
 
     func momentumProjectionRate(_ fpc: FloatingPanelController) -> CGFloat {
@@ -134,7 +132,7 @@ public class FloatingPanelDefaultBehavior: FloatingPanelBehavior {
     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
+        animator.isInterruptible = false // Prevent a propagation of the animation(spring etc) to a content view
         return animator
     }
 

Framework/Sources/FloatingPanelController.swift

@@ -72,6 +72,36 @@ public enum FloatingPanelPosition: Int {
     static var allCases: [FloatingPanelPosition] {
         return [.full, .half, .tip, .hidden]
     }
+
+    func next(in positions: [FloatingPanelPosition]) -> FloatingPanelPosition {
+        #if swift(>=4.2)
+        guard
+            let index = positions.firstIndex(of: self),
+            positions.indices.contains(index + 1)
+            else { return self }
+        #else
+        guard
+            let index = positions.index(of: self),
+            positions.indices.contains(index + 1)
+            else { return self }
+        #endif
+        return positions[index + 1]
+    }
+
+    func pre(in positions: [FloatingPanelPosition]) -> FloatingPanelPosition {
+        #if swift(>=4.2)
+        guard
+            let index = positions.firstIndex(of: self),
+            positions.indices.contains(index - 1)
+            else { return self }
+        #else
+        guard
+            let index = positions.index(of: self),
+            positions.indices.contains(index - 1)
+            else { return self }
+        #endif
+        return positions[index - 1]
+    }
 }
 
 ///
@@ -205,7 +235,8 @@ open class FloatingPanelController: UIViewController, UIScrollViewDelegate, UIGe
         if #available(iOS 11.0, *) {}
         else {
             // Because {top,bottom}LayoutGuide is managed as a view
-            if preSafeAreaInsets != layoutInsets {
+            if preSafeAreaInsets != layoutInsets,
+                floatingPanel.isDecelerating == false {
                 self.update(safeAreaInsets: layoutInsets)
             }
         }
@@ -256,8 +287,7 @@ open class FloatingPanelController: UIViewController, UIScrollViewDelegate, UIGe
 
     private func update(safeAreaInsets: UIEdgeInsets) {
         guard
-            preSafeAreaInsets != safeAreaInsets,
-            self.floatingPanel.isDecelerating == false
+            preSafeAreaInsets != safeAreaInsets
             else { return }
 
         log.debug("Update safeAreaInsets", safeAreaInsets)
@@ -526,16 +556,7 @@ open class FloatingPanelController: UIViewController, UIScrollViewDelegate, UIGe
 
     /// Returns the y-coordinate of the point at the origin of the surface view.
     public func originYOfSurface(for pos: FloatingPanelPosition) -> CGFloat {
-        switch pos {
-        case .full:
-            return floatingPanel.layoutAdapter.topY
-        case .half:
-            return floatingPanel.layoutAdapter.middleY
-        case .tip:
-            return floatingPanel.layoutAdapter.bottomY
-        case .hidden:
-            return floatingPanel.layoutAdapter.hiddenY
-        }
+        return floatingPanel.layoutAdapter.positionY(for: pos)
     }
 }
 

Framework/Sources/FloatingPanelLayout.swift

@@ -43,14 +43,16 @@ public protocol FloatingPanelLayout: class {
     /// Returns a set of FloatingPanelPosition objects to tell the applicable
     /// positions of the floating panel controller.
     ///
-    /// By default, it returns all position except for `hidden` position. Because
-    /// it's always supported by `FloatingPanelController` so you don't need to return it.
+    /// By default, it returns full, half and tip positions.
     var supportedPositions: Set<FloatingPanelPosition> { get }
 
     /// Return the interaction buffer to the top from the top position. Default is 6.0.
     var topInteractionBuffer: CGFloat { get }
 
     /// Return the interaction buffer to the bottom from the bottom position. Default is 6.0.
+    ///
+    /// - Important:
+    /// The specified buffer is ignored when `FloatingPanelController.isRemovalInteractionEnabled` is set to true.
     var bottomInteractionBuffer: CGFloat { get }
 
     /// Returns a CGFloat value to determine a Y coordinate of a floating panel for each position(full, half, tip and hidden).
@@ -130,9 +132,13 @@ public class FloatingPanelDefaultLandscapeLayout: FloatingPanelLayout {
     }
 }
 
+struct LayoutSegment {
+    let lower: FloatingPanelPosition?
+    let upper: FloatingPanelPosition?
+}
 
 class FloatingPanelLayoutAdapter {
-    weak var vc: UIViewController!
+    weak var vc: FloatingPanelController!
     private weak var surfaceView: FloatingPanelSurfaceView!
     private weak var backdropView: FloatingPanelBackdropView!
 
@@ -175,9 +181,7 @@ class FloatingPanelLayoutAdapter {
     }
 
     var supportedPositions: Set<FloatingPanelPosition> {
-        var supportedPositions = layout.supportedPositions
-        supportedPositions.remove(.hidden)
-        return supportedPositions
+        return layout.supportedPositions
     }
 
     var topMostState: FloatingPanelPosition {
@@ -189,54 +193,19 @@ class FloatingPanelLayoutAdapter {
     }
 
     var topY: CGFloat {
-        if supportedPositions.contains(.full) {
-            switch layout {
-            case is FloatingPanelIntrinsicLayout:
-                return surfaceView.superview!.bounds.height - surfaceView.bounds.height
-            case is FloatingPanelFullScreenLayout:
-                return fullInset
-            default:
-                return (safeAreaInsets.top + fullInset)
-            }
-        } else {
-            return middleY
-        }
-    }
-
-    var middleY: CGFloat {
-        if layout is FloatingPanelFullScreenLayout {
-            return surfaceView.superview!.bounds.height - halfInset
-        } else{
-            return surfaceView.superview!.bounds.height - (safeAreaInsets.bottom + halfInset)
-        }
+        return positionY(for: topMostState)
     }
 
     var bottomY: CGFloat {
-        if supportedPositions.contains(.tip) {
-            if layout is FloatingPanelFullScreenLayout {
-                return surfaceView.superview!.bounds.height - tipInset
-            } else{
-                return surfaceView.superview!.bounds.height - (safeAreaInsets.bottom + tipInset)
-            }
-        } else {
-            return middleY
-        }
-    }
-
-    var hiddenY: CGFloat {
-        return surfaceView.superview!.bounds.height
+        return positionY(for: bottomMostState)
     }
 
     var topMaxY: CGFloat {
-        return layout is FloatingPanelFullScreenLayout ? 0.0 : safeAreaInsets.top
+        return topY - layout.topInteractionBuffer
     }
 
     var bottomMaxY: CGFloat {
-        if layout is FloatingPanelFullScreenLayout{
-            return surfaceView.superview!.bounds.height - hiddenInset
-        } else {
-            return surfaceView.superview!.bounds.height - (safeAreaInsets.bottom + hiddenInset)
-        }
+        return bottomY + layout.bottomInteractionBuffer
     }
 
     var adjustedContentInsets: UIEdgeInsets {
@@ -249,13 +218,30 @@ class FloatingPanelLayoutAdapter {
     func positionY(for pos: FloatingPanelPosition) -> CGFloat {
         switch pos {
         case .full:
-            return topY
+            switch layout {
+            case is FloatingPanelIntrinsicLayout:
+                return surfaceView.superview!.bounds.height - surfaceView.bounds.height
+            case is FloatingPanelFullScreenLayout:
+                return fullInset
+            default:
+                return (safeAreaInsets.top + fullInset)
+            }
         case .half:
-            return middleY
+            switch layout {
+            case is FloatingPanelFullScreenLayout:
+                return surfaceView.superview!.bounds.height - halfInset
+            default:
+                return surfaceView.superview!.bounds.height - (safeAreaInsets.bottom + halfInset)
+            }
         case .tip:
-            return bottomY
+            switch layout {
+            case is FloatingPanelFullScreenLayout:
+                return surfaceView.superview!.bounds.height - tipInset
+            default:
+                return surfaceView.superview!.bounds.height - (safeAreaInsets.bottom + tipInset)
+            }
         case .hidden:
-            return hiddenY
+            return surfaceView.superview!.bounds.height - hiddenInset
         }
     }
 
@@ -289,7 +275,7 @@ class FloatingPanelLayoutAdapter {
                   ", content safe area(bottom) =", safeAreaBottom)
     }
 
-    func prepareLayout(in vc: UIViewController) {
+    func prepareLayout(in vc: FloatingPanelController) {
         self.vc = vc
 
         NSLayoutConstraint.deactivate(fixedConstraints + fullConstraints + halfConstraints + tipConstraints + offConstraints)
@@ -351,18 +337,19 @@ class FloatingPanelLayoutAdapter {
         ]
     }
 
-    func startInteraction(at state: FloatingPanelPosition) {
+    func startInteraction(at state: FloatingPanelPosition, offset: CGPoint = .zero) {
+        guard self.interactiveTopConstraint == nil else { return }
         NSLayoutConstraint.deactivate(fullConstraints + halfConstraints + tipConstraints + offConstraints)
 
         let interactiveTopConstraint: NSLayoutConstraint
         switch layout {
         case is FloatingPanelIntrinsicLayout,
              is FloatingPanelFullScreenLayout:
-            initialConst = surfaceView.frame.minY
+            initialConst = surfaceView.frame.minY + offset.y
             interactiveTopConstraint = surfaceView.topAnchor.constraint(equalTo: vc.view.topAnchor,
                                                                         constant: initialConst)
         default:
-            initialConst = surfaceView.frame.minY - safeAreaInsets.top
+            initialConst = surfaceView.frame.minY - safeAreaInsets.top + offset.y
             interactiveTopConstraint = surfaceView.topAnchor.constraint(equalTo: vc.layoutGuide.topAnchor,
                                                                         constant: initialConst)
         }
@@ -427,13 +414,14 @@ class FloatingPanelLayoutAdapter {
         }()
         let bottomMostConst: CGFloat = {
             var ret: CGFloat = 0.0
+            let _bottomY = vc.isRemovalInteractionEnabled ? positionY(for: .hidden) : bottomY
             switch layout {
             case is FloatingPanelIntrinsicLayout, is FloatingPanelFullScreenLayout:
-                ret = bottomY
+                ret = _bottomY
             default:
-                ret = bottomY - safeAreaInsets.top
+                ret = _bottomY - safeAreaInsets.top
             }
-            return min(ret, bottomMaxY)
+            return min(ret, surfaceView.superview!.bounds.height)
         }()
         let minConst = allowsTopBuffer ? topMostConst - layout.topInteractionBuffer : topMostConst
         let maxConst = bottomMostConst + layout.bottomInteractionBuffer
@@ -466,6 +454,7 @@ class FloatingPanelLayoutAdapter {
     func activateLayout(of state: FloatingPanelPosition) {
         defer {
             surfaceView.superview!.layoutIfNeeded()
+            log.debug("activateLayout -- surface.presentation = \(self.surfaceView.presentationFrame) surface.frame = \(self.surfaceView.frame)")
         }
 
         var state = state
@@ -479,7 +468,7 @@ class FloatingPanelLayoutAdapter {
         }
         NSLayoutConstraint.activate(fixedConstraints)
 
-        if supportedPositions.union([.hidden]).contains(state) == false {
+        if isValid(state) == false {
             state = layout.initialPosition
         }
 
@@ -496,6 +485,10 @@ class FloatingPanelLayoutAdapter {
         }
     }
 
+    func isValid(_ state: FloatingPanelPosition) -> Bool {
+        return supportedPositions.union([.hidden]).contains(state)
+    }
+
     private func setBackdropAlpha(of target: FloatingPanelPosition) {
         if target == .hidden {
             self.backdropView.alpha = 0.0
@@ -507,7 +500,7 @@ class FloatingPanelLayoutAdapter {
     private func checkLayoutConsistance() {
         // Verify layout configurations
         assert(supportedPositions.count > 0)
-        assert(supportedPositions.union([.hidden]).contains(layout.initialPosition),
+        assert(supportedPositions.contains(layout.initialPosition),
                "Does not include an initial position (\(layout.initialPosition)) in supportedPositions (\(supportedPositions))")
 
         if layout is FloatingPanelIntrinsicLayout {
@@ -526,4 +519,38 @@ class FloatingPanelLayoutAdapter {
             assert(bottomY > topY, "Invalid insets { topY: \(topY), bottomY: \(bottomY) }")
          }*/
     }
+
+    func segument(at posY: CGFloat, forward: Bool) -> LayoutSegment {
+        /// ----------------------->Y
+        /// --> forward                <-- backward
+        /// |-------|===o===|-------|  |-------|-------|===o===|
+        /// |-------|-------x=======|  |-------|=======x-------|
+        /// |-------|-------|===o===|  |-------|===o===|-------|
+        /// pos: o/x, seguement: =
+        let sortedPositions = supportedPositions.sorted(by: { $0.rawValue < $1.rawValue })
+
+        let upperIndex: Int?
+        if forward {
+            #if swift(>=4.2)
+            upperIndex = sortedPositions.firstIndex(where: { posY < positionY(for: $0) })
+            #else
+            upperIndex = sortedPositions.index(where: { posY < positionY(for: $0) })
+            #endif
+        } else {
+            #if swift(>=4.2)
+            upperIndex = sortedPositions.firstIndex(where: { posY <= positionY(for: $0) })
+            #else
+            upperIndex = sortedPositions.index(where: { posY <= positionY(for: $0) })
+            #endif
+        }
+
+        switch upperIndex {
+        case 0:
+            return LayoutSegment(lower: nil, upper: sortedPositions.first)
+        case let upperIndex?:
+            return LayoutSegment(lower: sortedPositions[upperIndex - 1], upper: sortedPositions[upperIndex])
+        default:
+            return LayoutSegment(lower: sortedPositions[sortedPositions.endIndex - 1], upper: nil)
+        }
+    }
 }

Framework/Sources/Info.plist

@@ -15,7 +15,7 @@
 	<key>CFBundlePackageType</key>
 	<string>FMWK</string>
 	<key>CFBundleShortVersionString</key>
-	<string>1.6.2</string>
+	<string>1.6.4</string>
 	<key>CFBundleVersion</key>
 	<string>$(CURRENT_PROJECT_VERSION)</string>
 </dict>

Framework/Sources/UIExtensions.swift

@@ -60,6 +60,10 @@ extension UIView {
             return self
         }
     }
+
+    var presentationFrame: CGRect {
+        return layer.presentation()?.frame ?? frame
+    }
 }
 
 extension UIView {

Framework/Tests/FloatingPanelControllerTests.swift

@@ -7,9 +7,7 @@ import XCTest
 @testable import FloatingPanel
 
 class FloatingPanelControllerTests: XCTestCase {
-
     override func setUp() {}
-
     override func tearDown() {}
 
     func test_warningRetainCycle() {
@@ -52,6 +50,63 @@ class FloatingPanelControllerTests: XCTestCase {
         XCTAssertEqual(traitCollection.userInterfaceStyle, .dark)
         fpc.prepare(for: traitCollection)
     }
+
+    func test_moveTo() {
+        let fpc = FloatingPanelController(delegate: nil)
+        fpc.showForTest()
+        fpc.move(to: .full, animated: false)
+        XCTAssertEqual(fpc.position, .full)
+        XCTAssertEqual(fpc.surfaceView.frame.minY, fpc.originYOfSurface(for: .full))
+
+        fpc.move(to: .half, animated: false)
+        XCTAssertEqual(fpc.position, .half)
+        XCTAssertEqual(fpc.surfaceView.frame.minY, fpc.originYOfSurface(for: .half))
+
+        fpc.move(to: .tip, animated: false)
+        XCTAssertEqual(fpc.position, .tip)
+        XCTAssertEqual(fpc.surfaceView.frame.minY, fpc.originYOfSurface(for: .tip))
+
+        fpc.move(to: .hidden, animated: false)
+        XCTAssertEqual(fpc.position, .hidden)
+        XCTAssertEqual(fpc.surfaceView.frame.minY, fpc.originYOfSurface(for: .hidden))
+
+        fpc.move(to: .full, animated: true)
+        waitRunLoop(secs: 0.3)
+        XCTAssertEqual(fpc.position, .full)
+        XCTAssertEqual(fpc.surfaceView.frame.minY, fpc.originYOfSurface(for: .full))
+
+        fpc.move(to: .half, animated: true)
+        waitRunLoop(secs: 0.3)
+        XCTAssertEqual(fpc.position, .half)
+        XCTAssertEqual(fpc.surfaceView.frame.minY, fpc.originYOfSurface(for: .half))
+
+        fpc.move(to: .tip, animated: true)
+        waitRunLoop(secs: 0.3)
+        XCTAssertEqual(fpc.position, .tip)
+        XCTAssertEqual(fpc.surfaceView.frame.minY, fpc.originYOfSurface(for: .tip))
+
+        fpc.move(to: .hidden, animated: true)
+        waitRunLoop(secs: 0.3)
+        XCTAssertEqual(fpc.position, .hidden)
+        XCTAssertEqual(fpc.surfaceView.frame.minY, fpc.originYOfSurface(for: .hidden))
+
+    }
+
+    func test_originSurfaceY() {
+        let fpc = FloatingPanelController(delegate: nil)
+        fpc.loadViewIfNeeded()
+        fpc.view.frame = CGRect(x: 0, y: 0, width: 375, height: 667)
+        fpc.show(animated: false, completion: nil)
+
+        fpc.move(to: .full, animated: false)
+        XCTAssertEqual(fpc.surfaceView.frame.minY, fpc.originYOfSurface(for: .full))
+        fpc.move(to: .half, animated: false)
+        XCTAssertEqual(fpc.surfaceView.frame.minY, fpc.originYOfSurface(for: .half))
+        fpc.move(to: .tip, animated: false)
+        XCTAssertEqual(fpc.surfaceView.frame.minY, fpc.originYOfSurface(for: .tip))
+        fpc.move(to: .hidden, animated: false)
+        XCTAssertEqual(fpc.surfaceView.frame.minY, fpc.originYOfSurface(for: .hidden))
+    }
 }
 
 private class MyZombieViewController: UIViewController, FloatingPanelLayout, FloatingPanelBehavior, FloatingPanelControllerDelegate {

Framework/Tests/FloatingPanelLayoutTests.swift

@@ -7,13 +7,15 @@ import XCTest
 @testable import FloatingPanel
 
 class FloatingPanelLayoutTests: XCTestCase {
-    override func setUp() {}
+    var fpc: FloatingPanelController!
+    override func setUp() {
+        fpc = FloatingPanelController(delegate: nil)
+        fpc.loadViewIfNeeded()
+        fpc.view.frame = CGRect(x: 0, y: 0, width: 375, height: 667)
+    }
     override func tearDown() {}
 
     func test_layoutAdapter_topAndBottomMostState() {
-        let fpc = FloatingPanelController(delegate: nil)
-        fpc.loadViewIfNeeded()
-        fpc.view.frame = CGRect(x: 0, y: 0, width: 375, height: 667)
         XCTAssertEqual(fpc.floatingPanel.layoutAdapter.topMostState, .full)
         XCTAssertEqual(fpc.floatingPanel.layoutAdapter.bottomMostState, .tip)
 
@@ -31,11 +33,174 @@ class FloatingPanelLayoutTests: XCTestCase {
         delegate.layout = FloatingPanelLayoutWithHidden()
         fpc.delegate = delegate
         XCTAssertEqual(fpc.floatingPanel.layoutAdapter.topMostState, .full)
-        XCTAssertEqual(fpc.floatingPanel.layoutAdapter.bottomMostState, .half) // Will fixed on fix-hidden-position branch
+        XCTAssertEqual(fpc.floatingPanel.layoutAdapter.bottomMostState, .hidden)
 
         delegate.layout = FloatingPanelLayout2Positions()
         fpc.delegate = delegate
         XCTAssertEqual(fpc.floatingPanel.layoutAdapter.topMostState, .half)
         XCTAssertEqual(fpc.floatingPanel.layoutAdapter.bottomMostState, .tip)
     }
+
+    func test_layoutSegment_3position() {
+        class FloatingPanelLayout3Positions: FloatingPanelTestLayout {
+            let initialPosition: FloatingPanelPosition = .half
+            let supportedPositions: Set<FloatingPanelPosition> = [.tip, .half, .full]
+        }
+
+        let delegate = FloatingPanelTestDelegate()
+        delegate.layout = FloatingPanelLayout3Positions()
+        fpc.delegate = delegate
+
+        let fullPos = fpc.originYOfSurface(for: .full)
+        let halfPos = fpc.originYOfSurface(for: .half)
+        let tipPos = fpc.originYOfSurface(for: .tip)
+
+        let minPos = CGFloat.leastNormalMagnitude
+        let maxPos = CGFloat.greatestFiniteMagnitude
+
+        assertLayoutSegment(fpc.floatingPanel, with: [
+            (#line, pos: minPos, forwardY: true, lower: nil, upper: .full),
+            (#line, pos: minPos, forwardY: false, lower: nil, upper: .full),
+            (#line, pos: fullPos, forwardY: true, lower: .full, upper: .half),
+            (#line, pos: fullPos, forwardY: false, lower: nil,  upper: .full),
+            (#line, pos: halfPos, forwardY: true, lower: .half, upper: .tip),
+            (#line, pos: halfPos, forwardY: false, lower: .full,  upper: .half),
+            (#line, pos: tipPos, forwardY: true, lower: .tip, upper: nil),
+            (#line, pos: tipPos, forwardY: false, lower: .half,  upper: .tip),
+            (#line, pos: maxPos, forwardY: true, lower: .tip, upper: nil),
+            (#line, pos: maxPos, forwardY: false, lower: .tip, upper: nil),
+            ])
+    }
+
+    func test_layoutSegment_2positions() {
+        class FloatingPanelLayout2Positions: FloatingPanelTestLayout {
+            let initialPosition: FloatingPanelPosition = .half
+            let supportedPositions: Set<FloatingPanelPosition> = [.half, .full]
+        }
+
+        let delegate = FloatingPanelTestDelegate()
+        delegate.layout = FloatingPanelLayout2Positions()
+        fpc.delegate = delegate
+
+        let fullPos = fpc.originYOfSurface(for: .full)
+        let halfPos = fpc.originYOfSurface(for: .half)
+
+        let minPos = CGFloat.leastNormalMagnitude
+        let maxPos = CGFloat.greatestFiniteMagnitude
+
+        assertLayoutSegment(fpc.floatingPanel, with: [
+            (#line, pos: minPos, forwardY: true, lower: nil, upper: .full),
+            (#line, pos: minPos, forwardY: false, lower: nil, upper: .full),
+            (#line, pos: fullPos, forwardY: true, lower: .full, upper: .half),
+            (#line, pos: fullPos, forwardY: false, lower: nil,  upper: .full),
+            (#line, pos: halfPos, forwardY: true, lower: .half, upper: nil),
+            (#line, pos: halfPos, forwardY: false, lower: .full,  upper: .half),
+            (#line, pos: maxPos, forwardY: true, lower: .half, upper: nil),
+            (#line, pos: maxPos, forwardY: false, lower: .half, upper: nil),
+            ])
+    }
+
+    func test_layoutSegment_1positions() {
+        class FloatingPanelLayout1Positions: FloatingPanelTestLayout {
+            let initialPosition: FloatingPanelPosition = .full
+            let supportedPositions: Set<FloatingPanelPosition> = [.full]
+        }
+
+        let delegate = FloatingPanelTestDelegate()
+        delegate.layout = FloatingPanelLayout1Positions()
+        fpc.delegate = delegate
+
+        let fullPos = fpc.originYOfSurface(for: .full)
+
+        let minPos = CGFloat.leastNormalMagnitude
+        let maxPos = CGFloat.greatestFiniteMagnitude
+
+        assertLayoutSegment(fpc.floatingPanel, with: [
+            (#line, pos: minPos, forwardY: true, lower: nil, upper: .full),
+            (#line, pos: minPos, forwardY: false, lower: nil, upper: .full),
+            (#line, pos: fullPos, forwardY: true, lower: .full, upper: nil),
+            (#line, pos: fullPos, forwardY: false, lower: nil,  upper: .full),
+            (#line, pos: maxPos, forwardY: true, lower: .full, upper: nil),
+            (#line, pos: maxPos, forwardY: false, lower: .full, upper: nil),
+            ])
+    }
+
+    func test_updateInteractiveTopConstraint() {
+        fpc.showForTest()
+        fpc.move(to: .full, animated: false)
+
+        fpc.floatingPanel.layoutAdapter.startInteraction(at: fpc.position)
+        fpc.floatingPanel.layoutAdapter.startInteraction(at: fpc.position) // Should be ignore
+
+        let fullPos = fpc.originYOfSurface(for: .full)
+        let tipPos = fpc.originYOfSurface(for: .tip)
+
+        var pre: CGFloat
+        var next: CGFloat
+        pre = fpc.surfaceView.frame.minY
+        fpc.floatingPanel.layoutAdapter.updateInteractiveTopConstraint(diff: -100.0, allowsTopBuffer: false, with: fpc.behavior)
+        next = fpc.surfaceView.frame.minY
+        XCTAssertEqual(next, pre)
+
+        fpc.floatingPanel.layoutAdapter.updateInteractiveTopConstraint(diff: -100.0, allowsTopBuffer: true, with: fpc.behavior)
+        next = fpc.surfaceView.frame.minY
+        XCTAssertEqual(next, fullPos - fpc.layout.topInteractionBuffer)
+
+        fpc.floatingPanel.layoutAdapter.updateInteractiveTopConstraint(diff: 100.0, allowsTopBuffer: true, with: fpc.behavior)
+        next = fpc.surfaceView.frame.minY
+        XCTAssertEqual(next, fullPos + 100.0)
+
+        fpc.floatingPanel.layoutAdapter.updateInteractiveTopConstraint(diff: tipPos - fullPos, allowsTopBuffer: true, with: fpc.behavior)
+        next = fpc.surfaceView.frame.minY
+        XCTAssertEqual(next, tipPos)
+
+        fpc.floatingPanel.layoutAdapter.updateInteractiveTopConstraint(diff: tipPos - fullPos + 100.0, allowsTopBuffer: true, with: fpc.behavior)
+        next = fpc.surfaceView.frame.minY
+        XCTAssertEqual(next, tipPos + fpc.layout.bottomInteractionBuffer)
+
+        fpc.floatingPanel.layoutAdapter.endInteraction(at: fpc.position)
+    }
+
+    func test_updateInteractiveTopConstraintWithHidden() {
+        class FloatingPanelLayout2Positions: FloatingPanelTestLayout {
+            let initialPosition: FloatingPanelPosition = .hidden
+            let supportedPositions: Set<FloatingPanelPosition> = [.hidden, .full]
+        }
+        let delegate = FloatingPanelTestDelegate()
+        delegate.layout = FloatingPanelLayout2Positions()
+        fpc.delegate = delegate
+        fpc.showForTest()
+        fpc.move(to: .full, animated: false)
+
+        fpc.floatingPanel.layoutAdapter.startInteraction(at: fpc.position)
+
+        let fullPos = fpc.originYOfSurface(for: .full)
+        let hiddenPos = fpc.originYOfSurface(for: .hidden)
+
+        var pre: CGFloat
+        var next: CGFloat
+        pre = fpc.surfaceView.frame.minY
+        fpc.floatingPanel.layoutAdapter.updateInteractiveTopConstraint(diff: -100.0, allowsTopBuffer: false, with: fpc.behavior)
+        next = fpc.surfaceView.frame.minY
+        XCTAssertEqual(next, pre)
+
+        fpc.floatingPanel.layoutAdapter.updateInteractiveTopConstraint(diff: -100.0, allowsTopBuffer: true, with: fpc.behavior)
+        next = fpc.surfaceView.frame.minY
+        XCTAssertEqual(next, fullPos - fpc.layout.topInteractionBuffer)
+
+        fpc.floatingPanel.layoutAdapter.updateInteractiveTopConstraint(diff: hiddenPos - fullPos + 100.0, allowsTopBuffer: true, with: fpc.behavior)
+        next = fpc.surfaceView.frame.minY
+        XCTAssertEqual(next, hiddenPos + fpc.layout.bottomInteractionBuffer)
+
+        fpc.floatingPanel.layoutAdapter.endInteraction(at: fpc.position)
+    }
+}
+
+private typealias LayoutSegmentTestParameter = (UInt, pos: CGFloat, forwardY: Bool, lower: FloatingPanelPosition?, upper: FloatingPanelPosition?)
+private func assertLayoutSegment(_ floatingPanel: FloatingPanel, with params: [LayoutSegmentTestParameter]) {
+    params.forEach { (line, pos, forwardY, lowr, upper) in
+        let segument = floatingPanel.layoutAdapter.segument(at: pos, forward: forwardY)
+        XCTAssertEqual(segument.lower, lowr, line: line)
+        XCTAssertEqual(segument.upper, upper, line: line)
+    }
 }

Framework/Tests/FloatingPanelPositionTests.swift

@@ -0,0 +1,27 @@
+//
+//  Created by Shin Yamamoto on 2019/07/05.
+//  Copyright © 2019 scenee. All rights reserved.
+//
+
+import XCTest
+@testable import FloatingPanel
+
+class FloatingPanelPositionTests: XCTestCase {
+    override func setUp() { }
+    override func tearDown() { }
+
+    func test_nextAndPre() {
+        var positions: [FloatingPanelPosition]
+        positions = [.full, .half, .tip, .hidden]
+        XCTAssertEqual(FloatingPanelPosition.full.next(in: positions),  .half)
+        XCTAssertEqual(FloatingPanelPosition.full.pre(in: positions),  .full)
+        XCTAssertEqual(FloatingPanelPosition.hidden.next(in: positions), .hidden)
+        XCTAssertEqual(FloatingPanelPosition.hidden.pre(in: positions), .tip)
+
+        positions = [.full, .hidden]
+        XCTAssertEqual(FloatingPanelPosition.full.next(in: positions),  .hidden)
+        XCTAssertEqual(FloatingPanelPosition.full.pre(in: positions),  .full)
+        XCTAssertEqual(FloatingPanelPosition.hidden.next(in: positions), .hidden)
+        XCTAssertEqual(FloatingPanelPosition.hidden.pre(in: positions), .full)
+    }
+}

Framework/Tests/FloatingPanelSurfaceViewTests.swift

@@ -8,7 +8,6 @@ import XCTest
 
 class FloatingPanelSurfaceViewTests: XCTestCase {
     override func setUp() {}
-
     override func tearDown() {}
 
     func test_surfaceView() {

Framework/Tests/FloatingPanelTests.swift

@@ -7,22 +7,19 @@ import XCTest
 @testable import FloatingPanel
 
 class FloatingPanelTests: XCTestCase {
-
     override func setUp() {}
-
     override func tearDown() {}
 
     func test_scrolllock() {
         let fpc = FloatingPanelController()
-        fpc.loadViewIfNeeded()
-        fpc.view.frame = CGRect(x: 0, y: 0, width: 375, height: 667)
+
         let contentVC1 = UITableViewController(nibName: nil, bundle: nil)
         XCTAssertEqual(contentVC1.tableView.showsVerticalScrollIndicator, true)
         XCTAssertEqual(contentVC1.tableView.bounces, true)
-
         fpc.set(contentViewController: contentVC1)
         fpc.track(scrollView: contentVC1.tableView)
-        fpc.show(animated: false, completion: nil) // half
+        fpc.showForTest()
+
         XCTAssertEqual(fpc.position, .half)
         XCTAssertEqual(contentVC1.tableView.showsVerticalScrollIndicator, false)
         XCTAssertEqual(contentVC1.tableView.bounces, false)
@@ -63,16 +60,478 @@ class FloatingPanelTests: XCTestCase {
         XCTAssertEqual(contentVC2.tableView.bounces, false)
     }
 
-}
-
-private protocol FloatingPanelTestLayout: FloatingPanelLayout {}
-private extension FloatingPanelTestLayout {
-    func insetFor(position: FloatingPanelPosition) -> CGFloat? {
-        switch position {
-        case .full: return 18.0
-        case .half: return 262.0
-        case .tip: return 69.0
-        default: return nil
+    func test_getBackdropAlpha_1positions() {
+        class FloatingPanelLayout1Positions: FloatingPanelTestLayout {
+            let initialPosition: FloatingPanelPosition = .full
+            let supportedPositions: Set<FloatingPanelPosition> = [.full]
         }
+        let delegate = FloatingPanelTestDelegate()
+        delegate.layout = FloatingPanelLayout1Positions()
+
+        let fpc = FloatingPanelController(delegate: delegate)
+        fpc.showForTest()
+
+        let fullPos = fpc.originYOfSurface(for: .full)
+
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: fullPos - 100.0, with: CGPoint(x: 0.0, y: -100.0)), 0.3)
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: fullPos, with: CGPoint(x: 0.0, y: 0.0)), 0.3)
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: fullPos + 100.0, with: CGPoint(x: 0.0, y: 100.0)), 0.3) // ok??
+    }
+
+    func test_getBackdropAlpha_2positions() {
+        class FloatingPanelLayout2Positions: FloatingPanelTestLayout {
+            let initialPosition: FloatingPanelPosition = .half
+            let supportedPositions: Set<FloatingPanelPosition> = [.half, .full]
+        }
+        let delegate = FloatingPanelTestDelegate()
+        delegate.layout = FloatingPanelLayout2Positions()
+
+        let fpc = FloatingPanelController(delegate: delegate)
+        fpc.showForTest()
+
+        let fullPos = fpc.originYOfSurface(for: .full)
+        let halfPos = fpc.originYOfSurface(for: .half)
+        let distance1 = abs(halfPos - fullPos)
+
+        fpc.move(to: .full, animated: false)
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: fullPos, with: CGPoint(x: 0.0, y: 0.0)), 0.3)
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: fullPos + distance1 * 0.5, with: CGPoint(x: 0.0, y: distance1 * 0.5)), 0.3 * 0.5)
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: halfPos, with: CGPoint(x: 0.0, y: distance1)), 0.0)
+
+        fpc.move(to: .half, animated: false)
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: halfPos, with: CGPoint(x: 0.0, y: 0.0)), 0.0)
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: fullPos + distance1 * 0.5, with: CGPoint(x: 0.0, y: -0.5 * distance1)), 0.3 * 0.5)
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: fullPos, with: CGPoint(x: 0.0, y: -1 * distance1)), 0.3)
+    }
+
+    func test_getBackdropAlpha_2positionsWithHidden() {
+        class FloatingPanelLayout2Positions: FloatingPanelTestLayout {
+            let initialPosition: FloatingPanelPosition = .hidden
+            let supportedPositions: Set<FloatingPanelPosition> = [.hidden, .full]
+        }
+        let delegate = FloatingPanelTestDelegate()
+        delegate.layout = FloatingPanelLayout2Positions()
+
+        let fpc = FloatingPanelController(delegate: delegate)
+        fpc.showForTest()
+
+        let fullPos = fpc.originYOfSurface(for: .full)
+        let hiddenPos = fpc.originYOfSurface(for: .hidden)
+
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: fullPos - 100.0, with: CGPoint(x: 0.0, y: -100.0)), 0.3)
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: fullPos, with: CGPoint(x: 0.0, y: 0.0)), 0.3)
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: hiddenPos, with: CGPoint(x: 0.0, y: 100.0)), 0.0)
+    }
+
+    func test_getBackdropAlpha_3positions() {
+        let fpc = FloatingPanelController()
+        fpc.showForTest()
+
+        let fullPos = fpc.originYOfSurface(for: .full)
+        let halfPos = fpc.originYOfSurface(for: .half)
+        let tipPos = fpc.originYOfSurface(for: .tip)
+        let distance1 = abs(halfPos - fullPos)
+        let distance2 = abs(tipPos - halfPos)
+
+        fpc.move(to: .full, animated: false)
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: fullPos, with: CGPoint(x: 0.0, y: 0.0)), 0.3)
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: fullPos + distance1 * 0.5, with: CGPoint(x: 0.0, y: distance1 * 0.5)), 0.3 * 0.5)
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: halfPos, with: CGPoint(x: 0.0, y: distance1)), 0.0)
+
+        fpc.move(to: .half, animated: false)
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: halfPos, with: CGPoint(x: 0.0, y: 0.0)), 0.0)
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: fullPos + distance1 * 0.5, with: CGPoint(x: 0.0, y: -0.5 * distance1)), 0.3 * 0.5)
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: fullPos, with: CGPoint(x: 0.0, y: -1 * distance1)), 0.3)
+
+        fpc.move(to: .tip, animated: false)
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: tipPos, with: CGPoint(x: 0.0, y: 0.0)), 0.0)
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: halfPos + distance2 * 0.5, with: CGPoint(x: 0.0, y: -0.5 * distance2)), 0.0)
+        XCTAssertEqual(fpc.floatingPanel.getBackdropAlpha(at: halfPos, with: CGPoint(x: 0.0, y: -1 * distance2)), 0.0)
+    }
+
+    func test_targetPosition_1positions() {
+        class FloatingPanelLayout1Positions: FloatingPanelTestLayout {
+            let initialPosition: FloatingPanelPosition = .full
+            let supportedPositions: Set<FloatingPanelPosition> = [.full]
+        }
+        let delegate = FloatingPanelTestDelegate()
+        delegate.layout = FloatingPanelLayout1Positions()
+
+        let fpc = FloatingPanelController(delegate: delegate)
+        fpc.showForTest()
+
+        let fullPos = fpc.originYOfSurface(for: .full)
+
+        fpc.move(to: .full, animated: false)
+        assertTargetPosition(fpc.floatingPanel, with: [
+            (#line, fullPos - 10.0, CGPoint(x: 0.0, y: 1000.0), .full), // redirect
+            (#line, fullPos, CGPoint(x: 0.0, y: -1000.0), .full), // redirect
+            (#line, fullPos, CGPoint(x: 0.0, y: -100.0), .full), // redirect
+            (#line, fullPos, CGPoint(x: 0.0, y: 0.0), .full),
+            (#line, fullPos, CGPoint(x: 0.0, y: 100.0), .full), // redirect
+            (#line, fullPos, CGPoint(x: 0.0, y: 1000.0), .full), // redirect
+            (#line, fullPos + 10.0, CGPoint(x: 0.0, y: 100.0), .full), // redirect
+            ])
+    }
+
+    func test_targetPosition_2positions() {
+        class FloatingPanelLayout2Positions: FloatingPanelTestLayout {
+            let initialPosition: FloatingPanelPosition = .half
+            let supportedPositions: Set<FloatingPanelPosition> = [.half, .full]
+        }
+        let delegate = FloatingPanelTestDelegate()
+        delegate.layout = FloatingPanelLayout2Positions()
+
+        let fpc = FloatingPanelController(delegate: delegate)
+        fpc.showForTest()
+
+        let fullPos = fpc.originYOfSurface(for: .full)
+        let halfPos = fpc.originYOfSurface(for: .half)
+
+        fpc.move(to: .full, animated: false)
+        assertTargetPosition(fpc.floatingPanel, with: [
+            (#line, fullPos - 10.0, CGPoint(x: 0.0, y: 1000.0), .half), // project to half
+            (#line, fullPos, CGPoint(x: 0.0, y: -1000.0), .full), // redirect
+            (#line, fullPos, CGPoint(x: 0.0, y: -100.0), .full),
+            (#line, fullPos, CGPoint(x: 0.0, y: 0.0), .full),
+            (#line, fullPos, CGPoint(x: 0.0, y: 100.0), .full),
+            (#line, fullPos, CGPoint(x: 0.0, y: 1000.0), .half), // project to half
+            (#line, fullPos + 10.0, CGPoint(x: 0.0, y: 100.0), .full), // redirect
+            (#line, halfPos - 10.0, CGPoint(x: 0.0, y: -100.0), .half), // redirect
+            (#line, halfPos, CGPoint(x: 0.0, y: -1000.0), .full),  // project to full
+            (#line, halfPos, CGPoint(x: 0.0, y: -100.0), .half),
+            (#line, halfPos, CGPoint(x: 0.0, y: 0.0), .half),
+            (#line, halfPos, CGPoint(x: 0.0, y: 100.0), .half),
+            (#line, halfPos, CGPoint(x: 0.0, y: 1000.0), .half), // redirect
+            (#line, halfPos + 10.0, CGPoint(x: 0.0, y: -1000.0), .full), // project to full
+            ])
+        fpc.move(to: .half, animated: false)
+        assertTargetPosition(fpc.floatingPanel, with: [
+            (#line, fullPos - 10.0, CGPoint(x: 0.0, y: 1000.0), .half), // project to half
+            (#line, fullPos, CGPoint(x: 0.0, y: -1000.0), .full), // redirect
+            (#line, fullPos, CGPoint(x: 0.0, y: -100.0), .full),
+            (#line, fullPos, CGPoint(x: 0.0, y: 0.0), .full),
+            (#line, fullPos, CGPoint(x: 0.0, y: 100.0), .full),
+            (#line, fullPos, CGPoint(x: 0.0, y: 1000.0), .half), // project to half
+            (#line, fullPos + 10.0, CGPoint(x: 0.0, y: 100.0), .full), // redirect
+            (#line, halfPos - 10.0, CGPoint(x: 0.0, y: -100.0), .half), // redirect
+            (#line, halfPos, CGPoint(x: 0.0, y: -1000.0), .full),  // project to full
+            (#line, halfPos, CGPoint(x: 0.0, y: -100.0), .half),
+            (#line, halfPos, CGPoint(x: 0.0, y: 0.0), .half),
+            (#line, halfPos, CGPoint(x: 0.0, y: 100.0), .half),
+            (#line, halfPos, CGPoint(x: 0.0, y: 1000.0), .half), // redirect
+            (#line, halfPos + 10.0, CGPoint(x: 0.0, y: -1000.0), .full), // project to full
+            ])
+    }
+
+    func test_targetPosition_2positionsWithHidden() {
+        class FloatingPanelLayout2Positions: FloatingPanelTestLayout {
+            let initialPosition: FloatingPanelPosition = .hidden
+            let supportedPositions: Set<FloatingPanelPosition> = [.hidden, .full]
+        }
+        let delegate = FloatingPanelTestDelegate()
+        delegate.layout = FloatingPanelLayout2Positions()
+
+        let fpc = FloatingPanelController(delegate: delegate)
+        fpc.showForTest()
+
+        let fullPos = fpc.originYOfSurface(for: .full)
+        let hiddenPos = fpc.originYOfSurface(for: .hidden)
+
+        fpc.move(to: .full, animated: false)
+        assertTargetPosition(fpc.floatingPanel, with: [
+            (#line, fullPos - 10.0, CGPoint(x: 0.0, y: 1000.0), .hidden), // project to hidden
+            (#line, fullPos, CGPoint(x: 0.0, y: -1000.0), .full), // redirect
+            (#line, fullPos, CGPoint(x: 0.0, y: -100.0), .full),
+            (#line, fullPos, CGPoint(x: 0.0, y: 0.0), .full),
+            (#line, fullPos, CGPoint(x: 0.0, y: 100.0), .full),
+            (#line, fullPos, CGPoint(x: 0.0, y: 1000.0), .hidden), // project to hidden
+            (#line, fullPos + 10.0, CGPoint(x: 0.0, y: 100.0), .full), // redirect
+            (#line, hiddenPos - 10.0, CGPoint(x: 0.0, y: -100.0), .hidden), // redirect
+            (#line, hiddenPos, CGPoint(x: 0.0, y: -1000.0), .full),  // project to full
+            (#line, hiddenPos, CGPoint(x: 0.0, y: -100.0), .hidden),
+            (#line, hiddenPos, CGPoint(x: 0.0, y: 0.0), .hidden),
+            (#line, hiddenPos, CGPoint(x: 0.0, y: 100.0), .hidden),
+            (#line, hiddenPos, CGPoint(x: 0.0, y: 1000.0), .hidden), // redirect
+            (#line, hiddenPos + 10.0, CGPoint(x: 0.0, y: -1000.0), .full), // project to full
+            ])
+        fpc.move(to: .hidden, animated: false)
+        assertTargetPosition(fpc.floatingPanel, with: [
+            (#line, fullPos - 10.0, CGPoint(x: 0.0, y: 1000.0), .hidden), // project to hidden
+            (#line, fullPos, CGPoint(x: 0.0, y: -1000.0), .full), // redirect
+            (#line, fullPos, CGPoint(x: 0.0, y: -100.0), .full),
+            (#line, fullPos, CGPoint(x: 0.0, y: 0.0), .full),
+            (#line, fullPos, CGPoint(x: 0.0, y: 100.0), .full),
+            (#line, fullPos, CGPoint(x: 0.0, y: 1000.0), .hidden), // project to hidden
+            (#line, fullPos + 10.0, CGPoint(x: 0.0, y: 100.0), .full), // redirect
+            (#line, hiddenPos - 10.0, CGPoint(x: 0.0, y: -100.0), .hidden), // redirect
+            (#line, hiddenPos, CGPoint(x: 0.0, y: -1000.0), .full),  // project to full
+            (#line, hiddenPos, CGPoint(x: 0.0, y: -100.0), .hidden),
+            (#line, hiddenPos, CGPoint(x: 0.0, y: 0.0), .hidden),
+            (#line, hiddenPos, CGPoint(x: 0.0, y: 100.0), .hidden),
+            (#line, hiddenPos, CGPoint(x: 0.0, y: 1000.0), .hidden), // redirect
+            (#line, hiddenPos + 10.0, CGPoint(x: 0.0, y: -1000.0), .full), // project to full
+            ])
+    }
+
+    func test_targetPosition_2positionsFromFull() {
+        let delegate = FloatingPanelTestDelegate()
+        delegate.layout = FloatingPanelLayout3Positions()
+        let fpc = FloatingPanelController(delegate: delegate)
+        fpc.showForTest()
+
+        let fullPos = fpc.originYOfSurface(for: .full)
+        let halfPos = fpc.originYOfSurface(for: .half)
+        let tipPos = fpc.originYOfSurface(for: .tip)
+        // From .full
+        fpc.move(to: .full, animated: false)
+        assertTargetPosition(fpc.floatingPanel, with: [
+            (#line, fullPos - 500.0, CGPoint(x: 0.0, y: -100.0), .full), // far from topMostState
+            (#line, fullPos - 500.0, CGPoint(x: 0.0, y: 0.0), .full), // far from topMostState
+            (#line, fullPos - 500.0, CGPoint(x: 0.0, y: 100.0), .full), // far from topMostState
+            (#line, fullPos - 10.0, CGPoint(x: 0.0, y: 3000.0), .half), // block projecting to tip at half
+            (#line, fullPos, CGPoint(x: 0.0, y: -100.0), .full),
+            (#line, fullPos, CGPoint(x: 0.0, y: 0.0), .full),
+            (#line, fullPos, CGPoint(x: 0.0, y: 500.0), .half), // project to half
+            (#line, fullPos, CGPoint(x: 0.0, y: 1000.0), .half), // block projecting to tip at half
+            (#line, fullPos, CGPoint(x: 0.0, y: 3000.0), .half), // block projecting to tip at half
+            (#line, fullPos + 10.0, CGPoint(x: 0.0, y: 100.0), .full), // redirect
+            (#line, halfPos - 10.0, CGPoint(x: 0.0, y: -100.0), .half), // redirect
+            (#line, halfPos, CGPoint(x: 0.0, y: -1000.0), .full), //project to full
+            (#line, halfPos, CGPoint(x: 0.0, y: -100.0), .half),
+            (#line, halfPos, CGPoint(x: 0.0, y: 0.0), .half),
+            (#line, halfPos, CGPoint(x: 0.0, y: 100.0), .half),
+            (#line, halfPos, CGPoint(x: 0.0, y: 1000.0), .tip), // project to tip
+            (#line, halfPos + 10.0, CGPoint(x: 0.0, y: 100.0), .half), // redirect
+            (#line, tipPos - 10.0, CGPoint(x: 0.0, y: -100.0), .tip), // redirect
+            (#line, tipPos, CGPoint(x: 0.0, y: -3000.0), .half), // block projecting to full at half
+            (#line, tipPos, CGPoint(x: 0.0, y: -1000.0), .half), // block projecting to full at half
+            (#line, tipPos, CGPoint(x: 0.0, y: -500.0), .half), // project to half
+            (#line, tipPos, CGPoint(x: 0.0, y: -100.0), .tip),
+            (#line, tipPos, CGPoint(x: 0.0, y: 0.0), .tip),
+            (#line, tipPos, CGPoint(x: 0.0, y: 100.0), .tip),
+            (#line, tipPos + 10.0, CGPoint(x: 0.0, y: -3000.0), .half), // block projecting to full at half
+            (#line, tipPos + 500.0, CGPoint(x: 0.0, y: -100.0), .tip), // far from bottomMostState
+            (#line, tipPos + 500.0, CGPoint(x: 0.0, y: 0.0), .tip), // far from bottomMostState
+            (#line, tipPos + 500.0, CGPoint(x: 0.0, y: 100.0), .tip), // far from bottomMostState
+            ])
+    }
+
+    func test_targetPosition_3positionsFromHalf() {
+        let delegate = FloatingPanelTestDelegate()
+        delegate.layout = FloatingPanelLayout3Positions()
+        let fpc = FloatingPanelController(delegate: delegate)
+        fpc.showForTest()
+
+        let fullPos = fpc.originYOfSurface(for: .full)
+        let halfPos = fpc.originYOfSurface(for: .half)
+        let tipPos = fpc.originYOfSurface(for: .tip)
+        // From .half
+        fpc.move(to: .half, animated: false)
+        assertTargetPosition(fpc.floatingPanel, with: [
+            (#line, fullPos - 500.0, CGPoint(x: 0.0, y: -100.0), .full), // far from topMostState
+            (#line, fullPos - 500.0, CGPoint(x: 0.0, y: 0.0), .full), // far from topMostState
+            (#line, fullPos - 500.0, CGPoint(x: 0.0, y: 100.0), .full), // far from topMostState
+            (#line, fullPos, CGPoint(x: 0.0, y: -100.0), .full),
+            (#line, fullPos, CGPoint(x: 0.0, y: 0.0), .full),
+            (#line, fullPos, CGPoint(x: 0.0, y: 500.0), .half), // project to half
+            (#line, fullPos, CGPoint(x: 0.0, y: 1000.0), .half), // block projecting to tip at half
+            (#line, fullPos, CGPoint(x: 0.0, y: 3000.0), .half), // block projecting to tip at half
+            (#line, fullPos + 10.0, CGPoint(x: 0.0, y: 100.0), .full), // redirect
+            (#line, halfPos - 10.0, CGPoint(x: 0.0, y: -100.0), .half), // redirect
+            (#line, halfPos, CGPoint(x: 0.0, y: -1000.0), .full),// project to full
+            (#line, halfPos, CGPoint(x: 0.0, y: -100.0), .half),
+            (#line, halfPos, CGPoint(x: 0.0, y: 0.0), .half),
+            (#line, halfPos, CGPoint(x: 0.0, y: 100.0), .half),
+            (#line, halfPos, CGPoint(x: 0.0, y: 1000.0), .tip), // project to tip
+            (#line, halfPos + 10.0, CGPoint(x: 0.0, y: 100.0), .half), // redirect
+            (#line, tipPos - 10.0, CGPoint(x: 0.0, y: -100.0), .tip), // redirect
+            (#line, tipPos, CGPoint(x: 0.0, y: -3000.0), .half), // block projecting to full at half
+            (#line, tipPos, CGPoint(x: 0.0, y: -1000.0), .half), // block projecting to full at half
+            (#line, tipPos, CGPoint(x: 0.0, y: -500.0), .half), // project to half
+            (#line, tipPos, CGPoint(x: 0.0, y: -100.0), .tip),
+            (#line, tipPos, CGPoint(x: 0.0, y: 0.0), .tip),
+            (#line, tipPos, CGPoint(x: 0.0, y: 100.0), .tip),
+            (#line, tipPos + 500.0, CGPoint(x: 0.0, y: -100.0), .tip), // far from bottomMostState
+            (#line, tipPos + 500.0, CGPoint(x: 0.0, y: 0.0), .tip), // far from bottomMostState
+            (#line, tipPos + 500.0, CGPoint(x: 0.0, y: 100.0), .tip), // far from bottomMostState
+            ])
+    }
+
+    func test_targetPosition_3positionsFromTip() {
+        let delegate = FloatingPanelTestDelegate()
+        delegate.layout = FloatingPanelLayout3Positions()
+        let fpc = FloatingPanelController(delegate: delegate)
+        fpc.showForTest()
+
+        let fullPos = fpc.originYOfSurface(for: .full)
+        let halfPos = fpc.originYOfSurface(for: .half)
+        let tipPos = fpc.originYOfSurface(for: .tip)
+
+        // From .tip
+        fpc.move(to: .tip, animated: false)
+        assertTargetPosition(fpc.floatingPanel, with: [
+            (#line, fullPos - 500.0, CGPoint(x: 0.0, y: -100.0), .full), // far from topMostState
+            (#line, fullPos - 500.0, CGPoint(x: 0.0, y: 0.0), .full), // far from topMostState
+            (#line, fullPos - 500.0, CGPoint(x: 0.0, y: 100.0), .full), // far from topMostState
+            (#line, fullPos, CGPoint(x: 0.0, y: -100.0), .full),
+            (#line, fullPos, CGPoint(x: 0.0, y: 0.0), .full),
+            (#line, fullPos, CGPoint(x: 0.0, y: 500.0), .half), // project to half
+            (#line, fullPos, CGPoint(x: 0.0, y: 1000.0), .half), // block projecting to tip at half
+            (#line, fullPos, CGPoint(x: 0.0, y: 3000.0), .half), // block projecting to tip at half
+            (#line, fullPos + 10.0, CGPoint(x: 0.0, y: 100.0), .full), // redirect
+            (#line, halfPos - 10.0, CGPoint(x: 0.0, y: -100.0), .half), // redirect
+            (#line, halfPos, CGPoint(x: 0.0, y: -3000.0), .full), // project to full
+            (#line, halfPos, CGPoint(x: 0.0, y: -100.0), .half),
+            (#line, halfPos, CGPoint(x: 0.0, y: 0.0), .half),
+            (#line, halfPos, CGPoint(x: 0.0, y: 100.0), .half),
+            (#line, halfPos, CGPoint(x: 0.0, y: 1000.0), .tip), // project to tip
+            (#line, halfPos + 10.0, CGPoint(x: 0.0, y: 100.0), .half), // redirect
+            (#line, tipPos - 10.0, CGPoint(x: 0.0, y: -100.0), .tip), // redirect
+            (#line, tipPos, CGPoint(x: 0.0, y: -3000.0), .half), // block projecting to full at half
+            (#line, tipPos, CGPoint(x: 0.0, y: -1000.0), .half), // block projecting to full at half
+            (#line, tipPos, CGPoint(x: 0.0, y: -500.0), .half), // project to half
+            (#line, tipPos, CGPoint(x: 0.0, y: -100.0), .tip),
+            (#line, tipPos, CGPoint(x: 0.0, y: 0.0), .tip),
+            (#line, tipPos, CGPoint(x: 0.0, y: 100.0), .tip),
+            (#line, tipPos + 500.0, CGPoint(x: 0.0, y: -100.0), .tip), // far from bottomMostState
+            (#line, tipPos + 500.0, CGPoint(x: 0.0, y: 0.0), .tip), // far from bottomMostState
+            (#line, tipPos + 500.0, CGPoint(x: 0.0, y: 100.0), .tip), // far from bottomMostState
+            ])
+    }
+
+    func test_targetPosition_3positionsAllProjection() {
+        let delegate = FloatingPanelTestDelegate()
+        delegate.layout = FloatingPanelLayout3Positions()
+        delegate.behavior = FloatingPanelProjectionalBehavior()
+
+        let fpc = FloatingPanelController(delegate: delegate)
+        fpc.showForTest()
+
+        let fullPos = fpc.originYOfSurface(for: .full)
+        let halfPos = fpc.originYOfSurface(for: .half)
+        let tipPos = fpc.originYOfSurface(for: .tip)
+
+        // From .full
+        fpc.move(to: .full, animated: false)
+        assertTargetPosition(fpc.floatingPanel, with: [
+            (#line, fullPos - 10.0, CGPoint(x: 0.0, y: 3000.0), .tip),
+            (#line, fullPos, CGPoint(x: 0.0, y: 1000.0), .tip),
+            (#line, fullPos, CGPoint(x: 0.0, y: 3000.0), .tip),
+            (#line, halfPos, CGPoint(x: 0.0, y: 1000.0), .tip),
+            (#line, halfPos, CGPoint(x: 0.0, y: -1000.0), .full),
+            (#line, tipPos, CGPoint(x: 0.0, y: -3000.0), .full),
+            (#line, tipPos, CGPoint(x: 0.0, y: -1000.0), .full),
+            (#line, tipPos + 10.0, CGPoint(x: 0.0, y: -3000.0), .full),
+            ])
+
+        // From .half
+        fpc.move(to: .tip, animated: false)
+        assertTargetPosition(fpc.floatingPanel, with: [
+            (#line, fullPos, CGPoint(x: 0.0, y: 1000.0), .tip),
+            (#line, fullPos, CGPoint(x: 0.0, y: 3000.0), .tip),
+            (#line, tipPos, CGPoint(x: 0.0, y: -3000.0), .full),
+            (#line, tipPos, CGPoint(x: 0.0, y: -1000.0), .full),
+            ])
+
+        // From .tip
+        fpc.move(to: .tip, animated: false)
+        assertTargetPosition(fpc.floatingPanel, with: [
+            (#line, fullPos - 10.0, CGPoint(x: 0.0, y: 3000.0), .tip),
+            (#line, fullPos, CGPoint(x: 0.0, y: 1000.0), .tip),
+            (#line, fullPos, CGPoint(x: 0.0, y: 3000.0), .tip),
+            (#line, halfPos, CGPoint(x: 0.0, y: 1000.0), .tip),
+            (#line, halfPos, CGPoint(x: 0.0, y: -1000.0), .full),
+            (#line, tipPos, CGPoint(x: 0.0, y: -3000.0), .full),
+            (#line, tipPos, CGPoint(x: 0.0, y: -1000.0), .full),
+            (#line, tipPos + 10.0, CGPoint(x: 0.0, y: -3000.0), .full),
+            ])
+    }
+
+    func test_targetPosition_3positionsWithHidden() {
+        class FloatingPanelLayout3PositionsWithHidden: FloatingPanelTestLayout {
+            let initialPosition: FloatingPanelPosition = .hidden
+            let supportedPositions: Set<FloatingPanelPosition> = [.hidden, .half, .full]
+        }
+        let delegate = FloatingPanelTestDelegate()
+        delegate.layout = FloatingPanelLayout3PositionsWithHidden()
+
+        let fpc = FloatingPanelController(delegate: delegate)
+        fpc.showForTest()
+        XCTAssertEqual(fpc.position, .hidden)
+
+        fpc.move(to: .full, animated: false)
+        assertTargetPosition(fpc.floatingPanel, with: [
+            (#line, fpc.surfaceView.frame.minY, CGPoint(x: 0.0, y: 1000.0), .half),
+            ])
+        fpc.move(to: .half, animated: false)
+        assertTargetPosition(fpc.floatingPanel, with: [
+            (#line, fpc.surfaceView.frame.minY, CGPoint(x: 0.0, y: -100.0), .half),
+            (#line, fpc.surfaceView.frame.minY, CGPoint(x: 0.0, y: -1000.0), .full),
+            (#line, fpc.surfaceView.frame.minY, CGPoint(x: 0.0, y: 0.0), .half),
+            (#line, fpc.surfaceView.frame.minY, CGPoint(x: 0.0, y: 1000.0), .hidden),
+            ])
+    }
+
+    func test_targetPosition_3positionsWithHiddenWithoutFull() {
+        class FloatingPanelLayout3Positions: FloatingPanelTestLayout {
+            let initialPosition: FloatingPanelPosition = .hidden
+            let supportedPositions: Set<FloatingPanelPosition> = [.hidden, .tip, .half]
+        }
+
+        let delegate = FloatingPanelTestDelegate()
+        delegate.layout = FloatingPanelLayout3Positions()
+        delegate.behavior = FloatingPanelProjectionalBehavior()
+
+        let fpc = FloatingPanelController(delegate: delegate)
+        fpc.showForTest()
+        XCTAssertEqual(fpc.position, .hidden)
+
+        let halfPos = fpc.originYOfSurface(for: .half)
+        let tipPos = fpc.originYOfSurface(for: .tip)
+        //let hiddenPos = fpc.originYOfSurface(for: .hidden)
+
+        fpc.move(to: .half, animated: false)
+        assertTargetPosition(fpc.floatingPanel, with: [
+            (#line, halfPos, CGPoint(x: 0.0, y: -100.0), .half),
+            (#line, halfPos, CGPoint(x: 0.0, y: 0.0), .half),
+            (#line, halfPos, CGPoint(x: 0.0, y: 385.0), .tip), // projection
+            (#line, halfPos, CGPoint(x: 0.0, y: 1000.0), .hidden), // projection
+            (#line, halfPos + 10.0, CGPoint(x: 0.0, y: 100.0), .half), // redirection
+            (#line, tipPos - 10.0, CGPoint(x: 0.0, y: -100.0), .tip), // redirection
+            (#line, tipPos, CGPoint(x: 0.0, y: -3000.0), .half), //projection
+            (#line, tipPos, CGPoint(x: 0.0, y: -10.0), .tip),
+            (#line, tipPos, CGPoint(x: 0.0, y: 0.0), .tip),
+            (#line, tipPos, CGPoint(x: 0.0, y: 10.0), .tip),
+            (#line, tipPos, CGPoint(x: 0.0, y: 1000.0), .hidden), //projection
+            (#line, tipPos + 10.0, CGPoint(x: 0.0, y: 10.0), .tip), // redirection
+            (#line, tipPos - 10.0, CGPoint(x: 0.0, y: 10.0), .tip), // redirection
+            ])
+        fpc.move(to: .tip, animated: false)
+        assertTargetPosition(fpc.floatingPanel, with: [
+            (#line, tipPos, CGPoint(x: 0.0, y: -100.0), .tip),
+            (#line, tipPos, CGPoint(x: 0.0, y: -1000.0), .half),
+            (#line, tipPos, CGPoint(x: 0.0, y: 0.0), .tip),
+            (#line, tipPos, CGPoint(x: 0.0, y: 1000.0), .hidden),
+            ])
+    }
+}
+
+private class FloatingPanelLayout3Positions: FloatingPanelTestLayout {
+    let initialPosition: FloatingPanelPosition = .tip
+    let supportedPositions: Set<FloatingPanelPosition> = [.tip, .half, .full]
+}
+
+private typealias TestParameter = (UInt, CGFloat,CGPoint, FloatingPanelPosition)
+private func assertTargetPosition(_ floatingPanel: FloatingPanel, with params: [TestParameter]) {
+    params.forEach { (line, pos, velocity, result) in
+        floatingPanel.surfaceView.frame.origin.y = pos
+        XCTAssertEqual(floatingPanel.targetPosition(from: pos, with: velocity), result, line: line)
+    }
+}
+
+private class FloatingPanelProjectionalBehavior: FloatingPanelBehavior {
+    func shouldProjectMomentum(_ fpc: FloatingPanelController, for proposedTargetPosition: FloatingPanelPosition) -> Bool {
+        return true
     }
 }

Framework/Tests/Utils.swift

@@ -10,9 +10,33 @@ func waitRunLoop(secs: TimeInterval = 0) {
     RunLoop.main.run(until: Date(timeIntervalSinceNow: secs))
 }
 
+extension FloatingPanelController {
+    func showForTest() {
+        loadViewIfNeeded()
+        view.frame = CGRect(x: 0, y: 0, width: 375, height: 667)
+        show(animated: false, completion: nil)
+    }
+}
+
 class FloatingPanelTestDelegate: FloatingPanelControllerDelegate {
     var layout: FloatingPanelLayout?
+    var behavior: FloatingPanelBehavior?
     func floatingPanel(_ vc: FloatingPanelController, layoutFor newCollection: UITraitCollection) -> FloatingPanelLayout? {
         return layout
     }
+    func floatingPanel(_ vc: FloatingPanelController, behaviorFor newCollection: UITraitCollection) -> FloatingPanelBehavior? {
+        return behavior
+    }
+}
+
+protocol FloatingPanelTestLayout: FloatingPanelFullScreenLayout {}
+extension FloatingPanelTestLayout {
+    func insetFor(position: FloatingPanelPosition) -> CGFloat? {
+        switch position {
+        case .full: return 20.0
+        case .half: return 250.0
+        case .tip: return 60.0
+        default: return nil
+        }
+    }
 }

README.md

@@ -93,6 +93,10 @@ For [Carthage](https://github.com/Carthage/Carthage), add the following to your
 github "scenee/FloatingPanel"
 ```
 
+### Swift Package Manager with Xcode 11
+
+Follow [this doc](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app).
+
 ## Getting Started
 
 ### Add a floating panel as a child view controller