kmx git

defmodule Exterm do
  @behaviour :wx_object
  use Bitwise

  @title 'exterm'
  @size {721, 433}

  def start_link(opts) do
    {_ref, _num, _type, pid} = :wx_object.start_link(__MODULE__, opts, [])
    {:ok, pid}
  end

  def child_spec(opts) do
    %{
      id: __MODULE__,
      start: {__MODULE__, :start_link, [opts]},
      type: :worker,
      restart: :permanent,
      shutdown: 500
    }
  end

  def init(config) do
    IO.inspect({&Exterm.init/1, config})
    wx = :wx.new(config)
    frame = :wxFrame.new(wx, :wx_const.wx_id_any, @title, [{:size, @size}])
    :ok = :wxWindow.connect(frame, :close_window)
    true = :wxFrame.show(frame)
    Exterm.Font.init()
    font = Exterm.Font.load()
    opts = [{:size, @size}]
    gl_attrib = [{:attribList, [:wx_const.wx_gl_rgba,
                                :wx_const.wx_gl_doublebuffer,
                                :wx_const.wx_gl_min_red, 8,
                                :wx_const.wx_gl_min_green, 8,
                                :wx_const.wx_gl_min_blue, 8,
                                :wx_const.wx_gl_depth_size, 24, 0]}]
    canvas = :wxGLCanvas.new(frame, opts ++ gl_attrib)
    :ok = :wxGLCanvas.connect(canvas, :size)
    :ok = :wxGLCanvas.connect(canvas, :char)
    :wxWindow.reparent(canvas, frame)
    context = :wxGLContext.new(canvas)
    :wxGLCanvas.setCurrent(canvas, context)
    setup_gl(canvas)
    state = %{bell: false,
              canvas: canvas,
              font: font,
              lines: ['$>_hello_world_!  ' |> Enum.reverse(),
                      'plop',
                      'hop',
                      'toto toto']}
    :wx.batch(fn -> render(state) end)
    {frame, state}
  end

  def code_change(_, _, state) do
    {:stop, :not_implemented, state}
  end

  def handle_cast(msg, state) do
    IO.puts "Cast:"
    IO.inspect msg
    {:noreply, state}
  end

  def handle_call(msg, _from, state) do
    IO.puts "Call:"
    IO.inspect msg
    {:reply, :ok, state}
  end

  def handle_info(:stop, state) do
    :wxGLCanvas.destroy(state.canvas)
    {:stop, :normal, state}
  end

  def handle_info(:update, state) do
    :wx.batch(fn -> render(state) end)
    {:noreply, state}
  end

  # Example input:
  # {:wx, -2006, {:wx_ref, 35, :wxFrame, []}, [], {:wxClose, :close_window}}
  def handle_event({:wx, _, _, _, {:wxClose, :close_window}}, state) do
    {:stop, :normal, state}
  end

  def handle_event(x = {:wx, _, _, _, {:wxSize, :size, {width, height}, _}}, state) do
    IO.inspect(x)
    if width != 0 and height != 0 do
      resize_gl_scene(width, height)
      :wx.batch(fn -> render(state) end)
      :ok
    end
    {:noreply, state}
  end

  def handle_event({:wx, _, _, _, {:wxKey, :char, _, _, code, _, _, _, _, _, _, _}}, state) do
    state = state
    |> state_input_char([code])
    :wx.batch(fn -> render(state) end)
    {:noreply, state}
  end

  defp state_input_char(state = %{lines: lines}, '\r') do
    %{state | lines: [[] | reverse_first_line(lines)]}
  end
  defp state_input_char(state = %{lines: []}, '\b') do
    %{state | bell: true}
  end
  defp state_input_char(state = %{lines: [[] | rest]}, '\b') do
    %{state | lines: rest}
  end
  defp state_input_char(state = %{lines: [[_ | rest] | lines_rest]}, '\b') do
    %{state | lines: [rest | lines_rest]}
  end
  defp state_input_char(state = %{lines: []}, char) do
    %{state | lines: [char]}
  end
  defp state_input_char(state = %{lines: [first | rest]}, [char]) do
    state = %{state | lines: [[char | first] | rest]}
  end

  def handle_event(data, state) do
    IO.inspect({:handle_event, data, state})
    {:noreply, state}
  end

  def terminate(_reason, state) do
    :wxGLCanvas.destroy(state.canvas)
  end

  defp setup_gl(win) do
    {w, h} = :wxWindow.getClientSize(win)
    resize_gl_scene(w, h)
    #:gl.shadeModel(:gl_const.gl_smooth)
    :gl.clearColor(1.0, 1.0, 1.0, 0.0)
    #:gl.clearDepth(1.0)
    #:gl.enable(:gl_const.gl_depth_test)
    #:gl.depthFunc(:gl_const.gl_lequal)
    #:gl.hint(:gl_const.gl_perspective_correction_hint, :gl_const.gl_nicest)
    :ok
  end

  defp resize_gl_scene(width, height) do
    IO.inspect({:resize_gl_scene, width, height})
    :gl.viewport(0, 0, width * 2, height * 2)
    :gl.matrixMode(:gl_const.gl_projection)
    :gl.loadIdentity()
    :gl.ortho(0.0, width + 0.0, 0.0, height + 0.0, -100.0, 100.0)
    :gl.matrixMode(:gl_const.gl_modelview)
    :gl.loadIdentity()
    :ok
  end

  defp draw(font, lines) do
    wrapped = lines |> reverse_first_line() |> wrap(80, 25)
    lists = wrapped
    |> Enum.map(fn line ->
      Enum.map(line, fn c ->
        Exterm.Font.load_glyph(font.regular, c)
      end)
    end)
    :gl.clearColor(0.5, 0.5, 0.5, 0.0)
    :gl.clear(:gl_const.gl_color_buffer_bit)
    lists
    |> Enum.with_index()
    |> Enum.each(fn {line, i} ->
      :gl.rasterPos2f(0.0, i * 16.0 + 32.0)
      :gl.callLists(line)
    end)
  end

  def reverse_first_line([]), do: []
  def reverse_first_line([first | rest]), do: [first |> Enum.reverse() | rest]

  def wrap(input, w, h) when is_list(input) do
    input
    |> Enum.slice(0..h)
    |> Enum.reverse()
    |> wrap(w, [], 0, [])
    |> Enum.slice(0..(h - 1))
  end
  def wrap([], _w, lines, _, _) do
    lines
  end
  def wrap([[] | rest], w, lines, x, acc) do
    line = acc |> Enum.reverse()
    wrap(rest, w, [line | lines], 0, [])
  end
  def wrap(input, w, lines, x, acc) when x >= w do
    line = acc |> Enum.reverse()
    wrap(input, w, [line | lines], 0, [])
  end
  def wrap([[9 | rest] | rest1], w, lines, x, acc) do
    len = Enum.count(acc)
    r = 8 - rem(len, 8)
    r = if r == 0, do: 8, else: r
    acc1 = 1..r
    |> Enum.reduce(acc, fn _, acc -> [32 | acc] end)
    wrap([rest | rest1], w, lines, x + r, acc1)
  end
  def wrap([[c | rest] | rest1], w, lines, x, acc) do
    wrap([rest | rest1], w, lines, x + 1, [c | acc])
  end

  defp render(%{canvas: canvas, font: font, lines: lines} = _state) do
    draw(font, lines)
    :wxGLCanvas.swapBuffers(canvas)
    :ok
  end
end
thodg/exterm/lib/exterm.ex

Commit

lib/exterm.ex
