blob: fef6f97b162bce2ebeaaa0199e0971511f601dd8 [file] [log] [blame]
epoger@google.comec3ed6a2011-07-28 14:26:00 +00001/*
2 * 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 */
reed868074b2014-06-03 10:53:59 -07007
Scroggo2c8208f2011-06-15 16:49:08 +00008#include "SampleApp.h"
9
Yuqian Li94fddf82017-09-25 14:45:25 -040010#include "SkCommonFlags.h"
tfarinabcbc1782014-06-18 14:32:48 -070011#include "OverView.h"
caryclarkf568f6a2014-07-18 10:58:56 -070012#include "Resources.h"
tfarinabcbc1782014-06-18 14:32:48 -070013#include "SampleCode.h"
reed76113a92015-02-02 12:55:02 -080014#include "SkAnimTimer.h"
reed@android.com8a1c16f2008-12-17 15:59:43 +000015#include "SkCanvas.h"
raftias94888332016-10-18 10:02:51 -070016#include "SkColorSpace_XYZ.h"
tfarinabcbc1782014-06-18 14:32:48 -070017#include "SkCommandLineFlags.h"
csmartdalton008b9d82017-02-22 12:00:42 -070018#include "SkCommonFlagsPathRenderer.h"
tfarinabcbc1782014-06-18 14:32:48 -070019#include "SkData.h"
reedddb5eca2014-10-08 11:10:51 -070020#include "SkDocument.h"
reed@android.com8a1c16f2008-12-17 15:59:43 +000021#include "SkGraphics.h"
tfarinabcbc1782014-06-18 14:32:48 -070022#include "SkOSFile.h"
Ben Wagnerbf111d72016-11-07 18:05:29 -050023#include "SkOSPath.h"
reed@android.com8a1c16f2008-12-17 15:59:43 +000024#include "SkPaint.h"
fmalita822ace92015-06-15 07:07:32 -070025#include "SkPaintFilterCanvas.h"
reed@android.com8a1c16f2008-12-17 15:59:43 +000026#include "SkPicture.h"
robertphillips@google.com770963f2014-04-18 18:04:41 +000027#include "SkPictureRecorder.h"
brianosman36db3f42016-04-20 09:20:46 -070028#include "SkPM4fPriv.h"
reed@android.com8a1c16f2008-12-17 15:59:43 +000029#include "SkStream.h"
commit-bot@chromium.org9a558d42014-05-30 15:06:24 +000030#include "SkSurface.h"
scroggo565901d2015-12-10 10:44:13 -080031#include "SkTemplates.h"
edisonn@google.comf8b6b012013-07-11 14:28:04 +000032#include "SkTSort.h"
reed@android.com44177402009-11-23 21:07:51 +000033#include "SkTime.h"
Scroggo0f185c22011-03-24 18:35:50 +000034#include "SkTypeface.h"
tfarinabcbc1782014-06-18 14:32:48 -070035#include "SkWindow.h"
tfarinabcbc1782014-06-18 14:32:48 -070036#include "sk_tool_utils.h"
liyuqian38911a72016-10-04 11:23:22 -070037#include "SkScan.h"
Mike Reedebfce6d2016-12-12 10:02:12 -050038#include "SkClipOpPriv.h"
Yuqian Lib55dd552017-04-03 10:52:48 -040039#include "SkThreadedBMPDevice.h"
reed@android.comf2b98d62010-12-20 18:26:13 +000040
reed54dc4872016-09-13 08:09:45 -070041#include "SkReadBuffer.h"
42#include "SkStream.h"
43
Mike Reed476e6c92016-09-30 15:26:47 -040044#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
45#include "SkCGUtils.h"
46#endif
47
Mike Reed96cf2062017-03-14 21:10:42 -040048#define PICTURE_MEANS_PIPE false
49#define SERIALIZE_PICTURE true
50
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +000051#if SK_SUPPORT_GPU
bsalomon3724e572016-03-30 18:56:19 -070052# include "gl/GrGLInterface.h"
53# include "gl/GrGLUtil.h"
bsalomon3724e572016-03-30 18:56:19 -070054# include "GrContext.h"
robertphillips7715e062016-04-22 10:57:16 -070055# include "SkGr.h"
bsalomon3724e572016-03-30 18:56:19 -070056# if SK_ANGLE
bsalomon273c0f52016-03-31 10:59:06 -070057# include "gl/angle/GLTestContext_angle.h"
bsalomon3724e572016-03-30 18:56:19 -070058# endif
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +000059#else
60class GrContext;
61#endif
Scroggo2c8208f2011-06-15 16:49:08 +000062
Mike Reed8780eda2017-08-07 12:25:19 -040063extern bool gSkForceRasterPipelineBlitter;
64
brianosman35a02a82016-09-29 14:37:02 -070065enum OutputColorSpace {
66 kLegacy_OutputColorSpace,
67 kSRGB_OutputColorSpace,
Brian Osmanfc2e7e02016-12-02 12:10:36 -050068 kNarrow_OutputColorSpace,
brianosman35a02a82016-09-29 14:37:02 -070069 kMonitor_OutputColorSpace,
reeda34be682016-02-15 07:48:35 -080070};
71
brianosman35a02a82016-09-29 14:37:02 -070072const struct {
73 SkColorType fColorType;
74 OutputColorSpace fColorSpace;
75 const char* fName;
76} gConfig[] = {
77 { kN32_SkColorType, kLegacy_OutputColorSpace, "L32" },
Mike Reed6bfc2742017-09-06 14:12:57 -040078 { kRGB_565_SkColorType, kLegacy_OutputColorSpace, "L565" },
brianosman35a02a82016-09-29 14:37:02 -070079 { kN32_SkColorType, kSRGB_OutputColorSpace, "S32" },
80 { kRGBA_F16_SkColorType, kSRGB_OutputColorSpace, "F16" },
Brian Osmanfc2e7e02016-12-02 12:10:36 -050081 { kRGBA_F16_SkColorType, kNarrow_OutputColorSpace, "F16 Narrow" },
brianosman35a02a82016-09-29 14:37:02 -070082 { kRGBA_F16_SkColorType, kMonitor_OutputColorSpace, "F16 Device" },
83};
reeda34be682016-02-15 07:48:35 -080084
reed5f629b42015-08-15 11:57:23 -070085// Should be 3x + 1
86#define kMaxFatBitsScale 28
87
reed@google.com1830c7a2012-06-04 12:05:43 +000088extern SampleView* CreateSamplePictFileView(const char filename[]);
89
90class PictFileFactory : public SkViewFactory {
91 SkString fFilename;
92public:
93 PictFileFactory(const SkString& filename) : fFilename(filename) {}
mtklein36352bf2015-03-25 18:17:31 -070094 SkView* operator() () const override {
reed@google.com1830c7a2012-06-04 12:05:43 +000095 return CreateSamplePictFileView(fFilename.c_str());
96 }
97};
98
csmartdalton8c679092017-03-27 12:32:29 -060099extern SampleView* CreateSamplePathFinderView(const char filename[]);
100
101class PathFinderFactory : public SkViewFactory {
102 SkString fFilename;
103public:
104 PathFinderFactory(const SkString& filename) : fFilename(filename) {}
105 SkView* operator() () const override {
106 return CreateSamplePathFinderView(fFilename.c_str());
107 }
108};
109
fmalita851d68a2016-08-15 07:48:47 -0700110extern SampleView* CreateSampleSVGFileView(const SkString& filename);
fmalita6ceef3d2016-07-26 18:46:34 -0700111
112class SVGFileFactory : public SkViewFactory {
113 SkString fFilename;
114public:
115 SVGFileFactory(const SkString& filename) : fFilename(filename) {}
116 SkView* operator() () const override {
fmalita851d68a2016-08-15 07:48:47 -0700117 return CreateSampleSVGFileView(fFilename);
fmalita6ceef3d2016-07-26 18:46:34 -0700118 }
119};
120
edisonn@google.comf8b6b012013-07-11 14:28:04 +0000121#ifdef SAMPLE_PDF_FILE_VIEWER
122extern SampleView* CreateSamplePdfFileViewer(const char filename[]);
123
124class PdfFileViewerFactory : public SkViewFactory {
125 SkString fFilename;
126public:
127 PdfFileViewerFactory(const SkString& filename) : fFilename(filename) {}
mtklein36352bf2015-03-25 18:17:31 -0700128 SkView* operator() () const override {
edisonn@google.comf8b6b012013-07-11 14:28:04 +0000129 return CreateSamplePdfFileViewer(fFilename.c_str());
130 }
131};
132#endif // SAMPLE_PDF_FILE_VIEWER
133
bsalomon49996162016-06-14 09:43:52 -0700134#if SK_ANGLE
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000135//#define DEFAULT_TO_ANGLE 1
136#else
bsalomon@google.com82d12232013-09-09 15:36:26 +0000137#define DEFAULT_TO_GPU 0 // if 1 default rendering is on GPU
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000138#endif
reed@android.comf2b98d62010-12-20 18:26:13 +0000139
reed@android.com8a1c16f2008-12-17 15:59:43 +0000140#define ANIMATING_EVENTTYPE "nextSample"
reed@google.com84cfce12013-05-29 19:22:20 +0000141#define ANIMATING_DELAY 250
reed@android.com8a1c16f2008-12-17 15:59:43 +0000142
mike@reedtribe.org2eb59522011-04-22 01:59:09 +0000143#ifdef SK_DEBUG
reed@google.combad8c872011-05-18 20:10:31 +0000144 #define FPS_REPEAT_MULTIPLIER 1
mike@reedtribe.org2eb59522011-04-22 01:59:09 +0000145#else
reed@google.combad8c872011-05-18 20:10:31 +0000146 #define FPS_REPEAT_MULTIPLIER 10
mike@reedtribe.org2eb59522011-04-22 01:59:09 +0000147#endif
reed@google.combad8c872011-05-18 20:10:31 +0000148#define FPS_REPEAT_COUNT (10 * FPS_REPEAT_MULTIPLIER)
mike@reedtribe.org2eb59522011-04-22 01:59:09 +0000149
reed@google.com3cec4d72011-07-06 13:59:47 +0000150static SampleWindow* gSampleWindow;
151
reed@google.coma4f81372012-11-15 15:56:38 +0000152static bool gShowGMBounds;
153
commit-bot@chromium.org6de4a782013-12-11 17:05:23 +0000154static void post_event_to_sink(SkEvent* evt, SkEventSink* sink) {
reed@google.com2072db82011-11-08 15:18:10 +0000155 evt->setTargetID(sink->getSinkID())->post();
156}
157
reed76113a92015-02-02 12:55:02 -0800158static SkAnimTimer gAnimTimer;
159
mike@reedtribe.org6f6e8c32011-12-27 22:33:50 +0000160///////////////////////////////////////////////////////////////////////////////
161
162static const char* skip_until(const char* str, const char* skip) {
163 if (!str) {
halcanary96fcdcc2015-08-27 07:41:13 -0700164 return nullptr;
mike@reedtribe.org6f6e8c32011-12-27 22:33:50 +0000165 }
166 return strstr(str, skip);
167}
168
169static const char* skip_past(const char* str, const char* skip) {
170 const char* found = skip_until(str, skip);
171 if (!found) {
halcanary96fcdcc2015-08-27 07:41:13 -0700172 return nullptr;
mike@reedtribe.org6f6e8c32011-12-27 22:33:50 +0000173 }
174 return found + strlen(skip);
175}
176
177static const char* gPrefFileName = "sampleapp_prefs.txt";
178
epoger@google.com6fc7cc22011-12-28 15:13:41 +0000179static bool readTitleFromPrefs(SkString* title) {
mike@reedtribe.org6f6e8c32011-12-27 22:33:50 +0000180 SkFILEStream stream(gPrefFileName);
181 if (!stream.isValid()) {
182 return false;
183 }
184
reed@google.com7fa2a652014-01-27 13:42:58 +0000185 size_t len = stream.getLength();
mike@reedtribe.org6f6e8c32011-12-27 22:33:50 +0000186 SkString data(len);
187 stream.read(data.writable_str(), len);
188 const char* s = data.c_str();
189
190 s = skip_past(s, "curr-slide-title");
191 s = skip_past(s, "=");
192 s = skip_past(s, "\"");
193 const char* stop = skip_until(s, "\"");
194 if (stop > s) {
195 title->set(s, stop - s);
196 return true;
197 }
198 return false;
199}
200
epoger@google.com6fc7cc22011-12-28 15:13:41 +0000201static void writeTitleToPrefs(const char* title) {
mike@reedtribe.org6f6e8c32011-12-27 22:33:50 +0000202 SkFILEWStream stream(gPrefFileName);
203 SkString data;
204 data.printf("curr-slide-title = \"%s\"\n", title);
205 stream.write(data.c_str(), data.size());
206}
207
208///////////////////////////////////////////////////////////////////////////////
209
bsalomon@google.com098e96d2011-07-14 14:30:46 +0000210class SampleWindow::DefaultDeviceManager : public SampleWindow::DeviceManager {
211public:
212
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000213 DefaultDeviceManager() {
214#if SK_SUPPORT_GPU
halcanary96fcdcc2015-08-27 07:41:13 -0700215 fCurContext = nullptr;
216 fCurIntf = nullptr;
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000217 fMSAASampleCount = 0;
brianosman2d1ee792016-05-05 12:24:31 -0700218 fDeepColor = false;
219 fActualColorBits = 0;
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000220#endif
221 fBackend = kNone_BackEndType;
bsalomon@google.com098e96d2011-07-14 14:30:46 +0000222 }
223
Brian Salomond3b65972017-03-22 12:05:03 -0400224 ~DefaultDeviceManager() override {
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000225#if SK_SUPPORT_GPU
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000226 SkSafeUnref(fCurContext);
227 SkSafeUnref(fCurIntf);
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000228#endif
bsalomon@google.com098e96d2011-07-14 14:30:46 +0000229 }
230
csmartdalton008b9d82017-02-22 12:00:42 -0700231 void setUpBackend(SampleWindow* win, const BackendOptions& backendOptions) override {
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000232 SkASSERT(kNone_BackEndType == fBackend);
robertphillips@google.com53e96a12012-03-30 14:47:53 +0000233
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000234 fBackend = kNone_BackEndType;
235
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000236#if SK_SUPPORT_GPU
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000237 switch (win->getDeviceType()) {
reedbeedb812015-05-05 12:14:45 -0700238 case kRaster_DeviceType: // fallthrough
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000239 case kGPU_DeviceType:
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000240 // all these guys use the native backend
241 fBackend = kNativeGL_BackEndType;
242 break;
robertphillips@google.combd8d7ad2012-03-30 15:18:14 +0000243#if SK_ANGLE
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000244 case kANGLE_DeviceType:
245 // ANGLE is really the only odd man out
246 fBackend = kANGLE_BackEndType;
247 break;
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000248#endif // SK_ANGLE
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000249 default:
250 SkASSERT(false);
251 break;
robertphillips@google.combd8d7ad2012-03-30 15:18:14 +0000252 }
bsalomon@google.com64cc8102013-03-05 20:06:05 +0000253 AttachmentInfo attachmentInfo;
csmartdalton008b9d82017-02-22 12:00:42 -0700254 bool result = win->attach(fBackend, backendOptions.fMSAASampleCount,
255 backendOptions.fDeepColor, &attachmentInfo);
robertphillips@google.comd3b9fbb2012-03-28 16:19:11 +0000256 if (!result) {
bsalomon@google.com74913722011-10-27 20:44:19 +0000257 SkDebugf("Failed to initialize GL");
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000258 return;
bsalomon@google.com098e96d2011-07-14 14:30:46 +0000259 }
csmartdalton008b9d82017-02-22 12:00:42 -0700260 fMSAASampleCount = backendOptions.fMSAASampleCount;
261 fDeepColor = backendOptions.fDeepColor;
brianosman2d1ee792016-05-05 12:24:31 -0700262 // Assume that we have at least 24-bit output, for backends that don't supply this data
263 fActualColorBits = SkTMax(attachmentInfo.fColorBits, 24);
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000264
halcanary96fcdcc2015-08-27 07:41:13 -0700265 SkASSERT(nullptr == fCurIntf);
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000266 switch (win->getDeviceType()) {
reedbeedb812015-05-05 12:14:45 -0700267 case kRaster_DeviceType: // fallthrough
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000268 case kGPU_DeviceType:
269 // all these guys use the native interface
csmartdalton008b9d82017-02-22 12:00:42 -0700270 fCurIntf = GrGLCreateNativeInterface();
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000271 break;
robertphillips@google.comd3b9fbb2012-03-28 16:19:11 +0000272#if SK_ANGLE
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000273 case kANGLE_DeviceType:
csmartdalton008b9d82017-02-22 12:00:42 -0700274 fCurIntf = sk_gpu_test::CreateANGLEGLInterface();
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000275 break;
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000276#endif // SK_ANGLE
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000277 default:
278 SkASSERT(false);
279 break;
bsalomon@google.com6fb736f2011-09-16 18:51:57 +0000280 }
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000281
halcanary96fcdcc2015-08-27 07:41:13 -0700282 SkASSERT(nullptr == fCurContext);
Greg Daniel02611d92017-07-25 10:05:01 -0400283 fCurContext = GrContext::MakeGL(fCurIntf, backendOptions.fGrContextOptions).release();
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000284
halcanary96fcdcc2015-08-27 07:41:13 -0700285 if (nullptr == fCurContext || nullptr == fCurIntf) {
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000286 // We need some context and interface to see results
287 SkSafeUnref(fCurContext);
288 SkSafeUnref(fCurIntf);
halcanary96fcdcc2015-08-27 07:41:13 -0700289 fCurContext = nullptr;
290 fCurIntf = nullptr;
bsalomon@google.com098e96d2011-07-14 14:30:46 +0000291 SkDebugf("Failed to setup 3D");
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000292
mtklein18300a32016-03-16 13:53:35 -0700293 win->release();
bsalomon@google.com098e96d2011-07-14 14:30:46 +0000294 }
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000295#endif // SK_SUPPORT_GPU
robertphillipsecf3dbe2016-07-28 15:17:34 -0700296 // call windowSizeChanged to create the gpu-backed Surface
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000297 this->windowSizeChanged(win);
bsalomon@google.com098e96d2011-07-14 14:30:46 +0000298 }
299
mtkleinf0599002015-07-13 06:18:39 -0700300 void tearDownBackend(SampleWindow *win) override {
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000301#if SK_SUPPORT_GPU
reed789e3272014-10-30 11:29:08 -0700302 if (fCurContext) {
303 // in case we have outstanding refs to this guy (lua?)
304 fCurContext->abandonContext();
305 fCurContext->unref();
halcanary96fcdcc2015-08-27 07:41:13 -0700306 fCurContext = nullptr;
reed789e3272014-10-30 11:29:08 -0700307 }
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000308
309 SkSafeUnref(fCurIntf);
halcanary96fcdcc2015-08-27 07:41:13 -0700310 fCurIntf = nullptr;
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000311
robertphillipsecf3dbe2016-07-28 15:17:34 -0700312 fGpuSurface = nullptr;
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000313#endif
mtklein18300a32016-03-16 13:53:35 -0700314 win->release();
bsalomon@google.comddd40e52012-04-10 15:56:29 +0000315 fBackend = kNone_BackEndType;
bsalomon@google.com098e96d2011-07-14 14:30:46 +0000316 }
317
robertphillipsecf3dbe2016-07-28 15:17:34 -0700318 sk_sp<SkSurface> makeSurface(SampleWindow::DeviceType dType, SampleWindow* win) override {
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000319#if SK_SUPPORT_GPU
bsalomon49f085d2014-09-05 13:34:00 -0700320 if (IsGpuDeviceType(dType) && fCurContext) {
reed4302ae92014-10-06 12:29:56 -0700321 SkSurfaceProps props(win->getSurfaceProps());
brianosman2d1ee792016-05-05 12:24:31 -0700322 if (kRGBA_F16_SkColorType == win->info().colorType() || fActualColorBits > 24) {
323 // If we're rendering to F16, we need an off-screen surface - the current render
324 // target is most likely the wrong format.
325 //
326 // If we're using a deep (10-bit or higher) surface, we probably need an off-screen
327 // surface. 10-bit, in particular, has strange gamma behavior.
brianosman6b086522016-04-14 12:39:00 -0700328 return SkSurface::MakeRenderTarget(fCurContext, SkBudgeted::kNo, win->info(),
robertphillipsecf3dbe2016-07-28 15:17:34 -0700329 fMSAASampleCount, &props);
brianosman6b086522016-04-14 12:39:00 -0700330 } else {
robertphillipsecf3dbe2016-07-28 15:17:34 -0700331 return fGpuSurface;
brianosman6b086522016-04-14 12:39:00 -0700332 }
bsalomon@google.com098e96d2011-07-14 14:30:46 +0000333 }
reed0397e9f2014-09-18 11:29:01 -0700334#endif
halcanary96fcdcc2015-08-27 07:41:13 -0700335 return nullptr;
bsalomon@google.com098e96d2011-07-14 14:30:46 +0000336 }
337
Ben Wagner55963bc2017-07-24 15:00:35 +0000338 void publishCanvas(SampleWindow::DeviceType dType,
339 SkCanvas* renderingCanvas, SampleWindow* win) override {
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000340#if SK_SUPPORT_GPU
brianosman2d1ee792016-05-05 12:24:31 -0700341 if (!IsGpuDeviceType(dType) ||
342 kRGBA_F16_SkColorType == win->info().colorType() ||
343 fActualColorBits > 24) {
Brian Osman0d4ff6c2017-01-17 16:10:07 -0500344 // We made/have an off-screen surface. Extract the pixels exactly as we rendered them:
345 SkImageInfo info = win->info();
346 size_t rowBytes = info.minRowBytes();
Mike Reedcd284c52017-09-29 15:22:56 -0400347 size_t size = info.computeByteSize(rowBytes);
Brian Osman0d4ff6c2017-01-17 16:10:07 -0500348 auto data = SkData::MakeUninitialized(size);
349 SkASSERT(data);
350
Ben Wagner55963bc2017-07-24 15:00:35 +0000351 if (!renderingCanvas->readPixels(info, data->writable_data(), rowBytes, 0, 0)) {
Brian Osman0d4ff6c2017-01-17 16:10:07 -0500352 SkDEBUGFAIL("Failed to read canvas pixels");
353 return;
brianosman35a02a82016-09-29 14:37:02 -0700354 }
Brian Osman0d4ff6c2017-01-17 16:10:07 -0500355
356 // Now, re-interpret those pixels as sRGB, so they won't be color converted when we
357 // draw then to FBO0. This ensures that if we rendered in any strange gamut, we'll see
358 // the "correct" output (because we generated the pixel values we wanted in the
359 // offscreen canvas).
360 auto colorSpace = kRGBA_F16_SkColorType == info.colorType()
Matt Sarett77a7a1b2017-02-07 13:56:11 -0500361 ? SkColorSpace::MakeSRGBLinear()
362 : SkColorSpace::MakeSRGB();
Brian Osman0d4ff6c2017-01-17 16:10:07 -0500363 auto offscreenImage = SkImage::MakeRasterData(info.makeColorSpace(colorSpace), data,
364 rowBytes);
robertphillipsecf3dbe2016-07-28 15:17:34 -0700365
robertphillips1e876182016-07-29 08:28:25 -0700366 SkCanvas* gpuCanvas = fGpuSurface->getCanvas();
brianosman2d1ee792016-05-05 12:24:31 -0700367
368 // With ten-bit output, we need to manually apply the gamma of the output device
369 // (unless we're in non-gamma correct mode, in which case our data is already
370 // fake-sRGB, like we're expected to put in the 10-bit buffer):
Brian Osman7039f742016-11-01 15:56:16 -0400371 bool doGamma = (fActualColorBits == 30) && win->info().colorSpace();
robertphillips1e876182016-07-29 08:28:25 -0700372
373 SkPaint gammaPaint;
reed374772b2016-10-05 17:33:02 -0700374 gammaPaint.setBlendMode(SkBlendMode::kSrc);
robertphillips1e876182016-07-29 08:28:25 -0700375 if (doGamma) {
Mike Reed412cda72017-07-05 15:43:15 -0400376 gammaPaint.setColorFilter(SkColorFilter::MakeLinearToSRGBGamma());
robertphillips1e876182016-07-29 08:28:25 -0700377 }
378
Brian Osman0d4ff6c2017-01-17 16:10:07 -0500379 gpuCanvas->drawImage(offscreenImage, 0, 0, &gammaPaint);
bsalomon@google.com098e96d2011-07-14 14:30:46 +0000380 }
robertphillips1e876182016-07-29 08:28:25 -0700381
382 fGpuSurface->prepareForExternalIO();
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000383#endif
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000384
385 win->present();
bsalomon@google.com098e96d2011-07-14 14:30:46 +0000386 }
387
mtkleinf0599002015-07-13 06:18:39 -0700388 void windowSizeChanged(SampleWindow* win) override {
Yuqian Li5458cf82017-05-24 09:58:07 -0400389 win->resetFPS();
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000390#if SK_SUPPORT_GPU
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000391 if (fCurContext) {
bsalomon@google.com64cc8102013-03-05 20:06:05 +0000392 AttachmentInfo attachmentInfo;
brianosman2d1ee792016-05-05 12:24:31 -0700393 win->attach(fBackend, fMSAASampleCount, fDeepColor, &attachmentInfo);
brianosman2d1ee792016-05-05 12:24:31 -0700394 fActualColorBits = SkTMax(attachmentInfo.fColorBits, 24);
robertphillipsecf3dbe2016-07-28 15:17:34 -0700395 fGpuSurface = win->makeGpuBackedSurface(attachmentInfo, fCurIntf, fCurContext);
bsalomon@google.com74913722011-10-27 20:44:19 +0000396 }
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000397#endif
bsalomon@google.com098e96d2011-07-14 14:30:46 +0000398 }
399
mtkleinf0599002015-07-13 06:18:39 -0700400 GrContext* getGrContext() override {
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000401#if SK_SUPPORT_GPU
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000402 return fCurContext;
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000403#else
halcanary96fcdcc2015-08-27 07:41:13 -0700404 return nullptr;
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000405#endif
bsalomon@google.com098e96d2011-07-14 14:30:46 +0000406 }
bsalomon@google.com11959252012-04-06 20:13:38 +0000407
robertphillipsecf3dbe2016-07-28 15:17:34 -0700408 int numColorSamples() const override {
brianosman1dfec742016-09-15 07:19:53 -0700409#if SK_SUPPORT_GPU
robertphillipsecf3dbe2016-07-28 15:17:34 -0700410 return fMSAASampleCount;
brianosman1dfec742016-09-15 07:19:53 -0700411#else
412 return 0;
413#endif
bsalomon@google.com11959252012-04-06 20:13:38 +0000414 }
415
brianosman2d1ee792016-05-05 12:24:31 -0700416 int getColorBits() override {
417#if SK_SUPPORT_GPU
418 return fActualColorBits;
419#else
420 return 24;
421#endif
422 }
423
bsalomon@google.com098e96d2011-07-14 14:30:46 +0000424private:
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000425
426#if SK_SUPPORT_GPU
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000427 GrContext* fCurContext;
428 const GrGLInterface* fCurIntf;
robertphillipsecf3dbe2016-07-28 15:17:34 -0700429 sk_sp<SkSurface> fGpuSurface;
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000430 int fMSAASampleCount;
brianosman2d1ee792016-05-05 12:24:31 -0700431 bool fDeepColor;
432 int fActualColorBits;
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000433#endif
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000434
435 SkOSWindow::SkBackEndTypes fBackend;
436
437 typedef SampleWindow::DeviceManager INHERITED;
bsalomon@google.com098e96d2011-07-14 14:30:46 +0000438};
439
440///////////////
mike@reedtribe.org2eb59522011-04-22 01:59:09 +0000441static const char view_inval_msg[] = "view-inval-msg";
442
Scroggo62b65b02011-06-21 16:01:26 +0000443void SampleWindow::postInvalDelay() {
reed@google.com87fac4a2011-08-04 13:50:17 +0000444 (new SkEvent(view_inval_msg, this->getSinkID()))->postDelay(1);
mike@reedtribe.org2eb59522011-04-22 01:59:09 +0000445}
446
447static bool isInvalEvent(const SkEvent& evt) {
448 return evt.isType(view_inval_msg);
449}
450//////////////////
451
bsalomon@google.com48dd1a22011-10-31 14:18:20 +0000452#include "GMSampleView.h"
453
bsalomon@google.com48dd1a22011-10-31 14:18:20 +0000454class AutoUnrefArray {
455public:
456 AutoUnrefArray() {}
457 ~AutoUnrefArray() {
458 int count = fObjs.count();
459 for (int i = 0; i < count; ++i) {
460 fObjs[i]->unref();
461 }
462 }
463 SkRefCnt*& push_back() { return *fObjs.append(); }
chudy@google.com4605a3f2012-08-01 17:58:01 +0000464
bsalomon@google.com48dd1a22011-10-31 14:18:20 +0000465private:
466 SkTDArray<SkRefCnt*> fObjs;
467};
468
469// registers GMs as Samples
470// This can't be performed during static initialization because it could be
471// run before GMRegistry has been fully built.
caryclark@google.com02939ce2012-06-06 12:09:51 +0000472static void SkGMRegistyToSampleRegistry() {
bsalomon@google.com48dd1a22011-10-31 14:18:20 +0000473 static bool gOnce;
chudy@google.com4605a3f2012-08-01 17:58:01 +0000474 static AutoUnrefArray fRegisters;
bsalomon@google.com48dd1a22011-10-31 14:18:20 +0000475
476 if (!gOnce) {
477 const skiagm::GMRegistry* gmreg = skiagm::GMRegistry::Head();
478 while (gmreg) {
479 fRegisters.push_back() = new SkViewRegister(gmreg->factory());
480 gmreg = gmreg->next();
481 }
482 gOnce = true;
483 }
484}
485
reed@google.comf0b5f682011-03-11 20:08:25 +0000486//////////////////////////////////////////////////////////////////////////////
487
reed@google.com569e0432011-04-05 13:07:03 +0000488enum FlipAxisEnum {
489 kFlipAxis_X = (1 << 0),
490 kFlipAxis_Y = (1 << 1)
491};
492
reed@google.comf0b5f682011-03-11 20:08:25 +0000493#include "SkDrawFilter.h"
494
bungeman@google.com96aabc82013-06-03 21:26:34 +0000495struct HintingState {
496 SkPaint::Hinting hinting;
497 const char* name;
498 const char* label;
499};
500static HintingState gHintingStates[] = {
halcanary96fcdcc2015-08-27 07:41:13 -0700501 {SkPaint::kNo_Hinting, "Mixed", nullptr },
bungeman@google.com96aabc82013-06-03 21:26:34 +0000502 {SkPaint::kNo_Hinting, "None", "H0 " },
503 {SkPaint::kSlight_Hinting, "Slight", "Hs " },
504 {SkPaint::kNormal_Hinting, "Normal", "Hn " },
505 {SkPaint::kFull_Hinting, "Full", "Hf " },
506};
507
bungeman5a59a422016-03-31 08:30:38 -0700508struct PixelGeometryState {
509 SkPixelGeometry pixelGeometry;
510 const char* name;
511 const char* label;
512};
513static PixelGeometryState gPixelGeometryStates[] = {
514 {SkPixelGeometry::kUnknown_SkPixelGeometry, "Mixed", nullptr },
515 {SkPixelGeometry::kUnknown_SkPixelGeometry, "Flat", "{Flat} " },
516 {SkPixelGeometry::kRGB_H_SkPixelGeometry, "RGB H", "{RGB H} " },
517 {SkPixelGeometry::kBGR_H_SkPixelGeometry, "BGR H", "{BGR H} " },
518 {SkPixelGeometry::kRGB_V_SkPixelGeometry, "RGB_V", "{RGB V} " },
519 {SkPixelGeometry::kBGR_V_SkPixelGeometry, "BGR_V", "{BGR V} " },
520};
521
reed93a12152015-03-16 10:08:34 -0700522struct FilterQualityState {
523 SkFilterQuality fQuality;
524 const char* fName;
525 const char* fLabel;
reed@google.com15bc13d2013-12-10 16:53:13 +0000526};
reed93a12152015-03-16 10:08:34 -0700527static FilterQualityState gFilterQualityStates[] = {
halcanary96fcdcc2015-08-27 07:41:13 -0700528 { kNone_SkFilterQuality, "Mixed", nullptr },
reed93a12152015-03-16 10:08:34 -0700529 { kNone_SkFilterQuality, "None", "F0 " },
530 { kLow_SkFilterQuality, "Low", "F1 " },
531 { kMedium_SkFilterQuality, "Medium", "F2 " },
532 { kHigh_SkFilterQuality, "High", "F3 " },
reed@google.com15bc13d2013-12-10 16:53:13 +0000533};
534
fmalita822ace92015-06-15 07:07:32 -0700535class FlagsFilterCanvas : public SkPaintFilterCanvas {
reed@google.comf0b5f682011-03-11 20:08:25 +0000536public:
fmalita822ace92015-06-15 07:07:32 -0700537 FlagsFilterCanvas(SkCanvas* canvas, SkOSMenu::TriState lcd, SkOSMenu::TriState aa,
538 SkOSMenu::TriState subpixel, int hinting, int filterQuality)
fmalitabad23dc2016-01-11 13:58:29 -0800539 : INHERITED(canvas)
fmalita822ace92015-06-15 07:07:32 -0700540 , fLCDState(lcd)
reed@google.com15bc13d2013-12-10 16:53:13 +0000541 , fAAState(aa)
542 , fSubpixelState(subpixel)
543 , fHintingState(hinting)
fmalita822ace92015-06-15 07:07:32 -0700544 , fFilterQualityIndex(filterQuality) {
reed93a12152015-03-16 10:08:34 -0700545 SkASSERT((unsigned)filterQuality < SK_ARRAY_COUNT(gFilterQualityStates));
reed@google.com15bc13d2013-12-10 16:53:13 +0000546 }
reed@google.comf0b5f682011-03-11 20:08:25 +0000547
fmalita822ace92015-06-15 07:07:32 -0700548protected:
fmalita32cdc322016-01-12 07:21:11 -0800549 bool onFilter(SkTCopyOnFirstWrite<SkPaint>* paint, Type t) const override {
550 if (!*paint) {
fmalitabad23dc2016-01-11 13:58:29 -0800551 return true;
552 }
553
yangsu@google.comdb03eaa2011-08-08 15:37:23 +0000554 if (kText_Type == t && SkOSMenu::kMixedState != fLCDState) {
fmalita32cdc322016-01-12 07:21:11 -0800555 paint->writable()->setLCDRenderText(SkOSMenu::kOnState == fLCDState);
reed@google.com569e0432011-04-05 13:07:03 +0000556 }
yangsu@google.comdb03eaa2011-08-08 15:37:23 +0000557 if (SkOSMenu::kMixedState != fAAState) {
fmalita32cdc322016-01-12 07:21:11 -0800558 paint->writable()->setAntiAlias(SkOSMenu::kOnState == fAAState);
reed@google.comf0b5f682011-03-11 20:08:25 +0000559 }
reed93a12152015-03-16 10:08:34 -0700560 if (0 != fFilterQualityIndex) {
fmalita32cdc322016-01-12 07:21:11 -0800561 paint->writable()->setFilterQuality(gFilterQualityStates[fFilterQualityIndex].fQuality);
reed@google.com176753a2011-05-17 15:32:04 +0000562 }
bungeman@google.com96aabc82013-06-03 21:26:34 +0000563 if (SkOSMenu::kMixedState != fSubpixelState) {
fmalita32cdc322016-01-12 07:21:11 -0800564 paint->writable()->setSubpixelText(SkOSMenu::kOnState == fSubpixelState);
bungeman@google.com96aabc82013-06-03 21:26:34 +0000565 }
bungeman@google.com055aa522013-06-03 21:35:03 +0000566 if (0 != fHintingState && fHintingState < (int)SK_ARRAY_COUNT(gHintingStates)) {
fmalita32cdc322016-01-12 07:21:11 -0800567 paint->writable()->setHinting(gHintingStates[fHintingState].hinting);
reed@google.com09e3baa2011-05-18 12:04:31 +0000568 }
fmalitabad23dc2016-01-11 13:58:29 -0800569 return true;
reed@google.comf0b5f682011-03-11 20:08:25 +0000570 }
571
572private:
yangsu@google.comdb03eaa2011-08-08 15:37:23 +0000573 SkOSMenu::TriState fLCDState;
574 SkOSMenu::TriState fAAState;
bungeman@google.com96aabc82013-06-03 21:26:34 +0000575 SkOSMenu::TriState fSubpixelState;
576 int fHintingState;
reed93a12152015-03-16 10:08:34 -0700577 int fFilterQualityIndex;
fmalita822ace92015-06-15 07:07:32 -0700578
579 typedef SkPaintFilterCanvas INHERITED;
reed@google.comf0b5f682011-03-11 20:08:25 +0000580};
581
reed@android.comf2b98d62010-12-20 18:26:13 +0000582///////////////////////////////////////////////////////////////////////////////
583
reed54dc4872016-09-13 08:09:45 -0700584class SampleTFSerializer : public SkTypefaceSerializer {
585public:
586 sk_sp<SkData> serialize(SkTypeface* tf) override {
587 tf->ref();
588 return SkData::MakeWithCopy(&tf, sizeof(tf));
589 }
590};
591
592class SampleTFDeserializer : public SkTypefaceDeserializer {
593public:
594 sk_sp<SkTypeface> deserialize(const void* data, size_t size) override {
595 SkASSERT(sizeof(SkTypeface*) == size);
596 SkTypeface* tf;
597 memcpy(&tf, data, size);
598 return sk_sp<SkTypeface>(tf); // this was ref'd in SampleTFSerializer
599 }
600};
601
602///////////////////////////////////////////////////////////////////////////////
603
commit-bot@chromium.orgcc63b322013-12-06 20:14:55 +0000604enum TilingMode {
605 kNo_Tiling,
606 kAbs_128x128_Tiling,
607 kAbs_256x256_Tiling,
608 kRel_4x4_Tiling,
609 kRel_1x16_Tiling,
610 kRel_16x1_Tiling,
611
612 kLast_TilingMode_Enum
613};
614
615struct TilingInfo {
616 const char* label;
617 SkScalar w, h;
618};
619
commit-bot@chromium.orgbbe43a92013-12-10 21:51:06 +0000620static const struct TilingInfo gTilingInfo[] = {
commit-bot@chromium.orgcc63b322013-12-06 20:14:55 +0000621 { "No tiling", SK_Scalar1 , SK_Scalar1 }, // kNo_Tiling
622 { "128x128" , SkIntToScalar(128), SkIntToScalar(128) }, // kAbs_128x128_Tiling
623 { "256x256" , SkIntToScalar(256), SkIntToScalar(256) }, // kAbs_256x256_Tiling
624 { "1/4x1/4" , SK_Scalar1 / 4 , SK_Scalar1 / 4 }, // kRel_4x4_Tiling
625 { "1/1x1/16" , SK_Scalar1 , SK_Scalar1 / 16 }, // kRel_1x16_Tiling
626 { "1/16x1/1" , SK_Scalar1 / 16 , SK_Scalar1 }, // kRel_16x1_Tiling
627};
bungeman99fe8222015-08-20 07:57:51 -0700628static_assert((SK_ARRAY_COUNT(gTilingInfo) == kLast_TilingMode_Enum),
629 "Incomplete_tiling_labels");
commit-bot@chromium.orgcc63b322013-12-06 20:14:55 +0000630
commit-bot@chromium.orgbbe43a92013-12-10 21:51:06 +0000631SkSize SampleWindow::tileSize() const {
632 SkASSERT((TilingMode)fTilingMode < kLast_TilingMode_Enum);
633 const struct TilingInfo* info = gTilingInfo + fTilingMode;
634 return SkSize::Make(info->w > SK_Scalar1 ? info->w : this->width() * info->w,
635 info->h > SK_Scalar1 ? info->h : this->height() * info->h);
636}
commit-bot@chromium.orgcc63b322013-12-06 20:14:55 +0000637//////////////////////////////////////////////////////////////////////////////
638
reed@android.comf2b98d62010-12-20 18:26:13 +0000639static SkView* curr_view(SkWindow* wind) {
640 SkView::F2BIter iter(wind);
641 return iter.next();
642}
643
mike@reedtribe.org6f6e8c32011-12-27 22:33:50 +0000644static bool curr_title(SkWindow* wind, SkString* title) {
645 SkView* view = curr_view(wind);
646 if (view) {
647 SkEvent evt(gTitleEvtName);
648 if (view->doQuery(&evt)) {
649 title->set(evt.findString(gTitleEvtName));
650 return true;
651 }
652 }
653 return false;
654}
655
reedd9adfe62015-02-01 19:01:04 -0800656bool SampleWindow::sendAnimatePulse() {
657 SkView* view = curr_view(this);
658 if (SampleView::IsSampleView(view)) {
reed76113a92015-02-02 12:55:02 -0800659 return ((SampleView*)view)->animate(gAnimTimer);
reedd9adfe62015-02-01 19:01:04 -0800660 }
661 return false;
662}
663
reed5f629b42015-08-15 11:57:23 -0700664void SampleWindow::setZoomCenter(float x, float y) {
commit-bot@chromium.org4b413c82013-11-25 19:44:07 +0000665 fZoomCenterX = x;
666 fZoomCenterY = y;
Scroggo2c8208f2011-06-15 16:49:08 +0000667}
reed@android.com8a1c16f2008-12-17 15:59:43 +0000668
reed5f629b42015-08-15 11:57:23 -0700669bool SampleWindow::zoomIn() {
Scroggo0f185c22011-03-24 18:35:50 +0000670 // Arbitrarily decided
reed5f629b42015-08-15 11:57:23 -0700671 if (fFatBitsScale == kMaxFatBitsScale) return false;
Scroggo0f185c22011-03-24 18:35:50 +0000672 fFatBitsScale++;
halcanary96fcdcc2015-08-27 07:41:13 -0700673 this->inval(nullptr);
Scroggo0f185c22011-03-24 18:35:50 +0000674 return true;
675}
676
reed5f629b42015-08-15 11:57:23 -0700677bool SampleWindow::zoomOut() {
Scroggo0f185c22011-03-24 18:35:50 +0000678 if (fFatBitsScale == 1) return false;
679 fFatBitsScale--;
halcanary96fcdcc2015-08-27 07:41:13 -0700680 this->inval(nullptr);
Scroggo0f185c22011-03-24 18:35:50 +0000681 return true;
682}
683
reed5f629b42015-08-15 11:57:23 -0700684void SampleWindow::updatePointer(int x, int y) {
Scroggo0f185c22011-03-24 18:35:50 +0000685 fMouseX = x;
686 fMouseY = y;
687 if (fShowZoomer) {
halcanary96fcdcc2015-08-27 07:41:13 -0700688 this->inval(nullptr);
Scroggo0f185c22011-03-24 18:35:50 +0000689 }
690}
691
bsalomon@google.com098e96d2011-07-14 14:30:46 +0000692static inline SampleWindow::DeviceType cycle_devicetype(SampleWindow::DeviceType ct) {
693 static const SampleWindow::DeviceType gCT[] = {
kkinnunen8686a5e2016-01-05 00:04:32 -0800694 SampleWindow::kRaster_DeviceType
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000695#if SK_SUPPORT_GPU
kkinnunen8686a5e2016-01-05 00:04:32 -0800696 , SampleWindow::kGPU_DeviceType
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000697#if SK_ANGLE
kkinnunen8686a5e2016-01-05 00:04:32 -0800698 , SampleWindow::kANGLE_DeviceType
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000699#endif // SK_ANGLE
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +0000700#endif // SK_SUPPORT_GPU
reed@android.com8a1c16f2008-12-17 15:59:43 +0000701 };
bungeman99fe8222015-08-20 07:57:51 -0700702 static_assert(SK_ARRAY_COUNT(gCT) == SampleWindow::kDeviceTypeCnt, "array_size_mismatch");
reed@android.com8a1c16f2008-12-17 15:59:43 +0000703 return gCT[ct];
704}
705
edisonn@google.comf8b6b012013-07-11 14:28:04 +0000706static SkString getSampleTitle(const SkViewFactory* sampleFactory) {
707 SkView* view = (*sampleFactory)();
708 SkString title;
709 SampleCode::RequestTitle(view, &title);
710 view->unref();
711 return title;
712}
713
edisonn@google.comde36b692013-07-11 15:40:31 +0000714static bool compareSampleTitle(const SkViewFactory* first, const SkViewFactory* second) {
edisonn@google.comf8b6b012013-07-11 14:28:04 +0000715 return strcmp(getSampleTitle(first).c_str(), getSampleTitle(second).c_str()) < 0;
robertphillips@google.com8570b5c2012-03-20 17:40:58 +0000716}
717
reedb7ffe032015-11-05 11:59:17 -0800718static int find_by_title(const SkViewFactory* const* factories, int count, const char title[]) {
719 for (int i = 0; i < count; i++) {
720 if (getSampleTitle(factories[i]).equals(title)) {
721 return i;
722 }
723 }
724 return -1;
725}
726
727static void restrict_samples(SkTDArray<const SkViewFactory*>& factories, const SkString titles[],
728 int count) {
729 int newCount = 0;
730 for (int i = 0; i < count; ++i) {
731 int index = find_by_title(factories.begin(), factories.count(), titles[i].c_str());
732 if (index >= 0) {
733 SkTSwap(factories.begin()[newCount], factories.begin()[index]);
734 newCount += 1;
735 }
736 }
737 if (newCount) {
738 factories.setCount(newCount);
739 }
740}
741
mtkleinfd117d82014-06-19 14:18:56 -0700742DEFINE_string(slide, "", "Start on this sample.");
mtkleinfd117d82014-06-19 14:18:56 -0700743DEFINE_string(pictureDir, "", "Read pictures from here.");
744DEFINE_string(picture, "", "Path to single picture.");
csmartdalton8c679092017-03-27 12:32:29 -0600745DEFINE_string(pathfinder, "", "SKP file with a single path to isolate.");
fmalita6ceef3d2016-07-26 18:46:34 -0700746DEFINE_string(svg, "", "Path to single SVG file.");
747DEFINE_string(svgDir, "", "Read SVGs from here.");
reedb7ffe032015-11-05 11:59:17 -0800748DEFINE_string(sequence, "", "Path to file containing the desired samples/gms to show.");
mtkleinfd117d82014-06-19 14:18:56 -0700749DEFINE_bool(sort, false, "Sort samples by title.");
750DEFINE_bool(list, false, "List samples?");
Jim Van Verthb6c5e532016-10-28 10:38:08 -0400751DEFINE_bool(startgpu, false, "Start up with gpu?");
brianosmanca348462016-02-24 11:47:47 -0800752DEFINE_bool(redraw, false, "Force continuous redrawing, for profiling or debugging tools.");
mtkleinfd117d82014-06-19 14:18:56 -0700753#ifdef SAMPLE_PDF_FILE_VIEWER
754DEFINE_string(pdfPath, "", "Path to direcotry of pdf files.");
755#endif
csmartdalton008b9d82017-02-22 12:00:42 -0700756#if SK_SUPPORT_GPU
757DEFINE_pathrenderer_flag;
758DEFINE_int32(msaa, 0, "Request multisampling with this count.");
759DEFINE_bool(deepColor, false, "Request deep color (10-bit/channel or more) display buffer.");
760#endif
Yuqian Li94fddf82017-09-25 14:45:25 -0400761DEFINE_int32(backendTiles, 0, "Number of tiles in the experimental threaded backend.");
762DEFINE_int32(backendThreads, 0, "Number of threads in the experimental threaded backend.");
763DEFINE_int32(measureMS, 0, "Number of miliseconds to measure the FPS before closing the SampleApp. "
764 "If it's 0, we won't measure the FPS or close SampleApp automatically.");
Yuqian Li6e3d9952017-09-27 13:25:36 -0400765DEFINE_int32(width, 1024, "Width of the window");
766DEFINE_int32(height, 768, "Height of the window");
mtkleinfd117d82014-06-19 14:18:56 -0700767
reed89889b62014-10-29 12:36:45 -0700768#include "SkTaskGroup.h"
769
chudy@google.com4605a3f2012-08-01 17:58:01 +0000770SampleWindow::SampleWindow(void* hwnd, int argc, char** argv, DeviceManager* devManager)
Yuqian Li6e3d9952017-09-27 13:25:36 -0400771 : INHERITED(hwnd, FLAGS_width, FLAGS_height)
halcanary96fcdcc2015-08-27 07:41:13 -0700772 , fDevManager(nullptr) {
robertphillips@google.com8570b5c2012-03-20 17:40:58 +0000773
reed@google.com7d05ac92013-06-06 13:14:13 +0000774 fCurrIndex = -1;
775
mtkleinfd117d82014-06-19 14:18:56 -0700776 if (!FLAGS_pictureDir.isEmpty()) {
777 SkOSFile::Iter iter(FLAGS_pictureDir[0], "skp");
778 SkString filename;
779 while (iter.next(&filename)) {
780 *fSamples.append() = new PictFileFactory(
tfarinaa8e2e152014-07-28 19:26:58 -0700781 SkOSPath::Join(FLAGS_pictureDir[0], filename.c_str()));
mtkleinfd117d82014-06-19 14:18:56 -0700782 }
783 }
784 if (!FLAGS_picture.isEmpty()) {
785 SkString path(FLAGS_picture[0]);
786 fCurrIndex = fSamples.count();
787 *fSamples.append() = new PictFileFactory(path);
788 }
csmartdalton8c679092017-03-27 12:32:29 -0600789 if (!FLAGS_pathfinder.isEmpty()) {
790 SkString path(FLAGS_pathfinder[0]);
791 fCurrIndex = fSamples.count();
792 *fSamples.append() = new PathFinderFactory(path);
793 }
fmalita6ceef3d2016-07-26 18:46:34 -0700794 if (!FLAGS_svg.isEmpty()) {
795 SkString path(FLAGS_svg[0]);
796 fCurrIndex = fSamples.count();
797 *fSamples.append() = new SVGFileFactory(path);
798 }
799 if (!FLAGS_svgDir.isEmpty()) {
800 SkOSFile::Iter iter(FLAGS_svgDir[0], "svg");
801 SkString filename;
802 while (iter.next(&filename)) {
803 *fSamples.append() = new SVGFileFactory(
804 SkOSPath::Join(FLAGS_svgDir[0], filename.c_str()));
805 }
806 }
edisonn@google.comf8b6b012013-07-11 14:28:04 +0000807#ifdef SAMPLE_PDF_FILE_VIEWER
mtkleinfd117d82014-06-19 14:18:56 -0700808 if (!FLAGS_pdfPath.isEmpty()) {
809 SkOSFile::Iter iter(FLAGS_pdfPath[0], "pdf");
810 SkString filename;
811 while (iter.next(&filename)) {
812 *fSamples.append() = new PdfFileViewerFactory(
tfarinaa8e2e152014-07-28 19:26:58 -0700813 SkOSPath::Join(FLAGS_pictureDir[0], filename.c_str()));
mtkleinfd117d82014-06-19 14:18:56 -0700814 }
815 }
816#endif
robertphillips@google.com76d40212012-03-22 14:12:15 +0000817 SkGMRegistyToSampleRegistry();
818 {
819 const SkViewRegister* reg = SkViewRegister::Head();
820 while (reg) {
821 *fSamples.append() = reg->factory();
822 reg = reg->next();
823 }
824 }
825
reedb7ffe032015-11-05 11:59:17 -0800826 if (!FLAGS_sequence.isEmpty()) {
827 // The sequence file just contains a list (separated by CRs) of the samples or GM:gms
828 // you want to restrict to. Only these will appear when you cycle through.
829 // If none are found, or the file is empty, then it will be ignored, and all samples
830 // will be available.
831 SkFILEStream stream(FLAGS_sequence[0]);
832 if (stream.isValid()) {
833 size_t len = stream.getLength();
scroggo565901d2015-12-10 10:44:13 -0800834 SkAutoTMalloc<char> storage(len + 1);
835 char* buffer = storage.get();
reedb7ffe032015-11-05 11:59:17 -0800836 stream.read(buffer, len);
837 buffer[len] = 0;
838
839 SkTArray<SkString> titles;
840 SkStrSplit(buffer, "\n\r", &titles);
841 restrict_samples(fSamples, titles.begin(), titles.count());
842 }
843 }
844
mtkleinfd117d82014-06-19 14:18:56 -0700845 if (FLAGS_sort) {
edisonn@google.comf8b6b012013-07-11 14:28:04 +0000846 // Sort samples, so foo.skp and foo.pdf are consecutive and we can quickly spot where
847 // skp -> pdf -> png fails.
halcanary96fcdcc2015-08-27 07:41:13 -0700848 SkTQSort(fSamples.begin(), fSamples.end() ? fSamples.end() - 1 : nullptr, compareSampleTitle);
edisonn@google.comf8b6b012013-07-11 14:28:04 +0000849 }
850
mtkleinfd117d82014-06-19 14:18:56 -0700851 if (!FLAGS_slide.isEmpty()) {
852 fCurrIndex = findByTitle(FLAGS_slide[0]);
853 if (fCurrIndex < 0) {
854 fprintf(stderr, "Unknown sample \"%s\"\n", FLAGS_slide[0]);
robertphillips@google.com7265e722012-05-03 18:22:28 +0000855 listTitles();
bsalomon@google.com11959252012-04-06 20:13:38 +0000856 }
mtkleinfd117d82014-06-19 14:18:56 -0700857 }
858
csmartdalton008b9d82017-02-22 12:00:42 -0700859#if SK_SUPPORT_GPU
860 fBackendOptions.fGrContextOptions.fGpuPathRenderers = CollectGpuPathRenderersFromFlags();
861 fBackendOptions.fMSAASampleCount = FLAGS_msaa;
862 fBackendOptions.fDeepColor = FLAGS_deepColor;
863#endif
brianosman35a02a82016-09-29 14:37:02 -0700864 fColorConfigIndex = 0;
mtkleinfd117d82014-06-19 14:18:56 -0700865
866 if (FLAGS_list) {
867 listTitles();
robertphillips@google.com8570b5c2012-03-20 17:40:58 +0000868 }
869
870 if (fCurrIndex < 0) {
871 SkString title;
872 if (readTitleFromPrefs(&title)) {
873 fCurrIndex = findByTitle(title.c_str());
874 }
875 }
876
877 if (fCurrIndex < 0) {
878 fCurrIndex = 0;
879 }
880
reed89889b62014-10-29 12:36:45 -0700881 static SkTaskGroup::Enabler enabled(-1);
reed@google.com3cec4d72011-07-06 13:59:47 +0000882 gSampleWindow = this;
883
robertphillips@google.combd8d7ad2012-03-30 15:18:14 +0000884 fDeviceType = kRaster_DeviceType;
jvanverth41518eb2015-10-02 10:42:36 -0700885#if SK_SUPPORT_GPU
Jim Van Verthb6c5e532016-10-28 10:38:08 -0400886 if (FLAGS_startgpu) {
jvanverth44dcb8a2015-10-02 09:12:05 -0700887 fDeviceType = kGPU_DeviceType;
888 }
jvanverth41518eb2015-10-02 10:42:36 -0700889#endif
halcanary9d524f22016-03-29 09:03:52 -0700890
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000891#if DEFAULT_TO_GPU
892 fDeviceType = kGPU_DeviceType;
reed@android.comf2b98d62010-12-20 18:26:13 +0000893#endif
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000894#if SK_ANGLE && DEFAULT_TO_ANGLE
895 fDeviceType = kANGLE_DeviceType;
896#endif
897
reed@android.com8a1c16f2008-12-17 15:59:43 +0000898 fUseClip = false;
reed91b4dfb2016-01-08 08:23:19 -0800899 fUsePicture = false;
reed@android.com8a1c16f2008-12-17 15:59:43 +0000900 fAnimating = false;
reed@android.com6c5f6f22009-08-14 16:08:38 +0000901 fRotate = false;
bsalomon@google.come8f09102011-09-08 18:48:12 +0000902 fPerspAnim = false;
reed@android.comf2b98d62010-12-20 18:26:13 +0000903 fRequestGrabImage = false;
commit-bot@chromium.orgcc63b322013-12-06 20:14:55 +0000904 fTilingMode = kNo_Tiling;
mike@reedtribe.org2eb59522011-04-22 01:59:09 +0000905 fMeasureFPS = false;
reedbabc3de2016-07-08 08:43:27 -0700906 fUseDeferredCanvas = false;
yangsu@google.comdb03eaa2011-08-08 15:37:23 +0000907 fLCDState = SkOSMenu::kMixedState;
908 fAAState = SkOSMenu::kMixedState;
bungeman@google.com96aabc82013-06-03 21:26:34 +0000909 fSubpixelState = SkOSMenu::kMixedState;
910 fHintingState = 0;
bungeman5a59a422016-03-31 08:30:38 -0700911 fPixelGeometryIndex = 0;
reed93a12152015-03-16 10:08:34 -0700912 fFilterQualityIndex = 0;
reed@google.com569e0432011-04-05 13:07:03 +0000913 fFlipAxis = 0;
reed@android.com8a1c16f2008-12-17 15:59:43 +0000914
Scroggo0f185c22011-03-24 18:35:50 +0000915 fMouseX = fMouseY = 0;
mike@reedtribe.org3ce59dc2011-04-08 00:38:05 +0000916 fFatBitsScale = 8;
reed5755cd92016-08-21 19:30:13 -0700917 fTypeface = SkTypeface::MakeFromName("Courier", SkFontStyle(SkFontStyle::kBold_Weight,
918 SkFontStyle::kNormal_Width,
919 SkFontStyle::kUpright_Slant));
Scroggo0f185c22011-03-24 18:35:50 +0000920 fShowZoomer = false;
chudy@google.com4605a3f2012-08-01 17:58:01 +0000921
mike@reedtribe.orgdd0cd342011-03-21 00:53:39 +0000922 fZoomLevel = 0;
923 fZoomScale = SK_Scalar1;
bungemance560262016-03-03 13:32:38 -0800924 fOffset = { 0, 0 };
chudy@google.com4605a3f2012-08-01 17:58:01 +0000925
yangsu@google.comdb03eaa2011-08-08 15:37:23 +0000926 fMagnify = false;
chudy@google.com4605a3f2012-08-01 17:58:01 +0000927
Scroggo8ac0d542011-06-21 14:44:57 +0000928 fSaveToPdf = false;
reed093b4e82015-08-04 18:46:38 -0700929 fSaveToSKP = false;
chudy@google.com4605a3f2012-08-01 17:58:01 +0000930
Yuqian Li94fddf82017-09-25 14:45:25 -0400931 gSkUseAnalyticAA = FLAGS_analyticAA;
932 gSkUseDeltaAA = FLAGS_deltaAA;
933 if (FLAGS_forceAnalyticAA) {
934 gSkForceAnalyticAA = true;
935 }
936 if (FLAGS_forceDeltaAA) {
937 gSkForceDeltaAA = true;
938 }
939 fTiles = FLAGS_backendTiles;
940 fThreads = FLAGS_backendThreads;
941 fMeasureMS = FLAGS_measureMS;
942 if (FLAGS_measureMS > 0) {
943 SkASSERT(fMeasureFPS == false);
944 toggleFPS();
945 }
946
reed54dc4872016-09-13 08:09:45 -0700947 if (true) {
948 fPipeSerializer.setTypefaceSerializer(new SampleTFSerializer);
949 fPipeDeserializer.setTypefaceDeserializer(new SampleTFDeserializer);
950 }
951
yangsu@google.com921091f2011-08-02 13:39:12 +0000952 int sinkID = this->getSinkID();
scroggo@google.com7dadc742012-04-18 14:07:57 +0000953 fAppMenu = new SkOSMenu;
954 fAppMenu->setTitle("Global Settings");
yangsu@google.comdb03eaa2011-08-08 15:37:23 +0000955 int itemID;
chudy@google.com4605a3f2012-08-01 17:58:01 +0000956
reeda34be682016-02-15 07:48:35 -0800957 itemID = fAppMenu->appendList("ColorType", "ColorType", sinkID, 0,
brianosman35a02a82016-09-29 14:37:02 -0700958 gConfig[0].fName,
959 gConfig[1].fName,
960 gConfig[2].fName,
961 gConfig[3].fName,
Brian Osmanfc2e7e02016-12-02 12:10:36 -0500962 gConfig[4].fName,
brianosman35a02a82016-09-29 14:37:02 -0700963 nullptr);
reeda34be682016-02-15 07:48:35 -0800964 fAppMenu->assignKeyEquivalentToItem(itemID, 'C');
965
kkinnunen8686a5e2016-01-05 00:04:32 -0800966 itemID = fAppMenu->appendList("Device Type", "Device Type", sinkID, 0,
967 "Raster",
968 "OpenGL",
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000969#if SK_ANGLE
kkinnunen8686a5e2016-01-05 00:04:32 -0800970 "ANGLE",
robertphillips@google.comb442a6d2012-04-02 19:24:21 +0000971#endif
kkinnunen8686a5e2016-01-05 00:04:32 -0800972 nullptr);
scroggo@google.com7dadc742012-04-18 14:07:57 +0000973 fAppMenu->assignKeyEquivalentToItem(itemID, 'd');
974 itemID = fAppMenu->appendTriState("AA", "AA", sinkID, fAAState);
975 fAppMenu->assignKeyEquivalentToItem(itemID, 'b');
976 itemID = fAppMenu->appendTriState("LCD", "LCD", sinkID, fLCDState);
977 fAppMenu->assignKeyEquivalentToItem(itemID, 'l');
reed93a12152015-03-16 10:08:34 -0700978 itemID = fAppMenu->appendList("FilterQuality", "FilterQuality", sinkID, fFilterQualityIndex,
979 gFilterQualityStates[0].fName,
980 gFilterQualityStates[1].fName,
981 gFilterQualityStates[2].fName,
982 gFilterQualityStates[3].fName,
983 gFilterQualityStates[4].fName,
halcanary96fcdcc2015-08-27 07:41:13 -0700984 nullptr);
scroggo@google.com7dadc742012-04-18 14:07:57 +0000985 fAppMenu->assignKeyEquivalentToItem(itemID, 'n');
bungeman@google.com96aabc82013-06-03 21:26:34 +0000986 itemID = fAppMenu->appendTriState("Subpixel", "Subpixel", sinkID, fSubpixelState);
987 fAppMenu->assignKeyEquivalentToItem(itemID, 's');
988 itemID = fAppMenu->appendList("Hinting", "Hinting", sinkID, fHintingState,
989 gHintingStates[0].name,
990 gHintingStates[1].name,
991 gHintingStates[2].name,
992 gHintingStates[3].name,
bungeman@google.coma9133bb2013-06-04 17:49:20 +0000993 gHintingStates[4].name,
halcanary96fcdcc2015-08-27 07:41:13 -0700994 nullptr);
scroggo@google.com7dadc742012-04-18 14:07:57 +0000995 fAppMenu->assignKeyEquivalentToItem(itemID, 'h');
reed@google.com67b89ee2012-08-15 14:41:58 +0000996
bungeman5a59a422016-03-31 08:30:38 -0700997 itemID = fAppMenu->appendList("Pixel Geometry", "Pixel Geometry", sinkID, fPixelGeometryIndex,
998 gPixelGeometryStates[0].name,
999 gPixelGeometryStates[1].name,
1000 gPixelGeometryStates[2].name,
1001 gPixelGeometryStates[3].name,
1002 gPixelGeometryStates[4].name,
1003 gPixelGeometryStates[5].name,
1004 nullptr);
1005 fAppMenu->assignKeyEquivalentToItem(itemID, 'P');
1006
commit-bot@chromium.orgcc63b322013-12-06 20:14:55 +00001007 itemID =fAppMenu->appendList("Tiling", "Tiling", sinkID, fTilingMode,
1008 gTilingInfo[kNo_Tiling].label,
1009 gTilingInfo[kAbs_128x128_Tiling].label,
1010 gTilingInfo[kAbs_256x256_Tiling].label,
1011 gTilingInfo[kRel_4x4_Tiling].label,
1012 gTilingInfo[kRel_1x16_Tiling].label,
1013 gTilingInfo[kRel_16x1_Tiling].label,
halcanary96fcdcc2015-08-27 07:41:13 -07001014 nullptr);
reed@google.com67b89ee2012-08-15 14:41:58 +00001015 fAppMenu->assignKeyEquivalentToItem(itemID, 't');
1016
chudy@google.com4605a3f2012-08-01 17:58:01 +00001017 itemID = fAppMenu->appendSwitch("Slide Show", "Slide Show" , sinkID, false);
1018 fAppMenu->assignKeyEquivalentToItem(itemID, 'a');
1019 itemID = fAppMenu->appendSwitch("Clip", "Clip" , sinkID, fUseClip);
scroggo@google.com7dadc742012-04-18 14:07:57 +00001020 fAppMenu->assignKeyEquivalentToItem(itemID, 'c');
chudy@google.com4605a3f2012-08-01 17:58:01 +00001021 itemID = fAppMenu->appendSwitch("Flip X", "Flip X" , sinkID, false);
scroggo@google.com7dadc742012-04-18 14:07:57 +00001022 fAppMenu->assignKeyEquivalentToItem(itemID, 'x');
1023 itemID = fAppMenu->appendSwitch("Flip Y", "Flip Y" , sinkID, false);
1024 fAppMenu->assignKeyEquivalentToItem(itemID, 'y');
1025 itemID = fAppMenu->appendSwitch("Zoomer", "Zoomer" , sinkID, fShowZoomer);
1026 fAppMenu->assignKeyEquivalentToItem(itemID, 'z');
1027 itemID = fAppMenu->appendSwitch("Magnify", "Magnify" , sinkID, fMagnify);
1028 fAppMenu->assignKeyEquivalentToItem(itemID, 'm');
reed093b4e82015-08-04 18:46:38 -07001029
scroggo@google.com7dadc742012-04-18 14:07:57 +00001030 itemID = fAppMenu->appendAction("Save to PDF", sinkID);
1031 fAppMenu->assignKeyEquivalentToItem(itemID, 'e');
chudy@google.com4605a3f2012-08-01 17:58:01 +00001032
scroggo@google.com7dadc742012-04-18 14:07:57 +00001033 this->addMenu(fAppMenu);
1034 fSlideMenu = new SkOSMenu;
1035 this->addMenu(fSlideMenu);
chudy@google.com4605a3f2012-08-01 17:58:01 +00001036
bsalomon@google.com2fbc7fa2011-01-05 16:34:41 +00001037 this->setVisibleP(true);
reed@android.comf2b98d62010-12-20 18:26:13 +00001038 this->setClipToBounds(false);
reed@android.com8a1c16f2008-12-17 15:59:43 +00001039
bsalomon@google.com48dd1a22011-10-31 14:18:20 +00001040 this->loadView((*fSamples[fCurrIndex])());
chudy@google.com4605a3f2012-08-01 17:58:01 +00001041
halcanary96fcdcc2015-08-27 07:41:13 -07001042 if (nullptr == devManager) {
bsalomon@google.com098e96d2011-07-14 14:30:46 +00001043 fDevManager = new DefaultDeviceManager();
1044 } else {
1045 devManager->ref();
1046 fDevManager = devManager;
1047 }
csmartdalton008b9d82017-02-22 12:00:42 -07001048 fDevManager->setUpBackend(this, fBackendOptions);
bsalomon@google.com098e96d2011-07-14 14:30:46 +00001049
Scroggob4490c72011-06-17 13:53:05 +00001050 // If another constructor set our dimensions, ensure that our
1051 // onSizeChange gets called.
1052 if (this->height() && this->width()) {
1053 this->onSizeChange();
1054 }
reed@google.com2072db82011-11-08 15:18:10 +00001055
1056 // can't call this synchronously, since it may require a subclass to
1057 // to implement, or the caller may need us to have returned from the
1058 // constructor first. Hence we post an event to ourselves.
1059// this->updateTitle();
commit-bot@chromium.org6de4a782013-12-11 17:05:23 +00001060 post_event_to_sink(new SkEvent(gUpdateWindowTitleEvtName), this);
reed76113a92015-02-02 12:55:02 -08001061
1062 gAnimTimer.run();
reed@android.com8a1c16f2008-12-17 15:59:43 +00001063}
1064
1065SampleWindow::~SampleWindow() {
Yuqian Li94fddf82017-09-25 14:45:25 -04001066 if (fMeasureFPS) {
1067 SkDebugf("Average frame time of the last slide: %.4f ms\n",
1068 fCumulativeFPS_Time / (float)SkTMax(1, fCumulativeFPS_Count));
1069 }
bsalomon@google.com098e96d2011-07-14 14:30:46 +00001070 SkSafeUnref(fDevManager);
reed@android.com8a1c16f2008-12-17 15:59:43 +00001071}
1072
edisonn@google.comf8b6b012013-07-11 14:28:04 +00001073
mike@reedtribe.org6f6e8c32011-12-27 22:33:50 +00001074int SampleWindow::findByTitle(const char title[]) {
1075 int i, count = fSamples.count();
1076 for (i = 0; i < count; i++) {
1077 if (getSampleTitle(i).equals(title)) {
1078 return i;
1079 }
1080 }
mike@reedtribe.orgdd52caa2011-12-28 20:02:10 +00001081 return -1;
mike@reedtribe.org6f6e8c32011-12-27 22:33:50 +00001082}
1083
robertphillips@google.com7265e722012-05-03 18:22:28 +00001084void SampleWindow::listTitles() {
1085 int count = fSamples.count();
1086 SkDebugf("All Slides:\n");
1087 for (int i = 0; i < count; i++) {
1088 SkDebugf(" %s\n", getSampleTitle(i).c_str());
1089 }
1090}
1091
reed@android.com55e76b22009-11-23 21:46:47 +00001092static SkBitmap capture_bitmap(SkCanvas* canvas) {
1093 SkBitmap bm;
reed84825042014-09-02 12:50:45 -07001094 if (bm.tryAllocPixels(canvas->imageInfo())) {
Mike Reed12e946b2017-04-17 10:53:29 -04001095 canvas->readPixels(bm, 0, 0);
commit-bot@chromium.orgc3bd8af2014-02-13 17:14:46 +00001096 }
reed@android.com55e76b22009-11-23 21:46:47 +00001097 return bm;
1098}
1099
reedf7f79d22015-02-21 09:03:20 -08001100static void drawText(SkCanvas* canvas, SkString str, SkScalar left, SkScalar top, SkPaint& paint) {
Scroggo0f185c22011-03-24 18:35:50 +00001101 SkColor desiredColor = paint.getColor();
1102 paint.setColor(SK_ColorWHITE);
reedf7f79d22015-02-21 09:03:20 -08001103 const char* c_str = str.c_str();
1104 size_t size = str.size();
Scroggo0f185c22011-03-24 18:35:50 +00001105 SkRect bounds;
1106 paint.measureText(c_str, size, &bounds);
1107 bounds.offset(left, top);
1108 SkScalar inset = SkIntToScalar(-2);
1109 bounds.inset(inset, inset);
1110 canvas->drawRect(bounds, paint);
Scroggo0f185c22011-03-24 18:35:50 +00001111 paint.setColor(desiredColor);
1112 canvas->drawText(c_str, size, left, top, paint);
1113}
1114
reed@android.com44177402009-11-23 21:07:51 +00001115#define XCLIP_N 8
1116#define YCLIP_N 8
reed@android.come522ca52009-11-23 20:10:41 +00001117
reedbabc3de2016-07-08 08:43:27 -07001118#include "SkDeferredCanvas.h"
1119#include "SkDumpCanvas.h"
1120
reed@android.come522ca52009-11-23 20:10:41 +00001121void SampleWindow::draw(SkCanvas* canvas) {
Yuqian Lib55dd552017-04-03 10:52:48 -04001122 std::unique_ptr<SkThreadedBMPDevice> tDev;
1123 std::unique_ptr<SkCanvas> tCanvas;
Yuqian Li70898af2017-06-05 13:36:32 -04001124 if (fTiles > 0 && fDeviceType == kRaster_DeviceType) {
Yuqian Liba0ce4b2017-09-01 14:24:40 -04001125 // Temporary hack: let the device create/destroy the thread pool between each frame somehow
1126 // makes it faster when we draw the same path 100 times when fMeasureFPS is true.
1127 SkExecutor* executor = fMeasureFPS ? nullptr : fExecutor.get();
1128 tDev.reset(new SkThreadedBMPDevice(this->getBitmap(), fTiles, fThreads, executor));
Yuqian Lib55dd552017-04-03 10:52:48 -04001129 tCanvas.reset(new SkCanvas(tDev.get()));
1130 canvas = tCanvas.get();
1131 }
1132
reed76113a92015-02-02 12:55:02 -08001133 gAnimTimer.updateTime();
chudy@google.com4605a3f2012-08-01 17:58:01 +00001134
reed@google.comf03bb562011-11-11 21:42:12 +00001135 if (fGesture.isActive()) {
1136 this->updateMatrix();
reed@google.com52f57e12011-03-16 12:10:02 +00001137 }
chudy@google.com4605a3f2012-08-01 17:58:01 +00001138
djsollen@google.com796763e2012-12-10 14:12:55 +00001139 if (fMeasureFPS) {
1140 fMeasureFPS_Time = 0;
1141 }
1142
reedf7f79d22015-02-21 09:03:20 -08001143 SkSize tile = this->tileSize();
reed@android.come522ca52009-11-23 20:10:41 +00001144
reedf7f79d22015-02-21 09:03:20 -08001145 if (kNo_Tiling == fTilingMode) {
reedbabc3de2016-07-08 08:43:27 -07001146 SkDebugfDumper dumper;
1147 SkDumpCanvas dump(&dumper);
Herb Derby1a3c4b82017-03-17 15:51:53 -04001148 SkDeferredCanvas deferred(canvas, SkDeferredCanvas::kEager);
reedbabc3de2016-07-08 08:43:27 -07001149 SkCanvas* c = fUseDeferredCanvas ? &deferred : canvas;
1150 this->INHERITED::draw(c); // no looping or surfaces needed
reed@android.come522ca52009-11-23 20:10:41 +00001151 } else {
bungemance560262016-03-03 13:32:38 -08001152 const SkScalar w = SkScalarCeilToScalar(tile.width());
1153 const SkScalar h = SkScalarCeilToScalar(tile.height());
1154 SkImageInfo info = SkImageInfo::MakeN32Premul(SkScalarTruncToInt(w), SkScalarTruncToInt(h));
reede8f30622016-03-23 18:59:25 -07001155 auto surface(canvas->makeSurface(info));
reedf7f79d22015-02-21 09:03:20 -08001156 SkCanvas* tileCanvas = surface->getCanvas();
rmistry@google.comae933ce2012-08-23 18:19:56 +00001157
bungemance560262016-03-03 13:32:38 -08001158 for (SkScalar y = 0; y < height(); y += h) {
1159 for (SkScalar x = 0; x < width(); x += w) {
reedf7f79d22015-02-21 09:03:20 -08001160 SkAutoCanvasRestore acr(tileCanvas, true);
1161 tileCanvas->translate(-x, -y);
1162 tileCanvas->clear(0);
1163 this->INHERITED::draw(tileCanvas);
halcanary96fcdcc2015-08-27 07:41:13 -07001164 surface->draw(canvas, x, y, nullptr);
commit-bot@chromium.org9a558d42014-05-30 15:06:24 +00001165 }
reedf7f79d22015-02-21 09:03:20 -08001166 }
commit-bot@chromium.org9a558d42014-05-30 15:06:24 +00001167
reedf7f79d22015-02-21 09:03:20 -08001168 // for drawing the borders between tiles
1169 SkPaint paint;
1170 paint.setColor(0x60FF00FF);
1171 paint.setStyle(SkPaint::kStroke_Style);
commit-bot@chromium.orgcc63b322013-12-06 20:14:55 +00001172
reedf7f79d22015-02-21 09:03:20 -08001173 for (SkScalar y = 0; y < height(); y += tile.height()) {
1174 for (SkScalar x = 0; x < width(); x += tile.width()) {
1175 canvas->drawRect(SkRect::MakeXYWH(x, y, tile.width(), tile.height()), paint);
scroggo@google.com85cade02012-08-17 13:29:50 +00001176 }
1177 }
reed@android.come522ca52009-11-23 20:10:41 +00001178 }
reedf7f79d22015-02-21 09:03:20 -08001179
bsalomon@google.com098e96d2011-07-14 14:30:46 +00001180 if (fShowZoomer && !fSaveToPdf) {
Scroggo3272ba82011-05-25 20:50:42 +00001181 showZoomer(canvas);
1182 }
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00001183 if (fMagnify && !fSaveToPdf) {
1184 magnify(canvas);
1185 }
chudy@google.com4605a3f2012-08-01 17:58:01 +00001186
djsollen@google.com796763e2012-12-10 14:12:55 +00001187 if (fMeasureFPS && fMeasureFPS_Time) {
1188 this->updateTitle();
1189 this->postInvalDelay();
1190 }
1191
brianosmanca348462016-02-24 11:47:47 -08001192 if (this->sendAnimatePulse() || FLAGS_redraw) {
halcanary96fcdcc2015-08-27 07:41:13 -07001193 this->inval(nullptr);
reedd9adfe62015-02-01 19:01:04 -08001194 }
1195
Yuqian Lib55dd552017-04-03 10:52:48 -04001196 canvas->flush();
Ben Wagner55963bc2017-07-24 15:00:35 +00001197
1198 // do this last
1199 fDevManager->publishCanvas(fDeviceType, canvas, this);
Scroggo3272ba82011-05-25 20:50:42 +00001200}
1201
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00001202static float clipW = 200;
1203static float clipH = 200;
1204void SampleWindow::magnify(SkCanvas* canvas) {
1205 SkRect r;
1206 int count = canvas->save();
chudy@google.com4605a3f2012-08-01 17:58:01 +00001207
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00001208 SkMatrix m = canvas->getTotalMatrix();
robertphillips@google.com07ef9112012-06-04 13:22:14 +00001209 if (!m.invert(&m)) {
1210 return;
1211 }
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00001212 SkPoint offset, center;
bsalomon@google.com820e80a2011-10-24 21:09:40 +00001213 SkScalar mouseX = fMouseX * SK_Scalar1;
1214 SkScalar mouseY = fMouseY * SK_Scalar1;
1215 m.mapXY(mouseX - clipW/2, mouseY - clipH/2, &offset);
1216 m.mapXY(mouseX, mouseY, &center);
chudy@google.com4605a3f2012-08-01 17:58:01 +00001217
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00001218 r.set(0, 0, clipW * m.getScaleX(), clipH * m.getScaleX());
1219 r.offset(offset.fX, offset.fY);
chudy@google.com4605a3f2012-08-01 17:58:01 +00001220
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00001221 SkPaint paint;
1222 paint.setColor(0xFF66AAEE);
1223 paint.setStyle(SkPaint::kStroke_Style);
bsalomon@google.com820e80a2011-10-24 21:09:40 +00001224 paint.setStrokeWidth(10.f * m.getScaleX());
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00001225 //lense offset
1226 //canvas->translate(0, -250);
1227 canvas->drawRect(r, paint);
1228 canvas->clipRect(r);
chudy@google.com4605a3f2012-08-01 17:58:01 +00001229
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00001230 m = canvas->getTotalMatrix();
1231 m.setTranslate(-center.fX, -center.fY);
bsalomon@google.com820e80a2011-10-24 21:09:40 +00001232 m.postScale(0.5f * fFatBitsScale, 0.5f * fFatBitsScale);
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00001233 m.postTranslate(center.fX, center.fY);
1234 canvas->concat(m);
chudy@google.com4605a3f2012-08-01 17:58:01 +00001235
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00001236 this->INHERITED::draw(canvas);
chudy@google.com4605a3f2012-08-01 17:58:01 +00001237
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00001238 canvas->restoreToCount(count);
1239}
1240
reed5f629b42015-08-15 11:57:23 -07001241static SkPaint& set_color_ref(SkPaint& paint, SkColor c) {
1242 paint.setColor(c);
1243 return paint;
1244}
reed@google.comb36334d2011-05-18 15:07:20 +00001245
reed5f629b42015-08-15 11:57:23 -07001246static void show_lcd_box(SkCanvas* canvas, SkScalar x, SkScalar y, SkColor c,
1247 SkScalar sx, SkScalar sy) {
1248 const SkScalar w = (1 - 1/sx) / 3;
1249 SkPaint paint;
1250 SkRect r = SkRect::MakeXYWH(x, y, w, 1 - 1/sy);
1251 canvas->drawRect(r, set_color_ref(paint, SkColorSetRGB(SkColorGetR(c), 0, 0)));
1252 r.offset(w, 0);
1253 canvas->drawRect(r, set_color_ref(paint, SkColorSetRGB(0, SkColorGetG(c), 0)));
1254 r.offset(w, 0);
1255 canvas->drawRect(r, set_color_ref(paint, SkColorSetRGB(0, 0, SkColorGetB(c))));
1256}
reed@google.comb36334d2011-05-18 15:07:20 +00001257
reed5f629b42015-08-15 11:57:23 -07001258static void show_lcd_circle(SkCanvas* canvas, SkScalar x, SkScalar y, SkColor c,
1259 SkScalar, SkScalar) {
1260 const SkRect r = SkRect::MakeXYWH(x, y, 1, 1);
1261 const SkScalar cx = x + 0.5f;
1262 const SkScalar cy = y + 0.5f;
1263
1264 SkPaint paint;
1265 paint.setAntiAlias(true);
1266
1267 SkPath path;
1268 path.addArc(r, 0, 120); path.lineTo(cx, cy);
1269 canvas->drawPath(path, set_color_ref(paint, SkColorSetRGB(SkColorGetR(c), 0, 0)));
1270
1271 path.reset(); path.addArc(r, 120, 120); path.lineTo(cx, cy);
1272 canvas->drawPath(path, set_color_ref(paint, SkColorSetRGB(0, SkColorGetG(c), 0)));
1273
1274 path.reset(); path.addArc(r, 240, 120); path.lineTo(cx, cy);
1275 canvas->drawPath(path, set_color_ref(paint, SkColorSetRGB(0, 0, SkColorGetB(c))));
1276}
1277
1278typedef void (*ShowLCDProc)(SkCanvas*, SkScalar, SkScalar, SkColor, SkScalar, SkScalar);
1279
1280/*
1281 * Like drawBitmapRect but we manually draw each pixels in RGB
1282 */
1283static void show_lcd_grid(SkCanvas* canvas, const SkBitmap& bitmap,
reed8a41adb2015-08-15 14:02:29 -07001284 const SkIRect& origSrc, const SkRect& dst, ShowLCDProc proc) {
reed5f629b42015-08-15 11:57:23 -07001285 SkIRect src;
1286 if (!src.intersect(origSrc, bitmap.bounds())) {
1287 return;
1288 }
1289 const SkScalar sx = dst.width() / src.width();
1290 const SkScalar sy = dst.height() / src.height();
1291
1292 SkAutoCanvasRestore acr(canvas, true);
1293 canvas->translate(dst.left(), dst.top());
1294 canvas->scale(sx, sy);
1295
reed5f629b42015-08-15 11:57:23 -07001296 for (int y = 0; y < src.height(); ++y) {
1297 for (int x = 0; x < src.width(); ++x) {
1298 proc(canvas, SkIntToScalar(x), SkIntToScalar(y),
1299 bitmap.getColor(src.left() + x, src.top() + y), sx, sy);
Scroggo0f185c22011-03-24 18:35:50 +00001300 }
reed5f629b42015-08-15 11:57:23 -07001301 }
1302}
1303
1304void SampleWindow::showZoomer(SkCanvas* canvas) {
1305 int count = canvas->save();
1306 canvas->resetMatrix();
1307 // Ensure the mouse position is on screen.
1308 int width = SkScalarRoundToInt(this->width());
1309 int height = SkScalarRoundToInt(this->height());
1310 if (fMouseX >= width) fMouseX = width - 1;
1311 else if (fMouseX < 0) fMouseX = 0;
1312 if (fMouseY >= height) fMouseY = height - 1;
1313 else if (fMouseY < 0) fMouseY = 0;
1314
1315 SkBitmap bitmap = capture_bitmap(canvas);
reed5f629b42015-08-15 11:57:23 -07001316
1317 // Find the size of the zoomed in view, forced to be odd, so the examined pixel is in the middle.
1318 int zoomedWidth = (width >> 1) | 1;
1319 int zoomedHeight = (height >> 1) | 1;
1320 SkIRect src;
1321 src.set(0, 0, zoomedWidth / fFatBitsScale, zoomedHeight / fFatBitsScale);
1322 src.offset(fMouseX - (src.width()>>1), fMouseY - (src.height()>>1));
1323 SkRect dest;
1324 dest.set(0, 0, SkIntToScalar(zoomedWidth), SkIntToScalar(zoomedHeight));
1325 dest.offset(SkIntToScalar(width - zoomedWidth), SkIntToScalar(height - zoomedHeight));
1326 SkPaint paint;
1327 // Clear the background behind our zoomed in view
1328 paint.setColor(SK_ColorWHITE);
1329 canvas->drawRect(dest, paint);
reed8a41adb2015-08-15 14:02:29 -07001330 switch (fFatBitsScale) {
1331 case kMaxFatBitsScale:
1332 show_lcd_grid(canvas, bitmap, src, dest, show_lcd_box);
1333 break;
1334 case kMaxFatBitsScale - 1:
1335 show_lcd_grid(canvas, bitmap, src, dest, show_lcd_circle);
1336 break;
1337 default:
halcanary96fcdcc2015-08-27 07:41:13 -07001338 canvas->drawBitmapRect(bitmap, src, dest, nullptr);
reed8a41adb2015-08-15 14:02:29 -07001339 break;
reed5f629b42015-08-15 11:57:23 -07001340 }
1341
1342 paint.setColor(SK_ColorBLACK);
1343 paint.setStyle(SkPaint::kStroke_Style);
1344 // Draw a border around the pixel in the middle
1345 SkRect originalPixel;
1346 originalPixel.set(SkIntToScalar(fMouseX), SkIntToScalar(fMouseY), SkIntToScalar(fMouseX + 1), SkIntToScalar(fMouseY + 1));
1347 SkMatrix matrix;
1348 SkRect scalarSrc;
1349 scalarSrc.set(src);
1350 SkColor color = bitmap.getColor(fMouseX, fMouseY);
1351 if (matrix.setRectToRect(scalarSrc, dest, SkMatrix::kFill_ScaleToFit)) {
1352 SkRect pixel;
1353 matrix.mapRect(&pixel, originalPixel);
1354 // TODO Perhaps measure the values and make the outline white if it's "dark"
1355 if (color == SK_ColorBLACK) {
1356 paint.setColor(SK_ColorWHITE);
1357 }
1358 canvas->drawRect(pixel, paint);
1359 }
1360 paint.setColor(SK_ColorBLACK);
1361 // Draw a border around the destination rectangle
1362 canvas->drawRect(dest, paint);
1363 paint.setStyle(SkPaint::kStrokeAndFill_Style);
1364 // Identify the pixel and its color on screen
1365 paint.setTypeface(fTypeface);
1366 paint.setAntiAlias(true);
reed5755cd92016-08-21 19:30:13 -07001367 paint.setTextSize(18);
halcanary96fcdcc2015-08-27 07:41:13 -07001368 SkScalar lineHeight = paint.getFontMetrics(nullptr);
reed5f629b42015-08-15 11:57:23 -07001369 SkString string;
1370 string.appendf("(%i, %i)", fMouseX, fMouseY);
1371 SkScalar left = dest.fLeft + SkIntToScalar(3);
1372 SkScalar i = SK_Scalar1;
Mike Reeddf85c382017-02-14 10:59:19 -05001373 drawText(canvas, string, left, lineHeight * i + dest.fTop, paint);
reed5f629b42015-08-15 11:57:23 -07001374 // Alpha
1375 i += SK_Scalar1;
1376 string.reset();
1377 string.appendf("A: %X", SkColorGetA(color));
Mike Reeddf85c382017-02-14 10:59:19 -05001378 drawText(canvas, string, left, lineHeight * i + dest.fTop, paint);
reed5f629b42015-08-15 11:57:23 -07001379 // Red
1380 i += SK_Scalar1;
1381 string.reset();
1382 string.appendf("R: %X", SkColorGetR(color));
1383 paint.setColor(SK_ColorRED);
Mike Reeddf85c382017-02-14 10:59:19 -05001384 drawText(canvas, string, left, lineHeight * i + dest.fTop, paint);
reed5f629b42015-08-15 11:57:23 -07001385 // Green
1386 i += SK_Scalar1;
1387 string.reset();
1388 string.appendf("G: %X", SkColorGetG(color));
reed5755cd92016-08-21 19:30:13 -07001389 paint.setColor(0xFF008800);
Mike Reeddf85c382017-02-14 10:59:19 -05001390 drawText(canvas, string, left, lineHeight * i + dest.fTop, paint);
reed5f629b42015-08-15 11:57:23 -07001391 // Blue
1392 i += SK_Scalar1;
1393 string.reset();
1394 string.appendf("B: %X", SkColorGetB(color));
1395 paint.setColor(SK_ColorBLUE);
Mike Reeddf85c382017-02-14 10:59:19 -05001396 drawText(canvas, string, left, lineHeight * i + dest.fTop, paint);
reed5f629b42015-08-15 11:57:23 -07001397 canvas->restoreToCount(count);
reed@android.come522ca52009-11-23 20:10:41 +00001398}
1399
reed@android.com8a1c16f2008-12-17 15:59:43 +00001400void SampleWindow::onDraw(SkCanvas* canvas) {
reed@android.com8a1c16f2008-12-17 15:59:43 +00001401}
1402
1403#include "SkColorPriv.h"
1404
Scroggo8ac0d542011-06-21 14:44:57 +00001405void SampleWindow::saveToPdf()
1406{
1407 fSaveToPdf = true;
halcanary96fcdcc2015-08-27 07:41:13 -07001408 this->inval(nullptr);
Scroggo8ac0d542011-06-21 14:44:57 +00001409}
1410
reed@android.com8a1c16f2008-12-17 15:59:43 +00001411SkCanvas* SampleWindow::beforeChildren(SkCanvas* canvas) {
Scroggo8ac0d542011-06-21 14:44:57 +00001412 if (fSaveToPdf) {
reedddb5eca2014-10-08 11:10:51 -07001413 SkString name;
1414 if (!this->getRawTitle(&name)) {
1415 name.set("unknown_sample");
1416 }
1417 name.append(".pdf");
1418#ifdef SK_BUILD_FOR_ANDROID
1419 name.prepend("/sdcard/");
1420#endif
halcanary676ab682016-05-03 12:10:04 -07001421 fPDFDocument = SkDocument::MakePDF(name.c_str());
reedddb5eca2014-10-08 11:10:51 -07001422 canvas = fPDFDocument->beginPage(this->width(), this->height());
kkinnunen8686a5e2016-01-05 00:04:32 -08001423 } else if (fSaveToSKP) {
1424 canvas = fRecorder.beginRecording(9999, 9999, nullptr, 0);
reed91b4dfb2016-01-08 08:23:19 -08001425 } else if (fUsePicture) {
Mike Reed96cf2062017-03-14 21:10:42 -04001426 if (PICTURE_MEANS_PIPE) {
1427 fPipeStream.reset(new SkDynamicMemoryWStream);
1428 canvas = fPipeSerializer.beginWrite(SkRect::MakeWH(this->width(), this->height()),
1429 fPipeStream.get());
1430 } else {
1431 canvas = fRecorder.beginRecording(9999, 9999, nullptr, 0);
1432 }
Scroggo8ac0d542011-06-21 14:44:57 +00001433 } else {
bsalomonbb0502e2015-02-11 11:11:11 -08001434 canvas = this->INHERITED::beforeChildren(canvas);
reed@android.com8a1c16f2008-12-17 15:59:43 +00001435 }
1436
1437 if (fUseClip) {
1438 canvas->drawColor(0xFFFF88FF);
Mike Reedc1f77742016-12-09 09:00:50 -05001439 canvas->clipPath(fClipPath, kIntersect_SkClipOp, true);
reed@android.com8a1c16f2008-12-17 15:59:43 +00001440 }
1441
fmalita822ace92015-06-15 07:07:32 -07001442 // Install a flags filter proxy canvas if needed
1443 if (fLCDState != SkOSMenu::kMixedState ||
1444 fAAState != SkOSMenu::kMixedState ||
1445 fSubpixelState != SkOSMenu::kMixedState ||
1446 fHintingState > 0 ||
1447 fFilterQualityIndex > 0) {
halcanary385fe4d2015-08-26 13:07:48 -07001448 canvas = new FlagsFilterCanvas(canvas, fLCDState, fAAState, fSubpixelState, fHintingState,
1449 fFilterQualityIndex);
fmalita822ace92015-06-15 07:07:32 -07001450 fFlagsFilterCanvas.reset(canvas);
1451 }
1452
reed@android.com8a1c16f2008-12-17 15:59:43 +00001453 return canvas;
1454}
reed89889b62014-10-29 12:36:45 -07001455#include "SkMultiPictureDraw.h"
reed@android.com8a1c16f2008-12-17 15:59:43 +00001456void SampleWindow::afterChildren(SkCanvas* orig) {
halcanary96fcdcc2015-08-27 07:41:13 -07001457 fFlagsFilterCanvas.reset(nullptr);
fmalita822ace92015-06-15 07:07:32 -07001458
Scroggo8ac0d542011-06-21 14:44:57 +00001459 if (fSaveToPdf) {
1460 fSaveToPdf = false;
reedddb5eca2014-10-08 11:10:51 -07001461 fPDFDocument->endPage();
halcanary96fcdcc2015-08-27 07:41:13 -07001462 fPDFDocument.reset(nullptr);
Scroggo8ac0d542011-06-21 14:44:57 +00001463 // We took over the draw calls in order to create the PDF, so we need
1464 // to redraw.
halcanary96fcdcc2015-08-27 07:41:13 -07001465 this->inval(nullptr);
Scroggo8ac0d542011-06-21 14:44:57 +00001466 return;
1467 }
chudy@google.com4605a3f2012-08-01 17:58:01 +00001468
reed@android.comf2b98d62010-12-20 18:26:13 +00001469 if (fRequestGrabImage) {
1470 fRequestGrabImage = false;
bsalomon@google.com2e7b43d2011-01-18 20:57:22 +00001471
reed52d9ac62014-06-30 09:05:34 -07001472 SkBitmap bmp = capture_bitmap(orig);
1473 if (!bmp.isNull()) {
reed@android.comf2b98d62010-12-20 18:26:13 +00001474 static int gSampleGrabCounter;
1475 SkString name;
reed@google.com7c57e0e2012-09-08 21:20:33 +00001476 name.printf("sample_grab_%d.png", gSampleGrabCounter++);
Hal Canarydb683012016-11-23 08:55:18 -07001477 sk_tool_utils::EncodeImageToFile(name.c_str(), bmp,
1478 SkEncodedImageFormat::kPNG, 100);
reed@android.comf2b98d62010-12-20 18:26:13 +00001479 }
kkinnunen8686a5e2016-01-05 00:04:32 -08001480 this->inval(nullptr);
1481 return;
reed@android.comf2b98d62010-12-20 18:26:13 +00001482 }
1483
kkinnunen8686a5e2016-01-05 00:04:32 -08001484 if (fSaveToSKP) {
reedca2622b2016-03-18 07:25:55 -07001485 sk_sp<SkPicture> picture(fRecorder.finishRecordingAsPicture());
kkinnunen8686a5e2016-01-05 00:04:32 -08001486 SkFILEWStream stream("sample_app.skp");
1487 picture->serialize(&stream);
1488 fSaveToSKP = false;
1489 this->inval(nullptr);
1490 return;
1491 }
robertphillips@google.com84b18c72014-04-13 19:09:42 +00001492
reed91b4dfb2016-01-08 08:23:19 -08001493 if (fUsePicture) {
Mike Reed96cf2062017-03-14 21:10:42 -04001494 if (PICTURE_MEANS_PIPE) {
reed54dc4872016-09-13 08:09:45 -07001495 fPipeSerializer.endWrite();
1496 sk_sp<SkData> data(fPipeStream->detachAsData());
1497 fPipeDeserializer.playback(data->data(), data->size(), orig);
1498 fPipeStream.reset();
1499 } else {
1500 sk_sp<SkPicture> picture(fRecorder.finishRecordingAsPicture());
Mike Reed96cf2062017-03-14 21:10:42 -04001501 if (SERIALIZE_PICTURE) {
1502 auto data = picture->serialize();
1503 picture = SkPicture::MakeFromData(data.get(), nullptr);
1504 }
reed54dc4872016-09-13 08:09:45 -07001505 orig->drawPicture(picture.get());
reedbfd5f172016-01-07 11:28:08 -08001506 }
reed@android.com8a1c16f2008-12-17 15:59:43 +00001507 }
bsalomon@google.com2e7b43d2011-01-18 20:57:22 +00001508
reed@google.com17d7aec2011-04-25 14:31:44 +00001509 // Do this after presentGL and other finishing, rather than in afterChild
jvanverth4d0d81a2015-08-11 11:07:07 -07001510 if (fMeasureFPS) {
reedb2ce0b02015-11-09 13:10:30 -08001511 orig->flush();
jvanverth4d0d81a2015-08-11 11:07:07 -07001512 fTimer.end();
1513 fMeasureFPS_Time += fTimer.fWall;
Yuqian Li5458cf82017-05-24 09:58:07 -04001514 fCumulativeFPS_Time += fTimer.fWall;
1515 fCumulativeFPS_Count += FPS_REPEAT_COUNT;
reed@google.com17d7aec2011-04-25 14:31:44 +00001516 }
reed@android.com8a1c16f2008-12-17 15:59:43 +00001517}
1518
reed@android.com6c5f6f22009-08-14 16:08:38 +00001519void SampleWindow::beforeChild(SkView* child, SkCanvas* canvas) {
reed@android.com6c5f6f22009-08-14 16:08:38 +00001520 if (fRotate) {
1521 SkScalar cx = this->width() / 2;
1522 SkScalar cy = this->height() / 2;
bungeman7438bfc2016-07-12 15:01:19 -07001523 canvas->rotate(gAnimTimer.scaled(10), cx, cy);
reed@android.com6c5f6f22009-08-14 16:08:38 +00001524 }
bungeman@google.comb1785912013-07-09 21:58:56 +00001525
bsalomon@google.come8f09102011-09-08 18:48:12 +00001526 if (fPerspAnim) {
reed76113a92015-02-02 12:55:02 -08001527 SkScalar secs = gAnimTimer.scaled(1);
bsalomon@google.com6fb736f2011-09-16 18:51:57 +00001528
1529 static const SkScalar gAnimPeriod = 10 * SK_Scalar1;
1530 static const SkScalar gAnimMag = SK_Scalar1 / 1000;
reed76113a92015-02-02 12:55:02 -08001531 SkScalar t = SkScalarMod(secs, gAnimPeriod);
reed80ea19c2015-05-12 10:37:34 -07001532 if (SkScalarFloorToInt(secs / gAnimPeriod) & 0x1) {
bsalomon@google.com6fb736f2011-09-16 18:51:57 +00001533 t = gAnimPeriod - t;
1534 }
1535 t = 2 * t - gAnimPeriod;
reed80ea19c2015-05-12 10:37:34 -07001536 t *= gAnimMag / gAnimPeriod;
bsalomon@google.com6fb736f2011-09-16 18:51:57 +00001537 SkMatrix m;
1538 m.reset();
reed5d9ab282014-09-19 13:04:17 -07001539#if 1
bsalomon@google.com6fb736f2011-09-16 18:51:57 +00001540 m.setPerspY(t);
reed5d9ab282014-09-19 13:04:17 -07001541#else
1542 m.setPerspY(SK_Scalar1 / 1000);
reed80ea19c2015-05-12 10:37:34 -07001543 m.setSkewX(8.0f / 25);
reed5d9ab282014-09-19 13:04:17 -07001544 m.dump();
1545#endif
bsalomon@google.come8f09102011-09-08 18:48:12 +00001546 canvas->concat(m);
1547 }
reed@google.comf0b5f682011-03-11 20:08:25 +00001548
mike@reedtribe.org2eb59522011-04-22 01:59:09 +00001549 if (fMeasureFPS) {
jvanverth4d0d81a2015-08-11 11:07:07 -07001550 (void)SampleView::SetRepeatDraw(child, FPS_REPEAT_COUNT);
1551 fTimer.start();
reed@google.comf2183392011-04-22 14:10:48 +00001552 } else {
1553 (void)SampleView::SetRepeatDraw(child, 1);
mike@reedtribe.org2eb59522011-04-22 01:59:09 +00001554 }
bungeman@google.comb1785912013-07-09 21:58:56 +00001555 if (fPerspAnim || fRotate) {
halcanary96fcdcc2015-08-27 07:41:13 -07001556 this->inval(nullptr);
bsalomon@google.come8f09102011-09-08 18:48:12 +00001557 }
reed@android.com6c5f6f22009-08-14 16:08:38 +00001558}
1559
bungemance560262016-03-03 13:32:38 -08001560void SampleWindow::changeOffset(SkVector delta) {
1561 fOffset += delta;
1562 this->updateMatrix();
1563}
1564
djsollen@google.come32b5832011-06-13 16:58:40 +00001565void SampleWindow::changeZoomLevel(float delta) {
commit-bot@chromium.org4b413c82013-11-25 19:44:07 +00001566 fZoomLevel += delta;
mike@reedtribe.orgdd0cd342011-03-21 00:53:39 +00001567 if (fZoomLevel > 0) {
djsollen@google.come32b5832011-06-13 16:58:40 +00001568 fZoomLevel = SkMinScalar(fZoomLevel, MAX_ZOOM_LEVEL);
1569 fZoomScale = fZoomLevel + SK_Scalar1;
mike@reedtribe.orgdd0cd342011-03-21 00:53:39 +00001570 } else if (fZoomLevel < 0) {
djsollen@google.come32b5832011-06-13 16:58:40 +00001571 fZoomLevel = SkMaxScalar(fZoomLevel, MIN_ZOOM_LEVEL);
1572 fZoomScale = SK_Scalar1 / (SK_Scalar1 - fZoomLevel);
mike@reedtribe.orgdd0cd342011-03-21 00:53:39 +00001573 } else {
1574 fZoomScale = SK_Scalar1;
1575 }
reed@google.comf03bb562011-11-11 21:42:12 +00001576 this->updateMatrix();
mike@reedtribe.orgdd0cd342011-03-21 00:53:39 +00001577}
1578
reed@google.comf03bb562011-11-11 21:42:12 +00001579void SampleWindow::updateMatrix(){
1580 SkMatrix m;
1581 m.reset();
bungemance560262016-03-03 13:32:38 -08001582
reed@google.comf03bb562011-11-11 21:42:12 +00001583 if (fZoomLevel) {
1584 SkPoint center;
1585 //m = this->getLocalMatrix();//.invert(&m);
1586 m.mapXY(fZoomCenterX, fZoomCenterY, &center);
1587 SkScalar cx = center.fX;
1588 SkScalar cy = center.fY;
chudy@google.com4605a3f2012-08-01 17:58:01 +00001589
reed@google.comf03bb562011-11-11 21:42:12 +00001590 m.setTranslate(-cx, -cy);
1591 m.postScale(fZoomScale, fZoomScale);
1592 m.postTranslate(cx, cy);
1593 }
chudy@google.com4605a3f2012-08-01 17:58:01 +00001594
bungemance560262016-03-03 13:32:38 -08001595 m.postTranslate(fOffset.fX, fOffset.fY);
1596
reed@google.comf03bb562011-11-11 21:42:12 +00001597 if (fFlipAxis) {
1598 m.preTranslate(fZoomCenterX, fZoomCenterY);
1599 if (fFlipAxis & kFlipAxis_X) {
1600 m.preScale(-SK_Scalar1, SK_Scalar1);
1601 }
1602 if (fFlipAxis & kFlipAxis_Y) {
1603 m.preScale(SK_Scalar1, -SK_Scalar1);
1604 }
1605 m.preTranslate(-fZoomCenterX, -fZoomCenterY);
1606 //canvas->concat(m);
1607 }
1608 // Apply any gesture matrix
1609 m.preConcat(fGesture.localM());
1610 m.preConcat(fGesture.globalM());
chudy@google.com4605a3f2012-08-01 17:58:01 +00001611
reed@google.comf03bb562011-11-11 21:42:12 +00001612 this->setLocalMatrix(m);
chudy@google.com4605a3f2012-08-01 17:58:01 +00001613
reed@google.comf03bb562011-11-11 21:42:12 +00001614 this->updateTitle();
halcanary96fcdcc2015-08-27 07:41:13 -07001615 this->inval(nullptr);
reed@google.comf03bb562011-11-11 21:42:12 +00001616}
Scroggo2c8208f2011-06-15 16:49:08 +00001617bool SampleWindow::previousSample() {
Yuqian Li5458cf82017-05-24 09:58:07 -04001618 this->resetFPS();
Scroggo62b65b02011-06-21 16:01:26 +00001619 fCurrIndex = (fCurrIndex - 1 + fSamples.count()) % fSamples.count();
reed63121f02015-01-13 19:43:04 -08001620 this->loadView((*fSamples[fCurrIndex])());
Scroggo2c8208f2011-06-15 16:49:08 +00001621 return true;
1622}
1623
reed216b6432015-08-19 12:25:40 -07001624#include "SkResourceCache.h"
1625#include "SkGlyphCache.h"
reed@android.com8a1c16f2008-12-17 15:59:43 +00001626bool SampleWindow::nextSample() {
Yuqian Li5458cf82017-05-24 09:58:07 -04001627 this->resetFPS();
reed@android.com34245c72009-11-03 04:00:48 +00001628 fCurrIndex = (fCurrIndex + 1) % fSamples.count();
reed63121f02015-01-13 19:43:04 -08001629 this->loadView((*fSamples[fCurrIndex])());
reed216b6432015-08-19 12:25:40 -07001630
1631 if (false) {
1632 SkResourceCache::TestDumpMemoryStatistics();
1633 SkGlyphCache::Dump();
1634 SkDebugf("\n");
1635 }
1636
reed@android.com34245c72009-11-03 04:00:48 +00001637 return true;
reed@android.com8a1c16f2008-12-17 15:59:43 +00001638}
1639
yangsu@google.com501775e2011-06-24 16:04:50 +00001640bool SampleWindow::goToSample(int i) {
Yuqian Li5458cf82017-05-24 09:58:07 -04001641 this->resetFPS();
yangsu@google.com501775e2011-06-24 16:04:50 +00001642 fCurrIndex = (i) % fSamples.count();
reed63121f02015-01-13 19:43:04 -08001643 this->loadView((*fSamples[fCurrIndex])());
yangsu@google.com501775e2011-06-24 16:04:50 +00001644 return true;
1645}
1646
1647SkString SampleWindow::getSampleTitle(int i) {
edisonn@google.comf8b6b012013-07-11 14:28:04 +00001648 return ::getSampleTitle(fSamples[i]);
yangsu@google.com501775e2011-06-24 16:04:50 +00001649}
1650
1651int SampleWindow::sampleCount() {
1652 return fSamples.count();
1653}
1654
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00001655void SampleWindow::showOverview() {
reed63121f02015-01-13 19:43:04 -08001656 this->loadView(create_overview(fSamples.count(), fSamples.begin()));
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00001657}
1658
Scroggo2c8208f2011-06-15 16:49:08 +00001659void SampleWindow::postAnimatingEvent() {
1660 if (fAnimating) {
reed@google.com87fac4a2011-08-04 13:50:17 +00001661 (new SkEvent(ANIMATING_EVENTTYPE, this->getSinkID()))->postDelay(ANIMATING_DELAY);
Scroggo2c8208f2011-06-15 16:49:08 +00001662 }
1663}
reed@google.come23f1942011-12-08 19:36:00 +00001664
brianosman35a02a82016-09-29 14:37:02 -07001665static sk_sp<SkColorSpace> getMonitorColorSpace() {
1666#if defined(SK_BUILD_FOR_MAC)
1667 CGColorSpaceRef cs = CGDisplayCopyColorSpace(CGMainDisplayID());
1668 CFDataRef dataRef = CGColorSpaceCopyICCProfile(cs);
1669 const uint8_t* data = CFDataGetBytePtr(dataRef);
1670 size_t size = CFDataGetLength(dataRef);
1671
Brian Osman526972e2016-10-24 09:24:02 -04001672 sk_sp<SkColorSpace> colorSpace = SkColorSpace::MakeICC(data, size);
brianosman35a02a82016-09-29 14:37:02 -07001673
1674 CFRelease(cs);
1675 CFRelease(dataRef);
1676 return colorSpace;
1677#elif defined(SK_BUILD_FOR_WIN)
1678 DISPLAY_DEVICE dd = { sizeof(DISPLAY_DEVICE) };
1679
1680 // Chrome's code for this currently just gets the primary monitor's profile. This code iterates
1681 // over all attached monitors, so it's "better" in that sense. Making intelligent use of this
1682 // information (via things like MonitorFromWindow or MonitorFromRect to pick the correct
1683 // profile for a particular window or region of a window), is an exercise left to the reader.
1684 for (int i = 0; EnumDisplayDevices(NULL, i, &dd, 0); ++i) {
1685 if (dd.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP) {
1686 // There are other helpful things in dd at this point:
1687 // dd.DeviceString has a longer name for the adapter
1688 // dd.StateFlags indicates primary display, mirroring, etc...
1689 HDC dc = CreateDC(NULL, dd.DeviceName, NULL, NULL);
1690 if (dc) {
1691 char icmPath[MAX_PATH + 1];
1692 DWORD pathLength = MAX_PATH;
Jim Van Verthb6c5e532016-10-28 10:38:08 -04001693 BOOL success = GetICMProfileA(dc, &pathLength, icmPath);
brianosman35a02a82016-09-29 14:37:02 -07001694 DeleteDC(dc);
1695 if (success) {
1696 sk_sp<SkData> iccData = SkData::MakeFromFileName(icmPath);
Brian Osman526972e2016-10-24 09:24:02 -04001697 return SkColorSpace::MakeICC(iccData->data(), iccData->size());
brianosman35a02a82016-09-29 14:37:02 -07001698 }
1699 }
1700 }
1701 }
1702
1703 return nullptr;
1704#else
1705 return nullptr;
1706#endif
1707}
1708
reed@android.com8a1c16f2008-12-17 15:59:43 +00001709bool SampleWindow::onEvent(const SkEvent& evt) {
reed@google.com2072db82011-11-08 15:18:10 +00001710 if (evt.isType(gUpdateWindowTitleEvtName)) {
1711 this->updateTitle();
1712 return true;
1713 }
reed@android.com8a1c16f2008-12-17 15:59:43 +00001714 if (evt.isType(ANIMATING_EVENTTYPE)) {
1715 if (fAnimating) {
1716 this->nextSample();
1717 this->postAnimatingEvent();
1718 }
1719 return true;
1720 }
reed@android.com34245c72009-11-03 04:00:48 +00001721 if (evt.isType("set-curr-index")) {
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00001722 this->goToSample(evt.getFast32());
reed@android.com34245c72009-11-03 04:00:48 +00001723 return true;
1724 }
mike@reedtribe.org2eb59522011-04-22 01:59:09 +00001725 if (isInvalEvent(evt)) {
halcanary96fcdcc2015-08-27 07:41:13 -07001726 this->inval(nullptr);
mike@reedtribe.org2eb59522011-04-22 01:59:09 +00001727 return true;
1728 }
yangsu@google.com921091f2011-08-02 13:39:12 +00001729 int selected = -1;
yangsu@google.comef7bdfa2011-08-12 14:27:47 +00001730 if (SkOSMenu::FindListIndex(evt, "Device Type", &selected)) {
yangsu@google.com921091f2011-08-02 13:39:12 +00001731 this->setDeviceType((DeviceType)selected);
chudy@google.com4605a3f2012-08-01 17:58:01 +00001732 return true;
yangsu@google.com921091f2011-08-02 13:39:12 +00001733 }
reeda34be682016-02-15 07:48:35 -08001734 if (SkOSMenu::FindListIndex(evt, "ColorType", &selected)) {
brianosman35a02a82016-09-29 14:37:02 -07001735 fColorConfigIndex = selected;
1736 sk_sp<SkColorSpace> colorSpace = nullptr;
1737 switch (gConfig[selected].fColorSpace) {
1738 case kSRGB_OutputColorSpace:
Matt Sarett77a7a1b2017-02-07 13:56:11 -05001739 colorSpace = SkColorSpace::MakeSRGB();
brianosman35a02a82016-09-29 14:37:02 -07001740 break;
Brian Osmanfc2e7e02016-12-02 12:10:36 -05001741 case kNarrow_OutputColorSpace:
1742 {
1743 // NarrowGamut RGB (an artifically smaller than sRGB gamut)
1744 SkColorSpacePrimaries primaries ={
1745 0.54f, 0.33f, // Rx, Ry
1746 0.33f, 0.50f, // Gx, Gy
1747 0.25f, 0.20f, // Bx, By
1748 0.3127f, 0.3290f, // Wx, Wy
1749 };
1750 SkMatrix44 narrowGamutRGBMatrix(SkMatrix44::kUninitialized_Constructor);
1751 primaries.toXYZD50(&narrowGamutRGBMatrix);
1752 colorSpace = SkColorSpace::MakeRGB(SkColorSpace::kSRGB_RenderTargetGamma,
1753 narrowGamutRGBMatrix);
1754 }
1755 break;
brianosman35a02a82016-09-29 14:37:02 -07001756 case kMonitor_OutputColorSpace:
1757 colorSpace = getMonitorColorSpace();
1758 if (!colorSpace) {
1759 // Fallback for platforms / machines where we can't get a monitor profile
Matt Sarett77a7a1b2017-02-07 13:56:11 -05001760 colorSpace = SkColorSpace::MakeSRGB();
brianosman35a02a82016-09-29 14:37:02 -07001761 }
1762 break;
1763 case kLegacy_OutputColorSpace:
1764 default:
1765 // Do nothing
1766 break;
1767 }
brianosman0e22eb82016-08-30 07:07:59 -07001768 if (kRGBA_F16_SkColorType == gConfig[selected].fColorType) {
brianosman35a02a82016-09-29 14:37:02 -07001769 SkASSERT(colorSpace);
raftias94888332016-10-18 10:02:51 -07001770 SkASSERT(SkColorSpace_Base::Type::kXYZ == as_CSB(colorSpace)->type());
1771 SkColorSpace_XYZ* csXYZ = static_cast<SkColorSpace_XYZ*>(colorSpace.get());
1772 colorSpace = csXYZ->makeLinearGamma();
brianosman0e22eb82016-08-30 07:07:59 -07001773 }
brianosman35a02a82016-09-29 14:37:02 -07001774 this->setDeviceColorType(gConfig[selected].fColorType, colorSpace);
reeda34be682016-02-15 07:48:35 -08001775 return true;
1776 }
halcanary96fcdcc2015-08-27 07:41:13 -07001777 if (SkOSMenu::FindSwitchState(evt, "Slide Show", nullptr)) {
yangsu@google.com921091f2011-08-02 13:39:12 +00001778 this->toggleSlideshow();
1779 return true;
1780 }
yangsu@google.comef7bdfa2011-08-12 14:27:47 +00001781 if (SkOSMenu::FindTriState(evt, "AA", &fAAState) ||
1782 SkOSMenu::FindTriState(evt, "LCD", &fLCDState) ||
reed93a12152015-03-16 10:08:34 -07001783 SkOSMenu::FindListIndex(evt, "FilterQuality", &fFilterQualityIndex) ||
bungeman@google.com96aabc82013-06-03 21:26:34 +00001784 SkOSMenu::FindTriState(evt, "Subpixel", &fSubpixelState) ||
1785 SkOSMenu::FindListIndex(evt, "Hinting", &fHintingState) ||
yangsu@google.comef7bdfa2011-08-12 14:27:47 +00001786 SkOSMenu::FindSwitchState(evt, "Clip", &fUseClip) ||
1787 SkOSMenu::FindSwitchState(evt, "Zoomer", &fShowZoomer) ||
reeda84d6602016-06-24 18:14:07 -07001788 SkOSMenu::FindSwitchState(evt, "Magnify", &fMagnify))
reed093b4e82015-08-04 18:46:38 -07001789 {
halcanary96fcdcc2015-08-27 07:41:13 -07001790 this->inval(nullptr);
commit-bot@chromium.orgbbe43a92013-12-10 21:51:06 +00001791 this->updateTitle();
1792 return true;
1793 }
bungeman5a59a422016-03-31 08:30:38 -07001794 if (SkOSMenu::FindListIndex(evt, "Pixel Geometry", &fPixelGeometryIndex)) {
1795 this->setPixelGeometry(fPixelGeometryIndex);
1796 return true;
1797 }
commit-bot@chromium.orgbbe43a92013-12-10 21:51:06 +00001798 if (SkOSMenu::FindListIndex(evt, "Tiling", &fTilingMode)) {
1799 if (SampleView::IsSampleView(curr_view(this))) {
1800 ((SampleView*)curr_view(this))->onTileSizeChanged(this->tileSize());
1801 }
halcanary96fcdcc2015-08-27 07:41:13 -07001802 this->inval(nullptr);
yangsu@google.com921091f2011-08-02 13:39:12 +00001803 this->updateTitle();
1804 return true;
1805 }
halcanary96fcdcc2015-08-27 07:41:13 -07001806 if (SkOSMenu::FindSwitchState(evt, "Flip X", nullptr)) {
yangsu@google.com921091f2011-08-02 13:39:12 +00001807 fFlipAxis ^= kFlipAxis_X;
reed@google.comf03bb562011-11-11 21:42:12 +00001808 this->updateMatrix();
yangsu@google.com921091f2011-08-02 13:39:12 +00001809 return true;
1810 }
halcanary96fcdcc2015-08-27 07:41:13 -07001811 if (SkOSMenu::FindSwitchState(evt, "Flip Y", nullptr)) {
yangsu@google.com921091f2011-08-02 13:39:12 +00001812 fFlipAxis ^= kFlipAxis_Y;
reed@google.comf03bb562011-11-11 21:42:12 +00001813 this->updateMatrix();
yangsu@google.com921091f2011-08-02 13:39:12 +00001814 return true;
1815 }
yangsu@google.comef7bdfa2011-08-12 14:27:47 +00001816 if (SkOSMenu::FindAction(evt,"Save to PDF")) {
yangsu@google.com921091f2011-08-02 13:39:12 +00001817 this->saveToPdf();
1818 return true;
chudy@google.com4605a3f2012-08-01 17:58:01 +00001819 }
reed@android.com8a1c16f2008-12-17 15:59:43 +00001820 return this->INHERITED::onEvent(evt);
1821}
1822
reed@android.comf2b98d62010-12-20 18:26:13 +00001823bool SampleWindow::onQuery(SkEvent* query) {
1824 if (query->isType("get-slide-count")) {
1825 query->setFast32(fSamples.count());
1826 return true;
1827 }
1828 if (query->isType("get-slide-title")) {
bsalomon@google.com48dd1a22011-10-31 14:18:20 +00001829 SkView* view = (*fSamples[query->getFast32()])();
reed@android.comf2b98d62010-12-20 18:26:13 +00001830 SkEvent evt(gTitleEvtName);
1831 if (view->doQuery(&evt)) {
1832 query->setString("title", evt.findString(gTitleEvtName));
1833 }
1834 SkSafeUnref(view);
1835 return true;
1836 }
1837 if (query->isType("use-fast-text")) {
1838 SkEvent evt(gFastTextEvtName);
1839 return curr_view(this)->doQuery(&evt);
1840 }
reed@google.com29038ed2011-07-06 17:56:47 +00001841 if (query->isType("ignore-window-bitmap")) {
halcanary96fcdcc2015-08-27 07:41:13 -07001842 query->setFast32(this->getGrContext() != nullptr);
reed@google.com29038ed2011-07-06 17:56:47 +00001843 return true;
1844 }
reed@android.comf2b98d62010-12-20 18:26:13 +00001845 return this->INHERITED::onQuery(query);
1846}
1847
Cary Clark992c7b02014-07-31 08:58:44 -04001848DECLARE_bool(portableFonts);
caryclark5fb6bd42014-06-23 11:25:00 -07001849
reed@android.com8a1c16f2008-12-17 15:59:43 +00001850bool SampleWindow::onHandleChar(SkUnichar uni) {
reed@android.comf2b98d62010-12-20 18:26:13 +00001851 {
1852 SkView* view = curr_view(this);
1853 if (view) {
1854 SkEvent evt(gCharEvtName);
1855 evt.setFast32(uni);
1856 if (view->doQuery(&evt)) {
1857 return true;
1858 }
1859 }
1860 }
chudy@google.com4605a3f2012-08-01 17:58:01 +00001861
reed@android.com8a1c16f2008-12-17 15:59:43 +00001862 int dx = 0xFF;
1863 int dy = 0xFF;
1864
1865 switch (uni) {
1866 case '5': dx = 0; dy = 0; break;
1867 case '8': dx = 0; dy = -1; break;
1868 case '6': dx = 1; dy = 0; break;
1869 case '2': dx = 0; dy = 1; break;
1870 case '4': dx = -1; dy = 0; break;
1871 case '7': dx = -1; dy = -1; break;
1872 case '9': dx = 1; dy = -1; break;
1873 case '3': dx = 1; dy = 1; break;
1874 case '1': dx = -1; dy = 1; break;
bsalomon@google.com2e7b43d2011-01-18 20:57:22 +00001875
reed@android.com8a1c16f2008-12-17 15:59:43 +00001876 default:
1877 break;
1878 }
bsalomon@google.com2e7b43d2011-01-18 20:57:22 +00001879
reed@android.com8a1c16f2008-12-17 15:59:43 +00001880 if (0xFF != dx && 0xFF != dy) {
bungemance560262016-03-03 13:32:38 -08001881 this->changeOffset({SkIntToScalar(dx / 32.0f), SkIntToScalar(dy / 32.0f)});
reed@android.com8a1c16f2008-12-17 15:59:43 +00001882 return true;
1883 }
bsalomon@google.com2e7b43d2011-01-18 20:57:22 +00001884
reed@android.com0ae6b242008-12-23 16:49:54 +00001885 switch (uni) {
reed76113a92015-02-02 12:55:02 -08001886 case 27: // ESC
1887 gAnimTimer.stop();
1888 if (this->sendAnimatePulse()) {
halcanary96fcdcc2015-08-27 07:41:13 -07001889 this->inval(nullptr);
reed76113a92015-02-02 12:55:02 -08001890 }
1891 break;
Yuqian Lib55dd552017-04-03 10:52:48 -04001892 case '+':
Yuqian Li70898af2017-06-05 13:36:32 -04001893 gSampleWindow->setTiles(gSampleWindow->getTiles() + 1);
Yuqian Lib55dd552017-04-03 10:52:48 -04001894 this->inval(nullptr);
1895 this->updateTitle();
1896 break;
1897 case '-':
Yuqian Li70898af2017-06-05 13:36:32 -04001898 gSampleWindow->setTiles(SkTMax(0, gSampleWindow->getTiles() - 1));
1899 this->inval(nullptr);
1900 this->updateTitle();
1901 break;
1902 case '>':
1903 gSampleWindow->setThreads(gSampleWindow->getThreads() + 1);
1904 this->inval(nullptr);
1905 this->updateTitle();
1906 break;
1907 case '<':
Yuqian Lib55dd552017-04-03 10:52:48 -04001908 gSampleWindow->setThreads(SkTMax(0, gSampleWindow->getThreads() - 1));
1909 this->inval(nullptr);
1910 this->updateTitle();
1911 break;
reedd9adfe62015-02-01 19:01:04 -08001912 case ' ':
reed76113a92015-02-02 12:55:02 -08001913 gAnimTimer.togglePauseResume();
reedd9adfe62015-02-01 19:01:04 -08001914 if (this->sendAnimatePulse()) {
halcanary96fcdcc2015-08-27 07:41:13 -07001915 this->inval(nullptr);
reedd9adfe62015-02-01 19:01:04 -08001916 }
1917 break;
Yuqian Li5458cf82017-05-24 09:58:07 -04001918 case '0':
1919 this->resetFPS();
1920 break;
liyuqian38911a72016-10-04 11:23:22 -07001921 case 'A':
Yuqian Lidf60e362017-07-25 11:26:31 -04001922 if (!gSkUseAnalyticAA) {
1923 gSkUseAnalyticAA = true;
1924 } else if (!gSkForceAnalyticAA && !gSkUseDeltaAA) {
Yuqian Li550148b2017-01-13 10:13:13 -05001925 gSkForceAnalyticAA = true;
Yuqian Lidf60e362017-07-25 11:26:31 -04001926 } else if (!gSkUseDeltaAA) {
Yuqian Li550148b2017-01-13 10:13:13 -05001927 gSkForceAnalyticAA = false;
Yuqian Lidf60e362017-07-25 11:26:31 -04001928 gSkUseDeltaAA = true;
1929 } else if (!gSkForceDeltaAA) {
1930 gSkForceDeltaAA = true;
1931 } else {
1932 gSkUseAnalyticAA = gSkForceAnalyticAA = gSkUseDeltaAA = gSkForceDeltaAA = false;
Yuqian Li550148b2017-01-13 10:13:13 -05001933 }
liyuqian38911a72016-10-04 11:23:22 -07001934 this->inval(nullptr);
liyuqianebcb8aa2016-10-11 12:20:08 -07001935 this->updateTitle();
liyuqian38911a72016-10-04 11:23:22 -07001936 break;
reed@google.coma4f81372012-11-15 15:56:38 +00001937 case 'B':
halcanary385fe4d2015-08-26 13:07:48 -07001938 post_event_to_sink(new SkEvent("PictFileView::toggleBBox"), curr_view(this));
commit-bot@chromium.org6de4a782013-12-11 17:05:23 +00001939 // Cannot call updateTitle() synchronously, because the toggleBBox event is still in
1940 // the queue.
halcanary385fe4d2015-08-26 13:07:48 -07001941 post_event_to_sink(new SkEvent(gUpdateWindowTitleEvtName), this);
halcanary96fcdcc2015-08-27 07:41:13 -07001942 this->inval(nullptr);
reed@google.coma4f81372012-11-15 15:56:38 +00001943 break;
reed4302ae92014-10-06 12:29:56 -07001944 case 'D':
1945 toggleDistanceFieldFonts();
1946 break;
reedbabc3de2016-07-08 08:43:27 -07001947 case 'E':
1948 fUseDeferredCanvas = !fUseDeferredCanvas;
1949 this->inval(nullptr);
1950 break;
yangsu@google.comef7bdfa2011-08-12 14:27:47 +00001951 case 'f':
chudy@google.com4605a3f2012-08-01 17:58:01 +00001952 // only
djsollen@google.com6ff82552011-11-07 15:43:57 +00001953 toggleFPS();
yangsu@google.comef7bdfa2011-08-12 14:27:47 +00001954 break;
caryclark5fb6bd42014-06-23 11:25:00 -07001955 case 'F':
Cary Clark992c7b02014-07-31 08:58:44 -04001956 FLAGS_portableFonts ^= true;
halcanary96fcdcc2015-08-27 07:41:13 -07001957 this->inval(nullptr);
caryclark5fb6bd42014-06-23 11:25:00 -07001958 break;
mike@reedtribe.org2eb59522011-04-22 01:59:09 +00001959 case 'g':
1960 fRequestGrabImage = true;
halcanary96fcdcc2015-08-27 07:41:13 -07001961 this->inval(nullptr);
mike@reedtribe.org2eb59522011-04-22 01:59:09 +00001962 break;
reed@google.coma4f81372012-11-15 15:56:38 +00001963 case 'G':
1964 gShowGMBounds = !gShowGMBounds;
commit-bot@chromium.org6de4a782013-12-11 17:05:23 +00001965 post_event_to_sink(GMSampleView::NewShowSizeEvt(gShowGMBounds),
reed@google.coma4f81372012-11-15 15:56:38 +00001966 curr_view(this));
halcanary96fcdcc2015-08-27 07:41:13 -07001967 this->inval(nullptr);
reed@google.coma4f81372012-11-15 15:56:38 +00001968 break;
mike@reedtribe.org2eb59522011-04-22 01:59:09 +00001969 case 'i':
1970 this->zoomIn();
1971 break;
mike@reedtribe.org2eb59522011-04-22 01:59:09 +00001972 case 'o':
1973 this->zoomOut();
1974 break;
reed@android.com6c5f6f22009-08-14 16:08:38 +00001975 case 'r':
1976 fRotate = !fRotate;
halcanary96fcdcc2015-08-27 07:41:13 -07001977 this->inval(nullptr);
reed@android.com6c5f6f22009-08-14 16:08:38 +00001978 this->updateTitle();
1979 return true;
Mike Reed8780eda2017-08-07 12:25:19 -04001980 case 'R':
1981 gSkForceRasterPipelineBlitter = !gSkForceRasterPipelineBlitter;
1982 this->inval(nullptr);
1983 this->updateTitle();
1984 break;
bsalomon@google.come8f09102011-09-08 18:48:12 +00001985 case 'k':
1986 fPerspAnim = !fPerspAnim;
halcanary96fcdcc2015-08-27 07:41:13 -07001987 this->inval(nullptr);
bsalomon@google.come8f09102011-09-08 18:48:12 +00001988 this->updateTitle();
1989 return true;
reed093b4e82015-08-04 18:46:38 -07001990 case 'K':
1991 fSaveToSKP = true;
halcanary96fcdcc2015-08-27 07:41:13 -07001992 this->inval(nullptr);
reed093b4e82015-08-04 18:46:38 -07001993 return true;
kkinnunen8686a5e2016-01-05 00:04:32 -08001994 case 'M':
reed91b4dfb2016-01-08 08:23:19 -08001995 fUsePicture = !fUsePicture;
kkinnunen8686a5e2016-01-05 00:04:32 -08001996 this->inval(nullptr);
1997 this->updateTitle();
1998 return true;
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +00001999#if SK_SUPPORT_GPU
twiz@google.com05e70242012-01-27 19:12:00 +00002000 case 'p':
2001 {
2002 GrContext* grContext = this->getGrContext();
2003 if (grContext) {
commit-bot@chromium.org95c20032014-05-09 14:29:32 +00002004 size_t cacheBytes;
halcanary96fcdcc2015-08-27 07:41:13 -07002005 grContext->getResourceCacheUsage(nullptr, &cacheBytes);
twiz@google.com05e70242012-01-27 19:12:00 +00002006 grContext->freeGpuResources();
commit-bot@chromium.org95c20032014-05-09 14:29:32 +00002007 SkDebugf("Purged %d bytes from the GPU resource cache.\n", cacheBytes);
twiz@google.com05e70242012-01-27 19:12:00 +00002008 }
2009 }
2010 return true;
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +00002011#endif
reed@android.com0ae6b242008-12-23 16:49:54 +00002012 default:
2013 break;
reed@android.com8a1c16f2008-12-17 15:59:43 +00002014 }
chudy@google.com4605a3f2012-08-01 17:58:01 +00002015
scroggo@google.com7dadc742012-04-18 14:07:57 +00002016 if (fAppMenu->handleKeyEquivalent(uni)|| fSlideMenu->handleKeyEquivalent(uni)) {
2017 this->onUpdateMenu(fAppMenu);
2018 this->onUpdateMenu(fSlideMenu);
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00002019 return true;
2020 }
reed@android.com8a1c16f2008-12-17 15:59:43 +00002021 return this->INHERITED::onHandleChar(uni);
2022}
2023
yangsu@google.com921091f2011-08-02 13:39:12 +00002024void SampleWindow::setDeviceType(DeviceType type) {
robertphillips@google.comb442a6d2012-04-02 19:24:21 +00002025 if (type == fDeviceType)
2026 return;
halcanary9d524f22016-03-29 09:03:52 -07002027
reeda34be682016-02-15 07:48:35 -08002028 fDevManager->tearDownBackend(this);
reeda34be682016-02-15 07:48:35 -08002029 fDeviceType = type;
csmartdalton008b9d82017-02-22 12:00:42 -07002030 fDevManager->setUpBackend(this, fBackendOptions);
halcanary9d524f22016-03-29 09:03:52 -07002031
reeda34be682016-02-15 07:48:35 -08002032 this->updateTitle();
2033 this->inval(nullptr);
2034}
2035
brianosmanb109b8c2016-06-16 13:03:24 -07002036void SampleWindow::setDeviceColorType(SkColorType ct, sk_sp<SkColorSpace> cs) {
2037 this->setColorType(ct, std::move(cs));
robertphillips@google.comb442a6d2012-04-02 19:24:21 +00002038
2039 fDevManager->tearDownBackend(this);
csmartdalton008b9d82017-02-22 12:00:42 -07002040 fDevManager->setUpBackend(this, fBackendOptions);
halcanary9d524f22016-03-29 09:03:52 -07002041
yangsu@google.com921091f2011-08-02 13:39:12 +00002042 this->updateTitle();
halcanary96fcdcc2015-08-27 07:41:13 -07002043 this->inval(nullptr);
yangsu@google.com921091f2011-08-02 13:39:12 +00002044}
2045
Scroggo2c8208f2011-06-15 16:49:08 +00002046void SampleWindow::toggleSlideshow() {
2047 fAnimating = !fAnimating;
2048 this->postAnimatingEvent();
2049 this->updateTitle();
2050}
2051
2052void SampleWindow::toggleRendering() {
robertphillips@google.comb442a6d2012-04-02 19:24:21 +00002053 this->setDeviceType(cycle_devicetype(fDeviceType));
Scroggo2c8208f2011-06-15 16:49:08 +00002054 this->updateTitle();
halcanary96fcdcc2015-08-27 07:41:13 -07002055 this->inval(nullptr);
Scroggo2c8208f2011-06-15 16:49:08 +00002056}
2057
djsollen@google.com6ff82552011-11-07 15:43:57 +00002058void SampleWindow::toggleFPS() {
2059 fMeasureFPS = !fMeasureFPS;
2060 this->updateTitle();
halcanary96fcdcc2015-08-27 07:41:13 -07002061 this->inval(nullptr);
djsollen@google.com6ff82552011-11-07 15:43:57 +00002062}
2063
Yuqian Li5458cf82017-05-24 09:58:07 -04002064void SampleWindow::resetFPS() {
2065 fCumulativeFPS_Time = 0;
2066 fCumulativeFPS_Count = 0;
2067}
2068
reed4302ae92014-10-06 12:29:56 -07002069void SampleWindow::toggleDistanceFieldFonts() {
2070 SkSurfaceProps props = this->getSurfaceProps();
bsalomonafcd7cd2015-08-31 12:39:41 -07002071 uint32_t flags = props.flags() ^ SkSurfaceProps::kUseDeviceIndependentFonts_Flag;
reed4302ae92014-10-06 12:29:56 -07002072 this->setSurfaceProps(SkSurfaceProps(flags, props.pixelGeometry()));
2073
Jim Van Verth3921ba22017-06-27 15:07:31 -04002074 // reset backend
2075 fDevManager->tearDownBackend(this);
2076 fDevManager->setUpBackend(this, fBackendOptions);
2077
reed4302ae92014-10-06 12:29:56 -07002078 this->updateTitle();
halcanary96fcdcc2015-08-27 07:41:13 -07002079 this->inval(nullptr);
reed4302ae92014-10-06 12:29:56 -07002080}
2081
bungeman5a59a422016-03-31 08:30:38 -07002082void SampleWindow::setPixelGeometry(int pixelGeometryIndex) {
bungeman5a59a422016-03-31 08:30:38 -07002083 const SkSurfaceProps& oldProps = this->getSurfaceProps();
2084 SkSurfaceProps newProps(oldProps.flags(), SkSurfaceProps::kLegacyFontHost_InitType);
2085 if (pixelGeometryIndex > 0) {
2086 newProps = SkSurfaceProps(oldProps.flags(),
2087 gPixelGeometryStates[pixelGeometryIndex].pixelGeometry);
2088 }
2089 this->setSurfaceProps(newProps);
2090
Jim Van Verth3921ba22017-06-27 15:07:31 -04002091 // reset backend
2092 fDevManager->tearDownBackend(this);
2093 fDevManager->setUpBackend(this, fBackendOptions);
2094
bungeman5a59a422016-03-31 08:30:38 -07002095 this->updateTitle();
2096 this->inval(nullptr);
2097}
2098
reed@android.com8a1c16f2008-12-17 15:59:43 +00002099#include "SkDumpCanvas.h"
2100
2101bool SampleWindow::onHandleKey(SkKey key) {
reed@android.comf2b98d62010-12-20 18:26:13 +00002102 {
2103 SkView* view = curr_view(this);
2104 if (view) {
2105 SkEvent evt(gKeyEvtName);
2106 evt.setFast32(key);
2107 if (view->doQuery(&evt)) {
2108 return true;
2109 }
2110 }
2111 }
bungemance560262016-03-03 13:32:38 -08002112
2113 int dx = 0xFF;
2114 int dy = 0xFF;
2115
reed@android.com8a1c16f2008-12-17 15:59:43 +00002116 switch (key) {
2117 case kRight_SkKey:
2118 if (this->nextSample()) {
2119 return true;
2120 }
2121 break;
2122 case kLeft_SkKey:
scroggo@google.come2dd9732012-08-15 20:03:06 +00002123 if (this->previousSample()) {
2124 return true;
2125 }
reed@android.com8a1c16f2008-12-17 15:59:43 +00002126 return true;
2127 case kUp_SkKey:
reedf7f79d22015-02-21 09:03:20 -08002128 this->changeZoomLevel(1.f / 32.f);
reed@android.com8a1c16f2008-12-17 15:59:43 +00002129 return true;
2130 case kDown_SkKey:
reedf7f79d22015-02-21 09:03:20 -08002131 this->changeZoomLevel(-1.f / 32.f);
reed@android.com8a1c16f2008-12-17 15:59:43 +00002132 return true;
mike@reedtribe.org6f6e8c32011-12-27 22:33:50 +00002133 case kOK_SkKey: {
2134 SkString title;
2135 if (curr_title(this, &title)) {
2136 writeTitleToPrefs(title.c_str());
reed@android.com8a1c16f2008-12-17 15:59:43 +00002137 }
2138 return true;
mike@reedtribe.org6f6e8c32011-12-27 22:33:50 +00002139 }
reed@android.com34245c72009-11-03 04:00:48 +00002140 case kBack_SkKey:
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00002141 this->showOverview();
reed@android.com34245c72009-11-03 04:00:48 +00002142 return true;
bungemance560262016-03-03 13:32:38 -08002143
2144 case k5_SkKey: dx = 0; dy = 0; break;
2145 case k8_SkKey: dx = 0; dy = -1; break;
2146 case k6_SkKey: dx = 1; dy = 0; break;
2147 case k2_SkKey: dx = 0; dy = 1; break;
2148 case k4_SkKey: dx = -1; dy = 0; break;
2149 case k7_SkKey: dx = -1; dy = -1; break;
2150 case k9_SkKey: dx = 1; dy = -1; break;
2151 case k3_SkKey: dx = 1; dy = 1; break;
2152 case k1_SkKey: dx = -1; dy = 1; break;
2153
reed@android.com8a1c16f2008-12-17 15:59:43 +00002154 default:
2155 break;
2156 }
bungemance560262016-03-03 13:32:38 -08002157
2158 if (0xFF != dx && 0xFF != dy) {
2159 this->changeOffset({SkIntToScalar(dx / 32.0f), SkIntToScalar(dy / 32.0f)});
2160 return true;
2161 }
2162
reed@android.com8a1c16f2008-12-17 15:59:43 +00002163 return this->INHERITED::onHandleKey(key);
2164}
2165
reed@google.com52f57e12011-03-16 12:10:02 +00002166///////////////////////////////////////////////////////////////////////////////
2167
2168static const char gGestureClickType[] = "GestureClickType";
2169
Scroggod3aed392011-06-22 13:26:56 +00002170bool SampleWindow::onDispatchClick(int x, int y, Click::State state,
reed@google.com4d5c26d2013-01-08 16:17:50 +00002171 void* owner, unsigned modi) {
Scroggo0f185c22011-03-24 18:35:50 +00002172 if (Click::kMoved_State == state) {
2173 updatePointer(x, y);
2174 }
reed@google.come1ca7052013-12-17 19:22:07 +00002175 int w = SkScalarRoundToInt(this->width());
2176 int h = SkScalarRoundToInt(this->height());
mike@reedtribe.orgdd0cd342011-03-21 00:53:39 +00002177
2178 // check for the resize-box
2179 if (w - x < 16 && h - y < 16) {
2180 return false; // let the OS handle the click
chudy@google.com4605a3f2012-08-01 17:58:01 +00002181 }
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00002182 else if (fMagnify) {
2183 //it's only necessary to update the drawing if there's a click
halcanary96fcdcc2015-08-27 07:41:13 -07002184 this->inval(nullptr);
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00002185 return false; //prevent dragging while magnify is enabled
reed@google.com4d5c26d2013-01-08 16:17:50 +00002186 } else {
2187 // capture control+option, and trigger debugger
2188 if ((modi & kControl_SkModifierKey) && (modi & kOption_SkModifierKey)) {
2189 if (Click::kDown_State == state) {
2190 SkEvent evt("debug-hit-test");
2191 evt.setS32("debug-hit-test-x", x);
2192 evt.setS32("debug-hit-test-y", y);
2193 curr_view(this)->doEvent(evt);
2194 }
2195 return true;
2196 } else {
2197 return this->INHERITED::onDispatchClick(x, y, state, owner, modi);
2198 }
mike@reedtribe.orgdd0cd342011-03-21 00:53:39 +00002199 }
2200}
2201
reed@google.com52f57e12011-03-16 12:10:02 +00002202class GestureClick : public SkView::Click {
2203public:
2204 GestureClick(SkView* target) : SkView::Click(target) {
2205 this->setType(gGestureClickType);
2206 }
2207
2208 static bool IsGesture(Click* click) {
2209 return click->isType(gGestureClickType);
2210 }
2211};
2212
reed@google.com4d5c26d2013-01-08 16:17:50 +00002213SkView::Click* SampleWindow::onFindClickHandler(SkScalar x, SkScalar y,
2214 unsigned modi) {
reed@google.com52f57e12011-03-16 12:10:02 +00002215 return new GestureClick(this);
2216}
2217
2218bool SampleWindow::onClick(Click* click) {
2219 if (GestureClick::IsGesture(click)) {
bsalomon@google.com4d4f2812011-12-12 18:34:01 +00002220 float x = static_cast<float>(click->fICurr.fX);
2221 float y = static_cast<float>(click->fICurr.fY);
chudy@google.com4605a3f2012-08-01 17:58:01 +00002222
reed@google.com52f57e12011-03-16 12:10:02 +00002223 switch (click->fState) {
2224 case SkView::Click::kDown_State:
Scroggod3aed392011-06-22 13:26:56 +00002225 fGesture.touchBegin(click->fOwner, x, y);
reed@google.com52f57e12011-03-16 12:10:02 +00002226 break;
2227 case SkView::Click::kMoved_State:
Scroggod3aed392011-06-22 13:26:56 +00002228 fGesture.touchMoved(click->fOwner, x, y);
reed@google.comf03bb562011-11-11 21:42:12 +00002229 this->updateMatrix();
reed@google.com52f57e12011-03-16 12:10:02 +00002230 break;
2231 case SkView::Click::kUp_State:
Scroggod3aed392011-06-22 13:26:56 +00002232 fGesture.touchEnd(click->fOwner);
reed@google.comf03bb562011-11-11 21:42:12 +00002233 this->updateMatrix();
reed@google.com52f57e12011-03-16 12:10:02 +00002234 break;
2235 }
2236 return true;
2237 }
2238 return false;
2239}
2240
2241///////////////////////////////////////////////////////////////////////////////
2242
reed@android.com8a1c16f2008-12-17 15:59:43 +00002243void SampleWindow::loadView(SkView* view) {
2244 SkView::F2BIter iter(this);
2245 SkView* prev = iter.next();
2246 if (prev) {
2247 prev->detachFromParent();
2248 }
chudy@google.com4605a3f2012-08-01 17:58:01 +00002249
reed@android.com8a1c16f2008-12-17 15:59:43 +00002250 view->setVisibleP(true);
reed@android.comf2b98d62010-12-20 18:26:13 +00002251 view->setClipToBounds(false);
reed@android.com8a1c16f2008-12-17 15:59:43 +00002252 this->attachChildToFront(view)->unref();
2253 view->setSize(this->width(), this->height());
2254
yangsu@google.com921091f2011-08-02 13:39:12 +00002255 //repopulate the slide menu when a view is loaded
scroggo@google.com7dadc742012-04-18 14:07:57 +00002256 fSlideMenu->reset();
djsollen@google.com388974f2013-01-17 13:20:01 +00002257
scroggo@google.com7dadc742012-04-18 14:07:57 +00002258 this->onUpdateMenu(fSlideMenu);
reed@android.com8a1c16f2008-12-17 15:59:43 +00002259 this->updateTitle();
2260}
2261
bsalomon@google.com098e96d2011-07-14 14:30:46 +00002262static const char* gDeviceTypePrefix[] = {
reed@android.com8a1c16f2008-12-17 15:59:43 +00002263 "raster: ",
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +00002264#if SK_SUPPORT_GPU
bsalomon@google.com74913722011-10-27 20:44:19 +00002265 "opengl: ",
robertphillips@google.comb442a6d2012-04-02 19:24:21 +00002266#if SK_ANGLE
2267 "angle: ",
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +00002268#endif // SK_ANGLE
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +00002269#endif // SK_SUPPORT_GPU
reed@android.com8a1c16f2008-12-17 15:59:43 +00002270};
bungeman99fe8222015-08-20 07:57:51 -07002271static_assert(SK_ARRAY_COUNT(gDeviceTypePrefix) == SampleWindow::kDeviceTypeCnt,
2272 "array_size_mismatch");
reed@android.com8a1c16f2008-12-17 15:59:43 +00002273
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00002274static const char* trystate_str(SkOSMenu::TriState state,
reed@google.com569e0432011-04-05 13:07:03 +00002275 const char trueStr[], const char falseStr[]) {
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00002276 if (SkOSMenu::kOnState == state) {
reed@google.com569e0432011-04-05 13:07:03 +00002277 return trueStr;
yangsu@google.comdb03eaa2011-08-08 15:37:23 +00002278 } else if (SkOSMenu::kOffState == state) {
reed@google.com569e0432011-04-05 13:07:03 +00002279 return falseStr;
2280 }
halcanary96fcdcc2015-08-27 07:41:13 -07002281 return nullptr;
reed@google.com569e0432011-04-05 13:07:03 +00002282}
2283
reedddb5eca2014-10-08 11:10:51 -07002284bool SampleWindow::getRawTitle(SkString* title) {
2285 return curr_title(this, title);
2286}
reed@android.com8a1c16f2008-12-17 15:59:43 +00002287
reedddb5eca2014-10-08 11:10:51 -07002288void SampleWindow::updateTitle() {
Yuqian Li94fddf82017-09-25 14:45:25 -04002289 if (fMeasureMS > 0 && (int)gAnimTimer.msec() > fMeasureMS) {
2290 this->closeWindow();
2291 }
2292
mike@reedtribe.org6f6e8c32011-12-27 22:33:50 +00002293 SkString title;
reedddb5eca2014-10-08 11:10:51 -07002294 if (!this->getRawTitle(&title)) {
reed@android.com8a1c16f2008-12-17 15:59:43 +00002295 title.set("<unknown>");
2296 }
bsalomon@google.com2e7b43d2011-01-18 20:57:22 +00002297
bsalomon@google.com098e96d2011-07-14 14:30:46 +00002298 title.prepend(gDeviceTypePrefix[fDeviceType]);
reed@android.com8a1c16f2008-12-17 15:59:43 +00002299
Yuqian Li70898af2017-06-05 13:36:32 -04002300 if (gSampleWindow->getTiles()) {
2301 title.prependf("[T%d/%d] ", gSampleWindow->getTiles(), gSampleWindow->getThreads());
Yuqian Lib55dd552017-04-03 10:52:48 -04002302 }
2303
Yuqian Lidf60e362017-07-25 11:26:31 -04002304 if (gSkUseDeltaAA) {
2305 if (gSkForceDeltaAA) {
2306 title.prepend("<FDAA> ");
2307 } else {
2308 title.prepend("<DAA> ");
2309 }
2310 } else if (gSkUseAnalyticAA) {
Yuqian Li550148b2017-01-13 10:13:13 -05002311 if (gSkForceAnalyticAA) {
2312 title.prepend("<FAAA> ");
2313 } else {
2314 title.prepend("<AAA> ");
2315 }
liyuqianebcb8aa2016-10-11 12:20:08 -07002316 }
commit-bot@chromium.orgcc63b322013-12-06 20:14:55 +00002317 if (fTilingMode != kNo_Tiling) {
2318 title.prependf("<T: %s> ", gTilingInfo[fTilingMode].label);
2319 }
reed@android.com8a1c16f2008-12-17 15:59:43 +00002320 if (fAnimating) {
2321 title.prepend("<A> ");
2322 }
reed@android.com6c5f6f22009-08-14 16:08:38 +00002323 if (fRotate) {
2324 title.prepend("<R> ");
2325 }
bsalomon@google.come8f09102011-09-08 18:48:12 +00002326 if (fPerspAnim) {
2327 title.prepend("<K> ");
2328 }
bsalomonafcd7cd2015-08-31 12:39:41 -07002329 if (this->getSurfaceProps().flags() & SkSurfaceProps::kUseDeviceIndependentFonts_Flag) {
2330 title.prepend("<DIF> ");
reed4302ae92014-10-06 12:29:56 -07002331 }
reed91b4dfb2016-01-08 08:23:19 -08002332 if (fUsePicture) {
2333 title.prepend("<P> ");
kkinnunen8686a5e2016-01-05 00:04:32 -08002334 }
reedbabc3de2016-07-08 08:43:27 -07002335 if (fUseDeferredCanvas) {
2336 title.prepend("<E> ");
2337 }
Mike Reed8780eda2017-08-07 12:25:19 -04002338 if (gSkForceRasterPipelineBlitter) {
2339 title.prepend("<R> ");
2340 }
reed@google.com569e0432011-04-05 13:07:03 +00002341
2342 title.prepend(trystate_str(fLCDState, "LCD ", "lcd "));
2343 title.prepend(trystate_str(fAAState, "AA ", "aa "));
reed93a12152015-03-16 10:08:34 -07002344 title.prepend(gFilterQualityStates[fFilterQualityIndex].fLabel);
bungeman@google.com96aabc82013-06-03 21:26:34 +00002345 title.prepend(trystate_str(fSubpixelState, "S ", "s "));
halcanary96fcdcc2015-08-27 07:41:13 -07002346 title.prepend(fFlipAxis & kFlipAxis_X ? "X " : nullptr);
2347 title.prepend(fFlipAxis & kFlipAxis_Y ? "Y " : nullptr);
bungeman@google.com96aabc82013-06-03 21:26:34 +00002348 title.prepend(gHintingStates[fHintingState].label);
bungeman5a59a422016-03-31 08:30:38 -07002349 title.prepend(gPixelGeometryStates[fPixelGeometryIndex].label);
mike@reedtribe.orgdd0cd342011-03-21 00:53:39 +00002350
bungemance560262016-03-03 13:32:38 -08002351 if (fOffset.fX || fOffset.fY) {
2352 title.prependf("(%.2f, %.2f) ", SkScalarToFloat(fOffset.fX), SkScalarToFloat(fOffset.fY));
2353 }
mike@reedtribe.orgdd0cd342011-03-21 00:53:39 +00002354 if (fZoomLevel) {
djsollen@google.come32b5832011-06-13 16:58:40 +00002355 title.prependf("{%.2f} ", SkScalarToFloat(fZoomLevel));
mike@reedtribe.orgdd0cd342011-03-21 00:53:39 +00002356 }
chudy@google.com4605a3f2012-08-01 17:58:01 +00002357
mike@reedtribe.org2eb59522011-04-22 01:59:09 +00002358 if (fMeasureFPS) {
jvanverth4d0d81a2015-08-11 11:07:07 -07002359 title.appendf(" %8.4f ms", fMeasureFPS_Time / (float)FPS_REPEAT_COUNT);
Yuqian Li5458cf82017-05-24 09:58:07 -04002360 title.appendf(" -> %4.4f ms", fCumulativeFPS_Time / (float)SkTMax(1, fCumulativeFPS_Count));
mike@reedtribe.org2eb59522011-04-22 01:59:09 +00002361 }
reedddb5eca2014-10-08 11:10:51 -07002362
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +00002363#if SK_SUPPORT_GPU
bsalomon@google.com82502e22013-01-24 20:47:18 +00002364 if (IsGpuDeviceType(fDeviceType) &&
bsalomon49f085d2014-09-05 13:34:00 -07002365 fDevManager &&
robertphillipsecf3dbe2016-07-28 15:17:34 -07002366 fDevManager->numColorSamples() > 0) {
bsalomon@google.com11959252012-04-06 20:13:38 +00002367 title.appendf(" [MSAA: %d]",
robertphillipsecf3dbe2016-07-28 15:17:34 -07002368 fDevManager->numColorSamples());
bsalomon@google.com11959252012-04-06 20:13:38 +00002369 }
bsalomon@google.comcf8fb1f2012-08-02 14:03:32 +00002370#endif
bsalomon@google.com11959252012-04-06 20:13:38 +00002371
brianosman35a02a82016-09-29 14:37:02 -07002372 title.appendf(" %s", gConfig[fColorConfigIndex].fName);
reeda34be682016-02-15 07:48:35 -08002373
brianosman2d1ee792016-05-05 12:24:31 -07002374 if (fDevManager && fDevManager->getColorBits() > 24) {
2375 title.appendf(" %d bpc", fDevManager->getColorBits());
2376 }
2377
reed@android.com8a1c16f2008-12-17 15:59:43 +00002378 this->setTitle(title.c_str());
2379}
2380
2381void SampleWindow::onSizeChange() {
2382 this->INHERITED::onSizeChange();
chudy@google.com4605a3f2012-08-01 17:58:01 +00002383
reed@android.com8a1c16f2008-12-17 15:59:43 +00002384 SkView::F2BIter iter(this);
2385 SkView* view = iter.next();
2386 view->setSize(this->width(), this->height());
bsalomon@google.com2e7b43d2011-01-18 20:57:22 +00002387
reed@android.com8a1c16f2008-12-17 15:59:43 +00002388 // rebuild our clippath
2389 {
2390 const SkScalar W = this->width();
2391 const SkScalar H = this->height();
bsalomon@google.com2e7b43d2011-01-18 20:57:22 +00002392
reed@android.com8a1c16f2008-12-17 15:59:43 +00002393 fClipPath.reset();
2394#if 0
2395 for (SkScalar y = SK_Scalar1; y < H; y += SkIntToScalar(32)) {
2396 SkRect r;
2397 r.set(SK_Scalar1, y, SkIntToScalar(30), y + SkIntToScalar(30));
2398 for (; r.fLeft < W; r.offset(SkIntToScalar(32), 0))
2399 fClipPath.addRect(r);
2400 }
2401#else
2402 SkRect r;
2403 r.set(0, 0, W, H);
2404 fClipPath.addRect(r, SkPath::kCCW_Direction);
2405 r.set(W/4, H/4, W*3/4, H*3/4);
2406 fClipPath.addRect(r, SkPath::kCW_Direction);
2407#endif
2408 }
bsalomon@google.com2e7b43d2011-01-18 20:57:22 +00002409
Scroggo2c8208f2011-06-15 16:49:08 +00002410 fZoomCenterX = SkScalarHalf(this->width());
2411 fZoomCenterY = SkScalarHalf(this->height());
2412
djsollen@google.com56c69772011-11-08 19:00:26 +00002413#ifdef SK_BUILD_FOR_ANDROID
Scroggob4490c72011-06-17 13:53:05 +00002414 // FIXME: The first draw after a size change does not work on Android, so
2415 // we post an invalidate.
Scroggo62b65b02011-06-21 16:01:26 +00002416 this->postInvalDelay();
Scroggo716a0382011-06-16 14:00:15 +00002417#endif
reed@android.com8a1c16f2008-12-17 15:59:43 +00002418 this->updateTitle(); // to refresh our config
bsalomon@google.com098e96d2011-07-14 14:30:46 +00002419 fDevManager->windowSizeChanged(this);
commit-bot@chromium.orgbbe43a92013-12-10 21:51:06 +00002420
2421 if (fTilingMode != kNo_Tiling && SampleView::IsSampleView(view)) {
2422 ((SampleView*)view)->onTileSizeChanged(this->tileSize());
2423 }
reed@android.com8a1c16f2008-12-17 15:59:43 +00002424}
2425
2426///////////////////////////////////////////////////////////////////////////////
2427
reed@android.comf2b98d62010-12-20 18:26:13 +00002428template <typename T> void SkTBSort(T array[], int count) {
2429 for (int i = 1; i < count - 1; i++) {
2430 bool didSwap = false;
2431 for (int j = count - 1; j > i; --j) {
2432 if (array[j] < array[j-1]) {
2433 T tmp(array[j-1]);
2434 array[j-1] = array[j];
2435 array[j] = tmp;
2436 didSwap = true;
2437 }
2438 }
2439 if (!didSwap) {
2440 break;
2441 }
2442 }
bsalomon@google.com2e7b43d2011-01-18 20:57:22 +00002443
reed@android.comf2b98d62010-12-20 18:26:13 +00002444 for (int k = 0; k < count - 1; k++) {
2445 SkASSERT(!(array[k+1] < array[k]));
2446 }
2447}
2448
2449#include "SkRandom.h"
2450
commit-bot@chromium.orge0e7cfe2013-09-09 20:09:12 +00002451static void rand_rect(SkIRect* rect, SkRandom& rand) {
reed@android.comf2b98d62010-12-20 18:26:13 +00002452 int bits = 8;
2453 int shift = 32 - bits;
2454 rect->set(rand.nextU() >> shift, rand.nextU() >> shift,
2455 rand.nextU() >> shift, rand.nextU() >> shift);
2456 rect->sort();
2457}
2458
2459static void dumpRect(const SkIRect& r) {
2460 SkDebugf(" { %d, %d, %d, %d },\n",
2461 r.fLeft, r.fTop,
2462 r.fRight, r.fBottom);
2463}
2464
2465static void test_rects(const SkIRect rect[], int count) {
2466 SkRegion rgn0, rgn1;
2467
2468 for (int i = 0; i < count; i++) {
2469 rgn0.op(rect[i], SkRegion::kUnion_Op);
2470 // dumpRect(rect[i]);
2471 }
2472 rgn1.setRects(rect, count);
2473
2474 if (rgn0 != rgn1) {
2475 SkDebugf("\n");
2476 for (int i = 0; i < count; i++) {
2477 dumpRect(rect[i]);
2478 }
2479 SkDebugf("\n");
2480 }
2481}
2482
2483static void test() {
2484 size_t i;
2485
2486 const SkIRect r0[] = {
2487 { 0, 0, 1, 1 },
2488 { 2, 2, 3, 3 },
2489 };
2490 const SkIRect r1[] = {
2491 { 0, 0, 1, 3 },
2492 { 1, 1, 2, 2 },
2493 { 2, 0, 3, 3 },
2494 };
2495 const SkIRect r2[] = {
2496 { 0, 0, 1, 2 },
2497 { 2, 1, 3, 3 },
2498 { 4, 0, 5, 1 },
2499 { 6, 0, 7, 4 },
2500 };
2501
2502 static const struct {
2503 const SkIRect* fRects;
2504 int fCount;
2505 } gRecs[] = {
2506 { r0, SK_ARRAY_COUNT(r0) },
2507 { r1, SK_ARRAY_COUNT(r1) },
2508 { r2, SK_ARRAY_COUNT(r2) },
2509 };
2510
2511 for (i = 0; i < SK_ARRAY_COUNT(gRecs); i++) {
2512 test_rects(gRecs[i].fRects, gRecs[i].fCount);
2513 }
bsalomon@google.com2e7b43d2011-01-18 20:57:22 +00002514
commit-bot@chromium.orge0e7cfe2013-09-09 20:09:12 +00002515 SkRandom rand;
reed@android.comf2b98d62010-12-20 18:26:13 +00002516 for (i = 0; i < 10000; i++) {
2517 SkRegion rgn0, rgn1;
2518
2519 const int N = 8;
2520 SkIRect rect[N];
2521 for (int j = 0; j < N; j++) {
2522 rand_rect(&rect[j], rand);
2523 }
2524 test_rects(rect, N);
2525 }
2526}
2527
caryclark@google.com02939ce2012-06-06 12:09:51 +00002528// FIXME: this should be in a header
2529SkOSWindow* create_sk_window(void* hwnd, int argc, char** argv);
senorblanco@chromium.org78b82532011-06-28 19:44:03 +00002530SkOSWindow* create_sk_window(void* hwnd, int argc, char** argv) {
Yuqian Li6e3d9952017-09-27 13:25:36 -04002531 SkCommandLineFlags::Parse(argc, argv);
2532
caryclark@google.com02939ce2012-06-06 12:09:51 +00002533 if (false) { // avoid bit rot, suppress warning
2534 test();
2535 }
halcanary96fcdcc2015-08-27 07:41:13 -07002536 return new SampleWindow(hwnd, argc, argv, nullptr);
reed@android.com8a1c16f2008-12-17 15:59:43 +00002537}
2538
caryclark@google.com5987f582012-10-02 18:33:14 +00002539#ifdef SK_BUILD_FOR_IOS
reedf0b17102014-10-22 13:06:00 -07002540#include "SkApplication.h"
caryclark17f0b6d2014-07-22 10:15:34 -07002541IOS_launch_type set_cmd_line_args(int , char *[], const char* resourceDir) {
caryclarkf568f6a2014-07-18 10:58:56 -07002542 SetResourcePath(resourceDir);
caryclark17f0b6d2014-07-22 10:15:34 -07002543 return kApplication__iOSLaunchType;
caryclark@google.com5987f582012-10-02 18:33:14 +00002544}
2545#endif
2546
reed@android.com8a1c16f2008-12-17 15:59:43 +00002547void application_init() {
2548// setenv("ANDROID_ROOT", "../../../data", 0);
reed@android.come191b162009-12-18 21:33:39 +00002549#ifdef SK_BUILD_FOR_MAC
reed@android.com8a1c16f2008-12-17 15:59:43 +00002550 setenv("ANDROID_ROOT", "/android/device/data", 0);
reed@android.come191b162009-12-18 21:33:39 +00002551#endif
bsalomon@google.com2fbc7fa2011-01-05 16:34:41 +00002552 SkGraphics::Init();
2553 SkEvent::Init();
reed@android.com8a1c16f2008-12-17 15:59:43 +00002554}
2555
2556void application_term() {
bsalomon@google.com2fbc7fa2011-01-05 16:34:41 +00002557 SkEvent::Term();
reed@android.com8a1c16f2008-12-17 15:59:43 +00002558}