#include "config.h"
#include "Gradient.h"
#if USE(CG)
#include "GraphicsContextCG.h"
#include <pal/spi/cg/CoreGraphicsSPI.h>
#include <wtf/RetainPtr.h>
namespace WebCore {
void Gradient::stopsChanged()
{
m_gradient = nullptr;
}
void Gradient::createCGGradient()
{
sortStops();
auto colorsArray = adoptCF(CFArrayCreateMutable(0, m_stops.size(), &kCFTypeArrayCallBacks));
unsigned numStops = m_stops.size();
const int reservedStops = 3;
Vector<CGFloat, reservedStops> locations;
locations.reserveInitialCapacity(numStops);
Vector<CGFloat, 4 * reservedStops> colorComponents;
colorComponents.reserveInitialCapacity(numStops * 4);
bool hasExtendedColors = false;
for (const auto& stop : m_stops) {
if (stop.color.isExtended())
hasExtendedColors = true;
auto [colorSpace, components] = stop.color.colorSpaceAndComponents();
auto [r, g, b, a] = components;
colorComponents.uncheckedAppend(r);
colorComponents.uncheckedAppend(g);
colorComponents.uncheckedAppend(b);
colorComponents.uncheckedAppend(a);
CFArrayAppendValue(colorsArray.get(), cachedCGColor(stop.color));
locations.uncheckedAppend(stop.offset);
}
if (hasExtendedColors)
m_gradient = adoptCF(CGGradientCreateWithColors(extendedSRGBColorSpaceRef(), colorsArray.get(), locations.data()));
else
m_gradient = adoptCF(CGGradientCreateWithColorComponents(sRGBColorSpaceRef(), colorComponents.data(), locations.data(), numStops));
}
void Gradient::fill(GraphicsContext& context, const FloatRect& rect)
{
context.clip(rect);
paint(context);
}
void Gradient::paint(GraphicsContext& context)
{
paint(context.platformContext());
}
void Gradient::paint(CGContextRef platformContext)
{
CGGradientDrawingOptions extendOptions = kCGGradientDrawsBeforeStartLocation | kCGGradientDrawsAfterEndLocation;
if (!m_gradient)
createCGGradient();
WTF::switchOn(m_data,
[&] (const LinearData& data) {
switch (m_spreadMethod) {
case GradientSpreadMethod::Repeat:
case GradientSpreadMethod::Reflect: {
CGContextStateSaver saveState(platformContext);
FloatPoint gradientVectorNorm(data.point1 - data.point0);
gradientVectorNorm.normalize();
CGFloat angle = acos(gradientVectorNorm.dot({ 1, 0 }));
CGContextRotateCTM(platformContext, angle);
CGAffineTransform transform = CGAffineTransformMakeRotation(-angle);
FloatPoint point0 = CGPointApplyAffineTransform(data.point0, transform);
FloatPoint point1 = CGPointApplyAffineTransform(data.point1, transform);
CGRect boundingBox = CGContextGetClipBoundingBox(platformContext);
CGFloat width = point1.x() - point0.x();
CGFloat pixelSize = CGFAbs(CGContextConvertSizeToUserSpace(platformContext, CGSizeMake(1, 1)).width);
if (width > 0 && !CGRectIsInfinite(boundingBox) && !CGRectIsEmpty(boundingBox)) {
extendOptions = 0;
if (width < pixelSize)
width = pixelSize;
CGFloat gradientStart = point0.x();
CGFloat gradientEnd = point1.x();
bool flip = m_spreadMethod == GradientSpreadMethod::Reflect;
int n = CGFloor((boundingBox.origin.x - gradientStart) / width);
gradientStart += n * width;
if (!(n % 2))
flip = false;
gradientEnd -= CGFloor((gradientEnd - CGRectGetMaxX(boundingBox)) / width) * width;
for (CGFloat start = gradientStart; start <= gradientEnd; start += width) {
CGPoint left = CGPointMake(flip ? start + width : start, boundingBox.origin.y);
CGPoint right = CGPointMake(flip ? start : start + width, boundingBox.origin.y);
CGContextDrawLinearGradient(platformContext, m_gradient.get(), left, right, extendOptions);
if (m_spreadMethod == GradientSpreadMethod::Reflect)
flip = !flip;
}
break;
}
FALLTHROUGH;
}
case GradientSpreadMethod::Pad:
CGContextDrawLinearGradient(platformContext, m_gradient.get(), data.point0, data.point1, extendOptions);
}
},
[&] (const RadialData& data) {
bool needScaling = data.aspectRatio != 1;
if (needScaling) {
CGContextSaveGState(platformContext);
ASSERT(data.point0 == data.point1);
CGContextTranslateCTM(platformContext, data.point0.x(), data.point0.y());
CGContextScaleCTM(platformContext, 1, 1 / data.aspectRatio);
CGContextTranslateCTM(platformContext, -data.point0.x(), -data.point0.y());
}
CGContextDrawRadialGradient(platformContext, m_gradient.get(), data.point0, data.startRadius, data.point1, data.endRadius, extendOptions);
if (needScaling)
CGContextRestoreGState(platformContext);
},
[&] (const ConicData& data) {
#if PLATFORM(COCOA) && !PLATFORM(APPLETV)
CGContextSaveGState(platformContext);
CGContextTranslateCTM(platformContext, data.point0.x(), data.point0.y());
CGContextRotateCTM(platformContext, (CGFloat)-M_PI_2);
CGContextTranslateCTM(platformContext, -data.point0.x(), -data.point0.y());
CGContextDrawConicGradient(platformContext, m_gradient.get(), data.point0, data.angleRadians);
CGContextRestoreGState(platformContext);
#else
UNUSED_PARAM(data);
#endif
}
);
}
}
#endif