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}

       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(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.

       stop(Ref::wxObject() | atom() | pid()) -> ok

              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(Ref::wxObject() | atom() | pid(), Reason::term(), Timeout::timeout()) -> ok

              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(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.

AUTHORS

       <>

                                                    wx 1.6.1                                     wx_object(3erl)