1 /* 2 * Copyright (C) 2006, 2008 Apple Inc. All rights reserved. 3 * Copyright (C) 2008, 2010 Nokia Corporation and/or its subsidiary(-ies) 4 * Copyright (C) 2007 Alp Toker <alp (at) atoker.com> 5 * Copyright (C) 2008 Eric Seidel <eric (at) webkit.org> 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY 17 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR 20 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 21 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 22 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 23 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY 24 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include "config.h" 30 #include "core/html/canvas/CanvasStyle.h" 31 32 #include "CSSPropertyNames.h" 33 #include "core/css/CSSParser.h" 34 #include "core/css/StylePropertySet.h" 35 #include "core/html/HTMLCanvasElement.h" 36 #include "core/html/canvas/CanvasGradient.h" 37 #include "core/html/canvas/CanvasPattern.h" 38 #include "core/platform/graphics/GraphicsContext.h" 39 #include "wtf/Assertions.h" 40 #include "wtf/PassRefPtr.h" 41 42 namespace WebCore { 43 44 enum ColorParseResult { ParsedRGBA, ParsedCurrentColor, ParsedSystemColor, ParseFailed }; 45 46 static ColorParseResult parseColor(RGBA32& parsedColor, const String& colorString, Document* document = 0) 47 { 48 if (equalIgnoringCase(colorString, "currentcolor")) 49 return ParsedCurrentColor; 50 if (CSSParser::parseColor(parsedColor, colorString)) 51 return ParsedRGBA; 52 if (CSSParser::parseSystemColor(parsedColor, colorString, document)) 53 return ParsedSystemColor; 54 return ParseFailed; 55 } 56 57 RGBA32 currentColor(HTMLCanvasElement* canvas) 58 { 59 if (!canvas || !canvas->inDocument() || !canvas->inlineStyle()) 60 return Color::black; 61 RGBA32 rgba = Color::black; 62 CSSParser::parseColor(rgba, canvas->inlineStyle()->getPropertyValue(CSSPropertyColor)); 63 return rgba; 64 } 65 66 bool parseColorOrCurrentColor(RGBA32& parsedColor, const String& colorString, HTMLCanvasElement* canvas) 67 { 68 ColorParseResult parseResult = parseColor(parsedColor, colorString, canvas ? canvas->document() : 0); 69 switch (parseResult) { 70 case ParsedRGBA: 71 case ParsedSystemColor: 72 return true; 73 case ParsedCurrentColor: 74 parsedColor = currentColor(canvas); 75 return true; 76 case ParseFailed: 77 return false; 78 default: 79 ASSERT_NOT_REACHED(); 80 return false; 81 } 82 } 83 84 CanvasStyle::CanvasStyle(Type type, float overrideAlpha) 85 : m_type(type) 86 , m_overrideAlpha(overrideAlpha) 87 { 88 } 89 90 CanvasStyle::CanvasStyle(RGBA32 rgba) 91 : m_type(RGBA) 92 , m_rgba(rgba) 93 { 94 } 95 96 CanvasStyle::CanvasStyle(float grayLevel, float alpha) 97 : m_type(RGBA) 98 , m_rgba(makeRGBA32FromFloats(grayLevel, grayLevel, grayLevel, alpha)) 99 { 100 } 101 102 CanvasStyle::CanvasStyle(float r, float g, float b, float a) 103 : m_type(RGBA) 104 , m_rgba(makeRGBA32FromFloats(r, g, b, a)) 105 { 106 } 107 108 CanvasStyle::CanvasStyle(float c, float m, float y, float k, float a) 109 : m_type(CMYKA) 110 , m_rgba(makeRGBAFromCMYKA(c, m, y, k, a)) 111 , m_cmyka(c, m, y, k, a) 112 { 113 } 114 115 CanvasStyle::CanvasStyle(PassRefPtr<CanvasGradient> gradient) 116 : m_type(Gradient) 117 , m_gradient(gradient) 118 { 119 } 120 121 CanvasStyle::CanvasStyle(PassRefPtr<CanvasPattern> pattern) 122 : m_type(ImagePattern) 123 , m_pattern(pattern) 124 { 125 } 126 127 PassRefPtr<CanvasStyle> CanvasStyle::createFromString(const String& color, Document* document) 128 { 129 RGBA32 rgba; 130 ColorParseResult parseResult = parseColor(rgba, color, document); 131 switch (parseResult) { 132 case ParsedRGBA: 133 case ParsedSystemColor: 134 return adoptRef(new CanvasStyle(rgba)); 135 case ParsedCurrentColor: 136 return adoptRef(new CanvasStyle(CurrentColor)); 137 case ParseFailed: 138 return 0; 139 default: 140 ASSERT_NOT_REACHED(); 141 return 0; 142 } 143 } 144 145 PassRefPtr<CanvasStyle> CanvasStyle::createFromStringWithOverrideAlpha(const String& color, float alpha) 146 { 147 RGBA32 rgba; 148 ColorParseResult parseResult = parseColor(rgba, color); 149 switch (parseResult) { 150 case ParsedRGBA: 151 return adoptRef(new CanvasStyle(colorWithOverrideAlpha(rgba, alpha))); 152 case ParsedCurrentColor: 153 return adoptRef(new CanvasStyle(CurrentColorWithOverrideAlpha, alpha)); 154 case ParseFailed: 155 return 0; 156 default: 157 ASSERT_NOT_REACHED(); 158 return 0; 159 } 160 } 161 162 PassRefPtr<CanvasStyle> CanvasStyle::createFromGradient(PassRefPtr<CanvasGradient> gradient) 163 { 164 if (!gradient) 165 return 0; 166 return adoptRef(new CanvasStyle(gradient)); 167 } 168 PassRefPtr<CanvasStyle> CanvasStyle::createFromPattern(PassRefPtr<CanvasPattern> pattern) 169 { 170 if (!pattern) 171 return 0; 172 return adoptRef(new CanvasStyle(pattern)); 173 } 174 175 bool CanvasStyle::isEquivalentColor(const CanvasStyle& other) const 176 { 177 if (m_type != other.m_type) 178 return false; 179 180 switch (m_type) { 181 case RGBA: 182 return m_rgba == other.m_rgba; 183 case CMYKA: 184 return m_cmyka.c == other.m_cmyka.c 185 && m_cmyka.m == other.m_cmyka.m 186 && m_cmyka.y == other.m_cmyka.y 187 && m_cmyka.k == other.m_cmyka.k 188 && m_cmyka.a == other.m_cmyka.a; 189 case Gradient: 190 case ImagePattern: 191 case CurrentColor: 192 case CurrentColorWithOverrideAlpha: 193 return false; 194 } 195 196 ASSERT_NOT_REACHED(); 197 return false; 198 } 199 200 bool CanvasStyle::isEquivalentRGBA(float r, float g, float b, float a) const 201 { 202 if (m_type != RGBA) 203 return false; 204 205 return m_rgba == makeRGBA32FromFloats(r, g, b, a); 206 } 207 208 bool CanvasStyle::isEquivalentCMYKA(float c, float m, float y, float k, float a) const 209 { 210 if (m_type != CMYKA) 211 return false; 212 213 return c == m_cmyka.c 214 && m == m_cmyka.m 215 && y == m_cmyka.y 216 && k == m_cmyka.k 217 && a == m_cmyka.a; 218 } 219 220 void CanvasStyle::applyStrokeColor(GraphicsContext* context) 221 { 222 if (!context) 223 return; 224 switch (m_type) { 225 case RGBA: 226 context->setStrokeColor(m_rgba); 227 break; 228 case CMYKA: { 229 // FIXME: Do this through platform-independent GraphicsContext API. 230 // We'll need a fancier Color abstraction to support CMYKA correctly 231 context->setStrokeColor(m_rgba); 232 break; 233 } 234 case Gradient: 235 context->setStrokeGradient(canvasGradient()->gradient()); 236 break; 237 case ImagePattern: 238 context->setStrokePattern(canvasPattern()->pattern()); 239 break; 240 case CurrentColor: 241 case CurrentColorWithOverrideAlpha: 242 ASSERT_NOT_REACHED(); 243 break; 244 } 245 } 246 247 void CanvasStyle::applyFillColor(GraphicsContext* context) 248 { 249 if (!context) 250 return; 251 switch (m_type) { 252 case RGBA: 253 context->setFillColor(m_rgba); 254 break; 255 case CMYKA: { 256 // FIXME: Do this through platform-independent GraphicsContext API. 257 // We'll need a fancier Color abstraction to support CMYKA correctly 258 context->setFillColor(m_rgba); 259 break; 260 } 261 case Gradient: 262 context->setFillGradient(canvasGradient()->gradient()); 263 break; 264 case ImagePattern: 265 context->setFillPattern(canvasPattern()->pattern()); 266 break; 267 case CurrentColor: 268 case CurrentColorWithOverrideAlpha: 269 ASSERT_NOT_REACHED(); 270 break; 271 } 272 } 273 274 } 275