refactor Bounds and InsetPad into utilities, add handling of label rotation

Author: brayellison

compose-charts/src/commonMain/kotlin/ir/ehsannarmani/compose_charts/LineChart.kt

@@ -37,6 +37,7 @@ import androidx.compose.ui.graphics.drawscope.DrawScope
 import androidx.compose.ui.graphics.drawscope.Stroke
 import androidx.compose.ui.graphics.drawscope.clipRect
 import androidx.compose.ui.graphics.drawscope.inset
+import androidx.compose.ui.graphics.drawscope.rotate
 import androidx.compose.ui.graphics.isSpecified
 import androidx.compose.ui.graphics.takeOrElse
 import androidx.compose.ui.input.pointer.PointerInputScope
@@ -73,6 +74,8 @@ import ir.ehsannarmani.compose_charts.models.LabelProperties
 import ir.ehsannarmani.compose_charts.models.Line
 import ir.ehsannarmani.compose_charts.models.PopupProperties
 import ir.ehsannarmani.compose_charts.models.ZeroLineProperties
+import ir.ehsannarmani.compose_charts.utils.InsetPad
+import ir.ehsannarmani.compose_charts.utils.bounds
 import ir.ehsannarmani.compose_charts.utils.calculateOffset
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
@@ -250,7 +253,7 @@ fun LineChart(
             if (!properties.enabled) return@forEachIndexed
 
             val bounds = insetPad.toBounds(size)
-            val positionX = position.x.coerceIn(bounds.xMin, bounds.xMax)
+            val positionX = position.x.coerceIn(bounds.left, bounds.right)
             val pathData = linesPathData[dataIndex]
 
             val isSingleValue = line.values.count() == 1
@@ -775,44 +778,6 @@ data class DotInfo(
     val value: Float,
 )
 
-data class InsetBounds(
-    val xMin: Float,
-    val xMax: Float,
-    val yMin: Float,
-    val yMax: Float,
-) {
-    fun xWithin(x: Float): Boolean {
-        return x in xMin..xMax
-    }
-
-    fun yWithin(y: Float): Boolean {
-        return y in yMin..yMax
-    }
-
-    fun pointWithin(x: Float, y: Float): Boolean {
-        return xWithin(x) && yWithin(y)
-    }
-}
-
-data class InsetPad(
-    var left: Float,
-    var right: Float,
-    var top: Float,
-    var bottom: Float,
-) {
-    fun width(size: IntSize): Float {
-        return size.width - left - right
-    }
-
-    fun height(size: IntSize): Float {
-        return size.height - top - bottom
-    }
-
-    fun toBounds(size: IntSize) = InsetBounds(
-        left, size.width - right, top, size.height - bottom
-    )
-}
-
 fun DrawScope.inset(insetPad: InsetPad, block: DrawScope.() -> Unit) {
     val mostLeft = size.width / 2f
     val mostTop = size.height / 2f
@@ -826,6 +791,43 @@ fun DrawScope.inset(insetPad: InsetPad, block: DrawScope.() -> Unit) {
     }
 }
 
+data class MinLabelPadding(
+    val minLeft: Float,
+    val minRight: Float,
+    val minBottom: Float,
+    val shouldRotate: Boolean
+)
+
+fun getLabelMinPadding(
+    labels: List<String>,
+    labelProperties: LabelProperties,
+    measureLabel: (String) -> TextLayoutResult
+): MinLabelPadding {
+    if (labels.isEmpty()) return MinLabelPadding(0f, 0f, 0f, false)
+    val measuredLabels = labels.map { measureLabel(it) }
+    val labelPad = measureLabel("M").size.width
+    val maxLabelWidth = measuredLabels.maxOf { it.size.width }
+    val minLabelWidth = measuredLabels.minOf { it.size.width }
+    val shouldRotate = labelProperties.rotation.mode == LabelProperties.Rotation.Mode.Force ||
+            ((maxLabelWidth / minLabelWidth.toDouble()) >= 1.5 && labelProperties.rotation.degree != 0f)
+    if (shouldRotate) {
+        val rotatedBounds =
+            measuredLabels.map { it.bounds.rotate(-labelProperties.rotation.degree) }
+        return MinLabelPadding(
+            rotatedBounds[0].width / 2f,
+            rotatedBounds.last().width / 2f,
+            rotatedBounds.maxOf { it.height } + labelPad,
+            true
+        )
+    }
+    return MinLabelPadding(
+        measuredLabels[0].size.width / 2f,
+        measuredLabels.last().size.width / 2f,
+        measuredLabels.maxOf { it.size.height }.toFloat() + labelPad,
+        false
+    )
+}
+
 fun getInsetPad(
     measureLabel: (String) -> TextLayoutResult,
     measureIndicator: (String) -> TextLayoutResult,
@@ -834,38 +836,28 @@ fun getInsetPad(
     labelProperties: LabelProperties
 ): InsetPad {
     val labels = labelProperties.labels
-    val insetPad = InsetPad(0f, 0f, 0f, 0f)
+    val (minLeft, minRight, minBottom, shouldRotate) =
+        getLabelMinPadding(labels, labelProperties, measureLabel)
+    val insetPad = InsetPad(0f, 0f, 0f, 0f, shouldRotate)
     if (indicators.isNotEmpty() && indicatorProperties.enabled) {
         val indicatorPad = measureIndicator("M").size.width
         val textIndicators = indicators.map(indicatorProperties.contentBuilder)
         val maxIndicatorWidth = textIndicators.maxOf { measureIndicator(it).size.width }
         val maxIndicatorHeight = textIndicators.maxOf { measureIndicator(it).size.height }
         insetPad.top = maxIndicatorHeight / 2f
-        if (labels.isNotEmpty()) {
-            val labelPad = measureLabel("M").size.width
-            insetPad.bottom = labels.maxOf { measureLabel(it).size.height }.toFloat() + labelPad
-            if (indicatorProperties.position == IndicatorPosition.Horizontal.Start) {
-                insetPad.left =
-                    max(measureLabel(labels[0]).size.width / 2f, maxIndicatorWidth.toFloat()) +
-                            indicatorPad.toFloat()
-                insetPad.right = measureLabel(labels.last()).size.width / 2f
-            } else {
-                insetPad.left = measureLabel(labels[0]).size.width / 2f
-                insetPad.right =
-                    max(measureLabel(labels.last()).size.width / 2f, maxIndicatorWidth.toFloat()) +
-                            indicatorPad.toFloat()
-            }
+        insetPad.bottom = max(maxIndicatorHeight / 2f, minBottom)
+        val indicatorSidePad = max(minLeft, maxIndicatorWidth.toFloat()) + indicatorPad.toFloat()
+        if (indicatorProperties.position == IndicatorPosition.Horizontal.Start) {
+            insetPad.left = indicatorSidePad
+            insetPad.right = minRight
         } else {
-            insetPad.bottom = (maxIndicatorHeight) / 2f
-            if (indicatorProperties.position == IndicatorPosition.Horizontal.Start) {
-                insetPad.left = (maxIndicatorWidth + indicatorPad).toFloat()
-            } else {
-                insetPad.right = (maxIndicatorWidth + indicatorPad).toFloat()
-            }
+            insetPad.left = minLeft
+            insetPad.right = indicatorSidePad
         }
     } else if (labels.isNotEmpty()) {
-        insetPad.left = measureLabel(labels[0]).size.width / 2f
-        insetPad.right = measureLabel(labels.last()).size.width / 2f
+        insetPad.left = minLeft
+        insetPad.right = minRight
+        insetPad.bottom = minBottom
     }
     return insetPad
 }
@@ -976,59 +968,109 @@ private fun RowScope.LineChartCanvas(
         onPressJobChange = onPressJobChange
     )
     Canvas(modifier = modifier) {
-        val yTicks = if (indicators.isNotEmpty() && indicatorProperties.enabled) {
-            val sortedIndicators = indicators.sortedBy { -it }.filter { it in minValue..maxValue }
-            val maxIndicatorWidth = sortedIndicators.maxOf {
-                measureIndicator(indicatorProperties.contentBuilder(it)).size.width
-            }
-            val drawingHeight = size.height - insetPad.top - insetPad.bottom
-            val getOffset = { value: Double ->
-                drawingHeight + insetPad.top - calculateOffset(
-                    maxValue,
-                    minValue,
-                    drawingHeight,
-                    value.toFloat()
+        val yTicks = getTicksAndDrawIndicators(
+            indicators,
+            indicatorProperties,
+            minValue,
+            maxValue,
+            measureIndicator,
+            insetPad,
+            textMeasurer,
+        )
+        val xTicks = getTicksAndDrawLabels(labelProperties, measureLabel, insetPad, textMeasurer)
+        inset(insetPad) {
+            insetDrawScope(xTicks + listOf(0f, size.width), yTicks + listOf(0f, size.height))
+        }
+    }
+}
+
+fun DrawScope.getTicksAndDrawIndicators(
+    indicators: List<Double>,
+    indicatorProperties: HorizontalIndicatorProperties,
+    minValue: Double,
+    maxValue: Double,
+    measureIndicator: (String) -> TextLayoutResult,
+    insetPad: InsetPad,
+    textMeasurer: TextMeasurer
+): List<Float> {
+    return if (indicators.isNotEmpty() && indicatorProperties.enabled) {
+        val sortedIndicators = indicators.sortedBy { -it }.filter { it in minValue..maxValue }
+        val maxIndicatorWidth = sortedIndicators.maxOf {
+            measureIndicator(indicatorProperties.contentBuilder(it)).size.width
+        }
+        val drawingHeight = size.height - insetPad.top - insetPad.bottom
+        val getTick = { value: Double ->
+            drawingHeight - calculateOffset(
+                maxValue,
+                minValue,
+                drawingHeight,
+                value.toFloat()
+            )
+        }
+        sortedIndicators.map {
+            val tick = getTick(it)
+            val offset = tick + insetPad.top
+            val text = indicatorProperties.contentBuilder(it)
+            val textSize = measureIndicator(text)
+            if (indicatorProperties.position == IndicatorPosition.Horizontal.Start) {
+                drawText(
+                    textMeasurer = textMeasurer,
+                    text = text,
+                    style = indicatorProperties.textStyle,
+                    topLeft = Offset(
+                        (maxIndicatorWidth - textSize.size.width).toFloat(),
+                        offset.toFloat() - textSize.size.height / 2f
+                    )
                 )
-            }
-            sortedIndicators.map {
-                val offset = getOffset(it)
-                val text = indicatorProperties.contentBuilder(it)
-                val textSize = measureIndicator(text)
-                if (indicatorProperties.position == IndicatorPosition.Horizontal.Start) {
-                    drawText(
-                        textMeasurer = textMeasurer,
-                        text = text,
-                        style = indicatorProperties.textStyle,
-                        topLeft = Offset(
-                            (maxIndicatorWidth - textSize.size.width).toFloat(),
-                            offset.toFloat() - textSize.size.height / 2f
-                        )
+            } else {
+                drawText(
+                    textMeasurer = textMeasurer,
+                    text = text,
+                    style = indicatorProperties.textStyle,
+                    topLeft = Offset(
+                        (size.width - maxIndicatorWidth),
+                        offset.toFloat() - textSize.size.height / 2f
                     )
-                } else {
+                )
+            }
+            tick.toFloat()
+        }
+    } else emptyList()
+}
+
+fun DrawScope.getTicksAndDrawLabels(
+    labelProperties: LabelProperties,
+    measureLabel: (String) -> TextLayoutResult,
+    insetPad: InsetPad,
+    textMeasurer: TextMeasurer
+): List<Float> {
+    return if (labelProperties.labels.isNotEmpty() && labelProperties.enabled) {
+        val labels = labelProperties.labels
+        val maxLabelHeight = labels.maxOf {
+            measureLabel(it).size.height
+        }
+        val insetBounds = insetPad.toBounds(size)
+        val bottomStart = insetBounds.bottom + measureLabel("M").size.width.let {
+            if (insetPad.shouldRotate) it*2f/3 else it.toFloat()
+        }
+        labels.mapIndexed { index, label ->
+            val tick = insetBounds.width * index / (labels.size - 1)
+            val offset = insetBounds.left + tick
+            val textSize = measureLabel(label)
+            if (insetPad.shouldRotate) {
+                val degrees = labelProperties.rotation.degree
+                val bounds = textSize.bounds
+                val rotatedBounds = bounds.rotate(-degrees)
+                val center = Offset(offset, bottomStart + rotatedBounds.height / 2f)
+                rotate(degrees, pivot = center) {
                     drawText(
                         textMeasurer = textMeasurer,
-                        text = text,
-                        style = indicatorProperties.textStyle,
-                        topLeft = Offset(
-                            (size.width - maxIndicatorWidth),
-                            offset.toFloat() - textSize.size.height / 2f
-                        )
+                        text = label,
+                        style = labelProperties.textStyle,
+                        topLeft = center - Offset(textSize.size.width/2f, textSize.size.height/2f)
                     )
                 }
-                (offset - insetPad.top).toFloat()
-            }
-        } else emptyList()
-        val xTicks = if (labelProperties.labels.isNotEmpty() && labelProperties.enabled) {
-            val labels = labelProperties.labels
-            val maxLabelHeight = labels.maxOf {
-                measureLabel(it).size.height
-            }
-            val start = insetPad.left
-            val end = size.width - insetPad.right
-            val range = end - start
-            labels.mapIndexed { index, label ->
-                val offset = start + range * index / (labels.size - 1)
-                val textSize = measureLabel(label)
+            } else {
                 drawText(
                     textMeasurer = textMeasurer,
                     text = label,
@@ -1038,13 +1080,8 @@ private fun RowScope.LineChartCanvas(
                         size.height - maxLabelHeight
                     )
                 )
-                offset - start
             }
-        } else emptyList()
-        inset(insetPad) {
-            insetDrawScope(xTicks + listOf(0f, size.width), yTicks + listOf(0f, size.height))
+            tick
         }
-    }
+    } else emptyList()
 }
-
-