Struct Drop 

pub struct Drop<'a, T: DragDropId, Message, OnAccept, OnDrop> { /* private fields */ }

A drop zone where draggable Drag items may be dropped

Implementations

impl<'a, T: DragDropId, Message: 'a, OnAccept, OnDrop> Drop<'a, T, Message, OnAccept, OnDrop>

where OnAccept: Fn(T) -> bool + 'a, OnDrop: Fn(T, (f32, f32)) -> Message + 'a,

pub fn new( context: &'a DragDropContext<T>, accept: OnAccept, drop: OnDrop, content: impl IntoNode<'a, Message>, ) -> Self

Construct a new Drop widget

pub fn context(self, context: &'a DragDropContext<T>) -> Self

Sets the drag and drop context that the drop widget will work with.

pub fn on_accept<N: Fn(T) -> bool>( self, on_accept: N, ) -> Drop<'a, T, Message, N, OnDrop>

Sets the on_accept delegate. If a draggable value is accepted by this drop target, the delegate should return true.

pub fn on_drop<N: Fn(T, (f32, f32)) -> Message>( self, on_drop: N, ) -> Drop<'a, T, Message, OnAccept, N>

Sets the on_drop delegate. The delegate should return a message for it’s parent component based on the dropped value. The second argument contains the exact (x, y) coordinates where the value was dropped.

pub fn extend<I: IntoIterator<Item = N>, N: IntoNode<'a, Message>>( self, iter: I, ) -> Self

Sets the content widget from the first element of an iterator.

Trait Implementations

impl<'a, T: DragDropId, Message> Default for Drop<'a, T, Message, fn(T) -> bool, fn(T, (f32, f32)) -> Message>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T: DragDropId + Send + Sync, Message: 'a, OnAccept, OnDrop> IntoNode<'a, Message> for Drop<'a, T, Message, OnAccept, OnDrop>

where OnAccept: Send + Fn(T) -> bool + 'a, OnDrop: Send + Fn(T, (f32, f32)) -> Message + 'a,

fn into_node(self) -> Node<'a, Message>

Perform the conversion.

fn class(self, class: &'a str) -> Node<'a, Message>

Convenience function that converts to a node and then adds a style class to the resulting Node.

fn key<K: Hash>(self, key: K) -> Node<'a, Message>

Convenience function that converts to a node and then sets a custom id to the resulting Node.

impl<'a, T, Message: 'a, OnAccept, OnDrop> Widget<'a, Message> for Drop<'a, T, Message, OnAccept, OnDrop>

where T: DragDropId + Send + Sync, OnAccept: 'a + Send + Fn(T) -> bool, OnDrop: 'a + Send + Fn(T, (f32, f32)) -> Message,

type State = DropState<T>

The type of state this widget keeps track of.

fn mount(&self) -> DropState<T>

Create a new state

fn widget(&self) -> &'static str

The name of this widget, used to identify widgets of this type in stylesheets.

fn state(&self, state: &DropState<T>) -> StateVec

The state of this widget, used for computing the style. If None is returned, Node will automatically compute a state, such as “hover” and “pressed”.

fn len(&self) -> usize

Should return the amount of children this widget has. Must be consistent with visit_children().

fn visit_children( &mut self, visitor: &mut dyn FnMut(&mut dyn GenericNode<'a, Message>), )

Applies a visitor to all childs of the widget. If an widget fails to visit it’s children, the children won’t be able to resolve their stylesheet, resulting in a panic when calling size, hit, event or draw.

fn size(&self, _: &DropState<T>, style: &Stylesheet) -> (Size, Size)

Returns the (width, height) of this widget. The extents are defined as a Size, which will later be resolved to actual dimensions.

fn event( &mut self, state: &mut DropState<T>, layout: Rectangle, clip: Rectangle, style: &Stylesheet, event: Event, context: &mut Context<Message>, )

Handle an event. If an event changes the graphical appearance of an Widget, redraw should be called to let the Ui know that the ui should be redrawn.

fn draw( &mut self, _: &mut DropState<T>, layout: Rectangle, clip: Rectangle, style: &Stylesheet, ) -> Vec<Primitive<'a>>

Draw the widget. Returns a list of Primitives that should be drawn.

fn key(&self) -> u64

The key of this widget, used for resolving state.

fn is_empty(&self) -> bool

Returns whether this children has no children. Must be consistent with visit_children().

fn hit( &self, _state: &Self::State, layout: Rectangle, clip: Rectangle, _style: &Stylesheet, x: f32, y: f32, ) -> bool

Perform a hit detect on the widget. Most widgets are fine with the default implementation, but some widgets (like Window need to report a miss (false) even when the queried position is within their layout.

fn focused(&self, _state: &Self::State) -> bool

Test the widget for focus exclusivity. If the widget or one of it’s descendants is in an exclusive focus state, this function should return true. In all other cases, it should return false. When a widget is in an exclusive focus state it is the only widget that is allowed to receive events in event. Widgets that intended to use this behaviour are modal dialogs, dropdown boxes, context menu’s, etc.