gdk/auto/

drag_context.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::{Atom, Device, DragAction, DragCancelReason, DragProtocol, Window, ffi};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    ///
    ///
    /// ## Signals
    ///
    ///
    /// #### `action-changed`
    ///  A new action is being chosen for the drag and drop operation.
    ///
    /// This signal will only be emitted if the [`DragContext`][crate::DragContext] manages
    /// the drag and drop operation. See [`DragContext::manage_dnd()`][crate::DragContext::manage_dnd()]
    /// for more information.
    ///
    ///
    ///
    ///
    /// #### `cancel`
    ///  The drag and drop operation was cancelled.
    ///
    /// This signal will only be emitted if the [`DragContext`][crate::DragContext] manages
    /// the drag and drop operation. See [`DragContext::manage_dnd()`][crate::DragContext::manage_dnd()]
    /// for more information.
    ///
    ///
    ///
    ///
    /// #### `dnd-finished`
    ///  The drag and drop operation was finished, the drag destination
    /// finished reading all data. The drag source can now free all
    /// miscellaneous data.
    ///
    /// This signal will only be emitted if the [`DragContext`][crate::DragContext] manages
    /// the drag and drop operation. See [`DragContext::manage_dnd()`][crate::DragContext::manage_dnd()]
    /// for more information.
    ///
    ///
    ///
    ///
    /// #### `drop-performed`
    ///  The drag and drop operation was performed on an accepting client.
    ///
    /// This signal will only be emitted if the [`DragContext`][crate::DragContext] manages
    /// the drag and drop operation. See [`DragContext::manage_dnd()`][crate::DragContext::manage_dnd()]
    /// for more information.
    ///
    ///
    #[doc(alias = "GdkDragContext")]
    pub struct DragContext(Object<ffi::GdkDragContext>);

    match fn {
        type_ => || ffi::gdk_drag_context_get_type(),
    }
}

impl DragContext {
    /// Determines the bitmask of actions proposed by the source if
    /// [`suggested_action()`][Self::suggested_action()] returns [`DragAction::ASK`][crate::DragAction::ASK].
    ///
    /// # Returns
    ///
    /// the [`DragAction`][crate::DragAction] flags
    #[doc(alias = "gdk_drag_context_get_actions")]
    #[doc(alias = "get_actions")]
    pub fn actions(&self) -> DragAction {
        unsafe { from_glib(ffi::gdk_drag_context_get_actions(self.to_glib_none().0)) }
    }

    /// Returns the destination window for the DND operation.
    ///
    /// # Returns
    ///
    /// a [`Window`][crate::Window]
    #[doc(alias = "gdk_drag_context_get_dest_window")]
    #[doc(alias = "get_dest_window")]
    pub fn dest_window(&self) -> Window {
        unsafe { from_glib_none(ffi::gdk_drag_context_get_dest_window(self.to_glib_none().0)) }
    }

    /// Returns the [`Device`][crate::Device] associated to the drag context.
    ///
    /// # Returns
    ///
    /// The [`Device`][crate::Device] associated to `self`.
    #[doc(alias = "gdk_drag_context_get_device")]
    #[doc(alias = "get_device")]
    pub fn device(&self) -> Device {
        unsafe { from_glib_none(ffi::gdk_drag_context_get_device(self.to_glib_none().0)) }
    }

    /// Returns the window on which the drag icon should be rendered
    /// during the drag operation. Note that the window may not be
    /// available until the drag operation has begun. GDK will move
    /// the window in accordance with the ongoing drag operation.
    /// The window is owned by `self` and will be destroyed when
    /// the drag operation is over.
    ///
    /// # Returns
    ///
    /// the drag window, or [`None`]
    #[doc(alias = "gdk_drag_context_get_drag_window")]
    #[doc(alias = "get_drag_window")]
    pub fn drag_window(&self) -> Option<Window> {
        unsafe { from_glib_none(ffi::gdk_drag_context_get_drag_window(self.to_glib_none().0)) }
    }

    /// Returns the drag protocol that is used by this context.
    ///
    /// # Returns
    ///
    /// the drag protocol
    #[doc(alias = "gdk_drag_context_get_protocol")]
    #[doc(alias = "get_protocol")]
    pub fn protocol(&self) -> DragProtocol {
        unsafe { from_glib(ffi::gdk_drag_context_get_protocol(self.to_glib_none().0)) }
    }

    /// Determines the action chosen by the drag destination.
    ///
    /// # Returns
    ///
    /// a [`DragAction`][crate::DragAction] value
    #[doc(alias = "gdk_drag_context_get_selected_action")]
    #[doc(alias = "get_selected_action")]
    pub fn selected_action(&self) -> DragAction {
        unsafe {
            from_glib(ffi::gdk_drag_context_get_selected_action(
                self.to_glib_none().0,
            ))
        }
    }

    /// Returns the [`Window`][crate::Window] where the DND operation started.
    ///
    /// # Returns
    ///
    /// a [`Window`][crate::Window]
    #[doc(alias = "gdk_drag_context_get_source_window")]
    #[doc(alias = "get_source_window")]
    pub fn source_window(&self) -> Window {
        unsafe {
            from_glib_none(ffi::gdk_drag_context_get_source_window(
                self.to_glib_none().0,
            ))
        }
    }

    /// Determines the suggested drag action of the context.
    ///
    /// # Returns
    ///
    /// a [`DragAction`][crate::DragAction] value
    #[doc(alias = "gdk_drag_context_get_suggested_action")]
    #[doc(alias = "get_suggested_action")]
    pub fn suggested_action(&self) -> DragAction {
        unsafe {
            from_glib(ffi::gdk_drag_context_get_suggested_action(
                self.to_glib_none().0,
            ))
        }
    }

    /// Retrieves the list of targets of the context.
    ///
    /// # Returns
    ///
    /// a `GList` of targets
    #[doc(alias = "gdk_drag_context_list_targets")]
    pub fn list_targets(&self) -> Vec<Atom> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::gdk_drag_context_list_targets(
                self.to_glib_none().0,
            ))
        }
    }

    /// Requests the drag and drop operation to be managed by `self`.
    /// When a drag and drop operation becomes managed, the [`DragContext`][crate::DragContext]
    /// will internally handle all input and source-side [`EventDND`][crate::EventDND] events
    /// as required by the windowing system.
    ///
    /// Once the drag and drop operation is managed, the drag context will
    /// emit the following signals:
    /// - The [`action-changed`][struct@crate::DragContext#action-changed] signal whenever the final action
    ///  to be performed by the drag and drop operation changes.
    /// - The [`drop-performed`][struct@crate::DragContext#drop-performed] signal after the user performs
    ///  the drag and drop gesture (typically by releasing the mouse button).
    /// - The [`dnd-finished`][struct@crate::DragContext#dnd-finished] signal after the drag and drop
    ///  operation concludes (after all `GdkSelection` transfers happen).
    /// - The [`cancel`][struct@crate::DragContext#cancel] signal if the drag and drop operation is
    ///  finished but doesn't happen over an accepting destination, or is
    ///  cancelled through other means.
    /// ## `ipc_window`
    /// Window to use for IPC messaging/events
    /// ## `actions`
    /// the actions supported by the drag source
    ///
    /// # Returns
    ///
    /// [`true`] if the drag and drop operation is managed.
    #[doc(alias = "gdk_drag_context_manage_dnd")]
    pub fn manage_dnd(&self, ipc_window: &Window, actions: DragAction) -> bool {
        unsafe {
            from_glib(ffi::gdk_drag_context_manage_dnd(
                self.to_glib_none().0,
                ipc_window.to_glib_none().0,
                actions.into_glib(),
            ))
        }
    }

    /// Associates a [`Device`][crate::Device] to `self`, so all Drag and Drop events
    /// for `self` are emitted as if they came from this device.
    /// ## `device`
    /// a [`Device`][crate::Device]
    #[doc(alias = "gdk_drag_context_set_device")]
    pub fn set_device(&self, device: &impl IsA<Device>) {
        unsafe {
            ffi::gdk_drag_context_set_device(
                self.to_glib_none().0,
                device.as_ref().to_glib_none().0,
            );
        }
    }

    /// Sets the position of the drag window that will be kept
    /// under the cursor hotspot. Initially, the hotspot is at the
    /// top left corner of the drag window.
    /// ## `hot_x`
    /// x coordinate of the drag window hotspot
    /// ## `hot_y`
    /// y coordinate of the drag window hotspot
    #[doc(alias = "gdk_drag_context_set_hotspot")]
    pub fn set_hotspot(&self, hot_x: i32, hot_y: i32) {
        unsafe {
            ffi::gdk_drag_context_set_hotspot(self.to_glib_none().0, hot_x, hot_y);
        }
    }

    /// A new action is being chosen for the drag and drop operation.
    ///
    /// This signal will only be emitted if the [`DragContext`][crate::DragContext] manages
    /// the drag and drop operation. See [`manage_dnd()`][Self::manage_dnd()]
    /// for more information.
    /// ## `action`
    /// The action currently chosen
    #[doc(alias = "action-changed")]
    pub fn connect_action_changed<F: Fn(&Self, DragAction) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn action_changed_trampoline<
            F: Fn(&DragContext, DragAction) + 'static,
        >(
            this: *mut ffi::GdkDragContext,
            action: ffi::GdkDragAction,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this), from_glib(action))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"action-changed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    action_changed_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The drag and drop operation was cancelled.
    ///
    /// This signal will only be emitted if the [`DragContext`][crate::DragContext] manages
    /// the drag and drop operation. See [`manage_dnd()`][Self::manage_dnd()]
    /// for more information.
    /// ## `reason`
    /// The reason the context was cancelled
    #[doc(alias = "cancel")]
    pub fn connect_cancel<F: Fn(&Self, DragCancelReason) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn cancel_trampoline<F: Fn(&DragContext, DragCancelReason) + 'static>(
            this: *mut ffi::GdkDragContext,
            reason: ffi::GdkDragCancelReason,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this), from_glib(reason))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"cancel".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    cancel_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The drag and drop operation was finished, the drag destination
    /// finished reading all data. The drag source can now free all
    /// miscellaneous data.
    ///
    /// This signal will only be emitted if the [`DragContext`][crate::DragContext] manages
    /// the drag and drop operation. See [`manage_dnd()`][Self::manage_dnd()]
    /// for more information.
    #[doc(alias = "dnd-finished")]
    pub fn connect_dnd_finished<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn dnd_finished_trampoline<F: Fn(&DragContext) + 'static>(
            this: *mut ffi::GdkDragContext,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"dnd-finished".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    dnd_finished_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The drag and drop operation was performed on an accepting client.
    ///
    /// This signal will only be emitted if the [`DragContext`][crate::DragContext] manages
    /// the drag and drop operation. See [`manage_dnd()`][Self::manage_dnd()]
    /// for more information.
    /// ## `time`
    /// the time at which the drop happened.
    #[doc(alias = "drop-performed")]
    pub fn connect_drop_performed<F: Fn(&Self, i32) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn drop_performed_trampoline<F: Fn(&DragContext, i32) + 'static>(
            this: *mut ffi::GdkDragContext,
            time: std::ffi::c_int,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this), time)
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"drop-performed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    drop_performed_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}