Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#ifndef MOZILLA_GFX_SCALEFACTORS2D_H_
#define MOZILLA_GFX_SCALEFACTORS2D_H_
#include <ostream>
#include "mozilla/Attributes.h"
#include "mozilla/FloatingPoint.h"
#include "mozilla/gfx/ScaleFactor.h"
#include "mozilla/gfx/Point.h"
#include "gfxPoint.h"
namespace mozilla {
namespace gfx {
/*
* This class is like ScaleFactor, but allows different scales on the x and
* y axes.
*/
template <class Src, class Dst, class T>
struct BaseScaleFactors2D {
T xScale;
T yScale;
constexpr BaseScaleFactors2D() : xScale(1.0), yScale(1.0) {}
constexpr BaseScaleFactors2D(const BaseScaleFactors2D& aCopy)
: xScale(aCopy.xScale), yScale(aCopy.yScale) {}
constexpr BaseScaleFactors2D(T aXScale, T aYScale)
: xScale(aXScale), yScale(aYScale) {}
// Layout code often uses gfxSize to represent a pair of x/y scales.
explicit constexpr BaseScaleFactors2D(const gfxSize& aSize)
: xScale(aSize.width), yScale(aSize.height) {}
// "Upgrade" from a ScaleFactor.
// This is deliberately 'explicit' so that the treatment of a single scale
// number as both the x- and y-scale in a context where they are allowed to
// be different, is more visible.
explicit constexpr BaseScaleFactors2D(const ScaleFactor<Src, Dst>& aScale)
: xScale(aScale.scale), yScale(aScale.scale) {}
bool AreScalesSame() const {
return FuzzyEqualsMultiplicative(xScale, yScale);
}
// Convert the underlying floating point type storing the scale factors
// to that of NewT.
template <typename NewT>
BaseScaleFactors2D<Src, Dst, NewT> ConvertTo() const {
return BaseScaleFactors2D<Src, Dst, NewT>(NewT(xScale), NewT(yScale));
}
// Convert to a ScaleFactor. Asserts that the scales are, in fact, equal.
ScaleFactor<Src, Dst> ToScaleFactor() const {
// Avoid implicit narrowing from double to float. An explicit conversion
// may be done with `scales.ConvertTo<float>().ToScaleFactor()` if desired.
static_assert(std::is_same_v<T, float>);
MOZ_ASSERT(AreScalesSame());
return ScaleFactor<Src, Dst>(xScale);
}
// Convert to a SizeTyped. Eventually, we should replace all uses of SizeTyped
// to represent scales with ScaleFactors2D, and remove this function.
SizeTyped<UnknownUnits, T> ToSize() const {
return SizeTyped<UnknownUnits, T>(xScale, yScale);
}
BaseScaleFactors2D& operator=(const BaseScaleFactors2D&) = default;
bool operator==(const BaseScaleFactors2D& aOther) const {
return xScale == aOther.xScale && yScale == aOther.yScale;
}
bool operator!=(const BaseScaleFactors2D& aOther) const {
return !(*this == aOther);
}
friend std::ostream& operator<<(std::ostream& aStream,
const BaseScaleFactors2D& aScale) {
if (aScale.AreScalesSame()) {
return aStream << aScale.xScale;
} else {
return aStream << '(' << aScale.xScale << ',' << aScale.yScale << ')';
}
}
template <class Other>
BaseScaleFactors2D<Other, Dst, T> operator/(
const BaseScaleFactors2D<Src, Other, T>& aOther) const {
return BaseScaleFactors2D<Other, Dst, T>(xScale / aOther.xScale,
yScale / aOther.yScale);
}
template <class Other>
BaseScaleFactors2D<Src, Other, T> operator/(
const BaseScaleFactors2D<Other, Dst, T>& aOther) const {
return BaseScaleFactors2D<Src, Other, T>(xScale / aOther.xScale,
yScale / aOther.yScale);
}
template <class Other>
BaseScaleFactors2D<Src, Other, T> operator*(
const BaseScaleFactors2D<Dst, Other, T>& aOther) const {
return BaseScaleFactors2D<Src, Other, T>(xScale * aOther.xScale,
yScale * aOther.yScale);
}
template <class Other>
BaseScaleFactors2D<Other, Dst, T> operator*(
const BaseScaleFactors2D<Other, Src, T>& aOther) const {
return BaseScaleFactors2D<Other, Dst, T>(xScale * aOther.xScale,
yScale * aOther.yScale);
}
BaseScaleFactors2D<Src, Src, T> operator*(
const BaseScaleFactors2D<Dst, Src, T>& aOther) const {
return BaseScaleFactors2D<Src, Src, T>(xScale * aOther.xScale,
yScale * aOther.yScale);
}
template <class Other>
BaseScaleFactors2D<Src, Other, T> operator*(
const ScaleFactor<Dst, Other>& aOther) const {
return *this * BaseScaleFactors2D<Dst, Other, T>(aOther);
}
template <class Other>
BaseScaleFactors2D<Other, Dst, T> operator*(
const ScaleFactor<Other, Src>& aOther) const {
return *this * BaseScaleFactors2D<Other, Src, T>(aOther);
}
BaseScaleFactors2D<Src, Src, T> operator*(
const ScaleFactor<Dst, Src>& aOther) const {
return *this * BaseScaleFactors2D<Dst, Src, T>(aOther);
}
template <class Other>
BaseScaleFactors2D<Src, Other, T> operator/(
const ScaleFactor<Other, Dst>& aOther) const {
return *this / BaseScaleFactors2D<Other, Dst, T>(aOther);
}
template <class Other>
BaseScaleFactors2D<Other, Dst, T> operator/(
const ScaleFactor<Src, Other>& aOther) const {
return *this / BaseScaleFactors2D<Src, Other, T>(aOther);
}
template <class Other>
friend BaseScaleFactors2D<Other, Dst, T> operator*(
const ScaleFactor<Other, Src>& aA, const BaseScaleFactors2D& aB) {
return BaseScaleFactors2D<Other, Src, T>(aA) * aB;
}
template <class Other>
friend BaseScaleFactors2D<Other, Src, T> operator/(
const ScaleFactor<Other, Dst>& aA, const BaseScaleFactors2D& aB) {
return BaseScaleFactors2D<Other, Src, T>(aA) / aB;
}
static BaseScaleFactors2D<Src, Dst, T> FromUnknownScale(
const BaseScaleFactors2D<UnknownUnits, UnknownUnits, T>& scale) {
return BaseScaleFactors2D<Src, Dst, T>(scale.xScale, scale.yScale);
}
BaseScaleFactors2D<UnknownUnits, UnknownUnits, T> ToUnknownScale() const {
return BaseScaleFactors2D<UnknownUnits, UnknownUnits, T>(xScale, yScale);
}
friend BaseScaleFactors2D Min(const BaseScaleFactors2D& aA,
const BaseScaleFactors2D& aB) {
return BaseScaleFactors2D(std::min(aA.xScale, aB.xScale),
std::min(aA.yScale, aB.yScale));
}
friend BaseScaleFactors2D Max(const BaseScaleFactors2D& aA,
const BaseScaleFactors2D& aB) {
return BaseScaleFactors2D(std::max(aA.xScale, aB.xScale),
std::max(aA.yScale, aB.yScale));
}
};
template <class Src, class Dst>
using ScaleFactors2D = BaseScaleFactors2D<Src, Dst, float>;
template <class Src, class Dst>
using ScaleFactors2DDouble = BaseScaleFactors2D<Src, Dst, double>;
} // namespace gfx
} // namespace mozilla
#endif /* MOZILLA_GFX_SCALEFACTORS2D_H_ */