hokusai-zero 0.1.3 → 0.1.5

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

@@ -5,7 +5,7 @@ module Hokusai
     attr_reader :focused, :parent, :target, :updater,
                 :props, :publisher
 
-    def self.commands
+    def commands
       @commands ||= Commands.new
     end
 
@@ -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)
@@ -132,13 +126,6 @@ module Hokusai
 
       false
     end
-    #
-    # def destroy
-    #   children.each do |child|
-    #     child.before_destroy if child.respond_to?(:before_destroy)
-    #     child.node.destroy
-    #   end
-    # end
 
     def child_delete(index)
       if child = children![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

data/ui/src/hokusai/painter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "./event"
+require "colorize"
 
 module Hokusai
   class PainterEntry
@@ -22,6 +23,9 @@ module Hokusai
     end
   end
 
+  ZTARGET_ROOT = "root"
+  ZTARGET_PARENT = "parent"
+
   class Painter
     attr_reader :root, :input, :before_render, :after_render,
                 :events
@@ -52,17 +56,36 @@ module Hokusai
       @after_render = block
     end
 
+    # def debug(parent, children)
+    #   @i ||= 0
+      
+    #   pp [
+    #     "#{@i}",
+    #     "parent: #{parent.block.class}##{parent.block.node.portal&.ast&.id} (z: #{parent.block.node.meta.get_prop(:z)})",
+    #     "children: #{children.map {|c| "#{c.block.class}##{c.block.node.portal&.ast&.id} (z: #{c.block.node.meta.get_prop(:z)})"} }"
+    #   ]
+    #   @i += 1
+    # end
+
     # @return [Array(Commands::Base)] the command list
     def render(canvas, resize = false, capture: true)
       return if root.children.empty?
 
+      zindexed = {}
+      zindex_counter = 0
+      zroot_x = canvas.x
+      zroot_y = canvas.y
+      zroot_w = canvas.width
+      zroot_h = canvas.height
+
       @root.on_resize(canvas) if resize
 
       before_render&.call([root, nil], canvas, input)
 
       root_children = (canvas.reverse? ? root.children?&.reverse.dup : root.children?&.dup) || []
       groups = []
-      groups << [root, measure(root_children, canvas)]
+      root_entry = PainterEntry.new(root, canvas.x, canvas.y, canvas.width, canvas.height)
+      groups << [root_entry, measure(root_children, canvas)]
 
       mouse_y = input.mouse.pos[:y]
       can_capture = mouse_y >= (canvas.y || 0.0) && mouse_y <= (canvas.y || 0.0) + canvas.height
@@ -71,13 +94,29 @@ module Hokusai
 
       while payload = groups.pop
         group_parent, group_children = payload
+        
+        parent_z = group_parent.block.node.meta.get_prop(:z)&.to_i
+        zindex_counter -= 1 if (parent_z || 0) > 0 && group_children.empty?
 
         while group = group_children.shift
-          canvas.reset(group.x, group.y, group.w, group.h)
+          z = group.block.node.meta.get_prop(:z)&.to_i || 0
+          ztarget = group.block.node.meta.get_prop(:ztarget)
+          entry = PainterEntry.new(group.block, group.x, group.y, group.w, group.h)
+
+          if (zindex_counter > 0 || z > 0)
+            case ztarget
+            when ZTARGET_ROOT
+              entry = PainterEntry.new(group.block, zroot_x || 0.0, zroot_y || 0.0, zroot_w, zroot_h).freeze
+            when ZTARGET_PARENT
+              entry = PainterEntry.new(group.block, group_parent.x || 0.0, group_parent.y || 0.0, group_parent.w, group_parent.h).freeze
+            end
+          end
+
+          canvas.reset(entry.x, entry.y, entry.w, entry.h)
 
           before_render&.call([group.block, group.parent], canvas, input.raw)
 
-          if capture && can_capture
+          if capture
             capture_events(group.block, canvas, hovered: hovered)
           end
 
@@ -92,17 +131,36 @@ module Hokusai
 
             unless local_children.nil?
               groups << [group_parent, group_children]
-              groups << [group.block, measure(local_children, local_canvas)]
+              parent = PainterEntry.new(group.block, canvas.x, canvas.y, canvas.width, canvas.height)
+              groups << [parent, measure(local_children, local_canvas)]
+
               breaked = true
             else
               breaked = false
             end
           end
+          
+          if z > 0
+            zindex_counter += 1
+            # puts ["start (#{z}) <#{parent_z}> {#{zindex_counter}} #{group.block.class}".colorize(:blue), z, group.block.node.portal&.ast&.id]
+            zindexed[zindex_counter] ||= []
+            zindexed[zindex_counter] << group.block
+          elsif zindex_counter > 0
+            # puts ["push (#{z}) <#{parent_z}>  {#{zindex_counter}} initial #{group.block.class}".colorize(:red), z, group.block.node.portal&.ast&.id]
+            zindexed[zindex_counter] << group.block
+          else
+            # puts ["draw (#{z}) <#{parent_z}>  {#{zindex_counter}} #{group.block.class}".colorize(:yellow), z, group.block.node.portal&.ast&.id]
+            group.block.execute_draw
+          end
 
           break if breaked
         end
       end
 
+      zindexed.sort.each do |z, blocks|
+        blocks.each(&:execute_draw)
+      end
+
       if capture
         events[:hover].bubble
         events[:wheel].bubble
@@ -132,10 +190,12 @@ module Hokusai
       hsum = 0.0
 
       children.each do |block|
-        # children.each do |block|
+        z = block.node.meta.get_prop?(:z)&.to_i || 0
         h = block.node.meta.get_prop?(:height)&.to_f
         w = block.node.meta.get_prop?(:width)&.to_f
 
+        next if z > 0
+
         if w
           wsum += w
           wcount = wcount.succ
@@ -188,7 +248,6 @@ module Hokusai
         return
       end
 
-
       rect = canvas.to_hoku_rect
       block_is_hovered = LibHokusai.hoku_input_is_hovered(input.raw, rect)
 
@@ -196,12 +255,11 @@ module Hokusai
         events[:hover].capture(block, canvas)
         events[:click].capture(block, canvas)
         events[:wheel].capture(block, canvas)
-        events[:mousedown].capture(block, canvas)
         events[:mouseup].capture(block, canvas)
+        events[:mousedown].capture(block, canvas)
       else
         events[:mouseout].capture(block, canvas)
       end
-
       events[:mousemove].capture(block, canvas)
 
       if block_is_hovered || block.node.meta.focused

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

@@ -15,9 +15,9 @@ module Hokusai::Util
     end
 
     def draw(font_size, boundary, selection: nil)
-      selection_extract(font_size, boundary, selection: selection)
+      # selection_extract(font_size, boundary, selection: selection)
       draw_text(font_size, boundary)
-      selection_update(selection)
+      # selection_update(selection)
       # self.start_select = 0.0
       # self.stop_select = nil
     end
@@ -85,17 +85,16 @@ module Hokusai::Util
         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
-              
+            if text == "\n"
               next
+              # x += group.width
             end
             
             @iterator.on_draw_cb&.call(text, x, y, group)
+
             x += group.width
           end
         else