os_settings.hpp

// Copyright Take Vos 2022.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "theme_mode.hpp"
#include "subpixel_orientation.hpp"
#include "../i18n/module.hpp"
#include "../geometry/module.hpp"
#include "../utility/module.hpp"
#include "../numeric/module.hpp"
#include "../observer/module.hpp"
#include "../loop.hpp"
#include <vector>
#include <mutex>
 
namespace hi::inline v1 {
 
class os_settings {
public:
    using notifier_type = notifier<>;
    using callback_token = notifier_type::callback_token;
    using callback_proto = notifier_type::callback_proto;
 
    [[nodiscard]] static std::vector<language_tag> language_tags() noexcept
    {
        hi_axiom(_populated.load(std::memory_order::acquire));
        hilet lock = std::scoped_lock(_mutex);
        return _language_tags;
    }
 
    [[nodiscard]] static bool left_to_right() noexcept
    {
        hi_axiom(_populated.load(std::memory_order::acquire));
        return _left_to_right.load(std::memory_order::relaxed);
    }
 
    [[nodiscard]] static hi::theme_mode theme_mode() noexcept
    {
        hi_axiom(_populated.load(std::memory_order::acquire));
        return _theme_mode.load(std::memory_order::relaxed);
    }
 
    [[nodiscard]] static hi::subpixel_orientation subpixel_orientation() noexcept
    {
        hi_axiom(_populated.load(std::memory_order::acquire));
        return _subpixel_orientation.load(std::memory_order::relaxed);
    }
 
    [[nodiscard]] static bool uniform_HDR() noexcept
    {
        hi_axiom(_populated.load(std::memory_order::acquire));
        return _uniform_HDR.load(std::memory_order::relaxed);
    }
 
    [[nodiscard]] static std::chrono::milliseconds double_click_interval() noexcept
    {
        hi_axiom(_populated.load(std::memory_order::acquire));
        return _double_click_interval.load(std::memory_order::relaxed);
    }
 
    [[nodiscard]] static float double_click_distance() noexcept
    {
        hi_axiom(_populated.load(std::memory_order::acquire));
        return _double_click_distance.load(std::memory_order::relaxed);
    }
 
    [[nodiscard]] static std::chrono::milliseconds keyboard_repeat_delay() noexcept
    {
        hi_axiom(_populated.load(std::memory_order::acquire));
        return _keyboard_repeat_delay.load(std::memory_order::relaxed);
    }
 
    [[nodiscard]] static std::chrono::milliseconds keyboard_repeat_interval() noexcept
    {
        hi_axiom(_populated.load(std::memory_order::acquire));
        return _keyboard_repeat_interval.load(std::memory_order::relaxed);
    }
 
    [[nodiscard]] static std::chrono::milliseconds cursor_blink_delay() noexcept
    {
        hi_axiom(_populated.load(std::memory_order::acquire));
        return _cursor_blink_delay.load(std::memory_order::relaxed);
    }
 
    [[nodiscard]] static std::chrono::milliseconds cursor_blink_interval() noexcept
    {
        hi_axiom(_populated.load(std::memory_order::acquire));
        return _cursor_blink_interval.load(std::memory_order::relaxed);
    }
 
    [[nodiscard]] static float minimum_window_width() noexcept
    {
        hi_axiom(_populated.load(std::memory_order::acquire));
        return _minimum_window_width.load(std::memory_order::relaxed);
    }
 
    [[nodiscard]] static float minimum_window_height() noexcept
    {
        hi_axiom(_populated.load(std::memory_order::acquire));
        return _minimum_window_height.load(std::memory_order::relaxed);
    }
 
    [[nodiscard]] static float maximum_window_width() noexcept
    {
        hi_axiom(_populated.load(std::memory_order::acquire));
        return _maximum_window_width.load(std::memory_order::relaxed);
    }
 
    [[nodiscard]] static float maximum_window_height() noexcept
    {
        hi_axiom(_populated.load(std::memory_order::acquire));
        return _maximum_window_height.load(std::memory_order::relaxed);
    }
 
    [[nodiscard]] static aarectangle primary_monitor_rectangle() noexcept
    {
        hi_axiom(_populated.load(std::memory_order::acquire));
        hilet lock = std::scoped_lock(_mutex);
        return _primary_monitor_rectangle;
    }
 
    [[nodiscard]] static uintptr_t primary_monitor_id() noexcept
    {
        hi_axiom(_populated.load(std::memory_order::acquire));
        return _primary_monitor_id.load(std::memory_order::relaxed);
    }
 
    [[nodiscard]] static aarectangle desktop_rectangle() noexcept
    {
        hi_axiom(_populated.load(std::memory_order::acquire));
        hilet lock = std::scoped_lock(_mutex);
        return _desktop_rectangle;
    }
 
    [[nodiscard]] static hi::policy policy() noexcept
    {
        return policy::unspecified;
    }
 
    [[nodiscard]] static hi::policy gpu_policy() noexcept
    {
        hi_axiom(_populated.load(std::memory_order::acquire));
        return _gpu_policy.load(std::memory_order::relaxed);
    }
 
    [[nodiscard]] static std::vector<uuid> preferred_gpus(hi::policy performance_policy) noexcept;
 
    static void gather() noexcept;
 
    [[nodiscard]] static callback_token
    subscribe(forward_of<callback_proto> auto&& callback, callback_flags flags = callback_flags::synchronous) noexcept
    {
        hilet lock = std::scoped_lock(_mutex);
        return _notifier.subscribe(hi_forward(callback), flags);
    }
 
    static bool start_subsystem() noexcept
    {
        return hi::start_subsystem(_started, false, subsystem_init, subsystem_deinit);
    }
 
private:
    static constexpr std::chrono::duration gather_interval = std::chrono::seconds(5);
    static constexpr std::chrono::duration gather_minimum_interval = std::chrono::seconds(1);
 
    static inline std::atomic<bool> _started = false;
    static inline std::atomic<bool> _populated = false;
    static inline unfair_mutex _mutex;
    static inline loop::timer_callback_token _gather_cbt;
    static inline utc_nanoseconds _gather_last_time;
 
    static inline notifier_type _notifier;
 
    static inline std::vector<language_tag> _language_tags = {};
    static inline std::atomic<bool> _left_to_right = true;
    static inline std::atomic<hi::theme_mode> _theme_mode = theme_mode::dark;
    static inline std::atomic<bool> _uniform_HDR = false;
    static inline std::atomic<hi::subpixel_orientation> _subpixel_orientation = hi::subpixel_orientation::unknown;
    static inline std::atomic<std::chrono::milliseconds> _double_click_interval = std::chrono::milliseconds(500);
    static inline std::atomic<float> _double_click_distance = 4.0f;
    static inline std::atomic<std::chrono::milliseconds> _keyboard_repeat_delay = std::chrono::milliseconds(250);
    static inline std::atomic<std::chrono::milliseconds> _keyboard_repeat_interval = std::chrono::milliseconds(33);
    static inline std::atomic<std::chrono::milliseconds> _cursor_blink_interval = std::chrono::milliseconds(1000);
    static inline std::atomic<std::chrono::milliseconds> _cursor_blink_delay = std::chrono::milliseconds(1000);
    static inline std::atomic<float> _minimum_window_width = 40.0f;
    static inline std::atomic<float> _minimum_window_height = 25.0f;
    static inline std::atomic<float> _maximum_window_width = 1920.0f;
    static inline std::atomic<float> _maximum_window_height = 1080.0f;
    static inline std::atomic<uintptr_t> _primary_monitor_id = 0;
    static inline aarectangle _primary_monitor_rectangle = aarectangle{0.0f, 0.0f, 1920.0f, 1080.0f};
    static inline aarectangle _desktop_rectangle = aarectangle{0.0f, 0.0f, 1920.0f, 1080.0f};
    static inline std::atomic<hi::policy> _gpu_policy = policy::unspecified;
 
    [[nodiscard]] static bool subsystem_init() noexcept;
    static void subsystem_deinit() noexcept;
 
    [[nodiscard]] static std::vector<language_tag> gather_languages();
    [[nodiscard]] static hi::theme_mode gather_theme_mode();
    [[nodiscard]] static hi::subpixel_orientation gather_subpixel_orientation();
    [[nodiscard]] static bool gather_uniform_HDR();
    [[nodiscard]] static std::chrono::milliseconds gather_double_click_interval();
    [[nodiscard]] static float gather_double_click_distance();
    [[nodiscard]] static std::chrono::milliseconds gather_keyboard_repeat_delay();
    [[nodiscard]] static std::chrono::milliseconds gather_keyboard_repeat_interval();
    [[nodiscard]] static std::chrono::milliseconds gather_cursor_blink_interval();
    [[nodiscard]] static std::chrono::milliseconds gather_cursor_blink_delay();
    [[nodiscard]] static float gather_minimum_window_width();
    [[nodiscard]] static float gather_minimum_window_height();
    [[nodiscard]] static float gather_maximum_window_width();
    [[nodiscard]] static float gather_maximum_window_height();
    [[nodiscard]] static uintptr_t gather_primary_monitor_id();
    [[nodiscard]] static aarectangle gather_primary_monitor_rectangle();
    [[nodiscard]] static aarectangle gather_desktop_rectangle();
    [[nodiscard]] static hi::policy gather_gpu_policy();
};
 
} // namespace hi::inline v1