wanda: restructure source layoutHEADdevelop

6 files changed, 362 insertions, 0 deletions

diff --git a/source/lib/src/system/environment.cpp b/source/lib/src/system/environment.cpp
new file mode 100644
index 0000000..8f79531
--- /dev/null
+++ b/source/lib/src/system/environment.cpp
@@ -0,0 +1,71 @@
+#include "wanda/system/environment.hpp"
+
+#include <string>
+
+namespace wanda::system
+{
+  environment::environment(char const * const * env)
+  {
+    if (!env)
+    {
+      return;
+    }
+
+    std::string buffer{};
+    for (; *env != nullptr; ++env)
+    {
+      buffer = *env;
+      int split_point = buffer.find('=');
+      if (split_point != std::string::npos)
+      {
+        m_cache[buffer.substr(0, split_point)] = buffer.substr(split_point + 1);
+      }
+    }
+  }
+
+  std::string & environment::operator[](std::string const & variable)
+  {
+    return m_cache[variable];
+  }
+
+  std::string const & environment::operator[](std::string const & variable) const
+  {
+    static std::string const empty{};
+    if (auto needle = m_cache.find(variable); needle != cend())
+    {
+      return needle->second;
+    }
+    return empty;
+  }
+
+  environment::iterator environment::begin()
+  {
+    return m_cache.begin();
+  }
+
+  environment::const_iterator environment::begin() const
+  {
+    return m_cache.begin();
+  }
+
+  environment::const_iterator environment::cbegin() const
+  {
+    return m_cache.cbegin();
+  }
+
+  environment::iterator environment::end()
+  {
+    return m_cache.end();
+  }
+
+  environment::const_iterator environment::end() const
+  {
+    return m_cache.end();
+  }
+
+  environment::const_iterator environment::cend() const
+  {
+    return m_cache.cend();
+  }
+
+}  // namespace wanda::system
\ No newline at end of file
diff --git a/source/lib/src/system/filesystem.cpp b/source/lib/src/system/filesystem.cpp
new file mode 100644
index 0000000..04dfff3
--- /dev/null
+++ b/source/lib/src/system/filesystem.cpp
@@ -0,0 +1,31 @@
+#include "wanda/system/filesystem.hpp"
+
+#include <random>
+#include <ranges>
+
+namespace wanda::system
+{
+  std::optional<path_list> scan(std::filesystem::path source, bool(filter)(std::filesystem::path const &))
+  {
+    if (!std::filesystem::is_directory(source))
+    {
+      return std::nullopt;
+    }
+    auto entries = std::filesystem::recursive_directory_iterator{source};
+    auto result = path_list{};
+    for (auto & entry : entries | std::views::filter(filter))
+    {
+      result.push_back(entry.path());
+    }
+    return result;
+  }
+
+  std::filesystem::path random_pick(path_list const & paths)
+  {
+    static auto generator = std::mt19937{std::random_device{}()};
+    auto distribution = std::uniform_int_distribution<std::size_t>{0, paths.size() - 1};
+
+    return paths[distribution(generator)];
+  }
+
+}  // namespace wanda::system
\ No newline at end of file
diff --git a/source/lib/src/system/logging.cpp b/source/lib/src/system/logging.cpp
new file mode 100644
index 0000000..83dc9f6
--- /dev/null
+++ b/source/lib/src/system/logging.cpp
@@ -0,0 +1,21 @@
+#include "wanda/system/logging.hpp"
+
+namespace wanda::system
+{
+  std::function<void(spdlog::sink_ptr)> initializer = [](spdlog::sink_ptr sink) {
+    spdlog::register_logger(std::make_shared<spdlog::logger>("wanda", sink));
+    initializer = [](auto) {};
+  };
+
+  void initialize_logger(spdlog::sink_ptr sink)
+  {
+    initializer(sink);
+  }
+
+  logger_ptr get_logger()
+  {
+    initialize_logger();
+    return spdlog::get("wanda");
+  }
+
+}  // namespace wanda::system
\ No newline at end of file
diff --git a/source/lib/src/system/setting.cpp b/source/lib/src/system/setting.cpp
new file mode 100644
index 0000000..1553eae
--- /dev/null
+++ b/source/lib/src/system/setting.cpp
@@ -0,0 +1,102 @@
+#include "wanda/system/setting.hpp"
+
+#include <algorithm>
+#include <type_traits>
+
+namespace wanda::system
+{
+  // UDL implementations
+
+  key literals::operator""_key(char const * str, std::size_t len)
+  {
+    return key{{str, len}};
+  }
+
+  std::optional<setting> literals::operator""_setting(char const * str, std::size_t len)
+  {
+    auto source = g_settings_schema_source_get_default();
+    if (!source)
+    {
+      return std::nullopt;
+    }
+
+    auto schema = g_settings_schema_source_lookup(source, str, true);
+    if (!schema)
+    {
+      return std::nullopt;
+    }
+
+    return setting{schema};
+  }
+
+  // 'setting' implementation
+
+  setting::setting(GSettingsSchema * schema)
+      : m_schema{schema, &g_settings_schema_unref}
+  {
+  }
+
+  std::optional<setting::entry> setting::operator[](key key) const
+  {
+    if (!g_settings_schema_has_key(m_schema.get(), key.get().c_str()))
+    {
+      return std::nullopt;
+    }
+
+    return setting::entry{*this, std::move(key)};
+  }
+
+  // 'setting::entry' implementation
+
+  setting::entry::entry(setting const & setting, key key)
+      : m_settings{g_settings_new(g_settings_schema_get_id(setting.m_schema.get())), &g_object_unref}
+      , m_key{key.get()}
+  {
+  }
+
+  setting::entry::value_type setting::entry::operator*() const
+  {
+    auto value = std::unique_ptr<GVariant, decltype(&g_variant_unref)>{g_settings_get_value(m_settings.get(), m_key.get().c_str()), &g_variant_unref};
+    auto raw = value.get();
+
+    if (g_variant_is_of_type(raw, G_VARIANT_TYPE_BOOLEAN))
+    {
+      return static_cast<bool>(g_variant_get_boolean(raw));
+    }
+    else if (g_variant_is_of_type(raw, G_VARIANT_TYPE_INT32))
+    {
+      return static_cast<std::int32_t>(g_variant_get_int32(raw));
+    }
+    else if (g_variant_is_of_type(raw, G_VARIANT_TYPE_INT64))
+    {
+      return static_cast<std::int64_t>(g_variant_get_int64(raw));
+    }
+    else if (g_variant_is_of_type(raw, G_VARIANT_TYPE_UINT32))
+    {
+      return static_cast<std::uint32_t>(g_variant_get_uint32(raw));
+    }
+    else if (g_variant_is_of_type(raw, G_VARIANT_TYPE_UINT64))
+    {
+      return static_cast<std::uint64_t>(g_variant_get_uint64(raw));
+    }
+    else if (g_variant_is_of_type(raw, G_VARIANT_TYPE_DOUBLE))
+    {
+      return static_cast<double>(g_variant_get_double(raw));
+    }
+    else if (g_variant_is_of_type(raw, G_VARIANT_TYPE_STRING))
+    {
+      auto size = gsize{};
+      auto string = g_variant_get_string(raw, &size);
+      return std::string{string, size};
+    }
+    else if (g_variant_is_of_type(raw, G_VARIANT_TYPE_STRING_ARRAY))
+    {
+      auto length = gsize{};
+      auto data = g_variant_get_strv(raw, &length);
+      return std::vector<std::string>{data, data + length};
+    }
+
+    return {};
+  }
+
+}  // namespace wanda::system
\ No newline at end of file
diff --git a/source/lib/src/system/wallpaper.cpp b/source/lib/src/system/wallpaper.cpp
new file mode 100644
index 0000000..11a6402
--- /dev/null
+++ b/source/lib/src/system/wallpaper.cpp
@@ -0,0 +1,91 @@
+#include "wanda/system/wallpaper.hpp"
+
+#include "wanda/std_ext/optional.hpp"
+#include "wanda/system/logging.hpp"
+#include "wanda/system/magic.hpp"
+#include "wanda/system/setting.hpp"
+
+#include <boost/gil.hpp>
+#include <boost/gil/extension/io/jpeg.hpp>
+#include <boost/gil/extension/io/png.hpp>
+#include <boost/gil/extension/numeric/resample.hpp>
+#include <boost/gil/extension/numeric/sampler.hpp>
+#include <spdlog/fmt/fmt.h>
+
+#include <algorithm>
+#include <cmath>
+#include <memory>
+
+namespace wanda::system
+{
+  namespace
+  {
+    auto magic_instance = magic{};
+
+    auto load_image(std::filesystem::path wallpaper)
+    {
+      auto image = boost::gil::rgb8_image_t{};
+
+      switch (magic_instance.type(wallpaper))
+      {
+        case magic::mime_type::image_jpeg:
+          boost::gil::read_and_convert_image(wallpaper.native(), image, boost::gil::jpeg_tag{});
+          break;
+        case magic::mime_type::image_png:
+          boost::gil::read_and_convert_image(wallpaper.native(), image, boost::gil::png_tag{});
+          break;
+      }
+
+      return image;
+    }
+
+    auto average_colors(boost::gil::rgb8_image_t image)
+    {
+      auto accumulator = boost::gil::rgb64f_pixel_t{};
+      auto view = const_view(image);
+
+      std::ranges::for_each(view, [&](auto const & source_pixel) {
+        at_c<0>(accumulator) += std::pow(boost::gil::at_c<0>(source_pixel), 2);
+        at_c<1>(accumulator) += std::pow(boost::gil::at_c<1>(source_pixel), 2);
+        at_c<2>(accumulator) += std::pow(boost::gil::at_c<2>(source_pixel), 2);
+      });
+
+      at_c<0>(accumulator) = std::sqrt(at_c<0>(accumulator) / view.size());
+      at_c<1>(accumulator) = std::sqrt(at_c<1>(accumulator) / view.size());
+      at_c<2>(accumulator) = std::sqrt(at_c<2>(accumulator) / view.size());
+
+      return accumulator;
+    }
+
+  }  // namespace
+
+  void set_wallpaper(std::filesystem::path wallpaper)
+  {
+    using namespace wanda::system::literals;
+    using namespace wanda::std_ext;
+    using namespace std::string_literals;
+
+    auto image = load_image(wallpaper);
+    auto color = average_colors(std::move(image));
+    auto hexstring = spdlog::fmt_lib::format("#{:02X}{:02X}{:02X}",
+                                             static_cast<std::uint8_t>(at_c<0>(color)),
+                                             static_cast<std::uint8_t>(at_c<1>(color)),
+                                             static_cast<std::uint8_t>(at_c<2>(color)));
+
+    with("org.gnome.desktop.background"_setting, [&](auto & setting) {
+      with(setting["primary-color"_key], [&](auto & value) {
+        value = hexstring;
+      });
+      with(setting["picture-uri"_key], [&](auto & value) {
+        value = "file://" + wallpaper.native();
+      }) ||
+          [&] { get_logger()->error("invalid settings key"); };
+      with(setting["picture-uri-dark"_key], [&](auto & value) {
+        value = "file://" + wallpaper.native();
+      }) ||
+          [&] { get_logger()->error("invalid settings key"); };
+    }) ||
+        [&] { get_logger()->error("invalid setting"); };
+  }
+
+}  // namespace wanda::system
diff --git a/source/lib/src/system/xdg.cpp b/source/lib/src/system/xdg.cpp
new file mode 100644
index 0000000..109beb1
--- /dev/null
+++ b/source/lib/src/system/xdg.cpp
@@ -0,0 +1,46 @@
+#include "wanda/system/xdg.hpp"
+
+#include <unistd.h>
+
+namespace wanda::system
+{
+  std::string xdg_variable(xdg_directory directory)
+  {
+    switch (directory)
+    {
+      case xdg_directory::data_home:
+        return "XDG_DATA_HOME";
+      case xdg_directory::config_home:
+        return "XDG_CONFIG_HOME";
+      case xdg_directory::cache_home:
+        return "XDG_CACHE_HOME";
+      case xdg_directory::runtime_dir:
+        return "XDG_RUNTIME_DIR";
+    }
+    return "XDG_INVALID_PATH";
+  }
+
+  std::filesystem::path xdg_path_for(xdg_directory directory, environment const & environment)
+  {
+    if (auto path = environment[xdg_variable(directory)]; !path.empty())
+    {
+      return path;
+    }
+
+    auto home = std::filesystem::path{environment["HOME"]};
+    switch (directory)
+    {
+      case xdg_directory::data_home:
+        return home / ".local/share";
+      case xdg_directory::config_home:
+        return home / ".config";
+      case xdg_directory::cache_home:
+        return home / ".cache";
+      case xdg_directory::runtime_dir:
+        return std::filesystem::path{"/run/user"} / std::to_string(::getuid());
+    }
+
+    return "";
+  }
+
+}  // namespace wanda::system
\ No newline at end of file