hokusai-zero 0.2.6.pre.pinephone4 → 0.2.6.pre.pinephone6

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

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 module Hokusai
   class KeyboardEvent < Event
     extend Forwardable
 
     def_delegators :@keyboard, :shift, :super, :ctrl,
-                   :alt, :pressed, :pressed_len, :released,
-                   :released_len
+                   :alt, :pressed, :released, :char, :code
 
     attr_reader :input
 
@@ -35,48 +36,40 @@ module Hokusai
   class KeyUpEvent < KeyboardEvent
     name "keyup"
 
-    def keyboard_key
-      input.raw[:keyboard][:released]
-    end
-
     def key
-      keyboard_key[:key][:key]
+      released[0]&.[](:symbol)
     end
 
     def code
-      keyboard_key[:char_code]
+      released[0]&.[](:code)
     end
 
     def char
-      code.chr
+      released[0]&.[](:char)
     end
 
     def capture(block, _)
-      captures << block if matches(block) && released_len > 0
+      captures << block if matches(block) && released.size > 0
     end
   end
 
   class KeyPressEvent < KeyboardEvent
     name "keypress"
 
-    def keyboard_key
-      input.raw[:keyboard][:pressed]
-    end
-
     def key
-      keyboard_key[:key][:key]
+      pressed[0]&.[](:symbol)
     end
 
     def code
-      keyboard_key[:char_code]
+      pressed[0]&.[](:code)
     end
 
     def char
-      code.chr
+      pressed[0]&.[](:char)
     end
 
     def capture(block, _)
-      return unless matches(block) && pressed_len > 0
+      return unless matches(block) && pressed.size > 0
 
       captures << block
     end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Hokusai
   class TouchEvent < Event
     extend Forwardable

data/ui/src/hokusai/painter.rb

@@ -96,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
@@ -127,7 +127,7 @@ module Hokusai
 
           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)
@@ -267,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)
@@ -281,7 +278,7 @@ module Hokusai
       end
       events[:mousemove].capture(block, canvas)
 
-      if block_is_hovered || block.node.meta.focused || input.keyboard_override
+      if input.hovered?(canvas) || block.node.meta.focused || input.keyboard_override
         events[:keyup].capture(block, canvas)
         events[:keypress].capture(block, canvas)
       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

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