hokusai-zero 0.1.1

data/ui/examples/tic_tac_toe.rb

@@ -0,0 +1,246 @@
+require_relative "../src/hokusai"
+require_relative "../src/hokusai/backends/raylib"
+require_relative "../src/hokusai/backends/sdl2"
+
+module TicTacToe
+  module Player
+    X = 0
+    O = 1
+    None = 2
+  end
+
+  class Square < Hokusai::Block
+    style <<-EOF
+    [style]
+    squareStyle {
+      outline: 3.0;
+      outline_color: rgb(233,233,233);
+    }
+    EOF
+
+    template <<-EOF
+    [template]
+      vblock { 
+        @click="emit_position"
+        @hover="set_hover"
+        @mouseout="set_mouseout"
+        :background="compute_background" 
+        ...squareStyle
+      }
+        label { height="13" :content="read_position" }
+        [if="has_player"]
+          image { :source="square_image" }
+    EOF
+
+    computed! :player
+    computed! :position
+
+    uses(
+      vblock: Hokusai::Blocks::Vblock,
+      image: Hokusai::Blocks::Image,
+      label: Hokusai::Blocks::Label
+    )
+
+    def compute_background
+      case player
+      when Player::X
+        [52,168,77]
+      when Player::O
+        [219,176,57]
+      when Player::None
+        @hover ? [55, 110, 155] : [47,98,140]
+      end
+    end
+
+    def set_hover(event)
+      @hover = true
+    end
+
+    def set_mouseout(event)
+      @hover = false
+    end
+
+    def read_position
+      position.inspect
+    end
+
+    def emit_position(click)
+      emit("position", position)
+    end
+
+    def has_player
+      player != Player::None
+    end
+
+    def square_image
+      case player
+      when Player::X
+        return "#{__dir__}/assets/science-troll.png"
+      when Player::O
+        return "#{__dir__}/assets/football-troll.png"
+      end
+    end
+  end
+
+  class Row < Hokusai::Block
+    template <<-EOF
+    [template]
+      hblock
+        [for="player in row"]
+          square { cursor="pointer" @position="emit_position" :player="player" :key="key(index)" :position="position(index)" }
+    EOF
+
+    uses(
+      square: Square,
+      hblock: Hokusai::Blocks::Hblock
+    )
+
+    computed! :row
+    computed! :row_index
+
+    def emit_position(pos)
+      emit("position", pos)
+    end
+
+    def key(index)
+      "player_#{row_index}_#{index}"
+    end
+
+    def position(index)
+      [row_index, index]
+    end
+
+  end
+
+  class App < Hokusai::Block
+    template <<-EOF
+    [template]
+      vblock
+        [if="has_winner"]
+          vblock { background="10,10,10,222" }
+            img { :source="winner_image"}
+            vblock
+              label { :content="winner_text"  color="255,255,255", size="30"}
+              label { @click="restart" color="222,199,199" size="20" content="restart"}
+        [else]
+          vblock
+            [for="row in board"]
+              row { @position="update_game" :row="row" :key="key(index)" :row_index="index" }
+    EOF
+
+    uses(
+      row: Row,
+      vblock: Hokusai::Blocks::Vblock,
+      hblock: Hokusai::Blocks::Hblock,
+      label: Hokusai::Blocks::Label,
+      empty: Hokusai::Blocks::Empty,
+      img: Hokusai::Blocks::Image
+    )
+
+    attr_accessor :current_player, :board, :count
+
+    def initialize(**args)
+      @current_player = Player::X
+      @count = 0
+      super
+
+      restart
+    end
+
+    def restart(*args)
+      @board = [
+        [Player::None, Player::None, Player::None],
+        [Player::None, Player::None, Player::None],
+        [Player::None, Player::None, Player::None]
+      ]
+      self.count = 0
+    end
+
+    def key(index)
+      "row_#{index}"
+    end
+
+    def winner_image
+      case winner
+      when Player::X
+        return "#{__dir__}/assets/science-troll.png"
+      when Player::O
+        return "#{__dir__}/assets/football-troll.png"
+      else
+        return "#{__dir__}/assets/baby_sean.png"
+      end
+    end
+
+    def winner_text
+      case winner
+      when Player::X
+        "Player X won!"
+      when Player::O
+        "Player O won!"
+      else
+        "No winner"
+      end
+    end
+
+    def has_winner
+      count >= 9 || !check_win.nil?
+    end
+
+    def winner
+      check_win
+    end
+
+    def update_game(position)
+      row, col = position
+
+      self.count += 1
+
+      case current_player
+      when Player::X
+        board[row][col] = Player::X unless board[row][col] != Player::None
+        self.current_player = Player::O
+      when Player::O
+        board[row][col] = Player::O unless board[row][col] != Player::None
+        self.current_player = Player::X
+      end
+    end
+
+    def check_win
+      [Player::X, Player::O].each do |player|
+        (0...3).step do |i|
+          if board[i][0] == player && board[i][1] == player && board[i][2] == player
+            return player
+          end
+
+          if board[0][i] == player && board[1][i] == player && board[2][i] == player
+            return player
+          end
+
+          diagonal_left = board[0][0] == player && board[1][1] == player && board[2][2] == player
+          diagonal_right = board[2][0] == player && board[1][1] == player && board[0][2] == player
+
+          if diagonal_left || diagonal_right
+            return player
+          end
+        end
+      end
+
+      nil
+    end
+
+    def render(canvas)
+      if Hokusai.can_render(canvas)
+
+        emit("width", canvas.width)
+
+        yield canvas
+      end
+    end
+  end
+end
+#
+# Hokusai::Backends::SDLBackend.run(TicTacToe::App) do |config|
+#   config.width = 500
+#   config.height = 500
+#   config.title = "Tic Tac Trollio"
+# end

data/ui/lib/lib_hokusai.rb

@@ -0,0 +1,425 @@
+require "ffi"
+
+module LibHokusai
+  class Error < StandardError; end
+  extend FFI::Library
+
+  case RbConfig::CONFIG['host_os']
+  when /darwin/
+    ffi_lib "#{__dir__}/../../vendor/lib/libhokusai.dylib"
+  when /linux/
+    ffi_lib "#{__dir__}/../../vendor/lib/libhokusai.so"
+  else
+    raise "Unsupported platform!"
+  end
+
+  typedef :pointer, :hashmap
+
+  def self.parse_template(name, template)
+    ptr = FFI::MemoryPointer.new :pointer
+    code = LibHokusai.hoku_ast_from_template(ptr, name, template)
+
+    raise LibHokusai::Error.new("Couldn't parse template") unless code.zero?
+
+    a_ptr = ptr.get_pointer(0)
+    LibHokusai::HmlAst.new FFI::AutoPointer.new(a_ptr, LibHokusai.method(:hoku_ast_free))
+  ensure
+    ptr.free
+  end
+
+  def self.parse_style(template)
+    ptr = FFI::MemoryPointer.new :pointer
+    pp template
+    code = LibHokusai.hoku_style_from_template(ptr, template)
+
+    raise LibHokusai::Error.new("Couldn't parse style template") unless code.zero?
+
+    a_ptr = ptr.get_pointer(0)
+    LibHokusai::HmlStyle.new FFI::AutoPointer.new(a_ptr, LibHokusai.method(:hoku_style_free))
+  ensure
+    ptr.free
+  end
+
+  enum :hml_style_type, [
+    :style_int,
+    :style_float,
+    :style_bool,
+    :style_string,
+    :style_func
+  ]
+
+  class HmlStyleAttribute < FFI::Struct
+    layout :name, :string,
+           :function_name, :string,
+           :value, :string,
+           :type, :hml_style_type,
+           :next, HmlStyleAttribute.ptr
+  end
+
+  class HmlStyle < FFI::Struct
+    layout :name, :string,
+           :attributes, HmlStyleAttribute.ptr,
+           :next, HmlStyle.ptr
+  end
+
+  class HmlAstFuncCall < FFI::Struct
+    layout :function, :string,
+           :args_len, :int,
+           :args, :pointer,
+           :strargs, :pointer
+  end
+
+  class HmlAstProp < FFI::Struct
+    layout :name, :string,
+           :computed, :bool,
+           :call, HmlAstFuncCall.ptr
+  end
+
+  class HmlAstEvent < FFI::Struct
+    layout :name, :string,
+           :call, HmlAstFuncCall.ptr
+  end
+
+  class HmlAstCondition < FFI::Struct
+    layout :not, :bool,
+           :call, HmlAstFuncCall.ptr
+  end
+
+  class HmlAstLoop < FFI::Struct
+    layout :name, :string,
+           :list_name, :string
+  end
+
+  class HmlAstClassList < FFI::Struct
+    layout :name, :string,
+           :next, HmlAstClassList.ptr
+  end
+
+  class HmlAstList < FFI::Struct; end
+
+  class HmlAst < FFI::Struct
+    layout :type, :string,
+           :id, :string,
+           :error, :string,
+           :has_slot, :bool,
+           :child_len, :int,
+           :styles, HmlStyle.ptr,
+           :style_list, HmlAstClassList.ptr,
+           :class_list, HmlAstClassList.ptr,
+           :cond, HmlAstCondition.ptr,
+           :loop, HmlAstLoop.ptr,
+           :props, :hashmap,
+           :events, :hashmap,
+           :parent, HmlAst.ptr,
+           :relations, HmlAstList.ptr,
+           :else_relations, HmlAstList.ptr,
+           :else_active, :int
+  end
+
+  class HmlAstList < FFI::Struct
+    layout :next_sibling, HmlAst.ptr,
+           :next_child, HmlAst.ptr
+  end
+
+
+  # fun hashmap_iter(map : Hashmap, i : LibC::SizeT*, item : Void**) : Bool
+  # ast methods
+  attach_function :hoku_ast_prop_init, [:pointer, :string], :int
+  attach_function :hoku_ast_class_list_includes, [:pointer, :string], :int
+  attach_function :hoku_ast_get_prop, [HmlAst.by_ref, HmlAstProp.by_ref], HmlAstProp.by_ref
+  attach_function :hoku_ast_get_event, [:pointer, :pointer], HmlAstEvent.by_ref
+  attach_function :hashmap_iter, [:hashmap, :pointer, :pointer], :bool
+  attach_function :hashmap_count, [:hashmap], :int
+  attach_function :hoku_ast_free, [:pointer], :void
+  attach_function :hoku_errored_ast, [HmlAst.by_ref], HmlAst.by_ref
+  attach_function :hoku_ast_from_template, [:pointer, :string, :string], :int
+  attach_function :hoku_style_from_template, [:pointer, :string], :int
+  attach_function :hoku_style_free, [:pointer], :void
+  attach_function :hoku_dump, [:pointer, :int], :void
+
+  enum :hml_input_key, [
+    :null, :apostrophe, :comma, :minus,
+    :period, :slash, :zero, :one, :two,
+    :three, :four, :five, :six, :seven,
+    :eight, :nine, :semicolon, :equal,
+    :a, :b, :c, :d, :e, :f, :g, :h, :i,
+    :j, :k, :l, :m, :n, :o, :p, :q, :r,
+    :s, :t, :u, :v, :w, :x, :y, :z,
+    :left_bracket, :backslash, :right_bracket,
+    :grave, :space, :escape, :enter, :tab,
+    :backspace, :insert, :delete, :right, :left,
+    :down, :up, :page_up, :page_down, :home,
+    :end, :caps_lock, :scroll_lock, :num_lock,
+    :print_screen, :pause, :f1, :f2, :f3, :f4,
+    :f5, :f6, :f7, :f8, :f9, :f10, :f11, :f12,
+    :left_shift, :left_control, :left_alt,
+    :left_super, :right_shift, :right_control, :right_alt,
+    :right_super, :kb_menu, :kp_0, :kp_1, :kp_2,
+    :kp_3, :kp_4, :kp_5, :kp_6, :kp_7, :kp_8, :kp_9,
+    :kp_decimal, :kp_divide, :kp_multiply, :kp_subtract, :kp_add,
+    :kp_enter, :kp_equal, :back, :menu, :volume_up, :volume_down,
+    :max
+  ]
+
+  enum :hml_input_select_type, [
+    :ACTIVE, 0x01,
+    :FROZEN, 0x02,
+    :NONE, 0x03
+  ]
+
+  class HmlVec2 < FFI::Struct
+    layout :x, :float,
+           :y, :float
+
+    def self.create(x, y)
+      new.tap do |instance|
+        instance[:x] = x
+        instance[:y] = y
+      end
+    end
+
+    def x
+      self[:x]
+    end
+
+    def y
+      self[:y]
+    end
+  end
+
+  class HmlDoubleVec2 < FFI::Struct
+    layout :x, :double,
+           :y, :double
+
+    def x
+      self[:x]
+    end
+
+    def y
+      self[:y]
+    end
+  end
+
+  class HmlRect < FFI::Struct
+    layout :x, :float,
+           :y, :float,
+           :w, :float,
+           :h, :float
+
+    def self.create(x, y, w, h)
+      new.tap do |instance|
+        instance[:x] = x
+        instance[:y] = y
+        instance[:w] = w
+        instance[:h] = h
+      end
+    end
+  end
+
+  class HmlInputKeyboardKey < FFI::Struct
+    layout :code, :int,
+           :down, :bool,
+           :up, :bool,
+           :released, :bool,
+           :pressed, :bool,
+           :key, :hml_input_key
+  end
+
+  class HmlInputKeyboardKeyWithChar < FFI::Struct
+    layout :key, HmlInputKeyboardKey,
+           :char_code, :int
+  end
+
+  class HmlInputKeyboard < FFI::Struct
+    layout :allocated_len, :int,
+           :pressed, HmlInputKeyboardKeyWithChar.ptr,
+           :pressed_len, :int,
+           :released, HmlInputKeyboardKeyWithChar.ptr,
+           :released_len, :int,
+           :shift, :bool,
+           :super, :bool,
+           :ctrl, :bool,
+           :alt, :bool,
+           :keys, HmlInputKeyboardKey.ptr,
+           :collecting, :bool
+  end
+
+  class HmlInputMouseButton < FFI::Struct
+    layout :down, :bool,
+           :up, :bool,
+           :clicked, :bool,
+           :released, :bool
+
+    def self.create(up: false, down: false, clicked: false, released: false)
+      @button ||= new
+      @button.tap do |instance|
+        instance[:down] = down
+        instance[:up] = up
+        instance[:clicked] = clicked
+        instance[:released] = released
+      end
+      @button
+    end
+
+    def down
+      self[:down]
+    end
+
+    def up
+      self[:up]
+    end
+
+    def clicked
+      self[:clicked]
+    end
+
+    def released
+      self[:released]
+    end
+  end
+
+  class HmlInputMouse < FFI::Struct
+    layout :pos, HmlVec2.ptr,
+           :delta, HmlDoubleVec2,
+           :scroll, :float,
+           :scroll_delta, :float,
+           :selection, HmlRect,
+           :selection_type, :hml_input_select_type,
+           :left, HmlInputMouseButton.ptr,
+           :middle, HmlInputMouseButton.ptr,
+           :right, HmlInputMouseButton.ptr
+  end
+
+  class HmlInput < FFI::Struct
+    layout :keyboard, HmlInputKeyboard.ptr,
+           :mouse, HmlInputMouse.ptr
+  end
+
+  def LibHokusai.const_missing( sym )
+    value = enum_value( sym )
+    return super unless value
+    value
+  end
+
+  # input methods
+  attach_function :hoku_input_init, [:pointer], :int
+  attach_function :hoku_input_free, [HmlInput.by_ref], :void
+  attach_function :hoku_input_set_mouse_position, [HmlInput.by_ref, HmlVec2.by_ref], :void
+  attach_function :hoku_input_mouse_set_scroll, [HmlInput.by_ref, :float], :void
+  attach_function :hoku_input_mouse_set_button, [HmlInput.by_ref, HmlInputMouseButton.by_ref, :int], :void
+
+  attach_function :hoku_input_is_clicked, [HmlInput.by_ref, HmlRect.by_ref], :bool
+  attach_function :hoku_input_is_hovered, [HmlInput.by_ref, HmlRect.by_ref], :bool
+
+  attach_function :hoku_input_keyboard_start, [HmlInput.by_ref], :void
+  attach_function :hoku_input_keyboard_set_key, [HmlInput.by_ref, :hml_input_key, :bool], :void
+  attach_function :hoku_input_keyboard_get_key, [HmlInput.by_ref, :hml_input_key], HmlInputKeyboardKey
+  attach_function :hoku_input_keyboard_stop, [HmlInput.by_ref], :void
+
+
+  enum :hoku_select_type, [
+    :active, 0x01,
+    :frozen, 0x02,
+    :none, 0x03
+  ]
+
+  class HokuCursorPosition < FFI::Struct
+    layout :x, :float,
+           :y, :float,
+           :w, :float,
+           :h, :float
+
+    def self.create(position)
+      new.tap do |instance|
+        instance[:x] = position[0]
+        instance[:y] = position[1]
+        instance[:w] = position[2]
+        instance[:h] = position[3]
+      end
+    end
+  end
+
+  class HokuSelection < FFI::Struct
+    layout :type, :hoku_select_type,
+           :start_x, :float,
+           :start_y, :float,
+           :stop_x, :float,
+           :stop_y, :float,
+           :offset_y, :float,
+           :cursor, HokuCursorPosition.ptr
+  end
+
+  attach_function :hoku_selection_init, [:pointer], :int
+  attach_function :hoku_selection_selected, [HokuSelection.by_ref, :float, :float, :float, :float], :bool
+  attach_function :hoku_selection_cursor_set, [HokuSelection.by_ref, HokuCursorPosition.by_value], :int
+  attach_function :hoku_selection_cursor_free, [HokuSelection.by_ref], :void
+  attach_function :hoku_selection_free, [HokuSelection.by_ref], :void
+
+  attach_function :hoku_rect_includes_y, [HmlRect.by_value, :float], :bool
+  attach_function :hoku_rect_includes_x, [HmlRect.by_value, :float], :bool
+  attach_function :hoku_rect_x_left, [HmlRect.by_value, :int], :float
+  attach_function :hoku_rect_x_right, [HmlRect.by_value, :int], :float
+  attach_function :hoku_rect_y_up, [HmlRect.by_value, :int], :float
+  attach_function :hoku_rect_y_down, [HmlRect.by_value, :int], :float
+
+  class HokuChar < FFI::Struct
+    layout :offset, :int,
+           :width, :int,
+           :next_char, HokuChar.ptr
+  end
+
+  GROUP_NORMAL = 1 << 0
+  GROUP_BOLD = 1 << 1
+  GROUP_ITALICS = 1 << 2
+  GROUP_LINK = 1 << 3
+  GROUP_IMAGE = 1 << 4
+  GROUP_CODE = 1 << 5
+  GROUP_LIST_ITEM = 1 << 6
+
+  class HokuGroupLink < FFI::Struct
+    layout :url, :string
+  end
+
+  class HokuGroupImage < FFI::Struct
+    layout :src, :string
+  end
+
+  class HokuGroupCode < FFI::Struct
+    layout :language, :string
+  end
+
+  class HokuGroupListItem < FFI::Struct
+    layout :level, :int
+  end
+
+  class HokuGroup < FFI::Struct
+    layout :offset, :int,
+           :size, :int,
+           :type, :uint8,
+           :payload, :pointer,
+           :chars, HokuChar.ptr,
+           :next_group, HokuGroup.ptr
+  end
+
+  class HokuSegment < FFI::Struct
+    layout :offset, :int,
+           :size, :int,
+           :select_begin, :int,
+           :select_end, :int,
+           :chars, HokuChar.ptr,
+           :groups, HokuGroup.ptr,
+           :next_segment, HokuSegment.ptr
+  end
+
+  class HokuClamping < FFI::Struct
+    layout :text, :string,
+           :width, :float,
+           :segments, HokuSegment.ptr
+  end
+
+  callback :hoku_char_width_cb, [:char, :pointer], :int
+  attach_function :hoku_text_clamp_debug, [HokuClamping.by_ref], :void
+  attach_function :hoku_text_md_clamp, [:pointer, :string, :float, :float, :pointer, :hoku_char_width_cb], :int
+  attach_function :hoku_text_clamp, [:pointer, :string, :float, :float, :pointer, :hoku_char_width_cb], :int
+  attach_function :hoku_text_clamping_free, [:pointer], :void
+end