[WebGL2] Teach WebGLRenderingContextBase about new texture internal formats
[WebKit-https.git] / Source / WebCore / platform / graphics / GraphicsTypes.cpp
1 /*
2  * Copyright (C) 2006 Apple Inc.  All rights reserved.
3  * Copyright (C) 2012 Rik Cabanier (cabanier@adobe.com)
4  * Copyright (C) 2014 Adobe Systems Incorporated. All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
26  */
27
28 #include "config.h"
29 #include "GraphicsTypes.h"
30
31 #include "TextStream.h"
32 #include <wtf/Assertions.h>
33 #include <wtf/text/WTFString.h>
34
35 namespace WebCore {
36
37 static const char* const compositeOperatorNames[] = {
38     "clear",
39     "copy",
40     "source-over",
41     "source-in",
42     "source-out",
43     "source-atop",
44     "destination-over",
45     "destination-in",
46     "destination-out",
47     "destination-atop",
48     "xor",
49     "darker",
50     "lighter",
51     "difference"
52 };
53
54 static const char* const blendOperatorNames[] = {
55     "normal",
56     "multiply",
57     "screen",
58     "darken",
59     "lighten",
60     "overlay",
61     "color-dodge",
62     "color-burn",
63     "hard-light",
64     "soft-light",
65     "difference",
66     "exclusion",
67     "hue",
68     "saturation",
69     "color",
70     "luminosity",
71     "plus-darker",
72     "plus-lighter"
73 };
74 const int numCompositeOperatorNames = WTF_ARRAY_LENGTH(compositeOperatorNames);
75 const int numBlendOperatorNames = WTF_ARRAY_LENGTH(blendOperatorNames);
76
77 bool parseBlendMode(const String& s, BlendMode& blendMode)
78 {
79     for (int i = 0; i < numBlendOperatorNames; i++) {
80         if (s == blendOperatorNames[i]) {
81             blendMode = static_cast<BlendMode>(i + BlendModeNormal);
82             return true;
83         }
84     }
85     
86     return false;
87 }
88
89 bool parseCompositeAndBlendOperator(const String& s, CompositeOperator& op, BlendMode& blendOp)
90 {
91     for (int i = 0; i < numCompositeOperatorNames; i++) {
92         if (s == compositeOperatorNames[i]) {
93             op = static_cast<CompositeOperator>(i);
94             blendOp = BlendModeNormal;
95             return true;
96         }
97     }
98     
99     if (parseBlendMode(s, blendOp)) {
100         // For now, blending will always assume source-over. This will be fixed in the future
101         op = CompositeSourceOver;
102         return true;
103     }
104     
105     return false;
106 }
107
108 // FIXME: when we support blend modes in combination with compositing other than source-over
109 // this routine needs to be updated.
110 String compositeOperatorName(CompositeOperator op, BlendMode blendOp)
111 {
112     ASSERT(op >= 0);
113     ASSERT(op < numCompositeOperatorNames);
114     ASSERT(blendOp >= BlendModeNormal);
115     ASSERT(blendOp <= numBlendOperatorNames);
116     if (blendOp > BlendModeNormal)
117         return blendOperatorNames[blendOp - BlendModeNormal];
118     return compositeOperatorNames[op];
119 }
120
121 static String blendModeName(BlendMode blendOp)
122 {
123     ASSERT(blendOp >= BlendModeNormal);
124     ASSERT(blendOp <= BlendModePlusLighter);
125     return blendOperatorNames[blendOp - BlendModeNormal];
126 }
127
128 bool parseLineCap(const String& s, LineCap& cap)
129 {
130     if (s == "butt") {
131         cap = ButtCap;
132         return true;
133     }
134     if (s == "round") {
135         cap = RoundCap;
136         return true;
137     }
138     if (s == "square") {
139         cap = SquareCap;
140         return true;
141     }
142     return false;
143 }
144
145 String lineCapName(LineCap cap)
146 {
147     ASSERT(cap >= 0);
148     ASSERT(cap < 3);
149     const char* const names[3] = { "butt", "round", "square" };
150     return names[cap];
151 }
152
153 bool parseLineJoin(const String& s, LineJoin& join)
154 {
155     if (s == "miter") {
156         join = MiterJoin;
157         return true;
158     }
159     if (s == "round") {
160         join = RoundJoin;
161         return true;
162     }
163     if (s == "bevel") {
164         join = BevelJoin;
165         return true;
166     }
167     return false;
168 }
169
170 String lineJoinName(LineJoin join)
171 {
172     ASSERT(join >= 0);
173     ASSERT(join < 3);
174     const char* const names[3] = { "miter", "round", "bevel" };
175     return names[join];
176 }
177
178 String textAlignName(TextAlign align)
179 {
180     ASSERT(align >= 0);
181     ASSERT(align < 5);
182     const char* const names[5] = { "start", "end", "left", "center", "right" };
183     return names[align];
184 }
185
186 bool parseTextAlign(const String& s, TextAlign& align)
187 {
188     if (s == "start") {
189         align = StartTextAlign;
190         return true;
191     }
192     if (s == "end") {
193         align = EndTextAlign;
194         return true;
195     }
196     if (s == "left") {
197         align = LeftTextAlign;
198         return true;
199     }
200     if (s == "center") {
201         align = CenterTextAlign;
202         return true;
203     }
204     if (s == "right") {
205         align = RightTextAlign;
206         return true;
207     }
208     return false;
209 }
210
211 String textBaselineName(TextBaseline baseline)
212 {
213     ASSERT(baseline >= 0);
214     ASSERT(baseline < 6);
215     const char* const names[6] = { "alphabetic", "top", "middle", "bottom", "ideographic", "hanging" };
216     return names[baseline];
217 }
218
219 bool parseTextBaseline(const String& s, TextBaseline& baseline)
220 {
221     if (s == "alphabetic") {
222         baseline = AlphabeticTextBaseline;
223         return true;
224     }
225     if (s == "top") {
226         baseline = TopTextBaseline;
227         return true;
228     }
229     if (s == "middle") {
230         baseline = MiddleTextBaseline;
231         return true;
232     }
233     if (s == "bottom") {
234         baseline = BottomTextBaseline;
235         return true;
236     }
237     if (s == "ideographic") {
238         baseline = IdeographicTextBaseline;
239         return true;
240     }
241     if (s == "hanging") {
242         baseline = HangingTextBaseline;
243         return true;
244     }
245     return false;
246 }
247
248 TextStream& operator<<(TextStream& ts, CompositeOperator op)
249 {
250     return ts << compositeOperatorName(op, BlendModeNormal);
251 }
252
253 TextStream& operator<<(TextStream& ts, BlendMode blendMode)
254 {
255     return ts << blendModeName(blendMode);
256 }
257
258 TextStream& operator<<(TextStream& ts, WindRule rule)
259 {
260     switch (rule) {
261     case RULE_NONZERO:
262         ts << "NON-ZERO";
263         break;
264     case RULE_EVENODD:
265         ts << "EVEN-ODD";
266         break;
267     }
268
269     return ts;
270 }
271
272 TextStream& operator<<(TextStream& ts, LineCap capStyle)
273 {
274     switch (capStyle) {
275     case ButtCap:
276         ts << "BUTT";
277         break;
278     case RoundCap:
279         ts << "ROUND";
280         break;
281     case SquareCap:
282         ts << "SQUARE";
283         break;
284     }
285     return ts;
286 }
287
288 TextStream& operator<<(TextStream& ts, LineJoin joinStyle)
289 {
290     switch (joinStyle) {
291     case MiterJoin:
292         ts << "MITER";
293         break;
294     case RoundJoin:
295         ts << "ROUND";
296         break;
297     case BevelJoin:
298         ts << "BEVEL";
299         break;
300     }
301     return ts;
302 }
303
304
305 }