1575 lines
45 KiB
C++
1575 lines
45 KiB
C++
/*
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <glog/logging.h>
|
|
#include <react/debug/react_native_expect.h>
|
|
#include <react/renderer/components/view/primitives.h>
|
|
#include <react/renderer/core/LayoutMetrics.h>
|
|
#include <react/renderer/core/PropsParserContext.h>
|
|
#include <react/renderer/core/RawProps.h>
|
|
#include <react/renderer/core/graphicsConversions.h>
|
|
#include <react/renderer/css/CSSAngle.h>
|
|
#include <react/renderer/css/CSSNumber.h>
|
|
#include <react/renderer/css/CSSPercentage.h>
|
|
#include <react/renderer/css/CSSValueParser.h>
|
|
#include <react/renderer/graphics/BackgroundImage.h>
|
|
#include <react/renderer/graphics/BlendMode.h>
|
|
#include <react/renderer/graphics/Isolation.h>
|
|
#include <react/renderer/graphics/LinearGradient.h>
|
|
#include <react/renderer/graphics/PlatformColorParser.h>
|
|
#include <react/renderer/graphics/Transform.h>
|
|
#include <react/renderer/graphics/ValueUnit.h>
|
|
#include <yoga/YGEnums.h>
|
|
#include <yoga/node/Node.h>
|
|
#include <cmath>
|
|
#include <optional>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
|
|
namespace facebook::react {
|
|
|
|
/*
|
|
* Yoga's `float` <-> React Native's `Float` (can be `double` or `float`)
|
|
*
|
|
* Regular Yoga `float` values represent some onscreen-position-related values.
|
|
* They can be real numbers or special value `YGUndefined` (which actually is
|
|
* `NaN`). Conceptually, layout computation process inside Yoga should never
|
|
* produce `NaN` values from non-`NaN` values. At the same time, ` YGUndefined`
|
|
* values have special "no limit" meaning in Yoga, therefore ` YGUndefined`
|
|
* usually corresponds to `Infinity` value.
|
|
*/
|
|
inline Float floatFromYogaFloat(float value) {
|
|
static_assert(
|
|
YGUndefined != YGUndefined,
|
|
"The code of this function assumes that YGUndefined is NaN.");
|
|
if (std::isnan(value) /* means: `value == YGUndefined` */) {
|
|
return std::numeric_limits<Float>::infinity();
|
|
}
|
|
|
|
return (Float)value;
|
|
}
|
|
|
|
inline float yogaFloatFromFloat(Float value) {
|
|
if (!std::isfinite(value)) {
|
|
return YGUndefined;
|
|
}
|
|
|
|
return (float)value;
|
|
}
|
|
|
|
/*
|
|
* `yoga::FloatOptional` <-> React Native's `Float`
|
|
*
|
|
* `yoga::FloatOptional` represents optional dimensionless float values in Yoga
|
|
* Style object (e.g. `flex`). The most suitable analogy to empty
|
|
* `yoga::FloatOptional` is `NaN` value.
|
|
* `yoga::FloatOptional` values are usually parsed from some outside data source
|
|
* which usually has some special corresponding representation for an empty
|
|
* value.
|
|
*/
|
|
inline Float floatFromYogaOptionalFloat(yoga::FloatOptional value) {
|
|
if (value.isUndefined()) {
|
|
return std::numeric_limits<Float>::quiet_NaN();
|
|
}
|
|
|
|
return floatFromYogaFloat(value.unwrap());
|
|
}
|
|
|
|
inline yoga::FloatOptional yogaOptionalFloatFromFloat(Float value) {
|
|
if (std::isnan(value)) {
|
|
return yoga::FloatOptional();
|
|
}
|
|
|
|
return yoga::FloatOptional((float)value);
|
|
}
|
|
|
|
inline std::optional<Float> optionalFloatFromYogaValue(
|
|
const yoga::Style::Length& length,
|
|
std::optional<Float> base = {}) {
|
|
if (length.isPoints()) {
|
|
return floatFromYogaOptionalFloat(length.value());
|
|
} else if (length.isPercent()) {
|
|
return base.has_value()
|
|
? std::optional<Float>(
|
|
base.value() * floatFromYogaOptionalFloat(length.value()))
|
|
: std::optional<Float>();
|
|
} else {
|
|
return {};
|
|
}
|
|
}
|
|
|
|
static inline PositionType positionTypeFromYogaPositionType(
|
|
yoga::PositionType positionType) {
|
|
switch (positionType) {
|
|
case yoga::PositionType::Static:
|
|
return PositionType::Static;
|
|
case yoga::PositionType::Relative:
|
|
return PositionType::Relative;
|
|
case yoga::PositionType::Absolute:
|
|
return PositionType::Absolute;
|
|
}
|
|
}
|
|
|
|
inline DisplayType displayTypeFromYGDisplay(YGDisplay display) {
|
|
switch (display) {
|
|
case YGDisplayNone:
|
|
return DisplayType::None;
|
|
case YGDisplayContents:
|
|
return DisplayType::Contents;
|
|
case YGDisplayFlex:
|
|
return DisplayType::Flex;
|
|
}
|
|
}
|
|
|
|
inline LayoutMetrics layoutMetricsFromYogaNode(yoga::Node& yogaNode) {
|
|
auto layoutMetrics = LayoutMetrics{};
|
|
|
|
layoutMetrics.frame = Rect{
|
|
Point{
|
|
floatFromYogaFloat(YGNodeLayoutGetLeft(&yogaNode)),
|
|
floatFromYogaFloat(YGNodeLayoutGetTop(&yogaNode))},
|
|
Size{
|
|
floatFromYogaFloat(YGNodeLayoutGetWidth(&yogaNode)),
|
|
floatFromYogaFloat(YGNodeLayoutGetHeight(&yogaNode))}};
|
|
|
|
layoutMetrics.borderWidth = EdgeInsets{
|
|
floatFromYogaFloat(YGNodeLayoutGetBorder(&yogaNode, YGEdgeLeft)),
|
|
floatFromYogaFloat(YGNodeLayoutGetBorder(&yogaNode, YGEdgeTop)),
|
|
floatFromYogaFloat(YGNodeLayoutGetBorder(&yogaNode, YGEdgeRight)),
|
|
floatFromYogaFloat(YGNodeLayoutGetBorder(&yogaNode, YGEdgeBottom))};
|
|
|
|
layoutMetrics.contentInsets = EdgeInsets{
|
|
layoutMetrics.borderWidth.left +
|
|
floatFromYogaFloat(YGNodeLayoutGetPadding(&yogaNode, YGEdgeLeft)),
|
|
layoutMetrics.borderWidth.top +
|
|
floatFromYogaFloat(YGNodeLayoutGetPadding(&yogaNode, YGEdgeTop)),
|
|
layoutMetrics.borderWidth.right +
|
|
floatFromYogaFloat(YGNodeLayoutGetPadding(&yogaNode, YGEdgeRight)),
|
|
layoutMetrics.borderWidth.bottom +
|
|
floatFromYogaFloat(YGNodeLayoutGetPadding(&yogaNode, YGEdgeBottom))};
|
|
|
|
layoutMetrics.displayType =
|
|
displayTypeFromYGDisplay(YGNodeStyleGetDisplay(&yogaNode));
|
|
|
|
layoutMetrics.positionType =
|
|
positionTypeFromYogaPositionType(yogaNode.style().positionType());
|
|
|
|
layoutMetrics.layoutDirection =
|
|
YGNodeLayoutGetDirection(&yogaNode) == YGDirectionRTL
|
|
? LayoutDirection::RightToLeft
|
|
: LayoutDirection::LeftToRight;
|
|
|
|
return layoutMetrics;
|
|
}
|
|
|
|
inline YGDirection yogaDirectionFromLayoutDirection(LayoutDirection direction) {
|
|
switch (direction) {
|
|
case LayoutDirection::Undefined:
|
|
return YGDirectionInherit;
|
|
case LayoutDirection::LeftToRight:
|
|
return YGDirectionLTR;
|
|
case LayoutDirection::RightToLeft:
|
|
return YGDirectionRTL;
|
|
}
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& context,
|
|
const RawValue& value,
|
|
yoga::Direction& result) {
|
|
result = yoga::Direction::Inherit;
|
|
react_native_expect(value.hasType<std::string>());
|
|
if (!value.hasType<std::string>()) {
|
|
return;
|
|
}
|
|
auto stringValue = (std::string)value;
|
|
if (stringValue == "inherit") {
|
|
result = yoga::Direction::Inherit;
|
|
return;
|
|
}
|
|
if (stringValue == "ltr") {
|
|
result = yoga::Direction::LTR;
|
|
return;
|
|
}
|
|
if (stringValue == "rtl") {
|
|
result = yoga::Direction::RTL;
|
|
return;
|
|
}
|
|
LOG(ERROR) << "Could not parse yoga::Direction: " << stringValue;
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& context,
|
|
const RawValue& value,
|
|
yoga::FlexDirection& result) {
|
|
result = yoga::FlexDirection::Column;
|
|
react_native_expect(value.hasType<std::string>());
|
|
if (!value.hasType<std::string>()) {
|
|
return;
|
|
}
|
|
auto stringValue = (std::string)value;
|
|
if (stringValue == "row") {
|
|
result = yoga::FlexDirection::Row;
|
|
return;
|
|
}
|
|
if (stringValue == "column") {
|
|
result = yoga::FlexDirection::Column;
|
|
return;
|
|
}
|
|
if (stringValue == "column-reverse") {
|
|
result = yoga::FlexDirection::ColumnReverse;
|
|
return;
|
|
}
|
|
if (stringValue == "row-reverse") {
|
|
result = yoga::FlexDirection::RowReverse;
|
|
return;
|
|
}
|
|
LOG(ERROR) << "Could not parse yoga::FlexDirection: " << stringValue;
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& /*context*/,
|
|
const RawValue& value,
|
|
yoga::BoxSizing& result) {
|
|
result = yoga::BoxSizing::BorderBox;
|
|
react_native_expect(value.hasType<std::string>());
|
|
if (!value.hasType<std::string>()) {
|
|
return;
|
|
}
|
|
auto stringValue = (std::string)value;
|
|
if (stringValue == "border-box") {
|
|
result = yoga::BoxSizing::BorderBox;
|
|
return;
|
|
}
|
|
if (stringValue == "content-box") {
|
|
result = yoga::BoxSizing::ContentBox;
|
|
return;
|
|
}
|
|
|
|
LOG(ERROR) << "Could not parse yoga::BoxSizing: " << stringValue;
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& context,
|
|
const RawValue& value,
|
|
yoga::Justify& result) {
|
|
result = yoga::Justify::FlexStart;
|
|
react_native_expect(value.hasType<std::string>());
|
|
if (!value.hasType<std::string>()) {
|
|
return;
|
|
}
|
|
auto stringValue = (std::string)value;
|
|
if (stringValue == "flex-start") {
|
|
result = yoga::Justify::FlexStart;
|
|
return;
|
|
}
|
|
if (stringValue == "center") {
|
|
result = yoga::Justify::Center;
|
|
return;
|
|
}
|
|
if (stringValue == "flex-end") {
|
|
result = yoga::Justify::FlexEnd;
|
|
return;
|
|
}
|
|
if (stringValue == "space-between") {
|
|
result = yoga::Justify::SpaceBetween;
|
|
return;
|
|
}
|
|
if (stringValue == "space-around") {
|
|
result = yoga::Justify::SpaceAround;
|
|
return;
|
|
}
|
|
if (stringValue == "space-evenly") {
|
|
result = yoga::Justify::SpaceEvenly;
|
|
return;
|
|
}
|
|
LOG(ERROR) << "Could not parse yoga::Justify: " << stringValue;
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& context,
|
|
const RawValue& value,
|
|
yoga::Align& result) {
|
|
result = yoga::Align::Stretch;
|
|
react_native_expect(value.hasType<std::string>());
|
|
if (!value.hasType<std::string>()) {
|
|
return;
|
|
}
|
|
auto stringValue = (std::string)value;
|
|
if (stringValue == "auto") {
|
|
result = yoga::Align::Auto;
|
|
return;
|
|
}
|
|
if (stringValue == "flex-start") {
|
|
result = yoga::Align::FlexStart;
|
|
return;
|
|
}
|
|
if (stringValue == "center") {
|
|
result = yoga::Align::Center;
|
|
return;
|
|
}
|
|
if (stringValue == "flex-end") {
|
|
result = yoga::Align::FlexEnd;
|
|
return;
|
|
}
|
|
if (stringValue == "stretch") {
|
|
result = yoga::Align::Stretch;
|
|
return;
|
|
}
|
|
if (stringValue == "baseline") {
|
|
result = yoga::Align::Baseline;
|
|
return;
|
|
}
|
|
if (stringValue == "space-between") {
|
|
result = yoga::Align::SpaceBetween;
|
|
return;
|
|
}
|
|
if (stringValue == "space-around") {
|
|
result = yoga::Align::SpaceAround;
|
|
return;
|
|
}
|
|
if (stringValue == "space-evenly") {
|
|
result = yoga::Align::SpaceEvenly;
|
|
return;
|
|
}
|
|
LOG(ERROR) << "Could not parse yoga::Align: " << stringValue;
|
|
react_native_expect(false);
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& context,
|
|
const RawValue& value,
|
|
yoga::PositionType& result) {
|
|
result = yoga::PositionType::Relative;
|
|
react_native_expect(value.hasType<std::string>());
|
|
if (!value.hasType<std::string>()) {
|
|
return;
|
|
}
|
|
auto stringValue = (std::string)value;
|
|
if (stringValue == "static") {
|
|
result = yoga::PositionType::Static;
|
|
return;
|
|
}
|
|
if (stringValue == "relative") {
|
|
result = yoga::PositionType::Relative;
|
|
return;
|
|
}
|
|
if (stringValue == "absolute") {
|
|
result = yoga::PositionType::Absolute;
|
|
return;
|
|
}
|
|
LOG(ERROR) << "Could not parse yoga::PositionType: " << stringValue;
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& context,
|
|
const RawValue& value,
|
|
yoga::Wrap& result) {
|
|
result = yoga::Wrap::NoWrap;
|
|
react_native_expect(value.hasType<std::string>());
|
|
if (!value.hasType<std::string>()) {
|
|
return;
|
|
}
|
|
auto stringValue = (std::string)value;
|
|
if (stringValue == "nowrap") {
|
|
result = yoga::Wrap::NoWrap;
|
|
return;
|
|
}
|
|
if (stringValue == "wrap") {
|
|
result = yoga::Wrap::Wrap;
|
|
return;
|
|
}
|
|
if (stringValue == "wrap-reverse") {
|
|
result = yoga::Wrap::WrapReverse;
|
|
return;
|
|
}
|
|
LOG(ERROR) << "Could not parse yoga::Wrap: " << stringValue;
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& context,
|
|
const RawValue& value,
|
|
yoga::Overflow& result) {
|
|
result = yoga::Overflow::Visible;
|
|
react_native_expect(value.hasType<std::string>());
|
|
if (!value.hasType<std::string>()) {
|
|
return;
|
|
}
|
|
auto stringValue = (std::string)value;
|
|
if (stringValue == "visible") {
|
|
result = yoga::Overflow::Visible;
|
|
return;
|
|
}
|
|
if (stringValue == "hidden") {
|
|
result = yoga::Overflow::Hidden;
|
|
return;
|
|
}
|
|
if (stringValue == "scroll") {
|
|
result = yoga::Overflow::Scroll;
|
|
return;
|
|
}
|
|
LOG(ERROR) << "Could not parse yoga::Overflow:" << stringValue;
|
|
react_native_expect(false);
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& context,
|
|
const RawValue& value,
|
|
yoga::Display& result) {
|
|
result = yoga::Display::Flex;
|
|
react_native_expect(value.hasType<std::string>());
|
|
if (!value.hasType<std::string>()) {
|
|
return;
|
|
}
|
|
auto stringValue = (std::string)value;
|
|
if (stringValue == "flex") {
|
|
result = yoga::Display::Flex;
|
|
return;
|
|
}
|
|
if (stringValue == "none") {
|
|
result = yoga::Display::None;
|
|
return;
|
|
}
|
|
if (stringValue == "contents") {
|
|
result = yoga::Display::Contents;
|
|
return;
|
|
}
|
|
LOG(ERROR) << "Could not parse yoga::Display: " << stringValue;
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& /*context*/,
|
|
const RawValue& value,
|
|
yoga::Style::SizeLength& result) {
|
|
if (value.hasType<Float>()) {
|
|
result = yoga::StyleSizeLength::points((float)value);
|
|
return;
|
|
} else if (value.hasType<std::string>()) {
|
|
const auto stringValue = (std::string)value;
|
|
if (stringValue == "auto") {
|
|
result = yoga::StyleSizeLength::ofAuto();
|
|
return;
|
|
} else if (stringValue == "max-content") {
|
|
result = yoga::StyleSizeLength::ofMaxContent();
|
|
return;
|
|
} else if (stringValue == "stretch") {
|
|
result = yoga::StyleSizeLength::ofStretch();
|
|
return;
|
|
} else if (stringValue == "fit-content") {
|
|
result = yoga::StyleSizeLength::ofFitContent();
|
|
return;
|
|
} else {
|
|
auto parsed = parseCSSProperty<CSSNumber, CSSPercentage>(stringValue);
|
|
if (std::holds_alternative<CSSPercentage>(parsed)) {
|
|
result = yoga::StyleSizeLength::percent(
|
|
std::get<CSSPercentage>(parsed).value);
|
|
return;
|
|
} else if (std::holds_alternative<CSSNumber>(parsed)) {
|
|
result =
|
|
yoga::StyleSizeLength::points(std::get<CSSNumber>(parsed).value);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
result = yoga::StyleSizeLength::undefined();
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& context,
|
|
const RawValue& value,
|
|
yoga::Style::Length& result) {
|
|
if (value.hasType<Float>()) {
|
|
result = yoga::StyleLength::points((float)value);
|
|
return;
|
|
} else if (value.hasType<std::string>()) {
|
|
const auto stringValue = (std::string)value;
|
|
if (stringValue == "auto") {
|
|
result = yoga::StyleLength::ofAuto();
|
|
return;
|
|
} else {
|
|
auto parsed = parseCSSProperty<CSSNumber, CSSPercentage>(stringValue);
|
|
if (std::holds_alternative<CSSPercentage>(parsed)) {
|
|
result =
|
|
yoga::StyleLength::percent(std::get<CSSPercentage>(parsed).value);
|
|
return;
|
|
} else if (std::holds_alternative<CSSNumber>(parsed)) {
|
|
result = yoga::StyleLength::points(std::get<CSSNumber>(parsed).value);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
result = yoga::StyleLength::undefined();
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& context,
|
|
const RawValue& value,
|
|
YGValue& result) {
|
|
yoga::Style::Length length{};
|
|
fromRawValue(context, value, length);
|
|
result = (YGValue)length;
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& context,
|
|
const RawValue& value,
|
|
yoga::FloatOptional& result) {
|
|
result = value.hasType<float>() ? yoga::FloatOptional((float)value)
|
|
: yoga::FloatOptional();
|
|
}
|
|
|
|
inline std::optional<Float> toRadians(const RawValue& value) {
|
|
if (value.hasType<Float>()) {
|
|
return (Float)value;
|
|
}
|
|
if (!value.hasType<std::string>()) {
|
|
return {};
|
|
}
|
|
|
|
auto angle = parseCSSProperty<CSSAngle>((std::string)value);
|
|
if (std::holds_alternative<CSSAngle>(angle)) {
|
|
return std::get<CSSAngle>(angle).degrees * M_PI / 180.0f;
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
inline ValueUnit toValueUnit(const RawValue& value) {
|
|
if (value.hasType<Float>()) {
|
|
return ValueUnit((Float)value, UnitType::Point);
|
|
}
|
|
if (!value.hasType<std::string>()) {
|
|
return {};
|
|
}
|
|
|
|
auto pct = parseCSSProperty<CSSPercentage>((std::string)value);
|
|
if (std::holds_alternative<CSSPercentage>(pct)) {
|
|
return ValueUnit(std::get<CSSPercentage>(pct).value, UnitType::Percent);
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& /*context*/,
|
|
const RawValue& value,
|
|
ValueUnit& result) {
|
|
result = toValueUnit(value);
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& context,
|
|
const RawValue& value,
|
|
Transform& result) {
|
|
auto transformMatrix = Transform{};
|
|
react_native_expect(value.hasType<std::vector<RawValue>>());
|
|
if (!value.hasType<std::vector<RawValue>>()) {
|
|
result = transformMatrix;
|
|
return;
|
|
}
|
|
|
|
auto configurations = static_cast<std::vector<RawValue>>(value);
|
|
for (const auto& configuration : configurations) {
|
|
if (!configuration.hasType<std::unordered_map<std::string, RawValue>>()) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
auto configurationPair =
|
|
static_cast<std::unordered_map<std::string, RawValue>>(configuration);
|
|
if (configurationPair.size() != 1) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
auto pair = configurationPair.begin();
|
|
auto operation = pair->first;
|
|
auto& parameters = pair->second;
|
|
auto Zero = ValueUnit(0, UnitType::Point);
|
|
auto One = ValueUnit(1, UnitType::Point);
|
|
|
|
if (operation == "matrix") {
|
|
// T215634510: We should support matrix transforms as part of a list of
|
|
// transforms
|
|
if (configurations.size() > 1) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
if (!parameters.hasType<std::vector<Float>>()) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
auto numbers = (std::vector<Float>)parameters;
|
|
if (numbers.size() != 9 && numbers.size() != 16) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
size_t i = 0;
|
|
for (auto number : numbers) {
|
|
transformMatrix.matrix[i++] = number;
|
|
}
|
|
transformMatrix.operations.push_back(TransformOperation{
|
|
TransformOperationType::Arbitrary, Zero, Zero, Zero});
|
|
} else if (operation == "perspective") {
|
|
if (!parameters.hasType<Float>()) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
transformMatrix.operations.push_back(TransformOperation{
|
|
TransformOperationType::Perspective,
|
|
ValueUnit((Float)parameters, UnitType::Point),
|
|
Zero,
|
|
Zero});
|
|
} else if (operation == "rotateX") {
|
|
auto radians = toRadians(parameters);
|
|
if (!radians.has_value()) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
transformMatrix.operations.push_back(TransformOperation{
|
|
TransformOperationType::Rotate,
|
|
ValueUnit(*radians, UnitType::Point),
|
|
Zero,
|
|
Zero});
|
|
} else if (operation == "rotateY") {
|
|
auto radians = toRadians(parameters);
|
|
if (!radians.has_value()) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
transformMatrix.operations.push_back(TransformOperation{
|
|
TransformOperationType::Rotate,
|
|
Zero,
|
|
ValueUnit(*radians, UnitType::Point),
|
|
Zero});
|
|
} else if (operation == "rotateZ" || operation == "rotate") {
|
|
auto radians = toRadians(parameters);
|
|
if (!radians.has_value()) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
transformMatrix.operations.push_back(TransformOperation{
|
|
TransformOperationType::Rotate,
|
|
Zero,
|
|
Zero,
|
|
ValueUnit(*radians, UnitType::Point)});
|
|
} else if (operation == "scale") {
|
|
if (!parameters.hasType<Float>()) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
auto number = ValueUnit((Float)parameters, UnitType::Point);
|
|
transformMatrix.operations.push_back(TransformOperation{
|
|
TransformOperationType::Scale, number, number, number});
|
|
} else if (operation == "scaleX") {
|
|
if (!parameters.hasType<Float>()) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
transformMatrix.operations.push_back(TransformOperation{
|
|
TransformOperationType::Scale,
|
|
ValueUnit((Float)parameters, UnitType::Point),
|
|
One,
|
|
One});
|
|
} else if (operation == "scaleY") {
|
|
if (!parameters.hasType<Float>()) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
transformMatrix.operations.push_back(TransformOperation{
|
|
TransformOperationType::Scale,
|
|
One,
|
|
ValueUnit((Float)parameters, UnitType::Point),
|
|
One});
|
|
} else if (operation == "scaleZ") {
|
|
if (!parameters.hasType<Float>()) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
transformMatrix.operations.push_back(TransformOperation{
|
|
TransformOperationType::Scale,
|
|
One,
|
|
One,
|
|
ValueUnit((Float)parameters, UnitType::Point)});
|
|
} else if (operation == "translate") {
|
|
if (!parameters.hasType<std::vector<RawValue>>()) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
auto numbers = (std::vector<RawValue>)parameters;
|
|
if (numbers.size() != 2) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
auto valueX = toValueUnit(numbers[0]);
|
|
if (!valueX) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
auto valueY = toValueUnit(numbers[1]);
|
|
if (!valueY) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
transformMatrix.operations.push_back(TransformOperation{
|
|
TransformOperationType::Translate, valueX, valueY, Zero});
|
|
} else if (operation == "translateX") {
|
|
auto valueX = toValueUnit(parameters);
|
|
if (!valueX) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
transformMatrix.operations.push_back(TransformOperation{
|
|
TransformOperationType::Translate, valueX, Zero, Zero});
|
|
} else if (operation == "translateY") {
|
|
auto valueY = toValueUnit(parameters);
|
|
if (!valueY) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
transformMatrix.operations.push_back(TransformOperation{
|
|
TransformOperationType::Translate, Zero, valueY, Zero});
|
|
} else if (operation == "skewX") {
|
|
auto radians = toRadians(parameters);
|
|
if (!radians.has_value()) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
transformMatrix.operations.push_back(TransformOperation{
|
|
TransformOperationType::Skew,
|
|
ValueUnit(*radians, UnitType::Point),
|
|
Zero,
|
|
Zero});
|
|
} else if (operation == "skewY") {
|
|
auto radians = toRadians(parameters);
|
|
if (!radians.has_value()) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
transformMatrix.operations.push_back(TransformOperation{
|
|
TransformOperationType::Skew,
|
|
Zero,
|
|
ValueUnit(*radians, UnitType::Point),
|
|
Zero});
|
|
}
|
|
}
|
|
|
|
result = transformMatrix;
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& context,
|
|
const RawValue& value,
|
|
TransformOrigin& result) {
|
|
if (!value.hasType<std::vector<RawValue>>()) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
auto origins = (std::vector<RawValue>)value;
|
|
if (origins.size() != 3) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
TransformOrigin transformOrigin;
|
|
|
|
for (size_t i = 0; i < 2; i++) {
|
|
auto origin = toValueUnit(origins[i]);
|
|
if (!origin) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
transformOrigin.xy[i] = origin;
|
|
}
|
|
|
|
if (!origins[2].hasType<Float>()) {
|
|
result = {};
|
|
return;
|
|
}
|
|
transformOrigin.z = (Float)origins[2];
|
|
|
|
result = transformOrigin;
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& context,
|
|
const RawValue& value,
|
|
PointerEventsMode& result) {
|
|
result = PointerEventsMode::Auto;
|
|
react_native_expect(value.hasType<std::string>());
|
|
if (!value.hasType<std::string>()) {
|
|
return;
|
|
}
|
|
auto stringValue = (std::string)value;
|
|
if (stringValue == "auto") {
|
|
result = PointerEventsMode::Auto;
|
|
return;
|
|
}
|
|
if (stringValue == "none") {
|
|
result = PointerEventsMode::None;
|
|
return;
|
|
}
|
|
if (stringValue == "box-none") {
|
|
result = PointerEventsMode::BoxNone;
|
|
return;
|
|
}
|
|
if (stringValue == "box-only") {
|
|
result = PointerEventsMode::BoxOnly;
|
|
return;
|
|
}
|
|
LOG(ERROR) << "Could not parse PointerEventsMode:" << stringValue;
|
|
react_native_expect(false);
|
|
}
|
|
|
|
inline std::string toString(const PointerEventsMode& value) {
|
|
switch (value) {
|
|
case PointerEventsMode::Auto:
|
|
return "auto";
|
|
case PointerEventsMode::None:
|
|
return "none";
|
|
case PointerEventsMode::BoxNone:
|
|
return "box-none";
|
|
case PointerEventsMode::BoxOnly:
|
|
return "box-only";
|
|
}
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& context,
|
|
const RawValue& value,
|
|
BackfaceVisibility& result) {
|
|
result = BackfaceVisibility::Auto;
|
|
react_native_expect(value.hasType<std::string>());
|
|
if (!value.hasType<std::string>()) {
|
|
return;
|
|
}
|
|
auto stringValue = (std::string)value;
|
|
if (stringValue == "auto") {
|
|
result = BackfaceVisibility::Auto;
|
|
return;
|
|
}
|
|
if (stringValue == "visible") {
|
|
result = BackfaceVisibility::Visible;
|
|
return;
|
|
}
|
|
if (stringValue == "hidden") {
|
|
result = BackfaceVisibility::Hidden;
|
|
return;
|
|
}
|
|
LOG(ERROR) << "Could not parse BackfaceVisibility:" << stringValue;
|
|
react_native_expect(false);
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& context,
|
|
const RawValue& value,
|
|
BorderCurve& result) {
|
|
result = BorderCurve::Circular;
|
|
react_native_expect(value.hasType<std::string>());
|
|
if (!value.hasType<std::string>()) {
|
|
return;
|
|
}
|
|
auto stringValue = (std::string)value;
|
|
if (stringValue == "circular") {
|
|
result = BorderCurve::Circular;
|
|
return;
|
|
}
|
|
if (stringValue == "continuous") {
|
|
result = BorderCurve::Continuous;
|
|
return;
|
|
}
|
|
LOG(ERROR) << "Could not parse BorderCurve:" << stringValue;
|
|
react_native_expect(false);
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& context,
|
|
const RawValue& value,
|
|
BorderStyle& result) {
|
|
result = BorderStyle::Solid;
|
|
react_native_expect(value.hasType<std::string>());
|
|
if (!value.hasType<std::string>()) {
|
|
return;
|
|
}
|
|
auto stringValue = (std::string)value;
|
|
if (stringValue == "solid") {
|
|
result = BorderStyle::Solid;
|
|
return;
|
|
}
|
|
if (stringValue == "dotted") {
|
|
result = BorderStyle::Dotted;
|
|
return;
|
|
}
|
|
if (stringValue == "dashed") {
|
|
result = BorderStyle::Dashed;
|
|
return;
|
|
}
|
|
LOG(ERROR) << "Could not parse BorderStyle:" << stringValue;
|
|
react_native_expect(false);
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& context,
|
|
const RawValue& value,
|
|
OutlineStyle& result) {
|
|
result = OutlineStyle::Solid;
|
|
react_native_expect(value.hasType<std::string>());
|
|
if (!value.hasType<std::string>()) {
|
|
return;
|
|
}
|
|
auto stringValue = (std::string)value;
|
|
if (stringValue == "solid") {
|
|
result = OutlineStyle::Solid;
|
|
return;
|
|
}
|
|
if (stringValue == "dotted") {
|
|
result = OutlineStyle::Dotted;
|
|
return;
|
|
}
|
|
if (stringValue == "dashed") {
|
|
result = OutlineStyle::Dashed;
|
|
return;
|
|
}
|
|
LOG(ERROR) << "Could not parse OutlineStyle:" << stringValue;
|
|
react_native_expect(false);
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& context,
|
|
const RawValue& value,
|
|
Cursor& result) {
|
|
result = Cursor::Auto;
|
|
react_native_expect(value.hasType<std::string>());
|
|
if (!value.hasType<std::string>()) {
|
|
return;
|
|
}
|
|
auto stringValue = (std::string)value;
|
|
if (stringValue == "alias") {
|
|
result = Cursor::Alias;
|
|
return;
|
|
}
|
|
if (stringValue == "all-scroll") {
|
|
result = Cursor::AllScroll;
|
|
return;
|
|
}
|
|
if (stringValue == "auto") {
|
|
result = Cursor::Auto;
|
|
return;
|
|
}
|
|
if (stringValue == "cell") {
|
|
result = Cursor::Cell;
|
|
return;
|
|
}
|
|
if (stringValue == "col-resize") {
|
|
result = Cursor::ColResize;
|
|
return;
|
|
}
|
|
if (stringValue == "context-menu") {
|
|
result = Cursor::ContextMenu;
|
|
return;
|
|
}
|
|
if (stringValue == "copy") {
|
|
result = Cursor::Copy;
|
|
return;
|
|
}
|
|
if (stringValue == "crosshair") {
|
|
result = Cursor::Crosshair;
|
|
return;
|
|
}
|
|
if (stringValue == "default") {
|
|
result = Cursor::Default;
|
|
return;
|
|
}
|
|
if (stringValue == "e-resize") {
|
|
result = Cursor::EResize;
|
|
return;
|
|
}
|
|
if (stringValue == "ew-resize") {
|
|
result = Cursor::EWResize;
|
|
return;
|
|
}
|
|
if (stringValue == "grab") {
|
|
result = Cursor::Grab;
|
|
return;
|
|
}
|
|
if (stringValue == "grabbing") {
|
|
result = Cursor::Grabbing;
|
|
return;
|
|
}
|
|
if (stringValue == "help") {
|
|
result = Cursor::Help;
|
|
return;
|
|
}
|
|
if (stringValue == "move") {
|
|
result = Cursor::Move;
|
|
return;
|
|
}
|
|
if (stringValue == "n-resize") {
|
|
result = Cursor::NResize;
|
|
return;
|
|
}
|
|
if (stringValue == "ne-resize") {
|
|
result = Cursor::NEResize;
|
|
return;
|
|
}
|
|
if (stringValue == "nesw-resize") {
|
|
result = Cursor::NESWResize;
|
|
return;
|
|
}
|
|
if (stringValue == "ns-resize") {
|
|
result = Cursor::NSResize;
|
|
return;
|
|
}
|
|
if (stringValue == "nw-resize") {
|
|
result = Cursor::NWResize;
|
|
return;
|
|
}
|
|
if (stringValue == "nwse-resize") {
|
|
result = Cursor::NWSEResize;
|
|
return;
|
|
}
|
|
if (stringValue == "no-drop") {
|
|
result = Cursor::NoDrop;
|
|
return;
|
|
}
|
|
if (stringValue == "none") {
|
|
result = Cursor::None;
|
|
return;
|
|
}
|
|
if (stringValue == "not-allowed") {
|
|
result = Cursor::NotAllowed;
|
|
return;
|
|
}
|
|
if (stringValue == "pointer") {
|
|
result = Cursor::Pointer;
|
|
return;
|
|
}
|
|
if (stringValue == "progress") {
|
|
result = Cursor::Progress;
|
|
return;
|
|
}
|
|
if (stringValue == "row-resize") {
|
|
result = Cursor::RowResize;
|
|
return;
|
|
}
|
|
if (stringValue == "s-resize") {
|
|
result = Cursor::SResize;
|
|
return;
|
|
}
|
|
if (stringValue == "se-resize") {
|
|
result = Cursor::SEResize;
|
|
return;
|
|
}
|
|
if (stringValue == "sw-resize") {
|
|
result = Cursor::SWResize;
|
|
return;
|
|
}
|
|
if (stringValue == "text") {
|
|
result = Cursor::Text;
|
|
return;
|
|
}
|
|
if (stringValue == "url") {
|
|
result = Cursor::Url;
|
|
return;
|
|
}
|
|
if (stringValue == "w-resize") {
|
|
result = Cursor::WResize;
|
|
return;
|
|
}
|
|
if (stringValue == "wait") {
|
|
result = Cursor::Wait;
|
|
return;
|
|
}
|
|
if (stringValue == "zoom-in") {
|
|
result = Cursor::ZoomIn;
|
|
return;
|
|
}
|
|
if (stringValue == "zoom-out") {
|
|
result = Cursor::ZoomOut;
|
|
return;
|
|
}
|
|
LOG(ERROR) << "Could not parse Cursor:" << stringValue;
|
|
react_native_expect(false);
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& /*context*/,
|
|
const RawValue& value,
|
|
LayoutConformance& result) {
|
|
react_native_expect(value.hasType<std::string>());
|
|
result = LayoutConformance::Strict;
|
|
if (!value.hasType<std::string>()) {
|
|
return;
|
|
}
|
|
|
|
auto stringValue = (std::string)value;
|
|
if (stringValue == "strict") {
|
|
result = LayoutConformance::Strict;
|
|
} else if (stringValue == "compatibility") {
|
|
result = LayoutConformance::Compatibility;
|
|
} else {
|
|
LOG(ERROR) << "Unexpected LayoutConformance value:" << stringValue;
|
|
react_native_expect(false);
|
|
}
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& /*context*/,
|
|
const RawValue& value,
|
|
BlendMode& result) {
|
|
react_native_expect(value.hasType<std::string>());
|
|
result = BlendMode::Normal;
|
|
if (!value.hasType<std::string>()) {
|
|
return;
|
|
}
|
|
|
|
auto rawBlendMode = static_cast<std::string>(value);
|
|
std::optional<BlendMode> blendMode = blendModeFromString(rawBlendMode);
|
|
|
|
if (!blendMode) {
|
|
LOG(ERROR) << "Could not parse blend mode: " << rawBlendMode;
|
|
return;
|
|
}
|
|
|
|
result = blendMode.value();
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& context,
|
|
const RawValue& value,
|
|
std::vector<BackgroundImage>& result) {
|
|
react_native_expect(value.hasType<std::vector<RawValue>>());
|
|
if (!value.hasType<std::vector<RawValue>>()) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
std::vector<BackgroundImage> backgroundImage{};
|
|
auto rawBackgroundImage = static_cast<std::vector<RawValue>>(value);
|
|
for (const auto& rawBackgroundImageValue : rawBackgroundImage) {
|
|
bool isMap = rawBackgroundImageValue
|
|
.hasType<std::unordered_map<std::string, RawValue>>();
|
|
react_native_expect(isMap);
|
|
if (!isMap) {
|
|
result = {};
|
|
return;
|
|
}
|
|
|
|
auto rawBackgroundImageMap =
|
|
static_cast<std::unordered_map<std::string, RawValue>>(
|
|
rawBackgroundImageValue);
|
|
|
|
auto typeIt = rawBackgroundImageMap.find("type");
|
|
if (typeIt == rawBackgroundImageMap.end() ||
|
|
!typeIt->second.hasType<std::string>()) {
|
|
continue;
|
|
}
|
|
|
|
std::string type = (std::string)(typeIt->second);
|
|
std::vector<ColorStop> colorStops;
|
|
auto colorStopsIt = rawBackgroundImageMap.find("colorStops");
|
|
|
|
if (colorStopsIt != rawBackgroundImageMap.end() &&
|
|
colorStopsIt->second.hasType<std::vector<RawValue>>()) {
|
|
auto rawColorStops =
|
|
static_cast<std::vector<RawValue>>(colorStopsIt->second);
|
|
|
|
for (const auto& stop : rawColorStops) {
|
|
if (stop.hasType<std::unordered_map<std::string, RawValue>>()) {
|
|
auto stopMap =
|
|
static_cast<std::unordered_map<std::string, RawValue>>(stop);
|
|
auto positionIt = stopMap.find("position");
|
|
auto colorIt = stopMap.find("color");
|
|
|
|
if (positionIt != stopMap.end() && colorIt != stopMap.end()) {
|
|
ColorStop colorStop;
|
|
if (positionIt->second.hasValue()) {
|
|
auto valueUnit = toValueUnit(positionIt->second);
|
|
if (!valueUnit) {
|
|
result = {};
|
|
return;
|
|
}
|
|
colorStop.position = valueUnit;
|
|
}
|
|
if (colorIt->second.hasValue()) {
|
|
fromRawValue(
|
|
context.contextContainer,
|
|
context.surfaceId,
|
|
colorIt->second,
|
|
colorStop.color);
|
|
}
|
|
colorStops.push_back(colorStop);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (type == "linear-gradient") {
|
|
LinearGradient linearGradient;
|
|
|
|
auto directionIt = rawBackgroundImageMap.find("direction");
|
|
if (directionIt != rawBackgroundImageMap.end() &&
|
|
directionIt->second
|
|
.hasType<std::unordered_map<std::string, RawValue>>()) {
|
|
auto directionMap =
|
|
static_cast<std::unordered_map<std::string, RawValue>>(
|
|
directionIt->second);
|
|
|
|
auto directionTypeIt = directionMap.find("type");
|
|
auto valueIt = directionMap.find("value");
|
|
|
|
if (directionTypeIt != directionMap.end() &&
|
|
valueIt != directionMap.end()) {
|
|
std::string directionType = (std::string)(directionTypeIt->second);
|
|
|
|
if (directionType == "angle") {
|
|
linearGradient.direction.type = GradientDirectionType::Angle;
|
|
if (valueIt->second.hasType<Float>()) {
|
|
linearGradient.direction.value = (Float)(valueIt->second);
|
|
}
|
|
} else if (directionType == "keyword") {
|
|
linearGradient.direction.type = GradientDirectionType::Keyword;
|
|
if (valueIt->second.hasType<std::string>()) {
|
|
linearGradient.direction.value =
|
|
parseGradientKeyword((std::string)(valueIt->second));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!colorStops.empty()) {
|
|
linearGradient.colorStops = colorStops;
|
|
}
|
|
|
|
backgroundImage.emplace_back(std::move(linearGradient));
|
|
} else if (type == "radial-gradient") {
|
|
RadialGradient radialGradient;
|
|
auto shapeIt = rawBackgroundImageMap.find("shape");
|
|
if (shapeIt != rawBackgroundImageMap.end() &&
|
|
shapeIt->second.hasType<std::string>()) {
|
|
auto shape = (std::string)(shapeIt->second);
|
|
radialGradient.shape = shape == "circle" ? RadialGradientShape::Circle
|
|
: RadialGradientShape::Ellipse;
|
|
}
|
|
|
|
auto sizeIt = rawBackgroundImageMap.find("size");
|
|
if (sizeIt != rawBackgroundImageMap.end()) {
|
|
if (sizeIt->second.hasType<std::string>()) {
|
|
auto sizeStr = (std::string)(sizeIt->second);
|
|
if (sizeStr == "closest-side") {
|
|
radialGradient.size.value =
|
|
RadialGradientSize::SizeKeyword::ClosestSide;
|
|
} else if (sizeStr == "farthest-side") {
|
|
radialGradient.size.value =
|
|
RadialGradientSize::SizeKeyword::FarthestSide;
|
|
} else if (sizeStr == "closest-corner") {
|
|
radialGradient.size.value =
|
|
RadialGradientSize::SizeKeyword::ClosestCorner;
|
|
} else if (sizeStr == "farthest-corner") {
|
|
radialGradient.size.value =
|
|
RadialGradientSize::SizeKeyword::FarthestCorner;
|
|
}
|
|
} else if (sizeIt->second
|
|
.hasType<std::unordered_map<std::string, RawValue>>()) {
|
|
auto sizeMap = static_cast<std::unordered_map<std::string, RawValue>>(
|
|
sizeIt->second);
|
|
auto xIt = sizeMap.find("x");
|
|
auto yIt = sizeMap.find("y");
|
|
if (xIt != sizeMap.end() && yIt != sizeMap.end()) {
|
|
RadialGradientSize sizeObj;
|
|
sizeObj.value = RadialGradientSize::Dimensions{
|
|
toValueUnit(xIt->second), toValueUnit(yIt->second)};
|
|
radialGradient.size = sizeObj;
|
|
}
|
|
}
|
|
|
|
auto positionIt = rawBackgroundImageMap.find("position");
|
|
if (positionIt != rawBackgroundImageMap.end() &&
|
|
positionIt->second
|
|
.hasType<std::unordered_map<std::string, RawValue>>()) {
|
|
auto positionMap =
|
|
static_cast<std::unordered_map<std::string, RawValue>>(
|
|
positionIt->second);
|
|
|
|
auto topIt = positionMap.find("top");
|
|
auto bottomIt = positionMap.find("bottom");
|
|
auto leftIt = positionMap.find("left");
|
|
auto rightIt = positionMap.find("right");
|
|
|
|
if (topIt != positionMap.end()) {
|
|
auto topValue = toValueUnit(topIt->second);
|
|
radialGradient.position.top = topValue;
|
|
} else if (bottomIt != positionMap.end()) {
|
|
auto bottomValue = toValueUnit(bottomIt->second);
|
|
radialGradient.position.bottom = bottomValue;
|
|
}
|
|
|
|
if (leftIt != positionMap.end()) {
|
|
auto leftValue = toValueUnit(leftIt->second);
|
|
radialGradient.position.left = leftValue;
|
|
} else if (rightIt != positionMap.end()) {
|
|
auto rightValue = toValueUnit(rightIt->second);
|
|
radialGradient.position.right = rightValue;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!colorStops.empty()) {
|
|
radialGradient.colorStops = colorStops;
|
|
}
|
|
|
|
backgroundImage.emplace_back(std::move(radialGradient));
|
|
}
|
|
}
|
|
|
|
result = backgroundImage;
|
|
}
|
|
|
|
inline void fromRawValue(
|
|
const PropsParserContext& /*context*/,
|
|
const RawValue& value,
|
|
Isolation& result) {
|
|
react_native_expect(value.hasType<std::string>());
|
|
result = Isolation::Auto;
|
|
if (!value.hasType<std::string>()) {
|
|
return;
|
|
}
|
|
|
|
auto rawIsolation = static_cast<std::string>(value);
|
|
std::optional<Isolation> isolation = isolationFromString(rawIsolation);
|
|
|
|
if (!isolation) {
|
|
LOG(ERROR) << "Could not parse isolation: " << rawIsolation;
|
|
return;
|
|
}
|
|
|
|
result = isolation.value();
|
|
}
|
|
|
|
template <size_t N>
|
|
inline std::string toString(const std::array<float, N> vec) {
|
|
std::string s;
|
|
|
|
s.append("{");
|
|
for (size_t i = 0; i < N - 1; i++) {
|
|
s.append(std::to_string(vec[i]) + ", ");
|
|
}
|
|
s.append(std::to_string(vec[N - 1]));
|
|
s.append("}");
|
|
|
|
return s;
|
|
}
|
|
|
|
inline std::string toString(const yoga::Direction& value) {
|
|
return YGDirectionToString(yoga::unscopedEnum(value));
|
|
}
|
|
|
|
inline std::string toString(const yoga::FlexDirection& value) {
|
|
return YGFlexDirectionToString(yoga::unscopedEnum(value));
|
|
}
|
|
|
|
inline std::string toString(const yoga::Justify& value) {
|
|
return YGJustifyToString(yoga::unscopedEnum(value));
|
|
}
|
|
|
|
inline std::string toString(const yoga::Align& value) {
|
|
return YGAlignToString(yoga::unscopedEnum(value));
|
|
}
|
|
|
|
inline std::string toString(const yoga::PositionType& value) {
|
|
return YGPositionTypeToString(yoga::unscopedEnum(value));
|
|
}
|
|
|
|
inline std::string toString(const yoga::Wrap& value) {
|
|
return YGWrapToString(yoga::unscopedEnum(value));
|
|
}
|
|
|
|
inline std::string toString(const yoga::Overflow& value) {
|
|
return YGOverflowToString(yoga::unscopedEnum(value));
|
|
}
|
|
|
|
inline std::string toString(const yoga::Display& value) {
|
|
return YGDisplayToString(yoga::unscopedEnum(value));
|
|
}
|
|
|
|
inline std::string toString(const yoga::Style::Length& length) {
|
|
if (length.isUndefined()) {
|
|
return "undefined";
|
|
} else if (length.isAuto()) {
|
|
return "auto";
|
|
} else if (length.isPoints()) {
|
|
return std::to_string(length.value().unwrap());
|
|
} else if (length.isPercent()) {
|
|
return std::to_string(length.value().unwrap()) + "%";
|
|
} else {
|
|
return "unknown";
|
|
}
|
|
}
|
|
|
|
inline std::string toString(const yoga::Style::SizeLength& length) {
|
|
if (length.isUndefined()) {
|
|
return "undefined";
|
|
} else if (length.isAuto()) {
|
|
return "auto";
|
|
} else if (length.isPoints()) {
|
|
return std::to_string(length.value().unwrap());
|
|
} else if (length.isPercent()) {
|
|
return std::to_string(length.value().unwrap()) + "%";
|
|
} else if (length.isMaxContent()) {
|
|
return "max-content";
|
|
} else if (length.isFitContent()) {
|
|
return "fit-content";
|
|
} else if (length.isStretch()) {
|
|
return "stretch";
|
|
} else {
|
|
return "unknown";
|
|
}
|
|
}
|
|
|
|
inline std::string toString(const yoga::FloatOptional& value) {
|
|
if (value.isUndefined()) {
|
|
return "undefined";
|
|
}
|
|
|
|
return std::to_string(value.unwrap());
|
|
}
|
|
|
|
inline std::string toString(const LayoutConformance& value) {
|
|
switch (value) {
|
|
case LayoutConformance::Strict:
|
|
return "strict";
|
|
case LayoutConformance::Compatibility:
|
|
return "compatibility";
|
|
}
|
|
}
|
|
|
|
inline std::string toString(const std::array<Float, 16>& m) {
|
|
std::string result;
|
|
result += "[ " + std::to_string(m[0]) + " " + std::to_string(m[1]) + " " +
|
|
std::to_string(m[2]) + " " + std::to_string(m[3]) + " ]\n";
|
|
result += "[ " + std::to_string(m[4]) + " " + std::to_string(m[5]) + " " +
|
|
std::to_string(m[6]) + " " + std::to_string(m[7]) + " ]\n";
|
|
result += "[ " + std::to_string(m[8]) + " " + std::to_string(m[9]) + " " +
|
|
std::to_string(m[10]) + " " + std::to_string(m[11]) + " ]\n";
|
|
result += "[ " + std::to_string(m[12]) + " " + std::to_string(m[13]) + " " +
|
|
std::to_string(m[14]) + " " + std::to_string(m[15]) + " ]";
|
|
return result;
|
|
}
|
|
|
|
inline std::string toString(const Transform& transform) {
|
|
std::string result = "[";
|
|
bool first = true;
|
|
|
|
for (const auto& operation : transform.operations) {
|
|
if (!first) {
|
|
result += ", ";
|
|
}
|
|
first = false;
|
|
|
|
switch (operation.type) {
|
|
case TransformOperationType::Perspective: {
|
|
result +=
|
|
"{\"perspective\": " + std::to_string(operation.x.value) + "}";
|
|
break;
|
|
}
|
|
case TransformOperationType::Rotate: {
|
|
if (operation.x.value != 0 && operation.y.value == 0 &&
|
|
operation.z.value == 0) {
|
|
result +=
|
|
R"({"rotateX": ")" + std::to_string(operation.x.value) + "rad\"}";
|
|
} else if (
|
|
operation.x.value == 0 && operation.y.value != 0 &&
|
|
operation.z.value == 0) {
|
|
result +=
|
|
R"({"rotateY": ")" + std::to_string(operation.y.value) + "rad\"}";
|
|
} else if (
|
|
operation.x.value == 0 && operation.y.value == 0 &&
|
|
operation.z.value != 0) {
|
|
result +=
|
|
R"({"rotateZ": ")" + std::to_string(operation.z.value) + "rad\"}";
|
|
}
|
|
break;
|
|
}
|
|
case TransformOperationType::Scale: {
|
|
if (operation.x.value == operation.y.value &&
|
|
operation.x.value == operation.z.value) {
|
|
result += "{\"scale\": " + std::to_string(operation.x.value) + "}";
|
|
} else if (operation.y.value == 1 && operation.z.value == 1) {
|
|
result += "{\"scaleX\": " + std::to_string(operation.x.value) + "}";
|
|
} else if (operation.x.value == 1 && operation.z.value == 1) {
|
|
result += "{\"scaleY\": " + std::to_string(operation.y.value) + "}";
|
|
} else if (operation.x.value == 1 && operation.y.value == 1) {
|
|
result += "{\"scaleZ\": " + std::to_string(operation.z.value) + "}";
|
|
}
|
|
break;
|
|
}
|
|
case TransformOperationType::Translate: {
|
|
if (operation.x.value != 0 && operation.y.value != 0 &&
|
|
operation.z.value == 0) {
|
|
result += "{\"translate\": [";
|
|
result += std::to_string(operation.x.value) + ", " +
|
|
std::to_string(operation.y.value);
|
|
result += "]}";
|
|
} else if (operation.x.value != 0 && operation.y.value == 0) {
|
|
result +=
|
|
"{\"translateX\": " + std::to_string(operation.x.value) + "}";
|
|
} else if (operation.x.value == 0 && operation.y.value != 0) {
|
|
result +=
|
|
"{\"translateY\": " + std::to_string(operation.y.value) + "}";
|
|
}
|
|
break;
|
|
}
|
|
case TransformOperationType::Skew: {
|
|
if (operation.x.value != 0 && operation.y.value == 0) {
|
|
result +=
|
|
R"({"skewX": ")" + std::to_string(operation.x.value) + "rad\"}";
|
|
} else if (operation.x.value == 0 && operation.y.value != 0) {
|
|
result +=
|
|
R"({"skewY": ")" + std::to_string(operation.y.value) + "rad\"}";
|
|
}
|
|
break;
|
|
}
|
|
case TransformOperationType::Arbitrary: {
|
|
result += "{\"matrix\": " + toString(transform.matrix) + "}";
|
|
break;
|
|
}
|
|
case TransformOperationType::Identity: {
|
|
result += "{\"identity\": true}";
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
result += "]";
|
|
return result;
|
|
}
|
|
|
|
} // namespace facebook::react
|