00001 /* 00002 * Copyright (C) 2006 The Android Open Source Project 00003 * 00004 * Licensed under the Apache License, Version 2.0 (the "License"); 00005 * you may not use this file except in compliance with the License. 00006 * You may obtain a copy of the License at 00007 * 00008 * http://www.apache.org/licenses/LICENSE-2.0 00009 * 00010 * Unless required by applicable law or agreed to in writing, software 00011 * distributed under the License is distributed on an "AS IS" BASIS, 00012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00013 * See the License for the specific language governing permissions and 00014 * limitations under the License. 00015 */ 00016 00017 #ifndef SkFlattenable_DEFINED 00018 #define SkFlattenable_DEFINED 00019 00020 #include "SkRefCnt.h" 00021 #include "SkBitmap.h" 00022 #include "SkReader32.h" 00023 #include "SkTDArray.h" 00024 #include "SkWriter32.h" 00025 00026 class SkFlattenableReadBuffer; 00027 class SkFlattenableWriteBuffer; 00028 class SkString; 00029 00036 class SkFlattenable : public SkRefCnt { 00037 public: 00038 typedef SkFlattenable* (*Factory)(SkFlattenableReadBuffer&); 00039 00040 SkFlattenable() {} 00041 00046 virtual Factory getFactory() = 0; 00051 virtual void flatten(SkFlattenableWriteBuffer&); 00052 00056 virtual bool toDumpString(SkString*) const; 00057 00058 static Factory NameToFactory(const char name[]); 00059 static const char* FactoryToName(Factory); 00060 static void Register(const char name[], Factory); 00061 00062 class Registrar { 00063 public: 00064 Registrar(const char name[], Factory factory) { 00065 SkFlattenable::Register(name, factory); 00066 } 00067 }; 00068 00069 protected: 00070 SkFlattenable(SkFlattenableReadBuffer&) {} 00071 }; 00072 00075 00076 class SkTypeface; 00077 00078 class SkFlattenableReadBuffer : public SkReader32 { 00079 public: 00080 SkFlattenableReadBuffer(); 00081 explicit SkFlattenableReadBuffer(const void* data); 00082 SkFlattenableReadBuffer(const void* data, size_t size); 00083 00084 void setRefCntArray(SkRefCnt* array[], int count) { 00085 fRCArray = array; 00086 fRCCount = count; 00087 } 00088 00089 void setTypefaceArray(SkTypeface* array[], int count) { 00090 fTFArray = array; 00091 fTFCount = count; 00092 } 00093 00094 void setFactoryPlayback(SkFlattenable::Factory array[], int count) { 00095 fFactoryArray = array; 00096 fFactoryCount = count; 00097 } 00098 00099 SkTypeface* readTypeface(); 00100 SkRefCnt* readRefCnt(); 00101 void* readFunctionPtr(); 00102 SkFlattenable* readFlattenable(); 00103 00104 private: 00105 SkRefCnt** fRCArray; 00106 int fRCCount; 00107 00108 SkTypeface** fTFArray; 00109 int fTFCount; 00110 00111 SkFlattenable::Factory* fFactoryArray; 00112 int fFactoryCount; 00113 00114 typedef SkReader32 INHERITED; 00115 }; 00116 00118 00119 #include "SkPtrRecorder.h" 00120 00121 class SkRefCntRecorder : public SkPtrRecorder { 00122 public: 00123 virtual ~SkRefCntRecorder(); 00124 00129 uint32_t record(SkRefCnt* ref) { 00130 return this->recordPtr(ref); 00131 } 00132 00133 // This does not change the owner counts on the objects 00134 void get(SkRefCnt* array[]) const { 00135 this->getPtrs((void**)array); 00136 } 00137 00138 protected: 00139 // overrides 00140 virtual void incPtr(void*); 00141 virtual void decPtr(void*); 00142 00143 private: 00144 typedef SkPtrRecorder INHERITED; 00145 }; 00146 00147 class SkFactoryRecorder : public SkPtrRecorder { 00148 public: 00152 uint32_t record(SkFlattenable::Factory fact) { 00153 return this->recordPtr((void*)fact); 00154 } 00155 00156 void get(SkFlattenable::Factory array[]) const { 00157 this->getPtrs((void**)array); 00158 } 00159 00160 private: 00161 typedef SkPtrRecorder INHERITED; 00162 }; 00163 00164 class SkFlattenableWriteBuffer : public SkWriter32 { 00165 public: 00166 SkFlattenableWriteBuffer(size_t minSize); 00167 virtual ~SkFlattenableWriteBuffer(); 00168 00169 void writeTypeface(SkTypeface*); 00170 void writeRefCnt(SkRefCnt*); 00171 void writeFunctionPtr(void*); 00172 void writeFlattenable(SkFlattenable* flattenable); 00173 00174 SkRefCntRecorder* getTypefaceRecorder() const { return fTFRecorder; } 00175 SkRefCntRecorder* setTypefaceRecorder(SkRefCntRecorder*); 00176 00177 SkRefCntRecorder* getRefCntRecorder() const { return fRCRecorder; } 00178 SkRefCntRecorder* setRefCntRecorder(SkRefCntRecorder*); 00179 00180 SkFactoryRecorder* getFactoryRecorder() const { return fFactoryRecorder; } 00181 SkFactoryRecorder* setFactoryRecorder(SkFactoryRecorder*); 00182 00183 enum Flags { 00184 kCrossProcess_Flag = 0x01 00185 }; 00186 Flags getFlags() const { return fFlags; } 00187 void setFlags(Flags flags) { fFlags = flags; } 00188 00189 bool isCrossProcess() const { return (fFlags & kCrossProcess_Flag) != 0; } 00190 00191 bool persistBitmapPixels() const { 00192 return (fFlags & kCrossProcess_Flag) != 0; 00193 } 00194 00195 bool persistTypeface() const { return (fFlags & kCrossProcess_Flag) != 0; } 00196 00197 private: 00198 Flags fFlags; 00199 SkRefCntRecorder* fTFRecorder; 00200 SkRefCntRecorder* fRCRecorder; 00201 SkFactoryRecorder* fFactoryRecorder; 00202 00203 typedef SkWriter32 INHERITED; 00204 }; 00205 00206 #endif 00207