pythonnative 0.40.0__cp313-cp313-win_amd64.whl

pythonnative/native/yoga/yoga/event/event.h

@@ -0,0 +1,130 @@
+/*
+ * 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 <array>
+#include <cstdint>
+#include <functional>
+#include <vector>
+
+namespace facebook::yoga {
+
+enum struct LayoutType : int {
+  kLayout = 0,
+  kMeasure = 1,
+  kCachedLayout = 2,
+  kCachedMeasure = 3
+};
+
+enum struct LayoutPassReason : int {
+  kInitial = 0,
+  kAbsLayout = 1,
+  kStretch = 2,
+  kMultilineStretch = 3,
+  kFlexLayout = 4,
+  kMeasureChild = 5,
+  kAbsMeasureChild = 6,
+  kFlexMeasure = 7,
+  COUNT
+};
+
+struct LayoutData {
+  int layouts;
+  int measures;
+  uint32_t maxMeasureCache;
+  int cachedLayouts;
+  int cachedMeasures;
+  int measureCallbacks;
+  std::array<int, static_cast<uint8_t>(LayoutPassReason::COUNT)>
+      measureCallbackReasonsCount;
+};
+
+const char* LayoutPassReasonToString(LayoutPassReason value);
+
+struct YG_EXPORT Event {
+  enum Type {
+    NodeAllocation,
+    NodeDeallocation,
+    NodeLayout,
+    LayoutPassStart,
+    LayoutPassEnd,
+    MeasureCallbackStart,
+    MeasureCallbackEnd,
+    NodeBaselineStart,
+    NodeBaselineEnd,
+  };
+  class Data;
+  using Subscriber = void(YGNodeConstRef, Type, Data);
+  using Subscribers = std::vector<std::function<Subscriber>>;
+
+  template <Type E>
+  struct TypedData {};
+
+  class Data {
+    const void* data_;
+
+   public:
+    template <Type E>
+    explicit Data(const TypedData<E>& data) : data_{&data} {}
+
+    template <Type E>
+    const TypedData<E>& get() const {
+      return *static_cast<const TypedData<E>*>(data_);
+    }
+  };
+
+  static void reset();
+
+  static void subscribe(std::function<Subscriber>&& subscriber);
+
+  template <Type E>
+  static void publish(YGNodeConstRef node, const TypedData<E>& eventData = {}) {
+    publish(node, E, Data{eventData});
+  }
+
+ private:
+  static void publish(
+      YGNodeConstRef /*node*/,
+      Type /*eventType*/,
+      const Data& /*eventData*/);
+};
+
+template <>
+struct Event::TypedData<Event::NodeAllocation> {
+  YGConfigConstRef config;
+};
+
+template <>
+struct Event::TypedData<Event::NodeDeallocation> {
+  YGConfigConstRef config;
+};
+
+template <>
+struct Event::TypedData<Event::LayoutPassEnd> {
+  LayoutData* layoutData;
+};
+
+template <>
+struct Event::TypedData<Event::MeasureCallbackEnd> {
+  float width;
+  YGMeasureMode widthMeasureMode;
+  float height;
+  YGMeasureMode heightMeasureMode;
+  float measuredWidth;
+  float measuredHeight;
+  const LayoutPassReason reason;
+};
+
+template <>
+struct Event::TypedData<Event::NodeLayout> {
+  LayoutType layoutType;
+};
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/module.modulemap

@@ -0,0 +1,21 @@
+/*
+ * 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.
+ */
+
+module yoga [system] {
+    module core {
+        header "YGConfig.h"
+        header "YGEnums.h"
+        header "YGMacros.h"
+        header "YGNode.h"
+        header "YGNodeLayout.h"
+        header "YGNodeStyle.h"
+        header "YGPixelGrid.h"
+        header "YGValue.h"
+        header "Yoga.h"
+        export *
+    }
+}

pythonnative/native/yoga/yoga/node/CachedMeasurement.h

@@ -0,0 +1,53 @@
+/*
+ * 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 <cmath>
+
+#include <yoga/Yoga.h>
+
+#include <yoga/algorithm/SizingMode.h>
+#include <yoga/numeric/Comparison.h>
+
+namespace facebook::yoga {
+
+struct CachedMeasurement {
+  float availableWidth{-1};
+  float availableHeight{-1};
+  SizingMode widthSizingMode{SizingMode::MaxContent};
+  SizingMode heightSizingMode{SizingMode::MaxContent};
+
+  float computedWidth{-1};
+  float computedHeight{-1};
+
+  bool operator==(CachedMeasurement measurement) const {
+    bool isEqual = widthSizingMode == measurement.widthSizingMode &&
+        heightSizingMode == measurement.heightSizingMode;
+
+    if (!yoga::isUndefined(availableWidth) ||
+        !yoga::isUndefined(measurement.availableWidth)) {
+      isEqual = isEqual && availableWidth == measurement.availableWidth;
+    }
+    if (!yoga::isUndefined(availableHeight) ||
+        !yoga::isUndefined(measurement.availableHeight)) {
+      isEqual = isEqual && availableHeight == measurement.availableHeight;
+    }
+    if (!yoga::isUndefined(computedWidth) ||
+        !yoga::isUndefined(measurement.computedWidth)) {
+      isEqual = isEqual && computedWidth == measurement.computedWidth;
+    }
+    if (!yoga::isUndefined(computedHeight) ||
+        !yoga::isUndefined(measurement.computedHeight)) {
+      isEqual = isEqual && computedHeight == measurement.computedHeight;
+    }
+
+    return isEqual;
+  }
+};
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/node/LayoutResults.cpp

@@ -0,0 +1,48 @@
+/*
+ * 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 <cmath>
+
+#include <yoga/node/LayoutResults.h>
+#include <yoga/numeric/Comparison.h>
+
+namespace facebook::yoga {
+
+bool LayoutResults::operator==(LayoutResults layout) const {
+  bool isEqual = yoga::inexactEquals(position_, layout.position_) &&
+      yoga::inexactEquals(dimensions_, layout.dimensions_) &&
+      yoga::inexactEquals(margin_, layout.margin_) &&
+      yoga::inexactEquals(border_, layout.border_) &&
+      yoga::inexactEquals(padding_, layout.padding_) &&
+      direction() == layout.direction() &&
+      hadOverflow() == layout.hadOverflow() &&
+      lastOwnerDirection == layout.lastOwnerDirection &&
+      configVersion == layout.configVersion &&
+      nextCachedMeasurementsIndex == layout.nextCachedMeasurementsIndex &&
+      cachedLayout == layout.cachedLayout &&
+      computedFlexBasis == layout.computedFlexBasis;
+
+  for (uint32_t i = 0; i < LayoutResults::MaxCachedMeasurements && isEqual;
+       ++i) {
+    isEqual = isEqual && cachedMeasurements[i] == layout.cachedMeasurements[i];
+  }
+
+  if (!yoga::isUndefined(measuredDimensions_[0]) ||
+      !yoga::isUndefined(layout.measuredDimensions_[0])) {
+    isEqual =
+        isEqual && (measuredDimensions_[0] == layout.measuredDimensions_[0]);
+  }
+  if (!yoga::isUndefined(measuredDimensions_[1]) ||
+      !yoga::isUndefined(layout.measuredDimensions_[1])) {
+    isEqual =
+        isEqual && (measuredDimensions_[1] == layout.measuredDimensions_[1]);
+  }
+
+  return isEqual;
+}
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/node/LayoutResults.h

@@ -0,0 +1,122 @@
+/*
+ * 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 <array>
+
+#include <yoga/debug/AssertFatal.h>
+#include <yoga/enums/Dimension.h>
+#include <yoga/enums/Direction.h>
+#include <yoga/enums/Edge.h>
+#include <yoga/enums/PhysicalEdge.h>
+#include <yoga/node/CachedMeasurement.h>
+#include <yoga/numeric/FloatOptional.h>
+
+namespace facebook::yoga {
+
+struct LayoutResults {
+  // This value was chosen based on empirical data:
+  // 98% of analyzed layouts require less than 8 entries.
+  static constexpr int32_t MaxCachedMeasurements = 8;
+
+  uint32_t computedFlexBasisGeneration = 0;
+  FloatOptional computedFlexBasis = {};
+
+  // Instead of recomputing the entire layout every single time, we cache some
+  // information to break early when nothing changed
+  uint32_t generationCount = 0;
+  uint32_t configVersion = 0;
+  Direction lastOwnerDirection = Direction::Inherit;
+
+  uint32_t nextCachedMeasurementsIndex = 0;
+  std::array<CachedMeasurement, MaxCachedMeasurements> cachedMeasurements = {};
+
+  CachedMeasurement cachedLayout{};
+
+  Direction direction() const {
+    return direction_;
+  }
+
+  void setDirection(Direction direction) {
+    direction_ = direction;
+  }
+
+  bool hadOverflow() const {
+    return hadOverflow_;
+  }
+
+  void setHadOverflow(bool hadOverflow) {
+    hadOverflow_ = hadOverflow;
+  }
+
+  float dimension(Dimension axis) const {
+    return dimensions_[yoga::to_underlying(axis)];
+  }
+
+  void setDimension(Dimension axis, float dimension) {
+    dimensions_[yoga::to_underlying(axis)] = dimension;
+  }
+
+  float measuredDimension(Dimension axis) const {
+    return measuredDimensions_[yoga::to_underlying(axis)];
+  }
+
+  void setMeasuredDimension(Dimension axis, float dimension) {
+    measuredDimensions_[yoga::to_underlying(axis)] = dimension;
+  }
+
+  float position(PhysicalEdge physicalEdge) const {
+    return position_[yoga::to_underlying(physicalEdge)];
+  }
+
+  void setPosition(PhysicalEdge physicalEdge, float dimension) {
+    position_[yoga::to_underlying(physicalEdge)] = dimension;
+  }
+
+  float margin(PhysicalEdge physicalEdge) const {
+    return margin_[yoga::to_underlying(physicalEdge)];
+  }
+
+  void setMargin(PhysicalEdge physicalEdge, float dimension) {
+    margin_[yoga::to_underlying(physicalEdge)] = dimension;
+  }
+
+  float border(PhysicalEdge physicalEdge) const {
+    return border_[yoga::to_underlying(physicalEdge)];
+  }
+
+  void setBorder(PhysicalEdge physicalEdge, float dimension) {
+    border_[yoga::to_underlying(physicalEdge)] = dimension;
+  }
+
+  float padding(PhysicalEdge physicalEdge) const {
+    return padding_[yoga::to_underlying(physicalEdge)];
+  }
+
+  void setPadding(PhysicalEdge physicalEdge, float dimension) {
+    padding_[yoga::to_underlying(physicalEdge)] = dimension;
+  }
+
+  bool operator==(LayoutResults layout) const;
+  bool operator!=(LayoutResults layout) const {
+    return !(*this == layout);
+  }
+
+ private:
+  Direction direction_ : bitCount<Direction>() = Direction::Inherit;
+  bool hadOverflow_ : 1 = false;
+
+  std::array<float, 2> dimensions_ = {{YGUndefined, YGUndefined}};
+  std::array<float, 2> measuredDimensions_ = {{YGUndefined, YGUndefined}};
+  std::array<float, 4> position_ = {};
+  std::array<float, 4> margin_ = {};
+  std::array<float, 4> border_ = {};
+  std::array<float, 4> padding_ = {};
+};
+
+} // namespace facebook::yoga

pythonnative/native/yoga/yoga/node/LayoutableChildren.h

@@ -0,0 +1,148 @@
+/*
+ * 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 <cstdint>
+#include <forward_list>
+#include <utility>
+
+#include <yoga/enums/Display.h>
+
+namespace facebook::yoga {
+
+class Node;
+
+template <typename T>
+class LayoutableChildren {
+ public:
+  struct Iterator {
+    using iterator_category = std::input_iterator_tag;
+    using difference_type = std::ptrdiff_t;
+    using value_type = T*;
+    using pointer = T*;
+    using reference = T*;
+
+    Iterator() = default;
+
+    Iterator(const T* node, size_t childIndex)
+        : node_(node), childIndex_(childIndex) {}
+
+    T* operator*() const {
+      return node_->getChild(childIndex_);
+    }
+
+    Iterator& operator++() {
+      next();
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      Iterator tmp = *this;
+      ++(*this);
+      return tmp;
+    }
+
+    friend bool operator==(const Iterator& a, const Iterator& b) {
+      return a.node_ == b.node_ && a.childIndex_ == b.childIndex_;
+    }
+
+    friend bool operator!=(const Iterator& a, const Iterator& b) {
+      return a.node_ != b.node_ || a.childIndex_ != b.childIndex_;
+    }
+
+   private:
+    void next() {
+      if (childIndex_ + 1 >= node_->getChildCount()) {
+        // if the current node has no more children, try to backtrack and
+        // visit its successor
+        if (backtrack_.empty()) [[likely]] {
+          // if there are no nodes to backtrack to, the last node has been
+          // visited
+          *this = Iterator{};
+        } else {
+          // pop and restore the latest backtrack entry
+          const auto& back = backtrack_.front();
+          node_ = back.first;
+          childIndex_ = back.second;
+          backtrack_.pop_front();
+
+          // go to the next node
+          next();
+        }
+      } else {
+        // current node has more children to visit, go to next
+        ++childIndex_;
+        // skip all display: contents nodes, possibly going deeper into the
+        // tree
+        if (node_->getChild(childIndex_)->style().display() ==
+            Display::Contents) [[unlikely]] {
+          skipContentsNodes();
+        }
+      }
+    }
+
+    void skipContentsNodes() {
+      // get the node that would be returned from the iterator
+      auto currentNode = node_->getChild(childIndex_);
+      while (currentNode->style().display() == Display::Contents &&
+             currentNode->getChildCount() > 0) {
+        // if it has display: contents set, it shouldn't be returned but its
+        // children should in its place push the current node and child index
+        // so that the current state can be restored when backtracking
+        backtrack_.push_front({node_, childIndex_});
+        // traverse the child
+        node_ = currentNode;
+        childIndex_ = 0;
+
+        // repeat until a node without display: contents is found in the
+        // subtree or a leaf is reached
+        currentNode = currentNode->getChild(childIndex_);
+      }
+
+      // if no node without display: contents was found, try to backtrack
+      if (currentNode->style().display() == Display::Contents) {
+        next();
+      }
+    }
+
+    const T* node_{nullptr};
+    size_t childIndex_{0};
+    std::forward_list<std::pair<const T*, size_t>> backtrack_;
+
+    friend LayoutableChildren;
+  };
+
+  explicit LayoutableChildren(const T* node) : node_(node) {
+    static_assert(std::input_iterator<LayoutableChildren<T>::Iterator>);
+    static_assert(
+        std::is_base_of<Node, T>::value,
+        "Type parameter of LayoutableChildren must derive from yoga::Node");
+  }
+
+  Iterator begin() const {
+    if (node_->getChildCount() > 0) {
+      auto result = Iterator(node_, 0);
+      if (node_->getChild(0)->style().display() == Display::Contents)
+          [[unlikely]] {
+        result.skipContentsNodes();
+      }
+      return result;
+    } else {
+      return Iterator{};
+    }
+  }
+
+  Iterator end() const {
+    return Iterator{};
+  }
+
+ private:
+  const T* node_;
+};
+
+} // namespace facebook::yoga