hokusai-zero 0.1.1

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

@@ -0,0 +1,200 @@
+require_relative "../util/piece_table"
+
+class Hokusai::Blocks::Input < Hokusai::Block
+  template <<~EOF
+  [template]
+  text {
+    @select_offset="handle_select_offset"
+    @selected="handle_selected"
+    @keypress="dynamic_keypress_handle"
+    @height_updated="update_height"
+    :content="text_content"
+    :size="size"
+    :padding="padding"
+    :cursor_offset="cursor_offset"
+    :color="text_color"
+    :selection_color="text_selection_color"
+  }
+  EOF
+
+  uses(
+    text: Hokusai::Blocks::Text,
+  )
+
+  computed :initial, default: "", convert: proc(&:to_s)
+  computed :text_color, default: [33,33,33], convert: Hokusai::Color
+  computed :text_selection_color, default: [233,233,233], convert: Hokusai::Color
+  computed :cursor_color, default: [244,22,22], convert: Hokusai::Color
+  computed :growable, default: false
+  computed :size, default: 14, convert: proc(&:to_i)
+  computed :padding, default: nil, convert: Hokusai::Padding
+  computed :background, default: nil, convert: Hokusai::Color
+  computed :rounding, default: 0.0, convert: proc(&:to_f)
+  computed :outline, default: [0,0,0,0], convert: Hokusai::Outline
+  computed :outline_color, default: nil, convert: Hokusai::Color
+
+  attr_accessor :table, :buffer, :buffer_count,
+                :start_time, :buffer_offset, :offset
+
+  def initialize(**args)
+    super
+
+    @table = ::Hokusai::Util::PieceTable.new(initial)
+    @buffer = ""
+    @buffer_count = 0
+    @start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    @buffer_offset = 0
+    @offset = 0
+  end
+
+  def update_height(value)
+    node.meta.props[:height] = value
+
+    emit("height_updated", value)
+  end
+
+  def handle_selected(start, stop)
+    flush
+
+    return if start.nil?
+
+    self.offset = start
+    self.buffer_count = 0
+
+    return if stop.nil?
+
+    self.buffer_count = (stop + 1) - start
+  end
+
+  def handle_select_offset(value)
+    flush
+    
+    self.offset = value
+    self.buffer_count = 0
+  end
+
+  def dynamic_keypress_handle(event)
+    case event
+    when proc(&:ctrl), proc(&:super)
+      if event.char == "z"
+        table.undo
+      end
+
+      return
+    else
+      case event.key
+      when :right
+        flush
+
+        self.offset += 1 unless offset + 1 > table.to_s.size
+      when :left
+        flush
+        
+        self.offset = offset - 1 <= 0 ? 0 : offset - 1
+      when :down, :up
+        # no op
+      when :delete, :backspace
+        flush
+
+        if buffer_count > 0
+          table.delete(offset, buffer_count)
+        elsif offset > 0
+          table.delete(offset - 1, 1)
+
+          self.offset -= 1
+        end
+
+        self.buffer_count = 0
+
+        return
+      when :enter
+        if buffer.size.zero?
+          self.buffer_offset = offset
+        end
+
+        unless growable
+          flush
+          
+          emit("change", table.to_s)
+
+          self.table = ::Hokusai::Util::PieceTable.new("")
+          self.buffer_offset = 0
+          self.offset = 0
+
+          return
+        end
+
+        self.buffer += "\n"
+      else
+        if buffer_count > 0
+          flush
+          
+          table.delete(offset, buffer_count)
+
+          self.buffer_offset = offset
+          self.buffer_count = 0
+        end
+
+        if buffer.size.zero?
+          self.buffer_offset = offset
+        end
+
+        self.buffer += event.char
+      end
+    end
+  end
+    
+  def flush
+    if buffer.size > 0
+      table.insert(buffer, buffer_offset)
+
+      self.offset = cursor_offset
+      self.buffer_offset = 0
+      self.buffer = ""
+    end
+  end
+
+  def cursor_offset
+    offset + buffer.size
+  end
+
+  def text_content
+    StringIO.open do |io|
+      saved = table.to_s
+
+      io.write saved[0...buffer_offset]
+      io.write buffer
+
+      if last = saved[buffer_offset..-1]
+        io.write last
+      end
+
+      io.string
+    end
+  end
+
+  def render(canvas)
+    if !buffer.empty? && (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) > 10
+      flush
+
+      if table.pieces.size > 10
+        self.table = Util::PieceTable.new(table.to_s)
+      end
+
+      self.start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    draw do
+      rect(canvas.x, canvas.y, canvas.width, canvas.height) do |command|
+        command.color = background if background
+        command.outline = outline if outline
+        command.outline_color = outline_color if outline_color
+        command.round = rounding if rounding
+
+        canvas = command.trim_canvas(canvas)
+      end
+    end
+
+    yield canvas
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+class Hokusai::Blocks::Label < Hokusai::Block
+  template <<~EOF
+  [template]
+    virtual
+  EOF
+
+  computed! :content
+  computed :size, default: 12
+  computed :color, default: [33,33,33], convert: Hokusai::Color
+  computed :padding, default: [5.0, 5.0, 5.0, 5.0], convert: Hokusai::Padding
+
+  def initialize(**args)
+    @content_width = 0.0
+    @content_height = 0.0
+    @updated = false
+    @last_content = nil
+
+    super(**args)
+  end
+
+  def render(canvas)
+    if @last_content != content
+      width, _ = Hokusai.fonts.active.measure(content.to_s, size.to_i)
+
+      emit("width_updated", width + padding.right + padding.left)
+
+      @last_content = content
+    end
+
+    draw do
+      text(content, canvas.x, canvas.y) do |command|
+        command.color = color
+        command.size = size
+        command.padding = padding
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+class Hokusai::Blocks::Panel < Hokusai::Block
+  template <<~EOF
+    [template]
+      hblock {
+        :background="background"
+        @wheel="wheel_handle"
+      }
+        clipped { :offset="offset" }
+          dynamic { @size_updated="set_size" }
+            slot
+        [if="scroll_active"]
+          scrollbar.scroller {
+            @scroll="scroll_complete"
+            :top="panel_top"
+            :goto="scrollbar_goto"
+            :width="scroll_width"
+            :background="scroll_background"
+            :control_color="scroll_color"
+            :control_height="scroll_control_height"
+          }
+  EOF
+
+  uses(
+    clipped: Hokusai::Blocks::Clipped,
+    dynamic: Hokusai::Blocks::Dynamic,
+    hblock: Hokusai::Blocks::Hblock,
+    scrollbar: Hokusai::Blocks::Scrollbar
+  )
+
+  computed :align, default: "top", convert: proc(&:to_s)
+  computed :scroll_goto, default: nil
+  computed :scroll_width, default: 14.0, convert: proc(&:to_f)
+  computed :scroll_background, default: nil, convert: Hokusai::Color
+  computed :scroll_color, default: nil, convert: Hokusai::Color
+  computed :background, default: nil, convert: Hokusai::Color
+
+  provide :panel_offset, :offset
+  provide :panel_content_height, :content_height
+  provide :panel_height, :panel_height
+  provide :panel_top, :panel_top
+
+  attr_accessor :top, :panel_height, :scroll_y, :scroll_percent,
+                :scroll_goto_y, :clipped_offset, :clipped_content_height
+
+  def initialize(**args)
+    @top = nil
+    @panel_height = 0.0
+    @scroll_y = 0.0
+    @scroll_percent = 0.0
+    @scroll_goto_y = nil
+    @clipped_offset = 0.0
+    @clipped_content_height = 0.0
+
+    super(**args)
+  end
+
+  def wheel_handle(event)
+    return if clipped_content_height <= panel_height
+
+    new_scroll_y = scroll_y + event.scroll * 20
+
+    if y = top
+      if new_scroll_y < y
+        self.scroll_goto_y = y
+      elsif new_scroll_y > panel_height
+        self.scroll_goto_y = panel_height
+      else
+        self.scroll_goto_y = new_scroll_y
+      end
+    end
+  end
+
+  def panel_top
+    top || 0.0
+  end
+
+  def set_size(_, height)
+    if panel_height != clipped_content_height || clipped_content_height.zero?
+      self.clipped_content_height = height
+      # self.scroll_goto_y = self.scroll_y unless scroll_y == top
+    end
+  end
+
+  def offset
+    ((panel_content_height * scroll_percent) - (panel_height * scroll_percent))
+  end
+
+  def content_height
+    clipped_content_height
+  end
+
+  def panel_content_height
+    clipped_content_height < panel_height ? panel_height : clipped_content_height
+  end
+
+  def scroll_active
+    clipped_content_height > panel_height
+  end
+
+  def scroll_complete(y, percent:)
+    self.scroll_y = y
+    self.scroll_percent = percent
+    self.scroll_goto_y = nil
+
+    # todo handle selection
+
+    emit("scroll", y, percent: percent)
+  end
+
+  def scrollbar_goto
+    scroll_goto_y || scroll_goto
+  end
+
+  def scroll_control_height
+    return 20.0 if panel_height <= 0.0
+
+    (panel_height / panel_content_height) * panel_height
+  end
+
+  def render(canvas)
+    self.top = canvas.y
+    self.panel_height = canvas.height
+
+    yield canvas
+  end
+end

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

@@ -0,0 +1,24 @@
+class Hokusai::Blocks::Rect < Hokusai::Block
+  template <<~EOF
+    [template]
+      slot
+  EOF
+
+  computed :color, default: nil, convert: Hokusai::Color
+  computed :rounding, default: 0.0
+  computed :outline, default: nil, convert: Hokusai::Outline
+  computed :outline_color, default: nil, convert: Hokusai::Color
+
+  def render(canvas)
+    draw do
+      rect(canvas.x, canvas.y, canvas.width, canvas.height) do |command|
+        command.color = color unless color.nil?
+        command.outline = outline unless outline.nil?
+        command.outline_color = outline_color unless outline_color.nil?
+        command.round = rounding
+      end
+    end
+
+    yield canvas
+  end
+end

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

@@ -0,0 +1,18 @@
+class Hokusai::Blocks::ScissorBegin < Hokusai::Block
+  template <<~EOF
+  [template]
+    slot
+  EOF
+
+  computed :offset, default: 0.0, convert: proc(&:to_f)
+
+  def render(canvas)
+    draw do
+      scissor_begin(canvas.x, canvas.y, canvas.width, canvas.height)
+    end
+
+    canvas.y -= offset
+
+    yield canvas
+  end
+end

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

@@ -0,0 +1,12 @@
+class Hokusai::Blocks::ScissorEnd < Hokusai::Block
+  template <<~EOF
+  [template]
+    virtual
+  EOF
+
+  def render(canvas)
+    draw do
+      scissor_end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+class Hokusai::Blocks::Scrollbar < Hokusai::Block
+  template <<~EOF
+    [template]
+      vblock.scrollbar {
+        @mousedown="scroll_start"
+        @mousemove="scroll_handle"
+        :background="background"
+      }
+        rect.top {
+          :height="scroll_top_height"
+        }
+          empty
+        rect.control {
+          :color="control_color"
+          :height="control_height"
+          :rounding="control_rounding"
+          :outline="control_padding"
+          outline_color="0,0,0,0"
+        }
+          empty
+        rect.bottom
+          empty
+  EOF
+
+  uses(
+    vblock: Hokusai::Blocks::Vblock,
+    rect: Hokusai::Blocks::Rect,
+    empty: Hokusai::Blocks::Empty
+  )
+
+  computed :goto, default: nil
+  computed :background, default: [22,22,22], convert: Hokusai::Color
+  computed :control_color, default: [66,66,66], convert: Hokusai::Color
+  computed :control_height, default: 20.0, convert: proc(&:to_f)
+  computed :control_rounding, default: 0.75, convert: proc(&:to_f)
+  computed :control_padding, default: 2.0, convert: proc(&:to_f)
+
+  attr_accessor :scroll_y, :scrolling, :height, :offset
+
+  def scroll_start(event)
+    self.scrolling = true
+    do_goto(event.pos.y)
+
+    event.stop
+  end
+
+  def scroll_handle(event)
+    if event.left.down && scrolling
+      do_goto(event.pos.y)
+    else
+      self.scrolling = false
+    end
+
+    # event.stop
+  end
+
+  def scroll_top_height
+    start = scroll_y
+    control_middle = (control_height / 2)
+
+    if start <= offset + control_middle
+      return 0.0
+    elsif start >= offset + height - control_middle
+      return height - control_height
+    else
+      return scroll_y - offset - control_middle
+    end
+
+    0.0
+  end
+
+  def after_updated
+    do_goto(goto) unless goto.nil?
+  end
+
+  def percent_scrolled
+    return 0 if scroll_top_height === 0
+
+    scroll_top_height / (height - control_height)
+  end
+
+  def do_goto(value)
+    self.scroll_y = value.to_f
+
+    emit("scroll", scroll_y, percent: percent_scrolled)
+  end
+
+  def initialize(**args)
+    @scroll_y = 0.0
+    @scrolling = false
+    @height = 0.0
+    @offset = 0.0
+
+    super(**args)
+  end
+
+  def render(canvas)
+    self.offset = canvas.y
+    self.height = canvas.height
+
+    yield(canvas)
+  end
+end

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

@@ -0,0 +1,77 @@
+require_relative "../util/selection"
+
+module Hokusai::Blocks
+  class Selectable < Hokusai::Block
+    template <<~EOF
+      [template]
+        vblock {
+          @click="start_selection"
+          @hover="update_selection"
+        }
+          slot
+          cursor {
+            height="0"
+            :color="cursor_color"
+            :x="cursor_x"
+            :y="cursor_y"
+            :cursor_height="cursor_height"
+            :show="cursor_show"
+          }
+    EOF
+
+    uses(
+      vblock: Hokusai::Blocks::Vblock,
+      cursor: Hokusai::Blocks::Cursor
+    )
+
+    computed :cursor_color, default: [255,22,22], convert: Hokusai::Color
+
+    provide :selection, :selection
+
+    attr_reader :selection
+
+    def initialize(**args)
+      @selection = Hokusai::Util::Selection.new
+
+      super
+    end
+
+    def start_selection(event)
+      if event.left.down && !selection.active?
+        selection.start(event.pos.x, event.pos.y)
+      end
+    end
+
+    def update_selection(event)
+      return unless selection.active?
+
+      if event.left[:up]
+        selection.freeze!
+      elsif event.left[:down]
+        selection.stop(event.pos.x, event.pos.y)
+      end
+    end
+
+    def cursor_x
+      cursor(0)
+    end
+
+    def cursor_y
+      cursor(1)
+    end
+
+    def cursor_height
+      cursor(3)
+    end
+
+    def cursor_show
+      !selection.cursor.nil?
+    end
+
+    def cursor(index)
+      return if selection.cursor.nil?
+
+      selection.cursor[index]
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+class Hokusai::Blocks::SVG < Hokusai::Block
+  template <<~EOF
+    [template]
+      virtual
+  EOF
+
+  computed! :source
+  computed :size, default: 12, convert: proc(&:to_i)
+  computed :color, default: [255,255,255], convert: Hokusai::Color
+
+  def render(canvas)
+    draw do
+      svg(source, canvas.x, canvas.y, size, size) do |command|
+        command.color = color
+      end
+    end
+
+    yield canvas
+  end
+end