Add drawer with state information

tools/viewer/Viewer.cpp

 /*
 * Copyright 2016 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #include "Viewer.h"
 
 #include "GMSlide.h"
@@ skipping 17 matching lines @@
     return vv->onPaint(canvas);
 }
 
 static bool on_touch_handler(int owner, Window::InputState state, float x, float y, void* userData)
 {
     Viewer* viewer = reinterpret_cast<Viewer*>(userData);
 
     return viewer->onTouch(owner, state, x, y);
 }
 
-DEFINE_bool2(fullscreen, f, false, "Run fullscreen.");
+static void on_ui_state_changed_handler(const SkString& stateName, const SkString& stateValue, void* userData) {
+    Viewer* viewer = reinterpret_cast<Viewer*>(userData);
+
+    return viewer->onUIStateChanged(stateName, stateValue);
+}
+
+DEFINE_bool2(fullscreen, f, true, "Run fullscreen.");
 DEFINE_string(key, "", "Space-separated key/value pairs to add to JSON identifying this builder.");
 DEFINE_string2(match, m, nullptr,
                "[~][^]substring[$] [...] of bench name to run.\n"
                "Multiple matches may be separated by spaces.\n"
                "~ causes a matching bench to always be skipped\n"
                "^ requires the start of the bench to match\n"
                "$ requires the end of the bench to match\n"
                "^ and $ requires an exact match\n"
                "If a bench does not match any list entry,\n"
                "it is skipped unless some list entry starts with ~");
 DEFINE_string(skps, "skps", "Directory to read skps from.");
 DEFINE_bool(vulkan, true, "Run with Vulkan.");
 
 const char *kBackendTypeStrings[sk_app::Window::kBackendTypeCount] = {
     " [OpenGL]",
     " [Vulkan]"
 };
 
+const char* kName = "name";
+const char* kValue = "value";
+const char* kOptions = "options";
+const char* kSlideStateName = "Slide";
+const char* kBackendStateName = "Backend";
+
 Viewer::Viewer(int argc, char** argv, void* platformData)
     : fCurrentMeasurement(0)
     , fDisplayStats(false)
     , fBackendType(sk_app::Window::kVulkan_BackendType)
     , fZoomCenterX(0.0f)
     , fZoomCenterY(0.0f)
     , fZoomLevel(0.0f)
     , fZoomScale(SK_Scalar1)
 {
     memset(fMeasurements, 0, sizeof(fMeasurements));
 
     SkDebugf("Command line arguments: ");
     for (int i = 1; i < argc; ++i) {
         SkDebugf("%s ", argv[i]);
     }
     SkDebugf("\n");
 
     SkCommandLineFlags::Parse(argc, argv);
 
     fBackendType = FLAGS_vulkan ? sk_app::Window::kVulkan_BackendType
                                 : sk_app::Window::kNativeGL_BackendType;
 
     fWindow = Window::CreateNativeWindow(platformData);
     fWindow->attach(fBackendType, DisplayParams());
 
     // register callbacks
     fCommands.attach(fWindow);
     fWindow->registerPaintFunc(on_paint_handler, this);
     fWindow->registerTouchFunc(on_touch_handler, this);
+    fWindow->registerUIStateChangedFunc(on_ui_state_changed_handler, this);
 
     // add key-bindings
     fCommands.addCommand('s', "Overlays", "Toggle stats display", [this]() {
         this->fDisplayStats = !this->fDisplayStats;
         fWindow->inval();
     });
     fCommands.addCommand('c', "Modes", "Toggle sRGB color mode", [this]() {
         DisplayParams params = fWindow->getDisplayParams();
         params.fProfileType = (kLinear_SkColorProfileType == params.fProfileType)
             ? kSRGB_SkColorProfileType : kLinear_SkColorProfileType;
@@ skipping 117 matching lines @@
     SkString title("Viewer: ");
     title.append(fSlides[fCurrentSlide]->getName());
     if (kSRGB_SkColorProfileType == fWindow->getDisplayParams().fProfileType) {
         title.append(" sRGB");
     }
     title.append(kBackendTypeStrings[fBackendType]);
     fWindow->setTitle(title.c_str());
 }
 
 void Viewer::setupCurrentSlide(int previousSlide) {
+    if (fCurrentSlide == previousSlide) {
+        return; // no change; do nothing
+    }
+
     fGesture.reset();
     fDefaultMatrix.reset();
     fDefaultMatrixInv.reset();
 
     if (fWindow->supportsContentRect() && fWindow->scaleContentToFit()) {
         const SkRect contentRect = fWindow->getContentRect();
         const SkISize slideSize = fSlides[fCurrentSlide]->getDimensions();
         const SkRect slideBounds = SkRect::MakeIWH(slideSize.width(), slideSize.height());
         if (contentRect.width() > 0 && contentRect.height() > 0) {
             fDefaultMatrix.setRectToRect(slideBounds, contentRect, SkMatrix::kStart_ScaleToFit);
             SkAssertResult(fDefaultMatrix.invert(&fDefaultMatrixInv));
         }
     }
 
     if (fWindow->supportsContentRect()) {
         const SkISize slideSize = fSlides[fCurrentSlide]->getDimensions();
         SkRect windowRect = fWindow->getContentRect();
         fDefaultMatrixInv.mapRect(&windowRect);
         fGesture.setTransLimit(SkRect::MakeWH(slideSize.width(), slideSize.height()), windowRect);
     }
 
     this->updateTitle();
+    this->updateUIState();
     fSlides[fCurrentSlide]->load();
     if (previousSlide >= 0) {
         fSlides[previousSlide]->unload();
     }
     fWindow->inval();
 }
 
 #define MAX_ZOOM_LEVEL  8
 #define MIN_ZOOM_LEVEL  -8
 
@@ skipping 127 matching lines @@
     // Record measurements
     fMeasurements[fCurrentMeasurement++] = ms;
     fCurrentMeasurement &= (kMeasurementCount - 1);  // fast mod
     SkASSERT(fCurrentMeasurement < kMeasurementCount);
 
     fAnimTimer.updateTime();
     if (fSlides[fCurrentSlide]->animate(fAnimTimer) || fDisplayStats) {
         fWindow->inval();
     }
 }
+
+void Viewer::updateUIState() {
+    Json::Value slideState(Json::objectValue);
+    slideState[kName] = kSlideStateName;
+    slideState[kValue] = fSlides[fCurrentSlide]->getName().c_str();
+    Json::Value allSlideNames(Json::arrayValue);
+    for(auto slide : fSlides) {
+        allSlideNames.append(Json::Value(slide->getName().c_str()));
+    }
+    slideState[kOptions] = allSlideNames;
+
+    // This state is currently a demo for the one without options.
+    // We will be able to change the backend too.
+    Json::Value backendState(Json::objectValue);
+    backendState[kName] = kBackendStateName;
+    backendState[kValue] = fBackendType == sk_app::Window::kVulkan_BackendType ?
+            "Vulkan" : "Other than Vulkan";
+    backendState[kOptions] = Json::Value(Json::arrayValue);
+
+    Json::Value state(Json::arrayValue);
+    state.append(slideState);
+    state.append(backendState);
+
+    fWindow->setUIState(state);
+}
+
+void Viewer::onUIStateChanged(const SkString& stateName, const SkString& stateValue) {
+    // Currently, we only recognize the Slide state
+    if (stateName.equals(kSlideStateName)) {
+        int previousSlide = fCurrentSlide;
+        fCurrentSlide = 0;
+        for(auto slide : fSlides) {
+            if (slide->getName().equals(stateValue)) {
+                setupCurrentSlide(previousSlide);
+                break;
+            }
+            fCurrentSlide++;
+        }
+        if (fCurrentSlide >= fSlides.count()) {
+            fCurrentSlide = previousSlide;
+            SkDebugf("Slide not found: %s", stateValue.c_str());
+        }
+    } else {
+        SkDebugf("Unknown stateName: %s", stateName.c_str());
+    }
+}