SampleApp.cpp revision 16e3ddea6a80972aced04b21b1d66377fa95e7c7 
1/*
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 */
7#include "SampleApp.h"
8
9#include "SkData.h"
10#include "SkCanvas.h"
11#include "SkDevice.h"
12#include "SkGraphics.h"
13#include "SkImageEncoder.h"
14#include "SkPaint.h"
15#include "SkPicture.h"
16#include "SkStream.h"
17#include "SkTime.h"
18#include "SkWindow.h"
19
20#include "SampleCode.h"
21#include "SkTypeface.h"
22
23#if SK_SUPPORT_GPU
24#include "gl/GrGLInterface.h"
25#include "gl/GrGLUtil.h"
26#include "GrRenderTarget.h"
27#include "GrContext.h"
28#include "SkGpuDevice.h"
29#else
30class GrContext;
31#endif
32
33#include "SkOSFile.h"
34#include "SkPDFDevice.h"
35#include "SkPDFDocument.h"
36#include "SkStream.h"
37
38#include "SkGPipe.h"
39#include "SamplePipeControllers.h"
40#include "OverView.h"
41#include "TransitionView.h"
42
43SK_DEFINE_INST_COUNT(SampleWindow::DeviceManager)
44
45extern SampleView* CreateSamplePictFileView(const char filename[]);
46
47class PictFileFactory : public SkViewFactory {
48    SkString fFilename;
49public:
50    PictFileFactory(const SkString& filename) : fFilename(filename) {}
51    virtual SkView* operator() () const SK_OVERRIDE {
52        return CreateSamplePictFileView(fFilename.c_str());
53    }
54};
55
56#define PIPE_FILEx
57#ifdef  PIPE_FILE
58#define FILE_PATH "/path/to/drawing.data"
59#endif
60
61#define PIPE_NETx
62#ifdef  PIPE_NET
63#include "SkSockets.h"
64SkTCPServer gServer;
65#endif
66
67#define DEBUGGERx
68#ifdef  DEBUGGER
69extern SkView* create_debugger(const char* data, size_t size);
70extern bool is_debugger(SkView* view);
71SkTDArray<char> gTempDataStore;
72#endif
73
74
75#define USE_ARROWS_FOR_ZOOM true
76
77#if SK_ANGLE
78//#define DEFAULT_TO_ANGLE 1
79#else
80//#define DEFAULT_TO_GPU 1
81#endif
82
83#define ANIMATING_EVENTTYPE "nextSample"
84#define ANIMATING_DELAY     750
85
86#ifdef SK_DEBUG
87    #define FPS_REPEAT_MULTIPLIER   1
88#else
89    #define FPS_REPEAT_MULTIPLIER   10
90#endif
91#define FPS_REPEAT_COUNT    (10 * FPS_REPEAT_MULTIPLIER)
92
93static SampleWindow* gSampleWindow;
94
95static void postEventToSink(SkEvent* evt, SkEventSink* sink) {
96    evt->setTargetID(sink->getSinkID())->post();
97}
98
99///////////////////////////////////////////////////////////////////////////////
100
101static const char* skip_until(const char* str, const char* skip) {
102    if (!str) {
103        return NULL;
104    }
105    return strstr(str, skip);
106}
107
108static const char* skip_past(const char* str, const char* skip) {
109    const char* found = skip_until(str, skip);
110    if (!found) {
111        return NULL;
112    }
113    return found + strlen(skip);
114}
115
116static const char* gPrefFileName = "sampleapp_prefs.txt";
117
118static bool readTitleFromPrefs(SkString* title) {
119    SkFILEStream stream(gPrefFileName);
120    if (!stream.isValid()) {
121        return false;
122    }
123
124    int len = stream.getLength();
125    SkString data(len);
126    stream.read(data.writable_str(), len);
127    const char* s = data.c_str();
128
129    s = skip_past(s, "curr-slide-title");
130    s = skip_past(s, "=");
131    s = skip_past(s, "\"");
132    const char* stop = skip_until(s, "\"");
133    if (stop > s) {
134        title->set(s, stop - s);
135        return true;
136    }
137    return false;
138}
139
140static void writeTitleToPrefs(const char* title) {
141    SkFILEWStream stream(gPrefFileName);
142    SkString data;
143    data.printf("curr-slide-title = \"%s\"\n", title);
144    stream.write(data.c_str(), data.size());
145}
146
147///////////////////////////////////////////////////////////////////////////////
148
149class SampleWindow::DefaultDeviceManager : public SampleWindow::DeviceManager {
150public:
151
152    DefaultDeviceManager() {
153#if SK_SUPPORT_GPU
154        fCurContext = NULL;
155        fCurIntf = NULL;
156        fCurRenderTarget = NULL;
157        fMSAASampleCount = 0;
158#endif
159        fBackend = kNone_BackEndType;
160    }
161
162    virtual ~DefaultDeviceManager() {
163#if SK_SUPPORT_GPU
164        SkSafeUnref(fCurContext);
165        SkSafeUnref(fCurIntf);
166        SkSafeUnref(fCurRenderTarget);
167#endif
168    }
169
170    virtual void setUpBackend(SampleWindow* win, int msaaSampleCount) {
171        SkASSERT(kNone_BackEndType == fBackend);
172
173        fBackend = kNone_BackEndType;
174
175#if SK_SUPPORT_GPU
176        switch (win->getDeviceType()) {
177            case kRaster_DeviceType:
178                // fallthrough
179            case kPicture_DeviceType:
180                // fallthrough
181            case kGPU_DeviceType:
182                // fallthrough
183            case kNullGPU_DeviceType:
184                // all these guys use the native backend
185                fBackend = kNativeGL_BackEndType;
186                break;
187#if SK_ANGLE
188            case kANGLE_DeviceType:
189                // ANGLE is really the only odd man out
190                fBackend = kANGLE_BackEndType;
191                break;
192#endif // SK_ANGLE
193            default:
194                SkASSERT(false);
195                break;
196        }
197
198        bool result = win->attach(fBackend, msaaSampleCount);
199        if (!result) {
200            SkDebugf("Failed to initialize GL");
201            return;
202        }
203        fMSAASampleCount = msaaSampleCount;
204
205        SkASSERT(NULL == fCurIntf);
206        switch (win->getDeviceType()) {
207            case kRaster_DeviceType:
208                // fallthrough
209            case kPicture_DeviceType:
210                // fallthrough
211            case kGPU_DeviceType:
212                // all these guys use the native interface
213                fCurIntf = GrGLCreateNativeInterface();
214                break;
215#if SK_ANGLE
216            case kANGLE_DeviceType:
217                fCurIntf = GrGLCreateANGLEInterface();
218                break;
219#endif // SK_ANGLE
220            case kNullGPU_DeviceType:
221                fCurIntf = GrGLCreateNullInterface();
222                break;
223            default:
224                SkASSERT(false);
225                break;
226        }
227
228        SkASSERT(NULL == fCurContext);
229        fCurContext = GrContext::Create(kOpenGL_GrBackend, (GrBackendContext) fCurIntf);
230
231        if (NULL == fCurContext || NULL == fCurIntf) {
232            // We need some context and interface to see results
233            SkSafeUnref(fCurContext);
234            SkSafeUnref(fCurIntf);
235            SkDebugf("Failed to setup 3D");
236
237            win->detach();
238        }
239#endif // SK_SUPPORT_GPU
240        // call windowSizeChanged to create the render target
241        this->windowSizeChanged(win);
242    }
243
244    virtual void tearDownBackend(SampleWindow *win) {
245#if SK_SUPPORT_GPU
246        SkSafeUnref(fCurContext);
247        fCurContext = NULL;
248
249        SkSafeUnref(fCurIntf);
250        fCurIntf = NULL;
251
252        SkSafeUnref(fCurRenderTarget);
253        fCurRenderTarget = NULL;
254#endif
255        win->detach();
256        fBackend = kNone_BackEndType;
257    }
258
259    virtual SkCanvas* createCanvas(SampleWindow::DeviceType dType,
260                                   SampleWindow* win) {
261        switch (dType) {
262            case kRaster_DeviceType:
263                // fallthrough
264            case kPicture_DeviceType:
265                // fallthrough
266#if SK_ANGLE
267            case kANGLE_DeviceType:
268#endif
269                break;
270#if SK_SUPPORT_GPU
271            case kGPU_DeviceType:
272            case kNullGPU_DeviceType:
273                if (fCurContext) {
274                    SkAutoTUnref<SkDevice> device(new SkGpuDevice(fCurContext,
275                                                                  fCurRenderTarget));
276                    return new SkCanvas(device);
277                } else {
278                    return NULL;
279                }
280                break;
281#endif
282            default:
283                SkASSERT(false);
284                return NULL;
285        }
286        return NULL;
287    }
288
289    virtual void publishCanvas(SampleWindow::DeviceType dType,
290                               SkCanvas* canvas,
291                               SampleWindow* win) {
292#if SK_SUPPORT_GPU
293        if (fCurContext) {
294            // in case we have queued drawing calls
295            fCurContext->flush();
296
297            if (kGPU_DeviceType != dType && kNullGPU_DeviceType != dType) {
298                // need to send the raster bits to the (gpu) window
299                fCurContext->setRenderTarget(fCurRenderTarget);
300                const SkBitmap& bm = win->getBitmap();
301                fCurRenderTarget->writePixels(0, 0, bm.width(), bm.height(),
302                                             kSkia8888_PM_GrPixelConfig,
303                                             bm.getPixels(),
304                                             bm.rowBytes());
305            }
306        }
307#endif
308
309        win->present();
310    }
311
312    virtual void windowSizeChanged(SampleWindow* win) {
313#if SK_SUPPORT_GPU
314        if (fCurContext) {
315            win->attach(fBackend, fMSAASampleCount);
316
317            GrBackendRenderTargetDesc desc;
318            desc.fWidth = SkScalarRound(win->width());
319            desc.fHeight = SkScalarRound(win->height());
320            desc.fConfig = kSkia8888_PM_GrPixelConfig;
321            GR_GL_GetIntegerv(fCurIntf, GR_GL_SAMPLES, &desc.fSampleCnt);
322            GR_GL_GetIntegerv(fCurIntf, GR_GL_STENCIL_BITS, &desc.fStencilBits);
323            GrGLint buffer;
324            GR_GL_GetIntegerv(fCurIntf, GR_GL_FRAMEBUFFER_BINDING, &buffer);
325            desc.fRenderTargetHandle = buffer;
326
327            SkSafeUnref(fCurRenderTarget);
328            fCurRenderTarget = fCurContext->wrapBackendRenderTarget(desc);
329        }
330#endif
331    }
332
333    virtual GrContext* getGrContext() {
334#if SK_SUPPORT_GPU
335        return fCurContext;
336#else
337        return NULL;
338#endif
339    }
340
341    virtual GrRenderTarget* getGrRenderTarget() SK_OVERRIDE {
342#if SK_SUPPORT_GPU
343        return fCurRenderTarget;
344#else
345        return NULL;
346#endif
347    }
348
349private:
350
351#if SK_SUPPORT_GPU
352    GrContext*              fCurContext;
353    const GrGLInterface*    fCurIntf;
354    GrRenderTarget*         fCurRenderTarget;
355    int fMSAASampleCount;
356#endif
357
358    SkOSWindow::SkBackEndTypes fBackend;
359
360    typedef SampleWindow::DeviceManager INHERITED;
361};
362
363///////////////
364static const char view_inval_msg[] = "view-inval-msg";
365
366void SampleWindow::postInvalDelay() {
367    (new SkEvent(view_inval_msg, this->getSinkID()))->postDelay(1);
368}
369
370static bool isInvalEvent(const SkEvent& evt) {
371    return evt.isType(view_inval_msg);
372}
373//////////////////
374
375SkFuncViewFactory::SkFuncViewFactory(SkViewCreateFunc func)
376    : fCreateFunc(func) {
377}
378
379SkView* SkFuncViewFactory::operator() () const {
380    return (*fCreateFunc)();
381}
382
383#include "GMSampleView.h"
384
385SkGMSampleViewFactory::SkGMSampleViewFactory(GMFactoryFunc func)
386    : fFunc(func) {
387}
388
389SkView* SkGMSampleViewFactory::operator() () const {
390    return new GMSampleView(fFunc(NULL));
391}
392
393SkViewRegister* SkViewRegister::gHead;
394SkViewRegister::SkViewRegister(SkViewFactory* fact) : fFact(fact) {
395    fFact->ref();
396    fChain = gHead;
397    gHead = this;
398}
399
400SkViewRegister::SkViewRegister(SkViewCreateFunc func) {
401    fFact = new SkFuncViewFactory(func);
402    fChain = gHead;
403    gHead = this;
404}
405
406SkViewRegister::SkViewRegister(GMFactoryFunc func) {
407    fFact = new SkGMSampleViewFactory(func);
408    fChain = gHead;
409    gHead = this;
410}
411
412class AutoUnrefArray {
413public:
414    AutoUnrefArray() {}
415    ~AutoUnrefArray() {
416        int count = fObjs.count();
417        for (int i = 0; i < count; ++i) {
418            fObjs[i]->unref();
419        }
420    }
421    SkRefCnt*& push_back() { return *fObjs.append(); }
422
423private:
424    SkTDArray<SkRefCnt*> fObjs;
425};
426
427// registers GMs as Samples
428// This can't be performed during static initialization because it could be
429// run before GMRegistry has been fully built.
430static void SkGMRegistyToSampleRegistry() {
431    static bool gOnce;
432    static AutoUnrefArray fRegisters;
433
434    if (!gOnce) {
435        const skiagm::GMRegistry* gmreg = skiagm::GMRegistry::Head();
436        while (gmreg) {
437            fRegisters.push_back() = new SkViewRegister(gmreg->factory());
438            gmreg = gmreg->next();
439        }
440        gOnce = true;
441    }
442}
443
444#if 0
445#include <CoreFoundation/CoreFoundation.h>
446#include <CoreFoundation/CFURLAccess.h>
447
448static void testpdf() {
449    CFStringRef path = CFStringCreateWithCString(NULL, "/test.pdf",
450                                                 kCFStringEncodingUTF8);
451    CFURLRef url = CFURLCreateWithFileSystemPath(NULL, path,
452                                              kCFURLPOSIXPathStyle,
453                                              false);
454    CFRelease(path);
455    CGRect box = CGRectMake(0, 0, 8*72, 10*72);
456    CGContextRef cg = CGPDFContextCreateWithURL(url, &box, NULL);
457    CFRelease(url);
458
459    CGContextBeginPage(cg, &box);
460    CGRect r = CGRectMake(10, 10, 40 + 0.5, 50 + 0.5);
461    CGContextFillEllipseInRect(cg, r);
462    CGContextEndPage(cg);
463    CGContextRelease(cg);
464
465    if (false) {
466        SkBitmap bm;
467        bm.setConfig(SkBitmap::kA8_Config, 64, 64);
468        bm.allocPixels();
469        bm.eraseColor(0);
470
471        SkCanvas canvas(bm);
472
473    }
474}
475#endif
476
477//////////////////////////////////////////////////////////////////////////////
478
479enum FlipAxisEnum {
480    kFlipAxis_X = (1 << 0),
481    kFlipAxis_Y = (1 << 1)
482};
483
484#include "SkDrawFilter.h"
485
486class FlagsDrawFilter : public SkDrawFilter {
487public:
488    FlagsDrawFilter(SkOSMenu::TriState lcd, SkOSMenu::TriState aa, SkOSMenu::TriState filter,
489                    SkOSMenu::TriState hinting) :
490        fLCDState(lcd), fAAState(aa), fFilterState(filter), fHintingState(hinting) {}
491
492    virtual void filter(SkPaint* paint, Type t) {
493        if (kText_Type == t && SkOSMenu::kMixedState != fLCDState) {
494            paint->setLCDRenderText(SkOSMenu::kOnState == fLCDState);
495        }
496        if (SkOSMenu::kMixedState != fAAState) {
497            paint->setAntiAlias(SkOSMenu::kOnState == fAAState);
498        }
499        if (SkOSMenu::kMixedState != fFilterState) {
500            paint->setFilterBitmap(SkOSMenu::kOnState == fFilterState);
501        }
502        if (SkOSMenu::kMixedState != fHintingState) {
503            paint->setHinting(SkOSMenu::kOnState == fHintingState ?
504                              SkPaint::kNormal_Hinting :
505                              SkPaint::kSlight_Hinting);
506        }
507    }
508
509private:
510    SkOSMenu::TriState  fLCDState;
511    SkOSMenu::TriState  fAAState;
512    SkOSMenu::TriState  fFilterState;
513    SkOSMenu::TriState  fHintingState;
514};
515
516//////////////////////////////////////////////////////////////////////////////
517
518#define MAX_ZOOM_LEVEL  8
519#define MIN_ZOOM_LEVEL  -8
520
521static const char gCharEvtName[] = "SampleCode_Char_Event";
522static const char gKeyEvtName[] = "SampleCode_Key_Event";
523static const char gTitleEvtName[] = "SampleCode_Title_Event";
524static const char gPrefSizeEvtName[] = "SampleCode_PrefSize_Event";
525static const char gFastTextEvtName[] = "SampleCode_FastText_Event";
526static const char gUpdateWindowTitleEvtName[] = "SampleCode_UpdateWindowTitle";
527
528bool SampleCode::CharQ(const SkEvent& evt, SkUnichar* outUni) {
529    if (evt.isType(gCharEvtName, sizeof(gCharEvtName) - 1)) {
530        if (outUni) {
531            *outUni = evt.getFast32();
532        }
533        return true;
534    }
535    return false;
536}
537
538bool SampleCode::KeyQ(const SkEvent& evt, SkKey* outKey) {
539    if (evt.isType(gKeyEvtName, sizeof(gKeyEvtName) - 1)) {
540        if (outKey) {
541            *outKey = (SkKey)evt.getFast32();
542        }
543        return true;
544    }
545    return false;
546}
547
548bool SampleCode::TitleQ(const SkEvent& evt) {
549    return evt.isType(gTitleEvtName, sizeof(gTitleEvtName) - 1);
550}
551
552void SampleCode::TitleR(SkEvent* evt, const char title[]) {
553    SkASSERT(evt && TitleQ(*evt));
554    evt->setString(gTitleEvtName, title);
555}
556
557bool SampleCode::RequestTitle(SkView* view, SkString* title) {
558    SkEvent evt(gTitleEvtName);
559    if (view->doQuery(&evt)) {
560        title->set(evt.findString(gTitleEvtName));
561        return true;
562    }
563    return false;
564}
565
566bool SampleCode::PrefSizeQ(const SkEvent& evt) {
567    return evt.isType(gPrefSizeEvtName, sizeof(gPrefSizeEvtName) - 1);
568}
569
570void SampleCode::PrefSizeR(SkEvent* evt, SkScalar width, SkScalar height) {
571    SkASSERT(evt && PrefSizeQ(*evt));
572    SkScalar size[2];
573    size[0] = width;
574    size[1] = height;
575    evt->setScalars(gPrefSizeEvtName, 2, size);
576}
577
578bool SampleCode::FastTextQ(const SkEvent& evt) {
579    return evt.isType(gFastTextEvtName, sizeof(gFastTextEvtName) - 1);
580}
581
582///////////////////////////////////////////////////////////////////////////////
583
584static SkMSec gAnimTime;
585static SkMSec gAnimTimePrev;
586
587SkMSec SampleCode::GetAnimTime() { return gAnimTime; }
588SkMSec SampleCode::GetAnimTimeDelta() { return gAnimTime - gAnimTimePrev; }
589SkScalar SampleCode::GetAnimSecondsDelta() {
590    return SkDoubleToScalar(GetAnimTimeDelta() / 1000.0);
591}
592
593SkScalar SampleCode::GetAnimScalar(SkScalar speed, SkScalar period) {
594    // since gAnimTime can be up to 32 bits, we can't convert it to a float
595    // or we'll lose the low bits. Hence we use doubles for the intermediate
596    // calculations
597    double seconds = (double)gAnimTime / 1000.0;
598    double value = SkScalarToDouble(speed) * seconds;
599    if (period) {
600        value = ::fmod(value, SkScalarToDouble(period));
601    }
602    return SkDoubleToScalar(value);
603}
604
605SkScalar SampleCode::GetAnimSinScalar(SkScalar amplitude,
606                                      SkScalar periodInSec,
607                                      SkScalar phaseInSec) {
608    if (!periodInSec) {
609        return 0;
610    }
611    double t = (double)gAnimTime / 1000.0 + phaseInSec;
612    t *= SkScalarToFloat(2 * SK_ScalarPI) / periodInSec;
613    amplitude = SK_ScalarHalf * amplitude;
614    return SkScalarMul(amplitude, SkDoubleToScalar(sin(t))) + amplitude;
615}
616
617GrContext* SampleCode::GetGr() {
618    return gSampleWindow ? gSampleWindow->getGrContext() : NULL;
619}
620
621// some GMs rely on having a skiagm::GetGr function defined
622namespace skiagm {
623    // FIXME: this should be moved into a header
624    GrContext* GetGr();
625    GrContext* GetGr() { return SampleCode::GetGr(); }
626}
627
628//////////////////////////////////////////////////////////////////////////////
629
630static SkView* curr_view(SkWindow* wind) {
631    SkView::F2BIter iter(wind);
632    return iter.next();
633}
634
635static bool curr_title(SkWindow* wind, SkString* title) {
636    SkView* view = curr_view(wind);
637    if (view) {
638        SkEvent evt(gTitleEvtName);
639        if (view->doQuery(&evt)) {
640            title->set(evt.findString(gTitleEvtName));
641            return true;
642        }
643    }
644    return false;
645}
646
647void SampleWindow::setZoomCenter(float x, float y)
648{
649    fZoomCenterX = SkFloatToScalar(x);
650    fZoomCenterY = SkFloatToScalar(y);
651}
652
653bool SampleWindow::zoomIn()
654{
655    // Arbitrarily decided
656    if (fFatBitsScale == 25) return false;
657    fFatBitsScale++;
658    this->inval(NULL);
659    return true;
660}
661
662bool SampleWindow::zoomOut()
663{
664    if (fFatBitsScale == 1) return false;
665    fFatBitsScale--;
666    this->inval(NULL);
667    return true;
668}
669
670void SampleWindow::updatePointer(int x, int y)
671{
672    fMouseX = x;
673    fMouseY = y;
674    if (fShowZoomer) {
675        this->inval(NULL);
676    }
677}
678
679static inline SampleWindow::DeviceType cycle_devicetype(SampleWindow::DeviceType ct) {
680    static const SampleWindow::DeviceType gCT[] = {
681        SampleWindow::kPicture_DeviceType,
682#if SK_SUPPORT_GPU
683        SampleWindow::kGPU_DeviceType,
684#if SK_ANGLE
685        SampleWindow::kANGLE_DeviceType,
686#endif // SK_ANGLE
687        SampleWindow::kRaster_DeviceType, // skip the null gpu device in normal cycling
688#endif // SK_SUPPORT_GPU
689        SampleWindow::kRaster_DeviceType
690    };
691    SK_COMPILE_ASSERT(SK_ARRAY_COUNT(gCT) == SampleWindow::kDeviceTypeCnt, array_size_mismatch);
692    return gCT[ct];
693}
694
695static void usage(const char * argv0) {
696    SkDebugf("%s [--slide sampleName] [-i resourcePath] [--msaa sampleCount] [--pictureDir dirPath] [--picture path]\n", argv0);
697    SkDebugf("    sampleName: sample at which to start.\n");
698    SkDebugf("    resourcePath: directory that stores image resources.\n");
699    SkDebugf("    msaa: request multisampling with the given sample count.\n");
700    SkDebugf("    dirPath: path to directory skia pictures are read from\n");
701    SkDebugf("    path: path to skia picture\n");
702}
703
704SampleWindow::SampleWindow(void* hwnd, int argc, char** argv, DeviceManager* devManager)
705    : INHERITED(hwnd)
706    , fDevManager(NULL) {
707
708    this->registerPictFileSamples(argv, argc);
709    this->registerPictFileSample(argv, argc);
710    SkGMRegistyToSampleRegistry();
711    {
712        const SkViewRegister* reg = SkViewRegister::Head();
713        while (reg) {
714            *fSamples.append() = reg->factory();
715            reg = reg->next();
716        }
717    }
718
719    const char* resourcePath = NULL;
720    fCurrIndex = -1;
721    fMSAASampleCount = 0;
722
723    const char* const commandName = argv[0];
724    char* const* stop = argv + argc;
725    for (++argv; argv < stop; ++argv) {
726        if (strcmp(*argv, "-i") == 0) {
727            argv++;
728            if (argv < stop && **argv) {
729                resourcePath = *argv;
730            }
731        } else if (strcmp(*argv, "--slide") == 0) {
732            argv++;
733            if (argv < stop && **argv) {
734                fCurrIndex = findByTitle(*argv);
735                if (fCurrIndex < 0) {
736                    fprintf(stderr, "Unknown sample \"%s\"\n", *argv);
737                    listTitles();
738                }
739            }
740        } else if (strcmp(*argv, "--msaa") == 0) {
741            ++argv;
742            if (argv < stop && **argv) {
743                fMSAASampleCount = atoi(*argv);
744            }
745        } else if (strcmp(*argv, "--list") == 0) {
746            listTitles();
747        }
748        else {
749            usage(commandName);
750        }
751    }
752
753    if (fCurrIndex < 0) {
754        SkString title;
755        if (readTitleFromPrefs(&title)) {
756            fCurrIndex = findByTitle(title.c_str());
757        }
758    }
759
760    if (fCurrIndex < 0) {
761        fCurrIndex = 0;
762    }
763
764    gSampleWindow = this;
765
766#ifdef  PIPE_FILE
767    //Clear existing file or create file if it doesn't exist
768    FILE* f = fopen(FILE_PATH, "wb");
769    fclose(f);
770#endif
771
772    fPicture = NULL;
773
774    fDeviceType = kRaster_DeviceType;
775
776#if DEFAULT_TO_GPU
777    fDeviceType = kGPU_DeviceType;
778#endif
779#if SK_ANGLE && DEFAULT_TO_ANGLE
780    fDeviceType = kANGLE_DeviceType;
781#endif
782
783    fUseClip = false;
784    fNClip = false;
785    fAnimating = false;
786    fRotate = false;
787    fPerspAnim = false;
788    fPerspAnimTime = 0;
789    fScale = false;
790    fRequestGrabImage = false;
791    fPipeState = SkOSMenu::kOffState;
792    fTilingState = SkOSMenu::kOffState;
793    fTileCount.set(1, 1);
794    fMeasureFPS = false;
795    fLCDState = SkOSMenu::kMixedState;
796    fAAState = SkOSMenu::kMixedState;
797    fFilterState = SkOSMenu::kMixedState;
798    fHintingState = SkOSMenu::kMixedState;
799    fFlipAxis = 0;
800    fScrollTestX = fScrollTestY = 0;
801
802    fMouseX = fMouseY = 0;
803    fFatBitsScale = 8;
804    fTypeface = SkTypeface::CreateFromTypeface(NULL, SkTypeface::kBold);
805    fShowZoomer = false;
806
807    fZoomLevel = 0;
808    fZoomScale = SK_Scalar1;
809
810    fMagnify = false;
811    fDebugger = false;
812
813    fSaveToPdf = false;
814    fPdfCanvas = NULL;
815
816    fTransitionNext = 6;
817    fTransitionPrev = 2;
818
819    int sinkID = this->getSinkID();
820    fAppMenu = new SkOSMenu;
821    fAppMenu->setTitle("Global Settings");
822    int itemID;
823
824    itemID =fAppMenu->appendList("Device Type", "Device Type", sinkID, 0,
825                                "Raster", "Picture", "OpenGL",
826#if SK_ANGLE
827                                "ANGLE",
828#endif
829                                NULL);
830    fAppMenu->assignKeyEquivalentToItem(itemID, 'd');
831    itemID = fAppMenu->appendTriState("AA", "AA", sinkID, fAAState);
832    fAppMenu->assignKeyEquivalentToItem(itemID, 'b');
833    itemID = fAppMenu->appendTriState("LCD", "LCD", sinkID, fLCDState);
834    fAppMenu->assignKeyEquivalentToItem(itemID, 'l');
835    itemID = fAppMenu->appendTriState("Filter", "Filter", sinkID, fFilterState);
836    fAppMenu->assignKeyEquivalentToItem(itemID, 'n');
837    itemID = fAppMenu->appendTriState("Hinting", "Hinting", sinkID, fHintingState);
838    fAppMenu->assignKeyEquivalentToItem(itemID, 'h');
839
840    fUsePipeMenuItemID = fAppMenu->appendTriState("Pipe", "Pipe" , sinkID,
841                                                  fPipeState);
842    fAppMenu->assignKeyEquivalentToItem(fUsePipeMenuItemID, 'P');
843
844    itemID = fAppMenu->appendTriState("Tiling", "Tiling", sinkID, fTilingState);
845    fAppMenu->assignKeyEquivalentToItem(itemID, 't');
846
847#ifdef DEBUGGER
848    itemID = fAppMenu->appendSwitch("Debugger", "Debugger", sinkID, fDebugger);
849    fAppMenu->assignKeyEquivalentToItem(itemID, 'q');
850#endif
851    itemID = fAppMenu->appendSwitch("Slide Show", "Slide Show" , sinkID, false);
852    fAppMenu->assignKeyEquivalentToItem(itemID, 'a');
853    itemID = fAppMenu->appendSwitch("Clip", "Clip" , sinkID, fUseClip);
854    fAppMenu->assignKeyEquivalentToItem(itemID, 'c');
855    itemID = fAppMenu->appendSwitch("Flip X", "Flip X" , sinkID, false);
856    fAppMenu->assignKeyEquivalentToItem(itemID, 'x');
857    itemID = fAppMenu->appendSwitch("Flip Y", "Flip Y" , sinkID, false);
858    fAppMenu->assignKeyEquivalentToItem(itemID, 'y');
859    itemID = fAppMenu->appendSwitch("Zoomer", "Zoomer" , sinkID, fShowZoomer);
860    fAppMenu->assignKeyEquivalentToItem(itemID, 'z');
861    itemID = fAppMenu->appendSwitch("Magnify", "Magnify" , sinkID, fMagnify);
862    fAppMenu->assignKeyEquivalentToItem(itemID, 'm');
863    itemID =fAppMenu->appendList("Transition-Next", "Transition-Next", sinkID,
864                                fTransitionNext, "Up", "Up and Right", "Right",
865                                "Down and Right", "Down", "Down and Left",
866                                "Left", "Up and Left", NULL);
867    fAppMenu->assignKeyEquivalentToItem(itemID, 'j');
868    itemID =fAppMenu->appendList("Transition-Prev", "Transition-Prev", sinkID,
869                                fTransitionPrev, "Up", "Up and Right", "Right",
870                                "Down and Right", "Down", "Down and Left",
871                                "Left", "Up and Left", NULL);
872    fAppMenu->assignKeyEquivalentToItem(itemID, 'k');
873    itemID = fAppMenu->appendAction("Save to PDF", sinkID);
874    fAppMenu->assignKeyEquivalentToItem(itemID, 'e');
875
876    this->addMenu(fAppMenu);
877    fSlideMenu = new SkOSMenu;
878    this->addMenu(fSlideMenu);
879
880//    this->setConfig(SkBitmap::kRGB_565_Config);
881    this->setConfig(SkBitmap::kARGB_8888_Config);
882    this->setVisibleP(true);
883    this->setClipToBounds(false);
884
885    skiagm::GM::SetResourcePath(resourcePath);
886
887    this->loadView((*fSamples[fCurrIndex])());
888
889    fPDFData = NULL;
890
891    if (NULL == devManager) {
892        fDevManager = new DefaultDeviceManager();
893    } else {
894        devManager->ref();
895        fDevManager = devManager;
896    }
897    fDevManager->setUpBackend(this, fMSAASampleCount);
898
899    // If another constructor set our dimensions, ensure that our
900    // onSizeChange gets called.
901    if (this->height() && this->width()) {
902        this->onSizeChange();
903    }
904
905    // can't call this synchronously, since it may require a subclass to
906    // to implement, or the caller may need us to have returned from the
907    // constructor first. Hence we post an event to ourselves.
908//    this->updateTitle();
909    postEventToSink(new SkEvent(gUpdateWindowTitleEvtName), this);
910}
911
912SampleWindow::~SampleWindow() {
913    delete fPicture;
914    delete fPdfCanvas;
915    fTypeface->unref();
916
917    SkSafeUnref(fDevManager);
918}
919
920static void make_filepath(SkString* path, const char* dir, const SkString& name) {
921    size_t len = strlen(dir);
922    path->set(dir);
923    if (len > 0 && dir[len - 1] != '/') {
924        path->append("/");
925    }
926    path->append(name);
927}
928
929void SampleWindow::registerPictFileSample(char** argv, int argc) {
930    const char* pict = NULL;
931
932    for (int i = 0; i < argc; ++i) {
933        if (!strcmp(argv[i], "--picture")) {
934            i += 1;
935            if (i < argc) {
936                pict = argv[i];
937                break;
938            }
939        }
940    }
941    if (pict) {
942        SkString path(pict);
943        *fSamples.append() = new PictFileFactory(path);
944    }
945}
946
947void SampleWindow::registerPictFileSamples(char** argv, int argc) {
948    const char* pictDir = NULL;
949
950    for (int i = 0; i < argc; ++i) {
951        if (!strcmp(argv[i], "--pictureDir")) {
952            i += 1;
953            if (i < argc) {
954                pictDir = argv[i];
955                break;
956            }
957        }
958    }
959    if (pictDir) {
960        SkOSFile::Iter iter(pictDir, "skp");
961        SkString filename;
962        while (iter.next(&filename)) {
963            SkString path;
964            make_filepath(&path, pictDir, filename);
965            *fSamples.append() = new PictFileFactory(path);
966        }
967    }
968}
969
970int SampleWindow::findByTitle(const char title[]) {
971    int i, count = fSamples.count();
972    for (i = 0; i < count; i++) {
973        if (getSampleTitle(i).equals(title)) {
974            return i;
975        }
976    }
977    return -1;
978}
979
980void SampleWindow::listTitles() {
981    int count = fSamples.count();
982    SkDebugf("All Slides:\n");
983    for (int i = 0; i < count; i++) {
984        SkDebugf("    %s\n", getSampleTitle(i).c_str());
985    }
986}
987
988static SkBitmap capture_bitmap(SkCanvas* canvas) {
989    SkBitmap bm;
990    const SkBitmap& src = canvas->getDevice()->accessBitmap(false);
991    src.copyTo(&bm, src.config());
992    return bm;
993}
994
995static bool bitmap_diff(SkCanvas* canvas, const SkBitmap& orig,
996                        SkBitmap* diff) {
997    const SkBitmap& src = canvas->getDevice()->accessBitmap(false);
998
999    SkAutoLockPixels alp0(src);
1000    SkAutoLockPixels alp1(orig);
1001    for (int y = 0; y < src.height(); y++) {
1002        const void* srcP = src.getAddr(0, y);
1003        const void* origP = orig.getAddr(0, y);
1004        size_t bytes = src.width() * src.bytesPerPixel();
1005        if (memcmp(srcP, origP, bytes)) {
1006            SkDebugf("---------- difference on line %d\n", y);
1007            return true;
1008        }
1009    }
1010    return false;
1011}
1012
1013static void drawText(SkCanvas* canvas, SkString string, SkScalar left, SkScalar top, SkPaint& paint)
1014{
1015    SkColor desiredColor = paint.getColor();
1016    paint.setColor(SK_ColorWHITE);
1017    const char* c_str = string.c_str();
1018    size_t size = string.size();
1019    SkRect bounds;
1020    paint.measureText(c_str, size, &bounds);
1021    bounds.offset(left, top);
1022    SkScalar inset = SkIntToScalar(-2);
1023    bounds.inset(inset, inset);
1024    canvas->drawRect(bounds, paint);
1025    if (desiredColor != SK_ColorBLACK) {
1026        paint.setColor(SK_ColorBLACK);
1027        canvas->drawText(c_str, size, left + SK_Scalar1, top + SK_Scalar1, paint);
1028    }
1029    paint.setColor(desiredColor);
1030    canvas->drawText(c_str, size, left, top, paint);
1031}
1032
1033#define XCLIP_N  8
1034#define YCLIP_N  8
1035
1036void SampleWindow::draw(SkCanvas* canvas) {
1037    // update the animation time
1038    if (!gAnimTimePrev && !gAnimTime) {
1039        // first time make delta be 0
1040        gAnimTime = SkTime::GetMSecs();
1041        gAnimTimePrev = gAnimTime;
1042    } else {
1043        gAnimTimePrev = gAnimTime;
1044        gAnimTime = SkTime::GetMSecs();
1045    }
1046
1047    if (fGesture.isActive()) {
1048        this->updateMatrix();
1049    }
1050
1051    if (fNClip) {
1052        this->INHERITED::draw(canvas);
1053        SkBitmap orig = capture_bitmap(canvas);
1054
1055        const SkScalar w = this->width();
1056        const SkScalar h = this->height();
1057        const SkScalar cw = w / XCLIP_N;
1058        const SkScalar ch = h / YCLIP_N;
1059        for (int y = 0; y < YCLIP_N; y++) {
1060            SkRect r;
1061            r.fTop = y * ch;
1062            r.fBottom = (y + 1) * ch;
1063            if (y == YCLIP_N - 1) {
1064                r.fBottom = h;
1065            }
1066            for (int x = 0; x < XCLIP_N; x++) {
1067                SkAutoCanvasRestore acr(canvas, true);
1068                r.fLeft = x * cw;
1069                r.fRight = (x + 1) * cw;
1070                if (x == XCLIP_N - 1) {
1071                    r.fRight = w;
1072                }
1073                canvas->clipRect(r);
1074                this->INHERITED::draw(canvas);
1075            }
1076        }
1077
1078        SkBitmap diff;
1079        if (bitmap_diff(canvas, orig, &diff)) {
1080        }
1081    } else {
1082        const SkScalar cw = SkScalarDiv(this->width(), SkIntToScalar(fTileCount.width()));
1083        const SkScalar ch = SkScalarDiv(this->height(), SkIntToScalar(fTileCount.height()));
1084
1085        for (int y = 0; y < fTileCount.height(); ++y) {
1086            for (int x = 0; x < fTileCount.width(); ++x) {
1087                SkAutoCanvasRestore acr(canvas, true);
1088                canvas->clipRect(SkRect::MakeXYWH(x * cw, y * ch, cw, ch));
1089                this->INHERITED::draw(canvas);
1090            }
1091        }
1092
1093        if (!fTileCount.equals(1, 1)) {
1094            SkPaint paint;
1095            paint.setColor(0x60FF00FF);
1096            paint.setStyle(SkPaint::kStroke_Style);
1097            for (int y = 0; y < fTileCount.height(); ++y) {
1098                for (int x = 0; x < fTileCount.width(); ++x) {
1099                    canvas->drawRect(SkRect::MakeXYWH(x * cw, y * ch, cw, ch), paint);
1100                }
1101            }
1102        }
1103    }
1104    if (fShowZoomer && !fSaveToPdf) {
1105        showZoomer(canvas);
1106    }
1107    if (fMagnify && !fSaveToPdf) {
1108        magnify(canvas);
1109    }
1110
1111    // do this last
1112    fDevManager->publishCanvas(fDeviceType, canvas, this);
1113}
1114
1115static float clipW = 200;
1116static float clipH = 200;
1117void SampleWindow::magnify(SkCanvas* canvas) {
1118    SkRect r;
1119    int count = canvas->save();
1120
1121    SkMatrix m = canvas->getTotalMatrix();
1122    if (!m.invert(&m)) {
1123        return;
1124    }
1125    SkPoint offset, center;
1126    SkScalar mouseX = fMouseX * SK_Scalar1;
1127    SkScalar mouseY = fMouseY * SK_Scalar1;
1128    m.mapXY(mouseX - clipW/2, mouseY - clipH/2, &offset);
1129    m.mapXY(mouseX, mouseY, &center);
1130
1131    r.set(0, 0, clipW * m.getScaleX(), clipH * m.getScaleX());
1132    r.offset(offset.fX, offset.fY);
1133
1134    SkPaint paint;
1135    paint.setColor(0xFF66AAEE);
1136    paint.setStyle(SkPaint::kStroke_Style);
1137    paint.setStrokeWidth(10.f * m.getScaleX());
1138    //lense offset
1139    //canvas->translate(0, -250);
1140    canvas->drawRect(r, paint);
1141    canvas->clipRect(r);
1142
1143    m = canvas->getTotalMatrix();
1144    m.setTranslate(-center.fX, -center.fY);
1145    m.postScale(0.5f * fFatBitsScale, 0.5f * fFatBitsScale);
1146    m.postTranslate(center.fX, center.fY);
1147    canvas->concat(m);
1148
1149    this->INHERITED::draw(canvas);
1150
1151    canvas->restoreToCount(count);
1152}
1153
1154void SampleWindow::showZoomer(SkCanvas* canvas) {
1155        int count = canvas->save();
1156        canvas->resetMatrix();
1157        // Ensure the mouse position is on screen.
1158        int width = SkScalarRound(this->width());
1159        int height = SkScalarRound(this->height());
1160        if (fMouseX >= width) fMouseX = width - 1;
1161        else if (fMouseX < 0) fMouseX = 0;
1162        if (fMouseY >= height) fMouseY = height - 1;
1163        else if (fMouseY < 0) fMouseY = 0;
1164
1165        SkBitmap bitmap = capture_bitmap(canvas);
1166        bitmap.lockPixels();
1167
1168        // Find the size of the zoomed in view, forced to be odd, so the examined pixel is in the middle.
1169        int zoomedWidth = (width >> 1) | 1;
1170        int zoomedHeight = (height >> 1) | 1;
1171        SkIRect src;
1172        src.set(0, 0, zoomedWidth / fFatBitsScale, zoomedHeight / fFatBitsScale);
1173        src.offset(fMouseX - (src.width()>>1), fMouseY - (src.height()>>1));
1174        SkRect dest;
1175        dest.set(0, 0, SkIntToScalar(zoomedWidth), SkIntToScalar(zoomedHeight));
1176        dest.offset(SkIntToScalar(width - zoomedWidth), SkIntToScalar(height - zoomedHeight));
1177        SkPaint paint;
1178        // Clear the background behind our zoomed in view
1179        paint.setColor(SK_ColorWHITE);
1180        canvas->drawRect(dest, paint);
1181        canvas->drawBitmapRect(bitmap, &src, dest);
1182        paint.setColor(SK_ColorBLACK);
1183        paint.setStyle(SkPaint::kStroke_Style);
1184        // Draw a border around the pixel in the middle
1185        SkRect originalPixel;
1186        originalPixel.set(SkIntToScalar(fMouseX), SkIntToScalar(fMouseY), SkIntToScalar(fMouseX + 1), SkIntToScalar(fMouseY + 1));
1187        SkMatrix matrix;
1188        SkRect scalarSrc;
1189        scalarSrc.set(src);
1190        SkColor color = bitmap.getColor(fMouseX, fMouseY);
1191        if (matrix.setRectToRect(scalarSrc, dest, SkMatrix::kFill_ScaleToFit)) {
1192            SkRect pixel;
1193            matrix.mapRect(&pixel, originalPixel);
1194            // TODO Perhaps measure the values and make the outline white if it's "dark"
1195            if (color == SK_ColorBLACK) {
1196                paint.setColor(SK_ColorWHITE);
1197            }
1198            canvas->drawRect(pixel, paint);
1199        }
1200        paint.setColor(SK_ColorBLACK);
1201        // Draw a border around the destination rectangle
1202        canvas->drawRect(dest, paint);
1203        paint.setStyle(SkPaint::kStrokeAndFill_Style);
1204        // Identify the pixel and its color on screen
1205        paint.setTypeface(fTypeface);
1206        paint.setAntiAlias(true);
1207        SkScalar lineHeight = paint.getFontMetrics(NULL);
1208        SkString string;
1209        string.appendf("(%i, %i)", fMouseX, fMouseY);
1210        SkScalar left = dest.fLeft + SkIntToScalar(3);
1211        SkScalar i = SK_Scalar1;
1212        drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
1213        // Alpha
1214        i += SK_Scalar1;
1215        string.reset();
1216        string.appendf("A: %X", SkColorGetA(color));
1217        drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
1218        // Red
1219        i += SK_Scalar1;
1220        string.reset();
1221        string.appendf("R: %X", SkColorGetR(color));
1222        paint.setColor(SK_ColorRED);
1223        drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
1224        // Green
1225        i += SK_Scalar1;
1226        string.reset();
1227        string.appendf("G: %X", SkColorGetG(color));
1228        paint.setColor(SK_ColorGREEN);
1229        drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
1230        // Blue
1231        i += SK_Scalar1;
1232        string.reset();
1233        string.appendf("B: %X", SkColorGetB(color));
1234        paint.setColor(SK_ColorBLUE);
1235        drawText(canvas, string, left, SkScalarMulAdd(lineHeight, i, dest.fTop), paint);
1236        canvas->restoreToCount(count);
1237}
1238
1239void SampleWindow::onDraw(SkCanvas* canvas) {
1240}
1241
1242#include "SkColorPriv.h"
1243
1244#if 0 // UNUSED
1245static void reverseRedAndBlue(const SkBitmap& bm) {
1246    SkASSERT(bm.config() == SkBitmap::kARGB_8888_Config);
1247    uint8_t* p = (uint8_t*)bm.getPixels();
1248    uint8_t* stop = p + bm.getSize();
1249    while (p < stop) {
1250        // swap red/blue (to go from ARGB(int) to RGBA(memory) and premultiply
1251        unsigned scale = SkAlpha255To256(p[3]);
1252        unsigned r = p[2];
1253        unsigned b = p[0];
1254        p[0] = SkAlphaMul(r, scale);
1255        p[1] = SkAlphaMul(p[1], scale);
1256        p[2] = SkAlphaMul(b, scale);
1257        p += 4;
1258    }
1259}
1260#endif
1261
1262void SampleWindow::saveToPdf()
1263{
1264    fSaveToPdf = true;
1265    this->inval(NULL);
1266}
1267
1268SkCanvas* SampleWindow::beforeChildren(SkCanvas* canvas) {
1269    if (fSaveToPdf) {
1270        const SkBitmap& bmp = canvas->getDevice()->accessBitmap(false);
1271        SkISize size = SkISize::Make(bmp.width(), bmp.height());
1272        SkPDFDevice* pdfDevice = new SkPDFDevice(size, size,
1273                canvas->getTotalMatrix());
1274        fPdfCanvas = new SkCanvas(pdfDevice);
1275        pdfDevice->unref();
1276        canvas = fPdfCanvas;
1277    } else {
1278        switch (fDeviceType) {
1279            case kRaster_DeviceType:
1280                // fallthrough
1281#if SK_SUPPORT_GPU
1282            case kGPU_DeviceType:
1283                // fallthrough
1284#if SK_ANGLE
1285            case kANGLE_DeviceType:
1286#endif // SK_ANGLE
1287#endif // SK_SUPPORT_GPU
1288                canvas = this->INHERITED::beforeChildren(canvas);
1289                break;
1290            case kPicture_DeviceType:
1291                fPicture = new SkPicture;
1292                canvas = fPicture->beginRecording(9999, 9999);
1293                break;
1294#if SK_SUPPORT_GPU
1295            case kNullGPU_DeviceType:
1296                break;
1297#endif
1298            default:
1299                SkASSERT(false);
1300                break;
1301        }
1302    }
1303
1304    if (fUseClip) {
1305        canvas->drawColor(0xFFFF88FF);
1306        canvas->clipPath(fClipPath, SkRegion::kIntersect_Op, true);
1307    }
1308
1309    return canvas;
1310}
1311
1312static void paint_rgn(const SkBitmap& bm, const SkIRect& r,
1313                      const SkRegion& rgn) {
1314    SkCanvas    canvas(bm);
1315    SkRegion    inval(rgn);
1316
1317    inval.translate(r.fLeft, r.fTop);
1318    canvas.clipRegion(inval);
1319    canvas.drawColor(0xFFFF8080);
1320}
1321#include "SkData.h"
1322void SampleWindow::afterChildren(SkCanvas* orig) {
1323    if (fSaveToPdf) {
1324        fSaveToPdf = false;
1325        if (fShowZoomer) {
1326            showZoomer(fPdfCanvas);
1327        }
1328        SkString name;
1329        name.printf("%s.pdf", this->getTitle());
1330        SkPDFDocument doc;
1331        SkPDFDevice* device = static_cast<SkPDFDevice*>(fPdfCanvas->getDevice());
1332        doc.appendPage(device);
1333#ifdef SK_BUILD_FOR_ANDROID
1334        name.prepend("/sdcard/");
1335#endif
1336
1337#ifdef SK_BUILD_FOR_IOS
1338        SkDynamicMemoryWStream mstream;
1339        doc.emitPDF(&mstream);
1340        fPDFData = mstream.copyToData();
1341#endif
1342        SkFILEWStream stream(name.c_str());
1343        if (stream.isValid()) {
1344            doc.emitPDF(&stream);
1345            const char* desc = "File saved from Skia SampleApp";
1346            this->onPDFSaved(this->getTitle(), desc, name.c_str());
1347        }
1348
1349        delete fPdfCanvas;
1350        fPdfCanvas = NULL;
1351
1352        // We took over the draw calls in order to create the PDF, so we need
1353        // to redraw.
1354        this->inval(NULL);
1355        return;
1356    }
1357
1358    if (fRequestGrabImage) {
1359        fRequestGrabImage = false;
1360
1361        SkDevice* device = orig->getDevice();
1362        SkBitmap bmp;
1363        if (device->accessBitmap(false).copyTo(&bmp, SkBitmap::kARGB_8888_Config)) {
1364            static int gSampleGrabCounter;
1365            SkString name;
1366            name.printf("sample_grab_%d.png", gSampleGrabCounter++);
1367            SkImageEncoder::EncodeFile(name.c_str(), bmp,
1368                                       SkImageEncoder::kPNG_Type, 100);
1369        }
1370    }
1371
1372    if (kPicture_DeviceType == fDeviceType) {
1373        if (true) {
1374            SkPicture* pict = new SkPicture(*fPicture);
1375            fPicture->unref();
1376            this->installDrawFilter(orig);
1377            orig->drawPicture(*pict);
1378            pict->unref();
1379        } else if (true) {
1380            SkDynamicMemoryWStream ostream;
1381            fPicture->serialize(&ostream);
1382            fPicture->unref();
1383
1384            SkAutoDataUnref data(ostream.copyToData());
1385            SkMemoryStream istream(data->data(), data->size());
1386            SkPicture pict(&istream);
1387            orig->drawPicture(pict);
1388        } else {
1389            fPicture->draw(orig);
1390            fPicture->unref();
1391        }
1392        fPicture = NULL;
1393    }
1394
1395    // Do this after presentGL and other finishing, rather than in afterChild
1396    if (fMeasureFPS && fMeasureFPS_Time) {
1397        fMeasureFPS_Time = SkTime::GetMSecs() - fMeasureFPS_Time;
1398        this->updateTitle();
1399        this->postInvalDelay();
1400    }
1401
1402    //    if ((fScrollTestX | fScrollTestY) != 0)
1403    if (false) {
1404        const SkBitmap& bm = orig->getDevice()->accessBitmap(true);
1405        int dx = fScrollTestX * 7;
1406        int dy = fScrollTestY * 7;
1407        SkIRect r;
1408        SkRegion inval;
1409
1410        r.set(50, 50, 50+100, 50+100);
1411        bm.scrollRect(&r, dx, dy, &inval);
1412        paint_rgn(bm, r, inval);
1413    }
1414#ifdef DEBUGGER
1415    SkView* curr = curr_view(this);
1416    if (fDebugger && !is_debugger(curr) && !is_transition(curr) && !is_overview(curr)) {
1417        //Stop Pipe when fDebugger is active
1418        if (fPipeState != SkOSMenu::kOffState) {
1419            fPipeState = SkOSMenu::kOffState;
1420            (void)SampleView::SetUsePipe(curr, fPipeState);
1421            fAppMenu->getItemByID(fUsePipeMenuItemID)->setTriState(fPipeState);
1422            this->onUpdateMenu(fAppMenu);
1423        }
1424
1425        //Reset any transformations
1426        fGesture.stop();
1427        fGesture.reset();
1428
1429        this->loadView(create_debugger(gTempDataStore.begin(),
1430                                       gTempDataStore.count()));
1431    }
1432#endif
1433}
1434
1435void SampleWindow::beforeChild(SkView* child, SkCanvas* canvas) {
1436    if (fScale) {
1437        SkScalar scale = SK_Scalar1 * 7 / 10;
1438        SkScalar cx = this->width() / 2;
1439        SkScalar cy = this->height() / 2;
1440        canvas->translate(cx, cy);
1441        canvas->scale(scale, scale);
1442        canvas->translate(-cx, -cy);
1443    }
1444    if (fRotate) {
1445        SkScalar cx = this->width() / 2;
1446        SkScalar cy = this->height() / 2;
1447        canvas->translate(cx, cy);
1448        canvas->rotate(SkIntToScalar(30));
1449        canvas->translate(-cx, -cy);
1450    }
1451    if (fPerspAnim) {
1452        fPerspAnimTime += SampleCode::GetAnimSecondsDelta();
1453
1454        static const SkScalar gAnimPeriod = 10 * SK_Scalar1;
1455        static const SkScalar gAnimMag = SK_Scalar1 / 1000;
1456        SkScalar t = SkScalarMod(fPerspAnimTime, gAnimPeriod);
1457        if (SkScalarFloorToInt(SkScalarDiv(fPerspAnimTime, gAnimPeriod)) & 0x1) {
1458            t = gAnimPeriod - t;
1459        }
1460        t = 2 * t - gAnimPeriod;
1461        t = SkScalarMul(SkScalarDiv(t, gAnimPeriod), gAnimMag);
1462        SkMatrix m;
1463        m.reset();
1464        m.setPerspY(t);
1465        canvas->concat(m);
1466    }
1467
1468    this->installDrawFilter(canvas);
1469
1470    if (fMeasureFPS) {
1471        fMeasureFPS_Time = 0;   // 0 means the child is not aware of repeat-draw
1472        if (SampleView::SetRepeatDraw(child, FPS_REPEAT_COUNT)) {
1473            fMeasureFPS_Time = SkTime::GetMSecs();
1474        }
1475    } else {
1476        (void)SampleView::SetRepeatDraw(child, 1);
1477    }
1478    if (fPerspAnim) {
1479        this->inval(NULL);
1480    }
1481}
1482
1483void SampleWindow::afterChild(SkView* child, SkCanvas* canvas) {
1484    canvas->setDrawFilter(NULL);
1485}
1486
1487static SkBitmap::Config gConfigCycle[] = {
1488    SkBitmap::kNo_Config,           // none -> none
1489    SkBitmap::kNo_Config,           // a1 -> none
1490    SkBitmap::kNo_Config,           // a8 -> none
1491    SkBitmap::kNo_Config,           // index8 -> none
1492    SkBitmap::kARGB_4444_Config,    // 565 -> 4444
1493    SkBitmap::kARGB_8888_Config,    // 4444 -> 8888
1494    SkBitmap::kRGB_565_Config       // 8888 -> 565
1495};
1496
1497static SkBitmap::Config cycle_configs(SkBitmap::Config c) {
1498    return gConfigCycle[c];
1499}
1500
1501void SampleWindow::changeZoomLevel(float delta) {
1502    fZoomLevel += SkFloatToScalar(delta);
1503    if (fZoomLevel > 0) {
1504        fZoomLevel = SkMinScalar(fZoomLevel, MAX_ZOOM_LEVEL);
1505        fZoomScale = fZoomLevel + SK_Scalar1;
1506    } else if (fZoomLevel < 0) {
1507        fZoomLevel = SkMaxScalar(fZoomLevel, MIN_ZOOM_LEVEL);
1508        fZoomScale = SK_Scalar1 / (SK_Scalar1 - fZoomLevel);
1509    } else {
1510        fZoomScale = SK_Scalar1;
1511    }
1512    this->updateMatrix();
1513}
1514
1515void SampleWindow::updateMatrix(){
1516    SkMatrix m;
1517    m.reset();
1518    if (fZoomLevel) {
1519        SkPoint center;
1520        //m = this->getLocalMatrix();//.invert(&m);
1521        m.mapXY(fZoomCenterX, fZoomCenterY, &center);
1522        SkScalar cx = center.fX;
1523        SkScalar cy = center.fY;
1524
1525        m.setTranslate(-cx, -cy);
1526        m.postScale(fZoomScale, fZoomScale);
1527        m.postTranslate(cx, cy);
1528    }
1529
1530    if (fFlipAxis) {
1531        m.preTranslate(fZoomCenterX, fZoomCenterY);
1532        if (fFlipAxis & kFlipAxis_X) {
1533            m.preScale(-SK_Scalar1, SK_Scalar1);
1534        }
1535        if (fFlipAxis & kFlipAxis_Y) {
1536            m.preScale(SK_Scalar1, -SK_Scalar1);
1537        }
1538        m.preTranslate(-fZoomCenterX, -fZoomCenterY);
1539        //canvas->concat(m);
1540    }
1541    // Apply any gesture matrix
1542    m.preConcat(fGesture.localM());
1543    m.preConcat(fGesture.globalM());
1544
1545    this->setLocalMatrix(m);
1546
1547    this->updateTitle();
1548    this->inval(NULL);
1549}
1550bool SampleWindow::previousSample() {
1551    fCurrIndex = (fCurrIndex - 1 + fSamples.count()) % fSamples.count();
1552    this->loadView(create_transition(curr_view(this), (*fSamples[fCurrIndex])(),
1553                                     fTransitionPrev));
1554    return true;
1555}
1556
1557bool SampleWindow::nextSample() {
1558    fCurrIndex = (fCurrIndex + 1) % fSamples.count();
1559    this->loadView(create_transition(curr_view(this), (*fSamples[fCurrIndex])(),
1560                                     fTransitionNext));
1561    return true;
1562}
1563
1564bool SampleWindow::goToSample(int i) {
1565    fCurrIndex = (i) % fSamples.count();
1566    this->loadView(create_transition(curr_view(this),(*fSamples[fCurrIndex])(), 6));
1567    return true;
1568}
1569
1570SkString SampleWindow::getSampleTitle(int i) {
1571    SkView* view = (*fSamples[i])();
1572    SkString title;
1573    SampleCode::RequestTitle(view, &title);
1574    view->unref();
1575    return title;
1576}
1577
1578int SampleWindow::sampleCount() {
1579    return fSamples.count();
1580}
1581
1582void SampleWindow::showOverview() {
1583    this->loadView(create_transition(curr_view(this),
1584                                     create_overview(fSamples.count(), fSamples.begin()),
1585                                     4));
1586}
1587
1588void SampleWindow::installDrawFilter(SkCanvas* canvas) {
1589    canvas->setDrawFilter(new FlagsDrawFilter(fLCDState, fAAState,
1590                                              fFilterState, fHintingState))->unref();
1591}
1592
1593void SampleWindow::postAnimatingEvent() {
1594    if (fAnimating) {
1595        (new SkEvent(ANIMATING_EVENTTYPE, this->getSinkID()))->postDelay(ANIMATING_DELAY);
1596    }
1597}
1598
1599bool SampleWindow::onEvent(const SkEvent& evt) {
1600    if (evt.isType(gUpdateWindowTitleEvtName)) {
1601        this->updateTitle();
1602        return true;
1603    }
1604    if (evt.isType(ANIMATING_EVENTTYPE)) {
1605        if (fAnimating) {
1606            this->nextSample();
1607            this->postAnimatingEvent();
1608        }
1609        return true;
1610    }
1611    if (evt.isType("replace-transition-view")) {
1612        this->loadView((SkView*)SkEventSink::FindSink(evt.getFast32()));
1613        return true;
1614    }
1615    if (evt.isType("set-curr-index")) {
1616        this->goToSample(evt.getFast32());
1617        return true;
1618    }
1619    if (isInvalEvent(evt)) {
1620        this->inval(NULL);
1621        return true;
1622    }
1623    int selected = -1;
1624    if (SkOSMenu::FindListIndex(evt, "Device Type", &selected)) {
1625        this->setDeviceType((DeviceType)selected);
1626        return true;
1627    }
1628    if (SkOSMenu::FindTriState(evt, "Pipe", &fPipeState)) {
1629#ifdef PIPE_NET
1630        if (!fPipeState != SkOSMenu::kOnState)
1631            gServer.disconnectAll();
1632#endif
1633        (void)SampleView::SetUsePipe(curr_view(this), fPipeState);
1634        this->updateTitle();
1635        this->inval(NULL);
1636        return true;
1637    }
1638    if (SkOSMenu::FindTriState(evt, "Tiling", &fTilingState)) {
1639        int nx = 1, ny = 1;
1640        switch (fTilingState) {
1641            case SkOSMenu::kOffState:   nx = 1; ny = 1; break;
1642            case SkOSMenu::kMixedState: nx = 1; ny = 16; break;
1643            case SkOSMenu::kOnState:    nx = 4; ny = 4; break;
1644        }
1645        fTileCount.set(nx, ny);
1646        this->inval(NULL);
1647        return true;
1648    }
1649    if (SkOSMenu::FindSwitchState(evt, "Slide Show", NULL)) {
1650        this->toggleSlideshow();
1651        return true;
1652    }
1653    if (SkOSMenu::FindTriState(evt, "AA", &fAAState) ||
1654        SkOSMenu::FindTriState(evt, "LCD", &fLCDState) ||
1655        SkOSMenu::FindTriState(evt, "Filter", &fFilterState) ||
1656        SkOSMenu::FindTriState(evt, "Hinting", &fHintingState) ||
1657        SkOSMenu::FindSwitchState(evt, "Clip", &fUseClip) ||
1658        SkOSMenu::FindSwitchState(evt, "Zoomer", &fShowZoomer) ||
1659        SkOSMenu::FindSwitchState(evt, "Magnify", &fMagnify) ||
1660        SkOSMenu::FindListIndex(evt, "Transition-Next", &fTransitionNext) ||
1661        SkOSMenu::FindListIndex(evt, "Transition-Prev", &fTransitionPrev)) {
1662        this->inval(NULL);
1663        this->updateTitle();
1664        return true;
1665    }
1666    if (SkOSMenu::FindSwitchState(evt, "Flip X", NULL)) {
1667        fFlipAxis ^= kFlipAxis_X;
1668        this->updateMatrix();
1669        return true;
1670    }
1671    if (SkOSMenu::FindSwitchState(evt, "Flip Y", NULL)) {
1672        fFlipAxis ^= kFlipAxis_Y;
1673        this->updateMatrix();
1674        return true;
1675    }
1676    if (SkOSMenu::FindAction(evt,"Save to PDF")) {
1677        this->saveToPdf();
1678        return true;
1679    }
1680#ifdef DEBUGGER
1681    if (SkOSMenu::FindSwitchState(evt, "Debugger", &fDebugger)) {
1682        if (fDebugger) {
1683            fPipeState = SkOSMenu::kOnState;
1684            (void)SampleView::SetUsePipe(curr_view(this), fPipeState);
1685        } else {
1686            this->loadView((*fSamples[fCurrIndex])());
1687        }
1688        this->inval(NULL);
1689        return true;
1690    }
1691#endif
1692    return this->INHERITED::onEvent(evt);
1693}
1694
1695bool SampleWindow::onQuery(SkEvent* query) {
1696    if (query->isType("get-slide-count")) {
1697        query->setFast32(fSamples.count());
1698        return true;
1699    }
1700    if (query->isType("get-slide-title")) {
1701        SkView* view = (*fSamples[query->getFast32()])();
1702        SkEvent evt(gTitleEvtName);
1703        if (view->doQuery(&evt)) {
1704            query->setString("title", evt.findString(gTitleEvtName));
1705        }
1706        SkSafeUnref(view);
1707        return true;
1708    }
1709    if (query->isType("use-fast-text")) {
1710        SkEvent evt(gFastTextEvtName);
1711        return curr_view(this)->doQuery(&evt);
1712    }
1713    if (query->isType("ignore-window-bitmap")) {
1714        query->setFast32(this->getGrContext() != NULL);
1715        return true;
1716    }
1717    return this->INHERITED::onQuery(query);
1718}
1719
1720#if 0 // UNUSED
1721static void cleanup_for_filename(SkString* name) {
1722    char* str = name->writable_str();
1723    for (size_t i = 0; i < name->size(); i++) {
1724        switch (str[i]) {
1725            case ':': str[i] = '-'; break;
1726            case '/': str[i] = '-'; break;
1727            case ' ': str[i] = '_'; break;
1728            default: break;
1729        }
1730    }
1731}
1732#endif
1733
1734bool SampleWindow::onHandleChar(SkUnichar uni) {
1735    {
1736        SkView* view = curr_view(this);
1737        if (view) {
1738            SkEvent evt(gCharEvtName);
1739            evt.setFast32(uni);
1740            if (view->doQuery(&evt)) {
1741                return true;
1742            }
1743        }
1744    }
1745
1746    int dx = 0xFF;
1747    int dy = 0xFF;
1748
1749    switch (uni) {
1750        case '5': dx =  0; dy =  0; break;
1751        case '8': dx =  0; dy = -1; break;
1752        case '6': dx =  1; dy =  0; break;
1753        case '2': dx =  0; dy =  1; break;
1754        case '4': dx = -1; dy =  0; break;
1755        case '7': dx = -1; dy = -1; break;
1756        case '9': dx =  1; dy = -1; break;
1757        case '3': dx =  1; dy =  1; break;
1758        case '1': dx = -1; dy =  1; break;
1759
1760        default:
1761            break;
1762    }
1763
1764    if (0xFF != dx && 0xFF != dy) {
1765        if ((dx | dy) == 0) {
1766            fScrollTestX = fScrollTestY = 0;
1767        } else {
1768            fScrollTestX += dx;
1769            fScrollTestY += dy;
1770        }
1771        this->inval(NULL);
1772        return true;
1773    }
1774
1775    switch (uni) {
1776        case 'f':
1777            // only
1778            toggleFPS();
1779            break;
1780        case 'g':
1781            fRequestGrabImage = true;
1782            this->inval(NULL);
1783            break;
1784        case 'i':
1785            this->zoomIn();
1786            break;
1787        case 'o':
1788            this->zoomOut();
1789            break;
1790        case 'r':
1791            fRotate = !fRotate;
1792            this->inval(NULL);
1793            this->updateTitle();
1794            return true;
1795        case 'k':
1796            fPerspAnim = !fPerspAnim;
1797            this->inval(NULL);
1798            this->updateTitle();
1799            return true;
1800#if SK_SUPPORT_GPU
1801        case '\\':
1802            this->setDeviceType(kNullGPU_DeviceType);
1803            this->inval(NULL);
1804            this->updateTitle();
1805            return true;
1806        case 'p':
1807            {
1808                GrContext* grContext = this->getGrContext();
1809                if (grContext) {
1810                    size_t cacheBytes = grContext->getGpuTextureCacheBytes();
1811                    grContext->freeGpuResources();
1812                    SkDebugf("Purged %d bytes from the GPU resource cache.\n",
1813                             cacheBytes);
1814                }
1815            }
1816            return true;
1817#endif
1818        case 's':
1819            fScale = !fScale;
1820            this->inval(NULL);
1821            this->updateTitle();
1822            return true;
1823        default:
1824            break;
1825    }
1826
1827    if (fAppMenu->handleKeyEquivalent(uni)|| fSlideMenu->handleKeyEquivalent(uni)) {
1828        this->onUpdateMenu(fAppMenu);
1829        this->onUpdateMenu(fSlideMenu);
1830        return true;
1831    }
1832    return this->INHERITED::onHandleChar(uni);
1833}
1834
1835void SampleWindow::setDeviceType(DeviceType type) {
1836    if (type == fDeviceType)
1837        return;
1838
1839    fDevManager->tearDownBackend(this);
1840
1841    fDeviceType = type;
1842
1843    fDevManager->setUpBackend(this, fMSAASampleCount);
1844
1845    this->updateTitle();
1846    this->inval(NULL);
1847}
1848
1849void SampleWindow::toggleSlideshow() {
1850    fAnimating = !fAnimating;
1851    this->postAnimatingEvent();
1852    this->updateTitle();
1853}
1854
1855void SampleWindow::toggleRendering() {
1856    this->setDeviceType(cycle_devicetype(fDeviceType));
1857    this->updateTitle();
1858    this->inval(NULL);
1859}
1860
1861void SampleWindow::toggleFPS() {
1862    fMeasureFPS = !fMeasureFPS;
1863    this->updateTitle();
1864    this->inval(NULL);
1865}
1866
1867#include "SkDumpCanvas.h"
1868
1869bool SampleWindow::onHandleKey(SkKey key) {
1870    {
1871        SkView* view = curr_view(this);
1872        if (view) {
1873            SkEvent evt(gKeyEvtName);
1874            evt.setFast32(key);
1875            if (view->doQuery(&evt)) {
1876                return true;
1877            }
1878        }
1879    }
1880    switch (key) {
1881        case kRight_SkKey:
1882            if (this->nextSample()) {
1883                return true;
1884            }
1885            break;
1886        case kLeft_SkKey:
1887            if (this->previousSample()) {
1888                return true;
1889            }
1890            return true;
1891        case kUp_SkKey:
1892            if (USE_ARROWS_FOR_ZOOM) {
1893                this->changeZoomLevel(1.f);
1894            } else {
1895                fNClip = !fNClip;
1896                this->inval(NULL);
1897                this->updateTitle();
1898            }
1899            return true;
1900        case kDown_SkKey:
1901            if (USE_ARROWS_FOR_ZOOM) {
1902                this->changeZoomLevel(-1.f);
1903            } else {
1904                this->setConfig(cycle_configs(this->getBitmap().config()));
1905                this->updateTitle();
1906            }
1907            return true;
1908        case kOK_SkKey: {
1909            SkString title;
1910            if (curr_title(this, &title)) {
1911                writeTitleToPrefs(title.c_str());
1912            }
1913            return true;
1914        }
1915        case kBack_SkKey:
1916            this->showOverview();
1917            return true;
1918        default:
1919            break;
1920    }
1921    return this->INHERITED::onHandleKey(key);
1922}
1923
1924///////////////////////////////////////////////////////////////////////////////
1925
1926static const char gGestureClickType[] = "GestureClickType";
1927
1928bool SampleWindow::onDispatchClick(int x, int y, Click::State state,
1929        void* owner) {
1930    if (Click::kMoved_State == state) {
1931        updatePointer(x, y);
1932    }
1933    int w = SkScalarRound(this->width());
1934    int h = SkScalarRound(this->height());
1935
1936    // check for the resize-box
1937    if (w - x < 16 && h - y < 16) {
1938        return false;   // let the OS handle the click
1939    }
1940    else if (fMagnify) {
1941        //it's only necessary to update the drawing if there's a click
1942        this->inval(NULL);
1943        return false; //prevent dragging while magnify is enabled
1944    }
1945    else {
1946        return this->INHERITED::onDispatchClick(x, y, state, owner);
1947    }
1948}
1949
1950class GestureClick : public SkView::Click {
1951public:
1952    GestureClick(SkView* target) : SkView::Click(target) {
1953        this->setType(gGestureClickType);
1954    }
1955
1956    static bool IsGesture(Click* click) {
1957        return click->isType(gGestureClickType);
1958    }
1959};
1960
1961SkView::Click* SampleWindow::onFindClickHandler(SkScalar x, SkScalar y) {
1962    return new GestureClick(this);
1963}
1964
1965bool SampleWindow::onClick(Click* click) {
1966    if (GestureClick::IsGesture(click)) {
1967        float x = static_cast<float>(click->fICurr.fX);
1968        float y = static_cast<float>(click->fICurr.fY);
1969
1970        switch (click->fState) {
1971            case SkView::Click::kDown_State:
1972                fGesture.touchBegin(click->fOwner, x, y);
1973                break;
1974            case SkView::Click::kMoved_State:
1975                fGesture.touchMoved(click->fOwner, x, y);
1976                this->updateMatrix();
1977                break;
1978            case SkView::Click::kUp_State:
1979                fGesture.touchEnd(click->fOwner);
1980                this->updateMatrix();
1981                break;
1982        }
1983        return true;
1984    }
1985    return false;
1986}
1987
1988///////////////////////////////////////////////////////////////////////////////
1989
1990void SampleWindow::loadView(SkView* view) {
1991    SkView::F2BIter iter(this);
1992    SkView* prev = iter.next();
1993    if (prev) {
1994        prev->detachFromParent();
1995    }
1996
1997    view->setVisibleP(true);
1998    view->setClipToBounds(false);
1999    this->attachChildToFront(view)->unref();
2000    view->setSize(this->width(), this->height());
2001
2002    //repopulate the slide menu when a view is loaded
2003    fSlideMenu->reset();
2004#ifdef DEBUGGER
2005    if (!is_debugger(view) && !is_overview(view) && !is_transition(view) && fDebugger) {
2006        //Force Pipe to be on if using debugger
2007        fPipeState = SkOSMenu::kOnState;
2008    }
2009#endif
2010    (void)SampleView::SetUsePipe(view, fPipeState);
2011    if (SampleView::IsSampleView(view))
2012        ((SampleView*)view)->requestMenu(fSlideMenu);
2013    this->onUpdateMenu(fSlideMenu);
2014    this->updateTitle();
2015}
2016
2017static const char* gConfigNames[] = {
2018    "unknown config",
2019    "A1",
2020    "A8",
2021    "Index8",
2022    "565",
2023    "4444",
2024    "8888"
2025};
2026
2027static const char* configToString(SkBitmap::Config c) {
2028    return gConfigNames[c];
2029}
2030
2031static const char* gDeviceTypePrefix[] = {
2032    "raster: ",
2033    "picture: ",
2034#if SK_SUPPORT_GPU
2035    "opengl: ",
2036#if SK_ANGLE
2037    "angle: ",
2038#endif // SK_ANGLE
2039    "null-gl: "
2040#endif // SK_SUPPORT_GPU
2041};
2042SK_COMPILE_ASSERT(SK_ARRAY_COUNT(gDeviceTypePrefix) == SampleWindow::kDeviceTypeCnt,
2043                  array_size_mismatch);
2044
2045static const bool gDeviceTypeIsGPU[] = {
2046    false,
2047    false,
2048#if SK_SUPPORT_GPU
2049    true,
2050#if SK_ANGLE
2051    true,
2052#endif // SK_ANGLE
2053    true
2054#endif // SK_SUPPORT_GPU
2055};
2056SK_COMPILE_ASSERT(SK_ARRAY_COUNT(gDeviceTypeIsGPU) == SampleWindow::kDeviceTypeCnt,
2057                  array_size_mismatch);
2058
2059
2060static const char* trystate_str(SkOSMenu::TriState state,
2061                                const char trueStr[], const char falseStr[]) {
2062    if (SkOSMenu::kOnState == state) {
2063        return trueStr;
2064    } else if (SkOSMenu::kOffState == state) {
2065        return falseStr;
2066    }
2067    return NULL;
2068}
2069
2070void SampleWindow::updateTitle() {
2071    SkView* view = curr_view(this);
2072
2073    SkString title;
2074    if (!curr_title(this, &title)) {
2075        title.set("<unknown>");
2076    }
2077
2078    title.prepend(gDeviceTypePrefix[fDeviceType]);
2079
2080    title.prepend(" ");
2081    title.prepend(configToString(this->getBitmap().config()));
2082
2083    if (fAnimating) {
2084        title.prepend("<A> ");
2085    }
2086    if (fScale) {
2087        title.prepend("<S> ");
2088    }
2089    if (fRotate) {
2090        title.prepend("<R> ");
2091    }
2092    if (fNClip) {
2093        title.prepend("<C> ");
2094    }
2095    if (fPerspAnim) {
2096        title.prepend("<K> ");
2097    }
2098
2099    title.prepend(trystate_str(fLCDState, "LCD ", "lcd "));
2100    title.prepend(trystate_str(fAAState, "AA ", "aa "));
2101    title.prepend(trystate_str(fFilterState, "H ", "h "));
2102    title.prepend(fFlipAxis & kFlipAxis_X ? "X " : NULL);
2103    title.prepend(fFlipAxis & kFlipAxis_Y ? "Y " : NULL);
2104
2105    if (fZoomLevel) {
2106        title.prependf("{%.2f} ", SkScalarToFloat(fZoomLevel));
2107    }
2108
2109    if (fMeasureFPS) {
2110        title.appendf(" %8.3f ms", fMeasureFPS_Time / (float)FPS_REPEAT_COUNT);
2111    }
2112    if (SampleView::IsSampleView(view)) {
2113        switch (fPipeState) {
2114            case SkOSMenu::kOnState:
2115                title.prepend("<Pipe> ");
2116                break;
2117            case SkOSMenu::kMixedState:
2118                title.prepend("<Tiled Pipe> ");
2119                break;
2120
2121            default:
2122                break;
2123        }
2124        title.prepend("! ");
2125    }
2126
2127#if SK_SUPPORT_GPU
2128    if (gDeviceTypeIsGPU[fDeviceType] &&
2129        NULL != fDevManager &&
2130        fDevManager->getGrRenderTarget()->numSamples() > 0) {
2131        title.appendf(" [MSAA: %d]",
2132                       fDevManager->getGrRenderTarget()->numSamples());
2133    }
2134#endif
2135
2136    this->setTitle(title.c_str());
2137}
2138
2139void SampleWindow::onSizeChange() {
2140    this->INHERITED::onSizeChange();
2141
2142    SkView::F2BIter iter(this);
2143    SkView* view = iter.next();
2144    view->setSize(this->width(), this->height());
2145
2146    // rebuild our clippath
2147    {
2148        const SkScalar W = this->width();
2149        const SkScalar H = this->height();
2150
2151        fClipPath.reset();
2152#if 0
2153        for (SkScalar y = SK_Scalar1; y < H; y += SkIntToScalar(32)) {
2154            SkRect r;
2155            r.set(SK_Scalar1, y, SkIntToScalar(30), y + SkIntToScalar(30));
2156            for (; r.fLeft < W; r.offset(SkIntToScalar(32), 0))
2157                fClipPath.addRect(r);
2158        }
2159#else
2160        SkRect r;
2161        r.set(0, 0, W, H);
2162        fClipPath.addRect(r, SkPath::kCCW_Direction);
2163        r.set(W/4, H/4, W*3/4, H*3/4);
2164        fClipPath.addRect(r, SkPath::kCW_Direction);
2165#endif
2166    }
2167
2168    fZoomCenterX = SkScalarHalf(this->width());
2169    fZoomCenterY = SkScalarHalf(this->height());
2170
2171#ifdef SK_BUILD_FOR_ANDROID
2172    // FIXME: The first draw after a size change does not work on Android, so
2173    // we post an invalidate.
2174    this->postInvalDelay();
2175#endif
2176    this->updateTitle();    // to refresh our config
2177    fDevManager->windowSizeChanged(this);
2178}
2179
2180///////////////////////////////////////////////////////////////////////////////
2181
2182static const char is_sample_view_tag[] = "sample-is-sample-view";
2183static const char repeat_count_tag[] = "sample-set-repeat-count";
2184static const char set_use_pipe_tag[] = "sample-set-use-pipe";
2185
2186bool SampleView::IsSampleView(SkView* view) {
2187    SkEvent evt(is_sample_view_tag);
2188    return view->doQuery(&evt);
2189}
2190
2191bool SampleView::SetRepeatDraw(SkView* view, int count) {
2192    SkEvent evt(repeat_count_tag);
2193    evt.setFast32(count);
2194    return view->doEvent(evt);
2195}
2196
2197bool SampleView::SetUsePipe(SkView* view, SkOSMenu::TriState state) {
2198    SkEvent evt;
2199    evt.setS32(set_use_pipe_tag, state);
2200    return view->doEvent(evt);
2201}
2202
2203bool SampleView::onEvent(const SkEvent& evt) {
2204    if (evt.isType(repeat_count_tag)) {
2205        fRepeatCount = evt.getFast32();
2206        return true;
2207    }
2208    int32_t pipeHolder;
2209    if (evt.findS32(set_use_pipe_tag, &pipeHolder)) {
2210        fPipeState = static_cast<SkOSMenu::TriState>(pipeHolder);
2211        return true;
2212    }
2213    return this->INHERITED::onEvent(evt);
2214}
2215
2216bool SampleView::onQuery(SkEvent* evt) {
2217    if (evt->isType(is_sample_view_tag)) {
2218        return true;
2219    }
2220    return this->INHERITED::onQuery(evt);
2221}
2222
2223
2224class SimplePC : public SkGPipeController {
2225public:
2226    SimplePC(SkCanvas* target);
2227    ~SimplePC();
2228
2229    virtual void* requestBlock(size_t minRequest, size_t* actual);
2230    virtual void notifyWritten(size_t bytes);
2231
2232private:
2233    SkGPipeReader   fReader;
2234    void*           fBlock;
2235    size_t          fBlockSize;
2236    size_t          fBytesWritten;
2237    int             fAtomsWritten;
2238    SkGPipeReader::Status   fStatus;
2239
2240    size_t        fTotalWritten;
2241};
2242
2243SimplePC::SimplePC(SkCanvas* target) : fReader(target) {
2244    fBlock = NULL;
2245    fBlockSize = fBytesWritten = 0;
2246    fStatus = SkGPipeReader::kDone_Status;
2247    fTotalWritten = 0;
2248    fAtomsWritten = 0;
2249}
2250
2251SimplePC::~SimplePC() {
2252//    SkASSERT(SkGPipeReader::kDone_Status == fStatus);
2253    if (fTotalWritten) {
2254        SkDebugf("--- %d bytes %d atoms, status %d\n", fTotalWritten,
2255                 fAtomsWritten, fStatus);
2256#ifdef  PIPE_FILE
2257        //File is open in append mode
2258        FILE* f = fopen(FILE_PATH, "ab");
2259        SkASSERT(f != NULL);
2260        fwrite((const char*)fBlock + fBytesWritten, 1, bytes, f);
2261        fclose(f);
2262#endif
2263#ifdef PIPE_NET
2264        if (fAtomsWritten > 1 && fTotalWritten > 4) { //ignore done
2265            gServer.acceptConnections();
2266            gServer.writePacket(fBlock, fTotalWritten);
2267        }
2268#endif
2269#ifdef  DEBUGGER
2270        gTempDataStore.reset();
2271        gTempDataStore.append(fTotalWritten, (const char*)fBlock);
2272#endif
2273    }
2274    sk_free(fBlock);
2275}
2276
2277void* SimplePC::requestBlock(size_t minRequest, size_t* actual) {
2278    sk_free(fBlock);
2279
2280    fBlockSize = minRequest * 4;
2281    fBlock = sk_malloc_throw(fBlockSize);
2282    fBytesWritten = 0;
2283    *actual = fBlockSize;
2284    return fBlock;
2285}
2286
2287void SimplePC::notifyWritten(size_t bytes) {
2288    SkASSERT(fBytesWritten + bytes <= fBlockSize);
2289    fStatus = fReader.playback((const char*)fBlock + fBytesWritten, bytes);
2290    SkASSERT(SkGPipeReader::kError_Status != fStatus);
2291    fBytesWritten += bytes;
2292    fTotalWritten += bytes;
2293
2294    fAtomsWritten += 1;
2295}
2296
2297void SampleView::draw(SkCanvas* canvas) {
2298    if (SkOSMenu::kOffState == fPipeState) {
2299        this->INHERITED::draw(canvas);
2300    } else {
2301        SkGPipeWriter writer;
2302        SimplePC controller(canvas);
2303        TiledPipeController tc(canvas->getDevice()->accessBitmap(false),
2304                               &canvas->getTotalMatrix());
2305        SkGPipeController* pc;
2306        if (SkOSMenu::kMixedState == fPipeState) {
2307            pc = &tc;
2308        } else {
2309            pc = &controller;
2310        }
2311        uint32_t flags = SkGPipeWriter::kCrossProcess_Flag;
2312
2313        canvas = writer.startRecording(pc, flags);
2314        //Must draw before controller goes out of scope and sends data
2315        this->INHERITED::draw(canvas);
2316        //explicitly end recording to ensure writer is flushed before the memory
2317        //is freed in the deconstructor of the controller
2318        writer.endRecording();
2319    }
2320}
2321void SampleView::onDraw(SkCanvas* canvas) {
2322    this->onDrawBackground(canvas);
2323
2324    for (int i = 0; i < fRepeatCount; i++) {
2325        SkAutoCanvasRestore acr(canvas, true);
2326        this->onDrawContent(canvas);
2327    }
2328}
2329
2330void SampleView::onDrawBackground(SkCanvas* canvas) {
2331    canvas->drawColor(fBGColor);
2332}
2333
2334///////////////////////////////////////////////////////////////////////////////
2335
2336template <typename T> void SkTBSort(T array[], int count) {
2337    for (int i = 1; i < count - 1; i++) {
2338        bool didSwap = false;
2339        for (int j = count - 1; j > i; --j) {
2340            if (array[j] < array[j-1]) {
2341                T tmp(array[j-1]);
2342                array[j-1] = array[j];
2343                array[j] = tmp;
2344                didSwap = true;
2345            }
2346        }
2347        if (!didSwap) {
2348            break;
2349        }
2350    }
2351
2352    for (int k = 0; k < count - 1; k++) {
2353        SkASSERT(!(array[k+1] < array[k]));
2354    }
2355}
2356
2357#include "SkRandom.h"
2358
2359static void rand_rect(SkIRect* rect, SkRandom& rand) {
2360    int bits = 8;
2361    int shift = 32 - bits;
2362    rect->set(rand.nextU() >> shift, rand.nextU() >> shift,
2363              rand.nextU() >> shift, rand.nextU() >> shift);
2364    rect->sort();
2365}
2366
2367static void dumpRect(const SkIRect& r) {
2368    SkDebugf(" { %d, %d, %d, %d },\n",
2369             r.fLeft, r.fTop,
2370             r.fRight, r.fBottom);
2371}
2372
2373static void test_rects(const SkIRect rect[], int count) {
2374    SkRegion rgn0, rgn1;
2375
2376    for (int i = 0; i < count; i++) {
2377        rgn0.op(rect[i], SkRegion::kUnion_Op);
2378     //   dumpRect(rect[i]);
2379    }
2380    rgn1.setRects(rect, count);
2381
2382    if (rgn0 != rgn1) {
2383        SkDebugf("\n");
2384        for (int i = 0; i < count; i++) {
2385            dumpRect(rect[i]);
2386        }
2387        SkDebugf("\n");
2388    }
2389}
2390
2391static void test() {
2392    size_t i;
2393
2394    const SkIRect r0[] = {
2395        { 0, 0, 1, 1 },
2396        { 2, 2, 3, 3 },
2397    };
2398    const SkIRect r1[] = {
2399        { 0, 0, 1, 3 },
2400        { 1, 1, 2, 2 },
2401        { 2, 0, 3, 3 },
2402    };
2403    const SkIRect r2[] = {
2404        { 0, 0, 1, 2 },
2405        { 2, 1, 3, 3 },
2406        { 4, 0, 5, 1 },
2407        { 6, 0, 7, 4 },
2408    };
2409
2410    static const struct {
2411        const SkIRect* fRects;
2412        int            fCount;
2413    } gRecs[] = {
2414        { r0, SK_ARRAY_COUNT(r0) },
2415        { r1, SK_ARRAY_COUNT(r1) },
2416        { r2, SK_ARRAY_COUNT(r2) },
2417    };
2418
2419    for (i = 0; i < SK_ARRAY_COUNT(gRecs); i++) {
2420        test_rects(gRecs[i].fRects, gRecs[i].fCount);
2421    }
2422
2423    SkRandom rand;
2424    for (i = 0; i < 10000; i++) {
2425        SkRegion rgn0, rgn1;
2426
2427        const int N = 8;
2428        SkIRect rect[N];
2429        for (int j = 0; j < N; j++) {
2430            rand_rect(&rect[j], rand);
2431        }
2432        test_rects(rect, N);
2433    }
2434}
2435
2436// FIXME: this should be in a header
2437SkOSWindow* create_sk_window(void* hwnd, int argc, char** argv);
2438SkOSWindow* create_sk_window(void* hwnd, int argc, char** argv) {
2439    if (false) { // avoid bit rot, suppress warning
2440        test();
2441    }
2442    return new SampleWindow(hwnd, argc, argv, NULL);
2443}
2444
2445// FIXME: this should be in a header
2446void get_preferred_size(int* x, int* y, int* width, int* height);
2447void get_preferred_size(int* x, int* y, int* width, int* height) {
2448    *x = 10;
2449    *y = 50;
2450    *width = 640;
2451    *height = 480;
2452}
2453
2454#ifdef SK_BUILD_FOR_IOS
2455void save_args(int argc, char *argv[]) {
2456}
2457#endif
2458
2459// FIXME: this should be in a header
2460void application_init();
2461void application_init() {
2462//    setenv("ANDROID_ROOT", "../../../data", 0);
2463#ifdef SK_BUILD_FOR_MAC
2464    setenv("ANDROID_ROOT", "/android/device/data", 0);
2465#endif
2466    SkGraphics::Init();
2467    SkEvent::Init();
2468}
2469
2470// FIXME: this should be in a header
2471void application_term();
2472void application_term() {
2473    SkEvent::Term();
2474    SkGraphics::Term();
2475}
2476