#pragma once
#include "AffineTransform.h"
#include "Color.h"
#include "FloatPoint.h"
#include "GraphicsTypes.h"
#include <wtf/RefCounted.h>
#include <wtf/Variant.h>
#include <wtf/Vector.h>
#if USE(CG)
typedef struct CGContext* CGContextRef;
typedef struct CGGradient* CGGradientRef;
typedef CGGradientRef PlatformGradient;
#elif USE(DIRECT2D)
interface ID2D1Brush;
interface ID2D1RenderTarget;
typedef ID2D1Brush* PlatformGradient;
#elif USE(CAIRO)
typedef struct _cairo_pattern cairo_pattern_t;
typedef cairo_pattern_t* PlatformGradient;
#else
typedef void* PlatformGradient;
#endif
namespace WebCore {
class Color;
class FloatRect;
class GraphicsContext;
class Gradient : public RefCounted<Gradient> {
public:
struct ColorStop {
float offset { 0 };
Color color;
ColorStop() = default;
ColorStop(float offset, const Color& color)
: offset(offset)
, color(color)
{
}
};
using ColorStopVector = Vector<ColorStop, 2>;
struct LinearData {
FloatPoint point0;
FloatPoint point1;
};
struct RadialData {
FloatPoint point0;
FloatPoint point1;
float startRadius;
float endRadius;
float aspectRatio; };
using Data = Variant<LinearData, RadialData>;
enum class Type { Linear, Radial };
static Ref<Gradient> create(LinearData&&);
static Ref<Gradient> create(RadialData&&);
WEBCORE_EXPORT ~Gradient();
Type type() const;
bool hasAlpha() const;
bool isZeroSize() const;
const Data& data() const { return m_data; }
WEBCORE_EXPORT void addColorStop(const ColorStop&);
WEBCORE_EXPORT void addColorStop(float, const Color&);
void setSortedColorStops(ColorStopVector&&);
const ColorStopVector& stops() const { return m_stops; }
void setSpreadMethod(GradientSpreadMethod);
GradientSpreadMethod spreadMethod() const { return m_spreadMethod; }
void setGradientSpaceTransform(const AffineTransform& gradientSpaceTransformation);
const AffineTransform& gradientSpaceTransform() { return m_gradientSpaceTransformation; }
void fill(GraphicsContext&, const FloatRect&);
void adjustParametersForTiledDrawing(FloatSize&, FloatRect&, const FloatSize& spacing);
unsigned hash() const;
void invalidateHash() { m_cachedHash = 0; }
#if USE(CG)
void paint(GraphicsContext&);
void paint(CGContextRef);
#elif USE(DIRECT2D)
PlatformGradient createPlatformGradientIfNecessary(ID2D1RenderTarget*);
#elif USE(CAIRO)
PlatformGradient createPlatformGradient(float globalAlpha);
#endif
private:
Gradient(LinearData&&);
Gradient(RadialData&&);
PlatformGradient platformGradient();
void platformInit() { m_gradient = nullptr; }
void platformDestroy();
void sortStopsIfNecessary();
#if USE(DIRECT2D)
void generateGradient(ID2D1RenderTarget*);
#endif
Data m_data;
mutable ColorStopVector m_stops;
mutable bool m_stopsSorted { false };
GradientSpreadMethod m_spreadMethod { SpreadMethodPad };
AffineTransform m_gradientSpaceTransformation;
mutable unsigned m_cachedHash { 0 };
PlatformGradient m_gradient;
};
}