hokusai-zero 0.2.6.pre.pinephone6 → 0.2.6

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

@@ -1,151 +0,0 @@
-# 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

@@ -1,168 +0,0 @@
-# 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

@@ -1,36 +0,0 @@
-# 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

@@ -1,56 +0,0 @@
-# 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

@@ -1,181 +0,0 @@
-# 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