third_party/WebKit/Source/core/animation/DoubleStyleInterpolation.cpp

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "config.h"
   6 #include "core/animation/DoubleStyleInterpolation.h"
   7
   8 #include "core/css/CSSValueList.h"
   9 #include "core/css/resolver/StyleBuilder.h"
  10 #include "core/style/ComputedStyleConstants.h"
  11
  12 namespace blink {
  13
  14 bool DoubleStyleInterpolation::canCreateFrom(const CSSValue& value)
  15 {
  16     return value.isPrimitiveValue() && (toCSSPrimitiveValue(value).isNumber() || toCSSPrimitiveValue(value).isAngle());
  17 }
  18
  19 PassOwnPtr<InterpolableValue> DoubleStyleInterpolation::doubleToInterpolableValue(const CSSValue& value)
  20 {
  21     ASSERT(canCreateFrom(value));
  22     const CSSPrimitiveValue& primitive = toCSSPrimitiveValue(value);
  23     if (primitive.isNumber())
  24         return InterpolableNumber::create(primitive.getDoubleValue());
  25     if (primitive.isAngle())
  26         return InterpolableNumber::create(primitive.computeDegrees());
  27     ASSERT_NOT_REACHED();
  28     return nullptr;
  29 }
  30
  31 static double clampToRange(double value, InterpolationRange clamp)
  32 {
  33     switch (clamp) {
  34     case RangeAll:
  35         // Do nothing
  36         return value;
  37     case RangeZeroToOne:
  38         return clampTo<float>(value, 0, 1);
  39     case RangeOpacityFIXME:
  40         return clampTo<float>(value, 0, nextafterf(1, 0));
  41     case RangeFloor:
  42         return floor(value);
  43     case RangeRound:
  44         return round(value);
  45     case RangeRoundGreaterThanOrEqualToOne:
  46         return clampTo<float>(round(value), 1);
  47     case RangeGreaterThanOrEqualToOne:
  48         return clampTo<float>(value, 1);
  49     case RangeNonNegative:
  50         return clampTo<float>(value, 0);
  51     default:
  52         ASSERT_NOT_REACHED();
  53         return value;
  54     }
  55 }
  56
  57 PassRefPtrWillBeRawPtr<CSSValue> DoubleStyleInterpolation::interpolableValueToDouble(const InterpolableValue* value, bool isNumber, InterpolationRange clamp)
  58 {
  59     ASSERT(value->isNumber());
  60     double doubleValue = clampToRange(toInterpolableNumber(value)->value(), clamp);
  61
  62     if (isNumber)
  63         return CSSPrimitiveValue::create(doubleValue, CSSPrimitiveValue::UnitType::Number);
  64     return CSSPrimitiveValue::create(doubleValue, CSSPrimitiveValue::UnitType::Degrees);
  65 }
  66
  67 void DoubleStyleInterpolation::apply(StyleResolverState& state) const
  68 {
  69     if (m_id != CSSPropertyMotionRotation) {
  70         StyleBuilder::applyProperty(m_id, state, interpolableValueToDouble(m_cachedValue.get(), m_isNumber, m_clamp).get());
  71         return;
  72     }
  73
  74     StyleBuilder::applyProperty(m_id, state, interpolableValueToMotionRotation(m_cachedValue.get(), m_flag).get());
  75 }
  76
  77 PassOwnPtr<InterpolableValue> DoubleStyleInterpolation::toInterpolableValue(const CSSValue& value, CSSPropertyID property)
  78 {
  79     ASSERT(canCreateFrom(value));
  80     return doubleToInterpolableValue(value);
  81 }
  82
  83 PassRefPtrWillBeRawPtr<CSSValue> DoubleStyleInterpolation::fromInterpolableValue(const InterpolableValue& value, InterpolationRange range)
  84 {
  85     return interpolableValueToDouble(&value, true, range);
  86 }
  87
  88 namespace {
  89
  90 bool extractMotionRotation(const CSSValue& value, float* rotation, MotionRotationType* rotationType)
  91 {
  92     *rotation = 0;
  93     *rotationType = MotionRotationFixed;
  94
  95     if (!value.isValueList())
  96         return false;
  97     const CSSValueList& list = toCSSValueList(value);
  98
  99     int len = list.length();
 100     for (int i = 0; i < len; i++) {
 101         const CSSValue* item = list.item(i);
 102         if (!item->isPrimitiveValue())
 103             return false;
 104         const CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(item);
 105         if (primitiveValue->getValueID() == CSSValueAuto) {
 106             *rotationType = MotionRotationAuto;
 107         } else if (primitiveValue->getValueID() == CSSValueReverse) {
 108             *rotationType = MotionRotationAuto;
 109             *rotation += 180;
 110         } else if (primitiveValue->isAngle()) {
 111             *rotation += primitiveValue->computeDegrees();
 112         } else {
 113             return false;
 114         }
 115     }
 116     return true;
 117 }
 118
 119 } // namespace
 120
 121 PassRefPtrWillBeRawPtr<CSSValue> DoubleStyleInterpolation::interpolableValueToMotionRotation(InterpolableValue* value, bool flag)
 122 {
 123     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
 124     if (flag)
 125         list->append(CSSPrimitiveValue::createIdentifier(CSSValueAuto));
 126     ASSERT(value->isNumber());
 127     list->append(CSSPrimitiveValue::create(toInterpolableNumber(value)->value(), CSSPrimitiveValue::UnitType::Degrees));
 128     return list.release();
 129 }
 130
 131 PassOwnPtr<InterpolableValue> DoubleStyleInterpolation::motionRotationToInterpolableValue(const CSSValue& value)
 132 {
 133     float rotation;
 134     MotionRotationType rotationType;
 135     extractMotionRotation(value, &rotation, &rotationType);
 136
 137     return InterpolableNumber::create(rotation);
 138 }
 139
 140 PassRefPtr<DoubleStyleInterpolation> DoubleStyleInterpolation::maybeCreateFromMotionRotation(const CSSValue& start, const CSSValue& end, CSSPropertyID id)
 141 {
 142     float startRotation, endRotation;
 143     MotionRotationType startRotationType, endRotationType;
 144
 145     if (!extractMotionRotation(start, &startRotation, &startRotationType)
 146         || !extractMotionRotation(end, &endRotation, &endRotationType)
 147         || startRotationType != endRotationType)
 148         return nullptr;
 149
 150     return adoptRef(new DoubleStyleInterpolation(
 151         motionRotationToInterpolableValue(start),
 152         motionRotationToInterpolableValue(end),
 153         id, true, InterpolationRange::RangeAll, startRotationType == MotionRotationAuto));
 154 }
 155
 156 }