{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gdk.Objects.DragContext
(
DragContext(..) ,
IsDragContext ,
toDragContext ,
noDragContext ,
#if defined(ENABLE_OVERLOADING)
ResolveDragContextMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
DragContextGetActionsMethodInfo ,
#endif
dragContextGetActions ,
#if defined(ENABLE_OVERLOADING)
DragContextGetDestWindowMethodInfo ,
#endif
dragContextGetDestWindow ,
#if defined(ENABLE_OVERLOADING)
DragContextGetDeviceMethodInfo ,
#endif
dragContextGetDevice ,
#if defined(ENABLE_OVERLOADING)
DragContextGetDragWindowMethodInfo ,
#endif
dragContextGetDragWindow ,
#if defined(ENABLE_OVERLOADING)
DragContextGetProtocolMethodInfo ,
#endif
dragContextGetProtocol ,
#if defined(ENABLE_OVERLOADING)
DragContextGetSelectedActionMethodInfo ,
#endif
dragContextGetSelectedAction ,
#if defined(ENABLE_OVERLOADING)
DragContextGetSourceWindowMethodInfo ,
#endif
dragContextGetSourceWindow ,
#if defined(ENABLE_OVERLOADING)
DragContextGetSuggestedActionMethodInfo ,
#endif
dragContextGetSuggestedAction ,
#if defined(ENABLE_OVERLOADING)
DragContextListTargetsMethodInfo ,
#endif
dragContextListTargets ,
#if defined(ENABLE_OVERLOADING)
DragContextManageDndMethodInfo ,
#endif
dragContextManageDnd ,
#if defined(ENABLE_OVERLOADING)
DragContextSetDeviceMethodInfo ,
#endif
dragContextSetDevice ,
#if defined(ENABLE_OVERLOADING)
DragContextSetHotspotMethodInfo ,
#endif
dragContextSetHotspot ,
C_DragContextActionChangedCallback ,
DragContextActionChangedCallback ,
#if defined(ENABLE_OVERLOADING)
DragContextActionChangedSignalInfo ,
#endif
afterDragContextActionChanged ,
genClosure_DragContextActionChanged ,
mk_DragContextActionChangedCallback ,
noDragContextActionChangedCallback ,
onDragContextActionChanged ,
wrap_DragContextActionChangedCallback ,
C_DragContextCancelCallback ,
DragContextCancelCallback ,
#if defined(ENABLE_OVERLOADING)
DragContextCancelSignalInfo ,
#endif
afterDragContextCancel ,
genClosure_DragContextCancel ,
mk_DragContextCancelCallback ,
noDragContextCancelCallback ,
onDragContextCancel ,
wrap_DragContextCancelCallback ,
C_DragContextDndFinishedCallback ,
DragContextDndFinishedCallback ,
#if defined(ENABLE_OVERLOADING)
DragContextDndFinishedSignalInfo ,
#endif
afterDragContextDndFinished ,
genClosure_DragContextDndFinished ,
mk_DragContextDndFinishedCallback ,
noDragContextDndFinishedCallback ,
onDragContextDndFinished ,
wrap_DragContextDndFinishedCallback ,
C_DragContextDropPerformedCallback ,
DragContextDropPerformedCallback ,
#if defined(ENABLE_OVERLOADING)
DragContextDropPerformedSignalInfo ,
#endif
afterDragContextDropPerformed ,
genClosure_DragContextDropPerformed ,
mk_DragContextDropPerformedCallback ,
noDragContextDropPerformedCallback ,
onDragContextDropPerformed ,
wrap_DragContextDropPerformedCallback ,
) 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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
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 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 GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gdk.Enums as Gdk.Enums
import {-# SOURCE #-} qualified GI.Gdk.Flags as Gdk.Flags
import {-# SOURCE #-} qualified GI.Gdk.Objects.Device as Gdk.Device
import {-# SOURCE #-} qualified GI.Gdk.Objects.Window as Gdk.Window
import {-# SOURCE #-} qualified GI.Gdk.Structs.Atom as Gdk.Atom
newtype DragContext = DragContext (ManagedPtr DragContext)
deriving (Eq)
foreign import ccall "gdk_drag_context_get_type"
c_gdk_drag_context_get_type :: IO GType
instance GObject DragContext where
gobjectType = c_gdk_drag_context_get_type
instance B.GValue.IsGValue DragContext where
toGValue o = do
gtype <- c_gdk_drag_context_get_type
B.ManagedPtr.withManagedPtr o (B.GValue.buildGValue gtype B.GValue.set_object)
fromGValue gv = do
ptr <- B.GValue.get_object gv :: IO (Ptr DragContext)
B.ManagedPtr.newObject DragContext ptr
class (GObject o, O.IsDescendantOf DragContext o) => IsDragContext o
instance (GObject o, O.IsDescendantOf DragContext o) => IsDragContext o
instance O.HasParentTypes DragContext
type instance O.ParentTypes DragContext = '[GObject.Object.Object]
toDragContext :: (MonadIO m, IsDragContext o) => o -> m DragContext
toDragContext = liftIO . unsafeCastTo DragContext
noDragContext :: Maybe DragContext
noDragContext = Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveDragContextMethod (t :: Symbol) (o :: *) :: * where
ResolveDragContextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveDragContextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveDragContextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveDragContextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveDragContextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveDragContextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveDragContextMethod "listTargets" o = DragContextListTargetsMethodInfo
ResolveDragContextMethod "manageDnd" o = DragContextManageDndMethodInfo
ResolveDragContextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveDragContextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveDragContextMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveDragContextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveDragContextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveDragContextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveDragContextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveDragContextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveDragContextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveDragContextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveDragContextMethod "getActions" o = DragContextGetActionsMethodInfo
ResolveDragContextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveDragContextMethod "getDestWindow" o = DragContextGetDestWindowMethodInfo
ResolveDragContextMethod "getDevice" o = DragContextGetDeviceMethodInfo
ResolveDragContextMethod "getDragWindow" o = DragContextGetDragWindowMethodInfo
ResolveDragContextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveDragContextMethod "getProtocol" o = DragContextGetProtocolMethodInfo
ResolveDragContextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveDragContextMethod "getSelectedAction" o = DragContextGetSelectedActionMethodInfo
ResolveDragContextMethod "getSourceWindow" o = DragContextGetSourceWindowMethodInfo
ResolveDragContextMethod "getSuggestedAction" o = DragContextGetSuggestedActionMethodInfo
ResolveDragContextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveDragContextMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveDragContextMethod "setDevice" o = DragContextSetDeviceMethodInfo
ResolveDragContextMethod "setHotspot" o = DragContextSetHotspotMethodInfo
ResolveDragContextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveDragContextMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDragContextMethod t DragContext, O.MethodInfo info DragContext p) => OL.IsLabel t (DragContext -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
type DragContextActionChangedCallback =
[Gdk.Flags.DragAction]
-> IO ()
noDragContextActionChangedCallback :: Maybe DragContextActionChangedCallback
noDragContextActionChangedCallback = Nothing
type C_DragContextActionChangedCallback =
Ptr () ->
CUInt ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DragContextActionChangedCallback :: C_DragContextActionChangedCallback -> IO (FunPtr C_DragContextActionChangedCallback)
genClosure_DragContextActionChanged :: MonadIO m => DragContextActionChangedCallback -> m (GClosure C_DragContextActionChangedCallback)
genClosure_DragContextActionChanged cb = liftIO $ do
let cb' = wrap_DragContextActionChangedCallback cb
mk_DragContextActionChangedCallback cb' >>= B.GClosure.newGClosure
wrap_DragContextActionChangedCallback ::
DragContextActionChangedCallback ->
C_DragContextActionChangedCallback
wrap_DragContextActionChangedCallback _cb _ action _ = do
let action' = wordToGFlags action
_cb action'
onDragContextActionChanged :: (IsDragContext a, MonadIO m) => a -> DragContextActionChangedCallback -> m SignalHandlerId
onDragContextActionChanged obj cb = liftIO $ do
let cb' = wrap_DragContextActionChangedCallback cb
cb'' <- mk_DragContextActionChangedCallback cb'
connectSignalFunPtr obj "action-changed" cb'' SignalConnectBefore Nothing
afterDragContextActionChanged :: (IsDragContext a, MonadIO m) => a -> DragContextActionChangedCallback -> m SignalHandlerId
afterDragContextActionChanged obj cb = liftIO $ do
let cb' = wrap_DragContextActionChangedCallback cb
cb'' <- mk_DragContextActionChangedCallback cb'
connectSignalFunPtr obj "action-changed" cb'' SignalConnectAfter Nothing
#if defined(ENABLE_OVERLOADING)
data DragContextActionChangedSignalInfo
instance SignalInfo DragContextActionChangedSignalInfo where
type HaskellCallbackType DragContextActionChangedSignalInfo = DragContextActionChangedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_DragContextActionChangedCallback cb
cb'' <- mk_DragContextActionChangedCallback cb'
connectSignalFunPtr obj "action-changed" cb'' connectMode detail
#endif
type DragContextCancelCallback =
Gdk.Enums.DragCancelReason
-> IO ()
noDragContextCancelCallback :: Maybe DragContextCancelCallback
noDragContextCancelCallback = Nothing
type C_DragContextCancelCallback =
Ptr () ->
CUInt ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DragContextCancelCallback :: C_DragContextCancelCallback -> IO (FunPtr C_DragContextCancelCallback)
genClosure_DragContextCancel :: MonadIO m => DragContextCancelCallback -> m (GClosure C_DragContextCancelCallback)
genClosure_DragContextCancel cb = liftIO $ do
let cb' = wrap_DragContextCancelCallback cb
mk_DragContextCancelCallback cb' >>= B.GClosure.newGClosure
wrap_DragContextCancelCallback ::
DragContextCancelCallback ->
C_DragContextCancelCallback
wrap_DragContextCancelCallback _cb _ reason _ = do
let reason' = (toEnum . fromIntegral) reason
_cb reason'
onDragContextCancel :: (IsDragContext a, MonadIO m) => a -> DragContextCancelCallback -> m SignalHandlerId
onDragContextCancel obj cb = liftIO $ do
let cb' = wrap_DragContextCancelCallback cb
cb'' <- mk_DragContextCancelCallback cb'
connectSignalFunPtr obj "cancel" cb'' SignalConnectBefore Nothing
afterDragContextCancel :: (IsDragContext a, MonadIO m) => a -> DragContextCancelCallback -> m SignalHandlerId
afterDragContextCancel obj cb = liftIO $ do
let cb' = wrap_DragContextCancelCallback cb
cb'' <- mk_DragContextCancelCallback cb'
connectSignalFunPtr obj "cancel" cb'' SignalConnectAfter Nothing
#if defined(ENABLE_OVERLOADING)
data DragContextCancelSignalInfo
instance SignalInfo DragContextCancelSignalInfo where
type HaskellCallbackType DragContextCancelSignalInfo = DragContextCancelCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_DragContextCancelCallback cb
cb'' <- mk_DragContextCancelCallback cb'
connectSignalFunPtr obj "cancel" cb'' connectMode detail
#endif
type DragContextDndFinishedCallback =
IO ()
noDragContextDndFinishedCallback :: Maybe DragContextDndFinishedCallback
noDragContextDndFinishedCallback = Nothing
type C_DragContextDndFinishedCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DragContextDndFinishedCallback :: C_DragContextDndFinishedCallback -> IO (FunPtr C_DragContextDndFinishedCallback)
genClosure_DragContextDndFinished :: MonadIO m => DragContextDndFinishedCallback -> m (GClosure C_DragContextDndFinishedCallback)
genClosure_DragContextDndFinished cb = liftIO $ do
let cb' = wrap_DragContextDndFinishedCallback cb
mk_DragContextDndFinishedCallback cb' >>= B.GClosure.newGClosure
wrap_DragContextDndFinishedCallback ::
DragContextDndFinishedCallback ->
C_DragContextDndFinishedCallback
wrap_DragContextDndFinishedCallback _cb _ _ = do
_cb
onDragContextDndFinished :: (IsDragContext a, MonadIO m) => a -> DragContextDndFinishedCallback -> m SignalHandlerId
onDragContextDndFinished obj cb = liftIO $ do
let cb' = wrap_DragContextDndFinishedCallback cb
cb'' <- mk_DragContextDndFinishedCallback cb'
connectSignalFunPtr obj "dnd-finished" cb'' SignalConnectBefore Nothing
afterDragContextDndFinished :: (IsDragContext a, MonadIO m) => a -> DragContextDndFinishedCallback -> m SignalHandlerId
afterDragContextDndFinished obj cb = liftIO $ do
let cb' = wrap_DragContextDndFinishedCallback cb
cb'' <- mk_DragContextDndFinishedCallback cb'
connectSignalFunPtr obj "dnd-finished" cb'' SignalConnectAfter Nothing
#if defined(ENABLE_OVERLOADING)
data DragContextDndFinishedSignalInfo
instance SignalInfo DragContextDndFinishedSignalInfo where
type HaskellCallbackType DragContextDndFinishedSignalInfo = DragContextDndFinishedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_DragContextDndFinishedCallback cb
cb'' <- mk_DragContextDndFinishedCallback cb'
connectSignalFunPtr obj "dnd-finished" cb'' connectMode detail
#endif
type DragContextDropPerformedCallback =
Int32
-> IO ()
noDragContextDropPerformedCallback :: Maybe DragContextDropPerformedCallback
noDragContextDropPerformedCallback = Nothing
type C_DragContextDropPerformedCallback =
Ptr () ->
Int32 ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DragContextDropPerformedCallback :: C_DragContextDropPerformedCallback -> IO (FunPtr C_DragContextDropPerformedCallback)
genClosure_DragContextDropPerformed :: MonadIO m => DragContextDropPerformedCallback -> m (GClosure C_DragContextDropPerformedCallback)
genClosure_DragContextDropPerformed cb = liftIO $ do
let cb' = wrap_DragContextDropPerformedCallback cb
mk_DragContextDropPerformedCallback cb' >>= B.GClosure.newGClosure
wrap_DragContextDropPerformedCallback ::
DragContextDropPerformedCallback ->
C_DragContextDropPerformedCallback
wrap_DragContextDropPerformedCallback _cb _ time _ = do
_cb time
onDragContextDropPerformed :: (IsDragContext a, MonadIO m) => a -> DragContextDropPerformedCallback -> m SignalHandlerId
onDragContextDropPerformed obj cb = liftIO $ do
let cb' = wrap_DragContextDropPerformedCallback cb
cb'' <- mk_DragContextDropPerformedCallback cb'
connectSignalFunPtr obj "drop-performed" cb'' SignalConnectBefore Nothing
afterDragContextDropPerformed :: (IsDragContext a, MonadIO m) => a -> DragContextDropPerformedCallback -> m SignalHandlerId
afterDragContextDropPerformed obj cb = liftIO $ do
let cb' = wrap_DragContextDropPerformedCallback cb
cb'' <- mk_DragContextDropPerformedCallback cb'
connectSignalFunPtr obj "drop-performed" cb'' SignalConnectAfter Nothing
#if defined(ENABLE_OVERLOADING)
data DragContextDropPerformedSignalInfo
instance SignalInfo DragContextDropPerformedSignalInfo where
type HaskellCallbackType DragContextDropPerformedSignalInfo = DragContextDropPerformedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_DragContextDropPerformedCallback cb
cb'' <- mk_DragContextDropPerformedCallback cb'
connectSignalFunPtr obj "drop-performed" cb'' connectMode detail
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DragContext
type instance O.AttributeList DragContext = DragContextAttributeList
type DragContextAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList DragContext = DragContextSignalList
type DragContextSignalList = ('[ '("actionChanged", DragContextActionChangedSignalInfo), '("cancel", DragContextCancelSignalInfo), '("dndFinished", DragContextDndFinishedSignalInfo), '("dropPerformed", DragContextDropPerformedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gdk_drag_context_get_actions" gdk_drag_context_get_actions ::
Ptr DragContext ->
IO CUInt
dragContextGetActions ::
(B.CallStack.HasCallStack, MonadIO m, IsDragContext a) =>
a
-> m [Gdk.Flags.DragAction]
dragContextGetActions context = liftIO $ do
context' <- unsafeManagedPtrCastPtr context
result <- gdk_drag_context_get_actions context'
let result' = wordToGFlags result
touchManagedPtr context
return result'
#if defined(ENABLE_OVERLOADING)
data DragContextGetActionsMethodInfo
instance (signature ~ (m [Gdk.Flags.DragAction]), MonadIO m, IsDragContext a) => O.MethodInfo DragContextGetActionsMethodInfo a signature where
overloadedMethod = dragContextGetActions
#endif
foreign import ccall "gdk_drag_context_get_dest_window" gdk_drag_context_get_dest_window ::
Ptr DragContext ->
IO (Ptr Gdk.Window.Window)
dragContextGetDestWindow ::
(B.CallStack.HasCallStack, MonadIO m, IsDragContext a) =>
a
-> m Gdk.Window.Window
dragContextGetDestWindow context = liftIO $ do
context' <- unsafeManagedPtrCastPtr context
result <- gdk_drag_context_get_dest_window context'
checkUnexpectedReturnNULL "dragContextGetDestWindow" result
result' <- (newObject Gdk.Window.Window) result
touchManagedPtr context
return result'
#if defined(ENABLE_OVERLOADING)
data DragContextGetDestWindowMethodInfo
instance (signature ~ (m Gdk.Window.Window), MonadIO m, IsDragContext a) => O.MethodInfo DragContextGetDestWindowMethodInfo a signature where
overloadedMethod = dragContextGetDestWindow
#endif
foreign import ccall "gdk_drag_context_get_device" gdk_drag_context_get_device ::
Ptr DragContext ->
IO (Ptr Gdk.Device.Device)
dragContextGetDevice ::
(B.CallStack.HasCallStack, MonadIO m, IsDragContext a) =>
a
-> m Gdk.Device.Device
dragContextGetDevice context = liftIO $ do
context' <- unsafeManagedPtrCastPtr context
result <- gdk_drag_context_get_device context'
checkUnexpectedReturnNULL "dragContextGetDevice" result
result' <- (newObject Gdk.Device.Device) result
touchManagedPtr context
return result'
#if defined(ENABLE_OVERLOADING)
data DragContextGetDeviceMethodInfo
instance (signature ~ (m Gdk.Device.Device), MonadIO m, IsDragContext a) => O.MethodInfo DragContextGetDeviceMethodInfo a signature where
overloadedMethod = dragContextGetDevice
#endif
foreign import ccall "gdk_drag_context_get_drag_window" gdk_drag_context_get_drag_window ::
Ptr DragContext ->
IO (Ptr Gdk.Window.Window)
dragContextGetDragWindow ::
(B.CallStack.HasCallStack, MonadIO m, IsDragContext a) =>
a
-> m (Maybe Gdk.Window.Window)
dragContextGetDragWindow context = liftIO $ do
context' <- unsafeManagedPtrCastPtr context
result <- gdk_drag_context_get_drag_window context'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (newObject Gdk.Window.Window) result'
return result''
touchManagedPtr context
return maybeResult
#if defined(ENABLE_OVERLOADING)
data DragContextGetDragWindowMethodInfo
instance (signature ~ (m (Maybe Gdk.Window.Window)), MonadIO m, IsDragContext a) => O.MethodInfo DragContextGetDragWindowMethodInfo a signature where
overloadedMethod = dragContextGetDragWindow
#endif
foreign import ccall "gdk_drag_context_get_protocol" gdk_drag_context_get_protocol ::
Ptr DragContext ->
IO CUInt
dragContextGetProtocol ::
(B.CallStack.HasCallStack, MonadIO m, IsDragContext a) =>
a
-> m Gdk.Enums.DragProtocol
dragContextGetProtocol context = liftIO $ do
context' <- unsafeManagedPtrCastPtr context
result <- gdk_drag_context_get_protocol context'
let result' = (toEnum . fromIntegral) result
touchManagedPtr context
return result'
#if defined(ENABLE_OVERLOADING)
data DragContextGetProtocolMethodInfo
instance (signature ~ (m Gdk.Enums.DragProtocol), MonadIO m, IsDragContext a) => O.MethodInfo DragContextGetProtocolMethodInfo a signature where
overloadedMethod = dragContextGetProtocol
#endif
foreign import ccall "gdk_drag_context_get_selected_action" gdk_drag_context_get_selected_action ::
Ptr DragContext ->
IO CUInt
dragContextGetSelectedAction ::
(B.CallStack.HasCallStack, MonadIO m, IsDragContext a) =>
a
-> m [Gdk.Flags.DragAction]
dragContextGetSelectedAction context = liftIO $ do
context' <- unsafeManagedPtrCastPtr context
result <- gdk_drag_context_get_selected_action context'
let result' = wordToGFlags result
touchManagedPtr context
return result'
#if defined(ENABLE_OVERLOADING)
data DragContextGetSelectedActionMethodInfo
instance (signature ~ (m [Gdk.Flags.DragAction]), MonadIO m, IsDragContext a) => O.MethodInfo DragContextGetSelectedActionMethodInfo a signature where
overloadedMethod = dragContextGetSelectedAction
#endif
foreign import ccall "gdk_drag_context_get_source_window" gdk_drag_context_get_source_window ::
Ptr DragContext ->
IO (Ptr Gdk.Window.Window)
dragContextGetSourceWindow ::
(B.CallStack.HasCallStack, MonadIO m, IsDragContext a) =>
a
-> m Gdk.Window.Window
dragContextGetSourceWindow context = liftIO $ do
context' <- unsafeManagedPtrCastPtr context
result <- gdk_drag_context_get_source_window context'
checkUnexpectedReturnNULL "dragContextGetSourceWindow" result
result' <- (newObject Gdk.Window.Window) result
touchManagedPtr context
return result'
#if defined(ENABLE_OVERLOADING)
data DragContextGetSourceWindowMethodInfo
instance (signature ~ (m Gdk.Window.Window), MonadIO m, IsDragContext a) => O.MethodInfo DragContextGetSourceWindowMethodInfo a signature where
overloadedMethod = dragContextGetSourceWindow
#endif
foreign import ccall "gdk_drag_context_get_suggested_action" gdk_drag_context_get_suggested_action ::
Ptr DragContext ->
IO CUInt
dragContextGetSuggestedAction ::
(B.CallStack.HasCallStack, MonadIO m, IsDragContext a) =>
a
-> m [Gdk.Flags.DragAction]
dragContextGetSuggestedAction context = liftIO $ do
context' <- unsafeManagedPtrCastPtr context
result <- gdk_drag_context_get_suggested_action context'
let result' = wordToGFlags result
touchManagedPtr context
return result'
#if defined(ENABLE_OVERLOADING)
data DragContextGetSuggestedActionMethodInfo
instance (signature ~ (m [Gdk.Flags.DragAction]), MonadIO m, IsDragContext a) => O.MethodInfo DragContextGetSuggestedActionMethodInfo a signature where
overloadedMethod = dragContextGetSuggestedAction
#endif
foreign import ccall "gdk_drag_context_list_targets" gdk_drag_context_list_targets ::
Ptr DragContext ->
IO (Ptr (GList (Ptr Gdk.Atom.Atom)))
dragContextListTargets ::
(B.CallStack.HasCallStack, MonadIO m, IsDragContext a) =>
a
-> m [Gdk.Atom.Atom]
dragContextListTargets context = liftIO $ do
context' <- unsafeManagedPtrCastPtr context
result <- gdk_drag_context_list_targets context'
result' <- unpackGList result
result'' <- mapM (newPtr Gdk.Atom.Atom) result'
touchManagedPtr context
return result''
#if defined(ENABLE_OVERLOADING)
data DragContextListTargetsMethodInfo
instance (signature ~ (m [Gdk.Atom.Atom]), MonadIO m, IsDragContext a) => O.MethodInfo DragContextListTargetsMethodInfo a signature where
overloadedMethod = dragContextListTargets
#endif
foreign import ccall "gdk_drag_context_manage_dnd" gdk_drag_context_manage_dnd ::
Ptr DragContext ->
Ptr Gdk.Window.Window ->
CUInt ->
IO CInt
dragContextManageDnd ::
(B.CallStack.HasCallStack, MonadIO m, IsDragContext a, Gdk.Window.IsWindow b) =>
a
-> b
-> [Gdk.Flags.DragAction]
-> m Bool
dragContextManageDnd context ipcWindow actions = liftIO $ do
context' <- unsafeManagedPtrCastPtr context
ipcWindow' <- unsafeManagedPtrCastPtr ipcWindow
let actions' = gflagsToWord actions
result <- gdk_drag_context_manage_dnd context' ipcWindow' actions'
let result' = (/= 0) result
touchManagedPtr context
touchManagedPtr ipcWindow
return result'
#if defined(ENABLE_OVERLOADING)
data DragContextManageDndMethodInfo
instance (signature ~ (b -> [Gdk.Flags.DragAction] -> m Bool), MonadIO m, IsDragContext a, Gdk.Window.IsWindow b) => O.MethodInfo DragContextManageDndMethodInfo a signature where
overloadedMethod = dragContextManageDnd
#endif
foreign import ccall "gdk_drag_context_set_device" gdk_drag_context_set_device ::
Ptr DragContext ->
Ptr Gdk.Device.Device ->
IO ()
dragContextSetDevice ::
(B.CallStack.HasCallStack, MonadIO m, IsDragContext a, Gdk.Device.IsDevice b) =>
a
-> b
-> m ()
dragContextSetDevice context device = liftIO $ do
context' <- unsafeManagedPtrCastPtr context
device' <- unsafeManagedPtrCastPtr device
gdk_drag_context_set_device context' device'
touchManagedPtr context
touchManagedPtr device
return ()
#if defined(ENABLE_OVERLOADING)
data DragContextSetDeviceMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDragContext a, Gdk.Device.IsDevice b) => O.MethodInfo DragContextSetDeviceMethodInfo a signature where
overloadedMethod = dragContextSetDevice
#endif
foreign import ccall "gdk_drag_context_set_hotspot" gdk_drag_context_set_hotspot ::
Ptr DragContext ->
Int32 ->
Int32 ->
IO ()
dragContextSetHotspot ::
(B.CallStack.HasCallStack, MonadIO m, IsDragContext a) =>
a
-> Int32
-> Int32
-> m ()
dragContextSetHotspot context hotX hotY = liftIO $ do
context' <- unsafeManagedPtrCastPtr context
gdk_drag_context_set_hotspot context' hotX hotY
touchManagedPtr context
return ()
#if defined(ENABLE_OVERLOADING)
data DragContextSetHotspotMethodInfo
instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsDragContext a) => O.MethodInfo DragContextSetHotspotMethodInfo a signature where
overloadedMethod = dragContextSetHotspot
#endif