{-# LANGUAGE 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 ,
C_SignalListItemFactoryBindCallback ,
SignalListItemFactoryBindCallback ,
#if defined(ENABLE_OVERLOADING)
SignalListItemFactoryBindSignalInfo ,
#endif
afterSignalListItemFactoryBind ,
genClosure_SignalListItemFactoryBind ,
mk_SignalListItemFactoryBindCallback ,
noSignalListItemFactoryBindCallback ,
onSignalListItemFactoryBind ,
wrap_SignalListItemFactoryBindCallback ,
C_SignalListItemFactorySetupCallback ,
SignalListItemFactorySetupCallback ,
#if defined(ENABLE_OVERLOADING)
SignalListItemFactorySetupSignalInfo ,
#endif
afterSignalListItemFactorySetup ,
genClosure_SignalListItemFactorySetup ,
mk_SignalListItemFactorySetupCallback ,
noSignalListItemFactorySetupCallback ,
onSignalListItemFactorySetup ,
wrap_SignalListItemFactorySetupCallback ,
C_SignalListItemFactoryTeardownCallback ,
SignalListItemFactoryTeardownCallback ,
#if defined(ENABLE_OVERLOADING)
SignalListItemFactoryTeardownSignalInfo ,
#endif
afterSignalListItemFactoryTeardown ,
genClosure_SignalListItemFactoryTeardown,
mk_SignalListItemFactoryTeardownCallback,
noSignalListItemFactoryTeardownCallback ,
onSignalListItemFactoryTeardown ,
wrap_SignalListItemFactoryTeardownCallback,
C_SignalListItemFactoryUnbindCallback ,
SignalListItemFactoryUnbindCallback ,
#if defined(ENABLE_OVERLOADING)
SignalListItemFactoryUnbindSignalInfo ,
#endif
afterSignalListItemFactoryUnbind ,
genClosure_SignalListItemFactoryUnbind ,
mk_SignalListItemFactoryUnbindCallback ,
noSignalListItemFactoryUnbindCallback ,
onSignalListItemFactoryUnbind ,
wrap_SignalListItemFactoryUnbindCallback,
) 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.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.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.ListItem as Gtk.ListItem
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
/= :: SignalListItemFactory -> SignalListItemFactory -> Bool
$c/= :: SignalListItemFactory -> SignalListItemFactory -> Bool
== :: SignalListItemFactory -> SignalListItemFactory -> Bool
$c== :: 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 (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 (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 =
Gtk.ListItem.ListItem
-> IO ()
noSignalListItemFactoryBindCallback :: Maybe SignalListItemFactoryBindCallback
noSignalListItemFactoryBindCallback :: Maybe SignalListItemFactoryBindCallback
noSignalListItemFactoryBindCallback = Maybe SignalListItemFactoryBindCallback
forall a. Maybe a
Nothing
type C_SignalListItemFactoryBindCallback =
Ptr () ->
Ptr Gtk.ListItem.ListItem ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_SignalListItemFactoryBindCallback :: C_SignalListItemFactoryBindCallback -> IO (FunPtr C_SignalListItemFactoryBindCallback)
genClosure_SignalListItemFactoryBind :: MonadIO m => SignalListItemFactoryBindCallback -> m (GClosure C_SignalListItemFactoryBindCallback)
genClosure_SignalListItemFactoryBind :: forall (m :: * -> *).
MonadIO m =>
SignalListItemFactoryBindCallback
-> m (GClosure C_SignalListItemFactoryBindCallback)
genClosure_SignalListItemFactoryBind SignalListItemFactoryBindCallback
cb = IO (GClosure C_SignalListItemFactoryBindCallback)
-> m (GClosure C_SignalListItemFactoryBindCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_SignalListItemFactoryBindCallback)
-> m (GClosure C_SignalListItemFactoryBindCallback))
-> IO (GClosure C_SignalListItemFactoryBindCallback)
-> m (GClosure C_SignalListItemFactoryBindCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_SignalListItemFactoryBindCallback
cb' = SignalListItemFactoryBindCallback
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryBindCallback SignalListItemFactoryBindCallback
cb
C_SignalListItemFactoryBindCallback
-> IO (FunPtr C_SignalListItemFactoryBindCallback)
mk_SignalListItemFactoryBindCallback C_SignalListItemFactoryBindCallback
cb' IO (FunPtr C_SignalListItemFactoryBindCallback)
-> (FunPtr C_SignalListItemFactoryBindCallback
-> IO (GClosure C_SignalListItemFactoryBindCallback))
-> IO (GClosure C_SignalListItemFactoryBindCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SignalListItemFactoryBindCallback
-> IO (GClosure C_SignalListItemFactoryBindCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_SignalListItemFactoryBindCallback ::
SignalListItemFactoryBindCallback ->
C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryBindCallback :: SignalListItemFactoryBindCallback
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryBindCallback SignalListItemFactoryBindCallback
_cb Ptr ()
_ Ptr ListItem
listitem Ptr ()
_ = do
ListItem
listitem' <- ((ManagedPtr ListItem -> ListItem) -> Ptr ListItem -> IO ListItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ListItem -> ListItem
Gtk.ListItem.ListItem) Ptr ListItem
listitem
SignalListItemFactoryBindCallback
_cb ListItem
listitem'
onSignalListItemFactoryBind :: (IsSignalListItemFactory a, MonadIO m) => a -> SignalListItemFactoryBindCallback -> m SignalHandlerId
onSignalListItemFactoryBind :: forall a (m :: * -> *).
(IsSignalListItemFactory a, MonadIO m) =>
a -> SignalListItemFactoryBindCallback -> m SignalHandlerId
onSignalListItemFactoryBind a
obj SignalListItemFactoryBindCallback
cb = IO SignalHandlerId -> m SignalHandlerId
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 cb' :: C_SignalListItemFactoryBindCallback
cb' = SignalListItemFactoryBindCallback
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryBindCallback SignalListItemFactoryBindCallback
cb
FunPtr C_SignalListItemFactoryBindCallback
cb'' <- C_SignalListItemFactoryBindCallback
-> IO (FunPtr C_SignalListItemFactoryBindCallback)
mk_SignalListItemFactoryBindCallback C_SignalListItemFactoryBindCallback
cb'
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
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterSignalListItemFactoryBind :: (IsSignalListItemFactory a, MonadIO m) => a -> SignalListItemFactoryBindCallback -> m SignalHandlerId
afterSignalListItemFactoryBind :: forall a (m :: * -> *).
(IsSignalListItemFactory a, MonadIO m) =>
a -> SignalListItemFactoryBindCallback -> m SignalHandlerId
afterSignalListItemFactoryBind a
obj SignalListItemFactoryBindCallback
cb = IO SignalHandlerId -> m SignalHandlerId
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 cb' :: C_SignalListItemFactoryBindCallback
cb' = SignalListItemFactoryBindCallback
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryBindCallback SignalListItemFactoryBindCallback
cb
FunPtr C_SignalListItemFactoryBindCallback
cb'' <- C_SignalListItemFactoryBindCallback
-> IO (FunPtr C_SignalListItemFactoryBindCallback)
mk_SignalListItemFactoryBindCallback C_SignalListItemFactoryBindCallback
cb'
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
cb'' 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
#endif
type SignalListItemFactorySetupCallback =
Gtk.ListItem.ListItem
-> IO ()
noSignalListItemFactorySetupCallback :: Maybe SignalListItemFactorySetupCallback
noSignalListItemFactorySetupCallback :: Maybe SignalListItemFactoryBindCallback
noSignalListItemFactorySetupCallback = Maybe SignalListItemFactoryBindCallback
forall a. Maybe a
Nothing
type C_SignalListItemFactorySetupCallback =
Ptr () ->
Ptr Gtk.ListItem.ListItem ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_SignalListItemFactorySetupCallback :: C_SignalListItemFactorySetupCallback -> IO (FunPtr C_SignalListItemFactorySetupCallback)
genClosure_SignalListItemFactorySetup :: MonadIO m => SignalListItemFactorySetupCallback -> m (GClosure C_SignalListItemFactorySetupCallback)
genClosure_SignalListItemFactorySetup :: forall (m :: * -> *).
MonadIO m =>
SignalListItemFactoryBindCallback
-> m (GClosure C_SignalListItemFactoryBindCallback)
genClosure_SignalListItemFactorySetup SignalListItemFactoryBindCallback
cb = IO (GClosure C_SignalListItemFactoryBindCallback)
-> m (GClosure C_SignalListItemFactoryBindCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_SignalListItemFactoryBindCallback)
-> m (GClosure C_SignalListItemFactoryBindCallback))
-> IO (GClosure C_SignalListItemFactoryBindCallback)
-> m (GClosure C_SignalListItemFactoryBindCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_SignalListItemFactoryBindCallback
cb' = SignalListItemFactoryBindCallback
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactorySetupCallback SignalListItemFactoryBindCallback
cb
C_SignalListItemFactoryBindCallback
-> IO (FunPtr C_SignalListItemFactoryBindCallback)
mk_SignalListItemFactorySetupCallback C_SignalListItemFactoryBindCallback
cb' IO (FunPtr C_SignalListItemFactoryBindCallback)
-> (FunPtr C_SignalListItemFactoryBindCallback
-> IO (GClosure C_SignalListItemFactoryBindCallback))
-> IO (GClosure C_SignalListItemFactoryBindCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SignalListItemFactoryBindCallback
-> IO (GClosure C_SignalListItemFactoryBindCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_SignalListItemFactorySetupCallback ::
SignalListItemFactorySetupCallback ->
C_SignalListItemFactorySetupCallback
wrap_SignalListItemFactorySetupCallback :: SignalListItemFactoryBindCallback
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactorySetupCallback SignalListItemFactoryBindCallback
_cb Ptr ()
_ Ptr ListItem
listitem Ptr ()
_ = do
ListItem
listitem' <- ((ManagedPtr ListItem -> ListItem) -> Ptr ListItem -> IO ListItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ListItem -> ListItem
Gtk.ListItem.ListItem) Ptr ListItem
listitem
SignalListItemFactoryBindCallback
_cb ListItem
listitem'
onSignalListItemFactorySetup :: (IsSignalListItemFactory a, MonadIO m) => a -> SignalListItemFactorySetupCallback -> m SignalHandlerId
onSignalListItemFactorySetup :: forall a (m :: * -> *).
(IsSignalListItemFactory a, MonadIO m) =>
a -> SignalListItemFactoryBindCallback -> m SignalHandlerId
onSignalListItemFactorySetup a
obj SignalListItemFactoryBindCallback
cb = IO SignalHandlerId -> m SignalHandlerId
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 cb' :: C_SignalListItemFactoryBindCallback
cb' = SignalListItemFactoryBindCallback
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactorySetupCallback SignalListItemFactoryBindCallback
cb
FunPtr C_SignalListItemFactoryBindCallback
cb'' <- C_SignalListItemFactoryBindCallback
-> IO (FunPtr C_SignalListItemFactoryBindCallback)
mk_SignalListItemFactorySetupCallback C_SignalListItemFactoryBindCallback
cb'
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
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterSignalListItemFactorySetup :: (IsSignalListItemFactory a, MonadIO m) => a -> SignalListItemFactorySetupCallback -> m SignalHandlerId
afterSignalListItemFactorySetup :: forall a (m :: * -> *).
(IsSignalListItemFactory a, MonadIO m) =>
a -> SignalListItemFactoryBindCallback -> m SignalHandlerId
afterSignalListItemFactorySetup a
obj SignalListItemFactoryBindCallback
cb = IO SignalHandlerId -> m SignalHandlerId
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 cb' :: C_SignalListItemFactoryBindCallback
cb' = SignalListItemFactoryBindCallback
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactorySetupCallback SignalListItemFactoryBindCallback
cb
FunPtr C_SignalListItemFactoryBindCallback
cb'' <- C_SignalListItemFactoryBindCallback
-> IO (FunPtr C_SignalListItemFactoryBindCallback)
mk_SignalListItemFactorySetupCallback C_SignalListItemFactoryBindCallback
cb'
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
cb'' 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
#endif
type SignalListItemFactoryTeardownCallback =
Gtk.ListItem.ListItem
-> IO ()
noSignalListItemFactoryTeardownCallback :: Maybe SignalListItemFactoryTeardownCallback
noSignalListItemFactoryTeardownCallback :: Maybe SignalListItemFactoryBindCallback
noSignalListItemFactoryTeardownCallback = Maybe SignalListItemFactoryBindCallback
forall a. Maybe a
Nothing
type C_SignalListItemFactoryTeardownCallback =
Ptr () ->
Ptr Gtk.ListItem.ListItem ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_SignalListItemFactoryTeardownCallback :: C_SignalListItemFactoryTeardownCallback -> IO (FunPtr C_SignalListItemFactoryTeardownCallback)
genClosure_SignalListItemFactoryTeardown :: MonadIO m => SignalListItemFactoryTeardownCallback -> m (GClosure C_SignalListItemFactoryTeardownCallback)
genClosure_SignalListItemFactoryTeardown :: forall (m :: * -> *).
MonadIO m =>
SignalListItemFactoryBindCallback
-> m (GClosure C_SignalListItemFactoryBindCallback)
genClosure_SignalListItemFactoryTeardown SignalListItemFactoryBindCallback
cb = IO (GClosure C_SignalListItemFactoryBindCallback)
-> m (GClosure C_SignalListItemFactoryBindCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_SignalListItemFactoryBindCallback)
-> m (GClosure C_SignalListItemFactoryBindCallback))
-> IO (GClosure C_SignalListItemFactoryBindCallback)
-> m (GClosure C_SignalListItemFactoryBindCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_SignalListItemFactoryBindCallback
cb' = SignalListItemFactoryBindCallback
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryTeardownCallback SignalListItemFactoryBindCallback
cb
C_SignalListItemFactoryBindCallback
-> IO (FunPtr C_SignalListItemFactoryBindCallback)
mk_SignalListItemFactoryTeardownCallback C_SignalListItemFactoryBindCallback
cb' IO (FunPtr C_SignalListItemFactoryBindCallback)
-> (FunPtr C_SignalListItemFactoryBindCallback
-> IO (GClosure C_SignalListItemFactoryBindCallback))
-> IO (GClosure C_SignalListItemFactoryBindCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SignalListItemFactoryBindCallback
-> IO (GClosure C_SignalListItemFactoryBindCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_SignalListItemFactoryTeardownCallback ::
SignalListItemFactoryTeardownCallback ->
C_SignalListItemFactoryTeardownCallback
wrap_SignalListItemFactoryTeardownCallback :: SignalListItemFactoryBindCallback
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryTeardownCallback SignalListItemFactoryBindCallback
_cb Ptr ()
_ Ptr ListItem
listitem Ptr ()
_ = do
ListItem
listitem' <- ((ManagedPtr ListItem -> ListItem) -> Ptr ListItem -> IO ListItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ListItem -> ListItem
Gtk.ListItem.ListItem) Ptr ListItem
listitem
SignalListItemFactoryBindCallback
_cb ListItem
listitem'
onSignalListItemFactoryTeardown :: (IsSignalListItemFactory a, MonadIO m) => a -> SignalListItemFactoryTeardownCallback -> m SignalHandlerId
onSignalListItemFactoryTeardown :: forall a (m :: * -> *).
(IsSignalListItemFactory a, MonadIO m) =>
a -> SignalListItemFactoryBindCallback -> m SignalHandlerId
onSignalListItemFactoryTeardown a
obj SignalListItemFactoryBindCallback
cb = IO SignalHandlerId -> m SignalHandlerId
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 cb' :: C_SignalListItemFactoryBindCallback
cb' = SignalListItemFactoryBindCallback
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryTeardownCallback SignalListItemFactoryBindCallback
cb
FunPtr C_SignalListItemFactoryBindCallback
cb'' <- C_SignalListItemFactoryBindCallback
-> IO (FunPtr C_SignalListItemFactoryBindCallback)
mk_SignalListItemFactoryTeardownCallback C_SignalListItemFactoryBindCallback
cb'
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
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterSignalListItemFactoryTeardown :: (IsSignalListItemFactory a, MonadIO m) => a -> SignalListItemFactoryTeardownCallback -> m SignalHandlerId
afterSignalListItemFactoryTeardown :: forall a (m :: * -> *).
(IsSignalListItemFactory a, MonadIO m) =>
a -> SignalListItemFactoryBindCallback -> m SignalHandlerId
afterSignalListItemFactoryTeardown a
obj SignalListItemFactoryBindCallback
cb = IO SignalHandlerId -> m SignalHandlerId
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 cb' :: C_SignalListItemFactoryBindCallback
cb' = SignalListItemFactoryBindCallback
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryTeardownCallback SignalListItemFactoryBindCallback
cb
FunPtr C_SignalListItemFactoryBindCallback
cb'' <- C_SignalListItemFactoryBindCallback
-> IO (FunPtr C_SignalListItemFactoryBindCallback)
mk_SignalListItemFactoryTeardownCallback C_SignalListItemFactoryBindCallback
cb'
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
cb'' 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
#endif
type SignalListItemFactoryUnbindCallback =
Gtk.ListItem.ListItem
-> IO ()
noSignalListItemFactoryUnbindCallback :: Maybe SignalListItemFactoryUnbindCallback
noSignalListItemFactoryUnbindCallback :: Maybe SignalListItemFactoryBindCallback
noSignalListItemFactoryUnbindCallback = Maybe SignalListItemFactoryBindCallback
forall a. Maybe a
Nothing
type C_SignalListItemFactoryUnbindCallback =
Ptr () ->
Ptr Gtk.ListItem.ListItem ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_SignalListItemFactoryUnbindCallback :: C_SignalListItemFactoryUnbindCallback -> IO (FunPtr C_SignalListItemFactoryUnbindCallback)
genClosure_SignalListItemFactoryUnbind :: MonadIO m => SignalListItemFactoryUnbindCallback -> m (GClosure C_SignalListItemFactoryUnbindCallback)
genClosure_SignalListItemFactoryUnbind :: forall (m :: * -> *).
MonadIO m =>
SignalListItemFactoryBindCallback
-> m (GClosure C_SignalListItemFactoryBindCallback)
genClosure_SignalListItemFactoryUnbind SignalListItemFactoryBindCallback
cb = IO (GClosure C_SignalListItemFactoryBindCallback)
-> m (GClosure C_SignalListItemFactoryBindCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_SignalListItemFactoryBindCallback)
-> m (GClosure C_SignalListItemFactoryBindCallback))
-> IO (GClosure C_SignalListItemFactoryBindCallback)
-> m (GClosure C_SignalListItemFactoryBindCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_SignalListItemFactoryBindCallback
cb' = SignalListItemFactoryBindCallback
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryUnbindCallback SignalListItemFactoryBindCallback
cb
C_SignalListItemFactoryBindCallback
-> IO (FunPtr C_SignalListItemFactoryBindCallback)
mk_SignalListItemFactoryUnbindCallback C_SignalListItemFactoryBindCallback
cb' IO (FunPtr C_SignalListItemFactoryBindCallback)
-> (FunPtr C_SignalListItemFactoryBindCallback
-> IO (GClosure C_SignalListItemFactoryBindCallback))
-> IO (GClosure C_SignalListItemFactoryBindCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SignalListItemFactoryBindCallback
-> IO (GClosure C_SignalListItemFactoryBindCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_SignalListItemFactoryUnbindCallback ::
SignalListItemFactoryUnbindCallback ->
C_SignalListItemFactoryUnbindCallback
wrap_SignalListItemFactoryUnbindCallback :: SignalListItemFactoryBindCallback
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryUnbindCallback SignalListItemFactoryBindCallback
_cb Ptr ()
_ Ptr ListItem
listitem Ptr ()
_ = do
ListItem
listitem' <- ((ManagedPtr ListItem -> ListItem) -> Ptr ListItem -> IO ListItem
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ListItem -> ListItem
Gtk.ListItem.ListItem) Ptr ListItem
listitem
SignalListItemFactoryBindCallback
_cb ListItem
listitem'
onSignalListItemFactoryUnbind :: (IsSignalListItemFactory a, MonadIO m) => a -> SignalListItemFactoryUnbindCallback -> m SignalHandlerId
onSignalListItemFactoryUnbind :: forall a (m :: * -> *).
(IsSignalListItemFactory a, MonadIO m) =>
a -> SignalListItemFactoryBindCallback -> m SignalHandlerId
onSignalListItemFactoryUnbind a
obj SignalListItemFactoryBindCallback
cb = IO SignalHandlerId -> m SignalHandlerId
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 cb' :: C_SignalListItemFactoryBindCallback
cb' = SignalListItemFactoryBindCallback
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryUnbindCallback SignalListItemFactoryBindCallback
cb
FunPtr C_SignalListItemFactoryBindCallback
cb'' <- C_SignalListItemFactoryBindCallback
-> IO (FunPtr C_SignalListItemFactoryBindCallback)
mk_SignalListItemFactoryUnbindCallback C_SignalListItemFactoryBindCallback
cb'
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
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterSignalListItemFactoryUnbind :: (IsSignalListItemFactory a, MonadIO m) => a -> SignalListItemFactoryUnbindCallback -> m SignalHandlerId
afterSignalListItemFactoryUnbind :: forall a (m :: * -> *).
(IsSignalListItemFactory a, MonadIO m) =>
a -> SignalListItemFactoryBindCallback -> m SignalHandlerId
afterSignalListItemFactoryUnbind a
obj SignalListItemFactoryBindCallback
cb = IO SignalHandlerId -> m SignalHandlerId
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 cb' :: C_SignalListItemFactoryBindCallback
cb' = SignalListItemFactoryBindCallback
-> C_SignalListItemFactoryBindCallback
wrap_SignalListItemFactoryUnbindCallback SignalListItemFactoryBindCallback
cb
FunPtr C_SignalListItemFactoryBindCallback
cb'' <- C_SignalListItemFactoryBindCallback
-> IO (FunPtr C_SignalListItemFactoryBindCallback)
mk_SignalListItemFactoryUnbindCallback C_SignalListItemFactoryBindCallback
cb'
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
cb'' 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
#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 (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 (m :: * -> *) a. Monad m => a -> m a
return SignalListItemFactory
result'
#if defined(ENABLE_OVERLOADING)
#endif