[datalogtool] Add datalogtool

This is a support tool for datalog file conversion (and eventually
download/remote datalog file management).

.github/workflows/cmake.yml

@@ -12,7 +12,7 @@ jobs:
             name: Linux
             container: wpilib/roborio-cross-ubuntu:2022-20.04
             flags: ""
-          - os: macos-latest
+          - os: macOS-11
             name: macOS
             container: ""
             flags: "-DWITH_JAVA=OFF"
@@ -43,7 +43,7 @@ jobs:
 
   build-vcpkg:
     name: "Build - Windows"
-    runs-on: windows-latest
+    runs-on: windows-2019
     steps:
       - uses: actions/checkout@v2
       - name: Prepare vcpkg

.github/workflows/gradle.yml

@@ -44,13 +44,13 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - os: windows-latest
+          - os: windows-2019
             artifact-name: Win64
             architecture: x64
-          - os: windows-latest
+          - os: windows-2019
             artifact-name: Win32
             architecture: x86
-          - os: macos-latest
+          - os: macOS-11
             artifact-name: macOS
             architecture: x64
     name: "Build - ${{ matrix.artifact-name }}"

.styleguide

@@ -11,6 +11,7 @@ cppSrcFileInclude {
 
 modifiableFileExclude {
   \.patch$
+  gradlew
 }
 
 generatedFileExclude {

.wpilib/wpilib_preferences.json

@@ -1,6 +1,6 @@
 {
   "enableCppIntellisense": true,
   "currentLanguage": "cpp",
-  "projectYear": "2021",
+  "projectYear": "intellisense",
   "teamNumber": 0
 }

CMakeLists.txt

@@ -6,11 +6,17 @@ FATAL: In-source builds are not allowed.
 ")
 endif()
 
+if ("${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "Windows")
+    set(CMAKE_SYSTEM_VERSION 10.0.18362.0 CACHE STRING INTERNAL FORCE)
+    set(CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION 10.0.18362.0 CACHE STRING INTERNAL FORCE)
+endif()
 
 project(allwpilib)
 cmake_minimum_required(VERSION 3.3.0)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
 
+message(STATUS "Platform version: ${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}")
+
 set(WPILIB_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 
 INCLUDE(CPack)
@@ -139,6 +145,8 @@ if (USE_VCPKG_EIGEN)
 set (EIGEN_VCPKG_REPLACE "find_package(Eigen3 CONFIG)")
 endif()
 
+find_package(LIBSSH 0.7.1)
+
 if (WITH_FLAT_INSTALL)
 set(WPIUTIL_DEP_REPLACE "include($\{SELF_DIR\}/wpiutil-config.cmake)")
 set(NTCORE_DEP_REPLACE "include($\{SELF_DIR\}/ntcore-config.cmake)")
@@ -239,7 +247,6 @@ if (WITH_TESTS)
     include(GoogleTest)
 endif()
 
-add_subdirectory(fieldImages)
 add_subdirectory(wpiutil)
 add_subdirectory(ntcore)
 
@@ -248,10 +255,15 @@ if (WITH_WPIMATH)
 endif()
 
 if (WITH_GUI)
+    add_subdirectory(fieldImages)
     add_subdirectory(imgui)
     add_subdirectory(wpigui)
     add_subdirectory(glass)
     add_subdirectory(outlineviewer)
+    if (LIBSSH_FOUND)
+        add_subdirectory(roborioteamnumbersetter)
+        add_subdirectory(datalogtool)
+    endif()
 endif()
 
 if (WITH_WPILIB OR WITH_SIMULATION_MODULES)

LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2009-2021 FIRST and other WPILib contributors
+Copyright (c) 2009-2022 FIRST and other WPILib contributors
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

MavenArtifacts.md

@@ -69,15 +69,36 @@ All artifacts are based at `edu.wpi.first.artifactname` in the repository.
 
 * wpiutil
 
+* wpigui
+  * imgui
+
+* ntcore
+  * wpiutil
+
+* wpimath
+  * wpiutil
+
+* glass/libglass
+  * wpiutil
+  * wpimath
+  * wpigui
+
+* glass/libglassnt
+  * wpiutil
+  * ntcore
+  * wpimath
+  * wpigui
+
 * hal
   * wpiutil
 
 * halsim
-  * imgui
-  * wpiutil
-
-* ntcore
   * wpiutil
+  * ntcore
+  * wpimath
+  * wpigui
+  * libglass
+  * libglassnt
 
 * cscore
   * opencv
@@ -101,6 +122,7 @@ All artifacts are based at `edu.wpi.first.artifactname` in the repository.
   * cameraserver
   * ntcore
   * cscore
+  * wpimath
   * wpiutil
 
 * wpilibNewCommands
@@ -109,9 +131,10 @@ All artifacts are based at `edu.wpi.first.artifactname` in the repository.
   * cameraserver
   * ntcore
   * cscore
+  * wpimath
   * wpiutil
 
-* wpilibNewCommands
+* wpilibOldCommands
   * wpilibc
   * hal
   * cameraserver
@@ -119,6 +142,7 @@ All artifacts are based at `edu.wpi.first.artifactname` in the repository.
   * cscore
   * wpiutil
 
+
 ### Third Party Artifacts
 
 This repository provides the builds of the following third party software.
@@ -128,3 +152,4 @@ All artifacts are based at `edu.wpi.first.thirdparty.frcYEAR` in the repository.
 * googletest
 * imgui
 * opencv
+* libssh

OtherVersions.md

@@ -11,6 +11,7 @@ Development builds are the per-commit build hosted everytime a commit is pushed
 In order to build a project using a development build, find the build.gradle file and open it. Then, add the following code below the plugin section and replace YEAR with the year of the development version.
 
 ```groovy
+wpi.maven.useLocal = false
 wpi.maven.useDevelopment = true
 wpi.versions.wpilibVersion = 'YEAR.+'
 wpi.versions.wpimathVersion = 'YEAR.+

README.md

@@ -39,7 +39,7 @@ Using Gradle makes building WPILib very straightforward. It only has a few depen
     - On macOS, install the JDK 11 .pkg from the link above
 - C++ compiler
     - On Linux, install GCC 8 or greater
-    - On Windows, install [Visual Studio Community 2019](https://visualstudio.microsoft.com/vs/community/) and select the C++ programming language during installation (Gradle can't use the build tools for Visual Studio 2019)
+    - On Windows, install [Visual Studio Community 2022 or 2019](https://visualstudio.microsoft.com/vs/community/) and select the C++ programming language during installation (Gradle can't use the build tools for Visual Studio)
     - On macOS, install the Xcode command-line build tools via `xcode-select --install`
 - ARM compiler toolchain
     - Run `./gradlew installRoboRioToolchain` after cloning this repository
@@ -71,6 +71,8 @@ The gradlew wrapper only exists in the root of the main project, so be sure to r
 
 There are a few tasks other than `build` available. To see them, run the meta-task `tasks`. This will print a list of all available tasks, with a description of each task.
 
+If opening from a fresh clone, generated java dependencies will not exist. Most IDEs will not run the generation tasks, which will cause lots of IDE errors. Manually run `./gradlew compileJava` from a terminal to run all the compile tasks, and then refresh your IDE's configuration (In VS Code open settings.gradle and save).
+
 ### Faster builds
 
 `./gradlew build` builds _everything_, which includes debug and release builds for desktop and all installed cross compilers. Many developers don't need or want to build all of this. Therefore, common tasks have shortcuts to only build necessary components for common development and testing tasks.

build.gradle

@@ -5,7 +5,7 @@ buildscript {
         mavenCentral()
     }
     dependencies {
-        classpath 'com.hubspot.jinjava:jinjava:2.5.8'
+        classpath 'com.hubspot.jinjava:jinjava:2.6.0'
     }
 }
 
@@ -15,13 +15,13 @@ plugins {
     id 'edu.wpi.first.wpilib.repositories.WPILibRepositoriesPlugin' version '2020.2'
     id 'edu.wpi.first.NativeUtils' apply false
     id 'edu.wpi.first.GradleJni' version '1.0.0'
-    id 'edu.wpi.first.GradleVsCode' version '1.0.0'
+    id 'edu.wpi.first.GradleVsCode'
     id 'idea'
     id 'visual-studio'
-    id 'net.ltgt.errorprone' version '1.1.1' apply false
-    id 'com.github.johnrengelman.shadow' version '5.2.0' apply false
-    id 'com.diffplug.spotless' version '5.5.0' apply false
-    id 'com.github.spotbugs' version '5.0.0-beta.1' apply false
+    id 'net.ltgt.errorprone' version '2.0.2' apply false
+    id 'com.github.johnrengelman.shadow' version '7.1.2' apply false
+    id 'com.diffplug.spotless' version '6.1.2' apply false
+    id 'com.github.spotbugs' version '5.0.4' apply false
 }
 
 wpilibVersioning.buildServerMode = project.hasProperty('buildServer')
@@ -147,5 +147,5 @@ ext.getCurrentArch = {
 }
 
 wrapper {
-    gradleVersion = '7.1.1'
+    gradleVersion = '7.3.3'
 }

buildSrc/build.gradle

@@ -5,5 +5,5 @@ repositories {
     }
 }
 dependencies {
-    implementation "edu.wpi.first:native-utils:2022.3.1"
+    implementation "edu.wpi.first:native-utils:2022.7.1"
 }

cameraserver/multiCameraServer/build.gradle

@@ -27,7 +27,7 @@ repositories {
 }
 
 dependencies {
-    implementation 'com.google.code.gson:gson:2.8.5'
+    implementation 'com.google.code.gson:gson:2.8.9'
 
     implementation project(':wpiutil')
     implementation project(':ntcore')

cameraserver/multiCameraServer/src/main/java/edu/wpi/Main.java

@@ -56,9 +56,9 @@ public final class Main {
     public JsonObject config;
   }
 
-  static int team;
-  static boolean server;
-  static List<CameraConfig> cameras = new ArrayList<>();
+  private static int team;
+  private static boolean server;
+  private static List<CameraConfig> cameras = new ArrayList<>();
 
   private Main() {}
 

cameraserver/src/main/native/cpp/cameraserver/CameraServer.cpp

@@ -450,9 +450,9 @@ Instance::Instance() {
           entry.SetString(VideoModeToString(sourceIt->second.GetVideoMode()));
           return;
         } else if (wpi::starts_with(relativeKey, "Property/")) {
-          propName = relativeKey.substr(9);
+          propName = wpi::substr(relativeKey, 9);
         } else if (wpi::starts_with(relativeKey, "RawProperty/")) {
-          propName = relativeKey.substr(12);
+          propName = wpi::substr(relativeKey, 12);
         } else {
           return;  // ignore
         }

cmake/modules/CompileWarnings.cmake

@@ -1,7 +1,7 @@
 macro(wpilib_target_warnings target)
     if(NOT MSVC)
-        target_compile_options(${target} PRIVATE -Wall -pedantic -Wextra -Werror -Wno-unused-parameter -Wno-error=deprecated-declarations)
+        target_compile_options(${target} PRIVATE -Wall -pedantic -Wextra -Werror -Wno-unused-parameter -Wno-error=deprecated-declarations ${WPILIB_TARGET_WARNINGS})
     else()
-        target_compile_options(${target} PRIVATE /wd4146 /wd4244 /wd4251 /wd4267 /wd4996 /WX)
+        target_compile_options(${target} PRIVATE /wd4146 /wd4244 /wd4251 /wd4267 /wd4996 /WX ${WPILIB_TARGET_WARNINGS})
     endif()
 endmacro()

cmake/modules/FindLIBSSH.cmake

@@ -0,0 +1,116 @@
+# - Try to find LibSSH
+# Once done this will define
+#
+#  LIBSSH_FOUND - system has LibSSH
+#  LIBSSH_INCLUDE_DIRS - the LibSSH include directory
+#  LIBSSH_LIBRARIES - link these to use LibSSH
+#  LIBSSH_VERSION -
+#
+#  Author Michal Vasko <mvasko@cesnet.cz>
+#  Copyright (c) 2020 CESNET, z.s.p.o.
+#
+#  Redistribution and use in source and binary forms, with or without
+#  modification, are permitted provided that the following conditions
+#  are met:
+#
+#  1. Redistributions of source code must retain the copyright
+#     notice, this list of conditions and the following disclaimer.
+#  2. Redistributions in binary form must reproduce the copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#  3. The name of the author may not be used to endorse or promote products
+#     derived from this software without specific prior written permission.
+#
+#  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+#  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+#  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+#  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+#  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+#  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+#  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+#  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+#  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+#  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+include(FindPackageHandleStandardArgs)
+
+if(LIBSSH_LIBRARIES AND LIBSSH_INCLUDE_DIRS)
+    # in cache already
+    set(LIBSSH_FOUND TRUE)
+else()
+    find_path(LIBSSH_INCLUDE_DIR
+        NAMES
+        libssh/libssh.h
+        PATHS
+        /usr/include
+        /usr/local/include
+        /opt/local/include
+        /sw/include
+        ${CMAKE_INCLUDE_PATH}
+        ${CMAKE_INSTALL_PREFIX}/include
+    )
+
+    find_library(LIBSSH_LIBRARY
+        NAMES
+        ssh.so
+        libssh.so
+        libssh.dylib
+        PATHS
+        /usr/lib
+        /usr/local/lib
+        /opt/local/lib
+        /sw/lib
+        ${CMAKE_LIBRARY_PATH}
+        ${CMAKE_INSTALL_PREFIX}/lib
+    )
+
+    if(LIBSSH_INCLUDE_DIR AND LIBSSH_LIBRARY)
+        # learn libssh version
+        if(EXISTS ${LIBSSH_INCLUDE_DIR}/libssh/libssh_version.h)
+            set(LIBSSH_HEADER_PATH ${LIBSSH_INCLUDE_DIR}/libssh/libssh_version.h)
+        else()
+            set(LIBSSH_HEADER_PATH ${LIBSSH_INCLUDE_DIR}/libssh/libssh.h)
+        endif()
+        file(STRINGS ${LIBSSH_HEADER_PATH} LIBSSH_VERSION_MAJOR
+            REGEX "#define[ ]+LIBSSH_VERSION_MAJOR[ ]+[0-9]+")
+        if(NOT LIBSSH_VERSION_MAJOR)
+            message(STATUS "LIBSSH_VERSION_MAJOR not found, assuming libssh is too old and cannot be used!")
+            set(LIBSSH_INCLUDE_DIR "LIBSSH_INCLUDE_DIR-NOTFOUND")
+            set(LIBSSH_LIBRARY "LIBSSH_LIBRARY-NOTFOUND")
+        else()
+            string(REGEX MATCH "[0-9]+" LIBSSH_VERSION_MAJOR ${LIBSSH_VERSION_MAJOR})
+            file(STRINGS ${LIBSSH_HEADER_PATH} LIBSSH_VERSION_MINOR
+                REGEX "#define[ ]+LIBSSH_VERSION_MINOR[ ]+[0-9]+")
+            string(REGEX MATCH "[0-9]+" LIBSSH_VERSION_MINOR ${LIBSSH_VERSION_MINOR})
+            file(STRINGS ${LIBSSH_HEADER_PATH} LIBSSH_VERSION_PATCH
+                REGEX "#define[ ]+LIBSSH_VERSION_MICRO[ ]+[0-9]+")
+            string(REGEX MATCH "[0-9]+" LIBSSH_VERSION_PATCH ${LIBSSH_VERSION_PATCH})
+
+            set(LIBSSH_VERSION ${LIBSSH_VERSION_MAJOR}.${LIBSSH_VERSION_MINOR}.${LIBSSH_VERSION_PATCH})
+
+            if(LIBSSH_VERSION VERSION_LESS 0.8.0)
+                # libssh_threads also needs to be linked for these versions
+                string(REPLACE "libssh.so" "libssh_threads.so"
+                    LIBSSH_THREADS_LIBRARY
+                    ${LIBSSH_LIBRARY}
+                )
+                string(REPLACE "libssh.dylib" "libssh_threads.dylib"
+                    LIBSSH_THREADS_LIBRARY
+                    ${LIBSSH_THREADS_LIBRARY}
+                )
+                string(REPLACE "ssh.so" "ssh_threads.so"
+                    LIBSSH_THREADS_LIBRARY
+                    ${LIBSSH_THREADS_LIBRARY}
+                )
+            endif()
+        endif()
+    endif()
+
+    set(LIBSSH_INCLUDE_DIRS ${LIBSSH_INCLUDE_DIR})
+    set(LIBSSH_LIBRARIES ${LIBSSH_LIBRARY} ${LIBSSH_THREADS_LIBRARY})
+    mark_as_advanced(LIBSSH_INCLUDE_DIRS LIBSSH_LIBRARIES)
+
+    find_package_handle_standard_args(LibSSH FOUND_VAR LIBSSH_FOUND
+        REQUIRED_VARS LIBSSH_INCLUDE_DIRS LIBSSH_LIBRARIES
+        VERSION_VAR LIBSSH_VERSION)
+endif()

cscore/src/main/native/cpp/HttpCameraImpl.cpp

@@ -208,7 +208,7 @@ wpi::HttpConnection* HttpCameraImpl::DeviceStreamConnect(
     if (wpi::trim(key) == "boundary") {
       value = wpi::trim(wpi::trim(value), '"');  // value may be quoted
       if (wpi::starts_with(value, "--")) {
-        value = value.substr(2);
+        value = wpi::substr(value, 2);
       }
       boundary.append(value.begin(), value.end());
     }

cscore/src/main/native/cpp/JpegUtil.cpp

@@ -4,6 +4,7 @@
 
 #include "JpegUtil.h"
 
+#include <wpi/StringExtras.h>
 #include <wpi/raw_istream.h>
 
 namespace cs {
@@ -64,7 +65,7 @@ bool GetJpegSize(std::string_view data, int* width, int* height) {
     return false;
   }
 
-  data = data.substr(2);  // Get to the first block
+  data = wpi::substr(data, 2);  // Get to the first block
   for (;;) {
     if (data.size() < 4) {
       return false;  // EOF
@@ -89,7 +90,7 @@ bool GetJpegSize(std::string_view data, int* width, int* height) {
       return true;
     }
     // Go to the next block
-    data = data.substr(bytes[2] * 256 + bytes[3] + 2);
+    data = wpi::substr(data, bytes[2] * 256 + bytes[3] + 2);
   }
 }
 
@@ -102,7 +103,7 @@ bool JpegNeedsDHT(const char* data, size_t* size, size_t* locSOF) {
   *locSOF = *size;
 
   // Search until SOS for DHT tag
-  sdata = sdata.substr(2);  // Get to the first block
+  sdata = wpi::substr(sdata, 2);  // Get to the first block
   for (;;) {
     if (sdata.size() < 4) {
       return false;  // EOF
@@ -121,7 +122,7 @@ bool JpegNeedsDHT(const char* data, size_t* size, size_t* locSOF) {
       *locSOF = sdata.data() - data;  // SOF
     }
     // Go to the next block
-    sdata = sdata.substr(bytes[2] * 256 + bytes[3] + 2);
+    sdata = wpi::substr(sdata, bytes[2] * 256 + bytes[3] + 2);
   }
 
   // Only add DHT if we also found SOF (insertion point)

cscore/src/main/native/cpp/MjpegServerImpl.cpp

@@ -797,14 +797,14 @@ void MjpegServerImpl::ConnThread::ProcessRequest() {
   // compatibility, others are for Axis camera compatibility.
   if ((pos = req.find("POST /stream")) != std::string_view::npos) {
     kind = kStream;
-    parameters = req.substr(req.find('?', pos + 12)).substr(1);
+    parameters = wpi::substr(wpi::substr(req, req.find('?', pos + 12)), 1);
   } else if ((pos = req.find("GET /?action=stream")) !=
              std::string_view::npos) {
     kind = kStream;
-    parameters = req.substr(req.find('&', pos + 19)).substr(1);
+    parameters = wpi::substr(wpi::substr(req, req.find('&', pos + 19)), 1);
   } else if ((pos = req.find("GET /stream.mjpg")) != std::string_view::npos) {
     kind = kStream;
-    parameters = req.substr(req.find('?', pos + 16)).substr(1);
+    parameters = wpi::substr(wpi::substr(req, req.find('?', pos + 16)), 1);
   } else if (req.find("GET /settings") != std::string_view::npos &&
              req.find(".json") != std::string_view::npos) {
     kind = kGetSettings;
@@ -820,7 +820,7 @@ void MjpegServerImpl::ConnThread::ProcessRequest() {
   } else if ((pos = req.find("GET /?action=command")) !=
              std::string_view::npos) {
     kind = kCommand;
-    parameters = req.substr(req.find('&', pos + 20)).substr(1);
+    parameters = wpi::substr(wpi::substr(req, req.find('&', pos + 20)), 1);
   } else if (req.find("GET / ") != std::string_view::npos || req == "GET /\n") {
     kind = kRootPage;
   } else {
@@ -833,7 +833,7 @@ void MjpegServerImpl::ConnThread::ProcessRequest() {
   pos = parameters.find_first_not_of(
       "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_"
       "-=&1234567890%./");
-  parameters = parameters.substr(0, pos);
+  parameters = wpi::substr(parameters, 0, pos);
   SDEBUG("command parameters: \"{}\"", parameters);
 
   // Read the rest of the HTTP request.

cscore/src/main/native/linux/UsbCameraImpl.cpp

@@ -107,7 +107,7 @@ static __u32 FromPixelFormat(VideoMode::PixelFormat pixelFormat) {
 
 static bool IsPercentageProperty(std::string_view name) {
   if (wpi::starts_with(name, "raw_")) {
-    name = name.substr(4);
+    name = wpi::substr(name, 4);
   }
   return name == "brightness" || name == "contrast" || name == "saturation" ||
          name == "hue" || name == "sharpness" || name == "gain" ||
@@ -181,13 +181,13 @@ static bool GetVendorProduct(int dev, int* vendor, int* product) {
   }
   std::string_view readStr{readBuf};
   if (auto v = wpi::parse_integer<int>(
-          readStr.substr(readStr.find('v')).substr(1, 4), 16)) {
+          wpi::substr(wpi::substr(readStr, readStr.find('v')), 1, 4), 16)) {
     *vendor = v.value();
   } else {
     return false;
   }
   if (auto v = wpi::parse_integer<int>(
-          readStr.substr(readStr.find('p')).substr(1, 4), 16)) {
+          wpi::substr(wpi::substr(readStr, readStr.find('p')), 1, 4), 16)) {
     *product = v.value();
   } else {
     return false;
@@ -236,8 +236,8 @@ static bool GetDescriptionIoctl(const char* cpath, std::string* desc) {
   std::optional<int> vendor;
   std::optional<int> product;
   if (wpi::starts_with(card, "UVC Camera (") &&
-      (vendor = wpi::parse_integer<int>(card.substr(12, 4), 16)) &&
-      (product = wpi::parse_integer<int>(card.substr(17, 4), 16))) {
+      (vendor = wpi::parse_integer<int>(wpi::substr(card, 12, 4), 16)) &&
+      (product = wpi::parse_integer<int>(wpi::substr(card, 17, 4), 16))) {
     std::string card2 = GetUsbNameFromId(vendor.value(), product.value());
     if (!card2.empty()) {
       *desc = std::move(card2);
@@ -283,7 +283,7 @@ static int GetDeviceNum(const char* cpath) {
   if (!wpi::starts_with(fn, "video")) {
     return -1;
   }
-  if (auto dev = wpi::parse_integer<int>(fn.substr(5), 10)) {
+  if (auto dev = wpi::parse_integer<int>(wpi::substr(fn, 5), 10)) {
     return dev.value();
   }
   return -1;
@@ -1635,7 +1635,8 @@ std::vector<UsbCameraInfo> EnumerateUsbCameras(CS_Status* status) {
       }
 
       unsigned int dev = 0;
-      if (auto v = wpi::parse_integer<unsigned int>(fname.substr(5), 10)) {
+      if (auto v =
+              wpi::parse_integer<unsigned int>(wpi::substr(fname, 5), 10)) {
         dev = v.value();
       } else {
         continue;
@@ -1686,7 +1687,8 @@ std::vector<UsbCameraInfo> EnumerateUsbCameras(CS_Status* status) {
             std::string fname = fs::path{target}.filename();
             std::optional<unsigned int> dev;
             if (wpi::starts_with(fname, "video") &&
-                (dev = wpi::parse_integer<unsigned int>(fname.substr(5), 10)) &&
+                (dev = wpi::parse_integer<unsigned int>(wpi::substr(fname, 5),
+                                                        10)) &&
                 dev.value() < retval.size()) {
               retval[dev.value()].otherPaths.emplace_back(path.str());
             }

cscore/src/main/native/linux/UsbCameraProperty.cpp

@@ -6,6 +6,7 @@
 
 #include <fmt/format.h>
 #include <wpi/SmallString.h>
+#include <wpi/StringExtras.h>
 
 #include "UsbUtil.h"
 
@@ -93,7 +94,7 @@ static int GetStringCtrlIoctl(int fd, int id, int maximum, std::string* value) {
 
 static int SetStringCtrlIoctl(int fd, int id, int maximum,
                               std::string_view value) {
-  wpi::SmallString<64> str{value.substr(0, maximum)};
+  wpi::SmallString<64> str{wpi::substr(value, 0, maximum)};
 
   struct v4l2_ext_control ctrl;
   struct v4l2_ext_controls ctrls;

cscore/src/main/native/linux/UsbUtil.cpp

@@ -49,7 +49,7 @@ static std::string GetUsbNameFromFile(int vendor, int product) {
     // look for vendor at start of line
     if (wpi::starts_with(line, vendorStr)) {
       foundVendor = true;
-      buf += wpi::trim(line.substr(5));
+      buf += wpi::trim(wpi::substr(line, 5));
       buf += ' ';
       continue;
     }
@@ -62,8 +62,8 @@ static std::string GetUsbNameFromFile(int vendor, int product) {
       }
 
       // look for product
-      if (wpi::starts_with(line.substr(1), productStr)) {
-        buf += wpi::trim(line.substr(6));
+      if (wpi::starts_with(wpi::substr(line, 1), productStr)) {
+        buf += wpi::trim(wpi::substr(line, 6));
         return buf;
       }
     }

cscore/src/main/native/windows/UsbCameraImpl.cpp

@@ -14,7 +14,6 @@
 #include <windowsx.h>
 
 #include <cmath>
-#include <codecvt>
 #include <memory>
 #include <string>
 #include <vector>
@@ -25,7 +24,9 @@
 #include <opencv2/core/core.hpp>
 #include <opencv2/highgui/highgui.hpp>
 #include <opencv2/imgproc/imgproc.hpp>
+#include <wpi/ConvertUTF.h>
 #include <wpi/MemAlloc.h>
+#include <wpi/SmallString.h>
 #include <wpi/StringExtras.h>
 #include <wpi/timestamp.h>
 
@@ -72,8 +73,9 @@ UsbCameraImpl::UsbCameraImpl(std::string_view name, wpi::Logger& logger,
                              Notifier& notifier, Telemetry& telemetry,
                              std::string_view path)
     : SourceImpl{name, logger, notifier, telemetry}, m_path{path} {
-  std::wstring_convert<std::codecvt_utf8<wchar_t>> utf8_conv;
-  m_widePath = utf8_conv.from_bytes(m_path.c_str());
+  wpi::SmallVector<wchar_t, 128> wideStorage;
+  wpi::sys::windows::UTF8ToUTF16(m_path, wideStorage);
+  m_widePath = std::wstring{wideStorage.data(), wideStorage.size()};
   m_deviceId = -1;
   StartMessagePump();
 }
@@ -227,7 +229,7 @@ void UsbCameraImpl::PostRequestNewFrame() {
 
 bool UsbCameraImpl::CheckDeviceChange(WPARAM wParam, DEV_BROADCAST_HDR* pHdr,
                                       bool* connected) {
-  DEV_BROADCAST_DEVICEINTERFACE* pDi = NULL;
+  DEV_BROADCAST_DEVICEINTERFACE_A* pDi = NULL;
 
   *connected = false;
 
@@ -240,9 +242,9 @@ bool UsbCameraImpl::CheckDeviceChange(WPARAM wParam, DEV_BROADCAST_HDR* pHdr,
 
   // Compare the device name with the symbolic link.
 
-  pDi = reinterpret_cast<DEV_BROADCAST_DEVICEINTERFACE*>(pHdr);
+  pDi = reinterpret_cast<DEV_BROADCAST_DEVICEINTERFACE_A*>(pHdr);
 
-  if (_stricmp(m_path.c_str(), pDi->dbcc_name) == 0) {
+  if (wpi::equals_lower(m_path, pDi->dbcc_name)) {
     if (wParam == DBT_DEVICEARRIVAL) {
       *connected = true;
       return true;
@@ -269,7 +271,7 @@ void UsbCameraImpl::DeviceDisconnect() {
 
 static bool IsPercentageProperty(std::string_view name) {
   if (wpi::starts_with(name, "raw_"))
-    name = name.substr(4);
+    name = wpi::substr(name, 4);
   return name == "Brightness" || name == "Contrast" || name == "Saturation" ||
          name == "Hue" || name == "Sharpness" || name == "Gain" ||
          name == "Exposure";
@@ -411,11 +413,12 @@ LRESULT UsbCameraImpl::PumpMain(HWND hwnd, UINT uiMsg, WPARAM wParam,
           // If has device ID, use the device ID from the event
           // because of windows bug
           auto&& device = devices[m_deviceId];
-          DEV_BROADCAST_DEVICEINTERFACE* pDi =
-              reinterpret_cast<DEV_BROADCAST_DEVICEINTERFACE*>(parameter);
+          DEV_BROADCAST_DEVICEINTERFACE_A* pDi =
+              reinterpret_cast<DEV_BROADCAST_DEVICEINTERFACE_A*>(parameter);
           m_path = pDi->dbcc_name;
-          std::wstring_convert<std::codecvt_utf8<wchar_t>> utf8_conv;
-          m_widePath = utf8_conv.from_bytes(m_path.c_str());
+          wpi::SmallVector<wchar_t, 128> wideStorage;
+          wpi::sys::windows::UTF8ToUTF16(m_path, wideStorage);
+          m_widePath = std::wstring{wideStorage.data(), wideStorage.size()};
         } else {
           // This device not found
           break;
@@ -482,9 +485,16 @@ bool UsbCameraImpl::DeviceConnect() {
   const wchar_t* path = m_widePath.c_str();
   m_mediaSource = CreateVideoCaptureDevice(path);
 
-  if (!m_mediaSource)
+  if (!m_mediaSource) {
     return false;
-  m_imageCallback = CreateSourceReaderCB(shared_from_this(), m_mode);
+  }
+  auto weakThis = weak_from_this();
+  auto sharedThis = weakThis.lock();
+  if (sharedThis) {
+    m_imageCallback = CreateSourceReaderCB(sharedThis, m_mode);
+  } else {
+    return false;
+  }
 
   m_sourceReader =
       CreateSourceReader(m_mediaSource.Get(), m_imageCallback.Get());
@@ -747,8 +757,9 @@ CS_StatusValue UsbCameraImpl::DeviceProcessCommand(
     {
       std::scoped_lock lock(m_mutex);
       m_path = msg->dataStr;
-      std::wstring_convert<std::codecvt_utf8<wchar_t>> utf8_conv;
-      m_widePath = utf8_conv.from_bytes(m_path.c_str());
+      wpi::SmallVector<wchar_t, 128> wideStorage;
+      wpi::sys::windows::UTF8ToUTF16(m_path, wideStorage);
+      m_widePath = std::wstring{wideStorage.data(), wideStorage.size()};
     }
     DeviceDisconnect();
     DeviceConnect();
@@ -1048,7 +1059,8 @@ std::vector<UsbCameraInfo> EnumerateUsbCameras(CS_Status* status) {
   // Ensure we are initialized by grabbing the message pump
   // GetMessagePump();
 
-  std::wstring_convert<std::codecvt_utf8<wchar_t>> utf8_conv;
+  wpi::SmallString<128> storage;
+  WCHAR buf[512];
   ComPtr<IMFAttributes> pAttributes;
   IMFActivate** ppDevices = nullptr;
   UINT32 count = 0;
@@ -1080,14 +1092,19 @@ std::vector<UsbCameraInfo> EnumerateUsbCameras(CS_Status* status) {
   for (UINT32 i = 0; i < count; i++) {
     UsbCameraInfo info;
     info.dev = i;
-    WCHAR buf[512];
+
+    UINT32 characters = 0;
     ppDevices[i]->GetString(MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME, buf,
-                            sizeof(buf) / sizeof(WCHAR), NULL);
-    info.name = utf8_conv.to_bytes(buf);
+                            sizeof(buf) / sizeof(WCHAR), &characters);
+    storage.clear();
+    wpi::sys::windows::UTF16ToUTF8(buf, characters, storage);
+    info.name = storage.string();
     ppDevices[i]->GetString(
         MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK, buf,
-        sizeof(buf) / sizeof(WCHAR), NULL);
-    info.path = utf8_conv.to_bytes(buf);
+        sizeof(buf) / sizeof(WCHAR), &characters);
+    storage.clear();
+    wpi::sys::windows::UTF16ToUTF8(buf, characters, storage);
+    info.path = storage.string();
 
     // Try to parse path from symbolic link
     ParseVidAndPid(info.path, &info.productId, &info.vendorId);

cscore/src/main/native/windows/WindowsMessagePump.cpp

@@ -89,7 +89,7 @@ static std::shared_ptr<ClassHolder> GetClassHolder() {
 WindowsMessagePump::WindowsMessagePump(
     std::function<LRESULT(HWND, UINT, WPARAM, LPARAM)> callback) {
   m_callback = callback;
-  auto handle = CreateEvent(NULL, true, false, NULL);
+  auto handle = CreateEventA(NULL, true, false, NULL);
   m_mainThread = std::thread([=] { ThreadMain(handle); });
   auto waitResult = WaitForSingleObject(handle, 1000);
   if (waitResult == WAIT_OBJECT_0) {
@@ -98,7 +98,7 @@ WindowsMessagePump::WindowsMessagePump(
 }
 
 WindowsMessagePump::~WindowsMessagePump() {
-  auto res = SendMessage(hwnd, WM_CLOSE, NULL, NULL);
+  auto res = SendMessageA(hwnd, WM_CLOSE, NULL, NULL);
   if (m_mainThread.joinable())
     m_mainThread.join();
 }
@@ -110,28 +110,28 @@ void WindowsMessagePump::ThreadMain(HANDLE eventHandle) {
   MFStartup(MF_VERSION);
 
   auto classHolder = GetClassHolder();
-  hwnd = CreateWindowEx(0, classHolder->class_name, "dummy_name", 0, 0, 0, 0, 0,
-                        HWND_MESSAGE, NULL, NULL, this);
+  hwnd = CreateWindowExA(0, classHolder->class_name, "dummy_name", 0, 0, 0, 0,
+                         0, HWND_MESSAGE, NULL, NULL, this);
 
   // Register for device notifications
   HDEVNOTIFY g_hdevnotify = NULL;
   HDEVNOTIFY g_hdevnotify2 = NULL;
 
-  DEV_BROADCAST_DEVICEINTERFACE di = {0};
+  DEV_BROADCAST_DEVICEINTERFACE_A di = {0};
   di.dbcc_size = sizeof(di);
   di.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
   di.dbcc_classguid = KSCATEGORY_CAPTURE;
 
   g_hdevnotify =
-      RegisterDeviceNotification(hwnd, &di, DEVICE_NOTIFY_WINDOW_HANDLE);
+      RegisterDeviceNotificationA(hwnd, &di, DEVICE_NOTIFY_WINDOW_HANDLE);
 
-  DEV_BROADCAST_DEVICEINTERFACE di2 = {0};
+  DEV_BROADCAST_DEVICEINTERFACE_A di2 = {0};
   di2.dbcc_size = sizeof(di2);
   di2.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
   di2.dbcc_classguid = KSCATEGORY_VIDEO_CAMERA;
 
   g_hdevnotify2 =
-      RegisterDeviceNotification(hwnd, &di2, DEVICE_NOTIFY_WINDOW_HANDLE);
+      RegisterDeviceNotificationA(hwnd, &di2, DEVICE_NOTIFY_WINDOW_HANDLE);
 
   SetEvent(eventHandle);
 

datalogtool/.styleguide

@@ -0,0 +1,29 @@
+cppHeaderFileInclude {
+  \.h$
+  \.inc$
+  \.inl$
+}
+
+cppSrcFileInclude {
+  \.cpp$
+}
+
+generatedFileExclude {
+  src/main/native/resources/
+  src/main/native/win/datalogtool.ico
+  src/main/native/mac/datalogtool.icns
+}
+
+repoRootNameOverride {
+  datalogtool
+}
+
+includeOtherLibs {
+  ^GLFW
+  ^fmt/
+  ^glass/
+  ^imgui
+  ^portable-file-dialog
+  ^wpi/
+  ^wpigui
+}

datalogtool/CMakeLists.txt

@@ -0,0 +1,29 @@
+project(datalogtool)
+
+include(CompileWarnings)
+include(GenResources)
+include(LinkMacOSGUI)
+
+configure_file(src/main/generate/WPILibVersion.cpp.in WPILibVersion.cpp)
+GENERATE_RESOURCES(src/main/native/resources generated/main/cpp DLT dlt datalogtool_resources_src)
+
+file(GLOB datalogtool_src src/main/native/cpp/*.cpp ${CMAKE_CURRENT_BINARY_DIR}/WPILibVersion.cpp)
+
+if (WIN32)
+    set(datalogtool_rc src/main/native/win/datalogtool.rc)
+elseif(APPLE)
+    set(MACOSX_BUNDLE_ICON_FILE datalogtool.icns)
+    set(APP_ICON_MACOSX src/main/native/mac/datalogtool.icns)
+    set_source_files_properties(${APP_ICON_MACOSX} PROPERTIES MACOSX_PACKAGE_LOCATION "Resources")
+endif()
+
+add_executable(datalogtool ${datalogtool_src} ${datalogtool_resources_src} ${datalogtool_rc} ${APP_ICON_MACOSX})
+wpilib_link_macos_gui(datalogtool)
+target_link_libraries(datalogtool libglass ${LIBSSH_LIBRARIES})
+target_include_directories(datalogtool PRIVATE ${LIBSSH_INCLUDE_DIRS})
+
+if (WIN32)
+    set_target_properties(datalogtool PROPERTIES WIN32_EXECUTABLE YES)
+elseif(APPLE)
+    set_target_properties(datalogtool PROPERTIES MACOSX_BUNDLE YES OUTPUT_NAME "datalogTool")
+endif()

datalogtool/Info.plist

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleName</key>
+	<string>datalogTool</string>
+	<key>CFBundleExecutable</key>
+	<string>datalogtool</string>
+	<key>CFBundleDisplayName</key>
+	<string>datalogTool</string>
+	<key>CFBundleIdentifier</key>
+	<string>edu.wpi.first.tools.datalogTool</string>
+	<key>CFBundleIconFile</key>
+	<string>datalogtool.icns</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleSupportedPlatforms</key>
+	<array>
+		<string>MacOSX</string>
+	</array>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleShortVersionString</key>
+	<string>2021</string>
+	<key>CFBundleVersion</key>
+	<string>2021</string>
+	<key>LSMinimumSystemVersion</key>
+	<string>10.11</string>
+	<key>NSHighResolutionCapable</key>
+	<true/>
+</dict>
+</plist>

datalogtool/build.gradle

@@ -0,0 +1,134 @@
+import org.gradle.internal.os.OperatingSystem
+
+if (!project.hasProperty('onlylinuxathena') && !project.hasProperty('onlylinuxraspbian') && !project.hasProperty('onlylinuxaarch64bionic')) {
+
+    description = "roboRIO Team Number Setter"
+
+    apply plugin: 'cpp'
+    apply plugin: 'c'
+    apply plugin: 'google-test-test-suite'
+    apply plugin: 'visual-studio'
+    apply plugin: 'edu.wpi.first.NativeUtils'
+
+    if (OperatingSystem.current().isWindows()) {
+        apply plugin: 'windows-resources'
+    }
+
+    ext {
+        nativeName = 'datalogtool'
+    }
+
+    apply from: "${rootDir}/shared/resources.gradle"
+    apply from: "${rootDir}/shared/config.gradle"
+
+    def wpilibVersionFileInput = file("src/main/generate/WPILibVersion.cpp.in")
+    def wpilibVersionFileOutput = file("$buildDir/generated/main/cpp/WPILibVersion.cpp")
+
+    nativeUtils {
+        nativeDependencyContainer {
+            libssh(getNativeDependencyTypeClass('WPIStaticMavenDependency')) {
+                groupId = "edu.wpi.first.thirdparty.frc2022"
+                artifactId = "libssh"
+                headerClassifier = "headers"
+                sourceClassifier = "sources"
+                ext = "zip"
+                version = '0.95-1'
+                targetPlatforms.addAll(nativeUtils.wpi.platforms.desktopPlatforms)
+            }
+        }
+    }
+
+    task generateCppVersion() {
+        description = 'Generates the wpilib version class'
+        group = 'WPILib'
+
+        outputs.file wpilibVersionFileOutput
+        inputs.file wpilibVersionFileInput
+
+        if (wpilibVersioning.releaseMode) {
+            outputs.upToDateWhen { false }
+        }
+
+        // We follow a simple set of checks to determine whether we should generate a new version file:
+        // 1. If the release type is not development, we generate a new version file
+        // 2. If there is no generated version number, we generate a new version file
+        // 3. If there is a generated build number, and the release type is development, then we will
+        //    only generate if the publish task is run.
+        doLast {
+            def version = wpilibVersioning.version.get()
+            println "Writing version ${version} to $wpilibVersionFileOutput"
+
+            if (wpilibVersionFileOutput.exists()) {
+                wpilibVersionFileOutput.delete()
+            }
+            def read = wpilibVersionFileInput.text.replace('${wpilib_version}', version)
+            wpilibVersionFileOutput.write(read)
+        }
+    }
+
+    gradle.taskGraph.addTaskExecutionGraphListener { graph ->
+        def willPublish = graph.hasTask(publish)
+        if (willPublish) {
+            generateCppVersion.outputs.upToDateWhen { false }
+        }
+    }
+
+    def generateTask = createGenerateResourcesTask('main', 'DLT', 'dlt', project)
+
+    project(':').libraryBuild.dependsOn build
+    tasks.withType(CppCompile) {
+        dependsOn generateTask
+        dependsOn generateCppVersion
+    }
+
+    model {
+        components {
+            // By default, a development executable will be generated. This is to help the case of
+            // testing specific functionality of the library.
+            "${nativeName}"(NativeExecutableSpec) {
+                baseName = 'datalogtool'
+                sources {
+                    cpp {
+                        source {
+                            srcDirs 'src/main/native/cpp', "$buildDir/generated/main/cpp"
+                            include '**/*.cpp'
+                        }
+                        exportedHeaders {
+                            srcDirs 'src/main/native/include'
+                        }
+                    }
+                    if (OperatingSystem.current().isWindows()) {
+                        rc {
+                            source {
+                                srcDirs 'src/main/native/win'
+                                include '*.rc'
+                            }
+                        }
+                    }
+                }
+                binaries.all {
+                    if (it.targetPlatform.name == nativeUtils.wpi.platforms.roborio || it.targetPlatform.name == nativeUtils.wpi.platforms.raspbian || it.targetPlatform.name == nativeUtils.wpi.platforms.aarch64bionic) {
+                        it.buildable = false
+                        return
+                    }
+                    it.cppCompiler.define("LIBSSH_STATIC")
+                    lib project: ':glass', library: 'glass', linkage: 'static'
+                    lib project: ':wpiutil', library: 'wpiutil', linkage: 'static'
+                    lib project: ':wpigui', library: 'wpigui', linkage: 'static'
+                    nativeUtils.useRequiredLibrary(it, 'imgui_static', 'libssh')
+                    if (it.targetPlatform.operatingSystem.isWindows()) {
+                        it.linker.args << 'Gdi32.lib' << 'Shell32.lib' << 'd3d11.lib' << 'd3dcompiler.lib'
+                        it.linker.args << 'ws2_32.lib' << 'advapi32.lib' << 'crypt32.lib' << 'user32.lib'
+                    } else if (it.targetPlatform.operatingSystem.isMacOsX()) {
+                        it.linker.args << '-framework' << 'Metal' << '-framework' << 'MetalKit' << '-framework' << 'Cocoa' << '-framework' << 'IOKit' << '-framework' << 'CoreFoundation' << '-framework' << 'CoreVideo' << '-framework' << 'QuartzCore'
+                        it.linker.args << '-framework' << 'Kerberos'
+                    } else {
+                        it.linker.args << '-lX11'
+                    }
+                }
+            }
+        }
+    }
+
+    apply from: 'publish.gradle'
+}

datalogtool/publish.gradle

@@ -0,0 +1,107 @@
+apply plugin: 'maven-publish'
+
+def baseArtifactId = 'DataLogTool'
+def artifactGroupId = 'edu.wpi.first.tools'
+def zipBaseName = '_GROUP_edu_wpi_first_tools_ID_DataLogTool_CLS'
+
+def outputsFolder = file("$project.buildDir/outputs")
+
+model {
+    tasks {
+        // Create the run task.
+        $.components.datalogtool.binaries.each { bin ->
+            if (bin.buildable && bin.name.toLowerCase().contains("debug")) {
+                Task run = project.tasks.create("run", Exec) {
+                    commandLine bin.tasks.install.runScriptFile.get().asFile.toString()
+                }
+                run.dependsOn bin.tasks.install
+            }
+        }
+    }
+    publishing {
+        def dataLogToolTaskList = []
+        $.components.each { component ->
+            component.binaries.each { binary ->
+                if (binary in NativeExecutableBinarySpec && binary.component.name.contains("datalogtool")) {
+                    if (binary.buildable && binary.name.contains("Release")) {
+                        // We are now in the binary that we want.
+                        // This is the default application path for the ZIP task.
+                        def applicationPath = binary.executable.file
+                        def icon = file("$project.projectDir/src/main/native/mac/datalogtool.icns")
+
+                        // Create the macOS bundle.
+                        def bundleTask = project.tasks.create("bundleDataLogToolOsxApp", Copy) {
+                            description("Creates a macOS application bundle for DataLogTool")
+                            from(file("$project.projectDir/Info.plist"))
+                            into(file("$project.buildDir/outputs/bundles/DataLogTool.app/Contents"))
+                            into("MacOS") { with copySpec { from binary.executable.file } }
+                            into("Resources") { with copySpec { from icon } }
+
+                            doLast {
+                                if (project.hasProperty("developerID")) {
+                                    // Get path to binary.
+                                    exec {
+                                        workingDir rootDir
+                                        def args = [
+                                            "sh",
+                                            "-c",
+                                            "codesign --force --strict --deep " +
+                                            "--timestamp --options=runtime " +
+                                            "--verbose -s ${project.findProperty("developerID")} " +
+                                            "$project.buildDir/outputs/bundles/DataLogTool.app/"
+                                        ]
+                                        commandLine args
+                                    }
+                                }
+                            }
+                        }
+
+                        // Reset the application path if we are creating a bundle.
+                        if (binary.targetPlatform.operatingSystem.isMacOsX()) {
+                            applicationPath = file("$project.buildDir/outputs/bundles")
+                            project.build.dependsOn bundleTask
+                        }
+
+                        // Create the ZIP.
+                        def task = project.tasks.create("copyDataLogToolExecutable", Zip) {
+                            description("Copies the DataLogTool executable to the outputs directory.")
+                            destinationDirectory = outputsFolder
+
+                            archiveBaseName = '_M_' + zipBaseName
+                            duplicatesStrategy = 'exclude'
+                            classifier = nativeUtils.getPublishClassifier(binary)
+
+                            from(licenseFile) {
+                                into '/'
+                            }
+
+                            from(applicationPath)
+                            into(nativeUtils.getPlatformPath(binary))
+                        }
+
+                        if (binary.targetPlatform.operatingSystem.isMacOsX()) {
+                            bundleTask.dependsOn binary.tasks.link
+                            task.dependsOn(bundleTask)
+                        }
+
+                        task.dependsOn binary.tasks.link
+                        dataLogToolTaskList.add(task)
+                        project.build.dependsOn task
+                        project.artifacts { task }
+                        addTaskToCopyAllOutputs(task)
+                    }
+                }
+            }
+        }
+
+        publications {
+            datalogtool(MavenPublication) {
+                dataLogToolTaskList.each { artifact it }
+
+                artifactId = baseArtifactId
+                groupId = artifactGroupId
+                version wpilibVersioning.version.get()
+            }
+        }
+    }
+}

datalogtool/src/main/generate/WPILibVersion.cpp.in

@@ -0,0 +1,7 @@
+/*
+ * Autogenerated file! Do not manually edit this file. This version is regenerated
+ * any time the publish task is run, or when this file is deleted.
+ */
+const char* GetWPILibVersion() {
+  return "${wpilib_version}";
+}

datalogtool/src/main/native/cpp/App.cpp

@@ -0,0 +1,156 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "App.h"
+
+#include <libssh/libssh.h>
+
+#include <memory>
+#include <string_view>
+
+#define IMGUI_DEFINE_MATH_OPERATORS
+
+#include <glass/Context.h>
+#include <glass/MainMenuBar.h>
+#include <glass/Storage.h>
+#include <imgui.h>
+#include <imgui_internal.h>
+#include <wpigui.h>
+
+#include "Downloader.h"
+#include "Exporter.h"
+
+namespace gui = wpi::gui;
+
+const char* GetWPILibVersion();
+
+namespace dlt {
+std::string_view GetResource_dlt_16_png();
+std::string_view GetResource_dlt_32_png();
+std::string_view GetResource_dlt_48_png();
+std::string_view GetResource_dlt_64_png();
+std::string_view GetResource_dlt_128_png();
+std::string_view GetResource_dlt_256_png();
+std::string_view GetResource_dlt_512_png();
+}  // namespace dlt
+
+bool gShutdown = false;
+
+static std::unique_ptr<Downloader> gDownloader;
+static bool* gDownloadVisible;
+static float gDefaultScale = 1.0;
+
+void SetNextWindowPos(const ImVec2& pos, ImGuiCond cond, const ImVec2& pivot) {
+  if ((cond & ImGuiCond_FirstUseEver) != 0) {
+    ImGui::SetNextWindowPos(pos * gDefaultScale, cond, pivot);
+  } else {
+    ImGui::SetNextWindowPos(pos, cond, pivot);
+  }
+}
+
+void SetNextWindowSize(const ImVec2& size, ImGuiCond cond) {
+  if ((cond & ImGuiCond_FirstUseEver) != 0) {
+    ImGui::SetNextWindowSize(size * gDefaultScale, cond);
+  } else {
+    ImGui::SetNextWindowPos(size, cond);
+  }
+}
+
+static void DisplayDownload() {
+  if (!*gDownloadVisible) {
+    return;
+  }
+  SetNextWindowPos(ImVec2{0, 250}, ImGuiCond_FirstUseEver);
+  SetNextWindowSize(ImVec2{375, 260}, ImGuiCond_FirstUseEver);
+  if (ImGui::Begin("Download", gDownloadVisible)) {
+    if (!gDownloader) {
+      gDownloader = std::make_unique<Downloader>(
+          glass::GetStorageRoot().GetChild("download"));
+    }
+    gDownloader->Display();
+  }
+  ImGui::End();
+}
+
+static void DisplayMainMenu() {
+  ImGui::BeginMainMenuBar();
+
+  static glass::MainMenuBar mainMenu;
+  mainMenu.WorkspaceMenu();
+  gui::EmitViewMenu();
+
+  if (ImGui::BeginMenu("Window")) {
+    ImGui::MenuItem("Download", nullptr, gDownloadVisible);
+    ImGui::EndMenu();
+  }
+
+  bool about = false;
+  if (ImGui::BeginMenu("Info")) {
+    if (ImGui::MenuItem("About")) {
+      about = true;
+    }
+    ImGui::EndMenu();
+  }
+
+  ImGui::EndMainMenuBar();
+
+  if (about) {
+    ImGui::OpenPopup("About");
+  }
+  if (ImGui::BeginPopupModal("About")) {
+    ImGui::Text("Datalog Tool");
+    ImGui::Separator();
+    ImGui::Text("v%s", GetWPILibVersion());
+    ImGui::Separator();
+    ImGui::Text("Save location: %s", glass::GetStorageDir().c_str());
+    if (ImGui::Button("Close")) {
+      ImGui::CloseCurrentPopup();
+    }
+    ImGui::EndPopup();
+  }
+}
+
+static void DisplayGui() {
+  DisplayMainMenu();
+  DisplayInputFiles();
+  DisplayEntries();
+  DisplayOutput(glass::GetStorageRoot().GetChild("output"));
+  DisplayDownload();
+}
+
+void Application(std::string_view saveDir) {
+  ssh_init();
+
+  gui::CreateContext();
+  glass::CreateContext();
+
+  // Add icons
+  gui::AddIcon(dlt::GetResource_dlt_16_png());
+  gui::AddIcon(dlt::GetResource_dlt_32_png());
+  gui::AddIcon(dlt::GetResource_dlt_48_png());
+  gui::AddIcon(dlt::GetResource_dlt_64_png());
+  gui::AddIcon(dlt::GetResource_dlt_128_png());
+  gui::AddIcon(dlt::GetResource_dlt_256_png());
+  gui::AddIcon(dlt::GetResource_dlt_512_png());
+
+  glass::SetStorageName("datalogtool");
+  glass::SetStorageDir(saveDir.empty() ? gui::GetPlatformSaveFileDir()
+                                       : saveDir);
+
+  gui::AddWindowScaler([](float scale) { gDefaultScale = scale; });
+  gui::AddLateExecute(DisplayGui);
+  gui::Initialize("Datalog Tool", 925, 510);
+
+  gDownloadVisible =
+      &glass::GetStorageRoot().GetChild("download").GetBool("visible", true);
+
+  gui::Main();
+
+  gShutdown = true;
+  glass::DestroyContext();
+  gui::DestroyContext();
+
+  gDownloader.reset();
+  ssh_finalize();
+}

datalogtool/src/main/native/cpp/App.h

@@ -0,0 +1,11 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include <imgui.h>
+
+void SetNextWindowPos(const ImVec2& pos, ImGuiCond cond = 0,
+                      const ImVec2& pivot = ImVec2(0, 0));
+void SetNextWindowSize(const ImVec2& size, ImGuiCond cond = 0);

datalogtool/src/main/native/cpp/DataLogThread.cpp

@@ -0,0 +1,72 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "DataLogThread.h"
+
+#include <fmt/format.h>
+
+DataLogThread::~DataLogThread() {
+  if (m_thread.joinable()) {
+    m_active = false;
+    m_thread.join();
+  }
+}
+
+void DataLogThread::ReadMain() {
+  for (auto record : m_reader) {
+    if (!m_active) {
+      break;
+    }
+    ++m_numRecords;
+    if (record.IsStart()) {
+      wpi::log::StartRecordData data;
+      if (record.GetStartData(&data)) {
+        std::scoped_lock lock{m_mutex};
+        if (m_entries.find(data.entry) != m_entries.end()) {
+          fmt::print("...DUPLICATE entry ID, overriding\n");
+        }
+        m_entries[data.entry] = data;
+        m_entryNames.emplace(data.name, data);
+        sigEntryAdded(data);
+      } else {
+        fmt::print("Start(INVALID)\n");
+      }
+    } else if (record.IsFinish()) {
+      int entry;
+      if (record.GetFinishEntry(&entry)) {
+        std::scoped_lock lock{m_mutex};
+        auto it = m_entries.find(entry);
+        if (it == m_entries.end()) {
+          fmt::print("...ID not found\n");
+        } else {
+          m_entries.erase(it);
+        }
+      } else {
+        fmt::print("Finish(INVALID)\n");
+      }
+    } else if (record.IsSetMetadata()) {
+      wpi::log::MetadataRecordData data;
+      if (record.GetSetMetadataData(&data)) {
+        std::scoped_lock lock{m_mutex};
+        auto it = m_entries.find(data.entry);
+        if (it == m_entries.end()) {
+          fmt::print("...ID not found\n");
+        } else {
+          it->second.metadata = data.metadata;
+          auto nameIt = m_entryNames.find(it->second.name);
+          if (nameIt != m_entryNames.end()) {
+            nameIt->second.metadata = data.metadata;
+          }
+        }
+      } else {
+        fmt::print("SetMetadata(INVALID)\n");
+      }
+    } else if (record.IsControl()) {
+      fmt::print("Unrecognized control record\n");
+    }
+  }
+
+  sigDone();
+  m_done = true;
+}

datalogtool/src/main/native/cpp/DataLogThread.h

@@ -0,0 +1,71 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include <atomic>
+#include <functional>
+#include <map>
+#include <string>
+#include <string_view>
+#include <thread>
+#include <utility>
+
+#include <wpi/DataLogReader.h>
+#include <wpi/DenseMap.h>
+#include <wpi/Signal.h>
+#include <wpi/mutex.h>
+
+class DataLogThread {
+ public:
+  explicit DataLogThread(wpi::log::DataLogReader reader)
+      : m_reader{std::move(reader)}, m_thread{[=] { ReadMain(); }} {}
+  ~DataLogThread();
+
+  bool IsDone() const { return m_done; }
+  std::string_view GetBufferIdentifier() const {
+    return m_reader.GetBufferIdentifier();
+  }
+  unsigned int GetNumRecords() const { return m_numRecords; }
+  unsigned int GetNumEntries() const {
+    std::scoped_lock lock{m_mutex};
+    return m_entryNames.size();
+  }
+
+  // Passes wpi::log::StartRecordData to func
+  template <typename T>
+  void ForEachEntryName(T&& func) {
+    std::scoped_lock lock{m_mutex};
+    for (auto&& kv : m_entryNames) {
+      func(kv.second);
+    }
+  }
+
+  wpi::log::StartRecordData GetEntry(std::string_view name) const {
+    std::scoped_lock lock{m_mutex};
+    auto it = m_entryNames.find(name);
+    if (it == m_entryNames.end()) {
+      return {};
+    }
+    return it->second;
+  }
+
+  const wpi::log::DataLogReader& GetReader() const { return m_reader; }
+
+  // note: these are called on separate thread
+  wpi::sig::Signal_mt<const wpi::log::StartRecordData&> sigEntryAdded;
+  wpi::sig::Signal_mt<> sigDone;
+
+ private:
+  void ReadMain();
+
+  wpi::log::DataLogReader m_reader;
+  mutable wpi::mutex m_mutex;
+  std::atomic_bool m_active{true};
+  std::atomic_bool m_done{false};
+  std::atomic<unsigned int> m_numRecords{0};
+  std::map<std::string, wpi::log::StartRecordData, std::less<>> m_entryNames;
+  wpi::DenseMap<int, wpi::log::StartRecordData> m_entries;
+  std::thread m_thread;
+};

datalogtool/src/main/native/cpp/Downloader.cpp

@@ -0,0 +1,393 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "Downloader.h"
+
+#include <libssh/sftp.h>
+
+#ifdef _WIN32
+#include <fcntl.h>
+#include <io.h>
+#else
+#include <sys/fcntl.h>
+#endif
+
+#include <algorithm>
+#include <filesystem>
+
+#include <fmt/format.h>
+#include <glass/Storage.h>
+#include <imgui.h>
+#include <imgui_stdlib.h>
+#include <portable-file-dialogs.h>
+#include <wpi/StringExtras.h>
+#include <wpi/fs.h>
+
+#include "Sftp.h"
+
+Downloader::Downloader(glass::Storage& storage)
+    : m_serverTeam{storage.GetString("serverTeam")},
+      m_remoteDir{storage.GetString("remoteDir", "/home/lvuser")},
+      m_username{storage.GetString("username", "lvuser")},
+      m_localDir{storage.GetString("localDir")},
+      m_deleteAfter{storage.GetBool("deleteAfter", true)},
+      m_thread{[this] { ThreadMain(); }} {}
+
+Downloader::~Downloader() {
+  {
+    std::scoped_lock lock{m_mutex};
+    m_state = kExit;
+  }
+  m_cv.notify_all();
+  m_thread.join();
+}
+
+void Downloader::DisplayConnect() {
+  // IP or Team Number text box
+  ImGui::SetNextItemWidth(ImGui::GetFontSize() * 12);
+  ImGui::InputText("Team Number / Address", &m_serverTeam);
+
+  // Username/password
+  ImGui::SetNextItemWidth(ImGui::GetFontSize() * 12);
+  ImGui::InputText("Username", &m_username);
+  ImGui::SetNextItemWidth(ImGui::GetFontSize() * 12);
+  ImGui::InputText("Password", &m_password, ImGuiInputTextFlags_Password);
+
+  // Connect button
+  if (ImGui::Button("Connect")) {
+    m_state = kConnecting;
+    m_cv.notify_all();
+  }
+}
+
+void Downloader::DisplayDisconnectButton() {
+  if (ImGui::Button("Disconnect")) {
+    m_state = kDisconnecting;
+    m_cv.notify_all();
+  }
+}
+
+void Downloader::DisplayRemoteDirSelector() {
+  ImGui::SameLine();
+  if (ImGui::Button("Refresh")) {
+    m_state = kGetFiles;
+    m_cv.notify_all();
+  }
+
+  // Remote directory text box
+  ImGui::SetNextItemWidth(ImGui::GetFontSize() * 20);
+  if (ImGui::InputText("Remote Dir", &m_remoteDir,
+                       ImGuiInputTextFlags_EnterReturnsTrue)) {
+    m_state = kGetFiles;
+    m_cv.notify_all();
+  }
+
+  // List directories
+  for (auto&& dir : m_dirList) {
+    if (ImGui::Selectable(dir.c_str())) {
+      if (dir == "..") {
+        if (wpi::ends_with(m_remoteDir, '/')) {
+          m_remoteDir.resize(m_remoteDir.size() - 1);
+        }
+        m_remoteDir = wpi::rsplit(m_remoteDir, '/').first;
+        if (m_remoteDir.empty()) {
+          m_remoteDir = "/";
+        }
+      } else {
+        if (!wpi::ends_with(m_remoteDir, '/')) {
+          m_remoteDir += '/';
+        }
+        m_remoteDir += dir;
+      }
+      m_state = kGetFiles;
+      m_cv.notify_all();
+    }
+  }
+}
+
+void Downloader::DisplayLocalDirSelector() {
+  // Local directory text / select button
+  if (ImGui::Button("Select Download Folder...")) {
+    m_localDirSelector =
+        std::make_unique<pfd::select_folder>("Select Download Folder");
+  }
+  ImGui::TextUnformatted(m_localDir.c_str());
+
+  // Delete after download (checkbox)
+  ImGui::Checkbox("Delete after download", &m_deleteAfter);
+
+  // Download button
+  if (!m_localDir.empty()) {
+    if (ImGui::Button("Download")) {
+      m_state = kDownload;
+      m_cv.notify_all();
+    }
+  }
+}
+
+size_t Downloader::DisplayFiles() {
+  // List of files (multi-select) (changes to progress bar for downloading)
+  size_t fileCount = 0;
+  if (ImGui::BeginTable(
+          "files", 3,
+          ImGuiTableFlags_Borders | ImGuiTableFlags_SizingStretchProp)) {
+    ImGui::TableSetupColumn("File");
+    ImGui::TableSetupColumn("Size");
+    ImGui::TableSetupColumn("Download");
+    ImGui::TableHeadersRow();
+    for (auto&& download : m_downloadList) {
+      if ((m_state == kDownload || m_state == kDownloadDone) &&
+          !download.enabled) {
+        continue;
+      }
+
+      ++fileCount;
+
+      ImGui::TableNextRow();
+      ImGui::TableNextColumn();
+      ImGui::TextUnformatted(download.name.c_str());
+      ImGui::TableNextColumn();
+      auto sizeText = fmt::format("{}", download.size);
+      ImGui::TextUnformatted(sizeText.c_str());
+      ImGui::TableNextColumn();
+      if (m_state == kDownload || m_state == kDownloadDone) {
+        if (!download.status.empty()) {
+          ImGui::TextUnformatted(download.status.c_str());
+        } else {
+          ImGui::ProgressBar(download.complete);
+        }
+      } else {
+        auto checkboxLabel = fmt::format("##{}", download.name);
+        ImGui::Checkbox(checkboxLabel.c_str(), &download.enabled);
+      }
+    }
+    ImGui::EndTable();
+  }
+
+  return fileCount;
+}
+
+void Downloader::Display() {
+  if (m_localDirSelector && m_localDirSelector->ready(0)) {
+    m_localDir = m_localDirSelector->result();
+    m_localDirSelector.reset();
+  }
+
+  std::scoped_lock lock{m_mutex};
+
+  if (!m_error.empty()) {
+    ImGui::TextUnformatted(m_error.c_str());
+  }
+
+  switch (m_state) {
+    case kDisconnected:
+      DisplayConnect();
+      break;
+    case kConnecting:
+      DisplayDisconnectButton();
+      ImGui::Text("Connecting to %s...", m_serverTeam.c_str());
+      break;
+    case kDisconnecting:
+      ImGui::TextUnformatted("Disconnecting...");
+      break;
+    case kConnected:
+    case kGetFiles:
+      DisplayDisconnectButton();
+      DisplayRemoteDirSelector();
+      if (DisplayFiles() > 0) {
+        DisplayLocalDirSelector();
+      }
+      break;
+    case kDownload:
+    case kDownloadDone:
+      DisplayDisconnectButton();
+      DisplayFiles();
+      if (m_state == kDownloadDone) {
+        if (ImGui::Button("Download complete!")) {
+          m_state = kGetFiles;
+          m_cv.notify_all();
+        }
+      }
+      break;
+    default:
+      break;
+  }
+}
+
+void Downloader::ThreadMain() {
+  std::unique_ptr<sftp::Session> session;
+
+  static constexpr size_t kBufSize = 32 * 1024;
+  std::unique_ptr<uint8_t[]> copyBuf = std::make_unique<uint8_t[]>(kBufSize);
+
+  std::unique_lock lock{m_mutex};
+  while (m_state != kExit) {
+    State prev = m_state;
+    m_cv.wait(lock, [&] { return m_state != prev; });
+    m_error.clear();
+    try {
+      switch (m_state) {
+        case kConnecting:
+          if (auto team = wpi::parse_integer<unsigned int>(m_serverTeam, 10)) {
+            // team number
+            session = std::make_unique<sftp::Session>(
+                fmt::format("roborio-{}-frc.local", team.value()), 22,
+                m_username, m_password);
+          } else {
+            session = std::make_unique<sftp::Session>(m_serverTeam, 22,
+                                                      m_username, m_password);
+          }
+          lock.unlock();
+          try {
+            session->Connect();
+          } catch (...) {
+            lock.lock();
+            throw;
+          }
+          lock.lock();
+          // FALLTHROUGH
+        case kGetFiles: {
+          std::string dir = m_remoteDir;
+          std::vector<sftp::Attributes> fileList;
+          lock.unlock();
+          try {
+            fileList = session->ReadDir(dir);
+          } catch (sftp::Exception& ex) {
+            lock.lock();
+            if (ex.err == SSH_FX_OK || ex.err == SSH_FX_CONNECTION_LOST) {
+              throw;
+            }
+            m_error = ex.what();
+            m_dirList.clear();
+            m_downloadList.clear();
+            m_state = kConnected;
+            break;
+          }
+          std::sort(
+              fileList.begin(), fileList.end(),
+              [](const auto& l, const auto& r) { return l.name < r.name; });
+          lock.lock();
+
+          m_dirList.clear();
+          m_downloadList.clear();
+          for (auto&& attr : fileList) {
+            if (attr.type == SSH_FILEXFER_TYPE_DIRECTORY) {
+              if (attr.name != ".") {
+                m_dirList.emplace_back(attr.name);
+              }
+            } else if (attr.type == SSH_FILEXFER_TYPE_REGULAR &&
+                       (attr.flags & SSH_FILEXFER_ATTR_SIZE) != 0 &&
+                       wpi::ends_with(attr.name, ".wpilog")) {
+              m_downloadList.emplace_back(attr.name, attr.size);
+            }
+          }
+
+          m_state = kConnected;
+          break;
+        }
+        case kDisconnecting:
+          session.reset();
+          m_state = kDisconnected;
+          break;
+        case kDownload: {
+          for (auto&& download : m_downloadList) {
+            if (m_state != kDownload) {
+              // user aborted
+              break;
+            }
+            if (!download.enabled) {
+              continue;
+            }
+
+            auto remoteFilename = fmt::format(
+                "{}{}{}", m_remoteDir,
+                wpi::ends_with(m_remoteDir, '/') ? "" : "/", download.name);
+            auto localFilename = fs::path{m_localDir} / download.name;
+            uint64_t fileSize = download.size;
+
+            lock.unlock();
+
+            // open local file
+            std::error_code ec;
+            fs::file_t of = fs::OpenFileForWrite(localFilename, ec,
+                                                 fs::CD_CreateNew, fs::OF_None);
+            if (ec) {
+              // failed to open
+              lock.lock();
+              download.status = ec.message();
+              continue;
+            }
+            int ofd = fs::FileToFd(of, ec, fs::OF_None);
+            if (ofd == -1 || ec) {
+              // failed to convert to fd
+              lock.lock();
+              download.status = ec.message();
+              continue;
+            }
+
+            try {
+              // open remote file
+              sftp::File f = session->Open(remoteFilename, O_RDONLY, 0);
+
+              // copy in chunks
+              uint64_t total = 0;
+              while (total < fileSize) {
+                uint64_t toCopy = (std::min)(fileSize - total,
+                                             static_cast<uint64_t>(kBufSize));
+                auto copied = f.Read(copyBuf.get(), toCopy);
+                if (write(ofd, copyBuf.get(), copied) !=
+                    static_cast<int64_t>(copied)) {
+                  // error writing
+                  close(ofd);
+                  fs::remove(localFilename, ec);
+                  lock.lock();
+                  download.status = "error writing local file";
+                  goto err;
+                }
+                total += copied;
+                lock.lock();
+                download.complete = static_cast<float>(total) / fileSize;
+                lock.unlock();
+              }
+
+              // close local file
+              close(ofd);
+              ofd = -1;
+
+              // delete remote file (if enabled)
+              if (m_deleteAfter) {
+                f = sftp::File{};
+                session->Unlink(remoteFilename);
+              }
+            } catch (sftp::Exception& ex) {
+              if (ofd != -1) {
+                // close local file and delete it (due to failure)
+                close(ofd);
+                fs::remove(localFilename, ec);
+              }
+              lock.lock();
+              download.status = ex.what();
+              if (ex.err == SSH_FX_OK || ex.err == SSH_FX_CONNECTION_LOST) {
+                throw;
+              }
+              continue;
+            }
+            lock.lock();
+          err : {}
+          }
+          if (m_state == kDownload) {
+            m_state = kDownloadDone;
+          }
+          break;
+        }
+        default:
+          break;
+      }
+    } catch (sftp::Exception& ex) {
+      m_error = ex.what();
+      session.reset();
+      m_state = kDisconnected;
+    }
+  }
+}

datalogtool/src/main/native/cpp/Downloader.h

@@ -0,0 +1,78 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include <wpi/condition_variable.h>
+#include <wpi/mutex.h>
+
+namespace glass {
+class Storage;
+}  // namespace glass
+
+namespace pfd {
+class select_folder;
+}  // namespace pfd
+
+class Downloader {
+ public:
+  explicit Downloader(glass::Storage& storage);
+  ~Downloader();
+
+  void Display();
+
+ private:
+  void DisplayConnect();
+  void DisplayDisconnectButton();
+  void DisplayRemoteDirSelector();
+  void DisplayLocalDirSelector();
+  size_t DisplayFiles();
+
+  void ThreadMain();
+
+  wpi::mutex m_mutex;
+  enum State {
+    kDisconnected,
+    kConnecting,
+    kConnected,
+    kDisconnecting,
+    kGetFiles,
+    kDownload,
+    kDownloadDone,
+    kExit
+  } m_state = kDisconnected;
+  std::condition_variable m_cv;
+
+  std::string& m_serverTeam;
+  std::string& m_remoteDir;
+  std::string& m_username;
+  std::string m_password;
+
+  std::string& m_localDir;
+  std::unique_ptr<pfd::select_folder> m_localDirSelector;
+
+  bool& m_deleteAfter;
+
+  std::vector<std::string> m_dirList;
+  struct DownloadState {
+    DownloadState(std::string_view name, uint64_t size)
+        : name{name}, size{size} {}
+
+    std::string name;
+    uint64_t size;
+    bool enabled = true;
+    float complete = 0.0;
+    std::string status;
+  };
+  std::vector<DownloadState> m_downloadList;
+
+  std::string m_error;
+
+  std::thread m_thread;
+};

datalogtool/src/main/native/cpp/Exporter.cpp

@@ -0,0 +1,655 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "Exporter.h"
+
+#include <atomic>
+#include <ctime>
+#include <future>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include <fmt/chrono.h>
+#include <fmt/format.h>
+#include <glass/Storage.h>
+#include <imgui.h>
+#include <imgui_internal.h>
+#include <imgui_stdlib.h>
+#include <portable-file-dialogs.h>
+#include <wpi/DenseMap.h>
+#include <wpi/MemoryBuffer.h>
+#include <wpi/SmallVector.h>
+#include <wpi/SpanExtras.h>
+#include <wpi/StringExtras.h>
+#include <wpi/fmt/raw_ostream.h>
+#include <wpi/fs.h>
+#include <wpi/mutex.h>
+#include <wpi/raw_ostream.h>
+
+#include "App.h"
+#include "DataLogThread.h"
+
+namespace {
+struct InputFile {
+  explicit InputFile(std::unique_ptr<DataLogThread> datalog);
+
+  InputFile(std::string_view filename, std::string_view status)
+      : filename{filename},
+        stem{fs::path{filename}.stem().string()},
+        status{status} {}
+
+  ~InputFile();
+
+  std::string filename;
+  std::string stem;
+  std::unique_ptr<DataLogThread> datalog;
+  std::string status;
+  bool highlight = false;
+};
+
+struct Entry {
+  explicit Entry(const wpi::log::StartRecordData& srd)
+      : name{srd.name}, type{srd.type}, metadata{srd.metadata} {}
+
+  std::string name;
+  std::string type;
+  std::string metadata;
+  std::set<InputFile*> inputFiles;
+  bool typeConflict = false;
+  bool metadataConflict = false;
+  bool selected = true;
+
+  // used only during export
+  int column = -1;
+};
+
+struct EntryTreeNode {
+  explicit EntryTreeNode(std::string_view name) : name{name} {}
+  std::string name;  // name of just this node
+  std::string path;  // full path if entry is nullptr
+  Entry* entry = nullptr;
+  std::vector<EntryTreeNode> children;  // children, sorted by name
+  int selected = 1;
+};
+}  // namespace
+
+static std::map<std::string, std::unique_ptr<InputFile>, std::less<>>
+    gInputFiles;
+static wpi::mutex gEntriesMutex;
+static std::map<std::string, std::unique_ptr<Entry>, std::less<>> gEntries;
+static std::vector<EntryTreeNode> gEntryTree;
+std::atomic_int gExportCount{0};
+
+// must be called with gEntriesMutex held
+static void RebuildEntryTree() {
+  gEntryTree.clear();
+  wpi::SmallVector<std::string_view, 16> parts;
+  for (auto& kv : gEntries) {
+    parts.clear();
+    // split on first : if one is present
+    auto [prefix, mainpart] = wpi::split(kv.first, ':');
+    if (mainpart.empty() || wpi::contains(prefix, '/')) {
+      mainpart = kv.first;
+    } else {
+      parts.emplace_back(prefix);
+    }
+    wpi::split(mainpart, parts, '/', -1, false);
+
+    // ignore a raw "/" key
+    if (parts.empty()) {
+      continue;
+    }
+
+    // get to leaf
+    auto nodes = &gEntryTree;
+    for (auto part : wpi::drop_back(wpi::span{parts.begin(), parts.end()})) {
+      auto it =
+          std::find_if(nodes->begin(), nodes->end(),
+                       [&](const auto& node) { return node.name == part; });
+      if (it == nodes->end()) {
+        nodes->emplace_back(part);
+        // path is from the beginning of the string to the end of the current
+        // part; this works because part is a reference to the internals of
+        // kv.first
+        nodes->back().path.assign(kv.first.data(),
+                                  part.data() + part.size() - kv.first.data());
+        it = nodes->end() - 1;
+      }
+      nodes = &it->children;
+    }
+
+    auto it = std::find_if(nodes->begin(), nodes->end(), [&](const auto& node) {
+      return node.name == parts.back();
+    });
+    if (it == nodes->end()) {
+      nodes->emplace_back(parts.back());
+      // no need to set path, as it's identical to kv.first
+      it = nodes->end() - 1;
+    }
+    it->entry = kv.second.get();
+  }
+}
+
+InputFile::InputFile(std::unique_ptr<DataLogThread> datalog_)
+    : filename{datalog_->GetBufferIdentifier()},
+      stem{fs::path{filename}.stem().string()},
+      datalog{std::move(datalog_)} {
+  datalog->sigEntryAdded.connect([this](const wpi::log::StartRecordData& srd) {
+    std::scoped_lock lock{gEntriesMutex};
+    auto it = gEntries.find(srd.name);
+    if (it == gEntries.end()) {
+      it = gEntries.emplace(srd.name, std::make_unique<Entry>(srd)).first;
+      RebuildEntryTree();
+    } else {
+      if (it->second->type != srd.type) {
+        it->second->typeConflict = true;
+      }
+      if (it->second->metadata != srd.metadata) {
+        it->second->metadataConflict = true;
+      }
+    }
+    it->second->inputFiles.emplace(this);
+  });
+}
+
+InputFile::~InputFile() {
+  if (gShutdown || !datalog) {
+    return;
+  }
+  std::scoped_lock lock{gEntriesMutex};
+  bool changed = false;
+  for (auto it = gEntries.begin(); it != gEntries.end();) {
+    it->second->inputFiles.erase(this);
+    if (it->second->inputFiles.empty()) {
+      it = gEntries.erase(it);
+      changed = true;
+    } else {
+      ++it;
+    }
+  }
+  if (changed) {
+    RebuildEntryTree();
+  }
+}
+
+static std::unique_ptr<InputFile> LoadDataLog(std::string_view filename) {
+  std::error_code ec;
+  auto buf = wpi::MemoryBuffer::GetFile(filename, ec);
+  std::string fn{filename};
+  if (ec) {
+    return std::make_unique<InputFile>(
+        fn, fmt::format("Could not open file: {}", ec.message()));
+  }
+
+  wpi::log::DataLogReader reader{std::move(buf)};
+  if (!reader.IsValid()) {
+    return std::make_unique<InputFile>(fn, "Not a valid datalog file");
+  }
+
+  return std::make_unique<InputFile>(
+      std::make_unique<DataLogThread>(std::move(reader)));
+}
+
+void DisplayInputFiles() {
+  static std::unique_ptr<pfd::open_file> dataFileSelector;
+
+  SetNextWindowPos(ImVec2{0, 20}, ImGuiCond_FirstUseEver);
+  SetNextWindowSize(ImVec2{375, 230}, ImGuiCond_FirstUseEver);
+  if (ImGui::Begin("Input Files")) {
+    if (ImGui::Button("Open File(s)...")) {
+      dataFileSelector = std::make_unique<pfd::open_file>(
+          "Select Data Log", "",
+          std::vector<std::string>{"DataLog Files", "*.wpilog"},
+          pfd::opt::multiselect);
+    }
+    ImGui::BeginTable(
+        "Input Files", 3,
+        ImGuiTableFlags_Borders | ImGuiTableFlags_SizingStretchProp);
+    ImGui::TableSetupColumn("File");
+    ImGui::TableSetupColumn("Status");
+    ImGui::TableSetupColumn("X", ImGuiTableColumnFlags_WidthFixed |
+                                     ImGuiTableColumnFlags_NoHeaderLabel |
+                                     ImGuiTableColumnFlags_NoHeaderWidth);
+    ImGui::TableHeadersRow();
+    for (auto it = gInputFiles.begin(); it != gInputFiles.end();) {
+      ImGui::TableNextRow();
+      ImGui::TableNextColumn();
+      if (it->second->highlight) {
+        ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg0,
+                               IM_COL32(0, 64, 0, 255));
+        it->second->highlight = false;
+      }
+      ImGui::TextUnformatted(it->first.c_str());
+      if (ImGui::IsItemHovered()) {
+        ImGui::SetTooltip("%s", it->second->filename.c_str());
+      }
+
+      ImGui::TableNextColumn();
+      if (it->second->datalog) {
+        ImGui::Text("%u records, %u entries%s",
+                    it->second->datalog->GetNumRecords(),
+                    it->second->datalog->GetNumEntries(),
+                    it->second->datalog->IsDone() ? "" : " (working)");
+      } else {
+        ImGui::TextUnformatted(it->second->status.c_str());
+      }
+
+      ImGui::TableNextColumn();
+      ImGui::PushID(it->first.c_str());
+      if (ImGui::SmallButton("X")) {
+        it = gInputFiles.erase(it);
+        gExportCount = 0;
+      } else {
+        ++it;
+      }
+      ImGui::PopID();
+    }
+    ImGui::EndTable();
+  }
+  ImGui::End();
+
+  // Load data file(s)
+  if (dataFileSelector && dataFileSelector->ready(0)) {
+    auto result = dataFileSelector->result();
+    for (auto&& filename : result) {
+      // don't allow duplicates
+      std::string stem = fs::path{filename}.stem().string();
+      auto it = gInputFiles.find(stem);
+      if (it == gInputFiles.end()) {
+        gInputFiles.emplace(std::move(stem), LoadDataLog(filename));
+        gExportCount = 0;
+      }
+    }
+    dataFileSelector.reset();
+  }
+}
+
+static bool EmitEntry(const std::string& name, Entry& entry) {
+  ImGui::TableNextColumn();
+  bool rv = ImGui::Checkbox(name.c_str(), &entry.selected);
+  if (ImGui::IsItemHovered() && gInputFiles.size() > 1) {
+    for (auto inputFile : entry.inputFiles) {
+      inputFile->highlight = true;
+    }
+  }
+
+  ImGui::TableNextColumn();
+  if (entry.typeConflict) {
+    ImGui::TextUnformatted("(Inconsistent)");
+    if (ImGui::IsItemHovered()) {
+      ImGui::BeginTooltip();
+      for (auto inputFile : entry.inputFiles) {
+        ImGui::Text(
+            "%s: %s", inputFile->stem.c_str(),
+            std::string{inputFile->datalog->GetEntry(entry.name).type}.c_str());
+      }
+      ImGui::EndTooltip();
+    }
+  } else {
+    ImGui::TextUnformatted(entry.type.c_str());
+  }
+
+  ImGui::TableNextColumn();
+  if (entry.metadataConflict) {
+    ImGui::TextUnformatted("(Inconsistent)");
+    if (ImGui::IsItemHovered()) {
+      ImGui::BeginTooltip();
+      for (auto inputFile : entry.inputFiles) {
+        ImGui::Text(
+            "%s: %s", inputFile->stem.c_str(),
+            std::string{inputFile->datalog->GetEntry(entry.name).metadata}
+                .c_str());
+      }
+      ImGui::EndTooltip();
+    }
+  } else {
+    ImGui::TextUnformatted(entry.metadata.c_str());
+  }
+  return rv;
+}
+
+static bool EmitEntryTree(std::vector<EntryTreeNode>& tree) {
+  bool rv = false;
+  for (auto&& node : tree) {
+    if (node.entry) {
+      if (EmitEntry(node.name, *node.entry)) {
+        rv = true;
+      }
+    }
+
+    if (!node.children.empty()) {
+      ImGui::TableNextColumn();
+      auto label = fmt::format("##check_{}", node.name);
+      if (node.selected == -1) {
+        ImGui::PushItemFlag(ImGuiItemFlags_MixedValue, true);
+        bool b = false;
+        if (ImGui::Checkbox(label.c_str(), &b)) {
+          node.selected = 3;  // 3 = enable group
+          rv = true;
+        }
+        ImGui::PopItemFlag();
+      } else {
+        bool b = node.selected == 1 || node.selected == 3;
+        if (ImGui::Checkbox(label.c_str(), &b)) {
+          node.selected = b ? 3 : 2;  // 2 = disable group
+          rv = true;
+        }
+      }
+      ImGui::SameLine();
+      bool open = ImGui::TreeNodeEx(node.name.c_str(),
+                                    ImGuiTreeNodeFlags_SpanFullWidth);
+      ImGui::TableNextColumn();
+      ImGui::TableNextColumn();
+      if (open) {
+        if (EmitEntryTree(node.children)) {
+          rv = true;
+        }
+        ImGui::TreePop();
+      }
+    }
+  }
+  return rv;
+}
+
+static void RefreshTreeCheckboxes(std::vector<EntryTreeNode>& tree,
+                                  int* selected) {
+  bool first = true;
+  for (auto&& node : tree) {
+    if (node.entry) {
+      if (first && *selected == -1) {
+        *selected = node.entry->selected ? 1 : 0;
+      }
+      if ((*selected == 0 && node.entry->selected) ||
+          (*selected == 1 && !node.entry->selected)) {
+        *selected = -1;             // inconsistent
+      } else if (*selected == 2) {  // disable group
+        node.entry->selected = false;
+      } else if (*selected == 3) {  // enable group
+        node.entry->selected = true;
+      }
+    }
+
+    if (!node.children.empty()) {
+      if (*selected == 2) {  // disable group
+        node.selected = 2;
+      } else if (*selected == 3) {  // enable group
+        node.selected = 3;
+      }
+      RefreshTreeCheckboxes(node.children, &node.selected);
+      if (node.selected == 2) {
+        node.selected = 0;
+      } else if (node.selected == 3) {
+        node.selected = 1;
+      }
+      if (first && *selected == -1) {
+        *selected = node.selected;
+      } else if (node.selected == -1 ||
+                 (*selected == 0 && node.selected == 1) ||
+                 (*selected == 1 && node.selected == 0)) {
+        *selected = -1;  // inconsistent
+      }
+    }
+
+    first = false;
+  }
+}
+
+void DisplayEntries() {
+  SetNextWindowPos(ImVec2{380, 20}, ImGuiCond_FirstUseEver);
+  SetNextWindowSize(ImVec2{540, 365}, ImGuiCond_FirstUseEver);
+  if (ImGui::Begin("Entries")) {
+    static bool treeView = true;
+    if (ImGui::BeginPopupContextItem()) {
+      ImGui::MenuItem("Tree View", "", &treeView);
+      ImGui::EndPopup();
+    }
+    std::scoped_lock lock{gEntriesMutex};
+    ImGui::BeginTable(
+        "Entries", 3,
+        ImGuiTableFlags_Borders | ImGuiTableFlags_SizingStretchProp);
+    ImGui::TableSetupColumn("Name");
+    ImGui::TableSetupColumn("Type");
+    ImGui::TableSetupColumn("Metadata");
+    ImGui::TableHeadersRow();
+    if (treeView) {
+      if (EmitEntryTree(gEntryTree)) {
+        int selected = -1;
+        RefreshTreeCheckboxes(gEntryTree, &selected);
+      }
+    } else {
+      for (auto&& kv : gEntries) {
+        EmitEntry(kv.first, *kv.second);
+      }
+    }
+    ImGui::EndTable();
+  }
+  ImGui::End();
+}
+
+static wpi::mutex gExportMutex;
+static std::vector<std::string> gExportErrors;
+
+static void PrintEscapedCsvString(wpi::raw_ostream& os, std::string_view str) {
+  auto s = str;
+  while (!s.empty()) {
+    std::string_view fragment;
+    std::tie(fragment, s) = wpi::split(s, '"');
+    os << fragment;
+    if (!s.empty()) {
+      os << '"' << '"';
+    }
+  }
+  if (wpi::ends_with(str, '"')) {
+    os << '"' << '"';
+  }
+}
+
+static void ValueToCsv(wpi::raw_ostream& os, const Entry& entry,
+                       const wpi::log::DataLogRecord& record) {
+  // handle systemTime specially
+  if (entry.name == "systemTime" && entry.type == "int64") {
+    int64_t val;
+    if (record.GetInteger(&val)) {
+      std::time_t timeval = val / 1000000;
+      fmt::print(os, "{:%Y-%m-%d %H:%M:%S}.{:06}", *std::localtime(&timeval),
+                 val % 1000000);
+      return;
+    }
+  } else if (entry.type == "double") {
+    double val;
+    if (record.GetDouble(&val)) {
+      fmt::print(os, "{}", val);
+      return;
+    }
+  } else if (entry.type == "int64") {
+    int64_t val;
+    if (record.GetInteger(&val)) {
+      fmt::print(os, "{}", val);
+      return;
+    }
+  } else if (entry.type == "string" || entry.type == "json") {
+    std::string_view val;
+    record.GetString(&val);
+    os << '"';
+    PrintEscapedCsvString(os, val);
+    os << '"';
+    return;
+  } else if (entry.type == "boolean") {
+    bool val;
+    if (record.GetBoolean(&val)) {
+      fmt::print(os, "{}", val);
+      return;
+    }
+  } else if (entry.type == "double[]") {
+    std::vector<double> val;
+    if (record.GetDoubleArray(&val)) {
+      fmt::print(os, "{}", fmt::join(val, ";"));
+      return;
+    }
+  } else if (entry.type == "float[]") {
+    std::vector<float> val;
+    if (record.GetFloatArray(&val)) {
+      fmt::print(os, "{}", fmt::join(val, ";"));
+      return;
+    }
+  } else if (entry.type == "int64[]") {
+    std::vector<int64_t> val;
+    if (record.GetIntegerArray(&val)) {
+      fmt::print(os, "{}", fmt::join(val, ";"));
+      return;
+    }
+  } else if (entry.type == "string[]") {
+    std::vector<std::string_view> val;
+    if (record.GetStringArray(&val)) {
+      os << '"';
+      bool first = true;
+      for (auto&& v : val) {
+        if (!first) {
+          os << ';';
+        }
+        first = false;
+        PrintEscapedCsvString(os, v);
+      }
+      os << '"';
+      return;
+    }
+  }
+  fmt::print(os, "<invalid>");
+}
+
+static void ExportCsvFile(InputFile& f, wpi::raw_ostream& os, int style) {
+  // header
+  if (style == 0) {
+    os << "Timestamp,Name,Value\n";
+  } else if (style == 1) {
+    // scan for exported fields for this file to print header and assign columns
+    os << "Timestamp";
+    int columnNum = 0;
+    for (auto&& entry : gEntries) {
+      if (entry.second->selected &&
+          entry.second->inputFiles.find(&f) != entry.second->inputFiles.end()) {
+        os << ',' << '"';
+        PrintEscapedCsvString(os, entry.first);
+        os << '"';
+        entry.second->column = columnNum++;
+      } else {
+        entry.second->column = -1;
+      }
+    }
+    os << '\n';
+  }
+
+  wpi::DenseMap<int, Entry*> nameMap;
+  for (auto&& record : f.datalog->GetReader()) {
+    if (record.IsStart()) {
+      wpi::log::StartRecordData data;
+      if (record.GetStartData(&data)) {
+        auto it = gEntries.find(data.name);
+        if (it != gEntries.end() && it->second->selected) {
+          nameMap[data.entry] = it->second.get();
+        }
+      }
+    } else if (record.IsFinish()) {
+      int entry;
+      if (record.GetFinishEntry(&entry)) {
+        nameMap.erase(entry);
+      }
+    } else if (!record.IsControl()) {
+      auto entryIt = nameMap.find(record.GetEntry());
+      if (entryIt == nameMap.end()) {
+        continue;
+      }
+      Entry* entry = entryIt->second;
+
+      if (style == 0) {
+        fmt::print(os, "{},\"", record.GetTimestamp() / 1000000.0);
+        PrintEscapedCsvString(os, entry->name);
+        os << '"' << ',';
+        ValueToCsv(os, *entry, record);
+        os << '\n';
+      } else if (style == 1 && entry->column != -1) {
+        fmt::print(os, "{},", record.GetTimestamp() / 1000000.0);
+        for (int i = 0; i < entry->column; ++i) {
+          os << ',';
+        }
+        ValueToCsv(os, *entry, record);
+        os << '\n';
+      }
+    }
+  }
+}
+
+static void ExportCsv(std::string_view outputFolder, int style) {
+  fs::path outPath{outputFolder};
+  for (auto&& f : gInputFiles) {
+    if (f.second->datalog) {
+      std::error_code ec;
+      auto of = fs::OpenFileForWrite(
+          outPath / fs::path{f.first}.replace_extension("csv"), ec,
+          fs::CD_CreateNew, fs::OF_Text);
+      if (ec) {
+        std::scoped_lock lock{gExportMutex};
+        gExportErrors.emplace_back(
+            fmt::format("{}: {}", f.first, ec.message()));
+        ++gExportCount;
+        continue;
+      }
+      wpi::raw_fd_ostream os{fs::FileToFd(of, ec, fs::OF_Text), true};
+      ExportCsvFile(*f.second, os, style);
+    }
+    ++gExportCount;
+  }
+}
+
+void DisplayOutput(glass::Storage& storage) {
+  static std::string& outputFolder = storage.GetString("outputFolder");
+  static std::unique_ptr<pfd::select_folder> outputFolderSelector;
+
+  SetNextWindowPos(ImVec2{380, 390}, ImGuiCond_FirstUseEver);
+  SetNextWindowSize(ImVec2{540, 120}, ImGuiCond_FirstUseEver);
+  if (ImGui::Begin("Output")) {
+    if (ImGui::Button("Select Output Folder...")) {
+      outputFolderSelector =
+          std::make_unique<pfd::select_folder>("Select Output Folder");
+    }
+    ImGui::TextUnformatted(outputFolder.c_str());
+
+    static const char* const options[] = {"List", "Table"};
+    static int style = 0;
+    ImGui::SetNextItemWidth(ImGui::GetFontSize() * 8);
+    ImGui::Combo("Style", &style, options,
+                 sizeof(options) / sizeof(const char*));
+
+    static std::future<void> exporter;
+    if (!gInputFiles.empty() && !outputFolder.empty() &&
+        ImGui::Button("Export CSV") &&
+        (gExportCount == 0 ||
+         gExportCount == static_cast<int>(gInputFiles.size()))) {
+      gExportCount = 0;
+      gExportErrors.clear();
+      exporter = std::async(std::launch::async, ExportCsv, outputFolder, style);
+    }
+    if (exporter.valid()) {
+      ImGui::SameLine();
+      ImGui::Text("Exported %d/%d", gExportCount.load(),
+                  static_cast<int>(gInputFiles.size()));
+    }
+    {
+      std::scoped_lock lock{gExportMutex};
+      for (auto&& err : gExportErrors) {
+        ImGui::TextUnformatted(err.c_str());
+      }
+    }
+  }
+  ImGui::End();
+
+  if (outputFolderSelector && outputFolderSelector->ready(0)) {
+    outputFolder = outputFolderSelector->result();
+    outputFolderSelector.reset();
+  }
+}

datalogtool/src/main/native/cpp/Exporter.h

@@ -0,0 +1,15 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+namespace glass {
+class Storage;
+}  // namespace glass
+
+void DisplayInputFiles();
+void DisplayEntries();
+void DisplayOutput(glass::Storage& storage);
+
+extern bool gShutdown;

datalogtool/src/main/native/cpp/Sftp.cpp

@@ -0,0 +1,215 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "Sftp.h"
+
+#include <fmt/format.h>
+
+using namespace sftp;
+
+Attributes::Attributes(sftp_attributes&& attr)
+    : name{attr->name}, flags{attr->flags}, type{attr->type}, size{attr->size} {
+  sftp_attributes_free(attr);
+}
+
+static std::string GetError(sftp_session sftp) {
+  switch (sftp_get_error(sftp)) {
+    case SSH_FX_EOF:
+      return "end of file";
+    case SSH_FX_NO_SUCH_FILE:
+      return "no such file";
+    case SSH_FX_PERMISSION_DENIED:
+      return "permission denied";
+    case SSH_FX_FAILURE:
+      return "SFTP failure";
+    case SSH_FX_BAD_MESSAGE:
+      return "SFTP bad message";
+    case SSH_FX_NO_CONNECTION:
+      return "SFTP no connection";
+    case SSH_FX_CONNECTION_LOST:
+      return "SFTP connection lost";
+    case SSH_FX_OP_UNSUPPORTED:
+      return "SFTP operation unsupported";
+    case SSH_FX_INVALID_HANDLE:
+      return "SFTP invalid handle";
+    case SSH_FX_NO_SUCH_PATH:
+      return "no such path";
+    case SSH_FX_FILE_ALREADY_EXISTS:
+      return "file already exists";
+    case SSH_FX_WRITE_PROTECT:
+      return "write protected filesystem";
+    case SSH_FX_NO_MEDIA:
+      return "no media inserted";
+    default:
+      return ssh_get_error(sftp->session);
+  }
+}
+
+Exception::Exception(sftp_session sftp)
+    : runtime_error{GetError(sftp)}, err{sftp_get_error(sftp)} {}
+
+File::~File() {
+  if (m_handle) {
+    sftp_close(m_handle);
+  }
+}
+
+Attributes File::Stat() const {
+  sftp_attributes attr = sftp_fstat(m_handle);
+  if (!attr) {
+    throw Exception{m_handle->sftp};
+  }
+  return Attributes{std::move(attr)};
+}
+
+size_t File::Read(void* buf, uint32_t count) {
+  auto rv = sftp_read(m_handle, buf, count);
+  if (rv < 0) {
+    throw Exception{m_handle->sftp};
+  }
+  return rv;
+}
+
+File::AsyncId File::AsyncReadBegin(uint32_t len) const {
+  int rv = sftp_async_read_begin(m_handle, len);
+  if (rv < 0) {
+    throw Exception{m_handle->sftp};
+  }
+  return rv;
+}
+
+size_t File::AsyncRead(void* data, uint32_t len, AsyncId id) {
+  auto rv = sftp_async_read(m_handle, data, len, id);
+  if (rv == SSH_ERROR) {
+    throw Exception{ssh_get_error(m_handle->sftp->session)};
+  }
+  if (rv == SSH_AGAIN) {
+    return 0;
+  }
+  return rv;
+}
+
+size_t File::Write(wpi::span<const uint8_t> data) {
+  auto rv = sftp_write(m_handle, data.data(), data.size());
+  if (rv < 0) {
+    throw Exception{m_handle->sftp};
+  }
+  return rv;
+}
+
+void File::Seek(uint64_t offset) {
+  if (sftp_seek64(m_handle, offset) < 0) {
+    throw Exception{m_handle->sftp};
+  }
+}
+
+uint64_t File::Tell() const {
+  return sftp_tell64(m_handle);
+}
+
+void File::Rewind() {
+  sftp_rewind(m_handle);
+}
+
+void File::Sync() {
+  if (sftp_fsync(m_handle) < 0) {
+    throw Exception{m_handle->sftp};
+  }
+}
+
+Session::Session(std::string_view host, int port, std::string_view user,
+                 std::string_view pass)
+    : m_host{host}, m_port{port}, m_username{user}, m_password{pass} {
+  // Create a new SSH session.
+  m_session = ssh_new();
+  if (!m_session) {
+    throw Exception{"The SSH session could not be allocated."};
+  }
+
+  // Set the host, user, and port.
+  ssh_options_set(m_session, SSH_OPTIONS_HOST, m_host.c_str());
+  ssh_options_set(m_session, SSH_OPTIONS_USER, m_username.c_str());
+  ssh_options_set(m_session, SSH_OPTIONS_PORT, &m_port);
+
+  // Set timeout to 3 seconds.
+  int64_t timeout = 3L;
+  ssh_options_set(m_session, SSH_OPTIONS_TIMEOUT, &timeout);
+
+  // Set other miscellaneous options.
+  ssh_options_set(m_session, SSH_OPTIONS_STRICTHOSTKEYCHECK, "no");
+}
+
+Session::~Session() {
+  if (m_sftp) {
+    sftp_free(m_sftp);
+  }
+  if (m_session) {
+    ssh_free(m_session);
+  }
+}
+
+void Session::Connect() {
+  // Connect to the server.
+  int rc = ssh_connect(m_session);
+  if (rc != SSH_OK) {
+    throw Exception{ssh_get_error(m_session)};
+  }
+
+  // Authenticate with password.
+  rc = ssh_userauth_password(m_session, nullptr, m_password.c_str());
+  if (rc != SSH_AUTH_SUCCESS) {
+    throw Exception{ssh_get_error(m_session)};
+  }
+
+  // Allocate the SFTP session.
+  m_sftp = sftp_new(m_session);
+  if (!m_sftp) {
+    throw Exception{ssh_get_error(m_session)};
+  }
+
+  // Initialize.
+  rc = sftp_init(m_sftp);
+  if (rc != SSH_OK) {
+    sftp_free(m_sftp);
+    m_sftp = nullptr;
+    throw Exception{ssh_get_error(m_session)};
+  }
+}
+
+void Session::Disconnect() {
+  if (m_sftp) {
+    sftp_free(m_sftp);
+    m_sftp = nullptr;
+  }
+  ssh_disconnect(m_session);
+}
+
+std::vector<Attributes> Session::ReadDir(const std::string& path) {
+  sftp_dir dir = sftp_opendir(m_sftp, path.c_str());
+  if (!dir) {
+    throw Exception{m_sftp};
+  }
+
+  std::vector<Attributes> rv;
+  while (sftp_attributes attr = sftp_readdir(m_sftp, dir)) {
+    rv.emplace_back(std::move(attr));
+  }
+
+  sftp_closedir(dir);
+  return rv;
+}
+
+void Session::Unlink(const std::string& filename) {
+  if (sftp_unlink(m_sftp, filename.c_str()) < 0) {
+    throw Exception{m_sftp};
+  }
+}
+
+File Session::Open(const std::string& filename, int accesstype, mode_t mode) {
+  sftp_file f = sftp_open(m_sftp, filename.c_str(), accesstype, mode);
+  if (!f) {
+    throw Exception{m_sftp};
+  }
+  return File{std::move(f)};
+}

datalogtool/src/main/native/cpp/Sftp.h

@@ -0,0 +1,144 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include <libssh/libssh.h>
+#include <libssh/sftp.h>
+
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include <wpi/span.h>
+
+namespace sftp {
+
+struct Attributes {
+  Attributes() = default;
+  explicit Attributes(sftp_attributes&& attr);
+
+  std::string name;
+  uint32_t flags = 0;
+  uint8_t type = 0;
+  uint64_t size = 0;
+};
+
+/**
+ * This is the exception that will be thrown if something goes wrong.
+ */
+class Exception : public std::runtime_error {
+ public:
+  explicit Exception(const std::string& msg) : std::runtime_error{msg} {}
+  explicit Exception(sftp_session sftp);
+
+  int err = 0;
+};
+
+class File {
+ public:
+  File() = default;
+  explicit File(sftp_file&& handle) : m_handle{handle} {}
+  ~File();
+
+  Attributes Stat() const;
+
+  void SetNonblocking() { sftp_file_set_nonblocking(m_handle); }
+  void SetBlocking() { sftp_file_set_blocking(m_handle); }
+
+  using AsyncId = uint32_t;
+
+  size_t Read(void* buf, uint32_t count);
+  AsyncId AsyncReadBegin(uint32_t len) const;
+  size_t AsyncRead(void* data, uint32_t len, AsyncId id);
+  size_t Write(wpi::span<const uint8_t> data);
+
+  void Seek(uint64_t offset);
+  uint64_t Tell() const;
+  void Rewind();
+
+  void Sync();
+
+  std::string_view GetName() const { return m_handle->name; }
+  uint64_t GetOffset() const { return m_handle->offset; }
+  bool IsEof() const { return m_handle->eof; }
+  bool IsNonblocking() const { return m_handle->nonblocking; }
+
+ private:
+  sftp_file m_handle{nullptr};
+};
+
+/**
+ * This class is a C++ implementation of the SshSessionController in
+ * wpilibsuite/deploy-utils. It handles connecting to an SSH server, running
+ * commands, and transferring files.
+ */
+class Session {
+ public:
+  /**
+   * Constructs a new session controller.
+   *
+   * @param host The hostname of the server to connect to.
+   * @param port The port that the sshd server is operating on.
+   * @param user The username to login as.
+   * @param pass The password for the given username.
+   */
+  Session(std::string_view host, int port, std::string_view user,
+          std::string_view pass);
+
+  /**
+   * Destroys the controller object. This also disconnects the session from the
+   * server.
+   */
+  ~Session();
+
+  /**
+   * Opens the SSH connection to the given host.
+   */
+  void Connect();
+
+  /**
+   * Disconnects the SSH connection.
+   */
+  void Disconnect();
+
+  /**
+   * Reads directory entries
+   *
+   * @param path remote path
+   * @return vector of file attributes
+   */
+  std::vector<Attributes> ReadDir(const std::string& path);
+
+  /**
+   * Unlinks (deletes) a file.
+   *
+   * @param filename filename
+   */
+  void Unlink(const std::string& filename);
+
+  /**
+   * Opens a file.
+   *
+   * @param filename filename
+   * @param accesstype O_RDONLY, O_WRONLY, or O_RDWR, combined with O_CREAT,
+   *                   O_EXCL, or O_TRUNC
+   * @param mode permissions to use if a new file is created
+   * @return File
+   */
+  File Open(const std::string& filename, int accesstype, mode_t mode);
+
+ private:
+  ssh_session m_session{nullptr};
+  sftp_session m_sftp{nullptr};
+  std::string m_host;
+
+  int m_port;
+
+  std::string m_username;
+  std::string m_password;
+};
+
+}  // namespace sftp

datalogtool/src/main/native/cpp/main.cpp

@@ -0,0 +1,25 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include <string_view>
+
+void Application(std::string_view saveDir);
+
+#ifdef _WIN32
+int __stdcall WinMain(void* hInstance, void* hPrevInstance, char* pCmdLine,
+                      int nCmdShow) {
+  int argc = __argc;
+  char** argv = __argv;
+#else
+int main(int argc, char** argv) {
+#endif
+  std::string_view saveDir;
+  if (argc == 2) {
+    saveDir = argv[1];
+  }
+
+  Application(saveDir);
+
+  return 0;
+}

datalogtool/src/main/native/win/datalogtool.rc

@@ -0,0 +1 @@
+IDI_ICON1 ICON "datalogtool.ico"

docs/build.gradle

@@ -125,9 +125,10 @@ doxygen {
     }
 
     case_sense_names false
-    extension_mapping 'inc=C++'
+    extension_mapping 'inc=C++', 'no_extension=C++'
     extract_all true
     extract_static true
+    file_patterns '*'
     full_path_names true
     generate_html true
     generate_latex false

fieldImages/build.gradle

@@ -15,10 +15,14 @@ if (!project.hasProperty('onlylinuxathena') && !project.hasProperty('onlylinuxra
 
     ext {
         nativeName = 'fieldImages'
+        baseId = nativeName
+        groupId = 'edu.wpi.first.fieldImages'
+        devMain = "edu.wpi.first.fieldImages.DevMain"
     }
 
     apply from: "${rootDir}/shared/resources.gradle"
     apply from: "${rootDir}/shared/config.gradle"
+    apply from: "${rootDir}/shared/java/javacommon.gradle"
 
     def generateTask = createGenerateResourcesTask('main', 'FIELDS', 'fields', project)
 

fieldImages/publish.gradle

@@ -1,14 +1,14 @@
 apply plugin: 'maven-publish'
 
-def baseArtifactId = 'fieldImages'
-def artifactGroupId = 'edu.wpi.first.fieldImages'
-def zipBaseName = '_GROUP_edu_wpi_first_field_images_ID_CLS'
+def baseArtifactId = project.nativeName
+def artifactGroupId = project.groupId
+def cppZipBaseName = "_GROUP_edu_wpi_first_fieldIimages_ID_${baseArtifactId}-cpp_CLS"
 
 def outputsFolder = file("$project.buildDir/outputs")
 
 task cppSourcesZip(type: Zip) {
     destinationDirectory = outputsFolder
-    archiveBaseName = zipBaseName
+    archiveBaseName = cppZipBaseName
     classifier = "sources"
 
     from(licenseFile) {
@@ -25,7 +25,7 @@ task cppSourcesZip(type: Zip) {
 
 task cppHeadersZip(type: Zip) {
     destinationDirectory = outputsFolder
-    archiveBaseName = zipBaseName
+    archiveBaseName = cppZipBaseName
     classifier = "headers"
 
     from(licenseFile) {
@@ -51,7 +51,7 @@ addTaskToCopyAllOutputs(cppSourcesZip)
 
 model {
     publishing {
-        def wpilibCTaskList = createComponentZipTasks($.components, ['fieldImages'], zipBaseName, Zip, project, includeStandardZipFormat)
+        def wpilibCTaskList = createComponentZipTasks($.components, ['fieldImages'], cppZipBaseName, Zip, project, includeStandardZipFormat)
 
         publications {
             cpp(MavenPublication) {
@@ -62,7 +62,7 @@ model {
                 artifact cppHeadersZip
                 artifact cppSourcesZip
 
-                artifactId = baseArtifactId
+                artifactId = "${baseArtifactId}-cpp"
                 groupId artifactGroupId
                 version wpilibVersioning.version.get()
             }

fieldImages/src/main/java/edu/wpi/fields/FieldImages.java

@@ -20,4 +20,6 @@ public class FieldImages {
   public static final String k2021GalacticSearchBFieldConfig =
       "/edu/wpi/first/fields/2021-galacticsearchb.json";
   public static final String k2021SlalomFieldConfig = "/edu/wpi/first/fields/2021-slalompath.json";
+  public static final String k2022RapidReactFieldConfig =
+      "/edu/wpi/first/fields/2022-rapidreact.json";
 }

fieldImages/src/main/native/include/fields/2022-rapidreact.h

@@ -0,0 +1,12 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include <string_view>
+
+namespace fields {
+std::string_view GetResource_2022_rapidreact_json();
+std::string_view GetResource_2022_field_png();
+}  // namespace fields

fieldImages/src/main/native/resources/edu/wpi/first/fields/2022-rapidreact.json

@@ -0,0 +1,10 @@
+{
+    "game": "Rapid React",
+    "field-image": "2022-field.png",
+    "field-corners": {
+      "top-left": [74, 50],
+      "bottom-right": [1774, 900]
+    },
+    "field-size": [54, 27],
+    "field-unit": "foot"
+  }

glass/build.gradle

@@ -185,15 +185,18 @@ if (!project.hasProperty('onlylinuxathena') && !project.hasProperty('onlylinuxra
                         it.buildable = false
                         return
                     }
+                    lib project: ':cscore', library: 'cscore', linkage: 'static'
                     lib library: 'glassnt', linkage: 'static'
                     lib library: nativeName, linkage: 'static'
                     lib project: ':ntcore', library: 'ntcore', linkage: 'static'
                     lib project: ':wpiutil', library: 'wpiutil', linkage: 'static'
                     lib project: ':wpimath', library: 'wpimath', linkage: 'static'
                     lib project: ':wpigui', library: 'wpigui', linkage: 'static'
+                    nativeUtils.useRequiredLibrary(it, 'opencv_static')
                     nativeUtils.useRequiredLibrary(it, 'imgui_static')
                     if (it.targetPlatform.operatingSystem.isWindows()) {
                         it.linker.args << 'Gdi32.lib' << 'Shell32.lib' << 'd3d11.lib' << 'd3dcompiler.lib'
+                        it.linker.args << '/DELAYLOAD:MF.dll' << '/DELAYLOAD:MFReadWrite.dll' << '/DELAYLOAD:MFPlat.dll' << '/delay:nobind'
                     } else if (it.targetPlatform.operatingSystem.isMacOsX()) {
                         it.linker.args << '-framework' << 'Metal' << '-framework' << 'MetalKit' << '-framework' << 'Cocoa' << '-framework' << 'IOKit' << '-framework' << 'CoreFoundation' << '-framework' << 'CoreVideo' << '-framework' << 'QuartzCore'
                     } else {

glass/publish.gradle

@@ -130,6 +130,14 @@ model {
                             }
 
                             from(applicationPath)
+
+                            if (binary.targetPlatform.operatingSystem.isWindows()) {
+                                def exePath = binary.executable.file.absolutePath
+                                exePath = exePath.substring(0, exePath.length() - 4)
+                                def pdbPath = new File(exePath + '.pdb')
+                                from(pdbPath)
+                            }
+
                             into(nativeUtils.getPlatformPath(binary))
                         }
 

glass/src/app/native/cpp/camerasupport.cpp

@@ -0,0 +1,52 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "camerasupport.h"
+
+#ifdef _WIN32
+#include "Windows.h"
+#include "delayimp.h"
+#pragma comment(lib, "delayimp.lib")
+static int CheckDelayException(int exception_value) {
+  if (exception_value ==
+          VcppException(ERROR_SEVERITY_ERROR, ERROR_MOD_NOT_FOUND) ||
+      exception_value ==
+          VcppException(ERROR_SEVERITY_ERROR, ERROR_PROC_NOT_FOUND)) {
+    // This example just executes the handler.
+    return EXCEPTION_EXECUTE_HANDLER;
+  }
+  // Don't attempt to handle other errors
+  return EXCEPTION_CONTINUE_SEARCH;
+}
+static bool TryDelayLoadAllImports(LPCSTR szDll) {
+  __try {
+    HRESULT hr = __HrLoadAllImportsForDll(szDll);
+    if (FAILED(hr)) {
+      return false;
+    }
+  } __except (CheckDelayException(GetExceptionCode())) {
+    return false;
+  }
+  return true;
+}
+namespace glass {
+bool HasCameraSupport() {
+  bool hasCameraSupport = false;
+  hasCameraSupport = TryDelayLoadAllImports("MF.dll");
+  if (hasCameraSupport) {
+    hasCameraSupport = TryDelayLoadAllImports("MFPlat.dll");
+  }
+  if (hasCameraSupport) {
+    hasCameraSupport = TryDelayLoadAllImports("MFReadWrite.dll");
+  }
+  return hasCameraSupport;
+}
+}  // namespace glass
+#else
+namespace glass {
+bool HasCameraSupport() {
+  return true;
+}
+}  // namespace glass
+#endif

glass/src/app/native/cpp/camerasupport.h

@@ -0,0 +1,9 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+namespace glass {
+bool HasCameraSupport();
+}  // namespace glass

glass/src/app/native/cpp/main.cpp

@@ -11,7 +11,9 @@
 #include <wpigui.h>
 
 #include "glass/Context.h"
+#include "glass/MainMenuBar.h"
 #include "glass/Model.h"
+#include "glass/Storage.h"
 #include "glass/View.h"
 #include "glass/networktables/NetworkTables.h"
 #include "glass/networktables/NetworkTablesProvider.h"
@@ -39,9 +41,14 @@ static std::unique_ptr<glass::NetworkTablesProvider> gNtProvider;
 static std::unique_ptr<glass::NetworkTablesModel> gNetworkTablesModel;
 static std::unique_ptr<glass::NetworkTablesSettings> gNetworkTablesSettings;
 static glass::LogData gNetworkTablesLog;
-static glass::Window* gNetworkTablesWindow;
-static glass::Window* gNetworkTablesSettingsWindow;
-static glass::Window* gNetworkTablesLogWindow;
+static std::unique_ptr<glass::Window> gNetworkTablesWindow;
+static std::unique_ptr<glass::Window> gNetworkTablesSettingsWindow;
+static std::unique_ptr<glass::Window> gNetworkTablesLogWindow;
+
+static glass::MainMenuBar gMainMenu;
+static bool gAbout = false;
+static bool gSetEnterKey = false;
+static bool gKeyEdit = false;
 
 static void NtInitialize() {
   // update window title when connection status changes
@@ -84,48 +91,65 @@ static void NtInitialize() {
     }
   });
 
-  gNetworkTablesLogWindow = gNtProvider->AddWindow(
-      "NetworkTables Log",
+  gNetworkTablesLogWindow = std::make_unique<glass::Window>(
+      glass::GetStorageRoot().GetChild("NetworkTables Log"),
+      "NetworkTables Log", glass::Window::kHide);
+  gNetworkTablesLogWindow->SetView(
       std::make_unique<glass::LogView>(&gNetworkTablesLog));
-  if (gNetworkTablesLogWindow) {
-    gNetworkTablesLogWindow->SetDefaultPos(250, 615);
-    gNetworkTablesLogWindow->SetDefaultSize(600, 130);
-    gNetworkTablesLogWindow->SetVisible(false);
-    gNetworkTablesLogWindow->DisableRenamePopup();
-  }
+  gNetworkTablesLogWindow->SetDefaultPos(250, 615);
+  gNetworkTablesLogWindow->SetDefaultSize(600, 130);
+  gNetworkTablesLogWindow->DisableRenamePopup();
+  gui::AddLateExecute([] { gNetworkTablesLogWindow->Display(); });
 
   // NetworkTables table window
   gNetworkTablesModel = std::make_unique<glass::NetworkTablesModel>();
   gui::AddEarlyExecute([] { gNetworkTablesModel->Update(); });
 
-  gNetworkTablesWindow = gNtProvider->AddWindow(
-      "NetworkTables",
+  gNetworkTablesWindow = std::make_unique<glass::Window>(
+      glass::GetStorageRoot().GetChild("NetworkTables View"), "NetworkTables");
+  gNetworkTablesWindow->SetView(
       std::make_unique<glass::NetworkTablesView>(gNetworkTablesModel.get()));
-  if (gNetworkTablesWindow) {
-    gNetworkTablesWindow->SetDefaultPos(250, 277);
-    gNetworkTablesWindow->SetDefaultSize(750, 185);
-    gNetworkTablesWindow->DisableRenamePopup();
-  }
+  gNetworkTablesWindow->SetDefaultPos(250, 277);
+  gNetworkTablesWindow->SetDefaultSize(750, 185);
+  gNetworkTablesWindow->DisableRenamePopup();
+  gui::AddLateExecute([] { gNetworkTablesWindow->Display(); });
 
   // NetworkTables settings window
-  gNetworkTablesSettings = std::make_unique<glass::NetworkTablesSettings>();
+  gNetworkTablesSettings = std::make_unique<glass::NetworkTablesSettings>(
+      glass::GetStorageRoot().GetChild("NetworkTables Settings"));
   gui::AddEarlyExecute([] { gNetworkTablesSettings->Update(); });
 
-  gNetworkTablesSettingsWindow = gNtProvider->AddWindow(
-      "NetworkTables Settings", [] { gNetworkTablesSettings->Display(); });
-  if (gNetworkTablesSettingsWindow) {
-    gNetworkTablesSettingsWindow->SetDefaultPos(30, 30);
-    gNetworkTablesSettingsWindow->SetFlags(ImGuiWindowFlags_AlwaysAutoResize);
-    gNetworkTablesSettingsWindow->DisableRenamePopup();
-  }
+  gNetworkTablesSettingsWindow = std::make_unique<glass::Window>(
+      glass::GetStorageRoot().GetChild("NetworkTables Settings"),
+      "NetworkTables Settings");
+  gNetworkTablesSettingsWindow->SetView(
+      glass::MakeFunctionView([] { gNetworkTablesSettings->Display(); }));
+  gNetworkTablesSettingsWindow->SetDefaultPos(30, 30);
+  gNetworkTablesSettingsWindow->SetFlags(ImGuiWindowFlags_AlwaysAutoResize);
+  gNetworkTablesSettingsWindow->DisableRenamePopup();
+  gui::AddLateExecute([] { gNetworkTablesSettingsWindow->Display(); });
+
+  gui::AddWindowScaler([](float scale) {
+    // scale default window positions
+    gNetworkTablesLogWindow->ScaleDefault(scale);
+    gNetworkTablesWindow->ScaleDefault(scale);
+    gNetworkTablesSettingsWindow->ScaleDefault(scale);
+  });
 }
 
 #ifdef _WIN32
 int __stdcall WinMain(void* hInstance, void* hPrevInstance, char* pCmdLine,
                       int nCmdShow) {
+  int argc = __argc;
+  char** argv = __argv;
 #else
-int main() {
+int main(int argc, char** argv) {
 #endif
+  std::string_view saveDir;
+  if (argc == 2) {
+    saveDir = argv[1];
+  }
+
   gui::CreateContext();
   glass::CreateContext();
 
@@ -137,21 +161,28 @@ int main() {
   gui::AddIcon(glass::GetResource_glass_256_png());
   gui::AddIcon(glass::GetResource_glass_512_png());
 
-  gPlotProvider = std::make_unique<glass::PlotProvider>("Plot");
-  gNtProvider = std::make_unique<glass::NetworkTablesProvider>("NTProvider");
+  gPlotProvider = std::make_unique<glass::PlotProvider>(
+      glass::GetStorageRoot().GetChild("Plots"));
+  gNtProvider = std::make_unique<glass::NetworkTablesProvider>(
+      glass::GetStorageRoot().GetChild("NetworkTables"));
 
-  gui::ConfigurePlatformSaveFile("glass.ini");
+  glass::SetStorageName("glass");
+  glass::SetStorageDir(saveDir.empty() ? gui::GetPlatformSaveFileDir()
+                                       : saveDir);
   gPlotProvider->GlobalInit();
   gui::AddInit([] { glass::ResetTime(); });
   gNtProvider->GlobalInit();
-  gui::AddInit(NtInitialize);
+  NtInitialize();
 
   glass::AddStandardNetworkTablesViews(*gNtProvider);
 
-  gui::AddLateExecute([] {
-    ImGui::BeginMainMenuBar();
-    gui::EmitViewMenu();
+  gui::AddLateExecute([] { gMainMenu.Display(); });
+
+  gMainMenu.AddMainMenu([] {
     if (ImGui::BeginMenu("View")) {
+      if (ImGui::MenuItem("Set Enter Key")) {
+        gSetEnterKey = true;
+      }
       if (ImGui::MenuItem("Reset Time")) {
         glass::ResetTime();
       }
@@ -181,38 +212,95 @@ int main() {
       ImGui::EndMenu();
     }
 
-    bool about = false;
     if (ImGui::BeginMenu("Info")) {
       if (ImGui::MenuItem("About")) {
-        about = true;
+        gAbout = true;
       }
       ImGui::EndMenu();
     }
-    ImGui::EndMainMenuBar();
+  });
 
-    if (about) {
+  gui::AddLateExecute([] {
+    if (gAbout) {
       ImGui::OpenPopup("About");
-      about = false;
+      gAbout = false;
     }
     if (ImGui::BeginPopupModal("About")) {
       ImGui::Text("Glass: A different kind of dashboard");
       ImGui::Separator();
       ImGui::Text("v%s", GetWPILibVersion());
+      ImGui::Separator();
+      ImGui::Text("Save location: %s", glass::GetStorageDir().c_str());
       if (ImGui::Button("Close")) {
         ImGui::CloseCurrentPopup();
       }
       ImGui::EndPopup();
     }
+
+    int& enterKey = glass::GetStorageRoot().GetInt("enterKey", GLFW_KEY_ENTER);
+
+    ImGuiIO& io = ImGui::GetIO();
+    io.KeyMap[ImGuiKey_Enter] = enterKey;
+
+    if (gSetEnterKey) {
+      ImGui::OpenPopup("Set Enter Key");
+      gSetEnterKey = false;
+    }
+    if (ImGui::BeginPopupModal("Set Enter Key")) {
+      ImGui::Text("Set the key to use to mean 'Enter'");
+      ImGui::Text("This is useful to edit values without the DS disabling");
+      ImGui::Separator();
+
+      if (gKeyEdit) {
+        for (int i = 0; i < IM_ARRAYSIZE(io.KeysDown); ++i) {
+          if (io.KeysDown[i]) {
+            // remove all other uses
+            enterKey = i;
+            gKeyEdit = false;
+            break;
+          }
+        }
+      }
+
+      ImGui::Text("Key:");
+      ImGui::SameLine();
+      char editLabel[40];
+      char nameBuf[32];
+      const char* name = glfwGetKeyName(enterKey, 0);
+      if (!name) {
+        std::snprintf(nameBuf, sizeof(nameBuf), "%d", enterKey);
+        name = nameBuf;
+      }
+      std::snprintf(editLabel, sizeof(editLabel), "%s###edit",
+                    gKeyEdit ? "(press key)" : name);
+      if (ImGui::SmallButton(editLabel)) {
+        gKeyEdit = true;
+      }
+      ImGui::SameLine();
+      if (ImGui::SmallButton("Reset")) {
+        enterKey = GLFW_KEY_ENTER;
+      }
+
+      if (ImGui::Button("Close")) {
+        ImGui::CloseCurrentPopup();
+        gKeyEdit = false;
+      }
+      ImGui::EndPopup();
+    }
   });
 
   gui::Initialize("Glass - DISCONNECTED", 1024, 768);
   gui::Main();
 
+  gNetworkTablesSettingsWindow.reset();
+  gNetworkTablesLogWindow.reset();
+  gNetworkTablesWindow.reset();
   gNetworkTablesModel.reset();
-  gNetworkTablesSettings.reset();
   gNtProvider.reset();
   gPlotProvider.reset();
 
   glass::DestroyContext();
   gui::DestroyContext();
+
+  return 0;
 }

glass/src/lib/native/cpp/Context.cpp

@@ -7,13 +7,21 @@
 #include <algorithm>
 #include <cinttypes>
 #include <cstdio>
+#include <filesystem>
 
+#include <fmt/format.h>
 #include <imgui.h>
 #include <imgui_internal.h>
 #include <imgui_stdlib.h>
 #include <wpi/StringExtras.h>
+#include <wpi/fs.h>
+#include <wpi/json.h>
+#include <wpi/json_serializer.h>
+#include <wpi/raw_istream.h>
+#include <wpi/raw_ostream.h>
 #include <wpi/timestamp.h>
 #include <wpigui.h>
+#include <wpigui_internal.h>
 
 #include "glass/ContextInternal.h"
 
@@ -21,172 +29,292 @@ using namespace glass;
 
 Context* glass::gContext;
 
-static bool ConvertInt(Storage::Value* value) {
-  value->type = Storage::Value::kInt;
-  if (auto val = wpi::parse_integer<int>(value->stringVal, 10)) {
-    value->intVal = val.value();
-    return true;
+static void WorkspaceResetImpl() {
+  // call reset functions
+  for (auto&& reset : gContext->workspaceReset) {
+    if (reset) {
+      reset();
+    }
   }
-  return false;
+
+  // clear storage
+  for (auto&& root : gContext->storageRoots) {
+    root.second->Clear();
+  }
+
+  // ImGui reset
+  ImGui::ClearIniSettings();
 }
 
-static bool ConvertInt64(Storage::Value* value) {
-  value->type = Storage::Value::kInt64;
-  if (auto val = wpi::parse_integer<int64_t>(value->stringVal, 10)) {
-    value->int64Val = val.value();
-    return true;
+static void WorkspaceInit() {
+  for (auto&& init : gContext->workspaceInit) {
+    if (init) {
+      init();
+    }
+  }
+
+  for (auto&& root : gContext->storageRoots) {
+    root.getValue()->Apply();
   }
-  return false;
 }
 
-static bool ConvertBool(Storage::Value* value) {
-  value->type = Storage::Value::kBool;
-  if (auto val = wpi::parse_integer<int>(value->stringVal, 10)) {
-    value->intVal = (val.value() != 0);
-    return true;
+static bool JsonToWindow(const wpi::json& jfile, const char* filename) {
+  if (!jfile.is_object()) {
+    ImGui::LogText("%s top level is not object", filename);
+    return false;
   }
-  return false;
+
+  // loop over JSON and generate ini format
+  std::string iniStr;
+  wpi::raw_string_ostream ini{iniStr};
+
+  for (auto&& jsection : jfile.items()) {
+    if (!jsection.value().is_object()) {
+      ImGui::LogText("%s section %s is not object", filename,
+                     jsection.key().c_str());
+      return false;
+    }
+    for (auto&& jsubsection : jsection.value().items()) {
+      if (!jsubsection.value().is_object()) {
+        ImGui::LogText("%s section %s subsection %s is not object", filename,
+                       jsection.key().c_str(), jsubsection.key().c_str());
+        return false;
+      }
+      ini << '[' << jsection.key() << "][" << jsubsection.key() << "]\n";
+      for (auto&& jkv : jsubsection.value().items()) {
+        try {
+          auto& value = jkv.value().get_ref<const std::string&>();
+          ini << jkv.key() << '=' << value << "\n";
+        } catch (wpi::json::exception&) {
+          ImGui::LogText("%s section %s subsection %s value %s is not string",
+                         filename, jsection.key().c_str(),
+                         jsubsection.key().c_str(), jkv.key().c_str());
+          return false;
+        }
+      }
+      ini << '\n';
+    }
+  }
+  ini.flush();
+
+  ImGui::LoadIniSettingsFromMemory(iniStr.data(), iniStr.size());
+  return true;
 }
 
-static bool ConvertFloat(Storage::Value* value) {
-  value->type = Storage::Value::kFloat;
-  if (auto val = wpi::parse_float<float>(value->stringVal)) {
-    value->floatVal = val.value();
-    return true;
-  }
-  return false;
-}
-
-static bool ConvertDouble(Storage::Value* value) {
-  value->type = Storage::Value::kDouble;
-  if (auto val = wpi::parse_float<double>(value->stringVal)) {
-    value->doubleVal = val.value();
-    return true;
-  }
-  return false;
-}
-
-static void* GlassStorageReadOpen(ImGuiContext*, ImGuiSettingsHandler* handler,
-                                  const char* name) {
-  auto ctx = static_cast<Context*>(handler->UserData);
-  auto& storage = ctx->storage[name];
-  if (!storage) {
-    storage = std::make_unique<Storage>();
-  }
-  return storage.get();
-}
-
-static void GlassStorageReadLine(ImGuiContext*, ImGuiSettingsHandler*,
-                                 void* entry, const char* line) {
-  auto storage = static_cast<Storage*>(entry);
-  auto [key, val] = wpi::split(line, '=');
-  auto& keys = storage->GetKeys();
-  auto& values = storage->GetValues();
-  auto it = std::find(keys.begin(), keys.end(), key);
-  if (it == keys.end()) {
-    keys.emplace_back(key);
-    values.emplace_back(std::make_unique<Storage::Value>(val));
+static bool LoadWindowStorageImpl(const std::string& filename) {
+  std::error_code ec;
+  wpi::raw_fd_istream is{filename, ec};
+  if (ec) {
+    ImGui::LogText("error opening %s: %s", filename.c_str(),
+                   ec.message().c_str());
+    return false;
   } else {
-    auto& value = *values[it - keys.begin()];
-    value.stringVal = val;
-    switch (value.type) {
-      case Storage::Value::kInt:
-        ConvertInt(&value);
-        break;
-      case Storage::Value::kInt64:
-        ConvertInt64(&value);
-        break;
-      case Storage::Value::kBool:
-        ConvertBool(&value);
-        break;
-      case Storage::Value::kFloat:
-        ConvertFloat(&value);
-        break;
-      case Storage::Value::kDouble:
-        ConvertDouble(&value);
-        break;
-      default:
-        break;
+    try {
+      return JsonToWindow(wpi::json::parse(is), filename.c_str());
+    } catch (wpi::json::parse_error& e) {
+      ImGui::LogText("Error loading %s: %s", filename.c_str(), e.what());
+      return false;
     }
   }
 }
 
-static void GlassStorageWriteAll(ImGuiContext*, ImGuiSettingsHandler* handler,
-                                 ImGuiTextBuffer* out_buf) {
-  auto ctx = static_cast<Context*>(handler->UserData);
-
-  // sort for output
-  std::vector<wpi::StringMapConstIterator<std::unique_ptr<Storage>>> sorted;
-  for (auto it = ctx->storage.begin(); it != ctx->storage.end(); ++it) {
-    sorted.emplace_back(it);
+static bool LoadStorageRootImpl(Context* ctx, const std::string& filename,
+                                std::string_view rootName) {
+  std::error_code ec;
+  wpi::raw_fd_istream is{filename, ec};
+  if (ec) {
+    ImGui::LogText("error opening %s: %s", filename.c_str(),
+                   ec.message().c_str());
+    return false;
+  } else {
+    auto& storage = ctx->storageRoots[rootName];
+    bool createdStorage = false;
+    if (!storage) {
+      storage = std::make_unique<Storage>();
+      createdStorage = true;
+    }
+    try {
+      storage->FromJson(wpi::json::parse(is), filename.c_str());
+    } catch (wpi::json::parse_error& e) {
+      ImGui::LogText("Error loading %s: %s", filename.c_str(), e.what());
+      if (createdStorage) {
+        ctx->storageRoots.erase(rootName);
+      }
+      return false;
+    }
   }
-  std::sort(sorted.begin(), sorted.end(), [](const auto& a, const auto& b) {
-    return a->getKey() < b->getKey();
-  });
+  return true;
+}
 
-  for (auto&& entryIt : sorted) {
-    auto& entry = *entryIt;
-    out_buf->append("[GlassStorage][");
-    out_buf->append(entry.first().data(),
-                    entry.first().data() + entry.first().size());
-    out_buf->append("]\n");
-    auto& keys = entry.second->GetKeys();
-    auto& values = entry.second->GetValues();
-    for (size_t i = 0; i < keys.size(); ++i) {
-      out_buf->append(keys[i].data(), keys[i].data() + keys[i].size());
-      out_buf->append("=");
-      auto& value = *values[i];
-      switch (value.type) {
-        case Storage::Value::kInt:
-          out_buf->appendf("%d\n", value.intVal);
-          break;
-        case Storage::Value::kInt64:
-          out_buf->appendf("%" PRId64 "\n", value.int64Val);
-          break;
-        case Storage::Value::kBool:
-          out_buf->appendf("%d\n", value.boolVal ? 1 : 0);
-          break;
-        case Storage::Value::kFloat:
-          out_buf->appendf("%f\n", value.floatVal);
-          break;
-        case Storage::Value::kDouble:
-          out_buf->appendf("%f\n", value.doubleVal);
-          break;
-        case Storage::Value::kNone:
-        case Storage::Value::kString:
-          out_buf->append(value.stringVal.data(),
-                          value.stringVal.data() + value.stringVal.size());
-          out_buf->append("\n");
-          break;
+static bool LoadStorageImpl(Context* ctx, std::string_view dir,
+                            std::string_view name) {
+  WorkspaceResetImpl();
+
+  bool rv = true;
+  for (auto&& root : ctx->storageRoots) {
+    std::string filename;
+    auto rootName = root.getKey();
+    if (rootName.empty()) {
+      filename = (fs::path{dir} / fmt::format("{}.json", name)).string();
+    } else {
+      filename =
+          (fs::path{dir} / fmt::format("{}-{}.json", name, rootName)).string();
+    }
+    if (!LoadStorageRootImpl(ctx, filename, rootName)) {
+      rv = false;
+    }
+  }
+
+  WorkspaceInit();
+  return rv;
+}
+
+static wpi::json WindowToJson() {
+  size_t iniLen;
+  const char* iniData = ImGui::SaveIniSettingsToMemory(&iniLen);
+  std::string_view ini{iniData, iniLen};
+
+  // parse the ini data and build JSON
+  // JSON format:
+  // {
+  //   "Section": {
+  //     "Subsection": {
+  //       "Key": "Value"  // all values are saved as strings
+  //     }
+  //   }
+  // }
+
+  wpi::json out = wpi::json::object();
+  wpi::json* curSection = nullptr;
+  while (!ini.empty()) {
+    std::string_view line;
+    std::tie(line, ini) = wpi::split(ini, '\n');
+    line = wpi::trim(line);
+    if (line.empty()) {
+      continue;
+    }
+    if (line[0] == '[') {
+      // new section
+      auto [section, subsection] = wpi::split(line, ']');
+      section = wpi::drop_front(section);  // drop '['; ']' was dropped by split
+      subsection = wpi::drop_back(wpi::drop_front(subsection));  // drop []
+      auto& jsection = out[section];
+      if (jsection.is_null()) {
+        jsection = wpi::json::object();
+      }
+      curSection = &jsection[subsection];
+      if (curSection->is_null()) {
+        *curSection = wpi::json::object();
+      }
+    } else {
+      // value
+      if (!curSection) {
+        continue;  // shouldn't happen, but just in case
+      }
+      auto [name, value] = wpi::split(line, '=');
+      (*curSection)[name] = value;
+    }
+  }
+
+  return out;
+}
+
+bool SaveWindowStorageImpl(const std::string& filename) {
+  std::error_code ec;
+  wpi::raw_fd_ostream os{filename, ec};
+  if (ec) {
+    ImGui::LogText("error opening %s: %s", filename.c_str(),
+                   ec.message().c_str());
+    return false;
+  }
+  WindowToJson().dump(os, 2);
+  os << '\n';
+  return true;
+}
+
+static bool SaveStorageRootImpl(Context* ctx, const std::string& filename,
+                                const Storage& storage) {
+  std::error_code ec;
+  wpi::raw_fd_ostream os{filename, ec};
+  if (ec) {
+    ImGui::LogText("error opening %s: %s", filename.c_str(),
+                   ec.message().c_str());
+    return false;
+  }
+  storage.ToJson().dump(os, 2);
+  os << '\n';
+  return true;
+}
+
+static bool SaveStorageImpl(Context* ctx, std::string_view dir,
+                            std::string_view name, bool exiting) {
+  fs::path dirPath{dir};
+
+  std::error_code ec;
+  fs::create_directories(dirPath, ec);
+  if (ec) {
+    return false;
+  }
+
+  // handle erasing save files on exit if requested
+  if (exiting && wpi::gui::gContext->resetOnExit) {
+    fs::remove(dirPath / fmt::format("{}-window.json", name), ec);
+    for (auto&& root : ctx->storageRoots) {
+      auto rootName = root.getKey();
+      if (rootName.empty()) {
+        fs::remove(dirPath / fmt::format("{}.json", name), ec);
+      } else {
+        fs::remove(dirPath / fmt::format("{}-{}.json", name, rootName), ec);
       }
     }
-    out_buf->append("\n");
   }
+
+  bool rv = SaveWindowStorageImpl(
+      (dirPath / fmt::format("{}-window.json", name)).string());
+
+  for (auto&& root : ctx->storageRoots) {
+    auto rootName = root.getKey();
+    std::string filename;
+    if (rootName.empty()) {
+      filename = (dirPath / fmt::format("{}.json", name)).string();
+    } else {
+      filename = (dirPath / fmt::format("{}-{}.json", name, rootName)).string();
+    }
+    if (!SaveStorageRootImpl(ctx, filename, *root.getValue())) {
+      rv = false;
+    }
+  }
+  return rv;
 }
 
-static void Initialize(Context* ctx) {
-  wpi::gui::AddInit([=] {
-    ImGuiSettingsHandler ini_handler;
-    ini_handler.TypeName = "GlassStorage";
-    ini_handler.TypeHash = ImHashStr("GlassStorage");
-    ini_handler.ReadOpenFn = GlassStorageReadOpen;
-    ini_handler.ReadLineFn = GlassStorageReadLine;
-    ini_handler.WriteAllFn = GlassStorageWriteAll;
-    ini_handler.UserData = ctx;
-    ImGui::GetCurrentContext()->SettingsHandlers.push_back(ini_handler);
+Context::Context()
+    : sourceNameStorage{storageRoots.insert({"", std::make_unique<Storage>()})
+                            .first->getValue()
+                            ->GetChild("sourceNames")} {
+  storageStack.emplace_back(storageRoots[""].get());
 
-    ctx->sources.Initialize();
-  });
+  // override ImGui ini saving
+  wpi::gui::ConfigureCustomSaveSettings(
+      [this] { LoadStorageImpl(this, storageLoadDir, storageName); },
+      [this] {
+        LoadWindowStorageImpl((fs::path{storageLoadDir} /
+                               fmt::format("{}-window.json", storageName))
+                                  .string());
+      },
+      [this](bool exiting) {
+        SaveStorageImpl(this, storageAutoSaveDir, storageName, exiting);
+      });
 }
 
-static void Shutdown(Context* ctx) {}
+Context::~Context() {
+  wpi::gui::ConfigureCustomSaveSettings(nullptr, nullptr, nullptr);
+}
 
 Context* glass::CreateContext() {
   Context* ctx = new Context;
   if (!gContext) {
     SetCurrentContext(ctx);
   }
-  Initialize(ctx);
   return ctx;
 }
 
@@ -194,7 +322,6 @@ void glass::DestroyContext(Context* ctx) {
   if (!ctx) {
     ctx = gContext;
   }
-  Shutdown(ctx);
   if (gContext == ctx) {
     SetCurrentContext(nullptr);
   }
@@ -217,215 +344,167 @@ uint64_t glass::GetZeroTime() {
   return gContext->zeroTime;
 }
 
-Storage::Value& Storage::GetValue(std::string_view key) {
-  auto it = std::find(m_keys.begin(), m_keys.end(), key);
-  if (it == m_keys.end()) {
-    m_keys.emplace_back(key);
-    m_values.emplace_back(std::make_unique<Value>());
-    return *m_values.back();
-  } else {
-    return *m_values[it - m_keys.begin()];
+void glass::WorkspaceReset() {
+  WorkspaceResetImpl();
+  WorkspaceInit();
+}
+
+void glass::AddWorkspaceInit(std::function<void()> init) {
+  if (init) {
+    gContext->workspaceInit.emplace_back(std::move(init));
   }
 }
 
-#define DEFUN(CapsName, LowerName, CType)                                      \
-  CType Storage::Get##CapsName(std::string_view key, CType defaultVal) const { \
-    auto it = std::find(m_keys.begin(), m_keys.end(), key);                    \
-    if (it == m_keys.end())                                                    \
-      return defaultVal;                                                       \
-    Value& value = *m_values[it - m_keys.begin()];                             \
-    if (value.type != Value::k##CapsName) {                                    \
-      if (!Convert##CapsName(&value))                                          \
-        value.LowerName##Val = defaultVal;                                     \
-    }                                                                          \
-    return value.LowerName##Val;                                               \
-  }                                                                            \
-                                                                               \
-  void Storage::Set##CapsName(std::string_view key, CType val) {               \
-    auto it = std::find(m_keys.begin(), m_keys.end(), key);                    \
-    if (it == m_keys.end()) {                                                  \
-      m_keys.emplace_back(key);                                                \
-      m_values.emplace_back(std::make_unique<Value>());                        \
-      m_values.back()->type = Value::k##CapsName;                              \
-      m_values.back()->LowerName##Val = val;                                   \
-    } else {                                                                   \
-      Value& value = *m_values[it - m_keys.begin()];                           \
-      value.type = Value::k##CapsName;                                         \
-      value.LowerName##Val = val;                                              \
-    }                                                                          \
-  }                                                                            \
-                                                                               \
-  CType* Storage::Get##CapsName##Ref(std::string_view key, CType defaultVal) { \
-    auto it = std::find(m_keys.begin(), m_keys.end(), key);                    \
-    if (it == m_keys.end()) {                                                  \
-      m_keys.emplace_back(key);                                                \
-      m_values.emplace_back(std::make_unique<Value>());                        \
-      m_values.back()->type = Value::k##CapsName;                              \
-      m_values.back()->LowerName##Val = defaultVal;                            \
-      return &m_values.back()->LowerName##Val;                                 \
-    } else {                                                                   \
-      Value& value = *m_values[it - m_keys.begin()];                           \
-      if (value.type != Value::k##CapsName) {                                  \
-        if (!Convert##CapsName(&value))                                        \
-          value.LowerName##Val = defaultVal;                                   \
-      }                                                                        \
-      return &value.LowerName##Val;                                            \
-    }                                                                          \
-  }
-
-DEFUN(Int, int, int)
-DEFUN(Int64, int64, int64_t)
-DEFUN(Bool, bool, bool)
-DEFUN(Float, float, float)
-DEFUN(Double, double, double)
-
-std::string Storage::GetString(std::string_view key,
-                               std::string_view defaultVal) const {
-  auto it = std::find(m_keys.begin(), m_keys.end(), key);
-  if (it == m_keys.end()) {
-    return std::string{defaultVal};
-  }
-  Value& value = *m_values[it - m_keys.begin()];
-  value.type = Value::kString;
-  return value.stringVal;
-}
-
-void Storage::SetString(std::string_view key, std::string_view val) {
-  auto it = std::find(m_keys.begin(), m_keys.end(), key);
-  if (it == m_keys.end()) {
-    m_keys.emplace_back(key);
-    m_values.emplace_back(std::make_unique<Value>(val));
-    m_values.back()->type = Value::kString;
-  } else {
-    Value& value = *m_values[it - m_keys.begin()];
-    value.type = Value::kString;
-    value.stringVal = val;
+void glass::AddWorkspaceReset(std::function<void()> reset) {
+  if (reset) {
+    gContext->workspaceReset.emplace_back(std::move(reset));
   }
 }
 
-std::string* Storage::GetStringRef(std::string_view key,
-                                   std::string_view defaultVal) {
-  auto it = std::find(m_keys.begin(), m_keys.end(), key);
-  if (it == m_keys.end()) {
-    m_keys.emplace_back(key);
-    m_values.emplace_back(std::make_unique<Value>(defaultVal));
-    m_values.back()->type = Value::kString;
-    return &m_values.back()->stringVal;
+void glass::SetStorageName(std::string_view name) {
+  gContext->storageName = name;
+}
+
+void glass::SetStorageDir(std::string_view dir) {
+  if (dir.empty()) {
+    gContext->storageLoadDir = ".";
+    gContext->storageAutoSaveDir = ".";
   } else {
-    Value& value = *m_values[it - m_keys.begin()];
-    value.type = Value::kString;
-    return &value.stringVal;
+    gContext->storageLoadDir = dir;
+    gContext->storageAutoSaveDir = dir;
+    gContext->isPlatformSaveDir = (dir == wpi::gui::GetPlatformSaveFileDir());
   }
 }
 
+std::string glass::GetStorageDir() {
+  return gContext->storageAutoSaveDir;
+}
+
+bool glass::LoadStorage(std::string_view dir) {
+  SaveStorage();
+  SetStorageDir(dir);
+  LoadWindowStorageImpl((fs::path{gContext->storageLoadDir} /
+                         fmt::format("{}-window.json", gContext->storageName))
+                            .string());
+  return LoadStorageImpl(gContext, dir, gContext->storageName);
+}
+
+bool glass::SaveStorage() {
+  return SaveStorageImpl(gContext, gContext->storageAutoSaveDir,
+                         gContext->storageName, false);
+}
+
+bool glass::SaveStorage(std::string_view dir) {
+  return SaveStorageImpl(gContext, dir, gContext->storageName, false);
+}
+
+Storage& glass::GetCurStorageRoot() {
+  return *gContext->storageStack.front();
+}
+
+Storage& glass::GetStorageRoot(std::string_view rootName) {
+  auto& storage = gContext->storageRoots[rootName];
+  if (!storage) {
+    storage = std::make_unique<Storage>();
+  }
+  return *storage;
+}
+
+void glass::ResetStorageStack(std::string_view rootName) {
+  if (gContext->storageStack.size() != 1) {
+    ImGui::LogText("resetting non-empty storage stack");
+  }
+  gContext->storageStack.clear();
+  gContext->storageStack.emplace_back(&GetStorageRoot(rootName));
+}
+
 Storage& glass::GetStorage() {
-  auto& storage = gContext->storage[gContext->curId];
-  if (!storage) {
-    storage = std::make_unique<Storage>();
-  }
-  return *storage;
+  return *gContext->storageStack.back();
 }
 
-Storage& glass::GetStorage(std::string_view id) {
-  auto& storage = gContext->storage[id];
-  if (!storage) {
-    storage = std::make_unique<Storage>();
-  }
-  return *storage;
+void glass::PushStorageStack(std::string_view label_id) {
+  gContext->storageStack.emplace_back(
+      &gContext->storageStack.back()->GetChild(label_id));
 }
 
-static void PushIDStack(std::string_view label_id) {
-  gContext->idStack.emplace_back(gContext->curId.size());
-
-  auto [label, id] = wpi::split(label_id, "###");
-  // if no ###id, use label as id
-  if (id.empty()) {
-    id = label;
-  }
-  if (!gContext->curId.empty()) {
-    gContext->curId += "###";
-  }
-  gContext->curId += id;
+void glass::PushStorageStack(Storage& storage) {
+  gContext->storageStack.emplace_back(&storage);
 }
 
-static void PopIDStack() {
-  gContext->curId.resize(gContext->idStack.back());
-  gContext->idStack.pop_back();
+void glass::PopStorageStack() {
+  if (gContext->storageStack.size() <= 1) {
+    ImGui::LogText("attempted to pop empty storage stack, mismatch push/pop?");
+    return;  // ignore
+  }
+  gContext->storageStack.pop_back();
 }
 
 bool glass::Begin(const char* name, bool* p_open, ImGuiWindowFlags flags) {
-  PushIDStack(name);
+  PushStorageStack(name);
   return ImGui::Begin(name, p_open, flags);
 }
 
 void glass::End() {
   ImGui::End();
-  PopIDStack();
+  PopStorageStack();
 }
 
 bool glass::BeginChild(const char* str_id, const ImVec2& size, bool border,
                        ImGuiWindowFlags flags) {
-  PushIDStack(str_id);
+  PushStorageStack(str_id);
   return ImGui::BeginChild(str_id, size, border, flags);
 }
 
 void glass::EndChild() {
   ImGui::EndChild();
-  PopIDStack();
+  PopStorageStack();
 }
 
 bool glass::CollapsingHeader(const char* label, ImGuiTreeNodeFlags flags) {
-  wpi::SmallString<64> openKey;
-  auto [name, id] = wpi::split(label, "###");
-  // if no ###id, use name as id
-  if (id.empty()) {
-    id = name;
-  }
-  openKey = id;
-  openKey += "###open";
-
-  bool* open = GetStorage().GetBoolRef(openKey.str());
-  *open = ImGui::CollapsingHeader(
-      label, flags | (*open ? ImGuiTreeNodeFlags_DefaultOpen : 0));
-  return *open;
+  bool& open = GetStorage().GetChild(label).GetBool(
+      "open", (flags & ImGuiTreeNodeFlags_DefaultOpen) != 0);
+  ImGui::SetNextItemOpen(open);
+  open = ImGui::CollapsingHeader(label, flags);
+  return open;
 }
 
 bool glass::TreeNodeEx(const char* label, ImGuiTreeNodeFlags flags) {
-  PushIDStack(label);
-  bool* open = GetStorage().GetBoolRef("open");
-  *open = ImGui::TreeNodeEx(
-      label, flags | (*open ? ImGuiTreeNodeFlags_DefaultOpen : 0));
-  if (!*open) {
-    PopIDStack();
+  PushStorageStack(label);
+  bool& open = GetStorage().GetBool(
+      "open", (flags & ImGuiTreeNodeFlags_DefaultOpen) != 0);
+  ImGui::SetNextItemOpen(open);
+  open = ImGui::TreeNodeEx(label, flags);
+  if (!open) {
+    PopStorageStack();
   }
-  return *open;
+  return open;
 }
 
 void glass::TreePop() {
   ImGui::TreePop();
-  PopIDStack();
+  PopStorageStack();
 }
 
 void glass::PushID(const char* str_id) {
-  PushIDStack(str_id);
+  PushStorageStack(str_id);
   ImGui::PushID(str_id);
 }
 
 void glass::PushID(const char* str_id_begin, const char* str_id_end) {
-  PushIDStack(std::string_view(str_id_begin, str_id_end - str_id_begin));
+  PushStorageStack(std::string_view(str_id_begin, str_id_end - str_id_begin));
   ImGui::PushID(str_id_begin, str_id_end);
 }
 
 void glass::PushID(int int_id) {
   char buf[16];
   std::snprintf(buf, sizeof(buf), "%d", int_id);
-  PushIDStack(buf);
+  PushStorageStack(buf);
   ImGui::PushID(int_id);
 }
 
 void glass::PopID() {
   ImGui::PopID();
-  PopIDStack();
+  PopStorageStack();
 }
 
 bool glass::PopupEditName(const char* label, std::string* name) {

glass/src/lib/native/cpp/DataSource.cpp

@@ -12,13 +12,9 @@ using namespace glass;
 
 wpi::sig::Signal<const char*, DataSource*> DataSource::sourceCreated;
 
-DataSource::DataSource(std::string_view id) : m_id{id} {
-  auto it = gContext->sources.try_emplace(m_id, this);
-  auto& srcName = it.first->getValue();
-  m_name = srcName.name.get();
-  if (!srcName.source) {
-    srcName.source = this;
-  }
+DataSource::DataSource(std::string_view id)
+    : m_id{id}, m_name{gContext->sourceNameStorage.GetString(m_id)} {
+  gContext->sources.try_emplace(m_id, this);
   sourceCreated(m_id.c_str(), this);
 }
 
@@ -32,43 +28,7 @@ DataSource::~DataSource() {
   if (!gContext) {
     return;
   }
-  auto it = gContext->sources.find(m_id);
-  if (it == gContext->sources.end()) {
-    return;
-  }
-  auto& srcName = it->getValue();
-  if (srcName.source == this) {
-    srcName.source = nullptr;
-  }
-}
-
-void DataSource::SetName(std::string_view name) {
-  m_name->SetName(name);
-}
-
-const char* DataSource::GetName() const {
-  return m_name->GetName();
-}
-
-void DataSource::PushEditNameId(int index) {
-  m_name->PushEditNameId(index);
-}
-
-void DataSource::PushEditNameId(const char* name) {
-  m_name->PushEditNameId(name);
-}
-
-bool DataSource::PopupEditName(int index) {
-  return m_name->PopupEditName(index);
-}
-
-bool DataSource::PopupEditName(const char* name) {
-  return m_name->PopupEditName(name);
-}
-
-bool DataSource::InputTextName(const char* label_id,
-                               ImGuiInputTextFlags flags) {
-  return m_name->InputTextName(label_id, flags);
+  gContext->sources.erase(m_id);
 }
 
 void DataSource::LabelText(const char* label, const char* fmt, ...) const {
@@ -82,7 +42,7 @@ void DataSource::LabelText(const char* label, const char* fmt, ...) const {
 void DataSource::LabelTextV(const char* label, const char* fmt,
                             va_list args) const {
   ImGui::PushID(label);
-  ImGui::LabelTextV("##input", fmt, args);
+  ImGui::LabelTextV("##input", fmt, args);  // NOLINT
   ImGui::SameLine(0, ImGui::GetStyle().ItemInnerSpacing.x);
   ImGui::Selectable(label);
   ImGui::PopID();
@@ -141,7 +101,7 @@ void DataSource::EmitDrag(ImGuiDragDropFlags flags) const {
   if (ImGui::BeginDragDropSource(flags)) {
     auto self = this;
     ImGui::SetDragDropPayload("DataSource", &self, sizeof(self));  // NOLINT
-    const char* name = GetName();
+    const char* name = GetName().c_str();
     ImGui::TextUnformatted(name[0] == '\0' ? m_id.c_str() : name);
     ImGui::EndDragDropSource();
   }
@@ -152,5 +112,5 @@ DataSource* DataSource::Find(std::string_view id) {
   if (it == gContext->sources.end()) {
     return nullptr;
   }
-  return it->getValue().source;
+  return it->getValue();
 }

glass/src/lib/native/cpp/MainMenuBar.cpp

@@ -6,8 +6,12 @@
 
 #include <cstdio>
 
+#include <imgui.h>
 #include <wpigui.h>
 
+#include "glass/Context.h"
+#include "glass/ContextInternal.h"
+
 using namespace glass;
 
 void MainMenuBar::AddMainMenu(std::function<void()> menu) {
@@ -25,6 +29,8 @@ void MainMenuBar::AddOptionMenu(std::function<void()> menu) {
 void MainMenuBar::Display() {
   ImGui::BeginMainMenuBar();
 
+  WorkspaceMenu();
+
   if (!m_optionMenus.empty()) {
     if (ImGui::BeginMenu("Options")) {
       for (auto&& menu : m_optionMenus) {
@@ -55,3 +61,46 @@ void MainMenuBar::Display() {
 #endif
   ImGui::EndMainMenuBar();
 }
+
+void MainMenuBar::WorkspaceMenu() {
+  if (ImGui::BeginMenu("Workspace")) {
+    if (ImGui::MenuItem("Open...")) {
+      m_openFolder =
+          std::make_unique<pfd::select_folder>("Choose folder to open");
+    }
+    if (ImGui::MenuItem("Save As...")) {
+      m_saveFolder = std::make_unique<pfd::select_folder>("Choose save folder");
+    }
+    if (ImGui::MenuItem("Save As Global", nullptr, false,
+                        !gContext->isPlatformSaveDir)) {
+      SetStorageDir(wpi::gui::GetPlatformSaveFileDir());
+      SaveStorage();
+    }
+    ImGui::Separator();
+    if (ImGui::MenuItem("Reset")) {
+      WorkspaceReset();
+    }
+    ImGui::Separator();
+    if (ImGui::MenuItem("Exit")) {
+      wpi::gui::Exit();
+    }
+    ImGui::EndMenu();
+  }
+
+  if (m_openFolder && m_openFolder->ready(0)) {
+    auto result = m_openFolder->result();
+    if (!result.empty()) {
+      LoadStorage(result);
+    }
+    m_openFolder.reset();
+  }
+
+  if (m_saveFolder && m_saveFolder->ready(0)) {
+    auto result = m_saveFolder->result();
+    if (!result.empty()) {
+      SetStorageDir(result);
+      SaveStorage(result);
+    }
+    m_saveFolder.reset();
+  }
+}

glass/src/lib/native/cpp/Storage.cpp

@@ -0,0 +1,688 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "glass/Storage.h"
+
+#include <type_traits>
+
+#include <imgui.h>
+#include <wpi/StringExtras.h>
+#include <wpi/json.h>
+
+using namespace glass;
+
+template <typename To>
+bool ConvertFromString(To* out, std::string_view str) {
+  if constexpr (std::is_same_v<To, bool>) {
+    if (str == "true") {
+      *out = true;
+    } else if (str == "false") {
+      *out = false;
+    } else if (auto val = wpi::parse_integer<int>(str, 10)) {
+      *out = val.value() != 0;
+    } else {
+      return false;
+    }
+  } else if constexpr (std::is_floating_point_v<To>) {
+    if (auto val = wpi::parse_float<To>(str)) {
+      *out = val.value();
+    } else {
+      return false;
+    }
+  } else {
+    if (auto val = wpi::parse_integer<To>(str, 10)) {
+      *out = val.value();
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+
+#define CONVERT(CapsName, LowerName, CType)                                 \
+  static bool Convert##CapsName(Storage::Value* value) {                    \
+    switch (value->type) {                                                  \
+      case Storage::Value::kBool:                                           \
+        value->LowerName##Val = value->boolVal;                             \
+        value->LowerName##Default = value->boolDefault;                     \
+        break;                                                              \
+      case Storage::Value::kDouble:                                         \
+        value->LowerName##Val = value->doubleVal;                           \
+        value->LowerName##Default = value->doubleDefault;                   \
+        break;                                                              \
+      case Storage::Value::kFloat:                                          \
+        value->LowerName##Val = value->floatVal;                            \
+        value->LowerName##Default = value->floatDefault;                    \
+        break;                                                              \
+      case Storage::Value::kInt:                                            \
+        value->LowerName##Val = value->intVal;                              \
+        value->LowerName##Default = value->intDefault;                      \
+        break;                                                              \
+      case Storage::Value::kInt64:                                          \
+        value->LowerName##Val = value->int64Val;                            \
+        value->LowerName##Default = value->int64Default;                    \
+        break;                                                              \
+      case Storage::Value::kString:                                         \
+        if (!ConvertFromString(&value->LowerName##Val, value->stringVal)) { \
+          return false;                                                     \
+        }                                                                   \
+        if (!ConvertFromString(&value->LowerName##Default,                  \
+                               value->stringDefault)) {                     \
+          return false;                                                     \
+        }                                                                   \
+        break;                                                              \
+      default:                                                              \
+        return false;                                                       \
+    }                                                                       \
+    value->type = Storage::Value::k##CapsName;                              \
+    return true;                                                            \
+  }
+
+CONVERT(Int, int, int)
+CONVERT(Int64, int64, int64_t)
+CONVERT(Float, float, float)
+CONVERT(Double, double, double)
+CONVERT(Bool, bool, bool)
+
+static inline bool ConvertString(Storage::Value* value) {
+  return false;
+}
+
+// Arrays can only come from JSON, so we only have to worry about conversions
+// between the various number types, not bool or string
+
+template <typename From, typename To>
+static void ConvertArray(std::vector<To>** outPtr, std::vector<From>** inPtr) {
+  if (*inPtr) {
+    std::vector<To>* tmp;
+    tmp = new std::vector<To>{(*inPtr)->begin(), (*inPtr)->end()};
+    delete *inPtr;
+    *outPtr = tmp;
+  } else {
+    *outPtr = nullptr;
+  }
+}
+
+#define CONVERT_ARRAY(CapsName, LowerName)                           \
+  static bool Convert##CapsName##Array(Storage::Value* value) {      \
+    switch (value->type) {                                           \
+      case Storage::Value::kDoubleArray:                             \
+        ConvertArray(&value->LowerName##Array, &value->doubleArray); \
+        ConvertArray(&value->LowerName##ArrayDefault,                \
+                     &value->doubleArrayDefault);                    \
+        break;                                                       \
+      case Storage::Value::kFloatArray:                              \
+        ConvertArray(&value->LowerName##Array, &value->floatArray);  \
+        ConvertArray(&value->LowerName##ArrayDefault,                \
+                     &value->floatArrayDefault);                     \
+        break;                                                       \
+      case Storage::Value::kIntArray:                                \
+        ConvertArray(&value->LowerName##Array, &value->intArray);    \
+        ConvertArray(&value->LowerName##ArrayDefault,                \
+                     &value->intArrayDefault);                       \
+        break;                                                       \
+      case Storage::Value::kInt64Array:                              \
+        ConvertArray(&value->LowerName##Array, &value->int64Array);  \
+        ConvertArray(&value->LowerName##ArrayDefault,                \
+                     &value->int64ArrayDefault);                     \
+        break;                                                       \
+      default:                                                       \
+        return false;                                                \
+    }                                                                \
+    value->type = Storage::Value::k##CapsName##Array;                \
+    return true;                                                     \
+  }
+
+CONVERT_ARRAY(Int, int)
+CONVERT_ARRAY(Int64, int64)
+CONVERT_ARRAY(Float, float)
+CONVERT_ARRAY(Double, double)
+
+static inline bool ConvertBoolArray(Storage::Value* value) {
+  return false;
+}
+
+static inline bool ConvertStringArray(Storage::Value* value) {
+  return false;
+}
+
+void Storage::Value::Reset(Type newType) {
+  switch (type) {
+    case kChild:
+      delete child;
+      break;
+    case kIntArray:
+      delete intArray;
+      delete intArrayDefault;
+      break;
+    case kInt64Array:
+      delete int64Array;
+      delete int64ArrayDefault;
+      break;
+    case kBoolArray:
+      delete boolArray;
+      delete boolArrayDefault;
+      break;
+    case kFloatArray:
+      delete floatArray;
+      delete floatArrayDefault;
+      break;
+    case kDoubleArray:
+      delete doubleArray;
+      delete doubleArrayDefault;
+      break;
+    case kStringArray:
+      delete stringArray;
+      delete stringArrayDefault;
+      break;
+    case kChildArray:
+      delete childArray;
+      break;
+    default:
+      break;
+  }
+  type = newType;
+}
+
+Storage::Value* Storage::FindValue(std::string_view key) {
+  auto it = m_values.find(key);
+  if (it == m_values.end()) {
+    return nullptr;
+  }
+  return it->second.get();
+}
+
+Storage::Value& Storage::GetValue(std::string_view key) {
+  auto& val = m_values[key];
+  if (!val) {
+    val = std::make_unique<Value>();
+  }
+  return *val;
+}
+
+#define DEFUN(CapsName, LowerName, CType, CParamType, ArrCType)                \
+  CType Storage::Read##CapsName(std::string_view key, CParamType defaultVal)   \
+      const {                                                                  \
+    auto it = m_values.find(key);                                              \
+    if (it == m_values.end()) {                                                \
+      return CType{defaultVal};                                                \
+    }                                                                          \
+    Value& value = *it->second;                                                \
+    if (value.type != Value::k##CapsName) {                                    \
+      if (!Convert##CapsName(&value)) {                                        \
+        value.Reset(Value::k##CapsName);                                       \
+        value.LowerName##Val = defaultVal;                                     \
+        value.LowerName##Default = defaultVal;                                 \
+        value.hasDefault = true;                                               \
+      }                                                                        \
+    }                                                                          \
+    return value.LowerName##Val;                                               \
+  }                                                                            \
+                                                                               \
+  void Storage::Set##CapsName(std::string_view key, CParamType val) {          \
+    auto& valuePtr = m_values[key];                                            \
+    if (!valuePtr) {                                                           \
+      valuePtr = std::make_unique<Value>(Value::k##CapsName);                  \
+    } else {                                                                   \
+      valuePtr->Reset(Value::k##CapsName);                                     \
+    }                                                                          \
+    valuePtr->LowerName##Val = val;                                            \
+    valuePtr->LowerName##Default = {};                                         \
+  }                                                                            \
+                                                                               \
+  CType& Storage::Get##CapsName(std::string_view key, CParamType defaultVal) { \
+    auto& valuePtr = m_values[key];                                            \
+    bool setValue = false;                                                     \
+    if (!valuePtr) {                                                           \
+      valuePtr = std::make_unique<Value>(Value::k##CapsName);                  \
+      setValue = true;                                                         \
+    } else if (valuePtr->type != Value::k##CapsName) {                         \
+      if (!Convert##CapsName(valuePtr.get())) {                                \
+        valuePtr->Reset(Value::k##CapsName);                                   \
+        setValue = true;                                                       \
+      }                                                                        \
+    }                                                                          \
+    if (setValue) {                                                            \
+      valuePtr->LowerName##Val = defaultVal;                                   \
+    }                                                                          \
+    if (!valuePtr->hasDefault) {                                               \
+      valuePtr->LowerName##Default = defaultVal;                               \
+      valuePtr->hasDefault = true;                                             \
+    }                                                                          \
+    return valuePtr->LowerName##Val;                                           \
+  }                                                                            \
+                                                                               \
+  std::vector<ArrCType>& Storage::Get##CapsName##Array(                        \
+      std::string_view key, wpi::span<const ArrCType> defaultVal) {            \
+    auto& valuePtr = m_values[key];                                            \
+    bool setValue = false;                                                     \
+    if (!valuePtr) {                                                           \
+      valuePtr = std::make_unique<Value>(Value::k##CapsName##Array);           \
+      setValue = true;                                                         \
+    } else if (valuePtr->type != Value::k##CapsName##Array) {                  \
+      if (!Convert##CapsName##Array(valuePtr.get())) {                         \
+        valuePtr->Reset(Value::k##CapsName##Array);                            \
+        setValue = true;                                                       \
+      }                                                                        \
+    }                                                                          \
+    if (setValue) {                                                            \
+      valuePtr->LowerName##Array =                                             \
+          new std::vector<ArrCType>{defaultVal.begin(), defaultVal.end()};     \
+    }                                                                          \
+    if (!valuePtr->hasDefault) {                                               \
+      if (defaultVal.empty()) {                                                \
+        valuePtr->LowerName##ArrayDefault = nullptr;                           \
+      } else {                                                                 \
+        valuePtr->LowerName##ArrayDefault =                                    \
+            new std::vector<ArrCType>{defaultVal.begin(), defaultVal.end()};   \
+      }                                                                        \
+      valuePtr->hasDefault = true;                                             \
+    }                                                                          \
+    assert(valuePtr->LowerName##Array);                                        \
+    return *valuePtr->LowerName##Array;                                        \
+  }
+
+DEFUN(Int, int, int, int, int)
+DEFUN(Int64, int64, int64_t, int64_t, int64_t)
+DEFUN(Bool, bool, bool, bool, int)
+DEFUN(Float, float, float, float, float)
+DEFUN(Double, double, double, double, double)
+DEFUN(String, string, std::string, std::string_view, std::string)
+
+Storage& Storage::GetChild(std::string_view label_id) {
+  auto [label, id] = wpi::split(label_id, "###");
+  if (id.empty()) {
+    id = label;
+  }
+  auto& childPtr = m_values[id];
+  if (!childPtr) {
+    childPtr = std::make_unique<Value>();
+  }
+  if (childPtr->type != Value::kChild) {
+    childPtr->type = Value::kChild;
+    childPtr->child = new Storage;
+  }
+  return *childPtr->child;
+}
+
+std::vector<std::unique_ptr<Storage>>& Storage::GetChildArray(
+    std::string_view key) {
+  auto& valuePtr = m_values[key];
+  if (!valuePtr) {
+    valuePtr = std::make_unique<Value>(Value::kChildArray);
+    valuePtr->childArray = new std::vector<std::unique_ptr<Storage>>();
+  } else if (valuePtr->type != Value::kChildArray) {
+    valuePtr->Reset(Value::kChildArray);
+    valuePtr->childArray = new std::vector<std::unique_ptr<Storage>>();
+  }
+
+  return *valuePtr->childArray;
+}
+
+std::unique_ptr<Storage::Value> Storage::Erase(std::string_view key) {
+  auto it = m_values.find(key);
+  if (it != m_values.end()) {
+    auto rv = std::move(it->getValue());
+    m_values.erase(it);
+    return rv;
+  }
+  return nullptr;
+}
+
+void Storage::EraseChildren() {
+  for (auto&& kv : m_values) {
+    if (kv.getValue()->type == Value::kChild) {
+      m_values.remove(&kv);
+    }
+  }
+}
+
+static bool JsonArrayToStorage(Storage::Value* valuePtr, const wpi::json& jarr,
+                               const char* filename) {
+  auto& arr = jarr.get_ref<const wpi::json::array_t&>();
+  if (arr.empty()) {
+    ImGui::LogText("empty array in %s, ignoring", filename);
+    return false;
+  }
+
+  // guess array type from first element
+  switch (arr[0].type()) {
+    case wpi::json::value_t::boolean:
+      if (valuePtr->type != Storage::Value::kBoolArray) {
+        valuePtr->Reset(Storage::Value::kBoolArray);
+        valuePtr->boolArray = new std::vector<int>();
+        valuePtr->boolArrayDefault = nullptr;
+      }
+      break;
+    case wpi::json::value_t::number_float:
+      if (valuePtr->type != Storage::Value::kDoubleArray) {
+        valuePtr->Reset(Storage::Value::kDoubleArray);
+        valuePtr->doubleArray = new std::vector<double>();
+        valuePtr->doubleArrayDefault = nullptr;
+      }
+      break;
+    case wpi::json::value_t::number_integer:
+    case wpi::json::value_t::number_unsigned:
+      if (valuePtr->type != Storage::Value::kInt64Array) {
+        valuePtr->Reset(Storage::Value::kInt64Array);
+        valuePtr->int64Array = new std::vector<int64_t>();
+        valuePtr->int64ArrayDefault = nullptr;
+      }
+      break;
+    case wpi::json::value_t::string:
+      if (valuePtr->type != Storage::Value::kStringArray) {
+        valuePtr->Reset(Storage::Value::kStringArray);
+        valuePtr->stringArray = new std::vector<std::string>();
+        valuePtr->stringArrayDefault = nullptr;
+      }
+      break;
+    case wpi::json::value_t::object:
+      if (valuePtr->type != Storage::Value::kChildArray) {
+        valuePtr->Reset(Storage::Value::kChildArray);
+        valuePtr->childArray = new std::vector<std::unique_ptr<Storage>>();
+      }
+      break;
+    case wpi::json::value_t::array:
+      ImGui::LogText("nested array in %s, ignoring", filename);
+      return false;
+    default:
+      ImGui::LogText("null value in %s, ignoring", filename);
+      return false;
+  }
+
+  // loop over array to store elements
+  for (auto jvalue : arr) {
+    switch (jvalue.type()) {
+      case wpi::json::value_t::boolean:
+        if (valuePtr->type == Storage::Value::kBoolArray) {
+          valuePtr->boolArray->push_back(jvalue.get<bool>());
+        } else {
+          goto error;
+        }
+        break;
+      case wpi::json::value_t::number_float:
+        if (valuePtr->type == Storage::Value::kDoubleArray) {
+          valuePtr->doubleArray->push_back(jvalue.get<double>());
+        } else {
+          goto error;
+        }
+        break;
+      case wpi::json::value_t::number_integer:
+        if (valuePtr->type == Storage::Value::kInt64Array) {
+          valuePtr->int64Array->push_back(jvalue.get<int64_t>());
+        } else if (valuePtr->type == Storage::Value::kDoubleArray) {
+          valuePtr->doubleArray->push_back(jvalue.get<int64_t>());
+        } else {
+          goto error;
+        }
+        break;
+      case wpi::json::value_t::number_unsigned:
+        if (valuePtr->type == Storage::Value::kInt64Array) {
+          valuePtr->int64Array->push_back(jvalue.get<uint64_t>());
+        } else if (valuePtr->type == Storage::Value::kDoubleArray) {
+          valuePtr->doubleArray->push_back(jvalue.get<uint64_t>());
+        } else {
+          goto error;
+        }
+        break;
+      case wpi::json::value_t::string:
+        if (valuePtr->type == Storage::Value::kStringArray) {
+          valuePtr->stringArray->emplace_back(
+              jvalue.get_ref<const std::string&>());
+        } else {
+          goto error;
+        }
+        break;
+      case wpi::json::value_t::object:
+        if (valuePtr->type == Storage::Value::kChildArray) {
+          valuePtr->childArray->emplace_back(std::make_unique<Storage>());
+          valuePtr->childArray->back()->FromJson(jvalue, filename);
+        } else {
+          goto error;
+        }
+        break;
+      case wpi::json::value_t::array:
+        ImGui::LogText("nested array in %s, ignoring", filename);
+        return false;
+      default:
+        ImGui::LogText("null value in %s, ignoring", filename);
+        return false;
+    }
+  }
+  return true;
+
+error:
+  ImGui::LogText("array with variant types in %s, ignoring", filename);
+  return false;
+}
+
+bool Storage::FromJson(const wpi::json& json, const char* filename) {
+  if (m_fromJson) {
+    return m_fromJson(json, filename);
+  }
+
+  if (!json.is_object()) {
+    ImGui::LogText("non-object in %s", filename);
+    return false;
+  }
+  for (auto&& jkv : json.items()) {
+    auto& valuePtr = m_values[jkv.key()];
+    bool created = false;
+    if (!valuePtr) {
+      valuePtr = std::make_unique<Value>();
+      created = true;
+    }
+    auto& jvalue = jkv.value();
+    switch (jvalue.type()) {
+      case wpi::json::value_t::boolean:
+        valuePtr->Reset(Value::kBool);
+        valuePtr->boolVal = jvalue.get<bool>();
+        break;
+      case wpi::json::value_t::number_float:
+        valuePtr->Reset(Value::kDouble);
+        valuePtr->doubleVal = jvalue.get<double>();
+        break;
+      case wpi::json::value_t::number_integer:
+        valuePtr->Reset(Value::kInt64);
+        valuePtr->int64Val = jvalue.get<int64_t>();
+        break;
+      case wpi::json::value_t::number_unsigned:
+        valuePtr->Reset(Value::kInt64);
+        valuePtr->int64Val = jvalue.get<uint64_t>();
+        break;
+      case wpi::json::value_t::string:
+        valuePtr->Reset(Value::kString);
+        valuePtr->stringVal = jvalue.get_ref<const std::string&>();
+        break;
+      case wpi::json::value_t::object:
+        if (valuePtr->type != Value::kChild) {
+          valuePtr->Reset(Value::kChild);
+          valuePtr->child = new Storage;
+        }
+        valuePtr->child->FromJson(jvalue, filename);  // recurse
+        break;
+      case wpi::json::value_t::array:
+        if (!JsonArrayToStorage(valuePtr.get(), jvalue, filename)) {
+          if (created) {
+            m_values.erase(jkv.key());
+          }
+        }
+        break;
+      default:
+        ImGui::LogText("null value in %s, ignoring", filename);
+        if (created) {
+          m_values.erase(jkv.key());
+        }
+        break;
+    }
+  }
+  return true;
+}
+
+template <typename T>
+static wpi::json StorageToJsonArray(const std::vector<T>& arr) {
+  wpi::json jarr = wpi::json::array();
+  for (auto&& v : arr) {
+    jarr.emplace_back(v);
+  }
+  return jarr;
+}
+
+template <>
+wpi::json StorageToJsonArray<std::unique_ptr<Storage>>(
+    const std::vector<std::unique_ptr<Storage>>& arr) {
+  wpi::json jarr = wpi::json::array();
+  for (auto&& v : arr) {
+    jarr.emplace_back(v->ToJson());
+  }
+  // remove any trailing empty items
+  while (!jarr.empty() && jarr.back().empty()) {
+    jarr.get_ref<wpi::json::array_t&>().pop_back();
+  }
+  return jarr;
+}
+
+wpi::json Storage::ToJson() const {
+  if (m_toJson) {
+    return m_toJson();
+  }
+
+  wpi::json j = wpi::json::object();
+  for (auto&& kv : m_values) {
+    wpi::json jelem;
+    auto& value = *kv.getValue();
+    switch (value.type) {
+#define CASE(CapsName, LowerName)                                        \
+  case Value::k##CapsName:                                               \
+    if (value.hasDefault &&                                              \
+        value.LowerName##Val == value.LowerName##Default) {              \
+      continue;                                                          \
+    }                                                                    \
+    jelem = value.LowerName##Val;                                        \
+    break;                                                               \
+  case Value::k##CapsName##Array:                                        \
+    if (value.hasDefault &&                                              \
+        ((!value.LowerName##ArrayDefault &&                              \
+          value.LowerName##Array->empty()) ||                            \
+         (value.LowerName##ArrayDefault &&                               \
+          *value.LowerName##Array == *value.LowerName##ArrayDefault))) { \
+      continue;                                                          \
+    }                                                                    \
+    jelem = StorageToJsonArray(*value.LowerName##Array);                 \
+    break;
+
+      CASE(Int, int)
+      CASE(Int64, int64)
+      CASE(Bool, bool)
+      CASE(Float, float)
+      CASE(Double, double)
+      CASE(String, string)
+
+      case Value::kChild:
+        jelem = value.child->ToJson();  // recurse
+        if (jelem.empty()) {
+          continue;
+        }
+        break;
+      case Value::kChildArray:
+        jelem = StorageToJsonArray(*value.childArray);
+        if (jelem.empty()) {
+          continue;
+        }
+        break;
+      default:
+        continue;
+    }
+    j.emplace(kv.getKey(), std::move(jelem));
+  }
+  return j;
+}
+
+void Storage::Clear() {
+  if (m_clear) {
+    return m_clear();
+  }
+
+  ClearValues();
+}
+
+void Storage::ClearValues() {
+  for (auto&& kv : m_values) {
+    auto& value = *kv.getValue();
+    switch (value.type) {
+      case Value::kInt:
+        value.intVal = value.intDefault;
+        break;
+      case Value::kInt64:
+        value.int64Val = value.int64Default;
+        break;
+      case Value::kBool:
+        value.boolVal = value.boolDefault;
+        break;
+      case Value::kFloat:
+        value.floatVal = value.floatDefault;
+        break;
+      case Value::kDouble:
+        value.doubleVal = value.doubleDefault;
+        break;
+      case Value::kString:
+        value.stringVal = value.stringDefault;
+        break;
+      case Value::kIntArray:
+        *value.intArray = *value.intArrayDefault;
+        break;
+      case Value::kInt64Array:
+        *value.int64Array = *value.int64ArrayDefault;
+        break;
+      case Value::kBoolArray:
+        *value.boolArray = *value.boolArrayDefault;
+        break;
+      case Value::kFloatArray:
+        *value.floatArray = *value.floatArrayDefault;
+        break;
+      case Value::kDoubleArray:
+        *value.doubleArray = *value.doubleArrayDefault;
+        break;
+      case Value::kStringArray:
+        *value.stringArray = *value.stringArrayDefault;
+        break;
+      case Value::kChild:
+        value.child->Clear();
+        break;
+      case Value::kChildArray:
+        for (auto&& child : *value.childArray) {
+          child->Clear();
+        }
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+void Storage::Apply() {
+  if (m_apply) {
+    return m_apply();
+  }
+
+  ApplyChildren();
+}
+
+void Storage::ApplyChildren() {
+  for (auto&& kv : m_values) {
+    auto& value = *kv.getValue();
+    switch (value.type) {
+      case Value::kChild:
+        value.child->Apply();
+        break;
+      case Value::kChildArray:
+        for (auto&& child : *value.childArray) {
+          child->Apply();
+        }
+        break;
+      default:
+        break;
+    }
+  }
+}

glass/src/lib/native/cpp/Window.cpp

@@ -8,23 +8,28 @@
 #include <wpi/StringExtras.h>
 
 #include "glass/Context.h"
+#include "glass/Storage.h"
 
 using namespace glass;
 
+Window::Window(Storage& storage, std::string_view id,
+               Visibility defaultVisibility)
+    : m_id{id},
+      m_name{storage.GetString("name")},
+      m_defaultName{id},
+      m_visible{storage.GetBool("visible", defaultVisibility != kHide)},
+      m_enabled{storage.GetBool("enabled", defaultVisibility != kDisabled)},
+      m_defaultVisible{storage.GetValue("visible").boolDefault},
+      m_defaultEnabled{storage.GetValue("enabled").boolDefault} {}
+
 void Window::SetVisibility(Visibility visibility) {
-  switch (visibility) {
-    case kHide:
-      m_visible = false;
-      m_enabled = true;
-      break;
-    case kShow:
-      m_visible = true;
-      m_enabled = true;
-      break;
-    case kDisabled:
-      m_enabled = false;
-      break;
-  }
+  m_visible = visibility != kHide;
+  m_enabled = visibility != kDisabled;
+}
+
+void Window::SetDefaultVisibility(Visibility visibility) {
+  m_defaultVisible = visibility != kHide;
+  m_defaultEnabled = visibility != kDisabled;
 }
 
 void Window::Display() {
@@ -85,27 +90,3 @@ void Window::ScaleDefault(float scale) {
     m_size.y *= scale;
   }
 }
-
-void Window::IniReadLine(const char* line) {
-  auto [name, value] = wpi::split(line, '=');
-  name = wpi::trim(name);
-  value = wpi::trim(value);
-
-  if (name == "name") {
-    m_name = value;
-  } else if (name == "visible") {
-    if (auto num = wpi::parse_integer<int>(value, 10)) {
-      m_visible = num.value();
-    }
-  } else if (name == "enabled") {
-    if (auto num = wpi::parse_integer<int>(value, 10)) {
-      m_enabled = num.value();
-    }
-  }
-}
-
-void Window::IniWriteAll(const char* typeName, ImGuiTextBuffer* out_buf) {
-  out_buf->appendf("[%s][%s]\nname=%s\nvisible=%d\nenabled=%d\n\n", typeName,
-                   m_id.c_str(), m_name.c_str(), m_visible ? 1 : 0,
-                   m_enabled ? 1 : 0);
-}

glass/src/lib/native/cpp/WindowManager.cpp

@@ -10,30 +10,23 @@
 #include <fmt/format.h>
 #include <wpigui.h>
 
+#include "glass/Context.h"
+#include "glass/Storage.h"
+
 using namespace glass;
 
-WindowManager::WindowManager(std::string_view iniName)
-    : m_iniSaver{iniName, this} {}
-
-// read/write open state to ini file
-void* WindowManager::IniSaver::IniReadOpen(const char* name) {
-  return m_manager->GetOrAddWindow(name, true);
-}
-
-void WindowManager::IniSaver::IniReadLine(void* entry, const char* lineStr) {
-  static_cast<Window*>(entry)->IniReadLine(lineStr);
-}
-
-void WindowManager::IniSaver::IniWriteAll(ImGuiTextBuffer* out_buf) {
-  const char* typeName = GetTypeName();
-  for (auto&& window : m_manager->m_windows) {
-    window->IniWriteAll(typeName, out_buf);
-  }
+WindowManager::WindowManager(Storage& storage) : m_storage{storage} {
+  storage.SetCustomApply([this] {
+    for (auto&& childIt : m_storage.GetChildren()) {
+      GetOrAddWindow(childIt.key(), true);
+    }
+  });
 }
 
 Window* WindowManager::AddWindow(std::string_view id,
-                                 wpi::unique_function<void()> display) {
-  auto win = GetOrAddWindow(id, false);
+                                 wpi::unique_function<void()> display,
+                                 Window::Visibility defaultVisibility) {
+  auto win = GetOrAddWindow(id, false, defaultVisibility);
   if (!win) {
     return nullptr;
   }
@@ -46,8 +39,9 @@ Window* WindowManager::AddWindow(std::string_view id,
 }
 
 Window* WindowManager::AddWindow(std::string_view id,
-                                 std::unique_ptr<View> view) {
-  auto win = GetOrAddWindow(id, false);
+                                 std::unique_ptr<View> view,
+                                 Window::Visibility defaultVisibility) {
+  auto win = GetOrAddWindow(id, false, defaultVisibility);
   if (!win) {
     return nullptr;
   }
@@ -59,7 +53,8 @@ Window* WindowManager::AddWindow(std::string_view id,
   return win;
 }
 
-Window* WindowManager::GetOrAddWindow(std::string_view id, bool duplicateOk) {
+Window* WindowManager::GetOrAddWindow(std::string_view id, bool duplicateOk,
+                                      Window::Visibility defaultVisibility) {
   // binary search
   auto it = std::lower_bound(
       m_windows.begin(), m_windows.end(), id,
@@ -72,7 +67,11 @@ Window* WindowManager::GetOrAddWindow(std::string_view id, bool duplicateOk) {
     return it->get();
   }
   // insert before (keeps sort)
-  return m_windows.emplace(it, std::make_unique<Window>(id))->get();
+  return m_windows
+      .emplace(it, std::make_unique<Window>(
+                       m_storage.GetChild(id).GetChild("window"), id,
+                       defaultVisibility))
+      ->get();
 }
 
 Window* WindowManager::GetWindow(std::string_view id) {
@@ -86,8 +85,12 @@ Window* WindowManager::GetWindow(std::string_view id) {
   return it->get();
 }
 
+void WindowManager::RemoveWindow(size_t index) {
+  m_storage.Erase(m_windows[index]->GetId());
+  m_windows.erase(m_windows.begin() + index);
+}
+
 void WindowManager::GlobalInit() {
-  wpi::gui::AddInit([this] { m_iniSaver.Initialize(); });
   wpi::gui::AddWindowScaler([this](float scale) {
     // scale default window positions
     for (auto&& window : m_windows) {
@@ -104,7 +107,9 @@ void WindowManager::DisplayMenu() {
 }
 
 void WindowManager::DisplayWindows() {
+  PushStorageStack(m_storage);
   for (auto&& window : m_windows) {
     window->Display();
   }
+  PopStorageStack();
 }

glass/src/lib/native/cpp/hardware/AnalogInput.cpp

@@ -8,6 +8,7 @@
 
 #include "glass/Context.h"
 #include "glass/DataSource.h"
+#include "glass/Storage.h"
 
 using namespace glass;
 
@@ -18,10 +19,10 @@ void glass::DisplayAnalogInput(AnalogInputModel* model, int index) {
   }
 
   // build label
-  std::string* name = GetStorage().GetStringRef("name");
+  std::string& name = GetStorage().GetString("name");
   char label[128];
-  if (!name->empty()) {
-    std::snprintf(label, sizeof(label), "%s [%d]###name", name->c_str(), index);
+  if (!name.empty()) {
+    std::snprintf(label, sizeof(label), "%s [%d]###name", name.c_str(), index);
   } else {
     std::snprintf(label, sizeof(label), "In[%d]###name", index);
   }
@@ -42,8 +43,8 @@ void glass::DisplayAnalogInput(AnalogInputModel* model, int index) {
   }
 
   // context menu to change name
-  if (PopupEditName("name", name)) {
-    voltageData->SetName(name->c_str());
+  if (PopupEditName("name", &name)) {
+    voltageData->SetName(name);
   }
 }
 

glass/src/lib/native/cpp/hardware/AnalogOutput.cpp

@@ -6,6 +6,7 @@
 
 #include "glass/Context.h"
 #include "glass/DataSource.h"
+#include "glass/Storage.h"
 #include "glass/other/DeviceTree.h"
 
 using namespace glass;
@@ -26,10 +27,10 @@ void glass::DisplayAnalogOutputsDevice(AnalogOutputsModel* model) {
       PushID(i);
 
       // build label
-      std::string* name = GetStorage().GetStringRef("name");
+      std::string& name = GetStorage().GetString("name");
       char label[128];
-      if (!name->empty()) {
-        std::snprintf(label, sizeof(label), "%s [%d]###name", name->c_str(), i);
+      if (!name.empty()) {
+        std::snprintf(label, sizeof(label), "%s [%d]###name", name.c_str(), i);
       } else {
         std::snprintf(label, sizeof(label), "Out[%d]###name", i);
       }
@@ -37,9 +38,9 @@ void glass::DisplayAnalogOutputsDevice(AnalogOutputsModel* model) {
       double value = analogOutData->GetValue();
       DeviceDouble(label, true, &value, analogOutData);
 
-      if (PopupEditName("name", name)) {
+      if (PopupEditName("name", &name)) {
         if (analogOutData) {
-          analogOutData->SetName(name->c_str());
+          analogOutData->SetName(name);
         }
       }
       PopID();

glass/src/lib/native/cpp/hardware/DIO.cpp

@@ -8,7 +8,7 @@
 
 #include "glass/DataSource.h"
 #include "glass/hardware/Encoder.h"
-#include "glass/support/IniSaverInfo.h"
+#include "glass/support/NameSetting.h"
 
 using namespace glass;
 
@@ -28,17 +28,18 @@ void DisplayDIOImpl(DIOModel* model, int index, bool outputsEnabled) {
   auto dutyCycleData = dutyCycle ? dutyCycle->GetValueData() : nullptr;
 
   bool exists = model->Exists();
-  auto& info = dioData->GetNameInfo();
+  NameSetting dioName{dioData->GetName()};
   char label[128];
   if (exists && dpwmData) {
-    dpwmData->GetNameInfo().GetLabel(label, sizeof(label), "PWM", index);
+    NameSetting{dpwmData->GetName()}.GetLabel(label, sizeof(label), "PWM",
+                                              index);
     if (auto simDevice = dpwm->GetSimDevice()) {
       LabelSimDevice(label, simDevice);
     } else {
       dpwmData->LabelText(label, "%0.3f", dpwmData->GetValue());
     }
   } else if (exists && encoder) {
-    info.GetLabel(label, sizeof(label), " In", index);
+    dioName.GetLabel(label, sizeof(label), " In", index);
     if (auto simDevice = encoder->GetSimDevice()) {
       LabelSimDevice(label, simDevice);
     } else {
@@ -48,7 +49,8 @@ void DisplayDIOImpl(DIOModel* model, int index, bool outputsEnabled) {
       ImGui::PopStyleColor();
     }
   } else if (exists && dutyCycleData) {
-    dutyCycleData->GetNameInfo().GetLabel(label, sizeof(label), "Dty", index);
+    NameSetting{dutyCycleData->GetName()}.GetLabel(label, sizeof(label), "Dty",
+                                                   index);
     if (auto simDevice = dutyCycle->GetSimDevice()) {
       LabelSimDevice(label, simDevice);
     } else {
@@ -60,10 +62,10 @@ void DisplayDIOImpl(DIOModel* model, int index, bool outputsEnabled) {
   } else {
     const char* name = model->GetName();
     if (name[0] != '\0') {
-      info.GetLabel(label, sizeof(label), name);
+      dioName.GetLabel(label, sizeof(label), name);
     } else {
-      info.GetLabel(label, sizeof(label), model->IsInput() ? " In" : "Out",
-                    index);
+      dioName.GetLabel(label, sizeof(label), model->IsInput() ? " In" : "Out",
+                       index);
     }
     if (auto simDevice = model->GetSimDevice()) {
       LabelSimDevice(label, simDevice);
@@ -87,12 +89,12 @@ void DisplayDIOImpl(DIOModel* model, int index, bool outputsEnabled) {
       }
     }
   }
-  if (info.PopupEditName(index)) {
+  if (dioName.PopupEditName(index)) {
     if (dpwmData) {
-      dpwmData->SetName(info.GetName());
+      dpwmData->SetName(dioName.GetName());
     }
     if (dutyCycleData) {
-      dutyCycleData->SetName(info.GetName());
+      dutyCycleData->SetName(dioName.GetName());
     }
   }
 }

glass/src/lib/native/cpp/hardware/Encoder.cpp

@@ -9,6 +9,7 @@
 
 #include "glass/Context.h"
 #include "glass/DataSource.h"
+#include "glass/Storage.h"
 
 using namespace glass;
 
@@ -66,21 +67,21 @@ void glass::DisplayEncoder(EncoderModel* model) {
   int chB = model->GetChannelB();
 
   // build header label
-  std::string* name = GetStorage().GetStringRef("name");
+  std::string& name = GetStorage().GetString("name");
   char label[128];
-  if (!name->empty()) {
-    std::snprintf(label, sizeof(label), "%s [%d,%d]###name", name->c_str(), chA,
-                  chB);
+  if (!name.empty()) {
+    std::snprintf(label, sizeof(label), "%s [%d,%d]###header", name.c_str(),
+                  chA, chB);
   } else {
-    std::snprintf(label, sizeof(label), "Encoder[%d,%d]###name", chA, chB);
+    std::snprintf(label, sizeof(label), "Encoder[%d,%d]###header", chA, chB);
   }
 
   // header
   bool open = CollapsingHeader(label);
 
   // context menu to change name
-  if (PopupEditName("name", name)) {
-    model->SetName(name->c_str());
+  if (PopupEditName("header", &name)) {
+    model->SetName(name);
   }
 
   if (!open) {

glass/src/lib/native/cpp/hardware/LEDDisplay.cpp

@@ -7,6 +7,7 @@
 #include <wpi/SmallVector.h>
 
 #include "glass/Context.h"
+#include "glass/Storage.h"
 #include "glass/support/ExtraGuiWidgets.h"
 
 using namespace glass;
@@ -25,27 +26,27 @@ void glass::DisplayLEDDisplay(LEDDisplayModel* model, int index) {
   bool running = model->IsRunning();
   auto& storage = GetStorage();
 
-  int* numColumns = storage.GetIntRef("columns", 10);
-  bool* serpentine = storage.GetBoolRef("serpentine", false);
-  int* order = storage.GetIntRef("order", LEDConfig::RowMajor);
-  int* start = storage.GetIntRef("start", LEDConfig::UpperLeft);
+  int& numColumns = storage.GetInt("columns", 10);
+  bool& serpentine = storage.GetBool("serpentine", false);
+  int& order = storage.GetInt("order", LEDConfig::RowMajor);
+  int& start = storage.GetInt("start", LEDConfig::UpperLeft);
 
   ImGui::PushItemWidth(ImGui::GetFontSize() * 6);
   ImGui::LabelText("Length", "%d", length);
   ImGui::LabelText("Running", "%s", running ? "Yes" : "No");
-  ImGui::InputInt("Columns", numColumns);
+  ImGui::InputInt("Columns", &numColumns);
   {
     static const char* options[] = {"Row Major", "Column Major"};
-    ImGui::Combo("Order", order, options, 2);
+    ImGui::Combo("Order", &order, options, 2);
   }
   {
     static const char* options[] = {"Upper Left", "Lower Left", "Upper Right",
                                     "Lower Right"};
-    ImGui::Combo("Start", start, options, 4);
+    ImGui::Combo("Start", &start, options, 4);
   }
-  ImGui::Checkbox("Serpentine", serpentine);
-  if (*numColumns < 1) {
-    *numColumns = 1;
+  ImGui::Checkbox("Serpentine", &serpentine);
+  if (numColumns < 1) {
+    numColumns = 1;
   }
   ImGui::PopItemWidth();
 
@@ -74,12 +75,12 @@ void glass::DisplayLEDDisplay(LEDDisplayModel* model, int index) {
   }
 
   LEDConfig config;
-  config.serpentine = *serpentine;
-  config.order = static_cast<LEDConfig::Order>(*order);
-  config.start = static_cast<LEDConfig::Start>(*start);
+  config.serpentine = serpentine;
+  config.order = static_cast<LEDConfig::Order>(order);
+  config.start = static_cast<LEDConfig::Start>(start);
 
-  DrawLEDs(iData->values.data(), length, *numColumns, iData->colors.data(), 0,
-           0, config);
+  DrawLEDs(iData->values.data(), length, numColumns, iData->colors.data(), 0, 0,
+           config);
 }
 
 void glass::DisplayLEDDisplays(LEDDisplaysModel* model) {

glass/src/lib/native/cpp/hardware/PCM.cpp

@@ -12,9 +12,10 @@
 
 #include "glass/Context.h"
 #include "glass/DataSource.h"
+#include "glass/Storage.h"
 #include "glass/other/DeviceTree.h"
 #include "glass/support/ExtraGuiWidgets.h"
-#include "glass/support/IniSaverInfo.h"
+#include "glass/support/NameSetting.h"
 
 using namespace glass;
 
@@ -42,18 +43,19 @@ bool glass::DisplayPCMSolenoids(PCMModel* model, int index,
   }
 
   // build header label
-  std::string* name = GetStorage().GetStringRef("name");
+  std::string& name = GetStorage().GetString("name");
   char label[128];
-  if (!name->empty()) {
-    std::snprintf(label, sizeof(label), "%s [%d]###name", name->c_str(), index);
+  if (!name.empty()) {
+    std::snprintf(label, sizeof(label), "%s [%d]###header", name.c_str(),
+                  index);
   } else {
-    std::snprintf(label, sizeof(label), "PCM[%d]###name", index);
+    std::snprintf(label, sizeof(label), "PCM[%d]###header", index);
   }
 
   // header
   bool open = CollapsingHeader(label);
 
-  PopupEditName("name", name);
+  PopupEditName("header", &name);
 
   ImGui::SetItemAllowOverlap();
   ImGui::SameLine();
@@ -68,11 +70,11 @@ bool glass::DisplayPCMSolenoids(PCMModel* model, int index,
     model->ForEachSolenoid([&](SolenoidModel& solenoid, int j) {
       if (auto data = solenoid.GetOutputData()) {
         PushID(j);
-        char solenoidName[64];
-        auto& info = data->GetNameInfo();
-        info.GetLabel(solenoidName, sizeof(solenoidName), "Solenoid", j);
-        data->LabelText(solenoidName, "%s", channels[j] == 1 ? "On" : "Off");
-        info.PopupEditName(j);
+        char label[64];
+        NameSetting name{data->GetName()};
+        name.GetLabel(label, sizeof(label), "Solenoid", j);
+        data->LabelText(label, "%s", channels[j] == 1 ? "On" : "Off");
+        name.PopupEditName(j);
         PopID();
       }
     });

glass/src/lib/native/cpp/hardware/PWM.cpp

@@ -8,6 +8,7 @@
 
 #include "glass/Context.h"
 #include "glass/DataSource.h"
+#include "glass/Storage.h"
 
 using namespace glass;
 
@@ -18,10 +19,10 @@ void glass::DisplayPWM(PWMModel* model, int index, bool outputsEnabled) {
   }
 
   // build label
-  std::string* name = GetStorage().GetStringRef("name");
+  std::string& name = GetStorage().GetString("name");
   char label[128];
-  if (!name->empty()) {
-    std::snprintf(label, sizeof(label), "%s [%d]###name", name->c_str(), index);
+  if (!name.empty()) {
+    std::snprintf(label, sizeof(label), "%s [%d]###name", name.c_str(), index);
   } else {
     std::snprintf(label, sizeof(label), "PWM[%d]###name", index);
   }
@@ -35,8 +36,8 @@ void glass::DisplayPWM(PWMModel* model, int index, bool outputsEnabled) {
     float val = outputsEnabled ? data->GetValue() : 0;
     data->LabelText(label, "%0.3f", val);
   }
-  if (PopupEditName("name", name)) {
-    data->SetName(name->c_str());
+  if (PopupEditName("name", &name)) {
+    data->SetName(name);
   }
 }
 

glass/src/lib/native/cpp/hardware/PowerDistribution.cpp

@@ -11,7 +11,7 @@
 
 #include "glass/Context.h"
 #include "glass/DataSource.h"
-#include "glass/support/IniSaverInfo.h"
+#include "glass/support/NameSetting.h"
 
 using namespace glass;
 
@@ -19,16 +19,16 @@ static float DisplayChannel(PowerDistributionModel& pdp, int channel) {
   float width = 0;
   if (auto currentData = pdp.GetCurrentData(channel)) {
     ImGui::PushID(channel);
-    auto& leftInfo = currentData->GetNameInfo();
+    NameSetting leftName{currentData->GetName()};
     char name[64];
-    leftInfo.GetLabel(name, sizeof(name), "", channel);
+    leftName.GetLabel(name, sizeof(name), "", channel);
     double val = currentData->GetValue();
     ImGui::SetNextItemWidth(ImGui::GetFontSize() * 4);
     if (currentData->InputDouble(name, &val, 0, 0, "%.3f")) {
       pdp.SetCurrent(channel, val);
     }
     width = ImGui::GetItemRectSize().x;
-    leftInfo.PopupEditName(channel);
+    leftName.PopupEditName(channel);
     ImGui::PopID();
   }
   return width;

glass/src/lib/native/cpp/hardware/Relay.cpp

@@ -8,6 +8,7 @@
 
 #include "glass/Context.h"
 #include "glass/DataSource.h"
+#include "glass/Storage.h"
 #include "glass/support/ExtraGuiWidgets.h"
 
 using namespace glass;
@@ -31,20 +32,20 @@ void glass::DisplayRelay(RelayModel* model, int index, bool outputsEnabled) {
     }
   }
 
-  std::string* name = GetStorage().GetStringRef("name");
+  std::string& name = GetStorage().GetString("name");
   ImGui::PushID("name");
-  if (!name->empty()) {
-    ImGui::Text("%s [%d]", name->c_str(), index);
+  if (!name.empty()) {
+    ImGui::Text("%s [%d]", name.c_str(), index);
   } else {
     ImGui::Text("Relay[%d]", index);
   }
   ImGui::PopID();
-  if (PopupEditName("name", name)) {
+  if (PopupEditName("name", &name)) {
     if (forwardData) {
-      forwardData->SetName(name->c_str());
+      forwardData->SetName(name);
     }
     if (reverseData) {
-      reverseData->SetName(name->c_str());
+      reverseData->SetName(name);
     }
   }
   ImGui::SameLine();

glass/src/lib/native/cpp/other/DeviceTree.cpp

@@ -51,13 +51,13 @@ bool glass::BeginDevice(const char* id, ImGuiTreeNodeFlags flags) {
   PushID(id);
 
   // build label
-  std::string* name = GetStorage().GetStringRef("name");
+  std::string& name = GetStorage().GetString("name");
   char label[128];
-  std::snprintf(label, sizeof(label), "%s###name",
-                name->empty() ? id : name->c_str());
+  std::snprintf(label, sizeof(label), "%s###header",
+                name.empty() ? id : name.c_str());
 
   bool open = CollapsingHeader(label, flags);
-  PopupEditName("name", name);
+  PopupEditName("header", &name);
 
   if (!open) {
     PopID();

glass/src/lib/native/cpp/other/Drive.cpp

@@ -90,11 +90,20 @@ void glass::DisplayDrive(DriveModel* m) {
     double a1 = 0.0;
     double a2 = wpi::numbers::pi / 2 * rotation;
 
-    draw->PathArcTo(center, radius, a1, a2, 20);
-    draw->PathStroke(color, false);
-    draw->PathArcTo(center, radius, a1 + wpi::numbers::pi,
-                    a2 + wpi::numbers::pi, 20);
-    draw->PathStroke(color, false);
+    // PathArcTo requires a_min <= a_max, and rotation can be negative
+    if (a1 > a2) {
+      draw->PathArcTo(center, radius, a2, a1, 20);
+      draw->PathStroke(color, false);
+      draw->PathArcTo(center, radius, a2 + wpi::numbers::pi,
+                      a1 + wpi::numbers::pi, 20);
+      draw->PathStroke(color, false);
+    } else {
+      draw->PathArcTo(center, radius, a1, a2, 20);
+      draw->PathStroke(color, false);
+      draw->PathArcTo(center, radius, a1 + wpi::numbers::pi,
+                      a2 + wpi::numbers::pi, 20);
+      draw->PathStroke(color, false);
+    }
 
     double adder = rotation < 0 ? wpi::numbers::pi : 0;
 

glass/src/lib/native/cpp/other/FMS.cpp

@@ -14,7 +14,7 @@ using namespace glass;
 static const char* stations[] = {"Red 1",  "Red 2",  "Red 3",
                                  "Blue 1", "Blue 2", "Blue 3"};
 
-void glass::DisplayFMS(FMSModel* model, bool* matchTimeEnabled) {
+void glass::DisplayFMS(FMSModel* model) {
   if (!model->Exists() || model->IsReadOnly()) {
     return DisplayFMSReadOnly(model);
   }
@@ -49,10 +49,6 @@ void glass::DisplayFMS(FMSModel* model, bool* matchTimeEnabled) {
 
   // Match Time
   if (auto data = model->GetMatchTimeData()) {
-    if (matchTimeEnabled) {
-      ImGui::Checkbox("Match Time Enabled", matchTimeEnabled);
-    }
-
     double val = data->GetValue();
     ImGui::SetNextItemWidth(ImGui::GetFontSize() * 8);
     if (ImGui::InputDouble("Match Time", &val, 0, 0, "%.1f",
@@ -60,9 +56,17 @@ void glass::DisplayFMS(FMSModel* model, bool* matchTimeEnabled) {
       model->SetMatchTime(val);
     }
     data->EmitDrag();
+    bool enabled = false;
+    if (auto enabledData = model->GetEnabledData()) {
+      enabled = enabledData->GetValue();
+    }
     ImGui::SameLine();
-    if (ImGui::Button("Reset")) {
-      model->SetMatchTime(0.0);
+    if (ImGui::Button("Auto") && !enabled) {
+      model->SetMatchTime(15.0);
+    }
+    ImGui::SameLine();
+    if (ImGui::Button("Teleop") && !enabled) {
+      model->SetMatchTime(135.0);
     }
   }
 

glass/src/lib/native/cpp/other/Field2D.cpp

@@ -32,6 +32,9 @@
 #include <wpigui.h>
 
 #include "glass/Context.h"
+#include "glass/Storage.h"
+#include "glass/support/ColorSetting.h"
+#include "glass/support/EnumSetting.h"
 
 using namespace glass;
 
@@ -114,12 +117,14 @@ struct DisplayOptions {
 
   static constexpr Style kDefaultStyle = kBoxImage;
   static constexpr float kDefaultWeight = 4.0f;
+  static constexpr float kDefaultColorFloat[] = {255, 0, 0, 255};
   static constexpr ImU32 kDefaultColor = IM_COL32(255, 0, 0, 255);
   static constexpr auto kDefaultWidth = 0.6858_m;
   static constexpr auto kDefaultLength = 0.8204_m;
   static constexpr bool kDefaultArrows = true;
   static constexpr int kDefaultArrowSize = 50;
   static constexpr float kDefaultArrowWeight = 4.0f;
+  static constexpr float kDefaultArrowColorFloat[] = {0, 255, 0, 255};
   static constexpr ImU32 kDefaultArrowColor = IM_COL32(0, 255, 0, 255);
   static constexpr bool kDefaultSelectable = true;
 
@@ -180,7 +185,7 @@ class PoseFrameData {
 
 class ObjectInfo {
  public:
-  ObjectInfo();
+  explicit ObjectInfo(Storage& storage);
 
   DisplayOptions GetDisplayOptions() const;
   void DisplaySettings();
@@ -191,26 +196,26 @@ class ObjectInfo {
 
  private:
   void Reset();
-  bool LoadImageImpl(const char* fn);
+  bool LoadImageImpl(const std::string& fn);
 
   std::unique_ptr<pfd::open_file> m_fileOpener;
 
   // in meters
-  float* m_pWidth;
-  float* m_pLength;
+  float& m_width;
+  float& m_length;
 
-  int* m_pStyle;  // DisplayOptions::Style
-  float* m_pWeight;
-  int* m_pColor;
+  EnumSetting m_style;  // DisplayOptions::Style
+  float& m_weight;
+  ColorSetting m_color;
 
-  bool* m_pArrows;
-  int* m_pArrowSize;
-  float* m_pArrowWeight;
-  int* m_pArrowColor;
+  bool& m_arrows;
+  int& m_arrowSize;
+  float& m_arrowWeight;
+  ColorSetting m_arrowColor;
 
-  bool* m_pSelectable;
+  bool& m_selectable;
 
-  std::string* m_pFilename;
+  std::string& m_filename;
   gui::Texture m_texture;
 };
 
@@ -219,7 +224,7 @@ class FieldInfo {
   static constexpr auto kDefaultWidth = 15.98_m;
   static constexpr auto kDefaultHeight = 8.21_m;
 
-  FieldInfo();
+  explicit FieldInfo(Storage& storage);
 
   void DisplaySettings();
 
@@ -231,25 +236,25 @@ class FieldInfo {
 
  private:
   void Reset();
-  bool LoadImageImpl(const char* fn);
+  bool LoadImageImpl(const std::string& fn);
   void LoadJson(std::string_view jsonfile);
 
   std::unique_ptr<pfd::open_file> m_fileOpener;
 
-  std::string* m_pFilename;
+  std::string& m_filename;
   gui::Texture m_texture;
 
   // in meters
-  float* m_pWidth;
-  float* m_pHeight;
+  float& m_width;
+  float& m_height;
 
   // in image pixels
   int m_imageWidth;
   int m_imageHeight;
-  int* m_pTop;
-  int* m_pLeft;
-  int* m_pBottom;
-  int* m_pRight;
+  int& m_top;
+  int& m_left;
+  int& m_bottom;
+  int& m_right;
 };
 
 }  // namespace
@@ -334,16 +339,14 @@ static bool InputPose(frc::Pose2d* pose) {
   return changed;
 }
 
-FieldInfo::FieldInfo() {
-  auto& storage = GetStorage();
-  m_pFilename = storage.GetStringRef("image");
-  m_pTop = storage.GetIntRef("top", 0);
-  m_pLeft = storage.GetIntRef("left", 0);
-  m_pBottom = storage.GetIntRef("bottom", -1);
-  m_pRight = storage.GetIntRef("right", -1);
-  m_pWidth = storage.GetFloatRef("width", kDefaultWidth.to<float>());
-  m_pHeight = storage.GetFloatRef("height", kDefaultHeight.to<float>());
-}
+FieldInfo::FieldInfo(Storage& storage)
+    : m_filename{storage.GetString("image")},
+      m_width{storage.GetFloat("width", kDefaultWidth.to<float>())},
+      m_height{storage.GetFloat("height", kDefaultHeight.to<float>())},
+      m_top{storage.GetInt("top", 0)},
+      m_left{storage.GetInt("left", 0)},
+      m_bottom{storage.GetInt("bottom", -1)},
+      m_right{storage.GetInt("right", -1)} {}
 
 void FieldInfo::DisplaySettings() {
   if (ImGui::Button("Choose image...")) {
@@ -357,23 +360,23 @@ void FieldInfo::DisplaySettings() {
   if (ImGui::Button("Reset image")) {
     Reset();
   }
-  InputFloatLength("Field Width", m_pWidth);
-  InputFloatLength("Field Height", m_pHeight);
-  // ImGui::InputInt("Field Top", m_pTop);
-  // ImGui::InputInt("Field Left", m_pLeft);
-  // ImGui::InputInt("Field Right", m_pRight);
-  // ImGui::InputInt("Field Bottom", m_pBottom);
+  InputFloatLength("Field Width", &m_width);
+  InputFloatLength("Field Height", &m_height);
+  // ImGui::InputInt("Field Top", &m_top);
+  // ImGui::InputInt("Field Left", &m_left);
+  // ImGui::InputInt("Field Right", &m_right);
+  // ImGui::InputInt("Field Bottom", &m_bottom);
 }
 
 void FieldInfo::Reset() {
   m_texture = gui::Texture{};
-  m_pFilename->clear();
+  m_filename.clear();
   m_imageWidth = 0;
   m_imageHeight = 0;
-  *m_pTop = 0;
-  *m_pLeft = 0;
-  *m_pBottom = -1;
-  *m_pRight = -1;
+  m_top = 0;
+  m_left = 0;
+  m_bottom = -1;
+  m_right = -1;
 }
 
 void FieldInfo::LoadImage() {
@@ -384,17 +387,17 @@ void FieldInfo::LoadImage() {
         LoadJson(result[0]);
       } else {
         LoadImageImpl(result[0].c_str());
-        *m_pTop = 0;
-        *m_pLeft = 0;
-        *m_pBottom = -1;
-        *m_pRight = -1;
+        m_top = 0;
+        m_left = 0;
+        m_bottom = -1;
+        m_right = -1;
       }
     }
     m_fileOpener.reset();
   }
-  if (!m_texture && !m_pFilename->empty()) {
-    if (!LoadImageImpl(m_pFilename->c_str())) {
-      m_pFilename->clear();
+  if (!m_texture && !m_filename.empty()) {
+    if (!LoadImageImpl(m_filename)) {
+      m_filename.clear();
     }
   }
 }
@@ -478,18 +481,18 @@ void FieldInfo::LoadJson(std::string_view jsonfile) {
   }
 
   // save to field info
-  *m_pFilename = pathname;
-  *m_pTop = top;
-  *m_pLeft = left;
-  *m_pBottom = bottom;
-  *m_pRight = right;
-  *m_pWidth = width;
-  *m_pHeight = height;
+  m_filename = pathname;
+  m_top = top;
+  m_left = left;
+  m_bottom = bottom;
+  m_right = right;
+  m_width = width;
+  m_height = height;
 }
 
-bool FieldInfo::LoadImageImpl(const char* fn) {
+bool FieldInfo::LoadImageImpl(const std::string& fn) {
   fmt::print("GUI: loading field image '{}'\n", fn);
-  auto texture = gui::Texture::CreateFromFile(fn);
+  auto texture = gui::Texture::CreateFromFile(fn.c_str());
   if (!texture) {
     std::puts("GUI: could not read field image");
     return false;
@@ -497,7 +500,7 @@ bool FieldInfo::LoadImageImpl(const char* fn) {
   m_texture = std::move(texture);
   m_imageWidth = m_texture.GetWidth();
   m_imageHeight = m_texture.GetHeight();
-  *m_pFilename = fn;
+  m_filename = fn;
   return true;
 }
 
@@ -512,19 +515,19 @@ FieldFrameData FieldInfo::GetFrameData(ImVec2 min, ImVec2 max) const {
   ffd.imageMax = max;
 
   // size down the box by the image corners (if any)
-  if (*m_pBottom > 0 && *m_pRight > 0) {
-    min.x += *m_pLeft * (max.x - min.x) / m_imageWidth;
-    min.y += *m_pTop * (max.y - min.y) / m_imageHeight;
-    max.x -= (m_imageWidth - *m_pRight) * (max.x - min.x) / m_imageWidth;
-    max.y -= (m_imageHeight - *m_pBottom) * (max.y - min.y) / m_imageHeight;
+  if (m_bottom > 0 && m_right > 0) {
+    min.x += m_left * (max.x - min.x) / m_imageWidth;
+    min.y += m_top * (max.y - min.y) / m_imageHeight;
+    max.x -= (m_imageWidth - m_right) * (max.x - min.x) / m_imageWidth;
+    max.y -= (m_imageHeight - m_bottom) * (max.y - min.y) / m_imageHeight;
   }
 
   // draw the field "active area" as a yellow boundary box
-  gui::MaxFit(&min, &max, *m_pWidth, *m_pHeight);
+  gui::MaxFit(&min, &max, m_width, m_height);
 
   ffd.min = min;
   ffd.max = max;
-  ffd.scale = (max.x - min.x) / *m_pWidth;
+  ffd.scale = (max.x - min.x) / m_width;
   return ffd;
 }
 
@@ -537,48 +540,47 @@ void FieldInfo::Draw(ImDrawList* drawList, const FieldFrameData& ffd) const {
   drawList->AddRect(ffd.min, ffd.max, IM_COL32(255, 255, 0, 255));
 }
 
-ObjectInfo::ObjectInfo() {
-  auto& storage = GetStorage();
-  m_pFilename = storage.GetStringRef("image");
-  m_pWidth =
-      storage.GetFloatRef("width", DisplayOptions::kDefaultWidth.to<float>());
-  m_pLength =
-      storage.GetFloatRef("length", DisplayOptions::kDefaultLength.to<float>());
-  m_pStyle = storage.GetIntRef("style", DisplayOptions::kDefaultStyle);
-  m_pWeight = storage.GetFloatRef("weight", DisplayOptions::kDefaultWeight);
-  m_pColor = storage.GetIntRef("color", DisplayOptions::kDefaultColor);
-  m_pArrows = storage.GetBoolRef("arrows", DisplayOptions::kDefaultArrows);
-  m_pArrowSize =
-      storage.GetIntRef("arrowSize", DisplayOptions::kDefaultArrowSize);
-  m_pArrowWeight =
-      storage.GetFloatRef("arrowWeight", DisplayOptions::kDefaultArrowWeight);
-  m_pArrowColor =
-      storage.GetIntRef("arrowColor", DisplayOptions::kDefaultArrowColor);
-  m_pSelectable =
-      storage.GetBoolRef("selectable", DisplayOptions::kDefaultSelectable);
-}
+ObjectInfo::ObjectInfo(Storage& storage)
+    : m_width{storage.GetFloat("width",
+                               DisplayOptions::kDefaultWidth.to<float>())},
+      m_length{storage.GetFloat("length",
+                                DisplayOptions::kDefaultLength.to<float>())},
+      m_style{storage.GetString("style"),
+              DisplayOptions::kDefaultStyle,
+              {"Box/Image", "Line", "Line (Closed)", "Track"}},
+      m_weight{storage.GetFloat("weight", DisplayOptions::kDefaultWeight)},
+      m_color{
+          storage.GetFloatArray("color", DisplayOptions::kDefaultColorFloat)},
+      m_arrows{storage.GetBool("arrows", DisplayOptions::kDefaultArrows)},
+      m_arrowSize{
+          storage.GetInt("arrowSize", DisplayOptions::kDefaultArrowSize)},
+      m_arrowWeight{
+          storage.GetFloat("arrowWeight", DisplayOptions::kDefaultArrowWeight)},
+      m_arrowColor{storage.GetFloatArray(
+          "arrowColor", DisplayOptions::kDefaultArrowColorFloat)},
+      m_selectable{
+          storage.GetBool("selectable", DisplayOptions::kDefaultSelectable)},
+      m_filename{storage.GetString("image")} {}
 
 DisplayOptions ObjectInfo::GetDisplayOptions() const {
   DisplayOptions rv{m_texture};
-  rv.style = static_cast<DisplayOptions::Style>(*m_pStyle);
-  rv.weight = *m_pWeight;
-  rv.color = *m_pColor;
-  rv.width = units::meter_t{*m_pWidth};
-  rv.length = units::meter_t{*m_pLength};
-  rv.arrows = *m_pArrows;
-  rv.arrowSize = *m_pArrowSize;
-  rv.arrowWeight = *m_pArrowWeight;
-  rv.arrowColor = *m_pArrowColor;
-  rv.selectable = *m_pSelectable;
+  rv.style = static_cast<DisplayOptions::Style>(m_style.GetValue());
+  rv.weight = m_weight;
+  rv.color = ImGui::ColorConvertFloat4ToU32(m_color.GetColor());
+  rv.width = units::meter_t{m_width};
+  rv.length = units::meter_t{m_length};
+  rv.arrows = m_arrows;
+  rv.arrowSize = m_arrowSize;
+  rv.arrowWeight = m_arrowWeight;
+  rv.arrowColor = ImGui::ColorConvertFloat4ToU32(m_arrowColor.GetColor());
+  rv.selectable = m_selectable;
   return rv;
 }
 
 void ObjectInfo::DisplaySettings() {
-  static const char* styleChoices[] = {"Box/Image", "Line", "Line (Closed)",
-                                       "Track"};
   ImGui::SetNextItemWidth(ImGui::GetFontSize() * 8);
-  ImGui::Combo("Style", m_pStyle, styleChoices, IM_ARRAYSIZE(styleChoices));
-  switch (*m_pStyle) {
+  m_style.Combo("Style");
+  switch (m_style.GetValue()) {
     case DisplayOptions::kBoxImage:
       if (ImGui::Button("Choose image...")) {
         m_fileOpener = std::make_unique<pfd::open_file>(
@@ -591,35 +593,27 @@ void ObjectInfo::DisplaySettings() {
       if (ImGui::Button("Reset image")) {
         Reset();
       }
-      InputFloatLength("Width", m_pWidth);
-      InputFloatLength("Length", m_pLength);
+      InputFloatLength("Width", &m_width);
+      InputFloatLength("Length", &m_length);
       break;
     case DisplayOptions::kTrack:
-      InputFloatLength("Width", m_pWidth);
+      InputFloatLength("Width", &m_width);
       break;
     default:
       break;
   }
 
-  ImGui::InputFloat("Line Weight", m_pWeight);
-  ImColor col(*m_pColor);
-  if (ImGui::ColorEdit3("Line Color", &col.Value.x,
-                        ImGuiColorEditFlags_NoInputs)) {
-    *m_pColor = col;
-  }
-  ImGui::Checkbox("Arrows", m_pArrows);
-  if (*m_pArrows) {
-    ImGui::SliderInt("Arrow Size", m_pArrowSize, 0, 100, "%d%%",
+  ImGui::InputFloat("Line Weight", &m_weight);
+  m_color.ColorEdit3("Line Color", ImGuiColorEditFlags_NoInputs);
+  ImGui::Checkbox("Arrows", &m_arrows);
+  if (m_arrows) {
+    ImGui::SliderInt("Arrow Size", &m_arrowSize, 0, 100, "%d%%",
                      ImGuiSliderFlags_AlwaysClamp);
-    ImGui::InputFloat("Arrow Weight", m_pArrowWeight);
-    ImColor col(*m_pArrowColor);
-    if (ImGui::ColorEdit3("Arrow Color", &col.Value.x,
-                          ImGuiColorEditFlags_NoInputs)) {
-      *m_pArrowColor = col;
-    }
+    ImGui::InputFloat("Arrow Weight", &m_arrowWeight);
+    m_arrowColor.ColorEdit3("Arrow Color", ImGuiColorEditFlags_NoInputs);
   }
 
-  ImGui::Checkbox("Selectable", m_pSelectable);
+  ImGui::Checkbox("Selectable", &m_selectable);
 }
 
 void ObjectInfo::DrawLine(ImDrawList* drawList,
@@ -629,10 +623,12 @@ void ObjectInfo::DrawLine(ImDrawList* drawList,
   }
 
   if (points.size() == 1) {
-    drawList->AddCircleFilled(points.front(), *m_pWeight, *m_pWeight);
+    drawList->AddCircleFilled(points.front(), m_weight, m_weight);
     return;
   }
 
+  ImU32 color = ImGui::ColorConvertFloat4ToU32(m_color.GetColor());
+
   // PolyLine doesn't handle acute angles well; workaround from
   // https://github.com/ocornut/imgui/issues/3366
   size_t i = 0;
@@ -651,18 +647,18 @@ void ObjectInfo::DrawLine(ImDrawList* drawList,
       ++nlin;
     }
 
-    drawList->AddPolyline(&points[i], nlin, *m_pColor, false, *m_pWeight);
+    drawList->AddPolyline(&points[i], nlin, color, false, m_weight);
     i += nlin - 1;
   }
 
-  if (points.size() > 2 && *m_pStyle == DisplayOptions::kLineClosed) {
-    drawList->AddLine(points.back(), points.front(), *m_pColor, *m_pWeight);
+  if (points.size() > 2 && m_style.GetValue() == DisplayOptions::kLineClosed) {
+    drawList->AddLine(points.back(), points.front(), color, m_weight);
   }
 }
 
 void ObjectInfo::Reset() {
   m_texture = gui::Texture{};
-  m_pFilename->clear();
+  m_filename.clear();
 }
 
 void ObjectInfo::LoadImage() {
@@ -673,22 +669,22 @@ void ObjectInfo::LoadImage() {
     }
     m_fileOpener.reset();
   }
-  if (!m_texture && !m_pFilename->empty()) {
-    if (!LoadImageImpl(m_pFilename->c_str())) {
-      m_pFilename->clear();
+  if (!m_texture && !m_filename.empty()) {
+    if (!LoadImageImpl(m_filename)) {
+      m_filename.clear();
     }
   }
 }
 
-bool ObjectInfo::LoadImageImpl(const char* fn) {
+bool ObjectInfo::LoadImageImpl(const std::string& fn) {
   fmt::print("GUI: loading object image '{}'\n", fn);
-  auto texture = gui::Texture::CreateFromFile(fn);
+  auto texture = gui::Texture::CreateFromFile(fn.c_str());
   if (!texture) {
     std::fputs("GUI: could not read object image\n", stderr);
     return false;
   }
   m_texture = std::move(texture);
-  *m_pFilename = fn;
+  m_filename = fn;
   return true;
 }
 
@@ -857,15 +853,16 @@ void glass::DisplayField2DSettings(Field2DModel* model) {
   auto& storage = GetStorage();
   auto field = storage.GetData<FieldInfo>();
   if (!field) {
-    storage.SetData(std::make_shared<FieldInfo>());
+    storage.SetData(std::make_shared<FieldInfo>(storage));
     field = storage.GetData<FieldInfo>();
   }
 
-  static const char* unitNames[] = {"meters", "feet", "inches"};
-  int* pDisplayUnits = GetStorage().GetIntRef("units", kDisplayMeters);
+  EnumSetting displayUnits{GetStorage().GetString("units"),
+                           kDisplayMeters,
+                           {"meters", "feet", "inches"}};
   ImGui::SetNextItemWidth(ImGui::GetFontSize() * 8);
-  ImGui::Combo("Units", pDisplayUnits, unitNames, IM_ARRAYSIZE(unitNames));
-  gDisplayUnits = static_cast<DisplayUnits>(*pDisplayUnits);
+  displayUnits.Combo("Units");
+  gDisplayUnits = static_cast<DisplayUnits>(displayUnits.GetValue());
 
   ImGui::PushItemWidth(ImGui::GetFontSize() * 4);
   if (ImGui::CollapsingHeader("Field")) {
@@ -881,7 +878,7 @@ void glass::DisplayField2DSettings(Field2DModel* model) {
     PushID(name);
     auto& objRef = field->m_objects[name];
     if (!objRef) {
-      objRef = std::make_unique<ObjectInfo>();
+      objRef = std::make_unique<ObjectInfo>(GetStorage());
     }
     auto obj = objRef.get();
 
@@ -1025,7 +1022,7 @@ void FieldDisplay::DisplayObject(FieldObjectModel& model,
   PushID(name);
   auto& objRef = m_field->m_objects[name];
   if (!objRef) {
-    objRef = std::make_unique<ObjectInfo>();
+    objRef = std::make_unique<ObjectInfo>(GetStorage());
   }
   auto obj = objRef.get();
   obj->LoadImage();
@@ -1205,7 +1202,7 @@ void glass::DisplayField2D(Field2DModel* model, const ImVec2& contentSize) {
   auto& storage = GetStorage();
   auto field = storage.GetData<FieldInfo>();
   if (!field) {
-    storage.SetData(std::make_shared<FieldInfo>());
+    storage.SetData(std::make_shared<FieldInfo>(storage));
     field = storage.GetData<FieldInfo>();
   }
 

glass/src/lib/native/cpp/other/Mechanism2D.cpp

@@ -27,6 +27,7 @@
 #include <wpigui.h>
 
 #include "glass/Context.h"
+#include "glass/Storage.h"
 
 using namespace glass;
 
@@ -61,7 +62,7 @@ struct FrameData {
 
 class BackgroundInfo {
  public:
-  BackgroundInfo();
+  explicit BackgroundInfo(Storage& storage);
 
   void DisplaySettings();
 
@@ -72,11 +73,11 @@ class BackgroundInfo {
 
  private:
   void Reset();
-  bool LoadImageImpl(const char* fn);
+  bool LoadImageImpl(const std::string& fn);
 
   std::unique_ptr<pfd::open_file> m_fileOpener;
 
-  std::string* m_pFilename;
+  std::string& m_filename;
   gui::Texture m_texture;
 
   // in image pixels
@@ -86,10 +87,8 @@ class BackgroundInfo {
 
 }  // namespace
 
-BackgroundInfo::BackgroundInfo() {
-  auto& storage = GetStorage();
-  m_pFilename = storage.GetStringRef("image");
-}
+BackgroundInfo::BackgroundInfo(Storage& storage)
+    : m_filename{storage.GetString("image")} {}
 
 void BackgroundInfo::DisplaySettings() {
   if (ImGui::Button("Choose image...")) {
@@ -106,7 +105,7 @@ void BackgroundInfo::DisplaySettings() {
 
 void BackgroundInfo::Reset() {
   m_texture = gui::Texture{};
-  m_pFilename->clear();
+  m_filename.clear();
   m_imageWidth = 0;
   m_imageHeight = 0;
 }
@@ -119,16 +118,16 @@ void BackgroundInfo::LoadImage() {
     }
     m_fileOpener.reset();
   }
-  if (!m_texture && !m_pFilename->empty()) {
-    if (!LoadImageImpl(m_pFilename->c_str())) {
-      m_pFilename->clear();
+  if (!m_texture && !m_filename.empty()) {
+    if (!LoadImageImpl(m_filename)) {
+      m_filename.clear();
     }
   }
 }
 
-bool BackgroundInfo::LoadImageImpl(const char* fn) {
+bool BackgroundInfo::LoadImageImpl(const std::string& fn) {
   fmt::print("GUI: loading background image '{}'\n", fn);
-  auto texture = gui::Texture::CreateFromFile(fn);
+  auto texture = gui::Texture::CreateFromFile(fn.c_str());
   if (!texture) {
     std::puts("GUI: could not read background image");
     return false;
@@ -136,7 +135,7 @@ bool BackgroundInfo::LoadImageImpl(const char* fn) {
   m_texture = std::move(texture);
   m_imageWidth = m_texture.GetWidth();
   m_imageHeight = m_texture.GetHeight();
-  *m_pFilename = fn;
+  m_filename = fn;
   return true;
 }
 
@@ -175,7 +174,7 @@ void glass::DisplayMechanism2DSettings(Mechanism2DModel* model) {
   auto& storage = GetStorage();
   auto bg = storage.GetData<BackgroundInfo>();
   if (!bg) {
-    storage.SetData(std::make_shared<BackgroundInfo>());
+    storage.SetData(std::make_shared<BackgroundInfo>(storage));
     bg = storage.GetData<BackgroundInfo>();
   }
   bg->DisplaySettings();
@@ -208,7 +207,7 @@ void glass::DisplayMechanism2D(Mechanism2DModel* model,
   auto& storage = GetStorage();
   auto bg = storage.GetData<BackgroundInfo>();
   if (!bg) {
-    storage.SetData(std::make_shared<BackgroundInfo>());
+    storage.SetData(std::make_shared<BackgroundInfo>(storage));
     bg = storage.GetData<BackgroundInfo>();
   }
 

glass/src/lib/native/cpp/support/ColorSetting.cpp

@@ -0,0 +1,11 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "glass/support/ColorSetting.h"
+
+using namespace glass;
+
+ColorSetting::ColorSetting(std::vector<float>& color) : m_color{color} {
+  m_color.resize(4);
+}

glass/src/lib/native/cpp/support/EnumSetting.cpp

@@ -0,0 +1,40 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "glass/support/EnumSetting.h"
+
+#include <imgui.h>
+
+using namespace glass;
+
+EnumSetting::EnumSetting(std::string& str, int defaultValue,
+                         std::initializer_list<const char*> choices)
+    : m_str{str}, m_choices{choices}, m_value{defaultValue} {
+  // override default value if str is one of the choices
+  int i = 0;
+  for (auto choice : choices) {
+    if (str == choice) {
+      m_value = i;
+      break;
+    }
+    ++i;
+  }
+}
+
+void EnumSetting::SetValue(int value) {
+  m_value = value;
+  m_str = m_choices[m_value];
+}
+
+bool EnumSetting::Combo(const char* label, int numOptions,
+                        int popup_max_height_in_items) {
+  if (ImGui::Combo(
+          label, &m_value, m_choices.data(),
+          numOptions < 0 ? m_choices.size() : static_cast<size_t>(numOptions),
+          popup_max_height_in_items)) {
+    m_str = m_choices[m_value];  // update stored string
+    return true;
+  }
+  return false;
+}

glass/src/lib/native/cpp/support/ExtraGuiWidgets.cpp

@@ -160,17 +160,17 @@ bool DeleteButton(ImGuiID id, const ImVec2& pos) {
 bool HeaderDeleteButton(const char* label) {
   ImGuiWindow* window = ImGui::GetCurrentWindow();
   ImGuiContext& g = *GImGui;
-  ImGuiLastItemDataBackup last_item_backup;
+  ImGuiLastItemData last_item_backup = g.LastItemData;
   ImGuiID id = window->GetID(label);
   float button_size = g.FontSize;
-  float button_x = ImMax(window->DC.LastItemRect.Min.x,
-                         window->DC.LastItemRect.Max.x -
-                             g.Style.FramePadding.x * 2.0f - button_size);
-  float button_y = window->DC.LastItemRect.Min.y;
+  float button_x = ImMax(
+      g.LastItemData.Rect.Min.x,
+      g.LastItemData.Rect.Max.x - g.Style.FramePadding.x * 2.0f - button_size);
+  float button_y = g.LastItemData.Rect.Min.y;
   bool rv = DeleteButton(
       window->GetID(reinterpret_cast<void*>(static_cast<intptr_t>(id) + 1)),
       ImVec2(button_x, button_y));
-  last_item_backup.Restore();
+  g.LastItemData = last_item_backup;
   return rv;
 }
 

glass/src/lib/native/cpp/support/IniSaverBase.cpp

@@ -1,62 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "glass/support/IniSaverBase.h"
-
-#include <imgui_internal.h>
-
-using namespace glass;
-
-namespace {
-class ImGuiSaver : public IniSaverBackend {
- public:
-  void Register(IniSaverBase* iniSaver) override;
-  void Unregister(IniSaverBase* iniSaver) override;
-};
-}  // namespace
-
-void ImGuiSaver::Register(IniSaverBase* iniSaver) {
-  // hook ini handler to save settings
-  ImGuiSettingsHandler iniHandler;
-  iniHandler.TypeName = iniSaver->GetTypeName();
-  iniHandler.TypeHash = ImHashStr(iniHandler.TypeName);
-  iniHandler.ReadOpenFn = [](ImGuiContext* ctx, ImGuiSettingsHandler* handler,
-                             const char* name) {
-    return static_cast<IniSaverBase*>(handler->UserData)->IniReadOpen(name);
-  };
-  iniHandler.ReadLineFn = [](ImGuiContext* ctx, ImGuiSettingsHandler* handler,
-                             void* entry, const char* line) {
-    static_cast<IniSaverBase*>(handler->UserData)->IniReadLine(entry, line);
-  };
-  iniHandler.WriteAllFn = [](ImGuiContext* ctx, ImGuiSettingsHandler* handler,
-                             ImGuiTextBuffer* out_buf) {
-    static_cast<IniSaverBase*>(handler->UserData)->IniWriteAll(out_buf);
-  };
-  iniHandler.UserData = iniSaver;
-  ImGui::GetCurrentContext()->SettingsHandlers.push_back(iniHandler);
-}
-
-void ImGuiSaver::Unregister(IniSaverBase* iniSaver) {
-  if (auto ctx = ImGui::GetCurrentContext()) {
-    auto& handlers = ctx->SettingsHandlers;
-    for (auto it = handlers.begin(), end = handlers.end(); it != end; ++it) {
-      if (it->UserData == iniSaver) {
-        handlers.erase(it);
-        return;
-      }
-    }
-  }
-}
-
-static ImGuiSaver* GetSaverInstance() {
-  static ImGuiSaver* inst = new ImGuiSaver;
-  return inst;
-}
-
-IniSaverBase::IniSaverBase(std::string_view typeName, IniSaverBackend* backend)
-    : m_typeName(typeName), m_backend{backend ? backend : GetSaverInstance()} {}
-
-IniSaverBase::~IniSaverBase() {
-  m_backend->Unregister(this);
-}

glass/src/lib/native/cpp/support/IniSaverInfo.cpp

@@ -1,168 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-#include "glass/support/IniSaverInfo.h"
-
-#include <cstdio>
-#include <cstring>
-
-#include <imgui_internal.h>
-#include <wpi/StringExtras.h>
-
-using namespace glass;
-
-void NameInfo::SetName(std::string_view name) {
-  size_t len = (std::min)(name.size(), sizeof(m_name) - 1);
-  std::memcpy(m_name, name.data(), len);
-  m_name[len] = '\0';
-}
-
-void NameInfo::GetName(char* buf, size_t size, const char* defaultName) const {
-  if (m_name[0] != '\0') {
-    std::snprintf(buf, size, "%s", m_name);
-  } else {
-    std::snprintf(buf, size, "%s", defaultName);
-  }
-}
-
-void NameInfo::GetName(char* buf, size_t size, const char* defaultName,
-                       int index) const {
-  if (m_name[0] != '\0') {
-    std::snprintf(buf, size, "%s [%d]", m_name, index);
-  } else {
-    std::snprintf(buf, size, "%s[%d]", defaultName, index);
-  }
-}
-
-void NameInfo::GetName(char* buf, size_t size, const char* defaultName,
-                       int index, int index2) const {
-  if (m_name[0] != '\0') {
-    std::snprintf(buf, size, "%s [%d,%d]", m_name, index, index2);
-  } else {
-    std::snprintf(buf, size, "%s[%d,%d]", defaultName, index, index2);
-  }
-}
-
-void NameInfo::GetLabel(char* buf, size_t size, const char* defaultName) const {
-  if (m_name[0] != '\0') {
-    std::snprintf(buf, size, "%s###Name%s", m_name, defaultName);
-  } else {
-    std::snprintf(buf, size, "%s###Name%s", defaultName, defaultName);
-  }
-}
-
-void NameInfo::GetLabel(char* buf, size_t size, const char* defaultName,
-                        int index) const {
-  if (m_name[0] != '\0') {
-    std::snprintf(buf, size, "%s [%d]###Name%d", m_name, index, index);
-  } else {
-    std::snprintf(buf, size, "%s[%d]###Name%d", defaultName, index, index);
-  }
-}
-
-void NameInfo::GetLabel(char* buf, size_t size, const char* defaultName,
-                        int index, int index2) const {
-  if (m_name[0] != '\0') {
-    std::snprintf(buf, size, "%s [%d,%d]###Name%d", m_name, index, index2,
-                  index);
-  } else {
-    std::snprintf(buf, size, "%s[%d,%d]###Name%d", defaultName, index, index2,
-                  index);
-  }
-}
-
-bool NameInfo::ReadIni(std::string_view name, std::string_view value) {
-  if (name != "name") {
-    return false;
-  }
-  size_t len = (std::min)(value.size(), sizeof(m_name) - 1);
-  std::memcpy(m_name, value.data(), len);
-  m_name[len] = '\0';
-  return true;
-}
-
-void NameInfo::WriteIni(ImGuiTextBuffer* out) {
-  out->appendf("name=%s\n", m_name);
-}
-
-void NameInfo::PushEditNameId(int index) {
-  char id[64];
-  std::snprintf(id, sizeof(id), "Name%d", index);
-  ImGui::PushID(id);
-}
-
-void NameInfo::PushEditNameId(const char* name) {
-  char id[128];
-  std::snprintf(id, sizeof(id), "Name%s", name);
-  ImGui::PushID(id);
-}
-
-bool NameInfo::PopupEditName(int index) {
-  bool rv = false;
-  char id[64];
-  std::snprintf(id, sizeof(id), "Name%d", index);
-  if (ImGui::BeginPopupContextItem(id)) {
-    ImGui::Text("Edit name:");
-    if (InputTextName("##edit")) {
-      rv = true;
-    }
-    if (ImGui::Button("Close") || ImGui::IsKeyPressedMap(ImGuiKey_Enter) ||
-        ImGui::IsKeyPressedMap(ImGuiKey_KeyPadEnter)) {
-      ImGui::CloseCurrentPopup();
-    }
-    ImGui::EndPopup();
-  }
-  return rv;
-}
-
-bool NameInfo::PopupEditName(const char* name) {
-  bool rv = false;
-  char id[128];
-  std::snprintf(id, sizeof(id), "Name%s", name);
-  if (ImGui::BeginPopupContextItem(id)) {
-    ImGui::Text("Edit name:");
-    if (InputTextName("##edit")) {
-      rv = true;
-    }
-    if (ImGui::Button("Close") || ImGui::IsKeyPressedMap(ImGuiKey_Enter) ||
-        ImGui::IsKeyPressedMap(ImGuiKey_KeyPadEnter)) {
-      ImGui::CloseCurrentPopup();
-    }
-    ImGui::EndPopup();
-  }
-  return rv;
-}
-
-bool NameInfo::InputTextName(const char* label_id, ImGuiInputTextFlags flags) {
-  return ImGui::InputText(label_id, m_name, sizeof(m_name), flags);
-}
-
-bool OpenInfo::ReadIni(std::string_view name, std::string_view value) {
-  if (name != "open") {
-    return false;
-  }
-  if (auto num = wpi::parse_integer<int>(value, 10)) {
-    m_open = num.value();
-  }
-  return true;
-}
-
-void OpenInfo::WriteIni(ImGuiTextBuffer* out) {
-  out->appendf("open=%d\n", m_open ? 1 : 0);
-}
-
-bool NameOpenInfo::ReadIni(std::string_view name, std::string_view value) {
-  if (NameInfo::ReadIni(name, value)) {
-    return true;
-  }
-  if (OpenInfo::ReadIni(name, value)) {
-    return true;
-  }
-  return false;
-}
-
-void NameOpenInfo::WriteIni(ImGuiTextBuffer* out) {
-  NameInfo::WriteIni(out);
-  OpenInfo::WriteIni(out);
-}

glass/src/lib/native/cpp/support/NameSetting.cpp

@@ -0,0 +1,123 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#include "glass/support/NameSetting.h"
+
+#include <cstdio>
+#include <cstring>
+
+#include <imgui_internal.h>
+#include <imgui_stdlib.h>
+#include <wpi/StringExtras.h>
+
+using namespace glass;
+
+void NameSetting::GetName(char* buf, size_t size,
+                          const char* defaultName) const {
+  if (!m_name.empty()) {
+    std::snprintf(buf, size, "%s", m_name.c_str());
+  } else {
+    std::snprintf(buf, size, "%s", defaultName);
+  }
+}
+
+void NameSetting::GetName(char* buf, size_t size, const char* defaultName,
+                          int index) const {
+  if (!m_name.empty()) {
+    std::snprintf(buf, size, "%s [%d]", m_name.c_str(), index);
+  } else {
+    std::snprintf(buf, size, "%s[%d]", defaultName, index);
+  }
+}
+
+void NameSetting::GetName(char* buf, size_t size, const char* defaultName,
+                          int index, int index2) const {
+  if (!m_name.empty()) {
+    std::snprintf(buf, size, "%s [%d,%d]", m_name.c_str(), index, index2);
+  } else {
+    std::snprintf(buf, size, "%s[%d,%d]", defaultName, index, index2);
+  }
+}
+
+void NameSetting::GetLabel(char* buf, size_t size,
+                           const char* defaultName) const {
+  if (!m_name.empty()) {
+    std::snprintf(buf, size, "%s###Name%s", m_name.c_str(), defaultName);
+  } else {
+    std::snprintf(buf, size, "%s###Name%s", defaultName, defaultName);
+  }
+}
+
+void NameSetting::GetLabel(char* buf, size_t size, const char* defaultName,
+                           int index) const {
+  if (!m_name.empty()) {
+    std::snprintf(buf, size, "%s [%d]###Name%d", m_name.c_str(), index, index);
+  } else {
+    std::snprintf(buf, size, "%s[%d]###Name%d", defaultName, index, index);
+  }
+}
+
+void NameSetting::GetLabel(char* buf, size_t size, const char* defaultName,
+                           int index, int index2) const {
+  if (!m_name.empty()) {
+    std::snprintf(buf, size, "%s [%d,%d]###Name%d", m_name.c_str(), index,
+                  index2, index);
+  } else {
+    std::snprintf(buf, size, "%s[%d,%d]###Name%d", defaultName, index, index2,
+                  index);
+  }
+}
+
+void NameSetting::PushEditNameId(int index) {
+  char id[64];
+  std::snprintf(id, sizeof(id), "Name%d", index);
+  ImGui::PushID(id);
+}
+
+void NameSetting::PushEditNameId(const char* name) {
+  char id[128];
+  std::snprintf(id, sizeof(id), "Name%s", name);
+  ImGui::PushID(id);
+}
+
+bool NameSetting::PopupEditName(int index) {
+  bool rv = false;
+  char id[64];
+  std::snprintf(id, sizeof(id), "Name%d", index);
+  if (ImGui::BeginPopupContextItem(id)) {
+    ImGui::Text("Edit name:");
+    if (InputTextName("##edit")) {
+      rv = true;
+    }
+    if (ImGui::Button("Close") || ImGui::IsKeyPressedMap(ImGuiKey_Enter) ||
+        ImGui::IsKeyPressedMap(ImGuiKey_KeyPadEnter)) {
+      ImGui::CloseCurrentPopup();
+    }
+    ImGui::EndPopup();
+  }
+  return rv;
+}
+
+bool NameSetting::PopupEditName(const char* name) {
+  bool rv = false;
+  char id[128];
+  std::snprintf(id, sizeof(id), "Name%s", name);
+  if (ImGui::BeginPopupContextItem(id)) {
+    ImGui::Text("Edit name:");
+    if (InputTextName("##edit")) {
+      rv = true;
+    }
+    if (ImGui::Button("Close") || ImGui::IsKeyPressedMap(ImGuiKey_Enter) ||
+        ImGui::IsKeyPressedMap(ImGuiKey_KeyPadEnter)) {
+      ImGui::CloseCurrentPopup();
+    }
+    ImGui::EndPopup();
+  }
+  return rv;
+}
+
+bool NameSetting::InputTextName(const char* label_id,
+                                ImGuiInputTextFlags flags) {
+  return ImGui::InputText(label_id, &m_name, flags);
+}

glass/src/lib/native/include/glass/Context.h

@@ -4,17 +4,16 @@
 
 #pragma once
 
-#include <memory>
+#include <functional>
 #include <string>
 #include <string_view>
-#include <utility>
-#include <vector>
 
 #include <imgui.h>
 
 namespace glass {
 
-struct Context;
+class Context;
+class Storage;
 
 Context* CreateContext();
 void DestroyContext(Context* ctx = nullptr);
@@ -32,86 +31,135 @@ void ResetTime();
 uint64_t GetZeroTime();
 
 /**
- * Storage provides both persistent and non-persistent key/value storage for
- * widgets.
- *
- * Keys are always strings.  The storage also provides non-persistent arbitrary
- * data storage (via std::shared_ptr<void>).
- *
- * Storage is automatically indexed internally by the ID stack.  Note it is
- * necessary to use the glass wrappers for PushID et al to preserve naming in
- * the save file (unnamed values are still stored, but this is non-ideal for
- * users trying to hand-edit the save file).
+ * Resets the workspace (all storage except window storage).
+ * Operates effectively like calling LoadStorage() on a path with no existing
+ * storage files. Note this will result in auto-saving of the reset state to
+ * storage.
  */
-class Storage {
- public:
-  struct Value {
-    Value() = default;
-    explicit Value(std::string_view str) : stringVal{str} {}
+void WorkspaceReset();
 
-    enum Type { kNone, kInt, kInt64, kBool, kFloat, kDouble, kString };
-    Type type = kNone;
-    union {
-      int intVal;
-      int64_t int64Val;
-      bool boolVal;
-      float floatVal;
-      double doubleVal;
-    };
-    std::string stringVal;
-  };
+/**
+ * Adds function to be called during workspace (storage) initialization/load.
+ * This should set up any initial default state, restore stored
+ * settings/windows, etc. This will be called after the storage is initialized.
+ * This must be called prior to WorkspaceInit() for proper automatic startup
+ * loading.
+ *
+ * @param init initialization function
+ */
+void AddWorkspaceInit(std::function<void()> init);
 
-  int GetInt(std::string_view key, int defaultVal = 0) const;
-  int64_t GetInt64(std::string_view key, int64_t defaultVal = 0) const;
-  bool GetBool(std::string_view key, bool defaultVal = false) const;
-  float GetFloat(std::string_view key, float defaultVal = 0.0f) const;
-  double GetDouble(std::string_view key, double defaultVal = 0.0) const;
-  std::string GetString(std::string_view key,
-                        std::string_view defaultVal = {}) const;
+/**
+ * Adds function to be called during workspace (storage) reset.  This should
+ * bring back the state to startup state (e.g. remove any storage references,
+ * destroy windows, etc). This will be called prior to the storage being
+ * destroyed.
+ *
+ * @param reset reset function
+ */
+void AddWorkspaceReset(std::function<void()> reset);
 
-  void SetInt(std::string_view key, int val);
-  void SetInt64(std::string_view key, int64_t val);
-  void SetBool(std::string_view key, bool val);
-  void SetFloat(std::string_view key, float val);
-  void SetDouble(std::string_view key, double val);
-  void SetString(std::string_view key, std::string_view val);
+/**
+ * Sets storage load and auto-save name.
+ * Call this prior to calling wpi::gui::Initialize() for automatic startup
+ * loading.
+ *
+ * @param name base name, suffix will be generated
+ */
+void SetStorageName(std::string_view name);
 
-  int* GetIntRef(std::string_view key, int defaultVal = 0);
-  int64_t* GetInt64Ref(std::string_view key, int64_t defaultVal = 0);
-  bool* GetBoolRef(std::string_view key, bool defaultVal = false);
-  float* GetFloatRef(std::string_view key, float defaultVal = 0.0f);
-  double* GetDoubleRef(std::string_view key, double defaultVal = 0.0);
-  std::string* GetStringRef(std::string_view key,
-                            std::string_view defaultVal = {});
+/**
+ * Sets storage load and auto-save directory. For more customized behavior, set
+ * Context::storageLoadPath and Context::storageAutoSavePath directly.
+ * Call this prior to calling wpi::gui::Initialize() for automatic startup
+ * loading.
+ *
+ * @param dir path to directory
+ */
+void SetStorageDir(std::string_view dir);
 
-  Value& GetValue(std::string_view key);
+/**
+ * Gets storage auto-save directory.
+ *
+ * @return Path to directory
+ */
+std::string GetStorageDir();
 
-  void SetData(std::shared_ptr<void>&& data) { m_data = std::move(data); }
+/**
+ * Explicitly load storage. Set Context::storageLoadDir prior to calling
+ * wpi::gui::Initialize() for automatic startup loading.
+ *
+ * Non-empty root names are not loaded unless GetStorageRoot() is called during
+ * initialization (or before this function is called).
+ *
+ * @param dir path to directory
+ */
+bool LoadStorage(std::string_view dir);
 
-  template <typename T>
-  T* GetData() const {
-    return static_cast<T*>(m_data.get());
-  }
+/**
+ * Save storage to automatic on-change save location.
+ */
+bool SaveStorage();
 
-  Storage() = default;
-  Storage(const Storage&) = delete;
-  Storage& operator=(const Storage&) = delete;
+/**
+ * Explicitly save storage. Set Context::storageAutoSaveDir prior to calling
+ * wpi::gui::Initialize() for automatic on-change saving.
+ *
+ * @param dir path to directory
+ */
+bool SaveStorage(std::string_view dir);
 
-  std::vector<std::string>& GetKeys() { return m_keys; }
-  const std::vector<std::string>& GetKeys() const { return m_keys; }
-  std::vector<std::unique_ptr<Value>>& GetValues() { return m_values; }
-  const std::vector<std::unique_ptr<Value>>& GetValues() const {
-    return m_values;
-  }
+/**
+ * Gets the storage root for the current ID stack (e.g. the last call to
+ * ResetStorageStack).
+ *
+ * @return Storage object
+ */
+Storage& GetCurStorageRoot();
 
- private:
-  mutable std::vector<std::string> m_keys;
-  mutable std::vector<std::unique_ptr<Value>> m_values;
-  std::shared_ptr<void> m_data;
-};
+/**
+ * Gets an arbitrary storage root.
+ *
+ * Non-empty root names are saved but not loaded unless GetStorageRoot()
+ * is called during initialization (or before LoadStorage is called).
+ *
+ * @param rootName root name
+ * @return Storage object
+ */
+Storage& GetStorageRoot(std::string_view rootName = {});
 
+/**
+ * Resets storage stack.  Should only be called at top level.
+ *
+ * @param rootName root name
+ */
+void ResetStorageStack(std::string_view rootName = {});
+
+/**
+ * Gets the storage object for the current point in the ID stack.
+ *
+ * @return Storage object
+ */
 Storage& GetStorage();
-Storage& GetStorage(std::string_view id);
+
+/**
+ * Pushes label/ID onto the storage stack, without pushing the imgui ID stack.
+ *
+ * @param label_id label or label###id
+ */
+void PushStorageStack(std::string_view label_id);
+
+/**
+ * Pushes specific storage onto the storage stack.
+ *
+ * @param storage storage
+ */
+void PushStorageStack(Storage& storage);
+
+/**
+ * Pops storage stack, without popping the imgui ID stack.
+ */
+void PopStorageStack();
 
 bool Begin(const char* name, bool* p_open = nullptr,
            ImGuiWindowFlags flags = 0);

glass/src/lib/native/include/glass/ContextInternal.h

@@ -6,42 +6,40 @@
 
 #include <stdint.h>
 
+#include <functional>
 #include <memory>
+#include <string>
+#include <vector>
 
-#include <imgui.h>
-#include <wpi/SmallString.h>
 #include <wpi/SmallVector.h>
 #include <wpi/StringMap.h>
 
 #include "glass/Context.h"
-#include "glass/support/IniSaverInfo.h"
-#include "glass/support/IniSaverString.h"
+#include "glass/Storage.h"
 
 namespace glass {
 
 class DataSource;
 
-class DataSourceName {
+class Context {
  public:
-  DataSourceName() = default;
-  explicit DataSourceName(DataSource* source) : source{source} {}
+  Context();
+  Context(const Context&) = delete;
+  Context& operator=(const Context&) = delete;
+  ~Context();
 
-  bool ReadIni(std::string_view name_, std::string_view value) {
-    return name->ReadIni(name_, value);
-  }
-  void WriteIni(ImGuiTextBuffer* out) { name->WriteIni(out); }
-
-  std::unique_ptr<NameInfo> name{new NameInfo};
-  DataSource* source = nullptr;
-};
-
-struct Context {
-  wpi::SmallString<128> curId;
-  wpi::SmallVector<size_t, 32> idStack;
-  wpi::StringMap<std::unique_ptr<Storage>> storage;
+  std::vector<std::function<void()>> workspaceInit;
+  std::vector<std::function<void()>> workspaceReset;
+  std::string storageLoadDir = ".";
+  std::string storageAutoSaveDir = ".";
+  std::string storageName = "imgui";
+  wpi::SmallVector<Storage*, 32> storageStack;
+  wpi::StringMap<std::unique_ptr<Storage>> storageRoots;
   wpi::StringMap<bool> deviceHidden;
-  IniSaverString<DataSourceName> sources{"Data Sources"};
+  wpi::StringMap<DataSource*> sources;
+  Storage& sourceNameStorage;
   uint64_t zeroTime = 0;
+  bool isPlatformSaveDir = false;
 };
 
 extern Context* gContext;

glass/src/lib/native/include/glass/DataSource.h

@@ -16,8 +16,6 @@
 
 namespace glass {
 
-class NameInfo;
-
 /**
  * A data source for numeric/boolean data.
  */
@@ -33,15 +31,9 @@ class DataSource {
 
   const char* GetId() const { return m_id.c_str(); }
 
-  void SetName(std::string_view name);
-  const char* GetName() const;
-  NameInfo& GetNameInfo() { return *m_name; }
-
-  void PushEditNameId(int index);
-  void PushEditNameId(const char* name);
-  bool PopupEditName(int index);
-  bool PopupEditName(const char* name);
-  bool InputTextName(const char* label_id, ImGuiInputTextFlags flags = 0);
+  void SetName(std::string_view name) { m_name = name; }
+  std::string& GetName() { return m_name; }
+  const std::string& GetName() const { return m_name; }
 
   void SetDigital(bool digital) { m_digital = digital; }
   bool IsDigital() const { return m_digital; }
@@ -53,8 +45,9 @@ class DataSource {
   double GetValue() const { return m_value; }
 
   // drag source helpers
-  void LabelText(const char* label, const char* fmt, ...) const;
-  void LabelTextV(const char* label, const char* fmt, va_list args) const;
+  void LabelText(const char* label, const char* fmt, ...) const IM_FMTARGS(3);
+  void LabelTextV(const char* label, const char* fmt, va_list args) const
+      IM_FMTLIST(3);
   bool Combo(const char* label, int* current_item, const char* const items[],
              int items_count, int popup_max_height_in_items = -1) const;
   bool SliderFloat(const char* label, float* v, float v_min, float v_max,
@@ -74,7 +67,7 @@ class DataSource {
 
  private:
   std::string m_id;
-  NameInfo* m_name;
+  std::string& m_name;
   bool m_digital = false;
   std::atomic<double> m_value = 0;
 };

glass/src/lib/native/include/glass/MainMenuBar.h

@@ -4,13 +4,14 @@
 
 #pragma once
 
+#include <portable-file-dialogs.h>
+
 #include <functional>
+#include <memory>
 #include <vector>
 
 namespace glass {
 
-class WindowManager;
-
 /**
  * GUI main menu bar.
  */
@@ -21,6 +22,11 @@ class MainMenuBar {
    */
   void Display();
 
+  /**
+   * Displays workspace menu.  Called by Display().
+   */
+  void WorkspaceMenu();
+
   /**
    * Adds to GUI's main menu bar.  The menu function is called from within a
    * ImGui::BeginMainMenuBar()/EndMainMenuBar() block.  Usually it's only
@@ -43,6 +49,8 @@ class MainMenuBar {
  private:
   std::vector<std::function<void()>> m_optionMenus;
   std::vector<std::function<void()>> m_menus;
+  std::unique_ptr<pfd::select_folder> m_openFolder;
+  std::unique_ptr<pfd::select_folder> m_saveFolder;
 };
 
 }  // namespace glass

glass/src/lib/native/include/glass/Provider.h

@@ -19,6 +19,8 @@
 
 namespace glass {
 
+class Storage;
+
 namespace detail {
 struct ProviderFunctions {
   using Exists = std::function<bool()>;
@@ -49,9 +51,9 @@ class Provider : public WindowManager {
   /**
    * Constructor.
    *
-   * @param iniName Group name to use in ini file
+   * @param storage Storage
    */
-  explicit Provider(std::string_view iniName) : WindowManager{iniName} {}
+  explicit Provider(Storage& storage) : WindowManager{storage} {}
 
   Provider(const Provider&) = delete;
   Provider& operator=(const Provider&) = delete;
@@ -133,6 +135,7 @@ class Provider : public WindowManager {
     ModelEntry* modelEntry;
     ViewExistsFunc exists;
     CreateViewFunc createView;
+    bool showDefault = false;
     Window* window = nullptr;
   };
 

glass/src/lib/native/include/glass/Provider.inc

@@ -26,7 +26,7 @@ void Provider<Functions>::ShowDefault(std::string_view name) {
   if (it == m_viewEntries.end() || (*it)->name != name) {
     return;
   }
-  this->Show(it->get(), (*it)->window);
+  (*it)->showDefault = true;
 }
 
 template <typename Functions>

glass/src/lib/native/include/glass/Storage.h

@@ -0,0 +1,293 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+#pragma once
+
+#include <stdint.h>
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+#include <wpi/StringMap.h>
+#include <wpi/iterator_range.h>
+#include <wpi/span.h>
+
+namespace wpi {
+class json;
+}  // namespace wpi
+
+namespace glass {
+
+namespace detail {
+template <typename IteratorType>
+class ChildIterator;
+}  // namespace detail
+
+/**
+ * Storage provides both persistent and non-persistent nested key/value storage
+ * for widgets.
+ *
+ * Keys are always strings.  The storage also provides non-persistent arbitrary
+ * data storage (via std::shared_ptr<void>).
+ *
+ * Storage is automatically indexed internally by the ID stack.  Note it is
+ * necessary to use the glass wrappers for PushID et al to preserve naming in
+ * the save file (unnamed values are still stored, but this is non-ideal for
+ * users trying to hand-edit the save file).
+ */
+class Storage {
+ public:
+  struct Value {
+    enum Type {
+      kNone,
+      kInt,
+      kInt64,
+      kBool,
+      kFloat,
+      kDouble,
+      kString,
+      kChild,
+      kIntArray,
+      kInt64Array,
+      kBoolArray,
+      kFloatArray,
+      kDoubleArray,
+      kStringArray,
+      kChildArray
+    };
+
+    Value() = default;
+    explicit Value(Type type) : type{type} {}
+    Value(const Value&) = delete;
+    Value& operator=(const Value&) = delete;
+    ~Value() { Reset(kNone); }
+
+    Type type = kNone;
+    union {
+      int intVal;
+      int64_t int64Val;
+      bool boolVal;
+      float floatVal;
+      double doubleVal;
+      Storage* child;
+      std::vector<int>* intArray;
+      std::vector<int64_t>* int64Array;
+      std::vector<int>* boolArray;
+      std::vector<float>* floatArray;
+      std::vector<double>* doubleArray;
+      std::vector<std::string>* stringArray;
+      std::vector<std::unique_ptr<Storage>>* childArray;
+    };
+    std::string stringVal;
+
+    union {
+      int intDefault;
+      int64_t int64Default;
+      bool boolDefault;
+      float floatDefault;
+      double doubleDefault;
+      // pointers may be nullptr to indicate empty
+      std::vector<int>* intArrayDefault;
+      std::vector<int64_t>* int64ArrayDefault;
+      std::vector<int>* boolArrayDefault;
+      std::vector<float>* floatArrayDefault;
+      std::vector<double>* doubleArrayDefault;
+      std::vector<std::string>* stringArrayDefault;
+    };
+    std::string stringDefault;
+
+    bool hasDefault = false;
+
+    void Reset(Type newType);
+  };
+
+  using ValueMap = wpi::StringMap<std::unique_ptr<Value>>;
+  template <typename Iterator>
+  using ChildIterator = detail::ChildIterator<Iterator>;
+
+  // The "Read" functions don't create or overwrite the value
+  int ReadInt(std::string_view key, int defaultVal = 0) const;
+  int64_t ReadInt64(std::string_view key, int64_t defaultVal = 0) const;
+  bool ReadBool(std::string_view key, bool defaultVal = false) const;
+  float ReadFloat(std::string_view key, float defaultVal = 0.0f) const;
+  double ReadDouble(std::string_view key, double defaultVal = 0.0) const;
+  std::string ReadString(std::string_view key,
+                         std::string_view defaultVal = {}) const;
+
+  void SetInt(std::string_view key, int val);
+  void SetInt64(std::string_view key, int64_t val);
+  void SetBool(std::string_view key, bool val);
+  void SetFloat(std::string_view key, float val);
+  void SetDouble(std::string_view key, double val);
+  void SetString(std::string_view key, std::string_view val);
+
+  // The "Get" functions create or override the current value type.
+  // If the value is not set, it is set to the provided default.
+  int& GetInt(std::string_view key, int defaultVal = 0);
+  int64_t& GetInt64(std::string_view key, int64_t defaultVal = 0);
+  bool& GetBool(std::string_view key, bool defaultVal = false);
+  float& GetFloat(std::string_view key, float defaultVal = 0.0f);
+  double& GetDouble(std::string_view key, double defaultVal = 0.0);
+  std::string& GetString(std::string_view key,
+                         std::string_view defaultVal = {});
+
+  std::vector<int>& GetIntArray(std::string_view key,
+                                wpi::span<const int> defaultVal = {});
+  std::vector<int64_t>& GetInt64Array(std::string_view key,
+                                      wpi::span<const int64_t> defaultVal = {});
+  std::vector<int>& GetBoolArray(std::string_view key,
+                                 wpi::span<const int> defaultVal = {});
+  std::vector<float>& GetFloatArray(std::string_view key,
+                                    wpi::span<const float> defaultVal = {});
+  std::vector<double>& GetDoubleArray(std::string_view key,
+                                      wpi::span<const double> defaultVal = {});
+  std::vector<std::string>& GetStringArray(
+      std::string_view key, wpi::span<const std::string> defaultVal = {});
+  std::vector<std::unique_ptr<Storage>>& GetChildArray(std::string_view key);
+
+  Value* FindValue(std::string_view key);
+  Value& GetValue(std::string_view key);
+  Storage& GetChild(std::string_view label_id);
+
+  void SetData(std::shared_ptr<void>&& data) { m_data = std::move(data); }
+
+  template <typename T>
+  T* GetData() const {
+    return static_cast<T*>(m_data.get());
+  }
+
+  Storage() = default;
+  Storage(const Storage&) = delete;
+  Storage& operator=(const Storage&) = delete;
+
+  void Insert(std::string_view key, std::unique_ptr<Value> value) {
+    m_values[key] = std::move(value);
+  }
+
+  std::unique_ptr<Value> Erase(std::string_view key);
+
+  void EraseAll() { m_values.clear(); }
+
+  ValueMap& GetValues() { return m_values; }
+  const ValueMap& GetValues() const { return m_values; }
+
+  wpi::iterator_range<ChildIterator<ValueMap::iterator>> GetChildren();
+
+  /**
+   * Erases all children (at top level).
+   */
+  void EraseChildren();
+
+  bool FromJson(const wpi::json& json, const char* filename);
+  wpi::json ToJson() const;
+
+  /**
+   * Clear settings (set to default).  Calls custom clear function (if set),
+   * otherwise calls ClearValues().
+   */
+  void Clear();
+
+  /**
+   * Clear values (and values of children) only (set to default).  Does not
+   * call custom clear function.
+   */
+  void ClearValues();
+
+  /**
+   * Apply settings (called after all settings have been loaded).  Calls
+   * custom apply function (if set), otherwise calls ApplyChildren().
+   */
+  void Apply();
+
+  /**
+   * Apply settings to children.  Does not call custom apply function.
+   */
+  void ApplyChildren();
+
+  /**
+   * Sets custom JSON handlers (replaces FromJson and ToJson).
+   *
+   * @param fromJson replacement for FromJson()
+   * @param toJson replacement for ToJson()
+   */
+  void SetCustomJson(
+      std::function<bool(const wpi::json& json, const char* filename)> fromJson,
+      std::function<wpi::json()> toJson) {
+    m_fromJson = std::move(fromJson);
+    m_toJson = std::move(toJson);
+  }
+
+  void SetCustomClear(std::function<void()> clear) {
+    m_clear = std::move(clear);
+  }
+
+  void SetCustomApply(std::function<void()> apply) {
+    m_apply = std::move(apply);
+  }
+
+ private:
+  mutable ValueMap m_values;
+  std::shared_ptr<void> m_data;
+  std::function<bool(const wpi::json& json, const char* filename)> m_fromJson;
+  std::function<wpi::json()> m_toJson;
+  std::function<void()> m_clear;
+  std::function<void()> m_apply;
+};
+
+namespace detail {
+
+/// proxy class for the GetChildren() function
+template <typename IteratorType>
+class ChildIterator {
+ private:
+  /// the iterator
+  IteratorType anchor;
+  IteratorType end;
+
+ public:
+  ChildIterator(IteratorType it, IteratorType end) noexcept
+      : anchor(it), end(end) {
+    while (anchor != end &&
+           anchor->getValue()->type != Storage::Value::kChild) {
+      ++anchor;
+    }
+  }
+
+  /// dereference operator (needed for range-based for)
+  ChildIterator& operator*() { return *this; }
+
+  /// increment operator (needed for range-based for)
+  ChildIterator& operator++() {
+    ++anchor;
+    while (anchor != end &&
+           anchor->getValue()->type != Storage::Value::kChild) {
+      ++anchor;
+    }
+    return *this;
+  }
+
+  /// inequality operator (needed for range-based for)
+  bool operator!=(const ChildIterator& o) const noexcept {
+    return anchor != o.anchor;
+  }
+
+  /// return key of the iterator
+  std::string_view key() const { return anchor->getKey(); }
+
+  /// return value of the iterator
+  Storage& value() const { return *anchor->getValue()->child; }
+};
+
+}  // namespace detail
+
+inline auto Storage::GetChildren()
+    -> wpi::iterator_range<ChildIterator<ValueMap::iterator>> {
+  return {{m_values.begin(), m_values.end()}, {m_values.end(), m_values.end()}};
+}
+
+}  // namespace glass

glass/src/lib/native/include/glass/Window.h

@@ -15,19 +15,21 @@
 
 namespace glass {
 
+class Storage;
+
 /**
  * Managed window information.
  * A Window owns the View that displays the window's contents.
  */
 class Window {
  public:
-  Window() = default;
-  explicit Window(std::string_view id) : m_id{id}, m_defaultName{id} {}
+  enum Visibility { kHide = 0, kShow, kDisabled };
+
+  Window(Storage& storage, std::string_view id,
+         Visibility defaultVisibility = kShow);
 
   std::string_view GetId() const { return m_id; }
 
-  enum Visibility { kHide = 0, kShow, kDisabled };
-
   bool HasView() { return static_cast<bool>(m_view); }
 
   void SetView(std::unique_ptr<View> view) { m_view = std::move(view); }
@@ -59,6 +61,13 @@ class Window {
    */
   void SetVisibility(Visibility visibility);
 
+  /**
+   * Sets default visibility of window.
+   *
+   * @param visibility 0=hide, 1=show, 2=disabled (force-hide)
+   */
+  void SetDefaultVisibility(Visibility visibility);
+
   /**
    * Sets default position of window.
    *
@@ -109,17 +118,16 @@ class Window {
    */
   void ScaleDefault(float scale);
 
-  void IniReadLine(const char* lineStr);
-  void IniWriteAll(const char* typeName, ImGuiTextBuffer* out_buf);
-
  private:
   std::string m_id;
-  std::string m_name;
+  std::string& m_name;
   std::string m_defaultName;
   std::unique_ptr<View> m_view;
   ImGuiWindowFlags m_flags = 0;
-  bool m_visible = true;
-  bool m_enabled = true;
+  bool& m_visible;
+  bool& m_enabled;
+  bool& m_defaultVisible;
+  bool& m_defaultEnabled;
   bool m_renamePopupEnabled = true;
   ImGuiCond m_posCond = 0;
   ImGuiCond m_sizeCond = 0;

glass/src/lib/native/include/glass/WindowManager.h

@@ -4,20 +4,18 @@
 
 #pragma once
 
-#include <functional>
 #include <memory>
 #include <string_view>
-#include <type_traits>
 #include <vector>
 
-#include <imgui.h>
 #include <wpi/FunctionExtras.h>
 
 #include "glass/Window.h"
-#include "glass/support/IniSaverBase.h"
 
 namespace glass {
 
+class Storage;
+
 /**
  * Window manager.
  *
@@ -31,9 +29,9 @@ class WindowManager {
   /**
    * Constructor.
    *
-   * @param iniName Group name to use in ini file
+   * @param storage Storage for window information
    */
-  explicit WindowManager(std::string_view iniName);
+  explicit WindowManager(Storage& storage);
   virtual ~WindowManager() = default;
 
   WindowManager(const WindowManager&) = delete;
@@ -65,8 +63,10 @@ class WindowManager {
    *
    * @param id unique identifier of the window (title bar)
    * @param display window contents display function
+   * @param defaultVisibility default window visibility
    */
-  Window* AddWindow(std::string_view id, wpi::unique_function<void()> display);
+  Window* AddWindow(std::string_view id, wpi::unique_function<void()> display,
+                    Window::Visibility defaultVisibility = Window::kShow);
 
   /**
    * Adds window to GUI.  The view's display function is called from within a
@@ -82,9 +82,11 @@ class WindowManager {
    *
    * @param id unique identifier of the window (title bar)
    * @param view view object
+   * @param defaultVisibility default window visibility
    * @return Window, or nullptr on duplicate window
    */
-  Window* AddWindow(std::string_view id, std::unique_ptr<View> view);
+  Window* AddWindow(std::string_view id, std::unique_ptr<View> view,
+                    Window::Visibility defaultVisibility = Window::kShow);
 
   /**
    * Adds window to GUI.  A View must be assigned to the returned Window
@@ -99,9 +101,12 @@ class WindowManager {
    * every frame in the gui::AddExecute() function.
    *
    * @param id unique identifier of the window (default title bar)
+   * @param duplicateOk if false, warn on duplicates
+   * @param defaultVisibility default window visibility
    * @return Window, or nullptr on duplicate window
    */
-  Window* GetOrAddWindow(std::string_view id, bool duplicateOk = false);
+  Window* GetOrAddWindow(std::string_view id, bool duplicateOk = false,
+                         Window::Visibility defaultVisibility = Window::kShow);
 
   /**
    * Gets existing window.  If none exists, returns nullptr.
@@ -111,27 +116,26 @@ class WindowManager {
    */
   Window* GetWindow(std::string_view id);
 
+  /**
+   * Erases all windows.
+   */
+  void EraseWindows() { m_windows.clear(); }
+
  protected:
-  virtual void DisplayWindows();
+  /**
+   * Removes existing window (by index)
+   *
+   * @param index index of window in m_windows
+   */
+  void RemoveWindow(size_t index);
 
   // kept sorted by id
   std::vector<std::unique_ptr<Window>> m_windows;
 
+  Storage& m_storage;
+
  private:
-  class IniSaver : public IniSaverBase {
-   public:
-    explicit IniSaver(std::string_view typeName, WindowManager* manager)
-        : IniSaverBase{typeName}, m_manager{manager} {}
-
-    void* IniReadOpen(const char* name) override;
-    void IniReadLine(void* entry, const char* lineStr) override;
-    void IniWriteAll(ImGuiTextBuffer* out_buf) override;
-
-   private:
-    WindowManager* m_manager;
-  };
-
-  IniSaver m_iniSaver;
+  void DisplayWindows();
 };
 
 }  // namespace glass

glass/src/lib/native/include/glass/other/FMS.h

@@ -47,7 +47,7 @@ class FMSModel : public Model {
  * @param matchTimeEnabled If not null, a checkbox is displayed for
  *                         "enable match time" linked to this value
  */
-void DisplayFMS(FMSModel* model, bool* matchTimeEnabled = nullptr);
+void DisplayFMS(FMSModel* model);
 void DisplayFMSReadOnly(FMSModel* model);
 
 }  // namespace glass