rebuildHeaderRows method

Implementation

void rebuildHeaderRows(
  List<HeaderRow> headerRows, {
  double? parentMaxWidth,
  bool scaleColumnsToFit = false,
}) {
  _sourceHeaderRows = headerRows;
  final oldRows = List<hr.HeaderRow>.from(buildedHeaderRows);
  final previousLeafSourceOrder =
      oldRows.isEmpty ? null : oldRows.last.columns.map((column) => column.sourceColumnIndex).toList();
  final shouldRestoreLeafOrder = previousLeafSourceOrder != null &&
      !const ListEquality<int>().equals(
        previousLeafSourceOrder,
        List<int>.generate(previousLeafSourceOrder.length, (index) => index),
      );
  final sourceGroupIndexesByLeaf = _sourceGroupIndexesByLeaf(headerRows);
  final newRows = <hr.HeaderRow>[];
  var restoredLeafOrder = false;

  for (int rowIndex = 0; rowIndex < headerRows.length; rowIndex++) {
    final oldRow = rowIndex < oldRows.length ? oldRows[rowIndex] : null;
    final isLeafRow = rowIndex == headerRows.length - 1;
    final widthOverrides = <int, double>{};
    if (scaleColumnsToFit && isLeafRow && oldRow != null) {
      for (final column in oldRow.columns) {
        if (_userResizedColumns.contains(column.sourceColumnIndex)) {
          widthOverrides[column.sourceColumnIndex] = column.width.value!;
        }
      }
    }
    final builtRow = buildHeaderColumns(
      headerRows,
      rowIndex,
      parentMaxWidth: parentMaxWidth,
      widthOverrides: widthOverrides,
    );
    final columns = <hc.HeaderColumn>[];
    final builtColumns =
        isLeafRow ? _restorePreviousLeafOrder(builtRow.columns, previousLeafSourceOrder) : builtRow.columns;
    restoredLeafOrder = restoredLeafOrder || !identical(builtColumns, builtRow.columns);
    final reuseOldColumns = isLeafRow || !shouldRestoreLeafOrder;
    final oldLeafColumnsBySource = isLeafRow && oldRow != null
        ? <int, hc.HeaderColumn>{
            for (final column in oldRow.columns) column.sourceColumnIndex: column,
          }
        : null;

    for (int columnIndex = 0; columnIndex < builtColumns.length; columnIndex++) {
      final builtColumn = builtColumns[columnIndex];
      final oldColumn = oldLeafColumnsBySource?[builtColumn.sourceColumnIndex] ??
          (reuseOldColumns && oldRow != null && columnIndex < oldRow.columns.length
              ? oldRow.columns[columnIndex]
              : null);

      if (oldColumn != null) {
        if (scaleColumnsToFit && isLeafRow && !_userResizedColumns.contains(builtColumn.sourceColumnIndex)) {
          oldColumn.width.value = builtColumn.width.value;
        }
        final sourceGroupColumnIndexes = isLeafRow ? List<int?>.from(oldColumn.sourceGroupColumnIndexes) : null;
        oldColumn.updateConfigurationFrom(builtColumn);
        if (sourceGroupColumnIndexes != null && sourceGroupColumnIndexes.isNotEmpty) {
          oldColumn.sourceGroupColumnIndexes = sourceGroupColumnIndexes;
        }
        _disposeHeaderColumns([builtColumn]);
        columns.add(oldColumn);
      } else {
        columns.add(builtColumn);
      }
    }

    newRows.add(hr.HeaderRow(columns: columns));
  }

  _disposeRemovedHeaderRows(oldRows, newRows);

  buildedHeaderRows
    ..clear()
    ..addAll(newRows);
  _assignHeaderGroupMetadata();
  if (restoredLeafOrder) {
    for (final leaf in buildedHeaderRows.last.columns) {
      leaf.sourceGroupColumnIndexes = List<int?>.from(sourceGroupIndexesByLeaf[leaf.sourceColumnIndex]);
    }
    _rebuildGroupedHeaderRowsFromLeafOrder();
  }
  _refreshHeaderWidgetsForDisplayOrder();
  _refreshFilterIndicators();
}