flet-charts 0.2.0.dev13__py3-none-any.whl

flutter/flet_charts/lib/src/scatter_chart.dart

@@ -0,0 +1,140 @@
+import 'package:fl_chart/fl_chart.dart';
+import 'package:flet/flet.dart';
+import 'package:flutter/material.dart';
+
+import 'utils/charts.dart';
+import 'utils/scatter_chart.dart';
+
+class ScatterChartControl extends StatefulWidget {
+  final Control control;
+
+  ScatterChartControl({Key? key, required this.control})
+      : super(key: ValueKey("control_${control.id}"));
+
+  @override
+  State<ScatterChartControl> createState() => _ScatterChartControlState();
+}
+
+class _ScatterChartControlState extends State<ScatterChartControl> {
+  @override
+  Widget build(BuildContext context) {
+    final theme = Theme.of(context);
+    var animation = widget.control.getAnimation(
+        "animation",
+        ImplicitAnimationDetails(
+            duration: const Duration(milliseconds: 150),
+            curve: Curves.linear))!;
+    var border = widget.control.getBorder("border", theme);
+
+    var leftTitles = parseAxisTitles(widget.control.child("left_axis"));
+    var topTitles = parseAxisTitles(widget.control.child("top_axis"));
+    var rightTitles = parseAxisTitles(widget.control.child("right_axis"));
+    var bottomTitles = parseAxisTitles(widget.control.child("bottom_axis"));
+
+    var interactive = widget.control.getBool("interactive", true)!;
+
+    // Build list of ScatterSpotData
+    final spots = widget.control.children('spots').map((spot) {
+      var x = spot.getDouble('x', 0)!;
+      var y = spot.getDouble('y', 0)!;
+      return ScatterSpot(x, y,
+          show: spot.getBool('visible', true)!,
+          renderPriority: spot.getInt('render_priority', 0)!,
+          xError: spot.get('x_error'),
+          yError: spot.get('y_error'),
+          dotPainter: spot.get("point") != null
+              ? parseChartDotPainter(spot.get("point"), theme, 0, null, null)
+              : FlDotCirclePainter(
+                  radius: spot.getDouble("radius"),
+                  color: spot.getColor(
+                      "color",
+                      context,
+                      Colors.primaries[
+                          ((x * y) % Colors.primaries.length).toInt()])!,
+                ));
+    }).toList();
+
+    final chart = ScatterChart(
+      ScatterChartData(
+        scatterSpots: spots,
+        backgroundColor: widget.control.getColor("bgcolor", context),
+        minX: widget.control.getDouble("min_x"),
+        maxX: widget.control.getDouble("max_x"),
+        minY: widget.control.getDouble("min_y"),
+        maxY: widget.control.getDouble("max_y"),
+        baselineX: widget.control.getDouble("baseline_x"),
+        baselineY: widget.control.getDouble("baseline_y"),
+        titlesData: FlTitlesData(
+          show: (leftTitles.sideTitles.showTitles ||
+              topTitles.sideTitles.showTitles ||
+              rightTitles.sideTitles.showTitles ||
+              bottomTitles.sideTitles.showTitles),
+          leftTitles: leftTitles,
+          topTitles: topTitles,
+          rightTitles: rightTitles,
+          bottomTitles: bottomTitles,
+        ),
+        borderData: FlBorderData(show: border != null, border: border),
+        gridData: parseChartGridData(
+            widget.control.get("horizontal_grid_lines"),
+            widget.control.get("vertical_grid_lines"),
+            theme),
+        scatterTouchData: ScatterTouchData(
+            enabled: interactive,
+            touchCallback: widget.control.getBool("on_event", false)!
+                ? (evt, resp) {
+                    var eventData =
+                        ScatterChartEventData.fromDetails(evt, resp);
+                    widget.control.triggerEvent("event", eventData.toMap());
+                  }
+                : null,
+            longPressDuration:
+                widget.control.getDuration("long_press_duration"),
+            handleBuiltInTouches:
+                widget.control.getBool("handle_built_in_touches", true)!,
+            touchTooltipData:
+                parseScatterTouchTooltipData(context, widget.control, spots)),
+        scatterLabelSettings: ScatterLabelSettings(
+          showLabel: true,
+          getLabelFunction: (spotIndex, spot) {
+            var dp = widget.control.children("spots")[spotIndex];
+            return dp.getString("label_text", "")!;
+          },
+          getLabelTextStyleFunction: (spotIndex, spot) {
+            var dp = widget.control.children("spots")[spotIndex];
+            var labelStyle =
+                dp.getTextStyle("label_style", theme, const TextStyle())!;
+            if (labelStyle.color == null) {
+              labelStyle =
+                  labelStyle.copyWith(color: spot.dotPainter.mainColor);
+            }
+            return labelStyle;
+          },
+        ),
+        showingTooltipIndicators: widget.control
+            .children('spots')
+            .asMap()
+            .entries
+            .where((e) => e.value.getBool("selected", false)!)
+            .map((e) => e.key)
+            .toList(),
+        rotationQuarterTurns:
+            widget.control.getInt('rotation_quarter_turns', 0)!,
+        //errorIndicatorData: widget.control.get('error_indicator_data'),
+      ),
+      duration: animation.duration,
+      curve: animation.curve,
+    );
+
+    return ConstrainedControl(
+        control: widget.control,
+        child: LayoutBuilder(
+            builder: (BuildContext context, BoxConstraints constraints) {
+          return (constraints.maxHeight == double.infinity)
+              ? ConstrainedBox(
+                  constraints: const BoxConstraints(maxHeight: 300),
+                  child: chart)
+              : chart;
+        }));
+  }
+}

flutter/flet_charts/lib/src/utils/bar_chart.dart

@@ -0,0 +1,177 @@
+import 'package:collection/collection.dart';
+import 'package:equatable/equatable.dart';
+import 'package:fl_chart/fl_chart.dart';
+import 'package:flet/flet.dart';
+import 'package:flutter/material.dart';
+
+import 'charts.dart';
+
+class BarChartEventData extends Equatable {
+  final String eventType;
+  final int? groupIndex;
+  final int? rodIndex;
+  final int? stackItemIndex;
+
+  const BarChartEventData(
+      {required this.eventType,
+      required this.groupIndex,
+      required this.rodIndex,
+      required this.stackItemIndex});
+
+  factory BarChartEventData.fromDetails(
+      FlTouchEvent event, BarTouchResponse? response) {
+    return BarChartEventData(
+        eventType: eventMap[event.runtimeType.toString()] ?? "undefined",
+        groupIndex: response != null && response.spot != null
+            ? response.spot!.touchedBarGroupIndex
+            : null,
+        rodIndex: response != null && response.spot != null
+            ? response.spot!.touchedRodDataIndex
+            : null,
+        stackItemIndex: response != null && response.spot != null
+            ? response.spot!.touchedStackItemIndex
+            : null);
+  }
+
+  Map<String, dynamic> toMap() => <String, dynamic>{
+        'type': eventType,
+        'group_index': groupIndex,
+        'rod_index': rodIndex,
+        'stack_item_index': stackItemIndex
+      };
+
+  @override
+  List<Object?> get props => [eventType, groupIndex, rodIndex, stackItemIndex];
+}
+
+TooltipDirection? parseTooltipDirection(String? value,
+    [TooltipDirection? defaultValue]) {
+  if (value == null) return defaultValue;
+  return TooltipDirection.values.firstWhereOrNull(
+          (e) => e.name.toLowerCase() == value.toLowerCase()) ??
+      defaultValue;
+}
+
+BarTouchTooltipData? parseBarTouchTooltipData(
+    BuildContext context, Control control,
+    [BarTouchTooltipData? defaultValue]) {
+  var tooltip = control.get("tooltip");
+  if (tooltip == null) return defaultValue;
+
+  final theme = Theme.of(context);
+
+  return BarTouchTooltipData(
+    getTooltipColor: (BarChartGroupData group) =>
+        parseColor(tooltip["bgcolor"], theme, theme.colorScheme.secondary)!,
+    tooltipBorderRadius: parseBorderRadius(tooltip["border_radius"]),
+    tooltipMargin: parseDouble(tooltip["margin"]),
+    tooltipPadding: parsePadding(tooltip["padding"]),
+    maxContentWidth: parseDouble(tooltip["max_width"]),
+    rotateAngle: parseDouble(tooltip["rotate_angle"]),
+    tooltipHorizontalOffset: parseDouble(tooltip["horizontal_offset"]),
+    tooltipBorder: parseBorderSide(tooltip["border_side"], theme),
+    fitInsideHorizontally: parseBool(tooltip["fit_inside_horizontally"]),
+    fitInsideVertically: parseBool(tooltip["fit_inside_vertically"]),
+    direction: parseTooltipDirection(tooltip["direction"]),
+    getTooltipItem: (group, groupIndex, rod, rodIndex) {
+      var rod =
+          control.children("groups")[groupIndex].children("rods")[rodIndex];
+      return parseBarTooltipItem(rod, context);
+    },
+  );
+}
+
+BarTooltipItem? parseBarTooltipItem(Control rod, BuildContext context) {
+  if (!rod.getBool("show_tooltip", true)!) return null;
+
+  final theme = Theme.of(context);
+
+  var tooltip = rod.get("tooltip");
+  var tooltipTextStyle =
+      parseTextStyle(tooltip["text_style"], theme, const TextStyle())!;
+  if (tooltipTextStyle.color == null) {
+    tooltipTextStyle = tooltipTextStyle.copyWith(
+        color: rod.getGradient("gradient", theme)?.colors.first ??
+            rod.getColor("color", context, Colors.blueGrey)!);
+  }
+  return BarTooltipItem(
+      tooltip["text"] ?? rod.getDouble("to_y", 0)!.toString(), tooltipTextStyle,
+      textAlign: parseTextAlign(tooltip["text_align"], TextAlign.center)!,
+      children: tooltip["text_spans"] != null
+          ? parseTextSpans(tooltip["text_spans"], theme, (s, eventName,
+              [eventData]) {
+              s.triggerEvent(eventName, eventData);
+            })
+          : null);
+}
+
+BarChartGroupData parseBarChartGroupData(
+    Control group, bool interactiveChart, BuildContext context) {
+  group.notifyParent = true;
+  return BarChartGroupData(
+    x: group.getInt("x", 0)!,
+    barsSpace: group.getDouble("spacing"),
+    groupVertically: group.getBool("group_vertically", false)!,
+    showingTooltipIndicators: group
+        .children("rods")
+        .asMap()
+        .entries
+        .where(
+            (rod) => !interactiveChart && rod.value.getBool("selected", false)!)
+        .map((rod) => rod.key)
+        .toList(),
+    barRods: group
+        .children("rods")
+        .map((rod) => parseBarChartRodData(rod, interactiveChart, context))
+        .toList(),
+  );
+}
+
+BarChartRodData parseBarChartRodData(
+    Control rod, bool interactiveChart, BuildContext context) {
+  rod.notifyParent = true;
+
+  final theme = Theme.of(context);
+  var bgFromY = rod.getDouble("bg_from_y");
+  var bgToY = rod.getDouble("bg_to_y");
+  var bgcolor = rod.getColor("bgcolor", context);
+  var backgroundGradient = rod.getGradient("background_gradient", theme);
+
+  return BarChartRodData(
+      fromY: rod.getDouble("from_y"),
+      toY: rod.getDouble("to_y", 0)!,
+      width: rod.getDouble("width"),
+      color: rod.getColor("color", context),
+      gradient: rod.getGradient("gradient", theme),
+      borderRadius: rod.getBorderRadius("border_radius"),
+      borderSide: rod.getBorderSide("border_side", theme,
+          defaultValue: BorderSide.none),
+      backDrawRodData: BackgroundBarChartRodData(
+          show: (bgFromY != null ||
+              bgToY != null ||
+              bgcolor != null ||
+              backgroundGradient != null),
+          fromY: bgFromY,
+          toY: bgToY,
+          color: bgcolor,
+          gradient: backgroundGradient),
+      rodStackItems: rod
+          .children("stack_items")
+          .map((rodStackItem) => parseBarChartRodStackItem(
+              rodStackItem, interactiveChart, context))
+          .toList());
+}
+
+BarChartRodStackItem parseBarChartRodStackItem(
+  Control rodStackItem,
+  bool interactiveChart,
+  BuildContext context,
+) {
+  rodStackItem.notifyParent = true;
+  return BarChartRodStackItem(
+      rodStackItem.getDouble("from_y")!,
+      rodStackItem.getDouble("to_y", 0)!,
+      rodStackItem.getColor("color", context)!,
+      rodStackItem.getBorderSide("border_side", Theme.of(context),
+          defaultValue: BorderSide.none)!);
+}

flutter/flet_charts/lib/src/utils/charts.dart

@@ -0,0 +1,173 @@
+import 'package:collection/collection.dart';
+import 'package:fl_chart/fl_chart.dart';
+import 'package:flet/flet.dart';
+import 'package:flutter/material.dart';
+
+FlDotPainter invisibleDotPainter =
+    FlDotCirclePainter(radius: 0, strokeWidth: 0);
+FlLine invisibleLine = const FlLine(strokeWidth: 0);
+
+FlGridData parseChartGridData(
+    dynamic horizontal, dynamic vertical, ThemeData theme) {
+  if (horizontal == null && vertical == null) {
+    return const FlGridData(show: false);
+  }
+
+  var hLine = parseFlLine(horizontal, theme);
+  var vLine = parseFlLine(vertical, theme);
+
+  return FlGridData(
+    show: true,
+    drawHorizontalLine: horizontal != null,
+    horizontalInterval:
+        horizontal != null ? parseDouble(horizontal["interval"]) : null,
+    getDrawingHorizontalLine:
+        hLine == null ? defaultGridLine : (value) => hLine,
+    drawVerticalLine: vertical != null,
+    verticalInterval:
+        vertical != null ? parseDouble(vertical["interval"]) : null,
+    getDrawingVerticalLine: vLine == null ? defaultGridLine : (value) => vLine,
+  );
+}
+
+FlLine? parseFlLine(dynamic value, ThemeData theme, [FlLine? defaultValue]) {
+  if (value == null ||
+      (value['color'] == null &&
+          value['width'] == null &&
+          value['dash_pattern'] == null)) {
+    return defaultValue;
+  }
+
+  return FlLine(
+      color: parseColor(value['color'], theme, Colors.black)!,
+      strokeWidth: parseDouble(value['width'], 2)!,
+      dashArray: (value['dash_pattern'] as List?)
+          ?.map((e) => parseInt(e))
+          .nonNulls
+          .toList());
+}
+
+FlLine? parseSelectedFlLine(
+    dynamic value, ThemeData theme, Color? color, Gradient? gradient,
+    [FlLine? defaultValue]) {
+  if (value == null) return defaultValue;
+
+  if (value == false) {
+    return invisibleLine;
+  } else if (value == true) {
+    return FlLine(
+        color: getDefaultPointColor(0, color, gradient), strokeWidth: 3);
+  }
+
+  return parseFlLine(value, theme, defaultValue)?.copyWith(
+      color: parseColor(
+          value['color'], theme, defaultGetDotStrokeColor(0, color, gradient)));
+}
+
+FlDotPainter? parseChartDotPainter(dynamic value, ThemeData theme,
+    double percentage, Color? barColor, Gradient? barGradient,
+    {FlDotPainter? defaultValue, bool selected = false}) {
+  if (value == null) {
+    return defaultValue;
+  } else if (value == false) {
+    return invisibleDotPainter;
+  } else if (value == true) {
+    return getDefaultDotPainter(percentage, barColor, barGradient,
+        selected: selected);
+  }
+  var type = value["_type"];
+  var strokeWidth = parseDouble(value["stroke_width"]);
+  var size = parseDouble(value["size"]);
+  var color = parseColor(value['color'], theme);
+  var strokeColor = parseColor(value['stroke_color'], theme,
+      defaultGetDotStrokeColor(percentage, barColor, barGradient))!;
+
+  if (type == "ChartCirclePoint") {
+    return FlDotCirclePainter(
+        color: color ?? getDefaultPointColor(percentage, barColor, barGradient),
+        radius: parseDouble(value["radius"]),
+        strokeColor: strokeColor,
+        strokeWidth: strokeWidth ?? 0.0);
+  } else if (type == "ChartSquarePoint") {
+    return FlDotSquarePainter(
+        color: color ?? getDefaultPointColor(percentage, barColor, barGradient),
+        size: size ?? 4.0,
+        strokeColor: strokeColor,
+        strokeWidth: strokeWidth ?? 1.0);
+  } else if (type == "ChartCrossPoint") {
+    return FlDotCrossPainter(
+      color:
+          color ?? defaultGetDotStrokeColor(percentage, barColor, barGradient),
+      size: size ?? 8.0,
+      width: parseDouble(value["width"], 2.0)!,
+    );
+  }
+  return defaultValue;
+}
+
+FlDotPainter getDefaultDotPainter(
+    double percentage, Color? barColor, Gradient? barGradient,
+    {bool selected = false}) {
+  return FlDotCirclePainter(
+    radius: selected ? 8 : 4,
+    strokeWidth: selected ? 2 : 1,
+    color: getDefaultPointColor(percentage, barColor, barGradient),
+    strokeColor: defaultGetDotStrokeColor(percentage, barColor, barGradient),
+  );
+}
+
+Color getDefaultPointColor(
+    double percentage, Color? barColor, Gradient? barGradient) {
+  if (barGradient != null && barGradient is LinearGradient) {
+    return lerpGradient(
+        barGradient.colors, barGradient.getSafeColorStops(), percentage / 100);
+  }
+  return barGradient?.colors.first ?? barColor ?? Colors.blueGrey;
+}
+
+Color defaultGetDotStrokeColor(double percentage,
+    [Color? barColor, Gradient? barGradient]) {
+  Color color = getDefaultPointColor(percentage, barColor, barGradient);
+  return color.darken();
+}
+
+AxisTitles parseAxisTitles(Control? control) {
+  if (control == null) {
+    return const AxisTitles(sideTitles: SideTitles(showTitles: false));
+  }
+
+  return AxisTitles(
+      axisNameWidget: control.buildWidget("title"),
+      axisNameSize: control.getDouble("title_size", 16)!,
+      sideTitles: SideTitles(
+        showTitles: control.getBool("show_labels", true)!,
+        reservedSize: control.getDouble("label_size", 22)!,
+        interval: control.getDouble("label_spacing"),
+        getTitlesWidget: control.children("labels").isEmpty
+            ? defaultGetTitle
+            : (double value, TitleMeta meta) {
+                var label = control
+                    .children("labels")
+                    .firstWhereOrNull((l) => l.getDouble("value") == value);
+                return label?.buildTextOrWidget("label") ??
+                    const SizedBox.shrink();
+              },
+      ));
+}
+
+const eventMap = {
+  "FlPointerEnterEvent": "pointerEnter",
+  "FlPointerExitEvent": "pointerExit",
+  "FlPointerHoverEvent": "pointerHover",
+  "FlPanCancelEvent": "panCancel",
+  "FlPanDownEvent": "panDown",
+  "FlPanEndEvent": "panEnd",
+  "FlPanStartEvent": "panStart",
+  "FlPanUpdateEvent": "panUpdate",
+  "FlLongPressEnd": "longPressEnd",
+  "FlLongPressMoveUpdate": "longPressMoveUpdate",
+  "FlLongPressStart": "longPressStart",
+  "FlTapCancelEvent": "tapCancel",
+  "FlTapDownEvent": "tapDown",
+  "FlTapUpEvent": "tapUp",
+};

flutter/flet_charts/lib/src/utils/line_chart.dart

@@ -0,0 +1,208 @@
+import 'package:equatable/equatable.dart';
+import 'package:fl_chart/fl_chart.dart';
+import 'package:flet/flet.dart';
+import 'package:flutter/material.dart';
+
+import 'charts.dart';
+
+class LineChartEventData extends Equatable {
+  final String eventType;
+  final List<LineChartEventDataSpot> barSpots;
+
+  const LineChartEventData({required this.eventType, required this.barSpots});
+
+  factory LineChartEventData.fromDetails(
+      FlTouchEvent event, LineTouchResponse? response) {
+    return LineChartEventData(
+        eventType: eventMap[event.runtimeType.toString()] ?? "undefined",
+        barSpots: response != null && response.lineBarSpots != null
+            ? response.lineBarSpots!
+                .map((bs) => LineChartEventDataSpot(
+                    barIndex: bs.barIndex, spotIndex: bs.spotIndex))
+                .toList()
+            : []);
+  }
+
+  Map<String, dynamic> toMap() => <String, dynamic>{
+        'type': eventType,
+        'spots': barSpots,
+      };
+
+  @override
+  List<Object?> get props => [eventType, barSpots];
+}
+
+class LineChartEventDataSpot extends Equatable {
+  final int barIndex;
+  final int spotIndex;
+
+  const LineChartEventDataSpot(
+      {required this.barIndex, required this.spotIndex});
+
+  Map<String, dynamic> toMap() => <String, dynamic>{
+        'bar_index': barIndex,
+        'spot_index': spotIndex,
+      };
+
+  @override
+  List<Object?> get props => [barIndex, spotIndex];
+}
+
+LineTooltipItem? parseLineTooltipItem(
+    Control dataPoint, LineBarSpot spot, BuildContext context) {
+  if (!dataPoint.getBool("show_tooltip", true)!) return null;
+
+  final theme = Theme.of(context);
+
+  var tooltip = dataPoint.get("tooltip");
+  var style = parseTextStyle(tooltip["text_style"], theme, const TextStyle())!;
+  if (style.color == null) {
+    style = style.copyWith(
+        color: spot.bar.gradient?.colors.first ??
+            spot.bar.color ??
+            Colors.blueGrey);
+  }
+  return LineTooltipItem(
+      tooltip["text"] ?? dataPoint.getDouble("y", 0)!.toString(), style,
+      textAlign: parseTextAlign(tooltip["text_align"], TextAlign.center)!,
+      children: tooltip["text_spans"] != null
+          ? parseTextSpans(tooltip["text_spans"], theme, (s, eventName,
+              [eventData]) {
+              s.triggerEvent(eventName, eventData);
+            })
+          : null);
+}
+
+LineTouchTooltipData? parseLineTouchTooltipData(
+    BuildContext context, Control control,
+    [LineTouchTooltipData? defaultValue]) {
+  final tooltip = control.get("tooltip");
+  if (tooltip == null) return defaultValue;
+
+  final theme = Theme.of(context);
+
+  return LineTouchTooltipData(
+    getTooltipColor: (LineBarSpot spot) => parseColor(
+        tooltip["bgcolor"], theme, const Color.fromRGBO(96, 125, 139, 1))!,
+    tooltipBorderRadius: parseBorderRadius(tooltip["border_radius"]),
+    tooltipMargin: parseDouble(tooltip["margin"], 16)!,
+    tooltipPadding: parsePadding(tooltip["padding"],
+        const EdgeInsets.symmetric(horizontal: 16, vertical: 8))!,
+    maxContentWidth: parseDouble(tooltip["max_width"], 120)!,
+    rotateAngle: parseDouble(tooltip["rotate_angle"], 0.0)!,
+    tooltipHorizontalOffset: parseDouble(tooltip["horizontal_offset"], 0)!,
+    tooltipBorder: parseBorderSide(tooltip["border_side"], theme,
+        defaultValue: BorderSide.none)!,
+    fitInsideHorizontally:
+        parseBool(tooltip["fit_inside_horizontally"], false)!,
+    fitInsideVertically: parseBool(tooltip["fit_inside_vertically"], false)!,
+    showOnTopOfTheChartBoxArea:
+        parseBool(tooltip["show_on_top_of_chart_box_area"], false)!,
+    getTooltipItems: (List<LineBarSpot> touchedSpots) {
+      return touchedSpots
+          .map((LineBarSpot spot) => parseLineTooltipItem(
+              control
+                  .children("data_series")[spot.barIndex]
+                  .children("points")[spot.spotIndex],
+              spot,
+              context))
+          .nonNulls
+          .toList();
+    },
+  );
+}
+
+LineChartBarData parseLineChartBarData(
+    Control parent,
+    Control chartData,
+    bool interactiveChart,
+    BuildContext context,
+    Map<int, List<FlSpot>> barSpots) {
+  final theme = Theme.of(context);
+
+  var aboveLineBgcolor = chartData.getColor("above_line_bgcolor", context);
+  var aboveLineGradient = chartData.getGradient("above_line_gradient", theme);
+  var belowLineBgcolor = chartData.getColor("below_line_bgcolor", context);
+  var belowLineGradient = chartData.getGradient("below_line_gradient", theme);
+  var dashPattern = chartData.get("dash_pattern");
+  var barColor = chartData.getColor("color", context, Colors.cyan)!;
+  var barGradient = chartData.getGradient("gradient", theme);
+  var aboveLine = parseFlLine(chartData.get("above_line"), Theme.of(context));
+  var belowLine = parseFlLine(chartData.get("below_line"), Theme.of(context));
+  var aboveLineCutoffY = chartData.getDouble("above_line_cutoff_y");
+  var belowLineCutoffY = chartData.getDouble("below_line_cutoff_y");
+
+  Map<FlSpot, Control> spots = {
+    for (var e in chartData.children("points"))
+      FlSpot(e.getDouble("x", 0)!, e.getDouble("y", 0)!): e
+  };
+  return LineChartBarData(
+      preventCurveOverShooting:
+          chartData.getBool("prevent_curve_over_shooting", false)!,
+      preventCurveOvershootingThreshold:
+          chartData.getDouble("prevent_curve_over_shooting_threshold", 10.0)!,
+      spots: barSpots[chartData.id] ?? [],
+      showingIndicators: chartData
+          .children("points")
+          .asMap()
+          .entries
+          .where(
+              (dp) => !interactiveChart && dp.value.getBool("selected", false)!)
+          .map((e) => e.key)
+          .toList(),
+      isCurved: chartData.getBool("curved", false)!,
+      isStrokeCapRound: chartData.getBool("rounded_stroke_cap", false)!,
+      barWidth: chartData.getDouble("stroke_width", 2.0)!,
+      dashArray: dashPattern != null
+          ? (dashPattern as List).map((e) => parseInt(e)).nonNulls.toList()
+          : null,
+      shadow: parseBoxShadow(chartData.get("shadow"), Theme.of(context)) ??
+          const Shadow(color: Colors.transparent),
+      dotData: FlDotData(
+          show: true,
+          getDotPainter: (spot, percent, barData, index) {
+            var allDotsPainter = parseChartDotPainter(
+                chartData.get("point"), theme, percent, barColor, barGradient);
+            var dotPainter = parseChartDotPainter(
+                chartData.children("points")[index].get("point"),
+                theme,
+                percent,
+                barColor,
+                barGradient);
+            return dotPainter ?? allDotsPainter ?? invisibleDotPainter;
+          }),
+      aboveBarData: aboveLineBgcolor != null ||
+              aboveLineGradient != null ||
+              aboveLine != null
+          ? BarAreaData(
+              show: true,
+              color: aboveLineBgcolor,
+              gradient: aboveLineGradient,
+              applyCutOffY: aboveLineCutoffY != null,
+              cutOffY: aboveLineCutoffY ?? 0,
+              spotsLine: BarAreaSpotsLine(
+                show: aboveLine != null,
+                flLineStyle: aboveLine ?? const FlLine(),
+                checkToShowSpotLine: (spot) =>
+                    spots[spot]!.getBool("show_above_line", true)!,
+              ))
+          : null,
+      belowBarData: belowLineBgcolor != null ||
+              belowLineGradient != null ||
+              belowLine != null
+          ? BarAreaData(
+              show: true,
+              color: belowLineBgcolor,
+              gradient: belowLineGradient,
+              applyCutOffY: belowLineCutoffY != null,
+              cutOffY: belowLineCutoffY ?? 0,
+              spotsLine: BarAreaSpotsLine(
+                show: belowLine != null,
+                flLineStyle: belowLine ?? const FlLine(),
+                checkToShowSpotLine: (spot) =>
+                    spots[spot]!.getBool("show_below_line", true)!,
+              ))
+          : null,
+      color: barColor,
+      gradient: barGradient);
+}