{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.GObject.Objects.SignalGroup.SignalGroup' manages to simplify the process of connecting
-- many signals to a t'GI.GObject.Objects.Object.Object' as a group. As such there is no API
-- to disconnect a signal from the group.
-- 
-- In particular, this allows you to:
-- 
--  - Change the target instance, which automatically causes disconnection
--    of the signals from the old instance and connecting to the new instance.
--  - Block and unblock signals as a group
--  - Ensuring that blocked state transfers across target instances.
-- 
-- One place you might want to use such a structure is with @/GtkTextView/@ and
-- @/GtkTextBuffer/@. Often times, you\'ll need to connect to many signals on
-- @/GtkTextBuffer/@ from a @/GtkTextView/@ subclass. This allows you to create a
-- signal group during instance construction, simply bind the
-- @/GtkTextView:buffer/@ property to [SignalGroup:target]("GI.GObject.Objects.SignalGroup#g:attr:target") and connect
-- all the signals you need. When the @/GtkTextView:buffer/@ property changes
-- all of the signals will be transitioned correctly.
-- 
-- /Since: 2.72/

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

module GI.GObject.Objects.SignalGroup
    ( 

-- * Exported types
    SignalGroup(..)                         ,
    IsSignalGroup                           ,
    toSignalGroup                           ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [block]("GI.GObject.Objects.SignalGroup#g:method:block"), [connectClosure]("GI.GObject.Objects.SignalGroup#g:method:connectClosure"), [connectData]("GI.GObject.Objects.SignalGroup#g:method:connectData"), [connectSwapped]("GI.GObject.Objects.SignalGroup#g:method:connectSwapped"), [dupTarget]("GI.GObject.Objects.SignalGroup#g:method:dupTarget"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unblock]("GI.GObject.Objects.SignalGroup#g:method:unblock"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setTarget]("GI.GObject.Objects.SignalGroup#g:method:setTarget").

#if defined(ENABLE_OVERLOADING)
    ResolveSignalGroupMethod                ,
#endif

-- ** block #method:block#

#if defined(ENABLE_OVERLOADING)
    SignalGroupBlockMethodInfo              ,
#endif
    signalGroupBlock                        ,


-- ** connectClosure #method:connectClosure#

#if defined(ENABLE_OVERLOADING)
    SignalGroupConnectClosureMethodInfo     ,
#endif
    signalGroupConnectClosure               ,


-- ** connectData #method:connectData#

#if defined(ENABLE_OVERLOADING)
    SignalGroupConnectDataMethodInfo        ,
#endif
    signalGroupConnectData                  ,


-- ** connectSwapped #method:connectSwapped#

#if defined(ENABLE_OVERLOADING)
    SignalGroupConnectSwappedMethodInfo     ,
#endif
    signalGroupConnectSwapped               ,


-- ** dupTarget #method:dupTarget#

#if defined(ENABLE_OVERLOADING)
    SignalGroupDupTargetMethodInfo          ,
#endif
    signalGroupDupTarget                    ,


-- ** new #method:new#

    signalGroupNew                          ,


-- ** setTarget #method:setTarget#

#if defined(ENABLE_OVERLOADING)
    SignalGroupSetTargetMethodInfo          ,
#endif
    signalGroupSetTarget                    ,


-- ** unblock #method:unblock#

#if defined(ENABLE_OVERLOADING)
    SignalGroupUnblockMethodInfo            ,
#endif
    signalGroupUnblock                      ,




 -- * Properties


-- ** target #attr:target#
-- | The target instance used when connecting signals.
-- 
-- /Since: 2.72/

#if defined(ENABLE_OVERLOADING)
    SignalGroupTargetPropertyInfo           ,
#endif
    clearSignalGroupTarget                  ,
    constructSignalGroupTarget              ,
    getSignalGroupTarget                    ,
    setSignalGroupTarget                    ,
#if defined(ENABLE_OVERLOADING)
    signalGroupTarget                       ,
#endif


-- ** targetType #attr:targetType#
-- | The t'GType' of the target property.
-- 
-- /Since: 2.72/

#if defined(ENABLE_OVERLOADING)
    SignalGroupTargetTypePropertyInfo       ,
#endif
    constructSignalGroupTargetType          ,
    getSignalGroupTargetType                ,
#if defined(ENABLE_OVERLOADING)
    signalGroupTargetType                   ,
#endif




 -- * Signals


-- ** bind #signal:bind#

    SignalGroupBindCallback                 ,
#if defined(ENABLE_OVERLOADING)
    SignalGroupBindSignalInfo               ,
#endif
    afterSignalGroupBind                    ,
    onSignalGroupBind                       ,


-- ** unbind #signal:unbind#

    SignalGroupUnbindCallback               ,
#if defined(ENABLE_OVERLOADING)
    SignalGroupUnbindSignalInfo             ,
#endif
    afterSignalGroupUnbind                  ,
    onSignalGroupUnbind                     ,




    ) 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 GI.GObject.Callbacks as GObject.Callbacks
import {-# SOURCE #-} qualified GI.GObject.Flags as GObject.Flags
import {-# SOURCE #-} qualified GI.GObject.Objects.Object as GObject.Object

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

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

foreign import ccall "g_signal_group_get_type"
    c_g_signal_group_get_type :: IO B.Types.GType

instance B.Types.TypedObject SignalGroup where
    glibType :: IO GType
glibType = IO GType
c_g_signal_group_get_type

instance B.Types.GObject SignalGroup

-- | Type class for types which can be safely cast to `SignalGroup`, for instance with `toSignalGroup`.
class (SP.GObject o, O.IsDescendantOf SignalGroup o) => IsSignalGroup o
instance (SP.GObject o, O.IsDescendantOf SignalGroup o) => IsSignalGroup o

instance O.HasParentTypes SignalGroup
type instance O.ParentTypes SignalGroup = '[GObject.Object.Object]

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

-- | Convert 'SignalGroup' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe SignalGroup) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_signal_group_get_type
    gvalueSet_ :: Ptr GValue -> Maybe SignalGroup -> IO ()
gvalueSet_ Ptr GValue
gv Maybe SignalGroup
P.Nothing = Ptr GValue -> Ptr SignalGroup -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr SignalGroup
forall a. Ptr a
FP.nullPtr :: FP.Ptr SignalGroup)
    gvalueSet_ Ptr GValue
gv (P.Just SignalGroup
obj) = SignalGroup -> (Ptr SignalGroup -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr SignalGroup
obj (Ptr GValue -> Ptr SignalGroup -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe SignalGroup)
gvalueGet_ Ptr GValue
gv = do
        Ptr SignalGroup
ptr <- Ptr GValue -> IO (Ptr SignalGroup)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr SignalGroup)
        if Ptr SignalGroup
ptr Ptr SignalGroup -> Ptr SignalGroup -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr SignalGroup
forall a. Ptr a
FP.nullPtr
        then SignalGroup -> Maybe SignalGroup
forall a. a -> Maybe a
P.Just (SignalGroup -> Maybe SignalGroup)
-> IO SignalGroup -> IO (Maybe SignalGroup)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr SignalGroup -> SignalGroup)
-> Ptr SignalGroup -> IO SignalGroup
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr SignalGroup -> SignalGroup
SignalGroup Ptr SignalGroup
ptr
        else Maybe SignalGroup -> IO (Maybe SignalGroup)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SignalGroup
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveSignalGroupMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveSignalGroupMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveSignalGroupMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveSignalGroupMethod "block" o = SignalGroupBlockMethodInfo
    ResolveSignalGroupMethod "connectClosure" o = SignalGroupConnectClosureMethodInfo
    ResolveSignalGroupMethod "connectData" o = SignalGroupConnectDataMethodInfo
    ResolveSignalGroupMethod "connectSwapped" o = SignalGroupConnectSwappedMethodInfo
    ResolveSignalGroupMethod "dupTarget" o = SignalGroupDupTargetMethodInfo
    ResolveSignalGroupMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveSignalGroupMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveSignalGroupMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveSignalGroupMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveSignalGroupMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveSignalGroupMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveSignalGroupMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveSignalGroupMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveSignalGroupMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveSignalGroupMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveSignalGroupMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveSignalGroupMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveSignalGroupMethod "unblock" o = SignalGroupUnblockMethodInfo
    ResolveSignalGroupMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveSignalGroupMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveSignalGroupMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveSignalGroupMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveSignalGroupMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveSignalGroupMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveSignalGroupMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveSignalGroupMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveSignalGroupMethod "setTarget" o = SignalGroupSetTargetMethodInfo
    ResolveSignalGroupMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- signal SignalGroup::bind
-- | This signal is emitted when [SignalGroup:target]("GI.GObject.Objects.SignalGroup#g:attr:target") is set to a new value
-- other than 'P.Nothing'. It is similar to [Object::notify]("GI.GObject.Objects.Object#g:signal:notify") on @target@ except it
-- will not emit when [SignalGroup:target]("GI.GObject.Objects.SignalGroup#g:attr:target") is 'P.Nothing' and also allows for
-- receiving the t'GI.GObject.Objects.Object.Object' without a data-race.
-- 
-- /Since: 2.72/
type SignalGroupBindCallback =
    GObject.Object.Object
    -- ^ /@instance@/: a t'GI.GObject.Objects.Object.Object' containing the new value for [SignalGroup:target]("GI.GObject.Objects.SignalGroup#g:attr:target")
    -> IO ()

type C_SignalGroupBindCallback =
    Ptr SignalGroup ->                      -- object
    Ptr GObject.Object.Object ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_SignalGroupBindCallback`.
foreign import ccall "wrapper"
    mk_SignalGroupBindCallback :: C_SignalGroupBindCallback -> IO (FunPtr C_SignalGroupBindCallback)

wrap_SignalGroupBindCallback :: 
    GObject a => (a -> SignalGroupBindCallback) ->
    C_SignalGroupBindCallback
wrap_SignalGroupBindCallback :: forall a.
GObject a =>
(a -> SignalGroupBindCallback) -> C_SignalGroupBindCallback
wrap_SignalGroupBindCallback a -> SignalGroupBindCallback
gi'cb Ptr SignalGroup
gi'selfPtr Ptr Object
instance_ Ptr ()
_ = do
    Object
instance_' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
instance_
    Ptr SignalGroup -> (SignalGroup -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr SignalGroup
gi'selfPtr ((SignalGroup -> IO ()) -> IO ())
-> (SignalGroup -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SignalGroup
gi'self -> a -> SignalGroupBindCallback
gi'cb (SignalGroup -> a
forall a b. Coercible a b => a -> b
Coerce.coerce SignalGroup
gi'self)  Object
instance_'


-- | Connect a signal handler for the [bind](#signal:bind) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' signalGroup #bind callback
-- @
-- 
-- 
onSignalGroupBind :: (IsSignalGroup a, MonadIO m) => a -> ((?self :: a) => SignalGroupBindCallback) -> m SignalHandlerId
onSignalGroupBind :: forall a (m :: * -> *).
(IsSignalGroup a, MonadIO m) =>
a -> ((?self::a) => SignalGroupBindCallback) -> m SignalHandlerId
onSignalGroupBind a
obj (?self::a) => SignalGroupBindCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> SignalGroupBindCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SignalGroupBindCallback
SignalGroupBindCallback
cb
    let wrapped' :: C_SignalGroupBindCallback
wrapped' = (a -> SignalGroupBindCallback) -> C_SignalGroupBindCallback
forall a.
GObject a =>
(a -> SignalGroupBindCallback) -> C_SignalGroupBindCallback
wrap_SignalGroupBindCallback a -> SignalGroupBindCallback
wrapped
    FunPtr C_SignalGroupBindCallback
wrapped'' <- C_SignalGroupBindCallback -> IO (FunPtr C_SignalGroupBindCallback)
mk_SignalGroupBindCallback C_SignalGroupBindCallback
wrapped'
    a
-> Text
-> FunPtr C_SignalGroupBindCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"bind" FunPtr C_SignalGroupBindCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [bind](#signal:bind) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' signalGroup #bind callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterSignalGroupBind :: (IsSignalGroup a, MonadIO m) => a -> ((?self :: a) => SignalGroupBindCallback) -> m SignalHandlerId
afterSignalGroupBind :: forall a (m :: * -> *).
(IsSignalGroup a, MonadIO m) =>
a -> ((?self::a) => SignalGroupBindCallback) -> m SignalHandlerId
afterSignalGroupBind a
obj (?self::a) => SignalGroupBindCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> SignalGroupBindCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SignalGroupBindCallback
SignalGroupBindCallback
cb
    let wrapped' :: C_SignalGroupBindCallback
wrapped' = (a -> SignalGroupBindCallback) -> C_SignalGroupBindCallback
forall a.
GObject a =>
(a -> SignalGroupBindCallback) -> C_SignalGroupBindCallback
wrap_SignalGroupBindCallback a -> SignalGroupBindCallback
wrapped
    FunPtr C_SignalGroupBindCallback
wrapped'' <- C_SignalGroupBindCallback -> IO (FunPtr C_SignalGroupBindCallback)
mk_SignalGroupBindCallback C_SignalGroupBindCallback
wrapped'
    a
-> Text
-> FunPtr C_SignalGroupBindCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"bind" FunPtr C_SignalGroupBindCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data SignalGroupBindSignalInfo
instance SignalInfo SignalGroupBindSignalInfo where
    type HaskellCallbackType SignalGroupBindSignalInfo = SignalGroupBindCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_SignalGroupBindCallback cb
        cb'' <- mk_SignalGroupBindCallback cb'
        connectSignalFunPtr obj "bind" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Objects.SignalGroup::bind"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.30/docs/GI-GObject-Objects-SignalGroup.html#g:signal:bind"})

#endif

-- signal SignalGroup::unbind
-- | This signal is emitted when the target instance of /@self@/ is set to a
-- new t'GI.GObject.Objects.Object.Object'.
-- 
-- This signal will only be emitted if the previous target of /@self@/ is
-- non-'P.Nothing'.
-- 
-- /Since: 2.72/
type SignalGroupUnbindCallback =
    IO ()

type C_SignalGroupUnbindCallback =
    Ptr SignalGroup ->                      -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_SignalGroupUnbindCallback`.
foreign import ccall "wrapper"
    mk_SignalGroupUnbindCallback :: C_SignalGroupUnbindCallback -> IO (FunPtr C_SignalGroupUnbindCallback)

wrap_SignalGroupUnbindCallback :: 
    GObject a => (a -> SignalGroupUnbindCallback) ->
    C_SignalGroupUnbindCallback
wrap_SignalGroupUnbindCallback :: forall a. GObject a => (a -> IO ()) -> C_SignalGroupUnbindCallback
wrap_SignalGroupUnbindCallback a -> IO ()
gi'cb Ptr SignalGroup
gi'selfPtr Ptr ()
_ = do
    Ptr SignalGroup -> (SignalGroup -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr SignalGroup
gi'selfPtr ((SignalGroup -> IO ()) -> IO ())
-> (SignalGroup -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SignalGroup
gi'self -> a -> IO ()
gi'cb (SignalGroup -> a
forall a b. Coercible a b => a -> b
Coerce.coerce SignalGroup
gi'self) 


-- | Connect a signal handler for the [unbind](#signal:unbind) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' signalGroup #unbind callback
-- @
-- 
-- 
onSignalGroupUnbind :: (IsSignalGroup a, MonadIO m) => a -> ((?self :: a) => SignalGroupUnbindCallback) -> m SignalHandlerId
onSignalGroupUnbind :: forall a (m :: * -> *).
(IsSignalGroup a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onSignalGroupUnbind a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_SignalGroupUnbindCallback
wrapped' = (a -> IO ()) -> C_SignalGroupUnbindCallback
forall a. GObject a => (a -> IO ()) -> C_SignalGroupUnbindCallback
wrap_SignalGroupUnbindCallback a -> IO ()
wrapped
    FunPtr C_SignalGroupUnbindCallback
wrapped'' <- C_SignalGroupUnbindCallback
-> IO (FunPtr C_SignalGroupUnbindCallback)
mk_SignalGroupUnbindCallback C_SignalGroupUnbindCallback
wrapped'
    a
-> Text
-> FunPtr C_SignalGroupUnbindCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"unbind" FunPtr C_SignalGroupUnbindCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [unbind](#signal:unbind) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' signalGroup #unbind callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterSignalGroupUnbind :: (IsSignalGroup a, MonadIO m) => a -> ((?self :: a) => SignalGroupUnbindCallback) -> m SignalHandlerId
afterSignalGroupUnbind :: forall a (m :: * -> *).
(IsSignalGroup a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterSignalGroupUnbind a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_SignalGroupUnbindCallback
wrapped' = (a -> IO ()) -> C_SignalGroupUnbindCallback
forall a. GObject a => (a -> IO ()) -> C_SignalGroupUnbindCallback
wrap_SignalGroupUnbindCallback a -> IO ()
wrapped
    FunPtr C_SignalGroupUnbindCallback
wrapped'' <- C_SignalGroupUnbindCallback
-> IO (FunPtr C_SignalGroupUnbindCallback)
mk_SignalGroupUnbindCallback C_SignalGroupUnbindCallback
wrapped'
    a
-> Text
-> FunPtr C_SignalGroupUnbindCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"unbind" FunPtr C_SignalGroupUnbindCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data SignalGroupUnbindSignalInfo
instance SignalInfo SignalGroupUnbindSignalInfo where
    type HaskellCallbackType SignalGroupUnbindSignalInfo = SignalGroupUnbindCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_SignalGroupUnbindCallback cb
        cb'' <- mk_SignalGroupUnbindCallback cb'
        connectSignalFunPtr obj "unbind" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Objects.SignalGroup::unbind"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.30/docs/GI-GObject-Objects-SignalGroup.html#g:signal:unbind"})

#endif

-- VVV Prop "target"
   -- Type: TInterface (Name {namespace = "GObject", name = "Object"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just True)

-- | Get the value of the “@target@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' signalGroup #target
-- @
getSignalGroupTarget :: (MonadIO m, IsSignalGroup o) => o -> m (Maybe GObject.Object.Object)
getSignalGroupTarget :: forall (m :: * -> *) o.
(MonadIO m, IsSignalGroup o) =>
o -> m (Maybe Object)
getSignalGroupTarget o
obj = IO (Maybe Object) -> m (Maybe Object)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Object -> Object) -> IO (Maybe Object)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"target" ManagedPtr Object -> Object
GObject.Object.Object

-- | Set the value of the “@target@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' signalGroup [ #target 'Data.GI.Base.Attributes.:=' value ]
-- @
setSignalGroupTarget :: (MonadIO m, IsSignalGroup o, GObject.Object.IsObject a) => o -> a -> m ()
setSignalGroupTarget :: forall (m :: * -> *) o a.
(MonadIO m, IsSignalGroup o, IsObject a) =>
o -> a -> m ()
setSignalGroupTarget o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"target" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@target@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSignalGroupTarget :: (IsSignalGroup o, MIO.MonadIO m, GObject.Object.IsObject a) => a -> m (GValueConstruct o)
constructSignalGroupTarget :: forall o (m :: * -> *) a.
(IsSignalGroup o, MonadIO m, IsObject a) =>
a -> m (GValueConstruct o)
constructSignalGroupTarget a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"target" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@target@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #target
-- @
clearSignalGroupTarget :: (MonadIO m, IsSignalGroup o) => o -> m ()
clearSignalGroupTarget :: forall (m :: * -> *) o. (MonadIO m, IsSignalGroup o) => o -> m ()
clearSignalGroupTarget o
obj = 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
$ o -> String -> Maybe Object -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"target" (Maybe Object
forall a. Maybe a
Nothing :: Maybe GObject.Object.Object)

#if defined(ENABLE_OVERLOADING)
data SignalGroupTargetPropertyInfo
instance AttrInfo SignalGroupTargetPropertyInfo where
    type AttrAllowedOps SignalGroupTargetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SignalGroupTargetPropertyInfo = IsSignalGroup
    type AttrSetTypeConstraint SignalGroupTargetPropertyInfo = GObject.Object.IsObject
    type AttrTransferTypeConstraint SignalGroupTargetPropertyInfo = GObject.Object.IsObject
    type AttrTransferType SignalGroupTargetPropertyInfo = GObject.Object.Object
    type AttrGetType SignalGroupTargetPropertyInfo = (Maybe GObject.Object.Object)
    type AttrLabel SignalGroupTargetPropertyInfo = "target"
    type AttrOrigin SignalGroupTargetPropertyInfo = SignalGroup
    attrGet = getSignalGroupTarget
    attrSet = setSignalGroupTarget
    attrTransfer _ v = do
        unsafeCastTo GObject.Object.Object v
    attrConstruct = constructSignalGroupTarget
    attrClear = clearSignalGroupTarget
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Objects.SignalGroup.target"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.30/docs/GI-GObject-Objects-SignalGroup.html#g:attr:target"
        })
#endif

-- VVV Prop "target-type"
   -- Type: TBasicType TGType
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@target-type@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' signalGroup #targetType
-- @
getSignalGroupTargetType :: (MonadIO m, IsSignalGroup o) => o -> m GType
getSignalGroupTargetType :: forall (m :: * -> *) o.
(MonadIO m, IsSignalGroup o) =>
o -> m GType
getSignalGroupTargetType o
obj = IO GType -> m GType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO GType -> m GType) -> IO GType -> m GType
forall a b. (a -> b) -> a -> b
$ o -> String -> IO GType
forall a. GObject a => a -> String -> IO GType
B.Properties.getObjectPropertyGType o
obj String
"target-type"

-- | Construct a `GValueConstruct` with valid value for the “@target-type@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSignalGroupTargetType :: (IsSignalGroup o, MIO.MonadIO m) => GType -> m (GValueConstruct o)
constructSignalGroupTargetType :: forall o (m :: * -> *).
(IsSignalGroup o, MonadIO m) =>
GType -> m (GValueConstruct o)
constructSignalGroupTargetType GType
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> GType -> IO (GValueConstruct o)
forall o. String -> GType -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyGType String
"target-type" GType
val

#if defined(ENABLE_OVERLOADING)
data SignalGroupTargetTypePropertyInfo
instance AttrInfo SignalGroupTargetTypePropertyInfo where
    type AttrAllowedOps SignalGroupTargetTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SignalGroupTargetTypePropertyInfo = IsSignalGroup
    type AttrSetTypeConstraint SignalGroupTargetTypePropertyInfo = (~) GType
    type AttrTransferTypeConstraint SignalGroupTargetTypePropertyInfo = (~) GType
    type AttrTransferType SignalGroupTargetTypePropertyInfo = GType
    type AttrGetType SignalGroupTargetTypePropertyInfo = GType
    type AttrLabel SignalGroupTargetTypePropertyInfo = "target-type"
    type AttrOrigin SignalGroupTargetTypePropertyInfo = SignalGroup
    attrGet = getSignalGroupTargetType
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructSignalGroupTargetType
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Objects.SignalGroup.targetType"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.30/docs/GI-GObject-Objects-SignalGroup.html#g:attr:targetType"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList SignalGroup
type instance O.AttributeList SignalGroup = SignalGroupAttributeList
type SignalGroupAttributeList = ('[ '("target", SignalGroupTargetPropertyInfo), '("targetType", SignalGroupTargetTypePropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
signalGroupTarget :: AttrLabelProxy "target"
signalGroupTarget = AttrLabelProxy

signalGroupTargetType :: AttrLabelProxy "targetType"
signalGroupTargetType = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList SignalGroup = SignalGroupSignalList
type SignalGroupSignalList = ('[ '("bind", SignalGroupBindSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("unbind", SignalGroupUnbindSignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method SignalGroup::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "target_type"
--           , argType = TBasicType TGType
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GType of the target instance."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GObject" , name = "SignalGroup" })
-- throws : False
-- Skip return : False

foreign import ccall "g_signal_group_new" g_signal_group_new :: 
    CGType ->                               -- target_type : TBasicType TGType
    IO (Ptr SignalGroup)

-- | Creates a new t'GI.GObject.Objects.SignalGroup.SignalGroup' for target instances of /@targetType@/.
-- 
-- /Since: 2.72/
signalGroupNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GType
    -- ^ /@targetType@/: the t'GType' of the target instance.
    -> m SignalGroup
    -- ^ __Returns:__ a new t'GI.GObject.Objects.SignalGroup.SignalGroup'
signalGroupNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
GType -> m SignalGroup
signalGroupNew GType
targetType = IO SignalGroup -> m SignalGroup
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalGroup -> m SignalGroup)
-> IO SignalGroup -> m SignalGroup
forall a b. (a -> b) -> a -> b
$ do
    let targetType' :: CGType
targetType' = GType -> CGType
gtypeToCGType GType
targetType
    Ptr SignalGroup
result <- CGType -> IO (Ptr SignalGroup)
g_signal_group_new CGType
targetType'
    Text -> Ptr SignalGroup -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"signalGroupNew" Ptr SignalGroup
result
    SignalGroup
result' <- ((ManagedPtr SignalGroup -> SignalGroup)
-> Ptr SignalGroup -> IO SignalGroup
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr SignalGroup -> SignalGroup
SignalGroup) Ptr SignalGroup
result
    SignalGroup -> IO SignalGroup
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SignalGroup
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SignalGroup::block
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "SignalGroup" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GSignalGroup" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_signal_group_block" g_signal_group_block :: 
    Ptr SignalGroup ->                      -- self : TInterface (Name {namespace = "GObject", name = "SignalGroup"})
    IO ()

-- | Blocks all signal handlers managed by /@self@/ so they will not
-- be called during any signal emissions. Must be unblocked exactly
-- the same number of times it has been blocked to become active again.
-- 
-- This blocked state will be kept across changes of the target instance.
-- 
-- /Since: 2.72/
signalGroupBlock ::
    (B.CallStack.HasCallStack, MonadIO m, IsSignalGroup a) =>
    a
    -- ^ /@self@/: the t'GI.GObject.Objects.SignalGroup.SignalGroup'
    -> m ()
signalGroupBlock :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSignalGroup a) =>
a -> m ()
signalGroupBlock a
self = 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
    Ptr SignalGroup
self' <- a -> IO (Ptr SignalGroup)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr SignalGroup -> IO ()
g_signal_group_block Ptr SignalGroup
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SignalGroupBlockMethodInfo
instance (signature ~ (m ()), MonadIO m, IsSignalGroup a) => O.OverloadedMethod SignalGroupBlockMethodInfo a signature where
    overloadedMethod = signalGroupBlock

instance O.OverloadedMethodInfo SignalGroupBlockMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Objects.SignalGroup.signalGroupBlock",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.30/docs/GI-GObject-Objects-SignalGroup.html#v:signalGroupBlock"
        })


#endif

-- method SignalGroup::connect_closure
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "SignalGroup" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GSignalGroup" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "detailed_signal"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a string of the form `signal-name` with optional `::signal-detail`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "closure"
--           , argType = TGClosure Nothing
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the closure to connect."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "after"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "whether the handler should be called before or after the\n default handler of the signal."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_signal_group_connect_closure" g_signal_group_connect_closure :: 
    Ptr SignalGroup ->                      -- self : TInterface (Name {namespace = "GObject", name = "SignalGroup"})
    CString ->                              -- detailed_signal : TBasicType TUTF8
    Ptr (GClosure ()) ->                    -- closure : TGClosure Nothing
    CInt ->                                 -- after : TBasicType TBoolean
    IO ()

-- | Connects /@closure@/ to the signal /@detailedSignal@/ on [SignalGroup:target]("GI.GObject.Objects.SignalGroup#g:attr:target").
-- 
-- You cannot connect a signal handler after [SignalGroup:target]("GI.GObject.Objects.SignalGroup#g:attr:target") has been set.
-- 
-- /Since: 2.74/
signalGroupConnectClosure ::
    (B.CallStack.HasCallStack, MonadIO m, IsSignalGroup a) =>
    a
    -- ^ /@self@/: a t'GI.GObject.Objects.SignalGroup.SignalGroup'
    -> T.Text
    -- ^ /@detailedSignal@/: a string of the form @signal-name@ with optional @::signal-detail@
    -> GClosure b
    -- ^ /@closure@/: the closure to connect.
    -> Bool
    -- ^ /@after@/: whether the handler should be called before or after the
    --  default handler of the signal.
    -> m ()
signalGroupConnectClosure :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSignalGroup a) =>
a -> Text -> GClosure b -> Bool -> m ()
signalGroupConnectClosure a
self Text
detailedSignal GClosure b
closure Bool
after = 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
    Ptr SignalGroup
self' <- a -> IO (Ptr SignalGroup)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
detailedSignal' <- Text -> IO CString
textToCString Text
detailedSignal
    Ptr (GClosure ())
closure' <- GClosure b -> IO (Ptr (GClosure ()))
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr GClosure b
closure
    let after' :: CInt
after' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
after
    Ptr SignalGroup -> CString -> Ptr (GClosure ()) -> CInt -> IO ()
g_signal_group_connect_closure Ptr SignalGroup
self' CString
detailedSignal' Ptr (GClosure ())
closure' CInt
after'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    GClosure b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GClosure b
closure
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
detailedSignal'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SignalGroupConnectClosureMethodInfo
instance (signature ~ (T.Text -> GClosure b -> Bool -> m ()), MonadIO m, IsSignalGroup a) => O.OverloadedMethod SignalGroupConnectClosureMethodInfo a signature where
    overloadedMethod = signalGroupConnectClosure

instance O.OverloadedMethodInfo SignalGroupConnectClosureMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Objects.SignalGroup.signalGroupConnectClosure",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.30/docs/GI-GObject-Objects-SignalGroup.html#v:signalGroupConnectClosure"
        })


#endif

-- method SignalGroup::connect_data
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "SignalGroup" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GSignalGroup" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "detailed_signal"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a string of the form \"signal-name::detail\""
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "c_handler"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Callback" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GCallback to connect"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeNotified
--           , argClosure = 3
--           , argDestroy = 4
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the data to pass to @c_handler calls"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "notify"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "ClosureNotify" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "function to be called when disposing of @self"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeNotified
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "ConnectFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the flags used to create the signal connection"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_signal_group_connect_data" g_signal_group_connect_data :: 
    Ptr SignalGroup ->                      -- self : TInterface (Name {namespace = "GObject", name = "SignalGroup"})
    CString ->                              -- detailed_signal : TBasicType TUTF8
    FunPtr GObject.Callbacks.C_Callback ->  -- c_handler : TInterface (Name {namespace = "GObject", name = "Callback"})
    Ptr () ->                               -- data : TBasicType TPtr
    FunPtr GObject.Callbacks.C_ClosureNotify -> -- notify : TInterface (Name {namespace = "GObject", name = "ClosureNotify"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "GObject", name = "ConnectFlags"})
    IO ()

-- | Connects /@cHandler@/ to the signal /@detailedSignal@/
-- on the target instance of /@self@/.
-- 
-- You cannot connect a signal handler after [SignalGroup:target]("GI.GObject.Objects.SignalGroup#g:attr:target") has been set.
-- 
-- /Since: 2.72/
signalGroupConnectData ::
    (B.CallStack.HasCallStack, MonadIO m, IsSignalGroup a) =>
    a
    -- ^ /@self@/: a t'GI.GObject.Objects.SignalGroup.SignalGroup'
    -> T.Text
    -- ^ /@detailedSignal@/: a string of the form \"signal-name[detail](#g:signal:detail)\"
    -> GObject.Callbacks.Callback
    -- ^ /@cHandler@/: the t'GI.GObject.Callbacks.Callback' to connect
    -> [GObject.Flags.ConnectFlags]
    -- ^ /@flags@/: the flags used to create the signal connection
    -> m ()
signalGroupConnectData :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSignalGroup a) =>
a -> Text -> IO () -> [ConnectFlags] -> m ()
signalGroupConnectData a
self Text
detailedSignal IO ()
cHandler [ConnectFlags]
flags = 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
    Ptr SignalGroup
self' <- a -> IO (Ptr SignalGroup)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
detailedSignal' <- Text -> IO CString
textToCString Text
detailedSignal
    FunPtr (IO ())
cHandler' <- IO () -> IO (FunPtr (IO ()))
GObject.Callbacks.mk_Callback (Maybe (Ptr (FunPtr (IO ()))) -> IO () -> IO ()
GObject.Callbacks.wrap_Callback Maybe (Ptr (FunPtr (IO ())))
forall a. Maybe a
Nothing IO ()
cHandler)
    let flags' :: CUInt
flags' = [ConnectFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ConnectFlags]
flags
    let data_ :: Ptr ()
data_ = FunPtr (IO ()) -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr (IO ())
cHandler'
    let notify :: FunPtr (Ptr a -> Ptr b -> IO ())
notify = FunPtr (Ptr a -> Ptr b -> IO ())
forall a b. FunPtr (Ptr a -> Ptr b -> IO ())
SP.safeFreeFunPtrPtr'
    Ptr SignalGroup
-> CString
-> FunPtr (IO ())
-> Ptr ()
-> FunPtr C_ClosureNotify
-> CUInt
-> IO ()
g_signal_group_connect_data Ptr SignalGroup
self' CString
detailedSignal' FunPtr (IO ())
cHandler' Ptr ()
data_ FunPtr C_ClosureNotify
forall a b. FunPtr (Ptr a -> Ptr b -> IO ())
notify CUInt
flags'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
detailedSignal'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SignalGroupConnectDataMethodInfo
instance (signature ~ (T.Text -> GObject.Callbacks.Callback -> [GObject.Flags.ConnectFlags] -> m ()), MonadIO m, IsSignalGroup a) => O.OverloadedMethod SignalGroupConnectDataMethodInfo a signature where
    overloadedMethod = signalGroupConnectData

instance O.OverloadedMethodInfo SignalGroupConnectDataMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Objects.SignalGroup.signalGroupConnectData",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.30/docs/GI-GObject-Objects-SignalGroup.html#v:signalGroupConnectData"
        })


#endif

-- method SignalGroup::connect_swapped
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "SignalGroup" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GSignalGroup" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "detailed_signal"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a string of the form \"signal-name::detail\""
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "c_handler"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Callback" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GCallback to connect"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 3
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the data to pass to @c_handler calls"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_signal_group_connect_swapped" g_signal_group_connect_swapped :: 
    Ptr SignalGroup ->                      -- self : TInterface (Name {namespace = "GObject", name = "SignalGroup"})
    CString ->                              -- detailed_signal : TBasicType TUTF8
    FunPtr GObject.Callbacks.C_Callback ->  -- c_handler : TInterface (Name {namespace = "GObject", name = "Callback"})
    Ptr () ->                               -- data : TBasicType TPtr
    IO ()

-- | Connects /@cHandler@/ to the signal /@detailedSignal@/
-- on the target instance of /@self@/.
-- 
-- The instance on which the signal is emitted and /@data@/
-- will be swapped when calling /@cHandler@/.
-- 
-- You cannot connect a signal handler after [SignalGroup:target]("GI.GObject.Objects.SignalGroup#g:attr:target") has been set.
-- 
-- /Since: 2.72/
signalGroupConnectSwapped ::
    (B.CallStack.HasCallStack, MonadIO m, IsSignalGroup a) =>
    a
    -- ^ /@self@/: a t'GI.GObject.Objects.SignalGroup.SignalGroup'
    -> T.Text
    -- ^ /@detailedSignal@/: a string of the form \"signal-name[detail](#g:signal:detail)\"
    -> GObject.Callbacks.Callback
    -- ^ /@cHandler@/: the t'GI.GObject.Callbacks.Callback' to connect
    -> m ()
signalGroupConnectSwapped :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSignalGroup a) =>
a -> Text -> IO () -> m ()
signalGroupConnectSwapped a
self Text
detailedSignal IO ()
cHandler = 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
    Ptr SignalGroup
self' <- a -> IO (Ptr SignalGroup)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
detailedSignal' <- Text -> IO CString
textToCString Text
detailedSignal
    Ptr (FunPtr (IO ()))
ptrcHandler <- IO (Ptr (FunPtr (IO ())))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GObject.Callbacks.C_Callback))
    FunPtr (IO ())
cHandler' <- IO () -> IO (FunPtr (IO ()))
GObject.Callbacks.mk_Callback (Maybe (Ptr (FunPtr (IO ()))) -> IO () -> IO ()
GObject.Callbacks.wrap_Callback (Ptr (FunPtr (IO ())) -> Maybe (Ptr (FunPtr (IO ())))
forall a. a -> Maybe a
Just Ptr (FunPtr (IO ()))
ptrcHandler) IO ()
cHandler)
    Ptr (FunPtr (IO ())) -> FunPtr (IO ()) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr (IO ()))
ptrcHandler FunPtr (IO ())
cHandler'
    let data_ :: Ptr a
data_ = Ptr a
forall a. Ptr a
nullPtr
    Ptr SignalGroup -> CString -> FunPtr (IO ()) -> Ptr () -> IO ()
g_signal_group_connect_swapped Ptr SignalGroup
self' CString
detailedSignal' FunPtr (IO ())
cHandler' Ptr ()
forall a. Ptr a
data_
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
detailedSignal'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SignalGroupConnectSwappedMethodInfo
instance (signature ~ (T.Text -> GObject.Callbacks.Callback -> m ()), MonadIO m, IsSignalGroup a) => O.OverloadedMethod SignalGroupConnectSwappedMethodInfo a signature where
    overloadedMethod = signalGroupConnectSwapped

instance O.OverloadedMethodInfo SignalGroupConnectSwappedMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Objects.SignalGroup.signalGroupConnectSwapped",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.30/docs/GI-GObject-Objects-SignalGroup.html#v:signalGroupConnectSwapped"
        })


#endif

-- method SignalGroup::dup_target
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "SignalGroup" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GSignalGroup" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GObject" , name = "Object" })
-- throws : False
-- Skip return : False

foreign import ccall "g_signal_group_dup_target" g_signal_group_dup_target :: 
    Ptr SignalGroup ->                      -- self : TInterface (Name {namespace = "GObject", name = "SignalGroup"})
    IO (Ptr GObject.Object.Object)

-- | Gets the target instance used when connecting signals.
-- 
-- /Since: 2.72/
signalGroupDupTarget ::
    (B.CallStack.HasCallStack, MonadIO m, IsSignalGroup a) =>
    a
    -- ^ /@self@/: the t'GI.GObject.Objects.SignalGroup.SignalGroup'
    -> m (Maybe GObject.Object.Object)
    -- ^ __Returns:__ The target instance
signalGroupDupTarget :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSignalGroup a) =>
a -> m (Maybe Object)
signalGroupDupTarget a
self = IO (Maybe Object) -> m (Maybe Object)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ do
    Ptr SignalGroup
self' <- a -> IO (Ptr SignalGroup)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Object
result <- Ptr SignalGroup -> IO (Ptr Object)
g_signal_group_dup_target Ptr SignalGroup
self'
    Maybe Object
maybeResult <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Object
result ((Ptr Object -> IO Object) -> IO (Maybe Object))
-> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \Ptr Object
result' -> do
        Object
result'' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
result'
        Object -> IO Object
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Object -> IO (Maybe Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Object
maybeResult

#if defined(ENABLE_OVERLOADING)
data SignalGroupDupTargetMethodInfo
instance (signature ~ (m (Maybe GObject.Object.Object)), MonadIO m, IsSignalGroup a) => O.OverloadedMethod SignalGroupDupTargetMethodInfo a signature where
    overloadedMethod = signalGroupDupTarget

instance O.OverloadedMethodInfo SignalGroupDupTargetMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Objects.SignalGroup.signalGroupDupTarget",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.30/docs/GI-GObject-Objects-SignalGroup.html#v:signalGroupDupTarget"
        })


#endif

-- method SignalGroup::set_target
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "SignalGroup" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GSignalGroup." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "target"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The target instance used\n    when connecting signals."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_signal_group_set_target" g_signal_group_set_target :: 
    Ptr SignalGroup ->                      -- self : TInterface (Name {namespace = "GObject", name = "SignalGroup"})
    Ptr GObject.Object.Object ->            -- target : TInterface (Name {namespace = "GObject", name = "Object"})
    IO ()

-- | Sets the target instance used when connecting signals. Any signal
-- that has been registered with @/g_signal_group_connect_object()/@ or
-- similar functions will be connected to this object.
-- 
-- If the target instance was previously set, signals will be
-- disconnected from that object prior to connecting to /@target@/.
-- 
-- /Since: 2.72/
signalGroupSetTarget ::
    (B.CallStack.HasCallStack, MonadIO m, IsSignalGroup a, GObject.Object.IsObject b) =>
    a
    -- ^ /@self@/: the t'GI.GObject.Objects.SignalGroup.SignalGroup'.
    -> Maybe (b)
    -- ^ /@target@/: The target instance used
    --     when connecting signals.
    -> m ()
signalGroupSetTarget :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSignalGroup a, IsObject b) =>
a -> Maybe b -> m ()
signalGroupSetTarget a
self Maybe b
target = 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
    Ptr SignalGroup
self' <- a -> IO (Ptr SignalGroup)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Object
maybeTarget <- case Maybe b
target of
        Maybe b
Nothing -> Ptr Object -> IO (Ptr Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
        Just b
jTarget -> do
            Ptr Object
jTarget' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jTarget
            Ptr Object -> IO (Ptr Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jTarget'
    Ptr SignalGroup -> Ptr Object -> IO ()
g_signal_group_set_target Ptr SignalGroup
self' Ptr Object
maybeTarget
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
target b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SignalGroupSetTargetMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsSignalGroup a, GObject.Object.IsObject b) => O.OverloadedMethod SignalGroupSetTargetMethodInfo a signature where
    overloadedMethod = signalGroupSetTarget

instance O.OverloadedMethodInfo SignalGroupSetTargetMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Objects.SignalGroup.signalGroupSetTarget",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.30/docs/GI-GObject-Objects-SignalGroup.html#v:signalGroupSetTarget"
        })


#endif

-- method SignalGroup::unblock
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "SignalGroup" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GSignalGroup" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_signal_group_unblock" g_signal_group_unblock :: 
    Ptr SignalGroup ->                      -- self : TInterface (Name {namespace = "GObject", name = "SignalGroup"})
    IO ()

-- | Unblocks all signal handlers managed by /@self@/ so they will be
-- called again during any signal emissions unless it is blocked
-- again. Must be unblocked exactly the same number of times it
-- has been blocked to become active again.
-- 
-- /Since: 2.72/
signalGroupUnblock ::
    (B.CallStack.HasCallStack, MonadIO m, IsSignalGroup a) =>
    a
    -- ^ /@self@/: the t'GI.GObject.Objects.SignalGroup.SignalGroup'
    -> m ()
signalGroupUnblock :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSignalGroup a) =>
a -> m ()
signalGroupUnblock a
self = 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
    Ptr SignalGroup
self' <- a -> IO (Ptr SignalGroup)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr SignalGroup -> IO ()
g_signal_group_unblock Ptr SignalGroup
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SignalGroupUnblockMethodInfo
instance (signature ~ (m ()), MonadIO m, IsSignalGroup a) => O.OverloadedMethod SignalGroupUnblockMethodInfo a signature where
    overloadedMethod = signalGroupUnblock

instance O.OverloadedMethodInfo SignalGroupUnblockMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GObject.Objects.SignalGroup.signalGroupUnblock",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.30/docs/GI-GObject-Objects-SignalGroup.html#v:signalGroupUnblock"
        })


#endif