{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gdk.Structs.EventDND
(
EventDND(..) ,
newZeroEventDND ,
#if defined(ENABLE_OVERLOADING)
ResolveEventDNDMethod ,
#endif
clearEventDNDContext ,
#if defined(ENABLE_OVERLOADING)
eventDND_context ,
#endif
getEventDNDContext ,
setEventDNDContext ,
#if defined(ENABLE_OVERLOADING)
eventDND_sendEvent ,
#endif
getEventDNDSendEvent ,
setEventDNDSendEvent ,
#if defined(ENABLE_OVERLOADING)
eventDND_time ,
#endif
getEventDNDTime ,
setEventDNDTime ,
#if defined(ENABLE_OVERLOADING)
eventDND_type ,
#endif
getEventDNDType ,
setEventDNDType ,
clearEventDNDWindow ,
#if defined(ENABLE_OVERLOADING)
eventDND_window ,
#endif
getEventDNDWindow ,
setEventDNDWindow ,
#if defined(ENABLE_OVERLOADING)
eventDND_xRoot ,
#endif
getEventDNDXRoot ,
setEventDNDXRoot ,
#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
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
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
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'
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
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
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)
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
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
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
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
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)
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
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
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
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
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
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
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