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));
123 #if COMPILER_SUPPORTS(CXX_RVALUE_REFERENCES)
124 Length(Length&& length)
126 memcpy(this, &length, sizeof(Length));
128 // Reset |length|'s type to Auto to make sure its destructor
129 // won't call decrementCalculatedRef() as we don't call
130 // incrementCalculatedRef() here.
131 length.m_type = Auto;
134 Length& operator=(Length&& length)
140 decrementCalculatedRef();
142 memcpy(this, &length, sizeof(Length));
144 // Reset |length|'s type to Auto to make sure its destructor
145 // won't call decrementCalculatedRef() as we don't call
146 // incrementCalculatedRef() here.
147 length.m_type = Auto;
156 decrementCalculatedRef();
159 bool operator==(const Length& o) const { return (m_type == o.m_type) && (m_quirk == o.m_quirk) && (isMaxSizeNone() || (getFloatValue() == o.getFloatValue()) || isCalculatedEqual(o)); }
160 bool operator!=(const Length& o) const { return !(*this == o); }
162 const Length& operator*=(float v)
164 if (isCalculated()) {
165 ASSERT_NOT_REACHED();
170 m_floatValue = static_cast<float>(m_floatValue * v);
172 m_intValue = static_cast<int>(m_intValue * v);
177 inline float value() const
179 return getFloatValue();
184 if (isCalculated()) {
185 ASSERT_NOT_REACHED();
188 return getIntValue();
191 float percent() const
193 ASSERT(type() == Percent);
194 return getFloatValue();
196 PixelsAndPercent pixelsAndPercent() const;
198 CalculationValue& calculationValue() const;
200 LengthType type() const { return static_cast<LengthType>(m_type); }
201 bool quirk() const { return m_quirk; }
203 void setQuirk(bool quirk)
208 void setValue(LengthType t, int value)
215 void setValue(int value)
217 if (isCalculated()) {
218 ASSERT_NOT_REACHED();
221 setValue(Fixed, value);
224 void setValue(LengthType t, float value)
227 m_floatValue = value;
231 void setValue(LengthType t, LayoutUnit value)
234 m_floatValue = value.toFloat();
238 void setValue(float value)
240 *this = Length(value, Fixed);
243 bool isMaxSizeNone() const { return type() == MaxSizeNone; }
245 // FIXME calc: https://bugs.webkit.org/show_bug.cgi?id=80357. A calculated Length
246 // always contains a percentage, and without a maxValue passed to these functions
247 // it's impossible to determine the sign or zero-ness. We assume all calc values
248 // are positive and non-zero for now.
251 ASSERT(!isMaxSizeNone());
255 return m_isFloat ? !m_floatValue : !m_intValue;
257 bool isPositive() const
264 return getFloatValue() > 0;
266 bool isNegative() const
268 if (isMaxSizeNone() || isCalculated())
271 return getFloatValue() < 0;
274 bool isAuto() const { return type() == Auto; }
275 bool isPercent() const { return type() == Percent || type() == Calculated; }
276 bool isFixed() const { return type() == Fixed; }
277 bool isIntrinsicOrAuto() const { return type() == Auto || isLegacyIntrinsic() || isIntrinsic(); }
278 bool isLegacyIntrinsic() const { return type() == Intrinsic || type() == MinIntrinsic; }
279 bool isIntrinsic() const { return type() == MinContent || type() == MaxContent || type() == FillAvailable || type() == FitContent; }
280 bool isSpecified() const { return type() == Fixed || type() == Percent || type() == Calculated; }
281 bool isSpecifiedOrIntrinsic() const { return isSpecified() || isIntrinsic(); }
282 bool isCalculated() const { return type() == Calculated; }
283 bool isCalculatedEqual(const Length&) const;
284 bool isMinContent() const { return type() == MinContent; }
285 bool isMaxContent() const { return type() == MaxContent; }
286 bool isFillAvailable() const { return type() == FillAvailable; }
287 bool isFitContent() const { return type() == FitContent; }
289 Length blend(const Length& from, double progress, ValueRange range) const
291 ASSERT(isSpecified() && from.isSpecified());
299 if (from.type() == Calculated || type() == Calculated)
300 return blendMixedTypes(from, progress, range);
302 if (!from.isZero() && !isZero() && from.type() != type())
303 return blendMixedTypes(from, progress, range);
305 if (from.isZero() && isZero())
308 LengthType resultType = type();
310 resultType = from.type();
312 float blendedValue = blink::blend(from.value(), value(), progress);
313 if (range == ValueRangeNonNegative)
314 blendedValue = clampTo<float>(blendedValue, 0);
315 return Length(blendedValue, resultType);
318 float getFloatValue() const
320 ASSERT(!isMaxSizeNone());
321 return m_isFloat ? m_floatValue : m_intValue;
323 float nonNanCalculatedValue(int maxValue) const;
325 Length subtractFromOneHundredPercent() const;
328 int getIntValue() const
330 ASSERT(!isMaxSizeNone());
331 return m_isFloat ? static_cast<int>(m_floatValue) : m_intValue;
334 Length blendMixedTypes(const Length& from, double progress, ValueRange) const;
336 int calculationHandle() const
338 ASSERT(isCalculated());
339 return getIntValue();
341 void incrementCalculatedRef() const;
342 void decrementCalculatedRef() const;
349 unsigned char m_type;
353 PLATFORM_EXPORT Vector<Length> parseHTMLAreaElementCoords(const String&);