/* -*- 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_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_ */
