// 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::ContentFormats;
use crate::Device;
use crate::Display;
use crate::Drag;
use crate::DragAction;
use crate::Surface;
use glib::object::IsA;
use glib::object::ObjectType as ObjectType_;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;
use std::pin::Pin;
use std::ptr;

glib::wrapper! {
    /// The [`Drop`][crate::Drop] object represents the target of an ongoing DND operation.
    ///
    /// Possible drop sites get informed about the status of the ongoing drag
    /// operation with events of type [`EventType::DragEnter`][crate::EventType::DragEnter], [`EventType::DragLeave`][crate::EventType::DragLeave],
    /// [`EventType::DragMotion`][crate::EventType::DragMotion] and [`EventType::DropStart`][crate::EventType::DropStart]. The [`Drop`][crate::Drop] object can be obtained
    /// from these [`Event`][crate::Event] types using [`DNDEvent::drop()`][crate::DNDEvent::drop()].
    ///
    /// The actual data transfer is initiated from the target side via an async
    /// read, using one of the [`Drop`][crate::Drop] methods for this purpose:
    /// [`read_async()`][Self::read_async()] or [`read_value_async()`][Self::read_value_async()].
    ///
    /// GTK provides a higher level abstraction based on top of these functions,
    /// and so they are not normally needed in GTK applications. See the
    /// "Drag and Drop" section of the GTK documentation for more information.
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    #[doc(alias = "GdkDrop")]
    pub struct Drop(Object<ffi::GdkDrop>);

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

impl Drop {
    /// Ends the drag operation after a drop.
    ///
    /// The @action must be a single action selected from the actions
    /// available via [`actions()`][Self::actions()].
    /// ## `action`
    /// the action performed by the destination or 0 if the drop failed
    #[doc(alias = "gdk_drop_finish")]
    pub fn finish(&self, action: DragAction) {
        unsafe {
            ffi::gdk_drop_finish(self.to_glib_none().0, action.into_glib());
        }
    }

    /// Returns the possible actions for this [`Drop`][crate::Drop].
    ///
    /// If this value contains multiple actions - i.e.
    /// [`DragAction::is_unique()`][crate::DragAction::is_unique()] returns [`false`] for the result -
    /// [`finish()`][Self::finish()] must choose the action to use when
    /// accepting the drop. This will only happen if you passed
    /// [`DragAction::ASK`][crate::DragAction::ASK] as one of the possible actions in
    /// [`status()`][Self::status()]. [`DragAction::ASK`][crate::DragAction::ASK] itself will not
    /// be included in the actions returned by this function.
    ///
    /// This value may change over the lifetime of the [`Drop`][crate::Drop]
    /// both as a response to source side actions as well as to calls to
    /// [`status()`][Self::status()] or [`finish()`][Self::finish()]. The source
    /// side will not change this value anymore once a drop has started.
    ///
    /// # Returns
    ///
    /// The possible `GdkDragActions`
    #[doc(alias = "gdk_drop_get_actions")]
    #[doc(alias = "get_actions")]
    pub fn actions(&self) -> DragAction {
        unsafe { from_glib(ffi::gdk_drop_get_actions(self.to_glib_none().0)) }
    }

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

    /// Gets the [`Display`][crate::Display] that @self was created for.
    ///
    /// # Returns
    ///
    /// a [`Display`][crate::Display]
    #[doc(alias = "gdk_drop_get_display")]
    #[doc(alias = "get_display")]
    pub fn display(&self) -> Display {
        unsafe { from_glib_none(ffi::gdk_drop_get_display(self.to_glib_none().0)) }
    }

    /// If this is an in-app drag-and-drop operation, returns the [`Drag`][crate::Drag]
    /// that corresponds to this drop.
    ///
    /// If it is not, [`None`] is returned.
    ///
    /// # Returns
    ///
    /// the corresponding [`Drag`][crate::Drag]
    #[doc(alias = "gdk_drop_get_drag")]
    #[doc(alias = "get_drag")]
    pub fn drag(&self) -> Option<Drag> {
        unsafe { from_glib_none(ffi::gdk_drop_get_drag(self.to_glib_none().0)) }
    }

    /// Returns the [`ContentFormats`][crate::ContentFormats] that the drop offers the data
    /// to be read in.
    ///
    /// # Returns
    ///
    /// The possible [`ContentFormats`][crate::ContentFormats]
    #[doc(alias = "gdk_drop_get_formats")]
    #[doc(alias = "get_formats")]
    pub fn formats(&self) -> ContentFormats {
        unsafe { from_glib_none(ffi::gdk_drop_get_formats(self.to_glib_none().0)) }
    }

    /// Returns the [`Surface`][crate::Surface] performing the drop.
    ///
    /// # Returns
    ///
    /// The [`Surface`][crate::Surface] performing the drop.
    #[doc(alias = "gdk_drop_get_surface")]
    #[doc(alias = "get_surface")]
    pub fn surface(&self) -> Surface {
        unsafe { from_glib_none(ffi::gdk_drop_get_surface(self.to_glib_none().0)) }
    }

    /// Asynchronously request the drag operation's contents converted
    /// to the given @type_.
    ///
    /// When the operation is finished @callback will be called. You must
    /// then call `Gdk::Drop::read_value_finish()` to get the resulting
    /// `GValue`.
    ///
    /// For local drag-and-drop operations that are available in the given
    /// `GType`, the value will be copied directly. Otherwise, GDK will
    /// try to use [`content_deserialize_async()`][crate::content_deserialize_async()] to convert the data.
    /// ## `type_`
    /// a `GType` to read
    /// ## `io_priority`
    /// the I/O priority of the request.
    /// ## `cancellable`
    /// optional `GCancellable` object, [`None`] to ignore.
    /// ## `callback`
    /// callback to call when the request is satisfied
    #[doc(alias = "gdk_drop_read_value_async")]
    pub fn read_value_async<P: FnOnce(Result<glib::Value, glib::Error>) + 'static>(
        &self,
        type_: glib::types::Type,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<gio::Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn read_value_async_trampoline<
            P: FnOnce(Result<glib::Value, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let ret = ffi::gdk_drop_read_value_finish(_source_object as *mut _, res, &mut error);
            let result = if error.is_null() {
                Ok(from_glib_none(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = read_value_async_trampoline::<P>;
        unsafe {
            ffi::gdk_drop_read_value_async(
                self.to_glib_none().0,
                type_.into_glib(),
                io_priority.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn read_value_future(
        &self,
        type_: glib::types::Type,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<glib::Value, glib::Error>> + 'static>>
    {
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.read_value_async(type_, io_priority, Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    /// Selects all actions that are potentially supported by the destination.
    ///
    /// When calling this function, do not restrict the passed in actions to
    /// the ones provided by [`actions()`][Self::actions()]. Those actions may
    /// change in the future, even depending on the actions you provide here.
    ///
    /// The @preferred action is a hint to the drag-and-drop mechanism about which
    /// action to use when multiple actions are possible.
    ///
    /// This function should be called by drag destinations in response to
    /// [`EventType::DragEnter`][crate::EventType::DragEnter] or [`EventType::DragMotion`][crate::EventType::DragMotion] events. If the destination does
    /// not yet know the exact actions it supports, it should set any possible
    /// actions first and then later call this function again.
    /// ## `actions`
    /// Supported actions of the destination, or 0 to indicate
    ///    that a drop will not be accepted
    /// ## `preferred`
    /// A unique action that's a member of @actions indicating the
    ///    preferred action
    #[doc(alias = "gdk_drop_status")]
    pub fn status(&self, actions: DragAction, preferred: DragAction) {
        unsafe {
            ffi::gdk_drop_status(
                self.to_glib_none().0,
                actions.into_glib(),
                preferred.into_glib(),
            );
        }
    }

    #[doc(alias = "display")]
    pub fn connect_display_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_display_trampoline<F: Fn(&Drop) + 'static>(
            this: *mut ffi::GdkDrop,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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 _,
                b"notify::display\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_display_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl fmt::Display for Drop {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("Drop")
    }
}