improvements in barRect height calculation

Source/Charts/Components/YAxis.swift

@@ -150,6 +150,23 @@ open class YAxis: AxisBase
         var min = _customAxisMin ? _axisMinimum : dataMin
         var max = _customAxisMax ? _axisMaximum : dataMax
 
+        // Make sure max is greater than min
+        // Discussion: https://github.com/danielgindi/Charts/pull/3650#discussion_r221409991
+        if min > max
+        {
+            switch(_customAxisMax, _customAxisMin)
+            {
+            case(true, true):
+                (min, max) = (max, min)
+            case(true, false):
+                min = max < 0 ? max * 1.5 : max * 0.5
+            case(false, true):
+                max = min < 0 ? min * 0.5 : min * 1.5
+            case(false, false):
+                break
+            }
+        }
+
         // temporary range (before calculations)
         let range = abs(max - min)
 

Source/Charts/Renderers/BarChartRenderer.swift

@@ -108,6 +108,32 @@ open class BarChartRenderer: BarLineScatterCandleBubbleRenderer
         var barRect = CGRect()
         var x: Double
         var y: Double
+
+
+
+        // When drawing each bar, the renderer actually draws each bar from 0 to the required value.
+        // This drawn bar is then clipped to the visible chart rect in BarLineChartViewBase's draw(rect:) using clipDataToContent.
+        // While this works fine when calculating the bar rects for drawing, it causes the accessibilityFrames to be oversized in some cases.
+        // This offset attempts to undo that unnecessary drawing when calculating barRects
+        // This offset calculation is not necessary when bars won't be clipped (when y-axis minimum <= 0  and y-axis maximum  >= 0)
+        var heightOffset: CGFloat = 0.0
+        var originYOffset: CGFloat = 0.0
+        if let offsetView = dataProvider as? BarChartView
+        {
+            let offsetAxis = dataSet.axisDependency == .left ? offsetView.leftAxis : offsetView.rightAxis
+            if offsetAxis.axisMinimum > 0
+            {
+                heightOffset = CGFloat(offsetAxis.axisMinimum)
+            }
+            if offsetAxis.axisMaximum < 0
+            {
+                originYOffset = CGFloat(offsetAxis.axisMaximum)
+            }
+            if isInverted
+            {
+                (heightOffset, originYOffset) = (originYOffset, heightOffset)
+            }
+        }
 
         for i in stride(from: 0, to: min(Int(ceil(Double(dataSet.entryCount) * animator.phaseX)), dataSet.entryCount), by: 1)
         {
@@ -125,12 +151,16 @@ open class BarChartRenderer: BarLineScatterCandleBubbleRenderer
                 var top = isInverted
                     ? (y <= 0.0 ? CGFloat(y) : 0)
                     : (y >= 0.0 ? CGFloat(y) : 0)
+                top += originYOffset
+
                 var bottom = isInverted
                     ? (y >= 0.0 ? CGFloat(y) : 0)
                     : (y <= 0.0 ? CGFloat(y) : 0)
+                bottom += heightOffset
 
                 // multiply the height of the rect with the phase
-                if top > 0
+                // explicitly add 0 + originYOffset to indicate this is changed after adding accessibility support (#3650, #3520)
+                if top > 0 + originYOffset
                 {
                     top *= CGFloat(phaseY)
                 }
@@ -139,28 +169,10 @@ open class BarChartRenderer: BarLineScatterCandleBubbleRenderer
                     bottom *= CGFloat(phaseY)
                 }
 
-                // When drawing with an auto calculated y-axis minimum, the renderer actually draws each bar from 0
-                // to the required value. This drawn bar is then clipped to the visible chart rect in BarLineChartViewBase's draw(rect:) using clipDataToContent.
-                // While this works fine when calculating the bar rects for drawing, it causes the accessibilityFrames to be oversized in some cases.
-                // This offset attempts to undo that unnecessary drawing when calculating barRects, particularly when not using custom axis minima.
-                // This allows the minimum to still be visually non zero, but the rects are only drawn where necessary.
-                // This offset calculation also avoids cases where there are positive/negative values mixed, since those won't need this offset.
-                var offset: CGFloat = 0.0
-                if let offsetView = dataProvider as? BarChartView {
-
-                    let offsetAxis = offsetView.leftAxis.isEnabled ? offsetView.leftAxis : offsetView.rightAxis
-
-                    if barData.yMin.sign != barData.yMax.sign { offset = 0.0 }
-                    else if !offsetAxis._customAxisMin {
-                        offset = CGFloat(offsetAxis.axisMinimum)
-                    }
-                }
-
                 barRect.origin.x = left
-                barRect.size.width = right - left
                 barRect.origin.y = top
-                barRect.size.height = bottom == top ? 0 : bottom - top + offset
-
+                barRect.size.width = right - left
+                barRect.size.height = bottom - top
                 buffer.rects[bufferIndex] = barRect
                 bufferIndex += 1
             }