diff options
Diffstat (limited to 'skia/include/SkFlattenable.h')
| -rw-r--r-- | skia/include/SkFlattenable.h | 202 |
1 files changed, 202 insertions, 0 deletions
diff --git a/skia/include/SkFlattenable.h b/skia/include/SkFlattenable.h new file mode 100644 index 0000000..8b2db8a --- /dev/null +++ b/skia/include/SkFlattenable.h @@ -0,0 +1,202 @@ +/* include/graphics/SkFlattenable.h + ** + ** Copyright 2006, Google Inc. + ** + ** Licensed under the Apache License, Version 2.0 (the "License"); + ** you may not use this file except in compliance with the License. + ** You may obtain a copy of the License at + ** + ** http://www.apache.org/licenses/LICENSE-2.0 + ** + ** Unless required by applicable law or agreed to in writing, software + ** distributed under the License is distributed on an "AS IS" BASIS, + ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + ** See the License for the specific language governing permissions and + ** limitations under the License. + */ + +#ifndef SkFlattenable_DEFINED +#define SkFlattenable_DEFINED + +#include "SkRefCnt.h" +#include "SkBitmap.h" +#include "SkReader32.h" +#include "SkTDArray.h" +#include "SkWriter32.h" + +class SkFlattenableReadBuffer; +class SkFlattenableWriteBuffer; + +/** \class SkFlattenable + + SkFlattenable is the base class for objects that need to be flattened + into a data stream for either transport or as part of the key to the + font cache. + */ +class SkFlattenable : public SkRefCnt { +public: + typedef SkFlattenable* (*Factory)(SkFlattenableReadBuffer&); + + SkFlattenable() {} + + /** Implement this to return a factory function pointer that can be called + to recreate your class given a buffer (previously written to by your + override of flatten(). + */ + virtual Factory getFactory() = 0; + /** Override this to write data specific to your subclass into the buffer, + being sure to call your super-class' version first. This data will later + be passed to your Factory function, returned by getFactory(). + */ + virtual void flatten(SkFlattenableWriteBuffer&); + + static Factory NameToFactory(const char name[]); + static const char* FactoryToName(Factory); + static void Register(const char name[], Factory); + + class Registrar { + public: + Registrar(const char name[], Factory factory) { + SkFlattenable::Register(name, factory); + } + }; + +protected: + SkFlattenable(SkFlattenableReadBuffer&) {} +}; + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +class SkTypeface; + +class SkFlattenableReadBuffer : public SkReader32 { +public: + SkFlattenableReadBuffer(); + explicit SkFlattenableReadBuffer(const void* data); + SkFlattenableReadBuffer(const void* data, size_t size); + + void setRefCntArray(SkRefCnt* array[], int count) { + fRCArray = array; + fRCCount = count; + } + + void setTypefaceArray(SkTypeface* array[], int count) { + fTFArray = array; + fTFCount = count; + } + + void setFactoryPlayback(SkFlattenable::Factory array[], int count) { + fFactoryArray = array; + fFactoryCount = count; + } + + SkTypeface* readTypeface(); + SkRefCnt* readRefCnt(); + void* readFunctionPtr(); + SkFlattenable* readFlattenable(); + +private: + SkRefCnt** fRCArray; + int fRCCount; + + SkTypeface** fTFArray; + int fTFCount; + + SkFlattenable::Factory* fFactoryArray; + int fFactoryCount; + + typedef SkReader32 INHERITED; +}; + +/////////////////////////////////////////////////////////////////////////////// + +#include "SkPtrRecorder.h" + +class SkRefCntRecorder : public SkPtrRecorder { +public: + virtual ~SkRefCntRecorder(); + + /** Add a refcnt object to the set and ref it if not already present, + or if it is already present, do nothing. Either way, returns 0 if obj + is null, or a base-1 index if obj is not null. + */ + uint32_t record(SkRefCnt* ref) { + return this->recordPtr(ref); + } + + // This does not change the owner counts on the objects + void get(SkRefCnt* array[]) const { + this->getPtrs((void**)array); + } + +protected: + // overrides + virtual void incPtr(void*); + virtual void decPtr(void*); + +private: + typedef SkPtrRecorder INHERITED; +}; + +class SkFactoryRecorder : public SkPtrRecorder { +public: + /** Add a factory to the set. If it is null return 0, otherwise return a + base-1 index for the factory. + */ + uint32_t record(SkFlattenable::Factory fact) { + return this->recordPtr((void*)fact); + } + + void get(SkFlattenable::Factory array[]) const { + this->getPtrs((void**)array); + } + +private: + typedef SkPtrRecorder INHERITED; +}; + +class SkFlattenableWriteBuffer : public SkWriter32 { +public: + SkFlattenableWriteBuffer(size_t minSize); + virtual ~SkFlattenableWriteBuffer(); + + void writeTypeface(SkTypeface*); + void writeRefCnt(SkRefCnt*); + void writeFunctionPtr(void*); + void writeFlattenable(SkFlattenable* flattenable); + + SkRefCntRecorder* getTypefaceRecorder() const { return fTFRecorder; } + SkRefCntRecorder* setTypefaceRecorder(SkRefCntRecorder*); + + SkRefCntRecorder* getRefCntRecorder() const { return fRCRecorder; } + SkRefCntRecorder* setRefCntRecorder(SkRefCntRecorder*); + + SkFactoryRecorder* getFactoryRecorder() const { return fFactoryRecorder; } + SkFactoryRecorder* setFactoryRecorder(SkFactoryRecorder*); + + enum Flags { + kCrossProcess_Flag = 0x01 + }; + Flags getFlags() const { return fFlags; } + void setFlags(Flags flags) { fFlags = flags; } + + bool isCrossProcess() const { return (fFlags & kCrossProcess_Flag) != 0; } + + bool persistBitmapPixels() const { + return (fFlags & kCrossProcess_Flag) != 0; + } + + bool persistTypeface() const { return (fFlags & kCrossProcess_Flag) != 0; } + +private: + Flags fFlags; + SkRefCntRecorder* fTFRecorder; + SkRefCntRecorder* fRCRecorder; + SkFactoryRecorder* fFactoryRecorder; + + typedef SkWriter32 INHERITED; +}; + +#endif + |