{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- @GtkDropTargetAsync@ 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 t'GI.Gtk.Objects.DropTarget.DropTarget', and you should only use
-- it if @GtkDropTarget@ doesn\'t provide all the features you need.
-- 
-- To use a @GtkDropTargetAsync@ to receive drops on a widget, you create
-- a @GtkDropTargetAsync@ object, configure which data formats and actions
-- you support, connect to its signals, and then attach it to the widget
-- with 'GI.Gtk.Objects.Widget.widgetAddController'.
-- 
-- During a drag operation, the first signal that a @GtkDropTargetAsync@
-- emits is [DropTargetAsync::accept]("GI.Gtk.Objects.DropTargetAsync#g:signal:accept"), which is meant to determine
-- whether the target is a possible drop site for the ongoing drop. The
-- default handler for the [accept](#g:signal: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
-- [DropTargetAsync::dragEnter]("GI.Gtk.Objects.DropTargetAsync#g:signal:dragEnter") signal, followed by
-- [DropTargetAsync::dragMotion]("GI.Gtk.Objects.DropTargetAsync#g:signal:dragMotion") signals as the pointer moves,
-- optionally a [DropTargetAsync::drop]("GI.Gtk.Objects.DropTargetAsync#g:signal:drop") signal when a drop happens,
-- and finally a [DropTargetAsync::dragLeave]("GI.Gtk.Objects.DropTargetAsync#g:signal:dragLeave") signal when the
-- pointer moves off the widget.
-- 
-- The [dragEnter](#g:signal:dragEnter) and [dragMotion](#g:signal:dragMotion) handler return a @GdkDragAction@
-- to update the status of the ongoing operation. The [drop](#g:signal: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
-- 'GI.Gdk.Objects.Drop.dropFinish'.
-- 
-- Between the [dragEnter](#g:signal:dragEnter) and [dragLeave](#g:signal:dragLeave) signals the widget is a
-- current drop target, and will receive the 'GI.Gtk.Flags.StateFlagsDropActive'
-- state, which can be used by themes to style the widget as a drop target.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Gtk.Objects.DropTargetAsync
    ( 

-- * Exported types
    DropTargetAsync(..)                     ,
    IsDropTargetAsync                       ,
    toDropTargetAsync                       ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [rejectDrop]("GI.Gtk.Objects.DropTargetAsync#g:method:rejectDrop"), [reset]("GI.Gtk.Objects.EventController#g:method:reset"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getActions]("GI.Gtk.Objects.DropTargetAsync#g:method:getActions"), [getCurrentEvent]("GI.Gtk.Objects.EventController#g:method:getCurrentEvent"), [getCurrentEventDevice]("GI.Gtk.Objects.EventController#g:method:getCurrentEventDevice"), [getCurrentEventState]("GI.Gtk.Objects.EventController#g:method:getCurrentEventState"), [getCurrentEventTime]("GI.Gtk.Objects.EventController#g:method:getCurrentEventTime"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getFormats]("GI.Gtk.Objects.DropTargetAsync#g:method:getFormats"), [getName]("GI.Gtk.Objects.EventController#g:method:getName"), [getPropagationLimit]("GI.Gtk.Objects.EventController#g:method:getPropagationLimit"), [getPropagationPhase]("GI.Gtk.Objects.EventController#g:method:getPropagationPhase"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getWidget]("GI.Gtk.Objects.EventController#g:method:getWidget").
-- 
-- ==== Setters
-- [setActions]("GI.Gtk.Objects.DropTargetAsync#g:method:setActions"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setFormats]("GI.Gtk.Objects.DropTargetAsync#g:method:setFormats"), [setName]("GI.Gtk.Objects.EventController#g:method:setName"), [setPropagationLimit]("GI.Gtk.Objects.EventController#g:method:setPropagationLimit"), [setPropagationPhase]("GI.Gtk.Objects.EventController#g:method:setPropagationPhase"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setStaticName]("GI.Gtk.Objects.EventController#g:method:setStaticName").

#if defined(ENABLE_OVERLOADING)
    ResolveDropTargetAsyncMethod            ,
#endif

-- ** getActions #method:getActions#

#if defined(ENABLE_OVERLOADING)
    DropTargetAsyncGetActionsMethodInfo     ,
#endif
    dropTargetAsyncGetActions               ,


-- ** getFormats #method:getFormats#

#if defined(ENABLE_OVERLOADING)
    DropTargetAsyncGetFormatsMethodInfo     ,
#endif
    dropTargetAsyncGetFormats               ,


-- ** new #method:new#

    dropTargetAsyncNew                      ,


-- ** rejectDrop #method:rejectDrop#

#if defined(ENABLE_OVERLOADING)
    DropTargetAsyncRejectDropMethodInfo     ,
#endif
    dropTargetAsyncRejectDrop               ,


-- ** setActions #method:setActions#

#if defined(ENABLE_OVERLOADING)
    DropTargetAsyncSetActionsMethodInfo     ,
#endif
    dropTargetAsyncSetActions               ,


-- ** setFormats #method:setFormats#

#if defined(ENABLE_OVERLOADING)
    DropTargetAsyncSetFormatsMethodInfo     ,
#endif
    dropTargetAsyncSetFormats               ,




 -- * Properties


-- ** actions #attr:actions#
-- | The @GdkDragActions@ that this drop target supports.

#if defined(ENABLE_OVERLOADING)
    DropTargetAsyncActionsPropertyInfo      ,
#endif
    constructDropTargetAsyncActions         ,
#if defined(ENABLE_OVERLOADING)
    dropTargetAsyncActions                  ,
#endif
    getDropTargetAsyncActions               ,
    setDropTargetAsyncActions               ,


-- ** formats #attr:formats#
-- | The @GdkContentFormats@ that determines the supported data formats.

#if defined(ENABLE_OVERLOADING)
    DropTargetAsyncFormatsPropertyInfo      ,
#endif
    clearDropTargetAsyncFormats             ,
    constructDropTargetAsyncFormats         ,
#if defined(ENABLE_OVERLOADING)
    dropTargetAsyncFormats                  ,
#endif
    getDropTargetAsyncFormats               ,
    setDropTargetAsyncFormats               ,




 -- * Signals


-- ** accept #signal:accept#

    DropTargetAsyncAcceptCallback           ,
#if defined(ENABLE_OVERLOADING)
    DropTargetAsyncAcceptSignalInfo         ,
#endif
    afterDropTargetAsyncAccept              ,
    onDropTargetAsyncAccept                 ,


-- ** dragEnter #signal:dragEnter#

    DropTargetAsyncDragEnterCallback        ,
#if defined(ENABLE_OVERLOADING)
    DropTargetAsyncDragEnterSignalInfo      ,
#endif
    afterDropTargetAsyncDragEnter           ,
    onDropTargetAsyncDragEnter              ,


-- ** dragLeave #signal:dragLeave#

    DropTargetAsyncDragLeaveCallback        ,
#if defined(ENABLE_OVERLOADING)
    DropTargetAsyncDragLeaveSignalInfo      ,
#endif
    afterDropTargetAsyncDragLeave           ,
    onDropTargetAsyncDragLeave              ,


-- ** dragMotion #signal:dragMotion#

    DropTargetAsyncDragMotionCallback       ,
#if defined(ENABLE_OVERLOADING)
    DropTargetAsyncDragMotionSignalInfo     ,
#endif
    afterDropTargetAsyncDragMotion          ,
    onDropTargetAsyncDragMotion             ,


-- ** drop #signal:drop#

    DropTargetAsyncDropCallback             ,
#if defined(ENABLE_OVERLOADING)
    DropTargetAsyncDropSignalInfo           ,
#endif
    afterDropTargetAsyncDrop                ,
    onDropTargetAsyncDrop                   ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Flags as Gdk.Flags
import qualified GI.Gdk.Objects.Drop as Gdk.Drop
import qualified GI.Gdk.Structs.ContentFormats as Gdk.ContentFormats
import {-# SOURCE #-} qualified GI.Gtk.Objects.EventController as Gtk.EventController

-- | Memory-managed wrapper type.
newtype DropTargetAsync = DropTargetAsync (SP.ManagedPtr DropTargetAsync)
    deriving (DropTargetAsync -> DropTargetAsync -> Bool
(DropTargetAsync -> DropTargetAsync -> Bool)
-> (DropTargetAsync -> DropTargetAsync -> Bool)
-> Eq DropTargetAsync
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DropTargetAsync -> DropTargetAsync -> Bool
== :: DropTargetAsync -> DropTargetAsync -> Bool
$c/= :: DropTargetAsync -> DropTargetAsync -> Bool
/= :: DropTargetAsync -> DropTargetAsync -> Bool
Eq)

instance SP.ManagedPtrNewtype DropTargetAsync where
    toManagedPtr :: DropTargetAsync -> ManagedPtr DropTargetAsync
toManagedPtr (DropTargetAsync ManagedPtr DropTargetAsync
p) = ManagedPtr DropTargetAsync
p

foreign import ccall "gtk_drop_target_async_get_type"
    c_gtk_drop_target_async_get_type :: IO B.Types.GType

instance B.Types.TypedObject DropTargetAsync where
    glibType :: IO GType
glibType = IO GType
c_gtk_drop_target_async_get_type

instance B.Types.GObject DropTargetAsync

-- | Type class for types which can be safely cast to `DropTargetAsync`, for instance with `toDropTargetAsync`.
class (SP.GObject o, O.IsDescendantOf DropTargetAsync o) => IsDropTargetAsync o
instance (SP.GObject o, O.IsDescendantOf DropTargetAsync o) => IsDropTargetAsync o

instance O.HasParentTypes DropTargetAsync
type instance O.ParentTypes DropTargetAsync = '[Gtk.EventController.EventController, GObject.Object.Object]

-- | Cast to `DropTargetAsync`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toDropTargetAsync :: (MIO.MonadIO m, IsDropTargetAsync o) => o -> m DropTargetAsync
toDropTargetAsync :: forall (m :: * -> *) o.
(MonadIO m, IsDropTargetAsync o) =>
o -> m DropTargetAsync
toDropTargetAsync = IO DropTargetAsync -> m DropTargetAsync
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO DropTargetAsync -> m DropTargetAsync)
-> (o -> IO DropTargetAsync) -> o -> m DropTargetAsync
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr DropTargetAsync -> DropTargetAsync)
-> o -> IO DropTargetAsync
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr DropTargetAsync -> DropTargetAsync
DropTargetAsync

-- | Convert 'DropTargetAsync' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe DropTargetAsync) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_drop_target_async_get_type
    gvalueSet_ :: Ptr GValue -> Maybe DropTargetAsync -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DropTargetAsync
P.Nothing = Ptr GValue -> Ptr DropTargetAsync -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr DropTargetAsync
forall a. Ptr a
FP.nullPtr :: FP.Ptr DropTargetAsync)
    gvalueSet_ Ptr GValue
gv (P.Just DropTargetAsync
obj) = DropTargetAsync -> (Ptr DropTargetAsync -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DropTargetAsync
obj (Ptr GValue -> Ptr DropTargetAsync -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe DropTargetAsync)
gvalueGet_ Ptr GValue
gv = do
        Ptr DropTargetAsync
ptr <- Ptr GValue -> IO (Ptr DropTargetAsync)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr DropTargetAsync)
        if Ptr DropTargetAsync
ptr Ptr DropTargetAsync -> Ptr DropTargetAsync -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr DropTargetAsync
forall a. Ptr a
FP.nullPtr
        then DropTargetAsync -> Maybe DropTargetAsync
forall a. a -> Maybe a
P.Just (DropTargetAsync -> Maybe DropTargetAsync)
-> IO DropTargetAsync -> IO (Maybe DropTargetAsync)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr DropTargetAsync -> DropTargetAsync)
-> Ptr DropTargetAsync -> IO DropTargetAsync
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr DropTargetAsync -> DropTargetAsync
DropTargetAsync Ptr DropTargetAsync
ptr
        else Maybe DropTargetAsync -> IO (Maybe DropTargetAsync)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DropTargetAsync
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveDropTargetAsyncMethod (t :: Symbol) (o :: *) :: * where
    ResolveDropTargetAsyncMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDropTargetAsyncMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDropTargetAsyncMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDropTargetAsyncMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDropTargetAsyncMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveDropTargetAsyncMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDropTargetAsyncMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDropTargetAsyncMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDropTargetAsyncMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDropTargetAsyncMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDropTargetAsyncMethod "rejectDrop" o = DropTargetAsyncRejectDropMethodInfo
    ResolveDropTargetAsyncMethod "reset" o = Gtk.EventController.EventControllerResetMethodInfo
    ResolveDropTargetAsyncMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDropTargetAsyncMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDropTargetAsyncMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDropTargetAsyncMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDropTargetAsyncMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDropTargetAsyncMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDropTargetAsyncMethod "getActions" o = DropTargetAsyncGetActionsMethodInfo
    ResolveDropTargetAsyncMethod "getCurrentEvent" o = Gtk.EventController.EventControllerGetCurrentEventMethodInfo
    ResolveDropTargetAsyncMethod "getCurrentEventDevice" o = Gtk.EventController.EventControllerGetCurrentEventDeviceMethodInfo
    ResolveDropTargetAsyncMethod "getCurrentEventState" o = Gtk.EventController.EventControllerGetCurrentEventStateMethodInfo
    ResolveDropTargetAsyncMethod "getCurrentEventTime" o = Gtk.EventController.EventControllerGetCurrentEventTimeMethodInfo
    ResolveDropTargetAsyncMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDropTargetAsyncMethod "getFormats" o = DropTargetAsyncGetFormatsMethodInfo
    ResolveDropTargetAsyncMethod "getName" o = Gtk.EventController.EventControllerGetNameMethodInfo
    ResolveDropTargetAsyncMethod "getPropagationLimit" o = Gtk.EventController.EventControllerGetPropagationLimitMethodInfo
    ResolveDropTargetAsyncMethod "getPropagationPhase" o = Gtk.EventController.EventControllerGetPropagationPhaseMethodInfo
    ResolveDropTargetAsyncMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDropTargetAsyncMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDropTargetAsyncMethod "getWidget" o = Gtk.EventController.EventControllerGetWidgetMethodInfo
    ResolveDropTargetAsyncMethod "setActions" o = DropTargetAsyncSetActionsMethodInfo
    ResolveDropTargetAsyncMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDropTargetAsyncMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveDropTargetAsyncMethod "setFormats" o = DropTargetAsyncSetFormatsMethodInfo
    ResolveDropTargetAsyncMethod "setName" o = Gtk.EventController.EventControllerSetNameMethodInfo
    ResolveDropTargetAsyncMethod "setPropagationLimit" o = Gtk.EventController.EventControllerSetPropagationLimitMethodInfo
    ResolveDropTargetAsyncMethod "setPropagationPhase" o = Gtk.EventController.EventControllerSetPropagationPhaseMethodInfo
    ResolveDropTargetAsyncMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDropTargetAsyncMethod "setStaticName" o = Gtk.EventController.EventControllerSetStaticNameMethodInfo
    ResolveDropTargetAsyncMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveDropTargetAsyncMethod t DropTargetAsync, O.OverloadedMethod info DropTargetAsync p) => OL.IsLabel t (DropTargetAsync -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveDropTargetAsyncMethod t DropTargetAsync, O.OverloadedMethod info DropTargetAsync p, R.HasField t DropTargetAsync p) => R.HasField t DropTargetAsync p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveDropTargetAsyncMethod t DropTargetAsync, O.OverloadedMethodInfo info DropTargetAsync) => OL.IsLabel t (O.MethodProxy info DropTargetAsync) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- signal DropTargetAsync::accept
-- | Emitted on the drop site when a drop operation is about to begin.
-- 
-- If the drop is not accepted, 'P.False' will be returned and the drop target
-- will ignore the drop. If 'P.True' is returned, the drop is accepted for now
-- but may be rejected later via a call to 'GI.Gtk.Objects.DropTargetAsync.dropTargetAsyncRejectDrop'
-- or ultimately by returning 'P.False' from a [DropTargetAsync::drop]("GI.Gtk.Objects.DropTargetAsync#g:signal: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 'P.True' and proceed as is /@drop@/ was accepted and if it decides to
-- reject the drop later, it should call 'GI.Gtk.Objects.DropTargetAsync.dropTargetAsyncRejectDrop'.
type DropTargetAsyncAcceptCallback =
    Gdk.Drop.Drop
    -- ^ /@drop@/: the @GdkDrop@
    -> IO Bool
    -- ^ __Returns:__ 'P.True' if /@drop@/ is accepted

type C_DropTargetAsyncAcceptCallback =
    Ptr DropTargetAsync ->                  -- object
    Ptr Gdk.Drop.Drop ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_DropTargetAsyncAcceptCallback`.
foreign import ccall "wrapper"
    mk_DropTargetAsyncAcceptCallback :: C_DropTargetAsyncAcceptCallback -> IO (FunPtr C_DropTargetAsyncAcceptCallback)

wrap_DropTargetAsyncAcceptCallback :: 
    GObject a => (a -> DropTargetAsyncAcceptCallback) ->
    C_DropTargetAsyncAcceptCallback
wrap_DropTargetAsyncAcceptCallback :: forall a.
GObject a =>
(a -> DropTargetAsyncAcceptCallback)
-> C_DropTargetAsyncAcceptCallback
wrap_DropTargetAsyncAcceptCallback a -> DropTargetAsyncAcceptCallback
gi'cb Ptr DropTargetAsync
gi'selfPtr Ptr Drop
drop Ptr ()
_ = do
    Drop
drop' <- ((ManagedPtr Drop -> Drop) -> Ptr Drop -> IO Drop
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Drop -> Drop
Gdk.Drop.Drop) Ptr Drop
drop
    Bool
result <- Ptr DropTargetAsync -> (DropTargetAsync -> IO Bool) -> IO Bool
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr DropTargetAsync
gi'selfPtr ((DropTargetAsync -> IO Bool) -> IO Bool)
-> (DropTargetAsync -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \DropTargetAsync
gi'self -> a -> DropTargetAsyncAcceptCallback
gi'cb (DropTargetAsync -> a
forall a b. Coercible a b => a -> b
Coerce.coerce DropTargetAsync
gi'self)  Drop
drop'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [accept](#signal:accept) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' dropTargetAsync #accept callback
-- @
-- 
-- 
onDropTargetAsyncAccept :: (IsDropTargetAsync a, MonadIO m) => a -> ((?self :: a) => DropTargetAsyncAcceptCallback) -> m SignalHandlerId
onDropTargetAsyncAccept :: forall a (m :: * -> *).
(IsDropTargetAsync a, MonadIO m) =>
a
-> ((?self::a) => DropTargetAsyncAcceptCallback)
-> m SignalHandlerId
onDropTargetAsyncAccept a
obj (?self::a) => DropTargetAsyncAcceptCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> DropTargetAsyncAcceptCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DropTargetAsyncAcceptCallback
DropTargetAsyncAcceptCallback
cb
    let wrapped' :: C_DropTargetAsyncAcceptCallback
wrapped' = (a -> DropTargetAsyncAcceptCallback)
-> C_DropTargetAsyncAcceptCallback
forall a.
GObject a =>
(a -> DropTargetAsyncAcceptCallback)
-> C_DropTargetAsyncAcceptCallback
wrap_DropTargetAsyncAcceptCallback a -> DropTargetAsyncAcceptCallback
wrapped
    FunPtr C_DropTargetAsyncAcceptCallback
wrapped'' <- C_DropTargetAsyncAcceptCallback
-> IO (FunPtr C_DropTargetAsyncAcceptCallback)
mk_DropTargetAsyncAcceptCallback C_DropTargetAsyncAcceptCallback
wrapped'
    a
-> Text
-> FunPtr C_DropTargetAsyncAcceptCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"accept" FunPtr C_DropTargetAsyncAcceptCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [accept](#signal:accept) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' dropTargetAsync #accept callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterDropTargetAsyncAccept :: (IsDropTargetAsync a, MonadIO m) => a -> ((?self :: a) => DropTargetAsyncAcceptCallback) -> m SignalHandlerId
afterDropTargetAsyncAccept :: forall a (m :: * -> *).
(IsDropTargetAsync a, MonadIO m) =>
a
-> ((?self::a) => DropTargetAsyncAcceptCallback)
-> m SignalHandlerId
afterDropTargetAsyncAccept a
obj (?self::a) => DropTargetAsyncAcceptCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> DropTargetAsyncAcceptCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DropTargetAsyncAcceptCallback
DropTargetAsyncAcceptCallback
cb
    let wrapped' :: C_DropTargetAsyncAcceptCallback
wrapped' = (a -> DropTargetAsyncAcceptCallback)
-> C_DropTargetAsyncAcceptCallback
forall a.
GObject a =>
(a -> DropTargetAsyncAcceptCallback)
-> C_DropTargetAsyncAcceptCallback
wrap_DropTargetAsyncAcceptCallback a -> DropTargetAsyncAcceptCallback
wrapped
    FunPtr C_DropTargetAsyncAcceptCallback
wrapped'' <- C_DropTargetAsyncAcceptCallback
-> IO (FunPtr C_DropTargetAsyncAcceptCallback)
mk_DropTargetAsyncAcceptCallback C_DropTargetAsyncAcceptCallback
wrapped'
    a
-> Text
-> FunPtr C_DropTargetAsyncAcceptCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"accept" FunPtr C_DropTargetAsyncAcceptCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data DropTargetAsyncAcceptSignalInfo
instance SignalInfo DropTargetAsyncAcceptSignalInfo where
    type HaskellCallbackType DropTargetAsyncAcceptSignalInfo = DropTargetAsyncAcceptCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_DropTargetAsyncAcceptCallback cb
        cb'' <- mk_DropTargetAsyncAcceptCallback cb'
        connectSignalFunPtr obj "accept" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.DropTargetAsync::accept"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-DropTargetAsync.html#g:signal:accept"})

#endif

-- signal DropTargetAsync::drag-enter
-- | Emitted on the drop site when the pointer enters the widget.
-- 
-- It can be used to set up custom highlighting.
type DropTargetAsyncDragEnterCallback =
    Gdk.Drop.Drop
    -- ^ /@drop@/: the @GdkDrop@
    -> Double
    -- ^ /@x@/: the x coordinate of the current pointer position
    -> Double
    -- ^ /@y@/: the y coordinate of the current pointer position
    -> IO [Gdk.Flags.DragAction]
    -- ^ __Returns:__ Preferred action for this drag operation.

type C_DropTargetAsyncDragEnterCallback =
    Ptr DropTargetAsync ->                  -- object
    Ptr Gdk.Drop.Drop ->
    CDouble ->
    CDouble ->
    Ptr () ->                               -- user_data
    IO CUInt

-- | Generate a function pointer callable from C code, from a `C_DropTargetAsyncDragEnterCallback`.
foreign import ccall "wrapper"
    mk_DropTargetAsyncDragEnterCallback :: C_DropTargetAsyncDragEnterCallback -> IO (FunPtr C_DropTargetAsyncDragEnterCallback)

wrap_DropTargetAsyncDragEnterCallback :: 
    GObject a => (a -> DropTargetAsyncDragEnterCallback) ->
    C_DropTargetAsyncDragEnterCallback
wrap_DropTargetAsyncDragEnterCallback :: forall a.
GObject a =>
(a -> DropTargetAsyncDragEnterCallback)
-> C_DropTargetAsyncDragEnterCallback
wrap_DropTargetAsyncDragEnterCallback a -> DropTargetAsyncDragEnterCallback
gi'cb Ptr DropTargetAsync
gi'selfPtr Ptr Drop
drop CDouble
x CDouble
y Ptr ()
_ = do
    Drop
drop' <- ((ManagedPtr Drop -> Drop) -> Ptr Drop -> IO Drop
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Drop -> Drop
Gdk.Drop.Drop) Ptr Drop
drop
    let x' :: Double
x' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
x
    let y' :: Double
y' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
y
    [DragAction]
result <- Ptr DropTargetAsync
-> (DropTargetAsync -> IO [DragAction]) -> IO [DragAction]
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr DropTargetAsync
gi'selfPtr ((DropTargetAsync -> IO [DragAction]) -> IO [DragAction])
-> (DropTargetAsync -> IO [DragAction]) -> IO [DragAction]
forall a b. (a -> b) -> a -> b
$ \DropTargetAsync
gi'self -> a -> DropTargetAsyncDragEnterCallback
gi'cb (DropTargetAsync -> a
forall a b. Coercible a b => a -> b
Coerce.coerce DropTargetAsync
gi'self)  Drop
drop' Double
x' Double
y'
    let result' :: CUInt
result' = [DragAction] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [DragAction]
result
    CUInt -> IO CUInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CUInt
result'


-- | Connect a signal handler for the [dragEnter](#signal:dragEnter) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' dropTargetAsync #dragEnter callback
-- @
-- 
-- 
onDropTargetAsyncDragEnter :: (IsDropTargetAsync a, MonadIO m) => a -> ((?self :: a) => DropTargetAsyncDragEnterCallback) -> m SignalHandlerId
onDropTargetAsyncDragEnter :: forall a (m :: * -> *).
(IsDropTargetAsync a, MonadIO m) =>
a
-> ((?self::a) => DropTargetAsyncDragEnterCallback)
-> m SignalHandlerId
onDropTargetAsyncDragEnter a
obj (?self::a) => DropTargetAsyncDragEnterCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> DropTargetAsyncDragEnterCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DropTargetAsyncDragEnterCallback
DropTargetAsyncDragEnterCallback
cb
    let wrapped' :: C_DropTargetAsyncDragEnterCallback
wrapped' = (a -> DropTargetAsyncDragEnterCallback)
-> C_DropTargetAsyncDragEnterCallback
forall a.
GObject a =>
(a -> DropTargetAsyncDragEnterCallback)
-> C_DropTargetAsyncDragEnterCallback
wrap_DropTargetAsyncDragEnterCallback a -> DropTargetAsyncDragEnterCallback
wrapped
    FunPtr C_DropTargetAsyncDragEnterCallback
wrapped'' <- C_DropTargetAsyncDragEnterCallback
-> IO (FunPtr C_DropTargetAsyncDragEnterCallback)
mk_DropTargetAsyncDragEnterCallback C_DropTargetAsyncDragEnterCallback
wrapped'
    a
-> Text
-> FunPtr C_DropTargetAsyncDragEnterCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drag-enter" FunPtr C_DropTargetAsyncDragEnterCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [dragEnter](#signal:dragEnter) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' dropTargetAsync #dragEnter callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterDropTargetAsyncDragEnter :: (IsDropTargetAsync a, MonadIO m) => a -> ((?self :: a) => DropTargetAsyncDragEnterCallback) -> m SignalHandlerId
afterDropTargetAsyncDragEnter :: forall a (m :: * -> *).
(IsDropTargetAsync a, MonadIO m) =>
a
-> ((?self::a) => DropTargetAsyncDragEnterCallback)
-> m SignalHandlerId
afterDropTargetAsyncDragEnter a
obj (?self::a) => DropTargetAsyncDragEnterCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> DropTargetAsyncDragEnterCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DropTargetAsyncDragEnterCallback
DropTargetAsyncDragEnterCallback
cb
    let wrapped' :: C_DropTargetAsyncDragEnterCallback
wrapped' = (a -> DropTargetAsyncDragEnterCallback)
-> C_DropTargetAsyncDragEnterCallback
forall a.
GObject a =>
(a -> DropTargetAsyncDragEnterCallback)
-> C_DropTargetAsyncDragEnterCallback
wrap_DropTargetAsyncDragEnterCallback a -> DropTargetAsyncDragEnterCallback
wrapped
    FunPtr C_DropTargetAsyncDragEnterCallback
wrapped'' <- C_DropTargetAsyncDragEnterCallback
-> IO (FunPtr C_DropTargetAsyncDragEnterCallback)
mk_DropTargetAsyncDragEnterCallback C_DropTargetAsyncDragEnterCallback
wrapped'
    a
-> Text
-> FunPtr C_DropTargetAsyncDragEnterCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drag-enter" FunPtr C_DropTargetAsyncDragEnterCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data DropTargetAsyncDragEnterSignalInfo
instance SignalInfo DropTargetAsyncDragEnterSignalInfo where
    type HaskellCallbackType DropTargetAsyncDragEnterSignalInfo = DropTargetAsyncDragEnterCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_DropTargetAsyncDragEnterCallback cb
        cb'' <- mk_DropTargetAsyncDragEnterCallback cb'
        connectSignalFunPtr obj "drag-enter" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.DropTargetAsync::drag-enter"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-DropTargetAsync.html#g:signal:dragEnter"})

#endif

-- signal DropTargetAsync::drag-leave
-- | Emitted on the drop site when the pointer leaves the widget.
-- 
-- Its main purpose it to undo things done in
-- @GtkDropTargetAsync@[dragEnter](#g:signal:dragEnter).
type DropTargetAsyncDragLeaveCallback =
    Gdk.Drop.Drop
    -- ^ /@drop@/: the @GdkDrop@
    -> IO ()

type C_DropTargetAsyncDragLeaveCallback =
    Ptr DropTargetAsync ->                  -- object
    Ptr Gdk.Drop.Drop ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_DropTargetAsyncDragLeaveCallback`.
foreign import ccall "wrapper"
    mk_DropTargetAsyncDragLeaveCallback :: C_DropTargetAsyncDragLeaveCallback -> IO (FunPtr C_DropTargetAsyncDragLeaveCallback)

wrap_DropTargetAsyncDragLeaveCallback :: 
    GObject a => (a -> DropTargetAsyncDragLeaveCallback) ->
    C_DropTargetAsyncDragLeaveCallback
wrap_DropTargetAsyncDragLeaveCallback :: forall a.
GObject a =>
(a -> DropTargetAsyncDragLeaveCallback)
-> C_DropTargetAsyncDragLeaveCallback
wrap_DropTargetAsyncDragLeaveCallback a -> DropTargetAsyncDragLeaveCallback
gi'cb Ptr DropTargetAsync
gi'selfPtr Ptr Drop
drop Ptr ()
_ = do
    Drop
drop' <- ((ManagedPtr Drop -> Drop) -> Ptr Drop -> IO Drop
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Drop -> Drop
Gdk.Drop.Drop) Ptr Drop
drop
    Ptr DropTargetAsync -> (DropTargetAsync -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr DropTargetAsync
gi'selfPtr ((DropTargetAsync -> IO ()) -> IO ())
-> (DropTargetAsync -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \DropTargetAsync
gi'self -> a -> DropTargetAsyncDragLeaveCallback
gi'cb (DropTargetAsync -> a
forall a b. Coercible a b => a -> b
Coerce.coerce DropTargetAsync
gi'self)  Drop
drop'


-- | Connect a signal handler for the [dragLeave](#signal:dragLeave) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' dropTargetAsync #dragLeave callback
-- @
-- 
-- 
onDropTargetAsyncDragLeave :: (IsDropTargetAsync a, MonadIO m) => a -> ((?self :: a) => DropTargetAsyncDragLeaveCallback) -> m SignalHandlerId
onDropTargetAsyncDragLeave :: forall a (m :: * -> *).
(IsDropTargetAsync a, MonadIO m) =>
a
-> ((?self::a) => DropTargetAsyncDragLeaveCallback)
-> m SignalHandlerId
onDropTargetAsyncDragLeave a
obj (?self::a) => DropTargetAsyncDragLeaveCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> DropTargetAsyncDragLeaveCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DropTargetAsyncDragLeaveCallback
DropTargetAsyncDragLeaveCallback
cb
    let wrapped' :: C_DropTargetAsyncDragLeaveCallback
wrapped' = (a -> DropTargetAsyncDragLeaveCallback)
-> C_DropTargetAsyncDragLeaveCallback
forall a.
GObject a =>
(a -> DropTargetAsyncDragLeaveCallback)
-> C_DropTargetAsyncDragLeaveCallback
wrap_DropTargetAsyncDragLeaveCallback a -> DropTargetAsyncDragLeaveCallback
wrapped
    FunPtr C_DropTargetAsyncDragLeaveCallback
wrapped'' <- C_DropTargetAsyncDragLeaveCallback
-> IO (FunPtr C_DropTargetAsyncDragLeaveCallback)
mk_DropTargetAsyncDragLeaveCallback C_DropTargetAsyncDragLeaveCallback
wrapped'
    a
-> Text
-> FunPtr C_DropTargetAsyncDragLeaveCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drag-leave" FunPtr C_DropTargetAsyncDragLeaveCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [dragLeave](#signal:dragLeave) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' dropTargetAsync #dragLeave callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterDropTargetAsyncDragLeave :: (IsDropTargetAsync a, MonadIO m) => a -> ((?self :: a) => DropTargetAsyncDragLeaveCallback) -> m SignalHandlerId
afterDropTargetAsyncDragLeave :: forall a (m :: * -> *).
(IsDropTargetAsync a, MonadIO m) =>
a
-> ((?self::a) => DropTargetAsyncDragLeaveCallback)
-> m SignalHandlerId
afterDropTargetAsyncDragLeave a
obj (?self::a) => DropTargetAsyncDragLeaveCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> DropTargetAsyncDragLeaveCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DropTargetAsyncDragLeaveCallback
DropTargetAsyncDragLeaveCallback
cb
    let wrapped' :: C_DropTargetAsyncDragLeaveCallback
wrapped' = (a -> DropTargetAsyncDragLeaveCallback)
-> C_DropTargetAsyncDragLeaveCallback
forall a.
GObject a =>
(a -> DropTargetAsyncDragLeaveCallback)
-> C_DropTargetAsyncDragLeaveCallback
wrap_DropTargetAsyncDragLeaveCallback a -> DropTargetAsyncDragLeaveCallback
wrapped
    FunPtr C_DropTargetAsyncDragLeaveCallback
wrapped'' <- C_DropTargetAsyncDragLeaveCallback
-> IO (FunPtr C_DropTargetAsyncDragLeaveCallback)
mk_DropTargetAsyncDragLeaveCallback C_DropTargetAsyncDragLeaveCallback
wrapped'
    a
-> Text
-> FunPtr C_DropTargetAsyncDragLeaveCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drag-leave" FunPtr C_DropTargetAsyncDragLeaveCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data DropTargetAsyncDragLeaveSignalInfo
instance SignalInfo DropTargetAsyncDragLeaveSignalInfo where
    type HaskellCallbackType DropTargetAsyncDragLeaveSignalInfo = DropTargetAsyncDragLeaveCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_DropTargetAsyncDragLeaveCallback cb
        cb'' <- mk_DropTargetAsyncDragLeaveCallback cb'
        connectSignalFunPtr obj "drag-leave" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.DropTargetAsync::drag-leave"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-DropTargetAsync.html#g:signal:dragLeave"})

#endif

-- signal DropTargetAsync::drag-motion
-- | Emitted while the pointer is moving over the drop target.
type DropTargetAsyncDragMotionCallback =
    Gdk.Drop.Drop
    -- ^ /@drop@/: the @GdkDrop@
    -> Double
    -- ^ /@x@/: the x coordinate of the current pointer position
    -> Double
    -- ^ /@y@/: the y coordinate of the current pointer position
    -> IO [Gdk.Flags.DragAction]
    -- ^ __Returns:__ Preferred action for this drag operation.

type C_DropTargetAsyncDragMotionCallback =
    Ptr DropTargetAsync ->                  -- object
    Ptr Gdk.Drop.Drop ->
    CDouble ->
    CDouble ->
    Ptr () ->                               -- user_data
    IO CUInt

-- | Generate a function pointer callable from C code, from a `C_DropTargetAsyncDragMotionCallback`.
foreign import ccall "wrapper"
    mk_DropTargetAsyncDragMotionCallback :: C_DropTargetAsyncDragMotionCallback -> IO (FunPtr C_DropTargetAsyncDragMotionCallback)

wrap_DropTargetAsyncDragMotionCallback :: 
    GObject a => (a -> DropTargetAsyncDragMotionCallback) ->
    C_DropTargetAsyncDragMotionCallback
wrap_DropTargetAsyncDragMotionCallback :: forall a.
GObject a =>
(a -> DropTargetAsyncDragEnterCallback)
-> C_DropTargetAsyncDragEnterCallback
wrap_DropTargetAsyncDragMotionCallback a -> DropTargetAsyncDragEnterCallback
gi'cb Ptr DropTargetAsync
gi'selfPtr Ptr Drop
drop CDouble
x CDouble
y Ptr ()
_ = do
    Drop
drop' <- ((ManagedPtr Drop -> Drop) -> Ptr Drop -> IO Drop
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Drop -> Drop
Gdk.Drop.Drop) Ptr Drop
drop
    let x' :: Double
x' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
x
    let y' :: Double
y' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
y
    [DragAction]
result <- Ptr DropTargetAsync
-> (DropTargetAsync -> IO [DragAction]) -> IO [DragAction]
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr DropTargetAsync
gi'selfPtr ((DropTargetAsync -> IO [DragAction]) -> IO [DragAction])
-> (DropTargetAsync -> IO [DragAction]) -> IO [DragAction]
forall a b. (a -> b) -> a -> b
$ \DropTargetAsync
gi'self -> a -> DropTargetAsyncDragEnterCallback
gi'cb (DropTargetAsync -> a
forall a b. Coercible a b => a -> b
Coerce.coerce DropTargetAsync
gi'self)  Drop
drop' Double
x' Double
y'
    let result' :: CUInt
result' = [DragAction] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [DragAction]
result
    CUInt -> IO CUInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CUInt
result'


-- | Connect a signal handler for the [dragMotion](#signal:dragMotion) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' dropTargetAsync #dragMotion callback
-- @
-- 
-- 
onDropTargetAsyncDragMotion :: (IsDropTargetAsync a, MonadIO m) => a -> ((?self :: a) => DropTargetAsyncDragMotionCallback) -> m SignalHandlerId
onDropTargetAsyncDragMotion :: forall a (m :: * -> *).
(IsDropTargetAsync a, MonadIO m) =>
a
-> ((?self::a) => DropTargetAsyncDragEnterCallback)
-> m SignalHandlerId
onDropTargetAsyncDragMotion a
obj (?self::a) => DropTargetAsyncDragEnterCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> DropTargetAsyncDragEnterCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DropTargetAsyncDragEnterCallback
DropTargetAsyncDragEnterCallback
cb
    let wrapped' :: C_DropTargetAsyncDragEnterCallback
wrapped' = (a -> DropTargetAsyncDragEnterCallback)
-> C_DropTargetAsyncDragEnterCallback
forall a.
GObject a =>
(a -> DropTargetAsyncDragEnterCallback)
-> C_DropTargetAsyncDragEnterCallback
wrap_DropTargetAsyncDragMotionCallback a -> DropTargetAsyncDragEnterCallback
wrapped
    FunPtr C_DropTargetAsyncDragEnterCallback
wrapped'' <- C_DropTargetAsyncDragEnterCallback
-> IO (FunPtr C_DropTargetAsyncDragEnterCallback)
mk_DropTargetAsyncDragMotionCallback C_DropTargetAsyncDragEnterCallback
wrapped'
    a
-> Text
-> FunPtr C_DropTargetAsyncDragEnterCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drag-motion" FunPtr C_DropTargetAsyncDragEnterCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [dragMotion](#signal:dragMotion) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' dropTargetAsync #dragMotion callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterDropTargetAsyncDragMotion :: (IsDropTargetAsync a, MonadIO m) => a -> ((?self :: a) => DropTargetAsyncDragMotionCallback) -> m SignalHandlerId
afterDropTargetAsyncDragMotion :: forall a (m :: * -> *).
(IsDropTargetAsync a, MonadIO m) =>
a
-> ((?self::a) => DropTargetAsyncDragEnterCallback)
-> m SignalHandlerId
afterDropTargetAsyncDragMotion a
obj (?self::a) => DropTargetAsyncDragEnterCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> DropTargetAsyncDragEnterCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DropTargetAsyncDragEnterCallback
DropTargetAsyncDragEnterCallback
cb
    let wrapped' :: C_DropTargetAsyncDragEnterCallback
wrapped' = (a -> DropTargetAsyncDragEnterCallback)
-> C_DropTargetAsyncDragEnterCallback
forall a.
GObject a =>
(a -> DropTargetAsyncDragEnterCallback)
-> C_DropTargetAsyncDragEnterCallback
wrap_DropTargetAsyncDragMotionCallback a -> DropTargetAsyncDragEnterCallback
wrapped
    FunPtr C_DropTargetAsyncDragEnterCallback
wrapped'' <- C_DropTargetAsyncDragEnterCallback
-> IO (FunPtr C_DropTargetAsyncDragEnterCallback)
mk_DropTargetAsyncDragMotionCallback C_DropTargetAsyncDragEnterCallback
wrapped'
    a
-> Text
-> FunPtr C_DropTargetAsyncDragEnterCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drag-motion" FunPtr C_DropTargetAsyncDragEnterCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data DropTargetAsyncDragMotionSignalInfo
instance SignalInfo DropTargetAsyncDragMotionSignalInfo where
    type HaskellCallbackType DropTargetAsyncDragMotionSignalInfo = DropTargetAsyncDragMotionCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_DropTargetAsyncDragMotionCallback cb
        cb'' <- mk_DropTargetAsyncDragMotionCallback cb'
        connectSignalFunPtr obj "drag-motion" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.DropTargetAsync::drag-motion"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-DropTargetAsync.html#g:signal:dragMotion"})

#endif

-- signal DropTargetAsync::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 'P.False' and no
-- further processing is necessary.
-- 
-- Otherwise, the handler returns 'P.True'. In this case, this handler will
-- accept the drop. The handler must ensure that 'GI.Gdk.Objects.Drop.dropFinish'
-- is called to let the source know that the drop is done. The call to
-- 'GI.Gdk.Objects.Drop.dropFinish' must only be done when all data has been received.
-- 
-- To receive the data, use one of the read functions provided by
-- t'GI.Gdk.Objects.Drop.Drop' such as 'GI.Gdk.Objects.Drop.dropReadAsync' or
-- 'GI.Gdk.Objects.Drop.dropReadValueAsync'.
type DropTargetAsyncDropCallback =
    Gdk.Drop.Drop
    -- ^ /@drop@/: the @GdkDrop@
    -> Double
    -- ^ /@x@/: the x coordinate of the current pointer position
    -> Double
    -- ^ /@y@/: the y coordinate of the current pointer position
    -> IO Bool
    -- ^ __Returns:__ whether the drop is accepted at the given pointer position

type C_DropTargetAsyncDropCallback =
    Ptr DropTargetAsync ->                  -- object
    Ptr Gdk.Drop.Drop ->
    CDouble ->
    CDouble ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_DropTargetAsyncDropCallback`.
foreign import ccall "wrapper"
    mk_DropTargetAsyncDropCallback :: C_DropTargetAsyncDropCallback -> IO (FunPtr C_DropTargetAsyncDropCallback)

wrap_DropTargetAsyncDropCallback :: 
    GObject a => (a -> DropTargetAsyncDropCallback) ->
    C_DropTargetAsyncDropCallback
wrap_DropTargetAsyncDropCallback :: forall a.
GObject a =>
(a -> DropTargetAsyncDropCallback) -> C_DropTargetAsyncDropCallback
wrap_DropTargetAsyncDropCallback a -> DropTargetAsyncDropCallback
gi'cb Ptr DropTargetAsync
gi'selfPtr Ptr Drop
drop CDouble
x CDouble
y Ptr ()
_ = do
    Drop
drop' <- ((ManagedPtr Drop -> Drop) -> Ptr Drop -> IO Drop
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Drop -> Drop
Gdk.Drop.Drop) Ptr Drop
drop
    let x' :: Double
x' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
x
    let y' :: Double
y' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
y
    Bool
result <- Ptr DropTargetAsync -> (DropTargetAsync -> IO Bool) -> IO Bool
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr DropTargetAsync
gi'selfPtr ((DropTargetAsync -> IO Bool) -> IO Bool)
-> (DropTargetAsync -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \DropTargetAsync
gi'self -> a -> DropTargetAsyncDropCallback
gi'cb (DropTargetAsync -> a
forall a b. Coercible a b => a -> b
Coerce.coerce DropTargetAsync
gi'self)  Drop
drop' Double
x' Double
y'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [drop](#signal:drop) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' dropTargetAsync #drop callback
-- @
-- 
-- 
onDropTargetAsyncDrop :: (IsDropTargetAsync a, MonadIO m) => a -> ((?self :: a) => DropTargetAsyncDropCallback) -> m SignalHandlerId
onDropTargetAsyncDrop :: forall a (m :: * -> *).
(IsDropTargetAsync a, MonadIO m) =>
a
-> ((?self::a) => DropTargetAsyncDropCallback) -> m SignalHandlerId
onDropTargetAsyncDrop a
obj (?self::a) => DropTargetAsyncDropCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> DropTargetAsyncDropCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DropTargetAsyncDropCallback
DropTargetAsyncDropCallback
cb
    let wrapped' :: C_DropTargetAsyncDropCallback
wrapped' = (a -> DropTargetAsyncDropCallback) -> C_DropTargetAsyncDropCallback
forall a.
GObject a =>
(a -> DropTargetAsyncDropCallback) -> C_DropTargetAsyncDropCallback
wrap_DropTargetAsyncDropCallback a -> DropTargetAsyncDropCallback
wrapped
    FunPtr C_DropTargetAsyncDropCallback
wrapped'' <- C_DropTargetAsyncDropCallback
-> IO (FunPtr C_DropTargetAsyncDropCallback)
mk_DropTargetAsyncDropCallback C_DropTargetAsyncDropCallback
wrapped'
    a
-> Text
-> FunPtr C_DropTargetAsyncDropCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drop" FunPtr C_DropTargetAsyncDropCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [drop](#signal:drop) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' dropTargetAsync #drop callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterDropTargetAsyncDrop :: (IsDropTargetAsync a, MonadIO m) => a -> ((?self :: a) => DropTargetAsyncDropCallback) -> m SignalHandlerId
afterDropTargetAsyncDrop :: forall a (m :: * -> *).
(IsDropTargetAsync a, MonadIO m) =>
a
-> ((?self::a) => DropTargetAsyncDropCallback) -> m SignalHandlerId
afterDropTargetAsyncDrop a
obj (?self::a) => DropTargetAsyncDropCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> DropTargetAsyncDropCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DropTargetAsyncDropCallback
DropTargetAsyncDropCallback
cb
    let wrapped' :: C_DropTargetAsyncDropCallback
wrapped' = (a -> DropTargetAsyncDropCallback) -> C_DropTargetAsyncDropCallback
forall a.
GObject a =>
(a -> DropTargetAsyncDropCallback) -> C_DropTargetAsyncDropCallback
wrap_DropTargetAsyncDropCallback a -> DropTargetAsyncDropCallback
wrapped
    FunPtr C_DropTargetAsyncDropCallback
wrapped'' <- C_DropTargetAsyncDropCallback
-> IO (FunPtr C_DropTargetAsyncDropCallback)
mk_DropTargetAsyncDropCallback C_DropTargetAsyncDropCallback
wrapped'
    a
-> Text
-> FunPtr C_DropTargetAsyncDropCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drop" FunPtr C_DropTargetAsyncDropCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data DropTargetAsyncDropSignalInfo
instance SignalInfo DropTargetAsyncDropSignalInfo where
    type HaskellCallbackType DropTargetAsyncDropSignalInfo = DropTargetAsyncDropCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_DropTargetAsyncDropCallback cb
        cb'' <- mk_DropTargetAsyncDropCallback cb'
        connectSignalFunPtr obj "drop" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.DropTargetAsync::drop"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-DropTargetAsync.html#g:signal:drop"})

#endif

-- VVV Prop "actions"
   -- Type: TInterface (Name {namespace = "Gdk", name = "DragAction"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@actions@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' dropTargetAsync #actions
-- @
getDropTargetAsyncActions :: (MonadIO m, IsDropTargetAsync o) => o -> m [Gdk.Flags.DragAction]
getDropTargetAsyncActions :: forall (m :: * -> *) o.
(MonadIO m, IsDropTargetAsync o) =>
o -> m [DragAction]
getDropTargetAsyncActions o
obj = IO [DragAction] -> m [DragAction]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [DragAction] -> m [DragAction])
-> IO [DragAction] -> m [DragAction]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO [DragAction]
forall a b.
(GObject a, IsGFlag b, BoxedFlags b) =>
a -> String -> IO [b]
B.Properties.getObjectPropertyFlags o
obj String
"actions"

-- | Set the value of the “@actions@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' dropTargetAsync [ #actions 'Data.GI.Base.Attributes.:=' value ]
-- @
setDropTargetAsyncActions :: (MonadIO m, IsDropTargetAsync o) => o -> [Gdk.Flags.DragAction] -> m ()
setDropTargetAsyncActions :: forall (m :: * -> *) o.
(MonadIO m, IsDropTargetAsync o) =>
o -> [DragAction] -> m ()
setDropTargetAsyncActions o
obj [DragAction]
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> [DragAction] -> IO ()
forall a b.
(IsGFlag b, BoxedFlags b, GObject a) =>
a -> String -> [b] -> IO ()
B.Properties.setObjectPropertyFlags o
obj String
"actions" [DragAction]
val

-- | Construct a `GValueConstruct` with valid value for the “@actions@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructDropTargetAsyncActions :: (IsDropTargetAsync o, MIO.MonadIO m) => [Gdk.Flags.DragAction] -> m (GValueConstruct o)
constructDropTargetAsyncActions :: forall o (m :: * -> *).
(IsDropTargetAsync o, MonadIO m) =>
[DragAction] -> m (GValueConstruct o)
constructDropTargetAsyncActions [DragAction]
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> [DragAction] -> IO (GValueConstruct o)
forall a o.
(IsGFlag a, BoxedFlags a) =>
String -> [a] -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFlags String
"actions" [DragAction]
val

#if defined(ENABLE_OVERLOADING)
data DropTargetAsyncActionsPropertyInfo
instance AttrInfo DropTargetAsyncActionsPropertyInfo where
    type AttrAllowedOps DropTargetAsyncActionsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint DropTargetAsyncActionsPropertyInfo = IsDropTargetAsync
    type AttrSetTypeConstraint DropTargetAsyncActionsPropertyInfo = (~) [Gdk.Flags.DragAction]
    type AttrTransferTypeConstraint DropTargetAsyncActionsPropertyInfo = (~) [Gdk.Flags.DragAction]
    type AttrTransferType DropTargetAsyncActionsPropertyInfo = [Gdk.Flags.DragAction]
    type AttrGetType DropTargetAsyncActionsPropertyInfo = [Gdk.Flags.DragAction]
    type AttrLabel DropTargetAsyncActionsPropertyInfo = "actions"
    type AttrOrigin DropTargetAsyncActionsPropertyInfo = DropTargetAsync
    attrGet = getDropTargetAsyncActions
    attrSet = setDropTargetAsyncActions
    attrTransfer _ v = do
        return v
    attrConstruct = constructDropTargetAsyncActions
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.DropTargetAsync.actions"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-DropTargetAsync.html#g:attr:actions"
        })
#endif

-- VVV Prop "formats"
   -- Type: TInterface (Name {namespace = "Gdk", name = "ContentFormats"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just True)

-- | Get the value of the “@formats@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' dropTargetAsync #formats
-- @
getDropTargetAsyncFormats :: (MonadIO m, IsDropTargetAsync o) => o -> m (Maybe Gdk.ContentFormats.ContentFormats)
getDropTargetAsyncFormats :: forall (m :: * -> *) o.
(MonadIO m, IsDropTargetAsync o) =>
o -> m (Maybe ContentFormats)
getDropTargetAsyncFormats o
obj = IO (Maybe ContentFormats) -> m (Maybe ContentFormats)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe ContentFormats) -> m (Maybe ContentFormats))
-> IO (Maybe ContentFormats) -> m (Maybe ContentFormats)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr ContentFormats -> ContentFormats)
-> IO (Maybe ContentFormats)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"formats" ManagedPtr ContentFormats -> ContentFormats
Gdk.ContentFormats.ContentFormats

-- | Set the value of the “@formats@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' dropTargetAsync [ #formats 'Data.GI.Base.Attributes.:=' value ]
-- @
setDropTargetAsyncFormats :: (MonadIO m, IsDropTargetAsync o) => o -> Gdk.ContentFormats.ContentFormats -> m ()
setDropTargetAsyncFormats :: forall (m :: * -> *) o.
(MonadIO m, IsDropTargetAsync o) =>
o -> ContentFormats -> m ()
setDropTargetAsyncFormats o
obj ContentFormats
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe ContentFormats -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"formats" (ContentFormats -> Maybe ContentFormats
forall a. a -> Maybe a
Just ContentFormats
val)

-- | Construct a `GValueConstruct` with valid value for the “@formats@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructDropTargetAsyncFormats :: (IsDropTargetAsync o, MIO.MonadIO m) => Gdk.ContentFormats.ContentFormats -> m (GValueConstruct o)
constructDropTargetAsyncFormats :: forall o (m :: * -> *).
(IsDropTargetAsync o, MonadIO m) =>
ContentFormats -> m (GValueConstruct o)
constructDropTargetAsyncFormats ContentFormats
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe ContentFormats -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"formats" (ContentFormats -> Maybe ContentFormats
forall a. a -> Maybe a
P.Just ContentFormats
val)

-- | Set the value of the “@formats@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #formats
-- @
clearDropTargetAsyncFormats :: (MonadIO m, IsDropTargetAsync o) => o -> m ()
clearDropTargetAsyncFormats :: forall (m :: * -> *) o.
(MonadIO m, IsDropTargetAsync o) =>
o -> m ()
clearDropTargetAsyncFormats o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe ContentFormats -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"formats" (Maybe ContentFormats
forall a. Maybe a
Nothing :: Maybe Gdk.ContentFormats.ContentFormats)

#if defined(ENABLE_OVERLOADING)
data DropTargetAsyncFormatsPropertyInfo
instance AttrInfo DropTargetAsyncFormatsPropertyInfo where
    type AttrAllowedOps DropTargetAsyncFormatsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint DropTargetAsyncFormatsPropertyInfo = IsDropTargetAsync
    type AttrSetTypeConstraint DropTargetAsyncFormatsPropertyInfo = (~) Gdk.ContentFormats.ContentFormats
    type AttrTransferTypeConstraint DropTargetAsyncFormatsPropertyInfo = (~) Gdk.ContentFormats.ContentFormats
    type AttrTransferType DropTargetAsyncFormatsPropertyInfo = Gdk.ContentFormats.ContentFormats
    type AttrGetType DropTargetAsyncFormatsPropertyInfo = (Maybe Gdk.ContentFormats.ContentFormats)
    type AttrLabel DropTargetAsyncFormatsPropertyInfo = "formats"
    type AttrOrigin DropTargetAsyncFormatsPropertyInfo = DropTargetAsync
    attrGet = getDropTargetAsyncFormats
    attrSet = setDropTargetAsyncFormats
    attrTransfer _ v = do
        return v
    attrConstruct = constructDropTargetAsyncFormats
    attrClear = clearDropTargetAsyncFormats
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.DropTargetAsync.formats"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-DropTargetAsync.html#g:attr:formats"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DropTargetAsync
type instance O.AttributeList DropTargetAsync = DropTargetAsyncAttributeList
type DropTargetAsyncAttributeList = ('[ '("actions", DropTargetAsyncActionsPropertyInfo), '("formats", DropTargetAsyncFormatsPropertyInfo), '("name", Gtk.EventController.EventControllerNamePropertyInfo), '("propagationLimit", Gtk.EventController.EventControllerPropagationLimitPropertyInfo), '("propagationPhase", Gtk.EventController.EventControllerPropagationPhasePropertyInfo), '("widget", Gtk.EventController.EventControllerWidgetPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
dropTargetAsyncActions :: AttrLabelProxy "actions"
dropTargetAsyncActions = AttrLabelProxy

dropTargetAsyncFormats :: AttrLabelProxy "formats"
dropTargetAsyncFormats = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList DropTargetAsync = DropTargetAsyncSignalList
type DropTargetAsyncSignalList = ('[ '("accept", DropTargetAsyncAcceptSignalInfo), '("dragEnter", DropTargetAsyncDragEnterSignalInfo), '("dragLeave", DropTargetAsyncDragLeaveSignalInfo), '("dragMotion", DropTargetAsyncDragMotionSignalInfo), '("drop", DropTargetAsyncDropSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method DropTargetAsync::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "formats"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "ContentFormats" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the supported data formats"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "actions"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "DragAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the supported actions"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gtk" , name = "DropTargetAsync" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drop_target_async_new" gtk_drop_target_async_new :: 
    Ptr Gdk.ContentFormats.ContentFormats -> -- formats : TInterface (Name {namespace = "Gdk", name = "ContentFormats"})
    CUInt ->                                -- actions : TInterface (Name {namespace = "Gdk", name = "DragAction"})
    IO (Ptr DropTargetAsync)

-- | Creates a new @GtkDropTargetAsync@ object.
dropTargetAsyncNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Maybe (Gdk.ContentFormats.ContentFormats)
    -- ^ /@formats@/: the supported data formats
    -> [Gdk.Flags.DragAction]
    -- ^ /@actions@/: the supported actions
    -> m DropTargetAsync
    -- ^ __Returns:__ the new @GtkDropTargetAsync@
dropTargetAsyncNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe ContentFormats -> [DragAction] -> m DropTargetAsync
dropTargetAsyncNew Maybe ContentFormats
formats [DragAction]
actions = IO DropTargetAsync -> m DropTargetAsync
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DropTargetAsync -> m DropTargetAsync)
-> IO DropTargetAsync -> m DropTargetAsync
forall a b. (a -> b) -> a -> b
$ do
    Ptr ContentFormats
maybeFormats <- case Maybe ContentFormats
formats of
        Maybe ContentFormats
Nothing -> Ptr ContentFormats -> IO (Ptr ContentFormats)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ContentFormats
forall a. Ptr a
nullPtr
        Just ContentFormats
jFormats -> do
            Ptr ContentFormats
jFormats' <- ContentFormats -> IO (Ptr ContentFormats)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed ContentFormats
jFormats
            Ptr ContentFormats -> IO (Ptr ContentFormats)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ContentFormats
jFormats'
    let actions' :: CUInt
actions' = [DragAction] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [DragAction]
actions
    Ptr DropTargetAsync
result <- Ptr ContentFormats -> CUInt -> IO (Ptr DropTargetAsync)
gtk_drop_target_async_new Ptr ContentFormats
maybeFormats CUInt
actions'
    Text -> Ptr DropTargetAsync -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dropTargetAsyncNew" Ptr DropTargetAsync
result
    DropTargetAsync
result' <- ((ManagedPtr DropTargetAsync -> DropTargetAsync)
-> Ptr DropTargetAsync -> IO DropTargetAsync
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DropTargetAsync -> DropTargetAsync
DropTargetAsync) Ptr DropTargetAsync
result
    Maybe ContentFormats -> (ContentFormats -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe ContentFormats
formats ContentFormats -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    DropTargetAsync -> IO DropTargetAsync
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DropTargetAsync
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method DropTargetAsync::get_actions
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "DropTargetAsync" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkDropTargetAsync`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gdk" , name = "DragAction" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drop_target_async_get_actions" gtk_drop_target_async_get_actions :: 
    Ptr DropTargetAsync ->                  -- self : TInterface (Name {namespace = "Gtk", name = "DropTargetAsync"})
    IO CUInt

-- | Gets the actions that this drop target supports.
dropTargetAsyncGetActions ::
    (B.CallStack.HasCallStack, MonadIO m, IsDropTargetAsync a) =>
    a
    -- ^ /@self@/: a @GtkDropTargetAsync@
    -> m [Gdk.Flags.DragAction]
    -- ^ __Returns:__ the actions that this drop target supports
dropTargetAsyncGetActions :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDropTargetAsync a) =>
a -> m [DragAction]
dropTargetAsyncGetActions a
self = IO [DragAction] -> m [DragAction]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [DragAction] -> m [DragAction])
-> IO [DragAction] -> m [DragAction]
forall a b. (a -> b) -> a -> b
$ do
    Ptr DropTargetAsync
self' <- a -> IO (Ptr DropTargetAsync)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr DropTargetAsync -> IO CUInt
gtk_drop_target_async_get_actions Ptr DropTargetAsync
self'
    let result' :: [DragAction]
result' = CUInt -> [DragAction]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    [DragAction] -> IO [DragAction]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [DragAction]
result'

#if defined(ENABLE_OVERLOADING)
data DropTargetAsyncGetActionsMethodInfo
instance (signature ~ (m [Gdk.Flags.DragAction]), MonadIO m, IsDropTargetAsync a) => O.OverloadedMethod DropTargetAsyncGetActionsMethodInfo a signature where
    overloadedMethod = dropTargetAsyncGetActions

instance O.OverloadedMethodInfo DropTargetAsyncGetActionsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.DropTargetAsync.dropTargetAsyncGetActions",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-DropTargetAsync.html#v:dropTargetAsyncGetActions"
        })


#endif

-- method DropTargetAsync::get_formats
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "DropTargetAsync" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkDropTargetAsync`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gdk" , name = "ContentFormats" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drop_target_async_get_formats" gtk_drop_target_async_get_formats :: 
    Ptr DropTargetAsync ->                  -- self : TInterface (Name {namespace = "Gtk", name = "DropTargetAsync"})
    IO (Ptr Gdk.ContentFormats.ContentFormats)

-- | Gets the data formats that this drop target accepts.
-- 
-- If the result is 'P.Nothing', all formats are expected to be supported.
dropTargetAsyncGetFormats ::
    (B.CallStack.HasCallStack, MonadIO m, IsDropTargetAsync a) =>
    a
    -- ^ /@self@/: a @GtkDropTargetAsync@
    -> m (Maybe Gdk.ContentFormats.ContentFormats)
    -- ^ __Returns:__ the supported data formats
dropTargetAsyncGetFormats :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDropTargetAsync a) =>
a -> m (Maybe ContentFormats)
dropTargetAsyncGetFormats a
self = IO (Maybe ContentFormats) -> m (Maybe ContentFormats)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ContentFormats) -> m (Maybe ContentFormats))
-> IO (Maybe ContentFormats) -> m (Maybe ContentFormats)
forall a b. (a -> b) -> a -> b
$ do
    Ptr DropTargetAsync
self' <- a -> IO (Ptr DropTargetAsync)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ContentFormats
result <- Ptr DropTargetAsync -> IO (Ptr ContentFormats)
gtk_drop_target_async_get_formats Ptr DropTargetAsync
self'
    Maybe ContentFormats
maybeResult <- Ptr ContentFormats
-> (Ptr ContentFormats -> IO ContentFormats)
-> IO (Maybe ContentFormats)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr ContentFormats
result ((Ptr ContentFormats -> IO ContentFormats)
 -> IO (Maybe ContentFormats))
-> (Ptr ContentFormats -> IO ContentFormats)
-> IO (Maybe ContentFormats)
forall a b. (a -> b) -> a -> b
$ \Ptr ContentFormats
result' -> do
        ContentFormats
result'' <- ((ManagedPtr ContentFormats -> ContentFormats)
-> Ptr ContentFormats -> IO ContentFormats
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr ContentFormats -> ContentFormats
Gdk.ContentFormats.ContentFormats) Ptr ContentFormats
result'
        ContentFormats -> IO ContentFormats
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ContentFormats
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe ContentFormats -> IO (Maybe ContentFormats)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ContentFormats
maybeResult

#if defined(ENABLE_OVERLOADING)
data DropTargetAsyncGetFormatsMethodInfo
instance (signature ~ (m (Maybe Gdk.ContentFormats.ContentFormats)), MonadIO m, IsDropTargetAsync a) => O.OverloadedMethod DropTargetAsyncGetFormatsMethodInfo a signature where
    overloadedMethod = dropTargetAsyncGetFormats

instance O.OverloadedMethodInfo DropTargetAsyncGetFormatsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.DropTargetAsync.dropTargetAsyncGetFormats",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-DropTargetAsync.html#v:dropTargetAsyncGetFormats"
        })


#endif

-- method DropTargetAsync::reject_drop
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "DropTargetAsync" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkDropTargetAsync`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "drop"
--           , argType = TInterface Name { namespace = "Gdk" , name = "Drop" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the `GdkDrop` of an ongoing drag operation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drop_target_async_reject_drop" gtk_drop_target_async_reject_drop :: 
    Ptr DropTargetAsync ->                  -- self : TInterface (Name {namespace = "Gtk", name = "DropTargetAsync"})
    Ptr Gdk.Drop.Drop ->                    -- drop : TInterface (Name {namespace = "Gdk", name = "Drop"})
    IO ()

-- | 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.
dropTargetAsyncRejectDrop ::
    (B.CallStack.HasCallStack, MonadIO m, IsDropTargetAsync a, Gdk.Drop.IsDrop b) =>
    a
    -- ^ /@self@/: a @GtkDropTargetAsync@
    -> b
    -- ^ /@drop@/: the @GdkDrop@ of an ongoing drag operation
    -> m ()
dropTargetAsyncRejectDrop :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDropTargetAsync a, IsDrop b) =>
a -> b -> m ()
dropTargetAsyncRejectDrop a
self b
drop = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DropTargetAsync
self' <- a -> IO (Ptr DropTargetAsync)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Drop
drop' <- b -> IO (Ptr Drop)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
drop
    Ptr DropTargetAsync -> Ptr Drop -> IO ()
gtk_drop_target_async_reject_drop Ptr DropTargetAsync
self' Ptr Drop
drop'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
drop
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DropTargetAsyncRejectDropMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDropTargetAsync a, Gdk.Drop.IsDrop b) => O.OverloadedMethod DropTargetAsyncRejectDropMethodInfo a signature where
    overloadedMethod = dropTargetAsyncRejectDrop

instance O.OverloadedMethodInfo DropTargetAsyncRejectDropMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.DropTargetAsync.dropTargetAsyncRejectDrop",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-DropTargetAsync.html#v:dropTargetAsyncRejectDrop"
        })


#endif

-- method DropTargetAsync::set_actions
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "DropTargetAsync" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkDropTargetAsync`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "actions"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "DragAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the supported actions"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drop_target_async_set_actions" gtk_drop_target_async_set_actions :: 
    Ptr DropTargetAsync ->                  -- self : TInterface (Name {namespace = "Gtk", name = "DropTargetAsync"})
    CUInt ->                                -- actions : TInterface (Name {namespace = "Gdk", name = "DragAction"})
    IO ()

-- | Sets the actions that this drop target supports.
dropTargetAsyncSetActions ::
    (B.CallStack.HasCallStack, MonadIO m, IsDropTargetAsync a) =>
    a
    -- ^ /@self@/: a @GtkDropTargetAsync@
    -> [Gdk.Flags.DragAction]
    -- ^ /@actions@/: the supported actions
    -> m ()
dropTargetAsyncSetActions :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDropTargetAsync a) =>
a -> [DragAction] -> m ()
dropTargetAsyncSetActions a
self [DragAction]
actions = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DropTargetAsync
self' <- a -> IO (Ptr DropTargetAsync)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let actions' :: CUInt
actions' = [DragAction] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [DragAction]
actions
    Ptr DropTargetAsync -> CUInt -> IO ()
gtk_drop_target_async_set_actions Ptr DropTargetAsync
self' CUInt
actions'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DropTargetAsyncSetActionsMethodInfo
instance (signature ~ ([Gdk.Flags.DragAction] -> m ()), MonadIO m, IsDropTargetAsync a) => O.OverloadedMethod DropTargetAsyncSetActionsMethodInfo a signature where
    overloadedMethod = dropTargetAsyncSetActions

instance O.OverloadedMethodInfo DropTargetAsyncSetActionsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.DropTargetAsync.dropTargetAsyncSetActions",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-DropTargetAsync.html#v:dropTargetAsyncSetActions"
        })


#endif

-- method DropTargetAsync::set_formats
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "DropTargetAsync" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkDropTargetAsync`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "formats"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "ContentFormats" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the supported data formats or %NULL for any format"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drop_target_async_set_formats" gtk_drop_target_async_set_formats :: 
    Ptr DropTargetAsync ->                  -- self : TInterface (Name {namespace = "Gtk", name = "DropTargetAsync"})
    Ptr Gdk.ContentFormats.ContentFormats -> -- formats : TInterface (Name {namespace = "Gdk", name = "ContentFormats"})
    IO ()

-- | Sets the data formats that this drop target will accept.
dropTargetAsyncSetFormats ::
    (B.CallStack.HasCallStack, MonadIO m, IsDropTargetAsync a) =>
    a
    -- ^ /@self@/: a @GtkDropTargetAsync@
    -> Maybe (Gdk.ContentFormats.ContentFormats)
    -- ^ /@formats@/: the supported data formats or 'P.Nothing' for any format
    -> m ()
dropTargetAsyncSetFormats :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDropTargetAsync a) =>
a -> Maybe ContentFormats -> m ()
dropTargetAsyncSetFormats a
self Maybe ContentFormats
formats = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DropTargetAsync
self' <- a -> IO (Ptr DropTargetAsync)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ContentFormats
maybeFormats <- case Maybe ContentFormats
formats of
        Maybe ContentFormats
Nothing -> Ptr ContentFormats -> IO (Ptr ContentFormats)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ContentFormats
forall a. Ptr a
nullPtr
        Just ContentFormats
jFormats -> do
            Ptr ContentFormats
jFormats' <- ContentFormats -> IO (Ptr ContentFormats)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ContentFormats
jFormats
            Ptr ContentFormats -> IO (Ptr ContentFormats)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ContentFormats
jFormats'
    Ptr DropTargetAsync -> Ptr ContentFormats -> IO ()
gtk_drop_target_async_set_formats Ptr DropTargetAsync
self' Ptr ContentFormats
maybeFormats
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe ContentFormats -> (ContentFormats -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe ContentFormats
formats ContentFormats -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DropTargetAsyncSetFormatsMethodInfo
instance (signature ~ (Maybe (Gdk.ContentFormats.ContentFormats) -> m ()), MonadIO m, IsDropTargetAsync a) => O.OverloadedMethod DropTargetAsyncSetFormatsMethodInfo a signature where
    overloadedMethod = dropTargetAsyncSetFormats

instance O.OverloadedMethodInfo DropTargetAsyncSetFormatsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.DropTargetAsync.dropTargetAsyncSetFormats",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-DropTargetAsync.html#v:dropTargetAsyncSetFormats"
        })


#endif