{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Generated during DND operations.

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

module GI.Gdk.Structs.EventDND
    ( 

-- * Exported types
    EventDND(..)                            ,
    newZeroEventDND                         ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveEventDNDMethod                   ,
#endif



 -- * Properties


-- ** context #attr:context#
-- | the t'GI.Gdk.Objects.DragContext.DragContext' for the current DND operation.

    clearEventDNDContext                    ,
#if defined(ENABLE_OVERLOADING)
    eventDND_context                        ,
#endif
    getEventDNDContext                      ,
    setEventDNDContext                      ,


-- ** sendEvent #attr:sendEvent#
-- | 'P.True' if the event was sent explicitly.

#if defined(ENABLE_OVERLOADING)
    eventDND_sendEvent                      ,
#endif
    getEventDNDSendEvent                    ,
    setEventDNDSendEvent                    ,


-- ** time #attr:time#
-- | the time of the event in milliseconds.

#if defined(ENABLE_OVERLOADING)
    eventDND_time                           ,
#endif
    getEventDNDTime                         ,
    setEventDNDTime                         ,


-- ** type #attr:type#
-- | the type of the event ('GI.Gdk.Enums.EventTypeDragEnter', 'GI.Gdk.Enums.EventTypeDragLeave',
--   'GI.Gdk.Enums.EventTypeDragMotion', 'GI.Gdk.Enums.EventTypeDragStatus', 'GI.Gdk.Enums.EventTypeDropStart' or
--   'GI.Gdk.Enums.EventTypeDropFinished').

#if defined(ENABLE_OVERLOADING)
    eventDND_type                           ,
#endif
    getEventDNDType                         ,
    setEventDNDType                         ,


-- ** window #attr:window#
-- | the window which received the event.

    clearEventDNDWindow                     ,
#if defined(ENABLE_OVERLOADING)
    eventDND_window                         ,
#endif
    getEventDNDWindow                       ,
    setEventDNDWindow                       ,


-- ** xRoot #attr:xRoot#
-- | the x coordinate of the pointer relative to the root of the
--   screen, only set for 'GI.Gdk.Enums.EventTypeDragMotion' and 'GI.Gdk.Enums.EventTypeDropStart'.

#if defined(ENABLE_OVERLOADING)
    eventDND_xRoot                          ,
#endif
    getEventDNDXRoot                        ,
    setEventDNDXRoot                        ,


-- ** yRoot #attr:yRoot#
-- | the y coordinate of the pointer relative to the root of the
--   screen, only set for 'GI.Gdk.Enums.EventTypeDragMotion' and 'GI.Gdk.Enums.EventTypeDropStart'.

#if defined(ENABLE_OVERLOADING)
    eventDND_yRoot                          ,
#endif
    getEventDNDYRoot                        ,
    setEventDNDYRoot                        ,




    ) 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.Kind as DK
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 {-# SOURCE #-} qualified GI.Gdk.Enums as Gdk.Enums
import {-# SOURCE #-} qualified GI.Gdk.Objects.DragContext as Gdk.DragContext
import {-# SOURCE #-} qualified GI.Gdk.Objects.Window as Gdk.Window

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

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

instance BoxedPtr EventDND where
    boxedPtrCopy :: EventDND -> IO EventDND
boxedPtrCopy = \EventDND
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr EventDND
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
24 forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr EventDND -> EventDND
EventDND)
    boxedPtrFree :: EventDND -> IO ()
boxedPtrFree = \EventDND
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr EventDND
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr EventDND where
    boxedPtrCalloc :: IO (Ptr EventDND)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
24


-- | Construct a `EventDND` struct initialized to zero.
newZeroEventDND :: MonadIO m => m EventDND
newZeroEventDND :: forall (m :: * -> *). MonadIO m => m EventDND
newZeroEventDND = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr EventDND -> EventDND
EventDND

instance tag ~ 'AttrSet => Constructible EventDND tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr EventDND -> EventDND)
-> [AttrOp EventDND tag] -> m EventDND
new ManagedPtr EventDND -> EventDND
_ [AttrOp EventDND tag]
attrs = do
        EventDND
o <- forall (m :: * -> *). MonadIO m => m EventDND
newZeroEventDND
        forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set EventDND
o [AttrOp EventDND tag]
attrs
        forall (m :: * -> *) a. Monad m => a -> m a
return EventDND
o


-- | Get the value of the “@type@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' eventDND #type
-- @
getEventDNDType :: MonadIO m => EventDND -> m Gdk.Enums.EventType
getEventDNDType :: forall (m :: * -> *). MonadIO m => EventDND -> m EventType
getEventDNDType EventDND
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventDND
s forall a b. (a -> b) -> a -> b
$ \Ptr EventDND
ptr -> do
    CInt
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventDND
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CInt
    let val' :: EventType
val' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
val
    forall (m :: * -> *) a. Monad m => a -> m a
return EventType
val'

-- | Set the value of the “@type@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' eventDND [ #type 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventDNDType :: MonadIO m => EventDND -> Gdk.Enums.EventType -> m ()
setEventDNDType :: forall (m :: * -> *). MonadIO m => EventDND -> EventType -> m ()
setEventDNDType EventDND
s EventType
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventDND
s forall a b. (a -> b) -> a -> b
$ \Ptr EventDND
ptr -> do
    let val' :: CInt
val' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) EventType
val
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventDND
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CInt
val' :: CInt)

#if defined(ENABLE_OVERLOADING)
data EventDNDTypeFieldInfo
instance AttrInfo EventDNDTypeFieldInfo where
    type AttrBaseTypeConstraint EventDNDTypeFieldInfo = (~) EventDND
    type AttrAllowedOps EventDNDTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint EventDNDTypeFieldInfo = (~) Gdk.Enums.EventType
    type AttrTransferTypeConstraint EventDNDTypeFieldInfo = (~)Gdk.Enums.EventType
    type AttrTransferType EventDNDTypeFieldInfo = Gdk.Enums.EventType
    type AttrGetType EventDNDTypeFieldInfo = Gdk.Enums.EventType
    type AttrLabel EventDNDTypeFieldInfo = "type"
    type AttrOrigin EventDNDTypeFieldInfo = EventDND
    attrGet = getEventDNDType
    attrSet = setEventDNDType
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gdk.Structs.EventDND.type"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventDND.html#g:attr:type"
        })

eventDND_type :: AttrLabelProxy "type"
eventDND_type = AttrLabelProxy

#endif


-- | Get the value of the “@window@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' eventDND #window
-- @
getEventDNDWindow :: MonadIO m => EventDND -> m (Maybe Gdk.Window.Window)
getEventDNDWindow :: forall (m :: * -> *). MonadIO m => EventDND -> m (Maybe Window)
getEventDNDWindow EventDND
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventDND
s forall a b. (a -> b) -> a -> b
$ \Ptr EventDND
ptr -> do
    Ptr Window
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventDND
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO (Ptr Gdk.Window.Window)
    Maybe Window
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Window
val forall a b. (a -> b) -> a -> b
$ \Ptr Window
val' -> do
        Window
val'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Window -> Window
Gdk.Window.Window) Ptr Window
val'
        forall (m :: * -> *) a. Monad m => a -> m a
return Window
val''
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Window
result

-- | Set the value of the “@window@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' eventDND [ #window 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventDNDWindow :: MonadIO m => EventDND -> Ptr Gdk.Window.Window -> m ()
setEventDNDWindow :: forall (m :: * -> *). MonadIO m => EventDND -> Ptr Window -> m ()
setEventDNDWindow EventDND
s Ptr Window
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventDND
s forall a b. (a -> b) -> a -> b
$ \Ptr EventDND
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventDND
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (Ptr Window
val :: Ptr Gdk.Window.Window)

-- | Set the value of the “@window@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #window
-- @
clearEventDNDWindow :: MonadIO m => EventDND -> m ()
clearEventDNDWindow :: forall (m :: * -> *). MonadIO m => EventDND -> m ()
clearEventDNDWindow EventDND
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventDND
s forall a b. (a -> b) -> a -> b
$ \Ptr EventDND
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventDND
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (forall a. Ptr a
FP.nullPtr :: Ptr Gdk.Window.Window)

#if defined(ENABLE_OVERLOADING)
data EventDNDWindowFieldInfo
instance AttrInfo EventDNDWindowFieldInfo where
    type AttrBaseTypeConstraint EventDNDWindowFieldInfo = (~) EventDND
    type AttrAllowedOps EventDNDWindowFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint EventDNDWindowFieldInfo = (~) (Ptr Gdk.Window.Window)
    type AttrTransferTypeConstraint EventDNDWindowFieldInfo = (~)(Ptr Gdk.Window.Window)
    type AttrTransferType EventDNDWindowFieldInfo = (Ptr Gdk.Window.Window)
    type AttrGetType EventDNDWindowFieldInfo = Maybe Gdk.Window.Window
    type AttrLabel EventDNDWindowFieldInfo = "window"
    type AttrOrigin EventDNDWindowFieldInfo = EventDND
    attrGet = getEventDNDWindow
    attrSet = setEventDNDWindow
    attrConstruct = undefined
    attrClear = clearEventDNDWindow
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gdk.Structs.EventDND.window"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventDND.html#g:attr:window"
        })

eventDND_window :: AttrLabelProxy "window"
eventDND_window = AttrLabelProxy

#endif


-- | Get the value of the “@send_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' eventDND #sendEvent
-- @
getEventDNDSendEvent :: MonadIO m => EventDND -> m Int8
getEventDNDSendEvent :: forall (m :: * -> *). MonadIO m => EventDND -> m Int8
getEventDNDSendEvent EventDND
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventDND
s forall a b. (a -> b) -> a -> b
$ \Ptr EventDND
ptr -> do
    Int8
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventDND
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Int8
    forall (m :: * -> *) a. Monad m => a -> m a
return Int8
val

-- | Set the value of the “@send_event@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' eventDND [ #sendEvent 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventDNDSendEvent :: MonadIO m => EventDND -> Int8 -> m ()
setEventDNDSendEvent :: forall (m :: * -> *). MonadIO m => EventDND -> Int8 -> m ()
setEventDNDSendEvent EventDND
s Int8
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventDND
s forall a b. (a -> b) -> a -> b
$ \Ptr EventDND
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventDND
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Int8
val :: Int8)

#if defined(ENABLE_OVERLOADING)
data EventDNDSendEventFieldInfo
instance AttrInfo EventDNDSendEventFieldInfo where
    type AttrBaseTypeConstraint EventDNDSendEventFieldInfo = (~) EventDND
    type AttrAllowedOps EventDNDSendEventFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint EventDNDSendEventFieldInfo = (~) Int8
    type AttrTransferTypeConstraint EventDNDSendEventFieldInfo = (~)Int8
    type AttrTransferType EventDNDSendEventFieldInfo = Int8
    type AttrGetType EventDNDSendEventFieldInfo = Int8
    type AttrLabel EventDNDSendEventFieldInfo = "send_event"
    type AttrOrigin EventDNDSendEventFieldInfo = EventDND
    attrGet = getEventDNDSendEvent
    attrSet = setEventDNDSendEvent
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gdk.Structs.EventDND.sendEvent"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventDND.html#g:attr:sendEvent"
        })

eventDND_sendEvent :: AttrLabelProxy "sendEvent"
eventDND_sendEvent = AttrLabelProxy

#endif


-- | Get the value of the “@context@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' eventDND #context
-- @
getEventDNDContext :: MonadIO m => EventDND -> m (Maybe Gdk.DragContext.DragContext)
getEventDNDContext :: forall (m :: * -> *).
MonadIO m =>
EventDND -> m (Maybe DragContext)
getEventDNDContext EventDND
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventDND
s forall a b. (a -> b) -> a -> b
$ \Ptr EventDND
ptr -> do
    Ptr DragContext
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventDND
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO (Ptr Gdk.DragContext.DragContext)
    Maybe DragContext
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr DragContext
val forall a b. (a -> b) -> a -> b
$ \Ptr DragContext
val' -> do
        DragContext
val'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DragContext -> DragContext
Gdk.DragContext.DragContext) Ptr DragContext
val'
        forall (m :: * -> *) a. Monad m => a -> m a
return DragContext
val''
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DragContext
result

-- | Set the value of the “@context@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' eventDND [ #context 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventDNDContext :: MonadIO m => EventDND -> Ptr Gdk.DragContext.DragContext -> m ()
setEventDNDContext :: forall (m :: * -> *).
MonadIO m =>
EventDND -> Ptr DragContext -> m ()
setEventDNDContext EventDND
s Ptr DragContext
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventDND
s forall a b. (a -> b) -> a -> b
$ \Ptr EventDND
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventDND
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (Ptr DragContext
val :: Ptr Gdk.DragContext.DragContext)

-- | Set the value of the “@context@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #context
-- @
clearEventDNDContext :: MonadIO m => EventDND -> m ()
clearEventDNDContext :: forall (m :: * -> *). MonadIO m => EventDND -> m ()
clearEventDNDContext EventDND
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventDND
s forall a b. (a -> b) -> a -> b
$ \Ptr EventDND
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventDND
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (forall a. Ptr a
FP.nullPtr :: Ptr Gdk.DragContext.DragContext)

#if defined(ENABLE_OVERLOADING)
data EventDNDContextFieldInfo
instance AttrInfo EventDNDContextFieldInfo where
    type AttrBaseTypeConstraint EventDNDContextFieldInfo = (~) EventDND
    type AttrAllowedOps EventDNDContextFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint EventDNDContextFieldInfo = (~) (Ptr Gdk.DragContext.DragContext)
    type AttrTransferTypeConstraint EventDNDContextFieldInfo = (~)(Ptr Gdk.DragContext.DragContext)
    type AttrTransferType EventDNDContextFieldInfo = (Ptr Gdk.DragContext.DragContext)
    type AttrGetType EventDNDContextFieldInfo = Maybe Gdk.DragContext.DragContext
    type AttrLabel EventDNDContextFieldInfo = "context"
    type AttrOrigin EventDNDContextFieldInfo = EventDND
    attrGet = getEventDNDContext
    attrSet = setEventDNDContext
    attrConstruct = undefined
    attrClear = clearEventDNDContext
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gdk.Structs.EventDND.context"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventDND.html#g:attr:context"
        })

eventDND_context :: AttrLabelProxy "context"
eventDND_context = AttrLabelProxy

#endif


-- | Get the value of the “@time@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' eventDND #time
-- @
getEventDNDTime :: MonadIO m => EventDND -> m Word32
getEventDNDTime :: forall (m :: * -> *). MonadIO m => EventDND -> m Word32
getEventDNDTime EventDND
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventDND
s forall a b. (a -> b) -> a -> b
$ \Ptr EventDND
ptr -> do
    Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventDND
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO Word32
    forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

-- | Set the value of the “@time@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' eventDND [ #time 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventDNDTime :: MonadIO m => EventDND -> Word32 -> m ()
setEventDNDTime :: forall (m :: * -> *). MonadIO m => EventDND -> Word32 -> m ()
setEventDNDTime EventDND
s Word32
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventDND
s forall a b. (a -> b) -> a -> b
$ \Ptr EventDND
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventDND
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data EventDNDTimeFieldInfo
instance AttrInfo EventDNDTimeFieldInfo where
    type AttrBaseTypeConstraint EventDNDTimeFieldInfo = (~) EventDND
    type AttrAllowedOps EventDNDTimeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint EventDNDTimeFieldInfo = (~) Word32
    type AttrTransferTypeConstraint EventDNDTimeFieldInfo = (~)Word32
    type AttrTransferType EventDNDTimeFieldInfo = Word32
    type AttrGetType EventDNDTimeFieldInfo = Word32
    type AttrLabel EventDNDTimeFieldInfo = "time"
    type AttrOrigin EventDNDTimeFieldInfo = EventDND
    attrGet = getEventDNDTime
    attrSet = setEventDNDTime
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gdk.Structs.EventDND.time"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventDND.html#g:attr:time"
        })

eventDND_time :: AttrLabelProxy "time"
eventDND_time = AttrLabelProxy

#endif


-- | Get the value of the “@x_root@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' eventDND #xRoot
-- @
getEventDNDXRoot :: MonadIO m => EventDND -> m Int16
getEventDNDXRoot :: forall (m :: * -> *). MonadIO m => EventDND -> m Int16
getEventDNDXRoot EventDND
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventDND
s forall a b. (a -> b) -> a -> b
$ \Ptr EventDND
ptr -> do
    Int16
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventDND
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) :: IO Int16
    forall (m :: * -> *) a. Monad m => a -> m a
return Int16
val

-- | Set the value of the “@x_root@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' eventDND [ #xRoot 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventDNDXRoot :: MonadIO m => EventDND -> Int16 -> m ()
setEventDNDXRoot :: forall (m :: * -> *). MonadIO m => EventDND -> Int16 -> m ()
setEventDNDXRoot EventDND
s Int16
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventDND
s forall a b. (a -> b) -> a -> b
$ \Ptr EventDND
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventDND
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (Int16
val :: Int16)

#if defined(ENABLE_OVERLOADING)
data EventDNDXRootFieldInfo
instance AttrInfo EventDNDXRootFieldInfo where
    type AttrBaseTypeConstraint EventDNDXRootFieldInfo = (~) EventDND
    type AttrAllowedOps EventDNDXRootFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint EventDNDXRootFieldInfo = (~) Int16
    type AttrTransferTypeConstraint EventDNDXRootFieldInfo = (~)Int16
    type AttrTransferType EventDNDXRootFieldInfo = Int16
    type AttrGetType EventDNDXRootFieldInfo = Int16
    type AttrLabel EventDNDXRootFieldInfo = "x_root"
    type AttrOrigin EventDNDXRootFieldInfo = EventDND
    attrGet = getEventDNDXRoot
    attrSet = setEventDNDXRoot
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gdk.Structs.EventDND.xRoot"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventDND.html#g:attr:xRoot"
        })

eventDND_xRoot :: AttrLabelProxy "xRoot"
eventDND_xRoot = AttrLabelProxy

#endif


-- | Get the value of the “@y_root@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' eventDND #yRoot
-- @
getEventDNDYRoot :: MonadIO m => EventDND -> m Int16
getEventDNDYRoot :: forall (m :: * -> *). MonadIO m => EventDND -> m Int16
getEventDNDYRoot EventDND
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventDND
s forall a b. (a -> b) -> a -> b
$ \Ptr EventDND
ptr -> do
    Int16
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventDND
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
22) :: IO Int16
    forall (m :: * -> *) a. Monad m => a -> m a
return Int16
val

-- | Set the value of the “@y_root@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' eventDND [ #yRoot 'Data.GI.Base.Attributes.:=' value ]
-- @
setEventDNDYRoot :: MonadIO m => EventDND -> Int16 -> m ()
setEventDNDYRoot :: forall (m :: * -> *). MonadIO m => EventDND -> Int16 -> m ()
setEventDNDYRoot EventDND
s Int16
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr EventDND
s forall a b. (a -> b) -> a -> b
$ \Ptr EventDND
ptr -> do
    forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventDND
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
22) (Int16
val :: Int16)

#if defined(ENABLE_OVERLOADING)
data EventDNDYRootFieldInfo
instance AttrInfo EventDNDYRootFieldInfo where
    type AttrBaseTypeConstraint EventDNDYRootFieldInfo = (~) EventDND
    type AttrAllowedOps EventDNDYRootFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint EventDNDYRootFieldInfo = (~) Int16
    type AttrTransferTypeConstraint EventDNDYRootFieldInfo = (~)Int16
    type AttrTransferType EventDNDYRootFieldInfo = Int16
    type AttrGetType EventDNDYRootFieldInfo = Int16
    type AttrLabel EventDNDYRootFieldInfo = "y_root"
    type AttrOrigin EventDNDYRootFieldInfo = EventDND
    attrGet = getEventDNDYRoot
    attrSet = setEventDNDYRoot
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gdk.Structs.EventDND.yRoot"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventDND.html#g:attr:yRoot"
        })

eventDND_yRoot :: AttrLabelProxy "yRoot"
eventDND_yRoot = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList EventDND
type instance O.AttributeList EventDND = EventDNDAttributeList
type EventDNDAttributeList = ('[ '("type", EventDNDTypeFieldInfo), '("window", EventDNDWindowFieldInfo), '("sendEvent", EventDNDSendEventFieldInfo), '("context", EventDNDContextFieldInfo), '("time", EventDNDTimeFieldInfo), '("xRoot", EventDNDXRootFieldInfo), '("yRoot", EventDNDYRootFieldInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveEventDNDMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveEventDNDMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveEventDNDMethod t EventDND, O.OverloadedMethod info EventDND p) => OL.IsLabel t (EventDND -> 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 ~ ResolveEventDNDMethod t EventDND, O.OverloadedMethod info EventDND p, R.HasField t EventDND p) => R.HasField t EventDND p where
    getField = O.overloadedMethod @info

#endif

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

#endif