diff options
Diffstat (limited to 'dom/svg/SVGLength.h')
| -rw-r--r-- | dom/svg/SVGLength.h | 174 |
1 files changed, 174 insertions, 0 deletions
diff --git a/dom/svg/SVGLength.h b/dom/svg/SVGLength.h new file mode 100644 index 000000000..5cfcf9472 --- /dev/null +++ b/dom/svg/SVGLength.h @@ -0,0 +1,174 @@ +/* -*- 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__ |