Struct WindowInner 

pub struct WindowInner {
    pub focus_item: RefCell<ItemWeak>,
    pub active_popups: RefCell<Vec<PopupWindow>>,
    /* private fields */
}

Inner datastructure for the crate::api::Window

Fields

focus_item: RefCell<ItemWeak>

ItemRC that currently have the focus (possibly an instance of TextInput)

active_popups: RefCell<Vec<PopupWindow>>

Stack of currently active popups

Implementations

impl WindowInner

pub fn new(window_adapter_weak: Weak<dyn WindowAdapter>) -> Self

Create a new instance of the window, given the window_adapter factory fn

pub fn set_component(&self, component: &ItemTreeRc)

Associates this window with the specified component. Further event handling and rendering, etc. will be done with that component.

pub fn component(&self) -> ItemTreeRc

return the component. Panics if it wasn’t set.

pub fn try_component(&self) -> Option<ItemTreeRc>

returns the component or None if it isn’t set.

pub fn ensure_tree_instantiated(&self)

Walk the component tree and every active popup to materialize every Repeater, Conditional and ComponentContainer. Runs change handlers and the instantiation pass in a loop because init callbacks may set properties that trigger change handlers, and change handlers may make new conditionals/repeaters dirty.

pub fn active_popups(&self) -> Ref<'_, [PopupWindow]>

Returns a slice of the active popups.

pub fn process_mouse_input( &self, event: MouseEvent, ) -> Option<MouseDispatchResult>

Receive a mouse event and pass it to the items of the component to change their state.

Returns None when there is no component to dispatch to; otherwise returns a MouseDispatchResult carrying:

• accepted: whether an item consumed the event, and
• drag_action: for DragMove/Drop events, the negotiated DragAction (or None if no DropArea accepted).

Note: when a drag is in flight, the runtime rewrites a Released into either a Drop (if a DropArea had previously accepted the matching DragMove) or an Exit (if not). The reported accepted reflects the rewritten event, so a Released that completes a drop on a non-accepting target reports accepted = false.

pub fn process_touch_input( &self, id: i32, position: LogicalPoint, phase: TouchPhase, ) -> Option<MouseDispatchResult>

Receive a raw touch event from a backend and either forward it as a mouse event (single finger) or synthesize PinchGesture/RotationGesture events (two fingers), producing the same events as platform gesture recognition.

position must be in logical coordinates (i.e., already divided by the scale factor). Passing physical coordinates will produce incorrect gesture geometry and hit-testing.

drag_action is taken from the last sub-event (including None), because drag_action reflects the current drop-target negotiation, not a per-event verdict to aggregate. For touch sequences that never produce a DragMove/Drop (the common case), this stays None throughout.

pub fn process_key_input( &self, internal_key_event: InternalKeyEvent, ) -> KeyEventResult

Receive a key event and pass it to the items of the component to change their state.

Arguments:

• event: The key event received by the windowing system.

pub fn set_cursor_blink_binding(&self, prop: &Property<bool>)

Installs a binding on the specified property that’s toggled whenever the text cursor is supposed to be visible or not.

pub fn set_focus_item( &self, new_focus_item: &ItemRc, set_focus: bool, reason: FocusReason, )

Sets the focus to the item pointed to by item_ptr. This will remove the focus from any currently focused item. If set_focus is false, the focus is cleared.

pub fn focus_next_item(&self)

Move keyboard focus to the next item

pub fn focus_previous_item(&self)

Move keyboard focus to the previous item.

pub fn set_active(&self, have_focus: bool)

Marks the window to be the active window. This typically coincides with the keyboard focus. One exception though is when a popup is shown, in which case the window may remain active but temporarily loose focus to the popup.

This results in WindowFocusReceived and WindowFocusLost events.

pub fn active(&self) -> bool

Returns true of the window is the active window. That typically implies having the keyboard focus, except when a popup is shown and temporarily takes the focus.

pub fn update_window_properties(&self)

If the component’s root item is a Window element, then this function synchronizes its properties, such as the title for example, with the properties known to the windowing system.

pub fn draw_contents<T>( &self, render_components: impl FnOnce(&[(ItemTreeWeak, LogicalPoint)], &dyn Fn(&mut dyn ItemRenderer)) -> T, ) -> Option<T>

Calls the render_components to render the main component and any sub-window components, tracked by a property dependency tracker.

The closure also receives a post_render callback. The renderer must invoke it once with its ItemRenderer after walking the components but before flushing, so the runtime can draw overlays that sit on top of the scene without being part of any item tree.

Returns None if no component is set yet.

pub fn show(&self) -> Result<(), PlatformError>

Registers the window with the windowing system, in order to render the component’s items and react to input events once the event loop spins.

pub fn hide(&self) -> Result<(), PlatformError>

De-registers the window with the windowing system.

pub fn supports_native_menu_bar(&self) -> bool

Return whether the platform supports native menu bars

pub fn setup_menubar(&self, menubar: VRc<MenuVTable>)

Setup the native menu bar

pub fn setup_menubar_shortcuts(&self, menubar: VRc<MenuVTable>)

Setup the shortcuts for the menubar Note: We still register the same shortcuts if the native menubar is active. Generally, the native menubar should capture the shortcuts first, but in case it doesn’t, the window can still match them manually.

pub fn create_child_window_adapter( &self, kind: WindowKind, ) -> Option<Rc<dyn WindowAdapter>>

Create a new popup window adapter This window adapter can be used on a popup component and shown with show_popup()

pub fn show_popup( &self, popup_componentrc: &ItemTreeRc, popup_access_position: Box<dyn Fn() -> LogicalPosition>, close_policy: PopupClosePolicy, parent_item: &ItemRc, window_kind: WindowKind, is_open_setter: Box<dyn Fn(bool)>, ) -> NonZeroU32

Show a popup at the given position relative to the parent_item and returns its ID. The returned ID will always be non-zero.

is_open_setter keeps the parent component’s PopupWindow::is-open property in sync with this popup: it is invoked immediately with true, and again with false when the popup is closed through any path (the Drop impl of PopupWindow handles the false). Pass a no-op closure for popups (such as menus) that do not expose is-open.

pub fn show_native_popup_menu( &self, context_menu_item: VRc<MenuVTable>, position: LogicalPosition, parent_item: &ItemRc, ) -> bool

Attempt to show a native popup menu

context_menu_item is an instance of a ContextMenu

Returns false if the native platform doesn’t support it

pub fn close_popup(&self, popup_id: NonZeroU32)

Removes the popup matching the given ID.

pub fn close_all_popups(&self)

Close all active popups.

pub fn close_top_popup(&self)

Close the top-most popup.

pub fn scale_factor(&self) -> f32

Returns the scale factor set on the window, as provided by the windowing system.

pub fn set_const_scale_factor(&self, factor: f32)

Sets the scale factor for the window. From that point on, the scale factor is constant and cannot be changed anymore.

pub fn text_input_focused(&self) -> bool

Reads the global property TextInputInterface.text-input-focused

pub fn set_text_input_focused(&self, value: bool)

Sets the global property TextInputInterface.text-input-focused

pub fn is_visible(&self) -> bool

Returns true if the window is visible

pub fn window_item_rc(&self) -> Option<ItemRc>

Returns the window item that is the first item in the component. When Some() is returned, it’s guaranteed to be safe to downcast to WindowItem.

pub fn window_item(&self) -> Option<VRcMapped<ItemTreeVTable, WindowItem>>

Returns the window item that is the first item in the component.

pub fn set_window_item_safe_area(&self, inset: LogicalEdges)

The safe area of the window has changed.

pub fn on_close_requested( &self, callback: impl FnMut() -> CloseRequestResponse + 'static, )

Sets the close_requested callback. The callback will be run when the user tries to close a window.

pub fn request_close(&self) -> bool

Runs the close_requested callback. If the callback returns KeepWindowShown, this function returns false. That should prevent the Window from closing. Otherwise it returns true, which allows the Window to hide.

pub fn is_fullscreen(&self) -> bool

Returns if the window is currently in fullscreen mode

pub fn set_fullscreen(&self, enabled: bool)

Set or unset the window to display fullscreen.

pub fn is_maximized(&self) -> bool

Returns if the window is currently maximized

pub fn set_maximized(&self, maximized: bool)

Set the window as maximized or unmaximized

pub fn is_minimized(&self) -> bool

Returns if the window is currently minimized

pub fn set_minimized(&self, minimized: bool)

Set the window as minimized or unminimized

pub fn xdg_app_id(&self) -> Option<SharedString>

Returns the (context global) xdg app id for use with wayland and x11.

pub fn window_adapter(&self) -> Rc<dyn WindowAdapter>

Returns the upgraded window adapter

pub fn from_pub(window: &Window) -> &Self

Private access to the WindowInner for a given window.

pub fn context(&self) -> &SlintContext

Provides access to the Windows’ Slint context.

pub fn try_context(&self) -> Option<&SlintContext>

Like Self::context, but returns None instead of panicking when no context is available yet.

pub fn set_context(&self, ctx: SlintContext)

Set the SlintContext. This needs to be called once before any other functions that would use the context.

Trait Implementations

impl Drop for WindowInner

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.