status-im
/
react-native
mirror of https://github.com/status-im/react-native.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Remove use of snake_case 

Reviewed By: lucasr

Differential Revision: D3886849

fbshipit-source-id: eaf3f219fe1ccb717ba363dba0d2f475ffb204e3
This commit is contained in:
Emil Sjolander 2016-09-20 10:16:13 -07:00 committed by Facebook Github Bot 5
parent 922cd6ddfc
commit 7f2bbf4263
1 changed files with 102 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

203
React/CSSLayout/CSSLayout.c
View File

@ -54,7 +54,7 @@ typedef struct CSSLayout {
CSSCachedMeasurement cachedMeasurements[CSS_MAX_CACHED_RESULT_COUNT];
float measuredDimensions[2];
CSSCachedMeasurement cached_layout;
CSSCachedMeasurement cachedLayout;
} CSSLayout;
typedef struct CSSStyle {
@ -186,8 +186,8 @@ void CSSNodeInit(const CSSNodeRef node) {
node->layout.measuredDimensions[CSSDimensionWidth] = CSSUndefined;
node->layout.measuredDimensions[CSSDimensionHeight] = CSSUndefined;
node->layout.cached_layout.widthMeasureMode = (CSSMeasureMode) -1;
node->layout.cached_layout.heightMeasureMode = (CSSMeasureMode) -1;
node->layout.cachedLayout.widthMeasureMode = (CSSMeasureMode) -1;
node->layout.cachedLayout.heightMeasureMode = (CSSMeasureMode) -1;
}
void _CSSNodeMarkDirty(const CSSNodeRef node) {
@ -362,24 +362,24 @@ static void indent(const uint32_t n) {
}
}
static void print_number_0(const char *str, const float number) {
static void printNumberIfNotZero(const char *str, const float number) {
if (!eq(number, 0)) {
printf("%s: %g, ", str, number);
}
}
static void print_number_nan(const char *str, const float number) {
if (!isnan(number)) {
static void printNumberIfNotUndefined(const char *str, const float number) {
if (!CSSValueIsUndefined(number)) {
printf("%s: %g, ", str, number);
}
}
static bool four_equal(const float four[4]) {
static bool eqFour(const float four[4]) {
return eq(four[0], four[1]) && eq(four[0], four[2]) && eq(four[0], four[3]);
}
static void
print_css_node_rec(const CSSNodeRef node, const CSSPrintOptions options, const uint32_t level) {
_CSSNodePrint(const CSSNodeRef node, const CSSPrintOptions options, const uint32_t level) {
indent(level);
printf("{");
@ -443,9 +443,9 @@ print_css_node_rec(const CSSNodeRef node, const CSSPrintOptions options, const u
printf("alignSelf: 'stretch', ");
}
print_number_nan("flexGrow", node->style.flexGrow);
print_number_nan("flexShrink", node->style.flexShrink);
print_number_nan("flexBasis", node->style.flexBasis);
printNumberIfNotUndefined("flexGrow", node->style.flexGrow);
printNumberIfNotUndefined("flexShrink", node->style.flexShrink);
printNumberIfNotUndefined("flexBasis", node->style.flexBasis);
if (node->style.overflow == CSSOverflowHidden) {
printf("overflow: 'hidden', ");
@ -453,62 +453,70 @@ print_css_node_rec(const CSSNodeRef node, const CSSPrintOptions options, const u
printf("overflow: 'visible', ");
}
if (four_equal(node->style.margin)) {
print_number_0("margin", computedEdgeValue(node->style.margin, CSSEdgeLeft, 0));
if (eqFour(node->style.margin)) {
printNumberIfNotZero("margin", computedEdgeValue(node->style.margin, CSSEdgeLeft, 0));
} else {
print_number_0("marginLeft", computedEdgeValue(node->style.margin, CSSEdgeLeft, 0));
print_number_0("marginRight", computedEdgeValue(node->style.margin, CSSEdgeRight, 0));
print_number_0("marginTop", computedEdgeValue(node->style.margin, CSSEdgeTop, 0));
print_number_0("marginBottom", computedEdgeValue(node->style.margin, CSSEdgeBottom, 0));
print_number_0("marginStart", computedEdgeValue(node->style.margin, CSSEdgeStart, 0));
print_number_0("marginEnd", computedEdgeValue(node->style.margin, CSSEdgeEnd, 0));
printNumberIfNotZero("marginLeft", computedEdgeValue(node->style.margin, CSSEdgeLeft, 0));
printNumberIfNotZero("marginRight", computedEdgeValue(node->style.margin, CSSEdgeRight, 0));
printNumberIfNotZero("marginTop", computedEdgeValue(node->style.margin, CSSEdgeTop, 0));
printNumberIfNotZero("marginBottom", computedEdgeValue(node->style.margin, CSSEdgeBottom, 0));
printNumberIfNotZero("marginStart", computedEdgeValue(node->style.margin, CSSEdgeStart, 0));
printNumberIfNotZero("marginEnd", computedEdgeValue(node->style.margin, CSSEdgeEnd, 0));
}
if (four_equal(node->style.padding)) {
print_number_0("padding", computedEdgeValue(node->style.padding, CSSEdgeLeft, 0));
if (eqFour(node->style.padding)) {
printNumberIfNotZero("padding", computedEdgeValue(node->style.padding, CSSEdgeLeft, 0));
} else {
print_number_0("paddingLeft", computedEdgeValue(node->style.padding, CSSEdgeLeft, 0));
print_number_0("paddingRight", computedEdgeValue(node->style.padding, CSSEdgeRight, 0));
print_number_0("paddingTop", computedEdgeValue(node->style.padding, CSSEdgeTop, 0));
print_number_0("paddingBottom", computedEdgeValue(node->style.padding, CSSEdgeBottom, 0));
print_number_0("paddingStart", computedEdgeValue(node->style.padding, CSSEdgeStart, 0));
print_number_0("paddingEnd", computedEdgeValue(node->style.padding, CSSEdgeEnd, 0));
printNumberIfNotZero("paddingLeft", computedEdgeValue(node->style.padding, CSSEdgeLeft, 0));
printNumberIfNotZero("paddingRight", computedEdgeValue(node->style.padding, CSSEdgeRight, 0));
printNumberIfNotZero("paddingTop", computedEdgeValue(node->style.padding, CSSEdgeTop, 0));
printNumberIfNotZero("paddingBottom",
computedEdgeValue(node->style.padding, CSSEdgeBottom, 0));
printNumberIfNotZero("paddingStart", computedEdgeValue(node->style.padding, CSSEdgeStart, 0));
printNumberIfNotZero("paddingEnd", computedEdgeValue(node->style.padding, CSSEdgeEnd, 0));
}
if (four_equal(node->style.border)) {
print_number_0("borderWidth", computedEdgeValue(node->style.border, CSSEdgeLeft, 0));
if (eqFour(node->style.border)) {
printNumberIfNotZero("borderWidth", computedEdgeValue(node->style.border, CSSEdgeLeft, 0));
} else {
print_number_0("borderLeftWidth", computedEdgeValue(node->style.border, CSSEdgeLeft, 0));
print_number_0("borderRightWidth", computedEdgeValue(node->style.border, CSSEdgeRight, 0));
print_number_0("borderTopWidth", computedEdgeValue(node->style.border, CSSEdgeTop, 0));
print_number_0("borderBottomWidth", computedEdgeValue(node->style.border, CSSEdgeBottom, 0));
print_number_0("borderStartWidth", computedEdgeValue(node->style.border, CSSEdgeStart, 0));
print_number_0("borderEndWidth", computedEdgeValue(node->style.border, CSSEdgeEnd, 0));
printNumberIfNotZero("borderLeftWidth",
computedEdgeValue(node->style.border, CSSEdgeLeft, 0));
printNumberIfNotZero("borderRightWidth",
computedEdgeValue(node->style.border, CSSEdgeRight, 0));
printNumberIfNotZero("borderTopWidth", computedEdgeValue(node->style.border, CSSEdgeTop, 0));
printNumberIfNotZero("borderBottomWidth",
computedEdgeValue(node->style.border, CSSEdgeBottom, 0));
printNumberIfNotZero("borderStartWidth",
computedEdgeValue(node->style.border, CSSEdgeStart, 0));
printNumberIfNotZero("borderEndWidth", computedEdgeValue(node->style.border, CSSEdgeEnd, 0));
}
print_number_nan("width", node->style.dimensions[CSSDimensionWidth]);
print_number_nan("height", node->style.dimensions[CSSDimensionHeight]);
print_number_nan("maxWidth", node->style.maxDimensions[CSSDimensionWidth]);
print_number_nan("maxHeight", node->style.maxDimensions[CSSDimensionHeight]);
print_number_nan("minWidth", node->style.minDimensions[CSSDimensionWidth]);
print_number_nan("minHeight", node->style.minDimensions[CSSDimensionHeight]);
printNumberIfNotUndefined("width", node->style.dimensions[CSSDimensionWidth]);
printNumberIfNotUndefined("height", node->style.dimensions[CSSDimensionHeight]);
printNumberIfNotUndefined("maxWidth", node->style.maxDimensions[CSSDimensionWidth]);
printNumberIfNotUndefined("maxHeight", node->style.maxDimensions[CSSDimensionHeight]);
printNumberIfNotUndefined("minWidth", node->style.minDimensions[CSSDimensionWidth]);
printNumberIfNotUndefined("minHeight", node->style.minDimensions[CSSDimensionHeight]);
if (node->style.positionType == CSSPositionTypeAbsolute) {
printf("position: 'absolute', ");
}
print_number_nan("left", computedEdgeValue(node->style.position, CSSEdgeLeft, CSSUndefined));
print_number_nan("right", computedEdgeValue(node->style.position, CSSEdgeRight, CSSUndefined));
print_number_nan("top", computedEdgeValue(node->style.position, CSSEdgeTop, CSSUndefined));
print_number_nan("bottom",
computedEdgeValue(node->style.position, CSSEdgeBottom, CSSUndefined));
printNumberIfNotUndefined("left",
computedEdgeValue(node->style.position, CSSEdgeLeft, CSSUndefined));
printNumberIfNotUndefined("right",
computedEdgeValue(node->style.position, CSSEdgeRight, CSSUndefined));
printNumberIfNotUndefined("top",
computedEdgeValue(node->style.position, CSSEdgeTop, CSSUndefined));
printNumberIfNotUndefined("bottom",
computedEdgeValue(node->style.position, CSSEdgeBottom, CSSUndefined));
}
const uint32_t childCount = CSSNodeListCount(node->children);
if (options & CSSPrintOptionsChildren && childCount > 0) {
printf("children: [\n");
for (uint32_t i = 0; i < childCount; i++) {
print_css_node_rec(CSSNodeGetChild(node, i), options, level + 1);
_CSSNodePrint(CSSNodeGetChild(node, i), options, level + 1);
}
indent(level);
printf("]},\n");
@ -518,7 +526,7 @@ print_css_node_rec(const CSSNodeRef node, const CSSPrintOptions options, const u
}
void CSSNodePrint(const CSSNodeRef node, const CSSPrintOptions options) {
print_css_node_rec(node, options, 0);
_CSSNodePrint(node, options, 0);
}
static const CSSEdge leading[4] = {
@ -555,8 +563,7 @@ static bool isColumnDirection(const CSSFlexDirection flexDirection) {
}
static float getLeadingMargin(const CSSNodeRef node, const CSSFlexDirection axis) {
if (isRowDirection(axis) &&
!CSSValueIsUndefined(node->style.margin[CSSEdgeStart])) {
if (isRowDirection(axis) && !CSSValueIsUndefined(node->style.margin[CSSEdgeStart])) {
return node->style.margin[CSSEdgeStart];
}
@ -564,8 +571,7 @@ static float getLeadingMargin(const CSSNodeRef node, const CSSFlexDirection axis
}
static float getTrailingMargin(const CSSNodeRef node, const CSSFlexDirection axis) {
if (isRowDirection(axis) &&
!CSSValueIsUndefined(node->style.margin[CSSEdgeEnd])) {
if (isRowDirection(axis) && !CSSValueIsUndefined(node->style.margin[CSSEdgeEnd])) {
return node->style.margin[CSSEdgeEnd];
}
@ -573,8 +579,7 @@ static float getTrailingMargin(const CSSNodeRef node, const CSSFlexDirection axi
}
static float getLeadingPadding(const CSSNodeRef node, const CSSFlexDirection axis) {
if (isRowDirection(axis) &&
!CSSValueIsUndefined(node->style.padding[CSSEdgeStart]) &&
if (isRowDirection(axis) && !CSSValueIsUndefined(node->style.padding[CSSEdgeStart]) &&
node->style.padding[CSSEdgeStart] >= 0) {
return node->style.padding[CSSEdgeStart];
}
@ -587,8 +592,7 @@ static float getLeadingPadding(const CSSNodeRef node, const CSSFlexDirection axi
}
static float getTrailingPadding(const CSSNodeRef node, const CSSFlexDirection axis) {
if (isRowDirection(axis) &&
!CSSValueIsUndefined(node->style.padding[CSSEdgeEnd]) &&
if (isRowDirection(axis) && !CSSValueIsUndefined(node->style.padding[CSSEdgeEnd]) &&
node->style.padding[CSSEdgeEnd] >= 0) {
return node->style.padding[CSSEdgeEnd];
}
@ -601,8 +605,7 @@ static float getTrailingPadding(const CSSNodeRef node, const CSSFlexDirection ax
}
static float getLeadingBorder(const CSSNodeRef node, const CSSFlexDirection axis) {
if (isRowDirection(axis) &&
!CSSValueIsUndefined(node->style.border[CSSEdgeStart]) &&
if (isRowDirection(axis) && !CSSValueIsUndefined(node->style.border[CSSEdgeStart]) &&
node->style.border[CSSEdgeStart] >= 0) {
return node->style.border[CSSEdgeStart];
}
@ -615,8 +618,7 @@ static float getLeadingBorder(const CSSNodeRef node, const CSSFlexDirection axis
}
static float getTrailingBorder(const CSSNodeRef node, const CSSFlexDirection axis) {
if (isRowDirection(axis) &&
!CSSValueIsUndefined(node->style.border[CSSEdgeEnd]) &&
if (isRowDirection(axis) && !CSSValueIsUndefined(node->style.border[CSSEdgeEnd]) &&
node->style.border[CSSEdgeEnd] >= 0) {
return node->style.border[CSSEdgeEnd];
}
@ -1941,60 +1943,59 @@ static const char *getModeName(const CSSMeasureMode mode, const bool performLayo
static bool canUseCachedMeasurement(const bool isTextNode,
const float availableWidth,
const float availableHeight,
const float margin_row,
const float margin_column,
const float marginRow,
const float marginColumn,
const CSSMeasureMode widthMeasureMode,
const CSSMeasureMode heightMeasureMode,
CSSCachedMeasurement cached_layout) {
const bool is_height_same = (cached_layout.heightMeasureMode == CSSMeasureModeUndefined &&
heightMeasureMode == CSSMeasureModeUndefined) ||
(cached_layout.heightMeasureMode == heightMeasureMode &&
eq(cached_layout.availableHeight, availableHeight));
CSSCachedMeasurement cachedLayout) {
const bool isHeightSame = (cachedLayout.heightMeasureMode == CSSMeasureModeUndefined &&
heightMeasureMode == CSSMeasureModeUndefined) ||
(cachedLayout.heightMeasureMode == heightMeasureMode &&
eq(cachedLayout.availableHeight, availableHeight));
const bool is_width_same = (cached_layout.widthMeasureMode == CSSMeasureModeUndefined &&
widthMeasureMode == CSSMeasureModeUndefined) ||
(cached_layout.widthMeasureMode == widthMeasureMode &&
eq(cached_layout.availableWidth, availableWidth));
const bool isWidthSame = (cachedLayout.widthMeasureMode == CSSMeasureModeUndefined &&
widthMeasureMode == CSSMeasureModeUndefined) ||
(cachedLayout.widthMeasureMode == widthMeasureMode &&
eq(cachedLayout.availableWidth, availableWidth));
if (is_height_same && is_width_same) {
if (isHeightSame && isWidthSame) {
return true;
}
const bool is_height_valid =
(cached_layout.heightMeasureMode == CSSMeasureModeUndefined &&
heightMeasureMode == CSSMeasureModeAtMost &&
cached_layout.computedHeight <= (availableHeight - margin_column)) ||
(heightMeasureMode == CSSMeasureModeExactly &&
eq(cached_layout.computedHeight, availableHeight - margin_column));
const bool isHeightValid = (cachedLayout.heightMeasureMode == CSSMeasureModeUndefined &&
heightMeasureMode == CSSMeasureModeAtMost &&
cachedLayout.computedHeight <= (availableHeight - marginColumn)) ||
(heightMeasureMode == CSSMeasureModeExactly &&
eq(cachedLayout.computedHeight, availableHeight - marginColumn));
if (is_width_same && is_height_valid) {
if (isWidthSame && isHeightValid) {
return true;
}
const bool is_width_valid = (cached_layout.widthMeasureMode == CSSMeasureModeUndefined &&
widthMeasureMode == CSSMeasureModeAtMost &&
cached_layout.computedWidth <= (availableWidth - margin_row)) ||
(widthMeasureMode == CSSMeasureModeExactly &&
eq(cached_layout.computedWidth, availableWidth - margin_row));
const bool isWidthValid = (cachedLayout.widthMeasureMode == CSSMeasureModeUndefined &&
widthMeasureMode == CSSMeasureModeAtMost &&
cachedLayout.computedWidth <= (availableWidth - marginRow)) ||
(widthMeasureMode == CSSMeasureModeExactly &&
eq(cachedLayout.computedWidth, availableWidth - marginRow));
if (is_height_same && is_width_valid) {
if (isHeightSame && isWidthValid) {
return true;
}
if (is_height_valid && is_width_valid) {
if (isHeightValid && isWidthValid) {
return true;
}
// We know this to be text so we can apply some more specialized heuristics.
if (isTextNode) {
if (is_width_same) {
if (isWidthSame) {
if (heightMeasureMode == CSSMeasureModeUndefined) {
// Width is the same and height is not restricted. Re-use cahced value.
return true;
}
if (heightMeasureMode == CSSMeasureModeAtMost &&
cached_layout.computedHeight < (availableHeight - margin_column)) {
cachedLayout.computedHeight < (availableHeight - marginColumn)) {
// Width is the same and height restriction is greater than the cached
// height. Re-use cached
// value.
@ -2004,14 +2005,14 @@ static bool canUseCachedMeasurement(const bool isTextNode,
// Width is the same but height restriction imposes smaller height than
// previously measured.
// Update the cached value to respect the new height restriction.
cached_layout.computedHeight = availableHeight - margin_column;
cachedLayout.computedHeight = availableHeight - marginColumn;
return true;
}
if (cached_layout.widthMeasureMode == CSSMeasureModeUndefined) {
if (cachedLayout.widthMeasureMode == CSSMeasureModeUndefined) {
if (widthMeasureMode == CSSMeasureModeUndefined ||
(widthMeasureMode == CSSMeasureModeAtMost &&
cached_layout.computedWidth <= (availableWidth - margin_row))) {
cachedLayout.computedWidth <= (availableWidth - marginRow))) {
// Previsouly this text was measured with no width restriction, if width
// is now restricted
// but to a larger value than the previsouly measured width we can
@ -2052,8 +2053,8 @@ bool layoutNodeInternal(const CSSNodeRef node,
if (needToVisitNode) {
// Invalidate the cached results.
layout->nextCachedMeasurementsIndex = 0;
layout->cached_layout.widthMeasureMode = (CSSMeasureMode) -1;
layout->cached_layout.heightMeasureMode = (CSSMeasureMode) -1;
layout->cachedLayout.widthMeasureMode = (CSSMeasureMode) -1;
layout->cachedLayout.heightMeasureMode = (CSSMeasureMode) -1;
}
CSSCachedMeasurement *cachedResults = NULL;
@ -2082,8 +2083,8 @@ bool layoutNodeInternal(const CSSNodeRef node,
marginAxisColumn,
widthMeasureMode,
heightMeasureMode,
layout->cached_layout)) {
cachedResults = &layout->cached_layout;
layout->cachedLayout)) {
cachedResults = &layout->cachedLayout;
} else {
// Try to use the measurement cache.
for (uint32_t i = 0; i < layout->nextCachedMeasurementsIndex; i++) {
@ -2101,11 +2102,11 @@ bool layoutNodeInternal(const CSSNodeRef node,
}
}
} else if (performLayout) {
if (eq(layout->cached_layout.availableWidth, availableWidth) &&
eq(layout->cached_layout.availableHeight, availableHeight) &&
layout->cached_layout.widthMeasureMode == widthMeasureMode &&
layout->cached_layout.heightMeasureMode == heightMeasureMode) {
cachedResults = &layout->cached_layout;
if (eq(layout->cachedLayout.availableWidth, availableWidth) &&
eq(layout->cachedLayout.availableHeight, availableHeight) &&
layout->cachedLayout.widthMeasureMode == widthMeasureMode &&
layout->cachedLayout.heightMeasureMode == heightMeasureMode) {
cachedResults = &layout->cachedLayout;
}
} else {
for (uint32_t i = 0; i < layout->nextCachedMeasurementsIndex; i++) {
@ -2185,7 +2186,7 @@ bool layoutNodeInternal(const CSSNodeRef node,
CSSCachedMeasurement *newCacheEntry;
if (performLayout) {
// Use the single layout cache entry.
newCacheEntry = &layout->cached_layout;
newCacheEntry = &layout->cachedLayout;
} else {
// Allocate a new measurement cache entry.
newCacheEntry = &layout->cachedMeasurements[layout->nextCachedMeasurementsIndex];