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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db63632b958a6ee6aaa4322f1e8737f74a74167df845dbbc01b167fc73907305
-  data.tar.gz: 0cceed2907fdf38549b34ddd77e6503a9c504a3b1c6fbc6a14d3adfdab2984a8
+  metadata.gz: fadc5b1cf6e75bc57d76dcca297a97521e64a744858ef0cafbf53e2e7d259373
+  data.tar.gz: 010f5c1f195932e39b8f5061cbab13bc55ce88485bec86dadb6a5ec0754feb2b
 SHA512:
-  metadata.gz: 277ef8ae488facee7aa4b43e25c7ea0e704343d0364dd2607eeb106deebf3b9529dcdfcd7672d3f291c2598821f6841ee4eac56c9f5b6026115a6e77a1887621
-  data.tar.gz: 0cce59cf2eaa17ff83d3e63f0c77ef7bd3acc8db4d4b07e2fbc0c28fc6f650dd9d7a5d6aa7614e10d07691211c12440be9f1476018b80efaf6688b24694de027
+  metadata.gz: 4e0bdc4ecaa1609324e3ca7a2ba3dadd7ca9ef145ee67c49d66a9fc8c76b5971f1d61f14f806124c7e0c5564a0420af50619dd44da64828a8e041ed47cf35a6d
+  data.tar.gz: 63f2644bd086280547eea3497df85f274e9dd6304314de84c77839eb4bbd49b903506afb87aae47a230e2861cb80201e1c296c864869b8fbf4a5dca0999c3abc

data/hokusai.gemspec

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

data/ui/examples/counter.rb

@@ -122,11 +122,12 @@ Hokusai::Backends::RaylibBackend.run(Demos::Counter) do |config|
   # end
 
   config.after_load do
-    font = Hokusai::Backends::RaylibBackend::Font.from_ext("#{__dir__}/assets/OpenSans-Regular.ttf", 160)
+    font = Hokusai::Backends::RaylibBackend::Font.sdf("#{__dir__}/assets/OpenSans-Regular.ttf", 260)
     Hokusai.fonts.register "opensans", font
     Hokusai.fonts.activate "opensans"
   end
 
+  config.fps = 40
   config.width = 500
   config.height = 500
   config.title = "Counter application"

data/ui/examples/spreadsheet.rb

@@ -119,15 +119,15 @@ module Demos
   end
 end
 
-Hokusai::Backends::SDLBackend.run(Demos::Spreadsheet::App) do |config|
-  # config.after_load do
-  #   font = Hokusai::Backends::RaylibBackend::Font.from("#{__dir__}/assets/Inter-Regular.ttf")
-  #   Hokusai.fonts.register "inter", font
-  #   Hokusai.fonts.activate "inter"
+Hokusai::Backends::RaylibBackend.run(Demos::Spreadsheet::App) do |config|
+  config.after_load do
+    font = Hokusai::Backends::RaylibBackend::Font.from("#{__dir__}/assets/Inter-Regular.ttf")
+    Hokusai.fonts.register "inter", font
+    Hokusai.fonts.activate "inter"
 
-  #   font = Hokusai::Backends::RaylibBackend::Font.from_ext("#{__dir__}/assets/Delius-Regular.ttf", 160)
-  #   Hokusai.fonts.register "dohyeon", font
-  # end 
+    font = Hokusai::Backends::RaylibBackend::Font.from_ext("#{__dir__}/assets/Delius-Regular.ttf", 160)
+    Hokusai.fonts.register "dohyeon", font
+  end 
 
   config.fps = 60
   config.width = 800
@@ -135,7 +135,7 @@ Hokusai::Backends::SDLBackend.run(Demos::Spreadsheet::App) do |config|
   config.title = "Spreadsheet application"
 
 
-  # config.config_flags = Raylib::FLAG_WINDOW_RESIZABLE | Raylib::FLAG_VSYNC_HINT | Raylib::FLAG_WINDOW_TRANSPARENT
-  # config.window_state_flags = Raylib::FLAG_WINDOW_RESIZABLE | Raylib::FLAG_WINDOW_UNDECORATED | Raylib::FLAG_WINDOW_TRANSPARENT
-  # config.background = Raylib::BLANK
+  config.config_flags = Raylib::FLAG_WINDOW_RESIZABLE | Raylib::FLAG_VSYNC_HINT | Raylib::FLAG_WINDOW_TRANSPARENT
+  config.window_state_flags = Raylib::FLAG_WINDOW_RESIZABLE | Raylib::FLAG_WINDOW_UNDECORATED | Raylib::FLAG_WINDOW_TRANSPARENT
+  config.background = Raylib::BLANK
 end

data/ui/examples/tic_tac_toe.rb

@@ -240,9 +240,9 @@ module Demos
     end
   end
 end
-#
-# Hokusai::Backends::SDLBackend.run(TicTacToe::App) do |config|
-#   config.width = 500
-#   config.height = 500
-#   config.title = "Tic Tac Trollio"
-# end
+
+Hokusai::Backends::RaylibBackend.run(Demos::TicTacToe::App) do |config|
+  config.width = 500
+  config.height = 500
+  config.title = "Tic Tac Trollio"
+end

data/ui/src/hokusai/automation/driver_commands/base.rb

@@ -65,14 +65,8 @@ module Hokusai::Automation
       end
 
       def mouse_move(x, y, input)
-        LibHokusai.hoku_input_set_mouse_position(input, vec2(x, y))
-      end
-
-      private
-  
-      # Returns an HmlVec2 from {x,y}
-      def vec2(x, y)
-        LibHokusai::HmlVec2.create(x, y)
+        input.mouse.pos.x = x
+        input.mouse.pos.y = y
       end
     end
   end

data/ui/src/hokusai/automation/driver_commands/trigger_keyboard.rb

@@ -33,21 +33,18 @@ module Hokusai::Automation
         decode_key = keys.shift
 
         mouse_center(canvas, input)
-        state = LibHokusai::HmlInputMouseButton.create(clicked: true)
-        LibHokusai.hoku_input_mouse_set_button(input, state, 0)
+        input.mouse.left.clicked = true
 
         begin
           key_results = to_hml_keygroup(decode_key)
 
-          LibHokusai.hoku_input_keyboard_start(input)
+          input.keyboard.reset
 
           key_results.each do |key|
             Log.info { "populating #{key}"}
 
-            LibHokusai.hoku_input_keyboard_set_key(input, key, true)
+            input.keyboard.set(key, true)
           end
-
-          LibHokusai.hoku_input_keyboard_stop(input)
         rescue Automation::Error => ex
           keys.clear
           self.exeception = ex

data/ui/src/hokusai/automation/driver_commands/trigger_mouse.rb

@@ -2,9 +2,9 @@ module Hokusai::Automation
   module DriverCommands
     module MouseMethods
       def trigger_mouse(input, **args)
-        state = LibHokusai::HmlInputMouseButton.create(**args)
-
-        LibHokusai.hoku_input_mouse_set_button(input, state, button)
+        args.each do |which, bool|
+          input.mouse.left.send("#{which}=", bool)
+        end
       end
     end
 
@@ -27,6 +27,14 @@ module Hokusai::Automation
         state[:button]
       end
 
+      def button_symbol
+        {
+          0 => :left,
+          1 => :middle,
+          2 => :right
+        }[button]
+      end
+
       def on_complete
         return value if done?
 
@@ -65,7 +73,6 @@ module Hokusai::Automation
     class TriggerMouseClick < TriggerMouseBase
       def execute(blocks, canvas, input)
         if matches_blocks(blocks)
-          
           mouse_center(canvas, input)
           trigger_mouse(input, clicked: true)
 
@@ -202,8 +209,8 @@ module Hokusai::Automation
       def execute(blocks, canvas, input)
         if matches_block(blocks[0])
           mouse_center(canvas, input)
-          LibHokusai.hoku_input_mouse_set_scroll(input, scroll_amount)
 
+          input.mouse.scroll = scroll_amount
 
           done!
         end

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

@@ -24,7 +24,7 @@ module Hokusai
       end
 
       class Font < Hokusai::Font
-        attr_reader :raw
+        attr_reader :raw, :sdf
 
         DEFAULT = "–—‘’“”…\r\n\t0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%%^&*(),.?/\"\\[]-_=+|~`{}<>;:'\0"
 
@@ -51,7 +51,7 @@ module Hokusai
 
           raylib_font = Raylib.LoadFontEx(file, font_size, codepoints, count)
           Raylib.GenTextureMipmaps(raylib_font.texture)
-          Raylib.SetTextureFilter(raylib_font.texture, Raylib::TEXTURE_FILTER_BILINEAR)
+          Raylib.SetTextureFilter(raylib_font.texture, Raylib::TEXTURE_FILTER_POINT)
 
           font = new(raylib_font)
           Raylib.UnloadCodepoints(codepoints)
@@ -59,9 +59,30 @@ module Hokusai
           font
         end
 
-        def initialize(raw, spacing = 1.0)
+        def self.sdf(file, size)
+          ptr = FFI::MemoryPointer.new(:int)
+          data = Raylib.LoadFileData(file, ptr)
+          font = Raylib::Font.new
+          font.baseSize = size
+          font.glyphCount = 95
+
+          font.glyphs = Raylib.LoadFontData(data, ptr.read_int, size, nil, 0, Raylib::FONT_SDF)
+          buf = FFI::MemoryPointer.new(:pointer, 1)
+          atlas = Raylib.GenImageFontAtlas(font.glyphs, buf, 95, size, 4, 0)
+          font.recs = buf.read_pointer
+          font.texture = Raylib.LoadTextureFromImage(atlas)
+          Raylib.UnloadImage(atlas)
+          Raylib.UnloadFileData(data)
+          buf.free
+          ptr.free
+
+          new(font, sdf: true)
+        end
+
+        def initialize(raw, spacing = 1.0, sdf: false)
           @raw = raw
           @spacing = spacing
+          @sdf = sdf
         end
 
         # returns the spacing for this font

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

@@ -5,6 +5,34 @@ require 'memory_profiler'
 
 module Hokusai::Backends
   class RaylibBackend
+
+    SDF_SHADER = <<~EOF
+    #version 100
+
+    precision mediump float;
+
+    // Input vertex attributes (from vertex shader)
+    varying vec2 fragTexCoord;
+    varying vec4 fragColor;
+
+    // Input uniform values
+    uniform sampler2D texture0;
+    uniform vec4 colDiffuse;
+
+    // NOTE: Add your custom variables here
+    const float smoothing = 1.0/16.0;
+
+    void main()
+    {
+        // Texel color fetching from texture sampler
+        // NOTE: Calculate alpha using signed distance field (SDF)
+        float distance = texture2D(texture0, fragTexCoord).a;
+        float alpha = smoothstep(0.5 - smoothing, 0.5 + smoothing, distance);
+
+        // Calculate final fragment color
+        gl_FragColor = vec4(fragColor.rgb, fragColor.a*alpha);
+    }
+    EOF
     
     RAYLIB_PATH = ENV["RAYLIB_PATH"] || begin
       path = "#{__dir__}/../../../../vendor/lib"
@@ -168,13 +196,11 @@ module Hokusai::Backends
       end
 
       if !input.keyboard_override
-        LibHokusai.hoku_input_keyboard_start(input.raw)
+        input.keyboard.reset
 
         Keys.each do |(hoku_key, raylib_key)|
-          LibHokusai.hoku_input_keyboard_set_key(input.raw, hoku_key, Raylib.IsKeyDown(raylib_key))
+          input.keyboard.set(hoku_key, Raylib.IsKeyDown(raylib_key))
         end
-
-        LibHokusai.hoku_input_keyboard_stop(input.raw)
       end
     end
 
@@ -198,11 +224,7 @@ module Hokusai::Backends
 
       register_command_handlers
 
-      ptr = FFI::MemoryPointer.new :pointer
-      LibHokusai.hoku_input_init(ptr)
-      raw = LibHokusai::HmlInput.new(ptr.get_pointer(0))
-      input = Hokusai::Input.new(raw)
-      ptr.free
+      input = Hokusai::Input.new
       input.support_touch! if config.touch
 
       Raylib.SetConfigFlags(config.config_flags)
@@ -296,8 +318,6 @@ module Hokusai::Backends
         Raylib.UnloadShader(shader)
       end
 
-      LibHokusai.hoku_input_free(input.raw)
-
       if ENV["PROFILE"]
         report = MemoryProfiler.stop
         report.pretty_print(scale_bytes: true)
@@ -487,9 +507,9 @@ module Hokusai::Backends
         next unless inside_scissor(command.x, command.y, command.size)
 
         active_name = Hokusai.fonts.active_font_name
-        font = Hokusai.fonts.active
+        font_name = command.font.nil? ? active_name : command.font
 
-        Hokusai.fonts.activate command.font.nil? ? active_name : command.font
+        Hokusai.fonts.activate font_name
         font = Hokusai.fonts.active
 
         c = color(command.color)
@@ -497,9 +517,16 @@ module Hokusai::Backends
         y = command.y + command.padding.t
 
         if fnt = font
-          # content = FFI::MemoryPointer.from_string(command.content)
+          if fnt.sdf
+            self.class.shaders["font-sdf-#{font_name}"] ||= Raylib.LoadShaderFromMemory(nil, SDF_SHADER)
+            Raylib.BeginShaderMode(self.class.shaders["font-sdf-#{font_name}"])
+          end
+    
           Raylib.DrawTextEx(fnt.raw, command.content.to_s, vec2(x, y), command.size, fnt.spacing, c)
-          # content.free
+
+          if fnt.sdf
+            Raylib.EndShaderMode
+          end
         else
           Raylib.DrawText(command.content, x, y, command.size, c)
         end

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

@@ -121,10 +121,7 @@ module Hokusai::Backends
       block = app.mount
       # MemoryProfiler.start if ENV["PROFILE"]
 
-      ptr = FFI::MemoryPointer.new :pointer
-      LibHokusai.hoku_input_init(ptr)
-      raw = LibHokusai::HmlInput.new(ptr.get_pointer(0))
-      input = Hokusai::Input.new(raw)
+      input = Hokusai::Input.new
       
       if config.touch
         input.support_touch!
@@ -142,16 +139,21 @@ module Hokusai::Backends
             if input.touch.touching?
               token = input.touch.token
 
-              LibHokusai.hoku_input_set_mouse_position(input.raw, hml_vec2(token[:x], token[:y]))
+              input.mouse.pos.x = token[:x]
+              input.mouse.pos.y = token[:y]
             end
 
             # translate taps to clicks
             if input.touch.tapped?
-              button = mouse_button(clicked: true, down: true, released: false, up: false)
-              LibHokusai.hoku_input_mouse_set_button(input.raw, button, 0)
+              input.mouse.left.clicked = true
+              input.mouse.left.down = true
+              input.mouse.left.released = false
+              input.mouse.left.up = false
             else
-              button = mouse_button(clicked: false, down: false, released: true, up: true)
-              LibHokusai.hoku_input_mouse_set_button(input.raw, button, 0)
+              input.mouse.left.clicked = true
+              input.mouse.left.down = true
+              input.mouse.left.released = false
+              input.mouse.left.up = false
             end
           end
         end
@@ -179,7 +181,6 @@ module Hokusai::Backends
         SDL.Delay(10)
       end
 
-      LibHokusai.hoku_input_free(input.raw)
       if ENV["PROFILE"]
         # report = MemoryProfiler.stop
         # report.pretty_print
@@ -211,16 +212,15 @@ module Hokusai::Backends
 
     def reset_keys(input)
       if !input.keyboard_override
-        LibHokusai.hoku_input_keyboard_start(input.raw)
-        Modifiers.each do |(sdlk, hkey)|
-          LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, false)
+        input.keyboard.reset
+
+        Modifiers.each do |(sdlk, hkey)| 
+          input.keyboard.set(hkey, false)
         end
 
         Keys.values.each do |hkey|
-          LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, false)
+          input.keyboard.set(hkey, false)
         end
-
-        LibHokusai.hoku_input_keyboard_stop(input.raw)
       end
     end
 
@@ -254,15 +254,15 @@ module Hokusai::Backends
           code = event[:key][:keysym][:sym]
           hkey = Keys[code]
 
-          LibHokusai.hoku_input_keyboard_start(input.raw)
+          input.keyboard.reset
+
           Modifiers.each do |(sdlk, hkey)|
             if modifier & sdlk == sdlk
-              LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, true)
+              input.keyboard.set(hkey, true)
             end
           end
 
-          LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, true) unless hkey.nil?
-          LibHokusai.hoku_input_keyboard_stop(input.raw)
+          input.keyboard.set(hkey, true) unless hkey.nil?
         end
 
         return true
@@ -271,16 +271,15 @@ module Hokusai::Backends
           modifier = event[:key][:keysym][:mod]
           code = event[:key][:keysym][:sym]
           hkey = Keys[code]
+          input.keyboard.reset
 
-          LibHokusai.hoku_input_keyboard_start(input.raw)
           Modifiers.each do |(sdlk, hkey)|
             if modifier & sdlk == sdlk
-              LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, false)
+              input.keyboard.set(hkey, false)
             end
           end
 
-          LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, false) unless hkey.nil?
-          LibHokusai.hoku_input_keyboard_stop(input.raw)
+          input.keyboard.set(hkey, false) unless hkey.nil?
         end
         return true
       when SDL::WINDOWEVENT
@@ -302,62 +301,59 @@ module Hokusai::Backends
 
         return true
       when SDL::MOUSEMOTION
-        if input.raw[:mouse][:delta][:y] > 0
-          # LibHokusai.hoku_input_mouse_set_scroll(input.raw, 0.0)
-          input.raw[:mouse][:delta][:y] = 0.0
-          input.raw[:mouse][:scroll_delta] = 0.0
-          input.raw[:mouse][:scroll] = event[:motion][:y]
+        if input.mouse.delta.y > 0
+          input.mouse.delta.y = 0.0
+          input.mouse.scroll_delta = 0.0
+          input.mouse.scroll = event[:motion][:y]
         end
 
-        # pp ["set mouse", Time.now.strftime("%H:%M:%S %L")]
-        hoku_mouse_pos = LibHokusai::HmlVec2.create(event[:motion][:x], event[:motion][:y])
-        LibHokusai.hoku_input_set_mouse_position(input.raw, hoku_mouse_pos)
+        input.mouse.pos.x = event[:motion][:x]
+        input.mouse.pos.y = event[:motion][:y]
 
         # clear any click events
         [[:left, 0], [:right, 2], [:middle, 1]].each do |(btn, i)|
-          button = input.raw[:mouse][btn]
-          button[:clicked] = false
-          LibHokusai.hoku_input_mouse_set_button(input.raw, button, i)
+          input.mouse.send(btn).clicked = false
         end
 
         return true
       when SDL::MOUSEWHEEL
-        LibHokusai.hoku_input_mouse_set_scroll(input.raw, event[:wheel][:preciseY])
-        input.raw[:mouse][:delta][:y] = event[:wheel][:preciseY]
+        input.mouse.scroll = event[:wheel][:preciseY]
+        input.mouse.delta.y = event[:wheel][:preciseY]
 
         # clear any click events
         [[:left, 0], [:right, 2], [:middle, 1]].each do |(btn, i)|
-          button = input.raw[:mouse][btn]
-          button[:clicked] = false
-          LibHokusai.hoku_input_mouse_set_button(input.raw, button, i)
+          input.mouse.send(btn).clicked = false
         end
+
         return true
       when SDL::MOUSEBUTTONDOWN
         clicked = event[:button][:clicks] > 0
-        button = mouse_button(down: true, clicked: clicked)
+        btn = {
+          0 => :left,
+          1 => :middle,
+          2 => :right
+        }[event[:button][:which]]
+
+        input.mouse.send(btn).clicked = clicked
+        input.mouse.send(btn).down = true
+        input.mouse.send(btn).up = false
+        input.mouse.scroll = 0.0
+        input.mouse.delta.y = 0.0
 
-        LibHokusai.hoku_input_mouse_set_scroll(input.raw, 0.0)
-        input.raw[:mouse][:delta][:y] = 0.0
-
-        LibHokusai.hoku_input_mouse_set_button(input.raw, button, event[:button][:which])
         return true
       when SDL::MOUSEBUTTONUP
-        button = mouse_button(up: true)
-        #
-        LibHokusai.hoku_input_mouse_set_scroll(input.raw, 0.0)
-        input.raw[:mouse][:delta][:y] = 0.0
-
-        LibHokusai.hoku_input_mouse_set_button(input.raw, button, event[:button][:which])
+        btn = {
+          0 => :left,
+          1 => :middle,
+          2 => :right
+        }[event[:button][:which]]
+
+        input.mouse.send(btn).up = true
+        input.mouse.send(btn).down = false
+        input.mouse.scroll = 0.0
+        input.mouse.delta.y = 0.0
         return true
       when SDL::TEXTINPUT
-        char = event[:text][:text].to_s
-        LibHokusai.hoku_input_keyboard_start(input.raw)
-
-        Modifiers.each do |(sdlk, hkey)|
-          LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, false)
-        end
-        LibHokusai.hoku_input_keyboard_set_key(input.raw, char.to_sym, true)
-        LibHokusai.hoku_input_keyboard_stop(input.raw)
 
         return true
       when SDL::TEXTEDITING

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

@@ -154,7 +154,7 @@ class Hokusai::Blocks::Input < Hokusai::Block
           self.buffer_offset = offset
         end
 
-        self.buffer += event.char
+        self.buffer += event.char unless event.char.nil?
       end
     end
 

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

@@ -5,8 +5,7 @@ module Hokusai
     extend Forwardable
 
     def_delegators :@keyboard, :shift, :super, :ctrl,
-                   :alt, :pressed, :pressed_len, :released,
-                   :released_len
+                   :alt, :pressed, :released, :char, :code
 
     attr_reader :input
 
@@ -37,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/painter.rb

@@ -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,11 +267,6 @@ module Hokusai
         return
       end
 
-      
-
-      # rect = canvas.to_hoku_rect
-      # block_is_hovered = LibHokusai.hoku_input_is_hovered(input.raw, rect)
-
       if input.hovered?(canvas)
         events[:hover].capture(block, canvas)
         events[:click].capture(block, canvas)

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.rb

@@ -4,34 +4,9 @@ require_relative "./types/primitives"
 require_relative "./types/display"
 require_relative "./types/touch"
 require_relative "./types/mouse"
+require_relative "./types/keyboard"
 
 module Hokusai
-  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 Input
     attr_accessor :keyboard_override
     attr_reader :raw, :touch
@@ -40,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
@@ -53,7 +27,7 @@ module Hokusai
     end
 
     def keyboard
-      Keyboard.new(@raw[:keyboard])
+      @keyboard ||= Keyboard.new
     end
 
     def mouse

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.pinephone5
+  version: 0.2.6.pre.pinephone6
 platform: ruby
 authors:
 - skinnyjames
@@ -293,6 +293,7 @@ files:
 - 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