#include "config.h"
#include "CanvasStyle.h"
#include "CSSParser.h"
#include "CSSPropertyNames.h"
#include "CanvasGradient.h"
#include "CanvasPattern.h"
#include "GraphicsContext.h"
#include "HTMLCanvasElement.h"
#include "StyleProperties.h"
#if USE(CG)
#include <CoreGraphics/CGContext.h>
#endif
namespace WebCore {
static bool isCurrentColorString(const String& colorString)
{
return equalLettersIgnoringASCIICase(colorString, "currentcolor");
}
static Color parseColor(const String& colorString)
{
Color color = CSSParser::parseColor(colorString);
if (color.isValid())
return color;
return CSSParser::parseSystemColor(colorString, nullptr);
}
Color currentColor(HTMLCanvasElement* canvas)
{
if (!canvas || !canvas->isConnected() || !canvas->inlineStyle())
return Color::black;
Color color = CSSParser::parseColor(canvas->inlineStyle()->getPropertyValue(CSSPropertyColor));
if (!color.isValid())
return Color::black;
return color;
}
Color parseColorOrCurrentColor(const String& colorString, HTMLCanvasElement* canvas)
{
if (isCurrentColorString(colorString))
return currentColor(canvas);
return parseColor(colorString);
}
CanvasStyle::CanvasStyle(Color color)
: m_style(color)
{
}
CanvasStyle::CanvasStyle(float grayLevel, float alpha)
: m_style(Color { grayLevel, grayLevel, grayLevel, alpha })
{
}
CanvasStyle::CanvasStyle(float r, float g, float b, float a)
: m_style(Color { r, g, b, a })
{
}
CanvasStyle::CanvasStyle(float c, float m, float y, float k, float a)
: m_style(CMYKAColor { Color { c, m, y, k, a }, c, m, y, k, a })
{
}
CanvasStyle::CanvasStyle(CanvasGradient& gradient)
: m_style(makeRefPtr(gradient))
{
}
CanvasStyle::CanvasStyle(CanvasPattern& pattern)
: m_style(makeRefPtr(pattern))
{
}
inline CanvasStyle::CanvasStyle(CurrentColor color)
: m_style(color)
{
}
CanvasStyle CanvasStyle::createFromString(const String& colorString)
{
if (isCurrentColorString(colorString))
return CurrentColor { WTF::nullopt };
Color color = parseColor(colorString);
if (!color.isValid())
return { };
return color;
}
CanvasStyle CanvasStyle::createFromStringWithOverrideAlpha(const String& colorString, float alpha)
{
if (isCurrentColorString(colorString))
return CurrentColor { alpha };
Color color = parseColor(colorString);
if (!color.isValid())
return { };
return Color { colorWithOverrideAlpha(color.rgb(), alpha) };
}
bool CanvasStyle::isEquivalentColor(const CanvasStyle& other) const
{
if (WTF::holds_alternative<Color>(m_style) && WTF::holds_alternative<Color>(other.m_style))
return WTF::get<Color>(m_style) == WTF::get<Color>(other.m_style);
if (WTF::holds_alternative<CMYKAColor>(m_style) && WTF::holds_alternative<CMYKAColor>(other.m_style)) {
auto& a = WTF::get<CMYKAColor>(m_style);
auto& b = WTF::get<CMYKAColor>(other.m_style);
return a.c == b.c && a.m == b.m && a.y == b.y && a.k == b.k && a.a == b.a;
}
return false;
}
bool CanvasStyle::isEquivalentRGBA(float r, float g, float b, float a) const
{
return WTF::holds_alternative<Color>(m_style) && WTF::get<Color>(m_style) == Color { r, g, b, a };
}
bool CanvasStyle::isEquivalentCMYKA(float c, float m, float y, float k, float a) const
{
if (!WTF::holds_alternative<CMYKAColor>(m_style))
return false;
auto& channels = WTF::get<CMYKAColor>(m_style);
return c == channels.c && m == channels.m && y == channels.y && k == channels.k && a == channels.a;
}
void CanvasStyle::applyStrokeColor(GraphicsContext& context) const
{
WTF::switchOn(m_style,
[&context] (const Color& color) {
context.setStrokeColor(color);
},
[&context] (const CMYKAColor& color) {
#if USE(CG)
CGContextSetCMYKStrokeColor(context.platformContext(), color.c, color.m, color.y, color.k, color.a);
#else
context.setStrokeColor(color.color);
#endif
},
[&context] (const RefPtr<CanvasGradient>& gradient) {
context.setStrokeGradient(gradient->gradient());
},
[&context] (const RefPtr<CanvasPattern>& pattern) {
context.setStrokePattern(pattern->pattern());
},
[] (const CurrentColor&) {
ASSERT_NOT_REACHED();
},
[] (const Invalid&) {
ASSERT_NOT_REACHED();
}
);
}
void CanvasStyle::applyFillColor(GraphicsContext& context) const
{
WTF::switchOn(m_style,
[&context] (const Color& color) {
context.setFillColor(color);
},
[&context] (const CMYKAColor& color) {
#if USE(CG)
CGContextSetCMYKFillColor(context.platformContext(), color.c, color.m, color.y, color.k, color.a);
#else
context.setFillColor(color.color);
#endif
},
[&context] (const RefPtr<CanvasGradient>& gradient) {
context.setFillGradient(gradient->gradient());
},
[&context] (const RefPtr<CanvasPattern>& pattern) {
context.setFillPattern(pattern->pattern());
},
[] (const CurrentColor&) {
ASSERT_NOT_REACHED();
},
[] (const Invalid&) {
ASSERT_NOT_REACHED();
}
);
}
}