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,
    );
  }
}