SkNWayCanvas.cpp revision 25c1408c3da9ca90509b84f21a1161ef40052bd1 
1
2/*
3 * Copyright 2011 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8#include "SkNWayCanvas.h"
9
10static SkBitmap make_noconfig_bm(int width, int height) {
11    SkBitmap bm;
12    bm.setConfig(SkBitmap::kNo_Config, width, height);
13    return bm;
14}
15
16SkNWayCanvas::SkNWayCanvas(int width, int height)
17        : INHERITED(make_noconfig_bm(width, height)) {}
18
19SkNWayCanvas::~SkNWayCanvas() {
20    this->removeAll();
21}
22
23void SkNWayCanvas::addCanvas(SkCanvas* canvas) {
24    if (canvas) {
25        canvas->ref();
26        *fList.append() = canvas;
27    }
28}
29
30void SkNWayCanvas::removeCanvas(SkCanvas* canvas) {
31    int index = fList.find(canvas);
32    if (index >= 0) {
33        canvas->unref();
34        fList.removeShuffle(index);
35    }
36}
37
38void SkNWayCanvas::removeAll() {
39    fList.unrefAll();
40    fList.reset();
41}
42
43///////////////////////////////////////////////////////////////////////////
44// These are forwarded to the N canvases we're referencing
45
46class SkNWayCanvas::Iter {
47public:
48    Iter(const SkTDArray<SkCanvas*>& list) : fList(list) {
49        fIndex = 0;
50    }
51    bool next() {
52        if (fIndex < fList.count()) {
53            fCanvas = fList[fIndex++];
54            return true;
55        }
56        return false;
57    }
58    SkCanvas* operator->() { return fCanvas; }
59
60private:
61    const SkTDArray<SkCanvas*>& fList;
62    int fIndex;
63    SkCanvas* fCanvas;
64};
65
66int SkNWayCanvas::save(SaveFlags flags) {
67    Iter iter(fList);
68    while (iter.next()) {
69        iter->save(flags);
70    }
71    return this->INHERITED::save(flags);
72}
73
74int SkNWayCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
75                                    SaveFlags flags) {
76    Iter iter(fList);
77    while (iter.next()) {
78        iter->saveLayer(bounds, paint, flags);
79    }
80    return this->INHERITED::saveLayer(bounds, paint, flags);
81}
82
83void SkNWayCanvas::restore() {
84    Iter iter(fList);
85    while (iter.next()) {
86        iter->restore();
87    }
88    this->INHERITED::restore();
89}
90
91bool SkNWayCanvas::translate(SkScalar dx, SkScalar dy) {
92    Iter iter(fList);
93    while (iter.next()) {
94        iter->translate(dx, dy);
95    }
96    return this->INHERITED::translate(dx, dy);
97}
98
99bool SkNWayCanvas::scale(SkScalar sx, SkScalar sy) {
100    Iter iter(fList);
101    while (iter.next()) {
102        iter->scale(sx, sy);
103    }
104    return this->INHERITED::scale(sx, sy);
105}
106
107bool SkNWayCanvas::rotate(SkScalar degrees) {
108    Iter iter(fList);
109    while (iter.next()) {
110        iter->rotate(degrees);
111    }
112    return this->INHERITED::rotate(degrees);
113}
114
115bool SkNWayCanvas::skew(SkScalar sx, SkScalar sy) {
116    Iter iter(fList);
117    while (iter.next()) {
118        iter->skew(sx, sy);
119    }
120    return this->INHERITED::skew(sx, sy);
121}
122
123bool SkNWayCanvas::concat(const SkMatrix& matrix) {
124    Iter iter(fList);
125    while (iter.next()) {
126        iter->concat(matrix);
127    }
128    return this->INHERITED::concat(matrix);
129}
130
131void SkNWayCanvas::setMatrix(const SkMatrix& matrix) {
132    Iter iter(fList);
133    while (iter.next()) {
134        iter->setMatrix(matrix);
135    }
136    this->INHERITED::setMatrix(matrix);
137}
138
139bool SkNWayCanvas::clipRect(const SkRect& rect, SkRegion::Op op, bool doAA) {
140    Iter iter(fList);
141    while (iter.next()) {
142        iter->clipRect(rect, op, doAA);
143    }
144    return this->INHERITED::clipRect(rect, op, doAA);
145}
146
147bool SkNWayCanvas::clipPath(const SkPath& path, SkRegion::Op op, bool doAA) {
148    Iter iter(fList);
149    while (iter.next()) {
150        iter->clipPath(path, op, doAA);
151    }
152    return this->INHERITED::clipPath(path, op, doAA);
153}
154
155bool SkNWayCanvas::clipRegion(const SkRegion& deviceRgn, SkRegion::Op op) {
156    Iter iter(fList);
157    while (iter.next()) {
158        iter->clipRegion(deviceRgn, op);
159    }
160    return this->INHERITED::clipRegion(deviceRgn, op);
161}
162
163void SkNWayCanvas::drawPaint(const SkPaint& paint) {
164    Iter iter(fList);
165    while (iter.next()) {
166        iter->drawPaint(paint);
167    }
168}
169
170void SkNWayCanvas::drawPoints(PointMode mode, size_t count, const SkPoint pts[],
171                        const SkPaint& paint) {
172    Iter iter(fList);
173    while (iter.next()) {
174        iter->drawPoints(mode, count, pts, paint);
175    }
176}
177
178void SkNWayCanvas::drawRect(const SkRect& rect, const SkPaint& paint) {
179    Iter iter(fList);
180    while (iter.next()) {
181        iter->drawRect(rect, paint);
182    }
183}
184
185void SkNWayCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
186    Iter iter(fList);
187    while (iter.next()) {
188        iter->drawPath(path, paint);
189    }
190}
191
192void SkNWayCanvas::drawBitmap(const SkBitmap& bitmap, SkScalar x, SkScalar y,
193                              const SkPaint* paint) {
194    Iter iter(fList);
195    while (iter.next()) {
196        iter->drawBitmap(bitmap, x, y, paint);
197    }
198}
199
200void SkNWayCanvas::drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
201                                  const SkRect& dst, const SkPaint* paint) {
202    Iter iter(fList);
203    while (iter.next()) {
204        iter->drawBitmapRectToRect(bitmap, src, dst, paint);
205    }
206}
207
208void SkNWayCanvas::drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m,
209                                    const SkPaint* paint) {
210    Iter iter(fList);
211    while (iter.next()) {
212        iter->drawBitmapMatrix(bitmap, m, paint);
213    }
214}
215
216void SkNWayCanvas::drawSprite(const SkBitmap& bitmap, int x, int y,
217                              const SkPaint* paint) {
218    Iter iter(fList);
219    while (iter.next()) {
220        iter->drawSprite(bitmap, x, y, paint);
221    }
222}
223
224void SkNWayCanvas::drawText(const void* text, size_t byteLength, SkScalar x,
225                            SkScalar y, const SkPaint& paint) {
226    Iter iter(fList);
227    while (iter.next()) {
228        iter->drawText(text, byteLength, x, y, paint);
229    }
230}
231
232void SkNWayCanvas::drawPosText(const void* text, size_t byteLength,
233                               const SkPoint pos[], const SkPaint& paint) {
234    Iter iter(fList);
235    while (iter.next()) {
236        iter->drawPosText(text, byteLength, pos, paint);
237    }
238}
239
240void SkNWayCanvas::drawPosTextH(const void* text, size_t byteLength,
241                                const SkScalar xpos[], SkScalar constY,
242                                const SkPaint& paint) {
243    Iter iter(fList);
244    while (iter.next()) {
245        iter->drawPosTextH(text, byteLength, xpos, constY, paint);
246    }
247}
248
249void SkNWayCanvas::drawTextOnPath(const void* text, size_t byteLength,
250                                  const SkPath& path, const SkMatrix* matrix,
251                                  const SkPaint& paint) {
252    Iter iter(fList);
253    while (iter.next()) {
254        iter->drawTextOnPath(text, byteLength, path, matrix, paint);
255    }
256}
257
258void SkNWayCanvas::drawPicture(SkPicture& picture) {
259    Iter iter(fList);
260    while (iter.next()) {
261        iter->drawPicture(picture);
262    }
263}
264
265void SkNWayCanvas::drawVertices(VertexMode vmode, int vertexCount,
266                          const SkPoint vertices[], const SkPoint texs[],
267                          const SkColor colors[], SkXfermode* xmode,
268                          const uint16_t indices[], int indexCount,
269                          const SkPaint& paint) {
270    Iter iter(fList);
271    while (iter.next()) {
272        iter->drawVertices(vmode, vertexCount, vertices, texs, colors, xmode,
273                           indices, indexCount, paint);
274    }
275}
276
277SkBounder* SkNWayCanvas::setBounder(SkBounder* bounder) {
278    Iter iter(fList);
279    while (iter.next()) {
280        iter->setBounder(bounder);
281    }
282    return this->INHERITED::setBounder(bounder);
283}
284
285SkDrawFilter* SkNWayCanvas::setDrawFilter(SkDrawFilter* filter) {
286    Iter iter(fList);
287    while (iter.next()) {
288        iter->setDrawFilter(filter);
289    }
290    return this->INHERITED::setDrawFilter(filter);
291}
292
293
294