wx_object(3erl) Erlang Module Definition wx_object(3erl)
NAME
wx_object - wx_object - Generic wx object behaviour.
DESCRIPTION
wx_object - Generic wx object behaviour
This is a behaviour module that can be used for "sub classing" wx ob-
jects. It works like a regular gen_server module and creates a server
per object.
NOTE: Currently no form of inheritance is implemented.
The user module should export:
init(Args) should return
{wxObject, State} | {wxObject, State, Timeout} | ignore | {stop, Rea-
son}
Asynchronous window event handling:
handle_event(#wx{}, State) should return
{noreply, State} | {noreply, State, Timeout} | {stop, Reason, State}
The user module can export the following callback functions:
handle_call(Msg, {From, Tag}, State) should return
{reply, Reply, State} | {reply, Reply, State, Timeout} | {noreply,
State} | {noreply, State, Timeout} | {stop, Reason, Reply, State}
handle_cast(Msg, State) should return
{noreply, State} | {noreply, State, Timeout} | {stop, Reason, State}
If the above are not exported but called, the wx_object process will
crash. The user module can also export:
Info is message e.g. {'EXIT', P, R}, {nodedown, N}, ...
handle_info(Info, State) should return , ...
{noreply, State} | {noreply, State, Timeout} | {stop, Reason, State}
If a message is sent to the wx_object process when handle_info is not
exported, the message will be dropped and ignored.
When stop is returned in one of the functions above with Reason = nor-
mal | shutdown | Term, terminate(State) is called. It lets the user
module clean up, it is always called when server terminates or when
wx_object() in the driver is deleted. If the Parent process terminates
the Module:terminate/2 function is called.
terminate(Reason, State)
Example:
-module(myDialog).
-export([new/2, show/1, destroy/1]). %% API
-export([init/1, handle_call/3, handle_event/2,
handle_info/2, code_change/3, terminate/2]).
new/2, showModal/1, destroy/1]). %% Callbacks
%% Client API
new(Parent, Msg) ->
wx_object:start(?MODULE, [Parent,Id], []).
show(Dialog) ->
wx_object:call(Dialog, show_modal).
destroy(Dialog) ->
wx_object:call(Dialog, destroy).
%% Server Implementation ala gen_server
init([Parent, Str]) ->
Dialog = wxDialog:new(Parent, 42, "Testing", []),
...
wxDialog:connect(Dialog, command_button_clicked),
{Dialog, MyState}.
handle_call(show, _From, State) ->
wxDialog:show(State#state.win),
{reply, ok, State};
...
handle_event(#wx{}, State) ->
io:format("Users clicked button~n",[]),
{noreply, State};
...
DATA TYPES
request_id() = term():
server_ref() = wx:wx_object() | atom() | pid():
EXPORTS
start(Name, Mod, Args, Options) -> wxWindow:wxWindow() | {error,
term()}
Types:
Name = {local, atom()}
Mod = atom()
Args = term()
Flag = trace | log | {logfile, string()} | statistics | debug
Options = [{timeout, timeout()} | {debug, [Flag]}]
Starts a generic wx_object server and invokes Mod:init(Args) in
the new process.
start_link(Mod, Args, Options) -> wxWindow:wxWindow() | {error, term()}
Types:
Mod = atom()
Args = term()
Flag = trace | log | {logfile, string()} | statistics | debug
Options = [{timeout, timeout()} | {debug, [Flag]}]
Starts a generic wx_object server and invokes Mod:init(Args) in
the new process.
start_link(Name, Mod, Args, Options) -> wxWindow:wxWindow() | {error,
term()}
Types:
Name = {local, atom()}
Mod = atom()
Args = term()
Flag = trace | log | {logfile, string()} | statistics | debug
Options = [{timeout, timeout()} | {debug, [Flag]}]
Starts a generic wx_object server and invokes Mod:init(Args) in
the new process.
stop(Obj) -> ok
Types:
Obj = wx:wx_object() | atom() | pid()
Stops a generic wx_object server with reason 'normal'. Invokes
terminate(Reason,State) in the server. The call waits until the
process is terminated. If the process does not exist, an excep-
tion is raised.
stop(Obj, Reason, Timeout) -> ok
Types:
Obj = wx:wx_object() | atom() | pid()
Reason = term()
Timeout = timeout()
Stops a generic wx_object 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.
call(Obj, Request) -> term()
Types:
Obj = wx:wx_object() | atom() | pid()
Request = term()
Make a call to a wx_object server. The call waits until it gets
a result. Invokes handle_call(Request, From, State) in the
server
call(Obj, Request, Timeout) -> term()
Types:
Obj = wx:wx_object() | atom() | pid()
Request = term()
Timeout = integer()
Make a call to a wx_object server with a timeout. Invokes han-
dle_call(Request, From, State) in server
send_request(Obj, Request::term()) -> request_id()
Types:
Obj = wx:wx_object() | atom() | pid()
Make an send_request to a generic server. and return a RequestId
which can/should be used with wait_response/[1|2]. Invokes han-
dle_call(Request, From, State) in server.
wait_response(RequestId::request_id()) -> {reply, Reply::term()} | {er-
ror, {term(), server_ref()}}
Wait infinitely for a reply from a generic server.
wait_response(Key::request_id(), Timeout::timeout()) -> {reply, Re-
ply::term()} | timeout | {error, {term(), server_ref()}}
Wait 'timeout' for a reply from a generic server.
check_response(Msg::term(), Key::request_id()) -> {reply, Re-
ply::term()} | false | {error, {term(), server_ref()}}
Check if a received message was a reply to a RequestId
cast(Obj, Request) -> ok
Types:
Obj = wx:wx_object() | atom() | pid()
Request = term()
Make a cast to a wx_object server. Invokes handle_cast(Request,
State) in the server
get_pid(Obj) -> pid()
Types:
Obj = wx:wx_object() | atom() | pid()
Get the pid of the object handle.
set_pid(Obj, Pid::pid()) -> wx:wx_object()
Types:
Obj = wx:wx_object() | atom() | pid()
Sets the controlling process of the object handle.
reply(X1::{pid(), Tag::term()}, Reply::term()) -> pid()
Get the pid of the object handle.
AUTHORS
<>
wx 1.9.1 wx_object(3erl)