SampleApp: Build list of devices dynamically

samplecode/SampleApp.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SampleApp.h"
 
 #include "OverView.h"
@@ skipping 51 matching lines @@
 class PdfFileViewerFactory : public SkViewFactory {
     SkString fFilename;
 public:
     PdfFileViewerFactory(const SkString& filename) : fFilename(filename) {}
     SkView* operator() () const override {
         return CreateSamplePdfFileViewer(fFilename.c_str());
     }
 };
 #endif  // SAMPLE_PDF_FILE_VIEWER
 
-#if SK_COMMAND_BUFFER
-#define DEFAULT_TO_COMMAND_BUFFER 1
-#elif SK_ANGLE
-//#define DEFAULT_TO_ANGLE 1
-#else
-#define DEFAULT_TO_GPU 0 // if 1 default rendering is on GPU
-#endif
-
 #define ANIMATING_EVENTTYPE "nextSample"
 #define ANIMATING_DELAY     250
 
 #ifdef SK_DEBUG
     #define FPS_REPEAT_MULTIPLIER   1
 #else
     #define FPS_REPEAT_MULTIPLIER   10
 #endif
 #define FPS_REPEAT_COUNT    (10 * FPS_REPEAT_MULTIPLIER)
 
@@ skipping 339 matching lines @@
 //////////////////////////////////////////////////////////////////////////////
 
 enum FlipAxisEnum {
     kFlipAxis_X = (1 << 0),
     kFlipAxis_Y = (1 << 1)
 };
 
 #include "SkDrawFilter.h"
 
 struct HintingState {
-    SkPaint::Hinting hinting;
-    const char* name;
-    const char* label;
+    SkPaint::Hinting fHinting;
+    const char* fMenuLabel;
+    const char* fTitleLabel;
 };
 static HintingState gHintingStates[] = {
     {SkPaint::kNo_Hinting, "Mixed", nullptr },
     {SkPaint::kNo_Hinting, "None", "H0 " },
     {SkPaint::kSlight_Hinting, "Slight", "Hs " },
     {SkPaint::kNormal_Hinting, "Normal", "Hn " },
     {SkPaint::kFull_Hinting, "Full", "Hf " },
 };
 
 struct FilterQualityState {
     SkFilterQuality fQuality;
-    const char*     fName;
-    const char*     fLabel;
+    const char*     fMenuLabel;
+    const char*     fTitleLabel;
 };
 static FilterQualityState gFilterQualityStates[] = {
     { kNone_SkFilterQuality,   "Mixed",    nullptr    },
     { kNone_SkFilterQuality,   "None",     "F0 "   },
     { kLow_SkFilterQuality,    "Low",      "F1 "   },
     { kMedium_SkFilterQuality, "Medium",   "F2 "   },
     { kHigh_SkFilterQuality,   "High",     "F3 "   },
 };
 
 class FlagsFilterCanvas : public SkPaintFilterCanvas {
@@ skipping 21 matching lines @@
         if (SkOSMenu::kMixedState != fAAState) {
             paint->writable()->setAntiAlias(SkOSMenu::kOnState == fAAState);
         }
         if (0 != fFilterQualityIndex) {
             paint->writable()->setFilterQuality(gFilterQualityStates[fFilterQualityIndex].fQuality);
         }
         if (SkOSMenu::kMixedState != fSubpixelState) {
             paint->writable()->setSubpixelText(SkOSMenu::kOnState == fSubpixelState);
         }
         if (0 != fHintingState && fHintingState < (int)SK_ARRAY_COUNT(gHintingStates)) {
-            paint->writable()->setHinting(gHintingStates[fHintingState].hinting);
+            paint->writable()->setHinting(gHintingStates[fHintingState].fHinting);
         }
         return true;
     }
 
 private:
     SkOSMenu::TriState  fLCDState;
     SkOSMenu::TriState  fAAState;
     SkOSMenu::TriState  fSubpixelState;
     int fHintingState;
     int fFilterQualityIndex;
@@ skipping 78 matching lines @@
     kRel_16x1_Tiling,
 
     kLast_TilingMode_Enum
 };
 
 struct TilingInfo {
     const char* label;
     SkScalar    w, h;
 };
 
-static const struct TilingInfo gTilingInfo[] = {
+static const struct TilingInfo gTilingInfos[] = {
     { "No tiling", SK_Scalar1        , SK_Scalar1         }, // kNo_Tiling
     { "128x128"  , SkIntToScalar(128), SkIntToScalar(128) }, // kAbs_128x128_Tiling
     { "256x256"  , SkIntToScalar(256), SkIntToScalar(256) }, // kAbs_256x256_Tiling
     { "1/4x1/4"  , SK_Scalar1 / 4    , SK_Scalar1 / 4     }, // kRel_4x4_Tiling
     { "1/1x1/16" , SK_Scalar1        , SK_Scalar1 / 16    }, // kRel_1x16_Tiling
     { "1/16x1/1" , SK_Scalar1 / 16   , SK_Scalar1         }, // kRel_16x1_Tiling
 };
-static_assert((SK_ARRAY_COUNT(gTilingInfo) == kLast_TilingMode_Enum),
+static_assert((SK_ARRAY_COUNT(gTilingInfos) == kLast_TilingMode_Enum),
               "Incomplete_tiling_labels");
 
 SkSize SampleWindow::tileSize() const {
     SkASSERT((TilingMode)fTilingMode < kLast_TilingMode_Enum);
-    const struct TilingInfo* info = gTilingInfo + fTilingMode;
+    const struct TilingInfo* info = &gTilingInfos[fTilingMode];
     return SkSize::Make(info->w > SK_Scalar1 ? info->w : this->width() * info->w,
                         info->h > SK_Scalar1 ? info->h : this->height() * info->h);
 }
 //////////////////////////////////////////////////////////////////////////////
 
 static SkView* curr_view(SkWindow* wind) {
     SkView::F2BIter iter(wind);
     return iter.next();
 }
 
@@ skipping 38 matching lines @@
 }
 
 void SampleWindow::updatePointer(int x, int y) {
     fMouseX = x;
     fMouseY = y;
     if (fShowZoomer) {
         this->inval(nullptr);
     }
 }
 
-static inline SampleWindow::DeviceType cycle_devicetype(SampleWindow::DeviceType ct) {
-    static const SampleWindow::DeviceType gCT[] = {
-        SampleWindow::kRaster_DeviceType
-#if SK_SUPPORT_GPU
-        , SampleWindow::kGPU_DeviceType
-#if SK_ANGLE
-        , SampleWindow::kANGLE_DeviceType
-#endif // SK_ANGLE
-#if SK_COMMAND_BUFFER
-        , SampleWindow::kCommandBuffer_DeviceType
-#endif // SK_COMMAND_BUFFER
-#endif // SK_SUPPORT_GPU
-    };
-    static_assert(SK_ARRAY_COUNT(gCT) == SampleWindow::kDeviceTypeCnt, "array_size_mismatch");
-    return gCT[ct];
-}
-
 static SkString getSampleTitle(const SkViewFactory* sampleFactory) {
     SkView* view = (*sampleFactory)();
     SkString title;
     SampleCode::RequestTitle(view, &title);
     view->unref();
     return title;
 }
 
 static bool compareSampleTitle(const SkViewFactory* first, const SkViewFactory* second) {
     return strcmp(getSampleTitle(first).c_str(), getSampleTitle(second).c_str()) < 0;
@@ skipping 23 matching lines @@
     }
 }
 
 DEFINE_string(slide, "", "Start on this sample.");
 DEFINE_int32(msaa, 0, "Request multisampling with this count.");
 DEFINE_string(pictureDir, "", "Read pictures from here.");
 DEFINE_string(picture, "", "Path to single picture.");
 DEFINE_string(sequence, "", "Path to file containing the desired samples/gms to show.");
 DEFINE_bool(sort, false, "Sort samples by title.");
 DEFINE_bool(list, false, "List samples?");
-DEFINE_bool(gpu, false, "Start up with gpu?");
 DEFINE_string(key, "", "");  // dummy to enable gm tests that have platform-specific names
 #ifdef SAMPLE_PDF_FILE_VIEWER
 DEFINE_string(pdfPath, "", "Path to direcotry of pdf files.");
 #endif
 
+static const char startWithHelp[] = "Start with backend. Options: raster"
+#if SK_SUPPORT_GPU
+        " gpu"
+#if SK_ANGLE
+#ifdef SK_BUILD_FOR_WIN
+        " angle"
+#endif
+#endif
+#if SK_COMMAND_BUFFER
+        " commandbuffer"
+#endif
+#endif
+        "";
+DEFINE_string(startWith, "raster", startWithHelp);
+
+
+struct DeviceInfo {
+    const char* fName;
+    const char* fMenuLabel;
+    SampleWindow::DeviceType fType;
+};
+static const DeviceInfo gDeviceInfos[] = {
+    { "raster", "Raster", SampleWindow::kRaster_DeviceType }
+#if SK_SUPPORT_GPU
+    , { "gpu", "GPU", SampleWindow::kGPU_DeviceType }
+#if SK_ANGLE
+#ifdef SK_BUILD_FOR_WIN
+    , { "angle", "ANGLE DirectX", SampleWindow::kANGLE_DeviceType }
+#endif
+#endif
+#if SK_COMMAND_BUFFER
+    , { "commandbuffer", "Command Buffer", kCommandBuffer_DeviceType }
+#endif
+#endif
+};
+
 #include "SkTaskGroup.h"
 
 SampleWindow::SampleWindow(void* hwnd, int argc, char** argv, DeviceManager* devManager)
     : INHERITED(hwnd)
     , fDevManager(nullptr) {
 
     SkCommandLineFlags::Parse(argc, argv);
+    for (fDeviceIndex = 0; fDeviceIndex < SK_ARRAY_COUNT(gDeviceInfos); ++fDeviceIndex) {
+        SkString name(gDeviceInfos[fDeviceIndex].fName);
+        if (name.equals(FLAGS_startWith[0])) {
+            break;
+        }
+    }
+    if (fDeviceIndex == SK_ARRAY_COUNT(gDeviceInfos)) {
+        SkDebugf("WARNING: can not start with unknown device %s\n",  FLAGS_startWith[0]);
+        fDeviceIndex = 0;
+    }
 
     fCurrIndex = -1;
 
     if (!FLAGS_pictureDir.isEmpty()) {
         SkOSFile::Iter iter(FLAGS_pictureDir[0], "skp");
         SkString filename;
         while (iter.next(&filename)) {
             *fSamples.append() = new PictFileFactory(
                 SkOSPath::Join(FLAGS_pictureDir[0], filename.c_str()));
         }
@@ skipping 48 matching lines @@
     }
 
     if (!FLAGS_slide.isEmpty()) {
         fCurrIndex = findByTitle(FLAGS_slide[0]);
         if (fCurrIndex < 0) {
             fprintf(stderr, "Unknown sample \"%s\"\n", FLAGS_slide[0]);
             listTitles();
         }
     }
 
-    fMSAASampleCount = FLAGS_msaa;
-
     if (FLAGS_list) {
         listTitles();
     }
 
     if (fCurrIndex < 0) {
         SkString title;
         if (readTitleFromPrefs(&title)) {
             fCurrIndex = findByTitle(title.c_str());
         }
     }
 
     if (fCurrIndex < 0) {
         fCurrIndex = 0;
     }
 
     static SkTaskGroup::Enabler enabled(-1);
     gSampleWindow = this;
 
-    fDeviceType = kRaster_DeviceType;
-#if SK_SUPPORT_GPU
-    if (FLAGS_gpu) {
-        fDeviceType = kGPU_DeviceType;
-    }
-#endif
-        
-#if DEFAULT_TO_GPU
-    fDeviceType = kGPU_DeviceType;
-#endif
-#if SK_ANGLE && DEFAULT_TO_ANGLE
-    fDeviceType = kANGLE_DeviceType;
-#endif
-#if SK_COMMAND_BUFFER && DEFAULT_TO_COMMAND_BUFFER
-    fDeviceType = kCommandBuffer_DeviceType;
-#endif
-
     fUseClip = false;
     fUsePicture = false;
     fAnimating = false;
     fRotate = false;
     fPerspAnim = false;
     fRequestGrabImage = false;
     fTilingMode = kNo_Tiling;
     fMeasureFPS = false;
     fLCDState = SkOSMenu::kMixedState;
     fAAState = SkOSMenu::kMixedState;
@@ skipping 14 matching lines @@
     fMagnify = false;
 
     fSaveToPdf = false;
     fSaveToSKP = false;
 
     int sinkID = this->getSinkID();
     fAppMenu = new SkOSMenu;
     fAppMenu->setTitle("Global Settings");
     int itemID;
 
-    itemID = fAppMenu->appendList("Device Type", "Device Type", sinkID, 0,
-                                  "Raster",
-                                  "OpenGL",
-#if SK_ANGLE
-                                  "ANGLE",
-#endif
-#if SK_COMMAND_BUFFER
-                                  "Command Buffer",
-#endif
-                                  nullptr);
+    SkTArray<const char*> deviceLabels;
+    for (auto& deviceInfo : gDeviceInfos) {
+        deviceLabels.push_back(deviceInfo.fMenuLabel);
+    }
+    itemID = fAppMenu->appendList("Device Type", "Device Type", sinkID, 0, deviceLabels);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'd');
     itemID = fAppMenu->appendTriState("AA", "AA", sinkID, fAAState);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'b');
     itemID = fAppMenu->appendTriState("LCD", "LCD", sinkID, fLCDState);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'l');
+    SkTArray<const char*> filterQualityLabels;
+    for (auto& state : gFilterQualityStates) {
+        filterQualityLabels.push_back(state.fMenuLabel);
+    }
     itemID = fAppMenu->appendList("FilterQuality", "FilterQuality", sinkID, fFilterQualityIndex,
-                                  gFilterQualityStates[0].fName,
-                                  gFilterQualityStates[1].fName,
-                                  gFilterQualityStates[2].fName,
-                                  gFilterQualityStates[3].fName,
-                                  gFilterQualityStates[4].fName,
-                                  nullptr);
+                                  filterQualityLabels);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'n');
     itemID = fAppMenu->appendTriState("Subpixel", "Subpixel", sinkID, fSubpixelState);
     fAppMenu->assignKeyEquivalentToItem(itemID, 's');
-    itemID = fAppMenu->appendList("Hinting", "Hinting", sinkID, fHintingState,
-                                  gHintingStates[0].name,
-                                  gHintingStates[1].name,
-                                  gHintingStates[2].name,
-                                  gHintingStates[3].name,
-                                  gHintingStates[4].name,
-                                  nullptr);
+    SkTArray<const char*> hintingStates;
+    for (auto& hintingState : gHintingStates) {
+        hintingStates.push_back(hintingState.fMenuLabel);
+    }
+    itemID = fAppMenu->appendList("Hinting", "Hinting", sinkID, fHintingState, hintingStates);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'h');
 
-    itemID =fAppMenu->appendList("Tiling", "Tiling", sinkID, fTilingMode,
-                                 gTilingInfo[kNo_Tiling].label,
-                                 gTilingInfo[kAbs_128x128_Tiling].label,
-                                 gTilingInfo[kAbs_256x256_Tiling].label,
-                                 gTilingInfo[kRel_4x4_Tiling].label,
-                                 gTilingInfo[kRel_1x16_Tiling].label,
-                                 gTilingInfo[kRel_16x1_Tiling].label,
-                                 nullptr);
+    SkTArray<const char*> tilingInfos;
+    for (auto& tilingInfo : gTilingInfos) {
+        tilingInfos.push_back(tilingInfo.label);
+    }
+    itemID = fAppMenu->appendList("Tiling", "Tiling", sinkID, fTilingMode, tilingInfos);
     fAppMenu->assignKeyEquivalentToItem(itemID, 't');
 
     itemID = fAppMenu->appendSwitch("Slide Show", "Slide Show" , sinkID, false);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'a');
     itemID = fAppMenu->appendSwitch("Clip", "Clip" , sinkID, fUseClip);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'c');
     itemID = fAppMenu->appendSwitch("Flip X", "Flip X" , sinkID, false);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'x');
     itemID = fAppMenu->appendSwitch("Flip Y", "Flip Y" , sinkID, false);
     fAppMenu->assignKeyEquivalentToItem(itemID, 'y');
@@ skipping 13 matching lines @@
     this->setClipToBounds(false);
 
     this->loadView((*fSamples[fCurrIndex])());
 
     if (nullptr == devManager) {
         fDevManager = new DefaultDeviceManager();
     } else {
         devManager->ref();
         fDevManager = devManager;
     }
-    fDevManager->setUpBackend(this, fMSAASampleCount);
+    fDeviceType = gDeviceInfos[fDeviceIndex].fType;
+    fDevManager->setUpBackend(this, FLAGS_msaa);
 
     // If another constructor set our dimensions, ensure that our
     // onSizeChange gets called.
     if (this->height() && this->width()) {
         this->onSizeChange();
     }
 
     // can't call this synchronously, since it may require a subclass to
     // to implement, or the caller may need us to have returned from the
     // constructor first. Hence we post an event to ourselves.
@@ skipping 582 matching lines @@
     if (evt.isType("set-curr-index")) {
         this->goToSample(evt.getFast32());
         return true;
     }
     if (isInvalEvent(evt)) {
         this->inval(nullptr);
         return true;
     }
     int selected = -1;
     if (SkOSMenu::FindListIndex(evt, "Device Type", &selected)) {
-        this->setDeviceType((DeviceType)selected);
+        this->setDevice(static_cast<size_t>(selected));
         return true;
     }
     if (SkOSMenu::FindSwitchState(evt, "Slide Show", nullptr)) {
         this->toggleSlideshow();
         return true;
     }
     if (SkOSMenu::FindTriState(evt, "AA", &fAAState) ||
         SkOSMenu::FindTriState(evt, "LCD", &fLCDState) ||
         SkOSMenu::FindListIndex(evt, "FilterQuality", &fFilterQualityIndex) ||
         SkOSMenu::FindTriState(evt, "Subpixel", &fSubpixelState) ||
@@ skipping 183 matching lines @@
     }
 
     if (fAppMenu->handleKeyEquivalent(uni)|| fSlideMenu->handleKeyEquivalent(uni)) {
         this->onUpdateMenu(fAppMenu);
         this->onUpdateMenu(fSlideMenu);
         return true;
     }
     return this->INHERITED::onHandleChar(uni);
 }
 
-void SampleWindow::setDeviceType(DeviceType type) {
-    if (type == fDeviceType)
+void SampleWindow::setDevice(size_t deviceIndex) {
+    if (fDeviceIndex == deviceIndex)
         return;
 
     fDevManager->tearDownBackend(this);
-
-    fDeviceType = type;
-
-    fDevManager->setUpBackend(this, fMSAASampleCount);
+    fDeviceIndex = deviceIndex;
+    fDeviceType = gDeviceInfos[fDeviceIndex].fType;
+    fDevManager->setUpBackend(this, FLAGS_msaa);
 
     this->updateTitle();
     this->inval(nullptr);
 }
 
 void SampleWindow::toggleSlideshow() {
     fAnimating = !fAnimating;
     this->postAnimatingEvent();
     this->updateTitle();
 }
 
 void SampleWindow::toggleRendering() {
-    this->setDeviceType(cycle_devicetype(fDeviceType));
+    this->setDevice((fDeviceIndex + 1) % SK_ARRAY_COUNT(gDeviceInfos));
     this->updateTitle();
     this->inval(nullptr);
 }
 
 void SampleWindow::toggleFPS() {
     fMeasureFPS = !fMeasureFPS;
     this->updateTitle();
     this->inval(nullptr);
 }
 
 void SampleWindow::toggleDistanceFieldFonts() {
     // reset backend
     fDevManager->tearDownBackend(this);
-    fDevManager->setUpBackend(this, fMSAASampleCount);
+    fDevManager->setUpBackend(this, FLAGS_msaa);
 
     SkSurfaceProps props = this->getSurfaceProps();
     uint32_t flags = props.flags() ^ SkSurfaceProps::kUseDeviceIndependentFonts_Flag;
     this->setSurfaceProps(SkSurfaceProps(flags, props.pixelGeometry()));
 
     this->updateTitle();
     this->inval(nullptr);
 }
 
 #include "SkDumpCanvas.h"
@@ skipping 131 matching lines @@
     this->attachChildToFront(view)->unref();
     view->setSize(this->width(), this->height());
 
     //repopulate the slide menu when a view is loaded
     fSlideMenu->reset();
 
     this->onUpdateMenu(fSlideMenu);
     this->updateTitle();
 }
 
-static const char* gDeviceTypePrefix[] = {
-    "raster: ",
-#if SK_SUPPORT_GPU
-    "opengl: ",
-#if SK_ANGLE
-    "angle: ",
-#endif // SK_ANGLE
-#if SK_COMMAND_BUFFER
-    "command buffer: ",
-#endif // SK_COMMAND_BUFFER
-#endif // SK_SUPPORT_GPU
-};
-static_assert(SK_ARRAY_COUNT(gDeviceTypePrefix) == SampleWindow::kDeviceTypeCnt,
-              "array_size_mismatch");
-
 static const char* trystate_str(SkOSMenu::TriState state,
                                 const char trueStr[], const char falseStr[]) {
     if (SkOSMenu::kOnState == state) {
         return trueStr;
     } else if (SkOSMenu::kOffState == state) {
         return falseStr;
     }
     return nullptr;
 }
 
 bool SampleWindow::getRawTitle(SkString* title) {
     return curr_title(this, title);
 }
 
 void SampleWindow::updateTitle() {
     SkString title;
     if (!this->getRawTitle(&title)) {
         title.set("<unknown>");
     }
+    title.prependf(" %s: ", gDeviceInfos[fDeviceIndex].fName);
 
-    title.prepend(gDeviceTypePrefix[fDeviceType]);
-
-    title.prepend(" ");
     title.prepend(sk_tool_utils::colortype_name(this->getBitmap().colorType()));
 
     if (fTilingMode != kNo_Tiling) {
-        title.prependf("<T: %s> ", gTilingInfo[fTilingMode].label);
+        title.prependf("<T: %s> ", gTilingInfos[fTilingMode].label);
     }
     if (fAnimating) {
         title.prepend("<A> ");
     }
     if (fRotate) {
         title.prepend("<R> ");
     }
     if (fPerspAnim) {
         title.prepend("<K> ");
     }
     if (this->getSurfaceProps().flags() & SkSurfaceProps::kUseDeviceIndependentFonts_Flag) {
         title.prepend("<DIF> ");
     }
     if (fUsePicture) {
         title.prepend("<P> ");
     }
 
     title.prepend(trystate_str(fLCDState, "LCD ", "lcd "));
     title.prepend(trystate_str(fAAState, "AA ", "aa "));
-    title.prepend(gFilterQualityStates[fFilterQualityIndex].fLabel);
+    title.prepend(gFilterQualityStates[fFilterQualityIndex].fTitleLabel);
     title.prepend(trystate_str(fSubpixelState, "S ", "s "));
     title.prepend(fFlipAxis & kFlipAxis_X ? "X " : nullptr);
     title.prepend(fFlipAxis & kFlipAxis_Y ? "Y " : nullptr);
-    title.prepend(gHintingStates[fHintingState].label);
+    title.prepend(gHintingStates[fHintingState].fTitleLabel);
 
     if (fZoomLevel) {
         title.prependf("{%.2f} ", SkScalarToFloat(fZoomLevel));
     }
 
     if (fMeasureFPS) {
         title.appendf(" %8.4f ms", fMeasureFPS_Time / (float)FPS_REPEAT_COUNT);
     }
 
 #if SK_SUPPORT_GPU
@@ skipping 241 matching lines @@
 #ifdef SK_BUILD_FOR_MAC
     setenv("ANDROID_ROOT", "/android/device/data", 0);
 #endif
     SkGraphics::Init();
     SkEvent::Init();
 }
 
 void application_term() {
     SkEvent::Term();
 }