Struct DropListener 

pub struct DropListener<T: ?Sized> {
    pub can_drop: Option<CanDropListenerFn<T>>,
    pub on_drag_over: Option<OnDragOverFn<T>>,
    pub on_drop: Option<OnDropFn<T>>,
}

Handles drags of a single type over an element: whether they can be dropped, how the element looks while they are over it, and what happens when they are released.

Attach it with InteractiveElement::on_drop_alt. For the common case of one handler per type, use InteractiveElement::on_drop instead.

Fields

can_drop: Option<CanDropListenerFn<T>>

Decides whether a dragged value of this type can be dropped on the element. If it is None, a value is accepted while the pointer is over the element.

on_drag_over: Option<OnDragOverFn<T>>

Returns the style to apply while a value of this type is over the element and can_drop allows it.

on_drop: Option<OnDropFn<T>>

Runs when a value of this type is released over the element and can_drop allows it.

Implementations

impl<T: Sized + 'static> DropListener<T>

pub fn can_drop_within( self, predicate: impl Fn(&T, &mut Window, &mut App) -> bool + 'static, ) -> Self

Sets a predicate that decides whether this handler receives drops, which runs only while the pointer is over the element.

The predicate receives the dragged value and the window and app. The hitbox check is added for you, so the predicate need not check it. A predicate on a listener for another type never runs.

pub fn can_drop_anywhere( self, predicate: impl Fn(&T, &Hitbox, &mut Window, &mut App) -> bool + 'static, ) -> Self

Sets a predicate that decides whether this handler receives drops, whether or not the pointer is over the element.

The predicate receives the dragged value, the element’s hitbox, and the window and app. Check Hitbox::is_hovered yourself if you need the pointer to be over the element.

pub fn on_drag_over( self, predicate: impl Fn(StyleRefinement, &T, &mut Window, &mut App) -> StyleRefinement + 'static, ) -> Self

Sets the style to apply while a value of type T is dragged over the element.

The style applies only if can_drop allows the value, and only while the pointer is over the element.

pub fn on_drop( self, predicate: impl Fn(&T, &MouseUpEvent, &mut Window, &mut App) + 'static, ) -> Self

Sets the function that handles a value of type T released over the element.

It runs only if can_drop allows the value. It receives the dragged value and the mouse release event.

pub fn into_any(self) -> DropListener<dyn Any>

Converts this typed listener into one that stores any value and checks the type at runtime.

GPUI calls this when you pass a DropListener to InteractiveElement::on_drop_alt. The callbacks downcast the dragged value to T. on_drag_over and on_drop panic if they receive another type, so register the listener only for the type it was written for.

Trait Implementations

impl<T> Default for DropListener<T>

fn default() -> Self

Returns the “default value” for a type.