hokusai-zero 0.1.1

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

@@ -0,0 +1,214 @@
+require_relative "../util/clamping_iterator"
+
+class Hokusai::Blocks::Text < Hokusai::Block
+  template <<~EOF
+  [template]
+    empty {
+      cursor="manual"
+      @hover="set_hover_position"
+      @mouseout="unset_hover_position"
+      @click="set_click_position"
+      @mouseup="clear_click_position"
+    }
+  EOF
+
+  uses(empty: Hokusai::Blocks::Empty)
+
+  computed! :content
+  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
+
+  inject :selection
+  inject :panel_top
+  inject :panel_height
+  inject :panel_offset
+
+  attr_accessor :last_content, :last_clamping, :last_width,
+                :last_height, :click_position, :last_cursor_offset,
+                :last_char_index, :hover_position
+
+  def set_hover_position(event)
+    self.hover_position = [event.pos.x, event.pos.y]
+  end
+
+  def unset_hover_position(event)
+    if !event.state.set
+      Hokusai.set_mouse_cursor(:default)
+
+      event.state.set = true
+    end
+
+    self.hover_position = nil
+  end
+
+  def set_click_position(event)
+    self.click_position = [event.pos.x, event.pos.y]
+  end
+
+  def clear_click_position(_)
+    self.click_position = nil
+  end
+
+  def internal_render(clamping, canvas)
+    iterator = Hokusai::Util::ClampingIterator.new(clamping, canvas.x + padding.left, canvas.y + padding.top)
+    boundary = panel_height || canvas.y + canvas.height
+    offset_y = panel_offset || 0.0
+
+    boundary += panel_top if panel_top
+    hovered = false
+    link_hovered = false
+
+    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]
+
+            self.last_cursor_offset = cursor_offset
+          end
+        end
+
+        if hover_position
+          cx, cy = hover_position
+
+          if cx > x && cx <= x + group.width && cy > y && cy <= y + size && y > (panel_top || 0.0)
+            hovered = true
+          end
+        end
+
+
+        commands.text(text, x, y) do |command|
+          command.color = color
+          command.size = size
+
+          if group.respond_to?(:bold?)
+            
+            unless group.normal?
+              command.bold = group.bold?
+              command.italic = group.italics?
+
+              if group.link? && hovered
+                cx, cy = hover_position
+
+                if cx > x && cx <= x + group.width && cy > y && cy <= y + size
+                  link_hovered = true
+                end
+              end
+
+              if group.link? && click_position
+                cx, cy = click_position
+
+                if cx > x && cx <= x + group.width && cy > y && cy <= y + size && cy > (panel_top || 0)
+                  # that's a click
+                  case RbConfig::CONFIG['host_os']
+                  when /darwin/
+                    system("open #{group.link}")
+                  when /linux/
+                    system("xdg-open #{group.link}")
+                  end
+
+                  self.click_position = nil
+                end
+              end
+
+              command.color = Hokusai::Color.new(50, 110, 188) if group.link?
+            end
+          end
+        end
+      end
+
+      iterator.on_draw_selection do |x, y, width, height|
+        # commands.rect(x, y, width, height) do |command|
+        #   command.color = selection_color
+        # end
+      end
+
+      iterator.on_selection_change do |start, stop|
+        emit("selected", start, stop)
+      end
+
+      iterator.on_cursor_change do |x, y, w, h|
+        selection.cursor = [x, y + offset_y, w, h] if selection
+      end
+
+      iterator.on_char do |char, hitbox, offset|
+        unless selection.nil?
+          if cursor_offset && offset == cursor_offset - 1 && (last_cursor_offset != cursor_offset || last_content != content)
+            selection.cursor = [hitbox.move_x_right(2), hitbox.y + offset_y, hitbox.width, hitbox.height]
+
+            self.last_cursor_offset = cursor_offset
+          end
+
+          unless click_position.nil?
+            click_x, click_y = click_position
+
+            rect = Hokusai::Rect.new(hitbox.move_x_right, hitbox.y, hitbox.width, hitbox.height)
+
+            if rect.includes_x?(click_x) && hitbox.includes_y?(click_y)
+              selection.cursor = [hitbox.move_x_right(2), hitbox.y + offset_y, hitbox.width, hitbox.height]
+
+              if offset + 1 != last_cursor_offset
+                emit("select_offset", offset + 1)
+                self.last_cursor_offset = offset + 1
+              end
+
+              self.click_position = nil
+            end
+          end
+        end
+      end
+
+      while segment = iterator.next
+        segment.draw(size, [canvas.y, boundary], selection: selection)
+      end
+    end
+
+    if link_hovered
+      Hokusai.set_mouse_cursor(:pointer)
+    elsif hovered
+      Hokusai.set_mouse_cursor(:ibeam)
+    elsif hover_position
+      Hokusai.set_mouse_cursor(:default)
+    end
+
+    iterator.height
+  end
+
+  def after_updated
+    node.meta.set_prop(:height, last_height)
+  end
+
+  def clamp(text, width)
+    if markdown
+      Hokusai.fonts.active.clamp_markdown(text, size.to_i, width - size.to_f - padding.right)
+    else
+      Hokusai.fonts.active.clamp(text, size.to_i, width - size.to_f, padding.right)
+    end
+  end
+
+  def render(canvas)
+    if Hokusai.can_render(canvas)
+      unless last_content == content && last_width == canvas.width
+        # self.last_clamping&.free
+        self.last_clamping = clamp(content, canvas.width - (padding.left + padding.right))
+        self.last_width = canvas.width
+        self.last_content = content
+      end
+
+      height = internal_render(last_clamping, canvas)
+      self.last_content = last_content
+      emit("height_updated", height + padding.bottom) unless last_height == height + padding.bottom
+
+      self.last_height = height + padding.bottom + padding.top
+
+
+      yield canvas
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+require "time"
+module Hokusai::Blocks::Titlebar
+  class OSX < Hokusai::Block
+    GREEN = [38, 200, 75]
+    YELLOW = [253, 189, 61]
+    RED = [255, 92, 87]
+    DEFAULT = [133, 133, 133]
+    DRAG = [46,49,63]
+
+    template <<-EOF
+    [template]
+      hblock {
+        :background="get_background"
+        :outline="outline"
+        :outline_color="outline_color"
+        :rounding="rounding"
+        @mousedown="handle_move_start"
+        @mousemove="handle_move"
+        @hover="set_hover"
+        @mouseout="clear_hover"
+      }
+        vblock { width="4" }
+          empty
+        vblock { width="60" }
+          hblock 
+            circle { @click="close" @hover="hover_red" @mouseout="blur_red" :radius="radius" :color="red" }
+            circle { @click="minimize" @hover="hover_yellow" @mouseout="blur_yellow" :radius="radius" :color="yellow" }
+            circle { @click="maximize" @hover="hover_green" @mouseout="blur_green" :radius="radius" :color="green" }
+        vblock
+          hblock
+            slot
+    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 :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
+
+
+    uses(
+      circle: Hokusai::Blocks::Circle,
+      vblock: Hokusai::Blocks::Vblock,
+      hblock: Hokusai::Blocks::Hblock,
+      empty: Hokusai::Blocks::Empty
+    )
+
+    attr_accessor :moving, :last_event, :hovering, :maximized
+
+    def get_background
+      moving ? background_drag : background
+    end
+
+    def handle_move_start(event)
+      self.last_event = [event.pos.x, event.pos.y] unless moving
+      self.moving = true
+    end
+
+    def handle_move(event)
+      if moving && event.left.down
+        x = event.pos.x - last_event[0]
+        y = event.pos.y - last_event[1]
+        # pp ["set window", Time.now.strftime("%H:%M:%S %L")]
+        Hokusai.set_window_position([x, y])
+      else
+        self.moving = false
+      end
+    end
+
+    def set_hover(_)
+      self.hovering = true
+    end
+
+    def clear_hover(_)
+      self.hovering = false
+    end
+
+    def close(_)
+      Hokusai.close_window
+    end
+
+    def minimize(_)
+      Hokusai.minimize_window
+    end
+
+    def maximize(_)
+      if maximized
+        Hokusai.restore_window
+        self.maximized = false
+      else
+        Hokusai.maximize_window
+        self.maximized = true
+      end
+    end
+
+    def blur_red(_)
+      @hovered_red = false
+    end
+
+    def blur_yellow(_)
+      @hovered_yellow = false
+    end
+
+    def blur_green(_)
+      @hovered_green = false
+    end
+
+    def hover_red(_)
+      @hovered_red = true
+    end
+
+    def hover_yellow(_)
+      @hovered_yellow = true
+    end
+
+    def hover_green(_)
+      @hovered_green = true
+    end
+
+    def red
+      @hovered_red ? RED : unhovered_color
+    end
+
+    def yellow
+      @hovered_yellow ? YELLOW : unhovered_color
+    end
+
+    def green
+      @hovered_green ? GREEN : unhovered_color
+    end
+
+    def initialize(**args)
+      super(**args)
+      @hovered_red = false
+      @hovered_yellow = false
+      @hovered_green = false
+      @moving = false
+      @hovering = false
+      @last_event = nil
+      @maximized = false
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+class Hokusai::Blocks::Toggle < Hokusai::Block
+  template <<-EOF
+  [template]
+    empty { @click="toggle" }
+  EOF
+
+  uses(empty: Hokusai::Blocks::Empty)
+
+  computed :size, default: 30.0, convert: proc(&:to_f)
+  computed :active_color, default: [137, 126, 186], convert: Hokusai::Color
+  computed :inactive_color, default: [61, 57, 81], convert: Hokusai::Color
+  computed :color, default: [215, 212, 226], convert: Hokusai::Color
+
+  attr_accessor :toggled
+
+  def toggle(_)
+    self.toggled = !toggled
+
+    emit("toggle", value: toggled)
+  end
+
+  def computed_color
+    toggled ? active_color : inactive_color
+  end
+
+  def initialize(**args)
+    @toggled = false
+
+    super(**args)
+  end
+
+  def render(canvas)
+    width = size * 2
+    radius = size / 2
+
+    start = toggled ? (canvas.x + width - radius) : canvas.x + radius
+
+    draw do
+      rect(canvas.x, canvas.y, width.to_f, size) do |command|
+        command.color = computed_color
+        command.round = size
+        command.padding = Hokusai::Padding.convert(20)
+      end
+
+      circle(start, canvas.y + radius, radius) do |command|
+        command.color = color
+      end
+    end
+
+    canvas.width = size * 2
+    canvas.height = size
+
+    yield(canvas)
+  end
+end

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

@@ -0,0 +1,35 @@
+class Hokusai::Blocks::Vblock < Hokusai::Block
+  template <<~EOF
+    [template]
+      slot
+  EOF
+
+  computed :padding, default: [0, 0, 0, 0], convert: Hokusai::Padding
+  computed :background, default: nil, convert: Hokusai::Color
+  computed :rounding, default: 0.0
+  computed :outline, default: Hokusai::Outline.default, convert: Hokusai::Outline
+  computed :outline_color, default: nil, convert: Hokusai::Color
+  computed :reverse, default: false
+
+  def render(canvas)
+    canvas.vertical = true
+    canvas.reverse = reverse
+
+    if background.nil?
+      yield canvas
+    else
+      draw do
+        rect(canvas.x, canvas.y, canvas.width, canvas.height) do |command|
+          command.color = background
+          command.outline = outline if outline
+          command.outline_color = outline_color if outline_color
+          command.round = rounding.to_f if rounding
+          command.padding = padding
+          canvas = command.trim_canvas(canvas)
+        end
+      end
+
+      yield canvas
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Hokusai::Commands
+  class Base
+    def self.on_draw(&block)
+      @draw = block
+    end
+
+    def self.draw
+      @draw
+    end
+
+    def draw
+      raise Hokusai::Error.new("No draw callback made for #{self.class}") if self.class.draw.nil?
+
+      self.class.draw.call(self.freeze)
+    end
+
+    def after_draw(canvas)
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Hokusai
+  class Commands::Circle < Commands::Base
+    attr_reader :x, :y, :radius, :color, :outline_color,
+                :outline
+
+    def initialize(x, y, radius)
+      @x = x
+      @y = y
+      @radius = radius
+      @color = Color.new(255, 255, 255, 255)
+      @outline_color = Color.new(0, 0, 0, 0)
+      @outline = 0.0
+    end
+
+    def hash
+      [self.class, x, y, radius, color.hash, outline_color.hash, outline].hash
+    end
+
+    def outline=(weight)
+      @outline = weight
+
+      self
+    end
+
+    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
+
+    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)
+      end
+
+      self
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Hokusai
+  class Commands::Image < Commands::Base
+    attr_reader :x, :y, :width, :height, :source
+
+    def initialize(source, x, y, width, height)
+      @source = source
+      @x = x
+      @y = y
+      @width = width
+      @height = height
+    end
+
+    def hash
+      [self.class, x, y, width, height, source].hash
+    end
+
+    def cache
+      [source, width, height].hash
+    end
+  end
+
+  class Commands::SVG < Commands::Base
+    attr_reader :x, :y, :width, :height, :source, :color
+
+    def initialize(source, x, y, width, height)
+      @source = source
+      @x = x
+      @y = y
+      @width = width
+      @height = height
+      @color = Color.new(255, 255, 255, 255)
+    end
+
+    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
+  end
+end