diff options
Diffstat (limited to 'layout/style/CSSCalc.h')
| -rw-r--r-- | layout/style/CSSCalc.h | 361 |
1 files changed, 361 insertions, 0 deletions
diff --git a/layout/style/CSSCalc.h b/layout/style/CSSCalc.h new file mode 100644 index 000000000..141ca9c0a --- /dev/null +++ b/layout/style/CSSCalc.h @@ -0,0 +1,361 @@ +/* vim: set shiftwidth=2 tabstop=8 autoindent cindent expandtab: */ +/* 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 CSSCalc_h_ +#define CSSCalc_h_ + +#include "nsCSSValue.h" +#include "nsStyleCoord.h" +#include <math.h> + +namespace mozilla { + +namespace css { + +/** + * ComputeCalc computes the result of a calc() expression tree. + * + * It is templatized over a CalcOps class that is expected to provide: + * + * // input_type and input_array_type have a bunch of very specific + * // expectations (which happen to be met by two classes (nsCSSValue + * // and nsStyleCoord). There must be methods (roughly): + * // input_array_type* input_type::GetArrayValue(); + * // uint32_t input_array_type::Count() const; + * // input_type& input_array_type::Item(uint32_t); + * typedef ... input_type; + * typedef ... input_array_type; + * + * typedef ... result_type; + * + * // GetUnit(avalue) must return the correct nsCSSUnit for any + * // value that represents a calc tree node (eCSSUnit_Calc*). For + * // other nodes, it may return any non eCSSUnit_Calc* unit. + * static nsCSSUnit GetUnit(const input_type& aValue); + * + * result_type + * MergeAdditive(nsCSSUnit aCalcFunction, + * result_type aValue1, result_type aValue2); + * + * result_type + * MergeMultiplicativeL(nsCSSUnit aCalcFunction, + * float aValue1, result_type aValue2); + * + * result_type + * MergeMultiplicativeR(nsCSSUnit aCalcFunction, + * result_type aValue1, float aValue2); + * + * result_type + * ComputeLeafValue(const input_type& aValue); + * + * float + * ComputeNumber(const input_type& aValue); + * + * The CalcOps methods might compute the calc() expression down to a + * number, reduce some parts of it to a number but replicate other + * parts, or produce a tree with a different data structure (for + * example, nsCSS* for specified values vs nsStyle* for computed + * values). + * + * For each leaf in the calc() expression, ComputeCalc will call either + * ComputeNumber (when the leaf is the left side of a Times_L or the + * right side of a Times_R or Divided) or ComputeLeafValue (otherwise). + * (The CalcOps in the CSS parser that reduces purely numeric + * expressions in turn calls ComputeCalc on numbers; other ops can + * presume that expressions in the number positions have already been + * normalized to a single numeric value and derive from + * NumbersAlreadyNormalizedCalcOps.) + * + * For non-leaves, one of the Merge functions will be called: + * MergeAdditive for Plus and Minus + * MergeMultiplicativeL for Times_L (number * value) + * MergeMultiplicativeR for Times_R (value * number) and Divided + */ +template <class CalcOps> +static typename CalcOps::result_type +ComputeCalc(const typename CalcOps::input_type& aValue, CalcOps &aOps) +{ + switch (CalcOps::GetUnit(aValue)) { + case eCSSUnit_Calc: { + typename CalcOps::input_array_type *arr = aValue.GetArrayValue(); + MOZ_ASSERT(arr->Count() == 1, "unexpected length"); + return ComputeCalc(arr->Item(0), aOps); + } + case eCSSUnit_Calc_Plus: + case eCSSUnit_Calc_Minus: { + typename CalcOps::input_array_type *arr = aValue.GetArrayValue(); + MOZ_ASSERT(arr->Count() == 2, "unexpected length"); + typename CalcOps::result_type lhs = ComputeCalc(arr->Item(0), aOps), + rhs = ComputeCalc(arr->Item(1), aOps); + return aOps.MergeAdditive(CalcOps::GetUnit(aValue), lhs, rhs); + } + case eCSSUnit_Calc_Times_L: { + typename CalcOps::input_array_type *arr = aValue.GetArrayValue(); + MOZ_ASSERT(arr->Count() == 2, "unexpected length"); + float lhs = aOps.ComputeNumber(arr->Item(0)); + typename CalcOps::result_type rhs = ComputeCalc(arr->Item(1), aOps); + return aOps.MergeMultiplicativeL(CalcOps::GetUnit(aValue), lhs, rhs); + } + case eCSSUnit_Calc_Times_R: + case eCSSUnit_Calc_Divided: { + typename CalcOps::input_array_type *arr = aValue.GetArrayValue(); + MOZ_ASSERT(arr->Count() == 2, "unexpected length"); + typename CalcOps::result_type lhs = ComputeCalc(arr->Item(0), aOps); + float rhs = aOps.ComputeNumber(arr->Item(1)); + return aOps.MergeMultiplicativeR(CalcOps::GetUnit(aValue), lhs, rhs); + } + default: { + return aOps.ComputeLeafValue(aValue); + } + } +} + +/** + * The input unit operation for input_type being nsCSSValue. + */ +struct CSSValueInputCalcOps +{ + typedef nsCSSValue input_type; + typedef nsCSSValue::Array input_array_type; + + static nsCSSUnit GetUnit(const nsCSSValue& aValue) + { + return aValue.GetUnit(); + } + +}; + +/** + * Basic*CalcOps provide a partial implementation of the CalcOps + * template parameter to ComputeCalc, for those callers whose merging + * just consists of mathematics (rather than tree construction). + */ + +struct BasicCoordCalcOps +{ + typedef nscoord result_type; + + result_type + MergeAdditive(nsCSSUnit aCalcFunction, + result_type aValue1, result_type aValue2) + { + if (aCalcFunction == eCSSUnit_Calc_Plus) { + return NSCoordSaturatingAdd(aValue1, aValue2); + } + MOZ_ASSERT(aCalcFunction == eCSSUnit_Calc_Minus, + "unexpected unit"); + return NSCoordSaturatingSubtract(aValue1, aValue2, 0); + } + + result_type + MergeMultiplicativeL(nsCSSUnit aCalcFunction, + float aValue1, result_type aValue2) + { + MOZ_ASSERT(aCalcFunction == eCSSUnit_Calc_Times_L, + "unexpected unit"); + return NSCoordSaturatingMultiply(aValue2, aValue1); + } + + result_type + MergeMultiplicativeR(nsCSSUnit aCalcFunction, + result_type aValue1, float aValue2) + { + MOZ_ASSERT(aCalcFunction == eCSSUnit_Calc_Times_R || + aCalcFunction == eCSSUnit_Calc_Divided, + "unexpected unit"); + if (aCalcFunction == eCSSUnit_Calc_Divided) { + aValue2 = 1.0f / aValue2; + } + return NSCoordSaturatingMultiply(aValue1, aValue2); + } +}; + +struct BasicFloatCalcOps +{ + typedef float result_type; + + result_type + MergeAdditive(nsCSSUnit aCalcFunction, + result_type aValue1, result_type aValue2) + { + if (aCalcFunction == eCSSUnit_Calc_Plus) { + return aValue1 + aValue2; + } + MOZ_ASSERT(aCalcFunction == eCSSUnit_Calc_Minus, + "unexpected unit"); + return aValue1 - aValue2; + } + + result_type + MergeMultiplicativeL(nsCSSUnit aCalcFunction, + float aValue1, result_type aValue2) + { + MOZ_ASSERT(aCalcFunction == eCSSUnit_Calc_Times_L, + "unexpected unit"); + return aValue1 * aValue2; + } + + result_type + MergeMultiplicativeR(nsCSSUnit aCalcFunction, + result_type aValue1, float aValue2) + { + if (aCalcFunction == eCSSUnit_Calc_Times_R) { + return aValue1 * aValue2; + } + MOZ_ASSERT(aCalcFunction == eCSSUnit_Calc_Divided, + "unexpected unit"); + return aValue1 / aValue2; + } +}; + +/** + * A ComputeNumber implementation for callers that can assume numbers + * are already normalized (i.e., anything past the parser). + */ +struct NumbersAlreadyNormalizedOps : public CSSValueInputCalcOps +{ + float ComputeNumber(const nsCSSValue& aValue) + { + MOZ_ASSERT(aValue.GetUnit() == eCSSUnit_Number, "unexpected unit"); + return aValue.GetFloatValue(); + } +}; + +/** + * SerializeCalc appends the serialization of aValue to a string. + * + * It is templatized over a CalcOps class that is expected to provide: + * + * // input_type and input_array_type have a bunch of very specific + * // expectations (which happen to be met by two classes (nsCSSValue + * // and nsStyleCoord). There must be methods (roughly): + * // input_array_type* input_type::GetArrayValue(); + * // uint32_t input_array_type::Count() const; + * // input_type& input_array_type::Item(uint32_t); + * typedef ... input_type; + * typedef ... input_array_type; + * + * static nsCSSUnit GetUnit(const input_type& aValue); + * + * void Append(const char* aString); + * void AppendLeafValue(const input_type& aValue); + * void AppendNumber(const input_type& aValue); + * + * Data structures given may or may not have a toplevel eCSSUnit_Calc + * node representing a calc whose toplevel is not min() or max(). + */ + +template <class CalcOps> +static void +SerializeCalcInternal(const typename CalcOps::input_type& aValue, CalcOps &aOps); + +// Serialize the toplevel value in a calc() tree. See big comment +// above. +template <class CalcOps> +static void +SerializeCalc(const typename CalcOps::input_type& aValue, CalcOps &aOps) +{ + aOps.Append("calc("); + nsCSSUnit unit = CalcOps::GetUnit(aValue); + if (unit == eCSSUnit_Calc) { + const typename CalcOps::input_array_type *array = aValue.GetArrayValue(); + MOZ_ASSERT(array->Count() == 1, "unexpected length"); + SerializeCalcInternal(array->Item(0), aOps); + } else { + SerializeCalcInternal(aValue, aOps); + } + aOps.Append(")"); +} + +static inline bool +IsCalcAdditiveUnit(nsCSSUnit aUnit) +{ + return aUnit == eCSSUnit_Calc_Plus || + aUnit == eCSSUnit_Calc_Minus; +} + +static inline bool +IsCalcMultiplicativeUnit(nsCSSUnit aUnit) +{ + return aUnit == eCSSUnit_Calc_Times_L || + aUnit == eCSSUnit_Calc_Times_R || + aUnit == eCSSUnit_Calc_Divided; +} + +// Serialize a non-toplevel value in a calc() tree. See big comment +// above. +template <class CalcOps> +/* static */ void +SerializeCalcInternal(const typename CalcOps::input_type& aValue, CalcOps &aOps) +{ + nsCSSUnit unit = CalcOps::GetUnit(aValue); + if (IsCalcAdditiveUnit(unit)) { + const typename CalcOps::input_array_type *array = aValue.GetArrayValue(); + MOZ_ASSERT(array->Count() == 2, "unexpected length"); + + SerializeCalcInternal(array->Item(0), aOps); + + if (eCSSUnit_Calc_Plus == unit) { + aOps.Append(" + "); + } else { + MOZ_ASSERT(eCSSUnit_Calc_Minus == unit, "unexpected unit"); + aOps.Append(" - "); + } + + bool needParens = IsCalcAdditiveUnit(CalcOps::GetUnit(array->Item(1))); + if (needParens) { + aOps.Append("("); + } + SerializeCalcInternal(array->Item(1), aOps); + if (needParens) { + aOps.Append(")"); + } + } else if (IsCalcMultiplicativeUnit(unit)) { + const typename CalcOps::input_array_type *array = aValue.GetArrayValue(); + MOZ_ASSERT(array->Count() == 2, "unexpected length"); + + bool needParens = IsCalcAdditiveUnit(CalcOps::GetUnit(array->Item(0))); + if (needParens) { + aOps.Append("("); + } + if (unit == eCSSUnit_Calc_Times_L) { + aOps.AppendNumber(array->Item(0)); + } else { + SerializeCalcInternal(array->Item(0), aOps); + } + if (needParens) { + aOps.Append(")"); + } + + if (eCSSUnit_Calc_Times_L == unit || eCSSUnit_Calc_Times_R == unit) { + aOps.Append(" * "); + } else { + MOZ_ASSERT(eCSSUnit_Calc_Divided == unit, "unexpected unit"); + aOps.Append(" / "); + } + + nsCSSUnit subUnit = CalcOps::GetUnit(array->Item(1)); + needParens = IsCalcAdditiveUnit(subUnit) || + IsCalcMultiplicativeUnit(subUnit); + if (needParens) { + aOps.Append("("); + } + if (unit == eCSSUnit_Calc_Times_L) { + SerializeCalcInternal(array->Item(1), aOps); + } else { + aOps.AppendNumber(array->Item(1)); + } + if (needParens) { + aOps.Append(")"); + } + } else { + aOps.AppendLeafValue(aValue); + } +} + +} // namespace css + +} // namespace mozilla + +#endif /* !defined(CSSCalc_h_) */ |