Merge pull request #470 from AppDevNext/KotlinBarLineScatterCandleBubbleRenderer

hannesa2 · web-flow · commit 4c933497e3cf · 2025-12-14T13:06:35.000+01:00
Kotlin bar line scatter candle bubble renderer
diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/BarChartRenderer.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/BarChartRenderer.kt
@@ -19,8 +19,8 @@ import kotlin.math.min
 
 open class BarChartRenderer(
     @JvmField var chart: BarDataProvider,
-    animator: ChartAnimator?,
-    viewPortHandler: ViewPortHandler?
+    animator: ChartAnimator,
+    viewPortHandler: ViewPortHandler
 ) : BarLineScatterCandleBubbleRenderer(animator, viewPortHandler) {
     /**
      * the rect object that is used for drawing the bars
@@ -48,8 +48,8 @@ open class BarChartRenderer(
     private var roundedBarRadius = 0f
 
     constructor(
-        chart: BarDataProvider, animator: ChartAnimator?,
-        viewPortHandler: ViewPortHandler?, mDrawRoundedBars: Boolean, mRoundedBarRadius: Float
+        chart: BarDataProvider, animator: ChartAnimator,
+        viewPortHandler: ViewPortHandler, mDrawRoundedBars: Boolean, mRoundedBarRadius: Float
     ) : this(chart, animator, viewPortHandler) {
         this.drawRoundedBars = mDrawRoundedBars
         this.roundedBarRadius = mRoundedBarRadius
diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/BarLineScatterCandleBubbleRenderer.java b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/BarLineScatterCandleBubbleRenderer.java
diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/BarLineScatterCandleBubbleRenderer.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/BarLineScatterCandleBubbleRenderer.kt
@@ -0,0 +1,75 @@
+package com.github.mikephil.charting.renderer
+
+import com.github.mikephil.charting.animation.ChartAnimator
+import com.github.mikephil.charting.data.DataSet
+import com.github.mikephil.charting.data.Entry
+import com.github.mikephil.charting.interfaces.dataprovider.BarLineScatterCandleBubbleDataProvider
+import com.github.mikephil.charting.interfaces.datasets.IBarLineScatterCandleBubbleDataSet
+import com.github.mikephil.charting.interfaces.datasets.IDataSet
+import com.github.mikephil.charting.utils.ViewPortHandler
+import kotlin.math.max
+import kotlin.math.min
+
+abstract class BarLineScatterCandleBubbleRenderer(animator: ChartAnimator, viewPortHandler: ViewPortHandler) : DataRenderer(animator, viewPortHandler) {
+    /**
+     * buffer for storing the current minimum and maximum visible x
+     */
+    protected var xBounds: XBounds = XBounds()
+
+    /**
+     * Returns true if the DataSet values should be drawn, false if not.
+     */
+    protected fun shouldDrawValues(set: IDataSet<*>): Boolean {
+        return set.isVisible() && (set.isDrawValuesEnabled() || set.isDrawIconsEnabled())
+    }
+
+    /**
+     * Checks if the provided entry object is in bounds for drawing considering the current animation phase.
+     */
+    protected fun <T : Entry> isInBoundsX(entry: T, set: IBarLineScatterCandleBubbleDataSet<T>): Boolean {
+        val entryIndex = set.getEntryIndex(entry).toFloat()
+
+        return if (entryIndex >= set.getEntryCount() * animator.phaseX) {
+            false
+        } else {
+            true
+        }
+    }
+
+    /**
+     * Class representing the bounds of the current viewport in terms of indices in the values array of a DataSet.
+     */
+    protected inner class XBounds {
+        /**
+         * minimum visible entry index
+         */
+        var min: Int = 0
+
+        /**
+         * maximum visible entry index
+         */
+        var max: Int = 0
+
+        /**
+         * range of visible entry indices
+         */
+        var range: Int = 0
+
+        /**
+         * Calculates the minimum and maximum x values as well as the range between them.
+         */
+        fun <T : Entry> set(chart: BarLineScatterCandleBubbleDataProvider, dataSet: IBarLineScatterCandleBubbleDataSet<T>) {
+            val phaseX = max(0f, min(1f, animator.phaseX))
+
+            val low = chart.lowestVisibleX
+            val high = chart.highestVisibleX
+
+            val entryFrom = dataSet.getEntryForXValue(low, Float.NaN, DataSet.Rounding.DOWN)
+            val entryTo = dataSet.getEntryForXValue(high, Float.NaN, DataSet.Rounding.UP)
+
+            min = if (entryFrom == null) 0 else dataSet.getEntryIndex(entryFrom)
+            max = if (entryTo == null) 0 else dataSet.getEntryIndex(entryTo)
+            range = ((max - min) * phaseX).toInt()
+        }
+    }
+}
diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/BubbleChartRenderer.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/BubbleChartRenderer.kt
@@ -19,8 +19,8 @@ import kotlin.math.sqrt
 @Suppress("MemberVisibilityCanBePrivate")
 open class BubbleChartRenderer(
     @JvmField
-    var dataProvider: BubbleDataProvider, animator: ChartAnimator?,
-    viewPortHandler: ViewPortHandler?
+    var dataProvider: BubbleDataProvider, animator: ChartAnimator,
+    viewPortHandler: ViewPortHandler
 ) : BarLineScatterCandleBubbleRenderer(animator, viewPortHandler) {
     override fun initBuffers() {
     }
diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/CandleStickChartRenderer.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/CandleStickChartRenderer.kt
@@ -13,8 +13,8 @@ import com.github.mikephil.charting.utils.ViewPortHandler
 
 open class CandleStickChartRenderer(
     @JvmField
-    var dataProvider: CandleDataProvider, animator: ChartAnimator?,
-    viewPortHandler: ViewPortHandler?
+    var dataProvider: CandleDataProvider, animator: ChartAnimator,
+    viewPortHandler: ViewPortHandler
 ) : LineScatterCandleRadarRenderer(animator, viewPortHandler) {
     private val shadowBuffers = FloatArray(8)
     private val bodyBuffers = FloatArray(4)
@@ -39,6 +39,7 @@ open class CandleStickChartRenderer(
         val barSpace = dataSet.barSpace
         val showCandleBar = dataSet.showCandleBar
 
+        this.xBounds
         xBounds.set(dataProvider, dataSet)
 
         paintRender.strokeWidth = dataSet.shadowWidth
diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/HorizontalBarChartRenderer.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/HorizontalBarChartRenderer.kt
@@ -22,8 +22,8 @@ import kotlin.math.min
  */
 @Suppress("MemberVisibilityCanBePrivate")
 open class HorizontalBarChartRenderer(
-    chart: BarDataProvider, animator: ChartAnimator?,
-    viewPortHandler: ViewPortHandler?
+    chart: BarDataProvider, animator: ChartAnimator,
+    viewPortHandler: ViewPortHandler
 ) : BarChartRenderer(chart, animator, viewPortHandler) {
     override fun initBuffers() {
         val barData = chart.barData
diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/LineChartRenderer.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/LineChartRenderer.kt
@@ -23,8 +23,8 @@ import kotlin.math.max
 import kotlin.math.min
 
 open class LineChartRenderer(
-    @JvmField var dataProvider: LineDataProvider, animator: ChartAnimator?,
-    viewPortHandler: ViewPortHandler?
+    @JvmField var dataProvider: LineDataProvider, animator: ChartAnimator,
+    viewPortHandler: ViewPortHandler
 ) : LineRadarRenderer(animator, viewPortHandler) {
     /**
      * paint for the inner circle of the value indicators
diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/LineRadarRenderer.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/LineRadarRenderer.kt
@@ -9,7 +9,7 @@ import com.github.mikephil.charting.animation.ChartAnimator
 import com.github.mikephil.charting.utils.ViewPortHandler
 import com.github.mikephil.charting.utils.getSDKInt
 
-abstract class LineRadarRenderer(animator: ChartAnimator?, viewPortHandler: ViewPortHandler?) :
+abstract class LineRadarRenderer(animator: ChartAnimator, viewPortHandler: ViewPortHandler) :
     LineScatterCandleRadarRenderer(animator, viewPortHandler) {
     /**
      * Draws the provided path in filled mode with the provided drawable.
diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/LineScatterCandleRadarRenderer.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/LineScatterCandleRadarRenderer.kt
@@ -6,7 +6,7 @@ import com.github.mikephil.charting.animation.ChartAnimator
 import com.github.mikephil.charting.interfaces.datasets.ILineScatterCandleRadarDataSet
 import com.github.mikephil.charting.utils.ViewPortHandler
 
-abstract class LineScatterCandleRadarRenderer(animator: ChartAnimator?, viewPortHandler: ViewPortHandler?) :
+abstract class LineScatterCandleRadarRenderer(animator: ChartAnimator, viewPortHandler: ViewPortHandler) :
     BarLineScatterCandleBubbleRenderer(animator, viewPortHandler) {
     /**
      * path that is used for drawing highlight-lines (drawLines(...) cannot be used because of dashes)
diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/RadarChartRenderer.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/RadarChartRenderer.kt
@@ -15,8 +15,8 @@ import com.github.mikephil.charting.utils.Utils
 import com.github.mikephil.charting.utils.ViewPortHandler
 
 open class RadarChartRenderer(
-    protected var chart: RadarChart, animator: ChartAnimator?,
-    viewPortHandler: ViewPortHandler?
+    protected var chart: RadarChart, animator: ChartAnimator,
+    viewPortHandler: ViewPortHandler
 ) : LineRadarRenderer(animator, viewPortHandler) {
     var webPaint: Paint
         protected set
@@ -300,11 +300,11 @@ open class RadarChartRenderer(
 
             if (set == null || !set.isHighlightEnabled) continue
 
-            val e = set.getEntryForIndex(high.x.toInt())
+            val radarEntry = set.getEntryForIndex(high.x.toInt())
 
-            if (!isInBoundsX(e, set)) continue
+            if (!isInBoundsX(radarEntry, set)) continue
 
-            val y = (e.y - chart.yChartMin)
+            val y = (radarEntry.y - chart.yChartMin)
 
             Utils.getPosition(
                 center,
diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/RoundedBarChartRenderer.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/RoundedBarChartRenderer.kt
@@ -15,7 +15,7 @@ import kotlin.math.min
 
 /** @noinspection unused
  */
-class RoundedBarChartRenderer(chart: BarDataProvider, animator: ChartAnimator?, viewPortHandler: ViewPortHandler?) :
+class RoundedBarChartRenderer(chart: BarDataProvider, animator: ChartAnimator, viewPortHandler: ViewPortHandler) :
     BarChartRenderer(chart, animator, viewPortHandler) {
     private val mBarShadowRectBuffer = RectF()
     private val mRadius = 20f
@@ -267,9 +267,9 @@ class RoundedBarChartRenderer(chart: BarDataProvider, animator: ChartAnimator?,
                 continue
             }
 
-            val e = set.getEntryForXValue(high.x, high.y)
+            val barEntry = set.getEntryForXValue(high.x, high.y)
 
-            if (!isInBoundsX(e, set)) {
+            if (!isInBoundsX(barEntry, set)) {
                 continue
             }
 
@@ -278,27 +278,27 @@ class RoundedBarChartRenderer(chart: BarDataProvider, animator: ChartAnimator?,
             paintHighlight.color = set.highLightColor
             paintHighlight.alpha = set.highLightAlpha
 
-            val isStack = high.stackIndex >= 0 && e.isStacked
+            val isStack = high.stackIndex >= 0 && barEntry.isStacked
 
             val y1: Float
             val y2: Float
 
             if (isStack) {
                 if (chart.isHighlightFullBarEnabled) {
-                    y1 = e.positiveSum
-                    y2 = -e.negativeSum
+                    y1 = barEntry.positiveSum
+                    y2 = -barEntry.negativeSum
                 } else {
-                    val range = e.ranges[high.stackIndex]
+                    val range = barEntry.ranges[high.stackIndex]
 
                     y1 = range?.from ?: 0f
                     y2 = range?.to ?: 0f
                 }
             } else {
-                y1 = e.y
+                y1 = barEntry.y
                 y2 = 0f
             }
 
-            prepareBarHighlight(e.x, y1, y2, barData.barWidth / 2f, trans!!)
+            prepareBarHighlight(barEntry.x, y1, y2, barData.barWidth / 2f, trans!!)
 
             setHighlightDrawPos(high, barRect)
 
diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/RoundedHorizontalBarChartRenderer.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/RoundedHorizontalBarChartRenderer.kt
@@ -14,7 +14,7 @@ import kotlin.math.min
 /**
  * @noinspection unused
  */
-class RoundedHorizontalBarChartRenderer(chart: BarDataProvider, animator: ChartAnimator?, viewPortHandler: ViewPortHandler?) :
+class RoundedHorizontalBarChartRenderer(chart: BarDataProvider, animator: ChartAnimator, viewPortHandler: ViewPortHandler) :
     HorizontalBarChartRenderer(chart, animator, viewPortHandler) {
     private val mBarShadowRectBuffer = RectF()
     private var roundedShadowRadius = 0f
diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/ScatterChartRenderer.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/ScatterChartRenderer.kt
@@ -12,7 +12,7 @@ import com.github.mikephil.charting.utils.ViewPortHandler
 import kotlin.math.ceil
 import kotlin.math.min
 
-open class ScatterChartRenderer(@JvmField var dataProvider: ScatterDataProvider, animator: ChartAnimator?, viewPortHandler: ViewPortHandler?) :
+open class ScatterChartRenderer(@JvmField var dataProvider: ScatterDataProvider, animator: ChartAnimator, viewPortHandler: ViewPortHandler) :
     LineScatterCandleRadarRenderer(animator, viewPortHandler) {
     override fun initBuffers() {
     }
@@ -159,12 +159,12 @@ open class ScatterChartRenderer(@JvmField var dataProvider: ScatterDataProvider,
 
             if (set == null || !set.isHighlightEnabled) continue
 
-            val e = set.getEntryForXValue(high.x, high.y)
+            val entry = set.getEntryForXValue(high.x, high.y)
 
-            if (!isInBoundsX(e, set)) continue
+            if (!isInBoundsX(entry, set)) continue
 
             val pix = dataProvider.getTransformer(set.axisDependency)!!.getPixelForValues(
-                e.x, e.y * animator
+                entry.x, entry.y * animator
                     .phaseY
             )
 
