    {- |
    Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    License    : LGPL-2.1
    Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

    Encapsulates information about a key event.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Atk.Structs.KeyEventStruct
        (

    -- * Exported types
        KeyEventStruct(..)                      ,
        newZeroKeyEventStruct                   ,
        noKeyEventStruct                        ,

     -- * Properties
    -- ** keycode #attr:keycode#
    {- | The raw hardware code that generated the key event.  This field is raraly useful.
    -}
        getKeyEventStructKeycode                ,
    #if ENABLE_OVERLOADING
        keyEventStruct_keycode                  ,
    #endif
        setKeyEventStructKeycode                ,

    -- ** keyval #attr:keyval#
    {- | A guint representing a keysym value corresponding to those used by GDK and X11: see
    \/usr\/X11\/include\/keysymdef.h.
    -}
        getKeyEventStructKeyval                 ,
    #if ENABLE_OVERLOADING
        keyEventStruct_keyval                   ,
    #endif
        setKeyEventStructKeyval                 ,

    -- ** length #attr:length#
    {- | The length of member @/string/@.
    -}
        getKeyEventStructLength                 ,
    #if ENABLE_OVERLOADING
        keyEventStruct_length                   ,
    #endif
        setKeyEventStructLength                 ,

    -- ** state #attr:state#
    {- | A bitmask representing the state of the modifier keys immediately after the event takes place.
    The meaning of the bits is currently defined to match the bitmask used by GDK in
    GdkEventType.state, see
    http:\/\/developer.gnome.org\/doc\/API\/2.0\/gdk\/gdk-Event-Structures.html@/GdkEventKey/@
    -}
        getKeyEventStructState                  ,
    #if ENABLE_OVERLOADING
        keyEventStruct_state                    ,
    #endif
        setKeyEventStructState                  ,

    -- ** string #attr:string#
    {- | A string containing one of the following: either a string approximating the text that would
    result from this keypress, if the key is a control or graphic character, or a symbolic name for this keypress.
    Alphanumeric and printable keys will have the symbolic key name in this string member, for instance \"A\". \"0\",
    \"semicolon\", \"aacute\".  Keypad keys have the prefix \"KP\".
    -}
        clearKeyEventStructString               ,
        getKeyEventStructString                 ,
    #if ENABLE_OVERLOADING
        keyEventStruct_string                   ,
    #endif
        setKeyEventStructString                 ,

    -- ** timestamp #attr:timestamp#
    {- | A timestamp in milliseconds indicating when the event occurred.
    These timestamps are relative to a starting point which should be considered arbitrary,
    and only used to compare the dispatch times of events to one another.
    -}
        getKeyEventStructTimestamp              ,
    #if ENABLE_OVERLOADING
        keyEventStruct_timestamp                ,
    #endif
        setKeyEventStructTimestamp              ,

    -- ** type #attr:type#
    {- | An AtkKeyEventType, generally one of ATK_KEY_EVENT_PRESS or ATK_KEY_EVENT_RELEASE
    -}
        getKeyEventStructType                   ,
    #if ENABLE_OVERLOADING
        keyEventStruct_type                     ,
    #endif
        setKeyEventStructType                   ,

        ) 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.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GError as B.GError
    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.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    -- | Memory-managed wrapper type.
    newtype KeyEventStruct = KeyEventStruct (ManagedPtr KeyEventStruct)
    instance WrappedPtr KeyEventStruct where
        wrappedPtrCalloc = callocBytes 32
        wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 32 >=> wrapPtr KeyEventStruct)
        wrappedPtrFree = Just ptr_to_g_free

    -- | Construct a `KeyEventStruct` struct initialized to zero.
    newZeroKeyEventStruct :: MonadIO m => m KeyEventStruct
    newZeroKeyEventStruct = liftIO $ wrappedPtrCalloc >>= wrapPtr KeyEventStruct

    instance tag ~ 'AttrSet => Constructible KeyEventStruct tag where
        new _ attrs = do
            o <- newZeroKeyEventStruct
            GI.Attributes.set o attrs
            return o

    -- | A convenience alias for `Nothing` :: `Maybe` `KeyEventStruct`.
    noKeyEventStruct :: Maybe KeyEventStruct
    noKeyEventStruct = Nothing

    {- |
    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' keyEventStruct #type
    @
    -}
    getKeyEventStructType :: MonadIO m => KeyEventStruct -> m Int32
    getKeyEventStructType s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 0) :: IO Int32
        return 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' keyEventStruct [ #type 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setKeyEventStructType :: MonadIO m => KeyEventStruct -> Int32 -> m ()
    setKeyEventStructType s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 0) (val :: Int32)

    #if ENABLE_OVERLOADING
    data KeyEventStructTypeFieldInfo
    instance AttrInfo KeyEventStructTypeFieldInfo where
        type AttrAllowedOps KeyEventStructTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint KeyEventStructTypeFieldInfo = (~) Int32
        type AttrBaseTypeConstraint KeyEventStructTypeFieldInfo = (~) KeyEventStruct
        type AttrGetType KeyEventStructTypeFieldInfo = Int32
        type AttrLabel KeyEventStructTypeFieldInfo = "type"
        type AttrOrigin KeyEventStructTypeFieldInfo = KeyEventStruct
        attrGet _ = getKeyEventStructType
        attrSet _ = setKeyEventStructType
        attrConstruct = undefined
        attrClear _ = undefined

    keyEventStruct_type :: AttrLabelProxy "type"
    keyEventStruct_type = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@state@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' keyEventStruct #state
    @
    -}
    getKeyEventStructState :: MonadIO m => KeyEventStruct -> m Word32
    getKeyEventStructState s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 4) :: IO Word32
        return val

    {- |
    Set the value of the “@state@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' keyEventStruct [ #state 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setKeyEventStructState :: MonadIO m => KeyEventStruct -> Word32 -> m ()
    setKeyEventStructState s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 4) (val :: Word32)

    #if ENABLE_OVERLOADING
    data KeyEventStructStateFieldInfo
    instance AttrInfo KeyEventStructStateFieldInfo where
        type AttrAllowedOps KeyEventStructStateFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint KeyEventStructStateFieldInfo = (~) Word32
        type AttrBaseTypeConstraint KeyEventStructStateFieldInfo = (~) KeyEventStruct
        type AttrGetType KeyEventStructStateFieldInfo = Word32
        type AttrLabel KeyEventStructStateFieldInfo = "state"
        type AttrOrigin KeyEventStructStateFieldInfo = KeyEventStruct
        attrGet _ = getKeyEventStructState
        attrSet _ = setKeyEventStructState
        attrConstruct = undefined
        attrClear _ = undefined

    keyEventStruct_state :: AttrLabelProxy "state"
    keyEventStruct_state = 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' keyEventStruct #keyval
    @
    -}
    getKeyEventStructKeyval :: MonadIO m => KeyEventStruct -> m Word32
    getKeyEventStructKeyval s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 8) :: IO Word32
        return 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' keyEventStruct [ #keyval 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setKeyEventStructKeyval :: MonadIO m => KeyEventStruct -> Word32 -> m ()
    setKeyEventStructKeyval s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 8) (val :: Word32)

    #if ENABLE_OVERLOADING
    data KeyEventStructKeyvalFieldInfo
    instance AttrInfo KeyEventStructKeyvalFieldInfo where
        type AttrAllowedOps KeyEventStructKeyvalFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint KeyEventStructKeyvalFieldInfo = (~) Word32
        type AttrBaseTypeConstraint KeyEventStructKeyvalFieldInfo = (~) KeyEventStruct
        type AttrGetType KeyEventStructKeyvalFieldInfo = Word32
        type AttrLabel KeyEventStructKeyvalFieldInfo = "keyval"
        type AttrOrigin KeyEventStructKeyvalFieldInfo = KeyEventStruct
        attrGet _ = getKeyEventStructKeyval
        attrSet _ = setKeyEventStructKeyval
        attrConstruct = undefined
        attrClear _ = undefined

    keyEventStruct_keyval :: AttrLabelProxy "keyval"
    keyEventStruct_keyval = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@length@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' keyEventStruct #length
    @
    -}
    getKeyEventStructLength :: MonadIO m => KeyEventStruct -> m Int32
    getKeyEventStructLength s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 12) :: IO Int32
        return val

    {- |
    Set the value of the “@length@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' keyEventStruct [ #length 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setKeyEventStructLength :: MonadIO m => KeyEventStruct -> Int32 -> m ()
    setKeyEventStructLength s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 12) (val :: Int32)

    #if ENABLE_OVERLOADING
    data KeyEventStructLengthFieldInfo
    instance AttrInfo KeyEventStructLengthFieldInfo where
        type AttrAllowedOps KeyEventStructLengthFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint KeyEventStructLengthFieldInfo = (~) Int32
        type AttrBaseTypeConstraint KeyEventStructLengthFieldInfo = (~) KeyEventStruct
        type AttrGetType KeyEventStructLengthFieldInfo = Int32
        type AttrLabel KeyEventStructLengthFieldInfo = "length"
        type AttrOrigin KeyEventStructLengthFieldInfo = KeyEventStruct
        attrGet _ = getKeyEventStructLength
        attrSet _ = setKeyEventStructLength
        attrConstruct = undefined
        attrClear _ = undefined

    keyEventStruct_length :: AttrLabelProxy "length"
    keyEventStruct_length = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@string@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' keyEventStruct #string
    @
    -}
    getKeyEventStructString :: MonadIO m => KeyEventStruct -> m (Maybe T.Text)
    getKeyEventStructString s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 16) :: IO CString
        result <- SP.convertIfNonNull val $ \val' -> do
            val'' <- cstringToText val'
            return val''
        return result

    {- |
    Set the value of the “@string@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' keyEventStruct [ #string 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setKeyEventStructString :: MonadIO m => KeyEventStruct -> CString -> m ()
    setKeyEventStructString s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 16) (val :: CString)

    {- |
    Set the value of the “@string@” 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' #string
    @
    -}
    clearKeyEventStructString :: MonadIO m => KeyEventStruct -> m ()
    clearKeyEventStructString s = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 16) (FP.nullPtr :: CString)

    #if ENABLE_OVERLOADING
    data KeyEventStructStringFieldInfo
    instance AttrInfo KeyEventStructStringFieldInfo where
        type AttrAllowedOps KeyEventStructStringFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint KeyEventStructStringFieldInfo = (~) CString
        type AttrBaseTypeConstraint KeyEventStructStringFieldInfo = (~) KeyEventStruct
        type AttrGetType KeyEventStructStringFieldInfo = Maybe T.Text
        type AttrLabel KeyEventStructStringFieldInfo = "string"
        type AttrOrigin KeyEventStructStringFieldInfo = KeyEventStruct
        attrGet _ = getKeyEventStructString
        attrSet _ = setKeyEventStructString
        attrConstruct = undefined
        attrClear _ = clearKeyEventStructString

    keyEventStruct_string :: AttrLabelProxy "string"
    keyEventStruct_string = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@keycode@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' keyEventStruct #keycode
    @
    -}
    getKeyEventStructKeycode :: MonadIO m => KeyEventStruct -> m Word16
    getKeyEventStructKeycode s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 24) :: IO Word16
        return val

    {- |
    Set the value of the “@keycode@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' keyEventStruct [ #keycode 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setKeyEventStructKeycode :: MonadIO m => KeyEventStruct -> Word16 -> m ()
    setKeyEventStructKeycode s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 24) (val :: Word16)

    #if ENABLE_OVERLOADING
    data KeyEventStructKeycodeFieldInfo
    instance AttrInfo KeyEventStructKeycodeFieldInfo where
        type AttrAllowedOps KeyEventStructKeycodeFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint KeyEventStructKeycodeFieldInfo = (~) Word16
        type AttrBaseTypeConstraint KeyEventStructKeycodeFieldInfo = (~) KeyEventStruct
        type AttrGetType KeyEventStructKeycodeFieldInfo = Word16
        type AttrLabel KeyEventStructKeycodeFieldInfo = "keycode"
        type AttrOrigin KeyEventStructKeycodeFieldInfo = KeyEventStruct
        attrGet _ = getKeyEventStructKeycode
        attrSet _ = setKeyEventStructKeycode
        attrConstruct = undefined
        attrClear _ = undefined

    keyEventStruct_keycode :: AttrLabelProxy "keycode"
    keyEventStruct_keycode = AttrLabelProxy

    #endif

    {- |
    Get the value of the “@timestamp@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' keyEventStruct #timestamp
    @
    -}
    getKeyEventStructTimestamp :: MonadIO m => KeyEventStruct -> m Word32
    getKeyEventStructTimestamp s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 28) :: IO Word32
        return val

    {- |
    Set the value of the “@timestamp@” field.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' keyEventStruct [ #timestamp 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setKeyEventStructTimestamp :: MonadIO m => KeyEventStruct -> Word32 -> m ()
    setKeyEventStructTimestamp s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 28) (val :: Word32)

    #if ENABLE_OVERLOADING
    data KeyEventStructTimestampFieldInfo
    instance AttrInfo KeyEventStructTimestampFieldInfo where
        type AttrAllowedOps KeyEventStructTimestampFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint KeyEventStructTimestampFieldInfo = (~) Word32
        type AttrBaseTypeConstraint KeyEventStructTimestampFieldInfo = (~) KeyEventStruct
        type AttrGetType KeyEventStructTimestampFieldInfo = Word32
        type AttrLabel KeyEventStructTimestampFieldInfo = "timestamp"
        type AttrOrigin KeyEventStructTimestampFieldInfo = KeyEventStruct
        attrGet _ = getKeyEventStructTimestamp
        attrSet _ = setKeyEventStructTimestamp
        attrConstruct = undefined
        attrClear _ = undefined

    keyEventStruct_timestamp :: AttrLabelProxy "timestamp"
    keyEventStruct_timestamp = AttrLabelProxy

    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList KeyEventStruct
    type instance O.AttributeList KeyEventStruct = KeyEventStructAttributeList
    type KeyEventStructAttributeList = ('[ '("type", KeyEventStructTypeFieldInfo), '("state", KeyEventStructStateFieldInfo), '("keyval", KeyEventStructKeyvalFieldInfo), '("length", KeyEventStructLengthFieldInfo), '("string", KeyEventStructStringFieldInfo), '("keycode", KeyEventStructKeycodeFieldInfo), '("timestamp", KeyEventStructTimestampFieldInfo)] :: [(Symbol, *)])
    #endif

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

    instance (info ~ ResolveKeyEventStructMethod t KeyEventStruct, O.MethodInfo info KeyEventStruct p) => O.IsLabelProxy t (KeyEventStruct -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveKeyEventStructMethod t KeyEventStruct, O.MethodInfo info KeyEventStruct p) => O.IsLabel t (KeyEventStruct -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #else
        fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #endif
    #endif

    #endif