1 /* libs/graphics/animator/SkDisplayType.cpp
2 **
3 ** Copyright 2006, The Android Open Source Project
4 **
5 ** Licensed under the Apache License, Version 2.0 (the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 ** http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing, software
12 ** distributed under the License is distributed on an "AS IS" BASIS,
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17
18 #include "SkDisplayType.h"
19 #include "SkAnimateMaker.h"
20 #include "SkAnimateSet.h"
21 #include "SkDisplayAdd.h"
22 #include "SkDisplayApply.h"
23 #include "SkDisplayBounds.h"
24 #include "SkDisplayEvent.h"
25 #include "SkDisplayInclude.h"
26 #ifdef SK_DEBUG
27 #include "SkDisplayList.h"
28 #endif
29 #include "SkDisplayMath.h"
30 #include "SkDisplayMovie.h"
31 #include "SkDisplayNumber.h"
32 #include "SkDisplayPost.h"
33 #include "SkDisplayRandom.h"
34 #include "SkDisplayTypes.h"
35 #include "SkDraw3D.h"
36 #include "SkDrawBitmap.h"
37 #include "SkDrawClip.h"
38 #include "SkDrawDash.h"
39 #include "SkDrawDiscrete.h"
40 #include "SkDrawEmboss.h"
41 #include "SkDrawFull.h"
42 #include "SkDrawGradient.h"
43 #include "SkDrawLine.h"
44 #include "SkDrawMatrix.h"
45 #include "SkDrawOval.h"
46 #include "SkDrawPaint.h"
47 #include "SkDrawPath.h"
48 #include "SkDrawPoint.h"
49 #include "SkDrawSaveLayer.h"
50 #include "SkDrawText.h"
51 #include "SkDrawTextBox.h"
52 #include "SkDrawTo.h"
53 #include "SkDrawTransparentShader.h"
54 #include "SkDump.h"
55 #include "SkExtras.h"
56 #include "SkHitClear.h"
57 #include "SkHitTest.h"
58 #include "SkMatrixParts.h"
59 #include "SkPathParts.h"
60 #include "SkPostParts.h"
61 #include "SkSnapshot.h"
62 #include "SkTextOnPath.h"
63 #include "SkTextToPath.h"
64 #include "SkTSearch.h"
65
66 #define CASE_NEW(_class) \
67 case SkType_##_class: result = new Sk##_class(); break
68 #define CASE_DRAW_NEW(_class) \
69 case SkType_##_class: result = new SkDraw##_class(); break
70 #define CASE_DISPLAY_NEW(_class) \
71 case SkType_##_class: result = new SkDisplay##_class(); break
72 #ifdef SK_DEBUG
73 #define CASE_DEBUG_RETURN_NIL(_class) \
74 case SkType_##_class: return NULL
75 #else
76 #define CASE_DEBUG_RETURN_NIL(_class)
77 #endif
78
79
80 SkDisplayTypes SkDisplayType::gNewTypes = kNumberOfTypes;
81
CreateInstance(SkAnimateMaker * maker,SkDisplayTypes type)82 SkDisplayable* SkDisplayType::CreateInstance(SkAnimateMaker* maker, SkDisplayTypes type) {
83 SkDisplayable* result = NULL;
84 switch (type) {
85 // unknown
86 CASE_DISPLAY_NEW(Math);
87 CASE_DISPLAY_NEW(Number);
88 CASE_NEW(Add);
89 CASE_NEW(AddCircle);
90 // addgeom
91 CASE_DEBUG_RETURN_NIL(AddMode);
92 CASE_NEW(AddOval);
93 CASE_NEW(AddPath);
94 CASE_NEW(AddRect);
95 CASE_NEW(AddRoundRect);
96 CASE_DEBUG_RETURN_NIL(Align);
97 CASE_NEW(Animate);
98 // animatebase
99 CASE_NEW(Apply);
100 CASE_DEBUG_RETURN_NIL(ApplyMode);
101 CASE_DEBUG_RETURN_NIL(ApplyTransition);
102 CASE_DISPLAY_NEW(Array);
103 // argb
104 // base64
105 // basebitmap
106 // baseclassinfo
107 CASE_DRAW_NEW(Bitmap);
108 // bitmapencoding
109 // bitmapformat
110 CASE_DRAW_NEW(BitmapShader);
111 CASE_DRAW_NEW(Blur);
112 CASE_DISPLAY_NEW(Boolean);
113 // boundable
114 CASE_DISPLAY_NEW(Bounds);
115 CASE_DEBUG_RETURN_NIL(Cap);
116 CASE_NEW(Clear);
117 CASE_DRAW_NEW(Clip);
118 CASE_NEW(Close);
119 CASE_DRAW_NEW(Color);
120 CASE_NEW(CubicTo);
121 CASE_NEW(Dash);
122 CASE_NEW(Data);
123 CASE_NEW(Discrete);
124 // displayable
125 // drawable
126 CASE_NEW(DrawTo);
127 CASE_NEW(Dump);
128 // dynamicstring
129 CASE_DRAW_NEW(Emboss);
130 CASE_DISPLAY_NEW(Event);
131 CASE_DEBUG_RETURN_NIL(EventCode);
132 CASE_DEBUG_RETURN_NIL(EventKind);
133 CASE_DEBUG_RETURN_NIL(EventMode);
134 // filltype
135 // filtertype
136 CASE_DISPLAY_NEW(Float);
137 CASE_NEW(FromPath);
138 CASE_DEBUG_RETURN_NIL(FromPathMode);
139 CASE_NEW(Full);
140 // gradient
141 CASE_NEW(Group);
142 CASE_NEW(HitClear);
143 CASE_NEW(HitTest);
144 CASE_NEW(Image);
145 CASE_NEW(Include);
146 CASE_NEW(Input);
147 CASE_DISPLAY_NEW(Int);
148 CASE_DEBUG_RETURN_NIL(Join);
149 CASE_NEW(Line);
150 CASE_NEW(LineTo);
151 CASE_NEW(LinearGradient);
152 CASE_DRAW_NEW(MaskFilter);
153 CASE_DEBUG_RETURN_NIL(MaskFilterBlurStyle);
154 // maskfilterlight
155 CASE_DRAW_NEW(Matrix);
156 // memberfunction
157 // memberproperty
158 CASE_NEW(Move);
159 CASE_NEW(MoveTo);
160 CASE_DISPLAY_NEW(Movie);
161 // msec
162 CASE_NEW(Oval);
163 CASE_DRAW_NEW(Paint);
164 CASE_DRAW_NEW(Path);
165 // pathdirection
166 CASE_DRAW_NEW(PathEffect);
167 // point
168 CASE_NEW(DrawPoint);
169 CASE_NEW(PolyToPoly);
170 CASE_NEW(Polygon);
171 CASE_NEW(Polyline);
172 CASE_NEW(Post);
173 CASE_NEW(QuadTo);
174 CASE_NEW(RCubicTo);
175 CASE_NEW(RLineTo);
176 CASE_NEW(RMoveTo);
177 CASE_NEW(RQuadTo);
178 CASE_NEW(RadialGradient);
179 CASE_DISPLAY_NEW(Random);
180 CASE_DRAW_NEW(Rect);
181 CASE_NEW(RectToRect);
182 CASE_NEW(Remove);
183 CASE_NEW(Replace);
184 CASE_NEW(Rotate);
185 CASE_NEW(RoundRect);
186 CASE_NEW(Save);
187 CASE_NEW(SaveLayer);
188 CASE_NEW(Scale);
189 // screenplay
190 CASE_NEW(Set);
191 CASE_DRAW_NEW(Shader);
192 CASE_NEW(Skew);
193 CASE_NEW(3D_Camera);
194 CASE_NEW(3D_Patch);
195 // 3dpoint
196 CASE_NEW(Snapshot);
197 CASE_DISPLAY_NEW(String);
198 // style
199 CASE_NEW(Text);
200 CASE_DRAW_NEW(TextBox);
201 // textboxalign
202 // textboxmode
203 CASE_NEW(TextOnPath);
204 CASE_NEW(TextToPath);
205 CASE_DEBUG_RETURN_NIL(TileMode);
206 CASE_NEW(Translate);
207 CASE_DRAW_NEW(TransparentShader);
208 CASE_DRAW_NEW(Typeface);
209 CASE_DEBUG_RETURN_NIL(Xfermode);
210 default:
211 SkExtras** end = maker->fExtras.end();
212 for (SkExtras** extraPtr = maker->fExtras.begin(); extraPtr < end; extraPtr++) {
213 if ((result = (*extraPtr)->createInstance(type)) != NULL)
214 return result;
215 }
216 SkASSERT(0);
217 }
218 return result;
219 }
220
221 #undef CASE_NEW
222 #undef CASE_DRAW_NEW
223 #undef CASE_DISPLAY_NEW
224
225 #if SK_USE_CONDENSED_INFO == 0
226
227 #define CASE_GET_INFO(_class) case SkType_##_class: \
228 info = Sk##_class::fInfo; infoCount = Sk##_class::fInfoCount; break
229 #define CASE_GET_DRAW_INFO(_class) case SkType_##_class: \
230 info = SkDraw##_class::fInfo; infoCount = SkDraw##_class::fInfoCount; break
231 #define CASE_GET_DISPLAY_INFO(_class) case SkType_##_class: \
232 info = SkDisplay##_class::fInfo; infoCount = SkDisplay##_class::fInfoCount; \
233 break
234
GetMembers(SkAnimateMaker * maker,SkDisplayTypes type,int * infoCountPtr)235 const SkMemberInfo* SkDisplayType::GetMembers(SkAnimateMaker* maker,
236 SkDisplayTypes type, int* infoCountPtr) {
237 const SkMemberInfo* info = NULL;
238 int infoCount = 0;
239 switch (type) {
240 // unknown
241 CASE_GET_DISPLAY_INFO(Math);
242 CASE_GET_DISPLAY_INFO(Number);
243 CASE_GET_INFO(Add);
244 CASE_GET_INFO(AddCircle);
245 CASE_GET_INFO(AddGeom);
246 // addmode
247 CASE_GET_INFO(AddOval);
248 CASE_GET_INFO(AddPath);
249 CASE_GET_INFO(AddRect);
250 CASE_GET_INFO(AddRoundRect);
251 // align
252 CASE_GET_INFO(Animate);
253 CASE_GET_INFO(AnimateBase);
254 CASE_GET_INFO(Apply);
255 // applymode
256 // applytransition
257 CASE_GET_DISPLAY_INFO(Array);
258 // argb
259 // base64
260 CASE_GET_INFO(BaseBitmap);
261 // baseclassinfo
262 CASE_GET_DRAW_INFO(Bitmap);
263 // bitmapencoding
264 // bitmapformat
265 CASE_GET_DRAW_INFO(BitmapShader);
266 CASE_GET_DRAW_INFO(Blur);
267 CASE_GET_DISPLAY_INFO(Boolean);
268 // boundable
269 CASE_GET_DISPLAY_INFO(Bounds);
270 // cap
271 // clear
272 CASE_GET_DRAW_INFO(Clip);
273 // close
274 CASE_GET_DRAW_INFO(Color);
275 CASE_GET_INFO(CubicTo);
276 CASE_GET_INFO(Dash);
277 CASE_GET_INFO(Data);
278 CASE_GET_INFO(Discrete);
279 // displayable
280 // drawable
281 CASE_GET_INFO(DrawTo);
282 CASE_GET_INFO(Dump);
283 // dynamicstring
284 CASE_GET_DRAW_INFO(Emboss);
285 CASE_GET_DISPLAY_INFO(Event);
286 // eventcode
287 // eventkind
288 // eventmode
289 // filltype
290 // filtertype
291 CASE_GET_DISPLAY_INFO(Float);
292 CASE_GET_INFO(FromPath);
293 // frompathmode
294 // full
295 CASE_GET_INFO(Gradient);
296 CASE_GET_INFO(Group);
297 CASE_GET_INFO(HitClear);
298 CASE_GET_INFO(HitTest);
299 CASE_GET_INFO(Image);
300 CASE_GET_INFO(Include);
301 CASE_GET_INFO(Input);
302 CASE_GET_DISPLAY_INFO(Int);
303 // join
304 CASE_GET_INFO(Line);
305 CASE_GET_INFO(LineTo);
306 CASE_GET_INFO(LinearGradient);
307 // maskfilter
308 // maskfilterblurstyle
309 // maskfilterlight
310 CASE_GET_DRAW_INFO(Matrix);
311 // memberfunction
312 // memberproperty
313 CASE_GET_INFO(Move);
314 CASE_GET_INFO(MoveTo);
315 CASE_GET_DISPLAY_INFO(Movie);
316 // msec
317 CASE_GET_INFO(Oval);
318 CASE_GET_DRAW_INFO(Path);
319 CASE_GET_DRAW_INFO(Paint);
320 // pathdirection
321 // patheffect
322 case SkType_Point: info = Sk_Point::fInfo; infoCount = Sk_Point::fInfoCount; break; // no virtual flavor
323 CASE_GET_INFO(DrawPoint); // virtual flavor
324 CASE_GET_INFO(PolyToPoly);
325 CASE_GET_INFO(Polygon);
326 CASE_GET_INFO(Polyline);
327 CASE_GET_INFO(Post);
328 CASE_GET_INFO(QuadTo);
329 CASE_GET_INFO(RCubicTo);
330 CASE_GET_INFO(RLineTo);
331 CASE_GET_INFO(RMoveTo);
332 CASE_GET_INFO(RQuadTo);
333 CASE_GET_INFO(RadialGradient);
334 CASE_GET_DISPLAY_INFO(Random);
335 CASE_GET_DRAW_INFO(Rect);
336 CASE_GET_INFO(RectToRect);
337 CASE_GET_INFO(Remove);
338 CASE_GET_INFO(Replace);
339 CASE_GET_INFO(Rotate);
340 CASE_GET_INFO(RoundRect);
341 CASE_GET_INFO(Save);
342 CASE_GET_INFO(SaveLayer);
343 CASE_GET_INFO(Scale);
344 // screenplay
345 CASE_GET_INFO(Set);
346 CASE_GET_DRAW_INFO(Shader);
347 CASE_GET_INFO(Skew);
348 CASE_GET_INFO(3D_Camera);
349 CASE_GET_INFO(3D_Patch);
350 CASE_GET_INFO(3D_Point);
351 CASE_GET_INFO(Snapshot);
352 CASE_GET_DISPLAY_INFO(String);
353 // style
354 CASE_GET_INFO(Text);
355 CASE_GET_DRAW_INFO(TextBox);
356 // textboxalign
357 // textboxmode
358 CASE_GET_INFO(TextOnPath);
359 CASE_GET_INFO(TextToPath);
360 // tilemode
361 CASE_GET_INFO(Translate);
362 // transparentshader
363 CASE_GET_DRAW_INFO(Typeface);
364 // xfermode
365 // knumberoftypes
366 default:
367 if (maker) {
368 SkExtras** end = maker->fExtras.end();
369 for (SkExtras** extraPtr = maker->fExtras.begin(); extraPtr < end; extraPtr++) {
370 if ((info = (*extraPtr)->getMembers(type, infoCountPtr)) != NULL)
371 return info;
372 }
373 }
374 return NULL;
375 }
376 if (infoCountPtr)
377 *infoCountPtr = infoCount;
378 return info;
379 }
380
GetMember(SkAnimateMaker * maker,SkDisplayTypes type,const char ** matchPtr)381 const SkMemberInfo* SkDisplayType::GetMember(SkAnimateMaker* maker,
382 SkDisplayTypes type, const char** matchPtr ) {
383 int infoCount;
384 const SkMemberInfo* info = GetMembers(maker, type, &infoCount);
385 info = SkMemberInfo::Find(info, infoCount, matchPtr);
386 // SkASSERT(info);
387 return info;
388 }
389
390 #undef CASE_GET_INFO
391 #undef CASE_GET_DRAW_INFO
392 #undef CASE_GET_DISPLAY_INFO
393
394 #endif // SK_USE_CONDENSED_INFO == 0
395
396 #if defined SK_DEBUG || defined SK_BUILD_CONDENSED
397 #define DRAW_NAME(_name, _type) {_name, _type, true, false }
398 #define DISPLAY_NAME(_name, _type) {_name, _type, false, true }
399 #define INIT_BOOL_FIELDS , false, false
400 #else
401 #define DRAW_NAME(_name, _type) {_name, _type }
402 #define DISPLAY_NAME(_name, _type) {_name, _type }
403 #define INIT_BOOL_FIELDS
404 #endif
405
406 const TypeNames gTypeNames[] = {
407 // unknown
408 { "Math", SkType_Math INIT_BOOL_FIELDS },
409 { "Number", SkType_Number INIT_BOOL_FIELDS },
410 { "add", SkType_Add INIT_BOOL_FIELDS },
411 { "addCircle", SkType_AddCircle INIT_BOOL_FIELDS },
412 // addgeom
413 // addmode
414 { "addOval", SkType_AddOval INIT_BOOL_FIELDS },
415 { "addPath", SkType_AddPath INIT_BOOL_FIELDS },
416 { "addRect", SkType_AddRect INIT_BOOL_FIELDS },
417 { "addRoundRect", SkType_AddRoundRect INIT_BOOL_FIELDS },
418 // align
419 { "animate", SkType_Animate INIT_BOOL_FIELDS },
420 // animateBase
421 { "apply", SkType_Apply INIT_BOOL_FIELDS },
422 // applymode
423 // applytransition
424 { "array", SkType_Array INIT_BOOL_FIELDS },
425 // argb
426 // base64
427 // basebitmap
428 // baseclassinfo
429 DRAW_NAME("bitmap", SkType_Bitmap),
430 // bitmapencoding
431 // bitmapformat
432 DRAW_NAME("bitmapShader", SkType_BitmapShader),
433 DRAW_NAME("blur", SkType_Blur),
434 { "boolean", SkType_Boolean INIT_BOOL_FIELDS },
435 // boundable
436 DISPLAY_NAME("bounds", SkType_Bounds),
437 // cap
438 { "clear", SkType_Clear INIT_BOOL_FIELDS },
439 DRAW_NAME("clip", SkType_Clip),
440 { "close", SkType_Close INIT_BOOL_FIELDS },
441 DRAW_NAME("color", SkType_Color),
442 { "cubicTo", SkType_CubicTo INIT_BOOL_FIELDS },
443 { "dash", SkType_Dash INIT_BOOL_FIELDS },
444 { "data", SkType_Data INIT_BOOL_FIELDS },
445 { "discrete", SkType_Discrete INIT_BOOL_FIELDS },
446 // displayable
447 // drawable
448 { "drawTo", SkType_DrawTo INIT_BOOL_FIELDS },
449 { "dump", SkType_Dump INIT_BOOL_FIELDS },
450 // dynamicstring
451 DRAW_NAME("emboss", SkType_Emboss),
452 DISPLAY_NAME("event", SkType_Event),
453 // eventcode
454 // eventkind
455 // eventmode
456 // filltype
457 // filtertype
458 { "float", SkType_Float INIT_BOOL_FIELDS },
459 { "fromPath", SkType_FromPath INIT_BOOL_FIELDS },
460 // frompathmode
461 { "full", SkType_Full INIT_BOOL_FIELDS },
462 // gradient
463 { "group", SkType_Group INIT_BOOL_FIELDS },
464 { "hitClear", SkType_HitClear INIT_BOOL_FIELDS },
465 { "hitTest", SkType_HitTest INIT_BOOL_FIELDS },
466 { "image", SkType_Image INIT_BOOL_FIELDS },
467 { "include", SkType_Include INIT_BOOL_FIELDS },
468 { "input", SkType_Input INIT_BOOL_FIELDS },
469 { "int", SkType_Int INIT_BOOL_FIELDS },
470 // join
471 { "line", SkType_Line INIT_BOOL_FIELDS },
472 { "lineTo", SkType_LineTo INIT_BOOL_FIELDS },
473 { "linearGradient", SkType_LinearGradient INIT_BOOL_FIELDS },
474 { "maskFilter", SkType_MaskFilter INIT_BOOL_FIELDS },
475 // maskfilterblurstyle
476 // maskfilterlight
477 DRAW_NAME("matrix", SkType_Matrix),
478 // memberfunction
479 // memberproperty
480 { "move", SkType_Move INIT_BOOL_FIELDS },
481 { "moveTo", SkType_MoveTo INIT_BOOL_FIELDS },
482 { "movie", SkType_Movie INIT_BOOL_FIELDS },
483 // msec
484 { "oval", SkType_Oval INIT_BOOL_FIELDS },
485 DRAW_NAME("paint", SkType_Paint),
486 DRAW_NAME("path", SkType_Path),
487 // pathdirection
488 { "pathEffect", SkType_PathEffect INIT_BOOL_FIELDS },
489 // point
490 DRAW_NAME("point", SkType_DrawPoint),
491 { "polyToPoly", SkType_PolyToPoly INIT_BOOL_FIELDS },
492 { "polygon", SkType_Polygon INIT_BOOL_FIELDS },
493 { "polyline", SkType_Polyline INIT_BOOL_FIELDS },
494 { "post", SkType_Post INIT_BOOL_FIELDS },
495 { "quadTo", SkType_QuadTo INIT_BOOL_FIELDS },
496 { "rCubicTo", SkType_RCubicTo INIT_BOOL_FIELDS },
497 { "rLineTo", SkType_RLineTo INIT_BOOL_FIELDS },
498 { "rMoveTo", SkType_RMoveTo INIT_BOOL_FIELDS },
499 { "rQuadTo", SkType_RQuadTo INIT_BOOL_FIELDS },
500 { "radialGradient", SkType_RadialGradient INIT_BOOL_FIELDS },
501 DISPLAY_NAME("random", SkType_Random),
502 { "rect", SkType_Rect INIT_BOOL_FIELDS },
503 { "rectToRect", SkType_RectToRect INIT_BOOL_FIELDS },
504 { "remove", SkType_Remove INIT_BOOL_FIELDS },
505 { "replace", SkType_Replace INIT_BOOL_FIELDS },
506 { "rotate", SkType_Rotate INIT_BOOL_FIELDS },
507 { "roundRect", SkType_RoundRect INIT_BOOL_FIELDS },
508 { "save", SkType_Save INIT_BOOL_FIELDS },
509 { "saveLayer", SkType_SaveLayer INIT_BOOL_FIELDS },
510 { "scale", SkType_Scale INIT_BOOL_FIELDS },
511 // screenplay
512 { "set", SkType_Set INIT_BOOL_FIELDS },
513 { "shader", SkType_Shader INIT_BOOL_FIELDS },
514 { "skew", SkType_Skew INIT_BOOL_FIELDS },
515 { "skia3d:camera", SkType_3D_Camera INIT_BOOL_FIELDS },
516 { "skia3d:patch", SkType_3D_Patch INIT_BOOL_FIELDS },
517 // point
518 { "snapshot", SkType_Snapshot INIT_BOOL_FIELDS },
519 { "string", SkType_String INIT_BOOL_FIELDS },
520 // style
521 { "text", SkType_Text INIT_BOOL_FIELDS },
522 { "textBox", SkType_TextBox INIT_BOOL_FIELDS },
523 // textboxalign
524 // textboxmode
525 { "textOnPath", SkType_TextOnPath INIT_BOOL_FIELDS },
526 { "textToPath", SkType_TextToPath INIT_BOOL_FIELDS },
527 // tilemode
528 { "translate", SkType_Translate INIT_BOOL_FIELDS },
529 DRAW_NAME("transparentShader", SkType_TransparentShader),
530 { "typeface", SkType_Typeface INIT_BOOL_FIELDS }
531 // xfermode
532 // knumberoftypes
533 };
534
535 const int kTypeNamesSize = SK_ARRAY_COUNT(gTypeNames);
536
Find(SkAnimateMaker * maker,const SkMemberInfo * match)537 SkDisplayTypes SkDisplayType::Find(SkAnimateMaker* maker, const SkMemberInfo* match) {
538 for (int index = 0; index < kTypeNamesSize; index++) {
539 SkDisplayTypes type = gTypeNames[index].fType;
540 const SkMemberInfo* info = SkDisplayType::GetMembers(maker, type, NULL);
541 if (info == match)
542 return type;
543 }
544 return (SkDisplayTypes) -1;
545 }
546
547 // !!! optimize this by replacing function with a byte-sized lookup table
GetParent(SkAnimateMaker * maker,SkDisplayTypes base)548 SkDisplayTypes SkDisplayType::GetParent(SkAnimateMaker* maker, SkDisplayTypes base) {
549 if (base == SkType_Group || base == SkType_Save || base == SkType_SaveLayer) //!!! cheat a little until we have a lookup table
550 return SkType_Displayable;
551 if (base == SkType_Set)
552 return SkType_Animate; // another cheat until we have a lookup table
553 const SkMemberInfo* info = GetMembers(maker, base, NULL); // get info for this type
554 SkASSERT(info);
555 if (info->fType != SkType_BaseClassInfo)
556 return SkType_Unknown; // if no base, done
557 // !!! could change SK_MEMBER_INHERITED macro to take type, stuff in offset, so that
558 // this (and table builder) could know type without the following steps:
559 const SkMemberInfo* inherited = info->getInherited();
560 SkDisplayTypes result = (SkDisplayTypes) (SkType_Unknown + 1);
561 for (; result <= SkType_Xfermode; result = (SkDisplayTypes) (result + 1)) {
562 const SkMemberInfo* match = GetMembers(maker, result, NULL);
563 if (match == inherited)
564 break;
565 }
566 SkASSERT(result <= SkType_Xfermode);
567 return result;
568 }
569
GetType(SkAnimateMaker * maker,const char match[],size_t len)570 SkDisplayTypes SkDisplayType::GetType(SkAnimateMaker* maker, const char match[], size_t len ) {
571 int index = SkStrSearch(&gTypeNames[0].fName, kTypeNamesSize, match,
572 len, sizeof(gTypeNames[0]));
573 if (index >= 0 && index < kTypeNamesSize)
574 return gTypeNames[index].fType;
575 SkExtras** end = maker->fExtras.end();
576 for (SkExtras** extraPtr = maker->fExtras.begin(); extraPtr < end; extraPtr++) {
577 SkDisplayTypes result = (*extraPtr)->getType(match, len);
578 if (result != SkType_Unknown)
579 return result;
580 }
581 return (SkDisplayTypes) -1;
582 }
583
IsEnum(SkAnimateMaker *,SkDisplayTypes type)584 bool SkDisplayType::IsEnum(SkAnimateMaker* , SkDisplayTypes type) {
585 switch (type) {
586 case SkType_AddMode:
587 case SkType_Align:
588 case SkType_ApplyMode:
589 case SkType_ApplyTransition:
590 case SkType_BitmapEncoding:
591 case SkType_BitmapFormat:
592 case SkType_Boolean:
593 case SkType_Cap:
594 case SkType_EventCode:
595 case SkType_EventKind:
596 case SkType_EventMode:
597 case SkType_FillType:
598 case SkType_FilterType:
599 case SkType_FontStyle:
600 case SkType_FromPathMode:
601 case SkType_Join:
602 case SkType_MaskFilterBlurStyle:
603 case SkType_PathDirection:
604 case SkType_Style:
605 case SkType_TextBoxAlign:
606 case SkType_TextBoxMode:
607 case SkType_TileMode:
608 case SkType_Xfermode:
609 return true;
610 default: // to avoid warnings
611 break;
612 }
613 return false;
614 }
615
IsDisplayable(SkAnimateMaker *,SkDisplayTypes type)616 bool SkDisplayType::IsDisplayable(SkAnimateMaker* , SkDisplayTypes type) {
617 switch (type) {
618 case SkType_Add:
619 case SkType_AddCircle:
620 case SkType_AddOval:
621 case SkType_AddPath:
622 case SkType_AddRect:
623 case SkType_AddRoundRect:
624 case SkType_Animate:
625 case SkType_AnimateBase:
626 case SkType_Apply:
627 case SkType_BaseBitmap:
628 case SkType_Bitmap:
629 case SkType_BitmapShader:
630 case SkType_Blur:
631 case SkType_Clear:
632 case SkType_Clip:
633 case SkType_Close:
634 case SkType_Color:
635 case SkType_CubicTo:
636 case SkType_Dash:
637 case SkType_Data:
638 case SkType_Discrete:
639 case SkType_Displayable:
640 case SkType_Drawable:
641 case SkType_DrawTo:
642 case SkType_Emboss:
643 case SkType_Event:
644 case SkType_FromPath:
645 case SkType_Full:
646 case SkType_Group:
647 case SkType_Image:
648 case SkType_Input:
649 case SkType_Line:
650 case SkType_LineTo:
651 case SkType_LinearGradient:
652 case SkType_Matrix:
653 case SkType_Move:
654 case SkType_MoveTo:
655 case SkType_Movie:
656 case SkType_Oval:
657 case SkType_Paint:
658 case SkType_Path:
659 case SkType_PolyToPoly:
660 case SkType_Polygon:
661 case SkType_Polyline:
662 case SkType_Post:
663 case SkType_QuadTo:
664 case SkType_RCubicTo:
665 case SkType_RLineTo:
666 case SkType_RMoveTo:
667 case SkType_RQuadTo:
668 case SkType_RadialGradient:
669 case SkType_Random:
670 case SkType_Rect:
671 case SkType_RectToRect:
672 case SkType_Remove:
673 case SkType_Replace:
674 case SkType_Rotate:
675 case SkType_RoundRect:
676 case SkType_Save:
677 case SkType_SaveLayer:
678 case SkType_Scale:
679 case SkType_Set:
680 case SkType_Shader:
681 case SkType_Skew:
682 case SkType_3D_Camera:
683 case SkType_3D_Patch:
684 case SkType_Snapshot:
685 case SkType_Text:
686 case SkType_TextBox:
687 case SkType_TextOnPath:
688 case SkType_TextToPath:
689 case SkType_Translate:
690 case SkType_TransparentShader:
691 return true;
692 default: // to avoid warnings
693 break;
694 }
695 return false;
696 }
697
IsStruct(SkAnimateMaker *,SkDisplayTypes type)698 bool SkDisplayType::IsStruct(SkAnimateMaker* , SkDisplayTypes type) {
699 switch (type) {
700 case SkType_Point:
701 case SkType_3D_Point:
702 return true;
703 default: // to avoid warnings
704 break;
705 }
706 return false;
707 }
708
709
RegisterNewType()710 SkDisplayTypes SkDisplayType::RegisterNewType() {
711 gNewTypes = (SkDisplayTypes) (gNewTypes + 1);
712 return gNewTypes;
713 }
714
715
716
717 #ifdef SK_DEBUG
GetName(SkAnimateMaker * maker,SkDisplayTypes type)718 const char* SkDisplayType::GetName(SkAnimateMaker* maker, SkDisplayTypes type) {
719 for (int index = 0; index < kTypeNamesSize - 1; index++) {
720 if (gTypeNames[index].fType == type)
721 return gTypeNames[index].fName;
722 }
723 SkExtras** end = maker->fExtras.end();
724 for (SkExtras** extraPtr = maker->fExtras.begin(); extraPtr < end; extraPtr++) {
725 const char* result = (*extraPtr)->getName(type);
726 if (result != NULL)
727 return result;
728 }
729 return NULL;
730 }
731 #endif
732
733 #ifdef SK_SUPPORT_UNITTEST
UnitTest()734 void SkDisplayType::UnitTest() {
735 SkAnimator animator;
736 SkAnimateMaker* maker = animator.fMaker;
737 int index;
738 for (index = 0; index < kTypeNamesSize - 1; index++) {
739 SkASSERT(strcmp(gTypeNames[index].fName, gTypeNames[index + 1].fName) < 0);
740 SkASSERT(gTypeNames[index].fType < gTypeNames[index + 1].fType);
741 }
742 for (index = 0; index < kTypeNamesSize; index++) {
743 SkDisplayable* test = CreateInstance(maker, gTypeNames[index].fType);
744 if (test == NULL)
745 continue;
746 #if defined _WIN32 && _MSC_VER >= 1300 && defined _INC_CRTDBG // only on windows, only if using "crtdbg.h"
747 // we know that crtdbg puts 0xfdfdfdfd at the end of the block
748 // look for unitialized memory, signature 0xcdcdcdcd prior to that
749 int* start = (int*) test;
750 while (*start != 0xfdfdfdfd) {
751 SkASSERT(*start != 0xcdcdcdcd);
752 start++;
753 }
754 #endif
755 delete test;
756 }
757 for (index = 0; index < kTypeNamesSize; index++) {
758 int infoCount;
759 const SkMemberInfo* info = GetMembers(maker, gTypeNames[index].fType, &infoCount);
760 if (info == NULL)
761 continue;
762 #if SK_USE_CONDENSED_INFO == 0
763 for (int inner = 0; inner < infoCount - 1; inner++) {
764 if (info[inner].fType == SkType_BaseClassInfo)
765 continue;
766 SkASSERT(strcmp(info[inner].fName, info[inner + 1].fName) < 0);
767 }
768 #endif
769 }
770 #if defined SK_DEBUG || defined SK_BUILD_CONDENSED
771 BuildCondensedInfo(maker);
772 #endif
773 }
774 #endif
775