-- 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.31


-- | Build time configuration used during code generation.
module GI.GObject.Config

-- | Overrides used when generating these bindings.
overrides :: Text


module GI.GObject.Constants

-- | If passed to <tt><i>G_VALUE_COLLECT()</i></tt>, allocated data won't
--   be copied but used verbatim. This does not affect ref-counted types
--   like objects. This does not affect usage of <a>valueCopy</a>, the data
--   will be copied if it is not ref-counted.
pattern VALUE_NOCOPY_CONTENTS :: Int32

-- | For string values, indicates that the string contained is canonical
--   and will exist for the duration of the process. See
--   <a>valueSetInternedString</a>.
--   
--   <i>Since: 2.66</i>
pattern VALUE_INTERNED_STRING :: Int32

-- | The maximal number of <tt><i>GTypeCValues</i></tt> which can be
--   collected for a single <a>Value</a>.
pattern VALUE_COLLECT_FORMAT_MAX_LENGTH :: Int32

-- | First available fundamental type number to create new fundamental type
--   id with <tt><i>G_TYPE_MAKE_FUNDAMENTAL()</i></tt>.
pattern TYPE_RESERVED_USER_FIRST :: Int32

-- | Last fundamental type number reserved for GLib.
pattern TYPE_RESERVED_GLIB_LAST :: Int32

-- | First fundamental type number to create a new fundamental type id with
--   <tt><i>G_TYPE_MAKE_FUNDAMENTAL()</i></tt> reserved for GLib.
pattern TYPE_RESERVED_GLIB_FIRST :: Int32

-- | Last fundamental type number reserved for BSE.
pattern TYPE_RESERVED_BSE_LAST :: Int32

-- | First fundamental type number to create a new fundamental type id with
--   <tt><i>G_TYPE_MAKE_FUNDAMENTAL()</i></tt> reserved for BSE.
pattern TYPE_RESERVED_BSE_FIRST :: Int32

-- | Shift value used in converting numbers to type IDs.
pattern TYPE_FUNDAMENTAL_SHIFT :: Int32

-- | An integer constant that represents the number of identifiers reserved
--   for types that are assigned at compile-time.
pattern TYPE_FUNDAMENTAL_MAX :: Int32

-- | A bit in the type number that's supposed to be left untouched.
pattern TYPE_FLAG_RESERVED_ID_BIT :: CSize

-- | A mask for all <a>SignalMatchType</a> bits.
pattern SIGNAL_MATCH_MASK :: Int32

-- | A mask for all <a>SignalFlags</a> bits.
pattern SIGNAL_FLAGS_MASK :: Int32

-- | Minimum shift count to be used for user defined flags, to be stored in
--   <a>ParamSpec</a>.<tt><i>flags</i></tt>. The maximum allowed is 10.
pattern PARAM_USER_SHIFT :: Int32

-- | <a>ParamFlags</a> value alias for <a>ParamFlagsStaticName</a> |
--   <a>ParamFlagsStaticNick</a> | <a>ParamFlagsStaticBlurb</a>.
--   
--   It is recommended to use this for all properties by default, as it
--   allows for internal performance improvements in GObject.
--   
--   It is very rare that a property would have a dynamically constructed
--   name, nickname or blurb.
--   
--   Since 2.13.0
pattern PARAM_STATIC_STRINGS :: Int32

-- | Mask containing the bits of <a>ParamSpec</a>.<tt><i>flags</i></tt>
--   which are reserved for GLib.
pattern PARAM_MASK :: Int32


module GI.GObject.Flags

-- | Flags to be passed to <a>objectBindProperty</a> or
--   <tt><i>g_object_bind_property_full()</i></tt>.
--   
--   This enumeration can be extended at later date.
--   
--   <i>Since: 2.26</i>
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
--   <a>True</a> will result in the other being set to <a>False</a> and
--   vice versa. This flag will only work for boolean properties, and
--   cannot be used when passing custom transformation functions to
--   <tt><i>g_object_bind_property_full()</i></tt>.
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

-- | Default behaviour (no special flags). Since: 2.74
ConnectFlagsDefault :: ConnectFlags

-- | If set, the handler should be called after the default handler of the
--   signal. Normally, the handler is called before the default handler.
ConnectFlagsAfter :: ConnectFlags

-- | If set, the instance and data should be swapped when calling the
--   handler; see <tt><i>g_signal_connect_swapped()</i></tt> for an
--   example.
ConnectFlagsSwapped :: ConnectFlags

-- | Catch-all for unknown values
AnotherConnectFlags :: Int -> ConnectFlags

-- | <i>No description available in the introspection data.</i>
data IOCondition

-- | <i>No description available in the introspection data.</i>
IOConditionIn :: IOCondition

-- | <i>No description available in the introspection data.</i>
IOConditionOut :: IOCondition

-- | <i>No description available in the introspection data.</i>
IOConditionPri :: IOCondition

-- | <i>No description available in the introspection data.</i>
IOConditionErr :: IOCondition

-- | <i>No description available in the introspection data.</i>
IOConditionHup :: IOCondition

-- | <i>No description available in the introspection data.</i>
IOConditionNval :: IOCondition

-- | Catch-all for unknown values
AnotherIOCondition :: Int -> IOCondition

-- | Through the <a>ParamFlags</a> flag values, certain aspects of
--   parameters can be configured.
--   
--   See also: <a>PARAM_STATIC_STRINGS</a>
data ParamFlags

-- | the parameter is readable
ParamFlagsReadable :: ParamFlags

-- | the parameter is writable
ParamFlagsWritable :: ParamFlags

-- | alias for <a>ParamFlagsReadable</a> | <a>ParamFlagsWritable</a>
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 <a>paramValueConvert</a>) 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 <a>objectSetProperty</a> for this property will not
--   automatically result in a "notify" signal being emitted: the
--   implementation must call <a>objectNotify</a> 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.
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 "<a>detail</a>" 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 <tt><i>g_signal_emit()</i></tt> 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

-- | Only used in <a>SignalAccumulator</a> accumulator functions for the
--   <a>SignalInvocationHint</a>::<tt><i>run_type</i></tt> field to mark
--   the first call to the accumulator function for a signal emission.
--   Since 2.68.
SignalFlagsAccumulatorFirstRun :: SignalFlags

-- | Catch-all for unknown values
AnotherSignalFlags :: Int -> SignalFlags

-- | The match types specify what <a>signalHandlersBlockMatched</a>,
--   <a>signalHandlersUnblockMatched</a> and
--   <a>signalHandlersDisconnectMatched</a> match signals by.
data SignalMatchType

-- | The signal id must be equal.
SignalMatchTypeId :: SignalMatchType

-- | The signal detail must 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 be matched.
SignalMatchTypeUnblocked :: SignalMatchType

-- | Catch-all for unknown values
AnotherSignalMatchType :: Int -> SignalMatchType

-- | These flags used to be passed to <a>typeInitWithDebugFlags</a> which
--   is now deprecated.
--   
--   If you need to enable debugging features, use the
--   <tt>GOBJECT_DEBUG</tt> environment variable.

-- | <i>Deprecated: (Since version 2.36)<a>typeInit</a> is now done
--   automatically</i>
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

-- | No special flags. Since: 2.74
TypeFlagsNone :: 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 <a>valueInit</a>
TypeFlagsValueAbstract :: TypeFlags

-- | Indicates a final type. A final type is a non-derivable leaf node in a
--   deep derivable type hierarchy tree. Since: 2.70
TypeFlagsFinal :: TypeFlags

-- | The type is deprecated and may be removed in a future version. A
--   warning will be emitted if it is instantiated while running with
--   <tt>G_ENABLE_DIAGNOSTIC=1</tt>. Since 2.76
TypeFlagsDeprecated :: 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 instantiatable 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.TypeFundamentalFlags
instance GHC.Show.Show GI.GObject.Flags.TypeFundamentalFlags
instance GHC.Classes.Eq GI.GObject.Flags.TypeFlags
instance GHC.Show.Show GI.GObject.Flags.TypeFlags
instance GHC.Classes.Eq GI.GObject.Flags.TypeDebugFlags
instance GHC.Show.Show GI.GObject.Flags.TypeDebugFlags
instance GHC.Classes.Eq GI.GObject.Flags.SignalMatchType
instance GHC.Show.Show GI.GObject.Flags.SignalMatchType
instance GHC.Classes.Eq GI.GObject.Flags.SignalFlags
instance GHC.Show.Show GI.GObject.Flags.SignalFlags
instance GHC.Classes.Eq GI.GObject.Flags.ParamFlags
instance GHC.Show.Show GI.GObject.Flags.ParamFlags
instance GHC.Classes.Eq GI.GObject.Flags.IOCondition
instance GHC.Show.Show GI.GObject.Flags.IOCondition
instance GHC.Classes.Eq GI.GObject.Flags.ConnectFlags
instance GHC.Show.Show GI.GObject.Flags.ConnectFlags
instance GHC.Classes.Eq GI.GObject.Flags.BindingFlags
instance GHC.Show.Show GI.GObject.Flags.BindingFlags
instance GHC.Enum.Enum GI.GObject.Flags.BindingFlags
instance GHC.Classes.Ord GI.GObject.Flags.BindingFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Flags.BindingFlags
instance Data.GI.Base.BasicTypes.TypedObject 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.IOCondition
instance GHC.Classes.Ord GI.GObject.Flags.IOCondition
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Flags.IOCondition
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Flags.IOCondition
instance Data.GI.Base.BasicTypes.BoxedFlags GI.GObject.Flags.IOCondition
instance Data.GI.Base.BasicTypes.IsGFlag GI.GObject.Flags.IOCondition
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


-- | <tt>GParamSpec</tt> encapsulates the metadata required to specify
--   parameters, such as <tt>GObject</tt> properties.
--   
--   <h2>Parameter names</h2>
--   
--   A property name consists of one or more segments consisting of ASCII
--   letters and digits, separated by either the <tt>-</tt> or <tt>_</tt>
--   character. The first character of a property name must be a letter.
--   These are the same rules as for signal naming (see
--   <tt><i>GObject.signal_new</i></tt>).
--   
--   When creating and looking up a <tt>GParamSpec</tt>, either separator
--   can be used, but they cannot be mixed. Using <tt>-</tt> is
--   considerably more efficient, and is the ‘canonical form’. Using
--   <tt>_</tt> is discouraged.
module GI.GObject.Objects.ParamSpec

-- | Memory-managed wrapper type.
newtype ParamSpec
ParamSpec :: ManagedPtr ParamSpec -> ParamSpec

-- | Type class for types which can be safely cast to <a>ParamSpec</a>, for
--   instance with <a>toParamSpec</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpec o) => IsParamSpec o

-- | Cast to <a>ParamSpec</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toParamSpec :: (MonadIO m, IsParamSpec o) => o -> m ParamSpec

-- | Get the short description of a <a>ParamSpec</a>.
paramSpecGetBlurb :: (HasCallStack, MonadIO m) => GParamSpec -> m (Maybe Text)

-- | Gets the default value of <i><tt>pspec</tt></i> as a pointer to a
--   <a>Value</a>.
--   
--   The <a>Value</a> will remain valid for the life of
--   <i><tt>pspec</tt></i>.
--   
--   <i>Since: 2.38</i>
paramSpecGetDefaultValue :: (HasCallStack, MonadIO m) => GParamSpec -> m GValue

-- | Get the name of a <a>ParamSpec</a>.
--   
--   The name is always an "interned" string (as per <a>internString</a>).
--   This allows for pointer-value comparisons.
paramSpecGetName :: (HasCallStack, MonadIO m) => GParamSpec -> m Text

-- | Gets the GQuark for the name.
--   
--   <i>Since: 2.46</i>
paramSpecGetNameQuark :: (HasCallStack, MonadIO m) => GParamSpec -> m Word32

-- | Get the nickname of a <a>ParamSpec</a>.
paramSpecGetNick :: (HasCallStack, MonadIO m) => GParamSpec -> m Text

-- | Gets back user data pointers stored via <a>paramSpecSetQdata</a>.
paramSpecGetQdata :: (HasCallStack, MonadIO m) => GParamSpec -> Word32 -> m (Ptr ())

-- | If the paramspec redirects operations to another paramspec, returns
--   that paramspec. Redirect is used typically for providing a new
--   implementation of a property in a derived type while preserving all
--   the properties from the parent type. Redirection is established by
--   creating a property of type <a>ParamSpecOverride</a>. See
--   <a>objectClassOverrideProperty</a> for an example of the use of this
--   capability.
--   
--   <i>Since: 2.4</i>
paramSpecGetRedirectTarget :: (HasCallStack, MonadIO m) => GParamSpec -> m (Maybe GParamSpec)

-- | Validate a property name for a <a>ParamSpec</a>. This can be useful
--   for dynamically-generated properties which need to be validated at
--   run-time before actually trying to create them.
--   
--   See [canonical parameter names][canonical-parameter-names] for details
--   of the rules for valid names.
--   
--   <i>Since: 2.66</i>
paramSpecIsValidName :: (HasCallStack, MonadIO m) => Text -> m Bool

-- | Sets an opaque, named pointer on a <a>ParamSpec</a>. The name is
--   specified through a <tt><i>GQuark</i></tt> (retrieved e.g. via
--   <a>quarkFromStaticString</a>), and the pointer can be gotten back from
--   the <i><tt>pspec</tt></i> with <a>paramSpecGetQdata</a>. Setting a
--   previously set user data pointer, overrides (frees) the old pointer
--   set, using <a>Nothing</a> as pointer essentially removes the data
--   stored.
paramSpecSetQdata :: (HasCallStack, MonadIO m) => GParamSpec -> Word32 -> Ptr () -> m ()

-- | The initial reference count of a newly created <a>ParamSpec</a> is 1,
--   even though no one has explicitly called
--   <tt><i>g_param_spec_ref()</i></tt> on it yet. So the initial reference
--   count is flagged as "floating", until someone calls
--   <tt>g_param_spec_ref (pspec); g_param_spec_sink (pspec);</tt> in
--   sequence on it, taking over the initial reference count (thus ending
--   up with a <i><tt>pspec</tt></i> that has a reference count of 1 still,
--   but is not flagged "floating" anymore).
paramSpecSink :: (HasCallStack, MonadIO m) => GParamSpec -> m ()

-- | Gets back user data pointers stored via <a>paramSpecSetQdata</a> and
--   removes the <i><tt>data</tt></i> from <i><tt>pspec</tt></i> without
--   invoking its <tt><i>destroy()</i></tt> function (if any was set).
--   Usually, calling this function is only required to update user data
--   pointers with a destroy notifier.
paramSpecStealQdata :: (HasCallStack, MonadIO m) => GParamSpec -> Word32 -> m (Ptr ())
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpec.ParamSpec
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpec.ParamSpec o) => GI.GObject.Objects.ParamSpec.IsParamSpec o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpec.ParamSpec
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpec.ParamSpec
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpec.ParamSpec
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.GObject.Objects.ParamSpec.ParamSpec)
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpec.ParamSpec


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   boolean properties.
module GI.GObject.Objects.ParamSpecBoolean

-- | Memory-managed wrapper type.
newtype ParamSpecBoolean
ParamSpecBoolean :: ManagedPtr ParamSpecBoolean -> ParamSpecBoolean

-- | Type class for types which can be safely cast to
--   <a>ParamSpecBoolean</a>, for instance with <a>toParamSpecBoolean</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecBoolean o) => IsParamSpecBoolean o

-- | Cast to <a>ParamSpecBoolean</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toParamSpecBoolean :: (MonadIO m, IsParamSpecBoolean o) => o -> m ParamSpecBoolean
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecBoolean.ParamSpecBoolean
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecBoolean.ParamSpecBoolean o) => GI.GObject.Objects.ParamSpecBoolean.IsParamSpecBoolean o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecBoolean.ParamSpecBoolean
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecBoolean.ParamSpecBoolean
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecBoolean.ParamSpecBoolean
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecBoolean.ParamSpecBoolean


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   boxed properties.
module GI.GObject.Objects.ParamSpecBoxed

-- | Memory-managed wrapper type.
newtype ParamSpecBoxed
ParamSpecBoxed :: ManagedPtr ParamSpecBoxed -> ParamSpecBoxed

-- | Type class for types which can be safely cast to
--   <a>ParamSpecBoxed</a>, for instance with <a>toParamSpecBoxed</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecBoxed o) => IsParamSpecBoxed o

-- | Cast to <a>ParamSpecBoxed</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toParamSpecBoxed :: (MonadIO m, IsParamSpecBoxed o) => o -> m ParamSpecBoxed
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecBoxed.ParamSpecBoxed
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecBoxed.ParamSpecBoxed o) => GI.GObject.Objects.ParamSpecBoxed.IsParamSpecBoxed o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecBoxed.ParamSpecBoxed
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecBoxed.ParamSpecBoxed
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecBoxed.ParamSpecBoxed
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecBoxed.ParamSpecBoxed


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   character properties.
module GI.GObject.Objects.ParamSpecChar

-- | Memory-managed wrapper type.
newtype ParamSpecChar
ParamSpecChar :: ManagedPtr ParamSpecChar -> ParamSpecChar

-- | Type class for types which can be safely cast to <a>ParamSpecChar</a>,
--   for instance with <a>toParamSpecChar</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecChar o) => IsParamSpecChar o

-- | Cast to <a>ParamSpecChar</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toParamSpecChar :: (MonadIO m, IsParamSpecChar o) => o -> m ParamSpecChar
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecChar.ParamSpecChar
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecChar.ParamSpecChar o) => GI.GObject.Objects.ParamSpecChar.IsParamSpecChar o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecChar.ParamSpecChar
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecChar.ParamSpecChar
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecChar.ParamSpecChar
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecChar.ParamSpecChar


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   double properties.
module GI.GObject.Objects.ParamSpecDouble

-- | Memory-managed wrapper type.
newtype ParamSpecDouble
ParamSpecDouble :: ManagedPtr ParamSpecDouble -> ParamSpecDouble

-- | Type class for types which can be safely cast to
--   <a>ParamSpecDouble</a>, for instance with <a>toParamSpecDouble</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecDouble o) => IsParamSpecDouble o

-- | Cast to <a>ParamSpecDouble</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toParamSpecDouble :: (MonadIO m, IsParamSpecDouble o) => o -> m ParamSpecDouble
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecDouble.ParamSpecDouble
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecDouble.ParamSpecDouble o) => GI.GObject.Objects.ParamSpecDouble.IsParamSpecDouble o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecDouble.ParamSpecDouble
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecDouble.ParamSpecDouble
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecDouble.ParamSpecDouble
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecDouble.ParamSpecDouble


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   enum properties.
module GI.GObject.Objects.ParamSpecEnum

-- | Memory-managed wrapper type.
newtype ParamSpecEnum
ParamSpecEnum :: ManagedPtr ParamSpecEnum -> ParamSpecEnum

-- | Type class for types which can be safely cast to <a>ParamSpecEnum</a>,
--   for instance with <a>toParamSpecEnum</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecEnum o) => IsParamSpecEnum o

-- | Cast to <a>ParamSpecEnum</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toParamSpecEnum :: (MonadIO m, IsParamSpecEnum o) => o -> m ParamSpecEnum
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecEnum.ParamSpecEnum
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecEnum.ParamSpecEnum o) => GI.GObject.Objects.ParamSpecEnum.IsParamSpecEnum o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecEnum.ParamSpecEnum
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecEnum.ParamSpecEnum
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecEnum.ParamSpecEnum
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecEnum.ParamSpecEnum


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   flags properties.
module GI.GObject.Objects.ParamSpecFlags

-- | Memory-managed wrapper type.
newtype ParamSpecFlags
ParamSpecFlags :: ManagedPtr ParamSpecFlags -> ParamSpecFlags

-- | Type class for types which can be safely cast to
--   <a>ParamSpecFlags</a>, for instance with <a>toParamSpecFlags</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecFlags o) => IsParamSpecFlags o

-- | Cast to <a>ParamSpecFlags</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toParamSpecFlags :: (MonadIO m, IsParamSpecFlags o) => o -> m ParamSpecFlags
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecFlags.ParamSpecFlags
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecFlags.ParamSpecFlags o) => GI.GObject.Objects.ParamSpecFlags.IsParamSpecFlags o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecFlags.ParamSpecFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecFlags.ParamSpecFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecFlags.ParamSpecFlags
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecFlags.ParamSpecFlags


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   float properties.
module GI.GObject.Objects.ParamSpecFloat

-- | Memory-managed wrapper type.
newtype ParamSpecFloat
ParamSpecFloat :: ManagedPtr ParamSpecFloat -> ParamSpecFloat

-- | Type class for types which can be safely cast to
--   <a>ParamSpecFloat</a>, for instance with <a>toParamSpecFloat</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecFloat o) => IsParamSpecFloat o

-- | Cast to <a>ParamSpecFloat</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toParamSpecFloat :: (MonadIO m, IsParamSpecFloat o) => o -> m ParamSpecFloat
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecFloat.ParamSpecFloat
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecFloat.ParamSpecFloat o) => GI.GObject.Objects.ParamSpecFloat.IsParamSpecFloat o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecFloat.ParamSpecFloat
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecFloat.ParamSpecFloat
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecFloat.ParamSpecFloat
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecFloat.ParamSpecFloat


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   <a>GType</a> properties.
--   
--   <i>Since: 2.10</i>
module GI.GObject.Objects.ParamSpecGType

-- | Memory-managed wrapper type.
newtype ParamSpecGType
ParamSpecGType :: ManagedPtr ParamSpecGType -> ParamSpecGType

-- | Type class for types which can be safely cast to
--   <a>ParamSpecGType</a>, for instance with <a>toParamSpecGType</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecGType o) => IsParamSpecGType o

-- | Cast to <a>ParamSpecGType</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toParamSpecGType :: (MonadIO m, IsParamSpecGType o) => o -> m ParamSpecGType
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecGType.ParamSpecGType
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecGType.ParamSpecGType o) => GI.GObject.Objects.ParamSpecGType.IsParamSpecGType o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecGType.ParamSpecGType
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecGType.ParamSpecGType
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecGType.ParamSpecGType
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecGType.ParamSpecGType


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   integer properties.
module GI.GObject.Objects.ParamSpecInt

-- | Memory-managed wrapper type.
newtype ParamSpecInt
ParamSpecInt :: ManagedPtr ParamSpecInt -> ParamSpecInt

-- | Type class for types which can be safely cast to <a>ParamSpecInt</a>,
--   for instance with <a>toParamSpecInt</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecInt o) => IsParamSpecInt o

-- | Cast to <a>ParamSpecInt</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toParamSpecInt :: (MonadIO m, IsParamSpecInt o) => o -> m ParamSpecInt
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecInt.ParamSpecInt
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecInt.ParamSpecInt o) => GI.GObject.Objects.ParamSpecInt.IsParamSpecInt o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecInt.ParamSpecInt
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecInt.ParamSpecInt
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecInt.ParamSpecInt
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecInt.ParamSpecInt


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   64bit integer properties.
module GI.GObject.Objects.ParamSpecInt64

-- | Memory-managed wrapper type.
newtype ParamSpecInt64
ParamSpecInt64 :: ManagedPtr ParamSpecInt64 -> ParamSpecInt64

-- | Type class for types which can be safely cast to
--   <a>ParamSpecInt64</a>, for instance with <a>toParamSpecInt64</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecInt64 o) => IsParamSpecInt64 o

-- | Cast to <a>ParamSpecInt64</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toParamSpecInt64 :: (MonadIO m, IsParamSpecInt64 o) => o -> m ParamSpecInt64
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecInt64.ParamSpecInt64
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecInt64.ParamSpecInt64 o) => GI.GObject.Objects.ParamSpecInt64.IsParamSpecInt64 o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecInt64.ParamSpecInt64
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecInt64.ParamSpecInt64
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecInt64.ParamSpecInt64
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecInt64.ParamSpecInt64


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   long integer properties.
module GI.GObject.Objects.ParamSpecLong

-- | Memory-managed wrapper type.
newtype ParamSpecLong
ParamSpecLong :: ManagedPtr ParamSpecLong -> ParamSpecLong

-- | Type class for types which can be safely cast to <a>ParamSpecLong</a>,
--   for instance with <a>toParamSpecLong</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecLong o) => IsParamSpecLong o

-- | Cast to <a>ParamSpecLong</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toParamSpecLong :: (MonadIO m, IsParamSpecLong o) => o -> m ParamSpecLong
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecLong.ParamSpecLong
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecLong.ParamSpecLong o) => GI.GObject.Objects.ParamSpecLong.IsParamSpecLong o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecLong.ParamSpecLong
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecLong.ParamSpecLong
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecLong.ParamSpecLong
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecLong.ParamSpecLong


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   object properties.
module GI.GObject.Objects.ParamSpecObject

-- | Memory-managed wrapper type.
newtype ParamSpecObject
ParamSpecObject :: ManagedPtr ParamSpecObject -> ParamSpecObject

-- | Type class for types which can be safely cast to
--   <a>ParamSpecObject</a>, for instance with <a>toParamSpecObject</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecObject o) => IsParamSpecObject o

-- | Cast to <a>ParamSpecObject</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toParamSpecObject :: (MonadIO m, IsParamSpecObject o) => o -> m ParamSpecObject
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecObject.ParamSpecObject
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecObject.ParamSpecObject o) => GI.GObject.Objects.ParamSpecObject.IsParamSpecObject o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecObject.ParamSpecObject
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecObject.ParamSpecObject
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecObject.ParamSpecObject
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecObject.ParamSpecObject


-- | A <a>ParamSpec</a> derived structure that redirects operations to
--   other types of <a>ParamSpec</a>.
--   
--   All operations other than getting or setting the value are redirected,
--   including accessing the nick and blurb, validating a value, and so
--   forth.
--   
--   See <a>paramSpecGetRedirectTarget</a> for retrieving the overridden
--   property. <a>ParamSpecOverride</a> is used in implementing
--   <a>objectClassOverrideProperty</a>, and will not be directly useful
--   unless you are implementing a new base type similar to GObject.
--   
--   <i>Since: 2.4</i>
module GI.GObject.Objects.ParamSpecOverride

-- | Memory-managed wrapper type.
newtype ParamSpecOverride
ParamSpecOverride :: ManagedPtr ParamSpecOverride -> ParamSpecOverride

-- | Type class for types which can be safely cast to
--   <a>ParamSpecOverride</a>, for instance with
--   <a>toParamSpecOverride</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecOverride o) => IsParamSpecOverride o

-- | Cast to <a>ParamSpecOverride</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toParamSpecOverride :: (MonadIO m, IsParamSpecOverride o) => o -> m ParamSpecOverride
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecOverride.ParamSpecOverride
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecOverride.ParamSpecOverride o) => GI.GObject.Objects.ParamSpecOverride.IsParamSpecOverride o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecOverride.ParamSpecOverride
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecOverride.ParamSpecOverride
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecOverride.ParamSpecOverride
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecOverride.ParamSpecOverride


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   <tt><i>G_TYPE_PARAM</i></tt> properties.
module GI.GObject.Objects.ParamSpecParam

-- | Memory-managed wrapper type.
newtype ParamSpecParam
ParamSpecParam :: ManagedPtr ParamSpecParam -> ParamSpecParam

-- | Type class for types which can be safely cast to
--   <a>ParamSpecParam</a>, for instance with <a>toParamSpecParam</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecParam o) => IsParamSpecParam o

-- | Cast to <a>ParamSpecParam</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toParamSpecParam :: (MonadIO m, IsParamSpecParam o) => o -> m ParamSpecParam
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecParam.ParamSpecParam
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecParam.ParamSpecParam o) => GI.GObject.Objects.ParamSpecParam.IsParamSpecParam o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecParam.ParamSpecParam
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecParam.ParamSpecParam
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecParam.ParamSpecParam
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecParam.ParamSpecParam


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   pointer properties.
module GI.GObject.Objects.ParamSpecPointer

-- | Memory-managed wrapper type.
newtype ParamSpecPointer
ParamSpecPointer :: ManagedPtr ParamSpecPointer -> ParamSpecPointer

-- | Type class for types which can be safely cast to
--   <a>ParamSpecPointer</a>, for instance with <a>toParamSpecPointer</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecPointer o) => IsParamSpecPointer o

-- | Cast to <a>ParamSpecPointer</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toParamSpecPointer :: (MonadIO m, IsParamSpecPointer o) => o -> m ParamSpecPointer
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecPointer.ParamSpecPointer
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecPointer.ParamSpecPointer o) => GI.GObject.Objects.ParamSpecPointer.IsParamSpecPointer o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecPointer.ParamSpecPointer
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecPointer.ParamSpecPointer
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecPointer.ParamSpecPointer
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecPointer.ParamSpecPointer


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   string properties.
module GI.GObject.Objects.ParamSpecString

-- | Memory-managed wrapper type.
newtype ParamSpecString
ParamSpecString :: ManagedPtr ParamSpecString -> ParamSpecString

-- | Type class for types which can be safely cast to
--   <a>ParamSpecString</a>, for instance with <a>toParamSpecString</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecString o) => IsParamSpecString o

-- | Cast to <a>ParamSpecString</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toParamSpecString :: (MonadIO m, IsParamSpecString o) => o -> m ParamSpecString
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecString.ParamSpecString
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecString.ParamSpecString o) => GI.GObject.Objects.ParamSpecString.IsParamSpecString o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecString.ParamSpecString
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecString.ParamSpecString
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecString.ParamSpecString
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecString.ParamSpecString


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   unsigned character properties.
module GI.GObject.Objects.ParamSpecUChar

-- | Memory-managed wrapper type.
newtype ParamSpecUChar
ParamSpecUChar :: ManagedPtr ParamSpecUChar -> ParamSpecUChar

-- | Type class for types which can be safely cast to
--   <a>ParamSpecUChar</a>, for instance with <a>toParamSpecUChar</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecUChar o) => IsParamSpecUChar o

-- | Cast to <a>ParamSpecUChar</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toParamSpecUChar :: (MonadIO m, IsParamSpecUChar o) => o -> m ParamSpecUChar
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecUChar.ParamSpecUChar
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecUChar.ParamSpecUChar o) => GI.GObject.Objects.ParamSpecUChar.IsParamSpecUChar o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecUChar.ParamSpecUChar
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecUChar.ParamSpecUChar
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecUChar.ParamSpecUChar
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecUChar.ParamSpecUChar


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   unsigned integer properties.
module GI.GObject.Objects.ParamSpecUInt

-- | Memory-managed wrapper type.
newtype ParamSpecUInt
ParamSpecUInt :: ManagedPtr ParamSpecUInt -> ParamSpecUInt

-- | Type class for types which can be safely cast to <a>ParamSpecUInt</a>,
--   for instance with <a>toParamSpecUInt</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecUInt o) => IsParamSpecUInt o

-- | Cast to <a>ParamSpecUInt</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toParamSpecUInt :: (MonadIO m, IsParamSpecUInt o) => o -> m ParamSpecUInt
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecUInt.ParamSpecUInt
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecUInt.ParamSpecUInt o) => GI.GObject.Objects.ParamSpecUInt.IsParamSpecUInt o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecUInt.ParamSpecUInt
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecUInt.ParamSpecUInt
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecUInt.ParamSpecUInt
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecUInt.ParamSpecUInt


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   unsigned 64bit integer properties.
module GI.GObject.Objects.ParamSpecUInt64

-- | Memory-managed wrapper type.
newtype ParamSpecUInt64
ParamSpecUInt64 :: ManagedPtr ParamSpecUInt64 -> ParamSpecUInt64

-- | Type class for types which can be safely cast to
--   <a>ParamSpecUInt64</a>, for instance with <a>toParamSpecUInt64</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecUInt64 o) => IsParamSpecUInt64 o

-- | Cast to <a>ParamSpecUInt64</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toParamSpecUInt64 :: (MonadIO m, IsParamSpecUInt64 o) => o -> m ParamSpecUInt64
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecUInt64.ParamSpecUInt64
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecUInt64.ParamSpecUInt64 o) => GI.GObject.Objects.ParamSpecUInt64.IsParamSpecUInt64 o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecUInt64.ParamSpecUInt64
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecUInt64.ParamSpecUInt64
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecUInt64.ParamSpecUInt64
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecUInt64.ParamSpecUInt64


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   unsigned long integer properties.
module GI.GObject.Objects.ParamSpecULong

-- | Memory-managed wrapper type.
newtype ParamSpecULong
ParamSpecULong :: ManagedPtr ParamSpecULong -> ParamSpecULong

-- | Type class for types which can be safely cast to
--   <a>ParamSpecULong</a>, for instance with <a>toParamSpecULong</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecULong o) => IsParamSpecULong o

-- | Cast to <a>ParamSpecULong</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toParamSpecULong :: (MonadIO m, IsParamSpecULong o) => o -> m ParamSpecULong
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecULong.ParamSpecULong
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecULong.ParamSpecULong o) => GI.GObject.Objects.ParamSpecULong.IsParamSpecULong o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecULong.ParamSpecULong
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecULong.ParamSpecULong
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecULong.ParamSpecULong
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecULong.ParamSpecULong


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   unichar (unsigned integer) properties.
module GI.GObject.Objects.ParamSpecUnichar

-- | Memory-managed wrapper type.
newtype ParamSpecUnichar
ParamSpecUnichar :: ManagedPtr ParamSpecUnichar -> ParamSpecUnichar

-- | Type class for types which can be safely cast to
--   <a>ParamSpecUnichar</a>, for instance with <a>toParamSpecUnichar</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecUnichar o) => IsParamSpecUnichar o

-- | Cast to <a>ParamSpecUnichar</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toParamSpecUnichar :: (MonadIO m, IsParamSpecUnichar o) => o -> m ParamSpecUnichar
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecUnichar.ParamSpecUnichar
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecUnichar.ParamSpecUnichar o) => GI.GObject.Objects.ParamSpecUnichar.IsParamSpecUnichar o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecUnichar.ParamSpecUnichar
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecUnichar.ParamSpecUnichar
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecUnichar.ParamSpecUnichar
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecUnichar.ParamSpecUnichar


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   <a>ValueArray</a> properties.
module GI.GObject.Objects.ParamSpecValueArray

-- | Memory-managed wrapper type.
newtype ParamSpecValueArray
ParamSpecValueArray :: ManagedPtr ParamSpecValueArray -> ParamSpecValueArray

-- | Type class for types which can be safely cast to
--   <a>ParamSpecValueArray</a>, for instance with
--   <a>toParamSpecValueArray</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecValueArray o) => IsParamSpecValueArray o

-- | Cast to <a>ParamSpecValueArray</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toParamSpecValueArray :: (MonadIO m, IsParamSpecValueArray o) => o -> m ParamSpecValueArray
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecValueArray.ParamSpecValueArray
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecValueArray.ParamSpecValueArray o) => GI.GObject.Objects.ParamSpecValueArray.IsParamSpecValueArray o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecValueArray.ParamSpecValueArray
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecValueArray.ParamSpecValueArray
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecValueArray.ParamSpecValueArray
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecValueArray.ParamSpecValueArray


-- | A <a>ParamSpec</a> derived structure that contains the meta data for
--   <a>GVariant</a> properties.
--   
--   When comparing values with <a>paramValuesCmp</a>, scalar values with
--   the same type will be compared with <a>variantCompare</a>. Other
--   non-<a>Nothing</a> variants will be checked for equality with
--   <a>variantEqual</a>, and their sort order is otherwise undefined.
--   <a>Nothing</a> is ordered before non-<a>Nothing</a> variants. Two
--   <a>Nothing</a> values compare equal.
--   
--   <i>Since: 2.26</i>
module GI.GObject.Objects.ParamSpecVariant

-- | Memory-managed wrapper type.
newtype ParamSpecVariant
ParamSpecVariant :: ManagedPtr ParamSpecVariant -> ParamSpecVariant

-- | Type class for types which can be safely cast to
--   <a>ParamSpecVariant</a>, for instance with <a>toParamSpecVariant</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ParamSpecVariant o) => IsParamSpecVariant o

-- | Cast to <a>ParamSpecVariant</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toParamSpecVariant :: (MonadIO m, IsParamSpecVariant o) => o -> m ParamSpecVariant
instance GHC.Classes.Eq GI.GObject.Objects.ParamSpecVariant.ParamSpecVariant
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.ParamSpecVariant.ParamSpecVariant o) => GI.GObject.Objects.ParamSpecVariant.IsParamSpecVariant o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.ParamSpecVariant.ParamSpecVariant
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.ParamSpecVariant.ParamSpecVariant
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.ParamSpecVariant.ParamSpecVariant
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Objects.ParamSpecVariant.ParamSpecVariant


-- | A <a>CClosure</a> is a specialization of <a>Closure</a> for C function
--   callbacks.
module GI.GObject.Structs.CClosure

-- | Memory-managed wrapper type.
newtype CClosure
CClosure :: ManagedPtr CClosure -> CClosure

-- | Construct a <a>CClosure</a> struct initialized to zero.
newZeroCClosure :: MonadIO m => m CClosure

-- | A <a>ClosureMarshal</a> 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 <a>signalAccumulatorTrueHandled</a>.
cClosureMarshalBOOLEAN_BOXEDBOXED :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with handlers
--   that take a flags type as an argument and return a boolean. If you
--   have such a signal, you will probably also need to use an accumulator,
--   such as <a>signalAccumulatorTrueHandled</a>.
cClosureMarshalBOOLEAN_FLAGS :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A generic marshaller function implemented via <a>libffi</a>.
--   
--   Normally this function is not passed explicitly to
--   <tt><i>g_signal_new()</i></tt>, but used automatically by GLib when
--   specifying a <a>Nothing</a> marshaller.
--   
--   <i>Since: 2.30</i>
cClosureMarshalGeneric :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with handlers
--   that take a <a>Object</a> and a pointer and produce a string. It is
--   highly unlikely that your signal handler fits this description.
cClosureMarshalSTRING_OBJECTPOINTER :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with a single
--   boolean argument.
cClosureMarshalVOID_BOOLEAN :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with a single
--   argument which is any boxed pointer type.
cClosureMarshalVOID_BOXED :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with a single
--   character argument.
cClosureMarshalVOID_CHAR :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with one
--   double-precision floating point argument.
cClosureMarshalVOID_DOUBLE :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with a single
--   argument with an enumerated type.
cClosureMarshalVOID_ENUM :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with a single
--   argument with a flags types.
cClosureMarshalVOID_FLAGS :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with one
--   single-precision floating point argument.
cClosureMarshalVOID_FLOAT :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with a single
--   integer argument.
cClosureMarshalVOID_INT :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with with a
--   single long integer argument.
cClosureMarshalVOID_LONG :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with a single
--   <a>Object</a> argument.
cClosureMarshalVOID_OBJECT :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with a single
--   argument of type <a>ParamSpec</a>.
cClosureMarshalVOID_PARAM :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with a single
--   raw pointer argument type.
--   
--   If it is possible, it is better to use one of the more specific
--   functions such as <a>cclosureMarshalVOID_OBJECT</a> or
--   <a>cclosureMarshalVOID_OBJECT</a>.
cClosureMarshalVOID_POINTER :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with a single
--   string argument.
cClosureMarshalVOID_STRING :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with a single
--   unsigned character argument.
cClosureMarshalVOID_UCHAR :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with with a
--   single unsigned integer argument.
cClosureMarshalVOID_UINT :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with an unsigned
--   int and a pointer as arguments.
cClosureMarshalVOID_UINTPOINTER :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with a single
--   unsigned long integer argument.
cClosureMarshalVOID_ULONG :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with a single
--   <a>GVariant</a> argument.
cClosureMarshalVOID_VARIANT :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A <a>ClosureMarshal</a> function for use with signals with no
--   arguments.
cClosureMarshalVOID_VOID :: (HasCallStack, MonadIO m) => GClosure a -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | Set the value of the “<tt>callback</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #callback
--   </pre>
clearCClosureCallback :: MonadIO m => CClosure -> m ()

-- | Get the value of the “<tt>callback</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cClosure #callback
--   </pre>
getCClosureCallback :: MonadIO m => CClosure -> m (Ptr ())

-- | Set the value of the “<tt>callback</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cClosure [ #callback <a>:=</a> value ]
--   </pre>
setCClosureCallback :: MonadIO m => CClosure -> Ptr () -> m ()

-- | Set the value of the “<tt>closure</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #closure
--   </pre>
clearCClosureClosure :: MonadIO m => CClosure -> m ()

-- | Get the value of the “<tt>closure</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> cClosure #closure
--   </pre>
getCClosureClosure :: MonadIO m => CClosure -> m (Maybe (GClosure ()))

-- | Set the value of the “<tt>closure</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> cClosure [ #closure <a>:=</a> value ]
--   </pre>
setCClosureClosure :: MonadIO m => CClosure -> Ptr (GClosure ()) -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.CClosure.CClosure
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.CClosure.CClosure
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.CClosure.CClosure
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.CClosure.CClosure
instance (tag GHC.Types.~ '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 <a>EnumValue</a> struct initialized to zero.
newZeroEnumValue :: MonadIO m => m EnumValue

-- | Get the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> enumValue #value
--   </pre>
getEnumValueValue :: MonadIO m => EnumValue -> m Int32

-- | Set the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> enumValue [ #value <a>:=</a> value ]
--   </pre>
setEnumValueValue :: MonadIO m => EnumValue -> Int32 -> m ()

-- | Set the value of the “<tt>value_name</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #valueName
--   </pre>
clearEnumValueValueName :: MonadIO m => EnumValue -> m ()

-- | Get the value of the “<tt>value_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> enumValue #valueName
--   </pre>
getEnumValueValueName :: MonadIO m => EnumValue -> m (Maybe Text)

-- | Set the value of the “<tt>value_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> enumValue [ #valueName <a>:=</a> value ]
--   </pre>
setEnumValueValueName :: MonadIO m => EnumValue -> CString -> m ()

-- | Set the value of the “<tt>value_nick</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #valueNick
--   </pre>
clearEnumValueValueNick :: MonadIO m => EnumValue -> m ()

-- | Get the value of the “<tt>value_nick</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> enumValue #valueNick
--   </pre>
getEnumValueValueNick :: MonadIO m => EnumValue -> m (Maybe Text)

-- | Set the value of the “<tt>value_nick</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> enumValue [ #valueNick <a>:=</a> value ]
--   </pre>
setEnumValueValueNick :: MonadIO m => EnumValue -> CString -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.EnumValue.EnumValue
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.EnumValue.EnumValue
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.EnumValue.EnumValue
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.EnumValue.EnumValue
instance (tag GHC.Types.~ '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 <a>FlagsValue</a> struct initialized to zero.
newZeroFlagsValue :: MonadIO m => m FlagsValue

-- | Get the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flagsValue #value
--   </pre>
getFlagsValueValue :: MonadIO m => FlagsValue -> m Word32

-- | Set the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flagsValue [ #value <a>:=</a> value ]
--   </pre>
setFlagsValueValue :: MonadIO m => FlagsValue -> Word32 -> m ()

-- | Set the value of the “<tt>value_name</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #valueName
--   </pre>
clearFlagsValueValueName :: MonadIO m => FlagsValue -> m ()

-- | Get the value of the “<tt>value_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flagsValue #valueName
--   </pre>
getFlagsValueValueName :: MonadIO m => FlagsValue -> m (Maybe Text)

-- | Set the value of the “<tt>value_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flagsValue [ #valueName <a>:=</a> value ]
--   </pre>
setFlagsValueValueName :: MonadIO m => FlagsValue -> CString -> m ()

-- | Set the value of the “<tt>value_nick</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #valueNick
--   </pre>
clearFlagsValueValueNick :: MonadIO m => FlagsValue -> m ()

-- | Get the value of the “<tt>value_nick</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flagsValue #valueNick
--   </pre>
getFlagsValueValueNick :: MonadIO m => FlagsValue -> m (Maybe Text)

-- | Set the value of the “<tt>value_nick</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flagsValue [ #valueNick <a>:=</a> value ]
--   </pre>
setFlagsValueValueNick :: MonadIO m => FlagsValue -> CString -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.FlagsValue.FlagsValue
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.FlagsValue.FlagsValue
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.FlagsValue.FlagsValue
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.FlagsValue.FlagsValue
instance (tag GHC.Types.~ '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 <a>ParamSpec</a>/t<a>Value</a> pairs to the
--   <i><tt>constructor</tt></i> of a <a>ObjectClass</a>.
module GI.GObject.Structs.ObjectConstructParam

-- | Memory-managed wrapper type.
newtype ObjectConstructParam
ObjectConstructParam :: ManagedPtr ObjectConstructParam -> ObjectConstructParam

-- | Construct a <a>ObjectConstructParam</a> struct initialized to zero.
newZeroObjectConstructParam :: MonadIO m => m ObjectConstructParam

-- | Set the value of the “<tt>pspec</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #pspec
--   </pre>
clearObjectConstructParamPspec :: MonadIO m => ObjectConstructParam -> m ()

-- | Get the value of the “<tt>pspec</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> objectConstructParam #pspec
--   </pre>
getObjectConstructParamPspec :: MonadIO m => ObjectConstructParam -> m (Maybe GParamSpec)

-- | Set the value of the “<tt>pspec</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> objectConstructParam [ #pspec <a>:=</a> value ]
--   </pre>
setObjectConstructParamPspec :: MonadIO m => ObjectConstructParam -> Ptr GParamSpec -> m ()

-- | Set the value of the “<tt>value</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #value
--   </pre>
clearObjectConstructParamValue :: MonadIO m => ObjectConstructParam -> m ()

-- | Get the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> objectConstructParam #value
--   </pre>
getObjectConstructParamValue :: MonadIO m => ObjectConstructParam -> m (Maybe GValue)

-- | Set the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> objectConstructParam [ #value <a>:=</a> value ]
--   </pre>
setObjectConstructParamValue :: MonadIO m => ObjectConstructParam -> Ptr GValue -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.ObjectConstructParam.ObjectConstructParam
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.ObjectConstructParam.ObjectConstructParam
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.ObjectConstructParam.ObjectConstructParam
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.ObjectConstructParam.ObjectConstructParam
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.ObjectConstructParam.ObjectConstructParam tag


-- | A <a>ParamSpecPool</a> maintains a collection of
--   <tt><i>GParamSpecs</i></tt> which can be quickly accessed by owner and
--   name.
--   
--   The implementation of the <a>Object</a> property system uses such a
--   pool to store the <tt><i>GParamSpecs</i></tt> of the properties all
--   object types.
module GI.GObject.Structs.ParamSpecPool

-- | Memory-managed wrapper type.
newtype ParamSpecPool
ParamSpecPool :: ManagedPtr ParamSpecPool -> ParamSpecPool

-- | Inserts a <a>ParamSpec</a> in the pool.
paramSpecPoolInsert :: (HasCallStack, MonadIO m) => ParamSpecPool -> GParamSpec -> GType -> m ()

-- | Gets an <a>List</a> of all <tt><i>GParamSpecs</i></tt> owned by
--   <i><tt>ownerType</tt></i> in the pool.
paramSpecPoolListOwned :: (HasCallStack, MonadIO m) => ParamSpecPool -> GType -> m [GParamSpec]

-- | Looks up a <a>ParamSpec</a> in the pool.
paramSpecPoolLookup :: (HasCallStack, MonadIO m) => ParamSpecPool -> Text -> GType -> Bool -> m (Maybe GParamSpec)

-- | Removes a <a>ParamSpec</a> from the pool.
paramSpecPoolRemove :: (HasCallStack, MonadIO m) => ParamSpecPool -> GParamSpec -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.ParamSpecPool.ParamSpecPool
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.ParamSpecPool.ParamSpecPool
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.ParamSpecPool.ParamSpecPool


-- | The GParameter struct is an auxiliary structure used to hand parameter
--   name/value pairs to <a>objectNewv</a>.
module GI.GObject.Structs.Parameter

-- | Memory-managed wrapper type.
newtype Parameter
Parameter :: ManagedPtr Parameter -> Parameter

-- | Construct a <a>Parameter</a> struct initialized to zero.
newZeroParameter :: MonadIO m => m Parameter

-- | Set the value of the “<tt>name</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #name
--   </pre>
clearParameterName :: MonadIO m => Parameter -> m ()

-- | Get the value of the “<tt>name</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> parameter #name
--   </pre>
getParameterName :: MonadIO m => Parameter -> m (Maybe Text)

-- | Set the value of the “<tt>name</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> parameter [ #name <a>:=</a> value ]
--   </pre>
setParameterName :: MonadIO m => Parameter -> CString -> m ()

-- | Set the value of the “<tt>value</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #value
--   </pre>
clearParameterValue :: MonadIO m => Parameter -> m ()

-- | Get the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> parameter #value
--   </pre>
getParameterValue :: MonadIO m => Parameter -> m (Maybe GValue)

-- | Set the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> parameter [ #value <a>:=</a> value ]
--   </pre>
setParameterValue :: MonadIO m => Parameter -> Ptr GValue -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.Parameter.Parameter
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.Parameter.Parameter
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.Parameter.Parameter
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.Parameter.Parameter
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.Parameter.Parameter tag


-- | The <a>SignalInvocationHint</a> 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 <a>SignalInvocationHint</a> struct initialized to zero.
newZeroSignalInvocationHint :: MonadIO m => m SignalInvocationHint

-- | Get the value of the “<tt>detail</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> signalInvocationHint #detail
--   </pre>
getSignalInvocationHintDetail :: MonadIO m => SignalInvocationHint -> m Word32

-- | Set the value of the “<tt>detail</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> signalInvocationHint [ #detail <a>:=</a> value ]
--   </pre>
setSignalInvocationHintDetail :: MonadIO m => SignalInvocationHint -> Word32 -> m ()

-- | Get the value of the “<tt>run_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> signalInvocationHint #runType
--   </pre>
getSignalInvocationHintRunType :: MonadIO m => SignalInvocationHint -> m [SignalFlags]

-- | Set the value of the “<tt>run_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> signalInvocationHint [ #runType <a>:=</a> value ]
--   </pre>
setSignalInvocationHintRunType :: MonadIO m => SignalInvocationHint -> [SignalFlags] -> m ()

-- | Get the value of the “<tt>signal_id</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> signalInvocationHint #signalId
--   </pre>
getSignalInvocationHintSignalId :: MonadIO m => SignalInvocationHint -> m Word32

-- | Set the value of the “<tt>signal_id</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> signalInvocationHint [ #signalId <a>:=</a> value ]
--   </pre>
setSignalInvocationHintSignalId :: MonadIO m => SignalInvocationHint -> Word32 -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint
instance (tag GHC.Types.~ '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.
--   
--   See also: <a>signalQuery</a>
module GI.GObject.Structs.SignalQuery

-- | Memory-managed wrapper type.
newtype SignalQuery
SignalQuery :: ManagedPtr SignalQuery -> SignalQuery

-- | Construct a <a>SignalQuery</a> struct initialized to zero.
newZeroSignalQuery :: MonadIO m => m SignalQuery

-- | Get the value of the “<tt>itype</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> signalQuery #itype
--   </pre>
getSignalQueryItype :: MonadIO m => SignalQuery -> m GType

-- | Set the value of the “<tt>itype</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> signalQuery [ #itype <a>:=</a> value ]
--   </pre>
setSignalQueryItype :: MonadIO m => SignalQuery -> GType -> m ()

-- | Get the value of the “<tt>n_params</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> signalQuery #nParams
--   </pre>
getSignalQueryNParams :: MonadIO m => SignalQuery -> m Word32

-- | Set the value of the “<tt>n_params</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> signalQuery [ #nParams <a>:=</a> value ]
--   </pre>
setSignalQueryNParams :: MonadIO m => SignalQuery -> Word32 -> m ()

-- | Get the value of the “<tt>return_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> signalQuery #returnType
--   </pre>
getSignalQueryReturnType :: MonadIO m => SignalQuery -> m GType

-- | Set the value of the “<tt>return_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> signalQuery [ #returnType <a>:=</a> value ]
--   </pre>
setSignalQueryReturnType :: MonadIO m => SignalQuery -> GType -> m ()

-- | Get the value of the “<tt>signal_flags</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> signalQuery #signalFlags
--   </pre>
getSignalQuerySignalFlags :: MonadIO m => SignalQuery -> m [SignalFlags]

-- | Set the value of the “<tt>signal_flags</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> signalQuery [ #signalFlags <a>:=</a> value ]
--   </pre>
setSignalQuerySignalFlags :: MonadIO m => SignalQuery -> [SignalFlags] -> m ()

-- | Get the value of the “<tt>signal_id</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> signalQuery #signalId
--   </pre>
getSignalQuerySignalId :: MonadIO m => SignalQuery -> m Word32

-- | Set the value of the “<tt>signal_id</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> signalQuery [ #signalId <a>:=</a> value ]
--   </pre>
setSignalQuerySignalId :: MonadIO m => SignalQuery -> Word32 -> m ()

-- | Set the value of the “<tt>signal_name</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #signalName
--   </pre>
clearSignalQuerySignalName :: MonadIO m => SignalQuery -> m ()

-- | Get the value of the “<tt>signal_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> signalQuery #signalName
--   </pre>
getSignalQuerySignalName :: MonadIO m => SignalQuery -> m (Maybe Text)

-- | Set the value of the “<tt>signal_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> signalQuery [ #signalName <a>:=</a> value ]
--   </pre>
setSignalQuerySignalName :: MonadIO m => SignalQuery -> CString -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.SignalQuery.SignalQuery
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.SignalQuery.SignalQuery
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.SignalQuery.SignalQuery
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.SignalQuery.SignalQuery
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.SignalQuery.SignalQuery 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 <a>TypeClass</a> struct initialized to zero.
newZeroTypeClass :: MonadIO m => m 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
--   <tt><i>class_init()</i></tt> function. The private structure can be
--   retrieved using the <tt><i>G_TYPE_INSTANCE_GET_PRIVATE()</i></tt>
--   macro.
--   
--   The following example shows attaching a private structure
--   MyObjectPrivate to an object MyObject defined in the standard GObject
--   fashion in the type's <tt><i>class_init()</i></tt> function.
--   
--   Note the use of a structure member "priv" to avoid the overhead of
--   repeatedly calling <tt><i>MY_OBJECT_GET_PRIVATE()</i></tt>.
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   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-&gt;priv = G_TYPE_INSTANCE_GET_PRIVATE (my_object,
--                                                    MY_TYPE_OBJECT,
--                                                    MyObjectPrivate);
--     // my_object-&gt;priv-&gt;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-&gt;priv;
--   
--     return priv-&gt;some_field;
--   }
--   </pre>
--   
--   <i>Since: 2.4</i>

-- | <i>Deprecated: (Since version 2.58)Use the
--   <tt><i>G_ADD_PRIVATE()</i></tt> macro with the <tt>G_DEFINE_*</tt>
--   family of macros to add instance private data to a type</i>
typeClassAddPrivate :: (HasCallStack, MonadIO m) => TypeClass -> CSize -> m ()

-- | <i>No description available in the introspection data.</i>
typeClassAdjustPrivateOffset :: (HasCallStack, MonadIO m) => Ptr () -> Int32 -> m ()

-- | <i>No description available in the introspection data.</i>
typeClassGetPrivate :: (HasCallStack, MonadIO m) => TypeClass -> GType -> m (Ptr ())

-- | This function is essentially the same as <a>typeClassRef</a>, except
--   that the classes reference count isn't incremented. As a consequence,
--   this function may return <a>Nothing</a> 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 <a>typeClassPeek</a> which works only for
--   static types.
--   
--   <i>Since: 2.4</i>
typeClassPeekStatic :: (HasCallStack, MonadIO m) => GType -> m TypeClass

-- | Increments the reference count of the class structure belonging to
--   <i><tt>type</tt></i>. 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 <a>typeClassUnref</a> are invalid.
typeClassUnref :: (HasCallStack, MonadIO m) => TypeClass -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.TypeClass.TypeClass
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.TypeClass.TypeClass
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.TypeClass.TypeClass
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.TypeClass.TypeClass
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.TypeClass.TypeClass 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 <a>FlagsClass</a> struct initialized to zero.
newZeroFlagsClass :: MonadIO m => m FlagsClass

-- | Get the value of the “<tt>g_type_class</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flagsClass #gTypeClass
--   </pre>
getFlagsClassGTypeClass :: MonadIO m => FlagsClass -> m TypeClass

-- | Get the value of the “<tt>mask</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flagsClass #mask
--   </pre>
getFlagsClassMask :: MonadIO m => FlagsClass -> m Word32

-- | Set the value of the “<tt>mask</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flagsClass [ #mask <a>:=</a> value ]
--   </pre>
setFlagsClassMask :: MonadIO m => FlagsClass -> Word32 -> m ()

-- | Get the value of the “<tt>n_values</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flagsClass #nValues
--   </pre>
getFlagsClassNValues :: MonadIO m => FlagsClass -> m Word32

-- | Set the value of the “<tt>n_values</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flagsClass [ #nValues <a>:=</a> value ]
--   </pre>
setFlagsClassNValues :: MonadIO m => FlagsClass -> Word32 -> m ()

-- | Set the value of the “<tt>values</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #values
--   </pre>
clearFlagsClassValues :: MonadIO m => FlagsClass -> m ()

-- | Get the value of the “<tt>values</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> flagsClass #values
--   </pre>
getFlagsClassValues :: MonadIO m => FlagsClass -> m (Maybe FlagsValue)

-- | Set the value of the “<tt>values</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> flagsClass [ #values <a>:=</a> value ]
--   </pre>
setFlagsClassValues :: MonadIO m => FlagsClass -> Ptr FlagsValue -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.FlagsClass.FlagsClass
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.FlagsClass.FlagsClass
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.FlagsClass.FlagsClass
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.FlagsClass.FlagsClass
instance (tag GHC.Types.~ '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 <a>EnumClass</a> struct initialized to zero.
newZeroEnumClass :: MonadIO m => m EnumClass

-- | Get the value of the “<tt>g_type_class</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> enumClass #gTypeClass
--   </pre>
getEnumClassGTypeClass :: MonadIO m => EnumClass -> m TypeClass

-- | Get the value of the “<tt>maximum</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> enumClass #maximum
--   </pre>
getEnumClassMaximum :: MonadIO m => EnumClass -> m Int32

-- | Set the value of the “<tt>maximum</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> enumClass [ #maximum <a>:=</a> value ]
--   </pre>
setEnumClassMaximum :: MonadIO m => EnumClass -> Int32 -> m ()

-- | Get the value of the “<tt>minimum</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> enumClass #minimum
--   </pre>
getEnumClassMinimum :: MonadIO m => EnumClass -> m Int32

-- | Set the value of the “<tt>minimum</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> enumClass [ #minimum <a>:=</a> value ]
--   </pre>
setEnumClassMinimum :: MonadIO m => EnumClass -> Int32 -> m ()

-- | Get the value of the “<tt>n_values</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> enumClass #nValues
--   </pre>
getEnumClassNValues :: MonadIO m => EnumClass -> m Word32

-- | Set the value of the “<tt>n_values</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> enumClass [ #nValues <a>:=</a> value ]
--   </pre>
setEnumClassNValues :: MonadIO m => EnumClass -> Word32 -> m ()

-- | Set the value of the “<tt>values</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #values
--   </pre>
clearEnumClassValues :: MonadIO m => EnumClass -> m ()

-- | Get the value of the “<tt>values</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> enumClass #values
--   </pre>
getEnumClassValues :: MonadIO m => EnumClass -> m (Maybe EnumValue)

-- | Set the value of the “<tt>values</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> enumClass [ #values <a>:=</a> value ]
--   </pre>
setEnumClassValues :: MonadIO m => EnumClass -> Ptr EnumValue -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.EnumClass.EnumClass
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.EnumClass.EnumClass
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.EnumClass.EnumClass
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.EnumClass.EnumClass
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.EnumClass.EnumClass 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 <a>TypeFundamentalInfo</a> struct initialized to zero.
newZeroTypeFundamentalInfo :: MonadIO m => m TypeFundamentalInfo

-- | Get the value of the “<tt>type_flags</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeFundamentalInfo #typeFlags
--   </pre>
getTypeFundamentalInfoTypeFlags :: MonadIO m => TypeFundamentalInfo -> m [TypeFundamentalFlags]

-- | Set the value of the “<tt>type_flags</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeFundamentalInfo [ #typeFlags <a>:=</a> value ]
--   </pre>
setTypeFundamentalInfoTypeFlags :: MonadIO m => TypeFundamentalInfo -> [TypeFundamentalFlags] -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.TypeFundamentalInfo.TypeFundamentalInfo
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.TypeFundamentalInfo.TypeFundamentalInfo
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.TypeFundamentalInfo.TypeFundamentalInfo
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.TypeFundamentalInfo.TypeFundamentalInfo
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.TypeFundamentalInfo.TypeFundamentalInfo tag


-- | 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 <a>TypeInstance</a> struct initialized to zero.
newZeroTypeInstance :: MonadIO m => m TypeInstance

-- | <i>No description available in the introspection data.</i>
typeInstanceGetPrivate :: (HasCallStack, MonadIO m) => TypeInstance -> GType -> m (Ptr ())
instance GHC.Classes.Eq GI.GObject.Structs.TypeInstance.TypeInstance
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.TypeInstance.TypeInstance
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.TypeInstance.TypeInstance
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.TypeInstance.TypeInstance
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.TypeInstance.TypeInstance tag


-- | A structure holding information for a specific type.
--   
--   See also: <a>typeQuery</a>
module GI.GObject.Structs.TypeQuery

-- | Memory-managed wrapper type.
newtype TypeQuery
TypeQuery :: ManagedPtr TypeQuery -> TypeQuery

-- | Construct a <a>TypeQuery</a> struct initialized to zero.
newZeroTypeQuery :: MonadIO m => m TypeQuery

-- | Get the value of the “<tt>class_size</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeQuery #classSize
--   </pre>
getTypeQueryClassSize :: MonadIO m => TypeQuery -> m Word32

-- | Set the value of the “<tt>class_size</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeQuery [ #classSize <a>:=</a> value ]
--   </pre>
setTypeQueryClassSize :: MonadIO m => TypeQuery -> Word32 -> m ()

-- | Get the value of the “<tt>instance_size</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeQuery #instanceSize
--   </pre>
getTypeQueryInstanceSize :: MonadIO m => TypeQuery -> m Word32

-- | Set the value of the “<tt>instance_size</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeQuery [ #instanceSize <a>:=</a> value ]
--   </pre>
setTypeQueryInstanceSize :: MonadIO m => TypeQuery -> Word32 -> m ()

-- | Get the value of the “<tt>type</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeQuery #type
--   </pre>
getTypeQueryType :: MonadIO m => TypeQuery -> m GType

-- | Set the value of the “<tt>type</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeQuery [ #type <a>:=</a> value ]
--   </pre>
setTypeQueryType :: MonadIO m => TypeQuery -> GType -> m ()

-- | Set the value of the “<tt>type_name</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #typeName
--   </pre>
clearTypeQueryTypeName :: MonadIO m => TypeQuery -> m ()

-- | Get the value of the “<tt>type_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeQuery #typeName
--   </pre>
getTypeQueryTypeName :: MonadIO m => TypeQuery -> m (Maybe Text)

-- | Set the value of the “<tt>type_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeQuery [ #typeName <a>:=</a> value ]
--   </pre>
setTypeQueryTypeName :: MonadIO m => TypeQuery -> CString -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.TypeQuery.TypeQuery
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.TypeQuery.TypeQuery
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.TypeQuery.TypeQuery
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.TypeQuery.TypeQuery
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.TypeQuery.TypeQuery tag


-- | A <tt>GValueArray</tt> is a container structure to hold an array of
--   generic values.
--   
--   The prime purpose of a <tt>GValueArray</tt> is for it to be used as an
--   object property that holds an array of values. A <tt>GValueArray</tt>
--   wraps an array of <tt>GValue</tt> elements in order for it to be used
--   as a boxed type through <tt>G_TYPE_VALUE_ARRAY</tt>.
--   
--   <tt>GValueArray</tt> is deprecated in favour of <tt>GArray</tt> since
--   GLib 2.32. It is possible to create a <tt>GArray</tt> that behaves
--   like a <tt>GValueArray</tt> by using the size of <tt>GValue</tt> as
--   the element size, and by setting <a>valueUnset</a> as the clear
--   function using [func<i><tt>gLib</tt></i>.Array.set_clear_func], for
--   instance, the following code:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GValueArray *array = g_value_array_new (10);
--   </pre>
--   
--   can be replaced by:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GArray *array = g_array_sized_new (FALSE, TRUE, sizeof (GValue), 10);
--   g_array_set_clear_func (array, (GDestroyNotify) g_value_unset);
--   </pre>
module GI.GObject.Structs.ValueArray

-- | Memory-managed wrapper type.
newtype ValueArray
ValueArray :: ManagedPtr ValueArray -> ValueArray

-- | Construct a <a>ValueArray</a> struct initialized to zero.
newZeroValueArray :: MonadIO m => m ValueArray

-- | Insert a copy of <i><tt>value</tt></i> as last element of
--   <i><tt>valueArray</tt></i>. If <i><tt>value</tt></i> is
--   <a>Nothing</a>, an uninitialized value is appended.

-- | <i>Deprecated: (Since version 2.32)Use <a>Array</a> and
--   <tt><i>g_array_append_val()</i></tt> instead.</i>
valueArrayAppend :: (HasCallStack, MonadIO m) => ValueArray -> Maybe GValue -> m ValueArray

-- | Construct an exact copy of a <a>ValueArray</a> by duplicating all its
--   contents.

-- | <i>Deprecated: (Since version 2.32)Use <a>Array</a> and
--   <tt><i>g_array_ref()</i></tt> instead.</i>
valueArrayCopy :: (HasCallStack, MonadIO m) => ValueArray -> m ValueArray

-- | Return a pointer to the value at <i><tt>index_</tt></i> containd in
--   <i><tt>valueArray</tt></i>.

-- | <i>Deprecated: (Since version 2.32)Use <tt><i>g_array_index()</i></tt>
--   instead.</i>
valueArrayGetNth :: (HasCallStack, MonadIO m) => ValueArray -> Word32 -> m GValue

-- | Insert a copy of <i><tt>value</tt></i> at specified position into
--   <i><tt>valueArray</tt></i>. If <i><tt>value</tt></i> is
--   <a>Nothing</a>, an uninitialized value is inserted.

-- | <i>Deprecated: (Since version 2.32)Use <a>Array</a> and
--   <tt><i>g_array_insert_val()</i></tt> instead.</i>
valueArrayInsert :: (HasCallStack, MonadIO m) => ValueArray -> Word32 -> Maybe GValue -> m ValueArray

-- | Allocate and initialize a new <a>ValueArray</a>, optionally preserve
--   space for <i><tt>nPrealloced</tt></i> elements. New arrays always
--   contain 0 elements, regardless of the value of
--   <i><tt>nPrealloced</tt></i>.

-- | <i>Deprecated: (Since version 2.32)Use <a>Array</a> and
--   <tt><i>g_array_sized_new()</i></tt> instead.</i>
valueArrayNew :: (HasCallStack, MonadIO m) => Word32 -> m ValueArray

-- | Insert a copy of <i><tt>value</tt></i> as first element of
--   <i><tt>valueArray</tt></i>. If <i><tt>value</tt></i> is
--   <a>Nothing</a>, an uninitialized value is prepended.

-- | <i>Deprecated: (Since version 2.32)Use <a>Array</a> and
--   <tt><i>g_array_prepend_val()</i></tt> instead.</i>
valueArrayPrepend :: (HasCallStack, MonadIO m) => ValueArray -> Maybe GValue -> m ValueArray

-- | Remove the value at position <i><tt>index_</tt></i> from
--   <i><tt>valueArray</tt></i>.

-- | <i>Deprecated: (Since version 2.32)Use <a>Array</a> and
--   <tt><i>g_array_remove_index()</i></tt> instead.</i>
valueArrayRemove :: (HasCallStack, MonadIO m) => ValueArray -> Word32 -> m ValueArray

-- | Sort <i><tt>valueArray</tt></i> using <i><tt>compareFunc</tt></i> to
--   compare the elements according to the semantics of
--   <a>CompareDataFunc</a>.
--   
--   The current implementation uses the same sorting algorithm as standard
--   C <tt><i>qsort()</i></tt> function.

-- | <i>Deprecated: (Since version 2.32)Use <a>Array</a> and
--   <tt><i>g_array_sort_with_data()</i></tt>.</i>
valueArraySort :: (HasCallStack, MonadIO m) => ValueArray -> CompareDataFunc -> m ValueArray

-- | Get the value of the “<tt>n_values</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> valueArray #nValues
--   </pre>
getValueArrayNValues :: MonadIO m => ValueArray -> m Word32

-- | Set the value of the “<tt>n_values</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> valueArray [ #nValues <a>:=</a> value ]
--   </pre>
setValueArrayNValues :: MonadIO m => ValueArray -> Word32 -> m ()

-- | Set the value of the “<tt>values</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #values
--   </pre>
clearValueArrayValues :: MonadIO m => ValueArray -> m ()

-- | Get the value of the “<tt>values</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> valueArray #values
--   </pre>
getValueArrayValues :: MonadIO m => ValueArray -> m (Maybe GValue)

-- | Set the value of the “<tt>values</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> valueArray [ #values <a>:=</a> value ]
--   </pre>
setValueArrayValues :: MonadIO m => ValueArray -> Ptr GValue -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.ValueArray.ValueArray
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.ValueArray.ValueArray
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Structs.ValueArray.ValueArray
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Structs.ValueArray.ValueArray
instance Data.GI.Base.BasicTypes.GBoxed GI.GObject.Structs.ValueArray.ValueArray
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.GObject.Structs.ValueArray.ValueArray)
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.ValueArray.ValueArray tag


-- | A structure containing a weak reference to a <a>Object</a>.
--   
--   A <tt>GWeakRef</tt> can either be empty (i.e. point to
--   <a>Nothing</a>), or point to an object for as long as at least one
--   "strong" reference to that object exists. Before the object's
--   <a>ObjectClass</a>.<tt><i>dispose</i></tt> method is called, every
--   <a>WeakRef</a> associated with becomes empty (i.e. points to
--   <a>Nothing</a>).
--   
--   Like <a>Value</a>, <a>WeakRef</a> can be statically allocated, stack-
--   or heap-allocated, or embedded in larger structures.
--   
--   Unlike <tt><i>g_object_weak_ref()</i></tt> and
--   <tt><i>g_object_add_weak_pointer()</i></tt>, 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 <a>ObjectClass</a>.<tt><i>dispose</i></tt> method
--   results in additional references to the object being held
--   (‘re-referencing’), any <tt><i>GWeakRefs</i></tt> taken before it was
--   disposed will continue to point to <a>Nothing</a>. Any
--   <tt><i>GWeakRefs</i></tt> taken during disposal and after
--   re-referencing, or after disposal has returned due to the
--   re-referencing, will continue to point to the object until its
--   refcount goes back to zero, at which point they too will be
--   invalidated.
--   
--   It is invalid to take a <a>WeakRef</a> on an object during
--   <a>ObjectClass</a>.<tt><i>dispose</i></tt> without first having or
--   creating a strong reference to the object.
module GI.GObject.Structs.WeakRef

-- | Memory-managed wrapper type.
newtype WeakRef
WeakRef :: ManagedPtr WeakRef -> WeakRef
instance GHC.Classes.Eq GI.GObject.Structs.WeakRef.WeakRef
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.WeakRef.WeakRef
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.WeakRef.WeakRef


-- | A union holding one collected value.
module GI.GObject.Unions.TypeCValue

-- | Memory-managed wrapper type.
newtype TypeCValue
TypeCValue :: ManagedPtr TypeCValue -> TypeCValue

-- | Construct a <a>TypeCValue</a> struct initialized to zero.
newZeroTypeCValue :: MonadIO m => m TypeCValue

-- | Get the value of the “<tt>v_double</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeCValue #vDouble
--   </pre>
getTypeCValueVDouble :: MonadIO m => TypeCValue -> m Double

-- | Set the value of the “<tt>v_double</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeCValue [ #vDouble <a>:=</a> value ]
--   </pre>
setTypeCValueVDouble :: MonadIO m => TypeCValue -> Double -> m ()

-- | Get the value of the “<tt>v_int</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeCValue #vInt
--   </pre>
getTypeCValueVInt :: MonadIO m => TypeCValue -> m Int32

-- | Set the value of the “<tt>v_int</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeCValue [ #vInt <a>:=</a> value ]
--   </pre>
setTypeCValueVInt :: MonadIO m => TypeCValue -> Int32 -> m ()

-- | Get the value of the “<tt>v_int64</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeCValue #vInt64
--   </pre>
getTypeCValueVInt64 :: MonadIO m => TypeCValue -> m Int64

-- | Set the value of the “<tt>v_int64</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeCValue [ #vInt64 <a>:=</a> value ]
--   </pre>
setTypeCValueVInt64 :: MonadIO m => TypeCValue -> Int64 -> m ()

-- | Get the value of the “<tt>v_long</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeCValue #vLong
--   </pre>
getTypeCValueVLong :: MonadIO m => TypeCValue -> m CLong

-- | Set the value of the “<tt>v_long</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeCValue [ #vLong <a>:=</a> value ]
--   </pre>
setTypeCValueVLong :: MonadIO m => TypeCValue -> CLong -> m ()

-- | Set the value of the “<tt>v_pointer</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #vPointer
--   </pre>
clearTypeCValueVPointer :: MonadIO m => TypeCValue -> m ()

-- | Get the value of the “<tt>v_pointer</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeCValue #vPointer
--   </pre>
getTypeCValueVPointer :: MonadIO m => TypeCValue -> m (Ptr ())

-- | Set the value of the “<tt>v_pointer</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeCValue [ #vPointer <a>:=</a> value ]
--   </pre>
setTypeCValueVPointer :: MonadIO m => TypeCValue -> Ptr () -> m ()
instance GHC.Classes.Eq GI.GObject.Unions.TypeCValue.TypeCValue
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Unions.TypeCValue.TypeCValue
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Unions.TypeCValue.TypeCValue
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Unions.TypeCValue.TypeCValue
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Unions.TypeCValue.TypeCValue tag


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 <tt><i>GBaseInitFunc()</i></tt> function.
--   
--   Class finalization basically works the inverse way in which class
--   initialization is performed.
--   
--   See <tt><i>GClassInitFunc()</i></tt> for a discussion of the class
--   initialization process.
type BaseFinalizeFunc = -- | /@gClass@/: The t'GI.GObject.Structs.TypeClass.TypeClass' structure to finalize TypeClass -> 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 <a>GClosure</a>.
genClosure_BaseFinalizeFunc :: MonadIO m => BaseFinalizeFunc -> m (GClosure C_BaseFinalizeFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_BaseFinalizeFunc</a>.
mk_BaseFinalizeFunc :: C_BaseFinalizeFunc -> IO (FunPtr C_BaseFinalizeFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>BaseFinalizeFunc</a></tt>.
noBaseFinalizeFunc :: Maybe BaseFinalizeFunc

-- | Wrap a <a>BaseFinalizeFunc</a> into a <a>C_BaseFinalizeFunc</a>.
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.
--   
--   This function 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 <tt><i>GClassInitFunc()</i></tt> for a
--   discussion of the class initialization process.
type BaseInitFunc = -- | /@gClass@/: The t'GI.GObject.Structs.TypeClass.TypeClass' structure to initialize TypeClass -> 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 <a>GClosure</a>.
genClosure_BaseInitFunc :: MonadIO m => BaseInitFunc -> m (GClosure C_BaseInitFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_BaseInitFunc</a>.
mk_BaseInitFunc :: C_BaseInitFunc -> IO (FunPtr C_BaseInitFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>BaseInitFunc</a></tt>.
noBaseInitFunc :: Maybe BaseInitFunc

-- | Wrap a <a>BaseInitFunc</a> into a <a>C_BaseInitFunc</a>.
wrap_BaseInitFunc :: Maybe (Ptr (FunPtr C_BaseInitFunc)) -> BaseInitFunc -> C_BaseInitFunc

-- | A function to be called to transform <i><tt>fromValue</tt></i> to
--   <i><tt>toValue</tt></i>.
--   
--   If this is the <i><tt>transformTo</tt></i> function of a binding, then
--   <i><tt>fromValue</tt></i> is the <i><tt>sourceProperty</tt></i> on the
--   <i><tt>source</tt></i> object, and <i><tt>toValue</tt></i> is the
--   <i><tt>targetProperty</tt></i> on the <i><tt>target</tt></i> object.
--   If this is the <i><tt>transformFrom</tt></i> function of a
--   <a>BindingFlagsBidirectional</a> binding, then those roles are
--   reversed.
--   
--   <i>Since: 2.26</i>
type BindingTransformFunc = -- | /@binding@/: a t'GI.GObject.Objects.Binding.Binding' Binding -> -- | /@fromValue@/: the t'GI.GObject.Structs.Value.Value' containing the value to transform GValue -> -- | /@toValue@/: the t'GI.GObject.Structs.Value.Value' in which to store the transformed value GValue -> -- | __Returns:__ 'P.True' if the transformation was successful, and 'P.False' --   otherwise IO Bool

-- | A function to be called to transform <i><tt>fromValue</tt></i> to
--   <i><tt>toValue</tt></i>.
--   
--   If this is the <i><tt>transformTo</tt></i> function of a binding, then
--   <i><tt>fromValue</tt></i> is the <i><tt>sourceProperty</tt></i> on the
--   <i><tt>source</tt></i> object, and <i><tt>toValue</tt></i> is the
--   <i><tt>targetProperty</tt></i> on the <i><tt>target</tt></i> object.
--   If this is the <i><tt>transformFrom</tt></i> function of a
--   <a>BindingFlagsBidirectional</a> binding, then those roles are
--   reversed.
--   
--   <i>Since: 2.26</i>
type BindingTransformFunc_WithClosures = -- | /@binding@/: a t'GI.GObject.Objects.Binding.Binding' Binding -> -- | /@fromValue@/: the t'GI.GObject.Structs.Value.Value' containing the value to transform GValue -> -- | /@toValue@/: the t'GI.GObject.Structs.Value.Value' in which to store the transformed value GValue -> -- | /@userData@/: data passed to the transform function Ptr () -> -- | __Returns:__ 'P.True' if the transformation was successful, and 'P.False' --   otherwise IO Bool

-- | 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 <a>GClosure</a>.
genClosure_BindingTransformFunc :: MonadIO m => BindingTransformFunc -> m (GClosure C_BindingTransformFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_BindingTransformFunc</a>.
mk_BindingTransformFunc :: C_BindingTransformFunc -> IO (FunPtr C_BindingTransformFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>BindingTransformFunc</a></tt>.
noBindingTransformFunc :: Maybe BindingTransformFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>BindingTransformFunc_WithClosures</a></tt>.
noBindingTransformFunc_WithClosures :: Maybe BindingTransformFunc_WithClosures

-- | Wrap a <a>BindingTransformFunc</a> into a
--   <a>C_BindingTransformFunc</a>.
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 = -- | __Returns:__ The newly created copy of the boxed structure. IO (Ptr ())

-- | This function is provided by the user and should produce a copy of the
--   passed in boxed structure.
type BoxedCopyFunc_WithClosures = -- | /@boxed@/: The boxed structure to be copied. Ptr () -> -- | __Returns:__ The newly created copy of the boxed structure. IO (Ptr ())

-- | Type for the callback on the (unwrapped) C side.
type C_BoxedCopyFunc = Ptr () -> IO (Ptr ())

-- | A simple wrapper that ignores the closure arguments.
drop_closures_BoxedCopyFunc :: BoxedCopyFunc -> BoxedCopyFunc_WithClosures

-- | 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 <a>GClosure</a>.
genClosure_BoxedCopyFunc :: MonadIO m => BoxedCopyFunc -> m (GClosure C_BoxedCopyFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_BoxedCopyFunc</a>.
mk_BoxedCopyFunc :: C_BoxedCopyFunc -> IO (FunPtr C_BoxedCopyFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>BoxedCopyFunc</a></tt>.
noBoxedCopyFunc :: Maybe BoxedCopyFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>BoxedCopyFunc_WithClosures</a></tt>.
noBoxedCopyFunc_WithClosures :: Maybe BoxedCopyFunc_WithClosures

-- | Wrap a <a>BoxedCopyFunc</a> into a <a>C_BoxedCopyFunc</a>.
wrap_BoxedCopyFunc :: Maybe (Ptr (FunPtr C_BoxedCopyFunc)) -> BoxedCopyFunc_WithClosures -> C_BoxedCopyFunc

-- | This function is provided by the user and should free the boxed
--   structure passed.
type BoxedFreeFunc = IO ()

-- | This function is provided by the user and should free the boxed
--   structure passed.
type BoxedFreeFunc_WithClosures = -- | /@boxed@/: The boxed structure to be freed. Ptr () -> IO ()

-- | Type for the callback on the (unwrapped) C side.
type C_BoxedFreeFunc = Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_BoxedFreeFunc :: BoxedFreeFunc -> BoxedFreeFunc_WithClosures

-- | 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 <a>GClosure</a>.
genClosure_BoxedFreeFunc :: MonadIO m => BoxedFreeFunc -> m (GClosure C_BoxedFreeFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_BoxedFreeFunc</a>.
mk_BoxedFreeFunc :: C_BoxedFreeFunc -> IO (FunPtr C_BoxedFreeFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>BoxedFreeFunc</a></tt>.
noBoxedFreeFunc :: Maybe BoxedFreeFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>BoxedFreeFunc_WithClosures</a></tt>.
noBoxedFreeFunc_WithClosures :: Maybe BoxedFreeFunc_WithClosures

-- | Wrap a <a>BoxedFreeFunc</a> into a <a>C_BoxedFreeFunc</a>.
wrap_BoxedFreeFunc :: Maybe (Ptr (FunPtr C_BoxedFreeFunc)) -> BoxedFreeFunc_WithClosures -> 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 <tt><i>G_CALLBACK()</i></tt> to cast the callback function to a
--   <a>Callback</a>.
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 <a>GClosure</a>.
genClosure_Callback :: MonadIO m => Callback -> m (GClosure C_Callback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_Callback</a>.
mk_Callback :: C_Callback -> IO (FunPtr C_Callback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>Callback</a></tt>.
noCallback :: Maybe Callback

-- | Wrap a <a>Callback</a> into a <a>C_Callback</a>.
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 <tt><i>GBaseInitFunc()</i></tt> and
--   <tt><i>GBaseFinalizeFunc()</i></tt>.
--   
--   Also, specification of a <tt><i>GClassFinalizeFunc()</i></tt> in the
--   <a>TypeInfo</a> 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 = -- | /@gClass@/: The t'GI.GObject.Structs.TypeClass.TypeClass' structure to finalize TypeClass -> 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 <tt><i>GBaseInitFunc()</i></tt> and
--   <tt><i>GBaseFinalizeFunc()</i></tt>.
--   
--   Also, specification of a <tt><i>GClassFinalizeFunc()</i></tt> in the
--   <a>TypeInfo</a> 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_WithClosures = -- | /@gClass@/: The t'GI.GObject.Structs.TypeClass.TypeClass' structure to finalize TypeClass -> -- | /@classData@/: The /@classData@/ member supplied via the t'GI.GObject.Structs.TypeInfo.TypeInfo' structure Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ClassFinalizeFunc :: ClassFinalizeFunc -> ClassFinalizeFunc_WithClosures

-- | 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 <a>GClosure</a>.
genClosure_ClassFinalizeFunc :: MonadIO m => ClassFinalizeFunc -> m (GClosure C_ClassFinalizeFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ClassFinalizeFunc</a>.
mk_ClassFinalizeFunc :: C_ClassFinalizeFunc -> IO (FunPtr C_ClassFinalizeFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClassFinalizeFunc</a></tt>.
noClassFinalizeFunc :: Maybe ClassFinalizeFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClassFinalizeFunc_WithClosures</a></tt>.
noClassFinalizeFunc_WithClosures :: Maybe ClassFinalizeFunc_WithClosures

-- | Wrap a <a>ClassFinalizeFunc</a> into a <a>C_ClassFinalizeFunc</a>.
wrap_ClassFinalizeFunc :: Maybe (Ptr (FunPtr C_ClassFinalizeFunc)) -> ClassFinalizeFunc_WithClosures -> 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:
--   
--   <ul>
--   <li>Copying common members from the parent class over to the derived
--   class structure.</li>
--   <li>Zero initialization of the remaining members not copied over from
--   the parent class.</li>
--   <li>Invocation of the <tt><i>GBaseInitFunc()</i></tt> initializers of
--   all parent types and the class' type.</li>
--   <li>Invocation of the class' <tt><i>GClassInitFunc()</i></tt>
--   initializer.</li>
--   </ul>
--   
--   Since derived classes are partially initialized through a memory copy
--   of the parent class, the general rule is that
--   <tt><i>GBaseInitFunc()</i></tt> and
--   <tt><i>GBaseFinalizeFunc()</i></tt> should take care of necessary
--   reinitialization and release of those class members that were
--   introduced by the type that specified these
--   <tt><i>GBaseInitFunc()</i></tt>/<tt><i>GBaseFinalizeFunc()</i></tt>.
--   <tt><i>GClassInitFunc()</i></tt> 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
--   <tt><i>GBaseInitFunc()</i></tt> 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:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   typedef struct {
--     GObjectClass parent_class;
--     gint         static_integer;
--     gchar       *dynamic_string;
--   } TypeAClass;
--   static void
--   type_a_base_class_init (TypeAClass *class)
--   {
--     class-&gt;dynamic_string = g_strdup ("some string");
--   }
--   static void
--   type_a_base_class_finalize (TypeAClass *class)
--   {
--     g_free (class-&gt;dynamic_string);
--   }
--   static void
--   type_a_class_init (TypeAClass *class)
--   {
--     class-&gt;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-&gt;dynamic_gstring = g_string_new ("some other string");
--   }
--   static void
--   type_b_base_class_finalize (TypeBClass *class)
--   {
--     g_string_free (class-&gt;dynamic_gstring);
--   }
--   static void
--   type_b_class_init (TypeBClass *class)
--   {
--     class-&gt;static_float = 3.14159265358979323846;
--   }
--   </pre>
--   
--   Initialization of TypeBClass will first cause initialization of
--   TypeAClass (derived classes reference their parent classes, see
--   <a>typeClassRef</a> on this).
--   
--   Initialization of TypeAClass roughly involves zero-initializing its
--   fields, then calling its <tt><i>GBaseInitFunc()</i></tt>
--   <tt><i>type_a_base_class_init()</i></tt> to allocate its dynamic
--   members (dynamic_string), and finally calling its
--   <tt><i>GClassInitFunc()</i></tt> <tt><i>type_a_class_init()</i></tt>
--   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 <tt><i>type_a_base_class_init()</i></tt> with an
--   argument of TypeBClass.
--   
--   After that, the <tt><i>GBaseInitFunc()</i></tt> of TypeBClass,
--   <tt><i>type_b_base_class_init()</i></tt> is called to allocate the
--   dynamic members of TypeBClass (dynamic_gstring), and finally the
--   <tt><i>GClassInitFunc()</i></tt> of TypeBClass,
--   <tt><i>type_b_class_init()</i></tt>, is called to complete the
--   initialization process with the static members (static_float).
--   
--   Corresponding finalization counter parts to the
--   <tt><i>GBaseInitFunc()</i></tt> functions have to be provided to
--   release allocated resources at class finalization time.
type ClassInitFunc = -- | /@gClass@/: The t'GI.GObject.Structs.TypeClass.TypeClass' structure to initialize. TypeClass -> 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:
--   
--   <ul>
--   <li>Copying common members from the parent class over to the derived
--   class structure.</li>
--   <li>Zero initialization of the remaining members not copied over from
--   the parent class.</li>
--   <li>Invocation of the <tt><i>GBaseInitFunc()</i></tt> initializers of
--   all parent types and the class' type.</li>
--   <li>Invocation of the class' <tt><i>GClassInitFunc()</i></tt>
--   initializer.</li>
--   </ul>
--   
--   Since derived classes are partially initialized through a memory copy
--   of the parent class, the general rule is that
--   <tt><i>GBaseInitFunc()</i></tt> and
--   <tt><i>GBaseFinalizeFunc()</i></tt> should take care of necessary
--   reinitialization and release of those class members that were
--   introduced by the type that specified these
--   <tt><i>GBaseInitFunc()</i></tt>/<tt><i>GBaseFinalizeFunc()</i></tt>.
--   <tt><i>GClassInitFunc()</i></tt> 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
--   <tt><i>GBaseInitFunc()</i></tt> 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:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   typedef struct {
--     GObjectClass parent_class;
--     gint         static_integer;
--     gchar       *dynamic_string;
--   } TypeAClass;
--   static void
--   type_a_base_class_init (TypeAClass *class)
--   {
--     class-&gt;dynamic_string = g_strdup ("some string");
--   }
--   static void
--   type_a_base_class_finalize (TypeAClass *class)
--   {
--     g_free (class-&gt;dynamic_string);
--   }
--   static void
--   type_a_class_init (TypeAClass *class)
--   {
--     class-&gt;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-&gt;dynamic_gstring = g_string_new ("some other string");
--   }
--   static void
--   type_b_base_class_finalize (TypeBClass *class)
--   {
--     g_string_free (class-&gt;dynamic_gstring);
--   }
--   static void
--   type_b_class_init (TypeBClass *class)
--   {
--     class-&gt;static_float = 3.14159265358979323846;
--   }
--   </pre>
--   
--   Initialization of TypeBClass will first cause initialization of
--   TypeAClass (derived classes reference their parent classes, see
--   <a>typeClassRef</a> on this).
--   
--   Initialization of TypeAClass roughly involves zero-initializing its
--   fields, then calling its <tt><i>GBaseInitFunc()</i></tt>
--   <tt><i>type_a_base_class_init()</i></tt> to allocate its dynamic
--   members (dynamic_string), and finally calling its
--   <tt><i>GClassInitFunc()</i></tt> <tt><i>type_a_class_init()</i></tt>
--   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 <tt><i>type_a_base_class_init()</i></tt> with an
--   argument of TypeBClass.
--   
--   After that, the <tt><i>GBaseInitFunc()</i></tt> of TypeBClass,
--   <tt><i>type_b_base_class_init()</i></tt> is called to allocate the
--   dynamic members of TypeBClass (dynamic_gstring), and finally the
--   <tt><i>GClassInitFunc()</i></tt> of TypeBClass,
--   <tt><i>type_b_class_init()</i></tt>, is called to complete the
--   initialization process with the static members (static_float).
--   
--   Corresponding finalization counter parts to the
--   <tt><i>GBaseInitFunc()</i></tt> functions have to be provided to
--   release allocated resources at class finalization time.
type ClassInitFunc_WithClosures = -- | /@gClass@/: The t'GI.GObject.Structs.TypeClass.TypeClass' structure to initialize. TypeClass -> -- | /@classData@/: The /@classData@/ member supplied via the t'GI.GObject.Structs.TypeInfo.TypeInfo' structure. Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ClassInitFunc :: ClassInitFunc -> ClassInitFunc_WithClosures

-- | 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 <a>GClosure</a>.
genClosure_ClassInitFunc :: MonadIO m => ClassInitFunc -> m (GClosure C_ClassInitFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ClassInitFunc</a>.
mk_ClassInitFunc :: C_ClassInitFunc -> IO (FunPtr C_ClassInitFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClassInitFunc</a></tt>.
noClassInitFunc :: Maybe ClassInitFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClassInitFunc_WithClosures</a></tt>.
noClassInitFunc_WithClosures :: Maybe ClassInitFunc_WithClosures

-- | Wrap a <a>ClassInitFunc</a> into a <a>C_ClassInitFunc</a>.
wrap_ClassInitFunc :: Maybe (Ptr (FunPtr C_ClassInitFunc)) -> ClassInitFunc_WithClosures -> C_ClassInitFunc

-- | Type for the callback on the (unwrapped) C side.
type C_ClosureMarshal = Ptr (GClosure ()) -> Ptr GValue -> Word32 -> Ptr GValue -> Ptr () -> Ptr () -> IO ()

-- | The type used for marshaller functions.
type ClosureMarshal = -- | /@closure@/: the t'GI.GObject.Structs.Closure.Closure' to which the marshaller belongs GClosure () -> -- | /@returnValue@/: a t'GI.GObject.Structs.Value.Value' to store the return --  value. May be 'P.Nothing' if the callback of /@closure@/ doesn\'t return a --  value. Maybe GValue -> -- | /@paramValues@/: an array of --  @/GValues/@ holding the arguments on which to invoke the --  callback of /@closure@/ [GValue] -> -- | /@invocationHint@/: the invocation hint given as the --  last argument to 'GI.GObject.Structs.Closure.closureInvoke' Ptr () -> IO ()

-- | The type used for marshaller functions.
type ClosureMarshal_WithClosures = -- | /@closure@/: the t'GI.GObject.Structs.Closure.Closure' to which the marshaller belongs GClosure () -> -- | /@returnValue@/: a t'GI.GObject.Structs.Value.Value' to store the return --  value. May be 'P.Nothing' if the callback of /@closure@/ doesn\'t return a --  value. Maybe GValue -> -- | /@paramValues@/: an array of --  @/GValues/@ holding the arguments on which to invoke the --  callback of /@closure@/ [GValue] -> -- | /@invocationHint@/: the invocation hint given as the --  last argument to 'GI.GObject.Structs.Closure.closureInvoke' Ptr () -> -- | /@marshalData@/: additional data specified when --  registering the marshaller, see @/g_closure_set_marshal()/@ and --  @/g_closure_set_meta_marshal()/@ Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ClosureMarshal :: ClosureMarshal -> ClosureMarshal_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ClosureMarshal :: (HasCallStack, MonadIO m) => FunPtr C_ClosureMarshal -> GClosure a -> Maybe GValue -> [GValue] -> Ptr () -> Ptr () -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ClosureMarshal :: MonadIO m => ClosureMarshal -> m (GClosure C_ClosureMarshal)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ClosureMarshal</a>.
mk_ClosureMarshal :: C_ClosureMarshal -> IO (FunPtr C_ClosureMarshal)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClosureMarshal</a></tt>.
noClosureMarshal :: Maybe ClosureMarshal

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClosureMarshal_WithClosures</a></tt>.
noClosureMarshal_WithClosures :: Maybe ClosureMarshal_WithClosures

-- | Wrap a <a>ClosureMarshal</a> into a <a>C_ClosureMarshal</a>.
wrap_ClosureMarshal :: Maybe (Ptr (FunPtr C_ClosureMarshal)) -> ClosureMarshal_WithClosures -> C_ClosureMarshal

-- | Type for the callback on the (unwrapped) C side.
type C_ClosureMarshalFieldCallback = Ptr (GClosure ()) -> Ptr GValue -> Word32 -> Ptr GValue -> Ptr () -> Ptr () -> IO ()

-- | <i>No description available in the introspection data.</i>
type ClosureMarshalFieldCallback = GClosure () -> GValue -> Word32 -> GValue -> Ptr () -> IO ()

-- | <i>No description available in the introspection data.</i>
type ClosureMarshalFieldCallback_WithClosures = GClosure () -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ClosureMarshalFieldCallback :: ClosureMarshalFieldCallback -> ClosureMarshalFieldCallback_WithClosures

-- | 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 <a>GClosure</a>.
genClosure_ClosureMarshalFieldCallback :: MonadIO m => ClosureMarshalFieldCallback -> m (GClosure C_ClosureMarshalFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ClosureMarshalFieldCallback</a>.
mk_ClosureMarshalFieldCallback :: C_ClosureMarshalFieldCallback -> IO (FunPtr C_ClosureMarshalFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClosureMarshalFieldCallback</a></tt>.
noClosureMarshalFieldCallback :: Maybe ClosureMarshalFieldCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClosureMarshalFieldCallback_WithClosures</a></tt>.
noClosureMarshalFieldCallback_WithClosures :: Maybe ClosureMarshalFieldCallback_WithClosures

-- | Wrap a <a>ClosureMarshalFieldCallback</a> into a
--   <a>C_ClosureMarshalFieldCallback</a>.
wrap_ClosureMarshalFieldCallback :: Maybe (Ptr (FunPtr C_ClosureMarshalFieldCallback)) -> ClosureMarshalFieldCallback_WithClosures -> 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 = -- | /@data@/: data specified when registering the notification callback Ptr () -> -- | /@closure@/: the t'GI.GObject.Structs.Closure.Closure' on which the notification is emitted GClosure () -> 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 <a>GClosure</a>.
genClosure_ClosureNotify :: MonadIO m => ClosureNotify -> m (GClosure C_ClosureNotify)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ClosureNotify</a>.
mk_ClosureNotify :: C_ClosureNotify -> IO (FunPtr C_ClosureNotify)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ClosureNotify</a></tt>.
noClosureNotify :: Maybe ClosureNotify

-- | Wrap a <a>ClosureNotify</a> into a <a>C_ClosureNotify</a>.
wrap_ClosureNotify :: Maybe (Ptr (FunPtr C_ClosureNotify)) -> ClosureNotify -> C_ClosureNotify

-- | Type for the callback on the (unwrapped) C side.
type C_InitiallyUnownedClassConstructedFieldCallback = Ptr Object -> IO ()

-- | <i>No description available in the introspection data.</i>
type InitiallyUnownedClassConstructedFieldCallback = Object -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_InitiallyUnownedClassConstructedFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassConstructedFieldCallback -> a -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_InitiallyUnownedClassConstructedFieldCallback :: MonadIO m => InitiallyUnownedClassConstructedFieldCallback -> m (GClosure C_InitiallyUnownedClassConstructedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_InitiallyUnownedClassConstructedFieldCallback</a>.
mk_InitiallyUnownedClassConstructedFieldCallback :: C_InitiallyUnownedClassConstructedFieldCallback -> IO (FunPtr C_InitiallyUnownedClassConstructedFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>InitiallyUnownedClassConstructedFieldCallback</a></tt>.
noInitiallyUnownedClassConstructedFieldCallback :: Maybe InitiallyUnownedClassConstructedFieldCallback

-- | Wrap a <a>InitiallyUnownedClassConstructedFieldCallback</a> into a
--   <a>C_InitiallyUnownedClassConstructedFieldCallback</a>.
wrap_InitiallyUnownedClassConstructedFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassConstructedFieldCallback)) -> InitiallyUnownedClassConstructedFieldCallback -> C_InitiallyUnownedClassConstructedFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback = Ptr Object -> Word32 -> Ptr GParamSpec -> IO ()

-- | <i>No description available in the introspection data.</i>
type InitiallyUnownedClassDispatchPropertiesChangedFieldCallback = Object -> Word32 -> GParamSpec -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback -> a -> Word32 -> GParamSpec -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback :: MonadIO m => InitiallyUnownedClassDispatchPropertiesChangedFieldCallback -> m (GClosure C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback</a>.
mk_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback :: C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback -> IO (FunPtr C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>InitiallyUnownedClassDispatchPropertiesChangedFieldCallback</a></tt>.
noInitiallyUnownedClassDispatchPropertiesChangedFieldCallback :: Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback

-- | Wrap a
--   <a>InitiallyUnownedClassDispatchPropertiesChangedFieldCallback</a>
--   into a
--   <a>C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback</a>.
wrap_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)) -> InitiallyUnownedClassDispatchPropertiesChangedFieldCallback -> C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_InitiallyUnownedClassDisposeFieldCallback = Ptr Object -> IO ()

-- | <i>No description available in the introspection data.</i>
type InitiallyUnownedClassDisposeFieldCallback = Object -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_InitiallyUnownedClassDisposeFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> a -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_InitiallyUnownedClassDisposeFieldCallback :: MonadIO m => InitiallyUnownedClassDisposeFieldCallback -> m (GClosure C_InitiallyUnownedClassDisposeFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_InitiallyUnownedClassDisposeFieldCallback</a>.
mk_InitiallyUnownedClassDisposeFieldCallback :: C_InitiallyUnownedClassDisposeFieldCallback -> IO (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>InitiallyUnownedClassDisposeFieldCallback</a></tt>.
noInitiallyUnownedClassDisposeFieldCallback :: Maybe InitiallyUnownedClassDisposeFieldCallback

-- | Wrap a <a>InitiallyUnownedClassDisposeFieldCallback</a> into a
--   <a>C_InitiallyUnownedClassDisposeFieldCallback</a>.
wrap_InitiallyUnownedClassDisposeFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassDisposeFieldCallback)) -> InitiallyUnownedClassDisposeFieldCallback -> C_InitiallyUnownedClassDisposeFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_InitiallyUnownedClassFinalizeFieldCallback = Ptr Object -> IO ()

-- | <i>No description available in the introspection data.</i>
type InitiallyUnownedClassFinalizeFieldCallback = Object -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_InitiallyUnownedClassFinalizeFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassFinalizeFieldCallback -> a -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_InitiallyUnownedClassFinalizeFieldCallback :: MonadIO m => InitiallyUnownedClassFinalizeFieldCallback -> m (GClosure C_InitiallyUnownedClassFinalizeFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_InitiallyUnownedClassFinalizeFieldCallback</a>.
mk_InitiallyUnownedClassFinalizeFieldCallback :: C_InitiallyUnownedClassFinalizeFieldCallback -> IO (FunPtr C_InitiallyUnownedClassFinalizeFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>InitiallyUnownedClassFinalizeFieldCallback</a></tt>.
noInitiallyUnownedClassFinalizeFieldCallback :: Maybe InitiallyUnownedClassFinalizeFieldCallback

-- | Wrap a <a>InitiallyUnownedClassFinalizeFieldCallback</a> into a
--   <a>C_InitiallyUnownedClassFinalizeFieldCallback</a>.
wrap_InitiallyUnownedClassFinalizeFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassFinalizeFieldCallback)) -> InitiallyUnownedClassFinalizeFieldCallback -> C_InitiallyUnownedClassFinalizeFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_InitiallyUnownedClassGetPropertyFieldCallback = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()

-- | <i>No description available in the introspection data.</i>
type InitiallyUnownedClassGetPropertyFieldCallback = Object -> Word32 -> GValue -> GParamSpec -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_InitiallyUnownedClassGetPropertyFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassGetPropertyFieldCallback -> a -> Word32 -> GValue -> GParamSpec -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_InitiallyUnownedClassGetPropertyFieldCallback :: MonadIO m => InitiallyUnownedClassGetPropertyFieldCallback -> m (GClosure C_InitiallyUnownedClassGetPropertyFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_InitiallyUnownedClassGetPropertyFieldCallback</a>.
mk_InitiallyUnownedClassGetPropertyFieldCallback :: C_InitiallyUnownedClassGetPropertyFieldCallback -> IO (FunPtr C_InitiallyUnownedClassGetPropertyFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>InitiallyUnownedClassGetPropertyFieldCallback</a></tt>.
noInitiallyUnownedClassGetPropertyFieldCallback :: Maybe InitiallyUnownedClassGetPropertyFieldCallback

-- | Wrap a <a>InitiallyUnownedClassGetPropertyFieldCallback</a> into a
--   <a>C_InitiallyUnownedClassGetPropertyFieldCallback</a>.
wrap_InitiallyUnownedClassGetPropertyFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassGetPropertyFieldCallback)) -> InitiallyUnownedClassGetPropertyFieldCallback -> C_InitiallyUnownedClassGetPropertyFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_InitiallyUnownedClassNotifyFieldCallback = Ptr Object -> Ptr GParamSpec -> IO ()

-- | <i>No description available in the introspection data.</i>
type InitiallyUnownedClassNotifyFieldCallback = -- | /@object@/: a t'GI.GObject.Objects.Object.Object' Object -> GParamSpec -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_InitiallyUnownedClassNotifyFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassNotifyFieldCallback -> a -> GParamSpec -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_InitiallyUnownedClassNotifyFieldCallback :: MonadIO m => InitiallyUnownedClassNotifyFieldCallback -> m (GClosure C_InitiallyUnownedClassNotifyFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_InitiallyUnownedClassNotifyFieldCallback</a>.
mk_InitiallyUnownedClassNotifyFieldCallback :: C_InitiallyUnownedClassNotifyFieldCallback -> IO (FunPtr C_InitiallyUnownedClassNotifyFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>InitiallyUnownedClassNotifyFieldCallback</a></tt>.
noInitiallyUnownedClassNotifyFieldCallback :: Maybe InitiallyUnownedClassNotifyFieldCallback

-- | Wrap a <a>InitiallyUnownedClassNotifyFieldCallback</a> into a
--   <a>C_InitiallyUnownedClassNotifyFieldCallback</a>.
wrap_InitiallyUnownedClassNotifyFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassNotifyFieldCallback)) -> InitiallyUnownedClassNotifyFieldCallback -> C_InitiallyUnownedClassNotifyFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_InitiallyUnownedClassSetPropertyFieldCallback = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()

-- | <i>No description available in the introspection data.</i>
type InitiallyUnownedClassSetPropertyFieldCallback = Object -> Word32 -> GValue -> GParamSpec -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_InitiallyUnownedClassSetPropertyFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback -> a -> Word32 -> GValue -> GParamSpec -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_InitiallyUnownedClassSetPropertyFieldCallback :: MonadIO m => InitiallyUnownedClassSetPropertyFieldCallback -> m (GClosure C_InitiallyUnownedClassSetPropertyFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_InitiallyUnownedClassSetPropertyFieldCallback</a>.
mk_InitiallyUnownedClassSetPropertyFieldCallback :: C_InitiallyUnownedClassSetPropertyFieldCallback -> IO (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>InitiallyUnownedClassSetPropertyFieldCallback</a></tt>.
noInitiallyUnownedClassSetPropertyFieldCallback :: Maybe InitiallyUnownedClassSetPropertyFieldCallback

-- | Wrap a <a>InitiallyUnownedClassSetPropertyFieldCallback</a> into a
--   <a>C_InitiallyUnownedClassSetPropertyFieldCallback</a>.
wrap_InitiallyUnownedClassSetPropertyFieldCallback :: Maybe (Ptr (FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback)) -> InitiallyUnownedClassSetPropertyFieldCallback -> C_InitiallyUnownedClassSetPropertyFieldCallback

-- | 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 <i><tt>instance</tt></i> are guaranteed to
--   have been filled with zeros before this function is called.
type InstanceInitFunc = -- | /@instance@/: The instance to initialize TypeInstance -> -- | /@gClass@/: The class of the type the instance is --    created for TypeClass -> 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 <a>GClosure</a>.
genClosure_InstanceInitFunc :: MonadIO m => InstanceInitFunc -> m (GClosure C_InstanceInitFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_InstanceInitFunc</a>.
mk_InstanceInitFunc :: C_InstanceInitFunc -> IO (FunPtr C_InstanceInitFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>InstanceInitFunc</a></tt>.
noInstanceInitFunc :: Maybe InstanceInitFunc

-- | Wrap a <a>InstanceInitFunc</a> into a <a>C_InstanceInitFunc</a>.
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
--   <tt><i>GInterfaceInitFunc()</i></tt> function.
type InterfaceFinalizeFunc = -- | /@gIface@/: The interface structure to finalize TypeInterface -> 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
--   <tt><i>GInterfaceInitFunc()</i></tt> function.
type InterfaceFinalizeFunc_WithClosures = -- | /@gIface@/: The interface structure to finalize TypeInterface -> -- | /@ifaceData@/: The /@interfaceData@/ supplied via the t'GI.GObject.Structs.InterfaceInfo.InterfaceInfo' structure Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_InterfaceFinalizeFunc :: InterfaceFinalizeFunc -> InterfaceFinalizeFunc_WithClosures

-- | 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 <a>GClosure</a>.
genClosure_InterfaceFinalizeFunc :: MonadIO m => InterfaceFinalizeFunc -> m (GClosure C_InterfaceFinalizeFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_InterfaceFinalizeFunc</a>.
mk_InterfaceFinalizeFunc :: C_InterfaceFinalizeFunc -> IO (FunPtr C_InterfaceFinalizeFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>InterfaceFinalizeFunc</a></tt>.
noInterfaceFinalizeFunc :: Maybe InterfaceFinalizeFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>InterfaceFinalizeFunc_WithClosures</a></tt>.
noInterfaceFinalizeFunc_WithClosures :: Maybe InterfaceFinalizeFunc_WithClosures

-- | Wrap a <a>InterfaceFinalizeFunc</a> into a
--   <a>C_InterfaceFinalizeFunc</a>.
wrap_InterfaceFinalizeFunc :: Maybe (Ptr (FunPtr C_InterfaceFinalizeFunc)) -> InterfaceFinalizeFunc_WithClosures -> 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 <i><tt>ifaceData</tt></i> are guaranteed to have been
--   filled with zeros before this function is called.
type InterfaceInitFunc = -- | /@gIface@/: The interface structure to initialize TypeInterface -> 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 <i><tt>ifaceData</tt></i> are guaranteed to have been
--   filled with zeros before this function is called.
type InterfaceInitFunc_WithClosures = -- | /@gIface@/: The interface structure to initialize TypeInterface -> -- | /@ifaceData@/: The /@interfaceData@/ supplied via the t'GI.GObject.Structs.InterfaceInfo.InterfaceInfo' structure Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_InterfaceInitFunc :: InterfaceInitFunc -> InterfaceInitFunc_WithClosures

-- | 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 <a>GClosure</a>.
genClosure_InterfaceInitFunc :: MonadIO m => InterfaceInitFunc -> m (GClosure C_InterfaceInitFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_InterfaceInitFunc</a>.
mk_InterfaceInitFunc :: C_InterfaceInitFunc -> IO (FunPtr C_InterfaceInitFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>InterfaceInitFunc</a></tt>.
noInterfaceInitFunc :: Maybe InterfaceInitFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>InterfaceInitFunc_WithClosures</a></tt>.
noInterfaceInitFunc_WithClosures :: Maybe InterfaceInitFunc_WithClosures

-- | Wrap a <a>InterfaceInitFunc</a> into a <a>C_InterfaceInitFunc</a>.
wrap_InterfaceInitFunc :: Maybe (Ptr (FunPtr C_InterfaceInitFunc)) -> InterfaceInitFunc_WithClosures -> C_InterfaceInitFunc

-- | Type for the callback on the (unwrapped) C side.
type C_ObjectClassConstructedFieldCallback = Ptr Object -> IO ()

-- | <i>No description available in the introspection data.</i>
type ObjectClassConstructedFieldCallback = Object -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ObjectClassConstructedFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassConstructedFieldCallback -> a -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ObjectClassConstructedFieldCallback :: MonadIO m => ObjectClassConstructedFieldCallback -> m (GClosure C_ObjectClassConstructedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ObjectClassConstructedFieldCallback</a>.
mk_ObjectClassConstructedFieldCallback :: C_ObjectClassConstructedFieldCallback -> IO (FunPtr C_ObjectClassConstructedFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ObjectClassConstructedFieldCallback</a></tt>.
noObjectClassConstructedFieldCallback :: Maybe ObjectClassConstructedFieldCallback

-- | Wrap a <a>ObjectClassConstructedFieldCallback</a> into a
--   <a>C_ObjectClassConstructedFieldCallback</a>.
wrap_ObjectClassConstructedFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassConstructedFieldCallback)) -> ObjectClassConstructedFieldCallback -> C_ObjectClassConstructedFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_ObjectClassDispatchPropertiesChangedFieldCallback = Ptr Object -> Word32 -> Ptr GParamSpec -> IO ()

-- | <i>No description available in the introspection data.</i>
type ObjectClassDispatchPropertiesChangedFieldCallback = Object -> Word32 -> GParamSpec -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ObjectClassDispatchPropertiesChangedFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback -> a -> Word32 -> GParamSpec -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ObjectClassDispatchPropertiesChangedFieldCallback :: MonadIO m => ObjectClassDispatchPropertiesChangedFieldCallback -> m (GClosure C_ObjectClassDispatchPropertiesChangedFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ObjectClassDispatchPropertiesChangedFieldCallback</a>.
mk_ObjectClassDispatchPropertiesChangedFieldCallback :: C_ObjectClassDispatchPropertiesChangedFieldCallback -> IO (FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ObjectClassDispatchPropertiesChangedFieldCallback</a></tt>.
noObjectClassDispatchPropertiesChangedFieldCallback :: Maybe ObjectClassDispatchPropertiesChangedFieldCallback

-- | Wrap a <a>ObjectClassDispatchPropertiesChangedFieldCallback</a> into a
--   <a>C_ObjectClassDispatchPropertiesChangedFieldCallback</a>.
wrap_ObjectClassDispatchPropertiesChangedFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback)) -> ObjectClassDispatchPropertiesChangedFieldCallback -> C_ObjectClassDispatchPropertiesChangedFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_ObjectClassDisposeFieldCallback = Ptr Object -> IO ()

-- | <i>No description available in the introspection data.</i>
type ObjectClassDisposeFieldCallback = Object -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ObjectClassDisposeFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassDisposeFieldCallback -> a -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ObjectClassDisposeFieldCallback :: MonadIO m => ObjectClassDisposeFieldCallback -> m (GClosure C_ObjectClassDisposeFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ObjectClassDisposeFieldCallback</a>.
mk_ObjectClassDisposeFieldCallback :: C_ObjectClassDisposeFieldCallback -> IO (FunPtr C_ObjectClassDisposeFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ObjectClassDisposeFieldCallback</a></tt>.
noObjectClassDisposeFieldCallback :: Maybe ObjectClassDisposeFieldCallback

-- | Wrap a <a>ObjectClassDisposeFieldCallback</a> into a
--   <a>C_ObjectClassDisposeFieldCallback</a>.
wrap_ObjectClassDisposeFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassDisposeFieldCallback)) -> ObjectClassDisposeFieldCallback -> C_ObjectClassDisposeFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_ObjectClassFinalizeFieldCallback = Ptr Object -> IO ()

-- | <i>No description available in the introspection data.</i>
type ObjectClassFinalizeFieldCallback = Object -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ObjectClassFinalizeFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassFinalizeFieldCallback -> a -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ObjectClassFinalizeFieldCallback :: MonadIO m => ObjectClassFinalizeFieldCallback -> m (GClosure C_ObjectClassFinalizeFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ObjectClassFinalizeFieldCallback</a>.
mk_ObjectClassFinalizeFieldCallback :: C_ObjectClassFinalizeFieldCallback -> IO (FunPtr C_ObjectClassFinalizeFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ObjectClassFinalizeFieldCallback</a></tt>.
noObjectClassFinalizeFieldCallback :: Maybe ObjectClassFinalizeFieldCallback

-- | Wrap a <a>ObjectClassFinalizeFieldCallback</a> into a
--   <a>C_ObjectClassFinalizeFieldCallback</a>.
wrap_ObjectClassFinalizeFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassFinalizeFieldCallback)) -> ObjectClassFinalizeFieldCallback -> C_ObjectClassFinalizeFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_ObjectClassGetPropertyFieldCallback = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()

-- | <i>No description available in the introspection data.</i>
type ObjectClassGetPropertyFieldCallback = Object -> Word32 -> GValue -> GParamSpec -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ObjectClassGetPropertyFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassGetPropertyFieldCallback -> a -> Word32 -> GValue -> GParamSpec -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ObjectClassGetPropertyFieldCallback :: MonadIO m => ObjectClassGetPropertyFieldCallback -> m (GClosure C_ObjectClassGetPropertyFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ObjectClassGetPropertyFieldCallback</a>.
mk_ObjectClassGetPropertyFieldCallback :: C_ObjectClassGetPropertyFieldCallback -> IO (FunPtr C_ObjectClassGetPropertyFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ObjectClassGetPropertyFieldCallback</a></tt>.
noObjectClassGetPropertyFieldCallback :: Maybe ObjectClassGetPropertyFieldCallback

-- | Wrap a <a>ObjectClassGetPropertyFieldCallback</a> into a
--   <a>C_ObjectClassGetPropertyFieldCallback</a>.
wrap_ObjectClassGetPropertyFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassGetPropertyFieldCallback)) -> ObjectClassGetPropertyFieldCallback -> C_ObjectClassGetPropertyFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_ObjectClassNotifyFieldCallback = Ptr Object -> Ptr GParamSpec -> IO ()

-- | <i>No description available in the introspection data.</i>
type ObjectClassNotifyFieldCallback = -- | /@object@/: a t'GI.GObject.Objects.Object.Object' Object -> GParamSpec -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ObjectClassNotifyFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassNotifyFieldCallback -> a -> GParamSpec -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ObjectClassNotifyFieldCallback :: MonadIO m => ObjectClassNotifyFieldCallback -> m (GClosure C_ObjectClassNotifyFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ObjectClassNotifyFieldCallback</a>.
mk_ObjectClassNotifyFieldCallback :: C_ObjectClassNotifyFieldCallback -> IO (FunPtr C_ObjectClassNotifyFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ObjectClassNotifyFieldCallback</a></tt>.
noObjectClassNotifyFieldCallback :: Maybe ObjectClassNotifyFieldCallback

-- | Wrap a <a>ObjectClassNotifyFieldCallback</a> into a
--   <a>C_ObjectClassNotifyFieldCallback</a>.
wrap_ObjectClassNotifyFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassNotifyFieldCallback)) -> ObjectClassNotifyFieldCallback -> C_ObjectClassNotifyFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_ObjectClassSetPropertyFieldCallback = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()

-- | <i>No description available in the introspection data.</i>
type ObjectClassSetPropertyFieldCallback = Object -> Word32 -> GValue -> GParamSpec -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ObjectClassSetPropertyFieldCallback :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectClassSetPropertyFieldCallback -> a -> Word32 -> GValue -> GParamSpec -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ObjectClassSetPropertyFieldCallback :: MonadIO m => ObjectClassSetPropertyFieldCallback -> m (GClosure C_ObjectClassSetPropertyFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ObjectClassSetPropertyFieldCallback</a>.
mk_ObjectClassSetPropertyFieldCallback :: C_ObjectClassSetPropertyFieldCallback -> IO (FunPtr C_ObjectClassSetPropertyFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ObjectClassSetPropertyFieldCallback</a></tt>.
noObjectClassSetPropertyFieldCallback :: Maybe ObjectClassSetPropertyFieldCallback

-- | Wrap a <a>ObjectClassSetPropertyFieldCallback</a> into a
--   <a>C_ObjectClassSetPropertyFieldCallback</a>.
wrap_ObjectClassSetPropertyFieldCallback :: Maybe (Ptr (FunPtr C_ObjectClassSetPropertyFieldCallback)) -> ObjectClassSetPropertyFieldCallback -> C_ObjectClassSetPropertyFieldCallback

-- | Type for the callback on the (unwrapped) C side.
type C_ObjectFinalizeFunc = Ptr Object -> IO ()

-- | The type of the <i><tt>finalize</tt></i> function of
--   <a>ObjectClass</a>.
type ObjectFinalizeFunc = -- | /@object@/: the t'GI.GObject.Objects.Object.Object' being finalized Object -> 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 <a>GClosure</a>.
genClosure_ObjectFinalizeFunc :: MonadIO m => ObjectFinalizeFunc -> m (GClosure C_ObjectFinalizeFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ObjectFinalizeFunc</a>.
mk_ObjectFinalizeFunc :: C_ObjectFinalizeFunc -> IO (FunPtr C_ObjectFinalizeFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ObjectFinalizeFunc</a></tt>.
noObjectFinalizeFunc :: Maybe ObjectFinalizeFunc

-- | Wrap a <a>ObjectFinalizeFunc</a> into a <a>C_ObjectFinalizeFunc</a>.
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 <i><tt>getProperty</tt></i> function of
--   <a>ObjectClass</a>.
type ObjectGetPropertyFunc = -- | /@object@/: a t'GI.GObject.Objects.Object.Object' Object -> -- | /@propertyId@/: the numeric id under which the property was registered with --  'GI.GObject.Structs.ObjectClass.objectClassInstallProperty'. Word32 -> -- | /@value@/: a t'GI.GObject.Structs.Value.Value' to return the property value in GValue -> -- | /@pspec@/: the t'GI.GObject.Objects.ParamSpec.ParamSpec' describing the property GParamSpec -> 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 <a>GClosure</a>.
genClosure_ObjectGetPropertyFunc :: MonadIO m => ObjectGetPropertyFunc -> m (GClosure C_ObjectGetPropertyFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ObjectGetPropertyFunc</a>.
mk_ObjectGetPropertyFunc :: C_ObjectGetPropertyFunc -> IO (FunPtr C_ObjectGetPropertyFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ObjectGetPropertyFunc</a></tt>.
noObjectGetPropertyFunc :: Maybe ObjectGetPropertyFunc

-- | Wrap a <a>ObjectGetPropertyFunc</a> into a
--   <a>C_ObjectGetPropertyFunc</a>.
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 <i><tt>setProperty</tt></i> function of
--   <a>ObjectClass</a>.
type ObjectSetPropertyFunc = -- | /@object@/: a t'GI.GObject.Objects.Object.Object' Object -> -- | /@propertyId@/: the numeric id under which the property was registered with --  'GI.GObject.Structs.ObjectClass.objectClassInstallProperty'. Word32 -> -- | /@value@/: the new value for the property GValue -> -- | /@pspec@/: the t'GI.GObject.Objects.ParamSpec.ParamSpec' describing the property GParamSpec -> 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 <a>GClosure</a>.
genClosure_ObjectSetPropertyFunc :: MonadIO m => ObjectSetPropertyFunc -> m (GClosure C_ObjectSetPropertyFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ObjectSetPropertyFunc</a>.
mk_ObjectSetPropertyFunc :: C_ObjectSetPropertyFunc -> IO (FunPtr C_ObjectSetPropertyFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ObjectSetPropertyFunc</a></tt>.
noObjectSetPropertyFunc :: Maybe ObjectSetPropertyFunc

-- | Wrap a <a>ObjectSetPropertyFunc</a> into a
--   <a>C_ObjectSetPropertyFunc</a>.
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 ()

-- | <i>No description available in the introspection data.</i>
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 <a>GClosure</a>.
genClosure_ParamSpecTypeInfoFinalizeFieldCallback :: MonadIO m => ParamSpecTypeInfoFinalizeFieldCallback -> m (GClosure C_ParamSpecTypeInfoFinalizeFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ParamSpecTypeInfoFinalizeFieldCallback</a>.
mk_ParamSpecTypeInfoFinalizeFieldCallback :: C_ParamSpecTypeInfoFinalizeFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ParamSpecTypeInfoFinalizeFieldCallback</a></tt>.
noParamSpecTypeInfoFinalizeFieldCallback :: Maybe ParamSpecTypeInfoFinalizeFieldCallback

-- | Wrap a <a>ParamSpecTypeInfoFinalizeFieldCallback</a> into a
--   <a>C_ParamSpecTypeInfoFinalizeFieldCallback</a>.
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 ()

-- | <i>No description available in the introspection data.</i>
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 <a>GClosure</a>.
genClosure_ParamSpecTypeInfoInstanceInitFieldCallback :: MonadIO m => ParamSpecTypeInfoInstanceInitFieldCallback -> m (GClosure C_ParamSpecTypeInfoInstanceInitFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ParamSpecTypeInfoInstanceInitFieldCallback</a>.
mk_ParamSpecTypeInfoInstanceInitFieldCallback :: C_ParamSpecTypeInfoInstanceInitFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ParamSpecTypeInfoInstanceInitFieldCallback</a></tt>.
noParamSpecTypeInfoInstanceInitFieldCallback :: Maybe ParamSpecTypeInfoInstanceInitFieldCallback

-- | Wrap a <a>ParamSpecTypeInfoInstanceInitFieldCallback</a> into a
--   <a>C_ParamSpecTypeInfoInstanceInitFieldCallback</a>.
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 ()

-- | <i>No description available in the introspection data.</i>
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 <a>GClosure</a>.
genClosure_ParamSpecTypeInfoValueSetDefaultFieldCallback :: MonadIO m => ParamSpecTypeInfoValueSetDefaultFieldCallback -> m (GClosure C_ParamSpecTypeInfoValueSetDefaultFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ParamSpecTypeInfoValueSetDefaultFieldCallback</a>.
mk_ParamSpecTypeInfoValueSetDefaultFieldCallback :: C_ParamSpecTypeInfoValueSetDefaultFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ParamSpecTypeInfoValueSetDefaultFieldCallback</a></tt>.
noParamSpecTypeInfoValueSetDefaultFieldCallback :: Maybe ParamSpecTypeInfoValueSetDefaultFieldCallback

-- | Wrap a <a>ParamSpecTypeInfoValueSetDefaultFieldCallback</a> into a
--   <a>C_ParamSpecTypeInfoValueSetDefaultFieldCallback</a>.
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

-- | <i>No description available in the introspection data.</i>
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 <a>GClosure</a>.
genClosure_ParamSpecTypeInfoValueValidateFieldCallback :: MonadIO m => ParamSpecTypeInfoValueValidateFieldCallback -> m (GClosure C_ParamSpecTypeInfoValueValidateFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ParamSpecTypeInfoValueValidateFieldCallback</a>.
mk_ParamSpecTypeInfoValueValidateFieldCallback :: C_ParamSpecTypeInfoValueValidateFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ParamSpecTypeInfoValueValidateFieldCallback</a></tt>.
noParamSpecTypeInfoValueValidateFieldCallback :: Maybe ParamSpecTypeInfoValueValidateFieldCallback

-- | Wrap a <a>ParamSpecTypeInfoValueValidateFieldCallback</a> into a
--   <a>C_ParamSpecTypeInfoValueValidateFieldCallback</a>.
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

-- | <i>No description available in the introspection data.</i>
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 <a>GClosure</a>.
genClosure_ParamSpecTypeInfoValuesCmpFieldCallback :: MonadIO m => ParamSpecTypeInfoValuesCmpFieldCallback -> m (GClosure C_ParamSpecTypeInfoValuesCmpFieldCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ParamSpecTypeInfoValuesCmpFieldCallback</a>.
mk_ParamSpecTypeInfoValuesCmpFieldCallback :: C_ParamSpecTypeInfoValuesCmpFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ParamSpecTypeInfoValuesCmpFieldCallback</a></tt>.
noParamSpecTypeInfoValuesCmpFieldCallback :: Maybe ParamSpecTypeInfoValuesCmpFieldCallback

-- | Wrap a <a>ParamSpecTypeInfoValuesCmpFieldCallback</a> into a
--   <a>C_ParamSpecTypeInfoValuesCmpFieldCallback</a>.
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 <a>Nothing</a>, 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 = -- | /@ihint@/: Signal invocation hint, see t'GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint'. SignalInvocationHint -> -- | /@returnAccu@/: Accumulator to collect callback return values in, this --  is the return value of the current signal emission. GValue -> -- | /@handlerReturn@/: A t'GI.GObject.Structs.Value.Value' holding the return value of the signal handler. GValue -> -- | __Returns:__ The accumulator function returns whether the signal emission --  should be aborted. Returning 'P.True' will continue with --  the signal emission. Returning 'P.False' will abort the current emission. --  Since 2.62, returning 'P.False' will skip to the CLEANUP stage. In this case, --  emission will occur as normal in the CLEANUP stage and the handler\'s --  return value will be accumulated. IO Bool

-- | 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 <a>Nothing</a>, 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_WithClosures = -- | /@ihint@/: Signal invocation hint, see t'GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint'. SignalInvocationHint -> -- | /@returnAccu@/: Accumulator to collect callback return values in, this --  is the return value of the current signal emission. GValue -> -- | /@handlerReturn@/: A t'GI.GObject.Structs.Value.Value' holding the return value of the signal handler. GValue -> -- | /@data@/: Callback data that was specified when creating the signal. Ptr () -> -- | __Returns:__ The accumulator function returns whether the signal emission --  should be aborted. Returning 'P.True' will continue with --  the signal emission. Returning 'P.False' will abort the current emission. --  Since 2.62, returning 'P.False' will skip to the CLEANUP stage. In this case, --  emission will occur as normal in the CLEANUP stage and the handler\'s --  return value will be accumulated. IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_SignalAccumulator :: SignalAccumulator -> SignalAccumulator_WithClosures

-- | 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 <a>GClosure</a>.
genClosure_SignalAccumulator :: MonadIO m => SignalAccumulator -> m (GClosure C_SignalAccumulator)

-- | Generate a function pointer callable from C code, from a
--   <a>C_SignalAccumulator</a>.
mk_SignalAccumulator :: C_SignalAccumulator -> IO (FunPtr C_SignalAccumulator)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>SignalAccumulator</a></tt>.
noSignalAccumulator :: Maybe SignalAccumulator

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>SignalAccumulator_WithClosures</a></tt>.
noSignalAccumulator_WithClosures :: Maybe SignalAccumulator_WithClosures

-- | Wrap a <a>SignalAccumulator</a> into a <a>C_SignalAccumulator</a>.
wrap_SignalAccumulator :: Maybe (Ptr (FunPtr C_SignalAccumulator)) -> SignalAccumulator_WithClosures -> 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.
--   
--   Emission hooks allow 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
--   <a>SignalFlagsNoHooks</a> flag.
type SignalEmissionHook = -- | /@ihint@/: Signal invocation hint, see t'GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint'. SignalInvocationHint -> -- | /@paramValues@/: the instance on which --  the signal was emitted, followed by the parameters of the emission. [GValue] -> -- | __Returns:__ whether it wants to stay connected. If it returns 'P.False', the signal --  hook is disconnected (and destroyed). IO Bool

-- | A simple function pointer to get invoked when the signal is emitted.
--   
--   Emission hooks allow 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
--   <a>SignalFlagsNoHooks</a> flag.
type SignalEmissionHook_WithClosures = -- | /@ihint@/: Signal invocation hint, see t'GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint'. SignalInvocationHint -> -- | /@paramValues@/: the instance on which --  the signal was emitted, followed by the parameters of the emission. [GValue] -> -- | /@data@/: user data associated with the hook. Ptr () -> -- | __Returns:__ whether it wants to stay connected. If it returns 'P.False', the signal --  hook is disconnected (and destroyed). IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_SignalEmissionHook :: SignalEmissionHook -> SignalEmissionHook_WithClosures

-- | 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 <a>GClosure</a>.
genClosure_SignalEmissionHook :: MonadIO m => SignalEmissionHook -> m (GClosure C_SignalEmissionHook)

-- | Generate a function pointer callable from C code, from a
--   <a>C_SignalEmissionHook</a>.
mk_SignalEmissionHook :: C_SignalEmissionHook -> IO (FunPtr C_SignalEmissionHook)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>SignalEmissionHook</a></tt>.
noSignalEmissionHook :: Maybe SignalEmissionHook

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>SignalEmissionHook_WithClosures</a></tt>.
noSignalEmissionHook_WithClosures :: Maybe SignalEmissionHook_WithClosures

-- | Wrap a <a>SignalEmissionHook</a> into a <a>C_SignalEmissionHook</a>.
wrap_SignalEmissionHook :: Maybe (Ptr (FunPtr C_SignalEmissionHook)) -> SignalEmissionHook_WithClosures -> 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 also: <tt><i>g_object_add_toggle_ref()</i></tt>
type ToggleNotify = -- | /@data@/: Callback data passed to @/g_object_add_toggle_ref()/@ Ptr () -> -- | /@object@/: The object on which @/g_object_add_toggle_ref()/@ was called. Object -> -- | /@isLastRef@/: 'P.True' if the toggle reference is now the --  last reference to the object. 'P.False' if the toggle --  reference was the last reference and there are now other --  references. Bool -> 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 <a>GClosure</a>.
genClosure_ToggleNotify :: MonadIO m => ToggleNotify -> m (GClosure C_ToggleNotify)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ToggleNotify</a>.
mk_ToggleNotify :: C_ToggleNotify -> IO (FunPtr C_ToggleNotify)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ToggleNotify</a></tt>.
noToggleNotify :: Maybe ToggleNotify

-- | Wrap a <a>ToggleNotify</a> into a <a>C_ToggleNotify</a>.
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 <a>typeClassRef</a> to prevent the class from being freed.
--   You should not call <a>typeClassUnref</a> from a
--   <a>TypeClassCacheFunc</a> function to prevent infinite recursion, use
--   <tt><i>g_type_class_unref_uncached()</i></tt> 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 <a>TypeClassCacheFunc</a> chain.
type TypeClassCacheFunc = -- | /@cacheData@/: data that was given to the @/g_type_add_class_cache_func()/@ call Ptr () -> -- | /@gClass@/: The t'GI.GObject.Structs.TypeClass.TypeClass' structure which is --    unreferenced TypeClass -> -- | __Returns:__ 'P.True' to stop further @/GTypeClassCacheFuncs/@ from being --  called, 'P.False' to continue IO Bool

-- | 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 <a>GClosure</a>.
genClosure_TypeClassCacheFunc :: MonadIO m => TypeClassCacheFunc -> m (GClosure C_TypeClassCacheFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TypeClassCacheFunc</a>.
mk_TypeClassCacheFunc :: C_TypeClassCacheFunc -> IO (FunPtr C_TypeClassCacheFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TypeClassCacheFunc</a></tt>.
noTypeClassCacheFunc :: Maybe TypeClassCacheFunc

-- | Wrap a <a>TypeClassCacheFunc</a> into a <a>C_TypeClassCacheFunc</a>.
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 <tt><i>g_type_add_interface_check()</i></tt>.
--   
--   <i>Since: 2.4</i>
type TypeInterfaceCheckFunc = -- | /@checkData@/: data passed to @/g_type_add_interface_check()/@ Ptr () -> -- | /@gIface@/: the interface that has been --    initialized TypeInterface -> 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 <a>GClosure</a>.
genClosure_TypeInterfaceCheckFunc :: MonadIO m => TypeInterfaceCheckFunc -> m (GClosure C_TypeInterfaceCheckFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TypeInterfaceCheckFunc</a>.
mk_TypeInterfaceCheckFunc :: C_TypeInterfaceCheckFunc -> IO (FunPtr C_TypeInterfaceCheckFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TypeInterfaceCheckFunc</a></tt>.
noTypeInterfaceCheckFunc :: Maybe TypeInterfaceCheckFunc

-- | Wrap a <a>TypeInterfaceCheckFunc</a> into a
--   <a>C_TypeInterfaceCheckFunc</a>.
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 <i><tt>completeInterfaceInfo</tt></i> function of
--   <tt><i>GTypePluginClass</i></tt>.
type TypePluginCompleteInterfaceInfo = -- | /@plugin@/: the t'GI.GObject.Interfaces.TypePlugin.TypePlugin' TypePlugin -> -- | /@instanceType@/: the t'GType' of an instantiatable type to which the interface --  is added GType -> -- | /@interfaceType@/: the t'GType' of the interface whose info is completed GType -> -- | /@info@/: the t'GI.GObject.Structs.InterfaceInfo.InterfaceInfo' to fill in InterfaceInfo -> 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 <a>GClosure</a>.
genClosure_TypePluginCompleteInterfaceInfo :: MonadIO m => TypePluginCompleteInterfaceInfo -> m (GClosure C_TypePluginCompleteInterfaceInfo)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TypePluginCompleteInterfaceInfo</a>.
mk_TypePluginCompleteInterfaceInfo :: C_TypePluginCompleteInterfaceInfo -> IO (FunPtr C_TypePluginCompleteInterfaceInfo)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TypePluginCompleteInterfaceInfo</a></tt>.
noTypePluginCompleteInterfaceInfo :: Maybe TypePluginCompleteInterfaceInfo

-- | Wrap a <a>TypePluginCompleteInterfaceInfo</a> into a
--   <a>C_TypePluginCompleteInterfaceInfo</a>.
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 <i><tt>completeTypeInfo</tt></i> function of
--   <tt><i>GTypePluginClass</i></tt>.
type TypePluginCompleteTypeInfo = -- | /@plugin@/: the t'GI.GObject.Interfaces.TypePlugin.TypePlugin' TypePlugin -> -- | /@gType@/: the t'GType' whose info is completed GType -> -- | /@info@/: the t'GI.GObject.Structs.TypeInfo.TypeInfo' struct to fill in TypeInfo -> -- | /@valueTable@/: the t'GI.GObject.Structs.TypeValueTable.TypeValueTable' to fill in TypeValueTable -> 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 <a>GClosure</a>.
genClosure_TypePluginCompleteTypeInfo :: MonadIO m => TypePluginCompleteTypeInfo -> m (GClosure C_TypePluginCompleteTypeInfo)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TypePluginCompleteTypeInfo</a>.
mk_TypePluginCompleteTypeInfo :: C_TypePluginCompleteTypeInfo -> IO (FunPtr C_TypePluginCompleteTypeInfo)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TypePluginCompleteTypeInfo</a></tt>.
noTypePluginCompleteTypeInfo :: Maybe TypePluginCompleteTypeInfo

-- | Wrap a <a>TypePluginCompleteTypeInfo</a> into a
--   <a>C_TypePluginCompleteTypeInfo</a>.
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 <i><tt>unusePlugin</tt></i> function of
--   <tt><i>GTypePluginClass</i></tt>.
type TypePluginUnuse = -- | /@plugin@/: the t'GI.GObject.Interfaces.TypePlugin.TypePlugin' whose use count should be decreased TypePlugin -> 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 <a>GClosure</a>.
genClosure_TypePluginUnuse :: MonadIO m => TypePluginUnuse -> m (GClosure C_TypePluginUnuse)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TypePluginUnuse</a>.
mk_TypePluginUnuse :: C_TypePluginUnuse -> IO (FunPtr C_TypePluginUnuse)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TypePluginUnuse</a></tt>.
noTypePluginUnuse :: Maybe TypePluginUnuse

-- | Wrap a <a>TypePluginUnuse</a> into a <a>C_TypePluginUnuse</a>.
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 <i><tt>usePlugin</tt></i> function of
--   <tt><i>GTypePluginClass</i></tt>, which gets called to increase the
--   use count of <i><tt>plugin</tt></i>.
type TypePluginUse = -- | /@plugin@/: the t'GI.GObject.Interfaces.TypePlugin.TypePlugin' whose use count should be increased TypePlugin -> 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 <a>GClosure</a>.
genClosure_TypePluginUse :: MonadIO m => TypePluginUse -> m (GClosure C_TypePluginUse)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TypePluginUse</a>.
mk_TypePluginUse :: C_TypePluginUse -> IO (FunPtr C_TypePluginUse)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TypePluginUse</a></tt>.
noTypePluginUse :: Maybe TypePluginUse

-- | Wrap a <a>TypePluginUse</a> into a <a>C_TypePluginUse</a>.
wrap_TypePluginUse :: Maybe (Ptr (FunPtr C_TypePluginUse)) -> TypePluginUse -> C_TypePluginUse

-- | Type for the callback on the (unwrapped) C side.
type C_TypeValueCollectFunc = Ptr GValue -> Word32 -> Ptr TypeCValue -> Word32 -> IO CString

-- | This function is responsible for converting the values collected from
--   a variadic argument list into contents suitable for storage in a
--   <a>Value</a>.
--   
--   This function should setup <i><tt>value</tt></i> similar to
--   <a>TypeValueInitFunc</a>; e.g. for a string value that does not allow
--   <tt>NULL</tt> pointers, it needs to either emit an error, or do an
--   implicit conversion by storing an empty string.
--   
--   The <i><tt>value</tt></i> passed in to this function has a zero-filled
--   data array, so just like for <a>TypeValueInitFunc</a> it is guaranteed
--   to not contain any old contents that might need freeing.
--   
--   The <i><tt>nCollectValues</tt></i> argument is the string length of
--   the <tt>collect_format</tt> field of <a>TypeValueTable</a>, and
--   <tt>collect_values</tt> is an array of <a>TypeCValue</a> with length
--   of <i><tt>nCollectValues</tt></i>, containing the collected values
--   according to <tt>collect_format</tt>.
--   
--   The <i><tt>collectFlags</tt></i> argument provided as a hint by the
--   caller. It may contain the flag <a>VALUE_NOCOPY_CONTENTS</a>
--   indicating that the collected value contents may be considered
--   ‘static’ for the duration of the <i><tt>value</tt></i> lifetime. Thus
--   an extra copy of the contents stored in <i><tt>collectValues</tt></i>
--   is not required for assignment to <i><tt>value</tt></i>.
--   
--   For our above string example, we continue with:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   if (!collect_values[0].v_pointer)
--     value-&gt;data[0].v_pointer = g_strdup ("");
--   else if (collect_flags &amp; G_VALUE_NOCOPY_CONTENTS)
--     {
--       value-&gt;data[0].v_pointer = collect_values[0].v_pointer;
--       // keep a flag for the value_free() implementation to not free this string
--       value-&gt;data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
--     }
--   else
--     value-&gt;data[0].v_pointer = g_strdup (collect_values[0].v_pointer);
--   return NULL;
--   </pre>
--   
--   It should be noted, that it is generally a bad idea to follow the
--   <a>VALUE_NOCOPY_CONTENTS</a> hint for reference counted types. Due to
--   reentrancy requirements and reference count assertions performed by
--   the signal emission code, reference counts should always be
--   incremented for reference counted contents stored in the
--   <tt>value-&gt;data</tt> array. To deviate from our string example for
--   a moment, and taking a look at an exemplary implementation for
--   <tt>GTypeValueTable.collect_value()</tt> of <tt>GObject</tt>:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   GObject *object = G_OBJECT (collect_values[0].v_pointer);
--   g_return_val_if_fail (object != NULL,
--      g_strdup_printf ("Object %p passed as invalid NULL pointer", object));
--   // never honour G_VALUE_NOCOPY_CONTENTS for ref-counted types
--   value-&gt;data[0].v_pointer = g_object_ref (object);
--   return NULL;
--   </pre>
--   
--   The reference count for valid objects is always incremented,
--   regardless of <tt>collect_flags</tt>. For invalid objects, the example
--   returns a newly allocated string without altering <tt>value</tt>.
--   
--   Upon success, <tt>collect_value()</tt> needs to return <tt>NULL</tt>.
--   If, however, an error condition occurred, <tt>collect_value()</tt>
--   should return a newly allocated string containing an error diagnostic.
--   
--   The calling code makes no assumptions about the <tt>value</tt>
--   contents being valid upon error returns, <tt>value</tt> is simply
--   thrown away without further freeing. As such, it is a good idea to not
--   allocate <tt>GValue</tt> contents prior to returning an error;
--   however, <tt>collect_values()</tt> is not obliged to return a
--   correctly setup <i><tt>value</tt></i> for error returns, simply
--   because any non-<tt>NULL</tt> return is considered a fatal programming
--   error, and further program behaviour is undefined.
--   
--   <i>Since: 2.78</i>
type TypeValueCollectFunc = -- | /@value@/: the value to initialize GValue -> -- | /@collectValues@/: the collected values [TypeCValue] -> -- | /@collectFlags@/: optional flags Word32 -> -- | __Returns:__ @NULL@ on success, otherwise a --   newly allocated error string on failure IO (Maybe Text)

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TypeValueCollectFunc :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueCollectFunc -> GValue -> [TypeCValue] -> Word32 -> m (Maybe Text)

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TypeValueCollectFunc :: MonadIO m => TypeValueCollectFunc -> m (GClosure C_TypeValueCollectFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TypeValueCollectFunc</a>.
mk_TypeValueCollectFunc :: C_TypeValueCollectFunc -> IO (FunPtr C_TypeValueCollectFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TypeValueCollectFunc</a></tt>.
noTypeValueCollectFunc :: Maybe TypeValueCollectFunc

-- | Wrap a <a>TypeValueCollectFunc</a> into a
--   <a>C_TypeValueCollectFunc</a>.
wrap_TypeValueCollectFunc :: Maybe (Ptr (FunPtr C_TypeValueCollectFunc)) -> TypeValueCollectFunc -> C_TypeValueCollectFunc

-- | Type for the callback on the (unwrapped) C side.
type C_TypeValueCopyFunc = Ptr GValue -> Ptr GValue -> IO ()

-- | Copies the content of a <a>Value</a> into another.
--   
--   The <i><tt>destValue</tt></i> is a <a>Value</a> with zero-filled data
--   section and <i><tt>srcValue</tt></i> is a properly initialized
--   <a>Value</a> of same type, or derived type.
--   
--   The purpose of this function is to copy the contents of
--   <i><tt>srcValue</tt></i> into <i><tt>destValue</tt></i> in a way, that
--   even after <i><tt>srcValue</tt></i> has been freed, the contents of
--   <i><tt>destValue</tt></i> remain valid. String type example:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   dest_value-&gt;data[0].v_pointer = g_strdup (src_value-&gt;data[0].v_pointer);
--   </pre>
--   
--   <i>Since: 2.78</i>
type TypeValueCopyFunc = -- | /@srcValue@/: the value to copy GValue -> IO (GValue)

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TypeValueCopyFunc :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueCopyFunc -> GValue -> m GValue

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TypeValueCopyFunc :: MonadIO m => TypeValueCopyFunc -> m (GClosure C_TypeValueCopyFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TypeValueCopyFunc</a>.
mk_TypeValueCopyFunc :: C_TypeValueCopyFunc -> IO (FunPtr C_TypeValueCopyFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TypeValueCopyFunc</a></tt>.
noTypeValueCopyFunc :: Maybe TypeValueCopyFunc

-- | Wrap a <a>TypeValueCopyFunc</a> into a <a>C_TypeValueCopyFunc</a>.
wrap_TypeValueCopyFunc :: Maybe (Ptr (FunPtr C_TypeValueCopyFunc)) -> TypeValueCopyFunc -> C_TypeValueCopyFunc

-- | Type for the callback on the (unwrapped) C side.
type C_TypeValueFreeFunc = Ptr GValue -> IO ()

-- | Frees any old contents that might be left in the
--   <tt>value-&gt;data</tt> array of the given value.
--   
--   No resources may remain allocated through the <a>Value</a> contents
--   after this function returns. E.g. for our above string type:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   // only free strings without a specific flag for static storage
--   if (!(value-&gt;data[1].v_uint &amp; G_VALUE_NOCOPY_CONTENTS))
--     g_free (value-&gt;data[0].v_pointer);
--   </pre>
--   
--   <i>Since: 2.78</i>
type TypeValueFreeFunc = -- | /@value@/: the value to free GValue -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TypeValueFreeFunc :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueFreeFunc -> GValue -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TypeValueFreeFunc :: MonadIO m => TypeValueFreeFunc -> m (GClosure C_TypeValueFreeFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TypeValueFreeFunc</a>.
mk_TypeValueFreeFunc :: C_TypeValueFreeFunc -> IO (FunPtr C_TypeValueFreeFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TypeValueFreeFunc</a></tt>.
noTypeValueFreeFunc :: Maybe TypeValueFreeFunc

-- | Wrap a <a>TypeValueFreeFunc</a> into a <a>C_TypeValueFreeFunc</a>.
wrap_TypeValueFreeFunc :: Maybe (Ptr (FunPtr C_TypeValueFreeFunc)) -> TypeValueFreeFunc -> C_TypeValueFreeFunc

-- | Type for the callback on the (unwrapped) C side.
type C_TypeValueInitFunc = Ptr GValue -> IO ()

-- | Initializes the value contents by setting the fields of the
--   <tt>value-&gt;data</tt> array.
--   
--   The data array of the <a>Value</a> passed into this function was
--   zero-filled with <tt>memset()</tt>, so no care has to be taken to free
--   any old contents. For example, in the case of a string value that may
--   never be <a>Nothing</a>, the implementation might look like:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   value-&gt;data[0].v_pointer = g_strdup ("");
--   </pre>
--   
--   <i>Since: 2.78</i>
type TypeValueInitFunc = -- | /@value@/: the value to initialize GValue -> IO ()

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TypeValueInitFunc :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueInitFunc -> GValue -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TypeValueInitFunc :: MonadIO m => TypeValueInitFunc -> m (GClosure C_TypeValueInitFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TypeValueInitFunc</a>.
mk_TypeValueInitFunc :: C_TypeValueInitFunc -> IO (FunPtr C_TypeValueInitFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TypeValueInitFunc</a></tt>.
noTypeValueInitFunc :: Maybe TypeValueInitFunc

-- | Wrap a <a>TypeValueInitFunc</a> into a <a>C_TypeValueInitFunc</a>.
wrap_TypeValueInitFunc :: Maybe (Ptr (FunPtr C_TypeValueInitFunc)) -> TypeValueInitFunc -> C_TypeValueInitFunc

-- | Type for the callback on the (unwrapped) C side.
type C_TypeValueLCopyFunc = Ptr GValue -> Word32 -> Ptr TypeCValue -> Word32 -> IO CString

-- | This function is responsible for storing the <tt>value</tt> contents
--   into arguments passed through a variadic argument list which got
--   collected into <tt>collect_values</tt> according to
--   <tt>lcopy_format</tt>.
--   
--   The <tt>n_collect_values</tt> argument equals the string length of
--   <tt>lcopy_format</tt>, and <tt>collect_flags</tt> may contain
--   <a>VALUE_NOCOPY_CONTENTS</a>.
--   
--   In contrast to <a>TypeValueCollectFunc</a>, this function is obliged
--   to always properly support <a>VALUE_NOCOPY_CONTENTS</a>.
--   
--   Similar to <a>TypeValueCollectFunc</a> the function may prematurely
--   abort by returning a newly allocated string describing an error
--   condition. To complete the string example:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   gchar **string_p = collect_values[0].v_pointer;
--   g_return_val_if_fail (string_p != NULL,
--     g_strdup ("string location passed as NULL"));
--   
--   if (collect_flags &amp; G_VALUE_NOCOPY_CONTENTS)
--     *string_p = value-&gt;data[0].v_pointer;
--   else
--     *string_p = g_strdup (value-&gt;data[0].v_pointer);
--   </pre>
--   
--   And an illustrative version of this function for reference-counted
--   types:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   GObject **object_p = collect_values[0].v_pointer;
--   g_return_val_if_fail (object_p != NULL,
--     g_strdup ("object location passed as NULL"));
--   
--   if (value-&gt;data[0].v_pointer == NULL)
--     *object_p = NULL;
--   else if (collect_flags &amp; G_VALUE_NOCOPY_CONTENTS) // always honour
--     *object_p = value-&gt;data[0].v_pointer;
--   else
--     *object_p = g_object_ref (value-&gt;data[0].v_pointer);
--   
--   return NULL;
--   </pre>
--   
--   <i>Since: 2.78</i>
type TypeValueLCopyFunc = -- | /@value@/: the value to lcopy GValue -> -- | /@collectValues@/: the collected --   locations for storage [TypeCValue] -> -- | /@collectFlags@/: optional flags Word32 -> -- | __Returns:__ @NULL@ on success, otherwise --   a newly allocated error string on failure IO (Maybe Text)

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TypeValueLCopyFunc :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueLCopyFunc -> GValue -> [TypeCValue] -> Word32 -> m (Maybe Text)

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TypeValueLCopyFunc :: MonadIO m => TypeValueLCopyFunc -> m (GClosure C_TypeValueLCopyFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TypeValueLCopyFunc</a>.
mk_TypeValueLCopyFunc :: C_TypeValueLCopyFunc -> IO (FunPtr C_TypeValueLCopyFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TypeValueLCopyFunc</a></tt>.
noTypeValueLCopyFunc :: Maybe TypeValueLCopyFunc

-- | Wrap a <a>TypeValueLCopyFunc</a> into a <a>C_TypeValueLCopyFunc</a>.
wrap_TypeValueLCopyFunc :: Maybe (Ptr (FunPtr C_TypeValueLCopyFunc)) -> TypeValueLCopyFunc -> C_TypeValueLCopyFunc

-- | Type for the callback on the (unwrapped) C side.
type C_TypeValuePeekPointerFunc = Ptr GValue -> IO (Ptr ())

-- | If the value contents fit into a pointer, such as objects or strings,
--   return this pointer, so the caller can peek at the current contents.
--   
--   To extend on our above string example:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   return value-&gt;data[0].v_pointer;
--   </pre>
--   
--   <i>Since: 2.78</i>
type TypeValuePeekPointerFunc = -- | /@value@/: the value to peek GValue -> -- | __Returns:__ a pointer to the value contents IO (Ptr ())

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_TypeValuePeekPointerFunc :: (HasCallStack, MonadIO m) => FunPtr C_TypeValuePeekPointerFunc -> GValue -> m (Ptr ())

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_TypeValuePeekPointerFunc :: MonadIO m => TypeValuePeekPointerFunc -> m (GClosure C_TypeValuePeekPointerFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_TypeValuePeekPointerFunc</a>.
mk_TypeValuePeekPointerFunc :: C_TypeValuePeekPointerFunc -> IO (FunPtr C_TypeValuePeekPointerFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>TypeValuePeekPointerFunc</a></tt>.
noTypeValuePeekPointerFunc :: Maybe TypeValuePeekPointerFunc

-- | Wrap a <a>TypeValuePeekPointerFunc</a> into a
--   <a>C_TypeValuePeekPointerFunc</a>.
wrap_TypeValuePeekPointerFunc :: Maybe (Ptr (FunPtr C_TypeValuePeekPointerFunc)) -> TypeValuePeekPointerFunc -> C_TypeValuePeekPointerFunc

-- | 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 <tt><i>g_value_register_transform_func()</i></tt>.
--   
--   <i><tt>destValue</tt></i> will be initialized to the correct
--   destination type.
type ValueTransform = -- | /@srcValue@/: Source value. GValue -> -- | /@destValue@/: Target value. GValue -> 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 <a>GClosure</a>.
genClosure_ValueTransform :: MonadIO m => ValueTransform -> m (GClosure C_ValueTransform)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ValueTransform</a>.
mk_ValueTransform :: C_ValueTransform -> IO (FunPtr C_ValueTransform)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ValueTransform</a></tt>.
noValueTransform :: Maybe ValueTransform

-- | Wrap a <a>ValueTransform</a> into a <a>C_ValueTransform</a>.
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 <a>WeakNotify</a> function can be added to an object as a callback
--   that gets triggered when the object is finalized.
--   
--   Since the object is already being disposed when the <a>WeakNotify</a>
--   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.
--   
--   In particular, this means it’s invalid to call <a>objectRef</a>,
--   <tt><i>g_weak_ref_init()</i></tt>, <tt><i>g_weak_ref_set()</i></tt>,
--   <tt><i>g_object_add_toggle_ref()</i></tt>,
--   <tt><i>g_object_weak_ref()</i></tt>,
--   <tt><i>g_object_add_weak_pointer()</i></tt> or any function which
--   calls them on the object from this callback.
type WeakNotify = -- | /@data@/: data that was provided when the weak reference was established Ptr () -> -- | /@whereTheObjectWas@/: the object being disposed Object -> 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 <a>GClosure</a>.
genClosure_WeakNotify :: MonadIO m => WeakNotify -> m (GClosure C_WeakNotify)

-- | Generate a function pointer callable from C code, from a
--   <a>C_WeakNotify</a>.
mk_WeakNotify :: C_WeakNotify -> IO (FunPtr C_WeakNotify)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>WeakNotify</a></tt>.
noWeakNotify :: Maybe WeakNotify

-- | Wrap a <a>WeakNotify</a> into a <a>C_WeakNotify</a>.
wrap_WeakNotify :: Maybe (Ptr (FunPtr C_WeakNotify)) -> WeakNotify -> C_WeakNotify


-- | The <a>TypeValueTable</a> provides the functions required by the
--   <a>Value</a> 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 <a>TypeValueTable</a> struct initialized to zero.
newZeroTypeValueTable :: MonadIO m => m TypeValueTable

-- | Set the value of the “<tt>collect_format</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #collectFormat
--   </pre>
clearTypeValueTableCollectFormat :: MonadIO m => TypeValueTable -> m ()

-- | Get the value of the “<tt>collect_format</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeValueTable #collectFormat
--   </pre>
getTypeValueTableCollectFormat :: MonadIO m => TypeValueTable -> m (Maybe Text)

-- | Set the value of the “<tt>collect_format</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeValueTable [ #collectFormat <a>:=</a> value ]
--   </pre>
setTypeValueTableCollectFormat :: MonadIO m => TypeValueTable -> CString -> m ()

-- | Set the value of the “<tt>collect_value</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #collectValue
--   </pre>
clearTypeValueTableCollectValue :: MonadIO m => TypeValueTable -> m ()

-- | Get the value of the “<tt>collect_value</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeValueTable #collectValue
--   </pre>
getTypeValueTableCollectValue :: MonadIO m => TypeValueTable -> m (Maybe TypeValueCollectFunc)

-- | Set the value of the “<tt>collect_value</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeValueTable [ #collectValue <a>:=</a> value ]
--   </pre>
setTypeValueTableCollectValue :: MonadIO m => TypeValueTable -> FunPtr C_TypeValueCollectFunc -> m ()

-- | Set the value of the “<tt>lcopy_format</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #lcopyFormat
--   </pre>
clearTypeValueTableLcopyFormat :: MonadIO m => TypeValueTable -> m ()

-- | Get the value of the “<tt>lcopy_format</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeValueTable #lcopyFormat
--   </pre>
getTypeValueTableLcopyFormat :: MonadIO m => TypeValueTable -> m (Maybe Text)

-- | Set the value of the “<tt>lcopy_format</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeValueTable [ #lcopyFormat <a>:=</a> value ]
--   </pre>
setTypeValueTableLcopyFormat :: MonadIO m => TypeValueTable -> CString -> m ()

-- | Set the value of the “<tt>lcopy_value</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #lcopyValue
--   </pre>
clearTypeValueTableLcopyValue :: MonadIO m => TypeValueTable -> m ()

-- | Get the value of the “<tt>lcopy_value</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeValueTable #lcopyValue
--   </pre>
getTypeValueTableLcopyValue :: MonadIO m => TypeValueTable -> m (Maybe TypeValueLCopyFunc)

-- | Set the value of the “<tt>lcopy_value</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeValueTable [ #lcopyValue <a>:=</a> value ]
--   </pre>
setTypeValueTableLcopyValue :: MonadIO m => TypeValueTable -> FunPtr C_TypeValueLCopyFunc -> m ()

-- | Set the value of the “<tt>value_copy</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #valueCopy
--   </pre>
clearTypeValueTableValueCopy :: MonadIO m => TypeValueTable -> m ()

-- | Get the value of the “<tt>value_copy</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeValueTable #valueCopy
--   </pre>
getTypeValueTableValueCopy :: MonadIO m => TypeValueTable -> m (Maybe TypeValueCopyFunc)

-- | Set the value of the “<tt>value_copy</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeValueTable [ #valueCopy <a>:=</a> value ]
--   </pre>
setTypeValueTableValueCopy :: MonadIO m => TypeValueTable -> FunPtr C_TypeValueCopyFunc -> m ()

-- | Set the value of the “<tt>value_free</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #valueFree
--   </pre>
clearTypeValueTableValueFree :: MonadIO m => TypeValueTable -> m ()

-- | Get the value of the “<tt>value_free</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeValueTable #valueFree
--   </pre>
getTypeValueTableValueFree :: MonadIO m => TypeValueTable -> m (Maybe TypeValueFreeFunc)

-- | Set the value of the “<tt>value_free</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeValueTable [ #valueFree <a>:=</a> value ]
--   </pre>
setTypeValueTableValueFree :: MonadIO m => TypeValueTable -> FunPtr C_TypeValueFreeFunc -> m ()

-- | Set the value of the “<tt>value_init</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #valueInit
--   </pre>
clearTypeValueTableValueInit :: MonadIO m => TypeValueTable -> m ()

-- | Get the value of the “<tt>value_init</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeValueTable #valueInit
--   </pre>
getTypeValueTableValueInit :: MonadIO m => TypeValueTable -> m (Maybe TypeValueInitFunc)

-- | Set the value of the “<tt>value_init</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeValueTable [ #valueInit <a>:=</a> value ]
--   </pre>
setTypeValueTableValueInit :: MonadIO m => TypeValueTable -> FunPtr C_TypeValueInitFunc -> m ()

-- | Set the value of the “<tt>value_peek_pointer</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #valuePeekPointer
--   </pre>
clearTypeValueTableValuePeekPointer :: MonadIO m => TypeValueTable -> m ()

-- | Get the value of the “<tt>value_peek_pointer</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeValueTable #valuePeekPointer
--   </pre>
getTypeValueTableValuePeekPointer :: MonadIO m => TypeValueTable -> m (Maybe TypeValuePeekPointerFunc)

-- | Set the value of the “<tt>value_peek_pointer</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeValueTable [ #valuePeekPointer <a>:=</a> value ]
--   </pre>
setTypeValueTableValuePeekPointer :: MonadIO m => TypeValueTable -> FunPtr C_TypeValuePeekPointerFunc -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.TypeValueTable.TypeValueTable
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.TypeValueTable.TypeValueTable
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.TypeValueTable.TypeValueTable
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.TypeValueTable.TypeValueTable
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.TypeValueTable.TypeValueTable tag


-- | 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 <a>TypeInterface</a> struct initialized to zero.
newZeroTypeInterface :: MonadIO m => m TypeInterface

-- | Adds <i><tt>prerequisiteType</tt></i> to the list of prerequisites of
--   <i><tt>interfaceType</tt></i>. This means that any type implementing
--   <i><tt>interfaceType</tt></i> must also implement
--   <i><tt>prerequisiteType</tt></i>. 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 <a>TypePlugin</a> structure for the dynamic interface
--   <i><tt>interfaceType</tt></i> which has been added to
--   <i><tt>instanceType</tt></i>, or <a>Nothing</a> if
--   <i><tt>interfaceType</tt></i> has not been added to
--   <i><tt>instanceType</tt></i> or does not have a <a>TypePlugin</a>
--   structure. See <a>typeAddInterfaceDynamic</a>.
typeInterfaceGetPlugin :: (HasCallStack, MonadIO m) => GType -> GType -> m TypePlugin

-- | Returns the most specific instantiatable prerequisite of an interface
--   type. If the interface type has no instantiatable prerequisite,
--   <tt><i>G_TYPE_INVALID</i></tt> is returned.
--   
--   See <a>typeInterfaceAddPrerequisite</a> for more information about
--   prerequisites.
--   
--   <i>Since: 2.68</i>
typeInterfaceInstantiatablePrerequisite :: (HasCallStack, MonadIO m) => GType -> m GType

-- | Returns the <a>TypeInterface</a> structure of an interface to which
--   the passed in class conforms.
typeInterfacePeek :: (HasCallStack, MonadIO m) => TypeClass -> GType -> m TypeInterface

-- | Returns the corresponding <a>TypeInterface</a> structure of the parent
--   type of the instance type to which <i><tt>gIface</tt></i> 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.
--   
--   <i>Since: 2.2</i>
typeInterfacePrerequisites :: (HasCallStack, MonadIO m) => GType -> m [GType]
instance GHC.Classes.Eq GI.GObject.Structs.TypeInterface.TypeInterface
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.TypeInterface.TypeInterface
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.TypeInterface.TypeInterface
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.TypeInterface.TypeInterface
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.TypeInterface.TypeInterface 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 <a>typeRegisterStatic</a>
--   function (or is copied into the provided <a>TypeInfo</a> structure in
--   the <a>typePluginCompleteTypeInfo</a>). The type system will perform a
--   deep copy of this structure, so its memory does not need to be
--   persistent across invocation of <a>typeRegisterStatic</a>.
module GI.GObject.Structs.TypeInfo

-- | Memory-managed wrapper type.
newtype TypeInfo
TypeInfo :: ManagedPtr TypeInfo -> TypeInfo

-- | Construct a <a>TypeInfo</a> struct initialized to zero.
newZeroTypeInfo :: MonadIO m => m TypeInfo

-- | Set the value of the “<tt>base_finalize</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #baseFinalize
--   </pre>
clearTypeInfoBaseFinalize :: MonadIO m => TypeInfo -> m ()

-- | Get the value of the “<tt>base_finalize</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeInfo #baseFinalize
--   </pre>
getTypeInfoBaseFinalize :: MonadIO m => TypeInfo -> m (Maybe BaseFinalizeFunc)

-- | Set the value of the “<tt>base_finalize</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeInfo [ #baseFinalize <a>:=</a> value ]
--   </pre>
setTypeInfoBaseFinalize :: MonadIO m => TypeInfo -> FunPtr C_BaseFinalizeFunc -> m ()

-- | Set the value of the “<tt>base_init</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #baseInit
--   </pre>
clearTypeInfoBaseInit :: MonadIO m => TypeInfo -> m ()

-- | Get the value of the “<tt>base_init</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeInfo #baseInit
--   </pre>
getTypeInfoBaseInit :: MonadIO m => TypeInfo -> m (Maybe BaseInitFunc)

-- | Set the value of the “<tt>base_init</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeInfo [ #baseInit <a>:=</a> value ]
--   </pre>
setTypeInfoBaseInit :: MonadIO m => TypeInfo -> FunPtr C_BaseInitFunc -> m ()

-- | Set the value of the “<tt>class_data</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #classData
--   </pre>
clearTypeInfoClassData :: MonadIO m => TypeInfo -> m ()

-- | Get the value of the “<tt>class_data</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeInfo #classData
--   </pre>
getTypeInfoClassData :: MonadIO m => TypeInfo -> m (Ptr ())

-- | Set the value of the “<tt>class_data</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeInfo [ #classData <a>:=</a> value ]
--   </pre>
setTypeInfoClassData :: MonadIO m => TypeInfo -> Ptr () -> m ()

-- | Set the value of the “<tt>class_finalize</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #classFinalize
--   </pre>
clearTypeInfoClassFinalize :: MonadIO m => TypeInfo -> m ()

-- | Get the value of the “<tt>class_finalize</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeInfo #classFinalize
--   </pre>
getTypeInfoClassFinalize :: MonadIO m => TypeInfo -> m (Maybe ClassFinalizeFunc_WithClosures)

-- | Set the value of the “<tt>class_finalize</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeInfo [ #classFinalize <a>:=</a> value ]
--   </pre>
setTypeInfoClassFinalize :: MonadIO m => TypeInfo -> FunPtr C_ClassFinalizeFunc -> m ()

-- | Set the value of the “<tt>class_init</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #classInit
--   </pre>
clearTypeInfoClassInit :: MonadIO m => TypeInfo -> m ()

-- | Get the value of the “<tt>class_init</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeInfo #classInit
--   </pre>
getTypeInfoClassInit :: MonadIO m => TypeInfo -> m (Maybe ClassInitFunc_WithClosures)

-- | Set the value of the “<tt>class_init</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeInfo [ #classInit <a>:=</a> value ]
--   </pre>
setTypeInfoClassInit :: MonadIO m => TypeInfo -> FunPtr C_ClassInitFunc -> m ()

-- | Get the value of the “<tt>class_size</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeInfo #classSize
--   </pre>
getTypeInfoClassSize :: MonadIO m => TypeInfo -> m Word16

-- | Set the value of the “<tt>class_size</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeInfo [ #classSize <a>:=</a> value ]
--   </pre>
setTypeInfoClassSize :: MonadIO m => TypeInfo -> Word16 -> m ()

-- | Set the value of the “<tt>instance_init</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #instanceInit
--   </pre>
clearTypeInfoInstanceInit :: MonadIO m => TypeInfo -> m ()

-- | Get the value of the “<tt>instance_init</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeInfo #instanceInit
--   </pre>
getTypeInfoInstanceInit :: MonadIO m => TypeInfo -> m (Maybe InstanceInitFunc)

-- | Set the value of the “<tt>instance_init</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeInfo [ #instanceInit <a>:=</a> value ]
--   </pre>
setTypeInfoInstanceInit :: MonadIO m => TypeInfo -> FunPtr C_InstanceInitFunc -> m ()

-- | Get the value of the “<tt>instance_size</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeInfo #instanceSize
--   </pre>
getTypeInfoInstanceSize :: MonadIO m => TypeInfo -> m Word16

-- | Set the value of the “<tt>instance_size</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeInfo [ #instanceSize <a>:=</a> value ]
--   </pre>
setTypeInfoInstanceSize :: MonadIO m => TypeInfo -> Word16 -> m ()

-- | Get the value of the “<tt>n_preallocs</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeInfo #nPreallocs
--   </pre>
getTypeInfoNPreallocs :: MonadIO m => TypeInfo -> m Word16

-- | Set the value of the “<tt>n_preallocs</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeInfo [ #nPreallocs <a>:=</a> value ]
--   </pre>
setTypeInfoNPreallocs :: MonadIO m => TypeInfo -> Word16 -> m ()

-- | Set the value of the “<tt>value_table</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #valueTable
--   </pre>
clearTypeInfoValueTable :: MonadIO m => TypeInfo -> m ()

-- | Get the value of the “<tt>value_table</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> typeInfo #valueTable
--   </pre>
getTypeInfoValueTable :: MonadIO m => TypeInfo -> m (Maybe TypeValueTable)

-- | Set the value of the “<tt>value_table</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> typeInfo [ #valueTable <a>:=</a> value ]
--   </pre>
setTypeInfoValueTable :: MonadIO m => TypeInfo -> Ptr TypeValueTable -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.TypeInfo.TypeInfo
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.TypeInfo.TypeInfo
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.TypeInfo.TypeInfo
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.TypeInfo.TypeInfo
instance (tag GHC.Types.~ '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
--   <a>paramTypeRegisterStatic</a> The type system will perform a deep
--   copy of this structure, so its memory does not need to be persistent
--   across invocation of <a>paramTypeRegisterStatic</a>.
module GI.GObject.Structs.ParamSpecTypeInfo

-- | Memory-managed wrapper type.
newtype ParamSpecTypeInfo
ParamSpecTypeInfo :: ManagedPtr ParamSpecTypeInfo -> ParamSpecTypeInfo

-- | Construct a <a>ParamSpecTypeInfo</a> struct initialized to zero.
newZeroParamSpecTypeInfo :: MonadIO m => m ParamSpecTypeInfo

-- | Set the value of the “<tt>finalize</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #finalize
--   </pre>
clearParamSpecTypeInfoFinalize :: MonadIO m => ParamSpecTypeInfo -> m ()

-- | Get the value of the “<tt>finalize</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paramSpecTypeInfo #finalize
--   </pre>
getParamSpecTypeInfoFinalize :: MonadIO m => ParamSpecTypeInfo -> m (Maybe ParamSpecTypeInfoFinalizeFieldCallback)

-- | Set the value of the “<tt>finalize</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> paramSpecTypeInfo [ #finalize <a>:=</a> value ]
--   </pre>
setParamSpecTypeInfoFinalize :: MonadIO m => ParamSpecTypeInfo -> FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback -> m ()

-- | Set the value of the “<tt>instance_init</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #instanceInit
--   </pre>
clearParamSpecTypeInfoInstanceInit :: MonadIO m => ParamSpecTypeInfo -> m ()

-- | Get the value of the “<tt>instance_init</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paramSpecTypeInfo #instanceInit
--   </pre>
getParamSpecTypeInfoInstanceInit :: MonadIO m => ParamSpecTypeInfo -> m (Maybe ParamSpecTypeInfoInstanceInitFieldCallback)

-- | Set the value of the “<tt>instance_init</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> paramSpecTypeInfo [ #instanceInit <a>:=</a> value ]
--   </pre>
setParamSpecTypeInfoInstanceInit :: MonadIO m => ParamSpecTypeInfo -> FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback -> m ()

-- | Get the value of the “<tt>instance_size</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paramSpecTypeInfo #instanceSize
--   </pre>
getParamSpecTypeInfoInstanceSize :: MonadIO m => ParamSpecTypeInfo -> m Word16

-- | Set the value of the “<tt>instance_size</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> paramSpecTypeInfo [ #instanceSize <a>:=</a> value ]
--   </pre>
setParamSpecTypeInfoInstanceSize :: MonadIO m => ParamSpecTypeInfo -> Word16 -> m ()

-- | Get the value of the “<tt>n_preallocs</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paramSpecTypeInfo #nPreallocs
--   </pre>
getParamSpecTypeInfoNPreallocs :: MonadIO m => ParamSpecTypeInfo -> m Word16

-- | Set the value of the “<tt>n_preallocs</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> paramSpecTypeInfo [ #nPreallocs <a>:=</a> value ]
--   </pre>
setParamSpecTypeInfoNPreallocs :: MonadIO m => ParamSpecTypeInfo -> Word16 -> m ()

-- | Set the value of the “<tt>value_set_default</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #valueSetDefault
--   </pre>
clearParamSpecTypeInfoValueSetDefault :: MonadIO m => ParamSpecTypeInfo -> m ()

-- | Get the value of the “<tt>value_set_default</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paramSpecTypeInfo #valueSetDefault
--   </pre>
getParamSpecTypeInfoValueSetDefault :: MonadIO m => ParamSpecTypeInfo -> m (Maybe ParamSpecTypeInfoValueSetDefaultFieldCallback)

-- | Set the value of the “<tt>value_set_default</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> paramSpecTypeInfo [ #valueSetDefault <a>:=</a> value ]
--   </pre>
setParamSpecTypeInfoValueSetDefault :: MonadIO m => ParamSpecTypeInfo -> FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback -> m ()

-- | Get the value of the “<tt>value_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paramSpecTypeInfo #valueType
--   </pre>
getParamSpecTypeInfoValueType :: MonadIO m => ParamSpecTypeInfo -> m GType

-- | Set the value of the “<tt>value_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> paramSpecTypeInfo [ #valueType <a>:=</a> value ]
--   </pre>
setParamSpecTypeInfoValueType :: MonadIO m => ParamSpecTypeInfo -> GType -> m ()

-- | Set the value of the “<tt>value_validate</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #valueValidate
--   </pre>
clearParamSpecTypeInfoValueValidate :: MonadIO m => ParamSpecTypeInfo -> m ()

-- | Get the value of the “<tt>value_validate</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paramSpecTypeInfo #valueValidate
--   </pre>
getParamSpecTypeInfoValueValidate :: MonadIO m => ParamSpecTypeInfo -> m (Maybe ParamSpecTypeInfoValueValidateFieldCallback)

-- | Set the value of the “<tt>value_validate</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> paramSpecTypeInfo [ #valueValidate <a>:=</a> value ]
--   </pre>
setParamSpecTypeInfoValueValidate :: MonadIO m => ParamSpecTypeInfo -> FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback -> m ()

-- | Set the value of the “<tt>values_cmp</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #valuesCmp
--   </pre>
clearParamSpecTypeInfoValuesCmp :: MonadIO m => ParamSpecTypeInfo -> m ()

-- | Get the value of the “<tt>values_cmp</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> paramSpecTypeInfo #valuesCmp
--   </pre>
getParamSpecTypeInfoValuesCmp :: MonadIO m => ParamSpecTypeInfo -> m (Maybe ParamSpecTypeInfoValuesCmpFieldCallback)

-- | Set the value of the “<tt>values_cmp</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> paramSpecTypeInfo [ #valuesCmp <a>:=</a> value ]
--   </pre>
setParamSpecTypeInfoValuesCmp :: MonadIO m => ParamSpecTypeInfo -> FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfo
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfo
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfo
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfo
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfo tag


-- | The class structure for the GObject type.
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   // Example of implementing a singleton using a constructor.
--   static MySingleton *the_singleton = NULL;
--   
--   static GObject*
--   my_singleton_constructor (GType                  type,
--                             guint                  n_construct_params,
--                             GObjectConstructParam *construct_params)
--   {
--     GObject *object;
--     
--     if (!the_singleton)
--       {
--         object = G_OBJECT_CLASS (parent_class)-&gt;constructor (type,
--                                                              n_construct_params,
--                                                              construct_params);
--         the_singleton = MY_SINGLETON (object);
--       }
--     else
--       object = g_object_ref (G_OBJECT (the_singleton));
--   
--     return object;
--   }
--   </pre>
module GI.GObject.Structs.ObjectClass

-- | Memory-managed wrapper type.
newtype ObjectClass
ObjectClass :: ManagedPtr ObjectClass -> ObjectClass

-- | Construct a <a>ObjectClass</a> struct initialized to zero.
newZeroObjectClass :: MonadIO m => m ObjectClass

-- | Looks up the <a>ParamSpec</a> for a property of a class.
objectClassFindProperty :: (HasCallStack, MonadIO m) => ObjectClass -> Text -> m GParamSpec

-- | Installs a new property.
--   
--   All properties should be installed during the class initializer. It is
--   possible to install properties after that, but doing so is not
--   recommend, and specifically, is not guaranteed to be thread-safe vs.
--   use of properties on the same type on other threads.
--   
--   Note that it is possible to redefine a property in a derived class, by
--   installing a property with the same name. This can be useful at times,
--   e.g. to change the range of allowed values or the default value.
objectClassInstallProperty :: (HasCallStack, MonadIO m) => ObjectClass -> Word32 -> GParamSpec -> m ()

-- | Registers <i><tt>propertyId</tt></i> as referring to a property with
--   the name <i><tt>name</tt></i> in a parent class or in an interface
--   implemented by <i><tt>oclass</tt></i>. This allows this class to
--   "override" a property implementation in a parent class or to provide
--   the implementation of a property from an interface.
--   
--   Internally, overriding is implemented by creating a property of type
--   <a>ParamSpecOverride</a>; generally operations that query the
--   properties of the object class, such as <a>objectClassFindProperty</a>
--   or <a>objectClassListProperties</a> will return the overridden
--   property. However, in one case, the
--   <i><tt>constructProperties</tt></i> argument of the
--   <i><tt>constructor</tt></i> virtual function, the
--   <a>ParamSpecOverride</a> is passed instead, so that the
--   <i><tt>paramId</tt></i> field of the <a>ParamSpec</a> will be correct.
--   For virtually all uses, this makes no difference. If you need to get
--   the overridden property, you can call
--   <a>paramSpecGetRedirectTarget</a>.
--   
--   <i>Since: 2.4</i>
objectClassOverrideProperty :: (HasCallStack, MonadIO m) => ObjectClass -> Word32 -> Text -> m ()

-- | Set the value of the “<tt>constructed</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #constructed
--   </pre>
clearObjectClassConstructed :: MonadIO m => ObjectClass -> m ()

-- | Get the value of the “<tt>constructed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> objectClass #constructed
--   </pre>
getObjectClassConstructed :: MonadIO m => ObjectClass -> m (Maybe ObjectClassConstructedFieldCallback)

-- | Set the value of the “<tt>constructed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> objectClass [ #constructed <a>:=</a> value ]
--   </pre>
setObjectClassConstructed :: MonadIO m => ObjectClass -> FunPtr C_ObjectClassConstructedFieldCallback -> m ()

-- | Set the value of the “<tt>dispatch_properties_changed</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #dispatchPropertiesChanged
--   </pre>
clearObjectClassDispatchPropertiesChanged :: MonadIO m => ObjectClass -> m ()

-- | Get the value of the “<tt>dispatch_properties_changed</tt>” field.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> objectClass #dispatchPropertiesChanged
--   </pre>
getObjectClassDispatchPropertiesChanged :: MonadIO m => ObjectClass -> m (Maybe ObjectClassDispatchPropertiesChangedFieldCallback)

-- | Set the value of the “<tt>dispatch_properties_changed</tt>” field.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> objectClass [ #dispatchPropertiesChanged <a>:=</a> value ]
--   </pre>
setObjectClassDispatchPropertiesChanged :: MonadIO m => ObjectClass -> FunPtr C_ObjectClassDispatchPropertiesChangedFieldCallback -> m ()

-- | Set the value of the “<tt>dispose</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #dispose
--   </pre>
clearObjectClassDispose :: MonadIO m => ObjectClass -> m ()

-- | Get the value of the “<tt>dispose</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> objectClass #dispose
--   </pre>
getObjectClassDispose :: MonadIO m => ObjectClass -> m (Maybe ObjectClassDisposeFieldCallback)

-- | Set the value of the “<tt>dispose</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> objectClass [ #dispose <a>:=</a> value ]
--   </pre>
setObjectClassDispose :: MonadIO m => ObjectClass -> FunPtr C_ObjectClassDisposeFieldCallback -> m ()

-- | Set the value of the “<tt>finalize</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #finalize
--   </pre>
clearObjectClassFinalize :: MonadIO m => ObjectClass -> m ()

-- | Get the value of the “<tt>finalize</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> objectClass #finalize
--   </pre>
getObjectClassFinalize :: MonadIO m => ObjectClass -> m (Maybe ObjectClassFinalizeFieldCallback)

-- | Set the value of the “<tt>finalize</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> objectClass [ #finalize <a>:=</a> value ]
--   </pre>
setObjectClassFinalize :: MonadIO m => ObjectClass -> FunPtr C_ObjectClassFinalizeFieldCallback -> m ()

-- | Get the value of the “<tt>g_type_class</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> objectClass #gTypeClass
--   </pre>
getObjectClassGTypeClass :: MonadIO m => ObjectClass -> m TypeClass

-- | Set the value of the “<tt>get_property</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #getProperty
--   </pre>
clearObjectClassGetProperty :: MonadIO m => ObjectClass -> m ()

-- | Get the value of the “<tt>get_property</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> objectClass #getProperty
--   </pre>
getObjectClassGetProperty :: MonadIO m => ObjectClass -> m (Maybe ObjectClassGetPropertyFieldCallback)

-- | Set the value of the “<tt>get_property</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> objectClass [ #getProperty <a>:=</a> value ]
--   </pre>
setObjectClassGetProperty :: MonadIO m => ObjectClass -> FunPtr C_ObjectClassGetPropertyFieldCallback -> m ()

-- | Set the value of the “<tt>notify</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #notify
--   </pre>
clearObjectClassNotify :: MonadIO m => ObjectClass -> m ()

-- | Get the value of the “<tt>notify</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> objectClass #notify
--   </pre>
getObjectClassNotify :: MonadIO m => ObjectClass -> m (Maybe ObjectClassNotifyFieldCallback)

-- | Set the value of the “<tt>notify</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> objectClass [ #notify <a>:=</a> value ]
--   </pre>
setObjectClassNotify :: MonadIO m => ObjectClass -> FunPtr C_ObjectClassNotifyFieldCallback -> m ()

-- | Set the value of the “<tt>set_property</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #setProperty
--   </pre>
clearObjectClassSetProperty :: MonadIO m => ObjectClass -> m ()

-- | Get the value of the “<tt>set_property</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> objectClass #setProperty
--   </pre>
getObjectClassSetProperty :: MonadIO m => ObjectClass -> m (Maybe ObjectClassSetPropertyFieldCallback)

-- | Set the value of the “<tt>set_property</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> objectClass [ #setProperty <a>:=</a> value ]
--   </pre>
setObjectClassSetProperty :: MonadIO m => ObjectClass -> FunPtr C_ObjectClassSetPropertyFieldCallback -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.ObjectClass.ObjectClass
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.ObjectClass.ObjectClass
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.ObjectClass.ObjectClass
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.ObjectClass.ObjectClass
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.ObjectClass.ObjectClass 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 <a>InterfaceInfo</a> struct initialized to zero.
newZeroInterfaceInfo :: MonadIO m => m InterfaceInfo

-- | Set the value of the “<tt>interface_data</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #interfaceData
--   </pre>
clearInterfaceInfoInterfaceData :: MonadIO m => InterfaceInfo -> m ()

-- | Get the value of the “<tt>interface_data</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> interfaceInfo #interfaceData
--   </pre>
getInterfaceInfoInterfaceData :: MonadIO m => InterfaceInfo -> m (Ptr ())

-- | Set the value of the “<tt>interface_data</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> interfaceInfo [ #interfaceData <a>:=</a> value ]
--   </pre>
setInterfaceInfoInterfaceData :: MonadIO m => InterfaceInfo -> Ptr () -> m ()

-- | Set the value of the “<tt>interface_finalize</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #interfaceFinalize
--   </pre>
clearInterfaceInfoInterfaceFinalize :: MonadIO m => InterfaceInfo -> m ()

-- | Get the value of the “<tt>interface_finalize</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> interfaceInfo #interfaceFinalize
--   </pre>
getInterfaceInfoInterfaceFinalize :: MonadIO m => InterfaceInfo -> m (Maybe InterfaceFinalizeFunc_WithClosures)

-- | Set the value of the “<tt>interface_finalize</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> interfaceInfo [ #interfaceFinalize <a>:=</a> value ]
--   </pre>
setInterfaceInfoInterfaceFinalize :: MonadIO m => InterfaceInfo -> FunPtr C_InterfaceFinalizeFunc -> m ()

-- | Set the value of the “<tt>interface_init</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #interfaceInit
--   </pre>
clearInterfaceInfoInterfaceInit :: MonadIO m => InterfaceInfo -> m ()

-- | Get the value of the “<tt>interface_init</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> interfaceInfo #interfaceInit
--   </pre>
getInterfaceInfoInterfaceInit :: MonadIO m => InterfaceInfo -> m (Maybe InterfaceInitFunc_WithClosures)

-- | Set the value of the “<tt>interface_init</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> interfaceInfo [ #interfaceInit <a>:=</a> value ]
--   </pre>
setInterfaceInfoInterfaceInit :: MonadIO m => InterfaceInfo -> FunPtr C_InterfaceInitFunc -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.InterfaceInfo.InterfaceInfo
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.InterfaceInfo.InterfaceInfo
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.InterfaceInfo.InterfaceInfo
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.InterfaceInfo.InterfaceInfo
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.InterfaceInfo.InterfaceInfo tag


-- | The class structure for the GInitiallyUnowned type.
module GI.GObject.Structs.InitiallyUnownedClass

-- | Memory-managed wrapper type.
newtype InitiallyUnownedClass
InitiallyUnownedClass :: ManagedPtr InitiallyUnownedClass -> InitiallyUnownedClass

-- | Construct a <a>InitiallyUnownedClass</a> struct initialized to zero.
newZeroInitiallyUnownedClass :: MonadIO m => m InitiallyUnownedClass

-- | Set the value of the “<tt>constructed</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #constructed
--   </pre>
clearInitiallyUnownedClassConstructed :: MonadIO m => InitiallyUnownedClass -> m ()

-- | Get the value of the “<tt>constructed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> initiallyUnownedClass #constructed
--   </pre>
getInitiallyUnownedClassConstructed :: MonadIO m => InitiallyUnownedClass -> m (Maybe InitiallyUnownedClassConstructedFieldCallback)

-- | Set the value of the “<tt>constructed</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> initiallyUnownedClass [ #constructed <a>:=</a> value ]
--   </pre>
setInitiallyUnownedClassConstructed :: MonadIO m => InitiallyUnownedClass -> FunPtr C_InitiallyUnownedClassConstructedFieldCallback -> m ()

-- | Set the value of the “<tt>dispatch_properties_changed</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #dispatchPropertiesChanged
--   </pre>
clearInitiallyUnownedClassDispatchPropertiesChanged :: MonadIO m => InitiallyUnownedClass -> m ()

-- | Get the value of the “<tt>dispatch_properties_changed</tt>” field.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> initiallyUnownedClass #dispatchPropertiesChanged
--   </pre>
getInitiallyUnownedClassDispatchPropertiesChanged :: MonadIO m => InitiallyUnownedClass -> m (Maybe InitiallyUnownedClassDispatchPropertiesChangedFieldCallback)

-- | Set the value of the “<tt>dispatch_properties_changed</tt>” field.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> initiallyUnownedClass [ #dispatchPropertiesChanged <a>:=</a> value ]
--   </pre>
setInitiallyUnownedClassDispatchPropertiesChanged :: MonadIO m => InitiallyUnownedClass -> FunPtr C_InitiallyUnownedClassDispatchPropertiesChangedFieldCallback -> m ()

-- | Set the value of the “<tt>dispose</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #dispose
--   </pre>
clearInitiallyUnownedClassDispose :: MonadIO m => InitiallyUnownedClass -> m ()

-- | Get the value of the “<tt>dispose</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> initiallyUnownedClass #dispose
--   </pre>
getInitiallyUnownedClassDispose :: MonadIO m => InitiallyUnownedClass -> m (Maybe InitiallyUnownedClassDisposeFieldCallback)

-- | Set the value of the “<tt>dispose</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> initiallyUnownedClass [ #dispose <a>:=</a> value ]
--   </pre>
setInitiallyUnownedClassDispose :: MonadIO m => InitiallyUnownedClass -> FunPtr C_InitiallyUnownedClassDisposeFieldCallback -> m ()

-- | Set the value of the “<tt>finalize</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #finalize
--   </pre>
clearInitiallyUnownedClassFinalize :: MonadIO m => InitiallyUnownedClass -> m ()

-- | Get the value of the “<tt>finalize</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> initiallyUnownedClass #finalize
--   </pre>
getInitiallyUnownedClassFinalize :: MonadIO m => InitiallyUnownedClass -> m (Maybe InitiallyUnownedClassFinalizeFieldCallback)

-- | Set the value of the “<tt>finalize</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> initiallyUnownedClass [ #finalize <a>:=</a> value ]
--   </pre>
setInitiallyUnownedClassFinalize :: MonadIO m => InitiallyUnownedClass -> FunPtr C_InitiallyUnownedClassFinalizeFieldCallback -> m ()

-- | Get the value of the “<tt>g_type_class</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> initiallyUnownedClass #gTypeClass
--   </pre>
getInitiallyUnownedClassGTypeClass :: MonadIO m => InitiallyUnownedClass -> m TypeClass

-- | Set the value of the “<tt>get_property</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #getProperty
--   </pre>
clearInitiallyUnownedClassGetProperty :: MonadIO m => InitiallyUnownedClass -> m ()

-- | Get the value of the “<tt>get_property</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> initiallyUnownedClass #getProperty
--   </pre>
getInitiallyUnownedClassGetProperty :: MonadIO m => InitiallyUnownedClass -> m (Maybe InitiallyUnownedClassGetPropertyFieldCallback)

-- | Set the value of the “<tt>get_property</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> initiallyUnownedClass [ #getProperty <a>:=</a> value ]
--   </pre>
setInitiallyUnownedClassGetProperty :: MonadIO m => InitiallyUnownedClass -> FunPtr C_InitiallyUnownedClassGetPropertyFieldCallback -> m ()

-- | Set the value of the “<tt>notify</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #notify
--   </pre>
clearInitiallyUnownedClassNotify :: MonadIO m => InitiallyUnownedClass -> m ()

-- | Get the value of the “<tt>notify</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> initiallyUnownedClass #notify
--   </pre>
getInitiallyUnownedClassNotify :: MonadIO m => InitiallyUnownedClass -> m (Maybe InitiallyUnownedClassNotifyFieldCallback)

-- | Set the value of the “<tt>notify</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> initiallyUnownedClass [ #notify <a>:=</a> value ]
--   </pre>
setInitiallyUnownedClassNotify :: MonadIO m => InitiallyUnownedClass -> FunPtr C_InitiallyUnownedClassNotifyFieldCallback -> m ()

-- | Set the value of the “<tt>set_property</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #setProperty
--   </pre>
clearInitiallyUnownedClassSetProperty :: MonadIO m => InitiallyUnownedClass -> m ()

-- | Get the value of the “<tt>set_property</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> initiallyUnownedClass #setProperty
--   </pre>
getInitiallyUnownedClassSetProperty :: MonadIO m => InitiallyUnownedClass -> m (Maybe InitiallyUnownedClassSetPropertyFieldCallback)

-- | Set the value of the “<tt>set_property</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> initiallyUnownedClass [ #setProperty <a>:=</a> value ]
--   </pre>
setInitiallyUnownedClassSetProperty :: MonadIO m => InitiallyUnownedClass -> FunPtr C_InitiallyUnownedClassSetPropertyFieldCallback -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.InitiallyUnownedClass.InitiallyUnownedClass
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.InitiallyUnownedClass.InitiallyUnownedClass
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.InitiallyUnownedClass.InitiallyUnownedClass
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.InitiallyUnownedClass.InitiallyUnownedClass
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.InitiallyUnownedClass.InitiallyUnownedClass tag


-- | <i>No description available in the introspection data.</i>
module GI.GObject.Structs.ClosureNotifyData

-- | Memory-managed wrapper type.
newtype ClosureNotifyData
ClosureNotifyData :: ManagedPtr ClosureNotifyData -> ClosureNotifyData

-- | Construct a <a>ClosureNotifyData</a> struct initialized to zero.
newZeroClosureNotifyData :: MonadIO m => m ClosureNotifyData

-- | Set the value of the “<tt>data</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #data
--   </pre>
clearClosureNotifyDataData :: MonadIO m => ClosureNotifyData -> m ()

-- | Get the value of the “<tt>data</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> closureNotifyData #data
--   </pre>
getClosureNotifyDataData :: MonadIO m => ClosureNotifyData -> m (Ptr ())

-- | Set the value of the “<tt>data</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> closureNotifyData [ #data <a>:=</a> value ]
--   </pre>
setClosureNotifyDataData :: MonadIO m => ClosureNotifyData -> Ptr () -> m ()

-- | Set the value of the “<tt>notify</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #notify
--   </pre>
clearClosureNotifyDataNotify :: MonadIO m => ClosureNotifyData -> m ()

-- | Get the value of the “<tt>notify</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> closureNotifyData #notify
--   </pre>
getClosureNotifyDataNotify :: MonadIO m => ClosureNotifyData -> m (Maybe ClosureNotify)

-- | Set the value of the “<tt>notify</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> closureNotifyData [ #notify <a>:=</a> value ]
--   </pre>
setClosureNotifyDataNotify :: MonadIO m => ClosureNotifyData -> FunPtr C_ClosureNotify -> m ()
instance GHC.Classes.Eq GI.GObject.Structs.ClosureNotifyData.ClosureNotifyData
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Structs.ClosureNotifyData.ClosureNotifyData
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Structs.ClosureNotifyData.ClosureNotifyData
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Structs.ClosureNotifyData.ClosureNotifyData
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.ClosureNotifyData.ClosureNotifyData tag


module GI.GObject.Structs


-- | <tt>GTypeModule</tt> provides a simple implementation of the
--   <tt>GTypePlugin</tt> interface.
--   
--   The model of <tt>GTypeModule</tt> 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
--   <a>typeModuleRegisterType</a> and <a>typeModuleAddInterface</a>. 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 reference
--   cannot be released from within the module code, since that would lead
--   to the caller's code being unloaded before <tt>g_object_unref()</tt>
--   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
--   <a>typeModuleUse</a> and <a>typeModuleUnuse</a>. Typically, when
--   loading a module for the first type, <tt>g_type_module_use()</tt> 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, <tt>g_type_module_unuse()</tt> is
--   called.
--   
--   <tt>GTypeModule</tt> does not actually provide any implementation of
--   module loading and unloading. To create a particular module type you
--   must derive from <tt>GTypeModule</tt> and implement the load and
--   unload functions in <tt>GTypeModuleClass</tt>.
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 <a>TypeModule</a>,
--   for instance with <a>toTypeModule</a>.
class (GObject o, IsDescendantOf TypeModule o) => IsTypeModule o

-- | Cast to <a>TypeModule</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTypeModule :: (MonadIO m, IsTypeModule o) => o -> m 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 <i><tt>module</tt></i> is <a>Nothing</a> this will call
--   <a>typeAddInterfaceStatic</a> instead. This can be used when making a
--   static build of the module.
typeModuleAddInterface :: (HasCallStack, MonadIO m, IsTypeModule a) => Maybe a -> GType -> GType -> InterfaceInfo -> m ()

-- | Looks up or registers an enumeration that is implemented with a
--   particular type plugin. If a type with name <i><tt>typeName</tt></i>
--   was previously registered, the <a>GType</a> identifier for the type is
--   returned, otherwise the type is newly registered, and the resulting
--   <a>GType</a> identifier returned.
--   
--   As long as any instances of the type exist, the type plugin will not
--   be unloaded.
--   
--   Since 2.56 if <i><tt>module</tt></i> is <a>Nothing</a> this will call
--   <a>typeRegisterStatic</a> instead. This can be used when making a
--   static build of the module.
--   
--   <i>Since: 2.6</i>
typeModuleRegisterEnum :: (HasCallStack, MonadIO m, IsTypeModule a) => Maybe 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 <i><tt>typeName</tt></i>
--   was previously registered, the <a>GType</a> identifier for the type is
--   returned, otherwise the type is newly registered, and the resulting
--   <a>GType</a> identifier returned.
--   
--   As long as any instances of the type exist, the type plugin will not
--   be unloaded.
--   
--   Since 2.56 if <i><tt>module</tt></i> is <a>Nothing</a> this will call
--   <a>typeRegisterStatic</a> instead. This can be used when making a
--   static build of the module.
--   
--   <i>Since: 2.6</i>
typeModuleRegisterFlags :: (HasCallStack, MonadIO m, IsTypeModule a) => Maybe a -> Text -> FlagsValue -> m GType

-- | Looks up or registers a type that is implemented with a particular
--   type plugin. If a type with name <i><tt>typeName</tt></i> was
--   previously registered, the <a>GType</a> identifier for the type is
--   returned, otherwise the type is newly registered, and the resulting
--   <a>GType</a> identifier returned.
--   
--   When reregistering a type (typically because a module is unloaded then
--   reloaded, and reinitialized), <i><tt>module</tt></i> and
--   <i><tt>parentType</tt></i> 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 <i><tt>module</tt></i> is <a>Nothing</a> this will call
--   <a>typeRegisterStatic</a> instead. This can be used when making a
--   static build of the module.
typeModuleRegisterType :: (HasCallStack, MonadIO m, IsTypeModule a) => Maybe a -> GType -> Text -> TypeInfo -> [TypeFlags] -> m GType

-- | Sets the name for a <a>TypeModule</a>
typeModuleSetName :: (HasCallStack, MonadIO m, IsTypeModule a) => a -> Text -> m ()

-- | Decreases the use count of a <a>TypeModule</a> by one. If the result
--   is zero, the module will be unloaded. (However, the <a>TypeModule</a>
--   will not be freed, and types associated with the <a>TypeModule</a> are
--   not unregistered. Once a <a>TypeModule</a> is initialized, it must
--   exist forever.)
typeModuleUnuse :: (HasCallStack, MonadIO m, IsTypeModule a) => a -> m ()

-- | Increases the use count of a <a>TypeModule</a> 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 GHC.Classes.Eq GI.GObject.Objects.TypeModule.TypeModule
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.ManagedPtrNewtype GI.GObject.Objects.TypeModule.TypeModule
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.TypeModule.TypeModule
instance Data.GI.Base.BasicTypes.GObject GI.GObject.Objects.TypeModule.TypeModule
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.TypeModule.TypeModule
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.GObject.Objects.TypeModule.TypeModule)


-- | <tt>GSignalGroup</tt> manages a collection of signals on a
--   <tt>GObject</tt>.
--   
--   <tt>GSignalGroup</tt> simplifies the process of connecting many
--   signals to a <tt>GObject</tt> as a group. As such there is no API to
--   disconnect a signal from the group.
--   
--   In particular, this allows you to:
--   
--   <ul>
--   <li>Change the target instance, which automatically causes
--   disconnection of the signals from the old instance and connecting to
--   the new instance.</li>
--   <li>Block and unblock signals as a group</li>
--   <li>Ensuring that blocked state transfers across target
--   instances.</li>
--   </ul>
--   
--   One place you might want to use such a structure is with
--   <tt>GtkTextView</tt> and <tt>GtkTextBuffer</tt>. Often times, you'll
--   need to connect to many signals on <tt>GtkTextBuffer</tt> from a
--   <tt>GtkTextView</tt> subclass. This allows you to create a signal
--   group during instance construction, simply bind the
--   <tt>GtkTextView:buffer</tt> property to <tt>GSignalGroup:target</tt>
--   and connect all the signals you need. When the
--   <tt>GtkTextView:buffer</tt> property changes all of the signals will
--   be transitioned correctly.
--   
--   <i>Since: 2.72</i>
module GI.GObject.Objects.SignalGroup

-- | Memory-managed wrapper type.
newtype SignalGroup
SignalGroup :: ManagedPtr SignalGroup -> SignalGroup

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

-- | Cast to <a>SignalGroup</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toSignalGroup :: (MonadIO m, IsSignalGroup o) => o -> m SignalGroup

-- | Blocks all signal handlers managed by <i><tt>self</tt></i> so they
--   will not be called during any signal emissions. Must be unblocked
--   exactly the same number of times it has been blocked to become active
--   again.
--   
--   This blocked state will be kept across changes of the target instance.
--   
--   <i>Since: 2.72</i>
signalGroupBlock :: (HasCallStack, MonadIO m, IsSignalGroup a) => a -> m ()

-- | Connects <i><tt>closure</tt></i> to the signal
--   <i><tt>detailedSignal</tt></i> on <a>SignalGroup:target</a>.
--   
--   You cannot connect a signal handler after <a>SignalGroup:target</a>
--   has been set.
--   
--   <i>Since: 2.74</i>
signalGroupConnectClosure :: (HasCallStack, MonadIO m, IsSignalGroup a) => a -> Text -> GClosure b -> Bool -> m ()

-- | Connects <i><tt>cHandler</tt></i> to the signal
--   <i><tt>detailedSignal</tt></i> on the target instance of
--   <i><tt>self</tt></i>.
--   
--   You cannot connect a signal handler after <a>SignalGroup:target</a>
--   has been set.
--   
--   <i>Since: 2.72</i>
signalGroupConnectData :: (HasCallStack, MonadIO m, IsSignalGroup a) => a -> Text -> Callback -> [ConnectFlags] -> m ()

-- | Connects <i><tt>cHandler</tt></i> to the signal
--   <i><tt>detailedSignal</tt></i> on the target instance of
--   <i><tt>self</tt></i>.
--   
--   The instance on which the signal is emitted and <i><tt>data</tt></i>
--   will be swapped when calling <i><tt>cHandler</tt></i>.
--   
--   You cannot connect a signal handler after <a>SignalGroup:target</a>
--   has been set.
--   
--   <i>Since: 2.72</i>
signalGroupConnectSwapped :: (HasCallStack, MonadIO m, IsSignalGroup a) => a -> Text -> Callback -> m ()

-- | Gets the target instance used when connecting signals.
--   
--   <i>Since: 2.72</i>
signalGroupDupTarget :: (HasCallStack, MonadIO m, IsSignalGroup a) => a -> m (Maybe Object)

-- | Creates a new <a>SignalGroup</a> for target instances of
--   <i><tt>targetType</tt></i>.
--   
--   <i>Since: 2.72</i>
signalGroupNew :: (HasCallStack, MonadIO m) => GType -> m SignalGroup

-- | Sets the target instance used when connecting signals. Any signal that
--   has been registered with
--   <tt><i>g_signal_group_connect_object()</i></tt> or similar functions
--   will be connected to this object.
--   
--   If the target instance was previously set, signals will be
--   disconnected from that object prior to connecting to
--   <i><tt>target</tt></i>.
--   
--   <i>Since: 2.72</i>
signalGroupSetTarget :: (HasCallStack, MonadIO m, IsSignalGroup a, IsObject b) => a -> Maybe b -> m ()

-- | Unblocks all signal handlers managed by <i><tt>self</tt></i> so they
--   will be called again during any signal emissions unless it is blocked
--   again. Must be unblocked exactly the same number of times it has been
--   blocked to become active again.
--   
--   <i>Since: 2.72</i>
signalGroupUnblock :: (HasCallStack, MonadIO m, IsSignalGroup a) => a -> m ()

-- | Set the value of the “<tt>target</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #target
--   </pre>
clearSignalGroupTarget :: (MonadIO m, IsSignalGroup o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>target</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSignalGroupTarget :: (IsSignalGroup o, MonadIO m, IsObject a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>target</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> signalGroup #target
--   </pre>
getSignalGroupTarget :: (MonadIO m, IsSignalGroup o) => o -> m (Maybe Object)

-- | Set the value of the “<tt>target</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> signalGroup [ #target <a>:=</a> value ]
--   </pre>
setSignalGroupTarget :: (MonadIO m, IsSignalGroup o, IsObject a) => o -> a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>target-type</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructSignalGroupTargetType :: (IsSignalGroup o, MonadIO m) => GType -> m (GValueConstruct o)

-- | Get the value of the “<tt>target-type</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> signalGroup #targetType
--   </pre>
getSignalGroupTargetType :: (MonadIO m, IsSignalGroup o) => o -> m GType

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

-- | Connect a signal handler for the <a>bind</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> signalGroup #bind callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSignalGroupBind :: (IsSignalGroup a, MonadIO m) => a -> ((?self :: a) => SignalGroupBindCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>bind</a> signal, to be run before
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>on</a> signalGroup #bind callback
--   </pre>
onSignalGroupBind :: (IsSignalGroup a, MonadIO m) => a -> ((?self :: a) => SignalGroupBindCallback) -> m SignalHandlerId

-- | This signal is emitted when the target instance of
--   <i><tt>self</tt></i> is set to a new <a>Object</a>.
--   
--   This signal will only be emitted if the previous target of
--   <i><tt>self</tt></i> is non-<a>Nothing</a>.
--   
--   <i>Since: 2.72</i>
type SignalGroupUnbindCallback = IO ()

-- | Connect a signal handler for the <a>unbind</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> signalGroup #unbind callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSignalGroupUnbind :: (IsSignalGroup a, MonadIO m) => a -> ((?self :: a) => SignalGroupUnbindCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>unbind</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> signalGroup #unbind callback
--   </pre>
onSignalGroupUnbind :: (IsSignalGroup a, MonadIO m) => a -> ((?self :: a) => SignalGroupUnbindCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.GObject.Objects.SignalGroup.SignalGroup
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.SignalGroup.SignalGroup o) => GI.GObject.Objects.SignalGroup.IsSignalGroup o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.SignalGroup.SignalGroup
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.SignalGroup.SignalGroup
instance Data.GI.Base.BasicTypes.GObject GI.GObject.Objects.SignalGroup.SignalGroup
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.SignalGroup.SignalGroup
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.GObject.Objects.SignalGroup.SignalGroup)


-- | The base object type.
--   
--   <tt>GObject</tt> is the fundamental type providing the common
--   attributes and methods for all object types in GTK, Pango and other
--   libraries based on GObject. The <tt>GObject</tt> class provides
--   methods for object construction and destruction, property access
--   methods, and signal support. Signals are described in detail
--   [here][gobject-Signals].
--   
--   For a tutorial on implementing a new <tt>GObject</tt> class, see
--   &lt;<a>http://developer.gnome.org/gobject/stable/tutorial.html#how-to-define-and-implement-a-new-gobject</a>
--   How to define and implement a new GObject&gt;. For a list of naming
--   conventions for GObjects and their methods, see the <a>GType
--   conventions</a>. For the high-level concepts behind GObject, read
--   <a>Instantiatable classed types: Objects</a>.
--   
--   Since GLib 2.72, all <tt>GObject</tt>s are guaranteed to be aligned to
--   at least the alignment of the largest basic GLib type (typically this
--   is <tt>guint64</tt> or <tt>gdouble</tt>). If you need larger alignment
--   for an element in a <tt>GObject</tt>, you should allocate it on the
--   heap (aligned), or arrange for your <tt>GObject</tt> to be
--   appropriately padded. This guarantee applies to the <tt>GObject</tt>
--   (or derived) struct, the <tt>GObjectClass</tt> (or derived) struct,
--   and any private data allocated by <tt>G_ADD_PRIVATE()</tt>.
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 <a>Object</a>, for
--   instance with <a>toObject</a>.
class (GObject o, IsDescendantOf Object o) => IsObject o

-- | Cast to <a>Object</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toObject :: (MonadIO m, IsObject o) => o -> m Object

-- | Creates a binding between <i><tt>sourceProperty</tt></i> on
--   <i><tt>source</tt></i> and <i><tt>targetProperty</tt></i> on
--   <i><tt>target</tt></i>.
--   
--   Whenever the <i><tt>sourceProperty</tt></i> is changed the
--   <i><tt>targetProperty</tt></i> is updated using the same value. For
--   instance:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   g_object_bind_property (action, "active", widget, "sensitive", 0);
--   </pre>
--   
--   Will result in the "sensitive" property of the widget <a>Object</a>
--   instance to be updated with the same value of the "active" property of
--   the action <a>Object</a> instance.
--   
--   If <i><tt>flags</tt></i> contains <a>BindingFlagsBidirectional</a>
--   then the binding will be mutual: if <i><tt>targetProperty</tt></i> on
--   <i><tt>target</tt></i> changes then the <i><tt>sourceProperty</tt></i>
--   on <i><tt>source</tt></i> will be updated as well.
--   
--   The binding will automatically be removed when either the
--   <i><tt>source</tt></i> or the <i><tt>target</tt></i> instances are
--   finalized. To remove the binding without affecting the
--   <i><tt>source</tt></i> and the <i><tt>target</tt></i> you can just
--   call <a>objectUnref</a> on the returned <a>Binding</a> instance.
--   
--   Removing the binding by calling <a>objectUnref</a> on it must only be
--   done if the binding, <i><tt>source</tt></i> and <i><tt>target</tt></i>
--   are only used from a single thread and it is clear that both
--   <i><tt>source</tt></i> and <i><tt>target</tt></i> outlive the binding.
--   Especially it is not safe to rely on this if the binding,
--   <i><tt>source</tt></i> or <i><tt>target</tt></i> can be finalized from
--   different threads. Keep another reference to the binding and use
--   <a>bindingUnbind</a> instead to be on the safe side.
--   
--   A <a>Object</a> can have multiple bindings.
--   
--   <i>Since: 2.26</i>
objectBindProperty :: (HasCallStack, MonadIO m, IsObject a, IsObject b) => a -> Text -> b -> Text -> [BindingFlags] -> m Binding

-- | Creates a binding between <i><tt>sourceProperty</tt></i> on
--   <i><tt>source</tt></i> and <i><tt>targetProperty</tt></i> on
--   <i><tt>target</tt></i>, allowing you to set the transformation
--   functions to be used by the binding.
--   
--   This function is the language bindings friendly version of
--   <tt><i>g_object_bind_property_full()</i></tt>, using
--   <tt><i>GClosures</i></tt> instead of function pointers.
--   
--   <i>Since: 2.26</i>
objectBindPropertyFull :: (HasCallStack, MonadIO m, IsObject a, IsObject b) => a -> Text -> b -> Text -> [BindingFlags] -> GClosure c -> GClosure d -> m Binding

-- | <i>No description available in the introspection data.</i>
objectCompatControl :: (HasCallStack, MonadIO m) => CSize -> Ptr () -> m CSize

-- | This function is intended for <a>Object</a> implementations to
--   re-enforce a [floating][floating-ref] object reference. Doing this is
--   seldom required: all <tt><i>GInitiallyUnowneds</i></tt> are created
--   with a floating reference which usually just needs to be sunken by
--   calling <a>objectRefSink</a>.
--   
--   <i>Since: 2.10</i>
objectForceFloating :: (HasCallStack, MonadIO m, IsObject a) => a -> m ()

-- | Increases the freeze count on <i><tt>object</tt></i>. If the freeze
--   count is non-zero, the emission of "notify" signals on
--   <i><tt>object</tt></i> is stopped. The signals are queued until the
--   freeze count is decreased to zero. Duplicate notifications are
--   squashed so that at most one <a>Object::notify</a> 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
--   <a>objectSetData</a>).
objectGetData :: (HasCallStack, MonadIO m, IsObject a) => a -> Text -> m (Ptr ())

-- | Gets a property of an object.
--   
--   The <i><tt>value</tt></i> can be:
--   
--   <ul>
--   <li>an empty <a>Value</a> initialized by <tt><i>G_VALUE_INIT</i></tt>,
--   which will be automatically initialized with the expected type of the
--   property (since GLib 2.60)</li>
--   <li>a <a>Value</a> initialized with the expected type of the
--   property</li>
--   <li>a <a>Value</a> initialized with a type to which the expected type
--   of the property can be transformed</li>
--   </ul>
--   
--   In general, a copy is made of the property contents and the caller is
--   responsible for freeing the memory by calling <a>valueUnset</a>.
--   
--   Note that <a>objectGetProperty</a> is really intended for language
--   bindings, <tt><i>g_object_get()</i></tt> 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
--   <tt><i>g_object_set_qdata()</i></tt>.
objectGetQdata :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> m (Ptr ())

-- | Gets <i><tt>nProperties</tt></i> properties for an
--   <i><tt>object</tt></i>. Obtained properties will be set to
--   <i><tt>values</tt></i>. All properties must be valid. Warnings will be
--   emitted and undefined behaviour may result if invalid properties are
--   passed in.
--   
--   <i>Since: 2.54</i>
objectGetv :: (HasCallStack, MonadIO m, IsObject a) => a -> [Text] -> [GValue] -> m ()

-- | Find the <a>ParamSpec</a> with the given name for an interface.
--   Generally, the interface vtable passed in as <i><tt>gIface</tt></i>
--   will be the default vtable from <a>typeDefaultInterfaceRef</a>, or, if
--   you know the interface has already been loaded,
--   <a>typeDefaultInterfacePeek</a>.
--   
--   <i>Since: 2.4</i>
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
--   <a>ParamSpec</a>, but normally <a>objectClassOverrideProperty</a> 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 <i><tt>classInit</tt></i> member
--   of <a>TypeInfo</a>.) It must not be called after after
--   <i><tt>classInit</tt></i> has been called for any object types
--   implementing this interface.
--   
--   If <i><tt>pspec</tt></i> is a floating reference, it will be consumed.
--   
--   <i>Since: 2.4</i>
objectInterfaceInstallProperty :: (HasCallStack, MonadIO m) => TypeInterface -> GParamSpec -> m ()

-- | Checks whether <i><tt>object</tt></i> has a [floating][floating-ref]
--   reference.
--   
--   <i>Since: 2.10</i>
objectIsFloating :: (HasCallStack, MonadIO m, IsObject a) => a -> m Bool

-- | Creates a new instance of a <a>Object</a> subtype and sets its
--   properties.
--   
--   Construction parameters (see <a>ParamFlagsConstruct</a>,
--   <a>ParamFlagsConstructOnly</a>) which are not explicitly specified are
--   set to their default values.

-- | <i>Deprecated: (Since version 2.54)Use
--   <tt><i>g_object_new_with_properties()</i></tt> instead.deprecated. See
--   <a>Parameter</a> for more information.</i>
objectNewv :: (HasCallStack, MonadIO m) => GType -> [Parameter] -> m Object

-- | Emits a "notify" signal for the property <i><tt>propertyName</tt></i>
--   on <i><tt>object</tt></i>.
--   
--   When possible, eg. when signaling a property change from within the
--   class that registered the property, you should use
--   <a>objectNotifyByPspec</a> instead.
--   
--   Note that emission of the notify signal may be blocked with
--   <a>objectFreezeNotify</a>. In this case, the signal emissions are
--   queued and will be emitted (in reverse order) when
--   <a>objectThawNotify</a> is called.
objectNotify :: (HasCallStack, MonadIO m, IsObject a) => a -> Text -> m ()

-- | Emits a "notify" signal for the property specified by
--   <i><tt>pspec</tt></i> on <i><tt>object</tt></i>.
--   
--   This function omits the property name lookup, hence it is faster than
--   <a>objectNotify</a>.
--   
--   One way to avoid using <a>objectNotify</a> from within the class that
--   registered the properties, and using <a>objectNotifyByPspec</a>
--   instead, is to store the GParamSpec used with
--   <a>objectClassInstallProperty</a> inside a static array, e.g.:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   typedef enum
--   {
--     PROP_FOO = 1,
--     PROP_LAST
--   } MyObjectProperty;
--   
--   static GParamSpec *properties[PROP_LAST];
--   
--   static void
--   my_object_class_init (MyObjectClass *klass)
--   {
--     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
--                                              0, 100,
--                                              50,
--                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
--     g_object_class_install_property (gobject_class,
--                                      PROP_FOO,
--                                      properties[PROP_FOO]);
--   }
--   </pre>
--   
--   and then notify a change on the "foo" property with:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   g_object_notify_by_pspec (self, properties[PROP_FOO]);
--   </pre>
--   
--   <i>Since: 2.26</i>
objectNotifyByPspec :: (HasCallStack, MonadIO m, IsObject a) => a -> GParamSpec -> m ()

-- | Increases the reference count of <i><tt>object</tt></i>.
--   
--   Since GLib 2.56, if <tt>GLIB_VERSION_MAX_ALLOWED</tt> is 2.56 or
--   greater, the type of <i><tt>object</tt></i> will be propagated to the
--   return type (using the GCC <tt><i>typeof()</i></tt> 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 <i><tt>object</tt></i>, and possibly
--   remove the [floating][floating-ref] reference, if
--   <i><tt>object</tt></i> 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 <i><tt>object</tt></i> will be propagated
--   to the return type under the same conditions as for <a>objectRef</a>.
--   
--   <i>Since: 2.10</i>
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.
--   
--   Internally, the <i><tt>key</tt></i> is converted to a
--   <tt><i>GQuark</i></tt> using <a>quarkFromString</a>. This means a copy
--   of <i><tt>key</tt></i> is kept permanently (even after
--   <i><tt>object</tt></i> has been finalized) — so it is recommended to
--   only use a small, bounded set of values for <i><tt>key</tt></i> in
--   your program, to avoid the <tt><i>GQuark</i></tt> storage growing
--   unbounded.
objectSetData :: (HasCallStack, MonadIO m, IsObject a) => a -> Text -> Ptr () -> m ()

-- | Like <a>objectSetData</a> 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 <i><tt>destroy</tt></i> callback is not called if
--   <i><tt>data</tt></i> is <a>Nothing</a>.
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
--   <tt><i>g_object_set_qdata()</i></tt> and removes the
--   <i><tt>data</tt></i> from object without invoking its
--   <tt><i>destroy()</i></tt> function (if any was set). Usually, calling
--   this function is only required to update user data pointers with a
--   destroy notifier, for example:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   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");
--     // retrieve 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-&gt;next)
--       g_free (node-&gt;data);
--     g_list_free (list);
--   }
--   </pre>
--   
--   Using <a>objectGetQdata</a> in the above example, instead of
--   <a>objectStealQdata</a> would have left the destroy function set, and
--   thus the partial string list would have been freed upon
--   <tt><i>g_object_set_qdata_full()</i></tt>.
objectStealQdata :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> m (Ptr ())

-- | Reverts the effect of a previous call to <a>objectFreezeNotify</a>.
--   The freeze count is decreased on <i><tt>object</tt></i> and when it
--   reaches zero, queued "notify" signals are emitted.
--   
--   Duplicate notifications for each property are squashed so that at most
--   one <a>Object::notify</a> 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 <i><tt>object</tt></i>. When its
--   reference count drops to 0, the object is finalized (i.e. its memory
--   is freed).
--   
--   If the pointer to the <a>Object</a> may be reused in future (for
--   example, if it is an instance variable of another object), it is
--   recommended to clear the pointer to <a>Nothing</a> rather than retain
--   a dangling pointer to a potentially invalid <a>Object</a> instance.
--   Use <tt><i>g_clear_object()</i></tt> for this.
objectUnref :: (HasCallStack, MonadIO m, IsObject a) => a -> m ()

-- | This function essentially limits the life time of the
--   <i><tt>closure</tt></i> to the life time of the object. That is, when
--   the object is finalized, the <i><tt>closure</tt></i> is invalidated by
--   calling <a>closureInvalidate</a> on it, in order to prevent
--   invocations of the closure with a finalized (nonexisting) object.
--   Also, <a>objectRef</a> and <a>objectUnref</a> are added as marshal
--   guards to the <i><tt>closure</tt></i>, to ensure that an extra
--   reference count is held on <i><tt>object</tt></i> during invocation of
--   the <i><tt>closure</tt></i>. Usually, this function will be called on
--   closures that use this <i><tt>object</tt></i> as closure data.
objectWatchClosure :: (HasCallStack, MonadIO m, IsObject a) => a -> GClosure b -> m ()

-- | The notify signal is emitted on an object when one of its properties
--   has its value set through <a>objectSetProperty</a>,
--   <tt><i>g_object_set()</i></tt>, 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 <a>ParamFlagsExplicitNotify</a>, then any call to
--   <a>objectSetProperty</a> results in <a>notify</a> being emitted, even
--   if the new value is the same as the old. If they did pass
--   <a>ParamFlagsExplicitNotify</a>, then this signal is emitted only when
--   they explicitly call <a>objectNotify</a> or
--   <a>objectNotifyByPspec</a>, 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
--   <tt><i>g_signal_connect()</i></tt> call, like this:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   g_signal_connect (text_view-&gt;buffer, "notify::paste-target-list",
--                     G_CALLBACK (gtk_text_view_target_list_notify),
--                     text_view)
--   </pre>
--   
--   It is important to note that you must use [canonical parameter
--   names][canonical-parameter-names] as detail strings for the notify
--   signal.
type ObjectNotifyCallback = -- | /@pspec@/: the t'GI.GObject.Objects.ParamSpec.ParamSpec' of the property which changed. GParamSpec -> IO ()

-- | Connect a signal handler for the <a>notify</a> signal, to be run after
--   the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> object #notify callback
--   </pre>
--   
--   This signal admits a optional parameter <tt>detail</tt>. If it's not
--   <tt>Nothing</tt>, we will connect to “<tt>notify::detail</tt>”
--   instead.
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterObjectNotify :: (IsObject a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => ObjectNotifyCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>notify</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> object #notify callback
--   </pre>
--   
--   This signal admits a optional parameter <tt>detail</tt>. If it's not
--   <tt>Nothing</tt>, we will connect to “<tt>notify::detail</tt>”
--   instead.
onObjectNotify :: (IsObject a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => ObjectNotifyCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.GObject.Objects.Object.Object
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.ManagedPtrNewtype GI.GObject.Objects.Object.Object
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.Object.Object
instance Data.GI.Base.BasicTypes.GObject GI.GObject.Objects.Object.Object
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.Object.Object
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.GObject.Objects.Object.Object)


-- | A type for objects that have an initially floating reference.
--   
--   All the fields in the <tt>GInitiallyUnowned</tt> structure are private
--   to the 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
--   <a>InitiallyUnowned</a>, for instance with <a>toInitiallyUnowned</a>.
class (GObject o, IsDescendantOf InitiallyUnowned o) => IsInitiallyUnowned o

-- | Cast to <a>InitiallyUnowned</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toInitiallyUnowned :: (MonadIO m, IsInitiallyUnowned o) => o -> m InitiallyUnowned
instance GHC.Classes.Eq GI.GObject.Objects.InitiallyUnowned.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.ManagedPtrNewtype GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned
instance Data.GI.Base.BasicTypes.GObject GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned)


-- | <tt>GBindingGroup</tt> can be used to bind multiple properties from an
--   object collectively.
--   
--   Use the various methods to bind properties from a single source object
--   to multiple destination objects. Properties can be bound
--   bidirectionally and are connected when the source object is set with
--   <a>bindingGroupSetSource</a>.
--   
--   <i>Since: 2.72</i>
module GI.GObject.Objects.BindingGroup

-- | Memory-managed wrapper type.
newtype BindingGroup
BindingGroup :: ManagedPtr BindingGroup -> BindingGroup

-- | Type class for types which can be safely cast to <a>BindingGroup</a>,
--   for instance with <a>toBindingGroup</a>.
class (GObject o, IsDescendantOf BindingGroup o) => IsBindingGroup o

-- | Cast to <a>BindingGroup</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toBindingGroup :: (MonadIO m, IsBindingGroup o) => o -> m BindingGroup

-- | Creates a binding between <i><tt>sourceProperty</tt></i> on the source
--   object and <i><tt>targetProperty</tt></i> on <i><tt>target</tt></i>.
--   Whenever the <i><tt>sourceProperty</tt></i> is changed the
--   <i><tt>targetProperty</tt></i> is updated using the same value. The
--   binding flag <a>BindingFlagsSyncCreate</a> is automatically specified.
--   
--   See <a>objectBindProperty</a> for more information.
--   
--   <i>Since: 2.72</i>
bindingGroupBind :: (HasCallStack, MonadIO m, IsBindingGroup a, IsObject b) => a -> Text -> b -> Text -> [BindingFlags] -> m ()

-- | Creates a binding between <i><tt>sourceProperty</tt></i> on the source
--   object and <i><tt>targetProperty</tt></i> on <i><tt>target</tt></i>,
--   allowing you to set the transformation functions to be used by the
--   binding. The binding flag <a>BindingFlagsSyncCreate</a> is
--   automatically specified.
--   
--   This function is the language bindings friendly version of
--   <tt><i>g_binding_group_bind_property_full()</i></tt>, using
--   <tt><i>GClosures</i></tt> instead of function pointers.
--   
--   See <a>objectBindPropertyFull</a> for more information.
--   
--   <i>Since: 2.72</i>
bindingGroupBindFull :: (HasCallStack, MonadIO m, IsBindingGroup a, IsObject b) => a -> Text -> b -> Text -> [BindingFlags] -> Maybe (GClosure c) -> Maybe (GClosure d) -> m ()

-- | Gets the source object used for binding properties.
--   
--   <i>Since: 2.72</i>
bindingGroupDupSource :: (HasCallStack, MonadIO m, IsBindingGroup a) => a -> m (Maybe Object)

-- | Creates a new <a>BindingGroup</a>.
--   
--   <i>Since: 2.72</i>
bindingGroupNew :: (HasCallStack, MonadIO m) => m BindingGroup

-- | Sets <i><tt>source</tt></i> as the source object used for creating
--   property bindings. If there is already a source object all bindings
--   from it will be removed.
--   
--   Note that all properties that have been bound must exist on
--   <i><tt>source</tt></i>.
--   
--   <i>Since: 2.72</i>
bindingGroupSetSource :: (HasCallStack, MonadIO m, IsBindingGroup a, IsObject b) => a -> Maybe b -> m ()

-- | Set the value of the “<tt>source</tt>” property to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #source
--   </pre>
clearBindingGroupSource :: (MonadIO m, IsBindingGroup o) => o -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>source</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructBindingGroupSource :: (IsBindingGroup o, MonadIO m, IsObject a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>source</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> bindingGroup #source
--   </pre>
getBindingGroupSource :: (MonadIO m, IsBindingGroup o) => o -> m (Maybe Object)

-- | Set the value of the “<tt>source</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> bindingGroup [ #source <a>:=</a> value ]
--   </pre>
setBindingGroupSource :: (MonadIO m, IsBindingGroup o, IsObject a) => o -> a -> m ()
instance GHC.Classes.Eq GI.GObject.Objects.BindingGroup.BindingGroup
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.GObject.Objects.BindingGroup.BindingGroup o) => GI.GObject.Objects.BindingGroup.IsBindingGroup o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Objects.BindingGroup.BindingGroup
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.BindingGroup.BindingGroup
instance Data.GI.Base.BasicTypes.GObject GI.GObject.Objects.BindingGroup.BindingGroup
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.BindingGroup.BindingGroup
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.GObject.Objects.BindingGroup.BindingGroup)


-- | <tt>GObject</tt> instance (or source) and another property on another
--   <tt>GObject</tt> instance (or target).
--   
--   Whenever the source property changes, the same value is applied to the
--   target property; for instance, the following binding:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   g_object_bind_property (object1, "property-a",
--                           object2, "property-b",
--                           G_BINDING_DEFAULT);
--   </pre>
--   
--   will cause the property named "property-b" of <i><tt>object2</tt></i>
--   to be updated every time [method<i><tt>gObject</tt></i>.set] or the
--   specific accessor changes the value of the property "property-a" of
--   <i><tt>object1</tt></i>.
--   
--   It is possible to create a bidirectional binding between two
--   properties of two <tt>GObject</tt> instances, so that if either
--   property changes, the other is updated as well, for instance:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   g_object_bind_property (object1, "property-a",
--                           object2, "property-b",
--                           G_BINDING_BIDIRECTIONAL);
--   </pre>
--   
--   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:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   g_object_bind_property_full (adjustment1, "value",
--                                adjustment2, "value",
--                                G_BINDING_BIDIRECTIONAL,
--                                celsius_to_fahrenheit,
--                                fahrenheit_to_celsius,
--                                NULL, NULL);
--   </pre>
--   
--   will keep the "value" property of the two adjustments in sync; the
--   <i><tt>celsiusToFahrenheit</tt></i> function will be called whenever
--   the "value" property of <i><tt>adjustment1</tt></i> changes and will
--   transform the current value of the property before applying it to the
--   "value" property of <i><tt>adjustment2</tt></i>.
--   
--   Vice versa, the <i><tt>fahrenheitToCelsius</tt></i> function will be
--   called whenever the "value" property of <i><tt>adjustment2</tt></i>
--   changes, and will transform the current value of the property before
--   applying it to the "value" property of <i><tt>adjustment1</tt></i>.
--   
--   Note that <a>Binding</a> does not resolve cycles by itself; a cycle
--   like
--   
--   <pre>
--   object1:propertyA -&gt; object2:propertyB
--   object2:propertyB -&gt; object3:propertyC
--   object3:propertyC -&gt; object1:propertyA
--   </pre>
--   
--   might lead to an infinite loop. The loop, in this particular case, can
--   be avoided if the objects emit the <tt>GObject::notify</tt> signal
--   only if the value has effectively been changed. A binding is
--   implemented using the <tt>GObject::notify</tt> signal, so it is
--   susceptible to all the various ways of blocking a signal emission,
--   like <a>signalStopEmission</a> or <a>signalHandlerBlock</a>.
--   
--   A binding will be severed, and the resources it allocates freed,
--   whenever either one of the <tt>GObject</tt> instances it refers to are
--   finalized, or when the <a>Binding</a> instance loses its last
--   reference.
--   
--   Bindings for languages with garbage collection can use
--   <a>bindingUnbind</a> 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.
--   
--   <i>Since: 2.26</i>
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 <a>Binding</a>, for
--   instance with <a>toBinding</a>.
class (GObject o, IsDescendantOf Binding o) => IsBinding o

-- | Cast to <a>Binding</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toBinding :: (MonadIO m, IsBinding o) => o -> m Binding

-- | Retrieves the <a>Object</a> instance used as the source of the
--   binding.
--   
--   A <a>Binding</a> can outlive the source <a>Object</a> as the binding
--   does not hold a strong reference to the source. If the source is
--   destroyed before the binding then this function will return
--   <a>Nothing</a>.
--   
--   <i>Since: 2.68</i>
bindingDupSource :: (HasCallStack, MonadIO m, IsBinding a) => a -> m (Maybe Object)

-- | Retrieves the <a>Object</a> instance used as the target of the
--   binding.
--   
--   A <a>Binding</a> can outlive the target <a>Object</a> as the binding
--   does not hold a strong reference to the target. If the target is
--   destroyed before the binding then this function will return
--   <a>Nothing</a>.
--   
--   <i>Since: 2.68</i>
bindingDupTarget :: (HasCallStack, MonadIO m, IsBinding a) => a -> m (Maybe Object)

-- | Retrieves the flags passed when constructing the <a>Binding</a>.
--   
--   <i>Since: 2.26</i>
bindingGetFlags :: (HasCallStack, MonadIO m, IsBinding a) => a -> m [BindingFlags]

-- | Retrieves the <a>Object</a> instance used as the source of the
--   binding.
--   
--   A <a>Binding</a> can outlive the source <a>Object</a> as the binding
--   does not hold a strong reference to the source. If the source is
--   destroyed before the binding then this function will return
--   <a>Nothing</a>.
--   
--   Use <a>bindingDupSource</a> if the source or binding are used from
--   different threads as otherwise the pointer returned from this function
--   might become invalid if the source is finalized from another thread in
--   the meantime.
--   
--   <i>Since: 2.26</i>

-- | <i>Deprecated: (Since version 2.68)Use <a>bindingDupSource</a> for a
--   safer version of thisfunction.</i>
bindingGetSource :: (HasCallStack, MonadIO m, IsBinding a) => a -> m (Maybe Object)

-- | Retrieves the name of the property of <a>Binding:source</a> used as
--   the source of the binding.
--   
--   <i>Since: 2.26</i>
bindingGetSourceProperty :: (HasCallStack, MonadIO m, IsBinding a) => a -> m Text

-- | Retrieves the <a>Object</a> instance used as the target of the
--   binding.
--   
--   A <a>Binding</a> can outlive the target <a>Object</a> as the binding
--   does not hold a strong reference to the target. If the target is
--   destroyed before the binding then this function will return
--   <a>Nothing</a>.
--   
--   Use <a>bindingDupTarget</a> if the target or binding are used from
--   different threads as otherwise the pointer returned from this function
--   might become invalid if the target is finalized from another thread in
--   the meantime.
--   
--   <i>Since: 2.26</i>

-- | <i>Deprecated: (Since version 2.68)Use <a>bindingDupTarget</a> for a
--   safer version of thisfunction.</i>
bindingGetTarget :: (HasCallStack, MonadIO m, IsBinding a) => a -> m (Maybe Object)

-- | Retrieves the name of the property of <a>Binding:target</a> used as
--   the target of the binding.
--   
--   <i>Since: 2.26</i>
bindingGetTargetProperty :: (HasCallStack, MonadIO m, IsBinding a) => a -> m Text

-- | Explicitly releases the binding between the source and the target
--   property expressed by <i><tt>binding</tt></i>.
--   
--   This function will release the reference that is being held on the
--   <i><tt>binding</tt></i> instance if the binding is still bound; if you
--   want to hold on to the <a>Binding</a> instance after calling
--   <a>bindingUnbind</a>, you will need to hold a reference to it.
--   
--   Note however that this function does not take ownership of
--   <i><tt>binding</tt></i>, it only unrefs the reference that was
--   initially created by <a>objectBindProperty</a> and is owned by the
--   binding.
--   
--   <i>Since: 2.38</i>
bindingUnbind :: (HasCallStack, MonadIO m, IsBinding a) => a -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>flags</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructBindingFlags :: (IsBinding o, MonadIO m) => [BindingFlags] -> m (GValueConstruct o)

-- | Get the value of the “<tt>flags</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> binding #flags
--   </pre>
getBindingFlags :: (MonadIO m, IsBinding o) => o -> m [BindingFlags]

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>source</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructBindingSource :: (IsBinding o, MonadIO m, IsObject a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>source</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> binding #source
--   </pre>
getBindingSource :: (MonadIO m, IsBinding o) => o -> m (Maybe Object)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>source-property</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructBindingSourceProperty :: (IsBinding o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>source-property</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> binding #sourceProperty
--   </pre>
getBindingSourceProperty :: (MonadIO m, IsBinding o) => o -> m Text

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>target</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructBindingTarget :: (IsBinding o, MonadIO m, IsObject a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>target</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> binding #target
--   </pre>
getBindingTarget :: (MonadIO m, IsBinding o) => o -> m (Maybe Object)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>target-property</tt>” property. This is rarely needed directly,
--   but it is used by <a>new</a>.
constructBindingTargetProperty :: (IsBinding o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>target-property</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> binding #targetProperty
--   </pre>
getBindingTargetProperty :: (MonadIO m, IsBinding o) => o -> m Text
instance GHC.Classes.Eq GI.GObject.Objects.Binding.Binding
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.ManagedPtrNewtype GI.GObject.Objects.Binding.Binding
instance Data.GI.Base.BasicTypes.TypedObject GI.GObject.Objects.Binding.Binding
instance Data.GI.Base.BasicTypes.GObject GI.GObject.Objects.Binding.Binding
instance Data.GI.Base.Overloading.HasParentTypes GI.GObject.Objects.Binding.Binding
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.GObject.Objects.Binding.Binding)


module GI.GObject.Objects


-- | An interface that handles the lifecycle of dynamically loaded types.
--   
--   The GObject type system supports dynamic loading of types. It goes as
--   follows:
--   
--   <ol>
--   <li>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: ``<tt>c new_type_id =
--   g_type_register_dynamic (parent_type_id, "TypeName", new_type_plugin,
--   type_flags); </tt>`<tt> where </tt>new_type_plugin<tt> is an
--   implementation of the </tt>GTypePlugin@ interface.</li>
--   <li>The type's implementation is referenced, e.g. through
--   [func@GObject.TypeClass.ref] or through
--   [func@GObject.type_create_instance] (this is being called by
--   [ctor@GObject.Object.new]) or through one of the above done on a type
--   derived from <tt>new_type_id</tt>.</li>
--   <li>This causes the type system to load the type's implementation by
--   calling [method@GObject.TypePlugin.use] and
--   [method@GObject.TypePlugin.complete_type_info] on
--   <tt>new_type_plugin</tt>.</li>
--   <li>At some point the type's implementation isn't required anymore,
--   e.g. after [method@GObject.TypeClass.unref] or
--   [func@GObject.type_free_instance] (called when the reference count of
--   an instance drops to zero).</li>
--   <li>This causes the type system to throw away the information
--   retrieved from [method@GObject.TypePlugin.complete_type_info] and then
--   it calls [method@GObject.TypePlugin.unuse] on
--   <tt>new_type_plugin</tt>.</li>
--   <li>Things may repeat from the second step.</li>
--   </ol>
--   
--   So basically, you need to implement a <tt>GTypePlugin</tt> 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
--   [method@GObject.TypePlugin.complete_type_info] 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 [method@GObject.TypePlugin.use] and
--   [method@GObject.TypePlugin.complete_type_info] again when the type is
--   needed again.
--   
--   <ul>
--   <li><i>class@GObject.TypeModule</i> is an implementation of
--   @GTypePlugin` that already implements most of this except for the
--   actual module loading and unloading. It even handles multiple
--   registered types per module.</li>
--   </ul>
module GI.GObject.Interfaces.TypePlugin

-- | Memory-managed wrapper type.
newtype TypePlugin
TypePlugin :: ManagedPtr TypePlugin -> TypePlugin

-- | Type class for types which implement <a>TypePlugin</a>.
class (ManagedPtrNewtype o, IsDescendantOf TypePlugin o) => IsTypePlugin o

-- | Calls the <i><tt>completeInterfaceInfo</tt></i> function from the
--   <tt><i>GTypePluginClass</i></tt> of <i><tt>plugin</tt></i>. 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 <i><tt>completeTypeInfo</tt></i> function from the
--   <tt><i>GTypePluginClass</i></tt> of <i><tt>plugin</tt></i>. 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 <i><tt>unusePlugin</tt></i> function from the
--   <tt><i>GTypePluginClass</i></tt> of <i><tt>plugin</tt></i>. 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 <i><tt>usePlugin</tt></i> function from the
--   <tt><i>GTypePluginClass</i></tt> of <i><tt>plugin</tt></i>. 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 GHC.Classes.Eq GI.GObject.Interfaces.TypePlugin.TypePlugin
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.ManagedPtrNewtype GI.GObject.Interfaces.TypePlugin.TypePlugin
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Interfaces.TypePlugin.TypePlugin


module GI.GObject.Interfaces


module GI.GObject.Functions

-- | Provide a copy of a boxed structure <i><tt>srcBoxed</tt></i> which is
--   of type <i><tt>boxedType</tt></i>.
boxedCopy :: (HasCallStack, MonadIO m) => GType -> Ptr () -> m (Ptr ())

-- | Free the boxed structure <i><tt>boxed</tt></i> which is of type
--   <i><tt>boxedType</tt></i>.
boxedFree :: (HasCallStack, MonadIO m) => GType -> Ptr () -> m ()

-- | This function creates a new <tt><i>G_TYPE_BOXED</i></tt> derived type
--   id for a new boxed type with name <i><tt>name</tt></i>.
--   
--   Boxed type handling functions have to be provided to copy and free
--   opaque boxed structures of this type.
--   
--   For the general case, it is recommended to use
--   <tt><i>G_DEFINE_BOXED_TYPE()</i></tt> instead of calling
--   <a>boxedTypeRegisterStatic</a> directly. The macro will create the
--   appropriate <tt>*_get_type()</tt> function for the boxed type.
boxedTypeRegisterStatic :: (HasCallStack, MonadIO m) => Text -> BoxedCopyFunc -> BoxedFreeFunc -> m GType

-- | Disconnects a handler from <i><tt>instance</tt></i> so it will not be
--   called during any future or currently ongoing emissions of the signal
--   it has been connected to. The <i><tt>handlerIdPtr</tt></i> is then set
--   to zero, which is never a valid handler ID value (see
--   <tt><i>g_signal_connect()</i></tt>).
--   
--   If the handler ID is 0 then this function does nothing.
--   
--   There is also a macro version of this function so that the code will
--   be inlined.
--   
--   <i>Since: 2.62</i>
clearSignalHandler :: (HasCallStack, MonadIO m, IsObject a) => CULong -> a -> m ()

-- | This function is meant to be called from the
--   <tt>complete_type_info</tt> function of a <a>TypePlugin</a>
--   implementation, as in the following example:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   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);
--   }
--   </pre>
enumCompleteTypeInfo :: (HasCallStack, MonadIO m) => GType -> EnumValue -> m TypeInfo

-- | Returns the <a>EnumValue</a> for a value.
enumGetValue :: (HasCallStack, MonadIO m) => EnumClass -> Int32 -> m (Maybe EnumValue)

-- | Looks up a <a>EnumValue</a> by name.
enumGetValueByName :: (HasCallStack, MonadIO m) => EnumClass -> Text -> m (Maybe EnumValue)

-- | Looks up a <a>EnumValue</a> by nickname.
enumGetValueByNick :: (HasCallStack, MonadIO m) => EnumClass -> Text -> m (Maybe EnumValue)

-- | Registers a new static enumeration type with the name
--   <i><tt>name</tt></i>.
--   
--   It is normally more convenient to let [glib-mkenums][glib-mkenums],
--   generate a <tt><i>my_enum_get_type()</i></tt> function from a usual C
--   enumeration definition than to write one yourself using
--   <a>enumRegisterStatic</a>.
enumRegisterStatic :: (HasCallStack, MonadIO m) => Text -> EnumValue -> m GType

-- | Pretty-prints <i><tt>value</tt></i> 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.
--   
--   <i>Since: 2.54</i>
enumToString :: (HasCallStack, MonadIO m) => GType -> Int32 -> m Text

-- | This function is meant to be called from the
--   <tt><i>complete_type_info()</i></tt> function of a <a>TypePlugin</a>
--   implementation, see the example for <a>enumCompleteTypeInfo</a> above.
flagsCompleteTypeInfo :: (HasCallStack, MonadIO m) => GType -> FlagsValue -> m TypeInfo

-- | Returns the first <a>FlagsValue</a> which is set in
--   <i><tt>value</tt></i>.
flagsGetFirstValue :: (HasCallStack, MonadIO m) => FlagsClass -> Word32 -> m (Maybe FlagsValue)

-- | Looks up a <a>FlagsValue</a> by name.
flagsGetValueByName :: (HasCallStack, MonadIO m) => FlagsClass -> Text -> m (Maybe FlagsValue)

-- | Looks up a <a>FlagsValue</a> by nickname.
flagsGetValueByNick :: (HasCallStack, MonadIO m) => FlagsClass -> Text -> m (Maybe FlagsValue)

-- | Registers a new static flags type with the name <i><tt>name</tt></i>.
--   
--   It is normally more convenient to let [glib-mkenums][glib-mkenums]
--   generate a <tt><i>my_flags_get_type()</i></tt> function from a usual C
--   enumeration definition than to write one yourself using
--   <a>flagsRegisterStatic</a>.
flagsRegisterStatic :: (HasCallStack, MonadIO m) => Text -> FlagsValue -> m GType

-- | Pretty-prints <i><tt>value</tt></i> in the form of the flag names
--   separated by <tt> | </tt> 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.
--   
--   <i>Since: 2.54</i>
flagsToString :: (HasCallStack, MonadIO m) => GType -> Word32 -> m Text

-- | <i>No description available in the introspection data.</i>
gtypeGetType :: (HasCallStack, MonadIO m) => m GType

-- | Creates a new <a>ParamSpecBoolean</a> instance specifying a
--   <tt><i>G_TYPE_BOOLEAN</i></tt> property. In many cases, it may be more
--   appropriate to use an enum with <a>paramSpecEnum</a>, 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 <tt><i>g_param_spec_internal()</i></tt> for details on property
--   names.
paramSpecBoolean :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Bool -> [ParamFlags] -> m GParamSpec

-- | Creates a new <a>ParamSpecBoxed</a> instance specifying a
--   <tt><i>G_TYPE_BOXED</i></tt> derived property.
--   
--   See <tt><i>g_param_spec_internal()</i></tt> for details on property
--   names.
paramSpecBoxed :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> GType -> [ParamFlags] -> m GParamSpec

-- | Creates a new <a>ParamSpecChar</a> instance specifying a
--   <tt><i>G_TYPE_CHAR</i></tt> property.
paramSpecChar :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Int8 -> Int8 -> Int8 -> [ParamFlags] -> m GParamSpec

-- | Creates a new <a>ParamSpecDouble</a> instance specifying a
--   <tt><i>G_TYPE_DOUBLE</i></tt> property.
--   
--   See <tt><i>g_param_spec_internal()</i></tt> for details on property
--   names.
paramSpecDouble :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Double -> Double -> Double -> [ParamFlags] -> m GParamSpec

-- | Creates a new <a>ParamSpecEnum</a> instance specifying a
--   <tt><i>G_TYPE_ENUM</i></tt> property.
--   
--   See <tt><i>g_param_spec_internal()</i></tt> for details on property
--   names.
paramSpecEnum :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> GType -> Int32 -> [ParamFlags] -> m GParamSpec

-- | Creates a new <a>ParamSpecFlags</a> instance specifying a
--   <tt><i>G_TYPE_FLAGS</i></tt> property.
--   
--   See <tt><i>g_param_spec_internal()</i></tt> for details on property
--   names.
paramSpecFlags :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> GType -> Word32 -> [ParamFlags] -> m GParamSpec

-- | Creates a new <a>ParamSpecFloat</a> instance specifying a
--   <tt><i>G_TYPE_FLOAT</i></tt> property.
--   
--   See <tt><i>g_param_spec_internal()</i></tt> for details on property
--   names.
paramSpecFloat :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Float -> Float -> Float -> [ParamFlags] -> m GParamSpec

-- | Creates a new <a>ParamSpecGType</a> instance specifying a
--   <tt><i>G_TYPE_GTYPE</i></tt> property.
--   
--   See <tt><i>g_param_spec_internal()</i></tt> for details on property
--   names.
--   
--   <i>Since: 2.10</i>
paramSpecGtype :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> GType -> [ParamFlags] -> m GParamSpec

-- | Creates a new <a>ParamSpecInt</a> instance specifying a
--   <tt><i>G_TYPE_INT</i></tt> property.
--   
--   See <tt><i>g_param_spec_internal()</i></tt> for details on property
--   names.
paramSpecInt :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Int32 -> Int32 -> Int32 -> [ParamFlags] -> m GParamSpec

-- | Creates a new <a>ParamSpecInt64</a> instance specifying a
--   <tt><i>G_TYPE_INT64</i></tt> property.
--   
--   See <tt><i>g_param_spec_internal()</i></tt> for details on property
--   names.
paramSpecInt64 :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Int64 -> Int64 -> Int64 -> [ParamFlags] -> m GParamSpec

-- | Creates a new <a>ParamSpecLong</a> instance specifying a
--   <tt><i>G_TYPE_LONG</i></tt> property.
--   
--   See <tt><i>g_param_spec_internal()</i></tt> for details on property
--   names.
paramSpecLong :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> CLong -> CLong -> CLong -> [ParamFlags] -> m GParamSpec

-- | Creates a new <a>ParamSpecBoxed</a> instance specifying a
--   <tt><i>G_TYPE_OBJECT</i></tt> derived property.
--   
--   See <tt><i>g_param_spec_internal()</i></tt> for details on property
--   names.
paramSpecObject :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> GType -> [ParamFlags] -> m GParamSpec

-- | Creates a new <a>ParamSpecParam</a> instance specifying a
--   <tt><i>G_TYPE_PARAM</i></tt> property.
--   
--   See <tt><i>g_param_spec_internal()</i></tt> for details on property
--   names.
paramSpecParam :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> GType -> [ParamFlags] -> m GParamSpec

-- | Creates a new <a>ParamSpecPointer</a> instance specifying a pointer
--   property. Where possible, it is better to use <a>paramSpecObject</a>
--   or <a>paramSpecBoxed</a> to expose memory management information.
--   
--   See <tt><i>g_param_spec_internal()</i></tt> for details on property
--   names.
paramSpecPointer :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> [ParamFlags] -> m GParamSpec

-- | Creates a new <a>ParamSpecString</a> instance.
--   
--   See <tt><i>g_param_spec_internal()</i></tt> for details on property
--   names.
paramSpecString :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Maybe Text -> [ParamFlags] -> m GParamSpec

-- | Creates a new <a>ParamSpecUChar</a> instance specifying a
--   <tt><i>G_TYPE_UCHAR</i></tt> property.
paramSpecUchar :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Word8 -> Word8 -> Word8 -> [ParamFlags] -> m GParamSpec

-- | Creates a new <a>ParamSpecUInt</a> instance specifying a
--   <tt><i>G_TYPE_UINT</i></tt> property.
--   
--   See <tt><i>g_param_spec_internal()</i></tt> for details on property
--   names.
paramSpecUint :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Word32 -> Word32 -> Word32 -> [ParamFlags] -> m GParamSpec

-- | Creates a new <a>ParamSpecUInt64</a> instance specifying a
--   <tt><i>G_TYPE_UINT64</i></tt> property.
--   
--   See <tt><i>g_param_spec_internal()</i></tt> for details on property
--   names.
paramSpecUint64 :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Word64 -> Word64 -> Word64 -> [ParamFlags] -> m GParamSpec

-- | Creates a new <a>ParamSpecULong</a> instance specifying a
--   <tt><i>G_TYPE_ULONG</i></tt> property.
--   
--   See <tt><i>g_param_spec_internal()</i></tt> for details on property
--   names.
paramSpecUlong :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> CULong -> CULong -> CULong -> [ParamFlags] -> m GParamSpec

-- | Creates a new <a>ParamSpecUnichar</a> instance specifying a
--   <tt><i>G_TYPE_UINT</i></tt> property. <a>Value</a> structures for this
--   property can be accessed with <a>valueSetUint</a> and
--   <a>valueGetUint</a>.
--   
--   See <tt><i>g_param_spec_internal()</i></tt> for details on property
--   names.
paramSpecUnichar :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> Char -> [ParamFlags] -> m GParamSpec

-- | Creates a new <a>ParamSpecVariant</a> instance specifying a
--   <a>GVariant</a> property.
--   
--   If <i><tt>defaultValue</tt></i> is floating, it is consumed.
--   
--   See <tt><i>g_param_spec_internal()</i></tt> for details on property
--   names.
--   
--   <i>Since: 2.26</i>
paramSpecVariant :: (HasCallStack, MonadIO m) => Text -> Maybe Text -> Maybe Text -> VariantType -> Maybe GVariant -> [ParamFlags] -> m GParamSpec

-- | Registers <i><tt>name</tt></i> as the name of a new static type
--   derived from <tt><i>G_TYPE_PARAM</i></tt>.
--   
--   The type system uses the information contained in the
--   <a>ParamSpecTypeInfo</a> structure pointed to by <i><tt>info</tt></i>
--   to manage the <a>ParamSpec</a> type and its instances.
paramTypeRegisterStatic :: (HasCallStack, MonadIO m) => Text -> ParamSpecTypeInfo -> m GType

-- | Transforms <i><tt>srcValue</tt></i> into <i><tt>destValue</tt></i> if
--   possible, and then validates <i><tt>destValue</tt></i>, in order for
--   it to conform to <i><tt>pspec</tt></i>. If
--   <i><tt>strictValidation</tt></i> is <a>True</a> this function will
--   only succeed if the transformed <i><tt>destValue</tt></i> complied to
--   <i><tt>pspec</tt></i> without modifications.
--   
--   See also <a>valueTypeTransformable</a>, <a>valueTransform</a> and
--   <a>paramValueValidate</a>.
paramValueConvert :: (HasCallStack, MonadIO m) => GParamSpec -> GValue -> GValue -> Bool -> m Bool

-- | Checks whether <i><tt>value</tt></i> contains the default value as
--   specified in <i><tt>pspec</tt></i>.
paramValueDefaults :: (HasCallStack, MonadIO m) => GParamSpec -> GValue -> m Bool

-- | Return whether the contents of <i><tt>value</tt></i> comply with the
--   specifications set out by <i><tt>pspec</tt></i>.
--   
--   <i>Since: 2.74</i>
paramValueIsValid :: (HasCallStack, MonadIO m) => GParamSpec -> GValue -> m Bool

-- | Sets <i><tt>value</tt></i> to its default value as specified in
--   <i><tt>pspec</tt></i>.
paramValueSetDefault :: (HasCallStack, MonadIO m) => GParamSpec -> GValue -> m ()

-- | Ensures that the contents of <i><tt>value</tt></i> comply with the
--   specifications set out by <i><tt>pspec</tt></i>. For example, a
--   <a>ParamSpecInt</a> might require that integers stored in
--   <i><tt>value</tt></i> may not be smaller than -42 and not be greater
--   than +42. If <i><tt>value</tt></i> 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 <i><tt>value1</tt></i> with <i><tt>value2</tt></i> according
--   to <i><tt>pspec</tt></i>, and return -1, 0 or +1, if
--   <i><tt>value1</tt></i> is found to be less than, equal to or greater
--   than <i><tt>value2</tt></i>, respectively.
paramValuesCmp :: (HasCallStack, MonadIO m) => GParamSpec -> GValue -> GValue -> m Int32

-- | Creates a new <tt><i>G_TYPE_POINTER</i></tt> derived type id for a new
--   pointer type with name <i><tt>name</tt></i>.
pointerTypeRegisterStatic :: (HasCallStack, MonadIO m) => Text -> m GType

-- | A predefined <a>SignalAccumulator</a> 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").
--   
--   <i>Since: 2.28</i>
signalAccumulatorFirstWins :: (HasCallStack, MonadIO m) => SignalInvocationHint -> GValue -> GValue -> Ptr () -> m Bool

-- | A predefined <a>SignalAccumulator</a> for signals that return a
--   boolean values. The behavior that this accumulator gives is that a
--   return of <a>True</a> stops the signal emission: no further callbacks
--   will be invoked, while a return of <a>False</a> allows the emission to
--   continue. The idea here is that a <a>True</a> return indicates that
--   the callback handled the signal, and no further handling is needed.
--   
--   <i>Since: 2.4</i>
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 <a>SignalFlagsNoHooks</a> 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
--   <a>signalOverrideClassClosure</a> and
--   <a>signalOverrideClassHandler</a>.
signalChainFromOverridden :: (HasCallStack, MonadIO m) => [GValue] -> GValue -> m ()

-- | Connects a closure to a signal for a particular object.
--   
--   If <i><tt>closure</tt></i> is a floating reference (see
--   <a>closureSink</a>), this function takes ownership of
--   <i><tt>closure</tt></i>.
--   
--   This function cannot fail. If the given signal doesn’t exist, a
--   critical warning is emitted.
signalConnectClosure :: (HasCallStack, MonadIO m, IsObject a) => a -> Text -> GClosure b -> Bool -> m CULong

-- | Connects a closure to a signal for a particular object.
--   
--   If <i><tt>closure</tt></i> is a floating reference (see
--   <a>closureSink</a>), this function takes ownership of
--   <i><tt>closure</tt></i>.
--   
--   This function cannot fail. If the given signal doesn’t exist, a
--   critical warning is emitted.
signalConnectClosureById :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> Word32 -> GClosure b -> Bool -> m CULong

-- | Emits a signal. Signal emission is done synchronously. The method will
--   only return control after all handlers are called or signal emission
--   was stopped.
--   
--   Note that <a>signalEmitv</a> doesn't change
--   <i><tt>returnValue</tt></i> if no handlers are connected, in contrast
--   to <tt><i>g_signal_emit()</i></tt> and
--   <tt><i>g_signal_emit_valist()</i></tt>.
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 (Maybe 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 deactivate it, a signal handler
--   has to be unblocked exactly the same amount of times it has been
--   blocked before to become active again.
--   
--   The <i><tt>handlerId</tt></i> has to be a valid signal handler id,
--   connected to a signal of <i><tt>instance</tt></i>.
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 <i><tt>handlerId</tt></i> becomes invalid and may be
--   reused.
--   
--   The <i><tt>handlerId</tt></i> has to be a valid signal handler id,
--   connected to a signal of <i><tt>instance</tt></i>.
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
--   <a>SignalMatchType</a> flags, and the criteria values are passed as
--   arguments. The match <i><tt>mask</tt></i> 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 <i><tt>handlerId</tt></i> is the ID of a handler
--   connected to <i><tt>instance</tt></i>.
signalHandlerIsConnected :: (HasCallStack, MonadIO m, IsObject a) => a -> CULong -> m Bool

-- | Undoes the effect of a previous <a>signalHandlerBlock</a> 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 <i><tt>handlerId</tt></i> has to be a valid id of a signal handler
--   that is connected to a signal of <i><tt>instance</tt></i> 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 a combination of <a>SignalMatchType</a>
--   flags, and the criteria values are passed as arguments. A handler must
--   match on all flags set in <i><tt>mask</tt></i> to be blocked (i.e. the
--   match is conjunctive).
--   
--   Passing at least one of the <a>SignalMatchTypeId</a>,
--   <a>SignalMatchTypeClosure</a>, <a>SignalMatchTypeFunc</a> or
--   <a>SignalMatchTypeData</a> match flags is required for successful
--   matches. If no handlers were found, 0 is returned, the number of
--   blocked handlers otherwise.
--   
--   Support for <a>SignalMatchTypeId</a> was added in GLib 2.78.
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 <a>Object</a> 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 a combination of <a>SignalMatchType</a>
--   flags, and the criteria values are passed as arguments. A handler must
--   match on all flags set in <i><tt>mask</tt></i> to be disconnected
--   (i.e. the match is conjunctive).
--   
--   Passing at least one of the <a>SignalMatchTypeId</a>,
--   <a>SignalMatchTypeClosure</a>, <a>SignalMatchTypeFunc</a> or
--   <a>SignalMatchTypeData</a> match flags is required for successful
--   matches. If no handlers were found, 0 is returned, the number of
--   disconnected handlers otherwise.
--   
--   Support for <a>SignalMatchTypeId</a> was added in GLib 2.78.
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 a combination of <a>SignalMatchType</a>
--   flags, and the criteria values are passed as arguments. A handler must
--   match on all flags set in <i><tt>mask</tt></i> to be unblocked (i.e.
--   the match is conjunctive).
--   
--   Passing at least one of the <a>SignalMatchTypeId</a>,
--   <a>SignalMatchTypeClosure</a>, <a>SignalMatchTypeFunc</a> or
--   <a>SignalMatchTypeData</a> 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.
--   
--   Support for <a>SignalMatchTypeId</a> was added in GLib 2.78.
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
--   <i><tt>instance</tt></i> for the given signal id and detail.
--   
--   If <i><tt>detail</tt></i> is 0 then it will only match handlers that
--   were connected without detail. If <i><tt>detail</tt></i> 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
--   <i><tt>detail</tt></i> 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

-- | Validate a signal name. This can be useful for dynamically-generated
--   signals which need to be validated at run-time before actually trying
--   to create them.
--   
--   See [canonical parameter names][canonical-parameter-names] for details
--   of the rules for valid names. The rules for signal names are the same
--   as those for property names.
--   
--   <i>Since: 2.66</i>
signalIsValidName :: (HasCallStack, MonadIO m) => Text -> m Bool

-- | Lists the signals by id that a certain instance or interface type
--   created. Further information about the signals can be acquired through
--   <a>signalQuery</a>.
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.
--   
--   The type class passed as <i><tt>itype</tt></i> must already have been
--   instantiated (for example, using <a>typeClassRef</a>) for this
--   function to work, as signals are always installed during class
--   initialization.
--   
--   See <tt><i>g_signal_new()</i></tt> 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 (Maybe Text)

-- | Creates a new signal. (This is usually done in the class initializer.)
--   
--   See <tt><i>g_signal_new()</i></tt> for details on allowed signal
--   names.
--   
--   If c_marshaller is <a>Nothing</a>, <a>cclosureMarshalGeneric</a> will
--   be used as the marshaller for this signal.
signalNewv :: (HasCallStack, MonadIO m) => Text -> GType -> [SignalFlags] -> Maybe (GClosure a) -> Maybe SignalAccumulator -> Maybe ClosureMarshal -> GType -> Maybe [GType] -> m Word32

-- | Overrides the class closure (i.e. the default handler) for the given
--   signal for emissions on instances of <i><tt>instanceType</tt></i>.
--   <i><tt>instanceType</tt></i> must be derived from the type to which
--   the signal belongs.
--   
--   See <a>signalChainFromOverridden</a> and
--   <tt><i>g_signal_chain_from_overridden_handler()</i></tt> for how to
--   chain up to the parent class closure from inside the overridden one.
signalOverrideClassClosure :: (HasCallStack, MonadIO m) => Word32 -> GType -> GClosure a -> m ()

-- | Overrides the class closure (i.e. the default handler) for the given
--   signal for emissions on instances of <i><tt>instanceType</tt></i> with
--   callback <i><tt>classHandler</tt></i>. <i><tt>instanceType</tt></i>
--   must be derived from the type to which the signal belongs.
--   
--   See <a>signalChainFromOverridden</a> and
--   <tt><i>g_signal_chain_from_overridden_handler()</i></tt> for how to
--   chain up to the parent class closure from inside the overridden one.
--   
--   <i>Since: 2.18</i>
signalOverrideClassHandler :: (HasCallStack, MonadIO m) => Text -> GType -> Callback -> m ()

-- | Internal function to parse a signal name into its
--   <i><tt>signalId</tt></i> and <i><tt>detail</tt></i> 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
--   <i><tt>signalId</tt></i> member of the <a>SignalQuery</a> is 0. All
--   members filled into the <a>SignalQuery</a> 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
--   <a>SignalFlagsRunLast</a> 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 <a>signalStopEmission</a> 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
--   <i><tt>structOffset</tt></i> in the class structure of the interface
--   or classed type identified by <i><tt>itype</tt></i>.
signalTypeCclosureNew :: (HasCallStack, MonadIO m) => GType -> Word32 -> m (GClosure a)

-- | Return a newly allocated string, which describes the contents of a
--   <a>Value</a>. The main purpose of this function is to describe
--   <a>Value</a> 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
--   <tt><i>get_type()</i></tt> function after the type is registered. The
--   private structure can be retrieved using the
--   <tt><i>G_TYPE_CLASS_GET_PRIVATE()</i></tt> macro.
--   
--   <i>Since: 2.24</i>
typeAddClassPrivate :: (HasCallStack, MonadIO m) => GType -> CSize -> m ()

-- | <i>No description available in the introspection data.</i>
typeAddInstancePrivate :: (HasCallStack, MonadIO m) => GType -> CSize -> m Int32

-- | Adds <i><tt>interfaceType</tt></i> to the dynamic
--   <i><tt>instanceType</tt></i>. The information contained in the
--   <a>TypePlugin</a> structure pointed to by <i><tt>plugin</tt></i> is
--   used to manage the relationship.
typeAddInterfaceDynamic :: (HasCallStack, MonadIO m, IsTypePlugin a) => GType -> GType -> a -> m ()

-- | Adds <i><tt>interfaceType</tt></i> to the static
--   <i><tt>instanceType</tt></i>. The information contained in the
--   <a>InterfaceInfo</a> structure pointed to by <i><tt>info</tt></i> is
--   used to manage the relationship.
typeAddInterfaceStatic :: (HasCallStack, MonadIO m) => GType -> GType -> InterfaceInfo -> m ()

-- | <i>No description available in the introspection data.</i>
typeCheckClassIsA :: (HasCallStack, MonadIO m) => TypeClass -> GType -> m Bool

-- | Private helper function to aid implementation of the
--   <tt><i>G_TYPE_CHECK_INSTANCE()</i></tt> macro.
typeCheckInstance :: (HasCallStack, MonadIO m) => TypeInstance -> m Bool

-- | <i>No description available in the introspection data.</i>
typeCheckInstanceIsA :: (HasCallStack, MonadIO m) => TypeInstance -> GType -> m Bool

-- | <i>No description available in the introspection data.</i>
typeCheckInstanceIsFundamentallyA :: (HasCallStack, MonadIO m) => TypeInstance -> GType -> m Bool

-- | <i>No description available in the introspection data.</i>
typeCheckIsValueType :: (HasCallStack, MonadIO m) => GType -> m Bool

-- | <i>No description available in the introspection data.</i>
typeCheckValue :: (HasCallStack, MonadIO m) => GValue -> m Bool

-- | <i>No description available in the introspection data.</i>
typeCheckValueHolds :: (HasCallStack, MonadIO m) => GValue -> GType -> m Bool

-- | Return a newly allocated and 0-terminated array of type IDs, listing
--   the child types of <i><tt>type</tt></i>.
typeChildren :: (HasCallStack, MonadIO m) => GType -> m [GType]

-- | If the interface type <i><tt>gType</tt></i> is currently in use,
--   returns its default interface vtable.
--   
--   <i>Since: 2.4</i>
typeDefaultInterfacePeek :: (HasCallStack, MonadIO m) => GType -> m TypeInterface

-- | Increments the reference count for the interface type
--   <i><tt>gType</tt></i>, 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 initialized by calling the base interface
--   init and default vtable init functions for the type (the
--   <i><tt>baseInit</tt></i> and <i><tt>classInit</tt></i> members of
--   <a>TypeInfo</a>). Calling <a>typeDefaultInterfaceRef</a> is useful
--   when you want to make sure that signals and properties for an
--   interface have been installed.
--   
--   <i>Since: 2.4</i>
typeDefaultInterfaceRef :: (HasCallStack, MonadIO m) => GType -> m TypeInterface

-- | Decrements the reference count for the type corresponding to the
--   interface default vtable <i><tt>gIface</tt></i>. 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 <i><tt>classFinalize</tt></i> member of <a>TypeInfo</a>)
--   will be called.
--   
--   <i>Since: 2.4</i>
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 <i><tt>type</tt></i> has been registered
--   with the type system, and its <tt><i>_class_init()</i></tt> method has
--   been run.
--   
--   In theory, simply calling the type's <tt><i>_get_type()</i></tt>
--   method (or using the corresponding macro) is supposed take care of
--   this. However, <tt><i>_get_type()</i></tt> methods are often marked
--   <tt><i>G_GNUC_CONST</i></tt> for performance reasons, even though this
--   is technically incorrect (since <tt><i>G_GNUC_CONST</i></tt> requires
--   that the function not have side effects, which
--   <tt><i>_get_type()</i></tt> methods do on the first call). As a
--   result, if you write a bare call to a <tt><i>_get_type()</i></tt>
--   macro, it may get optimized out by the compiler. Using
--   <a>typeEnsure</a> guarantees that the type's
--   <tt><i>_get_type()</i></tt> method is called.
--   
--   <i>Since: 2.34</i>
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 <tt><i>g_type_create_instance()</i></tt>, this function is
--   reserved for implementors of fundamental types.
typeFreeInstance :: (HasCallStack, MonadIO m) => TypeInstance -> m ()

-- | Look up 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 <tt><i>G_TYPE_FUNDAMENTAL()</i></tt> 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 <a>typeRegisterFundamental</a>.
--   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
--   <tt>instance-count</tt> debug flag is set (by setting the
--   <tt>GOBJECT_DEBUG</tt> variable to include <tt>instance-count</tt>).
--   
--   <i>Since: 2.44</i>
typeGetInstanceCount :: (HasCallStack, MonadIO m) => GType -> m Int32

-- | Returns the <a>TypePlugin</a> structure for <i><tt>type</tt></i>.
typeGetPlugin :: (HasCallStack, MonadIO m) => GType -> m TypePlugin

-- | Obtains data which has previously been attached to
--   <i><tt>type</tt></i> with <a>typeSetQdata</a>.
--   
--   Note that this does not take subtyping into account; data attached to
--   one type with <a>typeSetQdata</a> cannot be retrieved from a subtype
--   using <a>typeGetQdata</a>.
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 <a>typeFromName</a>) and know if the cache is still valid at
--   a later time by comparing the current serial with the one at the type
--   lookup.
--   
--   <i>Since: 2.36</i>
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.

-- | <i>Deprecated: (Since version 2.36)the type system is now initialised
--   automatically</i>
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
--   <tt>GOBJECT_DEBUG</tt> environment variable.

-- | <i>Deprecated: (Since version 2.36)the type system is now initialised
--   automatically</i>
typeInitWithDebugFlags :: (HasCallStack, MonadIO m) => [TypeDebugFlags] -> m ()

-- | Return a newly allocated and 0-terminated array of type IDs, listing
--   the interface types that <i><tt>type</tt></i> conforms to.
typeInterfaces :: (HasCallStack, MonadIO m) => GType -> m [GType]

-- | If <i><tt>isAType</tt></i> is a derivable type, check whether
--   <i><tt>type</tt></i> is a descendant of <i><tt>isAType</tt></i>. If
--   <i><tt>isAType</tt></i> is an interface, check whether
--   <i><tt>type</tt></i> 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.
--   <tt><i>G_TYPE_INVALID</i></tt> 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 (Maybe Text)

-- | <i>No description available in the introspection data.</i>
typeNameFromClass :: (HasCallStack, MonadIO m) => TypeClass -> m Text

-- | <i>No description available in the introspection data.</i>
typeNameFromInstance :: (HasCallStack, MonadIO m) => TypeInstance -> m Text

-- | Given a <i><tt>leafType</tt></i> and a <i><tt>rootType</tt></i> which
--   is contained in its ancestry, return the type that
--   <i><tt>rootType</tt></i> is the immediate parent of. In other words,
--   this function determines the type that is derived directly from
--   <i><tt>rootType</tt></i> which is also a base class of
--   <i><tt>leafType</tt></i>. 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 <a>GType</a> is passed in,
--   the <i><tt>type</tt></i> member of the <a>TypeQuery</a> is 0. All
--   members filled into the <a>TypeQuery</a> structure should be
--   considered constant and have to be left untouched.
--   
--   Since GLib 2.78, this function allows queries on dynamic types.
--   Previously it only supported static types.
typeQuery :: (HasCallStack, MonadIO m) => GType -> m TypeQuery

-- | Registers <i><tt>typeName</tt></i> as the name of a new dynamic type
--   derived from <i><tt>parentType</tt></i>. The type system uses the
--   information contained in the <a>TypePlugin</a> structure pointed to by
--   <i><tt>plugin</tt></i> to manage the type and its instances (if not
--   abstract). The value of <i><tt>flags</tt></i> determines the nature
--   (e.g. abstract or not) of the type.
typeRegisterDynamic :: (HasCallStack, MonadIO m, IsTypePlugin a) => GType -> Text -> a -> [TypeFlags] -> m GType

-- | Registers <i><tt>typeId</tt></i> as the predefined identifier and
--   <i><tt>typeName</tt></i> as the name of a fundamental type. If
--   <i><tt>typeId</tt></i> is already registered, or a type named
--   <i><tt>typeName</tt></i> is already registered, the behaviour is
--   undefined. The type system uses the information contained in the
--   <a>TypeInfo</a> structure pointed to by <i><tt>info</tt></i> and the
--   <a>TypeFundamentalInfo</a> structure pointed to by
--   <i><tt>finfo</tt></i> to manage the type and its instances. The value
--   of <i><tt>flags</tt></i> determines additional characteristics of the
--   fundamental type.
typeRegisterFundamental :: (HasCallStack, MonadIO m) => GType -> Text -> TypeInfo -> TypeFundamentalInfo -> [TypeFlags] -> m GType

-- | Registers <i><tt>typeName</tt></i> as the name of a new static type
--   derived from <i><tt>parentType</tt></i>. The type system uses the
--   information contained in the <a>TypeInfo</a> structure pointed to by
--   <i><tt>info</tt></i> to manage the type and its instances (if not
--   abstract). The value of <i><tt>flags</tt></i> 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 ()

-- | <i>No description available in the introspection data.</i>
typeTestFlags :: (HasCallStack, MonadIO m) => GType -> Word32 -> m Bool

-- | <i>No description available in the introspection data.</i>
variantGetGtype :: (HasCallStack, MonadIO m) => m GType


-- | <i>No description available in the introspection data.</i>
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 <a>Value_Data_Union_</a> struct initialized to zero.
newZeroValue_Data_Union_ :: MonadIO m => m Value_Data_Union_

-- | Get the value of the “<tt>v_double</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> value_Data_Union_ #vDouble
--   </pre>
getValue_Data_Union_VDouble :: MonadIO m => Value_Data_Union_ -> m Double

-- | Set the value of the “<tt>v_double</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> value_Data_Union_ [ #vDouble <a>:=</a> value ]
--   </pre>
setValue_Data_Union_VDouble :: MonadIO m => Value_Data_Union_ -> Double -> m ()

-- | Get the value of the “<tt>v_float</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> value_Data_Union_ #vFloat
--   </pre>
getValue_Data_Union_VFloat :: MonadIO m => Value_Data_Union_ -> m Float

-- | Set the value of the “<tt>v_float</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> value_Data_Union_ [ #vFloat <a>:=</a> value ]
--   </pre>
setValue_Data_Union_VFloat :: MonadIO m => Value_Data_Union_ -> Float -> m ()

-- | Get the value of the “<tt>v_int</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> value_Data_Union_ #vInt
--   </pre>
getValue_Data_Union_VInt :: MonadIO m => Value_Data_Union_ -> m Int32

-- | Set the value of the “<tt>v_int</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> value_Data_Union_ [ #vInt <a>:=</a> value ]
--   </pre>
setValue_Data_Union_VInt :: MonadIO m => Value_Data_Union_ -> Int32 -> m ()

-- | Get the value of the “<tt>v_int64</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> value_Data_Union_ #vInt64
--   </pre>
getValue_Data_Union_VInt64 :: MonadIO m => Value_Data_Union_ -> m Int64

-- | Set the value of the “<tt>v_int64</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> value_Data_Union_ [ #vInt64 <a>:=</a> value ]
--   </pre>
setValue_Data_Union_VInt64 :: MonadIO m => Value_Data_Union_ -> Int64 -> m ()

-- | Get the value of the “<tt>v_long</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> value_Data_Union_ #vLong
--   </pre>
getValue_Data_Union_VLong :: MonadIO m => Value_Data_Union_ -> m CLong

-- | Set the value of the “<tt>v_long</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> value_Data_Union_ [ #vLong <a>:=</a> value ]
--   </pre>
setValue_Data_Union_VLong :: MonadIO m => Value_Data_Union_ -> CLong -> m ()

-- | Set the value of the “<tt>v_pointer</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #vPointer
--   </pre>
clearValue_Data_Union_VPointer :: MonadIO m => Value_Data_Union_ -> m ()

-- | Get the value of the “<tt>v_pointer</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> value_Data_Union_ #vPointer
--   </pre>
getValue_Data_Union_VPointer :: MonadIO m => Value_Data_Union_ -> m (Ptr ())

-- | Set the value of the “<tt>v_pointer</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> value_Data_Union_ [ #vPointer <a>:=</a> value ]
--   </pre>
setValue_Data_Union_VPointer :: MonadIO m => Value_Data_Union_ -> Ptr () -> m ()

-- | Get the value of the “<tt>v_uint</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> value_Data_Union_ #vUint
--   </pre>
getValue_Data_Union_VUint :: MonadIO m => Value_Data_Union_ -> m Word32

-- | Set the value of the “<tt>v_uint</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> value_Data_Union_ [ #vUint <a>:=</a> value ]
--   </pre>
setValue_Data_Union_VUint :: MonadIO m => Value_Data_Union_ -> Word32 -> m ()

-- | Get the value of the “<tt>v_uint64</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> value_Data_Union_ #vUint64
--   </pre>
getValue_Data_Union_VUint64 :: MonadIO m => Value_Data_Union_ -> m Word64

-- | Set the value of the “<tt>v_uint64</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> value_Data_Union_ [ #vUint64 <a>:=</a> value ]
--   </pre>
setValue_Data_Union_VUint64 :: MonadIO m => Value_Data_Union_ -> Word64 -> m ()

-- | Get the value of the “<tt>v_ulong</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> value_Data_Union_ #vUlong
--   </pre>
getValue_Data_Union_VUlong :: MonadIO m => Value_Data_Union_ -> m CULong

-- | Set the value of the “<tt>v_ulong</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> value_Data_Union_ [ #vUlong <a>:=</a> value ]
--   </pre>
setValue_Data_Union_VUlong :: MonadIO m => Value_Data_Union_ -> CULong -> m ()
instance GHC.Classes.Eq GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_
instance Data.GI.Base.BasicTypes.CallocPtr GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_
instance (tag GHC.Types.~ '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
