Rework HighLighter

MPChartLib/src/main/java/com/github/mikephil/charting/data/LineDataSet.kt

@@ -168,6 +168,7 @@ open class LineDataSet(yVals: MutableList<Entry>?, label: String = "") : LineRad
     @Suppress("OVERRIDE_DEPRECATION")
     override val isDrawSteppedEnabled: Boolean
         get() = mLineDataSetMode == Mode.STEPPED
+
     override var circleRadius: Float
         get() = mCircleRadius
         set(value) {

MPChartLib/src/main/java/com/github/mikephil/charting/highlight/BarHighlighter.kt

@@ -12,7 +12,7 @@ open class BarHighlighter(barDataProvider: BarDataProvider) : ChartHighlighter<B
 
         val pos = getValsForTouch(x, y)
 
-        val barData = provider!!.barData
+        val barData = provider.barData
 
         val set = barData.getDataSetByIndex(high.dataSetIndex)
         if (set.isStacked()) {
@@ -46,7 +46,7 @@ open class BarHighlighter(barDataProvider: BarDataProvider) : ChartHighlighter<B
                 if (ranges.isNotEmpty()) {
                     val stackIndex = getClosestStackIndex(ranges, yVal)
 
-                    val pixels = provider!!.getTransformer(set.axisDependency)!!.getPixelForValues(high.x, ranges[stackIndex].to)
+                    val pixels = provider.getTransformer(set.axisDependency)!!.getPixelForValues(high.x, ranges[stackIndex].to)
 
                     val stackedHigh = Highlight(
                         entry.x,

MPChartLib/src/main/java/com/github/mikephil/charting/highlight/ChartHighlighter.kt

@@ -10,7 +10,7 @@ import com.github.mikephil.charting.utils.MPPointD
 import kotlin.math.abs
 import kotlin.math.hypot
 
-open class ChartHighlighter<T : BarLineScatterCandleBubbleDataProvider>(protected var provider: T?) : IHighlighter {
+open class ChartHighlighter<T : BarLineScatterCandleBubbleDataProvider>(protected var provider: T) : IHighlighter {
     /**
      * buffer for storing previously highlighted values
      */
@@ -32,7 +32,7 @@ open class ChartHighlighter<T : BarLineScatterCandleBubbleDataProvider>(protecte
     protected fun getValsForTouch(x: Float, y: Float): MPPointD {
         // take any transformer to determine the x-axis value
 
-        return provider!!.getTransformer(AxisDependency.LEFT)!!.getValuesByTouchPoint(x, y)
+        return provider.getTransformer(AxisDependency.LEFT)!!.getValuesByTouchPoint(x, y)
     }
 
     /**
@@ -50,7 +50,7 @@ open class ChartHighlighter<T : BarLineScatterCandleBubbleDataProvider>(protecte
 
         val axis = if (leftAxisMinDist < rightAxisMinDist) AxisDependency.LEFT else AxisDependency.RIGHT
 
-        return getClosestHighlightByPixel(closestValues, x, y, axis, provider!!.getMaxHighlightDistance())
+        return getClosestHighlightByPixel(closestValues, x, y, axis, provider.getMaxHighlightDistance())
     }
 
     /**

MPChartLib/src/main/java/com/github/mikephil/charting/highlight/CombinedHighlighter.kt

@@ -22,7 +22,7 @@ open class CombinedHighlighter(dataProvider: CombinedDataProvider, barChart: Bar
     override fun getHighlightsAtXValue(xVal: Float, x: Float, y: Float): MutableList<Highlight>? {
         highlightBuffer.clear()
 
-        val dataObjects = provider!!.combinedData!!.getAllData()
+        val dataObjects = provider.combinedData!!.getAllData()
 
         for (i in dataObjects.indices) {
             val dataObject: ChartData<*> = dataObjects[i]

MPChartLib/src/main/java/com/github/mikephil/charting/highlight/HorizontalBarHighlighter.kt

@@ -9,7 +9,7 @@ import kotlin.math.abs
 
 class HorizontalBarHighlighter(dataProvider: BarDataProvider) : BarHighlighter(dataProvider) {
     override fun getHighlight(x: Float, y: Float): Highlight? {
-        val barData = provider!!.barData
+        val barData = provider.barData
 
         val pos = getValsForTouch(y, x)
 
@@ -47,7 +47,7 @@ class HorizontalBarHighlighter(dataProvider: BarDataProvider) : BarHighlighter(d
 
         if (entries != null)
             for (entry in entries) {
-                val pixels = provider!!.getTransformer(set.axisDependency)!!.getPixelForValues(entry.y, entry.x)
+                val pixels = provider.getTransformer(set.axisDependency)!!.getPixelForValues(entry.y, entry.x)
 
                 highlights.add(
                     Highlight(

MPChartLib/src/main/java/com/github/mikephil/charting/highlight/PieHighlighter.kt

@@ -5,9 +5,9 @@ import com.github.mikephil.charting.data.Entry
 
 class PieHighlighter(chart: PieChart) : PieRadarHighlighter<PieChart>(chart) {
     override fun getClosestHighlight(index: Int, x: Float, y: Float): Highlight? {
-        val pieDataSet = chart!!.data!!.dataSet
+        val pieDataSet = chart.data!!.dataSet
 
-        val entry: Entry? = pieDataSet?.getEntryForIndex(index)
+        val entry: Entry? = pieDataSet.getEntryForIndex(index)
 
         entry?.let {
             return Highlight(index.toFloat(), entry.y, x, y, 0, pieDataSet.axisDependency)

MPChartLib/src/main/java/com/github/mikephil/charting/highlight/PieRadarHighlighter.kt

@@ -3,31 +3,31 @@ package com.github.mikephil.charting.highlight
 import com.github.mikephil.charting.charts.PieChart
 import com.github.mikephil.charting.charts.PieRadarChartBase
 
-abstract class PieRadarHighlighter<T : PieRadarChartBase<*>?>(protected var chart: T?) : IHighlighter {
+abstract class PieRadarHighlighter<T : PieRadarChartBase<*>>(protected var chart: T) : IHighlighter {
     /**
      * buffer for storing previously highlighted values
      */
     protected var mHighlightBuffer: MutableList<Highlight> = ArrayList()
 
     override fun getHighlight(x: Float, y: Float): Highlight? {
-        val touchDistanceToCenter = chart!!.distanceToCenter(x, y)
+        val touchDistanceToCenter = chart.distanceToCenter(x, y)
 
         // check if a slice was touched
-        if (touchDistanceToCenter > chart!!.getRadius()) {
+        if (touchDistanceToCenter > chart.getRadius()) {
             // if no slice was touched, highlight nothing
 
             return null
         } else {
-            var angle = chart!!.getAngleForPoint(x, y)
+            var angle = chart.getAngleForPoint(x, y)
 
             if (chart is PieChart) {
-                angle /= chart!!.animator.phaseY
+                angle /= chart.animator.phaseY
             }
 
-            val index = chart!!.getIndexForAngle(angle)
+            val index = chart.getIndexForAngle(angle)
 
             // check if the index could be found
-            return if (index < 0 || index >= chart!!.getData()!!.getMaxEntryCountSet().entryCount) {
+            return if (index < 0 || index >= chart.getData()!!.getMaxEntryCountSet().entryCount) {
                 null
             } else {
                 getClosestHighlight(index, x, y)

MPChartLib/src/main/java/com/github/mikephil/charting/highlight/RadarHighlighter.kt

@@ -7,7 +7,7 @@ import com.github.mikephil.charting.utils.MPPointF
 import com.github.mikephil.charting.utils.Utils
 import kotlin.math.abs
 
-open class RadarHighlighter(chart: RadarChart?) : PieRadarHighlighter<RadarChart?>(chart) {
+open class RadarHighlighter(chart: RadarChart) : PieRadarHighlighter<RadarChart>(chart) {
     override fun getClosestHighlight(index: Int, x: Float, y: Float): Highlight? {
         val highlights = getHighlightsAtIndex(index)
 

MPChartLib/src/main/java/com/github/mikephil/charting/highlight/Range.kt

@@ -4,7 +4,7 @@ package com.github.mikephil.charting.highlight
  * Class that represents the range of one value in a stacked bar entry. e.g.
  * stack values are -10, 5, 20 -> then ranges are (-10 - 0, 0 - 5, 5 - 25).
  */
-class Range(var from: Float, @JvmField var to: Float) {
+class Range(var from: Float, var to: Float) {
     /**
      * Returns true if this range contains (if the value is in between) the given value, false if not.
      */

MPChartLib/src/main/java/com/github/mikephil/charting/renderer/CandleStickChartRenderer.kt

@@ -267,10 +267,10 @@ open class CandleStickChartRenderer(
                         if (entry.icon != null && dataSet.isDrawIcons) {
                             val icon = entry.icon
 
-                            icon?.let {
+                            icon?.let { ico ->
                                 Utils.drawImage(
                                     canvas,
-                                    it,
+                                    ico,
                                     (x + iconsOffset.x).toInt(),
                                     (y + iconsOffset.y).toInt()
                                 )

MPChartLib/src/main/java/com/github/mikephil/charting/renderer/CombinedChartRenderer.kt

@@ -36,7 +36,7 @@ open class CombinedChartRenderer(chart: CombinedChart, animator: ChartAnimator,
 
         for (order in orders) {
             when (order) {
-                DrawOrder.BAR -> if (chart.barData != null) dataRenderers.add(BarChartRenderer(chart, animator, viewPortHandler))
+                DrawOrder.BAR -> dataRenderers.add(BarChartRenderer(chart, animator, viewPortHandler))
                 DrawOrder.BUBBLE -> if (chart.bubbleData != null) dataRenderers.add(BubbleChartRenderer(chart, animator, viewPortHandler))
                 DrawOrder.LINE -> dataRenderers.add(LineChartRenderer(chart, animator, viewPortHandler))
                 DrawOrder.CANDLE -> if (chart.candleData != null) dataRenderers.add(CandleStickChartRenderer(chart, animator, viewPortHandler))
@@ -98,8 +98,10 @@ open class CombinedChartRenderer(chart: CombinedChart, animator: ChartAnimator,
      * Returns the sub-renderer object at the specified index.
      */
     fun getSubRenderer(index: Int): DataRenderer? {
-        return if (index >= dataRenderers.size || index < 0) null
-        else dataRenderers[index]
+        return if (index >= dataRenderers.size || index < 0)
+            null
+        else
+            dataRenderers[index]
     }
 
     val subRenderers: List<DataRenderer>

MPChartLib/src/main/java/com/github/mikephil/charting/renderer/PieChartRenderer.kt

@@ -905,7 +905,7 @@ open class PieChartRenderer(
 
         val dataSet = chart.data!!.dataSet
 
-        if (!dataSet!!.isVisible)
+        if (!dataSet.isVisible)
             return
 
         val phaseX = animator.phaseX

MPChartLib/src/main/java/com/github/mikephil/charting/renderer/RoundedHorizontalBarChartRenderer.kt

@@ -17,21 +17,9 @@ import kotlin.math.min
 class RoundedHorizontalBarChartRenderer(chart: BarDataProvider, animator: ChartAnimator, viewPortHandler: ViewPortHandler) :
     HorizontalBarChartRenderer(chart, animator, viewPortHandler) {
     private val mBarShadowRectBuffer = RectF()
-    private var roundedShadowRadius = 0f
-    private var roundedPositiveDataSetRadius = 0f
-    private var roundedNegativeDataSetRadius = 0f
-
-    fun setRoundedNegativeDataSetRadius(roundedNegativeDataSet: Float) {
-        roundedNegativeDataSetRadius = roundedNegativeDataSet
-    }
-
-    fun setRoundedShadowRadius(roundedShadow: Float) {
-        roundedShadowRadius = roundedShadow
-    }
-
-    fun setRoundedPositiveDataSetRadius(roundedPositiveDataSet: Float) {
-        roundedPositiveDataSetRadius = roundedPositiveDataSet
-    }
+    var roundedShadowRadius = 0f
+    var roundedPositiveDataSetRadius = 0f
+    var roundedNegativeDataSetRadius = 0f
 
     init {
         paintValues.textAlign = Paint.Align.LEFT
@@ -43,7 +31,6 @@ class RoundedHorizontalBarChartRenderer(chart: BarDataProvider, animator: ChartA
         barBorderPaint.color = dataSet.barBorderColor
         barBorderPaint.strokeWidth = dataSet.barBorderWidth.convertDpToPixel()
         shadowPaint.color = dataSet.barShadowColor
-        val drawBorder = dataSet.barBorderWidth > 0f
         val phaseX = animator.phaseX
         val phaseY = animator.phaseY
 
@@ -234,6 +221,7 @@ class RoundedHorizontalBarChartRenderer(chart: BarDataProvider, animator: ChartA
         }
     }
 
+    @Suppress("SameParameterValue")
     private fun roundRect(rect: RectF, rx: Float, ry: Float, tl: Boolean, tr: Boolean, br: Boolean, bl: Boolean): Path {
         var rx = rx
         var ry = ry

MPChartLib/src/main/java/com/github/mikephil/charting/renderer/YAxisRendererHorizontalBarChart.kt

@@ -234,7 +234,7 @@ open class YAxisRendererHorizontalBarChart(
         limitLinePath.reset()
 
         for (i in limitLines.indices) {
-            val limitLine = limitLines[i]!!
+            val limitLine = limitLines[i]
 
             if (!limitLine.isEnabled) continue
 

MPChartLib/src/main/java/com/github/mikephil/charting/renderer/YAxisRendererRadarChart.kt

@@ -180,7 +180,7 @@ class YAxisRendererRadarChart(viewPortHandler: ViewPortHandler, yAxis: YAxis, pr
         val center = chart.centerOffsets
         val pOut = MPPointF.getInstance(0f, 0f)
         for (i in limitLines.indices) {
-            val limitLine = limitLines[i]!!
+            val limitLine = limitLines[i]
 
             if (!limitLine.isEnabled) continue