hokusai-zero 0.1.4 → 0.1.6

data/ui/src/hokusai/block.rb

@@ -30,6 +30,10 @@ module Hokusai
       @provides ||= {}
     end
 
+    def self.injectables
+      @injectables ||= []
+    end
+
     # Sets the template for this block
     #
     # @param [String] template to set
@@ -118,16 +122,18 @@ module Hokusai
     end
 
     def self.inject(name, aliased = name)
+      injectables << name
+
       define_method(aliased) do
-        if provider = Node.provides[node.uuid]&.[](name)
-          provider.call
-        end
+        @injections[name]&.call
       end
     end
 
     def self.inject!(name, aliased)
+      injectables << name
+
       define_method(aliased) do
-        if provider = Node.provides[node.uuid]&.[](name)
+        if provider = @injections[name]
           return provider.call
         end
 
@@ -147,6 +153,25 @@ module Hokusai
       raise Hokusai::Error.new("Must supply node argument to #{self.class}.new") unless args[:node]
 
       @node = args[:node]
+      @injections = {}
+
+      self.class.injectables.each do |name|
+        if value = args[:providers][name]
+          @injections[name] = value
+        end
+      end
+    end
+
+    def providers
+      self.class.provides.map do |k, v|
+        if v.is_a?(Symbol)
+          [k, -> { public_send(v) }]
+        elsif v.is_a?(Proc)
+          [k, v]
+        else
+          [k, -> { v }]
+        end
+      end.to_h
     end
 
     def children?
@@ -179,23 +204,23 @@ module Hokusai
 
     def draw(&block)
       instance_eval(&block)
-      # node.meta.commands.each(&:draw)
-      # node.meta.commands.clear!
     end
 
     def method_missing(name, *args,**kwargs, &block)
-      if Hokusai::Meta.commands.respond_to?(name)
-        return Hokusai::Meta.commands.send(name, *args, **kwargs, &block)
+      if node.meta.commands.respond_to?(name)
+        return node.meta.commands.send(name, *args, **kwargs, &block)
       end
 
       super
     end
 
     def draw_with
-      yield Hokusai::Meta.commands
+      yield node.meta.commands
+    end
 
-      # node.meta.commands.each(&:draw)
-      # node.meta.commands.clear!
+    def execute_draw
+      node.meta.commands.execute
+      node.meta.commands.clear!
     end
 
     def render(canvas)

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

@@ -9,7 +9,7 @@ class Hokusai::Blocks::Cursor < Hokusai::Block
   computed :x, default: 0.0
   computed :y, default: 0.0
   computed :show, default: false
-  computed :speed, default: 0.1
+  computed :speed, default: 0.5
   computed :cursor_width, default: 2.0
   computed :cursor_height, default: 0.0
   computed :color, default: DEFAULT_COLOR, convert: Hokusai::Color

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

@@ -0,0 +1,205 @@
+class Hokusai::Blocks::DropDownItem < Hokusai::Block
+  style <<~EOF
+  [style]
+  cursorStyle {
+    cursor: "pointer";
+  }
+  EOF
+  
+  template <<~EOF
+  [template]
+    text {
+      @hover="hover_handler"
+      @mouseout="mouseout_handler"
+      ...cursorStyle
+      :content="option"
+      :color="color"
+      :size="size"
+      @click="emit_option" 
+      @height_updated="update_height"
+    }
+  EOF
+
+  uses(text: Hokusai::Blocks::Text)
+
+  computed! :index
+  computed! :option
+  computed! :size
+  computed! :color
+
+  attr_accessor :hovered
+
+  def hover_handler(event)
+    self.hovered = true
+  end
+
+  def mouseout_handler(event)
+    self.hovered = false
+  end
+
+  def update_height(height)
+    node.meta.set_prop(:height, height)
+
+    emit("height", index, height)
+  end
+
+  def emit_option(event)
+    emit("option", index)
+  end
+
+  def render(canvas)
+    if hovered
+      draw do
+        rect(canvas.x, canvas.y, canvas.width, canvas.height) do |command|
+          command.color = Hokusai::Color.new(255, 255, 255, 20)
+        end
+      end
+    end
+
+    yield canvas
+  end
+end
+
+class Hokusai::Blocks::Dropdown < Hokusai::Block
+  style <<~EOF
+  [style]
+  panelStyle {
+    z: 1;
+  }
+  rootStyle {
+    height: 70.0;
+    color: rgb(122, 118, 135);
+  }
+
+  cursorStyle {
+    cursor: "pointer";
+  }
+  EOF
+
+  template <<~EOF
+  [template]
+    vblock {
+      @hover="dropdown_hover"
+      @mouseout="dropdown_mouseout"
+      @click="dropdown_toggle"
+      :background="background"
+      :height="size_with_padding"
+      :outline="outline"
+      :outline_color="outline_color"
+    }
+      hblock
+        label {
+          ...cursorStyle
+          :content="dropdown_option_selected" 
+          :size="size"
+          :color="text_color"
+        }
+        image {
+          padding="5.0,10.0,5.0,5.0"
+          :source="dropdown_icon"
+          :height="size"
+          :width="size"
+        }
+      [if="dropdown_is_toggled"]
+        panel#first { 
+          ...panelStyle
+          :height="panel_height"
+          :background="background"
+        }
+          [for="option in options"]
+            dropdown_item {
+              :color="text_color"
+              :size="size"
+              :height="option_height(index)"
+              :option="option_content(option)"
+              :key="dropdown_key(option, index)" 
+              :index="index" 
+              @option="option_emit_selected" 
+              @height="option_update_height" 
+            }
+  EOF
+
+  uses(
+    vblock: Hokusai::Blocks::Vblock,
+    hblock: Hokusai::Blocks::Hblock,
+    label: Hokusai::Blocks::Text,
+    panel: Hokusai::Blocks::Panel,
+    image: Hokusai::Blocks::Image,
+    dropdown_item: Hokusai::Blocks::DropDownItem
+  )
+
+  computed! :options
+  computed :option_callback, default: ->(option) { option }
+  computed :size, default: 25, convert: proc(&:to_i)
+  computed :padding, default: Hokusai::Padding.new(5.0, 5.0, 5.0, 5.0), convert: Hokusai::Padding
+  computed :background, default: Hokusai::Color.new(67, 64, 92), convert: Hokusai::Color
+  computed :outline, default: Hokusai::Outline.new(0.0, 0.0, 1.0, 0.0), convert: Hokusai::Outline
+  computed :outline_color, default: Hokusai::Color.new(122, 118, 135), convert: Hokusai::Color
+  computed :text_color, default: Hokusai::Color.new(255, 255, 255), convert: Hokusai::Color
+  computed :panel_width, default: 200.0, convert: proc(&:to_f)
+  computed :panel_height, default: 300.0, convert: proc(&:to_f)
+  computed :icon, default: "#{ASSETS_FOLDER}/arrow-drop-down-line.png"
+
+  attr_accessor :selected, :dropdown_is_toggled, :hovered
+  attr_reader :heights
+
+  def dropdown_icon
+    icon
+  end
+
+  def dropdown_hover(event)
+    self.hovered = true
+  end
+
+  def dropdown_mouseout(event)
+    self.hovered = false
+  end
+
+  def size_with_padding
+    size + padding.top + padding.bottom
+  end
+
+  def dropdown_key(option, index)
+    "option-#{option_callback.call(option)}-#{index}"
+  end
+
+  def dropdown_toggle(event)
+    self.dropdown_is_toggled = !dropdown_is_toggled
+  end
+
+  def dropdown_option_selected
+    option_callback.call(selected)
+  end
+
+  def option_height(index)
+    heights[index]
+  end
+
+  def option_update_height(index, height)
+    heights[index] = height
+  end
+
+  def option_content(option)
+    option_callback.call(option)
+  end
+
+  def after_updated
+    node.meta.set_prop(:height, size * 2)
+  end
+
+  def option_emit_selected(index)
+    emit("selected", options[index])
+
+    self.selected = options[index]
+    self.dropdown_is_toggled = false
+  end
+
+  def initialize(**args)
+    super
+
+    @hovered = false
+    @heights = {}
+    @dropdown_is_toggled = false
+    @selected = options.first
+  end
+end

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

@@ -9,12 +9,13 @@ class Hokusai::Blocks::Image < Hokusai::Block
   computed! :source
   computed :width, default: nil
   computed :height, default: nil
+  computed :padding, default: Hokusai::Padding.new(0.0, 0.0, 0.0, 0.0), convert: Hokusai::Padding
 
   def render(canvas)
     src = Pathname.new(source).absolute? ? source : "#{File.dirname(caller[-1].split(":")[0])}/#{source}"
 
     draw do
-      image(src, canvas.x, canvas.y, width&.to_f || canvas.width, height&.to_f || canvas.height)
+      image(src, canvas.x + padding.left, canvas.y + padding.top, (width&.to_f || canvas.width) - padding.right, (height&.to_f || canvas.height) - padding.bottom)
     end
 
     yield canvas

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

@@ -195,7 +195,7 @@ class Hokusai::Blocks::Input < Hokusai::Block
       flush
 
       if table.pieces.size > 10
-        self.table = Util::PieceTable.new(table.to_s)
+        self.table = ::Hokusai::Util::PieceTable.new(table.to_s)
       end
 
       self.start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)

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

@@ -0,0 +1,62 @@
+class Hokusai::Blocks::Modal < Hokusai::Block
+  style <<~EOF
+  [style]
+  closeButtonStyle {
+    width: 40;
+    height: 40;
+    cursor: "pointer";
+    padding: padding(10.0, 10.0, 10.0, 0.0)
+  }
+  EOF
+
+  template <<~EOF
+  [template]
+    hblock
+      empty
+      empty
+      image {
+        :source="close_icon"
+        ...closeButtonStyle
+        @click="emit_close"
+
+      }
+    hblock
+      empty
+      slot
+      empty
+    hblock
+      empty
+  EOF
+
+  uses(
+    vblock: Hokusai::Blocks::Vblock,
+    hblock: Hokusai::Blocks::Hblock,
+    empty: Hokusai::Blocks::Empty,
+    image: Hokusai::Blocks::Image
+  )
+
+  computed :active, default: false
+  computed :background, default: [0, 0, 0, 200], convert: Hokusai::Color
+  computed :close_icon, default: "#{ASSETS_FOLDER}/close-large-line.png"
+
+  def emit_close(event)
+    emit("close")
+  end
+
+  def on_mounted
+    node.meta.set_prop(:z, 1)
+    node.meta.set_prop(:ztarget, "root")
+  end
+
+  def render(canvas)
+    return unless active
+
+    draw do
+      rect(canvas.x, canvas.y, canvas.width, canvas.height) do |command|
+        command.color = background
+      end
+    end
+
+    yield canvas
+  end
+end

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

@@ -62,8 +62,8 @@ class Hokusai::Blocks::Panel < Hokusai::Block
     if y = top
       if new_scroll_y < y
         self.scroll_goto_y = y
-      elsif new_scroll_y > panel_height
-        self.scroll_goto_y = panel_height
+      elsif new_scroll_y - top >= panel_height
+        self.scroll_goto_y = panel_height if scroll_percent != 1.0
       else
         self.scroll_goto_y = new_scroll_y
       end

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

@@ -50,8 +50,6 @@ class Hokusai::Blocks::Scrollbar < Hokusai::Block
     else
       self.scrolling = false
     end
-
-    # event.stop
   end
 
   def scroll_top_height

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

@@ -15,6 +15,7 @@ class Hokusai::Blocks::Text < Hokusai::Block
   uses(empty: Hokusai::Blocks::Empty)
 
   computed! :content
+  computed :cursor, default: nil
   computed :font, default: nil
   computed :size, default: 16, convert: proc(&:to_i)
   computed :line_height, default: 5, convert: proc(&:to_f)
@@ -68,7 +69,7 @@ class Hokusai::Blocks::Text < Hokusai::Block
       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]
+            # selector.cursor = [x, y + offset_y, 0.0, size.to_f]
 
             self.last_cursor_offset = cursor_offset
           end
@@ -112,6 +113,8 @@ class Hokusai::Blocks::Text < Hokusai::Block
                     system("open #{group.link}")
                   when /linux/
                     system("xdg-open #{group.link}")
+                  when /msys|mingw/
+                    system("Start-Process \"#{group.link}\"")
                   end
 
                   self.click_position = nil
@@ -125,9 +128,9 @@ class Hokusai::Blocks::Text < Hokusai::Block
       end
 
       iterator.on_draw_selection do |x, y, width, height|
-        # commands.rect(x, y, width, height) do |command|
-        #   command.color = selection_color
-        # end
+        commands.rect(x, y, width, height) do |command|
+          command.color = selection_color
+        end
       end
 
       iterator.on_selection_change do |start, stop|
@@ -170,7 +173,7 @@ class Hokusai::Blocks::Text < Hokusai::Block
       end
     end
 
-    if link_hovered
+    if link_hovered || cursor == "pointer"
       Hokusai.set_mouse_cursor(:pointer)
     elsif hovered
       Hokusai.set_mouse_cursor(:ibeam)

data/ui/src/hokusai/commands.rb

@@ -15,7 +15,9 @@ module Hokusai
   class Commands
     attr_reader :queue
 
-    def initialize; end
+    def initialize
+      @queue = []
+    end
 
     # Draw a rectangle
     #
@@ -28,7 +30,8 @@ module Hokusai
 
       yield(command)
 
-      command.draw
+      queue << command
+      # command.draw
     end
 
     # Draw a circle
@@ -41,7 +44,9 @@ module Hokusai
 
       yield(command)
 
-      command.draw
+
+      queue << command
+      # command.draw
     end
 
     # Draws an SVG
@@ -55,23 +60,25 @@ module Hokusai
       command = Commands::SVG.new(source, x, y, w, h)
 
       yield(command)
+
+      queue << 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
+      queue << 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
+      queue << Commands::ScissorBegin.new(x, y, w, h)
     end
 
     # Invokes a scissor stop command
     def scissor_end
-      Commands::ScissorEnd.new.draw
+      queue << Commands::ScissorEnd.new
     end
 
     # Draws text
@@ -83,7 +90,15 @@ module Hokusai
       command = Commands::Text.new(content, x, y)
       yield command
 
-      command.draw
+      queue << command
+    end
+
+    def execute
+      queue.each(&:draw)
+    end
+
+    def clear!
+      queue.clear
     end
   end
 end

data/ui/src/hokusai/font.rb

@@ -224,7 +224,7 @@ module Hokusai
       end
 
       def char_is_selected(char)
-        return false if select_begin.nil? || select_end.nil?
+        return false if select_begin.nil? || select_end.nil? || (select_end - select_begin).zero?
 
         (select_begin..select_end).include?(char.offset)
       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
 
@@ -126,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/mounting/loop_entry.rb

@@ -27,7 +27,7 @@ module Hokusai
 
       INDEX_KEY = "index".freeze
 
-      def_delegators :@entry, :ast, :block, :target, :parent
+      def_delegators :@entry, :ast, :block, :target, :parent, :providers
 
       def initialize(mount_entry)
         @entry = mount_entry
@@ -78,12 +78,12 @@ module Hokusai
           block.node.meta << child_block
 
           node.ast.children.each_with_index do |child, idx|
-            entries_to_return << MountEntry.new(index, child, child_block, child_block, child_block, context: nil)
+            entries_to_return << MountEntry.new(index, child, child_block, child_block, child_block, context: nil, providers: providers.merge(child_block.providers))
           end
 
           siblings = []
           portal.ast.children.each_with_index do |child, idx|
-            siblings << MountEntry.new(idx, child, child_block, child_block, target, context: ctx)
+            siblings << MountEntry.new(idx, child, child_block, child_block, target, context: ctx, providers: providers.merge(child_block.providers))
           end
 
           secondary_entries << siblings

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

@@ -1,14 +1,15 @@
 module Hokusai
   module Mounting
     class MountEntry
-      attr_reader :block, :parent, :ast, :target, :index, :ctx
+      attr_reader :block, :parent, :ast, :target, :index, :ctx, :providers
 
-      def initialize(index, ast, block, parent, target = parent, context: nil)
+      def initialize(index, ast, block, parent, target = parent, context: nil, providers: {})
         @index = index
         @ast = ast
         @block = block
         @parent = parent
         @target = target
+        @providers = providers
         @ctx = context
       end
 
@@ -28,6 +29,7 @@ module Hokusai
         StringIO.open do |io|
           io << "#{block.class} | #{ast.type} (#{index})\n"
           io << "#{block.node.ast.children.map(&:type)}"
+          io << "providers: #{providers.map {|k,v| k }.join(", ")}\n"
           io << "parent: #{parent.class}\n"
           io << "target: #{target.class}\n\n"
         end.string
@@ -35,7 +37,7 @@ module Hokusai
 
       def with_block(new_block, supercede_parent: false)
         parent_block = supercede_parent ? block : parent
-        MountEntry.new(index, ast, new_block, parent_block, target, context: ctx)
+        MountEntry.new(index, ast, new_block, parent_block, target, context: ctx, providers: providers)
       end
 
       def mount(context: nil)
@@ -46,23 +48,11 @@ module Hokusai
         node.add_styles(target.class)
         node.add_props_from_block(target, context: context || ctx)
 
-        child_block = klass.new(node: node)
+        # handle provides / dependency injection
+        child_block = klass.new(node: node, providers: providers)
         child_block.node.meta.publisher.add(target) # todo
         UpdateEntry.new(child_block, block, target).register(context: context || ctx)
 
-        block.class.provides.each do |k, v|
-          if v.is_a?(Symbol)
-            Node.provide(child_block.node, k, ->{ block.public_send(v) })
-
-            # child_block.node.meta.provides[k] = -> { block.public_send(v) }
-            # child_block.class.provides[k] = -> { block.public_send(v) }
-          else
-            Node.provide(child_block.node, k, v)
-            # child_block.node.meta.provides[k] = v
-            # child_block.class.provides[k] = v
-          end
-        end
-
         block.node.meta << child_block
 
         yield child_block

data/ui/src/hokusai/node.rb

@@ -12,15 +12,6 @@ module Hokusai
 
     def_delegators :@ast, :slot?, :type, :event
 
-    def self.provides
-      @provides ||= {}
-    end
-
-    def self.provide(node, key, value)
-      provides[node.uuid] ||= {}
-      provides[node.uuid][key] = value
-    end
-
     def self.parse(template, name = "root", parent = nil)
       ast = Ast.parse(template, name)