mirror of
https://github.com/flutter/flutter.git
synced 2026-02-11 21:33:08 +08:00
1176 lines
46 KiB
Dart
1176 lines
46 KiB
Dart
// Copyright 2014 The Flutter 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:math' as math;
|
|
|
|
import 'package:flutter/foundation.dart';
|
|
|
|
import 'box.dart';
|
|
import 'debug_overflow_indicator.dart';
|
|
import 'layer.dart';
|
|
import 'layout_helper.dart';
|
|
import 'object.dart';
|
|
|
|
/// How the child is inscribed into the available space.
|
|
///
|
|
/// See also:
|
|
///
|
|
/// * [RenderFlex], the flex render object.
|
|
/// * [Column], [Row], and [Flex], the flex widgets.
|
|
/// * [Expanded], the widget equivalent of [tight].
|
|
/// * [Flexible], the widget equivalent of [loose].
|
|
enum FlexFit {
|
|
/// The child is forced to fill the available space.
|
|
///
|
|
/// The [Expanded] widget assigns this kind of [FlexFit] to its child.
|
|
tight,
|
|
|
|
/// The child can be at most as large as the available space (but is
|
|
/// allowed to be smaller).
|
|
///
|
|
/// The [Flexible] widget assigns this kind of [FlexFit] to its child.
|
|
loose,
|
|
}
|
|
|
|
/// Parent data for use with [RenderFlex].
|
|
class FlexParentData extends ContainerBoxParentData<RenderBox> {
|
|
/// The flex factor to use for this child.
|
|
///
|
|
/// If null or zero, the child is inflexible and determines its own size. If
|
|
/// non-zero, the amount of space the child's can occupy in the main axis is
|
|
/// determined by dividing the free space (after placing the inflexible
|
|
/// children) according to the flex factors of the flexible children.
|
|
int? flex;
|
|
|
|
/// How a flexible child is inscribed into the available space.
|
|
///
|
|
/// If [flex] is non-zero, the [fit] determines whether the child fills the
|
|
/// space the parent makes available during layout. If the fit is
|
|
/// [FlexFit.tight], the child is required to fill the available space. If the
|
|
/// fit is [FlexFit.loose], the child can be at most as large as the available
|
|
/// space (but is allowed to be smaller).
|
|
FlexFit? fit;
|
|
|
|
@override
|
|
String toString() => '${super.toString()}; flex=$flex; fit=$fit';
|
|
}
|
|
|
|
/// How much space should be occupied in the main axis.
|
|
///
|
|
/// During a flex layout, available space along the main axis is allocated to
|
|
/// children. After allocating space, there might be some remaining free space.
|
|
/// This value controls whether to maximize or minimize the amount of free
|
|
/// space, subject to the incoming layout constraints.
|
|
///
|
|
/// See also:
|
|
///
|
|
/// * [Column], [Row], and [Flex], the flex widgets.
|
|
/// * [Expanded] and [Flexible], the widgets that controls a flex widgets'
|
|
/// children's flex.
|
|
/// * [RenderFlex], the flex render object.
|
|
/// * [MainAxisAlignment], which controls how the free space is distributed.
|
|
enum MainAxisSize {
|
|
/// Minimize the amount of free space along the main axis, subject to the
|
|
/// incoming layout constraints.
|
|
///
|
|
/// If the incoming layout constraints have a large enough
|
|
/// [BoxConstraints.minWidth] or [BoxConstraints.minHeight], there might still
|
|
/// be a non-zero amount of free space.
|
|
///
|
|
/// If the incoming layout constraints are unbounded, and any children have a
|
|
/// non-zero [FlexParentData.flex] and a [FlexFit.tight] fit (as applied by
|
|
/// [Expanded]), the [RenderFlex] will assert, because there would be infinite
|
|
/// remaining free space and boxes cannot be given infinite size.
|
|
min,
|
|
|
|
/// Maximize the amount of free space along the main axis, subject to the
|
|
/// incoming layout constraints.
|
|
///
|
|
/// If the incoming layout constraints have a small enough
|
|
/// [BoxConstraints.maxWidth] or [BoxConstraints.maxHeight], there might still
|
|
/// be no free space.
|
|
///
|
|
/// If the incoming layout constraints are unbounded, the [RenderFlex] will
|
|
/// assert, because there would be infinite remaining free space and boxes
|
|
/// cannot be given infinite size.
|
|
max,
|
|
}
|
|
|
|
/// How the children should be placed along the main axis in a flex layout.
|
|
///
|
|
/// See also:
|
|
///
|
|
/// * [Column], [Row], and [Flex], the flex widgets.
|
|
/// * [RenderFlex], the flex render object.
|
|
enum MainAxisAlignment {
|
|
/// Place the children as close to the start of the main axis as possible.
|
|
///
|
|
/// If this value is used in a horizontal direction, a [TextDirection] must be
|
|
/// available to determine if the start is the left or the right.
|
|
///
|
|
/// If this value is used in a vertical direction, a [VerticalDirection] must be
|
|
/// available to determine if the start is the top or the bottom.
|
|
start,
|
|
|
|
/// Place the children as close to the end of the main axis as possible.
|
|
///
|
|
/// If this value is used in a horizontal direction, a [TextDirection] must be
|
|
/// available to determine if the end is the left or the right.
|
|
///
|
|
/// If this value is used in a vertical direction, a [VerticalDirection] must be
|
|
/// available to determine if the end is the top or the bottom.
|
|
end,
|
|
|
|
/// Place the children as close to the middle of the main axis as possible.
|
|
center,
|
|
|
|
/// Place the free space evenly between the children.
|
|
spaceBetween,
|
|
|
|
/// Place the free space evenly between the children as well as half of that
|
|
/// space before and after the first and last child.
|
|
spaceAround,
|
|
|
|
/// Place the free space evenly between the children as well as before and
|
|
/// after the first and last child.
|
|
spaceEvenly,
|
|
}
|
|
|
|
/// How the children should be placed along the cross axis in a flex layout.
|
|
///
|
|
/// See also:
|
|
///
|
|
/// * [Column], [Row], and [Flex], the flex widgets.
|
|
/// * [RenderFlex], the flex render object.
|
|
enum CrossAxisAlignment {
|
|
/// Place the children with their start edge aligned with the start side of
|
|
/// the cross axis.
|
|
///
|
|
/// For example, in a column (a flex with a vertical axis) whose
|
|
/// [TextDirection] is [TextDirection.ltr], this aligns the left edge of the
|
|
/// children along the left edge of the column.
|
|
///
|
|
/// If this value is used in a horizontal direction, a [TextDirection] must be
|
|
/// available to determine if the start is the left or the right.
|
|
///
|
|
/// If this value is used in a vertical direction, a [VerticalDirection] must be
|
|
/// available to determine if the start is the top or the bottom.
|
|
start,
|
|
|
|
/// Place the children as close to the end of the cross axis as possible.
|
|
///
|
|
/// For example, in a column (a flex with a vertical axis) whose
|
|
/// [TextDirection] is [TextDirection.ltr], this aligns the right edge of the
|
|
/// children along the right edge of the column.
|
|
///
|
|
/// If this value is used in a horizontal direction, a [TextDirection] must be
|
|
/// available to determine if the end is the left or the right.
|
|
///
|
|
/// If this value is used in a vertical direction, a [VerticalDirection] must be
|
|
/// available to determine if the end is the top or the bottom.
|
|
end,
|
|
|
|
/// Place the children so that their centers align with the middle of the
|
|
/// cross axis.
|
|
///
|
|
/// This is the default cross-axis alignment.
|
|
center,
|
|
|
|
/// Require the children to fill the cross axis.
|
|
///
|
|
/// This causes the constraints passed to the children to be tight in the
|
|
/// cross axis.
|
|
stretch,
|
|
|
|
/// Place the children along the cross axis such that their baselines match.
|
|
///
|
|
/// Because baselines are always horizontal, this alignment is intended for
|
|
/// horizontal main axes. If the main axis is vertical, then this value is
|
|
/// treated like [start].
|
|
///
|
|
/// For horizontal main axes, if the minimum height constraint passed to the
|
|
/// flex layout exceeds the intrinsic height of the cross axis, children will
|
|
/// be aligned as close to the top as they can be while honoring the baseline
|
|
/// alignment. In other words, the extra space will be below all the children.
|
|
///
|
|
/// Children who report no baseline will be top-aligned.
|
|
baseline,
|
|
}
|
|
|
|
bool? _startIsTopLeft(Axis direction, TextDirection? textDirection, VerticalDirection? verticalDirection) {
|
|
assert(direction != null);
|
|
// If the relevant value of textDirection or verticalDirection is null, this returns null too.
|
|
switch (direction) {
|
|
case Axis.horizontal:
|
|
switch (textDirection) {
|
|
case TextDirection.ltr:
|
|
return true;
|
|
case TextDirection.rtl:
|
|
return false;
|
|
case null:
|
|
return null;
|
|
}
|
|
case Axis.vertical:
|
|
switch (verticalDirection) {
|
|
case VerticalDirection.down:
|
|
return true;
|
|
case VerticalDirection.up:
|
|
return false;
|
|
case null:
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
typedef _ChildSizingFunction = double Function(RenderBox child, double extent);
|
|
|
|
/// Displays its children in a one-dimensional array.
|
|
///
|
|
/// ## Layout algorithm
|
|
///
|
|
/// _This section describes how the framework causes [RenderFlex] to position
|
|
/// its children._
|
|
/// _See [BoxConstraints] for an introduction to box layout models._
|
|
///
|
|
/// Layout for a [RenderFlex] proceeds in six steps:
|
|
///
|
|
/// 1. Layout each child a null or zero flex factor with unbounded main axis
|
|
/// constraints and the incoming cross axis constraints. If the
|
|
/// [crossAxisAlignment] is [CrossAxisAlignment.stretch], instead use tight
|
|
/// cross axis constraints that match the incoming max extent in the cross
|
|
/// axis.
|
|
/// 2. Divide the remaining main axis space among the children with non-zero
|
|
/// flex factors according to their flex factor. For example, a child with a
|
|
/// flex factor of 2.0 will receive twice the amount of main axis space as a
|
|
/// child with a flex factor of 1.0.
|
|
/// 3. Layout each of the remaining children with the same cross axis
|
|
/// constraints as in step 1, but instead of using unbounded main axis
|
|
/// constraints, use max axis constraints based on the amount of space
|
|
/// allocated in step 2. Children with [Flexible.fit] properties that are
|
|
/// [FlexFit.tight] are given tight constraints (i.e., forced to fill the
|
|
/// allocated space), and children with [Flexible.fit] properties that are
|
|
/// [FlexFit.loose] are given loose constraints (i.e., not forced to fill the
|
|
/// allocated space).
|
|
/// 4. The cross axis extent of the [RenderFlex] is the maximum cross axis
|
|
/// extent of the children (which will always satisfy the incoming
|
|
/// constraints).
|
|
/// 5. The main axis extent of the [RenderFlex] is determined by the
|
|
/// [mainAxisSize] property. If the [mainAxisSize] property is
|
|
/// [MainAxisSize.max], then the main axis extent of the [RenderFlex] is the
|
|
/// max extent of the incoming main axis constraints. If the [mainAxisSize]
|
|
/// property is [MainAxisSize.min], then the main axis extent of the [Flex]
|
|
/// is the sum of the main axis extents of the children (subject to the
|
|
/// incoming constraints).
|
|
/// 6. Determine the position for each child according to the
|
|
/// [mainAxisAlignment] and the [crossAxisAlignment]. For example, if the
|
|
/// [mainAxisAlignment] is [MainAxisAlignment.spaceBetween], any main axis
|
|
/// space that has not been allocated to children is divided evenly and
|
|
/// placed between the children.
|
|
///
|
|
/// See also:
|
|
///
|
|
/// * [Flex], the widget equivalent.
|
|
/// * [Row] and [Column], direction-specific variants of [Flex].
|
|
class RenderFlex extends RenderBox with ContainerRenderObjectMixin<RenderBox, FlexParentData>,
|
|
RenderBoxContainerDefaultsMixin<RenderBox, FlexParentData>,
|
|
DebugOverflowIndicatorMixin {
|
|
/// Creates a flex render object.
|
|
///
|
|
/// By default, the flex layout is horizontal and children are aligned to the
|
|
/// start of the main axis and the center of the cross axis.
|
|
RenderFlex({
|
|
List<RenderBox>? children,
|
|
Axis direction = Axis.horizontal,
|
|
MainAxisSize mainAxisSize = MainAxisSize.max,
|
|
MainAxisAlignment mainAxisAlignment = MainAxisAlignment.start,
|
|
CrossAxisAlignment crossAxisAlignment = CrossAxisAlignment.center,
|
|
TextDirection? textDirection,
|
|
VerticalDirection verticalDirection = VerticalDirection.down,
|
|
TextBaseline? textBaseline,
|
|
Clip clipBehavior = Clip.none,
|
|
}) : assert(direction != null),
|
|
assert(mainAxisAlignment != null),
|
|
assert(mainAxisSize != null),
|
|
assert(crossAxisAlignment != null),
|
|
assert(clipBehavior != null),
|
|
_direction = direction,
|
|
_mainAxisAlignment = mainAxisAlignment,
|
|
_mainAxisSize = mainAxisSize,
|
|
_crossAxisAlignment = crossAxisAlignment,
|
|
_textDirection = textDirection,
|
|
_verticalDirection = verticalDirection,
|
|
_textBaseline = textBaseline,
|
|
_clipBehavior = clipBehavior {
|
|
addAll(children);
|
|
}
|
|
|
|
/// The direction to use as the main axis.
|
|
Axis get direction => _direction;
|
|
Axis _direction;
|
|
set direction(Axis value) {
|
|
assert(value != null);
|
|
if (_direction != value) {
|
|
_direction = value;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
/// How the children should be placed along the main axis.
|
|
///
|
|
/// If the [direction] is [Axis.horizontal], and the [mainAxisAlignment] is
|
|
/// either [MainAxisAlignment.start] or [MainAxisAlignment.end], then the
|
|
/// [textDirection] must not be null.
|
|
///
|
|
/// If the [direction] is [Axis.vertical], and the [mainAxisAlignment] is
|
|
/// either [MainAxisAlignment.start] or [MainAxisAlignment.end], then the
|
|
/// [verticalDirection] must not be null.
|
|
MainAxisAlignment get mainAxisAlignment => _mainAxisAlignment;
|
|
MainAxisAlignment _mainAxisAlignment;
|
|
set mainAxisAlignment(MainAxisAlignment value) {
|
|
assert(value != null);
|
|
if (_mainAxisAlignment != value) {
|
|
_mainAxisAlignment = value;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
/// How much space should be occupied in the main axis.
|
|
///
|
|
/// After allocating space to children, there might be some remaining free
|
|
/// space. This value controls whether to maximize or minimize the amount of
|
|
/// free space, subject to the incoming layout constraints.
|
|
///
|
|
/// If some children have a non-zero flex factors (and none have a fit of
|
|
/// [FlexFit.loose]), they will expand to consume all the available space and
|
|
/// there will be no remaining free space to maximize or minimize, making this
|
|
/// value irrelevant to the final layout.
|
|
MainAxisSize get mainAxisSize => _mainAxisSize;
|
|
MainAxisSize _mainAxisSize;
|
|
set mainAxisSize(MainAxisSize value) {
|
|
assert(value != null);
|
|
if (_mainAxisSize != value) {
|
|
_mainAxisSize = value;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
/// How the children should be placed along the cross axis.
|
|
///
|
|
/// If the [direction] is [Axis.horizontal], and the [crossAxisAlignment] is
|
|
/// either [CrossAxisAlignment.start] or [CrossAxisAlignment.end], then the
|
|
/// [verticalDirection] must not be null.
|
|
///
|
|
/// If the [direction] is [Axis.vertical], and the [crossAxisAlignment] is
|
|
/// either [CrossAxisAlignment.start] or [CrossAxisAlignment.end], then the
|
|
/// [textDirection] must not be null.
|
|
CrossAxisAlignment get crossAxisAlignment => _crossAxisAlignment;
|
|
CrossAxisAlignment _crossAxisAlignment;
|
|
set crossAxisAlignment(CrossAxisAlignment value) {
|
|
assert(value != null);
|
|
if (_crossAxisAlignment != value) {
|
|
_crossAxisAlignment = value;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
/// Determines the order to lay children out horizontally and how to interpret
|
|
/// `start` and `end` in the horizontal direction.
|
|
///
|
|
/// If the [direction] is [Axis.horizontal], this controls the order in which
|
|
/// children are positioned (left-to-right or right-to-left), and the meaning
|
|
/// of the [mainAxisAlignment] property's [MainAxisAlignment.start] and
|
|
/// [MainAxisAlignment.end] values.
|
|
///
|
|
/// If the [direction] is [Axis.horizontal], and either the
|
|
/// [mainAxisAlignment] is either [MainAxisAlignment.start] or
|
|
/// [MainAxisAlignment.end], or there's more than one child, then the
|
|
/// [textDirection] must not be null.
|
|
///
|
|
/// If the [direction] is [Axis.vertical], this controls the meaning of the
|
|
/// [crossAxisAlignment] property's [CrossAxisAlignment.start] and
|
|
/// [CrossAxisAlignment.end] values.
|
|
///
|
|
/// If the [direction] is [Axis.vertical], and the [crossAxisAlignment] is
|
|
/// either [CrossAxisAlignment.start] or [CrossAxisAlignment.end], then the
|
|
/// [textDirection] must not be null.
|
|
TextDirection? get textDirection => _textDirection;
|
|
TextDirection? _textDirection;
|
|
set textDirection(TextDirection? value) {
|
|
if (_textDirection != value) {
|
|
_textDirection = value;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
/// Determines the order to lay children out vertically and how to interpret
|
|
/// `start` and `end` in the vertical direction.
|
|
///
|
|
/// If the [direction] is [Axis.vertical], this controls which order children
|
|
/// are painted in (down or up), the meaning of the [mainAxisAlignment]
|
|
/// property's [MainAxisAlignment.start] and [MainAxisAlignment.end] values.
|
|
///
|
|
/// If the [direction] is [Axis.vertical], and either the [mainAxisAlignment]
|
|
/// is either [MainAxisAlignment.start] or [MainAxisAlignment.end], or there's
|
|
/// more than one child, then the [verticalDirection] must not be null.
|
|
///
|
|
/// If the [direction] is [Axis.horizontal], this controls the meaning of the
|
|
/// [crossAxisAlignment] property's [CrossAxisAlignment.start] and
|
|
/// [CrossAxisAlignment.end] values.
|
|
///
|
|
/// If the [direction] is [Axis.horizontal], and the [crossAxisAlignment] is
|
|
/// either [CrossAxisAlignment.start] or [CrossAxisAlignment.end], then the
|
|
/// [verticalDirection] must not be null.
|
|
VerticalDirection get verticalDirection => _verticalDirection;
|
|
VerticalDirection _verticalDirection;
|
|
set verticalDirection(VerticalDirection value) {
|
|
if (_verticalDirection != value) {
|
|
_verticalDirection = value;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
/// If aligning items according to their baseline, which baseline to use.
|
|
///
|
|
/// Must not be null if [crossAxisAlignment] is [CrossAxisAlignment.baseline].
|
|
TextBaseline? get textBaseline => _textBaseline;
|
|
TextBaseline? _textBaseline;
|
|
set textBaseline(TextBaseline? value) {
|
|
assert(_crossAxisAlignment != CrossAxisAlignment.baseline || value != null);
|
|
if (_textBaseline != value) {
|
|
_textBaseline = value;
|
|
markNeedsLayout();
|
|
}
|
|
}
|
|
|
|
bool get _debugHasNecessaryDirections {
|
|
assert(direction != null);
|
|
assert(crossAxisAlignment != null);
|
|
if (firstChild != null && lastChild != firstChild) {
|
|
// i.e. there's more than one child
|
|
switch (direction) {
|
|
case Axis.horizontal:
|
|
assert(textDirection != null, 'Horizontal $runtimeType with multiple children has a null textDirection, so the layout order is undefined.');
|
|
break;
|
|
case Axis.vertical:
|
|
assert(verticalDirection != null, 'Vertical $runtimeType with multiple children has a null verticalDirection, so the layout order is undefined.');
|
|
break;
|
|
}
|
|
}
|
|
if (mainAxisAlignment == MainAxisAlignment.start ||
|
|
mainAxisAlignment == MainAxisAlignment.end) {
|
|
switch (direction) {
|
|
case Axis.horizontal:
|
|
assert(textDirection != null, 'Horizontal $runtimeType with $mainAxisAlignment has a null textDirection, so the alignment cannot be resolved.');
|
|
break;
|
|
case Axis.vertical:
|
|
assert(verticalDirection != null, 'Vertical $runtimeType with $mainAxisAlignment has a null verticalDirection, so the alignment cannot be resolved.');
|
|
break;
|
|
}
|
|
}
|
|
if (crossAxisAlignment == CrossAxisAlignment.start ||
|
|
crossAxisAlignment == CrossAxisAlignment.end) {
|
|
switch (direction) {
|
|
case Axis.horizontal:
|
|
assert(verticalDirection != null, 'Horizontal $runtimeType with $crossAxisAlignment has a null verticalDirection, so the alignment cannot be resolved.');
|
|
break;
|
|
case Axis.vertical:
|
|
assert(textDirection != null, 'Vertical $runtimeType with $crossAxisAlignment has a null textDirection, so the alignment cannot be resolved.');
|
|
break;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Set during layout if overflow occurred on the main axis.
|
|
double _overflow = 0;
|
|
// Check whether any meaningful overflow is present. Values below an epsilon
|
|
// are treated as not overflowing.
|
|
bool get _hasOverflow => _overflow > precisionErrorTolerance;
|
|
|
|
/// {@macro flutter.material.Material.clipBehavior}
|
|
///
|
|
/// Defaults to [Clip.none], and must not be null.
|
|
Clip get clipBehavior => _clipBehavior;
|
|
Clip _clipBehavior = Clip.none;
|
|
set clipBehavior(Clip value) {
|
|
assert(value != null);
|
|
if (value != _clipBehavior) {
|
|
_clipBehavior = value;
|
|
markNeedsPaint();
|
|
markNeedsSemanticsUpdate();
|
|
}
|
|
}
|
|
|
|
@override
|
|
void setupParentData(RenderBox child) {
|
|
if (child.parentData is! FlexParentData)
|
|
child.parentData = FlexParentData();
|
|
}
|
|
|
|
bool get _canComputeIntrinsics => crossAxisAlignment != CrossAxisAlignment.baseline;
|
|
|
|
double _getIntrinsicSize({
|
|
required Axis sizingDirection,
|
|
required double extent, // the extent in the direction that isn't the sizing direction
|
|
required _ChildSizingFunction childSize, // a method to find the size in the sizing direction
|
|
}) {
|
|
if (!_canComputeIntrinsics) {
|
|
// Intrinsics cannot be calculated without a full layout for
|
|
// baseline alignment. Throw an assertion and return 0.0 as documented
|
|
// on [RenderBox.computeMinIntrinsicWidth].
|
|
assert(
|
|
RenderObject.debugCheckingIntrinsics,
|
|
'Intrinsics are not available for CrossAxisAlignment.baseline.'
|
|
);
|
|
return 0.0;
|
|
}
|
|
if (_direction == sizingDirection) {
|
|
// INTRINSIC MAIN SIZE
|
|
// Intrinsic main size is the smallest size the flex container can take
|
|
// while maintaining the min/max-content contributions of its flex items.
|
|
double totalFlex = 0.0;
|
|
double inflexibleSpace = 0.0;
|
|
double maxFlexFractionSoFar = 0.0;
|
|
RenderBox? child = firstChild;
|
|
while (child != null) {
|
|
final int flex = _getFlex(child);
|
|
totalFlex += flex;
|
|
if (flex > 0) {
|
|
final double flexFraction = childSize(child, extent) / _getFlex(child);
|
|
maxFlexFractionSoFar = math.max(maxFlexFractionSoFar, flexFraction);
|
|
} else {
|
|
inflexibleSpace += childSize(child, extent);
|
|
}
|
|
final FlexParentData childParentData = child.parentData! as FlexParentData;
|
|
child = childParentData.nextSibling;
|
|
}
|
|
return maxFlexFractionSoFar * totalFlex + inflexibleSpace;
|
|
} else {
|
|
// INTRINSIC CROSS SIZE
|
|
// Intrinsic cross size is the max of the intrinsic cross sizes of the
|
|
// children, after the flexible children are fit into the available space,
|
|
// with the children sized using their max intrinsic dimensions.
|
|
|
|
// Get inflexible space using the max intrinsic dimensions of fixed children in the main direction.
|
|
final double availableMainSpace = extent;
|
|
int totalFlex = 0;
|
|
double inflexibleSpace = 0.0;
|
|
double maxCrossSize = 0.0;
|
|
RenderBox? child = firstChild;
|
|
while (child != null) {
|
|
final int flex = _getFlex(child);
|
|
totalFlex += flex;
|
|
late final double mainSize;
|
|
late final double crossSize;
|
|
if (flex == 0) {
|
|
switch (_direction) {
|
|
case Axis.horizontal:
|
|
mainSize = child.getMaxIntrinsicWidth(double.infinity);
|
|
crossSize = childSize(child, mainSize);
|
|
break;
|
|
case Axis.vertical:
|
|
mainSize = child.getMaxIntrinsicHeight(double.infinity);
|
|
crossSize = childSize(child, mainSize);
|
|
break;
|
|
}
|
|
inflexibleSpace += mainSize;
|
|
maxCrossSize = math.max(maxCrossSize, crossSize);
|
|
}
|
|
final FlexParentData childParentData = child.parentData! as FlexParentData;
|
|
child = childParentData.nextSibling;
|
|
}
|
|
|
|
// Determine the spacePerFlex by allocating the remaining available space.
|
|
// When you're overconstrained spacePerFlex can be negative.
|
|
final double spacePerFlex = math.max(0.0,
|
|
(availableMainSpace - inflexibleSpace) / totalFlex);
|
|
|
|
// Size remaining (flexible) items, find the maximum cross size.
|
|
child = firstChild;
|
|
while (child != null) {
|
|
final int flex = _getFlex(child);
|
|
if (flex > 0)
|
|
maxCrossSize = math.max(maxCrossSize, childSize(child, spacePerFlex * flex));
|
|
final FlexParentData childParentData = child.parentData! as FlexParentData;
|
|
child = childParentData.nextSibling;
|
|
}
|
|
|
|
return maxCrossSize;
|
|
}
|
|
}
|
|
|
|
@override
|
|
double computeMinIntrinsicWidth(double height) {
|
|
return _getIntrinsicSize(
|
|
sizingDirection: Axis.horizontal,
|
|
extent: height,
|
|
childSize: (RenderBox child, double extent) => child.getMinIntrinsicWidth(extent),
|
|
);
|
|
}
|
|
|
|
@override
|
|
double computeMaxIntrinsicWidth(double height) {
|
|
return _getIntrinsicSize(
|
|
sizingDirection: Axis.horizontal,
|
|
extent: height,
|
|
childSize: (RenderBox child, double extent) => child.getMaxIntrinsicWidth(extent),
|
|
);
|
|
}
|
|
|
|
@override
|
|
double computeMinIntrinsicHeight(double width) {
|
|
return _getIntrinsicSize(
|
|
sizingDirection: Axis.vertical,
|
|
extent: width,
|
|
childSize: (RenderBox child, double extent) => child.getMinIntrinsicHeight(extent),
|
|
);
|
|
}
|
|
|
|
@override
|
|
double computeMaxIntrinsicHeight(double width) {
|
|
return _getIntrinsicSize(
|
|
sizingDirection: Axis.vertical,
|
|
extent: width,
|
|
childSize: (RenderBox child, double extent) => child.getMaxIntrinsicHeight(extent),
|
|
);
|
|
}
|
|
|
|
@override
|
|
double? computeDistanceToActualBaseline(TextBaseline baseline) {
|
|
if (_direction == Axis.horizontal)
|
|
return defaultComputeDistanceToHighestActualBaseline(baseline);
|
|
return defaultComputeDistanceToFirstActualBaseline(baseline);
|
|
}
|
|
|
|
int _getFlex(RenderBox child) {
|
|
final FlexParentData childParentData = child.parentData! as FlexParentData;
|
|
return childParentData.flex ?? 0;
|
|
}
|
|
|
|
FlexFit _getFit(RenderBox child) {
|
|
final FlexParentData childParentData = child.parentData! as FlexParentData;
|
|
return childParentData.fit ?? FlexFit.tight;
|
|
}
|
|
|
|
double _getCrossSize(Size size) {
|
|
switch (_direction) {
|
|
case Axis.horizontal:
|
|
return size.height;
|
|
case Axis.vertical:
|
|
return size.width;
|
|
}
|
|
}
|
|
|
|
double _getMainSize(Size size) {
|
|
switch (_direction) {
|
|
case Axis.horizontal:
|
|
return size.width;
|
|
case Axis.vertical:
|
|
return size.height;
|
|
}
|
|
}
|
|
|
|
@override
|
|
Size computeDryLayout(BoxConstraints constraints) {
|
|
if (!_canComputeIntrinsics) {
|
|
assert(debugCannotComputeDryLayout(
|
|
reason: 'Dry layout cannot be computed for CrossAxisAlignment.baseline, which requires a full layout.'
|
|
));
|
|
return Size.zero;
|
|
}
|
|
FlutterError? constraintsError;
|
|
assert(() {
|
|
constraintsError = _debugCheckConstraints(
|
|
constraints: constraints,
|
|
reportParentConstraints: false,
|
|
);
|
|
return true;
|
|
}());
|
|
if (constraintsError != null) {
|
|
assert(debugCannotComputeDryLayout(error: constraintsError));
|
|
return Size.zero;
|
|
}
|
|
|
|
final _LayoutSizes sizes = _computeSizes(
|
|
layoutChild: ChildLayoutHelper.dryLayoutChild,
|
|
constraints: constraints,
|
|
);
|
|
|
|
switch (_direction) {
|
|
case Axis.horizontal:
|
|
return constraints.constrain(Size(sizes.mainSize, sizes.crossSize));
|
|
case Axis.vertical:
|
|
return constraints.constrain(Size(sizes.crossSize, sizes.mainSize));
|
|
}
|
|
}
|
|
|
|
FlutterError? _debugCheckConstraints({required BoxConstraints constraints, required bool reportParentConstraints}) {
|
|
FlutterError? result;
|
|
assert(() {
|
|
final double maxMainSize = _direction == Axis.horizontal ? constraints.maxWidth : constraints.maxHeight;
|
|
final bool canFlex = maxMainSize < double.infinity;
|
|
RenderBox? child = firstChild;
|
|
while (child != null) {
|
|
final int flex = _getFlex(child);
|
|
if (flex > 0) {
|
|
final String identity = _direction == Axis.horizontal ? 'row' : 'column';
|
|
final String axis = _direction == Axis.horizontal ? 'horizontal' : 'vertical';
|
|
final String dimension = _direction == Axis.horizontal ? 'width' : 'height';
|
|
DiagnosticsNode error, message;
|
|
final List<DiagnosticsNode> addendum = <DiagnosticsNode>[];
|
|
if (!canFlex && (mainAxisSize == MainAxisSize.max || _getFit(child) == FlexFit.tight)) {
|
|
error = ErrorSummary('RenderFlex children have non-zero flex but incoming $dimension constraints are unbounded.');
|
|
message = ErrorDescription(
|
|
'When a $identity is in a parent that does not provide a finite $dimension constraint, for example '
|
|
'if it is in a $axis scrollable, it will try to shrink-wrap its children along the $axis '
|
|
'axis. Setting a flex on a child (e.g. using Expanded) indicates that the child is to '
|
|
'expand to fill the remaining space in the $axis direction.'
|
|
);
|
|
if (reportParentConstraints) { // Constraints of parents are unavailable in dry layout.
|
|
RenderBox? node = this;
|
|
switch (_direction) {
|
|
case Axis.horizontal:
|
|
while (!node!.constraints.hasBoundedWidth && node.parent is RenderBox)
|
|
node = node.parent! as RenderBox;
|
|
if (!node.constraints.hasBoundedWidth)
|
|
node = null;
|
|
break;
|
|
case Axis.vertical:
|
|
while (!node!.constraints.hasBoundedHeight && node.parent is RenderBox)
|
|
node = node.parent! as RenderBox;
|
|
if (!node.constraints.hasBoundedHeight)
|
|
node = null;
|
|
break;
|
|
}
|
|
if (node != null) {
|
|
addendum.add(node.describeForError('The nearest ancestor providing an unbounded width constraint is'));
|
|
}
|
|
}
|
|
addendum.add(ErrorHint('See also: https://flutter.dev/layout/'));
|
|
} else {
|
|
return true;
|
|
}
|
|
result = FlutterError.fromParts(<DiagnosticsNode>[
|
|
error,
|
|
message,
|
|
ErrorDescription(
|
|
'These two directives are mutually exclusive. If a parent is to shrink-wrap its child, the child '
|
|
'cannot simultaneously expand to fit its parent.'
|
|
),
|
|
ErrorHint(
|
|
'Consider setting mainAxisSize to MainAxisSize.min and using FlexFit.loose fits for the flexible '
|
|
'children (using Flexible rather than Expanded). This will allow the flexible children '
|
|
'to size themselves to less than the infinite remaining space they would otherwise be '
|
|
'forced to take, and then will cause the RenderFlex to shrink-wrap the children '
|
|
'rather than expanding to fit the maximum constraints provided by the parent.'
|
|
),
|
|
ErrorDescription(
|
|
'If this message did not help you determine the problem, consider using debugDumpRenderTree():\n'
|
|
' https://flutter.dev/debugging/#rendering-layer\n'
|
|
' http://api.flutter.dev/flutter/rendering/debugDumpRenderTree.html'
|
|
),
|
|
describeForError('The affected RenderFlex is', style: DiagnosticsTreeStyle.errorProperty),
|
|
DiagnosticsProperty<dynamic>('The creator information is set to', debugCreator, style: DiagnosticsTreeStyle.errorProperty),
|
|
...addendum,
|
|
ErrorDescription(
|
|
"If none of the above helps enough to fix this problem, please don't hesitate to file a bug:\n"
|
|
' https://github.com/flutter/flutter/issues/new?template=2_bug.md'
|
|
),
|
|
]);
|
|
return true;
|
|
}
|
|
child = childAfter(child);
|
|
}
|
|
return true;
|
|
}());
|
|
return result;
|
|
}
|
|
|
|
_LayoutSizes _computeSizes({required BoxConstraints constraints, required ChildLayouter layoutChild}) {
|
|
assert(_debugHasNecessaryDirections);
|
|
assert(constraints != null);
|
|
|
|
// Determine used flex factor, size inflexible items, calculate free space.
|
|
int totalFlex = 0;
|
|
final double maxMainSize = _direction == Axis.horizontal ? constraints.maxWidth : constraints.maxHeight;
|
|
final bool canFlex = maxMainSize < double.infinity;
|
|
|
|
double crossSize = 0.0;
|
|
double allocatedSize = 0.0; // Sum of the sizes of the non-flexible children.
|
|
RenderBox? child = firstChild;
|
|
RenderBox? lastFlexChild;
|
|
while (child != null) {
|
|
final FlexParentData childParentData = child.parentData! as FlexParentData;
|
|
final int flex = _getFlex(child);
|
|
if (flex > 0) {
|
|
totalFlex += flex;
|
|
lastFlexChild = child;
|
|
} else {
|
|
final BoxConstraints innerConstraints;
|
|
if (crossAxisAlignment == CrossAxisAlignment.stretch) {
|
|
switch (_direction) {
|
|
case Axis.horizontal:
|
|
innerConstraints = BoxConstraints.tightFor(height: constraints.maxHeight);
|
|
break;
|
|
case Axis.vertical:
|
|
innerConstraints = BoxConstraints.tightFor(width: constraints.maxWidth);
|
|
break;
|
|
}
|
|
} else {
|
|
switch (_direction) {
|
|
case Axis.horizontal:
|
|
innerConstraints = BoxConstraints(maxHeight: constraints.maxHeight);
|
|
break;
|
|
case Axis.vertical:
|
|
innerConstraints = BoxConstraints(maxWidth: constraints.maxWidth);
|
|
break;
|
|
}
|
|
}
|
|
final Size childSize = layoutChild(child, innerConstraints);
|
|
allocatedSize += _getMainSize(childSize);
|
|
crossSize = math.max(crossSize, _getCrossSize(childSize));
|
|
}
|
|
assert(child.parentData == childParentData);
|
|
child = childParentData.nextSibling;
|
|
}
|
|
|
|
// Distribute free space to flexible children.
|
|
final double freeSpace = math.max(0.0, (canFlex ? maxMainSize : 0.0) - allocatedSize);
|
|
double allocatedFlexSpace = 0.0;
|
|
if (totalFlex > 0) {
|
|
final double spacePerFlex = canFlex ? (freeSpace / totalFlex) : double.nan;
|
|
child = firstChild;
|
|
while (child != null) {
|
|
final int flex = _getFlex(child);
|
|
if (flex > 0) {
|
|
final double maxChildExtent = canFlex ? (child == lastFlexChild ? (freeSpace - allocatedFlexSpace) : spacePerFlex * flex) : double.infinity;
|
|
late final double minChildExtent;
|
|
switch (_getFit(child)) {
|
|
case FlexFit.tight:
|
|
assert(maxChildExtent < double.infinity);
|
|
minChildExtent = maxChildExtent;
|
|
break;
|
|
case FlexFit.loose:
|
|
minChildExtent = 0.0;
|
|
break;
|
|
}
|
|
assert(minChildExtent != null);
|
|
final BoxConstraints innerConstraints;
|
|
if (crossAxisAlignment == CrossAxisAlignment.stretch) {
|
|
switch (_direction) {
|
|
case Axis.horizontal:
|
|
innerConstraints = BoxConstraints(
|
|
minWidth: minChildExtent,
|
|
maxWidth: maxChildExtent,
|
|
minHeight: constraints.maxHeight,
|
|
maxHeight: constraints.maxHeight,
|
|
);
|
|
break;
|
|
case Axis.vertical:
|
|
innerConstraints = BoxConstraints(
|
|
minWidth: constraints.maxWidth,
|
|
maxWidth: constraints.maxWidth,
|
|
minHeight: minChildExtent,
|
|
maxHeight: maxChildExtent,
|
|
);
|
|
break;
|
|
}
|
|
} else {
|
|
switch (_direction) {
|
|
case Axis.horizontal:
|
|
innerConstraints = BoxConstraints(
|
|
minWidth: minChildExtent,
|
|
maxWidth: maxChildExtent,
|
|
maxHeight: constraints.maxHeight,
|
|
);
|
|
break;
|
|
case Axis.vertical:
|
|
innerConstraints = BoxConstraints(
|
|
maxWidth: constraints.maxWidth,
|
|
minHeight: minChildExtent,
|
|
maxHeight: maxChildExtent,
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
final Size childSize = layoutChild(child, innerConstraints);
|
|
final double childMainSize = _getMainSize(childSize);
|
|
assert(childMainSize <= maxChildExtent);
|
|
allocatedSize += childMainSize;
|
|
allocatedFlexSpace += maxChildExtent;
|
|
crossSize = math.max(crossSize, _getCrossSize(childSize));
|
|
}
|
|
final FlexParentData childParentData = child.parentData! as FlexParentData;
|
|
child = childParentData.nextSibling;
|
|
}
|
|
}
|
|
|
|
final double idealSize = canFlex && mainAxisSize == MainAxisSize.max ? maxMainSize : allocatedSize;
|
|
return _LayoutSizes(
|
|
mainSize: idealSize,
|
|
crossSize: crossSize,
|
|
allocatedSize: allocatedSize,
|
|
);
|
|
}
|
|
|
|
@override
|
|
void performLayout() {
|
|
assert(_debugHasNecessaryDirections);
|
|
final BoxConstraints constraints = this.constraints;
|
|
assert(() {
|
|
final FlutterError? constraintsError = _debugCheckConstraints(
|
|
constraints: constraints,
|
|
reportParentConstraints: true,
|
|
);
|
|
if (constraintsError != null) {
|
|
throw constraintsError;
|
|
}
|
|
return true;
|
|
}());
|
|
|
|
final _LayoutSizes sizes = _computeSizes(
|
|
layoutChild: ChildLayoutHelper.layoutChild,
|
|
constraints: constraints,
|
|
);
|
|
|
|
final double allocatedSize = sizes.allocatedSize;
|
|
double actualSize = sizes.mainSize;
|
|
double crossSize = sizes.crossSize;
|
|
double maxBaselineDistance = 0.0;
|
|
if (crossAxisAlignment == CrossAxisAlignment.baseline) {
|
|
RenderBox? child = firstChild;
|
|
double maxSizeAboveBaseline = 0;
|
|
double maxSizeBelowBaseline = 0;
|
|
while (child != null) {
|
|
assert(() {
|
|
if (textBaseline == null)
|
|
throw FlutterError('To use FlexAlignItems.baseline, you must also specify which baseline to use using the "baseline" argument.');
|
|
return true;
|
|
}());
|
|
final double? distance = child.getDistanceToBaseline(textBaseline!, onlyReal: true);
|
|
if (distance != null) {
|
|
maxBaselineDistance = math.max(maxBaselineDistance, distance);
|
|
maxSizeAboveBaseline = math.max(
|
|
distance,
|
|
maxSizeAboveBaseline,
|
|
);
|
|
maxSizeBelowBaseline = math.max(
|
|
child.size.height - distance,
|
|
maxSizeBelowBaseline,
|
|
);
|
|
crossSize = math.max(maxSizeAboveBaseline + maxSizeBelowBaseline, crossSize);
|
|
}
|
|
final FlexParentData childParentData = child.parentData! as FlexParentData;
|
|
child = childParentData.nextSibling;
|
|
}
|
|
}
|
|
|
|
// Align items along the main axis.
|
|
switch (_direction) {
|
|
case Axis.horizontal:
|
|
size = constraints.constrain(Size(actualSize, crossSize));
|
|
actualSize = size.width;
|
|
crossSize = size.height;
|
|
break;
|
|
case Axis.vertical:
|
|
size = constraints.constrain(Size(crossSize, actualSize));
|
|
actualSize = size.height;
|
|
crossSize = size.width;
|
|
break;
|
|
}
|
|
final double actualSizeDelta = actualSize - allocatedSize;
|
|
_overflow = math.max(0.0, -actualSizeDelta);
|
|
final double remainingSpace = math.max(0.0, actualSizeDelta);
|
|
late final double leadingSpace;
|
|
late final double betweenSpace;
|
|
// flipMainAxis is used to decide whether to lay out left-to-right/top-to-bottom (false), or
|
|
// right-to-left/bottom-to-top (true). The _startIsTopLeft will return null if there's only
|
|
// one child and the relevant direction is null, in which case we arbitrarily decide not to
|
|
// flip, but that doesn't have any detectable effect.
|
|
final bool flipMainAxis = !(_startIsTopLeft(direction, textDirection, verticalDirection) ?? true);
|
|
switch (_mainAxisAlignment) {
|
|
case MainAxisAlignment.start:
|
|
leadingSpace = 0.0;
|
|
betweenSpace = 0.0;
|
|
break;
|
|
case MainAxisAlignment.end:
|
|
leadingSpace = remainingSpace;
|
|
betweenSpace = 0.0;
|
|
break;
|
|
case MainAxisAlignment.center:
|
|
leadingSpace = remainingSpace / 2.0;
|
|
betweenSpace = 0.0;
|
|
break;
|
|
case MainAxisAlignment.spaceBetween:
|
|
leadingSpace = 0.0;
|
|
betweenSpace = childCount > 1 ? remainingSpace / (childCount - 1) : 0.0;
|
|
break;
|
|
case MainAxisAlignment.spaceAround:
|
|
betweenSpace = childCount > 0 ? remainingSpace / childCount : 0.0;
|
|
leadingSpace = betweenSpace / 2.0;
|
|
break;
|
|
case MainAxisAlignment.spaceEvenly:
|
|
betweenSpace = childCount > 0 ? remainingSpace / (childCount + 1) : 0.0;
|
|
leadingSpace = betweenSpace;
|
|
break;
|
|
}
|
|
|
|
// Position elements
|
|
double childMainPosition = flipMainAxis ? actualSize - leadingSpace : leadingSpace;
|
|
RenderBox? child = firstChild;
|
|
while (child != null) {
|
|
final FlexParentData childParentData = child.parentData! as FlexParentData;
|
|
final double childCrossPosition;
|
|
switch (_crossAxisAlignment) {
|
|
case CrossAxisAlignment.start:
|
|
case CrossAxisAlignment.end:
|
|
childCrossPosition = _startIsTopLeft(flipAxis(direction), textDirection, verticalDirection)
|
|
== (_crossAxisAlignment == CrossAxisAlignment.start)
|
|
? 0.0
|
|
: crossSize - _getCrossSize(child.size);
|
|
break;
|
|
case CrossAxisAlignment.center:
|
|
childCrossPosition = crossSize / 2.0 - _getCrossSize(child.size) / 2.0;
|
|
break;
|
|
case CrossAxisAlignment.stretch:
|
|
childCrossPosition = 0.0;
|
|
break;
|
|
case CrossAxisAlignment.baseline:
|
|
if (_direction == Axis.horizontal) {
|
|
assert(textBaseline != null);
|
|
final double? distance = child.getDistanceToBaseline(textBaseline!, onlyReal: true);
|
|
if (distance != null)
|
|
childCrossPosition = maxBaselineDistance - distance;
|
|
else
|
|
childCrossPosition = 0.0;
|
|
} else {
|
|
childCrossPosition = 0.0;
|
|
}
|
|
break;
|
|
}
|
|
if (flipMainAxis)
|
|
childMainPosition -= _getMainSize(child.size);
|
|
switch (_direction) {
|
|
case Axis.horizontal:
|
|
childParentData.offset = Offset(childMainPosition, childCrossPosition);
|
|
break;
|
|
case Axis.vertical:
|
|
childParentData.offset = Offset(childCrossPosition, childMainPosition);
|
|
break;
|
|
}
|
|
if (flipMainAxis) {
|
|
childMainPosition -= betweenSpace;
|
|
} else {
|
|
childMainPosition += _getMainSize(child.size) + betweenSpace;
|
|
}
|
|
child = childParentData.nextSibling;
|
|
}
|
|
}
|
|
|
|
@override
|
|
bool hitTestChildren(BoxHitTestResult result, { required Offset position }) {
|
|
return defaultHitTestChildren(result, position: position);
|
|
}
|
|
|
|
@override
|
|
void paint(PaintingContext context, Offset offset) {
|
|
if (!_hasOverflow) {
|
|
defaultPaint(context, offset);
|
|
return;
|
|
}
|
|
|
|
// There's no point in drawing the children if we're empty.
|
|
if (size.isEmpty)
|
|
return;
|
|
|
|
if (clipBehavior == Clip.none) {
|
|
_clipRectLayer = null;
|
|
defaultPaint(context, offset);
|
|
} else {
|
|
// We have overflow and the clipBehavior isn't none. Clip it.
|
|
_clipRectLayer = context.pushClipRect(needsCompositing, offset, Offset.zero & size, defaultPaint,
|
|
clipBehavior: clipBehavior, oldLayer: _clipRectLayer);
|
|
}
|
|
|
|
assert(() {
|
|
// Only set this if it's null to save work. It gets reset to null if the
|
|
// _direction changes.
|
|
final List<DiagnosticsNode> debugOverflowHints = <DiagnosticsNode>[
|
|
ErrorDescription(
|
|
'The overflowing $runtimeType has an orientation of $_direction.'
|
|
),
|
|
ErrorDescription(
|
|
'The edge of the $runtimeType that is overflowing has been marked '
|
|
'in the rendering with a yellow and black striped pattern. This is '
|
|
'usually caused by the contents being too big for the $runtimeType.'
|
|
),
|
|
ErrorHint(
|
|
'Consider applying a flex factor (e.g. using an Expanded widget) to '
|
|
'force the children of the $runtimeType to fit within the available '
|
|
'space instead of being sized to their natural size.'
|
|
),
|
|
ErrorHint(
|
|
'This is considered an error condition because it indicates that there '
|
|
'is content that cannot be seen. If the content is legitimately bigger '
|
|
'than the available space, consider clipping it with a ClipRect widget '
|
|
'before putting it in the flex, or using a scrollable container rather '
|
|
'than a Flex, like a ListView.'
|
|
),
|
|
];
|
|
|
|
// Simulate a child rect that overflows by the right amount. This child
|
|
// rect is never used for drawing, just for determining the overflow
|
|
// location and amount.
|
|
final Rect overflowChildRect;
|
|
switch (_direction) {
|
|
case Axis.horizontal:
|
|
overflowChildRect = Rect.fromLTWH(0.0, 0.0, size.width + _overflow, 0.0);
|
|
break;
|
|
case Axis.vertical:
|
|
overflowChildRect = Rect.fromLTWH(0.0, 0.0, 0.0, size.height + _overflow);
|
|
break;
|
|
}
|
|
paintOverflowIndicator(context, offset, Offset.zero & size, overflowChildRect, overflowHints: debugOverflowHints);
|
|
return true;
|
|
}());
|
|
}
|
|
|
|
ClipRectLayer? _clipRectLayer;
|
|
|
|
@override
|
|
Rect? describeApproximatePaintClip(RenderObject child) => _hasOverflow ? Offset.zero & size : null;
|
|
|
|
@override
|
|
String toStringShort() {
|
|
String header = super.toStringShort();
|
|
if (_hasOverflow)
|
|
header += ' OVERFLOWING';
|
|
return header;
|
|
}
|
|
|
|
@override
|
|
void debugFillProperties(DiagnosticPropertiesBuilder properties) {
|
|
super.debugFillProperties(properties);
|
|
properties.add(EnumProperty<Axis>('direction', direction));
|
|
properties.add(EnumProperty<MainAxisAlignment>('mainAxisAlignment', mainAxisAlignment));
|
|
properties.add(EnumProperty<MainAxisSize>('mainAxisSize', mainAxisSize));
|
|
properties.add(EnumProperty<CrossAxisAlignment>('crossAxisAlignment', crossAxisAlignment));
|
|
properties.add(EnumProperty<TextDirection>('textDirection', textDirection, defaultValue: null));
|
|
properties.add(EnumProperty<VerticalDirection>('verticalDirection', verticalDirection, defaultValue: null));
|
|
properties.add(EnumProperty<TextBaseline>('textBaseline', textBaseline, defaultValue: null));
|
|
}
|
|
}
|
|
|
|
class _LayoutSizes {
|
|
const _LayoutSizes({
|
|
required this.mainSize,
|
|
required this.crossSize,
|
|
required this.allocatedSize,
|
|
});
|
|
|
|
final double mainSize;
|
|
final double crossSize;
|
|
final double allocatedSize;
|
|
}
|