1 files changed, 202 insertions, 0 deletions
diff --git a/gfx/2d/Coord.h b/gfx/2d/Coord.h
new file mode 100644
index 0000000000..3b81482b44
--- /dev/null
+++ b/gfx/2d/Coord.h
@@ -0,0 +1,202 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef MOZILLA_GFX_COORD_H_
+#define MOZILLA_GFX_COORD_H_
+
+#include "mozilla/Attributes.h"
+#include "mozilla/FloatingPoint.h"
+#include "Types.h"
+#include "BaseCoord.h"
+
+#include <cmath>
+#include <type_traits>
+
+namespace mozilla {
+
+namespace gfx {
+
+template <class Units, class Rep = int32_t>
+struct IntCoordTyped;
+template <class Units, class F = Float>
+struct CoordTyped;
+
+}  // namespace gfx
+
+}  // namespace mozilla
+
+namespace std {
+
+template <class Units, class Rep>
+struct common_type<mozilla::gfx::IntCoordTyped<Units, Rep>, float> {
+  using type = mozilla::gfx::CoordTyped<Units, common_type_t<Rep, float>>;
+};
+
+template <class Units, class Rep>
+struct common_type<mozilla::gfx::IntCoordTyped<Units, Rep>, double> {
+  using type = mozilla::gfx::CoordTyped<Units, common_type_t<Rep, double>>;
+};
+
+template <class Units, class Rep>
+struct common_type<mozilla::gfx::IntCoordTyped<Units, Rep>, int32_t> {
+  using type = mozilla::gfx::IntCoordTyped<Units, common_type_t<Rep, int32_t>>;
+};
+
+template <class Units, class Rep>
+struct common_type<mozilla::gfx::IntCoordTyped<Units, Rep>, uint32_t> {
+  using type = mozilla::gfx::IntCoordTyped<Units, common_type_t<Rep, uint32_t>>;
+};
+
+template <class Units, class F, class T>
+struct common_type<mozilla::gfx::CoordTyped<Units, F>, T> {
+  using type = mozilla::gfx::CoordTyped<Units, common_type_t<F, T>>;
+};
+
+// With a few exceptions, we use CoordTyped values with a float representation.
+// These are the types for which we have short typedefs like
+// CSSCoord, and the types expected in most interfaces.
+// So, for float inputs, keep the results as float even if the other
+// operand is a double, accepting a slight loss of precision.
+template <class Units, class T>
+struct common_type<mozilla::gfx::CoordTyped<Units, float>, T> {
+  using type = mozilla::gfx::CoordTyped<Units, float>;
+};
+
+}  // namespace std
+
+namespace mozilla {
+
+template <typename>
+struct IsPixel;
+
+namespace gfx {
+
+// Should only be used to define generic typedefs like Coord, Point, etc.
+struct UnknownUnits {};
+
+// This is a base class that provides mixed-type operator overloads between
+// a strongly-typed Coord and a Primitive value. It is needed to avoid
+// ambiguities at mixed-type call sites, because Coord classes are implicitly
+// convertible to their underlying value type. As we transition more of our code
+// to strongly-typed classes, we may be able to remove some or all of these
+// overloads.
+
+template <bool Enable, class Coord, class Primitive>
+struct CoordOperatorsHelper {
+  // Using SFINAE (Substitution Failure Is Not An Error) to suppress redundant
+  // operators
+};
+
+template <class Coord, class Primitive>
+struct CoordOperatorsHelper<true, Coord, Primitive> {
+  friend bool operator==(Coord aA, Primitive aB) { return aA.value == aB; }
+  friend bool operator==(Primitive aA, Coord aB) { return aA == aB.value; }
+  friend bool operator!=(Coord aA, Primitive aB) { return aA.value != aB; }
+  friend bool operator!=(Primitive aA, Coord aB) { return aA != aB.value; }
+
+  friend auto operator+(Coord aA, Primitive aB) { return aA.value + aB; }
+  friend auto operator+(Primitive aA, Coord aB) { return aA + aB.value; }
+  friend auto operator-(Coord aA, Primitive aB) { return aA.value - aB; }
+  friend auto operator-(Primitive aA, Coord aB) { return aA - aB.value; }
+  friend auto operator*(Coord aCoord, Primitive aScale) {
+    return std::common_type_t<Coord, Primitive>(aCoord.value * aScale);
+  }
+  friend auto operator*(Primitive aScale, Coord aCoord) {
+    return aCoord * aScale;
+  }
+  friend auto operator/(Coord aCoord, Primitive aScale) {
+    return std::common_type_t<Coord, Primitive>(aCoord.value / aScale);
+  }
+  // 'scale / coord' is intentionally omitted because it doesn't make sense.
+};
+
+template <class Units, class Rep>
+struct MOZ_EMPTY_BASES IntCoordTyped
+    : public BaseCoord<Rep, IntCoordTyped<Units, Rep>>,
+      public CoordOperatorsHelper<true, IntCoordTyped<Units, Rep>, float>,
+      public CoordOperatorsHelper<true, IntCoordTyped<Units, Rep>, double> {
+  static_assert(IsPixel<Units>::value,
+                "'Units' must be a coordinate system tag");
+
+  using Super = BaseCoord<Rep, IntCoordTyped<Units, Rep>>;
+
+  constexpr IntCoordTyped() : Super() {
+    static_assert(sizeof(IntCoordTyped) == sizeof(Rep),
+                  "Would be unfortunate otherwise!");
+  }
+  template <class T, typename = typename std::enable_if_t<
+                         std::is_integral_v<T> || std::is_enum_v<T>>>
+  constexpr MOZ_IMPLICIT IntCoordTyped(T aValue) : Super(aValue) {
+    static_assert(sizeof(IntCoordTyped) == sizeof(Rep),
+                  "Would be unfortunate otherwise!");
+  }
+};
+
+template <class Units, class F>
+struct MOZ_EMPTY_BASES CoordTyped
+    : public BaseCoord<F, CoordTyped<Units, F>>,
+      public CoordOperatorsHelper<!std::is_same_v<F, int32_t>,
+                                  CoordTyped<Units, F>, int32_t>,
+      public CoordOperatorsHelper<!std::is_same_v<F, uint32_t>,
+                                  CoordTyped<Units, F>, uint32_t>,
+      public CoordOperatorsHelper<!std::is_same_v<F, double>,
+                                  CoordTyped<Units, F>, double>,
+      public CoordOperatorsHelper<!std::is_same_v<F, float>,
+                                  CoordTyped<Units, F>, float> {
+  static_assert(IsPixel<Units>::value,
+                "'Units' must be a coordinate system tag");
+
+  using Super = BaseCoord<F, CoordTyped<Units, F>>;
+
+  constexpr CoordTyped() : Super() {
+    static_assert(sizeof(CoordTyped) == sizeof(F),
+                  "Would be unfortunate otherwise!");
+  }
+  constexpr MOZ_IMPLICIT CoordTyped(F aValue) : Super(aValue) {
+    static_assert(sizeof(CoordTyped) == sizeof(F),
+                  "Would be unfortunate otherwise!");
+  }
+  explicit constexpr CoordTyped(const IntCoordTyped<Units>& aCoord)
+      : Super(F(aCoord.value)) {
+    static_assert(sizeof(CoordTyped) == sizeof(F),
+                  "Would be unfortunate otherwise!");
+  }
+
+  void Round() { this->value = floor(this->value + 0.5); }
+  void Truncate() { this->value = int32_t(this->value); }
+
+  IntCoordTyped<Units> Rounded() const {
+    return IntCoordTyped<Units>(int32_t(floor(this->value + 0.5)));
+  }
+  IntCoordTyped<Units> Truncated() const {
+    return IntCoordTyped<Units>(int32_t(this->value));
+  }
+};
+
+typedef CoordTyped<UnknownUnits> Coord;
+
+}  // namespace gfx
+
+template <class Units, class F>
+static MOZ_ALWAYS_INLINE bool FuzzyEqualsAdditive(
+    gfx::CoordTyped<Units, F> aValue1, gfx::CoordTyped<Units, F> aValue2,
+    gfx::CoordTyped<Units, F> aEpsilon =
+        detail::FuzzyEqualsEpsilon<F>::value()) {
+  return FuzzyEqualsAdditive(aValue1.value, aValue2.value, aEpsilon.value);
+}
+
+template <class Units, class F>
+static MOZ_ALWAYS_INLINE bool FuzzyEqualsMultiplicative(
+    gfx::CoordTyped<Units, F> aValue1, gfx::CoordTyped<Units, F> aValue2,
+    gfx::CoordTyped<Units, F> aEpsilon =
+        detail::FuzzyEqualsEpsilon<F>::value()) {
+  return FuzzyEqualsMultiplicative(aValue1.value, aValue2.value,
+                                   aEpsilon.value);
+}
+
+}  // namespace mozilla
+
+#endif /* MOZILLA_GFX_COORD_H_ */