Cleanup Fill

Author: hannesa2

MPChartLib/src/main/java/com/github/mikephil/charting/utils/Fill.kt

@@ -3,13 +3,12 @@ package com.github.mikephil.charting.utils
 import android.graphics.Canvas
 import android.graphics.LinearGradient
 import android.graphics.Paint
-import android.graphics.Path
 import android.graphics.RectF
 import android.graphics.Shader
 import android.graphics.drawable.Drawable
 import kotlin.math.floor
 
-class Fill {
+open class Fill {
     enum class Type {
         EMPTY, COLOR, LINEAR_GRADIENT, DRAWABLE
     }
@@ -28,12 +27,12 @@ class Fill {
      */
     private var mColor: Int? = null
 
-    private var mFinalColor: Int? = null
+    private var finalColor: Int? = null
 
     /**
      * the drawable to be used for filling
      */
-    protected var mDrawable: Drawable? = null
+    protected var drawable: Drawable? = null
 
     var gradientColors: IntArray = intArrayOf()
 
@@ -44,46 +43,18 @@ class Fill {
      */
     private var mAlpha = 255
 
-    constructor()
-
-    constructor(color: Int) {
-        this.type = Type.COLOR
-        this.mColor = color
-        calculateFinalColor()
-    }
-
     constructor(startColor: Int, endColor: Int) {
         this.type = Type.LINEAR_GRADIENT
         this.gradientColors = intArrayOf(startColor, endColor)
     }
 
-    constructor(gradientColors: IntArray) {
-        this.type = Type.LINEAR_GRADIENT
-        this.gradientColors = gradientColors
-    }
-
-    constructor(gradientColors: IntArray, gradientPositions: FloatArray) {
-        this.type = Type.LINEAR_GRADIENT
-        this.gradientColors = gradientColors
-        this.gradientPositions = gradientPositions
-    }
-
-    constructor(drawable: Drawable) {
-        this.type = Type.DRAWABLE
-        this.mDrawable = drawable
-    }
-
     var color: Int?
         get() = mColor
         set(color) {
             this.mColor = color
             calculateFinalColor()
         }
 
-    fun setGradientColors(startColor: Int, endColor: Int) {
-        this.gradientColors = intArrayOf(startColor, endColor)
-    }
-
     var alpha: Int
         get() = mAlpha
         set(alpha) {
@@ -93,10 +64,10 @@ class Fill {
 
     private fun calculateFinalColor() {
         if (mColor == null) {
-            mFinalColor = null
+            finalColor = null
         } else {
             val alpha = floor(((mColor!! shr 24) / 255.0) * (mAlpha / 255.0) * 255.0).toInt()
-            mFinalColor = (alpha shl 24) or (mColor!! and 0xffffff)
+            finalColor = (alpha shl 24) or (mColor!! and 0xffffff)
         }
     }
 
@@ -109,38 +80,35 @@ class Fill {
             Type.EMPTY -> return
 
             Type.COLOR -> {
-                if (mFinalColor == null) {
+                if (finalColor == null) {
                     return
                 }
 
                 if (this.isClipPathSupported) {
                     val save = c.save()
 
                     c.clipRect(left, top, right, bottom)
-                    c.drawColor(mFinalColor!!)
+                    c.drawColor(finalColor!!)
 
                     c.restoreToCount(save)
                 } else {
                     // save
-                    val previous = paint.getStyle()
-                    val previousColor = paint.getColor()
+                    val previous = paint.style
+                    val previousColor = paint.color
 
                     // set
-                    paint.setStyle(Paint.Style.FILL)
-                    paint.setColor(mFinalColor!!)
+                    paint.style = Paint.Style.FILL
+                    paint.color = finalColor!!
 
                     c.drawRoundRect(RectF(left, top, right, bottom), mRoundedBarRadius, mRoundedBarRadius, paint)
 
                     // restore
-                    paint.setColor(previousColor)
-                    paint.setStyle(previous)
+                    paint.color = previousColor
+                    paint.style = previous
                 }
             }
 
             Type.LINEAR_GRADIENT -> {
-                if (this.gradientColors == null) {
-                    return
-                }
 
                 val gradient = LinearGradient(
                     (if (gradientDirection == Direction.RIGHT)
@@ -151,126 +119,38 @@ class Fill {
                         bottom
                     else
                         top).toInt().toFloat(),
-                    (if (gradientDirection == Direction.RIGHT)
-                        left
-                    else
-                        if (gradientDirection == Direction.LEFT)
-                            right
-                        else
-                            left).toInt().toFloat(),
-                    (if (gradientDirection == Direction.UP)
-                        top
-                    else
-                        if (gradientDirection == Direction.DOWN)
-                            bottom
-                        else
-                            top).toInt().toFloat(),
-                    this.gradientColors!!,
+                    (when (gradientDirection) {
+                        Direction.RIGHT -> left
+                        Direction.LEFT -> right
+                        else -> left
+                    }).toInt().toFloat(),
+                    (when (gradientDirection) {
+                        Direction.UP -> top
+                        Direction.DOWN -> bottom
+                        else -> top
+                    }).toInt().toFloat(),
+                    this.gradientColors,
                     this.gradientPositions,
                     Shader.TileMode.MIRROR
                 )
 
-                paint.setShader(gradient)
+                paint.shader = gradient
 
                 c.drawRoundRect(RectF(left, top, right, bottom), mRoundedBarRadius, mRoundedBarRadius, paint)
             }
 
             Type.DRAWABLE -> {
-                if (mDrawable == null) {
-                    return
-                }
-
-                mDrawable!!.setBounds(left.toInt(), top.toInt(), right.toInt(), bottom.toInt())
-                mDrawable!!.draw(c)
-            }
-        }
-    }
-
-    fun fillPath(
-        c: Canvas, path: Path, paint: Paint,
-        clipRect: RectF?
-    ) {
-        when (this.type) {
-            Type.EMPTY -> return
-
-            Type.COLOR -> {
-                if (mFinalColor == null) {
-                    return
-                }
-
-                if (clipRect != null && this.isClipPathSupported) {
-                    val save = c.save()
-
-                    c.clipPath(path)
-                    c.drawColor(mFinalColor!!)
-
-                    c.restoreToCount(save)
-                } else {
-                    // save
-                    val previous = paint.getStyle()
-                    val previousColor = paint.getColor()
-
-                    // set
-                    paint.setStyle(Paint.Style.FILL)
-                    paint.setColor(mFinalColor!!)
-
-                    c.drawPath(path, paint)
-
-                    // restore
-                    paint.setColor(previousColor)
-                    paint.setStyle(previous)
-                }
-            }
-
-            Type.LINEAR_GRADIENT -> {
-                if (this.gradientColors == null) {
-                    return
-                }
-
-                val gradient = LinearGradient(
-                    0f,
-                    0f,
-                    c.getWidth().toFloat(),
-                    c.getHeight().toFloat(),
-                    this.gradientColors!!,
-                    this.gradientPositions,
-                    Shader.TileMode.MIRROR
-                )
-
-                paint.setShader(gradient)
-
-                c.drawPath(path, paint)
-            }
-
-            Type.DRAWABLE -> {
-                if (mDrawable == null) {
+                if (drawable == null) {
                     return
                 }
 
-                ensureClipPathSupported()
-
-                val save = c.save()
-                c.clipPath(path)
-
-                mDrawable!!.setBounds(
-                    if (clipRect == null) 0 else clipRect.left.toInt(),
-                    if (clipRect == null) 0 else clipRect.top.toInt(),
-                    if (clipRect == null) c.getWidth() else clipRect.right.toInt(),
-                    if (clipRect == null) c.getHeight() else clipRect.bottom.toInt()
-                )
-                mDrawable!!.draw(c)
-
-                c.restoreToCount(save)
+                drawable!!.setBounds(left.toInt(), top.toInt(), right.toInt(), bottom.toInt())
+                drawable!!.draw(c)
             }
         }
     }
 
     private val isClipPathSupported: Boolean
         get() = getSDKInt() >= 18
 
-    private fun ensureClipPathSupported() {
-        if (getSDKInt() < 18) {
-            throw RuntimeException("Fill-drawables not (yet) supported below API level 18, this code was run on API level \${getSDKInt()}")
-        }
-    }
 }