hokusai-zero 0.2.6 → 0.2.8

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/rect.rb

@@ -2,7 +2,7 @@ module Hokusai
   class Commands::Rect < Commands::Base
     attr_reader :x, :y, :width, :height,
                 :rounding, :color, :outline,
-                :outline_color, :padding
+                :outline_color, :padding, :gradient
 
     def initialize(x, y, width, height)
       @x = x.to_f
@@ -11,9 +11,10 @@ module Hokusai
       @height = height.to_f
       @outline = Outline.default
       @rounding = 0.0
-      @color = Color.new(0, 0, 0, 0)
-      @outline_color = Color.new(0, 0, 0, 255)
+      @color = Color.new(255, 255, 255, 0)
+      @outline_color = Color.new(0, 0, 0, 0)
       @padding = Padding.new(0.0, 0.0, 0.0, 0.0)
+      @gradient = nil
     end
 
     def hash
@@ -44,6 +45,14 @@ module Hokusai
       height
     end
 
+    def gradient=(colors)
+      unless colors.is_a?(Array) && colors.size == 4 && colors.all? { |color| color.is_a?(Hokusai::Color) }
+        raise Hokusai::Error.new("Gradient must be an array of 4 Hokuai::Color")
+      end
+
+      @gradient = colors
+    end
+
     # Sets padding for the rectangle
     # `value` is an array with padding declarations
     # at [top, right, bottom, left]

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/shader.rb

@@ -0,0 +1,33 @@
+module Hokusai
+  class Commands::ShaderBegin < Commands::Base
+    attr_reader :vertex_shader, :fragment_shader, :uniforms
+
+    def initialize
+      @uniforms = []
+      @vertex_shader =  nil
+      @fragment_shader = nil
+    end
+
+    def vertex_shader=(content)
+      @vertex_shader = content
+    end
+
+    def fragment_shader=(content)
+      @fragment_shader = content
+    end
+
+    def uniforms=(values)
+      @uniforms = values
+    end
+
+    def hash
+      [self.class, vertex_shader, fragment_shader].hash
+    end
+  end
+
+  class Commands::ShaderEnd < Commands::Base;
+    def hash
+      [self.class].hash
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Hokusai
+  class Commands::Texture < Commands::Base
+    attr_reader :x, :y, :width, :height, :rotation, :scale
+
+    def initialize(x, y, width, height)
+      @x = x
+      @y = y
+      @width = width
+      @height = height
+      @rotation = 0.0
+      @scale = 10.0
+    end
+
+    def rotation=(value)
+      @rotation = value
+    end
+
+    def scale=(value)
+      @scale = value
+    end
+
+    def hash
+      [self.class, x, y, width, height].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

@@ -4,6 +4,11 @@ require_relative "./commands/image"
 require_relative "./commands/rect"
 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
@@ -31,7 +36,6 @@ module Hokusai
       yield(command)
 
       queue << command
-      # command.draw
     end
 
     # Draw a circle
@@ -44,9 +48,7 @@ module Hokusai
 
       yield(command)
 
-
       queue << command
-      # command.draw
     end
 
     # Draws an SVG
@@ -81,6 +83,50 @@ module Hokusai
       queue << Commands::ScissorEnd.new
     end
 
+    def shader_begin
+      command = Commands::ShaderBegin.new
+
+      yield command
+
+      queue << command
+    end
+
+    def shader_end
+      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)
+
+      yield command
+
+      queue << command
+    end
+
     # Draws text
     #
     # @param [String] the text content

data/ui/src/hokusai/event.rb

@@ -65,4 +65,5 @@ module Hokusai
 end
 
 require_relative './events/keyboard'
-require_relative './events/mouse'
+require_relative './events/mouse'
+require_relative './events/touch'

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

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 module Hokusai
   class KeyboardEvent < Event
     extend Forwardable
 
     def_delegators :@keyboard, :shift, :super, :ctrl,
-                   :alt, :pressed, :pressed_len, :released,
-                   :released_len
+                   :alt, :pressed, :released, :char, :code
 
     attr_reader :input
 
@@ -35,48 +36,40 @@ module Hokusai
   class KeyUpEvent < KeyboardEvent
     name "keyup"
 
-    def keyboard_key
-      input.raw[:keyboard][:released]
-    end
-
     def key
-      keyboard_key[:key][:key]
+      released[0]&.[](:symbol)
     end
 
     def code
-      keyboard_key[:char_code]
+      released[0]&.[](:code)
     end
 
     def char
-      code.chr
+      released[0]&.[](:char)
     end
 
     def capture(block, _)
-      captures << block if matches(block) && released_len > 0
+      captures << block if matches(block) && released.size > 0
     end
   end
 
   class KeyPressEvent < KeyboardEvent
     name "keypress"
 
-    def keyboard_key
-      input.raw[:keyboard][:pressed]
-    end
-
     def key
-      keyboard_key[:key][:key]
+      pressed[0]&.[](:symbol)
     end
 
     def code
-      keyboard_key[:char_code]
+      pressed[0]&.[](:code)
     end
 
     def char
-      code.chr
+      pressed[0]&.[](:char)
     end
 
     def capture(block, _)
-      return unless matches(block) && pressed_len > 0
+      return unless matches(block) && pressed.size > 0
 
       captures << block
     end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Hokusai
   class MouseEvent < Event
     extend Forwardable
@@ -67,7 +69,7 @@ module Hokusai
     protected
 
     def hovered(canvas)
-      LibHokusai.hoku_input_is_hovered(input.raw, canvas.to_hoku_rect)
+      input.hovered?(canvas)
     end
   end
 
@@ -85,19 +87,19 @@ module Hokusai
     name "click"
 
     def capture(block, canvas)
-      if left[:clicked] && clicked(canvas)
+      if left.clicked && clicked(canvas)
         block.node.meta.focus
 
         if matches(block)
           captures << block
         end
-      elsif left[:clicked]
+      elsif left.clicked
         block.node.meta.blur
       end
     end
 
     def clicked(canvas)
-      LibHokusai.hoku_input_is_clicked(input.raw, canvas.to_hoku_rect)
+      left.clicked && input.hovered?(canvas)
     end
   end
 
@@ -105,7 +107,7 @@ module Hokusai
     name "mouseup"
 
     def capture(block, _)
-      if left[:up] && matches(block)
+      if left.up && matches(block)
         captures << block
       end
     end
@@ -115,7 +117,7 @@ module Hokusai
     name "mousedown"
 
     def capture(block, _)
-      if left[:down] && matches(block)
+      if left.down && matches(block)
         captures << block
       end
     end
@@ -168,13 +170,13 @@ module Hokusai
     def capture(block, canvas)
       captures << block if matches(block)
 
-      if left[:clicked] && !clicked(canvas)
+      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)
+      left.clicked && input.hovered?(canvas)
     end
   end
 end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Hokusai
+  class TouchEvent < Event
+    extend Forwardable
+
+    def_delegators :@touch, :tapped?, :swiped?, :longtapped?, :longtapping?, :touching?,
+                   :duration, :direction, :distance, :angle, :position, :last_position,
+                   :touch_len, :touch_count, :timer
+
+    attr_reader :input
+
+    def initialize(input, state)
+      @input = input
+      @state = state
+      @touch = input.touch
+    end
+
+    def hovered(canvas)
+      input.hovered?(canvas)
+    end
+
+    def to_json
+      {
+        keypress: {
+          hold: hold,
+          hold_duration: hold_duration.to_s,
+        }
+      }.to_json
+    end
+  end
+
+  class TapHoldEvent < TouchEvent
+    name "taphold"
+
+    def capture(block, canvas)
+      if matches(block) && longtapped? && hovered(canvas) 
+        captures << block
+      end
+    end
+  end
+
+  class PinchEvent < TouchEvent
+    name "pinch"
+
+    def capture(block, canvas)
+      if false && matches(block)
+        captures << block
+      end
+    end
+  end
+
+  class SwipeEvent < TouchEvent
+    name "swipe"
+
+    def capture(block, canvas)
+      if swiped? && matches(block)
+        captures << block
+      end
+    end
+  end
+end

data/ui/src/hokusai/meta.rb

@@ -107,21 +107,28 @@ 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
-    end
 
-    def has_ast?(ast, index)
-      if portal = children![index]&.node&.portal&.portal
-        return portal.ast.object_id == ast.object_id
+      block.after_children_updated if block.respond_to?(:after_children_updated)
+    end
+    def has_ast?(ast, index, elsy = false)
+      if elsy
+        if portal = children![index]&.node&.portal
+          return portal.ast.object_id == ast.object_id
+        end
+      else
+        if portal = children![index]&.node&.portal&.portal
+          return portal.ast.object_id == ast.object_id
+        end
       end
 
       false

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

@@ -65,7 +65,7 @@ module Hokusai
 
           portal = Node.new(ast)
           node = child_block_class.compile(ast.type, portal)
-          child_block = child_block_class.new(node: node)
+          child_block = child_block_class.new(node: node, providers: mount_providers)
           child_block.node.add_styles(target.class)
           child_block.node.add_props_from_block(target, context: ctx)
           child_block.node.meta.set_prop(ast.loop.var.to_sym, value)
@@ -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

@@ -19,8 +19,8 @@ module Hokusai
             portal.ast.children.each_with_index do |child, index|
               next unless child.has_if_condition?
 
-              child_present = ->(child) do
-                meta.has_ast?(child, index)
+              child_present = ->(child, elsy) do
+                meta.has_ast?(child, index, elsy)
               end 
 
               if child.if.args.size > 0
@@ -33,11 +33,11 @@ module Hokusai
 
               if !!visible
                 if child.else_condition_active?
-                  meta.child_delete(index) if child_present.call(child)
+                  meta.child_delete(index) if child_present.call(child, false)
                   child.else_active = 0
                 end
 
-                unless child_present.call(child)
+                unless child_present.call(child, true)
                   portal = Node.new(child, Node.new(child))
                   node = child_block_klass.compile("root", portal)
                   node.add_styles(target.class)
@@ -52,7 +52,6 @@ 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)
-                  
                   meta.children!.insert(index, child_block)
 
                   child_block.public_send(:before_updated) if child_block.respond_to?(:before_updated)
@@ -61,7 +60,7 @@ module Hokusai
                 end
               elsif !visible
                 if !child.has_else_condition? || (child.has_else_condition? && !child.else_condition_active?)
-                  if (child_present.call(child))
+                  if (child_present.call(child, true))
                     meta.child_delete(index)
                   end
                 end