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

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

@@ -16,8 +16,7 @@ module Hokusai::Backends
         yield(config)
       end
 
-      block = app.mount
-      backend.run(block)
+      backend.run(app)
     end
 
     def self.cursors
@@ -30,6 +29,17 @@ module Hokusai::Backends
      }
     end
 
+    def hml_vec2(x, y)
+      if @hml_vec2.nil?
+        @hml_vec2 = LibHokusai::HmlVec2.create(x, y)
+      else
+        @hml_vec2[:x] = x
+        @hml_vec2[:y] = y
+      end
+
+      @hml_vec2
+    end
+
     def self.stopped
       @stopped ||= false
     end
@@ -56,7 +66,19 @@ module Hokusai::Backends
       yield @config
     end
 
-    def run(block)
+    def get_size(window)
+      w = FFI::MemoryPointer.new :int
+      h = FFI::MemoryPointer.new :int
+      
+      SDL.GL_GetDrawableSize(window, w, h)
+
+      res = { width: w.read_int, height: h.read_int }
+      w.free
+      h.free
+      res
+    end
+
+    def run(app)
       resize = true
       self.render_width = config.width
       self.render_height = config.height
@@ -80,6 +102,7 @@ module Hokusai::Backends
           image_libpath: "#{SDL_PATH}/libSDL2_image.so"
         )
       end
+
       SDL.Init(config.init_flags)
       SDL.TTF_Init
 
@@ -87,43 +110,73 @@ module Hokusai::Backends
       SDL.SetWindowPosition(window, SDL::WINDOWPOS_CENTERED_MASK, SDL::WINDOWPOS_CENTERED_MASK)
       renderer = SDL.CreateRenderer(window, -1, SDL::RENDERER_TARGETTEXTURE | SDL::RENDERER_ACCELERATED)
 
+      size = get_size(window)
+      SDL.RenderSetScale(renderer, size[:width] / render_width, size[:height] / render_height);
+
       Hokusai.fonts.register "default", SDLBackend::Font.from("#{__dir__}/sdl2/Monaco.ttf", 121)
       Hokusai.fonts.activate "default"
       config.after_load_cb&.call
 
       register_command_handlers(renderer, window)
+      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)
+      
+      if config.touch
+        input.support_touch!
+      end
+
       canvas = Hokusai::Canvas.new(render_width.to_f, render_height.to_f)
       event = SDL::Event.new
 
       loop do
-        SDL.WaitEvent(event)
-        break if event[:common][:type] == SDL::QUIT || self.class.stopped
-        if process_input(input, event)
-          # since we are using wait event, we need to process the render twice
-          # once to capture all events, and once after updating block state.
-          SDL.SetRenderDrawBlendMode(renderer, SDL::BLENDMODE_NONE)
-          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)
-          painter = Hokusai::Painter.new(block, input)
-          painter.render(canvas, resize)
-          block.update
-          SDL.RenderPresent(renderer)
-
-          SDL.SetRenderDrawBlendMode(renderer, SDL::BLENDMODE_NONE)
-          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)
-          painter = Hokusai::Painter.new(block, input)
-          painter.render(canvas, resize, capture: false)
-          SDL.RenderPresent(renderer)
+        if SDL.PollEvent(event)
+          self.class.stopped = true if event[:common][:type] == SDL::QUIT || self.class.stopped
+          
+          process_input(input, event)
+          if config.touch
+            if input.touch.touching?
+              token = input.touch.token
+
+              LibHokusai.hoku_input_set_mouse_position(input.raw, hml_vec2(token[:x], 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)
+            else
+              button = mouse_button(clicked: false, down: false, released: true, up: true)
+              LibHokusai.hoku_input_mouse_set_button(input.raw, button, 0)
+            end
+          end
         end
+
+        break if self.class.stopped
+        # since we are using wait event, we need to process the render twice
+        # once to capture all events, and once after updating block state.
+        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)
+        painter = Hokusai::Painter.new(block, input)
+        painter.render(canvas, resize)
+
+        SDL.RenderPresent(renderer)
+        block.update
+
+        # SDL.SetRenderDrawBlendMode(renderer, SDL::BLENDMODE_NONE)
+        # 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)
+        # painter = Hokusai::Painter.new(block, input)
+        # painter.render(canvas, resize, capture: false)
+        # SDL.RenderPresent(renderer)
+        SDL.Delay(10)
       end
 
       LibHokusai.hoku_input_free(input.raw)
@@ -157,52 +210,78 @@ module Hokusai::Backends
     end
 
     def reset_keys(input)
-      LibHokusai.hoku_input_keyboard_start(input.raw)
-      Modifiers.each do |(sdlk, hkey)|
-        LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, false)
-      end
+      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)
+        end
 
-      Keys.values.each do |hkey|
-        LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, false)
-      end
+        Keys.values.each do |hkey|
+          LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, false)
+        end
 
-      LibHokusai.hoku_input_keyboard_stop(input.raw)
+        LibHokusai.hoku_input_keyboard_stop(input.raw)
+      end
     end
 
     def process_input(input, event)
       reset_keys(input)
 
+      t = event[:common][:type]
+      if  config.touch && t != SDL::FINGERDOWN && t != SDL::WINDOWEVENT && t != SDL::FINGERUP && t != SDL::FINGERMOTION && t != SDL::MOUSEMOTION && t != SDL::POLLSENTINEL
+        input.touch.clear
+      end
+
       case event[:common][:type]
-      when SDL::KEYDOWN
-        modifier = event[:key][:keysym][:mod]
-        code = event[:key][:keysym][:sym]
-        hkey = Keys[code]
+      when SDL::FINGERDOWN
+        x = event[:tfinger][:x] * render_width
+        y = event[:tfinger][:y] * render_height
 
-        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, true)
+        input.touch.record(0, x, y)
+        return true
+      when SDL::FINGERUP
+        input.touch.clear
+        return true
+      when SDL::FINGERMOTION
+        x = event[:tfinger][:x] * render_width
+        y = event[:tfinger][:y] * render_height
+
+        input.touch.record(0, x, y)
+        return true
+      when SDL::KEYDOWN
+        if !input.keyboard_override
+          modifier = event[:key][:keysym][:mod]
+          code = event[:key][:keysym][:sym]
+          hkey = Keys[code]
+
+          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, true)
+            end
           end
-        end
 
-        LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, true) unless hkey.nil?
-        LibHokusai.hoku_input_keyboard_stop(input.raw)
+          LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, true) unless hkey.nil?
+          LibHokusai.hoku_input_keyboard_stop(input.raw)
+        end
 
         return true
       when SDL::KEYUP
-        modifier = event[:key][:keysym][:mod]
-        code = event[:key][:keysym][:sym]
-        hkey = Keys[code]
-
-        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)
+        if !input.keyboard_override
+          modifier = event[:key][:keysym][:mod]
+          code = event[:key][:keysym][:sym]
+          hkey = Keys[code]
+
+          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)
+            end
           end
-        end
 
-        LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, false) unless hkey.nil?
-        LibHokusai.hoku_input_keyboard_stop(input.raw)
+          LibHokusai.hoku_input_keyboard_set_key(input.raw, hkey, false) unless hkey.nil?
+          LibHokusai.hoku_input_keyboard_stop(input.raw)
+        end
         return true
       when SDL::WINDOWEVENT
         if event[:window][:event] == SDL::WINDOWEVENT_RESIZED
@@ -257,20 +336,34 @@ module Hokusai::Backends
         clicked = event[:button][:clicks] > 0
         button = mouse_button(down: true, clicked: clicked)
 
-        # LibHokusai.hoku_input_mouse_set_scroll(input.raw, 0.0)
-        # input.raw[: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_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::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
+        # start = event[:edit][:start]
+        # len = event[:edit][:length]
+        # text = event[:edit][:text]
         return false
       else
         false
@@ -410,16 +503,21 @@ module Hokusai::Backends
                       self.class.images[command.source]
                     else
                       file = File.read(command.source)
-
-                      rw = SDL.RWFromConstMem(file, file.size)
-                      surface_ptr = SDL.IMG_Load_RW(rw, 1)
-                      if surface_ptr.null?
+                      SDL.SetHint(SDL::HINT_RENDER_SCALE_QUALITY, "0");
+                      texture = SDL.IMG_LoadTexture(renderer, command.source)
+                      if texture.null?
                         raise Hokusai::Error.new("Can't load Image: #{SDL.GetError.read_string}")
                       end
 
-                      texture = SDL.CreateTextureFromSurface(renderer, surface_ptr)
+                      # rw = SDL.RWFromConstMem(file, file.size)
+                      # surface_ptr = SDL.IMG_LoadSVG_RW(rw)
+                      # if surface_ptr.null?
+                      #   raise Hokusai::Error.new("Can't load Image: #{SDL.GetError.read_string}")
+                      # end
+
+                      # texture = SDL.CreateTextureFromSurface(renderer, surface_ptr)
                       self.class.images[command.source] = texture
-                      SDL.FreeSurface(surface_ptr)
+                      # SDL.FreeSurface(surface_ptr)
                       texture
                     end
                   end
@@ -431,6 +529,7 @@ module Hokusai::Backends
 
       Hokusai::Commands::Rect.on_draw do |command|
         next unless inside_scissor(command.x, command.y, command.height)
+        next if command.color.a == 0
         # draw background first
         x, y, w, h = [command.x, command.y, command.width, command.height]
 
@@ -506,7 +605,6 @@ module Hokusai::Backends
         rounding = command.rounding
 
         if command.rounding > 0
-          pp command.color
           SDL.roundedBoxRGBA(renderer, x, y, x + w, y + h, (command.rounding).ceil.to_i, command.color.r, command.color.g, command.color.b, command.color.a)
         else
           rect = SDL::Rect.new
@@ -515,6 +613,7 @@ module Hokusai::Backends
           rect[:w] = w
           rect[:h] = h
 
+          SDL.SetRenderDrawBlendMode(renderer, SDL::BLENDMODE_BLEND)
           SDL.SetRenderDrawColor(renderer, command.color.r, command.color.g, command.color.b, command.color.a)
           SDL.RenderFillRect(renderer, rect)
         end

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

@@ -87,7 +87,7 @@ class Hokusai::Blocks::Input < Hokusai::Block
   end
 
   def dynamic_keypress_handle(event)
-    return unless node.meta.focused
+    return unless node.meta.focused || event.input.keyboard_override
     case event
     when proc(&:ctrl), proc(&:super)
       if event.char == "z"

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

@@ -0,0 +1,234 @@
+module Hokusai::Blocks
+  class Key < Hokusai::Block
+    template <<~EOF
+    [template]
+      empty {
+        @mousedown="set_down"
+        @mouseup="set_up"
+        cursor="pointer"
+      }
+    EOF
+
+    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
+
+    def initialize(**args)
+      @down = false
+
+      super
+    end
+
+    def set_down(event)
+      if !down
+        emit("clicked", value[0], event)
+
+        self.down = true
+      else
+        emit("released", value[0], event)
+      end
+    end
+
+    def set_up(event)
+      self.down = false
+      emit("released", value[0], event)
+    end
+
+    def render(canvas)
+      hpad = (canvas.width  - size) / 2
+      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
+
+          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
+
+          text(value[1].to_s, canvas.x + hpad + margin.width, canvas.y + margin.height) do |command|
+            command.color = color
+            command.size = size
+          end
+        end
+      end
+
+      yield canvas
+    end
+  end
+
+  class KeyboardRow < Hokusai::Block
+    style <<~EOF
+    [style]
+    keyboardStyle {
+      background: rgb(28, 28, 28);
+    }
+    keyStyle {
+      background: rgb(46, 46, 46);
+      color: rgb(208, 205, 218);
+      background_down: rgb(37, 37, 37);
+    }
+    EOF
+
+    template <<~EOF
+    [template]
+      hblock { ...keyboardStyle }
+        [for="number in keys"]
+          key {
+            ...keyStyle
+            :width="width(number)"
+            :icons="icons"
+            :key="loop_key(number)"
+            :value="number"
+            @clicked="emit_key"
+            @released="emit_released"
+          }
+    EOF
+
+    uses(
+      hblock: Hblock,
+      vblock: Vblock,
+      key: Key
+    )
+
+    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
+
+    def loop_key(value)
+      "key-#{value}"
+    end
+    
+    def emit_key(key, event)
+      emit("key", key, event)
+    end
+
+    def emit_released(key, event)
+      emit("released", key, event)
+    end
+  end
+
+  class Keyboard < Hokusai::Block
+    style <<~EOF
+    [style]
+    kstyle {
+      padding: padding(10.0, 5.0, 10.0, 5.0);
+      background: rgb(28, 28, 28);
+    }
+    EOF
+
+    template <<~EOF
+    [template]
+      vblock { ...kstyle }
+        [for="row in key_rows"]
+          row {
+            :icons="icons"
+            @released="handle_released"
+            @key="handle_keypress"
+            :key="index"
+            :keys="row"
+          }
+    EOF
+
+    uses(
+      vblock: Hokusai::Blocks::Vblock,
+      row: KeyboardRow
+    )
+
+
+    def self.icons
+      {
+        :shift => { 
+          file: Hokusai.asset("icons/outline/arrow-big-up.svg"),
+          width: 54.0,
+          size: 30,
+          background: Hokusai::Color.new(50, 109, 70),
+          color: Hokusai::Color.new(172, 224, 189)
+        },
+        :backspace => { 
+          file: Hokusai.asset("icons/outline/backspace.svg"), 
+          width: 54.0, 
+          size: 30,
+          background: Hokusai::Color.new(50, 109, 70),
+          color: Hokusai::Color.new(172, 224, 189)
+         }
+      }
+    end
+
+    computed :icons, default: icons
+    computed :row_height, default: 48.0, convert: proc(&:to_f)
+
+    def on_mounted
+      node.meta.set_prop(:height, row_height * 5.0 + 20)
+    end
+
+    def space_row
+      [[:comma, ","], [:space, ''], [:period, "."]]
+    end
+
+    def key_rows
+      [number_keys, querty_keys, asdf_keys, zxcv_keys, space_row]
+    end
+
+    def handle_released(key, event)
+      event.input.keyboard_override = false
+    end
+
+    def handle_keypress(key, event)
+      event.input.keyboard_override = true
+      LibHokusai.hoku_input_keyboard_start(event.input.raw)
+      LibHokusai.hoku_input_keyboard_set_key(event.input.raw, key.to_sym, true)
+      LibHokusai.hoku_input_keyboard_stop(event.input.raw)
+    end
+
+    def zxcv_keys
+      @zxcv_keys ||= begin
+        keys = %w[z x c v b n m]
+        middle = keys.zip(keys)
+        middle << [:backspace, :backspace]
+        middle.unshift([:shift, :shift])
+        middle
+      end
+    end
+
+    def asdf_keys
+      keys = %w[a s d f g h j k l]
+      @asdf_keys ||= keys.zip(keys)
+    end
+
+    def querty_keys
+      keys = %w[q w e r t y u i o p]
+      @querty_keys ||= keys.zip(keys)
+    end
+
+    def number_keys
+      keys = [[:one,1],[:two, 2], [:three,3], [:four,4],[:five, 5], [:six,6], [:seven,7], [:eight,8],[:nine,9], [:zero, 0]]
+      @number_keys ||= keys
+    end
+  end
+end