1#ifndef SkPictureFlat_DEFINED
2#define SkPictureFlat_DEFINED
3
4#include "SkChunkAlloc.h"
5#include "SkBitmap.h"
6#include "SkPicture.h"
7#include "SkMatrix.h"
8#include "SkPaint.h"
9#include "SkPath.h"
10#include "SkRegion.h"
11
12enum DrawType {
13    UNUSED,
14    CLIP_PATH,
15    CLIP_REGION,
16    CLIP_RECT,
17    CONCAT,
18    DRAW_BITMAP,
19    DRAW_BITMAP_MATRIX,
20    DRAW_BITMAP_RECT,
21    DRAW_CLEAR,
22    DRAW_DATA,
23    DRAW_PAINT,
24    DRAW_PATH,
25    DRAW_PICTURE,
26    DRAW_POINTS,
27    DRAW_POS_TEXT,
28    DRAW_POS_TEXT_TOP_BOTTOM, // fast variant of DRAW_POS_TEXT
29    DRAW_POS_TEXT_H,
30    DRAW_POS_TEXT_H_TOP_BOTTOM, // fast variant of DRAW_POS_TEXT_H
31    DRAW_RECT,
32    DRAW_SHAPE,
33    DRAW_SPRITE,
34    DRAW_TEXT,
35    DRAW_TEXT_ON_PATH,
36    DRAW_TEXT_TOP_BOTTOM,   // fast variant of DRAW_TEXT
37    DRAW_VERTICES,
38    RESTORE,
39    ROTATE,
40    SAVE,
41    SAVE_LAYER,
42    SCALE,
43    SET_MATRIX,
44    SKEW,
45    TRANSLATE
46};
47
48enum DrawVertexFlags {
49    DRAW_VERTICES_HAS_TEXS    = 0x01,
50    DRAW_VERTICES_HAS_COLORS  = 0x02,
51    DRAW_VERTICES_HAS_INDICES = 0x04
52};
53
54class SkRefCntPlayback {
55public:
56    SkRefCntPlayback();
57    virtual ~SkRefCntPlayback();
58
59    int count() const { return fCount; }
60
61    void reset(const SkRefCntSet*);
62
63    void setCount(int count);
64    SkRefCnt* set(int index, SkRefCnt*);
65
66    virtual void setupBuffer(SkFlattenableReadBuffer& buffer) const {
67        buffer.setRefCntArray(fArray, fCount);
68    }
69
70protected:
71    int fCount;
72    SkRefCnt** fArray;
73};
74
75class SkTypefacePlayback : public SkRefCntPlayback {
76public:
77    virtual void setupBuffer(SkFlattenableReadBuffer& buffer) const {
78        buffer.setTypefaceArray((SkTypeface**)fArray, fCount);
79    }
80};
81
82class SkFactoryPlayback {
83public:
84    SkFactoryPlayback(int count) : fCount(count) {
85        fArray = SkNEW_ARRAY(SkFlattenable::Factory, count);
86    }
87
88    ~SkFactoryPlayback() {
89        SkDELETE_ARRAY(fArray);
90    }
91
92    SkFlattenable::Factory* base() const { return fArray; }
93
94    void setupBuffer(SkFlattenableReadBuffer& buffer) const {
95        buffer.setFactoryPlayback(fArray, fCount);
96    }
97
98private:
99    int fCount;
100    SkFlattenable::Factory* fArray;
101};
102
103class SkFlatData {
104public:
105    static int Compare(const SkFlatData* a, const SkFlatData* b) {
106        return memcmp(&a->fAllocSize, &b->fAllocSize, a->fAllocSize);
107    }
108
109    int index() const { return fIndex; }
110
111#ifdef SK_DEBUG_SIZE
112    size_t size() const { return sizeof(fIndex) + fAllocSize; }
113#endif
114
115protected:
116    static SkFlatData* Alloc(SkChunkAlloc* heap, int32_t size, int index);
117
118    int fIndex;
119    int32_t fAllocSize;
120};
121
122class SkFlatBitmap : public SkFlatData {
123public:
124    static SkFlatBitmap* Flatten(SkChunkAlloc*, const SkBitmap&, int index,
125                                 SkRefCntSet*);
126
127    void unflatten(SkBitmap* bitmap, SkRefCntPlayback* rcp) const {
128        SkFlattenableReadBuffer buffer(fBitmapData);
129        if (rcp) {
130            rcp->setupBuffer(buffer);
131        }
132        bitmap->unflatten(buffer);
133    }
134
135#ifdef SK_DEBUG_VALIDATE
136    void validate() const {
137        // to be written
138    }
139#endif
140
141private:
142    char fBitmapData[1];
143    typedef SkFlatData INHERITED;
144};
145
146class SkFlatMatrix : public SkFlatData {
147public:
148    static SkFlatMatrix* Flatten(SkChunkAlloc* heap, const SkMatrix& matrix, int index);
149
150    void unflatten(SkMatrix* result) const {
151        result->unflatten(fMatrixData);
152    }
153
154#ifdef SK_DEBUG_DUMP
155    void dump() const;
156#endif
157
158#ifdef SK_DEBUG_VALIDATE
159    void validate() const {
160        // to be written
161    }
162#endif
163
164private:
165    char fMatrixData[1];
166    typedef SkFlatData INHERITED;
167};
168
169class SkFlatPaint : public SkFlatData {
170public:
171    static SkFlatPaint* Flatten(SkChunkAlloc* heap, const SkPaint& paint,
172                                int index, SkRefCntSet*,
173                                SkRefCntSet* faceRecorder);
174
175    void unflatten(SkPaint* result, SkRefCntPlayback* rcp,
176                   SkTypefacePlayback* facePlayback) const {
177        Read(fPaintData, result, rcp, facePlayback);
178    }
179
180    static void Read(const void* storage, SkPaint* paint, SkRefCntPlayback*,
181                     SkTypefacePlayback* facePlayback);
182
183#ifdef SK_DEBUG_DUMP
184    void dump() const;
185#endif
186
187private:
188    char fPaintData[1];
189    typedef SkFlatData INHERITED;
190};
191
192class SkFlatRegion : public SkFlatData {
193public:
194    static SkFlatRegion* Flatten(SkChunkAlloc* heap, const SkRegion& region, int index);
195
196    void unflatten(SkRegion* result) const {
197        result->unflatten(fRegionData);
198    }
199
200#ifdef SK_DEBUG_VALIDATE
201    void validate() const {
202        // to be written
203    }
204#endif
205
206private:
207    char fRegionData[1];
208    typedef SkFlatData INHERITED;
209};
210
211#endif
212