{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.Gdk.Objects.KeyEvent
    ( 

-- * Exported types
    KeyEvent(..)                            ,
    IsKeyEvent                              ,
    toKeyEvent                              ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveKeyEventMethod                   ,
#endif


-- ** getConsumedModifiers #method:getConsumedModifiers#

#if defined(ENABLE_OVERLOADING)
    KeyEventGetConsumedModifiersMethodInfo  ,
#endif
    keyEventGetConsumedModifiers            ,


-- ** getKeycode #method:getKeycode#

#if defined(ENABLE_OVERLOADING)
    KeyEventGetKeycodeMethodInfo            ,
#endif
    keyEventGetKeycode                      ,


-- ** getKeyval #method:getKeyval#

#if defined(ENABLE_OVERLOADING)
    KeyEventGetKeyvalMethodInfo             ,
#endif
    keyEventGetKeyval                       ,


-- ** getLayout #method:getLayout#

#if defined(ENABLE_OVERLOADING)
    KeyEventGetLayoutMethodInfo             ,
#endif
    keyEventGetLayout                       ,


-- ** getLevel #method:getLevel#

#if defined(ENABLE_OVERLOADING)
    KeyEventGetLevelMethodInfo              ,
#endif
    keyEventGetLevel                        ,


-- ** getMatch #method:getMatch#

#if defined(ENABLE_OVERLOADING)
    KeyEventGetMatchMethodInfo              ,
#endif
    keyEventGetMatch                        ,


-- ** isModifier #method:isModifier#

#if defined(ENABLE_OVERLOADING)
    KeyEventIsModifierMethodInfo            ,
#endif
    keyEventIsModifier                      ,


-- ** matches #method:matches#

#if defined(ENABLE_OVERLOADING)
    KeyEventMatchesMethodInfo               ,
#endif
    keyEventMatches                         ,




    ) 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.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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
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 {-# SOURCE #-} qualified GI.Gdk.Enums as Gdk.Enums
import {-# SOURCE #-} qualified GI.Gdk.Flags as Gdk.Flags
import {-# SOURCE #-} qualified GI.Gdk.Objects.Event as Gdk.Event

-- | 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
/= :: KeyEvent -> KeyEvent -> Bool
$c/= :: KeyEvent -> KeyEvent -> Bool
== :: KeyEvent -> KeyEvent -> Bool
$c== :: KeyEvent -> KeyEvent -> Bool
Eq)

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

foreign import ccall "gdk_key_event_get_type"
    c_gdk_key_event_get_type :: IO B.Types.GType

instance B.Types.TypedObject KeyEvent where
    glibType :: IO GType
glibType = IO GType
c_gdk_key_event_get_type

-- | Type class for types which can be safely cast to `KeyEvent`, for instance with `toKeyEvent`.
class (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf KeyEvent o) => IsKeyEvent o
instance (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf KeyEvent o) => IsKeyEvent o

instance O.HasParentTypes KeyEvent
type instance O.ParentTypes KeyEvent = '[Gdk.Event.Event]

-- | Cast to `KeyEvent`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toKeyEvent :: (MonadIO m, IsKeyEvent o) => o -> m KeyEvent
toKeyEvent :: o -> m KeyEvent
toKeyEvent = IO KeyEvent -> m KeyEvent
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO KeyEvent -> m KeyEvent)
-> (o -> IO KeyEvent) -> o -> m KeyEvent
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr KeyEvent -> KeyEvent) -> o -> IO KeyEvent
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr KeyEvent -> KeyEvent
KeyEvent

#if defined(ENABLE_OVERLOADING)
type family ResolveKeyEventMethod (t :: Symbol) (o :: *) :: * where
    ResolveKeyEventMethod "isModifier" o = KeyEventIsModifierMethodInfo
    ResolveKeyEventMethod "matches" o = KeyEventMatchesMethodInfo
    ResolveKeyEventMethod "ref" o = Gdk.Event.EventRefMethodInfo
    ResolveKeyEventMethod "triggersContextMenu" o = Gdk.Event.EventTriggersContextMenuMethodInfo
    ResolveKeyEventMethod "unref" o = Gdk.Event.EventUnrefMethodInfo
    ResolveKeyEventMethod "getAxes" o = Gdk.Event.EventGetAxesMethodInfo
    ResolveKeyEventMethod "getAxis" o = Gdk.Event.EventGetAxisMethodInfo
    ResolveKeyEventMethod "getConsumedModifiers" o = KeyEventGetConsumedModifiersMethodInfo
    ResolveKeyEventMethod "getDevice" o = Gdk.Event.EventGetDeviceMethodInfo
    ResolveKeyEventMethod "getDeviceTool" o = Gdk.Event.EventGetDeviceToolMethodInfo
    ResolveKeyEventMethod "getDisplay" o = Gdk.Event.EventGetDisplayMethodInfo
    ResolveKeyEventMethod "getEventSequence" o = Gdk.Event.EventGetEventSequenceMethodInfo
    ResolveKeyEventMethod "getEventType" o = Gdk.Event.EventGetEventTypeMethodInfo
    ResolveKeyEventMethod "getKeycode" o = KeyEventGetKeycodeMethodInfo
    ResolveKeyEventMethod "getKeyval" o = KeyEventGetKeyvalMethodInfo
    ResolveKeyEventMethod "getLayout" o = KeyEventGetLayoutMethodInfo
    ResolveKeyEventMethod "getLevel" o = KeyEventGetLevelMethodInfo
    ResolveKeyEventMethod "getMatch" o = KeyEventGetMatchMethodInfo
    ResolveKeyEventMethod "getModifierState" o = Gdk.Event.EventGetModifierStateMethodInfo
    ResolveKeyEventMethod "getPointerEmulated" o = Gdk.Event.EventGetPointerEmulatedMethodInfo
    ResolveKeyEventMethod "getPosition" o = Gdk.Event.EventGetPositionMethodInfo
    ResolveKeyEventMethod "getSourceDevice" o = Gdk.Event.EventGetSourceDeviceMethodInfo
    ResolveKeyEventMethod "getSurface" o = Gdk.Event.EventGetSurfaceMethodInfo
    ResolveKeyEventMethod "getTime" o = Gdk.Event.EventGetTimeMethodInfo
    ResolveKeyEventMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveKeyEventMethod t KeyEvent, O.MethodInfo 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

#endif

-- XXX Wrapping a foreign struct/union with no known destructor or size, leak?
instance BoxedPtr KeyEvent where
    boxedPtrCopy :: KeyEvent -> IO KeyEvent
boxedPtrCopy = KeyEvent -> IO KeyEvent
forall (m :: * -> *) a. Monad m => a -> m a
return
    boxedPtrFree :: KeyEvent -> IO ()
boxedPtrFree = \KeyEvent
_x -> () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()


-- method KeyEvent::get_consumed_modifiers
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "KeyEvent" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a key event" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gdk" , name = "ModifierType" })
-- throws : False
-- Skip return : False

foreign import ccall "gdk_key_event_get_consumed_modifiers" gdk_key_event_get_consumed_modifiers :: 
    Ptr KeyEvent ->                         -- event : TInterface (Name {namespace = "Gdk", name = "KeyEvent"})
    IO CUInt

-- | Extracts the consumed modifiers from a key event.
keyEventGetConsumedModifiers ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeyEvent a) =>
    a
    -- ^ /@event@/: a key event
    -> m [Gdk.Flags.ModifierType]
    -- ^ __Returns:__ the consumed modifiers or /@event@/
keyEventGetConsumedModifiers :: a -> m [ModifierType]
keyEventGetConsumedModifiers a
event = IO [ModifierType] -> m [ModifierType]
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
$ do
    Ptr KeyEvent
event' <- a -> IO (Ptr KeyEvent)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
event
    CUInt
result <- Ptr KeyEvent -> IO CUInt
gdk_key_event_get_consumed_modifiers Ptr KeyEvent
event'
    let result' :: [ModifierType]
result' = CUInt -> [ModifierType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
event
    [ModifierType] -> IO [ModifierType]
forall (m :: * -> *) a. Monad m => a -> m a
return [ModifierType]
result'

#if defined(ENABLE_OVERLOADING)
data KeyEventGetConsumedModifiersMethodInfo
instance (signature ~ (m [Gdk.Flags.ModifierType]), MonadIO m, IsKeyEvent a) => O.MethodInfo KeyEventGetConsumedModifiersMethodInfo a signature where
    overloadedMethod = keyEventGetConsumedModifiers

#endif

-- method KeyEvent::get_keycode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "KeyEvent" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a key event" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_key_event_get_keycode" gdk_key_event_get_keycode :: 
    Ptr KeyEvent ->                         -- event : TInterface (Name {namespace = "Gdk", name = "KeyEvent"})
    IO Word32

-- | Extracts the keycode from a key event.
keyEventGetKeycode ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeyEvent a) =>
    a
    -- ^ /@event@/: a key event
    -> m Word32
    -- ^ __Returns:__ the keycode of /@event@/
keyEventGetKeycode :: a -> m Word32
keyEventGetKeycode a
event = IO Word32 -> m Word32
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
$ do
    Ptr KeyEvent
event' <- a -> IO (Ptr KeyEvent)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
event
    Word32
result <- Ptr KeyEvent -> IO Word32
gdk_key_event_get_keycode Ptr KeyEvent
event'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
event
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data KeyEventGetKeycodeMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsKeyEvent a) => O.MethodInfo KeyEventGetKeycodeMethodInfo a signature where
    overloadedMethod = keyEventGetKeycode

#endif

-- method KeyEvent::get_keyval
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "KeyEvent" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a key event" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_key_event_get_keyval" gdk_key_event_get_keyval :: 
    Ptr KeyEvent ->                         -- event : TInterface (Name {namespace = "Gdk", name = "KeyEvent"})
    IO Word32

-- | Extracts the keyval from a key event.
keyEventGetKeyval ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeyEvent a) =>
    a
    -- ^ /@event@/: a key event
    -> m Word32
    -- ^ __Returns:__ the keyval of /@event@/
keyEventGetKeyval :: a -> m Word32
keyEventGetKeyval a
event = IO Word32 -> m Word32
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
$ do
    Ptr KeyEvent
event' <- a -> IO (Ptr KeyEvent)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
event
    Word32
result <- Ptr KeyEvent -> IO Word32
gdk_key_event_get_keyval Ptr KeyEvent
event'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
event
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data KeyEventGetKeyvalMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsKeyEvent a) => O.MethodInfo KeyEventGetKeyvalMethodInfo a signature where
    overloadedMethod = keyEventGetKeyval

#endif

-- method KeyEvent::get_layout
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "KeyEvent" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a key event" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_key_event_get_layout" gdk_key_event_get_layout :: 
    Ptr KeyEvent ->                         -- event : TInterface (Name {namespace = "Gdk", name = "KeyEvent"})
    IO Word32

-- | Extracts the layout from a key event.
keyEventGetLayout ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeyEvent a) =>
    a
    -- ^ /@event@/: a key event
    -> m Word32
    -- ^ __Returns:__ the layout of /@event@/
keyEventGetLayout :: a -> m Word32
keyEventGetLayout a
event = IO Word32 -> m Word32
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
$ do
    Ptr KeyEvent
event' <- a -> IO (Ptr KeyEvent)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
event
    Word32
result <- Ptr KeyEvent -> IO Word32
gdk_key_event_get_layout Ptr KeyEvent
event'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
event
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data KeyEventGetLayoutMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsKeyEvent a) => O.MethodInfo KeyEventGetLayoutMethodInfo a signature where
    overloadedMethod = keyEventGetLayout

#endif

-- method KeyEvent::get_level
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "KeyEvent" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a key event" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_key_event_get_level" gdk_key_event_get_level :: 
    Ptr KeyEvent ->                         -- event : TInterface (Name {namespace = "Gdk", name = "KeyEvent"})
    IO Word32

-- | Extracts the shift level from a key event.
keyEventGetLevel ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeyEvent a) =>
    a
    -- ^ /@event@/: a key event
    -> m Word32
    -- ^ __Returns:__ the shift level of /@event@/
keyEventGetLevel :: a -> m Word32
keyEventGetLevel a
event = IO Word32 -> m Word32
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
$ do
    Ptr KeyEvent
event' <- a -> IO (Ptr KeyEvent)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
event
    Word32
result <- Ptr KeyEvent -> IO Word32
gdk_key_event_get_level Ptr KeyEvent
event'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
event
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data KeyEventGetLevelMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsKeyEvent a) => O.MethodInfo KeyEventGetLevelMethodInfo a signature where
    overloadedMethod = keyEventGetLevel

#endif

-- method KeyEvent::get_match
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "KeyEvent" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a key #GdkEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "keyval"
--           , argType = TBasicType TUInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for a keyval"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "modifiers"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "ModifierType" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for modifiers"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_key_event_get_match" gdk_key_event_get_match :: 
    Ptr KeyEvent ->                         -- event : TInterface (Name {namespace = "Gdk", name = "KeyEvent"})
    Ptr Word32 ->                           -- keyval : TBasicType TUInt
    Ptr CUInt ->                            -- modifiers : TInterface (Name {namespace = "Gdk", name = "ModifierType"})
    IO CInt

-- | Gets a keyval and modifier combination that will cause
-- 'GI.Gdk.Objects.KeyEvent.keyEventMatches' to successfully match the given event.
keyEventGetMatch ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeyEvent a) =>
    a
    -- ^ /@event@/: a key t'GI.Gdk.Objects.Event.Event'
    -> m ((Bool, Word32, [Gdk.Flags.ModifierType]))
    -- ^ __Returns:__ 'P.True' on success
keyEventGetMatch :: a -> m (Bool, Word32, [ModifierType])
keyEventGetMatch a
event = IO (Bool, Word32, [ModifierType])
-> m (Bool, Word32, [ModifierType])
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Word32, [ModifierType])
 -> m (Bool, Word32, [ModifierType]))
-> IO (Bool, Word32, [ModifierType])
-> m (Bool, Word32, [ModifierType])
forall a b. (a -> b) -> a -> b
$ do
    Ptr KeyEvent
event' <- a -> IO (Ptr KeyEvent)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
event
    Ptr Word32
keyval <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
    Ptr CUInt
modifiers <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
    CInt
result <- Ptr KeyEvent -> Ptr Word32 -> Ptr CUInt -> IO CInt
gdk_key_event_get_match Ptr KeyEvent
event' Ptr Word32
keyval Ptr CUInt
modifiers
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Word32
keyval' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
keyval
    CUInt
modifiers' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
modifiers
    let modifiers'' :: [ModifierType]
modifiers'' = CUInt -> [ModifierType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
modifiers'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
event
    Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
keyval
    Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
modifiers
    (Bool, Word32, [ModifierType]) -> IO (Bool, Word32, [ModifierType])
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Word32
keyval', [ModifierType]
modifiers'')

#if defined(ENABLE_OVERLOADING)
data KeyEventGetMatchMethodInfo
instance (signature ~ (m ((Bool, Word32, [Gdk.Flags.ModifierType]))), MonadIO m, IsKeyEvent a) => O.MethodInfo KeyEventGetMatchMethodInfo a signature where
    overloadedMethod = keyEventGetMatch

#endif

-- method KeyEvent::is_modifier
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "KeyEvent" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a key event" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gdk_key_event_is_modifier" gdk_key_event_is_modifier :: 
    Ptr KeyEvent ->                         -- event : TInterface (Name {namespace = "Gdk", name = "KeyEvent"})
    IO CInt

-- | Extracts whether the key event is for a modifier key.
keyEventIsModifier ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeyEvent a) =>
    a
    -- ^ /@event@/: a key event
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the /@event@/ is for a modifier key
keyEventIsModifier :: a -> m Bool
keyEventIsModifier a
event = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr KeyEvent
event' <- a -> IO (Ptr KeyEvent)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
event
    CInt
result <- Ptr KeyEvent -> IO CInt
gdk_key_event_is_modifier Ptr KeyEvent
event'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
event
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data KeyEventIsModifierMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsKeyEvent a) => O.MethodInfo KeyEventIsModifierMethodInfo a signature where
    overloadedMethod = keyEventIsModifier

#endif

-- method KeyEvent::matches
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "KeyEvent" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a key #GdkEvent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "keyval"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the keyval to match"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "modifiers"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "ModifierType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the modifiers to match"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gdk" , name = "KeyMatch" })
-- throws : False
-- Skip return : False

foreign import ccall "gdk_key_event_matches" gdk_key_event_matches :: 
    Ptr KeyEvent ->                         -- event : TInterface (Name {namespace = "Gdk", name = "KeyEvent"})
    Word32 ->                               -- keyval : TBasicType TUInt
    CUInt ->                                -- modifiers : TInterface (Name {namespace = "Gdk", name = "ModifierType"})
    IO CUInt

-- | Matches a key event against a keyboard shortcut that is specified
-- as a keyval and modifiers. Partial matches are possible where the
-- combination matches if the currently active group is ignored.
-- 
-- Note that we ignore Caps Lock for matching.
keyEventMatches ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeyEvent a) =>
    a
    -- ^ /@event@/: a key t'GI.Gdk.Objects.Event.Event'
    -> Word32
    -- ^ /@keyval@/: the keyval to match
    -> [Gdk.Flags.ModifierType]
    -- ^ /@modifiers@/: the modifiers to match
    -> m Gdk.Enums.KeyMatch
    -- ^ __Returns:__ a GdkKeyMatch value describing whether /@event@/ matches
keyEventMatches :: a -> Word32 -> [ModifierType] -> m KeyMatch
keyEventMatches a
event Word32
keyval [ModifierType]
modifiers = IO KeyMatch -> m KeyMatch
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO KeyMatch -> m KeyMatch) -> IO KeyMatch -> m KeyMatch
forall a b. (a -> b) -> a -> b
$ do
    Ptr KeyEvent
event' <- a -> IO (Ptr KeyEvent)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
event
    let modifiers' :: CUInt
modifiers' = [ModifierType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ModifierType]
modifiers
    CUInt
result <- Ptr KeyEvent -> Word32 -> CUInt -> IO CUInt
gdk_key_event_matches Ptr KeyEvent
event' Word32
keyval CUInt
modifiers'
    let result' :: KeyMatch
result' = (Int -> KeyMatch
forall a. Enum a => Int -> a
toEnum (Int -> KeyMatch) -> (CUInt -> Int) -> CUInt -> KeyMatch
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
event
    KeyMatch -> IO KeyMatch
forall (m :: * -> *) a. Monad m => a -> m a
return KeyMatch
result'

#if defined(ENABLE_OVERLOADING)
data KeyEventMatchesMethodInfo
instance (signature ~ (Word32 -> [Gdk.Flags.ModifierType] -> m Gdk.Enums.KeyMatch), MonadIO m, IsKeyEvent a) => O.MethodInfo KeyEventMatchesMethodInfo a signature where
    overloadedMethod = keyEventMatches

#endif