mirror of
https://github.com/KevinMidboe/linguist.git
synced 2025-10-29 17:50:22 +00:00
1326 lines
59 KiB
ReasonML
1326 lines
59 KiB
ReasonML
/**
|
|
* Copyright (c) 2014, Facebook, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This source code is licensed under the BSD-style license found in the
|
|
* LICENSE file in the root directory of this source tree. An additional grant
|
|
* of patent rights can be found in the PATENTS file in the same directory.
|
|
*/
|
|
/*
|
|
* From css-layout comments:
|
|
* The spec describes four different layout modes: "fill available", "max
|
|
* content", "min content", and "fit content". Of these, we don't use
|
|
* "min content" because we don't support default minimum main sizes (see
|
|
* above for details). Each of our measure modes maps to a layout mode
|
|
* from the spec (https://www.w3.org/TR/css3-sizing/#terms):
|
|
*
|
|
* -.CssMeasureModeUndefined: `max-content`
|
|
* -.CssMeasureModeExactly: `fill-available`
|
|
* -.CssMeasureModeAtMost: `fit-content`
|
|
* If infinite space available in that axis, then `max-content.`
|
|
* Else, `min(max-content size, max(min-content size, fill-available size))`
|
|
* (Although, we don't support min-content)
|
|
*/
|
|
open LayoutTypes;
|
|
|
|
open LayoutValue;
|
|
|
|
open LayoutSupport;
|
|
|
|
let gCurrentGenerationCount = ref 0;
|
|
|
|
let gDepth = ref 0;
|
|
|
|
let gPrintTree = {contents: false};
|
|
|
|
let gPrintChanges = {contents: false};
|
|
|
|
let gPrintSkips = {contents: false};
|
|
|
|
let measureString = "measure";
|
|
|
|
let stretchString = "stretch";
|
|
|
|
let absMeasureString = "abs-measure";
|
|
|
|
let absLayoutString = "abs-layout";
|
|
|
|
let initialString = "initial";
|
|
|
|
let flexString = "flex";
|
|
|
|
let spacer = " ";
|
|
|
|
let getSpacer level => {
|
|
let spacerLen = String.length spacer;
|
|
let lvl = level > spacerLen ? level : spacerLen;
|
|
String.sub spacer lvl (String.length spacer)
|
|
};
|
|
|
|
let getModeName (mode, isLayoutInsteadOfMeasure) =>
|
|
switch mode {
|
|
| CSS_MEASURE_MODE_NEGATIVE_ONE_WHATEVER_THAT_MEANS =>
|
|
isLayoutInsteadOfMeasure ?
|
|
"CSS_MEASURE_MODE_NEGATIVE_ONE_WHATEVER_THAT_MEANS" :
|
|
"CSS_MEASURE_MODE_NEGATIVE_ONE_WHATEVER_THAT_MEANS"
|
|
| CssMeasureModeUndefined => isLayoutInsteadOfMeasure ? "LAY_UNDEFINED" : "UNDEFINED"
|
|
| CssMeasureModeExactly => isLayoutInsteadOfMeasure ? "LAY_EXACTLY" : "EXACTLY"
|
|
| CssMeasureModeAtMost => isLayoutInsteadOfMeasure ? "LAY_AT_MOST" : "AT_MOST"
|
|
};
|
|
|
|
let canUseCachedMeasurement
|
|
(
|
|
availableWidth,
|
|
availableHeight,
|
|
marginRow,
|
|
marginColumn,
|
|
widthMeasureMode,
|
|
heightMeasureMode,
|
|
cachedLayout
|
|
) =>
|
|
if (
|
|
cachedLayout.availableWidth == availableWidth &&
|
|
cachedLayout.availableHeight == availableHeight &&
|
|
cachedLayout.widthMeasureMode == widthMeasureMode && cachedLayout.heightMeasureMode == heightMeasureMode
|
|
) {
|
|
true
|
|
} else if
|
|
/* Is it an exact match?*/
|
|
/* If the width is an exact match, try a fuzzy match on the height.*/
|
|
(
|
|
cachedLayout.widthMeasureMode == widthMeasureMode &&
|
|
cachedLayout.availableWidth == availableWidth &&
|
|
heightMeasureMode === CssMeasureModeExactly &&
|
|
availableHeight -. marginColumn == cachedLayout.computedHeight
|
|
) {
|
|
true
|
|
} else if
|
|
/* If the height is an exact match, try a fuzzy match on the width.*/
|
|
(
|
|
cachedLayout.heightMeasureMode == heightMeasureMode &&
|
|
cachedLayout.availableHeight == availableHeight &&
|
|
widthMeasureMode === CssMeasureModeExactly && availableWidth -. marginRow == cachedLayout.computedWidth
|
|
) {
|
|
true
|
|
} else {
|
|
false
|
|
};
|
|
|
|
let cachedMeasurementAt layout i =>
|
|
switch i {
|
|
| 0 => layout.cachedMeasurement1
|
|
| 1 => layout.cachedMeasurement2
|
|
| 2 => layout.cachedMeasurement3
|
|
| 3 => layout.cachedMeasurement4
|
|
| 4 => layout.cachedMeasurement5
|
|
| 5 => layout.cachedMeasurement6
|
|
| _ => raise (Invalid_argument ("No cached measurement at " ^ string_of_int i))
|
|
};
|
|
|
|
|
|
/**
|
|
* This is a wrapper around the layoutNodeImpl function. It determines
|
|
* whether the layout request is redundant and can be skipped.
|
|
*
|
|
* Parameters:
|
|
* Input parameters are the same as layoutNodeImpl (see above)
|
|
* Return parameter is true if layout was performed, false if skipped
|
|
*/
|
|
let rec layoutNodeInternal
|
|
node
|
|
availableWidth
|
|
availableHeight
|
|
parentDirection
|
|
widthMeasureMode
|
|
heightMeasureMode
|
|
performLayout
|
|
reason => {
|
|
let layout = node.layout;
|
|
gDepth.contents = gDepth.contents + 1;
|
|
let needToVisitNode =
|
|
node.isDirty node.context && layout.generationCount != gCurrentGenerationCount.contents ||
|
|
layout.lastParentDirection != parentDirection;
|
|
if needToVisitNode {
|
|
/* Invalidate the cached results.*/
|
|
layout.nextCachedMeasurementsIndex = 0;
|
|
layout.cachedLayout.widthMeasureMode = CSS_MEASURE_MODE_NEGATIVE_ONE_WHATEVER_THAT_MEANS;
|
|
layout.cachedLayout.heightMeasureMode = CSS_MEASURE_MODE_NEGATIVE_ONE_WHATEVER_THAT_MEANS
|
|
};
|
|
let cachedResults = ref None;
|
|
/* Determine whether the results are already cached. We maintain a separate*/
|
|
/* cache for layouts and measurements. A layout operation modifies the positions*/
|
|
/* and dimensions for nodes in the subtree. The algorithm assumes that each node*/
|
|
/* gets layed out a maximum of one time per tree layout, but multiple measurements*/
|
|
/* may be required to resolve all of the flex dimensions.*/
|
|
/* We handle nodes with measure functions specially here because they are the most
|
|
* expensive to measure, so it's worth avoiding redundant measurements if at all possible.*/
|
|
if (node.measure !== dummyMeasure && node.childrenCount === 0) {
|
|
let marginAxisRow = getMarginAxis node CssFlexDirectionRow;
|
|
let marginAxisColumn = getMarginAxis node CssFlexDirectionColumn;
|
|
/* First, try to use the layout cache.*/
|
|
if (
|
|
canUseCachedMeasurement (
|
|
availableWidth,
|
|
availableHeight,
|
|
marginAxisRow,
|
|
marginAxisColumn,
|
|
widthMeasureMode,
|
|
heightMeasureMode,
|
|
layout.cachedLayout
|
|
)
|
|
) {
|
|
cachedResults.contents = Some layout.cachedLayout
|
|
} else {
|
|
/* Try to use the measurement cache.*/
|
|
let foundCached = {contents: false};
|
|
for i in 0 to (layout.nextCachedMeasurementsIndex - 1) {
|
|
/* This is basically the "break" */
|
|
if (not foundCached.contents) {
|
|
let cachedMeasurementAtIndex = cachedMeasurementAt layout i;
|
|
if (
|
|
canUseCachedMeasurement (
|
|
availableWidth,
|
|
availableHeight,
|
|
marginAxisRow,
|
|
marginAxisColumn,
|
|
widthMeasureMode,
|
|
heightMeasureMode,
|
|
cachedMeasurementAtIndex
|
|
)
|
|
) {
|
|
cachedResults.contents = Some cachedMeasurementAtIndex;
|
|
foundCached.contents = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if performLayout {
|
|
if (
|
|
layout.cachedLayout.availableWidth == availableWidth &&
|
|
layout.cachedLayout.availableHeight == availableHeight &&
|
|
layout.cachedLayout.widthMeasureMode == widthMeasureMode &&
|
|
layout.cachedLayout.heightMeasureMode == heightMeasureMode
|
|
) {
|
|
cachedResults.contents = Some layout.cachedLayout
|
|
}
|
|
} else {
|
|
let foundCached = {contents: false};
|
|
for i in 0 to (layout.nextCachedMeasurementsIndex - 1) {
|
|
/* This is basically the "break" */
|
|
if (not foundCached.contents) {
|
|
let cachedMeasurementAtIndex = cachedMeasurementAt layout i;
|
|
if (
|
|
cachedMeasurementAtIndex.availableWidth == availableWidth &&
|
|
cachedMeasurementAtIndex.availableHeight == availableHeight &&
|
|
cachedMeasurementAtIndex.widthMeasureMode == widthMeasureMode &&
|
|
cachedMeasurementAtIndex.heightMeasureMode == heightMeasureMode
|
|
) {
|
|
cachedResults.contents = Some cachedMeasurementAtIndex;
|
|
foundCached.contents = true
|
|
}
|
|
}
|
|
}
|
|
};
|
|
if (not needToVisitNode && cachedResults.contents != None) {
|
|
let cachedResults_ =
|
|
switch cachedResults.contents {
|
|
| None => raise (Invalid_argument "Not possible")
|
|
| Some cr => cr
|
|
};
|
|
layout.measuredWidth = cachedResults_.computedWidth;
|
|
layout.measuredHeight = cachedResults_.computedHeight;
|
|
if (gPrintChanges.contents && gPrintSkips.contents) {
|
|
Printf.printf "%s%d.{[skipped] " (getSpacer gDepth.contents) gDepth.contents;
|
|
switch node.print {
|
|
| None => ()
|
|
| Some printer => printer node.context
|
|
};
|
|
Printf.printf
|
|
"wm: %s, hm: %s, aw: %s ah: %s => d: (%s, %s) %s\n"
|
|
(getModeName (widthMeasureMode, performLayout))
|
|
(getModeName (heightMeasureMode, performLayout))
|
|
(scalarToString availableWidth)
|
|
(scalarToString availableHeight)
|
|
(scalarToString cachedResults_.computedWidth)
|
|
(scalarToString cachedResults_.computedHeight)
|
|
reason
|
|
}
|
|
} else {
|
|
if gPrintChanges.contents {
|
|
Printf.printf "%s%d.{%s" (getSpacer gDepth.contents) gDepth.contents (needToVisitNode ? "*" : "");
|
|
switch node.print {
|
|
| None => ()
|
|
| Some printer => printer node.context
|
|
};
|
|
Printf.printf
|
|
"wm: %s, hm: %s, aw: %s ah: %s %s\n"
|
|
(getModeName (widthMeasureMode, performLayout))
|
|
(getModeName (heightMeasureMode, performLayout))
|
|
(scalarToString availableWidth)
|
|
(scalarToString availableHeight)
|
|
reason
|
|
};
|
|
layoutNodeImpl (
|
|
node,
|
|
availableWidth,
|
|
availableHeight,
|
|
parentDirection,
|
|
widthMeasureMode,
|
|
heightMeasureMode,
|
|
performLayout
|
|
);
|
|
if gPrintChanges.contents {
|
|
Printf.printf "%s%d.}%s" (getSpacer gDepth.contents) gDepth.contents (needToVisitNode ? "*" : "");
|
|
switch node.print {
|
|
| None => ()
|
|
| Some printer => printer node.context
|
|
};
|
|
Printf.printf
|
|
"wm: %s, hm: %s, d: (%s, %s) %s\n"
|
|
(getModeName (widthMeasureMode, performLayout))
|
|
(getModeName (heightMeasureMode, performLayout))
|
|
(scalarToString layout.measuredWidth)
|
|
(scalarToString layout.measuredHeight)
|
|
reason
|
|
};
|
|
layout.lastParentDirection = parentDirection;
|
|
if (cachedResults.contents === None) {
|
|
if (layout.nextCachedMeasurementsIndex == css_max_cached_result_count) {
|
|
if gPrintChanges.contents {
|
|
Printf.printf "Out of cache entries!\n"
|
|
};
|
|
layout.nextCachedMeasurementsIndex = 0
|
|
};
|
|
let newCacheEntry =
|
|
performLayout ?
|
|
/* Use the single layout cache entry.*/
|
|
layout.cachedLayout :
|
|
{
|
|
/* Allocate a new measurement cache entry.*/
|
|
let newCacheEntry_ = cachedMeasurementAt layout layout.nextCachedMeasurementsIndex;
|
|
layout.nextCachedMeasurementsIndex = layout.nextCachedMeasurementsIndex + 1;
|
|
newCacheEntry_
|
|
};
|
|
newCacheEntry.availableWidth = availableWidth;
|
|
newCacheEntry.availableHeight = availableHeight;
|
|
newCacheEntry.widthMeasureMode = widthMeasureMode;
|
|
newCacheEntry.heightMeasureMode = heightMeasureMode;
|
|
newCacheEntry.computedWidth = layout.measuredWidth;
|
|
newCacheEntry.computedHeight = layout.measuredHeight
|
|
}
|
|
};
|
|
if performLayout {
|
|
node.layout.width = node.layout.measuredWidth;
|
|
node.layout.height = node.layout.measuredHeight;
|
|
layout.hasNewLayout = true
|
|
};
|
|
gDepth.contents = gDepth.contents - 1;
|
|
layout.generationCount = gCurrentGenerationCount.contents;
|
|
needToVisitNode || cachedResults.contents === None
|
|
}
|
|
and computeChildFlexBasis node child width widthMode height heightMode direction => {
|
|
let mainAxis = resolveAxis node.style.flexDirection direction;
|
|
let isMainAxisRow = isRowDirection mainAxis;
|
|
let childWidth = {contents: zero};
|
|
let childHeight = {contents: zero};
|
|
let childWidthMeasureMode = {contents: CssMeasureModeUndefined};
|
|
let childHeightMeasureMode = {contents: CssMeasureModeUndefined};
|
|
if (isMainAxisRow && isStyleDimDefined child.contents CssFlexDirectionRow) {
|
|
child.contents.layout.computedFlexBasis =
|
|
fmaxf child.contents.style.width (getPaddingAndBorderAxis child.contents CssFlexDirectionRow)
|
|
} else if (
|
|
not isMainAxisRow && isStyleDimDefined child.contents CssFlexDirectionColumn
|
|
) {
|
|
child.contents.layout.computedFlexBasis =
|
|
fmaxf child.contents.style.height (getPaddingAndBorderAxis child.contents CssFlexDirectionColumn)
|
|
} else if (
|
|
not (isUndefined child.contents.style.flexBasis)
|
|
) {
|
|
if (isUndefined child.contents.layout.computedFlexBasis) {
|
|
child.contents.layout.computedFlexBasis =
|
|
fmaxf child.contents.style.flexBasis (getPaddingAndBorderAxis child.contents mainAxis)
|
|
}
|
|
} else {
|
|
childWidth.contents = cssUndefined;
|
|
childHeight.contents = cssUndefined;
|
|
childWidthMeasureMode.contents = CssMeasureModeUndefined;
|
|
childHeightMeasureMode.contents = CssMeasureModeUndefined;
|
|
if (isStyleDimDefined child.contents CssFlexDirectionRow) {
|
|
childWidth.contents = child.contents.style.width +. getMarginAxis child.contents CssFlexDirectionRow;
|
|
childWidthMeasureMode.contents = CssMeasureModeExactly
|
|
};
|
|
|
|
/**
|
|
* Why can't this just be inlined to .height !== cssUndefined.
|
|
*/
|
|
if (isStyleDimDefined child.contents CssFlexDirectionColumn) {
|
|
childHeight.contents =
|
|
child.contents.style.height +. getMarginAxis child.contents CssFlexDirectionColumn;
|
|
childHeightMeasureMode.contents = CssMeasureModeExactly
|
|
};
|
|
if (not isMainAxisRow && node.style.overflow === Scroll || node.style.overflow !== Scroll) {
|
|
if (isUndefined childWidth.contents && not (isUndefined width)) {
|
|
childWidth.contents = width;
|
|
childWidthMeasureMode.contents = CssMeasureModeAtMost
|
|
}
|
|
};
|
|
if (isMainAxisRow && node.style.overflow === Scroll || node.style.overflow !== Scroll) {
|
|
if (isUndefined childHeight.contents && not (isUndefined height)) {
|
|
childHeight.contents = height;
|
|
childHeightMeasureMode.contents = CssMeasureModeAtMost
|
|
}
|
|
};
|
|
/*
|
|
* If child has no defined size in the cross axis and is set to
|
|
* stretch, set the cross axis to be measured exactly with the
|
|
* available inner width.
|
|
*/
|
|
if (
|
|
not isMainAxisRow &&
|
|
not (isUndefined width) &&
|
|
not (isStyleDimDefined child.contents CssFlexDirectionRow) &&
|
|
widthMode === CssMeasureModeExactly && getAlignItem node child.contents === CssAlignStretch
|
|
) {
|
|
childWidth.contents = width;
|
|
childWidthMeasureMode.contents = CssMeasureModeExactly
|
|
};
|
|
if (
|
|
isMainAxisRow &&
|
|
not (isUndefined height) &&
|
|
not (isStyleDimDefined child.contents CssFlexDirectionColumn) &&
|
|
heightMode === CssMeasureModeExactly && getAlignItem node child.contents === CssAlignStretch
|
|
) {
|
|
childHeight.contents = height;
|
|
childHeightMeasureMode.contents = CssMeasureModeExactly
|
|
};
|
|
let _ =
|
|
layoutNodeInternal
|
|
child.contents
|
|
childWidth.contents
|
|
childHeight.contents
|
|
direction
|
|
childWidthMeasureMode.contents
|
|
childHeightMeasureMode.contents
|
|
false
|
|
measureString;
|
|
child.contents.layout.computedFlexBasis =
|
|
fmaxf
|
|
(isMainAxisRow ? child.contents.layout.measuredWidth : child.contents.layout.measuredHeight)
|
|
(getPaddingAndBorderAxis child.contents mainAxis)
|
|
}
|
|
}
|
|
/**
|
|
* By default, mathematical operations are floating point.
|
|
*/
|
|
and layoutNodeImpl
|
|
(
|
|
node,
|
|
availableWidth,
|
|
availableHeight,
|
|
parentDirection,
|
|
widthMeasureMode,
|
|
heightMeasureMode,
|
|
performLayout
|
|
) => {
|
|
|
|
/** START_GENERATED **/
|
|
/* re_assert */
|
|
/* (isUndefined availableWidth ? widthMeasureMode === CssMeasureModeUndefined : true) */
|
|
/* "availableWidth is indefinite so widthMeasureMode must be CssMeasureModeUndefined"; */
|
|
/* re_assert */
|
|
/* (isUndefined availableHeight ? heightMeasureMode === CssMeasureModeUndefined : true) */
|
|
/* "availableHeight is indefinite so heightMeasureMode must be CssMeasureModeUndefined"; */
|
|
let paddingAndBorderAxisRow = getPaddingAndBorderAxis node CssFlexDirectionRow;
|
|
let paddingAndBorderAxisColumn = getPaddingAndBorderAxis node CssFlexDirectionColumn;
|
|
let marginAxisRow = getMarginAxis node CssFlexDirectionRow;
|
|
let marginAxisColumn = getMarginAxis node CssFlexDirectionColumn;
|
|
let direction = resolveDirection node parentDirection;
|
|
node.layout.direction = direction;
|
|
/* For content (text) nodes, determine the dimensions based on the text
|
|
contents. */
|
|
if (node.measure !== dummyMeasure && node.childrenCount === 0) {
|
|
let innerWidth = availableWidth -. marginAxisRow -. paddingAndBorderAxisRow;
|
|
let innerHeight = availableHeight -. marginAxisColumn -. paddingAndBorderAxisColumn;
|
|
if (widthMeasureMode === CssMeasureModeExactly && heightMeasureMode === CssMeasureModeExactly) {
|
|
node.layout.measuredWidth = boundAxis node CssFlexDirectionRow (availableWidth -. marginAxisRow);
|
|
node.layout.measuredHeight =
|
|
boundAxis node CssFlexDirectionColumn (availableHeight -. marginAxisColumn)
|
|
} else if (
|
|
not (isUndefined innerWidth) && innerWidth <= zero ||
|
|
not (isUndefined innerHeight) && innerHeight <= zero
|
|
) {
|
|
node.layout.measuredWidth = boundAxis node CssFlexDirectionRow zero;
|
|
node.layout.measuredHeight = boundAxis node CssFlexDirectionColumn zero
|
|
} else {
|
|
let measureDim = node.measure node innerWidth widthMeasureMode innerHeight heightMeasureMode;
|
|
node.layout.measuredWidth =
|
|
boundAxis
|
|
node
|
|
CssFlexDirectionRow
|
|
(
|
|
widthMeasureMode === CssMeasureModeUndefined || widthMeasureMode === CssMeasureModeAtMost ?
|
|
measureDim.width +. paddingAndBorderAxisRow : availableWidth -. marginAxisRow
|
|
);
|
|
node.layout.measuredHeight =
|
|
boundAxis
|
|
node
|
|
CssFlexDirectionColumn
|
|
(
|
|
heightMeasureMode === CssMeasureModeUndefined || heightMeasureMode === CssMeasureModeAtMost ?
|
|
measureDim.height +. paddingAndBorderAxisColumn : availableHeight -. marginAxisColumn
|
|
)
|
|
}
|
|
} else {
|
|
let childCount = Array.length node.children;
|
|
if (childCount === 0) {
|
|
node.layout.measuredWidth =
|
|
boundAxis
|
|
node
|
|
CssFlexDirectionRow
|
|
(
|
|
widthMeasureMode === CssMeasureModeUndefined || widthMeasureMode === CssMeasureModeAtMost ?
|
|
paddingAndBorderAxisRow : availableWidth -. marginAxisRow
|
|
);
|
|
node.layout.measuredHeight =
|
|
boundAxis
|
|
node
|
|
CssFlexDirectionColumn
|
|
(
|
|
heightMeasureMode === CssMeasureModeUndefined || heightMeasureMode === CssMeasureModeAtMost ?
|
|
paddingAndBorderAxisColumn : availableHeight -. marginAxisColumn
|
|
)
|
|
} else {
|
|
let shouldContinue = {contents: true};
|
|
if (not performLayout) {
|
|
if (
|
|
(
|
|
(
|
|
widthMeasureMode === CssMeasureModeAtMost &&
|
|
not (isUndefined availableWidth) && availableWidth <= zero
|
|
) &&
|
|
heightMeasureMode === CssMeasureModeAtMost
|
|
) &&
|
|
not (isUndefined availableHeight) && availableHeight <= zero
|
|
) {
|
|
node.layout.measuredWidth = boundAxis node CssFlexDirectionRow zero;
|
|
node.layout.measuredHeight = boundAxis node CssFlexDirectionColumn zero;
|
|
shouldContinue.contents = false
|
|
} else if (
|
|
widthMeasureMode === CssMeasureModeAtMost &&
|
|
not (isUndefined availableWidth) && availableWidth <= zero
|
|
) {
|
|
node.layout.measuredWidth = boundAxis node CssFlexDirectionRow zero;
|
|
node.layout.measuredHeight =
|
|
boundAxis
|
|
node
|
|
CssFlexDirectionColumn
|
|
(isUndefined availableHeight ? zero : availableHeight -. marginAxisColumn);
|
|
shouldContinue.contents = false
|
|
} else if (
|
|
heightMeasureMode === CssMeasureModeAtMost &&
|
|
not (isUndefined availableHeight) && availableHeight <= zero
|
|
) {
|
|
node.layout.measuredWidth =
|
|
boundAxis
|
|
node CssFlexDirectionRow (isUndefined availableWidth ? zero : availableWidth -. marginAxisRow);
|
|
node.layout.measuredHeight = boundAxis node CssFlexDirectionColumn zero;
|
|
shouldContinue.contents = false
|
|
} else if (
|
|
widthMeasureMode === CssMeasureModeExactly && heightMeasureMode === CssMeasureModeExactly
|
|
) {
|
|
node.layout.measuredWidth = boundAxis node CssFlexDirectionRow (availableWidth -. marginAxisRow);
|
|
node.layout.measuredHeight =
|
|
boundAxis node CssFlexDirectionColumn (availableHeight -. marginAxisColumn);
|
|
shouldContinue.contents = false
|
|
}
|
|
};
|
|
if shouldContinue.contents {
|
|
let mainAxis = resolveAxis node.style.flexDirection direction;
|
|
let crossAxis = getCrossFlexDirection mainAxis direction;
|
|
let isMainAxisRow = isRowDirection mainAxis;
|
|
let justifyContent = node.style.justifyContent;
|
|
let isNodeFlexWrap = node.style.flexWrap === CssWrap;
|
|
let firstAbsoluteChild = {contents: theNullNode};
|
|
let currentAbsoluteChild = {contents: theNullNode};
|
|
let leadingPaddingAndBorderMain = getLeadingPaddingAndBorder node mainAxis;
|
|
let trailingPaddingAndBorderMain = getTrailingPaddingAndBorder node mainAxis;
|
|
let leadingPaddingAndBorderCross = getLeadingPaddingAndBorder node crossAxis;
|
|
let paddingAndBorderAxisMain = getPaddingAndBorderAxis node mainAxis;
|
|
let paddingAndBorderAxisCross = getPaddingAndBorderAxis node crossAxis;
|
|
let measureModeMainDim = isMainAxisRow ? widthMeasureMode : heightMeasureMode;
|
|
let measureModeCrossDim = isMainAxisRow ? heightMeasureMode : widthMeasureMode;
|
|
let availableInnerWidth = availableWidth -. marginAxisRow -. paddingAndBorderAxisRow;
|
|
let availableInnerHeight = availableHeight -. marginAxisColumn -. paddingAndBorderAxisColumn;
|
|
let availableInnerMainDim = isMainAxisRow ? availableInnerWidth : availableInnerHeight;
|
|
let availableInnerCrossDim = isMainAxisRow ? availableInnerHeight : availableInnerWidth;
|
|
let child = {contents: theNullNode};
|
|
/* let i = 0; */
|
|
/* STEP 3: DETERMINE FLEX BASIS FOR EACH ITEM */
|
|
for i in 0 to (childCount - 1) {
|
|
child.contents = node.children.(i);
|
|
if performLayout {
|
|
let childDirection = resolveDirection child.contents direction;
|
|
setPosition child.contents childDirection
|
|
};
|
|
if (child.contents.style.positionType === CssPositionAbsolute) {
|
|
if (firstAbsoluteChild.contents === theNullNode) {
|
|
firstAbsoluteChild.contents = child.contents
|
|
};
|
|
if (currentAbsoluteChild.contents !== theNullNode) {
|
|
currentAbsoluteChild.contents.nextChild = child.contents
|
|
};
|
|
currentAbsoluteChild.contents = child.contents;
|
|
child.contents.nextChild = theNullNode
|
|
} else {
|
|
computeChildFlexBasis
|
|
node
|
|
child
|
|
availableInnerWidth
|
|
widthMeasureMode
|
|
availableInnerHeight
|
|
heightMeasureMode
|
|
direction
|
|
}
|
|
};
|
|
/* STEP 4: COLLECT FLEX ITEMS INTO FLEX LINES */
|
|
let startOfLineIndex = {contents: 0};
|
|
let endOfLineIndex = {contents: 0};
|
|
let lineCount = {contents: 0};
|
|
let totalLineCrossDim = {contents: zero};
|
|
let maxLineMainDim = {contents: zero};
|
|
while (endOfLineIndex.contents < childCount) {
|
|
let itemsOnLine = {contents: 0};
|
|
let sizeConsumedOnCurrentLine = {contents: zero};
|
|
let totalFlexGrowFactors = {contents: zero};
|
|
let totalFlexShrinkScaledFactors = {contents: zero};
|
|
let curIndex = {contents: startOfLineIndex.contents};
|
|
let firstRelativeChild = {contents: theNullNode};
|
|
let currentRelativeChild = {contents: theNullNode};
|
|
let shouldContinue = {contents: true};
|
|
while (curIndex.contents < childCount && shouldContinue.contents) {
|
|
child.contents = node.children.(curIndex.contents);
|
|
child.contents.lineIndex = lineCount.contents;
|
|
if (child.contents.style.positionType !== CssPositionAbsolute) {
|
|
let outerFlexBasis =
|
|
child.contents.layout.computedFlexBasis +. getMarginAxis child.contents mainAxis;
|
|
if (
|
|
(
|
|
sizeConsumedOnCurrentLine.contents +. outerFlexBasis > availableInnerMainDim && isNodeFlexWrap
|
|
) &&
|
|
itemsOnLine.contents > 0
|
|
) {
|
|
shouldContinue.contents = false
|
|
} else {
|
|
sizeConsumedOnCurrentLine.contents = sizeConsumedOnCurrentLine.contents +. outerFlexBasis;
|
|
itemsOnLine.contents = itemsOnLine.contents + 1;
|
|
if (isFlex child.contents) {
|
|
totalFlexGrowFactors.contents =
|
|
totalFlexGrowFactors.contents +. child.contents.style.flexGrow;
|
|
totalFlexShrinkScaledFactors.contents =
|
|
totalFlexShrinkScaledFactors.contents +.
|
|
-. child.contents.style.flexShrink *. child.contents.layout.computedFlexBasis
|
|
};
|
|
if (firstRelativeChild.contents === theNullNode) {
|
|
firstRelativeChild.contents = child.contents
|
|
};
|
|
if (currentRelativeChild.contents !== theNullNode) {
|
|
currentRelativeChild.contents.nextChild = child.contents
|
|
};
|
|
currentRelativeChild.contents = child.contents;
|
|
child.contents.nextChild = theNullNode;
|
|
curIndex.contents = curIndex.contents + 1;
|
|
endOfLineIndex.contents = endOfLineIndex.contents + 1
|
|
}
|
|
} else {
|
|
curIndex.contents = curIndex.contents + 1;
|
|
endOfLineIndex.contents = endOfLineIndex.contents + 1
|
|
}
|
|
};
|
|
let canSkipFlex = not performLayout && measureModeCrossDim === CssMeasureModeExactly;
|
|
let leadingMainDim = {contents: zero};
|
|
let betweenMainDim = {contents: zero};
|
|
let remainingFreeSpace = {contents: zero};
|
|
if (not (isUndefined availableInnerMainDim)) {
|
|
remainingFreeSpace.contents = availableInnerMainDim -. sizeConsumedOnCurrentLine.contents
|
|
} else if (
|
|
sizeConsumedOnCurrentLine.contents < zero
|
|
) {
|
|
remainingFreeSpace.contents = -. sizeConsumedOnCurrentLine.contents
|
|
};
|
|
let originalRemainingFreeSpace = remainingFreeSpace.contents;
|
|
let deltaFreeSpace = {contents: zero};
|
|
if (not canSkipFlex) {
|
|
let childFlexBasis = {contents: zero};
|
|
let flexShrinkScaledFactor = {contents: zero};
|
|
let flexGrowFactor = {contents: zero};
|
|
let baseMainSize = {contents: zero};
|
|
let boundMainSize = {contents: zero};
|
|
let deltaFlexShrinkScaledFactors = {contents: zero};
|
|
let deltaFlexGrowFactors = {contents: zero};
|
|
currentRelativeChild.contents = firstRelativeChild.contents;
|
|
while (currentRelativeChild.contents !== theNullNode) {
|
|
childFlexBasis.contents = currentRelativeChild.contents.layout.computedFlexBasis;
|
|
if (remainingFreeSpace.contents < zero) {
|
|
flexShrinkScaledFactor.contents =
|
|
-. currentRelativeChild.contents.style.flexShrink *. childFlexBasis.contents;
|
|
if (flexShrinkScaledFactor.contents != zero) {
|
|
baseMainSize.contents =
|
|
childFlexBasis.contents +.
|
|
/*
|
|
* Important to first scale, then divide - to support fixed
|
|
* point encoding.
|
|
*/
|
|
flexShrinkScaledFactor.contents *. remainingFreeSpace.contents /.
|
|
totalFlexShrinkScaledFactors.contents;
|
|
boundMainSize.contents =
|
|
boundAxis currentRelativeChild.contents mainAxis baseMainSize.contents;
|
|
if (baseMainSize.contents != boundMainSize.contents) {
|
|
deltaFreeSpace.contents =
|
|
deltaFreeSpace.contents -. (boundMainSize.contents -. childFlexBasis.contents);
|
|
deltaFlexShrinkScaledFactors.contents =
|
|
deltaFlexShrinkScaledFactors.contents -. flexShrinkScaledFactor.contents
|
|
}
|
|
}
|
|
} else if (
|
|
remainingFreeSpace.contents > zero
|
|
) {
|
|
flexGrowFactor.contents = currentRelativeChild.contents.style.flexGrow;
|
|
if (flexGrowFactor.contents != zero) {
|
|
baseMainSize.contents =
|
|
childFlexBasis.contents +.
|
|
/*
|
|
* Important to first scale, then divide - to support fixed
|
|
* point encoding.
|
|
*/
|
|
flexGrowFactor.contents *. remainingFreeSpace.contents /. totalFlexGrowFactors.contents;
|
|
boundMainSize.contents =
|
|
boundAxis currentRelativeChild.contents mainAxis baseMainSize.contents;
|
|
if (baseMainSize.contents != boundMainSize.contents) {
|
|
deltaFreeSpace.contents =
|
|
deltaFreeSpace.contents -. (boundMainSize.contents -. childFlexBasis.contents);
|
|
deltaFlexGrowFactors.contents = deltaFlexGrowFactors.contents -. flexGrowFactor.contents
|
|
}
|
|
}
|
|
};
|
|
currentRelativeChild.contents = currentRelativeChild.contents.nextChild
|
|
};
|
|
totalFlexShrinkScaledFactors.contents =
|
|
totalFlexShrinkScaledFactors.contents +. deltaFlexShrinkScaledFactors.contents;
|
|
totalFlexGrowFactors.contents = totalFlexGrowFactors.contents +. deltaFlexGrowFactors.contents;
|
|
remainingFreeSpace.contents = remainingFreeSpace.contents +. deltaFreeSpace.contents;
|
|
deltaFreeSpace.contents = zero;
|
|
currentRelativeChild.contents = firstRelativeChild.contents;
|
|
while (currentRelativeChild.contents !== theNullNode) {
|
|
childFlexBasis.contents = currentRelativeChild.contents.layout.computedFlexBasis;
|
|
let updatedMainSize = {contents: childFlexBasis.contents};
|
|
if (remainingFreeSpace.contents < zero) {
|
|
flexShrinkScaledFactor.contents =
|
|
-. currentRelativeChild.contents.style.flexShrink *. childFlexBasis.contents;
|
|
if (flexShrinkScaledFactor.contents != zero) {
|
|
updatedMainSize.contents =
|
|
boundAxis
|
|
currentRelativeChild.contents
|
|
mainAxis
|
|
(
|
|
childFlexBasis.contents +.
|
|
/*
|
|
* Important to first scale, then divide - to support
|
|
* fixed point encoding.
|
|
*/
|
|
flexShrinkScaledFactor.contents *. remainingFreeSpace.contents /.
|
|
totalFlexShrinkScaledFactors.contents
|
|
)
|
|
}
|
|
} else if (
|
|
remainingFreeSpace.contents > zero
|
|
) {
|
|
flexGrowFactor.contents = currentRelativeChild.contents.style.flexGrow;
|
|
if (flexGrowFactor.contents != zero) {
|
|
updatedMainSize.contents =
|
|
boundAxis
|
|
currentRelativeChild.contents
|
|
mainAxis
|
|
(
|
|
childFlexBasis.contents +.
|
|
/*
|
|
* Important to first scale, then divide - to support
|
|
* fixed point encoding.
|
|
*/
|
|
flexGrowFactor.contents *. remainingFreeSpace.contents /.
|
|
totalFlexGrowFactors.contents
|
|
)
|
|
}
|
|
};
|
|
deltaFreeSpace.contents =
|
|
deltaFreeSpace.contents -. (updatedMainSize.contents -. childFlexBasis.contents);
|
|
let childWidth = {contents: zero};
|
|
let childHeight = {contents: zero};
|
|
let childWidthMeasureMode = {contents: CssMeasureModeUndefined};
|
|
let childHeightMeasureMode = {contents: CssMeasureModeUndefined};
|
|
if isMainAxisRow {
|
|
childWidth.contents =
|
|
updatedMainSize.contents +.
|
|
getMarginAxis currentRelativeChild.contents CssFlexDirectionRow;
|
|
childWidthMeasureMode.contents = CssMeasureModeExactly;
|
|
if (
|
|
not (isUndefined availableInnerCrossDim) &&
|
|
not (isStyleDimDefined currentRelativeChild.contents CssFlexDirectionColumn) &&
|
|
heightMeasureMode === CssMeasureModeExactly &&
|
|
getAlignItem node currentRelativeChild.contents === CssAlignStretch
|
|
) {
|
|
childHeight.contents = availableInnerCrossDim;
|
|
childHeightMeasureMode.contents = CssMeasureModeExactly
|
|
} else if (
|
|
not (isStyleDimDefined currentRelativeChild.contents CssFlexDirectionColumn)
|
|
) {
|
|
childHeight.contents = availableInnerCrossDim;
|
|
childHeightMeasureMode.contents =
|
|
isUndefined childHeight.contents ? CssMeasureModeUndefined : CssMeasureModeAtMost
|
|
} else {
|
|
childHeight.contents =
|
|
currentRelativeChild.contents.style.height +.
|
|
getMarginAxis currentRelativeChild.contents CssFlexDirectionColumn;
|
|
childHeightMeasureMode.contents = CssMeasureModeExactly
|
|
}
|
|
} else {
|
|
childHeight.contents =
|
|
updatedMainSize.contents +.
|
|
getMarginAxis currentRelativeChild.contents CssFlexDirectionColumn;
|
|
childHeightMeasureMode.contents = CssMeasureModeExactly;
|
|
if (
|
|
not (isUndefined availableInnerCrossDim) &&
|
|
not (isStyleDimDefined currentRelativeChild.contents CssFlexDirectionRow) &&
|
|
widthMeasureMode === CssMeasureModeExactly &&
|
|
getAlignItem node currentRelativeChild.contents === CssAlignStretch
|
|
) {
|
|
childWidth.contents = availableInnerCrossDim;
|
|
childWidthMeasureMode.contents = CssMeasureModeExactly
|
|
} else if (
|
|
not (isStyleDimDefined currentRelativeChild.contents CssFlexDirectionRow)
|
|
) {
|
|
childWidth.contents = availableInnerCrossDim;
|
|
childWidthMeasureMode.contents =
|
|
isUndefined childWidth.contents ? CssMeasureModeUndefined : CssMeasureModeAtMost
|
|
} else {
|
|
childWidth.contents =
|
|
currentRelativeChild.contents.style.width +.
|
|
getMarginAxis currentRelativeChild.contents CssFlexDirectionRow;
|
|
childWidthMeasureMode.contents = CssMeasureModeExactly
|
|
}
|
|
};
|
|
let requiresStretchLayout =
|
|
not (isStyleDimDefined currentRelativeChild.contents crossAxis) &&
|
|
getAlignItem node currentRelativeChild.contents === CssAlignStretch;
|
|
let _ =
|
|
layoutNodeInternal
|
|
currentRelativeChild.contents
|
|
childWidth.contents
|
|
childHeight.contents
|
|
direction
|
|
childWidthMeasureMode.contents
|
|
childHeightMeasureMode.contents
|
|
(performLayout && not requiresStretchLayout)
|
|
flexString;
|
|
currentRelativeChild.contents = currentRelativeChild.contents.nextChild
|
|
}
|
|
};
|
|
remainingFreeSpace.contents = originalRemainingFreeSpace +. deltaFreeSpace.contents;
|
|
/* If we are using "at most" rules in the main axis. Calculate the remaining space when
|
|
constraint by the min size defined for the main axis. */
|
|
if (measureModeMainDim === CssMeasureModeAtMost) {
|
|
let minDim = styleMinDimensionForAxis node mainAxis;
|
|
if (not (isUndefined minDim) && minDim >= 0) {
|
|
remainingFreeSpace.contents =
|
|
fmaxf 0 (minDim - (availableInnerMainDim -. remainingFreeSpace.contents))
|
|
} else {
|
|
remainingFreeSpace.contents = zero
|
|
}
|
|
};
|
|
switch justifyContent {
|
|
| CssJustifyCenter => leadingMainDim.contents = divideScalarByInt remainingFreeSpace.contents 2
|
|
| CssJustifyFlexEnd => leadingMainDim.contents = remainingFreeSpace.contents
|
|
| CssJustifySpaceBetween =>
|
|
if (itemsOnLine.contents > 1) {
|
|
betweenMainDim.contents =
|
|
divideScalarByInt (fmaxf remainingFreeSpace.contents zero) (itemsOnLine.contents - 1)
|
|
} else {
|
|
betweenMainDim.contents = zero
|
|
}
|
|
| CssJustifySpaceAround =>
|
|
betweenMainDim.contents = divideScalarByInt remainingFreeSpace.contents itemsOnLine.contents;
|
|
leadingMainDim.contents = divideScalarByInt betweenMainDim.contents 2
|
|
| CssJustifyFlexStart => ()
|
|
};
|
|
let mainDim = {contents: leadingPaddingAndBorderMain +. leadingMainDim.contents};
|
|
let crossDim = {contents: zero};
|
|
for i in startOfLineIndex.contents to (endOfLineIndex.contents - 1) {
|
|
child.contents = node.children.(i);
|
|
if (
|
|
child.contents.style.positionType === CssPositionAbsolute &&
|
|
isLeadingPosDefinedWithFallback child.contents mainAxis
|
|
) {
|
|
if performLayout {
|
|
setLayoutLeadingPositionForAxis
|
|
child.contents
|
|
mainAxis
|
|
(
|
|
getLeadingPositionWithFallback child.contents mainAxis +. getLeadingBorder node mainAxis +.
|
|
getLeadingMargin child.contents mainAxis
|
|
)
|
|
}
|
|
} else {
|
|
if performLayout {
|
|
setLayoutLeadingPositionForAxis
|
|
child.contents
|
|
mainAxis
|
|
(layoutPosPositionForAxis child.contents mainAxis +. mainDim.contents)
|
|
};
|
|
if (child.contents.style.positionType === CssPositionRelative) {
|
|
if canSkipFlex {
|
|
mainDim.contents =
|
|
mainDim.contents +. betweenMainDim.contents +. getMarginAxis child.contents mainAxis +.
|
|
child.contents.layout.computedFlexBasis;
|
|
crossDim.contents = availableInnerCrossDim
|
|
} else {
|
|
mainDim.contents =
|
|
mainDim.contents +. betweenMainDim.contents +. getDimWithMargin child.contents mainAxis;
|
|
crossDim.contents = fmaxf crossDim.contents (getDimWithMargin child.contents crossAxis)
|
|
}
|
|
}
|
|
}
|
|
};
|
|
mainDim.contents = mainDim.contents +. trailingPaddingAndBorderMain;
|
|
let containerCrossAxis = {contents: availableInnerCrossDim};
|
|
if (
|
|
measureModeCrossDim === CssMeasureModeUndefined || measureModeCrossDim === CssMeasureModeAtMost
|
|
) {
|
|
containerCrossAxis.contents =
|
|
boundAxis node crossAxis (crossDim.contents +. paddingAndBorderAxisCross) -. paddingAndBorderAxisCross;
|
|
if (measureModeCrossDim === CssMeasureModeAtMost) {
|
|
containerCrossAxis.contents = fminf containerCrossAxis.contents availableInnerCrossDim
|
|
}
|
|
};
|
|
if (not isNodeFlexWrap && measureModeCrossDim === CssMeasureModeExactly) {
|
|
crossDim.contents = availableInnerCrossDim
|
|
};
|
|
crossDim.contents =
|
|
boundAxis node crossAxis (crossDim.contents +. paddingAndBorderAxisCross) -. paddingAndBorderAxisCross;
|
|
/*
|
|
* STEP 7: CROSS-AXIS ALIGNMENT We can skip child alignment if we're
|
|
* just measuring the container.
|
|
*/
|
|
if performLayout {
|
|
for i in startOfLineIndex.contents to (endOfLineIndex.contents - 1) {
|
|
child.contents = node.children.(i);
|
|
if (child.contents.style.positionType === CssPositionAbsolute) {
|
|
if (isLeadingPosDefinedWithFallback child.contents crossAxis) {
|
|
setLayoutLeadingPositionForAxis
|
|
child.contents
|
|
crossAxis
|
|
(
|
|
getLeadingPositionWithFallback child.contents crossAxis +.
|
|
getLeadingBorder node crossAxis +.
|
|
getLeadingMargin child.contents crossAxis
|
|
)
|
|
} else {
|
|
setLayoutLeadingPositionForAxis
|
|
child.contents
|
|
crossAxis
|
|
(leadingPaddingAndBorderCross +. getLeadingMargin child.contents crossAxis)
|
|
}
|
|
} else {
|
|
let leadingCrossDim = {contents: leadingPaddingAndBorderCross};
|
|
let alignItem = getAlignItem node child.contents;
|
|
if (alignItem === CssAlignStretch) {
|
|
let childWidth = {contents: zero};
|
|
let childHeight = {contents: zero};
|
|
let childWidthMeasureMode = {contents: CssMeasureModeUndefined};
|
|
let childHeightMeasureMode = {contents: CssMeasureModeUndefined};
|
|
childWidth.contents =
|
|
child.contents.layout.measuredWidth +. getMarginAxis child.contents CssFlexDirectionRow;
|
|
childHeight.contents =
|
|
child.contents.layout.measuredHeight +.
|
|
getMarginAxis child.contents CssFlexDirectionColumn;
|
|
let isCrossSizeDefinite = {contents: false};
|
|
if isMainAxisRow {
|
|
isCrossSizeDefinite.contents = isStyleDimDefined child.contents CssFlexDirectionColumn;
|
|
childHeight.contents = crossDim.contents
|
|
} else {
|
|
isCrossSizeDefinite.contents = isStyleDimDefined child.contents CssFlexDirectionRow;
|
|
childWidth.contents = crossDim.contents
|
|
};
|
|
if (not isCrossSizeDefinite.contents) {
|
|
childWidthMeasureMode.contents =
|
|
isUndefined childWidth.contents ? CssMeasureModeUndefined : CssMeasureModeExactly;
|
|
childHeightMeasureMode.contents =
|
|
isUndefined childHeight.contents ? CssMeasureModeUndefined : CssMeasureModeExactly;
|
|
let _ =
|
|
layoutNodeInternal
|
|
child.contents
|
|
childWidth.contents
|
|
childHeight.contents
|
|
direction
|
|
childWidthMeasureMode.contents
|
|
childHeightMeasureMode.contents
|
|
true
|
|
stretchString;
|
|
()
|
|
}
|
|
} else if (
|
|
alignItem !== CssAlignFlexStart
|
|
) {
|
|
let remainingCrossDim =
|
|
containerCrossAxis.contents -. getDimWithMargin child.contents crossAxis;
|
|
if (alignItem === CssAlignCenter) {
|
|
leadingCrossDim.contents =
|
|
leadingCrossDim.contents +. divideScalarByInt remainingCrossDim 2
|
|
} else {
|
|
leadingCrossDim.contents = leadingCrossDim.contents +. remainingCrossDim
|
|
}
|
|
};
|
|
setLayoutLeadingPositionForAxis
|
|
child.contents
|
|
crossAxis
|
|
(
|
|
layoutPosPositionForAxis child.contents crossAxis +. totalLineCrossDim.contents +.
|
|
leadingCrossDim.contents
|
|
)
|
|
}
|
|
}
|
|
};
|
|
totalLineCrossDim.contents = totalLineCrossDim.contents +. crossDim.contents;
|
|
maxLineMainDim.contents = fmaxf maxLineMainDim.contents mainDim.contents;
|
|
lineCount.contents = lineCount.contents + 1;
|
|
startOfLineIndex.contents = endOfLineIndex.contents
|
|
};
|
|
if (lineCount.contents > 1 && performLayout && not (isUndefined availableInnerCrossDim)) {
|
|
let remainingAlignContentDim = availableInnerCrossDim -. totalLineCrossDim.contents;
|
|
let crossDimLead = {contents: zero};
|
|
let currentLead = {contents: leadingPaddingAndBorderCross};
|
|
let alignContent = node.style.alignContent;
|
|
if (alignContent === CssAlignFlexEnd) {
|
|
currentLead.contents = currentLead.contents +. remainingAlignContentDim
|
|
} else if (
|
|
alignContent === CssAlignCenter
|
|
) {
|
|
currentLead.contents = currentLead.contents +. divideScalarByInt remainingAlignContentDim 2
|
|
} else if (
|
|
alignContent === CssAlignStretch
|
|
) {
|
|
if (availableInnerCrossDim > totalLineCrossDim.contents) {
|
|
crossDimLead.contents = divideScalarByInt remainingAlignContentDim lineCount.contents
|
|
}
|
|
};
|
|
let endIndex = {contents: 0};
|
|
for i in 0 to (lineCount.contents - 1) {
|
|
let startIndex = endIndex.contents;
|
|
let j = {contents: startIndex};
|
|
let lineHeight = {contents: zero};
|
|
let shouldContinue = {contents: false};
|
|
while (j.contents < childCount && shouldContinue.contents) {
|
|
child.contents = node.children.(j.contents);
|
|
if (child.contents.style.positionType === CssPositionRelative) {
|
|
if (child.contents.lineIndex !== i) {
|
|
shouldContinue.contents = false
|
|
} else if (
|
|
isLayoutDimDefined child.contents crossAxis
|
|
) {
|
|
lineHeight.contents =
|
|
fmaxf
|
|
lineHeight.contents
|
|
(
|
|
layoutMeasuredDimensionForAxis child.contents crossAxis +.
|
|
getMarginAxis child.contents crossAxis
|
|
)
|
|
}
|
|
};
|
|
j.contents = j.contents + 1
|
|
};
|
|
endIndex.contents = j.contents;
|
|
lineHeight.contents = lineHeight.contents +. crossDimLead.contents;
|
|
if performLayout {
|
|
for j in startIndex to (endIndex.contents - 1) {
|
|
child.contents = node.children.(j);
|
|
if (child.contents.style.positionType === CssPositionRelative) {
|
|
switch (getAlignItem node child.contents) {
|
|
| CssAlignFlexStart =>
|
|
setLayoutLeadingPositionForAxis
|
|
child.contents
|
|
crossAxis
|
|
(currentLead.contents +. getLeadingMargin child.contents crossAxis)
|
|
| CssAlignFlexEnd =>
|
|
setLayoutLeadingPositionForAxis
|
|
child.contents
|
|
crossAxis
|
|
(
|
|
currentLead.contents +. lineHeight.contents -.
|
|
getTrailingMargin child.contents crossAxis -.
|
|
layoutMeasuredDimensionForAxis child.contents crossAxis
|
|
)
|
|
| CssAlignCenter =>
|
|
let childHeight = layoutMeasuredDimensionForAxis child.contents crossAxis;
|
|
setLayoutLeadingPositionForAxis
|
|
child.contents
|
|
crossAxis
|
|
(currentLead.contents +. divideScalarByInt (lineHeight.contents -. childHeight) 2)
|
|
| CssAlignStretch =>
|
|
setLayoutLeadingPositionForAxis
|
|
child.contents
|
|
crossAxis
|
|
(currentLead.contents +. getLeadingMargin child.contents crossAxis)
|
|
| CssAlignAuto => raise (Invalid_argument "getAlignItem should never return auto")
|
|
}
|
|
}
|
|
}
|
|
};
|
|
currentLead.contents = currentLead.contents +. lineHeight.contents
|
|
}
|
|
};
|
|
/* STEP 9: COMPUTING FINAL DIMENSIONS */
|
|
node.layout.measuredWidth = boundAxis node CssFlexDirectionRow (availableWidth -. marginAxisRow);
|
|
node.layout.measuredHeight =
|
|
boundAxis node CssFlexDirectionColumn (availableHeight -. marginAxisColumn);
|
|
/* If the user didn't specify a width or height for the node, set the
|
|
* dimensions based on the children. */
|
|
if (measureModeMainDim === CssMeasureModeUndefined) {
|
|
setLayoutMeasuredDimensionForAxis node mainAxis (boundAxis node mainAxis maxLineMainDim.contents)
|
|
} else if (
|
|
measureModeMainDim === CssMeasureModeAtMost
|
|
) {
|
|
setLayoutMeasuredDimensionForAxis
|
|
node
|
|
mainAxis
|
|
(
|
|
fmaxf
|
|
(
|
|
fminf
|
|
(availableInnerMainDim +. paddingAndBorderAxisMain)
|
|
(boundAxisWithinMinAndMax node mainAxis maxLineMainDim.contents)
|
|
)
|
|
paddingAndBorderAxisMain
|
|
)
|
|
};
|
|
if (measureModeCrossDim === CssMeasureModeUndefined) {
|
|
setLayoutMeasuredDimensionForAxis
|
|
node
|
|
crossAxis
|
|
(boundAxis node crossAxis (totalLineCrossDim.contents +. paddingAndBorderAxisCross))
|
|
} else if (
|
|
measureModeCrossDim === CssMeasureModeAtMost
|
|
) {
|
|
setLayoutMeasuredDimensionForAxis
|
|
node
|
|
crossAxis
|
|
(
|
|
fmaxf
|
|
(
|
|
fminf
|
|
(availableInnerCrossDim +. paddingAndBorderAxisCross)
|
|
(
|
|
boundAxisWithinMinAndMax
|
|
node crossAxis (totalLineCrossDim.contents +. paddingAndBorderAxisCross)
|
|
)
|
|
)
|
|
paddingAndBorderAxisCross
|
|
)
|
|
};
|
|
currentAbsoluteChild.contents = firstAbsoluteChild.contents;
|
|
while (currentAbsoluteChild.contents !== theNullNode) {
|
|
if performLayout {
|
|
let childWidth = {contents: cssUndefined};
|
|
let childHeight = {contents: cssUndefined};
|
|
let childWidthMeasureMode = {contents: CssMeasureModeUndefined};
|
|
let childHeightMeasureMode = {contents: CssMeasureModeUndefined};
|
|
if (isStyleDimDefined currentAbsoluteChild.contents CssFlexDirectionRow) {
|
|
childWidth.contents =
|
|
currentAbsoluteChild.contents.style.width +.
|
|
getMarginAxis currentAbsoluteChild.contents CssFlexDirectionRow
|
|
} else if (
|
|
isLeadingPosDefinedWithFallback currentAbsoluteChild.contents CssFlexDirectionRow &&
|
|
isTrailingPosDefinedWithFallback currentAbsoluteChild.contents CssFlexDirectionRow
|
|
) {
|
|
childWidth.contents =
|
|
node.layout.measuredWidth -. (
|
|
getLeadingBorder node CssFlexDirectionRow +. getTrailingBorder node CssFlexDirectionRow
|
|
) -. (
|
|
getLeadingPositionWithFallback currentAbsoluteChild.contents CssFlexDirectionRow +.
|
|
getTrailingPositionWithFallback currentAbsoluteChild.contents CssFlexDirectionRow
|
|
);
|
|
childWidth.contents =
|
|
boundAxis currentAbsoluteChild.contents CssFlexDirectionRow childWidth.contents
|
|
};
|
|
if (isStyleDimDefined currentAbsoluteChild.contents CssFlexDirectionColumn) {
|
|
childHeight.contents =
|
|
currentAbsoluteChild.contents.style.height +.
|
|
getMarginAxis currentAbsoluteChild.contents CssFlexDirectionColumn
|
|
} else if (
|
|
/* If the child doesn't have a specified height, compute the height based on the top/bottom offsets if they're defined. */
|
|
isLeadingPosDefinedWithFallback currentAbsoluteChild.contents CssFlexDirectionColumn &&
|
|
isTrailingPosDefinedWithFallback currentAbsoluteChild.contents CssFlexDirectionColumn
|
|
) {
|
|
childHeight.contents =
|
|
node.layout.measuredHeight -. (
|
|
getLeadingBorder node CssFlexDirectionColumn +.
|
|
getTrailingBorder node CssFlexDirectionColumn
|
|
) -. (
|
|
getLeadingPositionWithFallback currentAbsoluteChild.contents CssFlexDirectionColumn +.
|
|
getTrailingPositionWithFallback currentAbsoluteChild.contents CssFlexDirectionColumn
|
|
);
|
|
childHeight.contents =
|
|
boundAxis currentAbsoluteChild.contents CssFlexDirectionColumn childHeight.contents
|
|
};
|
|
if (isUndefined childWidth.contents || isUndefined childHeight.contents) {
|
|
childWidthMeasureMode.contents =
|
|
isUndefined childWidth.contents ? CssMeasureModeUndefined : CssMeasureModeExactly;
|
|
childHeightMeasureMode.contents =
|
|
isUndefined childHeight.contents ? CssMeasureModeUndefined : CssMeasureModeExactly;
|
|
/*
|
|
* According to the spec, if the main size is not definite and the
|
|
* child's inline axis is parallel to the main axis (i.e. it's
|
|
* horizontal), the child should be sized using "UNDEFINED" in
|
|
* the main size. Otherwise use "AT_MOST" in the cross axis.
|
|
*/
|
|
if (
|
|
(not isMainAxisRow && isUndefined childWidth.contents) &&
|
|
not (isUndefined availableInnerWidth)
|
|
) {
|
|
childWidth.contents = availableInnerWidth;
|
|
childWidthMeasureMode.contents = CssMeasureModeAtMost
|
|
};
|
|
/*
|
|
* If child has no defined size in the cross axis and is set to stretch, set the cross
|
|
* axis to be measured exactly with the available inner width
|
|
*/
|
|
let _ =
|
|
layoutNodeInternal
|
|
currentAbsoluteChild.contents
|
|
childWidth.contents
|
|
childHeight.contents
|
|
direction
|
|
childWidthMeasureMode.contents
|
|
childHeightMeasureMode.contents
|
|
false
|
|
absMeasureString;
|
|
childWidth.contents =
|
|
currentAbsoluteChild.contents.layout.measuredWidth +.
|
|
getMarginAxis currentAbsoluteChild.contents CssFlexDirectionRow;
|
|
childHeight.contents =
|
|
currentAbsoluteChild.contents.layout.measuredHeight +.
|
|
getMarginAxis currentAbsoluteChild.contents CssFlexDirectionColumn
|
|
};
|
|
let _ =
|
|
layoutNodeInternal
|
|
currentAbsoluteChild.contents
|
|
childWidth.contents
|
|
childHeight.contents
|
|
direction
|
|
CssMeasureModeExactly
|
|
CssMeasureModeExactly
|
|
true
|
|
absLayoutString;
|
|
if (
|
|
isTrailingPosDefinedWithFallback currentAbsoluteChild.contents mainAxis &&
|
|
not (isLeadingPosDefinedWithFallback currentAbsoluteChild.contents mainAxis)
|
|
) {
|
|
setLayoutLeadingPositionForAxis
|
|
currentAbsoluteChild.contents
|
|
mainAxis
|
|
(
|
|
layoutMeasuredDimensionForAxis node mainAxis -.
|
|
layoutMeasuredDimensionForAxis currentAbsoluteChild.contents mainAxis -.
|
|
getTrailingPositionWithFallback currentAbsoluteChild.contents mainAxis
|
|
)
|
|
};
|
|
if (
|
|
isTrailingPosDefinedWithFallback currentAbsoluteChild.contents crossAxis &&
|
|
not (isLeadingPosDefinedWithFallback currentAbsoluteChild.contents crossAxis)
|
|
) {
|
|
setLayoutLeadingPositionForAxis
|
|
currentAbsoluteChild.contents
|
|
crossAxis
|
|
(
|
|
layoutMeasuredDimensionForAxis node crossAxis -.
|
|
layoutMeasuredDimensionForAxis currentAbsoluteChild.contents crossAxis -.
|
|
getTrailingPositionWithFallback currentAbsoluteChild.contents crossAxis
|
|
)
|
|
}
|
|
};
|
|
currentAbsoluteChild.contents = currentAbsoluteChild.contents.nextChild
|
|
};
|
|
/* STEP 11: SETTING TRAILING POSITIONS FOR CHILDREN */
|
|
if performLayout {
|
|
let needsMainTrailingPos =
|
|
mainAxis == CssFlexDirectionRowReverse || mainAxis == CssFlexDirectionColumnReverse;
|
|
let needsCrossTrailingPos =
|
|
crossAxis == CssFlexDirectionRowReverse || crossAxis == CssFlexDirectionColumnReverse;
|
|
/* Set trailing position if necessary. */
|
|
if (needsMainTrailingPos || needsCrossTrailingPos) {
|
|
for i in 0 to (childCount - 1) {
|
|
let child = node.children.(i);
|
|
if needsMainTrailingPos {
|
|
setTrailingPosition node child mainAxis
|
|
};
|
|
if needsCrossTrailingPos {
|
|
setTrailingPosition node child crossAxis
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/** END_GENERATED **/
|
|
};
|
|
|
|
let layoutNode node availableWidth availableHeight parentDirection => {
|
|
/* Increment the generation count. This will force the recursive routine to visit*/
|
|
/* all dirty nodes at least once. Subsequent visits will be skipped if the input*/
|
|
/* parameters don't change.*/
|
|
gCurrentGenerationCount.contents = gCurrentGenerationCount.contents + 1;
|
|
/* If the caller didn't specify a height/width, use the dimensions*/
|
|
/* specified in the style.*/
|
|
let (availableWidth, widthMeasureMode) =
|
|
if (not (isUndefined availableWidth)) {
|
|
(availableWidth, CssMeasureModeExactly)
|
|
} else if (
|
|
isStyleDimDefined node CssFlexDirectionRow
|
|
) {
|
|
(node.style.width +. getMarginAxis node CssFlexDirectionRow, CssMeasureModeExactly)
|
|
} else if (
|
|
node.style.maxWidth >= zero
|
|
) {
|
|
(node.style.maxWidth, CssMeasureModeAtMost)
|
|
} else {
|
|
(availableWidth, CssMeasureModeUndefined)
|
|
};
|
|
let (availableHeight, heightMeasureMode) =
|
|
if (not (isUndefined availableHeight)) {
|
|
(availableHeight, CssMeasureModeExactly)
|
|
} else if (
|
|
isStyleDimDefined node CssFlexDirectionColumn
|
|
) {
|
|
(node.style.height +. getMarginAxis node CssFlexDirectionColumn, CssMeasureModeExactly)
|
|
} else if (
|
|
node.style.maxHeight >= zero
|
|
) {
|
|
(node.style.maxHeight, CssMeasureModeAtMost)
|
|
} else {
|
|
(availableHeight, CssMeasureModeUndefined)
|
|
};
|
|
if (
|
|
layoutNodeInternal
|
|
node
|
|
availableWidth
|
|
availableHeight
|
|
parentDirection
|
|
widthMeasureMode
|
|
heightMeasureMode
|
|
true
|
|
initialString
|
|
) {
|
|
setPosition node node.layout.direction;
|
|
if gPrintTree.contents {
|
|
LayoutPrint.printCssNode (node, {printLayout: true, printChildren: true, printStyle: true})
|
|
}
|
|
}
|
|
}; |