{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Clutter.Structs.KeyEvent
(
KeyEvent(..) ,
newZeroKeyEvent ,
#if defined(ENABLE_OVERLOADING)
ResolveKeyEventMethod ,
#endif
clearKeyEventDevice ,
getKeyEventDevice ,
#if defined(ENABLE_OVERLOADING)
keyEvent_device ,
#endif
setKeyEventDevice ,
getKeyEventFlags ,
#if defined(ENABLE_OVERLOADING)
keyEvent_flags ,
#endif
setKeyEventFlags ,
getKeyEventHardwareKeycode ,
#if defined(ENABLE_OVERLOADING)
keyEvent_hardwareKeycode ,
#endif
setKeyEventHardwareKeycode ,
getKeyEventKeyval ,
#if defined(ENABLE_OVERLOADING)
keyEvent_keyval ,
#endif
setKeyEventKeyval ,
getKeyEventModifierState ,
#if defined(ENABLE_OVERLOADING)
keyEvent_modifierState ,
#endif
setKeyEventModifierState ,
clearKeyEventSource ,
getKeyEventSource ,
#if defined(ENABLE_OVERLOADING)
keyEvent_source ,
#endif
setKeyEventSource ,
clearKeyEventStage ,
getKeyEventStage ,
#if defined(ENABLE_OVERLOADING)
keyEvent_stage ,
#endif
setKeyEventStage ,
getKeyEventTime ,
#if defined(ENABLE_OVERLOADING)
keyEvent_time ,
#endif
setKeyEventTime ,
getKeyEventType ,
#if defined(ENABLE_OVERLOADING)
keyEvent_type ,
#endif
setKeyEventType ,
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
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
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
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'
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
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
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
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'
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
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
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)
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
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
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)
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
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'
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
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
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
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
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
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'
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
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
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)
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