refactored cth::win keyboard support and added ability to listen to keypresses

Author: Lukas Thomann

cth/incl/cth/io/keybd/keys.hpp

@@ -6,6 +6,7 @@
 #include "cth/os/osdef.hpp"
 #include "cth/string/format.hpp"
 
+#include <chrono>
 
 namespace cth::io {
 /**
@@ -261,24 +262,63 @@ cxpr std::string_view to_utf8_string(Key key) {
 
 CTH_GEN_ENUM_DEREF_OVERLOAD(cth::io::Key)
 
+CTH_FORMAT_CLASS_ATTRIBUTES(
+    cth::io::Key,
+    "{}",
+    ([](cth::io::Key const& key) { return cth::io::to_utf8_string(key); })
+);
+
 namespace cth::io {
 
 struct ex_key {
     Key key;
     bool right = false;
+
+    [[nodiscard]] constexpr bool operator==(ex_key const&) const = default;
 };
 
 struct key_state {
-    key_state(ex_key ex_key, bool down) : exKey{ex_key}, down{down} {}
-    key_state(Key key, bool right, bool down) : key_state{{key, right}, down} {}
+    constexpr key_state(ex_key ex_key, bool down) : exKey{ex_key}, down{down} {}
+    constexpr key_state(Key key, bool right, bool down) : key_state{{key, right}, down} {}
 
     ex_key exKey;
     bool down;
+
+    [[nodiscard]] constexpr bool operator==(key_state const&) const = default;
 };
 
 struct key_update {
     key_state data;
-    co::time_point_t time;
+    chrono::time_point_t time;
+
+    [[nodiscard]] constexpr bool operator==(key_update const&) const = default;
 };
 
 }
+
+CTH_FORMAT_CLASS_ATTRIBUTES(
+    cth::io::ex_key,
+    "{}, right: {}",
+    ([](cth::io::ex_key const& key) { return std::tie(key.key, key.right); })
+);
+
+
+CTH_FORMAT_CLASS_ATTRIBUTES(
+    cth::io::key_state,
+    "{}, down: {}",
+    ([](cth::io::key_state const& key){ return std::tie(key.exKey, key.down); })
+);
+
+
+CTH_FORMAT_CLASS_ATTRIBUTES(
+    cth::io::key_update,
+    "{}, time: {}",
+    (
+        [](cth::io::key_update const& update){
+        return std::forward_as_tuple(
+            update.data,
+            std::chrono::duration_cast<std::chrono::seconds>(update.time - cth::chrono::session_start)
+        );
+        }
+    )
+);

cth/incl/cth/string/format.hpp

@@ -54,6 +54,14 @@ struct std::formatter<type> {
     }                                                                                               \
 }
 
+/**
+ * creates a format overload for a class, implicitly includes type name with type[<fmt_string>]
+ * @param type The class/struct type to format
+ * @param fmt_string The format string (e.g., "ID: {}, Val: {}")
+ * @param tie_func An expression involving 'obj' that returns a tuple/tie
+ */
+#define CTH_FORMAT_CLASS_ATTRIBUTES(type, fmt_string, tie_func)\
+    CTH_FORMAT_CLASS(type, #type "[" fmt_string "]", tie_func)
 
 /**
  * @brief creates a format overload for the concept

cth_win/CMakeLists.txt

@@ -9,6 +9,7 @@ cth_target_enable_build_cache(cth_win OPTIONAL)
 cth_pkg_target_include_directories(
         cth_win
         PUBLIC incl
+        PRIVATE src
 )
 
 target_link_libraries(cth_win PUBLIC cth::cth)

cth_win/incl/cth/win/io/keyboard.hpp

@@ -1,14 +1,64 @@
 #pragma once
 #include "cth/io/keybd/keys.hpp"
 
+#include <mutex>
+#include <queue>
 #include <span>
+#include <vector>
 
 
-namespace cth::win {
-class keybd {
+namespace cth::win::keybd {
+
+void send(::cth::io::key_state);
+void send(std::span<::cth::io::key_state const> states);
+
+
+struct event_queue {
+    using event_t = ::cth::io::key_update;
+
+    event_queue();
+    event_queue(event_queue const&) = delete;
+    event_queue(event_queue&&) = delete;
+    ~event_queue();
+
+    /**
+     * peeks the queues front
+     */
+    [[nodiscard]] event_t front() const;
+    /**
+     * pops the queues front
+     */
+    [[nodiscard]] event_t pop();
+    /**
+     * pops the entire queue
+     */
+    [[nodiscard]] std::vector<event_t> pop_queue();
+
+    /**
+     * flushes the queue
+     */
+    void clear();
+
+    /**
+     * pushes onto the queue
+     * @param event to push
+     */
+    void push(event_t event);
+
+private:
+    std::queue<event_t> _queue{};
+    mutable std::mutex _queueMtx{};
+
 public:
-    static void send(io::key_state);
-    static void send(std::span<io::key_state const> states);
+    /**
+     * size of current buffer queue
+     */
+    [[nodiscard]] size_t size() const { return _queue.size(); }
+    
+    /**
+     * true if empty
+     */
+    [[nodiscard]] bool empty() const;
 };
 
-}
+} // namespace cth::win::io