Struct DropTargetAsync

pub struct DropTargetAsync { /* private fields */ }

DropTargetAsync is an event controller to receive Drag-and-Drop operations, asynchronously.

It is the more complete but also more complex method of handling drop operations compared to DropTarget, and you should only use it if DropTarget doesn’t provide all the features you need.

To use a DropTargetAsync to receive drops on a widget, you create a DropTargetAsync object, configure which data formats and actions you support, connect to its signals, and then attach it to the widget with WidgetExt::add_controller().

During a drag operation, the first signal that a DropTargetAsync emits is accept, which is meant to determine whether the target is a possible drop site for the ongoing drop. The default handler for the ::accept signal accepts the drop if it finds a compatible data format and an action that is supported on both sides.

If it is, and the widget becomes a target, you will receive a drag-enter signal, followed by drag-motion signals as the pointer moves, optionally a drop signal when a drop happens, and finally a drag-leave signal when the pointer moves off the widget.

The ::drag-enter and ::drag-motion handler return a gdk::DragAction to update the status of the ongoing operation. The ::drop handler should decide if it ultimately accepts the drop and if it does, it should initiate the data transfer and finish the operation by calling Drop::finish().

Between the ::drag-enter and ::drag-leave signals the widget is a current drop target, and will receive the StateFlags::DROP_ACTIVE state, which can be used by themes to style the widget as a drop target.

Properties

actions

The GdkDragActions that this drop target supports.

Readable | Writeable

formats

The gdk::ContentFormats that determines the supported data formats.

Readable | Writeable

EventController

name

The name for this controller, typically used for debugging purposes.

Readable | Writeable

propagation-limit

The limit for which events this controller will handle.

Readable | Writeable

propagation-phase

The propagation phase at which this controller will handle events.

Readable | Writeable

widget

The widget receiving the GdkEvents that the controller will handle.

Readable

Signals

accept

Emitted on the drop site when a drop operation is about to begin.

If the drop is not accepted, false will be returned and the drop target will ignore the drop. If true is returned, the drop is accepted for now but may be rejected later via a call to DropTargetAsync::reject_drop() or ultimately by returning false from a drop handler.

The default handler for this signal decides whether to accept the drop based on the formats provided by the @drop.

If the decision whether the drop will be accepted or rejected needs further processing, such as inspecting the data, this function should return true and proceed as is @drop was accepted and if it decides to reject the drop later, it should call DropTargetAsync::reject_drop().

drag-enter

Emitted on the drop site when the pointer enters the widget.

It can be used to set up custom highlighting.

drag-leave

Emitted on the drop site when the pointer leaves the widget.

Its main purpose it to undo things done in DropTargetAsync::drag-enter.

drag-motion

Emitted while the pointer is moving over the drop target.

drop

Emitted on the drop site when the user drops the data onto the widget.

The signal handler must determine whether the pointer position is in a drop zone or not. If it is not in a drop zone, it returns false and no further processing is necessary.

Otherwise, the handler returns true. In this case, this handler will accept the drop. The handler must ensure that Drop::finish() is called to let the source know that the drop is done. The call to Drop::finish() must only be done when all data has been received.

To receive the data, use one of the read functions provided by gdk::Drop such as Drop::read_async() or Drop::read_value_async().

Implements

EventControllerExt, [trait@glib::ObjectExt]

GLib type: GObject with reference counted clone semantics.

Implementations

impl DropTargetAsync

pub fn new( formats: Option<ContentFormats>, actions: DragAction, ) -> DropTargetAsync

Creates a new DropTargetAsync object.

formats

the supported data formats

actions

the supported actions

Returns

the new DropTargetAsync

pub fn builder() -> DropTargetAsyncBuilder

Creates a new builder-pattern struct instance to construct DropTargetAsync objects.

This method returns an instance of DropTargetAsyncBuilder which can be used to create DropTargetAsync objects.

pub fn actions(&self) -> DragAction

Gets the actions that this drop target supports.

Returns

the actions that this drop target supports

pub fn formats(&self) -> Option<ContentFormats>

Gets the data formats that this drop target accepts.

If the result is None, all formats are expected to be supported.

Returns

the supported data formats

pub fn reject_drop(&self, drop: &Drop)

Sets the @drop as not accepted on this drag site.

This function should be used when delaying the decision on whether to accept a drag or not until after reading the data.

drop

the gdk::Drop of an ongoing drag operation

pub fn set_actions(&self, actions: DragAction)

Sets the actions that this drop target supports.

actions

the supported actions

pub fn set_formats(&self, formats: Option<&ContentFormats>)

Sets the data formats that this drop target will accept.

formats

the supported data formats or None for any format

pub fn connect_accept<F: Fn(&Self, &Drop) -> bool + 'static>( &self, f: F, ) -> SignalHandlerId

Emitted on the drop site when a drop operation is about to begin.

If the drop is not accepted, false will be returned and the drop target will ignore the drop. If true is returned, the drop is accepted for now but may be rejected later via a call to reject_drop() or ultimately by returning false from a drop handler.

The default handler for this signal decides whether to accept the drop based on the formats provided by the @drop.

If the decision whether the drop will be accepted or rejected needs further processing, such as inspecting the data, this function should return true and proceed as is @drop was accepted and if it decides to reject the drop later, it should call reject_drop().

drop

the gdk::Drop

Returns

true if @drop is accepted

pub fn connect_drag_enter<F: Fn(&Self, &Drop, f64, f64) -> DragAction + 'static>( &self, f: F, ) -> SignalHandlerId

Emitted on the drop site when the pointer enters the widget.

It can be used to set up custom highlighting.

drop

the gdk::Drop

x

the x coordinate of the current pointer position

y

the y coordinate of the current pointer position

Returns

Preferred action for this drag operation.

pub fn connect_drag_leave<F: Fn(&Self, &Drop) + 'static>( &self, f: F, ) -> SignalHandlerId

Emitted on the drop site when the pointer leaves the widget.

Its main purpose it to undo things done in DropTargetAsync::drag-enter.

drop

the gdk::Drop

pub fn connect_drag_motion<F: Fn(&Self, &Drop, f64, f64) -> DragAction + 'static>( &self, f: F, ) -> SignalHandlerId

Emitted while the pointer is moving over the drop target.

drop

the gdk::Drop

x

the x coordinate of the current pointer position

y

the y coordinate of the current pointer position

Returns

Preferred action for this drag operation.

pub fn connect_drop<F: Fn(&Self, &Drop, f64, f64) -> bool + 'static>( &self, f: F, ) -> SignalHandlerId

Emitted on the drop site when the user drops the data onto the widget.

The signal handler must determine whether the pointer position is in a drop zone or not. If it is not in a drop zone, it returns false and no further processing is necessary.

Otherwise, the handler returns true. In this case, this handler will accept the drop. The handler must ensure that Drop::finish() is called to let the source know that the drop is done. The call to Drop::finish() must only be done when all data has been received.

To receive the data, use one of the read functions provided by gdk::Drop such as Drop::read_async() or Drop::read_value_async().

drop

the gdk::Drop

x

the x coordinate of the current pointer position

y

the y coordinate of the current pointer position

Returns

whether the drop is accepted at the given pointer position

pub fn connect_actions_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

pub fn connect_formats_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

Trait Implementations

impl Clone for DropTargetAsync

fn clone(&self) -> Self

Makes a clone of this shared reference.

This increments the strong reference count of the object. Dropping the object will decrement it again.

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

Performs copy-assignment from source.

impl Debug for DropTargetAsync

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

Formats the value using the given formatter.

impl Default for DropTargetAsync

fn default() -> Self

Returns the “default value” for a type.

impl HasParamSpec for DropTargetAsync

type ParamSpec = ParamSpecObject

type SetValue = DropTargetAsync

Preferred value to be used as setter for the associated ParamSpec.

type BuilderFn = fn(_: &str) -> ParamSpecObjectBuilder<'_, DropTargetAsync>

fn param_spec_builder() -> Self::BuilderFn

impl Hash for DropTargetAsync

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Hashes the memory address of this object.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for DropTargetAsync

fn cmp(&self, other: &Self) -> Ordering

Comparison for two GObjects.

Compares the memory addresses of the provided objects.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl ParentClassIs for DropTargetAsync

type Parent = EventController

impl<OT: ObjectType> PartialEq<OT> for DropTargetAsync

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

Equality for two GObjects.

Two GObjects are equal if their memory addresses are equal.

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<OT: ObjectType> PartialOrd<OT> for DropTargetAsync

fn partial_cmp(&self, other: &OT) -> Option<Ordering>

Partial comparison for two GObjects.

Compares the memory addresses of the provided objects.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for DropTargetAsync

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for DropTargetAsync

impl IsA<EventController> for DropTargetAsync