Struct DndWorld 

pub struct DndWorld<T: Clone + 'static> { /* private fields */ }

A drag world shared by several windows: one DndContext every joined provider re-provides, plus the window table cross-window hit-testing walks. Cheap to copy; pass it to a sibling window via VirtualDom::with_root_context.

Implementations

impl<T: Clone + 'static> DndWorld<T>

pub fn begin_from(&self, key: WindowKey)

Mark a drag as begun from key and reset stale presentation state. Draggable calls this at pickup; call it from custom drag sources so the world knows which window’s client px ctx.pointer() is in.

pub fn active_record(&self) -> Option<WindowRecord<T>>

The record of the window the in-flight drag started in.

pub fn global_pointer(&self) -> Option<Point>

The in-flight pointer in global physical px. None until a world pointer can be resolved or after the world drag finishes.

pub fn source_location(&self) -> Option<ZoneLocation>

Window-qualified source and hover locations for the active world drag. The legacy DndContext id accessors remain unchanged.

pub fn over_location(&self) -> Option<ZoneLocation>

pub fn drag_session(&self) -> Option<DragSessionId>

Current tracked pointer-drag generation, if this world owns one.

impl<T: Clone + 'static> DndWorld<T>

Host-side drive: entry points for desktop glue that sees the pointer where webviews cannot. Webview pointer events stop at the viewport edge (and under a pointer grab, every non-origin window is fully event-blind on all platforms), so cross-window pointer data must come from the windowing layer: poll the global cursor while a drag is in flight and feed it here.

pub fn modifiers(&self) -> Modifiers

Modifiers currently associated with host delivery. Returns an empty set outside an active world drag.

pub fn update_modifiers(&self, modifiers: Modifiers)

Update the live modifiers for the active world drag. Late host events after completion are ignored once the context stops dragging.

pub fn track_global(&self, global: Point)

Track an in-flight pointer drag from a host-reported cursor position (global physical px): updates the shared pointer (in the origin window’s client px, the coordinate anchor everything else expects) and enters/leaves zones across every joined window. No-op when nothing is dragging or the origin window is unknown.

Every host leg converges here, so overlapping legs are safe by construction rather than by leg exclusivity:

• Two legs reporting the same tick are idempotent: every write below is guarded by an equality check, and re-entering the current zone is a no-op.
• Legs run on one event-loop thread, so ticks serialize; a staler position arriving after a fresher one moves the hover briefly and the next tick corrects it - visual, transient, never structural.
• A tick landing after a drop cannot resurrect the drag: the dragging() gate below is dead after completion, and each leg additionally re-validates its captured BridgeGeneration immediately before calling in, so drag N’s sleeper cannot feed replacement drag N+1 even during the same event burst.

pub fn drop_at_global(&self, global: Point) -> Option<ZoneId>

where T: PartialEq,

Complete an in-flight pointer drag at a host-reported cursor position (global physical px): exact zone hit in whichever window contains the point, else that window’s 48px snap (in its own CSS px), else cancel. Returns the receiving zone. Used by glue that detects a release the webviews never saw - e.g. a non-origin window receiving its first pointer event mid-“drag”, which proves the button is up. A no-op returning None when nothing is dragging, so double delivery (webview pointerup plus host echo) is harmless.

pub fn cancel_drag(&self)

Abort an in-flight drag from the host side (a window manager signal, an escape hatch). No-op when nothing is dragging.

pub fn origin_window(&self) -> Option<WindowKey>

The key of the window the in-flight drag started in, if any - glue uses it to tell “origin window, webview owns the events” from “foreign window, I am the drag’s eyes”.

impl<T: Clone + 'static> DndWorld<T>

pub fn claim_settle(&self, key: WindowKey)

Elect key to present the next world settle. Custom world delivery calls this before crate::core::DndContext::take_settling; built-in delivery claims automatically.

The claim is required, not advisory: in a joined world, only the elected window’s overlay presents and finishes a settle. A custom source that calls take_settling without claiming gets no glide anywhere; that claimless settle is only cleaned up when its origin window closes or the next drag begins.

pub fn finish_settle_from(&self, key: WindowKey) -> bool

Finish a custom or built-in settle from its elected window. Custom world overlays should use this rather than finishing the shared context directly, so world metadata is cleared with it.

pub fn settling_in(&self) -> Option<WindowKey>

The window elected to present the current settle glide.

impl<T: Clone + 'static> DndWorld<T>

pub fn new() -> Self

Create a world. Its state is process-lived (see the module docs on lifetimes), so windows may close in any order afterwards. Must run inside a Dioxus app; prefer use_dnd_world, which also provides the world in context.

pub fn context(&self) -> DndContext<T>

The shared drag context every joined provider re-provides.

pub fn set_bridging(&self, enabled: bool)

Enable or disable host-side bridging at runtime - the lever for the day a webview or OS update ships a cross-window regression that a rebuild cannot wait for. While disabled, every host-drive entry point (Self::track_global, Self::drop_at_global) is inert and the desktop feature’s bridge legs stand down, so drags degrade to per-window - exactly the already-modeled Wayland behavior. Local drags, geometry, settle and delivery are untouched. Self::cancel_drag deliberately stays live: it is an escape hatch, not a bridge leg.

End users can flip the same switch without a rebuild by setting DIOXUS_DND_NO_BRIDGE=1 before launch (read once at world creation; 0 or an empty value leaves bridging on).

pub fn bridging_enabled(&self) -> bool

Is host-side bridging currently enabled? (See Self::set_bridging.)

pub fn record(&self, key: WindowKey) -> Option<WindowRecord<T>>

Look up a joined window. None for unknown keys.

pub fn windows(&self) -> Vec<WindowRecord<T>>

Every joined window, in join order. Subscribing read, like ZoneRegistry::records - its consumers are renderers and tests.

pub fn window_under(&self, global: Point) -> Option<WindowRecord<T>>

The window containing global (physical px), most recently focused first when several overlap. None while no live geometry contains the point.

pub fn resolve_global(&self, global: Point) -> Option<(WindowRecord<T>, Point)>

Resolve a global point to (window, client-local point). None when no live window contains it.

pub fn refresh_all_rects(&self)

Ask every joined window to re-measure its zones, each inside its own runtime through the window’s internal refresh callback.

Trait Implementations

impl<T: Clone + 'static> Clone for DndWorld<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Clone + 'static> Copy for DndWorld<T>

impl<T: Clone + 'static> Default for DndWorld<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Clone + 'static> PartialEq for DndWorld<T>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.