1 /* 2 * Copyright 2006 The Android Open Source Project 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #ifndef SkFlattenable_DEFINED 9 #define SkFlattenable_DEFINED 10 11 #include "SkRefCnt.h" 12 13 class SkReadBuffer; 14 class SkWriteBuffer; 15 16 #define SK_SUPPORT_LEGACY_DEEPFLATTENING 17 18 /* 19 * Flattening is straight-forward: 20 * 1. call getFactory() so we have a function-ptr to recreate the subclass 21 * 2. call flatten(buffer) to write out enough data for the factory to read 22 * 23 * Unflattening is easy for the caller: new_instance = factory(buffer) 24 * 25 * The complexity of supporting this is as follows. 26 * 27 * If your subclass wants to control unflattening, use this macro in your declaration: 28 * SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS 29 * This will provide a getFactory(), and require that the subclass implements CreateProc. 30 * 31 * For older buffers (before the DEEPFLATTENING change, the macros below declare 32 * a thin factory DeepCreateProc. It checks the version of the buffer, and if it is pre-deep, 33 * then it calls through to a (usually protected) constructor, passing the buffer. 34 * If the buffer is newer, then it directly calls the "real" factory: CreateProc. 35 */ 36 37 #define SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP() static void InitializeFlattenables(); 38 39 #define SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(flattenable) \ 40 void flattenable::InitializeFlattenables() { 41 42 #define SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END \ 43 } 44 45 #define SK_DECLARE_UNFLATTENABLE_OBJECT() \ 46 virtual Factory getFactory() const SK_OVERRIDE { return NULL; } 47 48 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING 49 #define SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(flattenable) \ 50 SkFlattenable::Registrar(#flattenable, flattenable::DeepCreateProc, \ 51 flattenable::GetFlattenableType()); 52 53 #define SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(flattenable) \ 54 private: \ 55 static SkFlattenable* CreateProc(SkReadBuffer&); \ 56 static SkFlattenable* DeepCreateProc(SkReadBuffer& buffer) { \ 57 if (NeedsDeepUnflatten(buffer)) { \ 58 return SkNEW_ARGS(flattenable, (buffer)); \ 59 } \ 60 return CreateProc(buffer); \ 61 } \ 62 friend class SkPrivateEffectInitializer; \ 63 public: \ 64 virtual Factory getFactory() const SK_OVERRIDE {return DeepCreateProc;} 65 #else 66 #define SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(flattenable) \ 67 SkFlattenable::Registrar(#flattenable, flattenable::CreateProc, \ 68 flattenable::GetFlattenableType()); 69 70 #define SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(flattenable) \ 71 private: \ 72 static SkFlattenable* CreateProc(SkReadBuffer&); \ 73 friend class SkPrivateEffectInitializer; \ 74 public: \ 75 virtual Factory getFactory() const SK_OVERRIDE { return CreateProc; } 76 #endif 77 78 // If your subclass will *never* need to be unflattened, declare this. 79 #define SK_DECLARE_NOT_FLATTENABLE_PROCS(flattenable) \ 80 virtual Factory getFactory() const SK_OVERRIDE { return ReturnNullCreateProc; } 81 82 /** For SkFlattenable derived objects with a valid type 83 This macro should only be used in base class objects in core 84 */ 85 #define SK_DEFINE_FLATTENABLE_TYPE(flattenable) \ 86 static Type GetFlattenableType() { \ 87 return k##flattenable##_Type; \ 88 } 89 90 /** \class SkFlattenable 91 92 SkFlattenable is the base class for objects that need to be flattened 93 into a data stream for either transport or as part of the key to the 94 font cache. 95 */ 96 class SK_API SkFlattenable : public SkRefCnt { 97 public: 98 enum Type { 99 kSkColorFilter_Type, 100 kSkDrawLooper_Type, 101 kSkImageFilter_Type, 102 kSkMaskFilter_Type, 103 kSkPathEffect_Type, 104 kSkPixelRef_Type, 105 kSkRasterizer_Type, 106 kSkShader_Type, 107 kSkUnused_Type, // used to be SkUnitMapper 108 kSkXfermode_Type, 109 }; 110 111 SK_DECLARE_INST_COUNT(SkFlattenable) 112 113 typedef SkFlattenable* (*Factory)(SkReadBuffer&); 114 SkFlattenable()115 SkFlattenable() {} 116 117 /** Implement this to return a factory function pointer that can be called 118 to recreate your class given a buffer (previously written to by your 119 override of flatten(). 120 */ 121 virtual Factory getFactory() const = 0; 122 123 /** Returns the name of the object's class 124 */ getTypeName()125 const char* getTypeName() const { return FactoryToName(getFactory()); } 126 127 static Factory NameToFactory(const char name[]); 128 static const char* FactoryToName(Factory); 129 static bool NameToType(const char name[], Type* type); 130 131 static void Register(const char name[], Factory, Type); 132 133 class Registrar { 134 public: Registrar(const char name[],Factory factory,Type type)135 Registrar(const char name[], Factory factory, Type type) { 136 SkFlattenable::Register(name, factory, type); 137 } 138 }; 139 140 /** 141 * Override this if your subclass needs to record data that it will need to recreate itself 142 * from its CreateProc (returned by getFactory()). 143 */ flatten(SkWriteBuffer &)144 virtual void flatten(SkWriteBuffer&) const {} 145 146 protected: 147 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING 148 static bool NeedsDeepUnflatten(const SkReadBuffer&); SkFlattenable(SkReadBuffer &)149 SkFlattenable(SkReadBuffer&) {} 150 #endif 151 ReturnNullCreateProc(SkReadBuffer &)152 static SkFlattenable* ReturnNullCreateProc(SkReadBuffer&) { 153 return NULL; 154 } 155 156 private: 157 static void InitializeFlattenablesIfNeeded(); 158 159 friend class SkGraphics; 160 161 typedef SkRefCnt INHERITED; 162 }; 163 164 #endif 165