diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/AxisRenderer.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/AxisRenderer.kt index f41ebc28d..fdafef061 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/AxisRenderer.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/AxisRenderer.kt @@ -233,30 +233,30 @@ abstract class AxisRenderer( /** * Draws the axis labels to the screen. * - * @param c + * @param canvas */ - abstract fun renderAxisLabels(c: Canvas) + abstract fun renderAxisLabels(canvas: Canvas) /** * Draws the grid lines belonging to the axis. * - * @param c + * @param canvas */ - abstract fun renderGridLines(c: Canvas) + abstract fun renderGridLines(canvas: Canvas) /** * Draws the line that goes alongside the axis. * - * @param c + * @param canvas */ - abstract fun renderAxisLine(c: Canvas) + abstract fun renderAxisLine(canvas: Canvas) /** * Draws the LimitLines associated with this axis to the screen. * - * @param c + * @param canvas */ - abstract fun renderLimitLines(c: Canvas) + abstract fun renderLimitLines(canvas: Canvas) /** * Sets the text color to use for the labels. Make sure to use 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 index ca88b8dc3..71216de13 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/BarChartRenderer.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/BarChartRenderer.kt @@ -69,7 +69,7 @@ open class BarChartRenderer( } } - override fun drawData(c: Canvas) { + override fun drawData(canvas: Canvas) { if (barBuffers.isEmpty()) { initBuffers() } @@ -80,7 +80,7 @@ open class BarChartRenderer( val set = barData.getDataSetByIndex(i) if (set.isVisible) { - drawDataSet(c, set, i) + drawDataSet(canvas, set, i) } } } @@ -101,7 +101,7 @@ open class BarChartRenderer( barBorderPaint.style = Paint.Style.STROKE } - protected open fun drawDataSet(c: Canvas, dataSet: IBarDataSet, index: Int) { + protected open fun drawDataSet(canvas: Canvas, dataSet: IBarDataSet, index: Int) { val trans = chart.getTransformer(dataSet.axisDependency) barBorderPaint.color = dataSet.barBorderColor @@ -147,9 +147,9 @@ open class BarChartRenderer( barShadowRectBuffer.bottom = viewPortHandler.contentBottom() if (drawRoundedBars) { - c.drawRoundRect(barShadowRectBuffer, roundedBarRadius, roundedBarRadius, shadowPaint) + canvas.drawRoundRect(barShadowRectBuffer, roundedBarRadius, roundedBarRadius, shadowPaint) } else { - c.drawRect(barShadowRectBuffer, shadowPaint) + canvas.drawRect(barShadowRectBuffer, shadowPaint) } i++ } @@ -195,7 +195,7 @@ open class BarChartRenderer( if (isCustomFill) { dataSet.getFill(pos) .fillRect( - c, paintRender, + canvas, paintRender, buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], @@ -205,14 +205,14 @@ open class BarChartRenderer( ) } else { if (drawRoundedBars) { - c.drawRoundRect( + canvas.drawRoundRect( RectF( buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], buffer.buffer[j + 3] ), roundedBarRadius, roundedBarRadius, paintRender ) } else { - c.drawRect( + canvas.drawRect( buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], buffer.buffer[j + 3], paintRender ) @@ -221,14 +221,14 @@ open class BarChartRenderer( if (drawBorder) { if (drawRoundedBars) { - c.drawRoundRect( + canvas.drawRoundRect( RectF( buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], buffer.buffer[j + 3] ), roundedBarRadius, roundedBarRadius, barBorderPaint ) } else { - c.drawRect( + canvas.drawRect( buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], buffer.buffer[j + 3], barBorderPaint ) @@ -242,15 +242,13 @@ open class BarChartRenderer( protected open fun prepareBarHighlight(x: Float, y1: Float, y2: Float, barWidthHalf: Float, trans: Transformer) { val left = x - barWidthHalf val right = x + barWidthHalf - val top = y1 - val bottom = y2 - barRect[left, top, right] = bottom + barRect[left, y1, right] = y2 trans.rectToPixelPhase(barRect, animator.phaseY) } - override fun drawValues(c: Canvas) { + override fun drawValues(canvas: Canvas) { // if values are drawn if (isDrawingValuesAllowed(chart)) { @@ -317,7 +315,7 @@ open class BarChartRenderer( if (dataSet.isDrawValuesEnabled) { drawValue( - c, dataSet.valueFormatter, `val`, entry, i, x, + canvas, dataSet.valueFormatter, `val`, entry, i, x, if (`val` >= 0) (buffer.buffer[j + 1] + posOffset) else (buffer.buffer[j + 3] + negOffset), dataSet.getValueTextColor(j / 4) ) @@ -333,7 +331,7 @@ open class BarChartRenderer( py += iconsOffset.y Utils.drawImage( - c, + canvas, icon, px.toInt(), py.toInt(), @@ -375,7 +373,7 @@ open class BarChartRenderer( if (dataSet.isDrawValuesEnabled) { drawValue( - c, dataSet.valueFormatter, entry.y, entry, i, x, + canvas, dataSet.valueFormatter, entry.y, entry, i, x, buffer.buffer[bufferIndex + 1] + (if (entry.y >= 0) posOffset else negOffset), color @@ -393,7 +391,7 @@ open class BarChartRenderer( py += iconsOffset.y Utils.drawImage( - c, + canvas, icon, px.toInt(), py.toInt(), @@ -457,7 +455,7 @@ open class BarChartRenderer( if (dataSet.isDrawValuesEnabled) { drawValue( - c, + canvas, dataSet.valueFormatter, vals[k / 2], entry, @@ -472,7 +470,7 @@ open class BarChartRenderer( val icon = entry.icon Utils.drawImage( - c, + canvas, icon, (x + iconsOffset.x).toInt(), (y + iconsOffset.y).toInt(), @@ -494,7 +492,7 @@ open class BarChartRenderer( } } - override fun drawHighlighted(c: Canvas, indices: Array) { + override fun drawHighlighted(canvas: Canvas, indices: Array) { val barData = chart.barData for (high in indices) { @@ -540,9 +538,9 @@ open class BarChartRenderer( setHighlightDrawPos(high, barRect) if (drawRoundedBars) { - c.drawRoundRect(RectF(barRect), roundedBarRadius, roundedBarRadius, paintHighlight) + canvas.drawRoundRect(RectF(barRect), roundedBarRadius, roundedBarRadius, paintHighlight) } else { - c.drawRect(barRect, paintHighlight) + canvas.drawRect(barRect, paintHighlight) } } } @@ -556,6 +554,6 @@ open class BarChartRenderer( high.setDraw(bar.centerX(), bar.top) } - override fun drawExtras(c: Canvas) { + override fun drawExtras(canvas: Canvas) { } } 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 index 661074837..7ff4d8fdb 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/BarLineScatterCandleBubbleRenderer.java +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/BarLineScatterCandleBubbleRenderer.java @@ -43,7 +43,7 @@ protected boolean isInBoundsX(Entry e, IBarLineScatterCandleBubbleDataSet set) { float entryIndex = set.getEntryIndex(e); - if (e == null || entryIndex >= set.getEntryCount() * animator.getPhaseX()) { + if (entryIndex >= set.getEntryCount() * animator.getPhaseX()) { return false; } else { return true; 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 index 7f2dd4b7a..733a2fb2d 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/BubbleChartRenderer.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/BubbleChartRenderer.kt @@ -13,6 +13,7 @@ import com.github.mikephil.charting.utils.ViewPortHandler import kotlin.math.abs import kotlin.math.max import kotlin.math.min +import kotlin.math.roundToInt import kotlin.math.sqrt @Suppress("MemberVisibilityCanBePrivate") @@ -24,11 +25,11 @@ open class BubbleChartRenderer( override fun initBuffers() { } - override fun drawData(c: Canvas) { + override fun drawData(canvas: Canvas) { val bubbleData = chart.bubbleData for (set in bubbleData.dataSets) { - if (set.isVisible) drawDataSet(c, set) + if (set.isVisible) drawDataSet(canvas, set) } } @@ -41,7 +42,7 @@ open class BubbleChartRenderer( return shapeSize } - protected fun drawDataSet(c: Canvas, dataSet: IBubbleDataSet) { + protected fun drawDataSet(canvas: Canvas, dataSet: IBubbleDataSet) { if (dataSet.entryCount < 1) return val trans = chart.getTransformer(dataSet.axisDependency) @@ -82,11 +83,11 @@ open class BubbleChartRenderer( val color = dataSet.getColor(j) paintRender.color = color - c.drawCircle(pointBuffer[0], pointBuffer[1], shapeHalf, paintRender) + canvas.drawCircle(pointBuffer[0], pointBuffer[1], shapeHalf, paintRender) } } - override fun drawValues(c: Canvas) { + override fun drawValues(canvas: Canvas) { val bubbleData = chart.bubbleData ?: return // if values are drawn @@ -128,7 +129,7 @@ open class BubbleChartRenderer( while (j < positions.size) { var valueTextColor = dataSet.getValueTextColor(j / 2 + xBounds.min) valueTextColor = Color.argb( - Math.round(255f * alpha), Color.red(valueTextColor), + (255f * alpha).roundToInt(), Color.red(valueTextColor), Color.green(valueTextColor), Color.blue(valueTextColor) ) @@ -146,7 +147,7 @@ open class BubbleChartRenderer( if (dataSet.isDrawValuesEnabled) { drawValue( - c, dataSet.valueFormatter, entry.size, entry, i, x, + canvas, dataSet.valueFormatter, entry.size, entry, i, x, y + (0.5f * lineHeight), valueTextColor ) } @@ -155,7 +156,7 @@ open class BubbleChartRenderer( val icon = entry.icon Utils.drawImage( - c, + canvas, icon, (x + iconsOffset.x).toInt(), (y + iconsOffset.y).toInt(), @@ -172,7 +173,7 @@ open class BubbleChartRenderer( } } - override fun drawExtras(c: Canvas) { + override fun drawExtras(canvas: Canvas) { } private val _hsvBuffer = FloatArray(3) @@ -184,7 +185,7 @@ open class BubbleChartRenderer( paintHighlight.strokeWidth = Utils.convertDpToPixel(1.5f) } - override fun drawHighlighted(c: Canvas, indices: Array) { + override fun drawHighlighted(canvas: Canvas, indices: Array) { val bubbleData = chart.bubbleData val phaseY = animator.phaseY @@ -248,7 +249,7 @@ open class BubbleChartRenderer( paintHighlight.color = color paintHighlight.strokeWidth = set.highlightCircleWidth - c.drawCircle(pointBuffer[0], pointBuffer[1], shapeHalf, paintHighlight) + canvas.drawCircle(pointBuffer[0], pointBuffer[1], shapeHalf, paintHighlight) } } } 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 index 15618802e..1f6730a27 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/CandleStickChartRenderer.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/CandleStickChartRenderer.kt @@ -24,15 +24,15 @@ open class CandleStickChartRenderer( override fun initBuffers() = Unit - override fun drawData(c: Canvas) { + override fun drawData(canvas: Canvas) { val candleData = chart.candleData for (set in candleData.dataSets) { - if (set.isVisible) drawDataSet(c, set) + if (set.isVisible) drawDataSet(canvas, set) } } - protected fun drawDataSet(c: Canvas, dataSet: ICandleDataSet) { + protected fun drawDataSet(canvas: Canvas, dataSet: ICandleDataSet) { val trans = chart.getTransformer(dataSet.axisDependency) val phaseY = animator.phaseY @@ -95,7 +95,7 @@ open class CandleStickChartRenderer( paintRender.style = Paint.Style.STROKE - c.drawLines(shadowBuffers, paintRender) + canvas.drawLines(shadowBuffers, paintRender) // calculate the body bodyBuffers[0] = xPos - 0.5f + barSpace @@ -116,7 +116,7 @@ open class CandleStickChartRenderer( paintRender.style = dataSet.decreasingPaintStyle - c.drawRect( + canvas.drawRect( bodyBuffers[0], bodyBuffers[3], bodyBuffers[2], bodyBuffers[1], paintRender @@ -130,7 +130,7 @@ open class CandleStickChartRenderer( paintRender.style = dataSet.increasingPaintStyle - c.drawRect( + canvas.drawRect( bodyBuffers[0], bodyBuffers[1], bodyBuffers[2], bodyBuffers[3], paintRender @@ -143,7 +143,7 @@ open class CandleStickChartRenderer( paintRender.color = dataSet.neutralColor } - c.drawLine( + canvas.drawLine( bodyBuffers[0], bodyBuffers[1], bodyBuffers[2], bodyBuffers[3], paintRender @@ -184,17 +184,17 @@ open class CandleStickChartRenderer( dataSet.neutralColor paintRender.color = barColor - c.drawLine( + canvas.drawLine( rangeBuffers[0], rangeBuffers[1], rangeBuffers[2], rangeBuffers[3], paintRender ) - c.drawLine( + canvas.drawLine( openBuffers[0], openBuffers[1], openBuffers[2], openBuffers[3], paintRender ) - c.drawLine( + canvas.drawLine( closeBuffers[0], closeBuffers[1], closeBuffers[2], closeBuffers[3], paintRender @@ -203,7 +203,7 @@ open class CandleStickChartRenderer( } } - override fun drawValues(c: Canvas) { + override fun drawValues(canvas: Canvas) { // if values are drawn if (isDrawingValuesAllowed(chart)) { val dataSets = chart.candleData.dataSets @@ -250,7 +250,7 @@ open class CandleStickChartRenderer( if (dataSet.isDrawValuesEnabled) { drawValue( - c, + canvas, dataSet.valueFormatter, entry.high, entry, @@ -266,7 +266,7 @@ open class CandleStickChartRenderer( val icon = entry.icon Utils.drawImage( - c, + canvas, icon, (x + iconsOffset.x).toInt(), (y + iconsOffset.y).toInt(), @@ -282,9 +282,9 @@ open class CandleStickChartRenderer( } } - override fun drawExtras(c: Canvas) = Unit + override fun drawExtras(canvas: Canvas) = Unit - override fun drawHighlighted(c: Canvas, indices: Array) { + override fun drawHighlighted(canvas: Canvas, indices: Array) { val candleData = chart.candleData for (high in indices) { @@ -305,7 +305,7 @@ open class CandleStickChartRenderer( high.setDraw(pix.x.toFloat(), pix.y.toFloat()) // draw the lines - drawHighlightLines(c, pix.x.toFloat(), pix.y.toFloat(), set) + drawHighlightLines(canvas, pix.x.toFloat(), pix.y.toFloat(), set) } } } diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/CombinedChartRenderer.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/CombinedChartRenderer.kt index 18b80e47f..9b9e794af 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/CombinedChartRenderer.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/CombinedChartRenderer.kt @@ -49,16 +49,16 @@ open class CombinedChartRenderer(chart: CombinedChart, animator: ChartAnimator, for (renderer in dataRenderers) renderer.initBuffers() } - override fun drawData(c: Canvas) { - for (renderer in dataRenderers) renderer.drawData(c) + override fun drawData(canvas: Canvas) { + for (renderer in dataRenderers) renderer.drawData(canvas) } - override fun drawValues(c: Canvas) { - for (renderer in dataRenderers) renderer.drawValues(c) + override fun drawValues(canvas: Canvas) { + for (renderer in dataRenderers) renderer.drawValues(canvas) } - override fun drawExtras(c: Canvas) { - for (renderer in dataRenderers) renderer.drawExtras(c) + override fun drawExtras(canvas: Canvas) { + for (renderer in dataRenderers) renderer.drawExtras(canvas) } protected var mHighlightBuffer: MutableList = ArrayList() @@ -67,7 +67,7 @@ open class CombinedChartRenderer(chart: CombinedChart, animator: ChartAnimator, createRenderers() } - override fun drawHighlighted(c: Canvas, indices: Array) { + override fun drawHighlighted(canvas: Canvas, indices: Array) { val chart = weakChart.get() ?: return for (renderer in dataRenderers) { @@ -90,7 +90,7 @@ open class CombinedChartRenderer(chart: CombinedChart, animator: ChartAnimator, if (h.dataIndex == dataIndex || h.dataIndex == -1) mHighlightBuffer.add(h) } - renderer.drawHighlighted(c, mHighlightBuffer.toTypedArray()) + renderer.drawHighlighted(canvas, mHighlightBuffer.toTypedArray()) } } diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/DataRenderer.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/DataRenderer.kt index 6742f9cdd..8be6203cc 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/DataRenderer.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/DataRenderer.kt @@ -67,7 +67,7 @@ abstract class DataRenderer( * object. */ protected fun applyValueTextStyle(set: IDataSet<*>) { - paintValues.setTypeface(set.valueTypeface) + paintValues.typeface = set.valueTypeface paintValues.textSize = set.valueTextSize } @@ -81,17 +81,17 @@ abstract class DataRenderer( /** * Draws the actual data in form of lines, bars, ... depending on Renderer subclass. */ - abstract fun drawData(c: Canvas) + abstract fun drawData(canvas: Canvas) /** * Loops over all Entries and draws their values. */ - abstract fun drawValues(c: Canvas) + abstract fun drawValues(canvas: Canvas) /** * Draws the value of the given entry by using the provided IValueFormatter. * - * @param c canvas + * @param canvas canvas * @param formatter formatter for custom value-formatting * @param value the value to be drawn * @param entry the entry the value belongs to @@ -99,19 +99,19 @@ abstract class DataRenderer( * @param x position * @param y position */ - fun drawValue(c: Canvas, formatter: IValueFormatter, value: Float, entry: Entry?, dataSetIndex: Int, x: Float, y: Float, color: Int) { + fun drawValue(canvas: Canvas, formatter: IValueFormatter, value: Float, entry: Entry?, dataSetIndex: Int, x: Float, y: Float, color: Int) { paintValues.color = color - c.drawText(formatter.getFormattedValue(value, entry, dataSetIndex, viewPortHandler)!!, x, y, paintValues) + canvas.drawText(formatter.getFormattedValue(value, entry, dataSetIndex, viewPortHandler)!!, x, y, paintValues) } /** * Draws any kind of additional information (e.g. line-circles). */ - abstract fun drawExtras(c: Canvas) + abstract fun drawExtras(canvas: Canvas) /** * Draws all highlight indicators for the values that are currently highlighted. * @param indices the highlighted values */ - abstract fun drawHighlighted(c: Canvas, indices: Array) + abstract fun drawHighlighted(canvas: Canvas, indices: Array) } 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 index 0b2ec45a2..56b2578b7 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/HorizontalBarChartRenderer.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/HorizontalBarChartRenderer.kt @@ -44,7 +44,7 @@ open class HorizontalBarChartRenderer( paintValues.textAlign = Align.LEFT } - override fun drawDataSet(c: Canvas, dataSet: IBarDataSet, index: Int) { + override fun drawDataSet(canvas: Canvas, dataSet: IBarDataSet, index: Int) { val trans = chart.getTransformer(dataSet.axisDependency) barBorderPaint.color = dataSet.barBorderColor @@ -90,7 +90,7 @@ open class HorizontalBarChartRenderer( mBarShadowRectBuffer.left = viewPortHandler.contentLeft() mBarShadowRectBuffer.right = viewPortHandler.contentRight() - c.drawRect(mBarShadowRectBuffer, shadowPaint) + canvas.drawRect(mBarShadowRectBuffer, shadowPaint) i++ } } @@ -136,7 +136,7 @@ open class HorizontalBarChartRenderer( if (isCustomFill) { dataSet.getFill(pos) .fillRect( - c, paintRender, + canvas, paintRender, buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], @@ -145,14 +145,14 @@ open class HorizontalBarChartRenderer( 0f ) } else { - c.drawRect( + canvas.drawRect( buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], buffer.buffer[j + 3], paintRender ) } if (drawBorder) { - c.drawRect( + canvas.drawRect( buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], buffer.buffer[j + 3], barBorderPaint ) @@ -162,7 +162,7 @@ open class HorizontalBarChartRenderer( } } - override fun drawValues(c: Canvas) { + override fun drawValues(canvas: Canvas) { // if values are drawn if (isDrawingValuesAllowed(chart)) { val dataSets = chart.barData.dataSets @@ -235,7 +235,7 @@ open class HorizontalBarChartRenderer( if (dataSet.isDrawValuesEnabled) { drawValue( - c, + canvas, formattedValue!!, buffer.buffer[j + 2] + (if (`val` >= 0) posOffset else negOffset), y + halfTextHeight, @@ -253,7 +253,7 @@ open class HorizontalBarChartRenderer( py += iconsOffset.y Utils.drawImage( - c, + canvas, icon, px.toInt(), py.toInt(), @@ -311,7 +311,7 @@ open class HorizontalBarChartRenderer( if (dataSet.isDrawValuesEnabled) { drawValue( - c, formattedValue!!, + canvas, formattedValue!!, buffer.buffer[bufferIndex + 2] + (if (entry.y >= 0) posOffset else negOffset), buffer.buffer[bufferIndex + 1] + halfTextHeight, color @@ -329,7 +329,7 @@ open class HorizontalBarChartRenderer( py += iconsOffset.y Utils.drawImage( - c, + canvas, icon, px.toInt(), py.toInt(), @@ -410,14 +410,14 @@ open class HorizontalBarChartRenderer( } if (dataSet.isDrawValuesEnabled) { - drawValue(c, formattedValue!!, x, y + halfTextHeight, color) + drawValue(canvas, formattedValue!!, x, y + halfTextHeight, color) } if (entry.icon != null && dataSet.isDrawIconsEnabled) { val icon = entry.icon Utils.drawImage( - c, + canvas, icon, (x + iconsOffset.x).toInt(), (y + iconsOffset.y).toInt(), @@ -439,18 +439,16 @@ open class HorizontalBarChartRenderer( } } - protected fun drawValue(c: Canvas, valueText: String, x: Float, y: Float, color: Int) { + protected fun drawValue(canvas: Canvas, valueText: String, x: Float, y: Float, color: Int) { paintValues.color = color - c.drawText(valueText, x, y, paintValues) + canvas.drawText(valueText, x, y, paintValues) } override fun prepareBarHighlight(x: Float, y1: Float, y2: Float, barWidthHalf: Float, trans: Transformer) { val top = x - barWidthHalf val bottom = x + barWidthHalf - val left = y1 - val right = y2 - barRect[left, top, right] = bottom + barRect[y1, top, y2] = bottom trans.rectToPixelPhaseHorizontal(barRect, animator.phaseY) } diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/LegendRenderer.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/LegendRenderer.kt index 7afa7c16e..0f6954402 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/LegendRenderer.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/LegendRenderer.kt @@ -186,7 +186,7 @@ open class LegendRenderer( val tf = legend.typeface - if (tf != null) labelPaint.setTypeface(tf) + if (tf != null) labelPaint.typeface = tf labelPaint.textSize = legend.textSize labelPaint.color = legend.textColor @@ -197,12 +197,12 @@ open class LegendRenderer( protected var legendFontMetrics: Paint.FontMetrics = Paint.FontMetrics() - fun renderLegend(c: Canvas) { + fun renderLegend(canvas: Canvas) { if (!legend.isEnabled) return val tf = legend.typeface - if (tf != null) labelPaint.setTypeface(tf) + if (tf != null) labelPaint.typeface = tf labelPaint.textSize = legend.textSize labelPaint.color = legend.textColor @@ -227,7 +227,7 @@ open class LegendRenderer( val yOffset = legend.yOffset val xOffset = legend.xOffset - var originPosX = 0f + var originPosX: Float when (horizontalAlignment) { LegendHorizontalAlignment.LEFT -> { @@ -308,7 +308,7 @@ open class LegendRenderer( if (drawingForm) { if (direction == LegendDirection.RIGHT_TO_LEFT) posX -= formSize - drawForm(c, posX, posY + formYOffset, e, legend) + drawForm(canvas, posX, posY + formYOffset, e, legend) if (direction == LegendDirection.LEFT_TO_RIGHT) posX += formSize } @@ -318,7 +318,7 @@ open class LegendRenderer( if (direction == LegendDirection.RIGHT_TO_LEFT) posX -= calculatedLabelSizes[i].width - drawLabel(c, posX, posY + labelLineHeight, e.label) + drawLabel(canvas, posX, posY + labelLineHeight, e.label) if (direction == LegendDirection.LEFT_TO_RIGHT) posX += calculatedLabelSizes[i].width @@ -332,7 +332,7 @@ open class LegendRenderer( // contains the stacked legend size in pixels var stack = 0f var wasStacked = false - var posY = 0f + var posY: Float when (verticalAlignment) { LegendVerticalAlignment.TOP -> { @@ -368,7 +368,7 @@ open class LegendRenderer( if (direction == LegendDirection.LEFT_TO_RIGHT) posX += stack else posX -= formSize - stack - drawForm(c, posX, posY + formYOffset, e, legend) + drawForm(canvas, posX, posY + formYOffset, e, legend) if (direction == LegendDirection.LEFT_TO_RIGHT) posX += formSize } @@ -383,10 +383,10 @@ open class LegendRenderer( if (direction == LegendDirection.RIGHT_TO_LEFT) posX -= Utils.calcTextWidth(labelPaint, e.label).toFloat() if (!wasStacked) { - drawLabel(c, posX, posY + labelLineHeight, e.label) + drawLabel(canvas, posX, posY + labelLineHeight, e.label) } else { posY += labelLineHeight + labelLineSpacing - drawLabel(c, posX, posY + labelLineHeight, e.label) + drawLabel(canvas, posX, posY + labelLineHeight, e.label) } // make a step down @@ -417,21 +417,21 @@ open class LegendRenderer( * Draws the Legend-form at the given position with the color at the given * index. * - * @param c canvas to draw with + * @param canvas canvas to draw with * @param x position * @param y position * @param entry the entry to render * @param legend the legend context */ protected fun drawForm( - c: Canvas, + canvas: Canvas, x: Float, y: Float, entry: LegendEntry, legend: Legend ) { if (entry.formColor == ColorTemplate.COLOR_SKIP || entry.formColor == ColorTemplate.COLOR_NONE || entry.formColor == 0) return - c.withSave { + canvas.withSave { var form = entry.form if (form == LegendForm.DEFAULT) form = legend.form @@ -451,12 +451,12 @@ open class LegendRenderer( LegendForm.EMPTY -> {} LegendForm.DEFAULT, LegendForm.CIRCLE -> { formPaint.style = Paint.Style.FILL - c.drawCircle(x + half, y, half, formPaint) + canvas.drawCircle(x + half, y, half, formPaint) } LegendForm.SQUARE -> { formPaint.style = Paint.Style.FILL - c.drawRect(x, y - half, x + formSize, y + half, formPaint) + canvas.drawRect(x, y - half, x + formSize, y + half, formPaint) } LegendForm.LINE -> { @@ -472,12 +472,12 @@ open class LegendRenderer( entry.formLineDashEffect formPaint.style = Paint.Style.STROKE formPaint.strokeWidth = formLineWidth - formPaint.setPathEffect(formLineDashEffect) + formPaint.pathEffect = formLineDashEffect mLineFormPath.reset() mLineFormPath.moveTo(x, y) mLineFormPath.lineTo(x + formSize, y) - c.drawPath(mLineFormPath, formPaint) + canvas.drawPath(mLineFormPath, formPaint) } } @@ -487,12 +487,12 @@ open class LegendRenderer( /** * Draws the provided label at the given position. * - * @param c canvas to draw with + * @param canvas canvas to draw with * @param x * @param y * @param label the label to draw */ - protected fun drawLabel(c: Canvas, x: Float, y: Float, label: String) { - c.drawText(label, x, y, labelPaint) + protected fun drawLabel(canvas: Canvas, x: Float, y: Float, label: String) { + canvas.drawText(label, x, y, labelPaint) } } 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 index 195cb7ea4..41826b7d6 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/LineChartRenderer.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/LineChartRenderer.kt @@ -55,7 +55,7 @@ class LineChartRenderer( override fun initBuffers() { } - override fun drawData(c: Canvas) { + override fun drawData(canvas: Canvas) { val width = viewPortHandler.chartWidth.toInt() val height = viewPortHandler.chartHeight.toInt() @@ -77,12 +77,12 @@ class LineChartRenderer( val lineData = chart.lineData for (set in lineData.dataSets) { - if (set.isVisible) drawDataSet(c, set) + if (set.isVisible) drawDataSet(canvas, set) } - c.drawBitmap(drawBitmapLocal, 0f, 0f, null) + canvas.drawBitmap(drawBitmapLocal, 0f, 0f, null) } - protected fun drawDataSet(c: Canvas, dataSet: ILineDataSet) { + protected fun drawDataSet(canvas: Canvas, dataSet: ILineDataSet) { if (dataSet.entryCount < 1) return @@ -90,10 +90,10 @@ class LineChartRenderer( paintRender.setPathEffect(dataSet.dashPathEffect) when (dataSet.mode) { - LineDataSet.Mode.LINEAR, LineDataSet.Mode.STEPPED -> drawLinear(c, dataSet) + LineDataSet.Mode.LINEAR, LineDataSet.Mode.STEPPED -> drawLinear(canvas, dataSet) LineDataSet.Mode.CUBIC_BEZIER -> drawCubicBezier(dataSet) LineDataSet.Mode.HORIZONTAL_BEZIER -> drawHorizontalBezier(dataSet) - else -> drawLinear(c, dataSet) + else -> drawLinear(canvas, dataSet) } paintRender.setPathEffect(null) @@ -224,7 +224,7 @@ class LineChartRenderer( paintRender.setPathEffect(null) } - protected fun drawCubicFill(c: Canvas, dataSet: ILineDataSet, spline: Path, trans: Transformer, bounds: XBounds) { + protected fun drawCubicFill(canvas: Canvas, dataSet: ILineDataSet, spline: Path, trans: Transformer, bounds: XBounds) { val fillMin = dataSet.fillFormatter.getFillLinePosition(dataSet, chart) spline.lineTo(dataSet.getEntryForIndex(bounds.min + bounds.range).x, fillMin) @@ -235,9 +235,9 @@ class LineChartRenderer( val drawable = dataSet.fillDrawable if (drawable != null) { - drawFilledPath(c, spline, drawable) + drawFilledPath(canvas, spline, drawable) } else { - drawFilledPath(c, spline, dataSet.fillColor, dataSet.fillAlpha) + drawFilledPath(canvas, spline, dataSet.fillColor, dataSet.fillAlpha) } } @@ -288,8 +288,6 @@ class LineChartRenderer( if (j < xBounds.max) { entry = dataSet.getEntryForIndex(j + 1) - if (entry == null) break - if (isDrawSteppedEnabled) { lineBuffer[2] = entry.x lineBuffer[3] = lineBuffer[1] @@ -390,12 +388,12 @@ class LineChartRenderer( /** * Draws a filled linear path on the canvas. * - * @param c + * @param canvas * @param dataSet * @param trans * @param bounds */ - protected fun drawLinearFill(c: Canvas, dataSet: ILineDataSet, trans: Transformer, bounds: XBounds) { + protected fun drawLinearFill(canvas: Canvas, dataSet: ILineDataSet, trans: Transformer, bounds: XBounds) { val filled = mGenerateFilledPathBuffer val startingIndex = bounds.min @@ -429,9 +427,9 @@ class LineChartRenderer( trans.pathValueToPixel(filled) if (drawable != null) { - drawFilledPath(c, filled, drawable) + drawFilledPath(canvas, filled, drawable) } else { - drawFilledPath(c, filled, dataSet.fillColor, dataSet.fillAlpha) + drawFilledPath(canvas, filled, dataSet.fillColor, dataSet.fillAlpha) } } @@ -486,7 +484,7 @@ class LineChartRenderer( filled.close() } - override fun drawValues(c: Canvas) { + override fun drawValues(canvas: Canvas) { if (isDrawingValuesAllowed(chart)) { val dataSets = chart.lineData.dataSets @@ -537,7 +535,7 @@ class LineChartRenderer( if (entry != null) { if (dataSet.isDrawValuesEnabled) { drawValue( - c, dataSet.valueFormatter, entry.y, entry, i, x, + canvas, dataSet.valueFormatter, entry.y, entry, i, x, y - valOffset, dataSet.getValueTextColor(j / 2) ) } @@ -546,7 +544,7 @@ class LineChartRenderer( val icon = entry.icon Utils.drawImage( - c, + canvas, icon, (x + iconsOffset.x).toInt(), (y + iconsOffset.y).toInt(), @@ -563,8 +561,8 @@ class LineChartRenderer( } } - override fun drawExtras(c: Canvas) { - drawCircles(c) + override fun drawExtras(canvas: Canvas) { + drawCircles(canvas) } /** @@ -582,7 +580,7 @@ class LineChartRenderer( circlePaintInner.color = Color.WHITE } - protected fun drawCircles(c: Canvas) { + protected fun drawCircles(canvas: Canvas) { paintRender.style = Paint.Style.FILL val phaseY = animator.phaseY @@ -644,13 +642,13 @@ class LineChartRenderer( val circleBitmap = imageCache.getBitmap(j) if (circleBitmap != null) { - c.drawBitmap(circleBitmap, mCirclesBuffer[0] - circleRadius, mCirclesBuffer[1] - circleRadius, null) + canvas.drawBitmap(circleBitmap, mCirclesBuffer[0] - circleRadius, mCirclesBuffer[1] - circleRadius, null) } } } } - override fun drawHighlighted(c: Canvas, indices: Array) { + override fun drawHighlighted(canvas: Canvas, indices: Array) { val lineData = chart.lineData for (high in indices) { @@ -670,29 +668,10 @@ class LineChartRenderer( high.setDraw(pix.x.toFloat(), pix.y.toFloat()) // draw the lines - drawHighlightLines(c, pix.x.toFloat(), pix.y.toFloat(), set) + drawHighlightLines(canvas, pix.x.toFloat(), pix.y.toFloat(), set) } } - var bitmapConfig: Bitmap.Config - /** - * Returns the Bitmap.Config that is used by this renderer. - * - * @return - */ - get() = mBitmapConfig - /** - * Sets the Bitmap.Config to be used by this renderer. - * Default: Bitmap.Config.ARGB_8888 - * Use Bitmap.Config.ARGB_4444 to consume less memory. - * - * @param config - */ - set(config) { - mBitmapConfig = config - releaseBitmap() - } - /** * Releases the drawing bitmap. This should be called when [LineChart.onDetachedFromWindow]. */ 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 index 7a499f073..6b3bab8fe 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/LineRadarRenderer.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/LineRadarRenderer.kt @@ -14,20 +14,20 @@ abstract class LineRadarRenderer(animator: ChartAnimator?, viewPortHandler: View /** * Draws the provided path in filled mode with the provided drawable. * - * @param c + * @param canvas * @param filledPath * @param drawable */ - protected fun drawFilledPath(c: Canvas, filledPath: Path, drawable: Drawable) { + protected fun drawFilledPath(canvas: Canvas, filledPath: Path, drawable: Drawable) { if (clipPathSupported()) { - c.withClip(filledPath) { + canvas.withClip(filledPath) { drawable.setBounds( viewPortHandler.contentLeft().toInt(), viewPortHandler.contentTop().toInt(), viewPortHandler.contentRight().toInt(), viewPortHandler.contentBottom().toInt() ) - drawable.draw(c) + drawable.draw(canvas) } } else { throw RuntimeException( @@ -41,17 +41,17 @@ abstract class LineRadarRenderer(animator: ChartAnimator?, viewPortHandler: View * Draws the provided path in filled mode with the provided color and alpha. * Special thanks to Angelo Suzuki (https://github.com/tinsukE) for this. * - * @param c + * @param canvas * @param filledPath * @param fillColor * @param fillAlpha */ - protected fun drawFilledPath(c: Canvas, filledPath: Path, fillColor: Int, fillAlpha: Int) { + protected fun drawFilledPath(canvas: Canvas, filledPath: Path, fillColor: Int, fillAlpha: Int) { val color = (fillAlpha shl 24) or (fillColor and 0xffffff) if (clipPathSupported()) { - c.withClip(filledPath) { - c.drawColor(color) + canvas.withClip(filledPath) { + canvas.drawColor(color) } } else { // save @@ -63,7 +63,7 @@ abstract class LineRadarRenderer(animator: ChartAnimator?, viewPortHandler: View paintRender.style = Paint.Style.FILL paintRender.color = color - c.drawPath(filledPath, paintRender) + canvas.drawPath(filledPath, paintRender) // restore paintRender.color = previousColor 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 index 5616e3a8b..a98c3f2fd 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/LineScatterCandleRadarRenderer.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/LineScatterCandleRadarRenderer.kt @@ -16,19 +16,19 @@ abstract class LineScatterCandleRadarRenderer(animator: ChartAnimator?, viewPort /** * Draws vertical & horizontal highlight-lines if enabled. * - * @param c + * @param canvas * @param x x-position of the highlight line intersection * @param y y-position of the highlight line intersection * @param set the currently drawn dataset */ - protected fun drawHighlightLines(c: Canvas, x: Float, y: Float, set: ILineScatterCandleRadarDataSet<*>) { + protected fun drawHighlightLines(canvas: Canvas, x: Float, y: Float, set: ILineScatterCandleRadarDataSet<*>) { // set color and stroke-width paintHighlight.color = set.highLightColor paintHighlight.strokeWidth = set.highlightLineWidth // draw highlighted lines (if enabled) - paintHighlight.setPathEffect(set.dashPathEffectHighlight) + paintHighlight.pathEffect = set.dashPathEffectHighlight // draw vertical highlight lines if (set.isVerticalHighlightIndicatorEnabled) { @@ -38,7 +38,7 @@ abstract class LineScatterCandleRadarRenderer(animator: ChartAnimator?, viewPort highlightLinePath.moveTo(x, viewPortHandler.contentTop()) highlightLinePath.lineTo(x, viewPortHandler.contentBottom()) - c.drawPath(highlightLinePath, paintHighlight) + canvas.drawPath(highlightLinePath, paintHighlight) } // draw horizontal highlight lines @@ -49,7 +49,7 @@ abstract class LineScatterCandleRadarRenderer(animator: ChartAnimator?, viewPort highlightLinePath.moveTo(viewPortHandler.contentLeft(), y) highlightLinePath.lineTo(viewPortHandler.contentRight(), y) - c.drawPath(highlightLinePath, paintHighlight) + canvas.drawPath(highlightLinePath, paintHighlight) } } } diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/PieChartRenderer.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/PieChartRenderer.kt index 5043bef5f..74abd0dc4 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/PieChartRenderer.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/PieChartRenderer.kt @@ -82,7 +82,7 @@ open class PieChartRenderer( override fun initBuffers() = Unit - override fun drawData(c: Canvas) { + override fun drawData(canvas: Canvas) { val width = viewPortHandler.chartWidth.toInt() val height = viewPortHandler.chartHeight.toInt() @@ -106,7 +106,7 @@ open class PieChartRenderer( val pieData = chart.data for (set in pieData!!.dataSets) { - if (set.isVisible && set.entryCount > 0) drawDataSet(c, set) + if (set.isVisible && set.entryCount > 0) drawDataSet(canvas, set) } } @@ -171,7 +171,7 @@ open class PieChartRenderer( return sliceSpace } - protected fun drawDataSet(c: Canvas?, dataSet: IPieDataSet) { + protected fun drawDataSet(canvas: Canvas?, dataSet: IPieDataSet) { var angle = 0f val rotationAngle = chart.rotationAngle @@ -362,7 +362,7 @@ open class PieChartRenderer( MPPointF.recycleInstance(center) } - override fun drawValues(c: Canvas) { + override fun drawValues(canvas: Canvas) { val center = chart.centerCircleBox // get whole the radius @@ -399,7 +399,7 @@ open class PieChartRenderer( var angle: Float var xIndex = 0 - c.withSave { + canvas.withSave { val offset = Utils.convertDpToPixel(5f) for (i in dataSets.indices) { @@ -610,19 +610,19 @@ open class PieChartRenderer( /** * Draws an entry label at the specified position. * - * @param c + * @param canvas * @param label * @param x * @param y */ - protected fun drawEntryLabel(c: Canvas, label: String, x: Float, y: Float) { - c.drawText(label, x, y, paintEntryLabels) + protected fun drawEntryLabel(canvas: Canvas, label: String, x: Float, y: Float) { + canvas.drawText(label, x, y, paintEntryLabels) } - override fun drawExtras(c: Canvas) { - drawHole(c) - c.drawBitmap(mDrawBitmap!!.get()!!, 0f, 0f, null) - drawCenterText(c) + override fun drawExtras(canvas: Canvas) { + drawHole(canvas) + canvas.drawBitmap(mDrawBitmap!!.get()!!, 0f, 0f, null) + drawCenterText(canvas) } private val mHoleCirclePath = Path() @@ -631,7 +631,7 @@ open class PieChartRenderer( * draws the hole in the center of the chart and the transparent circle / * hole */ - protected fun drawHole(c: Canvas?) { + protected fun drawHole(canvas: Canvas?) { if (chart.isDrawHoleEnabled && bitmapCanvas != null) { val radius = chart.radius val holeRadius = radius * (chart.holeRadius / 100) @@ -673,7 +673,7 @@ open class PieChartRenderer( * draws the description text in the center of the pie chart makes most * sense when center-hole is enabled */ - protected fun drawCenterText(c: Canvas) { + protected fun drawCenterText(canvas: Canvas) { val centerText = chart.centerText if (chart.isDrawCenterTextEnabled && centerText != null) { @@ -724,18 +724,18 @@ open class PieChartRenderer( //float layoutWidth = Utils.getStaticLayoutMaxWidth(mCenterTextLayout); val layoutHeight = centerTextLayout!!.height.toFloat() - c.save() + canvas.save() if (Build.VERSION.SDK_INT >= 18) { val path = mDrawCenterTextPathBuffer path.reset() path.addOval(holeRect, Path.Direction.CW) - c.clipPath(path) + canvas.clipPath(path) } - c.translate(boundingRect.left, boundingRect.top + (boundingRect.height() - layoutHeight) / 2f) - centerTextLayout!!.draw(c) + canvas.translate(boundingRect.left, boundingRect.top + (boundingRect.height() - layoutHeight) / 2f) + centerTextLayout!!.draw(canvas) - c.restore() + canvas.restore() MPPointF.recycleInstance(center) MPPointF.recycleInstance(offset) @@ -775,7 +775,7 @@ open class PieChartRenderer( roundedCornerPaint.isAntiAlias = true } - override fun drawHighlighted(c: Canvas, indices: Array) { + override fun drawHighlighted(canvas: Canvas, indices: Array) { /* Skip entirely if using rounded circle slices, because it doesn't make sense to highlight * in this way. * TODO: add support for changing slice color with highlighting rather than only shifting the slice @@ -959,9 +959,9 @@ open class PieChartRenderer( /** * This gives all pie-slices a rounded edge. * - * @param c + * @param canvas */ - protected fun drawRoundedSlices(c: Canvas?) { + protected fun drawRoundedSlices(canvas: Canvas?) { if (!chart.isDrawRoundedSlicesEnabled) return val dataSet = chart.data!!.dataSet 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 index 99bf27ac5..371df7164 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/RadarChartRenderer.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/RadarChartRenderer.kt @@ -30,14 +30,14 @@ open class RadarChartRenderer( override fun initBuffers() = Unit - override fun drawData(c: Canvas) { + override fun drawData(canvas: Canvas) { val radarData = chart.data val mostEntries = radarData!!.maxEntryCountSet.entryCount for (set in radarData.dataSets) { if (set.isVisible) { - drawDataSet(c, set, mostEntries) + drawDataSet(canvas, set, mostEntries) } } } @@ -47,15 +47,15 @@ open class RadarChartRenderer( /** * Draws the RadarDataSet * - * @param c + * @param canvas * @param dataSet * @param mostEntries the entry count of the dataset with the most entries */ - protected fun drawDataSet(c: Canvas, dataSet: IRadarDataSet, mostEntries: Int) { + protected fun drawDataSet(canvas: Canvas, dataSet: IRadarDataSet, mostEntries: Int) { val phaseX = animator.phaseX val phaseY = animator.phaseY - val sliceangle = chart.sliceAngle + val sliceAngle = chart.sliceAngle // calculate the factor that is needed for transforming the value to // pixels @@ -76,7 +76,7 @@ open class RadarChartRenderer( Utils.getPosition( center, (e.y - chart.yChartMin) * factor * phaseY, - sliceangle * j * phaseX + chart.rotationAngle, pOut + sliceAngle * j * phaseX + chart.rotationAngle, pOut ) if (java.lang.Float.isNaN(pOut.x)) continue @@ -97,9 +97,9 @@ open class RadarChartRenderer( if (dataSet.isDrawFilledEnabled) { val drawable = dataSet.fillDrawable if (drawable != null) { - drawFilledPath(c, surface, drawable) + drawFilledPath(canvas, surface, drawable) } else { - drawFilledPath(c, surface, dataSet.fillColor, dataSet.fillAlpha) + drawFilledPath(canvas, surface, dataSet.fillColor, dataSet.fillAlpha) } } @@ -107,17 +107,17 @@ open class RadarChartRenderer( paintRender.style = Paint.Style.STROKE // draw the line (only if filled is disabled or alpha is below 255) - if (!dataSet.isDrawFilledEnabled || dataSet.fillAlpha < 255) c.drawPath(surface, paintRender) + if (!dataSet.isDrawFilledEnabled || dataSet.fillAlpha < 255) canvas.drawPath(surface, paintRender) MPPointF.recycleInstance(center) MPPointF.recycleInstance(pOut) } - override fun drawValues(c: Canvas) { + override fun drawValues(canvas: Canvas) { val phaseX = animator.phaseX val phaseY = animator.phaseY - val sliceangle = chart.sliceAngle + val sliceAngle = chart.sliceAngle // calculate the factor that is needed for transforming the value to // pixels @@ -127,7 +127,7 @@ open class RadarChartRenderer( val pOut = MPPointF.getInstance(0f, 0f) val pIcon = MPPointF.getInstance(0f, 0f) - val yoffset = Utils.convertDpToPixel(5f) + val yOffset = Utils.convertDpToPixel(5f) for (i in 0..) { - val sliceangle = chart.sliceAngle + override fun drawHighlighted(canvas: Canvas, indices: Array) { + val sliceAngle = chart.sliceAngle // calculate the factor that is needed for transforming the value to // pixels @@ -309,14 +309,14 @@ open class RadarChartRenderer( Utils.getPosition( center, y * factor * animator.phaseY, - sliceangle * high.x * animator.phaseX + chart.rotationAngle, + sliceAngle * high.x * animator.phaseX + chart.rotationAngle, pOut ) high.setDraw(pOut.x, pOut.y) // draw the lines - drawHighlightLines(c, pOut.x, pOut.y, set) + drawHighlightLines(canvas, pOut.x, pOut.y, set) if (set.isDrawHighlightCircleEnabled) { if (!java.lang.Float.isNaN(pOut.x) && !java.lang.Float.isNaN(pOut.y)) { @@ -330,7 +330,7 @@ open class RadarChartRenderer( } drawHighlightCircle( - c, + canvas, pOut, set.highlightCircleInnerRadius, set.highlightCircleOuterRadius, @@ -365,7 +365,7 @@ open class RadarChartRenderer( } fun drawHighlightCircle( - c: Canvas, + canvas: Canvas, point: MPPointF, innerRadius: Float, outerRadius: Float, @@ -375,7 +375,7 @@ open class RadarChartRenderer( ) { var innerRadiusLocal = innerRadius var outerRadiusLocal = outerRadius - c.withSave { + canvas.withSave { outerRadiusLocal = Utils.convertDpToPixel(outerRadiusLocal) innerRadiusLocal = Utils.convertDpToPixel(innerRadiusLocal) 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 index 6060642f2..39fc8cb7e 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/RoundedBarChartRenderer.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/RoundedBarChartRenderer.kt @@ -35,7 +35,7 @@ class RoundedBarChartRenderer(chart: BarDataProvider, animator: ChartAnimator?, roundedPositiveDataSetRadius = roundedPositiveDataSet } - override fun drawDataSet(c: Canvas, dataSet: IBarDataSet, index: Int) { + override fun drawDataSet(canvas: Canvas, dataSet: IBarDataSet, index: Int) { initBuffers() val trans = chart.getTransformer(dataSet.axisDependency) barBorderPaint.color = dataSet.barBorderColor @@ -71,9 +71,9 @@ class RoundedBarChartRenderer(chart: BarDataProvider, animator: ChartAnimator?, if (roundedShadowRadius > 0) { - c.drawRoundRect(barRect, roundedShadowRadius, roundedShadowRadius, shadowPaint) + canvas.drawRoundRect(barRect, roundedShadowRadius, roundedShadowRadius, shadowPaint) } else { - c.drawRect(mBarShadowRectBuffer, shadowPaint) + canvas.drawRect(mBarShadowRectBuffer, shadowPaint) } i++ } @@ -102,7 +102,7 @@ class RoundedBarChartRenderer(chart: BarDataProvider, animator: ChartAnimator?, if (chart.isDrawBarShadowEnabled) { if (roundedShadowRadius > 0) { - c.drawRoundRect( + canvas.drawRoundRect( RectF( buffer.buffer[j], viewPortHandler.contentTop(), buffer.buffer[j + 2], @@ -110,7 +110,7 @@ class RoundedBarChartRenderer(chart: BarDataProvider, animator: ChartAnimator?, ), roundedShadowRadius, roundedShadowRadius, shadowPaint ) } else { - c.drawRect( + canvas.drawRect( buffer.buffer[j], viewPortHandler.contentTop(), buffer.buffer[j + 2], viewPortHandler.contentBottom(), shadowPaint @@ -122,14 +122,14 @@ class RoundedBarChartRenderer(chart: BarDataProvider, animator: ChartAnimator?, paintRender.color = dataSet.getColor(j / 4) if (roundedPositiveDataSetRadius > 0) { - c.drawRoundRect( + canvas.drawRoundRect( RectF( buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], buffer.buffer[j + 3] ), roundedPositiveDataSetRadius, roundedPositiveDataSetRadius, paintRender ) } else { - c.drawRect( + canvas.drawRect( buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], buffer.buffer[j + 3], paintRender ) @@ -152,7 +152,7 @@ class RoundedBarChartRenderer(chart: BarDataProvider, animator: ChartAnimator?, if (chart.isDrawBarShadowEnabled) { if (roundedShadowRadius > 0) { - c.drawRoundRect( + canvas.drawRoundRect( RectF( buffer.buffer[j], viewPortHandler.contentTop(), buffer.buffer[j + 2], @@ -160,7 +160,7 @@ class RoundedBarChartRenderer(chart: BarDataProvider, animator: ChartAnimator?, ), roundedShadowRadius, roundedShadowRadius, shadowPaint ) } else { - c.drawRect( + canvas.drawRect( buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], buffer.buffer[j + 3], paintRender ) @@ -168,14 +168,14 @@ class RoundedBarChartRenderer(chart: BarDataProvider, animator: ChartAnimator?, } if (roundedPositiveDataSetRadius > 0) { - c.drawRoundRect( + canvas.drawRoundRect( RectF( buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], buffer.buffer[j + 3] ), roundedPositiveDataSetRadius, roundedPositiveDataSetRadius, paintRender ) } else { - c.drawRect( + canvas.drawRect( buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], buffer.buffer[j + 3], paintRender ) @@ -237,7 +237,7 @@ class RoundedBarChartRenderer(chart: BarDataProvider, animator: ChartAnimator?, buffer.buffer[j + 3] ), roundedNegativeDataSetRadius, roundedNegativeDataSetRadius, true, true, true, true ) - c.drawPath(path2, paintRender) + canvas.drawPath(path2, paintRender) } else if ((dataSet.getEntryForIndex(j / 4).y > 0 && roundedPositiveDataSetRadius > 0)) { val path2 = roundRect( RectF( @@ -245,9 +245,9 @@ class RoundedBarChartRenderer(chart: BarDataProvider, animator: ChartAnimator?, buffer.buffer[j + 3] ), roundedPositiveDataSetRadius, roundedPositiveDataSetRadius, true, true, true, true ) - c.drawPath(path2, paintRender) + canvas.drawPath(path2, paintRender) } else { - c.drawRect( + canvas.drawRect( buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], buffer.buffer[j + 3], paintRender ) @@ -257,7 +257,7 @@ class RoundedBarChartRenderer(chart: BarDataProvider, animator: ChartAnimator?, } } - override fun drawHighlighted(c: Canvas, indices: Array) { + override fun drawHighlighted(canvas: Canvas, indices: Array) { val barData = chart.barData for (high in indices) { @@ -309,7 +309,7 @@ class RoundedBarChartRenderer(chart: BarDataProvider, animator: ChartAnimator?, ), mRadius, mRadius, true, true, true, true ) - c.drawPath(path2, paintHighlight) + canvas.drawPath(path2, paintHighlight) } } 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 index b169a2202..b33ce01df 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/RoundedHorizontalBarChartRenderer.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/RoundedHorizontalBarChartRenderer.kt @@ -37,7 +37,7 @@ class RoundedHorizontalBarChartRenderer(chart: BarDataProvider, animator: ChartA paintValues.textAlign = Paint.Align.LEFT } - override fun drawDataSet(c: Canvas, dataSet: IBarDataSet, index: Int) { + override fun drawDataSet(canvas: Canvas, dataSet: IBarDataSet, index: Int) { initBuffers() val trans = chart.getTransformer(dataSet.axisDependency) barBorderPaint.color = dataSet.barBorderColor @@ -72,9 +72,9 @@ class RoundedHorizontalBarChartRenderer(chart: BarDataProvider, animator: ChartA mBarShadowRectBuffer.right = viewPortHandler.contentRight() if (roundedShadowRadius > 0) { - c.drawRoundRect(barRect, roundedShadowRadius, roundedShadowRadius, shadowPaint) + canvas.drawRoundRect(barRect, roundedShadowRadius, roundedShadowRadius, shadowPaint) } else { - c.drawRect(mBarShadowRectBuffer, shadowPaint) + canvas.drawRect(mBarShadowRectBuffer, shadowPaint) } i++ } @@ -103,7 +103,7 @@ class RoundedHorizontalBarChartRenderer(chart: BarDataProvider, animator: ChartA if (chart.isDrawBarShadowEnabled) { if (roundedShadowRadius > 0) { - c.drawRoundRect( + canvas.drawRoundRect( RectF( buffer.buffer[j], viewPortHandler.contentTop(), buffer.buffer[j + 2], @@ -111,7 +111,7 @@ class RoundedHorizontalBarChartRenderer(chart: BarDataProvider, animator: ChartA ), roundedShadowRadius, roundedShadowRadius, shadowPaint ) } else { - c.drawRect( + canvas.drawRect( buffer.buffer[j], viewPortHandler.contentTop(), buffer.buffer[j + 2], viewPortHandler.contentBottom(), shadowPaint @@ -123,14 +123,14 @@ class RoundedHorizontalBarChartRenderer(chart: BarDataProvider, animator: ChartA paintRender.color = dataSet.getColor(j / 4) if (roundedPositiveDataSetRadius > 0) { - c.drawRoundRect( + canvas.drawRoundRect( RectF( buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], buffer.buffer[j + 3] ), roundedPositiveDataSetRadius, roundedPositiveDataSetRadius, paintRender ) } else { - c.drawRect( + canvas.drawRect( buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], buffer.buffer[j + 3], paintRender ) @@ -153,7 +153,7 @@ class RoundedHorizontalBarChartRenderer(chart: BarDataProvider, animator: ChartA if (chart.isDrawBarShadowEnabled) { if (roundedShadowRadius > 0) { - c.drawRoundRect( + canvas.drawRoundRect( RectF( buffer.buffer[j], viewPortHandler.contentTop(), buffer.buffer[j + 2], @@ -161,7 +161,7 @@ class RoundedHorizontalBarChartRenderer(chart: BarDataProvider, animator: ChartA ), roundedShadowRadius, roundedShadowRadius, shadowPaint ) } else { - c.drawRect( + canvas.drawRect( buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], buffer.buffer[j + 3], paintRender ) @@ -169,14 +169,14 @@ class RoundedHorizontalBarChartRenderer(chart: BarDataProvider, animator: ChartA } if (roundedPositiveDataSetRadius > 0) { - c.drawRoundRect( + canvas.drawRoundRect( RectF( buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], buffer.buffer[j + 3] ), roundedPositiveDataSetRadius, roundedPositiveDataSetRadius, paintRender ) } else { - c.drawRect( + canvas.drawRect( buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], buffer.buffer[j + 3], paintRender ) @@ -212,7 +212,7 @@ class RoundedHorizontalBarChartRenderer(chart: BarDataProvider, animator: ChartA buffer.buffer[j + 3] ), roundedNegativeDataSetRadius, roundedNegativeDataSetRadius, true, true, true, true ) - c.drawPath(path2, paintRender) + canvas.drawPath(path2, paintRender) } else if ((dataSet.getEntryForIndex(j / 4).y > 0 && roundedPositiveDataSetRadius > 0)) { val path2 = roundRect( RectF( @@ -220,9 +220,9 @@ class RoundedHorizontalBarChartRenderer(chart: BarDataProvider, animator: ChartA buffer.buffer[j + 3] ), roundedPositiveDataSetRadius, roundedPositiveDataSetRadius, true, true, true, true ) - c.drawPath(path2, paintRender) + canvas.drawPath(path2, paintRender) } else { - c.drawRect( + canvas.drawRect( buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2], buffer.buffer[j + 3], paintRender ) 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 index 931dca35d..daf916c40 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/ScatterChartRenderer.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/ScatterChartRenderer.kt @@ -17,17 +17,17 @@ open class ScatterChartRenderer(@JvmField var chart: ScatterDataProvider, animat override fun initBuffers() { } - override fun drawData(c: Canvas) { + override fun drawData(canvas: Canvas) { val scatterData = chart.scatterData for (set in scatterData.dataSets) { - if (set.isVisible) drawDataSet(c, set) + if (set.isVisible) drawDataSet(canvas, set) } } var pixelBuffer: FloatArray = FloatArray(2) - protected fun drawDataSet(c: Canvas?, dataSet: IScatterDataSet) { + protected fun drawDataSet(canvas: Canvas?, dataSet: IScatterDataSet) { if (dataSet.entryCount < 1) return val viewPortHandler = this.viewPortHandler @@ -63,14 +63,14 @@ open class ScatterChartRenderer(@JvmField var chart: ScatterDataProvider, animat paintRender.color = dataSet.getColor(i / 2) renderer.renderShape( - c, dataSet, this.viewPortHandler, + canvas, dataSet, this.viewPortHandler, pixelBuffer[0], pixelBuffer[1], paintRender ) } } - override fun drawValues(c: Canvas) { + override fun drawValues(canvas: Canvas) { // if values are drawn if (isDrawingValuesAllowed(chart)) { @@ -118,7 +118,7 @@ open class ScatterChartRenderer(@JvmField var chart: ScatterDataProvider, animat if (dataSet.isDrawValuesEnabled) { drawValue( - c, + canvas, dataSet.valueFormatter, entry.y, entry, @@ -133,7 +133,7 @@ open class ScatterChartRenderer(@JvmField var chart: ScatterDataProvider, animat val icon = entry.icon Utils.drawImage( - c, + canvas, icon, (positions[j] + iconsOffset.x).toInt(), (positions[j + 1] + iconsOffset.y).toInt(), @@ -149,10 +149,10 @@ open class ScatterChartRenderer(@JvmField var chart: ScatterDataProvider, animat } } - override fun drawExtras(c: Canvas) { + override fun drawExtras(canvas: Canvas) { } - override fun drawHighlighted(c: Canvas, indices: Array) { + override fun drawHighlighted(canvas: Canvas, indices: Array) { val scatterData = chart.scatterData for (high in indices) { @@ -172,7 +172,7 @@ open class ScatterChartRenderer(@JvmField var chart: ScatterDataProvider, animat high.setDraw(pix.x.toFloat(), pix.y.toFloat()) // draw the lines - drawHighlightLines(c, pix.x.toFloat(), pix.y.toFloat(), set) + drawHighlightLines(canvas, pix.x.toFloat(), pix.y.toFloat(), set) } } } diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/XAxisRenderer.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/XAxisRenderer.kt index 04d9f3d2b..364adefae 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/XAxisRenderer.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/XAxisRenderer.kt @@ -18,6 +18,7 @@ import com.github.mikephil.charting.utils.Utils import com.github.mikephil.charting.utils.ViewPortHandler import androidx.core.graphics.withClip import androidx.core.graphics.withSave +import kotlin.math.roundToInt open class XAxisRenderer( viewPortHandler: ViewPortHandler, @@ -28,12 +29,12 @@ open class XAxisRenderer( protected fun setupGridPaint() { paintGrid.color = xAxis.gridColor paintGrid.strokeWidth = xAxis.gridLineWidth - paintGrid.setPathEffect(xAxis.gridDashPathEffect) + paintGrid.pathEffect = xAxis.gridDashPathEffect } override fun computeAxis(min: Float, max: Float, inverted: Boolean) { // calculate the starting and entry point of the y-labels (depending on - // zoom / contentrect bounds) + // zoom / content rect bounds) var minLocal = min var maxLocal = max @@ -65,7 +66,7 @@ open class XAxisRenderer( protected open fun computeSize() { val longest = xAxis.longestLabel - paintAxisLabels.setTypeface(xAxis.typeface) + paintAxisLabels.typeface = xAxis.typeface paintAxisLabels.textSize = xAxis.textSize val labelSize = Utils.calcTextSize(paintAxisLabels, longest) @@ -80,17 +81,17 @@ open class XAxisRenderer( ) - xAxis.mLabelWidth = Math.round(labelRotatedSize.width) - xAxis.mLabelHeight = Math.round(labelRotatedSize.height) + xAxis.mLabelWidth = labelRotatedSize.width.roundToInt() + xAxis.mLabelHeight = labelRotatedSize.height.roundToInt() FSize.recycleInstance(labelRotatedSize) FSize.recycleInstance(labelSize) } - override fun renderAxisLabels(c: Canvas) { + override fun renderAxisLabels(canvas: Canvas) { if (!xAxis.isEnabled || !xAxis.isDrawLabelsEnabled) return - val yoffset = xAxis.yOffset + val yOffset = xAxis.yOffset paintAxisLabels.color = xAxis.textColor @@ -99,44 +100,44 @@ open class XAxisRenderer( XAxisPosition.TOP -> { pointF.x = 0.5f pointF.y = 1.0f - drawLabels(c, viewPortHandler.contentTop() - yoffset, pointF) + drawLabels(canvas, viewPortHandler.contentTop() - yOffset, pointF) } XAxisPosition.TOP_INSIDE -> { pointF.x = 0.5f pointF.y = 1.0f - drawLabels(c, viewPortHandler.contentTop() + yoffset + xAxis.mLabelHeight, pointF) + drawLabels(canvas, viewPortHandler.contentTop() + yOffset + xAxis.mLabelHeight, pointF) } XAxisPosition.BOTTOM -> { pointF.x = 0.5f pointF.y = 0.0f - drawLabels(c, viewPortHandler.contentBottom() + yoffset, pointF) + drawLabels(canvas, viewPortHandler.contentBottom() + yOffset, pointF) } XAxisPosition.BOTTOM_INSIDE -> { pointF.x = 0.5f pointF.y = 0.0f - drawLabels(c, viewPortHandler.contentBottom() - yoffset - xAxis.mLabelHeight, pointF) + drawLabels(canvas, viewPortHandler.contentBottom() - yOffset - xAxis.mLabelHeight, pointF) } else -> { // BOTH SIDED pointF.x = 0.5f pointF.y = 1.0f - drawLabels(c, viewPortHandler.contentTop() - yoffset, pointF) + drawLabels(canvas, viewPortHandler.contentTop() - yOffset, pointF) pointF.x = 0.5f pointF.y = 0.0f - drawLabels(c, viewPortHandler.contentBottom() + yoffset, pointF) + drawLabels(canvas, viewPortHandler.contentBottom() + yOffset, pointF) } } MPPointF.recycleInstance(pointF) } - override fun renderAxisLine(c: Canvas) { + override fun renderAxisLine(canvas: Canvas) { if (!xAxis.isDrawAxisLineEnabled || !xAxis.isEnabled) return paintAxisLine.color = xAxis.axisLineColor paintAxisLine.strokeWidth = xAxis.axisLineWidth - paintAxisLine.setPathEffect(xAxis.axisLineDashPathEffect) + paintAxisLine.pathEffect = xAxis.axisLineDashPathEffect if (xAxis.position == XAxisPosition.TOP || xAxis.position == XAxisPosition.TOP_INSIDE || xAxis.position == XAxisPosition.BOTH_SIDED) { - c.drawLine( + canvas.drawLine( viewPortHandler.contentLeft(), viewPortHandler.contentTop(), viewPortHandler.contentRight(), viewPortHandler.contentTop(), paintAxisLine @@ -144,7 +145,7 @@ open class XAxisRenderer( } if (xAxis.position == XAxisPosition.BOTTOM || xAxis.position == XAxisPosition.BOTTOM_INSIDE || xAxis.position == XAxisPosition.BOTH_SIDED) { - c.drawLine( + canvas.drawLine( viewPortHandler.contentLeft(), viewPortHandler.contentBottom(), viewPortHandler.contentRight(), viewPortHandler.contentBottom(), paintAxisLine @@ -157,7 +158,7 @@ open class XAxisRenderer( * * @param pos */ - protected open fun drawLabels(c: Canvas?, pos: Float, anchor: MPPointF?) { + protected open fun drawLabels(canvas: Canvas?, pos: Float, anchor: MPPointF?) { val labelRotationAngleDegrees = xAxis.labelRotationAngle val centeringEnabled = xAxis.isCenterAxisLabelsEnabled @@ -213,22 +214,22 @@ open class XAxisRenderer( } } - drawLabel(c, label, x, pos, anchor, labelRotationAngleDegrees) + drawLabel(canvas, label, x, pos, anchor, labelRotationAngleDegrees) } i += 2 } } - protected fun drawLabel(c: Canvas?, formattedLabel: String?, x: Float, y: Float, anchor: MPPointF?, angleDegrees: Float) { - Utils.drawXAxisValue(c, formattedLabel, x, y, paintAxisLabels, anchor, angleDegrees) + protected fun drawLabel(canvas: Canvas?, formattedLabel: String?, x: Float, y: Float, anchor: MPPointF?, angleDegrees: Float) { + Utils.drawXAxisValue(canvas, formattedLabel, x, y, paintAxisLabels, anchor, angleDegrees) } protected open var mRenderGridLinesPath: Path = Path() protected open var mRenderGridLinesBuffer: FloatArray = FloatArray(2) - override fun renderGridLines(c: Canvas) { + override fun renderGridLines(canvas: Canvas) { if (!xAxis.isDrawGridLinesEnabled || !xAxis.isEnabled) return - c.withClip(gridClippingRect!!) { + canvas.withClip(gridClippingRect!!) { if (axis.isShowSpecificPositions) { if (mRenderGridLinesBuffer.size != axis.specificPositions.size * 2) { mRenderGridLinesBuffer = FloatArray(xAxis.specificPositions.size * 2) @@ -263,7 +264,7 @@ open class XAxisRenderer( var i = 0 while (i < positions.size) { - drawGridLine(c, positions[i], positions[i + 1], gridLinePath) + drawGridLine(canvas, positions[i], positions[i + 1], gridLinePath) i += 2 } @@ -298,22 +299,22 @@ open class XAxisRenderer( /** * Draws the grid line at the specified position using the provided path. * - * @param c + * @param canvas * @param x * @param y * @param gridLinePath */ - protected open fun drawGridLine(c: Canvas, x: Float, y: Float, gridLinePath: Path) { + protected open fun drawGridLine(canvas: Canvas, x: Float, y: Float, gridLinePath: Path) { gridLinePath.moveTo(x, viewPortHandler.contentBottom()) gridLinePath.lineTo(x, viewPortHandler.contentTop()) // draw a path because lines don't support dashing on lower android versions - c.drawPath(gridLinePath, paintGrid) + canvas.drawPath(gridLinePath, paintGrid) gridLinePath.reset() } - fun renderLimitLineLine(c: Canvas, limitLine: LimitLine, position: FloatArray) { + fun renderLimitLineLine(canvas: Canvas, limitLine: LimitLine, position: FloatArray) { limitLineSegmentsBuffer[0] = position[0] limitLineSegmentsBuffer[1] = viewPortHandler.contentTop() limitLineSegmentsBuffer[2] = position[0] @@ -326,20 +327,20 @@ open class XAxisRenderer( limitLinePaint.style = Paint.Style.STROKE limitLinePaint.color = limitLine.lineColor limitLinePaint.strokeWidth = limitLine.lineWidth - limitLinePaint.setPathEffect(limitLine.dashPathEffect) + limitLinePaint.pathEffect = limitLine.dashPathEffect - c.drawPath(mLimitLinePath, limitLinePaint) + canvas.drawPath(mLimitLinePath, limitLinePaint) } /** * Draws the LimitLines associated with this axis to the screen. * - * @param c + * @param canvas */ - override fun renderLimitLines(c: Canvas) { + override fun renderLimitLines(canvas: Canvas) { val limitLines = xAxis.limitLines - if (limitLines == null || limitLines.size <= 0) return + if (limitLines == null || limitLines.isEmpty()) return val position = mRenderLimitLinesBuffer position[0] = 0f @@ -350,30 +351,30 @@ open class XAxisRenderer( if (!l.isEnabled) continue - c.withSave { + canvas.withSave { mLimitLineClippingRect.set(viewPortHandler.contentRect) mLimitLineClippingRect.inset(-l.lineWidth, 0f) - c.clipRect(mLimitLineClippingRect) + canvas.clipRect(mLimitLineClippingRect) position[0] = l.limit position[1] = 0f transformer!!.pointValuesToPixel(position) - renderLimitLineLine(c, l, position) - renderLimitLineLabel(c, l, position, 2f + l.yOffset) + renderLimitLineLine(canvas, l, position) + renderLimitLineLabel(canvas, l, position, 2f + l.yOffset) } } } - fun renderLimitLineLabel(c: Canvas, limitLine: LimitLine, position: FloatArray, yOffset: Float) { + fun renderLimitLineLabel(canvas: Canvas, limitLine: LimitLine, position: FloatArray, yOffset: Float) { val label = limitLine.label // if drawing the limit-value label is enabled if (label != null && label != "") { limitLinePaint.style = limitLine.textStyle - limitLinePaint.setPathEffect(null) + limitLinePaint.pathEffect = null limitLinePaint.color = limitLine.textColor limitLinePaint.strokeWidth = 0.5f limitLinePaint.textSize = limitLine.textSize @@ -387,26 +388,26 @@ open class XAxisRenderer( LimitLabelPosition.RIGHT_TOP -> { val labelLineHeight = Utils.calcTextHeight(limitLinePaint, label).toFloat() limitLinePaint.textAlign = Align.LEFT - c.drawText( + canvas.drawText( label, position[0] + xOffset, viewPortHandler.contentTop() + yOffset + labelLineHeight, limitLinePaint ) } LimitLabelPosition.RIGHT_BOTTOM -> { limitLinePaint.textAlign = Align.LEFT - c.drawText(label, position[0] + xOffset, viewPortHandler.contentBottom() - yOffset, limitLinePaint) + canvas.drawText(label, position[0] + xOffset, viewPortHandler.contentBottom() - yOffset, limitLinePaint) } LimitLabelPosition.LEFT_TOP -> { limitLinePaint.textAlign = Align.RIGHT val labelLineHeight = Utils.calcTextHeight(limitLinePaint, label).toFloat() - c.drawText( + canvas.drawText( label, position[0] - xOffset, viewPortHandler.contentTop() + yOffset + labelLineHeight, limitLinePaint ) } else -> { limitLinePaint.textAlign = Align.RIGHT - c.drawText(label, position[0] - xOffset, viewPortHandler.contentBottom() - yOffset, limitLinePaint) + canvas.drawText(label, position[0] - xOffset, viewPortHandler.contentBottom() - yOffset, limitLinePaint) } } } diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/XAxisRendererHorizontalBarChart.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/XAxisRendererHorizontalBarChart.kt index b1b0cf124..35d05907c 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/XAxisRendererHorizontalBarChart.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/XAxisRendererHorizontalBarChart.kt @@ -50,8 +50,8 @@ open class XAxisRendererHorizontalBarChart( } override fun computeSize() { - paintAxisLabels!!.setTypeface(xAxis.typeface) - paintAxisLabels!!.textSize = xAxis.textSize + paintAxisLabels.setTypeface(xAxis.typeface) + paintAxisLabels.textSize = xAxis.textSize val longest = xAxis.longestLabel @@ -72,14 +72,14 @@ open class XAxisRendererHorizontalBarChart( FSize.recycleInstance(labelRotatedSize) } - override fun renderAxisLabels(c: Canvas) { + override fun renderAxisLabels(canvas: Canvas) { if (!xAxis.isEnabled || !xAxis.isDrawLabelsEnabled) return val xOffset = xAxis.xOffset - paintAxisLabels!!.setTypeface(xAxis.typeface) - paintAxisLabels!!.textSize = xAxis.textSize - paintAxisLabels!!.color = xAxis.textColor + paintAxisLabels.setTypeface(xAxis.typeface) + paintAxisLabels.textSize = xAxis.textSize + paintAxisLabels.color = xAxis.textColor val pointF = MPPointF.getInstance(0f, 0f) @@ -87,37 +87,37 @@ open class XAxisRendererHorizontalBarChart( XAxisPosition.TOP -> { pointF.x = 0.0f pointF.y = 0.5f - drawLabels(c, viewPortHandler.contentRight() + xOffset, pointF) + drawLabels(canvas, viewPortHandler.contentRight() + xOffset, pointF) } XAxisPosition.TOP_INSIDE -> { pointF.x = 1.0f pointF.y = 0.5f - drawLabels(c, viewPortHandler.contentRight() - xOffset, pointF) + drawLabels(canvas, viewPortHandler.contentRight() - xOffset, pointF) } XAxisPosition.BOTTOM -> { pointF.x = 1.0f pointF.y = 0.5f - drawLabels(c, viewPortHandler.contentLeft() - xOffset, pointF) + drawLabels(canvas, viewPortHandler.contentLeft() - xOffset, pointF) } XAxisPosition.BOTTOM_INSIDE -> { pointF.x = 1.0f pointF.y = 0.5f - drawLabels(c, viewPortHandler.contentLeft() + xOffset, pointF) + drawLabels(canvas, viewPortHandler.contentLeft() + xOffset, pointF) } else -> { // BOTH SIDED pointF.x = 0.0f pointF.y = 0.5f - drawLabels(c, viewPortHandler.contentRight() + xOffset, pointF) + drawLabels(canvas, viewPortHandler.contentRight() + xOffset, pointF) pointF.x = 1.0f pointF.y = 0.5f - drawLabels(c, viewPortHandler.contentLeft() - xOffset, pointF) + drawLabels(canvas, viewPortHandler.contentLeft() - xOffset, pointF) } } MPPointF.recycleInstance(pointF) } - override fun drawLabels(c: Canvas?, pos: Float, anchor: MPPointF?) { + override fun drawLabels(canvas: Canvas?, pos: Float, anchor: MPPointF?) { val labelRotationAngleDegrees = xAxis.labelRotationAngle val centeringEnabled = xAxis.isCenterAxisLabelsEnabled @@ -144,7 +144,7 @@ open class XAxisRendererHorizontalBarChart( if (viewPortHandler.isInBoundsY(y)) { val label = xAxis.valueFormatter.getFormattedValue(xAxis.mEntries[i / 2], xAxis) - drawLabel(c, label, pos, y, anchor, labelRotationAngleDegrees) + drawLabel(canvas, label, pos, y, anchor, labelRotationAngleDegrees) } i += 2 } @@ -157,35 +157,35 @@ open class XAxisRendererHorizontalBarChart( return mGridClippingRect } - override fun drawGridLine(c: Canvas, x: Float, y: Float, gridLinePath: Path) { + override fun drawGridLine(canvas: Canvas, x: Float, y: Float, gridLinePath: Path) { gridLinePath.moveTo(viewPortHandler.contentRight(), y) gridLinePath.lineTo(viewPortHandler.contentLeft(), y) // draw a path because lines don't support dashing on lower android versions - c.drawPath(gridLinePath, paintGrid!!) + canvas.drawPath(gridLinePath, paintGrid) gridLinePath.reset() } - override fun renderAxisLine(c: Canvas) { + override fun renderAxisLine(canvas: Canvas) { if (!xAxis.isDrawAxisLineEnabled || !xAxis.isEnabled) return - paintAxisLine!!.color = xAxis.axisLineColor - paintAxisLine!!.strokeWidth = xAxis.axisLineWidth + paintAxisLine.color = xAxis.axisLineColor + paintAxisLine.strokeWidth = xAxis.axisLineWidth if (xAxis.position == XAxisPosition.TOP || xAxis.position == XAxisPosition.TOP_INSIDE || xAxis.position == XAxisPosition.BOTH_SIDED) { - c.drawLine( + canvas.drawLine( viewPortHandler.contentRight(), viewPortHandler.contentTop(), viewPortHandler.contentRight(), - viewPortHandler.contentBottom(), paintAxisLine!! + viewPortHandler.contentBottom(), paintAxisLine ) } if (xAxis.position == XAxisPosition.BOTTOM || xAxis.position == XAxisPosition.BOTTOM_INSIDE || xAxis.position == XAxisPosition.BOTH_SIDED) { - c.drawLine( + canvas.drawLine( viewPortHandler.contentLeft(), viewPortHandler.contentTop(), viewPortHandler.contentLeft(), - viewPortHandler.contentBottom(), paintAxisLine!! + viewPortHandler.contentBottom(), paintAxisLine ) } } @@ -194,9 +194,9 @@ open class XAxisRendererHorizontalBarChart( * Draws the LimitLines associated with this axis to the screen. * This is the standard YAxis renderer using the XAxis limit lines. * - * @param c + * @param canvas */ - override fun renderLimitLines(c: Canvas) { + override fun renderLimitLines(canvas: Canvas) { val limitLines = xAxis.limitLines if (limitLines == null || limitLines.size <= 0) return @@ -213,15 +213,15 @@ open class XAxisRendererHorizontalBarChart( if (!l.isEnabled) continue - c.withSave { + canvas.withSave { mLimitLineClippingRect.set(viewPortHandler.contentRect) mLimitLineClippingRect.inset(0f, -l.lineWidth) - c.clipRect(mLimitLineClippingRect) + canvas.clipRect(mLimitLineClippingRect) - limitLinePaint!!.style = Paint.Style.STROKE - limitLinePaint!!.color = l.lineColor - limitLinePaint!!.strokeWidth = l.lineWidth - limitLinePaint!!.setPathEffect(l.dashPathEffect) + limitLinePaint.style = Paint.Style.STROKE + limitLinePaint.color = l.lineColor + limitLinePaint.strokeWidth = l.lineWidth + limitLinePaint.setPathEffect(l.dashPathEffect) pts[1] = l.limit @@ -230,7 +230,7 @@ open class XAxisRendererHorizontalBarChart( limitLinePath.moveTo(viewPortHandler.contentLeft(), pts[1]) limitLinePath.lineTo(viewPortHandler.contentRight(), pts[1]) - c.drawPath(limitLinePath, limitLinePaint!!) + canvas.drawPath(limitLinePath, limitLinePaint!!) limitLinePath.reset() // c.drawLines(pts, mLimitLinePaint); @@ -238,11 +238,11 @@ open class XAxisRendererHorizontalBarChart( // if drawing the limit-value label is enabled if (label != null && label != "") { - limitLinePaint!!.style = l.textStyle - limitLinePaint!!.setPathEffect(null) - limitLinePaint!!.color = l.textColor - limitLinePaint!!.strokeWidth = 0.5f - limitLinePaint!!.textSize = l.textSize + limitLinePaint.style = l.textStyle + limitLinePaint.setPathEffect(null) + limitLinePaint.color = l.textColor + limitLinePaint.strokeWidth = 0.5f + limitLinePaint.textSize = l.textSize val labelLineHeight = Utils.calcTextHeight(limitLinePaint, label).toFloat() val xOffset = Utils.convertDpToPixel(4f) + l.xOffset @@ -252,35 +252,35 @@ open class XAxisRendererHorizontalBarChart( when (position) { LimitLabelPosition.RIGHT_TOP -> { - limitLinePaint!!.textAlign = Align.RIGHT - c.drawText( + limitLinePaint.textAlign = Align.RIGHT + canvas.drawText( label, viewPortHandler.contentRight() - xOffset, - pts[1] - yOffset + labelLineHeight, limitLinePaint!! + pts[1] - yOffset + labelLineHeight, limitLinePaint ) } LimitLabelPosition.RIGHT_BOTTOM -> { - limitLinePaint!!.textAlign = Align.RIGHT - c.drawText( + limitLinePaint.textAlign = Align.RIGHT + canvas.drawText( label, viewPortHandler.contentRight() - xOffset, - pts[1] + yOffset, limitLinePaint!! + pts[1] + yOffset, limitLinePaint ) } LimitLabelPosition.LEFT_TOP -> { - limitLinePaint!!.textAlign = Align.LEFT - c.drawText( + limitLinePaint.textAlign = Align.LEFT + canvas.drawText( label, viewPortHandler.contentLeft() + xOffset, - pts[1] - yOffset + labelLineHeight, limitLinePaint!! + pts[1] - yOffset + labelLineHeight, limitLinePaint ) } else -> { - limitLinePaint!!.textAlign = Align.LEFT - c.drawText( + limitLinePaint.textAlign = Align.LEFT + canvas.drawText( label, viewPortHandler.offsetLeft() + xOffset, - pts[1] + yOffset, limitLinePaint!! + pts[1] + yOffset, limitLinePaint ) } } diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/XAxisRendererRadarChart.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/XAxisRendererRadarChart.kt index 98c5829ae..975a7e629 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/XAxisRendererRadarChart.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/XAxisRendererRadarChart.kt @@ -8,7 +8,7 @@ import com.github.mikephil.charting.utils.Utils import com.github.mikephil.charting.utils.ViewPortHandler class XAxisRendererRadarChart(viewPortHandler: ViewPortHandler, xAxis: XAxis, private val chart: RadarChart) : XAxisRenderer(viewPortHandler, xAxis, null) { - override fun renderAxisLabels(c: Canvas) { + override fun renderAxisLabels(canvas: Canvas) { if (!xAxis.isEnabled || !xAxis.isDrawLabelsEnabled) return @@ -37,7 +37,7 @@ class XAxisRendererRadarChart(viewPortHandler: ViewPortHandler, xAxis: XAxis, pr ) drawLabel( - c, label, pOut.x, pOut.y - xAxis.mLabelHeight / 2f, + canvas, label, pOut.x, pOut.y - xAxis.mLabelHeight / 2f, drawLabelAnchor, labelRotationAngleDegrees ) } @@ -50,5 +50,5 @@ class XAxisRendererRadarChart(viewPortHandler: ViewPortHandler, xAxis: XAxis, pr /** * XAxis LimitLines on RadarChart not yet supported. */ - override fun renderLimitLines(c: Canvas) = Unit + override fun renderLimitLines(canvas: Canvas) = Unit } diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/YAxisRenderer.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/YAxisRenderer.kt index bc6956b6f..cad69feb0 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/YAxisRenderer.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/YAxisRenderer.kt @@ -50,13 +50,13 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v /** * draws the y-axis labels to the screen */ - override fun renderAxisLabels(c: Canvas) { + override fun renderAxisLabels(canvas: Canvas) { if (!yAxis.isEnabled || !yAxis.isDrawLabelsEnabled) return val positions = transformedPositions - paintAxisLabels.setTypeface(yAxis.typeface) + paintAxisLabels.typeface = yAxis.typeface paintAxisLabels.textSize = yAxis.textSize paintAxisLabels.color = yAxis.textColor @@ -68,10 +68,10 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v val xPos = calculateAxisLabelsXPosition(dependency, labelPosition) paintAxisLabels.textAlign = getAxisLabelTextAlign(dependency, labelPosition) - drawYLabels(c, xPos, positions, yOffset) + drawYLabels(canvas, xPos, positions, yOffset) } - override fun renderAxisLine(c: Canvas) { + override fun renderAxisLine(canvas: Canvas) { if (!yAxis.isEnabled || !yAxis.isDrawAxisLineEnabled) return @@ -79,12 +79,12 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v paintAxisLine.strokeWidth = yAxis.axisLineWidth if (yAxis.axisDependency == AxisDependency.LEFT) { - c.drawLine( + canvas.drawLine( viewPortHandler.contentLeft(), viewPortHandler.contentTop(), viewPortHandler.contentLeft(), viewPortHandler.contentBottom(), paintAxisLine ) } else { - c.drawLine( + canvas.drawLine( viewPortHandler.contentRight(), viewPortHandler.contentTop(), viewPortHandler.contentRight(), viewPortHandler.contentBottom(), paintAxisLine ) @@ -94,7 +94,7 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v /** * draws the y-labels on the specified x-position */ - protected open fun drawYLabels(c: Canvas, fixedPosition: Float, positions: FloatArray, offset: Float) { + protected open fun drawYLabels(canvas: Canvas, fixedPosition: Float, positions: FloatArray, offset: Float) { val from: Int val to: Int @@ -122,7 +122,7 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v yAxis.getFormattedLabel(i) } - c.drawText( + canvas.drawText( text!!, fixedPosition + xOffset, positions[i * 2 + 1] + offset, @@ -132,16 +132,16 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v } protected var renderGridLinesPath: Path = Path() - override fun renderGridLines(c: Canvas) { + override fun renderGridLines(canvas: Canvas) { if (!yAxis.isEnabled) return if (yAxis.isDrawGridLinesEnabled) { - c.withClip(gridClippingRect!!) { + canvas.withClip(gridClippingRect!!) { val positions = transformedPositions paintGrid.color = yAxis.gridColor paintGrid.strokeWidth = yAxis.gridLineWidth - paintGrid.setPathEffect(yAxis.gridDashPathEffect) + paintGrid.pathEffect = yAxis.gridDashPathEffect val gridLinePath = renderGridLinesPath gridLinePath.reset() @@ -150,7 +150,7 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v var i = 0 while (i < positions.size) { // draw a path because lines don't support dashing on lower android versions - c.drawPath(linePath(gridLinePath, i, positions)!!, paintGrid) + canvas.drawPath(linePath(gridLinePath, i, positions)!!, paintGrid) gridLinePath.reset() i += 2 } @@ -158,7 +158,7 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v } if (yAxis.isDrawZeroLineEnabled) { - drawZeroLine(c) + drawZeroLine(canvas) } } @@ -224,11 +224,11 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v /** * Draws the zero line. */ - protected open fun drawZeroLine(c: Canvas) { - val clipRestoreCount = c.save() + protected open fun drawZeroLine(canvas: Canvas) { + val clipRestoreCount = canvas.save() zeroLineClippingRect.set(viewPortHandler.contentRect) zeroLineClippingRect.inset(0f, -yAxis.zeroLineWidth) - c.clipRect(zeroLineClippingRect) + canvas.clipRect(zeroLineClippingRect) // draw zero line val pos = transformer?.getPixelForValues(0f, 0f) @@ -243,10 +243,10 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v zeroLinePath.lineTo(viewPortHandler.contentRight(), it.y.toFloat()) // draw a path because lines don't support dashing on lower android versions - c.drawPath(zeroLinePath, zeroLinePaint) + canvas.drawPath(zeroLinePath, zeroLinePaint) } - c.restoreToCount(clipRestoreCount) + canvas.restoreToCount(clipRestoreCount) } protected var renderLimitRanges: Path = Path() @@ -266,9 +266,9 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v /** * Draws the LimitLines associated with this axis to the screen. */ - override fun renderLimitLines(c: Canvas) { + override fun renderLimitLines(canvas: Canvas) { val limitLines = yAxis.limitLines - if (limitLines != null && limitLines.size > 0) { + if (limitLines != null && limitLines.isNotEmpty()) { val pts = renderLimitLinesBuffer pts[0] = 0f pts[1] = 0f @@ -281,15 +281,15 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v if (!limitLine.isEnabled) continue - c.withSave { + canvas.withSave { limitLineClippingRect.set(viewPortHandler.contentRect) limitLineClippingRect.inset(0f, -limitLine.lineWidth) - c.clipRect(limitLineClippingRect) + canvas.clipRect(limitLineClippingRect) limitLinePaint.style = Paint.Style.STROKE limitLinePaint.color = limitLine.lineColor limitLinePaint.strokeWidth = limitLine.lineWidth - limitLinePaint.setPathEffect(limitLine.dashPathEffect) + limitLinePaint.pathEffect = limitLine.dashPathEffect pts[1] = limitLine.limit @@ -298,7 +298,7 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v limitLinePath.moveTo(viewPortHandler.contentLeft(), pts[1]) limitLinePath.lineTo(viewPortHandler.contentRight(), pts[1]) - c.drawPath(limitLinePath, limitLinePaint) + canvas.drawPath(limitLinePath, limitLinePaint) limitLinePath.reset() // c.drawLines(pts, mLimitLinePaint); @@ -307,9 +307,9 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v // if drawing the limit-value label is enabled if (label != null && label != "") { limitLinePaint.style = limitLine.textStyle - limitLinePaint.setPathEffect(null) + limitLinePaint.pathEffect = null limitLinePaint.color = limitLine.textColor - limitLinePaint.setTypeface(limitLine.typeface) + limitLinePaint.typeface = limitLine.typeface limitLinePaint.strokeWidth = 0.5f limitLinePaint.textSize = limitLine.textSize @@ -319,34 +319,39 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v val position = limitLine.labelPosition - if (position == LimitLabelPosition.RIGHT_TOP) { - limitLinePaint.textAlign = Align.RIGHT - c.drawText( - label, - viewPortHandler.contentRight() - xOffset, - pts[1] - yOffset + labelLineHeight, limitLinePaint - ) - } else if (position == LimitLabelPosition.RIGHT_BOTTOM) { - limitLinePaint.textAlign = Align.RIGHT - c.drawText( - label, - viewPortHandler.contentRight() - xOffset, - pts[1] + yOffset, limitLinePaint - ) - } else if (position == LimitLabelPosition.LEFT_TOP) { - limitLinePaint.textAlign = Align.LEFT - c.drawText( - label, - viewPortHandler.contentLeft() + xOffset, - pts[1] - yOffset + labelLineHeight, limitLinePaint - ) - } else { - limitLinePaint.textAlign = Align.LEFT - c.drawText( - label, - viewPortHandler.offsetLeft() + xOffset, - pts[1] + yOffset, limitLinePaint - ) + when (position) { + LimitLabelPosition.RIGHT_TOP -> { + limitLinePaint.textAlign = Align.RIGHT + canvas.drawText( + label, + viewPortHandler.contentRight() - xOffset, + pts[1] - yOffset + labelLineHeight, limitLinePaint + ) + } + LimitLabelPosition.RIGHT_BOTTOM -> { + limitLinePaint.textAlign = Align.RIGHT + canvas.drawText( + label, + viewPortHandler.contentRight() - xOffset, + pts[1] + yOffset, limitLinePaint + ) + } + LimitLabelPosition.LEFT_TOP -> { + limitLinePaint.textAlign = Align.LEFT + canvas.drawText( + label, + viewPortHandler.contentLeft() + xOffset, + pts[1] - yOffset + labelLineHeight, limitLinePaint + ) + } + else -> { + limitLinePaint.textAlign = Align.LEFT + canvas.drawText( + label, + viewPortHandler.offsetLeft() + xOffset, + pts[1] + yOffset, limitLinePaint + ) + } } } @@ -356,7 +361,7 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v // Now the ranges val limitRanges = yAxis.limitRanges - if (limitRanges != null && limitRanges.size > 0) { + if (limitRanges != null && limitRanges.isNotEmpty()) { val ptsr = FloatArray(2) ptsr[0] = 0f ptsr[1] = 0f @@ -374,15 +379,15 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v if (!limitRange.isEnabled) continue - val clipRestoreCount = c.save() + val clipRestoreCount = canvas.save() limitLineClippingRect.set(viewPortHandler.contentRect) limitLineClippingRect.inset(0f, -limitRange.lineWidth) - c.clipRect(limitLineClippingRect) + canvas.clipRect(limitLineClippingRect) limitRangePaint.style = Paint.Style.STROKE limitRangePaint.color = limitRange.lineColor limitRangePaint.strokeWidth = limitRange.lineWidth - limitRangePaint.setPathEffect(limitRange.dashPathEffect) + limitRangePaint.pathEffect = limitRange.dashPathEffect limitRangePaintFill.style = Paint.Style.FILL limitRangePaintFill.color = limitRange.rangeColor @@ -401,17 +406,17 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v ptsr2[1], Path.Direction.CW ) - c.drawPath(limitRangePathFill, limitRangePaintFill) + canvas.drawPath(limitRangePathFill, limitRangePaintFill) limitRangePathFill.reset() if (limitRange.lineWidth > 0) { limitRangePath.moveTo(viewPortHandler.contentLeft(), ptsr[1]) limitRangePath.lineTo(viewPortHandler.contentRight(), ptsr[1]) - c.drawPath(limitRangePath, limitRangePaint) + canvas.drawPath(limitRangePath, limitRangePaint) limitRangePath.moveTo(viewPortHandler.contentLeft(), ptsr2[1]) limitRangePath.lineTo(viewPortHandler.contentRight(), ptsr2[1]) - c.drawPath(limitRangePath, limitRangePaint) + canvas.drawPath(limitRangePath, limitRangePaint) } limitRangePath.reset() @@ -421,9 +426,9 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v // if drawing the limit-value label is enabled if (label != null && label != "") { limitRangePaint.style = limitRange.textStyle - limitRangePaint.setPathEffect(null) + limitRangePaint.pathEffect = null limitRangePaint.color = limitRange.textColor - limitRangePaint.setTypeface(limitRange.typeface) + limitRangePaint.typeface = limitRange.typeface limitRangePaint.strokeWidth = 0.5f limitRangePaint.textSize = limitRange.textSize @@ -436,7 +441,7 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v when (position) { LimitLabelPosition.RIGHT_TOP -> { limitRangePaint.textAlign = Align.RIGHT - c.drawText( + canvas.drawText( label, viewPortHandler.contentRight() - xOffset, ptsr[1] - yOffset + labelLineHeight, limitRangePaint @@ -445,7 +450,7 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v LimitLabelPosition.RIGHT_BOTTOM -> { limitRangePaint.textAlign = Align.RIGHT - c.drawText( + canvas.drawText( label, viewPortHandler.contentRight() - xOffset, ptsr[1] + yOffset, limitRangePaint @@ -454,7 +459,7 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v LimitLabelPosition.LEFT_TOP -> { limitRangePaint.textAlign = Align.LEFT - c.drawText( + canvas.drawText( label, viewPortHandler.contentLeft() + xOffset, ptsr[1] - yOffset + labelLineHeight, limitRangePaint @@ -463,7 +468,7 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v else -> { limitRangePaint.textAlign = Align.LEFT - c.drawText( + canvas.drawText( label, viewPortHandler.offsetLeft() + xOffset, ptsr[1] + yOffset, limitRangePaint @@ -472,7 +477,7 @@ open class YAxisRenderer(viewPortHandler: ViewPortHandler, @JvmField protected v } } - c.restoreToCount(clipRestoreCount) + canvas.restoreToCount(clipRestoreCount) } } } diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/YAxisRendererHorizontalBarChart.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/YAxisRendererHorizontalBarChart.kt index 89563449a..4013fa8d7 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/YAxisRendererHorizontalBarChart.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/YAxisRendererHorizontalBarChart.kt @@ -63,7 +63,7 @@ open class YAxisRendererHorizontalBarChart( /** * draws the y-axis labels to the screen */ - override fun renderAxisLabels(c: Canvas) { + override fun renderAxisLabels(canvas: Canvas) { if (!yAxis.isEnabled || !yAxis.isDrawLabelsEnabled) return val positions = transformedPositions @@ -93,23 +93,23 @@ open class YAxisRendererHorizontalBarChart( } } - drawYLabels(c, yPos, positions, yAxis.yOffset) + drawYLabels(canvas, yPos, positions, yAxis.yOffset) } - override fun renderAxisLine(c: Canvas) { + override fun renderAxisLine(canvas: Canvas) { if (!yAxis.isEnabled || !yAxis.isDrawAxisLineEnabled) return paintAxisLine.color = yAxis.axisLineColor paintAxisLine.strokeWidth = yAxis.axisLineWidth if (yAxis.axisDependency == AxisDependency.LEFT) { - c.drawLine( + canvas.drawLine( viewPortHandler.contentLeft(), viewPortHandler.contentTop(), viewPortHandler.contentRight(), viewPortHandler.contentTop(), paintAxisLine ) } else { - c.drawLine( + canvas.drawLine( viewPortHandler.contentLeft(), viewPortHandler.contentBottom(), viewPortHandler.contentRight(), viewPortHandler.contentBottom(), paintAxisLine @@ -123,7 +123,7 @@ open class YAxisRendererHorizontalBarChart( * @param fixedPosition * @param positions */ - override fun drawYLabels(c: Canvas, fixedPosition: Float, positions: FloatArray, offset: Float) { + override fun drawYLabels(canvas: Canvas, fixedPosition: Float, positions: FloatArray, offset: Float) { paintAxisLabels.setTypeface(yAxis.typeface) paintAxisLabels.textSize = yAxis.textSize paintAxisLabels.color = yAxis.textColor @@ -139,7 +139,7 @@ open class YAxisRendererHorizontalBarChart( for (i in from.. { val labelLineHeight = Utils.calcTextHeight(limitLinePaint, label).toFloat() limitLinePaint.textAlign = Align.LEFT - c.drawText(label, pts[0] + xOffset, viewPortHandler.contentTop() + yOffset + labelLineHeight, limitLinePaint) + canvas.drawText(label, pts[0] + xOffset, viewPortHandler.contentTop() + yOffset + labelLineHeight, limitLinePaint) } LimitLabelPosition.RIGHT_BOTTOM -> { limitLinePaint.textAlign = Align.LEFT - c.drawText(label, pts[0] + xOffset, viewPortHandler.contentBottom() - yOffset, limitLinePaint) + canvas.drawText(label, pts[0] + xOffset, viewPortHandler.contentBottom() - yOffset, limitLinePaint) } LimitLabelPosition.LEFT_TOP -> { limitLinePaint.textAlign = Align.RIGHT val labelLineHeight = Utils.calcTextHeight(limitLinePaint, label).toFloat() - c.drawText(label, pts[0] - xOffset, viewPortHandler.contentTop() + yOffset + labelLineHeight, limitLinePaint) + canvas.drawText(label, pts[0] - xOffset, viewPortHandler.contentTop() + yOffset + labelLineHeight, limitLinePaint) } else -> { limitLinePaint.textAlign = Align.RIGHT - c.drawText(label, pts[0] - xOffset, viewPortHandler.contentBottom() - yOffset, limitLinePaint) + canvas.drawText(label, pts[0] - xOffset, viewPortHandler.contentBottom() - yOffset, limitLinePaint) } } } diff --git a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/YAxisRendererRadarChart.kt b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/YAxisRendererRadarChart.kt index e2a0afcbf..7dbed61b1 100644 --- a/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/YAxisRendererRadarChart.kt +++ b/MPChartLib/src/main/java/com/github/mikephil/charting/renderer/YAxisRendererRadarChart.kt @@ -134,7 +134,7 @@ class YAxisRendererRadarChart(viewPortHandler: ViewPortHandler, yAxis: YAxis, pr axis.mAxisRange = abs((axis.mAxisMaximum - axis.mAxisMinimum).toDouble()).toFloat() } - override fun renderAxisLabels(c: Canvas) { + override fun renderAxisLabels(canvas: Canvas) { if (!yAxis.isEnabled || !yAxis.isDrawLabelsEnabled) return paintAxisLabels!!.setTypeface(yAxis.typeface) @@ -160,13 +160,13 @@ class YAxisRendererRadarChart(viewPortHandler: ViewPortHandler, yAxis: YAxis, pr val label = yAxis.getFormattedLabel(j) - c.drawText(label, pOut.x + xOffset, pOut.y, paintAxisLabels!!) + canvas.drawText(label, pOut.x + xOffset, pOut.y, paintAxisLabels!!) } MPPointF.recycleInstance(center) MPPointF.recycleInstance(pOut) } - override fun renderLimitLines(c: Canvas) { + override fun renderLimitLines(canvas: Canvas) { val limitLines = yAxis.limitLines ?: return val sliceAngle = chart.sliceAngle @@ -200,7 +200,7 @@ class YAxisRendererRadarChart(viewPortHandler: ViewPortHandler, yAxis: YAxis, pr } limitPath.close() - c.drawPath(limitPath, limitLinePaint!!) + canvas.drawPath(limitPath, limitLinePaint!!) } MPPointF.recycleInstance(center) MPPointF.recycleInstance(pOut)