library;

import 'dart:math' as math;

import 'package:flutter/rendering.dart';

import 'package:flutter/widgets.dart';

import 'checkbox.dart';

import 'constants.dart';

import 'data_table_theme.dart';

import 'debug.dart';

import 'divider.dart';

import 'dropdown.dart';

import 'icons.dart';

import 'ink_well.dart';

import 'material.dart';

import 'theme.dart';

import 'tooltip.dart';

typedef DataColumnSortCallback = void Function(int columnIndex, bool ascending);

class DataColumn {

/// Creates the configuration for a column of a [DataTable].

const DataColumn({

required this.label,

this.columnWidth,

this.tooltip,

this.numeric = false,

this.onSort,

this.mouseCursor,

this.headingRowAlignment,

});

/// The column heading.

final Widget label;

/// How the horizontal extents of this column of the table should be determined.

final TableColumnWidth? columnWidth;

/// The column heading's tooltip.

final String? tooltip;

/// Whether this column represents numeric data or not.

final bool numeric;

/// Called when the user asks to sort the table using this column.

final DataColumnSortCallback? onSort;

bool get _debugInteractive => onSort != null;

/// The cursor for a mouse pointer when it enters or is hovering over the

final WidgetStateProperty<MouseCursor?>? mouseCursor;

/// Defines the horizontal layout of the [label] and sort indicator in the

final MainAxisAlignment? headingRowAlignment;

}

class DataRow {

/// Creates the configuration for a row of a [DataTable].

const DataRow({

this.key,

this.selected = false,

this.onSelectChanged,

this.onLongPress,

this.onHover,

this.color,

this.mouseCursor,

required this.cells,

});

/// Creates the configuration for a row of a [DataTable], deriving

DataRow.byIndex({

int? index,

this.selected = false,

this.onSelectChanged,

this.onLongPress,

this.onHover,

this.color,

this.mouseCursor,

required this.cells,

}) : key = ValueKey<int?>(index);

/// A [Key] that uniquely identifies this row. This is used to

final LocalKey? key;

/// Called when the user selects or unselects a selectable row.

final ValueChanged<bool?>? onSelectChanged;

/// Called if the row is long-pressed.

final GestureLongPressCallback? onLongPress;

/// Called when a pointer enters or exits the row.

final ValueChanged<bool>? onHover;

/// Whether the row is selected.

final bool selected;

/// The data for this row.

final List<DataCell> cells;

/// The color for the row.

final WidgetStateProperty<Color?>? color;

/// The cursor for a mouse pointer when it enters or is hovering over the

final WidgetStateProperty<MouseCursor?>? mouseCursor;

bool get _debugInteractive =>

onSelectChanged != null || cells.any((DataCell cell) => cell._debugInteractive);

}

class DataCell {

/// Creates an object to hold the data for a cell in a [DataTable].

const DataCell(

this.child, {

this.placeholder = false,

this.showEditIcon = false,

this.onTap,

this.onLongPress,

this.onTapDown,

this.onDoubleTap,

this.onTapCancel,

});

/// A cell that has no content and has zero width and height.

static const DataCell empty = DataCell(SizedBox.shrink());

/// The data for the row.

final Widget child;

/// Whether the [child] is actually a placeholder.

final bool placeholder;

/// Whether to show an edit icon at the end of the cell.

final bool showEditIcon;

/// Called if the cell is tapped.

final GestureTapCallback? onTap;

/// Called when the cell is double tapped.

final GestureTapCallback? onDoubleTap;

/// Called if the cell is long-pressed.

final GestureLongPressCallback? onLongPress;

/// Called if the cell is tapped down.

final GestureTapDownCallback? onTapDown;

/// Called if the user cancels a tap was started on cell.

final GestureTapCancelCallback? onTapCancel;

bool get _debugInteractive =>

onTap != null ||

onDoubleTap != null ||

onLongPress != null ||

onTapDown != null ||

onTapCancel != null;

}

class DataTable extends StatelessWidget {

/// Creates a widget describing a data table.

DataTable({

super.key,

required this.columns,

this.sortColumnIndex,

this.sortAscending = true,

this.onSelectAll,

this.decoration,

this.dataRowColor,

@Deprecated(

'Migrate to use dataRowMinHeight and dataRowMaxHeight instead. '

'This feature was deprecated after v3.7.0-5.0.pre.',

)

double? dataRowHeight,

double? dataRowMinHeight,

double? dataRowMaxHeight,

this.dataTextStyle,

this.headingRowColor,

this.headingRowHeight,

this.headingTextStyle,

this.horizontalMargin,

this.columnSpacing,

this.showCheckboxColumn = true,

this.showBottomBorder = false,

this.dividerThickness,

required this.rows,

this.checkboxHorizontalMargin,

this.border,

this.clipBehavior = Clip.none,

}) : assert(columns.isNotEmpty),

assert(

sortColumnIndex == null || (sortColumnIndex >= 0 && sortColumnIndex < columns.length),

),

assert(

!rows.any((DataRow row) => row.cells.length != columns.length),

'All rows must have the same number of cells as there are header cells (${columns.length})',

),

assert(dividerThickness == null || dividerThickness >= 0),

assert(

dataRowMinHeight == null ||

dataRowMaxHeight == null ||

dataRowMaxHeight >= dataRowMinHeight,

),

assert(

dataRowHeight == null || (dataRowMinHeight == null && dataRowMaxHeight == null),

'dataRowHeight ($dataRowHeight) must not be set if dataRowMinHeight ($dataRowMinHeight) or dataRowMaxHeight ($dataRowMaxHeight) are set.',

),

dataRowMinHeight = dataRowHeight ?? dataRowMinHeight,

dataRowMaxHeight = dataRowHeight ?? dataRowMaxHeight,

_onlyTextColumn = _initOnlyTextColumn(columns);

/// The configuration and labels for the columns in the table.

final List<DataColumn> columns;

/// The current primary sort key's column.

final int? sortColumnIndex;

/// Whether the column mentioned in [sortColumnIndex], if any, is sorted

final bool sortAscending;

/// Invoked when the user selects or unselects every row, using the

final ValueSetter<bool?>? onSelectAll;

/// {@template flutter.material.dataTable.decoration}

final Decoration? decoration;

/// {@template flutter.material.dataTable.dataRowColor}

final WidgetStateProperty<Color?>? dataRowColor;

/// {@template flutter.material.dataTable.dataRowHeight}

@Deprecated(

'Migrate to use dataRowMinHeight and dataRowMaxHeight instead. '

'This feature was deprecated after v3.7.0-5.0.pre.',

)

double? get dataRowHeight => dataRowMinHeight == dataRowMaxHeight ? dataRowMinHeight : null;

/// {@template flutter.material.dataTable.dataRowMinHeight}

final double? dataRowMinHeight;

/// {@template flutter.material.dataTable.dataRowMaxHeight}

final double? dataRowMaxHeight;

/// {@template flutter.material.dataTable.dataTextStyle}

final TextStyle? dataTextStyle;

/// {@template flutter.material.dataTable.headingRowColor}

final WidgetStateProperty<Color?>? headingRowColor;

/// {@template flutter.material.dataTable.headingRowHeight}

final double? headingRowHeight;

/// {@template flutter.material.dataTable.headingTextStyle}

final TextStyle? headingTextStyle;

/// {@template flutter.material.dataTable.horizontalMargin}

final double? horizontalMargin;

/// {@template flutter.material.dataTable.columnSpacing}

final double? columnSpacing;

/// {@template flutter.material.dataTable.showCheckboxColumn}

final bool showCheckboxColumn;

/// The data to show in each row (excluding the row that contains

final List<DataRow> rows;

/// {@template flutter.material.dataTable.dividerThickness}

final double? dividerThickness;

/// Whether a border at the bottom of the table is displayed.

final bool showBottomBorder;

/// {@template flutter.material.dataTable.checkboxHorizontalMargin}

final double? checkboxHorizontalMargin;

/// The style to use when painting the boundary and interior divisions of the table.

final TableBorder? border;

/// {@macro flutter.material.Material.clipBehavior}

final Clip clipBehavior;

// Set by the constructor to the index of the only Column that is

// non-numeric, if there is exactly one, otherwise null.

final int? _onlyTextColumn;

static int? _initOnlyTextColumn(List<DataColumn> columns) {

int? result;

for (var index = 0; index < columns.length; index += 1) {

final DataColumn column = columns[index];

if (!column.numeric) {

if (result != null) {

return null;

}

result = index;

}

}

return result;

}

bool get _debugInteractive {

return columns.any((DataColumn column) => column._debugInteractive) ||

rows.any((DataRow row) => row._debugInteractive);

}

static final LocalKey _headingRowKey = UniqueKey();

void _handleSelectAll(bool? checked, bool someChecked) {

// If some checkboxes are checked, all checkboxes are selected. Otherwise,

// use the new checked value but default to false if it's null.

final bool effectiveChecked = someChecked || (checked ?? false);

if (onSelectAll != null) {

onSelectAll!(effectiveChecked);

} else {

for (final DataRow row in rows) {

if (row.onSelectChanged != null && row.selected != effectiveChecked) {

row.onSelectChanged!(effectiveChecked);

}

}

}

}

/// The default height of the heading row.

static const double _headingRowHeight = 56.0;

/// The default horizontal margin between the edges of the table and the content

static const double _horizontalMargin = 24.0;

/// The default horizontal margin between the contents of each data column.

static const double _columnSpacing = 56.0;

/// The default padding between the heading content and sort arrow.

static const double _sortArrowPadding = 2.0;

/// The default divider thickness.

static const double _dividerThickness = 1.0;

static const Duration _sortArrowAnimationDuration = Duration(milliseconds: 150);

Widget _buildCheckbox({

required BuildContext context,

required bool? checked,

required VoidCallback? onRowTap,

required ValueChanged<bool?>? onCheckboxChanged,

required WidgetStateProperty<Color?>? overlayColor,

required bool tristate,

MouseCursor? rowMouseCursor,

}) {

final ThemeData themeData = Theme.of(context);

final double effectiveHorizontalMargin =

horizontalMargin ?? themeData.dataTableTheme.horizontalMargin ?? _horizontalMargin;

final double effectiveCheckboxHorizontalMarginStart =

checkboxHorizontalMargin ??

themeData.dataTableTheme.checkboxHorizontalMargin ??

effectiveHorizontalMargin;

final double effectiveCheckboxHorizontalMarginEnd =

checkboxHorizontalMargin ??

themeData.dataTableTheme.checkboxHorizontalMargin ??

effectiveHorizontalMargin / 2.0;

Widget contents = Semantics(

container: true,

child: Padding(

padding: EdgeInsetsDirectional.only(

start: effectiveCheckboxHorizontalMarginStart,

end: effectiveCheckboxHorizontalMarginEnd,

),

child: Center(

child: Checkbox(value: checked, onChanged: onCheckboxChanged, tristate: tristate),

),

),

);

if (onRowTap != null) {

contents = TableRowInkWell(

onTap: onRowTap,

overlayColor: overlayColor,

mouseCursor: rowMouseCursor,

child: contents,

);

}

return TableCell(verticalAlignment: TableCellVerticalAlignment.fill, child: contents);

}

Widget _buildHeadingCell({

required BuildContext context,

required EdgeInsetsGeometry padding,

required Widget label,

required String? tooltip,

required bool numeric,

required VoidCallback? onSort,

required bool sorted,

required bool ascending,

required WidgetStateProperty<Color?>? overlayColor,

required MouseCursor? mouseCursor,

required MainAxisAlignment headingRowAlignment,

}) {

final ThemeData themeData = Theme.of(context);

final DataTableThemeData dataTableTheme = DataTableTheme.of(context);

label = Semantics(

role: SemanticsRole.columnHeader,

child: Row(

textDirection: numeric ? TextDirection.rtl : null,

mainAxisAlignment: headingRowAlignment,

children: <Widget>[

if (headingRowAlignment == MainAxisAlignment.center && onSort != null)

const SizedBox(width: _SortArrowState._arrowIconSize + _sortArrowPadding),

label,

if (onSort != null) ...<Widget>[

_SortArrow(

visible: sorted,

up: sorted ? ascending : null,

duration: _sortArrowAnimationDuration,

),

const SizedBox(width: _sortArrowPadding),

],

],

),

);

final TextStyle effectiveHeadingTextStyle =

headingTextStyle ??

dataTableTheme.headingTextStyle ??

themeData.dataTableTheme.headingTextStyle ??

themeData.textTheme.titleSmall!;

final double effectiveHeadingRowHeight =

headingRowHeight ??

dataTableTheme.headingRowHeight ??

themeData.dataTableTheme.headingRowHeight ??

_headingRowHeight;

label = Container(

padding: padding,

height: effectiveHeadingRowHeight,

alignment: numeric ? Alignment.centerRight : AlignmentDirectional.centerStart,

child: AnimatedDefaultTextStyle(

style: DefaultTextStyle.of(context).style.merge(effectiveHeadingTextStyle),

softWrap: false,

duration: _sortArrowAnimationDuration,

child: label,

),

);

if (tooltip != null) {

label = Tooltip(message: tooltip, child: label);

}

label = InkWell(

onTap: onSort,

overlayColor: overlayColor,

mouseCursor: mouseCursor,

child: label,

);

return label;

}

Widget _buildDataCell({

required BuildContext context,

required EdgeInsetsGeometry padding,

required Widget label,

required bool numeric,

required bool placeholder,

required bool showEditIcon,

required GestureTapCallback? onTap,

required VoidCallback? onSelectChanged,

required GestureTapCallback? onDoubleTap,

required GestureLongPressCallback? onLongPress,

required GestureTapDownCallback? onTapDown,

required GestureTapCancelCallback? onTapCancel,

required WidgetStateProperty<Color?>? overlayColor,

required GestureLongPressCallback? onRowLongPress,

required ValueChanged<bool>? onRowHover,

required MouseCursor? mouseCursor,

}) {

final ThemeData themeData = Theme.of(context);

final DataTableThemeData dataTableTheme = DataTableTheme.of(context);

if (showEditIcon) {

const Widget icon = Icon(Icons.edit, size: 18.0);

label = Expanded(child: label);

label = Row(

textDirection: numeric ? TextDirection.rtl : null,

children: <Widget>[label, icon],

);

}

final TextStyle effectiveDataTextStyle =

dataTextStyle ??

dataTableTheme.dataTextStyle ??

themeData.dataTableTheme.dataTextStyle ??

themeData.textTheme.bodyMedium!;

final double effectiveDataRowMinHeight =

dataRowMinHeight ??

dataTableTheme.dataRowMinHeight ??

themeData.dataTableTheme.dataRowMinHeight ??

kMinInteractiveDimension;

final double effectiveDataRowMaxHeight =

dataRowMaxHeight ??

dataTableTheme.dataRowMaxHeight ??

themeData.dataTableTheme.dataRowMaxHeight ??

kMinInteractiveDimension;

label = Container(

padding: padding,

constraints: BoxConstraints(

minHeight: effectiveDataRowMinHeight,

maxHeight: effectiveDataRowMaxHeight,

),

alignment: numeric ? Alignment.centerRight : AlignmentDirectional.centerStart,

child: DefaultTextStyle(