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