TimelineTileBuilder.connected constructor

TimelineTileBuilder.connected({
  1. required int itemCount,
  2. ContentsAlign contentsAlign = ContentsAlign.basic,
  3. ConnectionDirection connectionDirection = ConnectionDirection.after,
  4. NullableIndexedWidgetBuilder? contentsBuilder,
  5. NullableIndexedWidgetBuilder? oppositeContentsBuilder,
  6. NullableIndexedWidgetBuilder? indicatorBuilder,
  7. ConnectedConnectorBuilder? connectorBuilder,
  8. WidgetBuilder? firstConnectorBuilder,
  9. WidgetBuilder? lastConnectorBuilder,
  10. double? itemExtent,
  11. IndexedValueBuilder<double>? itemExtentBuilder,
  12. IndexedValueBuilder<double>? nodePositionBuilder,
  13. IndexedValueBuilder<double>? indicatorPositionBuilder,
  14. bool addAutomaticKeepAlives = true,
  15. bool addRepaintBoundaries = true,
  16. bool addSemanticIndexes = true,
})

Create a connected tile builder, which builds tiles using each component builder.

Check below for how to build:

Original build system:

|            <-- builder(0)
O contents1  <-- builder(0)
|            <-- builder(0)
|            <-- builder(1)
O contents2  <-- builder(1)
|            <-- builder(1)

Connected build system(before):

|            <-- draw if provided [firstConnectorBuilder]
O contents1  <-- builder(0)
|            <-- builder(1)
|            <-- builder(1)
O contents2  <-- builder(1)
|            <-- builder(2)
|            <-- builder(2)
O            <-- builder(2)
|            <-- builder(3)
..
|            <-- draw if provided [lastConnectorBuilder]

Connected build system(after):

|            <-- draw if provided [firstConnectorBuilder]
O contents1  <-- builder(0)
|            <-- builder(0)
|            <-- builder(0)
O contents2  <-- builder(1)
|            <-- builder(1)
|            <-- builder(1)
O            <-- builder(2)
|            <-- builder(2)
..
|            <-- draw if provided [lastConnectorBuilder]

The above example can be made similar by just set the TimelineNode.indicatorPosition as 0 or 1, but the contents position may be limited.

If each item has a fixed extent, use itemExtent, and if each item has a different extent, use itemExtentBuilder.

See also:

Implementation

factory TimelineTileBuilder.connected({
  required int itemCount,
  ContentsAlign contentsAlign = ContentsAlign.basic,
  ConnectionDirection connectionDirection = ConnectionDirection.after,
  NullableIndexedWidgetBuilder? contentsBuilder,
  NullableIndexedWidgetBuilder? oppositeContentsBuilder,
  NullableIndexedWidgetBuilder? indicatorBuilder,
  ConnectedConnectorBuilder? connectorBuilder,
  WidgetBuilder? firstConnectorBuilder,
  WidgetBuilder? lastConnectorBuilder,
  double? itemExtent,
  IndexedValueBuilder<double>? itemExtentBuilder,
  IndexedValueBuilder<double>? nodePositionBuilder,
  IndexedValueBuilder<double>? indicatorPositionBuilder,
  bool addAutomaticKeepAlives = true,
  bool addRepaintBoundaries = true,
  bool addSemanticIndexes = true,
}) {
  return TimelineTileBuilder(
    itemCount: itemCount,
    contentsAlign: contentsAlign,
    contentsBuilder: contentsBuilder,
    oppositeContentsBuilder: oppositeContentsBuilder,
    indicatorBuilder: indicatorBuilder,
    startConnectorBuilder: _createConnectedStartConnectorBuilder(
      connectionDirection: connectionDirection,
      firstConnectorBuilder: firstConnectorBuilder,
      connectorBuilder: connectorBuilder,
    ),
    endConnectorBuilder: _createConnectedEndConnectorBuilder(
      connectionDirection: connectionDirection,
      lastConnectorBuilder: lastConnectorBuilder,
      connectorBuilder: connectorBuilder,
      itemCount: itemCount,
    ),
    itemExtent: itemExtent,
    itemExtentBuilder: itemExtentBuilder,
    nodePositionBuilder: nodePositionBuilder,
    indicatorPositionBuilder: indicatorPositionBuilder,
  );
}