{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Objects.SignalListItemFactory
(
SignalListItemFactory(..) ,
IsSignalListItemFactory ,
toSignalListItemFactory ,
#if defined(ENABLE_OVERLOADING)
ResolveSignalListItemFactoryMethod ,
#endif
signalListItemFactoryNew ,
SignalListItemFactoryBindCallback ,
#if defined(ENABLE_OVERLOADING)
SignalListItemFactoryBindSignalInfo ,
#endif
afterSignalListItemFactoryBind ,
onSignalListItemFactoryBind ,
SignalListItemFactorySetupCallback ,
#if defined(ENABLE_OVERLOADING)
SignalListItemFactorySetupSignalInfo ,
#endif
afterSignalListItemFactorySetup ,
onSignalListItemFactorySetup ,
SignalListItemFactoryTeardownCallback ,
#if defined(ENABLE_OVERLOADING)
SignalListItemFactoryTeardownSignalInfo ,
#endif
afterSignalListItemFactoryTeardown ,
onSignalListItemFactoryTeardown ,
SignalListItemFactoryUnbindCallback ,
#if defined(ENABLE_OVERLOADING)
SignalListItemFactoryUnbindSignalInfo ,
#endif
afterSignalListItemFactoryUnbind ,
onSignalListItemFactoryUnbind ,
) 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.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.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gtk.Objects.ListItemFactory as Gtk.ListItemFactory
newtype SignalListItemFactory = SignalListItemFactory (SP.ManagedPtr SignalListItemFactory)
deriving (SignalListItemFactory -> SignalListItemFactory -> Bool
(SignalListItemFactory -> SignalListItemFactory -> Bool)
-> (SignalListItemFactory -> SignalListItemFactory -> Bool)
-> Eq SignalListItemFactory
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SignalListItemFactory -> SignalListItemFactory -> Bool
== :: SignalListItemFactory -> SignalListItemFactory -> Bool
$c/= :: SignalListItemFactory -> SignalListItemFactory -> Bool
/= :: SignalListItemFactory -> SignalListItemFactory -> Bool
Eq)
instance SP.ManagedPtrNewtype SignalListItemFactory where
toManagedPtr :: SignalListItemFactory -> ManagedPtr SignalListItemFactory
toManagedPtr (SignalListItemFactory ManagedPtr SignalListItemFactory
p) = ManagedPtr SignalListItemFactory
p
foreign import ccall "gtk_signal_list_item_factory_get_type"
c_gtk_signal_list_item_factory_get_type :: IO B.Types.GType
instance B.Types.TypedObject SignalListItemFactory where
glibType :: IO GType
glibType = IO GType
c_gtk_signal_list_item_factory_get_type
instance B.Types.GObject SignalListItemFactory
class (SP.GObject o, O.IsDescendantOf SignalListItemFactory o) => IsSignalListItemFactory o
instance (SP.GObject o, O.IsDescendantOf SignalListItemFactory o) => IsSignalListItemFactory o
instance O.HasParentTypes SignalListItemFactory
type instance O.ParentTypes SignalListItemFactory = '[Gtk.ListItemFactory.ListItemFactory, GObject.Object.Object]
toSignalListItemFactory :: (MIO.MonadIO m, IsSignalListItemFactory o) => o -> m SignalListItemFactory
toSignalListItemFactory :: forall (m :: * -> *) o.
(MonadIO m, IsSignalListItemFactory o) =>
o -> m SignalListItemFactory
toSignalListItemFactory = IO SignalListItemFactory -> m SignalListItemFactory
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO SignalListItemFactory -> m SignalListItemFactory)
-> (o -> IO SignalListItemFactory) -> o -> m SignalListItemFactory
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr SignalListItemFactory -> SignalListItemFactory)
-> o -> IO SignalListItemFactory
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr SignalListItemFactory -> SignalListItemFactory
SignalListItemFactory
instance B.GValue.IsGValue (Maybe SignalListItemFactory) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_signal_list_item_factory_get_type
gvalueSet_ :: Ptr GValue -> Maybe SignalListItemFactory -> IO ()
gvalueSet_ Ptr GValue
gv Maybe SignalListItemFactory
P.Nothing = Ptr GValue -> Ptr SignalListItemFactory -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr SignalListItemFactory
forall a. Ptr a
FP.nullPtr :: FP.Ptr SignalListItemFactory)
gvalueSet_ Ptr GValue
gv (P.Just SignalListItemFactory
obj) = SignalListItemFactory
-> (Ptr SignalListItemFactory -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr SignalListItemFactory
obj (Ptr GValue -> Ptr SignalListItemFactory -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe SignalListItemFactory)
gvalueGet_ Ptr GValue
gv = do
Ptr SignalListItemFactory
ptr <- Ptr GValue -> IO (Ptr SignalListItemFactory)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr SignalListItemFactory)
if Ptr SignalListItemFactory
ptr Ptr SignalListItemFactory -> Ptr SignalListItemFactory -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr SignalListItemFactory
forall a. Ptr a
FP.nullPtr
then SignalListItemFactory -> Maybe SignalListItemFactory
forall a. a -> Maybe a
P.Just (SignalListItemFactory -> Maybe SignalListItemFactory)
-> IO SignalListItemFactory -> IO (Maybe SignalListItemFactory)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr SignalListItemFactory -> SignalListItemFactory)
-> Ptr SignalListItemFactory -> IO SignalListItemFactory
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr SignalListItemFactory -> SignalListItemFactory
SignalListItemFactory Ptr SignalListItemFactory
ptr
else Maybe SignalListItemFactory -> IO (Maybe SignalListItemFactory)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SignalListItemFactory
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveSignalListItemFactoryMethod (t :: Symbol) (o :: *) :: * where
ResolveSignalListItemFactoryMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveSignalListItemFactoryMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveSignalListItemFactoryMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveSignalListItemFactoryMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveSignalListItemFactoryMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveSignalListItemFactoryMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveSignalListItemFactoryMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveSignalListItemFactoryMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveSignalListItemFactoryMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveSignalListItemFactoryMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveSignalListItemFactoryMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveSignalListItemFactoryMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveSignalListItemFactoryMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveSignalListItemFactoryMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveSignalListItemFactoryMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveSignalListItemFactoryMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveSignalListItemFactoryMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveSignalListItemFactoryMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveSignalListItemFactoryMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveSignalListItemFactoryMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveSignalListItemFactoryMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveSignalListItemFactoryMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveSignalListItemFactoryMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveSignalListItemFactoryMethod t SignalListItemFactory, O.OverloadedMethod info SignalListItemFactory p) => OL.IsLabel t (SignalListItemFactory -> 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 ~ ResolveSignalListItemFactoryMethod t SignalListItemFactory, O.OverloadedMethod info SignalListItemFactory p, R.HasField t SignalListItemFactory p) => R.HasField t SignalListItemFactory p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveSignalListItemFactoryMethod t SignalListItemFactory, O.OverloadedMethodInfo info SignalListItemFactory) => OL.IsLabel t (O.MethodProxy info SignalListItemFactory) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
type SignalListItemFactoryBindCallback =
GObject.Object.Object
-> IO ()
type C_SignalListItemFactoryBindCallback =
Ptr SignalListItemFactory ->
Ptr GObject.Object.Object ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_SignalListItemFactoryBindCallback :: C_SignalListItemFactoryBindCallback -> IO (FunPtr C_SignalListItemFactoryBindCallback)
wrap_SignalListItemFactoryBindCallback ::
GObject a => (a -> SignalListItemFactoryBindCallback) ->
C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryBindCallback :: forall a.
GObject a =>
(a -> SignalListItemFactoryBindCallback)
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryBindCallback a -> SignalListItemFactoryBindCallback
gi'cb Ptr SignalListItemFactory
gi'selfPtr Ptr Object
object Ptr ()
_ = do
Object
object' <- ((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
object
Ptr SignalListItemFactory
-> (SignalListItemFactory -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr SignalListItemFactory
gi'selfPtr ((SignalListItemFactory -> IO ()) -> IO ())
-> (SignalListItemFactory -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SignalListItemFactory
gi'self -> a -> SignalListItemFactoryBindCallback
gi'cb (SignalListItemFactory -> a
forall a b. Coercible a b => a -> b
Coerce.coerce SignalListItemFactory
gi'self) Object
object'
onSignalListItemFactoryBind :: (IsSignalListItemFactory a, MonadIO m) => a -> ((?self :: a) => SignalListItemFactoryBindCallback) -> m SignalHandlerId
onSignalListItemFactoryBind :: forall a (m :: * -> *).
(IsSignalListItemFactory a, MonadIO m) =>
a
-> ((?self::a) => SignalListItemFactoryBindCallback)
-> m SignalHandlerId
onSignalListItemFactoryBind a
obj (?self::a) => SignalListItemFactoryBindCallback
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 -> SignalListItemFactoryBindCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SignalListItemFactoryBindCallback
SignalListItemFactoryBindCallback
cb
let wrapped' :: C_SignalListItemFactoryBindCallback
wrapped' = (a -> SignalListItemFactoryBindCallback)
-> C_SignalListItemFactoryBindCallback
forall a.
GObject a =>
(a -> SignalListItemFactoryBindCallback)
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryBindCallback a -> SignalListItemFactoryBindCallback
wrapped
FunPtr C_SignalListItemFactoryBindCallback
wrapped'' <- C_SignalListItemFactoryBindCallback
-> IO (FunPtr C_SignalListItemFactoryBindCallback)
mk_SignalListItemFactoryBindCallback C_SignalListItemFactoryBindCallback
wrapped'
a
-> Text
-> FunPtr C_SignalListItemFactoryBindCallback
-> 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_SignalListItemFactoryBindCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterSignalListItemFactoryBind :: (IsSignalListItemFactory a, MonadIO m) => a -> ((?self :: a) => SignalListItemFactoryBindCallback) -> m SignalHandlerId
afterSignalListItemFactoryBind :: forall a (m :: * -> *).
(IsSignalListItemFactory a, MonadIO m) =>
a
-> ((?self::a) => SignalListItemFactoryBindCallback)
-> m SignalHandlerId
afterSignalListItemFactoryBind a
obj (?self::a) => SignalListItemFactoryBindCallback
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 -> SignalListItemFactoryBindCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SignalListItemFactoryBindCallback
SignalListItemFactoryBindCallback
cb
let wrapped' :: C_SignalListItemFactoryBindCallback
wrapped' = (a -> SignalListItemFactoryBindCallback)
-> C_SignalListItemFactoryBindCallback
forall a.
GObject a =>
(a -> SignalListItemFactoryBindCallback)
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryBindCallback a -> SignalListItemFactoryBindCallback
wrapped
FunPtr C_SignalListItemFactoryBindCallback
wrapped'' <- C_SignalListItemFactoryBindCallback
-> IO (FunPtr C_SignalListItemFactoryBindCallback)
mk_SignalListItemFactoryBindCallback C_SignalListItemFactoryBindCallback
wrapped'
a
-> Text
-> FunPtr C_SignalListItemFactoryBindCallback
-> 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_SignalListItemFactoryBindCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data SignalListItemFactoryBindSignalInfo
instance SignalInfo SignalListItemFactoryBindSignalInfo where
type HaskellCallbackType SignalListItemFactoryBindSignalInfo = SignalListItemFactoryBindCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_SignalListItemFactoryBindCallback cb
cb'' <- mk_SignalListItemFactoryBindCallback cb'
connectSignalFunPtr obj "bind" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.SignalListItemFactory::bind"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-SignalListItemFactory.html#g:signal:bind"})
#endif
type SignalListItemFactorySetupCallback =
GObject.Object.Object
-> IO ()
type C_SignalListItemFactorySetupCallback =
Ptr SignalListItemFactory ->
Ptr GObject.Object.Object ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_SignalListItemFactorySetupCallback :: C_SignalListItemFactorySetupCallback -> IO (FunPtr C_SignalListItemFactorySetupCallback)
wrap_SignalListItemFactorySetupCallback ::
GObject a => (a -> SignalListItemFactorySetupCallback) ->
C_SignalListItemFactorySetupCallback
wrap_SignalListItemFactorySetupCallback :: forall a.
GObject a =>
(a -> SignalListItemFactoryBindCallback)
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactorySetupCallback a -> SignalListItemFactoryBindCallback
gi'cb Ptr SignalListItemFactory
gi'selfPtr Ptr Object
object Ptr ()
_ = do
Object
object' <- ((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
object
Ptr SignalListItemFactory
-> (SignalListItemFactory -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr SignalListItemFactory
gi'selfPtr ((SignalListItemFactory -> IO ()) -> IO ())
-> (SignalListItemFactory -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SignalListItemFactory
gi'self -> a -> SignalListItemFactoryBindCallback
gi'cb (SignalListItemFactory -> a
forall a b. Coercible a b => a -> b
Coerce.coerce SignalListItemFactory
gi'self) Object
object'
onSignalListItemFactorySetup :: (IsSignalListItemFactory a, MonadIO m) => a -> ((?self :: a) => SignalListItemFactorySetupCallback) -> m SignalHandlerId
onSignalListItemFactorySetup :: forall a (m :: * -> *).
(IsSignalListItemFactory a, MonadIO m) =>
a
-> ((?self::a) => SignalListItemFactoryBindCallback)
-> m SignalHandlerId
onSignalListItemFactorySetup a
obj (?self::a) => SignalListItemFactoryBindCallback
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 -> SignalListItemFactoryBindCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SignalListItemFactoryBindCallback
SignalListItemFactoryBindCallback
cb
let wrapped' :: C_SignalListItemFactoryBindCallback
wrapped' = (a -> SignalListItemFactoryBindCallback)
-> C_SignalListItemFactoryBindCallback
forall a.
GObject a =>
(a -> SignalListItemFactoryBindCallback)
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactorySetupCallback a -> SignalListItemFactoryBindCallback
wrapped
FunPtr C_SignalListItemFactoryBindCallback
wrapped'' <- C_SignalListItemFactoryBindCallback
-> IO (FunPtr C_SignalListItemFactoryBindCallback)
mk_SignalListItemFactorySetupCallback C_SignalListItemFactoryBindCallback
wrapped'
a
-> Text
-> FunPtr C_SignalListItemFactoryBindCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"setup" FunPtr C_SignalListItemFactoryBindCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterSignalListItemFactorySetup :: (IsSignalListItemFactory a, MonadIO m) => a -> ((?self :: a) => SignalListItemFactorySetupCallback) -> m SignalHandlerId
afterSignalListItemFactorySetup :: forall a (m :: * -> *).
(IsSignalListItemFactory a, MonadIO m) =>
a
-> ((?self::a) => SignalListItemFactoryBindCallback)
-> m SignalHandlerId
afterSignalListItemFactorySetup a
obj (?self::a) => SignalListItemFactoryBindCallback
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 -> SignalListItemFactoryBindCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SignalListItemFactoryBindCallback
SignalListItemFactoryBindCallback
cb
let wrapped' :: C_SignalListItemFactoryBindCallback
wrapped' = (a -> SignalListItemFactoryBindCallback)
-> C_SignalListItemFactoryBindCallback
forall a.
GObject a =>
(a -> SignalListItemFactoryBindCallback)
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactorySetupCallback a -> SignalListItemFactoryBindCallback
wrapped
FunPtr C_SignalListItemFactoryBindCallback
wrapped'' <- C_SignalListItemFactoryBindCallback
-> IO (FunPtr C_SignalListItemFactoryBindCallback)
mk_SignalListItemFactorySetupCallback C_SignalListItemFactoryBindCallback
wrapped'
a
-> Text
-> FunPtr C_SignalListItemFactoryBindCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"setup" FunPtr C_SignalListItemFactoryBindCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data SignalListItemFactorySetupSignalInfo
instance SignalInfo SignalListItemFactorySetupSignalInfo where
type HaskellCallbackType SignalListItemFactorySetupSignalInfo = SignalListItemFactorySetupCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_SignalListItemFactorySetupCallback cb
cb'' <- mk_SignalListItemFactorySetupCallback cb'
connectSignalFunPtr obj "setup" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.SignalListItemFactory::setup"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-SignalListItemFactory.html#g:signal:setup"})
#endif
type SignalListItemFactoryTeardownCallback =
GObject.Object.Object
-> IO ()
type C_SignalListItemFactoryTeardownCallback =
Ptr SignalListItemFactory ->
Ptr GObject.Object.Object ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_SignalListItemFactoryTeardownCallback :: C_SignalListItemFactoryTeardownCallback -> IO (FunPtr C_SignalListItemFactoryTeardownCallback)
wrap_SignalListItemFactoryTeardownCallback ::
GObject a => (a -> SignalListItemFactoryTeardownCallback) ->
C_SignalListItemFactoryTeardownCallback
wrap_SignalListItemFactoryTeardownCallback :: forall a.
GObject a =>
(a -> SignalListItemFactoryBindCallback)
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryTeardownCallback a -> SignalListItemFactoryBindCallback
gi'cb Ptr SignalListItemFactory
gi'selfPtr Ptr Object
object Ptr ()
_ = do
Object
object' <- ((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
object
Ptr SignalListItemFactory
-> (SignalListItemFactory -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr SignalListItemFactory
gi'selfPtr ((SignalListItemFactory -> IO ()) -> IO ())
-> (SignalListItemFactory -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SignalListItemFactory
gi'self -> a -> SignalListItemFactoryBindCallback
gi'cb (SignalListItemFactory -> a
forall a b. Coercible a b => a -> b
Coerce.coerce SignalListItemFactory
gi'self) Object
object'
onSignalListItemFactoryTeardown :: (IsSignalListItemFactory a, MonadIO m) => a -> ((?self :: a) => SignalListItemFactoryTeardownCallback) -> m SignalHandlerId
onSignalListItemFactoryTeardown :: forall a (m :: * -> *).
(IsSignalListItemFactory a, MonadIO m) =>
a
-> ((?self::a) => SignalListItemFactoryBindCallback)
-> m SignalHandlerId
onSignalListItemFactoryTeardown a
obj (?self::a) => SignalListItemFactoryBindCallback
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 -> SignalListItemFactoryBindCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SignalListItemFactoryBindCallback
SignalListItemFactoryBindCallback
cb
let wrapped' :: C_SignalListItemFactoryBindCallback
wrapped' = (a -> SignalListItemFactoryBindCallback)
-> C_SignalListItemFactoryBindCallback
forall a.
GObject a =>
(a -> SignalListItemFactoryBindCallback)
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryTeardownCallback a -> SignalListItemFactoryBindCallback
wrapped
FunPtr C_SignalListItemFactoryBindCallback
wrapped'' <- C_SignalListItemFactoryBindCallback
-> IO (FunPtr C_SignalListItemFactoryBindCallback)
mk_SignalListItemFactoryTeardownCallback C_SignalListItemFactoryBindCallback
wrapped'
a
-> Text
-> FunPtr C_SignalListItemFactoryBindCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"teardown" FunPtr C_SignalListItemFactoryBindCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterSignalListItemFactoryTeardown :: (IsSignalListItemFactory a, MonadIO m) => a -> ((?self :: a) => SignalListItemFactoryTeardownCallback) -> m SignalHandlerId
afterSignalListItemFactoryTeardown :: forall a (m :: * -> *).
(IsSignalListItemFactory a, MonadIO m) =>
a
-> ((?self::a) => SignalListItemFactoryBindCallback)
-> m SignalHandlerId
afterSignalListItemFactoryTeardown a
obj (?self::a) => SignalListItemFactoryBindCallback
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 -> SignalListItemFactoryBindCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SignalListItemFactoryBindCallback
SignalListItemFactoryBindCallback
cb
let wrapped' :: C_SignalListItemFactoryBindCallback
wrapped' = (a -> SignalListItemFactoryBindCallback)
-> C_SignalListItemFactoryBindCallback
forall a.
GObject a =>
(a -> SignalListItemFactoryBindCallback)
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryTeardownCallback a -> SignalListItemFactoryBindCallback
wrapped
FunPtr C_SignalListItemFactoryBindCallback
wrapped'' <- C_SignalListItemFactoryBindCallback
-> IO (FunPtr C_SignalListItemFactoryBindCallback)
mk_SignalListItemFactoryTeardownCallback C_SignalListItemFactoryBindCallback
wrapped'
a
-> Text
-> FunPtr C_SignalListItemFactoryBindCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"teardown" FunPtr C_SignalListItemFactoryBindCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data SignalListItemFactoryTeardownSignalInfo
instance SignalInfo SignalListItemFactoryTeardownSignalInfo where
type HaskellCallbackType SignalListItemFactoryTeardownSignalInfo = SignalListItemFactoryTeardownCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_SignalListItemFactoryTeardownCallback cb
cb'' <- mk_SignalListItemFactoryTeardownCallback cb'
connectSignalFunPtr obj "teardown" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.SignalListItemFactory::teardown"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-SignalListItemFactory.html#g:signal:teardown"})
#endif
type SignalListItemFactoryUnbindCallback =
GObject.Object.Object
-> IO ()
type C_SignalListItemFactoryUnbindCallback =
Ptr SignalListItemFactory ->
Ptr GObject.Object.Object ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_SignalListItemFactoryUnbindCallback :: C_SignalListItemFactoryUnbindCallback -> IO (FunPtr C_SignalListItemFactoryUnbindCallback)
wrap_SignalListItemFactoryUnbindCallback ::
GObject a => (a -> SignalListItemFactoryUnbindCallback) ->
C_SignalListItemFactoryUnbindCallback
wrap_SignalListItemFactoryUnbindCallback :: forall a.
GObject a =>
(a -> SignalListItemFactoryBindCallback)
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryUnbindCallback a -> SignalListItemFactoryBindCallback
gi'cb Ptr SignalListItemFactory
gi'selfPtr Ptr Object
object Ptr ()
_ = do
Object
object' <- ((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
object
Ptr SignalListItemFactory
-> (SignalListItemFactory -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr SignalListItemFactory
gi'selfPtr ((SignalListItemFactory -> IO ()) -> IO ())
-> (SignalListItemFactory -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SignalListItemFactory
gi'self -> a -> SignalListItemFactoryBindCallback
gi'cb (SignalListItemFactory -> a
forall a b. Coercible a b => a -> b
Coerce.coerce SignalListItemFactory
gi'self) Object
object'
onSignalListItemFactoryUnbind :: (IsSignalListItemFactory a, MonadIO m) => a -> ((?self :: a) => SignalListItemFactoryUnbindCallback) -> m SignalHandlerId
onSignalListItemFactoryUnbind :: forall a (m :: * -> *).
(IsSignalListItemFactory a, MonadIO m) =>
a
-> ((?self::a) => SignalListItemFactoryBindCallback)
-> m SignalHandlerId
onSignalListItemFactoryUnbind a
obj (?self::a) => SignalListItemFactoryBindCallback
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 -> SignalListItemFactoryBindCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SignalListItemFactoryBindCallback
SignalListItemFactoryBindCallback
cb
let wrapped' :: C_SignalListItemFactoryBindCallback
wrapped' = (a -> SignalListItemFactoryBindCallback)
-> C_SignalListItemFactoryBindCallback
forall a.
GObject a =>
(a -> SignalListItemFactoryBindCallback)
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryUnbindCallback a -> SignalListItemFactoryBindCallback
wrapped
FunPtr C_SignalListItemFactoryBindCallback
wrapped'' <- C_SignalListItemFactoryBindCallback
-> IO (FunPtr C_SignalListItemFactoryBindCallback)
mk_SignalListItemFactoryUnbindCallback C_SignalListItemFactoryBindCallback
wrapped'
a
-> Text
-> FunPtr C_SignalListItemFactoryBindCallback
-> 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_SignalListItemFactoryBindCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterSignalListItemFactoryUnbind :: (IsSignalListItemFactory a, MonadIO m) => a -> ((?self :: a) => SignalListItemFactoryUnbindCallback) -> m SignalHandlerId
afterSignalListItemFactoryUnbind :: forall a (m :: * -> *).
(IsSignalListItemFactory a, MonadIO m) =>
a
-> ((?self::a) => SignalListItemFactoryBindCallback)
-> m SignalHandlerId
afterSignalListItemFactoryUnbind a
obj (?self::a) => SignalListItemFactoryBindCallback
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 -> SignalListItemFactoryBindCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SignalListItemFactoryBindCallback
SignalListItemFactoryBindCallback
cb
let wrapped' :: C_SignalListItemFactoryBindCallback
wrapped' = (a -> SignalListItemFactoryBindCallback)
-> C_SignalListItemFactoryBindCallback
forall a.
GObject a =>
(a -> SignalListItemFactoryBindCallback)
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryUnbindCallback a -> SignalListItemFactoryBindCallback
wrapped
FunPtr C_SignalListItemFactoryBindCallback
wrapped'' <- C_SignalListItemFactoryBindCallback
-> IO (FunPtr C_SignalListItemFactoryBindCallback)
mk_SignalListItemFactoryUnbindCallback C_SignalListItemFactoryBindCallback
wrapped'
a
-> Text
-> FunPtr C_SignalListItemFactoryBindCallback
-> 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_SignalListItemFactoryBindCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data SignalListItemFactoryUnbindSignalInfo
instance SignalInfo SignalListItemFactoryUnbindSignalInfo where
type HaskellCallbackType SignalListItemFactoryUnbindSignalInfo = SignalListItemFactoryUnbindCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_SignalListItemFactoryUnbindCallback cb
cb'' <- mk_SignalListItemFactoryUnbindCallback cb'
connectSignalFunPtr obj "unbind" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Objects.SignalListItemFactory::unbind"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-SignalListItemFactory.html#g:signal:unbind"})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList SignalListItemFactory
type instance O.AttributeList SignalListItemFactory = SignalListItemFactoryAttributeList
type SignalListItemFactoryAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList SignalListItemFactory = SignalListItemFactorySignalList
type SignalListItemFactorySignalList = ('[ '("bind", SignalListItemFactoryBindSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("setup", SignalListItemFactorySetupSignalInfo), '("teardown", SignalListItemFactoryTeardownSignalInfo), '("unbind", SignalListItemFactoryUnbindSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gtk_signal_list_item_factory_new" gtk_signal_list_item_factory_new ::
IO (Ptr SignalListItemFactory)
signalListItemFactoryNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m SignalListItemFactory
signalListItemFactoryNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
m SignalListItemFactory
signalListItemFactoryNew = IO SignalListItemFactory -> m SignalListItemFactory
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalListItemFactory -> m SignalListItemFactory)
-> IO SignalListItemFactory -> m SignalListItemFactory
forall a b. (a -> b) -> a -> b
$ do
Ptr SignalListItemFactory
result <- IO (Ptr SignalListItemFactory)
gtk_signal_list_item_factory_new
Text -> Ptr SignalListItemFactory -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"signalListItemFactoryNew" Ptr SignalListItemFactory
result
SignalListItemFactory
result' <- ((ManagedPtr SignalListItemFactory -> SignalListItemFactory)
-> Ptr SignalListItemFactory -> IO SignalListItemFactory
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr SignalListItemFactory -> SignalListItemFactory
SignalListItemFactory) Ptr SignalListItemFactory
result
SignalListItemFactory -> IO SignalListItemFactory
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SignalListItemFactory
result'
#if defined(ENABLE_OVERLOADING)
#endif