table.dart 43.7 KB
Newer Older
Hixie's avatar
Hixie committed
1 2 3 4 5 6 7
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import 'dart:collection';
import 'dart:math' as math;

8 9
import 'package:flutter/foundation.dart';

Hixie's avatar
Hixie committed
10 11
import 'box.dart';
import 'object.dart';
12
import 'table_border.dart';
Hixie's avatar
Hixie committed
13 14 15

/// Parent data used by [RenderTable] for its children.
class TableCellParentData extends BoxParentData {
16
  /// Where this cell should be placed vertically.
Hixie's avatar
Hixie committed
17 18
  TableCellVerticalAlignment verticalAlignment;

Hixie's avatar
Hixie committed
19 20 21 22 23 24
  /// The column that the child was in the last time it was laid out.
  int x;

  /// The row that the child was in the last time it was laid out.
  int y;

Hixie's avatar
Hixie committed
25
  @override
26
  String toString() => '${super.toString()}; ${verticalAlignment == null ? "default vertical alignment" : "$verticalAlignment"}';
Hixie's avatar
Hixie committed
27 28 29
}

/// Base class to describe how wide a column in a [RenderTable] should be.
30 31 32 33 34 35 36 37
///
/// To size a column to a specific number of pixels, use a [FixedColumnWidth].
/// This is the cheapest way to size a column.
///
/// Other algorithms that are relatively cheap include [FlexColumnWidth], which
/// distributes the space equally among the flexible columns,
/// [FractionColumnWidth], which sizes a column based on the size of the
/// table's container.
38
@immutable
Hixie's avatar
Hixie committed
39
abstract class TableColumnWidth {
40 41
  /// Abstract const constructor. This constructor enables subclasses to provide
  /// const constructors so that they can be used in const expressions.
Hixie's avatar
Hixie committed
42 43
  const TableColumnWidth();

44 45 46 47 48 49 50 51
  /// The smallest width that the column can have.
  ///
  /// The `cells` argument is an iterable that provides all the cells
  /// in the table for this column. Walking the cells is by definition
  /// O(N), so algorithms that do that should be considered expensive.
  ///
  /// The `containerWidth` argument is the `maxWidth` of the incoming
  /// constraints for the table, and might be infinite.
Hixie's avatar
Hixie committed
52 53
  double minIntrinsicWidth(Iterable<RenderBox> cells, double containerWidth);

54 55 56 57 58 59 60 61 62 63 64 65
  /// The ideal width that the column should have. This must be equal
  /// to or greater than the [minIntrinsicWidth]. The column might be
  /// bigger than this width, e.g. if the column is flexible or if the
  /// table's width ends up being forced to be bigger than the sum of
  /// all the maxIntrinsicWidth values.
  ///
  /// The `cells` argument is an iterable that provides all the cells
  /// in the table for this column. Walking the cells is by definition
  /// O(N), so algorithms that do that should be considered expensive.
  ///
  /// The `containerWidth` argument is the `maxWidth` of the incoming
  /// constraints for the table, and might be infinite.
Hixie's avatar
Hixie committed
66 67
  double maxIntrinsicWidth(Iterable<RenderBox> cells, double containerWidth);

68 69 70 71 72 73 74 75
  /// The flex factor to apply to the cell if there is any room left
  /// over when laying out the table. The remaining space is
  /// distributed to any columns with flex in proportion to their flex
  /// value (higher values get more space).
  ///
  /// The `cells` argument is an iterable that provides all the cells
  /// in the table for this column. Walking the cells is by definition
  /// O(N), so algorithms that do that should be considered expensive.
Hixie's avatar
Hixie committed
76 77 78 79 80 81 82 83 84 85
  double flex(Iterable<RenderBox> cells) => null;

  @override
  String toString() => '$runtimeType';
}

/// Sizes the column according to the intrinsic dimensions of all the
/// cells in that column.
///
/// This is a very expensive way to size a column.
86 87 88 89
///
/// A flex value can be provided. If specified (and non-null), the
/// column will participate in the distribution of remaining space
/// once all the non-flexible columns have been sized.
90
class IntrinsicColumnWidth extends TableColumnWidth {
91 92 93
  /// Creates a column width based on intrinsic sizing.
  ///
  /// This sizing algorithm is very expensive.
94
  const IntrinsicColumnWidth({ double flex }) : _flex = flex;
Hixie's avatar
Hixie committed
95 96 97 98 99

  @override
  double minIntrinsicWidth(Iterable<RenderBox> cells, double containerWidth) {
    double result = 0.0;
    for (RenderBox cell in cells)
100
      result = math.max(result, cell.getMinIntrinsicWidth(double.infinity));
Hixie's avatar
Hixie committed
101 102 103 104 105 106 107
    return result;
  }

  @override
  double maxIntrinsicWidth(Iterable<RenderBox> cells, double containerWidth) {
    double result = 0.0;
    for (RenderBox cell in cells)
108
      result = math.max(result, cell.getMaxIntrinsicWidth(double.infinity));
Hixie's avatar
Hixie committed
109 110
    return result;
  }
111 112 113 114 115

  final double _flex;

  @override
  double flex(Iterable<RenderBox> cells) => _flex;
116 117 118

  @override
  String toString() => '$runtimeType(flex: ${_flex?.toStringAsFixed(1)})';
Hixie's avatar
Hixie committed
119 120 121 122 123 124
}

/// Sizes the column to a specific number of pixels.
///
/// This is the cheapest way to size a column.
class FixedColumnWidth extends TableColumnWidth {
125 126 127
  /// Creates a column width based on a fixed number of logical pixels.
  ///
  /// The [value] argument must not be null.
128
  const FixedColumnWidth(this.value) : assert(value != null);
129 130

  /// The width the column should occupy in logical pixels.
Hixie's avatar
Hixie committed
131 132 133 134 135 136 137 138 139 140 141 142 143
  final double value;

  @override
  double minIntrinsicWidth(Iterable<RenderBox> cells, double containerWidth) {
    return value;
  }

  @override
  double maxIntrinsicWidth(Iterable<RenderBox> cells, double containerWidth) {
    return value;
  }

  @override
144
  String toString() => '$runtimeType(${debugFormatDouble(value)})';
Hixie's avatar
Hixie committed
145 146 147 148 149 150
}

/// Sizes the column to a fraction of the table's constraints' maxWidth.
///
/// This is a cheap way to size a column.
class FractionColumnWidth extends TableColumnWidth {
151 152 153 154
  /// Creates a column width based on a fraction of the table's constraints'
  /// maxWidth.
  ///
  /// The [value] argument must not be null.
155
  const FractionColumnWidth(this.value) : assert(value != null);
156 157 158

  /// The fraction of the table's constraints' maxWidth that this column should
  /// occupy.
Hixie's avatar
Hixie committed
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
  final double value;

  @override
  double minIntrinsicWidth(Iterable<RenderBox> cells, double containerWidth) {
    if (!containerWidth.isFinite)
      return 0.0;
    return value * containerWidth;
  }

  @override
  double maxIntrinsicWidth(Iterable<RenderBox> cells, double containerWidth) {
    if (!containerWidth.isFinite)
      return 0.0;
    return value * containerWidth;
  }

  @override
  String toString() => '$runtimeType($value)';
}

/// Sizes the column by taking a part of the remaining space once all
/// the other columns have been laid out.
///
182
/// For example, if two columns have a [FlexColumnWidth], then half the
Hixie's avatar
Hixie committed
183 184 185 186
/// space will go to one and half the space will go to the other.
///
/// This is a cheap way to size a column.
class FlexColumnWidth extends TableColumnWidth {
187 188 189 190
  /// Creates a column width based on a fraction of the remaining space once all
  /// the other columns have been laid out.
  ///
  /// The [value] argument must not be null.
191
  const FlexColumnWidth([this.value = 1.0]) : assert(value != null);
192 193 194

  /// The reaction of the of the remaining space once all the other columns have
  /// been laid out that this column should occupy.
Hixie's avatar
Hixie committed
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212
  final double value;

  @override
  double minIntrinsicWidth(Iterable<RenderBox> cells, double containerWidth) {
    return 0.0;
  }

  @override
  double maxIntrinsicWidth(Iterable<RenderBox> cells, double containerWidth) {
    return 0.0;
  }

  @override
  double flex(Iterable<RenderBox> cells) {
    return value;
  }

  @override
213
  String toString() => '$runtimeType(${debugFormatDouble(value)})';
Hixie's avatar
Hixie committed
214 215 216 217 218 219 220 221 222 223 224 225 226
}

/// Sizes the column such that it is the size that is the maximum of
/// two column width specifications.
///
/// For example, to have a column be 10% of the container width or
/// 100px, whichever is bigger, you could use:
///
///     const MaxColumnWidth(const FixedColumnWidth(100.0), FractionColumnWidth(0.1))
///
/// Both specifications are evaluated, so if either specification is
/// expensive, so is this.
class MaxColumnWidth extends TableColumnWidth {
227
  /// Creates a column width that is the maximum of two other column widths.
Hixie's avatar
Hixie committed
228
  const MaxColumnWidth(this.a, this.b);
229 230

  /// A lower bound for the width of this column.
Hixie's avatar
Hixie committed
231
  final TableColumnWidth a;
232 233

  /// Another lower bound for the width of this column.
Hixie's avatar
Hixie committed
234 235 236 237 238 239
  final TableColumnWidth b;

  @override
  double minIntrinsicWidth(Iterable<RenderBox> cells, double containerWidth) {
    return math.max(
      a.minIntrinsicWidth(cells, containerWidth),
240
      b.minIntrinsicWidth(cells, containerWidth),
Hixie's avatar
Hixie committed
241 242 243 244 245 246 247
    );
  }

  @override
  double maxIntrinsicWidth(Iterable<RenderBox> cells, double containerWidth) {
    return math.max(
      a.maxIntrinsicWidth(cells, containerWidth),
248
      b.maxIntrinsicWidth(cells, containerWidth),
Hixie's avatar
Hixie committed
249 250 251 252 253
    );
  }

  @override
  double flex(Iterable<RenderBox> cells) {
254
    final double aFlex = a.flex(cells);
Hixie's avatar
Hixie committed
255 256
    if (aFlex == null)
      return b.flex(cells);
257 258 259 260
    final double bFlex = b.flex(cells);
    if (bFlex == null)
      return null;
    return math.max(aFlex, bFlex);
Hixie's avatar
Hixie committed
261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277
  }

  @override
  String toString() => '$runtimeType($a, $b)';
}

/// Sizes the column such that it is the size that is the minimum of
/// two column width specifications.
///
/// For example, to have a column be 10% of the container width but
/// never bigger than 100px, you could use:
///
///     const MinColumnWidth(const FixedColumnWidth(100.0), FractionColumnWidth(0.1))
///
/// Both specifications are evaluated, so if either specification is
/// expensive, so is this.
class MinColumnWidth extends TableColumnWidth {
278 279 280 281
  /// Creates a column width that is the minimum of two other column widths.
  const MinColumnWidth(this.a, this.b);

  /// An upper bound for the width of this column.
Hixie's avatar
Hixie committed
282
  final TableColumnWidth a;
283 284

  /// Another upper bound for the width of this column.
Hixie's avatar
Hixie committed
285 286 287 288 289 290
  final TableColumnWidth b;

  @override
  double minIntrinsicWidth(Iterable<RenderBox> cells, double containerWidth) {
    return math.min(
      a.minIntrinsicWidth(cells, containerWidth),
291
      b.minIntrinsicWidth(cells, containerWidth),
Hixie's avatar
Hixie committed
292 293 294 295 296 297 298
    );
  }

  @override
  double maxIntrinsicWidth(Iterable<RenderBox> cells, double containerWidth) {
    return math.min(
      a.maxIntrinsicWidth(cells, containerWidth),
299
      b.maxIntrinsicWidth(cells, containerWidth),
Hixie's avatar
Hixie committed
300 301 302 303 304
    );
  }

  @override
  double flex(Iterable<RenderBox> cells) {
305
    final double aFlex = a.flex(cells);
Hixie's avatar
Hixie committed
306 307
    if (aFlex == null)
      return b.flex(cells);
308
    final double bFlex = b.flex(cells);
309 310 311
    if (bFlex == null)
      return null;
    return math.min(aFlex, bFlex);
Hixie's avatar
Hixie committed
312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333
  }

  @override
  String toString() => '$runtimeType($a, $b)';
}

/// Vertical alignment options for cells in [RenderTable] objects.
///
/// This is specified using [TableCellParentData] objects on the
/// [RenderObject.parentData] of the children of the [RenderTable].
enum TableCellVerticalAlignment {
  /// Cells with this alignment are placed with their top at the top of the row.
  top,

  /// Cells with this alignment are vertically centered in the row.
  middle,

  /// Cells with this alignment are placed with their bottom at the bottom of the row.
  bottom,

  /// Cells with this alignment are aligned such that they all share the same
  /// baseline. Cells with no baseline are top-aligned instead. The baseline
Ian Hickson's avatar
Ian Hickson committed
334 335
  /// used is specified by [RenderTable.textBaseline]. It is not valid to use
  /// the baseline value if [RenderTable.textBaseline] is not specified.
336
  ///
337
  /// This vertical alignment is relatively expensive because it causes the table
338
  /// to compute the baseline for each cell in the row.
Hixie's avatar
Hixie committed
339 340 341 342 343 344 345 346 347
  baseline,

  /// Cells with this alignment are sized to be as tall as the row, then made to fit the row.
  /// If all the cells have this alignment, then the row will have zero height.
  fill
}

/// A table where the columns and rows are sized to fit the contents of the cells.
class RenderTable extends RenderBox {
348 349 350 351 352 353 354 355 356 357 358
  /// Creates a table render object.
  ///
  ///  * `columns` must either be null or non-negative. If `columns` is null,
  ///    the number of columns will be inferred from length of the first sublist
  ///    of `children`.
  ///  * `rows` must either be null or non-negative. If `rows` is null, the
  ///    number of rows will be inferred from the `children`. If `rows` is not
  ///    null, then `children` must be null.
  ///  * `children` must either be null or contain lists of all the same length.
  ///    if `children` is not null, then `rows` must be null.
  ///  * [defaultColumnWidth] must not be null.
359
  ///  * [configuration] must not be null (but has a default value).
Hixie's avatar
Hixie committed
360 361 362 363
  RenderTable({
    int columns,
    int rows,
    Map<int, TableColumnWidth> columnWidths,
364
    TableColumnWidth defaultColumnWidth = const FlexColumnWidth(1.0),
365
    @required TextDirection textDirection,
Hixie's avatar
Hixie committed
366
    TableBorder border,
367
    List<Decoration> rowDecorations,
368 369
    ImageConfiguration configuration = ImageConfiguration.empty,
    TableCellVerticalAlignment defaultVerticalAlignment = TableCellVerticalAlignment.top,
Hixie's avatar
Hixie committed
370
    TextBaseline textBaseline,
371
    List<List<RenderBox>> children,
372 373 374 375
  }) : assert(columns == null || columns >= 0),
       assert(rows == null || rows >= 0),
       assert(rows == null || children == null),
       assert(defaultColumnWidth != null),
376 377 378
       assert(textDirection != null),
       assert(configuration != null),
       _textDirection = textDirection {
379
    _columns = columns ?? (children != null && children.isNotEmpty ? children.first.length : 0);
Hixie's avatar
Hixie committed
380
    _rows = rows ?? 0;
381
    _children = <RenderBox>[]..length = _columns * _rows;
382
    _columnWidths = columnWidths ?? HashMap<int, TableColumnWidth>();
Hixie's avatar
Hixie committed
383 384
    _defaultColumnWidth = defaultColumnWidth;
    _border = border;
385 386
    this.rowDecorations = rowDecorations; // must use setter to initialize box painters array
    _configuration = configuration;
Hixie's avatar
Hixie committed
387 388
    _defaultVerticalAlignment = defaultVerticalAlignment;
    _textBaseline = textBaseline;
389
    children?.forEach(addRow);
Hixie's avatar
Hixie committed
390 391 392 393 394 395
  }

  // Children are stored in row-major order.
  // _children.length must be rows * columns
  List<RenderBox> _children = const <RenderBox>[];

396 397 398 399 400 401
  /// The number of vertical alignment lines in this table.
  ///
  /// Changing the number of columns will remove any children that no longer fit
  /// in the table.
  ///
  /// Changing the number of columns is an expensive operation because the table
402
  /// needs to rearrange its internal representation.
Hixie's avatar
Hixie committed
403 404
  int get columns => _columns;
  int _columns;
405
  set columns(int value) {
Hixie's avatar
Hixie committed
406 407 408 409
    assert(value != null);
    assert(value >= 0);
    if (value == columns)
      return;
410 411
    final int oldColumns = columns;
    final List<RenderBox> oldChildren = _children;
Hixie's avatar
Hixie committed
412
    _columns = value;
413
    _children = <RenderBox>[]..length = columns * rows;
414
    final int columnsToCopy = math.min(columns, oldColumns);
Hixie's avatar
Hixie committed
415 416 417 418
    for (int y = 0; y < rows; y += 1) {
      for (int x = 0; x < columnsToCopy; x += 1)
        _children[x + y * columns] = oldChildren[x + y * oldColumns];
    }
Hixie's avatar
Hixie committed
419 420 421
    if (oldColumns > columns) {
      for (int y = 0; y < rows; y += 1) {
        for (int x = columns; x < oldColumns; x += 1) {
422
          final int xy = x + y * oldColumns;
Hixie's avatar
Hixie committed
423 424 425 426 427
          if (oldChildren[xy] != null)
            dropChild(oldChildren[xy]);
        }
      }
    }
Hixie's avatar
Hixie committed
428 429 430
    markNeedsLayout();
  }

431 432 433 434
  /// The number of horizontal alignment lines in this table.
  ///
  /// Changing the number of rows will remove any children that no longer fit
  /// in the table.
Hixie's avatar
Hixie committed
435 436
  int get rows => _rows;
  int _rows;
437
  set rows(int value) {
Hixie's avatar
Hixie committed
438 439 440 441
    assert(value != null);
    assert(value >= 0);
    if (value == rows)
      return;
Hixie's avatar
Hixie committed
442 443 444 445 446 447
    if (_rows > value) {
      for (int xy = columns * value; xy < _children.length; xy += 1) {
        if (_children[xy] != null)
          dropChild(_children[xy]);
      }
    }
Hixie's avatar
Hixie committed
448 449 450 451 452
    _rows = value;
    _children.length = columns * rows;
    markNeedsLayout();
  }

453 454 455 456 457 458 459 460 461
  /// How the horizontal extents of the columns of this table should be determined.
  ///
  /// If the [Map] has a null entry for a given column, the table uses the
  /// [defaultColumnWidth] instead.
  ///
  /// The layout performance of the table depends critically on which column
  /// sizing algorithms are used here. In particular, [IntrinsicColumnWidth] is
  /// quite expensive because it needs to measure each cell in the column to
  /// determine the intrinsic size of the column.
462
  Map<int, TableColumnWidth> get columnWidths => Map<int, TableColumnWidth>.unmodifiable(_columnWidths);
463
  Map<int, TableColumnWidth> _columnWidths;
464
  set columnWidths(Map<int, TableColumnWidth> value) {
465
    value ??= HashMap<int, TableColumnWidth>();
Hixie's avatar
Hixie committed
466 467 468 469 470 471
    if (_columnWidths == value)
      return;
    _columnWidths = value;
    markNeedsLayout();
  }

472
  /// Determines how the width of column with the given index is determined.
Hixie's avatar
Hixie committed
473 474 475 476 477 478 479
  void setColumnWidth(int column, TableColumnWidth value) {
    if (_columnWidths[column] == value)
      return;
    _columnWidths[column] = value;
    markNeedsLayout();
  }

480 481 482 483
  /// How to determine with widths of columns that don't have an explicit sizing algorithm.
  ///
  /// Specifically, the [defaultColumnWidth] is used for column `i` if
  /// `columnWidths[i]` is null.
Hixie's avatar
Hixie committed
484 485
  TableColumnWidth get defaultColumnWidth => _defaultColumnWidth;
  TableColumnWidth _defaultColumnWidth;
486
  set defaultColumnWidth(TableColumnWidth value) {
Hixie's avatar
Hixie committed
487 488 489 490 491 492 493
    assert(value != null);
    if (defaultColumnWidth == value)
      return;
    _defaultColumnWidth = value;
    markNeedsLayout();
  }

494 495 496 497 498 499 500 501 502 503 504
  /// The direction in which the columns are ordered.
  TextDirection get textDirection => _textDirection;
  TextDirection _textDirection;
  set textDirection(TextDirection value) {
    assert(value != null);
    if (_textDirection == value)
      return;
    _textDirection = value;
    markNeedsLayout();
  }

505
  /// The style to use when painting the boundary and interior divisions of the table.
Hixie's avatar
Hixie committed
506 507
  TableBorder get border => _border;
  TableBorder _border;
508
  set border(TableBorder value) {
Hixie's avatar
Hixie committed
509 510 511 512 513
    if (border == value)
      return;
    _border = value;
    markNeedsPaint();
  }
514

515 516 517 518 519
  /// The decorations to use for each row of the table.
  ///
  /// Row decorations fill the horizontal and vertical extent of each row in
  /// the table, unlike decorations for individual cells, which might not fill
  /// either.
520
  List<Decoration> get rowDecorations => List<Decoration>.unmodifiable(_rowDecorations ?? const <Decoration>[]);
521 522
  // _rowDecorations and _rowDecorationPainters need to be in sync. They have to
  // either both be null or have same length.
523 524
  List<Decoration> _rowDecorations;
  List<BoxPainter> _rowDecorationPainters;
525
  set rowDecorations(List<Decoration> value) {
526 527 528
    if (_rowDecorations == value)
      return;
    _rowDecorations = value;
529 530 531
    if (_rowDecorationPainters != null) {
      for (BoxPainter painter in _rowDecorationPainters)
        painter?.dispose();
532
    }
533
    _rowDecorationPainters = _rowDecorations != null ? List<BoxPainter>(_rowDecorations.length) : null;
534 535
  }

536 537 538 539 540
  /// The settings to pass to the [rowDecorations] when painting, so that they
  /// can resolve images appropriately. See [ImageProvider.resolve] and
  /// [BoxPainter.paint].
  ImageConfiguration get configuration => _configuration;
  ImageConfiguration _configuration;
541
  set configuration(ImageConfiguration value) {
542 543 544 545 546
    assert(value != null);
    if (value == _configuration)
      return;
    _configuration = value;
    markNeedsPaint();
547
  }
Hixie's avatar
Hixie committed
548

549
  /// How cells that do not explicitly specify a vertical alignment are aligned vertically.
Hixie's avatar
Hixie committed
550 551
  TableCellVerticalAlignment get defaultVerticalAlignment => _defaultVerticalAlignment;
  TableCellVerticalAlignment _defaultVerticalAlignment;
552
  set defaultVerticalAlignment(TableCellVerticalAlignment value) {
Hixie's avatar
Hixie committed
553 554 555 556 557 558
    if (_defaultVerticalAlignment == value)
      return;
    _defaultVerticalAlignment = value;
    markNeedsLayout();
  }

559
  /// The text baseline to use when aligning rows using [TableCellVerticalAlignment.baseline].
Hixie's avatar
Hixie committed
560 561
  TextBaseline get textBaseline => _textBaseline;
  TextBaseline _textBaseline;
562
  set textBaseline(TextBaseline value) {
Hixie's avatar
Hixie committed
563 564 565 566 567 568 569 570 571
    if (_textBaseline == value)
      return;
    _textBaseline = value;
    markNeedsLayout();
  }

  @override
  void setupParentData(RenderObject child) {
    if (child.parentData is! TableCellParentData)
572
      child.parentData = TableCellParentData();
Hixie's avatar
Hixie committed
573 574
  }

575 576 577 578 579 580 581 582
  /// Replaces the children of this table with the given cells.
  ///
  /// The cells are divided into the specified number of columns before
  /// replacing the existing children.
  ///
  /// If the new cells contain any existing children of the table, those
  /// children are simply moved to their new location in the table rather than
  /// removed from the table and re-added.
Hixie's avatar
Hixie committed
583 584 585 586
  void setFlatChildren(int columns, List<RenderBox> cells) {
    if (cells == _children && columns == _columns)
      return;
    assert(columns >= 0);
Hixie's avatar
Hixie committed
587
    // consider the case of a newly empty table
588 589
    if (columns == 0 || cells.isEmpty) {
      assert(cells == null || cells.isEmpty);
Hixie's avatar
Hixie committed
590
      _columns = columns;
591
      if (_children.isEmpty) {
Hixie's avatar
Hixie committed
592
        assert(_rows == 0);
Hixie's avatar
Hixie committed
593
        return;
Hixie's avatar
Hixie committed
594
      }
Hixie's avatar
Hixie committed
595
      for (RenderBox oldChild in _children) {
Hixie's avatar
Hixie committed
596 597 598
        if (oldChild != null)
          dropChild(oldChild);
      }
Hixie's avatar
Hixie committed
599 600 601 602 603 604 605
      _rows = 0;
      _children.clear();
      markNeedsLayout();
      return;
    }
    assert(cells != null);
    assert(cells.length % columns == 0);
606 607 608
    // fill a set with the cells that are moving (it's important not
    // to dropChild a child that's remaining with us, because that
    // would clear their parentData field)
609
    final Set<RenderBox> lostChildren = HashSet<RenderBox>();
Hixie's avatar
Hixie committed
610 611
    for (int y = 0; y < _rows; y += 1) {
      for (int x = 0; x < _columns; x += 1) {
612 613
        final int xyOld = x + y * _columns;
        final int xyNew = x + y * columns;
Hixie's avatar
Hixie committed
614
        if (_children[xyOld] != null && (x >= columns || xyNew >= cells.length || _children[xyOld] != cells[xyNew]))
615
          lostChildren.add(_children[xyOld]);
Hixie's avatar
Hixie committed
616
      }
Hixie's avatar
Hixie committed
617
    }
618
    // adopt cells that are arriving, and cross cells that are just moving off our list of lostChildren
Hixie's avatar
Hixie committed
619 620 621
    int y = 0;
    while (y * columns < cells.length) {
      for (int x = 0; x < columns; x += 1) {
622 623
        final int xyNew = x + y * columns;
        final int xyOld = x + y * _columns;
624 625 626 627
        if (cells[xyNew] != null && (x >= _columns || y >= _rows || _children[xyOld] != cells[xyNew])) {
          if (!lostChildren.remove(cells[xyNew]))
            adoptChild(cells[xyNew]);
        }
Hixie's avatar
Hixie committed
628 629 630
      }
      y += 1;
    }
631
    // drop all the lost children
632
    lostChildren.forEach(dropChild);
Hixie's avatar
Hixie committed
633 634 635 636 637
    // update our internal values
    _columns = columns;
    _rows = cells.length ~/ columns;
    _children = cells.toList();
    assert(_children.length == rows * columns);
Hixie's avatar
Hixie committed
638 639 640
    markNeedsLayout();
  }

641
  /// Replaces the children of this table with the given cells.
Hixie's avatar
Hixie committed
642
  void setChildren(List<List<RenderBox>> cells) {
Hixie's avatar
Hixie committed
643
    // TODO(ianh): Make this smarter, like setFlatChildren
Hixie's avatar
Hixie committed
644 645 646 647
    if (cells == null) {
      setFlatChildren(0, null);
      return;
    }
Hixie's avatar
Hixie committed
648
    for (RenderBox oldChild in _children) {
Hixie's avatar
Hixie committed
649 650 651
      if (oldChild != null)
        dropChild(oldChild);
    }
Hixie's avatar
Hixie committed
652
    _children.clear();
653
    _columns = cells.isNotEmpty ? cells.first.length : 0;
Hixie's avatar
Hixie committed
654
    _rows = 0;
655
    cells.forEach(addRow);
Hixie's avatar
Hixie committed
656
    assert(_children.length == rows * columns);
Hixie's avatar
Hixie committed
657 658
  }

659 660 661
  /// Adds a row to the end of the table.
  ///
  /// The newly added children must not already have parents.
Hixie's avatar
Hixie committed
662 663
  void addRow(List<RenderBox> cells) {
    assert(cells.length == columns);
Hixie's avatar
Hixie committed
664
    assert(_children.length == rows * columns);
Hixie's avatar
Hixie committed
665 666 667 668 669 670 671 672 673
    _rows += 1;
    _children.addAll(cells);
    for (RenderBox cell in cells) {
      if (cell != null)
        adoptChild(cell);
    }
    markNeedsLayout();
  }

674 675 676 677 678
  /// Replaces the child at the given position with the given child.
  ///
  /// If the given child is already located at the given position, this function
  /// does not modify the table. Otherwise, the given child must not already
  /// have a parent.
Hixie's avatar
Hixie committed
679 680 681 682
  void setChild(int x, int y, RenderBox value) {
    assert(x != null);
    assert(y != null);
    assert(x >= 0 && x < columns && y >= 0 && y < rows);
Hixie's avatar
Hixie committed
683
    assert(_children.length == rows * columns);
Hixie's avatar
Hixie committed
684
    final int xy = x + y * columns;
685
    final RenderBox oldChild = _children[xy];
Hixie's avatar
Hixie committed
686 687
    if (oldChild == value)
      return;
Hixie's avatar
Hixie committed
688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703
    if (oldChild != null)
      dropChild(oldChild);
    _children[xy] = value;
    if (value != null)
      adoptChild(value);
  }

  @override
  void attach(PipelineOwner owner) {
    super.attach(owner);
    for (RenderBox child in _children)
      child?.attach(owner);
  }

  @override
  void detach() {
704
    super.detach();
705 706 707
    if (_rowDecorationPainters != null) {
      for (BoxPainter painter in _rowDecorationPainters)
        painter?.dispose();
708
      _rowDecorationPainters = List<BoxPainter>(_rowDecorations.length);
709
    }
Hixie's avatar
Hixie committed
710 711 712 713 714 715
    for (RenderBox child in _children)
      child?.detach();
  }

  @override
  void visitChildren(RenderObjectVisitor visitor) {
Hixie's avatar
Hixie committed
716
    assert(_children.length == rows * columns);
Hixie's avatar
Hixie committed
717 718 719 720 721 722 723
    for (RenderBox child in _children) {
      if (child != null)
        visitor(child);
    }
  }

  @override
724
  double computeMinIntrinsicWidth(double height) {
Hixie's avatar
Hixie committed
725
    assert(_children.length == rows * columns);
Hixie's avatar
Hixie committed
726 727
    double totalMinWidth = 0.0;
    for (int x = 0; x < columns; x += 1) {
728 729
      final TableColumnWidth columnWidth = _columnWidths[x] ?? defaultColumnWidth;
      final Iterable<RenderBox> columnCells = column(x);
730
      totalMinWidth += columnWidth.minIntrinsicWidth(columnCells, double.infinity);
Hixie's avatar
Hixie committed
731
    }
732
    return totalMinWidth;
Hixie's avatar
Hixie committed
733 734 735
  }

  @override
736
  double computeMaxIntrinsicWidth(double height) {
Hixie's avatar
Hixie committed
737
    assert(_children.length == rows * columns);
Hixie's avatar
Hixie committed
738 739
    double totalMaxWidth = 0.0;
    for (int x = 0; x < columns; x += 1) {
740 741
      final TableColumnWidth columnWidth = _columnWidths[x] ?? defaultColumnWidth;
      final Iterable<RenderBox> columnCells = column(x);
742
      totalMaxWidth += columnWidth.maxIntrinsicWidth(columnCells, double.infinity);
Hixie's avatar
Hixie committed
743
    }
744
    return totalMaxWidth;
Hixie's avatar
Hixie committed
745 746 747
  }

  @override
748
  double computeMinIntrinsicHeight(double width) {
Hixie's avatar
Hixie committed
749 750
    // winner of the 2016 world's most expensive intrinsic dimension function award
    // honorable mention, most likely to improve if taught about memoization award
Hixie's avatar
Hixie committed
751
    assert(_children.length == rows * columns);
752
    final List<double> widths = _computeColumnWidths(BoxConstraints.tightForFinite(width: width));
Hixie's avatar
Hixie committed
753 754 755 756 757
    double rowTop = 0.0;
    for (int y = 0; y < rows; y += 1) {
      double rowHeight = 0.0;
      for (int x = 0; x < columns; x += 1) {
        final int xy = x + y * columns;
758
        final RenderBox child = _children[xy];
Hixie's avatar
Hixie committed
759
        if (child != null)
760
          rowHeight = math.max(rowHeight, child.getMaxIntrinsicHeight(widths[x]));
Hixie's avatar
Hixie committed
761 762 763
      }
      rowTop += rowHeight;
    }
764
    return rowTop;
Hixie's avatar
Hixie committed
765 766 767
  }

  @override
768 769
  double computeMaxIntrinsicHeight(double width) {
    return computeMinIntrinsicHeight(width);
Hixie's avatar
Hixie committed
770 771 772 773 774 775
  }

  double _baselineDistance;
  @override
  double computeDistanceToActualBaseline(TextBaseline baseline) {
    // returns the baseline of the first cell that has a baseline in the first row
776
    assert(!debugNeedsLayout);
Hixie's avatar
Hixie committed
777 778 779
    return _baselineDistance;
  }

780 781 782 783
  /// Returns the list of [RenderBox] objects that are in the given
  /// column, in row order, starting from the first row.
  ///
  /// This is a lazily-evaluated iterable.
Hixie's avatar
Hixie committed
784 785 786
  Iterable<RenderBox> column(int x) sync* {
    for (int y = 0; y < rows; y += 1) {
      final int xy = x + y * columns;
787
      final RenderBox child = _children[xy];
Hixie's avatar
Hixie committed
788 789 790 791 792
      if (child != null)
        yield child;
    }
  }

793 794 795 796
  /// Returns the list of [RenderBox] objects that are on the given
  /// row, in column order, starting with the first column.
  ///
  /// This is a lazily-evaluated iterable.
Hixie's avatar
Hixie committed
797 798 799 800
  Iterable<RenderBox> row(int y) sync* {
    final int start = y * columns;
    final int end = (y + 1) * columns;
    for (int xy = start; xy < end; xy += 1) {
801
      final RenderBox child = _children[xy];
Hixie's avatar
Hixie committed
802 803 804 805 806
      if (child != null)
        yield child;
    }
  }

807
  List<double> _computeColumnWidths(BoxConstraints constraints) {
808
    assert(constraints != null);
Hixie's avatar
Hixie committed
809
    assert(_children.length == rows * columns);
810 811 812 813 814 815 816 817 818 819 820
    // We apply the constraints to the column widths in the order of
    // least important to most important:
    // 1. apply the ideal widths (maxIntrinsicWidth)
    // 2. grow the flex columns so that the table has the maxWidth (if
    //    finite) or the minWidth (if not)
    // 3. if there were no flex columns, then grow the table to the
    //    minWidth.
    // 4. apply the maximum width of the table, shrinking columns as
    //    necessary, applying minimum column widths as we go

    // 1. apply ideal widths, and collect information we'll need later
821 822 823
    final List<double> widths = List<double>(columns);
    final List<double> minWidths = List<double>(columns);
    final List<double> flexes = List<double>(columns);
824 825
    double tableWidth = 0.0; // running tally of the sum of widths[x] for all x
    double unflexedTableWidth = 0.0; // sum of the maxIntrinsicWidths of any column that has null flex
Hixie's avatar
Hixie committed
826 827
    double totalFlex = 0.0;
    for (int x = 0; x < columns; x += 1) {
828 829
      final TableColumnWidth columnWidth = _columnWidths[x] ?? defaultColumnWidth;
      final Iterable<RenderBox> columnCells = column(x);
830 831 832 833 834 835 836 837 838 839 840 841 842
      // apply ideal width (maxIntrinsicWidth)
      final double maxIntrinsicWidth = columnWidth.maxIntrinsicWidth(columnCells, constraints.maxWidth);
      assert(maxIntrinsicWidth.isFinite);
      assert(maxIntrinsicWidth >= 0.0);
      widths[x] = maxIntrinsicWidth;
      tableWidth += maxIntrinsicWidth;
      // collect min width information while we're at it
      final double minIntrinsicWidth = columnWidth.minIntrinsicWidth(columnCells, constraints.maxWidth);
      assert(minIntrinsicWidth.isFinite);
      assert(minIntrinsicWidth >= 0.0);
      minWidths[x] = minIntrinsicWidth;
      assert(maxIntrinsicWidth >= minIntrinsicWidth);
      // collect flex information while we're at it
843
      final double flex = columnWidth.flex(columnCells);
Hixie's avatar
Hixie committed
844
      if (flex != null) {
845 846
        assert(flex.isFinite);
        assert(flex > 0.0);
Hixie's avatar
Hixie committed
847 848
        flexes[x] = flex;
        totalFlex += flex;
849 850
      } else {
        unflexedTableWidth += maxIntrinsicWidth;
Hixie's avatar
Hixie committed
851 852 853
      }
    }
    assert(!widths.any((double value) => value == null));
854 855 856 857 858 859 860 861 862 863
    final double maxWidthConstraint = constraints.maxWidth;
    final double minWidthConstraint = constraints.minWidth;

    // 2. grow the flex columns so that the table has the maxWidth (if
    //    finite) or the minWidth (if not)
    if (totalFlex > 0.0) {
      // this can only grow the table, but it _will_ grow the table at
      // least as big as the target width.
      double targetWidth;
      if (maxWidthConstraint.isFinite) {
864
        targetWidth = maxWidthConstraint;
865 866 867 868 869 870 871
      } else {
        targetWidth = minWidthConstraint;
      }
      if (tableWidth < targetWidth) {
        final double remainingWidth = targetWidth - unflexedTableWidth;
        assert(remainingWidth.isFinite);
        assert(remainingWidth >= 0.0);
Hixie's avatar
Hixie committed
872 873
        for (int x = 0; x < columns; x += 1) {
          if (flexes[x] != null) {
874 875 876 877 878 879 880 881
            final double flexedWidth = remainingWidth * flexes[x] / totalFlex;
            assert(flexedWidth.isFinite);
            assert(flexedWidth >= 0.0);
            if (widths[x] < flexedWidth) {
              final double delta = flexedWidth - widths[x];
              tableWidth += delta;
              widths[x] = flexedWidth;
            }
Hixie's avatar
Hixie committed
882 883
          }
        }
884
        assert(tableWidth + precisionErrorTolerance >= targetWidth);
885
      }
886
    } // step 2 and 3 are mutually exclusive
887 888 889

    // 3. if there were no flex columns, then grow the table to the
    //    minWidth.
890
    else if (tableWidth < minWidthConstraint) {
891 892 893 894 895 896 897
      final double delta = (minWidthConstraint - tableWidth) / columns;
      for (int x = 0; x < columns; x += 1)
        widths[x] += delta;
      tableWidth = minWidthConstraint;
    }

    // beyond this point, unflexedTableWidth is no longer valid
898
    assert(() { unflexedTableWidth = null; return true; }());
899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920

    // 4. apply the maximum width of the table, shrinking columns as
    //    necessary, applying minimum column widths as we go
    if (tableWidth > maxWidthConstraint) {
      double deficit = tableWidth - maxWidthConstraint;
      // Some columns may have low flex but have all the free space.
      // (Consider a case with a 1px wide column of flex 1000.0 and
      // a 1000px wide column of flex 1.0; the sizes coming from the
      // maxIntrinsicWidths. If the maximum table width is 2px, then
      // just applying the flexes to the deficit would result in a
      // table with one column at -998px and one column at 990px,
      // which is wildly unhelpful.)
      // Similarly, some columns may be flexible, but not actually
      // be shrinkable due to a large minimum width. (Consider a
      // case with two columns, one is flex and one isn't, both have
      // 1000px maxIntrinsicWidths, but the flex one has 1000px
      // minIntrinsicWidth also. The whole deficit will have to come
      // from the non-flex column.)
      // So what we do is we repeatedly iterate through the flexible
      // columns shrinking them proportionally until we have no
      // available columns, then do the same to the non-flexible ones.
      int availableColumns = columns;
921
      while (deficit > precisionErrorTolerance && totalFlex > precisionErrorTolerance) {
922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937
        double newTotalFlex = 0.0;
        for (int x = 0; x < columns; x += 1) {
          if (flexes[x] != null) {
            final double newWidth = widths[x] - deficit * flexes[x] / totalFlex;
            assert(newWidth.isFinite);
            if (newWidth <= minWidths[x]) {
              // shrank to minimum
              deficit -= widths[x] - minWidths[x];
              widths[x] = minWidths[x];
              flexes[x] = null;
              availableColumns -= 1;
            } else {
              deficit -= widths[x] - newWidth;
              widths[x] = newWidth;
              newTotalFlex += flexes[x];
            }
938
            assert(widths[x] >= 0.0);
939 940 941 942
          }
        }
        totalFlex = newTotalFlex;
      }
943
      while (deficit > precisionErrorTolerance && availableColumns > 0) {
944 945 946 947 948
        // Now we have to take out the remaining space from the
        // columns that aren't minimum sized.
        // To make this fair, we repeatedly remove equal amounts from
        // each column, clamped to the minimum width, until we run out
        // of columns that aren't at their minWidth.
949 950 951 952 953 954 955 956 957 958 959 960 961 962
        final double delta = deficit / availableColumns;
        assert(delta != 0);
        int newAvailableColumns = 0;
        for (int x = 0; x < columns; x += 1) {
          final double availableDelta = widths[x] - minWidths[x];
          if (availableDelta > 0.0) {
            if (availableDelta <= delta) {
              // shrank to minimum
              deficit -= widths[x] - minWidths[x];
              widths[x] = minWidths[x];
            } else {
              deficit -= delta;
              widths[x] -= delta;
              newAvailableColumns += 1;
963 964
            }
          }
965 966
        }
        availableColumns = newAvailableColumns;
Hixie's avatar
Hixie committed
967 968 969 970 971 972
      }
    }
    return widths;
  }

  // cache the table geometry for painting purposes
973
  final List<double> _rowTops = <double>[];
974
  Iterable<double> _columnLefts;
Hixie's avatar
Hixie committed
975

976 977 978 979 980 981 982 983 984 985
  /// Returns the position and dimensions of the box that the given
  /// row covers, in this render object's coordinate space (so the
  /// left coordinate is always 0.0).
  ///
  /// The row being queried must exist.
  ///
  /// This is only valid after layout.
  Rect getRowBox(int row) {
    assert(row >= 0);
    assert(row < rows);
986
    assert(!debugNeedsLayout);
987
    return Rect.fromLTRB(0.0, _rowTops[row], size.width, _rowTops[row + 1]);
988 989
  }

Hixie's avatar
Hixie committed
990 991
  @override
  void performLayout() {
992 993
    final int rows = this.rows;
    final int columns = this.columns;
Hixie's avatar
Hixie committed
994
    assert(_children.length == rows * columns);
Hixie's avatar
Hixie committed
995
    if (rows * columns == 0) {
Hixie's avatar
Hixie committed
996 997
      // TODO(ianh): if columns is zero, this should be zero width
      // TODO(ianh): if columns is not zero, this should be based on the column width specifications
998
      size = constraints.constrain(const Size(0.0, 0.0));
Hixie's avatar
Hixie committed
999 1000
      return;
    }
1001
    final List<double> widths = _computeColumnWidths(constraints);
1002
    final List<double> positions = List<double>(columns);
1003 1004 1005 1006 1007 1008
    double tableWidth;
    switch (textDirection) {
      case TextDirection.rtl:
        positions[columns - 1] = 0.0;
        for (int x = columns - 2; x >= 0; x -= 1)
          positions[x] = positions[x+1] + widths[x+1];
1009
        _columnLefts = positions.reversed;
1010 1011 1012 1013 1014 1015 1016 1017 1018 1019
        tableWidth = positions.first + widths.first;
        break;
      case TextDirection.ltr:
        positions[0] = 0.0;
        for (int x = 1; x < columns; x += 1)
          positions[x] = positions[x-1] + widths[x-1];
        _columnLefts = positions;
        tableWidth = positions.last + widths.last;
        break;
    }
Hixie's avatar
Hixie committed
1020
    assert(!positions.any((double value) => value == null));
1021
    _rowTops.clear();
Hixie's avatar
Hixie committed
1022 1023 1024 1025 1026 1027 1028 1029 1030
    _baselineDistance = null;
    // then, lay out each row
    double rowTop = 0.0;
    for (int y = 0; y < rows; y += 1) {
      _rowTops.add(rowTop);
      double rowHeight = 0.0;
      bool haveBaseline = false;
      double beforeBaselineDistance = 0.0;
      double afterBaselineDistance = 0.0;
1031
      final List<double> baselines = List<double>(columns);
Hixie's avatar
Hixie committed
1032 1033
      for (int x = 0; x < columns; x += 1) {
        final int xy = x + y * columns;
1034
        final RenderBox child = _children[xy];
Hixie's avatar
Hixie committed
1035
        if (child != null) {
1036
          final TableCellParentData childParentData = child.parentData;
Hixie's avatar
Hixie committed
1037
          assert(childParentData != null);
Hixie's avatar
Hixie committed
1038 1039
          childParentData.x = x;
          childParentData.y = y;
Hixie's avatar
Hixie committed
1040 1041 1042
          switch (childParentData.verticalAlignment ?? defaultVerticalAlignment) {
            case TableCellVerticalAlignment.baseline:
              assert(textBaseline != null);
1043
              child.layout(BoxConstraints.tightFor(width: widths[x]), parentUsesSize: true);
1044
              final double childBaseline = child.getDistanceToBaseline(textBaseline, onlyReal: true);
Hixie's avatar
Hixie committed
1045 1046 1047 1048 1049 1050 1051
              if (childBaseline != null) {
                beforeBaselineDistance = math.max(beforeBaselineDistance, childBaseline);
                afterBaselineDistance = math.max(afterBaselineDistance, child.size.height - childBaseline);
                baselines[x] = childBaseline;
                haveBaseline = true;
              } else {
                rowHeight = math.max(rowHeight, child.size.height);
1052
                childParentData.offset = Offset(positions[x], rowTop);
Hixie's avatar
Hixie committed
1053 1054 1055 1056 1057
              }
              break;
            case TableCellVerticalAlignment.top:
            case TableCellVerticalAlignment.middle:
            case TableCellVerticalAlignment.bottom:
1058
              child.layout(BoxConstraints.tightFor(width: widths[x]), parentUsesSize: true);
Hixie's avatar
Hixie committed
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
              rowHeight = math.max(rowHeight, child.size.height);
              break;
            case TableCellVerticalAlignment.fill:
              break;
          }
        }
      }
      if (haveBaseline) {
        if (y == 0)
          _baselineDistance = beforeBaselineDistance;
        rowHeight = math.max(rowHeight, beforeBaselineDistance + afterBaselineDistance);
      }
      for (int x = 0; x < columns; x += 1) {
        final int xy = x + y * columns;
1073
        final RenderBox child = _children[xy];
Hixie's avatar
Hixie committed
1074 1075 1076 1077 1078
        if (child != null) {
          final TableCellParentData childParentData = child.parentData;
          switch (childParentData.verticalAlignment ?? defaultVerticalAlignment) {
            case TableCellVerticalAlignment.baseline:
              if (baselines[x] != null)
1079
                childParentData.offset = Offset(positions[x], rowTop + beforeBaselineDistance - baselines[x]);
Hixie's avatar
Hixie committed
1080 1081
              break;
            case TableCellVerticalAlignment.top:
1082
              childParentData.offset = Offset(positions[x], rowTop);
Hixie's avatar
Hixie committed
1083 1084
              break;
            case TableCellVerticalAlignment.middle:
1085
              childParentData.offset = Offset(positions[x], rowTop + (rowHeight - child.size.height) / 2.0);
Hixie's avatar
Hixie committed
1086 1087
              break;
            case TableCellVerticalAlignment.bottom:
1088
              childParentData.offset = Offset(positions[x], rowTop + rowHeight - child.size.height);
Hixie's avatar
Hixie committed
1089 1090
              break;
            case TableCellVerticalAlignment.fill:
1091 1092
              child.layout(BoxConstraints.tightFor(width: widths[x], height: rowHeight));
              childParentData.offset = Offset(positions[x], rowTop);
Hixie's avatar
Hixie committed
1093 1094 1095 1096 1097 1098
              break;
          }
        }
      }
      rowTop += rowHeight;
    }
1099
    _rowTops.add(rowTop);
1100
    size = constraints.constrain(Size(tableWidth, rowTop));
1101
    assert(_rowTops.length == rows + 1);
Hixie's avatar
Hixie committed
1102 1103 1104
  }

  @override
1105
  bool hitTestChildren(BoxHitTestResult result, { Offset position }) {
Hixie's avatar
Hixie committed
1106
    assert(_children.length == rows * columns);
Hixie's avatar
Hixie committed
1107
    for (int index = _children.length - 1; index >= 0; index -= 1) {
1108
      final RenderBox child = _children[index];
Hixie's avatar
Hixie committed
1109 1110
      if (child != null) {
        final BoxParentData childParentData = child.parentData;
1111 1112 1113 1114 1115 1116 1117 1118 1119
        final bool isHit = result.addWithPaintOffset(
          offset: childParentData.offset,
          position: position,
          hitTest: (BoxHitTestResult result, Offset transformed) {
            assert(transformed == position - childParentData.offset);
            return child.hitTest(result, position: transformed);
          },
        );
        if (isHit)
Hixie's avatar
Hixie committed
1120 1121 1122 1123 1124 1125 1126 1127
          return true;
      }
    }
    return false;
  }

  @override
  void paint(PaintingContext context, Offset offset) {
Hixie's avatar
Hixie committed
1128
    assert(_children.length == rows * columns);
1129
    if (rows * columns == 0) {
1130
      if (border != null) {
1131
        final Rect borderRect = Rect.fromLTWH(offset.dx, offset.dy, size.width, 0.0);
1132 1133
        border.paint(context.canvas, borderRect, rows: const <double>[], columns: const <double>[]);
      }
Hixie's avatar
Hixie committed
1134
      return;
1135
    }
1136 1137
    assert(_rowTops.length == rows + 1);
    if (_rowDecorations != null) {
1138
      assert(_rowDecorations.length == _rowDecorationPainters.length);
1139
      final Canvas canvas = context.canvas;
1140 1141 1142
      for (int y = 0; y < rows; y += 1) {
        if (_rowDecorations.length <= y)
          break;
1143
        if (_rowDecorations[y] != null) {
1144 1145 1146
          _rowDecorationPainters[y] ??= _rowDecorations[y].createBoxPainter(markNeedsPaint);
          _rowDecorationPainters[y].paint(
            canvas,
1147
            Offset(offset.dx, offset.dy + _rowTops[y]),
1148
            configuration.copyWith(size: Size(size.width, _rowTops[y+1] - _rowTops[y])),
1149
          );
1150
        }
1151 1152
      }
    }
Hixie's avatar
Hixie committed
1153
    for (int index = 0; index < _children.length; index += 1) {
1154
      final RenderBox child = _children[index];
Hixie's avatar
Hixie committed
1155
      if (child != null) {
1156
        final BoxParentData childParentData = child.parentData;
Hixie's avatar
Hixie committed
1157 1158 1159
        context.paintChild(child, childParentData.offset + offset);
      }
    }
1160 1161
    assert(_rows == _rowTops.length - 1);
    assert(_columns == _columnLefts.length);
1162 1163 1164 1165
    if (border != null) {
      // The border rect might not fill the entire height of this render object
      // if the rows underflow. We always force the columns to fill the width of
      // the render object, which means the columns cannot underflow.
1166
      final Rect borderRect = Rect.fromLTWH(offset.dx, offset.dy, size.width, _rowTops.last);
1167
      final Iterable<double> rows = _rowTops.getRange(1, _rowTops.length - 1);
1168 1169
      final Iterable<double> columns = _columnLefts.skip(1);
      border.paint(context.canvas, borderRect, rows: rows, columns: columns);
1170
    }
Hixie's avatar
Hixie committed
1171 1172 1173
  }

  @override
1174 1175
  void debugFillProperties(DiagnosticPropertiesBuilder properties) {
    super.debugFillProperties(properties);
1176 1177 1178 1179
    properties.add(DiagnosticsProperty<TableBorder>('border', border, defaultValue: null));
    properties.add(DiagnosticsProperty<Map<int, TableColumnWidth>>('specified column widths', _columnWidths, level: _columnWidths.isEmpty ? DiagnosticLevel.hidden : DiagnosticLevel.info));
    properties.add(DiagnosticsProperty<TableColumnWidth>('default column width', defaultColumnWidth));
    properties.add(MessageProperty('table size', '$columns\u00D7$rows'));
1180 1181
    properties.add(IterableProperty<String>('column offsets', _columnLefts?.map(debugFormatDouble), ifNull: 'unknown'));
    properties.add(IterableProperty<String>('row offsets', _rowTops?.map(debugFormatDouble), ifNull: 'unknown'));
Hixie's avatar
Hixie committed
1182 1183 1184
  }

  @override
1185 1186
  List<DiagnosticsNode> debugDescribeChildren() {
    if (_children.isEmpty) {
1187
      return <DiagnosticsNode>[DiagnosticsNode.message('table is empty')];
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198
    }

    final List<DiagnosticsNode> children = <DiagnosticsNode>[];
    for (int y = 0; y < rows; y += 1) {
      for (int x = 0; x < columns; x += 1) {
        final int xy = x + y * columns;
        final RenderBox child = _children[xy];
        final String name = 'child ($x, $y)';
        if (child != null)
          children.add(child.toDiagnosticsNode(name: name));
        else
1199
          children.add(DiagnosticsProperty<Object>(name, null, ifNull: 'is null', showSeparator: false));
Hixie's avatar
Hixie committed
1200 1201
      }
    }
1202
    return children;
Hixie's avatar
Hixie committed
1203 1204
  }
}