hokusai-zero 0.2.6.pre.pinephone3 → 0.2.6.pre.pinephone5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2b53ce8769964539f51ad894c33476cecb01095b7b5ce851355cbf7df17a707
-  data.tar.gz: 430de1cd6a0ffae61fdf9ca547b15aa61e0065769f94472962047c0205df83ff
+  metadata.gz: db63632b958a6ee6aaa4322f1e8737f74a74167df845dbbc01b167fc73907305
+  data.tar.gz: 0cceed2907fdf38549b34ddd77e6503a9c504a3b1c6fbc6a14d3adfdab2984a8
 SHA512:
-  metadata.gz: d571179fb72b52671eafceed834e76c7154e205faaff5bb67a95d7d1eb801c86d34f6e5525ade0247db57e48c3019098744dbef7d704630fc4ea7b7577854ab4
-  data.tar.gz: '082837551a6b0ff70eda1779c4bde8232efe3108dad48359a05f597023895250faa07812878367229da734075bb0fb1c5c2ab180820b06e4040f7569fdb87306'
+  metadata.gz: 277ef8ae488facee7aa4b43e25c7ea0e704343d0364dd2607eeb106deebf3b9529dcdfcd7672d3f291c2598821f6841ee4eac56c9f5b6026115a6e77a1887621
+  data.tar.gz: 0cce59cf2eaa17ff83d3e63f0c77ef7bd3acc8db4d4b07e2fbc0c28fc6f650dd9d7a5d6aa7614e10d07691211c12440be9f1476018b80efaf6688b24694de027

data/hokusai.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'hokusai-zero'
-  s.version     = '0.2.6-pinephone3'
+  s.version     = '0.2.6-pinephone5'
   s.licenses    = ['MIT']
   s.summary     = "A Ruby library for writing GUI applications"
   s.authors     = ["skinnyjames"]

data/ui/examples/keyboard.rb

@@ -40,7 +40,7 @@ class KeyboardExample < Hokusai::Block
   end
 end
 
-Hokusai::Backends::SDLBackend.run(KeyboardExample) do |config|
+Hokusai::Backends::RaylibBackend.run(KeyboardExample) do |config|
   config.width = 370
   config.height = 680
   config.title = "keyboard example"

data/ui/src/hokusai/backends/raylib/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, :touch
 
     def initialize
       @width = 500
@@ -22,6 +22,7 @@ module Hokusai::Backends
       @automated = false
       @on_reload = ->(_){}
       @event_waiting = false
+      @touch = false
     end
 
     def start_automation_driver

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

@@ -113,22 +113,58 @@ module Hokusai::Backends
     end
 
     def process_input(input)
-      raylib_mouse_pos = Raylib.GetMousePosition
-      raylib_mouse_delta = Raylib.GetMouseDelta
-      LibHokusai.hoku_input_mouse_set_scroll(input.raw, Raylib.GetMouseWheelMove)
-      LibHokusai.hoku_input_set_mouse_position(input.raw, hml_vec2(raylib_mouse_pos.x, raylib_mouse_pos.y))
+      if !config.touch
+        raylib_mouse_pos = Raylib.GetMousePosition
+        raylib_mouse_delta = Raylib.GetMouseDelta
+
+        input.mouse.pos.x = raylib_mouse_pos.x
+        input.mouse.pos.y = raylib_mouse_pos.y
+        input.mouse.delta.x = raylib_mouse_delta.x
+        input.mouse.delta.y = raylib_mouse_delta.y
+        input.mouse.scroll = Raylib.GetMouseWheelMove
+      end
+
+      if config.touch
+        count = Raylib.GetTouchPointCount
+        if count > 0
+          vec = Raylib.GetTouchPosition(0)
+          unless vec.x.zero? && vec.y.zero?
+            input.touch.record(0, vec.x, vec.y)
+          end
+        else
+          input.touch.clear
+        end
+      else
+         {left: 0, middle: 1, right: 2}.each do |key, button_id|
+
+          button = input.mouse.public_send(key)
+          button.clicked = Raylib.IsMouseButtonPressed(button_id)
+          button.down = Raylib.IsMouseButtonDown(button_id)
+          button.released = Raylib.IsMouseButtonReleased(button_id)
+          button.up = Raylib.IsMouseButtonUp(button_id)
+        end
+      end
 
-      input.raw[:mouse][:delta][:x] = raylib_mouse_delta.x
-      input.raw[:mouse][:delta][:y] = raylib_mouse_delta.y
+      if config.touch
+        if input.touch.touching?
+          token = input.touch.token
 
-      [0,1,2].each do |button_id|
-        clicked = Raylib.IsMouseButtonPressed(button_id)
-        down = Raylib.IsMouseButtonDown(button_id)
-        released = Raylib.IsMouseButtonReleased(button_id)
-        up = Raylib.IsMouseButtonUp(button_id)
+          input.mouse.pos.x = token[:x]
+          input.mouse.pos.y = token[:y]
+        end
 
-        button = mouse_button(clicked: clicked, down: down, released: released, up: up)
-        LibHokusai.hoku_input_mouse_set_button(input.raw, button, button_id)
+        # translate taps to clicks
+        if input.touch.tapped?
+          input.mouse.left.clicked = true
+          input.mouse.left.down = true
+          input.mouse.left.released = false
+          input.mouse.left.up = false
+        else
+          input.mouse.left.clicked = true
+          input.mouse.left.down = true
+          input.mouse.left.released = false
+          input.mouse.left.up = false
+        end
       end
 
       if !input.keyboard_override
@@ -155,7 +191,6 @@ module Hokusai::Backends
       self.class.reset
 
       Raylib.load_lib(RAYLIB_PATH)
-
       resize = false
       initial = true
       width = config.width
@@ -168,6 +203,7 @@ module Hokusai::Backends
       raw = LibHokusai::HmlInput.new(ptr.get_pointer(0))
       input = Hokusai::Input.new(raw)
       ptr.free
+      input.support_touch! if config.touch
 
       Raylib.SetConfigFlags(config.config_flags)
       Raylib.InitWindow(config.width, config.height, config.title)
@@ -221,7 +257,7 @@ module Hokusai::Backends
         block.update
         block.public_send(:after_updated) if block.respond_to?(:after_updated)
 
-        canvas.reset(nil, nil, width.to_f, height.to_f)
+        canvas.reset(0.0, 0.0, width.to_f, height.to_f)
 
         Raylib.BeginDrawing
         Raylib.ClearBackground(config.background)
@@ -245,7 +281,6 @@ module Hokusai::Backends
         Raylib.DrawFPS(10, 10) if ENV["PROFILE"] || ENV["FPS"]
         Raylib.EndDrawing
 
-
         break if self.class.stopped?
       end
 
@@ -351,14 +386,6 @@ module Hokusai::Backends
         Raylib.MinimizeWindow
       end
 
-      # Hokusai.on_set_shader_value do |location, value, type|
-      #   Raylib.SetShaderValue(@shader, location, value, type)
-      # end
-
-      # Hokusai.on_shader_location do |name|
-      #   Raylib.GetShaderLocation(@shader, name)
-      # end
-
       Hokusai.on_renderable do |canvas|
         inside_scissor(canvas.x, canvas.y, canvas.height)
       end

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

@@ -162,7 +162,7 @@ module Hokusai::Backends
         SDL.SetRenderDrawBlendMode(renderer, SDL::BLENDMODE_BLEND)
         SDL.SetRenderDrawColor(renderer, config.background[:r], config.background[:g], config.background[:b], config.background[:a])
         SDL.RenderClear(renderer)
-        canvas.reset(nil, nil, render_width.to_f, render_height.to_f)
+        canvas.reset(0.0, 0.0, render_width.to_f, render_height.to_f)
         painter = Hokusai::Painter.new(block, input)
         painter.render(canvas, resize)
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Hokusai::Blocks
   class Key < Hokusai::Block
     template <<~EOF
@@ -12,17 +14,21 @@ module Hokusai::Blocks
     uses(empty: Hokusai::Blocks::Empty)
 
     computed! :value
-    computed! :icons
     computed :size, default: 24, convert: proc(&:to_i)
     computed :background, default: Hokusai::Color.new(70, 70, 70), convert: Hokusai::Color
     computed :color, default: Hokusai::Color.new(244, 244, 244), convert: Hokusai::Color
     computed :background_down, default: Hokusai::Color.new(33,33,33), convert: Hokusai::Color
     computed :margin, default: Hokusai::Padding.new(3.0, 2.5, 3.0, 2.5), convert: Hokusai::Padding
 
-    attr_accessor :down
+    inject :keyboard_icons
+
+    attr_accessor :down, :last_commands, :last_canvas, :last_value
 
     def initialize(**args)
       @down = false
+      @last_commands = []
+      @last_canvas = nil
+      @last_value = nil
 
       super
     end
@@ -47,25 +53,44 @@ module Hokusai::Blocks
       vpad = (canvas.height - margin.height - size) / 2
 
       draw do
-        if icon = icons[value[0]]
-          rect(canvas.x + margin.left, canvas.y + margin.top, canvas.width - margin.width, canvas.height - margin.height) do |command|
-            command.color = icon[:background]# down ? background_down : background
-            command.round = 6.0
-          end
+        if last_canvas != canvas && last_value != value
+          self.last_value = value
+          self.last_canvas = canvas
 
-          svg(icon[:file], canvas.x + icon[:size] / 3, canvas.y + icon[:size] / 3, icon[:size], icon[:size]) do |command|
-            command.color = icon[:color]
-          end
-        else
-          rect(canvas.x + margin.left, canvas.y + margin.top, canvas.width - margin.width, canvas.height - margin.height) do |command|
-            command.color = down ? background_down : background
-            command.round = 6.0
-          end
+          if icon = keyboard_icons[value[0]]
+            if icon[:width]
+              node.meta.set_prop(:width, icon[:width])
+            end
+
+            rect(canvas.x + margin.left, canvas.y + margin.top, canvas.width - margin.width, canvas.height - margin.height) do |command|
+              command.color = icon[:background]# down ? background_down : background
+              command.round = 0.2
+
+              last_commands << command
+            end
+
+            svg(icon[:file], canvas.x + icon[:size] / 3, canvas.y + icon[:size] / 3, icon[:size], icon[:size]) do |command|
+              command.color = icon[:color]
+
+              last_commands << command
+            end
+          else
+            rect(canvas.x + margin.left, canvas.y + margin.top, canvas.width - margin.width, canvas.height - margin.height) do |command|
+              command.color = down ? background_down : background
+              command.round = 0.2
 
-          text(value[1].to_s, canvas.x + hpad + margin.width, canvas.y + margin.height) do |command|
-            command.color = color
-            command.size = size
+              last_commands << command
+            end
+
+            text(value[1].to_s, canvas.x + hpad + margin.width, canvas.y + margin.height) do |command|
+              command.color = color
+              command.size = size
+
+              last_commands << command
+            end
           end
+        else
+          queue.concat(last_commands)
         end
       end
 
@@ -92,9 +117,7 @@ module Hokusai::Blocks
         [for="number in keys"]
           key {
             ...keyStyle
-            :width="width(number)"
-            :icons="icons"
-            :key="loop_key(number)"
+            :key="index"
             :value="number"
             @clicked="emit_key"
             @released="emit_released"
@@ -108,20 +131,12 @@ module Hokusai::Blocks
     )
 
     computed! :keys
-    computed! :icons
 
-    # def on_mounted
-    #   node.meta.set_prop(:height, 48.0)
-    # end
-
-    def width(key)
-      if icon = icons[key[0]]
-        icon[:width]
-      end
-    end
+    inject :keyboard_icons
 
     def loop_key(value)
-      "key-#{value}"
+      @keys ||= {}
+      @keys[value] ||= "key-#{value}".freeze
     end
     
     def emit_key(key, event)
@@ -160,8 +175,7 @@ module Hokusai::Blocks
       row: KeyboardRow
     )
 
-
-    def self.icons
+    def icons
       {
         :shift => { 
           file: Hokusai.asset("icons/outline/arrow-big-up.svg"),
@@ -180,9 +194,10 @@ module Hokusai::Blocks
       }
     end
 
-    computed :icons, default: icons
     computed :row_height, default: 48.0, convert: proc(&:to_f)
 
+    provide :keyboard_icons, :icons
+
     def on_mounted
       node.meta.set_prop(:height, row_height * 5.0 + 20)
     end
@@ -210,8 +225,8 @@ module Hokusai::Blocks
       @zxcv_keys ||= begin
         keys = %w[z x c v b n m]
         middle = keys.zip(keys)
-        middle << [:backspace, :backspace]
-        middle.unshift([:shift, :shift])
+        # middle << [:backspace, :backspace]
+        # middle.unshift([:shift, :shift])
         middle
       end
     end

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

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

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/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/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
@@ -110,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
@@ -118,9 +117,14 @@ 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)
@@ -263,10 +267,12 @@ module Hokusai
         return
       end
 
-      rect = canvas.to_hoku_rect
-      block_is_hovered = LibHokusai.hoku_input_is_hovered(input.raw, rect)
+      
+
+      # 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)
@@ -277,7 +283,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/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

data/ui/src/hokusai/types.rb

@@ -1,200 +1,11 @@
 # frozen_string_literal: true
 
-module Hokusai
-  # Rect = Struct.new(:x, :y, :width, :height) do
-  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
-
-  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 reverse?
-      reverse
-    end
-
-    def to_hoku_rect
-      LibHokusai::HmlRect.create(x, y, width, height)
-    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
+require_relative "./types/primitives"
+require_relative "./types/display"
+require_relative "./types/touch"
+require_relative "./types/mouse"
 
+module Hokusai
   class Keyboard
     attr_reader :raw
 
@@ -221,208 +32,6 @@ module Hokusai
     end
   end
 
-  class Mouse
-    attr_reader :raw
-
-    def initialize(raw)
-      @raw = raw
-    end
-
-    [
-      :pos, :delta, :scroll,
-      :scroll_delta, :selection,
-      :selection_type, :left,
-      :middle, :right
-    ].each do |name|
-      define_method(name) do
-        # instance_variable_set("@#{name}", raw[name]) if instance_variable_get("@#{name}").nil?
-        #
-        # instance_variable_get("@#{name}")
-
-        raw[name]
-      end
-
-      define_method("#{name}=") do |val|
-        raw[name] = val
-      end
-    end
-  end
-
-  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) > 0.05 && within(10.0)
-          @longtapped = true
-          log('longtap')
-        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
-
   class Input
     attr_accessor :keyboard_override
     attr_reader :raw, :touch
@@ -448,11 +57,12 @@ module Hokusai
     end
 
     def mouse
-      @mouse ||= Mouse.new(@raw[:mouse])
+      @mouse ||= Mouse.new
     end
 
     def hovered?(canvas)
-      LibHokusai.hoku_input_is_hovered(raw, canvas.to_hoku_rect)
+      pos = mouse.pos
+      pos.x >= canvas.x && pos.x <= canvas.x + canvas.width && pos.y >= canvas.y && pos.y <= canvas.y + canvas.height
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hokusai-zero
 version: !ruby/object:Gem::Version
-  version: 0.2.6.pre.pinephone3
+  version: 0.2.6.pre.pinephone5
 platform: ruby
 authors:
 - skinnyjames
@@ -292,6 +292,10 @@ files:
 - ui/src/hokusai/publisher.rb
 - ui/src/hokusai/style.rb
 - ui/src/hokusai/types.rb
+- ui/src/hokusai/types/display.rb
+- ui/src/hokusai/types/mouse.rb
+- ui/src/hokusai/types/primitives.rb
+- ui/src/hokusai/types/touch.rb
 - ui/src/hokusai/util/clamping_iterator.rb
 - ui/src/hokusai/util/piece_table.rb
 - ui/src/hokusai/util/selection.rb