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


module GI.GObject.Unions.Value_Data_Union_
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_
noValue_Data_Union_ :: Maybe Value_Data_Union_
getValue_Data_Union_VDouble :: MonadIO m => Value_Data_Union_ -> m Double
setValue_Data_Union_VDouble :: MonadIO m => Value_Data_Union_ -> Double -> m ()
value_Data_Union__vDouble :: AttrLabelProxy "vDouble"
getValue_Data_Union_VFloat :: MonadIO m => Value_Data_Union_ -> m Float
setValue_Data_Union_VFloat :: MonadIO m => Value_Data_Union_ -> Float -> m ()
value_Data_Union__vFloat :: AttrLabelProxy "vFloat"
getValue_Data_Union_VInt :: MonadIO m => Value_Data_Union_ -> m Int32
setValue_Data_Union_VInt :: MonadIO m => Value_Data_Union_ -> Int32 -> m ()
value_Data_Union__vInt :: AttrLabelProxy "vInt"
getValue_Data_Union_VInt64 :: MonadIO m => Value_Data_Union_ -> m Int64
setValue_Data_Union_VInt64 :: MonadIO m => Value_Data_Union_ -> Int64 -> m ()
value_Data_Union__vInt64 :: AttrLabelProxy "vInt64"
getValue_Data_Union_VLong :: MonadIO m => Value_Data_Union_ -> m CLong
setValue_Data_Union_VLong :: MonadIO m => Value_Data_Union_ -> CLong -> m ()
value_Data_Union__vLong :: AttrLabelProxy "vLong"
clearValue_Data_Union_VPointer :: MonadIO m => Value_Data_Union_ -> m ()
getValue_Data_Union_VPointer :: MonadIO m => Value_Data_Union_ -> m (Ptr ())
setValue_Data_Union_VPointer :: MonadIO m => Value_Data_Union_ -> Ptr () -> m ()
value_Data_Union__vPointer :: AttrLabelProxy "vPointer"
getValue_Data_Union_VUint :: MonadIO m => Value_Data_Union_ -> m Word32
setValue_Data_Union_VUint :: MonadIO m => Value_Data_Union_ -> Word32 -> m ()
value_Data_Union__vUint :: AttrLabelProxy "vUint"
getValue_Data_Union_VUint64 :: MonadIO m => Value_Data_Union_ -> m Word64
setValue_Data_Union_VUint64 :: MonadIO m => Value_Data_Union_ -> Word64 -> m ()
value_Data_Union__vUint64 :: AttrLabelProxy "vUint64"
getValue_Data_Union_VUlong :: MonadIO m => Value_Data_Union_ -> m CULong
setValue_Data_Union_VUlong :: MonadIO m => Value_Data_Union_ -> CULong -> m ()
value_Data_Union__vUlong :: AttrLabelProxy "vUlong"
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_ tag
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_VIntFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_VUintFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_VLongFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_VUlongFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_VInt64FieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_VUint64FieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_VFloatFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_VDoubleFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_VPointerFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_
instance (info ~ GI.GObject.Unions.Value_Data_Union_.ResolveValue_Data_Union_Method t GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_ p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_ -> p)
instance (info ~ GI.GObject.Unions.Value_Data_Union_.ResolveValue_Data_Union_Method t GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_ p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Unions.Value_Data_Union_.Value_Data_Union_ -> p)


-- | A union holding one collected value.
module GI.GObject.Unions.TypeCValue
newtype TypeCValue
TypeCValue :: (ManagedPtr TypeCValue) -> TypeCValue

-- | Construct a <a>TypeCValue</a> struct initialized to zero.
newZeroTypeCValue :: MonadIO m => m TypeCValue
noTypeCValue :: Maybe TypeCValue
getTypeCValueVDouble :: MonadIO m => TypeCValue -> m Double
setTypeCValueVDouble :: MonadIO m => TypeCValue -> Double -> m ()
typeCValue_vDouble :: AttrLabelProxy "vDouble"
getTypeCValueVInt :: MonadIO m => TypeCValue -> m Int32
setTypeCValueVInt :: MonadIO m => TypeCValue -> Int32 -> m ()
typeCValue_vInt :: AttrLabelProxy "vInt"
getTypeCValueVInt64 :: MonadIO m => TypeCValue -> m Int64
setTypeCValueVInt64 :: MonadIO m => TypeCValue -> Int64 -> m ()
typeCValue_vInt64 :: AttrLabelProxy "vInt64"
getTypeCValueVLong :: MonadIO m => TypeCValue -> m CLong
setTypeCValueVLong :: MonadIO m => TypeCValue -> CLong -> m ()
typeCValue_vLong :: AttrLabelProxy "vLong"
clearTypeCValueVPointer :: MonadIO m => TypeCValue -> m ()
getTypeCValueVPointer :: MonadIO m => TypeCValue -> m (Ptr ())
setTypeCValueVPointer :: MonadIO m => TypeCValue -> Ptr () -> m ()
typeCValue_vPointer :: AttrLabelProxy "vPointer"
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Unions.TypeCValue.TypeCValue
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Unions.TypeCValue.TypeCValue tag
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Unions.TypeCValue.TypeCValueVIntFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Unions.TypeCValue.TypeCValueVLongFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Unions.TypeCValue.TypeCValueVInt64FieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Unions.TypeCValue.TypeCValueVDoubleFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Unions.TypeCValue.TypeCValueVPointerFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Unions.TypeCValue.TypeCValue
instance (info ~ GI.GObject.Unions.TypeCValue.ResolveTypeCValueMethod t GI.GObject.Unions.TypeCValue.TypeCValue, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Unions.TypeCValue.TypeCValue p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Unions.TypeCValue.TypeCValue -> p)
instance (info ~ GI.GObject.Unions.TypeCValue.ResolveTypeCValueMethod t GI.GObject.Unions.TypeCValue.TypeCValue, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Unions.TypeCValue.TypeCValue p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Unions.TypeCValue.TypeCValue -> p)


module GI.GObject.Unions


-- | A structure containing a weak reference to a <a>Object</a>. It 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, any
--   <tt><i>GWeakRefs</i></tt> taken before it was disposed will continue
--   to point to <a>Nothing</a>. If <tt><i>GWeakRefs</i></tt> are taken
--   after the object is disposed and re-referenced, they will continue to
--   point to it until its refcount goes back to zero, at which point they
--   too will be invalidated.
module GI.GObject.Structs.WeakRef
newtype WeakRef
WeakRef :: (ManagedPtr WeakRef) -> WeakRef
noWeakRef :: Maybe WeakRef
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.WeakRef.WeakRef
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.WeakRef.WeakRef
instance (info ~ GI.GObject.Structs.WeakRef.ResolveWeakRefMethod t GI.GObject.Structs.WeakRef.WeakRef, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.WeakRef.WeakRef p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.WeakRef.WeakRef -> p)
instance (info ~ GI.GObject.Structs.WeakRef.ResolveWeakRefMethod t GI.GObject.Structs.WeakRef.WeakRef, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.WeakRef.WeakRef p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.WeakRef.WeakRef -> p)


-- | A <a>ValueArray</a> contains an array of <a>Value</a> elements.
module GI.GObject.Structs.ValueArray
newtype ValueArray
ValueArray :: (ManagedPtr ValueArray) -> ValueArray

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

-- | 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
data ValueArrayCopyMethodInfo

-- | 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
data ValueArrayFreeMethodInfo

-- | Free a <a>ValueArray</a> including its contents.

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

-- | 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
data ValueArrayInsertMethodInfo

-- | 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
data ValueArrayPrependMethodInfo

-- | 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
data ValueArrayRemoveMethodInfo

-- | 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
data ValueArraySortMethodInfo

-- | 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
getValueArrayNValues :: MonadIO m => ValueArray -> m Word32
setValueArrayNValues :: MonadIO m => ValueArray -> Word32 -> m ()
valueArray_nValues :: AttrLabelProxy "nValues"
clearValueArrayValues :: MonadIO m => ValueArray -> m ()
getValueArrayValues :: MonadIO m => ValueArray -> m (Maybe GValue)
setValueArrayValues :: MonadIO m => ValueArray -> Ptr GValue -> m ()
valueArray_values :: AttrLabelProxy "values"
instance Data.GI.Base.BasicTypes.BoxedObject GI.GObject.Structs.ValueArray.ValueArray
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.ValueArray.ValueArray tag
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.ValueArray.ValueArrayNValuesFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.ValueArray.ValueArrayValuesFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.ValueArray.ValueArray
instance (signature ~ (GHC.Base.Maybe Data.GI.Base.GValue.GValue -> m GI.GObject.Structs.ValueArray.ValueArray), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Structs.ValueArray.ValueArrayAppendMethodInfo GI.GObject.Structs.ValueArray.ValueArray signature
instance (signature ~ m GI.GObject.Structs.ValueArray.ValueArray, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Structs.ValueArray.ValueArrayCopyMethodInfo GI.GObject.Structs.ValueArray.ValueArray signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Structs.ValueArray.ValueArrayFreeMethodInfo GI.GObject.Structs.ValueArray.ValueArray signature
instance (signature ~ (GHC.Word.Word32 -> m Data.GI.Base.GValue.GValue), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Structs.ValueArray.ValueArrayGetNthMethodInfo GI.GObject.Structs.ValueArray.ValueArray signature
instance (signature ~ (GHC.Word.Word32 -> GHC.Base.Maybe Data.GI.Base.GValue.GValue -> m GI.GObject.Structs.ValueArray.ValueArray), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Structs.ValueArray.ValueArrayInsertMethodInfo GI.GObject.Structs.ValueArray.ValueArray signature
instance (signature ~ (GHC.Base.Maybe Data.GI.Base.GValue.GValue -> m GI.GObject.Structs.ValueArray.ValueArray), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Structs.ValueArray.ValueArrayPrependMethodInfo GI.GObject.Structs.ValueArray.ValueArray signature
instance (signature ~ (GHC.Word.Word32 -> m GI.GObject.Structs.ValueArray.ValueArray), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Structs.ValueArray.ValueArrayRemoveMethodInfo GI.GObject.Structs.ValueArray.ValueArray signature
instance (signature ~ (GI.GLib.Callbacks.CompareDataFunc -> m GI.GObject.Structs.ValueArray.ValueArray), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Structs.ValueArray.ValueArraySortMethodInfo GI.GObject.Structs.ValueArray.ValueArray signature
instance (info ~ GI.GObject.Structs.ValueArray.ResolveValueArrayMethod t GI.GObject.Structs.ValueArray.ValueArray, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.ValueArray.ValueArray p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.ValueArray.ValueArray -> p)
instance (info ~ GI.GObject.Structs.ValueArray.ResolveValueArrayMethod t GI.GObject.Structs.ValueArray.ValueArray, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.ValueArray.ValueArray p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.ValueArray.ValueArray -> p)


-- | A structure holding information for a specific type. It is filled in
--   by the <a>typeQuery</a> function.
module GI.GObject.Structs.TypeQuery
newtype TypeQuery
TypeQuery :: (ManagedPtr TypeQuery) -> TypeQuery

-- | Construct a <a>TypeQuery</a> struct initialized to zero.
newZeroTypeQuery :: MonadIO m => m TypeQuery
noTypeQuery :: Maybe TypeQuery
getTypeQueryClassSize :: MonadIO m => TypeQuery -> m Word32
setTypeQueryClassSize :: MonadIO m => TypeQuery -> Word32 -> m ()
typeQuery_classSize :: AttrLabelProxy "classSize"
getTypeQueryInstanceSize :: MonadIO m => TypeQuery -> m Word32
setTypeQueryInstanceSize :: MonadIO m => TypeQuery -> Word32 -> m ()
typeQuery_instanceSize :: AttrLabelProxy "instanceSize"
getTypeQueryType :: MonadIO m => TypeQuery -> m GType
setTypeQueryType :: MonadIO m => TypeQuery -> GType -> m ()
typeQuery_type :: AttrLabelProxy "type"
clearTypeQueryTypeName :: MonadIO m => TypeQuery -> m ()
getTypeQueryTypeName :: MonadIO m => TypeQuery -> m (Maybe Text)
setTypeQueryTypeName :: MonadIO m => TypeQuery -> CString -> m ()
typeQuery_typeName :: AttrLabelProxy "typeName"
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.TypeQuery.TypeQuery
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.TypeQuery.TypeQuery tag
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeQuery.TypeQueryTypeFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeQuery.TypeQueryTypeNameFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeQuery.TypeQueryClassSizeFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeQuery.TypeQueryInstanceSizeFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.TypeQuery.TypeQuery
instance (info ~ GI.GObject.Structs.TypeQuery.ResolveTypeQueryMethod t GI.GObject.Structs.TypeQuery.TypeQuery, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.TypeQuery.TypeQuery p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.TypeQuery.TypeQuery -> p)
instance (info ~ GI.GObject.Structs.TypeQuery.ResolveTypeQueryMethod t GI.GObject.Structs.TypeQuery.TypeQuery, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.TypeQuery.TypeQuery p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.TypeQuery.TypeQuery -> p)


-- | An opaque structure used as the base of all type instances.
module GI.GObject.Structs.TypeInstance
newtype TypeInstance
TypeInstance :: (ManagedPtr TypeInstance) -> TypeInstance

-- | Construct a <a>TypeInstance</a> struct initialized to zero.
newZeroTypeInstance :: MonadIO m => m TypeInstance
noTypeInstance :: Maybe TypeInstance
data TypeInstanceGetPrivateMethodInfo

-- | <i>No description available in the introspection data.</i>
typeInstanceGetPrivate :: (HasCallStack, MonadIO m) => TypeInstance -> GType -> m (Ptr ())
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.TypeInstance.TypeInstance
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.TypeInstance.TypeInstance tag
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.TypeInstance.TypeInstance
instance (signature ~ (Data.GI.Base.GType.GType -> m (GHC.Ptr.Ptr ())), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Structs.TypeInstance.TypeInstanceGetPrivateMethodInfo GI.GObject.Structs.TypeInstance.TypeInstance signature
instance (info ~ GI.GObject.Structs.TypeInstance.ResolveTypeInstanceMethod t GI.GObject.Structs.TypeInstance.TypeInstance, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.TypeInstance.TypeInstance p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.TypeInstance.TypeInstance -> p)
instance (info ~ GI.GObject.Structs.TypeInstance.ResolveTypeInstanceMethod t GI.GObject.Structs.TypeInstance.TypeInstance, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.TypeInstance.TypeInstance p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.TypeInstance.TypeInstance -> p)


-- | An opaque structure used as the base of all classes.
module GI.GObject.Structs.TypeClass
newtype TypeClass
TypeClass :: (ManagedPtr TypeClass) -> TypeClass

-- | Construct a <a>TypeClass</a> struct initialized to zero.
newZeroTypeClass :: MonadIO m => m TypeClass
noTypeClass :: Maybe TypeClass
data TypeClassAddPrivateMethodInfo

-- | 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>
typeClassAddPrivate :: (HasCallStack, MonadIO m) => TypeClass -> Word64 -> m ()

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

-- | <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
data TypeClassPeekParentMethodInfo

-- | 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.
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
data TypeClassUnrefMethodInfo

-- | 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 Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.TypeClass.TypeClass
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.TypeClass.TypeClass tag
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.TypeClass.TypeClass
instance (signature ~ (GHC.Word.Word64 -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Structs.TypeClass.TypeClassAddPrivateMethodInfo GI.GObject.Structs.TypeClass.TypeClass signature
instance (signature ~ (Data.GI.Base.GType.GType -> m (GHC.Ptr.Ptr ())), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Structs.TypeClass.TypeClassGetPrivateMethodInfo GI.GObject.Structs.TypeClass.TypeClass signature
instance (signature ~ m GI.GObject.Structs.TypeClass.TypeClass, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Structs.TypeClass.TypeClassPeekParentMethodInfo GI.GObject.Structs.TypeClass.TypeClass signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Structs.TypeClass.TypeClassUnrefMethodInfo GI.GObject.Structs.TypeClass.TypeClass signature
instance (info ~ GI.GObject.Structs.TypeClass.ResolveTypeClassMethod t GI.GObject.Structs.TypeClass.TypeClass, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.TypeClass.TypeClass p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.TypeClass.TypeClass -> p)
instance (info ~ GI.GObject.Structs.TypeClass.ResolveTypeClassMethod t GI.GObject.Structs.TypeClass.TypeClass, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.TypeClass.TypeClass p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.TypeClass.TypeClass -> p)


-- | The GParameter struct is an auxiliary structure used to hand parameter
--   name/value pairs to <a>objectNew</a>.
module GI.GObject.Structs.Parameter
newtype Parameter
Parameter :: (ManagedPtr Parameter) -> Parameter

-- | Construct a <a>Parameter</a> struct initialized to zero.
newZeroParameter :: MonadIO m => m Parameter
noParameter :: Maybe Parameter
clearParameterName :: MonadIO m => Parameter -> m ()
getParameterName :: MonadIO m => Parameter -> m (Maybe Text)
parameter_name :: AttrLabelProxy "name"
setParameterName :: MonadIO m => Parameter -> CString -> m ()
getParameterValue :: MonadIO m => Parameter -> m GValue
parameter_value :: AttrLabelProxy "value"
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.Parameter.Parameter
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.Parameter.Parameter tag
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.Parameter.ParameterNameFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.Parameter.ParameterValueFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.Parameter.Parameter
instance (info ~ GI.GObject.Structs.Parameter.ResolveParameterMethod t GI.GObject.Structs.Parameter.Parameter, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.Parameter.Parameter p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.Parameter.Parameter -> p)
instance (info ~ GI.GObject.Structs.Parameter.ResolveParameterMethod t GI.GObject.Structs.Parameter.Parameter, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.Parameter.Parameter p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.Parameter.Parameter -> p)


-- | 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
newtype ParamSpecPool
ParamSpecPool :: (ManagedPtr ParamSpecPool) -> ParamSpecPool
noParamSpecPool :: Maybe ParamSpecPool
data ParamSpecPoolInsertMethodInfo

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

-- | 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]
data ParamSpecPoolLookupMethodInfo

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

-- | Creates a new <a>ParamSpecPool</a>.
--   
--   If <i><tt>typePrefixing</tt></i> is <a>True</a>, lookups in the newly
--   created pool will allow to specify the owner as a colon-separated
--   prefix of the property name, like "GtkContainer:border-width". This
--   feature is deprecated, so you should always set
--   <i><tt>typePrefixing</tt></i> to <a>False</a>.
paramSpecPoolNew :: (HasCallStack, MonadIO m) => Bool -> m ParamSpecPool
data ParamSpecPoolRemoveMethodInfo

-- | Removes a <a>ParamSpec</a> from the pool.
paramSpecPoolRemove :: (HasCallStack, MonadIO m) => ParamSpecPool -> GParamSpec -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.ParamSpecPool.ParamSpecPool
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.ParamSpecPool.ParamSpecPool
instance (signature ~ (Data.GI.Base.BasicTypes.GParamSpec -> Data.GI.Base.GType.GType -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Structs.ParamSpecPool.ParamSpecPoolInsertMethodInfo GI.GObject.Structs.ParamSpecPool.ParamSpecPool signature
instance (signature ~ (Data.GI.Base.GType.GType -> m [Data.GI.Base.BasicTypes.GParamSpec]), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Structs.ParamSpecPool.ParamSpecPoolListOwnedMethodInfo GI.GObject.Structs.ParamSpecPool.ParamSpecPool signature
instance (signature ~ (Data.Text.Internal.Text -> Data.GI.Base.GType.GType -> GHC.Types.Bool -> m Data.GI.Base.BasicTypes.GParamSpec), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Structs.ParamSpecPool.ParamSpecPoolLookupMethodInfo GI.GObject.Structs.ParamSpecPool.ParamSpecPool signature
instance (signature ~ (Data.GI.Base.BasicTypes.GParamSpec -> m ()), Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Structs.ParamSpecPool.ParamSpecPoolRemoveMethodInfo GI.GObject.Structs.ParamSpecPool.ParamSpecPool signature
instance (info ~ GI.GObject.Structs.ParamSpecPool.ResolveParamSpecPoolMethod t GI.GObject.Structs.ParamSpecPool.ParamSpecPool, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.ParamSpecPool.ParamSpecPool p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.ParamSpecPool.ParamSpecPool -> p)
instance (info ~ GI.GObject.Structs.ParamSpecPool.ResolveParamSpecPoolMethod t GI.GObject.Structs.ParamSpecPool.ParamSpecPool, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.ParamSpecPool.ParamSpecPool p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.ParamSpecPool.ParamSpecPool -> p)


-- | The GObjectConstructParam struct is an auxiliary structure used to
--   hand
--   'GI.GObject.Objects.ParamSpec.ParamSpec'\/'GI.GObject.Structs.Value.Value'
--   pairs to the <i><tt>constructor</tt></i> of a <a>ObjectClass</a>.
module GI.GObject.Structs.ObjectConstructParam
newtype ObjectConstructParam
ObjectConstructParam :: (ManagedPtr ObjectConstructParam) -> ObjectConstructParam

-- | Construct a <a>ObjectConstructParam</a> struct initialized to zero.
newZeroObjectConstructParam :: MonadIO m => m ObjectConstructParam
noObjectConstructParam :: Maybe ObjectConstructParam
clearObjectConstructParamPspec :: MonadIO m => ObjectConstructParam -> m ()
getObjectConstructParamPspec :: MonadIO m => ObjectConstructParam -> m (Maybe GParamSpec)
objectConstructParam_pspec :: AttrLabelProxy "pspec"
setObjectConstructParamPspec :: MonadIO m => ObjectConstructParam -> Ptr GParamSpec -> m ()
clearObjectConstructParamValue :: MonadIO m => ObjectConstructParam -> m ()
getObjectConstructParamValue :: MonadIO m => ObjectConstructParam -> m (Maybe GValue)
objectConstructParam_value :: AttrLabelProxy "value"
setObjectConstructParamValue :: MonadIO m => ObjectConstructParam -> Ptr GValue -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.ObjectConstructParam.ObjectConstructParam
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.ObjectConstructParam.ObjectConstructParam tag
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.ObjectConstructParam.ObjectConstructParamPspecFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.ObjectConstructParam.ObjectConstructParamValueFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.ObjectConstructParam.ObjectConstructParam
instance (info ~ GI.GObject.Structs.ObjectConstructParam.ResolveObjectConstructParamMethod t GI.GObject.Structs.ObjectConstructParam.ObjectConstructParam, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.ObjectConstructParam.ObjectConstructParam p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.ObjectConstructParam.ObjectConstructParam -> p)
instance (info ~ GI.GObject.Structs.ObjectConstructParam.ResolveObjectConstructParamMethod t GI.GObject.Structs.ObjectConstructParam.ObjectConstructParam, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.ObjectConstructParam.ObjectConstructParam p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.ObjectConstructParam.ObjectConstructParam -> p)


-- | A structure which contains a single flags value, its name, and its
--   nickname.
module GI.GObject.Structs.FlagsValue
newtype FlagsValue
FlagsValue :: (ManagedPtr FlagsValue) -> FlagsValue

-- | Construct a <a>FlagsValue</a> struct initialized to zero.
newZeroFlagsValue :: MonadIO m => m FlagsValue
noFlagsValue :: Maybe FlagsValue
flagsValue_value :: AttrLabelProxy "value"
getFlagsValueValue :: MonadIO m => FlagsValue -> m Word32
setFlagsValueValue :: MonadIO m => FlagsValue -> Word32 -> m ()
clearFlagsValueValueName :: MonadIO m => FlagsValue -> m ()
flagsValue_valueName :: AttrLabelProxy "valueName"
getFlagsValueValueName :: MonadIO m => FlagsValue -> m (Maybe Text)
setFlagsValueValueName :: MonadIO m => FlagsValue -> CString -> m ()
clearFlagsValueValueNick :: MonadIO m => FlagsValue -> m ()
flagsValue_valueNick :: AttrLabelProxy "valueNick"
getFlagsValueValueNick :: MonadIO m => FlagsValue -> m (Maybe Text)
setFlagsValueValueNick :: MonadIO m => FlagsValue -> CString -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.FlagsValue.FlagsValue
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.FlagsValue.FlagsValue tag
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.FlagsValue.FlagsValueValueFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.FlagsValue.FlagsValueValueNameFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.FlagsValue.FlagsValueValueNickFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.FlagsValue.FlagsValue
instance (info ~ GI.GObject.Structs.FlagsValue.ResolveFlagsValueMethod t GI.GObject.Structs.FlagsValue.FlagsValue, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.FlagsValue.FlagsValue p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.FlagsValue.FlagsValue -> p)
instance (info ~ GI.GObject.Structs.FlagsValue.ResolveFlagsValueMethod t GI.GObject.Structs.FlagsValue.FlagsValue, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.FlagsValue.FlagsValue p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.FlagsValue.FlagsValue -> p)


-- | The class of a flags type holds information about its possible values.
module GI.GObject.Structs.FlagsClass
newtype FlagsClass
FlagsClass :: (ManagedPtr FlagsClass) -> FlagsClass

-- | Construct a <a>FlagsClass</a> struct initialized to zero.
newZeroFlagsClass :: MonadIO m => m FlagsClass
noFlagsClass :: Maybe FlagsClass
flagsClass_gTypeClass :: AttrLabelProxy "gTypeClass"
getFlagsClassGTypeClass :: MonadIO m => FlagsClass -> m TypeClass
flagsClass_mask :: AttrLabelProxy "mask"
getFlagsClassMask :: MonadIO m => FlagsClass -> m Word32
setFlagsClassMask :: MonadIO m => FlagsClass -> Word32 -> m ()
flagsClass_nValues :: AttrLabelProxy "nValues"
getFlagsClassNValues :: MonadIO m => FlagsClass -> m Word32
setFlagsClassNValues :: MonadIO m => FlagsClass -> Word32 -> m ()
clearFlagsClassValues :: MonadIO m => FlagsClass -> m ()
flagsClass_values :: AttrLabelProxy "values"
getFlagsClassValues :: MonadIO m => FlagsClass -> m (Maybe FlagsValue)
setFlagsClassValues :: MonadIO m => FlagsClass -> Ptr FlagsValue -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.FlagsClass.FlagsClass
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.FlagsClass.FlagsClass tag
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.FlagsClass.FlagsClassGTypeClassFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.FlagsClass.FlagsClassMaskFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.FlagsClass.FlagsClassNValuesFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.FlagsClass.FlagsClassValuesFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.FlagsClass.FlagsClass
instance (info ~ GI.GObject.Structs.FlagsClass.ResolveFlagsClassMethod t GI.GObject.Structs.FlagsClass.FlagsClass, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.FlagsClass.FlagsClass p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.FlagsClass.FlagsClass -> p)
instance (info ~ GI.GObject.Structs.FlagsClass.ResolveFlagsClassMethod t GI.GObject.Structs.FlagsClass.FlagsClass, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.FlagsClass.FlagsClass p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.FlagsClass.FlagsClass -> p)


-- | A structure which contains a single enum value, its name, and its
--   nickname.
module GI.GObject.Structs.EnumValue
newtype EnumValue
EnumValue :: (ManagedPtr EnumValue) -> EnumValue

-- | Construct a <a>EnumValue</a> struct initialized to zero.
newZeroEnumValue :: MonadIO m => m EnumValue
noEnumValue :: Maybe EnumValue
enumValue_value :: AttrLabelProxy "value"
getEnumValueValue :: MonadIO m => EnumValue -> m Int32
setEnumValueValue :: MonadIO m => EnumValue -> Int32 -> m ()
clearEnumValueValueName :: MonadIO m => EnumValue -> m ()
enumValue_valueName :: AttrLabelProxy "valueName"
getEnumValueValueName :: MonadIO m => EnumValue -> m (Maybe Text)
setEnumValueValueName :: MonadIO m => EnumValue -> CString -> m ()
clearEnumValueValueNick :: MonadIO m => EnumValue -> m ()
enumValue_valueNick :: AttrLabelProxy "valueNick"
getEnumValueValueNick :: MonadIO m => EnumValue -> m (Maybe Text)
setEnumValueValueNick :: MonadIO m => EnumValue -> CString -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.EnumValue.EnumValue
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.EnumValue.EnumValue tag
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.EnumValue.EnumValueValueFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.EnumValue.EnumValueValueNameFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.EnumValue.EnumValueValueNickFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.EnumValue.EnumValue
instance (info ~ GI.GObject.Structs.EnumValue.ResolveEnumValueMethod t GI.GObject.Structs.EnumValue.EnumValue, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.EnumValue.EnumValue p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.EnumValue.EnumValue -> p)
instance (info ~ GI.GObject.Structs.EnumValue.ResolveEnumValueMethod t GI.GObject.Structs.EnumValue.EnumValue, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.EnumValue.EnumValue p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.EnumValue.EnumValue -> p)


-- | The class of an enumeration type holds information about its possible
--   values.
module GI.GObject.Structs.EnumClass
newtype EnumClass
EnumClass :: (ManagedPtr EnumClass) -> EnumClass

-- | Construct a <a>EnumClass</a> struct initialized to zero.
newZeroEnumClass :: MonadIO m => m EnumClass
noEnumClass :: Maybe EnumClass
enumClass_gTypeClass :: AttrLabelProxy "gTypeClass"
getEnumClassGTypeClass :: MonadIO m => EnumClass -> m TypeClass
enumClass_maximum :: AttrLabelProxy "maximum"
getEnumClassMaximum :: MonadIO m => EnumClass -> m Int32
setEnumClassMaximum :: MonadIO m => EnumClass -> Int32 -> m ()
enumClass_minimum :: AttrLabelProxy "minimum"
getEnumClassMinimum :: MonadIO m => EnumClass -> m Int32
setEnumClassMinimum :: MonadIO m => EnumClass -> Int32 -> m ()
enumClass_nValues :: AttrLabelProxy "nValues"
getEnumClassNValues :: MonadIO m => EnumClass -> m Word32
setEnumClassNValues :: MonadIO m => EnumClass -> Word32 -> m ()
clearEnumClassValues :: MonadIO m => EnumClass -> m ()
enumClass_values :: AttrLabelProxy "values"
getEnumClassValues :: MonadIO m => EnumClass -> m (Maybe EnumValue)
setEnumClassValues :: MonadIO m => EnumClass -> Ptr EnumValue -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.EnumClass.EnumClass
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.EnumClass.EnumClass tag
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.EnumClass.EnumClassGTypeClassFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.EnumClass.EnumClassMinimumFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.EnumClass.EnumClassMaximumFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.EnumClass.EnumClassNValuesFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.EnumClass.EnumClassValuesFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.EnumClass.EnumClass
instance (info ~ GI.GObject.Structs.EnumClass.ResolveEnumClassMethod t GI.GObject.Structs.EnumClass.EnumClass, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.EnumClass.EnumClass p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.EnumClass.EnumClass -> p)
instance (info ~ GI.GObject.Structs.EnumClass.ResolveEnumClassMethod t GI.GObject.Structs.EnumClass.EnumClass, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.EnumClass.EnumClass p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.EnumClass.EnumClass -> p)


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

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

-- | A <tt><i>GClosureMarshal</i></tt> 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) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type
--   <tt>gboolean (*callback) (gpointer instance, gint arg1, gpointer
--   user_data)</tt> where the <tt><i>gint</i></tt> parameter denotes a
--   flags type.
cClosureMarshalBOOLEAN_FLAGS :: (HasCallStack, MonadIO m) => Closure -> 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.
cClosureMarshalGeneric :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type <tt>gchar*
--   (*callback) (gpointer instance, GObject *arg1, gpointer arg2, gpointer
--   user_data)</tt>.
cClosureMarshalSTRING_OBJECTPOINTER :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type <tt>void
--   (*callback) (gpointer instance, gboolean arg1, gpointer
--   user_data)</tt>.
cClosureMarshalVOID_BOOLEAN :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type <tt>void
--   (*callback) (gpointer instance, GBoxed *arg1, gpointer
--   user_data)</tt>.
cClosureMarshalVOID_BOXED :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type <tt>void
--   (*callback) (gpointer instance, gchar arg1, gpointer user_data)</tt>.
cClosureMarshalVOID_CHAR :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type <tt>void
--   (*callback) (gpointer instance, gdouble arg1, gpointer
--   user_data)</tt>.
cClosureMarshalVOID_DOUBLE :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type <tt>void
--   (*callback) (gpointer instance, gint arg1, gpointer user_data)</tt>
--   where the <tt><i>gint</i></tt> parameter denotes an enumeration type..
cClosureMarshalVOID_ENUM :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type <tt>void
--   (*callback) (gpointer instance, gint arg1, gpointer user_data)</tt>
--   where the <tt><i>gint</i></tt> parameter denotes a flags type.
cClosureMarshalVOID_FLAGS :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type <tt>void
--   (*callback) (gpointer instance, gfloat arg1, gpointer user_data)</tt>.
cClosureMarshalVOID_FLOAT :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type <tt>void
--   (*callback) (gpointer instance, gint arg1, gpointer user_data)</tt>.
cClosureMarshalVOID_INT :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type <tt>void
--   (*callback) (gpointer instance, glong arg1, gpointer user_data)</tt>.
cClosureMarshalVOID_LONG :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type <tt>void
--   (*callback) (gpointer instance, GObject *arg1, gpointer
--   user_data)</tt>.
cClosureMarshalVOID_OBJECT :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type <tt>void
--   (*callback) (gpointer instance, GParamSpec *arg1, gpointer
--   user_data)</tt>.
cClosureMarshalVOID_PARAM :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type <tt>void
--   (*callback) (gpointer instance, gpointer arg1, gpointer
--   user_data)</tt>.
cClosureMarshalVOID_POINTER :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type <tt>void
--   (*callback) (gpointer instance, const gchar *arg1, gpointer
--   user_data)</tt>.
cClosureMarshalVOID_STRING :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type <tt>void
--   (*callback) (gpointer instance, guchar arg1, gpointer user_data)</tt>.
cClosureMarshalVOID_UCHAR :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type <tt>void
--   (*callback) (gpointer instance, guint arg1, gpointer user_data)</tt>.
cClosureMarshalVOID_UINT :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type <tt>void
--   (*callback) (gpointer instance, guint arg1, gpointer arg2, gpointer
--   user_data)</tt>.
cClosureMarshalVOID_UINTPOINTER :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type <tt>void
--   (*callback) (gpointer instance, gulong arg1, gpointer user_data)</tt>.
cClosureMarshalVOID_ULONG :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type <tt>void
--   (*callback) (gpointer instance, GVariant *arg1, gpointer
--   user_data)</tt>.
cClosureMarshalVOID_VARIANT :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()

-- | A marshaller for a <a>CClosure</a> with a callback of type <tt>void
--   (*callback) (gpointer instance, gpointer user_data)</tt>.
cClosureMarshalVOID_VOID :: (HasCallStack, MonadIO m) => Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
cClosure_callback :: AttrLabelProxy "callback"
clearCClosureCallback :: MonadIO m => CClosure -> m ()
getCClosureCallback :: MonadIO m => CClosure -> m (Ptr ())
setCClosureCallback :: MonadIO m => CClosure -> Ptr () -> m ()
cClosure_closure :: AttrLabelProxy "closure"
getCClosureClosure :: MonadIO m => CClosure -> m Closure
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.CClosure.CClosure
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.CClosure.CClosure tag
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.CClosure.CClosureClosureFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.CClosure.CClosureCallbackFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.CClosure.CClosure
instance (info ~ GI.GObject.Structs.CClosure.ResolveCClosureMethod t GI.GObject.Structs.CClosure.CClosure, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.CClosure.CClosure p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.CClosure.CClosure -> p)
instance (info ~ GI.GObject.Structs.CClosure.ResolveCClosureMethod t GI.GObject.Structs.CClosure.CClosure, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.CClosure.CClosure p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.CClosure.CClosure -> p)


module GI.GObject.Objects.ParamSpecVariant


module GI.GObject.Objects.ParamSpecValueArray


module GI.GObject.Objects.ParamSpecUnichar


module GI.GObject.Objects.ParamSpecULong


module GI.GObject.Objects.ParamSpecUInt64


module GI.GObject.Objects.ParamSpecUInt


module GI.GObject.Objects.ParamSpecUChar


module GI.GObject.Objects.ParamSpecString


module GI.GObject.Objects.ParamSpecPointer


module GI.GObject.Objects.ParamSpecParam


module GI.GObject.Objects.ParamSpecOverride


module GI.GObject.Objects.ParamSpecObject


module GI.GObject.Objects.ParamSpecLong


module GI.GObject.Objects.ParamSpecInt64


module GI.GObject.Objects.ParamSpecInt


module GI.GObject.Objects.ParamSpecGType


module GI.GObject.Objects.ParamSpecFloat


module GI.GObject.Objects.ParamSpecFlags


module GI.GObject.Objects.ParamSpecEnum


module GI.GObject.Objects.ParamSpecDouble


module GI.GObject.Objects.ParamSpecChar


module GI.GObject.Objects.ParamSpecBoxed


module GI.GObject.Objects.ParamSpecBoolean


module GI.GObject.Objects.ParamSpec


-- | All the fields in the GInitiallyUnowned structure are private to the
--   <a>InitiallyUnowned</a> implementation and should never be accessed
--   directly.
module GI.GObject.Objects.InitiallyUnowned
newtype InitiallyUnowned
InitiallyUnowned :: (ManagedPtr InitiallyUnowned) -> InitiallyUnowned
class GObject o => IsInitiallyUnowned o
toInitiallyUnowned :: IsInitiallyUnowned o => o -> IO InitiallyUnowned
noInitiallyUnowned :: Maybe InitiallyUnowned
instance Data.GI.Base.BasicTypes.GObject GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned a) => GI.GObject.Objects.InitiallyUnowned.IsInitiallyUnowned a
instance GI.GObject.Objects.InitiallyUnowned.IsInitiallyUnowned GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned
instance GI.GObject.Objects.Object.IsObject GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned
instance (info ~ GI.GObject.Objects.InitiallyUnowned.ResolveInitiallyUnownedMethod t GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned -> p)
instance (info ~ GI.GObject.Objects.InitiallyUnowned.ResolveInitiallyUnownedMethod t GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned -> p)
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Objects.InitiallyUnowned.InitiallyUnowned


-- | The GObject type system supports dynamic loading of types. The
--   <a>TypePlugin</a> interface is used to handle the lifecycle of
--   dynamically loaded 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:</li>
--   </ol>
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   new_type_id = g_type_register_dynamic (parent_type_id,
--                                          "TypeName",
--                                          new_type_plugin,
--                                          type_flags);
--   
--   </pre>
--   
--   where <i><tt>newTypePlugin</tt></i> is an implementation of the
--   <a>TypePlugin</a> interface.
--   
--   <ol>
--   <li>The type's implementation is referenced, e.g. through
--   <a>typeClassRef</a> or through
--   <tt><i>g_type_create_instance()</i></tt> (this is being called by
--   <tt><i>g_object_new()</i></tt>) or through one of the above done on a
--   type derived from <i><tt>newTypeId</tt></i>.</li>
--   <li>This causes the type system to load the type's implementation by
--   calling <a>typePluginUse</a> and <a>typePluginCompleteTypeInfo</a> on
--   <i><tt>newTypePlugin</tt></i>.</li>
--   <li>At some point the type's implementation isn't required anymore,
--   e.g. after <a>typeClassUnref</a> or <a>typeFreeInstance</a> (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 <a>typePluginCompleteTypeInfo</a> and then it calls
--   <a>typePluginUnuse</a> on <i><tt>newTypePlugin</tt></i>.</li>
--   <li>Things may repeat from the second step.</li>
--   </ol>
--   
--   So basically, you need to implement a <a>TypePlugin</a> 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
--   <a>typePluginCompleteTypeInfo</a> 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
--   <a>typePluginUse</a> and <a>typePluginCompleteTypeInfo</a> again when
--   the type is needed again.
--   
--   <a>TypeModule</a> is an implementation of <a>TypePlugin</a> that
--   already implements most of this except for the actual module loading
--   and unloading. It even handles multiple registered types per module.
module GI.GObject.Interfaces.TypePlugin
newtype TypePlugin
TypePlugin :: (ManagedPtr TypePlugin) -> TypePlugin
noTypePlugin :: Maybe TypePlugin
class ManagedPtrNewtype a => IsTypePlugin a
data TypePluginCompleteInterfaceInfoMethodInfo

-- | 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 ()
data TypePluginCompleteTypeInfoMethodInfo

-- | 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 ()
data TypePluginUnuseMethodInfo

-- | 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 ()
data TypePluginUseMethodInfo

-- | 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 GI.GObject.Interfaces.TypePlugin.IsTypePlugin GI.GObject.Interfaces.TypePlugin.TypePlugin
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Interfaces.TypePlugin.TypePlugin
instance (info ~ GI.GObject.Interfaces.TypePlugin.ResolveTypePluginMethod t GI.GObject.Interfaces.TypePlugin.TypePlugin, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Interfaces.TypePlugin.TypePlugin p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Interfaces.TypePlugin.TypePlugin -> p)
instance (info ~ GI.GObject.Interfaces.TypePlugin.ResolveTypePluginMethod t GI.GObject.Interfaces.TypePlugin.TypePlugin, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Interfaces.TypePlugin.TypePlugin p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Interfaces.TypePlugin.TypePlugin -> p)
instance (signature ~ (Data.GI.Base.GType.GType -> Data.GI.Base.GType.GType -> GI.GObject.Structs.InterfaceInfo.InterfaceInfo -> m ()), Control.Monad.IO.Class.MonadIO m, GI.GObject.Interfaces.TypePlugin.IsTypePlugin a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Interfaces.TypePlugin.TypePluginCompleteInterfaceInfoMethodInfo a signature
instance (signature ~ (Data.GI.Base.GType.GType -> GI.GObject.Structs.TypeInfo.TypeInfo -> GI.GObject.Structs.TypeValueTable.TypeValueTable -> m ()), Control.Monad.IO.Class.MonadIO m, GI.GObject.Interfaces.TypePlugin.IsTypePlugin a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Interfaces.TypePlugin.TypePluginCompleteTypeInfoMethodInfo a signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m, GI.GObject.Interfaces.TypePlugin.IsTypePlugin a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Interfaces.TypePlugin.TypePluginUnuseMethodInfo a signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m, GI.GObject.Interfaces.TypePlugin.IsTypePlugin a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Interfaces.TypePlugin.TypePluginUseMethodInfo a signature


-- | An opaque structure used as the base of all interface types.
module GI.GObject.Structs.TypeInterface
newtype TypeInterface
TypeInterface :: (ManagedPtr TypeInterface) -> TypeInterface

-- | Construct a <a>TypeInterface</a> struct initialized to zero.
newZeroTypeInterface :: MonadIO m => m TypeInterface
noTypeInterface :: Maybe 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 <a>TypeInterface</a> structure of an interface to which
--   the passed in class conforms.
typeInterfacePeek :: (HasCallStack, MonadIO m) => TypeClass -> GType -> m TypeInterface
data TypeInterfacePeekParentMethodInfo

-- | 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.
typeInterfacePrerequisites :: (HasCallStack, MonadIO m) => GType -> m [GType]
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.TypeInterface.TypeInterface
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.TypeInterface.TypeInterface tag
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.TypeInterface.TypeInterface
instance (signature ~ m GI.GObject.Structs.TypeInterface.TypeInterface, Control.Monad.IO.Class.MonadIO m) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Structs.TypeInterface.TypeInterfacePeekParentMethodInfo GI.GObject.Structs.TypeInterface.TypeInterface signature
instance (info ~ GI.GObject.Structs.TypeInterface.ResolveTypeInterfaceMethod t GI.GObject.Structs.TypeInterface.TypeInterface, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.TypeInterface.TypeInterface p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.TypeInterface.TypeInterface -> p)
instance (info ~ GI.GObject.Structs.TypeInterface.ResolveTypeInterfaceMethod t GI.GObject.Structs.TypeInterface.TypeInterface, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.TypeInterface.TypeInterface p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.TypeInterface.TypeInterface -> p)


module GI.GObject.Interfaces


module GI.GObject.Flags

-- | Bit masks used to check or determine specific characteristics of a
--   fundamental type.
data TypeFundamentalFlags

-- | Indicates a classed type
TypeFundamentalFlagsClassed :: TypeFundamentalFlags

-- | Indicates an instantiable type (implies classed)
TypeFundamentalFlagsInstantiatable :: TypeFundamentalFlags

-- | Indicates a flat derivable type
TypeFundamentalFlagsDerivable :: TypeFundamentalFlags

-- | Indicates a deep derivable type (implies derivable)
TypeFundamentalFlagsDeepDerivable :: TypeFundamentalFlags

-- | Catch-all for unknown values
AnotherTypeFundamentalFlags :: Int -> TypeFundamentalFlags

-- | Bit masks used to check or determine characteristics of a type.
data TypeFlags

-- | Indicates an abstract type. No instances can be created for an
--   abstract type
TypeFlagsAbstract :: TypeFlags

-- | Indicates an abstract value type, i.e. a type that introduces a value
--   table, but can't be used for <a>valueInit</a>
TypeFlagsValueAbstract :: TypeFlags

-- | Catch-all for unknown values
AnotherTypeFlags :: Int -> TypeFlags

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

-- | 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 be equal.
SignalMatchTypeDetail :: SignalMatchType

-- | The closure must be the same.
SignalMatchTypeClosure :: SignalMatchType

-- | The C closure callback must be the same.
SignalMatchTypeFunc :: SignalMatchType

-- | The closure data must be the same.
SignalMatchTypeData :: SignalMatchType

-- | Only unblocked signals may matched.
SignalMatchTypeUnblocked :: SignalMatchType

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

-- | The signal flags are used to specify a signal's behaviour, the overall
--   signal description outlines how especially the RUN flags control the
--   stages of a signal emission.
data SignalFlags

-- | Invoke the object method handler in the first emission stage.
SignalFlagsRunFirst :: SignalFlags

-- | Invoke the object method handler in the third emission stage.
SignalFlagsRunLast :: SignalFlags

-- | Invoke the object method handler in the last emission stage.
SignalFlagsRunCleanup :: SignalFlags

-- | Signals being emitted for an object while currently being in emission
--   for this very object will not be emitted recursively, but instead
--   cause the first emission to be restarted.
SignalFlagsNoRecurse :: SignalFlags

-- | This signal supports "::detail" appendices to the signal name upon
--   handler connections and emissions.
SignalFlagsDetailed :: SignalFlags

-- | Action signals are signals that may freely be emitted on alive objects
--   from user code via <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

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

-- | 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 connection flags are used to specify the behaviour of a signal's
--   connection.
data ConnectFlags

-- | whether the handler should be called before or after the default
--   handler of the signal.
ConnectFlagsAfter :: ConnectFlags

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

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

-- | 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.
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
instance GHC.Classes.Eq GI.GObject.Flags.BindingFlags
instance GHC.Show.Show GI.GObject.Flags.BindingFlags
instance GHC.Classes.Eq GI.GObject.Flags.ConnectFlags
instance GHC.Show.Show GI.GObject.Flags.ConnectFlags
instance GHC.Classes.Eq GI.GObject.Flags.ParamFlags
instance GHC.Show.Show GI.GObject.Flags.ParamFlags
instance GHC.Classes.Eq GI.GObject.Flags.SignalFlags
instance GHC.Show.Show GI.GObject.Flags.SignalFlags
instance GHC.Classes.Eq GI.GObject.Flags.SignalMatchType
instance GHC.Show.Show GI.GObject.Flags.SignalMatchType
instance GHC.Classes.Eq GI.GObject.Flags.TypeDebugFlags
instance GHC.Show.Show GI.GObject.Flags.TypeDebugFlags
instance GHC.Classes.Eq GI.GObject.Flags.TypeFlags
instance GHC.Show.Show GI.GObject.Flags.TypeFlags
instance GHC.Classes.Eq GI.GObject.Flags.TypeFundamentalFlags
instance GHC.Show.Show GI.GObject.Flags.TypeFundamentalFlags
instance GHC.Enum.Enum GI.GObject.Flags.TypeFundamentalFlags
instance GHC.Classes.Ord GI.GObject.Flags.TypeFundamentalFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GObject.Flags.TypeFundamentalFlags
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.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.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.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.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.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.BindingFlags
instance GHC.Classes.Ord GI.GObject.Flags.BindingFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.GObject.Flags.BindingFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GObject.Flags.BindingFlags


-- | <a>Binding</a> is the representation of a binding between a property
--   on a <a>Object</a> instance (or source) and another property on
--   another <a>Object</a> 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 <tt><i>g_object_set()</i></tt> 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 <a>Object</a> 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
--   <a>Object</a>::<tt><i>notify</i></tt> signal only if the value has
--   effectively been changed. A binding is implemented using the
--   <a>Object</a>::<tt><i>notify</i></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 <a>Object</a> 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.
--   
--   <a>Binding</a> is available since GObject 2.26
module GI.GObject.Objects.Binding
newtype Binding
Binding :: (ManagedPtr Binding) -> Binding
class GObject o => IsBinding o
toBinding :: IsBinding o => o -> IO Binding
noBinding :: Maybe Binding
data BindingGetFlagsMethodInfo

-- | Retrieves the flags passed when constructing the <a>Binding</a>.
bindingGetFlags :: (HasCallStack, MonadIO m, IsBinding a) => a -> m [BindingFlags]
data BindingGetSourceMethodInfo

-- | Retrieves the <a>Object</a> instance used as the source of the
--   binding.
bindingGetSource :: (HasCallStack, MonadIO m, IsBinding a) => a -> m Object
data BindingGetSourcePropertyMethodInfo

-- | Retrieves the name of the property of
--   <a>Binding</a>:<tt><i>source</i></tt> used as the source of the
--   binding.
bindingGetSourceProperty :: (HasCallStack, MonadIO m, IsBinding a) => a -> m Text
data BindingGetTargetMethodInfo

-- | Retrieves the <a>Object</a> instance used as the target of the
--   binding.
bindingGetTarget :: (HasCallStack, MonadIO m, IsBinding a) => a -> m Object
data BindingGetTargetPropertyMethodInfo

-- | Retrieves the name of the property of
--   <a>Binding</a>:<tt><i>target</i></tt> used as the target of the
--   binding.
bindingGetTargetProperty :: (HasCallStack, MonadIO m, IsBinding a) => a -> m Text
data BindingUnbindMethodInfo

-- | 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 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.
bindingUnbind :: (HasCallStack, MonadIO m, IsBinding a) => a -> m ()
data BindingFlagsPropertyInfo
bindingFlags :: AttrLabelProxy "flags"
constructBindingFlags :: (IsBinding o) => [BindingFlags] -> IO (GValueConstruct o)
getBindingFlags :: (MonadIO m, IsBinding o) => o -> m [BindingFlags]
data BindingSourcePropertyInfo
bindingSource :: AttrLabelProxy "source"
constructBindingSource :: (IsBinding o, IsObject a) => a -> IO (GValueConstruct o)
getBindingSource :: (MonadIO m, IsBinding o) => o -> m Object
data BindingSourcePropertyPropertyInfo
bindingSourceProperty :: AttrLabelProxy "sourceProperty"
constructBindingSourceProperty :: (IsBinding o) => Text -> IO (GValueConstruct o)
getBindingSourceProperty :: (MonadIO m, IsBinding o) => o -> m Text
data BindingTargetPropertyInfo
bindingTarget :: AttrLabelProxy "target"
constructBindingTarget :: (IsBinding o, IsObject a) => a -> IO (GValueConstruct o)
getBindingTarget :: (MonadIO m, IsBinding o) => o -> m Object
data BindingTargetPropertyPropertyInfo
bindingTargetProperty :: AttrLabelProxy "targetProperty"
constructBindingTargetProperty :: (IsBinding o) => Text -> IO (GValueConstruct o)
getBindingTargetProperty :: (MonadIO m, IsBinding o) => o -> m Text
instance Data.GI.Base.BasicTypes.GObject GI.GObject.Objects.Binding.Binding
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.GObject.Objects.Binding.Binding a) => GI.GObject.Objects.Binding.IsBinding a
instance GI.GObject.Objects.Binding.IsBinding GI.GObject.Objects.Binding.Binding
instance GI.GObject.Objects.Object.IsObject GI.GObject.Objects.Binding.Binding
instance (info ~ GI.GObject.Objects.Binding.ResolveBindingMethod t GI.GObject.Objects.Binding.Binding, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Objects.Binding.Binding p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Objects.Binding.Binding -> p)
instance (info ~ GI.GObject.Objects.Binding.ResolveBindingMethod t GI.GObject.Objects.Binding.Binding, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Objects.Binding.Binding p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Objects.Binding.Binding -> p)
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Objects.Binding.BindingFlagsPropertyInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Objects.Binding.BindingSourcePropertyInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Objects.Binding.BindingSourcePropertyPropertyInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Objects.Binding.BindingTargetPropertyInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Objects.Binding.BindingTargetPropertyPropertyInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Objects.Binding.Binding
instance (signature ~ m [GI.GObject.Flags.BindingFlags], Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Binding.IsBinding a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Binding.BindingGetFlagsMethodInfo a signature
instance (signature ~ m GI.GObject.Objects.Object.Object, Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Binding.IsBinding a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Binding.BindingGetSourceMethodInfo a signature
instance (signature ~ m Data.Text.Internal.Text, Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Binding.IsBinding a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Binding.BindingGetSourcePropertyMethodInfo a signature
instance (signature ~ m GI.GObject.Objects.Object.Object, Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Binding.IsBinding a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Binding.BindingGetTargetMethodInfo a signature
instance (signature ~ m Data.Text.Internal.Text, Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Binding.IsBinding a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Binding.BindingGetTargetPropertyMethodInfo a signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Binding.IsBinding a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Binding.BindingUnbindMethodInfo a signature


-- | All the fields in the GObject structure are private to the
--   <a>Object</a> implementation and should never be accessed directly.
module GI.GObject.Objects.Object
newtype Object
Object :: (ManagedPtr Object) -> Object
class GObject o => IsObject o
toObject :: IsObject o => o -> IO Object
noObject :: Maybe Object
data ObjectInterfaceListPropertiesMethodInfo
data ObjectBindPropertyMethodInfo

-- | 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:
--   
--   <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.
--   
--   A <a>Object</a> can have multiple bindings.
objectBindProperty :: (HasCallStack, MonadIO m, IsObject a, IsObject b) => a -> Text -> b -> Text -> [BindingFlags] -> m Binding
data ObjectBindPropertyFullMethodInfo

-- | 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.
objectBindPropertyFull :: (HasCallStack, MonadIO m, IsObject a, IsObject b) => a -> Text -> b -> Text -> [BindingFlags] -> Closure -> Closure -> m Binding

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

-- | 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>.
objectForceFloating :: (HasCallStack, MonadIO m, IsObject a) => a -> m ()
data ObjectFreezeNotifyMethodInfo

-- | 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</a>::<tt><i>notify</i></tt>
--   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 ()
data ObjectGetDataMethodInfo

-- | Gets a named field from the objects table of associations (see
--   <a>objectSetData</a>).
objectGetData :: (HasCallStack, MonadIO m, IsObject a) => a -> Text -> m (Ptr ())
data ObjectGetPropertyMethodInfo

-- | Gets a property of an object. <i><tt>value</tt></i> must have been
--   initialized to the expected type of the property (or a type to which
--   the expected type can be transformed) using <a>valueInit</a>.
--   
--   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 ()
data ObjectGetQdataMethodInfo

-- | 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 ())

-- | 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>.
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.
objectInterfaceInstallProperty :: (HasCallStack, MonadIO m) => TypeInterface -> GParamSpec -> m ()
data ObjectIsFloatingMethodInfo

-- | Checks whether <i><tt>object</tt></i> has a [floating][floating-ref]
--   reference.
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 <tt><i>G_PARAM_CONSTRUCT</i></tt>,
--   <tt><i>G_PARAM_CONSTRUCT_ONLY</i></tt>) which are not explicitly
--   specified are set to their default values.
objectNew :: (HasCallStack, MonadIO m) => GType -> [Parameter] -> m Object
data ObjectNotifyMethodInfo

-- | 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 ()
data ObjectNotifyByPspecMethodInfo

-- | 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>
--   enum
--   {
--     PROP_0,
--     PROP_FOO,
--     PROP_LAST
--   };
--   
--   static GParamSpec *properties[PROP_LAST];
--   
--   static void
--   my_object_class_init (MyObjectClass *klass)
--   {
--     properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
--                                              0, 100,
--                                              50,
--                                              G_PARAM_READWRITE);
--     g_object_class_install_property (gobject_class,
--                                      PROP_FOO,
--                                      properties[PROP_FOO]);
--   }
--   </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>
objectNotifyByPspec :: (HasCallStack, MonadIO m, IsObject a) => a -> GParamSpec -> m ()
data ObjectRefMethodInfo

-- | Increases the reference count of <i><tt>object</tt></i>.
objectRef :: (HasCallStack, MonadIO m, IsObject a) => a -> m Object
data ObjectRefSinkMethodInfo

-- | 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.
objectRefSink :: (HasCallStack, MonadIO m, IsObject a) => a -> m Object
data ObjectReplaceDataMethodInfo

-- | Compares the user data for the key <i><tt>key</tt></i> on
--   <i><tt>object</tt></i> with <i><tt>oldval</tt></i>, and if they are
--   the same, replaces <i><tt>oldval</tt></i> with <i><tt>newval</tt></i>.
--   
--   This is like a typical atomic compare-and-exchange operation, for user
--   data on an object.
--   
--   If the previous value was replaced then ownership of the old value
--   (<i><tt>oldval</tt></i>) is passed to the caller, including the
--   registered destroy notify for it (passed out in
--   <i><tt>oldDestroy</tt></i>). Its up to the caller to free this as he
--   wishes, which may or may not include using <i><tt>oldDestroy</tt></i>
--   as sometimes replacement should not destroy the object in the normal
--   way.
objectReplaceData :: (HasCallStack, MonadIO m, IsObject a) => a -> Text -> Ptr () -> Ptr () -> Maybe (DestroyNotify) -> Maybe (DestroyNotify) -> m Bool
data ObjectReplaceQdataMethodInfo

-- | Compares the user data for the key <i><tt>quark</tt></i> on
--   <i><tt>object</tt></i> with <i><tt>oldval</tt></i>, and if they are
--   the same, replaces <i><tt>oldval</tt></i> with <i><tt>newval</tt></i>.
--   
--   This is like a typical atomic compare-and-exchange operation, for user
--   data on an object.
--   
--   If the previous value was replaced then ownership of the old value
--   (<i><tt>oldval</tt></i>) is passed to the caller, including the
--   registered destroy notify for it (passed out in
--   <i><tt>oldDestroy</tt></i>). Its up to the caller to free this as he
--   wishes, which may or may not include using <i><tt>oldDestroy</tt></i>
--   as sometimes replacement should not destroy the object in the normal
--   way.
objectReplaceQdata :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> Ptr () -> Ptr () -> Maybe (DestroyNotify) -> Maybe (DestroyNotify) -> m Bool
data ObjectRunDisposeMethodInfo

-- | 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 ()
data ObjectSetDataMethodInfo

-- | Each object carries around a table of associations from strings to
--   pointers. This function lets you set an association.
--   
--   If the object already had an association with that name, the old
--   association will be destroyed.
objectSetData :: (HasCallStack, MonadIO m, IsObject a) => a -> Text -> Ptr () -> m ()
data ObjectSetPropertyMethodInfo

-- | Sets a property on an object.
objectSetProperty :: (HasCallStack, MonadIO m, IsObject a) => a -> Text -> GValue -> m ()
data ObjectStealDataMethodInfo

-- | 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 ())
data ObjectStealQdataMethodInfo

-- | 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");
--     // retrive the old string list
--     GList *list = g_object_steal_qdata (object, quark_string_list);
--   
--     // prepend new string
--     list = g_list_prepend (list, g_strdup (new_string));
--     // this changed 'list', so we need to set it again
--     g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
--   }
--   static void
--   free_string_list (gpointer data)
--   {
--     GList *node, *list = data;
--   
--     for (node = list; node; node = node-&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 ())
data ObjectThawNotifyMethodInfo

-- | 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</a>::<tt><i>notify</i></tt> 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 ()
data ObjectUnrefMethodInfo

-- | 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 ()
data ObjectWatchClosureMethodInfo

-- | 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 -> Closure -> m ()
type C_ObjectNotifyCallback = Ptr () -> Ptr GParamSpec -> Ptr () -> IO ()
type ObjectNotifyCallback = GParamSpec -> IO ()
data ObjectNotifySignalInfo
afterObjectNotify :: (IsObject a, MonadIO m) => a -> ObjectNotifyCallback -> m SignalHandlerId
genClosure_ObjectNotify :: ObjectNotifyCallback -> IO Closure
mk_ObjectNotifyCallback :: C_ObjectNotifyCallback -> IO (FunPtr C_ObjectNotifyCallback)
noObjectNotifyCallback :: Maybe ObjectNotifyCallback
onObjectNotify :: (IsObject a, MonadIO m) => a -> ObjectNotifyCallback -> m SignalHandlerId
wrap_ObjectNotifyCallback :: ObjectNotifyCallback -> Ptr () -> Ptr GParamSpec -> Ptr () -> IO ()
instance Data.GI.Base.BasicTypes.GObject GI.GObject.Objects.Object.Object
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.GObject.Objects.Object.Object a) => GI.GObject.Objects.Object.IsObject a
instance GI.GObject.Objects.Object.IsObject GI.GObject.Objects.Object.Object
instance (info ~ GI.GObject.Objects.Object.ResolveObjectMethod t GI.GObject.Objects.Object.Object, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Objects.Object.Object p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Objects.Object.Object -> p)
instance (info ~ GI.GObject.Objects.Object.ResolveObjectMethod t GI.GObject.Objects.Object.Object, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Objects.Object.Object p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Objects.Object.Object -> p)
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Objects.Object.Object
instance Data.GI.Base.Signals.SignalInfo GI.GObject.Objects.Object.ObjectNotifySignalInfo
instance (signature ~ (Data.Text.Internal.Text -> b -> Data.Text.Internal.Text -> [GI.GObject.Flags.BindingFlags] -> m GI.GObject.Objects.Binding.Binding), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a, GI.GObject.Objects.Object.IsObject b) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectBindPropertyMethodInfo a signature
instance (signature ~ (Data.Text.Internal.Text -> b -> Data.Text.Internal.Text -> [GI.GObject.Flags.BindingFlags] -> Data.GI.Base.Closure.Closure -> Data.GI.Base.Closure.Closure -> m GI.GObject.Objects.Binding.Binding), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a, GI.GObject.Objects.Object.IsObject b) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectBindPropertyFullMethodInfo a signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectForceFloatingMethodInfo a signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectFreezeNotifyMethodInfo a signature
instance (signature ~ (Data.Text.Internal.Text -> m (GHC.Ptr.Ptr ())), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectGetDataMethodInfo a signature
instance (signature ~ (Data.Text.Internal.Text -> Data.GI.Base.GValue.GValue -> m ()), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectGetPropertyMethodInfo a signature
instance (signature ~ (GHC.Word.Word32 -> m (GHC.Ptr.Ptr ())), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectGetQdataMethodInfo a signature
instance (signature ~ m GHC.Types.Bool, Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectIsFloatingMethodInfo a signature
instance (signature ~ (Data.Text.Internal.Text -> m ()), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectNotifyMethodInfo a signature
instance (signature ~ (Data.GI.Base.BasicTypes.GParamSpec -> m ()), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectNotifyByPspecMethodInfo a signature
instance (signature ~ m GI.GObject.Objects.Object.Object, Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectRefMethodInfo a signature
instance (signature ~ m GI.GObject.Objects.Object.Object, Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectRefSinkMethodInfo a signature
instance (signature ~ (Data.Text.Internal.Text -> GHC.Ptr.Ptr () -> GHC.Ptr.Ptr () -> GHC.Base.Maybe GI.GLib.Callbacks.DestroyNotify -> GHC.Base.Maybe GI.GLib.Callbacks.DestroyNotify -> m GHC.Types.Bool), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectReplaceDataMethodInfo a signature
instance (signature ~ (GHC.Word.Word32 -> GHC.Ptr.Ptr () -> GHC.Ptr.Ptr () -> GHC.Base.Maybe GI.GLib.Callbacks.DestroyNotify -> GHC.Base.Maybe GI.GLib.Callbacks.DestroyNotify -> m GHC.Types.Bool), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectReplaceQdataMethodInfo a signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectRunDisposeMethodInfo a signature
instance (signature ~ (Data.Text.Internal.Text -> GHC.Ptr.Ptr () -> m ()), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectSetDataMethodInfo a signature
instance (signature ~ (Data.Text.Internal.Text -> Data.GI.Base.GValue.GValue -> m ()), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectSetPropertyMethodInfo a signature
instance (signature ~ (Data.Text.Internal.Text -> m (GHC.Ptr.Ptr ())), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectStealDataMethodInfo a signature
instance (signature ~ (GHC.Word.Word32 -> m (GHC.Ptr.Ptr ())), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectStealQdataMethodInfo a signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectThawNotifyMethodInfo a signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectUnrefMethodInfo a signature
instance (signature ~ (Data.GI.Base.Closure.Closure -> m ()), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.Object.IsObject a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectWatchClosureMethodInfo a signature
instance (p ~ (), o ~ Data.GI.Base.Overloading.MethodResolutionFailed "interfaceListProperties" GI.GObject.Objects.Object.Object) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.Object.ObjectInterfaceListPropertiesMethodInfo o p


-- | <a>TypeModule</a> provides a simple implementation of the
--   <a>TypePlugin</a> interface. The model of <a>TypeModule</a> 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 unref cannot happen in module code, since
--   that would lead to the caller's code being unloaded before
--   <a>objectUnref</a> 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, <a>typeModuleUse</a> 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, <a>typeModuleUnuse</a> is called.
--   
--   <a>TypeModule</a> does not actually provide any implementation of
--   module loading and unloading. To create a particular module type you
--   must derive from <a>TypeModule</a> and implement the load and unload
--   functions in <a>TypeModuleClass</a>.
module GI.GObject.Objects.TypeModule
newtype TypeModule
TypeModule :: (ManagedPtr TypeModule) -> TypeModule
class GObject o => IsTypeModule o
toTypeModule :: IsTypeModule o => o -> IO TypeModule
noTypeModule :: Maybe TypeModule
data TypeModuleAddInterfaceMethodInfo

-- | 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.
typeModuleAddInterface :: (HasCallStack, MonadIO m, IsTypeModule a) => a -> GType -> GType -> InterfaceInfo -> m ()
data TypeModuleRegisterEnumMethodInfo

-- | 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.
typeModuleRegisterEnum :: (HasCallStack, MonadIO m, IsTypeModule a) => a -> Text -> EnumValue -> m GType
data TypeModuleRegisterFlagsMethodInfo

-- | 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.
typeModuleRegisterFlags :: (HasCallStack, MonadIO m, IsTypeModule a) => a -> Text -> FlagsValue -> m GType
data TypeModuleRegisterTypeMethodInfo

-- | 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.
typeModuleRegisterType :: (HasCallStack, MonadIO m, IsTypeModule a) => a -> GType -> Text -> TypeInfo -> [TypeFlags] -> m GType
data TypeModuleSetNameMethodInfo

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

-- | 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 ()
data TypeModuleUseMethodInfo

-- | 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 Data.GI.Base.BasicTypes.GObject GI.GObject.Objects.TypeModule.TypeModule
instance (Data.GI.Base.BasicTypes.GObject a, Data.GI.Base.Overloading.UnknownAncestorError GI.GObject.Objects.TypeModule.TypeModule a) => GI.GObject.Objects.TypeModule.IsTypeModule a
instance GI.GObject.Objects.TypeModule.IsTypeModule GI.GObject.Objects.TypeModule.TypeModule
instance GI.GObject.Objects.Object.IsObject GI.GObject.Objects.TypeModule.TypeModule
instance GI.GObject.Interfaces.TypePlugin.IsTypePlugin GI.GObject.Objects.TypeModule.TypeModule
instance (info ~ GI.GObject.Objects.TypeModule.ResolveTypeModuleMethod t GI.GObject.Objects.TypeModule.TypeModule, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Objects.TypeModule.TypeModule p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Objects.TypeModule.TypeModule -> p)
instance (info ~ GI.GObject.Objects.TypeModule.ResolveTypeModuleMethod t GI.GObject.Objects.TypeModule.TypeModule, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Objects.TypeModule.TypeModule p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Objects.TypeModule.TypeModule -> p)
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Objects.TypeModule.TypeModule
instance (signature ~ (Data.GI.Base.GType.GType -> Data.GI.Base.GType.GType -> GI.GObject.Structs.InterfaceInfo.InterfaceInfo -> m ()), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.TypeModule.IsTypeModule a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.TypeModule.TypeModuleAddInterfaceMethodInfo a signature
instance (signature ~ (Data.Text.Internal.Text -> GI.GObject.Structs.EnumValue.EnumValue -> m Data.GI.Base.GType.GType), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.TypeModule.IsTypeModule a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.TypeModule.TypeModuleRegisterEnumMethodInfo a signature
instance (signature ~ (Data.Text.Internal.Text -> GI.GObject.Structs.FlagsValue.FlagsValue -> m Data.GI.Base.GType.GType), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.TypeModule.IsTypeModule a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.TypeModule.TypeModuleRegisterFlagsMethodInfo a signature
instance (signature ~ (Data.GI.Base.GType.GType -> Data.Text.Internal.Text -> GI.GObject.Structs.TypeInfo.TypeInfo -> [GI.GObject.Flags.TypeFlags] -> m Data.GI.Base.GType.GType), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.TypeModule.IsTypeModule a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.TypeModule.TypeModuleRegisterTypeMethodInfo a signature
instance (signature ~ (Data.Text.Internal.Text -> m ()), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.TypeModule.IsTypeModule a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.TypeModule.TypeModuleSetNameMethodInfo a signature
instance (signature ~ m (), Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.TypeModule.IsTypeModule a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.TypeModule.TypeModuleUnuseMethodInfo a signature
instance (signature ~ m GHC.Types.Bool, Control.Monad.IO.Class.MonadIO m, GI.GObject.Objects.TypeModule.IsTypeModule a) => Data.GI.Base.Overloading.MethodInfo GI.GObject.Objects.TypeModule.TypeModuleUseMethodInfo a signature


module GI.GObject.Objects


-- | The <a>SignalInvocationHint</a> structure is used to pass on
--   additional information to callbacks during a signal emission.
module GI.GObject.Structs.SignalInvocationHint
newtype SignalInvocationHint
SignalInvocationHint :: (ManagedPtr SignalInvocationHint) -> SignalInvocationHint

-- | Construct a <a>SignalInvocationHint</a> struct initialized to zero.
newZeroSignalInvocationHint :: MonadIO m => m SignalInvocationHint
noSignalInvocationHint :: Maybe SignalInvocationHint
getSignalInvocationHintDetail :: MonadIO m => SignalInvocationHint -> m Word32
setSignalInvocationHintDetail :: MonadIO m => SignalInvocationHint -> Word32 -> m ()
signalInvocationHint_detail :: AttrLabelProxy "detail"
getSignalInvocationHintRunType :: MonadIO m => SignalInvocationHint -> m [SignalFlags]
setSignalInvocationHintRunType :: MonadIO m => SignalInvocationHint -> [SignalFlags] -> m ()
signalInvocationHint_runType :: AttrLabelProxy "runType"
getSignalInvocationHintSignalId :: MonadIO m => SignalInvocationHint -> m Word32
setSignalInvocationHintSignalId :: MonadIO m => SignalInvocationHint -> Word32 -> m ()
signalInvocationHint_signalId :: AttrLabelProxy "signalId"
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint tag
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.SignalInvocationHint.SignalInvocationHintSignalIdFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.SignalInvocationHint.SignalInvocationHintDetailFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.SignalInvocationHint.SignalInvocationHintRunTypeFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint
instance (info ~ GI.GObject.Structs.SignalInvocationHint.ResolveSignalInvocationHintMethod t GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint -> p)
instance (info ~ GI.GObject.Structs.SignalInvocationHint.ResolveSignalInvocationHintMethod t GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.SignalInvocationHint.SignalInvocationHint -> p)


-- | A structure holding in-depth information for a specific signal. It is
--   filled in by the <a>signalQuery</a> function.
module GI.GObject.Structs.SignalQuery
newtype SignalQuery
SignalQuery :: (ManagedPtr SignalQuery) -> SignalQuery

-- | Construct a <a>SignalQuery</a> struct initialized to zero.
newZeroSignalQuery :: MonadIO m => m SignalQuery
noSignalQuery :: Maybe SignalQuery
getSignalQueryItype :: MonadIO m => SignalQuery -> m GType
setSignalQueryItype :: MonadIO m => SignalQuery -> GType -> m ()
signalQuery_itype :: AttrLabelProxy "itype"
getSignalQueryNParams :: MonadIO m => SignalQuery -> m Word32
setSignalQueryNParams :: MonadIO m => SignalQuery -> Word32 -> m ()
signalQuery_nParams :: AttrLabelProxy "nParams"
getSignalQueryReturnType :: MonadIO m => SignalQuery -> m GType
setSignalQueryReturnType :: MonadIO m => SignalQuery -> GType -> m ()
signalQuery_returnType :: AttrLabelProxy "returnType"
getSignalQuerySignalFlags :: MonadIO m => SignalQuery -> m [SignalFlags]
setSignalQuerySignalFlags :: MonadIO m => SignalQuery -> [SignalFlags] -> m ()
signalQuery_signalFlags :: AttrLabelProxy "signalFlags"
getSignalQuerySignalId :: MonadIO m => SignalQuery -> m Word32
setSignalQuerySignalId :: MonadIO m => SignalQuery -> Word32 -> m ()
signalQuery_signalId :: AttrLabelProxy "signalId"
clearSignalQuerySignalName :: MonadIO m => SignalQuery -> m ()
getSignalQuerySignalName :: MonadIO m => SignalQuery -> m (Maybe Text)
setSignalQuerySignalName :: MonadIO m => SignalQuery -> CString -> m ()
signalQuery_signalName :: AttrLabelProxy "signalName"
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.SignalQuery.SignalQuery
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.SignalQuery.SignalQuery tag
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.SignalQuery.SignalQuerySignalIdFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.SignalQuery.SignalQuerySignalNameFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.SignalQuery.SignalQueryItypeFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.SignalQuery.SignalQuerySignalFlagsFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.SignalQuery.SignalQueryReturnTypeFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.SignalQuery.SignalQueryNParamsFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.SignalQuery.SignalQuery
instance (info ~ GI.GObject.Structs.SignalQuery.ResolveSignalQueryMethod t GI.GObject.Structs.SignalQuery.SignalQuery, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.SignalQuery.SignalQuery p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.SignalQuery.SignalQuery -> p)
instance (info ~ GI.GObject.Structs.SignalQuery.ResolveSignalQueryMethod t GI.GObject.Structs.SignalQuery.SignalQuery, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.SignalQuery.SignalQuery p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.SignalQuery.SignalQuery -> p)


-- | A structure that provides information to the type system which is used
--   specifically for managing fundamental types.
module GI.GObject.Structs.TypeFundamentalInfo
newtype TypeFundamentalInfo
TypeFundamentalInfo :: (ManagedPtr TypeFundamentalInfo) -> TypeFundamentalInfo

-- | Construct a <a>TypeFundamentalInfo</a> struct initialized to zero.
newZeroTypeFundamentalInfo :: MonadIO m => m TypeFundamentalInfo
noTypeFundamentalInfo :: Maybe TypeFundamentalInfo
getTypeFundamentalInfoTypeFlags :: MonadIO m => TypeFundamentalInfo -> m [TypeFundamentalFlags]
setTypeFundamentalInfoTypeFlags :: MonadIO m => TypeFundamentalInfo -> [TypeFundamentalFlags] -> m ()
typeFundamentalInfo_typeFlags :: AttrLabelProxy "typeFlags"
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.TypeFundamentalInfo.TypeFundamentalInfo
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.TypeFundamentalInfo.TypeFundamentalInfo tag
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeFundamentalInfo.TypeFundamentalInfoTypeFlagsFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.TypeFundamentalInfo.TypeFundamentalInfo
instance (info ~ GI.GObject.Structs.TypeFundamentalInfo.ResolveTypeFundamentalInfoMethod t GI.GObject.Structs.TypeFundamentalInfo.TypeFundamentalInfo, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.TypeFundamentalInfo.TypeFundamentalInfo p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.TypeFundamentalInfo.TypeFundamentalInfo -> p)
instance (info ~ GI.GObject.Structs.TypeFundamentalInfo.ResolveTypeFundamentalInfoMethod t GI.GObject.Structs.TypeFundamentalInfo.TypeFundamentalInfo, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.TypeFundamentalInfo.TypeFundamentalInfo p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.TypeFundamentalInfo.TypeFundamentalInfo -> p)


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.

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

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

-- | Last fundamental type number reserved for GLib.

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

-- | Last fundamental type number reserved for BSE.

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

-- | Shift value used in converting numbers to type IDs.

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

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

-- | A mask for all <a>SignalMatchType</a> bits.

-- | A mask for all <a>SignalFlags</a> bits.

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

-- | <a>ParamFlags</a> value alias for <a>ParamFlagsStaticName</a> |
--   <a>ParamFlagsStaticNick</a> | <a>ParamFlagsStaticBlurb</a>.
--   
--   Since 2.13.0

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


module GI.GObject.Callbacks
type BaseFinalizeFunc = TypeClass -> IO ()
type C_BaseFinalizeFunc = Ptr TypeClass -> IO ()
dynamic_BaseFinalizeFunc :: (HasCallStack, MonadIO m) => FunPtr C_BaseFinalizeFunc -> TypeClass -> m ()
genClosure_BaseFinalizeFunc :: BaseFinalizeFunc -> IO Closure
mk_BaseFinalizeFunc :: C_BaseFinalizeFunc -> IO (FunPtr C_BaseFinalizeFunc)
noBaseFinalizeFunc :: Maybe BaseFinalizeFunc
wrap_BaseFinalizeFunc :: Maybe (Ptr (FunPtr C_BaseFinalizeFunc)) -> BaseFinalizeFunc -> Ptr TypeClass -> IO ()
type BaseInitFunc = TypeClass -> IO ()
type C_BaseInitFunc = Ptr TypeClass -> IO ()
dynamic_BaseInitFunc :: (HasCallStack, MonadIO m) => FunPtr C_BaseInitFunc -> TypeClass -> m ()
genClosure_BaseInitFunc :: BaseInitFunc -> IO Closure
mk_BaseInitFunc :: C_BaseInitFunc -> IO (FunPtr C_BaseInitFunc)
noBaseInitFunc :: Maybe BaseInitFunc
wrap_BaseInitFunc :: Maybe (Ptr (FunPtr C_BaseInitFunc)) -> BaseInitFunc -> Ptr TypeClass -> IO ()
type BindingTransformFunc = Binding -> GValue -> GValue -> IO Bool
type BindingTransformFunc_WithClosures = Binding -> GValue -> GValue -> Ptr () -> IO Bool
type C_BindingTransformFunc = Ptr Binding -> Ptr GValue -> Ptr GValue -> Ptr () -> IO CInt
drop_closures_BindingTransformFunc :: BindingTransformFunc -> BindingTransformFunc_WithClosures
dynamic_BindingTransformFunc :: (HasCallStack, MonadIO m, IsBinding a) => FunPtr C_BindingTransformFunc -> a -> GValue -> GValue -> Ptr () -> m Bool
genClosure_BindingTransformFunc :: BindingTransformFunc -> IO Closure
mk_BindingTransformFunc :: C_BindingTransformFunc -> IO (FunPtr C_BindingTransformFunc)
noBindingTransformFunc :: Maybe BindingTransformFunc
noBindingTransformFunc_WithClosures :: Maybe BindingTransformFunc_WithClosures
wrap_BindingTransformFunc :: Maybe (Ptr (FunPtr C_BindingTransformFunc)) -> BindingTransformFunc_WithClosures -> Ptr Binding -> Ptr GValue -> Ptr GValue -> Ptr () -> IO CInt
type BoxedCopyFunc = Ptr () -> IO (Ptr ())
type C_BoxedCopyFunc = Ptr () -> IO (Ptr ())
dynamic_BoxedCopyFunc :: (HasCallStack, MonadIO m) => FunPtr C_BoxedCopyFunc -> Ptr () -> m (Ptr ())
genClosure_BoxedCopyFunc :: BoxedCopyFunc -> IO Closure
mk_BoxedCopyFunc :: C_BoxedCopyFunc -> IO (FunPtr C_BoxedCopyFunc)
noBoxedCopyFunc :: Maybe BoxedCopyFunc
wrap_BoxedCopyFunc :: Maybe (Ptr (FunPtr C_BoxedCopyFunc)) -> BoxedCopyFunc -> Ptr () -> IO (Ptr ())
type BoxedFreeFunc = Ptr () -> IO ()
type C_BoxedFreeFunc = Ptr () -> IO ()
dynamic_BoxedFreeFunc :: (HasCallStack, MonadIO m) => FunPtr C_BoxedFreeFunc -> Ptr () -> m ()
genClosure_BoxedFreeFunc :: BoxedFreeFunc -> IO Closure
mk_BoxedFreeFunc :: C_BoxedFreeFunc -> IO (FunPtr C_BoxedFreeFunc)
noBoxedFreeFunc :: Maybe BoxedFreeFunc
wrap_BoxedFreeFunc :: Maybe (Ptr (FunPtr C_BoxedFreeFunc)) -> BoxedFreeFunc -> Ptr () -> IO ()
type C_Callback = IO ()
type Callback = IO ()
dynamic_Callback :: (HasCallStack, MonadIO m) => FunPtr C_Callback -> m ()
genClosure_Callback :: Callback -> IO Closure
mk_Callback :: C_Callback -> IO (FunPtr C_Callback)
noCallback :: Maybe Callback
wrap_Callback :: Maybe (Ptr (FunPtr C_Callback)) -> Callback -> IO ()
type C_ClassFinalizeFunc = Ptr TypeClass -> Ptr () -> IO ()
type ClassFinalizeFunc = TypeClass -> Ptr () -> IO ()
dynamic_ClassFinalizeFunc :: (HasCallStack, MonadIO m) => FunPtr C_ClassFinalizeFunc -> TypeClass -> Ptr () -> m ()
genClosure_ClassFinalizeFunc :: ClassFinalizeFunc -> IO Closure
mk_ClassFinalizeFunc :: C_ClassFinalizeFunc -> IO (FunPtr C_ClassFinalizeFunc)
noClassFinalizeFunc :: Maybe ClassFinalizeFunc
wrap_ClassFinalizeFunc :: Maybe (Ptr (FunPtr C_ClassFinalizeFunc)) -> ClassFinalizeFunc -> Ptr TypeClass -> Ptr () -> IO ()
type C_ClassInitFunc = Ptr TypeClass -> Ptr () -> IO ()
type ClassInitFunc = TypeClass -> Ptr () -> IO ()
dynamic_ClassInitFunc :: (HasCallStack, MonadIO m) => FunPtr C_ClassInitFunc -> TypeClass -> Ptr () -> m ()
genClosure_ClassInitFunc :: ClassInitFunc -> IO Closure
mk_ClassInitFunc :: C_ClassInitFunc -> IO (FunPtr C_ClassInitFunc)
noClassInitFunc :: Maybe ClassInitFunc
wrap_ClassInitFunc :: Maybe (Ptr (FunPtr C_ClassInitFunc)) -> ClassInitFunc -> Ptr TypeClass -> Ptr () -> IO ()
type C_ClosureMarshalFieldCallback = Ptr Closure -> Ptr GValue -> Word32 -> Ptr GValue -> Ptr () -> Ptr () -> IO ()
type ClosureMarshalFieldCallback = Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> IO ()
dynamic_ClosureMarshalFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ClosureMarshalFieldCallback -> Closure -> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
genClosure_ClosureMarshalFieldCallback :: ClosureMarshalFieldCallback -> IO Closure
mk_ClosureMarshalFieldCallback :: C_ClosureMarshalFieldCallback -> IO (FunPtr C_ClosureMarshalFieldCallback)
noClosureMarshalFieldCallback :: Maybe ClosureMarshalFieldCallback
wrap_ClosureMarshalFieldCallback :: Maybe (Ptr (FunPtr C_ClosureMarshalFieldCallback)) -> ClosureMarshalFieldCallback -> Ptr Closure -> Ptr GValue -> Word32 -> Ptr GValue -> Ptr () -> Ptr () -> IO ()
type C_ClosureNotify = Ptr () -> Ptr Closure -> IO ()
type ClosureNotify = Ptr () -> Closure -> IO ()
dynamic_ClosureNotify :: (HasCallStack, MonadIO m) => FunPtr C_ClosureNotify -> Ptr () -> Closure -> m ()
genClosure_ClosureNotify :: ClosureNotify -> IO Closure
mk_ClosureNotify :: C_ClosureNotify -> IO (FunPtr C_ClosureNotify)
noClosureNotify :: Maybe ClosureNotify
wrap_ClosureNotify :: Maybe (Ptr (FunPtr C_ClosureNotify)) -> ClosureNotify -> Ptr () -> Ptr Closure -> IO ()
type C_InstanceInitFunc = Ptr TypeInstance -> Ptr TypeClass -> IO ()
type InstanceInitFunc = TypeInstance -> TypeClass -> IO ()
dynamic_InstanceInitFunc :: (HasCallStack, MonadIO m) => FunPtr C_InstanceInitFunc -> TypeInstance -> TypeClass -> m ()
genClosure_InstanceInitFunc :: InstanceInitFunc -> IO Closure
mk_InstanceInitFunc :: C_InstanceInitFunc -> IO (FunPtr C_InstanceInitFunc)
noInstanceInitFunc :: Maybe InstanceInitFunc
wrap_InstanceInitFunc :: Maybe (Ptr (FunPtr C_InstanceInitFunc)) -> InstanceInitFunc -> Ptr TypeInstance -> Ptr TypeClass -> IO ()
type C_InterfaceFinalizeFunc = Ptr TypeInterface -> Ptr () -> IO ()
type InterfaceFinalizeFunc = TypeInterface -> Ptr () -> IO ()
dynamic_InterfaceFinalizeFunc :: (HasCallStack, MonadIO m) => FunPtr C_InterfaceFinalizeFunc -> TypeInterface -> Ptr () -> m ()
genClosure_InterfaceFinalizeFunc :: InterfaceFinalizeFunc -> IO Closure
mk_InterfaceFinalizeFunc :: C_InterfaceFinalizeFunc -> IO (FunPtr C_InterfaceFinalizeFunc)
noInterfaceFinalizeFunc :: Maybe InterfaceFinalizeFunc
wrap_InterfaceFinalizeFunc :: Maybe (Ptr (FunPtr C_InterfaceFinalizeFunc)) -> InterfaceFinalizeFunc -> Ptr TypeInterface -> Ptr () -> IO ()
type C_InterfaceInitFunc = Ptr TypeInterface -> Ptr () -> IO ()
type InterfaceInitFunc = TypeInterface -> Ptr () -> IO ()
dynamic_InterfaceInitFunc :: (HasCallStack, MonadIO m) => FunPtr C_InterfaceInitFunc -> TypeInterface -> Ptr () -> m ()
genClosure_InterfaceInitFunc :: InterfaceInitFunc -> IO Closure
mk_InterfaceInitFunc :: C_InterfaceInitFunc -> IO (FunPtr C_InterfaceInitFunc)
noInterfaceInitFunc :: Maybe InterfaceInitFunc
wrap_InterfaceInitFunc :: Maybe (Ptr (FunPtr C_InterfaceInitFunc)) -> InterfaceInitFunc -> Ptr TypeInterface -> Ptr () -> IO ()
type C_ObjectFinalizeFunc = Ptr Object -> IO ()
type ObjectFinalizeFunc = Object -> IO ()
dynamic_ObjectFinalizeFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectFinalizeFunc -> a -> m ()
genClosure_ObjectFinalizeFunc :: ObjectFinalizeFunc -> IO Closure
mk_ObjectFinalizeFunc :: C_ObjectFinalizeFunc -> IO (FunPtr C_ObjectFinalizeFunc)
noObjectFinalizeFunc :: Maybe ObjectFinalizeFunc
wrap_ObjectFinalizeFunc :: Maybe (Ptr (FunPtr C_ObjectFinalizeFunc)) -> ObjectFinalizeFunc -> Ptr Object -> IO ()
type C_ObjectGetPropertyFunc = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()
type ObjectGetPropertyFunc = Object -> Word32 -> GValue -> GParamSpec -> IO ()
dynamic_ObjectGetPropertyFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectGetPropertyFunc -> a -> Word32 -> GValue -> GParamSpec -> m ()
genClosure_ObjectGetPropertyFunc :: ObjectGetPropertyFunc -> IO Closure
mk_ObjectGetPropertyFunc :: C_ObjectGetPropertyFunc -> IO (FunPtr C_ObjectGetPropertyFunc)
noObjectGetPropertyFunc :: Maybe ObjectGetPropertyFunc
wrap_ObjectGetPropertyFunc :: Maybe (Ptr (FunPtr C_ObjectGetPropertyFunc)) -> ObjectGetPropertyFunc -> Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()
type C_ObjectSetPropertyFunc = Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()
type ObjectSetPropertyFunc = Object -> Word32 -> GValue -> GParamSpec -> IO ()
dynamic_ObjectSetPropertyFunc :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ObjectSetPropertyFunc -> a -> Word32 -> GValue -> GParamSpec -> m ()
genClosure_ObjectSetPropertyFunc :: ObjectSetPropertyFunc -> IO Closure
mk_ObjectSetPropertyFunc :: C_ObjectSetPropertyFunc -> IO (FunPtr C_ObjectSetPropertyFunc)
noObjectSetPropertyFunc :: Maybe ObjectSetPropertyFunc
wrap_ObjectSetPropertyFunc :: Maybe (Ptr (FunPtr C_ObjectSetPropertyFunc)) -> ObjectSetPropertyFunc -> Ptr Object -> Word32 -> Ptr GValue -> Ptr GParamSpec -> IO ()
type C_ParamSpecTypeInfoFinalizeFieldCallback = Ptr GParamSpec -> IO ()
type ParamSpecTypeInfoFinalizeFieldCallback = GParamSpec -> IO ()
dynamic_ParamSpecTypeInfoFinalizeFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback -> GParamSpec -> m ()
genClosure_ParamSpecTypeInfoFinalizeFieldCallback :: ParamSpecTypeInfoFinalizeFieldCallback -> IO Closure
mk_ParamSpecTypeInfoFinalizeFieldCallback :: C_ParamSpecTypeInfoFinalizeFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback)
noParamSpecTypeInfoFinalizeFieldCallback :: Maybe ParamSpecTypeInfoFinalizeFieldCallback
wrap_ParamSpecTypeInfoFinalizeFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback)) -> ParamSpecTypeInfoFinalizeFieldCallback -> Ptr GParamSpec -> IO ()
type C_ParamSpecTypeInfoInstanceInitFieldCallback = Ptr GParamSpec -> IO ()
type ParamSpecTypeInfoInstanceInitFieldCallback = GParamSpec -> IO ()
dynamic_ParamSpecTypeInfoInstanceInitFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback -> GParamSpec -> m ()
genClosure_ParamSpecTypeInfoInstanceInitFieldCallback :: ParamSpecTypeInfoInstanceInitFieldCallback -> IO Closure
mk_ParamSpecTypeInfoInstanceInitFieldCallback :: C_ParamSpecTypeInfoInstanceInitFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback)
noParamSpecTypeInfoInstanceInitFieldCallback :: Maybe ParamSpecTypeInfoInstanceInitFieldCallback
wrap_ParamSpecTypeInfoInstanceInitFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback)) -> ParamSpecTypeInfoInstanceInitFieldCallback -> Ptr GParamSpec -> IO ()
type C_ParamSpecTypeInfoValueSetDefaultFieldCallback = Ptr GParamSpec -> Ptr GValue -> IO ()
type ParamSpecTypeInfoValueSetDefaultFieldCallback = GParamSpec -> GValue -> IO ()
dynamic_ParamSpecTypeInfoValueSetDefaultFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback -> GParamSpec -> GValue -> m ()
genClosure_ParamSpecTypeInfoValueSetDefaultFieldCallback :: ParamSpecTypeInfoValueSetDefaultFieldCallback -> IO Closure
mk_ParamSpecTypeInfoValueSetDefaultFieldCallback :: C_ParamSpecTypeInfoValueSetDefaultFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback)
noParamSpecTypeInfoValueSetDefaultFieldCallback :: Maybe ParamSpecTypeInfoValueSetDefaultFieldCallback
wrap_ParamSpecTypeInfoValueSetDefaultFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback)) -> ParamSpecTypeInfoValueSetDefaultFieldCallback -> Ptr GParamSpec -> Ptr GValue -> IO ()
type C_ParamSpecTypeInfoValueValidateFieldCallback = Ptr GParamSpec -> Ptr GValue -> IO CInt
type ParamSpecTypeInfoValueValidateFieldCallback = GParamSpec -> GValue -> IO Bool
dynamic_ParamSpecTypeInfoValueValidateFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback -> GParamSpec -> GValue -> m Bool
genClosure_ParamSpecTypeInfoValueValidateFieldCallback :: ParamSpecTypeInfoValueValidateFieldCallback -> IO Closure
mk_ParamSpecTypeInfoValueValidateFieldCallback :: C_ParamSpecTypeInfoValueValidateFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback)
noParamSpecTypeInfoValueValidateFieldCallback :: Maybe ParamSpecTypeInfoValueValidateFieldCallback
wrap_ParamSpecTypeInfoValueValidateFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback)) -> ParamSpecTypeInfoValueValidateFieldCallback -> Ptr GParamSpec -> Ptr GValue -> IO CInt
type C_ParamSpecTypeInfoValuesCmpFieldCallback = Ptr GParamSpec -> Ptr GValue -> Ptr GValue -> IO Int32
type ParamSpecTypeInfoValuesCmpFieldCallback = GParamSpec -> GValue -> GValue -> IO Int32
dynamic_ParamSpecTypeInfoValuesCmpFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback -> GParamSpec -> GValue -> GValue -> m Int32
genClosure_ParamSpecTypeInfoValuesCmpFieldCallback :: ParamSpecTypeInfoValuesCmpFieldCallback -> IO Closure
mk_ParamSpecTypeInfoValuesCmpFieldCallback :: C_ParamSpecTypeInfoValuesCmpFieldCallback -> IO (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback)
noParamSpecTypeInfoValuesCmpFieldCallback :: Maybe ParamSpecTypeInfoValuesCmpFieldCallback
wrap_ParamSpecTypeInfoValuesCmpFieldCallback :: Maybe (Ptr (FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback)) -> ParamSpecTypeInfoValuesCmpFieldCallback -> Ptr GParamSpec -> Ptr GValue -> Ptr GValue -> IO Int32
type C_SignalAccumulator = Ptr SignalInvocationHint -> Ptr GValue -> Ptr GValue -> Ptr () -> IO CInt
type SignalAccumulator = SignalInvocationHint -> GValue -> GValue -> Ptr () -> IO Bool
dynamic_SignalAccumulator :: (HasCallStack, MonadIO m) => FunPtr C_SignalAccumulator -> SignalInvocationHint -> GValue -> GValue -> Ptr () -> m Bool
genClosure_SignalAccumulator :: SignalAccumulator -> IO Closure
mk_SignalAccumulator :: C_SignalAccumulator -> IO (FunPtr C_SignalAccumulator)
noSignalAccumulator :: Maybe SignalAccumulator
wrap_SignalAccumulator :: Maybe (Ptr (FunPtr C_SignalAccumulator)) -> SignalAccumulator -> Ptr SignalInvocationHint -> Ptr GValue -> Ptr GValue -> Ptr () -> IO CInt
type C_SignalEmissionHook = Ptr SignalInvocationHint -> Word32 -> Ptr GValue -> Ptr () -> IO CInt
type SignalEmissionHook = SignalInvocationHint -> [GValue] -> Ptr () -> IO Bool
dynamic_SignalEmissionHook :: (HasCallStack, MonadIO m) => FunPtr C_SignalEmissionHook -> SignalInvocationHint -> [GValue] -> Ptr () -> m Bool
genClosure_SignalEmissionHook :: SignalEmissionHook -> IO Closure
mk_SignalEmissionHook :: C_SignalEmissionHook -> IO (FunPtr C_SignalEmissionHook)
noSignalEmissionHook :: Maybe SignalEmissionHook
wrap_SignalEmissionHook :: Maybe (Ptr (FunPtr C_SignalEmissionHook)) -> SignalEmissionHook -> Ptr SignalInvocationHint -> Word32 -> Ptr GValue -> Ptr () -> IO CInt
type C_ToggleNotify = Ptr () -> Ptr Object -> CInt -> IO ()
type ToggleNotify = Ptr () -> Object -> Bool -> IO ()
dynamic_ToggleNotify :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_ToggleNotify -> Ptr () -> a -> Bool -> m ()
genClosure_ToggleNotify :: ToggleNotify -> IO Closure
mk_ToggleNotify :: C_ToggleNotify -> IO (FunPtr C_ToggleNotify)
noToggleNotify :: Maybe ToggleNotify
wrap_ToggleNotify :: Maybe (Ptr (FunPtr C_ToggleNotify)) -> ToggleNotify -> Ptr () -> Ptr Object -> CInt -> IO ()
type C_TypeClassCacheFunc = Ptr () -> Ptr TypeClass -> IO CInt
type TypeClassCacheFunc = Ptr () -> TypeClass -> IO Bool
dynamic_TypeClassCacheFunc :: (HasCallStack, MonadIO m) => FunPtr C_TypeClassCacheFunc -> Ptr () -> TypeClass -> m Bool
genClosure_TypeClassCacheFunc :: TypeClassCacheFunc -> IO Closure
mk_TypeClassCacheFunc :: C_TypeClassCacheFunc -> IO (FunPtr C_TypeClassCacheFunc)
noTypeClassCacheFunc :: Maybe TypeClassCacheFunc
wrap_TypeClassCacheFunc :: Maybe (Ptr (FunPtr C_TypeClassCacheFunc)) -> TypeClassCacheFunc -> Ptr () -> Ptr TypeClass -> IO CInt
type C_TypeInterfaceCheckFunc = Ptr () -> Ptr TypeInterface -> IO ()
type TypeInterfaceCheckFunc = Ptr () -> TypeInterface -> IO ()
dynamic_TypeInterfaceCheckFunc :: (HasCallStack, MonadIO m) => FunPtr C_TypeInterfaceCheckFunc -> Ptr () -> TypeInterface -> m ()
genClosure_TypeInterfaceCheckFunc :: TypeInterfaceCheckFunc -> IO Closure
mk_TypeInterfaceCheckFunc :: C_TypeInterfaceCheckFunc -> IO (FunPtr C_TypeInterfaceCheckFunc)
noTypeInterfaceCheckFunc :: Maybe TypeInterfaceCheckFunc
wrap_TypeInterfaceCheckFunc :: Maybe (Ptr (FunPtr C_TypeInterfaceCheckFunc)) -> TypeInterfaceCheckFunc -> Ptr () -> Ptr TypeInterface -> IO ()
type C_TypePluginCompleteInterfaceInfo = Ptr TypePlugin -> CGType -> CGType -> Ptr InterfaceInfo -> IO ()
type TypePluginCompleteInterfaceInfo = TypePlugin -> GType -> GType -> InterfaceInfo -> IO ()
dynamic_TypePluginCompleteInterfaceInfo :: (HasCallStack, MonadIO m, IsTypePlugin a) => FunPtr C_TypePluginCompleteInterfaceInfo -> a -> GType -> GType -> InterfaceInfo -> m ()
genClosure_TypePluginCompleteInterfaceInfo :: TypePluginCompleteInterfaceInfo -> IO Closure
mk_TypePluginCompleteInterfaceInfo :: C_TypePluginCompleteInterfaceInfo -> IO (FunPtr C_TypePluginCompleteInterfaceInfo)
noTypePluginCompleteInterfaceInfo :: Maybe TypePluginCompleteInterfaceInfo
wrap_TypePluginCompleteInterfaceInfo :: Maybe (Ptr (FunPtr C_TypePluginCompleteInterfaceInfo)) -> TypePluginCompleteInterfaceInfo -> Ptr TypePlugin -> CGType -> CGType -> Ptr InterfaceInfo -> IO ()
type C_TypePluginCompleteTypeInfo = Ptr TypePlugin -> CGType -> Ptr TypeInfo -> Ptr TypeValueTable -> IO ()
type TypePluginCompleteTypeInfo = TypePlugin -> GType -> TypeInfo -> TypeValueTable -> IO ()
dynamic_TypePluginCompleteTypeInfo :: (HasCallStack, MonadIO m, IsTypePlugin a) => FunPtr C_TypePluginCompleteTypeInfo -> a -> GType -> TypeInfo -> TypeValueTable -> m ()
genClosure_TypePluginCompleteTypeInfo :: TypePluginCompleteTypeInfo -> IO Closure
mk_TypePluginCompleteTypeInfo :: C_TypePluginCompleteTypeInfo -> IO (FunPtr C_TypePluginCompleteTypeInfo)
noTypePluginCompleteTypeInfo :: Maybe TypePluginCompleteTypeInfo
wrap_TypePluginCompleteTypeInfo :: Maybe (Ptr (FunPtr C_TypePluginCompleteTypeInfo)) -> TypePluginCompleteTypeInfo -> Ptr TypePlugin -> CGType -> Ptr TypeInfo -> Ptr TypeValueTable -> IO ()
type C_TypePluginUnuse = Ptr TypePlugin -> IO ()
type TypePluginUnuse = TypePlugin -> IO ()
dynamic_TypePluginUnuse :: (HasCallStack, MonadIO m, IsTypePlugin a) => FunPtr C_TypePluginUnuse -> a -> m ()
genClosure_TypePluginUnuse :: TypePluginUnuse -> IO Closure
mk_TypePluginUnuse :: C_TypePluginUnuse -> IO (FunPtr C_TypePluginUnuse)
noTypePluginUnuse :: Maybe TypePluginUnuse
wrap_TypePluginUnuse :: Maybe (Ptr (FunPtr C_TypePluginUnuse)) -> TypePluginUnuse -> Ptr TypePlugin -> IO ()
type C_TypePluginUse = Ptr TypePlugin -> IO ()
type TypePluginUse = TypePlugin -> IO ()
dynamic_TypePluginUse :: (HasCallStack, MonadIO m, IsTypePlugin a) => FunPtr C_TypePluginUse -> a -> m ()
genClosure_TypePluginUse :: TypePluginUse -> IO Closure
mk_TypePluginUse :: C_TypePluginUse -> IO (FunPtr C_TypePluginUse)
noTypePluginUse :: Maybe TypePluginUse
wrap_TypePluginUse :: Maybe (Ptr (FunPtr C_TypePluginUse)) -> TypePluginUse -> Ptr TypePlugin -> IO ()
type C_TypeValueTableCollectValueFieldCallback = Ptr GValue -> Word32 -> Ptr TypeCValue -> Word32 -> IO CString
type TypeValueTableCollectValueFieldCallback = GValue -> Word32 -> TypeCValue -> Word32 -> IO Text
dynamic_TypeValueTableCollectValueFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueTableCollectValueFieldCallback -> GValue -> Word32 -> TypeCValue -> Word32 -> m Text
genClosure_TypeValueTableCollectValueFieldCallback :: TypeValueTableCollectValueFieldCallback -> IO Closure
mk_TypeValueTableCollectValueFieldCallback :: C_TypeValueTableCollectValueFieldCallback -> IO (FunPtr C_TypeValueTableCollectValueFieldCallback)
noTypeValueTableCollectValueFieldCallback :: Maybe TypeValueTableCollectValueFieldCallback
wrap_TypeValueTableCollectValueFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableCollectValueFieldCallback)) -> TypeValueTableCollectValueFieldCallback -> Ptr GValue -> Word32 -> Ptr TypeCValue -> Word32 -> IO CString
type C_TypeValueTableLcopyValueFieldCallback = Ptr GValue -> Word32 -> Ptr TypeCValue -> Word32 -> IO CString
type TypeValueTableLcopyValueFieldCallback = GValue -> Word32 -> TypeCValue -> Word32 -> IO Text
dynamic_TypeValueTableLcopyValueFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueTableLcopyValueFieldCallback -> GValue -> Word32 -> TypeCValue -> Word32 -> m Text
genClosure_TypeValueTableLcopyValueFieldCallback :: TypeValueTableLcopyValueFieldCallback -> IO Closure
mk_TypeValueTableLcopyValueFieldCallback :: C_TypeValueTableLcopyValueFieldCallback -> IO (FunPtr C_TypeValueTableLcopyValueFieldCallback)
noTypeValueTableLcopyValueFieldCallback :: Maybe TypeValueTableLcopyValueFieldCallback
wrap_TypeValueTableLcopyValueFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableLcopyValueFieldCallback)) -> TypeValueTableLcopyValueFieldCallback -> Ptr GValue -> Word32 -> Ptr TypeCValue -> Word32 -> IO CString
type C_TypeValueTableValueCopyFieldCallback = Ptr GValue -> Ptr GValue -> IO ()
type TypeValueTableValueCopyFieldCallback = GValue -> GValue -> IO ()
dynamic_TypeValueTableValueCopyFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueTableValueCopyFieldCallback -> GValue -> GValue -> m ()
genClosure_TypeValueTableValueCopyFieldCallback :: TypeValueTableValueCopyFieldCallback -> IO Closure
mk_TypeValueTableValueCopyFieldCallback :: C_TypeValueTableValueCopyFieldCallback -> IO (FunPtr C_TypeValueTableValueCopyFieldCallback)
noTypeValueTableValueCopyFieldCallback :: Maybe TypeValueTableValueCopyFieldCallback
wrap_TypeValueTableValueCopyFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableValueCopyFieldCallback)) -> TypeValueTableValueCopyFieldCallback -> Ptr GValue -> Ptr GValue -> IO ()
type C_TypeValueTableValueFreeFieldCallback = Ptr GValue -> IO ()
type TypeValueTableValueFreeFieldCallback = GValue -> IO ()
dynamic_TypeValueTableValueFreeFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueTableValueFreeFieldCallback -> GValue -> m ()
genClosure_TypeValueTableValueFreeFieldCallback :: TypeValueTableValueFreeFieldCallback -> IO Closure
mk_TypeValueTableValueFreeFieldCallback :: C_TypeValueTableValueFreeFieldCallback -> IO (FunPtr C_TypeValueTableValueFreeFieldCallback)
noTypeValueTableValueFreeFieldCallback :: Maybe TypeValueTableValueFreeFieldCallback
wrap_TypeValueTableValueFreeFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableValueFreeFieldCallback)) -> TypeValueTableValueFreeFieldCallback -> Ptr GValue -> IO ()
type C_TypeValueTableValueInitFieldCallback = Ptr GValue -> IO ()
type TypeValueTableValueInitFieldCallback = GValue -> IO ()
dynamic_TypeValueTableValueInitFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueTableValueInitFieldCallback -> GValue -> m ()
genClosure_TypeValueTableValueInitFieldCallback :: TypeValueTableValueInitFieldCallback -> IO Closure
mk_TypeValueTableValueInitFieldCallback :: C_TypeValueTableValueInitFieldCallback -> IO (FunPtr C_TypeValueTableValueInitFieldCallback)
noTypeValueTableValueInitFieldCallback :: Maybe TypeValueTableValueInitFieldCallback
wrap_TypeValueTableValueInitFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableValueInitFieldCallback)) -> TypeValueTableValueInitFieldCallback -> Ptr GValue -> IO ()
type C_TypeValueTableValuePeekPointerFieldCallback = Ptr GValue -> IO (Ptr ())
type TypeValueTableValuePeekPointerFieldCallback = GValue -> IO (Ptr ())
dynamic_TypeValueTableValuePeekPointerFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_TypeValueTableValuePeekPointerFieldCallback -> GValue -> m (Ptr ())
genClosure_TypeValueTableValuePeekPointerFieldCallback :: TypeValueTableValuePeekPointerFieldCallback -> IO Closure
mk_TypeValueTableValuePeekPointerFieldCallback :: C_TypeValueTableValuePeekPointerFieldCallback -> IO (FunPtr C_TypeValueTableValuePeekPointerFieldCallback)
noTypeValueTableValuePeekPointerFieldCallback :: Maybe TypeValueTableValuePeekPointerFieldCallback
wrap_TypeValueTableValuePeekPointerFieldCallback :: Maybe (Ptr (FunPtr C_TypeValueTableValuePeekPointerFieldCallback)) -> TypeValueTableValuePeekPointerFieldCallback -> Ptr GValue -> IO (Ptr ())
type C_ValueTransform = Ptr GValue -> Ptr GValue -> IO ()
type ValueTransform = GValue -> GValue -> IO ()
dynamic_ValueTransform :: (HasCallStack, MonadIO m) => FunPtr C_ValueTransform -> GValue -> GValue -> m ()
genClosure_ValueTransform :: ValueTransform -> IO Closure
mk_ValueTransform :: C_ValueTransform -> IO (FunPtr C_ValueTransform)
noValueTransform :: Maybe ValueTransform
wrap_ValueTransform :: Maybe (Ptr (FunPtr C_ValueTransform)) -> ValueTransform -> Ptr GValue -> Ptr GValue -> IO ()
type C_WeakNotify = Ptr () -> Ptr Object -> IO ()
type WeakNotify = Ptr () -> Object -> IO ()
dynamic_WeakNotify :: (HasCallStack, MonadIO m, IsObject a) => FunPtr C_WeakNotify -> Ptr () -> a -> m ()
genClosure_WeakNotify :: WeakNotify -> IO Closure
mk_WeakNotify :: C_WeakNotify -> IO (FunPtr C_WeakNotify)
noWeakNotify :: Maybe WeakNotify
wrap_WeakNotify :: Maybe (Ptr (FunPtr C_WeakNotify)) -> WeakNotify -> Ptr () -> Ptr Object -> IO ()


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 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 EnumValue

-- | Looks up a <a>EnumValue</a> by name.
enumGetValueByName :: (HasCallStack, MonadIO m) => EnumClass -> Text -> m EnumValue

-- | Looks up a <a>EnumValue</a> by nickname.
enumGetValueByNick :: (HasCallStack, MonadIO m) => EnumClass -> Text -> m 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

-- | 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 FlagsValue

-- | Looks up a <a>FlagsValue</a> by name.
flagsGetValueByName :: (HasCallStack, MonadIO m) => FlagsClass -> Text -> m FlagsValue

-- | Looks up a <a>FlagsValue</a> by nickname.
flagsGetValueByNick :: (HasCallStack, MonadIO m) => FlagsClass -> Text -> m 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

-- | <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 -> Text -> 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 -> Text -> 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 -> Text -> 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 -> Text -> 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 -> Text -> 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 -> Text -> 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 -> Text -> 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.
paramSpecGtype :: (HasCallStack, MonadIO m) => Text -> Text -> 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 -> Text -> 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 -> Text -> 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 -> Text -> 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 -> Text -> 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 -> Text -> 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 -> Text -> 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 -> Text -> 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 -> Text -> 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 -> Text -> 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 -> Text -> 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 -> Text -> 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 -> Text -> 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.
paramSpecVariant :: (HasCallStack, MonadIO m) => Text -> Text -> 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

-- | 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").
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.
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 <tt><i>G_SIGNAL_NO_HOOKS</i></tt>
--   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
--   <tt><i>g_signal_override_class_handler()</i></tt>.
signalChainFromOverridden :: (HasCallStack, MonadIO m) => Ptr (Ptr GValue) -> GValue -> m ()

-- | Connects a closure to a signal for a particular object.
signalConnectClosure :: (HasCallStack, MonadIO m, IsObject a) => a -> Text -> Closure -> Bool -> m CULong

-- | Connects a closure to a signal for a particular object.
signalConnectClosureById :: (HasCallStack, MonadIO m, IsObject a) => a -> Word32 -> Word32 -> Closure -> Bool -> m CULong

-- | Emits a signal.
--   
--   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) => Ptr (Ptr GValue) -> Word32 -> Word32 -> m (GValue)

-- | Returns the invocation hint of the innermost signal emission of
--   instance.
signalGetInvocationHint :: (HasCallStack, MonadIO m, IsObject a) => a -> m SignalInvocationHint

-- | Blocks a handler of an instance so it will not be called during any
--   signal emissions unless it is unblocked again. Thus "blocking" a
--   signal handler means to temporarily deactive it, a signal handler has
--   to be unblocked exactly the same amount of times it has been blocked
--   before to become active again.
--   
--   The <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 (Closure) -> 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 an OR-ed combination of
--   <a>SignalMatchType</a> flags, and the criteria values are passed as
--   arguments. Passing at least one of the <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.
signalHandlersBlockMatched :: (HasCallStack, MonadIO m, IsObject a) => a -> [SignalMatchType] -> Word32 -> Word32 -> Maybe (Closure) -> 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 an OR-ed combination of
--   <a>SignalMatchType</a> flags, and the criteria values are passed as
--   arguments. Passing at least one of the <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.
signalHandlersDisconnectMatched :: (HasCallStack, MonadIO m, IsObject a) => a -> [SignalMatchType] -> Word32 -> Word32 -> Maybe (Closure) -> Ptr () -> Ptr () -> m Word32

-- | Unblocks all handlers on an instance that match a certain selection
--   criteria. The criteria mask is passed as an OR-ed combination of
--   <a>SignalMatchType</a> flags, and the criteria values are passed as
--   arguments. Passing at least one of the <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.
signalHandlersUnblockMatched :: (HasCallStack, MonadIO m, IsObject a) => a -> [SignalMatchType] -> Word32 -> Word32 -> Maybe (Closure) -> 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

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

-- | 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 -> Closure -> 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 Closure

-- | Set the callback for a source as a <a>Closure</a>.
--   
--   If the source is not one of the standard GLib types, the
--   <i><tt>closureCallback</tt></i> and <i><tt>closureMarshal</tt></i>
--   fields of the <a>SourceFuncs</a> structure must have been filled in
--   with pointers to appropriate functions.
sourceSetClosure :: (HasCallStack, MonadIO m) => Source -> Closure -> m ()

-- | Sets a dummy callback for <i><tt>source</tt></i>. The callback will do
--   nothing, and if the source expects a <a>Bool</a> return value, it will
--   return <a>True</a>. (If the source expects any other type of return
--   value, it will return a 0/<a>Nothing</a> value; whatever
--   <a>valueInit</a> initializes a <a>Value</a> to for that type.)
--   
--   If the source is not one of the standard GLib types, the
--   <i><tt>closureCallback</tt></i> and <i><tt>closureMarshal</tt></i>
--   fields of the <a>SourceFuncs</a> structure must have been filled in
--   with pointers to appropriate functions.
sourceSetDummyCallback :: (HasCallStack, MonadIO m) => Source -> m ()

-- | Return a newly allocated string, which describes the contents of a
--   <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.
typeAddClassPrivate :: (HasCallStack, MonadIO m) => GType -> Word64 -> m ()

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

-- | Adds the dynamic <i><tt>interfaceType</tt></i> to
--   <i><tt>instantiableType</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 the static <i><tt>interfaceType</tt></i> to
--   <i><tt>instantiableType</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.
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 initalized 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.
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.
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.
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 ()

-- | Lookup the type ID from a given type name, returning 0 if no type has
--   been registered under this name (this is the preferred method to find
--   out by name whether a specific type has been registered yet).
typeFromName :: (HasCallStack, MonadIO m) => Text -> m GType

-- | Internal function, used to extract the fundamental type ID portion.
--   Use <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
--   instance_count debug flag is set (by setting the GOBJECT_DEBUG
--   variable to include instance-count).
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.
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 GOBJECT_DEBUG
--   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 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 anchestry, 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.
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


module GI.GObject.Structs.ClosureNotifyData
newtype ClosureNotifyData
ClosureNotifyData :: (ManagedPtr ClosureNotifyData) -> ClosureNotifyData

-- | Construct a <a>ClosureNotifyData</a> struct initialized to zero.
newZeroClosureNotifyData :: MonadIO m => m ClosureNotifyData
noClosureNotifyData :: Maybe ClosureNotifyData
clearClosureNotifyDataData :: MonadIO m => ClosureNotifyData -> m ()
closureNotifyData_data :: AttrLabelProxy "data"
getClosureNotifyDataData :: MonadIO m => ClosureNotifyData -> m (Ptr ())
setClosureNotifyDataData :: MonadIO m => ClosureNotifyData -> Ptr () -> m ()
clearClosureNotifyDataNotify :: MonadIO m => ClosureNotifyData -> m ()
closureNotifyData_notify :: AttrLabelProxy "notify"
getClosureNotifyDataNotify :: MonadIO m => ClosureNotifyData -> m (Maybe ClosureNotify)
setClosureNotifyDataNotify :: MonadIO m => ClosureNotifyData -> FunPtr C_ClosureNotify -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.ClosureNotifyData.ClosureNotifyData
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.ClosureNotifyData.ClosureNotifyData tag
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.ClosureNotifyData.ClosureNotifyDataDataFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.ClosureNotifyData.ClosureNotifyDataNotifyFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.ClosureNotifyData.ClosureNotifyData
instance (info ~ GI.GObject.Structs.ClosureNotifyData.ResolveClosureNotifyDataMethod t GI.GObject.Structs.ClosureNotifyData.ClosureNotifyData, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.ClosureNotifyData.ClosureNotifyData p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.ClosureNotifyData.ClosureNotifyData -> p)
instance (info ~ GI.GObject.Structs.ClosureNotifyData.ResolveClosureNotifyDataMethod t GI.GObject.Structs.ClosureNotifyData.ClosureNotifyData, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.ClosureNotifyData.ClosureNotifyData p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.ClosureNotifyData.ClosureNotifyData -> p)


-- | A structure that provides information to the type system which is used
--   specifically for managing interface types.
module GI.GObject.Structs.InterfaceInfo
newtype InterfaceInfo
InterfaceInfo :: (ManagedPtr InterfaceInfo) -> InterfaceInfo

-- | Construct a <a>InterfaceInfo</a> struct initialized to zero.
newZeroInterfaceInfo :: MonadIO m => m InterfaceInfo
noInterfaceInfo :: Maybe InterfaceInfo
clearInterfaceInfoInterfaceData :: MonadIO m => InterfaceInfo -> m ()
getInterfaceInfoInterfaceData :: MonadIO m => InterfaceInfo -> m (Ptr ())
interfaceInfo_interfaceData :: AttrLabelProxy "interfaceData"
setInterfaceInfoInterfaceData :: MonadIO m => InterfaceInfo -> Ptr () -> m ()
clearInterfaceInfoInterfaceFinalize :: MonadIO m => InterfaceInfo -> m ()
getInterfaceInfoInterfaceFinalize :: MonadIO m => InterfaceInfo -> m (Maybe InterfaceFinalizeFunc)
interfaceInfo_interfaceFinalize :: AttrLabelProxy "interfaceFinalize"
setInterfaceInfoInterfaceFinalize :: MonadIO m => InterfaceInfo -> FunPtr C_InterfaceFinalizeFunc -> m ()
clearInterfaceInfoInterfaceInit :: MonadIO m => InterfaceInfo -> m ()
getInterfaceInfoInterfaceInit :: MonadIO m => InterfaceInfo -> m (Maybe InterfaceInitFunc)
interfaceInfo_interfaceInit :: AttrLabelProxy "interfaceInit"
setInterfaceInfoInterfaceInit :: MonadIO m => InterfaceInfo -> FunPtr C_InterfaceInitFunc -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.InterfaceInfo.InterfaceInfo
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.InterfaceInfo.InterfaceInfo tag
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.InterfaceInfo.InterfaceInfoInterfaceInitFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.InterfaceInfo.InterfaceInfoInterfaceFinalizeFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.InterfaceInfo.InterfaceInfoInterfaceDataFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.InterfaceInfo.InterfaceInfo
instance (info ~ GI.GObject.Structs.InterfaceInfo.ResolveInterfaceInfoMethod t GI.GObject.Structs.InterfaceInfo.InterfaceInfo, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.InterfaceInfo.InterfaceInfo p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.InterfaceInfo.InterfaceInfo -> p)
instance (info ~ GI.GObject.Structs.InterfaceInfo.ResolveInterfaceInfoMethod t GI.GObject.Structs.InterfaceInfo.InterfaceInfo, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.InterfaceInfo.InterfaceInfo p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.InterfaceInfo.InterfaceInfo -> p)


-- | 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
newtype ParamSpecTypeInfo
ParamSpecTypeInfo :: (ManagedPtr ParamSpecTypeInfo) -> ParamSpecTypeInfo

-- | Construct a <a>ParamSpecTypeInfo</a> struct initialized to zero.
newZeroParamSpecTypeInfo :: MonadIO m => m ParamSpecTypeInfo
noParamSpecTypeInfo :: Maybe ParamSpecTypeInfo
clearParamSpecTypeInfoFinalize :: MonadIO m => ParamSpecTypeInfo -> m ()
getParamSpecTypeInfoFinalize :: MonadIO m => ParamSpecTypeInfo -> m (Maybe ParamSpecTypeInfoFinalizeFieldCallback)
paramSpecTypeInfo_finalize :: AttrLabelProxy "finalize"
setParamSpecTypeInfoFinalize :: MonadIO m => ParamSpecTypeInfo -> FunPtr C_ParamSpecTypeInfoFinalizeFieldCallback -> m ()
clearParamSpecTypeInfoInstanceInit :: MonadIO m => ParamSpecTypeInfo -> m ()
getParamSpecTypeInfoInstanceInit :: MonadIO m => ParamSpecTypeInfo -> m (Maybe ParamSpecTypeInfoInstanceInitFieldCallback)
paramSpecTypeInfo_instanceInit :: AttrLabelProxy "instanceInit"
setParamSpecTypeInfoInstanceInit :: MonadIO m => ParamSpecTypeInfo -> FunPtr C_ParamSpecTypeInfoInstanceInitFieldCallback -> m ()
getParamSpecTypeInfoInstanceSize :: MonadIO m => ParamSpecTypeInfo -> m Word16
paramSpecTypeInfo_instanceSize :: AttrLabelProxy "instanceSize"
setParamSpecTypeInfoInstanceSize :: MonadIO m => ParamSpecTypeInfo -> Word16 -> m ()
getParamSpecTypeInfoNPreallocs :: MonadIO m => ParamSpecTypeInfo -> m Word16
paramSpecTypeInfo_nPreallocs :: AttrLabelProxy "nPreallocs"
setParamSpecTypeInfoNPreallocs :: MonadIO m => ParamSpecTypeInfo -> Word16 -> m ()
clearParamSpecTypeInfoValueSetDefault :: MonadIO m => ParamSpecTypeInfo -> m ()
getParamSpecTypeInfoValueSetDefault :: MonadIO m => ParamSpecTypeInfo -> m (Maybe ParamSpecTypeInfoValueSetDefaultFieldCallback)
paramSpecTypeInfo_valueSetDefault :: AttrLabelProxy "valueSetDefault"
setParamSpecTypeInfoValueSetDefault :: MonadIO m => ParamSpecTypeInfo -> FunPtr C_ParamSpecTypeInfoValueSetDefaultFieldCallback -> m ()
getParamSpecTypeInfoValueType :: MonadIO m => ParamSpecTypeInfo -> m GType
paramSpecTypeInfo_valueType :: AttrLabelProxy "valueType"
setParamSpecTypeInfoValueType :: MonadIO m => ParamSpecTypeInfo -> GType -> m ()
clearParamSpecTypeInfoValueValidate :: MonadIO m => ParamSpecTypeInfo -> m ()
getParamSpecTypeInfoValueValidate :: MonadIO m => ParamSpecTypeInfo -> m (Maybe ParamSpecTypeInfoValueValidateFieldCallback)
paramSpecTypeInfo_valueValidate :: AttrLabelProxy "valueValidate"
setParamSpecTypeInfoValueValidate :: MonadIO m => ParamSpecTypeInfo -> FunPtr C_ParamSpecTypeInfoValueValidateFieldCallback -> m ()
clearParamSpecTypeInfoValuesCmp :: MonadIO m => ParamSpecTypeInfo -> m ()
getParamSpecTypeInfoValuesCmp :: MonadIO m => ParamSpecTypeInfo -> m (Maybe ParamSpecTypeInfoValuesCmpFieldCallback)
paramSpecTypeInfo_valuesCmp :: AttrLabelProxy "valuesCmp"
setParamSpecTypeInfoValuesCmp :: MonadIO m => ParamSpecTypeInfo -> FunPtr C_ParamSpecTypeInfoValuesCmpFieldCallback -> m ()
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfo
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfo tag
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfoInstanceSizeFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfoNPreallocsFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfoInstanceInitFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfoValueTypeFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfoFinalizeFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfoValueSetDefaultFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfoValueValidateFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfoValuesCmpFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfo
instance (info ~ GI.GObject.Structs.ParamSpecTypeInfo.ResolveParamSpecTypeInfoMethod t GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfo, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfo p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfo -> p)
instance (info ~ GI.GObject.Structs.ParamSpecTypeInfo.ResolveParamSpecTypeInfoMethod t GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfo, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfo p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.ParamSpecTypeInfo.ParamSpecTypeInfo -> p)


-- | 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
newtype TypeInfo
TypeInfo :: (ManagedPtr TypeInfo) -> TypeInfo

-- | Construct a <a>TypeInfo</a> struct initialized to zero.
newZeroTypeInfo :: MonadIO m => m TypeInfo
noTypeInfo :: Maybe TypeInfo
clearTypeInfoBaseFinalize :: MonadIO m => TypeInfo -> m ()
getTypeInfoBaseFinalize :: MonadIO m => TypeInfo -> m (Maybe BaseFinalizeFunc)
setTypeInfoBaseFinalize :: MonadIO m => TypeInfo -> FunPtr C_BaseFinalizeFunc -> m ()
typeInfo_baseFinalize :: AttrLabelProxy "baseFinalize"
clearTypeInfoBaseInit :: MonadIO m => TypeInfo -> m ()
getTypeInfoBaseInit :: MonadIO m => TypeInfo -> m (Maybe BaseInitFunc)
setTypeInfoBaseInit :: MonadIO m => TypeInfo -> FunPtr C_BaseInitFunc -> m ()
typeInfo_baseInit :: AttrLabelProxy "baseInit"
clearTypeInfoClassData :: MonadIO m => TypeInfo -> m ()
getTypeInfoClassData :: MonadIO m => TypeInfo -> m (Ptr ())
setTypeInfoClassData :: MonadIO m => TypeInfo -> Ptr () -> m ()
typeInfo_classData :: AttrLabelProxy "classData"
clearTypeInfoClassFinalize :: MonadIO m => TypeInfo -> m ()
getTypeInfoClassFinalize :: MonadIO m => TypeInfo -> m (Maybe ClassFinalizeFunc)
setTypeInfoClassFinalize :: MonadIO m => TypeInfo -> FunPtr C_ClassFinalizeFunc -> m ()
typeInfo_classFinalize :: AttrLabelProxy "classFinalize"
clearTypeInfoClassInit :: MonadIO m => TypeInfo -> m ()
getTypeInfoClassInit :: MonadIO m => TypeInfo -> m (Maybe ClassInitFunc)
setTypeInfoClassInit :: MonadIO m => TypeInfo -> FunPtr C_ClassInitFunc -> m ()
typeInfo_classInit :: AttrLabelProxy "classInit"
getTypeInfoClassSize :: MonadIO m => TypeInfo -> m Word16
setTypeInfoClassSize :: MonadIO m => TypeInfo -> Word16 -> m ()
typeInfo_classSize :: AttrLabelProxy "classSize"
clearTypeInfoInstanceInit :: MonadIO m => TypeInfo -> m ()
getTypeInfoInstanceInit :: MonadIO m => TypeInfo -> m (Maybe InstanceInitFunc)
setTypeInfoInstanceInit :: MonadIO m => TypeInfo -> FunPtr C_InstanceInitFunc -> m ()
typeInfo_instanceInit :: AttrLabelProxy "instanceInit"
getTypeInfoInstanceSize :: MonadIO m => TypeInfo -> m Word16
setTypeInfoInstanceSize :: MonadIO m => TypeInfo -> Word16 -> m ()
typeInfo_instanceSize :: AttrLabelProxy "instanceSize"
getTypeInfoNPreallocs :: MonadIO m => TypeInfo -> m Word16
setTypeInfoNPreallocs :: MonadIO m => TypeInfo -> Word16 -> m ()
typeInfo_nPreallocs :: AttrLabelProxy "nPreallocs"
clearTypeInfoValueTable :: MonadIO m => TypeInfo -> m ()
getTypeInfoValueTable :: MonadIO m => TypeInfo -> m (Maybe TypeValueTable)
setTypeInfoValueTable :: MonadIO m => TypeInfo -> Ptr TypeValueTable -> m ()
typeInfo_valueTable :: AttrLabelProxy "valueTable"
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.TypeInfo.TypeInfo
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.TypeInfo.TypeInfo tag
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeInfo.TypeInfoClassSizeFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeInfo.TypeInfoBaseInitFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeInfo.TypeInfoBaseFinalizeFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeInfo.TypeInfoClassInitFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeInfo.TypeInfoClassFinalizeFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeInfo.TypeInfoClassDataFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeInfo.TypeInfoInstanceSizeFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeInfo.TypeInfoNPreallocsFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeInfo.TypeInfoInstanceInitFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeInfo.TypeInfoValueTableFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.TypeInfo.TypeInfo
instance (info ~ GI.GObject.Structs.TypeInfo.ResolveTypeInfoMethod t GI.GObject.Structs.TypeInfo.TypeInfo, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.TypeInfo.TypeInfo p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.TypeInfo.TypeInfo -> p)
instance (info ~ GI.GObject.Structs.TypeInfo.ResolveTypeInfoMethod t GI.GObject.Structs.TypeInfo.TypeInfo, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.TypeInfo.TypeInfo p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.TypeInfo.TypeInfo -> p)


-- | 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
newtype TypeValueTable
TypeValueTable :: (ManagedPtr TypeValueTable) -> TypeValueTable

-- | Construct a <a>TypeValueTable</a> struct initialized to zero.
newZeroTypeValueTable :: MonadIO m => m TypeValueTable
noTypeValueTable :: Maybe TypeValueTable
clearTypeValueTableCollectFormat :: MonadIO m => TypeValueTable -> m ()
getTypeValueTableCollectFormat :: MonadIO m => TypeValueTable -> m (Maybe Text)
setTypeValueTableCollectFormat :: MonadIO m => TypeValueTable -> CString -> m ()
typeValueTable_collectFormat :: AttrLabelProxy "collectFormat"
clearTypeValueTableCollectValue :: MonadIO m => TypeValueTable -> m ()
getTypeValueTableCollectValue :: MonadIO m => TypeValueTable -> m (Maybe TypeValueTableCollectValueFieldCallback)
setTypeValueTableCollectValue :: MonadIO m => TypeValueTable -> FunPtr C_TypeValueTableCollectValueFieldCallback -> m ()
typeValueTable_collectValue :: AttrLabelProxy "collectValue"
clearTypeValueTableLcopyFormat :: MonadIO m => TypeValueTable -> m ()
getTypeValueTableLcopyFormat :: MonadIO m => TypeValueTable -> m (Maybe Text)
setTypeValueTableLcopyFormat :: MonadIO m => TypeValueTable -> CString -> m ()
typeValueTable_lcopyFormat :: AttrLabelProxy "lcopyFormat"
clearTypeValueTableLcopyValue :: MonadIO m => TypeValueTable -> m ()
getTypeValueTableLcopyValue :: MonadIO m => TypeValueTable -> m (Maybe TypeValueTableLcopyValueFieldCallback)
setTypeValueTableLcopyValue :: MonadIO m => TypeValueTable -> FunPtr C_TypeValueTableLcopyValueFieldCallback -> m ()
typeValueTable_lcopyValue :: AttrLabelProxy "lcopyValue"
clearTypeValueTableValueCopy :: MonadIO m => TypeValueTable -> m ()
getTypeValueTableValueCopy :: MonadIO m => TypeValueTable -> m (Maybe TypeValueTableValueCopyFieldCallback)
setTypeValueTableValueCopy :: MonadIO m => TypeValueTable -> FunPtr C_TypeValueTableValueCopyFieldCallback -> m ()
typeValueTable_valueCopy :: AttrLabelProxy "valueCopy"
clearTypeValueTableValueFree :: MonadIO m => TypeValueTable -> m ()
getTypeValueTableValueFree :: MonadIO m => TypeValueTable -> m (Maybe TypeValueTableValueFreeFieldCallback)
setTypeValueTableValueFree :: MonadIO m => TypeValueTable -> FunPtr C_TypeValueTableValueFreeFieldCallback -> m ()
typeValueTable_valueFree :: AttrLabelProxy "valueFree"
clearTypeValueTableValueInit :: MonadIO m => TypeValueTable -> m ()
getTypeValueTableValueInit :: MonadIO m => TypeValueTable -> m (Maybe TypeValueTableValueInitFieldCallback)
setTypeValueTableValueInit :: MonadIO m => TypeValueTable -> FunPtr C_TypeValueTableValueInitFieldCallback -> m ()
typeValueTable_valueInit :: AttrLabelProxy "valueInit"
clearTypeValueTableValuePeekPointer :: MonadIO m => TypeValueTable -> m ()
getTypeValueTableValuePeekPointer :: MonadIO m => TypeValueTable -> m (Maybe TypeValueTableValuePeekPointerFieldCallback)
setTypeValueTableValuePeekPointer :: MonadIO m => TypeValueTable -> FunPtr C_TypeValueTableValuePeekPointerFieldCallback -> m ()
typeValueTable_valuePeekPointer :: AttrLabelProxy "valuePeekPointer"
instance Data.GI.Base.BasicTypes.WrappedPtr GI.GObject.Structs.TypeValueTable.TypeValueTable
instance tag ~ 'Data.GI.Base.Attributes.AttrSet => Data.GI.Base.Constructible.Constructible GI.GObject.Structs.TypeValueTable.TypeValueTable tag
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeValueTable.TypeValueTableValueInitFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeValueTable.TypeValueTableValueFreeFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeValueTable.TypeValueTableValueCopyFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeValueTable.TypeValueTableValuePeekPointerFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeValueTable.TypeValueTableCollectFormatFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeValueTable.TypeValueTableCollectValueFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeValueTable.TypeValueTableLcopyFormatFieldInfo
instance Data.GI.Base.Attributes.AttrInfo GI.GObject.Structs.TypeValueTable.TypeValueTableLcopyValueFieldInfo
instance Data.GI.Base.Overloading.HasAttributeList GI.GObject.Structs.TypeValueTable.TypeValueTable
instance (info ~ GI.GObject.Structs.TypeValueTable.ResolveTypeValueTableMethod t GI.GObject.Structs.TypeValueTable.TypeValueTable, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.TypeValueTable.TypeValueTable p) => Data.GI.Base.Overloading.IsLabelProxy t (GI.GObject.Structs.TypeValueTable.TypeValueTable -> p)
instance (info ~ GI.GObject.Structs.TypeValueTable.ResolveTypeValueTableMethod t GI.GObject.Structs.TypeValueTable.TypeValueTable, Data.GI.Base.Overloading.MethodInfo info GI.GObject.Structs.TypeValueTable.TypeValueTable p) => GHC.OverloadedLabels.IsLabel t (GI.GObject.Structs.TypeValueTable.TypeValueTable -> p)


module GI.GObject.Structs


module GI.GObject

module GI.GObject.PkgInfo
pkgConfigVersions :: [(String, String)]
flags :: [(String, Bool)]