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

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,435 +1,12 @@
 # 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
-      @hoku_rect = LibHokusai::HmlRect.create(x, y, width, height)
-    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
-      @hoku_rect[:x] = x
-      @hoku_rect[:y] = y
-      @hoku_rect[:w] = width
-      @hoku_rect[:h] = height
-    end
-
-    def to_bounds
-      Hokusai::Rect.new(x, y, width, height)
-    end
-
-    def reverse?
-      reverse
-    end
-
-    def to_hoku_rect
-      @hoku_rect
-    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
-
-  class Keyboard
-    attr_reader :raw
-
-    [
-      :shift, :super, :ctrl,
-      :alt, :pressed, :pressed_len, :released,
-      :released_len
-    ].each do |name|
-      define_method(name) do
-        raw[name]
-      end
-    end
-
-    def keyboard_key
-      pressed.read_array_of_type(TYPE_UINT8, :read_uint8, pressed_len).first
-    end
-
-    def key
-      keyboard_key[:key][:key]
-    end
-
-    def initialize(raw)
-      @raw = raw
-    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) > 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
+require_relative "./types/primitives"
+require_relative "./types/display"
+require_relative "./types/touch"
+require_relative "./types/mouse"
+require_relative "./types/keyboard"
 
+module Hokusai
   class Input
     attr_accessor :keyboard_override
     attr_reader :raw, :touch
@@ -438,8 +15,7 @@ module Hokusai
       [self.class, mouse.pos.x, mouse.pos.y, mouse.scroll, mouse.left.clicked, mouse.left.down, mouse.left.up].hash
     end
 
-    def initialize(raw)
-      @raw = raw
+    def initialize
       @touch = nil
       @keyboard_override = false
     end
@@ -451,15 +27,16 @@ module Hokusai
     end
 
     def keyboard
-      Keyboard.new(@raw[:keyboard])
+      @keyboard ||= Keyboard.new
     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

data/ui/src/hokusai/util/wrap_stream.rb

@@ -1,7 +1,3 @@
-require "rouge"
-require "hokusai"
-require_relative "./lib/hokusai_code/formatter"
-
 module Hokusai::Util
   class Wrapped
     attr_accessor :text, :x, :y, :extra

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hokusai-zero
 version: !ruby/object:Gem::Version
-  version: 0.2.6.pre.pinephone4
+  version: 0.2.6.pre.pinephone6
 platform: ruby
 authors:
 - skinnyjames
@@ -292,6 +292,11 @@ 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/keyboard.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