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


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- @GSignalGroup@ manages a collection of signals on a @GObject@.
-- 
-- @GSignalGroup@ simplifies the process of connecting  many signals to a @GObject@
-- 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 @GSignalGroup: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 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.Callbacks as GLib.Callbacks
import qualified GI.GObject.Callbacks as GObject.Callbacks
import {-# SOURCE #-} qualified GI.GObject.Flags as GObject.Flags
import {-# SOURCE #-} qualified GI.GObject.Interfaces.TypePlugin as GObject.TypePlugin
import {-# SOURCE #-} qualified GI.GObject.Objects.Binding as GObject.Binding
import {-# SOURCE #-} qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.GObject.Structs.InterfaceInfo as GObject.InterfaceInfo
import {-# SOURCE #-} qualified GI.GObject.Structs.Parameter as GObject.Parameter
import {-# SOURCE #-} qualified GI.GObject.Structs.TypeClass as GObject.TypeClass
import {-# SOURCE #-} qualified GI.GObject.Structs.TypeInfo as GObject.TypeInfo
import {-# SOURCE #-} qualified GI.GObject.Structs.TypeInterface as GObject.TypeInterface
import {-# SOURCE #-} qualified GI.GObject.Structs.TypeValueTable as GObject.TypeValueTable

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

#endif

-- | 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 t'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 t'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 t'SignalGroup' to and from t'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 <- 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 /= FP.nullPtr
        then P.Just <$> B.ManagedPtr.newObject SignalGroup ptr
        else return 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
    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_
    B.ManagedPtr.withNewObject gi'selfPtr $ \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
    wrapped'' <- C_SignalGroupBindCallback -> IO (FunPtr C_SignalGroupBindCallback)
mk_SignalGroupBindCallback C_SignalGroupBindCallback
wrapped'
    connectSignalFunPtr obj "bind" wrapped'' SignalConnectBefore 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
    wrapped'' <- C_SignalGroupBindCallback -> IO (FunPtr C_SignalGroupBindCallback)
mk_SignalGroupBindCallback C_SignalGroupBindCallback
wrapped'
    connectSignalFunPtr obj "bind" wrapped'' SignalConnectAfter 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.31/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 o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject 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
    wrapped'' <- C_SignalGroupUnbindCallback
-> IO (FunPtr C_SignalGroupUnbindCallback)
mk_SignalGroupUnbindCallback C_SignalGroupUnbindCallback
wrapped'
    connectSignalFunPtr obj "unbind" wrapped'' SignalConnectBefore 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
    wrapped'' <- C_SignalGroupUnbindCallback
-> IO (FunPtr C_SignalGroupUnbindCallback)
mk_SignalGroupUnbindCallback C_SignalGroupUnbindCallback
wrapped'
    connectSignalFunPtr obj "unbind" wrapped'' SignalConnectAfter 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.31/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 t'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
    attrPut = undefined
    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.31/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 t'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
    attrPut = 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.31/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
--           , argCType = Just "GType"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GType of the target instance."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = 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
    result <- CGType -> IO (Ptr SignalGroup)
g_signal_group_new CGType
targetType'
    checkUnexpectedReturnNULL "signalGroupNew" result
    result' <- (wrapObject SignalGroup) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SignalGroup::block
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "SignalGroup" }
--           , argCType = Just "GSignalGroup*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GSignalGroup" , 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 "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
    self' <- a -> IO (Ptr SignalGroup)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    g_signal_group_block self'
    touchManagedPtr self
    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.31/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" }
--           , argCType = Just "GSignalGroup*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GSignalGroup" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "detailed_signal"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , 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
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "closure"
--           , argType = TGClosure Nothing
--           , argCType = Just "GClosure*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the closure to connect."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "after"
--           , argType = TBasicType TBoolean
--           , argCType = Just "gboolean"
--           , 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
--           , argCallbackUserData = 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
    self' <- a -> IO (Ptr SignalGroup)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    detailedSignal' <- textToCString detailedSignal
    closure' <- unsafeManagedPtrCastPtr closure
    let 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
    g_signal_group_connect_closure self' detailedSignal' closure' after'
    touchManagedPtr self
    touchManagedPtr closure
    freeMem detailedSignal'
    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.31/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" }
--           , argCType = Just "GSignalGroup*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GSignalGroup" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "detailed_signal"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , 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
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "c_handler"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Callback" }
--           , argCType = Just "GCallback"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GCallback to connect"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeNotified
--           , argClosure = 3
--           , argDestroy = 4
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , argCType = Just "gpointer"
--           , 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
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "notify"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "ClosureNotify" }
--           , argCType = Just "GClosureNotify"
--           , 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
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "ConnectFlags" }
--           , argCType = Just "GConnectFlags"
--           , 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
--           , argCallbackUserData = 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
    self' <- a -> IO (Ptr SignalGroup)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    detailedSignal' <- textToCString detailedSignal
    cHandler' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback Nothing cHandler)
    let flags' = [ConnectFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ConnectFlags]
flags
    let data_ = FunPtr (IO ()) -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr (IO ())
cHandler'
    let notify = FunPtr (Ptr a -> Ptr b -> IO ())
forall a b. FunPtr (Ptr a -> Ptr b -> IO ())
SP.safeFreeFunPtrPtr'
    g_signal_group_connect_data self' detailedSignal' cHandler' data_ notify flags'
    touchManagedPtr self
    freeMem detailedSignal'
    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.31/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" }
--           , argCType = Just "GSignalGroup*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GSignalGroup" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "detailed_signal"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , 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
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "c_handler"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Callback" }
--           , argCType = Just "GCallback"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GCallback to connect"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 3
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , argCType = Just "gpointer"
--           , 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
--           , argCallbackUserData = 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
    self' <- a -> IO (Ptr SignalGroup)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    detailedSignal' <- textToCString detailedSignal
    ptrcHandler <- callocMem :: IO (Ptr (FunPtr GObject.Callbacks.C_Callback))
    cHandler' <- GObject.Callbacks.mk_Callback (GObject.Callbacks.wrap_Callback (Just ptrcHandler) cHandler)
    poke ptrcHandler cHandler'
    let data_ = Ptr a
forall a. Ptr a
nullPtr
    g_signal_group_connect_swapped self' detailedSignal' cHandler' data_
    touchManagedPtr self
    freeMem detailedSignal'
    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.31/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" }
--           , argCType = Just "GSignalGroup*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GSignalGroup" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = 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
    self' <- a -> IO (Ptr SignalGroup)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    result <- g_signal_group_dup_target self'
    maybeResult <- convertIfNonNull result $ \Ptr Object
result' -> do
        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'
        return result''
    touchManagedPtr self
    return 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.31/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" }
--           , argCType = Just "GSignalGroup*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GSignalGroup." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "target"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Object" }
--           , argCType = Just "gpointer"
--           , 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
--           , argCallbackUserData = 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
    self' <- a -> IO (Ptr SignalGroup)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    maybeTarget <- case 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
FP.nullPtr
        Just b
jTarget -> do
            jTarget' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jTarget
            return jTarget'
    g_signal_group_set_target self' maybeTarget
    touchManagedPtr self
    whenJust target touchManagedPtr
    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.31/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" }
--           , argCType = Just "GSignalGroup*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GSignalGroup" , 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 "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
    self' <- a -> IO (Ptr SignalGroup)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    g_signal_group_unblock self'
    touchManagedPtr self
    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.31/docs/GI-GObject-Objects-SignalGroup.html#v:signalGroupUnblock"
        })


#endif