hokusai-zero 0.2.5 → 0.2.6.pre.pinephone

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 258655d3f20b0989fc428b59e1346fcce0cf2d3171cbd84734f76ab466147c41
-  data.tar.gz: dba94b3629f93488d2629440aa70e3f8e60e005814ba3a189c26cac1cb213698
+  metadata.gz: ff2e748026518a381a084842d38e6499cbc21ba6ae82ef8eecea9fcf1caac01d
+  data.tar.gz: b6f6552079320c6345dc2332c1876e4ad4640ae91edd1b80b5886cbb7e5a2a81
 SHA512:
-  metadata.gz: 05404fcf63164d6201d7ec3061ff2076a31dd3b2a8061940587aa099e84632afa07621fbbe9a79ac978ca374a22f72e2408d277db22b34c0076f0bffd3bcda4f
-  data.tar.gz: c074724a12bf76772f9052fccbf06cbd49ff55e871d763c2477bc2a242650a74deaee9a5c3c67dedaae9058b89eefb3b94399ce1daf5d3eeb45c5098a8b3958b
+  metadata.gz: b4d95dbfd485c9948af925f0d824383198a8676fa87714c1b8937b1c34c22bd0f384c86774a67e44e1e941fcfcad745e7576d287edc23f064022369d5187fad2
+  data.tar.gz: 73f8f5e98862ff3c219a61f570298e634a3d4293d619b6c79b557a5f499da96992366eb0f5ecf1f7adc7998f98d83ae54a878ee3445c527d262045cd41305038

data/Gemfile

@@ -3,7 +3,6 @@ source "https://www.rubygems.org"
 gem "ffi", github: "ffi/ffi", submodules: true
 
 group :development, :test do
-  gem "concurrent-ruby", require: "concurrent"
   gem "memory_profiler", require: false
   gem "mini_portile2", "~> 2.0.0" 
   gem "raylib-bindings"

data/Gemfile.lock

@@ -8,7 +8,6 @@ GIT
 GEM
   remote: https://www.rubygems.org/
   specs:
-    concurrent-ruby (1.3.5)
     daemons (1.4.1)
     diff-lcs (1.6.1)
     domain_name (0.6.20240107)
@@ -77,7 +76,6 @@ PLATFORMS
   x86_64-linux
 
 DEPENDENCIES
-  concurrent-ruby
   ffi!
   memory_profiler
   mini_portile2 (~> 2.0.0)

data/README.md

@@ -12,7 +12,7 @@ A Ruby library for authoring GUI applications
 In your Gemfile
 
 ```ruby
-gem "hokusai-zero",  "0.2.4"
+gem "hokusai-zero",  "0.2.6"
 ```
 
 ## In order to run an application, you will need to install a backend

data/ast/src/core/input.c

@@ -4,6 +4,84 @@
 #include "input.h"
 #include <stdio.h>
 
+int hoku_input_embedded_init(hoku_input_embedded** embedded)
+{
+  hoku_input_embedded* out = malloc(sizeof(hoku_input_embedded));
+  if (!out) return -1;
+
+  out->drag_pos = malloc(sizeof(hoku_vec2));
+  if (out->drag_pos == NULL) 
+  {
+    free(out);
+    return -1;
+  }
+
+  out->pinch_pos = malloc(sizeof(hoku_vec2));
+  if (out->pinch_pos == NULL)
+  {
+    free(out->drag_pos);
+    free(out);
+    return -1;
+  }
+
+  out->drag_pos->x = 0.0;
+  out->drag_pos->y = 0.0;
+  out->pinch_pos->x = 0.0;
+  out->pinch_pos->y = 0.0;
+  out->hold = false;
+  out->drag = false;
+  out->pinch = false;
+  out->drag_direction = HOKU_DRAG_UP;
+  out->pinch_direction = HOKU_PINCH_IN;
+  out->hold_duration = 0;
+  out->drag_angle = 0.0;
+  out->pinch_angle = 0.0;
+
+  *embedded = out;
+  return 0;
+}
+
+void hoku_input_embedded_set_hold(hoku_input* input, bool hold, int hold_duration)
+{
+  input->embedded->hold = hold;
+  input->embedded->hold_duration = hold_duration;
+}
+
+void hoku_input_embedded_set_drag(hoku_input* input, bool drag, hoku_drag_direction drag_direction, float drag_x, float drag_y, float drag_angle)
+{
+  input->embedded->drag = drag;
+  input->embedded->drag_direction = drag_direction;
+  input->embedded->drag_pos->x = drag_x;
+  input->embedded->drag_pos->y = drag_y;
+  input->embedded->drag_angle = drag_angle;
+}
+
+void hoku_input_embedded_set_pinch(hoku_input* input, bool pinch, hoku_pinch_direction pinch_direction, float pinch_x, float pinch_y, float pinch_angle)
+{
+  input->embedded->pinch = pinch;
+  input->embedded->pinch_direction = pinch_direction;
+  input->embedded->pinch_pos->x = pinch_x;
+  input->embedded->pinch_pos->y = pinch_y;
+  input->embedded->pinch_angle = pinch_angle;
+}
+
+int hoku_input_attach_embedded(hoku_input* input)
+{
+  hoku_input_embedded* embedded;
+  if (hoku_input_embedded_init(&embedded) == -1) return -1;
+  input->embedded = embedded;
+
+  return 0;
+}
+
+void hoku_input_embedded_free(hoku_input_embedded* embedded)
+{
+  free(embedded->drag_pos);
+  free(embedded->pinch_pos);
+  free(embedded);
+}
+
+
 static int hoku_keycodes[HOKU_KEY_MAX] = { 
   0,39,44,45,46,47,48,49,50,51,52,53,54,55,56,57,59,61,65,66,67,68,69,
   70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,
@@ -273,6 +351,12 @@ void hoku_input_free(hoku_input* input)
 {
   hoku_input_keyboard_free(input->keyboard);
   hoku_input_mouse_free(input->mouse);
+  
+  if (input->embedded)
+  {
+    hoku_input_embedded_free(input->embedded);
+  }
+
   free(input);
 }
 
@@ -298,6 +382,7 @@ int hoku_input_init(hoku_input** input)
     return -1;
   }
   init->keyboard = keyboard;
+  init->embedded = NULL;
 
   *input = init;
   return 0;

data/ast/src/core/input.h

@@ -87,12 +87,43 @@ typedef struct HmlInputKeyboard
   bool collecting;
 } hoku_input_keyboard;
 
+typedef enum HmlDragDirection {
+  HOKU_DRAG_UP,
+  HOKU_DRAG_DOWN,
+  HOKU_DRAG_LEFT,
+  HOKU_DRAG_RIGHT
+} hoku_drag_direction;
+
+typedef enum HmlPinchDirection {
+  HOKU_PINCH_IN,
+  HOKU_PINCH_OUT
+} hoku_pinch_direction;
+
+typedef struct HmlInputEmbedded
+{
+  bool hold;
+  int hold_duration;
+  bool drag;
+  hoku_drag_direction drag_direction;
+  hoku_vec2* drag_pos;
+  float drag_angle;
+  bool pinch;
+  hoku_pinch_direction pinch_direction;
+  hoku_vec2* pinch_pos;
+  float pinch_angle;
+} hoku_input_embedded;
+
 typedef struct HmlInput
 {
   hoku_input_keyboard* keyboard;
   hoku_input_mouse* mouse;
+  hoku_input_embedded* embedded;
 } hoku_input;
 
+void hoku_input_embedded_set_hold(hoku_input* input, bool hold, int hold_duration);
+void hoku_input_embedded_set_drag(hoku_input* input, bool drag, hoku_drag_direction drag_direction, float drag_x, float drag_y, float drag_angle);
+void hoku_input_embedded_set_pinch(hoku_input* input, bool pinch, hoku_pinch_direction pinch_direction, float pinch_x, float pinch_y, float pinch_angle);
+int hoku_input_attach_embedded(hoku_input* input);
 
 int hoku_input_keyboard_init(hoku_input_keyboard** keyboard);
 int hoku_input_mouse_init(hoku_input_mouse** mouse);

data/ast/src/core/util.c

@@ -3,33 +3,33 @@
 
 #include "util.h"
 
-bool hoku_rect_includes_y(hoku_rect rect, float y)
+bool hoku_rect_includes_y(hoku_rect* rect, float y)
 {
-  return y > rect.y && y <= (rect.y + rect.h);
+  return y > rect->y && y <= (rect->y + rect->h);
 }
 
-bool hoku_rect_includes_x(hoku_rect rect, float x)
+bool hoku_rect_includes_x(hoku_rect* rect, float x)
 {
-  return x > rect.x && x <= (rect.x + rect.w);
+  return x > rect->x && x <= (rect->x + rect->w);
 }
 
-float hoku_rect_x_left(hoku_rect rect, int times)
+float hoku_rect_x_left(hoku_rect* rect, int times)
 {
-  return (rect.x - ((rect.w / 2) * times));
+  return (rect->x - ((rect->w / 2) * times));
 }
-float hoku_rect_x_right(hoku_rect rect, int times)
+float hoku_rect_x_right(hoku_rect* rect, int times)
 {
-  return (rect.x + ((rect.w / 2) * times));
+  return (rect->x + ((rect->w / 2) * times));
 }
 
-float hoku_rect_y_up(hoku_rect rect, int times)
+float hoku_rect_y_up(hoku_rect* rect, int times)
 {
-  return (rect.y - ((rect.h / 2) * times));
+  return (rect->y - ((rect->h / 2) * times));
 }
 
-float hoku_rect_y_down(hoku_rect rect, int times)
+float hoku_rect_y_down(hoku_rect* rect, int times)
 {
-  return (rect.y + ((rect.h / 2) * times));
+  return (rect->y + ((rect->h / 2) * times));
 }
 
 int hoku_selection_init(hoku_selection** selection)
@@ -68,28 +68,28 @@ bool hoku_selection_selected(hoku_selection* selection, float x, float y, float
   bool right = selection->start_x <= selection->stop_x;
 
   hoku_rect hit_box = (hoku_rect){.x=x, .y=y, .w=width, .h=height};
-  float x_shifted_right = hoku_rect_x_right(hit_box, 1);
-  float y_shifted_up = hoku_rect_y_up(hit_box, 2);
-  float y_shifted_down = hoku_rect_y_down(hit_box, 2);
+  float x_shifted_right = hoku_rect_x_right(&hit_box, 1);
+  float y_shifted_up = hoku_rect_y_up(&hit_box, 2);
+  float y_shifted_down = hoku_rect_y_down(&hit_box, 2);
   float end_y = y + height;
 
   return (
    (down &&
     // first line of multiline selection
-    ((x_shifted_right > sx && end_y < ey && hoku_rect_includes_y(hit_box, sy)) ||
+    ((x_shifted_right > sx && end_y < ey && hoku_rect_includes_y(&hit_box, sy)) ||
       // last line of multiline selection
       (x_shifted_right <= ex && y_shifted_up + hit_box.h < ey && hit_box.y > sy) ||
       // middle line (all selected)
       (hit_box.y > sy && end_y < ey))) ||
     (up &&
       // first line of multiline selection
-      ((x_shifted_right <= sx && hit_box.y > ey && hoku_rect_includes_y(hit_box, sy)) ||
+      ((x_shifted_right <= sx && hit_box.y > ey && hoku_rect_includes_y(&hit_box, sy)) ||
       // last line of multiline selection
         (x_shifted_right >= ex && y_shifted_down > ey && end_y < sy) ||
         // middle line (all selected)
         (hit_box.y > ey && hit_box.y + hit_box.h < sy))) ||
     // single line selection
-    ((hoku_rect_includes_y(hit_box, sy) && hoku_rect_includes_y(hit_box, ey)) &&
+    ((hoku_rect_includes_y(&hit_box, sy) && hoku_rect_includes_y(&hit_box, ey)) &&
       ((left && x_shifted_right < sx && x_shifted_right > ex) || (right && x_shifted_right > sx && x_shifted_right < ex)))
   );
 }
@@ -108,7 +108,7 @@ hoku_cursor_position hoku_selection_cursor_get(hoku_selection* selection)
   return pos;
 }
 
-int hoku_selection_cursor_set(hoku_selection* selection, hoku_cursor_position cursor)
+int hoku_selection_cursor_set(hoku_selection* selection, hoku_cursor_position* cursor)
 {
   if (selection->cursor == NULL)
   {
@@ -117,10 +117,10 @@ int hoku_selection_cursor_set(hoku_selection* selection, hoku_cursor_position cu
     if (selection->cursor == NULL) return -1;
   }
 
-  selection->cursor->x = cursor.x;
-  selection->cursor->y = cursor.y;
-  selection->cursor->w = cursor.w;
-  selection->cursor->h = cursor.h;
+  selection->cursor->x = cursor->x;
+  selection->cursor->y = cursor->y;
+  selection->cursor->w = cursor->w;
+  selection->cursor->h = cursor->h;
 
   return 0;
 }

data/ast/src/core/util.h

@@ -30,16 +30,16 @@ typedef struct HokuSelection
    hoku_cursor_position* cursor;
 } hoku_selection;
 
-bool hoku_rect_includes_y(hoku_rect rect, float y);
-bool hoku_rect_includes_x(hoku_rect rect, float x);
-float hoku_rect_x_left(hoku_rect rect, int times);
-float hoku_rect_x_right(hoku_rect rect, int times);
-float hoku_rect_y_up(hoku_rect rect, int times);
-float hoku_rect_y_down(hoku_rect rect, int times);
+bool hoku_rect_includes_y(hoku_rect* rect, float y);
+bool hoku_rect_includes_x(hoku_rect* rect, float x);
+float hoku_rect_x_left(hoku_rect* rect, int times);
+float hoku_rect_x_right(hoku_rect* rect, int times);
+float hoku_rect_y_up(hoku_rect* rect, int times);
+float hoku_rect_y_down(hoku_rect* rect, int times);
 
 int hoku_selection_init(hoku_selection** selection);
 bool hoku_selection_selected(hoku_selection* selection, float x, float y, float width, float height);
-int hoku_selection_cursor_set(hoku_selection* selection, hoku_cursor_position cursor);
+int hoku_selection_cursor_set(hoku_selection* selection, hoku_cursor_position* cursor);
 void hoku_selection_cursor_free(hoku_selection* selection);
 void hoku_selection_free(hoku_selection* selection);
 

data/ext/extconf.rb

@@ -5,14 +5,17 @@ if MiniPortile.darwin?
   suffix = "dylib"
   ext = "tar.gz"
   md4cext = "a"
+  MDFLAGS = ""
 elsif MiniPortile.linux?
   suffix = "so"
   ext = "tar.gz"
-  md4cext = "so"
+  md4cext = "a"
+  MDFLAGS = "-DCMAKE_POSITION_INDEPENDENT_CODE=ON"
 elsif MiniPortile.windows?
   suffix = "dll"
   ext = "zip"
   md4cext = "a"
+  MDFLAGS = ""
 else
   raise "Currently only supporting darwin and linux"
 end
@@ -29,6 +32,7 @@ tree_sitter.tap do |t|
   end
 
   def t.install
+
     execute('install', %Q(#{make_cmd} all install CC=gcc AR=ar PREFIX=#{File.expand_path(port_path)}), { env: { "PREFIX" => File.expand_path(port_path) }})
   end
 
@@ -41,7 +45,7 @@ md4c = MiniPortileCMake.new("md4c", "0.5.2")
 md4c.files = ["https://github.com/mity/md4c/archive/refs/tags/release-0.5.2.#{ext}"]
 
 def md4c.cmake_compile_flags
-  [*super, "-DBUILD_SHARED_LIBS=OFF -DCMAKE_POSITION_INDEPENDENT_CODE=ON"]
+  [*super, "-DBUILD_SHARED_LIBS=OFF", "-DCMAKE_POSITION_INDEPENDENT_CODE=ON"]
 end
 
 md4c.cook
@@ -85,4 +89,4 @@ File.open("Makefile", "w") do |io|
   #{"\t"}rm -f #{File.expand_path("vendor/lib/libhokusai.*")}
   #{"\t"}rm -f #{File.expand_path("vendor/lib/libmd4c.*")}
   EOF
-end
+end

data/hokusai.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'hokusai-zero'
-  s.version     = '0.2.5'
+  s.version     = '0.2.6-pinephone'
   s.licenses    = ['MIT']
   s.summary     = "A Ruby library for writing GUI applications"
   s.authors     = ["skinnyjames"]
@@ -16,7 +16,6 @@ Gem::Specification.new do |s|
   s.metadata    = { "source_code_uri" => "https://codeberg.org/skinnyjames/hokusai" }
   
   s.add_dependency "ffi", "~> 1.16"
-  s.add_dependency "concurrent-ruby", "~> 1.3.4"
   s.add_dependency "raylib-bindings", "~> 0.7.9"
   s.add_dependency "sdl2-bindings", "~> 0.2.3"
   s.add_dependency "memory_profiler"

data/ui/examples/drag.rb

@@ -0,0 +1,154 @@
+require_relative "../src/hokusai"
+require_relative "../src/hokusai/backends/raylib"
+require "ostruct"
+
+class Item < Hokusai::Block
+  style <<~EOF
+  [style]
+  circleStyle {
+    cursor: "pointer";
+  }
+  EOF
+  template <<~EOF
+  [template]
+    empty {
+      ...circleStyle
+      :color="color"
+      @mousedown="start_drag"
+      @mouseup="release_drag"
+      @mousemove="emit_drag"
+    }
+  EOF
+
+  uses(empty: Hokusai::Blocks::Empty)
+
+  computed :index
+  computed! :pos
+  computed! :color
+
+  attr_accessor :dragging
+
+  def initialize(**props)
+    @dragging = false
+
+    super
+  end
+
+  def contains(p)
+    (((p.x - pos[0]) * (p.x - pos[0]) + (p.y - pos[1]) * (p.y - pos[1])) <= 40 * 40)
+  end
+
+  def start_drag(event)
+    if event.left.down && contains(event.pos)
+
+      self.dragging = true
+      node.meta.set_prop(:z, 2)
+      node.meta.set_prop(:position, "absolute")
+    end
+  end
+
+  def release_drag(event)
+    if dragging
+      emit("done", index)
+      self.dragging = false
+
+      node.meta.set_prop(:z, nil)
+      node.meta.set_prop(:position, nil)
+    end
+  end
+
+  def emit_drag(event)
+    if dragging && event.left.down
+      emit("drag", index, [event.pos.x, event.pos.y])
+    elsif dragging
+      emit("done", index)
+
+      self.dragging = false
+      node.meta.set_prop(:z, nil)
+      node.meta.set_prop(:position, nil)
+    end
+  end
+
+  def render(canvas)
+    canvas.x = canvas.x + (canvas.width / 2)
+    canvas.y = canvas.y + canvas.height / 2
+
+    circle(pos[0], pos[1], 40) do |command|
+      command.color = color
+    end
+
+    yield canvas
+  end
+end
+
+
+class Drag < Hokusai::Block
+  template <<~EOF
+  [template]
+    vblock { background="233,233,233" }
+      [for="thing in items"]
+        item {
+          :z="z(index)"
+          :key="key(index, thing)"
+          :index="index"
+          @drag="update_position"
+          @done="update_drag_state"
+          :pos="pos(thing)"
+          :color="color(thing)"
+        }
+  EOF
+
+  uses(
+    vblock: Hokusai::Blocks::Vblock,
+    item: Item
+  )
+
+  attr_reader :items
+
+  def z(index)
+    items[index].dragging ? 2 : nil
+  end
+
+  def update_drag_state(index)
+    items[index].dragging = false
+  end
+
+  def key(index, thing)
+    "key-#{index}"
+  end
+
+  def pos(thing)
+    thing.position
+  end
+
+  def color(thing)
+    thing.color
+  end
+
+  def update_position(index, pos)
+    items[index].dragging = true
+    items[index].position = pos
+  end
+
+  def initialize(**args)
+    @items = [[0, 10, [222,222,0]], [100, 100, [0,222,222]], [300, 300, [0, 222, 0]]].map do |list|
+      item = OpenStruct.new
+      item.position = [list[0], list[1]]
+      item.color = Hokusai::Color.convert(list[2])
+      item.dragging = false
+      item
+    end
+
+    pp items
+
+    super
+  end
+end
+
+Hokusai::Backends::RaylibBackend.run(Drag) do |config|
+  config.after_load do
+    font = Hokusai::Backends::RaylibBackend::Font.from("#{__dir__}/assets/Inter-Regular.ttf")
+    Hokusai.fonts.register "inter", font
+    Hokusai.fonts.activate "inter"
+  end
+end

data/ui/examples/embedded.rb

@@ -0,0 +1,59 @@
+require_relative "../src/hokusai"
+require_relative "../src/hokusai/backends/embedded"
+
+class App < Hokusai::Block
+  template <<~EOF
+  [template]
+    button {
+      @clicked="clear_text"
+      height="30"
+      content="clear"
+    }
+    panel {
+      @swipe="handle_swipe"
+      @taphold="handle_taphold"
+      @pinch="handle_pinch"
+    }
+      text {
+        :content="text"
+        :size="15"
+      }
+  EOF
+
+  uses(
+    button: Hokusai::Blocks::Button,
+    panel: Hokusai::Blocks::Panel,
+    text: Hokusai::Blocks::Text
+  )
+
+  attr_accessor :text
+
+  def initialize(**args)
+    @text = ""
+
+    super
+  end
+
+  def clear_text(event)
+    self.text = ""
+    pp ["clear", text]
+  end
+
+  def handle_pinch(event)
+    self.text += "Pinch: #{event.pinch_direction} - #{event.pinch_pos.x}x#{event.pinch_pos.y} (#{event.pinch_angle})\n\n"
+  end
+
+  def handle_swipe(event)
+    self.text += "Swipe: #{event.drag_direction} - #{event.drag_pos.x}x#{event.drag_pos.y} (#{event.drag_angle})\n\n"
+  end
+
+  def handle_taphold(event)
+    self.text += "Taphold #{event.hold_duration}\n\n"
+  end
+end
+
+Hokusai::Backends::EmbeddedBackend.run(App) do |config|
+  config.after_load do 
+    Hokusai.maximize_window
+  end
+end