{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Each key binding element of a binding sets binding list is
-- represented by a GtkBindingEntry.

#if !defined(__HADDOCK_VERSION__)
#define ENABLE_OVERLOADING
#endif

module GI.Gtk.Structs.BindingEntry
    ( 

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


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveBindingEntryMethod               ,
#endif

-- ** addSignalFromString #method:addSignalFromString#

    bindingEntryAddSignalFromString         ,


-- ** addSignall #method:addSignall#

    bindingEntryAddSignall                  ,


-- ** remove #method:remove#

    bindingEntryRemove                      ,


-- ** skip #method:skip#

    bindingEntrySkip                        ,




 -- * Properties


-- ** bindingSet #attr:bindingSet#
-- | binding set this entry belongs to

#if defined(ENABLE_OVERLOADING)
    bindingEntry_bindingSet                 ,
#endif
    clearBindingEntryBindingSet             ,
    getBindingEntryBindingSet               ,
    setBindingEntryBindingSet               ,


-- ** destroyed #attr:destroyed#
-- | implementation detail

#if defined(ENABLE_OVERLOADING)
    bindingEntry_destroyed                  ,
#endif
    getBindingEntryDestroyed                ,
    setBindingEntryDestroyed                ,


-- ** hashNext #attr:hashNext#
-- | implementation detail

#if defined(ENABLE_OVERLOADING)
    bindingEntry_hashNext                   ,
#endif
    clearBindingEntryHashNext               ,
    getBindingEntryHashNext                 ,
    setBindingEntryHashNext                 ,


-- ** inEmission #attr:inEmission#
-- | implementation detail

#if defined(ENABLE_OVERLOADING)
    bindingEntry_inEmission                 ,
#endif
    getBindingEntryInEmission               ,
    setBindingEntryInEmission               ,


-- ** keyval #attr:keyval#
-- | key value to match

#if defined(ENABLE_OVERLOADING)
    bindingEntry_keyval                     ,
#endif
    getBindingEntryKeyval                   ,
    setBindingEntryKeyval                   ,


-- ** marksUnbound #attr:marksUnbound#
-- | implementation detail

#if defined(ENABLE_OVERLOADING)
    bindingEntry_marksUnbound               ,
#endif
    getBindingEntryMarksUnbound             ,
    setBindingEntryMarksUnbound             ,


-- ** modifiers #attr:modifiers#
-- | key modifiers to match

#if defined(ENABLE_OVERLOADING)
    bindingEntry_modifiers                  ,
#endif
    getBindingEntryModifiers                ,
    setBindingEntryModifiers                ,


-- ** setNext #attr:setNext#
-- | linked list of entries maintained by binding set

#if defined(ENABLE_OVERLOADING)
    bindingEntry_setNext                    ,
#endif
    clearBindingEntrySetNext                ,
    getBindingEntrySetNext                  ,
    setBindingEntrySetNext                  ,


-- ** signals #attr:signals#
-- | action signals of this entry

#if defined(ENABLE_OVERLOADING)
    bindingEntry_signals                    ,
#endif
    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.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.Kind as DK
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 qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Enums as GLib.Enums
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Flags as Gdk.Flags
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
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

#else
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

#endif

-- | Memory-managed wrapper type.
newtype BindingEntry = BindingEntry (SP.ManagedPtr BindingEntry)
    deriving (BindingEntry -> BindingEntry -> Bool
(BindingEntry -> BindingEntry -> Bool)
-> (BindingEntry -> BindingEntry -> Bool) -> Eq BindingEntry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BindingEntry -> BindingEntry -> Bool
== :: BindingEntry -> BindingEntry -> Bool
$c/= :: BindingEntry -> BindingEntry -> Bool
/= :: BindingEntry -> BindingEntry -> Bool
Eq)

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

instance BoxedPtr BindingEntry where
    boxedPtrCopy :: BindingEntry -> IO BindingEntry
boxedPtrCopy = \BindingEntry
p -> BindingEntry
-> (Ptr BindingEntry -> IO BindingEntry) -> IO BindingEntry
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr BindingEntry
p (Int -> Ptr BindingEntry -> IO (Ptr BindingEntry)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
56 (Ptr BindingEntry -> IO (Ptr BindingEntry))
-> (Ptr BindingEntry -> IO BindingEntry)
-> Ptr BindingEntry
-> IO BindingEntry
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr BindingEntry -> BindingEntry)
-> Ptr BindingEntry -> IO BindingEntry
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr BindingEntry -> BindingEntry
BindingEntry)
    boxedPtrFree :: BindingEntry -> IO ()
boxedPtrFree = \BindingEntry
x -> BindingEntry -> (Ptr BindingEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr BindingEntry
x Ptr BindingEntry -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr BindingEntry where
    boxedPtrCalloc :: IO (Ptr BindingEntry)
boxedPtrCalloc = Int -> IO (Ptr BindingEntry)
forall a. Int -> IO (Ptr a)
callocBytes Int
56


-- | Construct a t'BindingEntry' struct initialized to zero.
newZeroBindingEntry :: MonadIO m => m BindingEntry
newZeroBindingEntry :: forall (m :: * -> *). MonadIO m => m BindingEntry
newZeroBindingEntry = IO BindingEntry -> m BindingEntry
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BindingEntry -> m BindingEntry)
-> IO BindingEntry -> m BindingEntry
forall a b. (a -> b) -> a -> b
$ IO (Ptr BindingEntry)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr BindingEntry)
-> (Ptr BindingEntry -> IO BindingEntry) -> IO BindingEntry
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr BindingEntry -> BindingEntry)
-> Ptr BindingEntry -> IO BindingEntry
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr BindingEntry -> BindingEntry
BindingEntry

instance tag ~ 'AttrSet => Constructible BindingEntry tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr BindingEntry -> BindingEntry)
-> [AttrOp BindingEntry tag] -> m BindingEntry
new ManagedPtr BindingEntry -> BindingEntry
_ [AttrOp BindingEntry tag]
attrs = do
        o <- m BindingEntry
forall (m :: * -> *). MonadIO m => m BindingEntry
newZeroBindingEntry
        GI.Attributes.set o attrs
        return o


-- | Get the value of the “@keyval@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' bindingEntry #keyval
-- @
getBindingEntryKeyval :: MonadIO m => BindingEntry -> m Word32
getBindingEntryKeyval :: forall (m :: * -> *). MonadIO m => BindingEntry -> m Word32
getBindingEntryKeyval BindingEntry
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
$ BindingEntry -> (Ptr BindingEntry -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO Word32) -> IO Word32)
-> (Ptr BindingEntry -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO Word32
    return val

-- | Set the value of the “@keyval@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' bindingEntry [ #keyval 'Data.GI.Base.Attributes.:=' value ]
-- @
setBindingEntryKeyval :: MonadIO m => BindingEntry -> Word32 -> m ()
setBindingEntryKeyval :: forall (m :: * -> *). MonadIO m => BindingEntry -> Word32 -> m ()
setBindingEntryKeyval BindingEntry
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
$ BindingEntry -> (Ptr BindingEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO ()) -> IO ())
-> (Ptr BindingEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data BindingEntryKeyvalFieldInfo
instance AttrInfo BindingEntryKeyvalFieldInfo where
    type AttrBaseTypeConstraint BindingEntryKeyvalFieldInfo = (~) BindingEntry
    type AttrAllowedOps BindingEntryKeyvalFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint BindingEntryKeyvalFieldInfo = (~) Word32
    type AttrTransferTypeConstraint BindingEntryKeyvalFieldInfo = (~)Word32
    type AttrTransferType BindingEntryKeyvalFieldInfo = Word32
    type AttrGetType BindingEntryKeyvalFieldInfo = Word32
    type AttrLabel BindingEntryKeyvalFieldInfo = "keyval"
    type AttrOrigin BindingEntryKeyvalFieldInfo = BindingEntry
    attrGet = getBindingEntryKeyval
    attrSet = setBindingEntryKeyval
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.BindingEntry.keyval"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-BindingEntry.html#g:attr:keyval"
        })

bindingEntry_keyval :: AttrLabelProxy "keyval"
bindingEntry_keyval = AttrLabelProxy

#endif


-- | Get the value of the “@modifiers@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' bindingEntry #modifiers
-- @
getBindingEntryModifiers :: MonadIO m => BindingEntry -> m [Gdk.Flags.ModifierType]
getBindingEntryModifiers :: forall (m :: * -> *). MonadIO m => BindingEntry -> m [ModifierType]
getBindingEntryModifiers BindingEntry
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
$ BindingEntry
-> (Ptr BindingEntry -> IO [ModifierType]) -> IO [ModifierType]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO [ModifierType]) -> IO [ModifierType])
-> (Ptr BindingEntry -> IO [ModifierType]) -> IO [ModifierType]
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO CUInt
    let val' = CUInt -> [ModifierType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
val
    return val'

-- | Set the value of the “@modifiers@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' bindingEntry [ #modifiers 'Data.GI.Base.Attributes.:=' value ]
-- @
setBindingEntryModifiers :: MonadIO m => BindingEntry -> [Gdk.Flags.ModifierType] -> m ()
setBindingEntryModifiers :: forall (m :: * -> *).
MonadIO m =>
BindingEntry -> [ModifierType] -> m ()
setBindingEntryModifiers BindingEntry
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
$ BindingEntry -> (Ptr BindingEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO ()) -> IO ())
-> (Ptr BindingEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
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 BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data BindingEntryModifiersFieldInfo
instance AttrInfo BindingEntryModifiersFieldInfo where
    type AttrBaseTypeConstraint BindingEntryModifiersFieldInfo = (~) BindingEntry
    type AttrAllowedOps BindingEntryModifiersFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint BindingEntryModifiersFieldInfo = (~) [Gdk.Flags.ModifierType]
    type AttrTransferTypeConstraint BindingEntryModifiersFieldInfo = (~)[Gdk.Flags.ModifierType]
    type AttrTransferType BindingEntryModifiersFieldInfo = [Gdk.Flags.ModifierType]
    type AttrGetType BindingEntryModifiersFieldInfo = [Gdk.Flags.ModifierType]
    type AttrLabel BindingEntryModifiersFieldInfo = "modifiers"
    type AttrOrigin BindingEntryModifiersFieldInfo = BindingEntry
    attrGet = getBindingEntryModifiers
    attrSet = setBindingEntryModifiers
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.BindingEntry.modifiers"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-BindingEntry.html#g:attr:modifiers"
        })

bindingEntry_modifiers :: AttrLabelProxy "modifiers"
bindingEntry_modifiers = AttrLabelProxy

#endif


-- | Get the value of the “@binding_set@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' bindingEntry #bindingSet
-- @
getBindingEntryBindingSet :: MonadIO m => BindingEntry -> m (Maybe Gtk.BindingSet.BindingSet)
getBindingEntryBindingSet :: forall (m :: * -> *).
MonadIO m =>
BindingEntry -> m (Maybe BindingSet)
getBindingEntryBindingSet BindingEntry
s = IO (Maybe BindingSet) -> m (Maybe BindingSet)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BindingSet) -> m (Maybe BindingSet))
-> IO (Maybe BindingSet) -> m (Maybe BindingSet)
forall a b. (a -> b) -> a -> b
$ BindingEntry
-> (Ptr BindingEntry -> IO (Maybe BindingSet))
-> IO (Maybe BindingSet)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO (Maybe BindingSet))
 -> IO (Maybe BindingSet))
-> (Ptr BindingEntry -> IO (Maybe BindingSet))
-> IO (Maybe BindingSet)
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    val <- Ptr (Ptr BindingSet) -> IO (Ptr BindingSet)
forall a. Storable a => Ptr a -> IO a
peek (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr (Ptr BindingSet)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO (Ptr Gtk.BindingSet.BindingSet)
    result <- SP.convertIfNonNull val $ \Ptr BindingSet
val' -> do
        val'' <- ((ManagedPtr BindingSet -> BindingSet)
-> Ptr BindingSet -> IO BindingSet
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr BindingSet -> BindingSet
Gtk.BindingSet.BindingSet) Ptr BindingSet
val'
        return val''
    return result

-- | Set the value of the “@binding_set@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' bindingEntry [ #bindingSet 'Data.GI.Base.Attributes.:=' value ]
-- @
setBindingEntryBindingSet :: MonadIO m => BindingEntry -> Ptr Gtk.BindingSet.BindingSet -> m ()
setBindingEntryBindingSet :: forall (m :: * -> *).
MonadIO m =>
BindingEntry -> Ptr BindingSet -> m ()
setBindingEntryBindingSet BindingEntry
s Ptr BindingSet
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
$ BindingEntry -> (Ptr BindingEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO ()) -> IO ())
-> (Ptr BindingEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    Ptr (Ptr BindingSet) -> Ptr BindingSet -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr (Ptr BindingSet)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Ptr BindingSet
val :: Ptr Gtk.BindingSet.BindingSet)

-- | Set the value of the “@binding_set@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #bindingSet
-- @
clearBindingEntryBindingSet :: MonadIO m => BindingEntry -> m ()
clearBindingEntryBindingSet :: forall (m :: * -> *). MonadIO m => BindingEntry -> m ()
clearBindingEntryBindingSet BindingEntry
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
$ BindingEntry -> (Ptr BindingEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO ()) -> IO ())
-> (Ptr BindingEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    Ptr (Ptr BindingSet) -> Ptr BindingSet -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr (Ptr BindingSet)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Ptr BindingSet
forall a. Ptr a
FP.nullPtr :: Ptr Gtk.BindingSet.BindingSet)

#if defined(ENABLE_OVERLOADING)
data BindingEntryBindingSetFieldInfo
instance AttrInfo BindingEntryBindingSetFieldInfo where
    type AttrBaseTypeConstraint BindingEntryBindingSetFieldInfo = (~) BindingEntry
    type AttrAllowedOps BindingEntryBindingSetFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint BindingEntryBindingSetFieldInfo = (~) (Ptr Gtk.BindingSet.BindingSet)
    type AttrTransferTypeConstraint BindingEntryBindingSetFieldInfo = (~)(Ptr Gtk.BindingSet.BindingSet)
    type AttrTransferType BindingEntryBindingSetFieldInfo = (Ptr Gtk.BindingSet.BindingSet)
    type AttrGetType BindingEntryBindingSetFieldInfo = Maybe Gtk.BindingSet.BindingSet
    type AttrLabel BindingEntryBindingSetFieldInfo = "binding_set"
    type AttrOrigin BindingEntryBindingSetFieldInfo = BindingEntry
    attrGet = getBindingEntryBindingSet
    attrSet = setBindingEntryBindingSet
    attrConstruct = undefined
    attrClear = clearBindingEntryBindingSet
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.BindingEntry.bindingSet"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-BindingEntry.html#g:attr:bindingSet"
        })

bindingEntry_bindingSet :: AttrLabelProxy "bindingSet"
bindingEntry_bindingSet = AttrLabelProxy

#endif


-- | Get the value of the “@destroyed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' bindingEntry #destroyed
-- @
getBindingEntryDestroyed :: MonadIO m => BindingEntry -> m Word32
getBindingEntryDestroyed :: forall (m :: * -> *). MonadIO m => BindingEntry -> m Word32
getBindingEntryDestroyed BindingEntry
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
$ BindingEntry -> (Ptr BindingEntry -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO Word32) -> IO Word32)
-> (Ptr BindingEntry -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO Word32
    return val

-- | Set the value of the “@destroyed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' bindingEntry [ #destroyed 'Data.GI.Base.Attributes.:=' value ]
-- @
setBindingEntryDestroyed :: MonadIO m => BindingEntry -> Word32 -> m ()
setBindingEntryDestroyed :: forall (m :: * -> *). MonadIO m => BindingEntry -> Word32 -> m ()
setBindingEntryDestroyed BindingEntry
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
$ BindingEntry -> (Ptr BindingEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO ()) -> IO ())
-> (Ptr BindingEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data BindingEntryDestroyedFieldInfo
instance AttrInfo BindingEntryDestroyedFieldInfo where
    type AttrBaseTypeConstraint BindingEntryDestroyedFieldInfo = (~) BindingEntry
    type AttrAllowedOps BindingEntryDestroyedFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint BindingEntryDestroyedFieldInfo = (~) Word32
    type AttrTransferTypeConstraint BindingEntryDestroyedFieldInfo = (~)Word32
    type AttrTransferType BindingEntryDestroyedFieldInfo = Word32
    type AttrGetType BindingEntryDestroyedFieldInfo = Word32
    type AttrLabel BindingEntryDestroyedFieldInfo = "destroyed"
    type AttrOrigin BindingEntryDestroyedFieldInfo = BindingEntry
    attrGet = getBindingEntryDestroyed
    attrSet = setBindingEntryDestroyed
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.BindingEntry.destroyed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-BindingEntry.html#g:attr:destroyed"
        })

bindingEntry_destroyed :: AttrLabelProxy "destroyed"
bindingEntry_destroyed = AttrLabelProxy

#endif


-- | Get the value of the “@in_emission@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' bindingEntry #inEmission
-- @
getBindingEntryInEmission :: MonadIO m => BindingEntry -> m Word32
getBindingEntryInEmission :: forall (m :: * -> *). MonadIO m => BindingEntry -> m Word32
getBindingEntryInEmission BindingEntry
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
$ BindingEntry -> (Ptr BindingEntry -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO Word32) -> IO Word32)
-> (Ptr BindingEntry -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) :: IO Word32
    return val

-- | Set the value of the “@in_emission@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' bindingEntry [ #inEmission 'Data.GI.Base.Attributes.:=' value ]
-- @
setBindingEntryInEmission :: MonadIO m => BindingEntry -> Word32 -> m ()
setBindingEntryInEmission :: forall (m :: * -> *). MonadIO m => BindingEntry -> Word32 -> m ()
setBindingEntryInEmission BindingEntry
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
$ BindingEntry -> (Ptr BindingEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO ()) -> IO ())
-> (Ptr BindingEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data BindingEntryInEmissionFieldInfo
instance AttrInfo BindingEntryInEmissionFieldInfo where
    type AttrBaseTypeConstraint BindingEntryInEmissionFieldInfo = (~) BindingEntry
    type AttrAllowedOps BindingEntryInEmissionFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint BindingEntryInEmissionFieldInfo = (~) Word32
    type AttrTransferTypeConstraint BindingEntryInEmissionFieldInfo = (~)Word32
    type AttrTransferType BindingEntryInEmissionFieldInfo = Word32
    type AttrGetType BindingEntryInEmissionFieldInfo = Word32
    type AttrLabel BindingEntryInEmissionFieldInfo = "in_emission"
    type AttrOrigin BindingEntryInEmissionFieldInfo = BindingEntry
    attrGet = getBindingEntryInEmission
    attrSet = setBindingEntryInEmission
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.BindingEntry.inEmission"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-BindingEntry.html#g:attr:inEmission"
        })

bindingEntry_inEmission :: AttrLabelProxy "inEmission"
bindingEntry_inEmission = AttrLabelProxy

#endif


-- | Get the value of the “@marks_unbound@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' bindingEntry #marksUnbound
-- @
getBindingEntryMarksUnbound :: MonadIO m => BindingEntry -> m Word32
getBindingEntryMarksUnbound :: forall (m :: * -> *). MonadIO m => BindingEntry -> m Word32
getBindingEntryMarksUnbound BindingEntry
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
$ BindingEntry -> (Ptr BindingEntry -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO Word32) -> IO Word32)
-> (Ptr BindingEntry -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO Word32
    return val

-- | Set the value of the “@marks_unbound@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' bindingEntry [ #marksUnbound 'Data.GI.Base.Attributes.:=' value ]
-- @
setBindingEntryMarksUnbound :: MonadIO m => BindingEntry -> Word32 -> m ()
setBindingEntryMarksUnbound :: forall (m :: * -> *). MonadIO m => BindingEntry -> Word32 -> m ()
setBindingEntryMarksUnbound BindingEntry
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
$ BindingEntry -> (Ptr BindingEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO ()) -> IO ())
-> (Ptr BindingEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data BindingEntryMarksUnboundFieldInfo
instance AttrInfo BindingEntryMarksUnboundFieldInfo where
    type AttrBaseTypeConstraint BindingEntryMarksUnboundFieldInfo = (~) BindingEntry
    type AttrAllowedOps BindingEntryMarksUnboundFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint BindingEntryMarksUnboundFieldInfo = (~) Word32
    type AttrTransferTypeConstraint BindingEntryMarksUnboundFieldInfo = (~)Word32
    type AttrTransferType BindingEntryMarksUnboundFieldInfo = Word32
    type AttrGetType BindingEntryMarksUnboundFieldInfo = Word32
    type AttrLabel BindingEntryMarksUnboundFieldInfo = "marks_unbound"
    type AttrOrigin BindingEntryMarksUnboundFieldInfo = BindingEntry
    attrGet = getBindingEntryMarksUnbound
    attrSet = setBindingEntryMarksUnbound
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.BindingEntry.marksUnbound"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-BindingEntry.html#g:attr:marksUnbound"
        })

bindingEntry_marksUnbound :: AttrLabelProxy "marksUnbound"
bindingEntry_marksUnbound = AttrLabelProxy

#endif


-- | Get the value of the “@set_next@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' bindingEntry #setNext
-- @
getBindingEntrySetNext :: MonadIO m => BindingEntry -> m (Maybe BindingEntry)
getBindingEntrySetNext :: forall (m :: * -> *).
MonadIO m =>
BindingEntry -> m (Maybe BindingEntry)
getBindingEntrySetNext BindingEntry
s = IO (Maybe BindingEntry) -> m (Maybe BindingEntry)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BindingEntry) -> m (Maybe BindingEntry))
-> IO (Maybe BindingEntry) -> m (Maybe BindingEntry)
forall a b. (a -> b) -> a -> b
$ BindingEntry
-> (Ptr BindingEntry -> IO (Maybe BindingEntry))
-> IO (Maybe BindingEntry)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO (Maybe BindingEntry))
 -> IO (Maybe BindingEntry))
-> (Ptr BindingEntry -> IO (Maybe BindingEntry))
-> IO (Maybe BindingEntry)
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    val <- Ptr (Ptr BindingEntry) -> IO (Ptr BindingEntry)
forall a. Storable a => Ptr a -> IO a
peek (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr (Ptr BindingEntry)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO (Ptr BindingEntry)
    result <- SP.convertIfNonNull val $ \Ptr BindingEntry
val' -> do
        val'' <- ((ManagedPtr BindingEntry -> BindingEntry)
-> Ptr BindingEntry -> IO BindingEntry
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr BindingEntry -> BindingEntry
BindingEntry) Ptr BindingEntry
val'
        return val''
    return result

-- | Set the value of the “@set_next@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' bindingEntry [ #setNext 'Data.GI.Base.Attributes.:=' value ]
-- @
setBindingEntrySetNext :: MonadIO m => BindingEntry -> Ptr BindingEntry -> m ()
setBindingEntrySetNext :: forall (m :: * -> *).
MonadIO m =>
BindingEntry -> Ptr BindingEntry -> m ()
setBindingEntrySetNext BindingEntry
s Ptr BindingEntry
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
$ BindingEntry -> (Ptr BindingEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO ()) -> IO ())
-> (Ptr BindingEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    Ptr (Ptr BindingEntry) -> Ptr BindingEntry -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr (Ptr BindingEntry)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (Ptr BindingEntry
val :: Ptr BindingEntry)

-- | Set the value of the “@set_next@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #setNext
-- @
clearBindingEntrySetNext :: MonadIO m => BindingEntry -> m ()
clearBindingEntrySetNext :: forall (m :: * -> *). MonadIO m => BindingEntry -> m ()
clearBindingEntrySetNext BindingEntry
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
$ BindingEntry -> (Ptr BindingEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO ()) -> IO ())
-> (Ptr BindingEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    Ptr (Ptr BindingEntry) -> Ptr BindingEntry -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr (Ptr BindingEntry)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (Ptr BindingEntry
forall a. Ptr a
FP.nullPtr :: Ptr BindingEntry)

#if defined(ENABLE_OVERLOADING)
data BindingEntrySetNextFieldInfo
instance AttrInfo BindingEntrySetNextFieldInfo where
    type AttrBaseTypeConstraint BindingEntrySetNextFieldInfo = (~) BindingEntry
    type AttrAllowedOps BindingEntrySetNextFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint BindingEntrySetNextFieldInfo = (~) (Ptr BindingEntry)
    type AttrTransferTypeConstraint BindingEntrySetNextFieldInfo = (~)(Ptr BindingEntry)
    type AttrTransferType BindingEntrySetNextFieldInfo = (Ptr BindingEntry)
    type AttrGetType BindingEntrySetNextFieldInfo = Maybe BindingEntry
    type AttrLabel BindingEntrySetNextFieldInfo = "set_next"
    type AttrOrigin BindingEntrySetNextFieldInfo = BindingEntry
    attrGet = getBindingEntrySetNext
    attrSet = setBindingEntrySetNext
    attrConstruct = undefined
    attrClear = clearBindingEntrySetNext
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.BindingEntry.setNext"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-BindingEntry.html#g:attr:setNext"
        })

bindingEntry_setNext :: AttrLabelProxy "setNext"
bindingEntry_setNext = AttrLabelProxy

#endif


-- | Get the value of the “@hash_next@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' bindingEntry #hashNext
-- @
getBindingEntryHashNext :: MonadIO m => BindingEntry -> m (Maybe BindingEntry)
getBindingEntryHashNext :: forall (m :: * -> *).
MonadIO m =>
BindingEntry -> m (Maybe BindingEntry)
getBindingEntryHashNext BindingEntry
s = IO (Maybe BindingEntry) -> m (Maybe BindingEntry)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BindingEntry) -> m (Maybe BindingEntry))
-> IO (Maybe BindingEntry) -> m (Maybe BindingEntry)
forall a b. (a -> b) -> a -> b
$ BindingEntry
-> (Ptr BindingEntry -> IO (Maybe BindingEntry))
-> IO (Maybe BindingEntry)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO (Maybe BindingEntry))
 -> IO (Maybe BindingEntry))
-> (Ptr BindingEntry -> IO (Maybe BindingEntry))
-> IO (Maybe BindingEntry)
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    val <- Ptr (Ptr BindingEntry) -> IO (Ptr BindingEntry)
forall a. Storable a => Ptr a -> IO a
peek (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr (Ptr BindingEntry)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO (Ptr BindingEntry)
    result <- SP.convertIfNonNull val $ \Ptr BindingEntry
val' -> do
        val'' <- ((ManagedPtr BindingEntry -> BindingEntry)
-> Ptr BindingEntry -> IO BindingEntry
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr BindingEntry -> BindingEntry
BindingEntry) Ptr BindingEntry
val'
        return val''
    return result

-- | Set the value of the “@hash_next@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' bindingEntry [ #hashNext 'Data.GI.Base.Attributes.:=' value ]
-- @
setBindingEntryHashNext :: MonadIO m => BindingEntry -> Ptr BindingEntry -> m ()
setBindingEntryHashNext :: forall (m :: * -> *).
MonadIO m =>
BindingEntry -> Ptr BindingEntry -> m ()
setBindingEntryHashNext BindingEntry
s Ptr BindingEntry
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
$ BindingEntry -> (Ptr BindingEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO ()) -> IO ())
-> (Ptr BindingEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    Ptr (Ptr BindingEntry) -> Ptr BindingEntry -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr (Ptr BindingEntry)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (Ptr BindingEntry
val :: Ptr BindingEntry)

-- | Set the value of the “@hash_next@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #hashNext
-- @
clearBindingEntryHashNext :: MonadIO m => BindingEntry -> m ()
clearBindingEntryHashNext :: forall (m :: * -> *). MonadIO m => BindingEntry -> m ()
clearBindingEntryHashNext BindingEntry
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
$ BindingEntry -> (Ptr BindingEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO ()) -> IO ())
-> (Ptr BindingEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    Ptr (Ptr BindingEntry) -> Ptr BindingEntry -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr (Ptr BindingEntry)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (Ptr BindingEntry
forall a. Ptr a
FP.nullPtr :: Ptr BindingEntry)

#if defined(ENABLE_OVERLOADING)
data BindingEntryHashNextFieldInfo
instance AttrInfo BindingEntryHashNextFieldInfo where
    type AttrBaseTypeConstraint BindingEntryHashNextFieldInfo = (~) BindingEntry
    type AttrAllowedOps BindingEntryHashNextFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint BindingEntryHashNextFieldInfo = (~) (Ptr BindingEntry)
    type AttrTransferTypeConstraint BindingEntryHashNextFieldInfo = (~)(Ptr BindingEntry)
    type AttrTransferType BindingEntryHashNextFieldInfo = (Ptr BindingEntry)
    type AttrGetType BindingEntryHashNextFieldInfo = Maybe BindingEntry
    type AttrLabel BindingEntryHashNextFieldInfo = "hash_next"
    type AttrOrigin BindingEntryHashNextFieldInfo = BindingEntry
    attrGet = getBindingEntryHashNext
    attrSet = setBindingEntryHashNext
    attrConstruct = undefined
    attrClear = clearBindingEntryHashNext
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.BindingEntry.hashNext"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-BindingEntry.html#g:attr:hashNext"
        })

bindingEntry_hashNext :: AttrLabelProxy "hashNext"
bindingEntry_hashNext = AttrLabelProxy

#endif


-- | Get the value of the “@signals@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' bindingEntry #signals
-- @
getBindingEntrySignals :: MonadIO m => BindingEntry -> m (Maybe Gtk.BindingSignal.BindingSignal)
getBindingEntrySignals :: forall (m :: * -> *).
MonadIO m =>
BindingEntry -> m (Maybe BindingSignal)
getBindingEntrySignals BindingEntry
s = IO (Maybe BindingSignal) -> m (Maybe BindingSignal)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BindingSignal) -> m (Maybe BindingSignal))
-> IO (Maybe BindingSignal) -> m (Maybe BindingSignal)
forall a b. (a -> b) -> a -> b
$ BindingEntry
-> (Ptr BindingEntry -> IO (Maybe BindingSignal))
-> IO (Maybe BindingSignal)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO (Maybe BindingSignal))
 -> IO (Maybe BindingSignal))
-> (Ptr BindingEntry -> IO (Maybe BindingSignal))
-> IO (Maybe BindingSignal)
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    val <- Ptr (Ptr BindingSignal) -> IO (Ptr BindingSignal)
forall a. Storable a => Ptr a -> IO a
peek (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr (Ptr BindingSignal)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) :: IO (Ptr Gtk.BindingSignal.BindingSignal)
    result <- SP.convertIfNonNull val $ \Ptr BindingSignal
val' -> do
        val'' <- ((ManagedPtr BindingSignal -> BindingSignal)
-> Ptr BindingSignal -> IO BindingSignal
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr BindingSignal -> BindingSignal
Gtk.BindingSignal.BindingSignal) Ptr BindingSignal
val'
        return val''
    return result

-- | Set the value of the “@signals@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' bindingEntry [ #signals 'Data.GI.Base.Attributes.:=' value ]
-- @
setBindingEntrySignals :: MonadIO m => BindingEntry -> Ptr Gtk.BindingSignal.BindingSignal -> m ()
setBindingEntrySignals :: forall (m :: * -> *).
MonadIO m =>
BindingEntry -> Ptr BindingSignal -> m ()
setBindingEntrySignals BindingEntry
s Ptr BindingSignal
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
$ BindingEntry -> (Ptr BindingEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO ()) -> IO ())
-> (Ptr BindingEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    Ptr (Ptr BindingSignal) -> Ptr BindingSignal -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr (Ptr BindingSignal)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (Ptr BindingSignal
val :: Ptr Gtk.BindingSignal.BindingSignal)

-- | Set the value of the “@signals@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #signals
-- @
clearBindingEntrySignals :: MonadIO m => BindingEntry -> m ()
clearBindingEntrySignals :: forall (m :: * -> *). MonadIO m => BindingEntry -> m ()
clearBindingEntrySignals BindingEntry
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
$ BindingEntry -> (Ptr BindingEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr BindingEntry
s ((Ptr BindingEntry -> IO ()) -> IO ())
-> (Ptr BindingEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr BindingEntry
ptr -> do
    Ptr (Ptr BindingSignal) -> Ptr BindingSignal -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BindingEntry
ptr Ptr BindingEntry -> Int -> Ptr (Ptr BindingSignal)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (Ptr BindingSignal
forall a. Ptr a
FP.nullPtr :: Ptr Gtk.BindingSignal.BindingSignal)

#if defined(ENABLE_OVERLOADING)
data BindingEntrySignalsFieldInfo
instance AttrInfo BindingEntrySignalsFieldInfo where
    type AttrBaseTypeConstraint BindingEntrySignalsFieldInfo = (~) BindingEntry
    type AttrAllowedOps BindingEntrySignalsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint BindingEntrySignalsFieldInfo = (~) (Ptr Gtk.BindingSignal.BindingSignal)
    type AttrTransferTypeConstraint BindingEntrySignalsFieldInfo = (~)(Ptr Gtk.BindingSignal.BindingSignal)
    type AttrTransferType BindingEntrySignalsFieldInfo = (Ptr Gtk.BindingSignal.BindingSignal)
    type AttrGetType BindingEntrySignalsFieldInfo = Maybe Gtk.BindingSignal.BindingSignal
    type AttrLabel BindingEntrySignalsFieldInfo = "signals"
    type AttrOrigin BindingEntrySignalsFieldInfo = BindingEntry
    attrGet = getBindingEntrySignals
    attrSet = setBindingEntrySignals
    attrConstruct = undefined
    attrClear = clearBindingEntrySignals
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Structs.BindingEntry.signals"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Structs-BindingEntry.html#g:attr:signals"
        })

bindingEntry_signals :: AttrLabelProxy "signals"
bindingEntry_signals = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
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, DK.Type)])
#endif

-- method BindingEntry::add_signal_from_string
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "binding_set"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "BindingSet" }
--           , argCType = Just "GtkBindingSet*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkBindingSet" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "signal_desc"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a signal description"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = 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 t'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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BindingSet -> Text -> m TokenType
bindingEntryAddSignalFromString BindingSet
bindingSet Text
signalDesc = IO TokenType -> m TokenType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TokenType -> m TokenType) -> IO TokenType -> m TokenType
forall a b. (a -> b) -> a -> b
$ do
    bindingSet' <- BindingSet -> IO (Ptr BindingSet)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BindingSet
bindingSet
    signalDesc' <- textToCString signalDesc
    result <- gtk_binding_entry_add_signal_from_string bindingSet' signalDesc'
    let result' = (Int -> TokenType
forall a. Enum a => Int -> a
toEnum (Int -> TokenType) -> (CUInt -> Int) -> CUInt -> TokenType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    touchManagedPtr bindingSet
    freeMem signalDesc'
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method BindingEntry::add_signall
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "binding_set"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "BindingSet" }
--           , argCType = Just "GtkBindingSet*"
--           , 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
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "keyval"
--           , argType = TBasicType TUInt
--           , argCType = Just "guint"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "key value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "modifiers"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "ModifierType" }
--           , argCType = Just "GdkModifierType"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "key modifier" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "signal_name"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "signal name to be bound"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "binding_args"
--           , argType =
--               TGSList
--                 (TInterface Name { namespace = "Gtk" , name = "BindingArg" })
--           , argCType = Just "GSList*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "\n    list of #GtkBindingArg signal arguments"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = 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 t'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 t'GI.Gtk.Structs.BindingArg.BindingArg' signal arguments
    -> m ()
bindingEntryAddSignall :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BindingSet
-> Word32 -> [ModifierType] -> Text -> [BindingArg] -> m ()
bindingEntryAddSignall BindingSet
bindingSet Word32
keyval [ModifierType]
modifiers Text
signalName [BindingArg]
bindingArgs = 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
$ do
    bindingSet' <- BindingSet -> IO (Ptr BindingSet)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BindingSet
bindingSet
    let modifiers' = [ModifierType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ModifierType]
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 ()

#if defined(ENABLE_OVERLOADING)
#endif

-- method BindingEntry::remove
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "binding_set"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "BindingSet" }
--           , argCType = Just "GtkBindingSet*"
--           , 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
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "keyval"
--           , argType = TBasicType TUInt
--           , argCType = Just "guint"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "key value of binding to remove"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "modifiers"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "ModifierType" }
--           , argCType = Just "GdkModifierType"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "key modifier of binding to remove"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = 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 t'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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BindingSet -> Word32 -> [ModifierType] -> m ()
bindingEntryRemove BindingSet
bindingSet Word32
keyval [ModifierType]
modifiers = 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
$ do
    bindingSet' <- BindingSet -> IO (Ptr BindingSet)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BindingSet
bindingSet
    let modifiers' = [ModifierType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ModifierType]
modifiers
    gtk_binding_entry_remove bindingSet' keyval modifiers'
    touchManagedPtr bindingSet
    return ()

#if defined(ENABLE_OVERLOADING)
#endif

-- method BindingEntry::skip
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "binding_set"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "BindingSet" }
--           , argCType = Just "GtkBindingSet*"
--           , 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
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "keyval"
--           , argType = TBasicType TUInt
--           , argCType = Just "guint"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "key value of binding to skip"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "modifiers"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "ModifierType" }
--           , argCType = Just "GdkModifierType"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "key modifier of binding to skip"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = 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 t'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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BindingSet -> Word32 -> [ModifierType] -> m ()
bindingEntrySkip BindingSet
bindingSet Word32
keyval [ModifierType]
modifiers = 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
$ do
    bindingSet' <- BindingSet -> IO (Ptr BindingSet)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BindingSet
bindingSet
    let modifiers' = [ModifierType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ModifierType]
modifiers
    gtk_binding_entry_skip bindingSet' keyval modifiers'
    touchManagedPtr bindingSet
    return ()

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveBindingEntryMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveBindingEntryMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveBindingEntryMethod t BindingEntry, O.OverloadedMethod info BindingEntry p) => OL.IsLabel t (BindingEntry -> 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 ~ ResolveBindingEntryMethod t BindingEntry, O.OverloadedMethod info BindingEntry p, R.HasField t BindingEntry p) => R.HasField t BindingEntry p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveBindingEntryMethod t BindingEntry, O.OverloadedMethodInfo info BindingEntry) => OL.IsLabel t (O.MethodProxy info BindingEntry) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif