查看源码 wx_object 行为 (wx v2.4.3)

wx_object - 通用的 wx 对象行为

这是一个行为模块,可用于“子类化” wx 对象。它的工作方式类似于常规的 gen_server 模块,并为每个对象创建一个服务器。

注意:目前尚未实现任何形式的继承。

用户模块应导出

init(Args) 应该返回
{wxWindow, State} | {wxWindow, State, Timeout} | ignore | {stop, Reason}

异步窗口事件处理
handle_event(#wx{}, State) 应该返回
{noreply, State} | {noreply, State, Timeout} | {stop, Reason, State}

用户模块可以导出以下回调函数

handle_call(Msg, {From, Tag}, State) 应该返回
{reply, Reply, State} | {reply, Reply, State, Timeout} | {noreply, State} | {noreply, State, Timeout} | {stop, Reason, Reply, State}

handle_cast(Msg, State) 应该返回
{noreply, State} | {noreply, State, Timeout} | {stop, Reason, State}

如果以上函数未导出但被调用,则 wx_object 进程将崩溃。用户模块还可以导出

Info 是消息,例如 {'EXIT', P, R}, {nodedown, N}, ...
handle_info(Info, State) 应该返回, ...
{noreply, State} | {noreply, State, Timeout} | {stop, Reason, State}

如果当未导出 handle_info 时向 wx_object 进程发送消息,则该消息将被丢弃并忽略。

当在上述函数之一中返回 stop 且 Reason = normal | shutdown | Term 时,将调用 terminate(State)。它允许用户模块清理,它总是在服务器终止或驱动程序中的 wx_object() 被删除时调用。如果父进程终止,则会调用 Module:terminate/2 函数。
terminate(Reason, State)

示例

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

数据类型

摘要

函数

向 wx_object 服务器发起调用。该调用会等待直到获得结果。在服务器中调用 handle_call(Request, From, State)

向带有超时的 wx_object 服务器发起调用。在服务器中调用 handle_call(Request, From, State)

向 wx_object 服务器发起投射。在服务器中调用 handle_cast(Request, State)

检查接收到的消息是否是对 RequestId 的回复

获取对象句柄的 pid。

获取对象句柄的 pid。

向通用服务器发起 send_request,并返回一个 RequestId,该 RequestId 可以/应该与 wait_response/[1|2] 一起使用。在服务器中调用 handle_call(Request, From, State)。

设置对象句柄的控制进程。

启动一个通用的 wx_object 服务器,并在新进程中调用 Mod:init(Args)。

启动一个通用的 wx_object 服务器,并在新进程中调用 Mod:init(Args)。

启动一个通用的 wx_object 服务器,并在新进程中调用 Mod:init(Args)。

停止一个通用的 wx_object 服务器,原因设置为 'normal'。在服务器中调用 terminate(Reason,State)。该调用会等待直到进程终止。如果进程不存在,则会引发异常。

使用给定的 Reason 停止一个通用的 wx_object 服务器。在服务器中调用 terminate(Reason,State)。该调用会等待直到进程终止。如果调用超时,或者进程不存在,则会引发异常。

无限期地等待来自通用服务器的回复。

等待 'timeout' 时间,以接收来自通用服务器的回复。

类型

-type event() ::
          wxActivateEvent:wxActivate() |
          wxAuiManagerEvent:wxAuiManager() |
          wxAuiNotebookEvent:wxAuiNotebook() |
          wxBookCtrlEvent:wxBookCtrl() |
          wxCalendarEvent:wxCalendar() |
          wxChildFocusEvent:wxChildFocus() |
          wxClipboardTextEvent:wxClipboardText() |
          wxCloseEvent:wxClose() |
          wxColourPickerEvent:wxColourPicker() |
          wxCommandEvent:wxCommand() |
          wxContextMenuEvent:wxContextMenu() |
          wxDateEvent:wxDate() |
          wxDisplayChangedEvent:wxDisplayChanged() |
          wxDropFilesEvent:wxDropFiles() |
          wxEraseEvent:wxErase() |
          wxFileDirPickerEvent:wxFileDirPicker() |
          wxFocusEvent:wxFocus() |
          wxFontPickerEvent:wxFontPicker() |
          wxGridEvent:wxGrid() |
          wxHelpEvent:wxHelp() |
          wxHtmlLinkEvent:wxHtmlLink() |
          wxIconizeEvent:wxIconize() |
          wxIdleEvent:wxIdle() |
          wxInitDialogEvent:wxInitDialog() |
          wxJoystickEvent:wxJoystick() |
          wxKeyEvent:wxKey() |
          wxListEvent:wxList() |
          wxMaximizeEvent:wxMaximize() |
          wxMenuEvent:wxMenu() |
          wxMouseCaptureChangedEvent:wxMouseCaptureChanged() |
          wxMouseCaptureLostEvent:wxMouseCaptureLost() |
          wxMouseEvent:wxMouse() |
          wxMoveEvent:wxMove() |
          wxNavigationKeyEvent:wxNavigationKey() |
          wxPaintEvent:wxPaint() |
          wxPaletteChangedEvent:wxPaletteChanged() |
          wxQueryNewPaletteEvent:wxQueryNewPalette() |
          wxSashEvent:wxSash() |
          wxScrollEvent:wxScroll() |
          wxScrollWinEvent:wxScrollWin() |
          wxSetCursorEvent:wxSetCursor() |
          wxShowEvent:wxShow() |
          wxSizeEvent:wxSize() |
          wxSpinEvent:wxSpin() |
          wxSplitterEvent:wxSplitter() |
          wxStyledTextEvent:wxStyledText() |
          wxSysColourChangedEvent:wxSysColourChanged() |
          wxTaskBarIconEvent:wxTaskBarIcon() |
          wxTreeEvent:wxTree() |
          wxUpdateUIEvent:wxUpdateUI() |
          wxWebViewEvent:wxWebView() |
          wxWindowCreateEvent:wxWindowCreate() |
          wxWindowDestroyEvent:wxWindowDestroy().
链接到此类型

request_id()

查看源码 (未导出)
-type request_id() :: term().
链接到此类型

server_ref()

查看源码 (未导出)
-type server_ref() :: Obj :: wx:wx_object() | atom() | pid().

回调

链接到此回调

code_change(OldVsn, State, Extra)

查看源码 (可选)
-callback code_change(OldVsn :: term() | {down, term()}, State :: term(), Extra :: term()) ->
                         {ok, NewState :: term()} | {error, Reason :: term()}.
链接到此回调

handle_call(Request, From, State)

查看源码 (可选)
-callback handle_call(Request :: term(), From :: {pid(), Tag :: term()}, State :: term()) ->
                         {reply, Reply :: term(), NewState :: term()} |
                         {reply, Reply :: term(), NewState :: term(), timeout() | hibernate} |
                         {noreply, NewState :: term()} |
                         {noreply, NewState :: term(), timeout() | hibernate} |
                         {stop, Reason :: term(), Reply :: term(), NewState :: term()} |
                         {stop, Reason :: term(), NewState :: term()}.
链接到此回调

handle_cast(Request, State)

查看源码 (可选)
-callback handle_cast(Request :: term(), State :: term()) ->
                         {noreply, NewState :: term()} |
                         {noreply, NewState :: term(), timeout() | hibernate} |
                         {stop, Reason :: term(), NewState :: term()}.
链接到此回调

handle_event(Request, State)

查看源码
-callback handle_event(Request ::
                           #wx{id :: integer(), obj :: wx:wx_object(), userData :: term(), event :: event()},
                       State :: term()) ->
                          {noreply, NewState :: term()} |
                          {noreply, NewState :: term(), timeout() | hibernate} |
                          {stop, Reason :: term(), NewState :: term()}.
链接到此回调

handle_info(Info, State)

查看源码 (可选)
-callback handle_info(Info :: timeout() | term(), State :: term()) ->
                         {noreply, NewState :: term()} |
                         {noreply, NewState :: term(), timeout() | hibernate} |
                         {stop, Reason :: term(), NewState :: term()}.
链接到此回调

handle_sync_event(Request, Ref, State)

查看源码 (可选)
-callback handle_sync_event(Request ::
                                #wx{id :: integer(),
                                    obj :: wx:wx_object(),
                                    userData :: term(),
                                    event :: event()},
                            Ref :: #wx_ref{ref :: term(), type :: term(), state :: term()},
                            State :: term()) ->
                               ok.
-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)

查看源码 (可选)
-callback terminate(Reason :: normal | shutdown | {shutdown, term()} | term(), State :: term()) -> term().

函数

-spec call(Obj, Request) -> term() when Obj :: wx:wx_object() | atom() | pid(), Request :: term().

向 wx_object 服务器发起调用。该调用会等待直到获得结果。在服务器中调用 handle_call(Request, From, State)

链接到此函数

call(Obj, Request, Timeout)

查看源码
-spec call(Obj, Request, Timeout) -> term()
              when Obj :: wx:wx_object() | atom() | pid(), Request :: term(), Timeout :: integer().

向带有超时的 wx_object 服务器发起调用。在服务器中调用 handle_call(Request, From, State)

-spec cast(Obj, Request) -> ok when Obj :: wx:wx_object() | atom() | pid(), Request :: term().

向 wx_object 服务器发起投射。在服务器中调用 handle_cast(Request, State)

链接到此函数

check_response(Msg, Key)

查看源码
-spec check_response(Msg :: term(), Key :: request_id()) ->
                        {reply, Reply :: term()} | false | {error, {term(), server_ref()}}.

检查接收到的消息是否是对 RequestId 的回复

-spec get_pid(Obj) -> pid() when Obj :: wx:wx_object() | atom() | pid().

获取对象句柄的 pid。

链接到此函数

reply(PidTag, Reply)

查看源码
-spec reply({pid(), Tag :: term()}, Reply :: term()) -> pid().

获取对象句柄的 pid。

链接到此函数

send_request(Obj, Request)

查看源码
-spec send_request(Obj, Request :: term()) -> request_id() when Obj :: wx:wx_object() | atom() | pid().

向通用服务器发起 send_request,并返回一个 RequestId,该 RequestId 可以/应该与 wait_response/[1|2] 一起使用。在服务器中调用 handle_call(Request, From, State)。

-spec set_pid(Obj, Pid :: pid()) -> wx:wx_object() when Obj :: wx:wx_object() | atom() | pid().

设置对象句柄的控制进程。

链接到此函数

start(Name, Mod, Args, Options)

查看源码
-spec start(Name, Mod, Args, Options) -> wxWindow:wxWindow() | {error, term()}
               when
                   Name :: {local, atom()},
                   Mod :: atom(),
                   Args :: term(),
                   Flag :: trace | log | {logfile, string()} | statistics | debug,
                   Options :: [{timeout, timeout()} | {debug, [Flag]}].

启动一个通用的 wx_object 服务器,并在新进程中调用 Mod:init(Args)。

链接到此函数

start_link(Mod, Args, Options)

查看源码
-spec start_link(Mod, Args, Options) -> wxWindow:wxWindow() | {error, term()}
                    when
                        Mod :: atom(),
                        Args :: term(),
                        Flag :: trace | log | {logfile, string()} | statistics | debug,
                        Options :: [{timeout, timeout()} | {debug, [Flag]}].

启动一个通用的 wx_object 服务器,并在新进程中调用 Mod:init(Args)。

链接到此函数

start_link(Name, Mod, Args, Options)

查看源码
-spec start_link(Name, Mod, Args, Options) -> wxWindow:wxWindow() | {error, term()}
                    when
                        Name :: {local, atom()},
                        Mod :: atom(),
                        Args :: term(),
                        Flag :: trace | log | {logfile, string()} | statistics | debug,
                        Options :: [{timeout, timeout()} | {debug, [Flag]}].

启动一个通用的 wx_object 服务器,并在新进程中调用 Mod:init(Args)。

-spec stop(Obj) -> ok when Obj :: wx:wx_object() | atom() | pid().

停止一个通用的 wx_object 服务器,原因设置为 'normal'。在服务器中调用 terminate(Reason,State)。该调用会等待直到进程终止。如果进程不存在,则会引发异常。

链接到此函数

stop(Obj, Reason, Timeout)

查看源码
-spec stop(Obj, Reason, Timeout) -> ok
              when Obj :: wx:wx_object() | atom() | pid(), Reason :: term(), Timeout :: timeout().

使用给定的 Reason 停止一个通用的 wx_object 服务器。在服务器中调用 terminate(Reason,State)。该调用会等待直到进程终止。如果调用超时,或者进程不存在,则会引发异常。

链接到此函数

wait_response(RequestId)

查看源码
-spec wait_response(RequestId :: request_id()) ->
                       {reply, Reply :: term()} | {error, {term(), server_ref()}}.

无限期地等待来自通用服务器的回复。

链接到此函数

wait_response(Key, Timeout)

查看源码
-spec wait_response(Key :: request_id(), Timeout :: timeout()) ->
                       {reply, Reply :: term()} | timeout | {error, {term(), server_ref()}}.

等待 'timeout' 时间,以接收来自通用服务器的回复。