View Source WxObject behaviour (wx_ex v0.4.3)

An Elixir wrapper for Erlang’s :wx_object behaviour, along the lines of GenServer etc.

Does not yet support 100% of :wx_object’s API.

Unlike GenServer, WxObject returns a wxWindow reference rather than a pid. If you want to include your top level object in your supervision tree, you will need to return the pid from start_link. For example:

def start_link(_arg) do
  ref = WxObject.start_link(__MODULE__, nil, name: __MODULE__)
  {:ok, WxObject.get_pid(ref)}
end

For an example of using this module, see wx_tutorial.

Summary

Callbacks

handle_call(request, from, state)

handle_cast(request, state)

handle_event(request, state)

handle_info(msg, state)

handle_sync_event(request, ref, state)

init(args)

terminate(reason, state)

Functions

call(obj, request, timeout \\ 5000)

Make a synchronous call to the server and wait for its reply.

cast(obj, request)

Cast a request to the server without waiting for a response.

get_pid(obj)

Get the pid of the object handle.

start_link(module, args)

start_link(name, module, args)

start_link(name, module, args, options)

stop(server, reason \\ :normal, timeout \\ :infinity)

Stops a WxObject server with the given reason. Invokes terminate(reason, state) in the server. The call waits until the process is terminated. If the call times out, or if the process does not exist, an exception is raised.

Callbacks

handle_call(request, from, state)

(optional)

@callback handle_call(request :: term(), from :: GenServer.server(), state :: term()) ::
  {:reply, reply, new_state}
  | {:reply, reply, new_state,
     timeout() | :hibernate | {:continue, continue_arg :: term()}}
  | {:noreply, new_state}
  | {:noreply, new_state,
     timeout() | :hibernate | {:continue, continue_arg :: term()}}
  | {:stop, reason, reply, new_state}
  | {:stop, reason, new_state}
when reply: term(), new_state: term(), reason: term()

handle_cast(request, state)

(optional)

@callback handle_cast(request :: term(), state :: term()) ::
  {:noreply, new_state}
  | {:noreply, new_state,
     timeout() | :hibernate | {:continue, continue_arg :: term()}}
  | {:stop, reason :: term(), new_state}
when new_state: term()

handle_event(request, state)

@callback handle_event(
  request ::
    {:wx, id :: integer(), obj :: :wx.wx_object(), userData :: term(),
     event :: tuple()},
  state :: term()
) ::
  {:noreply, new_state :: term()}
  | {:noreply, new_state :: term(), timeout() | :hibernate}
  | {:stop, reason :: term(), new_state :: term()}

handle_info(msg, state)

(optional)

@callback handle_info(msg :: :timeout | term(), state :: term()) ::
  {:noreply, new_state}
  | {:noreply, new_state,
     timeout() | :hibernate | {:continue, continue_arg :: term()}}
  | {:stop, reason :: term(), new_state}
when new_state: term()

handle_sync_event(request, ref, state)

(optional)

@callback handle_sync_event(
  request ::
    {:wx, id :: integer(), obj :: :wx.wx_object(), userData :: term(),
     event :: tuple()},
  ref :: {:wx_ref, ref :: term(), type :: term(), state :: term()},
  state :: term()
) :: :ok

init(args)

@callback init(args :: term()) ::
  {{:wx_ref, ref :: term(), type :: term(), state :: term()},
   [{:state, term()}]}
  | {{:wx_ref, ref :: term(), type :: term(), state :: term()}, state :: term(),
     timeout() | :hibernate}
  | {:stop, reason :: term()}
  | :ignore

terminate(reason, state)

(optional)

@callback terminate(reason, state :: term()) :: term()
when reason: :normal | :shutdown | {:shutdown, term()} | term()

Functions

call(obj, request, timeout \\ 5000)

@spec call(:wx.wx_object(), term(), timeout()) :: term()

Make a synchronous call to the server and wait for its reply.

cast(obj, request)

@spec cast(:wx.wx_object(), term()) :: term()

Cast a request to the server without waiting for a response.

get_pid(obj)

@spec get_pid(:wx.wx_object() | atom() | pid()) :: pid()

Get the pid of the object handle.

start_link(module, args)

start_link(name, module, args)

start_link(name, module, args, options)

stop(server, reason \\ :normal, timeout \\ :infinity)

@spec stop(:wx.wx_object(), term(), timeout()) :: :ok