Home | History | Annotate | Download | only in core 
      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 
     12 enum 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 
     48 enum DrawVertexFlags {
     49     DRAW_VERTICES_HAS_TEXS    = 0x01,
     50     DRAW_VERTICES_HAS_COLORS  = 0x02,
     51     DRAW_VERTICES_HAS_INDICES = 0x04
     52 };
     53 
     54 class SkRefCntPlayback {
     55 public:
     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 
     70 protected:
     71     int fCount;
     72     SkRefCnt** fArray;
     73 };
     74 
     75 class SkTypefacePlayback : public SkRefCntPlayback {
     76 public:
     77     virtual void setupBuffer(SkFlattenableReadBuffer& buffer) const {
     78         buffer.setTypefaceArray((SkTypeface**)fArray, fCount);
     79     }
     80 };
     81 
     82 class SkFactoryPlayback {
     83 public:
     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 
     98 private:
     99     int fCount;
    100     SkFlattenable::Factory* fArray;
    101 };
    102 
    103 class SkFlatData {
    104 public:
    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 
    115 protected:
    116     static SkFlatData* Alloc(SkChunkAlloc* heap, int32_t size, int index);
    117 
    118     int fIndex;
    119     int32_t fAllocSize;
    120 };
    121 
    122 class SkFlatBitmap : public SkFlatData {
    123 public:
    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 
    141 private:
    142     char fBitmapData[1];
    143     typedef SkFlatData INHERITED;
    144 };
    145 
    146 class SkFlatMatrix : public SkFlatData {
    147 public:
    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 
    164 private:
    165     char fMatrixData[1];
    166     typedef SkFlatData INHERITED;
    167 };
    168 
    169 class SkFlatPaint : public SkFlatData {
    170 public:
    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 
    187 private:
    188     char fPaintData[1];
    189     typedef SkFlatData INHERITED;
    190 };
    191 
    192 class SkFlatRegion : public SkFlatData {
    193 public:
    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 
    206 private:
    207     char fRegionData[1];
    208     typedef SkFlatData INHERITED;
    209 };
    210 
    211 #endif
    212