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 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}

       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 = normal | 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};
         ...

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 exception 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  handle_call(Request,
              From, State) in server

       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.8.3                             wx_object(3erl)