Struct gtk4::DragSource[−][src]

pub struct DragSource(_);

Expand description

DragSource is an event controller to initiate Drag-And-Drop operations.

DragSource can be set up with the necessary ingredients for a DND operation ahead of time. This includes the source for the data that is being transferred, in the form of a gdk::ContentProvider, the desired action, and the icon to use during the drag operation. After setting it up, the drag source must be added to a widget as an event controller, using WidgetExt::add_controller().

⚠️ The following code is in c ⚠️

static void
my_widget_init (MyWidget *self)
{
  GtkDragSource *drag_source = gtk_drag_source_new ();

  g_signal_connect (drag_source, "prepare", G_CALLBACK (on_drag_prepare), self);
  g_signal_connect (drag_source, "drag-begin", G_CALLBACK (on_drag_begin), self);

  gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (drag_source));
}

Setting up the content provider and icon ahead of time only makes sense when the data does not change. More commonly, you will want to set them up just in time. To do so, DragSource has signal::DragSource::prepare and signal::DragSource::drag-begin signals.

The ::prepare signal is emitted before a drag is started, and can be used to set the content provider and actions that the drag should be started with.

⚠️ The following code is in c ⚠️

static GdkContentProvider *
on_drag_prepare (GtkDragSource *source,
                 double         x,
                 double         y,
                 MyWidget      *self)
{
  // This widget supports two types of content: GFile objects
  // and GdkPixbuf objects; GTK will handle the serialization
  // of these types automatically
  GFile *file = my_widget_get_file (self);
  GdkPixbuf *pixbuf = my_widget_get_pixbuf (self);

  return gdk_content_provider_new_union ((GdkContentProvider *[2]) {
      gdk_content_provider_new_typed (G_TYPE_FILE, file),
      gdk_content_provider_new_typed (GDK_TYPE_PIXBUF, pixbuf),
    }, 2);
}

The ::drag-begin signal is emitted after the gdk::Drag object has been created, and can be used to set up the drag icon.

⚠️ The following code is in c ⚠️

static void
on_drag_begin (GtkDragSource *source,
               GtkDrag       *drag,
               MyWidget      *self)
{
  // Set the widget as the drag icon
  GdkPaintable *paintable = gtk_widget_paintable_new (GTK_WIDGET (self));
  gtk_drag_source_set_icon (source, paintable, 0, 0);
  g_object_unref (paintable);
}

During the DND operation, DragSource emits signals that can be used to obtain updates about the status of the operation, but it is not normally necessary to connect to any signals, except for one case: when the supported actions include gdk::DragAction::MOVE, you need to listen for the signal::DragSource::drag-end signal and delete the data after it has been transferred.

Implements

GestureSingleExt, GestureExt, EventControllerExt, glib::ObjectExt

Struct gtk4::DragSource[−][src]

Implementations

impl DragSource

pub fn new() -> DragSource

pub fn builder() -> DragSourceBuilder

pub fn drag_cancel(&self)

pub fn actions(&self) -> DragAction

pub fn content(&self) -> Option<ContentProvider>

pub fn drag(&self) -> Option<Drag>

pub fn set_actions(&self, actions: DragAction)

pub fn set_content<P: IsA<ContentProvider>>(&self, content: Option<&P>)

pub fn set_icon<P: IsA<Paintable>>( &self, paintable: Option<&P>, hot_x: i32, hot_y: i32)

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

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

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

pub fn connect_prepare<F: Fn(&Self, f64, f64) -> Option<ContentProvider> + 'static>( &self, f: F) -> SignalHandlerId

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

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

Trait Implementations

impl Clone for DragSource

fn clone(&self) -> DragSource

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

impl Debug for DragSource

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

impl Default for DragSource

fn default() -> Self

impl Display for DragSource

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

impl Hash for DragSource

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

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

impl Ord for DragSource

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

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

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

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

impl ParentClassIs for DragSource

type Parent = GestureSingle

impl<T: ObjectType> PartialEq<T> for DragSource

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

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

impl<T: ObjectType> PartialOrd<T> for DragSource

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

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

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

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

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

impl StaticType for DragSource

fn static_type() -> Type

impl Eq for DragSource

impl IsA<EventController> for DragSource

impl IsA<Gesture> for DragSource

impl IsA<GestureSingle> for DragSource

impl StructuralEq for DragSource

Auto Trait Implementations

impl RefUnwindSafe for DragSource

impl !Send for DragSource

impl !Sync for DragSource

impl Unpin for DragSource

impl UnwindSafe for DragSource

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized,

pub fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

pub fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

pub fn borrow_mut(&mut self) -> &mut T

impl<T> Cast for T where T: ObjectType,

fn upcast<T>(self) -> T where T: ObjectType, Self: IsA<T>,

fn upcast_ref<T>(&self) -> &T where T: ObjectType, Self: IsA<T>,

fn downcast<T>(self) -> Result<T, Self> where T: ObjectType, Self: CanDowncast<T>,

fn downcast_ref<T>(&self) -> Option<&T> where T: ObjectType, Self: CanDowncast<T>,

fn dynamic_cast<T>(self) -> Result<T, Self> where T: ObjectType,

fn dynamic_cast_ref<T>(&self) -> Option<&T> where T: ObjectType,

unsafe fn unsafe_cast<T>(self) -> T where T: ObjectType,

unsafe fn unsafe_cast_ref<T>(&self) -> &T where T: ObjectType,

impl<T> From<T> for T

pub fn from(t: T) -> T

impl<T, U> Into<U> for T where U: From<T>,

pub fn into(self) -> U

pub fn set_icon<P: IsA<Paintable>>(
&self,
paintable: Option<&P>,
hot_x: i32,
hot_y: i32
)

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

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

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

pub fn connect_prepare<F: Fn(&Self, f64, f64) -> Option<ContentProvider> + 'static>(
&self,
f: F
) -> SignalHandlerId

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

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

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

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

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

impl<T> Cast for T where
T: ObjectType,

fn upcast<T>(self) -> T where
T: ObjectType,
Self: IsA<T>,

fn upcast_ref<T>(&self) -> &T where
T: ObjectType,
Self: IsA<T>,

fn downcast<T>(self) -> Result<T, Self> where
T: ObjectType,
Self: CanDowncast<T>,

fn downcast_ref<T>(&self) -> Option<&T> where
T: ObjectType,
Self: CanDowncast<T>,

fn dynamic_cast<T>(self) -> Result<T, Self> where
T: ObjectType,

fn dynamic_cast_ref<T>(&self) -> Option<&T> where
T: ObjectType,

unsafe fn unsafe_cast<T>(self) -> T where
T: ObjectType,

unsafe fn unsafe_cast_ref<T>(&self) -> &T where
T: ObjectType,

impl<T, U> Into<U> for T where
U: From<T>,

impl<T> ObjectExt for T where
T: ObjectType,

pub fn is<U>(&self) -> bool where
U: StaticType,

pub fn class(&self) -> &Class<T> where
T: IsClass,

pub fn class_of<U>(&self) -> Option<&Class<U>> where
U: IsClass,

pub fn interface<U>(&self) -> Option<InterfaceRef<'_, U>> where
U: IsInterface,

pub fn set_property<'a, N, V>(
&self,
property_name: N,
value: V
) -> Result<(), BoolError> where
N: Into<&'a str>,
V: ToValue,

pub fn set_property_from_value<'a, N>(
&self,
property_name: N,
value: &Value
) -> Result<(), BoolError> where
N: Into<&'a str>,

pub fn set_properties(
&self,
property_values: &[(&str, &dyn ToValue )]
) -> Result<(), BoolError>

pub fn set_properties_from_value(
&self,
property_values: &[(&str, Value )]
) -> Result<(), BoolError>

pub fn property<'a, N>(&self, property_name: N) -> Result<Value, BoolError> where
N: Into<&'a str>,

pub fn has_property<'a, N>(&self, property_name: N, type_: Option<Type>) -> bool where
N: Into<&'a str>,

pub fn property_type<'a, N>(&self, property_name: N) -> Option<Type> where
N: Into<&'a str>,

pub fn find_property<'a, N>(&self, property_name: N) -> Option<ParamSpec> where
N: Into<&'a str>,

pub unsafe fn set_qdata<QD>(&self, key: Quark, value: QD) where
QD: 'static,

pub unsafe fn qdata<QD>(&self, key: Quark) -> Option<NonNull<QD>> where
QD: 'static,

pub unsafe fn steal_qdata<QD>(&self, key: Quark) -> Option<QD> where
QD: 'static,

pub unsafe fn set_data<QD>(&self, key: &str, value: QD) where
QD: 'static,

pub unsafe fn data<QD>(&self, key: &str) -> Option<NonNull<QD>> where
QD: 'static,

pub unsafe fn steal_data<QD>(&self, key: &str) -> Option<QD> where
QD: 'static,

pub fn connect<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: 'static + Fn(&[Value ]) -> Option<Value> + Send + Sync,

pub fn connect_id<F>(
&self,
signal_id: SignalId,
details: Option<Quark>,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: 'static + Fn(&[Value ]) -> Option<Value> + Send + Sync,

pub fn connect_local<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: 'static + Fn(&[Value ]) -> Option<Value>,

pub fn connect_local_id<F>(
&self,
signal_id: SignalId,
details: Option<Quark>,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: 'static + Fn(&[Value ]) -> Option<Value>,

pub unsafe fn connect_unsafe<'a, N, F>(
&self,
signal_name: N,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
N: Into<&'a str>,
F: Fn(&[Value ]) -> Option<Value>,

pub unsafe fn connect_unsafe_id<F>(
&self,
signal_id: SignalId,
details: Option<Quark>,
after: bool,
callback: F
) -> Result<SignalHandlerId, BoolError> where
F: Fn(&[Value ]) -> Option<Value>,

pub fn emit(
&self,
signal_id: SignalId,
args: &[&dyn ToValue ]
) -> Result<Option<Value>, BoolError>

pub fn emit_with_values(
&self,
signal_id: SignalId,
args: &[Value ]
) -> Result<Option<Value>, BoolError>

pub fn emit_by_name<'a, N>(
&self,
signal_name: N,
args: &[&dyn ToValue ]
) -> Result<Option<Value>, BoolError> where
N: Into<&'a str>,

pub fn emit_by_name_with_values<'a, N>(
&self,
signal_name: N,
args: &[Value ]
) -> Result<Option<Value>, BoolError> where
N: Into<&'a str>,

pub fn emit_with_details(
&self,
signal_id: SignalId,
details: Quark,
args: &[&dyn ToValue ]
) -> Result<Option<Value>, BoolError>

pub fn emit_with_details_and_values(
&self,
signal_id: SignalId,
details: Quark,
args: &[Value ]
) -> Result<Option<Value>, BoolError>

pub fn connect_notify<F>(&self, name: Option<&str>, f: F) -> SignalHandlerId where
F: 'static + Fn(&T, &ParamSpec) + Send + Sync,

pub fn connect_notify_local<F>(
&self,
name: Option<&str>,
f: F
) -> SignalHandlerId where
F: 'static + Fn(&T, &ParamSpec),

pub unsafe fn connect_notify_unsafe<F>(
&self,
name: Option<&str>,
f: F
) -> SignalHandlerId where
F: Fn(&T, &ParamSpec),

pub fn notify<'a, N>(&self, property_name: N) where
N: Into<&'a str>,