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