mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-08-15 02:29:04 +00:00
175 lines
5.1 KiB
C++
175 lines
5.1 KiB
C++
/* -*- 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_SVGLENGTH_H__
|
|
#define MOZILLA_SVGLENGTH_H__
|
|
|
|
#include "nsDebug.h"
|
|
#include "nsIDOMSVGLength.h"
|
|
#include "nsMathUtils.h"
|
|
#include "mozilla/FloatingPoint.h"
|
|
|
|
class nsSVGElement;
|
|
|
|
namespace mozilla {
|
|
|
|
/**
|
|
* This SVGLength class is currently used for SVGLength *list* attributes only.
|
|
* The class that is currently used for <length> attributes is nsSVGLength2.
|
|
*
|
|
* The member mUnit should always be valid, but the member mValue may be
|
|
* numeric_limits<float>::quiet_NaN() under one circumstances (see the comment
|
|
* in SetValueAndUnit below). Even if mValue is valid, some methods may return
|
|
* numeric_limits<float>::quiet_NaN() if they involve a unit conversion that
|
|
* fails - see comments below.
|
|
*
|
|
* The DOM wrapper class for this class is DOMSVGLength.
|
|
*/
|
|
class SVGLength
|
|
{
|
|
public:
|
|
|
|
SVGLength()
|
|
#ifdef DEBUG
|
|
: mValue(0.0f)
|
|
, mUnit(nsIDOMSVGLength::SVG_LENGTHTYPE_UNKNOWN) // caught by IsValid()
|
|
#endif
|
|
{}
|
|
|
|
SVGLength(float aValue, uint8_t aUnit)
|
|
: mValue(aValue)
|
|
, mUnit(aUnit)
|
|
{
|
|
NS_ASSERTION(IsValid(), "Constructed an invalid length");
|
|
}
|
|
|
|
SVGLength(const SVGLength &aOther)
|
|
: mValue(aOther.mValue)
|
|
, mUnit(aOther.mUnit)
|
|
{}
|
|
|
|
SVGLength& operator=(const SVGLength &rhs) {
|
|
mValue = rhs.mValue;
|
|
mUnit = rhs.mUnit;
|
|
return *this;
|
|
}
|
|
|
|
bool operator==(const SVGLength &rhs) const {
|
|
return mValue == rhs.mValue && mUnit == rhs.mUnit;
|
|
}
|
|
|
|
void GetValueAsString(nsAString& aValue) const;
|
|
|
|
/**
|
|
* This method returns true, unless there was a parse failure, in which
|
|
* case it returns false (and the length is left unchanged).
|
|
*/
|
|
bool SetValueFromString(const nsAString& aValue);
|
|
|
|
/**
|
|
* This will usually return a valid, finite number. There is one exception
|
|
* though - see the comment in SetValueAndUnit().
|
|
*/
|
|
float GetValueInCurrentUnits() const {
|
|
return mValue;
|
|
}
|
|
|
|
uint8_t GetUnit() const {
|
|
return mUnit;
|
|
}
|
|
|
|
void SetValueInCurrentUnits(float aValue) {
|
|
mValue = aValue;
|
|
NS_ASSERTION(IsValid(), "Set invalid SVGLength");
|
|
}
|
|
|
|
void SetValueAndUnit(float aValue, uint8_t aUnit) {
|
|
mValue = aValue;
|
|
mUnit = aUnit;
|
|
|
|
// IsValid() should always be true, with one exception: if
|
|
// SVGLengthListSMILType has to convert between unit types and the unit
|
|
// conversion is undefined, it will end up passing in and setting
|
|
// numeric_limits<float>::quiet_NaN(). Because of that we only check the
|
|
// unit here, and allow mValue to be invalid. The painting code has to be
|
|
// able to handle NaN anyway, since conversion to user units may fail in
|
|
// general.
|
|
|
|
NS_ASSERTION(IsValidUnitType(mUnit), "Set invalid SVGLength");
|
|
}
|
|
|
|
/**
|
|
* If it's not possible to convert this length's value to user units, then
|
|
* this method will return numeric_limits<float>::quiet_NaN().
|
|
*/
|
|
float GetValueInUserUnits(const nsSVGElement *aElement, uint8_t aAxis) const {
|
|
return mValue * GetUserUnitsPerUnit(aElement, aAxis);
|
|
}
|
|
|
|
/**
|
|
* Get this length's value in the units specified.
|
|
*
|
|
* This method returns numeric_limits<float>::quiet_NaN() if it is not
|
|
* possible to convert the value to the specified unit.
|
|
*/
|
|
float GetValueInSpecifiedUnit(uint8_t aUnit,
|
|
const nsSVGElement *aElement,
|
|
uint8_t aAxis) const;
|
|
|
|
bool IsPercentage() const {
|
|
return mUnit == nsIDOMSVGLength::SVG_LENGTHTYPE_PERCENTAGE;
|
|
}
|
|
|
|
static bool IsValidUnitType(uint16_t unit) {
|
|
return unit > nsIDOMSVGLength::SVG_LENGTHTYPE_UNKNOWN &&
|
|
unit <= nsIDOMSVGLength::SVG_LENGTHTYPE_PC;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of user units per current unit.
|
|
*
|
|
* This method returns numeric_limits<float>::quiet_NaN() if the conversion
|
|
* factor between the length's current unit and user units is undefined (see
|
|
* the comments for GetUserUnitsPerInch and GetUserUnitsPerPercent).
|
|
*/
|
|
float GetUserUnitsPerUnit(const nsSVGElement *aElement, uint8_t aAxis) const;
|
|
|
|
private:
|
|
|
|
#ifdef DEBUG
|
|
bool IsValid() const {
|
|
return IsFinite(mValue) && IsValidUnitType(mUnit);
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* The conversion factor between user units (CSS px) and CSS inches is
|
|
* constant: 96 px per inch.
|
|
*/
|
|
static float GetUserUnitsPerInch()
|
|
{
|
|
return 96.0;
|
|
}
|
|
|
|
/**
|
|
* The conversion factor between user units and percentage units depends on
|
|
* aElement being non-null, and on aElement having a viewport element
|
|
* ancestor with only appropriate SVG elements between aElement and that
|
|
* ancestor. If that's not the case, then the conversion factor is undefined.
|
|
*
|
|
* This function returns a non-negative value if the conversion factor is
|
|
* defined, otherwise it returns numeric_limits<float>::quiet_NaN().
|
|
*/
|
|
static float GetUserUnitsPerPercent(const nsSVGElement *aElement, uint8_t aAxis);
|
|
|
|
float mValue;
|
|
uint8_t mUnit;
|
|
};
|
|
|
|
} // namespace mozilla
|
|
|
|
#endif // MOZILLA_SVGLENGTH_H__
|