Struct DropEvent 

pub struct DropEvent<Id>
where
    Id: Hash + Eq + Clone,
{
    pub source: Id,
    pub target: Id,
    pub position: DropPosition,
}

Details of a drag-and-drop event in the outliner.

This struct contains information about a completed drop operation, including the source node that was dragged, the target node it was dropped onto, and the position relative to the target.

Generic Parameters

• Id - The type used to identify nodes in the outliner. Must implement Hash, Eq, and Clone.

Examples

if let Some(drop_event) = response.drop_event() {
    match drop_event.position {
        DropPosition::Before => {
            insert_before(drop_event.source, drop_event.target);
        }
        DropPosition::After => {
            insert_after(drop_event.source, drop_event.target);
        }
        DropPosition::Inside => {
            make_child_of(drop_event.source, drop_event.target);
        }
    }
}

Fields

source: Id

The ID of the node that was dragged.

target: Id

The ID of the node that the source was dropped onto.

position: DropPosition

The position where the source should be placed relative to the target.

Implementations

impl<Id> DropEvent<Id>

where Id: Hash + Eq + Clone,

pub fn new(source: Id, target: Id, position: DropPosition) -> Self

Creates a new drop event.

Arguments

• source - The ID of the node that was dragged
• target - The ID of the node that was dropped onto
• position - Where to place the source relative to the target

Examples

let drop_event = DropEvent::new(
    dragged_id,
    target_id,
    DropPosition::Inside,
);

Trait Implementations

impl<Id> Clone for DropEvent<Id>

where Id: Hash + Eq + Clone + Clone,

fn clone(&self) -> DropEvent<Id>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Id> Debug for DropEvent<Id>

where Id: Hash + Eq + Clone + Debug,

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

Formats the value using the given formatter.

impl<Id> PartialEq for DropEvent<Id>

where Id: Hash + Eq + Clone + PartialEq,

fn eq(&self, other: &DropEvent<Id>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Id> Eq for DropEvent<Id>

where Id: Hash + Eq + Clone + Eq,

impl<Id> StructuralPartialEq for DropEvent<Id>

where Id: Hash + Eq + Clone,