hokusai-zero 0.1.1

data/ui/src/hokusai/painter.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require_relative "./event"
+
+module Hokusai
+  class PainterEntry
+    attr_reader :block, :parent, :x, :y, :w, :h
+    def initialize(block, x, y, w, h)
+      @block = block
+      @x = x
+      @y = y
+      @w = w
+      @h = h
+    end
+  end
+
+  class CursorState
+    attr_accessor :set
+
+    def initialize
+      @set = false
+    end
+  end
+
+  class Painter
+    attr_reader :root, :input, :before_render, :after_render,
+                :events
+
+    def initialize(root, input)
+      state = CursorState.new
+
+      @root = root
+      @input = input
+      @events = {
+        hover: HoverEvent.new(input, state),
+        wheel: WheelEvent.new(input, state),
+        click: ClickEvent.new(input, state),
+        mousemove: MouseMoveEvent.new(input, state),
+        mouseout: MouseOutEvent.new(input, state),
+        mouseup: MouseUpEvent.new(input, state),
+        mousedown: MouseDownEvent.new(input, state),
+        keyup: KeyUpEvent.new(input, state),
+        keypress: KeyPressEvent.new(input, state)
+      }
+    end
+
+    def on_before_render(&block)
+      @before_render = block
+    end
+
+    def on_after_render(&block)
+      @after_render = block
+    end
+
+    # @return [Array(Commands::Base)] the command list
+    def render(canvas, resize = false, capture: true)
+      return if root.children.empty?
+
+      @root.on_resize(canvas) if resize
+
+      before_render&.call([root, nil], canvas, input)
+
+      root_children = (canvas.reverse? ? root.children?&.reverse.dup : root.children?&.dup) || []
+      groups = []
+      groups << [root, measure(root_children, canvas)]
+
+      mouse_y = input.mouse.pos[:y]
+      can_capture = mouse_y >= (canvas.y || 0.0) && mouse_y <= (canvas.y || 0.0) + canvas.height
+
+      hovered = false
+
+      while payload = groups.pop
+        group_parent, group_children = payload
+
+        while group = group_children.shift
+          canvas.reset(group.x, group.y, group.w, group.h)
+
+          before_render&.call([group.block, group.parent], canvas, input.raw)
+
+          if capture && can_capture
+            capture_events(group.block, canvas, hovered: hovered)
+          end
+
+          if resize
+            group.block.on_resize(canvas)
+          end
+
+          breaked = false
+
+          group.block.render(canvas) do |local_canvas|
+            local_children = (local_canvas.reverse? ? group.block.children?&.reverse : group.block.children?)
+
+            unless local_children.nil?
+              groups << [group_parent, group_children]
+              groups << [group.block, measure(local_children, local_canvas)]
+              breaked = true
+            else
+              breaked = false
+            end
+          end
+
+          break if breaked
+        end
+      end
+
+      if capture
+        events[:hover].bubble
+        events[:wheel].bubble
+        events[:click].bubble
+        events[:keyup].bubble
+        events[:keypress].bubble
+        events[:mousemove].bubble
+        events[:mouseout].bubble
+        events[:mousedown].bubble
+        events[:mouseup].bubble
+      end
+
+      after_render&.call
+    end
+
+    def measure(children, canvas)
+      x = canvas.x || 0.0
+      y = canvas.y || 0.0
+      width = canvas.width
+      height = canvas.height
+      vertical = canvas.vertical
+
+      count = 0
+      wcount = 0
+      hcount = 0
+      wsum = 0.0
+      hsum = 0.0
+
+      children.each do |block|
+        # children.each do |block|
+        h = block.node.meta.get_prop?(:height)&.to_f
+        w = block.node.meta.get_prop?(:width)&.to_f
+
+        if w
+          wsum += w
+          wcount = wcount.succ
+        end
+
+        if h
+          hsum += h
+          hcount = hcount.succ
+        end
+
+        count = count.succ
+      end
+
+      neww = width
+      newh = height
+
+      if vertical
+        c = (count - hcount)
+        newh = (newh - hsum)  / (c.zero? ? 1 : c)
+      else
+        c = (count - wcount)
+        neww = (neww - wsum) / (c.zero? ? 1 : c)
+      end
+
+      entries = []
+
+      children.each do |block|
+        # nw, nh = ntuple
+        w = block.node.meta.get_prop?(:width)&.to_f || neww
+        h = block.node.meta.get_prop?(:height)&.to_f || newh
+
+        # local_canvas = Hokusai::Canvas.new(w, h, x, y)
+        # block.node.meta.props[:height] ||= h
+        # block.node.meta.props[:width] ||= w
+
+        entries << PainterEntry.new(block, x, y, w, h).freeze
+
+        if vertical
+          y += h
+        else
+          x += w
+        end
+      end
+
+      entries
+    end
+
+    def capture_events(block, canvas, hovered: false)
+      if block.node.portal.nil?
+        return
+      end
+
+
+      rect = canvas.to_hoku_rect
+      block_is_hovered = LibHokusai.hoku_input_is_hovered(input.raw, rect)
+
+      if block_is_hovered
+        events[:hover].capture(block, canvas)
+        events[:click].capture(block, canvas)
+        events[:wheel].capture(block, canvas)
+        events[:mousedown].capture(block, canvas)
+        events[:mouseup].capture(block, canvas)
+      else
+        events[:mouseout].capture(block, canvas)
+      end
+
+      events[:mousemove].capture(block, canvas)
+
+      if block_is_hovered || block.node.meta.focused
+        events[:keyup].capture(block, canvas)
+        events[:keypress].capture(block, canvas)
+      end
+    end
+  end
+end
+

data/ui/src/hokusai/publisher.rb

@@ -0,0 +1,32 @@
+module Hokusai
+  # An event emitter
+  class Publisher
+    attr_reader :listeners
+
+    def initialize(listeners = [])
+      @listeners = listeners
+    end
+
+    # Adds a listener that subscribes
+    # to events emitted
+    # by this publisher
+    #
+    # @param [Hokusai::Block] listener
+    def add(listener)
+      listeners << listener
+    end
+
+    # emits `event` with `**args`
+    # to all subscribers
+    # @see
+    # @param [String] name the event name
+    # @param [**args] the args to emit
+    def notify(name, *args, **kwargs)
+      listeners.each do |listener|
+        raise Hokusai::Error.new("No target `##{name}` on #{listener.class}") unless listener.respond_to?(name)
+
+        listener.public_send(name, *args, **kwargs)
+      end
+    end
+  end
+end

data/ui/src/hokusai/style.rb

@@ -0,0 +1,72 @@
+module Hokusai
+  class Style
+    attr_reader :raw
+
+    def self.parse(template)
+      raw = LibHokusai.parse_style(template)
+      new(parse_styles(raw))
+    end
+
+    def self.parse_styles(raw)
+      styles = {}
+
+      until raw.null?
+        styles[raw[:name]] = parse_attributes(raw[:attributes])
+
+        raw = raw[:next]
+      end
+
+      styles
+    end
+
+    def self.parse_attributes(raw)
+      attributes = {}
+
+      until raw.null?
+        case raw[:type]
+        when :style_int
+          value = raw[:value].to_i
+        when :style_bool
+          value = (raw[:value] == "true")
+        when :style_float
+          value = raw[:value].to_f
+        when :style_string
+          value = raw[:value]
+        when :style_func
+          value = parse_function(raw[:function_name], raw[:value])
+        end
+
+        attributes[raw[:name]] = value
+        
+        raw = raw[:next]
+      end
+
+      attributes
+    end
+
+    def self.parse_function(name, value)
+      case name
+      when "rgb"
+        Color.convert(value)
+      when "outline"
+        Outline.convert(value)
+      when "padding"
+        Padding.convert(value)
+      else
+        raise Hokusai::Error.new("Unknown style function #{name}")
+      end
+    end
+
+    def initialize(elements)
+      @elements = elements
+    end
+
+    def [](element_name)
+      @elements[element_name]
+    end
+
+    def keys
+      @elements.keys
+    end
+  end
+end

data/ui/src/hokusai/types.rb

@@ -0,0 +1,266 @@
+# 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 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
+
+  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 Input
+    attr_reader :raw
+
+    def hash
+      [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
+    end
+
+    def keyboard
+      Keyboard.new(@raw[:keyboard])
+    end
+
+    def mouse
+      @mouse ||= Mouse.new(@raw[:mouse])
+    end
+
+    def hovered?(canvas)
+      LibHokusai.hoku_input_is_hovered(raw, canvas.to_hoku_rect)
+    end
+  end
+end