make all computeMax(Min)IntrinsicHeight(Width) methods to "internal override"

com.unity.uiwidgets/Runtime/cupertino/action_Sheet.cs

             return value;
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             float contentHeight = contentSection.getMinIntrinsicHeight(width);
             float actionsHeight = actionsSection.getMinIntrinsicHeight(width);
             bool hasDivider = contentHeight > 0.0f && actionsHeight > 0.0f;
             }
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             if (childCount == 0) {
                 return 0.0f;
             }

com.unity.uiwidgets/Runtime/cupertino/dialog.cs

             return value;
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             float contentHeight = contentSection.getMinIntrinsicHeight(width);
             float actionsHeight = actionsSection.getMinIntrinsicHeight(width);
             bool hasDivider = contentHeight > 0.0f && actionsHeight > 0.0f;
             }
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             float minHeight;
             if (childCount == 0) {
                 minHeight = 0.0f;

com.unity.uiwidgets/Runtime/rendering/box.cs

             return _computeIntrinsicDimension(_IntrinsicDimension.minWidth, height, computeMinIntrinsicWidth);
         }
 
-        protected virtual float computeMinIntrinsicWidth(float height) {
+        protected internal virtual float computeMinIntrinsicWidth(float height) {
             return 0.0f;
         }
 
             return _computeIntrinsicDimension(_IntrinsicDimension.maxWidth, height, computeMaxIntrinsicWidth);
         }
 
-        protected virtual float computeMaxIntrinsicWidth(float height) {
+        protected internal virtual float computeMaxIntrinsicWidth(float height) {
             return 0.0f;
         }
 
                 computeMinIntrinsicHeight);
         }
 
-        protected virtual float computeMinIntrinsicHeight(float width) {
+        protected internal virtual float computeMinIntrinsicHeight(float width) {
             return 0.0f;
         }
 

com.unity.uiwidgets/Runtime/rendering/custom_layout.cs

             return constraints.constrain(_delegate.getSize(constraints));
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
             float width = _getSize(BoxConstraints.tightForFinite(height: height)).width;
             if (width.isFinite()) {
                 return width;
         }
 
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             float width = _getSize(BoxConstraints.tightForFinite(height: height)).width;
             if (width.isFinite()) {
                 return width;
         }
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             float height = _getSize(BoxConstraints.tightForFinite(width: width)).height;
             if (height.isFinite()) {
                 return height;

com.unity.uiwidgets/Runtime/rendering/editable.cs

             return rect.shift(_getPixelPerfectCursorOffset(rect));
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             _layoutText(float.PositiveInfinity);
             return _textPainter.maxIntrinsicWidth + cursorWidth;
         }
             return Mathf.Max(preferredLineHeight, _textPainter.height);
         }
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             return _preferredHeight(width);
         }
 

com.unity.uiwidgets/Runtime/rendering/error.cs

         string message;
         Paragraph _paragraph;
 
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             return rendering_._kMaxWidth;
         }
 

com.unity.uiwidgets/Runtime/rendering/flex.cs

             }
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
             return _getIntrinsicSize(
                 sizingDirection: Axis.horizontal,
                 extent: height,
 
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             return _getIntrinsicSize(
                 sizingDirection: Axis.horizontal,
                 extent: height,
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             return _getIntrinsicSize(
                 sizingDirection: Axis.vertical,
                 extent: width,

com.unity.uiwidgets/Runtime/rendering/image.cs

             ));
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
             D.assert(height >= 0.0);
             if (_width == null && _height == null) {
                 return 0.0f;
         }
 
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             D.assert(width >= 0.0);
             if (_width == null && _height == null) {
                 return 0.0f;

com.unity.uiwidgets/Runtime/rendering/list_body.cs

         }
 
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
             switch (mainAxis) {
                 case Axis.horizontal:
                     return _getIntrinsicMainAxis((RenderBox child) => child.getMinIntrinsicWidth(height));
         }
 
 
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             switch (mainAxis) {
                 case Axis.horizontal:
                     return _getIntrinsicMainAxis((RenderBox child) => child.getMaxIntrinsicWidth(height));
         }
 
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             switch (mainAxis) {
                 case Axis.horizontal:
                     return _getIntrinsicMainAxis((RenderBox child) => child.getMinIntrinsicHeight(width));

com.unity.uiwidgets/Runtime/rendering/list_wheel_viewport.cs

             return extent;
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             if (childManager.childCount == null) {
                 return 0.0f;
             }

com.unity.uiwidgets/Runtime/rendering/lottie.cs

             return constraints.smallest;
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
             D.assert(height >= 0.0);
             if (_width == null && _height == null) {
                 return 0.0f;
         }
 
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             D.assert(width >= 0.0);
             if (_width == null && _height == null) {
                 return 0.0f;

com.unity.uiwidgets/Runtime/rendering/paragraph.cs

             get { return _textPainter.size; }
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             _layoutText();
             return _textPainter.maxIntrinsicWidth;
         }
             return _textPainter.height;
         }
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             return _computeIntrinsicHeight(width);
         }
 

com.unity.uiwidgets/Runtime/rendering/performance_overlay.cs

             get { return true; }
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             return 0.0f;
         }
 
             }
         }
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             return _intrinsicHeight;
         }
 

com.unity.uiwidgets/Runtime/rendering/proxy_box.cs

 
         BoxConstraints _additionalConstraints;
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
             if (_additionalConstraints.hasBoundedWidth && _additionalConstraints.hasTightWidth) {
                 return _additionalConstraints.minWidth;
             }
             return width;
         }
 
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             if (_additionalConstraints.hasBoundedWidth && _additionalConstraints.hasTightWidth) {
                 return _additionalConstraints.minWidth;
             }
             return width;
         }
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             if (_additionalConstraints.hasBoundedHeight && _additionalConstraints.hasTightHeight) {
                 return _additionalConstraints.minHeight;
             }
         float _aspectRatio;
 
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
             if (height.isFinite()) {
                 return height * _aspectRatio;
             }
             return 0.0f;
         }
 
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             if (height.isFinite()) {
                 return height * _aspectRatio;
             }
             return 0.0f;
         }
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             if (width.isFinite()) {
                 return width / _aspectRatio;
             }
             return (input / step.Value).ceil() * step.Value;
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             if (child == null) {
                 return 0.0f;
             }
         }
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             if (child == null) {
                 return 0.0f;
             }
         ) : base(child) {
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
             if (child == null) {
                 return 0.0f;
             }
             return child.getMinIntrinsicWidth(height);
         }
 
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             if (child == null) {
                 return 0.0f;
             }
             return child.getMaxIntrinsicWidth(height);
         }
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             return computeMaxIntrinsicHeight(width);
         }
 
 
         bool _offstage;
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
             if (offstage) {
                 return 0.0f;
             }
 
 
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             if (offstage) {
                 return 0.0f;
             }
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             if (offstage) {
                 return 0.0f;
             }

com.unity.uiwidgets/Runtime/rendering/proxy_box.mixin.gen.cs

             }
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
             if (child != null) {
                 return child.getMinIntrinsicWidth(height);
             }
 
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             if (child != null) {
                 return child.getMaxIntrinsicWidth(height);
             }
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             if (child != null) {
                 return child.getMinIntrinsicHeight(width);
             }

com.unity.uiwidgets/Runtime/rendering/proxy_box.mixin.njk

             }
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
             if (this.child != null) {
                 return this.child.getMinIntrinsicWidth(height);
             }
 
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             if (this.child != null) {
                 return this.child.getMaxIntrinsicWidth(height);
             }
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             if (this.child != null) {
                 return this.child.getMinIntrinsicHeight(width);
             }

com.unity.uiwidgets/Runtime/rendering/rotated_box.cs

             get { return quarterTurns % 2 == 1; }
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
             if (child == null) {
                 return 0.0f;
             }
                 : child.getMinIntrinsicWidth(height);
         }
 
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             if (child == null) {
                 return 0.0f;
             }
                 : child.getMaxIntrinsicWidth(height);
         }
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             if (child == null) {
                 return 0.0f;
             }

com.unity.uiwidgets/Runtime/rendering/shifted_box.cs

             this.child = child;
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
             if (child != null) {
                 return child.getMinIntrinsicWidth(height);
             }
 
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             if (child != null) {
                 return child.getMaxIntrinsicWidth(height);
             }
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             if (child != null) {
                 return child.getMinIntrinsicHeight(width);
             }
 
         EdgeInsets _padding;
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
             if (child != null) {
                 return child.getMinIntrinsicWidth(Mathf.Max(0.0f, height - _padding.vertical)) +
                        _padding.horizontal;
         }
 
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             if (child != null) {
                 return child.getMaxIntrinsicWidth(Mathf.Max(0.0f, height - _padding.vertical)) +
                        _padding.horizontal;
         }
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             if (child != null) {
                 return child.getMinIntrinsicHeight(Mathf.Max(0.0f, width - _padding.horizontal)) +
                        _padding.vertical;
 
         public Size _requestedSize;
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             return _requestedSize.height;
         }
 
             );
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
             float result;
             if (child == null) {
                 result = base.computeMinIntrinsicWidth(height);
             return result / (_widthFactor ?? 1.0f);
         }
 
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             float result;
             if (child == null) {
                 result = base.computeMaxIntrinsicWidth(height);
             return result / (_widthFactor ?? 1.0f);
         }
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             float result;
             if (child == null) {
                 result = base.computeMinIntrinsicHeight(width);
         }
 
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
             float width = _getSize(BoxConstraints.tightForFinite(height: height)).width;
             if (width.isFinite()) {
                 return width;
         }
 
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             float width = _getSize(BoxConstraints.tightForFinite(height: height)).width;
             if (width.isFinite()) {
                 return width;
         }
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             float height = _getSize(BoxConstraints.tightForFinite(width: width)).height;
             if (height.isFinite()) {
                 return height;

com.unity.uiwidgets/Runtime/rendering/stack.cs

             return extent;
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             return _getIntrinsicDimension((RenderBox child) => child.getMinIntrinsicHeight(width));
         }
 

com.unity.uiwidgets/Runtime/rendering/table.cs

             }
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
             D.assert(_children.Count == rows * columns);
             float totalMinWidth = 0.0f;
             for (int x = 0; x < columns; x++) {
             return totalMinWidth;
         }
 
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             D.assert(_children.Count == rows * columns);
             float totalMaxWidth = 0.0f;
             for (int x = 0; x < columns; x++) {
             return totalMaxWidth;
         }
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             D.assert(_children.Count == rows * columns);
             List<float> widths = _computeColumnWidths(BoxConstraints.tightForFinite(width: width));
             float rowTop = 0.0f;

com.unity.uiwidgets/Runtime/rendering/viewport.cs

             return true;
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             D.assert(debugThrowIfNotCheckingIntrinsics());
             return 0.0f;
         }

com.unity.uiwidgets/Runtime/rendering/wrap.cs

             return width;
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
             switch (direction) {
                 case Axis.horizontal:
                     float width = 0.0f;
             throw new Exception("Unknown axis: " + direction);
         }
 
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             switch (direction) {
                 case Axis.horizontal:
                     float width = 0.0f;
             throw new Exception("Unknown axis: " + direction);
         }
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             switch (direction) {
                 case Axis.horizontal:
                     return _computeIntrinsicHeightForWidth(width);

com.unity.uiwidgets/Runtime/widgets/layout_builder.cs

             return true;
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             D.assert(_debugThrowIfNotCheckingIntrinsics());
             return 0.0f;
         }

com.unity.uiwidgets/Runtime/widgets/overlay.cs

             get { return childCount - skipCount; }
         }
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             return RenderStack.getIntrinsicDimension(_firstOnstageChild,
                 (RenderBox child) => child.getMinIntrinsicHeight(width));
         }

com.unity.uiwidgets/Runtime/widgets/single_child_scroll_view.cs

         }
 
 
-        protected override float computeMinIntrinsicWidth(float height) {
+        protected internal override float computeMinIntrinsicWidth(float height) {
             if (child != null) {
                 return child.getMinIntrinsicWidth(height);
             }
 
-        protected override float computeMaxIntrinsicWidth(float height) {
+        protected internal override float computeMaxIntrinsicWidth(float height) {
             if (child != null) {
                 return child.getMaxIntrinsicWidth(height);
             }
 
-        protected override float computeMinIntrinsicHeight(float width) {
+        protected internal override float computeMinIntrinsicHeight(float width) {
             if (child != null) {
                 return child.getMinIntrinsicHeight(width);
             }