[ref][update] theme flags and refactored extentinze, remains docknize

Author: mrsrina

include/ekg/io/design.hpp

@@ -0,0 +1,47 @@
+#ifndef EKG_IO_DESIGN_HPP
+#define EKG_IO_DESIGN_HPP
+
+#include "ekg/ui/button/button.hpp"
+#include "ekg/ui/checkbox/checkbox.hpp"
+#include "ekg/ui/combobox/combobox.hpp"
+#include "ekg/ui/frame/frame.hpp"
+#include "ekg/ui/label/label.hpp"
+#include "ekg/ui/listbox/listbox.hpp"
+#include "ekg/ui/menu/menu.hpp"
+#include "ekg/ui/popup/popup.hpp"
+#include "ekg/ui/scrollbar/scrollbar.hpp"
+#include "ekg/ui/slider/slider.hpp"
+#include "ekg/ui/textbox/textbox.hpp"
+
+namespace ekg {
+  struct theme_t {
+  public:
+    std::string_view name {};
+    std::string_view author {};
+    std::string_view description {};
+    std::string_view path {};
+  public:
+    bool symmetric_layout {};
+    float min_widget_size {5};
+    float layout_offset {2.0f};
+
+    ekg::button_theme_t button {};
+    ekg::checkbox_theme_t checkbox {};
+    ekg::combobox_theme_t combobox {};
+    ekg::frame_theme_t frame {};
+    ekg::label_theme_t label {};
+    ekg::listbox_theme_t listbox {};
+    ekg::menu_theme_t menu {};
+    ekg::popup_theme_t popup {};
+    ekg::scrollbar_theme_t scrollbar {};
+    ekg::slider_theme_t slider {};
+    ekg::textbox_theme_t textbox {};
+  };
+
+  std::map<std::string_view, ekg::theme_t> &themes();
+  ekg::theme_t &theme(std::string_view name = "");
+  ekg::theme_t &theme(ekg::theme_t theme);
+  ekg::theme_t &set_current_theme(std::string_view name);
+}
+
+#endif

include/ekg/io/memory.hpp

@@ -37,7 +37,7 @@ namespace ekg {
   enum result {
     success           = 2 << 1,
     failed            = 2 << 2,
-    widget_not_found  = 2 << 3,
+    could_not_find    = 2 << 3,
     not_implemented   = 2 << 4
   };
 
@@ -74,7 +74,7 @@ namespace ekg {
     t &get_value() {
       return (
         this->p_address
-        ? 
+        ?
         /**
          *
          * idk idc i want

include/ekg/io/safety.hpp

@@ -60,6 +60,27 @@ namespace ekg::io {
     };
 
     switch (descriptor.type) {
+      case ekg::type::button: {
+        ekg::button_t &button {
+          ekg::io::any_static_cast<ekg::button_t>(
+            descriptor
+          )
+        };
+
+        ekg::ui::button *p_button {
+          ekg::io::new_widget_instance<ekg::ui::button>()
+        };
+
+        p_button->descriptor = button;
+        p_created_widget = p_button;
+
+        properties.descriptor = &p_button->descriptor;
+        properties.p_widget = &p_button;
+        properties.dock = button.dock; // i mean im dumb idk
+
+        break;
+      }
+
       case ekg::type::frame: {
         ekg::frame_t &frame {
           ekg::io::any_static_cast<ekg::frame_t>(
@@ -72,10 +93,12 @@ namespace ekg::io {
         };
 
         p_frame->descriptor = frame;
+        p_created_widget = p_frame;
+
         properties.descriptor = &p_frame->descriptor;
         properties.p_widget = &p_frame;
+        properties.dock = frame.dock;
 
-        p_created_widget = p_frame;
         break;
       }
     }

include/ekg/layout/docknize.hpp

@@ -1,66 +1,87 @@
 #ifndef EKG_LAYOUT_DOCKNIZE_H
 #define EKG_LAYOUT_DOCKNIZE_H
 
-#include "ekg/ui/abstract/ui_abstract_widget.hpp"
-#include "ekg/util/geometry.hpp"
+#include "ekg/ui/abstract.hpp"
+#include "ekg/math/geometry.hpp"
+#include "ekg/io/layout.hpp"
 
-/**
- * Returns the dimensional extent based in count and the offset (space between rects). 
- * 
- * The pixel imperfect issue was solved here...
- * For a long time I did not know what was going on with the pixels,
- * some solutions I used did not work, then I discovered that all the time
- * was this dimension extent with float imprecision loss.
- * 
- * Each pixels represent 1.0f, if the GPU receives pixels with
- * (n + f) `n` a non-floating point number and `f` a floating point;
- * the rasterizer will jump between pixels, resulting in pixel-imperfect.
- * 
- * The following formula make you understand:
- * ( (g - d) - (c * o) ) / c
- * 
- * g = group rect
- * d = dimensional extent
- * c = amount of widgets with fill property flag until any flag next
- * o = UI offset setting
- * 
- * Float-only without the int32_t cast may results in pixel-imperfect
- * due the influence of dimensional size of parent rect, font height, font width etc.
- * 
- * - Rina.
- **/
-#define ekg_layout_get_dimensional_extent(dimension, extent, offset, count) \
-( \
-  (static_cast<int32_t>(dimension) - static_cast<int32_t>(extent) - static_cast<int32_t>(count * offset)) \
-) / static_cast<int32_t>(count) \
+namespace ekg::layout {
+  /**
+   * Returns the dimensional extent based in count and the offset (space between rects). 
+   * 
+   * The pixel imperfect issue was solved here...
+   * For a long time I did not know what was going on with the pixels,
+   * some solutions I used did not work, then I discovered that all the time
+   * was this dimension extent with float imprecision loss.
+   * 
+   * Each pixels represent 1.0f, if the GPU receives pixels with
+   * (n + f) `n` a non-floating point number and `f` a floating point;
+   * the rasterizer will jump between pixels, resulting in pixel-imperfect.
+   * 
+   * The following formula make you understand:
+   * ( (g - d) - (c * o) ) / c
+   * 
+   * g = group rect
+   * d = dimensional extent
+   * c = amount of widgets with fill property flag until any flag next
+   * o = UI offset setting
+   * 
+   * Float-only without the int32_t cast may results in pixel-imperfect
+   * due the influence of dimensional size of parent rect, font height, font width etc.
+   * 
+   * - Rina.
+   **/
+  constexpr float transform_dimension_from_extent(
+    float dimension,
+    float extent,
+    float offset,
+    int32_t count
+  ) {
+    return static_cast<float>(
+      (
+        static_cast<int32_t>(dimension)
+        -
+        static_cast<int32_t>(extent)
+        -
+        static_cast<int32_t>(count * offset)
+      )
+      /
+      count
+    );
+  }
 
-/**
- * Pixel imperfection is a problem for UI widget placements, this macro provides
- * correction position for right/bottom based on left/top position.
- * 
- * It is important to understand that is impossible to remove all the pixel
- * imperfections, but there are ways to round it, as example, you can place widget
- * from a side (left or right, top or bottom) and align with an offset. That is how EKG fix it.
- * 
- * This method calculate the minimum possible position based on left until the pixel
- * escape for two or more offsets distance. Instead you use the container width directly
- * to calculate right widgets positions, EKG must use the left consistency to get the
- * real container (width/height) from the side of left (when using the container width directly
- * the position is pixel imperfect).
- * 
- * - Rina.
- **/
-#define ekg_layout_get_pixel_perfect_position(side_a, side_b, container_dimension, offset) \
-  ekg_min( \
-    ( \
-      (side_a + (container_dimension - side_a) + offset) \
-      - \
-      side_b \
-    ), \
-    side_a \
-  ) \
+  /**
+   * Pixel imperfection is a problem for UI widget placements, this macro provides
+   * correction position for right/bottom based on left/top position.
+   * 
+   * It is important to understand that is impossible to remove all the pixel
+   * imperfections, but there are ways to round it, as example, you can place widget
+   * from a side (left or right, top or bottom) and align with an offset. That is how EKG fix it.
+   * 
+   * This method calculate the minimum possible position based on left until the pixel
+   * escape for two or more offsets distance. Instead you use the container width directly
+   * to calculate right widgets positions, EKG must use the left consistency to get the
+   * real container (width/height) from the side of left (when using the container width directly
+   * the position is pixel imperfect).
+   * 
+   * - Rina.
+   **/
+  constexpr float transform_to_pixel_perfect_position(
+    float side_a,
+    float side_b,
+    float container_dimension,
+    float offset
+  ) {
+    return ekg::min_clamp(
+      (
+        (side_a + (container_dimension - side_a) + offset)
+        -
+        (side_b)
+      ),
+      side_a
+    );
+  }
 
-namespace ekg::layout {
   class mask {
   protected:
     std::vector<ekg::rect_descriptor_t> rect_descriptor_list {};
@@ -88,8 +109,8 @@ namespace ekg::layout {
    * A mid-functional feature to process dock position from widgets.
    * Note: Recursive.
    **/
-  void docknize(
-    ekg::ui::abstract_widget *p_parent_widget
+  void docknize_widget(
+    ekg::ui::abstract *p_parent_widget
   );
 }
 

include/ekg/layout/extentnize.hpp

@@ -1,6 +1,8 @@
 #ifndef EKG_LAYOUT_EXTENTNIZE_HPP
 #define EKG_LAYOUT_EXTENTNIZE_HPP
 
+#include "ekg/ui/abstract.hpp"
+
 namespace ekg::layout {
   struct fill_align_t {
   public:
@@ -21,35 +23,63 @@ namespace ekg::layout {
     static ekg::layout::extent_t v_rect_descriptor;
     static ekg::layout::extent_t h_rect_descriptor;
   public:
-    int64_t end_index {};
-    int64_t begin_index {};
-    int64_t count {};
+    int32_t end_index {};
+    int32_t begin_index {};
+    int32_t count {};
     float extent {};
   };
 
   /**
-   * Obtain the remain extent size, from the latest rect descriptor list index.
+   * The extentize is a method to calculate split (between all elements with `ekg::dock::fill` flag)
+   * data from a container dimension, extent is the amount of non `ekg::dock::fill` calculated dimension.
+   * 
+   * Both functions `extentnize_*` works almost equals, but with
+   * difference of specialization-level, rect descriptors are a
+   * compact way to calculate extent, while widgets works with some additional
+   * variables. For performance reasons EKG does not want to make generic
+   * this way, but soon maybe we can change it.
+   *
+   * ---
+   *  
+   * How it works: 
+   * 
+   * The last index does not check if contains a next flag,
+   * so it is needed to brute-check to stop at end of index. 
+   *
+   * The extent data store the previous bounding indices,
+   * in simply words, prevent useless iteration.
+   *
+   * The min offset is added for extent, because we need count
+   * the offset position when split the dimension width, but the
+   * last extent space is not necessary, so we need to subtract.
+   **/
+
+  /**
+   * Obtain the remain extent size, from the latest rect descriptor index `in`
+   * and return the new count `out`.
    **/
   void extentnize_rect_descriptor(
     std::vector<ekg::rect_descriptor_t> &rect_descriptor_list,
+    ekg::flags_t flag_ok,
+    ekg::flags_t flag_stop,
+    ekg::flags_t flag_axis,
+    ekg::layout::fill_align_t &fill_align,
     float &extent,
-    ekg::flags flag_ok,
-    ekg::flags flag_stop,
-    int64_t &begin_and_count,
-    ekg::axis axis
+    int32_t &in_out_count
   );
 
   /**
-   * Obtain the remain extent size, from the latest widget index.
+   * Obtain the remain extent size, from the latest widget index `in`
+   * and return the new count `out`.
    **/
   void extentnize_widget(
-    ekg::ui::abstract_widget *p_widget,
+    ekg::ui::abstract *p_widget,
+    ekg::flags_t flag_ok,
+    ekg::flags_t flag_stop,
+    ekg::flags_t flag_axis,
+    ekg::layout::fill_align_t &fill_align,
     float &extent,
-    fill_align_t *p_fill_align,
-    ekg::flags flag_ok,
-    ekg::flags flag_stop,
-    int64_t &begin_and_count,
-    ekg::axis axis
+    int32_t &in_out_count
   );
 }
 

include/ekg/math/geometry.hpp

@@ -1,7 +1,29 @@
 #ifndef EKG_MATH_GEOMETRY_HPP
 #define EKG_MATH_GEOMETRY_HPP
 
+#include <cstdint>
+
 namespace ekg {
+  enum dock {
+    none   = 2 << 1,
+    free   = 2 << 2,
+    top    = 2 << 3,
+    bottom = 2 << 4,
+    right  = 2 << 5,
+    left   = 2 << 6,
+    center = 2 << 7,
+    full   = 2 << 8,
+    next   = 2 << 9,
+    fill   = 2 << 10,
+    resize = 2 << 11,
+    bind   = 2 << 12
+  };
+
+  enum axis {
+    vertical   = 2 << 13,
+    horizontal = 2 << 14
+  };
+
   template<typename t>
   struct vec2_t {
     union {
@@ -134,4 +156,4 @@ namespace ekg {
   );
 }
 
-#endif
+#endif