Koala Plot Documentation

Koala Plot is a Compose Multiplatform-based charting library for Android, Desktop, iOS, and Web. Most plot elements are Composables, allowing for deep customization of colors, fonts, borders, and user interactions.

Supported chart types include:

• Pie and Donut charts: With hover effects, customizable labels, and donut center content.
• Line graphs: Supporting linear/log axes, numeric/category axes, zoom/pan, shaded areas (area charts), and various curve types (linear, stairstep, Bezier).
• Stacked area graphs: For plotting multiple lines with accumulated shaded areas.
• Vertical bar graphs: Supporting clustered and stacked bars, as well as negative values.
• Bullet Graphs: For individual or multiple vertically aligned metrics.
• Radar/Polar/Spider plots: Supporting lines, areas, and symbols with configurable origin and orientation.
• Heatmaps
• Layouts and Legends: Includes chart layout positioning (title, plot, legend) and legend layouts (single column or flow-layout).

You can create a stacked vertical bar plot within an XYGraphScope using the StackedVerticalBarPlot DSL. This approach allows you to define multiple series, where each series adds a layer to the stack at specific x coordinates.

To use this, call StackedVerticalBarPlot and use the series function to define each layer. Within each series, use item(x, y) to add data points. If a specific bar Composable is provided to item, it will override the defaultBar for that specific data point.

XYGraphScope<String, Float>.MyPlot() {
    StackedVerticalBarPlot(modifier = Modifier) {
        // First layer (bottom)
        series(defaultBar = verticalSolidBar(Color.Red)) {
            item("Jan", 10f)
            item("Feb", 15f)
        }
        // Second layer (middle)
        series(defaultBar = verticalSolidBar(Color.Green)) {
            item("Jan", 5f)
            item("Feb", 20f)
        }
    }
}

You can create a stacked horizontal bar plot within an XYGraphScope using the StackedHorizontalBarPlot Composable. This version uses a DSL approach where you define multiple series, and within each series, you add items at specific y coordinates with a given x width.

Key components:

• series: Defines a new layer of the stack. You can provide a defaultBar Composable for all items in this series.
• item: Adds a bar segment at a specific y coordinate with a width x. You can optionally override the bar Composable for a specific item.

Note: This version is specifically for XYGraphScope<Float, Y> where the x-axis values are Float.

StackedHorizontalBarPlot<Float, String>(modifier = Modifier) {
    series(horizontalSolidBar(Color.Red)) {
        item(x = 10f, y = "Category A")
        item(x = 5f, y = "Category B")
    }
    series(horizontalSolidBar(Color.Blue)) {
        item(x = 15f, y = "Category A")
    }
}

If you have pre-calculated data, you can use the StackedVerticalBarPlot overload that accepts a List<E> where E implements VerticalBarPlotStackedPointEntry<X, Y>.

Each entry requires:

• x: The x-axis value.
• yOrigin: The bottom coordinate of the stack (usually 0).
• y: A List<Y> representing the cumulative top coordinates of each bar in the stack. For example, if the first bar is 10 units high and the second is 5 units high, y should be [10, 15].

// Define your data
val data = listOf(
    DefaultVerticalBarPlotStackedPointEntry(
        x = "Jan",
        yOrigin = 0f,
        y = listOf(10f, 25f) // First bar height 10, second bar ends at 25
    )
)

// Render in XYGraphScope
StackedVerticalBarPlot(
    data = data,
    bar = { seriesIndex, barIndex, value -> 
        // Custom bar rendering logic
        verticalSolidBar(Color.Blue)(this, seriesIndex, barIndex, value)
    }
)

If you are providing your own data structure instead of using the DSL, you must implement the HorizontalBarPlotStackedPointEntry<X, Y> interface. This interface defines how the stacked segments are positioned along the x-axis for a given y-coordinate.

Properties:

• y: The y-axis value (the category/label).
• xOrigin: The starting x-coordinate (the left edge of the first bar in the stack).
• x: A List<X> representing the right-edge coordinates of each bar in the stack. The first element is the end of the first bar, the second is the end of the second bar, and so on.

public interface HorizontalBarPlotStackedPointEntry<X, Y> {
    public val y: Y
    public val xOrigin: X
    public val x: List<X>
}

// Standard implementation
public data class DefaultHorizontalBarPlotStackedPointEntry<X, Y>(
    override val y: Y,
    override val xOrigin: X,
    override val x: List<X>,
) : HorizontalBarPlotStackedPointEntry<X, Y>