Trait WindowOps 

pub trait WindowOps {
    // Required methods
    fn open_window(&mut self, config: WindowConfig) -> TeksiloWindowId;
    fn find_window(&self, string_id: &str) -> Option<TeksiloWindowId>;
    fn window_state(&self, id: TeksiloWindowId) -> Option<WindowState>;
    fn windows(&self) -> Vec<WindowState>;
    fn focus_window(&mut self, id: TeksiloWindowId);
    fn close_window_by_id(&mut self, id: TeksiloWindowId);

    // Provided methods
    fn request_activation_token(
        &mut self,
        _id: TeksiloWindowId,
        cb: Box<dyn FnOnce(Option<String>)>,
    ) { ... }
    fn request_activation_token_self(
        &mut self,
        cb: Box<dyn FnOnce(Option<String>)>,
    ) { ... }
    fn current_parent_handle(&self) -> Option<ParentHandle> { ... }
    fn set_ime_cursor_area(&mut self, _area: Rect) { ... }
    fn finish_ime_composition(&mut self) -> Option<String> { ... }
    fn begin_os_drag(
        &mut self,
        _data: OutboundDragData,
        _image: Option<DragImageData>,
        _pointer: PointerKind,
    ) -> OsDragStart { ... }
    fn set_drop_accepted(&mut self, _accepted: bool) { ... }
    fn cancel_os_drag(&mut self) { ... }
    fn soft_keyboard_support(&self) -> SoftKeyboardSupport { ... }
    fn quit(&mut self) { ... }
    fn quit_forced(&mut self) { ... }
    fn quit_in_progress(&self) -> bool { ... }
    fn quit_source(&self) -> Option<QuitSource> { ... }
    fn cancel_quit(&mut self) { ... }
}

App-level window operations exposed to handlers.

Implemented by teksilo_app::WindowManager (via a short-lived wrapper that also holds &ActiveEventLoop). Passed into every dispatch site as &mut dyn WindowOps and stored on EventContext.

Required Methods

fn open_window(&mut self, config: WindowConfig) -> TeksiloWindowId

Open a new window. Creates the winit-level window synchronously inside this call and returns its id, which is immediately valid for any other method on this trait.

fn find_window(&self, string_id: &str) -> Option<TeksiloWindowId>

Look up a window by the stable string id it was opened with (WindowConfig::id). Returns None if no live window carries that id.

fn window_state(&self, id: TeksiloWindowId) -> Option<WindowState>

Read the reactive state for a specific window.

fn windows(&self) -> Vec<WindowState>

Every live window’s state, in creation order.

fn focus_window(&mut self, id: TeksiloWindowId)

Raise a window and give it keyboard focus, restoring it first if it is minimised.

fn close_window_by_id(&mut self, id: TeksiloWindowId)

Close a specific window by id. The window is fully torn down before the next event-loop tick.

Provided Methods

fn request_activation_token( &mut self, _id: TeksiloWindowId, cb: Box<dyn FnOnce(Option<String>)>, )

Request an xdg_activation_v1 token for id — to hand to another window or a child process so it can raise itself on Wayland. cb fires once with the token string, or with None where unsupported (everything but Wayland/X11). Default implementation: immediate None.

fn request_activation_token_self(&mut self, cb: Box<dyn FnOnce(Option<String>)>)

Like request_activation_token but for the current dispatching window — the one whose handler is running. Works even mid-dispatch, when that window is temporarily out of the manager’s map, because it uses the captured window handle instead of an id lookup. Use this when a focused widget needs a token to hand to another window or process. Default implementation: immediate None.

fn current_parent_handle(&self) -> Option<ParentHandle>

Extract the platform parent handle of the window currently dispatching the event (the one that owns the in-flight EventContext). Used by native-dialog integrations (teksilo_platform::file_dialog) to parent OS dialogs to the originating Teksilo window.

Returns None for the standalone / test sink and on rare platform paths where the underlying surface refuses a handle (e.g. during shutdown).

fn set_ime_cursor_area(&mut self, _area: Rect)

Report the focused text widget’s caret rectangle (in window-logical pixels) so the platform can position the OS IME candidate window next to the insertion point. Called from text-editing widgets whenever the caret moves. The app applies it to the in-flight window’s set_ime_cursor_area, deduped against the last value.

No-op on the standalone / test sink.

fn finish_ime_composition(&mut self) -> Option<String>

Tell the platform’s input method that the focused field’s composition is over (a click elsewhere, a focus change), and return the text the input method committed for it, if it committed one: the field keeps that text in place of what the composition showed. On Windows the input method is asked to complete the composition, as a native edit control does, and its commit can differ from what it showed (Microsoft Pinyin commits “nihao” for the “ni’hao” it showed). None keeps what the composition showed: the platform keeps that (macOS, Linux), or the input method committed nothing.

The field calls it while it still holds the composition, and keeps the text right after, in the same handler. Whatever the platform delivers for the composition arrives after the handler returns (an empty update, an empty commit), and must find nothing left to change; a copy of the commit returned here is not delivered.

None on the standalone / test sink.

fn begin_os_drag( &mut self, _data: OutboundDragData, _image: Option<DragImageData>, _pointer: PointerKind, ) -> OsDragStart

Ask the platform to start a native OS drag for an in-app drag carrying an OS-exportable payload. The framework asks when the pointer leaves the window, or, for a payload with OsHandoff::Eager, on the first pointer move. The platform backend (teksilo_platform::external_dnd) starts a native drag session (NSDraggingSource / wl_data_source / OLE IDropSource / XDND) using data, optionally drawing image as the drag cursor.

The answer decides what happens to the in-app session:

• OsDragStart::Declined: nothing started, and the in-app drag continues; a later pointer move may ask again. This is the default, for the standalone / test sink and for a platform without an outbound backend.
• OsDragStart::Started: the native drag is running (macOS starts it inside the request). The in-app session is handed over at once.
• OsDragStart::Pending: the platform starts the drag on its own loop (Wayland, X11, Windows), under the OsDragId it carries. The in-app session stays alive until the platform confirms that drag’s start through WidgetTree::confirm_os_drag. A release before that ends the drag as Cancelled and calls Self::cancel_os_drag; a start that fails ends it through WidgetTree::handle_os_drag_ended_for. Events naming another drag’s id change nothing.

A failure known now (nothing to drag from, nothing to export) is a Declined, never a Pending that fails later: a decline keeps the in-app drag, a failure ends it.

pointer is the device carrying the drag. It is not decoration: on Wayland wl_data_device::start_drag must be given the serial of the input event that began the implicit grab, and a finger’s grab was opened by a wl_touch::down, not a wl_pointer::button; hand the wrong serial over and the compositor rejects the request silently and sends no terminal event at all.

fn set_drop_accepted(&mut self, _accepted: bool)

Tell the platform whether the widget under an inbound OS drag accepts it, so the OS shows the right cursor and permits (or refuses) the drop.

An inbound backend must answer the drag source synchronously — XDND requires an XdndStatus for every XdndPosition, and Wayland wants wl_data_offer::accept + set_actions on the offer — which happens on the backend’s own thread, before the widget tree has seen the sample. So the backend’s first answer can only be about format compatibility; this is how the widget’s actual verdict gets back to the OS. Called by the tree only when the answer changes.

The negotiated operation follows from the bit: Copy when accepted, none when refused. Copy is the only operation Teksilo advertises in either direction, so there is nothing else for a widget to choose — see docs/drag-and-drop.md §11.5.

Default: no-op — the standalone sink and any platform without an inbound backend.

fn cancel_os_drag(&mut self)

Abandon an OS drag requested with Self::begin_os_drag: the user pressed Escape, or released the pointer before a pending start was confirmed.

A start that is still pending must not happen after this: the backend drops it, or, if the native drag has already started, ends it. Once the drag runs, macOS and Windows hand it to a modal OS loop that owns Escape already, and this does nothing there; Wayland ends it by destroying its data source (an Escape this window still receives, over one of its own surfaces); X11 tracks the pointer on its own connection, so without this its drags could only end by releasing the button. A backend that ends a running drag still reports the terminal DropOutcome, so the source widget’s on_drag_ended fires exactly once regardless.

Default: no-op.

fn soft_keyboard_support(&self) -> SoftKeyboardSupport

What the host platform can do about an on-screen keyboard.

Read by a widget that must decide whether a touch-only user can reach a keyboard at all: where the answer is SoftKeyboardSupport::None the framework will never raise one and promises nothing about whether the platform will, so a text surface that expects a finger has to offer its own affordance.

Default: SoftKeyboardSupport::None, which is the truth for a standalone tree with no window under it.

fn quit(&mut self)

Ask the application to quit, asking every open window’s close guard in turn. See EventContext::quit.

Default: no-op, for a sink with no application behind it.

fn quit_forced(&mut self)

Quit the application without asking any close guard. See EventContext::quit_forced.

Default: no-op, for a sink with no application behind it.

fn quit_in_progress(&self) -> bool

Whether a quit is under way: requested, and neither finished nor abandoned. Default: false.

fn quit_source(&self) -> Option<QuitSource>

Where the quit under way came from, or None when no quit is under way. Default: None.

fn cancel_quit(&mut self)

Abandon the quit under way, if it is a guarded one; see EventContext::cancel_quit. Default: no-op.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl WindowOps for NoopWindowOps