Merge pull request #24 from Pfuster12/v1.3.0-milestone

Pfuster12 · web-flow · commit d703513bc555 · 2020-08-15T17:13:01.000+01:00
1.3.0 milestone
diff --git a/README.md b/README.md
@@ -295,7 +295,9 @@ possible.
 
 If you place the LiveChart in a scrollview the touch event gets consumed early.
 
-Unfortunately this is a feature of the Android Touch system. Without ruining the ScrollView functionality from the library side, a working solution is to call the LiveChart view's parent requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) :
+Unfortunately this is a feature of the Android Touch system. Without ruining the ScrollView
+functionality from the library side, a working solution is to call the 
+LiveChart view's parent `requestDisallowInterceptTouchEvent(disallowIntercept: Boolean)` :
 
 ```
 liveChart.setDataset(dataset)
diff --git a/app/src/main/java/com/yabu/livechartdemoapp/MainActivity.kt b/app/src/main/java/com/yabu/livechartdemoapp/MainActivity.kt
@@ -32,6 +32,7 @@ class MainActivity : AppCompatActivity() {
             pathStrokeWidth = 8f
             secondPathStrokeWidth = 4f
             textHeight = 40f
+            textColor = Color.WHITE
             overlayLineColor = Color.BLUE
             overlayCircleDiameter = 32f
             overlayCircleColor = Color.GREEN
@@ -49,6 +50,12 @@ class MainActivity : AppCompatActivity() {
 
         livechartSimple.setDataset(dataset)
             .setLiveChartStyle(chartStyle)
+            .drawYBounds()
+            .drawSmoothPath()
+            .drawVerticalGuidelines()
+            .setVerticalGuidelineSteps(2)
+            .setHorizontalGuidelineSteps(2)
+            .drawHorizontalGuidelines()
             .setOnTouchCallbackListener(object : LiveChart.OnTouchCallback {
                 @SuppressLint("SetTextI18n")
                 override fun onTouchCallback(point: DataPoint) {
@@ -82,17 +89,39 @@ class MainActivity : AppCompatActivity() {
         }
 
         livechart.setDataset(firstDataset)
-            .setSecondDataset(secondDataset)
             .setLiveChartStyle(style)
-            .disableTouchOverlay()
             .drawYBounds()
+            .setOnTouchCallbackListener(object : LiveChart.OnTouchCallback {
+                @SuppressLint("SetTextI18n")
+                override fun onTouchCallback(point: DataPoint) {
+                    livechart.parent
+                        .requestDisallowInterceptTouchEvent(true)
+                }
+
+                override fun onTouchFinished() {
+                    livechart.parent
+                        .requestDisallowInterceptTouchEvent(false)
+                }
+            })
             .drawDataset()
 
         livechartNegative.setDataset(negativeDataset)
             .drawYBounds()
             .drawBaseline()
             .drawLastPointLabel()
             .drawFill(false)
+            .setOnTouchCallbackListener(object : LiveChart.OnTouchCallback {
+                @SuppressLint("SetTextI18n")
+                override fun onTouchCallback(point: DataPoint) {
+                    livechartNegative.parent
+                        .requestDisallowInterceptTouchEvent(true)
+                }
+
+                override fun onTouchFinished() {
+                    livechartNegative.parent
+                        .requestDisallowInterceptTouchEvent(false)
+                }
+            })
             .drawDataset()
     }
 }
diff --git a/livechart/src/main/java/com/yabu/livechart/utils/EPointF.kt b/livechart/src/main/java/com/yabu/livechart/utils/EPointF.kt
@@ -0,0 +1,29 @@
+package com.yabu.livechart.utils
+
+/**
+ * Code adapted for LiveChart from Stuart Kent - July 3, 2015
+ *  https://www.stkent.com/2015/07/03/building-smooth-paths-using-bezier-curves.html
+ */
+class EPointF(val x: Float, val y: Float) {
+
+    fun plus(factor: Float, ePointF: EPointF): EPointF {
+        return EPointF(x + factor * ePointF.x, y + factor * ePointF.y)
+    }
+
+    operator fun plus(ePointF: EPointF): EPointF {
+        return plus(1.0f, ePointF)
+    }
+
+    fun minus(factor: Float, ePointF: EPointF): EPointF {
+        return EPointF(x - factor * ePointF.x, y - factor * ePointF.y)
+    }
+
+    operator fun minus(ePointF: EPointF): EPointF {
+        return minus(1.0f, ePointF)
+    }
+
+    fun scaleBy(factor: Float): EPointF {
+        return EPointF(factor * x, factor * y)
+    }
+
+}
diff --git a/livechart/src/main/java/com/yabu/livechart/utils/PolyBezierPathUtil.kt b/livechart/src/main/java/com/yabu/livechart/utils/PolyBezierPathUtil.kt
@@ -0,0 +1,148 @@
+package com.yabu.livechart.utils
+
+
+import android.graphics.Path
+import com.yabu.livechart.model.DataPoint
+
+/**
+ *  Code adapted for LiveChart from Stuart Kent - July 3, 2015
+ *  https://www.stkent.com/2015/07/03/building-smooth-paths-using-bezier-curves.html
+ */
+object PolyBezierPathUtil {
+
+    /**
+     * Computes a Poly-Bezier curve passing through a given list of knots.
+     * The curve will be twice-differentiable everywhere and satisfy natural
+     * boundary conditions at both ends.
+     *
+     * @param points [DataPoint] list
+     * @return      a Path representing the twice-differentiable curve
+     * passing through all the given knots
+     */
+    fun computePathThroughDataPoints(knots: List<EPointF>): Path {
+        throwExceptionIfInputIsInvalid(knots)
+        val polyBezierPath = Path()
+        val firstKnot: EPointF = knots[0]
+        polyBezierPath.moveTo(firstKnot.x, firstKnot.y)
+
+        val n = knots.size - 1
+        if (n == 1) {
+            val lastKnot: EPointF = knots[1]
+            polyBezierPath.lineTo(lastKnot.x, lastKnot.y)
+        } else {
+            val controlPoints: List<EPointF> = computeControlPoints(n, knots)
+            for (i in 0 until n) {
+                val targetKnot: EPointF = knots[i + 1]
+                appendCurveToPath(
+                    polyBezierPath,
+                    controlPoints[i],
+                    controlPoints[n + i],
+                    targetKnot
+                )
+            }
+        }
+        return polyBezierPath
+    }
+
+    private fun computeControlPoints(
+        n: Int,
+        knots: List<EPointF>
+    ): List<EPointF> {
+        val result: MutableList<EPointF> = MutableList(2*n) { EPointF(0f, 0f)}
+        val target: List<EPointF> = constructTargetVector(n, knots)
+        val lowerDiag = constructLowerDiagonalVector(n - 1)
+        val mainDiag = constructMainDiagonalVector(n)
+        val upperDiag = constructUpperDiagonalVector(n - 1)
+        val newTarget: MutableList<EPointF> = MutableList(n) { EPointF(0f, 0f) }
+        val newUpperDiag = MutableList(n-1) { it.toFloat()}
+
+        // forward sweep for control points c_i,0:
+        newUpperDiag[0] = upperDiag[0] / mainDiag[0]
+        newTarget[0] = target[0].scaleBy(1 / mainDiag[0])
+        for (i in 1 until n - 1) {
+            newUpperDiag[i] = upperDiag[i] /
+                    (mainDiag[i] - lowerDiag[i - 1] * newUpperDiag[i - 1])
+        }
+        for (i in 1 until n) {
+            val targetScale = 1 /
+                    (mainDiag[i] - lowerDiag[i - 1] * newUpperDiag[i - 1])
+            newTarget[i] =
+                target[i].minus(newTarget[i - 1].scaleBy(lowerDiag[i - 1])).scaleBy(
+                    targetScale
+                )
+        }
+
+        // backward sweep for control points c_i,0:
+        result[n - 1] = newTarget[n - 1]
+        for (i in n - 2 downTo 0) {
+            result[i] = newTarget[i].minus(newUpperDiag[i], result[i + 1])
+        }
+
+        // calculate remaining control points c_i,1 directly:
+        for (i in 0 until n - 1) {
+            result[n + i] = knots[i + 1].scaleBy(2f).minus(result[i + 1])
+        }
+        result[2 * n - 1] = knots[n].plus(result[n - 1]).scaleBy(0.5f)
+        return result
+    }
+
+    private fun constructTargetVector(
+        n: Int,
+        knots: List<EPointF>
+    ): List<EPointF> {
+        val result: MutableList<EPointF> = MutableList<EPointF>(n) { EPointF(0f, 0f) }
+        result[0] = knots[0].plus(2f, knots[1])
+        for (i in 1 until n - 1) {
+            result[i] = knots[i].scaleBy(2f).plus(knots[i + 1]).scaleBy(2f)
+        }
+        result[result.size - 1] = knots[n - 1].scaleBy(8f).plus(knots[n])
+        return result
+    }
+
+    private fun constructLowerDiagonalVector(length: Int): List<Float> {
+        val result = MutableList<Float>(length) { it.toFloat() }
+        for (i in 0 until length - 1) {
+            result[i] = 1f
+        }
+        result[result.size - 1] = 2f
+        return result
+    }
+
+    private fun constructMainDiagonalVector(n: Int): List<Float> {
+        val result = MutableList<Float>(n) { it.toFloat() }
+        result[0] = 2f
+        for (i in 1 until n - 1) {
+            result[i] = 4f
+        }
+        result[n - 1] = 7f
+        return result
+    }
+
+    private fun constructUpperDiagonalVector(length: Int): List<Float> {
+        val result = MutableList<Float>(length) { it.toFloat() }
+        for (i in 0 until length) {
+            result[i] = 1f
+        }
+        return result
+    }
+
+    private fun appendCurveToPath(
+        path: Path,
+        control1: EPointF,
+        control2: EPointF,
+        targetKnot: EPointF
+    ) {
+        path.cubicTo(
+            control1.x,
+            control1.y,
+            control2.x,
+            control2.y,
+            targetKnot.x,
+            targetKnot.y
+        )
+    }
+
+    private fun throwExceptionIfInputIsInvalid(knots: List<EPointF>) {
+        require(knots.size >= 2) { "Collection must contain at least two knots" }
+    }
+}
diff --git a/livechart/src/main/java/com/yabu/livechart/view/LiveChart.kt b/livechart/src/main/java/com/yabu/livechart/view/LiveChart.kt
@@ -134,6 +134,23 @@ class LiveChart(context: Context, attrs: AttributeSet?) : FrameLayout(context, a
         return this
     }
 
+    /**
+     * Draw smooth path flag.
+     */
+    @PublicApi
+    fun drawSmoothPath(): LiveChart {
+        livechart.drawSmoothPath()
+        overlay.drawSmoothPath()
+        return this
+    }
+
+    @PublicApi
+    fun drawStraightPath(): LiveChart {
+        livechart.drawStraightPath()
+        overlay.drawStraightPath()
+        return this
+    }
+
     /**
      * Disable Fill flag.
      */
@@ -197,6 +214,51 @@ class LiveChart(context: Context, attrs: AttributeSet?) : FrameLayout(context, a
         return this
     }
 
+    /**
+     * Draw vertical guidelines
+     */
+    @Suppress("UNUSED")
+    @PublicApi
+    fun drawVerticalGuidelines(): LiveChart {
+        livechart.drawVerticalGuidelines()
+
+        return this
+    }
+
+    /**
+     * Draw horizontal guidelines
+     */
+    @Suppress("UNUSED")
+    @PublicApi
+    fun drawHorizontalGuidelines(): LiveChart {
+        livechart.drawHorizontalGuidelines()
+
+        return this
+    }
+
+    /**
+     * Set vertical guidelines steps
+     */
+    @Suppress("UNUSED")
+    @PublicApi
+    fun setVerticalGuidelineSteps(steps: Int): LiveChart {
+        livechart.setVerticalGuidelineSteps(steps)
+
+        return this
+    }
+
+    /**
+     * Set horizontal guidelines steps
+     */
+    @Suppress("UNUSED")
+    @PublicApi
+    fun setHorizontalGuidelineSteps(steps: Int): LiveChart {
+        livechart.setHorizontalGuidelineSteps(steps)
+
+        return this
+    }
+
+
     /**
      * Draw on chart and bind overlay to dataset.
      */
diff --git a/livechart/src/main/java/com/yabu/livechart/view/LiveChartAttributes.kt b/livechart/src/main/java/com/yabu/livechart/view/LiveChartAttributes.kt
@@ -15,6 +15,12 @@ internal object LiveChartAttributes {
 
     const val MAIN_COLOR = Color.BLACK
 
+    const val SECOND_COLOR = Color.GRAY
+
+    const val TRANSPARENT_COLOR = "#00000000"
+
+    const val CORNER_RADIUS = 0f
+
     const val POSITIVE_COLOR = "#01C194"
 
     const val FILL_COLOR = "#11303030"
@@ -25,6 +31,12 @@ internal object LiveChartAttributes {
 
     const val NEGATIVE_FILL_COLOR = "#11d70a53"
 
+    const val BOUNDS_LINE_COLOR = Color.GRAY
+
+    const val BASELINE_LINE_COLOR = Color.GRAY
+
+    const val GUIDELINE_COLOR = Color.LTGRAY
+
     const val TAG_WIDTH = 120f
 
     const val CHART_END_PADDING = 140f
diff --git a/livechart/src/main/java/com/yabu/livechart/view/LiveChartStyle.kt b/livechart/src/main/java/com/yabu/livechart/view/LiveChartStyle.kt
@@ -20,7 +20,7 @@ class LiveChartStyle {
     /**
      * Main color
      */
-    var secondColor: Int = Color.GRAY
+    var secondColor: Int = LiveChartAttributes.SECOND_COLOR
 
     /**
      * Positive from baseline fill color.
@@ -47,15 +47,30 @@ class LiveChartStyle {
      */
     var negativeFillColor: Int = Color.parseColor(LiveChartAttributes.NEGATIVE_FILL_COLOR)
 
+    /**
+     * Main Path corner radius pixel amount.
+     */
+    var mainCornerRadius: Float = LiveChartAttributes.CORNER_RADIUS
+
+    /**
+     * Second Path corner radius pixel amount.
+     */
+    var secondCornerRadius: Float = LiveChartAttributes.CORNER_RADIUS
+
     /**
      * Baseline color.
      */
-    var baselineColor: Int = Color.GRAY
+    var baselineColor: Int = LiveChartAttributes.BASELINE_LINE_COLOR
+
+    /**
+     * Bounds color.
+     */
+    var boundsLineColor: Int = LiveChartAttributes.BOUNDS_LINE_COLOR
 
     /**
      * Baseline color.
      */
-    var boundsLineColor: Int = Color.GRAY
+    var guideLineColor: Int = LiveChartAttributes.GUIDELINE_COLOR
 
     /**
      * Path stroke width
diff --git a/livechart/src/main/java/com/yabu/livechart/view/LiveChartTouchOverlay.kt b/livechart/src/main/java/com/yabu/livechart/view/LiveChartTouchOverlay.kt
diff --git a/livechart/src/main/java/com/yabu/livechart/view/LiveChartView.kt b/livechart/src/main/java/com/yabu/livechart/view/LiveChartView.kt
diff --git a/livechart/src/main/res/values/attrs.xml b/livechart/src/main/res/values/attrs.xml
