hokusai-zero 0.1.2 → 0.1.4

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

@@ -45,6 +45,19 @@ class Hokusai::Blocks::Input < Hokusai::Block
     @start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     @buffer_offset = 0
     @offset = 0
+    @changed = false
+  end
+
+  def after_updated
+    if @changed && !growable
+      @table = ::Hokusai::Util::PieceTable.new(initial)
+      @buffer = ""
+      @buffer_count = 0
+      @start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @buffer_offset = 0
+      @offset = 0
+      @changed = false
+    end
   end
 
   def update_height(value)
@@ -74,6 +87,7 @@ class Hokusai::Blocks::Input < Hokusai::Block
   end
 
   def dynamic_keypress_handle(event)
+    return unless node.meta.focused
     case event
     when proc(&:ctrl), proc(&:super)
       if event.char == "z"
@@ -116,6 +130,7 @@ class Hokusai::Blocks::Input < Hokusai::Block
           flush
           
           emit("change", table.to_s)
+          @changed = true
 
           self.table = ::Hokusai::Util::PieceTable.new("")
           self.buffer_offset = 0
@@ -142,6 +157,8 @@ class Hokusai::Blocks::Input < Hokusai::Block
         self.buffer += event.char
       end
     end
+
+    emit("modified")
   end
     
   def flush

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

@@ -6,6 +6,7 @@ class Hokusai::Blocks::Label < Hokusai::Block
   EOF
 
   computed! :content
+  computed :font, default: nil
   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
@@ -21,8 +22,9 @@ class Hokusai::Blocks::Label < Hokusai::Block
 
   def render(canvas)
     if @last_content != content
-      width, _ = Hokusai.fonts.active.measure(content.to_s, size.to_i)
-
+      width, height = Hokusai.fonts.active.measure(content.to_s, size.to_i)
+      node.meta.set_prop(:width, width + padding.right + padding.left)
+      node.meta.set_prop(:height, height + padding.top + padding.bottom)
       emit("width_updated", width + padding.right + padding.left)
 
       @last_content = content
@@ -33,6 +35,7 @@ class Hokusai::Blocks::Label < Hokusai::Block
         command.color = color
         command.size = size
         command.padding = padding
+        command.font = font unless font.nil?
       end
     end
   end

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

@@ -15,13 +15,14 @@ class Hokusai::Blocks::Text < Hokusai::Block
   uses(empty: Hokusai::Blocks::Empty)
 
   computed! :content
+  computed :font, default: nil
   computed :size, default: 16, convert: proc(&:to_i)
   computed :line_height, default: 5, convert: proc(&:to_f)
   computed :color, default: [33,33,33], convert: Hokusai::Color
   computed :selection_color, default: [233,233,233], convert: Hokusai::Color
   computed :padding, default: [5.0, 5.0, 5.0, 5.0], convert: Hokusai::Padding
   computed :cursor_offset, default: nil
-  computed :markdown, default: false
+  computed :markdown, default: false, convert: ->(val) { val == "true" || val == true }
 
   inject :selection
   inject :panel_top
@@ -65,7 +66,6 @@ class Hokusai::Blocks::Text < Hokusai::Block
 
     draw_with do |commands|
       iterator.on_draw do |text, x, y, group|
-
         if selector = selection
           if cursor_offset&.zero? && !selector.started
             selector.cursor = [x, y + offset_y, 0.0, size.to_f]
@@ -86,6 +86,7 @@ class Hokusai::Blocks::Text < Hokusai::Block
         commands.text(text, x, y) do |command|
           command.color = color
           command.size = size
+          command.font = font unless font.nil?
 
           if group.respond_to?(:bold?)
             
@@ -186,7 +187,8 @@ class Hokusai::Blocks::Text < Hokusai::Block
 
   def clamp(text, width)
     if markdown
-      Hokusai.fonts.active.clamp_markdown(text, size.to_i, width - size.to_f - padding.right)
+      clamping = Hokusai.fonts.active.clamp_markdown(text, size.to_i, width - size.to_f - padding.right)
+      clamping
     else
       Hokusai.fonts.active.clamp(text, size.to_i, width - size.to_f, padding.right)
     end
@@ -203,10 +205,13 @@ class Hokusai::Blocks::Text < Hokusai::Block
 
       height = internal_render(last_clamping, canvas)
       self.last_content = last_content
-      emit("height_updated", height + padding.bottom) unless last_height == height + padding.bottom
+      
+      new_height = height + padding.bottom + padding.top
+      new_height -= size if markdown
 
-      self.last_height = height + padding.bottom + padding.top
+      emit("height_updated", new_height) unless last_height == new_height
 
+      self.last_height = new_height
 
       yield canvas
     end

data/ui/src/hokusai/blocks/titlebar/osx.rb

@@ -32,12 +32,12 @@ module Hokusai::Blocks::Titlebar
     EOF
 
     computed :rounding, default: 0.0, convert: proc(&:to_f)
-    computed :outline, default: [0.0, 0.0, 0.0, 0.0], convert: Hokusai::Outline
-    computed :outline_color, default: [0,0,0,0], convert: Hokusai::Color
+    computed :outline, default: nil
+    computed :outline_color, default: nil
     computed :unhovered_color, default: DEFAULT, convert: Hokusai::Color
     computed :radius, default: 6.0, convert: proc(&:to_f)
-    computed :background, default: nil, convert: Hokusai::Color
-    computed :background_drag, default: nil, convert: Hokusai::Color
+    computed :background, default: nil
+    computed :background_drag, default: nil
 
 
     uses(

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

@@ -0,0 +1,33 @@
+class Hokusai::Blocks::Variable < Hokusai::Block
+  template <<~EOF
+  [template]
+    empty
+  EOF
+
+  uses(empty: Hokusai::Blocks::Empty)
+
+  computed! :script
+
+  def after_updated
+    if @last_height != children[0].node.meta.get_prop(:height)
+      @last_height = children[0].node.meta.get_prop(:height)
+
+      node.meta.set_prop(:height, @last_height)
+      emit("height_updated", @last_height)
+    end
+  end
+
+  def on_mounted
+    klass = eval(script)
+
+    raise Hokusai::Error.new("Class #{klass} is not a Hokusai::Block") unless klass.ancestors.include?(Hokusai::Block)
+
+    node.meta.set_child(0, klass.mount)
+  end
+
+  def render(canvas)
+    if Hokusai.can_render(canvas)
+      yield canvas
+    end
+  end
+end

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

@@ -15,7 +15,7 @@ class Hokusai::Blocks::Vblock < Hokusai::Block
     canvas.vertical = true
     canvas.reverse = reverse
 
-    if background.nil?
+    if background.nil? && outline.nil?
       yield canvas
     else
       draw do

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

@@ -26,10 +26,10 @@ module Hokusai
     def trim_canvas(canvas)
       x, y, w, h = background_boundary
 
-      canvas.x = x + padding.left
-      canvas.y = y + padding.top
-      canvas.width = w - (padding.left + padding.right)
-      canvas.height = h - (padding.top + padding.bottom)
+      canvas.x = x + padding.left + outline.left
+      canvas.y = y + padding.top + outline.top
+      canvas.width = w - (padding.left + padding.right + outline.left + outline.right)
+      canvas.height = h - (padding.top + padding.bottom + outline.top + outline.bottom)
 
       canvas
     end

data/ui/src/hokusai/commands.rb

@@ -6,82 +6,84 @@ require_relative "./commands/scissor"
 require_relative "./commands/text"
 
 module Hokusai
+  # A proxy class for invoking various UI commands
+  #
+  # Invocations of commands are immediately sent to the backend
+  # for drawing
+  #
+  # Used as part of the drawing api for Hokusai::Block
   class Commands
     attr_reader :queue
 
-    def initialize
-      # @queue = []
-    end
-
-    # def hash
-    #   [self.class, *@queue.map(&:hash)].hash
-    # end
+    def initialize; end
 
+    # Draw a rectangle
+    #
+    # @param [Float] the x coordinate
+    # @param [Float] the y coordinate
+    # @param [Float] the width of the rectangle
+    # @param [Float] height of the rectangle
     def rect(x, y, w, h)
       command = Commands::Rect.new(x, y, w, h)
+
       yield(command)
 
       command.draw
-      # add(command)
     end
 
+    # Draw a circle
+    #
+    # @param [Float] x coordinate
+    # @param [Float] y coordinate
+    # @param [Float] radius of the circle
     def circle(x, y, radius)
       command = Commands::Circle.new(x, y, radius)
+
       yield(command)
 
       command.draw
-      # add(command)
     end
 
+    # Draws an SVG
+    #
+    # @param [String] location of the svg
+    # @param [Float] x coord
+    # @param [Float] y coord
+    # @param [Float] width of the svg
+    # @param [Float] height of the svg
     def svg(source, x, y, w, h)
       command = Commands::SVG.new(source, x, y, w, h)
-      yield(command)
 
-      # add(command)
+      yield(command)
     end
 
     # Invokes an image command
     # from a filename, at position {x,y} with `w`x`h` dimensions
     def image(source, x, y, w, h)
       Commands::Image.new(source, x, y, w, h).draw
-      # add(Commands::Image.new(source, x, y, w, h))
     end
 
     # Invokes a scissor begin command
     # at position {x,y} with `w`x`h` dimensions
     def scissor_begin(x, y, w, h)
       Commands::ScissorBegin.new(x, y, w, h).draw
-      # add(Commands::ScissorBegin.new(x, y, w, h))
     end
 
     # Invokes a scissor stop command
     def scissor_end
       Commands::ScissorEnd.new.draw
-      # add(Commands::ScissorEnd.new)
     end
 
+    # Draws text
+    #
+    # @param [String] the text content
+    # @param [Float] x coord
+    # @param [Float] y coord
     def text(content, x, y)
       command = Commands::Text.new(content, x, y)
       yield command
 
       command.draw
-      # add(command)
-    end
-
-    def each
-      queue.each do |cmd|
-        yield(cmd)
-      end
-    end
-
-    def clear!
-      # @queue = []
-    end
-
-    def add(command)
-      # @queue << command
-
-      self
     end
   end
 end

data/ui/src/hokusai/diff.rb

@@ -1,4 +1,6 @@
 module Hokusai
+  # Represents a patch to move a loop item
+  # from one location to another
   class MovePatch
     attr_accessor :from, :to, :delete
 
@@ -9,6 +11,8 @@ module Hokusai
     end
   end
 
+  # Represents a patch to insert an item
+  # into the loop list
   class InsertPatch
     attr_accessor :target, :value, :delete
 
@@ -19,6 +23,8 @@ module Hokusai
     end
   end
 
+  # Represents a patch to update the value
+  # of a loop item at an index
   class UpdatePatch
     attr_accessor :target, :value
 
@@ -28,6 +34,7 @@ module Hokusai
     end
   end
 
+  # Patch to delete a loop list item
   class DeletePatch
     attr_accessor :target
 
@@ -36,6 +43,10 @@ module Hokusai
     end
   end
 
+  # A Differ for comparing one set of values to another
+  #
+  # When #patch is called, will yield various patches to
+  # true up the old values with the new values.
   class Diff
     attr_reader :before, :after, :insertions
 

data/ui/src/hokusai/event.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 module Hokusai
+  # A Basic UI Event
   class Event
-    attr_reader :captures, :bubbles
+    attr_reader :captures
     attr_accessor :stopped
 
+    # Sets the name of this event kind
     def self.name(name)
       @name = name
     end
@@ -13,33 +15,45 @@ module Hokusai
       self.class.instance_variable_get("@name")
     end
 
+    # Has the event stopped propagation?
+    # @return [Bool]
     def stopped
       @stopped ||= false
     end
 
+    # Stop propagation on this event
+    # @return [Void]
     def stop
       self.stopped = true
     end
 
+    # @return [Array<Block>] the captured blocks for this event
     def captures
       @captures ||= []
     end
 
-    def bubbles
-      @bubbles ||= []
-    end
-
+    # A JSON string representing this event
+    # 
+    # Used in automation
+    # @return [String]
     def to_json
       raise Hokusai::Error.new("#{self.class} must implement to_json")
     end
 
+    # Does the event match the provided Hokusai::Block?
+    #
+    # @param [Hokusai::Block]
+    # @return [Bool]
     def matches(block)
       return false if block.node.portal.nil?
 
       val = block.node.portal.ast.event(name)
+
       !!val
     end
 
+    # Emit the event to all captured blocks,
+    # stopping if any of the blocks stop propagation
     def bubble
       while block = captures.pop
         block.emit(name, self)

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

@@ -165,8 +165,16 @@ module Hokusai
   class MouseOutEvent < MouseEvent
     name "mouseout"
 
-    def capture(block, _)
+    def capture(block, canvas)
       captures << block if matches(block)
+
+      if left[:clicked] && !clicked(canvas)
+        block.node.meta.blur
+      end
+    end
+
+    def clicked(canvas)
+      LibHokusai.hoku_input_is_clicked(input.raw, canvas.to_hoku_rect)
     end
   end
 end

data/ui/src/hokusai/font.rb

@@ -1,29 +1,54 @@
 module Hokusai
+  # A Backend agnostic font interface
+  #
+  # Backends are expected to implement the following methods
   class Font
+    # Creates a wrapping of text based on container width and font size
+    #
+    # @param [String] the text to wrap
+    # @param [Integer] the font size
+    # @param [Float] the width of the container
+    # @param [Float] an initital offset
+    # @return [Hokusai::Clamping]
     def clamp(text, size, width, initial_offset = 0.0)
       raise Hokusai::Error.new("Font #clamp not implemented")
     end
 
+    # Creates a wrapping of text based on the container width and font size
+    # and parses markdown
+    # @param [String] the text to wrap
+    # @param [Integer] the font size
+    # @param [Float] the width of the container
+    # @param [Float] an initital offset
+    # @return [Hokusai::Clamping]
     def clamp_markdown(text, size, width, initial_offset = 0.0)
       raise Hokusai::Error.new("Font #clamp not implemented")
     end
 
+    # @return [Integer] the font height
     def height
       raise Hokusai::Error.new("Font #height not implemented")
     end
   end
 
+  # A class representing wrapped text
+  #
+  # A clamping has many segments, delimited by a newline
+  # A segment has many possible groups, and a group has many possible charss
   class Clamping
     class Char
       attr_reader :raw
+
       def initialize(raw)
         @raw = raw
       end
 
+      # @return [Float] the width of the char
       def width
         raw[:width]
       end
 
+      # @return [Integer] the offset of the char relative to the clamping
       def offset
         raw[:offset]
       end
@@ -36,46 +61,57 @@ module Hokusai
         @raw = raw
       end
 
+      # @return [Integer] the offset of the group relative to the clamping 
       def offset
         @offset ||= raw[:offset]
       end
 
+      # @return [Integer] number of chars in this group
       def size
         @size ||= raw[:size]
       end
 
+      # @return [Float] the total width of chars in this group
       def width
         chars.sum(&:width)
       end
 
+      # @return [UInt] a flag for this group type
       def type
         @type ||= raw[:type]
       end
 
+      # @return [Bool] is this group normal?
       def normal?
         @normal ||= type == LibHokusai::GROUP_NORMAL
       end
 
+      # @return [Bool] is this group bold?
       def bold?
         @bold ||= ((type & LibHokusai::GROUP_BOLD) != 0)
       end
 
+      # @return [Bool] is this group italics?
       def italics?
         @italics ||= ((type & LibHokusai::GROUP_ITALICS) != 0)
       end
 
+      # @return [Bool] does this group represent a hyperlink?
       def link?
         @link ||= ((type & LibHokusai::GROUP_LINK) != 0)
       end
 
+      # @return [Bool] does this group represent a code block?
       def code?
         @code ||= type & LibHokusai::GROUP_CODE
       end
 
+      # @return [String] the hyperlink for this group if there is one
       def link
         @href ||= raw[:payload].read_string
       end
 
+      # @return [Array<Hokusai::Char>] an array of chars
       def chars
         return @chars unless @chars.nil?
 
@@ -106,18 +142,23 @@ module Hokusai
         @raw = raw
       end
 
+      # A segment width given a range of offsets
+      # NOTE: Defaults to the full segment
       def width(range = (offset...offset + size))
         chars[range]&.sum(&:width) || 0.0
       end
 
+      # @return [Integer] the offset of this segment relative to the clamping
       def offset
         raw[:offset]
       end
 
+      # @return [Integer] the number of chars in this segment
       def size
         raw[:size]
       end
 
+      # @return [Array<Hokusai::Char>] an array of chars
       def chars
         return @chars unless @chars.nil?
 
@@ -140,6 +181,7 @@ module Hokusai
         end
       end
 
+      # @return [Array<Hokusai::Group>] an array of clamping groups
       def groups
         return @groups unless @groups.nil?
 
@@ -243,6 +285,7 @@ module Hokusai
     end
   end
 
+  # Keeps track of any loaded fonts
   class FontRegistry
     attr_reader :fonts, :active_font
 
@@ -251,28 +294,45 @@ module Hokusai
       @active_font = nil
     end
 
+    # Registers a font
+    #
+    # @param [String] the name of the font
+    # @param [Hokusai::Font] a font
     def register(name, font)
       raise Hokusai::Error.new("Font #{name} already registered") if fonts[name]
 
       fonts[name] = font
     end
 
+    # Returns the active font's name
+    #
+    # @return [String]
     def active_font_name
       raise Hokusai::Error.new("No active font") if active_font.nil?
 
       active_font
     end
 
+    # Activates a font by name
+    #
+    # @param [String] the name of the registered font
     def activate(name)
       raise Hokusai::Error.new("Font #{name} is not registered") unless fonts[name]
 
       @active_font = name
     end
 
+    # Fetches a font
+    #
+    # @param [String] the name of the registered font
+    # @return [Hokusai::Font]
     def get(name)
       fonts[name]
     end
 
+    # Fetches the active font
+    #
+    # @return [Hokusai::Font]
     def active
       fonts[active_font]
     end

data/ui/src/hokusai/meta.rb

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

data/ui/src/hokusai/node.rb

@@ -83,7 +83,7 @@ module Hokusai
               elsif context&.table&.[](method)
                 value = context.table[method]
               else
-                value = block.public_send(method)
+                value = block.instance_eval(method)
               end
             else
               value = method