hokusai-zero 0.2.6.pre.android → 0.2.6.pre.pinephone2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce738bae9af93e8117b6a962e52d140c69ca8dacac118b7830819a8e4d1db585
-  data.tar.gz: 0a0cbb5d8f6fb7a35dbcb619e17d06f5d05788c226480b11d546b3e9de7c8813
+  metadata.gz: e6b346169398fdc8ace4e949627b34928b44230de71c120dc1b7ec2e3cb377c5
+  data.tar.gz: 444a5c3581cc74ca1537f2682cd0a1fd3859164f92a773af738a3fea434d579f
 SHA512:
-  metadata.gz: 1752951b5745a54239c07c9cb3a0b9569105a0011531174a6bfced4b9062466054b098029a72b7562b3f73a89378e422cd13983ff432b0130bcc1a8bce622e6e
-  data.tar.gz: cc55da6b2f736f4f637a50115ad294247da5eb5c73fb74785ba2eec790c8476b9aae1d0b97822a65152f27ac924a32fd3a58192594e97b5af9f1bb7479f8db94
+  metadata.gz: a9e491ff21f1ed5532ae4b265c2084f3599a1c242f68cd14974d9ccd2f0b9cc8d39897ff38795183460641aea0b62984fcf3cdcaea1432bc076b0bf4844e12c7
+  data.tar.gz: 80a602eff3310633a24f4edc99b7191d2d367a1a826e0f591ac4bece88119088551566cf82779f138f757c5fcd8c651efae8be1188b0c77c2131725aa016de87

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/ast/src/core/input.c

@@ -4,6 +4,134 @@
 #include "input.h"
 #include <stdio.h>
 
+#define NANO_TO_MILLISECONDS 1000000
+
+int hoku_input_touch_init(hoku_input_touch** embedded, int max_touch_positions)
+{
+  hoku_input_touch* out = malloc(sizeof(hoku_input_touch));
+  if (!out) return -1;
+
+  out->last_touch_positions = malloc(sizeof(hoku_dvec2*) * max_touch_positions);
+  if (out->last_touch_positions == NULL) return -1;
+
+  out->touch_positions = malloc(sizeof(hoku_dvec2*) * max_touch_positions);
+  if (out->touch_positions == NULL) return -1;
+
+  for (int i=0; i < max_touch_positions; i++)
+  {
+    out->last_touch_positions[i] = malloc(sizeof(hoku_dvec2));
+    if (out->last_touch_positions[i] == NULL) return -1;
+    out->last_touch_positions[i]->x = -1.0;
+    out->last_touch_positions[i]->y = -1.0;
+
+
+    out->touch_positions[i] = malloc(sizeof(hoku_dvec2));
+    if (out->touch_positions[i] == NULL) return -1;
+    out->touch_positions[i]->x = -1.0;
+    out->touch_positions[i]->y = -1.0;
+  }
+
+  out->touch_len = max_touch_positions;
+  out->touch_count = 0;
+  out->touching_now = false;
+  out->timer = 0;
+
+  *embedded = out;
+  return 0;
+}
+
+long hoku_input_touch_duration(hoku_input* input)
+{
+  return input->touch->timer * NANO_TO_MILLISECONDS;
+}
+
+bool hoku_input_touch_tapped(hoku_input* input)
+{
+  if (input->touch->touching_now == false && input->touch->last_touch_positions[0] != NULL) return true;
+
+  return false;
+}
+
+bool hoku_input_touch_swiped(hoku_input* input, float threshold)
+{
+  if (input->touch->touching_now == false)
+  {
+    hoku_dvec2* last = input->touch->last_touch_positions[0];
+    hoku_dvec2* now = input->touch->touch_positions[0];
+
+    if (last->x == -1.0 || last->y == -1.0) return false;
+    if (last == NULL || now == NULL) return false;
+
+    return (abs((int)(now->x - last->x)) >= threshold || abs((int)(now->y - last->y)) >= threshold);
+  }
+
+  return false;
+}
+
+bool hoku_input_touch_pinched(hoku_input* input)
+{
+  return false;
+}
+
+bool hoku_input_touch_longtapped(hoku_input* input, int threshold)
+{
+  if (input->touch->touching_now && input->touch->timer > 0l)
+  {
+    hoku_dvec2* last = input->touch->last_touch_positions[0];
+    hoku_dvec2* now = input->touch->touch_positions[0];
+
+    return (abs((int)(now->x - last->x)) < threshold && abs((int)(now->y - last->y)) < threshold);
+  }
+
+  return false;
+}
+
+void hoku_input_clear_touch(hoku_input* input, int index)
+{
+  input->touch->touching_now = false;
+  input->touch->timer = 0l;
+}
+
+int hoku_input_record_touch(hoku_input* input, int index, float x, float y)
+{
+  struct timespec start;
+  if (clock_gettime(CLOCK_MONOTONIC, &start) == -1) return -1;
+  
+  if (!(input->touch->touching_now))
+  {
+    input->touch->last_touch_positions[index]->x = input->touch->touch_positions[index]->x;
+    input->touch->last_touch_positions[index]->y = input->touch->touch_positions[index]->y;
+
+    input->touch->timer = start.tv_nsec;
+  }
+  else
+  {
+    input->touch->timer = start.tv_nsec - input->touch->timer;
+  }
+
+  input->touch->touch_positions[index]->x = x;
+  input->touch->touch_positions[index]->y = y;
+  input->touch->touching_now = true;
+
+  return 0;
+}
+
+int hoku_input_attach_touch(hoku_input* input, int max_touch_count)
+{
+  hoku_input_touch* touch;
+  if (hoku_input_touch_init(&touch, max_touch_count) == -1) return -1;
+  input->touch = touch;
+
+  return 0;
+}
+
+void hoku_input_touch_free(hoku_input_touch* embedded)
+{
+  free(embedded->touch_positions);
+  free(embedded->last_touch_positions);
+  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 +401,12 @@ void hoku_input_free(hoku_input* input)
 {
   hoku_input_keyboard_free(input->keyboard);
   hoku_input_mouse_free(input->mouse);
+  
+  if (input->touch)
+  {
+    hoku_input_touch_free(input->touch);
+  }
+
   free(input);
 }
 
@@ -298,6 +432,7 @@ int hoku_input_init(hoku_input** input)
     return -1;
   }
   init->keyboard = keyboard;
+  init->touch = NULL;
 
   *input = init;
   return 0;

data/ast/src/core/input.h

@@ -4,6 +4,7 @@
 #include "common.h"
 #include <stdbool.h>
 #include <stdlib.h>
+#include <time.h>
 
 typedef struct HmlInputMouseButton
 {
@@ -87,13 +88,44 @@ 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 HmlInputTouch
+{
+  int touch_len;
+  int touch_count;
+  bool touching_now;
+  long timer;
+  hoku_dvec2** last_touch_positions;
+  hoku_dvec2** touch_positions;
+} hoku_input_touch;
+
 typedef struct HmlInput
 {
   hoku_input_keyboard* keyboard;
   hoku_input_mouse* mouse;
+  hoku_input_touch* touch;
 } hoku_input;
 
 
+long hoku_input_touch_duration(hoku_input* input);
+bool hoku_input_touch_tapped(hoku_input* input);
+bool hoku_input_touch_swiped(hoku_input* input, float threshold);
+bool hoku_input_touch_longtapped(hoku_input* input, int threshold);
+void hoku_input_clear_touch(hoku_input* input, int index);
+int hoku_input_record_touch(hoku_input* input, int index, float x, float y);
+int hoku_input_attach_touch(hoku_input* input, int max_touch_count);
+
 int hoku_input_keyboard_init(hoku_input_keyboard** keyboard);
 int hoku_input_mouse_init(hoku_input_mouse** mouse);
 int hoku_input_init(hoku_input** input);

data/ast/test/hokusai.c

@@ -1,6 +1,7 @@
 #include "greatest.h"
 #include "parser.c"
 #include "text.c"
+#include "input.c"
 
 GREATEST_MAIN_DEFS();
 
@@ -9,6 +10,7 @@ int main(int argc, char** argv) {
 
   RUN_SUITE(hoku_parser_suite);
   RUN_SUITE(hoku_text_suite);
+  RUN_SUITE(hoku_input_suite);
 
   GREATEST_MAIN_END();
 }

data/ast/test/input.c

@@ -0,0 +1,44 @@
+#include "../src/core/input.c"
+#include<unistd.h>
+
+TEST test_hoku_input_touch_basic()
+{
+  hoku_input* input;
+  int ret = hoku_input_init(&input);
+  ASSERT_EQ_FMT(ret, 0, "%d");
+
+  ret = hoku_input_attach_touch(input, 2);
+  ASSERT_EQ_FMT(ret, 0, "%d");
+
+  hoku_input_record_touch(input, 0, 1.0, 2.0);
+  hoku_input_clear_touch(input, 0);
+
+  bool tapped = hoku_input_touch_tapped(input);
+  bool swiped = hoku_input_touch_swiped(input, 4);
+
+  ASSERT_EQ_FMT(1, tapped, "%d");
+  ASSERT_EQ_FMT(0, swiped, "%d");
+
+  hoku_input_record_touch(input, 0, 1.0, 2.0);
+  usleep(1000);
+  hoku_input_record_touch(input, 0, 3.0, 1.0);
+
+  bool longtapped = hoku_input_touch_longtapped(input, 4);
+
+  hoku_input_clear_touch(input, 0);
+  swiped = hoku_input_touch_swiped(input, 1.0);
+
+  ASSERT_EQ_FMT(1, longtapped, "%d");
+  ASSERT_EQ_FMT(1, swiped, "%d");
+  // ASSERT_EQ_FMT(pinched, 0, "%d");
+
+  hoku_input_free(input);
+
+  PASS();
+}
+
+
+SUITE(hoku_input_suite)
+{
+	RUN_TEST(test_hoku_input_touch_basic);
+}

data/hokusai.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'hokusai-zero'
-  s.version     = '0.2.6-android'
+  s.version     = '0.2.6-pinephone2'
   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,58 @@
+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 = ""
+  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

data/ui/examples/game.rb

@@ -0,0 +1,143 @@
+require_relative "../src/hokusai"
+require_relative "../src/hokusai/backends/raylib"
+require 'ostruct'
+
+TILES = [
+  ["Power Supply", 500],
+  ["Power Distribution", 400],
+  ["Farm", 100],
+  ["Medicine Production", 50],
+  ["Science Research", 400],
+  ["Lumberyard", 200],
+  ["Art Gallery", 20],
+  ["School", 100],
+  ["Commercial transportation", 300],
+  ["Mechanical Automation", 700],
+  ["Tailor shop", 50],
+  ["Housing Construction", 200],
+  ["Commerical Building Construction", 300],
+  ["Restaraunt", 50],
+  ["Furniture manufacturing", 200],
+  ["Cotton mill", 200],
+  ["Metals processing", 400],
+  ["Forestry center", 400],
+  ["Bar", 50],
+  ["Healthcare", 100]
+]
+
+
+class Game < Hokusai::Block
+  style <<-EOF
+  [style]
+  bg {
+    color: rgb(173, 207, 224);
+    width: 100;
+    height: 100;
+    outline: outline(1.0, 1.0, 1.0, 1.0);
+    outline_color: rgb(0, 0, 0);
+  }
+  board {
+    height: 500;
+    width: 500;
+  }
+  height {
+    height: 100;
+  }
+  textPadding {
+    padding: padding(10.0, 5.0, 10.0, 10.0);
+  }
+  EOF
+  template <<~EOF
+  [template]
+    vblock { ...board }
+      hblock
+        [for="tile in top"]
+          rect { :key="top_key(tile)" ...bg }
+            text {  :content="tile" ...textPadding}
+      [for="i in middle"]
+        hblock {...height :key="get(i)"}
+          rect {...bg}
+            text {  :key="get(i)" :content="get(i)" ...textPadding }
+          empty
+          empty
+          empty
+          rect {...bg }
+            text { :key="get_next(i)" :content="get_next(i)" ...textPadding}
+      hblock
+        [for="tile in bottom"]
+          rect { ...bg  :key="bottom_key(tile)" }
+            text { :key="tile" :content="tile" ...textPadding }
+  EOF
+
+  uses(
+    hblock: Hokusai::Blocks::Hblock,
+    vblock: Hokusai::Blocks::Vblock,
+    text: Hokusai::Blocks::Text,
+    empty: Hokusai::Blocks::Empty,
+    rect: Hokusai::Blocks::Rect
+  )
+
+  attr_reader :tiles
+
+  def get(i)
+    tiles[i[0]].title
+  end
+
+  def get_next(i)
+    tiles[i[1]].title
+  end
+
+  def middle
+   (5..10).each_slice(2).to_a
+  end
+
+  def bottom_key(t)
+    "bottom-#{t}"
+  end
+
+  def top_key(t)
+    "top-#{t}"
+  end
+
+  def top
+    tiles.take(5).map(&:title)
+  end
+
+  def bottom
+    a = tiles[-5, 5].map(&:title)
+    a
+  end
+
+  def after_updated
+    @tiles = TILES.map do |(label, cost)|
+      os = OpenStruct.new
+      os.title = label
+      os.cost = cost
+      os
+    end
+  end
+
+  def initialize(**args)
+    @tiles = TILES.map do |(label, cost)|
+      os = OpenStruct.new
+      os.title = label
+      os.cost = cost
+      os
+    end
+
+    super
+  end
+end
+
+
+Hokusai::Backends::RaylibBackend.run(Game) do |config|
+  config.width = 500
+  config.height = 500
+  
+  config.after_load do
+    font = Hokusai::Backends::RaylibBackend::Font.from_ext("#{__dir__}/assets/OpenSans-Regular.ttf", 160)
+    Hokusai.fonts.register "opensans", font
+    Hokusai.fonts.activate "opensans"
+  end
+end
+