CSS conic gradient

third_party/WebKit/Source/platform/graphics/Gradient.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 28 matching lines @@
 typedef Vector<SkColor, 8> ColorStopColorVector;
 
 namespace blink {
 
 Gradient::Gradient(const FloatPoint& p0, const FloatPoint& p1)
     : m_p0(p0)
     , m_p1(p1)
     , m_r0(0)
     , m_r1(0)
     , m_aspectRatio(1)
-    , m_radial(false)
+    , m_class(LinearClass)
     , m_stopsSorted(false)
     , m_drawInPMColorSpace(false)
     , m_spreadMethod(SpreadMethodPad)
 {
 }
 
 Gradient::Gradient(const FloatPoint& p0, float r0, const FloatPoint& p1, float r1, float aspectRatio)
     : m_p0(p0)
     , m_p1(p1)
     , m_r0(r0)
     , m_r1(r1)
     , m_aspectRatio(aspectRatio)
-    , m_radial(true)
+    , m_class(RadialClass)
     , m_stopsSorted(false)
     , m_drawInPMColorSpace(false)
     , m_spreadMethod(SpreadMethodPad)
+{
+}
+
+Gradient::Gradient(const FloatPoint& p0, float startAngle)
+    : m_p0(p0)
+    , m_r0(startAngle) // FIXME
+    , m_r1(0)
+    , m_aspectRatio(1)
+    , m_class(ConicClass)
+    , m_stopsSorted(false)
+    , m_drawInPMColorSpace(false)
+    , m_spreadMethod(SpreadMethodPad)
 {
 }
 
 Gradient::~Gradient()
 {
 }
 
 static inline bool compareStops(const Gradient::ColorStop& a, const Gradient::ColorStop& b)
 {
     return a.stop < b.stop;
 }
 
 void Gradient::addColorStop(const Gradient::ColorStop& stop)
 {
+    printf("*** addColorStop: %f/%x\n", stop.stop, stop.color.rgb());
     if (m_stops.isEmpty()) {
         m_stopsSorted = true;
     } else {
         m_stopsSorted = m_stopsSorted && compareStops(m_stops.last(), stop);
     }
 
     m_stops.append(stop);
     m_gradient.reset();
 }
 
@@ skipping 120 matching lines @@
     case SpreadMethodRepeat:
         tile = SkShader::kRepeat_TileMode;
         break;
     case SpreadMethodPad:
         tile = SkShader::kClamp_TileMode;
         break;
     }
 
     sk_sp<SkShader> shader;
     uint32_t shouldDrawInPMColorSpace = m_drawInPMColorSpace ? SkGradientShader::kInterpolateColorsInPremul_Flag : 0;
-    if (m_radial) {
+    switch (m_class) {
+    case RadialClass: {
         if (aspectRatio() != 1) {
             // CSS3 elliptical gradients: apply the elliptical scaling at the
             // gradient center point.
             m_gradientSpaceTransformation.translate(m_p0.x(), m_p0.y());
             m_gradientSpaceTransformation.scale(1, 1 / aspectRatio());
             m_gradientSpaceTransformation.translate(-m_p0.x(), -m_p0.y());
             ASSERT(m_p0 == m_p1);
         }
         SkMatrix localMatrix = affineTransformToSkMatrix(m_gradientSpaceTransformation);
 
         // Since the two-point radial gradient is slower than the plain radial,
         // only use it if we have to.
         if (m_p0 == m_p1 && m_r0 <= 0.0f) {
             shader = SkGradientShader::MakeRadial(m_p1.data(), m_r1, colors.data(), pos.data(), static_cast<int>(countUsed), tile, shouldDrawInPMColorSpace, &localMatrix);
         } else {
             // The radii we give to Skia must be positive. If we're given a
             // negative radius, ask for zero instead.
             SkScalar radius0 = m_r0 >= 0.0f ? WebCoreFloatToSkScalar(m_r0) : 0;
             SkScalar radius1 = m_r1 >= 0.0f ? WebCoreFloatToSkScalar(m_r1) : 0;
             shader = SkGradientShader::MakeTwoPointConical(m_p0.data(), radius0, m_p1.data(), radius1, colors.data(), pos.data(), static_cast<int>(countUsed), tile, shouldDrawInPMColorSpace, &localMatrix);
         }
-    } else {
+    } break;
+    case LinearClass: {
         SkPoint pts[2] = { m_p0.data(), m_p1.data() };
         SkMatrix localMatrix = affineTransformToSkMatrix(m_gradientSpaceTransformation);
         shader = SkGradientShader::MakeLinear(pts, colors.data(), pos.data(), static_cast<int>(countUsed), tile, shouldDrawInPMColorSpace, &localMatrix);
+    } break;
+    case ConicClass: {
+        SkMatrix localMatrix = affineTransformToSkMatrix(m_gradientSpaceTransformation);
+        shader = SkGradientShader::MakeSweep(m_p0.x(), m_p0.y(), colors.data(), pos.data(), static_cast<int>(countUsed), shouldDrawInPMColorSpace, &localMatrix);
+    } break;
     }
 
     if (!shader) {
         // use last color, since our "geometry" was degenerate (e.g. radius==0)
         shader = SkShader::MakeColorShader(colors[countUsed - 1]);
     }
 
     return shader;
 }
 
 void Gradient::applyToPaint(SkPaint& paint)
 {
     if (!m_gradient)
         m_gradient = createShader();
 
     paint.setShader(m_gradient);
 
     // Legacy behavior: gradients are always dithered.
     paint.setDither(true);
 }
 
 } // namespace blink