hokusai-zero 0.1.1

data/ui/src/hokusai/util/clamping_iterator.rb

@@ -0,0 +1,202 @@
+module Hokusai::Util
+  class SegmentRenderer
+    attr_reader :iterator, :segment
+    attr_accessor :started, :start_select, :stop_select,
+                  :select_x, :select_width
+
+    def initialize(segment, iterator)
+      @segment = segment
+      @iterator = iterator
+      @started = false
+      @start_select = 0
+      @stop_select = nil
+      @select_x = nil
+      @select_width = nil
+    end
+
+    def draw(font_size, boundary, selection: nil)
+      selection_extract(font_size, boundary, selection: selection)
+      draw_text(font_size, boundary)
+      selection_update(selection)
+      # self.start_select = 0.0
+      # self.stop_select = nil
+    end
+
+    def selection_extract(font_size, boundary, selection: nil)
+      local_x = iterator.x
+      y = iterator.y
+      hit_box = Hokusai::Rect.new(0, 0, 0, 0)
+
+      segment.chars.each do |char|
+        if can_render_inside(font_size, boundary) && segment.char_is_selected(char)
+          self.select_x ||= local_x
+          self.select_width = select_width.nil? ? char.width : (select_width + char.width)
+  
+          if selector = selection
+            if segment.select_begin == char.offset && selector.up? && !iterator.cursor_set && !selector.started
+              iterator.cursor_position = [local_x, y, char.width, font_size.to_f]
+              iterator.cursor_set = true
+              selector.started = true
+            elsif segment.select_end == char.offset && selector.down? && started
+              iterator.cursor_position = [local_x + char.width, y, char.width, font_size.to_f]
+            end
+          end
+        elsif !segment.select_end.nil? && segment.select_end < char.offset
+          selection&.started = false
+        end
+
+        # hit_box.x = local_x
+        # hit_box.y = y
+        # hit_box.width = char.width
+        # hit_box.height = font_size.to_f
+        hit_box = Hokusai::Rect.new(local_x, y, char.width, font_size.to_f)
+        iterator.on_char_cb&.call(char, hit_box, char.offset)
+
+        if selector = selection
+          if selector.active? && selector.selected(local_x, y, char.width.to_f, font_size.to_f)
+            self.stop_select = char.offset
+
+            unless started
+              self.start_select = char.offset
+              self.started = true
+            end
+          end
+        end
+
+        local_x += char.width
+      end
+
+      return unless select_x && select_width
+      iterator.on_draw_selection_cb&.call(select_x, y, select_width, font_size.to_f)
+    end
+
+    def selection_update(selection)
+      return unless selection&.active?
+      segment.make_selection(start_select, stop_select)
+
+      return if stop_select.nil?
+
+      iterator.start_select ||= start_select + iterator.cursor_offset
+      iterator.stop_select = stop_select + iterator.cursor_offset
+    end
+
+    def draw_text(font_size, boundary)
+      if can_render_inside(font_size, boundary)
+        x = @iterator.x
+
+        if @iterator.clamping.markdown
+
+          segment.groups.each do |group|
+            text = iterator.clamping[group.offset, group.size]
+
+            if text == " "
+              x += group.width * 2
+              
+              next
+            end
+            
+            @iterator.on_draw_cb&.call(text, x, y, group)
+            x += group.width
+          end
+        else
+          @iterator.on_draw_cb&.call(text, x, y, segment)
+        end
+      end
+
+      @iterator.y += font_size
+      @iterator.height += font_size
+    end
+
+    def x
+      iterator.x
+    end
+
+    def y
+      iterator.y
+    end
+
+    def text
+      iterator.clamping[segment.offset, segment.size]
+    end
+
+    def can_render_inside(font_size, boundary)
+      iterator.y >= boundary[0] && iterator.y + font_size <= boundary[1]
+    end
+  end
+
+  class ClampingIterator
+    attr_reader :segments, :clamping,
+                :on_draw_cb, :on_draw_selection_cb,
+                :on_selection_change_cb, :on_cursor_change_cb,
+                :on_char_cb
+
+    attr_accessor :produced, :height, :cursor_offset, :x, :y,
+                  :start_select, :stop_select, :cursor_position, :cursor_set
+
+    def initialize(clamping, x, y)
+      @clamping = clamping
+      @x = x
+      @y = y
+      @height = 0
+      @cursor_offset = 0
+      @cursor_set = false
+      @i = 0
+    end
+
+    def reset
+      @i = 0
+    end
+
+    def debug
+      clamping.debug
+    end
+
+    def segments
+      clamping.segments
+    end
+    
+    def next
+      if @i < segments.size
+        SegmentRenderer.new(segments[@i], self)
+      else
+        if position = cursor_position
+          on_cursor_change_cb&.call(position)
+        end
+
+        if start = start_select
+          on_selection_change_cb&.call(start, stop_select)
+        end
+      end
+    ensure
+      @i += 1
+    end
+
+    def cursor_y
+      y
+    end
+
+    def cursor_x
+      x
+    end
+
+    def on_draw(&block)
+      @on_draw_cb = block
+    end
+
+    def on_draw_selection(&block)
+      @on_draw_selection_cb = block
+    end
+
+    def on_selection_change(&block)
+      @on_selection_change_cb = block
+    end
+
+    def on_cursor_change(&block)
+      @on_cursor_change_cb = block
+    end
+
+    def on_char(&block)
+      @on_char_cb = block
+    end
+  end
+end

data/ui/src/hokusai/util/piece_table.rb

@@ -0,0 +1,111 @@
+require "stringio"
+
+module Hokusai::Util
+  class PieceTable
+    attr_accessor :buffer, :buffer_add, :last_piece_index
+    attr_reader :pieces
+
+    def initialize(buffer = "")
+      @pieces = [[:original, 0, buffer.size]]
+      @buffer_add = ""
+      @buffer = buffer
+      @last_piece_index = nil
+    end
+
+    def to_s
+      io = StringIO.open do |io|
+        pieces.each do |(which, start, size)|
+          case which
+          when :original
+            io.write buffer[start, size]
+          else
+            if buffer_add[start, size].nil?
+              raise Hokusai::Error.new("#{which} Bad: #{start} #{size}")
+            end
+
+            io.write buffer_add[start, size]
+          end
+        end
+
+        io.string
+      end
+
+      io
+    end
+
+    def insert(text, offset = buffer.size - 1)
+      return nil if text.size.zero?
+
+      piece_at_buffer_offset(offset) do |(piece, index, remainder)|
+        which, start, size = piece
+        length = remainder - start
+        
+        new_pieces = []
+        new_pieces << [which, start, length] if length > 0
+        new_pieces << [:add, buffer_add.size, text.size]
+        new_pieces << [which, length + start, size - length] if size - length > 0
+  
+        self.last_piece_index = index + 1
+        self.pieces[index..index] = new_pieces
+        self.buffer_add += text
+      end
+    end
+
+    def delete(offset, count)
+      piece_at_buffer_offset(offset) do |(piece_left, index_left, remainder_left)|
+        piece_at_buffer_offset(offset + count) do |(piece_right, index_right, remainder_right)|
+          if index_left == index_right
+            if remainder_left == piece_left[1]
+              pieces[index_left] = [piece_left[0], piece_left[1] + count, piece_left[2] - count]
+
+              return
+            elsif remainder_right == piece_left[1] + piece_left[2]
+              pieces[index_left] = [piece_left[0], piece_left[1], piece_left[2] - count]
+              
+              return
+            end
+          end
+  
+          new_pieces = []
+          left = [piece_left[0], piece_left[1], remainder_left - piece_left[1]]
+          left_condition = (remainder_left - piece_left[1] > 0)
+          right = [piece_right[0], remainder_right, piece_right[2] - (remainder_right - piece_right[1])]
+          right_condition =  (piece_right[2] - (remainder_right - piece_right[1]) > 0)
+
+          if !left_condition && !right_condition
+            new_pieces << left
+          end
+          
+          if left_condition
+            new_pieces << left
+          end
+
+          if right_condition
+            new_pieces << right
+          end
+
+          self.pieces[index_left..index_right] = new_pieces
+          self.last_piece_index = nil
+        end
+      end
+    end
+
+    private def piece_at_buffer_offset(offset)
+      raise Hokusai::Error.new("Piece table offset is negative") if offset.negative?
+  
+      remainder = offset
+  
+      pieces.each_with_index do |piece, index|
+        if remainder <= piece[2]
+          yield([piece, index, remainder + piece[1]])
+          
+          return
+        end
+  
+        remainder -= piece[2]
+      end      
+
+      raise Hokusai::Error.new("Piece table offset is greater than the buffer! #{offset}\n#{pieces}")
+    end
+  end
+end

data/ui/src/hokusai/util/selection.rb

@@ -0,0 +1,145 @@
+module Hokusai::Util
+  class Selection
+    attr_reader :raw
+    attr_accessor :started
+
+    def initialize
+      ptr = FFI::MemoryPointer.new :pointer
+      LibHokusai.hoku_selection_init(ptr)
+      @raw = LibHokusai::HokuSelection.new(ptr.get_pointer(0))
+      ptr.free
+      @started = false
+    end
+
+    def type
+      raw[:type]
+    end
+
+    def none?
+      type == :none
+    end
+
+    def ready?
+      type == :none || type == :frozen
+    end
+
+    def clear
+      raw[:start_x] = 0.0
+      raw[:stop_x] = 0.0
+      raw[:start_y] = 0.0
+      raw[:stop_y] = 0.0
+      raw[:cursor] = nil
+
+      activate!
+    end
+
+    def active?
+      type == :active
+    end
+
+    def frozen?
+      type == :frozen
+    end
+
+    def activate!
+      raw[:type] = :active
+    end
+
+    def freeze!
+      raw[:type] = :frozen
+    end
+
+    def coords
+      [start_x, stop_x, start_y, stop_y]
+    end
+
+    def offset_y=(val)
+      raw[:offset_y] = val
+    end
+
+    def offset_y
+      raw[:offset_y]
+    end
+
+    def start(x, y)
+      raw[:start_x] = x
+      raw[:start_y] = y
+      raw[:stop_x] = x
+      raw[:stop_y] = y
+
+      raw[:cursor] = nil
+
+      activate!
+    end
+
+    def stop(x, y)
+      raw[:stop_x] = x
+      raw[:stop_y] = y
+    end
+
+    def start_x
+      raw[:start_x]
+    end
+
+    def stop_x
+      raw[:stop_x]
+    end
+
+    def stop_y
+      raw[:stop_y]
+    end
+
+    def start_y
+      raw[:start_y]
+    end
+
+    def up?
+      stop_y < start_y
+    end
+
+    def down?
+      start_y <= stop_y
+    end
+
+    def left?
+      stop_x < start_x
+    end
+
+    def right?
+      start_x <= stop_x
+    end
+
+    def cursor=(position)
+      if position.nil?
+        LibHokusai.hoku_selection_cursor_free(raw)
+        return
+      end
+
+      pos = LibHokusai::HokuCursorPosition.create(position)
+
+      ret = LibHokusai.hoku_selection_cursor_set(raw, pos)
+
+      raise Hokusai::Error.new("Could not set cursor") if !ret.zero?
+    end
+
+    def cursor
+      return nil if raw[:cursor].null?
+
+      if frozen?
+        return [raw[:cursor][:x], raw[:cursor][:y] - offset_y, raw[:cursor][:w], raw[:cursor][:h]]
+      end
+
+      [raw[:cursor][:x], raw[:cursor][:y], raw[:cursor][:w], raw[:cursor][:h]]
+    end
+
+    def rect_selected(rect)
+      selected(rect[0], rect[1], rect[2], rect[3])
+    end
+
+    def selected(x, y, width, height)
+      return false if none?
+
+      LibHokusai.hoku_selection_selected(raw, x, y, width, height)
+    end
+  end
+end

data/ui/src/hokusai.rb

@@ -0,0 +1,120 @@
+require_relative '../lib/lib_hokusai'
+require_relative './hokusai/error'
+require_relative './hokusai/types'
+require_relative './hokusai/ast'
+require_relative './hokusai/style'
+require_relative './hokusai/node'
+require_relative './hokusai/block'
+require_relative './hokusai/commands'
+require_relative './hokusai/font'
+require_relative './hokusai/event'
+require_relative './hokusai/painter'
+require_relative './hokusai/util/selection'
+require_relative './hokusai/util/piece_table'
+require_relative './hokusai/blocks/empty'
+require_relative './hokusai/blocks/vblock'
+require_relative './hokusai/blocks/hblock'
+require_relative './hokusai/blocks/label'
+require_relative './hokusai/blocks/rect'
+require_relative './hokusai/blocks/button'
+require_relative './hokusai/blocks/circle'
+require_relative './hokusai/blocks/checkbox'
+require_relative './hokusai/blocks/scissor_begin'
+require_relative './hokusai/blocks/scissor_end'
+require_relative './hokusai/blocks/clipped'
+require_relative './hokusai/blocks/cursor'
+require_relative './hokusai/blocks/image'
+require_relative './hokusai/blocks/svg'
+require_relative './hokusai/blocks/toggle'
+require_relative './hokusai/blocks/scrollbar'
+require_relative './hokusai/blocks/dynamic'
+require_relative './hokusai/blocks/panel'
+require_relative './hokusai/blocks/text'
+require_relative './hokusai/blocks/selectable'
+require_relative './hokusai/blocks/input'
+require_relative './hokusai/blocks/titlebar/osx'
+
+require "concurrent"
+
+module Hokusai
+  ThreadPool = Concurrent::ThreadPoolExecutor.new(
+    min_threads: 5,
+    max_threads: 5,
+    max_queue: 20,
+    fallback_policy: :caller_runs
+  )
+
+  def self.fonts
+    @fonts ||= FontRegistry.new
+  end
+
+  def self.close_window
+    @on_close_window&.call
+  end
+
+  def self.on_close_window(&block)
+    @on_close_window = block
+  end
+
+  def self.on_restore_window(&block)
+    @on_restore_window = block
+  end
+
+  def self.restore_window
+    @on_restore_window&.call
+  end
+
+  def self.minimize_window
+    @on_minimize_window&.call
+  end
+
+  def self.on_minimize_window(&block)
+    @on_minimize_window = block
+  end
+
+  def self.maximize_window
+    @on_maximize_window&.call
+  end
+
+  def self.on_maximize_window(&block)
+    @on_maximize_window = block
+  end
+
+  # Sets the window position on the screen
+  #
+  # NOTE the implementation is backend specific
+  def self.set_window_position(mouse)
+    @on_set_window_position&.call(mouse)
+  end
+
+  def self.on_set_window_position(&block)
+    @on_set_window_position = block
+  end
+
+  # Sets the mouse position on the screen
+  #
+  # NOTE the implementation is backend specific
+  def self.on_set_mouse_position(&block)
+    @on_set_mouse_position = block
+  end
+
+  def self.set_mouse_position(mouse)
+    @on_set_mouse_position&.call(mouse)
+  end
+
+  def self.on_renderable(&block)
+    @on_renderable = block
+  end
+
+  def self.can_render(canvas)
+    @on_renderable&.call(canvas)
+  end
+
+  def self.on_set_mouse_cursor(&block)
+    @on_set_mouse_cursor = block
+  end
+
+  def self.set_mouse_cursor(type)
+    @on_set_mouse_cursor&.call(type)
+  end
+end