hokusai-zero 0.2.6 → 0.2.8

data/ui/src/hokusai/types.rb

@@ -1,266 +1,42 @@
 # 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
+require_relative "./types/primitives"
+require_relative "./types/display"
+require_relative "./types/touch"
+require_relative "./types/mouse"
+require_relative "./types/keyboard"
 
-    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
+module Hokusai
+  class Input
+    attr_accessor :keyboard_override
+    attr_reader :raw, :touch
 
     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
+      [self.class, mouse.pos.x, mouse.pos.y, mouse.scroll, mouse.left.clicked, mouse.left.down, mouse.left.up].hash
     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
+    def initialize
+      @touch = nil
+      @keyboard_override = false
     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 support_touch!
+      @touch ||= Touch.new
 
-    def initialize(raw)
-      @raw = raw
+      self
     end
 
     def keyboard
-      Keyboard.new(@raw[:keyboard])
+      @keyboard ||= Keyboard.new
     end
 
     def mouse
-      @mouse ||= Mouse.new(@raw[:mouse])
+      @mouse ||= Mouse.new
     end
 
     def hovered?(canvas)
-      LibHokusai.hoku_input_is_hovered(raw, canvas.to_hoku_rect)
+      pos = mouse.pos
+      pos.x >= canvas.x && pos.x <= canvas.x + canvas.width && pos.y >= canvas.y && pos.y <= canvas.y + canvas.height
     end
   end
 end

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

@@ -1,7 +1,7 @@
 module Hokusai::Util
   class Selection
     attr_reader :raw
-    attr_accessor :started
+    attr_accessor :started, :cleared
 
     def initialize
       ptr = FFI::MemoryPointer.new :pointer
@@ -9,6 +9,9 @@ module Hokusai::Util
       @raw = LibHokusai::HokuSelection.new(ptr.get_pointer(0))
       ptr.free
       @started = false
+      @direction = nil
+      @changed_direction = false
+      @cleared = false
     end
 
     def type
@@ -30,9 +33,14 @@ module Hokusai::Util
       raw[:stop_y] = 0.0
       raw[:cursor] = nil
 
+      self.cleared = true
       activate!
     end
 
+    def changed_direction?
+      @changed_direction
+    end
+
     def active?
       type == :active
     end
@@ -73,8 +81,17 @@ module Hokusai::Util
     end
 
     def stop(x, y)
+      self.cleared = false
       raw[:stop_x] = x
       raw[:stop_y] = y
+
+      if up? && @direction == :down || down? && @direction == :up
+        @changed_direction = true
+      else
+        @changed_direction = false
+      end
+
+      @direction = up? ? :up : :down
     end
 
     def start_x
@@ -93,12 +110,12 @@ module Hokusai::Util
       raw[:start_y]
     end
 
-    def up?
-      stop_y < start_y
+    def up?(height = 0)
+      stop_y < start_y - height
     end
 
-    def down?
-      start_y <= stop_y
+    def down?(height = 0)
+      start_y <= stop_y - height
     end
 
     def left?
@@ -126,7 +143,7 @@ module Hokusai::Util
       return nil if raw[:cursor].null?
 
       if frozen?
-        return [raw[:cursor][:x], raw[:cursor][:y] - offset_y, raw[:cursor][:w], raw[:cursor][:h]]
+        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]]
@@ -139,7 +156,11 @@ module Hokusai::Util
     def selected(x, y, width, height)
       return false if none?
 
-      LibHokusai.hoku_selection_selected(raw, x, y, width, height)
+      if frozen?
+        return LibHokusai.hoku_selection_selected(raw, x, y + offset_y, width, height)
+      else
+        LibHokusai.hoku_selection_selected(raw, x, y, width, height)
+      end
     end
   end
 end

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

@@ -0,0 +1,268 @@
+class Wrapped
+  attr_accessor :text, :x, :y, :extra
+  
+  def initialize(text, x, y, extra)
+    @text = text
+    @x = x
+    @y = y
+    @extra = extra
+  end
+end
+
+class SelectionWrapper
+  attr_accessor :x, :y, :width, :height, :offset, :buffer
+
+  def initialize(x, y, w, h)
+    @x = x
+    @y = y
+    @width = w
+    @height = h
+    @offset = 0.0
+    @buffer = ""
+  end
+
+  def <<(w)
+    @width += w
+  end
+end
+
+class WrapStream
+  attr_accessor :width, :current_width, :x, :y, :offset_y,
+                :origin_x, :origin_y, :buffer, :stack, :widths, :current_height,
+                :current_offset, :srange, :last, :first
+  attr_reader :on_text_cb, :on_text_selection_cb, :on_advancex_cb, :selector, :padding
+
+  def initialize(width, &measure)
+    @width = width
+    @current_width = 0.0
+
+    @origin_x = 0.0
+    @origin_y = 0.0
+    @x = @origin_x
+    @y = @origin_y
+
+    @current_offset = 0
+    @current_height = 0.0
+    @widths = []
+    @stack = []
+    @srange = nil
+    @selected = ""
+    @buffer = ""
+    @last = nil
+    @first = nil
+
+    @measure_cb = measure
+  end
+
+  def reset(width)
+    @width = width
+    @current_width = 0.0
+
+    @x = @origin_x
+    @y = @origin_y
+
+    @current_offset = 0
+    @current_height = 0.0
+    @widths = []
+    @stack = []
+    @selected = ""
+    @buffer = ""
+  
+    @first = nil
+
+    if @selector&.cleared
+      @selector&.cursor = nil
+
+      @srange = nil
+      @last = nil
+    end
+  end
+
+  def on_text_selection(selector, padding, &block)
+    @selector = selector
+    @padding = padding || Hokusai::Padding.new(0.0, 0.0, 0.0, 0.0)
+    @on_text_selection_cb = block
+  end
+
+  def on_bounds(&block)
+    @on_bounds_cb = block
+  end
+
+  def on_text(&block)
+    @on_text_cb = block
+  end
+
+  def measure(string, extra)
+    @measure_cb.call(string, extra)
+  end
+
+  def flush
+    sx = x
+    wrapper = nil
+    ii = 0
+    in_bounds = @on_bounds_cb.nil? ? true : @on_bounds_cb.call(y - offset_y)
+
+    stack.each do |(range, extra)|
+      size = buffer[range].size
+      if selector && in_bounds
+        i = 0
+        while i < size
+          nw = widths[i]
+          nh = current_height
+
+          # A char is selected
+          if selector.active? && selector.selected(sx, y, nw, nh)
+            # srange is for selecting downward.
+            # We cache the first char (our pivot point) and as we continue processing
+            # we can just append the next offset to the range
+            # self.srange ||= ((current_offset + i)..(current_offset + i))
+
+            # Selecting upward is more tricky.
+            # We need to cache the current offset as the first and last.
+            # After we process the whole text, we can nil the first offset
+            # And the next iteration the selection will pick up the new first offset
+            # The last offset will remain the origin (pivot)
+            # self.last ||= current_offset + i
+            self.first ||= current_offset + i
+            self.last = current_offset + i
+            self.srange = (first..last)
+          elsif selector.frozen? && selector.up? && selector.selected(sx, y, nw, nh)
+            self.first ||= current_offset + i
+          end
+
+          if srange&.include?(current_offset + i)
+            wrapper ||= begin
+              w = SelectionWrapper.new(sx, y, 0.0, nh)
+              w
+            end
+
+            if selector.up?(nh) && first == current_offset + i
+              selector.cursor ||= [sx, y - offset_y, 1.0, nh]
+            elsif selector.down? && last == current_offset + i
+              selector.cursor = [sx + nw, y - offset_y, 1.0, nh]
+            end
+          
+            wrapper << nw
+            wrapper.buffer << (buffer[ii + i] || "")
+          end
+
+          i = i.succ
+          sx += nw
+        end
+
+        on_text_selection_cb.call(wrapper) if wrapper 
+        wrapper = nil
+      end
+
+      ii += size
+      self.current_offset += size
+
+      nw = widths[range].sum
+      # hard break on the buffer, split on character
+      wrap_and_call(buffer[range], extra)
+      self.x += nw
+    end
+
+    self.current_width = 0.0
+    self.buffer = ""
+    stack.clear
+    widths.clear
+    self.x = origin_x
+  end
+
+  NEW_LINE_REGEX = /\n|\r\n/
+
+  def wrap(text, extra)
+    offset = 0
+    size = text.size
+
+    stack << [((buffer.size)..(text.size + buffer.size - 1)), extra]
+
+    while offset < size
+      w, h = measure(text[offset], extra)
+      self.current_height = h
+
+      # if it's a newline we want to break
+      if text[offset] =~ NEW_LINE_REGEX
+        self.widths << 0
+        self.buffer << text[offset]
+        flush
+
+        stack << [(0...(text.size - offset - 1)), extra]
+        self.y += h
+        self.x = origin_x
+        offset += 1
+
+        next
+      end
+
+      # if adding this char extends beyond the boundary
+      if current_width + w > width
+        # find the last space
+        idx = buffer.rindex(" ")
+        
+        # if there is a break in this line split the buffer
+        # and render the current line
+        unless idx.nil? || idx < (buffer.size / 2)
+          cur = []
+          nex = []
+
+          found = false
+
+          # We need to split up both the buffer, and the ranges
+          while payload = stack.shift
+            range, xtra = payload
+            if range.include?(idx)
+              # putting the space on this line
+              cur << [(range.begin..idx), xtra]
+              nex << [(0..(range.end - idx - 1)), xtra] unless idx == range.end
+              
+              found = true
+            elsif !found
+              cur << payload
+            else
+              nex << [((range.begin - idx - 1)..(range.end - idx - 1)), xtra] 
+            end
+          end
+
+          scur = buffer[0..idx]
+          snex = buffer[(idx + 1)..-1]
+          
+          wcur = widths[0..idx]
+          wnex = widths[(idx + 1)..-1]
+
+          self.buffer = scur
+          self.widths = wcur
+          self.stack = cur
+          flush
+
+          self.buffer = snex + text[offset]
+          self.widths = wnex.concat([w])
+          self.stack = nex
+          self.y += h
+          self.current_width = widths.sum
+          self.x = origin_x
+        else
+          # break on this word
+          flush
+
+          self.y += h
+          self.current_width = w
+          self.buffer = text[offset]
+          self.widths = [w]
+          stack << [(0...(text.size - offset)), extra]
+        end
+      else
+        self.current_width += w
+        widths << w
+        buffer << text[offset]
+      end
+
+      offset += 1
+    end
+  end
+
+  private def wrap_and_call(text, extra)
+    on_text_cb.call Wrapped.new(text, x, y, extra)
+  end
+end