blob: 9d850c905a3e1f38bc60ff8de33fb35cf093519a [file] [log] [blame]
Mike Reede4ca3622017-01-11 21:18:25 -05001/*
epoger@google.comec3ed6a2011-07-28 14:26:00 +00002 * Copyright 2011 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
reed8a21c9f2016-03-08 18:50:00 -08007
reed@google.com55b8e8c2011-01-13 16:22:35 +00008#include "SampleCode.h"
9#include "SkView.h"
10#include "SkCanvas.h"
11#include "SkGradientShader.h"
Mike Reed356f7c22017-01-10 11:58:39 -050012#include "SkMakeUnique.h"
reed@google.com55b8e8c2011-01-13 16:22:35 +000013
reed8a21c9f2016-03-08 18:50:00 -080014static sk_sp<SkShader> make_grad(SkScalar w, SkScalar h) {
reed@google.com55b8e8c2011-01-13 16:22:35 +000015 SkColor colors[] = { 0xFF000000, 0xFF333333 };
16 SkPoint pts[] = { { 0, 0 }, { w, h } };
reed8a21c9f2016-03-08 18:50:00 -080017 return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
reed@google.com55b8e8c2011-01-13 16:22:35 +000018}
19
reed@google.com0faac1e2011-05-11 05:58:58 +000020class BigGradientView : public SampleView {
reed@google.com55b8e8c2011-01-13 16:22:35 +000021public:
rmistry@google.comae933ce2012-08-23 18:19:56 +000022 BigGradientView() {}
reed@google.com55b8e8c2011-01-13 16:22:35 +000023
24protected:
reed8a21c9f2016-03-08 18:50:00 -080025 bool onQuery(SkEvent* evt) override {
reed@google.com55b8e8c2011-01-13 16:22:35 +000026 if (SampleCode::TitleQ(*evt)) {
27 SampleCode::TitleR(evt, "BigGradient");
28 return true;
29 }
30 return this->INHERITED::onQuery(evt);
31 }
32
reed8a21c9f2016-03-08 18:50:00 -080033 void onDrawContent(SkCanvas* canvas) override {
reed@google.com55b8e8c2011-01-13 16:22:35 +000034 SkRect r;
35 r.set(0, 0, this->width(), this->height());
36 SkPaint p;
reed8a21c9f2016-03-08 18:50:00 -080037 p.setShader(make_grad(this->width(), this->height()));
reed@google.com55b8e8c2011-01-13 16:22:35 +000038 canvas->drawRect(r, p);
39 }
40
41private:
reed@google.com0faac1e2011-05-11 05:58:58 +000042 typedef SampleView INHERITED;
reed@google.com55b8e8c2011-01-13 16:22:35 +000043};
44
45///////////////////////////////////////////////////////////////////////////////
46
47static SkView* MyFactory() { return new BigGradientView; }
48static SkViewRegister reg(MyFactory);
Mike Reed356f7c22017-01-10 11:58:39 -050049
50///////////////////////////////////////////////////////////////////////////////
51
Mike Reed356f7c22017-01-10 11:58:39 -050052#include "SkRasterHandleAllocator.h"
53
54class GraphicsPort {
55protected:
56 SkCanvas* fCanvas;
57
58public:
59 GraphicsPort(SkCanvas* canvas) : fCanvas(canvas) {}
60 virtual ~GraphicsPort() {}
61
62 void save() { fCanvas->save(); }
63 void saveLayer(const SkRect& bounds, SkAlpha alpha) {
64 fCanvas->saveLayerAlpha(&bounds, alpha);
65 }
66 void restore() { fCanvas->restore(); }
67
68 void translate(float x, float y) { fCanvas->translate(x, y); }
69 void scale(float s) { fCanvas->scale(s, s); }
Mike Reed108f55e2017-01-12 11:28:01 -050070 void clip(const SkRect& r) { fCanvas->clipRect(r); }
Mike Reed356f7c22017-01-10 11:58:39 -050071
72 void drawOval(const SkRect& r, SkColor c) {
73 SkPaint p;
74 p.setColor(c);
75 fCanvas->drawOval(r, p);
76 }
77
78 virtual void drawRect(const SkRect& r, SkColor c) {
79 SkPaint p;
80 p.setColor(c);
81 fCanvas->drawRect(r, p);
82 }
Mike Reed108f55e2017-01-12 11:28:01 -050083
84 SkCanvas* peekCanvas() const { return fCanvas; }
Mike Reed356f7c22017-01-10 11:58:39 -050085};
86
Mike Reede4ca3622017-01-11 21:18:25 -050087#ifdef SK_BUILD_FOR_MAC
88
89#include "SkCGUtils.h"
Mike Reed356f7c22017-01-10 11:58:39 -050090class CGGraphicsPort : public GraphicsPort {
91public:
92 CGGraphicsPort(SkCanvas* canvas) : GraphicsPort(canvas) {}
93
94 void drawRect(const SkRect& r, SkColor c) override {
95 CGContextRef cg = (CGContextRef)fCanvas->accessTopRasterHandle();
96
97 CGColorRef color = CGColorCreateGenericRGB(SkColorGetR(c)/255.f,
98 SkColorGetG(c)/255.f,
99 SkColorGetB(c)/255.f,
100 SkColorGetA(c)/255.f);
101
102 CGContextSetFillColorWithColor(cg, color);
103 CGContextFillRect(cg, CGRectMake(r.x(), r.y(), r.width(), r.height()));
104 }
105};
106
107static CGAffineTransform matrix_to_transform(CGContextRef cg, const SkMatrix& ctm) {
108 SkMatrix matrix;
109 matrix.setScale(1, -1);
110 matrix.postTranslate(0, SkIntToScalar(CGBitmapContextGetHeight(cg)));
111 matrix.preConcat(ctm);
112
113 return CGAffineTransformMake(matrix[SkMatrix::kMScaleX],
114 matrix[SkMatrix::kMSkewY],
115 matrix[SkMatrix::kMSkewX],
116 matrix[SkMatrix::kMScaleY],
117 matrix[SkMatrix::kMTransX],
118 matrix[SkMatrix::kMTransY]);
119}
120
121class Allocator_CG : public SkRasterHandleAllocator {
122public:
123 Allocator_CG() {}
124
125 bool allocHandle(const SkImageInfo& info, Rec* rec) override {
126 // let CG allocate the pixels
127 CGContextRef cg = SkCreateCGContext(SkPixmap(info, nullptr, 0));
128 if (!cg) {
129 return false;
130 }
131 rec->fReleaseProc = [](void* pixels, void* ctx){ CGContextRelease((CGContextRef)ctx); };
132 rec->fReleaseCtx = cg;
133 rec->fPixels = CGBitmapContextGetData(cg);
134 rec->fRowBytes = CGBitmapContextGetBytesPerRow(cg);
135 rec->fHandle = cg;
136 CGContextSaveGState(cg); // balanced each time updateContext is called
137 return true;
138 }
139
140 void updateHandle(Handle hndl, const SkMatrix& ctm, const SkIRect& clip) override {
141 CGContextRef cg = (CGContextRef)hndl;
142
143 CGContextRestoreGState(cg);
144 CGContextSaveGState(cg);
Mike Reed108f55e2017-01-12 11:28:01 -0500145 CGContextClipToRect(cg, CGRectMake(clip.x(), clip.y(), clip.width(), clip.height()));
Mike Reed356f7c22017-01-10 11:58:39 -0500146 CGContextConcatCTM(cg, matrix_to_transform(cg, ctm));
147 }
148};
149
Mike Reede4ca3622017-01-11 21:18:25 -0500150#define MyPort CGGraphicsPort
151#define MyAllocator Allocator_CG
152
153#elif defined(WIN32)
154
Mike Reed9e937af2017-01-12 14:18:39 -0500155static RECT toRECT(const SkIRect& r) {
156 return { r.left(), r.top(), r.right(), r.bottom() };
157}
158
Mike Reede4ca3622017-01-11 21:18:25 -0500159class GDIGraphicsPort : public GraphicsPort {
160public:
161 GDIGraphicsPort(SkCanvas* canvas) : GraphicsPort(canvas) {}
162
163 void drawRect(const SkRect& r, SkColor c) override {
164 HDC hdc = (HDC)fCanvas->accessTopRasterHandle();
165
166 COLORREF cr = RGB(SkColorGetR(c), SkColorGetG(c), SkColorGetB(c));// SkEndian_Swap32(c) >> 8;
Mike Kleinc722f792017-07-31 11:57:21 -0400167 RECT rounded = toRECT(r.round());
168 FillRect(hdc, &rounded, CreateSolidBrush(cr));
Mike Reede4ca3622017-01-11 21:18:25 -0500169
170 // Assuming GDI wrote zeros for alpha, this will or-in 0xFF for alpha
171 SkPaint paint;
172 paint.setBlendMode(SkBlendMode::kDstATop);
173 fCanvas->drawRect(r, paint);
174 }
175};
176
177static void DeleteHDCCallback(void*, void* context) {
178 HDC hdc = static_cast<HDC>(context);
179 HBITMAP hbitmap = static_cast<HBITMAP>(SelectObject(hdc, nullptr));
180 DeleteObject(hbitmap);
181 DeleteDC(hdc);
182}
183
184// We use this static factory function instead of the regular constructor so
185// that we can create the pixel data before calling the constructor. This is
186// required so that we can call the base class' constructor with the pixel
187// data.
188static bool Create(int width, int height, bool is_opaque, SkRasterHandleAllocator::Rec* rec) {
189 BITMAPINFOHEADER hdr = { 0 };
190 hdr.biSize = sizeof(BITMAPINFOHEADER);
191 hdr.biWidth = width;
192 hdr.biHeight = -height; // Minus means top-down bitmap.
193 hdr.biPlanes = 1;
194 hdr.biBitCount = 32;
195 hdr.biCompression = BI_RGB; // No compression.
196 hdr.biSizeImage = 0;
197 hdr.biXPelsPerMeter = 1;
198 hdr.biYPelsPerMeter = 1;
199 void* pixels;
200 HBITMAP hbitmap = CreateDIBSection(nullptr, (const BITMAPINFO*)&hdr, 0, &pixels, 0, 0);
201 if (!hbitmap) {
202 return false;
203 }
204
205 size_t row_bytes = width * sizeof(SkPMColor);
206 sk_bzero(pixels, row_bytes * height);
207
208 HDC hdc = CreateCompatibleDC(nullptr);
209 if (!hdc) {
210 DeleteObject(hbitmap);
211 return false;
212 }
213 SetGraphicsMode(hdc, GM_ADVANCED);
214 SelectObject(hdc, hbitmap);
215
216 rec->fReleaseProc = DeleteHDCCallback;
217 rec->fReleaseCtx = hdc;
218 rec->fPixels = pixels;
219 rec->fRowBytes = row_bytes;
220 rec->fHandle = hdc;
221 return true;
222}
223
224/**
225* Subclass of SkRasterHandleAllocator that returns an HDC as its "handle".
226*/
227class GDIAllocator : public SkRasterHandleAllocator {
228public:
229 GDIAllocator() {}
230
231 bool allocHandle(const SkImageInfo& info, Rec* rec) override {
232 SkASSERT(info.colorType() == kN32_SkColorType);
233 return Create(info.width(), info.height(), info.isOpaque(), rec);
234 }
235
236 void updateHandle(Handle handle, const SkMatrix& ctm, const SkIRect& clip_bounds) override {
237 HDC hdc = static_cast<HDC>(handle);
238
239 XFORM xf;
240 xf.eM11 = ctm[SkMatrix::kMScaleX];
241 xf.eM21 = ctm[SkMatrix::kMSkewX];
242 xf.eDx = ctm[SkMatrix::kMTransX];
243 xf.eM12 = ctm[SkMatrix::kMSkewY];
244 xf.eM22 = ctm[SkMatrix::kMScaleY];
245 xf.eDy = ctm[SkMatrix::kMTransY];
246 SetWorldTransform(hdc, &xf);
247
Mike Kleinc722f792017-07-31 11:57:21 -0400248 RECT clip_bounds_RECT = toRECT(clip_bounds);
249 HRGN hrgn = CreateRectRgnIndirect(&clip_bounds_RECT);
Mike Reede4ca3622017-01-11 21:18:25 -0500250 int result = SelectClipRgn(hdc, hrgn);
251 SkASSERT(result != ERROR);
252 result = DeleteObject(hrgn);
253 SkASSERT(result != 0);
Mike Reede4ca3622017-01-11 21:18:25 -0500254 }
255};
256
257#define MyPort GDIGraphicsPort
258#define MyAllocator GDIAllocator
259
260#endif
261
262#ifdef MyAllocator
Mike Reed356f7c22017-01-10 11:58:39 -0500263class RasterAllocatorSample : public SampleView {
264public:
265 RasterAllocatorSample() {}
266
267protected:
268 bool onQuery(SkEvent* evt) override {
269 if (SampleCode::TitleQ(*evt)) {
270 SampleCode::TitleR(evt, "raster-allocator");
271 return true;
272 }
273 return this->INHERITED::onQuery(evt);
274 }
275
276 void doDraw(GraphicsPort* port) {
Mike Reed108f55e2017-01-12 11:28:01 -0500277 SkAutoCanvasRestore acr(port->peekCanvas(), true);
278
Mike Reed356f7c22017-01-10 11:58:39 -0500279 port->drawRect({0, 0, 256, 256}, SK_ColorRED);
280 port->save();
281 port->translate(30, 30);
282 port->drawRect({0, 0, 30, 30}, SK_ColorBLUE);
283 port->drawOval({10, 10, 20, 20}, SK_ColorWHITE);
284 port->restore();
285
286 port->saveLayer({50, 50, 100, 100}, 0x80);
287 port->drawRect({55, 55, 95, 95}, SK_ColorGREEN);
288 port->restore();
Mike Reed108f55e2017-01-12 11:28:01 -0500289
290 port->clip({150, 50, 200, 200});
291 port->drawRect({0, 0, 256, 256}, 0xFFCCCCCC);
Mike Reed356f7c22017-01-10 11:58:39 -0500292 }
293
294 void onDrawContent(SkCanvas* canvas) override {
295 GraphicsPort skp(canvas);
296 doDraw(&skp);
297
298 const SkImageInfo info = SkImageInfo::MakeN32Premul(256, 256);
299 std::unique_ptr<SkCanvas> c2 =
Mike Reede4ca3622017-01-11 21:18:25 -0500300 SkRasterHandleAllocator::MakeCanvas(skstd::make_unique<MyAllocator>(), info);
301 MyPort cgp(c2.get());
Mike Reed356f7c22017-01-10 11:58:39 -0500302 doDraw(&cgp);
303
304 SkPixmap pm;
305 c2->peekPixels(&pm);
306 SkBitmap bm;
307 bm.installPixels(pm);
308 canvas->drawBitmap(bm, 280, 0, nullptr);
309 }
310
311private:
312 typedef SampleView INHERITED;
313};
314DEF_SAMPLE( return new RasterAllocatorSample; )
315#endif