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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce738bae9af93e8117b6a962e52d140c69ca8dacac118b7830819a8e4d1db585
-  data.tar.gz: 0a0cbb5d8f6fb7a35dbcb619e17d06f5d05788c226480b11d546b3e9de7c8813
+  metadata.gz: ff2e748026518a381a084842d38e6499cbc21ba6ae82ef8eecea9fcf1caac01d
+  data.tar.gz: b6f6552079320c6345dc2332c1876e4ad4640ae91edd1b80b5886cbb7e5a2a81
 SHA512:
-  metadata.gz: 1752951b5745a54239c07c9cb3a0b9569105a0011531174a6bfced4b9062466054b098029a72b7562b3f73a89378e422cd13983ff432b0130bcc1a8bce622e6e
-  data.tar.gz: cc55da6b2f736f4f637a50115ad294247da5eb5c73fb74785ba2eec790c8476b9aae1d0b97822a65152f27ac924a32fd3a58192594e97b5af9f1bb7479f8db94
+  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/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/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-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

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
+