336 lines
10 KiB
C++
336 lines
10 KiB
C++
/**
|
|
* Copyright (c) 2015-present, Facebook, Inc.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
|
|
#include "yogaValuesConversions.h"
|
|
|
|
#include <folly/Conv.h>
|
|
|
|
#include <fabric/core/LayoutMetrics.h>
|
|
|
|
namespace facebook {
|
|
namespace react {
|
|
|
|
Float fabricFloatFromYogaFloat(float value) {
|
|
if (value == YGUndefined) {
|
|
return kFloatUndefined;
|
|
}
|
|
|
|
return (Float)value;
|
|
}
|
|
|
|
float yogaFloatFromFabricFloat(Float value) {
|
|
if (value == kFloatUndefined) {
|
|
return YGUndefined;
|
|
}
|
|
|
|
return (float)value;
|
|
}
|
|
|
|
Float fabricFloatFromYogaOptionalFloat(YGFloatOptional value) {
|
|
if (value.isUndefined()) {
|
|
return kFloatUndefined;
|
|
}
|
|
|
|
return fabricFloatFromYogaFloat(value.getValue());
|
|
}
|
|
|
|
YGFloatOptional yogaOptionalFloatFromFabricFloat(Float value) {
|
|
if (value == kFloatUndefined) {
|
|
return YGFloatOptional();
|
|
}
|
|
|
|
return YGFloatOptional(yogaFloatFromFabricFloat(value));
|
|
}
|
|
|
|
LayoutMetrics layoutMetricsFromYogaNode(YGNode &yogaNode) {
|
|
LayoutMetrics layoutMetrics;
|
|
|
|
YGLayout layout = yogaNode.getLayout();
|
|
|
|
layoutMetrics.frame = Rect {
|
|
Point {
|
|
fabricFloatFromYogaFloat(layout.position[YGEdgeLeft]),
|
|
fabricFloatFromYogaFloat(layout.position[YGEdgeTop])
|
|
},
|
|
Size {
|
|
fabricFloatFromYogaFloat(layout.dimensions[YGDimensionWidth]),
|
|
fabricFloatFromYogaFloat(layout.dimensions[YGDimensionHeight])
|
|
}
|
|
};
|
|
|
|
layoutMetrics.borderWidth = EdgeInsets {
|
|
fabricFloatFromYogaFloat(layout.border[YGEdgeLeft]),
|
|
fabricFloatFromYogaFloat(layout.border[YGEdgeTop]),
|
|
fabricFloatFromYogaFloat(layout.border[YGEdgeRight]),
|
|
fabricFloatFromYogaFloat(layout.border[YGEdgeBottom])
|
|
};
|
|
|
|
layoutMetrics.contentInsets = EdgeInsets {
|
|
fabricFloatFromYogaFloat(layout.border[YGEdgeLeft] + layout.padding[YGEdgeLeft]),
|
|
fabricFloatFromYogaFloat(layout.border[YGEdgeTop] + layout.padding[YGEdgeTop]),
|
|
fabricFloatFromYogaFloat(layout.border[YGEdgeRight] + layout.padding[YGEdgeRight]),
|
|
fabricFloatFromYogaFloat(layout.border[YGEdgeBottom] + layout.padding[YGEdgeBottom])
|
|
};
|
|
|
|
layoutMetrics.displayType =
|
|
yogaNode.getStyle().display == YGDisplayNone ? DisplayType::None : DisplayType::Flex;
|
|
|
|
layoutMetrics.layoutDirection =
|
|
layout.direction == YGDirectionRTL ? LayoutDirection::RightToLeft : LayoutDirection::LeftToRight;
|
|
|
|
return layoutMetrics;
|
|
}
|
|
|
|
YGDirection yogaStyleDirectionFromDynamic(const folly::dynamic &value) {
|
|
assert(value.isString());
|
|
auto stringValue = value.asString();
|
|
|
|
if (stringValue == "inherit") { return YGDirectionInherit; }
|
|
if (stringValue == "ltr") { return YGDirectionLTR; }
|
|
if (stringValue == "rtl") { return YGDirectionRTL; }
|
|
|
|
abort();
|
|
}
|
|
|
|
YGFlexDirection yogaStyleFlexDirectionFromDynamic(const folly::dynamic &value) {
|
|
assert(value.isString());
|
|
auto stringValue = value.asString();
|
|
|
|
if (stringValue == "column") { return YGFlexDirectionColumn; }
|
|
if (stringValue == "column-reverse") { return YGFlexDirectionColumnReverse; }
|
|
if (stringValue == "row") { return YGFlexDirectionRow; }
|
|
if (stringValue == "row-reverse") { return YGFlexDirectionRowReverse; }
|
|
|
|
abort();
|
|
}
|
|
|
|
YGJustify yogaStyleJustifyFromDynamic(const folly::dynamic &value) {
|
|
assert(value.isString());
|
|
auto stringValue = value.asString();
|
|
|
|
if (stringValue == "flex-start") { return YGJustifyFlexStart; }
|
|
if (stringValue == "center") { return YGJustifyCenter; }
|
|
if (stringValue == "flex-end") { return YGJustifyFlexEnd; }
|
|
if (stringValue == "space-between") { return YGJustifySpaceBetween; }
|
|
if (stringValue == "space-around") { return YGJustifySpaceAround; }
|
|
if (stringValue == "space-evenly") { return YGJustifySpaceEvenly; }
|
|
|
|
abort();
|
|
}
|
|
|
|
YGAlign yogaStyleAlignFromDynamic(const folly::dynamic &value) {
|
|
assert(value.isString());
|
|
auto stringValue = value.asString();
|
|
|
|
if (stringValue == "auto") { return YGAlignAuto; }
|
|
if (stringValue == "flex-start") { return YGAlignFlexStart; }
|
|
if (stringValue == "center") { return YGAlignCenter; }
|
|
if (stringValue == "flex-end") { return YGAlignFlexEnd; }
|
|
if (stringValue == "stretch") { return YGAlignStretch; }
|
|
if (stringValue == "baseline") { return YGAlignBaseline; }
|
|
if (stringValue == "between") { return YGAlignSpaceBetween; }
|
|
if (stringValue == "space-around") { return YGAlignSpaceAround; }
|
|
|
|
abort();
|
|
}
|
|
|
|
YGPositionType yogaStylePositionTypeFromDynamic(const folly::dynamic &value) {
|
|
assert(value.isString());
|
|
auto stringValue = value.asString();
|
|
|
|
if (stringValue == "relative") { return YGPositionTypeRelative; }
|
|
if (stringValue == "absolute") { return YGPositionTypeAbsolute; }
|
|
|
|
abort();
|
|
}
|
|
|
|
YGWrap yogaStyleWrapFromDynamic(const folly::dynamic &value) {
|
|
assert(value.isString());
|
|
auto stringValue = value.asString();
|
|
|
|
if (stringValue == "no-wrap") { return YGWrapNoWrap; }
|
|
if (stringValue == "wrap") { return YGWrapWrap; }
|
|
if (stringValue == "wrap-reverse") { return YGWrapWrapReverse; }
|
|
|
|
abort();
|
|
}
|
|
|
|
YGOverflow yogaStyleOverflowFromDynamic(const folly::dynamic &value) {
|
|
assert(value.isString());
|
|
auto stringValue = value.asString();
|
|
|
|
if (stringValue == "visible") { return YGOverflowVisible; }
|
|
if (stringValue == "hidden") { return YGOverflowHidden; }
|
|
if (stringValue == "scroll") { return YGOverflowScroll; }
|
|
|
|
abort();
|
|
}
|
|
|
|
YGDisplay yogaStyleDisplayFromDynamic(const folly::dynamic &value) {
|
|
assert(value.isString());
|
|
auto stringValue = value.asString();
|
|
|
|
if (stringValue == "flex") { return YGDisplayFlex; }
|
|
if (stringValue == "none") { return YGDisplayNone; }
|
|
|
|
abort();
|
|
}
|
|
|
|
YGValue yogaStyleValueFromDynamic(const folly::dynamic &value) {
|
|
if (value.isNumber()) {
|
|
float x = value.asDouble();
|
|
return { x, YGUnitPoint };
|
|
} else if (value.isString()) {
|
|
const auto stringValue = value.asString();
|
|
if (stringValue == "auto") {
|
|
return { YGUndefined, YGUnitAuto };
|
|
} else {
|
|
if (stringValue.back() == '%') {
|
|
return { folly::to<float>(stringValue.substr(stringValue.length() - 1)), YGUnitPercent };
|
|
} else {
|
|
return { folly::to<float>(stringValue), YGUnitPoint };
|
|
}
|
|
}
|
|
}
|
|
|
|
return YGValueUndefined;
|
|
}
|
|
|
|
YGFloatOptional yogaStyleOptionalFloatFromDynamic(const folly::dynamic &value) {
|
|
if (value.isNumber()) {
|
|
return YGFloatOptional(value.asDouble());
|
|
} else if (value.isString()) {
|
|
const auto stringValue = value.asString();
|
|
if (stringValue == "auto") {
|
|
return YGFloatOptional();
|
|
}
|
|
}
|
|
|
|
abort();
|
|
}
|
|
|
|
std::string stringFromYogaDimensions(std::array<float, 2> dimensions) {
|
|
return "{" + folly::to<std::string>(dimensions[0]) + ", " + folly::to<std::string>(dimensions[1]) + "}";
|
|
}
|
|
|
|
std::string stringFromYogaPosition(std::array<float, 4> position) {
|
|
return "{" + folly::to<std::string>(position[0]) + ", " + folly::to<std::string>(position[1]) + "}";
|
|
}
|
|
|
|
std::string stringFromYogaEdges(std::array<float, 6> edges) {
|
|
return "{" +
|
|
folly::to<std::string>(edges[0]) + ", " +
|
|
folly::to<std::string>(edges[1]) + ", " +
|
|
folly::to<std::string>(edges[2]) + ", " +
|
|
folly::to<std::string>(edges[3]) + "}";
|
|
}
|
|
|
|
std::string stringFromYogaStyleDirection(YGDirection value) {
|
|
switch (value) {
|
|
case YGDirectionInherit: return "inherit";
|
|
case YGDirectionLTR: return "ltr";
|
|
case YGDirectionRTL: return "rtl";
|
|
}
|
|
}
|
|
|
|
std::string stringFromYogaStyleFlexDirection(YGFlexDirection value) {
|
|
switch (value) {
|
|
case YGFlexDirectionColumn: return "column";
|
|
case YGFlexDirectionColumnReverse: return "column-reverse";
|
|
case YGFlexDirectionRow: return "row";
|
|
case YGFlexDirectionRowReverse: return "row-reverse";
|
|
}
|
|
}
|
|
|
|
std::string stringFromYogaStyleJustify(YGJustify value) {
|
|
switch (value) {
|
|
case YGJustifyFlexStart: return "flex-start";
|
|
case YGJustifyCenter: return "center";
|
|
case YGJustifyFlexEnd: return "flex-end";
|
|
case YGJustifySpaceBetween: return "space-between";
|
|
case YGJustifySpaceAround: return "space-around";
|
|
case YGJustifySpaceEvenly: return "space-evenly";
|
|
}
|
|
}
|
|
|
|
std::string stringFromYogaStyleAlign(YGAlign value) {
|
|
switch (value) {
|
|
case YGAlignAuto: return "auto";
|
|
case YGAlignFlexStart: return "flex-start";
|
|
case YGAlignCenter: return "center";
|
|
case YGAlignFlexEnd: return "flex-end";
|
|
case YGAlignStretch: return "stretch";
|
|
case YGAlignBaseline: return "baseline";
|
|
case YGAlignSpaceBetween: return "space-between";
|
|
case YGAlignSpaceAround: return "space-around";
|
|
}
|
|
}
|
|
|
|
std::string stringFromYogaStylePositionType(YGPositionType value) {
|
|
switch (value) {
|
|
case YGPositionTypeRelative: return "relative";
|
|
case YGPositionTypeAbsolute: return "absolute";
|
|
}
|
|
}
|
|
|
|
std::string stringFromYogaStyleWrap(YGWrap value) {
|
|
switch (value) {
|
|
case YGWrapNoWrap: return "no-wrap";
|
|
case YGWrapWrap: return "wrap";
|
|
case YGWrapWrapReverse: return "wrap-reverse";
|
|
}
|
|
}
|
|
|
|
std::string stringFromYogaStyleOverflow(YGOverflow value) {
|
|
switch (value) {
|
|
case YGOverflowVisible: return "visible";
|
|
case YGOverflowScroll: return "scroll";
|
|
case YGOverflowHidden: return "hidden";
|
|
}
|
|
}
|
|
|
|
std::string stringFromYogaStyleDisplay(YGDisplay value) {
|
|
switch (value) {
|
|
case YGDisplayFlex: return "flex";
|
|
case YGDisplayNone: return "none";
|
|
}
|
|
}
|
|
|
|
std::string stringFromYogaStyleValue(YGValue value) {
|
|
switch (value.unit) {
|
|
case YGUnitUndefined: return "undefined";
|
|
case YGUnitPoint: return folly::to<std::string>(value.value);
|
|
case YGUnitPercent: return folly::to<std::string>(value.value) + "%";
|
|
case YGUnitAuto: return "auto";
|
|
}
|
|
}
|
|
|
|
std::string stringFromYogaStyleOptionalFloat(YGFloatOptional value) {
|
|
if (value.isUndefined()) {
|
|
return "undefined";
|
|
}
|
|
|
|
return folly::to<std::string>(fabricFloatFromYogaFloat(value.getValue()));
|
|
}
|
|
|
|
std::string stringFromYogaStyleDimensions(std::array<YGValue, 2> value) {
|
|
return "{" +
|
|
stringFromYogaStyleValue(value[0]) + ", " +
|
|
stringFromYogaStyleValue(value[1]) + "}";
|
|
}
|
|
|
|
std::string stringFromYogaStyleEdge(std::array<YGValue, YGEdgeCount> value) {
|
|
return "{" +
|
|
stringFromYogaStyleValue(value[0]) + ", " +
|
|
stringFromYogaStyleValue(value[1]) + ", " +
|
|
stringFromYogaStyleValue(value[2]) + ", " +
|
|
stringFromYogaStyleValue(value[3]) + "}";
|
|
}
|
|
|
|
} // namespace react
|
|
} // namespace facebook
|