diff --git a/resource/CMakeResources.cmake b/resource/CMakeResources.cmake
index 249fb93ac..920886b6f 100644
--- a/resource/CMakeResources.cmake
+++ b/resource/CMakeResources.cmake
@@ -7,7 +7,7 @@ function(add_resources out_var id)
     "\n"
     "namespace ${id}\n"
     "{\n"
-    "  extern const std::map<uint32_t, std::pair<const unsigned char *, unsigned int>> data\;\n"
+    "    extern const std::map<uint32_t, std::pair<const unsigned char *, unsigned int>> data\;\n"
     "}\n"
   )
 
@@ -20,7 +20,7 @@ function(add_resources out_var id)
     "namespace ${id}\n"
     "{\n"
     "\n"
-    "  const std::map<uint32_t, std::pair<const unsigned char *, unsigned int>> data = {\n"
+    "    const std::map<uint32_t, std::pair<const unsigned char *, unsigned int>> data = {\n"
   )
 
   set(options ${ARGN})
@@ -46,13 +46,13 @@ function(add_resources out_var id)
       "extern int ${symbol}_len\;\n"
       "\n")
     string(APPEND content_cpp_public
-      "    {${resource_id}, {${symbol}, ${symbol}_len}},\n")
+      "        {${resource_id}, {${symbol}, ${symbol}_len}},\n")
 
     list(APPEND result ${out_f_cpp})
   endwhile()
 
   string(APPEND content_cpp_public
-    "  }\;\n"
+    "    }\;\n"
     "\n"
     "}\n"
   )
diff --git a/source/frontends/.clang-format b/source/frontends/.clang-format
new file mode 120000
index 000000000..f95032f4f
--- /dev/null
+++ b/source/frontends/.clang-format
@@ -0,0 +1 @@
+../linux/.clang-format
\ No newline at end of file
diff --git a/source/frontends/common2/argparser.cpp b/source/frontends/common2/argparser.cpp
index 5794fac18..1ada91816 100644
--- a/source/frontends/common2/argparser.cpp
+++ b/source/frontends/common2/argparser.cpp
@@ -14,462 +14,444 @@
 namespace
 {
 
-  constexpr int PAUSED            = 1001;
-  constexpr int FIXED_SPEED       = 1002;
-  constexpr int HEADLESS          = 1003;
-  constexpr int NO_SQUARING       = 1004;
-  constexpr int SLIRP_NAT         = 1005;
+    constexpr int PAUSED = 1001;
+    constexpr int FIXED_SPEED = 1002;
+    constexpr int HEADLESS = 1003;
+    constexpr int NO_SQUARING = 1004;
+    constexpr int SLIRP_NAT = 1005;
 
-  constexpr int DISK_H1           = 1006;
-  constexpr int DISK_H2           = 1007;
+    constexpr int DISK_H1 = 1006;
+    constexpr int DISK_H2 = 1007;
 
-  constexpr int MEM_CLEAR         = 1008;
-  constexpr int ROM               = 1009;
-  constexpr int F8ROM             = 1010;
+    constexpr int MEM_CLEAR = 1008;
+    constexpr int ROM = 1009;
+    constexpr int F8ROM = 1010;
 
-  constexpr int NO_AUDIO          = 1011;
-  constexpr int AUDIO_BUFFER      = 1012;
-  constexpr int WAV_SPEAKER       = 1013;
-  constexpr int WAV_MOCKINGBOARD  = 1014;
+    constexpr int NO_AUDIO = 1011;
+    constexpr int AUDIO_BUFFER = 1012;
+    constexpr int WAV_SPEAKER = 1013;
+    constexpr int WAV_MOCKINGBOARD = 1014;
 
-  constexpr int SDL_DRIVER        = 1015;
-  constexpr int GL_SWAP           = 1016;
-  constexpr int TIMER             = 1017;
-  constexpr int NO_IMGUI          = 1018;
-  constexpr int GEOMETRY          = 1019;
-  constexpr int ASPECT_RATIO      = 1020;
-  constexpr int GAME_CONTROLLER   = 1021;
-  constexpr int MAPPING_FILE      = 1022;
-  constexpr int AUDIO_DEVICE      = 1023;
+    constexpr int SDL_DRIVER = 1015;
+    constexpr int GL_SWAP = 1016;
+    constexpr int TIMER = 1017;
+    constexpr int NO_IMGUI = 1018;
+    constexpr int GEOMETRY = 1019;
+    constexpr int ASPECT_RATIO = 1020;
+    constexpr int GAME_CONTROLLER = 1021;
+    constexpr int MAPPING_FILE = 1022;
+    constexpr int AUDIO_DEVICE = 1023;
 
-  constexpr int NO_VIDEO_UPDATE   = 1024;
-  constexpr int EV_DEVICE_NAME    = 1025;
+    constexpr int NO_VIDEO_UPDATE = 1024;
+    constexpr int EV_DEVICE_NAME = 1025;
 
-  struct OptionData_t
-  {
-    const char * name;
-    int has_arg;
-    int val;
-    const char * description;
-    const char * defaultValue;  // optional
-  };
+    struct OptionData_t
+    {
+        const char *name;
+        int has_arg;
+        int val;
+        const char *description;
+        const char *defaultValue; // optional
+    };
 
-  bool isShort(const int val)
-  {
-    return val >= 0 && val <= 0xFF;
-  }
+    bool isShort(const int val)
+    {
+        return val >= 0 && val <= 0xFF;
+    }
 
-  void printHelp(const std::vector<std::pair<std::string, std::vector<OptionData_t>>> & data)
-  {
-    for (const auto & categories : data)
+    void printHelp(const std::vector<std::pair<std::string, std::vector<OptionData_t>>> &data)
     {
-      std::cerr << categories.first << ":" << std::endl;
-      for (const auto & option : categories.second)
-      {
-        std::cerr << "  ";
-        std::ostringstream value;
-        if (isShort(option.val))
-        {
-          value << "[ -" << char(option.val) << " ] ";
-        }
-        else
-        {
-          value << "       ";
-        }
-        value << "--" << option.name;
-        if (option.has_arg == required_argument)
-        {
-          value << " arg";
-        }
-        std::cerr << std::left << std::setw(30) << value.str() << "\t" << option.description << std::endl;
-        if (option.defaultValue)
-        {
-          std::cerr << "\t\t\t\t\t( " << option.defaultValue << " )" << std::endl;
+        for (const auto &categories : data)
+        {
+            std::cerr << categories.first << ":" << std::endl;
+            for (const auto &option : categories.second)
+            {
+                std::cerr << "  ";
+                std::ostringstream value;
+                if (isShort(option.val))
+                {
+                    value << "[ -" << char(option.val) << " ] ";
+                }
+                else
+                {
+                    value << "       ";
+                }
+                value << "--" << option.name;
+                if (option.has_arg == required_argument)
+                {
+                    value << " arg";
+                }
+                std::cerr << std::left << std::setw(30) << value.str() << "\t" << option.description << std::endl;
+                if (option.defaultValue)
+                {
+                    std::cerr << "\t\t\t\t\t( " << option.defaultValue << " )" << std::endl;
+                }
+            }
+            std::cerr << std::endl;
         }
-      }
-      std::cerr << std::endl;
     }
-  }
 
-  void parseGeometry(const std::string & s, std::optional<common2::Geometry> & geometry)
-  {
-    std::smatch m;
-    if (std::regex_match(s, m, std::regex("^(\\d+)x(\\d+)(\\+(\\d+)\\+(\\d+))?$")))
+    void parseGeometry(const std::string &s, std::optional<common2::Geometry> &geometry)
     {
-      const size_t groups = m.size();
-      if (groups == 6)
-      {
-        geometry = common2::Geometry();
-        geometry->width = std::stoi(m.str(1));
-        geometry->height = std::stoi(m.str(2));
-        if (!m.str(3).empty())
-        {
-          geometry->x = std::stoi(m.str(4));
-          geometry->y = std::stoi(m.str(5));
-        }
-        return;
-      }
+        std::smatch m;
+        if (std::regex_match(s, m, std::regex("^(\\d+)x(\\d+)(\\+(\\d+)\\+(\\d+))?$")))
+        {
+            const size_t groups = m.size();
+            if (groups == 6)
+            {
+                geometry = common2::Geometry();
+                geometry->width = std::stoi(m.str(1));
+                geometry->height = std::stoi(m.str(2));
+                if (!m.str(3).empty())
+                {
+                    geometry->x = std::stoi(m.str(4));
+                    geometry->y = std::stoi(m.str(5));
+                }
+                return;
+            }
+        }
+        throw std::runtime_error("Invalid sizes: " + s);
     }
-    throw std::runtime_error("Invalid sizes: " + s);
-  }
 
-  void extractOptions(
-    const std::vector<std::pair<std::string, std::vector<OptionData_t>>>  & data,
-    std::vector<option>                                                   & longOptions,
-    std::string                                                           & shortOptions
-    )
-  {
-    std::ostringstream shorts;
-    for (const auto & categories : data)
+    void extractOptions(
+        const std::vector<std::pair<std::string, std::vector<OptionData_t>>> &data, std::vector<option> &longOptions,
+        std::string &shortOptions)
     {
-      for (const auto & option : categories.second)
-      {
-        longOptions.push_back({option.name, option.has_arg, nullptr, option.val});
-        const int val = option.val;
-        if (isShort(val))
-        {
-          shorts << char(val);
-          if (option.has_arg == required_argument)
-          {
-            shorts << ":";
-          }
-        }
-      }
+        std::ostringstream shorts;
+        for (const auto &categories : data)
+        {
+            for (const auto &option : categories.second)
+            {
+                longOptions.push_back({option.name, option.has_arg, nullptr, option.val});
+                const int val = option.val;
+                if (isShort(val))
+                {
+                    shorts << char(val);
+                    if (option.has_arg == required_argument)
+                    {
+                        shorts << ":";
+                    }
+                }
+            }
+        }
+        longOptions.push_back({nullptr, 0, nullptr, 0});
+        shortOptions.append(shorts.str());
     }
-    longOptions.push_back({nullptr, 0, nullptr, 0});
-    shortOptions.append(shorts.str());
-  }
 
-}
+} // namespace
 
 namespace common2
 {
 
-  bool getEmulatorOptions(int argc, char *const argv[], OptionsType type, const std::string & edition, EmulatorOptions & options)
-  {
-    const std::string name = "Apple Emulator for " + edition + " (based on AppleWin " + getVersion() + ")";
+    bool getEmulatorOptions(
+        int argc, char *const argv[], OptionsType type, const std::string &edition, EmulatorOptions &options)
+    {
+        const std::string name = "Apple Emulator for " + edition + " (based on AppleWin " + getVersion() + ")";
 
-    const std::string configurationFileDefault = options.configurationFile.string();
-    const std::string audioBufferDefault = std::to_string(options.audioBuffer);
+        const std::string configurationFileDefault = options.configurationFile.string();
+        const std::string audioBufferDefault = std::to_string(options.audioBuffer);
 
-    std::vector<std::pair<std::string, std::vector<OptionData_t>>> allOptions =
-      {
-        {
-          name.c_str(),
-          {
-            {"help",                    no_argument,          'h',              "Print this help message"},
-          }
-        },
-        {
-          "Configuration",
-          {
-            {"conf",                    required_argument,    'c',              "Select configuration file", configurationFileDefault.c_str()},
-            {"qt-ini",                  no_argument,          'q',              "Use Qt ini file (read only)"},
-            {"registry",                required_argument,    'r',              "Registry options section.path=value"},
-          }
-        },
-        {
-          "Emulator",
-          {
-            {"log",                     no_argument,          'l',              "Log to AppleWin.log"},
-            {"paused",                  no_argument,          PAUSED,           "Start paused"},
-            {"fixed-speed",             no_argument,          FIXED_SPEED,      "Fixed (non-adaptive) speed"},
-            {"headless",                no_argument,          HEADLESS,         "Headless: disable video (freewheel)"},
-            {"benchmark",               no_argument,          'b',              "Benchmark emulator"},
-            {"no-squaring",             no_argument,          NO_SQUARING,      "Gamepad range is (already) a square"},
-            {"nat",                     required_argument,    SLIRP_NAT,        "SLIRP PortFwd (e.g. 0,tcp,,8080,,http)"},
-          }
-        },
-        {
-          "Disk",
-          {
-            {"d1",                      required_argument,    '1',              "Disk in S6D1 drive"},
-            {"d2",                      required_argument,    '2',              "Disk in S6D2 drive"},
-            {"h1",                      required_argument,    DISK_H1,          "Hard Disk in 1st drive"},
-            {"h2",                      required_argument,    DISK_H2,          "Hard Disk in 1st drive"},
-          }
-        },
-        {
-          "Snapshot",
-          {
-            {"state-filename",          required_argument,    'f',              "Set snapshot filename"},
-            {"load-state",              required_argument,    's',              "Load snapshot from file"},
-          }
-        },
-        {
-          "Memory",
-          {
-            {"memclear",                required_argument,    MEM_CLEAR,        "Memory initialization pattern [0..7]"},
-            {"rom",                     required_argument,    ROM,              "Custom 12k/16k ROM"},
-            {"f8rom",                   required_argument,    F8ROM,            "Custom 2k ROM"},
-          }
-        },
-        {
-          "Audio",
-          {
-            {"no-audio",                no_argument,          NO_AUDIO,         "Disable audio"},
-            {"audio-buffer",            required_argument,    AUDIO_BUFFER,     "Audio buffer (ms)", audioBufferDefault.c_str()},
-            {"wav-speaker",             required_argument,    WAV_SPEAKER,      "Speaker wav output filename"},
-            {"wav-mockingboard",        required_argument,    WAV_MOCKINGBOARD, "Mockingboard wav output filename"},
-          }
-        },
-      };
+        // clang-format off
 
-    const std::vector<std::pair<std::string, std::vector<OptionData_t>>> sa2Options =
-      {
-        {
-          "sa2",
-          {
-            {"sdl-driver",              required_argument,    SDL_DRIVER,       "SDL driver"},
-            {"gl-swap",                 required_argument,    GL_SWAP,          "SDL_GL_SwapInterval"},
-            {"timer",                   no_argument,          TIMER,            "Synchronise with timer"},
-            {"no-imgui",                no_argument,          NO_IMGUI,         "Plain SDL2 renderer"},
-            {"geometry",                required_argument,    GEOMETRY,         "WxH[+X+Y]"},
-            {"aspect-ratio",            no_argument,          ASPECT_RATIO,     "Always preserve correct aspect ratio"},
-            {"game-controller",         required_argument,    GAME_CONTROLLER,  "SDL_GameControllerOpen"},
-            {"game-mapping-file",       required_argument,    MAPPING_FILE,     "SDL_GameControllerAddMappingsFromFile"},
-            {"audio-device",            required_argument,    AUDIO_DEVICE,     "Audio device name"},
-          }
-        },
-      };
+        std::vector<std::pair<std::string, std::vector<OptionData_t>>> allOptions = {
+            {name.c_str(),
+             {
+                 {"help",                    no_argument,          'h',              "Print this help message"},
+             }},
+            {"Configuration",
+             {
+                 {"conf",                    required_argument,    'c',              "Select configuration file", configurationFileDefault.c_str()},
+                 {"qt-ini",                  no_argument,          'q',              "Use Qt ini file (read only)"},
+                 {"registry",                required_argument,    'r',              "Registry options section.path=value"},
+             }},
+            {"Emulator",
+             {
+                 {"log",                     no_argument,          'l',              "Log to AppleWin.log"},
+                 {"paused",                  no_argument,          PAUSED,           "Start paused"},
+                 {"fixed-speed",             no_argument,          FIXED_SPEED,      "Fixed (non-adaptive) speed"},
+                 {"headless",                no_argument,          HEADLESS,         "Headless: disable video (freewheel)"},
+                 {"benchmark",               no_argument,          'b',              "Benchmark emulator"},
+                 {"no-squaring",             no_argument,          NO_SQUARING,      "Gamepad range is (already) a square"},
+                 {"nat",                     required_argument,    SLIRP_NAT,        "SLIRP PortFwd (e.g. 0,tcp,,8080,,http)"},
+             }},
+            {"Disk",
+             {
+                 {"d1",                      required_argument,    '1',              "Disk in S6D1 drive"},
+                 {"d2",                      required_argument,    '2',              "Disk in S6D2 drive"},
+                 {"h1",                      required_argument,    DISK_H1,          "Hard Disk in 1st drive"},
+                 {"h2",                      required_argument,    DISK_H2,          "Hard Disk in 1st drive"},
+             }},
+            {"Snapshot",
+             {
+                 {"state-filename",          required_argument,    'f',              "Set snapshot filename"},
+                 {"load-state",              required_argument,    's',              "Load snapshot from file"},
+             }},
+            {"Memory",
+             {
+                 {"memclear",                required_argument,    MEM_CLEAR,        "Memory initialization pattern [0..7]"},
+                 {"rom",                     required_argument,    ROM,              "Custom 12k/16k ROM"},
+                 {"f8rom",                   required_argument,    F8ROM,            "Custom 2k ROM"},
+             }},
+            {"Audio",
+             {
+                 {"no-audio",                no_argument,          NO_AUDIO,         "Disable audio"},
+                 {"audio-buffer",            required_argument,    AUDIO_BUFFER,     "Audio buffer (ms)", audioBufferDefault.c_str()},
+                 {"wav-speaker",             required_argument,    WAV_SPEAKER,      "Speaker wav output filename"},
+                 {"wav-mockingboard",        required_argument,    WAV_MOCKINGBOARD, "Mockingboard wav output filename"},
+             }},
+        };
 
-    const std::vector<std::pair<std::string, std::vector<OptionData_t>>> applenOptions =
-      {
-        {
-          "applen",
-          {
-            {"no-video-update",         no_argument,          NO_VIDEO_UPDATE,  "Do not execute NTSC code"},
-            {"ev-device-name",          required_argument,    EV_DEVICE_NAME,   "Gamepad ev-device name"},
-          }
-        },
-      };
+        const std::vector<std::pair<std::string, std::vector<OptionData_t>>> sa2Options = {
+            {"sa2",
+             {
+                 {"sdl-driver",              required_argument,    SDL_DRIVER,       "SDL driver"},
+                 {"gl-swap",                 required_argument,    GL_SWAP,          "SDL_GL_SwapInterval"},
+                 {"timer",                   no_argument,          TIMER,            "Synchronise with timer"},
+                 {"no-imgui",                no_argument,          NO_IMGUI,         "Plain SDL2 renderer"},
+                 {"geometry",                required_argument,    GEOMETRY,         "WxH[+X+Y]"},
+                 {"aspect-ratio",            no_argument,          ASPECT_RATIO,     "Always preserve correct aspect ratio"},
+                 {"game-controller",         required_argument,    GAME_CONTROLLER,  "SDL_GameControllerOpen"},
+                 {"game-mapping-file",       required_argument,    MAPPING_FILE,     "SDL_GameControllerAddMappingsFromFile"},
+                 {"audio-device",            required_argument,    AUDIO_DEVICE,     "Audio device name"},
+             }},
+        };
 
-    if (type == OptionsType::sa2)
-    {
-      allOptions.insert(allOptions.end(), sa2Options.begin(), sa2Options.end());
-    }
-    else if (type == OptionsType::applen)
-    {
-      allOptions.insert(allOptions.end(), applenOptions.begin(), applenOptions.end());
-    }
-
-    std::vector<option> longOptions;
-    std::string shortOptions;
-    extractOptions(allOptions, longOptions, shortOptions);
+        const std::vector<std::pair<std::string, std::vector<OptionData_t>>> applenOptions = {
+            {"applen",
+             {
+                 {"no-video-update",         no_argument,          NO_VIDEO_UPDATE,  "Do not execute NTSC code"},
+                 {"ev-device-name",          required_argument,    EV_DEVICE_NAME,   "Gamepad ev-device name"},
+             }},
+        };
 
-    while (true)
-    {
-      int optionIndex = 0;
-      const int c = getopt_long(argc, argv, shortOptions.c_str(), longOptions.data(), &optionIndex);
+        // clang-format on
 
-      switch (c)
-      {
-        case -1:
-        {
-          if (optind < argc)
-          {
-            std::cerr << "Uexpected positional argument: '" << argv[optind] << "'" << std::endl << std::endl;
-            printHelp(allOptions);
-            return false;
-          }
-          return true;
-        }
-        case '?':
-        {
-          std::cerr << std::endl;
-          printHelp(allOptions);
-          return false;
-        }
-        case 'h':
-        {
-          printHelp(allOptions);
-          return false;
-        }
-        case 'c':
-        {
-          options.configurationFile = optarg;
-          break;
-        }
-        case 'l':
-        {
-          options.log = true;
-          break;
-        }
-        case '1':
+        if (type == OptionsType::sa2)
         {
-          options.disk1 = optarg;
-          break;
+            allOptions.insert(allOptions.end(), sa2Options.begin(), sa2Options.end());
         }
-        case '2':
+        else if (type == OptionsType::applen)
         {
-          options.disk2 = optarg;
-          break;
+            allOptions.insert(allOptions.end(), applenOptions.begin(), applenOptions.end());
         }
-        case 'f':
-        {
-          options.snapshotFilename = optarg;
-          options.loadSnapshot = false;
-          break;
-        }
-        case 's':
-        {
-          options.snapshotFilename = optarg;
-          options.loadSnapshot = true;
-          break;
-        }
-        case 'q':
-        {
-          options.useQtIni = true;
-          break;
-        }
-        case 'r':
-        {
-          options.registryOptions.emplace_back(optarg);
-          break;
-        }
-        case 'b':
-        {
-          options.benchmark = true;
-          break;
-        }
-        case PAUSED:
-        {
-          options.autoBoot = false;
-          break;
-        }
-        case FIXED_SPEED:
-        {
-          options.fixedSpeed = true;
-          break;
-        }
-        case HEADLESS:
-        {
-          options.headless = true;
-          break;
-        }
-        case NO_SQUARING:
-        {
-          options.paddleSquaring = false;
-          break;
-        }
-        case SLIRP_NAT:
-        {
-          options.natPortFwds.emplace_back(optarg);
-          break;
-        }
-        case DISK_H1:
-        {
-          options.hardDisk1 = optarg;
-          break;
-        }
-        case DISK_H2:
-        {
-          options.hardDisk2 = optarg;
-          break;
-        }
-        case MEM_CLEAR:
-        {
-          const int memclear = std::stoi(optarg);
-          if (memclear >=0 && memclear < NUM_MIP)
-          {
-            options.memclear = memclear;
-          }
-          break;
-        }
-        case ROM:
-        {
-          options.customRom = optarg;
-          break;
-        }
-        case F8ROM:
-        {
-          options.customRomF8 = optarg;
-          break;
-        }
-        case NO_AUDIO:
-        {
-          options.noAudio = true;
-          break;
-        }
-        case AUDIO_BUFFER:
-        {
-          options.audioBuffer = std::stoul(optarg);
-          break;
-        }
-        case WAV_SPEAKER:
-        {
-          options.wavFileSpeaker = optarg;
-          break;
-        }
-        case WAV_MOCKINGBOARD:
-        {
-          options.wavFileMockingboard = optarg;
-          break;
-        }
-        case SDL_DRIVER:
-        {
-          options.sdlDriver = std::stoi(optarg);
-          break;
-        }
-        case GL_SWAP:
-        {
-          options.glSwapInterval = std::stoi(optarg);
-          break;
-        }
-        case TIMER:
-        {
-          options.syncWithTimer = true;
-          break;
-        }
-        case NO_IMGUI:
-        {
-          options.imgui = false;
-          break;
-        }
-        case GEOMETRY:
-        {
-          parseGeometry(optarg, options.geometry);
-          break;
-        }
-        case ASPECT_RATIO:
-        {
-          options.aspectRatio = true;
-          break;
-        }
-        case GAME_CONTROLLER:
-        {
-          options.gameControllerIndex = std::stoi(optarg);
-          break;
-        }
-        case MAPPING_FILE:
-        {
-          options.gameControllerMappingFile = optarg;
-          break;
-        }
-        case AUDIO_DEVICE:
-        {
-          options.audioDeviceName = optarg;
-          break;
-        }
-        case NO_VIDEO_UPDATE:
-        {
-          options.noVideoUpdate = true;
-          break;
-        }
-        case EV_DEVICE_NAME:
-        {
-          options.paddleDeviceName = optarg;
-          break;
-        }
-        default:
+
+        std::vector<option> longOptions;
+        std::string shortOptions;
+        extractOptions(allOptions, longOptions, shortOptions);
+
+        while (true)
         {
-          printHelp(allOptions);
-          return false;
+            int optionIndex = 0;
+            const int c = getopt_long(argc, argv, shortOptions.c_str(), longOptions.data(), &optionIndex);
+
+            switch (c)
+            {
+            case -1:
+            {
+                if (optind < argc)
+                {
+                    std::cerr << "Uexpected positional argument: '" << argv[optind] << "'" << std::endl << std::endl;
+                    printHelp(allOptions);
+                    return false;
+                }
+                return true;
+            }
+            case '?':
+            {
+                std::cerr << std::endl;
+                printHelp(allOptions);
+                return false;
+            }
+            case 'h':
+            {
+                printHelp(allOptions);
+                return false;
+            }
+            case 'c':
+            {
+                options.configurationFile = optarg;
+                break;
+            }
+            case 'l':
+            {
+                options.log = true;
+                break;
+            }
+            case '1':
+            {
+                options.disk1 = optarg;
+                break;
+            }
+            case '2':
+            {
+                options.disk2 = optarg;
+                break;
+            }
+            case 'f':
+            {
+                options.snapshotFilename = optarg;
+                options.loadSnapshot = false;
+                break;
+            }
+            case 's':
+            {
+                options.snapshotFilename = optarg;
+                options.loadSnapshot = true;
+                break;
+            }
+            case 'q':
+            {
+                options.useQtIni = true;
+                break;
+            }
+            case 'r':
+            {
+                options.registryOptions.emplace_back(optarg);
+                break;
+            }
+            case 'b':
+            {
+                options.benchmark = true;
+                break;
+            }
+            case PAUSED:
+            {
+                options.autoBoot = false;
+                break;
+            }
+            case FIXED_SPEED:
+            {
+                options.fixedSpeed = true;
+                break;
+            }
+            case HEADLESS:
+            {
+                options.headless = true;
+                break;
+            }
+            case NO_SQUARING:
+            {
+                options.paddleSquaring = false;
+                break;
+            }
+            case SLIRP_NAT:
+            {
+                options.natPortFwds.emplace_back(optarg);
+                break;
+            }
+            case DISK_H1:
+            {
+                options.hardDisk1 = optarg;
+                break;
+            }
+            case DISK_H2:
+            {
+                options.hardDisk2 = optarg;
+                break;
+            }
+            case MEM_CLEAR:
+            {
+                const int memclear = std::stoi(optarg);
+                if (memclear >= 0 && memclear < NUM_MIP)
+                {
+                    options.memclear = memclear;
+                }
+                break;
+            }
+            case ROM:
+            {
+                options.customRom = optarg;
+                break;
+            }
+            case F8ROM:
+            {
+                options.customRomF8 = optarg;
+                break;
+            }
+            case NO_AUDIO:
+            {
+                options.noAudio = true;
+                break;
+            }
+            case AUDIO_BUFFER:
+            {
+                options.audioBuffer = std::stoul(optarg);
+                break;
+            }
+            case WAV_SPEAKER:
+            {
+                options.wavFileSpeaker = optarg;
+                break;
+            }
+            case WAV_MOCKINGBOARD:
+            {
+                options.wavFileMockingboard = optarg;
+                break;
+            }
+            case SDL_DRIVER:
+            {
+                options.sdlDriver = std::stoi(optarg);
+                break;
+            }
+            case GL_SWAP:
+            {
+                options.glSwapInterval = std::stoi(optarg);
+                break;
+            }
+            case TIMER:
+            {
+                options.syncWithTimer = true;
+                break;
+            }
+            case NO_IMGUI:
+            {
+                options.imgui = false;
+                break;
+            }
+            case GEOMETRY:
+            {
+                parseGeometry(optarg, options.geometry);
+                break;
+            }
+            case ASPECT_RATIO:
+            {
+                options.aspectRatio = true;
+                break;
+            }
+            case GAME_CONTROLLER:
+            {
+                options.gameControllerIndex = std::stoi(optarg);
+                break;
+            }
+            case MAPPING_FILE:
+            {
+                options.gameControllerMappingFile = optarg;
+                break;
+            }
+            case AUDIO_DEVICE:
+            {
+                options.audioDeviceName = optarg;
+                break;
+            }
+            case NO_VIDEO_UPDATE:
+            {
+                options.noVideoUpdate = true;
+                break;
+            }
+            case EV_DEVICE_NAME:
+            {
+                options.paddleDeviceName = optarg;
+                break;
+            }
+            default:
+            {
+                printHelp(allOptions);
+                return false;
+            }
+            }
         }
-      }
-    }
 
-    return true;
-  }
+        return true;
+    }
 
-}
+} // namespace common2
diff --git a/source/frontends/common2/argparser.h b/source/frontends/common2/argparser.h
index f33bb4630..c85613dc0 100644
--- a/source/frontends/common2/argparser.h
+++ b/source/frontends/common2/argparser.h
@@ -2,9 +2,15 @@
 
 namespace common2
 {
-  struct EmulatorOptions;
+    struct EmulatorOptions;
 
-  enum class OptionsType { none, applen, sa2 };
+    enum class OptionsType
+    {
+        none,
+        applen,
+        sa2
+    };
 
-  bool getEmulatorOptions(int argc, char *const argv[], OptionsType type, const std::string & edition, EmulatorOptions & options);
-}
+    bool getEmulatorOptions(
+        int argc, char *const argv[], OptionsType type, const std::string &edition, EmulatorOptions &options);
+} // namespace common2
diff --git a/source/frontends/common2/commoncontext.cpp b/source/frontends/common2/commoncontext.cpp
index 22bdd2385..4c752f01c 100644
--- a/source/frontends/common2/commoncontext.cpp
+++ b/source/frontends/common2/commoncontext.cpp
@@ -7,24 +7,21 @@
 namespace common2
 {
 
-  CommonInitialisation::CommonInitialisation(
-    const std::shared_ptr<LinuxFrame> & frame,
-    const std::shared_ptr<Paddle> & paddle,
-    const EmulatorOptions & options)
-  : Initialisation(frame, paddle)
-  {
-    applyOptions(options);
-    myFrame->Begin();
-    setSnapshotFilename(options.snapshotFilename);
-    if (options.loadSnapshot)
+    CommonInitialisation::CommonInitialisation(
+        const std::shared_ptr<LinuxFrame> &frame, const std::shared_ptr<Paddle> &paddle, const EmulatorOptions &options)
+        : Initialisation(frame, paddle)
     {
-      myFrame->LoadSnapshot();
+        applyOptions(options);
+        myFrame->Begin();
+        setSnapshotFilename(options.snapshotFilename);
+        if (options.loadSnapshot)
+        {
+            myFrame->LoadSnapshot();
+        }
+    }
+    CommonInitialisation::~CommonInitialisation()
+    {
+        myFrame->End();
     }
 
-  }
-  CommonInitialisation::~CommonInitialisation()
-  {
-    myFrame->End();
-  }
-
-}
\ No newline at end of file
+} // namespace common2
\ No newline at end of file
diff --git a/source/frontends/common2/commoncontext.h b/source/frontends/common2/commoncontext.h
index 352ca4ca0..bf384d55f 100644
--- a/source/frontends/common2/commoncontext.h
+++ b/source/frontends/common2/commoncontext.h
@@ -2,16 +2,14 @@
 
 namespace common2
 {
-  struct EmulatorOptions;
+    struct EmulatorOptions;
 
-  class CommonInitialisation : public Initialisation
-  {
-  public:
-    CommonInitialisation(
-      const std::shared_ptr<LinuxFrame> & frame,
-      const std::shared_ptr<Paddle> & paddle,
-      const EmulatorOptions & options
-      );
-    ~CommonInitialisation();
-  };
-}
+    class CommonInitialisation : public Initialisation
+    {
+    public:
+        CommonInitialisation(
+            const std::shared_ptr<LinuxFrame> &frame, const std::shared_ptr<Paddle> &paddle,
+            const EmulatorOptions &options);
+        ~CommonInitialisation();
+    };
+} // namespace common2
diff --git a/source/frontends/common2/commonframe.cpp b/source/frontends/common2/commonframe.cpp
index 20880d295..b1225490a 100644
--- a/source/frontends/common2/commonframe.cpp
+++ b/source/frontends/common2/commonframe.cpp
@@ -18,193 +18,191 @@
 namespace common2
 {
 
-  CommonFrame::CommonFrame(const EmulatorOptions & options)
-    : LinuxFrame(options.autoBoot)
-    , mySpeed(options.fixedSpeed)
-    , mySynchroniseWithTimer(options.syncWithTimer)
-    , myAllowVideoUpdate(!options.noVideoUpdate)
-  {
-    myLastSync = std::chrono::steady_clock::now();
-  }
-
-  void CommonFrame::Begin()
-  {
-    LinuxFrame::Begin();
-    ResetSpeed();
-    ResetHardware();
-  }
-
-  void CommonFrame::ResetSpeed()
-  {
-    mySpeed.reset();
-  }
-
-  void CommonFrame::SetFullSpeed(const bool value)
-  {
-    if (g_bFullSpeed != value)
-    {
-      if (value)
-      {
-        // entering full speed
-        GetCardMgr().GetMockingboardCardMgr().MuteControl(true);
-        VideoRedrawScreenDuringFullSpeed(0, true);
-      }
-      else
-      {
-        // leaving full speed
-        GetCardMgr().GetMockingboardCardMgr().MuteControl(false);
+    CommonFrame::CommonFrame(const EmulatorOptions &options)
+        : LinuxFrame(options.autoBoot)
+        , mySpeed(options.fixedSpeed)
+        , mySynchroniseWithTimer(options.syncWithTimer)
+        , myAllowVideoUpdate(!options.noVideoUpdate)
+    {
+        myLastSync = std::chrono::steady_clock::now();
+    }
+
+    void CommonFrame::Begin()
+    {
+        LinuxFrame::Begin();
         ResetSpeed();
-      }
-      g_bFullSpeed = value;
-      g_nCpuCyclesFeedback = 0;
-    }
-  }
-
-  bool CommonFrame::CanDoFullSpeed()
-  {
-    return (g_dwSpeed == SPEED_MAX) ||
-           (GetCardMgr().GetDisk2CardMgr().IsConditionForFullSpeed() && 
-             !Spkr_IsActive() && 
-             !GetCardMgr().GetMockingboardCardMgr().IsActiveToPreventFullSpeed()
-           ) ||
-           IsDebugSteppingAtFullSpeed();
-  }
-
-  void CommonFrame::ExecuteOneFrame(const int64_t microseconds)
-  {
-    // when running in adaptive speed
-    // the value msNextFrame is only a hint for when the next frame will arrive
-    switch (g_nAppMode)
-    {
-      case MODE_RUNNING:
+        ResetHardware();
+    }
+
+    void CommonFrame::ResetSpeed()
+    {
+        mySpeed.reset();
+    }
+
+    void CommonFrame::SetFullSpeed(const bool value)
+    {
+        if (g_bFullSpeed != value)
         {
-          ExecuteInRunningMode(microseconds);
-          break;
+            if (value)
+            {
+                // entering full speed
+                GetCardMgr().GetMockingboardCardMgr().MuteControl(true);
+                VideoRedrawScreenDuringFullSpeed(0, true);
+            }
+            else
+            {
+                // leaving full speed
+                GetCardMgr().GetMockingboardCardMgr().MuteControl(false);
+                ResetSpeed();
+            }
+            g_bFullSpeed = value;
+            g_nCpuCyclesFeedback = 0;
         }
-      case MODE_STEPPING:
+    }
+
+    bool CommonFrame::CanDoFullSpeed()
+    {
+        return (g_dwSpeed == SPEED_MAX) ||
+               (GetCardMgr().GetDisk2CardMgr().IsConditionForFullSpeed() && !Spkr_IsActive() &&
+                !GetCardMgr().GetMockingboardCardMgr().IsActiveToPreventFullSpeed()) ||
+               IsDebugSteppingAtFullSpeed();
+    }
+
+    void CommonFrame::ExecuteOneFrame(const int64_t microseconds)
+    {
+        // when running in adaptive speed
+        // the value msNextFrame is only a hint for when the next frame will arrive
+        switch (g_nAppMode)
+        {
+        case MODE_RUNNING:
         {
-          ExecuteInDebugMode(microseconds);
-          break;
+            ExecuteInRunningMode(microseconds);
+            break;
         }
-      default:
-        break;
-    };
-  }
-
-  void CommonFrame::ExecuteInRunningMode(const int64_t microseconds)
-  {
-    SetFullSpeed(CanDoFullSpeed());
-    const uint32_t cyclesToExecute = mySpeed.getCyclesTillNext(microseconds);  // this checks g_bFullSpeed
-    Execute(cyclesToExecute);
-  }
-
-  void CommonFrame::ExecuteInDebugMode(const int64_t microseconds)
-  {
-    // In AppleWin this is called without a timer for just one iteration
-    // because we run a "frame" at a time, we need a bit of ingenuity
-    const uint32_t cyclesToExecute = mySpeed.getCyclesAtFixedSpeed(microseconds);
-    const int64_t target = g_nCumulativeCycles + cyclesToExecute;
-
-    while (g_nAppMode == MODE_STEPPING && g_nCumulativeCycles < target)
-    {
-      DebugContinueStepping();
-    }
-  }
-
-  void CommonFrame::Execute(const uint32_t cyclesToExecute)
-  {
-    const bool bVideoUpdate = myAllowVideoUpdate && !g_bFullSpeed;
-    const UINT dwClksPerFrame = NTSC_GetCyclesPerFrame();
-
-    // do it in the same batches as AppleWin (1 ms)
-    const uint32_t fExecutionPeriodClks = g_fCurrentCLK6502 * (1.0 / 1000.0);  // 1 ms
-
-    uint32_t totalCyclesExecuted = 0;
-    // check at the end because we want to always execute at least 1 cycle even for "0"
-    do
-    {
-      _ASSERT(cyclesToExecute >= totalCyclesExecuted);
-      const uint32_t thisCyclesToExecute = std::min(fExecutionPeriodClks, cyclesToExecute - totalCyclesExecuted);
-      const uint32_t executedCycles = CpuExecute(thisCyclesToExecute, bVideoUpdate);
-      totalCyclesExecuted += executedCycles;
-
-      GetCardMgr().Update(executedCycles);
-      SpkrUpdate(executedCycles);
-
-      g_dwCyclesThisFrame = (g_dwCyclesThisFrame + executedCycles) % dwClksPerFrame;
-
-    } while (totalCyclesExecuted < cyclesToExecute);
-  }
-
-  void CommonFrame::ChangeMode(const AppMode_e mode)
-  {
-    if (mode != g_nAppMode)
-    {
-      switch (mode)
-      {
-      case MODE_RUNNING:
-        DebugExitDebugger();
-        SoundCore_SetFade(FADE_IN);
-        break;
-      case MODE_DEBUG:
-        DebugBegin();
-        CmdWindowViewConsole(0);
-        break;
-      default:
-        g_nAppMode = mode;
-        SoundCore_SetFade(FADE_OUT);
-        break;
-      }
-      FrameRefreshStatus(DRAW_TITLE);
-      ResetSpeed();
-    }
-  }
-
-  void CommonFrame::TogglePaused()
-  {
-    const AppMode_e newMode = (g_nAppMode == MODE_RUNNING) ? MODE_PAUSED : MODE_RUNNING;
-    ChangeMode(newMode);
-  }
-
-  void CommonFrame::SingleStep()
-  {
-    SetFullSpeed(CanDoFullSpeed());
-    Execute(0);
-  }
-
-  void CommonFrame::ResetHardware()
-  {
-    myHardwareConfig.Reload();
-  }
-
-  bool CommonFrame::HardwareChanged() const
-  {
-    const CConfigNeedingRestart currentConfig = CConfigNeedingRestart::Create();
-    return myHardwareConfig != currentConfig;
-  }
-
-  void CommonFrame::LoadSnapshot()
-  {
-    LinuxFrame::LoadSnapshot();
-    ResetSpeed();
-    ResetHardware();
-  }
-
-  void CommonFrame::SyncVideoPresentScreen(const int64_t microseconds)
-  {
-    if (mySynchroniseWithTimer)
-    {
-      const auto next = myLastSync + std::chrono::microseconds(microseconds);
-      // no need to check here if "next" is in the past
-      std::this_thread::sleep_until(next);
-      myLastSync = std::chrono::steady_clock::now();
-    }
-    VideoPresentScreen();
-  }
+        case MODE_STEPPING:
+        {
+            ExecuteInDebugMode(microseconds);
+            break;
+        }
+        default:
+            break;
+        };
+    }
 
-}
+    void CommonFrame::ExecuteInRunningMode(const int64_t microseconds)
+    {
+        SetFullSpeed(CanDoFullSpeed());
+        const uint32_t cyclesToExecute = mySpeed.getCyclesTillNext(microseconds); // this checks g_bFullSpeed
+        Execute(cyclesToExecute);
+    }
+
+    void CommonFrame::ExecuteInDebugMode(const int64_t microseconds)
+    {
+        // In AppleWin this is called without a timer for just one iteration
+        // because we run a "frame" at a time, we need a bit of ingenuity
+        const uint32_t cyclesToExecute = mySpeed.getCyclesAtFixedSpeed(microseconds);
+        const int64_t target = g_nCumulativeCycles + cyclesToExecute;
+
+        while (g_nAppMode == MODE_STEPPING && g_nCumulativeCycles < target)
+        {
+            DebugContinueStepping();
+        }
+    }
+
+    void CommonFrame::Execute(const uint32_t cyclesToExecute)
+    {
+        const bool bVideoUpdate = myAllowVideoUpdate && !g_bFullSpeed;
+        const UINT dwClksPerFrame = NTSC_GetCyclesPerFrame();
+
+        // do it in the same batches as AppleWin (1 ms)
+        const uint32_t fExecutionPeriodClks = g_fCurrentCLK6502 * (1.0 / 1000.0); // 1 ms
+
+        uint32_t totalCyclesExecuted = 0;
+        // check at the end because we want to always execute at least 1 cycle even for "0"
+        do
+        {
+            _ASSERT(cyclesToExecute >= totalCyclesExecuted);
+            const uint32_t thisCyclesToExecute = std::min(fExecutionPeriodClks, cyclesToExecute - totalCyclesExecuted);
+            const uint32_t executedCycles = CpuExecute(thisCyclesToExecute, bVideoUpdate);
+            totalCyclesExecuted += executedCycles;
+
+            GetCardMgr().Update(executedCycles);
+            SpkrUpdate(executedCycles);
+
+            g_dwCyclesThisFrame = (g_dwCyclesThisFrame + executedCycles) % dwClksPerFrame;
+
+        } while (totalCyclesExecuted < cyclesToExecute);
+    }
+
+    void CommonFrame::ChangeMode(const AppMode_e mode)
+    {
+        if (mode != g_nAppMode)
+        {
+            switch (mode)
+            {
+            case MODE_RUNNING:
+                DebugExitDebugger();
+                SoundCore_SetFade(FADE_IN);
+                break;
+            case MODE_DEBUG:
+                DebugBegin();
+                CmdWindowViewConsole(0);
+                break;
+            default:
+                g_nAppMode = mode;
+                SoundCore_SetFade(FADE_OUT);
+                break;
+            }
+            FrameRefreshStatus(DRAW_TITLE);
+            ResetSpeed();
+        }
+    }
+
+    void CommonFrame::TogglePaused()
+    {
+        const AppMode_e newMode = (g_nAppMode == MODE_RUNNING) ? MODE_PAUSED : MODE_RUNNING;
+        ChangeMode(newMode);
+    }
+
+    void CommonFrame::SingleStep()
+    {
+        SetFullSpeed(CanDoFullSpeed());
+        Execute(0);
+    }
+
+    void CommonFrame::ResetHardware()
+    {
+        myHardwareConfig.Reload();
+    }
+
+    bool CommonFrame::HardwareChanged() const
+    {
+        const CConfigNeedingRestart currentConfig = CConfigNeedingRestart::Create();
+        return myHardwareConfig != currentConfig;
+    }
+
+    void CommonFrame::LoadSnapshot()
+    {
+        LinuxFrame::LoadSnapshot();
+        ResetSpeed();
+        ResetHardware();
+    }
+
+    void CommonFrame::SyncVideoPresentScreen(const int64_t microseconds)
+    {
+        if (mySynchroniseWithTimer)
+        {
+            const auto next = myLastSync + std::chrono::microseconds(microseconds);
+            // no need to check here if "next" is in the past
+            std::this_thread::sleep_until(next);
+            myLastSync = std::chrono::steady_clock::now();
+        }
+        VideoPresentScreen();
+    }
+
+} // namespace common2
 
 void SingleStep(bool /* bReinit */)
 {
-  dynamic_cast<common2::CommonFrame &>(GetFrame()).SingleStep();
+    dynamic_cast<common2::CommonFrame &>(GetFrame()).SingleStep();
 }
diff --git a/source/frontends/common2/commonframe.h b/source/frontends/common2/commonframe.h
index c9ffa510d..266dd759a 100644
--- a/source/frontends/common2/commonframe.h
+++ b/source/frontends/common2/commonframe.h
@@ -9,49 +9,49 @@
 
 namespace common2
 {
-  struct EmulatorOptions;
+    struct EmulatorOptions;
 
-  class CommonFrame : public LinuxFrame
-  {
-  public:
-    CommonFrame(const EmulatorOptions & options);
+    class CommonFrame : public LinuxFrame
+    {
+    public:
+        CommonFrame(const EmulatorOptions &options);
 
-    void Begin() override;
+        void Begin() override;
 
-    virtual void ResetSpeed();
+        virtual void ResetSpeed();
 
-    void ExecuteOneFrame(const int64_t microseconds);
+        void ExecuteOneFrame(const int64_t microseconds);
 
-    // this function will emulate GL vert sync if necessary
-    // it acts as a syncronisation point (sa2 (in qemu) and applen)
-    void SyncVideoPresentScreen(const int64_t microseconds);
+        // this function will emulate GL vert sync if necessary
+        // it acts as a syncronisation point (sa2 (in qemu) and applen)
+        void SyncVideoPresentScreen(const int64_t microseconds);
 
-    void ChangeMode(const AppMode_e mode);
-    void TogglePaused();
-    void SingleStep();
+        void ChangeMode(const AppMode_e mode);
+        void TogglePaused();
+        void SingleStep();
 
-    void ResetHardware();
-    bool HardwareChanged() const;
+        void ResetHardware();
+        bool HardwareChanged() const;
 
-    void LoadSnapshot() override;
+        void LoadSnapshot() override;
 
-  protected:
-    virtual void SetFullSpeed(const bool value);
-    virtual bool CanDoFullSpeed();
+    protected:
+        virtual void SetFullSpeed(const bool value);
+        virtual bool CanDoFullSpeed();
 
-    void ExecuteInRunningMode(const int64_t microseconds);
-    void ExecuteInDebugMode(const int64_t microseconds);
-    void Execute(const uint32_t uCycles);
+        void ExecuteInRunningMode(const int64_t microseconds);
+        void ExecuteInDebugMode(const int64_t microseconds);
+        void Execute(const uint32_t uCycles);
 
-    Speed mySpeed;
+        Speed mySpeed;
 
-    // used to synchronise if OpenGL cannot do it (or without it)
-    bool mySynchroniseWithTimer;
-    std::chrono::time_point<std::chrono::steady_clock> myLastSync;
+        // used to synchronise if OpenGL cannot do it (or without it)
+        bool mySynchroniseWithTimer;
+        std::chrono::time_point<std::chrono::steady_clock> myLastSync;
 
-  private:
-    const bool myAllowVideoUpdate;
-    CConfigNeedingRestart myHardwareConfig;
-  };
+    private:
+        const bool myAllowVideoUpdate;
+        CConfigNeedingRestart myHardwareConfig;
+    };
 
-}
+} // namespace common2
diff --git a/source/frontends/common2/controllerdoublepress.cpp b/source/frontends/common2/controllerdoublepress.cpp
index cb30a5346..a356944ac 100644
--- a/source/frontends/common2/controllerdoublepress.cpp
+++ b/source/frontends/common2/controllerdoublepress.cpp
@@ -3,12 +3,12 @@
 namespace common2
 {
 
-  bool ControllerDoublePress::pressButton()
-  {
-    const auto secondBtnPress = std::chrono::steady_clock::now();
-    const auto dt = std::chrono::duration_cast<std::chrono::milliseconds>(secondBtnPress - myFirstBtnPress).count();
-    myFirstBtnPress = secondBtnPress;
-    return dt <= myThreshold;
-  }
+    bool ControllerDoublePress::pressButton()
+    {
+        const auto secondBtnPress = std::chrono::steady_clock::now();
+        const auto dt = std::chrono::duration_cast<std::chrono::milliseconds>(secondBtnPress - myFirstBtnPress).count();
+        myFirstBtnPress = secondBtnPress;
+        return dt <= myThreshold;
+    }
 
-}
+} // namespace common2
diff --git a/source/frontends/common2/controllerdoublepress.h b/source/frontends/common2/controllerdoublepress.h
index d44788e1c..60330dec3 100644
--- a/source/frontends/common2/controllerdoublepress.h
+++ b/source/frontends/common2/controllerdoublepress.h
@@ -5,14 +5,14 @@
 namespace common2
 {
 
-  class ControllerDoublePress
-  {
-  public:
-    bool pressButton();  // if it returns true, action is triggered
-  private:
-    // too short and it becomes hard to trigger with SDL.
-    static constexpr long myThreshold = 1000;
-    std::chrono::steady_clock::time_point myFirstBtnPress;    
-  };
+    class ControllerDoublePress
+    {
+    public:
+        bool pressButton(); // if it returns true, action is triggered
+    private:
+        // too short and it becomes hard to trigger with SDL.
+        static constexpr long myThreshold = 1000;
+        std::chrono::steady_clock::time_point myFirstBtnPress;
+    };
 
-}
\ No newline at end of file
+} // namespace common2
\ No newline at end of file
diff --git a/source/frontends/common2/fileregistry.cpp b/source/frontends/common2/fileregistry.cpp
index a16d2617b..78784dc12 100644
--- a/source/frontends/common2/fileregistry.cpp
+++ b/source/frontends/common2/fileregistry.cpp
@@ -13,102 +13,104 @@
 namespace
 {
 
-  void parseOption(const std::string & s, std::string & path, std::string & value)
-  {
-    const size_t pos = s.find('=');
-    if (pos == std::string::npos)
+    void parseOption(const std::string &s, std::string &path, std::string &value)
     {
-      throw std::runtime_error("Invalid option format: " + s + ", expected: section.key=value");
+        const size_t pos = s.find('=');
+        if (pos == std::string::npos)
+        {
+            throw std::runtime_error("Invalid option format: " + s + ", expected: section.key=value");
+        }
+        path = s.substr(0, pos);
+        std::replace(path.begin(), path.end(), '_', ' ');
+        value = s.substr(pos + 1);
+        std::replace(value.begin(), value.end(), '_', ' ');
     }
-    path = s.substr(0, pos);
-    std::replace(path.begin(), path.end(), '_', ' ');
-    value = s.substr(pos + 1);
-    std::replace(value.begin(), value.end(), '_', ' ');
-  }
-
-  class Configuration : public common2::PTreeRegistry
-  {
-  public:
-    Configuration(const std::filesystem::path & filename, const bool saveOnExit);
-    ~Configuration();
-
-    void addExtraOptions(const std::vector<std::string> & options);
-
-    std::string getLocation() const override;
-
-  private:
-    const std::filesystem::path myFilename;
-    bool mySaveOnExit;
-  };
-
-  Configuration::Configuration(const std::filesystem::path & filename, const bool saveOnExit) : myFilename(filename), mySaveOnExit(saveOnExit)
-  {
-    if (std::filesystem::exists(myFilename))
+
+    class Configuration : public common2::PTreeRegistry
     {
-      boost::property_tree::ini_parser::read_ini(myFilename.string(), myINI);
-    }
-    else
+    public:
+        Configuration(const std::filesystem::path &filename, const bool saveOnExit);
+        ~Configuration();
+
+        void addExtraOptions(const std::vector<std::string> &options);
+
+        std::string getLocation() const override;
+
+    private:
+        const std::filesystem::path myFilename;
+        bool mySaveOnExit;
+    };
+
+    Configuration::Configuration(const std::filesystem::path &filename, const bool saveOnExit)
+        : myFilename(filename)
+        , mySaveOnExit(saveOnExit)
     {
-      LogFileOutput("Registry: configuration file '%s' not found\n", myFilename.string().c_str());
+        if (std::filesystem::exists(myFilename))
+        {
+            boost::property_tree::ini_parser::read_ini(myFilename.string(), myINI);
+        }
+        else
+        {
+            LogFileOutput("Registry: configuration file '%s' not found\n", myFilename.string().c_str());
+        }
     }
-  }
 
-  Configuration::~Configuration()
-  {
-    if (mySaveOnExit)
+    Configuration::~Configuration()
     {
-      try
-      {
-        saveToINIFile(myFilename.string());
-      }
-      catch(const std::exception& e)
-      {
-        LogFileOutput("Registry: cannot save settings to '%s': %s\n", myFilename.string().c_str(), e.what());
-      }
+        if (mySaveOnExit)
+        {
+            try
+            {
+                saveToINIFile(myFilename.string());
+            }
+            catch (const std::exception &e)
+            {
+                LogFileOutput("Registry: cannot save settings to '%s': %s\n", myFilename.string().c_str(), e.what());
+            }
+        }
     }
-  }
 
-  void Configuration::addExtraOptions(const std::vector<std::string> & options)
-  {
-    for (const std::string & option : options)
+    void Configuration::addExtraOptions(const std::vector<std::string> &options)
     {
-      std::string path, value;
-      parseOption(option, path, value);
-      myINI.put(path, value);
+        for (const std::string &option : options)
+        {
+            std::string path, value;
+            parseOption(option, path, value);
+            myINI.put(path, value);
+        }
     }
-  }
 
-  std::string Configuration::getLocation() const
-  {
-    return myFilename.string();
-  }
+    std::string Configuration::getLocation() const
+    {
+        return myFilename.string();
+    }
 
-}
+} // namespace
 
 namespace common2
 {
 
-  std::shared_ptr<Registry> CreateFileRegistry(const EmulatorOptions & options)
-  {
-    std::filesystem::path filename;
-    bool saveOnExit;
-
-    if (options.useQtIni)
-    {
-      filename = getSettingsRootDir() / ORGANIZATION_NAME / (std::string(APPLICATION_NAME) + ".conf");
-      saveOnExit = false;
-    }
-    else
+    std::shared_ptr<Registry> CreateFileRegistry(const EmulatorOptions &options)
     {
-      filename = options.configurationFile;
-      saveOnExit = true;
+        std::filesystem::path filename;
+        bool saveOnExit;
+
+        if (options.useQtIni)
+        {
+            filename = getSettingsRootDir() / ORGANIZATION_NAME / (std::string(APPLICATION_NAME) + ".conf");
+            saveOnExit = false;
+        }
+        else
+        {
+            filename = options.configurationFile;
+            saveOnExit = true;
+        }
+
+        LogFileOutput("Reading configuration from: '%s'\n", filename.string().c_str());
+        std::shared_ptr<Configuration> config = std::make_shared<Configuration>(filename, saveOnExit);
+        config->addExtraOptions(options.registryOptions);
+
+        return config;
     }
 
-    LogFileOutput("Reading configuration from: '%s'\n", filename.string().c_str());
-    std::shared_ptr<Configuration> config = std::make_shared<Configuration>(filename, saveOnExit);
-    config->addExtraOptions(options.registryOptions);
-
-    return config;
-  }
-
-}
+} // namespace common2
diff --git a/source/frontends/common2/fileregistry.h b/source/frontends/common2/fileregistry.h
index e763eb302..2869f5fdf 100644
--- a/source/frontends/common2/fileregistry.h
+++ b/source/frontends/common2/fileregistry.h
@@ -7,8 +7,8 @@ class Registry;
 namespace common2
 {
 
-  struct EmulatorOptions;
+    struct EmulatorOptions;
 
-  std::shared_ptr<Registry> CreateFileRegistry(const EmulatorOptions & options);
+    std::shared_ptr<Registry> CreateFileRegistry(const EmulatorOptions &options);
 
-}
+} // namespace common2
diff --git a/source/frontends/common2/gnuframe.cpp b/source/frontends/common2/gnuframe.cpp
index 723a4075c..a69ab2745 100644
--- a/source/frontends/common2/gnuframe.cpp
+++ b/source/frontends/common2/gnuframe.cpp
@@ -15,86 +15,86 @@
 namespace
 {
 
-  std::filesystem::path getExecutableFilename()
-  {
-    std::filesystem::path executable;
-#ifdef _WIN32
-    char self[1024] = {0};
-    int ch = GetModuleFileNameA(0, self, sizeof(self));
-    if (ch < sizeof(self))
+    std::filesystem::path getExecutableFilename()
     {
-      executable = self;
-    }
+        std::filesystem::path executable;
+#ifdef _WIN32
+        char self[1024] = {0};
+        int ch = GetModuleFileNameA(0, self, sizeof(self));
+        if (ch < sizeof(self))
+        {
+            executable = self;
+        }
 #elif __APPLE__
-    char self[1024] = {0};
-    uint32_t size = sizeof(self);
-    const int ch = _NSGetExecutablePath(self, &size);
-    if (ch != -1)
-    {
-      executable = self;
-    }
+        char self[1024] = {0};
+        uint32_t size = sizeof(self);
+        const int ch = _NSGetExecutablePath(self, &size);
+        if (ch != -1)
+        {
+            executable = self;
+        }
 #else
-    executable = std::filesystem::read_symlink("/proc/self/exe");
+        executable = std::filesystem::read_symlink("/proc/self/exe");
 #endif
-    return executable;
-  }
-
-  std::filesystem::path getResourceFolder(const std::string & target)
-  {
-    const std::filesystem::path executable = getExecutableFilename();
-
-    // why a vector? there used to be multiple alternatives to try..
-    std::vector<std::filesystem::path> paths;
-    if (std::filesystem::exists(executable))
-    {
-      const auto root = std::filesystem::canonical(executable.parent_path() / ROOT_PATH);
-      paths.push_back(root);
+        return executable;
     }
 
-    for (const auto & path : paths)
+    std::filesystem::path getResourceFolder(const std::string &target)
     {
-      const std::filesystem::path resourcePath = path / target;
-      if (std::filesystem::exists(resourcePath))
-      {
-        return resourcePath;
-      }
+        const std::filesystem::path executable = getExecutableFilename();
+
+        // why a vector? there used to be multiple alternatives to try..
+        std::vector<std::filesystem::path> paths;
+        if (std::filesystem::exists(executable))
+        {
+            const auto root = std::filesystem::canonical(executable.parent_path() / ROOT_PATH);
+            paths.push_back(root);
+        }
+
+        for (const auto &path : paths)
+        {
+            const std::filesystem::path resourcePath = path / target;
+            if (std::filesystem::exists(resourcePath))
+            {
+                return resourcePath;
+            }
+        }
+
+        // this is now used only for g_sProgramDir
+        // which only matters for Debug Symbols and Printer Filename
+        // let's be tolerant and use cwd
+
+        return std::filesystem::current_path() / target;
     }
 
-    // this is now used only for g_sProgramDir
-    // which only matters for Debug Symbols and Printer Filename
-    // let's be tolerant and use cwd
-
-    return std::filesystem::current_path() / target;
-  }
-
-}
+} // namespace
 
 namespace common2
 {
 
-  GNUFrame::GNUFrame(const EmulatorOptions & options)
-  : CommonFrame(options)
-  {
-    // should this go down to LinuxFrame (maybe Initialisation?)
-    g_sProgramDir = getResourceFolder("bin").string() + PATH_SEPARATOR;
-    LogFileOutput("Program Dir: '%s'\n", g_sProgramDir.c_str());
-  }
-
-  std::pair<const unsigned char *, unsigned int> GNUFrame::GetResourceData(WORD id) const
-  {
-    const auto it = apple2roms::data.find(id);
-    if (it == apple2roms::data.end())
+    GNUFrame::GNUFrame(const EmulatorOptions &options)
+        : CommonFrame(options)
     {
-      throw std::runtime_error("Cannot locate resource: " + std::to_string(id));
+        // should this go down to LinuxFrame (maybe Initialisation?)
+        g_sProgramDir = getResourceFolder("bin").string() + PATH_SEPARATOR;
+        LogFileOutput("Program Dir: '%s'\n", g_sProgramDir.c_str());
     }
-    return it->second;
-  }
 
-  std::string GNUFrame::Video_GetScreenShotFolder() const
-  {
-    const std::filesystem::path pictures = getHomeDir() / "Pictures";
-    std::filesystem::create_directories(pictures);
-    return pictures.string() + PATH_SEPARATOR;
-  }
+    std::pair<const unsigned char *, unsigned int> GNUFrame::GetResourceData(WORD id) const
+    {
+        const auto it = apple2roms::data.find(id);
+        if (it == apple2roms::data.end())
+        {
+            throw std::runtime_error("Cannot locate resource: " + std::to_string(id));
+        }
+        return it->second;
+    }
+
+    std::string GNUFrame::Video_GetScreenShotFolder() const
+    {
+        const std::filesystem::path pictures = getHomeDir() / "Pictures";
+        std::filesystem::create_directories(pictures);
+        return pictures.string() + PATH_SEPARATOR;
+    }
 
-}
+} // namespace common2
diff --git a/source/frontends/common2/gnuframe.h b/source/frontends/common2/gnuframe.h
index 8d6eb7ee5..963a213ee 100644
--- a/source/frontends/common2/gnuframe.h
+++ b/source/frontends/common2/gnuframe.h
@@ -6,16 +6,16 @@
 namespace common2
 {
 
-  class GNUFrame : public CommonFrame
-  {
-  public:
-    GNUFrame(const common2::EmulatorOptions & option);
+    class GNUFrame : public CommonFrame
+    {
+    public:
+        GNUFrame(const common2::EmulatorOptions &option);
 
-    std::string Video_GetScreenShotFolder() const override;
+        std::string Video_GetScreenShotFolder() const override;
 
-  protected:
-    // pointer and size
-    std::pair<const unsigned char *, unsigned int> GetResourceData(WORD id) const;
-  };
+    protected:
+        // pointer and size
+        std::pair<const unsigned char *, unsigned int> GetResourceData(WORD id) const;
+    };
 
-}
+} // namespace common2
diff --git a/source/frontends/common2/programoptions.cpp b/source/frontends/common2/programoptions.cpp
index 8ac5e74c7..a689b7464 100644
--- a/source/frontends/common2/programoptions.cpp
+++ b/source/frontends/common2/programoptions.cpp
@@ -14,84 +14,86 @@
 namespace common2
 {
 
-  EmulatorOptions::EmulatorOptions()
-  {
-    memclear = g_nMemoryClearType;
-    configurationFile = getConfigFile("applewin.conf");
-  }
-
-  void applyOptions(const EmulatorOptions & options)
-  {
-    g_nMemoryClearType = options.memclear;
-    g_bDisableDirectSound = options.noAudio;
-    g_bDisableDirectSoundMockingboard = options.noAudio;
-
-    LPCSTR szImageName_drive[NUM_DRIVES] = {nullptr, nullptr};
-	  bool driveConnected[NUM_DRIVES] = {true, true};
-
-    if (!options.disk1.empty())
+    EmulatorOptions::EmulatorOptions()
     {
-      szImageName_drive[DRIVE_1] = options.disk1.c_str();
+        memclear = g_nMemoryClearType;
+        configurationFile = getConfigFile("applewin.conf");
     }
 
-    if (!options.disk2.empty())
+    void applyOptions(const EmulatorOptions &options)
     {
-      szImageName_drive[DRIVE_2] = options.disk2.c_str();
+        g_nMemoryClearType = options.memclear;
+        g_bDisableDirectSound = options.noAudio;
+        g_bDisableDirectSoundMockingboard = options.noAudio;
+
+        LPCSTR szImageName_drive[NUM_DRIVES] = {nullptr, nullptr};
+        bool driveConnected[NUM_DRIVES] = {true, true};
+
+        if (!options.disk1.empty())
+        {
+            szImageName_drive[DRIVE_1] = options.disk1.c_str();
+        }
+
+        if (!options.disk2.empty())
+        {
+            szImageName_drive[DRIVE_2] = options.disk2.c_str();
+        }
+
+        bool bBoot = false;
+        InsertFloppyDisks(SLOT6, szImageName_drive, driveConnected, bBoot);
+
+        LPCSTR szImageName_harddisk[NUM_HARDDISKS] = {nullptr, nullptr};
+
+        if (!options.hardDisk1.empty())
+        {
+            szImageName_harddisk[DRIVE_1] = options.hardDisk1.c_str();
+        }
+
+        if (!options.hardDisk2.empty())
+        {
+            szImageName_harddisk[DRIVE_2] = options.hardDisk2.c_str();
+        }
+
+        InsertHardDisks(SLOT7, szImageName_harddisk, bBoot);
+
+        if (!options.customRom.empty())
+        {
+            CloseHandle(g_hCustomRom);
+            g_hCustomRom = CreateFile(
+                options.customRom.c_str(), GENERIC_READ, 0, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, nullptr);
+            if (g_hCustomRom == INVALID_HANDLE_VALUE)
+            {
+                LogFileOutput("Init: Failed to load Custom ROM: %s\n", options.customRom.c_str());
+            }
+        }
+
+        if (!options.customRomF8.empty())
+        {
+            CloseHandle(g_hCustomRomF8);
+            g_hCustomRomF8 = CreateFile(
+                options.customRomF8.c_str(), GENERIC_READ, 0, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, nullptr);
+            if (g_hCustomRomF8 == INVALID_HANDLE_VALUE)
+            {
+                LogFileOutput("Init: Failed to load custom F8 ROM: %s\n", options.customRomF8.c_str());
+            }
+        }
+
+        if (!options.wavFileSpeaker.empty())
+        {
+            if (RiffInitWriteFile(options.wavFileSpeaker.c_str(), SPKR_SAMPLE_RATE, 1))
+            {
+                Spkr_OutputToRiff();
+            }
+        }
+        else if (!options.wavFileMockingboard.empty())
+        {
+            if (RiffInitWriteFile(options.wavFileMockingboard.c_str(), MockingboardCard::SAMPLE_RATE, 2))
+            {
+                GetCardMgr().GetMockingboardCardMgr().OutputToRiff();
+            }
+        }
+
+        Paddle::setSquaring(options.paddleSquaring);
     }
 
-    bool bBoot = false;
-    InsertFloppyDisks(SLOT6, szImageName_drive, driveConnected, bBoot);
-
-    LPCSTR szImageName_harddisk[NUM_HARDDISKS] = {nullptr, nullptr};
-
-    if (!options.hardDisk1.empty())
-    {
-      szImageName_harddisk[DRIVE_1] = options.hardDisk1.c_str();
-    }
-
-    if (!options.hardDisk2.empty())
-    {
-      szImageName_harddisk[DRIVE_2] = options.hardDisk2.c_str();
-    }
-
-    InsertHardDisks(SLOT7, szImageName_harddisk, bBoot);
-
-    if (!options.customRom.empty())
-    {
-      CloseHandle(g_hCustomRom);
-      g_hCustomRom = CreateFile(options.customRom.c_str(), GENERIC_READ, 0, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, nullptr);
-      if (g_hCustomRom == INVALID_HANDLE_VALUE)
-      {
-        LogFileOutput("Init: Failed to load Custom ROM: %s\n", options.customRom.c_str());
-      }
-    }
-
-    if (!options.customRomF8.empty())
-    {
-      CloseHandle(g_hCustomRomF8);
-      g_hCustomRomF8 = CreateFile(options.customRomF8.c_str(), GENERIC_READ, 0, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, nullptr);
-      if (g_hCustomRomF8 == INVALID_HANDLE_VALUE)
-      {
-        LogFileOutput("Init: Failed to load custom F8 ROM: %s\n", options.customRomF8.c_str());
-      }
-    }
-
-    if (!options.wavFileSpeaker.empty())
-    {
-      if (RiffInitWriteFile(options.wavFileSpeaker.c_str(), SPKR_SAMPLE_RATE, 1))
-      {
-        Spkr_OutputToRiff();
-      }
-    }
-    else if (!options.wavFileMockingboard.empty())
-    {
-      if (RiffInitWriteFile(options.wavFileMockingboard.c_str(), MockingboardCard::SAMPLE_RATE, 2))
-      {
-        GetCardMgr().GetMockingboardCardMgr().OutputToRiff();
-      }
-    }
-
-    Paddle::setSquaring(options.paddleSquaring);
-  }
-
-}
+} // namespace common2
diff --git a/source/frontends/common2/programoptions.h b/source/frontends/common2/programoptions.h
index debfb9cc3..a8dc4a887 100644
--- a/source/frontends/common2/programoptions.h
+++ b/source/frontends/common2/programoptions.h
@@ -8,72 +8,71 @@
 namespace common2
 {
 
-  struct Geometry
-  {
-    int width;
-    int height;
-    int x;
-    int y;
-  };
+    struct Geometry
+    {
+        int width;
+        int height;
+        int x;
+        int y;
+    };
 
+    struct EmulatorOptions
+    {
+        EmulatorOptions();
 
-  struct EmulatorOptions
-  {
-    EmulatorOptions();
+        std::string disk1;
+        std::string disk2;
 
-    std::string disk1;
-    std::string disk2;
+        std::string hardDisk1;
+        std::string hardDisk2;
 
-    std::string hardDisk1;
-    std::string hardDisk2;
+        std::string snapshotFilename;
+        bool loadSnapshot = false;
 
-    std::string snapshotFilename;
-    bool loadSnapshot = false;
+        int memclear;
 
-    int memclear;
+        bool log = false;
 
-    bool log = false;
+        bool benchmark = false;
+        bool headless = false;
+        bool noVideoUpdate = false; // only for applen
 
-    bool benchmark = false;
-    bool headless = false;
-    bool noVideoUpdate = false;  // only for applen
+        bool paddleSquaring = true; // turn the x/y range to a square
+        // on my PC it is something like
+        // "/dev/input/by-id/usb-©Microsoft_Corporation_Controller_1BBE3DB-event-joystick"
+        std::string paddleDeviceName;
 
-    bool paddleSquaring = true;  // turn the x/y range to a square
-    // on my PC it is something like
-    // "/dev/input/by-id/usb-©Microsoft_Corporation_Controller_1BBE3DB-event-joystick"
-    std::string paddleDeviceName;
+        std::filesystem::path configurationFile;
+        bool useQtIni = false; // use Qt .ini file (read only)
 
-    std::filesystem::path configurationFile;
-    bool useQtIni = false;  // use Qt .ini file (read only)
+        bool run = true; // false if options include "-h"
 
-    bool run = true;  // false if options include "-h"
+        bool autoBoot = true;
+        bool fixedSpeed = false; // default adaptive
+        bool syncWithTimer = false;
+        size_t audioBuffer = 46; // in ms -> corresponds to 2048 samples (keep below 90ms)
 
-    bool autoBoot = true;
-    bool fixedSpeed = false; // default adaptive
-    bool syncWithTimer = false;
-    size_t audioBuffer = 46; // in ms -> corresponds to 2048 samples (keep below 90ms)
+        int sdlDriver = -1;               // default = -1 to let SDL choose
+        bool imgui = true;                // use imgui renderer
+        std::optional<Geometry> geometry; // must be initialised with defaults
+        bool aspectRatio = false;         // preserve aspect ratio
+        int glSwapInterval = 1;           // SDL_GL_SetSwapInterval
+        std::optional<int> gameControllerIndex;
+        std::string gameControllerMappingFile;
+        std::string audioDeviceName;
 
-    int sdlDriver = -1; // default = -1 to let SDL choose
-    bool imgui = true; // use imgui renderer
-    std::optional<Geometry> geometry; // must be initialised with defaults
-    bool aspectRatio = false; // preserve aspect ratio
-    int glSwapInterval = 1; // SDL_GL_SetSwapInterval
-    std::optional<int> gameControllerIndex;
-    std::string gameControllerMappingFile;
-    std::string audioDeviceName;
+        std::string customRomF8;
+        std::string customRom;
 
-    std::string customRomF8;
-    std::string customRom;
+        bool noAudio = false;
+        std::string wavFileSpeaker;
+        std::string wavFileMockingboard;
 
-    bool noAudio = false;
-    std::string wavFileSpeaker;
-    std::string wavFileMockingboard;
+        std::vector<std::string> registryOptions;
 
-    std::vector<std::string> registryOptions;
+        std::vector<std::string> natPortFwds;
+    };
 
-    std::vector<std::string> natPortFwds;
-  };
+    void applyOptions(const EmulatorOptions &options);
 
-  void applyOptions(const EmulatorOptions & options);
-
-}
+} // namespace common2
diff --git a/source/frontends/common2/ptreeregistry.cpp b/source/frontends/common2/ptreeregistry.cpp
index e9bbd1234..c417a4308 100644
--- a/source/frontends/common2/ptreeregistry.cpp
+++ b/source/frontends/common2/ptreeregistry.cpp
@@ -6,88 +6,87 @@
 namespace
 {
 
-  std::string decodeKey(const std::string & key)
-  {
-    std::string result = key;
-    // quick implementation, just to make it work.
-    // is there a library function available somewhere?
-    boost::algorithm::replace_all(result, "%20", " ");
-    return result;
-  }
+    std::string decodeKey(const std::string &key)
+    {
+        std::string result = key;
+        // quick implementation, just to make it work.
+        // is there a library function available somewhere?
+        boost::algorithm::replace_all(result, "%20", " ");
+        return result;
+    }
 
-}
+} // namespace
 
 namespace common2
 {
 
-  bool PTreeRegistry::KeyQtEncodedLess::operator()(const std::string & lhs, const std::string & rhs) const
-  {
-    const std::string key1 = decodeKey(lhs);
-    const std::string key2 = decodeKey(rhs);
-    return key1 < key2;
-  }
-
-  std::string PTreeRegistry::getString(const std::string & section, const std::string & key) const
-  {
-    return getValue<std::string>(section, key);
-  }
-
-  uint32_t PTreeRegistry::getDWord(const std::string & section, const std::string & key) const
-  {
-    return getValue<uint32_t>(section, key);
-  }
-
-  bool PTreeRegistry::getBool(const std::string & section, const std::string & key) const
-  {
-    return getValue<bool>(section, key);
-  }
-
-  void PTreeRegistry::putString(const std::string & section, const std::string & key, const std::string & value)
-  {
-    putValue(section, key, value);
-  }
-
-  void PTreeRegistry::putDWord(const std::string & section, const std::string & key, const uint32_t value)
-  {
-    putValue(section, key, value);
-  }
-
-  template <typename T>
-  T PTreeRegistry::getValue(const std::string & section, const std::string & key) const
-  {
-    const std::string path = section + "." + key;
-    const T value = myINI.get<T>(path);
-    return value;
-  }
-
-  template <typename T>
-  void PTreeRegistry::putValue(const std::string & section, const std::string & key, const T & value)
-  {
-    const std::string path = section + "." + key;
-    myINI.put(path, value);
-  }
-
-  std::map<std::string, std::map<std::string, std::string>> PTreeRegistry::getAllValues() const
-  {
-    std::map<std::string, std::map<std::string, std::string>> values;
-    for (const auto & it1 : myINI)
+    bool PTreeRegistry::KeyQtEncodedLess::operator()(const std::string &lhs, const std::string &rhs) const
+    {
+        const std::string key1 = decodeKey(lhs);
+        const std::string key2 = decodeKey(rhs);
+        return key1 < key2;
+    }
+
+    std::string PTreeRegistry::getString(const std::string &section, const std::string &key) const
+    {
+        return getValue<std::string>(section, key);
+    }
+
+    uint32_t PTreeRegistry::getDWord(const std::string &section, const std::string &key) const
+    {
+        return getValue<uint32_t>(section, key);
+    }
+
+    bool PTreeRegistry::getBool(const std::string &section, const std::string &key) const
+    {
+        return getValue<bool>(section, key);
+    }
+
+    void PTreeRegistry::putString(const std::string &section, const std::string &key, const std::string &value)
+    {
+        putValue(section, key, value);
+    }
+
+    void PTreeRegistry::putDWord(const std::string &section, const std::string &key, const uint32_t value)
+    {
+        putValue(section, key, value);
+    }
+
+    template <typename T> T PTreeRegistry::getValue(const std::string &section, const std::string &key) const
     {
-      for (const auto & it2 : it1.second)
-      {
-        values[it1.first][it2.first] = it2.second.get_value<std::string>();
-      }
+        const std::string path = section + "." + key;
+        const T value = myINI.get<T>(path);
+        return value;
     }
-    return values;
-  }
 
-  std::string PTreeRegistry::getLocation() const
-  {
-    return std::string();
-  }
+    template <typename T>
+    void PTreeRegistry::putValue(const std::string &section, const std::string &key, const T &value)
+    {
+        const std::string path = section + "." + key;
+        myINI.put(path, value);
+    }
 
-  void PTreeRegistry::saveToINIFile(const std::string & filename) const
-  {
-    boost::property_tree::ini_parser::write_ini(filename, myINI);
-  }
+    std::map<std::string, std::map<std::string, std::string>> PTreeRegistry::getAllValues() const
+    {
+        std::map<std::string, std::map<std::string, std::string>> values;
+        for (const auto &it1 : myINI)
+        {
+            for (const auto &it2 : it1.second)
+            {
+                values[it1.first][it2.first] = it2.second.get_value<std::string>();
+            }
+        }
+        return values;
+    }
+
+    std::string PTreeRegistry::getLocation() const
+    {
+        return std::string();
+    }
+
+    void PTreeRegistry::saveToINIFile(const std::string &filename) const
+    {
+        boost::property_tree::ini_parser::write_ini(filename, myINI);
+    }
 
-}
+} // namespace common2
diff --git a/source/frontends/common2/ptreeregistry.h b/source/frontends/common2/ptreeregistry.h
index a0b15ada3..21eac179e 100644
--- a/source/frontends/common2/ptreeregistry.h
+++ b/source/frontends/common2/ptreeregistry.h
@@ -7,40 +7,38 @@
 namespace common2
 {
 
-  class PTreeRegistry : public Registry
-  {
-  public:
-    struct KeyQtEncodedLess
+    class PTreeRegistry : public Registry
     {
-      // this function is used to make the Qt registry compatible with sa2 and napple
-      // it is here, in the base class PTreeRegistry simply because it makes things easier
-      // KeyQtEncodedLess goes in the typedef init_t below
-      bool operator()(const std::string & lhs, const std::string & rhs) const;
-    };
+    public:
+        struct KeyQtEncodedLess
+        {
+            // this function is used to make the Qt registry compatible with sa2 and napple
+            // it is here, in the base class PTreeRegistry simply because it makes things easier
+            // KeyQtEncodedLess goes in the typedef init_t below
+            bool operator()(const std::string &lhs, const std::string &rhs) const;
+        };
 
-    typedef boost::property_tree::basic_ptree<std::string, std::string, KeyQtEncodedLess> ini_t;
+        typedef boost::property_tree::basic_ptree<std::string, std::string, KeyQtEncodedLess> ini_t;
 
-    std::string getString(const std::string & section, const std::string & key) const override;
-    uint32_t getDWord(const std::string & section, const std::string & key) const override;
-    bool getBool(const std::string & section, const std::string & key) const override;
+        std::string getString(const std::string &section, const std::string &key) const override;
+        uint32_t getDWord(const std::string &section, const std::string &key) const override;
+        bool getBool(const std::string &section, const std::string &key) const override;
 
-    void putString(const std::string & section, const std::string & key, const std::string & value) override;
-    void putDWord(const std::string & section, const std::string & key, const uint32_t value) override;
+        void putString(const std::string &section, const std::string &key, const std::string &value) override;
+        void putDWord(const std::string &section, const std::string &key, const uint32_t value) override;
 
-    template<typename T>
-    T getValue(const std::string & section, const std::string & key) const;
+        template <typename T> T getValue(const std::string &section, const std::string &key) const;
 
-    template<typename T>
-    void putValue(const std::string & section, const std::string & key, const T & value);
+        template <typename T> void putValue(const std::string &section, const std::string &key, const T &value);
 
-    std::map<std::string, std::map<std::string, std::string>> getAllValues() const override;
+        std::map<std::string, std::map<std::string, std::string>> getAllValues() const override;
 
-    std::string getLocation() const override;
+        std::string getLocation() const override;
 
-    void saveToINIFile(const std::string & filename) const;
+        void saveToINIFile(const std::string &filename) const;
 
-  protected:
-    ini_t myINI;
-  };
+    protected:
+        ini_t myINI;
+    };
 
-}
+} // namespace common2
diff --git a/source/frontends/common2/speed.cpp b/source/frontends/common2/speed.cpp
index 6035a64ab..89b5273a7 100644
--- a/source/frontends/common2/speed.cpp
+++ b/source/frontends/common2/speed.cpp
@@ -7,94 +7,97 @@
 
 namespace
 {
-  double getAudioAdjustedSpeed()
-  {
-    return g_fClksPerSpkrSample * SPKR_SAMPLE_RATE;
-    // return g_fCurrentCLK6502;
-  }
-
-  uint32_t checkAndReturn(const int64_t cycles)
-  {
-    // AppleWin uses uint32_t, so we check the value is sound
-    const int64_t cyclesToExecute = std::max<int64_t>(0, cycles);
-    _ASSERT(cyclesToExecute <= std::numeric_limits<uint32_t>::max());
-
-    return static_cast<uint32_t>(cyclesToExecute);
-  }
-}
+    double getAudioAdjustedSpeed()
+    {
+        return g_fClksPerSpkrSample * SPKR_SAMPLE_RATE;
+        // return g_fCurrentCLK6502;
+    }
+
+    uint32_t checkAndReturn(const int64_t cycles)
+    {
+        // AppleWin uses uint32_t, so we check the value is sound
+        const int64_t cyclesToExecute = std::max<int64_t>(0, cycles);
+        _ASSERT(cyclesToExecute <= std::numeric_limits<uint32_t>::max());
+
+        return static_cast<uint32_t>(cyclesToExecute);
+    }
+} // namespace
 
 namespace common2
 {
 
-  Speed::Speed(const bool fixedSpeed)
-    : myFixedSpeed(fixedSpeed)
-  {
-    reset();
-  }
-
-  void Speed::reset()
-  {
-    myStartTime = std::chrono::steady_clock::now();
-    myStartCycles = g_nCumulativeCycles;
-    myOrgStartCycles = myStartCycles;
-    myTotalFeedbackCycles = 0;
-    myAudioSpeed = getAudioAdjustedSpeed();
-  }
-
-  uint32_t Speed::getCyclesAtFixedSpeed(const int64_t microseconds) const
-  {
-    const int64_t cycles = static_cast<int64_t>(microseconds * myAudioSpeed * 1.0e-6) + g_nCpuCyclesFeedback;
-    return checkAndReturn(cycles);
-  }
-
-  uint32_t Speed::getCyclesTillNext(const int64_t microseconds)
-  {
-    myTotalFeedbackCycles += g_nCpuCyclesFeedback;
-
-    if (myFixedSpeed || g_bFullSpeed)
+    Speed::Speed(const bool fixedSpeed)
+        : myFixedSpeed(fixedSpeed)
     {
-      return getCyclesAtFixedSpeed(microseconds);
+        reset();
     }
-    else
-    {
-      const int64_t currentCycles = g_nCumulativeCycles;
-      const auto currentTime = std::chrono::steady_clock::now();
 
-      const auto currentDelta = std::chrono::duration_cast<std::chrono::microseconds>(currentTime - myStartTime).count();
-      // target the next time we will be called
-      const auto targetDeltaInMicros = currentDelta + microseconds;
-
-      // permanently apply the correction
-      myStartCycles += g_nCpuCyclesFeedback;
+    void Speed::reset()
+    {
+        myStartTime = std::chrono::steady_clock::now();
+        myStartCycles = g_nCumulativeCycles;
+        myOrgStartCycles = myStartCycles;
+        myTotalFeedbackCycles = 0;
+        myAudioSpeed = getAudioAdjustedSpeed();
+    }
 
-      const int64_t targetCycles = static_cast<int64_t>(targetDeltaInMicros * myAudioSpeed * 1.0e-6) + myStartCycles;
+    uint32_t Speed::getCyclesAtFixedSpeed(const int64_t microseconds) const
+    {
+        const int64_t cycles = static_cast<int64_t>(microseconds * myAudioSpeed * 1.0e-6) + g_nCpuCyclesFeedback;
+        return checkAndReturn(cycles);
+    }
 
-      // if we got ahead, nothing to do this time
-      // CpuExecute will still execute 1 instruction, which does not cause any issues
-      return checkAndReturn(targetCycles - currentCycles);
+    uint32_t Speed::getCyclesTillNext(const int64_t microseconds)
+    {
+        myTotalFeedbackCycles += g_nCpuCyclesFeedback;
+
+        if (myFixedSpeed || g_bFullSpeed)
+        {
+            return getCyclesAtFixedSpeed(microseconds);
+        }
+        else
+        {
+            const int64_t currentCycles = g_nCumulativeCycles;
+            const auto currentTime = std::chrono::steady_clock::now();
+
+            const auto currentDelta =
+                std::chrono::duration_cast<std::chrono::microseconds>(currentTime - myStartTime).count();
+            // target the next time we will be called
+            const auto targetDeltaInMicros = currentDelta + microseconds;
+
+            // permanently apply the correction
+            myStartCycles += g_nCpuCyclesFeedback;
+
+            const int64_t targetCycles =
+                static_cast<int64_t>(targetDeltaInMicros * myAudioSpeed * 1.0e-6) + myStartCycles;
+
+            // if we got ahead, nothing to do this time
+            // CpuExecute will still execute 1 instruction, which does not cause any issues
+            return checkAndReturn(targetCycles - currentCycles);
+        }
     }
-  }
 
-  Speed::Stats Speed::getSpeedStats() const
-  {
-    const auto currentTime = std::chrono::steady_clock::now();
-    const auto currentDelta = std::chrono::duration_cast<std::chrono::microseconds>(currentTime - myStartTime).count();
-    const double multiplier = 1000000.0 / currentDelta;
+    Speed::Stats Speed::getSpeedStats() const
+    {
+        const auto currentTime = std::chrono::steady_clock::now();
+        const auto currentDelta =
+            std::chrono::duration_cast<std::chrono::microseconds>(currentTime - myStartTime).count();
+        const double multiplier = 1000000.0 / currentDelta;
 
-    Stats stats{};
+        Stats stats{};
 
-    stats.nominal = g_fCurrentCLK6502;
-    stats.audio = myAudioSpeed;
+        stats.nominal = g_fCurrentCLK6502;
+        stats.audio = myAudioSpeed;
 
-    if (g_nAppMode == MODE_RUNNING)
-    {
-      stats.netFeedback = myTotalFeedbackCycles * multiplier;
+        if (g_nAppMode == MODE_RUNNING)
+        {
+            stats.netFeedback = myTotalFeedbackCycles * multiplier;
 
-      const int64_t totalCycles = g_nCumulativeCycles - myOrgStartCycles;
-      stats.actual = totalCycles * multiplier;
-    }
+            const int64_t totalCycles = g_nCumulativeCycles - myOrgStartCycles;
+            stats.actual = totalCycles * multiplier;
+        }
 
-    return stats;
-  }
+        return stats;
+    }
 
-}
+} // namespace common2
diff --git a/source/frontends/common2/speed.h b/source/frontends/common2/speed.h
index 4f2362859..5dcae941a 100644
--- a/source/frontends/common2/speed.h
+++ b/source/frontends/common2/speed.h
@@ -5,39 +5,38 @@
 namespace common2
 {
 
-  class Speed
-  {
-  public:
-    struct Stats
+    class Speed
     {
-      double nominal;       // nominal speed
-      double audio;         // audio adjust speed (multiple of SPKR_SAMPLE_RATE)
-      double actual;        // real speed since last reset
+    public:
+        struct Stats
+        {
+            double nominal; // nominal speed
+            double audio;   // audio adjust speed (multiple of SPKR_SAMPLE_RATE)
+            double actual;  // real speed since last reset
 
-      double netFeedback;   // Hz net feedback adjustment
-    };
-
-    Speed(const bool fixedSpeed);
+            double netFeedback; // Hz net feedback adjustment
+        };
 
-    void reset();
+        Speed(const bool fixedSpeed);
 
-    // calculate the number of cycles to execute in the current period
-    // assuming the next call will happen in x microseconds
-    uint32_t getCyclesTillNext(const int64_t microseconds);
-    uint32_t getCyclesAtFixedSpeed(const int64_t microseconds) const;
+        void reset();
 
-    Stats getSpeedStats() const;
+        // calculate the number of cycles to execute in the current period
+        // assuming the next call will happen in x microseconds
+        uint32_t getCyclesTillNext(const int64_t microseconds);
+        uint32_t getCyclesAtFixedSpeed(const int64_t microseconds) const;
 
-  private:
+        Stats getSpeedStats() const;
 
-    const bool myFixedSpeed;
+    private:
+        const bool myFixedSpeed;
 
-    std::chrono::time_point<std::chrono::steady_clock> myStartTime;
-    int64_t myStartCycles;
-    int64_t myOrgStartCycles;
-    double myAudioSpeed;
+        std::chrono::time_point<std::chrono::steady_clock> myStartTime;
+        int64_t myStartCycles;
+        int64_t myOrgStartCycles;
+        double myAudioSpeed;
 
-    int64_t myTotalFeedbackCycles;
-  };
+        int64_t myTotalFeedbackCycles;
+    };
 
-}
+} // namespace common2
diff --git a/source/frontends/common2/timer.cpp b/source/frontends/common2/timer.cpp
index dc92364ed..d10594673 100644
--- a/source/frontends/common2/timer.cpp
+++ b/source/frontends/common2/timer.cpp
@@ -7,47 +7,47 @@
 namespace common2
 {
 
-  Timer::Timer()
-    : mySum(0)
-    , mySum2(0)
-    , myN(0)
-  {
-    tic();
-  }
-
-  void Timer::tic()
-  {
-    myT0 = std::chrono::steady_clock::now();
-  }
-
-  void Timer::toc()
-  {
-    const auto now = std::chrono::steady_clock::now();
-    const auto micros = std::chrono::duration_cast<std::chrono::microseconds>(now - myT0).count();
-    const double s = micros * 0.000001;
-    mySum += s;
-    mySum2 += s * s;
-    ++myN;
-    myT0 = now;
-  }
-
-  double Timer::getTimeInSeconds() const
-  {
-    return mySum;
-  }
-
-  std::ostream& operator<<(std::ostream& os, const Timer & timer)
-  {
-    const int width = 10;
-    const double m1 = timer.mySum / timer.myN;
-    const double m2 = timer.mySum2 / timer.myN;
-    const double std = std::sqrt(std::max(0.0, m2 - m1 * m1));
-    const double scale = 1000;
-    os << "total = " << std::setw(width) << timer.mySum * scale << " ms";
-    os << ", mean = " << std::setw(width) << m1 * scale << " ms";
-    os << ", std = " << std::setw(width) << std * scale << " ms";
-    os << ", n = " << std::setw(6) << timer.myN;
-    return os;
-  }
-
-}
+    Timer::Timer()
+        : mySum(0)
+        , mySum2(0)
+        , myN(0)
+    {
+        tic();
+    }
+
+    void Timer::tic()
+    {
+        myT0 = std::chrono::steady_clock::now();
+    }
+
+    void Timer::toc()
+    {
+        const auto now = std::chrono::steady_clock::now();
+        const auto micros = std::chrono::duration_cast<std::chrono::microseconds>(now - myT0).count();
+        const double s = micros * 0.000001;
+        mySum += s;
+        mySum2 += s * s;
+        ++myN;
+        myT0 = now;
+    }
+
+    double Timer::getTimeInSeconds() const
+    {
+        return mySum;
+    }
+
+    std::ostream &operator<<(std::ostream &os, const Timer &timer)
+    {
+        const int width = 10;
+        const double m1 = timer.mySum / timer.myN;
+        const double m2 = timer.mySum2 / timer.myN;
+        const double std = std::sqrt(std::max(0.0, m2 - m1 * m1));
+        const double scale = 1000;
+        os << "total = " << std::setw(width) << timer.mySum * scale << " ms";
+        os << ", mean = " << std::setw(width) << m1 * scale << " ms";
+        os << ", std = " << std::setw(width) << std * scale << " ms";
+        os << ", n = " << std::setw(6) << timer.myN;
+        return os;
+    }
+
+} // namespace common2
diff --git a/source/frontends/common2/timer.h b/source/frontends/common2/timer.h
index 88ac7db4b..988240e23 100644
--- a/source/frontends/common2/timer.h
+++ b/source/frontends/common2/timer.h
@@ -4,26 +4,25 @@
 namespace common2
 {
 
-  class Timer
-  {
-  public:
-    Timer();
-    void tic();
-    void toc();
+    class Timer
+    {
+    public:
+        Timer();
+        void tic();
+        void toc();
 
-    double getTimeInSeconds() const;
+        double getTimeInSeconds() const;
 
-    friend std::ostream& operator<<(std::ostream& os, const Timer & timer);
+        friend std::ostream &operator<<(std::ostream &os, const Timer &timer);
 
-  private:
+    private:
+        std::chrono::time_point<std::chrono::steady_clock> myT0;
 
-    std::chrono::time_point<std::chrono::steady_clock> myT0;
+        double mySum;
+        double mySum2;
+        int myN;
+    };
 
-    double mySum;
-    double mySum2;
-    int myN;
-  };
+    std::ostream &operator<<(std::ostream &os, const Timer &timer);
 
-  std::ostream& operator<<(std::ostream& os, const Timer & timer);
-
-}
+} // namespace common2
diff --git a/source/frontends/common2/utils.cpp b/source/frontends/common2/utils.cpp
index 6f0c16598..1e17a690c 100644
--- a/source/frontends/common2/utils.cpp
+++ b/source/frontends/common2/utils.cpp
@@ -8,111 +8,111 @@
 namespace
 {
 
-  std::string getEnvOrDefault(const char * var, const char * fallback = nullptr)
-  {
-    const char* value = getenv(var);
-    if (value)
+    std::string getEnvOrDefault(const char *var, const char *fallback = nullptr)
     {
-      return value;
+        const char *value = getenv(var);
+        if (value)
+        {
+            return value;
+        }
+        if (fallback)
+        {
+            return fallback;
+        }
+        throw std::runtime_error("${" + std::string(var) + "} not set");
     }
-    if (fallback)
-    {
-      return fallback;
-    }
-    throw std::runtime_error("${" + std::string(var) + "} not set");
-  }
 
-}
+} // namespace
 
 namespace common2
 {
 
-  std::filesystem::path getSettingsRootDir()
-  {
+    std::filesystem::path getSettingsRootDir()
+    {
 #ifdef _WIN32
-    const std::string profile = getEnvOrDefault("LOCALAPPDATA");
-    return profile;
+        const std::string profile = getEnvOrDefault("LOCALAPPDATA");
+        return profile;
 #else
-    // https://specifications.freedesktop.org/basedir-spec/latest/
-    const std::filesystem::path home = getHomeDir();
-    const std::filesystem::path config = getEnvOrDefault("XDG_CONFIG_HOME", ".config");
+        // https://specifications.freedesktop.org/basedir-spec/latest/
+        const std::filesystem::path home = getHomeDir();
+        const std::filesystem::path config = getEnvOrDefault("XDG_CONFIG_HOME", ".config");
 
-    return home / config;
+        return home / config;
 #endif
-  }
+    }
 
-  void setSnapshotFilename(const std::filesystem::path & filename)
-  {
-    if (std::filesystem::exists(filename))
+    void setSnapshotFilename(const std::filesystem::path &filename)
     {
-      std::filesystem::current_path(filename.parent_path());
-      Snapshot_SetFilename(filename.string());
-      RegSaveString(TEXT(REG_CONFIG), TEXT(REGVALUE_SAVESTATE_FILENAME), 1, Snapshot_GetPathname());
+        if (std::filesystem::exists(filename))
+        {
+            std::filesystem::current_path(filename.parent_path());
+            Snapshot_SetFilename(filename.string());
+            RegSaveString(TEXT(REG_CONFIG), TEXT(REGVALUE_SAVESTATE_FILENAME), 1, Snapshot_GetPathname());
+        }
     }
-  }
 
-  void loadGeometryFromRegistry(const std::string &section, Geometry & geometry)
-  {
-    const std::string path = section + "\\geometry";
-    const auto loadValue = [&path](const char * name, int & dest)
+    void loadGeometryFromRegistry(const std::string &section, Geometry &geometry)
     {
-      uint32_t value;
-      if (RegLoadValue(path.c_str(), name, TRUE, &value))
-      {
-        // uint32_t and int have the same size
-        // but if they did not, this would be necessary
-        typedef std::make_signed<uint32_t>::type signed_t;
-        dest = static_cast<signed_t>(value);
-      }
-    };
-
-    loadValue("width", geometry.width);
-    loadValue("height", geometry.height);
-    loadValue("x", geometry.x);
-    loadValue("y", geometry.y);
-  }
-
-  void saveGeometryToRegistry(const std::string &section, const Geometry & geometry)
-  {
-    const std::string path = section + "\\geometry";
-    const auto saveValue = [&path](const char * name, const int source)
+        const std::string path = section + "\\geometry";
+        const auto loadValue = [&path](const char *name, int &dest)
+        {
+            uint32_t value;
+            if (RegLoadValue(path.c_str(), name, TRUE, &value))
+            {
+                // uint32_t and int have the same size
+                // but if they did not, this would be necessary
+                typedef std::make_signed<uint32_t>::type signed_t;
+                dest = static_cast<signed_t>(value);
+            }
+        };
+
+        loadValue("width", geometry.width);
+        loadValue("height", geometry.height);
+        loadValue("x", geometry.x);
+        loadValue("y", geometry.y);
+    }
+
+    void saveGeometryToRegistry(const std::string &section, const Geometry &geometry)
+    {
+        const std::string path = section + "\\geometry";
+        const auto saveValue = [&path](const char *name, const int source)
+        {
+            // this seems to already do the right thing for negative numbers
+            RegSaveValue(path.c_str(), name, TRUE, source);
+        };
+        saveValue("width", geometry.width);
+        saveValue("height", geometry.height);
+        saveValue("x", geometry.x);
+        saveValue("y", geometry.y);
+    }
+
+    std::filesystem::path getHomeDir()
     {
-      // this seems to already do the right thing for negative numbers
-      RegSaveValue(path.c_str(), name, TRUE, source);
-    };
-    saveValue("width", geometry.width);
-    saveValue("height", geometry.height);
-    saveValue("x", geometry.x);
-    saveValue("y", geometry.y);
-  }
-
-  std::filesystem::path getHomeDir()
-  {
 #ifdef _WIN32
-    const char * var = "USERPROFILE";
+        const char *var = "USERPROFILE";
 #else
-    const char * var = "HOME";
+        const char *var = "HOME";
 #endif
-    const std::filesystem::path home = getEnvOrDefault(var);
-    return home;
-  }
+        const std::filesystem::path home = getEnvOrDefault(var);
+        return home;
+    }
 
-  std::filesystem::path getConfigFile(const std::string & filename)
-  {
-    const std::filesystem::path dir = getSettingsRootDir() / "applewin";
-    std::filesystem::create_directories(dir);
+    std::filesystem::path getConfigFile(const std::string &filename)
+    {
+        const std::filesystem::path dir = getSettingsRootDir() / "applewin";
+        std::filesystem::create_directories(dir);
 
-    return dir / filename;
-  }
+        return dir / filename;
+    }
 
-  RestoreCurrentDirectory::RestoreCurrentDirectory()
-  : myCurrentDirectory(std::filesystem::current_path())
-  {
-  }
+    RestoreCurrentDirectory::RestoreCurrentDirectory()
+        : myCurrentDirectory(std::filesystem::current_path())
+    {
+    }
 
-  RestoreCurrentDirectory::~RestoreCurrentDirectory()
-  {
-    std::filesystem::current_path(myCurrentDirectory);
-  }
+    RestoreCurrentDirectory::~RestoreCurrentDirectory()
+    {
+        std::filesystem::current_path(myCurrentDirectory);
+    }
 
-}
+} // namespace common2
diff --git a/source/frontends/common2/utils.h b/source/frontends/common2/utils.h
index a4f4cd292..8fef1da6b 100644
--- a/source/frontends/common2/utils.h
+++ b/source/frontends/common2/utils.h
@@ -5,25 +5,26 @@
 
 namespace common2
 {
-  struct Geometry;
+    struct Geometry;
 
-  void setSnapshotFilename(const std::filesystem::path & filename);
+    void setSnapshotFilename(const std::filesystem::path &filename);
 
-  void loadGeometryFromRegistry(const std::string &section, Geometry & geometry);
-  void saveGeometryToRegistry(const std::string &section, const Geometry & geometry);
+    void loadGeometryFromRegistry(const std::string &section, Geometry &geometry);
+    void saveGeometryToRegistry(const std::string &section, const Geometry &geometry);
 
-  std::filesystem::path getSettingsRootDir();
-  std::filesystem::path getHomeDir();
-  std::filesystem::path getConfigFile(const std::string & filename);
+    std::filesystem::path getSettingsRootDir();
+    std::filesystem::path getHomeDir();
+    std::filesystem::path getConfigFile(const std::string &filename);
 
-  // partial workaround to the (mis-)usage of chdir()
-  class RestoreCurrentDirectory
-  {
-  public:
-    RestoreCurrentDirectory();
-    ~RestoreCurrentDirectory();
-  private:
-    const std::filesystem::path myCurrentDirectory;
-  };
+    // partial workaround to the (mis-)usage of chdir()
+    class RestoreCurrentDirectory
+    {
+    public:
+        RestoreCurrentDirectory();
+        ~RestoreCurrentDirectory();
 
-}
+    private:
+        const std::filesystem::path myCurrentDirectory;
+    };
+
+} // namespace common2
diff --git a/source/frontends/libretro/analog.cpp b/source/frontends/libretro/analog.cpp
index 114b09599..c570ebe9d 100644
--- a/source/frontends/libretro/analog.cpp
+++ b/source/frontends/libretro/analog.cpp
@@ -9,19 +9,19 @@
 namespace ra2
 {
 
-  Analog::Analog()
-    : myAxisCodes(2)
-  {
-    myAxisCodes[0] = {RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_X};
-    myAxisCodes[1] = {RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_Y};
-  }
+    Analog::Analog()
+        : myAxisCodes(2)
+    {
+        myAxisCodes[0] = {RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_X};
+        myAxisCodes[1] = {RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_Y};
+    }
 
-  double Analog::getAxis(int i) const
-  {
-    const auto & code = myAxisCodes[i];
-    const int value = input_state_cb(0, code.device, code.index, code.id);
-    const double axis = 2.0 * double(value - AXIS_MIN) / double(AXIS_MAX - AXIS_MIN) - 1.0;
-    return axis;
-  }
+    double Analog::getAxis(int i) const
+    {
+        const auto &code = myAxisCodes[i];
+        const int value = input_state_cb(0, code.device, code.index, code.id);
+        const double axis = 2.0 * double(value - AXIS_MIN) / double(AXIS_MAX - AXIS_MIN) - 1.0;
+        return axis;
+    }
 
-}
+} // namespace ra2
diff --git a/source/frontends/libretro/analog.h b/source/frontends/libretro/analog.h
index 06ebfdae8..dfb66a719 100644
--- a/source/frontends/libretro/analog.h
+++ b/source/frontends/libretro/analog.h
@@ -7,15 +7,15 @@
 namespace ra2
 {
 
-  class Analog : public JoypadBase
-  {
-  public:
-    Analog();
+    class Analog : public JoypadBase
+    {
+    public:
+        Analog();
 
-    double getAxis(int i) const override;
+        double getAxis(int i) const override;
 
-  private:
-    std::vector<InputDescriptor> myAxisCodes;
-  };
+    private:
+        std::vector<InputDescriptor> myAxisCodes;
+    };
 
-}
+} // namespace ra2
diff --git a/source/frontends/libretro/buffer.h b/source/frontends/libretro/buffer.h
index fc8eded51..da2b4657e 100644
--- a/source/frontends/libretro/buffer.h
+++ b/source/frontends/libretro/buffer.h
@@ -6,42 +6,42 @@
 namespace ra2
 {
 
-  template<typename C> // so it works with both char * and const char *
-  class Buffer
-  {
-  public:
-    Buffer(C * const begin, size_t const size) : myPtr(begin), myEnd(begin + size)
+    template <typename C> // so it works with both char * and const char *
+    class Buffer
     {
-
-    }
-
-    template <typename T>
-    T & get()
-    {
-      C * c = myPtr;
-      advance(sizeof(T));
-      return *reinterpret_cast<T *>(c);
-    }
-
-    void get(size_t const size, C * & begin, C * & end)
-    {
-      begin = myPtr;
-      advance(size);
-      end = myPtr;
-    }
-
-  private:
-    C * myPtr;
-    C * const myEnd;
-
-    void advance(size_t const size)
-    {
-      if (myPtr + size > myEnd)
-      {
-        throw std::runtime_error("Buffer: out of bounds");
-      }
-      myPtr += size;
-    }
-  };
-
-}
+    public:
+        Buffer(C *const begin, size_t const size)
+            : myPtr(begin)
+            , myEnd(begin + size)
+        {
+        }
+
+        template <typename T> T &get()
+        {
+            C *c = myPtr;
+            advance(sizeof(T));
+            return *reinterpret_cast<T *>(c);
+        }
+
+        void get(size_t const size, C *&begin, C *&end)
+        {
+            begin = myPtr;
+            advance(size);
+            end = myPtr;
+        }
+
+    private:
+        C *myPtr;
+        C *const myEnd;
+
+        void advance(size_t const size)
+        {
+            if (myPtr + size > myEnd)
+            {
+                throw std::runtime_error("Buffer: out of bounds");
+            }
+            myPtr += size;
+        }
+    };
+
+} // namespace ra2
diff --git a/source/frontends/libretro/diskcontrol.cpp b/source/frontends/libretro/diskcontrol.cpp
index 133b442b6..7a5cdb770 100644
--- a/source/frontends/libretro/diskcontrol.cpp
+++ b/source/frontends/libretro/diskcontrol.cpp
@@ -11,391 +11,393 @@
 #include <fstream>
 #include <filesystem>
 
-
 namespace
 {
 
-  const std::string M3U_COMMENT("#");
-  const std::string M3U_SAVEDISK("#SAVEDISK:");
-  const std::string M3U_SAVEDISK_LABEL("Save Disk ");
+    const std::string M3U_COMMENT("#");
+    const std::string M3U_SAVEDISK("#SAVEDISK:");
+    const std::string M3U_SAVEDISK_LABEL("Save Disk ");
 
-  bool startsWith(const std::string & value, const std::string & prefix)
-  {
-    if (prefix.size() > value.size())
+    bool startsWith(const std::string &value, const std::string &prefix)
     {
-      return false;
+        if (prefix.size() > value.size())
+        {
+            return false;
+        }
+        return std::equal(prefix.begin(), prefix.end(), value.begin());
     }
-    return std::equal(prefix.begin(), prefix.end(), value.begin());
-  }
 
-  void getLabelAndPath(const std::string & line, std::filesystem::path & path, std::string & label)
-  {
-    const size_t pos = line.find('|');
-    if (pos == std::string::npos)
+    void getLabelAndPath(const std::string &line, std::filesystem::path &path, std::string &label)
     {
-      path = line;
-      label = path.stem().string();
+        const size_t pos = line.find('|');
+        if (pos == std::string::npos)
+        {
+            path = line;
+            label = path.stem().string();
+        }
+        else
+        {
+            path = line.substr(0, pos);
+            label = line.substr(pos + 1);
+        }
     }
-    else
+
+    void writeString(ra2::Buffer<char> &buffer, const std::string &value)
     {
-      path = line.substr(0, pos);
-      label = line.substr(pos + 1);
+        size_t const size = value.size();
+        buffer.get<size_t>() = size;
+        char *begin, *end;
+        buffer.get(size, begin, end);
+        memcpy(begin, value.data(), end - begin);
     }
-  }
-
-  void writeString(ra2::Buffer<char> & buffer, const std::string & value)
-  {
-    size_t const size = value.size();
-    buffer.get<size_t>() = size;
-    char * begin, * end;
-    buffer.get(size, begin, end);
-    memcpy(begin, value.data(), end - begin);
-  }
-
-  void readString(ra2::Buffer<const char> & buffer, std::string & value)
-  {
-    size_t const size = buffer.get<size_t const>();
-    char const * begin, * end;
-    buffer.get(size, begin, end);
-    value.assign(begin, end);
-  }
-
-}
 
-namespace ra2
-{
+    void readString(ra2::Buffer<const char> &buffer, std::string &value)
+    {
+        size_t const size = buffer.get<size_t const>();
+        char const *begin, *end;
+        buffer.get(size, begin, end);
+        value.assign(begin, end);
+    }
 
-  DiskControl::DiskControl() : myEjected(true), myIndex(0)
-  {
+} // namespace
 
-  }
+namespace ra2
+{
 
-  const std::string & DiskControl::getCurrentDiskFolder() const
-  {
-    return myCurrentDiskFolder;
-  }
+    DiskControl::DiskControl()
+        : myEjected(true)
+        , myIndex(0)
+    {
+    }
 
-  void DiskControl::storeCurrentDiskFolder(const std::string & path)
-  {
-    // a bit of a workaround to a save state issue, where the disk folder is lost
-    // this will only support 1 disk
-    const std::filesystem::path filePath(path);
-    myCurrentDiskFolder = filePath.parent_path().string();
-  }
+    const std::string &DiskControl::getCurrentDiskFolder() const
+    {
+        return myCurrentDiskFolder;
+    }
 
-  bool DiskControl::insertDisk(const std::string & path)
-  {
-    const bool writeProtected = IMAGE_FORCE_WRITE_PROTECTED;
-    const bool createIfNecessary = IMAGE_DONT_CREATE;
+    void DiskControl::storeCurrentDiskFolder(const std::string &path)
+    {
+        // a bit of a workaround to a save state issue, where the disk folder is lost
+        // this will only support 1 disk
+        const std::filesystem::path filePath(path);
+        myCurrentDiskFolder = filePath.parent_path().string();
+    }
 
-    if (insertFloppyDisk(path, writeProtected, createIfNecessary))
+    bool DiskControl::insertDisk(const std::string &path)
     {
-      myIndex = 0;
-      myImages.clear();
+        const bool writeProtected = IMAGE_FORCE_WRITE_PROTECTED;
+        const bool createIfNecessary = IMAGE_DONT_CREATE;
 
-      const std::filesystem::path filePath(path);
-      myImages.push_back({filePath.string(), filePath.stem().string(), writeProtected, createIfNecessary});
-      myEjected = false;
-      return true;
-    }
+        if (insertFloppyDisk(path, writeProtected, createIfNecessary))
+        {
+            myIndex = 0;
+            myImages.clear();
 
-    return insertHardDisk(path);
-  }
+            const std::filesystem::path filePath(path);
+            myImages.push_back({filePath.string(), filePath.stem().string(), writeProtected, createIfNecessary});
+            myEjected = false;
+            return true;
+        }
 
-  bool DiskControl::insertPlaylist(const std::string & path)
-  {
-    const std::filesystem::path playlistPath(path);
-    std::ifstream playlist(playlistPath);
-    if (!playlist)
-    {
-      return false;
+        return insertHardDisk(path);
     }
 
-    myImages.clear();
-    const std::filesystem::path parent = playlistPath.parent_path();
-    const std::filesystem::path savePath(ra2::save_directory);
-    const std::string playlistStem = playlistPath.stem().string();
-
-    std::string line;
-    while (std::getline(playlist, line))
+    bool DiskControl::insertPlaylist(const std::string &path)
     {
-      // should we trim initial spaces?
-      if (startsWith(line, M3U_SAVEDISK))
-      {
-        const size_t index = myImages.size() + 1;
-        const std::string filename = StrFormat("%s.save%" SIZE_T_FMT ".dsk", playlistStem.c_str(), index);
-
-        // 1) use the label from #SAVEDISK:label
-        std::string labelSuffix = line.substr(M3U_SAVEDISK.size());
-        if (labelSuffix.empty())
+        const std::filesystem::path playlistPath(path);
+        std::ifstream playlist(playlistPath);
+        if (!playlist)
         {
-          // 2) use an automatic label "the index"
-          labelSuffix = std::to_string(index);
+            return false;
         }
 
-        // Always prefix with "Save Disk"
-        const std::string label = M3U_SAVEDISK_LABEL + labelSuffix;
+        myImages.clear();
+        const std::filesystem::path parent = playlistPath.parent_path();
+        const std::filesystem::path savePath(ra2::save_directory);
+        const std::string playlistStem = playlistPath.stem().string();
+
+        std::string line;
+        while (std::getline(playlist, line))
+        {
+            // should we trim initial spaces?
+            if (startsWith(line, M3U_SAVEDISK))
+            {
+                const size_t index = myImages.size() + 1;
+                const std::string filename = StrFormat("%s.save%" SIZE_T_FMT ".dsk", playlistStem.c_str(), index);
+
+                // 1) use the label from #SAVEDISK:label
+                std::string labelSuffix = line.substr(M3U_SAVEDISK.size());
+                if (labelSuffix.empty())
+                {
+                    // 2) use an automatic label "the index"
+                    labelSuffix = std::to_string(index);
+                }
+
+                // Always prefix with "Save Disk"
+                const std::string label = M3U_SAVEDISK_LABEL + labelSuffix;
+
+                const std::filesystem::path imagePath = savePath / filename;
+
+                // TODO: this disk is NOT formatted
+                myImages.push_back({imagePath.string(), label, IMAGE_USE_FILES_WRITE_PROTECT_STATUS, IMAGE_CREATE});
+            }
+            else if (!startsWith(line, M3U_COMMENT))
+            {
+                std::filesystem::path imagePath;
+                std::string label;
+                getLabelAndPath(line, imagePath, label);
+
+                if (imagePath.is_relative())
+                {
+                    imagePath = parent / imagePath;
+                }
+                myImages.push_back({imagePath.string(), label, IMAGE_FORCE_WRITE_PROTECTED, IMAGE_DONT_CREATE});
+            }
+        }
 
-        const std::filesystem::path imagePath = savePath / filename;
+        // insert the first image by default
+        myIndex = 0;
 
-        // TODO: this disk is NOT formatted
-        myImages.push_back({imagePath.string(), label, IMAGE_USE_FILES_WRITE_PROTECT_STATUS, IMAGE_CREATE});
-      }
-      else if (!startsWith(line, M3U_COMMENT))
-      {
-        std::filesystem::path imagePath;
-        std::string label;
-        getLabelAndPath(line, imagePath, label);
+        const PlaylistStartDisk playlistStartDisk = GetPlaylistStartDisk();
 
-        if (imagePath.is_relative())
+        if (playlistStartDisk == PlaylistStartDisk::Previous)
         {
-          imagePath = parent / imagePath;
+            // if we have an initial disk image, let's try to honour it
+            if (!ourInitialPath.empty() && ourInitialIndex < myImages.size() &&
+                myImages[ourInitialIndex].path == ourInitialPath)
+            {
+                myIndex = ourInitialIndex;
+                // do we need to reset for next time?
+                ourInitialPath.clear();
+                ourInitialIndex = 0;
+            }
         }
-        myImages.push_back({imagePath.string(), label, IMAGE_FORCE_WRITE_PROTECTED, IMAGE_DONT_CREATE});
-      }
-    }
 
-    // insert the first image by default
-    myIndex = 0;
-
-    const PlaylistStartDisk playlistStartDisk = GetPlaylistStartDisk();
+        // this is safe even if myImages is empty
+        myEjected = true;
+        return setEjectedState(false);
+    }
 
-    if (playlistStartDisk == PlaylistStartDisk::Previous)
+    bool DiskControl::insertFloppyDisk(const std::string &path, const bool writeProtected, bool const createIfNecessary)
     {
-      // if we have an initial disk image, let's try to honour it
-      if (!ourInitialPath.empty() && ourInitialIndex < myImages.size() && myImages[ourInitialIndex].path == ourInitialPath)
-      {
-        myIndex = ourInitialIndex;
-        // do we need to reset for next time?
-        ourInitialPath.clear();
-        ourInitialIndex = 0;
-      }
-    }
+        CardManager &cardManager = GetCardMgr();
 
-    // this is safe even if myImages is empty
-    myEjected = true;
-    return setEjectedState(false);
-  }
+        Disk2InterfaceCard *disk2Card = dynamic_cast<Disk2InterfaceCard *>(cardManager.GetObj(SLOT6));
+        if (disk2Card)
+        {
+            const ImageError_e error = disk2Card->InsertDisk(DRIVE_1, path, writeProtected, createIfNecessary);
 
-  bool DiskControl::insertFloppyDisk(const std::string & path, const bool writeProtected, bool const createIfNecessary)
-  {
-    CardManager & cardManager = GetCardMgr();
+            if (error == eIMAGE_ERROR_NONE)
+            {
+                storeCurrentDiskFolder(path);
+                return true;
+            }
+        }
 
-    Disk2InterfaceCard * disk2Card = dynamic_cast<Disk2InterfaceCard*>(cardManager.GetObj(SLOT6));
-    if (disk2Card)
+        return false;
+    }
+
+    bool DiskControl::insertHardDisk(const std::string &path)
     {
-      const ImageError_e error = disk2Card->InsertDisk(DRIVE_1, path, writeProtected, createIfNecessary);
+        CardManager &cardManager = GetCardMgr();
 
-      if (error == eIMAGE_ERROR_NONE)
-      {
-        storeCurrentDiskFolder(path);
-        return true;
-      }
-    }
+        if (cardManager.QuerySlot(SLOT7) != CT_GenericHDD)
+        {
+            cardManager.Insert(SLOT7, CT_GenericHDD);
+        }
 
-    return false;
-  }
+        HarddiskInterfaceCard *harddiskCard = dynamic_cast<HarddiskInterfaceCard *>(cardManager.GetObj(SLOT7));
+        if (harddiskCard)
+        {
+            const BOOL bRes = harddiskCard->Insert(HARDDISK_1, path);
+            const bool ok = bRes == TRUE;
+            if (ok)
+            {
+                storeCurrentDiskFolder(path);
+            }
+            return ok;
+        }
 
-  bool DiskControl::insertHardDisk(const std::string & path)
-  {
-    CardManager & cardManager = GetCardMgr();
+        return false;
+    }
 
-    if (cardManager.QuerySlot(SLOT7) != CT_GenericHDD)
+    bool DiskControl::getEjectedState() const
     {
-      cardManager.Insert(SLOT7, CT_GenericHDD);
+        return myEjected;
     }
 
-    HarddiskInterfaceCard * harddiskCard = dynamic_cast<HarddiskInterfaceCard*>(cardManager.GetObj(SLOT7));
-    if (harddiskCard)
+    bool DiskControl::setEjectedState(bool ejected)
     {
-      const BOOL bRes = harddiskCard->Insert(HARDDISK_1, path);
-      const bool ok = bRes == TRUE;
-      if (ok)
-      {
-        storeCurrentDiskFolder(path);
-      }
-      return ok;
-    }
+        if (myEjected == ejected)
+        {
+            return true;
+        }
 
-    return false;
-  }
+        CardManager &cardManager = GetCardMgr();
+        Disk2InterfaceCard *disk2Card = dynamic_cast<Disk2InterfaceCard *>(cardManager.GetObj(SLOT6));
 
-  bool DiskControl::getEjectedState() const
-  {
-    return myEjected;
-  }
+        bool result = false;
+        if (disk2Card && myIndex < myImages.size())
+        {
+            if (ejected)
+            {
+                disk2Card->EjectDisk(DRIVE_1);
+                result = true;
+                myEjected = ejected;
+            }
+            else
+            {
+                // inserted
+                result = insertFloppyDisk(
+                    myImages[myIndex].path, myImages[myIndex].writeProtected, myImages[myIndex].createIfNecessary);
+                myEjected = !result;
+                ra2::log_cb(RETRO_LOG_INFO, "Insert new disk: %s -> %d\n", myImages[myIndex].path.c_str(), result);
+            }
+        }
 
-  bool DiskControl::setEjectedState(bool ejected)
-  {
-    if (myEjected == ejected)
-    {
-      return true;
+        return result;
     }
 
-    CardManager & cardManager = GetCardMgr();
-    Disk2InterfaceCard * disk2Card = dynamic_cast<Disk2InterfaceCard*>(cardManager.GetObj(SLOT6));
-
-    bool result = false;
-    if (disk2Card && myIndex < myImages.size())
+    size_t DiskControl::getImageIndex() const
     {
-      if (ejected)
-      {
-        disk2Card->EjectDisk(DRIVE_1);
-        result = true;
-        myEjected = ejected;
-      }
-      else
-      {
-        // inserted
-        result = insertFloppyDisk(myImages[myIndex].path, myImages[myIndex].writeProtected, myImages[myIndex].createIfNecessary);
-        myEjected = !result;
-        ra2::log_cb(RETRO_LOG_INFO, "Insert new disk: %s -> %d\n", myImages[myIndex].path.c_str(), result);
-      }
+        return myIndex;
     }
 
-    return result;
-  }
-
-  size_t DiskControl::getImageIndex() const
-  {
-    return myIndex;
-  }
-
-  bool DiskControl::setImageIndex(size_t index)
-  {
-    if (myEjected)
+    bool DiskControl::setImageIndex(size_t index)
     {
-      myIndex = index;
-      return true;
+        if (myEjected)
+        {
+            myIndex = index;
+            return true;
+        }
+        else
+        {
+            return false;
+        }
     }
-    else
+
+    size_t DiskControl::getNumImages() const
     {
-      return false;
+        return myImages.size();
     }
-  }
-
-  size_t DiskControl::getNumImages() const
-  {
-    return myImages.size();
-  }
 
-  bool DiskControl::replaceImageIndex(size_t index, const std::string & path)
-  {
-    if (myEjected && myIndex < myImages.size())
+    bool DiskControl::replaceImageIndex(size_t index, const std::string &path)
     {
-      const std::filesystem::path filePath(path);
+        if (myEjected && myIndex < myImages.size())
+        {
+            const std::filesystem::path filePath(path);
 
-      myImages[index].path = filePath.string();
-      myImages[index].label = filePath.stem().string();
-      myImages[index].writeProtected = IMAGE_FORCE_WRITE_PROTECTED;
-      myImages[index].createIfNecessary = IMAGE_DONT_CREATE;
-      return true;
-    }
-    else
-    {
-      return false;
+            myImages[index].path = filePath.string();
+            myImages[index].label = filePath.stem().string();
+            myImages[index].writeProtected = IMAGE_FORCE_WRITE_PROTECTED;
+            myImages[index].createIfNecessary = IMAGE_DONT_CREATE;
+            return true;
+        }
+        else
+        {
+            return false;
+        }
     }
-  }
 
-  bool DiskControl::removeImageIndex(size_t index)
-  {
-    if (myEjected && myIndex < myImages.size())
+    bool DiskControl::removeImageIndex(size_t index)
     {
-      myImages.erase(myImages.begin() + index);
-      if (myImages.empty() || myIndex == index)
-      {
-        myIndex = myImages.size();
-      }
-      else if (myIndex > index)
-      {
-        --myIndex;
-      }
-      return true;
-    }
-    else
-    {
-      return false;
+        if (myEjected && myIndex < myImages.size())
+        {
+            myImages.erase(myImages.begin() + index);
+            if (myImages.empty() || myIndex == index)
+            {
+                myIndex = myImages.size();
+            }
+            else if (myIndex > index)
+            {
+                --myIndex;
+            }
+            return true;
+        }
+        else
+        {
+            return false;
+        }
     }
-  }
-
-  bool DiskControl::addImageIndex()
-  {
-    myImages.push_back({"", "", IMAGE_FORCE_WRITE_PROTECTED, IMAGE_DONT_CREATE});
-    return true;
-  }
 
-  bool DiskControl::getImagePath(unsigned index, char *path, size_t len) const
-  {
-    if (index < myImages.size())
-    {
-      strncpy(path, myImages[index].path.c_str(), len);
-      path[len - 1] = 0;
-      return true;
-    }
-    else
+    bool DiskControl::addImageIndex()
     {
-      return false;
+        myImages.push_back({"", "", IMAGE_FORCE_WRITE_PROTECTED, IMAGE_DONT_CREATE});
+        return true;
     }
-  }
 
-  bool DiskControl::getImageLabel(unsigned index, char *label, size_t len) const
-  {
-    if (index < myImages.size())
+    bool DiskControl::getImagePath(unsigned index, char *path, size_t len) const
     {
-      strncpy(label, myImages[index].label.c_str(), len);
-      label[len - 1] = 0;
-      return true;
+        if (index < myImages.size())
+        {
+            strncpy(path, myImages[index].path.c_str(), len);
+            path[len - 1] = 0;
+            return true;
+        }
+        else
+        {
+            return false;
+        }
     }
-    else
+
+    bool DiskControl::getImageLabel(unsigned index, char *label, size_t len) const
     {
-      return false;
+        if (index < myImages.size())
+        {
+            strncpy(label, myImages[index].label.c_str(), len);
+            label[len - 1] = 0;
+            return true;
+        }
+        else
+        {
+            return false;
+        }
     }
-  }
-
-  void DiskControl::serialise(Buffer<char> & buffer) const
-  {
-    writeString(buffer, myCurrentDiskFolder);
-    buffer.get<bool>() = myEjected;
-    buffer.get<size_t>() = myIndex;
-    buffer.get<size_t>() = myImages.size();
 
-    for (DiskInfo const & image : myImages)
+    void DiskControl::serialise(Buffer<char> &buffer) const
     {
-      writeString(buffer, image.path);
-      writeString(buffer, image.label);
-      buffer.get<bool>() = image.writeProtected;
-      buffer.get<bool>() = image.createIfNecessary;
+        writeString(buffer, myCurrentDiskFolder);
+        buffer.get<bool>() = myEjected;
+        buffer.get<size_t>() = myIndex;
+        buffer.get<size_t>() = myImages.size();
+
+        for (DiskInfo const &image : myImages)
+        {
+            writeString(buffer, image.path);
+            writeString(buffer, image.label);
+            buffer.get<bool>() = image.writeProtected;
+            buffer.get<bool>() = image.createIfNecessary;
+        }
     }
-  }
-
-  void DiskControl::deserialise(Buffer<char const> & buffer)
-  {
-    readString(buffer, myCurrentDiskFolder);
-    myEjected = buffer.get<bool const>();
-    myIndex = buffer.get<size_t const>();
-    size_t const numberOfImages = buffer.get<size_t const>();
-    myImages.clear();
-    myImages.resize(numberOfImages);
-
-    for (DiskInfo & image : myImages)
+
+    void DiskControl::deserialise(Buffer<char const> &buffer)
     {
-      readString(buffer, image.path);
-      readString(buffer, image.label);
-      image.writeProtected = buffer.get<const bool>();
-      image.createIfNecessary = buffer.get<const bool>();
+        readString(buffer, myCurrentDiskFolder);
+        myEjected = buffer.get<bool const>();
+        myIndex = buffer.get<size_t const>();
+        size_t const numberOfImages = buffer.get<size_t const>();
+        myImages.clear();
+        myImages.resize(numberOfImages);
+
+        for (DiskInfo &image : myImages)
+        {
+            readString(buffer, image.path);
+            readString(buffer, image.label);
+            image.writeProtected = buffer.get<const bool>();
+            image.createIfNecessary = buffer.get<const bool>();
+        }
     }
-  }
 
-  unsigned DiskControl::ourInitialIndex = 0;
-  std::string DiskControl::ourInitialPath;
+    unsigned DiskControl::ourInitialIndex = 0;
+    std::string DiskControl::ourInitialPath;
 
-  void DiskControl::setInitialPath(unsigned index, const char *path)
-  {
-    if (path && *path)
+    void DiskControl::setInitialPath(unsigned index, const char *path)
     {
-      ourInitialIndex = index;
-      ourInitialPath = path;
+        if (path && *path)
+        {
+            ourInitialIndex = index;
+            ourInitialPath = path;
+        }
     }
-  }
 
-}
+} // namespace ra2
diff --git a/source/frontends/libretro/diskcontrol.h b/source/frontends/libretro/diskcontrol.h
index ee1ea90ae..915510d51 100644
--- a/source/frontends/libretro/diskcontrol.h
+++ b/source/frontends/libretro/diskcontrol.h
@@ -10,60 +10,64 @@
 namespace ra2
 {
 
-  enum class PlaylistStartDisk { First, Previous };
+    enum class PlaylistStartDisk
+    {
+        First,
+        Previous
+    };
 
-  struct DiskInfo
-  {
-    std::string path;
-    std::string label;
-    bool writeProtected = IMAGE_FORCE_WRITE_PROTECTED;
-    bool createIfNecessary = IMAGE_DONT_CREATE;
-  };
+    struct DiskInfo
+    {
+        std::string path;
+        std::string label;
+        bool writeProtected = IMAGE_FORCE_WRITE_PROTECTED;
+        bool createIfNecessary = IMAGE_DONT_CREATE;
+    };
 
-  class DiskControl
-  {
-  public:
-    DiskControl();
+    class DiskControl
+    {
+    public:
+        DiskControl();
 
-    const std::string & getCurrentDiskFolder() const;
-    bool getEjectedState() const;
-    bool setEjectedState(bool state);
+        const std::string &getCurrentDiskFolder() const;
+        bool getEjectedState() const;
+        bool setEjectedState(bool state);
 
-    size_t getImageIndex() const;
-    bool setImageIndex(size_t index);
+        size_t getImageIndex() const;
+        bool setImageIndex(size_t index);
 
-    size_t getNumImages() const;
+        size_t getNumImages() const;
 
-    bool replaceImageIndex(size_t index, const std::string & path);
-    bool removeImageIndex(size_t index);
-    bool addImageIndex();
+        bool replaceImageIndex(size_t index, const std::string &path);
+        bool removeImageIndex(size_t index);
+        bool addImageIndex();
 
-    // these 2 functions update the images for the Disc Control Interface
-    bool insertDisk(const std::string & path);
-    bool insertPlaylist(const std::string & path);
+        // these 2 functions update the images for the Disc Control Interface
+        bool insertDisk(const std::string &path);
+        bool insertPlaylist(const std::string &path);
 
-    bool getImagePath(unsigned index, char *path, size_t len) const;
-    bool getImageLabel(unsigned index, char *label, size_t len) const;
+        bool getImagePath(unsigned index, char *path, size_t len) const;
+        bool getImageLabel(unsigned index, char *label, size_t len) const;
 
-    static void setInitialPath(unsigned index, const char *path);
+        static void setInitialPath(unsigned index, const char *path);
 
-    void serialise(Buffer<char> & buffer) const;
-    void deserialise(Buffer<char const> & buffer);
+        void serialise(Buffer<char> &buffer) const;
+        void deserialise(Buffer<char const> &buffer);
 
-  private:
-    std::vector<DiskInfo> myImages;
+    private:
+        std::vector<DiskInfo> myImages;
 
-    bool myEjected;
-    size_t myIndex;
-    std::string myCurrentDiskFolder;
+        bool myEjected;
+        size_t myIndex;
+        std::string myCurrentDiskFolder;
 
-    bool insertFloppyDisk(const std::string & path, const bool writeProtected, bool const createIfNecessary);
-    bool insertHardDisk(const std::string & path);
-    void storeCurrentDiskFolder(const std::string & path);
+        bool insertFloppyDisk(const std::string &path, const bool writeProtected, bool const createIfNecessary);
+        bool insertHardDisk(const std::string &path);
+        void storeCurrentDiskFolder(const std::string &path);
 
-    // these are here because they are set before we have create a game context
-    static unsigned ourInitialIndex;
-    static std::string ourInitialPath;
-  };
+        // these are here because they are set before we have create a game context
+        static unsigned ourInitialIndex;
+        static std::string ourInitialPath;
+    };
 
-}
+} // namespace ra2
diff --git a/source/frontends/libretro/environment.cpp b/source/frontends/libretro/environment.cpp
index 49e13a96b..7889079f3 100644
--- a/source/frontends/libretro/environment.cpp
+++ b/source/frontends/libretro/environment.cpp
@@ -6,33 +6,33 @@
 namespace ra2
 {
 
-  std::string save_directory;
+    std::string save_directory;
 
-  void fallback_log(enum retro_log_level level, const char *fmt, ...)
-  {
-    // TODO: this should be a no-op
-    (void)level;
-    va_list va;
-    va_start(va, fmt);
-    vfprintf(stderr, fmt, va);
-    va_end(va);
-  }
+    void fallback_log(enum retro_log_level level, const char *fmt, ...)
+    {
+        // TODO: this should be a no-op
+        (void)level;
+        va_list va;
+        va_start(va, fmt);
+        vfprintf(stderr, fmt, va);
+        va_end(va);
+    }
 
-  retro_log_callback logging;
-  retro_log_printf_t log_cb = fallback_log;
-  retro_input_poll_t input_poll_cb;
-  retro_input_state_t input_state_cb;
+    retro_log_callback logging;
+    retro_log_printf_t log_cb = fallback_log;
+    retro_input_poll_t input_poll_cb;
+    retro_input_state_t input_state_cb;
 
-  retro_environment_t environ_cb;
-  retro_video_refresh_t video_cb;
-  retro_audio_sample_t audio_cb;
-  retro_audio_sample_batch_t audio_batch_cb;
+    retro_environment_t environ_cb;
+    retro_video_refresh_t video_cb;
+    retro_audio_sample_t audio_cb;
+    retro_audio_sample_batch_t audio_batch_cb;
 
-  void display_message(const std::string & message, int durationFrames)
-  {
-    retro_message rmsg;
-    rmsg.frames = durationFrames;
-    rmsg.msg = message.c_str();
-    environ_cb(RETRO_ENVIRONMENT_SET_MESSAGE, &rmsg);
-  }
-}
+    void display_message(const std::string &message, int durationFrames)
+    {
+        retro_message rmsg;
+        rmsg.frames = durationFrames;
+        rmsg.msg = message.c_str();
+        environ_cb(RETRO_ENVIRONMENT_SET_MESSAGE, &rmsg);
+    }
+} // namespace ra2
diff --git a/source/frontends/libretro/environment.h b/source/frontends/libretro/environment.h
index 11ae4bffb..eb67885ea 100644
--- a/source/frontends/libretro/environment.h
+++ b/source/frontends/libretro/environment.h
@@ -6,20 +6,20 @@
 namespace ra2
 {
 
-  void fallback_log(enum retro_log_level level, const char *fmt, ...) __attribute__ ((format (printf, 2, 3)));
-  extern retro_log_callback logging;
-  extern retro_log_printf_t log_cb __attribute__((format(printf, 2, 3)));
-  extern retro_input_poll_t input_poll_cb;
-  extern retro_input_state_t input_state_cb;
-  extern retro_environment_t environ_cb;
-  extern retro_video_refresh_t video_cb;
-  extern retro_audio_sample_t audio_cb;
-  extern retro_audio_sample_batch_t audio_batch_cb;
+    void fallback_log(enum retro_log_level level, const char *fmt, ...) __attribute__((format(printf, 2, 3)));
+    extern retro_log_callback logging;
+    extern retro_log_printf_t log_cb __attribute__((format(printf, 2, 3)));
+    extern retro_input_poll_t input_poll_cb;
+    extern retro_input_state_t input_state_cb;
+    extern retro_environment_t environ_cb;
+    extern retro_video_refresh_t video_cb;
+    extern retro_audio_sample_t audio_cb;
+    extern retro_audio_sample_batch_t audio_batch_cb;
 
-  extern std::string save_directory;
+    extern std::string save_directory;
 
 #define MAX_PADS 1
 
-  void display_message(const std::string & message, int durationFrames = 180);
+    void display_message(const std::string &message, int durationFrames = 180);
 
-}
+} // namespace ra2
diff --git a/source/frontends/libretro/game.cpp b/source/frontends/libretro/game.cpp
index da7ac093b..d0fdaed48 100644
--- a/source/frontends/libretro/game.cpp
+++ b/source/frontends/libretro/game.cpp
@@ -22,367 +22,366 @@
 namespace
 {
 
-  void saveRegistryToINI(const std::shared_ptr<common2::PTreeRegistry> & registry)
-  {
-    try
+    void saveRegistryToINI(const std::shared_ptr<common2::PTreeRegistry> &registry)
     {
-      registry->saveToINIFile(APPLEWIN_RETRO_CONF);
-      ra2::display_message("Configuration saved to: " APPLEWIN_RETRO_CONF);
-    }
-    catch (const std::exception & e)
-    {
-      ra2::display_message(std::string("Error saving configuration: ") + e.what());
+        try
+        {
+            registry->saveToINIFile(APPLEWIN_RETRO_CONF);
+            ra2::display_message("Configuration saved to: " APPLEWIN_RETRO_CONF);
+        }
+        catch (const std::exception &e)
+        {
+            ra2::display_message(std::string("Error saving configuration: ") + e.what());
+        }
     }
-  }
 
-}
+} // namespace
 
 namespace ra2
 {
 
-  unsigned Game::ourInputDevices[MAX_PADS] = {RETRO_DEVICE_NONE};
-
-  Game::Game(const bool supportsInputBitmasks)
-    : mySupportsInputBitmasks(supportsInputBitmasks)
-    , myButtonStates(0)
-    , myAudioSource(AudioSource::UNKNOWN)
-    , myKeyboardType(KeyboardType::ASCII)
-  {
-    myLoggerContext = std::make_shared<LoggerContext>(true);
-    myRegistry = CreateRetroRegistry();
-    myRegistryContext = std::make_shared<RegistryContext>(myRegistry);
-
-    common2::EmulatorOptions defaultOptions;
-    defaultOptions.fixedSpeed = true;
-    myFrame = std::make_shared<ra2::RetroFrame>(defaultOptions);
-
-    refreshVariables();
-
-    SetFrame(myFrame);
-    myFrame->Begin();
-
-    Video & video = GetVideo();
-    // should the user be allowed to tweak 0.75
-    myMouse[0] = {0.0, 0.75 / video.GetFrameBufferBorderlessWidth(), RETRO_DEVICE_ID_MOUSE_X};
-    myMouse[1] = {0.0, 0.75 / video.GetFrameBufferBorderlessHeight(), RETRO_DEVICE_ID_MOUSE_Y};
-  }
-
-  Game::~Game()
-  {
-    myFrame->End();
-    myFrame.reset();
-    SetFrame(myFrame);
-  }
-
-  void Game::executeOneFrame()
-  {
-    myFrame->ExecuteOneFrame(ourFrameTime);
-  }
-
-  void Game::refreshVariables()
-  {
-    myAudioSource = GetAudioSource();
-    myKeyboardType = GetKeyboardEmulationType();
-  }
-
-  void Game::updateVariables()
-  {
-    bool updated = false;
-    if (ra2::environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE, &updated) && updated)
-    {
-      PopulateRegistry(myRegistry);
+    unsigned Game::ourInputDevices[MAX_PADS] = {RETRO_DEVICE_NONE};
 
-      // some variables are immediately applied
-      refreshVariables();
+    Game::Game(const bool supportsInputBitmasks)
+        : mySupportsInputBitmasks(supportsInputBitmasks)
+        , myButtonStates(0)
+        , myAudioSource(AudioSource::UNKNOWN)
+        , myKeyboardType(KeyboardType::ASCII)
+    {
+        myLoggerContext = std::make_shared<LoggerContext>(true);
+        myRegistry = CreateRetroRegistry();
+        myRegistryContext = std::make_shared<RegistryContext>(myRegistry);
 
-      Video& video = GetVideo();
-      const VideoType_e prevVideoType = video.GetVideoType();
-      const VideoStyle_e prevVideoStyle = video.GetVideoStyle();
+        common2::EmulatorOptions defaultOptions;
+        defaultOptions.fixedSpeed = true;
+        myFrame = std::make_shared<ra2::RetroFrame>(defaultOptions);
 
-      uint32_t dwTmp = prevVideoType;
-      RegLoadValue(REG_CONFIG, REGVALUE_VIDEO_MODE, TRUE, &dwTmp);
-      const VideoType_e newVideoType = static_cast<VideoType_e>(dwTmp);
+        refreshVariables();
 
-      dwTmp = prevVideoStyle;
-      RegLoadValue(REG_CONFIG, REGVALUE_VIDEO_STYLE, TRUE, &dwTmp);
-      const VideoStyle_e newVideoStyle = static_cast<VideoStyle_e>(dwTmp);
+        SetFrame(myFrame);
+        myFrame->Begin();
 
-      if ((prevVideoType != newVideoType) || (prevVideoStyle != newVideoStyle))
-      {
-        video.SetVideoStyle(newVideoStyle);
-        video.SetVideoType(newVideoType);
-        myFrame->ApplyVideoModeChange();
-      }
+        Video &video = GetVideo();
+        // should the user be allowed to tweak 0.75
+        myMouse[0] = {0.0, 0.75 / video.GetFrameBufferBorderlessWidth(), RETRO_DEVICE_ID_MOUSE_X};
+        myMouse[1] = {0.0, 0.75 / video.GetFrameBufferBorderlessHeight(), RETRO_DEVICE_ID_MOUSE_Y};
     }
-  }
-
-  void Game::processInputEvents()
-  {
-    input_poll_cb();
-    keyboardEmulation();
-    mouseEmulation();
-  }
-
-  void Game::keyboardCallback(bool down, unsigned keycode, uint32_t character, uint16_t key_modifiers)
-  {
-    if (down)
+
+    Game::~Game()
     {
-      processKeyDown(keycode, character, key_modifiers);
+        myFrame->End();
+        myFrame.reset();
+        SetFrame(myFrame);
     }
-    else
+
+    void Game::executeOneFrame()
     {
-      processKeyUp(keycode, character, key_modifiers);
+        myFrame->ExecuteOneFrame(ourFrameTime);
     }
-  }
 
-  void Game::processKeyDown(unsigned keycode, uint32_t character, uint16_t key_modifiers)
-  {
-    BYTE ch = 0;
-    bool found = false; // it seems CTRL-2 produces NUL. is it a real key?
-    bool valid = true;
+    void Game::refreshVariables()
+    {
+        myAudioSource = GetAudioSource();
+        myKeyboardType = GetKeyboardEmulationType();
+    }
 
-    if (myKeyboardType == KeyboardType::ASCII)
+    void Game::updateVariables()
     {
-      // if we tried ASCII and the character is invalid, dont try again with scancode (e.g. £)
-      valid = character < 0x80;
-
-      // this block is to ensure the ascii character is used
-      // if selected and available
-      switch (character) {
-      case 0x20 ... 0x40:   // space ... @
-      case 0x5b ... 0x60:   // [ ... `
-      case 0x7b ... 0x7e:   // { ... ~
+        bool updated = false;
+        if (ra2::environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE, &updated) && updated)
         {
-          ch = character;
-          found = true;
-          break;
+            PopulateRegistry(myRegistry);
+
+            // some variables are immediately applied
+            refreshVariables();
+
+            Video &video = GetVideo();
+            const VideoType_e prevVideoType = video.GetVideoType();
+            const VideoStyle_e prevVideoStyle = video.GetVideoStyle();
+
+            uint32_t dwTmp = prevVideoType;
+            RegLoadValue(REG_CONFIG, REGVALUE_VIDEO_MODE, TRUE, &dwTmp);
+            const VideoType_e newVideoType = static_cast<VideoType_e>(dwTmp);
+
+            dwTmp = prevVideoStyle;
+            RegLoadValue(REG_CONFIG, REGVALUE_VIDEO_STYLE, TRUE, &dwTmp);
+            const VideoStyle_e newVideoStyle = static_cast<VideoStyle_e>(dwTmp);
+
+            if ((prevVideoType != newVideoType) || (prevVideoStyle != newVideoStyle))
+            {
+                video.SetVideoStyle(newVideoStyle);
+                video.SetVideoType(newVideoType);
+                myFrame->ApplyVideoModeChange();
+            }
         }
-      }
     }
 
-    if (!found && valid)
+    void Game::processInputEvents()
     {
-      // use scancodes, but dont overwrite invalid ASCII
-      found = getApple2Character(keycode, key_modifiers & RETROKMOD_CTRL, key_modifiers & RETROKMOD_SHIFT, ch);
+        input_poll_cb();
+        keyboardEmulation();
+        mouseEmulation();
     }
 
-    if (!found)
+    void Game::keyboardCallback(bool down, unsigned keycode, uint32_t character, uint16_t key_modifiers)
     {
-      // some special characters and letters
-      switch (keycode)
-      {
-      case RETROK_LEFT:
-        {
-          ch = 0x08;
-          break;
-        }
-      case RETROK_RIGHT:
-        {
-          ch = 0x15;
-          break;
-        }
-      case RETROK_UP:
+        if (down)
         {
-          ch = 0x0b;
-          break;
+            processKeyDown(keycode, character, key_modifiers);
         }
-      case RETROK_DOWN:
+        else
         {
-          ch = 0x0a;
-          break;
+            processKeyUp(keycode, character, key_modifiers);
         }
-      case RETROK_LALT:
+    }
+
+    void Game::processKeyDown(unsigned keycode, uint32_t character, uint16_t key_modifiers)
+    {
+        BYTE ch = 0;
+        bool found = false; // it seems CTRL-2 produces NUL. is it a real key?
+        bool valid = true;
+
+        if (myKeyboardType == KeyboardType::ASCII)
         {
-          Paddle::setButtonPressed(Paddle::ourOpenApple);
-          break;
+            // if we tried ASCII and the character is invalid, dont try again with scancode (e.g. £)
+            valid = character < 0x80;
+
+            // this block is to ensure the ascii character is used
+            // if selected and available
+            switch (character)
+            {
+            case 0x20 ... 0x40: // space ... @
+            case 0x5b ... 0x60: // [ ... `
+            case 0x7b ... 0x7e: // { ... ~
+            {
+                ch = character;
+                found = true;
+                break;
+            }
+            }
         }
-      case RETROK_RALT:
+
+        if (!found && valid)
         {
-          Paddle::setButtonPressed(Paddle::ourSolidApple);
-          break;
+            // use scancodes, but dont overwrite invalid ASCII
+            found = getApple2Character(keycode, key_modifiers & RETROKMOD_CTRL, key_modifiers & RETROKMOD_SHIFT, ch);
         }
-      case RETROK_a ... RETROK_z:
+
+        if (!found)
         {
-          ch = (keycode - RETROK_a) + 0x01;
-          if (key_modifiers & RETROKMOD_CTRL)
-          {
-            // ok
-          }
-          else if (key_modifiers & RETROKMOD_SHIFT)
-          {
-            ch += 0x60;
-          }
-          else
-          {
-            ch += 0x40;
-          }
-          break;
+            // some special characters and letters
+            switch (keycode)
+            {
+            case RETROK_LEFT:
+            {
+                ch = 0x08;
+                break;
+            }
+            case RETROK_RIGHT:
+            {
+                ch = 0x15;
+                break;
+            }
+            case RETROK_UP:
+            {
+                ch = 0x0b;
+                break;
+            }
+            case RETROK_DOWN:
+            {
+                ch = 0x0a;
+                break;
+            }
+            case RETROK_LALT:
+            {
+                Paddle::setButtonPressed(Paddle::ourOpenApple);
+                break;
+            }
+            case RETROK_RALT:
+            {
+                Paddle::setButtonPressed(Paddle::ourSolidApple);
+                break;
+            }
+            case RETROK_a ... RETROK_z:
+            {
+                ch = (keycode - RETROK_a) + 0x01;
+                if (key_modifiers & RETROKMOD_CTRL)
+                {
+                    // ok
+                }
+                else if (key_modifiers & RETROKMOD_SHIFT)
+                {
+                    ch += 0x60;
+                }
+                else
+                {
+                    ch += 0x40;
+                }
+                break;
+            }
+            }
+            found = !!ch;
         }
-      }
-      found = !!ch;
-    }
-
-    // log_cb(RETRO_LOG_INFO, "RA2: %s - char=%02x keycode=%04x modifiers=%02x ch=%02x\n", __FUNCTION__, character, keycode, key_modifiers, ch);
-
-    if (found)
-    {
-      addKeyToBuffer(ch);
-    }
-  }
 
-  void Game::processKeyUp(unsigned keycode, uint32_t character, uint16_t key_modifiers)
-  {
-    switch (keycode)
-    {
-    case RETROK_LALT:
-      {
-        Paddle::setButtonReleased(Paddle::ourOpenApple);
-        break;
-      }
-    case RETROK_RALT:
-      {
-        Paddle::setButtonReleased(Paddle::ourSolidApple);
-        break;
-      }
-    }
-  }
+        // log_cb(RETRO_LOG_INFO, "RA2: %s - char=%02x keycode=%04x modifiers=%02x ch=%02x\n", __FUNCTION__, character,
+        // keycode, key_modifiers, ch);
 
-  size_t Game::updateButtonStates()
-  {
-    size_t newState;
-    if (mySupportsInputBitmasks)
-    {
-      newState = input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_MASK);
-    }
-    else
-    {
-      newState = 0;
-      for (size_t i = 0; i < RETRO_DEVICE_ID_JOYPAD_R3 + 1; i++)
-      {
-        if (input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, i))
+        if (found)
         {
-          newState |= 1 << i;
+            addKeyToBuffer(ch);
         }
-      }
     }
-    // if it is active NOW and was NOT before.
-    const size_t result = (~myButtonStates) & newState;
-
-    myButtonStates = newState;
-    return result;
-  }
 
-  void Game::keyboardEmulation()
-  {
-    if (ourInputDevices[0] != RETRO_DEVICE_NONE)
+    void Game::processKeyUp(unsigned keycode, uint32_t character, uint16_t key_modifiers)
     {
-      const size_t activeButtons = updateButtonStates();
-
-      const auto checkButton = [activeButtons] (const size_t i)
-      {
-        return activeButtons & (1 << i);
-      };
-
-      if (checkButton(RETRO_DEVICE_ID_JOYPAD_R))
-      {
-        myFrame->CycleVideoType();
-      }
-      if (checkButton(RETRO_DEVICE_ID_JOYPAD_L))
-      {
-        myFrame->Cycle50ScanLines();
-      }
-      if (checkButton(RETRO_DEVICE_ID_JOYPAD_L2))
-      {
-        saveRegistryToINI(myRegistry);
-      }
-      if (checkButton(RETRO_DEVICE_ID_JOYPAD_R2))
-      {
-        switch (myAudioSource)
+        switch (keycode)
         {
-        case AudioSource::SPEAKER:
+        case RETROK_LALT:
         {
-          myAudioSource = AudioSource::MOCKINGBOARD;
-          display_message(std::string("Audio source: ") + REGVALUE_AUDIO_MOCKINGBOARD);
-          break;
+            Paddle::setButtonReleased(Paddle::ourOpenApple);
+            break;
         }
-        case AudioSource::MOCKINGBOARD:
+        case RETROK_RALT:
         {
-          myAudioSource = AudioSource::SPEAKER;
-          display_message(std::string("Audio source: ") + REGVALUE_AUDIO_SPEAKER);
-          break;
+            Paddle::setButtonReleased(Paddle::ourSolidApple);
+            break;
         }
         }
-      }
-      if (checkButton(RETRO_DEVICE_ID_JOYPAD_START))
-      {
-        // reset emulator by pressing "start" twice
-        if (myControllerReset.pressButton())
+    }
+
+    size_t Game::updateButtonStates()
+    {
+        size_t newState;
+        if (mySupportsInputBitmasks)
         {
-          reset(); // just a myFrame->Restart();
+            newState = input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_MASK);
         }
         else
         {
-          display_message("Press again to reset...", 60 /* 1.0s at 60 FPS */);
+            newState = 0;
+            for (size_t i = 0; i < RETRO_DEVICE_ID_JOYPAD_R3 + 1; i++)
+            {
+                if (input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, i))
+                {
+                    newState |= 1 << i;
+                }
+            }
         }
-      }
-      if (checkButton(RETRO_DEVICE_ID_JOYPAD_SELECT))
-      {
-        // added as convenience if game_focus is on:
-        // exit emulator by pressing "select" twice
-        if (myControllerQuit.pressButton())
+        // if it is active NOW and was NOT before.
+        const size_t result = (~myButtonStates) & newState;
+
+        myButtonStates = newState;
+        return result;
+    }
+
+    void Game::keyboardEmulation()
+    {
+        if (ourInputDevices[0] != RETRO_DEVICE_NONE)
         {
-          log_cb(RETRO_LOG_INFO, "RA2: %s - user quitted\n", __FUNCTION__);
-          environ_cb(RETRO_ENVIRONMENT_SHUTDOWN, NULL);
+            const size_t activeButtons = updateButtonStates();
+
+            const auto checkButton = [activeButtons](const size_t i) { return activeButtons & (1 << i); };
+
+            if (checkButton(RETRO_DEVICE_ID_JOYPAD_R))
+            {
+                myFrame->CycleVideoType();
+            }
+            if (checkButton(RETRO_DEVICE_ID_JOYPAD_L))
+            {
+                myFrame->Cycle50ScanLines();
+            }
+            if (checkButton(RETRO_DEVICE_ID_JOYPAD_L2))
+            {
+                saveRegistryToINI(myRegistry);
+            }
+            if (checkButton(RETRO_DEVICE_ID_JOYPAD_R2))
+            {
+                switch (myAudioSource)
+                {
+                case AudioSource::SPEAKER:
+                {
+                    myAudioSource = AudioSource::MOCKINGBOARD;
+                    display_message(std::string("Audio source: ") + REGVALUE_AUDIO_MOCKINGBOARD);
+                    break;
+                }
+                case AudioSource::MOCKINGBOARD:
+                {
+                    myAudioSource = AudioSource::SPEAKER;
+                    display_message(std::string("Audio source: ") + REGVALUE_AUDIO_SPEAKER);
+                    break;
+                }
+                }
+            }
+            if (checkButton(RETRO_DEVICE_ID_JOYPAD_START))
+            {
+                // reset emulator by pressing "start" twice
+                if (myControllerReset.pressButton())
+                {
+                    reset(); // just a myFrame->Restart();
+                }
+                else
+                {
+                    display_message("Press again to reset...", 60 /* 1.0s at 60 FPS */);
+                }
+            }
+            if (checkButton(RETRO_DEVICE_ID_JOYPAD_SELECT))
+            {
+                // added as convenience if game_focus is on:
+                // exit emulator by pressing "select" twice
+                if (myControllerQuit.pressButton())
+                {
+                    log_cb(RETRO_LOG_INFO, "RA2: %s - user quitted\n", __FUNCTION__);
+                    environ_cb(RETRO_ENVIRONMENT_SHUTDOWN, NULL);
+                }
+                else
+                {
+                    display_message("Press again to quit...", 60 /* 1.0s at 60 FPS */);
+                }
+            }
         }
         else
         {
-          display_message("Press again to quit...", 60 /* 1.0s at 60 FPS */);
+            myButtonStates = 0;
         }
-      }
     }
-    else
+
+    void Game::mouseEmulation()
     {
-      myButtonStates = 0;
+        // we should use an InputDescriptor, but these are all on RETRO_DEVICE_MOUSE anyway
+        for (auto &mouse : myMouse)
+        {
+            const int16_t x = input_state_cb(0, RETRO_DEVICE_MOUSE, 0, mouse.id);
+            mouse.position += x * mouse.multiplier;
+            mouse.position = std::min(1.0, std::max(mouse.position, -1.0));
+        }
+    }
+
+    double Game::getMousePosition(int i) const
+    {
+        return myMouse[i].position;
+    }
+
+    bool Game::loadSnapshot(const std::string &path)
+    {
+        const common2::RestoreCurrentDirectory restoreChDir;
+        common2::setSnapshotFilename(path);
+        myFrame->LoadSnapshot();
+        return true;
     }
-  }
 
-  void Game::mouseEmulation()
-  {
-    // we should use an InputDescriptor, but these are all on RETRO_DEVICE_MOUSE anyway
-    for (auto & mouse : myMouse)
+    DiskControl &Game::getDiskControl()
     {
-      const int16_t x = input_state_cb(0, RETRO_DEVICE_MOUSE, 0, mouse.id);
-      mouse.position += x * mouse.multiplier;
-      mouse.position = std::min(1.0, std::max(mouse.position, -1.0));
+        return myDiskControl;
     }
-  }
-
-  double Game::getMousePosition(int i) const
-  {
-    return myMouse[i].position;
-  }
-
-  bool Game::loadSnapshot(const std::string & path)
-  {
-    const common2::RestoreCurrentDirectory restoreChDir;
-    common2::setSnapshotFilename(path);
-    myFrame->LoadSnapshot();
-    return true;
-  }
-
-  DiskControl & Game::getDiskControl()
-  {
-    return myDiskControl;
-  }
-
-  void Game::reset()
-  {
-    myFrame->Restart();
-  }
-
-  void Game::writeAudio(const size_t fps)
-  {
-    ra2::writeAudio(myAudioSource, fps);
-  }
-
-}
+
+    void Game::reset()
+    {
+        myFrame->Restart();
+    }
+
+    void Game::writeAudio(const size_t fps)
+    {
+        ra2::writeAudio(myAudioSource, fps);
+    }
+
+} // namespace ra2
diff --git a/source/frontends/libretro/game.h b/source/frontends/libretro/game.h
index e0703407f..a1977fa55 100644
--- a/source/frontends/libretro/game.h
+++ b/source/frontends/libretro/game.h
@@ -16,74 +16,74 @@ class RegistryContext;
 
 namespace common2
 {
-  class PTreeRegistry;
+    class PTreeRegistry;
 }
 
 namespace ra2
 {
 
-  class RetroFrame;
+    class RetroFrame;
 
-  class Game
-  {
-  public:
-    Game(const bool supportsInputBitmasks);
-    ~Game();
+    class Game
+    {
+    public:
+        Game(const bool supportsInputBitmasks);
+        ~Game();
 
-    bool loadSnapshot(const std::string & path);
+        bool loadSnapshot(const std::string &path);
 
-    void reset();
+        void reset();
 
-    void updateVariables();
-    void executeOneFrame();
-    void processInputEvents();
-    void writeAudio(const size_t fps);
+        void updateVariables();
+        void executeOneFrame();
+        void processInputEvents();
+        void writeAudio(const size_t fps);
 
-    void drawVideoBuffer();
+        void drawVideoBuffer();
 
-    double getMousePosition(int i) const;
+        double getMousePosition(int i) const;
 
-    DiskControl & getDiskControl();
+        DiskControl &getDiskControl();
 
-    void keyboardCallback(bool down, unsigned keycode, uint32_t character, uint16_t key_modifiers);
+        void keyboardCallback(bool down, unsigned keycode, uint32_t character, uint16_t key_modifiers);
 
-    static constexpr size_t FPS = 60;
-    static unsigned ourInputDevices[MAX_PADS];
-    static constexpr retro_usec_t ourFrameTime = 1000000 / FPS;
+        static constexpr size_t FPS = 60;
+        static unsigned ourInputDevices[MAX_PADS];
+        static constexpr retro_usec_t ourFrameTime = 1000000 / FPS;
 
-  private:
-    const bool mySupportsInputBitmasks;
-    size_t myButtonStates;
-    AudioSource myAudioSource;
-    KeyboardType myKeyboardType;
+    private:
+        const bool mySupportsInputBitmasks;
+        size_t myButtonStates;
+        AudioSource myAudioSource;
+        KeyboardType myKeyboardType;
 
-    // keep them in this order!
-    std::shared_ptr<LoggerContext> myLoggerContext;
-    std::shared_ptr<common2::PTreeRegistry> myRegistry;
-    std::shared_ptr<RegistryContext> myRegistryContext;
-    std::shared_ptr<RetroFrame> myFrame;
+        // keep them in this order!
+        std::shared_ptr<LoggerContext> myLoggerContext;
+        std::shared_ptr<common2::PTreeRegistry> myRegistry;
+        std::shared_ptr<RegistryContext> myRegistryContext;
+        std::shared_ptr<RetroFrame> myFrame;
 
-    common2::ControllerDoublePress myControllerQuit;
-    common2::ControllerDoublePress myControllerReset;
+        common2::ControllerDoublePress myControllerQuit;
+        common2::ControllerDoublePress myControllerReset;
 
-    struct MousePosition_t
-    {
-      double position; // -1 to 1
-      double multiplier;
-      unsigned id;
-    };
+        struct MousePosition_t
+        {
+            double position; // -1 to 1
+            double multiplier;
+            unsigned id;
+        };
 
-    MousePosition_t myMouse[2];
+        MousePosition_t myMouse[2];
 
-    DiskControl myDiskControl;
+        DiskControl myDiskControl;
 
-    size_t updateButtonStates();
-    void keyboardEmulation();
-    void mouseEmulation();
-    void refreshVariables();
+        size_t updateButtonStates();
+        void keyboardEmulation();
+        void mouseEmulation();
+        void refreshVariables();
 
-    void processKeyDown(unsigned keycode, uint32_t character, uint16_t key_modifiers);
-    void processKeyUp(unsigned keycode, uint32_t character, uint16_t key_modifiers);
-  };
+        void processKeyDown(unsigned keycode, uint32_t character, uint16_t key_modifiers);
+        void processKeyUp(unsigned keycode, uint32_t character, uint16_t key_modifiers);
+    };
 
-}
+} // namespace ra2
diff --git a/source/frontends/libretro/joypad.cpp b/source/frontends/libretro/joypad.cpp
index 5afd6e27e..6296e048b 100644
--- a/source/frontends/libretro/joypad.cpp
+++ b/source/frontends/libretro/joypad.cpp
@@ -6,31 +6,31 @@
 namespace ra2
 {
 
-  Joypad::Joypad()
-    : myAxisCodes(2)
-  {
-    myAxisCodes[0] = {
-      {{RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT}, -1.0},
-      {{RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT}, 1.0},
-    };
-    myAxisCodes[1] = {
-      {{RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP}, -1.0},
-      {{RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN}, 1.0},
-    };
-  }
-
-  double Joypad::getAxis(int i) const
-  {
-    for (const auto & axis : myAxisCodes[i])
+    Joypad::Joypad()
+        : myAxisCodes(2)
     {
-      const int value = input_state_cb(0, axis.first.device, axis.first.index, axis.first.id);
-      if (value)
-      {
-        return axis.second;
-      }
+        myAxisCodes[0] = {
+            {{RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT}, -1.0},
+            {{RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT}, 1.0},
+        };
+        myAxisCodes[1] = {
+            {{RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP}, -1.0},
+            {{RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN}, 1.0},
+        };
     }
 
-    return 0.0;
-  }
+    double Joypad::getAxis(int i) const
+    {
+        for (const auto &axis : myAxisCodes[i])
+        {
+            const int value = input_state_cb(0, axis.first.device, axis.first.index, axis.first.id);
+            if (value)
+            {
+                return axis.second;
+            }
+        }
+
+        return 0.0;
+    }
 
-}
+} // namespace ra2
diff --git a/source/frontends/libretro/joypad.h b/source/frontends/libretro/joypad.h
index d42fec839..e09930f36 100644
--- a/source/frontends/libretro/joypad.h
+++ b/source/frontends/libretro/joypad.h
@@ -8,15 +8,15 @@
 namespace ra2
 {
 
-  class Joypad : public JoypadBase
-  {
-  public:
-    Joypad();
+    class Joypad : public JoypadBase
+    {
+    public:
+        Joypad();
 
-    double getAxis(int i) const override;
+        double getAxis(int i) const override;
 
-  private:
-    std::vector<std::vector<std::pair<InputDescriptor, double> > > myAxisCodes;
-  };
+    private:
+        std::vector<std::vector<std::pair<InputDescriptor, double>>> myAxisCodes;
+    };
 
-}
+} // namespace ra2
diff --git a/source/frontends/libretro/joypadbase.cpp b/source/frontends/libretro/joypadbase.cpp
index 4d1006aec..65eb1343c 100644
--- a/source/frontends/libretro/joypadbase.cpp
+++ b/source/frontends/libretro/joypadbase.cpp
@@ -8,24 +8,24 @@
 namespace ra2
 {
 
-  ControllerBase::ControllerBase(const std::vector<InputDescriptor> & buttonCodes)
-    : myButtonCodes(buttonCodes)
-  {
-  }
-
-  bool ControllerBase::getButton(int i) const
-  {
-    const auto & button = myButtonCodes[i];
-    const int value = input_state_cb(0, button.device, button.index, button.id);
-    return value != 0;
-  }
-
-  JoypadBase::JoypadBase() : ControllerBase({
-    {RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A},
-    {RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_B},
-    })
-  {
-
-  }
-
-}
+    ControllerBase::ControllerBase(const std::vector<InputDescriptor> &buttonCodes)
+        : myButtonCodes(buttonCodes)
+    {
+    }
+
+    bool ControllerBase::getButton(int i) const
+    {
+        const auto &button = myButtonCodes[i];
+        const int value = input_state_cb(0, button.device, button.index, button.id);
+        return value != 0;
+    }
+
+    JoypadBase::JoypadBase()
+        : ControllerBase({
+              {RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A},
+              {RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_B},
+          })
+    {
+    }
+
+} // namespace ra2
diff --git a/source/frontends/libretro/joypadbase.h b/source/frontends/libretro/joypadbase.h
index 87d6f890e..1d372d2f8 100644
--- a/source/frontends/libretro/joypadbase.h
+++ b/source/frontends/libretro/joypadbase.h
@@ -8,29 +8,28 @@
 namespace ra2
 {
 
-  struct InputDescriptor
-  {
-    unsigned device;
-    unsigned index;
-    unsigned id;
-  };
-
-  class ControllerBase : public Paddle
-  {
-  public:
-    ControllerBase(const std::vector<InputDescriptor> & buttonCodes);
-
-    bool getButton(int i) const override;
-
-  private:
-    const std::vector<InputDescriptor> myButtonCodes;
-  };
-
-  class JoypadBase : public ControllerBase
-  {
-  public:
-    JoypadBase();
-  };
-
-
-}
+    struct InputDescriptor
+    {
+        unsigned device;
+        unsigned index;
+        unsigned id;
+    };
+
+    class ControllerBase : public Paddle
+    {
+    public:
+        ControllerBase(const std::vector<InputDescriptor> &buttonCodes);
+
+        bool getButton(int i) const override;
+
+    private:
+        const std::vector<InputDescriptor> myButtonCodes;
+    };
+
+    class JoypadBase : public ControllerBase
+    {
+    public:
+        JoypadBase();
+    };
+
+} // namespace ra2
diff --git a/source/frontends/libretro/libretro-common/.clang-format b/source/frontends/libretro/libretro-common/.clang-format
new file mode 100644
index 000000000..e3845288a
--- /dev/null
+++ b/source/frontends/libretro/libretro-common/.clang-format
@@ -0,0 +1 @@
+DisableFormat: true
diff --git a/source/frontends/libretro/libretro.cpp b/source/frontends/libretro/libretro.cpp
index 61f62e1f6..1565a52ad 100644
--- a/source/frontends/libretro/libretro.cpp
+++ b/source/frontends/libretro/libretro.cpp
@@ -24,454 +24,443 @@
 namespace
 {
 
-  std::unique_ptr<ra2::Game> ourGame;
+    std::unique_ptr<ra2::Game> ourGame;
 
-  bool endsWith(const std::string & value, const std::string & ending)
-  {
-    if (ending.size() > value.size())
+    bool endsWith(const std::string &value, const std::string &ending)
     {
-      return false;
+        if (ending.size() > value.size())
+        {
+            return false;
+        }
+        return std::equal(ending.rbegin(), ending.rend(), value.rbegin());
     }
-    return std::equal(ending.rbegin(), ending.rend(), value.rbegin());
-  }
-
-  bool retro_set_eject_state(bool ejected)
-  {
-    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s (%d)\n", __FUNCTION__, ejected);
-    return ourGame->getDiskControl().setEjectedState(ejected);
-  }
-
-  bool retro_get_eject_state()
-  {
-    return ourGame->getDiskControl().getEjectedState();
-  }
-
-  unsigned retro_get_image_index()
-  {
-    return ourGame->getDiskControl().getImageIndex();
-  }
-
-  bool retro_set_image_index(unsigned index)
-  {
-    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s (%d)\n", __FUNCTION__, index);
-    return ourGame->getDiskControl().setImageIndex(index);
-  }
-
-  unsigned retro_get_num_images()
-  {
-    return ourGame->getDiskControl().getNumImages();
-  }
-
-  bool retro_replace_image_index(unsigned index, const struct retro_game_info *info)
-  {
-    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s (%s)\n", __FUNCTION__, info->path);
-    if (info->path)
+
+    bool retro_set_eject_state(bool ejected)
     {
-      return ourGame->getDiskControl().replaceImageIndex(index, info->path);
+        ra2::log_cb(RETRO_LOG_INFO, "RA2: %s (%d)\n", __FUNCTION__, ejected);
+        return ourGame->getDiskControl().setEjectedState(ejected);
     }
-    else
+
+    bool retro_get_eject_state()
     {
-      return ourGame->getDiskControl().removeImageIndex(index);
+        return ourGame->getDiskControl().getEjectedState();
     }
-  }
 
-  bool retro_add_image_index()
-  {
-    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
-    return ourGame->getDiskControl().addImageIndex();
-  }
-
-  bool retro_set_initial_image(unsigned index, const char *path)
-  {
-    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s (%d) = %s\n", __FUNCTION__, index, path);
-    ra2::DiskControl::setInitialPath(index, path);
-    return true;
-  }
-
-  bool retro_get_image_path(unsigned index, char *path, size_t len)
-  {
-    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s (%d)\n", __FUNCTION__, index);
-    return ourGame->getDiskControl().getImagePath(index, path, len);
-  }
-
-  bool retro_get_image_label(unsigned index, char *label, size_t len)
-  {
-    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s (%d)\n", __FUNCTION__, index);
-    return ourGame->getDiskControl().getImageLabel(index, label, len);
-  }
-
-  void retro_keyboard_event(bool down, unsigned keycode, uint32_t character, uint16_t key_modifiers)
-  {
-    ourGame->keyboardCallback(down, keycode, character, key_modifiers);
-  }
-
-  const retro_input_descriptor inputDescriptors[] = {
-    {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT, "PDL(0)=0"},
-    {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT, "PDL(0)=255"},
-    {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP, "PDL(1)=0"},
-    {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN, "PDL(1)=255"},
-    {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A, "Button 0"},
-    {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_B, "Button 1"},
-    {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_SELECT, "Select"},
-    {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START, "Start"},
-    {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L, "Scan lines"},
-    {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R, "Cycle video"},
-    {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L2, "Save conf"},
-    {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R2, "Switch audio"},
-
-    {0, RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_LEFT, "Button 0"},
-    {0, RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_RIGHT, "Button 1"},
-
-    {0, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_X, "PDL(0)" },
-    {0, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_Y, "PDL(1)" },
-    {0, 0, 0, 0, nullptr}
-  };
+    unsigned retro_get_image_index()
+    {
+        return ourGame->getDiskControl().getImageIndex();
+    }
 
-}
+    bool retro_set_image_index(unsigned index)
+    {
+        ra2::log_cb(RETRO_LOG_INFO, "RA2: %s (%d)\n", __FUNCTION__, index);
+        return ourGame->getDiskControl().setImageIndex(index);
+    }
+
+    unsigned retro_get_num_images()
+    {
+        return ourGame->getDiskControl().getNumImages();
+    }
+
+    bool retro_replace_image_index(unsigned index, const struct retro_game_info *info)
+    {
+        ra2::log_cb(RETRO_LOG_INFO, "RA2: %s (%s)\n", __FUNCTION__, info->path);
+        if (info->path)
+        {
+            return ourGame->getDiskControl().replaceImageIndex(index, info->path);
+        }
+        else
+        {
+            return ourGame->getDiskControl().removeImageIndex(index);
+        }
+    }
+
+    bool retro_add_image_index()
+    {
+        ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
+        return ourGame->getDiskControl().addImageIndex();
+    }
+
+    bool retro_set_initial_image(unsigned index, const char *path)
+    {
+        ra2::log_cb(RETRO_LOG_INFO, "RA2: %s (%d) = %s\n", __FUNCTION__, index, path);
+        ra2::DiskControl::setInitialPath(index, path);
+        return true;
+    }
+
+    bool retro_get_image_path(unsigned index, char *path, size_t len)
+    {
+        ra2::log_cb(RETRO_LOG_INFO, "RA2: %s (%d)\n", __FUNCTION__, index);
+        return ourGame->getDiskControl().getImagePath(index, path, len);
+    }
+
+    bool retro_get_image_label(unsigned index, char *label, size_t len)
+    {
+        ra2::log_cb(RETRO_LOG_INFO, "RA2: %s (%d)\n", __FUNCTION__, index);
+        return ourGame->getDiskControl().getImageLabel(index, label, len);
+    }
+
+    void retro_keyboard_event(bool down, unsigned keycode, uint32_t character, uint16_t key_modifiers)
+    {
+        ourGame->keyboardCallback(down, keycode, character, key_modifiers);
+    }
+
+    const retro_input_descriptor inputDescriptors[] = {
+        {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT, "PDL(0)=0"},
+        {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT, "PDL(0)=255"},
+        {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP, "PDL(1)=0"},
+        {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN, "PDL(1)=255"},
+        {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A, "Button 0"},
+        {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_B, "Button 1"},
+        {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_SELECT, "Select"},
+        {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START, "Start"},
+        {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L, "Scan lines"},
+        {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R, "Cycle video"},
+        {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L2, "Save conf"},
+        {0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R2, "Switch audio"},
+
+        {0, RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_LEFT, "Button 0"},
+        {0, RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_RIGHT, "Button 1"},
+
+        {0, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_X, "PDL(0)"},
+        {0, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_Y, "PDL(1)"},
+        {0, 0, 0, 0, nullptr}};
+
+} // namespace
 
 void retro_init(void)
 {
-  ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
+    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
 }
 
 void retro_deinit(void)
 {
-  ourGame.reset();
-  ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
+    ourGame.reset();
+    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
 }
 
 unsigned retro_api_version(void)
 {
-  return RETRO_API_VERSION;
+    return RETRO_API_VERSION;
 }
 
 void retro_set_controller_port_device(unsigned port, unsigned device)
 {
-  ra2::log_cb(RETRO_LOG_INFO, "RA2: %s, Plugging device %u into port %u\n", __FUNCTION__, device, port);
-  if (port == 0)
-  {
-    ra2::Game::ourInputDevices[port] = device;
-
-    switch (device)
+    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s, Plugging device %u into port %u\n", __FUNCTION__, device, port);
+    if (port == 0)
     {
-    case RETRO_DEVICE_NONE:
-      Paddle::instance.reset();
-      break;
-    case RETRO_DEVICE_JOYPAD:
-      Paddle::instance = std::make_shared<ra2::Joypad>();
-      Paddle::setSquaring(false);
-      break;
-    case RETRO_DEVICE_ANALOG:
-      Paddle::instance = std::make_shared<ra2::Analog>();
-      Paddle::setSquaring(true);
-      break;
-    case RETRO_DEVICE_MOUSE:
-      Paddle::instance = std::make_shared<ra2::Mouse>(&ourGame);
-      Paddle::setSquaring(false);
-      break;
-    default:
-      break;
+        ra2::Game::ourInputDevices[port] = device;
+
+        switch (device)
+        {
+        case RETRO_DEVICE_NONE:
+            Paddle::instance.reset();
+            break;
+        case RETRO_DEVICE_JOYPAD:
+            Paddle::instance = std::make_shared<ra2::Joypad>();
+            Paddle::setSquaring(false);
+            break;
+        case RETRO_DEVICE_ANALOG:
+            Paddle::instance = std::make_shared<ra2::Analog>();
+            Paddle::setSquaring(true);
+            break;
+        case RETRO_DEVICE_MOUSE:
+            Paddle::instance = std::make_shared<ra2::Mouse>(&ourGame);
+            Paddle::setSquaring(false);
+            break;
+        default:
+            break;
+        }
     }
-  }
 }
 
 void retro_get_system_info(retro_system_info *info)
 {
-  ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
-  static std::string version = getVersion();
-
-  memset(info, 0, sizeof(*info));
-  info->library_name     = "AppleWin";
-  info->library_version  = version.c_str();
-  info->need_fullpath    = true;
-  info->valid_extensions = "bin|do|dsk|nib|po|gz|woz|zip|2mg|2img|iie|apl|hdv|yaml|m3u";
+    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
+    static std::string version = getVersion();
+
+    memset(info, 0, sizeof(*info));
+    info->library_name = "AppleWin";
+    info->library_version = version.c_str();
+    info->need_fullpath = true;
+    info->valid_extensions = "bin|do|dsk|nib|po|gz|woz|zip|2mg|2img|iie|apl|hdv|yaml|m3u";
 }
 
 void retro_get_system_av_info(retro_system_av_info *info)
 {
-  ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
+    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
 
-  Video & video = GetVideo();
+    Video &video = GetVideo();
 
-  info->geometry.base_width   = video.GetFrameBufferBorderlessWidth();
-  info->geometry.base_height  = video.GetFrameBufferBorderlessHeight();
-  info->geometry.max_width    = video.GetFrameBufferBorderlessWidth();
-  info->geometry.max_height   = video.GetFrameBufferBorderlessHeight();
-  info->geometry.aspect_ratio = 0;
+    info->geometry.base_width = video.GetFrameBufferBorderlessWidth();
+    info->geometry.base_height = video.GetFrameBufferBorderlessHeight();
+    info->geometry.max_width = video.GetFrameBufferBorderlessWidth();
+    info->geometry.max_height = video.GetFrameBufferBorderlessHeight();
+    info->geometry.aspect_ratio = 0;
 
-  info->timing.fps            = ra2::Game::FPS;
-  info->timing.sample_rate    = SPKR_SAMPLE_RATE;
+    info->timing.fps = ra2::Game::FPS;
+    info->timing.sample_rate = SPKR_SAMPLE_RATE;
 }
 
 void retro_set_environment(retro_environment_t cb)
 {
-  ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
-  ra2::environ_cb = cb;
+    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
+    ra2::environ_cb = cb;
 
-  if (cb(RETRO_ENVIRONMENT_GET_LOG_INTERFACE, &ra2::logging))
-    ra2::log_cb = ra2::logging.log;
-  else
-    ra2::log_cb = ra2::fallback_log;
+    if (cb(RETRO_ENVIRONMENT_GET_LOG_INTERFACE, &ra2::logging))
+        ra2::log_cb = ra2::logging.log;
+    else
+        ra2::log_cb = ra2::fallback_log;
 
-  static const struct retro_controller_description controllers[] =
-    {
-     { "Standard Joypad", RETRO_DEVICE_JOYPAD },
-     { "Analog Joypad", RETRO_DEVICE_ANALOG },
-     { "Mouse", RETRO_DEVICE_MOUSE },
+    static const struct retro_controller_description controllers[] = {
+        {"Standard Joypad", RETRO_DEVICE_JOYPAD},
+        {"Analog Joypad", RETRO_DEVICE_ANALOG},
+        {"Mouse", RETRO_DEVICE_MOUSE},
     };
 
-  static const struct retro_controller_info ports[] =
+    static const struct retro_controller_info ports[] = {
+        {controllers, sizeof(controllers) / sizeof(controllers[0])}, {nullptr, 0}};
+
+    cb(RETRO_ENVIRONMENT_SET_CONTROLLER_INFO, (void *)ports);
+    cb(RETRO_ENVIRONMENT_SET_INPUT_DESCRIPTORS, (void *)inputDescriptors);
+
+    retro_keyboard_callback keyboardCallback = {&retro_keyboard_event};
+    cb(RETRO_ENVIRONMENT_SET_KEYBOARD_CALLBACK, &keyboardCallback);
+
+    // retro_audio_buffer_status_callback audioCallback = {&ra2::bufferStatusCallback};
+    // cb(RETRO_ENVIRONMENT_SET_AUDIO_BUFFER_STATUS_CALLBACK, &audioCallback);
+
+    // see retro_get_memory_data() below
+    bool achievements = true;
+    cb(RETRO_ENVIRONMENT_SET_SUPPORT_ACHIEVEMENTS, &achievements);
+
+    const char *saveDirectory = nullptr;
+    if (cb(RETRO_ENVIRONMENT_GET_SAVE_DIRECTORY, &saveDirectory))
     {
-     { controllers, sizeof(controllers) / sizeof(controllers[0]) },
-     { nullptr, 0 }
-    };
+        ra2::save_directory = saveDirectory;
+    }
 
-  cb(RETRO_ENVIRONMENT_SET_CONTROLLER_INFO, (void*)ports);
-  cb(RETRO_ENVIRONMENT_SET_INPUT_DESCRIPTORS, (void*)inputDescriptors);
-
-  retro_keyboard_callback keyboardCallback = {&retro_keyboard_event};
-  cb(RETRO_ENVIRONMENT_SET_KEYBOARD_CALLBACK, &keyboardCallback);
-
-  // retro_audio_buffer_status_callback audioCallback = {&ra2::bufferStatusCallback};
-  // cb(RETRO_ENVIRONMENT_SET_AUDIO_BUFFER_STATUS_CALLBACK, &audioCallback);
-
-  // see retro_get_memory_data() below
-  bool achievements = true;
-  cb(RETRO_ENVIRONMENT_SET_SUPPORT_ACHIEVEMENTS, &achievements);
-
-  const char * saveDirectory = nullptr;
-  if (cb(RETRO_ENVIRONMENT_GET_SAVE_DIRECTORY, &saveDirectory))
-  {
-    ra2::save_directory = saveDirectory;
-  }
-
-  unsigned dciVersion = 0;
-  if (cb(RETRO_ENVIRONMENT_GET_DISK_CONTROL_INTERFACE_VERSION, &dciVersion) && (dciVersion >= 1))
-  {
-    retro_disk_control_ext_callback diskControlExtCallback = {
-      &retro_set_eject_state, &retro_get_eject_state,
-      &retro_get_image_index, &retro_set_image_index,
-      &retro_get_num_images, &retro_replace_image_index,
-      &retro_add_image_index, &retro_set_initial_image,
-      &retro_get_image_path, &retro_get_image_label
-    };
-    cb(RETRO_ENVIRONMENT_SET_DISK_CONTROL_EXT_INTERFACE, &diskControlExtCallback);
-  }
-  else
-  {
-    retro_disk_control_callback diskControlCallback = {
-      &retro_set_eject_state, &retro_get_eject_state,
-      &retro_get_image_index, &retro_set_image_index,
-      &retro_get_num_images, &retro_replace_image_index,
-      &retro_add_image_index
-    };
-    cb(RETRO_ENVIRONMENT_SET_DISK_CONTROL_INTERFACE, &diskControlCallback);
-  }
+    unsigned dciVersion = 0;
+    if (cb(RETRO_ENVIRONMENT_GET_DISK_CONTROL_INTERFACE_VERSION, &dciVersion) && (dciVersion >= 1))
+    {
+        retro_disk_control_ext_callback diskControlExtCallback = {
+            &retro_set_eject_state, &retro_get_eject_state,     &retro_get_image_index, &retro_set_image_index,
+            &retro_get_num_images,  &retro_replace_image_index, &retro_add_image_index, &retro_set_initial_image,
+            &retro_get_image_path,  &retro_get_image_label};
+        cb(RETRO_ENVIRONMENT_SET_DISK_CONTROL_EXT_INTERFACE, &diskControlExtCallback);
+    }
+    else
+    {
+        retro_disk_control_callback diskControlCallback = {
+            &retro_set_eject_state, &retro_get_eject_state,     &retro_get_image_index, &retro_set_image_index,
+            &retro_get_num_images,  &retro_replace_image_index, &retro_add_image_index};
+        cb(RETRO_ENVIRONMENT_SET_DISK_CONTROL_INTERFACE, &diskControlCallback);
+    }
 
-  bool noContent = true;
-  cb(RETRO_ENVIRONMENT_SET_SUPPORT_NO_GAME, &noContent);
+    bool noContent = true;
+    cb(RETRO_ENVIRONMENT_SET_SUPPORT_NO_GAME, &noContent);
 
-  ra2::SetupRetroVariables();
+    ra2::SetupRetroVariables();
 }
 
 void retro_set_audio_sample(retro_audio_sample_t cb)
 {
-  ra2::audio_cb = cb;
+    ra2::audio_cb = cb;
 }
 
 void retro_set_audio_sample_batch(retro_audio_sample_batch_t cb)
 {
-  ra2::audio_batch_cb = cb;
+    ra2::audio_batch_cb = cb;
 }
 
 void retro_set_input_poll(retro_input_poll_t cb)
 {
-  ra2::input_poll_cb = cb;
+    ra2::input_poll_cb = cb;
 }
 
 void retro_set_input_state(retro_input_state_t cb)
 {
-  ra2::input_state_cb = cb;
+    ra2::input_state_cb = cb;
 }
 
 void retro_set_video_refresh(retro_video_refresh_t cb)
 {
-  ra2::video_cb = cb;
+    ra2::video_cb = cb;
 }
 
 void retro_run(void)
 {
-  ourGame->updateVariables();
-  ourGame->processInputEvents();
-  ourGame->executeOneFrame();
-  GetFrame().VideoPresentScreen();
-  ourGame->writeAudio(ra2::Game::FPS);
+    ourGame->updateVariables();
+    ourGame->processInputEvents();
+    ourGame->executeOneFrame();
+    GetFrame().VideoPresentScreen();
+    ourGame->writeAudio(ra2::Game::FPS);
 }
 
 bool retro_load_game(const retro_game_info *info)
 {
-  ourGame.reset();
-  ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
-
-  enum retro_pixel_format fmt = RETRO_PIXEL_FORMAT_XRGB8888;
-  if (!ra2::environ_cb(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &fmt))
-  {
-    ra2::log_cb(RETRO_LOG_INFO, "XRGB8888 is not supported.\n");
-    return false;
-  }
-
-  const bool supportsInputBitmasks = !!ra2::environ_cb(RETRO_ENVIRONMENT_GET_INPUT_BITMASKS, NULL);
-
-  try
-  {
-    std::unique_ptr<ra2::Game> game = std::make_unique<ra2::Game>(supportsInputBitmasks);
-
-    const std::string snapshotEnding = ".aws.yaml";
-    const std::string playlistEnding = ".m3u";
-
-    bool ok;
+    ourGame.reset();
+    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
 
-    if (info && info->path && *info->path)
+    enum retro_pixel_format fmt = RETRO_PIXEL_FORMAT_XRGB8888;
+    if (!ra2::environ_cb(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &fmt))
     {
-      const std::string gamePath = info->path;
-      if (endsWith(gamePath, snapshotEnding))
-      {
-        ok = game->loadSnapshot(gamePath);
-      }
-      else if (endsWith(gamePath, playlistEnding))
-      {
-        ok = game->getDiskControl().insertPlaylist(gamePath);
-      }
-      else
-      {
-        ok = game->getDiskControl().insertDisk(gamePath);
-      }
-      ra2::log_cb(RETRO_LOG_INFO, "Game path: %s -> %d\n", info->path, ok);
+        ra2::log_cb(RETRO_LOG_INFO, "XRGB8888 is not supported.\n");
+        return false;
     }
-    else
+
+    const bool supportsInputBitmasks = !!ra2::environ_cb(RETRO_ENVIRONMENT_GET_INPUT_BITMASKS, NULL);
+
+    try
     {
-      // we support no content
-      ok = true;
+        std::unique_ptr<ra2::Game> game = std::make_unique<ra2::Game>(supportsInputBitmasks);
+
+        const std::string snapshotEnding = ".aws.yaml";
+        const std::string playlistEnding = ".m3u";
+
+        bool ok;
+
+        if (info && info->path && *info->path)
+        {
+            const std::string gamePath = info->path;
+            if (endsWith(gamePath, snapshotEnding))
+            {
+                ok = game->loadSnapshot(gamePath);
+            }
+            else if (endsWith(gamePath, playlistEnding))
+            {
+                ok = game->getDiskControl().insertPlaylist(gamePath);
+            }
+            else
+            {
+                ok = game->getDiskControl().insertDisk(gamePath);
+            }
+            ra2::log_cb(RETRO_LOG_INFO, "Game path: %s -> %d\n", info->path, ok);
+        }
+        else
+        {
+            // we support no content
+            ok = true;
+        }
+
+        if (ok)
+        {
+            ra2::display_message("Enable Game Focus Mode for better keyboard handling");
+            std::swap(ourGame, game);
+        }
+
+        return ok;
     }
-
-    if (ok)
+    catch (const std::exception &e)
     {
-      ra2::display_message("Enable Game Focus Mode for better keyboard handling");
-      std::swap(ourGame, game);
+        ra2::log_cb(RETRO_LOG_INFO, "Exception: %s\n", e.what());
     }
 
-    return ok;
-  }
-  catch (const std::exception & e)
-  {
-    ra2::log_cb(RETRO_LOG_INFO, "Exception: %s\n", e.what());
-  }
-
-  return false;
+    return false;
 }
 
 void retro_unload_game(void)
 {
-  ourGame.reset();
-  ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
+    ourGame.reset();
+    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
 }
 
 unsigned retro_get_region(void)
 {
-  return RETRO_REGION_NTSC;
+    return RETRO_REGION_NTSC;
 }
 
 void retro_reset(void)
 {
-  if (ourGame)
-  {
-    ourGame->updateVariables();
-    ourGame->reset();
-  }
-  ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
+    if (ourGame)
+    {
+        ourGame->updateVariables();
+        ourGame->reset();
+    }
+    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
 }
 
 bool retro_load_game_special(unsigned type, const struct retro_game_info *info, size_t num)
 {
-  ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
-  return false;
+    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
+    return false;
 }
 
 size_t retro_serialize_size(void)
 {
-  try
-  {
-    const size_t size = ra2::RetroSerialisation::getSize();
-    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s - size = %" SIZE_T_FMT "\n", __FUNCTION__, size);
-    return size;
-  }
-  catch(const std::exception& e)
-  {
-    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s - %s\n", __FUNCTION__, e.what());
-    return 0;
-  }
+    try
+    {
+        const size_t size = ra2::RetroSerialisation::getSize();
+        ra2::log_cb(RETRO_LOG_INFO, "RA2: %s - size = %" SIZE_T_FMT "\n", __FUNCTION__, size);
+        return size;
+    }
+    catch (const std::exception &e)
+    {
+        ra2::log_cb(RETRO_LOG_INFO, "RA2: %s - %s\n", __FUNCTION__, e.what());
+        return 0;
+    }
 }
 
 bool retro_serialize(void *data, size_t size)
 {
-  try
-  {
-    ra2::RetroSerialisation::serialise(data, size, ourGame->getDiskControl());
-    return true;
-  }
-  catch(const std::exception& e)
-  {
-    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s - %s\n", __FUNCTION__, e.what());
-    return false;
-  }
+    try
+    {
+        ra2::RetroSerialisation::serialise(data, size, ourGame->getDiskControl());
+        return true;
+    }
+    catch (const std::exception &e)
+    {
+        ra2::log_cb(RETRO_LOG_INFO, "RA2: %s - %s\n", __FUNCTION__, e.what());
+        return false;
+    }
 }
 
 bool retro_unserialize(const void *data, size_t size)
 {
-  const common2::RestoreCurrentDirectory restoreChDir;
-
-  try
-  {
-    ra2::RetroSerialisation::deserialise(data, size, ourGame->getDiskControl());
-    return true;
-  }
-  catch(const std::exception& e)
-  {
-    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s - %s\n", __FUNCTION__, e.what());
-    return false;
-  }
+    const common2::RestoreCurrentDirectory restoreChDir;
+
+    try
+    {
+        ra2::RetroSerialisation::deserialise(data, size, ourGame->getDiskControl());
+        return true;
+    }
+    catch (const std::exception &e)
+    {
+        ra2::log_cb(RETRO_LOG_INFO, "RA2: %s - %s\n", __FUNCTION__, e.what());
+        return false;
+    }
 }
 
 void retro_cheat_reset(void)
 {
-  ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
+    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
 }
 
 void retro_cheat_set(unsigned index, bool enabled, const char *code)
 {
-  ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
+    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s\n", __FUNCTION__);
 }
 
 void *retro_get_memory_data(unsigned id)
 {
-  ra2::log_cb(RETRO_LOG_INFO, "RA2: %s (%d)\n", __FUNCTION__, id);
-  switch (id & RETRO_MEMORY_MASK)
-  {
-  case RETRO_MEMORY_SYSTEM_RAM:
-    return MemGetBankPtr(0, true);
-  default:
-    return nullptr;
-  };
+    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s (%d)\n", __FUNCTION__, id);
+    switch (id & RETRO_MEMORY_MASK)
+    {
+    case RETRO_MEMORY_SYSTEM_RAM:
+        return MemGetBankPtr(0, true);
+    default:
+        return nullptr;
+    };
 }
 
 size_t retro_get_memory_size(unsigned id)
 {
-  ra2::log_cb(RETRO_LOG_INFO, "RA2: %s (%d)\n", __FUNCTION__, id);
-  switch (id & RETRO_MEMORY_MASK)
-  {
-  case RETRO_MEMORY_SYSTEM_RAM:
-    return _6502_MEM_LEN;
-  default:
-    return 0;
-  };
+    ra2::log_cb(RETRO_LOG_INFO, "RA2: %s (%d)\n", __FUNCTION__, id);
+    switch (id & RETRO_MEMORY_MASK)
+    {
+    case RETRO_MEMORY_SYSTEM_RAM:
+        return _6502_MEM_LEN;
+    default:
+        return 0;
+    };
 }
diff --git a/source/frontends/libretro/mouse.cpp b/source/frontends/libretro/mouse.cpp
index 5ee4cc7bb..1b4497c02 100644
--- a/source/frontends/libretro/mouse.cpp
+++ b/source/frontends/libretro/mouse.cpp
@@ -7,18 +7,18 @@
 namespace ra2
 {
 
-  Mouse::Mouse(const std::unique_ptr<Game> * game)
-    : ControllerBase({
-      {RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_LEFT},
-      {RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_RIGHT},
-    })
-    , myGame(game)
-  {
-  }
+    Mouse::Mouse(const std::unique_ptr<Game> *game)
+        : ControllerBase({
+              {RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_LEFT},
+              {RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_RIGHT},
+          })
+        , myGame(game)
+    {
+    }
 
-  double Mouse::getAxis(int i) const
-  {
-    return *myGame ? (*myGame)->getMousePosition(i) : 0.0;
-  }
+    double Mouse::getAxis(int i) const
+    {
+        return *myGame ? (*myGame)->getMousePosition(i) : 0.0;
+    }
 
-}
+} // namespace ra2
diff --git a/source/frontends/libretro/mouse.h b/source/frontends/libretro/mouse.h
index f108603e0..875498f14 100644
--- a/source/frontends/libretro/mouse.h
+++ b/source/frontends/libretro/mouse.h
@@ -7,17 +7,17 @@
 namespace ra2
 {
 
-  class Game;
+    class Game;
 
-  class Mouse : public ControllerBase
-  {
-  public:
-    Mouse(const std::unique_ptr<Game> * game);
+    class Mouse : public ControllerBase
+    {
+    public:
+        Mouse(const std::unique_ptr<Game> *game);
 
-    double getAxis(int i) const override;
+        double getAxis(int i) const override;
 
-  private:
-    const std::unique_ptr<Game> * myGame;
-  };
+    private:
+        const std::unique_ptr<Game> *myGame;
+    };
 
-}
+} // namespace ra2
diff --git a/source/frontends/libretro/rdirectsound.cpp b/source/frontends/libretro/rdirectsound.cpp
index ad6617924..24deb0fc9 100644
--- a/source/frontends/libretro/rdirectsound.cpp
+++ b/source/frontends/libretro/rdirectsound.cpp
@@ -12,182 +12,187 @@
 namespace
 {
 
-  ra2::AudioSource getAudioSourceFromName(const std::string & name)
-  {
-    // These are the strings used in DSGetSoundBuffer
-
-    if (name == "Spkr")
+    ra2::AudioSource getAudioSourceFromName(const std::string &name)
     {
-      return ra2::AudioSource::SPEAKER;
-    }
-
-    if (name == "MB")
-    {
-      return ra2::AudioSource::MOCKINGBOARD;
-    }
+        // These are the strings used in DSGetSoundBuffer
 
-    if (name == "SSI263")
-    {
-      return ra2::AudioSource::SSI263;
-    }
+        if (name == "Spkr")
+        {
+            return ra2::AudioSource::SPEAKER;
+        }
 
-    // something new, just ignore it
-    return ra2::AudioSource::UNKNOWN;
-  }
+        if (name == "MB")
+        {
+            return ra2::AudioSource::MOCKINGBOARD;
+        }
 
-  class DirectSoundGenerator : public LinuxSoundBuffer
-  {
-  public:
-    DirectSoundGenerator(DWORD dwBufferSize, DWORD nSampleRate, int nChannels, LPCSTR pszVoiceName);
-    virtual ~DirectSoundGenerator() override;
+        if (name == "SSI263")
+        {
+            return ra2::AudioSource::SSI263;
+        }
 
-    void writeAudio(const size_t fps, const bool write);
+        // something new, just ignore it
+        return ra2::AudioSource::UNKNOWN;
+    }
 
-    bool isRunning();
+    class DirectSoundGenerator : public LinuxSoundBuffer
+    {
+    public:
+        DirectSoundGenerator(DWORD dwBufferSize, DWORD nSampleRate, int nChannels, LPCSTR pszVoiceName);
+        virtual ~DirectSoundGenerator() override;
 
-    ra2::AudioSource getSource() const;
+        void writeAudio(const size_t fps, const bool write);
 
-  private:
-    const ra2::AudioSource myAudioSource;
-    std::vector<int16_t> myMixerBuffer;
+        bool isRunning();
 
-    void mixBuffer(const void * ptr, const size_t size);
-  };
+        ra2::AudioSource getSource() const;
 
-  std::unordered_set<DirectSoundGenerator *> activeSoundGenerators;
+    private:
+        const ra2::AudioSource myAudioSource;
+        std::vector<int16_t> myMixerBuffer;
 
-  DirectSoundGenerator::DirectSoundGenerator(DWORD dwBufferSize, DWORD nSampleRate, int nChannels, LPCSTR pszVoiceName)
-    : LinuxSoundBuffer(dwBufferSize, nSampleRate, nChannels, pszVoiceName)
-    , myAudioSource(getAudioSourceFromName(myVoiceName))
-  {
-  }
+        void mixBuffer(const void *ptr, const size_t size);
+    };
 
-  DirectSoundGenerator::~DirectSoundGenerator()
-  {
-    activeSoundGenerators.erase(this);
-  }
+    std::unordered_set<DirectSoundGenerator *> activeSoundGenerators;
 
-  bool DirectSoundGenerator::isRunning()
-  {
-    DWORD dwStatus;
-    GetStatus(&dwStatus);
-    if (dwStatus & DSBSTATUS_PLAYING)
+    DirectSoundGenerator::DirectSoundGenerator(
+        DWORD dwBufferSize, DWORD nSampleRate, int nChannels, LPCSTR pszVoiceName)
+        : LinuxSoundBuffer(dwBufferSize, nSampleRate, nChannels, pszVoiceName)
+        , myAudioSource(getAudioSourceFromName(myVoiceName))
     {
-      return true;
     }
-    else
+
+    DirectSoundGenerator::~DirectSoundGenerator()
     {
-      return false;
+        activeSoundGenerators.erase(this);
     }
-  }
 
-  ra2::AudioSource DirectSoundGenerator::getSource() const
-  {
-    return myAudioSource;
-  }
-
-  void DirectSoundGenerator::mixBuffer(const void * ptr, const size_t size)
-  {
-    const int16_t frames = size / (sizeof(int16_t) * myChannels);
-    const int16_t * data = static_cast<const int16_t *>(ptr);
-
-    if (myChannels == 2)
+    bool DirectSoundGenerator::isRunning()
     {
-      myMixerBuffer.assign(data, data + frames * myChannels);
+        DWORD dwStatus;
+        GetStatus(&dwStatus);
+        if (dwStatus & DSBSTATUS_PLAYING)
+        {
+            return true;
+        }
+        else
+        {
+            return false;
+        }
     }
-    else
+
+    ra2::AudioSource DirectSoundGenerator::getSource() const
     {
-      myMixerBuffer.resize(2 * frames);
-      for (int16_t i = 0; i < frames; ++i)
-      {
-        myMixerBuffer[i * 2] = data[i];
-        myMixerBuffer[i * 2 + 1] = data[i];
-      }
+        return myAudioSource;
     }
 
-    const double logVolume = GetLogarithmicVolume();
-    // same formula as QAudio::convertVolume()
-    const double linVolume = logVolume > 0.99 ? 1.0 : -std::log(1.0 - logVolume) / std::log(100.0);
-    const int16_t rvolume = int16_t(linVolume * 128);
-
-    for (int16_t & sample : myMixerBuffer)
+    void DirectSoundGenerator::mixBuffer(const void *ptr, const size_t size)
     {
-      sample = (sample * rvolume) / 128;
+        const int16_t frames = size / (sizeof(int16_t) * myChannels);
+        const int16_t *data = static_cast<const int16_t *>(ptr);
+
+        if (myChannels == 2)
+        {
+            myMixerBuffer.assign(data, data + frames * myChannels);
+        }
+        else
+        {
+            myMixerBuffer.resize(2 * frames);
+            for (int16_t i = 0; i < frames; ++i)
+            {
+                myMixerBuffer[i * 2] = data[i];
+                myMixerBuffer[i * 2 + 1] = data[i];
+            }
+        }
+
+        const double logVolume = GetLogarithmicVolume();
+        // same formula as QAudio::convertVolume()
+        const double linVolume = logVolume > 0.99 ? 1.0 : -std::log(1.0 - logVolume) / std::log(100.0);
+        const int16_t rvolume = int16_t(linVolume * 128);
+
+        for (int16_t &sample : myMixerBuffer)
+        {
+            sample = (sample * rvolume) / 128;
+        }
+
+        ra2::audio_batch_cb(myMixerBuffer.data(), frames);
     }
 
-    ra2::audio_batch_cb(myMixerBuffer.data(), frames);
-  }
-
-  void DirectSoundGenerator::writeAudio(const size_t fps, const bool write)
-  {
-    const size_t frames = mySampleRate / fps;
-    const size_t bytesToRead = frames * myChannels * sizeof(int16_t);
-
-    LPVOID lpvAudioPtr1, lpvAudioPtr2;
-    DWORD dwAudioBytes1, dwAudioBytes2;
-    // always read to keep AppleWin audio algorithms working correctly.
-    Read(bytesToRead, &lpvAudioPtr1, &dwAudioBytes1, &lpvAudioPtr2, &dwAudioBytes2);
-
-    if (write)
+    void DirectSoundGenerator::writeAudio(const size_t fps, const bool write)
     {
-      if (lpvAudioPtr1 && dwAudioBytes1)
-      {
-        mixBuffer(lpvAudioPtr1, dwAudioBytes1);
-      }
-      if (lpvAudioPtr2 && dwAudioBytes2)
-      {
-        mixBuffer(lpvAudioPtr2, dwAudioBytes2);
-      }
+        const size_t frames = mySampleRate / fps;
+        const size_t bytesToRead = frames * myChannels * sizeof(int16_t);
+
+        LPVOID lpvAudioPtr1, lpvAudioPtr2;
+        DWORD dwAudioBytes1, dwAudioBytes2;
+        // always read to keep AppleWin audio algorithms working correctly.
+        Read(bytesToRead, &lpvAudioPtr1, &dwAudioBytes1, &lpvAudioPtr2, &dwAudioBytes2);
+
+        if (write)
+        {
+            if (lpvAudioPtr1 && dwAudioBytes1)
+            {
+                mixBuffer(lpvAudioPtr1, dwAudioBytes1);
+            }
+            if (lpvAudioPtr2 && dwAudioBytes2)
+            {
+                mixBuffer(lpvAudioPtr2, dwAudioBytes2);
+            }
+        }
     }
-  }
 
-}
+} // namespace
 
 namespace ra2
 {
 
-  std::shared_ptr<SoundBuffer> iCreateDirectSoundBuffer(uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char* pszVoiceName)
-  {
-    std::shared_ptr<DirectSoundGenerator> generator = std::make_shared<DirectSoundGenerator>(dwBufferSize, nSampleRate, nChannels, pszVoiceName);
-    DirectSoundGenerator * ptr = generator.get();
-    activeSoundGenerators.insert(ptr);
-    return generator;
-  }
-
-  void writeAudio(const AudioSource selectedSource, const size_t fps)
-  {
-    bool found = false;
-    for (const auto & it : activeSoundGenerators)
+    std::shared_ptr<SoundBuffer> iCreateDirectSoundBuffer(
+        uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char *pszVoiceName)
+    {
+        std::shared_ptr<DirectSoundGenerator> generator =
+            std::make_shared<DirectSoundGenerator>(dwBufferSize, nSampleRate, nChannels, pszVoiceName);
+        DirectSoundGenerator *ptr = generator.get();
+        activeSoundGenerators.insert(ptr);
+        return generator;
+    }
+
+    void writeAudio(const AudioSource selectedSource, const size_t fps)
     {
-      const auto & generator = it;
-      if (generator->isRunning())
-      {
-        const bool selected = !found && (selectedSource == generator->getSource());
-        // we still read audio from all buffers
-        // to keep AppleWin audio generation woking correctly
-        // but only write on the selected one
-        generator->writeAudio(fps, selected);
-        // TODO: implement an algorithm to merge 2 channels (speaker + mockingboard)
-        found = found || selected;
-      }
+        bool found = false;
+        for (const auto &it : activeSoundGenerators)
+        {
+            const auto &generator = it;
+            if (generator->isRunning())
+            {
+                const bool selected = !found && (selectedSource == generator->getSource());
+                // we still read audio from all buffers
+                // to keep AppleWin audio generation woking correctly
+                // but only write on the selected one
+                generator->writeAudio(fps, selected);
+                // TODO: implement an algorithm to merge 2 channels (speaker + mockingboard)
+                found = found || selected;
+            }
+        }
+        // TODO: if found = false, we should probably write some silence
     }
-    // TODO: if found = false, we should probably write some silence
-  }
 
-  void bufferStatusCallback(bool active, unsigned occupancy, bool underrun_likely)
-  {
-    if (active)
+    void bufferStatusCallback(bool active, unsigned occupancy, bool underrun_likely)
     {
-      // I am not sure this is any useful
-      static unsigned lastOccupancy = 0;
-      const int diff = std::abs(int(lastOccupancy) - int(occupancy));
-      if (diff >= 5)
-      {
-        // this is very verbose
-        log_cb(RETRO_LOG_INFO, "RA2: %s occupancy = %d, underrun_likely = %d\n", __FUNCTION__, occupancy, underrun_likely);
-        lastOccupancy = occupancy;
-      }
+        if (active)
+        {
+            // I am not sure this is any useful
+            static unsigned lastOccupancy = 0;
+            const int diff = std::abs(int(lastOccupancy) - int(occupancy));
+            if (diff >= 5)
+            {
+                // this is very verbose
+                log_cb(
+                    RETRO_LOG_INFO, "RA2: %s occupancy = %d, underrun_likely = %d\n", __FUNCTION__, occupancy,
+                    underrun_likely);
+                lastOccupancy = occupancy;
+            }
+        }
     }
-  }
 
-}
+} // namespace ra2
diff --git a/source/frontends/libretro/rdirectsound.h b/source/frontends/libretro/rdirectsound.h
index 061ac4d75..69c057b0c 100644
--- a/source/frontends/libretro/rdirectsound.h
+++ b/source/frontends/libretro/rdirectsound.h
@@ -3,23 +3,24 @@
 #include <cstdlib>
 #include <memory>
 
-#define REGVALUE_AUDIO_SPEAKER        "Speaker"
-#define REGVALUE_AUDIO_MOCKINGBOARD   "Mockingboard"
+#define REGVALUE_AUDIO_SPEAKER "Speaker"
+#define REGVALUE_AUDIO_MOCKINGBOARD "Mockingboard"
 
 class SoundBuffer;
 
 namespace ra2
 {
-  enum class AudioSource
-  {
-    SPEAKER = 0,
-    MOCKINGBOARD = 1,
-    SSI263 = 2,           // currently not selectable in libretro
-    UNKNOWN
-  };
+    enum class AudioSource
+    {
+        SPEAKER = 0,
+        MOCKINGBOARD = 1,
+        SSI263 = 2, // currently not selectable in libretro
+        UNKNOWN
+    };
 
-  std::shared_ptr<SoundBuffer> iCreateDirectSoundBuffer(uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char* pszVoiceName);
+    std::shared_ptr<SoundBuffer> iCreateDirectSoundBuffer(
+        uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char *pszVoiceName);
 
-  void writeAudio(const AudioSource selectedSource, const size_t fps);
-  void bufferStatusCallback(bool active, unsigned occupancy, bool underrun_likely);
-}
+    void writeAudio(const AudioSource selectedSource, const size_t fps);
+    void bufferStatusCallback(bool active, unsigned occupancy, bool underrun_likely);
+} // namespace ra2
diff --git a/source/frontends/libretro/retroframe.cpp b/source/frontends/libretro/retroframe.cpp
index 5c2ccee25..3ec866ed6 100644
--- a/source/frontends/libretro/retroframe.cpp
+++ b/source/frontends/libretro/retroframe.cpp
@@ -12,93 +12,94 @@
 namespace ra2
 {
 
-  RetroFrame::RetroFrame(const common2::EmulatorOptions & options)
-  : common2::GNUFrame(options)
-  {
-  }
-
-  void RetroFrame::FrameRefreshStatus(int drawflags)
-  {
-    if (drawflags & DRAW_TITLE)
+    RetroFrame::RetroFrame(const common2::EmulatorOptions &options)
+        : common2::GNUFrame(options)
     {
-      GetAppleWindowTitle();
-      display_message(g_pAppTitle.c_str());
     }
-  }
-
-  void RetroFrame::VideoPresentScreen()
-  {
-    // this should not be necessary
-    // either libretro handles it
-    // or we should change AW
-    // but for now, there is no alternative
-    for (size_t row = 0; row < myHeight; ++row)
+
+    void RetroFrame::FrameRefreshStatus(int drawflags)
+    {
+        if (drawflags & DRAW_TITLE)
+        {
+            GetAppleWindowTitle();
+            display_message(g_pAppTitle.c_str());
+        }
+    }
+
+    void RetroFrame::VideoPresentScreen()
+    {
+        // this should not be necessary
+        // either libretro handles it
+        // or we should change AW
+        // but for now, there is no alternative
+        for (size_t row = 0; row < myHeight; ++row)
+        {
+            const uint8_t *src = myFrameBuffer + row * myPitch;
+            uint8_t *dst = myVideoBuffer.data() + (myHeight - row - 1) * myPitch;
+            memcpy(dst, src, myPitch);
+        }
+
+        video_cb(myVideoBuffer.data() + myOffset, myBorderlessWidth, myBorderlessHeight, myPitch);
+    }
+
+    void RetroFrame::Initialize(bool resetVideoState)
+    {
+        CommonFrame::Initialize(resetVideoState);
+        FrameRefreshStatus(DRAW_TITLE);
+
+        Video &video = GetVideo();
+
+        myBorderlessWidth = video.GetFrameBufferBorderlessWidth();
+        myBorderlessHeight = video.GetFrameBufferBorderlessHeight();
+        const size_t borderWidth = video.GetFrameBufferBorderWidth();
+        const size_t borderHeight = video.GetFrameBufferBorderHeight();
+        const size_t width = video.GetFrameBufferWidth();
+        myHeight = video.GetFrameBufferHeight();
+
+        myFrameBuffer = video.GetFrameBuffer();
+
+        myPitch = width * sizeof(bgra_t);
+        myOffset = (width * borderHeight + borderWidth) * sizeof(bgra_t);
+
+        const size_t size = myHeight * myPitch;
+        myVideoBuffer.resize(size);
+    }
+
+    void RetroFrame::Destroy()
+    {
+        CommonFrame::Destroy();
+        myFrameBuffer = nullptr;
+        myVideoBuffer.clear();
+    }
+
+    int RetroFrame::FrameMessageBox(LPCSTR lpText, LPCSTR lpCaption, UINT uType)
+    {
+        log_cb(RETRO_LOG_INFO, "RA2: %s: %s - %s\n", __FUNCTION__, lpCaption, lpText);
+        return IDOK;
+    }
+
+    void RetroFrame::SetFullSpeed(const bool /* value */)
+    {
+        // do nothing
+    }
+
+    bool RetroFrame::CanDoFullSpeed()
+    {
+        // Let libretro deal with it.
+        return false;
+    }
+
+    void RetroFrame::Begin()
+    {
+        const common2::RestoreCurrentDirectory restoreChDir;
+        common2::GNUFrame::Begin();
+    }
+
+    std::shared_ptr<SoundBuffer> RetroFrame::CreateSoundBuffer(
+        uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char *pszVoiceName)
     {
-      const uint8_t * src = myFrameBuffer + row * myPitch;
-      uint8_t * dst = myVideoBuffer.data() + (myHeight - row - 1) * myPitch;
-      memcpy(dst, src, myPitch);
+        const auto buffer = ra2::iCreateDirectSoundBuffer(dwBufferSize, nSampleRate, nChannels, pszVoiceName);
+        return buffer;
     }
 
-    video_cb(myVideoBuffer.data() + myOffset, myBorderlessWidth, myBorderlessHeight, myPitch);
-  }
-
-  void RetroFrame::Initialize(bool resetVideoState)
-  {
-    CommonFrame::Initialize(resetVideoState);
-    FrameRefreshStatus(DRAW_TITLE);
-
-    Video & video = GetVideo();
-
-    myBorderlessWidth = video.GetFrameBufferBorderlessWidth();
-    myBorderlessHeight = video.GetFrameBufferBorderlessHeight();
-    const size_t borderWidth = video.GetFrameBufferBorderWidth();
-    const size_t borderHeight = video.GetFrameBufferBorderHeight();
-    const size_t width = video.GetFrameBufferWidth();
-    myHeight = video.GetFrameBufferHeight();
-
-    myFrameBuffer = video.GetFrameBuffer();
-
-    myPitch = width * sizeof(bgra_t);
-    myOffset = (width * borderHeight + borderWidth) * sizeof(bgra_t);
-
-    const size_t size = myHeight * myPitch;
-    myVideoBuffer.resize(size);
-  }
-
-  void RetroFrame::Destroy()
-  {
-    CommonFrame::Destroy();
-    myFrameBuffer = nullptr;
-    myVideoBuffer.clear();
-  }
-
-  int RetroFrame::FrameMessageBox(LPCSTR lpText, LPCSTR lpCaption, UINT uType)
-  {
-    log_cb(RETRO_LOG_INFO, "RA2: %s: %s - %s\n", __FUNCTION__, lpCaption, lpText);
-    return IDOK;
-  }
-
-  void RetroFrame::SetFullSpeed(const bool /* value */)
-  {
-    // do nothing
-  }
-  
-  bool RetroFrame::CanDoFullSpeed()
-  {
-    // Let libretro deal with it.
-    return false;
-  }
-
-  void RetroFrame::Begin()
-  {
-    const common2::RestoreCurrentDirectory restoreChDir;
-    common2::GNUFrame::Begin();
-  }
-
-  std::shared_ptr<SoundBuffer> RetroFrame::CreateSoundBuffer(uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char* pszVoiceName)
-  {
-      const auto buffer = ra2::iCreateDirectSoundBuffer(dwBufferSize, nSampleRate, nChannels, pszVoiceName);
-      return buffer;
-  }
-
-}
+} // namespace ra2
diff --git a/source/frontends/libretro/retroframe.h b/source/frontends/libretro/retroframe.h
index 5dd9619e9..fb644bfcc 100644
--- a/source/frontends/libretro/retroframe.h
+++ b/source/frontends/libretro/retroframe.h
@@ -7,33 +7,34 @@
 namespace ra2
 {
 
-  class RetroFrame : public common2::GNUFrame
-  {
-  public:
-    RetroFrame(const common2::EmulatorOptions & options);
-
-    void VideoPresentScreen() override;
-    void FrameRefreshStatus(int drawflags) override;
-    void Initialize(bool resetVideoState) override;
-    void Destroy() override;
-    void Begin() override;
-    int FrameMessageBox(LPCSTR lpText, LPCSTR lpCaption, UINT uType) override;
-
-    std::shared_ptr<SoundBuffer> CreateSoundBuffer(uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char* pszVoiceName) override;
-
-  protected:
-    virtual void SetFullSpeed(const bool value) override;
-    virtual bool CanDoFullSpeed() override;
-
-  private:
-    std::vector<uint8_t> myVideoBuffer;
-
-    size_t myPitch;
-    size_t myOffset;
-    size_t myHeight;
-    size_t myBorderlessWidth;
-    size_t myBorderlessHeight;
-    uint8_t* myFrameBuffer;
-  };
-
-}
+    class RetroFrame : public common2::GNUFrame
+    {
+    public:
+        RetroFrame(const common2::EmulatorOptions &options);
+
+        void VideoPresentScreen() override;
+        void FrameRefreshStatus(int drawflags) override;
+        void Initialize(bool resetVideoState) override;
+        void Destroy() override;
+        void Begin() override;
+        int FrameMessageBox(LPCSTR lpText, LPCSTR lpCaption, UINT uType) override;
+
+        std::shared_ptr<SoundBuffer> CreateSoundBuffer(
+            uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char *pszVoiceName) override;
+
+    protected:
+        virtual void SetFullSpeed(const bool value) override;
+        virtual bool CanDoFullSpeed() override;
+
+    private:
+        std::vector<uint8_t> myVideoBuffer;
+
+        size_t myPitch;
+        size_t myOffset;
+        size_t myHeight;
+        size_t myBorderlessWidth;
+        size_t myBorderlessHeight;
+        uint8_t *myFrameBuffer;
+    };
+
+} // namespace ra2
diff --git a/source/frontends/libretro/retroregistry.cpp b/source/frontends/libretro/retroregistry.cpp
index 80beb5783..137f6db93 100644
--- a/source/frontends/libretro/retroregistry.cpp
+++ b/source/frontends/libretro/retroregistry.cpp
@@ -16,241 +16,217 @@
 namespace
 {
 
-  const std::string ourScope = "applewin_";
+    const std::string ourScope = "applewin_";
 
-  const char * REG_RA2 = "ra2";
-  const char * REGVALUE_AUDIO_SOURCE = "Audio source";
-  const char * REGVALUE_KEYBOARD_TYPE = "Keyboard type";
-  const char * REGVALUE_PLAYLIST_START = "Playlist start";
+    const char *REG_RA2 = "ra2";
+    const char *REGVALUE_AUDIO_SOURCE = "Audio source";
+    const char *REGVALUE_KEYBOARD_TYPE = "Keyboard type";
+    const char *REGVALUE_PLAYLIST_START = "Playlist start";
 
-  struct Variable
-  {
-    std::string name;
-    std::string description;
-    std::string section;
-    std::string key;
-    std::vector<std::pair<std::string, uint32_t> > values;
-  };
-
-  const std::vector<Variable> ourVariables =
+    struct Variable
     {
-     {
-      "machine",
-      "Apple ][ Type",
-      REG_CONFIG,
-      REGVALUE_APPLE2_TYPE, // reset required
-      {
-       {"Enhanced Apple //e", A2TYPE_APPLE2EENHANCED},
-       {"Apple ][ (Original)", A2TYPE_APPLE2},
-       {"Apple ][+", A2TYPE_APPLE2PLUS},
-       {"Apple ][ J-Plus", A2TYPE_APPLE2JPLUS},
-       {"Apple //e", A2TYPE_APPLE2E},
-       {"Pravets 82", A2TYPE_PRAVETS82},
-       {"Pravets 8M", A2TYPE_PRAVETS8M},
-       {"Pravets 8A", A2TYPE_PRAVETS8A},
-       {"Base64A", A2TYPE_BASE64A},
-       {"TK3000 //e", A2TYPE_TK30002E},
-      }
-     },
-     {
-      "slot3",
-      "Card in Slot 3",
-      "Configuration\\Slot 3",
-      REGVALUE_CARD_TYPE, // reset required
-      {
-       {"Empty", CT_Empty},
-       {"Video HD", CT_VidHD},
-      }
-     },
-     {
-      "slot4",
-      "Card in Slot 4",
-      "Configuration\\Slot 4",
-      REGVALUE_CARD_TYPE, // reset required
-      {
-       {"Empty", CT_Empty},
-       {"Mouse", CT_MouseInterface},
-       {"Mockingboard", CT_MockingboardC},
-       {"Phasor", CT_Phasor},
-      }
-     },
-     {
-      "slot5",
-      "Card in Slot 5",
-      "Configuration\\Slot 5",
-      REGVALUE_CARD_TYPE, // reset required
-      {
-       {"Empty", CT_Empty},
-       {"CP/M", CT_Z80},
-       {"Mockingboard", CT_MockingboardC},
-       {"Phasor", CT_Phasor},
-       {"SAM/DAC", CT_SAM},
-      }
-     },
-     {
-      "video_mode",
-      "Video Mode",
-      REG_CONFIG,
-      REGVALUE_VIDEO_MODE,
-      {
-       {"Color (Composite Idealized)", VT_COLOR_IDEALIZED},
-       {"Color (RGB Card/Monitor)", VT_COLOR_VIDEOCARD_RGB},
-       {"Color (Composite Monitor)", VT_COLOR_MONITOR_NTSC},
-       {"Color TV", VT_COLOR_TV},
-       {"B&W TV", VT_MONO_TV},
-       {"Monochrome (Amber)", VT_MONO_AMBER},
-       {"Monochrome (Green)", VT_MONO_GREEN},
-       {"Monochrome (White)", VT_MONO_WHITE},
-      }
-     },
-     {
-      "video_style",
-      "Video Style",
-      REG_CONFIG,
-      REGVALUE_VIDEO_STYLE,
-      {
-       {"Half Scanlines", VS_HALF_SCANLINES},
-       {"None", VS_NONE},
-      }
-     },
-     {
-      "video_refresh_rate",
-      "Video Refresh Rate",
-      REG_CONFIG,
-      REGVALUE_VIDEO_REFRESH_RATE, // reset required
-      {
-       {"60Hz", VR_60HZ},
-       {"50Hz", VR_50HZ},
-      }
-     },
-     {
-      "audio_source",
-      "Audio Source",
-      REG_RA2,
-      REGVALUE_AUDIO_SOURCE,
-      {
-       {REGVALUE_AUDIO_SPEAKER, static_cast<uint32_t>(ra2::AudioSource::SPEAKER)},
-       {REGVALUE_AUDIO_MOCKINGBOARD, static_cast<uint32_t>(ra2::AudioSource::MOCKINGBOARD)},
-      }
-     },
-     {
-      "keyboard_type",
-      "Keyboard Type",
-      REG_RA2,
-      REGVALUE_KEYBOARD_TYPE,
-      {
-       {"ASCII", static_cast<uint32_t>(ra2::KeyboardType::ASCII)},
-       {"Original", static_cast<uint32_t>(ra2::KeyboardType::Original)},
-      }
-     },
-     {
-      "playlist_start",
-      "Playlist start disk",
-      REG_RA2,
-      REGVALUE_PLAYLIST_START,
-      {
-       {"First", static_cast<uint32_t>(ra2::PlaylistStartDisk::First)},
-       {"Previous", static_cast<uint32_t>(ra2::PlaylistStartDisk::Previous)},
-      }
-     },
+        std::string name;
+        std::string description;
+        std::string section;
+        std::string key;
+        std::vector<std::pair<std::string, uint32_t>> values;
+    };
+
+    const std::vector<Variable> ourVariables = {
+        {"machine",
+         "Apple ][ Type",
+         REG_CONFIG,
+         REGVALUE_APPLE2_TYPE, // reset required
+         {
+             {"Enhanced Apple //e", A2TYPE_APPLE2EENHANCED},
+             {"Apple ][ (Original)", A2TYPE_APPLE2},
+             {"Apple ][+", A2TYPE_APPLE2PLUS},
+             {"Apple ][ J-Plus", A2TYPE_APPLE2JPLUS},
+             {"Apple //e", A2TYPE_APPLE2E},
+             {"Pravets 82", A2TYPE_PRAVETS82},
+             {"Pravets 8M", A2TYPE_PRAVETS8M},
+             {"Pravets 8A", A2TYPE_PRAVETS8A},
+             {"Base64A", A2TYPE_BASE64A},
+             {"TK3000 //e", A2TYPE_TK30002E},
+         }},
+        {"slot3",
+         "Card in Slot 3",
+         "Configuration\\Slot 3",
+         REGVALUE_CARD_TYPE, // reset required
+         {
+             {"Empty", CT_Empty},
+             {"Video HD", CT_VidHD},
+         }},
+        {"slot4",
+         "Card in Slot 4",
+         "Configuration\\Slot 4",
+         REGVALUE_CARD_TYPE, // reset required
+         {
+             {"Empty", CT_Empty},
+             {"Mouse", CT_MouseInterface},
+             {"Mockingboard", CT_MockingboardC},
+             {"Phasor", CT_Phasor},
+         }},
+        {"slot5",
+         "Card in Slot 5",
+         "Configuration\\Slot 5",
+         REGVALUE_CARD_TYPE, // reset required
+         {
+             {"Empty", CT_Empty},
+             {"CP/M", CT_Z80},
+             {"Mockingboard", CT_MockingboardC},
+             {"Phasor", CT_Phasor},
+             {"SAM/DAC", CT_SAM},
+         }},
+        {"video_mode",
+         "Video Mode",
+         REG_CONFIG,
+         REGVALUE_VIDEO_MODE,
+         {
+             {"Color (Composite Idealized)", VT_COLOR_IDEALIZED},
+             {"Color (RGB Card/Monitor)", VT_COLOR_VIDEOCARD_RGB},
+             {"Color (Composite Monitor)", VT_COLOR_MONITOR_NTSC},
+             {"Color TV", VT_COLOR_TV},
+             {"B&W TV", VT_MONO_TV},
+             {"Monochrome (Amber)", VT_MONO_AMBER},
+             {"Monochrome (Green)", VT_MONO_GREEN},
+             {"Monochrome (White)", VT_MONO_WHITE},
+         }},
+        {"video_style",
+         "Video Style",
+         REG_CONFIG,
+         REGVALUE_VIDEO_STYLE,
+         {
+             {"Half Scanlines", VS_HALF_SCANLINES},
+             {"None", VS_NONE},
+         }},
+        {"video_refresh_rate",
+         "Video Refresh Rate",
+         REG_CONFIG,
+         REGVALUE_VIDEO_REFRESH_RATE, // reset required
+         {
+             {"60Hz", VR_60HZ},
+             {"50Hz", VR_50HZ},
+         }},
+        {"audio_source",
+         "Audio Source",
+         REG_RA2,
+         REGVALUE_AUDIO_SOURCE,
+         {
+             {REGVALUE_AUDIO_SPEAKER, static_cast<uint32_t>(ra2::AudioSource::SPEAKER)},
+             {REGVALUE_AUDIO_MOCKINGBOARD, static_cast<uint32_t>(ra2::AudioSource::MOCKINGBOARD)},
+         }},
+        {"keyboard_type",
+         "Keyboard Type",
+         REG_RA2,
+         REGVALUE_KEYBOARD_TYPE,
+         {
+             {"ASCII", static_cast<uint32_t>(ra2::KeyboardType::ASCII)},
+             {"Original", static_cast<uint32_t>(ra2::KeyboardType::Original)},
+         }},
+        {"playlist_start",
+         "Playlist start disk",
+         REG_RA2,
+         REGVALUE_PLAYLIST_START,
+         {
+             {"First", static_cast<uint32_t>(ra2::PlaylistStartDisk::First)},
+             {"Previous", static_cast<uint32_t>(ra2::PlaylistStartDisk::Previous)},
+         }},
     };
 
-  std::string getKey(const Variable & var)
-  {
-    std::ostringstream ss;
-    ss << var.description << "; ";
-    for (size_t i = 0; i < var.values.size(); ++i)
+    std::string getKey(const Variable &var)
     {
-      if (i > 0)
-      {
-        ss << "|";
-      }
-      ss << var.values[i].first;
+        std::ostringstream ss;
+        ss << var.description << "; ";
+        for (size_t i = 0; i < var.values.size(); ++i)
+        {
+            if (i > 0)
+            {
+                ss << "|";
+            }
+            ss << var.values[i].first;
+        }
+        return ss.str();
     }
-    return ss.str();
-  }
 
-}
+} // namespace
 
 namespace ra2
 {
 
-  void SetupRetroVariables()
-  {
-    const size_t numberOfVariables = ourVariables.size();
-    std::vector<retro_variable> retroVariables(numberOfVariables + 1);
-    std::list<std::string> workspace; // so objects do not move when it resized
+    void SetupRetroVariables()
+    {
+        const size_t numberOfVariables = ourVariables.size();
+        std::vector<retro_variable> retroVariables(numberOfVariables + 1);
+        std::list<std::string> workspace; // so objects do not move when it resized
 
-    // we need to keep the char * alive till after the call to RETRO_ENVIRONMENT_SET_VARIABLES
-    const auto c_str = [&workspace] (const auto & s)
-                       {
-                         workspace.push_back(s);
-                         return workspace.back().c_str();
-                       };
+        // we need to keep the char * alive till after the call to RETRO_ENVIRONMENT_SET_VARIABLES
+        const auto c_str = [&workspace](const auto &s)
+        {
+            workspace.push_back(s);
+            return workspace.back().c_str();
+        };
 
-    for (size_t i = 0; i < numberOfVariables; ++i)
-    {
-      const Variable & variable = ourVariables[i];
-      retro_variable & retroVariable = retroVariables[i];
+        for (size_t i = 0; i < numberOfVariables; ++i)
+        {
+            const Variable &variable = ourVariables[i];
+            retro_variable &retroVariable = retroVariables[i];
 
-      retroVariable.key = c_str(ourScope + variable.name);
-      retroVariable.value = c_str(getKey(variable));
-    }
+            retroVariable.key = c_str(ourScope + variable.name);
+            retroVariable.value = c_str(getKey(variable));
+        }
 
-    environ_cb(RETRO_ENVIRONMENT_SET_VARIABLES, retroVariables.data());
-  }
+        environ_cb(RETRO_ENVIRONMENT_SET_VARIABLES, retroVariables.data());
+    }
 
-  void PopulateRegistry(const std::shared_ptr<Registry> & registry)
-  {
-    for (const Variable & variable : ourVariables)
+    void PopulateRegistry(const std::shared_ptr<Registry> &registry)
     {
-      const std::string retroKey = ourScope + variable.name;
-      retro_variable retroVariable;
-      retroVariable.key = retroKey.c_str();
-      retroVariable.value = nullptr;
-      if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &retroVariable) && retroVariable.value)
-      {
-        const std::string value(retroVariable.value);
-        const auto check = [&value] (const auto & x)
-                           {
-                             return x.first == value;
-                           };
-        const auto it = std::find_if(variable.values.begin(), variable.values.end(), check);
-        if (it != variable.values.end())
+        for (const Variable &variable : ourVariables)
         {
-          registry->putDWord(variable.section, variable.key, it->second);
+            const std::string retroKey = ourScope + variable.name;
+            retro_variable retroVariable;
+            retroVariable.key = retroKey.c_str();
+            retroVariable.value = nullptr;
+            if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &retroVariable) && retroVariable.value)
+            {
+                const std::string value(retroVariable.value);
+                const auto check = [&value](const auto &x) { return x.first == value; };
+                const auto it = std::find_if(variable.values.begin(), variable.values.end(), check);
+                if (it != variable.values.end())
+                {
+                    registry->putDWord(variable.section, variable.key, it->second);
+                }
+            }
         }
-      }
     }
-  }
 
-  std::shared_ptr<common2::PTreeRegistry> CreateRetroRegistry()
-  {
-    const auto registry = std::make_shared<common2::PTreeRegistry>();
-    PopulateRegistry(registry);
-    return registry;
-  }
+    std::shared_ptr<common2::PTreeRegistry> CreateRetroRegistry()
+    {
+        const auto registry = std::make_shared<common2::PTreeRegistry>();
+        PopulateRegistry(registry);
+        return registry;
+    }
 
-  AudioSource GetAudioSource()
-  {
-    uint32_t value = 1;
-    RegLoadValue(REG_RA2, REGVALUE_AUDIO_SOURCE, TRUE, &value);
-    const AudioSource source = value <= uint32_t(AudioSource::UNKNOWN) ? AudioSource(value) : AudioSource::UNKNOWN;
-    return source;
-  }
+    AudioSource GetAudioSource()
+    {
+        uint32_t value = 1;
+        RegLoadValue(REG_RA2, REGVALUE_AUDIO_SOURCE, TRUE, &value);
+        const AudioSource source = value <= uint32_t(AudioSource::UNKNOWN) ? AudioSource(value) : AudioSource::UNKNOWN;
+        return source;
+    }
 
-  KeyboardType GetKeyboardEmulationType()
-  {
-    uint32_t value = static_cast<uint32_t>(KeyboardType::ASCII);
-    RegLoadValue(REG_RA2, REGVALUE_KEYBOARD_TYPE, TRUE, &value);
-    return static_cast<KeyboardType>(value);
-  }
+    KeyboardType GetKeyboardEmulationType()
+    {
+        uint32_t value = static_cast<uint32_t>(KeyboardType::ASCII);
+        RegLoadValue(REG_RA2, REGVALUE_KEYBOARD_TYPE, TRUE, &value);
+        return static_cast<KeyboardType>(value);
+    }
 
-  PlaylistStartDisk GetPlaylistStartDisk()
-  {
-    uint32_t value = static_cast<uint32_t>(PlaylistStartDisk::First);
-    RegLoadValue(REG_RA2, REGVALUE_PLAYLIST_START, TRUE, &value);
-    return static_cast<PlaylistStartDisk>(value);
-  }
+    PlaylistStartDisk GetPlaylistStartDisk()
+    {
+        uint32_t value = static_cast<uint32_t>(PlaylistStartDisk::First);
+        RegLoadValue(REG_RA2, REGVALUE_PLAYLIST_START, TRUE, &value);
+        return static_cast<PlaylistStartDisk>(value);
+    }
 
-}
+} // namespace ra2
diff --git a/source/frontends/libretro/retroregistry.h b/source/frontends/libretro/retroregistry.h
index b1deea7c1..97789aada 100644
--- a/source/frontends/libretro/retroregistry.h
+++ b/source/frontends/libretro/retroregistry.h
@@ -10,18 +10,18 @@ class Registry;
 
 namespace common2
 {
-  class PTreeRegistry;
+    class PTreeRegistry;
 }
 
 namespace ra2
 {
 
-  void SetupRetroVariables();
-  std::shared_ptr<common2::PTreeRegistry> CreateRetroRegistry();
-  void PopulateRegistry(const std::shared_ptr<Registry> & registry);
+    void SetupRetroVariables();
+    std::shared_ptr<common2::PTreeRegistry> CreateRetroRegistry();
+    void PopulateRegistry(const std::shared_ptr<Registry> &registry);
 
-  AudioSource GetAudioSource();
-  KeyboardType GetKeyboardEmulationType();
-  PlaylistStartDisk GetPlaylistStartDisk();
+    AudioSource GetAudioSource();
+    KeyboardType GetKeyboardEmulationType();
+    PlaylistStartDisk GetPlaylistStartDisk();
 
-}
+} // namespace ra2
diff --git a/source/frontends/libretro/rkeyboard.cpp b/source/frontends/libretro/rkeyboard.cpp
index 7c14d9dda..b96e19870 100644
--- a/source/frontends/libretro/rkeyboard.cpp
+++ b/source/frontends/libretro/rkeyboard.cpp
@@ -6,67 +6,47 @@
 
 namespace
 {
-  const std::unordered_map<size_t, std::array<uint8_t, 3>> CODES =
-  {
-    {0x7f, {0x7f, 0x7f, 0x7f}},
-    {0x08, {0x08, 0x08, 0x08}},
-    {0x09, {0x09, 0x09, 0x09}},
-    {0x0a, {0x0a, 0x0a, 0x0a}},
-    {0x0b, {0x0b, 0x0b, 0x0b}},
-    {0x0d, {0x0d, 0x0d, 0x0d}},
-    {0x15, {0x15, 0x15, 0x15}},
-    {0x1b, {0x1b, 0x1b, 0x1b}},
-    {0x20, {0x20, 0x20, 0x20}},
+    const std::unordered_map<size_t, std::array<uint8_t, 3>> CODES = {
+        {0x7f, {0x7f, 0x7f, 0x7f}}, {0x08, {0x08, 0x08, 0x08}}, {0x09, {0x09, 0x09, 0x09}}, {0x0a, {0x0a, 0x0a, 0x0a}},
+        {0x0b, {0x0b, 0x0b, 0x0b}}, {0x0d, {0x0d, 0x0d, 0x0d}}, {0x15, {0x15, 0x15, 0x15}}, {0x1b, {0x1b, 0x1b, 0x1b}},
+        {0x20, {0x20, 0x20, 0x20}},
 
-    {0x27, {0x27, 0x22, 0x22}},
-    {0x2c, {0x2c, 0x3c, 0x3c}},
-    {0x2d, {0x1f, 0x5f, 0x1f}},
-    {0x2e, {0x2e, 0x3e, 0x3e}},
-    {0x2f, {0x2f, 0x3f, 0x3f}},
-    {0x30, {0x30, 0x29, 0x29}},
-    {0x31, {0x31, 0x21, 0x21}},
-    {0x32, {0x00, 0x40, 0x00}},
-    {0x33, {0x33, 0x23, 0x23}},
-    {0x34, {0x34, 0x24, 0x24}},
-    {0x35, {0x35, 0x25, 0x25}},
-    {0x36, {0x1e, 0x5e, 0x1e}},
-    {0x37, {0x37, 0x26, 0x26}},
-    {0x38, {0x38, 0x2a, 0x2a}},
-    {0x39, {0x39, 0x28, 0x28}},
-    {0x3b, {0x3b, 0x3a, 0x3a}},
-    {0x3d, {0x3d, 0x2b, 0x2b}},
+        {0x27, {0x27, 0x22, 0x22}}, {0x2c, {0x2c, 0x3c, 0x3c}}, {0x2d, {0x1f, 0x5f, 0x1f}}, {0x2e, {0x2e, 0x3e, 0x3e}},
+        {0x2f, {0x2f, 0x3f, 0x3f}}, {0x30, {0x30, 0x29, 0x29}}, {0x31, {0x31, 0x21, 0x21}}, {0x32, {0x00, 0x40, 0x00}},
+        {0x33, {0x33, 0x23, 0x23}}, {0x34, {0x34, 0x24, 0x24}}, {0x35, {0x35, 0x25, 0x25}}, {0x36, {0x1e, 0x5e, 0x1e}},
+        {0x37, {0x37, 0x26, 0x26}}, {0x38, {0x38, 0x2a, 0x2a}}, {0x39, {0x39, 0x28, 0x28}}, {0x3b, {0x3b, 0x3a, 0x3a}},
+        {0x3d, {0x3d, 0x2b, 0x2b}},
 
-    {0x5b, {0x1b, 0x7b, 0x1b}},
-    {0x5c, {0x1c, 0x7c, 0x1c}},
-    {0x5d, {0x1d, 0x7d, 0x1d}},
-    {0x60, {0x60, 0x7e, 0x7e}},
-  };
+        {0x5b, {0x1b, 0x7b, 0x1b}}, {0x5c, {0x1c, 0x7c, 0x1c}}, {0x5d, {0x1d, 0x7d, 0x1d}}, {0x60, {0x60, 0x7e, 0x7e}},
+    };
 }
 
 namespace ra2
 {
-  bool getApple2Character(size_t keycode, bool ctrl, bool shift, uint8_t & out)
-  {
-    const auto it = CODES.find(keycode);
-    if (it == CODES.end())
+    bool getApple2Character(size_t keycode, bool ctrl, bool shift, uint8_t &out)
     {
-      return false;
+        const auto it = CODES.find(keycode);
+        if (it == CODES.end())
+        {
+            return false;
+        }
+        else
+        {
+            size_t pos = 0;
+            if (ctrl)
+                pos += 1;
+            if (shift)
+                pos += 2;
+            if (pos == 0)
+            {
+                out = it->first;
+            }
+            else
+            {
+                out = it->second[pos - 1];
+            }
+            return true;
+        }
     }
-    else
-    {
-      size_t pos = 0;
-      if (ctrl) pos += 1;
-      if (shift) pos += 2;
-      if (pos == 0)
-      {
-        out = it->first;
-      }
-      else
-      {
-        out = it->second[pos - 1];
-      }
-      return true;
-    }
-  }
 
-}
+} // namespace ra2
diff --git a/source/frontends/libretro/rkeyboard.h b/source/frontends/libretro/rkeyboard.h
index d4fd6be90..08a964cf9 100644
--- a/source/frontends/libretro/rkeyboard.h
+++ b/source/frontends/libretro/rkeyboard.h
@@ -5,6 +5,10 @@
 
 namespace ra2
 {
-  enum class KeyboardType { ASCII, Original };
-  bool getApple2Character(size_t keycode, bool shift, bool ctrl, uint8_t & out);
-}
+    enum class KeyboardType
+    {
+        ASCII,
+        Original
+    };
+    bool getApple2Character(size_t keycode, bool shift, bool ctrl, uint8_t &out);
+} // namespace ra2
diff --git a/source/frontends/libretro/serialisation.cpp b/source/frontends/libretro/serialisation.cpp
index 47fb835f5..545af1036 100644
--- a/source/frontends/libretro/serialisation.cpp
+++ b/source/frontends/libretro/serialisation.cpp
@@ -10,114 +10,114 @@
 
 namespace
 {
-  class AutoFile
-  {
-  public:
-    AutoFile();
-    ~AutoFile();
+    class AutoFile
+    {
+    public:
+        AutoFile();
+        ~AutoFile();
 
-    const std::string & getFilename() const;  // only if true
+        const std::string &getFilename() const; // only if true
 
-  protected:
-    int myFD;
-    std::string myFilename;
-  };
+    protected:
+        int myFD;
+        std::string myFilename;
+    };
 
-  AutoFile::AutoFile()
-  {
+    AutoFile::AutoFile()
+    {
 #ifdef _WIN32
-    char pattern[] = "/tmp/awXXXXXX";
-    myFD = mkstemp(pattern);
+        char pattern[] = "/tmp/awXXXXXX";
+        myFD = mkstemp(pattern);
 #else
-    char pattern[] = "/tmp/awXXXXXX.aws.yaml";
-    myFD = mkstemps(pattern, 9);
+        char pattern[] = "/tmp/awXXXXXX.aws.yaml";
+        myFD = mkstemps(pattern, 9);
 #endif
-    if (myFD <= 0)
-    {
-      throw std::runtime_error("Cannot create temporary file");
+        if (myFD <= 0)
+        {
+            throw std::runtime_error("Cannot create temporary file");
+        }
+        myFilename = pattern;
     }
-    myFilename = pattern;
-  }
 
-  AutoFile::~AutoFile()
-  {
-    close(myFD);
-    std::remove(myFilename.c_str());
-  }
+    AutoFile::~AutoFile()
+    {
+        close(myFD);
+        std::remove(myFilename.c_str());
+    }
 
-  const std::string & AutoFile::getFilename() const
-  {
-    return myFilename;
-  }
+    const std::string &AutoFile::getFilename() const
+    {
+        return myFilename;
+    }
 
-  void saveToFile(const std::string & filename)  // cannot be null!
-  {
-    Snapshot_SetFilename(filename);
-    Snapshot_SaveState();
-  }
+    void saveToFile(const std::string &filename) // cannot be null!
+    {
+        Snapshot_SetFilename(filename);
+        Snapshot_SaveState();
+    }
 
-}
+} // namespace
 
 namespace ra2
 {
 
-  size_t RetroSerialisation::getSize()
-  {
-    AutoFile autoFile;
-    std::string const & filename = autoFile.getFilename();
-    saveToFile(filename);
-    std::ifstream ifs(filename, std::ios::binary | std::ios::ate);
-
-    const size_t fileSize = ifs.tellg();
-    // we add a buffer to include a few things
-    // DiscControl images
-    // various sizes
-    // small variations in AW yaml format
-    const size_t buffer = 4096;
-    return fileSize + buffer;
-  }
-
-  void RetroSerialisation::serialise(void * data, size_t size, const DiskControl & diskControl)
-  {
-    Buffer buffer(reinterpret_cast<char *>(data), size);
-    diskControl.serialise(buffer);
-
-    AutoFile autoFile;
-    std::string const & filename = autoFile.getFilename();
-    saveToFile(filename);
-    std::ifstream ifs(filename, std::ios::binary | std::ios::ate);
-
-    size_t const fileSize = ifs.tellg();
-    buffer.get<size_t>() = fileSize;
-
-    char * begin, * end;
-    buffer.get(fileSize, begin, end);
-
-    ifs.seekg(0, std::ios::beg);
-    ifs.read(begin, end - begin);
-  }
-
-  void RetroSerialisation::deserialise(const void * data, size_t size, DiskControl & diskControl)
-  {
-    Buffer buffer(reinterpret_cast<const char *>(data), size);
-    diskControl.deserialise(buffer);
-
-    const size_t fileSize = buffer.get<size_t const>();
-
-    AutoFile autoFile;
-    std::string const & filename = autoFile.getFilename();
-    // do not remove the {} scope below! it ensures the file is flushed
+    size_t RetroSerialisation::getSize()
     {
-      char const * begin, * end;
-      buffer.get(fileSize, begin, end);
-      std::ofstream ofs(filename, std::ios::binary);
-      ofs.write(begin, end - begin);
+        AutoFile autoFile;
+        std::string const &filename = autoFile.getFilename();
+        saveToFile(filename);
+        std::ifstream ifs(filename, std::ios::binary | std::ios::ate);
+
+        const size_t fileSize = ifs.tellg();
+        // we add a buffer to include a few things
+        // DiscControl images
+        // various sizes
+        // small variations in AW yaml format
+        const size_t buffer = 4096;
+        return fileSize + buffer;
     }
 
-    // bit of a workaround, since the state files do not have full disk paths
-    SetCurrentDirectory(diskControl.getCurrentDiskFolder().c_str());
-    Snapshot_SetFilename(filename);
-    Snapshot_LoadState();
-  }
+    void RetroSerialisation::serialise(void *data, size_t size, const DiskControl &diskControl)
+    {
+        Buffer buffer(reinterpret_cast<char *>(data), size);
+        diskControl.serialise(buffer);
+
+        AutoFile autoFile;
+        std::string const &filename = autoFile.getFilename();
+        saveToFile(filename);
+        std::ifstream ifs(filename, std::ios::binary | std::ios::ate);
+
+        size_t const fileSize = ifs.tellg();
+        buffer.get<size_t>() = fileSize;
+
+        char *begin, *end;
+        buffer.get(fileSize, begin, end);
+
+        ifs.seekg(0, std::ios::beg);
+        ifs.read(begin, end - begin);
+    }
+
+    void RetroSerialisation::deserialise(const void *data, size_t size, DiskControl &diskControl)
+    {
+        Buffer buffer(reinterpret_cast<const char *>(data), size);
+        diskControl.deserialise(buffer);
+
+        const size_t fileSize = buffer.get<size_t const>();
+
+        AutoFile autoFile;
+        std::string const &filename = autoFile.getFilename();
+        // do not remove the {} scope below! it ensures the file is flushed
+        {
+            char const *begin, *end;
+            buffer.get(fileSize, begin, end);
+            std::ofstream ofs(filename, std::ios::binary);
+            ofs.write(begin, end - begin);
+        }
+
+        // bit of a workaround, since the state files do not have full disk paths
+        SetCurrentDirectory(diskControl.getCurrentDiskFolder().c_str());
+        Snapshot_SetFilename(filename);
+        Snapshot_LoadState();
+    }
 
-}
+} // namespace ra2
diff --git a/source/frontends/libretro/serialisation.h b/source/frontends/libretro/serialisation.h
index c222b8523..16cefcee8 100644
--- a/source/frontends/libretro/serialisation.h
+++ b/source/frontends/libretro/serialisation.h
@@ -3,14 +3,14 @@
 namespace ra2
 {
 
-  class DiskControl;
+    class DiskControl;
 
-  class RetroSerialisation
-  {
-  public:
-    static size_t getSize();
-    static void serialise(void * data, size_t size, const DiskControl & diskControl);
-    static void deserialise(const void * data, size_t size, DiskControl & diskControl);
-  };
+    class RetroSerialisation
+    {
+    public:
+        static size_t getSize();
+        static void serialise(void *data, size_t size, const DiskControl &diskControl);
+        static void deserialise(const void *data, size_t size, DiskControl &diskControl);
+    };
 
-}
+} // namespace ra2
diff --git a/source/frontends/ncurses/asciiart.cpp b/source/frontends/ncurses/asciiart.cpp
index cabbb4f43..2b74763ea 100644
--- a/source/frontends/ncurses/asciiart.cpp
+++ b/source/frontends/ncurses/asciiart.cpp
@@ -6,226 +6,227 @@
 namespace na2
 {
 
-  ASCIIArt::Unicode::Unicode(const char * aC, Blocks aValues)
-    : c(aC), values(aValues)
-  {
-  }
-
-  const int ASCIIArt::PPQ = 8 * (2 * 7) / 4;
-
-  ASCIIArt::ASCIIArt() : myRows(0), myColumns(0)
-  {
-    myGlyphs.push_back(Unicode("\u2580", {PPQ, PPQ,   0,   0}));  // top half
-    myGlyphs.push_back(Unicode("\u258C", {PPQ,   0, PPQ,   0}));  // left half
-    myGlyphs.push_back(Unicode("\u2596", {  0,   0, PPQ,   0}));  // lower left
-    myGlyphs.push_back(Unicode("\u2597", {  0,   0,   0, PPQ}));  // lower right
-    myGlyphs.push_back(Unicode("\u2598", {PPQ,   0,   0,   0}));  // top left
-    myGlyphs.push_back(Unicode("\u259A", {PPQ,   0,   0, PPQ}));  // diagonal
-    myGlyphs.push_back(Unicode("\u259D", {  0, PPQ,   0,   0}));  // top right
-
-    myBlocks.resize(128);
-
-    init(1, 1); // normal size
-  }
-
-  void ASCIIArt::init(const int rows, const int columns)
-  {
-    if (myRows != rows || myColumns != columns)
+    ASCIIArt::Unicode::Unicode(const char *aC, Blocks aValues)
+        : c(aC)
+        , values(aValues)
     {
-      if (myColumns != columns)
-      {
-        myColumns = columns;
-        for (size_t i = 0; i < myBlocks.size(); ++i)
-        {
-          myBlocks[i] = decodeByte(i);
-        }
-      }
+    }
 
-      myRows = rows;
+    const int ASCIIArt::PPQ = 8 * (2 * 7) / 4;
 
-      myValues.resize(boost::extents[myRows][myColumns]);
-      myChars.resize(boost::extents[rows][columns]);
-    }
-  }
-
-  void ASCIIArt::changeColumns(const int x)
-  {
-    int newColumns = myColumns + x;
-    newColumns = std::max(1, std::min(7, newColumns));
-    init(myRows, newColumns);
-  }
-
-  void ASCIIArt::changeRows(const int x)
-  {
-    int newRows = x > 0 ? myRows * 2 : myRows / 2;
-    newRows = std::max(1, std::min(4, newRows));
-    init(newRows, myColumns);
-  }
-
-  const ASCIIArt::array_char_t & ASCIIArt::getCharacters(const unsigned char * address)
-  {
-    const array_val_t & values = getQuadrantValues(address);
-    return getCharacters(values);
-  }
-
-  const ASCIIArt::array_val_t & ASCIIArt::getQuadrantValues(const unsigned char * address) const
-  {
-    std::fill(myValues.origin(), myValues.origin() + myValues.num_elements(), 0);
-
-    const int linesPerRow = 8 / myRows;
-    const int linesPerQuadrant = linesPerRow / 2;
-
-    // 8 lines per text character
-    for (size_t i = 0; i < 8; ++i)
+    ASCIIArt::ASCIIArt()
+        : myRows(0)
+        , myColumns(0)
     {
-      const int offset = 0x0400 * i;
-      // group color bit is ignored
-      const unsigned char value = (*(address + offset)) & 0x7f;
-
-      const int row = i / linesPerRow;
-      const int lineInRow = i % linesPerRow;
-      const int quadrant = lineInRow / linesPerQuadrant;
-      const int base = quadrant * 2;
-
-      const std::vector<Blocks> & decoded = myBlocks[value];
-
-      for (size_t col = 0; col < myColumns; ++col)
-      {
-        Blocks & blocks = myValues[row][col];
-        blocks.add(base + 0, decoded[col][0] * myRows);
-        blocks.add(base + 1, decoded[col][1] * myRows);
-      }
+        // clang-format off
+        myGlyphs.push_back(Unicode("\u2580", {PPQ, PPQ,   0,   0}));  // top half
+        myGlyphs.push_back(Unicode("\u258C", {PPQ,   0, PPQ,   0}));  // left half
+        myGlyphs.push_back(Unicode("\u2596", {  0,   0, PPQ,   0}));  // lower left
+        myGlyphs.push_back(Unicode("\u2597", {  0,   0,   0, PPQ}));  // lower right
+        myGlyphs.push_back(Unicode("\u2598", {PPQ,   0,   0,   0}));  // top left
+        myGlyphs.push_back(Unicode("\u259A", {PPQ,   0,   0, PPQ}));  // diagonal
+        myGlyphs.push_back(Unicode("\u259D", {  0, PPQ,   0,   0}));  // top right
+        // clang-format on
+
+        myBlocks.resize(128);
+
+        init(1, 1); // normal size
     }
 
-    return myValues;
-  }
-
-  std::vector<Blocks> ASCIIArt::decodeByte(const unsigned char value) const
-  {
-    const int each = myColumns * 4 * PPQ / (8 * 7);
-
-    int available = 7;
-    int col = 0;
-    int pos = 0; // left right
-
-    std::vector<Blocks> decoded(myColumns);
-
-    for (size_t j = 0; j < 7; ++j)
+    void ASCIIArt::init(const int rows, const int columns)
     {
-      int to_allocate = each;
-      do
-      {
-        const int here = std::min(available, to_allocate);
-        if (value & (1 << j))
-        {
-          decoded[col].add(pos, here);
-        }
-        to_allocate -= here;
-        available -= here;
-        if (available == 0)
+        if (myRows != rows || myColumns != columns)
         {
-          // new quadrant
-          available = 7;
-          ++pos;
-          if (pos == 2)
-          {
-            pos = 0;
-            ++col;
-          }
+            if (myColumns != columns)
+            {
+                myColumns = columns;
+                for (size_t i = 0; i < myBlocks.size(); ++i)
+                {
+                    myBlocks[i] = decodeByte(i);
+                }
+            }
+
+            myRows = rows;
+
+            myValues.resize(boost::extents[myRows][myColumns]);
+            myChars.resize(boost::extents[rows][columns]);
         }
-      }
-      while (to_allocate > 0);
     }
 
-    return decoded;
-  }
+    void ASCIIArt::changeColumns(const int x)
+    {
+        int newColumns = myColumns + x;
+        newColumns = std::max(1, std::min(7, newColumns));
+        init(myRows, newColumns);
+    }
 
-  const ASCIIArt::array_char_t & ASCIIArt::getCharacters(const array_val_t & values)
-  {
-    const int rows = values.shape()[0];
-    const int columns = values.shape()[1];
+    void ASCIIArt::changeRows(const int x)
+    {
+        int newRows = x > 0 ? myRows * 2 : myRows / 2;
+        newRows = std::max(1, std::min(4, newRows));
+        init(newRows, myColumns);
+    }
 
-    for (size_t i = 0; i < rows; ++i)
+    const ASCIIArt::array_char_t &ASCIIArt::getCharacters(const unsigned char *address)
     {
-      for (size_t j = 0; j < columns; ++j)
-      {
-        myChars[i][j] = getCharacter(values[i][j]);
-      }
+        const array_val_t &values = getQuadrantValues(address);
+        return getCharacters(values);
     }
 
-    return myChars;
-  }
+    const ASCIIArt::array_val_t &ASCIIArt::getQuadrantValues(const unsigned char *address) const
+    {
+        std::fill(myValues.origin(), myValues.origin() + myValues.num_elements(), 0);
+
+        const int linesPerRow = 8 / myRows;
+        const int linesPerQuadrant = linesPerRow / 2;
 
+        // 8 lines per text character
+        for (size_t i = 0; i < 8; ++i)
+        {
+            const int offset = 0x0400 * i;
+            // group color bit is ignored
+            const unsigned char value = (*(address + offset)) & 0x7f;
+
+            const int row = i / linesPerRow;
+            const int lineInRow = i % linesPerRow;
+            const int quadrant = lineInRow / linesPerQuadrant;
+            const int base = quadrant * 2;
+
+            const std::vector<Blocks> &decoded = myBlocks[value];
+
+            for (size_t col = 0; col < myColumns; ++col)
+            {
+                Blocks &blocks = myValues[row][col];
+                blocks.add(base + 0, decoded[col][0] * myRows);
+                blocks.add(base + 1, decoded[col][1] * myRows);
+            }
+        }
 
-  const ASCIIArt::Character & ASCIIArt::getCharacter(const Blocks & values)
-  {
-    const int zip = values.value;
+        return myValues;
+    }
 
-    const std::unordered_map<int, Character>::const_iterator it = myAsciiPixels.find(zip);
-    if (it == myAsciiPixels.end())
+    std::vector<Blocks> ASCIIArt::decodeByte(const unsigned char value) const
     {
-      Character & best = myAsciiPixels[zip];
-      best.error = DBL_MAX;
-
-      for (const Unicode & glyph: myGlyphs)
-      {
-        double foreground;
-        double background;
-        double error;
-        fit(values, glyph, foreground, background, error);
-        if (error < best.error)
+        const int each = myColumns * 4 * PPQ / (8 * 7);
+
+        int available = 7;
+        int col = 0;
+        int pos = 0; // left right
+
+        std::vector<Blocks> decoded(myColumns);
+
+        for (size_t j = 0; j < 7; ++j)
         {
-          best.error = error;
-          best.foreground = foreground;
-          best.background = background;
-          best.c = glyph.c;
+            int to_allocate = each;
+            do
+            {
+                const int here = std::min(available, to_allocate);
+                if (value & (1 << j))
+                {
+                    decoded[col].add(pos, here);
+                }
+                to_allocate -= here;
+                available -= here;
+                if (available == 0)
+                {
+                    // new quadrant
+                    available = 7;
+                    ++pos;
+                    if (pos == 2)
+                    {
+                        pos = 0;
+                        ++col;
+                    }
+                }
+            } while (to_allocate > 0);
         }
-      }
 
-      return best;
+        return decoded;
     }
-    else
+
+    const ASCIIArt::array_char_t &ASCIIArt::getCharacters(const array_val_t &values)
     {
-      return it->second;
+        const int rows = values.shape()[0];
+        const int columns = values.shape()[1];
+
+        for (size_t i = 0; i < rows; ++i)
+        {
+            for (size_t j = 0; j < columns; ++j)
+            {
+                myChars[i][j] = getCharacter(values[i][j]);
+            }
+        }
+
+        return myChars;
     }
 
-  }
+    const ASCIIArt::Character &ASCIIArt::getCharacter(const Blocks &values)
+    {
+        const int zip = values.value;
 
-  void ASCIIArt::fit(const Blocks & art, const Unicode & glyph,
-                     double & foreground, double & background, double & error)
-  {
-    int num_fg = 0;
-    int num_bg = 0;
-    int den_fg = 0;
-    int den_bg = 0;
+        const std::unordered_map<int, Character>::const_iterator it = myAsciiPixels.find(zip);
+        if (it == myAsciiPixels.end())
+        {
+            Character &best = myAsciiPixels[zip];
+            best.error = DBL_MAX;
+
+            for (const Unicode &glyph : myGlyphs)
+            {
+                double foreground;
+                double background;
+                double error;
+                fit(values, glyph, foreground, background, error);
+                if (error < best.error)
+                {
+                    best.error = error;
+                    best.foreground = foreground;
+                    best.background = background;
+                    best.c = glyph.c;
+                }
+            }
+
+            return best;
+        }
+        else
+        {
+            return it->second;
+        }
+    }
 
-    for (size_t i = 0; i < art.size(); ++i)
+    void ASCIIArt::fit(const Blocks &art, const Unicode &glyph, double &foreground, double &background, double &error)
     {
-      const double f = glyph.values[i];
-      const double b = PPQ - f;
+        int num_fg = 0;
+        int num_bg = 0;
+        int den_fg = 0;
+        int den_bg = 0;
 
-      num_fg += art[i] * f;
-      den_fg += f * f;
+        for (size_t i = 0; i < art.size(); ++i)
+        {
+            const double f = glyph.values[i];
+            const double b = PPQ - f;
 
-      num_bg += art[i] * b;
-      den_bg += b * b;
-    }
+            num_fg += art[i] * f;
+            den_fg += f * f;
 
-    // close formula to minimise the L2 norm of the difference
-    // of grey intensity
-    foreground = double(num_fg) / double(den_fg);
-    background = double(num_bg) / double(den_bg);
+            num_bg += art[i] * b;
+            den_bg += b * b;
+        }
 
-    error = 0.0;
-    for (size_t i = 0; i < art.size(); ++i)
-    {
-      const double f = glyph.values[i];
-      const double b = PPQ - f;
+        // close formula to minimise the L2 norm of the difference
+        // of grey intensity
+        foreground = double(num_fg) / double(den_fg);
+        background = double(num_bg) / double(den_bg);
 
-      const double g = foreground * f + background * b;
-      const double e = art[i] - g;
-      error += e * e;
+        error = 0.0;
+        for (size_t i = 0; i < art.size(); ++i)
+        {
+            const double f = glyph.values[i];
+            const double b = PPQ - f;
+
+            const double g = foreground * f + background * b;
+            const double e = art[i] - g;
+            error += e * e;
+        }
     }
-  }
 
-}
+} // namespace na2
diff --git a/source/frontends/ncurses/asciiart.h b/source/frontends/ncurses/asciiart.h
index ec3303af5..a02fa9439 100644
--- a/source/frontends/ncurses/asciiart.h
+++ b/source/frontends/ncurses/asciiart.h
@@ -8,99 +8,99 @@
 namespace na2
 {
 
-  struct Blocks
-  {
-    Blocks() : value(0) { }
-
-    Blocks(std::initializer_list<int> q)
-    {
-      value = 0;
-      for (auto it = rbegin(q); it != rend(q); ++it)
-      {
-        value <<= 5;
-        value += *it;
-      }
-    }
-
-    void add(int i, int val)
+    struct Blocks
     {
-      value += val << (i * 5);
-    }
+        Blocks()
+            : value(0)
+        {
+        }
+
+        Blocks(std::initializer_list<int> q)
+        {
+            value = 0;
+            for (auto it = rbegin(q); it != rend(q); ++it)
+            {
+                value <<= 5;
+                value += *it;
+            }
+        }
+
+        void add(int i, int val)
+        {
+            value += val << (i * 5);
+        }
+
+        int operator[](int i) const
+        {
+            const int val = (value >> (i * 5)) & 0b11111;
+            return val;
+        }
+
+        Blocks &operator=(const int val)
+        {
+            value = val;
+            return *this;
+        }
+
+        size_t size() const
+        {
+            return 4;
+        }
+
+        int value;
+    };
 
-    int operator[](int i) const
+    class ASCIIArt
     {
-      const int val = (value >> (i * 5)) & 0b11111;
-      return val;
-    }
+    public:
+        ASCIIArt();
 
-    Blocks & operator=(const int val)
-    {
-      value = val;
-      return *this;
-    }
+        struct Character
+        {
+            const char *c;
+            double foreground;
+            double background;
+            double error;
+        };
 
-    size_t size() const
-    {
-      return 4;
-    }
+        typedef boost::multi_array<Character, 2> array_char_t;
+        typedef boost::multi_array<Blocks, 2> array_val_t;
 
-    int value;
-  };
+        void init(const int rows, const int columns);
 
+        void changeColumns(const int x);
+        void changeRows(const int x);
 
-  class ASCIIArt
-  {
-  public:
-    ASCIIArt();
+        const array_char_t &getCharacters(const unsigned char *address);
+        const array_char_t &getCharacters(const array_val_t &values);
+        const array_val_t &getQuadrantValues(const unsigned char *address) const;
+        std::vector<Blocks> decodeByte(const unsigned char value) const;
 
-    struct Character
-    {
-      const char * c;
-      double foreground;
-      double background;
-      double error;
-    };
+    private:
+        static const int PPQ; // Pixels per Quadrant
 
-    typedef boost::multi_array<Character, 2> array_char_t;
-    typedef boost::multi_array<Blocks, 2> array_val_t;
+        std::unordered_map<int, Character> myAsciiPixels;
 
-    void init(const int rows, const int columns);
+        struct Unicode
+        {
+            Unicode(const char *aC, Blocks aValues);
 
-    void changeColumns(const int x);
-    void changeRows(const int x);
+            const char *c;
+            Blocks values; // foreground: top left - top right - bottom left - bottom right
+        };
 
-    const array_char_t & getCharacters(const unsigned char * address);
-    const array_char_t & getCharacters(const array_val_t & values);
-    const array_val_t & getQuadrantValues(const unsigned char * address) const;
-    std::vector<Blocks> decodeByte(const unsigned char value) const;
+        int myRows;
+        int myColumns;
 
-  private:
-    static const int PPQ; // Pixels per Quadrant
+        std::vector<Unicode> myGlyphs;
 
-    std::unordered_map<int, Character> myAsciiPixels;
+        std::vector<std::vector<Blocks>> myBlocks;
 
-    struct Unicode
-    {
-      Unicode(const char * aC, Blocks aValues);
+        mutable array_val_t myValues; // workspace
+        array_char_t myChars;         // workspace
 
-      const char * c;
-      Blocks values; // foreground: top left - top right - bottom left - bottom right
+        const Character &getCharacter(const Blocks &values);
+        static void fit(const Blocks &art, const Unicode &glyph, double &foreground, double &background, double &error);
     };
 
-    int myRows;
-    int myColumns;
-
-    std::vector<Unicode> myGlyphs;
-
-    std::vector<std::vector<Blocks>> myBlocks;
-
-    mutable array_val_t myValues; // workspace
-    array_char_t myChars; // workspace
-
-    const Character & getCharacter(const Blocks & values);
-    static void fit(const Blocks & art, const Unicode & glyph,
-                    double & foreground, double & background, double & error);
-
-  };
-
-}
+} // namespace na2
diff --git a/source/frontends/ncurses/colors.cpp b/source/frontends/ncurses/colors.cpp
index 488015197..d665355a4 100644
--- a/source/frontends/ncurses/colors.cpp
+++ b/source/frontends/ncurses/colors.cpp
@@ -5,125 +5,127 @@
 
 namespace
 {
-  enum Color {
-              BLACK,
-              DEEP_RED,
-              DARK_BLUE,
-              MAGENTA,
-              DARK_GREEN,
-              DARK_GRAY,
-              BLUE,
-              LIGHT_BLUE,
-              BROWN,
-              ORANGE,
-              LIGHT_GRAY,
-              PINK,
-              GREEN,
-              YELLOW,
-              AQUA,
-              WHITE
-  };
-
-  // input 0..255
-  // output 0..1000
-  int scaleRGB(int rgb)
-  {
-    return rgb * 1000 / 255;
-  }
-}
+    enum Color
+    {
+        BLACK,
+        DEEP_RED,
+        DARK_BLUE,
+        MAGENTA,
+        DARK_GREEN,
+        DARK_GRAY,
+        BLUE,
+        LIGHT_BLUE,
+        BROWN,
+        ORANGE,
+        LIGHT_GRAY,
+        PINK,
+        GREEN,
+        YELLOW,
+        AQUA,
+        WHITE
+    };
+
+    // input 0..255
+    // output 0..1000
+    int scaleRGB(int rgb)
+    {
+        return rgb * 1000 / 255;
+    }
+} // namespace
 
 #define SETFRAMECOLOR(c, r, g, b) init_color(firstColor + Color::c, scaleRGB(r), scaleRGB(g), scaleRGB(b));
 
 namespace na2
 {
 
-  GraphicsColors::GraphicsColors(const int firstColor, const int firstPair, const int numberOfGreys)
-    : myNumberOfGRColors(16), myNumberOfGreys(numberOfGreys)
-  {
-    has_colors();
-    start_color();
-    can_change_color();
-
-    SETFRAMECOLOR(BLACK,       0x00,0x00,0x00); // 0
-    SETFRAMECOLOR(DEEP_RED,  0x9D,0x09,0x66); // 0xD0,0x00,0x30 -> Linards Tweaked 0x9D,0x09,0x66
-    SETFRAMECOLOR(DARK_BLUE,   0x00,0x00,0x80); // 4 // not used
-    SETFRAMECOLOR(MAGENTA,     0xC7,0x34,0xFF); // FD Linards Tweaked 0xFF,0x00,0xFF -> 0xC7,0x34,0xFF
-
-    SETFRAMECOLOR(DARK_GREEN,  0x00,0x80,0x00); // 2 // not used
-    SETFRAMECOLOR(DARK_GRAY,   0x80,0x80,0x80); // F8
-    SETFRAMECOLOR(BLUE,        0x0D,0xA1,0xFF); // FC Linards Tweaked 0x00,0x00,0xFF -> 0x0D,0xA1,0xFF
-    SETFRAMECOLOR(LIGHT_BLUE,0xAA,0xAA,0xFF); // 0x60,0xA0,0xFF -> Linards Tweaked 0xAA,0xAA,0xFF
-
-    SETFRAMECOLOR(BROWN,     0x55,0x55,0x00); // 0x80,0x50,0x00 -> Linards Tweaked 0x55,0x55,0x00
-    SETFRAMECOLOR(ORANGE,    0xF2,0x5E,0x00); // 0xFF,0x80,0x00 -> Linards Tweaked 0xF2,0x5E,0x00
-    SETFRAMECOLOR(LIGHT_GRAY,  0xC0,0xC0,0xC0); // 7 // GR: COLOR=10
-    SETFRAMECOLOR(PINK,      0xFF,0x89,0xE5); // 0xFF,0x90,0x80 -> Linards Tweaked 0xFF,0x89,0xE5
-
-    SETFRAMECOLOR(GREEN,       0x38,0xCB,0x00); // FA Linards Tweaked 0x00,0xFF,0x00 -> 0x38,0xCB,0x00
-    SETFRAMECOLOR(YELLOW,      0xD5,0xD5,0x1A); // FB Linards Tweaked 0xFF,0xFF,0x00 -> 0xD5,0xD5,0x1A
-    SETFRAMECOLOR(AQUA,      0x62,0xF6,0x99); // 0x40,0xFF,0x90 -> Linards Tweaked 0x62,0xF6,0x99
-    SETFRAMECOLOR(WHITE,       0xFF,0xFF,0xFF); // FF
-
-    int baseColor = firstColor;
-    int basePair = firstPair;
-    myFirstGRPair = basePair;
-
-    for (size_t i = 0; i < myNumberOfGRColors; ++i)
-    {
-      const int fg = firstColor + i;
-      for (size_t j = 0; j < myNumberOfGRColors; ++j)
-      {
-        const int bg = firstColor + j;
-        const int pair = myFirstGRPair + i * myNumberOfGRColors + j;
-
-        init_pair(pair, fg, bg);
-      }
-    }
-
-    baseColor += myNumberOfGRColors;
-    basePair += myNumberOfGRColors * myNumberOfGRColors;
-    myFirstHGRPair = basePair;
-
-    for (size_t i = 0; i < myNumberOfGreys; ++i)
+    GraphicsColors::GraphicsColors(const int firstColor, const int firstPair, const int numberOfGreys)
+        : myNumberOfGRColors(16)
+        , myNumberOfGreys(numberOfGreys)
     {
-      const int color = baseColor + i;
-      const int grey = 1000 * i / (myNumberOfGreys - 1);
-      init_color(color, grey, grey, grey);
+        has_colors();
+        start_color();
+        can_change_color();
+
+        SETFRAMECOLOR(BLACK, 0x00, 0x00, 0x00);     // 0
+        SETFRAMECOLOR(DEEP_RED, 0x9D, 0x09, 0x66);  // 0xD0,0x00,0x30 -> Linards Tweaked 0x9D,0x09,0x66
+        SETFRAMECOLOR(DARK_BLUE, 0x00, 0x00, 0x80); // 4 // not used
+        SETFRAMECOLOR(MAGENTA, 0xC7, 0x34, 0xFF);   // FD Linards Tweaked 0xFF,0x00,0xFF -> 0xC7,0x34,0xFF
+
+        SETFRAMECOLOR(DARK_GREEN, 0x00, 0x80, 0x00); // 2 // not used
+        SETFRAMECOLOR(DARK_GRAY, 0x80, 0x80, 0x80);  // F8
+        SETFRAMECOLOR(BLUE, 0x0D, 0xA1, 0xFF);       // FC Linards Tweaked 0x00,0x00,0xFF -> 0x0D,0xA1,0xFF
+        SETFRAMECOLOR(LIGHT_BLUE, 0xAA, 0xAA, 0xFF); // 0x60,0xA0,0xFF -> Linards Tweaked 0xAA,0xAA,0xFF
+
+        SETFRAMECOLOR(BROWN, 0x55, 0x55, 0x00);      // 0x80,0x50,0x00 -> Linards Tweaked 0x55,0x55,0x00
+        SETFRAMECOLOR(ORANGE, 0xF2, 0x5E, 0x00);     // 0xFF,0x80,0x00 -> Linards Tweaked 0xF2,0x5E,0x00
+        SETFRAMECOLOR(LIGHT_GRAY, 0xC0, 0xC0, 0xC0); // 7 // GR: COLOR=10
+        SETFRAMECOLOR(PINK, 0xFF, 0x89, 0xE5);       // 0xFF,0x90,0x80 -> Linards Tweaked 0xFF,0x89,0xE5
+
+        SETFRAMECOLOR(GREEN, 0x38, 0xCB, 0x00);  // FA Linards Tweaked 0x00,0xFF,0x00 -> 0x38,0xCB,0x00
+        SETFRAMECOLOR(YELLOW, 0xD5, 0xD5, 0x1A); // FB Linards Tweaked 0xFF,0xFF,0x00 -> 0xD5,0xD5,0x1A
+        SETFRAMECOLOR(AQUA, 0x62, 0xF6, 0x99);   // 0x40,0xFF,0x90 -> Linards Tweaked 0x62,0xF6,0x99
+        SETFRAMECOLOR(WHITE, 0xFF, 0xFF, 0xFF);  // FF
+
+        int baseColor = firstColor;
+        int basePair = firstPair;
+        myFirstGRPair = basePair;
+
+        for (size_t i = 0; i < myNumberOfGRColors; ++i)
+        {
+            const int fg = firstColor + i;
+            for (size_t j = 0; j < myNumberOfGRColors; ++j)
+            {
+                const int bg = firstColor + j;
+                const int pair = myFirstGRPair + i * myNumberOfGRColors + j;
+
+                init_pair(pair, fg, bg);
+            }
+        }
+
+        baseColor += myNumberOfGRColors;
+        basePair += myNumberOfGRColors * myNumberOfGRColors;
+        myFirstHGRPair = basePair;
+
+        for (size_t i = 0; i < myNumberOfGreys; ++i)
+        {
+            const int color = baseColor + i;
+            const int grey = 1000 * i / (myNumberOfGreys - 1);
+            init_color(color, grey, grey, grey);
+        }
+
+        for (size_t i = 0; i < myNumberOfGreys; ++i)
+        {
+            const int fg = baseColor + i;
+            for (size_t j = 0; j < myNumberOfGreys; ++j)
+            {
+                const int bg = baseColor + j;
+                const int pair = basePair + i * myNumberOfGreys + j;
+
+                init_pair(pair, fg, bg);
+            }
+        }
     }
 
-    for (size_t i = 0; i < myNumberOfGreys; ++i)
+    int GraphicsColors::getPair(int color) const
     {
-      const int fg = baseColor + i;
-      for (size_t j = 0; j < myNumberOfGreys; ++j)
-      {
-        const int bg = baseColor + j;
-        const int pair = basePair + i * myNumberOfGreys + j;
-
-        init_pair(pair, fg, bg);
-      }
-    }
-  }
-
-  int GraphicsColors::getPair(int color) const
-  {
-    const int fg = color & 0x0f;
-    const int bg = color >> 4;
+        const int fg = color & 0x0f;
+        const int bg = color >> 4;
 
-    const int pair = myFirstGRPair + fg * myNumberOfGRColors + bg;
+        const int pair = myFirstGRPair + fg * myNumberOfGRColors + bg;
 
-    return pair;
-  }
+        return pair;
+    }
 
-  int GraphicsColors::getGrey(double foreground, double background) const
-  {
-    const int fg = std::nearbyint((myNumberOfGreys - 1) * foreground);
-    const int bg = std::nearbyint((myNumberOfGreys - 1) * background);
+    int GraphicsColors::getGrey(double foreground, double background) const
+    {
+        const int fg = std::nearbyint((myNumberOfGreys - 1) * foreground);
+        const int bg = std::nearbyint((myNumberOfGreys - 1) * background);
 
-    const int basePair = myFirstHGRPair;
+        const int basePair = myFirstHGRPair;
 
-    const int pair = basePair + fg * myNumberOfGreys + bg;
+        const int pair = basePair + fg * myNumberOfGreys + bg;
 
-    return pair;
-  }
+        return pair;
+    }
 
-}
+} // namespace na2
diff --git a/source/frontends/ncurses/colors.h b/source/frontends/ncurses/colors.h
index 93d21cef0..92e7e903b 100644
--- a/source/frontends/ncurses/colors.h
+++ b/source/frontends/ncurses/colors.h
@@ -3,21 +3,20 @@
 namespace na2
 {
 
-  class GraphicsColors
-  {
-  public:
-    GraphicsColors(const int firstColor, const int firstPair, const int numberOfGreys);
+    class GraphicsColors
+    {
+    public:
+        GraphicsColors(const int firstColor, const int firstPair, const int numberOfGreys);
 
-    int getPair(int color) const;
-    int getGrey(double foreground, double background) const;
+        int getPair(int color) const;
+        int getGrey(double foreground, double background) const;
 
-  private:
-    int myFirstGRPair;
-    int myFirstHGRPair;
+    private:
+        int myFirstGRPair;
+        int myFirstHGRPair;
 
-    const int myNumberOfGRColors;
-    const int myNumberOfGreys;
+        const int myNumberOfGRColors;
+        const int myNumberOfGreys;
+    };
 
-  };
-
-}
+} // namespace na2
diff --git a/source/frontends/ncurses/evdevpaddle.cpp b/source/frontends/ncurses/evdevpaddle.cpp
index fe9687717..c999f6969 100644
--- a/source/frontends/ncurses/evdevpaddle.cpp
+++ b/source/frontends/ncurses/evdevpaddle.cpp
@@ -14,109 +14,112 @@
 namespace na2
 {
 
-  EvDevPaddle::EvDevPaddle(const std::string & device)
-    : myFD(0), myButtonCodes(2), myAxisCodes(2), myAxisMins(2), myAxisMaxs(2)
-  {
-#ifndef _WIN32
-    myFD = open(device.c_str(), O_RDONLY | O_NONBLOCK);
-    if (myFD > 0)
+    EvDevPaddle::EvDevPaddle(const std::string &device)
+        : myFD(0)
+        , myButtonCodes(2)
+        , myAxisCodes(2)
+        , myAxisMins(2)
+        , myAxisMaxs(2)
     {
-      libevdev * dev;
-      int rc = libevdev_new_from_fd(myFD, &dev);
-      if (rc < 0)
-      {
-        LogFileOutput("Input: failed to init libevdev (%s): %s\n", strerror(-rc), device.c_str());
-      }
-      else
-      {
-        myDev.reset(dev, libevdev_free);
-
-        myName = libevdev_get_name(dev);
-
-        myButtonCodes[0] = BTN_SOUTH;
-        myButtonCodes[1] = BTN_EAST;
-        myAxisCodes[0] = ABS_X;
-        myAxisCodes[1] = ABS_Y;
-
-        for (size_t i = 0; i < myAxisCodes.size(); ++i)
+#ifndef _WIN32
+        myFD = open(device.c_str(), O_RDONLY | O_NONBLOCK);
+        if (myFD > 0)
         {
-          myAxisMins[i] = libevdev_get_abs_minimum(dev, myAxisCodes[i]);
-          myAxisMaxs[i] = libevdev_get_abs_maximum(dev, myAxisCodes[i]);
+            libevdev *dev;
+            int rc = libevdev_new_from_fd(myFD, &dev);
+            if (rc < 0)
+            {
+                LogFileOutput("Input: failed to init libevdev (%s): %s\n", strerror(-rc), device.c_str());
+            }
+            else
+            {
+                myDev.reset(dev, libevdev_free);
+
+                myName = libevdev_get_name(dev);
+
+                myButtonCodes[0] = BTN_SOUTH;
+                myButtonCodes[1] = BTN_EAST;
+                myAxisCodes[0] = ABS_X;
+                myAxisCodes[1] = ABS_Y;
+
+                for (size_t i = 0; i < myAxisCodes.size(); ++i)
+                {
+                    myAxisMins[i] = libevdev_get_abs_minimum(dev, myAxisCodes[i]);
+                    myAxisMaxs[i] = libevdev_get_abs_maximum(dev, myAxisCodes[i]);
+                }
+            }
+        }
+        else
+        {
+            LogFileOutput("Input: failed to open device (%s): %s\n", strerror(errno), device.c_str());
         }
-      }
-    }
-    else
-    {
-      LogFileOutput("Input: failed to open device (%s): %s\n", strerror(errno), device.c_str());
-    }
 #endif
-  }
+    }
 
-  EvDevPaddle::~EvDevPaddle()
-  {
-    if (myFD > 0)
+    EvDevPaddle::~EvDevPaddle()
     {
-      close(myFD);
+        if (myFD > 0)
+        {
+            close(myFD);
+        }
     }
-  }
 
-  int EvDevPaddle::poll()
-  {
-    int counter = 0;
-    if (!myDev)
+    int EvDevPaddle::poll()
     {
-      return counter;
-    }
+        int counter = 0;
+        if (!myDev)
+        {
+            return counter;
+        }
 
 #ifndef _WIN32
-    input_event ev;
-    int rc = LIBEVDEV_READ_STATUS_SUCCESS;
-    do
-    {
-      if (rc == LIBEVDEV_READ_STATUS_SYNC)
-        rc = libevdev_next_event(myDev.get(), LIBEVDEV_READ_FLAG_SYNC, &ev);
-      else
-        rc = libevdev_next_event(myDev.get(), LIBEVDEV_READ_FLAG_NORMAL, &ev);
-      ++counter;
-    } while (rc >= 0);
+        input_event ev;
+        int rc = LIBEVDEV_READ_STATUS_SUCCESS;
+        do
+        {
+            if (rc == LIBEVDEV_READ_STATUS_SYNC)
+                rc = libevdev_next_event(myDev.get(), LIBEVDEV_READ_FLAG_SYNC, &ev);
+            else
+                rc = libevdev_next_event(myDev.get(), LIBEVDEV_READ_FLAG_NORMAL, &ev);
+            ++counter;
+        } while (rc >= 0);
 #endif
 
-    return counter;
-  }
+        return counter;
+    }
 
-  const std::string & EvDevPaddle::getName() const
-  {
-    return myName;
-  }
+    const std::string &EvDevPaddle::getName() const
+    {
+        return myName;
+    }
 
-  bool EvDevPaddle::getButton(int i) const
-  {
-    int value = 0;
-    if (myDev)
+    bool EvDevPaddle::getButton(int i) const
     {
+        int value = 0;
+        if (myDev)
+        {
 #ifndef _WIN32
-      int rc = libevdev_fetch_event_value(myDev.get(), EV_KEY, myButtonCodes[i], &value);
+            int rc = libevdev_fetch_event_value(myDev.get(), EV_KEY, myButtonCodes[i], &value);
 #endif
+        }
+        return value != 0;
     }
-    return value != 0;
-  }
 
-  double EvDevPaddle::getAxis(int i) const
-  {
-#ifndef _WIN32
-    if  (myDev)
+    double EvDevPaddle::getAxis(int i) const
     {
-      int value = 0;
-      int rc = libevdev_fetch_event_value(myDev.get(), EV_ABS, myAxisCodes[i], &value);
-      const double axis = 2.0 * (value - myAxisMins[i]) / (myAxisMaxs[i] - myAxisMins[i]) - 1.0;
-      return axis;
-    }
-    else
+#ifndef _WIN32
+        if (myDev)
+        {
+            int value = 0;
+            int rc = libevdev_fetch_event_value(myDev.get(), EV_ABS, myAxisCodes[i], &value);
+            const double axis = 2.0 * (value - myAxisMins[i]) / (myAxisMaxs[i] - myAxisMins[i]) - 1.0;
+            return axis;
+        }
+        else
 #endif
-    {
-      return 0;
+        {
+            return 0;
+        }
     }
 
-  }
-
-}
+} // namespace na2
diff --git a/source/frontends/ncurses/evdevpaddle.h b/source/frontends/ncurses/evdevpaddle.h
index 336dfd7e6..a8408495d 100644
--- a/source/frontends/ncurses/evdevpaddle.h
+++ b/source/frontends/ncurses/evdevpaddle.h
@@ -11,30 +11,30 @@ struct input_event;
 namespace na2
 {
 
-  class EvDevPaddle : public Paddle
-  {
-  public:
-    EvDevPaddle(const std::string & device);
-    ~EvDevPaddle();
+    class EvDevPaddle : public Paddle
+    {
+    public:
+        EvDevPaddle(const std::string &device);
+        ~EvDevPaddle();
 
-    int poll();
+        int poll();
 
-    const std::string & getName() const;
-    bool getButton(int i) const override;
-    double getAxis(int i) const override;
+        const std::string &getName() const;
+        bool getButton(int i) const override;
+        double getAxis(int i) const override;
 
-  private:
-    int myFD;
-    std::shared_ptr<libevdev> myDev;
+    private:
+        int myFD;
+        std::shared_ptr<libevdev> myDev;
 
-    void process(const input_event & ev);
+        void process(const input_event &ev);
 
-    std::string myName;
+        std::string myName;
 
-    std::vector<unsigned int> myButtonCodes;
-    std::vector<unsigned int> myAxisCodes;
-    std::vector<int> myAxisMins;
-    std::vector<int> myAxisMaxs;
-  };
+        std::vector<unsigned int> myButtonCodes;
+        std::vector<unsigned int> myAxisCodes;
+        std::vector<int> myAxisMins;
+        std::vector<int> myAxisMaxs;
+    };
 
-}
+} // namespace na2
diff --git a/source/frontends/ncurses/main.cpp b/source/frontends/ncurses/main.cpp
index e727d748d..d508c97a3 100644
--- a/source/frontends/ncurses/main.cpp
+++ b/source/frontends/ncurses/main.cpp
@@ -21,139 +21,140 @@
 namespace
 {
 
-  void ProcessKeys(const std::shared_ptr<na2::NFrame> & frame, bool &quit)
-  {
-    const int key = GetKeyPressed(frame);
-
-    switch (key)
+    void ProcessKeys(const std::shared_ptr<na2::NFrame> &frame, bool &quit)
     {
-    case KEY_F(2):
-      {
-        ResetMachineState();
-        break;
-      }
-    case 278: // Shift-F2
-      {
-        CtrlReset();
-        break;
-      }
-    case KEY_F(3):
-      {
-        frame->TogglePaused();
-        break;
-      }
-    case KEY_F(4):
-    case 279: // Shift-F3 (this is non standard, use F4 instead)
-      {
-        quit = true;
-        break;
-      }
-    case KEY_F(5):
-      {
-        CardManager & cardManager = GetCardMgr();
-        if (cardManager.QuerySlot(SLOT6) == CT_Disk2)
+        const int key = GetKeyPressed(frame);
+
+        switch (key)
+        {
+        case KEY_F(2):
+        {
+            ResetMachineState();
+            break;
+        }
+        case 278: // Shift-F2
+        {
+            CtrlReset();
+            break;
+        }
+        case KEY_F(3):
+        {
+            frame->TogglePaused();
+            break;
+        }
+        case KEY_F(4):
+        case 279: // Shift-F3 (this is non standard, use F4 instead)
+        {
+            quit = true;
+            break;
+        }
+        case KEY_F(5):
+        {
+            CardManager &cardManager = GetCardMgr();
+            if (cardManager.QuerySlot(SLOT6) == CT_Disk2)
+            {
+                dynamic_cast<Disk2InterfaceCard *>(cardManager.GetObj(SLOT6))->DriveSwap();
+            }
+            break;
+        }
+        case KEY_F(11):
+        {
+            Snapshot_SaveState();
+            break;
+        }
+        case KEY_F(12):
         {
-          dynamic_cast<Disk2InterfaceCard*>(cardManager.GetObj(SLOT6))->DriveSwap();
+            frame->LoadSnapshot();
+            break;
+        }
         }
-        break;
-      }
-    case KEY_F(11):
-      {
-        Snapshot_SaveState();
-        break;
-      }
-    case KEY_F(12):
-      {
-        frame->LoadSnapshot();
-        break;
-      }
     }
-  }
 
-  void ContinueExecution(const common2::EmulatorOptions & options, const std::shared_ptr<na2::NFrame> & frame, bool &quit)
-  {
-    const auto start = std::chrono::steady_clock::now();
+    void ContinueExecution(
+        const common2::EmulatorOptions &options, const std::shared_ptr<na2::NFrame> &frame, bool &quit)
+    {
+        const auto start = std::chrono::steady_clock::now();
 
-    constexpr const int64_t oneFrameMicros = 1000000 / 60;             // 60 FPS
-    frame->ExecuteOneFrame(oneFrameMicros);
+        constexpr const int64_t oneFrameMicros = 1000000 / 60; // 60 FPS
+        frame->ExecuteOneFrame(oneFrameMicros);
 
-    ProcessKeys(frame, quit);
-    frame->ProcessEvDev();
+        ProcessKeys(frame, quit);
+        frame->ProcessEvDev();
 
-    if (!options.headless)
-    {
-      if (g_bFullSpeed)
-      {
-        frame->VideoPresentScreen();
-      }
-      else
-      {
-        frame->SyncVideoPresentScreen(oneFrameMicros);
-      }
+        if (!options.headless)
+        {
+            if (g_bFullSpeed)
+            {
+                frame->VideoPresentScreen();
+            }
+            else
+            {
+                frame->SyncVideoPresentScreen(oneFrameMicros);
+            }
+        }
     }
-  }
 
-  void EnterMessageLoop(const common2::EmulatorOptions & options, const std::shared_ptr<na2::NFrame> & frame)
-  {
-    if (options.headless)
+    void EnterMessageLoop(const common2::EmulatorOptions &options, const std::shared_ptr<na2::NFrame> &frame)
     {
-      std::cerr << "Press Ctrl-C to quit." << std::endl;
-    }
+        if (options.headless)
+        {
+            std::cerr << "Press Ctrl-C to quit." << std::endl;
+        }
 
-    bool quit = false;
+        bool quit = false;
+
+        do
+        {
+            ContinueExecution(options, frame, quit);
+        } while (!quit && !na2::g_stop);
+    }
 
-    do
+    int run_ncurses(int argc, char *const argv[])
     {
-      ContinueExecution(options, frame, quit);
-    } while (!quit && !na2::g_stop);
-  }
+        common2::EmulatorOptions options;
+        const bool run = getEmulatorOptions(argc, argv, common2::OptionsType::applen, "ncurses", options);
+        options.fixedSpeed = true; // TODO: remove, some testing required
+        options.syncWithTimer = true;
 
-  int run_ncurses(int argc, char *const argv[])
-  {
-    common2::EmulatorOptions options;
-    const bool run = getEmulatorOptions(argc, argv, common2::OptionsType::applen, "ncurses", options);
-    options.fixedSpeed = true;  // TODO: remove, some testing required
-    options.syncWithTimer = true;
+        if (!run)
+            return 1;
 
-    if (!run)
-      return 1;
+        const LoggerContext loggerContext(options.log);
+        const RegistryContext registryContet(CreateFileRegistry(options));
+        const std::shared_ptr<na2::EvDevPaddle> paddle = std::make_shared<na2::EvDevPaddle>(options.paddleDeviceName);
+        const std::shared_ptr<na2::NFrame> frame = std::make_shared<na2::NFrame>(options, paddle);
 
-    const LoggerContext loggerContext(options.log);
-    const RegistryContext registryContet(CreateFileRegistry(options));
-    const std::shared_ptr<na2::EvDevPaddle> paddle = std::make_shared<na2::EvDevPaddle>(options.paddleDeviceName);
-    const std::shared_ptr<na2::NFrame> frame = std::make_shared<na2::NFrame>(options, paddle);
+        const common2::CommonInitialisation init(frame, paddle, options);
 
-    const common2::CommonInitialisation init(frame, paddle, options);
+        // no audio in the ncurses frontend
+        g_bDisableDirectSound = true;
+        g_bDisableDirectSoundMockingboard = true;
+        na2::SetCtrlCHandler(options.headless);
 
-    // no audio in the ncurses frontend
-    g_bDisableDirectSound = true;
-    g_bDisableDirectSoundMockingboard = true;
-    na2::SetCtrlCHandler(options.headless);
+        if (options.benchmark)
+        {
+            const auto redraw = [&frame]() { frame->VideoRedrawScreen(); };
+            VideoBenchmark(redraw, redraw);
+        }
+        else
+        {
+            EnterMessageLoop(options, frame);
+        }
 
-    if (options.benchmark)
-    {
-      const auto redraw = [&frame]() { frame->VideoRedrawScreen(); };
-      VideoBenchmark(redraw, redraw);
-    }
-    else
-    {
-      EnterMessageLoop(options, frame);
+        return 0;
     }
 
-    return 0;
-  }
-
-}
+} // namespace
 
 int main(int argc, char *const argv[])
 {
-  try
-  {
-    return run_ncurses(argc, argv);
-  }
-  catch (const std::exception & e)
-  {
-    std::cerr << e.what() << std::endl;
-    return 1;
-  }
+    try
+    {
+        return run_ncurses(argc, argv);
+    }
+    catch (const std::exception &e)
+    {
+        std::cerr << e.what() << std::endl;
+        return 1;
+    }
 }
diff --git a/source/frontends/ncurses/nframe.cpp b/source/frontends/ncurses/nframe.cpp
index f0d88d634..678106d5f 100644
--- a/source/frontends/ncurses/nframe.cpp
+++ b/source/frontends/ncurses/nframe.cpp
@@ -18,392 +18,392 @@
 namespace na2
 {
 
-  struct NCurses
-  {
-    NCurses()
+    struct NCurses
     {
-      setlocale(LC_ALL, "");
-      initscr();
+        NCurses()
+        {
+            setlocale(LC_ALL, "");
+            initscr();
 
-      curs_set(0);
+            curs_set(0);
 
-      noecho();
-      cbreak();
-      set_escdelay(0);
+            noecho();
+            cbreak();
+            set_escdelay(0);
 
-      // make sure this happens when ncurses is indeed initialised
-      colors = std::make_shared<GraphicsColors>(20, 20, 32);
-    }
-    ~NCurses()
+            // make sure this happens when ncurses is indeed initialised
+            colors = std::make_shared<GraphicsColors>(20, 20, 32);
+        }
+        ~NCurses()
+        {
+            endwin();
+        }
+        void allclear()
+        {
+            clear();
+            refresh();
+        }
+        std::shared_ptr<GraphicsColors> colors;
+    };
+
+    NFrame::NFrame(const common2::EmulatorOptions &options, const std::shared_ptr<EvDevPaddle> &paddle)
+        : common2::GNUFrame(options)
+        , myPaddle(paddle)
+        , myRows(-1)
+        , myColumns(-1)
     {
-      endwin();
+        // only initialise if actually used
+        // so we can run headless
     }
-    void allclear()
+
+    void NFrame::Initialize(bool resetVideoState)
     {
-      clear();
-      refresh();
+        CommonFrame::Initialize(resetVideoState);
+        myTextFlashCounter = 0;
+        myTextFlashState = 0;
+        myAsciiArt = std::make_shared<ASCIIArt>();
     }
-    std::shared_ptr<GraphicsColors> colors;
-  };
-
-  NFrame::NFrame(const common2::EmulatorOptions & options, const std::shared_ptr<EvDevPaddle> & paddle)
-    : common2::GNUFrame(options)
-    , myPaddle(paddle)
-    , myRows(-1)
-    , myColumns(-1)
-  {
-    // only initialise if actually used
-    // so we can run headless
-  }
-
-  void NFrame::Initialize(bool resetVideoState)
-  {
-    CommonFrame::Initialize(resetVideoState);
-    myTextFlashCounter = 0;
-    myTextFlashState = 0;
-    myAsciiArt = std::make_shared<ASCIIArt>();
-  }
-
-  void NFrame::Destroy()
-  {
-    CommonFrame::Destroy();
-    myTextFlashCounter = 0;
-    myTextFlashState = 0;
-    myFrame.reset();
-    myStatus.reset();
-    myAsciiArt.reset();
-
-    myNCurses.reset();
-  }
-
-  void NFrame::ProcessEvDev()
-  {
-    myPaddle->poll();
-  }
-
-  void NFrame::ChangeColumns(const int x)
-  {
-    myAsciiArt->changeColumns(x);
-  }
-
-  void NFrame::ChangeRows(const int x)
-  {
-    myAsciiArt->changeRows(x);
-  }
-
-  void NFrame::ReInit()
-  {
-    ForceInit(myRows, myColumns);
-  }
-
-  void NFrame::ForceInit(int rows, int columns)
-  {
-    InitialiseNCurses();
-    myNCurses->allclear();
-
-    myRows = rows;
-    myColumns = columns;
-
-    const int width = 1 + myColumns + 1;
-    const int left = std::max(0, (COLS - width) / 2);
-
-    myFrame.reset(newwin(1 + myRows + 1, width, 0, left), delwin);
-    box(myFrame.get(), 0, 0);
-    wtimeout(myFrame.get(), 0);
-    keypad(myFrame.get(), true);
-    wrefresh(myFrame.get());
-
-    myStatus.reset(newwin(8, width, 1 + myRows + 1, left), delwin);
-    FrameRefreshStatus(DRAW_LEDS | DRAW_BUTTON_DRIVES | DRAW_DISK_STATUS);
-  }
-
-  void NFrame::Init(int rows, int columns)
-  {
-    if (myRows != rows || myColumns != columns)
+
+    void NFrame::Destroy()
     {
-      ForceInit(rows, columns);
+        CommonFrame::Destroy();
+        myTextFlashCounter = 0;
+        myTextFlashState = 0;
+        myFrame.reset();
+        myStatus.reset();
+        myAsciiArt.reset();
+
+        myNCurses.reset();
     }
-  }
-
-  WINDOW * NFrame::GetWindow()
-  {
-    return myFrame.get();
-  }
-
-  WINDOW * NFrame::GetStatus()
-  {
-    return myStatus.get();
-  }
 
-  void NFrame::InitialiseNCurses()
-  {
-    if (!myNCurses)
+    void NFrame::ProcessEvDev()
     {
-      myNCurses = std::make_shared<NCurses>();
-    }
-  }
-
-  void NFrame::VideoPresentScreen()
-  {
-    VideoUpdateFlash();
-
-    Video & video = GetVideo();
-
-    // see NTSC_SetVideoMode in NTSC.cpp
-    // we shoudl really use g_nTextPage and g_nHiresPage
-    const int displaypage2 = (video.VideoGetSWPAGE2() && !video.VideoGetSW80STORE()) ? 1 : 0;
-
-    myHiresBank1 = MemGetAuxPtr (0x2000 << displaypage2);
-    myHiresBank0 = MemGetMainPtr(0x2000 << displaypage2);
-    myTextBank1  = MemGetAuxPtr (0x400  << displaypage2);
-    myTextBank0  = MemGetMainPtr(0x400  << displaypage2);
-
-    typedef bool (NFrame::* VideoUpdateFuncPtr_t)(Video &, int, int, int, int, int);
-
-    VideoUpdateFuncPtr_t update = video.VideoGetSWTEXT()
-      ? video.VideoGetSW80COL()
-      ? &NFrame::Update80ColCell
-      : &NFrame::Update40ColCell
-      : video.VideoGetSWHIRES()
-      ? (video.VideoGetSWDHIRES() && video.VideoGetSW80COL())
-      ? &NFrame::UpdateDHiResCell
-      : &NFrame::UpdateHiResCell
-      : (video.VideoGetSWDHIRES() && video.VideoGetSW80COL())
-      ? &NFrame::UpdateDLoResCell
-      : &NFrame::UpdateLoResCell;
-
-    int  y        = 0;
-    int  ypixel   = 0;
-    while (y < 20) {
-      int offset = ((y & 7) << 7) + ((y >> 3) * 40);
-      int x      = 0;
-      int xpixel = 0;
-      while (x < 40) {
-        (this->*update)(video, x, y, xpixel, ypixel, offset + x);
-        ++x;
-        xpixel += 14;
-      }
-      ++y;
-      ypixel += 16;
+        myPaddle->poll();
     }
 
-    if (video.VideoGetSWMIXED())
-      update = video.VideoGetSW80COL() ? &NFrame::Update80ColCell
-        : &NFrame::Update40ColCell;
-
-    while (y < 24) {
-      int offset = ((y & 7) << 7) + ((y >> 3) * 40);
-      int x      = 0;
-      int xpixel = 0;
-      while (x < 40) {
-        (this->*update)(video, x, y, xpixel, ypixel, offset + x);
-        ++x;
-        xpixel += 14;
-      }
-      ++y;
-      ypixel += 16;
+    void NFrame::ChangeColumns(const int x)
+    {
+        myAsciiArt->changeColumns(x);
     }
 
-    wrefresh(myFrame.get());
-  }
-
-  void NFrame::FrameRefreshStatus(int /* drawflags */)
-  {
-    werase(myStatus.get());
-    box(myStatus.get(), 0 , 0);
-
-    int row = 0;
-
-    CardManager& cardManager = GetCardMgr();
-    if (cardManager.QuerySlot(SLOT6) == CT_Disk2)
+    void NFrame::ChangeRows(const int x)
     {
-      Disk2InterfaceCard& disk2 = dynamic_cast<Disk2InterfaceCard&>(cardManager.GetRef(SLOT6));
-      const size_t maximumWidth = myColumns - 6;  // 6 is the width of "S6D1: "
-      for (UINT i = DRIVE_1; i <= DRIVE_2; ++i)
-      {
-        const std::string name = disk2.GetBaseName(i).substr(0, maximumWidth);
-        mvwprintw(myStatus.get(), ++row, 1, "S6D%d: %s", 1 + i, name.c_str());
-      }
+        myAsciiArt->changeRows(x);
     }
-    else
+
+    void NFrame::ReInit()
     {
-      row += DRIVE_2 - DRIVE_1 + 1;
+        ForceInit(myRows, myColumns);
     }
 
-    ++row;
+    void NFrame::ForceInit(int rows, int columns)
+    {
+        InitialiseNCurses();
+        myNCurses->allclear();
 
-    mvwprintw(myStatus.get(), ++row, 1, "F2: ResetMachine / Shift-F2: CtrlReset");
-    mvwprintw(myStatus.get(), ++row, 1, "F3: Pause        / Shift-F3: Exit");
-    mvwprintw(myStatus.get(), ++row, 1, "F11: Save State  / F12: Load State");
-    wrefresh(myStatus.get());
-  }
+        myRows = rows;
+        myColumns = columns;
 
-  void NFrame::VideoUpdateFlash()
-  {
-    ++myTextFlashCounter;
+        const int width = 1 + myColumns + 1;
+        const int left = std::max(0, (COLS - width) / 2);
 
-    if (myTextFlashCounter == 16) // Flash rate = 0.5 * 60 / 16 Hz (as we need 2 changes for a period)
-    {
-      myTextFlashCounter = 0;
-      myTextFlashState = !myTextFlashState;
-    }
-  }
+        myFrame.reset(newwin(1 + myRows + 1, width, 0, left), delwin);
+        box(myFrame.get(), 0, 0);
+        wtimeout(myFrame.get(), 0);
+        keypad(myFrame.get(), true);
+        wrefresh(myFrame.get());
 
-  chtype NFrame::MapCharacter(Video & video, BYTE ch)
-  {
-    const char low = ch & 0x7f;
-    const char high = ch & 0x80;
+        myStatus.reset(newwin(8, width, 1 + myRows + 1, left), delwin);
+        FrameRefreshStatus(DRAW_LEDS | DRAW_BUTTON_DRIVES | DRAW_DISK_STATUS);
+    }
 
-    chtype result = low;
+    void NFrame::Init(int rows, int columns)
+    {
+        if (myRows != rows || myColumns != columns)
+        {
+            ForceInit(rows, columns);
+        }
+    }
 
-    const int code = low >> 5;
-    switch (code)
+    WINDOW *NFrame::GetWindow()
     {
-    case 0:           // 00 - 1F
-      result += 0x40; // UPPERCASE
-      break;
-    case 1:           // 20 - 3F
-      // SPECIAL CHARACTER
-      break;
-    case 2:           // 40 - 5F
-      // UPPERCASE
-      break;
-    case 3:           // 60 - 7F
-      // LOWERCASE
-      if (high == 0 && !video.VideoGetSWAltCharSet())
-      {
-        result -= 0x40;
-      }
-      break;
+        return myFrame.get();
     }
 
-    if (result == 0x7f)
+    WINDOW *NFrame::GetStatus()
     {
-      result = ACS_CKBOARD;
+        return myStatus.get();
     }
 
-    if (!high)
+    void NFrame::InitialiseNCurses()
     {
-      if (!video.VideoGetSWAltCharSet() && (low >= 0x40))
-      {
-        // result |= A_BLINK; // does not work on my terminal
-        if (myTextFlashState)
+        if (!myNCurses)
         {
-          result |= A_REVERSE;
+            myNCurses = std::make_shared<NCurses>();
         }
-      }
-      else
-      {
-        result |= A_REVERSE;
-      }
     }
 
-    return result;
-  }
+    void NFrame::VideoPresentScreen()
+    {
+        VideoUpdateFlash();
 
-  bool NFrame::Update40ColCell(Video & video, int x, int y, int xpixel, int ypixel, int offset)
-  {
-    Init(24, 40);
-    myAsciiArt->init(1, 1);
+        Video &video = GetVideo();
 
-    BYTE ch = *(myTextBank0+offset);
+        // see NTSC_SetVideoMode in NTSC.cpp
+        // we shoudl really use g_nTextPage and g_nHiresPage
+        const int displaypage2 = (video.VideoGetSWPAGE2() && !video.VideoGetSW80STORE()) ? 1 : 0;
 
-    const chtype ch2 = MapCharacter(video, ch);
-    mvwaddch(myFrame.get(), 1 + y, 1 + x, ch2);
+        myHiresBank1 = MemGetAuxPtr(0x2000 << displaypage2);
+        myHiresBank0 = MemGetMainPtr(0x2000 << displaypage2);
+        myTextBank1 = MemGetAuxPtr(0x400 << displaypage2);
+        myTextBank0 = MemGetMainPtr(0x400 << displaypage2);
 
-    return true;
-  }
+        typedef bool (NFrame::*VideoUpdateFuncPtr_t)(Video &, int, int, int, int, int);
 
-  bool NFrame::Update80ColCell(Video & video, int x, int y, int xpixel, int ypixel, int offset)
-  {
-    Init(24, 80);
-    myAsciiArt->init(1, 2);
+        VideoUpdateFuncPtr_t update =
+            video.VideoGetSWTEXT()    ? video.VideoGetSW80COL() ? &NFrame::Update80ColCell : &NFrame::Update40ColCell
+            : video.VideoGetSWHIRES() ? (video.VideoGetSWDHIRES() && video.VideoGetSW80COL())
+                                            ? &NFrame::UpdateDHiResCell
+                                            : &NFrame::UpdateHiResCell
+            : (video.VideoGetSWDHIRES() && video.VideoGetSW80COL()) ? &NFrame::UpdateDLoResCell
+                                                                    : &NFrame::UpdateLoResCell;
 
-    BYTE ch1 = *(myTextBank1+offset);
-    BYTE ch2 = *(myTextBank0+offset);
+        int y = 0;
+        int ypixel = 0;
+        while (y < 20)
+        {
+            int offset = ((y & 7) << 7) + ((y >> 3) * 40);
+            int x = 0;
+            int xpixel = 0;
+            while (x < 40)
+            {
+                (this->*update)(video, x, y, xpixel, ypixel, offset + x);
+                ++x;
+                xpixel += 14;
+            }
+            ++y;
+            ypixel += 16;
+        }
 
-    WINDOW * win = myFrame.get();
+        if (video.VideoGetSWMIXED())
+            update = video.VideoGetSW80COL() ? &NFrame::Update80ColCell : &NFrame::Update40ColCell;
 
-    const chtype ch12 = MapCharacter(video, ch1);
-    mvwaddch(win, 1 + y, 1 + 2 * x, ch12);
+        while (y < 24)
+        {
+            int offset = ((y & 7) << 7) + ((y >> 3) * 40);
+            int x = 0;
+            int xpixel = 0;
+            while (x < 40)
+            {
+                (this->*update)(video, x, y, xpixel, ypixel, offset + x);
+                ++x;
+                xpixel += 14;
+            }
+            ++y;
+            ypixel += 16;
+        }
 
-    const chtype ch22 = MapCharacter(video, ch2);
-    mvwaddch(win, 1 + y, 1 + 2 * x + 1, ch22);
+        wrefresh(myFrame.get());
+    }
+
+    void NFrame::FrameRefreshStatus(int /* drawflags */)
+    {
+        werase(myStatus.get());
+        box(myStatus.get(), 0, 0);
 
-    return true;
-  }
+        int row = 0;
 
-  bool NFrame::UpdateLoResCell(Video &, int x, int y, int xpixel, int ypixel, int offset)
-  {
-    BYTE val = *(myTextBank0+offset);
+        CardManager &cardManager = GetCardMgr();
+        if (cardManager.QuerySlot(SLOT6) == CT_Disk2)
+        {
+            Disk2InterfaceCard &disk2 = dynamic_cast<Disk2InterfaceCard &>(cardManager.GetRef(SLOT6));
+            const size_t maximumWidth = myColumns - 6; // 6 is the width of "S6D1: "
+            for (UINT i = DRIVE_1; i <= DRIVE_2; ++i)
+            {
+                const std::string name = disk2.GetBaseName(i).substr(0, maximumWidth);
+                mvwprintw(myStatus.get(), ++row, 1, "S6D%d: %s", 1 + i, name.c_str());
+            }
+        }
+        else
+        {
+            row += DRIVE_2 - DRIVE_1 + 1;
+        }
 
-    const int pair = myNCurses->colors->getPair(val);
+        ++row;
 
-    WINDOW * win = myFrame.get();
+        mvwprintw(myStatus.get(), ++row, 1, "F2: ResetMachine / Shift-F2: CtrlReset");
+        mvwprintw(myStatus.get(), ++row, 1, "F3: Pause        / Shift-F3: Exit");
+        mvwprintw(myStatus.get(), ++row, 1, "F11: Save State  / F12: Load State");
+        wrefresh(myStatus.get());
+    }
 
-    wcolor_set(win, pair, NULL);
-    if (myColumns == 40)
+    void NFrame::VideoUpdateFlash()
     {
-      mvwaddstr(win, 1 + y, 1 + x, "\u2580");
+        ++myTextFlashCounter;
+
+        if (myTextFlashCounter == 16) // Flash rate = 0.5 * 60 / 16 Hz (as we need 2 changes for a period)
+        {
+            myTextFlashCounter = 0;
+            myTextFlashState = !myTextFlashState;
+        }
     }
-    else
+
+    chtype NFrame::MapCharacter(Video &video, BYTE ch)
     {
-      mvwaddstr(win, 1 + y, 1 + 2 * x, "\u2580\u2580");
+        const char low = ch & 0x7f;
+        const char high = ch & 0x80;
+
+        chtype result = low;
+
+        const int code = low >> 5;
+        switch (code)
+        {
+        case 0:             // 00 - 1F
+            result += 0x40; // UPPERCASE
+            break;
+        case 1: // 20 - 3F
+            // SPECIAL CHARACTER
+            break;
+        case 2: // 40 - 5F
+            // UPPERCASE
+            break;
+        case 3: // 60 - 7F
+            // LOWERCASE
+            if (high == 0 && !video.VideoGetSWAltCharSet())
+            {
+                result -= 0x40;
+            }
+            break;
+        }
+
+        if (result == 0x7f)
+        {
+            result = ACS_CKBOARD;
+        }
+
+        if (!high)
+        {
+            if (!video.VideoGetSWAltCharSet() && (low >= 0x40))
+            {
+                // result |= A_BLINK; // does not work on my terminal
+                if (myTextFlashState)
+                {
+                    result |= A_REVERSE;
+                }
+            }
+            else
+            {
+                result |= A_REVERSE;
+            }
+        }
+
+        return result;
     }
-    wcolor_set(win, 0, NULL);
 
-    return true;
-  }
+    bool NFrame::Update40ColCell(Video &video, int x, int y, int xpixel, int ypixel, int offset)
+    {
+        Init(24, 40);
+        myAsciiArt->init(1, 1);
+
+        BYTE ch = *(myTextBank0 + offset);
 
-  bool NFrame::UpdateDLoResCell(Video &, int x, int y, int xpixel, int ypixel, int offset)
-  {
-    return true;
-  }
+        const chtype ch2 = MapCharacter(video, ch);
+        mvwaddch(myFrame.get(), 1 + y, 1 + x, ch2);
 
-  bool NFrame::UpdateHiResCell(Video &, int x, int y, int xpixel, int ypixel, int offset)
-  {
-    const BYTE * base = myHiresBank0 + offset;
+        return true;
+    }
+
+    bool NFrame::Update80ColCell(Video &video, int x, int y, int xpixel, int ypixel, int offset)
+    {
+        Init(24, 80);
+        myAsciiArt->init(1, 2);
 
-    const ASCIIArt::array_char_t & chs = myAsciiArt->getCharacters(base);
+        BYTE ch1 = *(myTextBank1 + offset);
+        BYTE ch2 = *(myTextBank0 + offset);
 
-    const auto shape = chs.shape();
-    const size_t rows = shape[0];
-    const size_t cols = shape[1];
+        WINDOW *win = myFrame.get();
 
-    Init(24 * rows, 40 * cols);
-    WINDOW * win = myFrame.get();
+        const chtype ch12 = MapCharacter(video, ch1);
+        mvwaddch(win, 1 + y, 1 + 2 * x, ch12);
 
-    const GraphicsColors & colors = *myNCurses->colors;
+        const chtype ch22 = MapCharacter(video, ch2);
+        mvwaddch(win, 1 + y, 1 + 2 * x + 1, ch22);
 
-    for (size_t i = 0; i < rows; ++i)
+        return true;
+    }
+
+    bool NFrame::UpdateLoResCell(Video &, int x, int y, int xpixel, int ypixel, int offset)
     {
-      for (size_t j = 0; j < cols; ++j)
-      {
-        const int pair = colors.getGrey(chs[i][j].foreground, chs[i][j].background);
+        BYTE val = *(myTextBank0 + offset);
+
+        const int pair = myNCurses->colors->getPair(val);
+
+        WINDOW *win = myFrame.get();
 
         wcolor_set(win, pair, NULL);
-        mvwaddstr(win, 1 + rows * y + i, 1 + cols * x + j, chs[i][j].c);
-      }
+        if (myColumns == 40)
+        {
+            mvwaddstr(win, 1 + y, 1 + x, "\u2580");
+        }
+        else
+        {
+            mvwaddstr(win, 1 + y, 1 + 2 * x, "\u2580\u2580");
+        }
+        wcolor_set(win, 0, NULL);
+
+        return true;
+    }
+
+    bool NFrame::UpdateDLoResCell(Video &, int x, int y, int xpixel, int ypixel, int offset)
+    {
+        return true;
     }
-    wcolor_set(win, 0, NULL);
 
-    return true;
-  }
+    bool NFrame::UpdateHiResCell(Video &, int x, int y, int xpixel, int ypixel, int offset)
+    {
+        const BYTE *base = myHiresBank0 + offset;
+
+        const ASCIIArt::array_char_t &chs = myAsciiArt->getCharacters(base);
 
-  bool NFrame::UpdateDHiResCell(Video &, int x, int y, int xpixel, int ypixel, int offset)
-  {
-    return true;
-  }
+        const auto shape = chs.shape();
+        const size_t rows = shape[0];
+        const size_t cols = shape[1];
 
-  int NFrame::FrameMessageBox(LPCSTR lpText, LPCSTR lpCaption, UINT uType)
-  {
-    LogFileOutput("MessageBox:\n%s\n%s\n\n", lpCaption, lpText);
-    return IDOK;
-  }
+        Init(24 * rows, 40 * cols);
+        WINDOW *win = myFrame.get();
+
+        const GraphicsColors &colors = *myNCurses->colors;
+
+        for (size_t i = 0; i < rows; ++i)
+        {
+            for (size_t j = 0; j < cols; ++j)
+            {
+                const int pair = colors.getGrey(chs[i][j].foreground, chs[i][j].background);
+
+                wcolor_set(win, pair, NULL);
+                mvwaddstr(win, 1 + rows * y + i, 1 + cols * x + j, chs[i][j].c);
+            }
+        }
+        wcolor_set(win, 0, NULL);
 
-  std::shared_ptr<SoundBuffer> NFrame::CreateSoundBuffer(uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char* pszVoiceName)
-  {
-    return nullptr;
-  }
+        return true;
+    }
+
+    bool NFrame::UpdateDHiResCell(Video &, int x, int y, int xpixel, int ypixel, int offset)
+    {
+        return true;
+    }
+
+    int NFrame::FrameMessageBox(LPCSTR lpText, LPCSTR lpCaption, UINT uType)
+    {
+        LogFileOutput("MessageBox:\n%s\n%s\n\n", lpCaption, lpText);
+        return IDOK;
+    }
+
+    std::shared_ptr<SoundBuffer> NFrame::CreateSoundBuffer(
+        uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char *pszVoiceName)
+    {
+        return nullptr;
+    }
 
-}
+} // namespace na2
diff --git a/source/frontends/ncurses/nframe.h b/source/frontends/ncurses/nframe.h
index 140be5cd9..3a4afe3ce 100644
--- a/source/frontends/ncurses/nframe.h
+++ b/source/frontends/ncurses/nframe.h
@@ -9,66 +9,66 @@
 namespace na2
 {
 
-  class ASCIIArt;
-  class EvDevPaddle;
-  struct NCurses;
+    class ASCIIArt;
+    class EvDevPaddle;
+    struct NCurses;
 
-  class NFrame : public common2::GNUFrame
-  {
-  public:
-    NFrame(const common2::EmulatorOptions & options, const std::shared_ptr<EvDevPaddle> & paddle);
+    class NFrame : public common2::GNUFrame
+    {
+    public:
+        NFrame(const common2::EmulatorOptions &options, const std::shared_ptr<EvDevPaddle> &paddle);
 
-    WINDOW * GetWindow();
-    WINDOW * GetStatus();
+        WINDOW *GetWindow();
+        WINDOW *GetStatus();
 
-    void Initialize(bool resetVideoState) override;
-    void Destroy() override;
-    void VideoPresentScreen() override;
-    int FrameMessageBox(LPCSTR lpText, LPCSTR lpCaption, UINT uType) override;
-    void FrameRefreshStatus(int drawflags) override;
+        void Initialize(bool resetVideoState) override;
+        void Destroy() override;
+        void VideoPresentScreen() override;
+        int FrameMessageBox(LPCSTR lpText, LPCSTR lpCaption, UINT uType) override;
+        void FrameRefreshStatus(int drawflags) override;
 
-    std::shared_ptr<SoundBuffer> CreateSoundBuffer(uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char* pszVoiceName) override;
+        std::shared_ptr<SoundBuffer> CreateSoundBuffer(
+            uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char *pszVoiceName) override;
 
-    void ProcessEvDev();
+        void ProcessEvDev();
 
-    void ChangeColumns(const int x);
-    void ChangeRows(const int x);
+        void ChangeColumns(const int x);
+        void ChangeRows(const int x);
 
-    void Init(int rows, int columns);
-    void ReInit();
+        void Init(int rows, int columns);
+        void ReInit();
 
-  private:
+    private:
+        const std::shared_ptr<EvDevPaddle> myPaddle;
 
-    const std::shared_ptr<EvDevPaddle> myPaddle;
+        int myRows;
+        int myColumns;
+        int myTextFlashCounter;
+        bool myTextFlashState;
 
-    int myRows;
-    int myColumns;
-    int myTextFlashCounter;
-    bool myTextFlashState;
+        std::shared_ptr<WINDOW> myFrame;
+        std::shared_ptr<WINDOW> myStatus;
+        std::shared_ptr<ASCIIArt> myAsciiArt;
+        std::shared_ptr<NCurses> myNCurses;
 
-    std::shared_ptr<WINDOW> myFrame;
-    std::shared_ptr<WINDOW> myStatus;
-    std::shared_ptr<ASCIIArt> myAsciiArt;
-    std::shared_ptr<NCurses> myNCurses;
+        LPBYTE myTextBank1; // Aux
+        LPBYTE myTextBank0; // Main
+        LPBYTE myHiresBank1;
+        LPBYTE myHiresBank0;
 
-    LPBYTE        myTextBank1; // Aux
-    LPBYTE        myTextBank0; // Main
-    LPBYTE        myHiresBank1;
-    LPBYTE        myHiresBank0;
+        void VideoUpdateFlash();
 
-    void VideoUpdateFlash();
+        chtype MapCharacter(Video &video, BYTE ch);
 
-    chtype MapCharacter(Video & video, BYTE ch);
+        bool Update40ColCell(Video &video, int x, int y, int xpixel, int ypixel, int offset);
+        bool Update80ColCell(Video &video, int x, int y, int xpixel, int ypixel, int offset);
+        bool UpdateLoResCell(Video &, int x, int y, int xpixel, int ypixel, int offset);
+        bool UpdateDLoResCell(Video &, int x, int y, int xpixel, int ypixel, int offset);
+        bool UpdateHiResCell(Video &, int x, int y, int xpixel, int ypixel, int offset);
+        bool UpdateDHiResCell(Video &, int x, int y, int xpixel, int ypixel, int offset);
 
-    bool Update40ColCell(Video & video, int x, int y, int xpixel, int ypixel, int offset);
-    bool Update80ColCell(Video & video, int x, int y, int xpixel, int ypixel, int offset);
-    bool UpdateLoResCell(Video &, int x, int y, int xpixel, int ypixel, int offset);
-    bool UpdateDLoResCell(Video &, int x, int y, int xpixel, int ypixel, int offset);
-    bool UpdateHiResCell(Video &, int x, int y, int xpixel, int ypixel, int offset);
-    bool UpdateDHiResCell(Video &, int x, int y, int xpixel, int ypixel, int offset);
+        void InitialiseNCurses();
+        void ForceInit(int rows, int columns);
+    };
 
-    void InitialiseNCurses();
-    void ForceInit(int rows, int columns);
-  };
-
-}
+} // namespace na2
diff --git a/source/frontends/ncurses/world.cpp b/source/frontends/ncurses/world.cpp
index 1944710ab..71c2ee215 100644
--- a/source/frontends/ncurses/world.cpp
+++ b/source/frontends/ncurses/world.cpp
@@ -17,136 +17,135 @@
 namespace
 {
 
-  void sig_handler_pass(int signo)
-  {
-    // Ctrl-C
-    // is there a race condition here?
-    // is it a problem?
-    addKeyToBuffer(0x03);
-  }
-
-  void sig_handler_exit(int signo)
-  {
-    na2::g_stop = true;
-  }
+    void sig_handler_pass(int signo)
+    {
+        // Ctrl-C
+        // is there a race condition here?
+        // is it a problem?
+        addKeyToBuffer(0x03);
+    }
 
-}
+    void sig_handler_exit(int signo)
+    {
+        na2::g_stop = true;
+    }
 
+} // namespace
 
 namespace na2
 {
 
-  bool g_stop = false;
+    bool g_stop = false;
 
-  void SetCtrlCHandler(const bool headless)
-  {
-    if (headless)
-    {
-      signal(SIGINT, sig_handler_exit);
-    }
-    else
+    void SetCtrlCHandler(const bool headless)
     {
-      signal(SIGINT, sig_handler_pass);
-      // pass Ctrl-C to the emulator
+        if (headless)
+        {
+            signal(SIGINT, sig_handler_exit);
+        }
+        else
+        {
+            signal(SIGINT, sig_handler_pass);
+            // pass Ctrl-C to the emulator
+        }
     }
-  }
 
-  int GetKeyPressed(const std::shared_ptr<NFrame> & frame)
-  {
-    WINDOW * window = frame->GetWindow();
-    if (!window)
+    int GetKeyPressed(const std::shared_ptr<NFrame> &frame)
     {
-      return ERR;
-    }
+        WINDOW *window = frame->GetWindow();
+        if (!window)
+        {
+            return ERR;
+        }
 
-    const int inch = wgetch(window);
+        const int inch = wgetch(window);
 
 #ifdef KEY_LOGGING_VERBOSE
-    if (inch != ERR)
-    {
-      LogFileOutput("wgetch = %3d\n", inch);
-    }
+        if (inch != ERR)
+        {
+            LogFileOutput("wgetch = %3d\n", inch);
+        }
 #endif
 
-    int ch = ERR;
+        int ch = ERR;
 
-    /*
-    Ctrl & Alt - Arrows are not quite right.
-    I have changed them many times and I suspect they are terminal-dependent.
-    */
+        /*
+        Ctrl & Alt - Arrows are not quite right.
+        I have changed them many times and I suspect they are terminal-dependent.
+        */
 
-    switch (inch)
-    {
-    case ERR:
-      break;
-    case '\n':
-      ch = 0x0d; // ENTER
-      break;
-    case KEY_BACKSPACE:
-    case KEY_LEFT:
-      ch = 0x08;
-      break;
-    case KEY_RIGHT:
-      ch = 0x15;
-      break;
-    case KEY_UP:
-      ch = 0x0b;
-      break;
-    case KEY_DOWN:
-      ch = 0x0a;
-      break;
-    case 0x14a: // DEL
-      ch = 0x7f;
-      break;
-    case 410:
-      frame->ReInit();
-      break;
-    case 548: // Raspberry Pi
-    case 550: // Alt-Left
-    case 552: // Ctrl-Left
-      frame->ChangeColumns(-1);
-      break;
-    case 563: // Raspberry Pi
-    case 565: // Alt-Right
-    case 567: // Ctrl-Right
-      frame->ChangeColumns(+1);
-      break;
-    case 569: // Raspberry Pi
-    case 571: // Alt-Up
-    case 573: // Ctrl-Up
-      frame->ChangeRows(-1);
-      break;
-    case 528: // Raspberry Pi
-    case 530: // Alt-Down
-    case 532: // Ctrl-Down
-      frame->ChangeRows(+1);
-      break;
-    default:
-      if (inch < 0x80)
-      {
-        ch = inch;
-        // Standard for Apple II is Upper case
-        if (ch >= 'A' && ch <= 'Z')
+        switch (inch)
         {
-          ch += 'a' - 'A';
+        case ERR:
+            break;
+        case '\n':
+            ch = 0x0d; // ENTER
+            break;
+        case KEY_BACKSPACE:
+        case KEY_LEFT:
+            ch = 0x08;
+            break;
+        case KEY_RIGHT:
+            ch = 0x15;
+            break;
+        case KEY_UP:
+            ch = 0x0b;
+            break;
+        case KEY_DOWN:
+            ch = 0x0a;
+            break;
+        case 0x14a: // DEL
+            ch = 0x7f;
+            break;
+        case 410:
+            frame->ReInit();
+            break;
+        case 548: // Raspberry Pi
+        case 550: // Alt-Left
+        case 552: // Ctrl-Left
+            frame->ChangeColumns(-1);
+            break;
+        case 563: // Raspberry Pi
+        case 565: // Alt-Right
+        case 567: // Ctrl-Right
+            frame->ChangeColumns(+1);
+            break;
+        case 569: // Raspberry Pi
+        case 571: // Alt-Up
+        case 573: // Ctrl-Up
+            frame->ChangeRows(-1);
+            break;
+        case 528: // Raspberry Pi
+        case 530: // Alt-Down
+        case 532: // Ctrl-Down
+            frame->ChangeRows(+1);
+            break;
+        default:
+            if (inch < 0x80)
+            {
+                ch = inch;
+                // Standard for Apple II is Upper case
+                if (ch >= 'A' && ch <= 'Z')
+                {
+                    ch += 'a' - 'A';
+                }
+                else if (ch >= 'a' && ch <= 'z')
+                {
+                    ch -= 'a' - 'A';
+                }
+            }
         }
-        else if (ch >= 'a' && ch <= 'z')
+
+        if (ch != ERR)
         {
-          ch -= 'a' - 'A';
+            addKeyToBuffer(ch);
+            return ERR;
+        }
+        else
+        {
+            // pass it back
+            return inch;
         }
-      }
-    }
-
-    if (ch != ERR)
-    {
-      addKeyToBuffer(ch);
-      return ERR;
-    }
-    else
-    {
-      // pass it back
-      return inch;
     }
-  }
 
-}
+} // namespace na2
diff --git a/source/frontends/ncurses/world.h b/source/frontends/ncurses/world.h
index 356a9eabf..691c99b19 100644
--- a/source/frontends/ncurses/world.h
+++ b/source/frontends/ncurses/world.h
@@ -5,13 +5,13 @@
 namespace na2
 {
 
-  class NFrame;
+    class NFrame;
 
-  int GetKeyPressed(const std::shared_ptr<NFrame> & frame);
-  void SetCtrlCHandler(const bool headless);
+    int GetKeyPressed(const std::shared_ptr<NFrame> &frame);
+    void SetCtrlCHandler(const bool headless);
 
-  extern double g_relativeSpeed;
+    extern double g_relativeSpeed;
 
-  extern bool g_stop;
+    extern bool g_stop;
 
-}
+} // namespace na2
diff --git a/source/frontends/qt/audioinfo.cpp b/source/frontends/qt/audioinfo.cpp
index e377a03dc..ed1d292d8 100644
--- a/source/frontends/qt/audioinfo.cpp
+++ b/source/frontends/qt/audioinfo.cpp
@@ -11,9 +11,9 @@
 typedef QString QLatin1StringView;
 #endif
 
-AudioInfo::AudioInfo(QWidget *parent) :
-    QWidget(parent),
-    ui(new Ui::AudioInfo)
+AudioInfo::AudioInfo(QWidget *parent)
+    : QWidget(parent)
+    , ui(new Ui::AudioInfo)
 {
     ui->setupUi(this);
 }
@@ -33,23 +33,23 @@ void AudioInfo::updateInfo(const qint64 speed, const qint64 target)
     }
 
     myCounter = 0;
-    const std::vector<QDirectSound::SoundInfo> & info = QDirectSound::getAudioInfo();
+    const std::vector<QDirectSound::SoundInfo> &info = QDirectSound::getAudioInfo();
 
     QString s("Voice   Channels  Buffer  Underruns\n");
-    for (const auto & i : info)
+    for (const auto &i : info)
     {
         if (i.running)
         {
             s += QString("%1    %2    %3   %4\n")
-                .arg(QString(i.voiceName.c_str()), -10)
-                .arg(i.channels, 2)
-                .arg(i.buffer, 4)
-                .arg(i.numberOfUnderruns, 8);
+                     .arg(QString(i.voiceName.c_str()), -10)
+                     .arg(i.channels, 2)
+                     .arg(i.buffer, 4)
+                     .arg(i.numberOfUnderruns, 8);
         }
     }
     s += QString("\nspeed                = %1\n").arg(speed, 10);
-    s +=   QString("target               = %1\n").arg(target, 10);
-    s +=   QString("g_nCpuCyclesFeedback =     %1\n").arg(g_nCpuCyclesFeedback, 6);
+    s += QString("target               = %1\n").arg(target, 10);
+    s += QString("g_nCpuCyclesFeedback =     %1\n").arg(g_nCpuCyclesFeedback, 6);
 
     ui->info->setPlainText(s);
 }
diff --git a/source/frontends/qt/audioinfo.h b/source/frontends/qt/audioinfo.h
index feeb17f55..67b3df24d 100644
--- a/source/frontends/qt/audioinfo.h
+++ b/source/frontends/qt/audioinfo.h
@@ -3,8 +3,9 @@
 
 #include <QWidget>
 
-namespace Ui {
-class AudioInfo;
+namespace Ui
+{
+    class AudioInfo;
 }
 
 class AudioInfo : public QWidget
diff --git a/source/frontends/qt/configuration.cpp b/source/frontends/qt/configuration.cpp
index 965a6299c..67032f104 100644
--- a/source/frontends/qt/configuration.cpp
+++ b/source/frontends/qt/configuration.cpp
@@ -1,16 +1,15 @@
 #include "configuration.h"
 
-
 namespace
 {
-    QString getKey(const std::string & section, const std::string & key)
+    QString getKey(const std::string &section, const std::string &key)
     {
         const QString qkey = QString::fromStdString(section) + "/" + QString::fromStdString(key);
         return qkey;
     }
-}
+} // namespace
 
-QVariant Configuration::getVariant(const std::string & section, const std::string & key) const
+QVariant Configuration::getVariant(const std::string &section, const std::string &key) const
 {
     const QString qkey = getKey(section, key);
     const QVariant value = mySettings.value(qkey);
@@ -21,34 +20,34 @@ QVariant Configuration::getVariant(const std::string & section, const std::strin
     return value;
 }
 
-std::string Configuration::getString(const std::string & section, const std::string & key) const
+std::string Configuration::getString(const std::string &section, const std::string &key) const
 {
     const QVariant value = getVariant(section, key);
     const std::string res = value.toString().toStdString();
     return res;
 }
 
-uint32_t Configuration::getDWord(const std::string & section, const std::string & key) const
+uint32_t Configuration::getDWord(const std::string &section, const std::string &key) const
 {
     const QVariant value = getVariant(section, key);
     const uint res = value.toUInt();
     return res;
 }
 
-bool Configuration::getBool(const std::string & section, const std::string & key) const
+bool Configuration::getBool(const std::string &section, const std::string &key) const
 {
     const QVariant value = getVariant(section, key);
     const bool res = value.toBool();
     return res;
 }
 
-void Configuration::putString(const std::string & section, const std::string & key, const std::string & value)
+void Configuration::putString(const std::string &section, const std::string &key, const std::string &value)
 {
     const QString s = QString::fromStdString(value);
     mySettings.setValue(getKey(section, key), QVariant::fromValue(s));
 }
 
-void Configuration::putDWord(const std::string & section, const std::string & key, const uint32_t value)
+void Configuration::putDWord(const std::string &section, const std::string &key, const uint32_t value)
 {
     mySettings.setValue(getKey(section, key), QVariant::fromValue(value));
 }
diff --git a/source/frontends/qt/configuration.h b/source/frontends/qt/configuration.h
index a7ba60545..6583d0bf5 100644
--- a/source/frontends/qt/configuration.h
+++ b/source/frontends/qt/configuration.h
@@ -8,12 +8,12 @@
 class Configuration : public Registry
 {
 public:
-    std::string getString(const std::string & section, const std::string & key) const override;
-    uint32_t getDWord(const std::string & section, const std::string & key) const override;
-    bool getBool(const std::string & section, const std::string & key) const override;
+    std::string getString(const std::string &section, const std::string &key) const override;
+    uint32_t getDWord(const std::string &section, const std::string &key) const override;
+    bool getBool(const std::string &section, const std::string &key) const override;
 
-    void putString(const std::string & section, const std::string & key, const std::string & value) override;
-    void putDWord(const std::string & section, const std::string & key, const uint32_t value) override;
+    void putString(const std::string &section, const std::string &key, const std::string &value) override;
+    void putDWord(const std::string &section, const std::string &key, const uint32_t value) override;
 
     std::map<std::string, std::map<std::string, std::string>> getAllValues() const override;
 
@@ -22,7 +22,7 @@ class Configuration : public Registry
 private:
     QSettings mySettings;
 
-    QVariant getVariant(const std::string & section, const std::string & key) const;
+    QVariant getVariant(const std::string &section, const std::string &key) const;
 };
 
 #endif // REGISTRY_H
diff --git a/source/frontends/qt/emulator.cpp b/source/frontends/qt/emulator.cpp
index 90f1c7bff..e05d031ce 100644
--- a/source/frontends/qt/emulator.cpp
+++ b/source/frontends/qt/emulator.cpp
@@ -6,9 +6,9 @@
 
 #include <cmath>
 
-Emulator::Emulator(QWidget *parent) :
-    QFrame(parent),
-    ui(new Ui::Emulator)
+Emulator::Emulator(QWidget *parent)
+    : QFrame(parent)
+    , ui(new Ui::Emulator)
 {
     ui->setupUi(this);
 }
@@ -30,7 +30,7 @@ void Emulator::refreshScreen(const bool force)
     }
 }
 
-bool Emulator::saveScreen(const QString & filename) const
+bool Emulator::saveScreen(const QString &filename) const
 {
     return ui->video->getScreen().save(filename);
 }
@@ -50,7 +50,7 @@ void Emulator::displayLogo()
     ui->video->displayLogo();
 }
 
-void Emulator::setVideoSize(QMdiSubWindow * window, const QSize & size)
+void Emulator::setVideoSize(QMdiSubWindow *window, const QSize &size)
 {
     window->showNormal();
 
@@ -59,20 +59,20 @@ void Emulator::setVideoSize(QMdiSubWindow * window, const QSize & size)
     window->resize(size + gap);
 }
 
-void Emulator::setZoom(QMdiSubWindow * window, const int x)
+void Emulator::setZoom(QMdiSubWindow *window, const int x)
 {
     const QSize target = ui->video->minimumSize() * x;
     setVideoSize(window, target);
 }
 
-void Emulator::set43AspectRatio(QMdiSubWindow * window)
+void Emulator::set43AspectRatio(QMdiSubWindow *window)
 {
     // keep the same surface with 4:3 aspect ratio
-    const QSize & size = ui->video->size();
+    const QSize &size = ui->video->size();
     const double area = size.height() * size.width();
 
-    const int numerator = 35;       // 7 * 40
-    const int denominator = 24;     // 8 * 24
+    const int numerator = 35;   // 7 * 40
+    const int denominator = 24; // 8 * 24
 
     const int x = sqrt(area / (numerator * denominator));
     const QSize target(numerator * x, denominator * x);
diff --git a/source/frontends/qt/emulator.h b/source/frontends/qt/emulator.h
index 0ef42919f..1d28d97d7 100644
--- a/source/frontends/qt/emulator.h
+++ b/source/frontends/qt/emulator.h
@@ -5,8 +5,9 @@
 
 class QMdiSubWindow;
 
-namespace Ui {
-class Emulator;
+namespace Ui
+{
+    class Emulator;
 }
 
 class Emulator : public QFrame
@@ -17,19 +18,19 @@ class Emulator : public QFrame
     explicit Emulator(QWidget *parent = nullptr);
     ~Emulator();
 
-    void redrawScreen();    // regenerate image and repaint
+    void redrawScreen(); // regenerate image and repaint
     void refreshScreen(const bool force);
 
-    bool saveScreen(const QString & filename) const;
+    bool saveScreen(const QString &filename) const;
     void loadVideoSettings();
     void unloadVideoSettings();
     void displayLogo();
 
-    void setZoom(QMdiSubWindow * window, const int x);
-    void set43AspectRatio(QMdiSubWindow * window);
+    void setZoom(QMdiSubWindow *window, const int x);
+    void set43AspectRatio(QMdiSubWindow *window);
 
 private:
-    void setVideoSize(QMdiSubWindow * window, const QSize & size);
+    void setVideoSize(QMdiSubWindow *window, const QSize &size);
 
 private:
     Ui::Emulator *ui;
diff --git a/source/frontends/qt/gamepadpaddle.cpp b/source/frontends/qt/gamepadpaddle.cpp
index 25a8a4f9c..7876a11a4 100644
--- a/source/frontends/qt/gamepadpaddle.cpp
+++ b/source/frontends/qt/gamepadpaddle.cpp
@@ -2,14 +2,14 @@
 
 #include <QGamepad>
 
-std::shared_ptr<Paddle> GamepadPaddle::fromName(const QString & name)
+std::shared_ptr<Paddle> GamepadPaddle::fromName(const QString &name)
 {
     if (name.isEmpty())
     {
         return nullptr;
     }
 
-    QGamepadManager * manager = QGamepadManager::instance();
+    QGamepadManager *manager = QGamepadManager::instance();
     const QList<int> gamepads = manager->connectedGamepads();
 
     for (int id : gamepads)
@@ -25,9 +25,9 @@ std::shared_ptr<Paddle> GamepadPaddle::fromName(const QString & name)
     return nullptr;
 }
 
-GamepadPaddle::GamepadPaddle(const std::shared_ptr<QGamepad> & gamepad) : myGamepad(gamepad)
+GamepadPaddle::GamepadPaddle(const std::shared_ptr<QGamepad> &gamepad)
+    : myGamepad(gamepad)
 {
-
 }
 
 bool GamepadPaddle::getButton(int i) const
diff --git a/source/frontends/qt/gamepadpaddle.h b/source/frontends/qt/gamepadpaddle.h
index bb6bc13a3..a25159785 100644
--- a/source/frontends/qt/gamepadpaddle.h
+++ b/source/frontends/qt/gamepadpaddle.h
@@ -9,8 +9,8 @@ class QString;
 class GamepadPaddle : public Paddle
 {
 public:
-    static std::shared_ptr<Paddle> fromName(const QString & name);
-    GamepadPaddle(const std::shared_ptr<QGamepad> & gamepad);
+    static std::shared_ptr<Paddle> fromName(const QString &name);
+    GamepadPaddle(const std::shared_ptr<QGamepad> &gamepad);
 
     bool getButton(int i) const override;
     double getAxis(int i) const override;
diff --git a/source/frontends/qt/main.cpp b/source/frontends/qt/main.cpp
index ad5dc13fb..1be1ff5be 100644
--- a/source/frontends/qt/main.cpp
+++ b/source/frontends/qt/main.cpp
@@ -8,7 +8,6 @@
 #include "linux/version.h"
 #include "applicationname.h"
 
-
 int main(int argc, char *argv[])
 {
     QApplication app(argc, argv);
diff --git a/source/frontends/qt/memorycontainer.cpp b/source/frontends/qt/memorycontainer.cpp
index 584eaad4c..5976b06e7 100644
--- a/source/frontends/qt/memorycontainer.cpp
+++ b/source/frontends/qt/memorycontainer.cpp
@@ -18,27 +18,25 @@ namespace
         QString comment;
     };
 
-    void setMetadata(QHexView* view, const Metadata_t & comment)
+    void setMetadata(QHexView *view, const Metadata_t &comment)
     {
         view->setMetadata(comment.begin, comment.end, comment.fgcolor, comment.bgcolor, comment.comment);
     }
-}
-
+} // namespace
 
-MemoryContainer::MemoryContainer(QWidget *parent) :
-    QTabWidget(parent),
-    ui(new Ui::MemoryContainer)
+MemoryContainer::MemoryContainer(QWidget *parent)
+    : QTabWidget(parent)
+    , ui(new Ui::MemoryContainer)
 {
     ui->setupUi(this);
 
     // main memory
-    char * mainBase = reinterpret_cast<char *>(MemGetMainPtr(0));
-    QHexDocument * mainDocument = QHexDocument::fromMemory<ViewBuffer>(mainBase, _6502_MEM_LEN, this);
+    char *mainBase = reinterpret_cast<char *>(MemGetMainPtr(0));
+    QHexDocument *mainDocument = QHexDocument::fromMemory<ViewBuffer>(mainBase, _6502_MEM_LEN, this);
     ui->main->setReadOnly(true);
     ui->main->setDocument(mainDocument);
 
-    const Metadata_t mainMetadata[] =
-    {
+    const Metadata_t mainMetadata[] = {
         {0x0400, 0x0800, Qt::blue, Qt::yellow, "Text Video Page 1"},
         {0x0800, 0x0C00, Qt::black, Qt::yellow, "Text Video Page 2"},
         {0x2000, 0x4000, Qt::blue, Qt::yellow, "HiRes Video Page 1"},
@@ -48,26 +46,25 @@ MemoryContainer::MemoryContainer(QWidget *parent) :
         {0xF800, 0x10000, Qt::white, Qt::red, "System Monitor"},
     };
 
-    for (const auto & metadata: mainMetadata)
+    for (const auto &metadata : mainMetadata)
     {
         setMetadata(ui->main, metadata);
     }
 
     // aux memory
-    char * auxBase = reinterpret_cast<char *>(MemGetAuxPtr(0));
-    QHexDocument * auxDocument = QHexDocument::fromMemory<ViewBuffer>(auxBase, _6502_MEM_LEN, this);
+    char *auxBase = reinterpret_cast<char *>(MemGetAuxPtr(0));
+    QHexDocument *auxDocument = QHexDocument::fromMemory<ViewBuffer>(auxBase, _6502_MEM_LEN, this);
     ui->aux->setReadOnly(true);
     ui->aux->setDocument(auxDocument);
 
-    const Metadata_t auxMetadata[] =
-    {
+    const Metadata_t auxMetadata[] = {
         {0x0400, 0x0800, Qt::blue, Qt::yellow, "Text Video Page 1"},
         {0x0800, 0x0C00, Qt::black, Qt::yellow, "Text Video Page 2"},
         {0x2000, 0x4000, Qt::blue, Qt::yellow, "HiRes Video Page 1"},
         {0x4000, 0x6000, Qt::black, Qt::yellow, "HiRes Video Page 2"},
     };
 
-    for (const auto & metadata: auxMetadata)
+    for (const auto &metadata : auxMetadata)
     {
         setMetadata(ui->aux, metadata);
     }
diff --git a/source/frontends/qt/memorycontainer.h b/source/frontends/qt/memorycontainer.h
index cc5473251..bffcac805 100644
--- a/source/frontends/qt/memorycontainer.h
+++ b/source/frontends/qt/memorycontainer.h
@@ -3,8 +3,9 @@
 
 #include <QTabWidget>
 
-namespace Ui {
-class MemoryContainer;
+namespace Ui
+{
+    class MemoryContainer;
 }
 
 class MemoryContainer : public QTabWidget
diff --git a/source/frontends/qt/options.cpp b/source/frontends/qt/options.cpp
index ee6587b87..a29bcf9c1 100644
--- a/source/frontends/qt/options.cpp
+++ b/source/frontends/qt/options.cpp
@@ -34,7 +34,7 @@ namespace
     const QString REG_TIMER = QString::fromUtf8("QApple/Emulator/Timer");
     const QString REG_FULL_SPEED = QString::fromUtf8("QApple/Emulator/Full Speed");
 
-    void insertDisk(Disk2InterfaceCard* pDisk2Card, const QString & filename, const int disk)
+    void insertDisk(Disk2InterfaceCard *pDisk2Card, const QString &filename, const int disk)
     {
         if (!pDisk2Card)
             return;
@@ -46,7 +46,8 @@ namespace
         else
         {
             const bool createMissingDisk = true;
-            const ImageError_e result = pDisk2Card->InsertDisk(disk, filename.toStdString().c_str(), IMAGE_USE_FILES_WRITE_PROTECT_STATUS, createMissingDisk);
+            const ImageError_e result = pDisk2Card->InsertDisk(
+                disk, filename.toStdString().c_str(), IMAGE_USE_FILES_WRITE_PROTECT_STATUS, createMissingDisk);
             if (result != eIMAGE_ERROR_NONE)
             {
                 const QString message = QString("Error [%1] inserting '%2'").arg(QString::number(result), filename);
@@ -55,7 +56,7 @@ namespace
         }
     }
 
-    void insertHD(HarddiskInterfaceCard * pHarddiskCard, const QString & filename, const int disk)
+    void insertHD(HarddiskInterfaceCard *pHarddiskCard, const QString &filename, const int disk)
     {
         if (!pHarddiskCard)
             return;
@@ -80,7 +81,7 @@ namespace
         if (slot >= NUM_SLOTS)
             return;
 
-        CardManager & cardManager = GetCardMgr();
+        CardManager &cardManager = GetCardMgr();
 
         // Two paths:
         // 1) Via Config dialog: card not inserted yet
@@ -89,7 +90,7 @@ namespace
             cardManager.Insert(slot, newCardType);
     }
 
-}
+} // namespace
 
 GlobalOptions::GlobalOptions()
 {
@@ -114,7 +115,7 @@ GlobalOptions GlobalOptions::fromQSettings()
     return options;
 }
 
-void GlobalOptions::setData(const GlobalOptions & data)
+void GlobalOptions::setData(const GlobalOptions &data)
 {
     if (this->msGap != data.msGap)
     {
@@ -163,21 +164,20 @@ void GlobalOptions::setData(const GlobalOptions & data)
         this->msAudioBuffer = data.msAudioBuffer;
         QSettings().setValue(REG_AUDIO_BUFFER, this->msAudioBuffer);
     }
-
 }
 
-void getAppleWinPreferences(PreferenceData & data)
+void getAppleWinPreferences(PreferenceData &data)
 {
-    CardManager & cardManager = GetCardMgr();
+    CardManager &cardManager = GetCardMgr();
 
     data.disks.resize(diskIDs.size());
-    Disk2InterfaceCard* pDisk2Card = dynamic_cast<Disk2InterfaceCard*>(cardManager.GetObj(SLOT6));
+    Disk2InterfaceCard *pDisk2Card = dynamic_cast<Disk2InterfaceCard *>(cardManager.GetObj(SLOT6));
 
     if (pDisk2Card)
     {
         for (size_t i = 0; i < diskIDs.size(); ++i)
         {
-            const std::string & diskName = pDisk2Card->GetFullName(diskIDs[i]);
+            const std::string &diskName = pDisk2Card->GetFullName(diskIDs[i]);
             if (!diskName.empty())
             {
                 data.disks[i] = QString::fromStdString(diskName);
@@ -186,13 +186,13 @@ void getAppleWinPreferences(PreferenceData & data)
     }
 
     data.hds.resize(hdIDs.size());
-    HarddiskInterfaceCard* pHarddiskCard = dynamic_cast<HarddiskInterfaceCard*>(cardManager.GetObj(SLOT7));
+    HarddiskInterfaceCard *pHarddiskCard = dynamic_cast<HarddiskInterfaceCard *>(cardManager.GetObj(SLOT7));
 
     if (pHarddiskCard)
     {
         for (size_t i = 0; i < hdIDs.size(); ++i)
         {
-            const std::string & diskName = pHarddiskCard->GetFullName(hdIDs[i]);
+            const std::string &diskName = pHarddiskCard->GetFullName(hdIDs[i]);
             if (!diskName.empty())
             {
                 data.hds[i] = QString::fromStdString(diskName);
@@ -211,13 +211,13 @@ void getAppleWinPreferences(PreferenceData & data)
     data.speakerVolume = SpkrGetVolume();
     data.mockingboardVolume = cardManager.GetMockingboardCardMgr().GetVolume();
 
-    const std::string & saveState = Snapshot_GetFilename();
+    const std::string &saveState = Snapshot_GetFilename();
     if (!saveState.empty())
     {
         data.saveState = QString::fromStdString(saveState);
     }
 
-    Video & video = GetVideo();
+    Video &video = GetVideo();
 
     data.videoType = video.GetVideoType();
     data.scanLines = video.IsVideoStyle(VS_HALF_SCANLINES);
@@ -227,8 +227,8 @@ void getAppleWinPreferences(PreferenceData & data)
 
     if (cardManager.IsParallelPrinterCardInstalled())
     {
-        ParallelPrinterCard* card = GetCardMgr().GetParallelPrinterCard();
-        const std::string & printerFilename = card->GetFilename();
+        ParallelPrinterCard *card = GetCardMgr().GetParallelPrinterCard();
+        const std::string &printerFilename = card->GetFilename();
         if (!printerFilename.empty())
         {
             data.printerFilename = QString::fromStdString(printerFilename);
@@ -236,11 +236,12 @@ void getAppleWinPreferences(PreferenceData & data)
     }
 }
 
-void setAppleWinPreferences(const std::shared_ptr<QtFrame> & frame, const PreferenceData & currentData, const PreferenceData & newData)
+void setAppleWinPreferences(
+    const std::shared_ptr<QtFrame> &frame, const PreferenceData &currentData, const PreferenceData &newData)
 {
-    CardManager & cardManager = GetCardMgr();
-    Disk2InterfaceCard* pDisk2Card = dynamic_cast<Disk2InterfaceCard*>(cardManager.GetObj(SLOT6));
-    HarddiskInterfaceCard* pHarddiskCard = dynamic_cast<HarddiskInterfaceCard*>(cardManager.GetObj(SLOT7));
+    CardManager &cardManager = GetCardMgr();
+    Disk2InterfaceCard *pDisk2Card = dynamic_cast<Disk2InterfaceCard *>(cardManager.GetObj(SLOT6));
+    HarddiskInterfaceCard *pHarddiskCard = dynamic_cast<HarddiskInterfaceCard *>(cardManager.GetObj(SLOT7));
 
     if (currentData.speakerVolume != newData.speakerVolume)
     {
@@ -312,17 +313,18 @@ void setAppleWinPreferences(const std::shared_ptr<QtFrame> & frame, const Prefer
     {
         if (cardManager.IsParallelPrinterCardInstalled())
         {
-            ParallelPrinterCard* card = cardManager.GetParallelPrinterCard();
+            ParallelPrinterCard *card = cardManager.GetParallelPrinterCard();
             const std::string name = newData.printerFilename.toStdString();
             card->SetFilename(name);
             RegSaveString(TEXT(REG_CONFIG), REGVALUE_PRINTER_FILENAME, 1, name);
         }
     }
 
-    if (currentData.videoType != newData.videoType || currentData.scanLines != newData.scanLines || currentData.verticalBlend != newData.verticalBlend
-            || currentData.hz50 != newData.hz50 || currentData.monochromeColor != newData.monochromeColor)
+    if (currentData.videoType != newData.videoType || currentData.scanLines != newData.scanLines ||
+        currentData.verticalBlend != newData.verticalBlend || currentData.hz50 != newData.hz50 ||
+        currentData.monochromeColor != newData.monochromeColor)
     {
-        Video & video = GetVideo();
+        Video &video = GetVideo();
 
         const VideoType_e videoType = VideoType_e(newData.videoType);
         video.SetVideoType(videoType);
@@ -343,5 +345,4 @@ void setAppleWinPreferences(const std::shared_ptr<QtFrame> & frame, const Prefer
 
         frame->ApplyVideoModeChange();
     }
-
 }
diff --git a/source/frontends/qt/options.h b/source/frontends/qt/options.h
index 221c35399..3ed5ae632 100644
--- a/source/frontends/qt/options.h
+++ b/source/frontends/qt/options.h
@@ -11,7 +11,7 @@
 class GlobalOptions
 {
 public:
-    GlobalOptions();  // empty, uninitialised
+    GlobalOptions(); // empty, uninitialised
 
     static GlobalOptions fromQSettings();
 
@@ -26,7 +26,7 @@ class GlobalOptions
 
     int msAudioBuffer;
 
-    void setData(const GlobalOptions & data);
+    void setData(const GlobalOptions &data);
 };
 
 struct PreferenceData
@@ -58,7 +58,8 @@ struct PreferenceData
 };
 
 class QtFrame;
-void getAppleWinPreferences(PreferenceData & data);
-void setAppleWinPreferences(const std::shared_ptr<QtFrame> & frame, const PreferenceData & currentData, const PreferenceData & newData);
+void getAppleWinPreferences(PreferenceData &data);
+void setAppleWinPreferences(
+    const std::shared_ptr<QtFrame> &frame, const PreferenceData &currentData, const PreferenceData &newData);
 
 #endif // CONFIGURATION_H
diff --git a/source/frontends/qt/preferences.cpp b/source/frontends/qt/preferences.cpp
index 58ee0e783..0ebb21057 100644
--- a/source/frontends/qt/preferences.cpp
+++ b/source/frontends/qt/preferences.cpp
@@ -18,7 +18,7 @@
 namespace
 {
 
-    int addDiskItem(QComboBox *disk, const QString & item)
+    int addDiskItem(QComboBox *disk, const QString &item)
     {
         if (!item.isEmpty())
         {
@@ -42,7 +42,7 @@ namespace
         return -1;
     }
 
-    void checkDuplicates(const std::vector<QComboBox *> & disks, const size_t id, const int new_selection)
+    void checkDuplicates(const std::vector<QComboBox *> &disks, const size_t id, const int new_selection)
     {
         if (new_selection >= 1)
         {
@@ -61,7 +61,7 @@ namespace
         }
     }
 
-    void initialiseDisks(const std::vector<QComboBox *> & disks, const std::vector<QString> & data)
+    void initialiseDisks(const std::vector<QComboBox *> &disks, const std::vector<QString> &data)
     {
         // share the same model for all disks in a group
         for (size_t i = 1; i < disks.size(); ++i)
@@ -74,7 +74,7 @@ namespace
         }
     }
 
-    void fillData(const std::vector<QComboBox *> & disks, std::vector<QString> & data)
+    void fillData(const std::vector<QComboBox *> &disks, std::vector<QString> &data)
     {
         data.resize(disks.size());
         for (size_t i = 0; i < disks.size(); ++i)
@@ -86,32 +86,32 @@ namespace
         }
     }
 
-    void processSettingsGroup(QSettings & settings, QTreeWidgetItem * item)
+    void processSettingsGroup(QSettings &settings, QTreeWidgetItem *item)
     {
         QList<QTreeWidgetItem *> items;
 
         // first the leaves
         const QStringList children = settings.childKeys();
-        for (const auto & child : children)
+        for (const auto &child : children)
         {
             QStringList columns;
-            columns.append(child); // the name
+            columns.append(child);                            // the name
             columns.append(settings.value(child).toString()); // the value
 
-            QTreeWidgetItem * newItem = new QTreeWidgetItem(item, columns);
+            QTreeWidgetItem *newItem = new QTreeWidgetItem(item, columns);
             items.append(newItem);
         }
 
         // then the subtrees
         const QStringList groups = settings.childGroups();
-        for (const auto & group : groups)
+        for (const auto &group : groups)
         {
             settings.beginGroup(group);
 
             QStringList columns;
             columns.append(group); // the name
 
-            QTreeWidgetItem * newItem = new QTreeWidgetItem(item, columns);
+            QTreeWidgetItem *newItem = new QTreeWidgetItem(item, columns);
             processSettingsGroup(settings, newItem); // process subtree
             items.append(newItem);
 
@@ -121,15 +121,14 @@ namespace
         item->addChildren(items);
     }
 
-    const std::vector<eApple2Type> computerTypes = {A2TYPE_APPLE2, A2TYPE_APPLE2PLUS, A2TYPE_APPLE2JPLUS, A2TYPE_APPLE2E,
-                                                    A2TYPE_APPLE2EENHANCED, A2TYPE_PRAVETS82, A2TYPE_PRAVETS8M, A2TYPE_PRAVETS8A,
-                                                    A2TYPE_BASE64A, A2TYPE_TK30002E};
+    const std::vector<eApple2Type> computerTypes = {
+        A2TYPE_APPLE2,    A2TYPE_APPLE2PLUS, A2TYPE_APPLE2JPLUS, A2TYPE_APPLE2E, A2TYPE_APPLE2EENHANCED,
+        A2TYPE_PRAVETS82, A2TYPE_PRAVETS8M,  A2TYPE_PRAVETS8A,   A2TYPE_BASE64A, A2TYPE_TK30002E};
     const std::vector<SS_CARDTYPE> cardsInSlot3 = {CT_Empty, CT_Uthernet, CT_Uthernet2, CT_VidHD};
     const std::vector<SS_CARDTYPE> cardsInSlot4 = {CT_Empty, CT_MouseInterface, CT_MockingboardC, CT_Phasor};
     const std::vector<SS_CARDTYPE> cardsInSlot5 = {CT_Empty, CT_Z80, CT_MockingboardC, CT_SAM};
 
-    template<class T>
-    int getIndexInList(const std::vector<T> & values, const T value, const int defaultValue)
+    template <class T> int getIndexInList(const std::vector<T> &values, const T value, const int defaultValue)
     {
         const auto it = std::find(values.begin(), values.end(), value);
         if (it != values.end())
@@ -142,11 +141,11 @@ namespace
         }
     }
 
-}
+} // namespace
 
-Preferences::Preferences(QWidget *parent) :
-    QDialog(parent),
-    ui(new Ui::Preferences)
+Preferences::Preferences(QWidget *parent)
+    : QDialog(parent)
+    , ui(new Ui::Preferences)
 {
     ui->setupUi(this);
 
@@ -162,7 +161,7 @@ Preferences::~Preferences()
     delete ui;
 }
 
-void Preferences::setup(const PreferenceData & data, QSettings & settings)
+void Preferences::setup(const PreferenceData &data, QSettings &settings)
 {
     populateJoysticks();
     setData(data);
@@ -175,7 +174,7 @@ void Preferences::populateJoysticks()
     ui->joystick->addItem("None"); // index = 0
 
 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
-    QGamepadManager * manager = QGamepadManager::instance();
+    QGamepadManager *manager = QGamepadManager::instance();
     const QList<int> gamepads = manager->connectedGamepads();
 
     for (int id : gamepads)
@@ -186,15 +185,15 @@ void Preferences::populateJoysticks()
 #endif
 }
 
-void Preferences::setSettings(QSettings & settings)
+void Preferences::setSettings(QSettings &settings)
 {
     ui->registryTree->clear();
 
     QStringList columns;
     columns.append(QString::fromUtf8("Registry")); // the name
-    columns.append(settings.fileName()); // the value
+    columns.append(settings.fileName());           // the value
 
-    QTreeWidgetItem * newItem = new QTreeWidgetItem(ui->registryTree, columns);
+    QTreeWidgetItem *newItem = new QTreeWidgetItem(ui->registryTree, columns);
     processSettingsGroup(settings, newItem);
 
     ui->registryTree->addTopLevelItem(newItem);
@@ -202,7 +201,7 @@ void Preferences::setSettings(QSettings & settings)
     ui->registryTree->resizeColumnToContents(0);
 }
 
-void Preferences::setData(const PreferenceData & data)
+void Preferences::setData(const PreferenceData &data)
 {
     ui->lc_0->setCurrentIndex(data.options.slot0Card);
     ui->timer_gap->setValue(data.options.msGap);
@@ -292,7 +291,7 @@ PreferenceData Preferences::getData() const
     return data;
 }
 
-void Preferences::browseDisk(const std::vector<QComboBox *> & vdisks, const size_t id)
+void Preferences::browseDisk(const std::vector<QComboBox *> &vdisks, const size_t id)
 {
     QFileDialog diskFileDialog(this);
     diskFileDialog.setFileMode(QFileDialog::AnyFile);
@@ -308,7 +307,7 @@ void Preferences::browseDisk(const std::vector<QComboBox *> & vdisks, const size
         QStringList files = diskFileDialog.selectedFiles();
         if (files.size() == 1)
         {
-            const QString & filename = files[0];
+            const QString &filename = files[0];
             const int selection = addDiskItem(vdisks[id], filename);
             // and now make sure there are no duplicates
             checkDuplicates(vdisks, id, selection);
@@ -389,5 +388,4 @@ void Preferences::on_browse_pf_clicked()
     {
         ui->printer_filename->setText(name);
     }
-
 }
diff --git a/source/frontends/qt/preferences.h b/source/frontends/qt/preferences.h
index ed9eace0e..70503f92e 100644
--- a/source/frontends/qt/preferences.h
+++ b/source/frontends/qt/preferences.h
@@ -9,8 +9,9 @@ class QComboBox;
 class QSettings;
 struct PreferenceData;
 
-namespace Ui {
-class Preferences;
+namespace Ui
+{
+    class Preferences;
 }
 
 class Preferences : public QDialog
@@ -18,11 +19,10 @@ class Preferences : public QDialog
     Q_OBJECT
 
 public:
-
     explicit Preferences(QWidget *parent);
     ~Preferences();
 
-    void setup(const PreferenceData & data, QSettings & settings);
+    void setup(const PreferenceData &data, QSettings &settings);
     PreferenceData getData() const;
 
 private slots:
@@ -50,10 +50,10 @@ private slots:
 
     QColor myMonochromeColor;
 
-    void setSettings(QSettings & settings);
-    void setData(const PreferenceData & data);
+    void setSettings(QSettings &settings);
+    void setData(const PreferenceData &data);
     void populateJoysticks();
-    void browseDisk(const std::vector<QComboBox *> & vdisks, const size_t id);
+    void browseDisk(const std::vector<QComboBox *> &vdisks, const size_t id);
 
 private:
     Ui::Preferences *ui;
diff --git a/source/frontends/qt/qapple.cpp b/source/frontends/qt/qapple.cpp
index 951e4f244..4225f33a7 100644
--- a/source/frontends/qt/qapple.cpp
+++ b/source/frontends/qt/qapple.cpp
@@ -64,10 +64,10 @@ namespace
     {
         return QApplication::platformName() == "wayland";
     }
-}
-
+} // namespace
 
-QApple::PauseEmulator::PauseEmulator(QApple * qapple) : myQApple(qapple)
+QApple::PauseEmulator::PauseEmulator(QApple *qapple)
+    : myQApple(qapple)
 {
     myWasRunning = myQApple->ui->actionPause->isEnabled();
     if (myWasRunning)
@@ -84,10 +84,10 @@ QApple::PauseEmulator::~PauseEmulator()
     }
 }
 
-QApple::QApple(QWidget *parent) :
-    QMainWindow(parent),
-    myTimerID(0),
-    ui(new Ui::QApple)
+QApple::QApple(QWidget *parent)
+    : QMainWindow(parent)
+    , myTimerID(0)
+    , ui(new Ui::QApple)
 {
     ui->setupUi(this);
 
@@ -108,8 +108,9 @@ QApple::QApple(QWidget *parent) :
 
     myPreferences = new Preferences(this);
 
-    Emulator * emulator = new Emulator(ui->mdiArea);
-    myEmulatorWindow = ui->mdiArea->addSubWindow(emulator, Qt::CustomizeWindowHint | Qt::WindowTitleHint | Qt::WindowMinMaxButtonsHint);
+    Emulator *emulator = new Emulator(ui->mdiArea);
+    myEmulatorWindow = ui->mdiArea->addSubWindow(
+        emulator, Qt::CustomizeWindowHint | Qt::WindowTitleHint | Qt::WindowMinMaxButtonsHint);
 
     myFrame = std::make_shared<QtFrame>(emulator, myEmulatorWindow);
     SetFrame(myFrame);
@@ -131,7 +132,7 @@ QApple::~QApple()
     delete ui;
 }
 
-void QApple::closeEvent(QCloseEvent * event)
+void QApple::closeEvent(QCloseEvent *event)
 {
     stopTimer();
     myFrame->End();
@@ -151,7 +152,8 @@ void QApple::readSettings()
     QSettings settings;
     const QByteArray windowGeometry = QByteArray::fromBase64(settings.value("QApple/window/geometry").toByteArray());
     const QByteArray windowState = QByteArray::fromBase64(settings.value("QApple/window/state").toByteArray());
-    const QByteArray emulatorGeometry = QByteArray::fromBase64(settings.value("QApple/emulator/geometry").toByteArray());
+    const QByteArray emulatorGeometry =
+        QByteArray::fromBase64(settings.value("QApple/emulator/geometry").toByteArray());
 
     restoreGeometry(windowGeometry);
     restoreState(windowState);
@@ -194,13 +196,14 @@ void QApple::on_timer()
         return;
     }
 
-    const qint64 maximumToRun = 10 * myOptions.msGap * audioAdjustedSpeed * 1.0e-3;  // just to avoid crazy times (e.g. debugging)
+    const qint64 maximumToRun =
+        10 * myOptions.msGap * audioAdjustedSpeed * 1.0e-3; // just to avoid crazy times (e.g. debugging)
     const qint64 toRun = std::min(targetCycles - currentCycles, maximumToRun);
     const uint32_t uCyclesToExecute = toRun;
 
     const bool bVideoUpdate = true;
 
-    CardManager & cardManager = GetCardMgr();
+    CardManager &cardManager = GetCardMgr();
 
     const qint64 wallclockTargetMS = elapsed + myOptions.msFullSpeed;
     const UINT dwClksPerFrame = NTSC_GetCyclesPerFrame();
@@ -216,21 +219,19 @@ void QApple::on_timer()
         // in case we run more than 1 frame
         g_dwCyclesThisFrame = g_dwCyclesThisFrame % dwClksPerFrame;
         ++count;
-    }
-    while (cardManager.GetDisk2CardMgr().IsConditionForFullSpeed() && (myElapsedTimer.elapsed() < wallclockTargetMS));
+    } while (cardManager.GetDisk2CardMgr().IsConditionForFullSpeed() && (myElapsedTimer.elapsed() < wallclockTargetMS));
 
     // just repaint each time, to make it simpler
     // we run @ 60 fps anyway
     myFrame->VideoPresentScreen();
 
-
     if (const qint64 nowElapsed = myElapsedTimer.elapsed())
     {
         const qint64 actualSpeed = 1000 * (g_nCumulativeCycles - myOrgStartCycles) / nowElapsed;
         emit endFrame(actualSpeed, static_cast<qint64>(audioAdjustedSpeed));
     }
 
-    if (count > 1)  // 1 is the non-full speed case
+    if (count > 1) // 1 is the non-full speed case
     {
         restartTimeCounters();
     }
@@ -311,8 +312,8 @@ void QApple::timerEvent(QTimerEvent *)
 
 void QApple::on_actionMemory_triggered()
 {
-    MemoryContainer * container = new MemoryContainer(ui->mdiArea);
-    QMdiSubWindow * window = ui->mdiArea->addSubWindow(container);
+    MemoryContainer *container = new MemoryContainer(ui->mdiArea);
+    QMdiSubWindow *window = ui->mdiArea->addSubWindow(container);
 
     // need to close as it points to old memory
     connect(this, SIGNAL(endEmulator()), window, SLOT(close()));
@@ -367,7 +368,7 @@ void QApple::on_actionLoad_state_triggered()
 
     emit endEmulator();
 
-    const std::string & filename = Snapshot_GetFilename();
+    const std::string &filename = Snapshot_GetFilename();
 
     const QFileInfo file(QString::fromStdString(filename));
     const QString path = file.absolutePath();
@@ -395,7 +396,7 @@ void QApple::on_actionAbout_triggered()
     QMessageBox::about(this, QApplication::applicationName(), message);
 }
 
-QString getImageFilename(const GlobalOptions & options)
+QString getImageFilename(const GlobalOptions &options)
 {
     static size_t counter = 0;
 
@@ -434,11 +435,11 @@ void QApple::on_actionScreenshot_triggered()
 void QApple::on_actionSwap_disks_triggered()
 {
     PauseEmulator pause(this);
-    CardManager & cardManager = GetCardMgr();
+    CardManager &cardManager = GetCardMgr();
 
     if (cardManager.QuerySlot(SLOT6) == CT_Disk2)
     {
-        dynamic_cast<Disk2InterfaceCard*>(cardManager.GetObj(SLOT6))->DriveSwap();
+        dynamic_cast<Disk2InterfaceCard *>(cardManager.GetObj(SLOT6))->DriveSwap();
     }
 }
 
@@ -454,7 +455,7 @@ void QApple::on_actionLoad_state_from_triggered()
         QStringList files = stateFileDialog.selectedFiles();
         if (files.size() == 1)
         {
-            const QString & filename = files[0];
+            const QString &filename = files[0];
             loadStateFile(filename);
         }
     }
@@ -465,7 +466,7 @@ void QApple::on_actionNext_video_mode_triggered()
     myFrame->CycleVideoType();
 }
 
-void QApple::loadStateFile(const QString & filename)
+void QApple::loadStateFile(const QString &filename)
 {
     const QFileInfo path(filename);
     // store it as absolute path
@@ -491,7 +492,7 @@ void QApple::dragEnterEvent(QDragEnterEvent *event)
 
 void QApple::dropEvent(QDropEvent *event)
 {
-    const QMimeData* mimeData = event->mimeData();
+    const QMimeData *mimeData = event->mimeData();
 
     if (mimeData->hasUrls())
     {
@@ -507,13 +508,13 @@ void QApple::dropEvent(QDropEvent *event)
                 loadStateFile(file);
             }
         }
-   }
+    }
 }
 
 void QApple::on_actionAudio_Info_triggered()
 {
-    AudioInfo * container = new AudioInfo(ui->mdiArea);
-    QMdiSubWindow * window = ui->mdiArea->addSubWindow(container);
+    AudioInfo *container = new AudioInfo(ui->mdiArea);
+    QMdiSubWindow *window = ui->mdiArea->addSubWindow(container);
 
     // need to close as it points to old memory
     connect(this, SIGNAL(endEmulator()), window, SLOT(close()));
diff --git a/source/frontends/qt/qapple.h b/source/frontends/qt/qapple.h
index ef62552d1..3eca2526a 100644
--- a/source/frontends/qt/qapple.h
+++ b/source/frontends/qt/qapple.h
@@ -1,7 +1,6 @@
 #ifndef QAPPLE_H
 #define QAPPLE_H
 
-
 #include <QMainWindow>
 #include <QElapsedTimer>
 #include <QAudio>
@@ -10,13 +9,13 @@
 
 #include "options.h"
 
-
 class QMdiSubWindow;
 class Preferences;
 class QtFrame;
 
-namespace Ui {
-class QApple;
+namespace Ui
+{
+    class QApple;
 }
 
 class QLabel;
@@ -29,7 +28,7 @@ class QApple : public QMainWindow
     explicit QApple(QWidget *parent = nullptr);
     ~QApple();
 
-    void loadStateFile(const QString & stateFile);
+    void loadStateFile(const QString &stateFile);
 
 signals:
     void endEmulator();
@@ -87,18 +86,17 @@ private slots:
     void on_actionAudio_Info_triggered();
 
 private:
-
     // helper class to pause the emulator and restart at the end of the block
     class PauseEmulator
     {
     public:
-        PauseEmulator(QApple * qapple);
+        PauseEmulator(QApple *qapple);
 
         ~PauseEmulator();
 
     private:
         bool myWasRunning;
-        QApple * myQApple;
+        QApple *myQApple;
     };
 
     void readSettings();
@@ -107,15 +105,15 @@ private slots:
     void reloadOptions();
 
     int myTimerID;
-    Preferences * myPreferences;
+    Preferences *myPreferences;
 
-    QLabel * mySaveStateLabel;
+    QLabel *mySaveStateLabel;
 
     std::shared_ptr<QtFrame> myFrame;
     QElapsedTimer myElapsedTimer;
     qint64 myStartCycles;
     qint64 myOrgStartCycles;
-    QMdiSubWindow * myEmulatorWindow;
+    QMdiSubWindow *myEmulatorWindow;
 
     GlobalOptions myOptions;
 
diff --git a/source/frontends/qt/qdirectsound.cpp b/source/frontends/qt/qdirectsound.cpp
index 3996b881e..affd625d3 100644
--- a/source/frontends/qt/qdirectsound.cpp
+++ b/source/frontends/qt/qdirectsound.cpp
@@ -28,10 +28,10 @@ namespace
         virtual ~DirectSoundGenerator() override;
 
         virtual HRESULT Stop() override;
-        virtual HRESULT Play( DWORD dwReserved1, DWORD dwReserved2, DWORD dwFlags ) override;
-        virtual HRESULT SetVolume( LONG lVolume ) override;
+        virtual HRESULT Play(DWORD dwReserved1, DWORD dwReserved2, DWORD dwFlags) override;
+        virtual HRESULT SetVolume(LONG lVolume) override;
 
-        void setOptions(const qint64 duration);  // in ms
+        void setOptions(const qint64 duration); // in ms
         QDirectSound::SoundInfo getInfo();
 
     protected:
@@ -44,8 +44,9 @@ namespace
 
     std::unordered_set<DirectSoundGenerator *> activeSoundGenerators;
 
-    DirectSoundGenerator::DirectSoundGenerator(DWORD dwBufferSize, DWORD nSampleRate, int nChannels, LPCSTR pszVoiceName) 
-    : LinuxSoundBuffer(dwBufferSize, nSampleRate, nChannels, pszVoiceName)
+    DirectSoundGenerator::DirectSoundGenerator(
+        DWORD dwBufferSize, DWORD nSampleRate, int nChannels, LPCSTR pszVoiceName)
+        : LinuxSoundBuffer(dwBufferSize, nSampleRate, nChannels, pszVoiceName)
     {
         // only initialise here to skip all the buffers which are not in DSBSTATUS_PLAYING mode
         QAudioFormat audioFormat;
@@ -72,7 +73,7 @@ namespace
         myAudioOutput->stop();
     }
 
-    void DirectSoundGenerator::setOptions(const qint64 duration)  // in ms
+    void DirectSoundGenerator::setOptions(const qint64 duration) // in ms
     {
         const qint64 buffer = myAudioOutput->format().bytesForDuration(duration * 1000);
         if (buffer == myAudioOutput->bufferSize())
@@ -94,11 +95,12 @@ namespace
         }
     }
 
-    HRESULT DirectSoundGenerator::SetVolume( LONG lVolume )
+    HRESULT DirectSoundGenerator::SetVolume(LONG lVolume)
     {
         const HRESULT res = LinuxSoundBuffer::SetVolume(lVolume);
         const qreal logVolume = GetLogarithmicVolume();
-        const qreal linVolume = QAudio::convertVolume(logVolume, QAudio::LogarithmicVolumeScale, QAudio::LinearVolumeScale);
+        const qreal linVolume =
+            QAudio::convertVolume(logVolume, QAudio::LogarithmicVolumeScale, QAudio::LinearVolumeScale);
         myAudioOutput->setVolume(linVolume);
         return res;
     }
@@ -111,7 +113,7 @@ namespace
         return res;
     }
 
-    HRESULT DirectSoundGenerator::Play( DWORD dwReserved1, DWORD dwReserved2, DWORD dwFlags )
+    HRESULT DirectSoundGenerator::Play(DWORD dwReserved1, DWORD dwReserved2, DWORD dwFlags)
     {
         const HRESULT res = LinuxSoundBuffer::Play(dwReserved1, dwReserved2, dwFlags);
         QIODevice::open(ReadOnly);
@@ -126,7 +128,7 @@ namespace
 
         const size_t bytesRead = Read(maxlen, &lpvAudioPtr1, &dwAudioBytes1, &lpvAudioPtr2, &dwAudioBytes2);
 
-        char * dest = data;
+        char *dest = data;
         if (lpvAudioPtr1 && dwAudioBytes1)
         {
             memcpy(dest, lpvAudioPtr1, dwAudioBytes1);
@@ -152,7 +154,7 @@ namespace
         if (info.running)
         {
             const uint32_t bytesInBuffer = GetBytesInBuffer();
-            const auto & format = myAudioOutput->format();
+            const auto &format = myAudioOutput->format();
             info.buffer = format.durationForBytes(bytesInBuffer) / 1000;
             info.size = format.durationForBytes(myBufferSize) / 1000;
         }
@@ -166,22 +168,24 @@ namespace
         return 0;
     }
 
-}
+} // namespace
 
 namespace QDirectSound
 {
 
-    std::shared_ptr<SoundBuffer> iCreateDirectSoundBuffer(uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char* pszVoiceName)
+    std::shared_ptr<SoundBuffer> iCreateDirectSoundBuffer(
+        uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char *pszVoiceName)
     {
         try
         {
-            std::shared_ptr<DirectSoundGenerator> generator = std::make_shared<DirectSoundGenerator>(dwBufferSize, nSampleRate, nChannels, pszVoiceName);
+            std::shared_ptr<DirectSoundGenerator> generator =
+                std::make_shared<DirectSoundGenerator>(dwBufferSize, nSampleRate, nChannels, pszVoiceName);
             generator->setOptions(defaultDuration);
-            DirectSoundGenerator * ptr = generator.get();
+            DirectSoundGenerator *ptr = generator.get();
             activeSoundGenerators.insert(ptr);
             return generator;
         }
-        catch (const std::exception & e)
+        catch (const std::exception &e)
         {
             qDebug(appleAudio) << "SoundBuffer: " << e.what();
             return nullptr;
@@ -193,9 +197,9 @@ namespace QDirectSound
         // this is necessary for the first initialisation
         // which happens before any buffer is created
         defaultDuration = duration;
-        for (const auto & it : activeSoundGenerators)
+        for (const auto &it : activeSoundGenerators)
         {
-            const auto & generator = it;
+            const auto &generator = it;
             generator->setOptions(duration);
         }
     }
@@ -205,13 +209,13 @@ namespace QDirectSound
         std::vector<SoundInfo> info;
         info.reserve(activeSoundGenerators.size());
 
-        for (const auto & it : activeSoundGenerators)
+        for (const auto &it : activeSoundGenerators)
         {
-            const auto & generator = it;
+            const auto &generator = it;
             info.push_back(generator->getInfo());
         }
 
         return info;
     }
 
-}
+} // namespace QDirectSound
diff --git a/source/frontends/qt/qdirectsound.h b/source/frontends/qt/qdirectsound.h
index de27e6a4d..cab330fee 100644
--- a/source/frontends/qt/qdirectsound.h
+++ b/source/frontends/qt/qdirectsound.h
@@ -24,10 +24,11 @@ namespace QDirectSound
         size_t numberOfUnderruns = 0;
     };
 
-    std::shared_ptr<SoundBuffer> iCreateDirectSoundBuffer(uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char* pszVoiceName);
+    std::shared_ptr<SoundBuffer> iCreateDirectSoundBuffer(
+        uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char *pszVoiceName);
 
-    void setOptions(const qint64 duration);  // in ms
+    void setOptions(const qint64 duration); // in ms
     std::vector<SoundInfo> getAudioInfo();
-}
+} // namespace QDirectSound
 
 #endif // DIRECTSOUND_H
diff --git a/source/frontends/qt/qtframe.cpp b/source/frontends/qt/qtframe.cpp
index a6de832f8..abb73ab4c 100644
--- a/source/frontends/qt/qtframe.cpp
+++ b/source/frontends/qt/qtframe.cpp
@@ -13,13 +13,12 @@
 #include <QMessageBox>
 #include <QStandardPaths>
 
-QtFrame::QtFrame(Emulator * emulator, QMdiSubWindow * window) 
-: LinuxFrame(true)
-, myEmulator(emulator)
-, myWindow(window)
-, myForceRepaint(false)
+QtFrame::QtFrame(Emulator *emulator, QMdiSubWindow *window)
+    : LinuxFrame(true)
+    , myEmulator(emulator)
+    , myWindow(window)
+    , myForceRepaint(false)
 {
-
 }
 
 void QtFrame::SetForceRepaint(const bool force)
@@ -65,7 +64,7 @@ void QtFrame::Set43Ratio()
     myEmulator->set43AspectRatio(myWindow);
 }
 
-bool QtFrame::saveScreen(const QString & filename) const
+bool QtFrame::saveScreen(const QString &filename) const
 {
     return myEmulator->saveScreen(filename);
 }
@@ -115,7 +114,8 @@ std::string QtFrame::Video_GetScreenShotFolder() const
     return pictures.toStdString() + "/";
 }
 
-std::shared_ptr<SoundBuffer> QtFrame::CreateSoundBuffer(uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char* pszVoiceName)
+std::shared_ptr<SoundBuffer> QtFrame::CreateSoundBuffer(
+    uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char *pszVoiceName)
 {
     const auto buffer = QDirectSound::iCreateDirectSoundBuffer(dwBufferSize, nSampleRate, nChannels, pszVoiceName);
     return buffer;
@@ -123,5 +123,4 @@ std::shared_ptr<SoundBuffer> QtFrame::CreateSoundBuffer(uint32_t dwBufferSize, u
 
 void SingleStep(bool /* bReinit */)
 {
-
 }
diff --git a/source/frontends/qt/qtframe.h b/source/frontends/qt/qtframe.h
index 7ba01cdaa..d7e6ca4ed 100644
--- a/source/frontends/qt/qtframe.h
+++ b/source/frontends/qt/qtframe.h
@@ -12,7 +12,7 @@ class QMdiSubWindow;
 class QtFrame : public LinuxFrame
 {
 public:
-    QtFrame(Emulator * emulator, QMdiSubWindow * window);
+    QtFrame(Emulator *emulator, QMdiSubWindow *window);
 
     void VideoPresentScreen() override;
     void FrameRefreshStatus(int drawflags) override;
@@ -22,16 +22,17 @@ class QtFrame : public LinuxFrame
     int FrameMessageBox(LPCSTR lpText, LPCSTR lpCaption, UINT uType) override;
     std::string Video_GetScreenShotFolder() const override;
 
-    std::shared_ptr<SoundBuffer> CreateSoundBuffer(uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char* pszVoiceName) override;
+    std::shared_ptr<SoundBuffer> CreateSoundBuffer(
+        uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char *pszVoiceName) override;
 
     void SetForceRepaint(const bool force);
     void SetZoom(const int x);
     void Set43Ratio();
-    bool saveScreen(const QString & filename) const;
+    bool saveScreen(const QString &filename) const;
 
 private:
-    Emulator * myEmulator;
-    QMdiSubWindow * myWindow;
+    Emulator *myEmulator;
+    QMdiSubWindow *myWindow;
     bool myForceRepaint;
 
     std::pair<const unsigned char *, unsigned int> GetResourceData(WORD id) const override;
diff --git a/source/frontends/qt/qvideo.cpp b/source/frontends/qt/qvideo.cpp
index 0b21ba7d0..e559c644c 100644
--- a/source/frontends/qt/qvideo.cpp
+++ b/source/frontends/qt/qvideo.cpp
@@ -13,7 +13,8 @@
 #include "Video.h"
 #include "Interface.h"
 
-QVideo::QVideo(QWidget *parent) : QVIDEO_BASECLASS(parent)
+QVideo::QVideo(QWidget *parent)
+    : QVIDEO_BASECLASS(parent)
 {
     this->setMouseTracking(true);
 
@@ -22,7 +23,7 @@ QVideo::QVideo(QWidget *parent) : QVIDEO_BASECLASS(parent)
 
 void QVideo::loadVideoSettings()
 {
-    Video & video = GetVideo();
+    Video &video = GetVideo();
 
     mySX = video.GetFrameBufferBorderWidth();
     mySY = video.GetFrameBufferBorderHeight();
@@ -193,7 +194,7 @@ void QVideo::keyPressEvent(QKeyEvent *event)
         const Qt::KeyboardModifiers modifiers = event->modifiers();
         if (modifiers & Qt::ControlModifier)
         {
-           ch = 0x1f;
+            ch = 0x1f;
         }
         break;
     }
@@ -206,7 +207,6 @@ void QVideo::keyPressEvent(QKeyEvent *event)
     }
     }
 
-
     if (ch)
     {
         addKeyToBuffer(ch);
@@ -219,7 +219,7 @@ void QVideo::keyPressEvent(QKeyEvent *event)
 
 void QVideo::mouseMoveEvent(QMouseEvent *event)
 {
-    CardManager & cardManager = GetCardMgr();
+    CardManager &cardManager = GetCardMgr();
 
     if (cardManager.IsMouseCardInstalled() && cardManager.GetMouseCard()->IsActiveAndEnabled())
     {
@@ -250,7 +250,7 @@ void QVideo::mouseMoveEvent(QMouseEvent *event)
 
 void QVideo::mousePressEvent(QMouseEvent *event)
 {
-    CardManager & cardManager = GetCardMgr();
+    CardManager &cardManager = GetCardMgr();
 
     if (cardManager.IsMouseCardInstalled() && cardManager.GetMouseCard()->IsActiveAndEnabled())
     {
@@ -272,7 +272,7 @@ void QVideo::mousePressEvent(QMouseEvent *event)
 
 void QVideo::mouseReleaseEvent(QMouseEvent *event)
 {
-    CardManager & cardManager = GetCardMgr();
+    CardManager &cardManager = GetCardMgr();
 
     if (cardManager.IsMouseCardInstalled() && cardManager.GetMouseCard()->IsActiveAndEnabled())
     {
diff --git a/source/frontends/qt/qvideo.h b/source/frontends/qt/qvideo.h
index e815c907d..8ff5019b2 100644
--- a/source/frontends/qt/qvideo.h
+++ b/source/frontends/qt/qvideo.h
@@ -4,7 +4,7 @@
 #include <QOpenGLWidget>
 
 #define QVIDEO_BASECLASS QOpenGLWidget
-//#define QVIDEO_BASECLASS QWidget
+// #define QVIDEO_BASECLASS QWidget
 
 class QVideo : public QVIDEO_BASECLASS
 {
@@ -44,7 +44,7 @@ public slots:
     int myLogoX;
     int myLogoY;
 
-    quint8 * myFrameBuffer;
+    quint8 *myFrameBuffer;
 
     QImage getScreenImage() const;
 };
diff --git a/source/frontends/qt/viewbuffer.cpp b/source/frontends/qt/viewbuffer.cpp
index 0e9e12659..4544040c5 100644
--- a/source/frontends/qt/viewbuffer.cpp
+++ b/source/frontends/qt/viewbuffer.cpp
@@ -1,8 +1,8 @@
 #include "viewbuffer.h"
 
-ViewBuffer::ViewBuffer(QObject *parent) : QHexBuffer(parent)
+ViewBuffer::ViewBuffer(QObject *parent)
+    : QHexBuffer(parent)
 {
-
 }
 
 uchar ViewBuffer::at(qint64 idx)
@@ -10,18 +10,18 @@ uchar ViewBuffer::at(qint64 idx)
     return static_cast<uchar>(myData.at(idx));
 }
 
-void ViewBuffer::replace(qint64 offset, const QByteArray& data)
+void ViewBuffer::replace(qint64 offset, const QByteArray &data)
 {
     Q_UNUSED(offset)
     Q_UNUSED(data)
 }
 
-void ViewBuffer::read(char* data, int size)
+void ViewBuffer::read(char *data, int size)
 {
     myData.setRawData(data, static_cast<uint>(size));
 }
 
-void ViewBuffer::read(const QByteArray& ba)
+void ViewBuffer::read(const QByteArray &ba)
 {
     Q_UNUSED(ba)
 }
@@ -31,7 +31,7 @@ qint64 ViewBuffer::length() const
     return myData.length();
 }
 
-void ViewBuffer::insert(qint64 offset, const QByteArray& data)
+void ViewBuffer::insert(qint64 offset, const QByteArray &data)
 {
     Q_UNUSED(offset)
     Q_UNUSED(data)
@@ -48,23 +48,23 @@ QByteArray ViewBuffer::read(qint64 offset, int length)
     return myData.mid(offset, length);
 }
 
-bool ViewBuffer::read(QIODevice* iodevice)
+bool ViewBuffer::read(QIODevice *iodevice)
 {
     Q_UNUSED(iodevice)
     return false;
 }
 
-void ViewBuffer::write(QIODevice* iodevice)
+void ViewBuffer::write(QIODevice *iodevice)
 {
     Q_UNUSED(iodevice)
 }
 
-qint64 ViewBuffer::indexOf(const QByteArray& ba, qint64 from)
+qint64 ViewBuffer::indexOf(const QByteArray &ba, qint64 from)
 {
     return myData.indexOf(ba, static_cast<int>(from));
 }
 
-qint64 ViewBuffer::lastIndexOf(const QByteArray& ba, qint64 from)
+qint64 ViewBuffer::lastIndexOf(const QByteArray &ba, qint64 from)
 {
     return myData.lastIndexOf(ba, static_cast<int>(from));
 }
diff --git a/source/frontends/qt/viewbuffer.h b/source/frontends/qt/viewbuffer.h
index bb9d3e2a0..4ec3deaa0 100644
--- a/source/frontends/qt/viewbuffer.h
+++ b/source/frontends/qt/viewbuffer.h
@@ -12,20 +12,21 @@ class ViewBuffer : public QHexBuffer
 
 public:
     uchar at(qint64 idx) override;
-    void replace(qint64 offset, const QByteArray& data) override;
-    void read(char* data, int size) override;
-    void read(const QByteArray& ba) override;
+    void replace(qint64 offset, const QByteArray &data) override;
+    void read(char *data, int size) override;
+    void read(const QByteArray &ba) override;
 
 public:
     qint64 length() const override;
-    void insert(qint64 offset, const QByteArray& data) override;
+    void insert(qint64 offset, const QByteArray &data) override;
     void remove(qint64 offset, int length) override;
     QByteArray read(qint64 offset, int length) override;
-    bool read(QIODevice* iodevice) override;
-    void write(QIODevice* iodevice) override;
+    bool read(QIODevice *iodevice) override;
+    void write(QIODevice *iodevice) override;
+
+    qint64 indexOf(const QByteArray &ba, qint64 from) override;
+    qint64 lastIndexOf(const QByteArray &ba, qint64 from) override;
 
-    qint64 indexOf(const QByteArray& ba, qint64 from) override;
-    qint64 lastIndexOf(const QByteArray& ba, qint64 from) override;
 private:
     QByteArray myData;
 };
diff --git a/source/frontends/sdl/gamepad.cpp b/source/frontends/sdl/gamepad.cpp
index 3963adf38..d1e01f39e 100644
--- a/source/frontends/sdl/gamepad.cpp
+++ b/source/frontends/sdl/gamepad.cpp
@@ -8,83 +8,83 @@
 #define AXIS_MIN -32768
 #define AXIS_MAX 32767
 
-
 namespace sa2
 {
 
-  std::shared_ptr<Gamepad> Gamepad::create(const std::optional<int> & index, const std::string & mappingFile)
-  {
-    if (!index && SDL_NumJoysticks() <= 0)
+    std::shared_ptr<Gamepad> Gamepad::create(const std::optional<int> &index, const std::string &mappingFile)
     {
-      // default and no joysticks available
-      return std::shared_ptr<Gamepad>();
-    }
+        if (!index && SDL_NumJoysticks() <= 0)
+        {
+            // default and no joysticks available
+            return std::shared_ptr<Gamepad>();
+        }
 
-    if (!mappingFile.empty())
-    {
-      const int res = SDL_GameControllerAddMappingsFromFile(mappingFile.c_str());
-      if (res < 0)
-      {
-        throw std::runtime_error(decorateSDLError("SDL_GameControllerAddMappingsFromFile"));
-      }
-      std::cerr << "SDL Game Controller: Loaded " << res << " mappings" << std::endl;
-    }
+        if (!mappingFile.empty())
+        {
+            const int res = SDL_GameControllerAddMappingsFromFile(mappingFile.c_str());
+            if (res < 0)
+            {
+                throw std::runtime_error(decorateSDLError("SDL_GameControllerAddMappingsFromFile"));
+            }
+            std::cerr << "SDL Game Controller: Loaded " << res << " mappings" << std::endl;
+        }
 
-    try
-    {
-      return std::make_shared<Gamepad>(index.value_or(0));
-    } 
-    catch (const std::runtime_error & e) 
-    {
-      if (!index)
-      {
-        // first game controller exists, but it is not usable
-        // since it was not explicitly required, do not throw
-        std::cerr << e.what() << std::endl;
-        return std::shared_ptr<Gamepad>();
-      }
-      throw;
+        try
+        {
+            return std::make_shared<Gamepad>(index.value_or(0));
+        }
+        catch (const std::runtime_error &e)
+        {
+            if (!index)
+            {
+                // first game controller exists, but it is not usable
+                // since it was not explicitly required, do not throw
+                std::cerr << e.what() << std::endl;
+                return std::shared_ptr<Gamepad>();
+            }
+            throw;
+        }
     }
-  }
 
-  Gamepad::Gamepad(const int index)
-    : myButtonCodes(2), myAxisCodes(2)
-  {
-    myController.reset(SDL_GameControllerOpen(index), SDL_GameControllerClose);
-    if (!myController)
+    Gamepad::Gamepad(const int index)
+        : myButtonCodes(2)
+        , myAxisCodes(2)
     {
-      throw std::runtime_error(decorateSDLError("SDL_GameControllerOpen"));
-    }
-    std::cerr << "SDL Game Controller: " << SDL_GameControllerName(myController.get()) << std::endl;
-
-    myButtonCodes[0] = SDL_CONTROLLER_BUTTON_A;
-    myButtonCodes[1] = SDL_CONTROLLER_BUTTON_B;
-    myAxisCodes[0] = SDL_CONTROLLER_AXIS_LEFTX;
-    myAxisCodes[1] = SDL_CONTROLLER_AXIS_LEFTY;
-  }
+        myController.reset(SDL_GameControllerOpen(index), SDL_GameControllerClose);
+        if (!myController)
+        {
+            throw std::runtime_error(decorateSDLError("SDL_GameControllerOpen"));
+        }
+        std::cerr << "SDL Game Controller: " << SDL_GameControllerName(myController.get()) << std::endl;
 
-  bool Gamepad::getButton(int i) const
-  {
-    int value = 0;
-    if (myController)
-    {
-      value = SDL_GameControllerGetButton(myController.get(), myButtonCodes[i]);
+        myButtonCodes[0] = SDL_CONTROLLER_BUTTON_A;
+        myButtonCodes[1] = SDL_CONTROLLER_BUTTON_B;
+        myAxisCodes[0] = SDL_CONTROLLER_AXIS_LEFTX;
+        myAxisCodes[1] = SDL_CONTROLLER_AXIS_LEFTY;
     }
-    return value != 0;
-  }
 
-  double Gamepad::getAxis(int i) const
-  {
-    if (myController)
+    bool Gamepad::getButton(int i) const
     {
-      const int value = SDL_GameControllerGetAxis(myController.get(), myAxisCodes[i]);
-      const double axis = 2.0 * double(value - AXIS_MIN) / double(AXIS_MAX - AXIS_MIN) - 1.0;
-      return axis;
+        int value = 0;
+        if (myController)
+        {
+            value = SDL_GameControllerGetButton(myController.get(), myButtonCodes[i]);
+        }
+        return value != 0;
     }
-    else
+
+    double Gamepad::getAxis(int i) const
     {
-      return 0.0;
+        if (myController)
+        {
+            const int value = SDL_GameControllerGetAxis(myController.get(), myAxisCodes[i]);
+            const double axis = 2.0 * double(value - AXIS_MIN) / double(AXIS_MAX - AXIS_MIN) - 1.0;
+            return axis;
+        }
+        else
+        {
+            return 0.0;
+        }
     }
-  }
 
-}
+} // namespace sa2
diff --git a/source/frontends/sdl/gamepad.h b/source/frontends/sdl/gamepad.h
index ad31477a9..ef68c0de0 100644
--- a/source/frontends/sdl/gamepad.h
+++ b/source/frontends/sdl/gamepad.h
@@ -11,20 +11,20 @@
 namespace sa2
 {
 
-  class Gamepad : public Paddle
-  {
-  public:
-    static std::shared_ptr<Gamepad> create(const std::optional<int> & index, const std::string & mappingFile);
-    Gamepad(const int index);
+    class Gamepad : public Paddle
+    {
+    public:
+        static std::shared_ptr<Gamepad> create(const std::optional<int> &index, const std::string &mappingFile);
+        Gamepad(const int index);
 
-    bool getButton(int i) const override;
-    double getAxis(int i) const override;
+        bool getButton(int i) const override;
+        double getAxis(int i) const override;
 
-  private:
-    std::shared_ptr<SDL_GameController> myController;
+    private:
+        std::shared_ptr<SDL_GameController> myController;
 
-    std::vector<SDL_GameControllerButton> myButtonCodes;
-    std::vector<SDL_GameControllerAxis> myAxisCodes;
-  };
+        std::vector<SDL_GameControllerButton> myButtonCodes;
+        std::vector<SDL_GameControllerAxis> myAxisCodes;
+    };
 
-}
+} // namespace sa2
diff --git a/source/frontends/sdl/imgui/cycletabitems.cpp b/source/frontends/sdl/imgui/cycletabitems.cpp
index 2b45606f6..80d16c1b3 100644
--- a/source/frontends/sdl/imgui/cycletabitems.cpp
+++ b/source/frontends/sdl/imgui/cycletabitems.cpp
@@ -6,45 +6,45 @@
 namespace sa2
 {
 
-  void CycleTabItems::init()
-  {
-    myTabID = 0;
-    myNextToSelect.reset();
-  }
-
-  bool CycleTabItems::beginTabBar(const char * str_id)
-  {
-    return ImGui::BeginTabBar(str_id);
-  }
-
-  bool CycleTabItems::beginTabItem(const char * label)
-  {
-    const bool isSelected = myNextToSelect.has_value() && myNextToSelect.value() == myTabID;
-    const ImGuiTabItemFlags tabFlags = isSelected ? ImGuiTabItemFlags_SetSelected : 0;
-
-    const bool res = ImGui::BeginTabItem(label, nullptr, tabFlags);
-    if (res)
+    void CycleTabItems::init()
     {
-      mySelectedTab = myTabID;
+        myTabID = 0;
+        myNextToSelect.reset();
     }
-    ++myTabID;
-    myNumberOfTabs = std::max(myNumberOfTabs, myTabID);
-    return res;
-  }
-
-  void CycleTabItems::prev()
-  {
-    if (mySelectedTab == 0)
+
+    bool CycleTabItems::beginTabBar(const char *str_id)
     {
-      mySelectedTab = myNumberOfTabs;
+        return ImGui::BeginTabBar(str_id);
     }
 
-    myNextToSelect = mySelectedTab - 1;
-  }
+    bool CycleTabItems::beginTabItem(const char *label)
+    {
+        const bool isSelected = myNextToSelect.has_value() && myNextToSelect.value() == myTabID;
+        const ImGuiTabItemFlags tabFlags = isSelected ? ImGuiTabItemFlags_SetSelected : 0;
+
+        const bool res = ImGui::BeginTabItem(label, nullptr, tabFlags);
+        if (res)
+        {
+            mySelectedTab = myTabID;
+        }
+        ++myTabID;
+        myNumberOfTabs = std::max(myNumberOfTabs, myTabID);
+        return res;
+    }
+
+    void CycleTabItems::prev()
+    {
+        if (mySelectedTab == 0)
+        {
+            mySelectedTab = myNumberOfTabs;
+        }
 
-  void CycleTabItems::next()
-  {
-    myNextToSelect = (mySelectedTab + 1) % myNumberOfTabs;
-  }
+        myNextToSelect = mySelectedTab - 1;
+    }
+
+    void CycleTabItems::next()
+    {
+        myNextToSelect = (mySelectedTab + 1) % myNumberOfTabs;
+    }
 
-}
+} // namespace sa2
diff --git a/source/frontends/sdl/imgui/cycletabitems.h b/source/frontends/sdl/imgui/cycletabitems.h
index 1a56bc8b5..ca7cd5d11 100644
--- a/source/frontends/sdl/imgui/cycletabitems.h
+++ b/source/frontends/sdl/imgui/cycletabitems.h
@@ -5,20 +5,21 @@
 namespace sa2
 {
 
-  class CycleTabItems
-  {
-  public:
-    void init();
-    bool beginTabBar(const char * str_id);
-    bool beginTabItem(const char * label);
+    class CycleTabItems
+    {
+    public:
+        void init();
+        bool beginTabBar(const char *str_id);
+        bool beginTabItem(const char *label);
 
-    void prev();
-    void next();
-  private:
-    size_t myNumberOfTabs = 0;
-    size_t mySelectedTab;
-    size_t myTabID;
-    std::optional<size_t> myNextToSelect;
-  };
+        void prev();
+        void next();
 
-}
\ No newline at end of file
+    private:
+        size_t myNumberOfTabs = 0;
+        size_t mySelectedTab;
+        size_t myTabID;
+        std::optional<size_t> myNextToSelect;
+    };
+
+} // namespace sa2
\ No newline at end of file
diff --git a/source/frontends/sdl/imgui/glselector.h b/source/frontends/sdl/imgui/glselector.h
index 2008824c2..fd1450d95 100644
--- a/source/frontends/sdl/imgui/glselector.h
+++ b/source/frontends/sdl/imgui/glselector.h
@@ -15,8 +15,8 @@
 #define SA2_CONTEXT_MINOR_VERSION 0
 
 // this is defined in gl2ext.h and nowhere in gl3.h
-#define SA2_IMAGE_FORMAT_INTERNAL   GL_BGRA_EXT
-#define SA2_IMAGE_FORMAT            GL_BGRA_EXT
+#define SA2_IMAGE_FORMAT_INTERNAL GL_BGRA_EXT
+#define SA2_IMAGE_FORMAT GL_BGRA_EXT
 
 #elif defined(IMGUI_IMPL_OPENGL_ES3)
 
@@ -39,8 +39,8 @@
 #define SA2_CONTEXT_MINOR_VERSION 0
 
 // this is defined in gl2ext.h and nowhere in gl3.h
-#define SA2_IMAGE_FORMAT_INTERNAL   GL_BGRA_EXT
-#define SA2_IMAGE_FORMAT            GL_BGRA_EXT
+#define SA2_IMAGE_FORMAT_INTERNAL GL_BGRA_EXT
+#define SA2_IMAGE_FORMAT GL_BGRA_EXT
 
 #elif defined(__APPLE__)
 
@@ -51,8 +51,8 @@
 #define SA2_CONTEXT_MAJOR_VERSION 3
 #define SA2_CONTEXT_MINOR_VERSION 2
 
-#define SA2_IMAGE_FORMAT_INTERNAL   GL_RGBA
-#define SA2_IMAGE_FORMAT            GL_BGRA
+#define SA2_IMAGE_FORMAT_INTERNAL GL_RGBA
+#define SA2_IMAGE_FORMAT GL_BGRA
 
 #else
 
@@ -63,8 +63,8 @@
 #define SA2_CONTEXT_MAJOR_VERSION 3
 #define SA2_CONTEXT_MINOR_VERSION 2
 
-#define SA2_IMAGE_FORMAT_INTERNAL   GL_RGBA
-#define SA2_IMAGE_FORMAT            GL_BGRA
+#define SA2_IMAGE_FORMAT_INTERNAL GL_RGBA
+#define SA2_IMAGE_FORMAT GL_BGRA
 
 #endif
 
diff --git a/source/frontends/sdl/imgui/image.cpp b/source/frontends/sdl/imgui/image.cpp
index d429076a1..da32f5cb0 100644
--- a/source/frontends/sdl/imgui/image.cpp
+++ b/source/frontends/sdl/imgui/image.cpp
@@ -11,45 +11,45 @@
 namespace sa2
 {
 
-  /*
-    2 extensions are used here
+    /*
+      2 extensions are used here
 
-    ES2: GL_UNPACK_ROW_LENGTH_EXT and GL_BGRA_EXT
-    ES3: GL_BGRA_EXT
+      ES2: GL_UNPACK_ROW_LENGTH_EXT and GL_BGRA_EXT
+      ES3: GL_BGRA_EXT
 
-    They both work on Pi3/4 and my Intel Haswell card.
+      They both work on Pi3/4 and my Intel Haswell card.
 
-    What does SDL do about it?
+      What does SDL do about it?
 
-    GL_UNPACK_ROW_LENGTH_EXT: it uses instead texture coordinates
-    GL_BGRA_EXT: it uses a shader to swap the color bytes
+      GL_UNPACK_ROW_LENGTH_EXT: it uses instead texture coordinates
+      GL_BGRA_EXT: it uses a shader to swap the color bytes
 
-    For simplicity (and because it just works) here we are using these 2 extensions.
-  */
+      For simplicity (and because it just works) here we are using these 2 extensions.
+    */
 
-  void allocateTexture(GLuint texture, size_t width, size_t height)
-  {
-    glBindTexture(GL_TEXTURE_2D, texture);
+    void allocateTexture(GLuint texture, size_t width, size_t height)
+    {
+        glBindTexture(GL_TEXTURE_2D, texture);
 
-    const GLenum type = GL_UNSIGNED_BYTE;
-    glTexImage2D(GL_TEXTURE_2D, 0, SA2_IMAGE_FORMAT_INTERNAL, width, height, 0, SA2_IMAGE_FORMAT, type, nullptr);
-  }
+        const GLenum type = GL_UNSIGNED_BYTE;
+        glTexImage2D(GL_TEXTURE_2D, 0, SA2_IMAGE_FORMAT_INTERNAL, width, height, 0, SA2_IMAGE_FORMAT, type, nullptr);
+    }
 
-  void loadTextureFromData(GLuint texture, const uint8_t * data, size_t width, size_t height, size_t pitch)
-  {
-    glBindTexture(GL_TEXTURE_2D, texture);
-    glPixelStorei(UGL_UNPACK_LENGTH, pitch); // in pixels
+    void loadTextureFromData(GLuint texture, const uint8_t *data, size_t width, size_t height, size_t pitch)
+    {
+        glBindTexture(GL_TEXTURE_2D, texture);
+        glPixelStorei(UGL_UNPACK_LENGTH, pitch); // in pixels
 
-    // Setup filtering parameters for display
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+        // Setup filtering parameters for display
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
-    const GLenum type = GL_UNSIGNED_BYTE;
-    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, SA2_IMAGE_FORMAT, type, data);
-    // reset to default state
-    glPixelStorei(UGL_UNPACK_LENGTH, 0);
-  }
+        const GLenum type = GL_UNSIGNED_BYTE;
+        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, SA2_IMAGE_FORMAT, type, data);
+        // reset to default state
+        glPixelStorei(UGL_UNPACK_LENGTH, 0);
+    }
 
-}
+} // namespace sa2
diff --git a/source/frontends/sdl/imgui/image.h b/source/frontends/sdl/imgui/image.h
index b0778edb2..e7490a6da 100644
--- a/source/frontends/sdl/imgui/image.h
+++ b/source/frontends/sdl/imgui/image.h
@@ -6,7 +6,7 @@
 namespace sa2
 {
 
-  void allocateTexture(GLuint texture, size_t width, size_t height);
-  void loadTextureFromData(GLuint texture, const uint8_t * data, size_t width, size_t height, size_t pitch);
+    void allocateTexture(GLuint texture, size_t width, size_t height);
+    void loadTextureFromData(GLuint texture, const uint8_t *data, size_t width, size_t height, size_t pitch);
 
-}
+} // namespace sa2
diff --git a/source/frontends/sdl/imgui/imconfig.h b/source/frontends/sdl/imgui/imconfig.h
index 8fed81268..1586d3cbc 100644
--- a/source/frontends/sdl/imgui/imconfig.h
+++ b/source/frontends/sdl/imgui/imconfig.h
@@ -1,3 +1,5 @@
+// clang-format off
+
 //-----------------------------------------------------------------------------
 // COMPILE-TIME OPTIONS FOR DEAR IMGUI
 // Runtime options (clipboard callbacks, enabling various features, etc.) can generally be set via the ImGuiIO structure.
diff --git a/source/frontends/sdl/imgui/inputtexthistory.cpp b/source/frontends/sdl/imgui/inputtexthistory.cpp
index 8a47e4122..18402acc3 100644
--- a/source/frontends/sdl/imgui/inputtexthistory.cpp
+++ b/source/frontends/sdl/imgui/inputtexthistory.cpp
@@ -6,97 +6,100 @@
 namespace sa2
 {
 
-  InputTextHistory::InputTextHistory()
-  {
-    insertNext();
-  }
-
-  void InputTextHistory::insertNext()
-  {
-    // the last entry is the "live" one, being edited
-    if (myHistory.empty() || !myHistory.back().empty())
+    InputTextHistory::InputTextHistory()
     {
-      myHistory.push_back("");
+        insertNext();
     }
-    myHistoryPos = myHistory.size() - 1;
-  }
-
-  int InputTextHistory::inputTextCallbackStub(ImGuiInputTextCallbackData* data)
-  {
-    InputTextHistory* history = (InputTextHistory*)data->UserData;
-    return history->inputTextCallback(data);
-  }
-
-  int InputTextHistory::inputTextCallback(ImGuiInputTextCallbackData* data)
-  {
-    switch (data->EventFlag)
-    {
-    case ImGuiInputTextFlags_CallbackHistory:
-    {
-      const size_t livePos = myHistory.size() - 1; 
-      const int prevHistoryPos = myHistoryPos;
-      if (data->EventKey == ImGuiKey_UpArrow)
-      {
-        if (myHistoryPos > 0)
-        {
-          --myHistoryPos;
-        }
-      }
-      else if (data->EventKey == ImGuiKey_DownArrow)
-      {
-        if (myHistoryPos != livePos)
-        {
-          ++myHistoryPos;
-        }
-      }
 
-      if (prevHistoryPos != myHistoryPos)
-      {
-        if (prevHistoryPos == livePos)
+    void InputTextHistory::insertNext()
+    {
+        // the last entry is the "live" one, being edited
+        if (myHistory.empty() || !myHistory.back().empty())
         {
-          // save "live" editable entry
-          myHistory[livePos] = data->Buf;
+            myHistory.push_back("");
         }
-        data->DeleteChars(0, data->BufTextLen);
-        data->InsertChars(0, myHistory[myHistoryPos].c_str());
-      }
-      break;
+        myHistoryPos = myHistory.size() - 1;
     }
+
+    int InputTextHistory::inputTextCallbackStub(ImGuiInputTextCallbackData *data)
+    {
+        InputTextHistory *history = (InputTextHistory *)data->UserData;
+        return history->inputTextCallback(data);
     }
 
-    return 0;
-  }
+    int InputTextHistory::inputTextCallback(ImGuiInputTextCallbackData *data)
+    {
+        switch (data->EventFlag)
+        {
+        case ImGuiInputTextFlags_CallbackHistory:
+        {
+            const size_t livePos = myHistory.size() - 1;
+            const int prevHistoryPos = myHistoryPos;
+            if (data->EventKey == ImGuiKey_UpArrow)
+            {
+                if (myHistoryPos > 0)
+                {
+                    --myHistoryPos;
+                }
+            }
+            else if (data->EventKey == ImGuiKey_DownArrow)
+            {
+                if (myHistoryPos != livePos)
+                {
+                    ++myHistoryPos;
+                }
+            }
+
+            if (prevHistoryPos != myHistoryPos)
+            {
+                if (prevHistoryPos == livePos)
+                {
+                    // save "live" editable entry
+                    myHistory[livePos] = data->Buf;
+                }
+                data->DeleteChars(0, data->BufTextLen);
+                data->InsertChars(0, myHistory[myHistoryPos].c_str());
+            }
+            break;
+        }
+        }
 
-  std::string InputTextHistory::execute()
-  {
-    const std::string line = myInputBuffer;
-    myInputBuffer[0] = 0;
+        return 0;
+    }
 
-    const auto end = myHistory.end() - 1;  // do not compare with live, as it might match
-    const auto it = std::find(myHistory.begin(), end, line);
-    if (it != end)
+    std::string InputTextHistory::execute()
     {
-      myHistory.erase(it);
-    }
+        const std::string line = myInputBuffer;
+        myInputBuffer[0] = 0;
 
-    myHistory.back() = line;  // replace "live" with the one executed
+        const auto end = myHistory.end() - 1; // do not compare with live, as it might match
+        const auto it = std::find(myHistory.begin(), end, line);
+        if (it != end)
+        {
+            myHistory.erase(it);
+        }
 
-    if (myHistory.size() >= myMaximumSize)
-    {
-      myHistory.erase(myHistory.begin());
-    }    
+        myHistory.back() = line; // replace "live" with the one executed
 
-    insertNext();
+        if (myHistory.size() >= myMaximumSize)
+        {
+            myHistory.erase(myHistory.begin());
+        }
+
+        insertNext();
 
-    return line;
-  }
+        return line;
+    }
 
-  bool InputTextHistory::inputText(const char* label)
-  {
-    const ImGuiInputTextFlags inputTextFlags = ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_EscapeClearsAll | ImGuiInputTextFlags_CallbackHistory;
-    const bool result = ImGui::InputText(label, myInputBuffer, IM_ARRAYSIZE(myInputBuffer), inputTextFlags, 
-      &InputTextHistory::inputTextCallbackStub, this);
-    return result;
-  }
+    bool InputTextHistory::inputText(const char *label)
+    {
+        const ImGuiInputTextFlags inputTextFlags = ImGuiInputTextFlags_EnterReturnsTrue |
+                                                   ImGuiInputTextFlags_EscapeClearsAll |
+                                                   ImGuiInputTextFlags_CallbackHistory;
+        const bool result = ImGui::InputText(
+            label, myInputBuffer, IM_ARRAYSIZE(myInputBuffer), inputTextFlags, &InputTextHistory::inputTextCallbackStub,
+            this);
+        return result;
+    }
 
-}
+} // namespace sa2
diff --git a/source/frontends/sdl/imgui/inputtexthistory.h b/source/frontends/sdl/imgui/inputtexthistory.h
index 370bf246d..7503a118f 100644
--- a/source/frontends/sdl/imgui/inputtexthistory.h
+++ b/source/frontends/sdl/imgui/inputtexthistory.h
@@ -10,24 +10,24 @@ struct ImGuiInputTextCallbackData;
 namespace sa2
 {
 
-  class InputTextHistory
-  {
-  public:
-    InputTextHistory();
+    class InputTextHistory
+    {
+    public:
+        InputTextHistory();
 
-    bool inputText(const char* label);
-    std::string execute();
+        bool inputText(const char *label);
+        std::string execute();
 
-  private:
-    static constexpr size_t myMaximumSize = 20;
-    static int inputTextCallbackStub(ImGuiInputTextCallbackData* data);
+    private:
+        static constexpr size_t myMaximumSize = 20;
+        static int inputTextCallbackStub(ImGuiInputTextCallbackData *data);
 
-    void insertNext();
-    char myInputBuffer[CONSOLE_WIDTH] = "";
-    int inputTextCallback(ImGuiInputTextCallbackData* data);
+        void insertNext();
+        char myInputBuffer[CONSOLE_WIDTH] = "";
+        int inputTextCallback(ImGuiInputTextCallbackData *data);
 
-    size_t myHistoryPos;
-    std::vector<std::string> myHistory;
-  };
+        size_t myHistoryPos;
+        std::vector<std::string> myHistory;
+    };
 
-}
+} // namespace sa2
diff --git a/source/frontends/sdl/imgui/sdldebugger.cpp b/source/frontends/sdl/imgui/sdldebugger.cpp
index bf24bb512..856c5f514 100644
--- a/source/frontends/sdl/imgui/sdldebugger.cpp
+++ b/source/frontends/sdl/imgui/sdldebugger.cpp
@@ -12,736 +12,752 @@
 namespace
 {
 
-  void printBoolean(const char * label, const bool value, const char * falseValue, const char * trueValue)
-  {
-    int elem = value;
-    const char * name = value ? trueValue : falseValue;
-    ImGui::SliderInt(label, &elem, 0, 1, name);
-  }
-
-  void printOnOff(const char * label, const bool value)
-  {
-    printBoolean(label, value, "OFF", "ON");
-  }
-
-  void printReg(const char label, const BYTE value)
-  {
-    ImGui::Text("%c  '%c'  %02X", label, sa2::getPrintableChar(value), value);
-  }
-
-  ImVec4 debuggerGetColor(int iColor)
-  {
-    const COLORREF cr = DebuggerGetColor(iColor);
-    const ImVec4 color = sa2::colorrefToImVec4(cr);
-    return color;
-  }
-
-  void debuggerTextColored(int iColor, const char* text)
-  {
-    const ImVec4 color = debuggerGetColor(iColor);
-    ImGui::TextColored(color, "%s", text);
-  }
-
-  void adjustMouseText(const char* text, size_t length, char* out)
-  {
-    for (size_t i = 0; i < length; ++i)
+    void printBoolean(const char *label, const bool value, const char *falseValue, const char *trueValue)
     {
-      const auto ch = *(text + i) & 0x7F;  // same as DebuggerPrint()
-      // to understand the conversion, look at
-      // resource/Debug_Font.bmp vs resource/debug6502.ttf
-      // the latter comes from https://fontstruct.com/fontstructions/show/1912741/debug6502
-      switch (ch)
-      {
-      case 0x00 ... 0x1F:  // mouse text -> U+00C0
-        *out = 0xC3;
-        ++out;
-        *out = 0x80 + (ch - 0x00);
-        break;
-      case 0x7F:  // -> U+00BF
-        *out = 0xC2;
-        ++out;
-        *out = 0xBF;
-        break;
-      case 0x80 ... 0x8F:  // bookmarks, not currently used -> U+00F0
-        *out = 0xC3;
-        ++out;
-        *out = 0xB0 + (ch - 0x80);
-        break;
-      default:
-        *out = ch;
-      }
-      ++out;
-    }
-    *out = 0x00;
-  }
-
-  // use this if "text" may contain mouse text
-  void safeDebuggerTextColored(int iColor, const char* text)
-  {
-    const size_t length = strlen(text);
-    char utf8[2 * length + 1];  // worst case is 2-bytes utf8 encoding
-    adjustMouseText(text, length, utf8);
-    debuggerTextColored(iColor, utf8);
-  }
-
-  void displayDisassemblyLine(const DisasmLine_t& line, const int bDisasmFormatFlags)
-  {
-    const char* pMnemonic = g_aOpcodes[line.iOpcode].sMnemonic;
-    ImGui::Text("%s ", pMnemonic);
-
-    if (line.bTargetImmediate)
-    {
-      ImGui::SameLine(0, 0);
-      debuggerTextColored(FG_DISASM_OPERATOR, "#$");
+        int elem = value;
+        const char *name = value ? trueValue : falseValue;
+        ImGui::SliderInt(label, &elem, 0, 1, name);
     }
 
-    if (line.bTargetIndexed || line.bTargetIndirect)
+    void printOnOff(const char *label, const bool value)
     {
-      ImGui::SameLine(0, 0);
-      debuggerTextColored(FG_DISASM_OPERATOR, "(");
+        printBoolean(label, value, "OFF", "ON");
     }
 
-    int targetColor;
-    if (bDisasmFormatFlags & DISASM_FORMAT_SYMBOL)
-    {
-      targetColor = FG_DISASM_SYMBOL;
-    }
-    else
+    void printReg(const char label, const BYTE value)
     {
-      if (line.iOpmode == AM_M)
-      {
-        targetColor = FG_DISASM_OPCODE;
-      }
-      else
-      {
-        targetColor = FG_DISASM_TARGET;
-      }
+        ImGui::Text("%c  '%c'  %02X", label, sa2::getPrintableChar(value), value);
     }
 
-    const char * target = line.sTarget;
-    if (target[0] == '$')
+    ImVec4 debuggerGetColor(int iColor)
     {
-      ImGui::SameLine(0, 0);
-      debuggerTextColored(FG_DISASM_OPERATOR, "$");
-      ++target;
+        const COLORREF cr = DebuggerGetColor(iColor);
+        const ImVec4 color = sa2::colorrefToImVec4(cr);
+        return color;
     }
-    ImGui::SameLine(0, 0);
-    debuggerTextColored(targetColor, target);
 
-    if (bDisasmFormatFlags & DISASM_FORMAT_OFFSET)
+    void debuggerTextColored(int iColor, const char *text)
     {
-      if (line.nTargetOffset > 0)
-      {
-        ImGui::SameLine(0, 0);
-        debuggerTextColored(FG_DISASM_OPERATOR, "+");
-      }
-      else if (line.nTargetOffset < 0)
-      {
-        ImGui::SameLine(0, 0);
-        debuggerTextColored(FG_DISASM_OPERATOR, "-");
-      }
-      ImGui::SameLine(0, 0);
-      debuggerTextColored(FG_DISASM_OPCODE, line.sTargetOffset);
+        const ImVec4 color = debuggerGetColor(iColor);
+        ImGui::TextColored(color, "%s", text);
     }
 
-    if (line.bTargetX)
-    {
-      ImGui::SameLine(0, 0);
-      debuggerTextColored(FG_DISASM_OPERATOR, ",");
-      ImGui::SameLine(0, 0);
-      debuggerTextColored(FG_INFO_REG, "X");
-    }
-    else if ((line.bTargetY) && (!line.bTargetIndirect))
+    void adjustMouseText(const char *text, size_t length, char *out)
     {
-      ImGui::SameLine(0, 0);
-      debuggerTextColored(FG_DISASM_OPERATOR, ",");
-      ImGui::SameLine(0, 0);
-      debuggerTextColored(FG_INFO_REG, "Y");
+        for (size_t i = 0; i < length; ++i)
+        {
+            const auto ch = *(text + i) & 0x7F; // same as DebuggerPrint()
+            // to understand the conversion, look at
+            // resource/Debug_Font.bmp vs resource/debug6502.ttf
+            // the latter comes from https://fontstruct.com/fontstructions/show/1912741/debug6502
+            switch (ch)
+            {
+            case 0x00 ... 0x1F: // mouse text -> U+00C0
+                *out = 0xC3;
+                ++out;
+                *out = 0x80 + (ch - 0x00);
+                break;
+            case 0x7F: // -> U+00BF
+                *out = 0xC2;
+                ++out;
+                *out = 0xBF;
+                break;
+            case 0x80 ... 0x8F: // bookmarks, not currently used -> U+00F0
+                *out = 0xC3;
+                ++out;
+                *out = 0xB0 + (ch - 0x80);
+                break;
+            default:
+                *out = ch;
+            }
+            ++out;
+        }
+        *out = 0x00;
     }
 
-    if (line.bTargetIndexed || line.bTargetIndirect)
+    // use this if "text" may contain mouse text
+    void safeDebuggerTextColored(int iColor, const char *text)
     {
-      ImGui::SameLine(0, 0);
-      debuggerTextColored(FG_DISASM_OPERATOR, ")");
+        const size_t length = strlen(text);
+        char utf8[2 * length + 1]; // worst case is 2-bytes utf8 encoding
+        adjustMouseText(text, length, utf8);
+        debuggerTextColored(iColor, utf8);
     }
 
-    if (line.bTargetIndexed && line.bTargetY)
+    void displayDisassemblyLine(const DisasmLine_t &line, const int bDisasmFormatFlags)
     {
-      ImGui::SameLine(0, 0);
-      debuggerTextColored(FG_DISASM_OPERATOR, ",");
-      ImGui::SameLine(0, 0);
-      debuggerTextColored(FG_INFO_REG, "Y");
-    }
-  }
+        const char *pMnemonic = g_aOpcodes[line.iOpcode].sMnemonic;
+        ImGui::Text("%s ", pMnemonic);
 
-}
+        if (line.bTargetImmediate)
+        {
+            ImGui::SameLine(0, 0);
+            debuggerTextColored(FG_DISASM_OPERATOR, "#$");
+        }
 
-namespace sa2
-{
-  void ImGuiDebugger::drawDebugger(SDLFrame * frame)
-  {
-    myAddressCycles[regs.pc] = g_nCumulativeCycles - myBaseDebuggerCycles;
+        if (line.bTargetIndexed || line.bTargetIndirect)
+        {
+            ImGui::SameLine(0, 0);
+            debuggerTextColored(FG_DISASM_OPERATOR, "(");
+        }
 
-    ImGui::PushTabStop(false);  // natural ImGui tabbing interacts with Tab switching
-    if (ImGui::Begin("Debugger", &showDebugger))
-    {
-      myCycleTabItems.init();
-      if (ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows))
-      {
-        // unfortunately if we put this where it belongs (i.e. a few lines below with the rest of the key handling)
-        // there are some focus-related issues, and we no longer capture keys
-        // at the same time, there is a potential double counting with InputText,
-        // but, since it does not handle TABs (see ImGuiInputTextFlags_CallbackCompletion & ImGuiInputTextFlags_AllowTabInput)
-        // this is not an issue now
-        ImGui::SetNextFrameWantCaptureKeyboard(true);
-        if (ImGui::IsKeyChordPressed(ImGuiKey_Tab | ImGuiMod_Shift))
+        int targetColor;
+        if (bDisasmFormatFlags & DISASM_FORMAT_SYMBOL)
         {
-          myCycleTabItems.prev();
+            targetColor = FG_DISASM_SYMBOL;
         }
-        else if (ImGui::IsKeyChordPressed(ImGuiKey_Tab))
+        else
         {
-          myCycleTabItems.next();
+            if (line.iOpmode == AM_M)
+            {
+                targetColor = FG_DISASM_OPCODE;
+            }
+            else
+            {
+                targetColor = FG_DISASM_TARGET;
+            }
         }
-      }
 
-      ImGui::BeginChild("Console", ImVec2(0, -ImGui::GetFrameHeightWithSpacing()));
-      if (myCycleTabItems.beginTabBar("Tabs"))
-      {
-        bool debuggerShortcutEnabled = false;
-        if (g_nAppMode == MODE_DEBUG)
+        const char *target = line.sTarget;
+        if (target[0] == '$')
         {
-          if (ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows))
-          {
-            debuggerShortcutEnabled = true;
-            ImGui::SetNextFrameWantCaptureKeyboard(true);
-            processDebuggerKeys();
-          }
+            ImGui::SameLine(0, 0);
+            debuggerTextColored(FG_DISASM_OPERATOR, "$");
+            ++target;
         }
+        ImGui::SameLine(0, 0);
+        debuggerTextColored(targetColor, target);
 
-        if (myCycleTabItems.beginTabItem("CPU"))
+        if (bDisasmFormatFlags & DISASM_FORMAT_OFFSET)
         {
-          if (ImGui::RadioButton("Color", g_iColorScheme == SCHEME_COLOR)) { g_iColorScheme = SCHEME_COLOR; } ImGui::SameLine();
-          if (ImGui::RadioButton("Mono", g_iColorScheme == SCHEME_MONO)) { g_iColorScheme = SCHEME_MONO; } ImGui::SameLine();
-          if (ImGui::RadioButton("BW", g_iColorScheme == SCHEME_BW)) { g_iColorScheme = SCHEME_BW; } ImGui::SameLine();
-
-          ImGui::BeginDisabled();
-          ImGui::Checkbox("Shortcuts", &debuggerShortcutEnabled);
-          ImGui::EndDisabled();
-          ImGui::SameLine();
-
-          ImGui::Checkbox("Auto-sync cursor", &mySyncCursor);
-
-          bool recalc = false;
-          if (mySyncCursor || (ImGui::SameLine(), ImGui::Button("Sync cursor")))
-          {
-            recalc = true;
-            g_nDisasmCurAddress = regs.pc;
-          }
-
-          if (ImGui::Button("Step"))
-          {
-            frame->ChangeMode(MODE_DEBUG);
-            frame->SingleStep();
-          }
-          ImGui::SameLine();
-
-          if ((ImGui::SameLine(), ImGui::Button("Debug")))
-          {
-            frame->ChangeMode(MODE_DEBUG);
-            resetDebuggerCycles();
-          }
-          if ((ImGui::SameLine(), ImGui::Button("Continue")))
-          {
-            frame->ChangeMode(MODE_RUNNING);
-          }
-          ImGui::SameLine();
-          ImGui::Text("%016llu - %04X", g_nCumulativeCycles, regs.pc);
-
-          if (!mySyncCursor)
-          {
-            ImGui::SameLine();
-            ImGui::PushItemWidth(ImGui::GetFontSize() * 5);
-            if (ImGui::InputScalar("Cursor", ImGuiDataType_U16, &g_nDisasmCurAddress, nullptr, nullptr, "%04X", ImGuiInputTextFlags_CharsHexadecimal))
+            if (line.nTargetOffset > 0)
             {
-              recalc = true;
+                ImGui::SameLine(0, 0);
+                debuggerTextColored(FG_DISASM_OPERATOR, "+");
             }
-            ImGui::PopItemWidth();
-          }
-
-          // do not flip next ||
-          if (ImGui::SliderInt("Cursor row", &g_nDisasmCurLine, 0, 100) || recalc)
-          {
-            DisasmCalcTopBotAddress();
-          }
-
-          // this is about right to contain the fixed-size register child
-          const ImVec2 registerTextSize = ImGui::CalcTextSize("Annunciators012345");
-
-          ImGui::BeginChild("Disasm", ImVec2(-registerTextSize.x, 0));
-          drawDisassemblyTable(frame);
-          ImGui::EndChild();
-
-          ImGui::SameLine();
-
-          ImGui::BeginChild("Flags");
-          const ImVec2 gap(0.0f, 20.0f);
-          drawRegisters();
-          ImGui::Dummy(gap);
-          drawStackReturnAddress();
-          ImGui::Dummy(gap);
-          drawAnnunciators();
-          ImGui::Dummy(gap);
-          drawSwitches();
-          ImGui::EndChild();
-
-          ImGui::EndTabItem();
+            else if (line.nTargetOffset < 0)
+            {
+                ImGui::SameLine(0, 0);
+                debuggerTextColored(FG_DISASM_OPERATOR, "-");
+            }
+            ImGui::SameLine(0, 0);
+            debuggerTextColored(FG_DISASM_OPCODE, line.sTargetOffset);
         }
-        if (myCycleTabItems.beginTabItem("Console"))
+
+        if (line.bTargetX)
         {
-          drawConsole();
-          ImGui::EndTabItem();
+            ImGui::SameLine(0, 0);
+            debuggerTextColored(FG_DISASM_OPERATOR, ",");
+            ImGui::SameLine(0, 0);
+            debuggerTextColored(FG_INFO_REG, "X");
         }
-        if (myCycleTabItems.beginTabItem("Breakpoints"))
+        else if ((line.bTargetY) && (!line.bTargetIndirect))
         {
-          drawBreakpoints();
-          ImGui::EndTabItem();
+            ImGui::SameLine(0, 0);
+            debuggerTextColored(FG_DISASM_OPERATOR, ",");
+            ImGui::SameLine(0, 0);
+            debuggerTextColored(FG_INFO_REG, "Y");
         }
-        ImGui::EndTabBar();
-      }
-      ImGui::EndChild();
 
-      if (g_nAppMode == MODE_DEBUG)
-      {
-        if (myInputTextHistory.inputText("Prompt"))
+        if (line.bTargetIndexed || line.bTargetIndirect)
         {
-          const std::string & command = myInputTextHistory.execute();
-          debuggerCommand(frame, command.c_str());
+            ImGui::SameLine(0, 0);
+            debuggerTextColored(FG_DISASM_OPERATOR, ")");
         }
-      }
-    }
-    ImGui::PopTabStop();  // natural ImGui tabbing interacts with Tab switching
 
-    if (!showDebugger)
-    {
-      // this happens when the window is closed
-      syncDebuggerState(frame);
+        if (line.bTargetIndexed && line.bTargetY)
+        {
+            ImGui::SameLine(0, 0);
+            debuggerTextColored(FG_DISASM_OPERATOR, ",");
+            ImGui::SameLine(0, 0);
+            debuggerTextColored(FG_INFO_REG, "Y");
+        }
     }
 
-    ImGui::End();
-  }
-
-  void ImGuiDebugger::syncDebuggerState(SDLFrame * frame)
-  {
-    const AppMode_e mode = showDebugger ? MODE_DEBUG : MODE_RUNNING;
-    frame->ChangeMode(mode);
-  }
+} // namespace
 
-  void ImGuiDebugger::debuggerCommand(SDLFrame * frame, const char * s)
-  {
-    for (; *s; ++s)
-    {
-      DebuggerInputConsoleChar(*s);
-    }
-    // this might trigger a GO
-    frame->ResetSpeed();
-    DebuggerProcessKey(VK_RETURN);
-    myScrollConsole = true;
-  }
-
-  void ImGuiDebugger::drawDisassemblyTable(SDLFrame * frame)
-  {
-    const ImGuiTableFlags flags = ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingStretchProp | ImGuiTableFlags_BordersOuter | ImGuiTableFlags_ScrollY;
-    if (ImGui::BeginTable("Disassembly", 9, flags))
+namespace sa2
+{
+    void ImGuiDebugger::drawDebugger(SDLFrame *frame)
     {
-      ImGui::PushStyleCompact();
-      // weigths proportional to column width (including header)
-      ImGui::TableSetupScrollFreeze(0, 1); // Make top row always visible
-      ImGui::TableSetupColumn("", 0, 1);
-      ImGui::TableSetupColumn("Address", 0, 5);
-      ImGui::TableSetupColumn("Opcode", 0, 6);
-      ImGui::TableSetupColumn("Symbol", 0, 10);
-      ImGui::TableSetupColumn("Disassembly", 0, 15);
-      ImGui::TableSetupColumn("Target", 0, 4);
-      ImGui::TableSetupColumn("Branch", 0, 3);
-      ImGui::TableSetupColumn("Immediate", 0, 4);
-      ImGui::TableSetupColumn("Cycles", 0, 6);
-      ImGui::TableHeadersRow();
-
-      ImGuiListClipper clipper;
-      clipper.Begin(1000);
-      int row = 0;
-      WORD nAddress = g_nDisasmTopAddress;
-      while (clipper.Step())
-      {
-        for (; row < clipper.DisplayStart; ++row)
-        {
-          int iOpcode, iOpmode, nOpbyte;
-          _6502_GetOpmodeOpbyte(nAddress, iOpmode, nOpbyte, nullptr);
-          nAddress += nOpbyte;
-        }
-        IM_ASSERT(row == clipper.DisplayStart && "Clipper position mismatch");
-        for (; row < clipper.DisplayEnd; ++row)
+        myAddressCycles[regs.pc] = g_nCumulativeCycles - myBaseDebuggerCycles;
+
+        ImGui::PushTabStop(false); // natural ImGui tabbing interacts with Tab switching
+        if (ImGui::Begin("Debugger", &showDebugger))
         {
-          ImGui::PushID(nAddress);
-          DisasmLine_t line;
-          std::string const* pSymbol = FindSymbolFromAddress(nAddress);
-          const int bDisasmFormatFlags = GetDisassemblyLine(nAddress, line);
-
-          ImGui::TableNextRow();
-
-          bool breakpointActive;
-          bool breakpointEnabled;
-          GetBreakpointInfo(nAddress, breakpointActive, breakpointEnabled);
-
-          float red = 0.0;
-          int state = 0;
-          if (breakpointEnabled)
-          {
-            red = 0.5;
-            state = 1;
-          }
-          else if (breakpointActive)
-          {
-            red = 0.25;
-            state = -1;
-          }
-
-          ImGui::TableNextColumn();
-
-          ImGui::BeginDisabled(g_nAppMode != MODE_DEBUG);
-          if (ImGui::CheckBoxTristate("##State", &state))
-          {
-            if (!breakpointActive && state == 1)
-            {
-              const std::string command = std::string("bpx ") + line.sAddress;
-              debuggerCommand(frame, command.c_str());
-            }
-            else
-            {
-              changeBreakpoint(nAddress, state == 1);
-            }
-          }
-          ImGui::EndDisabled();
-
-          if (nAddress == regs.pc)
-          {
-            const ImU32 currentBgColor = ImGui::GetColorU32(ImVec4(red, 0, 1, 1));
-            ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg0, currentBgColor);
-          }
-          else if (nAddress == g_nDisasmCurAddress)
-          {
-            const ImU32 currentBgColor = ImGui::GetColorU32(ImVec4(red, 0, 0.5, 1));
-            ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg0, currentBgColor);
-          }
-          else if (breakpointActive || breakpointEnabled)
-          {
-            const ImU32 currentBgColor = ImGui::GetColorU32(ImVec4(red, 0, 0, 1));
-            ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg0, currentBgColor);
-          }
-
-          ImGui::TableNextColumn();
-          if (ImGui::Selectable(line.sAddress, g_nDisasmCurAddress == nAddress, ImGuiSelectableFlags_SpanAllColumns))
-          {
-            g_nDisasmCurAddress = nAddress;
-            mySyncCursor = false;
-          }
-
-          ImGui::TableNextColumn();
-          debuggerTextColored(FG_DISASM_OPCODE, line.sOpCodes);
-
-          ImGui::TableNextColumn();
-          if (pSymbol)
-          {
-            debuggerTextColored(FG_DISASM_SYMBOL, pSymbol->c_str());
-          }
-
-          ImGui::TableNextColumn();
-          displayDisassemblyLine(line, bDisasmFormatFlags);
-
-          ImGui::TableNextColumn();
-          if (bDisasmFormatFlags & DISASM_FORMAT_TARGET_POINTER)
-          {
-            debuggerTextColored(FG_DISASM_ADDRESS, line.sTargetPointer);
-            
-            if (bDisasmFormatFlags & DISASM_FORMAT_TARGET_VALUE)
+            myCycleTabItems.init();
+            if (ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows))
             {
-              ImGui::SameLine(0, 0);
-              debuggerTextColored(FG_DISASM_OPERATOR, ":");
-              ImGui::SameLine(0, 0);
-              debuggerTextColored(FG_DISASM_OPCODE, line.sTargetValue);
+                // unfortunately if we put this where it belongs (i.e. a few lines below with the rest of the key
+                // handling) there are some focus-related issues, and we no longer capture keys at the same time, there
+                // is a potential double counting with InputText, but, since it does not handle TABs (see
+                // ImGuiInputTextFlags_CallbackCompletion & ImGuiInputTextFlags_AllowTabInput) this is not an issue now
+                ImGui::SetNextFrameWantCaptureKeyboard(true);
+                if (ImGui::IsKeyChordPressed(ImGuiKey_Tab | ImGuiMod_Shift))
+                {
+                    myCycleTabItems.prev();
+                }
+                else if (ImGui::IsKeyChordPressed(ImGuiKey_Tab))
+                {
+                    myCycleTabItems.next();
+                }
             }
-          }
-          else if (line.bTargetImmediate && line.nImmediate)
-          {
-            debuggerTextColored(FG_DISASM_OPERATOR, "#");
-            ImGui::SameLine(0, 0);
-            debuggerTextColored(FG_DISASM_SINT8, line.sImmediateSignedDec);
-          }
-
-          ImGui::TableNextColumn();
-          if (bDisasmFormatFlags & DISASM_FORMAT_BRANCH)
-          {
-            safeDebuggerTextColored(FG_DISASM_BRANCH, line.sBranch);
-          }
-
-          ImGui::TableNextColumn();
-          if (bDisasmFormatFlags & DISASM_FORMAT_CHAR)
-          {
-            DebugColors_e color;
-            const unsigned int c = (unsigned char)line.nImmediate;
-            if ((c & 0x7F) < 0x20)
-            {
-              // Invisible control characters 0x00..0x1F are mapped to a visible range
-              // in sImmediate, but we want to specially color it.
-              // Mimics "bCtrlBit" logic in Windows.
-              color = FG_INFO_CHAR_LO;
-            }
-            else if (c > 0x7F)
-            {
-              // Characters with high bit set are mapped back down to 0x00..0x7F in
-              // sImmediate, but we want to specially color it.
-              // Mimics "bHighBit" logic in Windows.
-              color = FG_INFO_CHAR_HI;
-            }
-            else
+
+            ImGui::BeginChild("Console", ImVec2(0, -ImGui::GetFrameHeightWithSpacing()));
+            if (myCycleTabItems.beginTabBar("Tabs"))
             {
-              color = FG_DISASM_CHAR;
+                bool debuggerShortcutEnabled = false;
+                if (g_nAppMode == MODE_DEBUG)
+                {
+                    if (ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows))
+                    {
+                        debuggerShortcutEnabled = true;
+                        ImGui::SetNextFrameWantCaptureKeyboard(true);
+                        processDebuggerKeys();
+                    }
+                }
+
+                if (myCycleTabItems.beginTabItem("CPU"))
+                {
+                    if (ImGui::RadioButton("Color", g_iColorScheme == SCHEME_COLOR))
+                    {
+                        g_iColorScheme = SCHEME_COLOR;
+                    }
+                    ImGui::SameLine();
+                    if (ImGui::RadioButton("Mono", g_iColorScheme == SCHEME_MONO))
+                    {
+                        g_iColorScheme = SCHEME_MONO;
+                    }
+                    ImGui::SameLine();
+                    if (ImGui::RadioButton("BW", g_iColorScheme == SCHEME_BW))
+                    {
+                        g_iColorScheme = SCHEME_BW;
+                    }
+                    ImGui::SameLine();
+
+                    ImGui::BeginDisabled();
+                    ImGui::Checkbox("Shortcuts", &debuggerShortcutEnabled);
+                    ImGui::EndDisabled();
+                    ImGui::SameLine();
+
+                    ImGui::Checkbox("Auto-sync cursor", &mySyncCursor);
+
+                    bool recalc = false;
+                    if (mySyncCursor || (ImGui::SameLine(), ImGui::Button("Sync cursor")))
+                    {
+                        recalc = true;
+                        g_nDisasmCurAddress = regs.pc;
+                    }
+
+                    if (ImGui::Button("Step"))
+                    {
+                        frame->ChangeMode(MODE_DEBUG);
+                        frame->SingleStep();
+                    }
+                    ImGui::SameLine();
+
+                    if ((ImGui::SameLine(), ImGui::Button("Debug")))
+                    {
+                        frame->ChangeMode(MODE_DEBUG);
+                        resetDebuggerCycles();
+                    }
+                    if ((ImGui::SameLine(), ImGui::Button("Continue")))
+                    {
+                        frame->ChangeMode(MODE_RUNNING);
+                    }
+                    ImGui::SameLine();
+                    ImGui::Text("%016llu - %04X", g_nCumulativeCycles, regs.pc);
+
+                    if (!mySyncCursor)
+                    {
+                        ImGui::SameLine();
+                        ImGui::PushItemWidth(ImGui::GetFontSize() * 5);
+                        if (ImGui::InputScalar(
+                                "Cursor", ImGuiDataType_U16, &g_nDisasmCurAddress, nullptr, nullptr, "%04X",
+                                ImGuiInputTextFlags_CharsHexadecimal))
+                        {
+                            recalc = true;
+                        }
+                        ImGui::PopItemWidth();
+                    }
+
+                    // do not flip next ||
+                    if (ImGui::SliderInt("Cursor row", &g_nDisasmCurLine, 0, 100) || recalc)
+                    {
+                        DisasmCalcTopBotAddress();
+                    }
+
+                    // this is about right to contain the fixed-size register child
+                    const ImVec2 registerTextSize = ImGui::CalcTextSize("Annunciators012345");
+
+                    ImGui::BeginChild("Disasm", ImVec2(-registerTextSize.x, 0));
+                    drawDisassemblyTable(frame);
+                    ImGui::EndChild();
+
+                    ImGui::SameLine();
+
+                    ImGui::BeginChild("Flags");
+                    const ImVec2 gap(0.0f, 20.0f);
+                    drawRegisters();
+                    ImGui::Dummy(gap);
+                    drawStackReturnAddress();
+                    ImGui::Dummy(gap);
+                    drawAnnunciators();
+                    ImGui::Dummy(gap);
+                    drawSwitches();
+                    ImGui::EndChild();
+
+                    ImGui::EndTabItem();
+                }
+                if (myCycleTabItems.beginTabItem("Console"))
+                {
+                    drawConsole();
+                    ImGui::EndTabItem();
+                }
+                if (myCycleTabItems.beginTabItem("Breakpoints"))
+                {
+                    drawBreakpoints();
+                    ImGui::EndTabItem();
+                }
+                ImGui::EndTabBar();
             }
-            safeDebuggerTextColored(color, line.sImmediate);
-          }
+            ImGui::EndChild();
 
-          ImGui::TableNextColumn();
-          if (g_nAppMode == MODE_DEBUG)
-          {
-            if (myAddressCycles.find(nAddress) != myAddressCycles.end())
+            if (g_nAppMode == MODE_DEBUG)
             {
-              ImGui::Text("%" PRIu64, myAddressCycles[nAddress]);
+                if (myInputTextHistory.inputText("Prompt"))
+                {
+                    const std::string &command = myInputTextHistory.execute();
+                    debuggerCommand(frame, command.c_str());
+                }
             }
-          }
+        }
+        ImGui::PopTabStop(); // natural ImGui tabbing interacts with Tab switching
 
-          nAddress += line.nOpbyte;
-          ImGui::PopID();
+        if (!showDebugger)
+        {
+            // this happens when the window is closed
+            syncDebuggerState(frame);
         }
-      }
-      ImGui::PopStyleCompact();
-      ImGui::EndTable();
+
+        ImGui::End();
     }
-  }
-
-  void ImGuiDebugger::drawRegisters()
-  {
-    ImGui::TextUnformatted("Registers");
-    ImGui::Separator();
-    printReg('A', regs.a);
-    printReg('X', regs.x);
-    printReg('Y', regs.y);
-    printReg('P', regs.ps);
-    ImGui::Text("PC    %04X", regs.pc);
-    ImGui::Text("SP    %04X", regs.sp);
-    if (regs.bJammed)
+
+    void ImGuiDebugger::syncDebuggerState(SDLFrame *frame)
     {
-      ImGui::Separator();
-      ImGui::Selectable("CPU Jammed");
+        const AppMode_e mode = showDebugger ? MODE_DEBUG : MODE_RUNNING;
+        frame->ChangeMode(mode);
     }
-  }
-
-  void ImGuiDebugger::drawStackReturnAddress()
-  {
-    ImGui::TextUnformatted("Stack return");
-    ImGui::Separator();
-    const WORD nAddress = _6502_GetStackReturnAddress();
-    const std::string s = FormatAddress(nAddress, 3);
-    if (ImGui::Button(s.c_str()))
+
+    void ImGuiDebugger::debuggerCommand(SDLFrame *frame, const char *s)
     {
-      setCurrentAddress(nAddress);
+        for (; *s; ++s)
+        {
+            DebuggerInputConsoleChar(*s);
+        }
+        // this might trigger a GO
+        frame->ResetSpeed();
+        DebuggerProcessKey(VK_RETURN);
+        myScrollConsole = true;
     }
-  }
-
-  void ImGuiDebugger::drawAnnunciators()
-  {
-    ImGui::TextUnformatted("Annunciators");
-    ImGui::Separator();
-    ImGui::BeginDisabled();
-    for (UINT i = 0; i < 4; ++i)
+
+    void ImGuiDebugger::drawDisassemblyTable(SDLFrame *frame)
     {
-      char buffer[20];
-      sprintf(buffer, "Ann %d", i);
-      printOnOff(buffer, MemGetAnnunciator(i));
+        const ImGuiTableFlags flags = ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingStretchProp |
+                                      ImGuiTableFlags_BordersOuter | ImGuiTableFlags_ScrollY;
+        if (ImGui::BeginTable("Disassembly", 9, flags))
+        {
+            ImGui::PushStyleCompact();
+            // weigths proportional to column width (including header)
+            ImGui::TableSetupScrollFreeze(0, 1); // Make top row always visible
+            ImGui::TableSetupColumn("", 0, 1);
+            ImGui::TableSetupColumn("Address", 0, 5);
+            ImGui::TableSetupColumn("Opcode", 0, 6);
+            ImGui::TableSetupColumn("Symbol", 0, 10);
+            ImGui::TableSetupColumn("Disassembly", 0, 15);
+            ImGui::TableSetupColumn("Target", 0, 4);
+            ImGui::TableSetupColumn("Branch", 0, 3);
+            ImGui::TableSetupColumn("Immediate", 0, 4);
+            ImGui::TableSetupColumn("Cycles", 0, 6);
+            ImGui::TableHeadersRow();
+
+            ImGuiListClipper clipper;
+            clipper.Begin(1000);
+            int row = 0;
+            WORD nAddress = g_nDisasmTopAddress;
+            while (clipper.Step())
+            {
+                for (; row < clipper.DisplayStart; ++row)
+                {
+                    int iOpcode, iOpmode, nOpbyte;
+                    _6502_GetOpmodeOpbyte(nAddress, iOpmode, nOpbyte, nullptr);
+                    nAddress += nOpbyte;
+                }
+                IM_ASSERT(row == clipper.DisplayStart && "Clipper position mismatch");
+                for (; row < clipper.DisplayEnd; ++row)
+                {
+                    ImGui::PushID(nAddress);
+                    DisasmLine_t line;
+                    std::string const *pSymbol = FindSymbolFromAddress(nAddress);
+                    const int bDisasmFormatFlags = GetDisassemblyLine(nAddress, line);
+
+                    ImGui::TableNextRow();
+
+                    bool breakpointActive;
+                    bool breakpointEnabled;
+                    GetBreakpointInfo(nAddress, breakpointActive, breakpointEnabled);
+
+                    float red = 0.0;
+                    int state = 0;
+                    if (breakpointEnabled)
+                    {
+                        red = 0.5;
+                        state = 1;
+                    }
+                    else if (breakpointActive)
+                    {
+                        red = 0.25;
+                        state = -1;
+                    }
+
+                    ImGui::TableNextColumn();
+
+                    ImGui::BeginDisabled(g_nAppMode != MODE_DEBUG);
+                    if (ImGui::CheckBoxTristate("##State", &state))
+                    {
+                        if (!breakpointActive && state == 1)
+                        {
+                            const std::string command = std::string("bpx ") + line.sAddress;
+                            debuggerCommand(frame, command.c_str());
+                        }
+                        else
+                        {
+                            changeBreakpoint(nAddress, state == 1);
+                        }
+                    }
+                    ImGui::EndDisabled();
+
+                    if (nAddress == regs.pc)
+                    {
+                        const ImU32 currentBgColor = ImGui::GetColorU32(ImVec4(red, 0, 1, 1));
+                        ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg0, currentBgColor);
+                    }
+                    else if (nAddress == g_nDisasmCurAddress)
+                    {
+                        const ImU32 currentBgColor = ImGui::GetColorU32(ImVec4(red, 0, 0.5, 1));
+                        ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg0, currentBgColor);
+                    }
+                    else if (breakpointActive || breakpointEnabled)
+                    {
+                        const ImU32 currentBgColor = ImGui::GetColorU32(ImVec4(red, 0, 0, 1));
+                        ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg0, currentBgColor);
+                    }
+
+                    ImGui::TableNextColumn();
+                    if (ImGui::Selectable(
+                            line.sAddress, g_nDisasmCurAddress == nAddress, ImGuiSelectableFlags_SpanAllColumns))
+                    {
+                        g_nDisasmCurAddress = nAddress;
+                        mySyncCursor = false;
+                    }
+
+                    ImGui::TableNextColumn();
+                    debuggerTextColored(FG_DISASM_OPCODE, line.sOpCodes);
+
+                    ImGui::TableNextColumn();
+                    if (pSymbol)
+                    {
+                        debuggerTextColored(FG_DISASM_SYMBOL, pSymbol->c_str());
+                    }
+
+                    ImGui::TableNextColumn();
+                    displayDisassemblyLine(line, bDisasmFormatFlags);
+
+                    ImGui::TableNextColumn();
+                    if (bDisasmFormatFlags & DISASM_FORMAT_TARGET_POINTER)
+                    {
+                        debuggerTextColored(FG_DISASM_ADDRESS, line.sTargetPointer);
+
+                        if (bDisasmFormatFlags & DISASM_FORMAT_TARGET_VALUE)
+                        {
+                            ImGui::SameLine(0, 0);
+                            debuggerTextColored(FG_DISASM_OPERATOR, ":");
+                            ImGui::SameLine(0, 0);
+                            debuggerTextColored(FG_DISASM_OPCODE, line.sTargetValue);
+                        }
+                    }
+                    else if (line.bTargetImmediate && line.nImmediate)
+                    {
+                        debuggerTextColored(FG_DISASM_OPERATOR, "#");
+                        ImGui::SameLine(0, 0);
+                        debuggerTextColored(FG_DISASM_SINT8, line.sImmediateSignedDec);
+                    }
+
+                    ImGui::TableNextColumn();
+                    if (bDisasmFormatFlags & DISASM_FORMAT_BRANCH)
+                    {
+                        safeDebuggerTextColored(FG_DISASM_BRANCH, line.sBranch);
+                    }
+
+                    ImGui::TableNextColumn();
+                    if (bDisasmFormatFlags & DISASM_FORMAT_CHAR)
+                    {
+                        DebugColors_e color;
+                        const unsigned int c = (unsigned char)line.nImmediate;
+                        if ((c & 0x7F) < 0x20)
+                        {
+                            // Invisible control characters 0x00..0x1F are mapped to a visible range
+                            // in sImmediate, but we want to specially color it.
+                            // Mimics "bCtrlBit" logic in Windows.
+                            color = FG_INFO_CHAR_LO;
+                        }
+                        else if (c > 0x7F)
+                        {
+                            // Characters with high bit set are mapped back down to 0x00..0x7F in
+                            // sImmediate, but we want to specially color it.
+                            // Mimics "bHighBit" logic in Windows.
+                            color = FG_INFO_CHAR_HI;
+                        }
+                        else
+                        {
+                            color = FG_DISASM_CHAR;
+                        }
+                        safeDebuggerTextColored(color, line.sImmediate);
+                    }
+
+                    ImGui::TableNextColumn();
+                    if (g_nAppMode == MODE_DEBUG)
+                    {
+                        if (myAddressCycles.find(nAddress) != myAddressCycles.end())
+                        {
+                            ImGui::Text("%" PRIu64, myAddressCycles[nAddress]);
+                        }
+                    }
+
+                    nAddress += line.nOpbyte;
+                    ImGui::PopID();
+                }
+            }
+            ImGui::PopStyleCompact();
+            ImGui::EndTable();
+        }
     }
-    ImGui::EndDisabled();
-  }
-
-  void ImGuiDebugger::drawSwitches()
-  {
-    Video & video = GetVideo();
-    ImGui::TextUnformatted("Switches C0xx");
-    ImGui::Separator();
-    ImGui::BeginDisabled();
-    printBoolean("50", video.VideoGetSWTEXT(), "GR", "TEXT");
-    printBoolean("52", video.VideoGetSWMIXED(), "FULL", "MIX");
-    printBoolean("54", video.VideoGetSWPAGE2(), "PAGE 1", "PAGE 2");
-    printBoolean("56", video.VideoGetSWHIRES(), "RES LO", "RES HI");
-    printBoolean("5E", !video.VideoGetSWDHIRES(), "DHGR", "HGR");
-    ImGui::Separator();
-    printBoolean("00", video.VideoGetSW80STORE(), "80sto 0", "80sto 1");
-    printBoolean("02", GetMemMode() & MF_AUXREAD, "R m", "R x");
-    printBoolean("02", GetMemMode() & MF_AUXWRITE, "W m", "R x");
-    printBoolean("0C", video.VideoGetSW80COL(), "Col 40", "Col 80");
-    printBoolean("0E", video.VideoGetSWAltCharSet(), "ASC", "MOUS");
-    ImGui::EndDisabled();
-  }
-
-  void ImGuiDebugger::drawBreakpoints()
-  {
-    if (ImGui::BeginTable("Breakpoints", 10, ImGuiTableFlags_RowBg))
+
+    void ImGuiDebugger::drawRegisters()
     {
-      ImGui::TableSetupColumn("ID");
-      ImGui::TableSetupColumn("First");
-      ImGui::TableSetupColumn("Last");
-      ImGui::TableSetupColumn("Source");
-      ImGui::TableSetupColumn("Operator");
-      ImGui::TableSetupColumn("Enabled");
-      ImGui::TableSetupColumn("Stop");
-      ImGui::TableSetupColumn("Temporary");
-      ImGui::TableSetupColumn("Counter");
-      ImGui::TableSetupColumn("Hit");
-      ImGui::TableHeadersRow();
-
-      for (int i = 0; i < MAX_BREAKPOINTS; ++i)
-      {
-        Breakpoint_t & bp = g_aBreakpoints[i];
-        if (bp.bSet)
+        ImGui::TextUnformatted("Registers");
+        ImGui::Separator();
+        printReg('A', regs.a);
+        printReg('X', regs.x);
+        printReg('Y', regs.y);
+        printReg('P', regs.ps);
+        ImGui::Text("PC    %04X", regs.pc);
+        ImGui::Text("SP    %04X", regs.sp);
+        if (regs.bJammed)
         {
-          ImGui::PushID(i);
-          ImGui::TableNextRow();
-          ImGui::TableNextColumn();
-          ImGui::Text("%2d", i);
-          ImGui::TableNextColumn();
-          ImGui::Text("%04X", bp.nAddress);
-          ImGui::TableNextColumn();
-          ImGui::Text("%04X", bp.nAddress + bp.nLength - 1);
-          ImGui::TableNextColumn();
-          ImGui::Text("%2d", bp.eSource);
-          ImGui::TableNextColumn();
-          ImGui::Text("%2d", bp.eOperator);
-          ImGui::TableNextColumn();
-          ImGui::Checkbox("##Enabled", &bp.bEnabled);
-          ImGui::TableNextColumn();
-          ImGui::Checkbox("##Stop", &bp.bStop);
-          ImGui::TableNextColumn();
-          ImGui::Checkbox("##Temp", &bp.bTemp);
-          ImGui::TableNextColumn();
-          ImGui::Text("%08X", bp.nHitCount);
-          ImGui::TableNextColumn();
-          ImGui::BeginDisabled();
-          ImGui::Checkbox("##Hit", &bp.bHit);
-          ImGui::EndDisabled();
-          ImGui::PopID();
+            ImGui::Separator();
+            ImGui::Selectable("CPU Jammed");
         }
-      }
-
-      ImGui::EndTable();
     }
-  }
 
-  void ImGuiDebugger::drawConsole()
-  {
-    const ImGuiTableFlags flags = ImGuiTableFlags_BordersV | ImGuiTableFlags_BordersOuter | ImGuiTableFlags_ScrollY;
-    if (ImGui::BeginTable("Console", 1, flags))
+    void ImGuiDebugger::drawStackReturnAddress()
     {
-      for (int i = g_nConsoleDisplayTotal; i >= CONSOLE_FIRST_LINE; --i)
-      {
-        const conchar_t * src = g_aConsoleDisplay[i];
-
-        char line[CONSOLE_WIDTH + 1];
-        char lineMouseText[2 * CONSOLE_WIDTH + 1];
-        size_t length = 0;
-
-        ImGui::TableNextRow();
-        ImGui::TableNextColumn();
-        COLORREF currentColor = DebuggerGetColor( FG_CONSOLE_OUTPUT );
-
-        const auto textAndReset = [&line, &lineMouseText, &length, &currentColor] () {
-          line[length] = 0;
-          const ImVec4 color = colorrefToImVec4(currentColor);
-          adjustMouseText(line, length, lineMouseText);
-          ImGui::TextColored(color, "%s", lineMouseText);
-          length = 0;
-        };
-
-        for (size_t j = 0; j < CONSOLE_WIDTH; ++j)
+        ImGui::TextUnformatted("Stack return");
+        ImGui::Separator();
+        const WORD nAddress = _6502_GetStackReturnAddress();
+        const std::string s = FormatAddress(nAddress, 3);
+        if (ImGui::Button(s.c_str()))
         {
-          const conchar_t g = src[j];
-          if (!g)
-          {
-            break;
-          }
-          if (ConsoleColor_IsColorOrMouse(g))
-          {
-            // colors propagate till next color information
-            // left in, right out = [ )
-            textAndReset();
-            ImGui::SameLine(0, 0);
-            currentColor = ConsoleColor_GetColor(g);
-          }
-          line[length] = ConsoleChar_GetChar(g);
-          ++length;
+            setCurrentAddress(nAddress);
         }
-        textAndReset();
-      }
-      ImGui::TableNextRow();
-      ImGui::TableNextColumn();
-      ImGui::TextUnformatted(g_aConsoleInput);
-
-      if (myScrollConsole)
-      {
-        ImGui::SetScrollHereY(1.0f);
-        myScrollConsole = false;
-      }
-      ImGui::EndTable();
     }
-  }
-
-  void ImGuiDebugger::resetDebuggerCycles()
-  {
-    myAddressCycles.clear();
-    myBaseDebuggerCycles = g_nCumulativeCycles;
-  }
 
-  void ImGuiDebugger::processDebuggerKeys()
-  {
-    if (ImGui::IsKeyChordPressed(ImGuiKey_Space | ImGuiMod_Ctrl))
+    void ImGuiDebugger::drawAnnunciators()
     {
-      CmdStepOver(0);
+        ImGui::TextUnformatted("Annunciators");
+        ImGui::Separator();
+        ImGui::BeginDisabled();
+        for (UINT i = 0; i < 4; ++i)
+        {
+            char buffer[20];
+            sprintf(buffer, "Ann %d", i);
+            printOnOff(buffer, MemGetAnnunciator(i));
+        }
+        ImGui::EndDisabled();
     }
-    else if (ImGui::IsKeyChordPressed(ImGuiKey_Space | ImGuiMod_Shift))
+
+    void ImGuiDebugger::drawSwitches()
     {
-      CmdStepOut(0);
+        Video &video = GetVideo();
+        ImGui::TextUnformatted("Switches C0xx");
+        ImGui::Separator();
+        ImGui::BeginDisabled();
+        printBoolean("50", video.VideoGetSWTEXT(), "GR", "TEXT");
+        printBoolean("52", video.VideoGetSWMIXED(), "FULL", "MIX");
+        printBoolean("54", video.VideoGetSWPAGE2(), "PAGE 1", "PAGE 2");
+        printBoolean("56", video.VideoGetSWHIRES(), "RES LO", "RES HI");
+        printBoolean("5E", !video.VideoGetSWDHIRES(), "DHGR", "HGR");
+        ImGui::Separator();
+        printBoolean("00", video.VideoGetSW80STORE(), "80sto 0", "80sto 1");
+        printBoolean("02", GetMemMode() & MF_AUXREAD, "R m", "R x");
+        printBoolean("02", GetMemMode() & MF_AUXWRITE, "W m", "R x");
+        printBoolean("0C", video.VideoGetSW80COL(), "Col 40", "Col 80");
+        printBoolean("0E", video.VideoGetSWAltCharSet(), "ASC", "MOUS");
+        ImGui::EndDisabled();
     }
-    else if (ImGui::IsKeyChordPressed(ImGuiKey_Space))
+
+    void ImGuiDebugger::drawBreakpoints()
     {
-      CmdTrace(0);
+        if (ImGui::BeginTable("Breakpoints", 10, ImGuiTableFlags_RowBg))
+        {
+            ImGui::TableSetupColumn("ID");
+            ImGui::TableSetupColumn("First");
+            ImGui::TableSetupColumn("Last");
+            ImGui::TableSetupColumn("Source");
+            ImGui::TableSetupColumn("Operator");
+            ImGui::TableSetupColumn("Enabled");
+            ImGui::TableSetupColumn("Stop");
+            ImGui::TableSetupColumn("Temporary");
+            ImGui::TableSetupColumn("Counter");
+            ImGui::TableSetupColumn("Hit");
+            ImGui::TableHeadersRow();
+
+            for (int i = 0; i < MAX_BREAKPOINTS; ++i)
+            {
+                Breakpoint_t &bp = g_aBreakpoints[i];
+                if (bp.bSet)
+                {
+                    ImGui::PushID(i);
+                    ImGui::TableNextRow();
+                    ImGui::TableNextColumn();
+                    ImGui::Text("%2d", i);
+                    ImGui::TableNextColumn();
+                    ImGui::Text("%04X", bp.nAddress);
+                    ImGui::TableNextColumn();
+                    ImGui::Text("%04X", bp.nAddress + bp.nLength - 1);
+                    ImGui::TableNextColumn();
+                    ImGui::Text("%2d", bp.eSource);
+                    ImGui::TableNextColumn();
+                    ImGui::Text("%2d", bp.eOperator);
+                    ImGui::TableNextColumn();
+                    ImGui::Checkbox("##Enabled", &bp.bEnabled);
+                    ImGui::TableNextColumn();
+                    ImGui::Checkbox("##Stop", &bp.bStop);
+                    ImGui::TableNextColumn();
+                    ImGui::Checkbox("##Temp", &bp.bTemp);
+                    ImGui::TableNextColumn();
+                    ImGui::Text("%08X", bp.nHitCount);
+                    ImGui::TableNextColumn();
+                    ImGui::BeginDisabled();
+                    ImGui::Checkbox("##Hit", &bp.bHit);
+                    ImGui::EndDisabled();
+                    ImGui::PopID();
+                }
+            }
+
+            ImGui::EndTable();
+        }
     }
-    else if (ImGui::IsKeyChordPressed(ImGuiKey_DownArrow | ImGuiMod_Ctrl))
+
+    void ImGuiDebugger::drawConsole()
     {
-      CmdCursorRunUntil(0);
+        const ImGuiTableFlags flags = ImGuiTableFlags_BordersV | ImGuiTableFlags_BordersOuter | ImGuiTableFlags_ScrollY;
+        if (ImGui::BeginTable("Console", 1, flags))
+        {
+            for (int i = g_nConsoleDisplayTotal; i >= CONSOLE_FIRST_LINE; --i)
+            {
+                const conchar_t *src = g_aConsoleDisplay[i];
+
+                char line[CONSOLE_WIDTH + 1];
+                char lineMouseText[2 * CONSOLE_WIDTH + 1];
+                size_t length = 0;
+
+                ImGui::TableNextRow();
+                ImGui::TableNextColumn();
+                COLORREF currentColor = DebuggerGetColor(FG_CONSOLE_OUTPUT);
+
+                const auto textAndReset = [&line, &lineMouseText, &length, &currentColor]()
+                {
+                    line[length] = 0;
+                    const ImVec4 color = colorrefToImVec4(currentColor);
+                    adjustMouseText(line, length, lineMouseText);
+                    ImGui::TextColored(color, "%s", lineMouseText);
+                    length = 0;
+                };
+
+                for (size_t j = 0; j < CONSOLE_WIDTH; ++j)
+                {
+                    const conchar_t g = src[j];
+                    if (!g)
+                    {
+                        break;
+                    }
+                    if (ConsoleColor_IsColorOrMouse(g))
+                    {
+                        // colors propagate till next color information
+                        // left in, right out = [ )
+                        textAndReset();
+                        ImGui::SameLine(0, 0);
+                        currentColor = ConsoleColor_GetColor(g);
+                    }
+                    line[length] = ConsoleChar_GetChar(g);
+                    ++length;
+                }
+                textAndReset();
+            }
+            ImGui::TableNextRow();
+            ImGui::TableNextColumn();
+            ImGui::TextUnformatted(g_aConsoleInput);
+
+            if (myScrollConsole)
+            {
+                ImGui::SetScrollHereY(1.0f);
+                myScrollConsole = false;
+            }
+            ImGui::EndTable();
+        }
     }
-    else if (ImGui::IsKeyChordPressed(ImGuiKey_RightArrow | ImGuiMod_Ctrl))
+
+    void ImGuiDebugger::resetDebuggerCycles()
     {
-      CmdCursorSetPC(0);
+        myAddressCycles.clear();
+        myBaseDebuggerCycles = g_nCumulativeCycles;
     }
-    else if (ImGui::IsKeyChordPressed(ImGuiKey_LeftArrow))
+
+    void ImGuiDebugger::processDebuggerKeys()
     {
-    	WORD nAddress = _6502_GetStackReturnAddress();
-      setCurrentAddress(nAddress);
+        if (ImGui::IsKeyChordPressed(ImGuiKey_Space | ImGuiMod_Ctrl))
+        {
+            CmdStepOver(0);
+        }
+        else if (ImGui::IsKeyChordPressed(ImGuiKey_Space | ImGuiMod_Shift))
+        {
+            CmdStepOut(0);
+        }
+        else if (ImGui::IsKeyChordPressed(ImGuiKey_Space))
+        {
+            CmdTrace(0);
+        }
+        else if (ImGui::IsKeyChordPressed(ImGuiKey_DownArrow | ImGuiMod_Ctrl))
+        {
+            CmdCursorRunUntil(0);
+        }
+        else if (ImGui::IsKeyChordPressed(ImGuiKey_RightArrow | ImGuiMod_Ctrl))
+        {
+            CmdCursorSetPC(0);
+        }
+        else if (ImGui::IsKeyChordPressed(ImGuiKey_LeftArrow))
+        {
+            WORD nAddress = _6502_GetStackReturnAddress();
+            setCurrentAddress(nAddress);
+        }
     }
-  }
 
-  void ImGuiDebugger::setCurrentAddress(const uint32_t nAddress)
-  {
-    g_nDisasmCurAddress = nAddress;
-    DisasmCalcTopBotAddress();
-    mySyncCursor = false;
-  }
+    void ImGuiDebugger::setCurrentAddress(const uint32_t nAddress)
+    {
+        g_nDisasmCurAddress = nAddress;
+        DisasmCalcTopBotAddress();
+        mySyncCursor = false;
+    }
 
-}
+} // namespace sa2
diff --git a/source/frontends/sdl/imgui/sdldebugger.h b/source/frontends/sdl/imgui/sdldebugger.h
index 73435cc70..7eb7a1099 100644
--- a/source/frontends/sdl/imgui/sdldebugger.h
+++ b/source/frontends/sdl/imgui/sdldebugger.h
@@ -8,41 +8,41 @@
 namespace sa2
 {
 
-  class SDLFrame;
+    class SDLFrame;
 
-  class ImGuiDebugger
-  {
-  public:
-    bool showDebugger = false;
+    class ImGuiDebugger
+    {
+    public:
+        bool showDebugger = false;
 
-    void drawDebugger(SDLFrame* frame);
-    void resetDebuggerCycles();
+        void drawDebugger(SDLFrame *frame);
+        void resetDebuggerCycles();
 
-    void syncDebuggerState(SDLFrame* frame);
+        void syncDebuggerState(SDLFrame *frame);
 
-  private:
-    bool mySyncCursor = true;
-    bool myScrollConsole = true;
+    private:
+        bool mySyncCursor = true;
+        bool myScrollConsole = true;
 
-    int64_t myBaseDebuggerCycles;
-    std::unordered_map<uint32_t, int64_t> myAddressCycles;
+        int64_t myBaseDebuggerCycles;
+        std::unordered_map<uint32_t, int64_t> myAddressCycles;
 
-    CycleTabItems myCycleTabItems;
-    InputTextHistory myInputTextHistory;
+        CycleTabItems myCycleTabItems;
+        InputTextHistory myInputTextHistory;
 
-    void debuggerCommand(SDLFrame * frame, const char * s);
+        void debuggerCommand(SDLFrame *frame, const char *s);
 
-    void drawDisassemblyTable(SDLFrame * frame);
-    void drawConsole();
-    void drawBreakpoints();
-    void drawRegisters();
-    void drawStackReturnAddress();
-    void drawAnnunciators();
-    void drawSwitches();
+        void drawDisassemblyTable(SDLFrame *frame);
+        void drawConsole();
+        void drawBreakpoints();
+        void drawRegisters();
+        void drawStackReturnAddress();
+        void drawAnnunciators();
+        void drawSwitches();
 
-    void processDebuggerKeys();
+        void processDebuggerKeys();
 
-    void setCurrentAddress(const uint32_t nAddress);
- };
+        void setCurrentAddress(const uint32_t nAddress);
+    };
 
-}
\ No newline at end of file
+} // namespace sa2
\ No newline at end of file
diff --git a/source/frontends/sdl/imgui/sdlimguiframe.cpp b/source/frontends/sdl/imgui/sdlimguiframe.cpp
index 6859370b6..4552144a9 100644
--- a/source/frontends/sdl/imgui/sdlimguiframe.cpp
+++ b/source/frontends/sdl/imgui/sdlimguiframe.cpp
@@ -13,337 +13,337 @@
 
 #include <iostream>
 
-
 namespace
 {
 
-  std::string safeGlGetString(GLenum name)
-  {
-    const char * str = reinterpret_cast<const char *>(glGetString(name));
-    if (str)
+    std::string safeGlGetString(GLenum name)
     {
-      return str;
+        const char *str = reinterpret_cast<const char *>(glGetString(name));
+        if (str)
+        {
+            return str;
+        }
+        else
+        {
+            return "<MISSING>";
+        }
     }
-    else
+
+    void correctAspectRatio(ImVec2 &p_min, ImVec2 &p_max, float originalAspectRatio)
     {
-      return "<MISSING>";
+        // scale
+        const float w1 = p_max.x - p_min.x;
+        const float h1 = p_max.y - p_min.y;
+        const float w = std::min(w1, h1 * originalAspectRatio);
+        const float h = std::min(h1, w1 / originalAspectRatio);
+
+        // center
+        p_min.x += (p_max.x - p_min.x - w) / 2;
+        p_max.x = p_min.x + w;
+        p_min.y += (p_max.y - p_min.y - h) / 2;
+        p_max.y = p_min.y + h;
     }
-  }
-
-  void correctAspectRatio(ImVec2 & p_min, ImVec2 & p_max, float originalAspectRatio)
-  {
-    // scale
-    const float w1 = p_max.x - p_min.x;
-    const float h1 = p_max.y - p_min.y;
-    const float w = std::min(w1, h1 * originalAspectRatio);
-    const float h = std::min(h1, w1 / originalAspectRatio);
-
-    // center
-    p_min.x += (p_max.x - p_min.x - w) / 2;
-    p_max.x = p_min.x + w;
-    p_min.y += (p_max.y - p_min.y - h) / 2;
-    p_max.y = p_min.y + h;
-  }
-
-}
 
+} // namespace
 
 namespace sa2
 {
 
-  SDLImGuiFrame::SDLImGuiFrame(const common2::EmulatorOptions & options)
-    : SDLFrame(options)
-    , myPresenting(false)
-    , myShowMouseCursor(true)
-  {
-    SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SA2_CONTEXT_FLAGS);
-    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SA2_CONTEXT_PROFILE_MASK);
-    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, SA2_CONTEXT_MAJOR_VERSION); // from local gles.h
-    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, SA2_CONTEXT_MINOR_VERSION);
-
-    // Create window with graphics context
-    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
-    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
-    SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
-
-    const SDL_WindowFlags windowFlags = (SDL_WindowFlags)(SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
-    const common2::Geometry geometry = getGeometryOrDefault(options.geometry);
-
-    myWindow.reset(SDL_CreateWindow(g_pAppTitle.c_str(), geometry.x, geometry.y, geometry.width, geometry.height, windowFlags), SDL_DestroyWindow);
-    if (!myWindow)
+    SDLImGuiFrame::SDLImGuiFrame(const common2::EmulatorOptions &options)
+        : SDLFrame(options)
+        , myPresenting(false)
+        , myShowMouseCursor(true)
     {
-      throw std::runtime_error(decorateSDLError("SDL_CreateWindow"));
-    }
-
-    SetApplicationIcon();
+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SA2_CONTEXT_FLAGS);
+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SA2_CONTEXT_PROFILE_MASK);
+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, SA2_CONTEXT_MAJOR_VERSION); // from local gles.h
+        SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, SA2_CONTEXT_MINOR_VERSION);
+
+        // Create window with graphics context
+        SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+        SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
+        SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
+
+        const SDL_WindowFlags windowFlags = (SDL_WindowFlags)(SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
+        const common2::Geometry geometry = getGeometryOrDefault(options.geometry);
+
+        myWindow.reset(
+            SDL_CreateWindow(g_pAppTitle.c_str(), geometry.x, geometry.y, geometry.width, geometry.height, windowFlags),
+            SDL_DestroyWindow);
+        if (!myWindow)
+        {
+            throw std::runtime_error(decorateSDLError("SDL_CreateWindow"));
+        }
 
-    myGLContext = SDL_GL_CreateContext(myWindow.get());
-    if (!myGLContext)
-    {
-      throw std::runtime_error(decorateSDLError("SDL_GL_CreateContext"));
-    }
+        SetApplicationIcon();
 
-    SDL_GL_MakeCurrent(myWindow.get(), myGLContext);
-    SetGLSynchronisation(options); // must be called after GL initialisation
-
-    // Setup Platform/Renderer backends
-    std::cerr << "IMGUI_VERSION: " << IMGUI_VERSION << std::endl;
-    std::cerr << "GL_VENDOR: " << safeGlGetString(GL_VENDOR) << std::endl;
-    std::cerr << "GL_RENDERER: " << safeGlGetString(GL_RENDERER) << std::endl;
-    std::cerr << "GL_VERSION: " << safeGlGetString(GL_VERSION) << std::endl;
-    std::cerr << "GL_SHADING_LANGUAGE_VERSION: " << safeGlGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
-    //  const char* runtime_gl_extensions = (const char*)safeGlGetString(GL_EXTENSIONS);
-    //  std::cerr << "GL_EXTENSIONS: " << runtime_gl_extensions << std::endl;
-
-    // Setup Dear ImGui context
-    IMGUI_CHECKVERSION();
-    ImGui::CreateContext();
-    ImGuiIO& io = ImGui::GetIO();
-
-    io.Fonts->AddFontDefault();
-    const auto debug6502TTF = GetResourceData(IDB_DEBUG_FONT_7_by_8);
-    ImFontConfig fontConfig;
-    fontConfig.FontDataOwnedByAtlas = false;
-    myDebuggerFont = io.Fonts->AddFontFromMemoryTTF(const_cast<unsigned char *>(debug6502TTF.first), debug6502TTF.second, 13,
-      &fontConfig);
-
-    myIniFileLocation = common2::getConfigFile("imgui.ini");
-    if (myIniFileLocation.empty())
-    {
-      io.IniFilename = nullptr;
-    }
-    else
-    {
-      io.IniFilename = myIniFileLocation.c_str();
-    }
+        myGLContext = SDL_GL_CreateContext(myWindow.get());
+        if (!myGLContext)
+        {
+            throw std::runtime_error(decorateSDLError("SDL_GL_CreateContext"));
+        }
 
-    //io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;     // Enable Keyboard Controls
-    //io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
+        SDL_GL_MakeCurrent(myWindow.get(), myGLContext);
+        SetGLSynchronisation(options); // must be called after GL initialisation
+
+        // Setup Platform/Renderer backends
+        std::cerr << "IMGUI_VERSION: " << IMGUI_VERSION << std::endl;
+        std::cerr << "GL_VENDOR: " << safeGlGetString(GL_VENDOR) << std::endl;
+        std::cerr << "GL_RENDERER: " << safeGlGetString(GL_RENDERER) << std::endl;
+        std::cerr << "GL_VERSION: " << safeGlGetString(GL_VERSION) << std::endl;
+        std::cerr << "GL_SHADING_LANGUAGE_VERSION: " << safeGlGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
+        //  const char* runtime_gl_extensions = (const char*)safeGlGetString(GL_EXTENSIONS);
+        //  std::cerr << "GL_EXTENSIONS: " << runtime_gl_extensions << std::endl;
+
+        // Setup Dear ImGui context
+        IMGUI_CHECKVERSION();
+        ImGui::CreateContext();
+        ImGuiIO &io = ImGui::GetIO();
+
+        io.Fonts->AddFontDefault();
+        const auto debug6502TTF = GetResourceData(IDB_DEBUG_FONT_7_by_8);
+        ImFontConfig fontConfig;
+        fontConfig.FontDataOwnedByAtlas = false;
+        myDebuggerFont = io.Fonts->AddFontFromMemoryTTF(
+            const_cast<unsigned char *>(debug6502TTF.first), debug6502TTF.second, 13, &fontConfig);
+
+        myIniFileLocation = common2::getConfigFile("imgui.ini");
+        if (myIniFileLocation.empty())
+        {
+            io.IniFilename = nullptr;
+        }
+        else
+        {
+            io.IniFilename = myIniFileLocation.c_str();
+        }
 
-    ImGui::StyleColorsDark();
+        // io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;     // Enable Keyboard Controls
+        // io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
 
-    ImGui_ImplSDL2_InitForOpenGL(myWindow.get(), myGLContext);
-    ImGui_ImplOpenGL3_Init();
+        ImGui::StyleColorsDark();
 
-    myDeadTopZone = 0;
-    myTexture = 0;
-  }
+        ImGui_ImplSDL2_InitForOpenGL(myWindow.get(), myGLContext);
+        ImGui_ImplOpenGL3_Init();
 
-  SDLImGuiFrame::~SDLImGuiFrame()
-  {
-    glDeleteTextures(1, &myTexture);
-    ImGui_ImplOpenGL3_Shutdown();
-    ImGui_ImplSDL2_Shutdown();
-    ImGui::DestroyContext();
-    SDL_GL_DeleteContext(myGLContext);
-  }
+        myDeadTopZone = 0;
+        myTexture = 0;
+    }
 
-  void SDLImGuiFrame::Initialize(bool resetVideoState)
-  {
-    SDLFrame::Initialize(resetVideoState);
-    glDeleteTextures(1, &myTexture);
-    glGenTextures(1, &myTexture);
+    SDLImGuiFrame::~SDLImGuiFrame()
+    {
+        glDeleteTextures(1, &myTexture);
+        ImGui_ImplOpenGL3_Shutdown();
+        ImGui_ImplSDL2_Shutdown();
+        ImGui::DestroyContext();
+        SDL_GL_DeleteContext(myGLContext);
+    }
 
-    Video & video = GetVideo();
+    void SDLImGuiFrame::Initialize(bool resetVideoState)
+    {
+        SDLFrame::Initialize(resetVideoState);
+        glDeleteTextures(1, &myTexture);
+        glGenTextures(1, &myTexture);
 
-    myBorderlessWidth = video.GetFrameBufferBorderlessWidth();
-    myBorderlessHeight = video.GetFrameBufferBorderlessHeight();
-    myOriginalAspectRatio = float(myBorderlessWidth) / float(myBorderlessHeight);
+        Video &video = GetVideo();
 
-    const int width = video.GetFrameBufferWidth();
-    const size_t borderWidth = video.GetFrameBufferBorderWidth();
-    const size_t borderHeight = video.GetFrameBufferBorderHeight();
+        myBorderlessWidth = video.GetFrameBufferBorderlessWidth();
+        myBorderlessHeight = video.GetFrameBufferBorderlessHeight();
+        myOriginalAspectRatio = float(myBorderlessWidth) / float(myBorderlessHeight);
 
-    myPitch = width;
-    myOffset = (width * borderHeight + borderWidth) * sizeof(bgra_t);
+        const int width = video.GetFrameBufferWidth();
+        const size_t borderWidth = video.GetFrameBufferBorderWidth();
+        const size_t borderHeight = video.GetFrameBufferBorderHeight();
 
-    allocateTexture(myTexture, myBorderlessWidth, myBorderlessHeight);
-  }
+        myPitch = width;
+        myOffset = (width * borderHeight + borderWidth) * sizeof(bgra_t);
 
-  void SDLImGuiFrame::UpdateTexture()
-  {
-    loadTextureFromData(myTexture, myFramebuffer.data() + myOffset, myBorderlessWidth, myBorderlessHeight, myPitch);
-  }
+        allocateTexture(myTexture, myBorderlessWidth, myBorderlessHeight);
+    }
 
-  void SDLImGuiFrame::ClearBackground()
-  {
-    ImVec4 background(0.0f, 0.0f, 0.0f, 1.0f); // black is good for the borders
-    if (mySettings.windowed)
+    void SDLImGuiFrame::UpdateTexture()
     {
-      background = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);
+        loadTextureFromData(myTexture, myFramebuffer.data() + myOffset, myBorderlessWidth, myBorderlessHeight, myPitch);
     }
 
-    glClearColor(background.x, background.y, background.z, background.w);
-    glClear(GL_COLOR_BUFFER_BIT);
-  }
-
-  void SDLImGuiFrame::DrawAppleVideo()
-  {
-    // need to flip the texture vertically
-    const ImVec2 uv0(0, 1);
-    const ImVec2 uv1(1, 0);
-
-    const float menuBarHeight = mySettings.drawMenuBar(this, !myFullscreen);
-    myDeadTopZone = menuBarHeight;
-
-    if (mySettings.windowed)
+    void SDLImGuiFrame::ClearBackground()
     {
-      if (ImGui::Begin("Apple ]["))
-      {
-        UpdateTexture();
-        ImGui::Image(myTexture, ImGui::GetContentRegionAvail(), uv0, uv1);
-      }
-      ImGui::End();
+        ImVec4 background(0.0f, 0.0f, 0.0f, 1.0f); // black is good for the borders
+        if (mySettings.windowed)
+        {
+            background = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);
+        }
+
+        glClearColor(background.x, background.y, background.z, background.w);
+        glClear(GL_COLOR_BUFFER_BIT);
     }
-    else
+
+    void SDLImGuiFrame::DrawAppleVideo()
     {
-      UpdateTexture();
+        // need to flip the texture vertically
+        const ImVec2 uv0(0, 1);
+        const ImVec2 uv1(1, 0);
+
+        const float menuBarHeight = mySettings.drawMenuBar(this, !myFullscreen);
+        myDeadTopZone = menuBarHeight;
+
+        if (mySettings.windowed)
+        {
+            if (ImGui::Begin("Apple ]["))
+            {
+                UpdateTexture();
+                ImGui::Image(myTexture, ImGui::GetContentRegionAvail(), uv0, uv1);
+            }
+            ImGui::End();
+        }
+        else
+        {
+            UpdateTexture();
 
-      // draw on the background
-      ImGuiIO& io = ImGui::GetIO();
-      ImVec2 p_min(0, menuBarHeight);
-      ImVec2 p_max = io.DisplaySize;
+            // draw on the background
+            ImGuiIO &io = ImGui::GetIO();
+            ImVec2 p_min(0, menuBarHeight);
+            ImVec2 p_max = io.DisplaySize;
 
-      if (myPreserveAspectRatio)
-      {
-        // scale & center
-        correctAspectRatio(p_min, p_max, myOriginalAspectRatio);
-      }
+            if (myPreserveAspectRatio)
+            {
+                // scale & center
+                correctAspectRatio(p_min, p_max, myOriginalAspectRatio);
+            }
 
-      ImGui::GetBackgroundDrawList()->AddImage(myTexture, p_min, p_max, uv0, uv1);
+            ImGui::GetBackgroundDrawList()->AddImage(myTexture, p_min, p_max, uv0, uv1);
+        }
     }
-  }
-
-  void SDLImGuiFrame::GetRelativeMousePosition(const SDL_MouseMotionEvent & motion, float & x, float & y) const
-  {
-    // this currently ignores a windowed apple video and applies to the whole sdl window
-    int w, h;
-    SDL_GetWindowSize(myWindow.get(), &w, &h);
-
-    const float posY = std::max(motion.y - myDeadTopZone, 0.0f);
-    const float height = std::max(h - myDeadTopZone, 1.0f);  // a real window has a minimum size of 1
-    const float width = w;
-
-    x = GetRelativePosition(motion.x, width);
-    y = GetRelativePosition(posY, height);
-  }
-
-  void SDLImGuiFrame::VideoPresentScreen()
-  {
-    // this is NOT REENTRANT
-    // the debugger (executed via mySettings.show(this)) might call it recursively
-    if (!myPresenting)
+
+    void SDLImGuiFrame::GetRelativeMousePosition(const SDL_MouseMotionEvent &motion, float &x, float &y) const
     {
-      myPresenting = true;
-      ImGui_ImplOpenGL3_NewFrame();
-      ImGui_ImplSDL2_NewFrame();
-      ImGui::NewFrame();
-
-      if (!myShowMouseCursor)
-      {
-        ImGui::SetMouseCursor(ImGuiMouseCursor_None);
-      } // otherwise leave it to the default set in ImGui::NewFrame();
-
-      // "this" is a bit circular
-      mySettings.show(this, myDebuggerFont);
-      DrawAppleVideo();
-
-      ImGui::Render();
-      ClearBackground();
-      ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
-      SDL_GL_SwapWindow(myWindow.get());
-      myPresenting = false;
-    }
-  }
+        // this currently ignores a windowed apple video and applies to the whole sdl window
+        int w, h;
+        SDL_GetWindowSize(myWindow.get(), &w, &h);
+
+        const float posY = std::max(motion.y - myDeadTopZone, 0.0f);
+        const float height = std::max(h - myDeadTopZone, 1.0f); // a real window has a minimum size of 1
+        const float width = w;
 
-  void SDLImGuiFrame::ProcessSingleEvent(const SDL_Event & event, bool & quit)
-  {
-    ImGui_ImplSDL2_ProcessEvent(&event);
+        x = GetRelativePosition(motion.x, width);
+        y = GetRelativePosition(posY, height);
+    }
 
-    switch (event.type)
+    void SDLImGuiFrame::VideoPresentScreen()
     {
-    case SDL_KEYDOWN:
-    case SDL_KEYUP:
-    case SDL_TEXTINPUT:
-      {
-        ImGuiIO& io = ImGui::GetIO();
-        if (io.WantCaptureKeyboard)
-        {
-          return; // do not pass on
-        }
-        break;
-      }
-    case SDL_MOUSEBUTTONDOWN:
-    case SDL_MOUSEBUTTONUP:
-    case SDL_MOUSEMOTION:
-      {
-        ImGuiIO& io = ImGui::GetIO();
-        if (io.WantCaptureMouse)
+        // this is NOT REENTRANT
+        // the debugger (executed via mySettings.show(this)) might call it recursively
+        if (!myPresenting)
         {
-          return; // do not pass on
+            myPresenting = true;
+            ImGui_ImplOpenGL3_NewFrame();
+            ImGui_ImplSDL2_NewFrame();
+            ImGui::NewFrame();
+
+            if (!myShowMouseCursor)
+            {
+                ImGui::SetMouseCursor(ImGuiMouseCursor_None);
+            } // otherwise leave it to the default set in ImGui::NewFrame();
+
+            // "this" is a bit circular
+            mySettings.show(this, myDebuggerFont);
+            DrawAppleVideo();
+
+            ImGui::Render();
+            ClearBackground();
+            ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+            SDL_GL_SwapWindow(myWindow.get());
+            myPresenting = false;
         }
-        break;
-      }
     }
 
-    SDLFrame::ProcessSingleEvent(event, quit);
-  }
-
-  void SDLImGuiFrame::ProcessKeyDown(const SDL_KeyboardEvent & key, bool &quit)
-  {
-    // a bit of care is required
-    // since we do not want to trigger twice (here and SDLFrame)
-    // we need to ensure the modifiers are consistent
-    if (!key.repeat)
+    void SDLImGuiFrame::ProcessSingleEvent(const SDL_Event &event, bool &quit)
     {
-      const size_t modifiers = getCanonicalModifiers(key);
+        ImGui_ImplSDL2_ProcessEvent(&event);
 
-      switch (key.keysym.sym)
-      {
-      case SDLK_F8:
+        switch (event.type)
         {
-          if (modifiers == KMOD_NONE)
-          {
-            mySettings.toggleSettings();
-          }
-          break;
-        }
-      case SDLK_F3:
+        case SDL_KEYDOWN:
+        case SDL_KEYUP:
+        case SDL_TEXTINPUT:
         {
-          if (modifiers == KMOD_NONE)
-          {
-            mySettings.showDiskTab();
-          }
-          break;
+            ImGuiIO &io = ImGui::GetIO();
+            if (io.WantCaptureKeyboard)
+            {
+                return; // do not pass on
+            }
+            break;
         }
-      case SDLK_F1:
+        case SDL_MOUSEBUTTONDOWN:
+        case SDL_MOUSEBUTTONUP:
+        case SDL_MOUSEMOTION:
         {
-          if (modifiers == KMOD_NONE)
-          {
-            mySettings.toggleShortcuts();
-          }
-          break;
+            ImGuiIO &io = ImGui::GetIO();
+            if (io.WantCaptureMouse)
+            {
+                return; // do not pass on
+            }
+            break;
+        }
         }
-      }
+
+        SDLFrame::ProcessSingleEvent(event, quit);
     }
 
-    SDLFrame::ProcessKeyDown(key, quit);
-  }
+    void SDLImGuiFrame::ProcessKeyDown(const SDL_KeyboardEvent &key, bool &quit)
+    {
+        // a bit of care is required
+        // since we do not want to trigger twice (here and SDLFrame)
+        // we need to ensure the modifiers are consistent
+        if (!key.repeat)
+        {
+            const size_t modifiers = getCanonicalModifiers(key);
+
+            switch (key.keysym.sym)
+            {
+            case SDLK_F8:
+            {
+                if (modifiers == KMOD_NONE)
+                {
+                    mySettings.toggleSettings();
+                }
+                break;
+            }
+            case SDLK_F3:
+            {
+                if (modifiers == KMOD_NONE)
+                {
+                    mySettings.showDiskTab();
+                }
+                break;
+            }
+            case SDLK_F1:
+            {
+                if (modifiers == KMOD_NONE)
+                {
+                    mySettings.toggleShortcuts();
+                }
+                break;
+            }
+            }
+        }
+
+        SDLFrame::ProcessKeyDown(key, quit);
+    }
 
-  bool SDLImGuiFrame::Quit() const
-  {
-    return mySettings.quit;
-  }
+    bool SDLImGuiFrame::Quit() const
+    {
+        return mySettings.quit;
+    }
 
-  void SDLImGuiFrame::ResetSpeed()
-  {
-    SDLFrame::ResetSpeed();
-    mySettings.resetDebuggerCycles();
-  }
+    void SDLImGuiFrame::ResetSpeed()
+    {
+        SDLFrame::ResetSpeed();
+        mySettings.resetDebuggerCycles();
+    }
 
-  void SDLImGuiFrame::ToggleMouseCursor()
-  {
-    myShowMouseCursor = !myShowMouseCursor;
-  }
+    void SDLImGuiFrame::ToggleMouseCursor()
+    {
+        myShowMouseCursor = !myShowMouseCursor;
+    }
 
-}
+} // namespace sa2
diff --git a/source/frontends/sdl/imgui/sdlimguiframe.h b/source/frontends/sdl/imgui/sdlimguiframe.h
index 8abd7854e..9a9dcc78b 100644
--- a/source/frontends/sdl/imgui/sdlimguiframe.h
+++ b/source/frontends/sdl/imgui/sdlimguiframe.h
@@ -7,48 +7,46 @@
 namespace sa2
 {
 
-  class SDLImGuiFrame : public SDLFrame
-  {
-  public:
-    SDLImGuiFrame(const common2::EmulatorOptions & options);
+    class SDLImGuiFrame : public SDLFrame
+    {
+    public:
+        SDLImGuiFrame(const common2::EmulatorOptions &options);
 
-    ~SDLImGuiFrame() override;
+        ~SDLImGuiFrame() override;
 
-    void VideoPresentScreen() override;
-    void ResetSpeed() override;
-    void Initialize(bool resetVideoState) override;
+        void VideoPresentScreen() override;
+        void ResetSpeed() override;
+        void Initialize(bool resetVideoState) override;
 
-    bool Quit() const override;
+        bool Quit() const override;
 
-  protected:
+    protected:
+        void ProcessSingleEvent(const SDL_Event &event, bool &quit) override;
+        void ProcessKeyDown(const SDL_KeyboardEvent &key, bool &quit) override;
+        void GetRelativeMousePosition(const SDL_MouseMotionEvent &motion, float &x, float &y) const override;
+        void ToggleMouseCursor() override;
 
-    void ProcessSingleEvent(const SDL_Event & event, bool & quit) override;
-    void ProcessKeyDown(const SDL_KeyboardEvent & key, bool &quit) override;
-    void GetRelativeMousePosition(const SDL_MouseMotionEvent & motion, float & x, float & y) const override;
-    void ToggleMouseCursor() override;
+    private:
+        void UpdateTexture();
+        void ClearBackground();
+        void DrawAppleVideo();
 
-  private:
+        size_t myPitch;
+        size_t myOffset;
+        size_t myBorderlessWidth;
+        size_t myBorderlessHeight;
+        float myOriginalAspectRatio;
 
-    void UpdateTexture();
-    void ClearBackground();
-    void DrawAppleVideo();
+        float myDeadTopZone; // for mouse position
+        bool myPresenting;   // VideoPresentScreen() is NOT REENTRANT
+        bool myShowMouseCursor;
 
-    size_t myPitch;
-    size_t myOffset;
-    size_t myBorderlessWidth;
-    size_t myBorderlessHeight;
-    float myOriginalAspectRatio;
+        SDL_GLContext myGLContext;
+        ImTextureID myTexture;
 
-    float myDeadTopZone; // for mouse position
-    bool myPresenting; // VideoPresentScreen() is NOT REENTRANT
-    bool myShowMouseCursor;
+        std::string myIniFileLocation;
+        ImFont *myDebuggerFont;
+        ImGuiSettings mySettings;
+    };
 
-    SDL_GLContext myGLContext;
-    ImTextureID myTexture;
-
-    std::string myIniFileLocation;
-    ImFont* myDebuggerFont;
-    ImGuiSettings mySettings;
-  };
-
-}
+} // namespace sa2
diff --git a/source/frontends/sdl/imgui/sdlmemory.cpp b/source/frontends/sdl/imgui/sdlmemory.cpp
index 910c6484f..33bcf2b0b 100644
--- a/source/frontends/sdl/imgui/sdlmemory.cpp
+++ b/source/frontends/sdl/imgui/sdlmemory.cpp
@@ -13,85 +13,88 @@
 namespace sa2
 {
 
-  void ImGuiMemory::drawSingleView(const size_t address)
-  {
-    const ImGuiTableFlags flags = ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingStretchProp | ImGuiTableFlags_BordersInnerV | ImGuiTableFlags_ScrollY;
-    if (ImGui::BeginTable("table1", 3, flags))
+    void ImGuiMemory::drawSingleView(const size_t address)
     {
-      ImGuiListClipper clipper;
-      clipper.Begin(myNumberOfRows);
-      while (clipper.Step())
-      {
-        for (int row = clipper.DisplayStart; row < clipper.DisplayEnd; row++)
+        const ImGuiTableFlags flags = ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingStretchProp |
+                                      ImGuiTableFlags_BordersInnerV | ImGuiTableFlags_ScrollY;
+        if (ImGui::BeginTable("table1", 3, flags))
         {
-          const size_t base = (address + row * myBytesPerRow) & _6502_MEM_END;
-          const std::string addr = StrFormat("%04X", (unsigned)base);
+            ImGuiListClipper clipper;
+            clipper.Begin(myNumberOfRows);
+            while (clipper.Step())
+            {
+                for (int row = clipper.DisplayStart; row < clipper.DisplayEnd; row++)
+                {
+                    const size_t base = (address + row * myBytesPerRow) & _6502_MEM_END;
+                    const std::string addr = StrFormat("%04X", (unsigned)base);
 
-          std::ostringstream hex;
-          hex << std::setfill('0') << std::hex << std::uppercase;
+                    std::ostringstream hex;
+                    hex << std::setfill('0') << std::hex << std::uppercase;
 
-          std::ostringstream text;
-          for (size_t k = 0; k < myBytesPerRow; ++k)
-          {
-            if (k)
-            {
-              hex << ' ';
-            }
-            const int value = static_cast<int>(mem[(base + k) & _6502_MEM_END]);
-            hex << std::setw(2) << value;
-            text << getPrintableChar(value);
-          }
+                    std::ostringstream text;
+                    for (size_t k = 0; k < myBytesPerRow; ++k)
+                    {
+                        if (k)
+                        {
+                            hex << ' ';
+                        }
+                        const int value = static_cast<int>(mem[(base + k) & _6502_MEM_END]);
+                        hex << std::setw(2) << value;
+                        text << getPrintableChar(value);
+                    }
 
-          ImGui::TableNextColumn();
-          ImGui::Selectable(addr.c_str(), false, ImGuiSelectableFlags_SpanAllColumns);
+                    ImGui::TableNextColumn();
+                    ImGui::Selectable(addr.c_str(), false, ImGuiSelectableFlags_SpanAllColumns);
 
-          ImGui::TableNextColumn();
-          ImGui::TextUnformatted(hex.str().c_str());
+                    ImGui::TableNextColumn();
+                    ImGui::TextUnformatted(hex.str().c_str());
 
-          ImGui::TableNextColumn();
-          ImGui::TextUnformatted(text.str().c_str());
+                    ImGui::TableNextColumn();
+                    ImGui::TextUnformatted(text.str().c_str());
+                }
+            }
+            ImGui::EndTable();
         }
-      }
-      ImGui::EndTable();
     }
-  }
 
-  void ImGuiMemory::draw()
-  {
-    if (ImGui::Begin("Memory viewer", &show))
+    void ImGuiMemory::draw()
     {
-      ImGui::PushItemWidth(ImGui::GetFontSize() * 5);
-      ImGui::InputScalar("address", ImGuiDataType_U16, &myNewAddress, nullptr, nullptr, "%04X", ImGuiInputTextFlags_CharsHexadecimal);
-      ImGui::PopItemWidth();
-      ImGui::SameLine();
-      if (ImGui::Button("Add"))
-      {
-        myMemoryAddresses.push_back(myNewAddress);
-        myNewAddress = (myNewAddress + 0x0100) & _6502_MEM_END;
-      }
+        if (ImGui::Begin("Memory viewer", &show))
+        {
+            ImGui::PushItemWidth(ImGui::GetFontSize() * 5);
+            ImGui::InputScalar(
+                "address", ImGuiDataType_U16, &myNewAddress, nullptr, nullptr, "%04X",
+                ImGuiInputTextFlags_CharsHexadecimal);
+            ImGui::PopItemWidth();
+            ImGui::SameLine();
+            if (ImGui::Button("Add"))
+            {
+                myMemoryAddresses.push_back(myNewAddress);
+                myNewAddress = (myNewAddress + 0x0100) & _6502_MEM_END;
+            }
 
-      ImGui::SliderInt("Width", &myBytesPerRow, 8, 32);
+            ImGui::SliderInt("Width", &myBytesPerRow, 8, 32);
 
-      auto it = myMemoryAddresses.begin();
-      int id = 0;
-      while (it != myMemoryAddresses.end())
-      {
-        ImGui::PushID(++id);
-        ImGui::BeginChild("pippo", ImVec2(0, 200), ImGuiChildFlags_Border | ImGuiChildFlags_ResizeY);
-        if (ImGui::Button("Remove"))
-        {
-          it = myMemoryAddresses.erase(it);
-        }
-        else
-        {
-          drawSingleView(*it);
-          ++it;
+            auto it = myMemoryAddresses.begin();
+            int id = 0;
+            while (it != myMemoryAddresses.end())
+            {
+                ImGui::PushID(++id);
+                ImGui::BeginChild("pippo", ImVec2(0, 200), ImGuiChildFlags_Border | ImGuiChildFlags_ResizeY);
+                if (ImGui::Button("Remove"))
+                {
+                    it = myMemoryAddresses.erase(it);
+                }
+                else
+                {
+                    drawSingleView(*it);
+                    ++it;
+                }
+                ImGui::EndChild();
+                ImGui::PopID();
+            }
         }
-        ImGui::EndChild();
-        ImGui::PopID();
-      }
+        ImGui::End();
     }
-    ImGui::End();
-  }
 
-}
+} // namespace sa2
diff --git a/source/frontends/sdl/imgui/sdlmemory.h b/source/frontends/sdl/imgui/sdlmemory.h
index 1c8a16db4..4744aaa1b 100644
--- a/source/frontends/sdl/imgui/sdlmemory.h
+++ b/source/frontends/sdl/imgui/sdlmemory.h
@@ -4,20 +4,20 @@
 namespace sa2
 {
 
-  class ImGuiMemory
-  {
-  public:
-    bool show = false;
+    class ImGuiMemory
+    {
+    public:
+        bool show = false;
 
-    void draw();
+        void draw();
 
-  private:
-    uint16_t myNewAddress = 0;
-    int myBytesPerRow = 16;
-    int myNumberOfRows = 32;
-    std::list<size_t> myMemoryAddresses;
+    private:
+        uint16_t myNewAddress = 0;
+        int myBytesPerRow = 16;
+        int myNumberOfRows = 32;
+        std::list<size_t> myMemoryAddresses;
 
-    void drawSingleView(const size_t address);
-  };
+        void drawSingleView(const size_t address);
+    };
 
-}
+} // namespace sa2
diff --git a/source/frontends/sdl/imgui/sdlsettings.cpp b/source/frontends/sdl/imgui/sdlsettings.cpp
index ddeae0744..5b28b4cdf 100644
--- a/source/frontends/sdl/imgui/sdlsettings.cpp
+++ b/source/frontends/sdl/imgui/sdlsettings.cpp
@@ -25,957 +25,988 @@
 namespace
 {
 
-  const char * ourShortcutHeaders[6] = {
-    "Key", "Normal", "Control", "Shift", "Both", "Alt",
-  };
-
-  const char * ourShortcutKeys[][6] = {
-    {"Left Alt", "Open Apple"},
-    {"Right Alt", "Solid Apple"},
-    {"Pause", "Pause"},
-    {"Insert", nullptr, "Copy", "Paste", "Screenshot"},
-    {"Scroll lock", "Full speed"},
-    {"F1", "Shortcuts", "Print audio info"},
-    {"F2", "Reset", "Ctrl-Reset", "Quit"},
-    {"F3", "Disks"},
-    {"F4", nullptr, nullptr, nullptr, nullptr, "Quit"},
-    {"F5", "Swap S6 disks"},
-    {"F6", "Fullscreen", "2x", nullptr, "50 scan lines"},
-    {"F8", "Settings"},
-    {"F9", "Cycle video type", "Toggle mouse cursor"},
-    {"F11", "Save snapshot"},
-    {"F12", "Load snapshot"},
-  };
-
-  const char * ourDebuggerShortcutKeys[][6] = {
-    {"Tab", "Cycle", nullptr, "Cycle"},
-    {"Space", "Step into", "Step over", "Step out"},
-    {"Down", nullptr, "Run to cursor"},
-    {"Right", nullptr, "Set PC"},
-    {"Left", "Show return"},
-  };
-
-  template <typename T>
-  void drawShortcutTable(const char * label, const T & keys)
-  {
-    ImGui::SeparatorText(label);
-    if (ImGui::BeginTable(label, std::size(ourShortcutHeaders), ImGuiTableFlags_RowBg))
+    const char *ourShortcutHeaders[6] = {
+        "Key", "Normal", "Control", "Shift", "Both", "Alt",
+    };
+
+    const char *ourShortcutKeys[][6] = {
+        {"Left Alt", "Open Apple"},
+        {"Right Alt", "Solid Apple"},
+        {"Pause", "Pause"},
+        {"Insert", nullptr, "Copy", "Paste", "Screenshot"},
+        {"Scroll lock", "Full speed"},
+        {"F1", "Shortcuts", "Print audio info"},
+        {"F2", "Reset", "Ctrl-Reset", "Quit"},
+        {"F3", "Disks"},
+        {"F4", nullptr, nullptr, nullptr, nullptr, "Quit"},
+        {"F5", "Swap S6 disks"},
+        {"F6", "Fullscreen", "2x", nullptr, "50 scan lines"},
+        {"F8", "Settings"},
+        {"F9", "Cycle video type", "Toggle mouse cursor"},
+        {"F11", "Save snapshot"},
+        {"F12", "Load snapshot"},
+    };
+
+    const char *ourDebuggerShortcutKeys[][6] = {
+        {"Tab", "Cycle", nullptr, "Cycle"},
+        {"Space", "Step into", "Step over", "Step out"},
+        {"Down", nullptr, "Run to cursor"},
+        {"Right", nullptr, "Set PC"},
+        {"Left", "Show return"},
+    };
+
+    template <typename T> void drawShortcutTable(const char *label, const T &keys)
     {
-      for (const auto & col : ourShortcutHeaders)
-      {
-        ImGui::TableSetupColumn(col);
-      }
-      ImGui::TableHeadersRow();
-
-      for (const auto & row : keys)
-      {
-        ImGui::TableNextRow();
-        for (const auto & col : row)
+        ImGui::SeparatorText(label);
+        if (ImGui::BeginTable(label, std::size(ourShortcutHeaders), ImGuiTableFlags_RowBg))
         {
-          ImGui::TableNextColumn();
-          if (col)
-          {
-            ImGui::TextUnformatted(col);
-          }
+            for (const auto &col : ourShortcutHeaders)
+            {
+                ImGui::TableSetupColumn(col);
+            }
+            ImGui::TableHeadersRow();
+
+            for (const auto &row : keys)
+            {
+                ImGui::TableNextRow();
+                for (const auto &col : row)
+                {
+                    ImGui::TableNextColumn();
+                    if (col)
+                    {
+                        ImGui::TextUnformatted(col);
+                    }
+                }
+            }
+            ImGui::EndTable();
         }
-      }
-      ImGui::EndTable();
     }
-  }
-
-  struct MemoryTab
-  {
-    void * basePtr;
-    size_t baseAddr;
-    size_t length;
-    std::string name;
-  };
-
-  void HelpMarker(const char* desc)
-  {
-    ImGui::TextDisabled("(?)");
-    if (ImGui::IsItemHovered())
+
+    struct MemoryTab
     {
-      ImGui::BeginTooltip();
-      ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);
-      ImGui::TextUnformatted(desc);
-      ImGui::PopTextWrapPos();
-      ImGui::EndTooltip();
+        void *basePtr;
+        size_t baseAddr;
+        size_t length;
+        std::string name;
+    };
+
+    void HelpMarker(const char *desc)
+    {
+        ImGui::TextDisabled("(?)");
+        if (ImGui::IsItemHovered())
+        {
+            ImGui::BeginTooltip();
+            ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);
+            ImGui::TextUnformatted(desc);
+            ImGui::PopTextWrapPos();
+            ImGui::EndTooltip();
+        }
     }
-  }
 
-  void setSpeedMultiplier(sa2::SDLFrame* frame, const uint32_t speedMultiplier)
-  {
-    g_dwSpeed = speedMultiplier;
-    SetCurrentCLK6502();
-    REGSAVE(TEXT(REGVALUE_EMULATION_SPEED), g_dwSpeed);
-    frame->ResetSpeed();
-  }
+    void setSpeedMultiplier(sa2::SDLFrame *frame, const uint32_t speedMultiplier)
+    {
+        g_dwSpeed = speedMultiplier;
+        SetCurrentCLK6502();
+        REGSAVE(TEXT(REGVALUE_EMULATION_SPEED), g_dwSpeed);
+        frame->ResetSpeed();
+    }
 
-}
+} // namespace
 
 namespace sa2
 {
-  ImGuiSettings::ImGuiSettings()
-    : mySaveFileDialog(ImGuiFileBrowserFlags_EnterNewFilename | ImGuiFileBrowserFlags_CreateNewDir)
-  {
-
-  }
-
-  void ImGuiSettings::showSettings(SDLFrame* frame)
-  {
-    if (ImGui::Begin("Settings", &myShowSettings))
+    ImGuiSettings::ImGuiSettings()
+        : mySaveFileDialog(ImGuiFileBrowserFlags_EnterNewFilename | ImGuiFileBrowserFlags_CreateNewDir)
     {
-      CardManager & cardManager = GetCardMgr();
-
-      if (ImGui::BeginTabBar("Settings"))
-      {
-        if (ImGui::BeginTabItem("General"))
-        {
-          ImGui::Checkbox("Apple Video windowed", &windowed);
-          ImGui::SameLine(); HelpMarker("Show Apple video in a separate window.");
-
-          ImGui::Checkbox("Preserve aspect ratio", &frame->getPreserveAspectRatio());
-
-          ImGui::Checkbox("Memory viewer", &myMemoryViewer.show);
-
-          ImGui::Checkbox("Memory editor", &myShowMemoryEditor);
-          ImGui::SameLine(); HelpMarker("Show Apple memory.");
-
-          if (ImGui::Checkbox("Debugger", &myDebugger.showDebugger))
-          {
-            myDebugger.syncDebuggerState(frame);
-          }
-          ImGui::SameLine(); HelpMarker("Show Apple CPU.");
-          ImGui::Separator();
-
-          ImGui::BeginDisabled();
-          ImGuiIO& io = ImGui::GetIO();
-          bool keyboardEnabled = !io.WantCaptureKeyboard;
-          ImGui::Checkbox("Apple keyboard enabled", &keyboardEnabled);
-          ImGui::EndDisabled();
-          ImGui::SameLine(); HelpMarker("Keys go to Apple ][.");
-          ImGui::Separator();
-
-          const std::string& snapshotPathname = Snapshot_GetPathname();
-          if (ImGui::Button(snapshotPathname.c_str()))
-          {
-            openFileDialog(mySaveFileDialog, snapshotPathname);
-          }
-
-          mySaveFileDialog.Display();
-          if (mySaveFileDialog.HasSelected())
-          {
-              Snapshot_SetFilename(mySaveFileDialog.GetSelected().string());
-              RegSaveString(TEXT(REG_CONFIG), TEXT(REGVALUE_SAVESTATE_FILENAME), 1, Snapshot_GetPathname());
-              mySaveFileDialog.ClearSelected();
-          }
-
-          ImGui::SameLine();
-          if (ImGui::Button("Save F11"))
-          {
-            frame->SaveSnapshot();
-          }
-          ImGui::SameLine();
-          if (ImGui::Button("Load F12"))
-          {
-            frame->LoadSnapshot();
-          }
-          ImGui::Separator();
-
-          if (frame->HardwareChanged())
-          {
-            ImGui::PushStyleColor(ImGuiCol_Button, (ImVec4)ImColor(180, 0, 0));
-          }
-          else
-          {
-            ImGui::PushStyleColor(ImGuiCol_Button, (ImVec4)ImColor(0, 180, 0));
-          }
-          if (ImGui::Button("Restart"))
-          {
-            frame->Restart();
-          }
-          ImGui::PopStyleColor(1);
-
-          ImGui::SameLine();
-          if (ImGui::Button("ResetMachineState"))
-          {
-            frame->FrameResetMachineState();
-          }
-
-          ImGui::SameLine();
-          if (ImGui::Button("CtrlReset"))
-          {
-            CtrlReset();
-          }
-
-          ImGui::EndTabItem();
-        }
+    }
 
-        if (ImGui::BeginTabItem("Speed"))
+    void ImGuiSettings::showSettings(SDLFrame *frame)
+    {
+        if (ImGui::Begin("Settings", &myShowSettings))
         {
-          ImGui::BeginDisabled();
-          ImGui::Checkbox("Full speed", &g_bFullSpeed);
-          ImGui::EndDisabled();
-
-          ImGui::Checkbox("Auto boot", &frame->getAutoBoot());
-          if (ImGui::Button(getAppModeName(g_nAppMode).c_str()))
-          {
-            frame->TogglePaused();
-          }
-
-          ImGui::Separator();
-
-          int speedMultiplier = g_dwSpeed;
-          if (ImGui::SliderInt("Speed", &speedMultiplier, SPEED_MIN, SPEED_MAX))
-          {
-            setSpeedMultiplier(frame, speedMultiplier);
-          }
-
-          /*              */ if (ImGui::Button("0.5 MHz")) setSpeedMultiplier(frame, SPEED_MIN);
-          ImGui::SameLine(); if (ImGui::Button("1 MHz")) setSpeedMultiplier(frame, SPEED_NORMAL);
-          ImGui::SameLine(); if (ImGui::Button("2 MHz")) setSpeedMultiplier(frame, SPEED_NORMAL * 2);
-          ImGui::SameLine(); if (ImGui::Button("3 MHz")) setSpeedMultiplier(frame, SPEED_NORMAL * 3);
-          ImGui::SameLine(); if (ImGui::Button("MAX")) setSpeedMultiplier(frame, SPEED_MAX);
-
-          ImGui::Separator();
-
-          const common2::Speed::Stats stats = frame->getSpeed().getSpeedStats();
-          ImGui::LabelText("Clock",          "%15.2f Hz", stats.nominal);
-          ImGui::LabelText("Audio adjusted", "%12.0f    Hz", stats.audio);
-          ImGui::LabelText("Actual",         "%12.0f    Hz", stats.actual);
-          ImGui::LabelText("Feedback",       "%12.0f    Hz", stats.netFeedback);
-          if (ImGui::Button("Reset stats"))
-          {
-            frame->ResetSpeed();
-          }
-
-          ImGui::EndTabItem();
-        }
+            CardManager &cardManager = GetCardMgr();
 
-        if (ImGui::BeginTabItem("Hardware"))
-        {
-          ImGui::LabelText("Option", "Value");
-
-          comboIterator("Apple 2", GetApple2Type(), getAapple2Types(), [] (eApple2Type x) {
-            SetApple2Type(x);
-            REGSAVE(REGVALUE_APPLE2_TYPE, x);
-          });
-
-          ImGui::LabelText("CPU", "%s", getCPUName(GetMainCpu()).c_str());
-          ImGui::LabelText("Mode", "%s", getAppModeName(g_nAppMode).c_str());
-
-          ImGui::Separator();
-
-          ImGui::LabelText("Slot", "Card");
-          for (size_t slot = SLOT1; slot < NUM_SLOTS; ++slot)
-          {
-            const SS_CARDTYPE current = cardManager.QuerySlot(slot);
-            comboIterator(std::to_string(slot).c_str(), current, getCardsForSlot(slot), getCardNames(), [slot, &frame] (SS_CARDTYPE x) {
-              insertCard(slot, x, frame);
-            });
-          }
-
-          ImGui::Separator();
-
-          {
-            // Expansion
-            const SS_CARDTYPE expansion = GetCurrentExpansionMemType();
-            comboIterator("Expansion", expansion, getExpansionCards(), getCardNames(), [] (SS_CARDTYPE x) {
-              setExpansionCard(x);
-            });
-
-            int ramWorksMemorySize = GetRamWorksMemorySize();
-            if (ImGui::SliderInt("RamWorks size", &ramWorksMemorySize, 1, kMaxExMemoryBanks))
+            if (ImGui::BeginTabBar("Settings"))
             {
-              SetRamWorksMemorySize(ramWorksMemorySize);
-            }
-          }
-
-          ImGui::Separator();
-
-          comboIterator("Copy protection", GetCopyProtectionDongleType(), getDongleTypes(), [] (DONGLETYPE x) {
-            SetCopyProtectionDongleType(x);
-            RegSetConfigGameIOConnectorNewDongleType(GAME_IO_CONNECTOR, x);
-          });
-
-          const UINT uthernetSlot = SLOT3;
-
-          if (PCapBackend::tfe_is_npcap_loaded())
-          {
-            const std::string current_interface = PCapBackend::GetRegistryInterface(uthernetSlot);
-
-            if (ImGui::BeginCombo("pcap", current_interface.c_str()))
-            {
-              std::vector<std::string> ifaces;
-              if (PCapBackend::tfe_enumadapter_open())
-              {
-                std::string name;
-                std::string description;
+                if (ImGui::BeginTabItem("General"))
+                {
+                    ImGui::Checkbox("Apple Video windowed", &windowed);
+                    ImGui::SameLine();
+                    HelpMarker("Show Apple video in a separate window.");
+
+                    ImGui::Checkbox("Preserve aspect ratio", &frame->getPreserveAspectRatio());
+
+                    ImGui::Checkbox("Memory viewer", &myMemoryViewer.show);
+
+                    ImGui::Checkbox("Memory editor", &myShowMemoryEditor);
+                    ImGui::SameLine();
+                    HelpMarker("Show Apple memory.");
+
+                    if (ImGui::Checkbox("Debugger", &myDebugger.showDebugger))
+                    {
+                        myDebugger.syncDebuggerState(frame);
+                    }
+                    ImGui::SameLine();
+                    HelpMarker("Show Apple CPU.");
+                    ImGui::Separator();
+
+                    ImGui::BeginDisabled();
+                    ImGuiIO &io = ImGui::GetIO();
+                    bool keyboardEnabled = !io.WantCaptureKeyboard;
+                    ImGui::Checkbox("Apple keyboard enabled", &keyboardEnabled);
+                    ImGui::EndDisabled();
+                    ImGui::SameLine();
+                    HelpMarker("Keys go to Apple ][.");
+                    ImGui::Separator();
+
+                    const std::string &snapshotPathname = Snapshot_GetPathname();
+                    if (ImGui::Button(snapshotPathname.c_str()))
+                    {
+                        openFileDialog(mySaveFileDialog, snapshotPathname);
+                    }
+
+                    mySaveFileDialog.Display();
+                    if (mySaveFileDialog.HasSelected())
+                    {
+                        Snapshot_SetFilename(mySaveFileDialog.GetSelected().string());
+                        RegSaveString(TEXT(REG_CONFIG), TEXT(REGVALUE_SAVESTATE_FILENAME), 1, Snapshot_GetPathname());
+                        mySaveFileDialog.ClearSelected();
+                    }
+
+                    ImGui::SameLine();
+                    if (ImGui::Button("Save F11"))
+                    {
+                        frame->SaveSnapshot();
+                    }
+                    ImGui::SameLine();
+                    if (ImGui::Button("Load F12"))
+                    {
+                        frame->LoadSnapshot();
+                    }
+                    ImGui::Separator();
+
+                    if (frame->HardwareChanged())
+                    {
+                        ImGui::PushStyleColor(ImGuiCol_Button, (ImVec4)ImColor(180, 0, 0));
+                    }
+                    else
+                    {
+                        ImGui::PushStyleColor(ImGuiCol_Button, (ImVec4)ImColor(0, 180, 0));
+                    }
+                    if (ImGui::Button("Restart"))
+                    {
+                        frame->Restart();
+                    }
+                    ImGui::PopStyleColor(1);
+
+                    ImGui::SameLine();
+                    if (ImGui::Button("ResetMachineState"))
+                    {
+                        frame->FrameResetMachineState();
+                    }
+
+                    ImGui::SameLine();
+                    if (ImGui::Button("CtrlReset"))
+                    {
+                        CtrlReset();
+                    }
+
+                    ImGui::EndTabItem();
+                }
 
-                while (PCapBackend::tfe_enumadapter(name, description))
+                if (ImGui::BeginTabItem("Speed"))
                 {
-                  ifaces.push_back(name);
+                    ImGui::BeginDisabled();
+                    ImGui::Checkbox("Full speed", &g_bFullSpeed);
+                    ImGui::EndDisabled();
+
+                    ImGui::Checkbox("Auto boot", &frame->getAutoBoot());
+                    if (ImGui::Button(getAppModeName(g_nAppMode).c_str()))
+                    {
+                        frame->TogglePaused();
+                    }
+
+                    ImGui::Separator();
+
+                    int speedMultiplier = g_dwSpeed;
+                    if (ImGui::SliderInt("Speed", &speedMultiplier, SPEED_MIN, SPEED_MAX))
+                    {
+                        setSpeedMultiplier(frame, speedMultiplier);
+                    }
+
+                    /*              */ if (ImGui::Button("0.5 MHz"))
+                        setSpeedMultiplier(frame, SPEED_MIN);
+                    ImGui::SameLine();
+                    if (ImGui::Button("1 MHz"))
+                        setSpeedMultiplier(frame, SPEED_NORMAL);
+                    ImGui::SameLine();
+                    if (ImGui::Button("2 MHz"))
+                        setSpeedMultiplier(frame, SPEED_NORMAL * 2);
+                    ImGui::SameLine();
+                    if (ImGui::Button("3 MHz"))
+                        setSpeedMultiplier(frame, SPEED_NORMAL * 3);
+                    ImGui::SameLine();
+                    if (ImGui::Button("MAX"))
+                        setSpeedMultiplier(frame, SPEED_MAX);
+
+                    ImGui::Separator();
+
+                    const common2::Speed::Stats stats = frame->getSpeed().getSpeedStats();
+                    ImGui::LabelText("Clock", "%15.2f Hz", stats.nominal);
+                    ImGui::LabelText("Audio adjusted", "%12.0f    Hz", stats.audio);
+                    ImGui::LabelText("Actual", "%12.0f    Hz", stats.actual);
+                    ImGui::LabelText("Feedback", "%12.0f    Hz", stats.netFeedback);
+                    if (ImGui::Button("Reset stats"))
+                    {
+                        frame->ResetSpeed();
+                    }
+
+                    ImGui::EndTabItem();
                 }
-                PCapBackend::tfe_enumadapter_close();
 
-                for (const auto & iface : ifaces)
+                if (ImGui::BeginTabItem("Hardware"))
                 {
-                  const bool isSelected = iface == current_interface;
-                  if (ImGui::Selectable(iface.c_str(), isSelected))
-                  {
-                    // the following line interacts with tfe_enumadapter, so we must run it outside the above loop
-                    PCapBackend::SetRegistryInterface(uthernetSlot, iface);
-                  }
-                  if (isSelected)
-                  {
-                    ImGui::SetItemDefaultFocus();
-                  }
+                    ImGui::LabelText("Option", "Value");
+
+                    comboIterator(
+                        "Apple 2", GetApple2Type(), getAapple2Types(),
+                        [](eApple2Type x)
+                        {
+                            SetApple2Type(x);
+                            REGSAVE(REGVALUE_APPLE2_TYPE, x);
+                        });
+
+                    ImGui::LabelText("CPU", "%s", getCPUName(GetMainCpu()).c_str());
+                    ImGui::LabelText("Mode", "%s", getAppModeName(g_nAppMode).c_str());
+
+                    ImGui::Separator();
+
+                    ImGui::LabelText("Slot", "Card");
+                    for (size_t slot = SLOT1; slot < NUM_SLOTS; ++slot)
+                    {
+                        const SS_CARDTYPE current = cardManager.QuerySlot(slot);
+                        comboIterator(
+                            std::to_string(slot).c_str(), current, getCardsForSlot(slot), getCardNames(),
+                            [slot, &frame](SS_CARDTYPE x) { insertCard(slot, x, frame); });
+                    }
+
+                    ImGui::Separator();
+
+                    {
+                        // Expansion
+                        const SS_CARDTYPE expansion = GetCurrentExpansionMemType();
+                        comboIterator(
+                            "Expansion", expansion, getExpansionCards(), getCardNames(),
+                            [](SS_CARDTYPE x) { setExpansionCard(x); });
+
+                        int ramWorksMemorySize = GetRamWorksMemorySize();
+                        if (ImGui::SliderInt("RamWorks size", &ramWorksMemorySize, 1, kMaxExMemoryBanks))
+                        {
+                            SetRamWorksMemorySize(ramWorksMemorySize);
+                        }
+                    }
+
+                    ImGui::Separator();
+
+                    comboIterator(
+                        "Copy protection", GetCopyProtectionDongleType(), getDongleTypes(),
+                        [](DONGLETYPE x)
+                        {
+                            SetCopyProtectionDongleType(x);
+                            RegSetConfigGameIOConnectorNewDongleType(GAME_IO_CONNECTOR, x);
+                        });
+
+                    const UINT uthernetSlot = SLOT3;
+
+                    if (PCapBackend::tfe_is_npcap_loaded())
+                    {
+                        const std::string current_interface = PCapBackend::GetRegistryInterface(uthernetSlot);
+
+                        if (ImGui::BeginCombo("pcap", current_interface.c_str()))
+                        {
+                            std::vector<std::string> ifaces;
+                            if (PCapBackend::tfe_enumadapter_open())
+                            {
+                                std::string name;
+                                std::string description;
+
+                                while (PCapBackend::tfe_enumadapter(name, description))
+                                {
+                                    ifaces.push_back(name);
+                                }
+                                PCapBackend::tfe_enumadapter_close();
+
+                                for (const auto &iface : ifaces)
+                                {
+                                    const bool isSelected = iface == current_interface;
+                                    if (ImGui::Selectable(iface.c_str(), isSelected))
+                                    {
+                                        // the following line interacts with tfe_enumadapter, so we must run it outside
+                                        // the above loop
+                                        PCapBackend::SetRegistryInterface(uthernetSlot, iface);
+                                    }
+                                    if (isSelected)
+                                    {
+                                        ImGui::SetItemDefaultFocus();
+                                    }
+                                }
+                            }
+                            ImGui::EndCombo();
+                        }
+                    }
+
+                    bool virtualDNS = Uthernet2::GetRegistryVirtualDNS(uthernetSlot);
+                    if (ImGui::Checkbox("Virtual DNS", &virtualDNS))
+                    {
+                        Uthernet2::SetRegistryVirtualDNS(uthernetSlot, virtualDNS);
+                    }
+
+                    ImGui::EndTabItem();
                 }
-              }
-              ImGui::EndCombo();
-            }
-          }
 
-          bool virtualDNS = Uthernet2::GetRegistryVirtualDNS(uthernetSlot);
-          if (ImGui::Checkbox("Virtual DNS", &virtualDNS))
-          {
-            Uthernet2::SetRegistryVirtualDNS(uthernetSlot, virtualDNS);
-          }
+                const ImGuiTabItemFlags disksFlags = myShowDiskTab ? ImGuiTabItemFlags_SetSelected : 0;
+                myShowDiskTab = false; // only do it once
+                if (ImGui::BeginTabItem("Disks", nullptr, disksFlags))
+                {
+                    bool enhancedSpeed = cardManager.GetDisk2CardMgr().GetEnhanceDisk();
+                    if (ImGui::Checkbox("Enhanced speed", &enhancedSpeed))
+                    {
+                        cardManager.GetDisk2CardMgr().SetEnhanceDisk(enhancedSpeed);
+                        REGSAVE(TEXT(REGVALUE_ENHANCE_DISK_SPEED), (uint32_t)enhancedSpeed);
+                    }
+
+                    ImGui::Separator();
+
+                    size_t dragAndDropSlot;
+                    size_t dragAndDropDrive;
+                    frame->getDragDropSlotAndDrive(dragAndDropSlot, dragAndDropDrive);
+
+                    if (ImGui::BeginTable("Disk2", 13, ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingFixedFit))
+                    {
+                        ImGui::TableSetupColumn("Slot", ImGuiTableColumnFlags_WidthFixed);
+                        ImGui::TableSetupColumn("Drive", ImGuiTableColumnFlags_WidthFixed);
+                        ImGui::TableSetupColumn("Firmware", ImGuiTableColumnFlags_WidthFixed);
+                        ImGui::TableSetupColumn("Track", ImGuiTableColumnFlags_WidthFixed);
+                        ImGui::TableSetupColumn("Track", ImGuiTableColumnFlags_WidthFixed);
+                        ImGui::TableSetupColumn("Phase", ImGuiTableColumnFlags_WidthFixed);
+                        ImGui::TableSetupColumn("Status", ImGuiTableColumnFlags_WidthFixed);
+                        ImGui::TableSetupColumn("D&D", ImGuiTableColumnFlags_WidthFixed);
+                        ImGui::TableSetupColumn("Eject", ImGuiTableColumnFlags_WidthFixed);
+                        ImGui::TableSetupColumn("Swap", ImGuiTableColumnFlags_WidthFixed);
+                        ImGui::TableSetupColumn("Open", ImGuiTableColumnFlags_WidthFixed);
+                        ImGui::TableSetupColumn("Filename", ImGuiTableColumnFlags_WidthStretch);
+                        ImGui::TableHeadersRow();
+
+                        // only scan disk slots.
+                        for (int slot = SLOT5; slot < NUM_SLOTS; ++slot)
+                        {
+                            ImGui::PushID(slot);
+                            if (cardManager.QuerySlot(slot) == CT_Disk2)
+                            {
+                                Disk2InterfaceCard *card2 =
+                                    dynamic_cast<Disk2InterfaceCard *>(cardManager.GetObj(slot));
+
+                                const int currentDrive = card2->GetCurrentDrive();
+                                Disk_Status_e statuses[NUM_DRIVES] = {};
+                                card2->GetLightStatus(statuses + 0, statuses + 1);
+                                const UINT firmware = card2->GetCurrentFirmware();
+
+                                for (size_t drive = DRIVE_1; drive < NUM_DRIVES; ++drive)
+                                {
+                                    ImGui::PushID(drive);
+                                    ImGui::TableNextRow();
+                                    ImGui::TableNextColumn();
+                                    ImGui::Text("%d", slot);
+                                    ImGui::TableNextColumn();
+                                    ImGui::Text("%zu", drive + 1);
+                                    ImGui::TableNextColumn();
+                                    ImGui::Text("%d", firmware);
+                                    ImGui::TableNextColumn();
+                                    ImGui::Text("%d", card2->GetTrack(drive));
+                                    ImGui::TableNextColumn();
+                                    if (drive == currentDrive)
+                                    {
+                                        ImGui::TextUnformatted(card2->GetCurrentTrackString().c_str());
+                                    }
+                                    ImGui::TableNextColumn();
+                                    if (drive == currentDrive)
+                                    {
+                                        ImGui::TextUnformatted(card2->GetCurrentPhaseString().c_str());
+                                    }
+                                    ImGui::TableNextColumn();
+                                    ImGui::TextUnformatted(getDiskStatusName(statuses[drive]).c_str());
+
+                                    ImGui::TableNextColumn();
+                                    if (ImGui::RadioButton(
+                                            "##Sel", (dragAndDropSlot == slot) && (dragAndDropDrive == drive)))
+                                    {
+                                        frame->setDragDropSlotAndDrive(slot, drive);
+                                    }
+
+                                    ImGui::TableNextColumn();
+                                    if (ImGui::SmallButton("Eject"))
+                                    {
+                                        card2->EjectDisk(drive);
+                                    }
+
+                                    ImGui::TableNextColumn();
+                                    if (ImGui::SmallButton("Swap"))
+                                    {
+                                        card2->DriveSwap();
+                                    }
+
+                                    ImGui::TableNextColumn();
+                                    if (ImGui::SmallButton("Open"))
+                                    {
+                                        const std::string &diskName = card2->DiskGetFullPathName(drive);
+                                        openDiskFileDialog(myDiskFileDialog, diskName, slot, drive);
+                                    }
+
+                                    ImGui::TableNextColumn();
+                                    ImGui::TextUnformatted(card2->GetFullDiskFilename(drive).c_str());
+
+                                    ImGui::PopID();
+                                }
+                            }
+                            else if (cardManager.QuerySlot(slot) == CT_GenericHDD)
+                            {
+                                HarddiskInterfaceCard *pHarddiskCard =
+                                    dynamic_cast<HarddiskInterfaceCard *>(cardManager.GetObj(slot));
+                                Disk_Status_e disk1Status_;
+                                pHarddiskCard->GetLightStatus(&disk1Status_);
+                                for (size_t drive = HARDDISK_1; drive < NUM_HARDDISKS; ++drive)
+                                {
+                                    ImGui::PushID(drive);
+                                    ImGui::TableNextRow();
+                                    ImGui::TableNextColumn();
+                                    ImGui::Text("%d", slot);
+                                    ImGui::TableNextColumn();
+                                    ImGui::Text("%zu", drive + 1);
+                                    ImGui::TableNextColumn();
+                                    ImGui::TextUnformatted("HD");
+                                    ImGui::TableNextColumn();
+                                    ImGui::TableNextColumn();
+                                    ImGui::TableNextColumn();
+
+                                    ImGui::TableNextColumn();
+                                    ImGui::TextUnformatted(getDiskStatusName(disk1Status_).c_str());
+
+                                    ImGui::TableNextColumn();
+                                    if (ImGui::RadioButton(
+                                            "##Sel", (dragAndDropSlot == slot) && (dragAndDropDrive == drive)))
+                                    {
+                                        frame->setDragDropSlotAndDrive(slot, drive);
+                                    }
+
+                                    ImGui::TableNextColumn();
+                                    if (ImGui::SmallButton("Eject"))
+                                    {
+                                        pHarddiskCard->Unplug(drive);
+                                    }
+
+                                    ImGui::TableNextColumn();
+                                    if (ImGui::SmallButton("Swap"))
+                                    {
+                                        pHarddiskCard->ImageSwap();
+                                    }
+
+                                    ImGui::TableNextColumn();
+                                    if (ImGui::SmallButton("Open"))
+                                    {
+                                        const std::string &diskName = pHarddiskCard->HarddiskGetFullPathName(drive);
+                                        openDiskFileDialog(myDiskFileDialog, diskName, slot, drive);
+                                    }
+
+                                    ImGui::TableNextColumn();
+                                    ImGui::TextUnformatted(pHarddiskCard->GetFullName(drive).c_str());
+
+                                    ImGui::PopID();
+                                }
+                            }
+                            ImGui::PopID();
+                        }
+                        ImGui::EndTable();
+
+                        myDiskFileDialog.Display();
+                        if (myDiskFileDialog.HasSelected())
+                        {
+                            sa2::processFile(
+                                frame, myDiskFileDialog.GetSelected().string().c_str(), myOpenSlot, myOpenDrive);
+                            myDiskFileDialog.ClearSelected();
+                        }
+                    }
+                    ImGui::EndTabItem();
+                }
 
-          ImGui::EndTabItem();
-        }
+                if (ImGui::BeginTabItem("Printer"))
+                {
+                    if (cardManager.IsParallelPrinterCardInstalled())
+                    {
+                        ParallelPrinterCard *card = cardManager.GetParallelPrinterCard();
+                        ImGui::LabelText("Printer file", "%s", card->GetFilename().c_str());
+                        ImGui::SameLine();
+                        if (ImGui::Button("Reset"))
+                        {
+                            card->Reset(true);
+                        }
+                        ImGui::Separator();
+                        bool printerAppend = card->GetPrinterAppend();
+                        if (ImGui::Checkbox("Append", &printerAppend))
+                        {
+                            card->SetPrinterAppend(printerAppend);
+                        }
+
+                        bool filterUnprintable = card->GetFilterUnprintable();
+                        if (ImGui::Checkbox("Filter unprintable", &filterUnprintable))
+                        {
+                            card->SetFilterUnprintable(filterUnprintable);
+                        }
+
+                        bool convertEncoding = card->GetConvertEncoding();
+                        if (ImGui::Checkbox("Convert encoding", &convertEncoding))
+                        {
+                            card->SetConvertEncoding(convertEncoding);
+                        }
+                    }
+
+                    ImGui::EndTabItem();
+                }
 
-        const ImGuiTabItemFlags disksFlags = myShowDiskTab ? ImGuiTabItemFlags_SetSelected : 0;
-        myShowDiskTab = false;  // only do it once
-        if (ImGui::BeginTabItem("Disks", nullptr, disksFlags))
-        {
-          bool enhancedSpeed = cardManager.GetDisk2CardMgr().GetEnhanceDisk();
-          if (ImGui::Checkbox("Enhanced speed", &enhancedSpeed))
-          {
-            cardManager.GetDisk2CardMgr().SetEnhanceDisk(enhancedSpeed);
-            REGSAVE(TEXT(REGVALUE_ENHANCE_DISK_SPEED), (uint32_t)enhancedSpeed);
-          }
-
-          ImGui::Separator();
-
-          size_t dragAndDropSlot;
-          size_t dragAndDropDrive;
-          frame->getDragDropSlotAndDrive(dragAndDropSlot, dragAndDropDrive);
-
-          if (ImGui::BeginTable("Disk2", 13, ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingFixedFit))
-          {
-            ImGui::TableSetupColumn("Slot", ImGuiTableColumnFlags_WidthFixed);
-            ImGui::TableSetupColumn("Drive", ImGuiTableColumnFlags_WidthFixed);
-            ImGui::TableSetupColumn("Firmware", ImGuiTableColumnFlags_WidthFixed);
-            ImGui::TableSetupColumn("Track", ImGuiTableColumnFlags_WidthFixed);
-            ImGui::TableSetupColumn("Track", ImGuiTableColumnFlags_WidthFixed);
-            ImGui::TableSetupColumn("Phase", ImGuiTableColumnFlags_WidthFixed);
-            ImGui::TableSetupColumn("Status", ImGuiTableColumnFlags_WidthFixed);
-            ImGui::TableSetupColumn("D&D", ImGuiTableColumnFlags_WidthFixed);
-            ImGui::TableSetupColumn("Eject", ImGuiTableColumnFlags_WidthFixed);
-            ImGui::TableSetupColumn("Swap", ImGuiTableColumnFlags_WidthFixed);
-            ImGui::TableSetupColumn("Open", ImGuiTableColumnFlags_WidthFixed);
-            ImGui::TableSetupColumn("Filename", ImGuiTableColumnFlags_WidthStretch);
-            ImGui::TableHeadersRow();
+                if (ImGui::BeginTabItem("Audio"))
+                {
+                    const int volumeMax = GetPropertySheet().GetVolumeMax();
+                    mySpeakerVolume = volumeMax - SpkrGetVolume();
+                    if (ImGui::SliderInt("Speaker volume", &mySpeakerVolume, 0, volumeMax))
+                    {
+                        SpkrSetVolume(volumeMax - mySpeakerVolume, volumeMax);
+                        REGSAVE(TEXT(REGVALUE_SPKR_VOLUME), SpkrGetVolume());
+                    }
+
+                    MockingboardCardManager &mockingboard = cardManager.GetMockingboardCardMgr();
+
+                    myMockingboardVolume = volumeMax - mockingboard.GetVolume();
+                    if (ImGui::SliderInt("Mockingboard volume", &myMockingboardVolume, 0, volumeMax))
+                    {
+                        mockingboard.SetVolume(volumeMax - myMockingboardVolume, volumeMax);
+                        REGSAVE(TEXT(REGVALUE_MB_VOLUME), mockingboard.GetVolume());
+                    }
+
+                    ImGui::Separator();
+
+                    if (ImGui::BeginTable("Devices", 6, ImGuiTableFlags_RowBg))
+                    {
+                        myAudioInfo = getAudioInfo();
+                        ImGui::TableSetupColumn("Voice");
+                        ImGui::TableSetupColumn("Running");
+                        ImGui::TableSetupColumn("Channels");
+                        ImGui::TableSetupColumn("Volume");
+                        ImGui::TableSetupColumn("Buffer (ms)");
+                        ImGui::TableSetupColumn("Underruns");
+                        ImGui::TableHeadersRow();
+
+                        ImGui::BeginDisabled();
+                        for (SoundInfo &device : myAudioInfo)
+                        {
+                            ImGui::TableNextColumn();
+                            ImGui::TextUnformatted(device.voiceName.c_str());
+                            ImGui::TableNextColumn();
+                            ImGui::Checkbox("##Running", &device.running);
+                            ImGui::TableNextColumn();
+                            ImGui::Text("%d", device.channels);
+                            ImGui::TableNextColumn();
+                            int volume = device.volume * 100;
+                            ImGui::SliderInt("##Volume", &volume, 0, 100, "%3d");
+                            ImGui::TableNextColumn();
+                            float buffer = device.buffer * 1000;
+                            float size = device.size * 1000;
+                            ImGui::SliderFloat("##Buffer", &buffer, 0, size, "%4.0f");
+                            ImGui::TableNextColumn();
+                            ImGui::Text("%zu", device.numberOfUnderruns);
+                        }
+                        ImGui::EndDisabled();
+
+                        ImGui::EndTable();
+                    }
+
+                    if (ImGui::Button("Reset underruns"))
+                    {
+                        resetAudioUnderruns();
+                    }
+
+                    ImGui::EndTabItem();
+                }
 
-            // only scan disk slots.
-            for (int slot = SLOT5; slot < NUM_SLOTS; ++slot)
-            {
-              ImGui::PushID(slot);
-              if (cardManager.QuerySlot(slot) == CT_Disk2)
-              {
-                Disk2InterfaceCard * card2 = dynamic_cast<Disk2InterfaceCard*>(cardManager.GetObj(slot));
+                if (ImGui::BeginTabItem("Video"))
+                {
+                    Video &video = GetVideo();
+                    comboIterator(
+                        "Video mode", video.GetVideoType(), getVideoTypes(),
+                        [&video, &frame](VideoType_e x)
+                        {
+                            video.SetVideoType(x);
+                            frame->ApplyVideoModeChange();
+                        });
+
+                    ImVec4 color = colorrefToImVec4(video.GetMonochromeRGB());
+                    if (ImGui::ColorEdit3("Monochrome Color", (float *)&color, 0))
+                    {
+                        const COLORREF cr = imVec4ToColorref(color);
+                        video.SetMonochromeRGB(cr);
+                        frame->ApplyVideoModeChange();
+                    }
+
+                    bool scanLines = video.IsVideoStyle(VS_HALF_SCANLINES);
+                    if (ImGui::Checkbox("50% Scan lines", &scanLines))
+                    {
+                        setVideoStyle(video, VS_HALF_SCANLINES, scanLines);
+                        frame->ApplyVideoModeChange();
+                    }
+
+                    bool verticalBlend = video.IsVideoStyle(VS_COLOR_VERTICAL_BLEND);
+                    if (ImGui::Checkbox("Vertical blend", &verticalBlend))
+                    {
+                        setVideoStyle(video, VS_COLOR_VERTICAL_BLEND, verticalBlend);
+                        frame->ApplyVideoModeChange();
+                    }
+
+                    bool hertz50 = video.GetVideoRefreshRate() == VR_50HZ;
+                    if (ImGui::Checkbox("50Hz video", &hertz50))
+                    {
+                        video.SetVideoRefreshRate(hertz50 ? VR_50HZ : VR_60HZ);
+                        frame->ApplyVideoModeChange();
+                    }
+
+                    ImGui::EndTabItem();
+                }
 
-                const int currentDrive = card2->GetCurrentDrive();
-                Disk_Status_e statuses[NUM_DRIVES] = {};
-                card2->GetLightStatus(statuses + 0, statuses + 1);
-                const UINT firmware = card2->GetCurrentFirmware();
+                if (ImGui::BeginTabItem("Tape"))
+                {
+                    CassetteTape &tape = CassetteTape::instance();
+
+                    CassetteTape::TapeInfo info;
+                    tape.getTapeInfo(info);
+
+                    if (info.size)
+                    {
+                        const float remaining = float(info.size - (info.pos + 1)) / float(info.frequency);
+                        const float fraction = float(info.pos + 1) / float(info.size);
+                        char buf[32];
+                        sprintf(buf, "-%.1f s", remaining);
+                        const ImU32 color = info.bit ? IM_COL32(200, 0, 0, 100) : IM_COL32(0, 200, 0, 100);
+
+                        ImGui::PushStyleColor(ImGuiCol_PlotHistogram, color);
+                        ImGui::ProgressBar(fraction, ImVec2(-FLT_MIN, 0), buf);
+                        ImGui::PopStyleColor();
+
+                        ImGui::LabelText("Filename", "%s", info.filename.c_str());
+                        ImGui::LabelText("Frequency", "%d Hz", info.frequency);
+                        ImGui::LabelText("Auto Play", "%s", "ON");
+
+                        ImGui::Separator();
+
+                        if (ImGui::Button("Rewind"))
+                        {
+                            tape.rewind();
+                        }
+                        ImGui::SameLine();
+                        if (ImGui::Button("Eject"))
+                        {
+                            tape.eject();
+                        }
+                    }
+                    else
+                    {
+                        ImGui::TextUnformatted("Drop a .wav file.");
+                    }
+
+                    ImGui::EndTabItem();
+                }
 
-                for (size_t drive = DRIVE_1; drive < NUM_DRIVES; ++drive)
+#ifdef U2_USE_SLIRP
+                if (ImGui::BeginTabItem("Network"))
                 {
-                  ImGui::PushID(drive);
-                  ImGui::TableNextRow();
-                  ImGui::TableNextColumn();
-                  ImGui::Text("%d", slot);
-                  ImGui::TableNextColumn();
-                  ImGui::Text("%zu", drive + 1);
-                  ImGui::TableNextColumn();
-                  ImGui::Text("%d", firmware);
-                  ImGui::TableNextColumn();
-                  ImGui::Text("%d", card2->GetTrack(drive));
-                  ImGui::TableNextColumn();
-                  if (drive == currentDrive)
-                  {
-                    ImGui::TextUnformatted(card2->GetCurrentTrackString().c_str());
-                  }
-                  ImGui::TableNextColumn();
-                  if (drive == currentDrive)
-                  {
-                    ImGui::TextUnformatted(card2->GetCurrentPhaseString().c_str());
-                  }
-                  ImGui::TableNextColumn();
-                  ImGui::TextUnformatted(getDiskStatusName(statuses[drive]).c_str());
-
-                  ImGui::TableNextColumn();
-                  if (ImGui::RadioButton("##Sel", (dragAndDropSlot == slot) && (dragAndDropDrive == drive)))
-                  {
-                    frame->setDragDropSlotAndDrive(slot, drive);
-                  }
-
-                  ImGui::TableNextColumn();
-                  if (ImGui::SmallButton("Eject"))
-                  {
-                    card2->EjectDisk(drive);
-                  }
-
-                  ImGui::TableNextColumn();
-                  if (ImGui::SmallButton("Swap"))
-                  {
-                    card2->DriveSwap();
-                  }
-
-                  ImGui::TableNextColumn();
-                  if (ImGui::SmallButton("Open"))
-                  {
-                    const std::string & diskName = card2->DiskGetFullPathName(drive);
-                    openDiskFileDialog(myDiskFileDialog, diskName, slot, drive);
-                  }
-
-                  ImGui::TableNextColumn();
-                  ImGui::TextUnformatted(card2->GetFullDiskFilename(drive).c_str());
-
-                  ImGui::PopID();
+                    if (ImGui::BeginTabBar("Uthernet"))
+                    {
+                        for (size_t slot = SLOT1; slot < NUM_SLOTS; ++slot)
+                        {
+                            const SS_CARDTYPE card = cardManager.QuerySlot(slot);
+                            if (card == CT_Uthernet || card == CT_Uthernet2)
+                            {
+                                const std::string slotNumber = StrFormat("Slot %" SIZE_T_FMT, slot);
+                                if (ImGui::BeginTabItem(slotNumber.c_str()))
+                                {
+                                    ImGui::LabelText("Card", "%s", getCardName(card).c_str());
+                                    ImGui::Separator();
+                                    const NetworkCard &networkCard =
+                                        dynamic_cast<NetworkCard &>(cardManager.GetRef(slot));
+                                    const std::shared_ptr<NetworkBackend> &backend = networkCard.GetNetworkBackend();
+                                    const std::shared_ptr<SlirpBackend> slirp =
+                                        std::dynamic_pointer_cast<SlirpBackend>(backend);
+                                    if (slirp)
+                                    {
+                                        const std::string info = slirp->getNeighborInfo();
+                                        ImGui::TextUnformatted(info.c_str());
+                                    }
+                                    ImGui::EndTabItem();
+                                }
+                            }
+                        }
+
+                        ImGui::EndTabBar();
+                    }
+                    ImGui::EndTabItem();
                 }
-              }
-              else if (cardManager.QuerySlot(slot) == CT_GenericHDD)
-              {
-                HarddiskInterfaceCard* pHarddiskCard = dynamic_cast<HarddiskInterfaceCard*>(cardManager.GetObj(slot));
-                Disk_Status_e disk1Status_;
-                pHarddiskCard->GetLightStatus(&disk1Status_);
-                for (size_t drive = HARDDISK_1; drive < NUM_HARDDISKS; ++drive)
+#endif
+
+                if (ImGui::BeginTabItem("Registry"))
                 {
-                  ImGui::PushID(drive);
-                  ImGui::TableNextRow();
-                  ImGui::TableNextColumn();
-                  ImGui::Text("%d", slot);
-                  ImGui::TableNextColumn();
-                  ImGui::Text("%zu", drive + 1);
-                  ImGui::TableNextColumn();
-                  ImGui::TextUnformatted("HD");
-                  ImGui::TableNextColumn();
-                  ImGui::TableNextColumn();
-                  ImGui::TableNextColumn();
-
-                  ImGui::TableNextColumn();
-                  ImGui::TextUnformatted(getDiskStatusName(disk1Status_).c_str());
-
-                  ImGui::TableNextColumn();
-                  if (ImGui::RadioButton("##Sel", (dragAndDropSlot == slot) && (dragAndDropDrive == drive)))
-                  {
-                    frame->setDragDropSlotAndDrive(slot, drive);
-                  }
-
-                  ImGui::TableNextColumn();
-                  if (ImGui::SmallButton("Eject"))
-                  {
-                    pHarddiskCard->Unplug(drive);
-                  }
-
-                  ImGui::TableNextColumn();
-                  if (ImGui::SmallButton("Swap"))
-                  {
-                    pHarddiskCard->ImageSwap();
-                  }
-
-                  ImGui::TableNextColumn();
-                  if (ImGui::SmallButton("Open"))
-                  {
-                    const std::string & diskName = pHarddiskCard->HarddiskGetFullPathName(drive);
-                    openDiskFileDialog(myDiskFileDialog, diskName, slot, drive);
-                  }
-
-                  ImGui::TableNextColumn();
-                  ImGui::TextUnformatted(pHarddiskCard->GetFullName(drive).c_str());
-
-                  ImGui::PopID();
+                    if (ImGui::BeginTable("Registry", 2, ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingFixedFit))
+                    {
+                        ImGui::TableSetupColumn("Option", ImGuiTableColumnFlags_WidthFixed);
+                        ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
+                        ImGui::TableHeadersRow();
+
+                        ImGui::TableNextRow();
+                        ImGui::TableNextColumn();
+                        const bool open = ImGui::TreeNode("Registry");
+                        ImGui::TableNextColumn();
+                        sectableToClipboard(Registry::instance->getLocation());
+                        if (open)
+                        {
+                            const std::map<std::string, std::map<std::string, std::string>> values =
+                                Registry::instance->getAllValues();
+
+                            for (const auto &it1 : values)
+                            {
+                                ImGui::TableNextRow();
+                                ImGui::TableNextColumn();
+                                if (ImGui::TreeNodeEx(it1.first.c_str(), ImGuiTreeNodeFlags_SpanFullWidth))
+                                {
+                                    int id = 0;
+                                    for (const auto &it2 : it1.second)
+                                    {
+                                        ImGui::PushID(++id);
+                                        ImGui::TableNextRow();
+                                        ImGui::TableNextColumn();
+                                        ImGui::TreeNodeEx(
+                                            it2.first.c_str(), ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_Bullet |
+                                                                   ImGuiTreeNodeFlags_NoTreePushOnOpen |
+                                                                   ImGuiTreeNodeFlags_SpanFullWidth);
+                                        ImGui::TableNextColumn();
+                                        sectableToClipboard(it2.second);
+                                        ImGui::PopID();
+                                    }
+                                    ImGui::TreePop();
+                                }
+                            }
+                            ImGui::TreePop();
+                        }
+                        ImGui::EndTable();
+                    }
+                    ImGui::EndTabItem();
                 }
-              }
-              ImGui::PopID();
-            }
-            ImGui::EndTable();
 
-            myDiskFileDialog.Display();
-            if (myDiskFileDialog.HasSelected())
-            {
-              sa2::processFile(frame, myDiskFileDialog.GetSelected().string().c_str(), myOpenSlot, myOpenDrive);
-              myDiskFileDialog.ClearSelected();
+                ImGui::EndTabBar();
             }
-
-          }
-          ImGui::EndTabItem();
         }
+        ImGui::End();
+    }
 
-        if (ImGui::BeginTabItem("Printer"))
+    void ImGuiSettings::showAboutWindow()
+    {
+        if (ImGui::Begin("About", &myShowAbout, ImGuiWindowFlags_AlwaysAutoResize))
         {
-          if (cardManager.IsParallelPrinterCardInstalled())
-          {
-            ParallelPrinterCard* card = cardManager.GetParallelPrinterCard();
-            ImGui::LabelText("Printer file", "%s", card->GetFilename().c_str());
-            ImGui::SameLine();
-            if (ImGui::Button("Reset"))
-            {
-              card->Reset(true);
-            }
-            ImGui::Separator();
-            bool printerAppend = card->GetPrinterAppend();
-            if (ImGui::Checkbox("Append", &printerAppend))
-            {
-              card->SetPrinterAppend(printerAppend);
-            }
+            ImGui::TextUnformatted("sa2: Apple ][ emulator for Linux");
+            ImGui::Text("Based on AppleWin %s", getVersion().c_str());
 
-            bool filterUnprintable = card->GetFilterUnprintable();
-            if (ImGui::Checkbox("Filter unprintable", &filterUnprintable))
-            {
-              card->SetFilterUnprintable(filterUnprintable);
-            }
+            int nMajor, nMinor, nFixMajor, nFixMinor;
+            UnpackVersion(DEBUGGER_VERSION, nMajor, nMinor, nFixMajor, nFixMinor);
+            ImGui::Text("Debugger %d.%d.%d.%d", nMajor, nMinor, nFixMajor, nFixMinor);
 
-            bool convertEncoding = card->GetConvertEncoding();
-            if (ImGui::Checkbox("Convert encoding", &convertEncoding))
-            {
-              card->SetConvertEncoding(convertEncoding);
-            }
-          }
+            ImGui::Separator();
+            SDL_version sdl;
+            SDL_GetVersion(&sdl);
+            ImGui::Text("SDL version %d.%d.%d", sdl.major, sdl.minor, sdl.patch);
+            ImGui::Text("Dear ImGui %s", ImGui::GetVersion());
 
-          ImGui::EndTabItem();
+            ImGui::Separator();
+            const int glSwap = SDL_GL_GetSwapInterval();
+            ImGui::Text("GL Swap: %d", glSwap);
+            ImGuiIO &io = ImGui::GetIO();
+            ImGui::Text("FPS: %d", int(io.Framerate));
         }
 
-        if (ImGui::BeginTabItem("Audio"))
-        {
-          const int volumeMax = GetPropertySheet().GetVolumeMax();
-          mySpeakerVolume = volumeMax - SpkrGetVolume();
-          if (ImGui::SliderInt("Speaker volume", &mySpeakerVolume, 0, volumeMax))
-          {
-            SpkrSetVolume(volumeMax - mySpeakerVolume, volumeMax);
-            REGSAVE(TEXT(REGVALUE_SPKR_VOLUME), SpkrGetVolume());
-          }
-
-          MockingboardCardManager& mockingboard = cardManager.GetMockingboardCardMgr();
-
-          myMockingboardVolume = volumeMax - mockingboard.GetVolume();
-          if (ImGui::SliderInt("Mockingboard volume", &myMockingboardVolume, 0, volumeMax))
-          {
-            mockingboard.SetVolume(volumeMax - myMockingboardVolume, volumeMax);
-            REGSAVE(TEXT(REGVALUE_MB_VOLUME), mockingboard.GetVolume());
-          }
-
-          ImGui::Separator();
-
-          if (ImGui::BeginTable("Devices", 6, ImGuiTableFlags_RowBg))
-          {
-            myAudioInfo = getAudioInfo();
-            ImGui::TableSetupColumn("Voice");
-            ImGui::TableSetupColumn("Running");
-            ImGui::TableSetupColumn("Channels");
-            ImGui::TableSetupColumn("Volume");
-            ImGui::TableSetupColumn("Buffer (ms)");
-            ImGui::TableSetupColumn("Underruns");
-            ImGui::TableHeadersRow();
-
-            ImGui::BeginDisabled();
-            for (SoundInfo & device : myAudioInfo)
-            {
-              ImGui::TableNextColumn();
-              ImGui::TextUnformatted(device.voiceName.c_str());
-              ImGui::TableNextColumn();
-              ImGui::Checkbox("##Running", &device.running);
-              ImGui::TableNextColumn();
-              ImGui::Text("%d", device.channels);
-              ImGui::TableNextColumn();
-              int volume = device.volume * 100;
-              ImGui::SliderInt("##Volume", &volume, 0, 100, "%3d");
-              ImGui::TableNextColumn();
-              float buffer = device.buffer * 1000;
-              float size = device.size * 1000;
-              ImGui::SliderFloat("##Buffer", &buffer, 0, size, "%4.0f");
-              ImGui::TableNextColumn();
-              ImGui::Text("%zu", device.numberOfUnderruns);
-            }
-            ImGui::EndDisabled();
-
-            ImGui::EndTable();
-          }
+        ImGui::End();
+    }
 
-          if (ImGui::Button("Reset underruns"))
-          {
-            resetAudioUnderruns();
-          }
+    void ImGuiSettings::showShortcutWindow()
+    {
+        if (ImGui::Begin("Shortcuts", &myShowShortcuts))
+        {
+            drawShortcutTable("Emulator", ourShortcutKeys);
+            drawShortcutTable("Debugger", ourDebuggerShortcutKeys);
 
-          ImGui::EndTabItem();
+            ImGui::SeparatorText("Gamepad");
+            ImGui::TextUnformatted("Press the Gamepad BACK button twice to quit.");
         }
+        ImGui::End();
+    }
 
-        if (ImGui::BeginTabItem("Video"))
+    void ImGuiSettings::show(SDLFrame *frame, ImFont *debuggerFont)
+    {
+        if (myShowSettings)
         {
-          Video & video = GetVideo();
-          comboIterator("Video mode", video.GetVideoType(), getVideoTypes(), [&video, &frame] (VideoType_e x) {
-            video.SetVideoType(x);
-            frame->ApplyVideoModeChange();
-          });
-
-          ImVec4 color = colorrefToImVec4(video.GetMonochromeRGB());
-          if (ImGui::ColorEdit3("Monochrome Color", (float*)&color, 0))
-          {
-            const COLORREF cr = imVec4ToColorref(color);
-            video.SetMonochromeRGB(cr);
-            frame->ApplyVideoModeChange();
-          }
-
-          bool scanLines = video.IsVideoStyle(VS_HALF_SCANLINES);
-          if (ImGui::Checkbox("50% Scan lines", &scanLines))
-          {
-            setVideoStyle(video, VS_HALF_SCANLINES, scanLines);
-            frame->ApplyVideoModeChange();
-          }
-
-          bool verticalBlend = video.IsVideoStyle(VS_COLOR_VERTICAL_BLEND);
-          if (ImGui::Checkbox("Vertical blend", &verticalBlend))
-          {
-            setVideoStyle(video, VS_COLOR_VERTICAL_BLEND, verticalBlend);
-            frame->ApplyVideoModeChange();
-          }
-
-          bool hertz50 = video.GetVideoRefreshRate() == VR_50HZ;
-          if (ImGui::Checkbox("50Hz video", &hertz50))
-          {
-            video.SetVideoRefreshRate(hertz50 ? VR_50HZ : VR_60HZ);
-            frame->ApplyVideoModeChange();
-          }
-
-          ImGui::EndTabItem();
+            showSettings(frame);
         }
 
-        if (ImGui::BeginTabItem("Tape"))
+        if (myShowMemoryEditor)
         {
-          CassetteTape & tape = CassetteTape::instance();
-
-          CassetteTape::TapeInfo info;
-          tape.getTapeInfo(info);
-
-          if (info.size)
-          {
-            const float remaining = float(info.size - (info.pos + 1)) / float(info.frequency);
-            const float fraction = float(info.pos + 1) / float(info.size);
-            char buf[32];
-            sprintf(buf, "-%.1f s", remaining);
-            const ImU32 color = info.bit ? IM_COL32(200, 0, 0, 100) : IM_COL32(0, 200, 0, 100);
-
-            ImGui::PushStyleColor(ImGuiCol_PlotHistogram, color);
-            ImGui::ProgressBar(fraction, ImVec2(-FLT_MIN, 0), buf);
-            ImGui::PopStyleColor();
-
-            ImGui::LabelText("Filename", "%s", info.filename.c_str());
-            ImGui::LabelText("Frequency", "%d Hz", info.frequency);
-            ImGui::LabelText("Auto Play", "%s", "ON");
-
-            ImGui::Separator();
+            showMemoryEditor();
+        }
 
-            if (ImGui::Button("Rewind"))
+        if (myMemoryViewer.show || myDebugger.showDebugger)
+        {
+            ImGui::PushFont(debuggerFont);
+            if (myMemoryViewer.show)
             {
-              tape.rewind();
+                myMemoryViewer.draw();
             }
-            ImGui::SameLine();
-            if (ImGui::Button("Eject"))
+            if (myDebugger.showDebugger)
             {
-              tape.eject();
+                myDebugger.drawDebugger(frame);
             }
-          }
-          else
-          {
-            ImGui::TextUnformatted("Drop a .wav file.");
-          }
-
-          ImGui::EndTabItem();
+            ImGui::PopFont();
         }
 
-#ifdef U2_USE_SLIRP
-        if (ImGui::BeginTabItem("Network"))
+        if (myShowAbout)
         {
-          if (ImGui::BeginTabBar("Uthernet"))
-          {
-            for (size_t slot = SLOT1; slot < NUM_SLOTS; ++slot)
-            {
-              const SS_CARDTYPE card = cardManager.QuerySlot(slot);
-              if (card == CT_Uthernet || card == CT_Uthernet2)
-              {
-                const std::string slotNumber = StrFormat("Slot %" SIZE_T_FMT, slot);
-                if (ImGui::BeginTabItem(slotNumber.c_str()))
-                {
-                  ImGui::LabelText("Card", "%s", getCardName(card).c_str());
-                  ImGui::Separator();
-                  const NetworkCard & networkCard = dynamic_cast<NetworkCard &>(cardManager.GetRef(slot));
-                  const std::shared_ptr<NetworkBackend> & backend = networkCard.GetNetworkBackend();
-                  const std::shared_ptr<SlirpBackend> slirp = std::dynamic_pointer_cast<SlirpBackend>(backend);
-                  if (slirp)
-                  {
-                    const std::string info = slirp->getNeighborInfo();
-                    ImGui::TextUnformatted(info.c_str());
-                  }
-                  ImGui::EndTabItem();
-                }
-              }
-            }
+            showAboutWindow();
+        }
 
-            ImGui::EndTabBar();
-          }
-          ImGui::EndTabItem();
+        if (myShowShortcuts)
+        {
+            showShortcutWindow();
         }
-#endif
 
-        if (ImGui::BeginTabItem("Registry"))
+        if (myShowDemo)
         {
-          if (ImGui::BeginTable("Registry", 2, ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingFixedFit))
-          {
-            ImGui::TableSetupColumn("Option", ImGuiTableColumnFlags_WidthFixed);
-            ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
-            ImGui::TableHeadersRow();
+            ImGui::ShowDemoWindow(&myShowDemo);
+        }
+    }
 
-            ImGui::TableNextRow();
-            ImGui::TableNextColumn();
-            const bool open = ImGui::TreeNode("Registry");
-            ImGui::TableNextColumn();
-            sectableToClipboard(Registry::instance->getLocation());
-            if (open)
-            {
-              const std::map<std::string, std::map<std::string, std::string>> values = Registry::instance->getAllValues();
+    float ImGuiSettings::drawMenuBar(SDLFrame *frame, const bool enabled)
+    {
+        float menuBarHeight;
 
-              for (const auto & it1 : values)
-              {
-                ImGui::TableNextRow();
-                ImGui::TableNextColumn();
-                if (ImGui::TreeNodeEx(it1.first.c_str(), ImGuiTreeNodeFlags_SpanFullWidth))
+        if (enabled && ImGui::BeginMainMenuBar())
+        {
+            menuBarHeight = ImGui::GetWindowHeight();
+            if (ImGui::BeginMenu("System"))
+            {
+                ImGui::MenuItem("Settings", "F8", &myShowSettings);
+                ImGui::MenuItem("Memory viewer", nullptr, &myMemoryViewer.show);
+                ImGui::MenuItem("Memory editor", nullptr, &myShowMemoryEditor);
+                if (ImGui::MenuItem("Debugger", nullptr, &myDebugger.showDebugger))
                 {
-                  int id = 0;
-                  for (const auto & it2 : it1.second)
-                  {
-                    ImGui::PushID(++id);
-                    ImGui::TableNextRow();
-                    ImGui::TableNextColumn();
-                    ImGui::TreeNodeEx(it2.first.c_str(), ImGuiTreeNodeFlags_Leaf | ImGuiTreeNodeFlags_Bullet | ImGuiTreeNodeFlags_NoTreePushOnOpen | ImGuiTreeNodeFlags_SpanFullWidth);
-                    ImGui::TableNextColumn();
-                    sectableToClipboard(it2.second);
-                    ImGui::PopID();
-                  }
-                  ImGui::TreePop();
+                    myDebugger.syncDebuggerState(frame);
                 }
-              }
-              ImGui::TreePop();
+                ImGui::Separator();
+                ImGui::MenuItem("Quit", "Alt-F4", &quit);
+                ImGui::EndMenu();
             }
-            ImGui::EndTable();
-          }
-          ImGui::EndTabItem();
-        }
 
-        ImGui::EndTabBar();
-      }
+            if (ImGui::BeginMenu("Help"))
+            {
+                ImGui::MenuItem("Shortcuts", "F1", &myShowShortcuts);
+                ImGui::MenuItem("ImGui Demo", nullptr, &myShowDemo);
+                ImGui::Separator();
+                ImGui::MenuItem("About", nullptr, &myShowAbout);
+                ImGui::EndMenu();
+            }
+            ImGui::EndMainMenuBar();
+        }
+        else
+        {
+            menuBarHeight = 0.0;
+        }
 
+        return menuBarHeight;
     }
-    ImGui::End();
-  }
 
-  void ImGuiSettings::showAboutWindow()
-  {
-    if (ImGui::Begin("About", &myShowAbout, ImGuiWindowFlags_AlwaysAutoResize))
+    void ImGuiSettings::showMemoryEditor()
     {
-      ImGui::TextUnformatted("sa2: Apple ][ emulator for Linux");
-      ImGui::Text("Based on AppleWin %s", getVersion().c_str());
-
-      int nMajor, nMinor, nFixMajor, nFixMinor;
-      UnpackVersion(DEBUGGER_VERSION, nMajor, nMinor, nFixMajor, nFixMinor);
-      ImGui::Text("Debugger %d.%d.%d.%d", nMajor, nMinor, nFixMajor, nFixMinor);
-
-      ImGui::Separator();
-      SDL_version sdl;
-      SDL_GetVersion(&sdl);
-      ImGui::Text("SDL version %d.%d.%d", sdl.major, sdl.minor, sdl.patch);
-      ImGui::Text("Dear ImGui %s", ImGui::GetVersion());
-
-      ImGui::Separator();
-      const int glSwap = SDL_GL_GetSwapInterval();
-      ImGui::Text("GL Swap: %d", glSwap);
-      ImGuiIO& io = ImGui::GetIO();
-      ImGui::Text("FPS: %d", int(io.Framerate));
-    }
+        if (ImGui::Begin("Memory editor", &myShowMemoryEditor))
+        {
+            if (ImGui::BeginTabBar("Memory"))
+            {
+                std::vector<MemoryTab> banks;
 
-    ImGui::End();
-  }
+                banks.push_back({mem, 0, _6502_MEM_LEN, "Memory"});
+                banks.push_back({MemGetCxRomPeripheral(), _6502_IO_BEGIN, 4 * 1024, "Cx ROM"});
 
-  void ImGuiSettings::showShortcutWindow()
-  {
-    if (ImGui::Begin("Shortcuts", &myShowShortcuts))
-    {
-      drawShortcutTable("Emulator", ourShortcutKeys);
-      drawShortcutTable("Debugger", ourDebuggerShortcutKeys);
+                size_t i = 0;
+                void *bank;
+                while ((bank = MemGetBankPtr(i, true)))
+                {
+                    const std::string name = "Bank " + std::to_string(i);
+                    banks.push_back({bank, 0, _6502_MEM_LEN, name});
+                    ++i;
+                }
 
-      ImGui::SeparatorText("Gamepad");
-      ImGui::TextUnformatted("Press the Gamepad BACK button twice to quit.");
-    }
-    ImGui::End();
-  }
+                myMemoryEditors.resize(banks.size());
 
-  void ImGuiSettings::show(SDLFrame * frame, ImFont * debuggerFont)
-  {
-    if (myShowSettings)
-    {
-      showSettings(frame);
-    }
+                for (i = 0; i < banks.size(); ++i)
+                {
+                    if (ImGui::BeginTabItem(banks[i].name.c_str()))
+                    {
+                        myMemoryEditors[i].DrawContents(banks[i].basePtr, banks[i].length, banks[i].baseAddr);
+                        ImGui::EndTabItem();
+                    }
+                }
 
-    if (myShowMemoryEditor)
-    {
-      showMemoryEditor();
+                ImGui::EndTabBar();
+            }
+        }
+        ImGui::End();
     }
 
-    if (myMemoryViewer.show || myDebugger.showDebugger)
+    void ImGuiSettings::resetDebuggerCycles()
     {
-      ImGui::PushFont(debuggerFont);
-      if (myMemoryViewer.show)
-      {
-        myMemoryViewer.draw();
-      }
-      if (myDebugger.showDebugger)
-      {
-        myDebugger.drawDebugger(frame);
-      }
-      ImGui::PopFont();
+        myDebugger.resetDebuggerCycles();
     }
 
-    if (myShowAbout)
+    void ImGuiSettings::openFileDialog(ImGui::FileBrowser &browser, const std::string &filename)
     {
-      showAboutWindow();
+        if (!filename.empty())
+        {
+            const std::filesystem::path path(filename);
+            browser.SetPwd(path.parent_path());
+        }
+        browser.Open();
     }
 
-    if (myShowShortcuts)
+    void ImGuiSettings::openDiskFileDialog(
+        ImGui::FileBrowser &browser, const std::string &diskName, const size_t slot, const size_t drive)
     {
-      showShortcutWindow();
+        openFileDialog(browser, diskName);
+        myOpenSlot = slot;
+        myOpenDrive = drive;
     }
 
-    if (myShowDemo)
+    void ImGuiSettings::showDiskTab()
     {
-      ImGui::ShowDemoWindow(&myShowDemo);
+        myShowSettings = true;
+        myShowDiskTab = true;
     }
-  }
 
-  float ImGuiSettings::drawMenuBar(SDLFrame* frame, const bool enabled)
-  {
-    float menuBarHeight;
-
-    if (enabled && ImGui::BeginMainMenuBar())
-    {
-      menuBarHeight = ImGui::GetWindowHeight();
-      if (ImGui::BeginMenu("System"))
-      {
-        ImGui::MenuItem("Settings", "F8", &myShowSettings);
-        ImGui::MenuItem("Memory viewer", nullptr, &myMemoryViewer.show);
-        ImGui::MenuItem("Memory editor", nullptr, &myShowMemoryEditor);
-        if (ImGui::MenuItem("Debugger", nullptr, &myDebugger.showDebugger))
-        {
-          myDebugger.syncDebuggerState(frame);
-        }
-        ImGui::Separator();
-        ImGui::MenuItem("Quit", "Alt-F4", &quit);
-        ImGui::EndMenu();
-      }
-
-      if (ImGui::BeginMenu("Help"))
-      {
-        ImGui::MenuItem("Shortcuts", "F1", &myShowShortcuts);
-        ImGui::MenuItem("ImGui Demo", nullptr, &myShowDemo);
-        ImGui::Separator();
-        ImGui::MenuItem("About", nullptr, &myShowAbout);
-        ImGui::EndMenu();
-      }
-      ImGui::EndMainMenuBar();
-    }
-    else
+    void ImGuiSettings::toggleSettings()
     {
-      menuBarHeight = 0.0;
+        myShowSettings = !myShowSettings;
     }
 
-    return menuBarHeight;
-  }
-
-  void ImGuiSettings::showMemoryEditor()
-  {
-    if (ImGui::Begin("Memory editor", &myShowMemoryEditor))
+    void ImGuiSettings::toggleShortcuts()
     {
-      if (ImGui::BeginTabBar("Memory"))
-      {
-        std::vector<MemoryTab> banks;
-
-        banks.push_back({mem, 0, _6502_MEM_LEN, "Memory"});
-        banks.push_back({MemGetCxRomPeripheral(), _6502_IO_BEGIN, 4 * 1024, "Cx ROM"});
-
-        size_t i = 0;
-        void * bank;
-        while ((bank = MemGetBankPtr(i, true)))
-        {
-          const std::string name = "Bank " + std::to_string(i);
-          banks.push_back({bank, 0, _6502_MEM_LEN, name});
-          ++i;
-        }
-
-        myMemoryEditors.resize(banks.size());
-
-        for (i = 0; i < banks.size(); ++i)
-        {
-          if (ImGui::BeginTabItem(banks[i].name.c_str()))
-          {
-            myMemoryEditors[i].DrawContents(banks[i].basePtr, banks[i].length, banks[i].baseAddr);
-            ImGui::EndTabItem();
-          }
-        }
-
-        ImGui::EndTabBar();
-      }
+        myShowShortcuts = !myShowShortcuts;
     }
-    ImGui::End();
-  }
-
-  void ImGuiSettings::resetDebuggerCycles()
-  {
-    myDebugger.resetDebuggerCycles();
-  }
 
-  void ImGuiSettings::openFileDialog(ImGui::FileBrowser & browser, const std::string & filename)
-  {
-    if (!filename.empty())
-    {
-      const std::filesystem::path path(filename);
-      browser.SetPwd(path.parent_path());
-    }
-    browser.Open();
-  }
-
-  void ImGuiSettings::openDiskFileDialog(ImGui::FileBrowser & browser, const std::string & diskName, const size_t slot, const size_t drive)
-  {
-    openFileDialog(browser, diskName);
-    myOpenSlot = slot;
-    myOpenDrive = drive;
-  }
-
-  void ImGuiSettings::showDiskTab()
-  {
-    myShowSettings = true;
-    myShowDiskTab = true;
-  }
-
-  void ImGuiSettings::toggleSettings()
-  {
-    myShowSettings = !myShowSettings;
-  }
-
-  void ImGuiSettings::toggleShortcuts()
-  {
-    myShowShortcuts = !myShowShortcuts;
-  }
-
-}
+} // namespace sa2
diff --git a/source/frontends/sdl/imgui/sdlsettings.h b/source/frontends/sdl/imgui/sdlsettings.h
index a6ababf1d..a2a045942 100644
--- a/source/frontends/sdl/imgui/sdlsettings.h
+++ b/source/frontends/sdl/imgui/sdlsettings.h
@@ -9,52 +9,53 @@
 namespace sa2
 {
 
-  class SDLFrame;
-
-  class ImGuiSettings
-  {
-  public:
-    ImGuiSettings();
-
-    void show(SDLFrame* frame, ImFont * debuggerFont);
-    float drawMenuBar(SDLFrame* frame, const bool enabled);
-    void resetDebuggerCycles();
-    void showDiskTab();
-    void toggleSettings();
-    void toggleShortcuts();
-
-    bool windowed = false;
-    bool quit = false;
-
-  private:
-    bool myShowDemo = false;
-    bool myShowSettings = false;
-    bool myShowMemoryEditor = false;
-    bool myShowAbout = false;
-    bool myShowShortcuts = false;
-    bool myShowDiskTab = false;
-
-    int mySpeakerVolume;
-    int myMockingboardVolume;
-
-    size_t myOpenSlot = 0;
-    size_t myOpenDrive = 0;
-
-    ImGuiDebugger myDebugger;
-    ImGuiMemory myMemoryViewer;
-    ImGui::FileBrowser myDiskFileDialog;
-    ImGui::FileBrowser mySaveFileDialog;
-
-    std::vector<MemoryEditor> myMemoryEditors;
-
-    std::vector<SoundInfo> myAudioInfo;
-
-    void showSettings(SDLFrame* frame);
-    void showMemoryEditor();
-    void showAboutWindow();
-    void showShortcutWindow();
-    void openFileDialog(ImGui::FileBrowser & browser, const std::string & filename);
-    void openDiskFileDialog(ImGui::FileBrowser & browser, const std::string & diskName, const size_t slot, const size_t drive);
-  };
-
-}
+    class SDLFrame;
+
+    class ImGuiSettings
+    {
+    public:
+        ImGuiSettings();
+
+        void show(SDLFrame *frame, ImFont *debuggerFont);
+        float drawMenuBar(SDLFrame *frame, const bool enabled);
+        void resetDebuggerCycles();
+        void showDiskTab();
+        void toggleSettings();
+        void toggleShortcuts();
+
+        bool windowed = false;
+        bool quit = false;
+
+    private:
+        bool myShowDemo = false;
+        bool myShowSettings = false;
+        bool myShowMemoryEditor = false;
+        bool myShowAbout = false;
+        bool myShowShortcuts = false;
+        bool myShowDiskTab = false;
+
+        int mySpeakerVolume;
+        int myMockingboardVolume;
+
+        size_t myOpenSlot = 0;
+        size_t myOpenDrive = 0;
+
+        ImGuiDebugger myDebugger;
+        ImGuiMemory myMemoryViewer;
+        ImGui::FileBrowser myDiskFileDialog;
+        ImGui::FileBrowser mySaveFileDialog;
+
+        std::vector<MemoryEditor> myMemoryEditors;
+
+        std::vector<SoundInfo> myAudioInfo;
+
+        void showSettings(SDLFrame *frame);
+        void showMemoryEditor();
+        void showAboutWindow();
+        void showShortcutWindow();
+        void openFileDialog(ImGui::FileBrowser &browser, const std::string &filename);
+        void openDiskFileDialog(
+            ImGui::FileBrowser &browser, const std::string &diskName, const size_t slot, const size_t drive);
+    };
+
+} // namespace sa2
diff --git a/source/frontends/sdl/imgui/settingshelper.cpp b/source/frontends/sdl/imgui/settingshelper.cpp
index b3a7c1c9f..ad5a0b434 100644
--- a/source/frontends/sdl/imgui/settingshelper.cpp
+++ b/source/frontends/sdl/imgui/settingshelper.cpp
@@ -18,320 +18,312 @@ void CreateLanguageCard(void);
 
 namespace
 {
-  const std::map<SS_CARDTYPE, std::string> cards =
-    {
-     {CT_Empty, "Empty"},
-     {CT_Disk2, "Disk2"},
-     {CT_SSC, "SSC"},
-     {CT_MockingboardC, "MockingboardC"},
-     {CT_MegaAudio, "MegaAudio"},
-     {CT_SDMusic, "SDMusic"},
-     {CT_GenericPrinter, "GenericPrinter"},
-     {CT_GenericHDD, "GenericHDD"},
-     {CT_GenericClock, "GenericClock"},
-     {CT_MouseInterface, "MouseInterface"},
-     {CT_Z80, "Z80"},
-     {CT_Phasor, "Phasor"},
-     {CT_Echo, "Echo"},
-     {CT_SAM, "SAM"},
-     {CT_80Col, "80Col"},
-     {CT_Extended80Col, "Extended80Col"},
-     {CT_RamWorksIII, "RamWorksIII"},
-     {CT_Uthernet, "Uthernet"},
-     {CT_LanguageCard, "LanguageCard"},
-     {CT_LanguageCardIIe, "LanguageCardIIe"},
-     {CT_Saturn128K, "Saturn128K"},
-     {CT_FourPlay, "FourPlay"},
-     {CT_SNESMAX, "SNESMAX"},
-     {CT_VidHD, "VidHD"},
-     {CT_Uthernet2, "Uthernet2"},
+    const std::map<SS_CARDTYPE, std::string> cards = {
+        {CT_Empty, "Empty"},
+        {CT_Disk2, "Disk2"},
+        {CT_SSC, "SSC"},
+        {CT_MockingboardC, "MockingboardC"},
+        {CT_MegaAudio, "MegaAudio"},
+        {CT_SDMusic, "SDMusic"},
+        {CT_GenericPrinter, "GenericPrinter"},
+        {CT_GenericHDD, "GenericHDD"},
+        {CT_GenericClock, "GenericClock"},
+        {CT_MouseInterface, "MouseInterface"},
+        {CT_Z80, "Z80"},
+        {CT_Phasor, "Phasor"},
+        {CT_Echo, "Echo"},
+        {CT_SAM, "SAM"},
+        {CT_80Col, "80Col"},
+        {CT_Extended80Col, "Extended80Col"},
+        {CT_RamWorksIII, "RamWorksIII"},
+        {CT_Uthernet, "Uthernet"},
+        {CT_LanguageCard, "LanguageCard"},
+        {CT_LanguageCardIIe, "LanguageCardIIe"},
+        {CT_Saturn128K, "Saturn128K"},
+        {CT_FourPlay, "FourPlay"},
+        {CT_SNESMAX, "SNESMAX"},
+        {CT_VidHD, "VidHD"},
+        {CT_Uthernet2, "Uthernet2"},
     };
 
-  const std::map<eApple2Type, std::string> apple2Types =
-    {
-     {A2TYPE_APPLE2, "APPLE2"},
-     {A2TYPE_APPLE2PLUS, "APPLE2PLUS"},
-     {A2TYPE_APPLE2JPLUS, "APPLE2JPLUS"},
-     {A2TYPE_APPLE2E, "APPLE2E"},
-     {A2TYPE_APPLE2EENHANCED, "APPLE2EENHANCED"},
-     {A2TYPE_APPLE2C, "APPLE2C"},
-     {A2TYPE_PRAVETS8M, "PRAVETS8M"},
-     {A2TYPE_PRAVETS82, "PRAVETS82"},
-     {A2TYPE_BASE64A, "BASE64A"},
-     {A2TYPE_PRAVETS8A, "PRAVETS8A"},
-     {A2TYPE_TK30002E, "TK30002E"},
+    const std::map<eApple2Type, std::string> apple2Types = {
+        {A2TYPE_APPLE2, "APPLE2"},
+        {A2TYPE_APPLE2PLUS, "APPLE2PLUS"},
+        {A2TYPE_APPLE2JPLUS, "APPLE2JPLUS"},
+        {A2TYPE_APPLE2E, "APPLE2E"},
+        {A2TYPE_APPLE2EENHANCED, "APPLE2EENHANCED"},
+        {A2TYPE_APPLE2C, "APPLE2C"},
+        {A2TYPE_PRAVETS8M, "PRAVETS8M"},
+        {A2TYPE_PRAVETS82, "PRAVETS82"},
+        {A2TYPE_BASE64A, "BASE64A"},
+        {A2TYPE_PRAVETS8A, "PRAVETS8A"},
+        {A2TYPE_TK30002E, "TK30002E"},
     };
 
-  const std::map<eCpuType, std::string> cpuTypes =
-    {
-     {CPU_6502, "6502"},
-     {CPU_65C02, "65C02"},
-     {CPU_Z80, "Z80"},
+    const std::map<eCpuType, std::string> cpuTypes = {
+        {CPU_6502, "6502"},
+        {CPU_65C02, "65C02"},
+        {CPU_Z80, "Z80"},
     };
 
-  const std::map<AppMode_e, std::string> appModes =
-    {
-     {MODE_LOGO, "LOGO"},
-     {MODE_PAUSED, "PAUSED"},
-     {MODE_RUNNING, "RUNNING"},
-     {MODE_DEBUG, "DEBUG"},
-     {MODE_STEPPING, "STEPPING"},
-     {MODE_BENCHMARK, "BENCHMARCK"},
+    const std::map<AppMode_e, std::string> appModes = {
+        {MODE_LOGO, "LOGO"},   {MODE_PAUSED, "PAUSED"},     {MODE_RUNNING, "RUNNING"},
+        {MODE_DEBUG, "DEBUG"}, {MODE_STEPPING, "STEPPING"}, {MODE_BENCHMARK, "BENCHMARCK"},
     };
 
-  const std::map<Disk_Status_e, std::string> statuses =
-    {
-      {DISK_STATUS_OFF, "OFF"},
-      {DISK_STATUS_READ, "READ"},
-      {DISK_STATUS_WRITE, "WRITE"},
-      {DISK_STATUS_PROT, "PROT"},
+    const std::map<Disk_Status_e, std::string> statuses = {
+        {DISK_STATUS_OFF, "OFF"},
+        {DISK_STATUS_READ, "READ"},
+        {DISK_STATUS_WRITE, "WRITE"},
+        {DISK_STATUS_PROT, "PROT"},
     };
 
-  const std::map<VideoType_e, std::string> videoTypes =
-  {
-    {VT_MONO_CUSTOM, "Monochrome (Custom)"},
-    {VT_COLOR_IDEALIZED, "Color (Composite Idealized)"},
-    {VT_COLOR_VIDEOCARD_RGB, "Color (RGB Card/Monitor)"},
-    {VT_COLOR_MONITOR_NTSC, "Color (Composite Monitor)"},
-    {VT_COLOR_TV, "Color TV"},
-    {VT_MONO_TV, "B&W TV"},
-    {VT_MONO_AMBER, "Monochrome (Amber)"},
-    {VT_MONO_GREEN, "Monochrome (Green)"},
-    {VT_MONO_WHITE, "Monochrome (White)"},
-  };
-
-  const std::map<DONGLETYPE, std::string> dongleTypes =
-  {
-    {DT_EMPTY, "Empty"},
-    {DT_SDSSPEEDSTAR, "Speed Star"},
-    {DT_CODEWRITER, "Code Writer"},
-    {DT_ROBOCOM500, "RoboCom 500"},
-    {DT_ROBOCOM1000, "RoboCom 1000"},
-    {DT_ROBOCOM1500, "RoboCom 1500"},
-  };
-
-  const std::map<size_t, std::vector<SS_CARDTYPE>> cardsForSlots =
-    {
-      {0, {CT_Empty, CT_LanguageCard, CT_Saturn128K}},
-      {1, {CT_Empty, CT_GenericPrinter, CT_Uthernet2}},
-      {2, {CT_Empty, CT_SSC, CT_Uthernet2}},
-      {3, {CT_Empty, CT_Uthernet, CT_Uthernet2, CT_VidHD}},
-      {4, {CT_Empty, CT_MockingboardC, CT_MegaAudio, CT_SDMusic, CT_MouseInterface, CT_Phasor, CT_Uthernet2}},
-      {5, {CT_Empty, CT_MockingboardC, CT_MegaAudio, CT_SDMusic, CT_Disk2, CT_GenericHDD, CT_Phasor, CT_Uthernet2, CT_Z80, CT_SAM, CT_FourPlay, CT_SNESMAX}},
-      {6, {CT_Empty, CT_Disk2, CT_Uthernet2}},
-      {7, {CT_Empty, CT_GenericHDD, CT_Uthernet2}},
+    const std::map<VideoType_e, std::string> videoTypes = {
+        {VT_MONO_CUSTOM, "Monochrome (Custom)"},
+        {VT_COLOR_IDEALIZED, "Color (Composite Idealized)"},
+        {VT_COLOR_VIDEOCARD_RGB, "Color (RGB Card/Monitor)"},
+        {VT_COLOR_MONITOR_NTSC, "Color (Composite Monitor)"},
+        {VT_COLOR_TV, "Color TV"},
+        {VT_MONO_TV, "B&W TV"},
+        {VT_MONO_AMBER, "Monochrome (Amber)"},
+        {VT_MONO_GREEN, "Monochrome (Green)"},
+        {VT_MONO_WHITE, "Monochrome (White)"},
     };
 
-    const std::vector<SS_CARDTYPE> expansionCards =
-      {CT_Empty, CT_LanguageCard, CT_Extended80Col, CT_Saturn128K, CT_RamWorksIII};
+    const std::map<DONGLETYPE, std::string> dongleTypes = {
+        {DT_EMPTY, "Empty"},
+        {DT_SDSSPEEDSTAR, "Speed Star"},
+        {DT_CODEWRITER, "Code Writer"},
+        {DT_ROBOCOM500, "RoboCom 500"},
+        {DT_ROBOCOM1000, "RoboCom 1000"},
+        {DT_ROBOCOM1500, "RoboCom 1500"},
+    };
 
-  uint8_t roundToRGB(float x)
-  {
-    // c++ cast truncates
-    return uint8_t(x * 255 + 0.5);
-  }
+    const std::map<size_t, std::vector<SS_CARDTYPE>> cardsForSlots = {
+        {0, {CT_Empty, CT_LanguageCard, CT_Saturn128K}},
+        {1, {CT_Empty, CT_GenericPrinter, CT_Uthernet2}},
+        {2, {CT_Empty, CT_SSC, CT_Uthernet2}},
+        {3, {CT_Empty, CT_Uthernet, CT_Uthernet2, CT_VidHD}},
+        {4, {CT_Empty, CT_MockingboardC, CT_MegaAudio, CT_SDMusic, CT_MouseInterface, CT_Phasor, CT_Uthernet2}},
+        {5,
+         {CT_Empty, CT_MockingboardC, CT_MegaAudio, CT_SDMusic, CT_Disk2, CT_GenericHDD, CT_Phasor, CT_Uthernet2,
+          CT_Z80, CT_SAM, CT_FourPlay, CT_SNESMAX}},
+        {6, {CT_Empty, CT_Disk2, CT_Uthernet2}},
+        {7, {CT_Empty, CT_GenericHDD, CT_Uthernet2}},
+    };
 
-}
+    const std::vector<SS_CARDTYPE> expansionCards = {
+        CT_Empty, CT_LanguageCard, CT_Extended80Col, CT_Saturn128K, CT_RamWorksIII};
+
+    uint8_t roundToRGB(float x)
+    {
+        // c++ cast truncates
+        return uint8_t(x * 255 + 0.5);
+    }
+
+} // namespace
 
 namespace sa2
 {
 
-  const std::string & getCardName(SS_CARDTYPE card)
-  {
-    return cards.at(card);
-  }
-
-  const std::string & getCPUName(eCpuType cpu)
-  {
-    return cpuTypes.at(cpu);
-  }
-
-  const std::string & getAppModeName(AppMode_e mode)
-  {
-    return appModes.at(mode);
-  }
-
-  const std::vector<SS_CARDTYPE> & getCardsForSlot(size_t slot)
-  {
-    return cardsForSlots.at(slot);
-  }
-
-  const std::vector<SS_CARDTYPE> & getExpansionCards()
-  {
-    return expansionCards;
-  }
-
-  const std::map<SS_CARDTYPE, std::string> & getCardNames()
-  {
-    return cards;
-  }
-
-  const std::map<eApple2Type, std::string> & getAapple2Types()
-  {
-    return apple2Types;
-  }
-
-  const std::map<DONGLETYPE, std::string> & getDongleTypes()
-  {
-    return dongleTypes;
-  }
-
-  const std::map<VideoType_e, std::string> & getVideoTypes()
-  {
-    return videoTypes;
-  }
-
-  const std::string & getDiskStatusName(Disk_Status_e status)
-  {
-    return statuses.at(status);
-  }
-
-  void insertCard(size_t slot, SS_CARDTYPE card, FrameBase * frame)
-  {
-    CardManager & cardManager = GetCardMgr();
-    Video & video = GetVideo();
-    const bool oldHasVid = video.HasVidHD();
-    switch (slot)
+    const std::string &getCardName(SS_CARDTYPE card)
+    {
+        return cards.at(card);
+    }
+
+    const std::string &getCPUName(eCpuType cpu)
+    {
+        return cpuTypes.at(cpu);
+    }
+
+    const std::string &getAppModeName(AppMode_e mode)
+    {
+        return appModes.at(mode);
+    }
+
+    const std::vector<SS_CARDTYPE> &getCardsForSlot(size_t slot)
+    {
+        return cardsForSlots.at(slot);
+    }
+
+    const std::vector<SS_CARDTYPE> &getExpansionCards()
     {
-      case 3:
-      {
-        if (cardManager.QuerySlot(slot) == CT_VidHD)
+        return expansionCards;
+    }
+
+    const std::map<SS_CARDTYPE, std::string> &getCardNames()
+    {
+        return cards;
+    }
+
+    const std::map<eApple2Type, std::string> &getAapple2Types()
+    {
+        return apple2Types;
+    }
+
+    const std::map<DONGLETYPE, std::string> &getDongleTypes()
+    {
+        return dongleTypes;
+    }
+
+    const std::map<VideoType_e, std::string> &getVideoTypes()
+    {
+        return videoTypes;
+    }
+
+    const std::string &getDiskStatusName(Disk_Status_e status)
+    {
+        return statuses.at(status);
+    }
+
+    void insertCard(size_t slot, SS_CARDTYPE card, FrameBase *frame)
+    {
+        CardManager &cardManager = GetCardMgr();
+        Video &video = GetVideo();
+        const bool oldHasVid = video.HasVidHD();
+        switch (slot)
+        {
+        case 3:
         {
-          // the old card was a VidHD, which will be removed
-          // reset it
-          video.SetVidHD(false);
+            if (cardManager.QuerySlot(slot) == CT_VidHD)
+            {
+                // the old card was a VidHD, which will be removed
+                // reset it
+                video.SetVidHD(false);
+            }
+            break;
         }
-        break;
-      }
-    };
+        };
+
+        cardManager.Insert(slot, card);
 
-    cardManager.Insert(slot, card);
+        // keep everything consistent
+        // a bit of a heavy call, but nothing simpler is available now
+        MemInitializeIO();
 
-    // keep everything consistent
-    // a bit of a heavy call, but nothing simpler is available now
-    MemInitializeIO();
+        if (oldHasVid != video.HasVidHD())
+        {
+            frame->Destroy();
+            frame->Initialize(true);
+        }
+    }
 
-    if (oldHasVid != video.HasVidHD())
+    void setExpansionCard(SS_CARDTYPE card)
     {
-      frame->Destroy();
-      frame->Initialize(true);
+        SetExpansionMemType(card);
+        CreateLanguageCard();
+        MemInitializeIO();
     }
-  }
-
-  void setExpansionCard(SS_CARDTYPE card)
-  {
-    SetExpansionMemType(card);
-    CreateLanguageCard();
-    MemInitializeIO();
-  }
-
-  void setVideoStyle(Video & video, const VideoStyle_e style, const bool enabled)
-  {
-    VideoStyle_e currentVideoStyle = video.GetVideoStyle();
-    if (enabled)
+
+    void setVideoStyle(Video &video, const VideoStyle_e style, const bool enabled)
     {
-      currentVideoStyle = VideoStyle_e(currentVideoStyle | style);
+        VideoStyle_e currentVideoStyle = video.GetVideoStyle();
+        if (enabled)
+        {
+            currentVideoStyle = VideoStyle_e(currentVideoStyle | style);
+        }
+        else
+        {
+            currentVideoStyle = VideoStyle_e(currentVideoStyle & (~style));
+        }
+        video.SetVideoStyle(currentVideoStyle);
     }
-    else
+
+    void saveTFEEnabled(const int enabled)
     {
-      currentVideoStyle = VideoStyle_e(currentVideoStyle & (~style));
+        REGSAVE(TEXT(REGVALUE_UTHERNET_ACTIVE), enabled);
     }
-    video.SetVideoStyle(currentVideoStyle);
-  }
-
-  void saveTFEEnabled(const int enabled)
-  {
-    REGSAVE(TEXT(REGVALUE_UTHERNET_ACTIVE), enabled);
-  }
-
-  void changeBreakpoint(const uint32_t nAddress, const bool enableAndSet)
-  {
-    // see _BWZ_RemoveOne
-    for (Breakpoint_t & bp : g_aBreakpoints)
+
+    void changeBreakpoint(const uint32_t nAddress, const bool enableAndSet)
     {
-      if (bp.bSet && bp.nLength && (nAddress >= bp.nAddress) && (nAddress < bp.nAddress + bp.nLength))
-      {
-        bp.bSet = enableAndSet;
-        bp.bEnabled = enableAndSet;
-        if (!enableAndSet)
+        // see _BWZ_RemoveOne
+        for (Breakpoint_t &bp : g_aBreakpoints)
         {
-          bp.nLength = 0;
-          --g_nBreakpoints;
+            if (bp.bSet && bp.nLength && (nAddress >= bp.nAddress) && (nAddress < bp.nAddress + bp.nLength))
+            {
+                bp.bSet = enableAndSet;
+                bp.bEnabled = enableAndSet;
+                if (!enableAndSet)
+                {
+                    bp.nLength = 0;
+                    --g_nBreakpoints;
+                }
+            }
         }
-      }
     }
-  }
-
-  ImVec4 colorrefToImVec4(const COLORREF cr)
-  {
-    const float coeff = 1.0 / 255.0;
-    const bgra_t * bgra = reinterpret_cast<const bgra_t *>(&cr);
-    const ImVec4 color(bgra->b * coeff, bgra->g * coeff, bgra->r * coeff, 1);
-    return color;
-  }
-
-  COLORREF imVec4ToColorref(const ImVec4 & color)
-  {
-    const bgra_t bgra = {roundToRGB(color.x), roundToRGB(color.y), roundToRGB(color.z), roundToRGB(color.w)};
-    const COLORREF * cr = reinterpret_cast<const COLORREF *>(&bgra);
-    return *cr;
-  }
-
-  char getPrintableChar(const uint8_t x)  // copied from FormatCharTxtCtrl
-  {
-    char c = x & 0x7F; // .32 Changed: Lo now maps High Ascii to printable chars. i.e. ML1 D0D0
-    if (c < 0x20) // SPACE
+
+    ImVec4 colorrefToImVec4(const COLORREF cr)
     {
-      c += '@'; // map ctrl chars to visible
+        const float coeff = 1.0 / 255.0;
+        const bgra_t *bgra = reinterpret_cast<const bgra_t *>(&cr);
+        const ImVec4 color(bgra->b * coeff, bgra->g * coeff, bgra->r * coeff, 1);
+        return color;
     }
-    return c;
-  }
 
-  void sectableToClipboard(const std::string & text)
-  {
-    if (!text.empty() && ImGui::Selectable(text.c_str()))
+    COLORREF imVec4ToColorref(const ImVec4 &color)
     {
-      SDL_SetClipboardText(text.c_str());
+        const bgra_t bgra = {roundToRGB(color.x), roundToRGB(color.y), roundToRGB(color.z), roundToRGB(color.w)};
+        const COLORREF *cr = reinterpret_cast<const COLORREF *>(&bgra);
+        return *cr;
     }
-  }
 
-}
+    char getPrintableChar(const uint8_t x) // copied from FormatCharTxtCtrl
+    {
+        char c = x & 0x7F; // .32 Changed: Lo now maps High Ascii to printable chars. i.e. ML1 D0D0
+        if (c < 0x20)      // SPACE
+        {
+            c += '@'; // map ctrl chars to visible
+        }
+        return c;
+    }
+
+    void sectableToClipboard(const std::string &text)
+    {
+        if (!text.empty() && ImGui::Selectable(text.c_str()))
+        {
+            SDL_SetClipboardText(text.c_str());
+        }
+    }
+
+} // namespace sa2
 
 namespace ImGui
 {
 
-  bool CheckBoxTristate(const char* label, int* v_tristate)
-  {
-    bool ret;
-    if (*v_tristate == -1)
+    bool CheckBoxTristate(const char *label, int *v_tristate)
     {
-      ImGui::PushItemFlag(ImGuiItemFlags_MixedValue, true);
-      bool b = false;
-      ret = ImGui::Checkbox(label, &b);
-      if (ret)
-        *v_tristate = 1;
-      ImGui::PopItemFlag();
+        bool ret;
+        if (*v_tristate == -1)
+        {
+            ImGui::PushItemFlag(ImGuiItemFlags_MixedValue, true);
+            bool b = false;
+            ret = ImGui::Checkbox(label, &b);
+            if (ret)
+                *v_tristate = 1;
+            ImGui::PopItemFlag();
+        }
+        else
+        {
+            bool b = (*v_tristate != 0);
+            ret = ImGui::Checkbox(label, &b);
+            if (ret)
+                *v_tristate = (int)b;
+        }
+        return ret;
     }
-    else
+
+    void PushStyleCompact()
     {
-      bool b = (*v_tristate != 0);
-      ret = ImGui::Checkbox(label, &b);
-      if (ret)
-        *v_tristate = (int)b;
+        ImGuiStyle &style = ImGui::GetStyle();
+        ImGui::PushStyleVar(
+            ImGuiStyleVar_FramePadding, ImVec2(style.FramePadding.x, (float)(int)(style.FramePadding.y * 0.60f)));
+        ImGui::PushStyleVar(
+            ImGuiStyleVar_ItemSpacing, ImVec2(style.ItemSpacing.x, (float)(int)(style.ItemSpacing.y * 0.60f)));
     }
-    return ret;
-  }
-
-  void PushStyleCompact()
-  {
-    ImGuiStyle& style = ImGui::GetStyle();
-    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(style.FramePadding.x, (float)(int)(style.FramePadding.y * 0.60f)));
-    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(style.ItemSpacing.x, (float)(int)(style.ItemSpacing.y * 0.60f)));
-  }
-
-  void PopStyleCompact()
-  {
-    ImGui::PopStyleVar(2);
-  }
-
-}
+
+    void PopStyleCompact()
+    {
+        ImGui::PopStyleVar(2);
+    }
+
+} // namespace ImGui
diff --git a/source/frontends/sdl/imgui/settingshelper.h b/source/frontends/sdl/imgui/settingshelper.h
index 3a7d06d4e..1633d5304 100644
--- a/source/frontends/sdl/imgui/settingshelper.h
+++ b/source/frontends/sdl/imgui/settingshelper.h
@@ -18,97 +18,88 @@ class FrameBase;
 namespace sa2
 {
 
-  template<typename T, typename A>
-  void comboIterator(
-    const char* label, 
-    const T current,
-    const std::map<T, std::string> & values,
-    const A action
-    )
-  {
-    if (ImGui::BeginCombo(label, values.at(current).c_str()))
+    template <typename T, typename A>
+    void comboIterator(const char *label, const T current, const std::map<T, std::string> &values, const A action)
     {
-      for (const auto & it: values)
-      {
-        // this only 
-        const T value = it.first; // 
-        const std::string & name = it.second;
-        const bool isSelected = current == value;
-        if (ImGui::Selectable(name.c_str(), isSelected))
+        if (ImGui::BeginCombo(label, values.at(current).c_str()))
         {
-          action(value);
+            for (const auto &it : values)
+            {
+                // this only
+                const T value = it.first; //
+                const std::string &name = it.second;
+                const bool isSelected = current == value;
+                if (ImGui::Selectable(name.c_str(), isSelected))
+                {
+                    action(value);
+                }
+                if (isSelected)
+                {
+                    ImGui::SetItemDefaultFocus();
+                }
+            }
+            ImGui::EndCombo();
         }
-        if (isSelected)
-        {
-          ImGui::SetItemDefaultFocus();
-        }
-      }
-      ImGui::EndCombo();
     }
-  }
-
-  template<typename T, typename A>
-  void comboIterator(
-    const char* label, 
-    const T current,
-    const std::vector<T> & values,
-    const std::map<T, std::string> & names,
-    const A action
-    )
-  {
-    if (ImGui::BeginCombo(label, names.at(current).c_str()))
+
+    template <typename T, typename A>
+    void comboIterator(
+        const char *label, const T current, const std::vector<T> &values, const std::map<T, std::string> &names,
+        const A action)
     {
-      for (const auto & it: values)
-      {
-        const T value = it;
-        const std::string & name = names.at(it);
-        const bool isSelected = current == value;
-        if (ImGui::Selectable(name.c_str(), isSelected))
-        {
-          action(value);
-        }
-        if (isSelected)
+        if (ImGui::BeginCombo(label, names.at(current).c_str()))
         {
-          ImGui::SetItemDefaultFocus();
+            for (const auto &it : values)
+            {
+                const T value = it;
+                const std::string &name = names.at(it);
+                const bool isSelected = current == value;
+                if (ImGui::Selectable(name.c_str(), isSelected))
+                {
+                    action(value);
+                }
+                if (isSelected)
+                {
+                    ImGui::SetItemDefaultFocus();
+                }
+            }
+            ImGui::EndCombo();
         }
-      }
-      ImGui::EndCombo();
     }
-  }
 
-  const std::string & getCardName(SS_CARDTYPE card);
-  const std::string & getCPUName(eCpuType cpu);
-  const std::string & getAppModeName(AppMode_e mode);
-  const std::string & getDiskStatusName(Disk_Status_e status);
+    const std::string &getCardName(SS_CARDTYPE card);
+    const std::string &getCPUName(eCpuType cpu);
+    const std::string &getAppModeName(AppMode_e mode);
+    const std::string &getDiskStatusName(Disk_Status_e status);
 
-  const std::vector<SS_CARDTYPE> & getCardsForSlot(size_t slot);
-  const std::vector<SS_CARDTYPE> & getExpansionCards();
+    const std::vector<SS_CARDTYPE> &getCardsForSlot(size_t slot);
+    const std::vector<SS_CARDTYPE> &getExpansionCards();
 
-  const std::map<eApple2Type, std::string> & getAapple2Types();
-  const std::map<DONGLETYPE, std::string> & getDongleTypes();
-  const std::map<VideoType_e, std::string> & getVideoTypes();
-  const std::map<SS_CARDTYPE, std::string> & getCardNames();
+    const std::map<eApple2Type, std::string> &getAapple2Types();
+    const std::map<DONGLETYPE, std::string> &getDongleTypes();
+    const std::map<VideoType_e, std::string> &getVideoTypes();
+    const std::map<SS_CARDTYPE, std::string> &getCardNames();
 
-  void insertCard(size_t slot, SS_CARDTYPE card, FrameBase * frame);
-  void setExpansionCard(SS_CARDTYPE card);
-  void setVideoStyle(Video & video, const VideoStyle_e style, const bool enabled);
+    void insertCard(size_t slot, SS_CARDTYPE card, FrameBase *frame);
+    void setExpansionCard(SS_CARDTYPE card);
+    void setVideoStyle(Video &video, const VideoStyle_e style, const bool enabled);
 
-  void saveTFEEnabled(const int enabled);
+    void saveTFEEnabled(const int enabled);
 
-  void changeBreakpoint(const uint32_t nAddress, const bool enableAndSet);
+    void changeBreakpoint(const uint32_t nAddress, const bool enableAndSet);
 
-  ImVec4 colorrefToImVec4(const COLORREF cr);
-  COLORREF imVec4ToColorref(const ImVec4 & color);
+    ImVec4 colorrefToImVec4(const COLORREF cr);
+    COLORREF imVec4ToColorref(const ImVec4 &color);
 
-  char getPrintableChar(const uint8_t x);  // copied from FormatCharTxtCtrl
+    char getPrintableChar(const uint8_t x); // copied from FormatCharTxtCtrl
 
-  void sectableToClipboard(const std::string & text);
+    void sectableToClipboard(const std::string &text);
 
-}
+} // namespace sa2
 
 namespace ImGui
 {
-  bool CheckBoxTristate(const char* label, int* v_tristate);
-  void PushStyleCompact();
-  void PopStyleCompact();
-}
+    bool CheckBoxTristate(const char *label, int *v_tristate);
+    void PushStyleCompact();
+    void PopStyleCompact();
+} // namespace ImGui
diff --git a/source/frontends/sdl/main.cpp b/source/frontends/sdl/main.cpp
index 8003012c1..88c23eaea 100644
--- a/source/frontends/sdl/main.cpp
+++ b/source/frontends/sdl/main.cpp
@@ -30,165 +30,165 @@
 namespace
 {
 
-  int getRefreshRate()
-  {
-    SDL_DisplayMode current;
+    int getRefreshRate()
+    {
+        SDL_DisplayMode current;
 
-    const int should_be_zero = SDL_GetCurrentDisplayMode(0, &current);
+        const int should_be_zero = SDL_GetCurrentDisplayMode(0, &current);
 
-    if (should_be_zero)
-    {
-      throw std::runtime_error(sa2::decorateSDLError("SDL_GetCurrentDisplayMode"));
-    }
+        if (should_be_zero)
+        {
+            throw std::runtime_error(sa2::decorateSDLError("SDL_GetCurrentDisplayMode"));
+        }
 
-    return current.refresh_rate ? current.refresh_rate : 60;
-  }
+        return current.refresh_rate ? current.refresh_rate : 60;
+    }
 
-  struct Data
-  {
-    sa2::SDLFrame * frame;
-    SDL_mutex * mutex;
-    common2::Timer * timer;
-  };
+    struct Data
+    {
+        sa2::SDLFrame *frame;
+        SDL_mutex *mutex;
+        common2::Timer *timer;
+    };
 
-}
+} // namespace
 
 void run_sdl(int argc, char *const argv[])
 {
-  common2::EmulatorOptions options;
+    common2::EmulatorOptions options;
 
-  const bool run = getEmulatorOptions(argc, argv, common2::OptionsType::sa2, "SDL2", options);
+    const bool run = getEmulatorOptions(argc, argv, common2::OptionsType::sa2, "SDL2", options);
 
-  if (!run)
-    return;
+    if (!run)
+        return;
 
-  std::cerr << std::fixed << std::setprecision(2);
+    std::cerr << std::fixed << std::setprecision(2);
 
-  sa2::printVideoInfo(std::cerr);
-  sa2::printAudioInfo(std::cerr);
+    sa2::printVideoInfo(std::cerr);
+    sa2::printAudioInfo(std::cerr);
 
-  const LoggerContext logger(options.log);
-  const RegistryContext registryContext(CreateFileRegistry(options));
-  const std::shared_ptr<Paddle> paddle = sa2::Gamepad::create(options.gameControllerIndex, options.gameControllerMappingFile);
+    const LoggerContext logger(options.log);
+    const RegistryContext registryContext(CreateFileRegistry(options));
+    const std::shared_ptr<Paddle> paddle =
+        sa2::Gamepad::create(options.gameControllerIndex, options.gameControllerMappingFile);
 
-  sa2::setAudioOptions(options);
+    sa2::setAudioOptions(options);
 
-  std::shared_ptr<sa2::SDLFrame> frame;
-  if (options.imgui)
-  {
-    frame = std::make_shared<sa2::SDLImGuiFrame>(options);
-  }
-  else
-  {
-    frame = std::make_shared<sa2::SDLRendererFrame>(options);
-  }
+    std::shared_ptr<sa2::SDLFrame> frame;
+    if (options.imgui)
+    {
+        frame = std::make_shared<sa2::SDLImGuiFrame>(options);
+    }
+    else
+    {
+        frame = std::make_shared<sa2::SDLRendererFrame>(options);
+    }
 
-  std::cerr << "Default GL swap interval: " << SDL_GL_GetSwapInterval() << std::endl;
+    std::cerr << "Default GL swap interval: " << SDL_GL_GetSwapInterval() << std::endl;
 
-  const common2::CommonInitialisation init(frame, paddle, options);
+    const common2::CommonInitialisation init(frame, paddle, options);
 
-  const int fps = getRefreshRate();
-  std::cerr << "Video refresh rate: " << fps << " Hz, " << 1000.0 / fps << " ms" << std::endl;
+    const int fps = getRefreshRate();
+    std::cerr << "Video refresh rate: " << fps << " Hz, " << 1000.0 / fps << " ms" << std::endl;
 
 #ifdef EMULATOR_RUN
-  if (options.benchmark)
-  {
-    // we need to switch off vsync, otherwise FPS is limited to 60
-    // and it will take longer to run
-    sa2::SDLFrame::setGLSwapInterval(0);
-
-    const auto redraw = [&frame]{
-                          frame->VideoPresentScreen();
-                        };
-
-    Video & video = GetVideo();
-    const auto refresh = [redraw, &video]{
-                           NTSC_SetVideoMode( video.GetVideoMode() );
-                           NTSC_VideoRedrawWholeScreen();
-                           redraw();
-                         };
-
-    VideoBenchmark(redraw, refresh);
-  }
-  else
-  {
-    common2::Timer global;
-    common2::Timer refreshScreenTimer;
-    common2::Timer cpuTimer;
-    common2::Timer eventTimer;
-    common2::Timer frameTimer;
-
-    const std::string globalTag = ". .";
-    std::string updateTextureTimerTag, refreshScreenTimerTag, cpuTimerTag, eventTimerTag;
-
-    // it does not need to be exact
-    const int64_t oneFrameMicros = 1000000 / fps;
-
-    bool quit = false;
-
-    do
+    if (options.benchmark)
     {
-      frameTimer.tic();
+        // we need to switch off vsync, otherwise FPS is limited to 60
+        // and it will take longer to run
+        sa2::SDLFrame::setGLSwapInterval(0);
 
-      eventTimer.tic();
-      frame->ProcessEvents(quit);
-      eventTimer.toc();
+        const auto redraw = [&frame] { frame->VideoPresentScreen(); };
 
-      cpuTimer.tic();
-      frame->ExecuteOneFrame(oneFrameMicros);
-      cpuTimer.toc();
-
-      if (!options.headless)
-      {
-        refreshScreenTimer.tic();
-        if (g_bFullSpeed)
-        {
-          frame->VideoRedrawScreenDuringFullSpeed(g_dwCyclesThisFrame);
-        }
-        else
+        Video &video = GetVideo();
+        const auto refresh = [redraw, &video]
         {
-          frame->SyncVideoPresentScreen(oneFrameMicros);
-        }
-        refreshScreenTimer.toc();
-      }
+            NTSC_SetVideoMode(video.GetVideoMode());
+            NTSC_VideoRedrawWholeScreen();
+            redraw();
+        };
 
-      frameTimer.toc();
-    } while (!quit && !frame->Quit());
+        VideoBenchmark(redraw, refresh);
+    }
+    else
+    {
+        common2::Timer global;
+        common2::Timer refreshScreenTimer;
+        common2::Timer cpuTimer;
+        common2::Timer eventTimer;
+        common2::Timer frameTimer;
+
+        const std::string globalTag = ". .";
+        std::string updateTextureTimerTag, refreshScreenTimerTag, cpuTimerTag, eventTimerTag;
+
+        // it does not need to be exact
+        const int64_t oneFrameMicros = 1000000 / fps;
 
-    global.toc();
+        bool quit = false;
 
-    std::cerr << "Global:  " << global << std::endl;
-    std::cerr << "Frame:   " << frameTimer << std::endl;
-    std::cerr << "Screen:  " << refreshScreenTimer << std::endl;
-    std::cerr << "Events:  " << eventTimer << std::endl;
-    std::cerr << "CPU:     " << cpuTimer << std::endl;
-  }
+        do
+        {
+            frameTimer.tic();
+
+            eventTimer.tic();
+            frame->ProcessEvents(quit);
+            eventTimer.toc();
+
+            cpuTimer.tic();
+            frame->ExecuteOneFrame(oneFrameMicros);
+            cpuTimer.toc();
+
+            if (!options.headless)
+            {
+                refreshScreenTimer.tic();
+                if (g_bFullSpeed)
+                {
+                    frame->VideoRedrawScreenDuringFullSpeed(g_dwCyclesThisFrame);
+                }
+                else
+                {
+                    frame->SyncVideoPresentScreen(oneFrameMicros);
+                }
+                refreshScreenTimer.toc();
+            }
+
+            frameTimer.toc();
+        } while (!quit && !frame->Quit());
+
+        global.toc();
+
+        std::cerr << "Global:  " << global << std::endl;
+        std::cerr << "Frame:   " << frameTimer << std::endl;
+        std::cerr << "Screen:  " << refreshScreenTimer << std::endl;
+        std::cerr << "Events:  " << eventTimer << std::endl;
+        std::cerr << "CPU:     " << cpuTimer << std::endl;
+    }
 #endif
 }
 
 int main(int argc, char *const argv[])
 {
-  //First we need to start up SDL, and make sure it went ok
-  const Uint32 flags = SDL_INIT_VIDEO | SDL_INIT_GAMECONTROLLER | SDL_INIT_AUDIO | SDL_INIT_TIMER | SDL_INIT_EVENTS;
-  if (SDL_Init(flags) != 0)
-  {
-    std::cerr << "SDL_Init Error: " << SDL_GetError() << std::endl;
-    return 1;
-  }
-
-  int exit = 0;
-
-  try
-  {
-    run_sdl(argc, argv);
-  }
-  catch (const std::exception & e)
-  {
-    exit = 2;
-    std::cerr << e.what() << std::endl;
-  }
-
-  SDL_Quit();
-
-  return exit;
+    // First we need to start up SDL, and make sure it went ok
+    const Uint32 flags = SDL_INIT_VIDEO | SDL_INIT_GAMECONTROLLER | SDL_INIT_AUDIO | SDL_INIT_TIMER | SDL_INIT_EVENTS;
+    if (SDL_Init(flags) != 0)
+    {
+        std::cerr << "SDL_Init Error: " << SDL_GetError() << std::endl;
+        return 1;
+    }
+
+    int exit = 0;
+
+    try
+    {
+        run_sdl(argc, argv);
+    }
+    catch (const std::exception &e)
+    {
+        exit = 2;
+        std::cerr << e.what() << std::endl;
+    }
+
+    SDL_Quit();
+
+    return exit;
 }
diff --git a/source/frontends/sdl/processfile.cpp b/source/frontends/sdl/processfile.cpp
index 78d122323..7a7a2d810 100644
--- a/source/frontends/sdl/processfile.cpp
+++ b/source/frontends/sdl/processfile.cpp
@@ -16,128 +16,133 @@
 namespace
 {
 
-  bool doesExtensionMatch(const char * filename, const std::vector<const char *> & valid)
-  {
-    return std::any_of(valid.begin(), valid.end(), [filename] (const char * ext) {
-      return strlen(filename) > strlen(ext) && !strcasecmp(filename + strlen(filename) - strlen(ext), ext);
-    });
-  }
+    bool doesExtensionMatch(const char *filename, const std::vector<const char *> &valid)
+    {
+        return std::any_of(
+            valid.begin(), valid.end(), [filename](const char *ext)
+            { return strlen(filename) > strlen(ext) && !strcasecmp(filename + strlen(filename) - strlen(ext), ext); });
+    }
 
-  bool checkExtension(sa2::SDLFrame * frame, const char * filename, const std::vector<const char *> & valid)
-  {
-    if (!doesExtensionMatch(filename, valid))
+    bool checkExtension(sa2::SDLFrame *frame, const char *filename, const std::vector<const char *> &valid)
     {
-      std::ostringstream msg;
-      msg << "Invalid extension (" << filename << "). Supported: ";
-      for (size_t i = 0; i < valid.size(); ++i)
-      {
-        if (i)
+        if (!doesExtensionMatch(filename, valid))
         {
-          msg << ", ";
+            std::ostringstream msg;
+            msg << "Invalid extension (" << filename << "). Supported: ";
+            for (size_t i = 0; i < valid.size(); ++i)
+            {
+                if (i)
+                {
+                    msg << ", ";
+                }
+                msg << valid[i];
+            }
+            frame->FrameMessageBox(msg.str().c_str(), "ERROR", MB_OK);
+            return false;
+        }
+        else
+        {
+            return true;
         }
-        msg << valid[i];
-      }
-      frame->FrameMessageBox(msg.str().c_str(), "ERROR", MB_OK);
-      return false;
-    }
-    else
-    {
-      return true;
     }
-  }
 
-  void insertDisk(sa2::SDLFrame * frame, const char * filename, const size_t dragAndDropSlot, const size_t dragAndDropDrive)
-  {
-    CardManager & cardManager = GetCardMgr();
-    const SS_CARDTYPE cardInSlot = cardManager.QuerySlot(dragAndDropSlot);
-    switch (cardInSlot)
+    void insertDisk(
+        sa2::SDLFrame *frame, const char *filename, const size_t dragAndDropSlot, const size_t dragAndDropDrive)
     {
-      case CT_Disk2:
-      {
-        if (checkExtension(frame, filename, {".bin", ".do", ".dsk", ".nib", ".po", ".gz", ".woz", ".zip", ".2mg", ".2img", ".iie", ".apl"}))
+        CardManager &cardManager = GetCardMgr();
+        const SS_CARDTYPE cardInSlot = cardManager.QuerySlot(dragAndDropSlot);
+        switch (cardInSlot)
         {
-          Disk2InterfaceCard * card2 = dynamic_cast<Disk2InterfaceCard*>(cardManager.GetObj(dragAndDropSlot));
-          const ImageError_e error = card2->InsertDisk(dragAndDropDrive, filename, IMAGE_USE_FILES_WRITE_PROTECT_STATUS, IMAGE_DONT_CREATE);
-          if (error != eIMAGE_ERROR_NONE)
-          {
-            card2->NotifyInvalidImage(dragAndDropDrive, filename, error);
-          }
+        case CT_Disk2:
+        {
+            if (checkExtension(
+                    frame, filename,
+                    {".bin", ".do", ".dsk", ".nib", ".po", ".gz", ".woz", ".zip", ".2mg", ".2img", ".iie", ".apl"}))
+            {
+                Disk2InterfaceCard *card2 = dynamic_cast<Disk2InterfaceCard *>(cardManager.GetObj(dragAndDropSlot));
+                const ImageError_e error = card2->InsertDisk(
+                    dragAndDropDrive, filename, IMAGE_USE_FILES_WRITE_PROTECT_STATUS, IMAGE_DONT_CREATE);
+                if (error != eIMAGE_ERROR_NONE)
+                {
+                    card2->NotifyInvalidImage(dragAndDropDrive, filename, error);
+                }
+            }
+            break;
         }
-        break;
-      }
-      case CT_GenericHDD:
-      {
-        if (checkExtension(frame, filename, {".hdv", ".po", ".2mg", ".2img", ".gz", ".zip"}))
+        case CT_GenericHDD:
         {
-          HarddiskInterfaceCard * harddiskCard = dynamic_cast<HarddiskInterfaceCard*>(cardManager.GetObj(dragAndDropSlot));
-          if (!harddiskCard->Insert(dragAndDropDrive, filename))
-          {
-            frame->FrameMessageBox("Invalid HD image", "ERROR", MB_OK);
-          }
+            if (checkExtension(frame, filename, {".hdv", ".po", ".2mg", ".2img", ".gz", ".zip"}))
+            {
+                HarddiskInterfaceCard *harddiskCard =
+                    dynamic_cast<HarddiskInterfaceCard *>(cardManager.GetObj(dragAndDropSlot));
+                if (!harddiskCard->Insert(dragAndDropDrive, filename))
+                {
+                    frame->FrameMessageBox("Invalid HD image", "ERROR", MB_OK);
+                }
+            }
+            break;
+        }
+        default:
+        {
+            frame->FrameMessageBox("Invalid D&D target", "ERROR", MB_OK);
+        }
         }
-        break;
-      }
-      default:
-      {
-        frame->FrameMessageBox("Invalid D&D target", "ERROR", MB_OK);
-      }
     }
-  }
 
-  void insertTape(sa2::SDLFrame * frame, const char * filename)
-  {
-    SDL_AudioSpec wavSpec;
-    Uint32 wavLength;
-    Uint8 *wavBuffer;
-    if (!SDL_LoadWAV(filename, &wavSpec, &wavBuffer, &wavLength))
+    void insertTape(sa2::SDLFrame *frame, const char *filename)
     {
-      frame->FrameMessageBox("Could not open wav file", "ERROR", MB_OK);
-      return;
-    }
-
-    SDL_AudioCVT cvt;
-    // tested with all formats from https://asciiexpress.net/
-    // 8 bit mono is just enough
-    // TAPEIN will interpolate so we do not need to resample at a higher frequency
-    const SDL_AudioFormat format = sizeof(CassetteTape::tape_data_t) == 1 ? AUDIO_S8 : AUDIO_S16SYS;
-    const int res = SDL_BuildAudioCVT(&cvt, wavSpec.format, wavSpec.channels, wavSpec.freq, format, 1, wavSpec.freq);
-    cvt.len = wavLength;
-    std::vector<CassetteTape::tape_data_t> output(cvt.len_mult * cvt.len / sizeof(CassetteTape::tape_data_t));
-    std::memcpy(output.data(), wavBuffer, cvt.len);
-    SDL_FreeWAV(wavBuffer);
+        SDL_AudioSpec wavSpec;
+        Uint32 wavLength;
+        Uint8 *wavBuffer;
+        if (!SDL_LoadWAV(filename, &wavSpec, &wavBuffer, &wavLength))
+        {
+            frame->FrameMessageBox("Could not open wav file", "ERROR", MB_OK);
+            return;
+        }
 
-    if (res)
-    {
-      cvt.buf = reinterpret_cast<Uint8 *>(output.data());
-      SDL_ConvertAudio(&cvt);
-      output.resize(cvt.len_cvt / sizeof(CassetteTape::tape_data_t));
-    }
+        SDL_AudioCVT cvt;
+        // tested with all formats from https://asciiexpress.net/
+        // 8 bit mono is just enough
+        // TAPEIN will interpolate so we do not need to resample at a higher frequency
+        const SDL_AudioFormat format = sizeof(CassetteTape::tape_data_t) == 1 ? AUDIO_S8 : AUDIO_S16SYS;
+        const int res =
+            SDL_BuildAudioCVT(&cvt, wavSpec.format, wavSpec.channels, wavSpec.freq, format, 1, wavSpec.freq);
+        cvt.len = wavLength;
+        std::vector<CassetteTape::tape_data_t> output(cvt.len_mult * cvt.len / sizeof(CassetteTape::tape_data_t));
+        std::memcpy(output.data(), wavBuffer, cvt.len);
+        SDL_FreeWAV(wavBuffer);
 
-    CassetteTape::instance().setData(filename, output, wavSpec.freq);
-  }
+        if (res)
+        {
+            cvt.buf = reinterpret_cast<Uint8 *>(output.data());
+            SDL_ConvertAudio(&cvt);
+            output.resize(cvt.len_cvt / sizeof(CassetteTape::tape_data_t));
+        }
 
-}
+        CassetteTape::instance().setData(filename, output, wavSpec.freq);
+    }
 
+} // namespace
 
 namespace sa2
 {
 
-  void processFile(SDLFrame * frame, const char * filename, const size_t dragAndDropSlot, const size_t dragAndDropDrive)
-  {
-    if (doesExtensionMatch(filename, {".yaml"}))
-    {
-      common2::setSnapshotFilename(filename);
-      frame->LoadSnapshot();
-    }
-    else if (doesExtensionMatch(filename, {".wav"}))
-    {
-      insertTape(frame, filename);
-    }
-    else
+    void processFile(SDLFrame *frame, const char *filename, const size_t dragAndDropSlot, const size_t dragAndDropDrive)
     {
-      insertDisk(frame, filename, dragAndDropSlot, dragAndDropDrive);
+        if (doesExtensionMatch(filename, {".yaml"}))
+        {
+            common2::setSnapshotFilename(filename);
+            frame->LoadSnapshot();
+        }
+        else if (doesExtensionMatch(filename, {".wav"}))
+        {
+            insertTape(frame, filename);
+        }
+        else
+        {
+            insertDisk(frame, filename, dragAndDropSlot, dragAndDropDrive);
+        }
+        frame->ResetSpeed();
     }
-    frame->ResetSpeed();
-  }
-  
-}
+
+} // namespace sa2
diff --git a/source/frontends/sdl/processfile.h b/source/frontends/sdl/processfile.h
index 32b067c18..9a4f234fd 100644
--- a/source/frontends/sdl/processfile.h
+++ b/source/frontends/sdl/processfile.h
@@ -1,6 +1,7 @@
 namespace sa2
 {
-  class SDLFrame;
+    class SDLFrame;
 
-  void processFile(SDLFrame * frame, const char * filename, const size_t dragAndDropSlot, const size_t dragAndDropDrive);
-}
+    void processFile(
+        SDLFrame *frame, const char *filename, const size_t dragAndDropSlot, const size_t dragAndDropDrive);
+} // namespace sa2
diff --git a/source/frontends/sdl/renderer/sdlrendererframe.cpp b/source/frontends/sdl/renderer/sdlrendererframe.cpp
index 8f8c0e26e..ca2d8ff92 100644
--- a/source/frontends/sdl/renderer/sdlrendererframe.cpp
+++ b/source/frontends/sdl/renderer/sdlrendererframe.cpp
@@ -11,80 +11,87 @@
 namespace sa2
 {
 
-  SDLRendererFrame::SDLRendererFrame(const common2::EmulatorOptions & options)
-    : SDLFrame(options)
-  {
-    const common2::Geometry geometry = getGeometryOrDefault(options.geometry);
-
-    myWindow.reset(SDL_CreateWindow(g_pAppTitle.c_str(), geometry.x, geometry.y, geometry.width, geometry.height, SDL_WINDOW_RESIZABLE), SDL_DestroyWindow);
-    if (!myWindow)
+    SDLRendererFrame::SDLRendererFrame(const common2::EmulatorOptions &options)
+        : SDLFrame(options)
     {
-      throw std::runtime_error(decorateSDLError("SDL_CreateWindow"));
+        const common2::Geometry geometry = getGeometryOrDefault(options.geometry);
+
+        myWindow.reset(
+            SDL_CreateWindow(
+                g_pAppTitle.c_str(), geometry.x, geometry.y, geometry.width, geometry.height, SDL_WINDOW_RESIZABLE),
+            SDL_DestroyWindow);
+        if (!myWindow)
+        {
+            throw std::runtime_error(decorateSDLError("SDL_CreateWindow"));
+        }
+
+        SetApplicationIcon();
+
+        myRenderer.reset(
+            SDL_CreateRenderer(myWindow.get(), options.sdlDriver, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC),
+            SDL_DestroyRenderer);
+        if (!myRenderer)
+        {
+            throw std::runtime_error(decorateSDLError("SDL_CreateRenderer"));
+        }
+
+        SetGLSynchronisation(options); // must be called after GL initialisation
+
+        printRendererInfo(std::cerr, myRenderer, ourPixelFormat, options.sdlDriver);
     }
 
-    SetApplicationIcon();
-
-    myRenderer.reset(SDL_CreateRenderer(myWindow.get(), options.sdlDriver, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC), SDL_DestroyRenderer);
-    if (!myRenderer)
+    void SDLRendererFrame::Initialize(bool resetVideoState)
     {
-      throw std::runtime_error(decorateSDLError("SDL_CreateRenderer"));
+        SDLFrame::Initialize(resetVideoState);
+        Video &video = GetVideo();
+
+        const int width = video.GetFrameBufferWidth();
+        const int height = video.GetFrameBufferHeight();
+        const int sw = video.GetFrameBufferBorderlessWidth();
+        const int sh = video.GetFrameBufferBorderlessHeight();
+
+        if (myPreserveAspectRatio && SDL_RenderSetLogicalSize(myRenderer.get(), sw, sh))
+        {
+            throw std::runtime_error(decorateSDLError("SDL_RenderSetLogicalSize"));
+        }
+
+        myTexture.reset(
+            SDL_CreateTexture(myRenderer.get(), ourPixelFormat, SDL_TEXTUREACCESS_STATIC, width, height),
+            SDL_DestroyTexture);
+
+        myRect.x = video.GetFrameBufferBorderWidth();
+        myRect.y = video.GetFrameBufferBorderHeight();
+        myRect.w = sw;
+        myRect.h = sh;
+        myPitch = width * sizeof(bgra_t);
     }
 
-    SetGLSynchronisation(options);  // must be called after GL initialisation
+    void SDLRendererFrame::VideoPresentScreen()
+    {
+        SDL_UpdateTexture(myTexture.get(), nullptr, myFramebuffer.data(), myPitch);
+        SDL_RenderClear(myRenderer.get());
+        SDL_RenderCopyEx(myRenderer.get(), myTexture.get(), &myRect, nullptr, 0.0, nullptr, SDL_FLIP_VERTICAL);
+        SDL_RenderPresent(myRenderer.get());
+    }
 
-    printRendererInfo(std::cerr, myRenderer, ourPixelFormat, options.sdlDriver);
-  }
+    void SDLRendererFrame::GetRelativeMousePosition(const SDL_MouseMotionEvent &motion, float &x, float &y) const
+    {
+        int width, height;
+        SDL_GetWindowSize(myWindow.get(), &width, &height);
 
-  void SDLRendererFrame::Initialize(bool resetVideoState)
-  {
-    SDLFrame::Initialize(resetVideoState);
-    Video & video = GetVideo();
+        x = GetRelativePosition(motion.x, width);
+        y = GetRelativePosition(motion.y, height);
+    }
 
-    const int width = video.GetFrameBufferWidth();
-    const int height = video.GetFrameBufferHeight();
-    const int sw = video.GetFrameBufferBorderlessWidth();
-    const int sh = video.GetFrameBufferBorderlessHeight();
+    bool SDLRendererFrame::Quit() const
+    {
+        return false;
+    }
 
-    if (myPreserveAspectRatio && SDL_RenderSetLogicalSize(myRenderer.get(), sw, sh))
+    void SDLRendererFrame::ToggleMouseCursor()
     {
-      throw std::runtime_error(decorateSDLError("SDL_RenderSetLogicalSize"));
+        const int current = SDL_ShowCursor(SDL_QUERY);
+        SDL_ShowCursor(current ^ 1);
     }
 
-    myTexture.reset(SDL_CreateTexture(myRenderer.get(), ourPixelFormat, SDL_TEXTUREACCESS_STATIC, width, height), SDL_DestroyTexture);
-
-    myRect.x = video.GetFrameBufferBorderWidth();
-    myRect.y = video.GetFrameBufferBorderHeight();
-    myRect.w = sw;
-    myRect.h = sh;
-    myPitch = width * sizeof(bgra_t);
-  }
-
-  void SDLRendererFrame::VideoPresentScreen()
-  {
-    SDL_UpdateTexture(myTexture.get(), nullptr, myFramebuffer.data(), myPitch);
-    SDL_RenderClear(myRenderer.get());
-    SDL_RenderCopyEx(myRenderer.get(), myTexture.get(), &myRect, nullptr, 0.0, nullptr, SDL_FLIP_VERTICAL);
-    SDL_RenderPresent(myRenderer.get());
-  }
-
-  void SDLRendererFrame::GetRelativeMousePosition(const SDL_MouseMotionEvent & motion, float & x, float & y) const
-  {
-    int width, height;
-    SDL_GetWindowSize(myWindow.get(), &width, &height);
-
-    x = GetRelativePosition(motion.x, width);
-    y = GetRelativePosition(motion.y, height);
-  }
-
-  bool SDLRendererFrame::Quit() const
-  {
-    return false;
-  }
-
-  void SDLRendererFrame::ToggleMouseCursor()
-  {
-    const int current = SDL_ShowCursor(SDL_QUERY);
-    SDL_ShowCursor(current ^ 1);
-  }
-
-}
+} // namespace sa2
diff --git a/source/frontends/sdl/renderer/sdlrendererframe.h b/source/frontends/sdl/renderer/sdlrendererframe.h
index 80d317977..6ace55c70 100644
--- a/source/frontends/sdl/renderer/sdlrendererframe.h
+++ b/source/frontends/sdl/renderer/sdlrendererframe.h
@@ -6,29 +6,28 @@
 namespace sa2
 {
 
-  class SDLRendererFrame : public SDLFrame
-  {
-  public:
-    SDLRendererFrame(const common2::EmulatorOptions & options);
+    class SDLRendererFrame : public SDLFrame
+    {
+    public:
+        SDLRendererFrame(const common2::EmulatorOptions &options);
 
-    void VideoPresentScreen() override;
-    void Initialize(bool resetVideoState) override;
+        void VideoPresentScreen() override;
+        void Initialize(bool resetVideoState) override;
 
-    bool Quit() const override;
+        bool Quit() const override;
 
-  protected:
-    void GetRelativeMousePosition(const SDL_MouseMotionEvent & motion, float & x, float & y) const override;
-    void ToggleMouseCursor() override;
+    protected:
+        void GetRelativeMousePosition(const SDL_MouseMotionEvent &motion, float &x, float &y) const override;
+        void ToggleMouseCursor() override;
 
-  private:
+    private:
+        static constexpr SDL_PixelFormatEnum ourPixelFormat = SDL_PIXELFORMAT_ARGB8888;
 
-    static constexpr SDL_PixelFormatEnum ourPixelFormat = SDL_PIXELFORMAT_ARGB8888;
+        SDL_Rect myRect;
+        int myPitch;
 
-    SDL_Rect myRect;
-    int myPitch;
+        std::shared_ptr<SDL_Renderer> myRenderer;
+        std::shared_ptr<SDL_Texture> myTexture;
+    };
 
-    std::shared_ptr<SDL_Renderer> myRenderer;
-    std::shared_ptr<SDL_Texture> myTexture;
-  };
-
-}
+} // namespace sa2
diff --git a/source/frontends/sdl/sdirectsound.cpp b/source/frontends/sdl/sdirectsound.cpp
index b691eab45..80e519172 100644
--- a/source/frontends/sdl/sdirectsound.cpp
+++ b/source/frontends/sdl/sdirectsound.cpp
@@ -19,250 +19,255 @@
 namespace
 {
 
-  // these have to come from EmulatorOptions
-  std::string audioDeviceName;
-  size_t audioBuffer = 0;
+    // these have to come from EmulatorOptions
+    std::string audioDeviceName;
+    size_t audioBuffer = 0;
 
-  size_t getBytesPerSecond(const SDL_AudioSpec & spec)
-  {
-    const size_t bitsPerSample = spec.format & SDL_AUDIO_MASK_BITSIZE;
-    const size_t bytesPerFrame = spec.channels * bitsPerSample / 8;
-    return spec.freq * bytesPerFrame;
-  }
-
-  size_t nextPowerOf2(size_t n)
-  {
-    size_t k = 1;
-    while (k < n)
-      k *= 2;
-    return k;
-  }
-
-  class DirectSoundGenerator : public LinuxSoundBuffer
-  {
-  public:
-    DirectSoundGenerator(DWORD dwBufferSize, DWORD nSampleRate, int nChannels, LPCSTR pszVoiceName, const char * deviceName, const size_t ms);
-    virtual ~DirectSoundGenerator() override;
-
-    virtual HRESULT Stop() override;
-    virtual HRESULT Play( DWORD dwReserved1, DWORD dwReserved2, DWORD dwFlags ) override;
+    size_t getBytesPerSecond(const SDL_AudioSpec &spec)
+    {
+        const size_t bitsPerSample = spec.format & SDL_AUDIO_MASK_BITSIZE;
+        const size_t bytesPerFrame = spec.channels * bitsPerSample / 8;
+        return spec.freq * bytesPerFrame;
+    }
 
-    void printInfo();
-    sa2::SoundInfo getInfo();
+    size_t nextPowerOf2(size_t n)
+    {
+        size_t k = 1;
+        while (k < n)
+            k *= 2;
+        return k;
+    }
 
-  private:
-    static void staticAudioCallback(void* userdata, uint8_t* stream, int len);
+    class DirectSoundGenerator : public LinuxSoundBuffer
+    {
+    public:
+        DirectSoundGenerator(
+            DWORD dwBufferSize, DWORD nSampleRate, int nChannels, LPCSTR pszVoiceName, const char *deviceName,
+            const size_t ms);
+        virtual ~DirectSoundGenerator() override;
 
-    void audioCallback(uint8_t* stream, int len);
+        virtual HRESULT Stop() override;
+        virtual HRESULT Play(DWORD dwReserved1, DWORD dwReserved2, DWORD dwFlags) override;
 
-    std::vector<uint8_t> myMixerBuffer;
+        void printInfo();
+        sa2::SoundInfo getInfo();
 
-    SDL_AudioDeviceID myAudioDevice;
-    SDL_AudioSpec myAudioSpec;
+    private:
+        static void staticAudioCallback(void *userdata, uint8_t *stream, int len);
 
-    size_t myBytesPerSecond;
+        void audioCallback(uint8_t *stream, int len);
 
-    uint8_t * mixBufferTo(uint8_t * stream);
-  };
+        std::vector<uint8_t> myMixerBuffer;
 
-  std::unordered_set<DirectSoundGenerator *> activeSoundGenerators;
+        SDL_AudioDeviceID myAudioDevice;
+        SDL_AudioSpec myAudioSpec;
 
-  void DirectSoundGenerator::staticAudioCallback(void* userdata, uint8_t* stream, int len)
-  {
-    DirectSoundGenerator * generator = static_cast<DirectSoundGenerator *>(userdata);
-    return generator->audioCallback(stream, len);
-  }
+        size_t myBytesPerSecond;
 
-  void DirectSoundGenerator::audioCallback(uint8_t* stream, int len)
-  {
-    LPVOID lpvAudioPtr1, lpvAudioPtr2;
-    DWORD dwAudioBytes1, dwAudioBytes2;
-    const size_t bytesRead = Read(len, &lpvAudioPtr1, &dwAudioBytes1, &lpvAudioPtr2, &dwAudioBytes2);
+        uint8_t *mixBufferTo(uint8_t *stream);
+    };
 
-    myMixerBuffer.resize(bytesRead);
+    std::unordered_set<DirectSoundGenerator *> activeSoundGenerators;
 
-    uint8_t * dest = myMixerBuffer.data();
-    if (lpvAudioPtr1 && dwAudioBytes1)
+    void DirectSoundGenerator::staticAudioCallback(void *userdata, uint8_t *stream, int len)
     {
-      memcpy(dest, lpvAudioPtr1, dwAudioBytes1);
-      dest += dwAudioBytes1;
+        DirectSoundGenerator *generator = static_cast<DirectSoundGenerator *>(userdata);
+        return generator->audioCallback(stream, len);
     }
-    if (lpvAudioPtr2 && dwAudioBytes2)
+
+    void DirectSoundGenerator::audioCallback(uint8_t *stream, int len)
     {
-      memcpy(dest, lpvAudioPtr2, dwAudioBytes2);
-      dest += dwAudioBytes2;
+        LPVOID lpvAudioPtr1, lpvAudioPtr2;
+        DWORD dwAudioBytes1, dwAudioBytes2;
+        const size_t bytesRead = Read(len, &lpvAudioPtr1, &dwAudioBytes1, &lpvAudioPtr2, &dwAudioBytes2);
+
+        myMixerBuffer.resize(bytesRead);
+
+        uint8_t *dest = myMixerBuffer.data();
+        if (lpvAudioPtr1 && dwAudioBytes1)
+        {
+            memcpy(dest, lpvAudioPtr1, dwAudioBytes1);
+            dest += dwAudioBytes1;
+        }
+        if (lpvAudioPtr2 && dwAudioBytes2)
+        {
+            memcpy(dest, lpvAudioPtr2, dwAudioBytes2);
+            dest += dwAudioBytes2;
+        }
+
+        stream = mixBufferTo(stream);
+
+        const size_t gap = len - bytesRead;
+        if (gap)
+        {
+            memset(stream, myAudioSpec.silence, gap);
+        }
     }
 
-    stream = mixBufferTo(stream);
-
-    const size_t gap = len - bytesRead;
-    if (gap)
+    DirectSoundGenerator::DirectSoundGenerator(
+        DWORD dwBufferSize, DWORD nSampleRate, int nChannels, LPCSTR pszVoiceName, const char *deviceName,
+        const size_t ms)
+        : LinuxSoundBuffer(dwBufferSize, nSampleRate, nChannels, pszVoiceName)
+        , myAudioDevice(0)
+        , myBytesPerSecond(0)
     {
-      memset(stream, myAudioSpec.silence, gap);
+        SDL_zero(myAudioSpec);
+
+        SDL_AudioSpec want;
+        SDL_zero(want);
+
+        _ASSERT(ms > 0);
+
+        want.freq = mySampleRate;
+        want.format = AUDIO_S16LSB;
+        want.channels = myChannels;
+        want.samples = std::min<size_t>(MAX_SAMPLES, nextPowerOf2(mySampleRate * ms / 1000));
+        want.callback = staticAudioCallback;
+        want.userdata = this;
+        myAudioDevice = SDL_OpenAudioDevice(deviceName, 0, &want, &myAudioSpec, 0);
+
+        if (myAudioDevice)
+        {
+            myBytesPerSecond = getBytesPerSecond(myAudioSpec);
+        }
+        else
+        {
+            throw std::runtime_error(sa2::decorateSDLError("SDL_OpenAudioDevice"));
+        }
     }
-  }
-
-  DirectSoundGenerator::DirectSoundGenerator(DWORD dwBufferSize, DWORD nSampleRate, int nChannels, LPCSTR pszVoiceName, const char * deviceName, const size_t ms)
-    : LinuxSoundBuffer(dwBufferSize, nSampleRate, nChannels, pszVoiceName)
-    , myAudioDevice(0)
-    , myBytesPerSecond(0)
-  {
-    SDL_zero(myAudioSpec);
-
-    SDL_AudioSpec want;
-    SDL_zero(want);
 
-    _ASSERT(ms > 0);
-
-    want.freq = mySampleRate;
-    want.format = AUDIO_S16LSB;
-    want.channels = myChannels;
-    want.samples = std::min<size_t>(MAX_SAMPLES, nextPowerOf2(mySampleRate * ms / 1000));
-    want.callback = staticAudioCallback;
-    want.userdata = this;
-    myAudioDevice = SDL_OpenAudioDevice(deviceName, 0, &want, &myAudioSpec, 0);
-
-    if (myAudioDevice)
+    DirectSoundGenerator::~DirectSoundGenerator()
     {
-      myBytesPerSecond = getBytesPerSecond(myAudioSpec);
+        activeSoundGenerators.erase(this);
+        SDL_PauseAudioDevice(myAudioDevice, 1);
+        SDL_CloseAudioDevice(myAudioDevice);
     }
-    else
+
+    HRESULT DirectSoundGenerator::Stop()
     {
-      throw std::runtime_error(sa2::decorateSDLError("SDL_OpenAudioDevice"));
+        const HRESULT res = LinuxSoundBuffer::Stop();
+        SDL_PauseAudioDevice(myAudioDevice, 1);
+        return res;
     }
-  }
-
-  DirectSoundGenerator::~DirectSoundGenerator()
-  {
-    activeSoundGenerators.erase(this);
-    SDL_PauseAudioDevice(myAudioDevice, 1);
-    SDL_CloseAudioDevice(myAudioDevice);
-  }
-
-  HRESULT DirectSoundGenerator::Stop()
-  {
-    const HRESULT res = LinuxSoundBuffer::Stop();
-    SDL_PauseAudioDevice(myAudioDevice, 1);
-    return res;
-  }
-  
-  HRESULT DirectSoundGenerator::Play( DWORD dwReserved1, DWORD dwReserved2, DWORD dwFlags )
-  {
-    const HRESULT res = LinuxSoundBuffer::Play(dwReserved1, dwReserved2, dwFlags);
-    SDL_PauseAudioDevice(myAudioDevice, 0);
-    return res;
-  }
-
-  void DirectSoundGenerator::printInfo()
-  {
-    const uint32_t bytesInBuffer = GetBytesInBuffer();
-    std::cerr << "Channels: " << (int)myAudioSpec.channels;
-    std::cerr << ", buffer: " << std::setw(6) << bytesInBuffer;
-    const double time = double(bytesInBuffer) / myBytesPerSecond * 1000;
-    std::cerr << ", " << std::setw(8) << time << " ms";
-    std::cerr << ", underruns: " << std::setw(10) << GetBufferUnderruns() << std::endl;
-  }
-
-  sa2::SoundInfo DirectSoundGenerator::getInfo()
-  {
-    DWORD dwStatus;
-    GetStatus(&dwStatus);
-
-    sa2::SoundInfo info;
-    info.voiceName = myVoiceName;
-    info.running = dwStatus & DSBSTATUS_PLAYING;
-    info.channels = myChannels;
-    info.volume = GetLogarithmicVolume();
-    info.numberOfUnderruns = GetBufferUnderruns();
-
-    if (info.running && myBytesPerSecond > 0)
+
+    HRESULT DirectSoundGenerator::Play(DWORD dwReserved1, DWORD dwReserved2, DWORD dwFlags)
     {
-      const uint32_t bytesInBuffer = GetBytesInBuffer();
-      const float coeff = 1.0 / myBytesPerSecond;
-      info.buffer = bytesInBuffer * coeff;
-      info.size = myBufferSize * coeff;
+        const HRESULT res = LinuxSoundBuffer::Play(dwReserved1, dwReserved2, dwFlags);
+        SDL_PauseAudioDevice(myAudioDevice, 0);
+        return res;
     }
 
-    return info;
-  }
+    void DirectSoundGenerator::printInfo()
+    {
+        const uint32_t bytesInBuffer = GetBytesInBuffer();
+        std::cerr << "Channels: " << (int)myAudioSpec.channels;
+        std::cerr << ", buffer: " << std::setw(6) << bytesInBuffer;
+        const double time = double(bytesInBuffer) / myBytesPerSecond * 1000;
+        std::cerr << ", " << std::setw(8) << time << " ms";
+        std::cerr << ", underruns: " << std::setw(10) << GetBufferUnderruns() << std::endl;
+    }
 
-  uint8_t * DirectSoundGenerator::mixBufferTo(uint8_t * stream)
-  {
-    // we could copy ADJUST_VOLUME from SDL_mixer.c and avoid all copying and (rare) race conditions
-    const double logVolume = GetLogarithmicVolume();
-    // same formula as QAudio::convertVolume()
-    const double linVolume = logVolume > 0.99 ? 1.0 : -std::log(1.0 - logVolume) / std::log(100.0);
-    const uint8_t svolume = uint8_t(linVolume * SDL_MIX_MAXVOLUME);
+    sa2::SoundInfo DirectSoundGenerator::getInfo()
+    {
+        DWORD dwStatus;
+        GetStatus(&dwStatus);
+
+        sa2::SoundInfo info;
+        info.voiceName = myVoiceName;
+        info.running = dwStatus & DSBSTATUS_PLAYING;
+        info.channels = myChannels;
+        info.volume = GetLogarithmicVolume();
+        info.numberOfUnderruns = GetBufferUnderruns();
+
+        if (info.running && myBytesPerSecond > 0)
+        {
+            const uint32_t bytesInBuffer = GetBytesInBuffer();
+            const float coeff = 1.0 / myBytesPerSecond;
+            info.buffer = bytesInBuffer * coeff;
+            info.size = myBufferSize * coeff;
+        }
+
+        return info;
+    }
 
-    const size_t len = myMixerBuffer.size();
-    memset(stream, 0, len);
-    SDL_MixAudioFormat(stream, myMixerBuffer.data(), myAudioSpec.format, len, svolume);
-    return stream + len;
-  }
+    uint8_t *DirectSoundGenerator::mixBufferTo(uint8_t *stream)
+    {
+        // we could copy ADJUST_VOLUME from SDL_mixer.c and avoid all copying and (rare) race conditions
+        const double logVolume = GetLogarithmicVolume();
+        // same formula as QAudio::convertVolume()
+        const double linVolume = logVolume > 0.99 ? 1.0 : -std::log(1.0 - logVolume) / std::log(100.0);
+        const uint8_t svolume = uint8_t(linVolume * SDL_MIX_MAXVOLUME);
+
+        const size_t len = myMixerBuffer.size();
+        memset(stream, 0, len);
+        SDL_MixAudioFormat(stream, myMixerBuffer.data(), myAudioSpec.format, len, svolume);
+        return stream + len;
+    }
 
-}
+} // namespace
 
 namespace sa2
 {
 
-  std::shared_ptr<SoundBuffer> iCreateDirectSoundBuffer(uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char* pszVoiceName)
-  {
-    try
+    std::shared_ptr<SoundBuffer> iCreateDirectSoundBuffer(
+        uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char *pszVoiceName)
     {
-      const char * deviceName = audioDeviceName.empty() ? nullptr : audioDeviceName.c_str();
-
-      std::shared_ptr<DirectSoundGenerator> generator = std::make_shared<DirectSoundGenerator>(
-        dwBufferSize, nSampleRate, nChannels, pszVoiceName, deviceName, audioBuffer);
-      DirectSoundGenerator * ptr = generator.get();
-      activeSoundGenerators.insert(ptr);
-      return generator;
+        try
+        {
+            const char *deviceName = audioDeviceName.empty() ? nullptr : audioDeviceName.c_str();
+
+            std::shared_ptr<DirectSoundGenerator> generator = std::make_shared<DirectSoundGenerator>(
+                dwBufferSize, nSampleRate, nChannels, pszVoiceName, deviceName, audioBuffer);
+            DirectSoundGenerator *ptr = generator.get();
+            activeSoundGenerators.insert(ptr);
+            return generator;
+        }
+        catch (const std::exception &e)
+        {
+            // once this fails, no point in trying again next time
+            g_bDisableDirectSound = true;
+            g_bDisableDirectSoundMockingboard = true;
+            LogOutput("SoundBuffer: %s\n", e.what());
+            return nullptr;
+        }
     }
-    catch (const std::exception & e)
+
+    void printAudioInfo()
     {
-      // once this fails, no point in trying again next time
-      g_bDisableDirectSound = true;
-      g_bDisableDirectSoundMockingboard = true;
-      LogOutput("SoundBuffer: %s\n", e.what());
-      return nullptr;
+        for (const auto &it : activeSoundGenerators)
+        {
+            const auto &generator = it;
+            generator->printInfo();
+        }
     }
-  }
 
-  void printAudioInfo()
-  {
-    for (const auto & it : activeSoundGenerators)
+    void resetAudioUnderruns()
     {
-      const auto & generator = it;
-      generator->printInfo();
+        for (const auto &it : activeSoundGenerators)
+        {
+            const auto &generator = it;
+            generator->ResetUnderruns();
+        }
     }
-  }
 
-  void resetAudioUnderruns()
-  {
-    for (const auto & it : activeSoundGenerators)
+    std::vector<SoundInfo> getAudioInfo()
     {
-      const auto & generator = it;
-      generator->ResetUnderruns();
-    }
-  }
+        std::vector<SoundInfo> info;
+        info.reserve(activeSoundGenerators.size());
 
-  std::vector<SoundInfo> getAudioInfo()
-  {
-    std::vector<SoundInfo> info;
-    info.reserve(activeSoundGenerators.size());
+        for (const auto &it : activeSoundGenerators)
+        {
+            const auto &generator = it;
+            info.push_back(generator->getInfo());
+        }
 
-    for (const auto & it : activeSoundGenerators)
-    {
-      const auto & generator = it;
-      info.push_back(generator->getInfo());
+        return info;
     }
 
-    return info;
-  }
-
-  void setAudioOptions(const common2::EmulatorOptions & options)
-  {
-    audioDeviceName = options.audioDeviceName;
-    audioBuffer = options.audioBuffer;
-  }
+    void setAudioOptions(const common2::EmulatorOptions &options)
+    {
+        audioDeviceName = options.audioDeviceName;
+        audioBuffer = options.audioBuffer;
+    }
 
-}
+} // namespace sa2
diff --git a/source/frontends/sdl/sdirectsound.h b/source/frontends/sdl/sdirectsound.h
index 4ff5ce707..48b8e7c15 100644
--- a/source/frontends/sdl/sdirectsound.h
+++ b/source/frontends/sdl/sdirectsound.h
@@ -8,32 +8,33 @@ class SoundBuffer;
 
 namespace common2
 {
-  struct EmulatorOptions;
+    struct EmulatorOptions;
 }
 
 namespace sa2
 {
 
-  struct SoundInfo
-  {
-    bool running = false;
-    std::string voiceName;
-    int channels = 0;
+    struct SoundInfo
+    {
+        bool running = false;
+        std::string voiceName;
+        int channels = 0;
 
-    // in seconds
-    // float to work with ImGui.
-    float buffer = 0.0;
-    float size = 0.0;
-    float volume = 0.0;
+        // in seconds
+        // float to work with ImGui.
+        float buffer = 0.0;
+        float size = 0.0;
+        float volume = 0.0;
 
-    size_t numberOfUnderruns = 0;
-  };
+        size_t numberOfUnderruns = 0;
+    };
 
-  std::shared_ptr<SoundBuffer> iCreateDirectSoundBuffer(uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char* pszVoiceName);
+    std::shared_ptr<SoundBuffer> iCreateDirectSoundBuffer(
+        uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char *pszVoiceName);
 
-  void resetAudioUnderruns();
-  void printAudioInfo();
-  std::vector<SoundInfo> getAudioInfo();
+    void resetAudioUnderruns();
+    void printAudioInfo();
+    std::vector<SoundInfo> getAudioInfo();
 
-  void setAudioOptions(const common2::EmulatorOptions & options);
-}
+    void setAudioOptions(const common2::EmulatorOptions &options);
+} // namespace sa2
diff --git a/source/frontends/sdl/sdlframe.cpp b/source/frontends/sdl/sdlframe.cpp
index afe0a5783..b05d716e9 100644
--- a/source/frontends/sdl/sdlframe.cpp
+++ b/source/frontends/sdl/sdlframe.cpp
@@ -31,670 +31,671 @@
 namespace
 {
 
-  void processAppleKey(const SDL_KeyboardEvent & key, const bool forceCapsLock)
-  {
-    // using keycode (or scan code) one takes a physical view of the keyboard
-    // ignoring non US layouts
-    // SHIFT-3 on a A2 keyboard in # while on my UK keyboard is £?
-    // so for now all ASCII keys are handled as text below
-    // but this makes it impossible to detect CTRL-ASCII... more to follow
-    BYTE ch = 0;
-
-    switch (key.keysym.sym)
+    void processAppleKey(const SDL_KeyboardEvent &key, const bool forceCapsLock)
     {
-    case SDLK_RETURN:
-    case SDLK_KP_ENTER:
-      {
-        ch = 0x0d;
-        break;
-      }
+        // using keycode (or scan code) one takes a physical view of the keyboard
+        // ignoring non US layouts
+        // SHIFT-3 on a A2 keyboard in # while on my UK keyboard is £?
+        // so for now all ASCII keys are handled as text below
+        // but this makes it impossible to detect CTRL-ASCII... more to follow
+        BYTE ch = 0;
+
+        switch (key.keysym.sym)
+        {
+        case SDLK_RETURN:
+        case SDLK_KP_ENTER:
+        {
+            ch = 0x0d;
+            break;
+        }
 #ifndef __APPLE__
-    // On macOS, the [delete] key emits SDLK_BACKSPACE but we want to map it to DEL (0x7F)
-    case SDLK_BACKSPACE: // same as AppleWin
+        // On macOS, the [delete] key emits SDLK_BACKSPACE but we want to map it to DEL (0x7F)
+        case SDLK_BACKSPACE: // same as AppleWin
 #endif
-    case SDLK_LEFT:
-      {
-        ch = 0x08;
-        break;
-      }
-    case SDLK_RIGHT:
-      {
-        ch = 0x15;
-        break;
-      }
-    case SDLK_UP:
-      {
-        ch = 0x0b;
-        break;
-      }
-    case SDLK_DOWN:
-      {
-        ch = 0x0a;
-        break;
-      }
+        case SDLK_LEFT:
+        {
+            ch = 0x08;
+            break;
+        }
+        case SDLK_RIGHT:
+        {
+            ch = 0x15;
+            break;
+        }
+        case SDLK_UP:
+        {
+            ch = 0x0b;
+            break;
+        }
+        case SDLK_DOWN:
+        {
+            ch = 0x0a;
+            break;
+        }
 #ifdef __APPLE__
-    // On macOS, the [delete] key emits SDLK_BACKSPACE but we want to map it to DEL (0x7F)
-    case SDLK_BACKSPACE:
+        // On macOS, the [delete] key emits SDLK_BACKSPACE but we want to map it to DEL (0x7F)
+        case SDLK_BACKSPACE:
 #endif
-    case SDLK_DELETE:
-      {
-        ch = 0x7f;
-        break;
-      }
-    case SDLK_ESCAPE:
-      {
-        ch = 0x1b;
-        break;
-      }
-    case SDLK_TAB:
-      {
-        ch = 0x09;
-        break;
-      }
-    case SDLK_a ... SDLK_z:
-      {
-        // same logic as AW
-        // CAPS is forced when the emulator starts
-        // until is used the first time
-        const bool capsLock = forceCapsLock || (SDL_GetModState() & KMOD_CAPS);
-        const bool upper = capsLock || (key.keysym.mod & KMOD_SHIFT);
-
-        ch = (key.keysym.sym - SDLK_a) + 0x01;
-        if (key.keysym.mod & KMOD_CTRL)
-        {
-          // ok
-        }
-        else if (upper)
-        {
-          ch += 0x40; // upper case
+        case SDLK_DELETE:
+        {
+            ch = 0x7f;
+            break;
         }
-        else
+        case SDLK_ESCAPE:
         {
-          ch += 0x60; // lower case
+            ch = 0x1b;
+            break;
+        }
+        case SDLK_TAB:
+        {
+            ch = 0x09;
+            break;
+        }
+        case SDLK_a ... SDLK_z:
+        {
+            // same logic as AW
+            // CAPS is forced when the emulator starts
+            // until is used the first time
+            const bool capsLock = forceCapsLock || (SDL_GetModState() & KMOD_CAPS);
+            const bool upper = capsLock || (key.keysym.mod & KMOD_SHIFT);
+
+            ch = (key.keysym.sym - SDLK_a) + 0x01;
+            if (key.keysym.mod & KMOD_CTRL)
+            {
+                // ok
+            }
+            else if (upper)
+            {
+                ch += 0x40; // upper case
+            }
+            else
+            {
+                ch += 0x60; // lower case
+            }
+            break;
+        }
         }
-        break;
-      }
-    }
 
-    if (ch)
-    {
-      addKeyToBuffer(ch);
+        if (ch)
+        {
+            addKeyToBuffer(ch);
 #ifdef KEY_LOGGING_VERBOSE
-      LogOutput("SDL KeyboardEvent: %02x\n", ch);
+            LogOutput("SDL KeyboardEvent: %02x\n", ch);
 #endif
+        }
     }
-  }
 
-}
+} // namespace
 
 namespace sa2
 {
 
-  SDLFrame::SDLFrame(const common2::EmulatorOptions & options)
-    : common2::GNUFrame(options)
-    , myTargetGLSwap(options.glSwapInterval)
-    , myPreserveAspectRatio(options.aspectRatio)
-    , myForceCapsLock(true)
-    , myMultiplier(1)
-    , myFullscreen(false)
-    , myDragAndDropSlot(SLOT6)
-    , myDragAndDropDrive(DRIVE_1)
-    , myScrollLockFullSpeed(false)
-    , myPortFwds(getPortFwds(options.natPortFwds))
-  {
-  }
-
-  void SDLFrame::SetGLSynchronisation(const common2::EmulatorOptions & options)
-  {
-    const int defaultGLSwap = SDL_GL_GetSwapInterval();
-    if (defaultGLSwap == 0)
+    SDLFrame::SDLFrame(const common2::EmulatorOptions &options)
+        : common2::GNUFrame(options)
+        , myTargetGLSwap(options.glSwapInterval)
+        , myPreserveAspectRatio(options.aspectRatio)
+        , myForceCapsLock(true)
+        , myMultiplier(1)
+        , myFullscreen(false)
+        , myDragAndDropSlot(SLOT6)
+        , myDragAndDropDrive(DRIVE_1)
+        , myScrollLockFullSpeed(false)
+        , myPortFwds(getPortFwds(options.natPortFwds))
     {
-      // sane default
-      mySynchroniseWithTimer = true;
-      myTargetGLSwap = 0;
     }
-    else if (options.syncWithTimer)
+
+    void SDLFrame::SetGLSynchronisation(const common2::EmulatorOptions &options)
     {
-      mySynchroniseWithTimer = true;
-      myTargetGLSwap = 0;
+        const int defaultGLSwap = SDL_GL_GetSwapInterval();
+        if (defaultGLSwap == 0)
+        {
+            // sane default
+            mySynchroniseWithTimer = true;
+            myTargetGLSwap = 0;
+        }
+        else if (options.syncWithTimer)
+        {
+            mySynchroniseWithTimer = true;
+            myTargetGLSwap = 0;
+        }
+        else
+        {
+            mySynchroniseWithTimer = false;
+            myTargetGLSwap = options.glSwapInterval;
+        }
     }
-    else
+
+    void SDLFrame::End()
     {
-      mySynchroniseWithTimer = false;
-      myTargetGLSwap = options.glSwapInterval;
+        CommonFrame::End();
+        if (!myFullscreen)
+        {
+            common2::Geometry geometry;
+            SDL_GetWindowPosition(myWindow.get(), &geometry.x, &geometry.y);
+            SDL_GetWindowSize(myWindow.get(), &geometry.width, &geometry.height);
+            saveGeometryToRegistry("sa2", geometry);
+        }
     }
-  }
 
-  void SDLFrame::End()
-  {
-    CommonFrame::End();
-    if (!myFullscreen)
+    void SDLFrame::setGLSwapInterval(const int interval)
     {
-      common2::Geometry geometry;
-      SDL_GetWindowPosition(myWindow.get(), &geometry.x, &geometry.y);
-      SDL_GetWindowSize(myWindow.get(), &geometry.width, &geometry.height);
-      saveGeometryToRegistry("sa2", geometry);
+        const int current = SDL_GL_GetSwapInterval();
+        // in QEMU with GL_RENDERER: llvmpipe (LLVM 12.0.0, 256 bits)
+        // SDL_GL_SetSwapInterval() always fails
+        if (interval != current && SDL_GL_SetSwapInterval(interval))
+        {
+            throw std::runtime_error(decorateSDLError("SDL_GL_SetSwapInterval"));
+        }
     }
-  }
-
-  void SDLFrame::setGLSwapInterval(const int interval)
-  {
-    const int current = SDL_GL_GetSwapInterval();
-    // in QEMU with GL_RENDERER: llvmpipe (LLVM 12.0.0, 256 bits)
-    // SDL_GL_SetSwapInterval() always fails
-    if (interval != current && SDL_GL_SetSwapInterval(interval))
+
+    void SDLFrame::Begin()
     {
-      throw std::runtime_error(decorateSDLError("SDL_GL_SetSwapInterval"));
+        CommonFrame::Begin();
+        setGLSwapInterval(myTargetGLSwap);
     }
-  }
 
-  void SDLFrame::Begin()
-  {
-    CommonFrame::Begin();
-    setGLSwapInterval(myTargetGLSwap);
-  }
-
-  void SDLFrame::FrameRefreshStatus(int drawflags)
-  {
-    if (drawflags & DRAW_TITLE)
+    void SDLFrame::FrameRefreshStatus(int drawflags)
     {
-      GetAppleWindowTitle();
-      SDL_SetWindowTitle(myWindow.get(), g_pAppTitle.c_str());
+        if (drawflags & DRAW_TITLE)
+        {
+            GetAppleWindowTitle();
+            SDL_SetWindowTitle(myWindow.get(), g_pAppTitle.c_str());
+        }
     }
-  }
 
-  void SDLFrame::SetApplicationIcon()
-  {
-    const auto resource = GetResourceData(IDC_APPLEWIN_ICON);
+    void SDLFrame::SetApplicationIcon()
+    {
+        const auto resource = GetResourceData(IDC_APPLEWIN_ICON);
 
-    SDL_RWops * ops = SDL_RWFromConstMem(resource.first, resource.second);
+        SDL_RWops *ops = SDL_RWFromConstMem(resource.first, resource.second);
 
-    std::shared_ptr<SDL_Surface> icon(IMG_Load_RW(ops, 1), SDL_FreeSurface);
-    if (icon)
-    {
-      SDL_SetWindowIcon(myWindow.get(), icon.get());
+        std::shared_ptr<SDL_Surface> icon(IMG_Load_RW(ops, 1), SDL_FreeSurface);
+        if (icon)
+        {
+            SDL_SetWindowIcon(myWindow.get(), icon.get());
+        }
     }
-  }
-
-  const std::shared_ptr<SDL_Window> & SDLFrame::GetWindow() const
-  {
-    return myWindow;
-  }
-
-  int SDLFrame::FrameMessageBox(LPCSTR lpText, LPCSTR lpCaption, UINT uType)
-  {
-    // tabs do not render properly
-    std::string s(lpText);
-    std::replace(s.begin(), s.end(), '\t', ' ');
-    SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, lpCaption, s.c_str(), nullptr);
-    ResetSpeed();
-    return IDOK;
-  }
-
-  void SDLFrame::ProcessEvents(bool &quit)
-  {
-    SDL_Event e;
-    while (SDL_PollEvent(&e) != 0)
+
+    const std::shared_ptr<SDL_Window> &SDLFrame::GetWindow() const
     {
-      ProcessSingleEvent(e, quit);
+        return myWindow;
     }
-  }
 
-  void SDLFrame::ProcessSingleEvent(const SDL_Event & e, bool &quit)
-  {
-    switch (e.type)
+    int SDLFrame::FrameMessageBox(LPCSTR lpText, LPCSTR lpCaption, UINT uType)
     {
-    case SDL_QUIT:
-      {
-        quit = true;
-        break;
-      }
-    case SDL_KEYDOWN:
-      {
-        ProcessKeyDown(e.key, quit);
-        break;
-      }
-    case SDL_KEYUP:
-      {
-        ProcessKeyUp(e.key);
-        break;
-      }
-    case SDL_TEXTINPUT:
-      {
-        ProcessText(e.text);
-        break;
-      }
-    case SDL_MOUSEBUTTONDOWN:
-    case SDL_MOUSEBUTTONUP:
-      {
-        ProcessMouseButton(e.button);
-        break;
-      }
-    case SDL_MOUSEMOTION:
-      {
-        ProcessMouseMotion(e.motion);
-        break;
-      }
-    case SDL_DROPFILE:
-      {
-        ProcessDropEvent(e.drop);
-        SDL_free(e.drop.file);
-        break;
-      }
-    case SDL_CONTROLLERBUTTONDOWN:
-      {
-        if (e.cbutton.button == SDL_CONTROLLER_BUTTON_BACK)  // SELECT
-        {
-          quit = myControllerQuit.pressButton();
-        }
-        break;
-      }
+        // tabs do not render properly
+        std::string s(lpText);
+        std::replace(s.begin(), s.end(), '\t', ' ');
+        SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, lpCaption, s.c_str(), nullptr);
+        ResetSpeed();
+        return IDOK;
     }
-  }
 
-  void SDLFrame::ProcessMouseButton(const SDL_MouseButtonEvent & event)
-  {
-    CardManager & cardManager = GetCardMgr();
-
-    if (cardManager.IsMouseCardInstalled() && cardManager.GetMouseCard()->IsActiveAndEnabled())
+    void SDLFrame::ProcessEvents(bool &quit)
     {
-      switch (event.button)
-      {
-      case SDL_BUTTON_LEFT:
-      case SDL_BUTTON_RIGHT:
+        SDL_Event e;
+        while (SDL_PollEvent(&e) != 0)
         {
-          const eBUTTONSTATE state = (event.state == SDL_PRESSED) ? BUTTON_DOWN : BUTTON_UP;
-          const eBUTTON button = (event.button == SDL_BUTTON_LEFT) ? BUTTON0 : BUTTON1;
-          cardManager.GetMouseCard()->SetButton(button, state);
-          break;
+            ProcessSingleEvent(e, quit);
         }
-      }
     }
-  }
-
-  float SDLFrame::GetRelativePosition(const float value, const float size)
-  {
-    // the minimum size of a window is 1
-    const float result = value / std::max(1.0f, size - 1.0f);
-    return result;
-  }
-
-  void SDLFrame::ProcessMouseMotion(const SDL_MouseMotionEvent & motion)
-  {
-    CardManager & cardManager = GetCardMgr();
 
-    if (cardManager.IsMouseCardInstalled() && cardManager.GetMouseCard()->IsActiveAndEnabled())
+    void SDLFrame::ProcessSingleEvent(const SDL_Event &e, bool &quit)
     {
-      int iX, iMinX, iMaxX;
-      int iY, iMinY, iMaxY;
-      cardManager.GetMouseCard()->GetXY(iX, iMinX, iMaxX, iY, iMinY, iMaxY);
-
-      int width, height;
-      SDL_GetWindowSize(myWindow.get(), &width, &height);
-      const bool relative = (iMaxX - iMinX == 32767) && (iMaxY - iMinY == 32767);
-
-      int dx, dy;
-      if (relative)
-      {
-        // in geos the screen in 280 * 2 mouse ticks in x and 192 in y
-        // everything works in relative motion
-        // so we do not know where the pointer is
-        //
-        // the risk is that we leave the SDL window before the guest pointer reaches the end
-        // and we stop receiving events
-        //
-        // we could call SDL_CaptureMouse(), but this interacts badly with ImGui
-        //
-        // so we make the guest pointer a bit faster (alpha > 1)
-        //
-        // at least the pointer moves at the right speed
-        // and with some gymnic, one can put it in the right place
-
-        const double sizeX = 280 * 2;
-        const double sizeY = 192;
-
-        const double relX = double(motion.xrel) / double(width) * sizeX;
-        const double relY = double(motion.yrel) / double(height) * sizeY;
-
-        const double alpha = 1.1;
-        dx = lround(relX * alpha);
-        dy = lround(relY * alpha);
-      }
-      else
-      {
-        const int sizeX = iMaxX - iMinX;
-        const int sizeY = iMaxY - iMinY;
-
-
-        float x, y;
-        GetRelativeMousePosition(motion, x, y);
-
-        const int newX = lround(x * sizeX) + iMinX;
-        const int newY = lround(y * sizeY) + iMinY;
-
-        dx = newX - iX;
-        dy = newY - iY;
-      }
-
-      int outOfBoundsX;
-      int outOfBoundsY;
-      cardManager.GetMouseCard()->SetPositionRel(dx, dy, &outOfBoundsX, &outOfBoundsY);
-    }
-  }
-
-  void SDLFrame::ProcessDropEvent(const SDL_DropEvent & drop)
-  {
-    processFile(this, drop.file, myDragAndDropSlot, myDragAndDropDrive);
-  }
-
-  void SDLFrame::ProcessKeyDown(const SDL_KeyboardEvent & key, bool &quit)
-  {
-    // scancode vs keycode
-    // scancode is relative to the position on the keyboard
-    // keycode is what the os maps it to
-    // if the user has decided to change the layout, we just go with it and use the keycode
-    if (!key.repeat)
-    {
-      const size_t modifiers = getCanonicalModifiers(key);
-      switch (key.keysym.sym)
-      {
-      case SDLK_F12:
-        {
-          if (modifiers == KMOD_NONE)
-          {
-            LoadSnapshot();
-          }
-          break;
-        }
-      case SDLK_F11:
-        {
-          if (modifiers == KMOD_NONE)
-          {
-            SaveSnapshot();
-          }
-          break;
-        }
-      case SDLK_F9:
-        {
-          if (modifiers == KMOD_NONE)
-          {
-            CycleVideoType();
-          }
-          else if (modifiers == KMOD_CTRL)
-          {
-            ToggleMouseCursor();
-          }
-          break;
-        }
-      case SDLK_F6:
-        {
-          if (modifiers == (KMOD_CTRL | KMOD_SHIFT))
-          {
-            Cycle50ScanLines();
-          }
-          else if (modifiers == KMOD_CTRL)
-          {
-            Video & video = GetVideo();
-            myMultiplier = myMultiplier == 1 ? 2 : 1;
-            const int sw = video.GetFrameBufferBorderlessWidth();
-            const int sh = video.GetFrameBufferBorderlessHeight();
-            SDL_SetWindowSize(myWindow.get(), sw * myMultiplier, sh * myMultiplier);
-          }
-          else if (modifiers == KMOD_NONE)
-          {
-            myFullscreen = !myFullscreen;
-            SDL_SetWindowFullscreen(myWindow.get(), myFullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
-          }
-          break;
-        }
-      case SDLK_F5:
-        {
-          if (modifiers == KMOD_NONE)
-          {
-            CardManager & cardManager = GetCardMgr();
-            if (cardManager.QuerySlot(SLOT6) == CT_Disk2)
-            {
-              dynamic_cast<Disk2InterfaceCard*>(cardManager.GetObj(SLOT6))->DriveSwap();
-            }
-          }
-          break;
-        }
-      case SDLK_F4:
+        switch (e.type)
+        {
+        case SDL_QUIT:
         {
-          if (modifiers == KMOD_ALT)
-          {
-            // In GNOME (and probably most Desktop Environments)
-            // we never get here: we receive instead a SDL_QUIT
-            // this is only a fallback for "other" environments
             quit = true;
-          }
-          break;
+            break;
         }
-      case SDLK_F2:
+        case SDL_KEYDOWN:
         {
-          if (modifiers == KMOD_CTRL)
-          {
-            CtrlReset();
-          }
-          else if (modifiers == KMOD_SHIFT)
-          {
-            quit = true;
-          }
-          else if (modifiers == KMOD_NONE)
-          {
-            FrameResetMachineState();
-          }
-          break;
+            ProcessKeyDown(e.key, quit);
+            break;
         }
-      case SDLK_F1:
+        case SDL_KEYUP:
         {
-          if (modifiers == KMOD_CTRL)
-          {
-            sa2::printAudioInfo();
-          }
-          break;
+            ProcessKeyUp(e.key);
+            break;
         }
-      case SDLK_LALT:
+        case SDL_TEXTINPUT:
         {
-          Paddle::setButtonPressed(Paddle::ourOpenApple);
-          break;
+            ProcessText(e.text);
+            break;
         }
-      case SDLK_RALT:
+        case SDL_MOUSEBUTTONDOWN:
+        case SDL_MOUSEBUTTONUP:
         {
-          Paddle::setButtonPressed(Paddle::ourSolidApple);
-          break;
+            ProcessMouseButton(e.button);
+            break;
         }
-      case SDLK_PAUSE:
+        case SDL_MOUSEMOTION:
         {
-          TogglePaused();
-          break;
+            ProcessMouseMotion(e.motion);
+            break;
         }
-      case SDLK_CAPSLOCK:
+        case SDL_DROPFILE:
         {
-          myForceCapsLock = false;
-          break;
+            ProcessDropEvent(e.drop);
+            SDL_free(e.drop.file);
+            break;
         }
-      case SDLK_INSERT:
+        case SDL_CONTROLLERBUTTONDOWN:
         {
-          if (modifiers == (KMOD_CTRL | KMOD_SHIFT))
-          {
-            Video_TakeScreenShot(Video::SCREENSHOT_560x384);
-          }
-          else if (modifiers ==  KMOD_SHIFT)
-          {
-            char * text = SDL_GetClipboardText();
-            if (text)
+            if (e.cbutton.button == SDL_CONTROLLER_BUTTON_BACK) // SELECT
             {
-              addTextToBuffer(text);
-              SDL_free(text);
+                quit = myControllerQuit.pressButton();
             }
-          }
-          else if (modifiers == KMOD_CTRL)
-          {
-            // in AppleWin this is Ctrl-PrintScreen
-            // but PrintScreen is not passed to SDL
-            char *pText;
-            const size_t size = Util_GetTextScreen(pText);
-            if (size)
+            break;
+        }
+        }
+    }
+
+    void SDLFrame::ProcessMouseButton(const SDL_MouseButtonEvent &event)
+    {
+        CardManager &cardManager = GetCardMgr();
+
+        if (cardManager.IsMouseCardInstalled() && cardManager.GetMouseCard()->IsActiveAndEnabled())
+        {
+            switch (event.button)
             {
-              SDL_SetClipboardText(pText);
+            case SDL_BUTTON_LEFT:
+            case SDL_BUTTON_RIGHT:
+            {
+                const eBUTTONSTATE state = (event.state == SDL_PRESSED) ? BUTTON_DOWN : BUTTON_UP;
+                const eBUTTON button = (event.button == SDL_BUTTON_LEFT) ? BUTTON0 : BUTTON1;
+                cardManager.GetMouseCard()->SetButton(button, state);
+                break;
+            }
             }
-          }
-          break;
         }
-      case SDLK_SCROLLLOCK:
+    }
+
+    float SDLFrame::GetRelativePosition(const float value, const float size)
+    {
+        // the minimum size of a window is 1
+        const float result = value / std::max(1.0f, size - 1.0f);
+        return result;
+    }
+
+    void SDLFrame::ProcessMouseMotion(const SDL_MouseMotionEvent &motion)
+    {
+        CardManager &cardManager = GetCardMgr();
+
+        if (cardManager.IsMouseCardInstalled() && cardManager.GetMouseCard()->IsActiveAndEnabled())
         {
-          myScrollLockFullSpeed = !myScrollLockFullSpeed;
-          break;
+            int iX, iMinX, iMaxX;
+            int iY, iMinY, iMaxY;
+            cardManager.GetMouseCard()->GetXY(iX, iMinX, iMaxX, iY, iMinY, iMaxY);
+
+            int width, height;
+            SDL_GetWindowSize(myWindow.get(), &width, &height);
+            const bool relative = (iMaxX - iMinX == 32767) && (iMaxY - iMinY == 32767);
+
+            int dx, dy;
+            if (relative)
+            {
+                // in geos the screen in 280 * 2 mouse ticks in x and 192 in y
+                // everything works in relative motion
+                // so we do not know where the pointer is
+                //
+                // the risk is that we leave the SDL window before the guest pointer reaches the end
+                // and we stop receiving events
+                //
+                // we could call SDL_CaptureMouse(), but this interacts badly with ImGui
+                //
+                // so we make the guest pointer a bit faster (alpha > 1)
+                //
+                // at least the pointer moves at the right speed
+                // and with some gymnic, one can put it in the right place
+
+                const double sizeX = 280 * 2;
+                const double sizeY = 192;
+
+                const double relX = double(motion.xrel) / double(width) * sizeX;
+                const double relY = double(motion.yrel) / double(height) * sizeY;
+
+                const double alpha = 1.1;
+                dx = lround(relX * alpha);
+                dy = lround(relY * alpha);
+            }
+            else
+            {
+                const int sizeX = iMaxX - iMinX;
+                const int sizeY = iMaxY - iMinY;
+
+                float x, y;
+                GetRelativeMousePosition(motion, x, y);
+
+                const int newX = lround(x * sizeX) + iMinX;
+                const int newY = lround(y * sizeY) + iMinY;
+
+                dx = newX - iX;
+                dy = newY - iY;
+            }
+
+            int outOfBoundsX;
+            int outOfBoundsY;
+            cardManager.GetMouseCard()->SetPositionRel(dx, dy, &outOfBoundsX, &outOfBoundsY);
         }
-      }
     }
 
-    processAppleKey(key, myForceCapsLock);
-  }
+    void SDLFrame::ProcessDropEvent(const SDL_DropEvent &drop)
+    {
+        processFile(this, drop.file, myDragAndDropSlot, myDragAndDropDrive);
+    }
 
-  void SDLFrame::ProcessKeyUp(const SDL_KeyboardEvent & key)
-  {
-    switch (key.keysym.sym)
+    void SDLFrame::ProcessKeyDown(const SDL_KeyboardEvent &key, bool &quit)
     {
-    case SDLK_LALT:
-      {
-        Paddle::setButtonReleased(Paddle::ourOpenApple);
-        break;
-      }
-    case SDLK_RALT:
-      {
-        Paddle::setButtonReleased(Paddle::ourSolidApple);
-        break;
-      }
+        // scancode vs keycode
+        // scancode is relative to the position on the keyboard
+        // keycode is what the os maps it to
+        // if the user has decided to change the layout, we just go with it and use the keycode
+        if (!key.repeat)
+        {
+            const size_t modifiers = getCanonicalModifiers(key);
+            switch (key.keysym.sym)
+            {
+            case SDLK_F12:
+            {
+                if (modifiers == KMOD_NONE)
+                {
+                    LoadSnapshot();
+                }
+                break;
+            }
+            case SDLK_F11:
+            {
+                if (modifiers == KMOD_NONE)
+                {
+                    SaveSnapshot();
+                }
+                break;
+            }
+            case SDLK_F9:
+            {
+                if (modifiers == KMOD_NONE)
+                {
+                    CycleVideoType();
+                }
+                else if (modifiers == KMOD_CTRL)
+                {
+                    ToggleMouseCursor();
+                }
+                break;
+            }
+            case SDLK_F6:
+            {
+                if (modifiers == (KMOD_CTRL | KMOD_SHIFT))
+                {
+                    Cycle50ScanLines();
+                }
+                else if (modifiers == KMOD_CTRL)
+                {
+                    Video &video = GetVideo();
+                    myMultiplier = myMultiplier == 1 ? 2 : 1;
+                    const int sw = video.GetFrameBufferBorderlessWidth();
+                    const int sh = video.GetFrameBufferBorderlessHeight();
+                    SDL_SetWindowSize(myWindow.get(), sw * myMultiplier, sh * myMultiplier);
+                }
+                else if (modifiers == KMOD_NONE)
+                {
+                    myFullscreen = !myFullscreen;
+                    SDL_SetWindowFullscreen(myWindow.get(), myFullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);
+                }
+                break;
+            }
+            case SDLK_F5:
+            {
+                if (modifiers == KMOD_NONE)
+                {
+                    CardManager &cardManager = GetCardMgr();
+                    if (cardManager.QuerySlot(SLOT6) == CT_Disk2)
+                    {
+                        dynamic_cast<Disk2InterfaceCard *>(cardManager.GetObj(SLOT6))->DriveSwap();
+                    }
+                }
+                break;
+            }
+            case SDLK_F4:
+            {
+                if (modifiers == KMOD_ALT)
+                {
+                    // In GNOME (and probably most Desktop Environments)
+                    // we never get here: we receive instead a SDL_QUIT
+                    // this is only a fallback for "other" environments
+                    quit = true;
+                }
+                break;
+            }
+            case SDLK_F2:
+            {
+                if (modifiers == KMOD_CTRL)
+                {
+                    CtrlReset();
+                }
+                else if (modifiers == KMOD_SHIFT)
+                {
+                    quit = true;
+                }
+                else if (modifiers == KMOD_NONE)
+                {
+                    FrameResetMachineState();
+                }
+                break;
+            }
+            case SDLK_F1:
+            {
+                if (modifiers == KMOD_CTRL)
+                {
+                    sa2::printAudioInfo();
+                }
+                break;
+            }
+            case SDLK_LALT:
+            {
+                Paddle::setButtonPressed(Paddle::ourOpenApple);
+                break;
+            }
+            case SDLK_RALT:
+            {
+                Paddle::setButtonPressed(Paddle::ourSolidApple);
+                break;
+            }
+            case SDLK_PAUSE:
+            {
+                TogglePaused();
+                break;
+            }
+            case SDLK_CAPSLOCK:
+            {
+                myForceCapsLock = false;
+                break;
+            }
+            case SDLK_INSERT:
+            {
+                if (modifiers == (KMOD_CTRL | KMOD_SHIFT))
+                {
+                    Video_TakeScreenShot(Video::SCREENSHOT_560x384);
+                }
+                else if (modifiers == KMOD_SHIFT)
+                {
+                    char *text = SDL_GetClipboardText();
+                    if (text)
+                    {
+                        addTextToBuffer(text);
+                        SDL_free(text);
+                    }
+                }
+                else if (modifiers == KMOD_CTRL)
+                {
+                    // in AppleWin this is Ctrl-PrintScreen
+                    // but PrintScreen is not passed to SDL
+                    char *pText;
+                    const size_t size = Util_GetTextScreen(pText);
+                    if (size)
+                    {
+                        SDL_SetClipboardText(pText);
+                    }
+                }
+                break;
+            }
+            case SDLK_SCROLLLOCK:
+            {
+                myScrollLockFullSpeed = !myScrollLockFullSpeed;
+                break;
+            }
+            }
+        }
+
+        processAppleKey(key, myForceCapsLock);
+    }
+
+    void SDLFrame::ProcessKeyUp(const SDL_KeyboardEvent &key)
+    {
+        switch (key.keysym.sym)
+        {
+        case SDLK_LALT:
+        {
+            Paddle::setButtonReleased(Paddle::ourOpenApple);
+            break;
+        }
+        case SDLK_RALT:
+        {
+            Paddle::setButtonReleased(Paddle::ourSolidApple);
+            break;
+        }
+        }
     }
-  }
 
-  void SDLFrame::ProcessText(const SDL_TextInputEvent & text)
-  {
-    if (strlen(text.text) == 1)
+    void SDLFrame::ProcessText(const SDL_TextInputEvent &text)
     {
-      const char key = text.text[0];
-      switch (key) {
-      case 0x20 ... 0x40:
-      case 0x5b ... 0x60:
-      case 0x7b ... 0x7e:
-        {
-          // not the letters
-          // this is very simple, but one cannot handle CRTL-key combination.
-          addKeyToBuffer(key);
+        if (strlen(text.text) == 1)
+        {
+            const char key = text.text[0];
+            switch (key)
+            {
+            case 0x20 ... 0x40:
+            case 0x5b ... 0x60:
+            case 0x7b ... 0x7e:
+            {
+                // not the letters
+                // this is very simple, but one cannot handle CRTL-key combination.
+                addKeyToBuffer(key);
 #ifdef KEY_LOGGING_VERBOSE
-          LogOutput("SDL TextInputEvent: %02x\n", key);
+                LogOutput("SDL TextInputEvent: %02x\n", key);
 #endif
-          break;
+                break;
+            }
+            }
         }
-      }
     }
-  }
-
-  void SDLFrame::getDragDropSlotAndDrive(size_t & slot, size_t & drive) const
-  {
-    slot = myDragAndDropSlot;
-    drive = myDragAndDropDrive;
-  }
-
-  void SDLFrame::setDragDropSlotAndDrive(const size_t slot, const size_t drive)
-  {
-    myDragAndDropSlot = slot;
-    myDragAndDropDrive = drive;
-  }
-
-  bool & SDLFrame::getPreserveAspectRatio()
-  {
-    return myPreserveAspectRatio;
-  }
-
-  bool & SDLFrame::getAutoBoot()
-  {
-    return myAutoBoot;
-  }
-
-  void SDLFrame::SetFullSpeed(const bool value)
-  {
-    CommonFrame::SetFullSpeed(value);
-    if (g_bFullSpeed != value)
+
+    void SDLFrame::getDragDropSlotAndDrive(size_t &slot, size_t &drive) const
     {
-      if (value)
-      {
-        // entering full speed
-        setGLSwapInterval(0);
-      }
-      else
-      {
-        // leaving full speed
-        setGLSwapInterval(myTargetGLSwap);
-      }
+        slot = myDragAndDropSlot;
+        drive = myDragAndDropDrive;
+    }
+
+    void SDLFrame::setDragDropSlotAndDrive(const size_t slot, const size_t drive)
+    {
+        myDragAndDropSlot = slot;
+        myDragAndDropDrive = drive;
+    }
+
+    bool &SDLFrame::getPreserveAspectRatio()
+    {
+        return myPreserveAspectRatio;
+    }
+
+    bool &SDLFrame::getAutoBoot()
+    {
+        return myAutoBoot;
+    }
+
+    void SDLFrame::SetFullSpeed(const bool value)
+    {
+        CommonFrame::SetFullSpeed(value);
+        if (g_bFullSpeed != value)
+        {
+            if (value)
+            {
+                // entering full speed
+                setGLSwapInterval(0);
+            }
+            else
+            {
+                // leaving full speed
+                setGLSwapInterval(myTargetGLSwap);
+            }
+        }
+    }
+
+    bool SDLFrame::CanDoFullSpeed()
+    {
+        return myScrollLockFullSpeed || CommonFrame::CanDoFullSpeed();
+    }
+
+    void SDLFrame::FrameResetMachineState()
+    {
+        ResetMachineState(); // this changes g_bFullSpeed
+        ResetSpeed();
+    }
+
+    common2::Geometry SDLFrame::getGeometryOrDefault(const std::optional<common2::Geometry> &geometry) const
+    {
+        if (geometry)
+        {
+            return *geometry;
+        }
+
+        Video &video = GetVideo();
+        const int sw = video.GetFrameBufferBorderlessWidth();
+        const int sh = video.GetFrameBufferBorderlessHeight();
+
+        // initialise with defaults
+        common2::Geometry actual = {
+            .width = sw * 2, .height = sh * 2, .x = SDL_WINDOWPOS_UNDEFINED, .y = SDL_WINDOWPOS_UNDEFINED};
+
+        // add registry information
+        loadGeometryFromRegistry("sa2", actual);
+
+        return actual;
     }
-  }
-
-  bool SDLFrame::CanDoFullSpeed()
-  {
-    return myScrollLockFullSpeed || CommonFrame::CanDoFullSpeed();
-  }
-
-  void SDLFrame::FrameResetMachineState()
-  {
-    ResetMachineState();  // this changes g_bFullSpeed
-    ResetSpeed();
-  }
-
-  common2::Geometry SDLFrame::getGeometryOrDefault(const std::optional<common2::Geometry> & geometry) const
-  {
-    if (geometry)
+
+    std::shared_ptr<NetworkBackend> SDLFrame::CreateNetworkBackend(const std::string &interfaceName)
     {
-      return *geometry;
+#ifdef U2_USE_SLIRP
+        return std::make_shared<SlirpBackend>(myPortFwds);
+#else
+        return common2::GNUFrame::CreateNetworkBackend(interfaceName);
+#endif
     }
 
-    Video & video = GetVideo();
-    const int sw = video.GetFrameBufferBorderlessWidth();
-    const int sh = video.GetFrameBufferBorderlessHeight();
-
-    // initialise with defaults
-    common2::Geometry actual = {.width = sw * 2, .height = sh * 2, .x = SDL_WINDOWPOS_UNDEFINED, .y = SDL_WINDOWPOS_UNDEFINED};
-
-    // add registry information
-    loadGeometryFromRegistry("sa2", actual);
-
-    return actual;
-  }
-
-  std::shared_ptr<NetworkBackend> SDLFrame::CreateNetworkBackend(const std::string & interfaceName)
-  {
-    #ifdef U2_USE_SLIRP
-      return std::make_shared<SlirpBackend>(myPortFwds);
-    #else
-      return common2::GNUFrame::CreateNetworkBackend(interfaceName);
-    #endif
-  }
-
-  const common2::Speed & SDLFrame::getSpeed() const
-  {
-    return mySpeed;
-  }
-
-  void SDLFrame::SaveSnapshot()
-  {
-    const std::string & pathname = Snapshot_GetPathname();
-    const std::string message = "Do you want to save the state to: " + pathname + "?";
-    SoundCore_SetFade(FADE_OUT);
-    if (show_yes_no_dialog(myWindow, "Save state", message))
+    const common2::Speed &SDLFrame::getSpeed() const
     {
-      Snapshot_SaveState();
+        return mySpeed;
     }
-    SoundCore_SetFade(FADE_IN);
-    ResetSpeed();
-  }
 
-  std::shared_ptr<SoundBuffer> SDLFrame::CreateSoundBuffer(uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char* pszVoiceName)
-  {
-    const auto buffer = iCreateDirectSoundBuffer(dwBufferSize, nSampleRate, nChannels, pszVoiceName);
-    return buffer;
-  }
+    void SDLFrame::SaveSnapshot()
+    {
+        const std::string &pathname = Snapshot_GetPathname();
+        const std::string message = "Do you want to save the state to: " + pathname + "?";
+        SoundCore_SetFade(FADE_OUT);
+        if (show_yes_no_dialog(myWindow, "Save state", message))
+        {
+            Snapshot_SaveState();
+        }
+        SoundCore_SetFade(FADE_IN);
+        ResetSpeed();
+    }
 
-}
+    std::shared_ptr<SoundBuffer> SDLFrame::CreateSoundBuffer(
+        uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char *pszVoiceName)
+    {
+        const auto buffer = iCreateDirectSoundBuffer(dwBufferSize, nSampleRate, nChannels, pszVoiceName);
+        return buffer;
+    }
 
+} // namespace sa2
diff --git a/source/frontends/sdl/sdlframe.h b/source/frontends/sdl/sdlframe.h
index f80e5912f..634149d30 100644
--- a/source/frontends/sdl/sdlframe.h
+++ b/source/frontends/sdl/sdlframe.h
@@ -9,79 +9,80 @@
 namespace sa2
 {
 
-  class SDLFrame : public common2::GNUFrame
-  {
-  public:
-    SDLFrame(const common2::EmulatorOptions & options);
+    class SDLFrame : public common2::GNUFrame
+    {
+    public:
+        SDLFrame(const common2::EmulatorOptions &options);
 
-    void Begin() override;
-    void End() override;
+        void Begin() override;
+        void End() override;
 
-    void FrameRefreshStatus(int drawflags) override;
-    int FrameMessageBox(LPCSTR lpText, LPCSTR lpCaption, UINT uType) override;
-    std::shared_ptr<NetworkBackend> CreateNetworkBackend(const std::string & interfaceName) override;
+        void FrameRefreshStatus(int drawflags) override;
+        int FrameMessageBox(LPCSTR lpText, LPCSTR lpCaption, UINT uType) override;
+        std::shared_ptr<NetworkBackend> CreateNetworkBackend(const std::string &interfaceName) override;
 
-  	// create an object to write sound output to
-	  std::shared_ptr<SoundBuffer> CreateSoundBuffer(uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char* pszVoiceName) override;
+        // create an object to write sound output to
+        std::shared_ptr<SoundBuffer> CreateSoundBuffer(
+            uint32_t dwBufferSize, uint32_t nSampleRate, int nChannels, const char *pszVoiceName) override;
 
-    virtual bool Quit() const = 0;
+        virtual bool Quit() const = 0;
 
-    void ProcessEvents(bool &quit);
+        void ProcessEvents(bool &quit);
 
-    void FrameResetMachineState();
+        void FrameResetMachineState();
 
-    const std::shared_ptr<SDL_Window> & GetWindow() const;
+        const std::shared_ptr<SDL_Window> &GetWindow() const;
 
-    void getDragDropSlotAndDrive(size_t & slot, size_t & drive) const;
-    void setDragDropSlotAndDrive(const size_t slot, const size_t drive);
+        void getDragDropSlotAndDrive(size_t &slot, size_t &drive) const;
+        void setDragDropSlotAndDrive(const size_t slot, const size_t drive);
 
-    bool & getPreserveAspectRatio();
-    bool & getAutoBoot();
+        bool &getPreserveAspectRatio();
+        bool &getAutoBoot();
 
-    const common2::Speed & getSpeed() const;
+        const common2::Speed &getSpeed() const;
 
-    void SaveSnapshot();
+        void SaveSnapshot();
 
-    static void setGLSwapInterval(const int interval);
+        static void setGLSwapInterval(const int interval);
 
-  protected:
-    void SetApplicationIcon();
-    void SetGLSynchronisation(const common2::EmulatorOptions & options);
+    protected:
+        void SetApplicationIcon();
+        void SetGLSynchronisation(const common2::EmulatorOptions &options);
 
-    virtual void ProcessSingleEvent(const SDL_Event & event, bool & quit);
-    virtual void GetRelativeMousePosition(const SDL_MouseMotionEvent & motion, float & x, float & y) const = 0;
-    virtual void ProcessKeyDown(const SDL_KeyboardEvent & key, bool &quit);
-    virtual void ToggleMouseCursor() = 0;
+        virtual void ProcessSingleEvent(const SDL_Event &event, bool &quit);
+        virtual void GetRelativeMousePosition(const SDL_MouseMotionEvent &motion, float &x, float &y) const = 0;
+        virtual void ProcessKeyDown(const SDL_KeyboardEvent &key, bool &quit);
+        virtual void ToggleMouseCursor() = 0;
 
-    void ProcessKeyUp(const SDL_KeyboardEvent & key);
-    void ProcessText(const SDL_TextInputEvent & text);
-    void ProcessDropEvent(const SDL_DropEvent & drop);
-    void ProcessMouseButton(const SDL_MouseButtonEvent & button);
-    void ProcessMouseMotion(const SDL_MouseMotionEvent & motion);
+        void ProcessKeyUp(const SDL_KeyboardEvent &key);
+        void ProcessText(const SDL_TextInputEvent &text);
+        void ProcessDropEvent(const SDL_DropEvent &drop);
+        void ProcessMouseButton(const SDL_MouseButtonEvent &button);
+        void ProcessMouseMotion(const SDL_MouseMotionEvent &motion);
 
-    void SetFullSpeed(const bool value) override;
-    bool CanDoFullSpeed() override;
+        void SetFullSpeed(const bool value) override;
+        bool CanDoFullSpeed() override;
 
-    common2::Geometry getGeometryOrDefault(const std::optional<common2::Geometry> & geometry) const;
+        common2::Geometry getGeometryOrDefault(const std::optional<common2::Geometry> &geometry) const;
 
-    static float GetRelativePosition(const float value, const float size);
+        static float GetRelativePosition(const float value, const float size);
 
-    int myTargetGLSwap;
-    bool myPreserveAspectRatio;
-    bool myForceCapsLock;
-    int myMultiplier;
-    bool myFullscreen;
+        int myTargetGLSwap;
+        bool myPreserveAspectRatio;
+        bool myForceCapsLock;
+        int myMultiplier;
+        bool myFullscreen;
 
-    size_t myDragAndDropSlot;
-    size_t myDragAndDropDrive;
+        size_t myDragAndDropSlot;
+        size_t myDragAndDropDrive;
 
-    bool myScrollLockFullSpeed;
+        bool myScrollLockFullSpeed;
 
-    std::vector<PortFwd> myPortFwds;
+        std::vector<PortFwd> myPortFwds;
 
-    std::shared_ptr<SDL_Window> myWindow;
+        std::shared_ptr<SDL_Window> myWindow;
 
-    common2::ControllerDoublePress myControllerQuit;
-  };
+        common2::ControllerDoublePress myControllerQuit;
+    };
 
-}
+} // namespace sa2
diff --git a/source/frontends/sdl/utils.cpp b/source/frontends/sdl/utils.cpp
index 4d8d0a719..7c8be2560 100644
--- a/source/frontends/sdl/utils.cpp
+++ b/source/frontends/sdl/utils.cpp
@@ -6,138 +6,129 @@
 namespace sa2
 {
 
-  void printVideoInfo(std::ostream & os)
-  {
-    os << "SDL Video driver (SDL_VIDEODRIVER): " << SDL_GetCurrentVideoDriver() << std::endl;
-    for (int i = 0; i < SDL_GetNumVideoDrivers(); ++i)
+    void printVideoInfo(std::ostream &os)
     {
-      os << INDENT << SDL_GetVideoDriver(i) << std::endl;
+        os << "SDL Video driver (SDL_VIDEODRIVER): " << SDL_GetCurrentVideoDriver() << std::endl;
+        for (int i = 0; i < SDL_GetNumVideoDrivers(); ++i)
+        {
+            os << INDENT << SDL_GetVideoDriver(i) << std::endl;
+        }
     }
-  }
 
-  void printAudioInfo(std::ostream & os)
-  {
-    os << "SDL Audio driver (SDL_AUDIODRIVER): " << SDL_GetCurrentAudioDriver() << std::endl;
-    for (int i = 0; i < SDL_GetNumAudioDrivers(); ++i)
+    void printAudioInfo(std::ostream &os)
     {
-      os << INDENT << SDL_GetAudioDriver(i) << std::endl;
-    }
+        os << "SDL Audio driver (SDL_AUDIODRIVER): " << SDL_GetCurrentAudioDriver() << std::endl;
+        for (int i = 0; i < SDL_GetNumAudioDrivers(); ++i)
+        {
+            os << INDENT << SDL_GetAudioDriver(i) << std::endl;
+        }
+
+        os << "SDL Audio device: ";
 
-    os << "SDL Audio device: ";
-    
-    const int iscapture = 0;
+        const int iscapture = 0;
 
 #if SDL_VERSION_ATLEAST(2, 24, 0)
-    char *defaultDevice = nullptr;
-    SDL_AudioSpec spec;
-    if (!SDL_GetDefaultAudioInfo(&defaultDevice, &spec, iscapture))
-    {
-      os << defaultDevice;
-      SDL_free(defaultDevice);
-    }
-    else
+        char *defaultDevice = nullptr;
+        SDL_AudioSpec spec;
+        if (!SDL_GetDefaultAudioInfo(&defaultDevice, &spec, iscapture))
+        {
+            os << defaultDevice;
+            SDL_free(defaultDevice);
+        }
+        else
 #endif
 
-    {
-      os << "<default>";
-    }
-    os << std::endl;
+        {
+            os << "<default>";
+        }
+        os << std::endl;
 
-    for (int i = 0; i < SDL_GetNumAudioDevices(iscapture); ++i)
-    {
-      os << INDENT << SDL_GetAudioDeviceName(i, iscapture) << std::endl;
-    }
-  }
-
-  void printRendererInfo(std::ostream & os,
-                         const std::shared_ptr<SDL_Renderer> & ren,
-                         const SDL_PixelFormatEnum pixelFormat,
-                         const int selectedDriver)
-  {
-    SDL_RendererInfo info;
-    SDL_GetRendererInfo(ren.get(), &info);
-
-    const size_t n = SDL_GetNumRenderDrivers();
-    os << "SDL Render driver:" << std::endl;
-    for(size_t i = 0; i < n; ++i)
-    {
-      SDL_RendererInfo info;
-      SDL_GetRenderDriverInfo(i, &info);
-      os << INDENT << i << ": " << info.name << std::endl;
+        for (int i = 0; i < SDL_GetNumAudioDevices(iscapture); ++i)
+        {
+            os << INDENT << SDL_GetAudioDeviceName(i, iscapture) << std::endl;
+        }
     }
 
-    if (SDL_GetRendererInfo(ren.get(), &info) == 0)
+    void printRendererInfo(
+        std::ostream &os, const std::shared_ptr<SDL_Renderer> &ren, const SDL_PixelFormatEnum pixelFormat,
+        const int selectedDriver)
     {
-      os << "Active driver (" << selectedDriver << "): " << info.name << std::endl;
-      os << INDENT << "SDL_RENDERER_SOFTWARE: " << ((info.flags & SDL_RENDERER_SOFTWARE) > 0) << std::endl;
-      os << INDENT << "SDL_RENDERER_ACCELERATED: " << ((info.flags & SDL_RENDERER_ACCELERATED) > 0) << std::endl;
-      os << INDENT << "SDL_RENDERER_PRESENTVSYNC: " << ((info.flags & SDL_RENDERER_PRESENTVSYNC) > 0) << std::endl;
-      os << INDENT << "SDL_RENDERER_TARGETTEXTURE: " << ((info.flags & SDL_RENDERER_TARGETTEXTURE) > 0) << std::endl;
-
-      os << "Pixel format: " << SDL_GetPixelFormatName(pixelFormat) << std::endl;
-      for (size_t i = 0; i < info.num_texture_formats; ++i)
-      {
-        os << INDENT << SDL_GetPixelFormatName(info.texture_formats[i]) << std::endl;
-      }
+        SDL_RendererInfo info;
+        SDL_GetRendererInfo(ren.get(), &info);
+
+        const size_t n = SDL_GetNumRenderDrivers();
+        os << "SDL Render driver:" << std::endl;
+        for (size_t i = 0; i < n; ++i)
+        {
+            SDL_RendererInfo info;
+            SDL_GetRenderDriverInfo(i, &info);
+            os << INDENT << i << ": " << info.name << std::endl;
+        }
+
+        if (SDL_GetRendererInfo(ren.get(), &info) == 0)
+        {
+            os << "Active driver (" << selectedDriver << "): " << info.name << std::endl;
+            os << INDENT << "SDL_RENDERER_SOFTWARE: " << ((info.flags & SDL_RENDERER_SOFTWARE) > 0) << std::endl;
+            os << INDENT << "SDL_RENDERER_ACCELERATED: " << ((info.flags & SDL_RENDERER_ACCELERATED) > 0) << std::endl;
+            os << INDENT << "SDL_RENDERER_PRESENTVSYNC: " << ((info.flags & SDL_RENDERER_PRESENTVSYNC) > 0)
+               << std::endl;
+            os << INDENT << "SDL_RENDERER_TARGETTEXTURE: " << ((info.flags & SDL_RENDERER_TARGETTEXTURE) > 0)
+               << std::endl;
+
+            os << "Pixel format: " << SDL_GetPixelFormatName(pixelFormat) << std::endl;
+            for (size_t i = 0; i < info.num_texture_formats; ++i)
+            {
+                os << INDENT << SDL_GetPixelFormatName(info.texture_formats[i]) << std::endl;
+            }
+        }
+        else
+        {
+            os << "No Renderinfo" << std::endl;
+        }
     }
-    else
+
+    bool show_yes_no_dialog(const std::shared_ptr<SDL_Window> &win, const std::string &title, const std::string &text)
     {
-      os << "No Renderinfo" << std::endl;
-    }
-  }
-
-  bool show_yes_no_dialog(const std::shared_ptr<SDL_Window> & win,
-                          const std::string & title,
-                          const std::string & text)
-  {
-    const SDL_MessageBoxButtonData buttons[] =
-      {
-       { SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT, 0, "yes" },
-       { SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT, 1, "no" },
-      };
-
-    const SDL_MessageBoxData messageboxdata =
-      {
-       SDL_MESSAGEBOX_INFORMATION,
-       win.get(),
-       title.c_str(),
-       text.c_str(),
-       SDL_arraysize(buttons),
-       buttons,
-       nullptr
-      };
-
-    int buttonid;
-    if (SDL_ShowMessageBox(&messageboxdata, &buttonid) < 0) {
-      return false;
-    }
+        const SDL_MessageBoxButtonData buttons[] = {
+            {SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT, 0, "yes"},
+            {SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT, 1, "no"},
+        };
 
-    return buttonid == 0;
-  }
+        const SDL_MessageBoxData messageboxdata = {SDL_MESSAGEBOX_INFORMATION, win.get(), title.c_str(), text.c_str(),
+                                                   SDL_arraysize(buttons),     buttons,   nullptr};
 
-  std::string decorateSDLError(const std::string & prefix)
-  {
-    return prefix + ": " + SDL_GetError();
-  }
+        int buttonid;
+        if (SDL_ShowMessageBox(&messageboxdata, &buttonid) < 0)
+        {
+            return false;
+        }
 
-  size_t getCanonicalModifiers(const SDL_KeyboardEvent & key)
-  {
-    // simplification of the handling of left and right version of the modifiers
-    // so we can use equality == comparisons
-    size_t modifiers = KMOD_NONE;
-    if (key.keysym.mod & KMOD_CTRL)
-    {
-      modifiers |= KMOD_CTRL;
+        return buttonid == 0;
     }
-    if (key.keysym.mod & KMOD_SHIFT)
+
+    std::string decorateSDLError(const std::string &prefix)
     {
-      modifiers |= KMOD_SHIFT;
+        return prefix + ": " + SDL_GetError();
     }
-    if (key.keysym.mod & KMOD_ALT)
+
+    size_t getCanonicalModifiers(const SDL_KeyboardEvent &key)
     {
-      modifiers |= KMOD_ALT;
+        // simplification of the handling of left and right version of the modifiers
+        // so we can use equality == comparisons
+        size_t modifiers = KMOD_NONE;
+        if (key.keysym.mod & KMOD_CTRL)
+        {
+            modifiers |= KMOD_CTRL;
+        }
+        if (key.keysym.mod & KMOD_SHIFT)
+        {
+            modifiers |= KMOD_SHIFT;
+        }
+        if (key.keysym.mod & KMOD_ALT)
+        {
+            modifiers |= KMOD_ALT;
+        }
+        return modifiers;
     }
-    return modifiers;
-  }
 
-}
+} // namespace sa2
diff --git a/source/frontends/sdl/utils.h b/source/frontends/sdl/utils.h
index eb95fd6d0..10082207b 100644
--- a/source/frontends/sdl/utils.h
+++ b/source/frontends/sdl/utils.h
@@ -8,21 +8,18 @@
 namespace sa2
 {
 
-  void printVideoInfo(std::ostream & os);
+    void printVideoInfo(std::ostream &os);
 
-  void printAudioInfo(std::ostream & os);
+    void printAudioInfo(std::ostream &os);
 
-  void printRendererInfo(std::ostream & os,
-                         const std::shared_ptr<SDL_Renderer> & ren,
-                         const SDL_PixelFormatEnum pixelFormat,
-                         const int selectedDriver);
+    void printRendererInfo(
+        std::ostream &os, const std::shared_ptr<SDL_Renderer> &ren, const SDL_PixelFormatEnum pixelFormat,
+        const int selectedDriver);
 
-  bool show_yes_no_dialog(const std::shared_ptr<SDL_Window> & win,
-                          const std::string & title,
-                          const std::string & text);
+    bool show_yes_no_dialog(const std::shared_ptr<SDL_Window> &win, const std::string &title, const std::string &text);
 
-  std::string decorateSDLError(const std::string & prefix);
+    std::string decorateSDLError(const std::string &prefix);
 
-  size_t getCanonicalModifiers(const SDL_KeyboardEvent & key);
+    size_t getCanonicalModifiers(const SDL_KeyboardEvent &key);
 
-}
+} // namespace sa2
diff --git a/source/linux/.clang-format b/source/linux/.clang-format
new file mode 100644
index 000000000..09eaea6e8
--- /dev/null
+++ b/source/linux/.clang-format
@@ -0,0 +1,7 @@
+BasedOnStyle: Microsoft
+AccessModifierOffset: -4
+AlignAfterOpenBracket: AlwaysBreak
+BreakBeforeBraces: Allman
+BreakConstructorInitializers: BeforeComma
+NamespaceIndentation: All
+SortIncludes: Never
diff --git a/source/linux/benchmark.cpp b/source/linux/benchmark.cpp
index d5d60aeff..5cdeec2bd 100644
--- a/source/linux/benchmark.cpp
+++ b/source/linux/benchmark.cpp
@@ -16,162 +16,152 @@
 
 void VideoBenchmark(std::function<void()> redraw, std::function<void()> refresh)
 {
-  FrameBase & frame = GetFrame();
-  Video & video = GetVideo();
-  // PREPARE TWO DIFFERENT FRAME BUFFERS, EACH OF WHICH HAVE HALF OF THE
-  // BYTES SET TO 0x14 AND THE OTHER HALF SET TO 0xAA
-  int     loop;
-  LPDWORD mem32 = (LPDWORD)mem;
-  for (loop = 4096; loop < 6144; loop++)
-    *(mem32+loop) = ((loop & 1) ^ ((loop & 0x40) >> 6)) ? 0x14141414
-                                                        : 0xAAAAAAAA;
-  for (loop = 6144; loop < 8192; loop++)
-    *(mem32+loop) = ((loop & 1) ^ ((loop & 0x40) >> 6)) ? 0xAAAAAAAA
-                                                        : 0x14141414;
+    FrameBase &frame = GetFrame();
+    Video &video = GetVideo();
+    // PREPARE TWO DIFFERENT FRAME BUFFERS, EACH OF WHICH HAVE HALF OF THE
+    // BYTES SET TO 0x14 AND THE OTHER HALF SET TO 0xAA
+    int loop;
+    LPDWORD mem32 = (LPDWORD)mem;
+    for (loop = 4096; loop < 6144; loop++)
+        *(mem32 + loop) = ((loop & 1) ^ ((loop & 0x40) >> 6)) ? 0x14141414 : 0xAAAAAAAA;
+    for (loop = 6144; loop < 8192; loop++)
+        *(mem32 + loop) = ((loop & 1) ^ ((loop & 0x40) >> 6)) ? 0xAAAAAAAA : 0x14141414;
 
-  // SEE HOW MANY HIRES FRAMES PER SECOND WE CAN PRODUCE WITH NOTHING ELSE
-  // GOING ON, CHANGING HALF OF THE BYTES IN THE VIDEO BUFFER EACH FRAME TO
-  // SIMULATE THE ACTIVITY OF AN AVERAGE GAME
-  video.SetVideoMode(VF_HIRES);
-  memset(mem+0x2000,0x14,0x2000);
-  redraw();
+    // SEE HOW MANY HIRES FRAMES PER SECOND WE CAN PRODUCE WITH NOTHING ELSE
+    // GOING ON, CHANGING HALF OF THE BYTES IN THE VIDEO BUFFER EACH FRAME TO
+    // SIMULATE THE ACTIVITY OF AN AVERAGE GAME
+    video.SetVideoMode(VF_HIRES);
+    memset(mem + 0x2000, 0x14, 0x2000);
+    redraw();
 
-  typedef std::chrono::microseconds interval_t;
-  typedef int64_t counter_t; // avoid overflows
-  const counter_t onesecond = 1000000;
-  counter_t totalhiresfps = 0;
-  counter_t elapsed;
+    typedef std::chrono::microseconds interval_t;
+    typedef int64_t counter_t; // avoid overflows
+    const counter_t onesecond = 1000000;
+    counter_t totalhiresfps = 0;
+    counter_t elapsed;
 
-  auto start = std::chrono::steady_clock::now();
-  do {
-    if (totalhiresfps & 1)
-      memset(mem+0x2000,0x14,0x2000);
-    else
-      memcpy(mem+0x2000,mem+((totalhiresfps & 2) ? 0x4000 : 0x6000),0x2000);
-    refresh();
-    totalhiresfps++;
-
-    const auto end = std::chrono::steady_clock::now();
-    elapsed = std::chrono::duration_cast<interval_t>(end - start).count();
-  } while (elapsed < onesecond);
-  // adjust for broken ms
-  totalhiresfps = totalhiresfps * onesecond / elapsed;
+    auto start = std::chrono::steady_clock::now();
+    do
+    {
+        if (totalhiresfps & 1)
+            memset(mem + 0x2000, 0x14, 0x2000);
+        else
+            memcpy(mem + 0x2000, mem + ((totalhiresfps & 2) ? 0x4000 : 0x6000), 0x2000);
+        refresh();
+        totalhiresfps++;
 
-  // DETERMINE HOW MANY 65C02 CLOCK CYCLES WE CAN EMULATE PER SECOND WITH
-  // NOTHING ELSE GOING ON
-  counter_t totalmhz10[2] = {0, 0};	// bVideoUpdate & !bVideoUpdate
-  for (size_t i = 0; i < 2; i++)
-  {
-    CpuSetupBenchmark();
-    start = std::chrono::steady_clock::now();
-    do {
-      CpuExecute(100000, i==0 ? true : false);
-      totalmhz10[i]++;
-      const auto end = std::chrono::steady_clock::now();
-      elapsed = std::chrono::duration_cast<interval_t>(end - start).count();
+        const auto end = std::chrono::steady_clock::now();
+        elapsed = std::chrono::duration_cast<interval_t>(end - start).count();
     } while (elapsed < onesecond);
-    totalmhz10[i] = totalmhz10[i] * onesecond / elapsed;
-  }
+    // adjust for broken ms
+    totalhiresfps = totalhiresfps * onesecond / elapsed;
 
-  // IF THE PROGRAM COUNTER IS NOT IN THE EXPECTED RANGE AT THE END OF THE
-  // CPU BENCHMARK, REPORT AN ERROR AND OPTIONALLY TRACK IT DOWN
-  if ((regs.pc < 0x300) || (regs.pc > 0x400))
-    if (frame.FrameMessageBox(
-                   TEXT("The emulator has detected a problem while running ")
-                   TEXT("the CPU benchmark.  Would you like to gather more ")
-                   TEXT("information?"),
-                   TEXT("Benchmarks"),
-                   MB_ICONQUESTION | MB_YESNO | MB_SETFOREGROUND) == IDYES) {
-      BOOL error  = 0;
-      WORD lastpc = 0x300;
-      int  loop   = 0;
-      while ((loop < 10000) && !error) {
+    // DETERMINE HOW MANY 65C02 CLOCK CYCLES WE CAN EMULATE PER SECOND WITH
+    // NOTHING ELSE GOING ON
+    counter_t totalmhz10[2] = {0, 0}; // bVideoUpdate & !bVideoUpdate
+    for (size_t i = 0; i < 2; i++)
+    {
         CpuSetupBenchmark();
-        CpuExecute(loop, true);
-        if ((regs.pc < 0x300) || (regs.pc > 0x400))
-          error = 1;
-        else {
-          lastpc = regs.pc;
-          ++loop;
-        }
-      }
-      if (error) {
-        const std::string outstr = StrFormat(
-          TEXT("The emulator experienced an error %u clock cycles ")
-          TEXT("into the CPU benchmark.  Prior to the error, the ")
-          TEXT("program counter was at $%04X.  After the error, it ")
-          TEXT("had jumped to $%04X."),
-          (unsigned)loop,
-          (unsigned)lastpc,
-          (unsigned)regs.pc);
-        frame.FrameMessageBox(
-                   outstr.c_str(),
-                   TEXT("Benchmarks"),
-                   MB_ICONINFORMATION | MB_SETFOREGROUND);
-      }
-      else
-      {
-        frame.FrameMessageBox(
-                   TEXT("The emulator was unable to locate the exact ")
-                   TEXT("point of the error.  This probably means that ")
-                   TEXT("the problem is external to the emulator, ")
-                   TEXT("happening asynchronously, such as a problem in ")
-                   TEXT("a timer interrupt handler."),
-                   TEXT("Benchmarks"),
-                   MB_ICONINFORMATION | MB_SETFOREGROUND);
-      }
+        start = std::chrono::steady_clock::now();
+        do
+        {
+            CpuExecute(100000, i == 0 ? true : false);
+            totalmhz10[i]++;
+            const auto end = std::chrono::steady_clock::now();
+            elapsed = std::chrono::duration_cast<interval_t>(end - start).count();
+        } while (elapsed < onesecond);
+        totalmhz10[i] = totalmhz10[i] * onesecond / elapsed;
     }
 
-  // DO A REALISTIC TEST OF HOW MANY FRAMES PER SECOND WE CAN PRODUCE
-  // WITH FULL EMULATION OF THE CPU, JOYSTICK, AND DISK HAPPENING AT
-  // THE SAME TIME
-  counter_t realisticfps = 0;
-  memset(mem+0x2000,0xAA,0x2000);
-  redraw();
+    // IF THE PROGRAM COUNTER IS NOT IN THE EXPECTED RANGE AT THE END OF THE
+    // CPU BENCHMARK, REPORT AN ERROR AND OPTIONALLY TRACK IT DOWN
+    if ((regs.pc < 0x300) || (regs.pc > 0x400))
+        if (frame.FrameMessageBox(
+                TEXT("The emulator has detected a problem while running ")
+                    TEXT("the CPU benchmark.  Would you like to gather more ") TEXT("information?"),
+                TEXT("Benchmarks"), MB_ICONQUESTION | MB_YESNO | MB_SETFOREGROUND) == IDYES)
+        {
+            BOOL error = 0;
+            WORD lastpc = 0x300;
+            int loop = 0;
+            while ((loop < 10000) && !error)
+            {
+                CpuSetupBenchmark();
+                CpuExecute(loop, true);
+                if ((regs.pc < 0x300) || (regs.pc > 0x400))
+                    error = 1;
+                else
+                {
+                    lastpc = regs.pc;
+                    ++loop;
+                }
+            }
+            if (error)
+            {
+                const std::string outstr = StrFormat(
+                    TEXT("The emulator experienced an error %u clock cycles ")
+                        TEXT("into the CPU benchmark.  Prior to the error, the ")
+                            TEXT("program counter was at $%04X.  After the error, it ") TEXT("had jumped to $%04X."),
+                    (unsigned)loop, (unsigned)lastpc, (unsigned)regs.pc);
+                frame.FrameMessageBox(outstr.c_str(), TEXT("Benchmarks"), MB_ICONINFORMATION | MB_SETFOREGROUND);
+            }
+            else
+            {
+                frame.FrameMessageBox(
+                    TEXT("The emulator was unable to locate the exact ")
+                        TEXT("point of the error.  This probably means that ")
+                            TEXT("the problem is external to the emulator, ")
+                                TEXT("happening asynchronously, such as a problem in ")
+                                    TEXT("a timer interrupt handler."),
+                    TEXT("Benchmarks"), MB_ICONINFORMATION | MB_SETFOREGROUND);
+            }
+        }
 
-  const size_t dwClksPerFrame = NTSC_GetCyclesPerFrame();
-  const size_t cyclesPerMs = g_fCurrentCLK6502 / 1000;
+    // DO A REALISTIC TEST OF HOW MANY FRAMES PER SECOND WE CAN PRODUCE
+    // WITH FULL EMULATION OF THE CPU, JOYSTICK, AND DISK HAPPENING AT
+    // THE SAME TIME
+    counter_t realisticfps = 0;
+    memset(mem + 0x2000, 0xAA, 0x2000);
+    redraw();
 
-  counter_t cyclesThisFrame = 0;
-  start = std::chrono::steady_clock::now();
+    const size_t dwClksPerFrame = NTSC_GetCyclesPerFrame();
+    const size_t cyclesPerMs = g_fCurrentCLK6502 / 1000;
 
-  do {
-    // this is a simplified version of AppleWin.cpp:ContinueExecution()
-    const uint32_t executedcycles = CpuExecute(cyclesPerMs, true);
-    cyclesThisFrame += executedcycles;
-    // every ms disk and joystick are updated
-    GetCardMgr().GetDisk2CardMgr().Update(executedcycles);
+    counter_t cyclesThisFrame = 0;
+    start = std::chrono::steady_clock::now();
+
+    do
+    {
+        // this is a simplified version of AppleWin.cpp:ContinueExecution()
+        const uint32_t executedcycles = CpuExecute(cyclesPerMs, true);
+        cyclesThisFrame += executedcycles;
+        // every ms disk and joystick are updated
+        GetCardMgr().GetDisk2CardMgr().Update(executedcycles);
 #if 0
     JoyUpdateButtonLatch(executedcycles);
 #endif
-    if (cyclesThisFrame >= dwClksPerFrame)
-    {
-      cyclesThisFrame -= dwClksPerFrame;
-      if (realisticfps & 1)
-	memset(mem+0x2000,0xAA,0x2000);
-      else
-	memcpy(mem+0x2000,mem+((realisticfps & 2) ? 0x4000 : 0x6000),0x2000);
-      realisticfps++;
-      refresh();
-    }
-    const auto end = std::chrono::steady_clock::now();
-    elapsed = std::chrono::duration_cast<interval_t>(end - start).count();
-  } while (elapsed < onesecond);
-  realisticfps = realisticfps * onesecond / elapsed;
+        if (cyclesThisFrame >= dwClksPerFrame)
+        {
+            cyclesThisFrame -= dwClksPerFrame;
+            if (realisticfps & 1)
+                memset(mem + 0x2000, 0xAA, 0x2000);
+            else
+                memcpy(mem + 0x2000, mem + ((realisticfps & 2) ? 0x4000 : 0x6000), 0x2000);
+            realisticfps++;
+            refresh();
+        }
+        const auto end = std::chrono::steady_clock::now();
+        elapsed = std::chrono::duration_cast<interval_t>(end - start).count();
+    } while (elapsed < onesecond);
+    realisticfps = realisticfps * onesecond / elapsed;
 
-  // DISPLAY THE RESULTS
-  const std::string outstr = StrFormat(
-    TEXT("Pure Video FPS:\t%u\n")
-    TEXT("Pure CPU MHz:\t%u.%u%s (video update)\n")
-    TEXT("Pure CPU MHz:\t%u.%u%s (full-speed)\n\n")
-    TEXT("EXPECTED AVERAGE VIDEO GAME\n")
-    TEXT("PERFORMANCE: %u FPS"),
-    (unsigned)totalhiresfps,
-    (unsigned)(totalmhz10[0] / 10), (unsigned)(totalmhz10[0] % 10), (LPCTSTR)(IS_APPLE2 ? TEXT(" (6502)") : TEXT("")),
-    (unsigned)(totalmhz10[1] / 10), (unsigned)(totalmhz10[1] % 10), (LPCTSTR)(IS_APPLE2 ? TEXT(" (6502)") : TEXT("")),
-    (unsigned)realisticfps);
-  frame.FrameMessageBox(
-             outstr.c_str(),
-             TEXT("Benchmarks"),
-             MB_ICONINFORMATION | MB_SETFOREGROUND);
+    // DISPLAY THE RESULTS
+    const std::string outstr = StrFormat(
+        TEXT("Pure Video FPS:\t%u\n") TEXT("Pure CPU MHz:\t%u.%u%s (video update)\n")
+            TEXT("Pure CPU MHz:\t%u.%u%s (full-speed)\n\n") TEXT("EXPECTED AVERAGE VIDEO GAME\n")
+                TEXT("PERFORMANCE: %u FPS"),
+        (unsigned)totalhiresfps, (unsigned)(totalmhz10[0] / 10), (unsigned)(totalmhz10[0] % 10),
+        (LPCTSTR)(IS_APPLE2 ? TEXT(" (6502)") : TEXT("")), (unsigned)(totalmhz10[1] / 10),
+        (unsigned)(totalmhz10[1] % 10), (LPCTSTR)(IS_APPLE2 ? TEXT(" (6502)") : TEXT("")), (unsigned)realisticfps);
+    frame.FrameMessageBox(outstr.c_str(), TEXT("Benchmarks"), MB_ICONINFORMATION | MB_SETFOREGROUND);
 }
diff --git a/source/linux/benchmark.h b/source/linux/benchmark.h
index bc2cf7c0b..5ba746747 100644
--- a/source/linux/benchmark.h
+++ b/source/linux/benchmark.h
@@ -2,6 +2,7 @@
 
 #include <functional>
 
-void VideoBenchmark(std::function<void()> redraw,   // regenerate image and repaint
-		    std::function<void()> refresh   // just repaint
-		    );
+void VideoBenchmark(
+    std::function<void()> redraw, // regenerate image and repaint
+    std::function<void()> refresh // just repaint
+);
diff --git a/source/linux/bitmap.cpp b/source/linux/bitmap.cpp
index 388f65665..b0b903846 100644
--- a/source/linux/bitmap.cpp
+++ b/source/linux/bitmap.cpp
@@ -7,80 +7,80 @@
 namespace
 {
 
-  template<typename T>
-  T getAs(const unsigned char * buffer, const size_t bufferSize, const size_t offset)
-  {
-    if (offset + sizeof(T) > bufferSize)
+    template <typename T> T getAs(const unsigned char *buffer, const size_t bufferSize, const size_t offset)
     {
-      throw std::runtime_error("Invalid bitmap");
+        if (offset + sizeof(T) > bufferSize)
+        {
+            throw std::runtime_error("Invalid bitmap");
+        }
+        const T *ptr = reinterpret_cast<const T *>(buffer + offset);
+        return *ptr;
     }
-    const T * ptr = reinterpret_cast<const T *>(buffer + offset);
-    return * ptr;
-  }
 
-  // minimal parser to extract data from the AppleWin BPMs.
-  bool extractBitmapData(const unsigned char * buffer, const size_t bufferSize, int32_t & width, int32_t & height, uint16_t & bpp,
-    const unsigned char * & data, uint32_t & size)
-  {
-    if (bufferSize < 2)
+    // minimal parser to extract data from the AppleWin BPMs.
+    bool extractBitmapData(
+        const unsigned char *buffer, const size_t bufferSize, int32_t &width, int32_t &height, uint16_t &bpp,
+        const unsigned char *&data, uint32_t &size)
     {
-      return false;
-    }
+        if (bufferSize < 2)
+        {
+            return false;
+        }
 
-    if (buffer[0] != 0x42 || buffer[1] != 0x4D)
-    {
-      return false;
-    }
+        if (buffer[0] != 0x42 || buffer[1] != 0x4D)
+        {
+            return false;
+        }
 
-    const uint32_t fileSize = getAs<uint32_t>(buffer, bufferSize, 2);
-    if (fileSize != bufferSize)
-    {
-      return false;
-    }
+        const uint32_t fileSize = getAs<uint32_t>(buffer, bufferSize, 2);
+        if (fileSize != bufferSize)
+        {
+            return false;
+        }
 
-    const uint32_t offset = getAs<uint32_t>(buffer, bufferSize, 10);
-    const uint32_t header = getAs<uint32_t>(buffer, bufferSize, 14);
-    if (header != 40)
-    {
-      return false;
-    }
+        const uint32_t offset = getAs<uint32_t>(buffer, bufferSize, 10);
+        const uint32_t header = getAs<uint32_t>(buffer, bufferSize, 14);
+        if (header != 40)
+        {
+            return false;
+        }
 
-    width = getAs<int32_t>(buffer, bufferSize, 18);
-    height = getAs<int32_t>(buffer, bufferSize, 22);
-    bpp = getAs<uint16_t>(buffer, bufferSize, 28);
-    const uint32_t imageSize = getAs<uint32_t>(buffer, bufferSize, 34);
-    if (offset + imageSize > fileSize)
-    {
-      return false;
+        width = getAs<int32_t>(buffer, bufferSize, 18);
+        height = getAs<int32_t>(buffer, bufferSize, 22);
+        bpp = getAs<uint16_t>(buffer, bufferSize, 28);
+        const uint32_t imageSize = getAs<uint32_t>(buffer, bufferSize, 34);
+        if (offset + imageSize > fileSize)
+        {
+            return false;
+        }
+        data = buffer + offset;
+        size = imageSize;
+        return true;
     }
-    data = buffer + offset;
-    size = imageSize;
-    return true;
-  }
 
-}
+} // namespace
 
-bool GetBitmapFromResource(const std::pair<const unsigned char *, unsigned int> &resource, int cb, void * lpvBits)
+bool GetBitmapFromResource(const std::pair<const unsigned char *, unsigned int> &resource, int cb, void *lpvBits)
 {
-  int32_t width, height;
-  uint16_t bpp;
-  const unsigned char * data;
-  uint32_t size;
-  const bool res = extractBitmapData(resource.first, resource.second, width, height, bpp, data, size);
+    int32_t width, height;
+    uint16_t bpp;
+    const unsigned char *data;
+    uint32_t size;
+    const bool res = extractBitmapData(resource.first, resource.second, width, height, bpp, data, size);
 
-  if (res && bpp == 1 && height > 0 && width > 0 && size <= cb)
-  {
-    const size_t length = size / height;
-    // rows are stored upside down
-    unsigned char * out = static_cast<unsigned char *>(lpvBits);
-    for (size_t row = 0; row < height; ++row)
+    if (res && bpp == 1 && height > 0 && width > 0 && size <= cb)
     {
-      const unsigned char * src = data + row * length;
-      unsigned char * dst = out + (height - row - 1) * length;
-      memcpy(dst, src, length);
+        const size_t length = size / height;
+        // rows are stored upside down
+        unsigned char *out = static_cast<unsigned char *>(lpvBits);
+        for (size_t row = 0; row < height; ++row)
+        {
+            const unsigned char *src = data + row * length;
+            unsigned char *dst = out + (height - row - 1) * length;
+            memcpy(dst, src, length);
+        }
+        return true;
     }
-    return true;
-  }
 
-  return false;
+    return false;
 }
diff --git a/source/linux/bitmap.h b/source/linux/bitmap.h
index 48b7ad48d..29ce3fea8 100644
--- a/source/linux/bitmap.h
+++ b/source/linux/bitmap.h
@@ -2,5 +2,4 @@
 
 #include <utility>
 
-
-bool GetBitmapFromResource(const std::pair<const unsigned char *, unsigned int> &data, int cb, void * lpvBits);
+bool GetBitmapFromResource(const std::pair<const unsigned char *, unsigned int> &data, int cb, void *lpvBits);
diff --git a/source/linux/cassettetape.cpp b/source/linux/cassettetape.cpp
index 0f02561f5..e4c7a7581 100644
--- a/source/linux/cassettetape.cpp
+++ b/source/linux/cassettetape.cpp
@@ -10,117 +10,117 @@
 
 #include <limits>
 
-CassetteTape & CassetteTape::instance()
+CassetteTape &CassetteTape::instance()
 {
-  static CassetteTape tape;
-  return tape;
+    static CassetteTape tape;
+    return tape;
 }
 
-void CassetteTape::setData(const std::string & filename, const std::vector<tape_data_t> & data, const int frequency)
+void CassetteTape::setData(const std::string &filename, const std::vector<tape_data_t> &data, const int frequency)
 {
-  myFilename = filename;
-  myData = data;
-  myFrequency = frequency;
-  myIsPlaying = false;
+    myFilename = filename;
+    myData = data;
+    myFrequency = frequency;
+    myIsPlaying = false;
 }
 
 void CassetteTape::eject()
 {
-  myData.clear();
+    myData.clear();
 }
 
 void CassetteTape::rewind()
 {
-  myIsPlaying = false;
+    myIsPlaying = false;
 }
 
 BYTE CassetteTape::getBitValue(const tape_data_t val)
 {
-  // threshold not needed for https://asciiexpress.net
-  // but probably necessary for a real audio file
-  //
-  // this has been tested on all formats from https://asciiexpress.net
-  //
-  // we are extracting the sign bit (set for negative numbers)
-  // this is really important for the asymmetric wave in https://asciiexpress.net/diskserver/
-  // not so much for the other cases
-  if (val > myThreshold)
-  {
-    myLastBit = 0;
-  }
-  else if (val < -myThreshold)
-  {
-    myLastBit = 1;
-  }
-  // else leave it unchanged to the previous value
-  return myLastBit;
+    // threshold not needed for https://asciiexpress.net
+    // but probably necessary for a real audio file
+    //
+    // this has been tested on all formats from https://asciiexpress.net
+    //
+    // we are extracting the sign bit (set for negative numbers)
+    // this is really important for the asymmetric wave in https://asciiexpress.net/diskserver/
+    // not so much for the other cases
+    if (val > myThreshold)
+    {
+        myLastBit = 0;
+    }
+    else if (val < -myThreshold)
+    {
+        myLastBit = 1;
+    }
+    // else leave it unchanged to the previous value
+    return myLastBit;
 }
 
-CassetteTape::tape_data_t CassetteTape::getCurrentWave(size_t & pos) const
+CassetteTape::tape_data_t CassetteTape::getCurrentWave(size_t &pos) const
 {
-  if (myIsPlaying)
-  {
-    const double delta = g_nCumulativeCycles - myBaseCycles;
-    const double position = delta / g_fCurrentCLK6502 * myFrequency;
-    pos = static_cast<size_t>(position);
-
-    if (pos + 1 < myData.size())
+    if (myIsPlaying)
     {
-      // linear interpolation
-      const double reminder = position - pos;
-      const double value = (1.0 - reminder) * myData[pos] + reminder * myData[pos + 1];
-      return lround(value);
+        const double delta = g_nCumulativeCycles - myBaseCycles;
+        const double position = delta / g_fCurrentCLK6502 * myFrequency;
+        pos = static_cast<size_t>(position);
+
+        if (pos + 1 < myData.size())
+        {
+            // linear interpolation
+            const double reminder = position - pos;
+            const double value = (1.0 - reminder) * myData[pos] + reminder * myData[pos + 1];
+            return lround(value);
+        }
+        else
+        {
+            pos = myData.size() - 1;
+        }
     }
     else
     {
-      pos = myData.size() - 1;
+        pos = 0;
     }
-  }
-  else
-  {
-    pos = 0;
-  }
-  return std::numeric_limits<tape_data_t>::min();
+    return std::numeric_limits<tape_data_t>::min();
 }
 
 BYTE CassetteTape::getValue(const ULONG nExecutedCycles)
 {
-  CpuCalcCycles(nExecutedCycles);
+    CpuCalcCycles(nExecutedCycles);
 
-  if (!myIsPlaying)
-  {
-    // start play as soon as TAPEIN is read
-    myIsPlaying = true;
-    myBaseCycles = g_nCumulativeCycles;
-  }
+    if (!myIsPlaying)
+    {
+        // start play as soon as TAPEIN is read
+        myIsPlaying = true;
+        myBaseCycles = g_nCumulativeCycles;
+    }
 
-  size_t pos;
-  const tape_data_t val = getCurrentWave(pos);
-  const BYTE highBit = getBitValue(val);
+    size_t pos;
+    const tape_data_t val = getCurrentWave(pos);
+    const BYTE highBit = getBitValue(val);
 
-  return highBit;
+    return highBit;
 }
 
-void CassetteTape::getTapeInfo(TapeInfo & info) const
+void CassetteTape::getTapeInfo(TapeInfo &info) const
 {
-  info.filename = myFilename;
-  const tape_data_t val = getCurrentWave(info.pos);
-  info.bit = myLastBit;
-  info.size = myData.size();
-  info.frequency = myFrequency;
+    info.filename = myFilename;
+    const tape_data_t val = getCurrentWave(info.pos);
+    info.bit = myLastBit;
+    info.size = myData.size();
+    info.frequency = myFrequency;
 }
 
-BYTE __stdcall TapeRead(WORD pc, WORD address, BYTE, BYTE, ULONG nExecutedCycles)	// $C060 TAPEIN
+BYTE __stdcall TapeRead(WORD pc, WORD address, BYTE, BYTE, ULONG nExecutedCycles) // $C060 TAPEIN
 {
-  if (g_Apple2Type == A2TYPE_PRAVETS8A)
-    return GetPravets().GetKeycode( MemReadFloatingBus(nExecutedCycles) );
+    if (g_Apple2Type == A2TYPE_PRAVETS8A)
+        return GetPravets().GetKeycode(MemReadFloatingBus(nExecutedCycles));
 
-  const BYTE highBit = CassetteTape::instance().getValue(nExecutedCycles);
+    const BYTE highBit = CassetteTape::instance().getValue(nExecutedCycles);
 
-  return MemReadFloatingBus(highBit, nExecutedCycles);
+    return MemReadFloatingBus(highBit, nExecutedCycles);
 }
 
-BYTE __stdcall TapeWrite(WORD, WORD address, BYTE, BYTE, ULONG nExecutedCycles)	// $C020 TAPEOUT
+BYTE __stdcall TapeWrite(WORD, WORD address, BYTE, BYTE, ULONG nExecutedCycles) // $C020 TAPEOUT
 {
-  return 0;
+    return 0;
 }
diff --git a/source/linux/cassettetape.h b/source/linux/cassettetape.h
index 49769308d..eb8082444 100644
--- a/source/linux/cassettetape.h
+++ b/source/linux/cassettetape.h
@@ -6,38 +6,37 @@
 class CassetteTape
 {
 public:
+    typedef int8_t tape_data_t;
 
-  typedef int8_t tape_data_t;
+    void setData(const std::string &filename, const std::vector<tape_data_t> &data, const int frequency);
+    BYTE getValue(const ULONG nExecutedCycles);
 
-  void setData(const std::string & filename, const std::vector<tape_data_t> & data, const int frequency);
-  BYTE getValue(const ULONG nExecutedCycles);
+    struct TapeInfo
+    {
+        std::string filename;
+        size_t size;
+        size_t pos;
+        int frequency;
+        uint8_t bit;
+    };
 
-  struct TapeInfo
-  {
-    std::string filename;
-    size_t size;
-    size_t pos;
-    int frequency;
-    uint8_t bit;
-  };
+    void getTapeInfo(TapeInfo &info) const;
+    void eject();
+    void rewind();
 
-  void getTapeInfo(TapeInfo & info) const;
-  void eject();
-  void rewind();
-
-  static CassetteTape & instance();
+    static CassetteTape &instance();
 
 private:
-  BYTE getBitValue(const tape_data_t val);
-  tape_data_t getCurrentWave(size_t & pos) const;
+    BYTE getBitValue(const tape_data_t val);
+    tape_data_t getCurrentWave(size_t &pos) const;
 
-  std::vector<tape_data_t> myData;
+    std::vector<tape_data_t> myData;
 
-  int64_t myBaseCycles;
-  int myFrequency;
-  bool myIsPlaying = false;
-  BYTE myLastBit = 1; // negative wave
-  std::string myFilename; // just for info
+    int64_t myBaseCycles;
+    int myFrequency;
+    bool myIsPlaying = false;
+    BYTE myLastBit = 1;     // negative wave
+    std::string myFilename; // just for info
 
-  static constexpr tape_data_t myThreshold = 5;
+    static constexpr tape_data_t myThreshold = 5;
 };
diff --git a/source/linux/context.cpp b/source/linux/context.cpp
index 1d90a1db3..53ab3ffb8 100644
--- a/source/linux/context.cpp
+++ b/source/linux/context.cpp
@@ -19,115 +19,112 @@
 #include "Memory.h"
 #include "Speaker.h"
 
-
 namespace
 {
-  std::shared_ptr<FrameBase> sg_LinuxFrame;
+    std::shared_ptr<FrameBase> sg_LinuxFrame;
 }
 
-IPropertySheet& GetPropertySheet()
+IPropertySheet &GetPropertySheet()
 {
-  static CPropertySheet sg_PropertySheet;
-  return sg_PropertySheet;
+    static CPropertySheet sg_PropertySheet;
+    return sg_PropertySheet;
 }
 
-FrameBase& GetFrame()
+FrameBase &GetFrame()
 {
-  return *sg_LinuxFrame;
+    return *sg_LinuxFrame;
 }
 
-void SetFrame(const std::shared_ptr<FrameBase> & frame)
+void SetFrame(const std::shared_ptr<FrameBase> &frame)
 {
-  sg_LinuxFrame = frame;
+    sg_LinuxFrame = frame;
 }
 
-Video& GetVideo()
+Video &GetVideo()
 {
-  static Video sg_Video;
-  return sg_Video;
+    static Video sg_Video;
+    return sg_Video;
 }
 
-Initialisation::Initialisation(
-  const std::shared_ptr<LinuxFrame> & frame,
-  const std::shared_ptr<Paddle> & paddle)
-: myFrame(frame)
+Initialisation::Initialisation(const std::shared_ptr<LinuxFrame> &frame, const std::shared_ptr<Paddle> &paddle)
+    : myFrame(frame)
 {
-  SetFrame(myFrame);
-  Paddle::instance = paddle;
+    SetFrame(myFrame);
+    Paddle::instance = paddle;
 }
 
 Initialisation::~Initialisation()
 {
-  myFrame->Destroy();
-  SetFrame(std::shared_ptr<FrameBase>());
+    myFrame->Destroy();
+    SetFrame(std::shared_ptr<FrameBase>());
 
-  Paddle::instance.reset();
+    Paddle::instance.reset();
 
-  RiffFinishWriteFile();
+    RiffFinishWriteFile();
 
-  CloseHandle(g_hCustomRomF8);
-  g_hCustomRomF8 = INVALID_HANDLE_VALUE;
-  CloseHandle(g_hCustomRom);
-  g_hCustomRom = INVALID_HANDLE_VALUE;
+    CloseHandle(g_hCustomRomF8);
+    g_hCustomRomF8 = INVALID_HANDLE_VALUE;
+    CloseHandle(g_hCustomRom);
+    g_hCustomRom = INVALID_HANDLE_VALUE;
 }
 
 LoggerContext::LoggerContext(const bool log)
 {
-  if (log)
-  {
-    LogInit();
-  }
+    if (log)
+    {
+        LogInit();
+    }
 }
 
 LoggerContext::~LoggerContext()
 {
-  LogDone();
+    LogDone();
 }
 
-RegistryContext::RegistryContext(const std::shared_ptr<Registry> & registry)
+RegistryContext::RegistryContext(const std::shared_ptr<Registry> &registry)
 {
-  Registry::instance = registry;
+    Registry::instance = registry;
 }
 
 RegistryContext::~RegistryContext()
 {
-  Registry::instance.reset();
+    Registry::instance.reset();
 }
 
 void InitialiseEmulator(const AppMode_e mode)
 {
-  g_nAppMode = mode;
-  LogFileOutput("Initialisation\n");
+    g_nAppMode = mode;
+    LogFileOutput("Initialisation\n");
 
-  g_bFullSpeed = false;
+    g_bFullSpeed = false;
 
-  GetVideo().SetVidHD(false);
-  LoadConfiguration(true);
-  SetCurrentCLK6502();
-  GetAppleWindowTitle();
-  GetFrame().FrameRefreshStatus(DRAW_LEDS | DRAW_BUTTON_DRIVES | DRAW_DISK_STATUS);
+    GetVideo().SetVidHD(false);
+    LoadConfiguration(true);
+    SetCurrentCLK6502();
+    GetAppleWindowTitle();
+    GetFrame().FrameRefreshStatus(DRAW_LEDS | DRAW_BUTTON_DRIVES | DRAW_DISK_STATUS);
 
-  SpkrInitialize();
+    SpkrInitialize();
 
-  MemInitialize();
+    MemInitialize();
 
-  CardManager & cardManager = GetCardMgr();
-  cardManager.Reset(true);
+    CardManager &cardManager = GetCardMgr();
+    cardManager.Reset(true);
 
-  Snapshot_Startup();
+    Snapshot_Startup();
 
-  DebugInitialize();
-  KeybReset();
+    DebugInitialize();
+    KeybReset();
 }
 
 void DestroyEmulator()
 {
-  CardManager & cardManager = GetCardMgr();
-  cardManager.Destroy();
-
-  Snapshot_Shutdown();
-  MemDestroy();
-  SpkrDestroy();
-  CpuDestroy();
-  DebugDestroy();
+    CardManager &cardManager = GetCardMgr();
+    cardManager.Destroy();
+
+    Snapshot_Shutdown();
+    MemDestroy();
+    SpkrDestroy();
+    CpuDestroy();
+    DebugDestroy();
 }
diff --git a/source/linux/context.h b/source/linux/context.h
index af96ae8df..37b83fdcb 100644
--- a/source/linux/context.h
+++ b/source/linux/context.h
@@ -9,7 +9,7 @@ class LinuxFrame;
 class Paddle;
 class Registry;
 
-void SetFrame(const std::shared_ptr<FrameBase> & frame);
+void SetFrame(const std::shared_ptr<FrameBase> &frame);
 
 void InitialiseEmulator(const AppMode_e mode);
 void DestroyEmulator();
@@ -18,26 +18,24 @@ void DestroyEmulator();
 class Initialisation
 {
 public:
-  Initialisation(
-    const std::shared_ptr<LinuxFrame> & frame,
-    const std::shared_ptr<Paddle> & paddle
-    );
-  ~Initialisation();
+    Initialisation(const std::shared_ptr<LinuxFrame> &frame, const std::shared_ptr<Paddle> &paddle);
+    ~Initialisation();
+
 protected:
-  const std::shared_ptr<LinuxFrame> myFrame;
+    const std::shared_ptr<LinuxFrame> myFrame;
 };
 
 // RAII around LogInit / LogDone.
 class LoggerContext
 {
 public:
-  LoggerContext(const bool log);
-  ~LoggerContext();
+    LoggerContext(const bool log);
+    ~LoggerContext();
 };
 
 class RegistryContext
 {
 public:
-  RegistryContext(const std::shared_ptr<Registry> & registry);
-  ~RegistryContext();
+    RegistryContext(const std::shared_ptr<Registry> &registry);
+    ~RegistryContext();
 };
diff --git a/source/linux/duplicates/Debugger_Display.cpp b/source/linux/duplicates/Debugger_Display.cpp
index fd8cf8d08..9fa8f737a 100644
--- a/source/linux/duplicates/Debugger_Display.cpp
+++ b/source/linux/duplicates/Debugger_Display.cpp
@@ -3,25 +3,25 @@
 #include "Keyboard.h"
 
 // NOTE: Keep in sync ConsoleColors_e g_anConsoleColor !
-COLORREF g_anConsoleColor[ NUM_CONSOLE_COLORS ] =
-{                         // # <Bright Blue Green Red>
-  RGB(   0,   0,   0 ), // 0 0000 K
-  RGB( 255,  32,  32 ), // 1 1001 R
-  RGB(   0, 255,   0 ), // 2 1010 G
-  RGB( 255, 255,   0 ), // 3 1011 Y
-  RGB(  64,  64, 255 ), // 4 1100 B
-  RGB( 255,   0, 255 ), // 5 1101 M Purple/Magenta now used for warnings.
-  RGB(   0, 255, 255 ), // 6 1110 C
-  RGB( 255, 255, 255 ), // 7 1111 W
-  RGB( 255, 128,   0 ), // 8 0011 Orange
-  RGB( 128, 128, 128 ), // 9 0111 Grey
-
-  RGB(  80, 192, 255 )  // Lite Blue
+COLORREF g_anConsoleColor[NUM_CONSOLE_COLORS] = {
+    // # <Bright Blue Green Red>
+    RGB(0, 0, 0),       // 0 0000 K
+    RGB(255, 32, 32),   // 1 1001 R
+    RGB(0, 255, 0),     // 2 1010 G
+    RGB(255, 255, 0),   // 3 1011 Y
+    RGB(64, 64, 255),   // 4 1100 B
+    RGB(255, 0, 255),   // 5 1101 M Purple/Magenta now used for warnings.
+    RGB(0, 255, 255),   // 6 1110 C
+    RGB(255, 255, 255), // 7 1111 W
+    RGB(255, 128, 0),   // 8 0011 Orange
+    RGB(128, 128, 128), // 9 0111 Grey
+
+    RGB(80, 192, 255) // Lite Blue
 };
 
 VideoScannerDisplayInfo g_videoScannerDisplayInfo;
 
-char g_aDebuggerVirtualTextScreen[ DEBUG_VIRTUAL_TEXT_HEIGHT ][ DEBUG_VIRTUAL_TEXT_WIDTH ];
+char g_aDebuggerVirtualTextScreen[DEBUG_VIRTUAL_TEXT_HEIGHT][DEBUG_VIRTUAL_TEXT_WIDTH];
 
 void DrawConsoleCursor()
 {
@@ -29,7 +29,7 @@ void DrawConsoleCursor()
 
 HDC GetDebuggerMemDC(void)
 {
-  return nullptr;
+    return nullptr;
 }
 
 void KeybQueueKeypress(WPARAM /* key */, Keystroke_e /* bASCII */)
@@ -54,7 +54,7 @@ void ReleaseConsoleFontDC(void)
 
 HDC GetConsoleFontDC(void)
 {
-  return nullptr;
+    return nullptr;
 }
 
 void DrawConsoleInput()
diff --git a/source/linux/duplicates/Debugger_Win32.cpp b/source/linux/duplicates/Debugger_Win32.cpp
index 601793beb..75ab480b9 100644
--- a/source/linux/duplicates/Debugger_Win32.cpp
+++ b/source/linux/duplicates/Debugger_Win32.cpp
@@ -3,12 +3,12 @@
 
 Update_t CmdConfigFont(int /* nArgs */)
 {
-  return UPDATE_NOTHING;
+    return UPDATE_NOTHING;
 }
 
 Update_t CmdConfigGetFont(int /* nArgs */)
 {
-  return UPDATE_NOTHING;
+    return UPDATE_NOTHING;
 }
 
 void ProcessClipboardCommands()
diff --git a/source/linux/duplicates/FourPlay.cpp b/source/linux/duplicates/FourPlay.cpp
index 1cd0cdf2a..f5ffc2e70 100644
--- a/source/linux/duplicates/FourPlay.cpp
+++ b/source/linux/duplicates/FourPlay.cpp
@@ -10,24 +10,24 @@ void FourPlayCard::InitializeIO(LPBYTE pCxRomPeripheral)
 
 static const UINT kUNIT_VERSION = 1;
 
-const std::string & FourPlayCard::GetSnapshotCardName(void)
+const std::string &FourPlayCard::GetSnapshotCardName(void)
 {
-  static const std::string name("4Play");
-  return name;
+    static const std::string name("4Play");
+    return name;
 }
 
-void FourPlayCard::SaveSnapshot(YamlSaveHelper& yamlSaveHelper)
+void FourPlayCard::SaveSnapshot(YamlSaveHelper &yamlSaveHelper)
 {
-  YamlSaveHelper::Slot slot(yamlSaveHelper, GetSnapshotCardName(), m_slot, kUNIT_VERSION);
+    YamlSaveHelper::Slot slot(yamlSaveHelper, GetSnapshotCardName(), m_slot, kUNIT_VERSION);
 
-  YamlSaveHelper::Label unit(yamlSaveHelper, "%s: null\n", SS_YAML_KEY_STATE);
-  // NB. No state for this card
+    YamlSaveHelper::Label unit(yamlSaveHelper, "%s: null\n", SS_YAML_KEY_STATE);
+    // NB. No state for this card
 }
 
-bool FourPlayCard::LoadSnapshot(YamlLoadHelper& yamlLoadHelper, UINT version)
+bool FourPlayCard::LoadSnapshot(YamlLoadHelper &yamlLoadHelper, UINT version)
 {
-  if (version < 1 || version > kUNIT_VERSION)
-    ThrowErrorInvalidVersion(version);
+    if (version < 1 || version > kUNIT_VERSION)
+        ThrowErrorInvalidVersion(version);
 
-  return true;
+    return true;
 }
diff --git a/source/linux/duplicates/Joystick.cpp b/source/linux/duplicates/Joystick.cpp
index 172fd8bdf..e4c254484 100644
--- a/source/linux/duplicates/Joystick.cpp
+++ b/source/linux/duplicates/Joystick.cpp
@@ -6,7 +6,7 @@ void JoyportControl(const UINT uControl)
 {
 }
 
-void JoySaveSnapshot(YamlSaveHelper&)
+void JoySaveSnapshot(YamlSaveHelper &)
 {
 }
 
@@ -39,32 +39,32 @@ void JoySetButtonVirtualKey(UINT button, UINT virtKey)
 
 static std::string JoyGetSnapshotStructName(void)
 {
-  static const std::string name("Joystick");
-  return name;
+    static const std::string name("Joystick");
+    return name;
 }
 
-void JoyLoadSnapshot(YamlLoadHelper& yamlLoadHelper, UINT version)
+void JoyLoadSnapshot(YamlLoadHelper &yamlLoadHelper, UINT version)
 {
-  if (!yamlLoadHelper.GetSubMap(JoyGetSnapshotStructName()))
-    return;
+    if (!yamlLoadHelper.GetSubMap(JoyGetSnapshotStructName()))
+        return;
 
-  yamlLoadHelper.LoadInt(SS_YAML_KEY_JOY0TRIMX);
-  yamlLoadHelper.LoadInt(SS_YAML_KEY_JOY0TRIMY);
-  yamlLoadHelper.LoadInt(SS_YAML_KEY_JOY1TRIMX);
-  yamlLoadHelper.LoadInt(SS_YAML_KEY_JOY1TRIMY);
+    yamlLoadHelper.LoadInt(SS_YAML_KEY_JOY0TRIMX);
+    yamlLoadHelper.LoadInt(SS_YAML_KEY_JOY0TRIMY);
+    yamlLoadHelper.LoadInt(SS_YAML_KEY_JOY1TRIMX);
+    yamlLoadHelper.LoadInt(SS_YAML_KEY_JOY1TRIMY);
 
-  if (version >= 7)
-  {
-    for (UINT n = 0; n < 4; n++)
+    if (version >= 7)
     {
-      const std::string str = StrFormat(SS_YAML_KEY_PDL_INACTIVE_CYCLE, n);
-      yamlLoadHelper.LoadUint64(str);
+        for (UINT n = 0; n < 4; n++)
+        {
+            const std::string str = StrFormat(SS_YAML_KEY_PDL_INACTIVE_CYCLE, n);
+            yamlLoadHelper.LoadUint64(str);
+        }
+    }
+    else
+    {
+        yamlLoadHelper.LoadUint64(SS_YAML_KEY_COUNTERRESETCYCLE);
     }
-  }
-  else
-  {
-    yamlLoadHelper.LoadUint64(SS_YAML_KEY_COUNTERRESETCYCLE);
-  }
 
-  yamlLoadHelper.PopMap();
+    yamlLoadHelper.PopMap();
 }
diff --git a/source/linux/duplicates/Keyboard.cpp b/source/linux/duplicates/Keyboard.cpp
index 32c0f4f6d..737a0e2b8 100644
--- a/source/linux/duplicates/Keyboard.cpp
+++ b/source/linux/duplicates/Keyboard.cpp
@@ -8,43 +8,43 @@
 
 namespace
 {
-  std::queue<BYTE> keys;
-  bool g_bCapsLock = true; //Caps lock key for Apple2 and Lat/Cyr lock for Pravets8
-  BYTE keycode = 0;
+    std::queue<BYTE> keys;
+    bool g_bCapsLock = true; // Caps lock key for Apple2 and Lat/Cyr lock for Pravets8
+    BYTE keycode = 0;
 
-  void setKeyCode()
-  {
-    if (!keys.empty())
+    void setKeyCode()
     {
-      keycode = keys.front();
+        if (!keys.empty())
+        {
+            keycode = keys.front();
+        }
     }
-  }
-}
+} // namespace
 
 void addKeyToBuffer(BYTE key)
 {
-  keys.push(key);
+    keys.push(key);
 }
 
-void addTextToBuffer(const char * text)
+void addTextToBuffer(const char *text)
 {
-   while (*text)
-   {
-     switch (*text)
-     {
-       case '\n':
-       {
-        addKeyToBuffer(0x0d);
-        break;
-       }
-       case 0x20 ... 0x7e:
-       {
-        addKeyToBuffer(*text);
-        break;
-       }
-     }
-     ++text;
-   }
+    while (*text)
+    {
+        switch (*text)
+        {
+        case '\n':
+        {
+            addKeyToBuffer(0x0d);
+            break;
+        }
+        case 0x20 ... 0x7e:
+        {
+            addKeyToBuffer(*text);
+            break;
+        }
+        }
+        ++text;
+    }
 }
 
 void KeybSetAltGrSendsWM_CHAR(bool state)
@@ -57,33 +57,33 @@ void KeybSetCapsLock(bool state)
 
 bool KeybGetCapsStatus()
 {
-  return g_bCapsLock;
+    return g_bCapsLock;
 }
 
 BYTE KeybGetKeycode()
 {
-  return keycode;
+    return keycode;
 }
 
 BYTE KeybReadData()
 {
-  LogFileTimeUntilFirstKeyRead();
+    LogFileTimeUntilFirstKeyRead();
 
-  setKeyCode();
+    setKeyCode();
 
-  return keycode | (keys.empty() ? 0 : 0x80);
+    return keycode | (keys.empty() ? 0 : 0x80);
 }
 
 BYTE KeybReadFlag()
 {
-  _ASSERT(!IS_APPLE2);	// And also not Pravets machines?
+    _ASSERT(!IS_APPLE2); // And also not Pravets machines?
 
-  BYTE res = KeybClearStrobe();
-  if (res)
-    return res;
+    BYTE res = KeybClearStrobe();
+    if (res)
+        return res;
 
-	// AKD
-  return keycode | (keys.empty() ? 0: 0x80);
+    // AKD
+    return keycode | (keys.empty() ? 0 : 0x80);
 }
 
 #define SS_YAML_KEY_LASTKEY "Last Key"
@@ -91,65 +91,65 @@ BYTE KeybReadFlag()
 
 static std::string KeybGetSnapshotStructName(void)
 {
-  static const std::string name("Keyboard");
-  return name;
+    static const std::string name("Keyboard");
+    return name;
 }
 
-void KeybSaveSnapshot(YamlSaveHelper& yamlSaveHelper)
+void KeybSaveSnapshot(YamlSaveHelper &yamlSaveHelper)
 {
-  YamlSaveHelper::Label state(yamlSaveHelper, "%s:\n", KeybGetSnapshotStructName().c_str());
-  yamlSaveHelper.SaveHexUint8(SS_YAML_KEY_LASTKEY, keycode);
-  yamlSaveHelper.SaveBool(SS_YAML_KEY_KEYWAITING, keys.empty() ? false : false);
+    YamlSaveHelper::Label state(yamlSaveHelper, "%s:\n", KeybGetSnapshotStructName().c_str());
+    yamlSaveHelper.SaveHexUint8(SS_YAML_KEY_LASTKEY, keycode);
+    yamlSaveHelper.SaveBool(SS_YAML_KEY_KEYWAITING, keys.empty() ? false : false);
 }
 
-void KeybLoadSnapshot(YamlLoadHelper& yamlLoadHelper, UINT version)
+void KeybLoadSnapshot(YamlLoadHelper &yamlLoadHelper, UINT version)
 {
-  if (!yamlLoadHelper.GetSubMap(KeybGetSnapshotStructName()))
-    return;
+    if (!yamlLoadHelper.GetSubMap(KeybGetSnapshotStructName()))
+        return;
 
-  keycode = (BYTE) yamlLoadHelper.LoadUint(SS_YAML_KEY_LASTKEY);
+    keycode = (BYTE)yamlLoadHelper.LoadUint(SS_YAML_KEY_LASTKEY);
 
-  bool keywaiting = false;
-  if (version >= 2)
-    keywaiting = yamlLoadHelper.LoadBool(SS_YAML_KEY_KEYWAITING);
+    bool keywaiting = false;
+    if (version >= 2)
+        keywaiting = yamlLoadHelper.LoadBool(SS_YAML_KEY_KEYWAITING);
 
-  keys = std::queue<BYTE>();
-  addKeyToBuffer(keycode);
+    keys = std::queue<BYTE>();
+    addKeyToBuffer(keycode);
 
-  yamlLoadHelper.PopMap();
+    yamlLoadHelper.PopMap();
 }
 
 void KeybReset()
 {
-  keycode = 0;
-  std::queue<BYTE>().swap(keys);
+    keycode = 0;
+    std::queue<BYTE>().swap(keys);
 }
 
 bool KeybGetShiftStatus()
 {
-  return false;
+    return false;
 }
 
 bool KeybGetAltStatus()
 {
-  return false;
+    return false;
 }
 
 bool KeybGetCtrlStatus()
 {
-  return false;
+    return false;
 }
 
 BYTE KeybClearStrobe(void)
 {
-  if (keys.empty())
-  {
-    return 0;
-  }
-  else
-  {
-    const BYTE result = keys.front();
-    keys.pop();
-    return result | 0x80;
-  }
+    if (keys.empty())
+    {
+        return 0;
+    }
+    else
+    {
+        const BYTE result = keys.front();
+        keys.pop();
+        return result | 0x80;
+    }
 }
diff --git a/source/linux/duplicates/PageAdvanced.cpp b/source/linux/duplicates/PageAdvanced.cpp
index 52d47d40d..ee2318fde 100644
--- a/source/linux/duplicates/PageAdvanced.cpp
+++ b/source/linux/duplicates/PageAdvanced.cpp
@@ -5,12 +5,11 @@
 // IPropertySheetPage
 INT_PTR CPageAdvanced::DlgProcInternal(HWND hWnd, UINT message, WPARAM wparam, LPARAM lparam)
 {
-  return 0;
+    return 0;
 }
 
 void CPageAdvanced::DlgOK(HWND hWnd)
 {
-
 }
 
-CPageAdvanced* CPageAdvanced::ms_this = nullptr;
+CPageAdvanced *CPageAdvanced::ms_this = nullptr;
diff --git a/source/linux/duplicates/PageConfig.cpp b/source/linux/duplicates/PageConfig.cpp
index c851ff156..9aa35da78 100644
--- a/source/linux/duplicates/PageConfig.cpp
+++ b/source/linux/duplicates/PageConfig.cpp
@@ -5,12 +5,11 @@
 // IPropertySheetPage
 INT_PTR CPageConfig::DlgProcInternal(HWND hWnd, UINT message, WPARAM wparam, LPARAM lparam)
 {
-  return 0;
+    return 0;
 }
 
 void CPageConfig::DlgOK(HWND hWnd)
 {
-
 }
 
-CPageConfig* CPageConfig::ms_this = nullptr;
+CPageConfig *CPageConfig::ms_this = nullptr;
diff --git a/source/linux/duplicates/PageConfigTfe.cpp b/source/linux/duplicates/PageConfigTfe.cpp
index df139ba48..264aae384 100644
--- a/source/linux/duplicates/PageConfigTfe.cpp
+++ b/source/linux/duplicates/PageConfigTfe.cpp
@@ -5,17 +5,15 @@
 // IPropertySheetPage
 INT_PTR CPageConfigTfe::DlgProcInternal(HWND hWnd, UINT message, WPARAM wparam, LPARAM lparam)
 {
-  return 0;
+    return 0;
 }
 
 void CPageConfigTfe::DlgOK(HWND hWnd)
 {
-
 }
 
 void CPageConfigTfe::DlgCANCEL(HWND window)
 {
-
 }
 
-CPageConfigTfe* CPageConfigTfe::ms_this = nullptr;
+CPageConfigTfe *CPageConfigTfe::ms_this = nullptr;
diff --git a/source/linux/duplicates/PageDisk.cpp b/source/linux/duplicates/PageDisk.cpp
index 3bb610c29..2f28f0df1 100644
--- a/source/linux/duplicates/PageDisk.cpp
+++ b/source/linux/duplicates/PageDisk.cpp
@@ -5,12 +5,11 @@
 // IPropertySheetPage
 INT_PTR CPageDisk::DlgProcInternal(HWND hWnd, UINT message, WPARAM wparam, LPARAM lparam)
 {
-  return 0;
+    return 0;
 }
 
 void CPageDisk::DlgOK(HWND hWnd)
 {
-
 }
 
-CPageDisk* CPageDisk::ms_this = nullptr;
+CPageDisk *CPageDisk::ms_this = nullptr;
diff --git a/source/linux/duplicates/PageInput.cpp b/source/linux/duplicates/PageInput.cpp
index b66e950fd..d4d8dfa47 100644
--- a/source/linux/duplicates/PageInput.cpp
+++ b/source/linux/duplicates/PageInput.cpp
@@ -5,12 +5,11 @@
 // IPropertySheetPage
 INT_PTR CPageInput::DlgProcInternal(HWND hWnd, UINT message, WPARAM wparam, LPARAM lparam)
 {
-  return 0;
+    return 0;
 }
 
 void CPageInput::DlgOK(HWND hWnd)
 {
-
 }
 
-CPageInput* CPageInput::ms_this = nullptr;
+CPageInput *CPageInput::ms_this = nullptr;
diff --git a/source/linux/duplicates/PageSound.cpp b/source/linux/duplicates/PageSound.cpp
index b36025d7d..e38ed9f5c 100644
--- a/source/linux/duplicates/PageSound.cpp
+++ b/source/linux/duplicates/PageSound.cpp
@@ -5,12 +5,11 @@
 // IPropertySheetPage
 INT_PTR CPageSound::DlgProcInternal(HWND hWnd, UINT message, WPARAM wparam, LPARAM lparam)
 {
-  return 0;
+    return 0;
 }
 
 void CPageSound::DlgOK(HWND hWnd)
 {
-
 }
 
-CPageSound* CPageSound::ms_this = nullptr;
+CPageSound *CPageSound::ms_this = nullptr;
diff --git a/source/linux/duplicates/PropertySheet.cpp b/source/linux/duplicates/PropertySheet.cpp
index be5d51757..0f07512ac 100644
--- a/source/linux/duplicates/PropertySheet.cpp
+++ b/source/linux/duplicates/PropertySheet.cpp
@@ -8,10 +8,10 @@ void CPropertySheet::Init(void)
 
 uint32_t CPropertySheet::GetVolumeMax(void)
 {
-  return 99;
+    return 99;
 }
 
 bool CPropertySheet::SaveStateSelectImage(HWND hWindow, bool bSave)
 {
-  return false;
+    return false;
 }
diff --git a/source/linux/duplicates/Registry.cpp b/source/linux/duplicates/Registry.cpp
index 91afbe3e3..316a15a54 100644
--- a/source/linux/duplicates/Registry.cpp
+++ b/source/linux/duplicates/Registry.cpp
@@ -1,19 +1,15 @@
 #include "StdAfx.h"
 #include "Registry.h"
 
-
-
 //===========================================================================
 static inline std::string RegGetSlotSection(UINT slot)
 {
-	return (slot == SLOT_AUX)
-		? std::string(REG_CONFIG_SLOT_AUX)
-		: (std::string(REG_CONFIG_SLOT) + (char)('0' + slot));
+    return (slot == SLOT_AUX) ? std::string(REG_CONFIG_SLOT_AUX) : (std::string(REG_CONFIG_SLOT) + (char)('0' + slot));
 }
 
 std::string RegGetConfigSlotSection(UINT slot)
 {
-	return std::string(REG_CONFIG "\\") + RegGetSlotSection(slot);
+    return std::string(REG_CONFIG "\\") + RegGetSlotSection(slot);
 }
 
 void RegDeleteConfigSlotSection(UINT slot)
@@ -22,24 +18,24 @@ void RegDeleteConfigSlotSection(UINT slot)
 
 void RegSetConfigSlotNewCardType(UINT slot, SS_CARDTYPE type)
 {
-	RegDeleteConfigSlotSection(slot);
+    RegDeleteConfigSlotSection(slot);
 
-	std::string regSection;
-	regSection = RegGetConfigSlotSection(slot);
+    std::string regSection;
+    regSection = RegGetConfigSlotSection(slot);
 
-	RegSaveValue(regSection.c_str(), REGVALUE_CARD_TYPE, TRUE, type);
+    RegSaveValue(regSection.c_str(), REGVALUE_CARD_TYPE, TRUE, type);
 }
 
 void RegSetConfigGameIOConnectorNewDongleType(UINT slot, DONGLETYPE type)
 {
-	_ASSERT(slot == GAME_IO_CONNECTOR);
-	if (slot != GAME_IO_CONNECTOR)
-		return;
+    _ASSERT(slot == GAME_IO_CONNECTOR);
+    if (slot != GAME_IO_CONNECTOR)
+        return;
 
-	RegDeleteConfigSlotSection(slot);
+    RegDeleteConfigSlotSection(slot);
 
-	std::string regSection;
-	regSection = RegGetConfigSlotSection(slot);
+    std::string regSection;
+    regSection = RegGetConfigSlotSection(slot);
 
-	RegSaveValue(regSection.c_str(), REGVALUE_GAME_IO_TYPE, TRUE, type);
+    RegSaveValue(regSection.c_str(), REGVALUE_GAME_IO_TYPE, TRUE, type);
 }
diff --git a/source/linux/duplicates/SNESMAX.cpp b/source/linux/duplicates/SNESMAX.cpp
index 84d5a143c..a7c6e5902 100644
--- a/source/linux/duplicates/SNESMAX.cpp
+++ b/source/linux/duplicates/SNESMAX.cpp
@@ -6,9 +6,9 @@ void SNESMAXCard::InitializeIO(LPBYTE pCxRomPeripheral)
 {
 }
 
-bool SNESMAXCard::ParseControllerMappingFile(UINT joyNum, const char* pathname, std::string& errorMsg)
+bool SNESMAXCard::ParseControllerMappingFile(UINT joyNum, const char *pathname, std::string &errorMsg)
 {
-  return false;
+    return false;
 }
 
 //===========================================================================
@@ -17,26 +17,26 @@ static const UINT kUNIT_VERSION = 1;
 
 #define SS_YAML_KEY_BUTTON_INDEX "Button Index"
 
-const std::string & SNESMAXCard::GetSnapshotCardName(void)
+const std::string &SNESMAXCard::GetSnapshotCardName(void)
 {
-  static const std::string name("SNES MAX");
-  return name;
+    static const std::string name("SNES MAX");
+    return name;
 }
 
-void SNESMAXCard::SaveSnapshot(YamlSaveHelper& yamlSaveHelper)
+void SNESMAXCard::SaveSnapshot(YamlSaveHelper &yamlSaveHelper)
 {
-  YamlSaveHelper::Slot slot(yamlSaveHelper, GetSnapshotCardName(), m_slot, kUNIT_VERSION);
+    YamlSaveHelper::Slot slot(yamlSaveHelper, GetSnapshotCardName(), m_slot, kUNIT_VERSION);
 
-  YamlSaveHelper::Label unit(yamlSaveHelper, "%s:\n", SS_YAML_KEY_STATE);
-  yamlSaveHelper.SaveUint(SS_YAML_KEY_BUTTON_INDEX, m_buttonIndex);
+    YamlSaveHelper::Label unit(yamlSaveHelper, "%s:\n", SS_YAML_KEY_STATE);
+    yamlSaveHelper.SaveUint(SS_YAML_KEY_BUTTON_INDEX, m_buttonIndex);
 }
 
-bool SNESMAXCard::LoadSnapshot(YamlLoadHelper& yamlLoadHelper, UINT version)
+bool SNESMAXCard::LoadSnapshot(YamlLoadHelper &yamlLoadHelper, UINT version)
 {
-  if (version < 1 || version > kUNIT_VERSION)
-    ThrowErrorInvalidVersion(version);
+    if (version < 1 || version > kUNIT_VERSION)
+        ThrowErrorInvalidVersion(version);
 
-  yamlLoadHelper.LoadUint(SS_YAML_KEY_BUTTON_INDEX);
+    yamlLoadHelper.LoadUint(SS_YAML_KEY_BUTTON_INDEX);
 
-  return true;
+    return true;
 }
diff --git a/source/linux/duplicates/SerialComms.cpp b/source/linux/duplicates/SerialComms.cpp
index db0936b35..fb4bb9b8d 100644
--- a/source/linux/duplicates/SerialComms.cpp
+++ b/source/linux/duplicates/SerialComms.cpp
@@ -3,9 +3,8 @@
 #include "SerialComms.h"
 #include "YamlHelper.h"
 
-
-CSuperSerialCard::CSuperSerialCard(UINT slot) :
-  Card(CT_SSC, slot)
+CSuperSerialCard::CSuperSerialCard(UINT slot)
+    : Card(CT_SSC, slot)
 {
 }
 
@@ -13,7 +12,7 @@ CSuperSerialCard::~CSuperSerialCard()
 {
 }
 
-void CSuperSerialCard::SetSerialPortName(const char* pSerialPortName)
+void CSuperSerialCard::SetSerialPortName(const char *pSerialPortName)
 {
 }
 
@@ -53,66 +52,66 @@ static const UINT kUNIT_VERSION = 2;
 #define SS_YAML_KEY_SERIALPORTNAME "Serial Port Name"
 #define SS_YAML_KEY_SUPPORT_DCD "Support DCD"
 
-void CSuperSerialCard::LoadSnapshotDIPSW(YamlLoadHelper& yamlLoadHelper, std::string key, SSC_DIPSW& dipsw)
+void CSuperSerialCard::LoadSnapshotDIPSW(YamlLoadHelper &yamlLoadHelper, std::string key, SSC_DIPSW &dipsw)
 {
-  if (!yamlLoadHelper.GetSubMap(key))
-    throw std::runtime_error("Card: Expected key: " + key);
-
-  yamlLoadHelper.LoadUint(SS_YAML_KEY_BAUDRATE);
-  yamlLoadHelper.LoadUint(SS_YAML_KEY_FWMODE);
-  yamlLoadHelper.LoadUint(SS_YAML_KEY_STOPBITS);
-  yamlLoadHelper.LoadUint(SS_YAML_KEY_BYTESIZE);
-  yamlLoadHelper.LoadUint(SS_YAML_KEY_PARITY);
-  yamlLoadHelper.LoadBool(SS_YAML_KEY_LINEFEED);
-  yamlLoadHelper.LoadBool(SS_YAML_KEY_INTERRUPTS);
-
-  yamlLoadHelper.PopMap();
+    if (!yamlLoadHelper.GetSubMap(key))
+        throw std::runtime_error("Card: Expected key: " + key);
+
+    yamlLoadHelper.LoadUint(SS_YAML_KEY_BAUDRATE);
+    yamlLoadHelper.LoadUint(SS_YAML_KEY_FWMODE);
+    yamlLoadHelper.LoadUint(SS_YAML_KEY_STOPBITS);
+    yamlLoadHelper.LoadUint(SS_YAML_KEY_BYTESIZE);
+    yamlLoadHelper.LoadUint(SS_YAML_KEY_PARITY);
+    yamlLoadHelper.LoadBool(SS_YAML_KEY_LINEFEED);
+    yamlLoadHelper.LoadBool(SS_YAML_KEY_INTERRUPTS);
+
+    yamlLoadHelper.PopMap();
 }
 
-bool CSuperSerialCard::LoadSnapshot(YamlLoadHelper& yamlLoadHelper, UINT version)
+bool CSuperSerialCard::LoadSnapshot(YamlLoadHelper &yamlLoadHelper, UINT version)
 {
-  if (version < 1 || version > kUNIT_VERSION)
-    ThrowErrorInvalidVersion(version);
+    if (version < 1 || version > kUNIT_VERSION)
+        ThrowErrorInvalidVersion(version);
 
-  SSC_DIPSW dipsw;
-  LoadSnapshotDIPSW(yamlLoadHelper, SS_YAML_KEY_DIPSWDEFAULT, dipsw);
-  LoadSnapshotDIPSW(yamlLoadHelper, SS_YAML_KEY_DIPSWCURRENT, dipsw);
+    SSC_DIPSW dipsw;
+    LoadSnapshotDIPSW(yamlLoadHelper, SS_YAML_KEY_DIPSWDEFAULT, dipsw);
+    LoadSnapshotDIPSW(yamlLoadHelper, SS_YAML_KEY_DIPSWCURRENT, dipsw);
 
-  if (version == 1)	// Consume redundant/obsolete data
-  {
-    yamlLoadHelper.LoadUint(SS_YAML_KEY_PARITY);		// Redundant: derived from uCommandByte in UpdateCommandReg()
-    yamlLoadHelper.LoadBool(SS_YAML_KEY_TXIRQENABLED);	// Redundant: derived from uCommandByte in UpdateCommandReg()
-    yamlLoadHelper.LoadBool(SS_YAML_KEY_RXIRQENABLED);	// Redundant: derived from uCommandByte in UpdateCommandReg()
+    if (version == 1) // Consume redundant/obsolete data
+    {
+        yamlLoadHelper.LoadUint(SS_YAML_KEY_PARITY);       // Redundant: derived from uCommandByte in UpdateCommandReg()
+        yamlLoadHelper.LoadBool(SS_YAML_KEY_TXIRQENABLED); // Redundant: derived from uCommandByte in UpdateCommandReg()
+        yamlLoadHelper.LoadBool(SS_YAML_KEY_RXIRQENABLED); // Redundant: derived from uCommandByte in UpdateCommandReg()
 
-    yamlLoadHelper.LoadUint(SS_YAML_KEY_BAUDRATE);		// Redundant: derived from uControlByte in UpdateControlReg()
-    yamlLoadHelper.LoadUint(SS_YAML_KEY_STOPBITS);		// Redundant: derived from uControlByte in UpdateControlReg()
-    yamlLoadHelper.LoadUint(SS_YAML_KEY_BYTESIZE);		// Redundant: derived from uControlByte in UpdateControlReg()
+        yamlLoadHelper.LoadUint(SS_YAML_KEY_BAUDRATE); // Redundant: derived from uControlByte in UpdateControlReg()
+        yamlLoadHelper.LoadUint(SS_YAML_KEY_STOPBITS); // Redundant: derived from uControlByte in UpdateControlReg()
+        yamlLoadHelper.LoadUint(SS_YAML_KEY_BYTESIZE); // Redundant: derived from uControlByte in UpdateControlReg()
 
-    yamlLoadHelper.LoadUint(SS_YAML_KEY_INACTIVITY);	// Obsolete (so just consume)
-  }
-  else if (version >= 2)
-  {
-    yamlLoadHelper.LoadBool(SS_YAML_KEY_SUPPORT_DCD);
-  }
+        yamlLoadHelper.LoadUint(SS_YAML_KEY_INACTIVITY); // Obsolete (so just consume)
+    }
+    else if (version >= 2)
+    {
+        yamlLoadHelper.LoadBool(SS_YAML_KEY_SUPPORT_DCD);
+    }
 
-  yamlLoadHelper.LoadUint(SS_YAML_KEY_COMMAND);
-  yamlLoadHelper.LoadUint(SS_YAML_KEY_CONTROL);
+    yamlLoadHelper.LoadUint(SS_YAML_KEY_COMMAND);
+    yamlLoadHelper.LoadUint(SS_YAML_KEY_CONTROL);
 
-  yamlLoadHelper.LoadBool(SS_YAML_KEY_TXIRQPENDING);
-  yamlLoadHelper.LoadBool(SS_YAML_KEY_RXIRQPENDING);
-  yamlLoadHelper.LoadBool(SS_YAML_KEY_WRITTENTX);
+    yamlLoadHelper.LoadBool(SS_YAML_KEY_TXIRQPENDING);
+    yamlLoadHelper.LoadBool(SS_YAML_KEY_RXIRQPENDING);
+    yamlLoadHelper.LoadBool(SS_YAML_KEY_WRITTENTX);
 
-  yamlLoadHelper.LoadString(SS_YAML_KEY_SERIALPORTNAME);
+    yamlLoadHelper.LoadString(SS_YAML_KEY_SERIALPORTNAME);
 
-  return true;
+    return true;
 }
 
-void CSuperSerialCard::SaveSnapshot(YamlSaveHelper&)
+void CSuperSerialCard::SaveSnapshot(YamlSaveHelper &)
 {
 }
 
-const std::string & CSuperSerialCard::GetSnapshotCardName()
+const std::string &CSuperSerialCard::GetSnapshotCardName()
 {
-  static const std::string name(SS_YAML_VALUE_CARD_SSC);
-  return name;
+    static const std::string name(SS_YAML_VALUE_CARD_SSC);
+    return name;
 }
diff --git a/source/linux/duplicates/tfearch.cpp b/source/linux/duplicates/tfearch.cpp
index 158d5d8df..2bdf7744f 100644
--- a/source/linux/duplicates/tfearch.cpp
+++ b/source/linux/duplicates/tfearch.cpp
@@ -1,10 +1,10 @@
 /*
- * tfearch.c - TFE ("The final ethernet") emulation, 
+ * tfearch.c - TFE ("The final ethernet") emulation,
  *                 architecture-dependant stuff
  *
  * Written by
  *  Spiro Trikaliotis <Spiro.Trikaliotis@gmx.de>
- * 
+ *
  * This file is part of VICE, the Versatile Commodore Emulator.
  * See README for copyright notice.
  *
@@ -25,12 +25,10 @@
  *
  */
 
-
 #include <StdAfx.h> // this is necessary in linux, but in MSVC windows.h MUST come after winsock2.h (from pcap.h above)
 #include "Tfe/tfearch.h"
 #include "../Log.h"
 
-
 /** #define TFE_DEBUG_ARCH 1 **/
 /* #define TFE_DEBUG_FRAMES - might be defined in TFE.H! */
 
@@ -39,7 +37,7 @@ int tfe_arch_enumadapter_open(void)
     return 0;
 }
 
-int tfe_arch_enumadapter(std::string & name, std::string & description)
+int tfe_arch_enumadapter(std::string &name, std::string &description)
 {
     return 0;
 }
@@ -49,84 +47,89 @@ int tfe_arch_enumadapter_close(void)
     return 0;
 }
 
-pcap_t * TfePcapOpenAdapter(const std::string & interface_name)
+pcap_t *TfePcapOpenAdapter(const std::string &interface_name)
 {
     return NULL;
 }
 
-void TfePcapCloseAdapter(pcap_t * TfePcapFP)
+void TfePcapCloseAdapter(pcap_t *TfePcapFP)
 {
 }
 
 /* ------------------------------------------------------------------------- */
 /*    the architecture-dependend functions                                   */
 
-void tfe_arch_set_mac( const BYTE mac[6] )
+void tfe_arch_set_mac(const BYTE mac[6])
 {
 #if defined(TFE_DEBUG_ARCH) || defined(TFE_DEBUG_FRAMES)
-    if(g_fh) fprintf( g_fh, "New MAC address set: %02X:%02X:%02X:%02X:%02X:%02X.\n",
-        mac[0], mac[1], mac[2], mac[3], mac[4], mac[5] );
+    if (g_fh)
+        fprintf(
+            g_fh, "New MAC address set: %02X:%02X:%02X:%02X:%02X:%02X.\n", mac[0], mac[1], mac[2], mac[3], mac[4],
+            mac[5]);
 #endif
 }
 
 void tfe_arch_set_hashfilter(const uint32_t hash_mask[2])
 {
 #if defined(TFE_DEBUG_ARCH) || defined(TFE_DEBUG_FRAMES)
-    if(g_fh) fprintf( g_fh, "New hash filter set: %08X:%08X.\n",
-        hash_mask[1], hash_mask[0]);
+    if (g_fh)
+        fprintf(g_fh, "New hash filter set: %08X:%08X.\n", hash_mask[1], hash_mask[0]);
 #endif
 }
 
-void tfe_arch_recv_ctl( int bBroadcast,   /* broadcast */
-                        int bIA,          /* individual address (IA) */
-                        int bMulticast,   /* multicast if address passes the hash filter */
-                        int bCorrect,     /* accept correct frames */
-                        int bPromiscuous, /* promiscuous mode */
-                        int bIAHash       /* accept if IA passes the hash filter */
-                      )
+void tfe_arch_recv_ctl(
+    int bBroadcast,   /* broadcast */
+    int bIA,          /* individual address (IA) */
+    int bMulticast,   /* multicast if address passes the hash filter */
+    int bCorrect,     /* accept correct frames */
+    int bPromiscuous, /* promiscuous mode */
+    int bIAHash       /* accept if IA passes the hash filter */
+)
 {
 #if defined(TFE_DEBUG_ARCH) || defined(TFE_DEBUG_FRAMES)
-    if(g_fh) {
-        fprintf( g_fh, "tfe_arch_recv_ctl() called with the following parameters:" );
-        fprintf( g_fh, "\tbBroadcast   = %s", bBroadcast   ? "TRUE" : "FALSE" );
-        fprintf( g_fh, "\tbIA          = %s", bIA          ? "TRUE" : "FALSE" );
-        fprintf( g_fh, "\tbMulticast   = %s", bMulticast   ? "TRUE" : "FALSE" );
-        fprintf( g_fh, "\tbCorrect     = %s", bCorrect     ? "TRUE" : "FALSE" );
-        fprintf( g_fh, "\tbPromiscuous = %s", bPromiscuous ? "TRUE" : "FALSE" );
-        fprintf( g_fh, "\tbIAHash      = %s", bIAHash      ? "TRUE" : "FALSE" );
-        fprintf( g_fh, "\n" );
+    if (g_fh)
+    {
+        fprintf(g_fh, "tfe_arch_recv_ctl() called with the following parameters:");
+        fprintf(g_fh, "\tbBroadcast   = %s", bBroadcast ? "TRUE" : "FALSE");
+        fprintf(g_fh, "\tbIA          = %s", bIA ? "TRUE" : "FALSE");
+        fprintf(g_fh, "\tbMulticast   = %s", bMulticast ? "TRUE" : "FALSE");
+        fprintf(g_fh, "\tbCorrect     = %s", bCorrect ? "TRUE" : "FALSE");
+        fprintf(g_fh, "\tbPromiscuous = %s", bPromiscuous ? "TRUE" : "FALSE");
+        fprintf(g_fh, "\tbIAHash      = %s", bIAHash ? "TRUE" : "FALSE");
+        fprintf(g_fh, "\n");
     }
 #endif
 }
 
-void tfe_arch_line_ctl(int bEnableTransmitter, int bEnableReceiver )
+void tfe_arch_line_ctl(int bEnableTransmitter, int bEnableReceiver)
 {
 #if defined(TFE_DEBUG_ARCH) || defined(TFE_DEBUG_FRAMES)
-    if(g_fh) {
-        fprintf( g_fh, "tfe_arch_line_ctl() called with the following parameters:" );
-        fprintf( g_fh, "\tbEnableTransmitter = %s", bEnableTransmitter ? "TRUE" : "FALSE" );
-        fprintf( g_fh, "\tbEnableReceiver    = %s", bEnableReceiver    ? "TRUE" : "FALSE" );
-        fprintf( g_fh, "\n" );
+    if (g_fh)
+    {
+        fprintf(g_fh, "tfe_arch_line_ctl() called with the following parameters:");
+        fprintf(g_fh, "\tbEnableTransmitter = %s", bEnableTransmitter ? "TRUE" : "FALSE");
+        fprintf(g_fh, "\tbEnableReceiver    = %s", bEnableReceiver ? "TRUE" : "FALSE");
+        fprintf(g_fh, "\n");
     }
 #endif
 }
 
-void tfe_arch_transmit(pcap_t * TfePcapFP,
-                       int txlength,    /* Frame length */
-                       BYTE *txframe    /* Pointer to the frame to be transmitted */
-                      )
+void tfe_arch_transmit(
+    pcap_t *TfePcapFP, int txlength, /* Frame length */
+    BYTE *txframe                    /* Pointer to the frame to be transmitted */
+)
 {
 }
 
-int tfe_arch_receive(pcap_t * TfePcapFP,
-                     const int size ,    /* Size of buffer */
-                     BYTE *pbuffer       /* where to store a frame */
-                    )
+int tfe_arch_receive(
+    pcap_t *TfePcapFP, const int size, /* Size of buffer */
+    BYTE *pbuffer                      /* where to store a frame */
+)
 {
     return -1;
 }
 
-const char * tfe_arch_lib_version()
+const char *tfe_arch_lib_version()
 {
     return 0;
 }
@@ -136,4 +139,4 @@ int tfe_arch_is_npcap_loaded()
     return 0;
 }
 
-//#endif /* #ifdef HAVE_TFE */
+// #endif /* #ifdef HAVE_TFE */
diff --git a/source/linux/keyboardbuffer.h b/source/linux/keyboardbuffer.h
index 83a37335f..9edf1632d 100644
--- a/source/linux/keyboardbuffer.h
+++ b/source/linux/keyboardbuffer.h
@@ -1,3 +1,3 @@
 // these are defined in source/linux/duplicates/Keyboard.cpp
 void addKeyToBuffer(BYTE key);
-void addTextToBuffer(const char * text);
+void addTextToBuffer(const char *text);
diff --git a/source/linux/libwindows/dmusicc.cpp b/source/linux/libwindows/dmusicc.cpp
index 8004b3992..b3fe47966 100644
--- a/source/linux/libwindows/dmusicc.cpp
+++ b/source/linux/libwindows/dmusicc.cpp
@@ -3,15 +3,16 @@
 
 HRESULT IReferenceClock::GetTime(REFERENCE_TIME *pTime)
 {
-  return S_OK;
+    return S_OK;
 }
 
-HRESULT IReferenceClock::AdvisePeriodic(REFERENCE_TIME startTime, REFERENCE_TIME periodTime, HSEMAPHORE hSemaphore, DWORD_PTR *pdwAdviseCookie)
+HRESULT IReferenceClock::AdvisePeriodic(
+    REFERENCE_TIME startTime, REFERENCE_TIME periodTime, HSEMAPHORE hSemaphore, DWORD_PTR *pdwAdviseCookie)
 {
-  return S_OK;
+    return S_OK;
 }
 
 HRESULT IReferenceClock::Unadvise(DWORD_PTR dwAdviseCookie)
 {
-  return S_OK;
+    return S_OK;
 }
diff --git a/source/linux/libwindows/dmusicc.h b/source/linux/libwindows/dmusicc.h
index 276fb406c..872758350 100644
--- a/source/linux/libwindows/dmusicc.h
+++ b/source/linux/libwindows/dmusicc.h
@@ -6,7 +6,8 @@
 typedef LONGLONG REFERENCE_TIME;
 struct IReferenceClock : public IAutoRelease
 {
-  HRESULT GetTime(REFERENCE_TIME *pTime);
-  HRESULT AdvisePeriodic(REFERENCE_TIME startTime, REFERENCE_TIME periodTime, HSEMAPHORE hSemaphore, DWORD_PTR *pdwAdviseCookie);
-  HRESULT Unadvise(DWORD_PTR dwAdviseCookie);
+    HRESULT GetTime(REFERENCE_TIME *pTime);
+    HRESULT AdvisePeriodic(
+        REFERENCE_TIME startTime, REFERENCE_TIME periodTime, HSEMAPHORE hSemaphore, DWORD_PTR *pdwAdviseCookie);
+    HRESULT Unadvise(DWORD_PTR dwAdviseCookie);
 };
diff --git a/source/linux/libwindows/dsound.h b/source/linux/libwindows/dsound.h
index 61a5c6f98..0d6ef7111 100644
--- a/source/linux/libwindows/dsound.h
+++ b/source/linux/libwindows/dsound.h
@@ -4,64 +4,65 @@
 #include "mmreg.h"
 #include "guiddef.h"
 
-#define DS_OK				0
+#define DS_OK 0
 
-#define DSBCAPS_CTRLVOLUME          0x00000080
-#define DSBCAPS_LOCSOFTWARE         0x00000008
-#define DSBCAPS_CTRLPOSITIONNOTIFY  0x00000100
-#define DSBCAPS_STICKYFOCUS         0x00004000
+#define DSBCAPS_CTRLVOLUME 0x00000080
+#define DSBCAPS_LOCSOFTWARE 0x00000008
+#define DSBCAPS_CTRLPOSITIONNOTIFY 0x00000100
+#define DSBCAPS_STICKYFOCUS 0x00004000
 #define DSBCAPS_GETCURRENTPOSITION2 0x00010000
 
-#define DSBVOLUME_MIN               -10000
-#define DSBVOLUME_MAX               0
+#define DSBVOLUME_MIN -10000
+#define DSBVOLUME_MAX 0
 
-#define DSBPLAY_LOOPING             0x00000001
+#define DSBPLAY_LOOPING 0x00000001
 
-#define DSBSTATUS_PLAYING           0x00000001
-#define DSBSTATUS_BUFFERLOST        0x00000002
-#define DSBSTATUS_LOOPING           0x00000004
+#define DSBSTATUS_PLAYING 0x00000001
+#define DSBSTATUS_BUFFERLOST 0x00000002
+#define DSBSTATUS_LOOPING 0x00000004
 
-#define DSBLOCK_ENTIREBUFFER        0x00000002
+#define DSBLOCK_ENTIREBUFFER 0x00000002
 
-#define _FACDS                      0x878
-#define MAKE_DSHRESULT(code)        MAKE_HRESULT(1,_FACDS,code)
+#define _FACDS 0x878
+#define MAKE_DSHRESULT(code) MAKE_HRESULT(1, _FACDS, code)
 
-#define DSERR_ALLOCATED             MAKE_DSHRESULT(10)
-#define DSERR_CONTROLUNAVAIL        MAKE_DSHRESULT(30)
-#define DSERR_INVALIDPARAM          E_INVALIDARG
-#define DSERR_INVALIDCALL           MAKE_DSHRESULT(50)
-#define DSERR_GENERIC               E_FAIL
-#define DSERR_PRIOLEVELNEEDED       MAKE_DSHRESULT(70)
-#define DSERR_OUTOFMEMORY           E_OUTOFMEMORY
-#define DSERR_BADFORMAT             MAKE_DSHRESULT(100)
-#define DSERR_UNSUPPORTED           E_NOTIMPL
-#define DSERR_NODRIVER              MAKE_DSHRESULT(120)
-#define DSERR_ALREADYINITIALIZED    MAKE_DSHRESULT(130)
-#define DSERR_NOAGGREGATION         CLASS_E_NOAGGREGATION
-#define DSERR_BUFFERLOST            MAKE_DSHRESULT(150)
-#define DSERR_OTHERAPPHASPRIO       MAKE_DSHRESULT(160)
-#define DSERR_UNINITIALIZED         MAKE_DSHRESULT(170)
-#define DSERR_NOINTERFACE           E_NOINTERFACE
+#define DSERR_ALLOCATED MAKE_DSHRESULT(10)
+#define DSERR_CONTROLUNAVAIL MAKE_DSHRESULT(30)
+#define DSERR_INVALIDPARAM E_INVALIDARG
+#define DSERR_INVALIDCALL MAKE_DSHRESULT(50)
+#define DSERR_GENERIC E_FAIL
+#define DSERR_PRIOLEVELNEEDED MAKE_DSHRESULT(70)
+#define DSERR_OUTOFMEMORY E_OUTOFMEMORY
+#define DSERR_BADFORMAT MAKE_DSHRESULT(100)
+#define DSERR_UNSUPPORTED E_NOTIMPL
+#define DSERR_NODRIVER MAKE_DSHRESULT(120)
+#define DSERR_ALREADYINITIALIZED MAKE_DSHRESULT(130)
+#define DSERR_NOAGGREGATION CLASS_E_NOAGGREGATION
+#define DSERR_BUFFERLOST MAKE_DSHRESULT(150)
+#define DSERR_OTHERAPPHASPRIO MAKE_DSHRESULT(160)
+#define DSERR_UNINITIALIZED MAKE_DSHRESULT(170)
+#define DSERR_NOINTERFACE E_NOINTERFACE
 
-#define	DSSCL_NORMAL                1
+#define DSSCL_NORMAL 1
 
-typedef struct {
-  DWORD  dwSize;
-  DWORD  dwFlags;
-  DWORD  dwFormats;
-  DWORD  dwChannels;
+typedef struct
+{
+    DWORD dwSize;
+    DWORD dwFlags;
+    DWORD dwFormats;
+    DWORD dwChannels;
 } DSCCAPS, DSCAPS, *LPDSCCAPS;
 
 typedef const DSCCAPS *LPCDSCCAPS;
 
 typedef struct _DSBUFFERDESC
 {
-  DWORD		dwSize;
-  DWORD		dwFlags;
-  DWORD		dwBufferBytes;
-  DWORD		dwReserved;
-  LPWAVEFORMATEX	lpwfxFormat;
-  GUID		guid3DAlgorithm;
-  LPCSTR  szName;  // only in the linux version to differentiate the channels
-} DSBUFFERDESC,*LPDSBUFFERDESC;
+    DWORD dwSize;
+    DWORD dwFlags;
+    DWORD dwBufferBytes;
+    DWORD dwReserved;
+    LPWAVEFORMATEX lpwfxFormat;
+    GUID guid3DAlgorithm;
+    LPCSTR szName; // only in the linux version to differentiate the channels
+} DSBUFFERDESC, *LPDSBUFFERDESC;
 typedef const DSBUFFERDESC *LPCDSBUFFERDESC;
diff --git a/source/linux/libwindows/fileapi.cpp b/source/linux/libwindows/fileapi.cpp
index 648192c4d..e02bf2b21 100644
--- a/source/linux/libwindows/fileapi.cpp
+++ b/source/linux/libwindows/fileapi.cpp
@@ -7,157 +7,160 @@
 
 namespace
 {
-  struct FILE_HANDLE : public CHANDLE
-  {
-    FILE_HANDLE(FILE * ff) : f(ff) {}
-    FILE * f = nullptr;
-    ~FILE_HANDLE() override
+    struct FILE_HANDLE : public CHANDLE
     {
-      if (f)
-      {
-        fclose(f);
-      }
+        FILE_HANDLE(FILE *ff)
+            : f(ff)
+        {
+        }
+        FILE *f = nullptr;
+        ~FILE_HANDLE() override
+        {
+            if (f)
+            {
+                fclose(f);
+            }
+        }
+    };
+} // namespace
+
+DWORD SetFilePointer(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod)
+{
+    const FILE_HANDLE &file_handle = dynamic_cast<FILE_HANDLE &>(*hFile);
+
+    const int res = fseek(file_handle.f, lDistanceToMove, dwMoveMethod);
+    if (res)
+    {
+        return INVALID_SET_FILE_POINTER;
+    }
+    else
+    {
+        return ftell(file_handle.f);
     }
-  };
 }
 
-DWORD SetFilePointer(HANDLE hFile, LONG lDistanceToMove,
-       PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod)
+BOOL ReadFile(
+    HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped)
 {
-  const FILE_HANDLE & file_handle = dynamic_cast<FILE_HANDLE &>(*hFile);
-
-  const int res = fseek(file_handle.f, lDistanceToMove, dwMoveMethod);
-  if (res)
-  {
-    return INVALID_SET_FILE_POINTER;
-  }
-  else
-  {
-    return ftell(file_handle.f);
-  }
-}
+    const FILE_HANDLE &file_handle = dynamic_cast<FILE_HANDLE &>(*hFile);
 
-BOOL ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
-              LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped)   {
-  const FILE_HANDLE & file_handle = dynamic_cast<FILE_HANDLE &>(*hFile);
-
-  /* read something from file */
-  DWORD bytesread = fread(lpBuffer, 1, nNumberOfBytesToRead, file_handle.f);
-  *lpNumberOfBytesRead = bytesread;
-  return nNumberOfBytesToRead == bytesread;
+    /* read something from file */
+    DWORD bytesread = fread(lpBuffer, 1, nNumberOfBytesToRead, file_handle.f);
+    *lpNumberOfBytesRead = bytesread;
+    return nNumberOfBytesToRead == bytesread;
 }
 
-BOOL WriteFile(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite,
-               LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped) {
+BOOL WriteFile(
+    HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten,
+    LPOVERLAPPED lpOverlapped)
+{
 
-  const FILE_HANDLE & file_handle = dynamic_cast<FILE_HANDLE &>(*hFile);
+    const FILE_HANDLE &file_handle = dynamic_cast<FILE_HANDLE &>(*hFile);
 
-  /* write something to file */
-  DWORD byteswritten = fwrite(lpBuffer, 1, nNumberOfBytesToWrite, file_handle.f);
-  *lpNumberOfBytesWritten = byteswritten;
-  return nNumberOfBytesToWrite == byteswritten;
+    /* write something to file */
+    DWORD byteswritten = fwrite(lpBuffer, 1, nNumberOfBytesToWrite, file_handle.f);
+    *lpNumberOfBytesWritten = byteswritten;
+    return nNumberOfBytesToWrite == byteswritten;
 }
 
-BOOL DeleteFile(LPCTSTR lpFileName) {
-  if (remove(lpFileName) == 0)
-    return TRUE;
-  else
-    return FALSE;
+BOOL DeleteFile(LPCTSTR lpFileName)
+{
+    if (remove(lpFileName) == 0)
+        return TRUE;
+    else
+        return FALSE;
 }
 
-DWORD GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh) {
-  const FILE_HANDLE & file_handle = dynamic_cast<FILE_HANDLE &>(*hFile);
-  /* what is the size of the specified file??? Hmmm, really I donna. ^_^ */
-  long lcurset = ftell(file_handle.f); // remember current file position
-
-  fseek(file_handle.f, 0, FILE_END);    // go to the end of file
-  DWORD lfilesize = ftell(file_handle.f); // that is the real size of file, isn't it??
-  fseek(file_handle.f, lcurset, FILE_BEGIN); // let the file position be the same as before
-  return lfilesize;
+DWORD GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh)
+{
+    const FILE_HANDLE &file_handle = dynamic_cast<FILE_HANDLE &>(*hFile);
+    /* what is the size of the specified file??? Hmmm, really I donna. ^_^ */
+    long lcurset = ftell(file_handle.f); // remember current file position
+
+    fseek(file_handle.f, 0, FILE_END);         // go to the end of file
+    DWORD lfilesize = ftell(file_handle.f);    // that is the real size of file, isn't it??
+    fseek(file_handle.f, lcurset, FILE_BEGIN); // let the file position be the same as before
+    return lfilesize;
 }
 
-HANDLE CreateFile(LPCTSTR               lpFileName,
-                  DWORD                 dwDesiredAccess,
-                  DWORD                 dwShareMode,
-                  LPSECURITY_ATTRIBUTES lpSecurityAttributes,
-                  DWORD                 dwCreationDisposition,
-                  DWORD                 dwFlagsAndAttributes,
-                  HANDLE                hTemplateFile)
+HANDLE CreateFile(
+    LPCTSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes,
+    DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
 {
-  FILE * f = nullptr;
-  if (dwCreationDisposition == CREATE_NEW || dwCreationDisposition == CREATE_ALWAYS)
-  {
-    if (dwDesiredAccess & GENERIC_READ)
-      f = fopen(lpFileName, "w+");
-    else
-      f = fopen(lpFileName, "w");
-  }
+    FILE *f = nullptr;
+    if (dwCreationDisposition == CREATE_NEW || dwCreationDisposition == CREATE_ALWAYS)
+    {
+        if (dwDesiredAccess & GENERIC_READ)
+            f = fopen(lpFileName, "w+");
+        else
+            f = fopen(lpFileName, "w");
+    }
 
-  if (dwCreationDisposition == OPEN_EXISTING)
-  {
-    if (dwDesiredAccess & GENERIC_WRITE)
-      f = fopen(lpFileName, "r+");
+    if (dwCreationDisposition == OPEN_EXISTING)
+    {
+        if (dwDesiredAccess & GENERIC_WRITE)
+            f = fopen(lpFileName, "r+");
+        else
+            f = fopen(lpFileName, "r");
+    }
+
+    if (f)
+    {
+        return new FILE_HANDLE(f);
+    }
     else
-      f = fopen(lpFileName, "r");
-  }
-
-  if (f)
-  {
-    return new FILE_HANDLE(f);
-  }
-  else
-  {
-    return INVALID_HANDLE_VALUE;
-  }
+    {
+        return INVALID_HANDLE_VALUE;
+    }
 }
 
-DWORD GetFileAttributes(const char * filename)
+DWORD GetFileAttributes(const char *filename)
 {
-  // minimum is R_OK
-  // no point checking F_OK as it is useless
-  const int read = access(filename, R_OK);
-  if (read)
-    return INVALID_FILE_ATTRIBUTES;
+    // minimum is R_OK
+    // no point checking F_OK as it is useless
+    const int read = access(filename, R_OK);
+    if (read)
+        return INVALID_FILE_ATTRIBUTES;
 
-  const int write = access(filename, W_OK);
-  if (write)
-    return FILE_ATTRIBUTE_READONLY;
+    const int write = access(filename, W_OK);
+    if (write)
+        return FILE_ATTRIBUTE_READONLY;
 
-  return FILE_ATTRIBUTE_NORMAL;
+    return FILE_ATTRIBUTE_NORMAL;
 }
 
-DWORD GetFullPathName(const char* filename, DWORD length, char * buffer, char ** filePart)
+DWORD GetFullPathName(const char *filename, DWORD length, char *buffer, char **filePart)
 {
-  // what is the filename does not exist?
-  // unfortunately realpath returns -ENOENT
-  const char * result = realpath(filename, buffer);
-  if (!result)
-  {
-    *buffer = 0;
-  }
-  return strlen(buffer);
+    // what is the filename does not exist?
+    // unfortunately realpath returns -ENOENT
+    const char *result = realpath(filename, buffer);
+    if (!result)
+    {
+        *buffer = 0;
+    }
+    return strlen(buffer);
 }
 
-DWORD GetCurrentDirectory(DWORD length, char * buffer)
+DWORD GetCurrentDirectory(DWORD length, char *buffer)
 {
-  const char * cwd = getcwd(buffer, length);
+    const char *cwd = getcwd(buffer, length);
 
-  if (cwd)
-  {
-    return strlen(buffer);
-  }
-  else
-  {
-    return 0;
-  }
+    if (cwd)
+    {
+        return strlen(buffer);
+    }
+    else
+    {
+        return 0;
+    }
 }
 
 BOOL GetOpenFileName(LPOPENFILENAME lpofn)
 {
-  return FALSE;
+    return FALSE;
 }
 
 BOOL GetSaveFileName(LPOPENFILENAME lpofn)
 {
-  return FALSE;
+    return FALSE;
 }
diff --git a/source/linux/libwindows/fileapi.h b/source/linux/libwindows/fileapi.h
index dd1d4fe6e..764bb99f8 100644
--- a/source/linux/libwindows/fileapi.h
+++ b/source/linux/libwindows/fileapi.h
@@ -3,71 +3,65 @@
 #include "wincompat.h"
 #include "winhandles.h"
 
-#define INVALID_FILE_ATTRIBUTES  (~0u)
+#define INVALID_FILE_ATTRIBUTES (~0u)
 #define INVALID_SET_FILE_POINTER (~0u)
 
-typedef struct tagOFN {
-  DWORD         lStructSize;
-  HWND          hwndOwner;
-  HINSTANCE     hInstance;
-  LPCTSTR       lpstrFilter;
-  LPTSTR        lpstrFile;
-  DWORD         nMaxFile;
-  LPCTSTR       lpstrInitialDir;
-  LPCTSTR       lpstrTitle;
-  DWORD         Flags;
-  WORD          nFileExtension;
-  WORD          nFileOffset;
+typedef struct tagOFN
+{
+    DWORD lStructSize;
+    HWND hwndOwner;
+    HINSTANCE hInstance;
+    LPCTSTR lpstrFilter;
+    LPTSTR lpstrFile;
+    DWORD nMaxFile;
+    LPCTSTR lpstrInitialDir;
+    LPCTSTR lpstrTitle;
+    DWORD Flags;
+    WORD nFileExtension;
+    WORD nFileOffset;
 } OPENFILENAME, *LPOPENFILENAME;
 
-#define FILE_BEGIN      SEEK_SET
-#define FILE_CURRENT    SEEK_CUR
-#define FILE_END        SEEK_END
+#define FILE_BEGIN SEEK_SET
+#define FILE_CURRENT SEEK_CUR
+#define FILE_END SEEK_END
 
 #define FILE_ATTRIBUTE_READONLY 0x00000001
 #define FILE_ATTRIBUTE_NORMAL 0
 
-#define OFN_READONLY                 0x00000001
-#define OFN_HIDEREADONLY             0x00000004
-#define OFN_PATHMUSTEXIST            0x00000800
-#define OFN_FILEMUSTEXIST            0x00001000
-#define OPEN_EXISTING           3
-#define CREATE_NEW              1
-#define CREATE_ALWAYS           2
+#define OFN_READONLY 0x00000001
+#define OFN_HIDEREADONLY 0x00000004
+#define OFN_PATHMUSTEXIST 0x00000800
+#define OFN_FILEMUSTEXIST 0x00001000
+#define OPEN_EXISTING 3
+#define CREATE_NEW 1
+#define CREATE_ALWAYS 2
 
 #define GENERIC_READ 0x80000000
 #define GENERIC_WRITE 0x40000000
 #define FILE_SHARE_READ 0x00000001
 
-#define _MAX_FNAME          256
-#define _MAX_EXT            _MAX_FNAME
+#define _MAX_FNAME 256
+#define _MAX_EXT _MAX_FNAME
 
-DWORD SetFilePointer(HANDLE hFile,
-       LONG lDistanceToMove,
-       PLONG lpDistanceToMoveHigh,
-       DWORD dwMoveMethod);
+DWORD SetFilePointer(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod);
 
-BOOL ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
-                     LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped);
+BOOL ReadFile(
+    HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped);
 
-BOOL WriteFile(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite,
-                    LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped);
+BOOL WriteFile(
+    HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten,
+    LPOVERLAPPED lpOverlapped);
 
 BOOL DeleteFile(LPCTSTR lpFileName);
 
-DWORD GetFileAttributes(const char * filename);
-DWORD GetFullPathName(const char* filename, DWORD, char *, char **);
+DWORD GetFileAttributes(const char *filename);
+DWORD GetFullPathName(const char *filename, DWORD, char *, char **);
 BOOL GetOpenFileName(LPOPENFILENAME lpofn);
 BOOL GetSaveFileName(LPOPENFILENAME lpofn);
 
-HANDLE CreateFile(LPCTSTR               lpFileName,
-                  DWORD                 dwDesiredAccess,
-                  DWORD                 dwShareMode,
-                  LPSECURITY_ATTRIBUTES lpSecurityAttributes,
-                  DWORD                 dwCreationDisposition,
-                  DWORD                 dwFlagsAndAttributes,
-                  HANDLE                hTemplateFile
-);
+HANDLE CreateFile(
+    LPCTSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes,
+    DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile);
 
 DWORD GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh);
 
diff --git a/source/linux/libwindows/guiddef.cpp b/source/linux/libwindows/guiddef.cpp
index 7d41f42fd..3f519a1f6 100644
--- a/source/linux/libwindows/guiddef.cpp
+++ b/source/linux/libwindows/guiddef.cpp
@@ -3,28 +3,22 @@
 
 HRESULT IUnknown::QueryInterface(int riid, void **ppvObject)
 {
-  return S_OK;
+    return S_OK;
 }
 
 HRESULT IUnknown::Release()
 {
-  return S_OK;
+    return S_OK;
 }
 
 HRESULT IAutoRelease::Release()
 {
-  const HRESULT res = IUnknown::Release();
-  delete this;
-  return res;
+    const HRESULT res = IUnknown::Release();
+    delete this;
+    return res;
 }
 
-HRESULT CoCreateInstance(
-  REFCLSID  rclsid,
-  LPUNKNOWN pUnkOuter,
-  DWORD     dwClsContext,
-  REFIID    riid,
-  LPVOID    *ppv
-)
+HRESULT CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID riid, LPVOID *ppv)
 {
-  return S_OK;
+    return S_OK;
 }
diff --git a/source/linux/libwindows/guiddef.h b/source/linux/libwindows/guiddef.h
index 5e10a4275..4a3538bd6 100644
--- a/source/linux/libwindows/guiddef.h
+++ b/source/linux/libwindows/guiddef.h
@@ -13,22 +13,16 @@ typedef GUID REFIID;
 
 struct IUnknown
 {
-  HRESULT QueryInterface(int riid, void **ppvObject);
-  virtual HRESULT Release();
+    HRESULT QueryInterface(int riid, void **ppvObject);
+    virtual HRESULT Release();
 
-  virtual ~IUnknown() = default;
+    virtual ~IUnknown() = default;
 };
 typedef IUnknown *LPUNKNOWN;
 
 struct IAutoRelease : public IUnknown
 {
-  virtual HRESULT Release() override;
+    virtual HRESULT Release() override;
 };
 
-HRESULT CoCreateInstance(
-  REFCLSID  rclsid,
-  LPUNKNOWN pUnkOuter,
-  DWORD     dwClsContext,
-  REFIID    riid,
-  LPVOID    *ppv
-);
+HRESULT CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID riid, LPVOID *ppv);
diff --git a/source/linux/libwindows/joystickapi.h b/source/linux/libwindows/joystickapi.h
index a555e4399..e18b3cd15 100644
--- a/source/linux/libwindows/joystickapi.h
+++ b/source/linux/libwindows/joystickapi.h
@@ -2,18 +2,19 @@
 
 #include "wincompat.h"
 
-typedef struct joyinfoex_tag {
-  DWORD dwSize;
-  DWORD dwFlags;
-  DWORD dwXpos;
-  DWORD dwYpos;
-  DWORD dwZpos;
-  DWORD dwRpos;
-  DWORD dwUpos;
-  DWORD dwVpos;
-  DWORD dwButtons;
-  DWORD dwButtonNumber;
-  DWORD dwPOV;
-  DWORD dwReserved1;
-  DWORD dwReserved2;
+typedef struct joyinfoex_tag
+{
+    DWORD dwSize;
+    DWORD dwFlags;
+    DWORD dwXpos;
+    DWORD dwYpos;
+    DWORD dwZpos;
+    DWORD dwRpos;
+    DWORD dwUpos;
+    DWORD dwVpos;
+    DWORD dwButtons;
+    DWORD dwButtonNumber;
+    DWORD dwPOV;
+    DWORD dwReserved1;
+    DWORD dwReserved2;
 } JOYINFOEX, *PJOYINFOEX, *NPJOYINFOEX, *LPJOYINFOEX;
diff --git a/source/linux/libwindows/misc.cpp b/source/linux/libwindows/misc.cpp
index 8d9336eda..2de7e7acb 100644
--- a/source/linux/libwindows/misc.cpp
+++ b/source/linux/libwindows/misc.cpp
@@ -2,5 +2,5 @@
 
 BOOL WINAPI PostMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
 {
-  return TRUE;
+    return TRUE;
 }
diff --git a/source/linux/libwindows/misc.h b/source/linux/libwindows/misc.h
index a76d74087..c10276c4c 100644
--- a/source/linux/libwindows/misc.h
+++ b/source/linux/libwindows/misc.h
@@ -7,37 +7,37 @@
 
 #define WM_USER 0x0400
 #ifndef INVALID_SOCKET
-#define INVALID_SOCKET             (SOCKET)(~0)
+#define INVALID_SOCKET (SOCKET)(~0)
 #endif
 
-#define MB_OK			0x00000000
-#define MB_OKCANCEL		0x00000001
-#define MB_ICONEXCLAMATION	0x00000030
-#define MB_YESNO		0x00000004
-#define MB_YESNOCANCEL		0x00000003
-#define MB_ICONHAND		0x00000010
-#define MB_ICONQUESTION		0x00000020
-#define MB_ICONASTERISK		0x00000040
-#define MB_SETFOREGROUND	0x00010000
-#define MB_ICONSTOP		MB_ICONHAND
-#define MB_ICONWARNING		MB_ICONEXCLAMATION
-#define MB_ICONINFORMATION	MB_ICONASTERISK
+#define MB_OK 0x00000000
+#define MB_OKCANCEL 0x00000001
+#define MB_ICONEXCLAMATION 0x00000030
+#define MB_YESNO 0x00000004
+#define MB_YESNOCANCEL 0x00000003
+#define MB_ICONHAND 0x00000010
+#define MB_ICONQUESTION 0x00000020
+#define MB_ICONASTERISK 0x00000040
+#define MB_SETFOREGROUND 0x00010000
+#define MB_ICONSTOP MB_ICONHAND
+#define MB_ICONWARNING MB_ICONEXCLAMATION
+#define MB_ICONINFORMATION MB_ICONASTERISK
 
 #define IDOK 1
 #define IDCANCEL 2
 #define IDYES 6
 #define IDNO 7
 
-#define EINVAL          22
+#define EINVAL 22
 
 BOOL WINAPI PostMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
 int MessageBox(HWND, const char *, const char *, UINT);
 
-void OutputDebugString(const char * str);
+void OutputDebugString(const char *str);
 
-void DeleteCriticalSection(CRITICAL_SECTION * criticalSection);
-void InitializeCriticalSection(CRITICAL_SECTION * criticalSection);
-void EnterCriticalSection(CRITICAL_SECTION * criticalSection);
-void LeaveCriticalSection(CRITICAL_SECTION * criticalSection);
+void DeleteCriticalSection(CRITICAL_SECTION *criticalSection);
+void InitializeCriticalSection(CRITICAL_SECTION *criticalSection);
+void EnterCriticalSection(CRITICAL_SECTION *criticalSection);
+void LeaveCriticalSection(CRITICAL_SECTION *criticalSection);
 
 void ExitProcess(int);
diff --git a/source/linux/libwindows/mmreg.h b/source/linux/libwindows/mmreg.h
index fa0540d28..96b07d2af 100644
--- a/source/linux/libwindows/mmreg.h
+++ b/source/linux/libwindows/mmreg.h
@@ -2,12 +2,13 @@
 
 #include "wincompat.h"
 
-typedef struct _WAVEFORMATEX {
-  WORD   wFormatTag;
-  WORD   nChannels;
-  DWORD  nSamplesPerSec;
-  DWORD  nAvgBytesPerSec;
-  WORD   nBlockAlign;
-  WORD   wBitsPerSample;
-  WORD   cbSize;
+typedef struct _WAVEFORMATEX
+{
+    WORD wFormatTag;
+    WORD nChannels;
+    DWORD nSamplesPerSec;
+    DWORD nAvgBytesPerSec;
+    WORD nBlockAlign;
+    WORD wBitsPerSample;
+    WORD cbSize;
 } WAVEFORMATEX, *PWAVEFORMATEX, *NPWAVEFORMATEX, *LPWAVEFORMATEX;
diff --git a/source/linux/libwindows/mmsystem.h b/source/linux/libwindows/mmsystem.h
index 12bf68e6c..3d8272e2f 100644
--- a/source/linux/libwindows/mmsystem.h
+++ b/source/linux/libwindows/mmsystem.h
@@ -1,3 +1,3 @@
 #pragma once
 
-#define WAVE_FORMAT_PCM     1
+#define WAVE_FORMAT_PCM 1
diff --git a/source/linux/libwindows/strsafe.cpp b/source/linux/libwindows/strsafe.cpp
index bcbf93768..3f0099524 100644
--- a/source/linux/libwindows/strsafe.cpp
+++ b/source/linux/libwindows/strsafe.cpp
@@ -1,9 +1,9 @@
 #include "strsafe.h"
 #include <cstring>
 
-HRESULT StringCbCopy(char * pszDest, const size_t cbDest, const char * pszSrc)
+HRESULT StringCbCopy(char *pszDest, const size_t cbDest, const char *pszSrc)
 {
-  strncpy(pszDest, pszSrc, cbDest - 1);
-  pszDest[cbDest - 1] = '\0';
-  return 0;
+    strncpy(pszDest, pszSrc, cbDest - 1);
+    pszDest[cbDest - 1] = '\0';
+    return 0;
 }
diff --git a/source/linux/libwindows/strsafe.h b/source/linux/libwindows/strsafe.h
index 34cd3f762..b244cccb6 100644
--- a/source/linux/libwindows/strsafe.h
+++ b/source/linux/libwindows/strsafe.h
@@ -3,4 +3,4 @@
 #include "wincompat.h"
 #include <cstddef>
 
-HRESULT StringCbCopy(char * pszDest, const size_t cbDest, const char * pszSrc);
+HRESULT StringCbCopy(char *pszDest, const size_t cbDest, const char *pszSrc);
diff --git a/source/linux/libwindows/timeapi.cpp b/source/linux/libwindows/timeapi.cpp
index 051eb8028..cf4152bcb 100644
--- a/source/linux/libwindows/timeapi.cpp
+++ b/source/linux/libwindows/timeapi.cpp
@@ -5,67 +5,71 @@
 #include <cstring>
 #include <sstream>
 
-errno_t ctime_s(char * buf, size_t size, const time_t *time)
+errno_t ctime_s(char *buf, size_t size, const time_t *time)
 {
-  const char * t = asctime(localtime(time));
-  strncpy(buf, t, size);
-  return 0;
+    const char *t = asctime(localtime(time));
+    strncpy(buf, t, size);
+    return 0;
 }
 
 DWORD timeGetTime()
 {
-  struct timeval now;
-  gettimeofday(&now, NULL);
-  return now.tv_usec / 1000;
+    struct timeval now;
+    gettimeofday(&now, NULL);
+    return now.tv_usec / 1000;
 }
 
 /// Returns the number of ticks since an undefined time (usually system startup).
 DWORD GetTickCount()
 {
-  struct timespec ts;
-  clock_gettime(CLOCK_MONOTONIC, &ts);
-  const uint64_t ticks = (uint64_t)(ts.tv_nsec / 1000000) + ((uint64_t)ts.tv_sec * 1000ull);
-  return ticks;
+    struct timespec ts;
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+    const uint64_t ticks = (uint64_t)(ts.tv_nsec / 1000000) + ((uint64_t)ts.tv_sec * 1000ull);
+    return ticks;
 }
 
 void GetLocalTime(SYSTEMTIME *t)
 {
-  timespec ts;
-  clock_gettime(CLOCK_REALTIME, &ts);
+    timespec ts;
+    clock_gettime(CLOCK_REALTIME, &ts);
 
-  time_t tim = ts.tv_sec;
+    time_t tim = ts.tv_sec;
 
-  t->wMilliseconds = ts.tv_nsec / 1000000;
+    t->wMilliseconds = ts.tv_nsec / 1000000;
 
-  tm * local = localtime(&tim);
+    tm *local = localtime(&tim);
 
-  t->wSecond = local->tm_sec;
-  t->wMinute = local->tm_min;
-  t->wHour = local->tm_hour;
-  t->wDayOfWeek = local->tm_wday;
-  t->wDay = local->tm_mday;
-  t->wMonth = local->tm_mon + 1;
-  t->wYear = local->tm_year;
+    t->wSecond = local->tm_sec;
+    t->wMinute = local->tm_min;
+    t->wHour = local->tm_hour;
+    t->wDayOfWeek = local->tm_wday;
+    t->wDay = local->tm_mday;
+    t->wMonth = local->tm_mon + 1;
+    t->wYear = local->tm_year;
 }
 
-int GetDateFormat(LCID /* Locale */, DWORD /* dwFlags */, CONST SYSTEMTIME * /* lpDate */, LPCSTR /* lpFormat */, LPSTR lpDateStr, int cchDate)
+int GetDateFormat(
+    LCID /* Locale */, DWORD /* dwFlags */, CONST SYSTEMTIME * /* lpDate */, LPCSTR /* lpFormat */, LPSTR lpDateStr,
+    int cchDate)
 {
-  std::time_t t = std::time(nullptr);
-  std::tm tm = *std::localtime(&t);
-  std::ostringstream ss;
-  ss << std::put_time(&tm, "%F");
-  const std::string str = ss.str();
-  strncpy(lpDateStr, str.c_str(), cchDate);
-  return cchDate; // not 100% sure, but it is never used
+    std::time_t t = std::time(nullptr);
+    std::tm tm = *std::localtime(&t);
+    std::ostringstream ss;
+    ss << std::put_time(&tm, "%F");
+    const std::string str = ss.str();
+    strncpy(lpDateStr, str.c_str(), cchDate);
+    return cchDate; // not 100% sure, but it is never used
 }
 
-int GetTimeFormat(LCID /* Locale */, DWORD /* dwFlags */, CONST SYSTEMTIME * /* lpTime */, LPCSTR /* lpFormat */, LPSTR lpTimeStr, int cchTime)
+int GetTimeFormat(
+    LCID /* Locale */, DWORD /* dwFlags */, CONST SYSTEMTIME * /* lpTime */, LPCSTR /* lpFormat */, LPSTR lpTimeStr,
+    int cchTime)
 {
-  std::time_t t = std::time(nullptr);
-  std::tm tm = *std::localtime(&t);
-  std::ostringstream ss;
-  ss << std::put_time(&tm, "%T");
-  const std::string str = ss.str();
-  strncpy(lpTimeStr, str.c_str(), cchTime);
-  return cchTime; // not 100% sure, but it is never used
+    std::time_t t = std::time(nullptr);
+    std::tm tm = *std::localtime(&t);
+    std::ostringstream ss;
+    ss << std::put_time(&tm, "%T");
+    const std::string str = ss.str();
+    strncpy(lpTimeStr, str.c_str(), cchTime);
+    return cchTime; // not 100% sure, but it is never used
 }
diff --git a/source/linux/libwindows/timeapi.h b/source/linux/libwindows/timeapi.h
index a110435af..cb0d58fb1 100644
--- a/source/linux/libwindows/timeapi.h
+++ b/source/linux/libwindows/timeapi.h
@@ -5,19 +5,20 @@
 #include <ctime>
 
 #define _tzset tzset
-errno_t ctime_s(char * buf, size_t size, const time_t *time);
+errno_t ctime_s(char *buf, size_t size, const time_t *time);
 
 #define LOCALE_SYSTEM_DEFAULT 0x0800
 
-typedef struct _SYSTEMTIME {
-  WORD wYear;
-  WORD wMonth;
-  WORD wDayOfWeek;
-  WORD wDay;
-  WORD wHour;
-  WORD wMinute;
-  WORD wSecond;
-  WORD wMilliseconds;
+typedef struct _SYSTEMTIME
+{
+    WORD wYear;
+    WORD wMonth;
+    WORD wDayOfWeek;
+    WORD wDay;
+    WORD wHour;
+    WORD wMinute;
+    WORD wSecond;
+    WORD wMilliseconds;
 } SYSTEMTIME, *PSYSTEMTIME;
 
 int GetDateFormat(LCID Locale, DWORD dwFlags, CONST SYSTEMTIME *lpDate, LPCSTR lpFormat, LPSTR lpDateStr, int cchDate);
diff --git a/source/linux/libwindows/winbase.cpp b/source/linux/libwindows/winbase.cpp
index fd1883d4a..de108493d 100644
--- a/source/linux/libwindows/winbase.cpp
+++ b/source/linux/libwindows/winbase.cpp
@@ -7,103 +7,97 @@
 #include <unistd.h>
 #include <sstream>
 
-
-DWORD       WINAPI GetLastError(void)
+DWORD WINAPI GetLastError(void)
 {
-  return errno;
+    return errno;
 }
 
-void DeleteCriticalSection(CRITICAL_SECTION * criticalSection)
+void DeleteCriticalSection(CRITICAL_SECTION *criticalSection)
 {
 }
 
-void InitializeCriticalSection(CRITICAL_SECTION * criticalSection)
+void InitializeCriticalSection(CRITICAL_SECTION *criticalSection)
 {
 }
 
-void EnterCriticalSection(CRITICAL_SECTION * criticalSection)
+void EnterCriticalSection(CRITICAL_SECTION *criticalSection)
 {
 }
 
-void LeaveCriticalSection(CRITICAL_SECTION * criticalSection)
+void LeaveCriticalSection(CRITICAL_SECTION *criticalSection)
 {
 }
 
 BOOL SetCurrentDirectory(LPCSTR path)
 {
-  const int res = chdir(path);
-  return res == 0;
+    const int res = chdir(path);
+    return res == 0;
 }
 
-
-void OutputDebugString(const char * str)
+void OutputDebugString(const char *str)
 {
-  std::cerr << str;
+    std::cerr << str;
 }
 
 void ExitProcess(int status)
 {
-  std::ostringstream buffer("ExitProcess: ");
-  buffer << status;
+    std::ostringstream buffer("ExitProcess: ");
+    buffer << status;
 
-  throw std::runtime_error(buffer.str());
+    throw std::runtime_error(buffer.str());
 }
 
-DWORD       WINAPI WaitForMultipleObjects(DWORD,const HANDLE*,BOOL,DWORD)
+DWORD WINAPI WaitForMultipleObjects(DWORD, const HANDLE *, BOOL, DWORD)
 {
-  return WAIT_FAILED;
+    return WAIT_FAILED;
 }
 
-DWORD       WINAPI WaitForSingleObject(const HANDLE,DWORD)
+DWORD WINAPI WaitForSingleObject(const HANDLE, DWORD)
 {
-  return WAIT_FAILED;
+    return WAIT_FAILED;
 }
 
-BOOL        WINAPI GetExitCodeThread(HANDLE,LPDWORD code)
+BOOL WINAPI GetExitCodeThread(HANDLE, LPDWORD code)
 {
-  *code = 0;
-  return TRUE;
+    *code = 0;
+    return TRUE;
 }
 
-BOOL        WINAPI SetEvent(HANDLE)
+BOOL WINAPI SetEvent(HANDLE)
 {
-  return TRUE;
+    return TRUE;
 }
 
-VOID        WINAPI Sleep(DWORD ms)
+VOID WINAPI Sleep(DWORD ms)
 {
-  std::this_thread::sleep_for (std::chrono::milliseconds(ms));
+    std::this_thread::sleep_for(std::chrono::milliseconds(ms));
 }
 
-BOOL        WINAPI SetThreadPriority(HANDLE,INT)
+BOOL WINAPI SetThreadPriority(HANDLE, INT)
 {
-  return TRUE;
+    return TRUE;
 }
 
-HANDLE      WINAPI CreateEvent(LPSECURITY_ATTRIBUTES,BOOL,BOOL,LPCSTR)
+HANDLE WINAPI CreateEvent(LPSECURITY_ATTRIBUTES, BOOL, BOOL, LPCSTR)
 {
-  return INVALID_HANDLE_VALUE;
+    return INVALID_HANDLE_VALUE;
 }
 
-HANDLE      WINAPI CreateThread(LPSECURITY_ATTRIBUTES,SIZE_T,LPTHREAD_START_ROUTINE,LPVOID,DWORD,LPDWORD)
+HANDLE WINAPI CreateThread(LPSECURITY_ATTRIBUTES, SIZE_T, LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD)
 {
-  return INVALID_HANDLE_VALUE;
+    return INVALID_HANDLE_VALUE;
 }
 
-BOOL WINAPI QueryPerformanceCounter(LARGE_INTEGER*counter)
+BOOL WINAPI QueryPerformanceCounter(LARGE_INTEGER *counter)
 {
-  const auto now = std::chrono::steady_clock::now();
-  const auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
-  counter->QuadPart = ms.count();
-  return TRUE;
+    const auto now = std::chrono::steady_clock::now();
+    const auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
+    counter->QuadPart = ms.count();
+    return TRUE;
 }
 
 HANDLE CreateSemaphore(
-  LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
-  LONG                  lInitialCount,
-  LONG                  lMaximumCount,
-  LPCSTR                lpName
-)
+    LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCSTR lpName)
 {
-  return INVALID_HANDLE_VALUE;
+    return INVALID_HANDLE_VALUE;
 }
diff --git a/source/linux/libwindows/winbase.h b/source/linux/libwindows/winbase.h
index 5103d9278..25d9896cb 100644
--- a/source/linux/libwindows/winbase.h
+++ b/source/linux/libwindows/winbase.h
@@ -5,53 +5,51 @@
 
 #include <cstddef>
 
-DWORD       WINAPI GetLastError(void);
-void DeleteCriticalSection(CRITICAL_SECTION * criticalSection);
-void InitializeCriticalSection(CRITICAL_SECTION * criticalSection);
-void EnterCriticalSection(CRITICAL_SECTION * criticalSection);
-void LeaveCriticalSection(CRITICAL_SECTION * criticalSection);
-void OutputDebugString(const char * str);
+DWORD WINAPI GetLastError(void);
+void DeleteCriticalSection(CRITICAL_SECTION *criticalSection);
+void InitializeCriticalSection(CRITICAL_SECTION *criticalSection);
+void EnterCriticalSection(CRITICAL_SECTION *criticalSection);
+void LeaveCriticalSection(CRITICAL_SECTION *criticalSection);
+void OutputDebugString(const char *str);
 BOOL WINAPI SetCurrentDirectory(LPCSTR path);
 
-#define INFINITE      0xFFFFFFFF
-#define WAIT_OBJECT_0           0
-#define WAIT_FAILED             0xffffffff
-#define STATUS_PENDING          0x00000103
-#define STILL_ACTIVE            STATUS_PENDING
+#define INFINITE 0xFFFFFFFF
+#define WAIT_OBJECT_0 0
+#define WAIT_FAILED 0xffffffff
+#define STATUS_PENDING 0x00000103
+#define STILL_ACTIVE STATUS_PENDING
 
+#define THREAD_BASE_PRIORITY_LOWRT 15
+#define THREAD_PRIORITY_TIME_CRITICAL THREAD_BASE_PRIORITY_LOWRT
 
-#define THREAD_BASE_PRIORITY_LOWRT  15
-#define THREAD_PRIORITY_TIME_CRITICAL   THREAD_BASE_PRIORITY_LOWRT
-
-typedef DWORD (CALLBACK *LPTHREAD_START_ROUTINE)(LPVOID);
+typedef DWORD(CALLBACK *LPTHREAD_START_ROUTINE)(LPVOID);
 typedef size_t SIZE_T;
 
-BOOL        WINAPI SetThreadPriority(HANDLE,INT);
-DWORD       WINAPI WaitForSingleObject(const HANDLE,DWORD);
-DWORD       WINAPI WaitForMultipleObjects(DWORD,const HANDLE*,BOOL,DWORD);
-BOOL        WINAPI GetExitCodeThread(HANDLE,LPDWORD);
-BOOL        WINAPI SetEvent(HANDLE);
-VOID        WINAPI Sleep(DWORD);
-HANDLE      WINAPI CreateEvent(LPSECURITY_ATTRIBUTES,BOOL,BOOL,LPCSTR);
-HANDLE      WINAPI CreateThread(LPSECURITY_ATTRIBUTES,SIZE_T,LPTHREAD_START_ROUTINE,LPVOID,DWORD,LPDWORD);
-
-typedef union _LARGE_INTEGER {
-  struct {
-    DWORD LowPart;
-    LONG  HighPart;
-  } DUMMYSTRUCTNAME;
-  struct {
-    DWORD LowPart;
-    LONG  HighPart;
-  } u;
-  LONGLONG QuadPart;
+BOOL WINAPI SetThreadPriority(HANDLE, INT);
+DWORD WINAPI WaitForSingleObject(const HANDLE, DWORD);
+DWORD WINAPI WaitForMultipleObjects(DWORD, const HANDLE *, BOOL, DWORD);
+BOOL WINAPI GetExitCodeThread(HANDLE, LPDWORD);
+BOOL WINAPI SetEvent(HANDLE);
+VOID WINAPI Sleep(DWORD);
+HANDLE WINAPI CreateEvent(LPSECURITY_ATTRIBUTES, BOOL, BOOL, LPCSTR);
+HANDLE WINAPI CreateThread(LPSECURITY_ATTRIBUTES, SIZE_T, LPTHREAD_START_ROUTINE, LPVOID, DWORD, LPDWORD);
+
+typedef union _LARGE_INTEGER
+{
+    struct
+    {
+        DWORD LowPart;
+        LONG HighPart;
+    } DUMMYSTRUCTNAME;
+    struct
+    {
+        DWORD LowPart;
+        LONG HighPart;
+    } u;
+    LONGLONG QuadPart;
 } LARGE_INTEGER;
 
-BOOL WINAPI QueryPerformanceCounter(LARGE_INTEGER*);
+BOOL WINAPI QueryPerformanceCounter(LARGE_INTEGER *);
 
 HANDLE CreateSemaphore(
-  LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
-  LONG                  lInitialCount,
-  LONG                  lMaximumCount,
-  LPCSTR                lpName
-);
+    LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, LONG lInitialCount, LONG lMaximumCount, LPCSTR lpName);
diff --git a/source/linux/libwindows/wincompat.h b/source/linux/libwindows/wincompat.h
index 8632aa906..7c38b6505 100644
--- a/source/linux/libwindows/wincompat.h
+++ b/source/linux/libwindows/wincompat.h
@@ -1,10 +1,10 @@
 /****************************************************************************
-*                                                                           *
-* wincompat.h -- Basic Windows Type Definitions                                *
-*                                                                           *
-* Copyright (c) 1985-1997, Microsoft Corp. All rights reserved.             *
-*                                                                           *
-****************************************************************************/
+ *                                                                           *
+ * wincompat.h -- Basic Windows Type Definitions                                *
+ *                                                                           *
+ * Copyright (c) 1985-1997, Microsoft Corp. All rights reserved.             *
+ *                                                                           *
+ ****************************************************************************/
 
 /*
         Please note all long types (save for pointers) were replaced by int types
@@ -21,18 +21,19 @@
 #include <cassert>
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
 #ifndef BASETYPES
 #define BASETYPES
-typedef uint32_t ULONG;  // 32 bit long in VS
-typedef uint16_t USHORT;
-typedef unsigned char UCHAR;
-#endif  /* !BASETYPES */
+    typedef uint32_t ULONG; // 32 bit long in VS
+    typedef uint16_t USHORT;
+    typedef unsigned char UCHAR;
+#endif /* !BASETYPES */
 
-typedef int16_t INT16;
-typedef uint16_t UINT16;
+    typedef int16_t INT16;
+    typedef uint16_t UINT16;
 
 // in Visual Studio, __int64 is *always* the same as long long int
 // in 32 *and* 64 bit
@@ -43,93 +44,91 @@ typedef uint16_t UINT16;
 // we stick to VS's definition
 // this is important when selecting the correct printf format specifier
 #define __int64 long long int
-typedef __int64 LONGLONG;
-typedef unsigned __int64 UINT64;
+    typedef __int64 LONGLONG;
+    typedef unsigned __int64 UINT64;
 
-typedef intptr_t INT_PTR;
-typedef uintptr_t UINT_PTR;
+    typedef intptr_t INT_PTR;
+    typedef uintptr_t UINT_PTR;
 
+    typedef uint32_t UINT32;
 
-typedef uint32_t UINT32;
-
-#define MAX_PATH          260
+#define MAX_PATH 260
 
 #ifndef NULL
 #ifdef __cplusplus
-#define NULL    0
+#define NULL 0
 #else
-#define NULL    ((void *)0)
+#define NULL ((void *)0)
 #endif
 #endif
 
 #ifndef FALSE
-#define FALSE               0
+#define FALSE 0
 #endif
 
 #ifndef TRUE
-#define TRUE                1
+#define TRUE 1
 #endif
 
 #define FAR
 
 #ifndef CONST
-#define CONST               const
+#define CONST const
 #endif
 
-typedef unsigned int        DWORD;
-typedef int                 BOOL;
-typedef unsigned char       BYTE;
-typedef unsigned short      WORD;
-typedef BOOL                *LPBOOL;
-typedef BYTE                *LPBYTE;
-typedef WORD                *LPWORD;
-typedef DWORD               *LPDWORD;
-typedef void                *LPVOID;
-typedef CONST void          *LPCVOID;
-
-typedef int                 INT;
-typedef unsigned int        UINT;
-
-#define MAKEWORD(a, b)      ((WORD)(((BYTE)(a)) | ((WORD)((BYTE)(b))) << 8))
-#define MAKELONG(a, b)      ((LONG)(((WORD)(a)) | ((DWORD)((WORD)(b))) << 16))
-#define LOWORD(l)           ((WORD)(l))
-#define HIWORD(l)           ((WORD)(((DWORD)(l) >> 16) & 0xFFFF))
-#define LOBYTE(w)           ((BYTE)(w))
-#define HIBYTE(w)           ((BYTE)(((WORD)(w) >> 8) & 0xFF))
-
-typedef DWORD   COLORREF;
-typedef DWORD   *LPCOLORREF;
-
+    typedef unsigned int DWORD;
+    typedef int BOOL;
+    typedef unsigned char BYTE;
+    typedef unsigned short WORD;
+    typedef BOOL *LPBOOL;
+    typedef BYTE *LPBYTE;
+    typedef WORD *LPWORD;
+    typedef DWORD *LPDWORD;
+    typedef void *LPVOID;
+    typedef CONST void *LPCVOID;
+
+    typedef int INT;
+    typedef unsigned int UINT;
+
+#define MAKEWORD(a, b) ((WORD)(((BYTE)(a)) | ((WORD)((BYTE)(b))) << 8))
+#define MAKELONG(a, b) ((LONG)(((WORD)(a)) | ((DWORD)((WORD)(b))) << 16))
+#define LOWORD(l) ((WORD)(l))
+#define HIWORD(l) ((WORD)(((DWORD)(l) >> 16) & 0xFFFF))
+#define LOBYTE(w) ((BYTE)(w))
+#define HIBYTE(w) ((BYTE)(((WORD)(w) >> 8) & 0xFF))
+
+    typedef DWORD COLORREF;
+    typedef DWORD *LPCOLORREF;
 
 ////////////////////////// WINNT ///////////////////////////////
 #define VOID void
-typedef char CHAR;
-typedef short SHORT;
-typedef int /*long*/ LONG;
-typedef LONG *PLONG;
-typedef wchar_t WCHAR;
+    typedef char CHAR;
+    typedef short SHORT;
+    typedef int /*long*/ LONG;
+    typedef LONG *PLONG;
+    typedef wchar_t WCHAR;
 
-typedef LONG            HRESULT;
-typedef intptr_t        LONG_PTR;
-typedef uintptr_t       ULONG_PTR;
-typedef LONG_PTR        LRESULT;
-typedef ULONG_PTR       DWORD_PTR;
+    typedef LONG HRESULT;
+    typedef intptr_t LONG_PTR;
+    typedef uintptr_t ULONG_PTR;
+    typedef LONG_PTR LRESULT;
+    typedef ULONG_PTR DWORD_PTR;
 
-typedef DWORD           LCID;
+    typedef DWORD LCID;
 
-//
-// ANSI (Multi-byte Character) types
-//
-typedef CHAR *PCHAR;
+    //
+    // ANSI (Multi-byte Character) types
+    //
+    typedef CHAR *PCHAR;
 
-typedef CHAR *LPSTR;
-typedef CONST CHAR *LPCSTR;
+    typedef CHAR *LPSTR;
+    typedef CONST CHAR *LPCSTR;
 
-typedef LPSTR PTSTR, LPTSTR;
-typedef LPCSTR LPCTSTR;
+    typedef LPSTR PTSTR, LPTSTR;
+    typedef LPCSTR LPCTSTR;
 
-typedef WCHAR *LPWSTR;
-typedef CONST WCHAR *LPCWSTR;
+    typedef WCHAR *LPWSTR;
+    typedef CONST WCHAR *LPCWSTR;
 
 #ifndef _TCHAR_DEFINED
 // TCHAR a typedef or a define?
@@ -137,20 +136,20 @@ typedef CONST WCHAR *LPCWSTR;
 // othwerise QTCreator does not show the values (i.e. string) while debugging
 // it treats it as an array of bytes
 #define TCHAR char
-typedef TCHAR _TCHAR;
+    typedef TCHAR _TCHAR;
 #define _TCHAR_DEFINED
 #endif /* !_TCHAR_DEFINED */
 
 // TCHAR support
-#define __TEXT(quote) quote         // r_winnt
-#define TEXT(quote) __TEXT(quote)   // r_winnt
+#define __TEXT(quote) quote       // r_winnt
+#define TEXT(quote) __TEXT(quote) // r_winnt
 
 #define WINAPI
 #define __stdcall
 #define CALLBACK
 
 #ifdef _DEBUG
-#define _ASSERT(expr)   assert(expr)
+#define _ASSERT(expr) assert(expr)
 #else
 #define _ASSERT(expr)
 #endif
@@ -160,11 +159,11 @@ typedef TCHAR _TCHAR;
 
 #define _tmain main
 
-typedef void * HWND;
-typedef LONG_PTR LPARAM;
-typedef UINT_PTR WPARAM;
+    typedef void *HWND;
+    typedef LONG_PTR LPARAM;
+    typedef UINT_PTR WPARAM;
 
-typedef int errno_t;
+    typedef int errno_t;
 
 #ifdef __cplusplus
 }
diff --git a/source/linux/libwindows/winerror.h b/source/linux/libwindows/winerror.h
index 4ce928401..32d063ac9 100644
--- a/source/linux/libwindows/winerror.h
+++ b/source/linux/libwindows/winerror.h
@@ -2,24 +2,24 @@
 
 #define _HRESULT_TYPEDEF_(x) ((HRESULT)x)
 
-#define CLASS_E_NOAGGREGATION   _HRESULT_TYPEDEF_(0x80040110)
+#define CLASS_E_NOAGGREGATION _HRESULT_TYPEDEF_(0x80040110)
 
-#define E_NOINTERFACE   HRESULT(0x80004002)
+#define E_NOINTERFACE HRESULT(0x80004002)
 
-#define E_NOTIMPL       _HRESULT_TYPEDEF_(0x80004001)
-#define E_FAIL          _HRESULT_TYPEDEF_(0x80004005)
-#define E_OUTOFMEMORY   _HRESULT_TYPEDEF_(0x8007000E)
-#define E_INVALIDARG    _HRESULT_TYPEDEF_(0x80070057)
+#define E_NOTIMPL _HRESULT_TYPEDEF_(0x80004001)
+#define E_FAIL _HRESULT_TYPEDEF_(0x80004005)
+#define E_OUTOFMEMORY _HRESULT_TYPEDEF_(0x8007000E)
+#define E_INVALIDARG _HRESULT_TYPEDEF_(0x80070057)
 
 #define S_OK HRESULT(0)
 #define S_FALSE HRESULT(1)
 
-#define MAKE_HRESULT(sev,fac,code)                                      \
-    ((HRESULT) (((unsigned int)(sev)<<31) | ((unsigned int)(fac)<<16) | ((unsigned int)(code))) )
-#define MAKE_SCODE(sev,fac,code) \
-        ((SCODE) (((unsigned int)(sev)<<31) | ((unsigned int)(fac)<<16) | ((unsigned int)(code))) )
-#define SUCCEEDED(stat) ((HRESULT)(stat)>=0)
-#define FAILED(stat) ((HRESULT)(stat)<0)
+#define MAKE_HRESULT(sev, fac, code)                                                                                   \
+    ((HRESULT)(((unsigned int)(sev) << 31) | ((unsigned int)(fac) << 16) | ((unsigned int)(code))))
+#define MAKE_SCODE(sev, fac, code)                                                                                     \
+    ((SCODE)(((unsigned int)(sev) << 31) | ((unsigned int)(fac) << 16) | ((unsigned int)(code))))
+#define SUCCEEDED(stat) ((HRESULT)(stat) >= 0)
+#define FAILED(stat) ((HRESULT)(stat) < 0)
 
 #define HRESULT_CODE(hr) ((hr) & 0xFFFF)
-#define SCODE_CODE(sc)   ((sc) & 0xFFFF)
+#define SCODE_CODE(sc) ((sc) & 0xFFFF)
diff --git a/source/linux/libwindows/wingdi.h b/source/linux/libwindows/wingdi.h
index 71fcc2579..d8760a032 100644
--- a/source/linux/libwindows/wingdi.h
+++ b/source/linux/libwindows/wingdi.h
@@ -2,12 +2,13 @@
 
 #include "wincompat.h"
 
-typedef struct tagRGBQUAD {
-  BYTE rgbBlue;
-  BYTE rgbGreen;
-  BYTE rgbRed;
-  BYTE rgbReserved;
+typedef struct tagRGBQUAD
+{
+    BYTE rgbBlue;
+    BYTE rgbGreen;
+    BYTE rgbRed;
+    BYTE rgbReserved;
 } RGBQUAD;
 
-#define RGB(r,g,b)          ((COLORREF)((BYTE)(r) | ((BYTE)(g) << 8) | ((BYTE)(b) << 16)))
-#define BI_RGB           0
+#define RGB(r, g, b) ((COLORREF)((BYTE)(r) | ((BYTE)(g) << 8) | ((BYTE)(b) << 16)))
+#define BI_RGB 0
diff --git a/source/linux/libwindows/winhandles.cpp b/source/linux/libwindows/winhandles.cpp
index 2b99f21fe..bad708630 100644
--- a/source/linux/libwindows/winhandles.cpp
+++ b/source/linux/libwindows/winhandles.cpp
@@ -2,13 +2,13 @@
 
 BOOL CloseHandle(HANDLE hObject)
 {
-  if (hObject && hObject != INVALID_HANDLE_VALUE)
-  {
-    delete hObject;
-    return TRUE;
-  }
-  else
-  {
-    return FALSE;
-  }
+    if (hObject && hObject != INVALID_HANDLE_VALUE)
+    {
+        delete hObject;
+        return TRUE;
+    }
+    else
+    {
+        return FALSE;
+    }
 }
diff --git a/source/linux/libwindows/winhandles.h b/source/linux/libwindows/winhandles.h
index b19e0851e..baf8c3314 100644
--- a/source/linux/libwindows/winhandles.h
+++ b/source/linux/libwindows/winhandles.h
@@ -4,28 +4,28 @@
 
 struct CHANDLE
 {
-  virtual ~CHANDLE() = default;
+    virtual ~CHANDLE() = default;
 };
 
-typedef CHANDLE * HANDLE;
-#define INVALID_HANDLE_VALUE     ((HANDLE)~(ULONG_PTR)0)
+typedef CHANDLE *HANDLE;
+#define INVALID_HANDLE_VALUE ((HANDLE) ~(ULONG_PTR)0)
 
 typedef HANDLE HGLOBAL;
 
-typedef void * HWD;
-typedef void * HDC;
-typedef void * HINSTANCE;
+typedef void *HWD;
+typedef void *HDC;
+typedef void *HINSTANCE;
 typedef LONG_PTR LPARAM;
 typedef UINT_PTR WPARAM;
-typedef void * CRITICAL_SECTION;
-typedef void * LPDIRECTDRAW;
-typedef void * LPOVERLAPPED;
-typedef void * OVERLAPPED;
-typedef void * LPSECURITY_ATTRIBUTES;
-typedef void * HSEMAPHORE;
+typedef void *CRITICAL_SECTION;
+typedef void *LPDIRECTDRAW;
+typedef void *LPOVERLAPPED;
+typedef void *OVERLAPPED;
+typedef void *LPSECURITY_ATTRIBUTES;
+typedef void *HSEMAPHORE;
 
 #ifndef SOCKET
-  #define SOCKET int
+#define SOCKET int
 #endif
 
 BOOL CloseHandle(HANDLE hObject);
diff --git a/source/linux/libwindows/winnls.cpp b/source/linux/libwindows/winnls.cpp
index 7282a1af2..5663120ec 100644
--- a/source/linux/libwindows/winnls.cpp
+++ b/source/linux/libwindows/winnls.cpp
@@ -5,22 +5,25 @@
 
 // massive hack until I understand how it works!
 
-INT WINAPI MultiByteToWideChar(UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr, INT cbMultiByte, LPWSTR lpWideCharStr, INT cchWideChar)
+INT WINAPI MultiByteToWideChar(
+    UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr, INT cbMultiByte, LPWSTR lpWideCharStr, INT cchWideChar)
 {
-//  int res = mbstowcs(lpWideCharStr, lpMultiByteStr, strlen(lpMultiByteStr));
-  if (lpWideCharStr)
-  {
-    strcpy(reinterpret_cast<char *>(lpWideCharStr), lpMultiByteStr);
-  }
-  return strlen(lpMultiByteStr) + 1;  // add NULL char at end
+    //  int res = mbstowcs(lpWideCharStr, lpMultiByteStr, strlen(lpMultiByteStr));
+    if (lpWideCharStr)
+    {
+        strcpy(reinterpret_cast<char *>(lpWideCharStr), lpMultiByteStr);
+    }
+    return strlen(lpMultiByteStr) + 1; // add NULL char at end
 }
 
-INT WINAPI WideCharToMultiByte(UINT CodePage, DWORD dwFlags, LPCWSTR lpWideCharStr, INT cchWideChar, LPSTR lpMultiByteStr, INT cbMultiByte, LPCSTR lpDefaultChar, LPBOOL lpUsedDefaultChar)
+INT WINAPI WideCharToMultiByte(
+    UINT CodePage, DWORD dwFlags, LPCWSTR lpWideCharStr, INT cchWideChar, LPSTR lpMultiByteStr, INT cbMultiByte,
+    LPCSTR lpDefaultChar, LPBOOL lpUsedDefaultChar)
 {
-  if (lpMultiByteStr)
-  {
-    strcpy(lpMultiByteStr, reinterpret_cast<const char *>(lpWideCharStr));
-  }
-  //  size_t res = wcstombs(lpMultiByteStr, lpWideCharStr, cbMultiByte);
-  return strlen((const char *)lpWideCharStr) + 1;
+    if (lpMultiByteStr)
+    {
+        strcpy(lpMultiByteStr, reinterpret_cast<const char *>(lpWideCharStr));
+    }
+    //  size_t res = wcstombs(lpMultiByteStr, lpWideCharStr, cbMultiByte);
+    return strlen((const char *)lpWideCharStr) + 1;
 }
diff --git a/source/linux/libwindows/winnls.h b/source/linux/libwindows/winnls.h
index 0ead82f1b..d97a40805 100644
--- a/source/linux/libwindows/winnls.h
+++ b/source/linux/libwindows/winnls.h
@@ -2,9 +2,9 @@
 
 #include "wincompat.h"
 
-#define CP_ACP        0
-#define CP_UTF8       65001
-#define MB_ERR_INVALID_CHARS        0x08
+#define CP_ACP 0
+#define CP_UTF8 65001
+#define MB_ERR_INVALID_CHARS 0x08
 
-INT         WINAPI MultiByteToWideChar(UINT,DWORD,LPCSTR,INT,LPWSTR,INT);
-INT         WINAPI WideCharToMultiByte(UINT,DWORD,LPCWSTR,INT,LPSTR,INT,LPCSTR,LPBOOL);
+INT WINAPI MultiByteToWideChar(UINT, DWORD, LPCSTR, INT, LPWSTR, INT);
+INT WINAPI WideCharToMultiByte(UINT, DWORD, LPCWSTR, INT, LPSTR, INT, LPCSTR, LPBOOL);
diff --git a/source/linux/libwindows/winstrings.cpp b/source/linux/libwindows/winstrings.cpp
index bfdc96f62..cd8ff4c0b 100644
--- a/source/linux/libwindows/winstrings.cpp
+++ b/source/linux/libwindows/winstrings.cpp
@@ -7,59 +7,59 @@
 // make all chars in buffer lowercase
 DWORD CharLowerBuff(LPTSTR lpsz, DWORD cchLength)
 {
-  for (CHAR * c = lpsz; c != lpsz + cchLength; ++c)
-  {
-    *c = tolower(*c);
-  }
-  return cchLength;
+    for (CHAR *c = lpsz; c != lpsz + cchLength; ++c)
+    {
+        *c = tolower(*c);
+    }
+    return cchLength;
 }
 
-void strcpy_s(char * dest, size_t size, const char * source)
+void strcpy_s(char *dest, size_t size, const char *source)
 {
-  strncpy(dest, source, size);
+    strncpy(dest, source, size);
 }
 
-LPSTR _strupr( LPSTR str )
+LPSTR _strupr(LPSTR str)
 {
-  LPSTR ret = str;
-  for ( ; *str; str++)
-    *str = toupper(*str);
-  return ret;
+    LPSTR ret = str;
+    for (; *str; str++)
+        *str = toupper(*str);
+    return ret;
 }
 
-errno_t strncpy_s(char * dest, size_t numberOfElements, const char *src, size_t count)
+errno_t strncpy_s(char *dest, size_t numberOfElements, const char *src, size_t count)
 {
-  if (!count)
-  {
-    if(dest && numberOfElements)
+    if (!count)
     {
-      *dest = 0;
+        if (dest && numberOfElements)
+        {
+            *dest = 0;
+        }
+        return 0;
     }
-    return 0;
-  }
 
-  size_t end;
-  if (count != _TRUNCATE && count < numberOfElements)
-  {
-    end = count;
-  }
-  else
-  {
-    end = numberOfElements - 1;
-  }
+    size_t end;
+    if (count != _TRUNCATE && count < numberOfElements)
+    {
+        end = count;
+    }
+    else
+    {
+        end = numberOfElements - 1;
+    }
 
-  size_t i;
-  for (i = 0; i < end && src[i]; i++)
-  {
-    dest[i] = src[i];
-  }
+    size_t i;
+    for (i = 0; i < end && src[i]; i++)
+    {
+        dest[i] = src[i];
+    }
 
-  if (!src[i] || end == count || count == _TRUNCATE)
-  {
-    dest[i] = '\0';
-    return 0;
-  }
+    if (!src[i] || end == count || count == _TRUNCATE)
+    {
+        dest[i] = '\0';
+        return 0;
+    }
 
-  dest[0] = '\0';
-  return EINVAL;
+    dest[0] = '\0';
+    return EINVAL;
 }
diff --git a/source/linux/libwindows/winstrings.h b/source/linux/libwindows/winstrings.h
index abbd77dd0..ef4795ed4 100644
--- a/source/linux/libwindows/winstrings.h
+++ b/source/linux/libwindows/winstrings.h
@@ -6,38 +6,38 @@
 #include <ctype.h>
 #include <cstdarg>
 
-void strcpy_s(char * dest, size_t size, const char * source);
+void strcpy_s(char *dest, size_t size, const char *source);
 
-#define _TRUNCATE ((size_t)-1)
+#define _TRUNCATE ((size_t) - 1)
 
 #define _strdup strdup
 #define _strtoui64 strtoull
 #define _tcsrchr strrchr
 #define _tcsncpy strncpy
-#define _tcslen     strlen
+#define _tcslen strlen
 #define _tcscmp strcmp
 #define _tcsicmp _stricmp
 #define _stricmp strcasecmp
 #define _tcsstr strstr
-#define _tcscpy     strcpy
+#define _tcscpy strcpy
 #define _tcstol strtol
 #define _tcstoul strtoul
 #define sscanf_s sscanf
 #define _tcsncmp strncmp
 #define _tcsncat strncat
 
-inline bool IsCharLower(char ch) {
-        return isascii(ch) && islower(ch);
+inline bool IsCharLower(char ch)
+{
+    return isascii(ch) && islower(ch);
 }
 
 DWORD CharLowerBuff(LPTSTR lpsz, DWORD cchLength);
 
-LPSTR _strupr( LPSTR str );
+LPSTR _strupr(LPSTR str);
 
-errno_t strncpy_s(char * dest, size_t numberOfElements, const char *src, size_t count);
+errno_t strncpy_s(char *dest, size_t numberOfElements, const char *src, size_t count);
 
-template <size_t size>
-errno_t strncpy_s(char (&dest)[size], const char *src, size_t count)
+template <size_t size> errno_t strncpy_s(char (&dest)[size], const char *src, size_t count)
 {
-  return strncpy_s(dest, size, src, count);
+    return strncpy_s(dest, size, src, count);
 }
diff --git a/source/linux/libwindows/winuser.cpp b/source/linux/libwindows/winuser.cpp
index bac89b045..75f8cbfd8 100644
--- a/source/linux/libwindows/winuser.cpp
+++ b/source/linux/libwindows/winuser.cpp
@@ -4,40 +4,40 @@
 
 HCURSOR LoadCursor(HINSTANCE hInstance, LPCSTR lpCursorName)
 {
-  return nullptr;
+    return nullptr;
 }
 
 HCURSOR SetCursor(HCURSOR hCursor)
 {
-  return nullptr;
+    return nullptr;
 }
 
-UINT_PTR SetTimer(HWND,UINT_PTR,UINT,TIMERPROC)
+UINT_PTR SetTimer(HWND, UINT_PTR, UINT, TIMERPROC)
 {
-  // ignore everything
-  // 1 is to avoid a warning to the console
-  return 1;
+    // ignore everything
+    // 1 is to avoid a warning to the console
+    return 1;
 }
 
 BOOL KillTimer(HWND hWnd, UINT uIDEvent)
 {
-  return TRUE;
+    return TRUE;
 }
 
-HWND        WINAPI GetDlgItem(HWND,INT)
+HWND WINAPI GetDlgItem(HWND, INT)
 {
-  return nullptr;
+    return nullptr;
 }
 
-LRESULT     WINAPI SendMessage(HWND,UINT,WPARAM,LPARAM)
+LRESULT WINAPI SendMessage(HWND, UINT, WPARAM, LPARAM)
 {
-  return 0;
+    return 0;
 }
 
-void        WINAPI PostQuitMessage(INT status)
+void WINAPI PostQuitMessage(INT status)
 {
-  std::ostringstream buffer("PostQuitMessage: ");
-  buffer << status;
+    std::ostringstream buffer("PostQuitMessage: ");
+    buffer << status;
 
-  throw std::runtime_error(buffer.str());
+    throw std::runtime_error(buffer.str());
 }
diff --git a/source/linux/libwindows/winuser.h b/source/linux/libwindows/winuser.h
index d6fb914f4..1b523399b 100644
--- a/source/linux/libwindows/winuser.h
+++ b/source/linux/libwindows/winuser.h
@@ -2,42 +2,42 @@
 
 #include "winhandles.h"
 
-typedef void * HCURSOR;
+typedef void *HCURSOR;
 
 #define IDC_WAIT "IDC_WAIT"
-#define CB_ERR              (-1)
-#define CB_ADDSTRING             0x0143
-#define CB_RESETCONTENT          0x014b
-#define CB_SETCURSEL             0x014e
+#define CB_ERR (-1)
+#define CB_ADDSTRING 0x0143
+#define CB_RESETCONTENT 0x014b
+#define CB_SETCURSEL 0x014e
 
 HCURSOR LoadCursor(HINSTANCE hInstance, LPCSTR lpCursorName);
 HCURSOR SetCursor(HCURSOR hCursor);
 
-typedef VOID    (CALLBACK *TIMERPROC)(HWND,UINT,UINT_PTR,DWORD);
+typedef VOID(CALLBACK *TIMERPROC)(HWND, UINT, UINT_PTR, DWORD);
 
-UINT_PTR SetTimer(HWND,UINT_PTR,UINT,TIMERPROC);
+UINT_PTR SetTimer(HWND, UINT_PTR, UINT, TIMERPROC);
 BOOL KillTimer(HWND hWnd, UINT uIDEvent);
-HWND        WINAPI GetDlgItem(HWND,INT);
-LRESULT     WINAPI SendMessage(HWND,UINT,WPARAM,LPARAM);
-void        WINAPI PostQuitMessage(INT);
-
-#define VK_BACK           0x08
-#define VK_TAB            0x09
-#define VK_RETURN         0x0D
-#define VK_SHIFT          0x10
-#define VK_CONTROL        0x11
-#define VK_MENU           0x12
-#define VK_ESCAPE         0x1B
-#define VK_SPACE          0x20
-#define VK_PRIOR          0x21
-#define VK_NEXT           0x22
-#define VK_END            0x23
-#define VK_HOME           0x24
-#define VK_LEFT           0x25
-#define VK_UP             0x26
-#define VK_RIGHT          0x27
-#define VK_DOWN           0x28
-#define VK_OEM_3          0xC0   // '`~' for US
-#define VK_OEM_8          0xDF
-
-#define KF_EXTENDED       0x0100
+HWND WINAPI GetDlgItem(HWND, INT);
+LRESULT WINAPI SendMessage(HWND, UINT, WPARAM, LPARAM);
+void WINAPI PostQuitMessage(INT);
+
+#define VK_BACK 0x08
+#define VK_TAB 0x09
+#define VK_RETURN 0x0D
+#define VK_SHIFT 0x10
+#define VK_CONTROL 0x11
+#define VK_MENU 0x12
+#define VK_ESCAPE 0x1B
+#define VK_SPACE 0x20
+#define VK_PRIOR 0x21
+#define VK_NEXT 0x22
+#define VK_END 0x23
+#define VK_HOME 0x24
+#define VK_LEFT 0x25
+#define VK_UP 0x26
+#define VK_RIGHT 0x27
+#define VK_DOWN 0x28
+#define VK_OEM_3 0xC0 // '`~' for US
+#define VK_OEM_8 0xDF
+
+#define KF_EXTENDED 0x0100
diff --git a/source/linux/linuxframe.cpp b/source/linux/linuxframe.cpp
index 229f49de4..aa513491b 100644
--- a/source/linux/linuxframe.cpp
+++ b/source/linux/linuxframe.cpp
@@ -37,14 +37,15 @@ void LinuxFrame::SetFullScreenShowSubunitStatus(bool /* bShow */)
 {
 }
 
-bool LinuxFrame::GetBestDisplayResolutionForFullScreen(UINT& /* bestWidth */, UINT& /* bestHeight */, UINT /* userSpecifiedWidth */, UINT /* userSpecifiedHeight */)
+bool LinuxFrame::GetBestDisplayResolutionForFullScreen(
+    UINT & /* bestWidth */, UINT & /* bestHeight */, UINT /* userSpecifiedWidth */, UINT /* userSpecifiedHeight */)
 {
-  return false;
+    return false;
 }
 
 int LinuxFrame::SetViewportScale(int nNewScale, bool /* bForce */)
 {
-  return nNewScale;
+    return nNewScale;
 }
 
 void LinuxFrame::SetAltEnterToggleFullScreen(bool /* mode */)
@@ -63,123 +64,125 @@ void LinuxFrame::SetWindowedModeShowDiskiiStatus(bool /* bShow */)
 {
 }
 
-LinuxFrame::LinuxFrame(const bool autoBoot) : myAutoBoot(autoBoot)
+LinuxFrame::LinuxFrame(const bool autoBoot)
+    : myAutoBoot(autoBoot)
 {
-  const std::array<int, 4> version = getVersionNumbers();
-  SetAppleWinVersion(version[0], version[1], version[2], version[3]);
+    const std::array<int, 4> version = getVersionNumbers();
+    SetAppleWinVersion(version[0], version[1], version[2], version[3]);
 }
 
 void LinuxFrame::Initialize(bool resetVideoState)
 {
-  Video & video = GetVideo();
+    Video &video = GetVideo();
 
-  const size_t numberOfPixels = video.GetFrameBufferWidth() * video.GetFrameBufferHeight();
+    const size_t numberOfPixels = video.GetFrameBufferWidth() * video.GetFrameBufferHeight();
 
-  static_assert(sizeof(bgra_t) == 4, "Invalid size of bgra_t");
-  const size_t numberOfBytes = sizeof(bgra_t) * numberOfPixels;
+    static_assert(sizeof(bgra_t) == 4, "Invalid size of bgra_t");
+    const size_t numberOfBytes = sizeof(bgra_t) * numberOfPixels;
 
-  myFramebuffer.resize(numberOfBytes);
-  video.Initialize(myFramebuffer.data(), resetVideoState);
-  LogFileTimeUntilFirstKeyReadReset();
+    myFramebuffer.resize(numberOfBytes);
+    video.Initialize(myFramebuffer.data(), resetVideoState);
+    LogFileTimeUntilFirstKeyReadReset();
 }
 
 void LinuxFrame::Destroy()
 {
-  myFramebuffer.clear();
-  GetVideo().Destroy(); // this resets the Video's FrameBuffer pointer
+    myFramebuffer.clear();
+    GetVideo().Destroy(); // this resets the Video's FrameBuffer pointer
 }
 
 void LinuxFrame::ApplyVideoModeChange()
 {
-  // this is similar to Win32Frame::ApplyVideoModeChange
-  // but it does not refresh the screen
-  // TODO see if the screen should refresh right now
-  Video & video = GetVideo();
+    // this is similar to Win32Frame::ApplyVideoModeChange
+    // but it does not refresh the screen
+    // TODO see if the screen should refresh right now
+    Video &video = GetVideo();
 
-  video.VideoReinitialize(false);
-  video.Config_Save_Video();
+    video.VideoReinitialize(false);
+    video.Config_Save_Video();
 
-  FrameRefreshStatus(DRAW_TITLE);
+    FrameRefreshStatus(DRAW_TITLE);
 }
 
 void LinuxFrame::CycleVideoType()
 {
-  Video & video = GetVideo();
-  video.IncVideoType();
+    Video &video = GetVideo();
+    video.IncVideoType();
 
-  ApplyVideoModeChange();
+    ApplyVideoModeChange();
 }
 
 void LinuxFrame::Cycle50ScanLines()
 {
-  Video & video = GetVideo();
+    Video &video = GetVideo();
 
-  VideoStyle_e videoStyle = video.GetVideoStyle();
-  videoStyle = VideoStyle_e(videoStyle ^ VS_HALF_SCANLINES);
+    VideoStyle_e videoStyle = video.GetVideoStyle();
+    videoStyle = VideoStyle_e(videoStyle ^ VS_HALF_SCANLINES);
 
-  video.SetVideoStyle(videoStyle);
+    video.SetVideoStyle(videoStyle);
 
-  ApplyVideoModeChange();
+    ApplyVideoModeChange();
 }
 
-BYTE* LinuxFrame::GetResource(WORD id, LPCSTR lpType, uint32_t expectedSize)
+BYTE *LinuxFrame::GetResource(WORD id, LPCSTR lpType, uint32_t expectedSize)
 {
-  const auto resource = GetResourceData(id);
+    const auto resource = GetResourceData(id);
 
-  if (resource.second != expectedSize)
-  {
-    throw std::runtime_error("Invalid size for resource " + std::to_string(id) + ": " + 
-      std::to_string(resource.second) + " != " + std::to_string(expectedSize));
-  }
+    if (resource.second != expectedSize)
+    {
+        throw std::runtime_error(
+            "Invalid size for resource " + std::to_string(id) + ": " + std::to_string(resource.second) +
+            " != " + std::to_string(expectedSize));
+    }
 
-  auto data = const_cast<unsigned char *>(resource.first);
-  return reinterpret_cast<BYTE*>(data);
+    auto data = const_cast<unsigned char *>(resource.first);
+    return reinterpret_cast<BYTE *>(data);
 }
 
 void LinuxFrame::GetBitmap(WORD id, LONG cb, LPVOID lpvBits)
 {
-  const auto resource = GetResourceData(id);
-  if (!GetBitmapFromResource(resource, cb, lpvBits))
-  {
-    throw std::runtime_error("Cannot process bitmap resource " + std::to_string(id));
-  }
+    const auto resource = GetResourceData(id);
+    if (!GetBitmapFromResource(resource, cb, lpvBits))
+    {
+        throw std::runtime_error("Cannot process bitmap resource " + std::to_string(id));
+    }
 }
 
 void LinuxFrame::Begin()
 {
-  InitialiseEmulator(myAutoBoot ? MODE_RUNNING : MODE_PAUSED);
-  Initialize(true);
+    InitialiseEmulator(myAutoBoot ? MODE_RUNNING : MODE_PAUSED);
+    Initialize(true);
 }
 
 void LinuxFrame::End()
 {
-  Destroy();
-  DestroyEmulator();
+    Destroy();
+    DestroyEmulator();
 }
 
 void LinuxFrame::Restart()
 {
-  End();
-  Begin();
+    End();
+    Begin();
 }
 
 void LinuxFrame::LoadSnapshot()
 {
-  Snapshot_LoadState();
+    Snapshot_LoadState();
 }
 
-std::shared_ptr<NetworkBackend> LinuxFrame::CreateNetworkBackend(const std::string & interfaceName)
+std::shared_ptr<NetworkBackend> LinuxFrame::CreateNetworkBackend(const std::string &interfaceName)
 {
 #ifdef U2_USE_SLIRP
-  return std::make_shared<SlirpBackend>();
+    return std::make_shared<SlirpBackend>();
 #else
-  return std::make_shared<PCapBackend>(interfaceName);
+    return std::make_shared<PCapBackend>(interfaceName);
 #endif
 }
 
 #ifndef _WIN32
 int MessageBox(HWND, LPCSTR lpText, LPCSTR lpCaption, UINT uType)
 {
-  return GetFrame().FrameMessageBox(lpText, lpCaption, uType);
+    return GetFrame().FrameMessageBox(lpText, lpCaption, uType);
 }
 #endif
diff --git a/source/linux/linuxframe.h b/source/linux/linuxframe.h
index 5ff0cfd66..64392a36d 100644
--- a/source/linux/linuxframe.h
+++ b/source/linux/linuxframe.h
@@ -7,50 +7,51 @@
 class LinuxFrame : public FrameBase
 {
 public:
-  LinuxFrame(const bool autoBoot);
+    LinuxFrame(const bool autoBoot);
 
-  void Initialize(bool resetVideoState) override;
-  void Destroy() override;
+    void Initialize(bool resetVideoState) override;
+    void Destroy() override;
 
-  void FrameDrawDiskLEDS() override;
-  void FrameDrawDiskStatus() override;
-  void FrameRefreshStatus(int drawflags) override;
-  void FrameUpdateApple2Type() override;
-  void FrameSetCursorPosByMousePos() override;
-  void ResizeWindow() override;
+    void FrameDrawDiskLEDS() override;
+    void FrameDrawDiskStatus() override;
+    void FrameRefreshStatus(int drawflags) override;
+    void FrameUpdateApple2Type() override;
+    void FrameSetCursorPosByMousePos() override;
+    void ResizeWindow() override;
 
-  void SetFullScreenShowSubunitStatus(bool bShow) override;
-  void SetWindowedModeShowDiskiiStatus(bool bShow) override;
-  bool GetBestDisplayResolutionForFullScreen(UINT& bestWidth, UINT& bestHeight, UINT userSpecifiedWidth = 0, UINT userSpecifiedHeight = 0) override;
-  int SetViewportScale(int nNewScale, bool bForce = false) override;
-  void SetAltEnterToggleFullScreen(bool mode) override;
+    void SetFullScreenShowSubunitStatus(bool bShow) override;
+    void SetWindowedModeShowDiskiiStatus(bool bShow) override;
+    bool GetBestDisplayResolutionForFullScreen(
+        UINT &bestWidth, UINT &bestHeight, UINT userSpecifiedWidth = 0, UINT userSpecifiedHeight = 0) override;
+    int SetViewportScale(int nNewScale, bool bForce = false) override;
+    void SetAltEnterToggleFullScreen(bool mode) override;
 
-  void SetLoadedSaveStateFlag(const bool bFlag) override;
+    void SetLoadedSaveStateFlag(const bool bFlag) override;
 
-  void Restart() override; // calls End() - Begin()
-  BYTE* GetResource(WORD id, LPCSTR lpType, uint32_t expectedSize) override;
-  void GetBitmap(WORD id, LONG cb, LPVOID lpvBits) override;
+    void Restart() override; // calls End() - Begin()
+    BYTE *GetResource(WORD id, LPCSTR lpType, uint32_t expectedSize) override;
+    void GetBitmap(WORD id, LONG cb, LPVOID lpvBits) override;
 
-  std::shared_ptr<NetworkBackend> CreateNetworkBackend(const std::string & interfaceName) override;
+    std::shared_ptr<NetworkBackend> CreateNetworkBackend(const std::string &interfaceName) override;
 
-  void CycleVideoType();
-  void Cycle50ScanLines();
+    void CycleVideoType();
+    void Cycle50ScanLines();
 
-  void ApplyVideoModeChange();
+    void ApplyVideoModeChange();
 
-  // these are wrappers around Initialize / Destroy that take care of initialising the emulator components
-  // FrameBase::Initialize and ::Destroy only deal with the video part of the Frame, not the emulator
-  // in AppleWin this happens in AppleWin.cpp, but it is useful to share it
-  virtual void Begin();
-  virtual void End();
+    // these are wrappers around Initialize / Destroy that take care of initialising the emulator components
+    // FrameBase::Initialize and ::Destroy only deal with the video part of the Frame, not the emulator
+    // in AppleWin this happens in AppleWin.cpp, but it is useful to share it
+    virtual void Begin();
+    virtual void End();
 
-  virtual void LoadSnapshot();
+    virtual void LoadSnapshot();
 
 protected:
-  std::vector<uint8_t> myFramebuffer;
+    std::vector<uint8_t> myFramebuffer;
 
-  // pointer and size
-  virtual std::pair<const unsigned char *, unsigned int> GetResourceData(WORD id) const = 0;
+    // pointer and size
+    virtual std::pair<const unsigned char *, unsigned int> GetResourceData(WORD id) const = 0;
 
-  bool myAutoBoot;  // non const to allow settings change
+    bool myAutoBoot; // non const to allow settings change
 };
diff --git a/source/linux/linuxsoundbuffer.cpp b/source/linux/linuxsoundbuffer.cpp
index a180ff4d8..66b4b54b5 100644
--- a/source/linux/linuxsoundbuffer.cpp
+++ b/source/linux/linuxsoundbuffer.cpp
@@ -2,176 +2,178 @@
 
 #include "linux/linuxsoundbuffer.h"
 
-
 LinuxSoundBuffer::LinuxSoundBuffer(DWORD dwBufferSize, DWORD nSampleRate, int nChannels, LPCSTR pszVoiceName)
-  : mySoundBuffer(dwBufferSize)
-  , myNumberOfUnderruns(0)
-  , myBufferSize(dwBufferSize)
-  , mySampleRate(nSampleRate)
-  , myChannels(nChannels)
-  , myBitsPerSample(16)
-  , myVoiceName(pszVoiceName)
+    : mySoundBuffer(dwBufferSize)
+    , myNumberOfUnderruns(0)
+    , myBufferSize(dwBufferSize)
+    , mySampleRate(nSampleRate)
+    , myChannels(nChannels)
+    , myBitsPerSample(16)
+    , myVoiceName(pszVoiceName)
 {
 }
 
-HRESULT LinuxSoundBuffer::Unlock( LPVOID lpvAudioPtr1, DWORD dwAudioBytes1, LPVOID lpvAudioPtr2, DWORD dwAudioBytes2 )
+HRESULT LinuxSoundBuffer::Unlock(LPVOID lpvAudioPtr1, DWORD dwAudioBytes1, LPVOID lpvAudioPtr2, DWORD dwAudioBytes2)
 {
-  const size_t totalWrittenBytes = dwAudioBytes1 + dwAudioBytes2;
-  this->myWritePosition = (this->myWritePosition + totalWrittenBytes) % this->mySoundBuffer.size();
-  myMutex.unlock();
-  return DS_OK;
+    const size_t totalWrittenBytes = dwAudioBytes1 + dwAudioBytes2;
+    this->myWritePosition = (this->myWritePosition + totalWrittenBytes) % this->mySoundBuffer.size();
+    myMutex.unlock();
+    return DS_OK;
 }
 
 HRESULT LinuxSoundBuffer::Stop()
 {
-  const DWORD mask = DSBSTATUS_PLAYING | DSBSTATUS_LOOPING;
-  this->myStatus &= ~mask;
-  return DS_OK;
+    const DWORD mask = DSBSTATUS_PLAYING | DSBSTATUS_LOOPING;
+    this->myStatus &= ~mask;
+    return DS_OK;
 }
 
-HRESULT LinuxSoundBuffer::SetCurrentPosition( DWORD dwNewPosition )
+HRESULT LinuxSoundBuffer::SetCurrentPosition(DWORD dwNewPosition)
 {
-  return DS_OK;
+    return DS_OK;
 }
 
-HRESULT LinuxSoundBuffer::Play( DWORD dwReserved1, DWORD dwReserved2, DWORD dwFlags )
+HRESULT LinuxSoundBuffer::Play(DWORD dwReserved1, DWORD dwReserved2, DWORD dwFlags)
 {
-  this->myStatus |= DSBSTATUS_PLAYING;
-  if (dwFlags & DSBPLAY_LOOPING)
-  {
-    this->myStatus |= DSBSTATUS_LOOPING;
-  }
-  return DS_OK;
+    this->myStatus |= DSBSTATUS_PLAYING;
+    if (dwFlags & DSBPLAY_LOOPING)
+    {
+        this->myStatus |= DSBSTATUS_LOOPING;
+    }
+    return DS_OK;
 }
 
-HRESULT LinuxSoundBuffer::SetVolume( LONG lVolume )
+HRESULT LinuxSoundBuffer::SetVolume(LONG lVolume)
 {
-  this->myVolume = lVolume;
-  return DS_OK;
+    this->myVolume = lVolume;
+    return DS_OK;
 }
 
-HRESULT LinuxSoundBuffer::GetStatus( LPDWORD lpdwStatus )
+HRESULT LinuxSoundBuffer::GetStatus(LPDWORD lpdwStatus)
 {
-  *lpdwStatus = this->myStatus;
-  return DS_OK;
+    *lpdwStatus = this->myStatus;
+    return DS_OK;
 }
 
 HRESULT LinuxSoundBuffer::Restore()
 {
-  return DS_OK;
+    return DS_OK;
 }
 
-HRESULT LinuxSoundBuffer::Lock( DWORD dwWriteCursor, DWORD dwWriteBytes, LPVOID * lplpvAudioPtr1, DWORD * lpdwAudioBytes1, LPVOID * lplpvAudioPtr2, DWORD * lpdwAudioBytes2, DWORD dwFlags )
+HRESULT LinuxSoundBuffer::Lock(
+    DWORD dwWriteCursor, DWORD dwWriteBytes, LPVOID *lplpvAudioPtr1, DWORD *lpdwAudioBytes1, LPVOID *lplpvAudioPtr2,
+    DWORD *lpdwAudioBytes2, DWORD dwFlags)
 {
-  myMutex.lock();
-  // No attempt is made at restricting write buffer not to overtake play cursor
-  if (dwFlags & DSBLOCK_ENTIREBUFFER)
-  {
-    *lplpvAudioPtr1 = this->mySoundBuffer.data();
-    *lpdwAudioBytes1 = this->mySoundBuffer.size();
-    if (lplpvAudioPtr2 && lpdwAudioBytes2)
+    myMutex.lock();
+    // No attempt is made at restricting write buffer not to overtake play cursor
+    if (dwFlags & DSBLOCK_ENTIREBUFFER)
     {
-      *lplpvAudioPtr2 = nullptr;
-      *lpdwAudioBytes2 = 0;
+        *lplpvAudioPtr1 = this->mySoundBuffer.data();
+        *lpdwAudioBytes1 = this->mySoundBuffer.size();
+        if (lplpvAudioPtr2 && lpdwAudioBytes2)
+        {
+            *lplpvAudioPtr2 = nullptr;
+            *lpdwAudioBytes2 = 0;
+        }
     }
-  }
-  else
-  {
-    const DWORD availableInFirstPart = this->mySoundBuffer.size() - dwWriteCursor;
-
-    *lplpvAudioPtr1 = this->mySoundBuffer.data() + dwWriteCursor;
-    *lpdwAudioBytes1 = std::min(availableInFirstPart, dwWriteBytes);
-
-    if (lplpvAudioPtr2 && lpdwAudioBytes2)
+    else
     {
-      if (*lpdwAudioBytes1 < dwWriteBytes)
-      {
-        *lplpvAudioPtr2 = this->mySoundBuffer.data();
-        *lpdwAudioBytes2 = std::min(dwWriteCursor, dwWriteBytes - *lpdwAudioBytes1);
-      }
-      else
-      {
-        *lplpvAudioPtr2 = nullptr;
-        *lpdwAudioBytes2 = 0;
-      }
+        const DWORD availableInFirstPart = this->mySoundBuffer.size() - dwWriteCursor;
+
+        *lplpvAudioPtr1 = this->mySoundBuffer.data() + dwWriteCursor;
+        *lpdwAudioBytes1 = std::min(availableInFirstPart, dwWriteBytes);
+
+        if (lplpvAudioPtr2 && lpdwAudioBytes2)
+        {
+            if (*lpdwAudioBytes1 < dwWriteBytes)
+            {
+                *lplpvAudioPtr2 = this->mySoundBuffer.data();
+                *lpdwAudioBytes2 = std::min(dwWriteCursor, dwWriteBytes - *lpdwAudioBytes1);
+            }
+            else
+            {
+                *lplpvAudioPtr2 = nullptr;
+                *lpdwAudioBytes2 = 0;
+            }
+        }
     }
-  }
 
-  return DS_OK;
+    return DS_OK;
 }
 
-DWORD LinuxSoundBuffer::Read( DWORD dwReadBytes, LPVOID * lplpvAudioPtr1, DWORD * lpdwAudioBytes1, LPVOID * lplpvAudioPtr2, DWORD * lpdwAudioBytes2)
+DWORD LinuxSoundBuffer::Read(
+    DWORD dwReadBytes, LPVOID *lplpvAudioPtr1, DWORD *lpdwAudioBytes1, LPVOID *lplpvAudioPtr2, DWORD *lpdwAudioBytes2)
 {
-  const std::lock_guard<std::mutex> guard(myMutex);
+    const std::lock_guard<std::mutex> guard(myMutex);
 
-  // Read up to dwReadBytes, never going past the write cursor
-  // Positions are updated immediately
-  const DWORD available = (this->myWritePosition - this->myPlayPosition) % this->myBufferSize;
-  if (available < dwReadBytes)
-  {
-    dwReadBytes = available;
-    ++myNumberOfUnderruns;
-  }
+    // Read up to dwReadBytes, never going past the write cursor
+    // Positions are updated immediately
+    const DWORD available = (this->myWritePosition - this->myPlayPosition) % this->myBufferSize;
+    if (available < dwReadBytes)
+    {
+        dwReadBytes = available;
+        ++myNumberOfUnderruns;
+    }
 
-  const DWORD availableInFirstPart = this->mySoundBuffer.size() - this->myPlayPosition;
+    const DWORD availableInFirstPart = this->mySoundBuffer.size() - this->myPlayPosition;
 
-  *lplpvAudioPtr1 = this->mySoundBuffer.data() + this->myPlayPosition;
-  *lpdwAudioBytes1 = std::min(availableInFirstPart, dwReadBytes);
+    *lplpvAudioPtr1 = this->mySoundBuffer.data() + this->myPlayPosition;
+    *lpdwAudioBytes1 = std::min(availableInFirstPart, dwReadBytes);
 
-  if (lplpvAudioPtr2 && lpdwAudioBytes2)
-  {
-    if (*lpdwAudioBytes1 < dwReadBytes)
-    {
-      *lplpvAudioPtr2 = this->mySoundBuffer.data();
-      *lpdwAudioBytes2 = dwReadBytes - *lpdwAudioBytes1;
-    }
-    else
+    if (lplpvAudioPtr2 && lpdwAudioBytes2)
     {
-      *lplpvAudioPtr2 = nullptr;
-      *lpdwAudioBytes2 = 0;
+        if (*lpdwAudioBytes1 < dwReadBytes)
+        {
+            *lplpvAudioPtr2 = this->mySoundBuffer.data();
+            *lpdwAudioBytes2 = dwReadBytes - *lpdwAudioBytes1;
+        }
+        else
+        {
+            *lplpvAudioPtr2 = nullptr;
+            *lpdwAudioBytes2 = 0;
+        }
     }
-  }
-  this->myPlayPosition = (this->myPlayPosition + dwReadBytes) % this->mySoundBuffer.size();
-  return dwReadBytes;
+    this->myPlayPosition = (this->myPlayPosition + dwReadBytes) % this->mySoundBuffer.size();
+    return dwReadBytes;
 }
 
 DWORD LinuxSoundBuffer::GetBytesInBuffer()
 {
-  const std::lock_guard<std::mutex> guard(myMutex);
-  const DWORD available = (this->myWritePosition - this->myPlayPosition) % this->myBufferSize;
-  return available;
+    const std::lock_guard<std::mutex> guard(myMutex);
+    const DWORD available = (this->myWritePosition - this->myPlayPosition) % this->myBufferSize;
+    return available;
 }
 
-HRESULT LinuxSoundBuffer::GetCurrentPosition( LPDWORD lpdwCurrentPlayCursor, LPDWORD lpdwCurrentWriteCursor )
+HRESULT LinuxSoundBuffer::GetCurrentPosition(LPDWORD lpdwCurrentPlayCursor, LPDWORD lpdwCurrentWriteCursor)
 {
-  *lpdwCurrentPlayCursor = this->myPlayPosition;
-  *lpdwCurrentWriteCursor = this->myWritePosition;
-  return DS_OK;
+    *lpdwCurrentPlayCursor = this->myPlayPosition;
+    *lpdwCurrentWriteCursor = this->myWritePosition;
+    return DS_OK;
 }
 
-HRESULT LinuxSoundBuffer::GetVolume( LONG * lplVolume )
+HRESULT LinuxSoundBuffer::GetVolume(LONG *lplVolume)
 {
-  *lplVolume = this->myVolume;
-  return DS_OK;
+    *lplVolume = this->myVolume;
+    return DS_OK;
 }
 
 double LinuxSoundBuffer::GetLogarithmicVolume() const
 {
-  const double volume = (double(myVolume) - DSBVOLUME_MIN) / (0.0 - DSBVOLUME_MIN);
-  return volume;
+    const double volume = (double(myVolume) - DSBVOLUME_MIN) / (0.0 - DSBVOLUME_MIN);
+    return volume;
 }
 
 size_t LinuxSoundBuffer::GetBufferUnderruns() const
 {
-  return myNumberOfUnderruns;
+    return myNumberOfUnderruns;
 }
 
 void LinuxSoundBuffer::ResetUnderruns()
 {
-  myNumberOfUnderruns = 0;
+    myNumberOfUnderruns = 0;
 }
 
 bool DSAvailable()
 {
-  return true;
+    return true;
 }
diff --git a/source/linux/linuxsoundbuffer.h b/source/linux/linuxsoundbuffer.h
index f4fa2895c..e97a9840c 100644
--- a/source/linux/linuxsoundbuffer.h
+++ b/source/linux/linuxsoundbuffer.h
@@ -10,47 +10,51 @@
 class LinuxSoundBuffer : public SoundBuffer
 {
 private:
-  std::vector<uint8_t> mySoundBuffer;
+    std::vector<uint8_t> mySoundBuffer;
 
-  size_t myPlayPosition = 0;
-  size_t myWritePosition = 0;
-  WORD myStatus = 0;
-  LONG myVolume = 0;
+    size_t myPlayPosition = 0;
+    size_t myWritePosition = 0;
+    WORD myStatus = 0;
+    LONG myVolume = 0;
 
-  // updated by the callback
-  std::atomic_size_t myNumberOfUnderruns;
-  std::mutex myMutex;
+    // updated by the callback
+    std::atomic_size_t myNumberOfUnderruns;
+    std::mutex myMutex;
 
 protected:
-  LinuxSoundBuffer(DWORD dwBufferSize, DWORD nSampleRate, int nChannels, LPCSTR pszVoiceName);
+    LinuxSoundBuffer(DWORD dwBufferSize, DWORD nSampleRate, int nChannels, LPCSTR pszVoiceName);
 
 public:
-  const size_t myBufferSize;
-  const size_t mySampleRate;
-  const size_t myChannels;
-  const size_t myBitsPerSample;
-  const std::string myVoiceName;
-
-  HRESULT SetCurrentPosition(DWORD dwNewPosition) override;
-  HRESULT GetCurrentPosition(LPDWORD lpdwCurrentPlayCursor, LPDWORD lpdwCurrentWriteCursor) override;
-
-  HRESULT Lock(DWORD dwWriteCursor, DWORD dwWriteBytes, LPVOID* lplpvAudioPtr1, DWORD* lpdwAudioBytes1, LPVOID* lplpvAudioPtr2, DWORD* lpdwAudioBytes2, DWORD dwFlags) override;
-  virtual HRESULT Unlock(LPVOID lpvAudioPtr1, DWORD dwAudioBytes1, LPVOID lpvAudioPtr2, DWORD dwAudioBytes2) override;
-
-  virtual HRESULT Stop() override;
-  virtual HRESULT Play(DWORD dwReserved1, DWORD dwReserved2, DWORD dwFlags) override;
-
-  virtual HRESULT SetVolume(LONG lVolume) override;
-  HRESULT GetVolume(LONG* lplVolume) override;
-
-  HRESULT GetStatus(LPDWORD lpdwStatus) override;
-  HRESULT Restore() override;
-
-  DWORD Read(DWORD dwReadBytes, LPVOID* lplpvAudioPtr1, DWORD* lpdwAudioBytes1, LPVOID* lplpvAudioPtr2, DWORD* lpdwAudioBytes2);
-  DWORD GetBytesInBuffer();
-  size_t GetBufferUnderruns() const;
-  void ResetUnderruns();
-  double GetLogarithmicVolume() const;  // in [0, 1]
+    const size_t myBufferSize;
+    const size_t mySampleRate;
+    const size_t myChannels;
+    const size_t myBitsPerSample;
+    const std::string myVoiceName;
+
+    HRESULT SetCurrentPosition(DWORD dwNewPosition) override;
+    HRESULT GetCurrentPosition(LPDWORD lpdwCurrentPlayCursor, LPDWORD lpdwCurrentWriteCursor) override;
+
+    HRESULT Lock(
+        DWORD dwWriteCursor, DWORD dwWriteBytes, LPVOID *lplpvAudioPtr1, DWORD *lpdwAudioBytes1, LPVOID *lplpvAudioPtr2,
+        DWORD *lpdwAudioBytes2, DWORD dwFlags) override;
+    virtual HRESULT Unlock(LPVOID lpvAudioPtr1, DWORD dwAudioBytes1, LPVOID lpvAudioPtr2, DWORD dwAudioBytes2) override;
+
+    virtual HRESULT Stop() override;
+    virtual HRESULT Play(DWORD dwReserved1, DWORD dwReserved2, DWORD dwFlags) override;
+
+    virtual HRESULT SetVolume(LONG lVolume) override;
+    HRESULT GetVolume(LONG *lplVolume) override;
+
+    HRESULT GetStatus(LPDWORD lpdwStatus) override;
+    HRESULT Restore() override;
+
+    DWORD Read(
+        DWORD dwReadBytes, LPVOID *lplpvAudioPtr1, DWORD *lpdwAudioBytes1, LPVOID *lplpvAudioPtr2,
+        DWORD *lpdwAudioBytes2);
+    DWORD GetBytesInBuffer();
+    size_t GetBufferUnderruns() const;
+    void ResetUnderruns();
+    double GetLogarithmicVolume() const; // in [0, 1]
 };
 
 bool DSAvailable();
diff --git a/source/linux/network/portfwds.cpp b/source/linux/network/portfwds.cpp
index 4fcbadbff..9d927ec1b 100644
--- a/source/linux/network/portfwds.cpp
+++ b/source/linux/network/portfwds.cpp
@@ -15,88 +15,89 @@
 namespace
 {
 
-  void parseAddress(const addrinfo & hints, const std::string & addr, const std::string & port,
-                    in_addr & host_addr, int & host_port)
-  {
-    addrinfo *result = nullptr;
-    const char * a = addr.empty() ? nullptr : addr.c_str();
-    const int r = getaddrinfo(a, port.c_str(), &hints, &result);
-    if (r)
+    void parseAddress(
+        const addrinfo &hints, const std::string &addr, const std::string &port, in_addr &host_addr, int &host_port)
     {
-      throw std::runtime_error(StrFormat("getaddrinfo('%s:%s') [%s]", addr.c_str(), port.c_str(), gai_strerror(r)));
+        addrinfo *result = nullptr;
+        const char *a = addr.empty() ? nullptr : addr.c_str();
+        const int r = getaddrinfo(a, port.c_str(), &hints, &result);
+        if (r)
+        {
+            throw std::runtime_error(
+                StrFormat("getaddrinfo('%s:%s') [%s]", addr.c_str(), port.c_str(), gai_strerror(r)));
+        }
+
+        const addrinfo *res = result;
+        while (res)
+        {
+            if (res->ai_family == AF_INET)
+            {
+                const sockaddr_in *ip = reinterpret_cast<const sockaddr_in *>(res->ai_addr);
+                host_addr = ip->sin_addr;
+                host_port = ntohs(ip->sin_port);
+                freeaddrinfo(result); // we should find a better RAII
+                return;
+            }
+            res = res->ai_next;
+        }
+
+        freeaddrinfo(result);
+        throw std::runtime_error(StrFormat("No valid address: '%s:%s'", addr.c_str(), port.c_str()));
     }
 
-    const addrinfo *res = result;
-    while (res)
-    {
-      if (res->ai_family == AF_INET)
-      {
-        const sockaddr_in * ip = reinterpret_cast<const sockaddr_in *>(res->ai_addr);
-        host_addr = ip->sin_addr;
-        host_port = ntohs(ip->sin_port);
-        freeaddrinfo(result); // we should find a better RAII
-        return;
-      }
-      res = res->ai_next;
-    }
-
-    freeaddrinfo(result);
-    throw std::runtime_error(StrFormat("No valid address: '%s:%s'", addr.c_str(), port.c_str()));
-  }
-
-}
+} // namespace
 
 std::string PortFwd::toString() const
 {
-  char address1[INET_ADDRSTRLEN + 1];
-  char address2[INET_ADDRSTRLEN + 1];
-  const char * h = inet_ntop(AF_INET, &host_addr, address1, sizeof(address1));
-  const char * g = inet_ntop(AF_INET, &guest_addr, address2, sizeof(address2));
-  const std::string str = StrFormat("%s:%d -> %s:%d", h, host_port, g, guest_port);
-  return str;
+    char address1[INET_ADDRSTRLEN + 1];
+    char address2[INET_ADDRSTRLEN + 1];
+    const char *h = inet_ntop(AF_INET, &host_addr, address1, sizeof(address1));
+    const char *g = inet_ntop(AF_INET, &guest_addr, address2, sizeof(address2));
+    const std::string str = StrFormat("%s:%d -> %s:%d", h, host_port, g, guest_port);
+    return str;
 }
 
-std::vector<PortFwd> getPortFwds(const std::vector<std::string> & specs)
+std::vector<PortFwd> getPortFwds(const std::vector<std::string> &specs)
 {
-  std::vector<PortFwd> fwds;
-  addrinfo hints;
-  memset(&hints, 0, sizeof (hints));
-  hints.ai_family = AF_INET;
-  hints.ai_socktype = 0;
-  hints.ai_flags = AI_NUMERICHOST | AI_PASSIVE;
-
-  const std::regex re("^(\\d),(udp|tcp),([a-zA-Z0-9.]*?),(\\w+?),([a-zA-Z0-9.]*?),(\\w+?)$");
-
-  for (const auto & value : specs)
-  {
-    std::smatch m;
-    if (std::regex_match(value, m, re) && m.size() == 7)
-    {
-      PortFwd fwd;
-      fwd.slot = std::stoi(m.str(1));
-      fwd.is_udp = m.str(2) == "udp";
-      parseAddress(hints, m.str(3), m.str(4), fwd.host_addr, fwd.host_port);
-      parseAddress(hints, m.str(5), m.str(6), fwd.guest_addr, fwd.guest_port);
-      fwds.push_back(std::move(fwd));
-    }
-    else
+    std::vector<PortFwd> fwds;
+    addrinfo hints;
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_INET;
+    hints.ai_socktype = 0;
+    hints.ai_flags = AI_NUMERICHOST | AI_PASSIVE;
+
+    const std::regex re("^(\\d),(udp|tcp),([a-zA-Z0-9.]*?),(\\w+?),([a-zA-Z0-9.]*?),(\\w+?)$");
+
+    for (const auto &value : specs)
     {
-      throw std::runtime_error(StrFormat("Invalid NAT spec: '%s'", value.c_str()));
+        std::smatch m;
+        if (std::regex_match(value, m, re) && m.size() == 7)
+        {
+            PortFwd fwd;
+            fwd.slot = std::stoi(m.str(1));
+            fwd.is_udp = m.str(2) == "udp";
+            parseAddress(hints, m.str(3), m.str(4), fwd.host_addr, fwd.host_port);
+            parseAddress(hints, m.str(5), m.str(6), fwd.guest_addr, fwd.guest_port);
+            fwds.push_back(std::move(fwd));
+        }
+        else
+        {
+            throw std::runtime_error(StrFormat("Invalid NAT spec: '%s'", value.c_str()));
+        }
     }
-  }
-  return fwds;
+    return fwds;
 }
 
 #else
 
 std::string PortFwd::toString() const
 {
-  return "";
+    return "";
 }
 
-std::vector<PortFwd> getPortFwds(const std::vector<std::string> & specs)
+std::vector<PortFwd> getPortFwds(const std::vector<std::string> &specs)
 {
-  return {};
+    return {};
 }
-  
+
 #endif
diff --git a/source/linux/network/portfwds.h b/source/linux/network/portfwds.h
index aabb5e443..dce85f545 100644
--- a/source/linux/network/portfwds.h
+++ b/source/linux/network/portfwds.h
@@ -11,14 +11,14 @@
 
 struct PortFwd
 {
-  int slot;
-  int is_udp;
-  in_addr host_addr;
-  int host_port;
-  in_addr guest_addr;
-  int guest_port;
+    int slot;
+    int is_udp;
+    in_addr host_addr;
+    int host_port;
+    in_addr guest_addr;
+    int guest_port;
 
-  std::string toString() const;
+    std::string toString() const;
 };
 
-std::vector<PortFwd> getPortFwds(const std::vector<std::string> & specs);
+std::vector<PortFwd> getPortFwds(const std::vector<std::string> &specs);
diff --git a/source/linux/network/slirp2.cpp b/source/linux/network/slirp2.cpp
index 6e9915535..fbcf93505 100644
--- a/source/linux/network/slirp2.cpp
+++ b/source/linux/network/slirp2.cpp
@@ -10,234 +10,241 @@
 #include "CPU.h"
 #include "Core.h"
 
-#define IP_PACK(a,b,c,d) htonl( ((a)<<24) | ((b)<<16) | ((c)<<8) | (d))
+#define IP_PACK(a, b, c, d) htonl(((a) << 24) | ((b) << 16) | ((c) << 8) | (d))
 
 namespace
 {
 
-  short vdeslirp_slirp_to_poll(int events)
-  {
-    short ret = 0;
-    if (events & SLIRP_POLL_IN)  ret |= POLLIN;
-    if (events & SLIRP_POLL_OUT) ret |= POLLOUT;
-    if (events & SLIRP_POLL_PRI) ret |= POLLPRI;
-    if (events & SLIRP_POLL_ERR) ret |= POLLERR;
-    if (events & SLIRP_POLL_HUP) ret |= POLLHUP;
-    return ret;
-  }
-
-  int vdeslirp_poll_to_slirp(short events)
-  {
-    int ret = 0;
-    if (events & POLLIN)  ret |= SLIRP_POLL_IN;
-    if (events & POLLOUT) ret |= SLIRP_POLL_OUT;
-    if (events & POLLPRI) ret |= SLIRP_POLL_PRI;
-    if (events & POLLERR) ret |= SLIRP_POLL_ERR;
-    if (events & POLLHUP) ret |= SLIRP_POLL_HUP;
-    return ret;
-  }
-
-  ssize_t net_slirp_send_packet(const void *buf, size_t len, void *opaque)
-  {
-    SlirpBackend * slirp = reinterpret_cast<SlirpBackend *>(opaque);
-    slirp->sendToGuest(reinterpret_cast<const uint8_t *>(buf), len);
-    return len;
-  }
-
-  void net_slirp_guest_error(const char *msg, void *opaque)
-  {
-    LogOutput("SLIRP: %s\n", msg);
-  }
-
-  int64_t net_slirp_clock_get_ns(void *opaque)
-  {
-    const int64_t ns = (10e9 * g_nCumulativeCycles) / g_fCurrentCLK6502;
-    return ns;
-  }
-
-  void *net_slirp_timer_new(SlirpTimerCb cb, void *cb_opaque, void *opaque)
-  {
-    LogFileOutput("SLIRP: slirp_timer_new()\n");
-    return nullptr;
-  }
-
-  void net_slirp_timer_free(void *timer, void *opaque)
-  {
-    LogFileOutput("SLIRP: slirp_timer_free()\n");
-  }
-
-  void net_slirp_timer_mod(void *timer, int64_t expire_timer, void *opaque)
-  {
-    LogFileOutput("SLIRP: slirp_timer_mod()\n");
-  }
-
-  void net_slirp_register_poll_fd(int /* fd */, void * /* opaque */)
-  {
-    // most existing implementations are a NOOP???
-  }
-
-  void net_slirp_unregister_poll_fd(int /* fd */, void * /* opaque */)
-  {
-    // most existing implementations are a NOOP???
-  }
-
-  void net_slirp_notify(void *opaque)
-  {
-    LogFileOutput("SLIRP: slirp_notify()\n");
-  }
-
-  int net_slirp_add_poll(int fd, int events, void *opaque)
-  {
-    SlirpBackend * slirp = reinterpret_cast<SlirpBackend *>(opaque);
-    return slirp->addPoll(fd, events);
-  }
-
-  int net_slirp_get_revents(int idx, void *opaque)
-  {
-    const SlirpBackend * slirp = reinterpret_cast<SlirpBackend *>(opaque);
-	  return slirp->getREvents(idx);
-  }
+    short vdeslirp_slirp_to_poll(int events)
+    {
+        short ret = 0;
+        if (events & SLIRP_POLL_IN)
+            ret |= POLLIN;
+        if (events & SLIRP_POLL_OUT)
+            ret |= POLLOUT;
+        if (events & SLIRP_POLL_PRI)
+            ret |= POLLPRI;
+        if (events & SLIRP_POLL_ERR)
+            ret |= POLLERR;
+        if (events & SLIRP_POLL_HUP)
+            ret |= POLLHUP;
+        return ret;
+    }
 
-}
+    int vdeslirp_poll_to_slirp(short events)
+    {
+        int ret = 0;
+        if (events & POLLIN)
+            ret |= SLIRP_POLL_IN;
+        if (events & POLLOUT)
+            ret |= SLIRP_POLL_OUT;
+        if (events & POLLPRI)
+            ret |= SLIRP_POLL_PRI;
+        if (events & POLLERR)
+            ret |= SLIRP_POLL_ERR;
+        if (events & POLLHUP)
+            ret |= SLIRP_POLL_HUP;
+        return ret;
+    }
 
-SlirpBackend::SlirpBackend(const std::vector<PortFwd> & portFwds)
-{
-  const SlirpConfig cfg =
-  {
-    .version = SLIRP_CONFIG_VERSION_MAX,
-    .in_enabled = 1,
-    .vnetwork = { .s_addr = IP_PACK(10, 0, 0, 0) },
-    .vnetmask = { .s_addr = IP_PACK(255, 255, 255, 0) },
-    .vhost = { .s_addr = IP_PACK(10, 0, 0, 1) },
-    .vhostname = "applewin",
-    .vdhcp_start = { .s_addr = IP_PACK(10, 0, 0, 2) },
-  };
-  static const SlirpCb slirp_cb =
-  {
-    .send_packet = net_slirp_send_packet,
-    .guest_error = net_slirp_guest_error,
-    .clock_get_ns = net_slirp_clock_get_ns,
-    .timer_new = net_slirp_timer_new,
-    .timer_free = net_slirp_timer_free,
-    .timer_mod = net_slirp_timer_mod,
-    .register_poll_fd = net_slirp_register_poll_fd,
-    .unregister_poll_fd = net_slirp_unregister_poll_fd,
-    .notify = net_slirp_notify,
-  };
-  Slirp * slirp = slirp_new(&cfg, &slirp_cb, this);
-  mySlirp.reset(slirp, slirp_cleanup);
-  for (const auto & pf : portFwds)
-  {
-    const int res = slirp_add_hostfwd(slirp, pf.is_udp, pf.host_addr, pf.host_port, 
-      pf.guest_addr, pf.guest_port);
-    if (res != 0)
-    {
-      LogOutput("nat [%s]: slirp error: %s\n", pf.toString().c_str(), strerror(errno));
+    ssize_t net_slirp_send_packet(const void *buf, size_t len, void *opaque)
+    {
+        SlirpBackend *slirp = reinterpret_cast<SlirpBackend *>(opaque);
+        slirp->sendToGuest(reinterpret_cast<const uint8_t *>(buf), len);
+        return len;
     }
-    else
+
+    void net_slirp_guest_error(const char *msg, void *opaque)
+    {
+        LogOutput("SLIRP: %s\n", msg);
+    }
+
+    int64_t net_slirp_clock_get_ns(void *opaque)
+    {
+        const int64_t ns = (10e9 * g_nCumulativeCycles) / g_fCurrentCLK6502;
+        return ns;
+    }
+
+    void *net_slirp_timer_new(SlirpTimerCb cb, void *cb_opaque, void *opaque)
+    {
+        LogFileOutput("SLIRP: slirp_timer_new()\n");
+        return nullptr;
+    }
+
+    void net_slirp_timer_free(void *timer, void *opaque)
+    {
+        LogFileOutput("SLIRP: slirp_timer_free()\n");
+    }
+
+    void net_slirp_timer_mod(void *timer, int64_t expire_timer, void *opaque)
     {
-      LogOutput("nat [%s]\n", pf.toString().c_str());
+        LogFileOutput("SLIRP: slirp_timer_mod()\n");
+    }
+
+    void net_slirp_register_poll_fd(int /* fd */, void * /* opaque */)
+    {
+        // most existing implementations are a NOOP???
+    }
+
+    void net_slirp_unregister_poll_fd(int /* fd */, void * /* opaque */)
+    {
+        // most existing implementations are a NOOP???
+    }
+
+    void net_slirp_notify(void *opaque)
+    {
+        LogFileOutput("SLIRP: slirp_notify()\n");
+    }
+
+    int net_slirp_add_poll(int fd, int events, void *opaque)
+    {
+        SlirpBackend *slirp = reinterpret_cast<SlirpBackend *>(opaque);
+        return slirp->addPoll(fd, events);
+    }
+
+    int net_slirp_get_revents(int idx, void *opaque)
+    {
+        const SlirpBackend *slirp = reinterpret_cast<SlirpBackend *>(opaque);
+        return slirp->getREvents(idx);
+    }
+
+} // namespace
+
+SlirpBackend::SlirpBackend(const std::vector<PortFwd> &portFwds)
+{
+    const SlirpConfig cfg = {
+        .version = SLIRP_CONFIG_VERSION_MAX,
+        .in_enabled = 1,
+        .vnetwork = {.s_addr = IP_PACK(10, 0, 0, 0)},
+        .vnetmask = {.s_addr = IP_PACK(255, 255, 255, 0)},
+        .vhost = {.s_addr = IP_PACK(10, 0, 0, 1)},
+        .vhostname = "applewin",
+        .vdhcp_start = {.s_addr = IP_PACK(10, 0, 0, 2)},
+    };
+    static const SlirpCb slirp_cb = {
+        .send_packet = net_slirp_send_packet,
+        .guest_error = net_slirp_guest_error,
+        .clock_get_ns = net_slirp_clock_get_ns,
+        .timer_new = net_slirp_timer_new,
+        .timer_free = net_slirp_timer_free,
+        .timer_mod = net_slirp_timer_mod,
+        .register_poll_fd = net_slirp_register_poll_fd,
+        .unregister_poll_fd = net_slirp_unregister_poll_fd,
+        .notify = net_slirp_notify,
+    };
+    Slirp *slirp = slirp_new(&cfg, &slirp_cb, this);
+    mySlirp.reset(slirp, slirp_cleanup);
+    for (const auto &pf : portFwds)
+    {
+        const int res = slirp_add_hostfwd(slirp, pf.is_udp, pf.host_addr, pf.host_port, pf.guest_addr, pf.guest_port);
+        if (res != 0)
+        {
+            LogOutput("nat [%s]: slirp error: %s\n", pf.toString().c_str(), strerror(errno));
+        }
+        else
+        {
+            LogOutput("nat [%s]\n", pf.toString().c_str());
+        }
     }
-  }
 }
 
-void SlirpBackend::transmit(const int txlength,	uint8_t *txframe)
+void SlirpBackend::transmit(const int txlength, uint8_t *txframe)
 {
-  slirp_input(mySlirp.get(), txframe, txlength);
+    slirp_input(mySlirp.get(), txframe, txlength);
 }
 
-int SlirpBackend::receive(const int size,	uint8_t * rxframe)
+int SlirpBackend::receive(const int size, uint8_t *rxframe)
 {
-  if (!myQueue.empty())
-  {
-    const std::vector<uint8_t> & packet = myQueue.front();
-    int received = std::min(static_cast<int>(packet.size()), size);
-    memcpy(rxframe, packet.data(), received);
-    if (received & 1)
-    {
-      rxframe[received] = 0;
-      ++received;
-    }
-    myQueue.pop();
-    return received;
-  }
-  else
-  {
-    return -1;
-  }
+    if (!myQueue.empty())
+    {
+        const std::vector<uint8_t> &packet = myQueue.front();
+        int received = std::min(static_cast<int>(packet.size()), size);
+        memcpy(rxframe, packet.data(), received);
+        if (received & 1)
+        {
+            rxframe[received] = 0;
+            ++received;
+        }
+        myQueue.pop();
+        return received;
+    }
+    else
+    {
+        return -1;
+    }
 }
 
 void SlirpBackend::sendToGuest(const uint8_t *pkt, int pkt_len)
 {
-  if (myQueue.size() < ourQueueSize)
-  {
-    myQueue.emplace(pkt, pkt + pkt_len);
-  }
-  else
-  {
-    // drop it
-  }
+    if (myQueue.size() < ourQueueSize)
+    {
+        myQueue.emplace(pkt, pkt + pkt_len);
+    }
+    else
+    {
+        // drop it
+    }
 }
 
 void SlirpBackend::update(const ULONG /* nExecutedCycles */)
 {
-  uint32_t timeout = 0;
-  myFDs.clear();
-  slirp_pollfds_fill(mySlirp.get(), &timeout, net_slirp_add_poll, this);
-  int pollout;
-  if (myFDs.empty())
-  {
-    pollout = 0;
-  }
-  else
-  {
-    pollout = poll(myFDs.data(), myFDs.size(), timeout);
-  }
-  slirp_pollfds_poll(mySlirp.get(), (pollout <= 0), net_slirp_get_revents, this);
+    uint32_t timeout = 0;
+    myFDs.clear();
+    slirp_pollfds_fill(mySlirp.get(), &timeout, net_slirp_add_poll, this);
+    int pollout;
+    if (myFDs.empty())
+    {
+        pollout = 0;
+    }
+    else
+    {
+        pollout = poll(myFDs.data(), myFDs.size(), timeout);
+    }
+    slirp_pollfds_poll(mySlirp.get(), (pollout <= 0), net_slirp_get_revents, this);
 }
 
 int SlirpBackend::addPoll(const int fd, const int events)
 {
-  const pollfd ff = { .fd = fd, .events = vdeslirp_slirp_to_poll(events) };
-  myFDs.push_back(ff);
-  return myFDs.size() - 1;
+    const pollfd ff = {.fd = fd, .events = vdeslirp_slirp_to_poll(events)};
+    myFDs.push_back(ff);
+    return myFDs.size() - 1;
 }
 
 int SlirpBackend::getREvents(const int idx) const
 {
-  return vdeslirp_poll_to_slirp(myFDs[idx].revents);
+    return vdeslirp_poll_to_slirp(myFDs[idx].revents);
 }
 
 bool SlirpBackend::isValid()
 {
-  return true;
+    return true;
 }
 
-void SlirpBackend::getMACAddress(const uint32_t address, MACAddress & mac)
+void SlirpBackend::getMACAddress(const uint32_t address, MACAddress &mac)
 {
-  // a bit of a hack, I've found out that slirp uses
-  /* emulated hosts use the MAC addr 52:55:IP:IP:IP:IP */
-  // https://gitlab.freedesktop.org/slirp/libslirp/-/blob/bf917b89d64f57d9302aba4b2f027ea68fb78c13/src/slirp.c#L78
-  mac.address[0] = 0x52;
-  mac.address[1] = 0x55;
-  uint32_t * ptr = reinterpret_cast<uint32_t *>(mac.address + 2);
-  *ptr = address;
+    // a bit of a hack, I've found out that slirp uses
+    /* emulated hosts use the MAC addr 52:55:IP:IP:IP:IP */
+    // https://gitlab.freedesktop.org/slirp/libslirp/-/blob/bf917b89d64f57d9302aba4b2f027ea68fb78c13/src/slirp.c#L78
+    mac.address[0] = 0x52;
+    mac.address[1] = 0x55;
+    uint32_t *ptr = reinterpret_cast<uint32_t *>(mac.address + 2);
+    *ptr = address;
 }
 
-const std::string & SlirpBackend::getInterfaceName()
+const std::string &SlirpBackend::getInterfaceName()
 {
-  return myEmptyInterface;
+    return myEmptyInterface;
 }
 
 std::string SlirpBackend::getNeighborInfo() const
 {
 #if SLIRP_CHECK_VERSION(4, 5, 0)
-  char * info = slirp_neighbor_info(mySlirp.get());
-  const std::string ret = info;
-  free(info);
-  return ret;
+    char *info = slirp_neighbor_info(mySlirp.get());
+    const std::string ret = info;
+    free(info);
+    return ret;
 #else
-  return "NeighborInfo not available";
+    return "NeighborInfo not available";
 #endif
 }
 
diff --git a/source/linux/network/slirp2.h b/source/linux/network/slirp2.h
index 0651e773f..cd7a482d5 100644
--- a/source/linux/network/slirp2.h
+++ b/source/linux/network/slirp2.h
@@ -24,33 +24,33 @@ struct Slirp;
 class SlirpBackend : public NetworkBackend
 {
 public:
-  SlirpBackend(const std::vector<PortFwd> & portFwds = std::vector<PortFwd>());
+    SlirpBackend(const std::vector<PortFwd> &portFwds = std::vector<PortFwd>());
 
-  void transmit(const int txlength,	uint8_t *txframe) override;
-  int receive(const int size,	uint8_t * rxframe) override;
+    void transmit(const int txlength, uint8_t *txframe) override;
+    int receive(const int size, uint8_t *rxframe) override;
 
-  void update(const ULONG nExecutedCycles) override;
-  bool isValid() override;
+    void update(const ULONG nExecutedCycles) override;
+    bool isValid() override;
 
-  void getMACAddress(const uint32_t address, MACAddress & mac) override;
+    void getMACAddress(const uint32_t address, MACAddress &mac) override;
 
-  const std::string & getInterfaceName() override;
+    const std::string &getInterfaceName() override;
 
-  void sendToGuest(const uint8_t *pkt, int pkt_len);
+    void sendToGuest(const uint8_t *pkt, int pkt_len);
 
-  int addPoll(const int fd, const int events);
-  int getREvents(const int idx) const;
+    int addPoll(const int fd, const int events);
+    int getREvents(const int idx) const;
 
-  std::string getNeighborInfo() const;
-private:
+    std::string getNeighborInfo() const;
 
-  static constexpr size_t ourQueueSize = 10;
+private:
+    static constexpr size_t ourQueueSize = 10;
 
-  const std::string myEmptyInterface;
-  std::shared_ptr<Slirp> mySlirp;
-  std::vector<pollfd> myFDs;
+    const std::string myEmptyInterface;
+    std::shared_ptr<Slirp> mySlirp;
+    std::vector<pollfd> myFDs;
 
-  std::queue<std::vector<uint8_t>> myQueue;
+    std::queue<std::vector<uint8_t>> myQueue;
 };
 
 #endif
diff --git a/source/linux/paddle.cpp b/source/linux/paddle.cpp
index 10e016f71..8f88b60b6 100644
--- a/source/linux/paddle.cpp
+++ b/source/linux/paddle.cpp
@@ -8,10 +8,9 @@
 
 namespace
 {
-  unsigned __int64 g_nJoyCntrResetCycle = 0;	// Abs cycle that joystick counters were reset
-  const double PDL_CNTR_INTERVAL = 2816.0 / 255.0;	// 11.04 (From KEGS)
-}
-
+    unsigned __int64 g_nJoyCntrResetCycle = 0;       // Abs cycle that joystick counters were reset
+    const double PDL_CNTR_INTERVAL = 2816.0 / 255.0; // 11.04 (From KEGS)
+} // namespace
 
 std::shared_ptr<Paddle> Paddle::instance;
 
@@ -20,143 +19,145 @@ bool Paddle::ourSquaring = true;
 
 void Paddle::setButtonPressed(int i)
 {
-  ourButtons.insert(i);
+    ourButtons.insert(i);
 }
 
 void Paddle::setButtonReleased(int i)
 {
-  ourButtons.erase(i);
+    ourButtons.erase(i);
 }
 
 void Paddle::setSquaring(bool value)
 {
-  ourSquaring = value;
+    ourSquaring = value;
 }
 
-
 bool Paddle::getButton(int i) const
 {
-  return false;
+    return false;
 }
 
 double Paddle::getAxis(int i) const
 {
-  return 0;
+    return 0;
 }
 
 int Paddle::getAxisValue(int i) const
 {
-  double axis;
-  if (ourSquaring)
-  {
-    const double x[2] = {getAxis(0), getAxis(1)};
-    axis = x[i];
+    double axis;
+    if (ourSquaring)
+    {
+        const double x[2] = {getAxis(0), getAxis(1)};
+        axis = x[i];
 
-    if (x[0] * x[1] != 0.0)
+        if (x[0] * x[1] != 0.0)
+        {
+            // rescale the circle to the square
+            const double ratio2 = (x[1] * x[1]) / (x[0] * x[0]);
+            const double c = std::min(ratio2, 1.0 / ratio2);
+            const double coeff = std::sqrt(1.0 + c);
+            axis *= coeff;
+        }
+    }
+    else
     {
-      // rescale the circle to the square
-      const double ratio2 = (x[1] * x[1]) / (x[0] * x[0]);
-      const double c = std::min(ratio2, 1.0 / ratio2);
-      const double coeff = std::sqrt(1.0 + c);
-      axis *= coeff;
+        axis = getAxis(i);
     }
-  }
-  else
-  {
-    axis = getAxis(i);
-  }
-
-  const int value = static_cast<int>((axis + 1.0) * 0.5 * 255);
-  return value;
+
+    const int value = static_cast<int>((axis + 1.0) * 0.5 * 255);
+    return value;
 }
 
 BYTE __stdcall JoyReadButton(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG uExecutedCycles)
 {
-  addr &= 0xFF;
-  BOOL pressed = 0;
-
-  if (Paddle::ourButtons.find(addr) != Paddle::ourButtons.end())
-  {
-    pressed = 1;
-  }
-  else
-  {
-    if (Paddle::instance)
+    addr &= 0xFF;
+    BOOL pressed = 0;
+
+    if (Paddle::ourButtons.find(addr) != Paddle::ourButtons.end())
     {
-      switch (addr)
-      {
-      case Paddle::ourOpenApple:
-        if (CopyProtectionDonglePB0() >= 0)
-        {
-          pressed = CopyProtectionDonglePB0();
-        }
-        else
-        {
-          pressed = Paddle::instance->getButton(0);
-        }
-        break;
-      case Paddle::ourSolidApple:
-        if (CopyProtectionDonglePB1() >= 0)
-        {
-          pressed = CopyProtectionDonglePB1();
-        }
-        else
-        {
-          pressed = Paddle::instance->getButton(1);
-        }
-        break;
-      case Paddle::ourThirdApple:
-        if (CopyProtectionDonglePB2() >= 0)
+        pressed = 1;
+    }
+    else
+    {
+        if (Paddle::instance)
         {
-          pressed = CopyProtectionDonglePB2();
+            switch (addr)
+            {
+            case Paddle::ourOpenApple:
+                if (CopyProtectionDonglePB0() >= 0)
+                {
+                    pressed = CopyProtectionDonglePB0();
+                }
+                else
+                {
+                    pressed = Paddle::instance->getButton(0);
+                }
+                break;
+            case Paddle::ourSolidApple:
+                if (CopyProtectionDonglePB1() >= 0)
+                {
+                    pressed = CopyProtectionDonglePB1();
+                }
+                else
+                {
+                    pressed = Paddle::instance->getButton(1);
+                }
+                break;
+            case Paddle::ourThirdApple:
+                if (CopyProtectionDonglePB2() >= 0)
+                {
+                    pressed = CopyProtectionDonglePB2();
+                }
+                break;
+            }
         }
-        break;
-      }
     }
-  }
 
-  return MemReadFloatingBus(pressed, uExecutedCycles);
+    return MemReadFloatingBus(pressed, uExecutedCycles);
 }
 
 BYTE __stdcall JoyReadPosition(WORD pc, WORD address, BYTE bWrite, BYTE d, ULONG uExecutedCycles)
 {
-  CpuCalcCycles(uExecutedCycles);
-
-  const int pdl = address & 3;  // 11: joy number & axis
-  const int copyProtection = CopyProtectionDonglePDL(pdl);
-
-  // if nothing is connected, set it to TRUE
-  BOOL nPdlCntrActive = TRUE;
-
-  const auto setPdlPos = [&nPdlCntrActive] (const int pos) {
-    nPdlCntrActive = g_nCumulativeCycles <= (g_nJoyCntrResetCycle + (unsigned __int64) ((double)pos * PDL_CNTR_INTERVAL));
-  };
-
-  if (copyProtection >= 0)
-  {
-    // if active, this has the highest priority
-    setPdlPos(copyProtection);
-  }
-  else if (Paddle::instance)
-  {
-    const int nJoyNum = (address & 2) ? 1 : 0;	// $C064..$C067
-    if (nJoyNum == 0)
+    CpuCalcCycles(uExecutedCycles);
+
+    const int pdl = address & 3; // 11: joy number & axis
+    const int copyProtection = CopyProtectionDonglePDL(pdl);
+
+    // if nothing is connected, set it to TRUE
+    BOOL nPdlCntrActive = TRUE;
+
+    const auto setPdlPos = [&nPdlCntrActive](const int pos)
     {
-      int axis = address & 1;
-      int pos = Paddle::instance->getAxisValue(axis);
-      // This is from KEGS. It helps games like Championship Lode Runner, Boulderdash & Learning with Leeper(GH#1128)
-      if (pos >= 255)
-        pos = 287;
+        nPdlCntrActive =
+            g_nCumulativeCycles <= (g_nJoyCntrResetCycle + (unsigned __int64)((double)pos * PDL_CNTR_INTERVAL));
+    };
 
-      setPdlPos(pos);
+    if (copyProtection >= 0)
+    {
+        // if active, this has the highest priority
+        setPdlPos(copyProtection);
+    }
+    else if (Paddle::instance)
+    {
+        const int nJoyNum = (address & 2) ? 1 : 0; // $C064..$C067
+        if (nJoyNum == 0)
+        {
+            int axis = address & 1;
+            int pos = Paddle::instance->getAxisValue(axis);
+            // This is from KEGS. It helps games like Championship Lode Runner, Boulderdash & Learning with
+            // Leeper(GH#1128)
+            if (pos >= 255)
+                pos = 287;
+
+            setPdlPos(pos);
+        }
     }
-  }
 
-  return MemReadFloatingBus(nPdlCntrActive, uExecutedCycles);
+    return MemReadFloatingBus(nPdlCntrActive, uExecutedCycles);
 }
 
 void JoyResetPosition(ULONG uExecutedCycles)
 {
-  CpuCalcCycles(uExecutedCycles);
-  g_nJoyCntrResetCycle = g_nCumulativeCycles;
+    CpuCalcCycles(uExecutedCycles);
+    g_nJoyCntrResetCycle = g_nCumulativeCycles;
 }
diff --git a/source/linux/paddle.h b/source/linux/paddle.h
index 0ba331a39..d69fae09d 100644
--- a/source/linux/paddle.h
+++ b/source/linux/paddle.h
@@ -6,24 +6,24 @@
 class Paddle
 {
 public:
-  virtual ~Paddle() = default;
+    virtual ~Paddle() = default;
 
-  virtual bool getButton(int i) const;
-  virtual double getAxis(int i) const;  // -> [-1, 1]
+    virtual bool getButton(int i) const;
+    virtual double getAxis(int i) const; // -> [-1, 1]
 
-  int getAxisValue(int i) const;
+    int getAxisValue(int i) const;
 
-  static constexpr int ourOpenApple = 0x61;
-  static constexpr int ourSolidApple = 0x62;
-  static constexpr int ourThirdApple = 0x63;
+    static constexpr int ourOpenApple = 0x61;
+    static constexpr int ourSolidApple = 0x62;
+    static constexpr int ourThirdApple = 0x63;
 
-  static void setButtonPressed(int i);
-  static void setButtonReleased(int i);
-  static std::set<int> ourButtons;
-  static void setSquaring(bool value);
+    static void setButtonPressed(int i);
+    static void setButtonReleased(int i);
+    static std::set<int> ourButtons;
+    static void setSquaring(bool value);
 
-  static std::shared_ptr<Paddle> instance;
+    static std::shared_ptr<Paddle> instance;
 
 private:
-  static bool ourSquaring;
+    static bool ourSquaring;
 };
diff --git a/source/linux/registryclass.cpp b/source/linux/registryclass.cpp
index df7a68521..f53cccacf 100644
--- a/source/linux/registryclass.cpp
+++ b/source/linux/registryclass.cpp
@@ -5,83 +5,83 @@
 
 std::shared_ptr<Registry> Registry::instance;
 
-BOOL RegLoadString (LPCTSTR section, LPCTSTR key, BOOL peruser, LPTSTR buffer, uint32_t chars, LPCTSTR defaultValue)
+BOOL RegLoadString(LPCTSTR section, LPCTSTR key, BOOL peruser, LPTSTR buffer, uint32_t chars, LPCTSTR defaultValue)
 {
-  BOOL success = RegLoadString(section, key, peruser, buffer, chars);
-  if (!success)
-    StringCbCopy(buffer, chars, defaultValue);
-  return success;
+    BOOL success = RegLoadString(section, key, peruser, buffer, chars);
+    if (!success)
+        StringCbCopy(buffer, chars, defaultValue);
+    return success;
 }
 
-BOOL RegLoadValue (LPCTSTR section, LPCTSTR key, BOOL peruser, uint32_t* value, uint32_t defaultValue) {
-  BOOL success = RegLoadValue(section, key, peruser, value);
-  if (!success)
-    *value = defaultValue;
-  return success;
+BOOL RegLoadValue(LPCTSTR section, LPCTSTR key, BOOL peruser, uint32_t *value, uint32_t defaultValue)
+{
+    BOOL success = RegLoadValue(section, key, peruser, value);
+    if (!success)
+        *value = defaultValue;
+    return success;
 }
 
-BOOL RegLoadString (LPCTSTR section, LPCTSTR key, BOOL peruser,
-                    LPTSTR buffer, uint32_t chars)
+BOOL RegLoadString(LPCTSTR section, LPCTSTR key, BOOL peruser, LPTSTR buffer, uint32_t chars)
 {
-  BOOL result;
-  try
-  {
-    const std::string s = Registry::instance->getString(section, key);
-    strncpy(buffer, s.c_str(), chars);
-    buffer[chars - 1] = 0;
-    result = TRUE;
-    LogFileOutput("RegLoadString: %s - %s = %s\n", section, key, buffer);
-  }
-  catch (const std::exception & e)
-  {
-    result = FALSE;
-    LogFileOutput("RegLoadString: %s - %s = ??\n", section, key);
-  }
-  return result;
+    BOOL result;
+    try
+    {
+        const std::string s = Registry::instance->getString(section, key);
+        strncpy(buffer, s.c_str(), chars);
+        buffer[chars - 1] = 0;
+        result = TRUE;
+        LogFileOutput("RegLoadString: %s - %s = %s\n", section, key, buffer);
+    }
+    catch (const std::exception &e)
+    {
+        result = FALSE;
+        LogFileOutput("RegLoadString: %s - %s = ??\n", section, key);
+    }
+    return result;
 }
 
-BOOL RegLoadValue (LPCTSTR section, LPCTSTR key, BOOL peruser, uint32_t *value)
+BOOL RegLoadValue(LPCTSTR section, LPCTSTR key, BOOL peruser, uint32_t *value)
 {
-  BOOL result;
-  try
-  {
-    *value = Registry::instance->getDWord(section, key);
-    result = TRUE;
-    LogFileOutput("RegLoadValue: %s - %s = %d\n", section, key, *value);
-  }
-  catch (const std::exception & e)
-  {
-    result = FALSE;
-    LogFileOutput("RegLoadValue: %s - %s = ??\n", section, key);
-  }
-  return result;
+    BOOL result;
+    try
+    {
+        *value = Registry::instance->getDWord(section, key);
+        result = TRUE;
+        LogFileOutput("RegLoadValue: %s - %s = %d\n", section, key, *value);
+    }
+    catch (const std::exception &e)
+    {
+        result = FALSE;
+        LogFileOutput("RegLoadValue: %s - %s = ??\n", section, key);
+    }
+    return result;
 }
 
-BOOL RegLoadValue (LPCTSTR section, LPCTSTR key, BOOL peruser, BOOL *value)
+BOOL RegLoadValue(LPCTSTR section, LPCTSTR key, BOOL peruser, BOOL *value)
 {
-  BOOL result;
-  try
-  {
-    *value = Registry::instance->getBool(section, key);
-    result = TRUE;
-    LogFileOutput("RegLoadValue: %s - %s = %d\n", section, key, *value);
-  }
-  catch (const std::exception & e)
-  {
-    result = FALSE;
-    LogFileOutput("RegLoadValue: %s - %s = ??\n", section, key);
-  }
-  return result;
+    BOOL result;
+    try
+    {
+        *value = Registry::instance->getBool(section, key);
+        result = TRUE;
+        LogFileOutput("RegLoadValue: %s - %s = %d\n", section, key, *value);
+    }
+    catch (const std::exception &e)
+    {
+        result = FALSE;
+        LogFileOutput("RegLoadValue: %s - %s = ??\n", section, key);
+    }
+    return result;
 }
 
-void RegSaveString (LPCTSTR section, LPCTSTR key, BOOL peruser, const std::string & buffer)
+void RegSaveString(LPCTSTR section, LPCTSTR key, BOOL peruser, const std::string &buffer)
 {
-  Registry::instance->putString(section, key, buffer);
-  LogFileOutput("RegSaveString: %s - %s = %s\n", section, key, buffer.c_str());
+    Registry::instance->putString(section, key, buffer);
+    LogFileOutput("RegSaveString: %s - %s = %s\n", section, key, buffer.c_str());
 }
 
-void RegSaveValue (LPCTSTR section, LPCTSTR key, BOOL peruser, uint32_t value)
+void RegSaveValue(LPCTSTR section, LPCTSTR key, BOOL peruser, uint32_t value)
 {
-  Registry::instance->putDWord(section, key, value);
-  LogFileOutput("RegSaveValue: %s - %s = %d\n", section, key, value);
+    Registry::instance->putDWord(section, key, value);
+    LogFileOutput("RegSaveValue: %s - %s = %d\n", section, key, value);
 }
diff --git a/source/linux/registryclass.h b/source/linux/registryclass.h
index e726287b7..fd5dd7ef3 100644
--- a/source/linux/registryclass.h
+++ b/source/linux/registryclass.h
@@ -7,19 +7,18 @@
 class Registry
 {
 public:
-  virtual ~Registry() = default;
+    virtual ~Registry() = default;
 
-  static std::shared_ptr<Registry> instance;
+    static std::shared_ptr<Registry> instance;
 
-  virtual std::string getString(const std::string & section, const std::string & key) const = 0;
-  virtual uint32_t getDWord(const std::string & section, const std::string & key) const = 0;
-  virtual bool getBool(const std::string & section, const std::string & key) const = 0;
+    virtual std::string getString(const std::string &section, const std::string &key) const = 0;
+    virtual uint32_t getDWord(const std::string &section, const std::string &key) const = 0;
+    virtual bool getBool(const std::string &section, const std::string &key) const = 0;
 
-  virtual void putString(const std::string & section, const std::string & key, const std::string & value) = 0;
-  virtual void putDWord(const std::string & section, const std::string & key, const uint32_t value) = 0;
+    virtual void putString(const std::string &section, const std::string &key, const std::string &value) = 0;
+    virtual void putDWord(const std::string &section, const std::string &key, const uint32_t value) = 0;
 
-  virtual std::map<std::string, std::map<std::string, std::string>> getAllValues() const = 0;
-
-  virtual std::string getLocation() const = 0;
+    virtual std::map<std::string, std::map<std::string, std::string>> getAllValues() const = 0;
 
+    virtual std::string getLocation() const = 0;
 };
diff --git a/source/linux/version.cpp b/source/linux/version.cpp
index 6db442470..2a9a6b1d3 100644
--- a/source/linux/version.cpp
+++ b/source/linux/version.cpp
@@ -2,14 +2,14 @@
 #include "../resource/version.h"
 
 #define xstr2(a) str2(a)
-#define str2(a, b, c, d) #a"."#b"."#c"."#d
+#define str2(a, b, c, d) #a "." #b "." #c "." #d
 
 std::string getVersion()
 {
-  return xstr2(APPLEWIN_VERSION);
+    return xstr2(APPLEWIN_VERSION);
 }
 
 std::array<int, 4> getVersionNumbers()
 {
-  return {APPLEWIN_VERSION};
+    return {APPLEWIN_VERSION};
 }