{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gdk.Structs.EventKey
(
EventKey(..) ,
newZeroEventKey ,
#if defined(ENABLE_OVERLOADING)
ResolveEventKeyMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
eventKey_group ,
#endif
getEventKeyGroup ,
setEventKeyGroup ,
#if defined(ENABLE_OVERLOADING)
eventKey_hardwareKeycode ,
#endif
getEventKeyHardwareKeycode ,
setEventKeyHardwareKeycode ,
#if defined(ENABLE_OVERLOADING)
eventKey_isModifier ,
#endif
getEventKeyIsModifier ,
setEventKeyIsModifier ,
#if defined(ENABLE_OVERLOADING)
eventKey_keyval ,
#endif
getEventKeyKeyval ,
setEventKeyKeyval ,
#if defined(ENABLE_OVERLOADING)
eventKey_length ,
#endif
getEventKeyLength ,
setEventKeyLength ,
#if defined(ENABLE_OVERLOADING)
eventKey_sendEvent ,
#endif
getEventKeySendEvent ,
setEventKeySendEvent ,
#if defined(ENABLE_OVERLOADING)
eventKey_state ,
#endif
getEventKeyState ,
setEventKeyState ,
clearEventKeyString ,
#if defined(ENABLE_OVERLOADING)
eventKey_string ,
#endif
getEventKeyString ,
setEventKeyString ,
#if defined(ENABLE_OVERLOADING)
eventKey_time ,
#endif
getEventKeyTime ,
setEventKeyTime ,
#if defined(ENABLE_OVERLOADING)
eventKey_type ,
#endif
getEventKeyType ,
setEventKeyType ,
clearEventKeyWindow ,
#if defined(ENABLE_OVERLOADING)
eventKey_window ,
#endif
getEventKeyWindow ,
setEventKeyWindow ,
) 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 EventKey = EventKey (SP.ManagedPtr EventKey)
deriving (EventKey -> EventKey -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EventKey -> EventKey -> Bool
$c/= :: EventKey -> EventKey -> Bool
== :: EventKey -> EventKey -> Bool
$c== :: EventKey -> EventKey -> Bool
Eq)
instance SP.ManagedPtrNewtype EventKey where
toManagedPtr :: EventKey -> ManagedPtr EventKey
toManagedPtr (EventKey ManagedPtr EventKey
p) = ManagedPtr EventKey
p
instance BoxedPtr EventKey where
boxedPtrCopy :: EventKey -> IO EventKey
boxedPtrCopy = \EventKey
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr EventKey
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
40 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 EventKey -> EventKey
EventKey)
boxedPtrFree :: EventKey -> IO ()
boxedPtrFree = \EventKey
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr EventKey
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr EventKey where
boxedPtrCalloc :: IO (Ptr EventKey)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
40
newZeroEventKey :: MonadIO m => m EventKey
newZeroEventKey :: forall (m :: * -> *). MonadIO m => m EventKey
newZeroEventKey = 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 EventKey -> EventKey
EventKey
instance tag ~ 'AttrSet => Constructible EventKey tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr EventKey -> EventKey)
-> [AttrOp EventKey tag] -> m EventKey
new ManagedPtr EventKey -> EventKey
_ [AttrOp EventKey tag]
attrs = do
EventKey
o <- forall (m :: * -> *). MonadIO m => m EventKey
newZeroEventKey
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set EventKey
o [AttrOp EventKey tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return EventKey
o
getEventKeyType :: MonadIO m => EventKey -> m Gdk.Enums.EventType
getEventKeyType :: forall (m :: * -> *). MonadIO m => EventKey -> m EventType
getEventKeyType EventKey
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
CInt
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventKey
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'
setEventKeyType :: MonadIO m => EventKey -> Gdk.Enums.EventType -> m ()
setEventKeyType :: forall (m :: * -> *). MonadIO m => EventKey -> EventType -> m ()
setEventKeyType EventKey
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
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 EventKey
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CInt
val' :: CInt)
#if defined(ENABLE_OVERLOADING)
data EventKeyTypeFieldInfo
instance AttrInfo EventKeyTypeFieldInfo where
type AttrBaseTypeConstraint EventKeyTypeFieldInfo = (~) EventKey
type AttrAllowedOps EventKeyTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventKeyTypeFieldInfo = (~) Gdk.Enums.EventType
type AttrTransferTypeConstraint EventKeyTypeFieldInfo = (~)Gdk.Enums.EventType
type AttrTransferType EventKeyTypeFieldInfo = Gdk.Enums.EventType
type AttrGetType EventKeyTypeFieldInfo = Gdk.Enums.EventType
type AttrLabel EventKeyTypeFieldInfo = "type"
type AttrOrigin EventKeyTypeFieldInfo = EventKey
attrGet = getEventKeyType
attrSet = setEventKeyType
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventKey.type"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventKey.html#g:attr:type"
})
eventKey_type :: AttrLabelProxy "type"
eventKey_type = AttrLabelProxy
#endif
getEventKeyWindow :: MonadIO m => EventKey -> m (Maybe Gdk.Window.Window)
getEventKeyWindow :: forall (m :: * -> *). MonadIO m => EventKey -> m (Maybe Window)
getEventKeyWindow EventKey
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
Ptr Window
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventKey
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
setEventKeyWindow :: MonadIO m => EventKey -> Ptr Gdk.Window.Window -> m ()
setEventKeyWindow :: forall (m :: * -> *). MonadIO m => EventKey -> Ptr Window -> m ()
setEventKeyWindow EventKey
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventKey
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (Ptr Window
val :: Ptr Gdk.Window.Window)
clearEventKeyWindow :: MonadIO m => EventKey -> m ()
clearEventKeyWindow :: forall (m :: * -> *). MonadIO m => EventKey -> m ()
clearEventKeyWindow EventKey
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventKey
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 EventKeyWindowFieldInfo
instance AttrInfo EventKeyWindowFieldInfo where
type AttrBaseTypeConstraint EventKeyWindowFieldInfo = (~) EventKey
type AttrAllowedOps EventKeyWindowFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint EventKeyWindowFieldInfo = (~) (Ptr Gdk.Window.Window)
type AttrTransferTypeConstraint EventKeyWindowFieldInfo = (~)(Ptr Gdk.Window.Window)
type AttrTransferType EventKeyWindowFieldInfo = (Ptr Gdk.Window.Window)
type AttrGetType EventKeyWindowFieldInfo = Maybe Gdk.Window.Window
type AttrLabel EventKeyWindowFieldInfo = "window"
type AttrOrigin EventKeyWindowFieldInfo = EventKey
attrGet = getEventKeyWindow
attrSet = setEventKeyWindow
attrConstruct = undefined
attrClear = clearEventKeyWindow
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventKey.window"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventKey.html#g:attr:window"
})
eventKey_window :: AttrLabelProxy "window"
eventKey_window = AttrLabelProxy
#endif
getEventKeySendEvent :: MonadIO m => EventKey -> m Int8
getEventKeySendEvent :: forall (m :: * -> *). MonadIO m => EventKey -> m Int8
getEventKeySendEvent EventKey
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
Int8
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventKey
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
setEventKeySendEvent :: MonadIO m => EventKey -> Int8 -> m ()
setEventKeySendEvent :: forall (m :: * -> *). MonadIO m => EventKey -> Int8 -> m ()
setEventKeySendEvent EventKey
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventKey
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Int8
val :: Int8)
#if defined(ENABLE_OVERLOADING)
data EventKeySendEventFieldInfo
instance AttrInfo EventKeySendEventFieldInfo where
type AttrBaseTypeConstraint EventKeySendEventFieldInfo = (~) EventKey
type AttrAllowedOps EventKeySendEventFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventKeySendEventFieldInfo = (~) Int8
type AttrTransferTypeConstraint EventKeySendEventFieldInfo = (~)Int8
type AttrTransferType EventKeySendEventFieldInfo = Int8
type AttrGetType EventKeySendEventFieldInfo = Int8
type AttrLabel EventKeySendEventFieldInfo = "send_event"
type AttrOrigin EventKeySendEventFieldInfo = EventKey
attrGet = getEventKeySendEvent
attrSet = setEventKeySendEvent
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventKey.sendEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventKey.html#g:attr:sendEvent"
})
eventKey_sendEvent :: AttrLabelProxy "sendEvent"
eventKey_sendEvent = AttrLabelProxy
#endif
getEventKeyTime :: MonadIO m => EventKey -> m Word32
getEventKeyTime :: forall (m :: * -> *). MonadIO m => EventKey -> m Word32
getEventKeyTime EventKey
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventKey
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setEventKeyTime :: MonadIO m => EventKey -> Word32 -> m ()
setEventKeyTime :: forall (m :: * -> *). MonadIO m => EventKey -> Word32 -> m ()
setEventKeyTime EventKey
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventKey
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data EventKeyTimeFieldInfo
instance AttrInfo EventKeyTimeFieldInfo where
type AttrBaseTypeConstraint EventKeyTimeFieldInfo = (~) EventKey
type AttrAllowedOps EventKeyTimeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventKeyTimeFieldInfo = (~) Word32
type AttrTransferTypeConstraint EventKeyTimeFieldInfo = (~)Word32
type AttrTransferType EventKeyTimeFieldInfo = Word32
type AttrGetType EventKeyTimeFieldInfo = Word32
type AttrLabel EventKeyTimeFieldInfo = "time"
type AttrOrigin EventKeyTimeFieldInfo = EventKey
attrGet = getEventKeyTime
attrSet = setEventKeyTime
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventKey.time"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventKey.html#g:attr:time"
})
eventKey_time :: AttrLabelProxy "time"
eventKey_time = AttrLabelProxy
#endif
getEventKeyState :: MonadIO m => EventKey -> m [Gdk.Flags.ModifierType]
getEventKeyState :: forall (m :: * -> *). MonadIO m => EventKey -> m [ModifierType]
getEventKeyState EventKey
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
CUInt
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventKey
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: 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'
setEventKeyState :: MonadIO m => EventKey -> [Gdk.Flags.ModifierType] -> m ()
setEventKeyState :: forall (m :: * -> *).
MonadIO m =>
EventKey -> [ModifierType] -> m ()
setEventKeyState EventKey
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
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 EventKey
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CUInt
val' :: CUInt)
#if defined(ENABLE_OVERLOADING)
data EventKeyStateFieldInfo
instance AttrInfo EventKeyStateFieldInfo where
type AttrBaseTypeConstraint EventKeyStateFieldInfo = (~) EventKey
type AttrAllowedOps EventKeyStateFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventKeyStateFieldInfo = (~) [Gdk.Flags.ModifierType]
type AttrTransferTypeConstraint EventKeyStateFieldInfo = (~)[Gdk.Flags.ModifierType]
type AttrTransferType EventKeyStateFieldInfo = [Gdk.Flags.ModifierType]
type AttrGetType EventKeyStateFieldInfo = [Gdk.Flags.ModifierType]
type AttrLabel EventKeyStateFieldInfo = "state"
type AttrOrigin EventKeyStateFieldInfo = EventKey
attrGet = getEventKeyState
attrSet = setEventKeyState
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventKey.state"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventKey.html#g:attr:state"
})
eventKey_state :: AttrLabelProxy "state"
eventKey_state = AttrLabelProxy
#endif
getEventKeyKeyval :: MonadIO m => EventKey -> m Word32
getEventKeyKeyval :: forall (m :: * -> *). MonadIO m => EventKey -> m Word32
getEventKeyKeyval EventKey
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventKey
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) :: IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setEventKeyKeyval :: MonadIO m => EventKey -> Word32 -> m ()
setEventKeyKeyval :: forall (m :: * -> *). MonadIO m => EventKey -> Word32 -> m ()
setEventKeyKeyval EventKey
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventKey
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data EventKeyKeyvalFieldInfo
instance AttrInfo EventKeyKeyvalFieldInfo where
type AttrBaseTypeConstraint EventKeyKeyvalFieldInfo = (~) EventKey
type AttrAllowedOps EventKeyKeyvalFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventKeyKeyvalFieldInfo = (~) Word32
type AttrTransferTypeConstraint EventKeyKeyvalFieldInfo = (~)Word32
type AttrTransferType EventKeyKeyvalFieldInfo = Word32
type AttrGetType EventKeyKeyvalFieldInfo = Word32
type AttrLabel EventKeyKeyvalFieldInfo = "keyval"
type AttrOrigin EventKeyKeyvalFieldInfo = EventKey
attrGet = getEventKeyKeyval
attrSet = setEventKeyKeyval
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventKey.keyval"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventKey.html#g:attr:keyval"
})
eventKey_keyval :: AttrLabelProxy "keyval"
eventKey_keyval = AttrLabelProxy
#endif
getEventKeyLength :: MonadIO m => EventKey -> m Int32
getEventKeyLength :: forall (m :: * -> *). MonadIO m => EventKey -> m Int32
getEventKeyLength EventKey
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
Int32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventKey
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setEventKeyLength :: MonadIO m => EventKey -> Int32 -> m ()
setEventKeyLength :: forall (m :: * -> *). MonadIO m => EventKey -> Int32 -> m ()
setEventKeyLength EventKey
s Int32
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventKey
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data EventKeyLengthFieldInfo
instance AttrInfo EventKeyLengthFieldInfo where
type AttrBaseTypeConstraint EventKeyLengthFieldInfo = (~) EventKey
type AttrAllowedOps EventKeyLengthFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventKeyLengthFieldInfo = (~) Int32
type AttrTransferTypeConstraint EventKeyLengthFieldInfo = (~)Int32
type AttrTransferType EventKeyLengthFieldInfo = Int32
type AttrGetType EventKeyLengthFieldInfo = Int32
type AttrLabel EventKeyLengthFieldInfo = "length"
type AttrOrigin EventKeyLengthFieldInfo = EventKey
attrGet = getEventKeyLength
attrSet = setEventKeyLength
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventKey.length"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventKey.html#g:attr:length"
})
eventKey_length :: AttrLabelProxy "length"
eventKey_length = AttrLabelProxy
#endif
getEventKeyString :: MonadIO m => EventKey -> m (Maybe T.Text)
getEventKeyString :: forall (m :: * -> *). MonadIO m => EventKey -> m (Maybe Text)
getEventKeyString EventKey
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventKey
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) :: IO CString
Maybe Text
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
cstringToText CString
val'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setEventKeyString :: MonadIO m => EventKey -> CString -> m ()
setEventKeyString :: forall (m :: * -> *). MonadIO m => EventKey -> CString -> m ()
setEventKeyString EventKey
s CString
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventKey
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) (CString
val :: CString)
clearEventKeyString :: MonadIO m => EventKey -> m ()
clearEventKeyString :: forall (m :: * -> *). MonadIO m => EventKey -> m ()
clearEventKeyString EventKey
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventKey
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) (forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data EventKeyStringFieldInfo
instance AttrInfo EventKeyStringFieldInfo where
type AttrBaseTypeConstraint EventKeyStringFieldInfo = (~) EventKey
type AttrAllowedOps EventKeyStringFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint EventKeyStringFieldInfo = (~) CString
type AttrTransferTypeConstraint EventKeyStringFieldInfo = (~)CString
type AttrTransferType EventKeyStringFieldInfo = CString
type AttrGetType EventKeyStringFieldInfo = Maybe T.Text
type AttrLabel EventKeyStringFieldInfo = "string"
type AttrOrigin EventKeyStringFieldInfo = EventKey
attrGet = getEventKeyString
attrSet = setEventKeyString
attrConstruct = undefined
attrClear = clearEventKeyString
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventKey.string"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventKey.html#g:attr:string"
})
eventKey_string :: AttrLabelProxy "string"
eventKey_string = AttrLabelProxy
#endif
getEventKeyHardwareKeycode :: MonadIO m => EventKey -> m Word16
getEventKeyHardwareKeycode :: forall (m :: * -> *). MonadIO m => EventKey -> m Word16
getEventKeyHardwareKeycode EventKey
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
Word16
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventKey
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO Word16
forall (m :: * -> *) a. Monad m => a -> m a
return Word16
val
setEventKeyHardwareKeycode :: MonadIO m => EventKey -> Word16 -> m ()
setEventKeyHardwareKeycode :: forall (m :: * -> *). MonadIO m => EventKey -> Word16 -> m ()
setEventKeyHardwareKeycode EventKey
s Word16
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventKey
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (Word16
val :: Word16)
#if defined(ENABLE_OVERLOADING)
data EventKeyHardwareKeycodeFieldInfo
instance AttrInfo EventKeyHardwareKeycodeFieldInfo where
type AttrBaseTypeConstraint EventKeyHardwareKeycodeFieldInfo = (~) EventKey
type AttrAllowedOps EventKeyHardwareKeycodeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventKeyHardwareKeycodeFieldInfo = (~) Word16
type AttrTransferTypeConstraint EventKeyHardwareKeycodeFieldInfo = (~)Word16
type AttrTransferType EventKeyHardwareKeycodeFieldInfo = Word16
type AttrGetType EventKeyHardwareKeycodeFieldInfo = Word16
type AttrLabel EventKeyHardwareKeycodeFieldInfo = "hardware_keycode"
type AttrOrigin EventKeyHardwareKeycodeFieldInfo = EventKey
attrGet = getEventKeyHardwareKeycode
attrSet = setEventKeyHardwareKeycode
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventKey.hardwareKeycode"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventKey.html#g:attr:hardwareKeycode"
})
eventKey_hardwareKeycode :: AttrLabelProxy "hardwareKeycode"
eventKey_hardwareKeycode = AttrLabelProxy
#endif
getEventKeyGroup :: MonadIO m => EventKey -> m Word8
getEventKeyGroup :: forall (m :: * -> *). MonadIO m => EventKey -> m Word8
getEventKeyGroup EventKey
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
Word8
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventKey
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
34) :: IO Word8
forall (m :: * -> *) a. Monad m => a -> m a
return Word8
val
setEventKeyGroup :: MonadIO m => EventKey -> Word8 -> m ()
setEventKeyGroup :: forall (m :: * -> *). MonadIO m => EventKey -> Word8 -> m ()
setEventKeyGroup EventKey
s Word8
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventKey
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
34) (Word8
val :: Word8)
#if defined(ENABLE_OVERLOADING)
data EventKeyGroupFieldInfo
instance AttrInfo EventKeyGroupFieldInfo where
type AttrBaseTypeConstraint EventKeyGroupFieldInfo = (~) EventKey
type AttrAllowedOps EventKeyGroupFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventKeyGroupFieldInfo = (~) Word8
type AttrTransferTypeConstraint EventKeyGroupFieldInfo = (~)Word8
type AttrTransferType EventKeyGroupFieldInfo = Word8
type AttrGetType EventKeyGroupFieldInfo = Word8
type AttrLabel EventKeyGroupFieldInfo = "group"
type AttrOrigin EventKeyGroupFieldInfo = EventKey
attrGet = getEventKeyGroup
attrSet = setEventKeyGroup
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventKey.group"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventKey.html#g:attr:group"
})
eventKey_group :: AttrLabelProxy "group"
eventKey_group = AttrLabelProxy
#endif
getEventKeyIsModifier :: MonadIO m => EventKey -> m Word32
getEventKeyIsModifier :: forall (m :: * -> *). MonadIO m => EventKey -> m Word32
getEventKeyIsModifier EventKey
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr EventKey
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36) :: IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setEventKeyIsModifier :: MonadIO m => EventKey -> Word32 -> m ()
setEventKeyIsModifier :: forall (m :: * -> *). MonadIO m => EventKey -> Word32 -> m ()
setEventKeyIsModifier EventKey
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 EventKey
s forall a b. (a -> b) -> a -> b
$ \Ptr EventKey
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr EventKey
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
36) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data EventKeyIsModifierFieldInfo
instance AttrInfo EventKeyIsModifierFieldInfo where
type AttrBaseTypeConstraint EventKeyIsModifierFieldInfo = (~) EventKey
type AttrAllowedOps EventKeyIsModifierFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint EventKeyIsModifierFieldInfo = (~) Word32
type AttrTransferTypeConstraint EventKeyIsModifierFieldInfo = (~)Word32
type AttrTransferType EventKeyIsModifierFieldInfo = Word32
type AttrGetType EventKeyIsModifierFieldInfo = Word32
type AttrLabel EventKeyIsModifierFieldInfo = "is_modifier"
type AttrOrigin EventKeyIsModifierFieldInfo = EventKey
attrGet = getEventKeyIsModifier
attrSet = setEventKeyIsModifier
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gdk.Structs.EventKey.isModifier"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gdk-3.0.26/docs/GI-Gdk-Structs-EventKey.html#g:attr:isModifier"
})
eventKey_isModifier :: AttrLabelProxy "isModifier"
eventKey_isModifier = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList EventKey
type instance O.AttributeList EventKey = EventKeyAttributeList
type EventKeyAttributeList = ('[ '("type", EventKeyTypeFieldInfo), '("window", EventKeyWindowFieldInfo), '("sendEvent", EventKeySendEventFieldInfo), '("time", EventKeyTimeFieldInfo), '("state", EventKeyStateFieldInfo), '("keyval", EventKeyKeyvalFieldInfo), '("length", EventKeyLengthFieldInfo), '("string", EventKeyStringFieldInfo), '("hardwareKeycode", EventKeyHardwareKeycodeFieldInfo), '("group", EventKeyGroupFieldInfo), '("isModifier", EventKeyIsModifierFieldInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveEventKeyMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveEventKeyMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveEventKeyMethod t EventKey, O.OverloadedMethod info EventKey p) => OL.IsLabel t (EventKey -> 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 ~ ResolveEventKeyMethod t EventKey, O.OverloadedMethod info EventKey p, R.HasField t EventKey p) => R.HasField t EventKey p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveEventKeyMethod t EventKey, O.OverloadedMethodInfo info EventKey) => OL.IsLabel t (O.MethodProxy info EventKey) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif