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 "core/CSSPropertyNames.h" 33 #include "core/css/StylePropertySet.h" 34 #include "core/css/parser/CSSParser.h" 35 #include "core/html/HTMLCanvasElement.h" 36 #include "core/html/canvas/CanvasGradient.h" 37 #include "core/html/canvas/CanvasPattern.h" 38 #include "platform/graphics/GraphicsContext.h" 39 #include "wtf/PassRefPtr.h" 40 41 namespace blink { 42 43 enum ColorParseResult { ParsedRGBA, ParsedCurrentColor, ParsedSystemColor, ParseFailed }; 44 45 static ColorParseResult parseColor(RGBA32& parsedColor, const String& colorString) 46 { 47 if (equalIgnoringCase(colorString, "currentcolor")) 48 return ParsedCurrentColor; 49 const bool useStrictParsing = true; 50 if (CSSParser::parseColor(parsedColor, colorString, useStrictParsing)) 51 return ParsedRGBA; 52 if (CSSParser::parseSystemColor(parsedColor, colorString)) 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); 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(PassRefPtrWillBeRawPtr<CanvasGradient> gradient) 116 : m_type(Gradient) 117 , m_gradient(gradient) 118 { 119 } 120 121 CanvasStyle::CanvasStyle(PassRefPtrWillBeRawPtr<CanvasPattern> pattern) 122 : m_type(ImagePattern) 123 , m_pattern(pattern) 124 { 125 } 126 127 PassRefPtrWillBeRawPtr<CanvasStyle> CanvasStyle::createFromString(const String& color) 128 { 129 RGBA32 rgba; 130 ColorParseResult parseResult = parseColor(rgba, color); 131 switch (parseResult) { 132 case ParsedRGBA: 133 case ParsedSystemColor: 134 return adoptRefWillBeNoop(new CanvasStyle(rgba)); 135 case ParsedCurrentColor: 136 return adoptRefWillBeNoop(new CanvasStyle(CurrentColor)); 137 case ParseFailed: 138 return nullptr; 139 default: 140 ASSERT_NOT_REACHED(); 141 return nullptr; 142 } 143 } 144 145 PassRefPtrWillBeRawPtr<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 adoptRefWillBeNoop(new CanvasStyle(colorWithOverrideAlpha(rgba, alpha))); 152 case ParsedCurrentColor: 153 return adoptRefWillBeNoop(new CanvasStyle(CurrentColorWithOverrideAlpha, alpha)); 154 case ParseFailed: 155 return nullptr; 156 default: 157 ASSERT_NOT_REACHED(); 158 return nullptr; 159 } 160 } 161 162 PassRefPtrWillBeRawPtr<CanvasStyle> CanvasStyle::createFromGradient(PassRefPtrWillBeRawPtr<CanvasGradient> gradient) 163 { 164 if (!gradient) 165 return nullptr; 166 return adoptRefWillBeNoop(new CanvasStyle(gradient)); 167 } 168 169 PassRefPtrWillBeRawPtr<CanvasStyle> CanvasStyle::createFromPattern(PassRefPtrWillBeRawPtr<CanvasPattern> pattern) 170 { 171 if (!pattern) 172 return nullptr; 173 return adoptRefWillBeNoop(new CanvasStyle(pattern)); 174 } 175 176 bool CanvasStyle::isEquivalentColor(const CanvasStyle& other) const 177 { 178 if (m_type != other.m_type) 179 return false; 180 181 switch (m_type) { 182 case RGBA: 183 return m_rgba == other.m_rgba; 184 case CMYKA: 185 return m_cmyka.c == other.m_cmyka.c 186 && m_cmyka.m == other.m_cmyka.m 187 && m_cmyka.y == other.m_cmyka.y 188 && m_cmyka.k == other.m_cmyka.k 189 && m_cmyka.a == other.m_cmyka.a; 190 case Gradient: 191 case ImagePattern: 192 case CurrentColor: 193 case CurrentColorWithOverrideAlpha: 194 return false; 195 } 196 197 ASSERT_NOT_REACHED(); 198 return false; 199 } 200 201 bool CanvasStyle::isEquivalentRGBA(float r, float g, float b, float a) const 202 { 203 if (m_type != RGBA) 204 return false; 205 206 return m_rgba == makeRGBA32FromFloats(r, g, b, a); 207 } 208 209 bool CanvasStyle::isEquivalentCMYKA(float c, float m, float y, float k, float a) const 210 { 211 if (m_type != CMYKA) 212 return false; 213 214 return c == m_cmyka.c 215 && m == m_cmyka.m 216 && y == m_cmyka.y 217 && k == m_cmyka.k 218 && a == m_cmyka.a; 219 } 220 221 void CanvasStyle::applyStrokeColor(GraphicsContext* context) 222 { 223 if (!context) 224 return; 225 switch (m_type) { 226 case RGBA: 227 context->setStrokeColor(m_rgba); 228 break; 229 case CMYKA: { 230 // FIXME: Do this through platform-independent GraphicsContext API. 231 // We'll need a fancier Color abstraction to support CMYKA correctly 232 context->setStrokeColor(m_rgba); 233 break; 234 } 235 case Gradient: 236 context->setStrokeGradient(canvasGradient()->gradient()); 237 break; 238 case ImagePattern: 239 context->setStrokePattern(canvasPattern()->pattern()); 240 break; 241 case CurrentColor: 242 case CurrentColorWithOverrideAlpha: 243 ASSERT_NOT_REACHED(); 244 break; 245 } 246 } 247 248 void CanvasStyle::applyFillColor(GraphicsContext* context) 249 { 250 if (!context) 251 return; 252 switch (m_type) { 253 case RGBA: 254 context->setFillColor(m_rgba); 255 break; 256 case CMYKA: { 257 // FIXME: Do this through platform-independent GraphicsContext API. 258 // We'll need a fancier Color abstraction to support CMYKA correctly 259 context->setFillColor(m_rgba); 260 break; 261 } 262 case Gradient: 263 context->setFillGradient(canvasGradient()->gradient()); 264 break; 265 case ImagePattern: 266 context->setFillPattern(canvasPattern()->pattern()); 267 break; 268 case CurrentColor: 269 case CurrentColorWithOverrideAlpha: 270 ASSERT_NOT_REACHED(); 271 break; 272 } 273 } 274 275 void CanvasStyle::trace(Visitor* visitor) 276 { 277 visitor->trace(m_gradient); 278 visitor->trace(m_pattern); 279 } 280 281 } 282