User's Guide
Reference Manual
Release Notes
PDF
Top

wxErlang
Reference Manual
Version 0.98.5

Expand All
Contract All

Table of Contents

# wx_object

### MODULE

wx_object

### MODULE SUMMARY

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 objects. 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, Reason}

handle_call(Msg, {From, Tag}, State) should return
{reply, Reply, State} | {reply, Reply, State, Timeout} | {noreply, State} | {noreply, State, Timeout} | {stop, Reason, Reply, State}

Asynchronous window event handling:
handle_event(#wx{}, State) should return
{noreply, State} | {noreply, State, Timeout} | {stop, Reason, State}

Info is message e.g. {'EXIT', P, R}, {nodedown, N}, ...
handle_info(Info, State) should return , ...
{noreply, State} | {noreply, State, Timeout} | {stop, Reason, State}

When stop is returned in one of the functions above with Reason = normal | shutdown | Term, terminate(State) is called. It lets the user module clean up, it is always called when server terminates or when wxObject() 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};
      ...

### EXPORTS

start(Mod, Args, Options) -> wxWindow() (see module wxWindow)

Types:

Mod = atom()
Args = term()
Options = [{timeout, Timeout} | {debug, [Flag]}]
Flag = trace | log | {logfile, File} | statistics | debug

Starts a generic wx_object server and invokes Mod:init(Args) in the new process.

start(Name, Mod, Args, Options) -> wxWindow() (see module wxWindow)

Types:

Name = {local, atom()}
Mod = atom()
Args = term()
Options = [{timeout, Timeout} | {debug, [Flag]}]
Flag = trace | log | {logfile, File} | statistics | debug

Starts a generic wx_object server and invokes Mod:init(Args) in the new process.

start_link(Mod, Args, Options) -> wxWindow() (see module wxWindow)

Types:

Mod = atom()
Args = term()
Options = [{timeout, Timeout} | {debug, [Flag]}]
Flag = trace | log | {logfile, File} | statistics | debug

Starts a generic wx_object server and invokes Mod:init(Args) in the new process.

start_link(Name, Mod, Args, Options) -> wxWindow() (see module wxWindow)

Types:

Name = {local, atom()}
Mod = atom()
Args = term()
Options = [{timeout, Timeout} | {debug, [Flag]}]
Flag = trace | log | {logfile, File} | statistics | debug

Starts a generic wx_object server and invokes Mod:init(Args) in the new process.

call(Ref::wxObject() | atom() | pid(), Request::term()) -> 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(Ref::wxObject() | atom() | pid(), Request::term(), Timeout::integer()) -> term()

Make a call to a wx_object server with a timeout. Invokes handle_call(Request, From, State) in server

cast(Ref::wxObject() | atom() | pid(), Request::term()) -> ok

Make a cast to a wx_object server. Invokes handle_cast(Request, State) in the server

get_pid(Ref::wxObject()) -> pid()

Get the pid of the object handle.

reply(From::tuple(), Reply::term()) -> pid()

Get the pid of the object handle.