hokusai-zero 0.2.7 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 608b618b6ed01eea7db698a5e8d18d7916d8e06ef9227b6ce0b24a9e9e744d24
-  data.tar.gz: f0ae7f8a0e94aa8056989af6090a8e734dc1674880a3b138338d6f15a55500d0
+  metadata.gz: 3430bbda86d7deae31c2e789646f7347e378bb8e0349bb7f37545010417b5d1f
+  data.tar.gz: 72457b126d79909ef0989cb67fd278993377b7aa18b9e759b6822e2c05380e8c
 SHA512:
-  metadata.gz: 42dad85dbcaf2e3a5bf5af87cfb608b18be65b978cdeac5fe13aa6f27c944ae0661aa3c92045d296e65065049482f66d4a02d27a187950a18fa5060857b0712b
-  data.tar.gz: ae90ae51b1025fe9f991b05ef632b7ff4f354c541f34ad507c8c8e90ac8cd80ee35e759ae82cb45f2d8060530572c9dba468a6433b76ec76b64df4705fb45991
+  metadata.gz: 407646a8c7bb287f18b1cc864d72150f4f93f12e29dbcb833befb9968ee5bbea48e0447fda35ca9b40513e4a371db499bc3cd4457e66f8f1d70a6b1d6c0692bb
+  data.tar.gz: ea2e824fb8df8fb0c0a28fbf2ffeb6768f6c2a66d900bf0f2146e04da68dad0a9d93e30eb36d654a60deec1fa4d0625321d9d21a47156a3162bd428f10049b8d

data/ast/src/core/hml.c

@@ -707,6 +707,8 @@ int hoku_style_from_template(hoku_style** out, char* template)
 		return -1;
 	}
 
+	ts_tree_delete(tree);
+	ts_parser_delete(parser);
 	*out = style;
 	return 0;
 }

data/hokusai.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'hokusai-zero'
-  s.version     = '0.2.7'
+  s.version     = '0.2.8'
   s.licenses    = ['MIT']
   s.summary     = "A Ruby library for writing GUI applications"
   s.authors     = ["skinnyjames"]

data/ui/spec/hokusai/e2e/client_spec.rb

@@ -19,7 +19,6 @@ describe Hokusai::Automation::Client do
       attr_accessor :count
 
       def increment(_event)
-        # pp ["INCREMENTING FUCK"]
         self.count += 1
       end
 

data/ui/src/hokusai/backends/raylib/font.rb

@@ -26,7 +26,7 @@ module Hokusai
       class Font < Hokusai::Font
         attr_reader :raw, :sdf
 
-        DEFAULT = "–—‘’“”…\r\n\t0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%%^&*(),.?/\"\\[]-_=+|~`{}<>;:'\0"
+        DEFAULT = "–—‘’“”…\r\n\t\s0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%%^&*(),.?/\"\\[]-_=+|~`{}<>;:'\0"
 
         def self.default
           font = Raylib.GetFontDefault
@@ -83,6 +83,26 @@ module Hokusai
           @raw = raw
           @spacing = spacing
           @sdf = sdf
+          @measure_map = {}
+
+          DEFAULT.split("").each do |char|
+            @measure_map[char] ||= begin
+              bcount = FFI::MemoryPointer.new(:int)
+              letter = Raylib.GetCodepoint(char, bcount)
+              bcount.free
+              info = Raylib.GetGlyphInfo(raw, letter)
+              if info.advanceX > 0
+                w = info.advanceX
+              else
+                w = info.image.width + info.offsetX
+              end
+            
+              ->(size) do
+                width = (size.to_f / raw.baseSize.to_f) * w + (spacing)
+                width
+              end
+            end
+          end
         end
 
         # returns the spacing for this font
@@ -94,6 +114,16 @@ module Hokusai
           (ssize / (raw.baseSize.zero? ? 1 : raw.baseSize)).to_f
         end
 
+        def measure_char(char, size)
+          w = @measure_map[char]&.call(size)
+
+          if w.nil?
+            measure(char, size).first
+          else
+            w
+          end
+        end
+
         def measure(string, size)
           vec = Raylib.MeasureTextEx(raw, string, size, spacing)
 

data/ui/src/hokusai/backends/raylib.rb

@@ -380,6 +380,10 @@ module Hokusai::Backends
         end
       end
 
+      Hokusai.on_copy do |text|
+        Raylib.SetClipboardText(text)
+      end
+
       Hokusai.on_set_mouse_position do |mouse|
         Raylib.SetMousePosition(mouse.pos.x, mouse.pos.y)
       end
@@ -410,6 +414,34 @@ module Hokusai::Backends
         inside_scissor(canvas.x, canvas.y, canvas.height)
       end
 
+      Hokusai::Commands::TranslationBegin.on_draw do |command|
+        Raylib.rlPushMatrix
+        Raylib.rlTranslatef(command.x, command.y, 0)
+      end
+
+      Hokusai::Commands::TranslationEnd.on_draw do |command|
+        Raylib.rlPopMatrix
+      end
+      
+      Hokusai::Commands::RotationBegin.on_draw do |command|
+        Raylib.rlPushMatrix
+        Raylib.rlTranslatef(command.x, command.y, 0)
+        Raylib.rlRotatef(command.degrees, 0, 0, 1);
+      end
+
+      Hokusai::Commands::RotationEnd.on_draw do
+        Raylib.rlPopMatrix
+      end
+
+      Hokusai::Commands::ScaleBegin.on_draw do |command|
+        Raylib.rlPushMatrix
+        Raylib.rlScalef(command.x, command.y, 0)
+      end
+
+      Hokusai::Commands::ScaleEnd.on_draw do
+        Raylib.rlPopMatrix
+      end
+
       Hokusai::Commands::ShaderBegin.on_draw do |command|
         self.class.shaders[command.hash] ||= Raylib.LoadShaderFromMemory(command.vertex_shader, command.fragment_shader)
 

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

@@ -25,6 +25,8 @@ class Hokusai::Blocks::Dynamic < Hokusai::Block
       w += block.node.meta.get_prop?(:width)&.to_f || 0.0
     end
 
+    node.meta.set_prop(:height, h)
+
     [w, h]
   end
 

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

@@ -39,6 +39,8 @@ class Hokusai::Blocks::Panel < Hokusai::Block
   provide :panel_height, :panel_height
   provide :panel_top, :panel_top
 
+  inject :selection
+
   attr_accessor :top, :panel_height, :scroll_y, :scroll_percent,
                 :scroll_goto_y, :clipped_offset, :clipped_content_height
 

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

@@ -1,7 +1,14 @@
 class Hokusai::Blocks::Scrollbar < Hokusai::Block
+  style <<~EOF
+  [style]
+  scrollbar {
+    cursor: "pointer";
+  }
+  EOF
   template <<~EOF
     [template]
       vblock.scrollbar {
+        ...scrollbar
         @mousedown="scroll_start"
         @mousemove="scroll_handle"
         :background="background"

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

@@ -38,6 +38,7 @@ module Hokusai::Blocks
 
     def start_selection(event)
       if event.left.down && !selection.active?
+        selection.clear
         selection.start(event.pos.x, event.pos.y)
       end
     end

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

@@ -0,0 +1,130 @@
+class Hokusai::Blocks::TextStream < Hokusai::Block
+  template <<~EOF
+  [template]
+    empty {
+      cursor="ibeam"
+    }
+  EOF
+
+  uses(empty: Hokusai::Blocks::Empty)
+
+  computed! :content
+  computed :font, default: nil
+  computed :size, default: 16, convert: proc(&:to_i)
+  computed :color, default: Hokusai::Color.new(33, 33, 33), convert: Hokusai::Color
+  computed :selection_color, default: Hokusai::Color.new(233,233,233), convert: Hokusai::Color
+  computed :padding, default: Hokusai::Padding.new(5.0, 5.0, 5.0, 5.0), convert: Hokusai::Padding
+  computed :cursor_offset, default: nil
+
+  inject :selection
+  inject :panel_top
+  inject :panel_height
+  inject :panel_offset
+
+  attr_accessor :last_commands, :last_content, :last_coords, :last_height,
+                :last_width, :last_selector, :last_panel_offset, :copying, :buffer
+
+  attr_reader :stream
+
+  def initialize(**args)
+    @last_commands = []
+    @last_coords = nil
+    @last_height = 0.0
+    @last_width = nil
+    @last_selector = nil
+    @last_content = nil
+    @last_panel_offset = nil
+    @last_canvas = nil
+    @copying = false
+    @reset = false
+    @buffer = ""
+
+    super
+  end
+
+  def after_updated
+    @stream&.reset(last_width)
+  end
+  
+  def render(canvas)
+    w = canvas.width - padding.left - padding.right
+    poff = panel_offset || 0.0 - panel_top || 0.0
+    selection&.offset_y = poff
+
+    lfont = Hokusai.fonts.active_font_name
+    Hokusai.fonts.activate font unless font.nil?
+
+    # if Hokusai.can_render(canvas)
+      # if (last_content != content || 
+      #     last_width != w || 
+      #     panel_offset != last_panel_offset || 
+      #     last_coords != selection&.coords || 
+      #     copying || 
+      #     last_selector != selection&.type)
+
+        last_commands.clear
+        self.last_panel_offset = panel_offset
+        self.last_content = content
+        self.last_width = w
+        self.last_selector = selection&.type
+        self.last_coords = selection&.coords
+
+        @stream ||= WrapStream.new(w) do |string, extra|
+          [Hokusai.fonts.active.measure_char(string, size), size]
+        end
+
+        stream.origin_x = canvas.x + padding.left
+        stream.origin_y = canvas.y + padding.top
+        stream.offset_y = 0.0
+        stream.reset(w)
+
+        draw do
+          stream.on_text_selection(selection, nil) do |wrapped|
+            self.buffer << wrapped.buffer if copying
+            rect(wrapped.x, wrapped.y, wrapped.width, wrapped.height) do |command|
+              command.color = selection_color
+
+              last_commands << command
+            end
+          end
+
+          stream.on_text do |wrapped|
+            text(wrapped.text, wrapped.x, wrapped.y) do |command|
+              command.color = color
+              command.size = size
+              command.font = font
+
+              last_commands << command
+            end
+          end
+
+          stream.wrap(content, nil)
+          stream.flush
+          stream.y += size
+        end
+
+        self.last_height = stream.y - canvas.y + padding.top + padding.bottom
+        emit("height_updated", last_height)
+        node.meta.set_prop(:height, last_height)
+
+
+      # else
+      #   draw do
+      #     queue.concat last_commands
+      #   end
+      # end
+
+      if copying
+        Hokusai.copy(buffer)
+        self.buffer = ""
+        self.copying = false
+      end
+
+      # node.portal&.meta&.set_prop(:height, last_height + padding.top + padding.bottom)
+
+      yield canvas
+    # end
+
+    Hokusai.fonts.activate lfont
+  end
+end

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

@@ -0,0 +1,91 @@
+class Hokusai::Blocks::TranslationBlock < Hokusai::Block
+  template <<~EOF
+  [template]
+    dynamic { @size_updated="set_size" }
+      slot
+  EOF
+
+  uses(dynamic: Hokusai::Blocks::Dynamic)
+
+  attr_accessor :content_width, :content_height
+
+  def set_size(width, height)
+    self.content_width = width
+    self.content_height = height
+    node.meta.set_prop(:width, width)
+    node.meta.set_prop(:height, height)
+  end
+
+  computed :duration, default: 500.0, convert: proc(&:to_f)
+  computed :from, default: :top, convert: proc(&:to_sym)
+
+  def on_mounted
+    @start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+  end
+
+  def circular_in(t)
+    return 1.0 - Math.sqrt(1.0 - t * t);
+  end
+
+  def bounce_out(x)
+    n1 = 7.5625;
+    d1 = 2.75;
+    if (x < 1 / d1)
+        return n1 * x * x;
+    elsif (x < 2 / d1)
+        return n1 * (x -= 1.5 / d1) * x + 0.75;
+    elsif (x < 2.5 / d1)
+        return n1 * (x -= 2.25 / d1) * x + 0.9375;
+    else
+        return n1 * (x -= 2.625 / d1) * x + 0.984375;
+    end
+  end
+
+  def bounce_in(t)
+    return 1.0 - bounce_out(1.0 - t);
+  end
+
+  def ease(x)
+    return 1 - Math.cos((x * Math::PI) / 2);
+  end
+
+  def render(canvas)
+    @canvas ||= canvas
+    time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) - @start
+
+    if time > duration
+      yield canvas
+
+      return
+    else
+      case from
+      when :top
+        @startx ||= canvas.x
+        @starty ||= canvas.y - canvas.height
+      when :left
+        @startx ||= canvas.x - canvas.width
+        @starty ||= canvas.y
+      when :right
+        @startx ||= canvas.x + canvas.width
+        @starty ||= canvas.y
+      when :bottom
+        @startx ||= canvas.x
+        @starty ||= canvas.y + canvas.height
+      end
+      
+      @targetx ||= canvas.x
+      @targety ||= canvas.y
+      
+      progress = bounce_in(time.to_f / duration)
+
+      if progress >= 1
+        progress = 1.0
+      end
+
+      canvas.x = (@startx + (-@startx * progress)) + (@targetx * progress)
+      canvas.y = (@starty + (-@starty * progress)) + (@targety * progress)
+
+      yield canvas
+    end
+  end
+end

data/ui/src/hokusai/commands/rotation.rb

@@ -0,0 +1,21 @@
+module Hokusai
+  class Commands::RotationBegin < Commands::Base
+    attr_reader :x, :y, :degrees
+
+    def initialize(x, y, deg)
+      @x = x
+      @y = y
+      @degrees = deg
+    end
+
+    def hash
+      [self.class, x, y, degrees].hash
+    end
+  end
+
+  class Commands::RotationEnd < Commands::Base;
+    def hash
+      [self.class].hash
+    end
+  end
+end

data/ui/src/hokusai/commands/scale.rb

@@ -0,0 +1,20 @@
+module Hokusai
+  class Commands::ScaleBegin < Commands::Base
+    attr_reader :x, :y
+
+    def initialize(x, y = x)
+      @x = x
+      @y = y
+    end
+
+    def hash
+      [self.class, x, y].hash
+    end
+  end
+
+  class Commands::ScaleEnd < Commands::Base;
+    def hash
+      [self.class].hash
+    end
+  end
+end

data/ui/src/hokusai/commands/translation.rb

@@ -0,0 +1,20 @@
+module Hokusai
+  class Commands::TranslationBegin < Commands::Base
+    attr_reader :x, :y
+
+    def initialize(x, y = x)
+      @x = x
+      @y = y
+    end
+
+    def hash
+      [self.class, x, y].hash
+    end
+  end
+
+  class Commands::TranslationEnd < Commands::Base;
+    def hash
+      [self.class].hash
+    end
+  end
+end

data/ui/src/hokusai/commands.rb

@@ -6,6 +6,9 @@ require_relative "./commands/scissor"
 require_relative "./commands/text"
 require_relative "./commands/shader"
 require_relative "./commands/texture"
+require_relative "./commands/rotation"
+require_relative "./commands/scale"
+require_relative "./commands/translation"
 
 module Hokusai
   # A proxy class for invoking various UI commands
@@ -33,7 +36,6 @@ module Hokusai
       yield(command)
 
       queue << command
-      # command.draw
     end
 
     # Draw a circle
@@ -46,9 +48,7 @@ module Hokusai
 
       yield(command)
 
-
       queue << command
-      # command.draw
     end
 
     # Draws an SVG
@@ -95,6 +95,30 @@ module Hokusai
       queue << Commands::ShaderEnd.new
     end
 
+    def rotation_begin(x, y, deg)
+      queue << Commands::RotationBegin.new(x, y, deg)
+    end
+
+    def rotation_end
+      queue << Commands::RotationEnd.new
+    end
+
+    def scale_begin(*args)
+      queue << Commands::ScaleBegin.new(*args)
+    end
+
+    def scale_end
+      queue << Commands::ScaleEnd.new
+    end
+
+    def translation_Begin(x, y)
+      queue << Commands::TranslationBegin.new
+    end
+
+    def translation_end
+      queue << Commands::TranslationEnd.new
+    end
+
     def texture(x, y, w, h)
       command = Commands::Texture.new(x, y, w, h)
 

data/ui/src/hokusai/meta.rb

@@ -107,16 +107,18 @@ module Hokusai
     def update(block)
       if target_block = target
         if updater_block = updater
-          block.public_send(:before_updated) if block.respond_to?(:before_updated)
+          block.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)
+          block.after_updated if block.respond_to?(:after_updated)
         end
       end
 
       children?&.each do |child|
         child.update
       end
+
+      block.after_children_updated if block.respond_to?(:after_children_updated)
     end
     def has_ast?(ast, index, elsy = false)
       if elsy

data/ui/src/hokusai/mounting/loop_entry.rb

@@ -154,7 +154,7 @@ module Hokusai
               if patch.delete
                 from = children[patch.from]
                 children[patch.to] = from
-                children[patch.from].public_send(:on_destroy) if children[patch.from].respond_to? :on_destroy
+                children[patch.from].public_send(:before_destroy) if children[patch.from].respond_to? :before_destroy
                 children[patch.from].node.destroy
                 children[patch.from] = nil
               else
@@ -189,7 +189,7 @@ module Hokusai
                 if !condition && ast.has_else_condition?
                   target_ast = ast.else_ast
                 elsif !condition
-                  children[patch.target].public_send(:on_destroy) if children[patch.target].respond_to? :on_destroy
+                  children[patch.target].public_send(:before_destroy) if children[patch.target].respond_to? :before_destroy
                   children[patch.target].node.destroy
                   children[patch.target] = nil
                   next
@@ -210,7 +210,7 @@ module Hokusai
                 children.insert(patch.target, child_block)
               end
             when DeletePatch
-              children[patch.target].public_send(:on_destroy) if children[patch.target].respond_to? :on_destroy
+              children[patch.target].public_send(:before_destroy) if children[patch.target].respond_to? :before_destroy
               children[patch.target].node.destroy
               children[patch.target] = nil
               # TODO: update rest of block props

data/ui/src/hokusai/mounting/update_entry.rb

@@ -52,9 +52,7 @@ module Hokusai
                   child_block = NodeMounter.new(node, child_block_klass, [stack], previous_providers: providers).mount(context: context, providers: providers)
 
                   UpdateEntry.new(child_block, block, target).register(context: context, providers: providers)
-                  pp [meta.has_ast?(child, index, false), "shouldn't be here?"]
                   meta.children!.insert(index, child_block)
-                  pp ["children", meta.children!.size, meta.children!.map(&:class)]
 
                   child_block.public_send(:before_updated) if child_block.respond_to?(:before_updated)
                   child_block.update

data/ui/src/hokusai/types/display.rb

@@ -117,7 +117,7 @@ module Hokusai
 
   # Color = Struct.new(:red, :green, :blue, :alpha) do
   class Color
-    attr_reader :red, :green, :blue, :alpha
+    attr_accessor :red, :green, :blue, :alpha
     def initialize(red, green, blue, alpha = 255)
       @red = red.freeze
       @green = green.freeze
@@ -144,6 +144,10 @@ module Hokusai
       new(value[0], value[1], value[2], value[3] || 255)
     end
 
+    def to_shader_value
+      [(r / 255.0), (g / 255.0), (b / 255.0), (a / 255.0)]
+    end
+
     def hash
       [self.class, r, g, b, a].hash
     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

@@ -1,193 +1,268 @@
-module Hokusai::Util
-  class Wrapped
-    attr_accessor :text, :x, :y, :extra
-    
-    def initialize(text, x, y, extra)
-      @text = text
-      @x = x
-      @y = y
-      @extra = extra
-    end
+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
+class SelectionWrapper
+  attr_accessor :x, :y, :width, :height, :offset, :buffer
 
-    def initialize(x, y, w, h)
-      @x = x
-      @y = y
-      @width = w
-      @height = h
-    end
+  def initialize(x, y, w, h)
+    @x = x
+    @y = y
+    @width = w
+    @height = h
+    @offset = 0.0
+    @buffer = ""
+  end
 
-    def <<(w)
-      @width += w
-    end
+  def <<(w)
+    @width += w
   end
+end
 
-  class WrapStream
-    attr_accessor :width, :current_width, :x, :y,
-                  :origin_x, :origin_y, :buffer, :stack
-    attr_reader :on_text_cb, :on_text_selection_cb, :on_advancex_cb, :selector, :padding
+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 initialize(width, &measure)
-      @width = width
-      @current_width = 0.0
+  def reset(width)
+    @width = width
+    @current_width = 0.0
 
-      @origin_x = 0.0
-      @origin_y = 0.0
-      @x = @origin_x
-      @y = @origin_y
+    @x = @origin_x
+    @y = @origin_y
 
-      @stack = []
-      @buffer = ""
+    @current_offset = 0
+    @current_height = 0.0
+    @widths = []
+    @stack = []
+    @selected = ""
+    @buffer = ""
+  
+    @first = nil
 
-      @measure_cb = measure
-    end
+    if @selector&.cleared
+      @selector&.cursor = nil
 
-    def on_advancex(&block)
-      @on_advancex_cb = block
+      @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_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_text(&block)
-      @on_text_cb = block
-    end
+  def on_bounds(&block)
+    @on_bounds_cb = block
+  end
 
-    def measure(string, extra)
-      @measure_cb.call(string, extra)
-    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
 
-    def flush
-      sx = x + padding.left
-      wrapper = nil
-      stack.each do |(range, extra)|
-        str = buffer[range]
-        if selector
-          str.split("").each do |char|
-            nw, nh = measure(char, extra)
-            ox = on_advancex_cb.call(char.codepoints.first)
-
-            if selector.selected(sx, y + padding.top - selector.offset_y, nw, nh)
-              wrapper ||= SelectionWrapper.new(sx, y + padding.top, 0.0, nh)
-              wrapper << ox
+          if srange&.include?(current_offset + i)
+            wrapper ||= begin
+              w = SelectionWrapper.new(sx, y, 0.0, nh)
+              w
             end
 
-            sx +=  ox
+            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
 
-          on_text_selection_cb.call(wrapper) if wrapper  
-          wrapper = nil
+          i = i.succ
+          sx += nw
         end
 
-        nw, _ = measure(str, extra)
+        on_text_selection_cb.call(wrapper) if wrapper 
+        wrapper = nil
+      end
 
-        # hard break on the buffer, split on character
-        wrap_and_call(str, extra)
+      ii += size
+      self.current_offset += size
 
-        self.x += nw
-      end
-      
-      self.current_width = 0.0
-      self.buffer = ""
-      stack.clear
-      self.x = origin_x
+      nw = widths[range].sum
+      # hard break on the buffer, split on character
+      wrap_and_call(buffer[range], extra)
+      self.x += nw
     end
 
-    def wrap(text, extra)
-      offset = 0
-      size = text.size
+    self.current_width = 0.0
+    self.buffer = ""
+    stack.clear
+    widths.clear
+    self.x = origin_x
+  end
 
-      stack << [((buffer.size)..(text.size + buffer.size - 1)), extra]
+  NEW_LINE_REGEX = /\n|\r\n/
 
-      while offset < size
-        char = text[offset]
-        w, h = measure(char, extra)
+  def wrap(text, extra)
+    offset = 0
+    size = text.size
 
-        # if it's a newline we want to break
-        if char =~ /\n|\r\n/
-          flush
+    stack << [((buffer.size)..(text.size + buffer.size - 1)), extra]
 
-          stack << [(0...(text.size - offset - 1)), extra]
-          self.y += h
-          self.x = origin_x
-          offset += 1
+    while offset < size
+      w, h = measure(text[offset], extra)
+      self.current_height = h
 
-          next
-        end
+      # if it's a newline we want to break
+      if text[offset] =~ NEW_LINE_REGEX
+        self.widths << 0
+        self.buffer << text[offset]
+        flush
 
-        # 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]
-                # pp [range, idx]
-                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
+        stack << [(0...(text.size - offset - 1)), extra]
+        self.y += h
+        self.x = origin_x
+        offset += 1
 
-            scur = buffer[0..idx]
-            snex = buffer[(idx + 1)..-1]
+        next
+      end
 
-            cur.each do |(range, xtra)|
-              str = scur[range]
+      # 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
 
-              nw, _ = measure(str, xtra)
-              wrap_and_call(str, xtra)
+          scur = buffer[0..idx]
+          snex = buffer[(idx + 1)..-1]
+          
+          wcur = widths[0..idx]
+          wnex = widths[(idx + 1)..-1]
 
-              self.x += nw
-            end
+          self.buffer = scur
+          self.widths = wcur
+          self.stack = cur
+          flush
 
-            self.buffer = snex + char
-            self.stack = nex
-            self.y += h
-            self.current_width = measure(buffer, extra).first
-            self.x = origin_x
-          else
-            # break on this word
-            flush
-
-            self.y += h
-            self.current_width = measure(char, extra).first
-            self.buffer = char
-            stack << [(0...(text.size - offset)), extra]
-          end
+          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
-          self.current_width += w
-          buffer << char
-        end
+          # break on this word
+          flush
 
-        offset += 1
+          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
-      
-    end
 
-    private def wrap_and_call(text, extra)
-      on_text_cb.call Wrapped.new(text, x, y, extra)
+      offset += 1
     end
   end
+
+  private def wrap_and_call(text, extra)
+    on_text_cb.call Wrapped.new(text, x, y, extra)
+  end
 end

data/ui/src/hokusai.rb

@@ -13,6 +13,7 @@ require_relative './hokusai/event'
 require_relative './hokusai/painter'
 require_relative './hokusai/util/selection'
 require_relative './hokusai/util/piece_table'
+require_relative './hokusai/util/wrap_stream'
 
 # A backend agnostic library for authoring 
 # desktop applications
@@ -137,6 +138,14 @@ module Hokusai
     @on_set_mouse_cursor&.call(type)
   end
 
+  def self.on_copy(&block)
+    @on_copy = block
+  end
+
+  def self.copy(text)
+    @on_copy&.call(text)
+  end
+
   # Mobile support
   def self.on_show_keyboard(&block)
     @on_show_keyboard = block
@@ -192,4 +201,6 @@ require_relative './hokusai/blocks/shader_begin'
 require_relative './hokusai/blocks/shader_end'
 require_relative './hokusai/blocks/texture'
 require_relative './hokusai/blocks/color_picker'
-require_relative './hokusai/blocks/keyboard'
+require_relative './hokusai/blocks/keyboard'
+require_relative './hokusai/blocks/translation'
+require_relative './hokusai/blocks/text_stream'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hokusai-zero
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.8
 platform: ruby
 authors:
 - skinnyjames
@@ -263,9 +263,11 @@ files:
 - ui/src/hokusai/blocks/slider.rb
 - ui/src/hokusai/blocks/svg.rb
 - ui/src/hokusai/blocks/text.rb
+- ui/src/hokusai/blocks/text_stream.rb
 - ui/src/hokusai/blocks/texture.rb
 - ui/src/hokusai/blocks/titlebar/osx.rb
 - ui/src/hokusai/blocks/toggle.rb
+- ui/src/hokusai/blocks/translation.rb
 - ui/src/hokusai/blocks/variable.rb
 - ui/src/hokusai/blocks/vblock.rb
 - ui/src/hokusai/commands.rb
@@ -273,10 +275,13 @@ files:
 - ui/src/hokusai/commands/circle.rb
 - ui/src/hokusai/commands/image.rb
 - ui/src/hokusai/commands/rect.rb
+- ui/src/hokusai/commands/rotation.rb
+- ui/src/hokusai/commands/scale.rb
 - ui/src/hokusai/commands/scissor.rb
 - ui/src/hokusai/commands/shader.rb
 - ui/src/hokusai/commands/text.rb
 - ui/src/hokusai/commands/texture.rb
+- ui/src/hokusai/commands/translation.rb
 - ui/src/hokusai/diff.rb
 - ui/src/hokusai/error.rb
 - ui/src/hokusai/event.rb