pythonnative 0.40.0__cp313-cp313-win_amd64.whl

pythonnative/native/yoga/yoga/algorithm/CalculateLayout.h

@@ -0,0 +1,38 @@
+/*
+ * 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 <yoga/Yoga.h>
+#include <yoga/algorithm/FlexDirection.h>
+#include <yoga/event/event.h>
+#include <yoga/node/Node.h>
+
+namespace facebook::yoga {
+
+void calculateLayout(
+    yoga::Node* node,
+    float ownerWidth,
+    float ownerHeight,
+    Direction ownerDirection);
+
+bool calculateLayoutInternal(
+    yoga::Node* node,
+    float availableWidth,
+    float availableHeight,
+    Direction ownerDirection,
+    SizingMode widthSizingMode,
+    SizingMode heightSizingMode,
+    float ownerWidth,
+    float ownerHeight,
+    bool performLayout,
+    LayoutPassReason reason,
+    LayoutData& layoutMarkerData,
+    uint32_t depth,
+    uint32_t generationCount);
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/algorithm/FlexDirection.h

@@ -0,0 +1,120 @@
+/*
+ * 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 <yoga/Yoga.h>
+
+#include <yoga/debug/AssertFatal.h>
+#include <yoga/enums/Dimension.h>
+#include <yoga/enums/Direction.h>
+#include <yoga/enums/Edge.h>
+#include <yoga/enums/FlexDirection.h>
+#include <yoga/enums/PhysicalEdge.h>
+
+namespace facebook::yoga {
+
+inline bool isRow(const FlexDirection flexDirection) {
+  return flexDirection == FlexDirection::Row ||
+      flexDirection == FlexDirection::RowReverse;
+}
+
+inline bool isColumn(const FlexDirection flexDirection) {
+  return flexDirection == FlexDirection::Column ||
+      flexDirection == FlexDirection::ColumnReverse;
+}
+
+inline FlexDirection resolveDirection(
+    const FlexDirection flexDirection,
+    const Direction direction) {
+  if (direction == Direction::RTL) {
+    if (flexDirection == FlexDirection::Row) {
+      return FlexDirection::RowReverse;
+    } else if (flexDirection == FlexDirection::RowReverse) {
+      return FlexDirection::Row;
+    }
+  }
+
+  return flexDirection;
+}
+
+inline FlexDirection resolveCrossDirection(
+    const FlexDirection flexDirection,
+    const Direction direction) {
+  return isColumn(flexDirection)
+      ? resolveDirection(FlexDirection::Row, direction)
+      : FlexDirection::Column;
+}
+
+inline PhysicalEdge flexStartEdge(FlexDirection flexDirection) {
+  switch (flexDirection) {
+    case FlexDirection::Column:
+      return PhysicalEdge::Top;
+    case FlexDirection::ColumnReverse:
+      return PhysicalEdge::Bottom;
+    case FlexDirection::Row:
+      return PhysicalEdge::Left;
+    case FlexDirection::RowReverse:
+      return PhysicalEdge::Right;
+  }
+
+  fatalWithMessage("Invalid FlexDirection");
+}
+
+inline PhysicalEdge flexEndEdge(FlexDirection flexDirection) {
+  switch (flexDirection) {
+    case FlexDirection::Column:
+      return PhysicalEdge::Bottom;
+    case FlexDirection::ColumnReverse:
+      return PhysicalEdge::Top;
+    case FlexDirection::Row:
+      return PhysicalEdge::Right;
+    case FlexDirection::RowReverse:
+      return PhysicalEdge::Left;
+  }
+
+  fatalWithMessage("Invalid FlexDirection");
+}
+
+inline PhysicalEdge inlineStartEdge(
+    FlexDirection flexDirection,
+    Direction direction) {
+  if (isRow(flexDirection)) {
+    return direction == Direction::RTL ? PhysicalEdge::Right
+                                       : PhysicalEdge::Left;
+  }
+
+  return PhysicalEdge::Top;
+}
+
+inline PhysicalEdge inlineEndEdge(
+    FlexDirection flexDirection,
+    Direction direction) {
+  if (isRow(flexDirection)) {
+    return direction == Direction::RTL ? PhysicalEdge::Left
+                                       : PhysicalEdge::Right;
+  }
+
+  return PhysicalEdge::Bottom;
+}
+
+inline Dimension dimension(FlexDirection flexDirection) {
+  switch (flexDirection) {
+    case FlexDirection::Column:
+      return Dimension::Height;
+    case FlexDirection::ColumnReverse:
+      return Dimension::Height;
+    case FlexDirection::Row:
+      return Dimension::Width;
+    case FlexDirection::RowReverse:
+      return Dimension::Width;
+  }
+
+  fatalWithMessage("Invalid FlexDirection");
+}
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/algorithm/FlexLine.cpp

@@ -0,0 +1,124 @@
+/*
+ * 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.
+ */
+
+#include <yoga/Yoga.h>
+
+#include <yoga/algorithm/BoundAxis.h>
+#include <yoga/algorithm/FlexDirection.h>
+#include <yoga/algorithm/FlexLine.h>
+
+namespace facebook::yoga {
+
+FlexLine calculateFlexLine(
+    yoga::Node* const node,
+    const Direction ownerDirection,
+    const float ownerWidth,
+    const float mainAxisownerSize,
+    const float availableInnerWidth,
+    const float availableInnerMainDim,
+    Node::LayoutableChildren::Iterator& iterator,
+    const size_t lineCount) {
+  std::vector<yoga::Node*> itemsInFlow;
+  itemsInFlow.reserve(node->getChildCount());
+
+  float sizeConsumed = 0.0f;
+  float totalFlexGrowFactors = 0.0f;
+  float totalFlexShrinkScaledFactors = 0.0f;
+  size_t numberOfAutoMargins = 0;
+  yoga::Node* firstElementInLine = nullptr;
+
+  float sizeConsumedIncludingMinConstraint = 0;
+  const Direction direction = node->resolveDirection(ownerDirection);
+  const FlexDirection mainAxis =
+      resolveDirection(node->style().flexDirection(), direction);
+  const bool isNodeFlexWrap = node->style().flexWrap() != Wrap::NoWrap;
+  const float gap =
+      node->style().computeGapForAxis(mainAxis, availableInnerMainDim);
+
+  const auto childrenEnd = node->getLayoutChildren().end();
+  // Add items to the current line until it's full or we run out of items.
+  for (; iterator != childrenEnd; iterator++) {
+    auto child = *iterator;
+    if (child->style().display() == Display::None ||
+        child->style().positionType() == PositionType::Absolute) {
+      continue;
+    }
+
+    if (firstElementInLine == nullptr) {
+      firstElementInLine = child;
+    }
+
+    if (child->style().flexStartMarginIsAuto(mainAxis, ownerDirection)) {
+      numberOfAutoMargins++;
+    }
+    if (child->style().flexEndMarginIsAuto(mainAxis, ownerDirection)) {
+      numberOfAutoMargins++;
+    }
+
+    child->setLineIndex(lineCount);
+    const float childMarginMainAxis =
+        child->style().computeMarginForAxis(mainAxis, availableInnerWidth);
+    const float childLeadingGapMainAxis =
+        child == firstElementInLine ? 0.0f : gap;
+    const float flexBasisWithMinAndMaxConstraints =
+        boundAxisWithinMinAndMax(
+            child,
+            direction,
+            mainAxis,
+            child->getLayout().computedFlexBasis,
+            mainAxisownerSize,
+            ownerWidth)
+            .unwrap();
+
+    // If this is a multi-line flow and this item pushes us over the available
+    // size, we've hit the end of the current line. Break out of the loop and
+    // lay out the current line.
+    if (sizeConsumedIncludingMinConstraint + flexBasisWithMinAndMaxConstraints +
+                childMarginMainAxis + childLeadingGapMainAxis >
+            availableInnerMainDim &&
+        isNodeFlexWrap && !itemsInFlow.empty()) {
+      break;
+    }
+
+    sizeConsumedIncludingMinConstraint += flexBasisWithMinAndMaxConstraints +
+        childMarginMainAxis + childLeadingGapMainAxis;
+    sizeConsumed += flexBasisWithMinAndMaxConstraints + childMarginMainAxis +
+        childLeadingGapMainAxis;
+
+    if (child->isNodeFlexible()) {
+      totalFlexGrowFactors += child->resolveFlexGrow();
+
+      // Unlike the grow factor, the shrink factor is scaled relative to the
+      // child dimension.
+      totalFlexShrinkScaledFactors += -child->resolveFlexShrink() *
+          child->getLayout().computedFlexBasis.unwrap();
+    }
+
+    itemsInFlow.push_back(child);
+  }
+
+  // The total flex factor needs to be floored to 1.
+  if (totalFlexGrowFactors > 0 && totalFlexGrowFactors < 1) {
+    totalFlexGrowFactors = 1;
+  }
+
+  // The total flex shrink factor needs to be floored to 1.
+  if (totalFlexShrinkScaledFactors > 0 && totalFlexShrinkScaledFactors < 1) {
+    totalFlexShrinkScaledFactors = 1;
+  }
+
+  return FlexLine{
+      .itemsInFlow = std::move(itemsInFlow),
+      .sizeConsumed = sizeConsumed,
+      .numberOfAutoMargins = numberOfAutoMargins,
+      .layout = FlexLineRunningLayout{
+          totalFlexGrowFactors,
+          totalFlexShrinkScaledFactors,
+      }};
+}
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/algorithm/FlexLine.h

@@ -0,0 +1,75 @@
+/*
+ * 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 <vector>
+
+#include <yoga/Yoga.h>
+#include <yoga/node/Node.h>
+
+namespace facebook::yoga {
+
+struct FlexLineRunningLayout {
+  // Total flex grow factors of flex items which are to be laid in the current
+  // line. This is decremented as free space is distributed.
+  float totalFlexGrowFactors{0.0f};
+
+  // Total flex shrink factors of flex items which are to be laid in the current
+  // line. This is decremented as free space is distributed.
+  float totalFlexShrinkScaledFactors{0.0f};
+
+  // The amount of available space within inner dimensions of the line which may
+  // still be distributed.
+  float remainingFreeSpace{0.0f};
+
+  // The size of the mainDim for the row after considering size, padding, margin
+  // and border of flex items. This is used to calculate maxLineDim after going
+  // through all the rows to decide on the main axis size of owner.
+  float mainDim{0.0f};
+
+  // The size of the crossDim for the row after considering size, padding,
+  // margin and border of flex items. Used for calculating containers crossSize.
+  float crossDim{0.0f};
+};
+
+struct FlexLine {
+  // List of children which are part of the line flow. This means they are not
+  // positioned absolutely, or with `display: "none"`, and do not overflow the
+  // available dimensions.
+  const std::vector<yoga::Node*> itemsInFlow{};
+
+  // Accumulation of the dimensions and margin of all the children on the
+  // current line. This will be used in order to either set the dimensions of
+  // the node if none already exist or to compute the remaining space left for
+  // the flexible children.
+  const float sizeConsumed{0.0f};
+
+  // Number of edges along the line flow with an auto margin.
+  const size_t numberOfAutoMargins{0};
+
+  // Layout information about the line computed in steps after line-breaking
+  FlexLineRunningLayout layout{};
+};
+
+// Calculates where a line starting at a given index should break, returning
+// information about the collective children on the liune.
+//
+// This function assumes that all the children of node have their
+// computedFlexBasis properly computed(To do this use
+// computeFlexBasisForChildren function).
+FlexLine calculateFlexLine(
+    yoga::Node* node,
+    Direction ownerDirection,
+    float ownerWidth,
+    float mainAxisownerSize,
+    float availableInnerWidth,
+    float availableInnerMainDim,
+    Node::LayoutableChildren::Iterator& iterator,
+    size_t lineCount);
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/algorithm/PixelGrid.cpp

@@ -0,0 +1,132 @@
+/*
+ * 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.
+ */
+
+#include <yoga/Yoga.h>
+
+#include <yoga/algorithm/PixelGrid.h>
+#include <yoga/numeric/Comparison.h>
+
+namespace facebook::yoga {
+
+float roundValueToPixelGrid(
+    const double value,
+    const double pointScaleFactor,
+    const bool forceCeil,
+    const bool forceFloor) {
+  double scaledValue = value * pointScaleFactor;
+  // We want to calculate `fractial` such that `floor(scaledValue) = scaledValue
+  // - fractial`.
+  double fractial = fmod(scaledValue, 1.0);
+  if (fractial < 0) {
+    // This branch is for handling negative numbers for `value`.
+    //
+    // Regarding `floor` and `ceil`. Note that for a number x, `floor(x) <= x <=
+    // ceil(x)` even for negative numbers. Here are a couple of examples:
+    //   - x =  2.2: floor( 2.2) =  2, ceil( 2.2) =  3
+    //   - x = -2.2: floor(-2.2) = -3, ceil(-2.2) = -2
+    //
+    // Regarding `fmodf`. For fractional negative numbers, `fmodf` returns a
+    // negative number. For example, `fmodf(-2.2) = -0.2`. However, we want
+    // `fractial` to be the number such that subtracting it from `value` will
+    // give us `floor(value)`. In the case of negative numbers, adding 1 to
+    // `fmodf(value)` gives us this. Let's continue the example from above:
+    //   - fractial = fmodf(-2.2) = -0.2
+    //   - Add 1 to the fraction: fractial2 = fractial + 1 = -0.2 + 1 = 0.8
+    //   - Finding the `floor`: -2.2 - fractial2 = -2.2 - 0.8 = -3
+    ++fractial;
+  }
+  if (yoga::inexactEquals(fractial, 0)) {
+    // First we check if the value is already rounded
+    scaledValue = scaledValue - fractial;
+  } else if (yoga::inexactEquals(fractial, 1.0)) {
+    scaledValue = scaledValue - fractial + 1.0;
+  } else if (forceCeil) {
+    // Next we check if we need to use forced rounding
+    scaledValue = scaledValue - fractial + 1.0;
+  } else if (forceFloor) {
+    scaledValue = scaledValue - fractial;
+  } else {
+    // Finally we just round the value
+    scaledValue = scaledValue - fractial +
+        (!std::isnan(fractial) &&
+                 (fractial > 0.5 || yoga::inexactEquals(fractial, 0.5))
+             ? 1.0
+             : 0.0);
+  }
+  return (std::isnan(scaledValue) || std::isnan(pointScaleFactor))
+      ? YGUndefined
+      : (float)(scaledValue / pointScaleFactor);
+}
+
+void roundLayoutResultsToPixelGrid(
+    yoga::Node* const node,
+    const double absoluteLeft,
+    const double absoluteTop) {
+  const auto pointScaleFactor = node->getConfig()->getPointScaleFactor();
+
+  const double nodeLeft = node->getLayout().position(PhysicalEdge::Left);
+  const double nodeTop = node->getLayout().position(PhysicalEdge::Top);
+
+  const double nodeWidth = node->getLayout().dimension(Dimension::Width);
+  const double nodeHeight = node->getLayout().dimension(Dimension::Height);
+
+  const double absoluteNodeLeft = absoluteLeft + nodeLeft;
+  const double absoluteNodeTop = absoluteTop + nodeTop;
+
+  const double absoluteNodeRight = absoluteNodeLeft + nodeWidth;
+  const double absoluteNodeBottom = absoluteNodeTop + nodeHeight;
+
+  if (pointScaleFactor != 0.0f) {
+    // If a node has a custom measure function we never want to round down its
+    // size as this could lead to unwanted text truncation.
+    const bool textRounding = node->getNodeType() == NodeType::Text;
+
+    node->setLayoutPosition(
+        roundValueToPixelGrid(nodeLeft, pointScaleFactor, false, textRounding),
+        PhysicalEdge::Left);
+
+    node->setLayoutPosition(
+        roundValueToPixelGrid(nodeTop, pointScaleFactor, false, textRounding),
+        PhysicalEdge::Top);
+
+    // We multiply dimension by scale factor and if the result is close to the
+    // whole number, we don't have any fraction To verify if the result is close
+    // to whole number we want to check both floor and ceil numbers
+    const bool hasFractionalWidth =
+        !yoga::inexactEquals(fmod(nodeWidth * pointScaleFactor, 1.0), 0) &&
+        !yoga::inexactEquals(fmod(nodeWidth * pointScaleFactor, 1.0), 1.0);
+    const bool hasFractionalHeight =
+        !yoga::inexactEquals(fmod(nodeHeight * pointScaleFactor, 1.0), 0) &&
+        !yoga::inexactEquals(fmod(nodeHeight * pointScaleFactor, 1.0), 1.0);
+
+    node->setLayoutDimension(
+        roundValueToPixelGrid(
+            absoluteNodeRight,
+            pointScaleFactor,
+            (textRounding && hasFractionalWidth),
+            (textRounding && !hasFractionalWidth)) -
+            roundValueToPixelGrid(
+                absoluteNodeLeft, pointScaleFactor, false, textRounding),
+        Dimension::Width);
+
+    node->setLayoutDimension(
+        roundValueToPixelGrid(
+            absoluteNodeBottom,
+            pointScaleFactor,
+            (textRounding && hasFractionalHeight),
+            (textRounding && !hasFractionalHeight)) -
+            roundValueToPixelGrid(
+                absoluteNodeTop, pointScaleFactor, false, textRounding),
+        Dimension::Height);
+  }
+
+  for (yoga::Node* child : node->getChildren()) {
+    roundLayoutResultsToPixelGrid(child, absoluteNodeLeft, absoluteNodeTop);
+  }
+}
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/algorithm/PixelGrid.h

@@ -0,0 +1,29 @@
+/*
+ * 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 <yoga/Yoga.h>
+#include <yoga/node/Node.h>
+
+namespace facebook::yoga {
+
+// Round a point value to the nearest physical pixel based on DPI
+// (pointScaleFactor)
+float roundValueToPixelGrid(
+    double value,
+    double pointScaleFactor,
+    bool forceCeil,
+    bool forceFloor);
+
+// Round the layout results of a node and its subtree to the pixel grid.
+void roundLayoutResultsToPixelGrid(
+    yoga::Node* node,
+    double absoluteLeft,
+    double absoluteTop);
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/algorithm/SizingMode.h

@@ -0,0 +1,73 @@
+/*
+ * 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 <yoga/debug/AssertFatal.h>
+#include <yoga/enums/MeasureMode.h>
+
+namespace facebook::yoga {
+
+/**
+ * Corresponds to a CSS auto box sizes. Missing "min-content", as Yoga does not
+ * current support automatic minimum sizes.
+ * https://www.w3.org/TR/css-sizing-3/#auto-box-sizes
+ * https://www.w3.org/TR/css-flexbox-1/#min-size-auto
+ */
+enum class SizingMode {
+  /**
+   * The size a box would take if its outer size filled the available space in
+   * the given axis; in other words, the stretch fit into the available space,
+   * if that is definite. Undefined if the available space is indefinite.
+   */
+  StretchFit,
+
+  /**
+   * A box’s “ideal” size in a given axis when given infinite available space.
+   * Usually this is the smallest size the box could take in that axis while
+   * still fitting around its contents, i.e. minimizing unfilled space while
+   * avoiding overflow.
+   */
+  MaxContent,
+
+  /**
+   * If the available space in a given axis is definite, equal to
+   * clamp(min-content size, stretch-fit size, max-content size) (i.e.
+   * max(min-content size, min(max-content size, stretch-fit size))). When
+   * sizing under a min-content constraint, equal to the min-content size.
+   * Otherwise, equal to the max-content size in that axis.
+   */
+  FitContent,
+};
+
+inline MeasureMode measureMode(SizingMode mode) {
+  switch (mode) {
+    case SizingMode::StretchFit:
+      return MeasureMode::Exactly;
+    case SizingMode::MaxContent:
+      return MeasureMode::Undefined;
+    case SizingMode::FitContent:
+      return MeasureMode::AtMost;
+  }
+
+  fatalWithMessage("Invalid SizingMode");
+}
+
+inline SizingMode sizingMode(MeasureMode mode) {
+  switch (mode) {
+    case MeasureMode::Exactly:
+      return SizingMode::StretchFit;
+    case MeasureMode::Undefined:
+      return SizingMode::MaxContent;
+    case MeasureMode::AtMost:
+      return SizingMode::FitContent;
+  }
+
+  fatalWithMessage("Invalid MeasureMode");
+}
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/algorithm/TrailingPosition.h

@@ -0,0 +1,44 @@
+/*
+ * 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 <yoga/Yoga.h>
+#include <yoga/algorithm/FlexDirection.h>
+#include <yoga/event/event.h>
+#include <yoga/node/Node.h>
+
+namespace facebook::yoga {
+
+// Given an offset to an edge, returns the offset to the opposite edge on the
+// same axis. This assumes that the width/height of both nodes is determined at
+// this point.
+inline float getPositionOfOppositeEdge(
+    float position,
+    FlexDirection axis,
+    const yoga::Node* const containingNode,
+    const yoga::Node* const node) {
+  return containingNode->getLayout().measuredDimension(dimension(axis)) -
+      node->getLayout().measuredDimension(dimension(axis)) - position;
+}
+
+inline void setChildTrailingPosition(
+    const yoga::Node* const node,
+    yoga::Node* const child,
+    const FlexDirection axis) {
+  child->setLayoutPosition(
+      getPositionOfOppositeEdge(
+          child->getLayout().position(flexStartEdge(axis)), axis, node, child),
+      flexEndEdge(axis));
+}
+
+inline bool needsTrailingPosition(const FlexDirection axis) {
+  return axis == FlexDirection::RowReverse ||
+      axis == FlexDirection::ColumnReverse;
+}
+
+} // namespace facebook::yoga