hokusai-zero 0.1.1

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

@@ -0,0 +1,158 @@
+module Hokusai
+  class Commands::Rect < Commands::Base
+    attr_reader :x, :y, :width, :height,
+                :rounding, :color, :outline,
+                :outline_color, :padding
+
+    def initialize(x, y, width, height)
+      @x = x.to_f
+      @y = y.to_f
+      @width = width.to_f
+      @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)
+      @padding = Padding.new(0.0, 0.0, 0.0, 0.0)
+    end
+
+    def hash
+      [self.class, x, y, width, height, rounding, color.hash, outline.hash, outline_color.hash, padding.hash].hash
+    end
+
+    # Modifies the parameter *Canvas*
+    # to offset the boundary with
+    # this rectangle's computed geometry
+    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
+    end
+
+    # Shorthand for #width
+    def w
+      width
+    end
+
+    # Shorthand for #height
+    def h
+      height
+    end
+
+    # Sets padding for the rectangle
+    # `value` is an array with padding declarations
+    # at [top, right, bottom, left]
+    def padding=(value)
+      case value
+      when Padding
+        @padding = value
+      else
+        @padding = Padding.convert(value)
+      end
+
+      self
+    end
+
+    # Sets an outline at `weight`
+    def outline=(outline)
+      @outline = outline
+
+      self
+    end
+
+    # Sets the outline color to `value`
+    def outline_color=(value)
+      case value
+      when Color
+        @outline_color = value
+      when Array
+        @outline_color = Color.new(value[0], value[1], value[2], value[3] || 255)
+      else
+        raise "Basd color"
+      end
+
+      self
+    end
+
+
+    # Sets the color of the rectangle
+    # from an array of rgba values
+    def color=(value)
+      case value
+      when Color
+        @color = value
+      when Array
+        @color = Color.new(value[0], value[1], value[2], value[3] || 255)
+      end
+
+      self
+    end
+
+    # Rounding amount for this rect
+    def round=(amount)
+      @rounding = amount
+
+      self
+    end
+
+    # Returns true if the rectangle has any padding
+    def padding?
+      [padding.t, padding.r, padding.b, padding.l].any? do |p|
+        p != 0.0
+      end
+    end
+
+    # Returns a tuple with the
+    # geometric boundary for this rectangle
+    def boundary
+      [x, y, width, height]
+    end
+
+    # Returns a tuple with the
+    # computed geometric **inner** boundary for this rectangle
+    # with outlines subtracted
+    def background_boundary
+      nx = x.dup
+      ny = y.dup
+      nw = width.dup
+      nh = height.dup
+
+      if outline.top > 0.0
+        ny += outline.top
+        nh -= outline.top
+      end
+
+      if outline.left > 0.0
+        nx += outline.left
+        nw -= outline.left
+      end
+
+      if outline.bottom > 0.0
+        nh -= outline.bottom
+      end
+
+      if outline.right > 0.0
+        nw -= outline.right
+      end
+
+      [nx, ny, nw, nh]
+    end
+
+    # Returns true if this rectangle
+    # has an outline
+    def outline?
+      outline.present?
+    end
+
+    # Returns true if this rectangle's
+    # outline is uniform
+    def outline_uniform?
+      outline.uniform?
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Hokusai
+  class Commands::ScissorBegin < Commands::Base
+    attr_reader :x, :y, :width, :height
+
+    def initialize(x, y, width, height)
+      @x = x
+      @y = y
+      @width = width
+      @height = height
+    end
+
+    def hash
+      [self.class, x, y, width, height].hash
+    end
+  end
+
+  class Commands::ScissorEnd < Commands::Base;
+    def hash
+      [self.class].hash
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+module Hokusai
+  class Commands::Text < Commands::Base
+    attr_reader :x, :y, :size, :color,
+                :padding, :wrap, :content,
+                :font, :static, :line_height,
+                :bold, :italic
+
+    def initialize(content, x, y)
+      @content = content
+      @x = x.to_f
+      @y = y.to_f
+      @color = Color.new(0, 0, 0, 255)
+      @padding = Padding.new(0.0, 0.0, 0.0, 0.0)
+      @size = 17
+      @wrap = false
+      @font = nil
+      @static = true
+      @bold = false
+      @italic = false
+      @line_height = 0.0
+    end
+
+    def hash
+      [self.class, content, color.hash, padding.hash, size, font, wrap].hash
+    end
+
+    def bold=(value)
+      @bold = value
+    end
+
+    def italic=(value)
+      @italic = value
+    end
+
+    def static=(value)
+      @static = !!value
+    end
+
+    def line_height=(value)
+      @line_height = value
+    end
+
+    def dynamic=(value)
+      @static = !value
+    end
+
+    def font=(value)
+      @font = value
+    end
+
+    def content=(value)
+      @content = value
+    end
+
+    def size=(height)
+      @size = height.to_f
+    end
+
+    # Sets padding for the text
+    # `value` is an array with padding declarations
+    # at [top, right, bottom, left]
+    def padding=(value)
+      case value
+      when Array
+        @padding = Padding.new(value[0], value[1], value[2], value[3])
+      when Integer
+        @padding = Padding.new(value, value, value, value)
+      when Padding
+        @padding = value
+      end
+
+      self
+    end
+
+    # Sets the color of the text
+    # from an array of rgba values
+    def color=(value)
+      case value
+      when Color
+        @color = value
+      when Array
+        @color = Color.new(value[0], value[1], value[2], value[3] || 255)
+      end
+    end
+
+    def padding?
+      [padding.t, padding.r, padding.b, padding.l].any? do |p|
+        p != 0.0
+      end
+    end
+  end
+end

data/ui/src/hokusai/commands.rb

@@ -0,0 +1,87 @@
+require_relative "./commands/base"
+require_relative "./commands/circle"
+require_relative "./commands/image"
+require_relative "./commands/rect"
+require_relative "./commands/scissor"
+require_relative "./commands/text"
+
+module Hokusai
+  class Commands
+    attr_reader :queue
+
+    def initialize
+      # @queue = []
+    end
+
+    # def hash
+    #   [self.class, *@queue.map(&:hash)].hash
+    # end
+
+    def rect(x, y, w, h)
+      command = Commands::Rect.new(x, y, w, h)
+      yield(command)
+
+      command.draw
+      # add(command)
+    end
+
+    def circle(x, y, radius)
+      command = Commands::Circle.new(x, y, radius)
+      yield(command)
+
+      command.draw
+      # add(command)
+    end
+
+    def svg(source, x, y, w, h)
+      command = Commands::SVG.new(source, x, y, w, h)
+      yield(command)
+
+      # add(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
+
+    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

@@ -0,0 +1,124 @@
+module Hokusai
+  class MovePatch
+    attr_accessor :from, :to, :delete
+
+    def initialize(from:, to:, delete: false)
+      @from = from
+      @to = to
+      @delete = delete
+    end
+  end
+
+  class InsertPatch
+    attr_accessor :target, :value, :delete
+
+    def initialize(target:, value:, delete: false)
+      @target = target
+      @value = value
+      @delete = delete
+    end
+  end
+
+  class UpdatePatch
+    attr_accessor :target, :value
+
+    def initialize(target:, value:)
+      @target = target
+      @value = value
+    end
+  end
+
+  class DeletePatch
+    attr_accessor :target
+
+    def initialize(target)
+      @target = target
+    end
+  end
+
+  class Diff
+    attr_reader :before, :after, :insertions
+
+    def initialize(before, after)
+      @before = before
+      @after = after
+      @insertions = {}
+    end
+
+    def map(list)
+      memo = {}
+      list.each_with_index do |(key, value), index|
+        memo[key] = { value: value, index: index }
+      end
+
+      memo
+    end
+
+    def patch
+      i = 0
+      deletions = 0
+      mapbefore = map(before)
+      mapafter = map(after)
+
+      while i < after.size
+        # left            right
+        # [d, a, c]     [(c), e, a, b]
+        #
+        # 1. [c, a]     [c, (e), a]
+        #
+        # 2. [c, e, a]   [c, e, b, (a),]
+        #
+        # 3. [c, e, b, a]
+        #
+        # is value (c) in left?
+        # yes ->
+        #   is left[0] (a) in right?
+        #     yes -> move c to 0, move a to 2
+        #     no -> delete a, move c to 0
+        #
+        akey, value = after[i]              # b
+        ckey, current = before[i] || nil    # a
+
+        if bi = mapbefore.delete(akey) # 2
+          if bi[:index] != i              # true (2 != 0)
+            if mapafter[ckey] # true
+              # move a to 2
+              before[bi[:index]] = [ckey, current] # before[2] = a
+              # update index
+              mapbefore[ckey] = { index: bi, value: current }
+
+              # move c to 0
+              yield MovePatch.new(from: bi, to: i)
+            else
+              yield MovePatch.new(from: bi, to: i, delete: true)
+              mapbefore[ckey] = nil
+              deletions += 1
+              # next
+            end
+          elsif value != current
+            yield UpdatePatch.new(target: i, value: value)
+          end
+        else # insert logic
+          if mapafter[ckey]
+            before[i + 1] = [ckey, current]
+            mapbefore[ckey] = { index: i + 1, value: current }
+
+            yield InsertPatch.new(target: i, value: value)
+          else
+            yield InsertPatch.new(target: i, value: value, delete: true)
+            mapbefore[ckey] = nil
+
+          end
+        end
+
+        i += 1
+      end
+
+      mapbefore.values.each do |value|
+        next if value.nil?
+
+        yield DeletePatch.new(value[:index]) unless value[:index].nil?
+      end
+    end
+  end
+end

data/ui/src/hokusai/error.rb

@@ -0,0 +1,3 @@
+module Hokusai
+  class Error < StandardError; end
+end

data/ui/src/hokusai/event.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Hokusai
+  class Event
+    attr_reader :captures, :bubbles
+    attr_accessor :stopped
+
+    def self.name(name)
+      @name = name
+    end
+
+    def name
+      self.class.instance_variable_get("@name")
+    end
+
+    def stopped
+      @stopped ||= false
+    end
+
+    def stop
+      self.stopped = true
+    end
+
+    def captures
+      @captures ||= []
+    end
+
+    def bubbles
+      @bubbles ||= []
+    end
+
+    def to_json
+      raise Hokusai::Error.new("#{self.class} must implement to_json")
+    end
+
+    def matches(block)
+      return false if block.node.portal.nil?
+
+      val = block.node.portal.ast.event(name)
+      !!val
+    end
+
+    def bubble
+      while block = captures.pop
+        block.emit(name, self)
+
+        break if stopped
+      end
+    end
+  end
+end
+
+require_relative './events/keyboard'
+require_relative './events/mouse'

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

@@ -0,0 +1,84 @@
+module Hokusai
+  class KeyboardEvent < Event
+    extend Forwardable
+
+    def_delegators :@keyboard, :shift, :super, :ctrl,
+                   :alt, :pressed, :pressed_len, :released,
+                   :released_len
+
+    attr_reader :input
+
+    def initialize(input, state)
+      @input = input
+      @state = state
+      @keyboard = input.keyboard
+    end
+
+    def hovered(canvas)
+      input.hovered?(canvas)
+    end
+
+    def to_json
+      {
+        keypress: {
+          keycode: code,
+          char: char.to_s,
+          super: self.super,
+          control: ctrl,
+          shift: shift,
+          alt: alt
+        }
+      }.to_json
+    end
+  end
+
+  class KeyUpEvent < KeyboardEvent
+    name "keyup"
+
+    def keyboard_key
+      input.raw[:keyboard][:released]
+    end
+
+    def key
+      keyboard_key[:key][:key]
+    end
+
+    def code
+      keyboard_key[:char_code]
+    end
+
+    def char
+      code.chr
+    end
+
+    def capture(block, _)
+      captures << block if matches(block) && released_len > 0
+    end
+  end
+
+  class KeyPressEvent < KeyboardEvent
+    name "keypress"
+
+    def keyboard_key
+      input.raw[:keyboard][:pressed]
+    end
+
+    def key
+      keyboard_key[:key][:key]
+    end
+
+    def code
+      keyboard_key[:char_code]
+    end
+
+    def char
+      code.chr
+    end
+
+    def capture(block, _)
+      return unless matches(block) && pressed_len > 0
+
+      captures << block
+    end
+  end
+end