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

Each key binding element of a binding sets binding list is
represented by a GtkBindingEntry.
-}

module GI.Gtk.Structs.BindingEntry
    ( 

-- * Exported types
    BindingEntry(..)                        ,
    newZeroBindingEntry                     ,
    noBindingEntry                          ,


 -- * Methods
-- ** addSignalFromString #method:addSignalFromString#
    bindingEntryAddSignalFromString         ,


-- ** addSignall #method:addSignall#
    bindingEntryAddSignall                  ,


-- ** remove #method:remove#
    bindingEntryRemove                      ,


-- ** skip #method:skip#
    bindingEntrySkip                        ,




 -- * Properties
-- ** bindingSet #attr:bindingSet#
    bindingEntry_bindingSet                 ,
    clearBindingEntryBindingSet             ,
    getBindingEntryBindingSet               ,
    setBindingEntryBindingSet               ,


-- ** destroyed #attr:destroyed#
    bindingEntry_destroyed                  ,
    getBindingEntryDestroyed                ,
    setBindingEntryDestroyed                ,


-- ** hashNext #attr:hashNext#
    bindingEntry_hashNext                   ,
    clearBindingEntryHashNext               ,
    getBindingEntryHashNext                 ,
    setBindingEntryHashNext                 ,


-- ** inEmission #attr:inEmission#
    bindingEntry_inEmission                 ,
    getBindingEntryInEmission               ,
    setBindingEntryInEmission               ,


-- ** keyval #attr:keyval#
    bindingEntry_keyval                     ,
    getBindingEntryKeyval                   ,
    setBindingEntryKeyval                   ,


-- ** marksUnbound #attr:marksUnbound#
    bindingEntry_marksUnbound               ,
    getBindingEntryMarksUnbound             ,
    setBindingEntryMarksUnbound             ,


-- ** modifiers #attr:modifiers#
    bindingEntry_modifiers                  ,
    getBindingEntryModifiers                ,
    setBindingEntryModifiers                ,


-- ** setNext #attr:setNext#
    bindingEntry_setNext                    ,
    clearBindingEntrySetNext                ,
    getBindingEntrySetNext                  ,
    setBindingEntrySetNext                  ,


-- ** signals #attr:signals#
    bindingEntry_signals                    ,
    clearBindingEntrySignals                ,
    getBindingEntrySignals                  ,
    setBindingEntrySignals                  ,




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

import qualified GI.GLib.Enums as GLib.Enums
import qualified GI.Gdk.Flags as Gdk.Flags
import {-# SOURCE #-} qualified GI.Gtk.Structs.BindingArg as Gtk.BindingArg
import {-# SOURCE #-} qualified GI.Gtk.Structs.BindingSet as Gtk.BindingSet
import {-# SOURCE #-} qualified GI.Gtk.Structs.BindingSignal as Gtk.BindingSignal

newtype BindingEntry = BindingEntry (ManagedPtr BindingEntry)
instance WrappedPtr BindingEntry where
    wrappedPtrCalloc = callocBytes 56
    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 56 >=> wrapPtr BindingEntry)
    wrappedPtrFree = Just ptr_to_g_free

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

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


noBindingEntry :: Maybe BindingEntry
noBindingEntry = Nothing

getBindingEntryKeyval :: MonadIO m => BindingEntry -> m Word32
getBindingEntryKeyval s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word32
    return val

setBindingEntryKeyval :: MonadIO m => BindingEntry -> Word32 -> m ()
setBindingEntryKeyval s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Word32)

data BindingEntryKeyvalFieldInfo
instance AttrInfo BindingEntryKeyvalFieldInfo where
    type AttrAllowedOps BindingEntryKeyvalFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint BindingEntryKeyvalFieldInfo = (~) Word32
    type AttrBaseTypeConstraint BindingEntryKeyvalFieldInfo = (~) BindingEntry
    type AttrGetType BindingEntryKeyvalFieldInfo = Word32
    type AttrLabel BindingEntryKeyvalFieldInfo = "keyval"
    type AttrOrigin BindingEntryKeyvalFieldInfo = BindingEntry
    attrGet _ = getBindingEntryKeyval
    attrSet _ = setBindingEntryKeyval
    attrConstruct = undefined
    attrClear _ = undefined

bindingEntry_keyval :: AttrLabelProxy "keyval"
bindingEntry_keyval = AttrLabelProxy


getBindingEntryModifiers :: MonadIO m => BindingEntry -> m [Gdk.Flags.ModifierType]
getBindingEntryModifiers s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 4) :: IO CUInt
    let val' = wordToGFlags val
    return val'

setBindingEntryModifiers :: MonadIO m => BindingEntry -> [Gdk.Flags.ModifierType] -> m ()
setBindingEntryModifiers s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = gflagsToWord val
    poke (ptr `plusPtr` 4) (val' :: CUInt)

data BindingEntryModifiersFieldInfo
instance AttrInfo BindingEntryModifiersFieldInfo where
    type AttrAllowedOps BindingEntryModifiersFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint BindingEntryModifiersFieldInfo = (~) [Gdk.Flags.ModifierType]
    type AttrBaseTypeConstraint BindingEntryModifiersFieldInfo = (~) BindingEntry
    type AttrGetType BindingEntryModifiersFieldInfo = [Gdk.Flags.ModifierType]
    type AttrLabel BindingEntryModifiersFieldInfo = "modifiers"
    type AttrOrigin BindingEntryModifiersFieldInfo = BindingEntry
    attrGet _ = getBindingEntryModifiers
    attrSet _ = setBindingEntryModifiers
    attrConstruct = undefined
    attrClear _ = undefined

bindingEntry_modifiers :: AttrLabelProxy "modifiers"
bindingEntry_modifiers = AttrLabelProxy


getBindingEntryBindingSet :: MonadIO m => BindingEntry -> m (Maybe Gtk.BindingSet.BindingSet)
getBindingEntryBindingSet s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO (Ptr Gtk.BindingSet.BindingSet)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newPtr Gtk.BindingSet.BindingSet) val'
        return val''
    return result

setBindingEntryBindingSet :: MonadIO m => BindingEntry -> Ptr Gtk.BindingSet.BindingSet -> m ()
setBindingEntryBindingSet s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: Ptr Gtk.BindingSet.BindingSet)

clearBindingEntryBindingSet :: MonadIO m => BindingEntry -> m ()
clearBindingEntryBindingSet s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr Gtk.BindingSet.BindingSet)

data BindingEntryBindingSetFieldInfo
instance AttrInfo BindingEntryBindingSetFieldInfo where
    type AttrAllowedOps BindingEntryBindingSetFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint BindingEntryBindingSetFieldInfo = (~) (Ptr Gtk.BindingSet.BindingSet)
    type AttrBaseTypeConstraint BindingEntryBindingSetFieldInfo = (~) BindingEntry
    type AttrGetType BindingEntryBindingSetFieldInfo = Maybe Gtk.BindingSet.BindingSet
    type AttrLabel BindingEntryBindingSetFieldInfo = "binding_set"
    type AttrOrigin BindingEntryBindingSetFieldInfo = BindingEntry
    attrGet _ = getBindingEntryBindingSet
    attrSet _ = setBindingEntryBindingSet
    attrConstruct = undefined
    attrClear _ = clearBindingEntryBindingSet

bindingEntry_bindingSet :: AttrLabelProxy "bindingSet"
bindingEntry_bindingSet = AttrLabelProxy


getBindingEntryDestroyed :: MonadIO m => BindingEntry -> m Word32
getBindingEntryDestroyed s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO Word32
    return val

setBindingEntryDestroyed :: MonadIO m => BindingEntry -> Word32 -> m ()
setBindingEntryDestroyed s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (val :: Word32)

data BindingEntryDestroyedFieldInfo
instance AttrInfo BindingEntryDestroyedFieldInfo where
    type AttrAllowedOps BindingEntryDestroyedFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint BindingEntryDestroyedFieldInfo = (~) Word32
    type AttrBaseTypeConstraint BindingEntryDestroyedFieldInfo = (~) BindingEntry
    type AttrGetType BindingEntryDestroyedFieldInfo = Word32
    type AttrLabel BindingEntryDestroyedFieldInfo = "destroyed"
    type AttrOrigin BindingEntryDestroyedFieldInfo = BindingEntry
    attrGet _ = getBindingEntryDestroyed
    attrSet _ = setBindingEntryDestroyed
    attrConstruct = undefined
    attrClear _ = undefined

bindingEntry_destroyed :: AttrLabelProxy "destroyed"
bindingEntry_destroyed = AttrLabelProxy


getBindingEntryInEmission :: MonadIO m => BindingEntry -> m Word32
getBindingEntryInEmission s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 20) :: IO Word32
    return val

setBindingEntryInEmission :: MonadIO m => BindingEntry -> Word32 -> m ()
setBindingEntryInEmission s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 20) (val :: Word32)

data BindingEntryInEmissionFieldInfo
instance AttrInfo BindingEntryInEmissionFieldInfo where
    type AttrAllowedOps BindingEntryInEmissionFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint BindingEntryInEmissionFieldInfo = (~) Word32
    type AttrBaseTypeConstraint BindingEntryInEmissionFieldInfo = (~) BindingEntry
    type AttrGetType BindingEntryInEmissionFieldInfo = Word32
    type AttrLabel BindingEntryInEmissionFieldInfo = "in_emission"
    type AttrOrigin BindingEntryInEmissionFieldInfo = BindingEntry
    attrGet _ = getBindingEntryInEmission
    attrSet _ = setBindingEntryInEmission
    attrConstruct = undefined
    attrClear _ = undefined

bindingEntry_inEmission :: AttrLabelProxy "inEmission"
bindingEntry_inEmission = AttrLabelProxy


getBindingEntryMarksUnbound :: MonadIO m => BindingEntry -> m Word32
getBindingEntryMarksUnbound s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO Word32
    return val

setBindingEntryMarksUnbound :: MonadIO m => BindingEntry -> Word32 -> m ()
setBindingEntryMarksUnbound s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (val :: Word32)

data BindingEntryMarksUnboundFieldInfo
instance AttrInfo BindingEntryMarksUnboundFieldInfo where
    type AttrAllowedOps BindingEntryMarksUnboundFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint BindingEntryMarksUnboundFieldInfo = (~) Word32
    type AttrBaseTypeConstraint BindingEntryMarksUnboundFieldInfo = (~) BindingEntry
    type AttrGetType BindingEntryMarksUnboundFieldInfo = Word32
    type AttrLabel BindingEntryMarksUnboundFieldInfo = "marks_unbound"
    type AttrOrigin BindingEntryMarksUnboundFieldInfo = BindingEntry
    attrGet _ = getBindingEntryMarksUnbound
    attrSet _ = setBindingEntryMarksUnbound
    attrConstruct = undefined
    attrClear _ = undefined

bindingEntry_marksUnbound :: AttrLabelProxy "marksUnbound"
bindingEntry_marksUnbound = AttrLabelProxy


getBindingEntrySetNext :: MonadIO m => BindingEntry -> m (Maybe BindingEntry)
getBindingEntrySetNext s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO (Ptr BindingEntry)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newPtr BindingEntry) val'
        return val''
    return result

setBindingEntrySetNext :: MonadIO m => BindingEntry -> Ptr BindingEntry -> m ()
setBindingEntrySetNext s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (val :: Ptr BindingEntry)

clearBindingEntrySetNext :: MonadIO m => BindingEntry -> m ()
clearBindingEntrySetNext s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (FP.nullPtr :: Ptr BindingEntry)

data BindingEntrySetNextFieldInfo
instance AttrInfo BindingEntrySetNextFieldInfo where
    type AttrAllowedOps BindingEntrySetNextFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint BindingEntrySetNextFieldInfo = (~) (Ptr BindingEntry)
    type AttrBaseTypeConstraint BindingEntrySetNextFieldInfo = (~) BindingEntry
    type AttrGetType BindingEntrySetNextFieldInfo = Maybe BindingEntry
    type AttrLabel BindingEntrySetNextFieldInfo = "set_next"
    type AttrOrigin BindingEntrySetNextFieldInfo = BindingEntry
    attrGet _ = getBindingEntrySetNext
    attrSet _ = setBindingEntrySetNext
    attrConstruct = undefined
    attrClear _ = clearBindingEntrySetNext

bindingEntry_setNext :: AttrLabelProxy "setNext"
bindingEntry_setNext = AttrLabelProxy


getBindingEntryHashNext :: MonadIO m => BindingEntry -> m (Maybe BindingEntry)
getBindingEntryHashNext s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 40) :: IO (Ptr BindingEntry)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newPtr BindingEntry) val'
        return val''
    return result

setBindingEntryHashNext :: MonadIO m => BindingEntry -> Ptr BindingEntry -> m ()
setBindingEntryHashNext s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 40) (val :: Ptr BindingEntry)

clearBindingEntryHashNext :: MonadIO m => BindingEntry -> m ()
clearBindingEntryHashNext s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 40) (FP.nullPtr :: Ptr BindingEntry)

data BindingEntryHashNextFieldInfo
instance AttrInfo BindingEntryHashNextFieldInfo where
    type AttrAllowedOps BindingEntryHashNextFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint BindingEntryHashNextFieldInfo = (~) (Ptr BindingEntry)
    type AttrBaseTypeConstraint BindingEntryHashNextFieldInfo = (~) BindingEntry
    type AttrGetType BindingEntryHashNextFieldInfo = Maybe BindingEntry
    type AttrLabel BindingEntryHashNextFieldInfo = "hash_next"
    type AttrOrigin BindingEntryHashNextFieldInfo = BindingEntry
    attrGet _ = getBindingEntryHashNext
    attrSet _ = setBindingEntryHashNext
    attrConstruct = undefined
    attrClear _ = clearBindingEntryHashNext

bindingEntry_hashNext :: AttrLabelProxy "hashNext"
bindingEntry_hashNext = AttrLabelProxy


getBindingEntrySignals :: MonadIO m => BindingEntry -> m (Maybe Gtk.BindingSignal.BindingSignal)
getBindingEntrySignals s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 48) :: IO (Ptr Gtk.BindingSignal.BindingSignal)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newPtr Gtk.BindingSignal.BindingSignal) val'
        return val''
    return result

setBindingEntrySignals :: MonadIO m => BindingEntry -> Ptr Gtk.BindingSignal.BindingSignal -> m ()
setBindingEntrySignals s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 48) (val :: Ptr Gtk.BindingSignal.BindingSignal)

clearBindingEntrySignals :: MonadIO m => BindingEntry -> m ()
clearBindingEntrySignals s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 48) (FP.nullPtr :: Ptr Gtk.BindingSignal.BindingSignal)

data BindingEntrySignalsFieldInfo
instance AttrInfo BindingEntrySignalsFieldInfo where
    type AttrAllowedOps BindingEntrySignalsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint BindingEntrySignalsFieldInfo = (~) (Ptr Gtk.BindingSignal.BindingSignal)
    type AttrBaseTypeConstraint BindingEntrySignalsFieldInfo = (~) BindingEntry
    type AttrGetType BindingEntrySignalsFieldInfo = Maybe Gtk.BindingSignal.BindingSignal
    type AttrLabel BindingEntrySignalsFieldInfo = "signals"
    type AttrOrigin BindingEntrySignalsFieldInfo = BindingEntry
    attrGet _ = getBindingEntrySignals
    attrSet _ = setBindingEntrySignals
    attrConstruct = undefined
    attrClear _ = clearBindingEntrySignals

bindingEntry_signals :: AttrLabelProxy "signals"
bindingEntry_signals = AttrLabelProxy



instance O.HasAttributeList BindingEntry
type instance O.AttributeList BindingEntry = BindingEntryAttributeList
type BindingEntryAttributeList = ('[ '("keyval", BindingEntryKeyvalFieldInfo), '("modifiers", BindingEntryModifiersFieldInfo), '("bindingSet", BindingEntryBindingSetFieldInfo), '("destroyed", BindingEntryDestroyedFieldInfo), '("inEmission", BindingEntryInEmissionFieldInfo), '("marksUnbound", BindingEntryMarksUnboundFieldInfo), '("setNext", BindingEntrySetNextFieldInfo), '("hashNext", BindingEntryHashNextFieldInfo), '("signals", BindingEntrySignalsFieldInfo)] :: [(Symbol, *)])

-- method BindingEntry::add_signal_from_string
-- method type : MemberFunction
-- Args : [Arg {argCName = "binding_set", argType = TInterface (Name {namespace = "Gtk", name = "BindingSet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkBindingSet", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "signal_desc", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a signal description", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GLib", name = "TokenType"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_binding_entry_add_signal_from_string" gtk_binding_entry_add_signal_from_string :: 
    Ptr Gtk.BindingSet.BindingSet ->        -- binding_set : TInterface (Name {namespace = "Gtk", name = "BindingSet"})
    CString ->                              -- signal_desc : TBasicType TUTF8
    IO CUInt

{- |
Parses a signal description from /@signalDesc@/ and incorporates
it into /@bindingSet@/.

Signal descriptions may either bind a key combination to
one or more signals:
>
>  bind "key" {
>    "signalname" (param, ...)
>    ...
>  }


Or they may also unbind a key combination:
>
>  unbind "key"


Key combinations must be in a format that can be parsed by
'GI.Gtk.Functions.acceleratorParse'.

@since 3.0
-}
bindingEntryAddSignalFromString ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gtk.BindingSet.BindingSet
    {- ^ /@bindingSet@/: a 'GI.Gtk.Structs.BindingSet.BindingSet' -}
    -> T.Text
    {- ^ /@signalDesc@/: a signal description -}
    -> m GLib.Enums.TokenType
    {- ^ __Returns:__ 'GI.GLib.Enums.TokenTypeNone' if the signal was successfully parsed and added,
    the expected token otherwise -}
bindingEntryAddSignalFromString bindingSet signalDesc = liftIO $ do
    bindingSet' <- unsafeManagedPtrGetPtr bindingSet
    signalDesc' <- textToCString signalDesc
    result <- gtk_binding_entry_add_signal_from_string bindingSet' signalDesc'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr bindingSet
    freeMem signalDesc'
    return result'

-- method BindingEntry::add_signall
-- method type : MemberFunction
-- Args : [Arg {argCName = "binding_set", argType = TInterface (Name {namespace = "Gtk", name = "BindingSet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkBindingSet to add a signal to", 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 "key value", 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 "key modifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "signal_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "signal name to be bound", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "binding_args", argType = TGSList (TInterface (Name {namespace = "Gtk", name = "BindingArg"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "\n    list of #GtkBindingArg signal arguments", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_binding_entry_add_signall" gtk_binding_entry_add_signall :: 
    Ptr Gtk.BindingSet.BindingSet ->        -- binding_set : TInterface (Name {namespace = "Gtk", name = "BindingSet"})
    Word32 ->                               -- keyval : TBasicType TUInt
    CUInt ->                                -- modifiers : TInterface (Name {namespace = "Gdk", name = "ModifierType"})
    CString ->                              -- signal_name : TBasicType TUTF8
    Ptr (GSList (Ptr Gtk.BindingArg.BindingArg)) -> -- binding_args : TGSList (TInterface (Name {namespace = "Gtk", name = "BindingArg"}))
    IO ()

{- |
Override or install a new key binding for /@keyval@/ with /@modifiers@/ on
/@bindingSet@/.
-}
bindingEntryAddSignall ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gtk.BindingSet.BindingSet
    {- ^ /@bindingSet@/: a 'GI.Gtk.Structs.BindingSet.BindingSet' to add a signal to -}
    -> Word32
    {- ^ /@keyval@/: key value -}
    -> [Gdk.Flags.ModifierType]
    {- ^ /@modifiers@/: key modifier -}
    -> T.Text
    {- ^ /@signalName@/: signal name to be bound -}
    -> [Gtk.BindingArg.BindingArg]
    {- ^ /@bindingArgs@/: 
    list of 'GI.Gtk.Structs.BindingArg.BindingArg' signal arguments -}
    -> m ()
bindingEntryAddSignall bindingSet keyval modifiers signalName bindingArgs = liftIO $ do
    bindingSet' <- unsafeManagedPtrGetPtr bindingSet
    let modifiers' = gflagsToWord modifiers
    signalName' <- textToCString signalName
    bindingArgs' <- mapM unsafeManagedPtrGetPtr bindingArgs
    bindingArgs'' <- packGSList bindingArgs'
    gtk_binding_entry_add_signall bindingSet' keyval modifiers' signalName' bindingArgs''
    touchManagedPtr bindingSet
    mapM_ touchManagedPtr bindingArgs
    freeMem signalName'
    g_slist_free bindingArgs''
    return ()

-- method BindingEntry::remove
-- method type : MemberFunction
-- Args : [Arg {argCName = "binding_set", argType = TInterface (Name {namespace = "Gtk", name = "BindingSet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkBindingSet to remove an entry of", 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 "key value of binding to remove", 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 "key modifier of binding to remove", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_binding_entry_remove" gtk_binding_entry_remove :: 
    Ptr Gtk.BindingSet.BindingSet ->        -- binding_set : TInterface (Name {namespace = "Gtk", name = "BindingSet"})
    Word32 ->                               -- keyval : TBasicType TUInt
    CUInt ->                                -- modifiers : TInterface (Name {namespace = "Gdk", name = "ModifierType"})
    IO ()

{- |
Remove a binding previously installed via
@/gtk_binding_entry_add_signal()/@ on /@bindingSet@/.
-}
bindingEntryRemove ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gtk.BindingSet.BindingSet
    {- ^ /@bindingSet@/: a 'GI.Gtk.Structs.BindingSet.BindingSet' to remove an entry of -}
    -> Word32
    {- ^ /@keyval@/: key value of binding to remove -}
    -> [Gdk.Flags.ModifierType]
    {- ^ /@modifiers@/: key modifier of binding to remove -}
    -> m ()
bindingEntryRemove bindingSet keyval modifiers = liftIO $ do
    bindingSet' <- unsafeManagedPtrGetPtr bindingSet
    let modifiers' = gflagsToWord modifiers
    gtk_binding_entry_remove bindingSet' keyval modifiers'
    touchManagedPtr bindingSet
    return ()

-- method BindingEntry::skip
-- method type : MemberFunction
-- Args : [Arg {argCName = "binding_set", argType = TInterface (Name {namespace = "Gtk", name = "BindingSet"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkBindingSet to skip an entry of", 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 "key value of binding to skip", 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 "key modifier of binding to skip", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_binding_entry_skip" gtk_binding_entry_skip :: 
    Ptr Gtk.BindingSet.BindingSet ->        -- binding_set : TInterface (Name {namespace = "Gtk", name = "BindingSet"})
    Word32 ->                               -- keyval : TBasicType TUInt
    CUInt ->                                -- modifiers : TInterface (Name {namespace = "Gdk", name = "ModifierType"})
    IO ()

{- |
Install a binding on /@bindingSet@/ which causes key lookups
to be aborted, to prevent bindings from lower priority sets
to be activated.

@since 2.12
-}
bindingEntrySkip ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gtk.BindingSet.BindingSet
    {- ^ /@bindingSet@/: a 'GI.Gtk.Structs.BindingSet.BindingSet' to skip an entry of -}
    -> Word32
    {- ^ /@keyval@/: key value of binding to skip -}
    -> [Gdk.Flags.ModifierType]
    {- ^ /@modifiers@/: key modifier of binding to skip -}
    -> m ()
bindingEntrySkip bindingSet keyval modifiers = liftIO $ do
    bindingSet' <- unsafeManagedPtrGetPtr bindingSet
    let modifiers' = gflagsToWord modifiers
    gtk_binding_entry_skip bindingSet' keyval modifiers'
    touchManagedPtr bindingSet
    return ()

type family ResolveBindingEntryMethod (t :: Symbol) (o :: *) :: * where
    ResolveBindingEntryMethod l o = O.MethodResolutionFailed l o

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

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