Merge pull request #3 from gelly-gmod/1-relocate

1 - Relocate to an installation dir

Author: yogwoggf

CHANGELOG.md

@@ -5,6 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.3.0] - 2025-01-03
+
+### Added
+
+- The installer now automatically relocates itself to the installed apps directory.
+- This is in preparation for the upcoming auto-update feature.
+- Note: Opening the installer again will launch the installed app and not the one that was previously launched.
+
 ## [1.2.0] - 2024-12-27
 
 ### Added

CMakeLists.txt

@@ -56,6 +56,16 @@ add_executable(gelly_installer WIN32
         src/logging/log.cpp
         src/logging/crash-logging.cpp
         src/logging/crash-logging.hpp
+        src/helpers/find-app-data.cpp
+        src/helpers/find-app-data.hpp
+        src/app/config.cpp
+        src/app/config.hpp
+        src/app/relocate-installation.cpp
+        src/app/relocate-installation.hpp
+        src/helpers/launch-installer.cpp
+        src/helpers/launch-installer.hpp
+        src/helpers/parse-version.cpp
+        src/helpers/parse-version.hpp
 )
 
 target_link_libraries(gelly_installer
@@ -71,6 +81,7 @@ target_link_libraries(gelly_installer
 target_include_directories(gelly_installer
         PRIVATE
         src
+        ${CMAKE_CURRENT_BINARY_DIR}/src
         vendor/SDL/include
         vendor/VDFParser
         vendor/imgui
@@ -84,7 +95,10 @@ target_compile_definitions(gelly_installer
 )
 
 include(ExtraFiles)
+include(GetCurrentVersion)
 get_extra_files(${CMAKE_CURRENT_SOURCE_DIR})
+get_current_version_from_changelog(${CMAKE_CURRENT_SOURCE_DIR}/CHANGELOG.md)
+configure_file(src/version.hpp.in src/version.hpp @ONLY)
 
 foreach (file ${EXTRA_FILES})
   add_custom_command(TARGET gelly_installer POST_BUILD

cmake/modules/GetCurrentVersion.cmake

@@ -0,0 +1,5 @@
+function(get_current_version_from_changelog changelog_file)
+  file(READ ${changelog_file} CHANGELOG)
+  string(REGEX MATCH "## \\[([0-9]+\.[0-9]+\.[0-9]+)\\]" _ ${CHANGELOG})
+  set(GELLY_INSTALLER_VERSION ${CMAKE_MATCH_1} PARENT_SCOPE)
+endfunction()

src/app/config.cpp

@@ -0,0 +1,62 @@
+#include "config.hpp"
+
+#include "helpers/parse-version.hpp"
+
+#include <array>
+#include <windows.h>
+
+namespace gelly {
+namespace {
+auto REGISTRY_PARENT = std::string("SOFTWARE\\") + Config::APP_NAME;
+auto KEY = HKEY_CURRENT_USER;
+
+std::optional<std::string> FetchFromGellyRegistry(const std::string &subkey) {
+  std::array<char, MAX_PATH> value = {};
+  DWORD size = sizeof(value);
+
+  const auto path = REGISTRY_PARENT;
+  if (RegGetValue(KEY, path.c_str(), subkey.c_str(), RRF_RT_REG_SZ, nullptr,
+                  value.data(), &size) != ERROR_SUCCESS) {
+    return std::nullopt;
+  }
+
+  std::string valueStr(value.begin(), value.begin() + (size - 1));
+  return valueStr;
+}
+
+void WriteToGellyRegistry(const std::string &subkey, const std::string &value) {
+  if (RegSetKeyValue(KEY, REGISTRY_PARENT.c_str(), subkey.c_str(),
+                     RRF_RT_REG_SZ, value.data(),
+                     value.size()) != ERROR_SUCCESS) {
+    throw std::runtime_error("Failed to write to registry");
+  }
+}
+} // namespace
+
+optional<std::filesystem::path> Config::GetAppInstallPath() {
+  return FetchFromGellyRegistry("InstallPath");
+}
+
+void Config::SetAppInstallPath(const std::filesystem::path &path) {
+  WriteToGellyRegistry("InstallPath", path.string());
+}
+
+optional<std::string> Config::GetAppVersion() {
+  return FetchFromGellyRegistry("Version");
+}
+
+void Config::SetAppVersion(const std::string &version) {
+  WriteToGellyRegistry("Version", version);
+}
+
+bool Config::IsAppInstalled() {
+  return GetAppInstallPath().has_value() &&
+         std::filesystem::exists(*GetAppInstallPath());
+}
+
+bool Config::IsAppUpToDate() {
+  return IsAppInstalled() && (GetAppVersion().has_value() &&
+                              *helpers::ParseVersion(*GetAppVersion()) >=
+                                  *helpers::ParseVersion(APP_VERSION));
+}
+} // namespace gelly

src/app/config.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <filesystem>
+#include <optional>
+#include <version.hpp>
+
+using std::optional;
+
+namespace gelly {
+class Config {
+public:
+  static constexpr auto APP_NAME = "GellyInstaller";
+  static constexpr auto APP_VERSION = GELLY_INSTALLER_VERSION;
+
+  static optional<std::filesystem::path> GetAppInstallPath();
+  static void SetAppInstallPath(const std::filesystem::path &path);
+
+  static optional<std::string> GetAppVersion();
+  static void SetAppVersion(const std::string &version);
+
+  static bool IsAppInstalled();
+  static bool IsAppUpToDate();
+};
+
+} // namespace gelly

src/app/relocate-installation.cpp

@@ -0,0 +1,26 @@
+#include "relocate-installation.hpp"
+#include "app/config.hpp"
+#include "helpers/find-app-data.hpp"
+
+#include <filesystem>
+
+namespace gelly {
+std::filesystem::path RelocateInstallation() {
+  const auto cwd = std::filesystem::current_path();
+  const auto appData = helpers::FindAppData();
+  if (!appData.has_value()) {
+    throw std::runtime_error("Failed to find AppData directory");
+  }
+
+  const auto newPath = appData.value() / Config::APP_NAME;
+  if (!std::filesystem::exists(newPath)) {
+    std::filesystem::create_directories(newPath);
+  } else {
+    std::filesystem::remove_all(newPath);
+  }
+
+  std::filesystem::copy(cwd, newPath, std::filesystem::copy_options::recursive);
+  return newPath;
+}
+
+} // namespace gelly

src/app/relocate-installation.hpp

@@ -0,0 +1,6 @@
+#pragma once
+#include <filesystem>
+
+namespace gelly {
+std::filesystem::path RelocateInstallation();
+} // namespace gelly

src/helpers/find-app-data.cpp

@@ -0,0 +1,17 @@
+#include "find-app-data.hpp"
+#include <array>
+#include <shlobj_core.h>
+#include <windows.h>
+
+namespace gelly::helpers {
+std::optional<std::filesystem::path> FindAppData() {
+  std::array<TCHAR, MAX_PATH> appDataPath;
+  if (SUCCEEDED(SHGetFolderPath(nullptr, CSIDL_APPDATA, nullptr, 0,
+                                appDataPath.data()))) {
+    return std::filesystem::path(appDataPath.data());
+  }
+
+  return std::nullopt;
+}
+
+} // namespace gelly::helpers

src/helpers/find-app-data.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <filesystem>
+#include <optional>
+
+namespace gelly::helpers {
+std::optional<std::filesystem::path> FindAppData();
+}

src/helpers/launch-installer.cpp

@@ -0,0 +1,37 @@
+#include "launch-installer.hpp"
+
+// clang-format off
+#include <windows.h>
+#include <shellapi.h>
+// clang-format on
+
+namespace gelly::helpers {
+namespace {
+const auto INSTALLER_EXE = std::string("gelly_installer.exe");
+}
+
+void LaunchInstaller(const std::filesystem::path &installerPath) {
+  auto exePath = installerPath.string() + "\\" + INSTALLER_EXE;
+  auto workingDir = installerPath.string();
+
+  SHELLEXECUTEINFO info = {};
+  info.cbSize = sizeof(SHELLEXECUTEINFO);
+  info.fMask = SEE_MASK_NOCLOSEPROCESS;
+  info.lpFile = exePath.c_str();
+  info.lpDirectory = workingDir.c_str();
+  info.lpClass = ".exe";
+  info.nShow = SW_SHOW;
+  info.lpVerb = "open";
+  info.hwnd = nullptr;
+
+  const auto result = ShellExecuteExA(&info);
+  if (result == FALSE) {
+    MessageBoxW(nullptr, L"Failed to launch installer", L"Error",
+                MB_OK | MB_ICONERROR);
+    std::exit(1);
+  }
+
+  std::exit(0);
+}
+
+} // namespace gelly::helpers