hotfix :)

CMakeLists.txt

@@ -1,8 +1,14 @@
-cmake_minimum_required(VERSION 3.26)
+cmake_minimum_required(VERSION 3.27)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 project(cyd_ui)
 
 set(CMAKE_CXX_STANDARD 23)
+#set(CMAKE_CXX_SCAN_FOR_MODULES YES)
+#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fmodules-ts")
+
+SET(TEST_DIR ${CMAKE_CURRENT_LIST_DIR}/test)
+SET(INCLUDE_DIR ${CMAKE_CURRENT_LIST_DIR}/include)
+SET(SOURCE_DIR ${CMAKE_CURRENT_LIST_DIR}/src)
 
 include(CheckCXXCompilerFlag)
 
@@ -52,7 +58,7 @@ compiler_flags(
 )
 
 
-include_directories(${CMAKE_CURRENT_LIST_DIR}/include)
+include_directories(${INCLUDE_DIR})
 include_directories(/usr/include/freetype2)
 
 find_package(PkgConfig REQUIRED)
@@ -61,12 +67,12 @@ include_directories(${CAIROMM-1.16_INCLUDE_DIRS})
 
 
 FILE(GLOB_RECURSE SRC_LIST
-        ${CMAKE_CURRENT_LIST_DIR}/include/*.h
-        ${CMAKE_CURRENT_LIST_DIR}/include/*.hpp
-        ${CMAKE_CURRENT_LIST_DIR}/include/*.cpp
-        ${CMAKE_CURRENT_LIST_DIR}/src/*.h
-        ${CMAKE_CURRENT_LIST_DIR}/src/*.hpp
-        ${CMAKE_CURRENT_LIST_DIR}/src/*.cpp
+        ${INCLUDE_DIR}/*.h
+        ${INCLUDE_DIR}/*.hpp
+        ${INCLUDE_DIR}/*.cpp
+        ${SOURCE_DIR}/*.h
+        ${SOURCE_DIR}/*.hpp
+        ${SOURCE_DIR}/*.cpp
 )
 
 add_library(cyd_ui)
@@ -82,10 +88,22 @@ target_link_libraries(cyd_ui
 
 # Build Tests
 FILE(GLOB_RECURSE TEST_LIST
-        ${CMAKE_CURRENT_LIST_DIR}/test/*.*
+        ${TEST_DIR}/*.h
+        ${TEST_DIR}/*.hpp
+        ${TEST_DIR}/*.cpp
+        #        ${TEST_DIR}/**/*.*
 )
+#FILE(GLOB_RECURSE TEST_MOD_LIST
+#        ${TEST_DIR}/*.cppm
+#        ${TEST_DIR}/**/*.*
+#)
 add_executable(cyd_ui_test ${TEST_LIST})
-target_link_libraries(cyd_ui_test PRIVATE cyd_ui)
+#target_sources(cyd_ui_test
+#        PRIVATE FILE_SET CXX_MODULES FILES ${TEST_MOD_LIST})
+target_include_directories(cyd_ui_test PRIVATE ${TEST_DIR})
+target_link_libraries(cyd_ui_test
+        PRIVATE cyd_ui
+        sensors)
 
 # Build Doxygen Documentation
 add_custom_target(
@@ -107,7 +125,7 @@ if (CMAKE_BUILD_TYPE MATCHES "Release")
     add_custom_command(TARGET cyd_ui POST_BUILD
             COMMAND /usr/bin/cp
             -rv
-            ${CMAKE_CURRENT_LIST_DIR}/include
+            ${INCLUDE_DIR}
             ${CMAKE_CURRENT_LIST_DIR}/dist/
             WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
             COMMENT "Copying header files..."

dist/include/core/component.h

@@ -28,6 +28,11 @@ namespace cydui::components {
       std::optional<component_state_t*> parent = std::nullopt;
       std::unordered_map<std::string, component_state_t*> children_states {};
 
+      component_state_t() = default;
+      component_state_t(void* props) {
+
+      }
+
       bool _dirty = false;
 
       bool focused = false;
@@ -90,6 +95,7 @@ namespace cydui::components {
       virtual void subscribe_events() = 0;
       virtual void clear_children() = 0;
       virtual attrs_component<>* attrs() = 0;
+      virtual void* get_props() = 0;
       virtual std::string name() = 0;
 
       virtual event_handler_t* event_handler() = 0;
@@ -152,7 +158,7 @@ namespace cydui::components {
           evh->parent = nullptr;
         }
         evh->state = (typename T::state_t*) state.value();
-        evh->props = &(((T*) this)->props);
+        evh->props = &(static_cast<T*>(this)->props);
         evh->attrs = (attrs_component<T>*) this;
         evh->get_dim = [this] {return get_dimensional_relations();};
         evh->$children = [this] {return children;};
@@ -173,18 +179,19 @@ namespace cydui::components {
         // `(attrs_component<>*)` does not work since that type is not a base of this
         // class. So we need to cast to the base class first and then to its `void`
         // specialization.
-        return (attrs_component<>*) (attrs_component<T>*) this;
+        return (attrs_component<>*) static_cast<attrs_component<T>*>(this);
       }
 
-
       component_state_t* create_state_instance() override {
-        return new typename T::state_t;
+        return new typename T::state_t((typename T::props_t*) get_props());
       }
       event_handler_t* event_handler() override {
         return event_handler_;
       }
 
       void redraw(cydui::layout::Layout* layout) override {
+        state.value()->_dirty = false;
+
         std::vector<component_holder_t> content_children = this->_content();
         std::string content_id_prefix = "content:";
         std::size_t id_i = 0;
@@ -350,8 +357,13 @@ namespace cydui::components {
 
 }
 
-template<typename C>
-struct component_state_template: public cydui::components::component_state_t { };
+template<typename, typename = void>
+constexpr bool is_type_complete_v = false;
+
+template<typename T>
+constexpr bool is_type_complete_v
+  <T, std::void_t<decltype(sizeof(T))>> = true;
+
 
 //#include "../graphics/vg.h"
 //

dist/include/core/component_event_handler.h

@@ -150,7 +150,7 @@ namespace cydui::components {
           parent->on_key_release(ev);
       }
       // * set text input context (a type that accepts text events like insert, backspace and such)
-      TODO("Implement a method to set an input context for text input")
+      //TODO - Implement a method to set an input context for text input
 
       struct listener_data_t {
         std::function<void(cydui::events::Event*)> handler {};
@@ -173,7 +173,7 @@ namespace cydui::components {
 #define ON_SCROLL           CYDUI_INTERNAL_EV_HANDLER_IMPL(scroll)
 #define ON_KEY_PRESS        CYDUI_INTERNAL_EV_HANDLER_IMPL(key_press)
 #define ON_KEY_RELEASE      CYDUI_INTERNAL_EV_HANDLER_IMPL(key_release)
-    TODO("Implement a method to set an input context for text input")
+    // TODO - Implement a method to set an input context for text input
 
 #pragma clang diagnostic pop
 

dist/include/core/component_macros.h

@@ -20,35 +20,40 @@
 
 // ? Macros for declaring component classes
 // ?>
-#define STATE(NAME) \
-struct NAME;        \
-template<typename T>\
-struct component_state_template; \
-template<>          \
-struct component_state_template<NAME>: public cydui::components::component_state_t
+
+//#define STATE(NAME) \
+//struct CYDUI_STATE_NAME(NAME): public cydui::components::component_state_t
+
+#define STATE ; struct init: public cydui::components::component_state_t
 
 // ?>
 #define COMPONENT(NAME, ...) \
 struct NAME;                 \
-using CYDUI_STATE_NAME(NAME) = component_state_template<NAME>; \
 struct CYDUI_EV_HANDLER_NAME(NAME); \
 struct NAME:                 \
   public cydui::components::component_t<CYDUI_EV_HANDLER_NAME(NAME),NAME> \
   {                          \
     CYDUI_COMPONENT_METADATA(NAME)  \
-    using state_t = CYDUI_STATE_NAME(NAME);                   \
-    using event_handler_t = CYDUI_EV_HANDLER_NAME(NAME);      \
+    using event_handler_t = CYDUI_EV_HANDLER_NAME(NAME);                  \
+    struct init;             \
     struct props_t           \
       __VA_ARGS__;           \
     props_t props;           \
+    using state_t =          \
+      std::conditional<is_type_complete_v<struct init>  \
+        , init    \
+        , cydui::components::component_state_t>::type;                    \
     NAME() = default;        \
     explicit NAME(props_t props)    \
       : cydui::components::component_t<CYDUI_EV_HANDLER_NAME(NAME),NAME>()\
       , props(std::move(props)) { } \
     ~NAME() override = default;     \
+    void* get_props() override {    \
+      return (void*)&(this->props); \
+    }                        \
   };                         \
 struct CYDUI_EV_HANDLER_DATA_NAME(NAME) {                     \
-  CYDUI_STATE_NAME(NAME)* state = nullptr;                    \
+  NAME::state_t* state = nullptr;                    \
   NAME::props_t* props = nullptr;   \
   attrs_component<NAME>* attrs = nullptr;                     \
   logging::logger log{.name = #NAME};                         \
@@ -90,6 +95,9 @@ struct NAME:                          \
       >()                             \
       , props(std::move(props)) { }   \
     ~NAME() override = default;       \
+    void* get_props() override {      \
+      return (void*)&(this->props);   \
+    }                                 \
 };                                    \
 template SET_COMPONENT_TEMPLATE_DEFAULT \
 struct CYDUI_EV_HANDLER_DATA_NAME(NAME) {                     \

dist/include/core/component_types.h

@@ -27,7 +27,7 @@ namespace cydui::components {
 
     template<typename C>
     concept ComponentConcept = requires(C c) {
-      std::derived_from<C, component_t<typename C::event_handler_t, C>>;
+      requires std::derived_from<C, component_t<typename C::event_handler_t, C>>;
       typename C::props_t;
       typename C::state_t;
       typename C::event_handler_t;

dist/include/core/with_specialization.h

@@ -38,11 +38,11 @@ namespace cydui::components::with {
         }
         return *this;
       }
-#define then(...) \
-  _Pragma("clang diagnostic push") \
-  _Pragma("clang diagnostic ignored \"-Wunused-lambda-capture\"") \
-  then([this]{ return std::vector<component_holder_t> __VA_ARGS__ ; }) \
-  _Pragma("clang diagnostic pop")
+//#define then(...) \
+//  _Pragma("clang diagnostic push") \
+//  _Pragma("clang diagnostic ignored \"-Wunused-lambda-capture\"") \
+//  then([this]{ return std::vector<cydui::components::component_holder_t> __VA_ARGS__ ; }) \
+//  _Pragma("clang diagnostic pop")
 
       with<bool> &or_else(std::function<std::vector<component_holder_t>()> components) {
         if (!val) {

dist/include/stdui.h

@@ -27,11 +27,21 @@ auto &PROP(typeof(props_t::PROP)&& _##PROP) {\
           };
 
           struct props_t {
-            Direction dir;
+            Direction dir = Direction::HORIZONTAL;
             cydui::dimensions::dimensional_relation_t spacing = 0;
           };
           ATTR(dir)
           ATTR(spacing)
+
+          auto &horizontal() {
+            props.dir = Direction::HORIZONTAL;
+            return *this;
+          }
+          auto &vertical() {
+            props.dir = Direction::VERTICAL;
+            return *this;
+          }
+
         ) {
 
           void horizontal_fixed_width() {
@@ -151,16 +161,15 @@ auto &PROP(typeof(props_t::PROP)&& _##PROP) {\
           }
         };
 
-        STATE(Grid) {
-          std::unordered_map<cydui::components::component_base_t*, std::pair<int, int>> positions {};
-          std::unordered_map<cydui::components::component_base_t*, std::pair<int, int>> sizes {};
-        };
         COMPONENT(Grid, {
           unsigned int rows;
           unsigned int cols;
           int x_gap = 0;
           int y_gap = 0;
-        }; ATTR(rows) ATTR(cols) ATTR(x_gap) ATTR(y_gap)) {
+        }; ATTR(rows) ATTR(cols) ATTR(x_gap) ATTR(y_gap) STATE {
+          std::unordered_map<cydui::components::component_base_t*, std::pair<int, int>> positions { };
+          std::unordered_map<cydui::components::component_base_t*, std::pair<int, int>> sizes { };
+        }) {
           ON_REDRAW {
             state->positions.clear();
             state->sizes.clear();
@@ -226,4 +235,4 @@ auto &PROP(typeof(props_t::PROP)&& _##PROP) {\
     using namespace layout;
 }
 
-#endif //CYD_UI_STDUI_H
+#endif //CYD_UI_STDUI_H