hokusai-zero 0.2.6 → 0.2.8

data/ui/src/hokusai/painter.rb

@@ -45,6 +45,16 @@ module Hokusai
         keyup: KeyUpEvent.new(input, state),
         keypress: KeyPressEvent.new(input, state)
       }
+
+      add_touch_events(events, input, state) unless input.touch.nil?
+    end
+
+    def add_touch_events(events, input, state)
+      events.merge!({
+        taphold: TapHoldEvent.new(input, state),
+        pinch: PinchEvent.new(input, state),
+        swipe: SwipeEvent.new(input, state),
+      })
     end
 
     def on_before_render(&block)
@@ -86,7 +96,7 @@ module Hokusai
       root_entry = PainterEntry.new(root, canvas.x, canvas.y, canvas.width, canvas.height)
       groups << [root_entry, measure(root_children, canvas)]
 
-      mouse_y = input.mouse.pos[:y]
+      mouse_y = input.mouse.pos.y
       can_capture = mouse_y >= (canvas.y || 0.0) && mouse_y <= (canvas.y || 0.0) + canvas.height
 
       hovered = false
@@ -100,7 +110,6 @@ module Hokusai
         while group = group_children.shift
           z = group.block.node.meta.get_prop(:z)&.to_i || 0
           ztarget = group.block.node.meta.get_prop(:ztarget)
-          entry = PainterEntry.new(group.block, group.x, group.y, group.w, group.h)
 
           if (zindex_counter > 0 || z > 0)
             case ztarget
@@ -108,12 +117,17 @@ module Hokusai
               entry = PainterEntry.new(group.block, zroot_x || 0.0, zroot_y || 0.0, zroot_w, zroot_h).freeze
             when ZTARGET_PARENT
               entry = PainterEntry.new(group.block, group_parent.x || 0.0, group_parent.y || 0.0, group_parent.w, group_parent.h).freeze
+            else
+              entry = PainterEntry.new(group.block, group.x, group.y, group.w, group.h).freeze
             end
+          else
+            entry = PainterEntry.new(group.block, group.x, group.y, group.w, group.h).freeze
           end
 
+
           canvas.reset(entry.x, entry.y, entry.w, entry.h)
 
-          before_render&.call([group.block, group.parent], canvas, input.raw)
+          before_render&.call([group.block, group.parent], canvas, input)
 
           if capture
             capture_events(group.block, canvas, hovered: hovered)
@@ -170,6 +184,12 @@ module Hokusai
         events[:mouseout].bubble
         events[:mousedown].bubble
         events[:mouseup].bubble
+
+        unless input.touch.nil?
+          events[:taphold].bubble
+          events[:pinch].bubble
+          events[:swipe].bubble
+        end
       end
 
       after_render&.call
@@ -247,10 +267,7 @@ module Hokusai
         return
       end
 
-      rect = canvas.to_hoku_rect
-      block_is_hovered = LibHokusai.hoku_input_is_hovered(input.raw, rect)
-
-      if block_is_hovered
+      if input.hovered?(canvas)
         events[:hover].capture(block, canvas)
         events[:click].capture(block, canvas)
         events[:wheel].capture(block, canvas)
@@ -261,10 +278,16 @@ module Hokusai
       end
       events[:mousemove].capture(block, canvas)
 
-      if block_is_hovered || block.node.meta.focused
+      if input.hovered?(canvas) || block.node.meta.focused || input.keyboard_override
         events[:keyup].capture(block, canvas)
         events[:keypress].capture(block, canvas)
       end
+
+      unless input.touch.nil?
+        events[:taphold].capture(block, canvas)
+        events[:pinch].capture(block, canvas)
+        events[:swipe].capture(block, canvas)
+      end
     end
   end
 end

data/ui/src/hokusai/types/display.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Hokusai
+    Outline = Struct.new(:top, :right, :bottom, :left) do
+    def self.default
+      new(0.0, 0.0, 0.0, 0.0)
+    end
+
+    def hash
+      [self.class, top, right, bottom, left].hash
+    end
+
+    def self.convert(value)
+      case value
+      when String
+        if value =~ /,/
+          convert(value.split(",").map(&:to_f))
+        else
+          convert(value.to_f)
+        end
+      when Float
+        new(value, value, value, value)
+      when Array
+        new(value[0] || 0.0, value[1] || 0.0, value[2] || 0.0, value[3] || 0.0)
+      when Outline
+        value
+      end
+    end
+
+    def present?
+      top > 0.0 || right > 0.0 || bottom > 0.0 || left > 0.0
+    end
+
+    def uniform?
+      top == right && top == bottom && top == left
+    end
+  end
+
+  class Padding
+    attr_reader :top, :left, :right, :bottom
+    def initialize(top, right, bottom, left)
+      @top = top
+      @left = left
+      @right = right
+      @bottom = bottom
+    end
+
+    alias_method :t, :top
+    alias_method :l, :left
+    alias_method :r, :right
+    alias_method :b, :bottom
+
+    def width
+      right + left
+    end
+
+    def height
+      top + bottom
+    end
+
+    def self.convert(value)
+      case value
+      when String
+        if value =~ /,/
+          convert(value.split(",").map(&:to_f))
+        else
+          convert(value.to_i)
+        end
+      when Integer
+        new(value, value, value, value)
+      when Array
+        new(value[0], value[1], value[2], value[3])
+      when Padding
+        value
+      else
+        raise Hokusai::Error.new("Unsupported conversion type #{value.class} for Hokusai::Padding")
+      end
+    end
+
+    def hash
+      [self.class, top, right, bottom, left].hash
+    end
+  end
+
+  class Canvas
+    attr_accessor :width, :height, :x, :y, :vertical, :reverse
+    def initialize(width, height, x = 0.0, y = 0.0, vertical = true, reverse = false)
+      @width = width
+      @height = height
+      @x = x
+      @y = y
+      @vertical = vertical
+      @reverse = reverse
+    end
+
+    def reset(x, y, width, height, vertical: true, reverse: false)
+      self.x = x
+      self.y = y
+      self.width = width
+      self.height = height
+      self.vertical = vertical
+      self.reverse = reverse
+    end
+
+    def to_bounds
+      Hokusai::Rect.new(x, y, width, height)
+    end
+
+    def hovered?(input)
+      input.hovered?(self)
+    end
+
+    def reverse?
+      reverse
+    end
+  end
+
+  # Color = Struct.new(:red, :green, :blue, :alpha) do
+  class Color
+    attr_accessor :red, :green, :blue, :alpha
+    def initialize(red, green, blue, alpha = 255)
+      @red = red.freeze
+      @green = green.freeze
+      @blue = blue.freeze
+      @alpha = alpha.freeze
+    end
+
+    alias_method :r, :red
+    alias_method :b, :blue
+    alias_method :g, :green
+    alias_method :a, :alpha
+
+    def self.convert(value)
+      case value
+      when String
+        value = value.split(",").map(&:to_i)
+      when Array
+      when Color
+        return value
+      else
+        raise Hokusai::Error.new("Unsupported conversion type #{value.class} for Hokusai::Color")
+      end
+
+      new(value[0], value[1], value[2], value[3] || 255)
+    end
+
+    def to_shader_value
+      [(r / 255.0), (g / 255.0), (b / 255.0), (a / 255.0)]
+    end
+
+    def hash
+      [self.class, r, g, b, a].hash
+    end
+  end
+end

data/ui/src/hokusai/types/keyboard.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Hokusai
+  KEY_CODES = { 
+    null: 0, apostrophe: 39, comma: 44, minus: 45, period: 46,
+    slash: 47, zero: 48, one: 49, two: 50, three: 51, four: 52,
+    five: 53, six: 54, seven: 55, eight: 56, nine: 57, semicolon: 59, 
+    equal: 61, a: 65, b: 66, c: 67, d: 68, e: 69, f: 70, g: 71, h: 72, 
+    i: 73, j: 74, k: 75, l: 76, m: 77, n: 78, o: 79, p: 80, q: 81, r: 82, 
+    s: 83, t: 84, u: 85, v: 86, w: 87, x: 88, y: 89, z: 90, left_bracket: 91, 
+    backslash: 92, right_bracket: 93, grave: 96, space: 32, escape: 256, 
+    enter: 257, tab: 258, backspace: 259, insert: 260, delete: 261, right: 262, 
+    left: 263, down: 264, up: 265, page_up: 266, page_down: 267, home: 268, end: 269, 
+    caps_lock: 280, scroll_lock: 281, num_lock: 282, print_screen: 283, pause: 284, 
+    f1: 290, f2: 291, f3: 292, f4: 293, f5: 294, f6: 295, f7: 296, f8: 297, 
+    f9: 298, f10: 299, f11: 300, f12: 301, left_shift: 340, left_control: 341, 
+    left_alt: 342, left_super: 343, right_shift: 344, right_control: 345, right_alt: 346, 
+    right_super: 347, kb_menu: 348, kp_0: 320, kp_1: 321, kp_2: 322, kp_3: 323, 
+    kp_4: 324, kp_5: 325, kp_6: 326, kp_7: 327, kp_8: 328, kp_9: 329, kp_decimal: 330, 
+    kp_divide: 331, kp_multiply: 332, kp_subtract: 333, kp_add: 334, kp_enter: 335, 
+    kp_equal: 336, back: 4, menu: 5, volume_up: 24, volume_down: 25
+  }
+
+  class Keyboard
+    attr_accessor :shift, :control, :super, :alt
+    attr_reader :keys, :pressed, :released
+
+    def initialize
+      @shift = false
+      @control = false
+      @super = false
+      @alt = false
+
+      @keys = {}
+      @pressed = []
+      @released = []
+
+      # populate the key states
+      KEY_CODES.each do |symbol, code|
+        @keys[symbol] = { code: code, symbol: symbol, up: false, down: false, pressed: false, released: false }
+      end
+    end
+
+    def code
+      pressed[0]&.[](:code)
+    end
+
+    def char
+      pressed[0]&.[](:char)
+    end
+
+    def ctrl
+      @control
+    end
+
+    def reset
+      @pressed.clear
+      @released.clear
+      
+      @shift = false
+      @control = false
+      @super = false
+      @alt = false
+    end
+
+
+    def key_is_letter?(symbol)
+      symbol == :a || symbol == :b || symbol == :c || symbol == :d ||
+      symbol == :e || symbol == :f || symbol == :g || symbol == :h ||
+      symbol == :i || symbol == :j || symbol == :k || symbol == :l ||
+      symbol == :m || symbol == :n || symbol == :o || symbol == :p || 
+      symbol == :q || symbol == :r || symbol == :s || symbol == :t ||
+      symbol == :u || symbol == :v || symbol == :w || symbol == :x ||
+      symbol == :y || symbol == :z
+    end
+
+    def char_code_from_key(key, shift)
+      code = keys[key][:code]
+
+      if !shift && key_is_letter?(key)
+        code += 32 
+      elsif shift && key == :apostrophe
+        code = 34
+      elsif shift && key == :comma
+        code = 60
+      elsif shift && key == :minus
+        code = 95
+      elsif shift && key == :period
+        code = 62
+      elsif shift && key == :slash
+        code = 63
+      elsif shift && key == :zero
+        code = 41
+      elsif shift && key == :one
+        code = 33
+      elsif shift && key == :two
+        code = 64
+      elsif shift && key == :three
+        code = 35
+      elsif shift && key == :four
+        code = 36
+      elsif shift && key == :five
+        code = 37
+      elsif shift && key == :six
+        code = 94
+      elsif shift && key == :seven
+        code = 38
+      elsif shift && key == :eight
+        code = 42
+      elsif shift && key == :nine
+        code = 40
+      elsif shift && key == :semicolon
+        code = 58
+      elsif shift && key == :equal
+        code = 43
+      elsif shift && key == :left_bracket
+        code = 123
+      elsif shift && key == :backslash
+        code = 124
+      elsif shift && key == :right_bracket
+        code = 125
+      elsif shift && key == :grave
+        code = 126
+      end
+
+      return code if code <= 256
+    end
+
+    def set(key, down)
+      if down
+        case key
+        when :left_shift, :right_shift
+          @shift = true
+        when :left_control, :right_control
+          @control = true
+        when :left_super, :right_super
+          @super = true
+        when :left_alt, :right_alt
+          @alt = true
+        end
+      end
+
+      if down && keys[key][:up]
+        keys[key][:pressed] = true
+        keys[key][:released]= false
+
+        nkey = keys[key].dup
+        nkey.merge!({ char: char_code_from_key(key, shift)&.chr })
+        
+        pressed << nkey
+      elsif !down && keys[key][:down]
+        keys[key][:pressed] = false
+        keys[key][:released] = true
+
+        nkey = keys[key].dup
+        nkey.merge!({ char: char_code_from_key(key, shift)&.chr })
+
+        released << nkey
+      else
+        keys[key][:pressed] = false
+        keys[key][:released] = false
+      end
+
+      keys[key][:down] = down
+      keys[key][:up] = !down
+    end
+  end
+end

data/ui/src/hokusai/types/mouse.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Hokusai
+  class MouseButton
+    attr_accessor :up, :down, :clicked, :released
+
+    def initialize
+      @up = false
+      @down = false
+      @clicked = false
+      @released = false
+    end
+  end
+
+  class Mouse
+    attr_reader :pos, :delta, :left, :right, :middle, :scroll
+    attr_accessor :scroll_delta
+
+    def initialize
+      @pos = Vec2.new(0.0, 0.0)
+      @delta = Vec2.new(0.0, 0.0)
+      @scroll = 0.0
+      @scroll_delta = 0.0
+      @left = MouseButton.new
+      @middle = MouseButton.new
+      @right = MouseButton.new
+    end
+
+    def scroll=(val)
+      last = scroll
+      new_y = (last >= val) ? last - val : val - last
+      self.scroll_delta = new_y
+      @scroll = val
+    end
+  end
+end

data/ui/src/hokusai/types/primitives.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Hokusai
+  class Vec2
+    attr_accessor :x, :y
+    def initialize(x, y)
+      @x = x
+      @y = y
+    end
+  end
+
+  class Rect
+    attr_accessor :x, :y, :width, :height
+
+    def initialize(x, y, width, height)
+      @x = x
+      @y = y
+      @width = width
+      @height = height
+    end
+    def to_hoku_rect
+      @hoku_rect ||= LibHokusai::HmlRect.create(x, y, width, height)
+    end
+
+    def includes_y?(y)
+      LibHokusai.hoku_rect_includes_y(to_hoku_rect, y)
+    end
+
+    def includes_x?(x)
+      LibHokusai.hoku_rect_includes_x(to_hoku_rect, x)
+    end
+
+    def move_x_left(times = 1)
+      LibHokusai.hoku_rect_x_left(to_hoku_rect, times)
+    end
+
+    def move_x_right(times = 1)
+      LibHokusai.hoku_rect_x_right(to_hoku_rect, times)
+    end
+
+    def move_y_up(times = 1)
+      LibHokusai.hoku_rect_y_up(to_hoku_rect, times)
+    end
+
+    def move_y_down(times = 1)
+      LibHokusai.hoku_rect_y_down(to_hoku_rect, times)
+    end
+
+    def self.from_hoku_rect(rect)
+      self.x = rect[:x]
+      self.y = rect[:y]
+      self.width = rect[:w]
+      self.height = rect[:h]
+    end
+  end
+end

data/ui/src/hokusai/types/touch.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Hokusai
+  class Touch
+    attr_accessor :stack, :archive
+
+    def initialize
+      @stack = []
+      @archive = []
+      @tapped = false
+      @swiped = false
+      @pinched = false
+      # @file = File.open("touch.log", "w")
+    end
+
+    def tapped?
+      @tapped
+    end
+
+    def swiped?
+      @swiped
+    end
+
+    def pinched?
+      @pinched
+    end
+
+    def longtapping?(stuff = "ok")
+      log("#{touching?} - #{elapsed(token)} - #{stuff}") if touching?
+      touching? && elapsed(token) > 5
+    end
+    
+    def longtapped?
+      @longtapped
+    end
+
+    def touching?
+      type == :down || type == :move
+    end
+
+    def duration
+      if longtapping?
+        return elapsed(token)
+      end
+      
+      first, last = archive[-2..-1]
+
+      last[:start] - first[:start]
+    end
+
+    def distance
+      raise Hokusai::Error.new("Archive is empty") if archive.empty?
+      first, last = archive[-2..-1]
+      
+      x = last[:x] - first[:x]
+      y = last[:y] - first[:y]
+
+      [x, y]
+    end
+
+    def direction
+      raise Hokusai::Error.new("Archive is empty") if archive.empty?
+
+      first, last = archive[-2..-1]
+      
+      x = last[:x] - first[:x]
+      y = last[:y] - first[:y]
+
+      if x.abs > y.abs
+        # swiping left/right
+        last[:x] > first[:x] ? :right : :left
+      else
+        # swiping up/down
+        last[:y] > first[:y] ? :down : :up
+      end
+    end
+
+    def angle
+      raise Hokusai::Error.new("Archive is empty") if archive.empty?
+
+      last, first = archive[-2..-1]
+      
+      x = last[:x] - first[:x]
+      y = last[:y] - first[:y]
+
+      (Math.atan2(x, y) * (-180 / Math::PI)).round(0).to_i
+    end
+
+    def log(str)
+      # Thread.new do
+      #   @file.write_nonblock("#{str}\n")
+      # end
+    end
+
+    def record(finger, x, y)
+      log("recording #{token}")
+      if type == :down
+        push(:move, finger, x, y)
+        log("state is move")
+      elsif type == :move
+        stack.last[:x] = x
+        stack.last[:y] = y
+        
+        log("updated state move")
+      else 
+        @longtapped = false
+        @swiped = false
+        @tapped = false
+        push(:down, finger, x, y)
+        log("state is down")
+      end
+    end
+
+    def clear
+      # log("clearing")
+      if type == :move
+        log("elapsed: #{elapsed(token)}")
+        if elapsed(token) > 300 && within(10.0)
+          @longtapped = true
+          log('longtap')
+        elsif within(10.0)
+          @tapped = true
+        else
+          @swiped = true
+          log('swipe')
+        end
+      elsif type == :down
+        @tapped = true
+        log('tap')
+      else
+        @longtapped = false
+        @swiped = false
+        @tapped = false
+      end
+
+      self.archive = stack.dup
+      stack.clear
+    end
+
+    def elapsed(token)
+      Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) - token[:start]
+    end
+
+    def within(threshold)
+      move = stack.last
+      down = stack[-2]
+
+      t1 = (move[:x] - down[:x]).abs
+      t2 = (move[:y] - down[:y]).abs
+
+      t1 < threshold && t2 < threshold
+    end
+
+    def pop
+      stack.pop
+    end
+
+    def push(type, finger, x, y)
+      log("push: #{type}")
+      stack << {
+        type: type,
+        i: finger,
+        x: x,
+        y: y,
+        start: Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+      }
+    end
+
+    def index
+      token&.[](:finger)
+    end
+
+    def type
+      token&.[](:type)
+    end
+
+    def token
+      @stack.last
+    end
+  end
+end