layout method

@override void layout(BoxConstraints constraints)

Implementation

@override
void layout(BoxConstraints constraints) {
  super.layout(constraints);
  var maxWidth = 0.0;
  var maxHeight = 0.0;
  final isExpand = fit == StackFit.expand;
  final expandWidth = isExpand && constraints.hasBoundedWidth
      ? constraints.maxWidth
      : null;
  final expandHeight = isExpand && constraints.hasBoundedHeight
      ? constraints.maxHeight
      : null;
  var hasNonPositionedChild = false;

  for (final child in children) {
    final data = child.parentData as StackParentData?;
    if (data != null && data.isPositioned) {
      continue;
    }
    child.layout(
      BoxConstraints(
        minWidth: expandWidth ?? 0,
        maxWidth: expandWidth ?? constraints.maxWidth,
        minHeight: expandHeight ?? 0,
        maxHeight: expandHeight ?? constraints.maxHeight,
      ),
    );
    hasNonPositionedChild = true;
    maxWidth = math.max(maxWidth, child.size.width);
    maxHeight = math.max(maxHeight, child.size.height);
  }

  var resolvedWidth =
      _resolveDimensionDouble(width) ??
      (expandWidth ??
          (hasNonPositionedChild
          ? maxWidth
          : constraints.hasBoundedWidth
          ? constraints.maxWidth
          : 0.0));
  var resolvedHeight =
      _resolveDimensionDouble(height) ??
      (expandHeight ??
          (hasNonPositionedChild
          ? maxHeight
          : constraints.hasBoundedHeight
          ? constraints.maxHeight
          : 0.0));

  if (resolvedWidth.isInfinite) {
    resolvedWidth = maxWidth;
  }
  if (resolvedHeight.isInfinite) {
    resolvedHeight = maxHeight;
  }

  // Positioned children paint over the stack's resolved size but do not
  // contribute to it in loose mode.
  for (var i = 0; i < children.length; i++) {
    final child = children[i];
    final data = child.parentData as StackParentData?;
    if (data != null && data.isPositioned) {
      final left = _resolveDimensionDouble(data.left);
      final right = _resolveDimensionDouble(data.right);
      final top = _resolveDimensionDouble(data.top);
      final bottom = _resolveDimensionDouble(data.bottom);
      final childWidth =
          _resolveDimensionDouble(data.width) ??
          (left != null && right != null
              ? math.max(0, resolvedWidth - left - right)
              : null);
      final childHeight =
          _resolveDimensionDouble(data.height) ??
          (top != null && bottom != null
              ? math.max(0, resolvedHeight - top - bottom)
              : null);
      final childConstraints = BoxConstraints(
        minWidth: childWidth ?? 0,
        maxWidth: childWidth ?? resolvedWidth,
        minHeight: childHeight ?? 0,
        maxHeight: childHeight ?? resolvedHeight,
      );
      child.layout(childConstraints);
    }
  }

  size = constraints.constrain(Size(resolvedWidth, resolvedHeight));

  final targetWidth = size.width.toInt();
  final targetHeight = size.height.toInt();
  for (final child in children) {
    final data = child.parentData as StackParentData?;
    child.offset = _resolveChildOffset(child, data, targetWidth, targetHeight);
  }
}