gi-atk-2.0.17: GI/Atk/Structs/KeyEventStruct.hs

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

Encapsulates information about a key event.
-}

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !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.GClosure as B.GClosure
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.GI.Base.Properties as B.Properties
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


-- | 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) => OL.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