{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gdk.Structs.EventCrossing
(
EventCrossing(..) ,
newZeroEventCrossing ,
#if defined(ENABLE_OVERLOADING)
ResolveEventCrossingMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
eventCrossing_detail ,
#endif
getEventCrossingDetail ,
setEventCrossingDetail ,
#if defined(ENABLE_OVERLOADING)
eventCrossing_focus ,
#endif
getEventCrossingFocus ,
setEventCrossingFocus ,
#if defined(ENABLE_OVERLOADING)
eventCrossing_mode ,
#endif
getEventCrossingMode ,
setEventCrossingMode ,
#if defined(ENABLE_OVERLOADING)
eventCrossing_sendEvent ,
#endif
getEventCrossingSendEvent ,
setEventCrossingSendEvent ,
#if defined(ENABLE_OVERLOADING)
eventCrossing_state ,
#endif
getEventCrossingState ,
setEventCrossingState ,
clearEventCrossingSubwindow ,
#if defined(ENABLE_OVERLOADING)
eventCrossing_subwindow ,
#endif
getEventCrossingSubwindow ,
setEventCrossingSubwindow ,
#if defined(ENABLE_OVERLOADING)
eventCrossing_time ,
#endif
getEventCrossingTime ,
setEventCrossingTime ,
#if defined(ENABLE_OVERLOADING)
eventCrossing_type ,
#endif
getEventCrossingType ,
setEventCrossingType ,
clearEventCrossingWindow ,
#if defined(ENABLE_OVERLOADING)
eventCrossing_window ,
#endif
getEventCrossingWindow ,
setEventCrossingWindow ,
#if defined(ENABLE_OVERLOADING)
eventCrossing_x ,
#endif
getEventCrossingX ,
setEventCrossingX ,
#if defined(ENABLE_OVERLOADING)
eventCrossing_xRoot ,
#endif
getEventCrossingXRoot ,
setEventCrossingXRoot ,
#if defined(ENABLE_OVERLOADING)
eventCrossing_y ,
#endif
getEventCrossingY ,
setEventCrossingY ,
#if defined(ENABLE_OVERLOADING)
eventCrossing_yRoot ,
#endif
getEventCrossingYRoot ,
setEventCrossingYRoot ,
) 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.Flags as Gdk.Flags
import {-# SOURCE #-} qualified GI.Gdk.Objects.Window as Gdk.Window
newtype EventCrossing = EventCrossing (SP.ManagedPtr EventCrossing)
deriving (EventCrossing -> EventCrossing -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EventCrossing -> EventCrossing -> Bool
$c/= :: EventCrossing -> EventCrossing -> Bool
== :: EventCrossing -> EventCrossing -> Bool
$c== :: EventCrossing -> EventCrossing -> Bool
Eq)
instance SP.ManagedPtrNewtype EventCrossing where
toManagedPtr :: EventCrossing -> ManagedPtr EventCrossing
toManagedPtr (EventCrossing ManagedPtr EventCrossing
p) = ManagedPtr EventCrossing
p
instance BoxedPtr EventCrossing where
boxedPtrCopy :: EventCrossing -> IO EventCrossing
boxedPtrCopy = \EventCrossing
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr EventCrossing
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
68 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 EventCrossing -> EventCrossing
EventCrossing)
boxedPtrFree :: EventCrossing -> IO ()
boxedPtrFree = \EventCrossing
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr EventCrossing
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr EventCrossing where
boxedPtrCalloc :: IO (Ptr EventCrossing)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
68
newZeroEventCrossing :: MonadIO m => m EventCrossing
newZeroEventCrossing :: forall (m :: * -> *). MonadIO m => m EventCrossing
newZeroEventCrossing = 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 EventCrossing -> EventCrossing
EventCrossing
instance tag ~ 'AttrSet => Constructible EventCrossing tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr EventCrossing -> EventCrossing)
-> [AttrOp EventCrossing tag] -> m EventCrossing
new ManagedPtr EventCrossing -> EventCrossing
_ [AttrOp EventCrossing tag]
attrs = do
EventCrossing
o <- forall (m :: * -> *). MonadIO m => m EventCrossing
newZeroEventCrossing
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set EventCrossing
o [AttrOp EventCrossing tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return EventCrossing
o
getEventCrossingType :: MonadIO m => EventCrossing -> m Gdk.Enums.EventType
getEventCrossingType :: forall (m :: * -> *). MonadIO m => EventCrossing -> m EventType
getEventCrossingType EventCrossing
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
CInt
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventCrossing
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'
setEventCrossingType :: MonadIO m => EventCrossing -> Gdk.Enums.EventType -> m ()
setEventCrossingType :: forall (m :: * -> *).
MonadIO m =>
EventCrossing -> EventType -> m ()
setEventCrossingType EventCrossing
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
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 EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CInt
val' :: CInt)
#if defined(ENABLE_OVERLOADING)
data EventCrossingTypeFieldInfo
instance AttrInfo EventCrossingTypeFieldInfo where
type AttrBaseTypeConstraint EventCrossingTypeFieldInfo = (~) EventCrossing
type AttrAllowedOps EventCrossingTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventCrossingTypeFieldInfo = (~) Gdk.Enums.EventType
type AttrTransferTypeConstraint EventCrossingTypeFieldInfo = (~)Gdk.Enums.EventType
type AttrTransferType EventCrossingTypeFieldInfo = Gdk.Enums.EventType
type AttrGetType EventCrossingTypeFieldInfo = Gdk.Enums.EventType
type AttrLabel EventCrossingTypeFieldInfo = "type"
type AttrOrigin EventCrossingTypeFieldInfo = EventCrossing
attrGet = getEventCrossingType
attrSet = setEventCrossingType
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventCrossing.type"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventCrossing.html#g:attr:type"
})
eventCrossing_type :: AttrLabelProxy "type"
eventCrossing_type = AttrLabelProxy
#endif
getEventCrossingWindow :: MonadIO m => EventCrossing -> m (Maybe Gdk.Window.Window)
getEventCrossingWindow :: forall (m :: * -> *).
MonadIO m =>
EventCrossing -> m (Maybe Window)
getEventCrossingWindow EventCrossing
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
Ptr Window
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventCrossing
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
setEventCrossingWindow :: MonadIO m => EventCrossing -> Ptr Gdk.Window.Window -> m ()
setEventCrossingWindow :: forall (m :: * -> *).
MonadIO m =>
EventCrossing -> Ptr Window -> m ()
setEventCrossingWindow EventCrossing
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (Ptr Window
val :: Ptr Gdk.Window.Window)
clearEventCrossingWindow :: MonadIO m => EventCrossing -> m ()
clearEventCrossingWindow :: forall (m :: * -> *). MonadIO m => EventCrossing -> m ()
clearEventCrossingWindow EventCrossing
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventCrossing
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 EventCrossingWindowFieldInfo
instance AttrInfo EventCrossingWindowFieldInfo where
type AttrBaseTypeConstraint EventCrossingWindowFieldInfo = (~) EventCrossing
type AttrAllowedOps EventCrossingWindowFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint EventCrossingWindowFieldInfo = (~) (Ptr Gdk.Window.Window)
type AttrTransferTypeConstraint EventCrossingWindowFieldInfo = (~)(Ptr Gdk.Window.Window)
type AttrTransferType EventCrossingWindowFieldInfo = (Ptr Gdk.Window.Window)
type AttrGetType EventCrossingWindowFieldInfo = Maybe Gdk.Window.Window
type AttrLabel EventCrossingWindowFieldInfo = "window"
type AttrOrigin EventCrossingWindowFieldInfo = EventCrossing
attrGet = getEventCrossingWindow
attrSet = setEventCrossingWindow
attrConstruct = undefined
attrClear = clearEventCrossingWindow
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventCrossing.window"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventCrossing.html#g:attr:window"
})
eventCrossing_window :: AttrLabelProxy "window"
eventCrossing_window = AttrLabelProxy
#endif
getEventCrossingSendEvent :: MonadIO m => EventCrossing -> m Int8
getEventCrossingSendEvent :: forall (m :: * -> *). MonadIO m => EventCrossing -> m Int8
getEventCrossingSendEvent EventCrossing
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
Int8
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventCrossing
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
setEventCrossingSendEvent :: MonadIO m => EventCrossing -> Int8 -> m ()
setEventCrossingSendEvent :: forall (m :: * -> *). MonadIO m => EventCrossing -> Int8 -> m ()
setEventCrossingSendEvent EventCrossing
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Int8
val :: Int8)
#if defined(ENABLE_OVERLOADING)
data EventCrossingSendEventFieldInfo
instance AttrInfo EventCrossingSendEventFieldInfo where
type AttrBaseTypeConstraint EventCrossingSendEventFieldInfo = (~) EventCrossing
type AttrAllowedOps EventCrossingSendEventFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventCrossingSendEventFieldInfo = (~) Int8
type AttrTransferTypeConstraint EventCrossingSendEventFieldInfo = (~)Int8
type AttrTransferType EventCrossingSendEventFieldInfo = Int8
type AttrGetType EventCrossingSendEventFieldInfo = Int8
type AttrLabel EventCrossingSendEventFieldInfo = "send_event"
type AttrOrigin EventCrossingSendEventFieldInfo = EventCrossing
attrGet = getEventCrossingSendEvent
attrSet = setEventCrossingSendEvent
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventCrossing.sendEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventCrossing.html#g:attr:sendEvent"
})
eventCrossing_sendEvent :: AttrLabelProxy "sendEvent"
eventCrossing_sendEvent = AttrLabelProxy
#endif
getEventCrossingSubwindow :: MonadIO m => EventCrossing -> m (Maybe Gdk.Window.Window)
getEventCrossingSubwindow :: forall (m :: * -> *).
MonadIO m =>
EventCrossing -> m (Maybe Window)
getEventCrossingSubwindow EventCrossing
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
Ptr Window
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: 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
setEventCrossingSubwindow :: MonadIO m => EventCrossing -> Ptr Gdk.Window.Window -> m ()
setEventCrossingSubwindow :: forall (m :: * -> *).
MonadIO m =>
EventCrossing -> Ptr Window -> m ()
setEventCrossingSubwindow EventCrossing
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (Ptr Window
val :: Ptr Gdk.Window.Window)
clearEventCrossingSubwindow :: MonadIO m => EventCrossing -> m ()
clearEventCrossingSubwindow :: forall (m :: * -> *). MonadIO m => EventCrossing -> m ()
clearEventCrossingSubwindow EventCrossing
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (forall a. Ptr a
FP.nullPtr :: Ptr Gdk.Window.Window)
#if defined(ENABLE_OVERLOADING)
data EventCrossingSubwindowFieldInfo
instance AttrInfo EventCrossingSubwindowFieldInfo where
type AttrBaseTypeConstraint EventCrossingSubwindowFieldInfo = (~) EventCrossing
type AttrAllowedOps EventCrossingSubwindowFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint EventCrossingSubwindowFieldInfo = (~) (Ptr Gdk.Window.Window)
type AttrTransferTypeConstraint EventCrossingSubwindowFieldInfo = (~)(Ptr Gdk.Window.Window)
type AttrTransferType EventCrossingSubwindowFieldInfo = (Ptr Gdk.Window.Window)
type AttrGetType EventCrossingSubwindowFieldInfo = Maybe Gdk.Window.Window
type AttrLabel EventCrossingSubwindowFieldInfo = "subwindow"
type AttrOrigin EventCrossingSubwindowFieldInfo = EventCrossing
attrGet = getEventCrossingSubwindow
attrSet = setEventCrossingSubwindow
attrConstruct = undefined
attrClear = clearEventCrossingSubwindow
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventCrossing.subwindow"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventCrossing.html#g:attr:subwindow"
})
eventCrossing_subwindow :: AttrLabelProxy "subwindow"
eventCrossing_subwindow = AttrLabelProxy
#endif
getEventCrossingTime :: MonadIO m => EventCrossing -> m Word32
getEventCrossingTime :: forall (m :: * -> *). MonadIO m => EventCrossing -> m Word32
getEventCrossingTime EventCrossing
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventCrossing
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
setEventCrossingTime :: MonadIO m => EventCrossing -> Word32 -> m ()
setEventCrossingTime :: forall (m :: * -> *). MonadIO m => EventCrossing -> Word32 -> m ()
setEventCrossingTime EventCrossing
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data EventCrossingTimeFieldInfo
instance AttrInfo EventCrossingTimeFieldInfo where
type AttrBaseTypeConstraint EventCrossingTimeFieldInfo = (~) EventCrossing
type AttrAllowedOps EventCrossingTimeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventCrossingTimeFieldInfo = (~) Word32
type AttrTransferTypeConstraint EventCrossingTimeFieldInfo = (~)Word32
type AttrTransferType EventCrossingTimeFieldInfo = Word32
type AttrGetType EventCrossingTimeFieldInfo = Word32
type AttrLabel EventCrossingTimeFieldInfo = "time"
type AttrOrigin EventCrossingTimeFieldInfo = EventCrossing
attrGet = getEventCrossingTime
attrSet = setEventCrossingTime
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventCrossing.time"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventCrossing.html#g:attr:time"
})
eventCrossing_time :: AttrLabelProxy "time"
eventCrossing_time = AttrLabelProxy
#endif
getEventCrossingX :: MonadIO m => EventCrossing -> m Double
getEventCrossingX :: forall (m :: * -> *). MonadIO m => EventCrossing -> m Double
getEventCrossingX EventCrossing
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
CDouble
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) :: IO CDouble
let val' :: Double
val' = forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'
setEventCrossingX :: MonadIO m => EventCrossing -> Double -> m ()
setEventCrossingX :: forall (m :: * -> *). MonadIO m => EventCrossing -> Double -> m ()
setEventCrossingX EventCrossing
s Double
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
let val' :: CDouble
val' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
val
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (CDouble
val' :: CDouble)
#if defined(ENABLE_OVERLOADING)
data EventCrossingXFieldInfo
instance AttrInfo EventCrossingXFieldInfo where
type AttrBaseTypeConstraint EventCrossingXFieldInfo = (~) EventCrossing
type AttrAllowedOps EventCrossingXFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventCrossingXFieldInfo = (~) Double
type AttrTransferTypeConstraint EventCrossingXFieldInfo = (~)Double
type AttrTransferType EventCrossingXFieldInfo = Double
type AttrGetType EventCrossingXFieldInfo = Double
type AttrLabel EventCrossingXFieldInfo = "x"
type AttrOrigin EventCrossingXFieldInfo = EventCrossing
attrGet = getEventCrossingX
attrSet = setEventCrossingX
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventCrossing.x"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventCrossing.html#g:attr:x"
})
eventCrossing_x :: AttrLabelProxy "x"
eventCrossing_x = AttrLabelProxy
#endif
getEventCrossingY :: MonadIO m => EventCrossing -> m Double
getEventCrossingY :: forall (m :: * -> *). MonadIO m => EventCrossing -> m Double
getEventCrossingY EventCrossing
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
CDouble
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) :: IO CDouble
let val' :: Double
val' = forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'
setEventCrossingY :: MonadIO m => EventCrossing -> Double -> m ()
setEventCrossingY :: forall (m :: * -> *). MonadIO m => EventCrossing -> Double -> m ()
setEventCrossingY EventCrossing
s Double
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
let val' :: CDouble
val' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
val
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) (CDouble
val' :: CDouble)
#if defined(ENABLE_OVERLOADING)
data EventCrossingYFieldInfo
instance AttrInfo EventCrossingYFieldInfo where
type AttrBaseTypeConstraint EventCrossingYFieldInfo = (~) EventCrossing
type AttrAllowedOps EventCrossingYFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventCrossingYFieldInfo = (~) Double
type AttrTransferTypeConstraint EventCrossingYFieldInfo = (~)Double
type AttrTransferType EventCrossingYFieldInfo = Double
type AttrGetType EventCrossingYFieldInfo = Double
type AttrLabel EventCrossingYFieldInfo = "y"
type AttrOrigin EventCrossingYFieldInfo = EventCrossing
attrGet = getEventCrossingY
attrSet = setEventCrossingY
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventCrossing.y"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventCrossing.html#g:attr:y"
})
eventCrossing_y :: AttrLabelProxy "y"
eventCrossing_y = AttrLabelProxy
#endif
getEventCrossingXRoot :: MonadIO m => EventCrossing -> m Double
getEventCrossingXRoot :: forall (m :: * -> *). MonadIO m => EventCrossing -> m Double
getEventCrossingXRoot EventCrossing
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
CDouble
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36) :: IO CDouble
let val' :: Double
val' = forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'
setEventCrossingXRoot :: MonadIO m => EventCrossing -> Double -> m ()
setEventCrossingXRoot :: forall (m :: * -> *). MonadIO m => EventCrossing -> Double -> m ()
setEventCrossingXRoot EventCrossing
s Double
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
let val' :: CDouble
val' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
val
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36) (CDouble
val' :: CDouble)
#if defined(ENABLE_OVERLOADING)
data EventCrossingXRootFieldInfo
instance AttrInfo EventCrossingXRootFieldInfo where
type AttrBaseTypeConstraint EventCrossingXRootFieldInfo = (~) EventCrossing
type AttrAllowedOps EventCrossingXRootFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventCrossingXRootFieldInfo = (~) Double
type AttrTransferTypeConstraint EventCrossingXRootFieldInfo = (~)Double
type AttrTransferType EventCrossingXRootFieldInfo = Double
type AttrGetType EventCrossingXRootFieldInfo = Double
type AttrLabel EventCrossingXRootFieldInfo = "x_root"
type AttrOrigin EventCrossingXRootFieldInfo = EventCrossing
attrGet = getEventCrossingXRoot
attrSet = setEventCrossingXRoot
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventCrossing.xRoot"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventCrossing.html#g:attr:xRoot"
})
eventCrossing_xRoot :: AttrLabelProxy "xRoot"
eventCrossing_xRoot = AttrLabelProxy
#endif
getEventCrossingYRoot :: MonadIO m => EventCrossing -> m Double
getEventCrossingYRoot :: forall (m :: * -> *). MonadIO m => EventCrossing -> m Double
getEventCrossingYRoot EventCrossing
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
CDouble
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
44) :: IO CDouble
let val' :: Double
val' = forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'
setEventCrossingYRoot :: MonadIO m => EventCrossing -> Double -> m ()
setEventCrossingYRoot :: forall (m :: * -> *). MonadIO m => EventCrossing -> Double -> m ()
setEventCrossingYRoot EventCrossing
s Double
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
let val' :: CDouble
val' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
val
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
44) (CDouble
val' :: CDouble)
#if defined(ENABLE_OVERLOADING)
data EventCrossingYRootFieldInfo
instance AttrInfo EventCrossingYRootFieldInfo where
type AttrBaseTypeConstraint EventCrossingYRootFieldInfo = (~) EventCrossing
type AttrAllowedOps EventCrossingYRootFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventCrossingYRootFieldInfo = (~) Double
type AttrTransferTypeConstraint EventCrossingYRootFieldInfo = (~)Double
type AttrTransferType EventCrossingYRootFieldInfo = Double
type AttrGetType EventCrossingYRootFieldInfo = Double
type AttrLabel EventCrossingYRootFieldInfo = "y_root"
type AttrOrigin EventCrossingYRootFieldInfo = EventCrossing
attrGet = getEventCrossingYRoot
attrSet = setEventCrossingYRoot
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventCrossing.yRoot"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventCrossing.html#g:attr:yRoot"
})
eventCrossing_yRoot :: AttrLabelProxy "yRoot"
eventCrossing_yRoot = AttrLabelProxy
#endif
getEventCrossingMode :: MonadIO m => EventCrossing -> m Gdk.Enums.CrossingMode
getEventCrossingMode :: forall (m :: * -> *). MonadIO m => EventCrossing -> m CrossingMode
getEventCrossingMode EventCrossing
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
CUInt
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
52) :: IO CUInt
let val' :: CrossingMode
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) CUInt
val
forall (m :: * -> *) a. Monad m => a -> m a
return CrossingMode
val'
setEventCrossingMode :: MonadIO m => EventCrossing -> Gdk.Enums.CrossingMode -> m ()
setEventCrossingMode :: forall (m :: * -> *).
MonadIO m =>
EventCrossing -> CrossingMode -> m ()
setEventCrossingMode EventCrossing
s CrossingMode
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
let val' :: CUInt
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) CrossingMode
val
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
52) (CUInt
val' :: CUInt)
#if defined(ENABLE_OVERLOADING)
data EventCrossingModeFieldInfo
instance AttrInfo EventCrossingModeFieldInfo where
type AttrBaseTypeConstraint EventCrossingModeFieldInfo = (~) EventCrossing
type AttrAllowedOps EventCrossingModeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventCrossingModeFieldInfo = (~) Gdk.Enums.CrossingMode
type AttrTransferTypeConstraint EventCrossingModeFieldInfo = (~)Gdk.Enums.CrossingMode
type AttrTransferType EventCrossingModeFieldInfo = Gdk.Enums.CrossingMode
type AttrGetType EventCrossingModeFieldInfo = Gdk.Enums.CrossingMode
type AttrLabel EventCrossingModeFieldInfo = "mode"
type AttrOrigin EventCrossingModeFieldInfo = EventCrossing
attrGet = getEventCrossingMode
attrSet = setEventCrossingMode
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventCrossing.mode"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventCrossing.html#g:attr:mode"
})
eventCrossing_mode :: AttrLabelProxy "mode"
eventCrossing_mode = AttrLabelProxy
#endif
getEventCrossingDetail :: MonadIO m => EventCrossing -> m Gdk.Enums.NotifyType
getEventCrossingDetail :: forall (m :: * -> *). MonadIO m => EventCrossing -> m NotifyType
getEventCrossingDetail EventCrossing
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
CUInt
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) :: IO CUInt
let val' :: NotifyType
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) CUInt
val
forall (m :: * -> *) a. Monad m => a -> m a
return NotifyType
val'
setEventCrossingDetail :: MonadIO m => EventCrossing -> Gdk.Enums.NotifyType -> m ()
setEventCrossingDetail :: forall (m :: * -> *).
MonadIO m =>
EventCrossing -> NotifyType -> m ()
setEventCrossingDetail EventCrossing
s NotifyType
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
let val' :: CUInt
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) NotifyType
val
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) (CUInt
val' :: CUInt)
#if defined(ENABLE_OVERLOADING)
data EventCrossingDetailFieldInfo
instance AttrInfo EventCrossingDetailFieldInfo where
type AttrBaseTypeConstraint EventCrossingDetailFieldInfo = (~) EventCrossing
type AttrAllowedOps EventCrossingDetailFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventCrossingDetailFieldInfo = (~) Gdk.Enums.NotifyType
type AttrTransferTypeConstraint EventCrossingDetailFieldInfo = (~)Gdk.Enums.NotifyType
type AttrTransferType EventCrossingDetailFieldInfo = Gdk.Enums.NotifyType
type AttrGetType EventCrossingDetailFieldInfo = Gdk.Enums.NotifyType
type AttrLabel EventCrossingDetailFieldInfo = "detail"
type AttrOrigin EventCrossingDetailFieldInfo = EventCrossing
attrGet = getEventCrossingDetail
attrSet = setEventCrossingDetail
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventCrossing.detail"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventCrossing.html#g:attr:detail"
})
eventCrossing_detail :: AttrLabelProxy "detail"
eventCrossing_detail = AttrLabelProxy
#endif
getEventCrossingFocus :: MonadIO m => EventCrossing -> m Bool
getEventCrossingFocus :: forall (m :: * -> *). MonadIO m => EventCrossing -> m Bool
getEventCrossingFocus EventCrossing
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
CInt
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
60) :: IO CInt
let val' :: Bool
val' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
val
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
val'
setEventCrossingFocus :: MonadIO m => EventCrossing -> Bool -> m ()
setEventCrossingFocus :: forall (m :: * -> *). MonadIO m => EventCrossing -> Bool -> m ()
setEventCrossingFocus EventCrossing
s Bool
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
let val' :: CInt
val' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
val
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
60) (CInt
val' :: CInt)
#if defined(ENABLE_OVERLOADING)
data EventCrossingFocusFieldInfo
instance AttrInfo EventCrossingFocusFieldInfo where
type AttrBaseTypeConstraint EventCrossingFocusFieldInfo = (~) EventCrossing
type AttrAllowedOps EventCrossingFocusFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventCrossingFocusFieldInfo = (~) Bool
type AttrTransferTypeConstraint EventCrossingFocusFieldInfo = (~)Bool
type AttrTransferType EventCrossingFocusFieldInfo = Bool
type AttrGetType EventCrossingFocusFieldInfo = Bool
type AttrLabel EventCrossingFocusFieldInfo = "focus"
type AttrOrigin EventCrossingFocusFieldInfo = EventCrossing
attrGet = getEventCrossingFocus
attrSet = setEventCrossingFocus
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventCrossing.focus"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventCrossing.html#g:attr:focus"
})
eventCrossing_focus :: AttrLabelProxy "focus"
eventCrossing_focus = AttrLabelProxy
#endif
getEventCrossingState :: MonadIO m => EventCrossing -> m [Gdk.Flags.ModifierType]
getEventCrossingState :: forall (m :: * -> *).
MonadIO m =>
EventCrossing -> m [ModifierType]
getEventCrossingState EventCrossing
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
CUInt
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) :: IO CUInt
let val' :: [ModifierType]
val' = forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
val
forall (m :: * -> *) a. Monad m => a -> m a
return [ModifierType]
val'
setEventCrossingState :: MonadIO m => EventCrossing -> [Gdk.Flags.ModifierType] -> m ()
setEventCrossingState :: forall (m :: * -> *).
MonadIO m =>
EventCrossing -> [ModifierType] -> m ()
setEventCrossingState EventCrossing
s [ModifierType]
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 EventCrossing
s forall a b. (a -> b) -> a -> b
$ \Ptr EventCrossing
ptr -> do
let val' :: CUInt
val' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ModifierType]
val
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventCrossing
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
64) (CUInt
val' :: CUInt)
#if defined(ENABLE_OVERLOADING)
data EventCrossingStateFieldInfo
instance AttrInfo EventCrossingStateFieldInfo where
type AttrBaseTypeConstraint EventCrossingStateFieldInfo = (~) EventCrossing
type AttrAllowedOps EventCrossingStateFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventCrossingStateFieldInfo = (~) [Gdk.Flags.ModifierType]
type AttrTransferTypeConstraint EventCrossingStateFieldInfo = (~)[Gdk.Flags.ModifierType]
type AttrTransferType EventCrossingStateFieldInfo = [Gdk.Flags.ModifierType]
type AttrGetType EventCrossingStateFieldInfo = [Gdk.Flags.ModifierType]
type AttrLabel EventCrossingStateFieldInfo = "state"
type AttrOrigin EventCrossingStateFieldInfo = EventCrossing
attrGet = getEventCrossingState
attrSet = setEventCrossingState
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventCrossing.state"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventCrossing.html#g:attr:state"
})
eventCrossing_state :: AttrLabelProxy "state"
eventCrossing_state = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList EventCrossing
type instance O.AttributeList EventCrossing = EventCrossingAttributeList
type EventCrossingAttributeList = ('[ '("type", EventCrossingTypeFieldInfo), '("window", EventCrossingWindowFieldInfo), '("sendEvent", EventCrossingSendEventFieldInfo), '("subwindow", EventCrossingSubwindowFieldInfo), '("time", EventCrossingTimeFieldInfo), '("x", EventCrossingXFieldInfo), '("y", EventCrossingYFieldInfo), '("xRoot", EventCrossingXRootFieldInfo), '("yRoot", EventCrossingYRootFieldInfo), '("mode", EventCrossingModeFieldInfo), '("detail", EventCrossingDetailFieldInfo), '("focus", EventCrossingFocusFieldInfo), '("state", EventCrossingStateFieldInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveEventCrossingMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveEventCrossingMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveEventCrossingMethod t EventCrossing, O.OverloadedMethod info EventCrossing p) => OL.IsLabel t (EventCrossing -> 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 ~ ResolveEventCrossingMethod t EventCrossing, O.OverloadedMethod info EventCrossing p, R.HasField t EventCrossing p) => R.HasField t EventCrossing p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveEventCrossingMethod t EventCrossing, O.OverloadedMethodInfo info EventCrossing) => OL.IsLabel t (O.MethodProxy info EventCrossing) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif