Struct winsafe::gui::events::WindowEvents

pub struct WindowEvents(_);

Exposes window messages.

You cannot directly instantiate this object, it is created internally by the window.

Implementations

impl WindowEvents

pub fn wm<F>(&self, ident: WM, func: F) where
    F: Fn(WndMsg) -> BoxResult<isize> + 'static, 

Event to any window message.

Note: Instead of using this event, you should always prefer the specific events, which will give you the correct message parameters. This generic method should be used when you have a custom, non-standard window message.

Examples

Handling a custom, user-defined message:

use winsafe::{co, gui, msg, BoxResult};

let wnd: gui::WindowMain; // initialized somewhere

let CUSTOM_MSG = co::WM::from(0x1234);

wnd.on().wm(CUSTOM_MSG, {
    let wnd = wnd.clone(); // pass into the closure
    move |p: msg::WndMsg| -> BoxResult<isize> {
        println!("HWND: {}, msg ID: {}", wnd.hwnd(), p.msg_id);
        Ok(0)
    }
});

pub fn wm_timer<F>(&self, timer_id: u32, func: F) where
    F: Fn() -> BoxResult<()> + 'static, 

WM_TIMER message, narrowed to a specific timer ID.

Posted to the installing thread’s message queue when a timer expires.

pub fn wm_command<F>(&self, code: CMD, ctrl_id: u16, func: F) where
    F: Fn() -> BoxResult<()> + 'static, 

WM_COMMAND message, for specific code and control ID.

A command notification must be narrowed by the command code and the control ID, so the closure will be fired for that specific control at that specific event.

Note: Instead of using this event, you should always prefer the specific command notifications, which will give you the correct message parameters. This generic method should be used when you have a custom, non-standard window notification.

pub fn wm_command_accel_menu<F>(&self, ctrl_id: u16, func: F) where
    F: Fn() -> BoxResult<()> + 'static, 

WM_COMMAND message, handling both CMD::Accelerator and CMD::Menu, for a specific command ID.

Ideal to be used with menu commands whose IDs are shared with accelerators.

Examples

Closing the window on ESC key:

use winsafe::{co, gui, msg, BoxResult};

let wnd: gui::WindowMain; // initialized somewhere

wnd.on().wm_command_accel_menu(co::DLGID::CANCEL.into(), {
    let wnd = wnd.clone(); // pass into the closure
    move || -> BoxResult<()> {
        wnd.hwnd().SendMessage(msg::wm::Close {});
        Ok(())
    }
});

pub fn wm_notify<F>(&self, id_from: i32, code: NM, func: F) where
    F: Fn(Notify<'_>) -> BoxResult<isize> + 'static, 

WM_NOTIFY message, for specific ID and notification code.

A notification must be narrowed by the notification code and the control ID, so the closure will be fired for that specific control at the specific event.

Note: Instead of using this event, you should always prefer the specific notifications, which will give you the correct notification struct. This generic method should be used when you have a custom, non-standard window notification.

pub fn wm_activate<F>(&self, func: F) where
    F: Fn(Activate) -> BoxResult<()> + 'static, 

WM_ACTIVATE message.

Sent to both the window being activated and the window being deactivated. If the windows use the same input queue, the message is sent synchronously, first to the window procedure of the top-level window being deactivated, then to the window procedure of the top-level window being activated. If the windows use different input queues, the message is sent asynchronously, so the window is activated immediately.

Default handling

If you handle this event, you’ll overwrite the default handling in:

• non-dialog WindowMain.

pub fn wm_activate_app<F>(&self, func: F) where
    F: Fn(ActivateApp) -> BoxResult<()> + 'static, 

WM_ACTIVATEAPP message.

Sent when a window belonging to a different application than the active window is about to be activated. The message is sent to the application whose window is being activated and to the application whose window is being deactivated.

pub fn wm_app_command<F>(&self, func: F) where
    F: Fn(AppCommand) -> BoxResult<()> + 'static, 

WM_APPCOMMAND message.

Notifies a window that the user generated an application command event, for example, by clicking an application command button using the mouse or typing an application command key on the keyboard.

pub fn wm_cancel_mode<F>(&self, func: F) where
    F: Fn() -> BoxResult<()> + 'static, 

WM_CANCELMODE message.

Sent to cancel certain modes, such as mouse capture. For example, the system sends this message to the active window when a dialog box or message box is displayed. Certain functions also send this message explicitly to the specified window regardless of whether it is the active window. For example, the HWND::EnableWindow function sends this message when disabling the specified window.

pub fn wm_capture_changed<F>(&self, func: F) where
    F: Fn(CaptureChanged) -> BoxResult<()> + 'static, 

WM_CAPTURECHANGED message.

Sent to the window that is losing the mouse capture.

pub fn wm_char<F>(&self, func: F) where
    F: Fn(Char) -> BoxResult<()> + 'static, 

WM_CHAR message.

Posted to the window with the keyboard focus when a WM_KEYDOWN message is translated by the TranslateMessage function. The WM_CHAR message contains the character code of the key that was pressed.

pub fn wm_child_activate<F>(&self, func: F) where
    F: Fn() -> BoxResult<()> + 'static, 

WM_CHILDACTIVATE message.

Sent to a child window when the user clicks the window’s title bar or when the window is activated, moved, or sized.

pub fn wm_close<F>(&self, func: F) where
    F: Fn() -> BoxResult<()> + 'static, 

WM_CLOSE message.

Sent as a signal that a window or an application should terminate.

Default handling

If you handle this event, you’ll overwrite the default handling in:

• dialog WindowMain;
• dialog WindowModal;
• non-dialog WindowModal.

pub fn wm_context_menu<F>(&self, func: F) where
    F: Fn() -> BoxResult<()> + 'static, 

WM_CONTEXTMENU message.

Notifies a window that the user desires a context menu to appear. The user may have clicked the right mouse button (right-clicked) in the window, pressed Shift+F10 or pressed the applications key (context menu key) available on some keyboards.

pub fn wm_create<F>(&self, func: F) where
    F: Fn(Create<'_, '_, '_>) -> BoxResult<i32> + 'static, 

WM_CREATE message, sent only to non-dialog windows. Dialog windows receive WM_INITDIALOG instead.

Sent when an application requests that a window be created by calling the HWND::CreateWindowEx function. The message is sent before the function returns. The window procedure of the new window receives this message after the window is created, but before the window becomes visible.

Examples

use winsafe::{gui, msg, BoxResult};

let wnd: gui::WindowMain; // initialized somewhere

wnd.on().wm_create({
    let wnd = wnd.clone(); // pass into the closure
    move |p: msg::wm::Create| -> BoxResult<i32> {
        println!("HWND: {}, client area: {}x{}",
            wnd.hwnd(),
            p.createstruct.cx,
            p.createstruct.cy,
        );
        Ok(0)
    }
});

pub fn wm_ctl_color_btn<F>(&self, func: F) where
    F: Fn(CtlColorBtn) -> BoxResult<HBRUSH> + 'static, 

WM_CTLCOLORBTN message.

Sent to the parent window of a button before drawing the button. The parent window can change the button’s text and background colors. However, only owner-drawn buttons respond to the parent window processing this message.

pub fn wm_ctl_color_dlg<F>(&self, func: F) where
    F: Fn(CtlColorDlg) -> BoxResult<HBRUSH> + 'static, 

WM_CTLCOLORDLG message.

Sent to a dialog box before the system draws the dialog box. By responding to this message, the dialog box can set its text and background colors using the specified display device context handle.

pub fn wm_ctl_color_edit<F>(&self, func: F) where
    F: Fn(CtlColorEdit) -> BoxResult<HBRUSH> + 'static, 

WM_CTLCOLOREDIT message.

An edit control that is not read-only or disabled sends the message to its parent window when the control is about to be drawn. By responding to this message, the parent window can use the specified device context handle to set the text and background colors of the edit control.

pub fn wm_ctl_color_list_box<F>(&self, func: F) where
    F: Fn(CtlColorListBox) -> BoxResult<HBRUSH> + 'static, 

WM_CTLCOLORLISTBOX message.

Sent to the parent window of a list box before the system draws the list box. By responding to this message, the parent window can set the text and background colors of the list box by using the specified display device context handle.

pub fn wm_ctl_color_scroll_bar<F>(&self, func: F) where
    F: Fn(CtlColorScrollBar) -> BoxResult<HBRUSH> + 'static, 

WM_CTLCOLORSCROLLBAR message.

Sent to the parent window of a scroll bar control when the control is about to be drawn. By responding to this message, the parent window can use the display context handle to set the background color of the scroll bar control.

pub fn wm_ctl_color_static<F>(&self, func: F) where
    F: Fn(CtlColorStatic) -> BoxResult<HBRUSH> + 'static, 

WM_CTLCOLORSTATIC message.

A static control, or an edit control that is read-only or disabled, sends the message to its parent window when the control is about to be drawn. By responding to this message, the parent window can use the specified device context handle to set the text foreground and background colors of the static control.

pub fn wm_dead_char<F>(&self, func: F) where
    F: Fn(DeadChar) -> BoxResult<()> + 'static, 

WM_DEADCHAR message.

Posted to the window with the keyboard focus when a WM_KEYUP message is translated by the TranslateMessage function. WM_DEADCHAR specifies a character code generated by a dead key. A dead key is a key that generates a character, such as the umlaut (double-dot), that is combined with another character to form a composite character. For example, the umlaut-O character (Ö) is generated by typing the dead key for the umlaut character, and then typing the O key.

pub fn wm_delete_item<F>(&self, func: F) where
    F: Fn(DeleteItem<'_>) -> BoxResult<bool> + 'static, 

WM_DELETEITEM message.

Sent to the owner of a list box or combo box when the list box or combo box is destroyed or when items are removed.

pub fn wm_destroy<F>(&self, func: F) where
    F: Fn() -> BoxResult<()> + 'static, 

WM_DESTROY message.

Sent when a window is being destroyed. It is sent to the window procedure of the window being destroyed after the window is removed from the screen.

This message is sent first to the window being destroyed and then to the child windows (if any) as they are destroyed. During the processing of the message, it can be assumed that all child windows still exist.

Examples

use winsafe::{gui, BoxResult};

let wnd: gui::WindowMain; // initialized somewhere

wnd.on().wm_destroy(|| -> BoxResult<()> {
    println!("Window is gone, goodbye!");
    Ok(())
});

pub fn wm_display_change<F>(&self, func: F) where
    F: Fn(DisplayChange) -> BoxResult<()> + 'static, 

WM_DISPLAYCHANGE message.

Sent to all windows when the display resolution has changed.

pub fn wm_drop_files<F>(&self, func: F) where
    F: Fn(DropFiles) -> BoxResult<()> + 'static, 

WM_DROPFILES message.

Sent when the user drops a file on the window of an application that has registered itself as a recipient of dropped files.

Examples

use winsafe::{gui, msg, BoxResult};

let wnd: gui::WindowMain; // initialized somewhere

wnd.on().wm_drop_files(|p: msg::wm::DropFiles| -> BoxResult<()> {
    for dropped_file in p.hdrop.DragQueryFiles()?.iter() {
        println!("Dropped: {}", dropped_file);
    }
    Ok(())
});

pub fn wm_enable<F>(&self, func: F) where
    F: Fn(Enable) -> BoxResult<()> + 'static, 

WM_ENABLE message.

Sent when an application changes the enabled state of a window. It is sent to the window whose enabled state is changing. This message is sent before the HWND::EnableWindow function returns, but after the enabled state (WS::DISABLED style bit) of the window has changed.

pub fn wm_end_session<F>(&self, func: F) where
    F: Fn(EndSession) -> BoxResult<()> + 'static, 

WM_ENDSESSION message.

Sent to an application after the system processes the results of the WM_QUERYENDSESSION message. The WM_ENDSESSION message informs the application whether the session is ending.

pub fn wm_enter_idle<F>(&self, func: F) where
    F: Fn(EnterIdle) -> BoxResult<()> + 'static, 

WM_ENTERIDLE message.

Sent to the owner window of a modal dialog box or menu that is entering an idle state. A modal dialog box or menu enters an idle state when no messages are waiting in its queue after it has processed one or more previous messages.

pub fn wm_enter_menu_loop<F>(&self, func: F) where
    F: Fn(EnterMenuLoop) -> BoxResult<()> + 'static, 

WM_ENTERMENULOOP message.

Notifies an application’s main window procedure that a menu modal loop has been entered.

pub fn wm_enter_size_move<F>(&self, func: F) where
    F: Fn(EnterSizeMove) -> BoxResult<()> + 'static, 

WM_ENTERSIZEMOVE message.

Sent one time to a window after it enters the moving or sizing modal loop. The window enters the moving or sizing modal loop when the user clicks the window’s title bar or sizing border, or when the window passes the WM_SYSCOMMAND message to the DefWindowProc function and the wParam parameter of the message specifies the SC_MOVE or SC_SIZE value. The operation is complete when DefWindowProc returns.

The system sends the message regardless of whether the dragging of full windows is enabled.

pub fn wm_erase_bkgnd<F>(&self, func: F) where
    F: Fn(EraseBkgnd) -> BoxResult<i32> + 'static, 

WM_ERASEBKGND message.

Sent when the window background must be erased (for example, when a window is resized). The message is sent to prepare an invalidated portion of a window for painting.

pub fn wm_exit_menu_loop<F>(&self, func: F) where
    F: Fn(ExitMenuLoop) -> BoxResult<()> + 'static, 

WM_EXITMENULOOP message.

Notifies an application’s main window procedure that a menu modal loop has been exited.

pub fn wm_exit_size_move<F>(&self, func: F) where
    F: Fn() -> BoxResult<()> + 'static, 

WM_EXITSIZEMOVE message.

Sent one time to a window, after it has exited the moving or sizing modal loop. The window enters the moving or sizing modal loop when the user clicks the window’s title bar or sizing border, or when the window passes the WM_SYSCOMMAND message to the DefWindowProc function and the wParam parameter of the message specifies the SC_MOVE or SC_SIZE value. The operation is complete when DefWindowProc returns.

pub fn wm_get_dlg_code<F>(&self, func: F) where
    F: Fn(GetDlgCode<'_>) -> BoxResult<DLGC> + 'static, 

WM_GETDLGCODE message.

By default, the system handles all keyboard input to the control; the system interprets certain types of keyboard input as dialog box navigation keys. To override this default behavior, the control can respond to the WM_GETDLGCODE message to indicate the types of input it wants to process itself.

pub fn wm_get_font<F>(&self, func: F) where
    F: Fn() -> BoxResult<Option<HFONT>> + 'static, 

WM_GETFONT message.

Retrieves the font with which the control is currently drawing its text.

pub fn wm_get_hmenu<F>(&self, func: F) where
    F: Fn() -> BoxResult<Option<HMENU>> + 'static, 

MN_GETHMENU message.

Retrieves the menu handle for the current window.

pub fn wm_get_min_max_info<F>(&self, func: F) where
    F: Fn(GetMinMaxInfo<'_>) -> BoxResult<()> + 'static, 

WM_GETMINMAXINFO message.

Sent to a window when the size or position of the window is about to change. An application can use this message to override the window’s default maximized size and position, or its default minimum or maximum tracking size.

pub fn wm_get_title_bar_info_ex<F>(&self, func: F) where
    F: Fn(GetTitleBarInfoEx<'_>) -> BoxResult<()> + 'static, 

WM_GETTITLEBARINFOEX message.

Sent to request extended title bar information.

pub fn wm_help<F>(&self, func: F) where
    F: Fn(Help<'_>) -> BoxResult<()> + 'static, 

WM_HELP message.

Indicates that the user pressed the F1 key.

pub fn wm_h_scroll<F>(&self, func: F) where
    F: Fn(HScroll) -> BoxResult<()> + 'static, 

WM_HSCROLL message.

The WM_HSCROLL message is sent to a window when a scroll event occurs in the window’s standard horizontal scroll bar. This message is also sent to the owner of a horizontal scroll bar control when a scroll event occurs in the control.

pub fn wm_init_dialog<F>(&self, func: F) where
    F: Fn(InitDialog) -> BoxResult<bool> + 'static, 

WM_INITDIALOG message, sent only to dialog windows. Non-dialog windows receive WM_CREATE instead.

Sent to the dialog box procedure immediately before a dialog box is displayed. Dialog box procedures typically use this message to initialize controls and carry out any other initialization tasks that affect the appearance of the dialog box.

Examples

use winsafe::{gui, msg, BoxResult};

let wnd: gui::WindowMain; // initialized somewhere

wnd.on().wm_init_dialog({
    let wnd = wnd.clone(); // pass into the closure
    move |p: msg::wm::InitDialog| -> BoxResult<bool> {
        println!("Focused HWND: {}", p.hwnd_focus);
        Ok(true)
    }
});

pub fn wm_init_menu_popup<F>(&self, func: F) where
    F: Fn(InitMenuPopup) -> BoxResult<()> + 'static, 

WM_INITMENUPOPUP message.

Sent when a drop-down menu or submenu is about to become active. This allows an application to modify the menu before it is displayed, without changing the entire menu.

pub fn wm_key_down<F>(&self, func: F) where
    F: Fn(KeyDown) -> BoxResult<()> + 'static, 

WM_KEYDOWN message.

Posted to the window with the keyboard focus when a nonsystem key is pressed. A nonsystem key is a key that is pressed when the ALT key is not pressed.

pub fn wm_key_up<F>(&self, func: F) where
    F: Fn(KeyUp) -> BoxResult<()> + 'static, 

WM_KEYUP message.

Posted to the window with the keyboard focus when a nonsystem key is released. A nonsystem key is a key that is pressed when the ALT key is not pressed, or a keyboard key that is pressed when a window has the keyboard focus.

pub fn wm_kill_focus<F>(&self, func: F) where
    F: Fn(KillFocus) -> BoxResult<()> + 'static, 

WM_KILLFOCUS message.

Sent to a window immediately before it loses the keyboard focus.

pub fn wm_l_button_dbl_clk<F>(&self, func: F) where
    F: Fn(LButtonDblClk) -> BoxResult<()> + 'static, 

WM_LBUTTONDBLCLK message.

Posted when the user double-clicks the left mouse button while the cursor is in the client area of a window. If the mouse is not captured, the message is posted to the window beneath the cursor. Otherwise, the message is posted to the window that has captured the mouse.

pub fn wm_l_button_down<F>(&self, func: F) where
    F: Fn(LButtonDown) -> BoxResult<()> + 'static, 

WM_LBUTTONDOWN message.

Posted when the user presses the left mouse button while the cursor is in the client area of a window. If the mouse is not captured, the message is posted to the window beneath the cursor. Otherwise, the message is posted to the window that has captured the mouse.

Examples

use winsafe::{gui, msg, BoxResult};

let wnd: gui::WindowMain; // initialized somewhere

wnd.on().wm_l_button_down({
    let wnd = wnd.clone(); // pass into the closure
    move |p: msg::wm::LButtonDown| -> BoxResult<()> {
        println!("Point: {}x{}", p.coords.x, p.coords.y);
        Ok(())
    }
});

pub fn wm_l_button_up<F>(&self, func: F) where
    F: Fn(LButtonUp) -> BoxResult<()> + 'static, 

WM_LBUTTONUP message.

Posted when the user releases the left mouse button while the cursor is in the client area of a window. If the mouse is not captured, the message is posted to the window beneath the cursor. Otherwise, the message is posted to the window that has captured the mouse.

pub fn wm_m_button_dbl_clk<F>(&self, func: F) where
    F: Fn(MButtonDblClk) -> BoxResult<()> + 'static, 

WM_MBUTTONDBLCLK message.

Posted when the user double-clicks the middle mouse button while the cursor is in the client area of a window. If the mouse is not captured, the message is posted to the window beneath the cursor. Otherwise, the message is posted to the window that has captured the mouse.

pub fn wm_m_button_down<F>(&self, func: F) where
    F: Fn(MButtonDown) -> BoxResult<()> + 'static, 

WM_MBUTTONDOWN message.

Posted when the user presses the middle mouse button while the cursor is in the client area of a window. If the mouse is not captured, the message is posted to the window beneath the cursor. Otherwise, the message is posted to the window that has captured the mouse.

pub fn wm_m_button_up<F>(&self, func: F) where
    F: Fn(MButtonUp) -> BoxResult<()> + 'static, 

WM_MBUTTONUP message.

Posted when the user releases the middle mouse button while the cursor is in the client area of a window. If the mouse is not captured, the message is posted to the window beneath the cursor. Otherwise, the message is posted to the window that has captured the mouse.

pub fn wm_menu_command<F>(&self, func: F) where
    F: Fn(MenuCommand) -> BoxResult<()> + 'static, 

WM_MENUCOMMAND message.

Sent when the user makes a selection from a menu.

pub fn wm_menu_drag<F>(&self, func: F) where
    F: Fn(MenuDrag) -> BoxResult<MND> + 'static, 

WM_MENUDRAG message.

Sent to the owner of a drag-and-drop menu when the user drags a menu item.

pub fn wm_menu_r_button_up<F>(&self, func: F) where
    F: Fn(MenuRButtonUp) -> BoxResult<()> + 'static, 

WM_MENURBUTTONUP message.

Sent when the user releases the right mouse button while the cursor is on a menu item.

pub fn wm_mouse_hover<F>(&self, func: F) where
    F: Fn(MouseHover) -> BoxResult<()> + 'static, 

WM_MOUSEHOVER message.

Posted to a window when the cursor hovers over the client area of the window for the period of time specified in a prior call to TrackMouseEvent.

pub fn wm_mouse_leave<F>(&self, func: F) where
    F: Fn() -> BoxResult<()> + 'static, 

WM_MOUSELEAVE message.

Posted to a window when the cursor leaves the client area of the window specified in a prior call to TrackMouseEvent.

pub fn wm_mouse_move<F>(&self, func: F) where
    F: Fn(MouseMove) -> BoxResult<()> + 'static, 

WM_MOUSEMOVE message.

Posted to a window when the cursor moves. If the mouse is not captured, the message is posted to the window that contains the cursor. Otherwise, the message is posted to the window that has captured the mouse.

pub fn wm_move<F>(&self, func: F) where
    F: Fn(Move) -> BoxResult<()> + 'static, 

WM_MOVE message.

Sent after a window has been moved.

pub fn wm_moving<F>(&self, func: F) where
    F: Fn(Moving<'_>) -> BoxResult<()> + 'static, 

WM_MOVING message.

Sent to a window that the user is moving. By processing this message, an application can monitor the position of the drag rectangle and, if needed, change its position.

pub fn wm_nc_calc_size<F>(&self, func: F) where
    F: Fn(NcCalcSize<'_, '_>) -> BoxResult<WVR> + 'static, 

WM_NCCALCSIZE message.

Sent when the size and position of a window’s client area must be calculated. By processing this message, an application can control the content of the window’s client area when the size or position of the window changes.

pub fn wm_nc_create<F>(&self, func: F) where
    F: Fn(NcCreate<'_, '_, '_>) -> BoxResult<bool> + 'static, 

WM_NCCREATE message.

Sent prior to the WM_CREATE message when a window is first created.

pub fn wm_nc_destroy<F>(&self, func: F) where
    F: Fn() -> BoxResult<()> + 'static, 

WM_NCDESTROY message.

Notifies a window that its nonclient area is being destroyed. The HWND::DestroyWindow function sends the message to the window following the WM_DESTROY message. WM_DESTROY is used to free the allocated memory object associated with the window.

The WM_NCDESTROY message is sent after the child windows have been destroyed. In contrast, WM_DESTROY is sent before the child windows are destroyed.

Default handling

If you handle this event, you’ll overwrite the default handling in:

• non-dialog WindowMain;
• dialog WindowMain.

pub fn wm_nc_hit_test<F>(&self, func: F) where
    F: Fn(NcHitTest) -> BoxResult<HT> + 'static, 

WM_NCHITTEST message.

Sent to a window in order to determine what part of the window corresponds to a particular screen coordinate. This can happen, for example, when the cursor moves, when a mouse button is pressed or released, or in response to a call to a function such as HWND::WindowFromPoint. If the mouse is not captured, the message is sent to the window beneath the cursor. Otherwise, the message is sent to the window that has captured the mouse.

pub fn wm_nc_paint<F>(&self, func: F) where
    F: Fn(NcPaint) -> BoxResult<()> + 'static, 

WM_NCPAINT message.

Sent to a window when its frame must be painted.

Default handling

If you handle this event, you’ll overwrite the default handling in:

• non-dialog WindowControl;
• dialog WindowControl.

pub fn wm_next_dlg_ctl<F>(&self, func: F) where
    F: Fn(NextDlgCtl) -> BoxResult<()> + 'static, 

WM_NEXTDLGCTL message.

Sent to a dialog box procedure to set the keyboard focus to a different control in the dialog box.

pub fn wm_null<F>(&self, func: F) where
    F: Fn() -> BoxResult<()> + 'static, 

WM_NULL message.

Performs no operation. An application sends the message if it wants to post a message that the recipient window will ignore.

pub fn wm_paint<F>(&self, func: F) where
    F: Fn() -> BoxResult<()> + 'static, 

WM_PAINT message.

Sent when the system or another application makes a request to paint a portion of an application’s window. The message is sent when the HWND::UpdateWindow or HWND::RedrawWindow function is called, or by the DispatchMessage function when the application obtains a WM_PAINT message by using the GetMessage or PeekMessage function.

pub fn wm_parent_notify<F>(&self, func: F) where
    F: Fn(ParentNotify) -> BoxResult<()> + 'static, 

WM_PARENTNOTIFY message.

Sent to a window when a significant action occurs on a descendant window.

pub fn wm_query_open<F>(&self, func: F) where
    F: Fn() -> BoxResult<bool> + 'static, 

WM_QUERYOPEN message.

Sent to an icon when the user requests that the window be restored to its previous size and position.

pub fn wm_r_button_dbl_clk<F>(&self, func: F) where
    F: Fn(RButtonDblClk) -> BoxResult<()> + 'static, 

WM_RBUTTONDBLCLK message.

Posted when the user double-clicks the right mouse button while the cursor is in the client area of a window. If the mouse is not captured, the message is posted to the window beneath the cursor. Otherwise, the message is posted to the window that has captured the mouse.

pub fn wm_r_button_down<F>(&self, func: F) where
    F: Fn(RButtonDown) -> BoxResult<()> + 'static, 

WM_RBUTTONDOWN message.

Posted when the user presses the right mouse button while the cursor is in the client area of a window. If the mouse is not captured, the message is posted to the window beneath the cursor. Otherwise, the message is posted to the window that has captured the mouse.

pub fn wm_r_button_up<F>(&self, func: F) where
    F: Fn(RButtonUp) -> BoxResult<()> + 'static, 

WM_RBUTTONUP message.

Posted when the user releases the right mouse button while the cursor is in the client area of a window. If the mouse is not captured, the message is posted to the window beneath the cursor. Otherwise, the message is posted to the window that has captured the mouse.

pub fn wm_set_cursor<F>(&self, func: F) where
    F: Fn(SetCursor) -> BoxResult<bool> + 'static, 

WM_SETCURSOR message.

Sent to a window if the mouse causes the cursor to move within a window and mouse input is not captured.

pub fn wm_set_focus<F>(&self, func: F) where
    F: Fn(SetFocus) -> BoxResult<()> + 'static, 

WM_SETFOCUS message.

Sent to a window after it has gained the keyboard focus.

Default handling

If you handle this event, you’ll overwrite the default handling in:

• non-dialog WindowMain;
• non-dialog WindowModal.

pub fn wm_set_font<F>(&self, func: F) where
    F: Fn(SetFont) -> BoxResult<()> + 'static, 

WM_SETFONT message.

Sets the font that a control is to use when drawing text.

pub fn wm_set_icon<F>(&self, func: F) where
    F: Fn(SetIcon) -> BoxResult<Option<HICON>> + 'static, 

WM_SETICON message.

Associates a new large or small icon with a window. The system displays the large icon in the Alt+TAB dialog box, and the small icon in the window caption.

pub fn wm_set_redraw<F>(&self, func: F) where
    F: Fn(SetRedraw) -> BoxResult<()> + 'static, 

WM_SETRDRAW message.

Sent to a window to allow changes in that window to be redrawn, or to prevent changes in that window from being redrawn.

pub fn wm_show_window<F>(&self, func: F) where
    F: Fn(ShowWindow) -> BoxResult<()> + 'static, 

WM_SHOWWINDOW message.

Sent to a window when the window is about to be hidden or shown.

pub fn wm_size<F>(&self, func: F) where
    F: Fn(Size) -> BoxResult<()> + 'static, 

WM_SIZE message.

Sent to a window after its size has changed.

Examples

use winsafe::{gui, msg, BoxResult};

let wnd: gui::WindowMain; // initialized somewhere

wnd.on().wm_size({
    let wnd = wnd.clone(); // pass into the closure
    move |p: msg::wm::Size| -> BoxResult<()> {
        println!("HWND: {}, client area: {}x{}",
            wnd.hwnd(),
            p.width,
            p.height,
        );
        Ok(())
    }
});

pub fn wm_sizing<F>(&self, func: F) where
    F: Fn(Sizing<'_>) -> BoxResult<()> + 'static, 

WM_SIZING message.

Sent to a window that the user is resizing. By processing this message, an application can monitor the size and position of the drag rectangle and, if needed, change its size or position.

pub fn wm_style_changed<F>(&self, func: F) where
    F: Fn(StyleChanged<'_>) -> BoxResult<()> + 'static, 

WM_STYLECHANGED message.

Sent to a window after the HWND::SetWindowLongPtr function has changed one or more of the window’s styles.

pub fn wm_style_changing<F>(&self, func: F) where
    F: Fn(StyleChanging<'_>) -> BoxResult<()> + 'static, 

WM_STYLECHANGING message.

Sent to a window when the HWND::SetWindowLongPtr function is about to change one or more of the window’s styles.

pub fn wm_sync_paint<F>(&self, func: F) where
    F: Fn() -> BoxResult<()> + 'static, 

WM_SYNCPAINT message.

Used to synchronize painting while avoiding linking independent GUI threads.

pub fn wm_sys_char<F>(&self, func: F) where
    F: Fn(SysChar) -> BoxResult<()> + 'static, 

WM_SYSCHAR message.

Posted to the window with the keyboard focus when a WM_SYSKEYDOWN message is translated by the TranslateMessage function. It specifies the character code of a system character key that is, a character key that is pressed while the ALT key is down.

pub fn wm_sys_command<F>(&self, func: F) where
    F: Fn(SysCommand) -> BoxResult<()> + 'static, 

WM_SYSCOMMAND message.

A window receives this message when the user chooses a command from the Window menu (formerly known as the system or control menu) or when the user chooses the maximize button, minimize button, restore button, or close button.

pub fn wm_sys_dead_char<F>(&self, func: F) where
    F: Fn(SysDeadChar) -> BoxResult<()> + 'static, 

WM_SYSDEADCHAR message.

Sent to the window with the keyboard focus when a WM_SYSKEYDOWN message is translated by the TranslateMessage function. WM_SYSDEADCHAR specifies the character code of a system dead key that is, a dead key that is pressed while holding down the ALT key.

pub fn wm_sys_key_down<F>(&self, func: F) where
    F: Fn(SysKeyDown) -> BoxResult<()> + 'static, 

WM_SYSKEYDOWN message.

Posted to the window with the keyboard focus when the user presses the F10 key (which activates the menu bar) or holds down the ALT key and then presses another key. It also occurs when no window currently has the keyboard focus; in this case, the WM_SYSKEYDOWN message is sent to the active window. The window that receives the message can distinguish between these two contexts by checking the context code in the lParam parameter.

pub fn wm_sys_key_up<F>(&self, func: F) where
    F: Fn(SysKeyUp) -> BoxResult<()> + 'static, 

WM_SYSKEYUP message.

Posted to the window with the keyboard focus when the user releases a key that was pressed while the ALT key was held down. It also occurs when no window currently has the keyboard focus; in this case, the WM_SYSKEYUP message is sent to the active window. The window that receives the message can distinguish between these two contexts by checking the context code in the lParam parameter.

pub fn wm_theme_changed<F>(&self, func: F) where
    F: Fn() -> BoxResult<()> + 'static, 

WM_THEMECHANGED message.

Broadcast to every window following a theme change event. Examples of theme change events are the activation of a theme, the deactivation of a theme, or a transition from one theme to another.

pub fn wm_uninit_menu_popup<F>(&self, func: F) where
    F: Fn(UninitMenuPopup) -> BoxResult<()> + 'static, 

WM_UNINITMENUPOPUP message.

Sent when a drop-down menu or submenu has been destroyed.

pub fn wm_v_scroll<F>(&self, func: F) where
    F: Fn(VScroll) -> BoxResult<()> + 'static, 

WM_VSCROLL message.

The WM_VSCROLL message is sent to a window when a scroll event occurs in the window’s standard vertical scroll bar. This message is also sent to the owner of a vertical scroll bar control when a scroll event occurs in the control.

pub fn wm_window_pos_changed<F>(&self, func: F) where
    F: Fn(WindowPosChanged<'_>) -> BoxResult<()> + 'static, 

WM_WINDOWPOSCHANGED message.

Sent to a window whose size, position, or place in the Z order has changed as a result of a call to the HWND::SetWindowPos function or another window-management function.

pub fn wm_window_pos_changing<F>(&self, func: F) where
    F: Fn(WindowPosChanging<'_>) -> BoxResult<()> + 'static, 

WM_WINDOWPOSCHANGING message.

Sent to a window whose size, position, or place in the Z order is about to change as a result of a call to the HWND::SetWindowPos function or another window-management function.

pub fn wm_x_button_dbl_clk<F>(&self, func: F) where
    F: Fn(XButtonDblClk) -> BoxResult<()> + 'static, 

WM_XBUTTONDBLCLK message.

Posted when the user double-clicks the first or second X button while the cursor is in the client area of a window. If the mouse is not captured, the message is posted to the window beneath the cursor. Otherwise, the message is posted to the window that has captured the mouse.

pub fn wm_x_button_down<F>(&self, func: F) where
    F: Fn(XButtonDown) -> BoxResult<()> + 'static, 

WM_XBUTTONDOWN message.

Posted when the user presses the first or second X button while the cursor is in the client area of a window. If the mouse is not captured, the message is posted to the window beneath the cursor. Otherwise, the message is posted to the window that has captured the mouse.

pub fn wm_x_button_up<F>(&self, func: F) where
    F: Fn(XButtonUp) -> BoxResult<()> + 'static, 

WM_XBUTTONUP message.

Posted when the user releases the first or second X button while the cursor is in the client area of a window. If the mouse is not captured, the message is posted to the window beneath the cursor. Otherwise, the message is posted to the window that has captured the mouse.