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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff2e748026518a381a084842d38e6499cbc21ba6ae82ef8eecea9fcf1caac01d
-  data.tar.gz: b6f6552079320c6345dc2332c1876e4ad4640ae91edd1b80b5886cbb7e5a2a81
+  metadata.gz: e6b346169398fdc8ace4e949627b34928b44230de71c120dc1b7ec2e3cb377c5
+  data.tar.gz: 444a5c3581cc74ca1537f2682cd0a1fd3859164f92a773af738a3fea434d579f
 SHA512:
-  metadata.gz: b4d95dbfd485c9948af925f0d824383198a8676fa87714c1b8937b1c34c22bd0f384c86774a67e44e1e941fcfcad745e7576d287edc23f064022369d5187fad2
-  data.tar.gz: 73f8f5e98862ff3c219a61f570298e634a3d4293d619b6c79b557a5f499da96992366eb0f5ecf1f7adc7998f98d83ae54a878ee3445c527d262045cd41305038
+  metadata.gz: a9e491ff21f1ed5532ae4b265c2084f3599a1c242f68cd14974d9ccd2f0b9cc8d39897ff38795183460641aea0b62984fcf3cdcaea1432bc076b0bf4844e12c7
+  data.tar.gz: 80a602eff3310633a24f4edc99b7191d2d367a1a826e0f591ac4bece88119088551566cf82779f138f757c5fcd8c651efae8be1188b0c77c2131725aa016de87

data/ast/src/core/input.c

@@ -4,83 +4,133 @@
 #include "input.h"
 #include <stdio.h>
 
-int hoku_input_embedded_init(hoku_input_embedded** embedded)
+#define NANO_TO_MILLISECONDS 1000000
+
+int hoku_input_touch_init(hoku_input_touch** embedded, int max_touch_positions)
 {
-  hoku_input_embedded* out = malloc(sizeof(hoku_input_embedded));
+  hoku_input_touch* out = malloc(sizeof(hoku_input_touch));
   if (!out) return -1;
 
-  out->drag_pos = malloc(sizeof(hoku_vec2));
-  if (out->drag_pos == NULL) 
-  {
-    free(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;
 
-  out->pinch_pos = malloc(sizeof(hoku_vec2));
-  if (out->pinch_pos == NULL)
+  for (int i=0; i < max_touch_positions; i++)
   {
-    free(out->drag_pos);
-    free(out);
-    return -1;
+    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->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;
+  out->touch_len = max_touch_positions;
+  out->touch_count = 0;
+  out->touching_now = false;
+  out->timer = 0;
 
   *embedded = out;
   return 0;
 }
 
-void hoku_input_embedded_set_hold(hoku_input* input, bool hold, int hold_duration)
+long hoku_input_touch_duration(hoku_input* input)
 {
-  input->embedded->hold = hold;
-  input->embedded->hold_duration = hold_duration;
+  return input->touch->timer * NANO_TO_MILLISECONDS;
 }
 
-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)
+bool hoku_input_touch_tapped(hoku_input* input)
 {
-  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;
+  if (input->touch->touching_now == false && input->touch->last_touch_positions[0] != NULL) return true;
+
+  return false;
 }
 
-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)
+bool hoku_input_touch_swiped(hoku_input* input, float threshold)
 {
-  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;
+  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;
 }
 
-int hoku_input_attach_embedded(hoku_input* input)
+bool hoku_input_touch_longtapped(hoku_input* input, int threshold)
 {
-  hoku_input_embedded* embedded;
-  if (hoku_input_embedded_init(&embedded) == -1) return -1;
-  input->embedded = embedded;
+  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;
 }
 
-void hoku_input_embedded_free(hoku_input_embedded* embedded)
+int hoku_input_attach_touch(hoku_input* input, int max_touch_count)
 {
-  free(embedded->drag_pos);
-  free(embedded->pinch_pos);
-  free(embedded);
+  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,
@@ -352,9 +402,9 @@ void hoku_input_free(hoku_input* input)
   hoku_input_keyboard_free(input->keyboard);
   hoku_input_mouse_free(input->mouse);
   
-  if (input->embedded)
+  if (input->touch)
   {
-    hoku_input_embedded_free(input->embedded);
+    hoku_input_touch_free(input->touch);
   }
 
   free(input);
@@ -382,7 +432,7 @@ int hoku_input_init(hoku_input** input)
     return -1;
   }
   init->keyboard = keyboard;
-  init->embedded = NULL;
+  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
 {
@@ -99,31 +100,31 @@ typedef enum HmlPinchDirection {
   HOKU_PINCH_OUT
 } hoku_pinch_direction;
 
-typedef struct HmlInputEmbedded
+typedef struct HmlInputTouch
 {
-  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;
+  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_embedded* embedded;
+  hoku_input_touch* touch;
 } 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);
+
+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);

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-pinephone'
+  s.version     = '0.2.6-pinephone2'
   s.licenses    = ['MIT']
   s.summary     = "A Ruby library for writing GUI applications"
   s.authors     = ["skinnyjames"]

data/ui/examples/embedded.rb

@@ -36,7 +36,6 @@ class App < Hokusai::Block
 
   def clear_text(event)
     self.text = ""
-    pp ["clear", text]
   end
 
   def handle_pinch(event)

data/ui/lib/lib_hokusai.rb

@@ -245,20 +245,13 @@ module LibHokusai
            :collecting, :bool
   end
 
-  enum :hml_drag_direction, [:up, :down, :left, :right]
-  enum :hml_pinch_direction, [:in, :out]
-
-  class HmlInputEmbedded < FFI::Struct
-    layout :hold, :bool,
-           :hold_duration, :int,
-           :drag, :bool,
-           :drag_direction, :hml_drag_direction,
-           :drag_pos, HmlVec2.ptr,
-           :drag_angle, :float,
-           :pinch, :bool,
-           :pinch_direction, :hml_pinch_direction,
-           :pinch_pos, HmlVec2.ptr,
-           :pinch_angle, :float           
+  class HmlInputTouch < FFI::Struct
+    layout :touch_len, :int,
+           :touch_count, :int,
+           :touching_now, :bool,
+           :timer, :long,
+           :last_touch_positions, :pointer,
+           :touch_positions, :pointer       
   end
 
   class HmlInputMouseButton < FFI::Struct
@@ -310,7 +303,7 @@ module LibHokusai
   class HmlInput < FFI::Struct
     layout :keyboard, HmlInputKeyboard.ptr,
            :mouse, HmlInputMouse.ptr,
-           :embedded, HmlInputEmbedded.ptr
+           :touch, HmlInputTouch.ptr
   end
 
   def LibHokusai.const_missing( sym )
@@ -325,10 +318,15 @@ module LibHokusai
   attach_function :hoku_input_set_mouse_position, [HmlInput.by_ref, HmlVec2.by_ref], :void
   attach_function :hoku_input_mouse_set_scroll, [HmlInput.by_ref, :float], :void
   attach_function :hoku_input_mouse_set_button, [HmlInput.by_ref, HmlInputMouseButton.by_ref, :int], :void
-  attach_function :hoku_input_embedded_set_hold, [HmlInput.by_ref, :bool, :int], :void
-  attach_function :hoku_input_embedded_set_drag, [HmlInput.by_ref, :bool, :hml_drag_direction, :float, :float, :float], :void
-  attach_function :hoku_input_embedded_set_pinch, [HmlInput.by_ref, :bool, :hml_pinch_direction, :float, :float, :float], :void
-  attach_function :hoku_input_attach_embedded, [HmlInput.by_ref], :int
+  # touch functions
+  attach_function :hoku_input_attach_touch, [HmlInput.by_ref, :int], :int
+  attach_function :hoku_input_record_touch, [HmlInput.by_ref, :int, :float, :float], :int
+  attach_function :hoku_input_clear_touch, [HmlInput.by_ref, :int], :void
+
+  attach_function :hoku_input_touch_duration, [HmlInput.by_ref], :long
+  attach_function :hoku_input_touch_tapped, [HmlInput.by_ref], :bool
+  attach_function :hoku_input_touch_swiped, [HmlInput.by_ref], :bool
+  attach_function :hoku_input_touch_longtapped, [HmlInput.by_ref], :bool
 
   attach_function :hoku_input_is_clicked, [HmlInput.by_ref, HmlRect.by_ref], :bool
   attach_function :hoku_input_is_hovered, [HmlInput.by_ref, HmlRect.by_ref], :bool

data/ui/src/hokusai/backends/embedded/config.rb

@@ -5,7 +5,7 @@ module Hokusai::Backends
     attr_accessor :width, :height, :fps,
                   :title, :config_flags, :window_state_flags,
                   :automation_driver, :background, :after_load_cb,
-                  :host, :port, :automated, :on_reload, :event_waiting
+                  :host, :port, :automated, :on_reload, :event_waiting, :max_touch_count
 
     def initialize
       @width = 500
@@ -22,6 +22,7 @@ module Hokusai::Backends
       @automated = false
       @on_reload = ->(_){}
       @event_waiting = false
+      @max_touch_count = 2
     end
 
     def start_automation_driver

data/ui/src/hokusai/backends/embedded.rb

@@ -18,7 +18,8 @@ module Hokusai::Backends
       end
     end
 
-    attr_reader :config, :last_touch
+    attr_reader :config
+    attr_accessor :last_touch, :last_gesture, :touches, :stuff
 
     def self.icons
       @icons ||= {}
@@ -113,56 +114,28 @@ module Hokusai::Backends
     end
 
     def process_input(input)
-      raylib_mouse_pos = Raylib.GetMousePosition
-      raylib_mouse_delta = Raylib.GetMouseDelta
-      LibHokusai.hoku_input_set_mouse_position(input.raw, hml_vec2(raylib_mouse_pos.x, raylib_mouse_pos.y))
+      self.touches = Raylib.GetTouchPointCount
+      if touches > 0
+        touches.times do |i|
+          vec = Raylib.GetTouchPosition
 
-      input.raw[:mouse][:delta][:x] = raylib_mouse_delta.x
-      input.raw[:mouse][:delta][:y] = raylib_mouse_delta.y
-
-      if Raylib.GetTouchPointCount > 0
-        self.last_touch = Raylib.GetTouchPosition(0)
-
-        button = mouse_button(clicked: false, down: true, released: false, up: false)
-        LibHokusai.hoku_input_mouse_set_button(input.raw, button, 0)
+          if LibHokusai.hoku_input_record_touch(input.raw, i, vec.x, vec.y) == -1
+            raise Hokusai::Error.new("Could not record touch")
+          end
+        end
       else
-        if last_touch
-          button = mouse_button(clicked: true, down: false, released: true, up: true)
-          LibHokusai.hoku_input_mouse_set_button(input.raw, button, 0)
+        config.max_touch_count.times do |i|
+          LibHokusai.hoku_input_clear_touch(input.raw, i)
         end
       end
 
-      LibHokusai.hoku_input_embedded_set_drag(input.raw, false, :up, 0.0, 0.0, 0.0)
-      LibHokusai.hoku_input_embedded_set_hold(input.raw, false, 0)
-      LibHokusai.hoku_input_embedded_set_pinch(input.raw, false, :in, 0.0, 0.0, 0.0)
-
-      gesture = Raylib.GetGestureDetected
-      case gesture
-      when Raylib::GESTURE_NONE
-        # nothing yet
-      when Raylib::GESTURE_DOUBLETAP
-        # nothing yet
-      when Raylib::GESTURE_HOLD
-        LibHokusai.hoku_input_embedded_set_hold(input.raw, true, Raylib.GetGestureHoldDuration)
-      when Raylib::GESTURE_DRAG
-        # nothing yet
-      when Raylib::GESTURE_SWIPE_DOWN
-        pos = Raylb.GetGestureDragVector
-        LibHokusai.hoku_input_embedded_set_drag(input.raw, true, :down, pos.x, pos.y, Raylb.GetGestureDragAngle)
-      when Raylib::GESTURE_SWIPE_UP
-        pos = Raylb.GetGestureDragVector
-        LibHokusai.hoku_input_embedded_set_drag(input.raw, true, :up, pos.x, pos.y, Raylb.GetGestureDragAngle)
-      when Raylib::GESTURE_SWIPE_LEFT
-        pos = Raylb.GetGestureDragVector
-        LibHokusai.hoku_input_embedded_set_drag(input.raw, true, :left, pos.x, pos.y, Raylb.GetGestureDragAngle)
-      when Raylib::GESTURE_SWIPE_RIGHT
-        pos = Raylb.GetGestureDragVector
-        LibHokusai.hoku_input_embedded_set_drag(input.raw, true, :right, pos.x, pos.y, Raylb.GetGestureDragAngle)
-      when Raylib::GESTURE_PINCH_IN
-        pos = Raylib.GetGesturePinchVector
-        LibHokusai.hoku_input_embedded_set_pinch(input.raw, true, :in, pos.x, pos.y, Raylb.GetGesturePinchAngle)
-      when Raylib::GESTURE_PINCH_OUT
-        LibHokusai.hoku_input_embedded_set_pinch(input.raw, true, :out, pos.x, pos.y, Raylb.GetGesturePinchAngle)
+      # translate taps to clicks
+      if input.touch.tapped?
+        button = mouse_button(clicked: true, down: true, released: false, up: false)
+        LibHokusai.hoku_input_mouse_set_button(input.raw, button, 0)
+      else
+        button = mouse_button(clicked: false, down: false, released: true, up: true)
+        LibHokusai.hoku_input_mouse_set_button(input.raw, button, 0)
       end
     end
 
@@ -190,7 +163,7 @@ module Hokusai::Backends
       ptr = FFI::MemoryPointer.new :pointer
       LibHokusai.hoku_input_init(ptr)
       raw = LibHokusai::HmlInput.new(ptr.get_pointer(0))
-      LibHokusai.hoku_input_attach_embedded(raw)
+      LibHokusai.hoku_input_attach_touch(raw, config.max_touch_count)
 
       input = Hokusai::Input.new(raw)
       ptr.free
@@ -268,6 +241,9 @@ module Hokusai::Backends
 
         painter.render(canvas, resize)
 
+        Raylib.DrawText("Touches: #{touches}", 10, 10, 14, color(Hokusai::Color.new(244,22,22)));
+        Raylib.DrawText("Stuff: #{stuff}", 10, 24, 14, color(Hokusai::Color.new(244,22,22))) if stuff
+
         Raylib.DrawFPS(10, 10) if ENV["PROFILE"] || ENV["FPS"]
         Raylib.EndDrawing
 

data/ui/src/hokusai/event.rb

@@ -66,4 +66,4 @@ end
 
 require_relative './events/keyboard'
 require_relative './events/mouse'
-require_relative './events/embedded'
+require_relative './events/touch'

data/ui/src/hokusai/events/{embedded.rb → touch.rb}

@@ -1,17 +1,17 @@
 module Hokusai
-  class EmbeddedEvent < Event
+  class TouchEvent < Event
     extend Forwardable
 
-    def_delegators :@embedded, :hold, :hold_duration, :drag, :drag_direction, 
-                    :drag_pos, :drag_angle, :pinch,
-                    :pinch_direction, :pinch_pos, :pinch_angle
+    def_delegators :@touch, :tapped?, :swiped?, :longtapped?, :touching?,
+                   :duration, :direction, :angle, :position, :last_position,
+                  :touch_len, :touch_count, :timer
 
     attr_reader :input
 
     def initialize(input, state)
       @input = input
       @state = state
-      @embedded = input.embedded
+      @touch = input.touch
     end
 
     def hovered(canvas)
@@ -28,37 +28,37 @@ module Hokusai
     end
   end
 
-  class TapHoldEvent < EmbeddedEvent
+  class TapHoldEvent < TouchEvent
     name "taphold"
 
     def capture(block, canvas)
-      if hold && hovered(canvas)
+      if longtapped? && hovered(canvas)
         block.node.meta.focus
         
         if matches(block)
           captures << block
         end
-      elsif hold
+      elsif touching?
         block.node.meta.blur
       end
     end
   end
 
-  class PinchEvent < EmbeddedEvent
+  class PinchEvent < TouchEvent
     name "pinch"
 
     def capture(block, canvas)
-      if pinch && matches(block)
+      if false && matches(block)
         captures << block
       end
     end
   end
 
-  class SwipeEvent < EmbeddedEvent
+  class SwipeEvent < TouchEvent
     name "swipe"
 
     def capture(block, canvas)
-      if drag && matches(block)
+      if swiped? && matches(block)
         captures << block
       end
     end

data/ui/src/hokusai/painter.rb

@@ -46,10 +46,10 @@ module Hokusai
         keypress: KeyPressEvent.new(input, state)
       }
 
-      add_embedded_events(events, input, state) unless input.embedded.nil?
+      add_touch_events(events, input, state) unless input.touch.nil?
     end
 
-    def add_embedded_events(events, input, state)
+    def add_touch_events(events, input, state)
       events.merge!({
         taphold: TapHoldEvent.new(input, state),
         pinch: PinchEvent.new(input, state),
@@ -181,7 +181,7 @@ module Hokusai
         events[:mousedown].bubble
         events[:mouseup].bubble
 
-        unless input.embedded.nil?
+        unless input.touch.nil?
           events[:taphold].bubble
           events[:pinch].bubble
           events[:swipe].bubble
@@ -282,7 +282,7 @@ module Hokusai
         events[:keypress].capture(block, canvas)
       end
 
-      unless input.embedded.nil?
+      unless input.touch.nil?
         events[:taphold].capture(block, canvas)
         events[:pinch].capture(block, canvas)
         events[:swipe].capture(block, canvas)

data/ui/src/hokusai/types.rb

@@ -240,23 +240,83 @@ module Hokusai
     end
   end
 
-  class Embedded
+  class Touch
     attr_reader :raw
-    
+
     [
-      :hold, :hold_duration, :drag, :drag_direction, 
-      :drag_pos, :drag_angle, :pinch,
-      :pinch_direction, :pinch_pos, :pinch_angle
+      :touch_len, :touch_count, :touching_now, :timer, 
     ].each do |key|
       define_method(key) do
-        raw[key]
+        raw[:touch][key]
       end
+    end
+
+    def swiped?
+      LibHokusai.hoku_input_touch_swiped(raw)
+    end
+
+    def longtapped?
+      LibHokusai.hoku_input_touch_longtapped(raw)
+    end
+
+    # return [Intger] duration in milliseconds
+    def duration
+      LibHokusai.hoku_input_touch_duration(raw)
+    end
+
+    def touching?
+      touching_now
+    end
+
+    def tapped?
+      LibHokusai.hoku_input_touch_tapped(raw)
+    end
+
+    def position(index=0)
+      touches[index]
+    end
 
-      define_method("#{key}=") do |val|
-        raw[key] = val
+    def last_position(index=0)
+      last_touches[index]
+    end
+
+    def angle(index = 0)
+      return nil unless swiped?
+
+      pos = position(index)
+      lpos = last_position(index)
+
+      x = position.x - last_position.x
+      y = position.y - last_position.y
+
+      (Math.atan2(x, y) * (180 / Math::PI)).round(0).to_i
+    end
+
+    def direction(index=0)
+      return nil unless swiped?
+
+      pos = position(index)
+      lpos = last_position(index)
+
+      x = position.x - last_position.x
+      y = position.y - last_position.y
+
+      if x.abs > y.abs
+        # swiping left/right
+        position.x > last_position.x ? :right : :left
+      else
+        # swiping up/down
+        position.y > last_position.y ? :up : :down
       end
     end
 
+    def last_touches
+      @raw[:last_touch_positions].read_array_of_type(LibHokusai::HmlDoubleVec2, :read_pointer, touch_len)
+    end
+
+    def touches
+      @raw[:touch_positions].read_array_of_type(LibHokusai::HmlDoubleVec2, :read_pointer, touch_len)
+    end
 
     def initialize(raw)
       @raw = raw
@@ -274,10 +334,10 @@ module Hokusai
       @raw = raw
     end
 
-    def embedded
-      return nil if @raw[:embedded].null?
+    def touch
+      return nil if @raw[:touch].null?
 
-      Embedded.new(@raw[:embedded])
+      Touch.new(@raw)
     end
 
     def keyboard

data/xmake.lua

@@ -159,7 +159,7 @@ target("test-ast")
   )
   -- add_cflags("-Wall -Werror")
   after_build(function(target)
-    os.exec("./%s -t markdown", target:targetfile())
+    os.exec("./%s -t input", target:targetfile())
     -- os.exec("leaks -atExit -- %s", target:targetfile())
   end)
 target_end()

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hokusai-zero
 version: !ruby/object:Gem::Version
-  version: 0.2.6.pre.pinephone
+  version: 0.2.6.pre.pinephone2
 platform: ruby
 authors:
 - skinnyjames
@@ -114,6 +114,7 @@ files:
 - ast/test/fixtures/test.ui
 - ast/test/greatest.h
 - ast/test/hokusai.c
+- ast/test/input.c
 - ast/test/parser.c
 - ast/test/text.c
 - docs.sh
@@ -276,9 +277,9 @@ files:
 - ui/src/hokusai/diff.rb
 - ui/src/hokusai/error.rb
 - ui/src/hokusai/event.rb
-- ui/src/hokusai/events/embedded.rb
 - ui/src/hokusai/events/keyboard.rb
 - ui/src/hokusai/events/mouse.rb
+- ui/src/hokusai/events/touch.rb
 - ui/src/hokusai/font.rb
 - ui/src/hokusai/meta.rb
 - ui/src/hokusai/mounting/loop_entry.rb