2 Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3 Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
4 Copyright (C) 2011 Rik Cabanier (cabanier@adobe.com)
5 Copyright (C) 2011 Adobe Systems Incorporated. All rights reserved.
7 This library is free software; you can redistribute it and/or
8 modify it under the terms of the GNU Library General Public
9 License as published by the Free Software Foundation; either
10 version 2 of the License, or (at your option) any later version.
12 This library is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Library General Public License for more details.
17 You should have received a copy of the GNU Library General Public License
18 along with this library; see the file COPYING.LIB. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA.
26 #include "platform/PlatformExport.h"
27 #include "platform/animation/AnimationUtilities.h"
28 #include "wtf/Assertions.h"
29 #include "wtf/FastAllocBase.h"
30 #include "wtf/Forward.h"
31 #include "wtf/HashMap.h"
32 #include "wtf/MathExtras.h"
33 #include "wtf/Vector.h"
38 // FIXME: This enum makes it hard to tell in general what values may be
39 // appropriate for any given Length.
42 Intrinsic, MinIntrinsic,
43 MinContent, MaxContent, FillAvailable, FitContent,
45 ExtendToZoom, DeviceWidth, DeviceHeight,
54 struct PixelsAndPercent {
55 PixelsAndPercent(float pixels, float percent)
64 class CalculationValue;
66 class PLATFORM_EXPORT Length {
67 WTF_MAKE_FAST_ALLOCATED;
70 : m_intValue(0), m_quirk(false), m_type(Auto), m_isFloat(false)
75 : m_intValue(0), m_quirk(false), m_type(t), m_isFloat(false)
77 ASSERT(t != Calculated);
80 Length(int v, LengthType t, bool q = false)
81 : m_intValue(v), m_quirk(q), m_type(t), m_isFloat(false)
83 ASSERT(t != Calculated);
86 Length(LayoutUnit v, LengthType t, bool q = false)
87 : m_floatValue(v.toFloat()), m_quirk(q), m_type(t), m_isFloat(true)
89 ASSERT(t != Calculated);
92 Length(float v, LengthType t, bool q = false)
93 : m_floatValue(v), m_quirk(q), m_type(t), m_isFloat(true)
95 ASSERT(t != Calculated);
98 Length(double v, LengthType t, bool q = false)
99 : m_quirk(q), m_type(t), m_isFloat(true)
101 m_floatValue = static_cast<float>(v);
104 explicit Length(PassRefPtr<CalculationValue>);
106 Length(const Length& length)
108 memcpy(this, &length, sizeof(Length));
110 incrementCalculatedRef();
113 Length& operator=(const Length& length)
115 if (length.isCalculated())
116 length.incrementCalculatedRef();
118 decrementCalculatedRef();
119 memcpy(this, &length, sizeof(Length));
126 decrementCalculatedRef();
129 bool operator==(const Length& o) const { return (m_type == o.m_type) && (m_quirk == o.m_quirk) && (isUndefined() || (getFloatValue() == o.getFloatValue()) || isCalculatedEqual(o)); }
130 bool operator!=(const Length& o) const { return !(*this == o); }
132 const Length& operator*=(float v)
134 if (isCalculated()) {
135 ASSERT_NOT_REACHED();
140 m_floatValue = static_cast<float>(m_floatValue * v);
142 m_intValue = static_cast<int>(m_intValue * v);
147 inline float value() const
149 return getFloatValue();
154 if (isCalculated()) {
155 ASSERT_NOT_REACHED();
158 return getIntValue();
161 float percent() const
163 ASSERT(type() == Percent);
164 return getFloatValue();
166 PixelsAndPercent pixelsAndPercent() const;
168 CalculationValue& calculationValue() const;
170 LengthType type() const { return static_cast<LengthType>(m_type); }
171 bool quirk() const { return m_quirk; }
173 void setQuirk(bool quirk)
178 void setValue(LengthType t, int value)
185 void setValue(int value)
187 if (isCalculated()) {
188 ASSERT_NOT_REACHED();
191 setValue(Fixed, value);
194 void setValue(LengthType t, float value)
197 m_floatValue = value;
201 void setValue(LengthType t, LayoutUnit value)
204 m_floatValue = value.toFloat();
208 void setValue(float value)
210 *this = Length(value, Fixed);
213 bool isUndefined() const { return type() == Undefined; }
215 // FIXME calc: https://bugs.webkit.org/show_bug.cgi?id=80357. A calculated Length
216 // always contains a percentage, and without a maxValue passed to these functions
217 // it's impossible to determine the sign or zero-ness. We assume all calc values
218 // are positive and non-zero for now.
221 ASSERT(!isUndefined());
225 return m_isFloat ? !m_floatValue : !m_intValue;
227 bool isPositive() const
234 return getFloatValue() > 0;
236 bool isNegative() const
238 if (isUndefined() || isCalculated())
241 return getFloatValue() < 0;
244 bool isAuto() const { return type() == Auto; }
245 bool isPercent() const { return type() == Percent || type() == Calculated; }
246 bool isFixed() const { return type() == Fixed; }
247 bool isIntrinsicOrAuto() const { return type() == Auto || isLegacyIntrinsic() || isIntrinsic(); }
248 bool isLegacyIntrinsic() const { return type() == Intrinsic || type() == MinIntrinsic; }
249 bool isIntrinsic() const { return type() == MinContent || type() == MaxContent || type() == FillAvailable || type() == FitContent; }
250 bool isSpecified() const { return type() == Fixed || type() == Percent || type() == Calculated; }
251 bool isSpecifiedOrIntrinsic() const { return isSpecified() || isIntrinsic(); }
252 bool isCalculated() const { return type() == Calculated; }
253 bool isCalculatedEqual(const Length&) const;
254 bool isMinContent() const { return type() == MinContent; }
255 bool isMaxContent() const { return type() == MaxContent; }
256 bool isFillAvailable() const { return type() == FillAvailable; }
257 bool isFitContent() const { return type() == FitContent; }
259 Length blend(const Length& from, double progress, ValueRange range) const
261 ASSERT(isSpecified() && from.isSpecified());
269 if (from.type() == Calculated || type() == Calculated)
270 return blendMixedTypes(from, progress, range);
272 if (!from.isZero() && !isZero() && from.type() != type())
273 return blendMixedTypes(from, progress, range);
275 if (from.isZero() && isZero())
278 LengthType resultType = type();
280 resultType = from.type();
282 float blendedValue = WebCore::blend(from.value(), value(), progress);
283 if (range == ValueRangeNonNegative)
284 blendedValue = clampTo<float>(blendedValue, 0);
285 return Length(blendedValue, resultType);
288 float getFloatValue() const
290 ASSERT(!isUndefined());
291 return m_isFloat ? m_floatValue : m_intValue;
293 float nonNanCalculatedValue(int maxValue) const;
295 Length subtractFromOneHundredPercent() const;
298 int getIntValue() const
300 ASSERT(!isUndefined());
301 return m_isFloat ? static_cast<int>(m_floatValue) : m_intValue;
304 Length blendMixedTypes(const Length& from, double progress, ValueRange) const;
306 int calculationHandle() const
308 ASSERT(isCalculated());
309 return getIntValue();
311 void incrementCalculatedRef() const;
312 void decrementCalculatedRef() const;
319 unsigned char m_type;
323 PLATFORM_EXPORT Vector<Length> parseHTMLAreaElementCoords(const String&);
325 } // namespace WebCore