hokusai-zero 0.2.6 → 0.2.7

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Hokusai
   class MouseEvent < Event
     extend Forwardable
@@ -67,7 +69,7 @@ module Hokusai
     protected
 
     def hovered(canvas)
-      LibHokusai.hoku_input_is_hovered(input.raw, canvas.to_hoku_rect)
+      input.hovered?(canvas)
     end
   end
 
@@ -85,19 +87,19 @@ module Hokusai
     name "click"
 
     def capture(block, canvas)
-      if left[:clicked] && clicked(canvas)
+      if left.clicked && clicked(canvas)
         block.node.meta.focus
 
         if matches(block)
           captures << block
         end
-      elsif left[:clicked]
+      elsif left.clicked
         block.node.meta.blur
       end
     end
 
     def clicked(canvas)
-      LibHokusai.hoku_input_is_clicked(input.raw, canvas.to_hoku_rect)
+      left.clicked && input.hovered?(canvas)
     end
   end
 
@@ -105,7 +107,7 @@ module Hokusai
     name "mouseup"
 
     def capture(block, _)
-      if left[:up] && matches(block)
+      if left.up && matches(block)
         captures << block
       end
     end
@@ -115,7 +117,7 @@ module Hokusai
     name "mousedown"
 
     def capture(block, _)
-      if left[:down] && matches(block)
+      if left.down && matches(block)
         captures << block
       end
     end
@@ -168,13 +170,13 @@ module Hokusai
     def capture(block, canvas)
       captures << block if matches(block)
 
-      if left[:clicked] && !clicked(canvas)
+      if left.clicked && !clicked(canvas)
         block.node.meta.blur
       end
     end
 
     def clicked(canvas)
-      LibHokusai.hoku_input_is_clicked(input.raw, canvas.to_hoku_rect)
+      left.clicked && input.hovered?(canvas)
     end
   end
 end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Hokusai
+  class TouchEvent < Event
+    extend Forwardable
+
+    def_delegators :@touch, :tapped?, :swiped?, :longtapped?, :longtapping?, :touching?,
+                   :duration, :direction, :distance, :angle, :position, :last_position,
+                   :touch_len, :touch_count, :timer
+
+    attr_reader :input
+
+    def initialize(input, state)
+      @input = input
+      @state = state
+      @touch = input.touch
+    end
+
+    def hovered(canvas)
+      input.hovered?(canvas)
+    end
+
+    def to_json
+      {
+        keypress: {
+          hold: hold,
+          hold_duration: hold_duration.to_s,
+        }
+      }.to_json
+    end
+  end
+
+  class TapHoldEvent < TouchEvent
+    name "taphold"
+
+    def capture(block, canvas)
+      if matches(block) && longtapped? && hovered(canvas) 
+        captures << block
+      end
+    end
+  end
+
+  class PinchEvent < TouchEvent
+    name "pinch"
+
+    def capture(block, canvas)
+      if false && matches(block)
+        captures << block
+      end
+    end
+  end
+
+  class SwipeEvent < TouchEvent
+    name "swipe"
+
+    def capture(block, canvas)
+      if swiped? && matches(block)
+        captures << block
+      end
+    end
+  end
+end

data/ui/src/hokusai/meta.rb

@@ -118,10 +118,15 @@ module Hokusai
         child.update
       end
     end
-
-    def has_ast?(ast, index)
-      if portal = children![index]&.node&.portal&.portal
-        return portal.ast.object_id == ast.object_id
+    def has_ast?(ast, index, elsy = false)
+      if elsy
+        if portal = children![index]&.node&.portal
+          return portal.ast.object_id == ast.object_id
+        end
+      else
+        if portal = children![index]&.node&.portal&.portal
+          return portal.ast.object_id == ast.object_id
+        end
       end
 
       false

data/ui/src/hokusai/mounting/loop_entry.rb

@@ -65,7 +65,7 @@ module Hokusai
 
           portal = Node.new(ast)
           node = child_block_class.compile(ast.type, portal)
-          child_block = child_block_class.new(node: node)
+          child_block = child_block_class.new(node: node, providers: mount_providers)
           child_block.node.add_styles(target.class)
           child_block.node.add_props_from_block(target, context: ctx)
           child_block.node.meta.set_prop(ast.loop.var.to_sym, value)

data/ui/src/hokusai/mounting/update_entry.rb

@@ -19,8 +19,8 @@ module Hokusai
             portal.ast.children.each_with_index do |child, index|
               next unless child.has_if_condition?
 
-              child_present = ->(child) do
-                meta.has_ast?(child, index)
+              child_present = ->(child, elsy) do
+                meta.has_ast?(child, index, elsy)
               end 
 
               if child.if.args.size > 0
@@ -33,11 +33,11 @@ module Hokusai
 
               if !!visible
                 if child.else_condition_active?
-                  meta.child_delete(index) if child_present.call(child)
+                  meta.child_delete(index) if child_present.call(child, false)
                   child.else_active = 0
                 end
 
-                unless child_present.call(child)
+                unless child_present.call(child, true)
                   portal = Node.new(child, Node.new(child))
                   node = child_block_klass.compile("root", portal)
                   node.add_styles(target.class)
@@ -52,8 +52,9 @@ module Hokusai
                   child_block = NodeMounter.new(node, child_block_klass, [stack], previous_providers: providers).mount(context: context, providers: providers)
 
                   UpdateEntry.new(child_block, block, target).register(context: context, providers: providers)
-                  
+                  pp [meta.has_ast?(child, index, false), "shouldn't be here?"]
                   meta.children!.insert(index, child_block)
+                  pp ["children", meta.children!.size, meta.children!.map(&:class)]
 
                   child_block.public_send(:before_updated) if child_block.respond_to?(:before_updated)
                   child_block.update
@@ -61,7 +62,7 @@ module Hokusai
                 end
               elsif !visible
                 if !child.has_else_condition? || (child.has_else_condition? && !child.else_condition_active?)
-                  if (child_present.call(child))
+                  if (child_present.call(child, true))
                     meta.child_delete(index)
                   end
                 end

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,151 @@
+# 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_reader :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 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