-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | GObject bindings
--
-- Bindings for GObject, autogenerated by haskell-gi.
@package gi-gobject
@version 2.0.21
module GI.GObject.Config
overrides :: Text
module GI.GObject.Constants
-- | If passed to G_VALUE_COLLECT(), allocated data won't
-- be copied but used verbatim. This does not affect ref-counted types
-- like objects.
-- | First available fundamental type number to create new fundamental type
-- id with G_TYPE_MAKE_FUNDAMENTAL().
-- | Last fundamental type number reserved for GLib.
-- | First fundamental type number to create a new fundamental type id with
-- G_TYPE_MAKE_FUNDAMENTAL() reserved for GLib.
-- | Last fundamental type number reserved for BSE.
-- | First fundamental type number to create a new fundamental type id with
-- G_TYPE_MAKE_FUNDAMENTAL() reserved for BSE.
-- | Shift value used in converting numbers to type IDs.
-- | An integer constant that represents the number of identifiers reserved
-- for types that are assigned at compile-time.
-- | A bit in the type number that's supposed to be left untouched.
-- | A mask for all SignalMatchType bits.
-- | A mask for all SignalFlags bits.
-- | Minimum shift count to be used for user defined flags, to be stored in
-- ParamSpec.flags. The maximum allowed is 10.
-- | ParamFlags value alias for ParamFlagsStaticName |
-- ParamFlagsStaticNick | ParamFlagsStaticBlurb.
--
-- Since 2.13.0
-- | Mask containing the bits of ParamSpec.flags
-- which are reserved for GLib.
module GI.GObject.Flags
-- | Flags to be passed to objectBindProperty or
-- g_object_bind_property_full().
--
-- This enumeration can be extended at later date.
--
-- Since: 2.26
data BindingFlags
-- | The default binding; if the source property changes, the target
-- property is updated with its value.
BindingFlagsDefault :: BindingFlags
-- | Bidirectional binding; if either the property of the source or the
-- property of the target changes, the other is updated.
BindingFlagsBidirectional :: BindingFlags
-- | Synchronize the values of the source and target properties when
-- creating the binding; the direction of the synchronization is always
-- from the source to the target.
BindingFlagsSyncCreate :: BindingFlags
-- | If the two properties being bound are booleans, setting one to
-- True will result in the other being set to False and
-- vice versa. This flag will only work for boolean properties, and
-- cannot be used when passing custom transformation functions to
-- g_object_bind_property_full().
BindingFlagsInvertBoolean :: BindingFlags
-- | Catch-all for unknown values
AnotherBindingFlags :: Int -> BindingFlags
-- | The connection flags are used to specify the behaviour of a signal's
-- connection.
data ConnectFlags
-- | whether the handler should be called before or after the default
-- handler of the signal.
ConnectFlagsAfter :: ConnectFlags
-- | whether the instance and data should be swapped when calling the
-- handler; see g_signal_connect_swapped() for an
-- example.
ConnectFlagsSwapped :: ConnectFlags
-- | Catch-all for unknown values
AnotherConnectFlags :: Int -> ConnectFlags
-- | Through the ParamFlags flag values, certain aspects of
-- parameters can be configured. See also PARAM_STATIC_STRINGS.
data ParamFlags
-- | the parameter is readable
ParamFlagsReadable :: ParamFlags
-- | the parameter is writable
ParamFlagsWritable :: ParamFlags
-- | alias for ParamFlagsReadable | ParamFlagsWritable
ParamFlagsReadwrite :: ParamFlags
-- | the parameter will be set upon object construction
ParamFlagsConstruct :: ParamFlags
-- | the parameter can only be set upon object construction
ParamFlagsConstructOnly :: ParamFlags
-- | upon parameter conversion (see paramValueConvert) strict
-- validation is not required
ParamFlagsLaxValidation :: ParamFlags
-- | the string used as name when constructing the parameter is guaranteed
-- to remain valid and unmodified for the lifetime of the parameter.
-- Since 2.8
ParamFlagsStaticName :: ParamFlags
-- | internal
ParamFlagsPrivate :: ParamFlags
-- | the string used as nick when constructing the parameter is guaranteed
-- to remain valid and unmmodified for the lifetime of the parameter.
-- Since 2.8
ParamFlagsStaticNick :: ParamFlags
-- | the string used as blurb when constructing the parameter is guaranteed
-- to remain valid and unmodified for the lifetime of the parameter.
-- Since 2.8
ParamFlagsStaticBlurb :: ParamFlags
-- | calls to objectSetProperty for this property will not
-- automatically result in a "notify" signal being emitted: the
-- implementation must call objectNotify themselves in case the
-- property actually changes. Since: 2.42.
ParamFlagsExplicitNotify :: ParamFlags
-- | the parameter is deprecated and will be removed in a future version. A
-- warning will be generated if it is used while running with
-- G_ENABLE_DIAGNOSTIC=1. Since 2.26
ParamFlagsDeprecated :: ParamFlags
-- | Catch-all for unknown values
AnotherParamFlags :: Int -> ParamFlags
-- | The signal flags are used to specify a signal's behaviour, the overall
-- signal description outlines how especially the RUN flags control the
-- stages of a signal emission.
data SignalFlags
-- | Invoke the object method handler in the first emission stage.
SignalFlagsRunFirst :: SignalFlags
-- | Invoke the object method handler in the third emission stage.
SignalFlagsRunLast :: SignalFlags
-- | Invoke the object method handler in the last emission stage.
SignalFlagsRunCleanup :: SignalFlags
-- | Signals being emitted for an object while currently being in emission
-- for this very object will not be emitted recursively, but instead
-- cause the first emission to be restarted.
SignalFlagsNoRecurse :: SignalFlags
-- | This signal supports "::detail" appendices to the signal name upon
-- handler connections and emissions.
SignalFlagsDetailed :: SignalFlags
-- | Action signals are signals that may freely be emitted on alive objects
-- from user code via g_signal_emit() and friends,
-- without the need of being embedded into extra code that performs pre
-- or post emission adjustments on the object. They can also be thought
-- of as object methods which can be called generically by third-party
-- code.
SignalFlagsAction :: SignalFlags
-- | No emissions hooks are supported for this signal.
SignalFlagsNoHooks :: SignalFlags
-- | Varargs signal emission will always collect the arguments, even if
-- there are no signal handlers connected. Since 2.30.
SignalFlagsMustCollect :: SignalFlags
-- | The signal is deprecated and will be removed in a future version. A
-- warning will be generated if it is connected while running with
-- G_ENABLE_DIAGNOSTIC=1. Since 2.32.
SignalFlagsDeprecated :: SignalFlags
-- | Catch-all for unknown values
AnotherSignalFlags :: Int -> SignalFlags
-- | The match types specify what signalHandlersBlockMatched,
-- signalHandlersUnblockMatched and
-- signalHandlersDisconnectMatched match signals by.
data SignalMatchType
-- | The signal id must be equal.
SignalMatchTypeId :: SignalMatchType
-- | The signal detail be equal.
SignalMatchTypeDetail :: SignalMatchType
-- | The closure must be the same.
SignalMatchTypeClosure :: SignalMatchType
-- | The C closure callback must be the same.
SignalMatchTypeFunc :: SignalMatchType
-- | The closure data must be the same.
SignalMatchTypeData :: SignalMatchType
-- | Only unblocked signals may matched.
SignalMatchTypeUnblocked :: SignalMatchType
-- | Catch-all for unknown values
AnotherSignalMatchType :: Int -> SignalMatchType
-- | These flags used to be passed to typeInitWithDebugFlags which
-- is now deprecated.
--
-- If you need to enable debugging features, use the GOBJECT_DEBUG
-- environment variable.
-- | Deprecated: (Since version 2.36)typeInit is now done
-- automatically
data TypeDebugFlags
-- | Print no messages
TypeDebugFlagsNone :: TypeDebugFlags
-- | Print messages about object bookkeeping
TypeDebugFlagsObjects :: TypeDebugFlags
-- | Print messages about signal emissions
TypeDebugFlagsSignals :: TypeDebugFlags
-- | Keep a count of instances of each type
TypeDebugFlagsInstanceCount :: TypeDebugFlags
-- | Mask covering all debug flags
TypeDebugFlagsMask :: TypeDebugFlags
-- | Catch-all for unknown values
AnotherTypeDebugFlags :: Int -> TypeDebugFlags
-- | Bit masks used to check or determine characteristics of a type.
data TypeFlags
-- | Indicates an abstract type. No instances can be created for an
-- abstract type
TypeFlagsAbstract :: TypeFlags
-- | Indicates an abstract value type, i.e. a type that introduces a value
-- table, but can't be used for valueInit
TypeFlagsValueAbstract :: TypeFlags
-- | Catch-all for unknown values
AnotherTypeFlags :: Int -> TypeFlags
-- | Bit masks used to check or determine specific characteristics of a
-- fundamental type.
data TypeFundamentalFlags
-- | Indicates a classed type
TypeFundamentalFlagsClassed :: TypeFundamentalFlags
-- | Indicates an instantiable type (implies classed)
TypeFundamentalFlagsInstantiatable :: TypeFundamentalFlags
-- | Indicates a flat derivable type
TypeFundamentalFlagsDerivable :: TypeFundamentalFlags
-- | Indicates a deep derivable type (implies derivable)
TypeFundamentalFlagsDeepDerivable :: TypeFundamentalFlags
-- | Catch-all for unknown values
AnotherTypeFundamentalFlags :: Int -> TypeFundamentalFlags
instance GHC.Classes.Eq GI.GObject.Flags.BindingFlags
instance GHC.Show.Show GI.GObject.Flags.BindingFlags
instance GHC.Classes.Eq GI.GObject.Flags.ConnectFlags
instance GHC.Show.Show GI.GObject.Flags.ConnectFlags
instance GHC.Classes.Eq GI.GObject.Flags.ParamFlags
instance GHC.Show.Show GI.GObject.Flags.ParamFlags
instance GHC.Classes.Eq GI.GObject.Flags.SignalFlags
instance GHC.Show.Show GI.GObject.Flags.SignalFlags
instance GHC.Classes.Eq GI.GObject.Flags.SignalMatchType
instance GHC.Show.Show GI.GObject.Flags.SignalMatchType
instance GHC.Classes.Eq GI.GObject.Flags.TypeDebugFlags
instance GHC.Show.Show GI.GObject.Flags.TypeDebugFlags
instance GHC.Classes.Eq GI.GObject.Flags.TypeFlags
instance GHC.Show.Show GI.GObject.Flags.TypeFlags
instance GHC.Classes.Eq GI.GObject.Flags.TypeFundamentalFlags
instance GHC.Show.Show GI.GObject.Flags.TypeFundamentalFlags
instance GHC.Enum.Enum GI.GObject.Flags.BindingFlags
instance GHC.Classes.Ord GI.GObject.Flags.BindingFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.GObject.Flags.BindingFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GObject.Flags.BindingFlags
instance GHC.Enum.Enum GI.GObject.Flags.ConnectFlags
instance GHC.Classes.Ord GI.GObject.Flags.ConnectFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GObject.Flags.ConnectFlags
instance GHC.Enum.Enum GI.GObject.Flags.ParamFlags
instance GHC.Classes.Ord GI.GObject.Flags.ParamFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GObject.Flags.ParamFlags
instance GHC.Enum.Enum GI.GObject.Flags.SignalFlags
instance GHC.Classes.Ord GI.GObject.Flags.SignalFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GObject.Flags.SignalFlags
instance GHC.Enum.Enum GI.GObject.Flags.SignalMatchType
instance GHC.Classes.Ord GI.GObject.Flags.SignalMatchType
instance Data.GI.Base.BasicTypes.IsGFlag GI.GObject.Flags.SignalMatchType
instance GHC.Enum.Enum GI.GObject.Flags.TypeDebugFlags
instance GHC.Classes.Ord GI.GObject.Flags.TypeDebugFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GObject.Flags.TypeDebugFlags
instance GHC.Enum.Enum GI.GObject.Flags.TypeFlags
instance GHC.Classes.Ord GI.GObject.Flags.TypeFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GObject.Flags.TypeFlags
instance GHC.Enum.Enum GI.GObject.Flags.TypeFundamentalFlags
instance GHC.Classes.Ord GI.GObject.Flags.TypeFundamentalFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GObject.Flags.TypeFundamentalFlags
-- | All the fields in the GInitiallyUnowned structure are private to the
-- InitiallyUnowned implementation and should never be accessed
-- directly.
module GI.GObject.Objects.InitiallyUnowned
-- | Memory-managed wrapper type.
newtype InitiallyUnowned
InitiallyUnowned :: ManagedPtr InitiallyUnowned -> InitiallyUnowned
-- | Type class for types which can be safely cast to
-- InitiallyUnowned, for instance with toInitiallyUnowned.
class (GObject o, IsDescendantOf InitiallyUnowned o) => IsInitiallyUnowned o
-- | Cast to InitiallyUnowned, for types for which this is known to
-- be safe. For general casts, use castTo.
toInitiallyUnowned :: (MonadIO m, IsInitiallyUnowned o) => o -> m InitiallyUnowned
-- | A convenience alias for Nothing :: Maybe
-- InitiallyUnowned.
noInitiallyUnowned :: Maybe InitiallyUnowned
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned o) => GI.GObject.Objects.InitiallyUnowned.IsInitiallyUnowned o
instance Data.GI.Base.BasicTypes.GObject GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned
-- | Binding is the representation of a binding between a property
-- on a Object instance (or source) and another property on
-- another Object instance (or target). Whenever the source
-- property changes, the same value is applied to the target property;
-- for instance, the following binding:
--
-- C code
--
--
-- g_object_bind_property (object1, "property-a",
-- object2, "property-b",
-- G_BINDING_DEFAULT);
--
--
-- will cause the property named "property-b" of object2
-- to be updated every time g_object_set() or the
-- specific accessor changes the value of the property "property-a" of
-- object1.
--
-- It is possible to create a bidirectional binding between two
-- properties of two Object instances, so that if either property
-- changes, the other is updated as well, for instance:
--
-- C code
--
--
-- g_object_bind_property (object1, "property-a",
-- object2, "property-b",
-- G_BINDING_BIDIRECTIONAL);
--
--
-- will keep the two properties in sync.
--
-- It is also possible to set a custom transformation function (in both
-- directions, in case of a bidirectional binding) to apply a custom
-- transformation from the source value to the target value before
-- applying it; for instance, the following binding:
--
-- C code
--
--
-- g_object_bind_property_full (adjustment1, "value",
-- adjustment2, "value",
-- G_BINDING_BIDIRECTIONAL,
-- celsius_to_fahrenheit,
-- fahrenheit_to_celsius,
-- NULL, NULL);
--
--
-- will keep the "value" property of the two adjustments in sync; the
-- celsiusToFahrenheit function will be called whenever
-- the "value" property of adjustment1 changes and will
-- transform the current value of the property before applying it to the
-- "value" property of adjustment2.
--
-- Vice versa, the fahrenheitToCelsius function will be
-- called whenever the "value" property of adjustment2
-- changes, and will transform the current value of the property before
-- applying it to the "value" property of adjustment1.
--
-- Note that Binding does not resolve cycles by itself; a cycle
-- like
--
--
-- object1:propertyA -> object2:propertyB
-- object2:propertyB -> object3:propertyC
-- object3:propertyC -> object1:propertyA
--
--
-- might lead to an infinite loop. The loop, in this particular case, can
-- be avoided if the objects emit the
-- Object::notify signal only if the value has
-- effectively been changed. A binding is implemented using the
-- Object::notify signal, so it is susceptible to
-- all the various ways of blocking a signal emission, like
-- signalStopEmission or signalHandlerBlock.
--
-- A binding will be severed, and the resources it allocates freed,
-- whenever either one of the Object instances it refers to are
-- finalized, or when the Binding instance loses its last
-- reference.
--
-- Bindings for languages with garbage collection can use
-- bindingUnbind to explicitly release a binding between the
-- source and target properties, instead of relying on the last reference
-- on the binding, source, and target instances to drop.
--
-- Binding is available since GObject 2.26
--
-- Since: 2.26
module GI.GObject.Objects.Binding
-- | Memory-managed wrapper type.
newtype Binding
Binding :: ManagedPtr Binding -> Binding
-- | Type class for types which can be safely cast to Binding, for
-- instance with toBinding.
class (GObject o, IsDescendantOf Binding o) => IsBinding o
-- | Cast to Binding, for types for which this is known to be safe.
-- For general casts, use castTo.
toBinding :: (MonadIO m, IsBinding o) => o -> m Binding
-- | A convenience alias for Nothing :: Maybe Binding.
noBinding :: Maybe Binding
-- | Retrieves the flags passed when constructing the Binding.
--
-- Since: 2.26
bindingGetFlags :: (HasCallStack, MonadIO m, IsBinding a) => a -> m [BindingFlags]
-- | Retrieves the Object instance used as the source of the
-- binding.
--
-- Since: 2.26
bindingGetSource :: (HasCallStack, MonadIO m, IsBinding a) => a -> m Object
-- | Retrieves the name of the property of
-- Binding:source used as the source of the
-- binding.
--
-- Since: 2.26
bindingGetSourceProperty :: (HasCallStack, MonadIO m, IsBinding a) => a -> m Text
-- | Retrieves the Object instance used as the target of the
-- binding.
--
-- Since: 2.26
bindingGetTarget :: (HasCallStack, MonadIO m, IsBinding a) => a -> m Object
-- | Retrieves the name of the property of
-- Binding:target used as the target of the
-- binding.
--
-- Since: 2.26
bindingGetTargetProperty :: (HasCallStack, MonadIO m, IsBinding a) => a -> m Text
-- | Explicitly releases the binding between the source and the target
-- property expressed by binding.
--
-- This function will release the reference that is being held on the
-- binding instance; if you want to hold on to the
-- Binding instance after calling bindingUnbind, you will
-- need to hold a reference to it.
--
-- Since: 2.38
bindingUnbind :: (HasCallStack, MonadIO m, IsBinding a) => a -> m ()
-- | Construct a GValueConstruct with valid value for the
-- “flags” property. This is rarely needed directly, but it is
-- used by new.
constructBindingFlags :: IsBinding o => [BindingFlags] -> IO (GValueConstruct o)
-- | Get the value of the “flags” property. When
-- overloading is enabled, this is equivalent to
--
--
-- get binding #flags
--
getBindingFlags :: (MonadIO m, IsBinding o) => o -> m [BindingFlags]
-- | Construct a GValueConstruct with valid value for the
-- “source” property. This is rarely needed directly, but it is
-- used by new.
constructBindingSource :: (IsBinding o, IsObject a) => a -> IO (GValueConstruct o)
-- | Get the value of the “source” property. When
-- overloading is enabled, this is equivalent to
--
--
-- get binding #source
--
getBindingSource :: (MonadIO m, IsBinding o) => o -> m Object
-- | Construct a GValueConstruct with valid value for the
-- “source-property” property. This is rarely needed directly,
-- but it is used by new.
constructBindingSourceProperty :: IsBinding o => Text -> IO (GValueConstruct o)
-- | Get the value of the “source-property” property. When
-- overloading is enabled, this is equivalent to
--
--
-- get binding #sourceProperty
--
getBindingSourceProperty :: (MonadIO m, IsBinding o) => o -> m Text
-- | Construct a GValueConstruct with valid value for the
-- “target” property. This is rarely needed directly, but it is
-- used by new.
constructBindingTarget :: (IsBinding o, IsObject a) => a -> IO (GValueConstruct o)
-- | Get the value of the “target” property. When
-- overloading is enabled, this is equivalent to
--
--
-- get binding #target
--
getBindingTarget :: (MonadIO m, IsBinding o) => o -> m Object
-- | Construct a GValueConstruct with valid value for the
-- “target-property” property. This is rarely needed directly,
-- but it is used by new.
constructBindingTargetProperty :: IsBinding o => Text -> IO (GValueConstruct o)
-- | Get the value of the “target-property” property. When
-- overloading is enabled, this is equivalent to
--
--
-- get binding #targetProperty
--
getBindingTargetProperty :: (MonadIO m, IsBinding o) => o -> m Text
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.Binding.Binding o) => GI.GObject.Objects.Binding.IsBinding o
instance Data.GI.Base.BasicTypes.GObject GI.GObject.Objects.Binding.Binding
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.Binding.Binding
module GI.GObject.Objects.ParamSpec
module GI.GObject.Objects.ParamSpecBoolean
module GI.GObject.Objects.ParamSpecBoxed
module GI.GObject.Objects.ParamSpecChar
module GI.GObject.Objects.ParamSpecDouble
module GI.GObject.Objects.ParamSpecEnum
module GI.GObject.Objects.ParamSpecFlags
module GI.GObject.Objects.ParamSpecFloat
module GI.GObject.Objects.ParamSpecGType
module GI.GObject.Objects.ParamSpecInt
module GI.GObject.Objects.ParamSpecInt64
module GI.GObject.Objects.ParamSpecLong
module GI.GObject.Objects.ParamSpecObject
module GI.GObject.Objects.ParamSpecOverride
module GI.GObject.Objects.ParamSpecParam
module GI.GObject.Objects.ParamSpecPointer
module GI.GObject.Objects.ParamSpecString
module GI.GObject.Objects.ParamSpecUChar
module GI.GObject.Objects.ParamSpecUInt
module GI.GObject.Objects.ParamSpecUInt64
module GI.GObject.Objects.ParamSpecULong
module GI.GObject.Objects.ParamSpecUnichar
module GI.GObject.Objects.ParamSpecValueArray
module GI.GObject.Objects.ParamSpecVariant
-- | A CClosure is a specialization of Closure for C function
-- callbacks.
module GI.GObject.Structs.CClosure
-- | Memory-managed wrapper type.
newtype CClosure
CClosure :: ManagedPtr CClosure -> CClosure
-- | Construct a CClosure struct initialized to zero.
newZeroCClosure :: MonadIO m => m CClosure
-- | A convenience alias for Nothing :: Maybe
-- CClosure.
noCClosure :: Maybe CClosure
-- | A GClosureMarshal function for use with signals with
-- handlers that take two boxed pointers as arguments and return a
-- boolean. If you have such a signal, you will probably also need to use
-- an accumulator, such as signalAccumulatorTrueHandled.
cClosureMarshalBOOLEAN_BOXEDBOXED :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type
-- gboolean (*callback) (gpointer instance, gint arg1, gpointer
-- user_data) where the gint parameter denotes a
-- flags type.
cClosureMarshalBOOLEAN_FLAGS :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A generic marshaller function implemented via libffi.
--
-- Normally this function is not passed explicitly to
-- g_signal_new(), but used automatically by GLib when
-- specifying a Nothing marshaller.
--
-- Since: 2.30
cClosureMarshalGeneric :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type gchar*
-- (*callback) (gpointer instance, GObject *arg1, gpointer arg2, gpointer
-- user_data).
cClosureMarshalSTRING_OBJECTPOINTER :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type void
-- (*callback) (gpointer instance, gboolean arg1, gpointer
-- user_data).
cClosureMarshalVOID_BOOLEAN :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type void
-- (*callback) (gpointer instance, GBoxed *arg1, gpointer
-- user_data).
cClosureMarshalVOID_BOXED :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type void
-- (*callback) (gpointer instance, gchar arg1, gpointer user_data).
cClosureMarshalVOID_CHAR :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type void
-- (*callback) (gpointer instance, gdouble arg1, gpointer
-- user_data).
cClosureMarshalVOID_DOUBLE :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type void
-- (*callback) (gpointer instance, gint arg1, gpointer user_data)
-- where the gint parameter denotes an enumeration type..
cClosureMarshalVOID_ENUM :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type void
-- (*callback) (gpointer instance, gint arg1, gpointer user_data)
-- where the gint parameter denotes a flags type.
cClosureMarshalVOID_FLAGS :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type void
-- (*callback) (gpointer instance, gfloat arg1, gpointer user_data).
cClosureMarshalVOID_FLOAT :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type void
-- (*callback) (gpointer instance, gint arg1, gpointer user_data).
cClosureMarshalVOID_INT :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type void
-- (*callback) (gpointer instance, glong arg1, gpointer user_data).
cClosureMarshalVOID_LONG :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type void
-- (*callback) (gpointer instance, GObject *arg1, gpointer
-- user_data).
cClosureMarshalVOID_OBJECT :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type void
-- (*callback) (gpointer instance, GParamSpec *arg1, gpointer
-- user_data).
cClosureMarshalVOID_PARAM :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type void
-- (*callback) (gpointer instance, gpointer arg1, gpointer
-- user_data).
cClosureMarshalVOID_POINTER :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type void
-- (*callback) (gpointer instance, const gchar *arg1, gpointer
-- user_data).
cClosureMarshalVOID_STRING :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type void
-- (*callback) (gpointer instance, guchar arg1, gpointer user_data).
cClosureMarshalVOID_UCHAR :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type void
-- (*callback) (gpointer instance, guint arg1, gpointer user_data).
cClosureMarshalVOID_UINT :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type void
-- (*callback) (gpointer instance, guint arg1, gpointer arg2, gpointer
-- user_data).
cClosureMarshalVOID_UINTPOINTER :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type void
-- (*callback) (gpointer instance, gulong arg1, gpointer user_data).
cClosureMarshalVOID_ULONG :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type void
-- (*callback) (gpointer instance, GVariant *arg1, gpointer
-- user_data).
--
-- Since: 2.26
cClosureMarshalVOID_VARIANT :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | A marshaller for a CClosure with a callback of type void
-- (*callback) (gpointer instance, gpointer user_data).
cClosureMarshalVOID_VOID :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | Set the value of the “callback” field to Nothing. When
-- overloading is enabled, this is equivalent to
--
--
-- clear #callback
--
clearCClosureCallback :: MonadIO m => CClosure -> m ()
-- | Get the value of the “callback” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get cClosure #callback
--
getCClosureCallback :: MonadIO m => CClosure -> m (Ptr ())
-- | Set the value of the “callback” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set cClosure [ #callback := value ]
--
setCClosureCallback :: MonadIO m => CClosure -> Ptr () -> m ()
-- | Set the value of the “closure” field to Nothing. When
-- overloading is enabled, this is equivalent to
--
--
-- clear #closure
--
clearCClosureClosure :: MonadIO m => CClosure -> m ()
-- | Get the value of the “closure” field. When overloading
-- is enabled, this is equivalent to
--
--
-- get cClosure #closure
--
getCClosureClosure :: MonadIO m => CClosure -> m (Maybe (GClosure ()))
-- | Set the value of the “closure” field. When overloading
-- is enabled, this is equivalent to
--
--
-- set cClosure [ #closure := value ]
--
setCClosureClosure :: MonadIO m => CClosure -> Ptr (GClosure ()) -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.CClosure.CClosure
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.CClosure.CClosure tag
-- | A structure which contains a single enum value, its name, and its
-- nickname.
module GI.GObject.Structs.EnumValue
-- | Memory-managed wrapper type.
newtype EnumValue
EnumValue :: ManagedPtr EnumValue -> EnumValue
-- | Construct a EnumValue struct initialized to zero.
newZeroEnumValue :: MonadIO m => m EnumValue
-- | A convenience alias for Nothing :: Maybe
-- EnumValue.
noEnumValue :: Maybe EnumValue
-- | Get the value of the “value” field. When overloading
-- is enabled, this is equivalent to
--
--
-- get enumValue #value
--
getEnumValueValue :: MonadIO m => EnumValue -> m Int32
-- | Set the value of the “value” field. When overloading
-- is enabled, this is equivalent to
--
--
-- set enumValue [ #value := value ]
--
setEnumValueValue :: MonadIO m => EnumValue -> Int32 -> m ()
-- | Set the value of the “value_name” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #valueName
--
clearEnumValueValueName :: MonadIO m => EnumValue -> m ()
-- | Get the value of the “value_name” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get enumValue #valueName
--
getEnumValueValueName :: MonadIO m => EnumValue -> m (Maybe Text)
-- | Set the value of the “value_name” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set enumValue [ #valueName := value ]
--
setEnumValueValueName :: MonadIO m => EnumValue -> CString -> m ()
-- | Set the value of the “value_nick” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #valueNick
--
clearEnumValueValueNick :: MonadIO m => EnumValue -> m ()
-- | Get the value of the “value_nick” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get enumValue #valueNick
--
getEnumValueValueNick :: MonadIO m => EnumValue -> m (Maybe Text)
-- | Set the value of the “value_nick” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set enumValue [ #valueNick := value ]
--
setEnumValueValueNick :: MonadIO m => EnumValue -> CString -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.EnumValue.EnumValue
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.EnumValue.EnumValue tag
-- | A structure which contains a single flags value, its name, and its
-- nickname.
module GI.GObject.Structs.FlagsValue
-- | Memory-managed wrapper type.
newtype FlagsValue
FlagsValue :: ManagedPtr FlagsValue -> FlagsValue
-- | Construct a FlagsValue struct initialized to zero.
newZeroFlagsValue :: MonadIO m => m FlagsValue
-- | A convenience alias for Nothing :: Maybe
-- FlagsValue.
noFlagsValue :: Maybe FlagsValue
-- | Get the value of the “value” field. When overloading
-- is enabled, this is equivalent to
--
--
-- get flagsValue #value
--
getFlagsValueValue :: MonadIO m => FlagsValue -> m Word32
-- | Set the value of the “value” field. When overloading
-- is enabled, this is equivalent to
--
--
-- set flagsValue [ #value := value ]
--
setFlagsValueValue :: MonadIO m => FlagsValue -> Word32 -> m ()
-- | Set the value of the “value_name” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #valueName
--
clearFlagsValueValueName :: MonadIO m => FlagsValue -> m ()
-- | Get the value of the “value_name” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get flagsValue #valueName
--
getFlagsValueValueName :: MonadIO m => FlagsValue -> m (Maybe Text)
-- | Set the value of the “value_name” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set flagsValue [ #valueName := value ]
--
setFlagsValueValueName :: MonadIO m => FlagsValue -> CString -> m ()
-- | Set the value of the “value_nick” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #valueNick
--
clearFlagsValueValueNick :: MonadIO m => FlagsValue -> m ()
-- | Get the value of the “value_nick” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get flagsValue #valueNick
--
getFlagsValueValueNick :: MonadIO m => FlagsValue -> m (Maybe Text)
-- | Set the value of the “value_nick” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set flagsValue [ #valueNick := value ]
--
setFlagsValueValueNick :: MonadIO m => FlagsValue -> CString -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.FlagsValue.FlagsValue
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.FlagsValue.FlagsValue tag
-- | The GObjectConstructParam struct is an auxiliary structure used to
-- hand
-- 'GI.GObject.Objects.ParamSpec.ParamSpec'\/'GI.GObject.Structs.Value.Value'
-- pairs to the constructor of a ObjectClass.
module GI.GObject.Structs.ObjectConstructParam
-- | Memory-managed wrapper type.
newtype ObjectConstructParam
ObjectConstructParam :: ManagedPtr ObjectConstructParam -> ObjectConstructParam
-- | Construct a ObjectConstructParam struct initialized to zero.
newZeroObjectConstructParam :: MonadIO m => m ObjectConstructParam
-- | A convenience alias for Nothing :: Maybe
-- ObjectConstructParam.
noObjectConstructParam :: Maybe ObjectConstructParam
-- | Set the value of the “pspec” field to Nothing. When
-- overloading is enabled, this is equivalent to
--
--
-- clear #pspec
--
clearObjectConstructParamPspec :: MonadIO m => ObjectConstructParam -> m ()
-- | Get the value of the “pspec” field. When overloading
-- is enabled, this is equivalent to
--
--
-- get objectConstructParam #pspec
--
getObjectConstructParamPspec :: MonadIO m => ObjectConstructParam -> m (Maybe GParamSpec)
-- | Set the value of the “pspec” field. When overloading
-- is enabled, this is equivalent to
--
--
-- set objectConstructParam [ #pspec := value ]
--
setObjectConstructParamPspec :: MonadIO m => ObjectConstructParam -> Ptr GParamSpec -> m ()
-- | Set the value of the “value” field to Nothing. When
-- overloading is enabled, this is equivalent to
--
--
-- clear #value
--
clearObjectConstructParamValue :: MonadIO m => ObjectConstructParam -> m ()
-- | Get the value of the “value” field. When overloading
-- is enabled, this is equivalent to
--
--
-- get objectConstructParam #value
--
getObjectConstructParamValue :: MonadIO m => ObjectConstructParam -> m (Maybe GValue)
-- | Set the value of the “value” field. When overloading
-- is enabled, this is equivalent to
--
--
-- set objectConstructParam [ #value := value ]
--
setObjectConstructParamValue :: MonadIO m => ObjectConstructParam -> Ptr GValue -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.ObjectConstructParam.ObjectConstructParam
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.ObjectConstructParam.ObjectConstructParam tag
-- | A ParamSpecPool maintains a collection of
-- GParamSpecs which can be quickly accessed by owner and
-- name. The implementation of the Object property system uses
-- such a pool to store the GParamSpecs of the properties
-- all object types.
module GI.GObject.Structs.ParamSpecPool
-- | Memory-managed wrapper type.
newtype ParamSpecPool
ParamSpecPool :: ManagedPtr ParamSpecPool -> ParamSpecPool
-- | A convenience alias for Nothing :: Maybe
-- ParamSpecPool.
noParamSpecPool :: Maybe ParamSpecPool
-- | Inserts a ParamSpec in the pool.
paramSpecPoolInsert :: (HasCallStack, MonadIO m) => ParamSpecPool -> GParamSpec -> GType -> m ()
-- | Gets an List of all GParamSpecs owned by
-- ownerType in the pool.
paramSpecPoolListOwned :: (HasCallStack, MonadIO m) => ParamSpecPool -> GType -> m [GParamSpec]
-- | Looks up a ParamSpec in the pool.
paramSpecPoolLookup :: (HasCallStack, MonadIO m) => ParamSpecPool -> Text -> GType -> Bool -> m GParamSpec
-- | Creates a new ParamSpecPool.
--
-- If typePrefixing is True, lookups in the newly
-- created pool will allow to specify the owner as a colon-separated
-- prefix of the property name, like "GtkContainer:border-width". This
-- feature is deprecated, so you should always set
-- typePrefixing to False.
paramSpecPoolNew :: (HasCallStack, MonadIO m) => Bool -> m ParamSpecPool
-- | Removes a ParamSpec from the pool.
paramSpecPoolRemove :: (HasCallStack, MonadIO m) => ParamSpecPool -> GParamSpec -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.ParamSpecPool.ParamSpecPool
-- | The GParameter struct is an auxiliary structure used to hand parameter
-- name/value pairs to objectNewv.
module GI.GObject.Structs.Parameter
-- | Memory-managed wrapper type.
newtype Parameter
Parameter :: ManagedPtr Parameter -> Parameter
-- | Construct a Parameter struct initialized to zero.
newZeroParameter :: MonadIO m => m Parameter
-- | A convenience alias for Nothing :: Maybe
-- Parameter.
noParameter :: Maybe Parameter
-- | Set the value of the “name” field to Nothing. When
-- overloading is enabled, this is equivalent to
--
--
-- clear #name
--
clearParameterName :: MonadIO m => Parameter -> m ()
-- | Get the value of the “name” field. When overloading is
-- enabled, this is equivalent to
--
--
-- get parameter #name
--
getParameterName :: MonadIO m => Parameter -> m (Maybe Text)
-- | Set the value of the “name” field. When overloading is
-- enabled, this is equivalent to
--
--
-- set parameter [ #name := value ]
--
setParameterName :: MonadIO m => Parameter -> CString -> m ()
-- | Get the value of the “value” field. When overloading
-- is enabled, this is equivalent to
--
--
-- get parameter #value
--
getParameterValue :: MonadIO m => Parameter -> m GValue
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.Parameter.Parameter
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.Parameter.Parameter tag
-- | The SignalInvocationHint structure is used to pass on
-- additional information to callbacks during a signal emission.
module GI.GObject.Structs.SignalInvocationHint
-- | Memory-managed wrapper type.
newtype SignalInvocationHint
SignalInvocationHint :: ManagedPtr SignalInvocationHint -> SignalInvocationHint
-- | Construct a SignalInvocationHint struct initialized to zero.
newZeroSignalInvocationHint :: MonadIO m => m SignalInvocationHint
-- | A convenience alias for Nothing :: Maybe
-- SignalInvocationHint.
noSignalInvocationHint :: Maybe SignalInvocationHint
-- | Get the value of the “detail” field. When overloading
-- is enabled, this is equivalent to
--
--
-- get signalInvocationHint #detail
--
getSignalInvocationHintDetail :: MonadIO m => SignalInvocationHint -> m Word32
-- | Set the value of the “detail” field. When overloading
-- is enabled, this is equivalent to
--
--
-- set signalInvocationHint [ #detail := value ]
--
setSignalInvocationHintDetail :: MonadIO m => SignalInvocationHint -> Word32 -> m ()
-- | Get the value of the “run_type” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get signalInvocationHint #runType
--
getSignalInvocationHintRunType :: MonadIO m => SignalInvocationHint -> m [SignalFlags]
-- | Set the value of the “run_type” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set signalInvocationHint [ #runType := value ]
--
setSignalInvocationHintRunType :: MonadIO m => SignalInvocationHint -> [SignalFlags] -> m ()
-- | Get the value of the “signal_id” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get signalInvocationHint #signalId
--
getSignalInvocationHintSignalId :: MonadIO m => SignalInvocationHint -> m Word32
-- | Set the value of the “signal_id” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set signalInvocationHint [ #signalId := value ]
--
setSignalInvocationHintSignalId :: MonadIO m => SignalInvocationHint -> Word32 -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint tag
-- | A structure holding in-depth information for a specific signal. It is
-- filled in by the signalQuery function.
module GI.GObject.Structs.SignalQuery
-- | Memory-managed wrapper type.
newtype SignalQuery
SignalQuery :: ManagedPtr SignalQuery -> SignalQuery
-- | Construct a SignalQuery struct initialized to zero.
newZeroSignalQuery :: MonadIO m => m SignalQuery
-- | A convenience alias for Nothing :: Maybe
-- SignalQuery.
noSignalQuery :: Maybe SignalQuery
-- | Get the value of the “itype” field. When overloading
-- is enabled, this is equivalent to
--
--
-- get signalQuery #itype
--
getSignalQueryItype :: MonadIO m => SignalQuery -> m GType
-- | Set the value of the “itype” field. When overloading
-- is enabled, this is equivalent to
--
--
-- set signalQuery [ #itype := value ]
--
setSignalQueryItype :: MonadIO m => SignalQuery -> GType -> m ()
-- | Get the value of the “n_params” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get signalQuery #nParams
--
getSignalQueryNParams :: MonadIO m => SignalQuery -> m Word32
-- | Set the value of the “n_params” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set signalQuery [ #nParams := value ]
--
setSignalQueryNParams :: MonadIO m => SignalQuery -> Word32 -> m ()
-- | Get the value of the “return_type” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get signalQuery #returnType
--
getSignalQueryReturnType :: MonadIO m => SignalQuery -> m GType
-- | Set the value of the “return_type” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set signalQuery [ #returnType := value ]
--
setSignalQueryReturnType :: MonadIO m => SignalQuery -> GType -> m ()
-- | Get the value of the “signal_flags” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get signalQuery #signalFlags
--
getSignalQuerySignalFlags :: MonadIO m => SignalQuery -> m [SignalFlags]
-- | Set the value of the “signal_flags” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set signalQuery [ #signalFlags := value ]
--
setSignalQuerySignalFlags :: MonadIO m => SignalQuery -> [SignalFlags] -> m ()
-- | Get the value of the “signal_id” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get signalQuery #signalId
--
getSignalQuerySignalId :: MonadIO m => SignalQuery -> m Word32
-- | Set the value of the “signal_id” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set signalQuery [ #signalId := value ]
--
setSignalQuerySignalId :: MonadIO m => SignalQuery -> Word32 -> m ()
-- | Set the value of the “signal_name” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #signalName
--
clearSignalQuerySignalName :: MonadIO m => SignalQuery -> m ()
-- | Get the value of the “signal_name” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get signalQuery #signalName
--
getSignalQuerySignalName :: MonadIO m => SignalQuery -> m (Maybe Text)
-- | Set the value of the “signal_name” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set signalQuery [ #signalName := value ]
--
setSignalQuerySignalName :: MonadIO m => SignalQuery -> CString -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.SignalQuery.SignalQuery
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.SignalQuery.SignalQuery tag
-- | The class of a flags type holds information about its possible values.
module GI.GObject.Structs.FlagsClass
-- | Memory-managed wrapper type.
newtype FlagsClass
FlagsClass :: ManagedPtr FlagsClass -> FlagsClass
-- | Construct a FlagsClass struct initialized to zero.
newZeroFlagsClass :: MonadIO m => m FlagsClass
-- | A convenience alias for Nothing :: Maybe
-- FlagsClass.
noFlagsClass :: Maybe FlagsClass
-- | Get the value of the “g_type_class” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get flagsClass #gTypeClass
--
getFlagsClassGTypeClass :: MonadIO m => FlagsClass -> m TypeClass
-- | Get the value of the “mask” field. When overloading is
-- enabled, this is equivalent to
--
--
-- get flagsClass #mask
--
getFlagsClassMask :: MonadIO m => FlagsClass -> m Word32
-- | Set the value of the “mask” field. When overloading is
-- enabled, this is equivalent to
--
--
-- set flagsClass [ #mask := value ]
--
setFlagsClassMask :: MonadIO m => FlagsClass -> Word32 -> m ()
-- | Get the value of the “n_values” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get flagsClass #nValues
--
getFlagsClassNValues :: MonadIO m => FlagsClass -> m Word32
-- | Set the value of the “n_values” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set flagsClass [ #nValues := value ]
--
setFlagsClassNValues :: MonadIO m => FlagsClass -> Word32 -> m ()
-- | Set the value of the “values” field to Nothing. When
-- overloading is enabled, this is equivalent to
--
--
-- clear #values
--
clearFlagsClassValues :: MonadIO m => FlagsClass -> m ()
-- | Get the value of the “values” field. When overloading
-- is enabled, this is equivalent to
--
--
-- get flagsClass #values
--
getFlagsClassValues :: MonadIO m => FlagsClass -> m (Maybe FlagsValue)
-- | Set the value of the “values” field. When overloading
-- is enabled, this is equivalent to
--
--
-- set flagsClass [ #values := value ]
--
setFlagsClassValues :: MonadIO m => FlagsClass -> Ptr FlagsValue -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.FlagsClass.FlagsClass
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.FlagsClass.FlagsClass tag
-- | The class of an enumeration type holds information about its possible
-- values.
module GI.GObject.Structs.EnumClass
-- | Memory-managed wrapper type.
newtype EnumClass
EnumClass :: ManagedPtr EnumClass -> EnumClass
-- | Construct a EnumClass struct initialized to zero.
newZeroEnumClass :: MonadIO m => m EnumClass
-- | A convenience alias for Nothing :: Maybe
-- EnumClass.
noEnumClass :: Maybe EnumClass
-- | Get the value of the “g_type_class” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get enumClass #gTypeClass
--
getEnumClassGTypeClass :: MonadIO m => EnumClass -> m TypeClass
-- | Get the value of the “maximum” field. When overloading
-- is enabled, this is equivalent to
--
--
-- get enumClass #maximum
--
getEnumClassMaximum :: MonadIO m => EnumClass -> m Int32
-- | Set the value of the “maximum” field. When overloading
-- is enabled, this is equivalent to
--
--
-- set enumClass [ #maximum := value ]
--
setEnumClassMaximum :: MonadIO m => EnumClass -> Int32 -> m ()
-- | Get the value of the “minimum” field. When overloading
-- is enabled, this is equivalent to
--
--
-- get enumClass #minimum
--
getEnumClassMinimum :: MonadIO m => EnumClass -> m Int32
-- | Set the value of the “minimum” field. When overloading
-- is enabled, this is equivalent to
--
--
-- set enumClass [ #minimum := value ]
--
setEnumClassMinimum :: MonadIO m => EnumClass -> Int32 -> m ()
-- | Get the value of the “n_values” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get enumClass #nValues
--
getEnumClassNValues :: MonadIO m => EnumClass -> m Word32
-- | Set the value of the “n_values” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set enumClass [ #nValues := value ]
--
setEnumClassNValues :: MonadIO m => EnumClass -> Word32 -> m ()
-- | Set the value of the “values” field to Nothing. When
-- overloading is enabled, this is equivalent to
--
--
-- clear #values
--
clearEnumClassValues :: MonadIO m => EnumClass -> m ()
-- | Get the value of the “values” field. When overloading
-- is enabled, this is equivalent to
--
--
-- get enumClass #values
--
getEnumClassValues :: MonadIO m => EnumClass -> m (Maybe EnumValue)
-- | Set the value of the “values” field. When overloading
-- is enabled, this is equivalent to
--
--
-- set enumClass [ #values := value ]
--
setEnumClassValues :: MonadIO m => EnumClass -> Ptr EnumValue -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.EnumClass.EnumClass
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.EnumClass.EnumClass tag
-- | An opaque structure used as the base of all classes.
module GI.GObject.Structs.TypeClass
-- | Memory-managed wrapper type.
newtype TypeClass
TypeClass :: ManagedPtr TypeClass -> TypeClass
-- | Construct a TypeClass struct initialized to zero.
newZeroTypeClass :: MonadIO m => m TypeClass
-- | A convenience alias for Nothing :: Maybe
-- TypeClass.
noTypeClass :: Maybe TypeClass
-- | Registers a private structure for an instantiatable type.
--
-- When an object is allocated, the private structures for the type and
-- all of its parent types are allocated sequentially in the same memory
-- block as the public structures, and are zero-filled.
--
-- Note that the accumulated size of the private structures of a type and
-- all its parent types cannot exceed 64 KiB.
--
-- This function should be called in the type's
-- class_init() function. The private structure can be
-- retrieved using the G_TYPE_INSTANCE_GET_PRIVATE()
-- macro.
--
-- The following example shows attaching a private structure
-- MyObjectPrivate to an object MyObject defined in the standard GObject
-- fashion in the type's class_init() function.
--
-- Note the use of a structure member "priv" to avoid the overhead of
-- repeatedly calling MY_OBJECT_GET_PRIVATE().
--
-- C code
--
--
-- typedef struct _MyObject MyObject;
-- typedef struct _MyObjectPrivate MyObjectPrivate;
--
-- struct _MyObject {
-- GObject parent;
--
-- MyObjectPrivate *priv;
-- };
--
-- struct _MyObjectPrivate {
-- int some_field;
-- };
--
-- static void
-- my_object_class_init (MyObjectClass *klass)
-- {
-- g_type_class_add_private (klass, sizeof (MyObjectPrivate));
-- }
--
-- static void
-- my_object_init (MyObject *my_object)
-- {
-- my_object->priv = G_TYPE_INSTANCE_GET_PRIVATE (my_object,
-- MY_TYPE_OBJECT,
-- MyObjectPrivate);
-- // my_object->priv->some_field will be automatically initialised to 0
-- }
--
-- static int
-- my_object_get_some_field (MyObject *my_object)
-- {
-- MyObjectPrivate *priv;
--
-- g_return_val_if_fail (MY_IS_OBJECT (my_object), 0);
--
-- priv = my_object->priv;
--
-- return priv->some_field;
-- }
--
--
-- Since: 2.4
-- | Deprecated: (Since version 2.58)Use the
-- G_ADD_PRIVATE() macro with the G_DEFINE_*
-- family of macros to add instance private data to a type
typeClassAddPrivate :: (HasCallStack, MonadIO m) => TypeClass -> Word64 -> m ()
-- | No description available in the introspection data.
typeClassAdjustPrivateOffset :: (HasCallStack, MonadIO m) => Ptr () -> Int32 -> m ()
-- | No description available in the introspection data.
typeClassGetPrivate :: (HasCallStack, MonadIO m) => TypeClass -> GType -> m (Ptr ())
-- | This function is essentially the same as typeClassRef, except
-- that the classes reference count isn't incremented. As a consequence,
-- this function may return Nothing if the class of the type
-- passed in does not currently exist (hasn't been referenced before).
typeClassPeek :: (HasCallStack, MonadIO m) => GType -> m TypeClass
-- | This is a convenience function often needed in class initializers. It
-- returns the class structure of the immediate parent type of the class
-- passed in. Since derived classes hold a reference count on their
-- parent classes as long as they are instantiated, the returned class
-- will always exist.
--
-- This function is essentially equivalent to: g_type_class_peek
-- (g_type_parent (G_TYPE_FROM_CLASS (g_class)))
typeClassPeekParent :: (HasCallStack, MonadIO m) => TypeClass -> m TypeClass
-- | A more efficient version of typeClassPeek which works only for
-- static types.
--
-- Since: 2.4
typeClassPeekStatic :: (HasCallStack, MonadIO m) => GType -> m TypeClass
-- | Increments the reference count of the class structure belonging to
-- type. This function will demand-create the class if it
-- doesn't exist already.
typeClassRef :: (HasCallStack, MonadIO m) => GType -> m TypeClass
-- | Decrements the reference count of the class structure being passed in.
-- Once the last reference count of a class has been released, classes
-- may be finalized by the type system, so further dereferencing of a
-- class pointer after typeClassUnref are invalid.
typeClassUnref :: (HasCallStack, MonadIO m) => TypeClass -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.TypeClass.TypeClass
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.TypeClass.TypeClass tag
-- | A structure that provides information to the type system which is used
-- specifically for managing fundamental types.
module GI.GObject.Structs.TypeFundamentalInfo
-- | Memory-managed wrapper type.
newtype TypeFundamentalInfo
TypeFundamentalInfo :: ManagedPtr TypeFundamentalInfo -> TypeFundamentalInfo
-- | Construct a TypeFundamentalInfo struct initialized to zero.
newZeroTypeFundamentalInfo :: MonadIO m => m TypeFundamentalInfo
-- | A convenience alias for Nothing :: Maybe
-- TypeFundamentalInfo.
noTypeFundamentalInfo :: Maybe TypeFundamentalInfo
-- | Get the value of the “type_flags” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeFundamentalInfo #typeFlags
--
getTypeFundamentalInfoTypeFlags :: MonadIO m => TypeFundamentalInfo -> m [TypeFundamentalFlags]
-- | Set the value of the “type_flags” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeFundamentalInfo [ #typeFlags := value ]
--
setTypeFundamentalInfoTypeFlags :: MonadIO m => TypeFundamentalInfo -> [TypeFundamentalFlags] -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.TypeFundamentalInfo.TypeFundamentalInfo
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.TypeFundamentalInfo.TypeFundamentalInfo tag
-- | TypeModule provides a simple implementation of the
-- TypePlugin interface. The model of TypeModule is a
-- dynamically loaded module which implements some number of types and
-- interface implementations. When the module is loaded, it registers its
-- types and interfaces using typeModuleRegisterType and
-- typeModuleAddInterface. As long as any instances of these types
-- and interface implementations are in use, the module is kept loaded.
-- When the types and interfaces are gone, the module may be unloaded. If
-- the types and interfaces become used again, the module will be
-- reloaded. Note that the last unref cannot happen in module code, since
-- that would lead to the caller's code being unloaded before
-- objectUnref returns to it.
--
-- Keeping track of whether the module should be loaded or not is done by
-- using a use count - it starts at zero, and whenever it is greater than
-- zero, the module is loaded. The use count is maintained internally by
-- the type system, but also can be explicitly controlled by
-- typeModuleUse and typeModuleUnuse. Typically, when
-- loading a module for the first type, typeModuleUse will be used
-- to load it so that it can initialize its types. At some later point,
-- when the module no longer needs to be loaded except for the type
-- implementations it contains, typeModuleUnuse is called.
--
-- TypeModule does not actually provide any implementation of
-- module loading and unloading. To create a particular module type you
-- must derive from TypeModule and implement the load and unload
-- functions in TypeModuleClass.
module GI.GObject.Objects.TypeModule
-- | Memory-managed wrapper type.
newtype TypeModule
TypeModule :: ManagedPtr TypeModule -> TypeModule
-- | Type class for types which can be safely cast to TypeModule,
-- for instance with toTypeModule.
class (GObject o, IsDescendantOf TypeModule o) => IsTypeModule o
-- | Cast to TypeModule, for types for which this is known to be
-- safe. For general casts, use castTo.
toTypeModule :: (MonadIO m, IsTypeModule o) => o -> m TypeModule
-- | A convenience alias for Nothing :: Maybe
-- TypeModule.
noTypeModule :: Maybe TypeModule
-- | Registers an additional interface for a type, whose interface lives in
-- the given type plugin. If the interface was already registered for the
-- type in this plugin, nothing will be done.
--
-- As long as any instances of the type exist, the type plugin will not
-- be unloaded.
--
-- Since 2.56 if module is Nothing this will call
-- typeAddInterfaceStatic instead. This can be used when making a
-- static build of the module.
typeModuleAddInterface :: (HasCallStack, MonadIO m, IsTypeModule a) => a -> GType -> GType -> InterfaceInfo -> m ()
-- | Looks up or registers an enumeration that is implemented with a
-- particular type plugin. If a type with name typeName
-- was previously registered, the GType identifier for the type is
-- returned, otherwise the type is newly registered, and the resulting
-- GType identifier returned.
--
-- As long as any instances of the type exist, the type plugin will not
-- be unloaded.
--
-- Since 2.56 if module is Nothing this will call
-- typeRegisterStatic instead. This can be used when making a
-- static build of the module.
--
-- Since: 2.6
typeModuleRegisterEnum :: (HasCallStack, MonadIO m, IsTypeModule a) => a -> Text -> EnumValue -> m GType
-- | Looks up or registers a flags type that is implemented with a
-- particular type plugin. If a type with name typeName
-- was previously registered, the GType identifier for the type is
-- returned, otherwise the type is newly registered, and the resulting
-- GType identifier returned.
--
-- As long as any instances of the type exist, the type plugin will not
-- be unloaded.
--
-- Since 2.56 if module is Nothing this will call
-- typeRegisterStatic instead. This can be used when making a
-- static build of the module.
--
-- Since: 2.6
typeModuleRegisterFlags :: (HasCallStack, MonadIO m, IsTypeModule a) => a -> Text -> FlagsValue -> m GType
-- | Looks up or registers a type that is implemented with a particular
-- type plugin. If a type with name typeName was
-- previously registered, the GType identifier for the type is
-- returned, otherwise the type is newly registered, and the resulting
-- GType identifier returned.
--
-- When reregistering a type (typically because a module is unloaded then
-- reloaded, and reinitialized), module and
-- parentType must be the same as they were previously.
--
-- As long as any instances of the type exist, the type plugin will not
-- be unloaded.
--
-- Since 2.56 if module is Nothing this will call
-- typeRegisterStatic instead. This can be used when making a
-- static build of the module.
typeModuleRegisterType :: (HasCallStack, MonadIO m, IsTypeModule a) => a -> GType -> Text -> TypeInfo -> [TypeFlags] -> m GType
-- | Sets the name for a TypeModule
typeModuleSetName :: (HasCallStack, MonadIO m, IsTypeModule a) => a -> Text -> m ()
-- | Decreases the use count of a TypeModule by one. If the result
-- is zero, the module will be unloaded. (However, the TypeModule
-- will not be freed, and types associated with the TypeModule are
-- not unregistered. Once a TypeModule is initialized, it must
-- exist forever.)
typeModuleUnuse :: (HasCallStack, MonadIO m, IsTypeModule a) => a -> m ()
-- | Increases the use count of a TypeModule by one. If the use
-- count was zero before, the plugin will be loaded. If loading the
-- plugin fails, the use count is reset to its prior value.
typeModuleUse :: (HasCallStack, MonadIO m, IsTypeModule a) => a -> m Bool
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.TypeModule.TypeModule o) => GI.GObject.Objects.TypeModule.IsTypeModule o
instance Data.GI.Base.BasicTypes.GObject GI.GObject.Objects.TypeModule.TypeModule
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.TypeModule.TypeModule
-- | An opaque structure used as the base of all type instances.
module GI.GObject.Structs.TypeInstance
-- | Memory-managed wrapper type.
newtype TypeInstance
TypeInstance :: ManagedPtr TypeInstance -> TypeInstance
-- | Construct a TypeInstance struct initialized to zero.
newZeroTypeInstance :: MonadIO m => m TypeInstance
-- | A convenience alias for Nothing :: Maybe
-- TypeInstance.
noTypeInstance :: Maybe TypeInstance
-- | No description available in the introspection data.
typeInstanceGetPrivate :: (HasCallStack, MonadIO m) => TypeInstance -> GType -> m (Ptr ())
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.TypeInstance.TypeInstance
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.TypeInstance.TypeInstance tag
-- | All the fields in the GObject structure are private to the
-- Object implementation and should never be accessed directly.
module GI.GObject.Objects.Object
-- | Memory-managed wrapper type.
newtype Object
Object :: ManagedPtr Object -> Object
-- | Type class for types which can be safely cast to Object, for
-- instance with toObject.
class (GObject o, IsDescendantOf Object o) => IsObject o
-- | Cast to Object, for types for which this is known to be safe.
-- For general casts, use castTo.
toObject :: (MonadIO m, IsObject o) => o -> m Object
-- | A convenience alias for Nothing :: Maybe Object.
noObject :: Maybe Object
-- | Creates a binding between sourceProperty on
-- source and targetProperty on
-- target. Whenever the sourceProperty is
-- changed the targetProperty is updated using the same
-- value. For instance:
--
--
-- g_object_bind_property (action, "active", widget, "sensitive", 0);
--
--
-- Will result in the "sensitive" property of the widget Object
-- instance to be updated with the same value of the "active" property of
-- the action Object instance.
--
-- If flags contains BindingFlagsBidirectional
-- then the binding will be mutual: if targetProperty on
-- target changes then the sourceProperty
-- on source will be updated as well.
--
-- The binding will automatically be removed when either the
-- source or the target instances are
-- finalized. To remove the binding without affecting the
-- source and the target you can just
-- call objectUnref on the returned Binding instance.
--
-- A Object can have multiple bindings.
--
-- Since: 2.26
objectBindProperty :: (HasCallStack, MonadIO m, IsObject a, IsObject b) => a -> Text -> b -> Text -> [BindingFlags] -> m Binding
-- | Creates a binding between sourceProperty on
-- source and targetProperty on
-- target, allowing you to set the transformation
-- functions to be used by the binding.
--
-- This function is the language bindings friendly version of
-- g_object_bind_property_full(), using
-- GClosures instead of function pointers.
--
-- Since: 2.26
objectBindPropertyFull :: (HasCallStack, MonadIO m, IsObject a, IsObject b) => a -> Text -> b -> Text -> [BindingFlags] -> GClosure c -> GClosure d -> m Binding
-- | No description available in the introspection data.
objectCompatControl :: (HasCallStack, MonadIO m) => Word64 -> Ptr () -> m Word64
-- | This function is intended for Object implementations to
-- re-enforce a [floating][floating-ref] object reference. Doing this is
-- seldom required: all GInitiallyUnowneds are created
-- with a floating reference which usually just needs to be sunken by
-- calling objectRefSink.
--
-- Since: 2.10
objectForceFloating :: (HasCallStack, MonadIO m, IsObject a) => a -> m ()
-- | Increases the freeze count on object. If the freeze
-- count is non-zero, the emission of "notify" signals on
-- object is stopped. The signals are queued until the
-- freeze count is decreased to zero. Duplicate notifications are
-- squashed so that at most one Object::notify
-- signal is emitted for each property modified while the object is
-- frozen.
--
-- This is necessary for accessors that modify multiple properties to
-- prevent premature notification while the object is still being
-- modified.
objectFreezeNotify :: (HasCallStack, MonadIO m, IsObject a) => a -> m ()
-- | Gets a named field from the objects table of associations (see
-- objectSetData).
objectGetData :: (HasCallStack, MonadIO m, IsObject a) => a -> Text -> m (Ptr ())
-- | Gets a property of an object. value must have been
-- initialized to the expected type of the property (or a type to which
-- the expected type can be transformed) using valueInit.
--
-- In general, a copy is made of the property contents and the caller is
-- responsible for freeing the memory by calling valueUnset.
--
-- Note that objectGetProperty is really intended for language
-- bindings, g_object_get() is much more convenient for C
-- programming.
objectGetProperty :: (HasCallStack, MonadIO m, IsObject a) => a -> Text -> GValue -> m ()
-- | This function gets back user data pointers stored via
-- g_object_set_qdata().
objectGetQdata :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> m (Ptr ())
-- | Gets nProperties properties for an
-- object. Obtained properties will be set to
-- values. All properties must be valid. Warnings will be
-- emitted and undefined behaviour may result if invalid properties are
-- passed in.
--
-- Since: 2.54
objectGetv :: (HasCallStack, MonadIO m, IsObject a) => a -> [Text] -> [GValue] -> m ()
-- | Find the ParamSpec with the given name for an interface.
-- Generally, the interface vtable passed in as gIface
-- will be the default vtable from typeDefaultInterfaceRef, or, if
-- you know the interface has already been loaded,
-- typeDefaultInterfacePeek.
--
-- Since: 2.4
objectInterfaceFindProperty :: (HasCallStack, MonadIO m) => TypeInterface -> Text -> m GParamSpec
-- | Add a property to an interface; this is only useful for interfaces
-- that are added to GObject-derived types. Adding a property to an
-- interface forces all objects classes with that interface to have a
-- compatible property. The compatible property could be a newly created
-- ParamSpec, but normally objectClassOverrideProperty will
-- be used so that the object class only needs to provide an
-- implementation and inherits the property description, default value,
-- bounds, and so forth from the interface property.
--
-- This function is meant to be called from the interface's default
-- vtable initialization function (the classInit member
-- of TypeInfo.) It must not be called after after
-- classInit has been called for any object types
-- implementing this interface.
--
-- If pspec is a floating reference, it will be consumed.
--
-- Since: 2.4
objectInterfaceInstallProperty :: (HasCallStack, MonadIO m) => TypeInterface -> GParamSpec -> m ()
-- | Checks whether object has a [floating][floating-ref]
-- reference.
--
-- Since: 2.10
objectIsFloating :: (HasCallStack, MonadIO m, IsObject a) => a -> m Bool
-- | Creates a new instance of a Object subtype and sets its
-- properties.
--
-- Construction parameters (see G_PARAM_CONSTRUCT,
-- G_PARAM_CONSTRUCT_ONLY) which are not explicitly
-- specified are set to their default values.
-- | Deprecated: (Since version 2.54)Use
-- g_object_new_with_properties() instead.deprecated. See
-- Parameter for more information.
objectNewv :: (HasCallStack, MonadIO m) => GType -> [Parameter] -> m Object
-- | Emits a "notify" signal for the property propertyName
-- on object.
--
-- When possible, eg. when signaling a property change from within the
-- class that registered the property, you should use
-- objectNotifyByPspec instead.
--
-- Note that emission of the notify signal may be blocked with
-- objectFreezeNotify. In this case, the signal emissions are
-- queued and will be emitted (in reverse order) when
-- objectThawNotify is called.
objectNotify :: (HasCallStack, MonadIO m, IsObject a) => a -> Text -> m ()
-- | Emits a "notify" signal for the property specified by
-- pspec on object.
--
-- This function omits the property name lookup, hence it is faster than
-- objectNotify.
--
-- One way to avoid using objectNotify from within the class that
-- registered the properties, and using objectNotifyByPspec
-- instead, is to store the GParamSpec used with
-- objectClassInstallProperty inside a static array, e.g.:
--
-- C code
--
--
-- enum
-- {
-- PROP_0,
-- PROP_FOO,
-- PROP_LAST
-- };
--
-- static GParamSpec *properties[PROP_LAST];
--
-- static void
-- my_object_class_init (MyObjectClass *klass)
-- {
-- properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
-- 0, 100,
-- 50,
-- G_PARAM_READWRITE);
-- g_object_class_install_property (gobject_class,
-- PROP_FOO,
-- properties[PROP_FOO]);
-- }
--
--
-- and then notify a change on the "foo" property with:
--
-- C code
--
--
-- g_object_notify_by_pspec (self, properties[PROP_FOO]);
--
--
-- Since: 2.26
objectNotifyByPspec :: (HasCallStack, MonadIO m, IsObject a) => a -> GParamSpec -> m ()
-- | Increases the reference count of object.
--
-- Since GLib 2.56, if GLIB_VERSION_MAX_ALLOWED is 2.56 or
-- greater, the type of object will be propagated to the
-- return type (using the GCC typeof() extension), so any
-- casting the caller needs to do on the return type must be explicit.
objectRef :: (HasCallStack, MonadIO m, IsObject a) => a -> m Object
-- | Increase the reference count of object, and possibly
-- remove the [floating][floating-ref] reference, if
-- object has a floating reference.
--
-- In other words, if the object is floating, then this call "assumes
-- ownership" of the floating reference, converting it to a normal
-- reference by clearing the floating flag while leaving the reference
-- count unchanged. If the object is not floating, then this call adds a
-- new normal reference increasing the reference count by one.
--
-- Since GLib 2.56, the type of object will be propagated
-- to the return type under the same conditions as for objectRef.
--
-- Since: 2.10
objectRefSink :: (HasCallStack, MonadIO m, IsObject a) => a -> m Object
-- | Releases all references to other objects. This can be used to break
-- reference cycles.
--
-- This function should only be called from object system
-- implementations.
objectRunDispose :: (HasCallStack, MonadIO m, IsObject a) => a -> m ()
-- | Each object carries around a table of associations from strings to
-- pointers. This function lets you set an association.
--
-- If the object already had an association with that name, the old
-- association will be destroyed.
objectSetData :: (HasCallStack, MonadIO m, IsObject a) => a -> Text -> Ptr () -> m ()
-- | Like objectSetData except it adds notification for when the
-- association is destroyed, either by setting it to a different value or
-- when the object is destroyed.
--
-- Note that the destroy callback is not called if
-- data is Nothing.
objectSetDataFull :: (HasCallStack, MonadIO m, IsObject a) => a -> Text -> Ptr () -> Maybe DestroyNotify -> m ()
-- | Sets a property on an object.
objectSetProperty :: (HasCallStack, MonadIO m, IsObject a) => a -> Text -> GValue -> m ()
-- | Remove a specified datum from the object's data associations, without
-- invoking the association's destroy handler.
objectStealData :: (HasCallStack, MonadIO m, IsObject a) => a -> Text -> m (Ptr ())
-- | This function gets back user data pointers stored via
-- g_object_set_qdata() and removes the
-- data from object without invoking its
-- destroy() function (if any was set). Usually, calling
-- this function is only required to update user data pointers with a
-- destroy notifier, for example:
--
-- C code
--
--
-- void
-- object_add_to_user_list (GObject *object,
-- const gchar *new_string)
-- {
-- // the quark, naming the object data
-- GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
-- // retrive the old string list
-- GList *list = g_object_steal_qdata (object, quark_string_list);
--
-- // prepend new string
-- list = g_list_prepend (list, g_strdup (new_string));
-- // this changed 'list', so we need to set it again
-- g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
-- }
-- static void
-- free_string_list (gpointer data)
-- {
-- GList *node, *list = data;
--
-- for (node = list; node; node = node->next)
-- g_free (node->data);
-- g_list_free (list);
-- }
--
--
-- Using objectGetQdata in the above example, instead of
-- objectStealQdata would have left the destroy function set, and
-- thus the partial string list would have been freed upon
-- g_object_set_qdata_full().
objectStealQdata :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> m (Ptr ())
-- | Reverts the effect of a previous call to objectFreezeNotify.
-- The freeze count is decreased on object and when it
-- reaches zero, queued "notify" signals are emitted.
--
-- Duplicate notifications for each property are squashed so that at most
-- one Object::notify signal is emitted for each
-- property, in the reverse order in which they have been queued.
--
-- It is an error to call this function when the freeze count is zero.
objectThawNotify :: (HasCallStack, MonadIO m, IsObject a) => a -> m ()
-- | Decreases the reference count of object. When its
-- reference count drops to 0, the object is finalized (i.e. its memory
-- is freed).
--
-- If the pointer to the Object may be reused in future (for
-- example, if it is an instance variable of another object), it is
-- recommended to clear the pointer to Nothing rather than retain
-- a dangling pointer to a potentially invalid Object instance.
-- Use g_clear_object() for this.
objectUnref :: (HasCallStack, MonadIO m, IsObject a) => a -> m ()
-- | This function essentially limits the life time of the
-- closure to the life time of the object. That is, when
-- the object is finalized, the closure is invalidated by
-- calling closureInvalidate on it, in order to prevent
-- invocations of the closure with a finalized (nonexisting) object.
-- Also, objectRef and objectUnref are added as marshal
-- guards to the closure, to ensure that an extra
-- reference count is held on object during invocation of
-- the closure. Usually, this function will be called on
-- closures that use this object as closure data.
objectWatchClosure :: (HasCallStack, MonadIO m, IsObject a) => a -> GClosure b -> m ()
-- | Type for the callback on the (unwrapped) C side.
type C_ObjectNotifyCallback = Ptr () -> Ptr GParamSpec -> Ptr () -> IO ()
-- | The notify signal is emitted on an object when one of its properties
-- has its value set through objectSetProperty,
-- g_object_set(), et al.
--
-- Note that getting this signal doesn’t itself guarantee that the value
-- of the property has actually changed. When it is emitted is determined
-- by the derived GObject class. If the implementor did not create the
-- property with ParamFlagsExplicitNotify, then any call to
-- objectSetProperty results in ::notify being emitted, even if
-- the new value is the same as the old. If they did pass
-- ParamFlagsExplicitNotify, then this signal is emitted only when
-- they explicitly call objectNotify or
-- objectNotifyByPspec, and common practice is to do that only
-- when the value has actually changed.
--
-- This signal is typically used to obtain change notification for a
-- single property, by specifying the property name as a detail in the
-- g_signal_connect() call, like this:
--
-- C code
--
--
-- g_signal_connect (text_view->buffer, "notify::paste-target-list",
-- G_CALLBACK (gtk_text_view_target_list_notify),
-- text_view)
--
--
-- It is important to note that you must use [canonical parameter
-- names][canonical-parameter-names] as detail strings for the notify
-- signal.
type ObjectNotifyCallback = GParamSpec " /@pspec@/: the 'GI.GObject.Objects.ParamSpec.ParamSpec' of the property which changed. " -> IO ()
-- | Connect a signal handler for the “notify” signal, to be run
-- after the default handler. When overloading is enabled, this is
-- equivalent to
--
--
-- after object #notify callback
--
afterObjectNotify :: (IsObject a, MonadIO m) => a -> ObjectNotifyCallback -> m SignalHandlerId
-- | Wrap the callback into a GClosure.
genClosure_ObjectNotify :: MonadIO m => ObjectNotifyCallback -> m (GClosure C_ObjectNotifyCallback)
-- | Generate a function pointer callable from C code, from a
-- C_ObjectNotifyCallback.
mk_ObjectNotifyCallback :: C_ObjectNotifyCallback -> IO (FunPtr C_ObjectNotifyCallback)
-- | A convenience synonym for Nothing :: Maybe
-- ObjectNotifyCallback.
noObjectNotifyCallback :: Maybe ObjectNotifyCallback
-- | Connect a signal handler for the “notify” signal, to be run
-- before the default handler. When overloading is enabled, this
-- is equivalent to
--
--
-- on object #notify callback
--
onObjectNotify :: (IsObject a, MonadIO m) => a -> ObjectNotifyCallback -> m SignalHandlerId
-- | Wrap a ObjectNotifyCallback into a
-- C_ObjectNotifyCallback.
wrap_ObjectNotifyCallback :: ObjectNotifyCallback -> C_ObjectNotifyCallback
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.Object.Object o) => GI.GObject.Objects.Object.IsObject o
instance Data.GI.Base.BasicTypes.GObject GI.GObject.Objects.Object.Object
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.Object.Object
module GI.GObject.Objects
-- | An opaque structure used as the base of all interface types.
module GI.GObject.Structs.TypeInterface
-- | Memory-managed wrapper type.
newtype TypeInterface
TypeInterface :: ManagedPtr TypeInterface -> TypeInterface
-- | Construct a TypeInterface struct initialized to zero.
newZeroTypeInterface :: MonadIO m => m TypeInterface
-- | A convenience alias for Nothing :: Maybe
-- TypeInterface.
noTypeInterface :: Maybe TypeInterface
-- | Adds prerequisiteType to the list of prerequisites of
-- interfaceType. This means that any type implementing
-- interfaceType must also implement
-- prerequisiteType. Prerequisites can be thought of as
-- an alternative to interface derivation (which GType doesn't support).
-- An interface can have at most one instantiatable prerequisite type.
typeInterfaceAddPrerequisite :: (HasCallStack, MonadIO m) => GType -> GType -> m ()
-- | Returns the TypePlugin structure for the dynamic interface
-- interfaceType which has been added to
-- instanceType, or Nothing if
-- interfaceType has not been added to
-- instanceType or does not have a TypePlugin
-- structure. See typeAddInterfaceDynamic.
typeInterfaceGetPlugin :: (HasCallStack, MonadIO m) => GType -> GType -> m TypePlugin
-- | Returns the TypeInterface structure of an interface to which
-- the passed in class conforms.
typeInterfacePeek :: (HasCallStack, MonadIO m) => TypeClass -> GType -> m TypeInterface
-- | Returns the corresponding TypeInterface structure of the parent
-- type of the instance type to which gIface belongs.
-- This is useful when deriving the implementation of an interface from
-- the parent type and then possibly overriding some methods.
typeInterfacePeekParent :: (HasCallStack, MonadIO m) => TypeInterface -> m TypeInterface
-- | Returns the prerequisites of an interfaces type.
--
-- Since: 2.2
typeInterfacePrerequisites :: (HasCallStack, MonadIO m) => GType -> m [GType]
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.TypeInterface.TypeInterface
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.TypeInterface.TypeInterface tag
-- | A structure holding information for a specific type. It is filled in
-- by the typeQuery function.
module GI.GObject.Structs.TypeQuery
-- | Memory-managed wrapper type.
newtype TypeQuery
TypeQuery :: ManagedPtr TypeQuery -> TypeQuery
-- | Construct a TypeQuery struct initialized to zero.
newZeroTypeQuery :: MonadIO m => m TypeQuery
-- | A convenience alias for Nothing :: Maybe
-- TypeQuery.
noTypeQuery :: Maybe TypeQuery
-- | Get the value of the “class_size” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeQuery #classSize
--
getTypeQueryClassSize :: MonadIO m => TypeQuery -> m Word32
-- | Set the value of the “class_size” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeQuery [ #classSize := value ]
--
setTypeQueryClassSize :: MonadIO m => TypeQuery -> Word32 -> m ()
-- | Get the value of the “instance_size” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeQuery #instanceSize
--
getTypeQueryInstanceSize :: MonadIO m => TypeQuery -> m Word32
-- | Set the value of the “instance_size” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeQuery [ #instanceSize := value ]
--
setTypeQueryInstanceSize :: MonadIO m => TypeQuery -> Word32 -> m ()
-- | Get the value of the “type” field. When overloading is
-- enabled, this is equivalent to
--
--
-- get typeQuery #type
--
getTypeQueryType :: MonadIO m => TypeQuery -> m GType
-- | Set the value of the “type” field. When overloading is
-- enabled, this is equivalent to
--
--
-- set typeQuery [ #type := value ]
--
setTypeQueryType :: MonadIO m => TypeQuery -> GType -> m ()
-- | Set the value of the “type_name” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #typeName
--
clearTypeQueryTypeName :: MonadIO m => TypeQuery -> m ()
-- | Get the value of the “type_name” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeQuery #typeName
--
getTypeQueryTypeName :: MonadIO m => TypeQuery -> m (Maybe Text)
-- | Set the value of the “type_name” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeQuery [ #typeName := value ]
--
setTypeQueryTypeName :: MonadIO m => TypeQuery -> CString -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.TypeQuery.TypeQuery
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.TypeQuery.TypeQuery tag
-- | The GObject type system supports dynamic loading of types. The
-- TypePlugin interface is used to handle the lifecycle of
-- dynamically loaded types. It goes as follows:
--
--
-- - The type is initially introduced (usually upon loading the module
-- the first time, or by your main application that knows what modules
-- introduces what types), like this:
--
--
-- C code
--
--
-- new_type_id = g_type_register_dynamic (parent_type_id,
-- "TypeName",
-- new_type_plugin,
-- type_flags);
--
--
--
-- where newTypePlugin is an implementation of the
-- TypePlugin interface.
--
--
-- - The type's implementation is referenced, e.g. through
-- typeClassRef or through
-- g_type_create_instance() (this is being called by
-- g_object_new()) or through one of the above done on a
-- type derived from newTypeId.
-- - This causes the type system to load the type's implementation by
-- calling typePluginUse and typePluginCompleteTypeInfo on
-- newTypePlugin.
-- - At some point the type's implementation isn't required anymore,
-- e.g. after typeClassUnref or typeFreeInstance (called
-- when the reference count of an instance drops to zero).
-- - This causes the type system to throw away the information
-- retrieved from typePluginCompleteTypeInfo and then it calls
-- typePluginUnuse on newTypePlugin.
-- - Things may repeat from the second step.
--
--
-- So basically, you need to implement a TypePlugin type that
-- carries a use_count, once use_count goes from zero to one, you need to
-- load the implementation to successfully handle the upcoming
-- typePluginCompleteTypeInfo call. Later, maybe after succeeding
-- use/unuse calls, once use_count drops to zero, you can unload the
-- implementation again. The type system makes sure to call
-- typePluginUse and typePluginCompleteTypeInfo again when
-- the type is needed again.
--
-- TypeModule is an implementation of TypePlugin that
-- already implements most of this except for the actual module loading
-- and unloading. It even handles multiple registered types per module.
module GI.GObject.Interfaces.TypePlugin
-- | Memory-managed wrapper type.
newtype TypePlugin
TypePlugin :: ManagedPtr TypePlugin -> TypePlugin
-- | A convenience alias for Nothing :: Maybe
-- TypePlugin.
noTypePlugin :: Maybe TypePlugin
-- | Type class for types which implement TypePlugin.
class (ManagedPtrNewtype o, IsDescendantOf TypePlugin o) => IsTypePlugin o
-- | Calls the completeInterfaceInfo function from the
-- GTypePluginClass of plugin. There
-- should be no need to use this function outside of the GObject type
-- system itself.
typePluginCompleteInterfaceInfo :: (HasCallStack, MonadIO m, IsTypePlugin a) => a -> GType -> GType -> InterfaceInfo -> m ()
-- | Calls the completeTypeInfo function from the
-- GTypePluginClass of plugin. There
-- should be no need to use this function outside of the GObject type
-- system itself.
typePluginCompleteTypeInfo :: (HasCallStack, MonadIO m, IsTypePlugin a) => a -> GType -> TypeInfo -> TypeValueTable -> m ()
-- | Calls the unusePlugin function from the
-- GTypePluginClass of plugin. There
-- should be no need to use this function outside of the GObject type
-- system itself.
typePluginUnuse :: (HasCallStack, MonadIO m, IsTypePlugin a) => a -> m ()
-- | Calls the usePlugin function from the
-- GTypePluginClass of plugin. There
-- should be no need to use this function outside of the GObject type
-- system itself.
typePluginUse :: (HasCallStack, MonadIO m, IsTypePlugin a) => a -> m ()
instance (Data.GI.Base.BasicTypes.ManagedPtrNewtype o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Interfaces.TypePlugin.TypePlugin o) => GI.GObject.Interfaces.TypePlugin.IsTypePlugin o
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Interfaces.TypePlugin.TypePlugin
module GI.GObject.Interfaces
-- | A ValueArray contains an array of Value elements.
module GI.GObject.Structs.ValueArray
-- | Memory-managed wrapper type.
newtype ValueArray
ValueArray :: ManagedPtr ValueArray -> ValueArray
-- | Construct a ValueArray struct initialized to zero.
newZeroValueArray :: MonadIO m => m ValueArray
-- | A convenience alias for Nothing :: Maybe
-- ValueArray.
noValueArray :: Maybe ValueArray
-- | Insert a copy of value as last element of
-- valueArray. If value is
-- Nothing, an uninitialized value is appended.
-- | Deprecated: (Since version 2.32)Use Array and
-- g_array_append_val() instead.
valueArrayAppend :: (HasCallStack, MonadIO m) => ValueArray -> Maybe GValue -> m ValueArray
-- | Construct an exact copy of a ValueArray by duplicating all its
-- contents.
-- | Deprecated: (Since version 2.32)Use Array and
-- g_array_ref() instead.
valueArrayCopy :: (HasCallStack, MonadIO m) => ValueArray -> m ValueArray
-- | Return a pointer to the value at index_ containd in
-- valueArray.
-- | Deprecated: (Since version 2.32)Use g_array_index()
-- instead.
valueArrayGetNth :: (HasCallStack, MonadIO m) => ValueArray -> Word32 -> m GValue
-- | Insert a copy of value at specified position into
-- valueArray. If value is
-- Nothing, an uninitialized value is inserted.
-- | Deprecated: (Since version 2.32)Use Array and
-- g_array_insert_val() instead.
valueArrayInsert :: (HasCallStack, MonadIO m) => ValueArray -> Word32 -> Maybe GValue -> m ValueArray
-- | Allocate and initialize a new ValueArray, optionally preserve
-- space for nPrealloced elements. New arrays always
-- contain 0 elements, regardless of the value of
-- nPrealloced.
-- | Deprecated: (Since version 2.32)Use Array and
-- g_array_sized_new() instead.
valueArrayNew :: (HasCallStack, MonadIO m) => Word32 -> m ValueArray
-- | Insert a copy of value as first element of
-- valueArray. If value is
-- Nothing, an uninitialized value is prepended.
-- | Deprecated: (Since version 2.32)Use Array and
-- g_array_prepend_val() instead.
valueArrayPrepend :: (HasCallStack, MonadIO m) => ValueArray -> Maybe GValue -> m ValueArray
-- | Remove the value at position index_ from
-- valueArray.
-- | Deprecated: (Since version 2.32)Use Array and
-- g_array_remove_index() instead.
valueArrayRemove :: (HasCallStack, MonadIO m) => ValueArray -> Word32 -> m ValueArray
-- | Sort valueArray using compareFunc to
-- compare the elements according to the semantics of
-- CompareDataFunc.
--
-- The current implementation uses the same sorting algorithm as standard
-- C qsort() function.
-- | Deprecated: (Since version 2.32)Use Array and
-- g_array_sort_with_data().
valueArraySort :: (HasCallStack, MonadIO m) => ValueArray -> CompareDataFunc -> m ValueArray
-- | Get the value of the “n_values” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get valueArray #nValues
--
getValueArrayNValues :: MonadIO m => ValueArray -> m Word32
-- | Set the value of the “n_values” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set valueArray [ #nValues := value ]
--
setValueArrayNValues :: MonadIO m => ValueArray -> Word32 -> m ()
-- | Set the value of the “values” field to Nothing. When
-- overloading is enabled, this is equivalent to
--
--
-- clear #values
--
clearValueArrayValues :: MonadIO m => ValueArray -> m ()
-- | Get the value of the “values” field. When overloading
-- is enabled, this is equivalent to
--
--
-- get valueArray #values
--
getValueArrayValues :: MonadIO m => ValueArray -> m (Maybe GValue)
-- | Set the value of the “values” field. When overloading
-- is enabled, this is equivalent to
--
--
-- set valueArray [ #values := value ]
--
setValueArrayValues :: MonadIO m => ValueArray -> Ptr GValue -> m ()
instance Data.GI.Base.BasicTypes.BoxedObject GI.GObject.Structs.ValueArray.ValueArray
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.ValueArray.ValueArray tag
-- | A structure containing a weak reference to a Object. It can
-- either be empty (i.e. point to Nothing), or point to an object
-- for as long as at least one "strong" reference to that object exists.
-- Before the object's ObjectClass.dispose method
-- is called, every WeakRef associated with becomes empty (i.e.
-- points to Nothing).
--
-- Like Value, WeakRef can be statically allocated, stack-
-- or heap-allocated, or embedded in larger structures.
--
-- Unlike g_object_weak_ref() and
-- g_object_add_weak_pointer(), this weak reference is
-- thread-safe: converting a weak pointer to a reference is atomic with
-- respect to invalidation of weak pointers to destroyed objects.
--
-- If the object's ObjectClass.dispose method
-- results in additional references to the object being held, any
-- GWeakRefs taken before it was disposed will continue
-- to point to Nothing. If GWeakRefs are taken
-- after the object is disposed and re-referenced, they will continue to
-- point to it until its refcount goes back to zero, at which point they
-- too will be invalidated.
module GI.GObject.Structs.WeakRef
-- | Memory-managed wrapper type.
newtype WeakRef
WeakRef :: ManagedPtr WeakRef -> WeakRef
-- | A convenience alias for Nothing :: Maybe WeakRef.
noWeakRef :: Maybe WeakRef
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.WeakRef.WeakRef
module GI.GObject.Callbacks
-- | A callback function used by the type system to finalize those portions
-- of a derived types class structure that were setup from the
-- corresponding GBaseInitFunc() function. Class
-- finalization basically works the inverse way in which class
-- initialization is performed. See GClassInitFunc() for
-- a discussion of the class initialization process.
type BaseFinalizeFunc = TypeClass " /@gClass@/: The 'GI.GObject.Structs.TypeClass.TypeClass' structure to finalize " -> IO ()
-- | Type for the callback on the (unwrapped) C side.
type C_BaseFinalizeFunc = Ptr TypeClass -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_BaseFinalizeFunc :: (HasCallStack, MonadIO m) => FunPtr C_BaseFinalizeFunc -> TypeClass -> m ()
-- | Wrap the callback into a GClosure.
genClosure_BaseFinalizeFunc :: MonadIO m => BaseFinalizeFunc -> m (GClosure C_BaseFinalizeFunc)
-- | Generate a function pointer callable from C code, from a
-- C_BaseFinalizeFunc.
mk_BaseFinalizeFunc :: C_BaseFinalizeFunc -> IO (FunPtr C_BaseFinalizeFunc)
-- | A convenience synonym for Nothing :: Maybe
-- BaseFinalizeFunc.
noBaseFinalizeFunc :: Maybe BaseFinalizeFunc
-- | Wrap a BaseFinalizeFunc into a C_BaseFinalizeFunc.
wrap_BaseFinalizeFunc :: Maybe (Ptr (FunPtr C_BaseFinalizeFunc)) -> BaseFinalizeFunc -> C_BaseFinalizeFunc
-- | A callback function used by the type system to do base initialization
-- of the class structures of derived types. It is called as part of the
-- initialization process of all derived classes and should reallocate or
-- reset all dynamic class members copied over from the parent class. For
-- example, class members (such as strings) that are not sufficiently
-- handled by a plain memory copy of the parent class into the derived
-- class have to be altered. See GClassInitFunc() for a
-- discussion of the class initialization process.
type BaseInitFunc = TypeClass " /@gClass@/: The 'GI.GObject.Structs.TypeClass.TypeClass' structure to initialize " -> IO ()
-- | Type for the callback on the (unwrapped) C side.
type C_BaseInitFunc = Ptr TypeClass -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_BaseInitFunc :: (HasCallStack, MonadIO m) => FunPtr C_BaseInitFunc -> TypeClass -> m ()
-- | Wrap the callback into a GClosure.
genClosure_BaseInitFunc :: MonadIO m => BaseInitFunc -> m (GClosure C_BaseInitFunc)
-- | Generate a function pointer callable from C code, from a
-- C_BaseInitFunc.
mk_BaseInitFunc :: C_BaseInitFunc -> IO (FunPtr C_BaseInitFunc)
-- | A convenience synonym for Nothing :: Maybe
-- BaseInitFunc.
noBaseInitFunc :: Maybe BaseInitFunc
-- | Wrap a BaseInitFunc into a C_BaseInitFunc.
wrap_BaseInitFunc :: Maybe (Ptr (FunPtr C_BaseInitFunc)) -> BaseInitFunc -> C_BaseInitFunc
-- | A function to be called to transform fromValue to
-- toValue. If this is the transformTo
-- function of a binding, then fromValue is the
-- sourceProperty on the source object,
-- and toValue is the targetProperty on
-- the target object. If this is the
-- transformFrom function of a
-- BindingFlagsBidirectional binding, then those roles are
-- reversed.
--
-- Since: 2.26
type BindingTransformFunc = Binding " /@binding@/: a 'GI.GObject.Objects.Binding.Binding' " -> GValue " /@fromValue@/: the 'GI.GObject.Structs.Value.Value' containing the value to transform " -> GValue " /@toValue@/: the 'GI.GObject.Structs.Value.Value' in which to store the transformed value " -> IO Bool " __Returns:__ 'True' if the transformation was successful, and 'False' otherwise "
-- | A function to be called to transform fromValue to
-- toValue. If this is the transformTo
-- function of a binding, then fromValue is the
-- sourceProperty on the source object,
-- and toValue is the targetProperty on
-- the target object. If this is the
-- transformFrom function of a
-- BindingFlagsBidirectional binding, then those roles are
-- reversed.
--
-- Since: 2.26
type BindingTransformFunc_WithClosures = Binding " /@binding@/: a 'GI.GObject.Objects.Binding.Binding' " -> GValue " /@fromValue@/: the 'GI.GObject.Structs.Value.Value' containing the value to transform " -> GValue " /@toValue@/: the 'GI.GObject.Structs.Value.Value' in which to store the transformed value " -> Ptr () " /@userData@/: data passed to the transform function " -> IO Bool " __Returns:__ 'True' if the transformation was successful, and 'False' otherwise "
-- | Type for the callback on the (unwrapped) C side.
type C_BindingTransformFunc = Ptr Binding -> Ptr GValue -> Ptr GValue -> Ptr () -> IO CInt
-- | A simple wrapper that ignores the closure arguments.
drop_closures_BindingTransformFunc :: BindingTransformFunc -> BindingTransformFunc_WithClosures
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_BindingTransformFunc :: (HasCallStack, MonadIO m, IsBinding a) => FunPtr C_BindingTransformFunc -> a -> GValue -> GValue -> Ptr () -> m Bool
-- | Wrap the callback into a GClosure.
genClosure_BindingTransformFunc :: MonadIO m => BindingTransformFunc -> m (GClosure C_BindingTransformFunc)
-- | Generate a function pointer callable from C code, from a
-- C_BindingTransformFunc.
mk_BindingTransformFunc :: C_BindingTransformFunc -> IO (FunPtr C_BindingTransformFunc)
-- | A convenience synonym for Nothing :: Maybe
-- BindingTransformFunc.
noBindingTransformFunc :: Maybe BindingTransformFunc
-- | A convenience synonym for Nothing :: Maybe
-- BindingTransformFunc_WithClosures.
noBindingTransformFunc_WithClosures :: Maybe BindingTransformFunc_WithClosures
-- | Wrap a BindingTransformFunc into a
-- C_BindingTransformFunc.
wrap_BindingTransformFunc :: Maybe (Ptr (FunPtr C_BindingTransformFunc)) -> BindingTransformFunc_WithClosures -> C_BindingTransformFunc
-- | This function is provided by the user and should produce a copy of the
-- passed in boxed structure.
type BoxedCopyFunc = Ptr () " /@boxed@/: The boxed structure to be copied. " -> IO (Ptr ()) " __Returns:__ The newly created copy of the boxed structure. "
-- | Type for the callback on the (unwrapped) C side.
type C_BoxedCopyFunc = Ptr () -> IO (Ptr ())
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_BoxedCopyFunc :: (HasCallStack, MonadIO m) => FunPtr C_BoxedCopyFunc -> Ptr () -> m (Ptr ())
-- | Wrap the callback into a GClosure.
genClosure_BoxedCopyFunc :: MonadIO m => BoxedCopyFunc -> m (GClosure C_BoxedCopyFunc)
-- | Generate a function pointer callable from C code, from a
-- C_BoxedCopyFunc.
mk_BoxedCopyFunc :: C_BoxedCopyFunc -> IO (FunPtr C_BoxedCopyFunc)
-- | A convenience synonym for Nothing :: Maybe
-- BoxedCopyFunc.
noBoxedCopyFunc :: Maybe BoxedCopyFunc
-- | Wrap a BoxedCopyFunc into a C_BoxedCopyFunc.
wrap_BoxedCopyFunc :: Maybe (Ptr (FunPtr C_BoxedCopyFunc)) -> BoxedCopyFunc -> C_BoxedCopyFunc
-- | This function is provided by the user and should free the boxed
-- structure passed.
type BoxedFreeFunc = Ptr () " /@boxed@/: The boxed structure to be freed. " -> IO ()
-- | Type for the callback on the (unwrapped) C side.
type C_BoxedFreeFunc = Ptr () -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_BoxedFreeFunc :: (HasCallStack, MonadIO m) => FunPtr C_BoxedFreeFunc -> Ptr () -> m ()
-- | Wrap the callback into a GClosure.
genClosure_BoxedFreeFunc :: MonadIO m => BoxedFreeFunc -> m (GClosure C_BoxedFreeFunc)
-- | Generate a function pointer callable from C code, from a
-- C_BoxedFreeFunc.
mk_BoxedFreeFunc :: C_BoxedFreeFunc -> IO (FunPtr C_BoxedFreeFunc)
-- | A convenience synonym for Nothing :: Maybe
-- BoxedFreeFunc.
noBoxedFreeFunc :: Maybe BoxedFreeFunc
-- | Wrap a BoxedFreeFunc into a C_BoxedFreeFunc.
wrap_BoxedFreeFunc :: Maybe (Ptr (FunPtr C_BoxedFreeFunc)) -> BoxedFreeFunc -> C_BoxedFreeFunc
-- | Type for the callback on the (unwrapped) C side.
type C_Callback = IO ()
-- | The type used for callback functions in structure definitions and
-- function signatures. This doesn't mean that all callback functions
-- must take no parameters and return void. The required signature of a
-- callback function is determined by the context in which is used (e.g.
-- the signal to which it is connected). Use G_CALLBACK()
-- to cast the callback function to a Callback.
type Callback = IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_Callback :: (HasCallStack, MonadIO m) => FunPtr C_Callback -> m ()
-- | Wrap the callback into a GClosure.
genClosure_Callback :: MonadIO m => Callback -> m (GClosure C_Callback)
-- | Generate a function pointer callable from C code, from a
-- C_Callback.
mk_Callback :: C_Callback -> IO (FunPtr C_Callback)
-- | A convenience synonym for Nothing :: Maybe
-- Callback.
noCallback :: Maybe Callback
-- | Wrap a Callback into a C_Callback.
wrap_Callback :: Maybe (Ptr (FunPtr C_Callback)) -> Callback -> C_Callback
-- | Type for the callback on the (unwrapped) C side.
type C_ClassFinalizeFunc = Ptr TypeClass -> Ptr () -> IO ()
-- | A callback function used by the type system to finalize a class. This
-- function is rarely needed, as dynamically allocated class resources
-- should be handled by GBaseInitFunc() and
-- GBaseFinalizeFunc(). Also, specification of a
-- GClassFinalizeFunc() in the TypeInfo structure
-- of a static type is invalid, because classes of static types will
-- never be finalized (they are artificially kept alive when their
-- reference count drops to zero).
type ClassFinalizeFunc = TypeClass " /@gClass@/: The 'GI.GObject.Structs.TypeClass.TypeClass' structure to finalize " -> Ptr () " /@classData@/: The /@classData@/ member supplied via the 'GI.GObject.Structs.TypeInfo.TypeInfo' structure " -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_ClassFinalizeFunc :: (HasCallStack, MonadIO m) => FunPtr C_ClassFinalizeFunc -> TypeClass -> Ptr () -> m ()
-- | Wrap the callback into a GClosure.
genClosure_ClassFinalizeFunc :: MonadIO m => ClassFinalizeFunc -> m (GClosure C_ClassFinalizeFunc)
-- | Generate a function pointer callable from C code, from a
-- C_ClassFinalizeFunc.
mk_ClassFinalizeFunc :: C_ClassFinalizeFunc -> IO (FunPtr C_ClassFinalizeFunc)
-- | A convenience synonym for Nothing :: Maybe
-- ClassFinalizeFunc.
noClassFinalizeFunc :: Maybe ClassFinalizeFunc
-- | Wrap a ClassFinalizeFunc into a C_ClassFinalizeFunc.
wrap_ClassFinalizeFunc :: Maybe (Ptr (FunPtr C_ClassFinalizeFunc)) -> ClassFinalizeFunc -> C_ClassFinalizeFunc
-- | Type for the callback on the (unwrapped) C side.
type C_ClassInitFunc = Ptr TypeClass -> Ptr () -> IO ()
-- | A callback function used by the type system to initialize the class of
-- a specific type. This function should initialize all static class
-- members.
--
-- The initialization process of a class involves:
--
--
-- - Copying common members from the parent class over to the derived
-- class structure.
-- - Zero initialization of the remaining members not copied over from
-- the parent class.
-- - Invocation of the GBaseInitFunc() initializers of
-- all parent types and the class' type.
-- - Invocation of the class' GClassInitFunc()
-- initializer.
--
--
-- Since derived classes are partially initialized through a memory copy
-- of the parent class, the general rule is that
-- GBaseInitFunc() and
-- GBaseFinalizeFunc() should take care of necessary
-- reinitialization and release of those class members that were
-- introduced by the type that specified these
-- GBaseInitFunc()/GBaseFinalizeFunc().
-- GClassInitFunc() should only care about initializing
-- static class members, while dynamic class members (such as allocated
-- strings or reference counted resources) are better handled by a
-- GBaseInitFunc() for this type, so proper
-- initialization of the dynamic class members is performed for class
-- initialization of derived types as well.
--
-- An example may help to correspond the intend of the different class
-- initializers:
--
-- C code
--
--
-- typedef struct {
-- GObjectClass parent_class;
-- gint static_integer;
-- gchar *dynamic_string;
-- } TypeAClass;
-- static void
-- type_a_base_class_init (TypeAClass *class)
-- {
-- class->dynamic_string = g_strdup ("some string");
-- }
-- static void
-- type_a_base_class_finalize (TypeAClass *class)
-- {
-- g_free (class->dynamic_string);
-- }
-- static void
-- type_a_class_init (TypeAClass *class)
-- {
-- class->static_integer = 42;
-- }
--
-- typedef struct {
-- TypeAClass parent_class;
-- gfloat static_float;
-- GString *dynamic_gstring;
-- } TypeBClass;
-- static void
-- type_b_base_class_init (TypeBClass *class)
-- {
-- class->dynamic_gstring = g_string_new ("some other string");
-- }
-- static void
-- type_b_base_class_finalize (TypeBClass *class)
-- {
-- g_string_free (class->dynamic_gstring);
-- }
-- static void
-- type_b_class_init (TypeBClass *class)
-- {
-- class->static_float = 3.14159265358979323846;
-- }
--
--
-- Initialization of TypeBClass will first cause initialization of
-- TypeAClass (derived classes reference their parent classes, see
-- typeClassRef on this).
--
-- Initialization of TypeAClass roughly involves zero-initializing its
-- fields, then calling its GBaseInitFunc()
-- type_a_base_class_init() to allocate its dynamic
-- members (dynamic_string), and finally calling its
-- GClassInitFunc() type_a_class_init()
-- to initialize its static members (static_integer). The first step in
-- the initialization process of TypeBClass is then a plain memory copy
-- of the contents of TypeAClass into TypeBClass and zero-initialization
-- of the remaining fields in TypeBClass. The dynamic members of
-- TypeAClass within TypeBClass now need reinitialization which is
-- performed by calling type_a_base_class_init() with an
-- argument of TypeBClass.
--
-- After that, the GBaseInitFunc() of TypeBClass,
-- type_b_base_class_init() is called to allocate the
-- dynamic members of TypeBClass (dynamic_gstring), and finally the
-- GClassInitFunc() of TypeBClass,
-- type_b_class_init(), is called to complete the
-- initialization process with the static members (static_float).
--
-- Corresponding finalization counter parts to the
-- GBaseInitFunc() functions have to be provided to
-- release allocated resources at class finalization time.
type ClassInitFunc = TypeClass " /@gClass@/: The 'GI.GObject.Structs.TypeClass.TypeClass' structure to initialize. " -> Ptr () " /@classData@/: The /@classData@/ member supplied via the 'GI.GObject.Structs.TypeInfo.TypeInfo' structure. " -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_ClassInitFunc :: (HasCallStack, MonadIO m) => FunPtr C_ClassInitFunc -> TypeClass -> Ptr () -> m ()
-- | Wrap the callback into a GClosure.
genClosure_ClassInitFunc :: MonadIO m => ClassInitFunc -> m (GClosure C_ClassInitFunc)
-- | Generate a function pointer callable from C code, from a
-- C_ClassInitFunc.
mk_ClassInitFunc :: C_ClassInitFunc -> IO (FunPtr C_ClassInitFunc)
-- | A convenience synonym for Nothing :: Maybe
-- ClassInitFunc.
noClassInitFunc :: Maybe ClassInitFunc
-- | Wrap a ClassInitFunc into a C_ClassInitFunc.
wrap_ClassInitFunc :: Maybe (Ptr (FunPtr C_ClassInitFunc)) -> ClassInitFunc -> C_ClassInitFunc
-- | Type for the callback on the (unwrapped) C side.
type C_ClosureMarshalFieldCallback = Ptr (GClosure ()) -> Ptr GValue -> Word32 -> Ptr GValue -> Ptr () -> Ptr () -> IO ()
-- | No description available in the introspection data.
type ClosureMarshalFieldCallback = GClosure () -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_ClosureMarshalFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ClosureMarshalFieldCallback -> GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
-- | Wrap the callback into a GClosure.
genClosure_ClosureMarshalFieldCallback :: MonadIO m => ClosureMarshalFieldCallback -> m (GClosure C_ClosureMarshalFieldCallback)
-- | Generate a function pointer callable from C code, from a
-- C_ClosureMarshalFieldCallback.
mk_ClosureMarshalFieldCallback :: C_ClosureMarshalFieldCallback -> IO (FunPtr C_ClosureMarshalFieldCallback)
-- | A convenience synonym for Nothing :: Maybe
-- ClosureMarshalFieldCallback.
noClosureMarshalFieldCallback :: Maybe ClosureMarshalFieldCallback
-- | Wrap a ClosureMarshalFieldCallback into a
-- C_ClosureMarshalFieldCallback.
wrap_ClosureMarshalFieldCallback :: Maybe (Ptr (FunPtr C_ClosureMarshalFieldCallback)) -> ClosureMarshalFieldCallback -> C_ClosureMarshalFieldCallback
-- | Type for the callback on the (unwrapped) C side.
type C_ClosureNotify = Ptr () -> Ptr (GClosure ()) -> IO ()
-- | The type used for the various notification callbacks which can be
-- registered on closures.
type ClosureNotify = Ptr () " /@data@/: data specified when registering the notification callback " -> GClosure () " /@closure@/: the 'GI.GObject.Structs.Closure.Closure' on which the notification is emitted " -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_ClosureNotify :: (HasCallStack, MonadIO m) => FunPtr C_ClosureNotify -> Ptr () -> GClosure a -> m ()
-- | Wrap the callback into a GClosure.
genClosure_ClosureNotify :: MonadIO m => ClosureNotify -> m (GClosure C_ClosureNotify)
-- | Generate a function pointer callable from C code, from a
-- C_ClosureNotify.
mk_ClosureNotify :: C_ClosureNotify -> IO (FunPtr C_ClosureNotify)
-- | A convenience synonym for Nothing :: Maybe
-- ClosureNotify.
noClosureNotify :: Maybe ClosureNotify
-- | Wrap a ClosureNotify into a C_ClosureNotify.
wrap_ClosureNotify :: Maybe (Ptr (FunPtr C_ClosureNotify)) -> ClosureNotify -> C_ClosureNotify
-- | Type for the callback on the (unwrapped) C side.
type C_InstanceInitFunc = Ptr TypeInstance -> Ptr TypeClass -> IO ()
-- | A callback function used by the type system to initialize a new
-- instance of a type. This function initializes all instance members and
-- allocates any resources required by it.
--
-- Initialization of a derived instance involves calling all its parent
-- types instance initializers, so the class member of the instance is
-- altered during its initialization to always point to the class that
-- belongs to the type the current initializer was introduced for.
--
-- The extended members of instance are guaranteed to
-- have been filled with zeros before this function is called.
type InstanceInitFunc = TypeInstance " /@instance@/: The instance to initialize " -> TypeClass " /@gClass@/: The class of the type the instance is created for " -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_InstanceInitFunc :: (HasCallStack, MonadIO m) => FunPtr C_InstanceInitFunc -> TypeInstance -> TypeClass -> m ()
-- | Wrap the callback into a GClosure.
genClosure_InstanceInitFunc :: MonadIO m => InstanceInitFunc -> m (GClosure C_InstanceInitFunc)
-- | Generate a function pointer callable from C code, from a
-- C_InstanceInitFunc.
mk_InstanceInitFunc :: C_InstanceInitFunc -> IO (FunPtr C_InstanceInitFunc)
-- | A convenience synonym for Nothing :: Maybe
-- InstanceInitFunc.
noInstanceInitFunc :: Maybe InstanceInitFunc
-- | Wrap a InstanceInitFunc into a C_InstanceInitFunc.
wrap_InstanceInitFunc :: Maybe (Ptr (FunPtr C_InstanceInitFunc)) -> InstanceInitFunc -> C_InstanceInitFunc
-- | Type for the callback on the (unwrapped) C side.
type C_InterfaceFinalizeFunc = Ptr TypeInterface -> Ptr () -> IO ()
-- | A callback function used by the type system to finalize an interface.
-- This function should destroy any internal data and release any
-- resources allocated by the corresponding
-- GInterfaceInitFunc() function.
type InterfaceFinalizeFunc = TypeInterface " /@gIface@/: The interface structure to finalize " -> Ptr () " /@ifaceData@/: The /@interfaceData@/ supplied via the 'GI.GObject.Structs.InterfaceInfo.InterfaceInfo' structure " -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_InterfaceFinalizeFunc :: (HasCallStack, MonadIO m) => FunPtr C_InterfaceFinalizeFunc -> TypeInterface -> Ptr () -> m ()
-- | Wrap the callback into a GClosure.
genClosure_InterfaceFinalizeFunc :: MonadIO m => InterfaceFinalizeFunc -> m (GClosure C_InterfaceFinalizeFunc)
-- | Generate a function pointer callable from C code, from a
-- C_InterfaceFinalizeFunc.
mk_InterfaceFinalizeFunc :: C_InterfaceFinalizeFunc -> IO (FunPtr C_InterfaceFinalizeFunc)
-- | A convenience synonym for Nothing :: Maybe
-- InterfaceFinalizeFunc.
noInterfaceFinalizeFunc :: Maybe InterfaceFinalizeFunc
-- | Wrap a InterfaceFinalizeFunc into a
-- C_InterfaceFinalizeFunc.
wrap_InterfaceFinalizeFunc :: Maybe (Ptr (FunPtr C_InterfaceFinalizeFunc)) -> InterfaceFinalizeFunc -> C_InterfaceFinalizeFunc
-- | Type for the callback on the (unwrapped) C side.
type C_InterfaceInitFunc = Ptr TypeInterface -> Ptr () -> IO ()
-- | A callback function used by the type system to initialize a new
-- interface. This function should initialize all internal data and
-- allocate any resources required by the interface.
--
-- The members of ifaceData are guaranteed to have been
-- filled with zeros before this function is called.
type InterfaceInitFunc = TypeInterface " /@gIface@/: The interface structure to initialize " -> Ptr () " /@ifaceData@/: The /@interfaceData@/ supplied via the 'GI.GObject.Structs.InterfaceInfo.InterfaceInfo' structure " -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_InterfaceInitFunc :: (HasCallStack, MonadIO m) => FunPtr C_InterfaceInitFunc -> TypeInterface -> Ptr () -> m ()
-- | Wrap the callback into a GClosure.
genClosure_InterfaceInitFunc :: MonadIO m => InterfaceInitFunc -> m (GClosure C_InterfaceInitFunc)
-- | Generate a function pointer callable from C code, from a
-- C_InterfaceInitFunc.
mk_InterfaceInitFunc :: C_InterfaceInitFunc -> IO (FunPtr C_InterfaceInitFunc)
-- | A convenience synonym for Nothing :: Maybe
-- InterfaceInitFunc.
noInterfaceInitFunc :: Maybe InterfaceInitFunc
-- | Wrap a InterfaceInitFunc into a C_InterfaceInitFunc.
wrap_InterfaceInitFunc :: Maybe (Ptr (FunPtr C_InterfaceInitFunc)) -> InterfaceInitFunc -> C_InterfaceInitFunc
-- | Type for the callback on the (unwrapped) C side.
type C_ObjectFinalizeFunc = Ptr Object -> IO ()
-- | The type of the finalize function of
-- ObjectClass.
type ObjectFinalizeFunc = Object " /@object@/: the 'GI.GObject.Objects.Object.Object' being finalized " -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_ObjectFinalizeFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectFinalizeFunc -> a -> m ()
-- | Wrap the callback into a GClosure.
genClosure_ObjectFinalizeFunc :: MonadIO m => ObjectFinalizeFunc -> m (GClosure C_ObjectFinalizeFunc)
-- | Generate a function pointer callable from C code, from a
-- C_ObjectFinalizeFunc.
mk_ObjectFinalizeFunc :: C_ObjectFinalizeFunc -> IO (FunPtr C_ObjectFinalizeFunc)
-- | A convenience synonym for Nothing :: Maybe
-- ObjectFinalizeFunc.
noObjectFinalizeFunc :: Maybe ObjectFinalizeFunc
-- | Wrap a ObjectFinalizeFunc into a C_ObjectFinalizeFunc.
wrap_ObjectFinalizeFunc :: Maybe (Ptr (FunPtr C_ObjectFinalizeFunc)) -> ObjectFinalizeFunc -> C_ObjectFinalizeFunc
-- | Type for the callback on the (unwrapped) C side.
type C_ObjectGetPropertyFunc = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()
-- | The type of the getProperty function of
-- ObjectClass.
type ObjectGetPropertyFunc = Object " /@object@/: a 'GI.GObject.Objects.Object.Object' " -> Word32 " /@propertyId@/: the numeric id under which the property was registered with 'GI.GObject.Structs.ObjectClass.objectClassInstallProperty'. " -> GValue " /@value@/: a 'GI.GObject.Structs.Value.Value' to return the property value in " -> GParamSpec " /@pspec@/: the 'GI.GObject.Objects.ParamSpec.ParamSpec' describing the property " -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_ObjectGetPropertyFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectGetPropertyFunc -> a -> Word32 -> GValue -> GParamSpec -> m ()
-- | Wrap the callback into a GClosure.
genClosure_ObjectGetPropertyFunc :: MonadIO m => ObjectGetPropertyFunc -> m (GClosure C_ObjectGetPropertyFunc)
-- | Generate a function pointer callable from C code, from a
-- C_ObjectGetPropertyFunc.
mk_ObjectGetPropertyFunc :: C_ObjectGetPropertyFunc -> IO (FunPtr C_ObjectGetPropertyFunc)
-- | A convenience synonym for Nothing :: Maybe
-- ObjectGetPropertyFunc.
noObjectGetPropertyFunc :: Maybe ObjectGetPropertyFunc
-- | Wrap a ObjectGetPropertyFunc into a
-- C_ObjectGetPropertyFunc.
wrap_ObjectGetPropertyFunc :: Maybe (Ptr (FunPtr C_ObjectGetPropertyFunc)) -> ObjectGetPropertyFunc -> C_ObjectGetPropertyFunc
-- | Type for the callback on the (unwrapped) C side.
type C_ObjectSetPropertyFunc = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()
-- | The type of the setProperty function of
-- ObjectClass.
type ObjectSetPropertyFunc = Object " /@object@/: a 'GI.GObject.Objects.Object.Object' " -> Word32 " /@propertyId@/: the numeric id under which the property was registered with 'GI.GObject.Structs.ObjectClass.objectClassInstallProperty'. " -> GValue " /@value@/: the new value for the property " -> GParamSpec " /@pspec@/: the 'GI.GObject.Objects.ParamSpec.ParamSpec' describing the property " -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_ObjectSetPropertyFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectSetPropertyFunc -> a -> Word32 -> GValue -> GParamSpec -> m ()
-- | Wrap the callback into a GClosure.
genClosure_ObjectSetPropertyFunc :: MonadIO m => ObjectSetPropertyFunc -> m (GClosure C_ObjectSetPropertyFunc)
-- | Generate a function pointer callable from C code, from a
-- C_ObjectSetPropertyFunc.
mk_ObjectSetPropertyFunc :: C_ObjectSetPropertyFunc -> IO (FunPtr C_ObjectSetPropertyFunc)
-- | A convenience synonym for Nothing :: Maybe
-- ObjectSetPropertyFunc.
noObjectSetPropertyFunc :: Maybe ObjectSetPropertyFunc
-- | Wrap a ObjectSetPropertyFunc into a
-- C_ObjectSetPropertyFunc.
wrap_ObjectSetPropertyFunc :: Maybe (Ptr (FunPtr C_ObjectSetPropertyFunc)) -> ObjectSetPropertyFunc -> C_ObjectSetPropertyFunc
-- | Type for the callback on the (unwrapped) C side.
type C_ParamSpecTypeInfoFinalizeFieldCallback = Ptr GParamSpec -> IO ()
-- | No description available in the introspection data.
type ParamSpecTypeInfoFinalizeFieldCallback = GParamSpec -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_ParamSpecTypeInfoFinalizeFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback -> GParamSpec -> m ()
-- | Wrap the callback into a GClosure.
genClosure_ParamSpecTypeInfoFinalizeFieldCallback :: MonadIO m => ParamSpecTypeInfoFinalizeFieldCallback -> m (GClosure C_ParamSpecTypeInfoFinalizeFieldCallback)
-- | Generate a function pointer callable from C code, from a
-- C_ParamSpecTypeInfoFinalizeFieldCallback.
mk_ParamSpecTypeInfoFinalizeFieldCallback :: C_ParamSpecTypeInfoFinalizeFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback)
-- | A convenience synonym for Nothing :: Maybe
-- ParamSpecTypeInfoFinalizeFieldCallback.
noParamSpecTypeInfoFinalizeFieldCallback :: Maybe ParamSpecTypeInfoFinalizeFieldCallback
-- | Wrap a ParamSpecTypeInfoFinalizeFieldCallback into a
-- C_ParamSpecTypeInfoFinalizeFieldCallback.
wrap_ParamSpecTypeInfoFinalizeFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback)) -> ParamSpecTypeInfoFinalizeFieldCallback -> C_ParamSpecTypeInfoFinalizeFieldCallback
-- | Type for the callback on the (unwrapped) C side.
type C_ParamSpecTypeInfoInstanceInitFieldCallback = Ptr GParamSpec -> IO ()
-- | No description available in the introspection data.
type ParamSpecTypeInfoInstanceInitFieldCallback = GParamSpec -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_ParamSpecTypeInfoInstanceInitFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback -> GParamSpec -> m ()
-- | Wrap the callback into a GClosure.
genClosure_ParamSpecTypeInfoInstanceInitFieldCallback :: MonadIO m => ParamSpecTypeInfoInstanceInitFieldCallback -> m (GClosure C_ParamSpecTypeInfoInstanceInitFieldCallback)
-- | Generate a function pointer callable from C code, from a
-- C_ParamSpecTypeInfoInstanceInitFieldCallback.
mk_ParamSpecTypeInfoInstanceInitFieldCallback :: C_ParamSpecTypeInfoInstanceInitFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback)
-- | A convenience synonym for Nothing :: Maybe
-- ParamSpecTypeInfoInstanceInitFieldCallback.
noParamSpecTypeInfoInstanceInitFieldCallback :: Maybe ParamSpecTypeInfoInstanceInitFieldCallback
-- | Wrap a ParamSpecTypeInfoInstanceInitFieldCallback into a
-- C_ParamSpecTypeInfoInstanceInitFieldCallback.
wrap_ParamSpecTypeInfoInstanceInitFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback)) -> ParamSpecTypeInfoInstanceInitFieldCallback -> C_ParamSpecTypeInfoInstanceInitFieldCallback
-- | Type for the callback on the (unwrapped) C side.
type C_ParamSpecTypeInfoValueSetDefaultFieldCallback = Ptr GParamSpec -> Ptr GValue -> IO ()
-- | No description available in the introspection data.
type ParamSpecTypeInfoValueSetDefaultFieldCallback = GParamSpec -> GValue -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_ParamSpecTypeInfoValueSetDefaultFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback -> GParamSpec -> GValue -> m ()
-- | Wrap the callback into a GClosure.
genClosure_ParamSpecTypeInfoValueSetDefaultFieldCallback :: MonadIO m => ParamSpecTypeInfoValueSetDefaultFieldCallback -> m (GClosure C_ParamSpecTypeInfoValueSetDefaultFieldCallback)
-- | Generate a function pointer callable from C code, from a
-- C_ParamSpecTypeInfoValueSetDefaultFieldCallback.
mk_ParamSpecTypeInfoValueSetDefaultFieldCallback :: C_ParamSpecTypeInfoValueSetDefaultFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback)
-- | A convenience synonym for Nothing :: Maybe
-- ParamSpecTypeInfoValueSetDefaultFieldCallback.
noParamSpecTypeInfoValueSetDefaultFieldCallback :: Maybe ParamSpecTypeInfoValueSetDefaultFieldCallback
-- | Wrap a ParamSpecTypeInfoValueSetDefaultFieldCallback into a
-- C_ParamSpecTypeInfoValueSetDefaultFieldCallback.
wrap_ParamSpecTypeInfoValueSetDefaultFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback)) -> ParamSpecTypeInfoValueSetDefaultFieldCallback -> C_ParamSpecTypeInfoValueSetDefaultFieldCallback
-- | Type for the callback on the (unwrapped) C side.
type C_ParamSpecTypeInfoValueValidateFieldCallback = Ptr GParamSpec -> Ptr GValue -> IO CInt
-- | No description available in the introspection data.
type ParamSpecTypeInfoValueValidateFieldCallback = GParamSpec -> GValue -> IO Bool
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_ParamSpecTypeInfoValueValidateFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback -> GParamSpec -> GValue -> m Bool
-- | Wrap the callback into a GClosure.
genClosure_ParamSpecTypeInfoValueValidateFieldCallback :: MonadIO m => ParamSpecTypeInfoValueValidateFieldCallback -> m (GClosure C_ParamSpecTypeInfoValueValidateFieldCallback)
-- | Generate a function pointer callable from C code, from a
-- C_ParamSpecTypeInfoValueValidateFieldCallback.
mk_ParamSpecTypeInfoValueValidateFieldCallback :: C_ParamSpecTypeInfoValueValidateFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback)
-- | A convenience synonym for Nothing :: Maybe
-- ParamSpecTypeInfoValueValidateFieldCallback.
noParamSpecTypeInfoValueValidateFieldCallback :: Maybe ParamSpecTypeInfoValueValidateFieldCallback
-- | Wrap a ParamSpecTypeInfoValueValidateFieldCallback into a
-- C_ParamSpecTypeInfoValueValidateFieldCallback.
wrap_ParamSpecTypeInfoValueValidateFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback)) -> ParamSpecTypeInfoValueValidateFieldCallback -> C_ParamSpecTypeInfoValueValidateFieldCallback
-- | Type for the callback on the (unwrapped) C side.
type C_ParamSpecTypeInfoValuesCmpFieldCallback = Ptr GParamSpec -> Ptr GValue -> Ptr GValue -> IO Int32
-- | No description available in the introspection data.
type ParamSpecTypeInfoValuesCmpFieldCallback = GParamSpec -> GValue -> GValue -> IO Int32
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_ParamSpecTypeInfoValuesCmpFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback -> GParamSpec -> GValue -> GValue -> m Int32
-- | Wrap the callback into a GClosure.
genClosure_ParamSpecTypeInfoValuesCmpFieldCallback :: MonadIO m => ParamSpecTypeInfoValuesCmpFieldCallback -> m (GClosure C_ParamSpecTypeInfoValuesCmpFieldCallback)
-- | Generate a function pointer callable from C code, from a
-- C_ParamSpecTypeInfoValuesCmpFieldCallback.
mk_ParamSpecTypeInfoValuesCmpFieldCallback :: C_ParamSpecTypeInfoValuesCmpFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback)
-- | A convenience synonym for Nothing :: Maybe
-- ParamSpecTypeInfoValuesCmpFieldCallback.
noParamSpecTypeInfoValuesCmpFieldCallback :: Maybe ParamSpecTypeInfoValuesCmpFieldCallback
-- | Wrap a ParamSpecTypeInfoValuesCmpFieldCallback into a
-- C_ParamSpecTypeInfoValuesCmpFieldCallback.
wrap_ParamSpecTypeInfoValuesCmpFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback)) -> ParamSpecTypeInfoValuesCmpFieldCallback -> C_ParamSpecTypeInfoValuesCmpFieldCallback
-- | Type for the callback on the (unwrapped) C side.
type C_SignalAccumulator = Ptr SignalInvocationHint -> Ptr GValue -> Ptr GValue -> Ptr () -> IO CInt
-- | The signal accumulator is a special callback function that can be used
-- to collect return values of the various callbacks that are called
-- during a signal emission. The signal accumulator is specified at
-- signal creation time, if it is left Nothing, no accumulation of
-- callback return values is performed. The return value of signal
-- emissions is then the value returned by the last callback.
type SignalAccumulator = SignalInvocationHint " /@ihint@/: Signal invocation hint, see 'GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint'. " -> GValue " /@returnAccu@/: Accumulator to collect callback return values in, this is the return value of the current signal emission. " -> GValue " /@handlerReturn@/: A 'GI.GObject.Structs.Value.Value' holding the return value of the signal handler. " -> Ptr () " /@data@/: Callback data that was specified when creating the signal. " -> IO Bool " __Returns:__ The accumulator function returns whether the signal emission should be aborted. Returning 'False' means to abort the current emission and 'True' is returned for continuation. "
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_SignalAccumulator :: (HasCallStack, MonadIO m) => FunPtr C_SignalAccumulator -> SignalInvocationHint -> GValue -> GValue -> Ptr () -> m Bool
-- | Wrap the callback into a GClosure.
genClosure_SignalAccumulator :: MonadIO m => SignalAccumulator -> m (GClosure C_SignalAccumulator)
-- | Generate a function pointer callable from C code, from a
-- C_SignalAccumulator.
mk_SignalAccumulator :: C_SignalAccumulator -> IO (FunPtr C_SignalAccumulator)
-- | A convenience synonym for Nothing :: Maybe
-- SignalAccumulator.
noSignalAccumulator :: Maybe SignalAccumulator
-- | Wrap a SignalAccumulator into a C_SignalAccumulator.
wrap_SignalAccumulator :: Maybe (Ptr (FunPtr C_SignalAccumulator)) -> SignalAccumulator -> C_SignalAccumulator
-- | Type for the callback on the (unwrapped) C side.
type C_SignalEmissionHook = Ptr SignalInvocationHint -> Word32 -> Ptr GValue -> Ptr () -> IO CInt
-- | A simple function pointer to get invoked when the signal is emitted.
-- This allows you to tie a hook to the signal type, so that it will trap
-- all emissions of that signal, from any object.
--
-- You may not attach these to signals created with the
-- G_SIGNAL_NO_HOOKS flag.
type SignalEmissionHook = SignalInvocationHint " /@ihint@/: Signal invocation hint, see 'GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint'. " -> [GValue] " /@paramValues@/: the instance on which the signal was emitted, followed by the parameters of the emission. " -> Ptr () " /@data@/: user data associated with the hook. " -> IO Bool " __Returns:__ whether it wants to stay connected. If it returns 'False', the signal hook is disconnected (and destroyed). "
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_SignalEmissionHook :: (HasCallStack, MonadIO m) => FunPtr C_SignalEmissionHook -> SignalInvocationHint -> [GValue] -> Ptr () -> m Bool
-- | Wrap the callback into a GClosure.
genClosure_SignalEmissionHook :: MonadIO m => SignalEmissionHook -> m (GClosure C_SignalEmissionHook)
-- | Generate a function pointer callable from C code, from a
-- C_SignalEmissionHook.
mk_SignalEmissionHook :: C_SignalEmissionHook -> IO (FunPtr C_SignalEmissionHook)
-- | A convenience synonym for Nothing :: Maybe
-- SignalEmissionHook.
noSignalEmissionHook :: Maybe SignalEmissionHook
-- | Wrap a SignalEmissionHook into a C_SignalEmissionHook.
wrap_SignalEmissionHook :: Maybe (Ptr (FunPtr C_SignalEmissionHook)) -> SignalEmissionHook -> C_SignalEmissionHook
-- | Type for the callback on the (unwrapped) C side.
type C_ToggleNotify = Ptr () -> Ptr Object -> CInt -> IO ()
-- | A callback function used for notification when the state of a toggle
-- reference changes. See g_object_add_toggle_ref().
type ToggleNotify = Ptr () " /@data@/: Callback data passed to @/g_object_add_toggle_ref()/@ " -> Object " /@object@/: The object on which @/g_object_add_toggle_ref()/@ was called. " -> Bool " /@isLastRef@/: 'True' if the toggle reference is now the last reference to the object. 'False' if the toggle reference was the last reference and there are now other references. " -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_ToggleNotify :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ToggleNotify -> Ptr () -> a -> Bool -> m ()
-- | Wrap the callback into a GClosure.
genClosure_ToggleNotify :: MonadIO m => ToggleNotify -> m (GClosure C_ToggleNotify)
-- | Generate a function pointer callable from C code, from a
-- C_ToggleNotify.
mk_ToggleNotify :: C_ToggleNotify -> IO (FunPtr C_ToggleNotify)
-- | A convenience synonym for Nothing :: Maybe
-- ToggleNotify.
noToggleNotify :: Maybe ToggleNotify
-- | Wrap a ToggleNotify into a C_ToggleNotify.
wrap_ToggleNotify :: Maybe (Ptr (FunPtr C_ToggleNotify)) -> ToggleNotify -> C_ToggleNotify
-- | Type for the callback on the (unwrapped) C side.
type C_TypeClassCacheFunc = Ptr () -> Ptr TypeClass -> IO CInt
-- | A callback function which is called when the reference count of a
-- class drops to zero. It may use typeClassRef to prevent the
-- class from being freed. You should not call typeClassUnref from
-- a TypeClassCacheFunc function to prevent infinite recursion,
-- use g_type_class_unref_uncached() instead.
--
-- The functions have to check the class id passed in to figure whether
-- they actually want to cache the class of this type, since all classes
-- are routed through the same TypeClassCacheFunc chain.
type TypeClassCacheFunc = Ptr () " /@cacheData@/: data that was given to the @/g_type_add_class_cache_func()/@ call " -> TypeClass " /@gClass@/: The 'GI.GObject.Structs.TypeClass.TypeClass' structure which is unreferenced " -> IO Bool " __Returns:__ 'True' to stop further @/GTypeClassCacheFuncs/@ from being called, 'False' to continue "
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_TypeClassCacheFunc :: (HasCallStack, MonadIO m) => FunPtr C_TypeClassCacheFunc -> Ptr () -> TypeClass -> m Bool
-- | Wrap the callback into a GClosure.
genClosure_TypeClassCacheFunc :: MonadIO m => TypeClassCacheFunc -> m (GClosure C_TypeClassCacheFunc)
-- | Generate a function pointer callable from C code, from a
-- C_TypeClassCacheFunc.
mk_TypeClassCacheFunc :: C_TypeClassCacheFunc -> IO (FunPtr C_TypeClassCacheFunc)
-- | A convenience synonym for Nothing :: Maybe
-- TypeClassCacheFunc.
noTypeClassCacheFunc :: Maybe TypeClassCacheFunc
-- | Wrap a TypeClassCacheFunc into a C_TypeClassCacheFunc.
wrap_TypeClassCacheFunc :: Maybe (Ptr (FunPtr C_TypeClassCacheFunc)) -> TypeClassCacheFunc -> C_TypeClassCacheFunc
-- | Type for the callback on the (unwrapped) C side.
type C_TypeInterfaceCheckFunc = Ptr () -> Ptr TypeInterface -> IO ()
-- | A callback called after an interface vtable is initialized. See
-- g_type_add_interface_check().
--
-- Since: 2.4
type TypeInterfaceCheckFunc = Ptr () " /@checkData@/: data passed to @/g_type_add_interface_check()/@ " -> TypeInterface " /@gIface@/: the interface that has been initialized " -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_TypeInterfaceCheckFunc :: (HasCallStack, MonadIO m) => FunPtr C_TypeInterfaceCheckFunc -> Ptr () -> TypeInterface -> m ()
-- | Wrap the callback into a GClosure.
genClosure_TypeInterfaceCheckFunc :: MonadIO m => TypeInterfaceCheckFunc -> m (GClosure C_TypeInterfaceCheckFunc)
-- | Generate a function pointer callable from C code, from a
-- C_TypeInterfaceCheckFunc.
mk_TypeInterfaceCheckFunc :: C_TypeInterfaceCheckFunc -> IO (FunPtr C_TypeInterfaceCheckFunc)
-- | A convenience synonym for Nothing :: Maybe
-- TypeInterfaceCheckFunc.
noTypeInterfaceCheckFunc :: Maybe TypeInterfaceCheckFunc
-- | Wrap a TypeInterfaceCheckFunc into a
-- C_TypeInterfaceCheckFunc.
wrap_TypeInterfaceCheckFunc :: Maybe (Ptr (FunPtr C_TypeInterfaceCheckFunc)) -> TypeInterfaceCheckFunc -> C_TypeInterfaceCheckFunc
-- | Type for the callback on the (unwrapped) C side.
type C_TypePluginCompleteInterfaceInfo = Ptr TypePlugin -> CGType -> CGType -> Ptr InterfaceInfo -> IO ()
-- | The type of the completeInterfaceInfo function of
-- GTypePluginClass.
type TypePluginCompleteInterfaceInfo = TypePlugin " /@plugin@/: the 'GI.GObject.Interfaces.TypePlugin.TypePlugin' " -> GType " /@instanceType@/: the 'GType' of an instantiable type to which the interface is added " -> GType " /@interfaceType@/: the 'GType' of the interface whose info is completed " -> InterfaceInfo " /@info@/: the 'GI.GObject.Structs.InterfaceInfo.InterfaceInfo' to fill in " -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_TypePluginCompleteInterfaceInfo :: (HasCallStack, MonadIO m, IsTypePlugin a) => FunPtr C_TypePluginCompleteInterfaceInfo -> a -> GType -> GType -> InterfaceInfo -> m ()
-- | Wrap the callback into a GClosure.
genClosure_TypePluginCompleteInterfaceInfo :: MonadIO m => TypePluginCompleteInterfaceInfo -> m (GClosure C_TypePluginCompleteInterfaceInfo)
-- | Generate a function pointer callable from C code, from a
-- C_TypePluginCompleteInterfaceInfo.
mk_TypePluginCompleteInterfaceInfo :: C_TypePluginCompleteInterfaceInfo -> IO (FunPtr C_TypePluginCompleteInterfaceInfo)
-- | A convenience synonym for Nothing :: Maybe
-- TypePluginCompleteInterfaceInfo.
noTypePluginCompleteInterfaceInfo :: Maybe TypePluginCompleteInterfaceInfo
-- | Wrap a TypePluginCompleteInterfaceInfo into a
-- C_TypePluginCompleteInterfaceInfo.
wrap_TypePluginCompleteInterfaceInfo :: Maybe (Ptr (FunPtr C_TypePluginCompleteInterfaceInfo)) -> TypePluginCompleteInterfaceInfo -> C_TypePluginCompleteInterfaceInfo
-- | Type for the callback on the (unwrapped) C side.
type C_TypePluginCompleteTypeInfo = Ptr TypePlugin -> CGType -> Ptr TypeInfo -> Ptr TypeValueTable -> IO ()
-- | The type of the completeTypeInfo function of
-- GTypePluginClass.
type TypePluginCompleteTypeInfo = TypePlugin " /@plugin@/: the 'GI.GObject.Interfaces.TypePlugin.TypePlugin' " -> GType " /@gType@/: the 'GType' whose info is completed " -> TypeInfo " /@info@/: the 'GI.GObject.Structs.TypeInfo.TypeInfo' struct to fill in " -> TypeValueTable " /@valueTable@/: the 'GI.GObject.Structs.TypeValueTable.TypeValueTable' to fill in " -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_TypePluginCompleteTypeInfo :: (HasCallStack, MonadIO m, IsTypePlugin a) => FunPtr C_TypePluginCompleteTypeInfo -> a -> GType -> TypeInfo -> TypeValueTable -> m ()
-- | Wrap the callback into a GClosure.
genClosure_TypePluginCompleteTypeInfo :: MonadIO m => TypePluginCompleteTypeInfo -> m (GClosure C_TypePluginCompleteTypeInfo)
-- | Generate a function pointer callable from C code, from a
-- C_TypePluginCompleteTypeInfo.
mk_TypePluginCompleteTypeInfo :: C_TypePluginCompleteTypeInfo -> IO (FunPtr C_TypePluginCompleteTypeInfo)
-- | A convenience synonym for Nothing :: Maybe
-- TypePluginCompleteTypeInfo.
noTypePluginCompleteTypeInfo :: Maybe TypePluginCompleteTypeInfo
-- | Wrap a TypePluginCompleteTypeInfo into a
-- C_TypePluginCompleteTypeInfo.
wrap_TypePluginCompleteTypeInfo :: Maybe (Ptr (FunPtr C_TypePluginCompleteTypeInfo)) -> TypePluginCompleteTypeInfo -> C_TypePluginCompleteTypeInfo
-- | Type for the callback on the (unwrapped) C side.
type C_TypePluginUnuse = Ptr TypePlugin -> IO ()
-- | The type of the unusePlugin function of
-- GTypePluginClass.
type TypePluginUnuse = TypePlugin " /@plugin@/: the 'GI.GObject.Interfaces.TypePlugin.TypePlugin' whose use count should be decreased " -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_TypePluginUnuse :: (HasCallStack, MonadIO m, IsTypePlugin a) => FunPtr C_TypePluginUnuse -> a -> m ()
-- | Wrap the callback into a GClosure.
genClosure_TypePluginUnuse :: MonadIO m => TypePluginUnuse -> m (GClosure C_TypePluginUnuse)
-- | Generate a function pointer callable from C code, from a
-- C_TypePluginUnuse.
mk_TypePluginUnuse :: C_TypePluginUnuse -> IO (FunPtr C_TypePluginUnuse)
-- | A convenience synonym for Nothing :: Maybe
-- TypePluginUnuse.
noTypePluginUnuse :: Maybe TypePluginUnuse
-- | Wrap a TypePluginUnuse into a C_TypePluginUnuse.
wrap_TypePluginUnuse :: Maybe (Ptr (FunPtr C_TypePluginUnuse)) -> TypePluginUnuse -> C_TypePluginUnuse
-- | Type for the callback on the (unwrapped) C side.
type C_TypePluginUse = Ptr TypePlugin -> IO ()
-- | The type of the usePlugin function of
-- GTypePluginClass, which gets called to increase the
-- use count of plugin.
type TypePluginUse = TypePlugin " /@plugin@/: the 'GI.GObject.Interfaces.TypePlugin.TypePlugin' whose use count should be increased " -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_TypePluginUse :: (HasCallStack, MonadIO m, IsTypePlugin a) => FunPtr C_TypePluginUse -> a -> m ()
-- | Wrap the callback into a GClosure.
genClosure_TypePluginUse :: MonadIO m => TypePluginUse -> m (GClosure C_TypePluginUse)
-- | Generate a function pointer callable from C code, from a
-- C_TypePluginUse.
mk_TypePluginUse :: C_TypePluginUse -> IO (FunPtr C_TypePluginUse)
-- | A convenience synonym for Nothing :: Maybe
-- TypePluginUse.
noTypePluginUse :: Maybe TypePluginUse
-- | Wrap a TypePluginUse into a C_TypePluginUse.
wrap_TypePluginUse :: Maybe (Ptr (FunPtr C_TypePluginUse)) -> TypePluginUse -> C_TypePluginUse
-- | Type for the callback on the (unwrapped) C side.
type C_TypeValueTableCollectValueFieldCallback = Ptr GValue -> Word32 -> Ptr TypeCValue -> Word32 -> IO CString
-- | No description available in the introspection data.
type TypeValueTableCollectValueFieldCallback = GValue -> Word32 -> TypeCValue -> Word32 -> IO Text
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_TypeValueTableCollectValueFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueTableCollectValueFieldCallback -> GValue -> Word32 -> TypeCValue -> Word32 -> m Text
-- | Wrap the callback into a GClosure.
genClosure_TypeValueTableCollectValueFieldCallback :: MonadIO m => TypeValueTableCollectValueFieldCallback -> m (GClosure C_TypeValueTableCollectValueFieldCallback)
-- | Generate a function pointer callable from C code, from a
-- C_TypeValueTableCollectValueFieldCallback.
mk_TypeValueTableCollectValueFieldCallback :: C_TypeValueTableCollectValueFieldCallback -> IO (FunPtr C_TypeValueTableCollectValueFieldCallback)
-- | A convenience synonym for Nothing :: Maybe
-- TypeValueTableCollectValueFieldCallback.
noTypeValueTableCollectValueFieldCallback :: Maybe TypeValueTableCollectValueFieldCallback
-- | Wrap a TypeValueTableCollectValueFieldCallback into a
-- C_TypeValueTableCollectValueFieldCallback.
wrap_TypeValueTableCollectValueFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableCollectValueFieldCallback)) -> TypeValueTableCollectValueFieldCallback -> C_TypeValueTableCollectValueFieldCallback
-- | Type for the callback on the (unwrapped) C side.
type C_TypeValueTableLcopyValueFieldCallback = Ptr GValue -> Word32 -> Ptr TypeCValue -> Word32 -> IO CString
-- | No description available in the introspection data.
type TypeValueTableLcopyValueFieldCallback = GValue -> Word32 -> TypeCValue -> Word32 -> IO Text
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_TypeValueTableLcopyValueFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueTableLcopyValueFieldCallback -> GValue -> Word32 -> TypeCValue -> Word32 -> m Text
-- | Wrap the callback into a GClosure.
genClosure_TypeValueTableLcopyValueFieldCallback :: MonadIO m => TypeValueTableLcopyValueFieldCallback -> m (GClosure C_TypeValueTableLcopyValueFieldCallback)
-- | Generate a function pointer callable from C code, from a
-- C_TypeValueTableLcopyValueFieldCallback.
mk_TypeValueTableLcopyValueFieldCallback :: C_TypeValueTableLcopyValueFieldCallback -> IO (FunPtr C_TypeValueTableLcopyValueFieldCallback)
-- | A convenience synonym for Nothing :: Maybe
-- TypeValueTableLcopyValueFieldCallback.
noTypeValueTableLcopyValueFieldCallback :: Maybe TypeValueTableLcopyValueFieldCallback
-- | Wrap a TypeValueTableLcopyValueFieldCallback into a
-- C_TypeValueTableLcopyValueFieldCallback.
wrap_TypeValueTableLcopyValueFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableLcopyValueFieldCallback)) -> TypeValueTableLcopyValueFieldCallback -> C_TypeValueTableLcopyValueFieldCallback
-- | Type for the callback on the (unwrapped) C side.
type C_TypeValueTableValueCopyFieldCallback = Ptr GValue -> Ptr GValue -> IO ()
-- | No description available in the introspection data.
type TypeValueTableValueCopyFieldCallback = GValue -> GValue -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_TypeValueTableValueCopyFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueTableValueCopyFieldCallback -> GValue -> GValue -> m ()
-- | Wrap the callback into a GClosure.
genClosure_TypeValueTableValueCopyFieldCallback :: MonadIO m => TypeValueTableValueCopyFieldCallback -> m (GClosure C_TypeValueTableValueCopyFieldCallback)
-- | Generate a function pointer callable from C code, from a
-- C_TypeValueTableValueCopyFieldCallback.
mk_TypeValueTableValueCopyFieldCallback :: C_TypeValueTableValueCopyFieldCallback -> IO (FunPtr C_TypeValueTableValueCopyFieldCallback)
-- | A convenience synonym for Nothing :: Maybe
-- TypeValueTableValueCopyFieldCallback.
noTypeValueTableValueCopyFieldCallback :: Maybe TypeValueTableValueCopyFieldCallback
-- | Wrap a TypeValueTableValueCopyFieldCallback into a
-- C_TypeValueTableValueCopyFieldCallback.
wrap_TypeValueTableValueCopyFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableValueCopyFieldCallback)) -> TypeValueTableValueCopyFieldCallback -> C_TypeValueTableValueCopyFieldCallback
-- | Type for the callback on the (unwrapped) C side.
type C_TypeValueTableValueFreeFieldCallback = Ptr GValue -> IO ()
-- | No description available in the introspection data.
type TypeValueTableValueFreeFieldCallback = GValue -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_TypeValueTableValueFreeFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueTableValueFreeFieldCallback -> GValue -> m ()
-- | Wrap the callback into a GClosure.
genClosure_TypeValueTableValueFreeFieldCallback :: MonadIO m => TypeValueTableValueFreeFieldCallback -> m (GClosure C_TypeValueTableValueFreeFieldCallback)
-- | Generate a function pointer callable from C code, from a
-- C_TypeValueTableValueFreeFieldCallback.
mk_TypeValueTableValueFreeFieldCallback :: C_TypeValueTableValueFreeFieldCallback -> IO (FunPtr C_TypeValueTableValueFreeFieldCallback)
-- | A convenience synonym for Nothing :: Maybe
-- TypeValueTableValueFreeFieldCallback.
noTypeValueTableValueFreeFieldCallback :: Maybe TypeValueTableValueFreeFieldCallback
-- | Wrap a TypeValueTableValueFreeFieldCallback into a
-- C_TypeValueTableValueFreeFieldCallback.
wrap_TypeValueTableValueFreeFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableValueFreeFieldCallback)) -> TypeValueTableValueFreeFieldCallback -> C_TypeValueTableValueFreeFieldCallback
-- | Type for the callback on the (unwrapped) C side.
type C_TypeValueTableValueInitFieldCallback = Ptr GValue -> IO ()
-- | No description available in the introspection data.
type TypeValueTableValueInitFieldCallback = GValue -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_TypeValueTableValueInitFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueTableValueInitFieldCallback -> GValue -> m ()
-- | Wrap the callback into a GClosure.
genClosure_TypeValueTableValueInitFieldCallback :: MonadIO m => TypeValueTableValueInitFieldCallback -> m (GClosure C_TypeValueTableValueInitFieldCallback)
-- | Generate a function pointer callable from C code, from a
-- C_TypeValueTableValueInitFieldCallback.
mk_TypeValueTableValueInitFieldCallback :: C_TypeValueTableValueInitFieldCallback -> IO (FunPtr C_TypeValueTableValueInitFieldCallback)
-- | A convenience synonym for Nothing :: Maybe
-- TypeValueTableValueInitFieldCallback.
noTypeValueTableValueInitFieldCallback :: Maybe TypeValueTableValueInitFieldCallback
-- | Wrap a TypeValueTableValueInitFieldCallback into a
-- C_TypeValueTableValueInitFieldCallback.
wrap_TypeValueTableValueInitFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableValueInitFieldCallback)) -> TypeValueTableValueInitFieldCallback -> C_TypeValueTableValueInitFieldCallback
-- | Type for the callback on the (unwrapped) C side.
type C_TypeValueTableValuePeekPointerFieldCallback = Ptr GValue -> IO (Ptr ())
-- | No description available in the introspection data.
type TypeValueTableValuePeekPointerFieldCallback = GValue -> IO (Ptr ())
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_TypeValueTableValuePeekPointerFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueTableValuePeekPointerFieldCallback -> GValue -> m (Ptr ())
-- | Wrap the callback into a GClosure.
genClosure_TypeValueTableValuePeekPointerFieldCallback :: MonadIO m => TypeValueTableValuePeekPointerFieldCallback -> m (GClosure C_TypeValueTableValuePeekPointerFieldCallback)
-- | Generate a function pointer callable from C code, from a
-- C_TypeValueTableValuePeekPointerFieldCallback.
mk_TypeValueTableValuePeekPointerFieldCallback :: C_TypeValueTableValuePeekPointerFieldCallback -> IO (FunPtr C_TypeValueTableValuePeekPointerFieldCallback)
-- | A convenience synonym for Nothing :: Maybe
-- TypeValueTableValuePeekPointerFieldCallback.
noTypeValueTableValuePeekPointerFieldCallback :: Maybe TypeValueTableValuePeekPointerFieldCallback
-- | Wrap a TypeValueTableValuePeekPointerFieldCallback into a
-- C_TypeValueTableValuePeekPointerFieldCallback.
wrap_TypeValueTableValuePeekPointerFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableValuePeekPointerFieldCallback)) -> TypeValueTableValuePeekPointerFieldCallback -> C_TypeValueTableValuePeekPointerFieldCallback
-- | Type for the callback on the (unwrapped) C side.
type C_ValueTransform = Ptr GValue -> Ptr GValue -> IO ()
-- | The type of value transformation functions which can be registered
-- with g_value_register_transform_func().
--
-- destValue will be initialized to the correct
-- destination type.
type ValueTransform = GValue " /@srcValue@/: Source value. " -> GValue " /@destValue@/: Target value. " -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_ValueTransform :: (HasCallStack, MonadIO m) => FunPtr C_ValueTransform -> GValue -> GValue -> m ()
-- | Wrap the callback into a GClosure.
genClosure_ValueTransform :: MonadIO m => ValueTransform -> m (GClosure C_ValueTransform)
-- | Generate a function pointer callable from C code, from a
-- C_ValueTransform.
mk_ValueTransform :: C_ValueTransform -> IO (FunPtr C_ValueTransform)
-- | A convenience synonym for Nothing :: Maybe
-- ValueTransform.
noValueTransform :: Maybe ValueTransform
-- | Wrap a ValueTransform into a C_ValueTransform.
wrap_ValueTransform :: Maybe (Ptr (FunPtr C_ValueTransform)) -> ValueTransform -> C_ValueTransform
-- | Type for the callback on the (unwrapped) C side.
type C_WeakNotify = Ptr () -> Ptr Object -> IO ()
-- | A WeakNotify function can be added to an object as a callback
-- that gets triggered when the object is finalized. Since the object is
-- already being finalized when the WeakNotify is called, there's
-- not much you could do with the object, apart from e.g. using its
-- address as hash-index or the like.
type WeakNotify = Ptr () " /@data@/: data that was provided when the weak reference was established " -> Object " /@whereTheObjectWas@/: the object being finalized " -> IO ()
-- | Given a pointer to a foreign C function, wrap it into a function
-- callable from Haskell.
dynamic_WeakNotify :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_WeakNotify -> Ptr () -> a -> m ()
-- | Wrap the callback into a GClosure.
genClosure_WeakNotify :: MonadIO m => WeakNotify -> m (GClosure C_WeakNotify)
-- | Generate a function pointer callable from C code, from a
-- C_WeakNotify.
mk_WeakNotify :: C_WeakNotify -> IO (FunPtr C_WeakNotify)
-- | A convenience synonym for Nothing :: Maybe
-- WeakNotify.
noWeakNotify :: Maybe WeakNotify
-- | Wrap a WeakNotify into a C_WeakNotify.
wrap_WeakNotify :: Maybe (Ptr (FunPtr C_WeakNotify)) -> WeakNotify -> C_WeakNotify
-- | The TypeValueTable provides the functions required by the
-- Value implementation, to serve as a container for values of a
-- type.
module GI.GObject.Structs.TypeValueTable
-- | Memory-managed wrapper type.
newtype TypeValueTable
TypeValueTable :: ManagedPtr TypeValueTable -> TypeValueTable
-- | Construct a TypeValueTable struct initialized to zero.
newZeroTypeValueTable :: MonadIO m => m TypeValueTable
-- | A convenience alias for Nothing :: Maybe
-- TypeValueTable.
noTypeValueTable :: Maybe TypeValueTable
-- | Set the value of the “collect_format” field to
-- Nothing. When overloading is enabled, this is equivalent
-- to
--
--
-- clear #collectFormat
--
clearTypeValueTableCollectFormat :: MonadIO m => TypeValueTable -> m ()
-- | Get the value of the “collect_format” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeValueTable #collectFormat
--
getTypeValueTableCollectFormat :: MonadIO m => TypeValueTable -> m (Maybe Text)
-- | Set the value of the “collect_format” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeValueTable [ #collectFormat := value ]
--
setTypeValueTableCollectFormat :: MonadIO m => TypeValueTable -> CString -> m ()
-- | Set the value of the “collect_value” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #collectValue
--
clearTypeValueTableCollectValue :: MonadIO m => TypeValueTable -> m ()
-- | Get the value of the “collect_value” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeValueTable #collectValue
--
getTypeValueTableCollectValue :: MonadIO m => TypeValueTable -> m (Maybe TypeValueTableCollectValueFieldCallback)
-- | Set the value of the “collect_value” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeValueTable [ #collectValue := value ]
--
setTypeValueTableCollectValue :: MonadIO m => TypeValueTable -> FunPtr C_TypeValueTableCollectValueFieldCallback -> m ()
-- | Set the value of the “lcopy_format” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #lcopyFormat
--
clearTypeValueTableLcopyFormat :: MonadIO m => TypeValueTable -> m ()
-- | Get the value of the “lcopy_format” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeValueTable #lcopyFormat
--
getTypeValueTableLcopyFormat :: MonadIO m => TypeValueTable -> m (Maybe Text)
-- | Set the value of the “lcopy_format” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeValueTable [ #lcopyFormat := value ]
--
setTypeValueTableLcopyFormat :: MonadIO m => TypeValueTable -> CString -> m ()
-- | Set the value of the “lcopy_value” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #lcopyValue
--
clearTypeValueTableLcopyValue :: MonadIO m => TypeValueTable -> m ()
-- | Get the value of the “lcopy_value” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeValueTable #lcopyValue
--
getTypeValueTableLcopyValue :: MonadIO m => TypeValueTable -> m (Maybe TypeValueTableLcopyValueFieldCallback)
-- | Set the value of the “lcopy_value” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeValueTable [ #lcopyValue := value ]
--
setTypeValueTableLcopyValue :: MonadIO m => TypeValueTable -> FunPtr C_TypeValueTableLcopyValueFieldCallback -> m ()
-- | Set the value of the “value_copy” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #valueCopy
--
clearTypeValueTableValueCopy :: MonadIO m => TypeValueTable -> m ()
-- | Get the value of the “value_copy” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeValueTable #valueCopy
--
getTypeValueTableValueCopy :: MonadIO m => TypeValueTable -> m (Maybe TypeValueTableValueCopyFieldCallback)
-- | Set the value of the “value_copy” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeValueTable [ #valueCopy := value ]
--
setTypeValueTableValueCopy :: MonadIO m => TypeValueTable -> FunPtr C_TypeValueTableValueCopyFieldCallback -> m ()
-- | Set the value of the “value_free” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #valueFree
--
clearTypeValueTableValueFree :: MonadIO m => TypeValueTable -> m ()
-- | Get the value of the “value_free” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeValueTable #valueFree
--
getTypeValueTableValueFree :: MonadIO m => TypeValueTable -> m (Maybe TypeValueTableValueFreeFieldCallback)
-- | Set the value of the “value_free” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeValueTable [ #valueFree := value ]
--
setTypeValueTableValueFree :: MonadIO m => TypeValueTable -> FunPtr C_TypeValueTableValueFreeFieldCallback -> m ()
-- | Set the value of the “value_init” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #valueInit
--
clearTypeValueTableValueInit :: MonadIO m => TypeValueTable -> m ()
-- | Get the value of the “value_init” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeValueTable #valueInit
--
getTypeValueTableValueInit :: MonadIO m => TypeValueTable -> m (Maybe TypeValueTableValueInitFieldCallback)
-- | Set the value of the “value_init” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeValueTable [ #valueInit := value ]
--
setTypeValueTableValueInit :: MonadIO m => TypeValueTable -> FunPtr C_TypeValueTableValueInitFieldCallback -> m ()
-- | Set the value of the “value_peek_pointer” field to
-- Nothing. When overloading is enabled, this is equivalent
-- to
--
--
-- clear #valuePeekPointer
--
clearTypeValueTableValuePeekPointer :: MonadIO m => TypeValueTable -> m ()
-- | Get the value of the “value_peek_pointer” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeValueTable #valuePeekPointer
--
getTypeValueTableValuePeekPointer :: MonadIO m => TypeValueTable -> m (Maybe TypeValueTableValuePeekPointerFieldCallback)
-- | Set the value of the “value_peek_pointer” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeValueTable [ #valuePeekPointer := value ]
--
setTypeValueTableValuePeekPointer :: MonadIO m => TypeValueTable -> FunPtr C_TypeValueTableValuePeekPointerFieldCallback -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.TypeValueTable.TypeValueTable
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.TypeValueTable.TypeValueTable tag
-- | This structure is used to provide the type system with the information
-- required to initialize and destruct (finalize) a type's class and its
-- instances.
--
-- The initialized structure is passed to the typeRegisterStatic
-- function (or is copied into the provided TypeInfo structure in
-- the typePluginCompleteTypeInfo). The type system will perform a
-- deep copy of this structure, so its memory does not need to be
-- persistent across invocation of typeRegisterStatic.
module GI.GObject.Structs.TypeInfo
-- | Memory-managed wrapper type.
newtype TypeInfo
TypeInfo :: ManagedPtr TypeInfo -> TypeInfo
-- | Construct a TypeInfo struct initialized to zero.
newZeroTypeInfo :: MonadIO m => m TypeInfo
-- | A convenience alias for Nothing :: Maybe
-- TypeInfo.
noTypeInfo :: Maybe TypeInfo
-- | Set the value of the “base_finalize” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #baseFinalize
--
clearTypeInfoBaseFinalize :: MonadIO m => TypeInfo -> m ()
-- | Get the value of the “base_finalize” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeInfo #baseFinalize
--
getTypeInfoBaseFinalize :: MonadIO m => TypeInfo -> m (Maybe BaseFinalizeFunc)
-- | Set the value of the “base_finalize” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeInfo [ #baseFinalize := value ]
--
setTypeInfoBaseFinalize :: MonadIO m => TypeInfo -> FunPtr C_BaseFinalizeFunc -> m ()
-- | Set the value of the “base_init” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #baseInit
--
clearTypeInfoBaseInit :: MonadIO m => TypeInfo -> m ()
-- | Get the value of the “base_init” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeInfo #baseInit
--
getTypeInfoBaseInit :: MonadIO m => TypeInfo -> m (Maybe BaseInitFunc)
-- | Set the value of the “base_init” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeInfo [ #baseInit := value ]
--
setTypeInfoBaseInit :: MonadIO m => TypeInfo -> FunPtr C_BaseInitFunc -> m ()
-- | Set the value of the “class_data” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #classData
--
clearTypeInfoClassData :: MonadIO m => TypeInfo -> m ()
-- | Get the value of the “class_data” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeInfo #classData
--
getTypeInfoClassData :: MonadIO m => TypeInfo -> m (Ptr ())
-- | Set the value of the “class_data” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeInfo [ #classData := value ]
--
setTypeInfoClassData :: MonadIO m => TypeInfo -> Ptr () -> m ()
-- | Set the value of the “class_finalize” field to
-- Nothing. When overloading is enabled, this is equivalent
-- to
--
--
-- clear #classFinalize
--
clearTypeInfoClassFinalize :: MonadIO m => TypeInfo -> m ()
-- | Get the value of the “class_finalize” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeInfo #classFinalize
--
getTypeInfoClassFinalize :: MonadIO m => TypeInfo -> m (Maybe ClassFinalizeFunc)
-- | Set the value of the “class_finalize” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeInfo [ #classFinalize := value ]
--
setTypeInfoClassFinalize :: MonadIO m => TypeInfo -> FunPtr C_ClassFinalizeFunc -> m ()
-- | Set the value of the “class_init” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #classInit
--
clearTypeInfoClassInit :: MonadIO m => TypeInfo -> m ()
-- | Get the value of the “class_init” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeInfo #classInit
--
getTypeInfoClassInit :: MonadIO m => TypeInfo -> m (Maybe ClassInitFunc)
-- | Set the value of the “class_init” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeInfo [ #classInit := value ]
--
setTypeInfoClassInit :: MonadIO m => TypeInfo -> FunPtr C_ClassInitFunc -> m ()
-- | Get the value of the “class_size” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeInfo #classSize
--
getTypeInfoClassSize :: MonadIO m => TypeInfo -> m Word16
-- | Set the value of the “class_size” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeInfo [ #classSize := value ]
--
setTypeInfoClassSize :: MonadIO m => TypeInfo -> Word16 -> m ()
-- | Set the value of the “instance_init” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #instanceInit
--
clearTypeInfoInstanceInit :: MonadIO m => TypeInfo -> m ()
-- | Get the value of the “instance_init” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeInfo #instanceInit
--
getTypeInfoInstanceInit :: MonadIO m => TypeInfo -> m (Maybe InstanceInitFunc)
-- | Set the value of the “instance_init” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeInfo [ #instanceInit := value ]
--
setTypeInfoInstanceInit :: MonadIO m => TypeInfo -> FunPtr C_InstanceInitFunc -> m ()
-- | Get the value of the “instance_size” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeInfo #instanceSize
--
getTypeInfoInstanceSize :: MonadIO m => TypeInfo -> m Word16
-- | Set the value of the “instance_size” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeInfo [ #instanceSize := value ]
--
setTypeInfoInstanceSize :: MonadIO m => TypeInfo -> Word16 -> m ()
-- | Get the value of the “n_preallocs” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeInfo #nPreallocs
--
getTypeInfoNPreallocs :: MonadIO m => TypeInfo -> m Word16
-- | Set the value of the “n_preallocs” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeInfo [ #nPreallocs := value ]
--
setTypeInfoNPreallocs :: MonadIO m => TypeInfo -> Word16 -> m ()
-- | Set the value of the “value_table” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #valueTable
--
clearTypeInfoValueTable :: MonadIO m => TypeInfo -> m ()
-- | Get the value of the “value_table” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get typeInfo #valueTable
--
getTypeInfoValueTable :: MonadIO m => TypeInfo -> m (Maybe TypeValueTable)
-- | Set the value of the “value_table” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set typeInfo [ #valueTable := value ]
--
setTypeInfoValueTable :: MonadIO m => TypeInfo -> Ptr TypeValueTable -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.TypeInfo.TypeInfo
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.TypeInfo.TypeInfo tag
-- | This structure is used to provide the type system with the information
-- required to initialize and destruct (finalize) a parameter's class and
-- instances thereof. The initialized structure is passed to the
-- paramTypeRegisterStatic The type system will perform a deep
-- copy of this structure, so its memory does not need to be persistent
-- across invocation of paramTypeRegisterStatic.
module GI.GObject.Structs.ParamSpecTypeInfo
-- | Memory-managed wrapper type.
newtype ParamSpecTypeInfo
ParamSpecTypeInfo :: ManagedPtr ParamSpecTypeInfo -> ParamSpecTypeInfo
-- | Construct a ParamSpecTypeInfo struct initialized to zero.
newZeroParamSpecTypeInfo :: MonadIO m => m ParamSpecTypeInfo
-- | A convenience alias for Nothing :: Maybe
-- ParamSpecTypeInfo.
noParamSpecTypeInfo :: Maybe ParamSpecTypeInfo
-- | Set the value of the “finalize” field to Nothing. When
-- overloading is enabled, this is equivalent to
--
--
-- clear #finalize
--
clearParamSpecTypeInfoFinalize :: MonadIO m => ParamSpecTypeInfo -> m ()
-- | Get the value of the “finalize” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get paramSpecTypeInfo #finalize
--
getParamSpecTypeInfoFinalize :: MonadIO m => ParamSpecTypeInfo -> m (Maybe ParamSpecTypeInfoFinalizeFieldCallback)
-- | Set the value of the “finalize” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set paramSpecTypeInfo [ #finalize := value ]
--
setParamSpecTypeInfoFinalize :: MonadIO m => ParamSpecTypeInfo -> FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback -> m ()
-- | Set the value of the “instance_init” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #instanceInit
--
clearParamSpecTypeInfoInstanceInit :: MonadIO m => ParamSpecTypeInfo -> m ()
-- | Get the value of the “instance_init” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get paramSpecTypeInfo #instanceInit
--
getParamSpecTypeInfoInstanceInit :: MonadIO m => ParamSpecTypeInfo -> m (Maybe ParamSpecTypeInfoInstanceInitFieldCallback)
-- | Set the value of the “instance_init” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set paramSpecTypeInfo [ #instanceInit := value ]
--
setParamSpecTypeInfoInstanceInit :: MonadIO m => ParamSpecTypeInfo -> FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback -> m ()
-- | Get the value of the “instance_size” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get paramSpecTypeInfo #instanceSize
--
getParamSpecTypeInfoInstanceSize :: MonadIO m => ParamSpecTypeInfo -> m Word16
-- | Set the value of the “instance_size” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set paramSpecTypeInfo [ #instanceSize := value ]
--
setParamSpecTypeInfoInstanceSize :: MonadIO m => ParamSpecTypeInfo -> Word16 -> m ()
-- | Get the value of the “n_preallocs” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get paramSpecTypeInfo #nPreallocs
--
getParamSpecTypeInfoNPreallocs :: MonadIO m => ParamSpecTypeInfo -> m Word16
-- | Set the value of the “n_preallocs” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set paramSpecTypeInfo [ #nPreallocs := value ]
--
setParamSpecTypeInfoNPreallocs :: MonadIO m => ParamSpecTypeInfo -> Word16 -> m ()
-- | Set the value of the “value_set_default” field to
-- Nothing. When overloading is enabled, this is equivalent
-- to
--
--
-- clear #valueSetDefault
--
clearParamSpecTypeInfoValueSetDefault :: MonadIO m => ParamSpecTypeInfo -> m ()
-- | Get the value of the “value_set_default” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get paramSpecTypeInfo #valueSetDefault
--
getParamSpecTypeInfoValueSetDefault :: MonadIO m => ParamSpecTypeInfo -> m (Maybe ParamSpecTypeInfoValueSetDefaultFieldCallback)
-- | Set the value of the “value_set_default” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set paramSpecTypeInfo [ #valueSetDefault := value ]
--
setParamSpecTypeInfoValueSetDefault :: MonadIO m => ParamSpecTypeInfo -> FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback -> m ()
-- | Get the value of the “value_type” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get paramSpecTypeInfo #valueType
--
getParamSpecTypeInfoValueType :: MonadIO m => ParamSpecTypeInfo -> m GType
-- | Set the value of the “value_type” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set paramSpecTypeInfo [ #valueType := value ]
--
setParamSpecTypeInfoValueType :: MonadIO m => ParamSpecTypeInfo -> GType -> m ()
-- | Set the value of the “value_validate” field to
-- Nothing. When overloading is enabled, this is equivalent
-- to
--
--
-- clear #valueValidate
--
clearParamSpecTypeInfoValueValidate :: MonadIO m => ParamSpecTypeInfo -> m ()
-- | Get the value of the “value_validate” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get paramSpecTypeInfo #valueValidate
--
getParamSpecTypeInfoValueValidate :: MonadIO m => ParamSpecTypeInfo -> m (Maybe ParamSpecTypeInfoValueValidateFieldCallback)
-- | Set the value of the “value_validate” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set paramSpecTypeInfo [ #valueValidate := value ]
--
setParamSpecTypeInfoValueValidate :: MonadIO m => ParamSpecTypeInfo -> FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback -> m ()
-- | Set the value of the “values_cmp” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #valuesCmp
--
clearParamSpecTypeInfoValuesCmp :: MonadIO m => ParamSpecTypeInfo -> m ()
-- | Get the value of the “values_cmp” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get paramSpecTypeInfo #valuesCmp
--
getParamSpecTypeInfoValuesCmp :: MonadIO m => ParamSpecTypeInfo -> m (Maybe ParamSpecTypeInfoValuesCmpFieldCallback)
-- | Set the value of the “values_cmp” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set paramSpecTypeInfo [ #valuesCmp := value ]
--
setParamSpecTypeInfoValuesCmp :: MonadIO m => ParamSpecTypeInfo -> FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfo
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfo tag
-- | A structure that provides information to the type system which is used
-- specifically for managing interface types.
module GI.GObject.Structs.InterfaceInfo
-- | Memory-managed wrapper type.
newtype InterfaceInfo
InterfaceInfo :: ManagedPtr InterfaceInfo -> InterfaceInfo
-- | Construct a InterfaceInfo struct initialized to zero.
newZeroInterfaceInfo :: MonadIO m => m InterfaceInfo
-- | A convenience alias for Nothing :: Maybe
-- InterfaceInfo.
noInterfaceInfo :: Maybe InterfaceInfo
-- | Set the value of the “interface_data” field to
-- Nothing. When overloading is enabled, this is equivalent
-- to
--
--
-- clear #interfaceData
--
clearInterfaceInfoInterfaceData :: MonadIO m => InterfaceInfo -> m ()
-- | Get the value of the “interface_data” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get interfaceInfo #interfaceData
--
getInterfaceInfoInterfaceData :: MonadIO m => InterfaceInfo -> m (Ptr ())
-- | Set the value of the “interface_data” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set interfaceInfo [ #interfaceData := value ]
--
setInterfaceInfoInterfaceData :: MonadIO m => InterfaceInfo -> Ptr () -> m ()
-- | Set the value of the “interface_finalize” field to
-- Nothing. When overloading is enabled, this is equivalent
-- to
--
--
-- clear #interfaceFinalize
--
clearInterfaceInfoInterfaceFinalize :: MonadIO m => InterfaceInfo -> m ()
-- | Get the value of the “interface_finalize” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get interfaceInfo #interfaceFinalize
--
getInterfaceInfoInterfaceFinalize :: MonadIO m => InterfaceInfo -> m (Maybe InterfaceFinalizeFunc)
-- | Set the value of the “interface_finalize” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set interfaceInfo [ #interfaceFinalize := value ]
--
setInterfaceInfoInterfaceFinalize :: MonadIO m => InterfaceInfo -> FunPtr C_InterfaceFinalizeFunc -> m ()
-- | Set the value of the “interface_init” field to
-- Nothing. When overloading is enabled, this is equivalent
-- to
--
--
-- clear #interfaceInit
--
clearInterfaceInfoInterfaceInit :: MonadIO m => InterfaceInfo -> m ()
-- | Get the value of the “interface_init” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get interfaceInfo #interfaceInit
--
getInterfaceInfoInterfaceInit :: MonadIO m => InterfaceInfo -> m (Maybe InterfaceInitFunc)
-- | Set the value of the “interface_init” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set interfaceInfo [ #interfaceInit := value ]
--
setInterfaceInfoInterfaceInit :: MonadIO m => InterfaceInfo -> FunPtr C_InterfaceInitFunc -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.InterfaceInfo.InterfaceInfo
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.InterfaceInfo.InterfaceInfo tag
-- | No description available in the introspection data.
module GI.GObject.Structs.ClosureNotifyData
-- | Memory-managed wrapper type.
newtype ClosureNotifyData
ClosureNotifyData :: ManagedPtr ClosureNotifyData -> ClosureNotifyData
-- | Construct a ClosureNotifyData struct initialized to zero.
newZeroClosureNotifyData :: MonadIO m => m ClosureNotifyData
-- | A convenience alias for Nothing :: Maybe
-- ClosureNotifyData.
noClosureNotifyData :: Maybe ClosureNotifyData
-- | Set the value of the “data” field to Nothing. When
-- overloading is enabled, this is equivalent to
--
--
-- clear #data
--
clearClosureNotifyDataData :: MonadIO m => ClosureNotifyData -> m ()
-- | Get the value of the “data” field. When overloading is
-- enabled, this is equivalent to
--
--
-- get closureNotifyData #data
--
getClosureNotifyDataData :: MonadIO m => ClosureNotifyData -> m (Ptr ())
-- | Set the value of the “data” field. When overloading is
-- enabled, this is equivalent to
--
--
-- set closureNotifyData [ #data := value ]
--
setClosureNotifyDataData :: MonadIO m => ClosureNotifyData -> Ptr () -> m ()
-- | Set the value of the “notify” field to Nothing. When
-- overloading is enabled, this is equivalent to
--
--
-- clear #notify
--
clearClosureNotifyDataNotify :: MonadIO m => ClosureNotifyData -> m ()
-- | Get the value of the “notify” field. When overloading
-- is enabled, this is equivalent to
--
--
-- get closureNotifyData #notify
--
getClosureNotifyDataNotify :: MonadIO m => ClosureNotifyData -> m (Maybe ClosureNotify)
-- | Set the value of the “notify” field. When overloading
-- is enabled, this is equivalent to
--
--
-- set closureNotifyData [ #notify := value ]
--
setClosureNotifyDataNotify :: MonadIO m => ClosureNotifyData -> FunPtr C_ClosureNotify -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.ClosureNotifyData.ClosureNotifyData
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.ClosureNotifyData.ClosureNotifyData tag
module GI.GObject.Structs
module GI.GObject.Functions
-- | Provide a copy of a boxed structure srcBoxed which is
-- of type boxedType.
boxedCopy :: (HasCallStack, MonadIO m) => GType -> Ptr () -> m (Ptr ())
-- | Free the boxed structure boxed which is of type
-- boxedType.
boxedFree :: (HasCallStack, MonadIO m) => GType -> Ptr () -> m ()
-- | This function is meant to be called from the
-- complete_type_info function of a TypePlugin
-- implementation, as in the following example:
--
-- C code
--
--
-- static void
-- my_enum_complete_type_info (GTypePlugin *plugin,
-- GType g_type,
-- GTypeInfo *info,
-- GTypeValueTable *value_table)
-- {
-- static const GEnumValue values[] = {
-- { MY_ENUM_FOO, "MY_ENUM_FOO", "foo" },
-- { MY_ENUM_BAR, "MY_ENUM_BAR", "bar" },
-- { 0, NULL, NULL }
-- };
--
-- g_enum_complete_type_info (type, info, values);
-- }
--
enumCompleteTypeInfo :: (HasCallStack, MonadIO m) => GType -> EnumValue -> m TypeInfo
-- | Returns the EnumValue for a value.
enumGetValue :: (HasCallStack, MonadIO m) => EnumClass -> Int32 -> m EnumValue
-- | Looks up a EnumValue by name.
enumGetValueByName :: (HasCallStack, MonadIO m) => EnumClass -> Text -> m EnumValue
-- | Looks up a EnumValue by nickname.
enumGetValueByNick :: (HasCallStack, MonadIO m) => EnumClass -> Text -> m EnumValue
-- | Registers a new static enumeration type with the name
-- name.
--
-- It is normally more convenient to let [glib-mkenums][glib-mkenums],
-- generate a my_enum_get_type() function from a usual C
-- enumeration definition than to write one yourself using
-- enumRegisterStatic.
enumRegisterStatic :: (HasCallStack, MonadIO m) => Text -> EnumValue -> m GType
-- | Pretty-prints value in the form of the enum’s name.
--
-- This is intended to be used for debugging purposes. The format of the
-- output may change in the future.
--
-- Since: 2.54
enumToString :: (HasCallStack, MonadIO m) => GType -> Int32 -> m Text
-- | This function is meant to be called from the
-- complete_type_info() function of a TypePlugin
-- implementation, see the example for enumCompleteTypeInfo above.
flagsCompleteTypeInfo :: (HasCallStack, MonadIO m) => GType -> FlagsValue -> m TypeInfo
-- | Returns the first FlagsValue which is set in
-- value.
flagsGetFirstValue :: (HasCallStack, MonadIO m) => FlagsClass -> Word32 -> m FlagsValue
-- | Looks up a FlagsValue by name.
flagsGetValueByName :: (HasCallStack, MonadIO m) => FlagsClass -> Text -> m FlagsValue
-- | Looks up a FlagsValue by nickname.
flagsGetValueByNick :: (HasCallStack, MonadIO m) => FlagsClass -> Text -> m FlagsValue
-- | Registers a new static flags type with the name name.
--
-- It is normally more convenient to let [glib-mkenums][glib-mkenums]
-- generate a my_flags_get_type() function from a usual C
-- enumeration definition than to write one yourself using
-- flagsRegisterStatic.
flagsRegisterStatic :: (HasCallStack, MonadIO m) => Text -> FlagsValue -> m GType
-- | Pretty-prints value in the form of the flag names
-- separated by | and sorted. Any extra bits will be shown at
-- the end as a hexadecimal number.
--
-- This is intended to be used for debugging purposes. The format of the
-- output may change in the future.
--
-- Since: 2.54
flagsToString :: (HasCallStack, MonadIO m) => GType -> Word32 -> m Text
-- | No description available in the introspection data.
gtypeGetType :: (HasCallStack, MonadIO m) => m GType
-- | Creates a new ParamSpecBoolean instance specifying a
-- G_TYPE_BOOLEAN property. In many cases, it may be more
-- appropriate to use an enum with paramSpecEnum, both to improve
-- code clarity by using explicitly named values, and to allow for more
-- values to be added in future without breaking API.
--
-- See g_param_spec_internal() for details on property
-- names.
paramSpecBoolean :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Bool -> [ParamFlags] -> m GParamSpec
-- | Creates a new ParamSpecBoxed instance specifying a
-- G_TYPE_BOXED derived property.
--
-- See g_param_spec_internal() for details on property
-- names.
paramSpecBoxed :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> GType -> [ParamFlags] -> m GParamSpec
-- | Creates a new ParamSpecChar instance specifying a
-- G_TYPE_CHAR property.
paramSpecChar :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Int8 -> Int8 -> Int8 -> [ParamFlags] -> m GParamSpec
-- | Creates a new ParamSpecDouble instance specifying a
-- G_TYPE_DOUBLE property.
--
-- See g_param_spec_internal() for details on property
-- names.
paramSpecDouble :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Double -> Double -> Double -> [ParamFlags] -> m GParamSpec
-- | Creates a new ParamSpecEnum instance specifying a
-- G_TYPE_ENUM property.
--
-- See g_param_spec_internal() for details on property
-- names.
paramSpecEnum :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> GType -> Int32 -> [ParamFlags] -> m GParamSpec
-- | Creates a new ParamSpecFlags instance specifying a
-- G_TYPE_FLAGS property.
--
-- See g_param_spec_internal() for details on property
-- names.
paramSpecFlags :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> GType -> Word32 -> [ParamFlags] -> m GParamSpec
-- | Creates a new ParamSpecFloat instance specifying a
-- G_TYPE_FLOAT property.
--
-- See g_param_spec_internal() for details on property
-- names.
paramSpecFloat :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Float -> Float -> Float -> [ParamFlags] -> m GParamSpec
-- | Creates a new ParamSpecGType instance specifying a
-- G_TYPE_GTYPE property.
--
-- See g_param_spec_internal() for details on property
-- names.
--
-- Since: 2.10
paramSpecGtype :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> GType -> [ParamFlags] -> m GParamSpec
-- | Creates a new ParamSpecInt instance specifying a
-- G_TYPE_INT property.
--
-- See g_param_spec_internal() for details on property
-- names.
paramSpecInt :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Int32 -> Int32 -> Int32 -> [ParamFlags] -> m GParamSpec
-- | Creates a new ParamSpecInt64 instance specifying a
-- G_TYPE_INT64 property.
--
-- See g_param_spec_internal() for details on property
-- names.
paramSpecInt64 :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Int64 -> Int64 -> Int64 -> [ParamFlags] -> m GParamSpec
-- | Creates a new ParamSpecLong instance specifying a
-- G_TYPE_LONG property.
--
-- See g_param_spec_internal() for details on property
-- names.
paramSpecLong :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> CLong -> CLong -> CLong -> [ParamFlags] -> m GParamSpec
-- | Creates a new ParamSpecBoxed instance specifying a
-- G_TYPE_OBJECT derived property.
--
-- See g_param_spec_internal() for details on property
-- names.
paramSpecObject :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> GType -> [ParamFlags] -> m GParamSpec
-- | Creates a new ParamSpecParam instance specifying a
-- G_TYPE_PARAM property.
--
-- See g_param_spec_internal() for details on property
-- names.
paramSpecParam :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> GType -> [ParamFlags] -> m GParamSpec
-- | Creates a new ParamSpecPointer instance specifying a pointer
-- property. Where possible, it is better to use paramSpecObject
-- or paramSpecBoxed to expose memory management information.
--
-- See g_param_spec_internal() for details on property
-- names.
paramSpecPointer :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> [ParamFlags] -> m GParamSpec
-- | Creates a new ParamSpecString instance.
--
-- See g_param_spec_internal() for details on property
-- names.
paramSpecString :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Maybe Text -> [ParamFlags] -> m GParamSpec
-- | Creates a new ParamSpecUChar instance specifying a
-- G_TYPE_UCHAR property.
paramSpecUchar :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Word8 -> Word8 -> Word8 -> [ParamFlags] -> m GParamSpec
-- | Creates a new ParamSpecUInt instance specifying a
-- G_TYPE_UINT property.
--
-- See g_param_spec_internal() for details on property
-- names.
paramSpecUint :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Word32 -> Word32 -> Word32 -> [ParamFlags] -> m GParamSpec
-- | Creates a new ParamSpecUInt64 instance specifying a
-- G_TYPE_UINT64 property.
--
-- See g_param_spec_internal() for details on property
-- names.
paramSpecUint64 :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Word64 -> Word64 -> Word64 -> [ParamFlags] -> m GParamSpec
-- | Creates a new ParamSpecULong instance specifying a
-- G_TYPE_ULONG property.
--
-- See g_param_spec_internal() for details on property
-- names.
paramSpecUlong :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> CULong -> CULong -> CULong -> [ParamFlags] -> m GParamSpec
-- | Creates a new ParamSpecUnichar instance specifying a
-- G_TYPE_UINT property. Value structures for this
-- property can be accessed with valueSetUint and
-- valueGetUint.
--
-- See g_param_spec_internal() for details on property
-- names.
paramSpecUnichar :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> Char -> [ParamFlags] -> m GParamSpec
-- | Creates a new ParamSpecVariant instance specifying a
-- GVariant property.
--
-- If defaultValue is floating, it is consumed.
--
-- See g_param_spec_internal() for details on property
-- names.
--
-- Since: 2.26
paramSpecVariant :: (HasCallStack, MonadIO m) => Text -> Text -> Text -> VariantType -> Maybe GVariant -> [ParamFlags] -> m GParamSpec
-- | Registers name as the name of a new static type
-- derived from G_TYPE_PARAM. The type system uses the
-- information contained in the ParamSpecTypeInfo structure
-- pointed to by info to manage the ParamSpec type
-- and its instances.
paramTypeRegisterStatic :: (HasCallStack, MonadIO m) => Text -> ParamSpecTypeInfo -> m GType
-- | Transforms srcValue into destValue if
-- possible, and then validates destValue, in order for
-- it to conform to pspec. If
-- strictValidation is True this function will
-- only succeed if the transformed destValue complied to
-- pspec without modifications.
--
-- See also valueTypeTransformable, valueTransform and
-- paramValueValidate.
paramValueConvert :: (HasCallStack, MonadIO m) => GParamSpec -> GValue -> GValue -> Bool -> m Bool
-- | Checks whether value contains the default value as
-- specified in pspec.
paramValueDefaults :: (HasCallStack, MonadIO m) => GParamSpec -> GValue -> m Bool
-- | Sets value to its default value as specified in
-- pspec.
paramValueSetDefault :: (HasCallStack, MonadIO m) => GParamSpec -> GValue -> m ()
-- | Ensures that the contents of value comply with the
-- specifications set out by pspec. For example, a
-- ParamSpecInt might require that integers stored in
-- value may not be smaller than -42 and not be greater
-- than +42. If value contains an integer outside of this
-- range, it is modified accordingly, so the resulting value will fit
-- into the range -42 .. +42.
paramValueValidate :: (HasCallStack, MonadIO m) => GParamSpec -> GValue -> m Bool
-- | Compares value1 with value2 according
-- to pspec, and return -1, 0 or +1, if
-- value1 is found to be less than, equal to or greater
-- than value2, respectively.
paramValuesCmp :: (HasCallStack, MonadIO m) => GParamSpec -> GValue -> GValue -> m Int32
-- | Creates a new G_TYPE_POINTER derived type id for a new
-- pointer type with name name.
pointerTypeRegisterStatic :: (HasCallStack, MonadIO m) => Text -> m GType
-- | A predefined SignalAccumulator for signals intended to be used
-- as a hook for application code to provide a particular value. Usually
-- only one such value is desired and multiple handlers for the same
-- signal don't make much sense (except for the case of the default
-- handler defined in the class structure, in which case you will usually
-- want the signal connection to override the class handler).
--
-- This accumulator will use the return value from the first signal
-- handler that is run as the return value for the signal and not run any
-- further handlers (ie: the first handler "wins").
--
-- Since: 2.28
signalAccumulatorFirstWins :: (HasCallStack, MonadIO m) => SignalInvocationHint -> GValue -> GValue -> Ptr () -> m Bool
-- | A predefined SignalAccumulator for signals that return a
-- boolean values. The behavior that this accumulator gives is that a
-- return of True stops the signal emission: no further callbacks
-- will be invoked, while a return of False allows the emission to
-- continue. The idea here is that a True return indicates that
-- the callback handled the signal, and no further handling is needed.
--
-- Since: 2.4
signalAccumulatorTrueHandled :: (HasCallStack, MonadIO m) => SignalInvocationHint -> GValue -> GValue -> Ptr () -> m Bool
-- | Adds an emission hook for a signal, which will get called for any
-- emission of that signal, independent of the instance. This is possible
-- only for signals which don't have G_SIGNAL_NO_HOOKS
-- flag set.
signalAddEmissionHook :: (HasCallStack, MonadIO m) => Word32 -> Word32 -> SignalEmissionHook -> m CULong
-- | Calls the original class closure of a signal. This function should
-- only be called from an overridden class closure; see
-- signalOverrideClassClosure and
-- g_signal_override_class_handler().
signalChainFromOverridden :: (HasCallStack, MonadIO m) => [GValue] -> GValue -> m ()
-- | Connects a closure to a signal for a particular object.
signalConnectClosure :: (HasCallStack, MonadIO m, IsObject a) => a -> Text -> GClosure b -> Bool -> m CULong
-- | Connects a closure to a signal for a particular object.
signalConnectClosureById :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> Word32 -> GClosure b -> Bool -> m CULong
-- | Emits a signal.
--
-- Note that signalEmitv doesn't change
-- returnValue if no handlers are connected, in contrast
-- to g_signal_emit() and
-- g_signal_emit_valist().
signalEmitv :: (HasCallStack, MonadIO m) => [GValue] -> Word32 -> Word32 -> m GValue
-- | Returns the invocation hint of the innermost signal emission of
-- instance.
signalGetInvocationHint :: (HasCallStack, MonadIO m, IsObject a) => a -> m SignalInvocationHint
-- | Blocks a handler of an instance so it will not be called during any
-- signal emissions unless it is unblocked again. Thus "blocking" a
-- signal handler means to temporarily deactive it, a signal handler has
-- to be unblocked exactly the same amount of times it has been blocked
-- before to become active again.
--
-- The handlerId has to be a valid signal handler id,
-- connected to a signal of instance.
signalHandlerBlock :: (HasCallStack, MonadIO m, IsObject a) => a -> CULong -> m ()
-- | Disconnects a handler from an instance so it will not be called during
-- any future or currently ongoing emissions of the signal it has been
-- connected to. The handlerId becomes invalid and may be
-- reused.
--
-- The handlerId has to be a valid signal handler id,
-- connected to a signal of instance.
signalHandlerDisconnect :: (HasCallStack, MonadIO m, IsObject a) => a -> CULong -> m ()
-- | Finds the first signal handler that matches certain selection
-- criteria. The criteria mask is passed as an OR-ed combination of
-- SignalMatchType flags, and the criteria values are passed as
-- arguments. The match mask has to be non-0 for
-- successful matches. If no handler was found, 0 is returned.
signalHandlerFind :: (HasCallStack, MonadIO m, IsObject a) => a -> [SignalMatchType] -> Word32 -> Word32 -> Maybe (GClosure b) -> Ptr () -> Ptr () -> m CULong
-- | Returns whether handlerId is the ID of a handler
-- connected to instance.
signalHandlerIsConnected :: (HasCallStack, MonadIO m, IsObject a) => a -> CULong -> m Bool
-- | Undoes the effect of a previous signalHandlerBlock call. A
-- blocked handler is skipped during signal emissions and will not be
-- invoked, unblocking it (for exactly the amount of times it has been
-- blocked before) reverts its "blocked" state, so the handler will be
-- recognized by the signal system and is called upon future or currently
-- ongoing signal emissions (since the order in which handlers are called
-- during signal emissions is deterministic, whether the unblocked
-- handler in question is called as part of a currently ongoing emission
-- depends on how far that emission has proceeded yet).
--
-- The handlerId has to be a valid id of a signal handler
-- that is connected to a signal of instance and is
-- currently blocked.
signalHandlerUnblock :: (HasCallStack, MonadIO m, IsObject a) => a -> CULong -> m ()
-- | Blocks all handlers on an instance that match a certain selection
-- criteria. The criteria mask is passed as an OR-ed combination of
-- SignalMatchType flags, and the criteria values are passed as
-- arguments. Passing at least one of the SignalMatchTypeClosure,
-- SignalMatchTypeFunc or SignalMatchTypeData match flags
-- is required for successful matches. If no handlers were found, 0 is
-- returned, the number of blocked handlers otherwise.
signalHandlersBlockMatched :: (HasCallStack, MonadIO m, IsObject a) => a -> [SignalMatchType] -> Word32 -> Word32 -> Maybe (GClosure b) -> Ptr () -> Ptr () -> m Word32
-- | Destroy all signal handlers of a type instance. This function is an
-- implementation detail of the Object dispose implementation, and
-- should not be used outside of the type system.
signalHandlersDestroy :: (HasCallStack, MonadIO m, IsObject a) => a -> m ()
-- | Disconnects all handlers on an instance that match a certain selection
-- criteria. The criteria mask is passed as an OR-ed combination of
-- SignalMatchType flags, and the criteria values are passed as
-- arguments. Passing at least one of the SignalMatchTypeClosure,
-- SignalMatchTypeFunc or SignalMatchTypeData match flags
-- is required for successful matches. If no handlers were found, 0 is
-- returned, the number of disconnected handlers otherwise.
signalHandlersDisconnectMatched :: (HasCallStack, MonadIO m, IsObject a) => a -> [SignalMatchType] -> Word32 -> Word32 -> Maybe (GClosure b) -> Ptr () -> Ptr () -> m Word32
-- | Unblocks all handlers on an instance that match a certain selection
-- criteria. The criteria mask is passed as an OR-ed combination of
-- SignalMatchType flags, and the criteria values are passed as
-- arguments. Passing at least one of the SignalMatchTypeClosure,
-- SignalMatchTypeFunc or SignalMatchTypeData match flags
-- is required for successful matches. If no handlers were found, 0 is
-- returned, the number of unblocked handlers otherwise. The match
-- criteria should not apply to any handlers that are not currently
-- blocked.
signalHandlersUnblockMatched :: (HasCallStack, MonadIO m, IsObject a) => a -> [SignalMatchType] -> Word32 -> Word32 -> Maybe (GClosure b) -> Ptr () -> Ptr () -> m Word32
-- | Returns whether there are any handlers connected to
-- instance for the given signal id and detail.
--
-- If detail is 0 then it will only match handlers that
-- were connected without detail. If detail is non-zero
-- then it will match handlers connected both without detail and with the
-- given detail. This is consistent with how a signal emitted with
-- detail would be delivered to those handlers.
--
-- Since 2.46 this also checks for a non-default class closure being
-- installed, as this is basically always what you want.
--
-- One example of when you might use this is when the arguments to the
-- signal are difficult to compute. A class implementor may opt to not
-- emit the signal if no one is attached anyway, thus saving the cost of
-- building the arguments.
signalHasHandlerPending :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> Word32 -> Bool -> m Bool
-- | Lists the signals by id that a certain instance or interface type
-- created. Further information about the signals can be acquired through
-- signalQuery.
signalListIds :: (HasCallStack, MonadIO m) => GType -> m [Word32]
-- | Given the name of the signal and the type of object it connects to,
-- gets the signal's identifying integer. Emitting the signal by number
-- is somewhat faster than using the name each time.
--
-- Also tries the ancestors of the given type.
--
-- See g_signal_new() for details on allowed signal
-- names.
signalLookup :: (HasCallStack, MonadIO m) => Text -> GType -> m Word32
-- | Given the signal's identifier, finds its name.
--
-- Two different signals may have the same name, if they have differing
-- types.
signalName :: (HasCallStack, MonadIO m) => Word32 -> m Text
-- | Overrides the class closure (i.e. the default handler) for the given
-- signal for emissions on instances of instanceType.
-- instanceType must be derived from the type to which
-- the signal belongs.
--
-- See signalChainFromOverridden and
-- g_signal_chain_from_overridden_handler() for how to
-- chain up to the parent class closure from inside the overridden one.
signalOverrideClassClosure :: (HasCallStack, MonadIO m) => Word32 -> GType -> GClosure a -> m ()
-- | Internal function to parse a signal name into its
-- signalId and detail quark.
signalParseName :: (HasCallStack, MonadIO m) => Text -> GType -> Bool -> m (Bool, Word32, Word32)
-- | Queries the signal system for in-depth information about a specific
-- signal. This function will fill in a user-provided structure to hold
-- signal-specific information. If an invalid signal id is passed in, the
-- signalId member of the SignalQuery is 0. All
-- members filled into the SignalQuery structure should be
-- considered constant and have to be left untouched.
signalQuery :: (HasCallStack, MonadIO m) => Word32 -> m SignalQuery
-- | Deletes an emission hook.
signalRemoveEmissionHook :: (HasCallStack, MonadIO m) => Word32 -> CULong -> m ()
-- | Stops a signal's current emission.
--
-- This will prevent the default method from running, if the signal was
-- SignalFlagsRunLast and you connected normally (i.e. without the
-- "after" flag).
--
-- Prints a warning if used on a signal which isn't being emitted.
signalStopEmission :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> Word32 -> m ()
-- | Stops a signal's current emission.
--
-- This is just like signalStopEmission except it will look up the
-- signal id for you.
signalStopEmissionByName :: (HasCallStack, MonadIO m, IsObject a) => a -> Text -> m ()
-- | Creates a new closure which invokes the function found at the offset
-- structOffset in the class structure of the interface
-- or classed type identified by itype.
signalTypeCclosureNew :: (HasCallStack, MonadIO m) => GType -> Word32 -> m (GClosure a)
-- | Set the callback for a source as a Closure.
--
-- If the source is not one of the standard GLib types, the
-- closureCallback and closureMarshal
-- fields of the SourceFuncs structure must have been filled in
-- with pointers to appropriate functions.
sourceSetClosure :: (HasCallStack, MonadIO m) => Source -> GClosure a -> m ()
-- | Sets a dummy callback for source. The callback will do
-- nothing, and if the source expects a Bool return value, it will
-- return True. (If the source expects any other type of return
-- value, it will return a 0/Nothing value; whatever
-- valueInit initializes a Value to for that type.)
--
-- If the source is not one of the standard GLib types, the
-- closureCallback and closureMarshal
-- fields of the SourceFuncs structure must have been filled in
-- with pointers to appropriate functions.
sourceSetDummyCallback :: (HasCallStack, MonadIO m) => Source -> m ()
-- | Return a newly allocated string, which describes the contents of a
-- Value. The main purpose of this function is to describe
-- Value contents for debugging output, the way in which the
-- contents are described may change between different GLib versions.
strdupValueContents :: (HasCallStack, MonadIO m) => GValue -> m Text
-- | Registers a private class structure for a classed type; when the class
-- is allocated, the private structures for the class and all of its
-- parent types are allocated sequentially in the same memory block as
-- the public structures, and are zero-filled.
--
-- This function should be called in the type's
-- get_type() function after the type is registered. The
-- private structure can be retrieved using the
-- G_TYPE_CLASS_GET_PRIVATE() macro.
--
-- Since: 2.24
typeAddClassPrivate :: (HasCallStack, MonadIO m) => GType -> Word64 -> m ()
-- | No description available in the introspection data.
typeAddInstancePrivate :: (HasCallStack, MonadIO m) => GType -> Word64 -> m Int32
-- | Adds the dynamic interfaceType to
-- instantiableType. The information contained in the
-- TypePlugin structure pointed to by plugin is
-- used to manage the relationship.
typeAddInterfaceDynamic :: (HasCallStack, MonadIO m, IsTypePlugin a) => GType -> GType -> a -> m ()
-- | Adds the static interfaceType to
-- instantiableType. The information contained in the
-- InterfaceInfo structure pointed to by info is
-- used to manage the relationship.
typeAddInterfaceStatic :: (HasCallStack, MonadIO m) => GType -> GType -> InterfaceInfo -> m ()
-- | No description available in the introspection data.
typeCheckClassIsA :: (HasCallStack, MonadIO m) => TypeClass -> GType -> m Bool
-- | Private helper function to aid implementation of the
-- G_TYPE_CHECK_INSTANCE() macro.
typeCheckInstance :: (HasCallStack, MonadIO m) => TypeInstance -> m Bool
-- | No description available in the introspection data.
typeCheckInstanceIsA :: (HasCallStack, MonadIO m) => TypeInstance -> GType -> m Bool
-- | No description available in the introspection data.
typeCheckInstanceIsFundamentallyA :: (HasCallStack, MonadIO m) => TypeInstance -> GType -> m Bool
-- | No description available in the introspection data.
typeCheckIsValueType :: (HasCallStack, MonadIO m) => GType -> m Bool
-- | No description available in the introspection data.
typeCheckValue :: (HasCallStack, MonadIO m) => GValue -> m Bool
-- | No description available in the introspection data.
typeCheckValueHolds :: (HasCallStack, MonadIO m) => GValue -> GType -> m Bool
-- | Return a newly allocated and 0-terminated array of type IDs, listing
-- the child types of type.
typeChildren :: (HasCallStack, MonadIO m) => GType -> m [GType]
-- | If the interface type gType is currently in use,
-- returns its default interface vtable.
--
-- Since: 2.4
typeDefaultInterfacePeek :: (HasCallStack, MonadIO m) => GType -> m TypeInterface
-- | Increments the reference count for the interface type
-- gType, and returns the default interface vtable for
-- the type.
--
-- If the type is not currently in use, then the default vtable for the
-- type will be created and initalized by calling the base interface init
-- and default vtable init functions for the type (the
-- baseInit and classInit members of
-- TypeInfo). Calling typeDefaultInterfaceRef is useful
-- when you want to make sure that signals and properties for an
-- interface have been installed.
--
-- Since: 2.4
typeDefaultInterfaceRef :: (HasCallStack, MonadIO m) => GType -> m TypeInterface
-- | Decrements the reference count for the type corresponding to the
-- interface default vtable gIface. If the type is
-- dynamic, then when no one is using the interface and all references
-- have been released, the finalize function for the interface's default
-- vtable (the classFinalize member of TypeInfo)
-- will be called.
--
-- Since: 2.4
typeDefaultInterfaceUnref :: (HasCallStack, MonadIO m) => TypeInterface -> m ()
-- | Returns the length of the ancestry of the passed in type. This
-- includes the type itself, so that e.g. a fundamental type has depth 1.
typeDepth :: (HasCallStack, MonadIO m) => GType -> m Word32
-- | Ensures that the indicated type has been registered
-- with the type system, and its _class_init() method has
-- been run.
--
-- In theory, simply calling the type's _get_type()
-- method (or using the corresponding macro) is supposed take care of
-- this. However, _get_type() methods are often marked
-- G_GNUC_CONST for performance reasons, even though this
-- is technically incorrect (since G_GNUC_CONST requires
-- that the function not have side effects, which
-- _get_type() methods do on the first call). As a
-- result, if you write a bare call to a _get_type()
-- macro, it may get optimized out by the compiler. Using
-- typeEnsure guarantees that the type's
-- _get_type() method is called.
--
-- Since: 2.34
typeEnsure :: (HasCallStack, MonadIO m) => GType -> m ()
-- | Frees an instance of a type, returning it to the instance pool for the
-- type, if there is one.
--
-- Like g_type_create_instance(), this function is
-- reserved for implementors of fundamental types.
typeFreeInstance :: (HasCallStack, MonadIO m) => TypeInstance -> m ()
-- | Lookup the type ID from a given type name, returning 0 if no type has
-- been registered under this name (this is the preferred method to find
-- out by name whether a specific type has been registered yet).
typeFromName :: (HasCallStack, MonadIO m) => Text -> m GType
-- | Internal function, used to extract the fundamental type ID portion.
-- Use G_TYPE_FUNDAMENTAL() instead.
typeFundamental :: (HasCallStack, MonadIO m) => GType -> m GType
-- | Returns the next free fundamental type id which can be used to
-- register a new fundamental type with typeRegisterFundamental.
-- The returned type ID represents the highest currently registered
-- fundamental type identifier.
typeFundamentalNext :: (HasCallStack, MonadIO m) => m GType
-- | Returns the number of instances allocated of the particular type; this
-- is only available if GLib is built with debugging support and the
-- instance_count debug flag is set (by setting the GOBJECT_DEBUG
-- variable to include instance-count).
--
-- Since: 2.44
typeGetInstanceCount :: (HasCallStack, MonadIO m) => GType -> m Int32
-- | Returns the TypePlugin structure for type.
typeGetPlugin :: (HasCallStack, MonadIO m) => GType -> m TypePlugin
-- | Obtains data which has previously been attached to
-- type with typeSetQdata.
--
-- Note that this does not take subtyping into account; data attached to
-- one type with typeSetQdata cannot be retrieved from a subtype
-- using typeGetQdata.
typeGetQdata :: (HasCallStack, MonadIO m) => GType -> Word32 -> m (Ptr ())
-- | Returns an opaque serial number that represents the state of the set
-- of registered types. Any time a type is registered this serial
-- changes, which means you can cache information based on type lookups
-- (such as typeFromName) and know if the cache is still valid at
-- a later time by comparing the current serial with the one at the type
-- lookup.
--
-- Since: 2.36
typeGetTypeRegistrationSerial :: (HasCallStack, MonadIO m) => m Word32
-- | This function used to initialise the type system. Since GLib 2.36, the
-- type system is initialised automatically and this function does
-- nothing.
-- | Deprecated: (Since version 2.36)the type system is now initialised
-- automatically
typeInit :: (HasCallStack, MonadIO m) => m ()
-- | This function used to initialise the type system with debugging flags.
-- Since GLib 2.36, the type system is initialised automatically and this
-- function does nothing.
--
-- If you need to enable debugging features, use the GOBJECT_DEBUG
-- environment variable.
-- | Deprecated: (Since version 2.36)the type system is now initialised
-- automatically
typeInitWithDebugFlags :: (HasCallStack, MonadIO m) => [TypeDebugFlags] -> m ()
-- | Return a newly allocated and 0-terminated array of type IDs, listing
-- the interface types that type conforms to.
typeInterfaces :: (HasCallStack, MonadIO m) => GType -> m [GType]
-- | If isAType is a derivable type, check whether
-- type is a descendant of isAType. If
-- isAType is an interface, check whether
-- type conforms to it.
typeIsA :: (HasCallStack, MonadIO m) => GType -> GType -> m Bool
-- | Get the unique name that is assigned to a type ID. Note that this
-- function (like all other GType API) cannot cope with invalid type IDs.
-- G_TYPE_INVALID may be passed to this function, as may
-- be any other validly registered type ID, but randomized type IDs
-- should not be passed in and will most likely lead to a crash.
typeName :: (HasCallStack, MonadIO m) => GType -> m Text
-- | No description available in the introspection data.
typeNameFromClass :: (HasCallStack, MonadIO m) => TypeClass -> m Text
-- | No description available in the introspection data.
typeNameFromInstance :: (HasCallStack, MonadIO m) => TypeInstance -> m Text
-- | Given a leafType and a rootType which
-- is contained in its anchestry, return the type that
-- rootType is the immediate parent of. In other words,
-- this function determines the type that is derived directly from
-- rootType which is also a base class of
-- leafType. Given a root type and a leaf type, this
-- function can be used to determine the types and order in which the
-- leaf type is descended from the root type.
typeNextBase :: (HasCallStack, MonadIO m) => GType -> GType -> m GType
-- | Return the direct parent type of the passed in type. If the passed in
-- type has no parent, i.e. is a fundamental type, 0 is returned.
typeParent :: (HasCallStack, MonadIO m) => GType -> m GType
-- | Get the corresponding quark of the type IDs name.
typeQname :: (HasCallStack, MonadIO m) => GType -> m Word32
-- | Queries the type system for information about a specific type. This
-- function will fill in a user-provided structure to hold type-specific
-- information. If an invalid GType is passed in, the
-- type member of the TypeQuery is 0. All members
-- filled into the TypeQuery structure should be considered
-- constant and have to be left untouched.
typeQuery :: (HasCallStack, MonadIO m) => GType -> m TypeQuery
-- | Registers typeName as the name of a new dynamic type
-- derived from parentType. The type system uses the
-- information contained in the TypePlugin structure pointed to by
-- plugin to manage the type and its instances (if not
-- abstract). The value of flags determines the nature
-- (e.g. abstract or not) of the type.
typeRegisterDynamic :: (HasCallStack, MonadIO m, IsTypePlugin a) => GType -> Text -> a -> [TypeFlags] -> m GType
-- | Registers typeId as the predefined identifier and
-- typeName as the name of a fundamental type. If
-- typeId is already registered, or a type named
-- typeName is already registered, the behaviour is
-- undefined. The type system uses the information contained in the
-- TypeInfo structure pointed to by info and the
-- TypeFundamentalInfo structure pointed to by
-- finfo to manage the type and its instances. The value
-- of flags determines additional characteristics of the
-- fundamental type.
typeRegisterFundamental :: (HasCallStack, MonadIO m) => GType -> Text -> TypeInfo -> TypeFundamentalInfo -> [TypeFlags] -> m GType
-- | Registers typeName as the name of a new static type
-- derived from parentType. The type system uses the
-- information contained in the TypeInfo structure pointed to by
-- info to manage the type and its instances (if not
-- abstract). The value of flags determines the nature
-- (e.g. abstract or not) of the type.
typeRegisterStatic :: (HasCallStack, MonadIO m) => GType -> Text -> TypeInfo -> [TypeFlags] -> m GType
-- | Attaches arbitrary data to a type.
typeSetQdata :: (HasCallStack, MonadIO m) => GType -> Word32 -> Ptr () -> m ()
-- | No description available in the introspection data.
typeTestFlags :: (HasCallStack, MonadIO m) => GType -> Word32 -> m Bool
-- | No description available in the introspection data.
module GI.GObject.Unions.TypeCValue
-- | Memory-managed wrapper type.
newtype TypeCValue
TypeCValue :: ManagedPtr TypeCValue -> TypeCValue
-- | A convenience alias for Nothing :: Maybe
-- TypeCValue.
noTypeCValue :: Maybe TypeCValue
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Unions.TypeCValue.TypeCValue
-- | No description available in the introspection data.
module GI.GObject.Unions.Value_Data_Union_
-- | Memory-managed wrapper type.
newtype Value_Data_Union_
Value_Data_Union_ :: ManagedPtr Value_Data_Union_ -> Value_Data_Union_
-- | Construct a Value_Data_Union_ struct initialized to zero.
newZeroValue_Data_Union_ :: MonadIO m => m Value_Data_Union_
-- | A convenience alias for Nothing :: Maybe
-- Value_Data_Union_.
noValue_Data_Union_ :: Maybe Value_Data_Union_
-- | Get the value of the “v_double” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get value_Data_Union_ #vDouble
--
getValue_Data_Union_VDouble :: MonadIO m => Value_Data_Union_ -> m Double
-- | Set the value of the “v_double” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set value_Data_Union_ [ #vDouble := value ]
--
setValue_Data_Union_VDouble :: MonadIO m => Value_Data_Union_ -> Double -> m ()
-- | Get the value of the “v_float” field. When overloading
-- is enabled, this is equivalent to
--
--
-- get value_Data_Union_ #vFloat
--
getValue_Data_Union_VFloat :: MonadIO m => Value_Data_Union_ -> m Float
-- | Set the value of the “v_float” field. When overloading
-- is enabled, this is equivalent to
--
--
-- set value_Data_Union_ [ #vFloat := value ]
--
setValue_Data_Union_VFloat :: MonadIO m => Value_Data_Union_ -> Float -> m ()
-- | Get the value of the “v_int” field. When overloading
-- is enabled, this is equivalent to
--
--
-- get value_Data_Union_ #vInt
--
getValue_Data_Union_VInt :: MonadIO m => Value_Data_Union_ -> m Int32
-- | Set the value of the “v_int” field. When overloading
-- is enabled, this is equivalent to
--
--
-- set value_Data_Union_ [ #vInt := value ]
--
setValue_Data_Union_VInt :: MonadIO m => Value_Data_Union_ -> Int32 -> m ()
-- | Get the value of the “v_int64” field. When overloading
-- is enabled, this is equivalent to
--
--
-- get value_Data_Union_ #vInt64
--
getValue_Data_Union_VInt64 :: MonadIO m => Value_Data_Union_ -> m Int64
-- | Set the value of the “v_int64” field. When overloading
-- is enabled, this is equivalent to
--
--
-- set value_Data_Union_ [ #vInt64 := value ]
--
setValue_Data_Union_VInt64 :: MonadIO m => Value_Data_Union_ -> Int64 -> m ()
-- | Get the value of the “v_long” field. When overloading
-- is enabled, this is equivalent to
--
--
-- get value_Data_Union_ #vLong
--
getValue_Data_Union_VLong :: MonadIO m => Value_Data_Union_ -> m CLong
-- | Set the value of the “v_long” field. When overloading
-- is enabled, this is equivalent to
--
--
-- set value_Data_Union_ [ #vLong := value ]
--
setValue_Data_Union_VLong :: MonadIO m => Value_Data_Union_ -> CLong -> m ()
-- | Set the value of the “v_pointer” field to Nothing.
-- When overloading is enabled, this is equivalent to
--
--
-- clear #vPointer
--
clearValue_Data_Union_VPointer :: MonadIO m => Value_Data_Union_ -> m ()
-- | Get the value of the “v_pointer” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get value_Data_Union_ #vPointer
--
getValue_Data_Union_VPointer :: MonadIO m => Value_Data_Union_ -> m (Ptr ())
-- | Set the value of the “v_pointer” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set value_Data_Union_ [ #vPointer := value ]
--
setValue_Data_Union_VPointer :: MonadIO m => Value_Data_Union_ -> Ptr () -> m ()
-- | Get the value of the “v_uint” field. When overloading
-- is enabled, this is equivalent to
--
--
-- get value_Data_Union_ #vUint
--
getValue_Data_Union_VUint :: MonadIO m => Value_Data_Union_ -> m Word32
-- | Set the value of the “v_uint” field. When overloading
-- is enabled, this is equivalent to
--
--
-- set value_Data_Union_ [ #vUint := value ]
--
setValue_Data_Union_VUint :: MonadIO m => Value_Data_Union_ -> Word32 -> m ()
-- | Get the value of the “v_uint64” field. When
-- overloading is enabled, this is equivalent to
--
--
-- get value_Data_Union_ #vUint64
--
getValue_Data_Union_VUint64 :: MonadIO m => Value_Data_Union_ -> m Word64
-- | Set the value of the “v_uint64” field. When
-- overloading is enabled, this is equivalent to
--
--
-- set value_Data_Union_ [ #vUint64 := value ]
--
setValue_Data_Union_VUint64 :: MonadIO m => Value_Data_Union_ -> Word64 -> m ()
-- | Get the value of the “v_ulong” field. When overloading
-- is enabled, this is equivalent to
--
--
-- get value_Data_Union_ #vUlong
--
getValue_Data_Union_VUlong :: MonadIO m => Value_Data_Union_ -> m CULong
-- | Set the value of the “v_ulong” field. When overloading
-- is enabled, this is equivalent to
--
--
-- set value_Data_Union_ [ #vUlong := value ]
--
setValue_Data_Union_VUlong :: MonadIO m => Value_Data_Union_ -> CULong -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_
instance (tag Data.Type.Equality.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_ tag
module GI.GObject.Unions
module GI.GObject