Fixed content jump due to short tab content being pinned to tab bar after switching tabs. Added stickyHeaderTabController(_, didUpdateCompoundHeaderHeight:) delegate method.

bchrobot · bchrobot · commit ddc2be30c083 · 2017-10-06T09:45:24.000-04:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -5,6 +5,11 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+### Added
+- `stickyHeaderTabController(_, didUpdateCompoundHeaderHeight:)` delegate method.
+
+### Fixed
+- Content jump due to short tab content being pinned to tab bar after switching tabs.
 
 ## [0.1.0] - 2017-10-05
 ### Added
diff --git a/Example/StickyHeaderTabController/Tabs/TabData.swift b/Example/StickyHeaderTabController/Tabs/TabData.swift
@@ -23,7 +23,8 @@ struct TabData {
         "Georgia",
         "Hawaii",
         "Idaho",
-        "Illinois Indiana",
+        "Illinois",
+        "Indiana",
         "Iowa",
         "Kansas",
         "Kentucky",
diff --git a/StickyHeaderTabController/Classes/StickyHeaderTabController.swift b/StickyHeaderTabController/Classes/StickyHeaderTabController.swift
@@ -7,8 +7,10 @@
 
 import UIKit
 
-public protocol StickyHeaderTabControllerDelegate: class {
-    func stickyHeaderTabControllerDidScrollVertically(_ controller: StickyHeaderTabController)
+@objc public protocol StickyHeaderTabControllerDelegate: class {
+    @objc optional func stickyHeaderTabController(_ controller: StickyHeaderTabController,
+                                            didUpdateCompoundHeaderHeight headerHeight: CGFloat)
+    @objc optional func stickyHeaderTabControllerDidScrollVertically(_ controller: StickyHeaderTabController)
 }
 
 open class StickyHeaderTabController: UIViewController {
@@ -71,6 +73,7 @@ open class StickyHeaderTabController: UIViewController {
     /// Could instead be a calculated variable, but then we lose the `didSet` functionality.
     fileprivate var compoundHeaderHeight: CGFloat = 0.0 {
         didSet {
+            delegate?.stickyHeaderTabController?(self, didUpdateCompoundHeaderHeight: compoundHeaderHeight)
             updateInsetForCompoundHeaderHeight(compoundHeaderHeight)
         }
     }
@@ -86,7 +89,7 @@ open class StickyHeaderTabController: UIViewController {
     /// gesture began.
     fileprivate weak var activeVerticalTab: StickyHeaderContentTabViewController?
 
-    private let verticalPanRecognizer = UIPanGestureRecognizer()
+    fileprivate let verticalPanRecognizer = UIPanGestureRecognizer()
 
     // MARK: AutoLayout magic
 
@@ -149,8 +152,6 @@ open class StickyHeaderTabController: UIViewController {
 
         horizontalScrollView.frame = view.bounds
         horizontalScrollView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
-
-        // view.insertSubview(gradientBackground, at: 0)
     }
 
     private func setUpVerticalPanRecognizer() {
@@ -337,14 +338,19 @@ open class StickyHeaderTabController: UIViewController {
         stickyGuideTopConstraint?.constant = -trueScrollOffset
 
         let offsetY = trueScrollOffset - compoundHeaderHeight
-        for tab in tabs {
-            if tab != activeVerticalTab {
-                // TODO: Refine this to account for differences in `contentSize`
-                tab.contentOffset = CGPoint(x: 0, y: offsetY)
+        let isTabBarPinned = tabBar.frame.origin.y <= stickyHeader.pinnedHeight
+        let otherTabs = tabs.filter { tab -> Bool in tab != activeVerticalTab }
+        for otherTab in otherTabs {
+            var newOffsetY = offsetY
+            if isTabBarPinned {
+                let tabBottom = tabBar.frame.origin.y + tabBar.frame.height
+                newOffsetY = max(otherTab.contentOffset.y, -tabBottom)
             }
+
+            otherTab.contentOffset = CGPoint(x: 0, y: newOffsetY)
         }
 
-        delegate?.stickyHeaderTabControllerDidScrollVertically(self)
+        delegate?.stickyHeaderTabControllerDidScrollVertically?(self)
     }
 
     fileprivate func scrollToTabIndex(_ tabIndex: Int, animated: Bool = true) {
@@ -423,6 +429,7 @@ open class StickyHeaderTabController: UIViewController {
 extension StickyHeaderTabController: StickyHeaderTabBarViewDelegate {
     public func stickyHeaderTabBarView(_ stickyHeaderTabBarView: StickyHeaderTabBarView,
                                 tabSelectedAtIndex index: Int) {
+        verticalPanRecognizer.cancelCurrentGesture()
         scrollToTabIndex(index, animated: true)
     }
 }
@@ -438,15 +445,6 @@ extension StickyHeaderTabController: StickyHeaderTabBarViewDataSource {
     }
 }
 
-// MARK: - StickyHeaderViewDelegate
-
-extension StickyHeaderTabController: StickyHeaderViewDelegate {
-    public func stickyHeaderView(_ stickyHeaderView: StickyHeaderView,
-                                 didChangeHeight height: CGFloat) {
-        updateCompoundHeaderHeight()
-    }
-}
-
 // MARK: - UIScrollViewDelegate
 
 extension StickyHeaderTabController: UIScrollViewDelegate {
@@ -480,6 +478,6 @@ extension StickyHeaderTabController: UIScrollViewDelegate {
 extension StickyHeaderTabController: UIGestureRecognizerDelegate {
     public func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer,
                                   shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool {
-        return false //true
+        return true
     }
 }
diff --git a/StickyHeaderTabController/Classes/ViewControllers/StickyHeaderContentTabViewController.swift b/StickyHeaderTabController/Classes/ViewControllers/StickyHeaderContentTabViewController.swift
@@ -19,40 +19,57 @@ open class StickyHeaderContentTabViewController: UIViewController {
     /// Set the bottom inset for the scrollView. This will be used to calculate the "true" inset.
     open var bottomInset: CGFloat { return 10.0 }
 
+    private var supplementalBottomInset: CGFloat = 0.0 {
+        didSet {
+            if oldValue != supplementalBottomInset {
+                updateContentInset()
+            }
+        }
+    }
+
     /// Generic access to tab's content `scrollView`.
     open var scrollView: UIScrollView {
         fatalError("subclasses must override this property!")
     }
 
     /// This is the "opaque" content inset value. Setting this will add the appropriate inset for
     /// the specific tab (as defined by `topInset` and `bottomInset`).
-    public var contentInset: UIEdgeInsets {
-        get {
-            let trueInset = scrollView.contentInset
-            return UIEdgeInsets(top: trueInset.top - topInset,
-                                left: trueInset.left,
-                                bottom: trueInset.bottom - bottomInset,
-                                right: trueInset.right)
-        }
-        set {
-            scrollView.contentInset = UIEdgeInsets(top: newValue.top + topInset,
-                                                   left: newValue.left,
-                                                   bottom: newValue.bottom + bottomInset,
-                                                   right: newValue.right)
+    public var contentInset: UIEdgeInsets = .zero {
+        didSet {
+            updateContentInset()
         }
     }
 
     /// This is the "opaque" content offset value. Setting this will add the appropriate offset for
     /// the specific tab (as defined by `topInset` and `bottomInset`).
-    public var contentOffset: CGPoint {
-        get {
-            let trueOffset = scrollView.contentOffset
-            return CGPoint(x: trueOffset.x, y: trueOffset.y + topInset)
-        }
-        set {
-            scrollView.contentOffset = CGPoint(x: newValue.x, y: newValue.y - topInset)
+    public var contentOffset: CGPoint = .zero {
+        didSet {
+            updateContentOffset()
         }
     }
+
+    // MARK: - Private Methods
+
+    private func updateContentInset() {
+        let newBottomInset = contentInset.bottom + bottomInset + supplementalBottomInset
+        scrollView.contentInset = UIEdgeInsets(top: contentInset.top + topInset,
+                                               left: contentInset.left,
+                                               bottom: newBottomInset,
+                                               right: contentInset.right)
+    }
+
+    private func updateContentOffset() {
+        let newOffsetY = contentOffset.y - topInset
+        scrollView.contentOffset.y = newOffsetY
+        updateSupplementalInsetForOffsetY(newOffsetY)
+    }
+
+    fileprivate func updateSupplementalInsetForOffsetY(_ offsetY: CGFloat) {
+        let contentBottomPosition = scrollView.contentSize.height - offsetY
+        let adjustedBottomPosition = contentBottomPosition + bottomInset
+
+        supplementalBottomInset = max(0, view.bounds.height - adjustedBottomPosition)
+    }
 }
 
 // MARK: - UIScrollViewDelegate
@@ -61,6 +78,13 @@ extension StickyHeaderContentTabViewController: UIScrollViewDelegate {
 
     open func scrollViewDidScroll(_ scrollView: UIScrollView) {
         scrollViewDelegate?.scrollViewDidScroll?(scrollView)
+
+        let offsetY = scrollView.contentOffset.y
+        let insetBottom = scrollView.contentInset.bottom
+        let contentBottomPosition = scrollView.contentSize.height + insetBottom - offsetY
+        if contentBottomPosition > view.bounds.height {
+            updateSupplementalInsetForOffsetY(scrollView.contentOffset.y)
+        }
     }
 
     open func scrollViewWillBeginDragging(_ scrollView: UIScrollView) {
diff --git a/StickyHeaderTabController/Classes/Views/StickyHeaderView.swift b/StickyHeaderTabController/Classes/Views/StickyHeaderView.swift
@@ -7,16 +7,10 @@
 
 import UIKit
 
-public protocol StickyHeaderViewDelegate: class {
-    func stickyHeaderView(_ stickyHeaderView: StickyHeaderView, didChangeHeight height: CGFloat)
-}
-
 open class StickyHeaderView: UIView {
 
     // MARK: - Public Properties
 
-    public weak var delegate: StickyHeaderViewDelegate?
-
     /// The minimum header height (while pinned in sticky top position)
     open var pinnedHeight: CGFloat {
         return 0.0
