hokusai-zero 0.1.1

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

@@ -0,0 +1,172 @@
+module Hokusai
+  class MouseEvent < Event
+    extend Forwardable
+
+    attr_reader :input, :state
+
+    def initialize(input, state)
+      @input = input
+      @mouse = input.mouse
+      @left = @mouse.left
+      @right = @mouse.right
+      @middle = @mouse.middle
+      @state = state
+    end
+
+    def mouse
+      @mouse
+    end
+
+    def pos
+      mouse.pos
+    end
+
+    def delta
+      mouse.delta
+    end
+
+    def scroll
+      mouse.scroll
+    end
+
+    def scroll_delta
+      mouse.scroll_delta
+    end
+
+    def left
+      @left
+    end
+
+    def right
+      @right
+    end
+
+    def middle
+      @middle
+    end
+
+    def to_json
+      hash = {}
+      hash[:pos] = { x: pos.x, y: pos.y }
+
+      [:left, :right, :middle].each do |button|
+        hash[button] = {
+          down: send(button).down,
+          up: send(button).up,
+          clicked: send(button).clicked,
+          released: send(button).released
+        }
+      end
+
+      hash[:scroll] = scroll
+      hash[:scroll_delta] = scroll_delta
+
+      hash.to_json
+    end
+
+    protected
+
+    def hovered(canvas)
+      LibHokusai.hoku_input_is_hovered(input.raw, canvas.to_hoku_rect)
+    end
+  end
+
+  class MouseMoveEvent < MouseEvent
+    name "mousemove"
+
+    def capture(block, _)
+      if matches(block) #&& (delta.y != 0.0000000000 && delta.x != 0.0000000000)
+        captures << block
+      end
+    end
+  end
+
+  class ClickEvent < MouseEvent
+    name "click"
+
+    def capture(block, canvas)
+      if left[:clicked] && clicked(canvas)
+        block.node.meta.focus
+
+        if matches(block)
+          captures << block
+        end
+      elsif left[:clicked]
+        block.node.meta.blur
+      end
+    end
+
+    def clicked(canvas)
+      LibHokusai.hoku_input_is_clicked(input.raw, canvas.to_hoku_rect)
+    end
+  end
+
+  class MouseUpEvent < MouseEvent
+    name "mouseup"
+
+    def capture(block, _)
+      if left[:up] && matches(block)
+        captures << block
+      end
+    end
+  end
+
+  class MouseDownEvent < MouseEvent
+    name "mousedown"
+
+    def capture(block, _)
+      if left[:down] && matches(block)
+        captures << block
+      end
+    end
+  end
+
+  class WheelEvent < MouseEvent
+    name "wheel"
+
+    def capture(block, _)
+      if matches(block) && scroll_delta != 0.0
+        captures << block
+      end
+    end
+  end
+
+  class HoverEvent < MouseEvent
+    name "hover"
+
+    def capture(block, _)
+      captures << block
+    end
+
+    def bubble
+      while block = captures.pop
+        block.emit(name, self)
+
+        cursor = block.node.meta.get_prop(:cursor)&.to_sym
+
+        if !state.set && cursor == :manual
+          state.set = true
+        end
+
+        if !state.set && cursor && cursor != :manual
+          Hokusai.set_mouse_cursor(cursor)
+          state.set = true
+        end
+
+        break if stopped
+      end
+
+      if !state.nil? && !state.set
+        Hokusai.set_mouse_cursor(:default)
+      end
+    end
+  end
+
+  class MouseOutEvent < MouseEvent
+    name "mouseout"
+
+    def capture(block, _)
+      captures << block if matches(block)
+    end
+  end
+end

data/ui/src/hokusai/font.rb

@@ -0,0 +1,280 @@
+module Hokusai
+  class Font
+    def clamp(text, size, width, initial_offset = 0.0)
+      raise Hokusai::Error.new("Font #clamp not implemented")
+    end
+
+    def clamp_markdown(text, size, width, initial_offset = 0.0)
+      raise Hokusai::Error.new("Font #clamp not implemented")
+    end
+
+    def height
+      raise Hokusai::Error.new("Font #height not implemented")
+    end
+  end
+
+  class Clamping
+    class Char
+      attr_reader :raw
+      def initialize(raw)
+        @raw = raw
+      end
+
+      def width
+        raw[:width]
+      end
+
+      def offset
+        raw[:offset]
+      end
+    end
+
+    class Group
+      attr_reader :raw
+
+      def initialize(raw)
+        @raw = raw
+      end
+
+      def offset
+        @offset ||= raw[:offset]
+      end
+
+      def size
+        @size ||= raw[:size]
+      end
+
+      def width
+        chars.sum(&:width)
+      end
+
+      def type
+        @type ||= raw[:type]
+      end
+
+      def normal?
+        @normal ||= type == LibHokusai::GROUP_NORMAL
+      end
+
+      def bold?
+        @bold ||= ((type & LibHokusai::GROUP_BOLD) != 0)
+      end
+
+      def italics?
+        @italics ||= ((type & LibHokusai::GROUP_ITALICS) != 0)
+      end
+
+      def link?
+        @link ||= ((type & LibHokusai::GROUP_LINK) != 0)
+      end
+
+      def code?
+        @code ||= type & LibHokusai::GROUP_CODE
+      end
+
+      def link
+        @href ||= raw[:payload].read_string
+      end
+
+      def chars
+        return @chars unless @chars.nil?
+
+        @chars = []
+        each_char do |char|
+          @chars << char
+        end
+
+        @chars
+      end
+
+      def each_char
+        char = raw[:chars]
+        i = 0
+
+        while !char.null?
+          yield Char.new(char), i
+          i += 1
+          char = char[:next_char]
+        end
+      end 
+    end
+
+    class Segment
+      attr_reader :raw
+
+      def initialize(raw)
+        @raw = raw
+      end
+
+      def width(range = (offset...offset + size))
+        chars[range]&.sum(&:width) || 0.0
+      end
+
+      def offset
+        raw[:offset]
+      end
+
+      def size
+        raw[:size]
+      end
+
+      def chars
+        return @chars unless @chars.nil?
+
+        @chars = []
+        each_char do |char|
+          @chars << char
+        end
+
+        @chars
+      end
+
+      def each_char
+        char = raw[:chars]
+        i = 0
+
+        while !char.null?
+          yield Char.new(char), i
+          i += 1
+          char = char[:next_char]
+        end
+      end
+
+      def groups
+        return @groups unless @groups.nil?
+
+        @groups = []
+        each_group do |group|
+          @groups << group
+        end
+
+        @groups
+      end
+
+      def each_group
+        group = raw[:groups]
+        i = 0
+        until group.null?
+          yield Group.new(group), i
+          i.succ
+          group = group[:next_group]
+        end
+      end
+
+      def select_end
+        raw[:select_end]
+      end
+
+      def select_begin
+        raw[:select_begin]
+      end
+
+      def select_begin=(val)
+        raw[:select_begin] = val
+      end
+
+      def select_end=(val)
+        raw[:select_end] = val.nil? ? select_begin : val
+      end
+
+      def has_selection?
+        !select_end.nil? && !select_begin.nil?
+      end
+
+      def char_is_selected(char)
+        return false if select_begin.nil? || select_end.nil?
+
+        (select_begin..select_end).include?(char.offset)
+      end
+
+      def make_selection(start, stop)
+        self.select_begin = start
+        self.select_end = stop
+      end
+    end
+
+    attr_reader :raw, :markdown
+
+    def initialize(raw, markdown: false)
+      @markdown = markdown
+      @raw = raw
+    end
+
+    def segments
+      return @segments unless @segments.nil?
+
+      @segments = []
+      each_segment do |segment|
+        @segments << segment
+      end
+
+      @segments
+    end
+
+    def debug
+      LibHokusai.hoku_text_clamp_debug(raw)
+    end
+
+    def each_segment
+      segment = raw[:segments]
+      i = 0
+
+      until segment.null?
+        yield Segment.new(segment), i
+        i += 1
+
+
+        segment = segment[:next_segment]
+      end
+    end
+
+    def text(segment)
+      raw[:text][segment.offset, segment.size]
+    end
+
+    def [](offset, size)
+      raw[:text][offset, size]
+    end
+
+    def to_a
+      segments.map do |segment|
+        text(segment)
+      end
+    end
+  end
+
+  class FontRegistry
+    attr_reader :fonts, :active_font
+
+    def initialize
+      @fonts = {}
+      @active_font = nil
+    end
+
+    def register(name, font)
+      raise Hokusai::Error.new("Font #{name} already registered") if fonts[name]
+
+      fonts[name] = font
+    end
+
+    def active_font_name
+      raise Hokusai::Error.new("No active font") if active_font.nil?
+
+      active_font
+    end
+
+    def activate(name)
+      raise Hokusai::Error.new("Font #{name} is not registered") unless fonts[name]
+
+      @active_font = name
+    end
+
+    def get(name)
+      fonts[name]
+    end
+
+    def active
+      fonts[active_font]
+    end
+  end
+end

data/ui/src/hokusai/meta.rb

@@ -0,0 +1,152 @@
+require_relative "./publisher"
+
+module Hokusai
+  class Meta
+    attr_reader :focused, :parent, :target, :updater,
+                :props, :publisher
+
+    def self.commands
+      @commands ||= Commands.new
+    end
+
+    def initialize
+      @focused = false
+      @parent = nil
+      @target = nil
+      @updater = nil
+      @props = nil
+      @publisher = Publisher.new
+      @children = nil
+    end
+
+    def node_count
+      count = children?&.size || 0
+
+      children?&.each do |child|
+        count += child.node.meta.node_count
+      end
+
+      count
+    end
+
+    def get_child?(index)
+      return nil if @children.nil?
+
+      get_child(index)
+    end
+
+    def children=(values)
+      @children = values
+    end
+
+    def children?
+      return nil if @children.nil?
+
+      @children
+    end
+
+    def <<(child)
+      children! << child
+    end
+
+    def get_child(index)
+      children![index]
+    end
+
+    def set_child(index, value)
+      children![index] = value
+    end
+
+    def children!
+      @children ||= []
+    end
+
+    def props!
+      @props ||= {}
+    end
+
+    def get_prop?(name)
+      return nil if @props.nil?
+
+      get_prop(name)
+    end
+
+    def set_prop(name, value)
+      @props ||= {}
+
+      @props[name] = value
+    end
+
+    def get_prop(name)
+      @props ||= {}
+
+      @props[name]
+    end
+
+    def focus
+      @focused = true
+
+      children?&.each do |child|
+        child.node.meta.focus
+      end
+    end
+
+    def blur
+      @focused = false
+
+      children?&.each do |child|
+        child.node.meta.blur
+      end
+    end
+
+    def on_update(target, &block)
+      @target = target
+      @updater = block
+    end
+
+    def update(block)
+      # pp props
+      # if parent_block = parent
+        if target_block = target
+          if updater_block = updater
+            # Hokusai::Pool.post do
+              block.public_send(:before_updated) if block.respond_to?(:before_updated)
+
+              updater_block.call(block, target_block, target_block)
+              block.public_send(:after_updated) if block.respond_to?(:after_updated)
+
+            # end
+          end
+        end
+      # end
+
+        children?&.each do |child|
+         child.update
+        end
+    end
+
+    def has_ast?(ast, index)
+      if portal = children![index]&.node&.portal
+        return portal.ast.object_id == ast.object_id
+      end
+
+      false
+    end
+    #
+    # def destroy
+    #   children.each do |child|
+    #     child.before_destroy if child.respond_to?(:before_destroy)
+    #     child.node.destroy
+    #   end
+    # end
+
+    def child_delete(index)
+      if child = children![index]
+        child.before_destroy if child.respond_to?(:before_destroy)
+        child.node.destroy
+
+        children!.delete_at(index)
+      end
+    end
+  end
+end