Struct RemovedItem 

pub struct RemovedItem { /* private fields */ }

One item lifted whole out of a Scene: its entry, its magnets and its logical-AT decorations, still owned and still carrying its original ItemId.

Opaque on purpose. It wraps the crate-private SceneEntry whole rather than copying its fields out, so a future field added to the entry cannot be missed by Scene::restore — the same argument the single-construction-site rule makes for insertion.

Ordering

Scene::take returns a subtree deepest-first, the order remove already announces in. Scene::restore_all reverses it for you; restoring by hand means roots first, or a child hits RestoreError::MissingParent.

Implementations

impl RemovedItem

pub fn id(&self) -> ItemId

The id this item had, and the id Scene::restore puts it back at.

pub fn local_pos(&self) -> Point

Position in the parent’s coordinate frame.

pub fn local_bounds(&self) -> Rect

AABB in local coordinates.

pub fn transform(&self) -> Transform2D

Local→parent transform.

pub fn z(&self) -> f32

Paint z-order.

pub fn layer(&self) -> SceneLayer

Lightweight paint band.

pub fn parent(&self) -> Option<ItemId>

Logical parent at the moment of removal. A restore needs this item present, or it fails with RestoreError::MissingParent.

pub fn detach(&mut self)

Forget the recorded parent, so this salvage restores at root level.

The door RestoreError::MissingParent points at, and the one a move between scenes needs: the parent a salvage names is still in the scene it came from, so restoring a parented item into a second scene is refused unless its parent went first — or unless the caller says, here, that it should arrive unparented.

Nothing else changes: geometry is untouched, so an item that was placed in its parent’s frame keeps those numbers and now reads them as scene coordinates. Use Scene::reparent_keeping_scene_pos after the restore when the item should not visibly move.

pub fn children(&self) -> &[ItemId]

Direct children at the moment of removal — all of them removed with it, and all of them present in the same Scene::take result.

pub fn flags(&self) -> ItemFlags

Behaviour flags.

pub fn opacity(&self) -> f32

Local opacity multiplier.

pub fn is_widget(&self) -> bool

Whether this was a heavyweight Widget entry rather than a lightweight SceneItem one.

pub fn item(&self) -> Option<&dyn SceneItem>

The lightweight item, if this was one. None for widget entries.

pub fn into_item(self) -> Option<Box<dyn SceneItem>>

Consume the salvage for its lightweight item box — cut-to-clipboard. None for widget entries (and the salvage is dropped either way).

pub fn payload(&self) -> Option<Rc<dyn Any>>

The type-erased payload of a multi-view (Delegated) heavyweight entry, which is what lets a restored card be rebuilt by every view’s delegate. None for a lightweight item and for a single-view (Scene::add_widget) entry.

pub fn widget_instance_present(&self) -> bool

Whether a single-view (Scene::add_widget) entry still carries its one Box<dyn Widget>.

true for every lightweight item and for every multi-view (add_widget_item) entry, because neither depends on a one-shot box.

This is a fact about the salvage, not a verdict on restorability, and the distinction matters: a Once widget already drained by a mounted view restores perfectly well when the take and the restore happen inside one build cycle (the view’s orphan reap keys on the scene’s live heavyweight set, which the restore has already put the id back into, so the arena instance is never destroyed). Refusing such a restore would refuse one that works — and would refuse the whole entry, geometry and accessibility included, over a widget instance.

So Scene::restore always accepts, and this reports what an app needs to decide for itself. When false and the view has already reaped the instance, the restored entry is a heavyweight slot with nothing to materialise — visible to no view. The rule that avoids it entirely is the same one multi-view content already follows: content that must survive an undo goes in through SceneModel::add_widget_item, whose payload every view can rebuild from.

pub fn a11y(&self) -> &ItemA11yDecorations

The logical-AT decorations this item carried — both directions of every edge. See ItemA11yDecorations.

pub fn magnet_count(&self) -> usize

How many magnets were attached to this item. Their ids are preserved by a restore, so a consumer keying connections on MagnetId keeps them.

Trait Implementations

impl Debug for RemovedItem

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Hand-written: SceneEntry holds a Box<dyn SceneItem> or a Box<dyn Widget> plus an Option<Box<SceneItemHandlerSet>>, and Magnet is Clone only — none of the three is Debug, so this cannot be derived.