OLD | NEW |
1 | 1 |
2 /* | 2 /* |
3 * Copyright 2006 The Android Open Source Project | 3 * Copyright 2006 The Android Open Source Project |
4 * | 4 * |
5 * Use of this source code is governed by a BSD-style license that can be | 5 * Use of this source code is governed by a BSD-style license that can be |
6 * found in the LICENSE file. | 6 * found in the LICENSE file. |
7 */ | 7 */ |
8 | 8 |
9 | 9 |
10 #include "SkLayerRasterizer.h" | 10 #include "SkLayerRasterizer.h" |
11 #include "SkDraw.h" | 11 #include "SkDraw.h" |
12 #include "SkReadBuffer.h" | 12 #include "SkReadBuffer.h" |
13 #include "SkWriteBuffer.h" | 13 #include "SkWriteBuffer.h" |
14 #include "SkMask.h" | 14 #include "SkMask.h" |
15 #include "SkMaskFilter.h" | 15 #include "SkMaskFilter.h" |
16 #include "SkPaint.h" | 16 #include "SkPaint.h" |
17 #include "SkPath.h" | 17 #include "SkPath.h" |
18 #include "SkPathEffect.h" | 18 #include "SkPathEffect.h" |
19 #include "../core/SkRasterClip.h" | 19 #include "../core/SkRasterClip.h" |
20 #include "SkXfermode.h" | 20 #include "SkXfermode.h" |
21 #include <new> | 21 #include <new> |
22 | 22 |
23 struct SkLayerRasterizer_Rec { | 23 struct SkLayerRasterizer_Rec { |
24 SkPaint fPaint; | 24 SkPaint fPaint; |
25 SkVector fOffset; | 25 SkVector fOffset; |
26 }; | 26 }; |
27 | 27 |
28 SkLayerRasterizer::SkLayerRasterizer() | 28 SkLayerRasterizer::SkLayerRasterizer() : fLayers(new SkDeque(sizeof(SkLayerRaste
rizer_Rec))) {} |
29 : fLayers(SkNEW_ARGS(SkDeque, (sizeof(SkLayerRasterizer_Rec)))) | |
30 { | |
31 } | |
32 | 29 |
33 SkLayerRasterizer::SkLayerRasterizer(SkDeque* layers) : fLayers(layers) | 30 SkLayerRasterizer::SkLayerRasterizer(SkDeque* layers) : fLayers(layers) |
34 { | 31 { |
35 } | 32 } |
36 | 33 |
37 // Helper function to call destructors on SkPaints held by layers and delete lay
ers. | 34 // Helper function to call destructors on SkPaints held by layers and delete lay
ers. |
38 static void clean_up_layers(SkDeque* layers) { | 35 static void clean_up_layers(SkDeque* layers) { |
39 SkDeque::F2BIter iter(*layers); | 36 SkDeque::F2BIter iter(*layers); |
40 SkLayerRasterizer_Rec* rec; | 37 SkLayerRasterizer_Rec* rec; |
41 | 38 |
42 while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) | 39 while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) |
43 rec->fPaint.~SkPaint(); | 40 rec->fPaint.~SkPaint(); |
44 | 41 |
45 SkDELETE(layers); | 42 delete layers; |
46 } | 43 } |
47 | 44 |
48 SkLayerRasterizer::~SkLayerRasterizer() { | 45 SkLayerRasterizer::~SkLayerRasterizer() { |
49 SkASSERT(fLayers); | 46 SkASSERT(fLayers); |
50 clean_up_layers(const_cast<SkDeque*>(fLayers)); | 47 clean_up_layers(const_cast<SkDeque*>(fLayers)); |
51 } | 48 } |
52 | 49 |
53 static bool compute_bounds(const SkDeque& layers, const SkPath& path, | 50 static bool compute_bounds(const SkDeque& layers, const SkPath& path, |
54 const SkMatrix& matrix, | 51 const SkMatrix& matrix, |
55 const SkIRect* clipBounds, SkIRect* bounds) { | 52 const SkIRect* clipBounds, SkIRect* bounds) { |
(...skipping 86 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
142 while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) { | 139 while ((rec = (SkLayerRasterizer_Rec*)iter.next()) != NULL) { |
143 drawMatrix = translatedMatrix; | 140 drawMatrix = translatedMatrix; |
144 drawMatrix.preTranslate(rec->fOffset.fX, rec->fOffset.fY); | 141 drawMatrix.preTranslate(rec->fOffset.fX, rec->fOffset.fY); |
145 draw.drawPath(path, rec->fPaint); | 142 draw.drawPath(path, rec->fPaint); |
146 } | 143 } |
147 } | 144 } |
148 return true; | 145 return true; |
149 } | 146 } |
150 | 147 |
151 SkFlattenable* SkLayerRasterizer::CreateProc(SkReadBuffer& buffer) { | 148 SkFlattenable* SkLayerRasterizer::CreateProc(SkReadBuffer& buffer) { |
152 return SkNEW_ARGS(SkLayerRasterizer, (ReadLayers(buffer))); | 149 return new SkLayerRasterizer(ReadLayers(buffer)); |
153 } | 150 } |
154 | 151 |
155 SkDeque* SkLayerRasterizer::ReadLayers(SkReadBuffer& buffer) { | 152 SkDeque* SkLayerRasterizer::ReadLayers(SkReadBuffer& buffer) { |
156 int count = buffer.readInt(); | 153 int count = buffer.readInt(); |
157 | 154 |
158 SkDeque* layers = SkNEW_ARGS(SkDeque, (sizeof(SkLayerRasterizer_Rec))); | 155 SkDeque* layers = new SkDeque(sizeof(SkLayerRasterizer_Rec)); |
159 for (int i = 0; i < count; i++) { | 156 for (int i = 0; i < count; i++) { |
160 SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)layers->push_back()
; | 157 SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)layers->push_back()
; |
161 | 158 |
162 SkNEW_PLACEMENT(&rec->fPaint, SkPaint); | 159 new (&rec->fPaint) SkPaint; |
163 buffer.readPaint(&rec->fPaint); | 160 buffer.readPaint(&rec->fPaint); |
164 buffer.readPoint(&rec->fOffset); | 161 buffer.readPoint(&rec->fOffset); |
165 } | 162 } |
166 return layers; | 163 return layers; |
167 } | 164 } |
168 | 165 |
169 void SkLayerRasterizer::flatten(SkWriteBuffer& buffer) const { | 166 void SkLayerRasterizer::flatten(SkWriteBuffer& buffer) const { |
170 this->INHERITED::flatten(buffer); | 167 this->INHERITED::flatten(buffer); |
171 | 168 |
172 SkASSERT(fLayers); | 169 SkASSERT(fLayers); |
173 buffer.writeInt(fLayers->count()); | 170 buffer.writeInt(fLayers->count()); |
174 | 171 |
175 SkDeque::F2BIter iter(*fLayers); | 172 SkDeque::F2BIter iter(*fLayers); |
176 const SkLayerRasterizer_Rec* rec; | 173 const SkLayerRasterizer_Rec* rec; |
177 | 174 |
178 while ((rec = (const SkLayerRasterizer_Rec*)iter.next()) != NULL) { | 175 while ((rec = (const SkLayerRasterizer_Rec*)iter.next()) != NULL) { |
179 buffer.writePaint(rec->fPaint); | 176 buffer.writePaint(rec->fPaint); |
180 buffer.writePoint(rec->fOffset); | 177 buffer.writePoint(rec->fOffset); |
181 } | 178 } |
182 } | 179 } |
183 | 180 |
184 SkLayerRasterizer::Builder::Builder() | 181 SkLayerRasterizer::Builder::Builder() : fLayers(new SkDeque(sizeof(SkLayerRaster
izer_Rec))) {} |
185 : fLayers(SkNEW_ARGS(SkDeque, (sizeof(SkLayerRasterizer_Rec)))) | |
186 { | |
187 } | |
188 | 182 |
189 SkLayerRasterizer::Builder::~Builder() | 183 SkLayerRasterizer::Builder::~Builder() |
190 { | 184 { |
191 if (fLayers != NULL) { | 185 if (fLayers != NULL) { |
192 clean_up_layers(fLayers); | 186 clean_up_layers(fLayers); |
193 } | 187 } |
194 } | 188 } |
195 | 189 |
196 void SkLayerRasterizer::Builder::addLayer(const SkPaint& paint, SkScalar dx, | 190 void SkLayerRasterizer::Builder::addLayer(const SkPaint& paint, SkScalar dx, |
197 SkScalar dy) { | 191 SkScalar dy) { |
198 SkASSERT(fLayers); | 192 SkASSERT(fLayers); |
199 SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers->push_back(); | 193 SkLayerRasterizer_Rec* rec = (SkLayerRasterizer_Rec*)fLayers->push_back(); |
200 | 194 |
201 SkNEW_PLACEMENT_ARGS(&rec->fPaint, SkPaint, (paint)); | 195 new (&rec->fPaint) SkPaint(paint); |
202 rec->fOffset.set(dx, dy); | 196 rec->fOffset.set(dx, dy); |
203 } | 197 } |
204 | 198 |
205 SkLayerRasterizer* SkLayerRasterizer::Builder::detachRasterizer() { | 199 SkLayerRasterizer* SkLayerRasterizer::Builder::detachRasterizer() { |
206 SkLayerRasterizer* rasterizer; | 200 SkLayerRasterizer* rasterizer; |
207 if (0 == fLayers->count()) { | 201 if (0 == fLayers->count()) { |
208 rasterizer = NULL; | 202 rasterizer = NULL; |
209 SkDELETE(fLayers); | 203 delete fLayers; |
210 } else { | 204 } else { |
211 rasterizer = SkNEW_ARGS(SkLayerRasterizer, (fLayers)); | 205 rasterizer = new SkLayerRasterizer(fLayers); |
212 } | 206 } |
213 fLayers = NULL; | 207 fLayers = NULL; |
214 return rasterizer; | 208 return rasterizer; |
215 } | 209 } |
216 | 210 |
217 SkLayerRasterizer* SkLayerRasterizer::Builder::snapshotRasterizer() const { | 211 SkLayerRasterizer* SkLayerRasterizer::Builder::snapshotRasterizer() const { |
218 if (0 == fLayers->count()) { | 212 if (0 == fLayers->count()) { |
219 return NULL; | 213 return NULL; |
220 } | 214 } |
221 SkDeque* layers = SkNEW_ARGS(SkDeque, (sizeof(SkLayerRasterizer_Rec), fLayer
s->count())); | 215 SkDeque* layers = new SkDeque(sizeof(SkLayerRasterizer_Rec), fLayers->count(
)); |
222 SkDeque::F2BIter iter(*fLayers); | 216 SkDeque::F2BIter iter(*fLayers); |
223 const SkLayerRasterizer_Rec* recOrig; | 217 const SkLayerRasterizer_Rec* recOrig; |
224 SkDEBUGCODE(int count = 0;) | 218 SkDEBUGCODE(int count = 0;) |
225 while ((recOrig = static_cast<SkLayerRasterizer_Rec*>(iter.next())) != NULL)
{ | 219 while ((recOrig = static_cast<SkLayerRasterizer_Rec*>(iter.next())) != NULL)
{ |
226 SkDEBUGCODE(count++); | 220 SkDEBUGCODE(count++); |
227 SkLayerRasterizer_Rec* recCopy = static_cast<SkLayerRasterizer_Rec*>(lay
ers->push_back()); | 221 SkLayerRasterizer_Rec* recCopy = static_cast<SkLayerRasterizer_Rec*>(lay
ers->push_back()); |
228 SkNEW_PLACEMENT_ARGS(&recCopy->fPaint, SkPaint, (recOrig->fPaint)); | 222 new (&recCopy->fPaint) SkPaint(recOrig->fPaint); |
229 recCopy->fOffset = recOrig->fOffset; | 223 recCopy->fOffset = recOrig->fOffset; |
230 } | 224 } |
231 SkASSERT(fLayers->count() == count); | 225 SkASSERT(fLayers->count() == count); |
232 SkASSERT(layers->count() == count); | 226 SkASSERT(layers->count() == count); |
233 SkLayerRasterizer* rasterizer = SkNEW_ARGS(SkLayerRasterizer, (layers)); | 227 SkLayerRasterizer* rasterizer = new SkLayerRasterizer(layers); |
234 return rasterizer; | 228 return rasterizer; |
235 } | 229 } |
OLD | NEW |