{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Key event
-- 
-- /Since: 0.2/

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

module GI.Clutter.Structs.KeyEvent
    ( 

-- * Exported types
    KeyEvent(..)                            ,
    newZeroKeyEvent                         ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveKeyEventMethod                   ,
#endif



 -- * Properties


-- ** device #attr:device#
-- | the device that originated the event. If you want the physical
-- device the event originated from, use 'GI.Clutter.Unions.Event.eventGetSourceDevice'

    clearKeyEventDevice                     ,
    getKeyEventDevice                       ,
#if defined(ENABLE_OVERLOADING)
    keyEvent_device                         ,
#endif
    setKeyEventDevice                       ,


-- ** flags #attr:flags#
-- | event flags

    getKeyEventFlags                        ,
#if defined(ENABLE_OVERLOADING)
    keyEvent_flags                          ,
#endif
    setKeyEventFlags                        ,


-- ** hardwareKeycode #attr:hardwareKeycode#
-- | raw hardware key value

    getKeyEventHardwareKeycode              ,
#if defined(ENABLE_OVERLOADING)
    keyEvent_hardwareKeycode                ,
#endif
    setKeyEventHardwareKeycode              ,


-- ** keyval #attr:keyval#
-- | raw key value

    getKeyEventKeyval                       ,
#if defined(ENABLE_OVERLOADING)
    keyEvent_keyval                         ,
#endif
    setKeyEventKeyval                       ,


-- ** modifierState #attr:modifierState#
-- | key modifiers

    getKeyEventModifierState                ,
#if defined(ENABLE_OVERLOADING)
    keyEvent_modifierState                  ,
#endif
    setKeyEventModifierState                ,


-- ** source #attr:source#
-- | event source actor

    clearKeyEventSource                     ,
    getKeyEventSource                       ,
#if defined(ENABLE_OVERLOADING)
    keyEvent_source                         ,
#endif
    setKeyEventSource                       ,


-- ** stage #attr:stage#
-- | event source stage

    clearKeyEventStage                      ,
    getKeyEventStage                        ,
#if defined(ENABLE_OVERLOADING)
    keyEvent_stage                          ,
#endif
    setKeyEventStage                        ,


-- ** time #attr:time#
-- | event time

    getKeyEventTime                         ,
#if defined(ENABLE_OVERLOADING)
    keyEvent_time                           ,
#endif
    setKeyEventTime                         ,


-- ** type #attr:type#
-- | event type

    getKeyEventType                         ,
#if defined(ENABLE_OVERLOADING)
    keyEvent_type                           ,
#endif
    setKeyEventType                         ,


-- ** unicodeValue #attr:unicodeValue#
-- | Unicode representation

    getKeyEventUnicodeValue                 ,
#if defined(ENABLE_OVERLOADING)
    keyEvent_unicodeValue                   ,
#endif
    setKeyEventUnicodeValue                 ,




    ) 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.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.Clutter.Enums as Clutter.Enums
import {-# SOURCE #-} qualified GI.Clutter.Flags as Clutter.Flags
import {-# SOURCE #-} qualified GI.Clutter.Objects.Actor as Clutter.Actor
import {-# SOURCE #-} qualified GI.Clutter.Objects.InputDevice as Clutter.InputDevice
import {-# SOURCE #-} qualified GI.Clutter.Objects.Stage as Clutter.Stage

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

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

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


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

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


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

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

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

keyEvent_type :: AttrLabelProxy "type"
keyEvent_type = AttrLabelProxy

#endif


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

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

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

keyEvent_time :: AttrLabelProxy "time"
keyEvent_time = AttrLabelProxy

#endif


-- | Get the value of the “@flags@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' keyEvent #flags
-- @
getKeyEventFlags :: MonadIO m => KeyEvent -> m [Clutter.Flags.EventFlags]
getKeyEventFlags :: forall (m :: * -> *). MonadIO m => KeyEvent -> m [EventFlags]
getKeyEventFlags KeyEvent
s = IO [EventFlags] -> m [EventFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [EventFlags] -> m [EventFlags])
-> IO [EventFlags] -> m [EventFlags]
forall a b. (a -> b) -> a -> b
$ KeyEvent -> (Ptr KeyEvent -> IO [EventFlags]) -> IO [EventFlags]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr KeyEvent
s ((Ptr KeyEvent -> IO [EventFlags]) -> IO [EventFlags])
-> (Ptr KeyEvent -> IO [EventFlags]) -> IO [EventFlags]
forall a b. (a -> b) -> a -> b
$ \Ptr KeyEvent
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr KeyEvent
ptr Ptr KeyEvent -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO CUInt
    let val' :: [EventFlags]
val' = CUInt -> [EventFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
val
    [EventFlags] -> IO [EventFlags]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [EventFlags]
val'

-- | Set the value of the “@flags@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' keyEvent [ #flags 'Data.GI.Base.Attributes.:=' value ]
-- @
setKeyEventFlags :: MonadIO m => KeyEvent -> [Clutter.Flags.EventFlags] -> m ()
setKeyEventFlags :: forall (m :: * -> *). MonadIO m => KeyEvent -> [EventFlags] -> m ()
setKeyEventFlags KeyEvent
s [EventFlags]
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ KeyEvent -> (Ptr KeyEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr KeyEvent
s ((Ptr KeyEvent -> IO ()) -> IO ())
-> (Ptr KeyEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr KeyEvent
ptr -> do
    let val' :: CUInt
val' = [EventFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [EventFlags]
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr KeyEvent
ptr Ptr KeyEvent -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data KeyEventFlagsFieldInfo
instance AttrInfo KeyEventFlagsFieldInfo where
    type AttrBaseTypeConstraint KeyEventFlagsFieldInfo = (~) KeyEvent
    type AttrAllowedOps KeyEventFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint KeyEventFlagsFieldInfo = (~) [Clutter.Flags.EventFlags]
    type AttrTransferTypeConstraint KeyEventFlagsFieldInfo = (~)[Clutter.Flags.EventFlags]
    type AttrTransferType KeyEventFlagsFieldInfo = [Clutter.Flags.EventFlags]
    type AttrGetType KeyEventFlagsFieldInfo = [Clutter.Flags.EventFlags]
    type AttrLabel KeyEventFlagsFieldInfo = "flags"
    type AttrOrigin KeyEventFlagsFieldInfo = KeyEvent
    attrGet = getKeyEventFlags
    attrSet = setKeyEventFlags
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.KeyEvent.flags"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Structs-KeyEvent.html#g:attr:flags"
        })

keyEvent_flags :: AttrLabelProxy "flags"
keyEvent_flags = AttrLabelProxy

#endif


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

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

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

#if defined(ENABLE_OVERLOADING)
data KeyEventStageFieldInfo
instance AttrInfo KeyEventStageFieldInfo where
    type AttrBaseTypeConstraint KeyEventStageFieldInfo = (~) KeyEvent
    type AttrAllowedOps KeyEventStageFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint KeyEventStageFieldInfo = (~) (Ptr Clutter.Stage.Stage)
    type AttrTransferTypeConstraint KeyEventStageFieldInfo = (~)(Ptr Clutter.Stage.Stage)
    type AttrTransferType KeyEventStageFieldInfo = (Ptr Clutter.Stage.Stage)
    type AttrGetType KeyEventStageFieldInfo = Maybe Clutter.Stage.Stage
    type AttrLabel KeyEventStageFieldInfo = "stage"
    type AttrOrigin KeyEventStageFieldInfo = KeyEvent
    attrGet = getKeyEventStage
    attrSet = setKeyEventStage
    attrConstruct = undefined
    attrClear = clearKeyEventStage
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.KeyEvent.stage"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Structs-KeyEvent.html#g:attr:stage"
        })

keyEvent_stage :: AttrLabelProxy "stage"
keyEvent_stage = AttrLabelProxy

#endif


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

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

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

#if defined(ENABLE_OVERLOADING)
data KeyEventSourceFieldInfo
instance AttrInfo KeyEventSourceFieldInfo where
    type AttrBaseTypeConstraint KeyEventSourceFieldInfo = (~) KeyEvent
    type AttrAllowedOps KeyEventSourceFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint KeyEventSourceFieldInfo = (~) (Ptr Clutter.Actor.Actor)
    type AttrTransferTypeConstraint KeyEventSourceFieldInfo = (~)(Ptr Clutter.Actor.Actor)
    type AttrTransferType KeyEventSourceFieldInfo = (Ptr Clutter.Actor.Actor)
    type AttrGetType KeyEventSourceFieldInfo = Maybe Clutter.Actor.Actor
    type AttrLabel KeyEventSourceFieldInfo = "source"
    type AttrOrigin KeyEventSourceFieldInfo = KeyEvent
    attrGet = getKeyEventSource
    attrSet = setKeyEventSource
    attrConstruct = undefined
    attrClear = clearKeyEventSource
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.KeyEvent.source"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Structs-KeyEvent.html#g:attr:source"
        })

keyEvent_source :: AttrLabelProxy "source"
keyEvent_source = AttrLabelProxy

#endif


-- | Get the value of the “@modifier_state@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' keyEvent #modifierState
-- @
getKeyEventModifierState :: MonadIO m => KeyEvent -> m [Clutter.Flags.ModifierType]
getKeyEventModifierState :: forall (m :: * -> *). MonadIO m => KeyEvent -> m [ModifierType]
getKeyEventModifierState KeyEvent
s = IO [ModifierType] -> m [ModifierType]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [ModifierType] -> m [ModifierType])
-> IO [ModifierType] -> m [ModifierType]
forall a b. (a -> b) -> a -> b
$ KeyEvent
-> (Ptr KeyEvent -> IO [ModifierType]) -> IO [ModifierType]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr KeyEvent
s ((Ptr KeyEvent -> IO [ModifierType]) -> IO [ModifierType])
-> (Ptr KeyEvent -> IO [ModifierType]) -> IO [ModifierType]
forall a b. (a -> b) -> a -> b
$ \Ptr KeyEvent
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr KeyEvent
ptr Ptr KeyEvent -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO CUInt
    let val' :: [ModifierType]
val' = CUInt -> [ModifierType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
val
    [ModifierType] -> IO [ModifierType]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [ModifierType]
val'

-- | Set the value of the “@modifier_state@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' keyEvent [ #modifierState 'Data.GI.Base.Attributes.:=' value ]
-- @
setKeyEventModifierState :: MonadIO m => KeyEvent -> [Clutter.Flags.ModifierType] -> m ()
setKeyEventModifierState :: forall (m :: * -> *).
MonadIO m =>
KeyEvent -> [ModifierType] -> m ()
setKeyEventModifierState KeyEvent
s [ModifierType]
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ KeyEvent -> (Ptr KeyEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr KeyEvent
s ((Ptr KeyEvent -> IO ()) -> IO ())
-> (Ptr KeyEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr KeyEvent
ptr -> do
    let val' :: CUInt
val' = [ModifierType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ModifierType]
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr KeyEvent
ptr Ptr KeyEvent -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data KeyEventModifierStateFieldInfo
instance AttrInfo KeyEventModifierStateFieldInfo where
    type AttrBaseTypeConstraint KeyEventModifierStateFieldInfo = (~) KeyEvent
    type AttrAllowedOps KeyEventModifierStateFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint KeyEventModifierStateFieldInfo = (~) [Clutter.Flags.ModifierType]
    type AttrTransferTypeConstraint KeyEventModifierStateFieldInfo = (~)[Clutter.Flags.ModifierType]
    type AttrTransferType KeyEventModifierStateFieldInfo = [Clutter.Flags.ModifierType]
    type AttrGetType KeyEventModifierStateFieldInfo = [Clutter.Flags.ModifierType]
    type AttrLabel KeyEventModifierStateFieldInfo = "modifier_state"
    type AttrOrigin KeyEventModifierStateFieldInfo = KeyEvent
    attrGet = getKeyEventModifierState
    attrSet = setKeyEventModifierState
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.KeyEvent.modifierState"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Structs-KeyEvent.html#g:attr:modifierState"
        })

keyEvent_modifierState :: AttrLabelProxy "modifierState"
keyEvent_modifierState = AttrLabelProxy

#endif


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

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

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

keyEvent_keyval :: AttrLabelProxy "keyval"
keyEvent_keyval = AttrLabelProxy

#endif


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

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

#if defined(ENABLE_OVERLOADING)
data KeyEventHardwareKeycodeFieldInfo
instance AttrInfo KeyEventHardwareKeycodeFieldInfo where
    type AttrBaseTypeConstraint KeyEventHardwareKeycodeFieldInfo = (~) KeyEvent
    type AttrAllowedOps KeyEventHardwareKeycodeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint KeyEventHardwareKeycodeFieldInfo = (~) Word16
    type AttrTransferTypeConstraint KeyEventHardwareKeycodeFieldInfo = (~)Word16
    type AttrTransferType KeyEventHardwareKeycodeFieldInfo = Word16
    type AttrGetType KeyEventHardwareKeycodeFieldInfo = Word16
    type AttrLabel KeyEventHardwareKeycodeFieldInfo = "hardware_keycode"
    type AttrOrigin KeyEventHardwareKeycodeFieldInfo = KeyEvent
    attrGet = getKeyEventHardwareKeycode
    attrSet = setKeyEventHardwareKeycode
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.KeyEvent.hardwareKeycode"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Structs-KeyEvent.html#g:attr:hardwareKeycode"
        })

keyEvent_hardwareKeycode :: AttrLabelProxy "hardwareKeycode"
keyEvent_hardwareKeycode = AttrLabelProxy

#endif


-- | Get the value of the “@unicode_value@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' keyEvent #unicodeValue
-- @
getKeyEventUnicodeValue :: MonadIO m => KeyEvent -> m Char
getKeyEventUnicodeValue :: forall (m :: * -> *). MonadIO m => KeyEvent -> m Char
getKeyEventUnicodeValue KeyEvent
s = IO Char -> m Char
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Char -> m Char) -> IO Char -> m Char
forall a b. (a -> b) -> a -> b
$ KeyEvent -> (Ptr KeyEvent -> IO Char) -> IO Char
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr KeyEvent
s ((Ptr KeyEvent -> IO Char) -> IO Char)
-> (Ptr KeyEvent -> IO Char) -> IO Char
forall a b. (a -> b) -> a -> b
$ \Ptr KeyEvent
ptr -> do
    CInt
val <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr KeyEvent
ptr Ptr KeyEvent -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
44) :: IO CInt
    let val' :: Char
val' = (Int -> Char
chr (Int -> Char) -> (CInt -> Int) -> CInt -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
val
    Char -> IO Char
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Char
val'

-- | Set the value of the “@unicode_value@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' keyEvent [ #unicodeValue 'Data.GI.Base.Attributes.:=' value ]
-- @
setKeyEventUnicodeValue :: MonadIO m => KeyEvent -> Char -> m ()
setKeyEventUnicodeValue :: forall (m :: * -> *). MonadIO m => KeyEvent -> Char -> m ()
setKeyEventUnicodeValue KeyEvent
s Char
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ KeyEvent -> (Ptr KeyEvent -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr KeyEvent
s ((Ptr KeyEvent -> IO ()) -> IO ())
-> (Ptr KeyEvent -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr KeyEvent
ptr -> do
    let val' :: CInt
val' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Char -> Int) -> Char -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
ord) Char
val
    Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr KeyEvent
ptr Ptr KeyEvent -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
44) (CInt
val' :: CInt)

#if defined(ENABLE_OVERLOADING)
data KeyEventUnicodeValueFieldInfo
instance AttrInfo KeyEventUnicodeValueFieldInfo where
    type AttrBaseTypeConstraint KeyEventUnicodeValueFieldInfo = (~) KeyEvent
    type AttrAllowedOps KeyEventUnicodeValueFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint KeyEventUnicodeValueFieldInfo = (~) Char
    type AttrTransferTypeConstraint KeyEventUnicodeValueFieldInfo = (~)Char
    type AttrTransferType KeyEventUnicodeValueFieldInfo = Char
    type AttrGetType KeyEventUnicodeValueFieldInfo = Char
    type AttrLabel KeyEventUnicodeValueFieldInfo = "unicode_value"
    type AttrOrigin KeyEventUnicodeValueFieldInfo = KeyEvent
    attrGet = getKeyEventUnicodeValue
    attrSet = setKeyEventUnicodeValue
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.KeyEvent.unicodeValue"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Structs-KeyEvent.html#g:attr:unicodeValue"
        })

keyEvent_unicodeValue :: AttrLabelProxy "unicodeValue"
keyEvent_unicodeValue = AttrLabelProxy

#endif


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

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

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

#if defined(ENABLE_OVERLOADING)
data KeyEventDeviceFieldInfo
instance AttrInfo KeyEventDeviceFieldInfo where
    type AttrBaseTypeConstraint KeyEventDeviceFieldInfo = (~) KeyEvent
    type AttrAllowedOps KeyEventDeviceFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint KeyEventDeviceFieldInfo = (~) (Ptr Clutter.InputDevice.InputDevice)
    type AttrTransferTypeConstraint KeyEventDeviceFieldInfo = (~)(Ptr Clutter.InputDevice.InputDevice)
    type AttrTransferType KeyEventDeviceFieldInfo = (Ptr Clutter.InputDevice.InputDevice)
    type AttrGetType KeyEventDeviceFieldInfo = Maybe Clutter.InputDevice.InputDevice
    type AttrLabel KeyEventDeviceFieldInfo = "device"
    type AttrOrigin KeyEventDeviceFieldInfo = KeyEvent
    attrGet = getKeyEventDevice
    attrSet = setKeyEventDevice
    attrConstruct = undefined
    attrClear = clearKeyEventDevice
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Clutter.Structs.KeyEvent.device"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-clutter-1.0.3/docs/GI-Clutter-Structs-KeyEvent.html#g:attr:device"
        })

keyEvent_device :: AttrLabelProxy "device"
keyEvent_device = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList KeyEvent
type instance O.AttributeList KeyEvent = KeyEventAttributeList
type KeyEventAttributeList = ('[ '("type", KeyEventTypeFieldInfo), '("time", KeyEventTimeFieldInfo), '("flags", KeyEventFlagsFieldInfo), '("stage", KeyEventStageFieldInfo), '("source", KeyEventSourceFieldInfo), '("modifierState", KeyEventModifierStateFieldInfo), '("keyval", KeyEventKeyvalFieldInfo), '("hardwareKeycode", KeyEventHardwareKeycodeFieldInfo), '("unicodeValue", KeyEventUnicodeValueFieldInfo), '("device", KeyEventDeviceFieldInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveKeyEventMethod (t :: Symbol) (o :: *) :: * where
    ResolveKeyEventMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif