getConstraints method

BoxConstraints getConstraints()

Implementation

BoxConstraints getConstraints() {
  if (enableWebFProfileTracking) {
    WebFProfiler.instance.startTrackLayoutStep('RenderBoxModel.getConstraints');
  }

  // Inner scrolling content box of overflow element inherits constraints from parent
  // but has indefinite max constraints to allow children overflow
  if (isScrollingContentBox) {
    RenderStyle parentRenderStyle = (parent as RenderBoxModel).renderStyle;
    EdgeInsets borderEdge = parentRenderStyle.border;
    EdgeInsetsGeometry? padding = parentRenderStyle.padding;
    double horizontalBorderLength = borderEdge.horizontal;
    double verticalBorderLength = borderEdge.vertical;
    double horizontalPaddingLength = padding.horizontal;
    double verticalPaddingLength = padding.vertical;

    BoxConstraints parentConstraints = (parent as RenderBoxModel).constraints;
    BoxConstraints constraints = BoxConstraints(
      minWidth: (parentConstraints.maxWidth != double.infinity && parentRenderStyle.width.value != null)
          ? parentConstraints.maxWidth - horizontalBorderLength - horizontalPaddingLength
          : 0,
      maxWidth: double.infinity,
      minHeight: (parentConstraints.maxHeight != double.infinity && parentRenderStyle.height.value != null)
          ? parentConstraints.maxHeight - verticalBorderLength - verticalPaddingLength
          : 0,
      maxHeight: double.infinity,
    );
    if (parent is RenderFlexLayout) {
      constraints = BoxConstraints(
        minWidth: 0,
        maxWidth: double.infinity,
        minHeight: 0,
        maxHeight: double.infinity,
      );
    }

    if (enableWebFProfileTracking) {
      WebFProfiler.instance.finishTrackLayoutStep();
    }

    return constraints;
  }

  CSSDisplay? effectiveDisplay = renderStyle.effectiveDisplay;
  bool isDisplayInline = effectiveDisplay == CSSDisplay.inline;

  double? minWidth = renderStyle.minWidth.isAuto ? null : renderStyle.minWidth.computedValue;
  double? maxWidth = renderStyle.maxWidth.isNone ? null : renderStyle.maxWidth.computedValue;
  double? minHeight = renderStyle.minHeight.isAuto ? null : renderStyle.minHeight.computedValue;
  double? maxHeight = renderStyle.maxHeight.isNone ? null : renderStyle.maxHeight.computedValue;

  // Need to calculated logic content size on every layout.
  renderStyle.computeContentBoxLogicalWidth();
  renderStyle.computeContentBoxLogicalHeight();

  // Width should be not smaller than border and padding in horizontal direction
  // when box-sizing is border-box which is only supported.
  double minConstraintWidth = renderStyle.effectiveBorderLeftWidth.computedValue +
      renderStyle.effectiveBorderRightWidth.computedValue +
      renderStyle.paddingLeft.computedValue +
      renderStyle.paddingRight.computedValue;

  double? parentBoxContentConstraintsWidth;
  if (parent is RenderBoxModel && this is RenderLayoutBox) {
    RenderBoxModel parentRenderBoxModel = (parent as RenderBoxModel);
    parentBoxContentConstraintsWidth = parentRenderBoxModel.renderStyle.deflateMarginConstraints(parentRenderBoxModel.contentConstraints!).maxWidth;

    // When inner minimal content size are larger that parent's constraints.
    if (parentBoxContentConstraintsWidth < minConstraintWidth) {
      parentBoxContentConstraintsWidth = null;
    }

    // FlexItems with flex:none won't inherit parent box's constraints
    if (parent is RenderFlexLayout && (parent as RenderFlexLayout).isFlexNone(this)) {
      parentBoxContentConstraintsWidth = null;
    }
  }

  double maxConstraintWidth = renderStyle.borderBoxLogicalWidth ?? parentBoxContentConstraintsWidth ?? double.infinity;
  // Height should be not smaller than border and padding in vertical direction
  // when box-sizing is border-box which is only supported.
  double minConstraintHeight = renderStyle.effectiveBorderTopWidth.computedValue +
      renderStyle.effectiveBorderBottomWidth.computedValue +
      renderStyle.paddingTop.computedValue +
      renderStyle.paddingBottom.computedValue;
  double maxConstraintHeight = renderStyle.borderBoxLogicalHeight ?? double.infinity;

  if (parent is RenderFlexLayout) {
    double? flexBasis = renderStyle.flexBasis == CSSLengthValue.auto ? null : renderStyle.flexBasis?.computedValue;
    RenderBoxModel? parentRenderBoxModel = parent as RenderBoxModel?;
    // In flex layout, flex basis takes priority over width/height if set.
    // Flex-basis cannot be smaller than its content size which happens can not be known
    // in constraints apply stage, so flex-basis acts as min-width in constraints apply stage.
    if (flexBasis != null) {
      if (CSSFlex.isHorizontalFlexDirection(parentRenderBoxModel!.renderStyle.flexDirection)) {
        minWidth = minWidth != null ? math.max(flexBasis, minWidth) : flexBasis;
      } else {
        minHeight = minHeight != null ? math.max(flexBasis, minHeight) : flexBasis;
      }
    }
  }

  // Clamp constraints by min/max size when display is not inline.
  if (!isDisplayInline) {
    if (minWidth != null) {
      minConstraintWidth = minConstraintWidth < minWidth ? minWidth : minConstraintWidth;
      maxConstraintWidth = maxConstraintWidth < minWidth ? minWidth : maxConstraintWidth;
    }
    if (maxWidth != null) {
      minConstraintWidth = minConstraintWidth > maxWidth ? maxWidth : minConstraintWidth;
      maxConstraintWidth = maxConstraintWidth > maxWidth ? maxWidth : maxConstraintWidth;
    }
    if (minHeight != null) {
      minConstraintHeight = minConstraintHeight < minHeight ? minHeight : minConstraintHeight;
      maxConstraintHeight = maxConstraintHeight < minHeight ? minHeight : maxConstraintHeight;
    }
    if (maxHeight != null) {
      minConstraintHeight = minConstraintHeight > maxHeight ? maxHeight : minConstraintHeight;
      maxConstraintHeight = maxConstraintHeight > maxHeight ? maxHeight : maxConstraintHeight;
    }
  }

  BoxConstraints constraints = BoxConstraints(
    minWidth: minConstraintWidth,
    maxWidth: maxConstraintWidth,
    minHeight: minConstraintHeight,
    maxHeight: maxConstraintHeight,
  );

  if (enableWebFProfileTracking) {
    WebFProfiler.instance.finishTrackLayoutStep();
  }

  return constraints;
}