kmx git

defmodule Exterm do
  @behaviour :wx_object
  use Bitwise

  @title 'exterm'
  @size {800, 600}

  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}])
    :wxWindow.connect(frame, :close_window)
    :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)
    :wxGLCanvas.connect(canvas, :size)
    :wxWindow.reparent(canvas, frame)
    context = :wxGLContext.new(canvas)
    :wxGLCanvas.setCurrent(canvas, context)
    setup_gl(canvas)
    state = %{canvas: canvas,
              font: font,
              lines: ['$ hello world !']}
    :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({:wx, _, _, _, {:wxSize, :size, {width, height}, _}}, state) do
    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(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, height)
    :gl.matrixMode(:gl_const.gl_projection)
    :gl.loadIdentity()
    :gl.ortho(0.0, width + 0.0, height + 0.0, 0.0, -1.0, 1.0)
    :gl.matrixMode(:gl_const.gl_modelview)
    :gl.loadIdentity()
    :ok
  end

  defp draw(font, lines) do
    IO.inspect(:draw)
    :gl.clear(:gl_const.gl_color_buffer_bit)
    :gl.loadIdentity()
    Enum.each(lines, fn line ->
      Enum.each(line, fn c when is_integer(c) ->
        Exterm.Font.render_glyph(font.regular, c)
      end)
    end)
    :gl.end()
  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
