Scroll indicators update - positioning correction, support for both indicators at the same time

Sources/UIScrollView+indicatorsInternal.swift

@@ -10,22 +10,47 @@
 // You can't override methods that were defined in an extension.
 
 internal extension UIScrollView {
-    internal static let indicatorDistanceFromScrollViewFrame: CGFloat = 2.5
+    internal var indicatorLengths: (horizontal: CGFloat, vertical: CGFloat) {
+        let minIndicatorLength: CGFloat = 30.0
+        return (
+            horizontal: max(minIndicatorLength, (bounds.width / contentSize.width) * bounds.width),
+            vertical: max(minIndicatorLength, (bounds.height / contentSize.height) * bounds.height)
+        )
+    }
+
+    internal var indicatorOffsetsInContentSpace: (horizontal: CGFloat, vertical: CGFloat) {
+        let indicatorDistanceFromScrollViewFrame: CGFloat = 2.5
 
-    internal func indicatorOffsetsInContentSpace() -> (horizontal: CGFloat, vertical: CGFloat) {
         let totalContentArea = (
             horizontal: contentInset.left + contentSize.width + contentInset.right,
             vertical: contentInset.top + contentSize.height + contentInset.bottom
         )
 
         let scrollViewProgress = (
-            horizontal: (contentInset.left + contentOffset.x) / (totalContentArea.horizontal + bounds.width),
-            vertical: (contentInset.top + contentOffset.y) / (totalContentArea.vertical + bounds.height)
+            horizontal: (contentInset.left + contentOffset.x) / (totalContentArea.horizontal - bounds.width),
+            vertical: (contentInset.top + contentOffset.y) / (totalContentArea.vertical - bounds.height)
+        )
+
+        let shouldShowBothIndicators = shouldLayoutHorizontalScrollIndicator && shouldLayoutVerticalScrollIndicator
+
+        let additionalSpacingToPreventOverlap = (
+            horizontal: shouldShowBothIndicators ? 2 * indicatorDistanceFromScrollViewFrame : 0,
+            vertical: shouldShowBothIndicators ? indicatorDistanceFromScrollViewFrame : 0
+        )
+
+        let totalSpacingFromFrameSides = (
+            horizontal: totalScrollIndicatorInsets.left + totalScrollIndicatorInsets.right + additionalSpacingToPreventOverlap.horizontal,
+            vertical: totalScrollIndicatorInsets.bottom + totalScrollIndicatorInsets.top + additionalSpacingToPreventOverlap.vertical
+        )
+
+        let lengthOfAvailableSpaceForIndicators = (
+            horizontal: bounds.width - (indicatorLengths.horizontal + totalSpacingFromFrameSides.horizontal),
+            vertical: bounds.height - (indicatorLengths.vertical + totalSpacingFromFrameSides.vertical)
         )
 
         let indicatorOffsetInBounds = (
-            horizontal: scrollViewProgress.horizontal * bounds.size.width,
-            vertical: scrollViewProgress.vertical * bounds.size.height
+            horizontal: scrollViewProgress.horizontal * lengthOfAvailableSpaceForIndicators.horizontal,
+            vertical: scrollViewProgress.vertical * lengthOfAvailableSpaceForIndicators.vertical
         )
 
         return (
@@ -42,28 +67,27 @@ internal extension UIScrollView {
         return showsVerticalScrollIndicator && contentSize.height > bounds.height
     }
 
-
     internal func layoutScrollIndicatorsIfNeeded() {
         guard shouldLayoutHorizontalScrollIndicator || shouldLayoutVerticalScrollIndicator else { return }
 
-        let indicatorDistanceFromScrollViewFrame = UIScrollView.indicatorDistanceFromScrollViewFrame
-        let indicatorOffsets = indicatorOffsetsInContentSpace()
-        let indicatorLengths = (horizontal: (bounds.width / contentSize.width) * bounds.width,
-                                vertical: (bounds.height / contentSize.height) * bounds.height)
+        let distanceFromFrame = (
+            horizontal: indicatorThickness + totalScrollIndicatorInsets.bottom,
+            vertical: indicatorThickness + totalScrollIndicatorInsets.right
+        )
 
         if shouldLayoutHorizontalScrollIndicator {
             horizontalScrollIndicator.frame = CGRect(
-                x: indicatorDistanceFromScrollViewFrame + indicatorOffsets.horizontal,
-                y: bounds.height - (indicatorThickness + indicatorDistanceFromScrollViewFrame),
+                x: totalScrollIndicatorInsets.left + indicatorOffsetsInContentSpace.horizontal,
+                y: bounds.height + contentOffset.y - distanceFromFrame.horizontal,
                 width: indicatorLengths.horizontal,
                 height: indicatorThickness
             )
         }
 
         if shouldLayoutVerticalScrollIndicator {
             verticalScrollIndicator.frame = CGRect(
-                x: bounds.width - (indicatorThickness + indicatorDistanceFromScrollViewFrame),
-                y: indicatorDistanceFromScrollViewFrame + indicatorOffsets.vertical,
+                x: bounds.width + contentOffset.x - distanceFromFrame.vertical,
+                y: totalScrollIndicatorInsets.top + indicatorOffsetsInContentSpace.vertical,
                 width: indicatorThickness,
                 height: indicatorLengths.vertical
             )

Sources/UIScrollView.swift

@@ -56,12 +56,6 @@ open class UIScrollView: UIView {
         )
     }
 
-    public var indicatorStyle: UIScrollViewIndicatorStyle = .`default` {
-        didSet { applyScrollIndicatorsStyle() }
-    }
-
-    // TODO: var scrollIndicatorInsets
-
     var weightedAverageVelocity: CGPoint = .zero
 
     override public init(frame: CGRect) {
@@ -77,6 +71,19 @@ open class UIScrollView: UIView {
             addSubview($0)
         }
     }
+
+    // When adding subviews, make sure that the scroll indicators stay on top
+    open override func addSubview(_ view: UIView) {
+        if view == horizontalScrollIndicator || view == verticalScrollIndicator {
+            super.addSubview(view)
+        } else {
+            super.insertSubview(view, at: subviews.count - 2)
+        }
+    }
+
+    open override func insertSubview(_ view: UIView, at index: Int) {
+        super.insertSubview(view, at: min(index, subviews.count - 2))
+    }
 
     open var isDecelerating = false {
         didSet {
@@ -120,10 +127,24 @@ open class UIScrollView: UIView {
     open var contentInset: UIEdgeInsets = .zero
     open var contentSize: CGSize = .zero
 
-
     // MARK: Scroll Indicators
 
     let indicatorThickness: CGFloat = 2.5
+
+    public var indicatorStyle: UIScrollViewIndicatorStyle = .`default` {
+        didSet { applyScrollIndicatorsStyle() }
+    }
+
+    private let baseScrollIndicatorInsets = UIEdgeInsets(top: 2.5, left: 2.5, bottom: 2.5, right: 2.5)
+    public var scrollIndicatorInsets = UIEdgeInsets.zero
+
+
+    var totalScrollIndicatorInsets: UIEdgeInsets {
+        return UIEdgeInsets(top: baseScrollIndicatorInsets.top + scrollIndicatorInsets.top,
+                            left: baseScrollIndicatorInsets.left + scrollIndicatorInsets.left,
+                            bottom: baseScrollIndicatorInsets.bottom + scrollIndicatorInsets.bottom,
+                            right: baseScrollIndicatorInsets.right + scrollIndicatorInsets.right)
+    }
 
     private func applyScrollIndicatorsStyle() {
         for scrollIndicator in [verticalScrollIndicator, horizontalScrollIndicator] {

UIKitTests/UIScrollViewTests.swift

@@ -98,10 +98,6 @@ class UIScrollViewTests: XCTestCase {
 
     // TODO: test final position. [blocked by setting contentOffset programatically - test behaviour in iOS]
 
-    func testIfScrollIndicatorsAreAccurate() {
-        // TODO: how?
-    }
-
     func testIfScrollViewBouncesBackAferPullIfNeeded() {
         // TODO: test setting inset and bouncing after it's implented in ScrollView
     }