-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Foundation for libraries generated by haskell-gi
--   
--   Foundation for libraries generated by haskell-gi
@package haskell-gi-base
@version 0.24.2


-- | A compatibility layer for <a>CallStack</a>, so that we can have
--   uniform signatures even in old GHC versions (even if the functionality
--   itself does not work there).
module Data.GI.Base.CallStack
type HasCallStack = ?callStack :: CallStack
data CallStack
prettyCallStack :: CallStack -> String
callStack :: HasCallStack => CallStack


-- | Basic types used in the bindings.
module Data.GI.Base.BasicTypes

-- | Thin wrapper over <a>ForeignPtr</a>, supporting the extra notion of
--   <tt>disowning</tt>, that is, not running the finalizers associated
--   with the foreign ptr.
data ManagedPtr a
ManagedPtr :: ForeignPtr a -> Maybe CallStack -> IORef (Maybe CallStack) -> ManagedPtr a
[managedForeignPtr] :: ManagedPtr a -> ForeignPtr a

-- | <a>CallStack</a> for the call that created the pointer.
[managedPtrAllocCallStack] :: ManagedPtr a -> Maybe CallStack

-- | When disowned, the <a>CallStack</a> for the disowning call.
[managedPtrIsDisowned] :: ManagedPtr a -> IORef (Maybe CallStack)

-- | A constraint ensuring that the given type is a newtype over a
--   <a>ManagedPtr</a>.
class Coercible a (ManagedPtr ()) => ManagedPtrNewtype a
toManagedPtr :: ManagedPtrNewtype a => a -> ManagedPtr a

-- | Pointers to chunks of memory which we know how to copy and release.
class ManagedPtrNewtype a => BoxedPtr a

-- | Make a copy of the given <a>BoxedPtr</a>.
boxedPtrCopy :: BoxedPtr a => a -> IO a

-- | A pointer to a function for freeing the given pointer.
boxedPtrFree :: BoxedPtr a => a -> IO ()

-- | A ptr to a memory block which we know how to allocate and fill with
--   zero.
class BoxedPtr a => CallocPtr a

-- | Allocate a zero-initialized block of memory for the given type.
boxedPtrCalloc :: CallocPtr a => IO (Ptr a)

-- | A common omission in the introspection data is missing (nullable)
--   annotations for return types, when they clearly are nullable. (A
--   common idiom is "Returns: valid value, or %NULL if something went
--   wrong.")
--   
--   Haskell wrappers will raise this exception if the return value is an
--   unexpected <a>nullPtr</a>.
data UnexpectedNullPointerReturn
UnexpectedNullPointerReturn :: Text -> UnexpectedNullPointerReturn
[nullPtrErrorMsg] :: UnexpectedNullPointerReturn -> Text

-- | A wrapped object that has an associated GLib type. This does not
--   necessarily descend from <a>GObject</a>, that constraint is
--   implemented by <a>GObject</a> below.
class HasParentTypes a => TypedObject a

-- | The <a>GType</a> for this object.
glibType :: TypedObject a => IO GType

-- | A wrapped <a>GObject</a>, or any other type that descends from it.
class (ManagedPtrNewtype a, TypedObject a) => GObject a

-- | A newtype for use on the haskell side.
newtype GType
GType :: CGType -> GType
[gtypeToCGType] :: GType -> CGType

-- | A type identifier in the GLib type system. This is the low-level type
--   associated with the representation in memory, when using this on the
--   Haskell side use <a>GType</a> below.
type CGType = Word64

-- | Get the name assigned to the given <a>GType</a>.
gtypeName :: GType -> IO String

-- | A <a>GVariant</a>. See <a>Data.GI.Base.GVariant</a> for further
--   methods.
newtype GVariant
GVariant :: ManagedPtr GVariant -> GVariant

-- | Chunks of memory whose allocation/deallocation info has been
--   registered with the GLib type system.
class (ManagedPtrNewtype a, TypedObject a) => GBoxed a

-- | Enums with an associated <a>GType</a>.
class TypedObject a => BoxedEnum a

-- | Flags with an associated <a>GType</a>.
class TypedObject a => BoxedFlags a

-- | A <a>GParamSpec</a>. See <a>Data.GI.Base.GParamSpec</a> for further
--   methods.
newtype GParamSpec
GParamSpec :: ManagedPtr GParamSpec -> GParamSpec

-- | A convenient synonym for <tt>Nothing :: Maybe GParamSpec</tt>.
noGParamSpec :: Maybe GParamSpec

-- | A <a>GArray</a>. Marshalling for this type is done in
--   <a>Data.GI.Base.BasicConversions</a>, it is mapped to a list on the
--   Haskell side.
data GArray a
GArray :: Ptr (GArray a) -> GArray a

-- | A <a>GPtrArray</a>. Marshalling for this type is done in
--   <a>Data.GI.Base.BasicConversions</a>, it is mapped to a list on the
--   Haskell side.
data GPtrArray a
GPtrArray :: Ptr (GPtrArray a) -> GPtrArray a

-- | A <a>GByteArray</a>. Marshalling for this type is done in
--   <a>Data.GI.Base.BasicConversions</a>, it is packed to a
--   <a>ByteString</a> on the Haskell side.
data GByteArray
GByteArray :: Ptr GByteArray -> GByteArray

-- | A <a>GHashTable</a>. It is mapped to a <a>Map</a> on the Haskell side.
data GHashTable a b
GHashTable :: Ptr (GHashTable a b) -> GHashTable a b

-- | A <a>GList</a>, mapped to a list on the Haskell side. Marshalling is
--   done in <a>Data.GI.Base.BasicConversions</a>.
data GList a
GList :: Ptr (GList a) -> GList a

-- | Free the given <a>GList</a>.
g_list_free :: Ptr (GList a) -> IO ()

-- | A <a>GSList</a>, mapped to a list on the Haskell side. Marshalling is
--   done in <a>Data.GI.Base.BasicConversions</a>.
data GSList a
GSList :: Ptr (GSList a) -> GSList a

-- | Free the given <a>GSList</a>.
g_slist_free :: Ptr (GSList a) -> IO ()

-- | An enum usable as a flag for a function.
class Enum a => IsGFlag a

-- | Some APIs, such as <a>GHashTable</a>, pass around scalar types wrapped
--   into a pointer. We encode such a type as follows.
newtype PtrWrapped a
PtrWrapped :: Ptr a -> PtrWrapped a
[unwrapPtr] :: PtrWrapped a -> Ptr a

-- | Destroy the memory associated with a given pointer.
type GDestroyNotify a = FunPtr (Ptr a -> IO ())
instance GHC.Show.Show Data.GI.Base.BasicTypes.UnexpectedNullPointerReturn
instance GHC.Exception.Type.Exception Data.GI.Base.BasicTypes.UnexpectedNullPointerReturn
instance GHC.Types.Coercible a (Data.GI.Base.BasicTypes.ManagedPtr ()) => Data.GI.Base.BasicTypes.ManagedPtrNewtype a
instance GHC.Classes.Eq (Data.GI.Base.BasicTypes.ManagedPtr a)


-- | Basic <a>GType</a>s.
module Data.GI.Base.GType

-- | <ul>
--   <li><i>Note: compile-time vs run-time GTypes</i></li>
--   </ul>
--   
--   Notice that there are two types of GType's: the fundamental ones,
--   which are created with G_TYPE_MAKE_FUNDAMENTAL(n) and always have the
--   same runtime representation, and the ones that are registered in the
--   GObject type system at runtime, and whose <a>CGType</a> may change for
--   each program run (and generally does).
--   
--   For the first type it is safe to use hsc to read the numerical values
--   of the CGType at compile type, but for the second type it is essential
--   to call the corresponding _get_type() function at runtime, and not use
--   the value of the corresponding "constant" at compile time via hsc.
--   
--   <a>GType</a> of strings.
gtypeString :: GType

-- | <a>GType</a> of pointers.
gtypePointer :: GType

-- | <a>GType</a> for signed integers (<tt>gint</tt> or <tt>gint32</tt>).
gtypeInt :: GType

-- | <a>GType</a> for unsigned integers (<tt>guint</tt> or
--   <tt>guint32</tt>).
gtypeUInt :: GType

-- | <a>GType</a> for <tt>glong</tt>.
gtypeLong :: GType

-- | <a>GType</a> for <tt>gulong</tt>.
gtypeULong :: GType

-- | <a>GType</a> for signed 64 bit integers.
gtypeInt64 :: GType

-- | <a>GType</a> for unsigned 64 bit integers.
gtypeUInt64 :: GType

-- | <a>GType</a> for floating point values.
gtypeFloat :: GType

-- | <a>GType</a> for gdouble.
gtypeDouble :: GType

-- | <a>GType</a> corresponding to gboolean.
gtypeBoolean :: GType

-- | The <a>GType</a> corresponding to <a>GError</a>.
gtypeError :: GType

-- | <a>GType</a> corresponding to a <a>GType</a> itself.
gtypeGType :: GType

-- | <a>GType</a> for a NULL terminated array of strings.
gtypeStrv :: GType

-- | <a>GType</a> corresponding to a boxed object.
gtypeBoxed :: GType

-- | <a>GType</a> corresponding to a <tt>GObject</tt>.
gtypeObject :: GType

-- | The <a>GType</a> corresponding to a <tt>GVariant</tt>.
gtypeVariant :: GType

-- | <a>GType</a> for a boxed type holding a <tt>GByteArray</tt>.
gtypeByteArray :: GType

-- | An invalid <a>GType</a> used as error return value in some functions
--   which return a <a>GType</a>.
gtypeInvalid :: GType

-- | The <a>GType</a> for boxed <tt>StablePtr</tt>s.
gtypeStablePtr :: GType


-- | Machinery for some basic support of <tt>GHashTable</tt>.
--   
--   The GLib <tt>GHashTable</tt> implementation requires two things: we
--   need to "pack" a datatype into a pointer (for datatypes that are
--   represented by pointers this is the trivial operation, for integers it
--   is not, and GLib has some helper macros).
--   
--   We also need to be able to hash and check for equality different
--   datatypes.
module Data.GI.Base.GHashTable

-- | A pointer to a hashing function on the C side.
type GHashFunc a = FunPtr (PtrWrapped a -> IO Word32)

-- | A pointer to an equality checking function on the C side.
type GEqualFunc a = FunPtr (PtrWrapped a -> PtrWrapped a -> IO Int32)

-- | Compute the hash for a <a>Ptr</a>.
gDirectHash :: GHashFunc (Ptr a)

-- | Check whether two pointers are equal.
gDirectEqual :: GEqualFunc (Ptr a)

-- | Pack a <a>Ptr</a> into a <a>PtrWrapped</a> <a>Ptr</a>.
ptrPackPtr :: Ptr a -> PtrWrapped (Ptr a)

-- | Extract a <a>Ptr</a> from a <a>PtrWrapped</a> <a>Ptr</a>.
ptrUnpackPtr :: PtrWrapped (Ptr a) -> Ptr a

-- | Compute the hash for a <a>CString</a>.
gStrHash :: GHashFunc CString

-- | Check whether two <a>CString</a>s are equal.
gStrEqual :: GEqualFunc CString

-- | Pack a <a>CString</a> into a <a>Ptr</a> than can go into a
--   <tt>GHashTable</tt>.
cstringPackPtr :: CString -> PtrWrapped CString

-- | Extract a <a>CString</a> wrapped into a <a>Ptr</a> coming from a
--   <tt>GHashTable</tt>.
cstringUnpackPtr :: PtrWrapped CString -> CString


-- | Utilities for dealing with <a>GArray</a> types.
module Data.GI.Base.GArray

-- | Allocate a <a>GArray</a> with elements of the given size.
allocGArray :: CUInt -> IO (Ptr (GArray a))


-- | Helpers for dealing with overladed properties, signals and methods.
module Data.GI.Base.Overloading

-- | All the types that are ascendants of this type, including interfaces
--   that the type implements.
type family ParentTypes a :: [*]

-- | A constraint on a type, to be fulfilled whenever it has a type
--   instance for <a>ParentTypes</a>. This leads to nicer errors, thanks to
--   the overlappable instance below.
class HasParentTypes (o :: *)

-- | Check that a type is in the list of <a>ParentTypes</a> of another
--   type.
type family IsDescendantOf (parent :: *) (descendant :: *) :: Constraint

-- | Safe coercions to a parent class. For instance:
--   
--   <pre>
--   #show $ label `asA` Gtk.Widget
--   </pre>
asA :: (ManagedPtrNewtype a, ManagedPtrNewtype b, HasParentTypes b, IsDescendantOf a b) => b -> (ManagedPtr a -> a) -> a

-- | The list of attributes defined for a given type. Each element of the
--   list is a tuple, with the first element of the tuple the name of the
--   attribute, and the second the type encoding the information of the
--   attribute. This type will be an instance of <a>AttrInfo</a>.
type family AttributeList a :: [(Symbol, *)]

-- | A constraint on a type, to be fulfilled whenever it has a type
--   instance for <a>AttributeList</a>. This is here for nicer error
--   reporting.
class HasAttributeList a

-- | Return the type encoding the attribute information for a given type
--   and attribute.
type family ResolveAttribute (s :: Symbol) (o :: *) :: *

-- | A constraint imposing that the given object has the given attribute.
type family HasAttribute (attr :: Symbol) (o :: *) :: Constraint

-- | A constraint that enforces that the given type has a given attribute.
class HasAttr (attr :: Symbol) (o :: *)

-- | The list of signals defined for a given type. Each element of the list
--   is a tuple, with the first element of the tuple the name of the
--   signal, and the second the type encoding the information of the
--   signal. This type will be an instance of <a>SignalInfo</a>.
type family SignalList a :: [(Symbol, *)]

-- | Return the type encoding the signal information for a given type and
--   signal.
type family ResolveSignal (s :: Symbol) (o :: *) :: *

-- | A constraint enforcing that the signal exists for the given object, or
--   one of its ancestors.
type family HasSignal (s :: Symbol) (o :: *) :: Constraint

-- | Returned when the method is not found, hopefully making the resulting
--   error messages somewhat clearer.
type family MethodResolutionFailed (method :: Symbol) (o :: *)

-- | A constraint that always fails with a type error, for documentation
--   purposes.
type family UnsupportedMethodError (s :: Symbol) (o :: *) :: *

-- | Class for types containing the information about an overloaded method
--   of type <tt>o -&gt; s</tt>.
class MethodInfo i o s
overloadedMethod :: MethodInfo i o s => o -> s
instance Data.GI.Base.Overloading.HasAttribute attr o => Data.GI.Base.Overloading.HasAttr attr o
instance forall k (a :: k). (TypeError ...) => Data.GI.Base.Overloading.HasAttributeList a
instance (TypeError ...) => Data.GI.Base.Overloading.HasParentTypes a


-- | Assorted utility functions for bindings.
module Data.GI.Base.Utils

-- | When the given value is of "Just a" form, execute the given action,
--   otherwise do nothing.
whenJust :: Monad m => Maybe a -> (a -> m ()) -> m ()

-- | Like <a>maybe</a>, but for actions on a monad, and with slightly
--   different argument order.
maybeM :: Monad m => b -> Maybe a -> (a -> m b) -> m b

-- | Check if the pointer is <a>nullPtr</a>, and wrap it on a <a>Maybe</a>
--   accordingly.
maybeFromPtr :: Ptr a -> Maybe (Ptr a)

-- | Given a function and a list of two-tuples, apply the function to every
--   first element of the tuples.
mapFirst :: (a -> c) -> [(a, b)] -> [(c, b)]

-- | Applicative version of <a>mapFirst</a>.
mapFirstA :: Applicative f => (a -> f c) -> [(a, b)] -> f [(c, b)]

-- | Same for the second element.
mapSecond :: (b -> c) -> [(a, b)] -> [(a, c)]

-- | Applicative version of <a>mapSecond</a>.
mapSecondA :: Applicative f => (b -> f c) -> [(a, b)] -> f [(a, c)]

-- | Apply the given conversion action to the given pointer if it is
--   non-NULL, otherwise return <a>Nothing</a>.
convertIfNonNull :: Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)

-- | Apply the given conversion action to the given function pointer if it
--   is non-NULL, otherwise return <a>Nothing</a>.
convertFunPtrIfNonNull :: FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)

-- | Make a zero-filled allocation using the GLib allocator.
callocBytes :: Int -> IO (Ptr a)

-- | Make a zero filled allocation of n bytes for a boxed object. The
--   difference with a normal callocBytes is that the returned memory is
--   allocated using whatever memory allocator g_boxed_copy uses, which in
--   particular may well be different from a plain g_malloc. In particular
--   g_slice_alloc is often used for allocating boxed objects, which are
--   then freed using g_slice_free.
callocBoxedBytes :: forall a. GBoxed a => Int -> IO (Ptr a)

-- | Make a zero-filled allocation of enough size to hold the given
--   <a>Storable</a> type, using the GLib allocator.
callocMem :: forall a. Storable a => IO (Ptr a)

-- | Allocate the given number of bytes using the GLib allocator.
allocBytes :: Integral a => a -> IO (Ptr b)

-- | Allocate space for the given <a>Storable</a> using the GLib allocator.
allocMem :: forall a. Storable a => IO (Ptr a)

-- | A wrapper for <tt>g_free</tt>.
freeMem :: Ptr a -> IO ()

-- | Pointer to <tt>g_free</tt>.
ptr_to_g_free :: FunPtr (Ptr a -> IO ())

-- | Copy memory into a destination (in the first argument) from a source
--   (in the second argument).
memcpy :: Ptr a -> Ptr b -> Int -> IO ()

-- | Same as freeHaskellFunPtr, but it does nothing when given a nullPtr.
safeFreeFunPtr :: Ptr a -> IO ()

-- | A pointer to <a>safeFreeFunPtr</a>.
safeFreeFunPtrPtr :: FunPtr (Ptr a -> IO ())

-- | If given a pointer to the memory location, free the <a>FunPtr</a> at
--   that location, and then the pointer itself. Useful for freeing the
--   memory associated to callbacks which are called just once, with no
--   destroy notification.
maybeReleaseFunPtr :: Maybe (Ptr (FunPtr a)) -> IO ()

-- | Check that the given pointer is not NULL. If it is, raise a
--   <a>UnexpectedNullPointerReturn</a> exception.
checkUnexpectedReturnNULL :: HasCallStack => Text -> Ptr a -> IO ()

-- | An annotated version of <tt>fromJust</tt>, which raises a
--   <a>UnexpectedNullPointerReturn</a> in case it encounters a
--   <a>Nothing</a>.
checkUnexpectedNothing :: HasCallStack => Text -> IO (Maybe a) -> IO a

-- | Print a string to the debug log in an atomic way (so the output of
--   different threads does not get intermingled).
dbgLog :: Text -> IO ()


-- | We wrap most objects in a "managed pointer", which is basically a
--   <tt>ForeignPtr</tt> of the appropriate type together with a notion of
--   "disowning", which means not running the finalizers passed upon
--   construction of the object upon garbage collection. The routines in
--   this module deal with the memory management of such managed pointers.
module Data.GI.Base.ManagedPtr

-- | Thin wrapper over <a>newForeignPtr</a>.
newManagedPtr :: HasCallStack => Ptr a -> IO () -> IO (ManagedPtr a)

-- | Version of <a>newManagedPtr</a> taking a <a>FinalizerPtr</a> and a
--   corresponding <a>Ptr</a>, as in <a>newForeignPtr</a>.
newManagedPtr' :: HasCallStack => FinalizerPtr a -> Ptr a -> IO (ManagedPtr a)

-- | Thin wrapper over <a>newForeignPtr_</a>.
newManagedPtr_ :: Ptr a -> IO (ManagedPtr a)

-- | Perform an IO action on the <a>Ptr</a> inside a managed pointer.
withManagedPtr :: (HasCallStack, ManagedPtrNewtype a) => a -> (Ptr a -> IO c) -> IO c

-- | Like <a>withManagedPtr</a>, but accepts a <a>Maybe</a> type. If the
--   passed value is <a>Nothing</a> the inner action will be executed with
--   a <a>nullPtr</a> argument.
maybeWithManagedPtr :: (HasCallStack, ManagedPtrNewtype a) => Maybe a -> (Ptr a -> IO c) -> IO c

-- | Perform an IO action taking a list of <a>Ptr</a> on a list of managed
--   pointers.
withManagedPtrList :: (HasCallStack, ManagedPtrNewtype a) => [a] -> ([Ptr a] -> IO c) -> IO c

-- | Perform the IO action with a transient managed pointer. The managed
--   pointer will be valid while calling the action, but will be disowned
--   as soon as the action finished.
withTransient :: (HasCallStack, ManagedPtrNewtype a) => (ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b

-- | Return the <a>Ptr</a> in a given managed pointer. As the name says,
--   this is potentially unsafe: the given <a>Ptr</a> may only be used
--   <i>before</i> a call to <a>touchManagedPtr</a>. This function is of
--   most interest to the autogenerated bindings, for hand-written code
--   <a>withManagedPtr</a> is almost always a better choice.
unsafeManagedPtrGetPtr :: (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)

-- | Same as <a>unsafeManagedPtrGetPtr</a>, but is polymorphic on the
--   return type.
unsafeManagedPtrCastPtr :: forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)

-- | Ensure that the <a>Ptr</a> in the given managed pointer is still alive
--   (i.e. it has not been garbage collected by the runtime) at the point
--   that this is called.
touchManagedPtr :: forall a. ManagedPtrNewtype a => a -> IO ()

-- | Do not run the finalizers upon garbage collection of the
--   <a>ManagedPtr</a>.
disownManagedPtr :: forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)

-- | Cast from one object type to another, checking that the cast is valid.
--   If it is not, we return <a>Nothing</a>. Usage:
--   
--   <pre>
--   maybeWidget &lt;- castTo Widget label
--   </pre>
castTo :: forall o o'. (HasCallStack, ManagedPtrNewtype o, TypedObject o, ManagedPtrNewtype o', TypedObject o', GObject o') => (ManagedPtr o' -> o') -> o -> IO (Maybe o')

-- | Cast a typed object to a new type (without any assumption that both
--   types descend from <a>GObject</a>), assuming that the cast will
--   succeed. This function will call <a>error</a> if the cast is illegal.
unsafeCastTo :: forall o o'. (HasCallStack, ManagedPtrNewtype o, TypedObject o, ManagedPtrNewtype o', TypedObject o') => (ManagedPtr o' -> o') -> o -> IO o'

-- | Check whether the given object is an instance of the given type.
checkInstanceType :: (ManagedPtrNewtype o, TypedObject o) => o -> GType -> IO Bool

-- | Construct a Haskell wrapper for a <a>GObject</a>, increasing its
--   reference count, or taking ownership of the floating reference if
--   there is one.
newObject :: (HasCallStack, GObject a, GObject b) => (ManagedPtr a -> a) -> Ptr b -> IO a

-- | Same as <a>newObject</a>, but we steal ownership of the object.
wrapObject :: forall a b. (HasCallStack, GObject a, GObject b) => (ManagedPtr a -> a) -> Ptr b -> IO a

-- | Unref the given <a>GObject</a> and disown it. Use this if you want to
--   manually release the memory associated to a given <a>GObject</a>
--   (assuming that no other reference to the underlying C object exists)
--   before the garbage collector does it. It is typically not safe to
--   access the <a>GObject</a> after calling this function.
releaseObject :: (HasCallStack, GObject a) => a -> IO ()

-- | Decrease the reference count of the given <a>GObject</a>. The memory
--   associated with the object may be released if the reference count
--   reaches 0.
unrefObject :: (HasCallStack, GObject a) => a -> IO ()

-- | Disown a GObject, that is, do not unref the associated foreign GObject
--   when the Haskell object gets garbage collected. Returns the pointer to
--   the underlying GObject.
disownObject :: (HasCallStack, GObject a) => a -> IO (Ptr b)

-- | Construct a Haskell wrapper for the given boxed object. We make a copy
--   of the object.
newBoxed :: forall a. (HasCallStack, GBoxed a) => (ManagedPtr a -> a) -> Ptr a -> IO a

-- | Like <a>newBoxed</a>, but we do not make a copy (we "steal" the passed
--   object, so now it is managed by the Haskell runtime).
wrapBoxed :: forall a. (HasCallStack, GBoxed a) => (ManagedPtr a -> a) -> Ptr a -> IO a

-- | Make a copy of the given boxed object.
copyBoxed :: forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)

-- | Like <a>copyBoxed</a>, but acting directly on a pointer, instead of a
--   managed pointer.
copyBoxedPtr :: forall a. GBoxed a => Ptr a -> IO (Ptr a)

-- | Free the memory associated with a boxed object. Note that this disowns
--   the associated <a>ManagedPtr</a> via <a>disownManagedPtr</a>.
freeBoxed :: forall a. (HasCallStack, GBoxed a) => a -> IO ()

-- | Disown a boxed object, that is, do not free the associated foreign
--   GBoxed when the Haskell object gets garbage collected. Returns the
--   pointer to the underlying <a>GBoxed</a>.
disownBoxed :: (HasCallStack, GBoxed a) => a -> IO (Ptr a)

-- | Wrap a pointer, taking ownership of it.
wrapPtr :: (HasCallStack, BoxedPtr a) => (ManagedPtr a -> a) -> Ptr a -> IO a

-- | Wrap a pointer, making a copy of the data.
newPtr :: (HasCallStack, BoxedPtr a) => (ManagedPtr a -> a) -> Ptr a -> IO a

-- | Make a copy of a wrapped pointer using <tt>memcpy</tt> into a freshly
--   allocated memory region of the given size.
copyBytes :: (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)


-- | Some helper functions for dealing with <tt>GClosure</tt>s.
module Data.GI.Base.GClosure

-- | The basic type. This corresponds to a wrapped <tt>GClosure</tt> on the
--   C side, which is a boxed object.
newtype GClosure a
GClosure :: ManagedPtr (GClosure a) -> GClosure a

-- | Create a new <a>GClosure</a> holding the given <a>FunPtr</a>. Note
--   that after calling this the <a>FunPtr</a> will be freed whenever the
--   <a>GClosure</a> is garbage collected, so it is generally not safe to
--   refer to the generated <a>FunPtr</a> after this function returns.
newGClosure :: MonadIO m => FunPtr a -> m (GClosure a)

-- | Take ownership of a passed in <a>Ptr</a> to a <a>GClosure</a>.
wrapGClosurePtr :: Ptr (GClosure a) -> IO (GClosure a)

-- | Construct a Haskell wrapper for the <a>GClosure</a>, without assuming
--   ownership.
newGClosureFromPtr :: Ptr (GClosure a) -> IO (GClosure a)

-- | A convenience alias for <tt>Nothing :: Maybe (GClosure a)</tt>.
noGClosure :: Maybe (GClosure a)

-- | Decrease the reference count of the given <a>GClosure</a>. If the
--   reference count reaches 0 the memory will be released.
unrefGClosure :: (HasCallStack, MonadIO m) => GClosure a -> m ()

-- | Disown (that is, remove from te purview of the Haskell Garbage
--   Collector) the given <a>GClosure</a>.
disownGClosure :: GClosure a -> IO (Ptr (GClosure a))
instance Data.GI.Base.Overloading.HasParentTypes (Data.GI.Base.GClosure.GClosure a)
instance Data.GI.Base.BasicTypes.TypedObject (Data.GI.Base.GClosure.GClosure a)
instance Data.GI.Base.BasicTypes.GBoxed (Data.GI.Base.GClosure.GClosure a)

module Data.GI.Base.BasicConversions
gflagsToWord :: (Num b, IsGFlag a) => [a] -> b
wordToGFlags :: (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]

-- | Given a Haskell list of items, construct a GList with those values.
packGList :: [Ptr a] -> IO (Ptr (GList (Ptr a)))

-- | Given a GSList construct the corresponding Haskell list.
unpackGList :: Ptr (GList (Ptr a)) -> IO [Ptr a]

-- | Given a Haskell list of items, construct a GSList with those values.
packGSList :: [Ptr a] -> IO (Ptr (GSList (Ptr a)))

-- | Given a GSList construct the corresponding Haskell list.
unpackGSList :: Ptr (GSList (Ptr a)) -> IO [Ptr a]
packGArray :: forall a. Storable a => [a] -> IO (Ptr (GArray a))
unpackGArray :: forall a. Storable a => Ptr (GArray a) -> IO [a]
unrefGArray :: Ptr (GArray a) -> IO ()
packGPtrArray :: [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
unpackGPtrArray :: Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unrefPtrArray :: Ptr (GPtrArray a) -> IO ()
packGByteArray :: ByteString -> IO (Ptr GByteArray)
unpackGByteArray :: Ptr GByteArray -> IO ByteString
unrefGByteArray :: Ptr GByteArray -> IO ()
packGHashTable :: GHashFunc a -> GEqualFunc a -> Maybe (GDestroyNotify a) -> Maybe (GDestroyNotify b) -> [(PtrWrapped a, PtrWrapped b)] -> IO (Ptr (GHashTable a b))
unpackGHashTable :: Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unrefGHashTable :: Ptr (GHashTable a b) -> IO ()
packByteString :: ByteString -> IO (Ptr Word8)
packZeroTerminatedByteString :: ByteString -> IO (Ptr Word8)
unpackByteStringWithLength :: Integral a => a -> Ptr Word8 -> IO ByteString
unpackZeroTerminatedByteString :: Ptr Word8 -> IO ByteString
packFileNameArray :: [String] -> IO (Ptr CString)
packZeroTerminatedFileNameArray :: [String] -> IO (Ptr CString)
unpackZeroTerminatedFileNameArray :: HasCallStack => Ptr CString -> IO [String]
unpackFileNameArrayWithLength :: (HasCallStack, Integral a) => a -> Ptr CString -> IO [String]
packUTF8CArray :: [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray :: [Text] -> IO (Ptr CString)
unpackUTF8CArrayWithLength :: (HasCallStack, Integral a) => a -> Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray :: HasCallStack => Ptr CString -> IO [Text]
packStorableArray :: Storable a => [a] -> IO (Ptr a)
packZeroTerminatedStorableArray :: (Num a, Storable a) => [a] -> IO (Ptr a)
unpackStorableArrayWithLength :: (Integral a, Storable b) => a -> Ptr b -> IO [b]
unpackZeroTerminatedStorableArray :: (Eq a, Num a, Storable a) => Ptr a -> IO [a]
packMapStorableArray :: forall a b. Storable b => (a -> b) -> [a] -> IO (Ptr b)
packMapZeroTerminatedStorableArray :: forall a b. (Num b, Storable b) => (a -> b) -> [a] -> IO (Ptr b)
unpackMapStorableArrayWithLength :: forall a b c. (Integral a, Storable b) => (b -> c) -> a -> Ptr b -> IO [c]
unpackMapZeroTerminatedStorableArray :: forall a b. (Eq a, Num a, Storable a) => (a -> b) -> Ptr a -> IO [b]
packPtrArray :: [Ptr a] -> IO (Ptr (Ptr a))
packZeroTerminatedPtrArray :: [Ptr a] -> IO (Ptr (Ptr a))
unpackPtrArrayWithLength :: Integral a => a -> Ptr (Ptr b) -> IO [Ptr b]
unpackZeroTerminatedPtrArray :: Ptr (Ptr a) -> IO [Ptr a]

-- | Given a set of pointers to blocks of memory of the specified size,
--   copy the contents of these blocks to a freshly-allocated (with
--   <a>allocBytes</a>) continuous area of memory.
packBlockArray :: Int -> [Ptr a] -> IO (Ptr a)
unpackBlockArrayWithLength :: Integral a => Int -> a -> Ptr b -> IO [Ptr b]
unpackBoxedArrayWithLength :: forall a b. (Integral a, GBoxed b) => Int -> a -> Ptr b -> IO [Ptr b]
stringToCString :: String -> IO CString
cstringToString :: HasCallStack => CString -> IO String

-- | Convert <a>Text</a> into a <a>CString</a>, using the GLib allocator.
textToCString :: Text -> IO CString
withTextCString :: Text -> (CString -> IO a) -> IO a
cstringToText :: HasCallStack => CString -> IO Text
byteStringToCString :: ByteString -> IO CString
cstringToByteString :: HasCallStack => CString -> IO ByteString
mapZeroTerminatedCArray :: (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapCArrayWithLength :: (Storable a, Integral b) => b -> (a -> IO c) -> Ptr a -> IO ()
mapGArray :: forall a b. Storable a => (a -> IO b) -> Ptr (GArray a) -> IO ()
mapPtrArray :: (Ptr a -> IO b) -> Ptr (GPtrArray (Ptr a)) -> IO ()
mapGList :: (Ptr a -> IO b) -> Ptr (GList (Ptr a)) -> IO ()
mapGSList :: (Ptr a -> IO b) -> Ptr (GSList (Ptr a)) -> IO ()


-- | This module contains some helper functions for dealing with GVariant
--   values. The simplest way of dealing with them is by using the
--   <a>IsGVariant</a> typeclass:
--   
--   <pre>
--   str &lt;- fromGVariant variant :: IO (Maybe Text)
--   </pre>
--   
--   assuming that the variant is expected to contain a string in UTF8
--   encoding. The code becomes even shorter if the type checker can
--   determine the return type for you:
--   
--   <pre>
--   readStringVariant :: GVariant -&gt; IO Text
--   readStringVariant variant =
--     fromGVariant variant &gt;&gt;= \case
--        Nothing  -&gt; error "Variant was not a string"
--        Just str -&gt; return str
--   </pre>
--   
--   Alternatively, you can use manually the gvariantFrom* and gvariantTo*
--   family of functions.
module Data.GI.Base.GVariant

-- | The typeclass for types that can be automatically marshalled into
--   <a>GVariant</a> using <a>toGVariant</a> and <a>fromGVariant</a>.
class IsGVariant a

-- | Convert a value of the given type into a GVariant.
toGVariant :: IsGVariant a => a -> IO GVariant

-- | Try to decode a <a>GVariant</a> into a target type. If the conversion
--   fails we return <a>Nothing</a>. The type that was expected can be
--   obtained by calling <a>toGVariantFormatString</a>, and the actual type
--   as understood by the <a>GVariant</a> code can be obtained by calling
--   <tt>gvariantToTypeString</tt>.
fromGVariant :: IsGVariant a => GVariant -> IO (Maybe a)

-- | The expected format string for this type (the argument is ignored).
toGVariantFormatString :: IsGVariant a => a -> Text

-- | The typeclass for basic type <a>GVariant</a> types, i.e. those that
--   are not containers.
class Ord a => IsGVariantBasicType a

-- | An alias for <tt>Nothing :: Maybe GVariant</tt> to save some typing.
noGVariant :: Maybe GVariant

-- | Get the expected type of a <a>GVariant</a>, in <a>GVariant</a>
--   notation. See
--   <a>https://developer.gnome.org/glib/stable/glib-GVariantType.html</a>
--   for the meaning of the resulting format string.
gvariantGetTypeString :: GVariant -> IO Text

-- | Haskell has no notion of one element tuples, but GVariants do, so the
--   following allows for marshalling one element tuples properly using
--   <a>fromGVariant</a> and <a>toGVariant</a>. For instance, to construct
--   a single element tuple containing a string, you could do
--   
--   <pre>
--   toGVariant (GVariantSinglet "Test")
--   </pre>
newtype GVariantSinglet a
GVariantSinglet :: a -> GVariantSinglet a

-- | A DictEntry <a>GVariant</a> is isomorphic to a two-tuple. Wrapping the
--   values into a <tt>GVariantDictentry</tt> allows the <a>IsGVariant</a>
--   instance to do the right thing.
data GVariantDictEntry key value
GVariantDictEntry :: key -> value -> GVariantDictEntry key value
newtype GVariantHandle
GVariantHandle :: Int32 -> GVariantHandle

-- | An object representing a DBus object path, which is a particular type
--   of <a>GVariant</a> too. (Just a string with some specific
--   requirements.) In order to construct/deconstruct a
--   <a>GVariantObjectPath</a> one can use <a>newGVariantObjectPath</a> and
--   <a>gvariantObjectPathToText</a>.
data GVariantObjectPath

-- | Try to construct a DBus object path. If the passed string is not a
--   valid object path <a>Nothing</a> will be returned.
newGVariantObjectPath :: Text -> Maybe GVariantObjectPath

-- | Return the <a>Text</a> representation of a <a>GVariantObjectPath</a>.
gvariantObjectPathToText :: GVariantObjectPath -> Text

-- | An object representing a DBus signature, which is a particular type of
--   <a>GVariant</a> too. (Just a string with some specific requirements.)
--   In order to construct/deconstruct a <a>GVariantSignature</a> one can
--   use <a>newGVariantSignature</a> and <a>gvariantSignatureToText</a>.
data GVariantSignature

-- | Try to construct a DBus object path. If the passed string is not a
--   valid DBus signature <a>Nothing</a> will be returned.
newGVariantSignature :: Text -> Maybe GVariantSignature

-- | Return the <a>Text</a> representation of a <a>GVariantSignature</a>.
gvariantSignatureToText :: GVariantSignature -> Text

-- | Take ownership of a passed in <a>Ptr</a> (typically created just for
--   us, so if it is floating we sink it).
wrapGVariantPtr :: Ptr GVariant -> IO GVariant

-- | Construct a Haskell wrapper for the given <a>GVariant</a>, without
--   assuming ownership.
newGVariantFromPtr :: Ptr GVariant -> IO GVariant

-- | Remove a reference to the given <a>GVariant</a>.
unrefGVariant :: GVariant -> IO ()

-- | Disown a <a>GVariant</a>, i.e. do not unref the underlying object when
--   the Haskell object is garbage collected.
disownGVariant :: GVariant -> IO (Ptr GVariant)
gvariantToBool :: GVariant -> IO (Maybe Bool)
gvariantFromBool :: Bool -> IO GVariant
gvariantToWord8 :: GVariant -> IO (Maybe Word8)
gvariantFromWord8 :: Word8 -> IO GVariant
gvariantToInt16 :: GVariant -> IO (Maybe Int16)
gvariantFromInt16 :: Int16 -> IO GVariant
gvariantToWord16 :: GVariant -> IO (Maybe Word16)
gvariantFromWord16 :: Word16 -> IO GVariant
gvariantToInt32 :: GVariant -> IO (Maybe Int32)
gvariantFromInt32 :: Int32 -> IO GVariant
gvariantToWord32 :: GVariant -> IO (Maybe Word32)
gvariantFromWord32 :: Word32 -> IO GVariant
gvariantToInt64 :: GVariant -> IO (Maybe Int64)
gvariantFromInt64 :: Int64 -> IO GVariant
gvariantToWord64 :: GVariant -> IO (Maybe Word64)
gvariantFromWord64 :: Word64 -> IO GVariant

-- | Extract the DBus handle (an <a>Int32</a>) inside a <a>GVariant</a>.
gvariantToHandle :: GVariant -> IO (Maybe Int32)

-- | Convert a DBus handle (an <a>Int32</a>) into a <a>GVariant</a>.
gvariantFromHandle :: Int32 -> IO GVariant
gvariantToDouble :: GVariant -> IO (Maybe Double)
gvariantFromDouble :: Double -> IO GVariant

-- | Decode an UTF-8 encoded string <a>GVariant</a> into <a>Text</a>.
gvariantToText :: GVariant -> IO (Maybe Text)

-- | Encode a <a>Text</a> into an UTF-8 encoded string <a>GVariant</a>.
gvariantFromText :: Text -> IO GVariant

-- | Extract a <a>GVariantObjectPath</a> from a <a>GVariant</a>,
--   represented as its underlying <a>Text</a> representation.
gvariantToObjectPath :: GVariant -> IO (Maybe Text)

-- | Construct a <a>GVariant</a> containing an object path. In order to
--   build a <a>GVariantObjectPath</a> value see
--   <a>newGVariantObjectPath</a>.
gvariantFromObjectPath :: GVariantObjectPath -> IO GVariant

-- | Extract a <a>GVariantSignature</a> from a <a>GVariant</a>, represented
--   as <a>Text</a>.
gvariantToSignature :: GVariant -> IO (Maybe Text)

-- | Construct a <a>GVariant</a> containing an DBus signature. In order to
--   build a <a>GVariantSignature</a> value see
--   <a>newGVariantSignature</a>.
gvariantFromSignature :: GVariantSignature -> IO GVariant

-- | Unbox a <a>GVariant</a> contained inside another <a>GVariant</a>.
gvariantToGVariant :: GVariant -> IO (Maybe GVariant)

-- | Box a <a>GVariant</a> inside another <a>GVariant</a>.
gvariantFromGVariant :: GVariant -> IO GVariant

-- | Extract a zero terminated list of bytes into a <a>ByteString</a>.
gvariantToBytestring :: GVariant -> IO (Maybe ByteString)

-- | Encode a <a>ByteString</a> into a list of bytes <a>GVariant</a>.
gvariantFromBytestring :: ByteString -> IO GVariant

-- | Convert a <a>Maybe</a> value into a corresponding <a>GVariant</a> of
--   maybe type.
gvariantFromMaybe :: forall a. IsGVariant a => Maybe a -> IO GVariant

-- | Try to decode a maybe <a>GVariant</a> into the corresponding
--   <a>Maybe</a> type. If the conversion is successful this returns
--   <tt>Just x</tt>, where <tt>x</tt> itself is of <a>Maybe</a> type. So,
--   in particular, <tt>Just Nothing</tt> indicates a successful call, and
--   means that the GVariant of maybe type was empty.
gvariantToMaybe :: forall a. IsGVariant a => GVariant -> IO (Maybe (Maybe a))

-- | Construct a <a>GVariant</a> of type DictEntry from the given
--   <tt>key</tt> and <tt>value</tt>. The key must be a basic
--   <a>GVariant</a> type, i.e. not a container. This is determined by
--   whether it belongs to the <a>IsGVariantBasicType</a> typeclass. On the
--   other hand <tt>value</tt> is an arbitrary <a>GVariant</a>, and in
--   particular it can be a container type.
gvariantFromDictEntry :: (IsGVariant key, IsGVariantBasicType key, IsGVariant value) => key -> value -> IO GVariant

-- | Unpack a DictEntry variant into <tt>key</tt> and <tt>value</tt>, which
--   are returned as a two element tuple in case of success.
gvariantToDictEntry :: forall key value. (IsGVariant key, IsGVariantBasicType key, IsGVariant value) => GVariant -> IO (Maybe (key, value))

-- | Pack a <tt>Map</tt> into a <a>GVariant</a> for dictionary type, which
--   is just an array of <a>GVariantDictEntry</a>.
gvariantFromMap :: (IsGVariant key, IsGVariantBasicType key, IsGVariant value) => Map key value -> IO GVariant

-- | Unpack a <a>GVariant</a> into a <a>Map</a>. Notice that this assumes
--   that all the elements in the <a>GVariant</a> array of
--   <a>GVariantDictEntry</a> are of the same type, which is not necessary
--   for a generic <a>GVariant</a>, so this is somewhat restrictive. For
--   the general case it is necessary to use <a>gvariantToList</a> plus
--   <a>gvariantToDictEntry</a> directly.
gvariantToMap :: forall key value. (IsGVariant key, IsGVariantBasicType key, IsGVariant value) => GVariant -> IO (Maybe (Map key value))

-- | Given a list of elements construct a <a>GVariant</a> array containing
--   them.
gvariantFromList :: forall a. IsGVariant a => [a] -> IO GVariant

-- | Unpack a <a>GVariant</a> array into its elements.
gvariantToList :: forall a. IsGVariant a => GVariant -> IO (Maybe [a])

-- | Given a list of <a>GVariant</a>, construct a <a>GVariant</a> tuple
--   containing the elements in the list.
gvariantFromTuple :: [GVariant] -> IO GVariant

-- | Extract the children of a <a>GVariant</a> tuple into a list.
gvariantToTuple :: GVariant -> IO (Maybe [GVariant])
instance (GHC.Show.Show key, GHC.Show.Show value) => GHC.Show.Show (Data.GI.Base.GVariant.GVariantDictEntry key value)
instance (GHC.Classes.Eq key, GHC.Classes.Eq value) => GHC.Classes.Eq (Data.GI.Base.GVariant.GVariantDictEntry key value)
instance GHC.Show.Show Data.GI.Base.GVariant.GVariantSignature
instance GHC.Classes.Eq Data.GI.Base.GVariant.GVariantSignature
instance GHC.Classes.Ord Data.GI.Base.GVariant.GVariantSignature
instance GHC.Show.Show Data.GI.Base.GVariant.GVariantObjectPath
instance GHC.Classes.Eq Data.GI.Base.GVariant.GVariantObjectPath
instance GHC.Classes.Ord Data.GI.Base.GVariant.GVariantObjectPath
instance GHC.Show.Show Data.GI.Base.GVariant.GVariantHandle
instance GHC.Classes.Ord Data.GI.Base.GVariant.GVariantHandle
instance GHC.Classes.Eq Data.GI.Base.GVariant.GVariantHandle
instance GHC.Show.Show a => GHC.Show.Show (Data.GI.Base.GVariant.GVariantSinglet a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.GI.Base.GVariant.GVariantSinglet a)
instance (Data.GI.Base.GVariant.IsGVariant a, Data.GI.Base.GVariant.IsGVariantBasicType a, Data.GI.Base.GVariant.IsGVariant b) => Data.GI.Base.GVariant.IsGVariant (Data.GI.Base.GVariant.GVariantDictEntry a b)
instance Data.GI.Base.GVariant.IsGVariant Data.GI.Base.GVariant.GVariantSignature
instance Data.GI.Base.GVariant.IsGVariantBasicType Data.GI.Base.GVariant.GVariantSignature
instance Data.GI.Base.GVariant.IsGVariant Data.GI.Base.GVariant.GVariantObjectPath
instance Data.GI.Base.GVariant.IsGVariantBasicType Data.GI.Base.GVariant.GVariantObjectPath
instance Data.GI.Base.GVariant.IsGVariant Data.GI.Base.GVariant.GVariantHandle
instance Data.GI.Base.GVariant.IsGVariantBasicType Data.GI.Base.GVariant.GVariantHandle
instance Data.GI.Base.GVariant.IsGVariant a => Data.GI.Base.GVariant.IsGVariant (Data.GI.Base.GVariant.GVariantSinglet a)
instance Data.GI.Base.GVariant.IsGVariantBasicType GHC.Types.Bool
instance Data.GI.Base.GVariant.IsGVariantBasicType GHC.Word.Word8
instance Data.GI.Base.GVariant.IsGVariantBasicType GHC.Int.Int16
instance Data.GI.Base.GVariant.IsGVariantBasicType GHC.Word.Word16
instance Data.GI.Base.GVariant.IsGVariantBasicType GHC.Int.Int32
instance Data.GI.Base.GVariant.IsGVariantBasicType GHC.Word.Word32
instance Data.GI.Base.GVariant.IsGVariantBasicType GHC.Int.Int64
instance Data.GI.Base.GVariant.IsGVariantBasicType GHC.Word.Word64
instance Data.GI.Base.GVariant.IsGVariantBasicType GHC.Types.Double
instance Data.GI.Base.GVariant.IsGVariantBasicType Data.Text.Internal.Text
instance (Data.GI.Base.GVariant.IsGVariant a, Data.GI.Base.GVariant.IsGVariantBasicType a, Data.GI.Base.GVariant.IsGVariant b) => Data.GI.Base.GVariant.IsGVariant (Data.Map.Internal.Map a b)
instance Data.GI.Base.GVariant.IsGVariant GHC.Types.Bool
instance Data.GI.Base.GVariant.IsGVariant GHC.Word.Word8
instance Data.GI.Base.GVariant.IsGVariant GHC.Int.Int16
instance Data.GI.Base.GVariant.IsGVariant GHC.Word.Word16
instance Data.GI.Base.GVariant.IsGVariant GHC.Int.Int32
instance Data.GI.Base.GVariant.IsGVariant GHC.Word.Word32
instance Data.GI.Base.GVariant.IsGVariant GHC.Int.Int64
instance Data.GI.Base.GVariant.IsGVariant GHC.Word.Word64
instance Data.GI.Base.GVariant.IsGVariant GHC.Types.Double
instance Data.GI.Base.GVariant.IsGVariant Data.Text.Internal.Text
instance Data.GI.Base.GVariant.IsGVariant Data.GI.Base.BasicTypes.GVariant
instance Data.GI.Base.GVariant.IsGVariant Data.ByteString.Internal.ByteString
instance Data.GI.Base.GVariant.IsGVariant a => Data.GI.Base.GVariant.IsGVariant (GHC.Maybe.Maybe a)
instance Data.GI.Base.GVariant.IsGVariant a => Data.GI.Base.GVariant.IsGVariant [a]
instance Data.GI.Base.GVariant.IsGVariant ()
instance (Data.GI.Base.GVariant.IsGVariant a, Data.GI.Base.GVariant.IsGVariant b) => Data.GI.Base.GVariant.IsGVariant (a, b)
instance (Data.GI.Base.GVariant.IsGVariant a, Data.GI.Base.GVariant.IsGVariant b, Data.GI.Base.GVariant.IsGVariant c) => Data.GI.Base.GVariant.IsGVariant (a, b, c)
instance (Data.GI.Base.GVariant.IsGVariant a, Data.GI.Base.GVariant.IsGVariant b, Data.GI.Base.GVariant.IsGVariant c, Data.GI.Base.GVariant.IsGVariant d) => Data.GI.Base.GVariant.IsGVariant (a, b, c, d)
instance (Data.GI.Base.GVariant.IsGVariant a, Data.GI.Base.GVariant.IsGVariant b, Data.GI.Base.GVariant.IsGVariant c, Data.GI.Base.GVariant.IsGVariant d, Data.GI.Base.GVariant.IsGVariant e) => Data.GI.Base.GVariant.IsGVariant (a, b, c, d, e)

module Data.GI.Base.GValue

-- | Haskell-side representation of a <tt>GValue</tt>.
newtype GValue
GValue :: ManagedPtr GValue -> GValue

-- | A convenience class for marshaling back and forth between Haskell
--   values and <a>GValue</a>s.
class IsGValue a
toGValue :: IsGValue a => a -> IO GValue
fromGValue :: IsGValue a => GValue -> IO a

-- | A type holding a <a>GValue</a> with an associated label. It is
--   parameterized by a phantom type encoding the target type for the
--   <a>GValue</a> (useful when constructing properties).
data GValueConstruct o
GValueConstruct :: String -> GValue -> GValueConstruct o

-- | Build a new, empty, <a>GValue</a> of the given type.
newGValue :: GType -> IO GValue

-- | A convenience function for building a new GValue and setting the
--   initial value.
buildGValue :: GType -> (GValue -> a -> IO ()) -> a -> IO GValue

-- | Disown a <a>GValue</a>, i.e. do not unref the underlying object when
--   the Haskell object is garbage collected.
disownGValue :: GValue -> IO (Ptr GValue)

-- | A convenience alias for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>GValue</a></tt>.
noGValue :: Maybe GValue

-- | Construct a Haskell wrapper for the given <a>GValue</a>, making a
--   copy.
newGValueFromPtr :: Ptr GValue -> IO GValue

-- | Take ownership of a passed in <a>Ptr</a>.
wrapGValuePtr :: Ptr GValue -> IO GValue

-- | Unset the <a>GValue</a>, freeing all resources associated to it.
unsetGValue :: Ptr GValue -> IO ()

-- | Pack the given list of GValues contiguously into a C array
packGValueArray :: [GValue] -> IO (Ptr GValue)

-- | Unpack an array of contiguous GValues into a list of GValues.
unpackGValueArrayWithLength :: Integral a => a -> Ptr GValue -> IO [GValue]

-- | Map over the <a>GValue</a>s inside a C array.
mapGValueArrayWithLength :: Integral a => a -> (Ptr GValue -> IO c) -> Ptr GValue -> IO ()
set_string :: GValue -> Maybe Text -> IO ()
get_string :: GValue -> IO (Maybe Text)
set_pointer :: GValue -> Ptr a -> IO ()
get_pointer :: GValue -> IO (Ptr b)
set_int :: GValue -> CInt -> IO ()
get_int :: GValue -> IO CInt
set_uint :: GValue -> CUInt -> IO ()
get_uint :: GValue -> IO CUInt
set_long :: GValue -> CLong -> IO ()
get_long :: GValue -> IO CLong
set_ulong :: GValue -> CULong -> IO ()
get_ulong :: GValue -> IO CULong
set_int32 :: GValue -> Int32 -> IO ()
get_int32 :: GValue -> IO Int32
set_uint32 :: GValue -> Word32 -> IO ()
get_uint32 :: GValue -> IO Word32
set_int64 :: GValue -> Int64 -> IO ()
get_int64 :: GValue -> IO Int64
set_uint64 :: GValue -> Word64 -> IO ()
get_uint64 :: GValue -> IO Word64
set_float :: GValue -> Float -> IO ()
get_float :: GValue -> IO Float
set_double :: GValue -> Double -> IO ()
get_double :: GValue -> IO Double
set_boolean :: GValue -> Bool -> IO ()
get_boolean :: GValue -> IO Bool
set_gtype :: GValue -> GType -> IO ()
get_gtype :: GValue -> IO GType
set_object :: GObject a => GValue -> Ptr a -> IO ()
get_object :: GObject b => GValue -> IO (Ptr b)
set_boxed :: GValue -> Ptr a -> IO ()
get_boxed :: GValue -> IO (Ptr b)
set_variant :: GValue -> Ptr GVariant -> IO ()
get_variant :: GValue -> IO (Ptr GVariant)
set_enum :: GValue -> CUInt -> IO ()
get_enum :: GValue -> IO CUInt
set_flags :: GValue -> CUInt -> IO ()
get_flags :: GValue -> IO CUInt

-- | Set the value of <a>GValue</a> containing a <a>StablePtr</a>
set_stablePtr :: GValue -> StablePtr a -> IO ()

-- | Get the value of a <a>GValue</a> containing a <a>StablePtr</a>
get_stablePtr :: GValue -> IO (StablePtr a)

-- | Like <a>set_stablePtr</a>, but the <a>GValue</a> takes ownership of
--   the <a>StablePtr</a>
take_stablePtr :: Ptr GValue -> StablePtr a -> IO ()
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GHC.Base.String)
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe Data.Text.Internal.Text)
instance Data.GI.Base.GValue.IsGValue (GHC.Ptr.Ptr a)
instance Data.GI.Base.GValue.IsGValue GHC.Int.Int32
instance Data.GI.Base.GValue.IsGValue GHC.Word.Word32
instance Data.GI.Base.GValue.IsGValue Foreign.C.Types.CInt
instance Data.GI.Base.GValue.IsGValue Foreign.C.Types.CUInt
instance Data.GI.Base.GValue.IsGValue Foreign.C.Types.CLong
instance Data.GI.Base.GValue.IsGValue Foreign.C.Types.CULong
instance Data.GI.Base.GValue.IsGValue GHC.Int.Int64
instance Data.GI.Base.GValue.IsGValue GHC.Word.Word64
instance Data.GI.Base.GValue.IsGValue GHC.Types.Float
instance Data.GI.Base.GValue.IsGValue GHC.Types.Double
instance Data.GI.Base.GValue.IsGValue GHC.Types.Bool
instance Data.GI.Base.GValue.IsGValue Data.GI.Base.BasicTypes.GType
instance Data.GI.Base.GValue.IsGValue (GHC.Stable.StablePtr a)
instance Data.GI.Base.Overloading.HasParentTypes Data.GI.Base.GValue.GValue
instance Data.GI.Base.BasicTypes.TypedObject Data.GI.Base.GValue.GValue
instance Data.GI.Base.BasicTypes.GBoxed Data.GI.Base.GValue.GValue


-- | <h2>Basic attributes interface</h2>
--   
--   Attributes of an object can be get, set and constructed. For types
--   descending from <a>GObject</a>, properties are encoded in attributes,
--   although attributes are slightly more general (every property of a
--   <a>GObject</a> is an attribute, but we can also have attributes for
--   types not descending from <a>GObject</a>).
--   
--   If you're wondering what the possible attributes of a GObject are,
--   look at the list of properties in the documentation, e.g. the
--   Properties heading of the docs for <a>Button</a> lists properties such
--   as <tt>image</tt> and <tt>relief</tt>. Parent classes may also
--   introduce properties, so since a Button is an instance of
--   <tt>IsActionable</tt>, it inherits properties like <tt>actionName</tt>
--   from <a>Actionable</a> too.
--   
--   As an example consider a <tt>button</tt> widget and a property (of the
--   Button class, or any of its parent classes or implemented interfaces)
--   called "label". The simplest way of getting the value of the button is
--   to do
--   
--   <pre>
--   value &lt;- getButtonLabel button
--   </pre>
--   
--   And for setting:
--   
--   <pre>
--   setButtonLabel button label
--   </pre>
--   
--   This mechanism quickly becomes rather cumbersome, for example for
--   setting the "window" property in a DOMDOMWindow in WebKit:
--   
--   <pre>
--   win &lt;- getDOMDOMWindowWindow dom
--   </pre>
--   
--   and perhaps more importantly, one needs to chase down the type which
--   introduces the property:
--   
--   <pre>
--   setWidgetSensitive button False
--   </pre>
--   
--   There is no <tt>setButtonSensitive</tt>, since it is the
--   <tt>Widget</tt> type that introduces the "sensitive" property.
--   
--   <h2>Overloaded attributes</h2>
--   
--   A much more convenient overloaded attribute resolution API is provided
--   by this module. Getting the value of an object's attribute is
--   straightforward:
--   
--   <pre>
--   value &lt;- get button _label
--   </pre>
--   
--   The definition of <tt>_label</tt> is basically a <a>Proxy</a> encoding
--   the name of the attribute to get:
--   
--   <pre>
--   _label = fromLabelProxy (Proxy :: Proxy "label")
--   </pre>
--   
--   These proxies can be automatically generated by invoking the code
--   generator with the <tt>-l</tt> option. The leading underscore is
--   simply so the autogenerated identifiers do not pollute the namespace,
--   but if this is not a concern the autogenerated names (in the
--   autogenerated <tt>GI/Properties.hs</tt>) can be edited as one wishes.
--   
--   In addition, for ghc &gt;= 8.0, one can directly use the overloaded
--   labels provided by GHC itself. Using the <a>OverloadedLabels</a>
--   extension, the code above can also be written as
--   
--   <pre>
--   value &lt;- get button #label
--   </pre>
--   
--   The syntax for setting or updating an attribute is only slightly more
--   complex. At the simplest level it is just:
--   
--   <pre>
--   set button [ _label := value ]
--   </pre>
--   
--   or for the WebKit example above
--   
--   <pre>
--   set dom [_window := win]
--   </pre>
--   
--   However as the list notation would indicate, you can set or update
--   multiple attributes of the same object in one go:
--   
--   <pre>
--   set button [ _label := value, _sensitive := False ]
--   </pre>
--   
--   You are not limited to setting the value of an attribute, you can also
--   apply an update function to an attribute's value. That is the function
--   receives the current value of the attribute and returns the new value.
--   
--   <pre>
--   set spinButton [ _value :~ (+1) ]
--   </pre>
--   
--   There are other variants of these operators, see <a>AttrOp</a> below.
--   <a>:=&gt;</a> and <a>:~&gt;</a> are like <a>:=</a> and <a>:~</a> but
--   operate in the <a>IO</a> monad rather than being pure.
--   
--   Attributes can also be set during construction of a <a>GObject</a>
--   using <a>new</a>
--   
--   <pre>
--   button &lt;- new Button [_label := "Can't touch this!", _sensitive := False]
--   </pre>
--   
--   In addition for value being set/get having to have the right type,
--   there can be attributes that are read-only, or that can only be set
--   during construction with <a>new</a>, but cannot be <a>set</a>
--   afterwards. That these invariants hold is also checked during compile
--   time.
--   
--   <h2>Nullable attributes</h2>
--   
--   Whenever the attribute is represented as a pointer in the C side, it
--   is often the case that the underlying C representation admits or
--   returns <tt>NULL</tt> as a valid value for the property. In these
--   cases the <a>get</a> operation may return a <a>Maybe</a> value, with
--   <a>Nothing</a> representing the <tt>NULL</tt> pointer value (notable
--   exceptions are <a>GList</a> and <a>GSList</a>, for which <tt>NULL</tt>
--   is represented simply as the empty list). This can be overridden in
--   the introspection data, since sometimes attributes are non-nullable,
--   even if the type would allow for <tt>NULL</tt>.
--   
--   For convenience, in nullable cases the <a>set</a> operation will by
--   default <i>not</i> take a <a>Maybe</a> value, but rather assume that
--   the caller wants to set a non-<tt>NULL</tt> value. If setting a
--   <tt>NULL</tt> value is desired, use <a>clear</a> as follows
--   
--   <pre>
--   clear object _propName
--   </pre>
module Data.GI.Base.Attributes

-- | Info describing an attribute.
class AttrInfo (info :: *) where {
    
    -- | The operations that are allowed on the attribute.
    type family AttrAllowedOps info :: [AttrOpTag];
    
    -- | Constraint on the type for which we are allowed to create/set/get the
    --   attribute.
    type family AttrBaseTypeConstraint info :: * -> Constraint;
    
    -- | Type returned by <a>attrGet</a>.
    type family AttrGetType info;
    
    -- | Constraint on the value being set.
    type family AttrSetTypeConstraint info :: * -> Constraint;
    
    -- | Constraint on the value being set, with allocation allowed (see
    --   <a>:&amp;=</a> below).
    type family AttrTransferTypeConstraint info :: * -> Constraint;
    
    -- | Type resulting from the allocation.
    type family AttrTransferType info :: *;
    
    -- | Name of the attribute.
    type family AttrLabel info :: Symbol;
    
    -- | Type which introduces the attribute.
    type family AttrOrigin info;
    type AttrSetTypeConstraint info = (~) (AttrGetType info);
    type AttrTransferTypeConstraint info = (~) (AttrTransferType info);
    type AttrTransferType info = AttrGetType info;
}

-- | Get the value of the given attribute.
attrGet :: (AttrInfo info, AttrBaseTypeConstraint info o) => o -> IO (AttrGetType info)

-- | Get the value of the given attribute.
attrGet :: (AttrInfo info, CheckNotElem 'AttrGet (AttrAllowedOps info) (GetNotProvidedError info)) => o -> IO (AttrGetType info)

-- | Set the value of the given attribute, after the object having the
--   attribute has already been created.
attrSet :: (AttrInfo info, AttrBaseTypeConstraint info o, AttrSetTypeConstraint info b) => o -> b -> IO ()

-- | Set the value of the given attribute, after the object having the
--   attribute has already been created.
attrSet :: (AttrInfo info, CheckNotElem 'AttrSet (AttrAllowedOps info) (SetNotProvidedError info)) => o -> b -> IO ()

-- | Set the value of the given attribute to <tt>NULL</tt> (for nullable
--   attributes).
attrClear :: (AttrInfo info, AttrBaseTypeConstraint info o) => o -> IO ()

-- | Set the value of the given attribute to <tt>NULL</tt> (for nullable
--   attributes).
attrClear :: (AttrInfo info, CheckNotElem 'AttrClear (AttrAllowedOps info) (ClearNotProvidedError info)) => o -> IO ()

-- | Build a <a>GValue</a> representing the attribute.
attrConstruct :: (AttrInfo info, AttrBaseTypeConstraint info o, AttrSetTypeConstraint info b) => b -> IO (GValueConstruct o)

-- | Build a <a>GValue</a> representing the attribute.
attrConstruct :: (AttrInfo info, CheckNotElem 'AttrConstruct (AttrAllowedOps info) (ConstructNotProvidedError info)) => b -> IO (GValueConstruct o)

-- | Allocate memory as necessary to generate a settable type from the
--   transfer type. This is useful for types which needs allocations for
--   marshalling from Haskell to C, this makes the allocation explicit.
attrTransfer :: forall o b. (AttrInfo info, AttrBaseTypeConstraint info o, AttrTransferTypeConstraint info b) => Proxy o -> b -> IO (AttrTransferType info)

-- | Allocate memory as necessary to generate a settable type from the
--   transfer type. This is useful for types which needs allocations for
--   marshalling from Haskell to C, this makes the allocation explicit.
attrTransfer :: forall o b. (AttrInfo info, AttrBaseTypeConstraint info o, AttrTransferTypeConstraint info b, b ~ AttrGetType info, b ~ AttrTransferType info) => Proxy o -> b -> IO (AttrTransferType info)

-- | Possible operations on an attribute.
data AttrOpTag

-- | It is possible to read the value of the attribute with <a>get</a>.
AttrGet :: AttrOpTag

-- | It is possible to write the value of the attribute with <a>set</a>.
AttrSet :: AttrOpTag

-- | It is possible to set the value of the attribute in <a>new</a>.
AttrConstruct :: AttrOpTag

-- | It is possible to clear the value of the (nullable) attribute with
--   <a>clear</a>.
AttrClear :: AttrOpTag

-- | Constructors for the different operations allowed on an attribute.
data AttrOp obj (tag :: AttrOpTag)

-- | Assign a value to an attribute
[:=] :: (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrSetTypeConstraint info b) => AttrLabelProxy (attr :: Symbol) -> b -> AttrOp obj tag

-- | Assign the result of an IO action to an attribute
[:=>] :: (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrSetTypeConstraint info b) => AttrLabelProxy (attr :: Symbol) -> IO b -> AttrOp obj tag

-- | Apply an update function to an attribute
[:~] :: (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, tag ~ 'AttrSet, AttrOpAllowed 'AttrSet info obj, AttrOpAllowed 'AttrGet info obj, AttrSetTypeConstraint info b, a ~ AttrGetType info) => AttrLabelProxy (attr :: Symbol) -> (a -> b) -> AttrOp obj tag

-- | Apply an IO update function to an attribute
[:~>] :: (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, tag ~ 'AttrSet, AttrOpAllowed 'AttrSet info obj, AttrOpAllowed 'AttrGet info obj, AttrSetTypeConstraint info b, a ~ AttrGetType info) => AttrLabelProxy (attr :: Symbol) -> (a -> IO b) -> AttrOp obj tag

-- | Assign a value to an attribute, allocating any necessary memory for
--   representing the Haskell value as a C value. Note that it is the
--   responsibility of the caller to make sure that the memory is freed
--   when no longer used, otherwise there will be a memory leak. In the
--   majority of cases you probably want to use <a>:=</a> instead, which
--   has no potential memory leaks (at the cost of sometimes requiring some
--   explicit Haskell -&gt; C marshalling).
[:&=] :: (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrTransferTypeConstraint info b, AttrSetTypeConstraint info (AttrTransferType info)) => AttrLabelProxy (attr :: Symbol) -> b -> AttrOp obj tag
infixr 0 :=
infixr 0 :~
infixr 0 :=>
infixr 0 :~>

-- | Whether a given <a>AttrOpTag</a> is allowed on an attribute, given the
--   info type.
type family AttrOpAllowed (tag :: AttrOpTag) (info :: *) (useType :: *) :: Constraint

-- | Constraints on a <tt>obj</tt>/<tt>attr</tt> pair so <a>get</a> is
--   possible, producing a value of type <tt>result</tt>.
type AttrGetC info obj attr result = (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, (AttrBaseTypeConstraint info) obj, AttrOpAllowed 'AttrGet info obj, result ~ AttrGetType info)

-- | Constraint on a <tt>obj</tt>/<tt>attr</tt> pair so that <a>set</a>
--   works on values of type <tt>value</tt>.
type AttrSetC info obj attr value = (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed 'AttrSet info obj, (AttrSetTypeConstraint info) value)

-- | Constraint on a <tt>obj</tt>/<tt>value</tt> pair so that <a>new</a>
--   works on values of type <tt>value</tt>.
type AttrConstructC info obj attr value = (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed 'AttrConstruct info obj, (AttrSetTypeConstraint info) value)

-- | Constraint on a <tt>obj</tt>/<tt>attr</tt> pair so that <a>clear</a>
--   is allowed.
type AttrClearC info obj attr = (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, (AttrBaseTypeConstraint info) obj, AttrOpAllowed 'AttrClear info obj)

-- | Get the value of an attribute for an object.
get :: forall info attr obj result m. (AttrGetC info obj attr result, MonadIO m) => obj -> AttrLabelProxy (attr :: Symbol) -> m result

-- | Set a number of properties for some object.
set :: forall o m. MonadIO m => o -> [AttrOp o 'AttrSet] -> m ()

-- | Set a nullable attribute to <tt>NULL</tt>.
clear :: forall info attr obj m. (AttrClearC info obj attr, MonadIO m) => obj -> AttrLabelProxy (attr :: Symbol) -> m ()

-- | A proxy for attribute labels.
data AttrLabelProxy (a :: Symbol)
AttrLabelProxy :: AttrLabelProxy (a :: Symbol)
instance GHC.Show.Show Data.GI.Base.Attributes.AttrOpTag
instance GHC.Enum.Bounded Data.GI.Base.Attributes.AttrOpTag
instance GHC.Enum.Enum Data.GI.Base.Attributes.AttrOpTag
instance GHC.Classes.Ord Data.GI.Base.Attributes.AttrOpTag
instance GHC.Classes.Eq Data.GI.Base.Attributes.AttrOpTag
instance (a GHC.Types.~ x) => GHC.OverloadedLabels.IsLabel x (Data.GI.Base.Attributes.AttrLabelProxy a)


-- | Basic support for <a>GQuark</a>s.
module Data.GI.Base.GQuark

-- | A <a>GQuark</a>, which is simply an integer.
newtype GQuark a
GQuark :: Word32 -> GQuark a

-- | Construct a GQuark from the given string.
gQuarkFromString :: Text -> IO (GQuark a)


-- | Management of <a>GParamSpec</a>s.
module Data.GI.Base.GParamSpec

-- | Take ownership of a ParamSpec passed in <a>Ptr</a>.
wrapGParamSpecPtr :: Ptr GParamSpec -> IO GParamSpec

-- | Construct a Haskell wrapper for the given <a>GParamSpec</a>, without
--   assuming ownership.
newGParamSpecFromPtr :: Ptr GParamSpec -> IO GParamSpec

-- | Remove a reference to the given <a>GParamSpec</a>.
unrefGParamSpec :: GParamSpec -> IO ()

-- | Disown a <a>GParamSpec</a>, i.e. do not longer unref the associated
--   foreign <a>GParamSpec</a> when the Haskell <a>GParamSpec</a> gets
--   garbage collected.
disownGParamSpec :: GParamSpec -> IO (Ptr GParamSpec)

-- | Information on a property encoding a Haskell value. Note that from the
--   C side this property will appear as an opaque pointer. Use the
--   specialized constructors below for creating properties meaningful from
--   the C side.
--   
--   A property name consists of segments consisting of ASCII letters and
--   digits, separated by either the '-' or '_' character. The first
--   character of a property name must be a letter. Names which violate
--   these rules lead to undefined behaviour.
--   
--   When creating and looking up a property, either separator can be used,
--   but they cannot be mixed. Using '-' is considerably more efficient and
--   in fact required when using property names as detail strings for
--   signals.
--   
--   Beyond the name, properties have two more descriptive strings
--   associated with them, the <tt>nick</tt>, which should be suitable for
--   use as a label for the property in a property editor, and the
--   <tt>blurb</tt>, which should be a somewhat longer description,
--   suitable for e.g. a tooltip. The <tt>nick</tt> and <tt>blurb</tt>
--   should ideally be localized.
data PropertyInfo o a
PropertyInfo :: Text -> Text -> Text -> (o -> a -> IO ()) -> (o -> IO a) -> Maybe [GParamFlag] -> PropertyInfo o a

-- | Identifier for the property.
[$sel:name:PropertyInfo] :: PropertyInfo o a -> Text

-- | Identifier for display to the user.
[$sel:nick:PropertyInfo] :: PropertyInfo o a -> Text

-- | Description of the property.
[$sel:blurb:PropertyInfo] :: PropertyInfo o a -> Text

-- | Handler invoked when the property is being set.
[$sel:setter:PropertyInfo] :: PropertyInfo o a -> o -> a -> IO ()

-- | Handler that returns the current value of the property.
[$sel:getter:PropertyInfo] :: PropertyInfo o a -> o -> IO a

-- | Set of flags, or <a>Nothing</a> for the default set of flags.
[$sel:flags:PropertyInfo] :: PropertyInfo o a -> Maybe [GParamFlag]

-- | Create a <a>GParamSpec</a> for a Haskell value.
gParamSpecValue :: forall o a. GObject o => PropertyInfo o a -> IO GParamSpec

-- | Information on a property of type <a>Text</a> to be registered. A
--   property name consists of segments consisting of ASCII letters and
--   digits, separated by either the '-' or '_' character. The first
--   character of a property name must be a letter. Names which violate
--   these rules lead to undefined behaviour.
--   
--   When creating and looking up a property, either separator can be used,
--   but they cannot be mixed. Using '-' is considerably more efficient and
--   in fact required when using property names as detail strings for
--   signals.
--   
--   Beyond the name, properties have two more descriptive strings
--   associated with them, the <tt>nick</tt>, which should be suitable for
--   use as a label for the property in a property editor, and the
--   <tt>blurb</tt>, which should be a somewhat longer description,
--   suitable for e.g. a tooltip. The <tt>nick</tt> and <tt>blurb</tt>
--   should ideally be localized.
data CStringPropertyInfo o
CStringPropertyInfo :: Text -> Text -> Text -> Maybe Text -> Maybe [GParamFlag] -> (o -> Maybe Text -> IO ()) -> (o -> IO (Maybe Text)) -> CStringPropertyInfo o
[$sel:name:CStringPropertyInfo] :: CStringPropertyInfo o -> Text
[$sel:nick:CStringPropertyInfo] :: CStringPropertyInfo o -> Text
[$sel:blurb:CStringPropertyInfo] :: CStringPropertyInfo o -> Text
[$sel:defaultValue:CStringPropertyInfo] :: CStringPropertyInfo o -> Maybe Text
[$sel:flags:CStringPropertyInfo] :: CStringPropertyInfo o -> Maybe [GParamFlag]
[$sel:setter:CStringPropertyInfo] :: CStringPropertyInfo o -> o -> Maybe Text -> IO ()
[$sel:getter:CStringPropertyInfo] :: CStringPropertyInfo o -> o -> IO (Maybe Text)

-- | Create a <a>GParamSpec</a> for a string param.
gParamSpecCString :: GObject o => CStringPropertyInfo o -> IO GParamSpec

-- | Information on a property of type <a>CInt</a> to be registered. A
--   property name consists of segments consisting of ASCII letters and
--   digits, separated by either the '-' or '_' character. The first
--   character of a property name must be a letter. Names which violate
--   these rules lead to undefined behaviour.
--   
--   When creating and looking up a property, either separator can be used,
--   but they cannot be mixed. Using '-' is considerably more efficient and
--   in fact required when using property names as detail strings for
--   signals.
--   
--   Beyond the name, properties have two more descriptive strings
--   associated with them, the <tt>nick</tt>, which should be suitable for
--   use as a label for the property in a property editor, and the
--   <tt>blurb</tt>, which should be a somewhat longer description,
--   suitable for e.g. a tooltip. The <tt>nick</tt> and <tt>blurb</tt>
--   should ideally be localized.
data CIntPropertyInfo o
CIntPropertyInfo :: Text -> Text -> Text -> CInt -> (o -> CInt -> IO ()) -> (o -> IO CInt) -> Maybe [GParamFlag] -> Maybe CInt -> Maybe CInt -> CIntPropertyInfo o

-- | Identifier for the property.
[$sel:name:CIntPropertyInfo] :: CIntPropertyInfo o -> Text

-- | Identifier for display to the user.
[$sel:nick:CIntPropertyInfo] :: CIntPropertyInfo o -> Text

-- | Description of the property.
[$sel:blurb:CIntPropertyInfo] :: CIntPropertyInfo o -> Text

-- | Default value.
[$sel:defaultValue:CIntPropertyInfo] :: CIntPropertyInfo o -> CInt

-- | Handler invoked when the property is being set.
[$sel:setter:CIntPropertyInfo] :: CIntPropertyInfo o -> o -> CInt -> IO ()

-- | Handler that returns the current value of the property.
[$sel:getter:CIntPropertyInfo] :: CIntPropertyInfo o -> o -> IO CInt

-- | Set of flags, or <a>Nothing</a> for the default set of flags.
[$sel:flags:CIntPropertyInfo] :: CIntPropertyInfo o -> Maybe [GParamFlag]

-- | Minimum value, or <a>Nothing</a>, which would be replaced by
--   <tt>MININT</tt>.
[$sel:minValue:CIntPropertyInfo] :: CIntPropertyInfo o -> Maybe CInt

-- | Maximum value, or <a>Nothing</a>, which would be replaced by
--   <tt>MAXINT</tt>.
[$sel:maxValue:CIntPropertyInfo] :: CIntPropertyInfo o -> Maybe CInt

-- | Create a <a>GParamSpec</a> for an integer param.
gParamSpecCInt :: GObject o => CIntPropertyInfo o -> IO GParamSpec

-- | Low-level getter and setter for the property.
data PropGetSetter o
PropGetSetter :: (Ptr o -> Ptr GValue -> IO ()) -> (Ptr o -> Ptr GValue -> IO ()) -> PropGetSetter o
[$sel:propGetter:PropGetSetter] :: PropGetSetter o -> Ptr o -> Ptr GValue -> IO ()
[$sel:propSetter:PropGetSetter] :: PropGetSetter o -> Ptr o -> Ptr GValue -> IO ()

-- | Attempt to get the Haskell setter and getter for the given
--   <a>GParamSpec</a>. This will only be possible if the <a>GParamSpec</a>
--   was created with one of the functions above, if this is not the case
--   the function will return <a>Nothing</a>.
getGParamSpecGetterSetter :: forall o. Ptr GParamSpec -> IO (Maybe (PropGetSetter o))
instance GHC.Classes.Eq Data.GI.Base.GParamSpec.GParamFlag
instance GHC.Show.Show Data.GI.Base.GParamSpec.GParamFlag
instance GHC.Enum.Enum Data.GI.Base.GParamSpec.GParamFlag
instance GHC.Classes.Ord Data.GI.Base.GParamSpec.GParamFlag
instance Data.GI.Base.BasicTypes.IsGFlag Data.GI.Base.GParamSpec.GParamFlag


-- | Routines for connecting <a>GObject</a>s to signals. There are two
--   basic variants, <a>on</a> and <a>after</a>, which correspond to
--   <a>g_signal_connect</a> and <a>g_signal_connect_after</a>,
--   respectively.
--   
--   Basic usage is
--   
--   <pre>
--   <a>on</a> widget #signalName $ do ...
--   </pre>
--   
--   or
--   
--   <pre>
--   <a>after</a> widget #signalName $ do ...
--   </pre>
--   
--   Note that in the Haskell bindings we represent the signal name in
--   camelCase, so a signal like <a>script-message-received</a> in the
--   original API becomes <a>scriptMessageReceived</a> in the bindings.
--   
--   There are two variants of note. If you want to provide a detail when
--   connecting the signal you can use <a>:::</a>, as follows:
--   
--   <pre>
--   <a>on</a> widget (#scriptMessageReceived <a>:::</a> "handlerName") $ do ...
--   </pre>
--   
--   On the other hand, if you want to connect to the "<a>notify</a>"
--   signal for a property of a widget, it is recommended to use instead
--   <a>PropertyNotify</a>, as follows:
--   
--   <pre>
--   <a>on</a> widget (<a>PropertyNotify</a> #propertyName) $ do ...
--   </pre>
--   
--   which has the advantage that it will be checked at compile time that
--   the widget does indeed have the property "<tt>propertyName</tt>".
module Data.GI.Base.Signals

-- | Connect a signal to a signal handler.
on :: forall object info m. (GObject object, MonadIO m, SignalInfo info) => object -> SignalProxy object info -> HaskellCallbackType info -> m SignalHandlerId

-- | Connect a signal to a handler, running the handler after the default
--   one.
after :: forall object info m. (GObject object, MonadIO m, SignalInfo info) => object -> SignalProxy object info -> HaskellCallbackType info -> m SignalHandlerId

-- | Support for overloaded signal connectors.
data SignalProxy (object :: *) (info :: *)

-- | A basic signal name connector.
[SignalProxy] :: SignalProxy o info

-- | A signal connector annotated with a detail.
[:::] :: forall o info. SignalProxy o info -> Text -> SignalProxy o info

-- | A signal connector for the <tt>notify</tt> signal on the given
--   property.
[PropertyNotify] :: (info ~ ResolveAttribute propName o, AttrInfo info, pl ~ AttrLabel info, KnownSymbol pl) => AttrLabelProxy propName -> SignalProxy o GObjectNotifySignalInfo

-- | Whether to connect a handler to a signal with <a>connectSignal</a> so
--   that it runs before/after the default handler for the given signal.
data SignalConnectMode

-- | Run before the default handler.
SignalConnectBefore :: SignalConnectMode

-- | Run after the default handler.
SignalConnectAfter :: SignalConnectMode

-- | Connect a signal to a handler, given as a <a>FunPtr</a>.
connectSignalFunPtr :: GObject o => o -> Text -> FunPtr a -> SignalConnectMode -> Maybe Text -> IO SignalHandlerId

-- | Disconnect a previously connected signal.
disconnectSignalHandler :: GObject o => o -> SignalHandlerId -> IO ()

-- | Type of a <a>GObject</a> signal handler id.
type SignalHandlerId = CULong

-- | Information about an overloaded signal.
class SignalInfo (info :: *) where {
    
    -- | The type for the signal handler.
    type family HaskellCallbackType info :: *;
}

-- | Connect a Haskell function to a signal of the given <a>GObject</a>,
--   specifying whether the handler will be called before or after the
--   default handler.
connectSignal :: (SignalInfo info, GObject o) => o -> HaskellCallbackType info -> SignalConnectMode -> Maybe Text -> IO SignalHandlerId

-- | Connection information for a "notify" signal indicating that a
--   specific property changed (see <a>PropertyNotify</a> for the relevant
--   constructor).
data GObjectNotifySignalInfo

-- | Generate an informative type error whenever one tries to use a signal
--   for which code generation has failed.
type family SignalCodeGenError (signalName :: Symbol) :: *
instance Data.GI.Base.Signals.SignalInfo Data.GI.Base.Signals.GObjectNotifySignalInfo
instance (info GHC.Types.~ Data.GI.Base.Overloading.ResolveSignal slot object) => GHC.OverloadedLabels.IsLabel slot (Data.GI.Base.Signals.SignalProxy object info)


-- | This module constains helpers for dealing with <a>GObject</a>-derived
--   types.
module Data.GI.Base.GObject

-- | Construct a GObject given the constructor and a list of settable
--   attributes. See <a>new</a> for a more general version.
constructGObject :: forall o m. (GObject o, MonadIO m) => (ManagedPtr o -> o) -> [AttrOp o 'AttrConstruct] -> m o

-- | Construct the given <a>GObject</a>, given a set of actions
--   constructing desired <a>GValue</a>s to set at construction time.
new' :: (MonadIO m, GObject o) => (ManagedPtr o -> o) -> [m (GValueConstruct o)] -> m o

-- | Get the value of a given key for the object.
gobjectGetUserData :: (HasCallStack, GObject o) => o -> GQuark a -> IO (Maybe a)

-- | Set the value of the user data for the given <a>GObject</a> to a
--   <a>StablePtr</a> to the given Haskell object. The <a>StablePtr</a>
--   will be freed when the object is destroyed, or the value is replaced.
gobjectSetUserData :: (HasCallStack, GObject o) => o -> GQuark a -> a -> IO ()

-- | A combination of <a>gobjectGetUserData</a> and
--   <a>gobjectSetUserData</a>, for convenience.
gobjectModifyUserData :: (HasCallStack, GObject o) => o -> GQuark a -> (Maybe a -> a) -> IO ()

-- | This typeclass contains the data necessary for defining a new
--   <a>GObject</a> type from Haskell.
class GObject a => DerivedGObject a where {
    
    -- | The parent type
    type family GObjectParentType a;
    
    -- | Type of the private data for each instance.
    type family GObjectPrivateData a;
}

-- | Name of the type, it should be unique.
objectTypeName :: DerivedGObject a => Text

-- | Code to run when the class is inited. This is a good place to register
--   signals and properties for the type.
objectClassInit :: DerivedGObject a => GObjectClass -> IO ()

-- | Code to run when each instance of the type is constructed. Returns the
--   private data to be associated with the new instance (use
--   <a>gobjectGetPrivateData</a> and <a>gobjectSetPrivateData</a> to
--   manipulate this further).
objectInstanceInit :: DerivedGObject a => GObjectClass -> a -> IO (GObjectPrivateData a)

-- | Register the given type into the <tt>GObject</tt> type system and
--   return the resulting <a>GType</a>, if it has not been registered
--   already. If the type has been registered already the existing
--   <a>GType</a> will be returned instead.
--   
--   Note that for this function to work the type must be an instance of
--   <a>DerivedGObject</a>.
registerGType :: forall o. (HasCallStack, DerivedGObject o, GObject (GObjectParentType o), GObject o) => (ManagedPtr o -> o) -> IO GType

-- | Get the private data associated with the given object.
gobjectGetPrivateData :: forall o. (HasCallStack, DerivedGObject o) => o -> IO (GObjectPrivateData o)

-- | Set the private data associated with the given object.
gobjectSetPrivateData :: forall o. (HasCallStack, DerivedGObject o) => o -> GObjectPrivateData o -> IO ()

-- | Modify the private data for the given object.
gobjectModifyPrivateData :: forall o. (HasCallStack, DerivedGObject o) => o -> (GObjectPrivateData o -> GObjectPrivateData o) -> IO ()

-- | Wrapper around <tt>GObjectClass</tt> on the C-side.
newtype GObjectClass
GObjectClass :: Ptr GObjectClass -> GObjectClass

-- | Find the <a>GType</a> associated to a given <a>GObjectClass</a>.
gtypeFromClass :: GObjectClass -> IO GType

-- | Find the <a>GType</a> for a given <a>GObject</a>.
gtypeFromInstance :: GObject o => o -> IO GType

-- | Add a Haskell object-valued property to the given object class.
gobjectInstallProperty :: DerivedGObject o => GObjectClass -> PropertyInfo o a -> IO ()

-- | Add a <a>CInt</a>-valued property to the given object class.
gobjectInstallCIntProperty :: DerivedGObject o => GObjectClass -> CIntPropertyInfo o -> IO ()

-- | Add a <a>CString</a>-valued property to the given object class.
gobjectInstallCStringProperty :: DerivedGObject o => GObjectClass -> CStringPropertyInfo o -> IO ()


-- | <a>Constructible</a> types are those for which <a>new</a> is defined.
--   Often these are <a>GObject</a>s, but it is possible to construct new
--   (zero-initialized) structures and unions too.
module Data.GI.Base.Constructible

-- | Constructible types, i.e. those which can be allocated by <a>new</a>.
class Constructible a (tag :: AttrOpTag)

-- | Allocate a new instance of the given type, with the given attributes.
new :: (Constructible a tag, MonadIO m) => (ManagedPtr a -> a) -> [AttrOp a tag] -> m a
instance (Data.GI.Base.BasicTypes.GObject a, tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrConstruct) => Data.GI.Base.Constructible.Constructible a tag


-- | To catch GError exceptions use the catchGError* or handleGError*
--   functions. They work in a similar way to the standard <a>catch</a> and
--   <a>handle</a> functions.
--   
--   To catch just a single specific error use <a>catchGErrorJust</a> /
--   <a>handleGErrorJust</a>. To catch any error in a particular error
--   domain use <a>catchGErrorJustDomain</a> /
--   <a>handleGErrorJustDomain</a>
--   
--   For convenience, generated code also includes specialized variants of
--   <a>catchGErrorJust</a> / <a>handleGErrorJust</a> for each error type.
--   For example, for errors of type <a>PixbufError</a> one could invoke
--   <a>catchPixbufError</a> / <a>handlePixbufError</a>. The definition is
--   simply
--   
--   <pre>
--   catchPixbufError :: IO a -&gt; (PixbufError -&gt; GErrorMessage -&gt; IO a) -&gt; IO a
--   catchPixbufError = catchGErrorJustDomain
--   </pre>
--   
--   Notice that the type is suitably specialized, so only errors of type
--   <a>PixbufError</a> will be caught.
module Data.GI.Base.GError

-- | A GError, consisting of a domain, code and a human readable message.
--   These can be accessed by <a>gerrorDomain</a>, <a>gerrorCode</a> and
--   <a>gerrorMessage</a> below.
newtype GError
GError :: ManagedPtr GError -> GError

-- | Return the domain for the given <a>GError</a>. This is a GQuark, a
--   textual representation can be obtained with <a>quarkToString</a>.
gerrorDomain :: GError -> IO GQuark

-- | The numeric code for the given <a>GError</a>.
gerrorCode :: GError -> IO GErrorCode

-- | A text message describing the <a>GError</a>.
gerrorMessage :: GError -> IO GErrorMessage

-- | A code used to identify the "namespace" of the error. Within each
--   error domain all the error codes are defined in an enumeration. Each
--   gtk/gnome module that uses GErrors has its own error domain. The
--   rationale behind using error domains is so that each module can
--   organise its own error codes without having to coordinate on a global
--   error code list.
type GErrorDomain = GQuark

-- | A code to identify a specific error within a given
--   <a>GErrorDomain</a>. Most of time you will not need to deal with this
--   raw code since there is an enumeration type for each error domain. Of
--   course which enumeration to use depends on the error domain, but if
--   you use <a>catchGErrorJustDomain</a> or <a>handleGErrorJustDomain</a>,
--   this is worked out for you automatically.
type GErrorCode = Int32

-- | A human readable error message.
type GErrorMessage = Text

-- | This will catch just a specific GError exception. If you need to catch
--   a range of related errors, <a>catchGErrorJustDomain</a> is probably
--   more appropriate. Example:
--   
--   <pre>
--   do image &lt;- catchGErrorJust PixbufErrorCorruptImage
--                 loadImage
--                 (\errorMessage -&gt; do log errorMessage
--                                      return mssingImagePlaceholder)
--   </pre>
catchGErrorJust :: GErrorClass err => err -> IO a -> (GErrorMessage -> IO a) -> IO a

-- | Catch all GErrors from a particular error domain. The handler function
--   should just deal with one error enumeration type. If you need to catch
--   errors from more than one error domain, use this function twice with
--   an appropriate handler functions for each.
--   
--   <pre>
--   catchGErrorJustDomain
--     loadImage
--     (\err message -&gt; case err of
--         PixbufErrorCorruptImage -&gt; ...
--         PixbufErrorInsufficientMemory -&gt; ...
--         PixbufErrorUnknownType -&gt; ...
--         _ -&gt; ...)
--   </pre>
catchGErrorJustDomain :: forall err a. GErrorClass err => IO a -> (err -> GErrorMessage -> IO a) -> IO a

-- | A verson of <a>handleGErrorJust</a> with the arguments swapped around.
handleGErrorJust :: GErrorClass err => err -> (GErrorMessage -> IO a) -> IO a -> IO a

-- | A verson of <a>catchGErrorJustDomain</a> with the arguments swapped
--   around.
handleGErrorJustDomain :: GErrorClass err => (err -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Create a new <a>GError</a>.
gerrorNew :: GErrorDomain -> GErrorCode -> GErrorMessage -> IO GError

-- | Each error domain's error enumeration type should be an instance of
--   this class. This class helps to hide the raw error and domain codes
--   from the user.
--   
--   Example for <a>PixbufError</a>:
--   
--   <pre>
--   instance GErrorClass PixbufError where
--     gerrorClassDomain _ = "gdk-pixbuf-error-quark"
--   </pre>
class Enum err => GErrorClass err
gerrorClassDomain :: GErrorClass err => err -> Text

-- | Run the given function catching possible <a>GError</a>s in its
--   execution. If a <a>GError</a> is emitted this throws the corresponding
--   exception.
propagateGError :: (Ptr (Ptr GError) -> IO a) -> IO a

-- | Like <a>propagateGError</a>, but allows to specify a custom handler
--   instead of just throwing the exception.
checkGError :: (Ptr (Ptr GError) -> IO a) -> (GError -> IO a) -> IO a

-- | If the passed in <tt><a>Maybe</a> <a>GError</a></tt> is not
--   <a>Nothing</a>, store a copy in the passed in pointer, unless the
--   pointer is <a>nullPtr</a>.
maybePokeGError :: Ptr (Ptr GError) -> Maybe GError -> IO ()
instance GHC.Show.Show Data.GI.Base.GError.GError
instance GHC.Exception.Type.Exception Data.GI.Base.GError.GError
instance Data.GI.Base.Overloading.HasParentTypes Data.GI.Base.GError.GError
instance Data.GI.Base.BasicTypes.TypedObject Data.GI.Base.GError.GError
instance Data.GI.Base.BasicTypes.GBoxed Data.GI.Base.GError.GError


-- | The Haskell Prelude exports a number of symbols that can easily
--   collide with functions appearing in bindings. The generated code
--   requires just a small subset of the functions in the Prelude, together
--   with some of the functionality in Data.GI.Base, we reexport this
--   explicitly here.
module Data.GI.Base.ShortPrelude
data Char
ord :: Char -> Int
chr :: Int -> Char
data Int
data Int8
data Int16
data Int32
data Int64
data Word8
data Word16
data Word32
data Word64
data ByteString
type CString = Ptr CChar
newtype CDouble
CDouble :: Double -> CDouble
newtype CFloat
CFloat :: Float -> CFloat
newtype CInt
CInt :: Int32 -> CInt
newtype CIntPtr
CIntPtr :: Int64 -> CIntPtr
newtype CLong
CLong :: Int64 -> CLong
newtype CUInt
CUInt :: Word32 -> CUInt
newtype CUIntPtr
CUIntPtr :: Word64 -> CUIntPtr
newtype CULong
CULong :: Word64 -> CULong
data Ptr a
data FunPtr a
castFunPtrToPtr :: FunPtr a -> Ptr b
castPtrToFunPtr :: Ptr a -> FunPtr b
nullPtr :: Ptr a
plusPtr :: Ptr a -> Int -> Ptr b
data ForeignPtr a
unsafeForeignPtrToPtr :: ForeignPtr a -> Ptr a
peek :: Storable a => Ptr a -> IO a
poke :: Storable a => Ptr a -> a -> IO ()
sizeOf :: Storable a => a -> Int
(<$>) :: Functor f => (a -> b) -> f a -> f b
onException :: IO a -> IO b -> IO a
class Monad m => MonadIO (m :: Type -> Type)
liftIO :: MonadIO m => IO a -> m a

-- | Constraint on a <tt>obj</tt>/<tt>attr</tt> pair so that <a>clear</a>
--   is allowed.
type AttrClearC info obj attr = (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, (AttrBaseTypeConstraint info) obj, AttrOpAllowed 'AttrClear info obj)

-- | Constraints on a <tt>obj</tt>/<tt>attr</tt> pair so <a>get</a> is
--   possible, producing a value of type <tt>result</tt>.
type AttrGetC info obj attr result = (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, (AttrBaseTypeConstraint info) obj, AttrOpAllowed 'AttrGet info obj, result ~ AttrGetType info)

-- | Constructors for the different operations allowed on an attribute.
data AttrOp obj (tag :: AttrOpTag)

-- | Assign a value to an attribute
[:=] :: (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrSetTypeConstraint info b) => AttrLabelProxy (attr :: Symbol) -> b -> AttrOp obj tag

-- | Assign the result of an IO action to an attribute
[:=>] :: (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrSetTypeConstraint info b) => AttrLabelProxy (attr :: Symbol) -> IO b -> AttrOp obj tag

-- | Apply an update function to an attribute
[:~] :: (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, tag ~ 'AttrSet, AttrOpAllowed 'AttrSet info obj, AttrOpAllowed 'AttrGet info obj, AttrSetTypeConstraint info b, a ~ AttrGetType info) => AttrLabelProxy (attr :: Symbol) -> (a -> b) -> AttrOp obj tag

-- | Apply an IO update function to an attribute
[:~>] :: (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, tag ~ 'AttrSet, AttrOpAllowed 'AttrSet info obj, AttrOpAllowed 'AttrGet info obj, AttrSetTypeConstraint info b, a ~ AttrGetType info) => AttrLabelProxy (attr :: Symbol) -> (a -> IO b) -> AttrOp obj tag

-- | Assign a value to an attribute, allocating any necessary memory for
--   representing the Haskell value as a C value. Note that it is the
--   responsibility of the caller to make sure that the memory is freed
--   when no longer used, otherwise there will be a memory leak. In the
--   majority of cases you probably want to use <a>:=</a> instead, which
--   has no potential memory leaks (at the cost of sometimes requiring some
--   explicit Haskell -&gt; C marshalling).
[:&=] :: (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrTransferTypeConstraint info b, AttrSetTypeConstraint info (AttrTransferType info)) => AttrLabelProxy (attr :: Symbol) -> b -> AttrOp obj tag
infixr 0 :=
infixr 0 :~
infixr 0 :=>
infixr 0 :~>

-- | Constraint on a <tt>obj</tt>/<tt>value</tt> pair so that <a>new</a>
--   works on values of type <tt>value</tt>.
type AttrConstructC info obj attr value = (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed 'AttrConstruct info obj, (AttrSetTypeConstraint info) value)

-- | Constraint on a <tt>obj</tt>/<tt>attr</tt> pair so that <a>set</a>
--   works on values of type <tt>value</tt>.
type AttrSetC info obj attr value = (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed 'AttrSet info obj, (AttrSetTypeConstraint info) value)

-- | Possible operations on an attribute.
data AttrOpTag

-- | It is possible to read the value of the attribute with <a>get</a>.
AttrGet :: AttrOpTag

-- | It is possible to write the value of the attribute with <a>set</a>.
AttrSet :: AttrOpTag

-- | It is possible to set the value of the attribute in <a>new</a>.
AttrConstruct :: AttrOpTag

-- | It is possible to clear the value of the (nullable) attribute with
--   <a>clear</a>.
AttrClear :: AttrOpTag

-- | Whether a given <a>AttrOpTag</a> is allowed on an attribute, given the
--   info type.
type family AttrOpAllowed (tag :: AttrOpTag) (info :: *) (useType :: *) :: Constraint

-- | Info describing an attribute.
class AttrInfo (info :: *) where {
    
    -- | The operations that are allowed on the attribute.
    type family AttrAllowedOps info :: [AttrOpTag];
    
    -- | Constraint on the type for which we are allowed to create/set/get the
    --   attribute.
    type family AttrBaseTypeConstraint info :: * -> Constraint;
    
    -- | Type returned by <a>attrGet</a>.
    type family AttrGetType info;
    
    -- | Constraint on the value being set.
    type family AttrSetTypeConstraint info :: * -> Constraint;
    
    -- | Constraint on the value being set, with allocation allowed (see
    --   <a>:&amp;=</a> below).
    type family AttrTransferTypeConstraint info :: * -> Constraint;
    
    -- | Type resulting from the allocation.
    type family AttrTransferType info :: *;
    
    -- | Name of the attribute.
    type family AttrLabel info :: Symbol;
    
    -- | Type which introduces the attribute.
    type family AttrOrigin info;
    type AttrSetTypeConstraint info = (~) (AttrGetType info);
    type AttrTransferTypeConstraint info = (~) (AttrTransferType info);
    type AttrTransferType info = AttrGetType info;
}

-- | Get the value of the given attribute.
attrGet :: (AttrInfo info, AttrBaseTypeConstraint info o) => o -> IO (AttrGetType info)

-- | Get the value of the given attribute.
attrGet :: (AttrInfo info, CheckNotElem 'AttrGet (AttrAllowedOps info) (GetNotProvidedError info)) => o -> IO (AttrGetType info)

-- | Set the value of the given attribute, after the object having the
--   attribute has already been created.
attrSet :: (AttrInfo info, AttrBaseTypeConstraint info o, AttrSetTypeConstraint info b) => o -> b -> IO ()

-- | Set the value of the given attribute, after the object having the
--   attribute has already been created.
attrSet :: (AttrInfo info, CheckNotElem 'AttrSet (AttrAllowedOps info) (SetNotProvidedError info)) => o -> b -> IO ()

-- | Set the value of the given attribute to <tt>NULL</tt> (for nullable
--   attributes).
attrClear :: (AttrInfo info, AttrBaseTypeConstraint info o) => o -> IO ()

-- | Set the value of the given attribute to <tt>NULL</tt> (for nullable
--   attributes).
attrClear :: (AttrInfo info, CheckNotElem 'AttrClear (AttrAllowedOps info) (ClearNotProvidedError info)) => o -> IO ()

-- | Build a <a>GValue</a> representing the attribute.
attrConstruct :: (AttrInfo info, AttrBaseTypeConstraint info o, AttrSetTypeConstraint info b) => b -> IO (GValueConstruct o)

-- | Build a <a>GValue</a> representing the attribute.
attrConstruct :: (AttrInfo info, CheckNotElem 'AttrConstruct (AttrAllowedOps info) (ConstructNotProvidedError info)) => b -> IO (GValueConstruct o)

-- | Allocate memory as necessary to generate a settable type from the
--   transfer type. This is useful for types which needs allocations for
--   marshalling from Haskell to C, this makes the allocation explicit.
attrTransfer :: forall o b. (AttrInfo info, AttrBaseTypeConstraint info o, AttrTransferTypeConstraint info b) => Proxy o -> b -> IO (AttrTransferType info)

-- | Allocate memory as necessary to generate a settable type from the
--   transfer type. This is useful for types which needs allocations for
--   marshalling from Haskell to C, this makes the allocation explicit.
attrTransfer :: forall o b. (AttrInfo info, AttrBaseTypeConstraint info o, AttrTransferTypeConstraint info b, b ~ AttrGetType info, b ~ AttrTransferType info) => Proxy o -> b -> IO (AttrTransferType info)

-- | A proxy for attribute labels.
data AttrLabelProxy (a :: Symbol)
AttrLabelProxy :: AttrLabelProxy (a :: Symbol)

-- | Set a nullable attribute to <tt>NULL</tt>.
clear :: forall info attr obj m. (AttrClearC info obj attr, MonadIO m) => obj -> AttrLabelProxy (attr :: Symbol) -> m ()

-- | The basic type. This corresponds to a wrapped <tt>GClosure</tt> on the
--   C side, which is a boxed object.
data GClosure a

-- | Connection information for a "notify" signal indicating that a
--   specific property changed (see <a>PropertyNotify</a> for the relevant
--   constructor).
data GObjectNotifySignalInfo

-- | Whether to connect a handler to a signal with <a>connectSignal</a> so
--   that it runs before/after the default handler for the given signal.
data SignalConnectMode

-- | Run before the default handler.
SignalConnectBefore :: SignalConnectMode

-- | Run after the default handler.
SignalConnectAfter :: SignalConnectMode

-- | Information about an overloaded signal.
class SignalInfo (info :: *) where {
    
    -- | The type for the signal handler.
    type family HaskellCallbackType info :: *;
}

-- | Connect a Haskell function to a signal of the given <a>GObject</a>,
--   specifying whether the handler will be called before or after the
--   default handler.
connectSignal :: (SignalInfo info, GObject o) => o -> HaskellCallbackType info -> SignalConnectMode -> Maybe Text -> IO SignalHandlerId

-- | Type of a <a>GObject</a> signal handler id.
type SignalHandlerId = CULong

-- | Connect a signal to a handler, given as a <a>FunPtr</a>.
connectSignalFunPtr :: GObject o => o -> Text -> FunPtr a -> SignalConnectMode -> Maybe Text -> IO SignalHandlerId
data Symbol
class Enum a
toEnum :: Enum a => Int -> a
fromEnum :: Enum a => a -> Int
class Show a
showsPrec :: Show a => Int -> a -> ShowS
show :: Show a => a -> String
showList :: Show a => [a] -> ShowS
class Eq a
(==) :: Eq a => a -> a -> Bool
(/=) :: Eq a => a -> a -> Bool
data IO a
class Applicative m => Monad (m :: Type -> Type)
(>>=) :: Monad m => m a -> (a -> m b) -> m b
(>>) :: Monad m => m a -> m b -> m b
return :: Monad m => a -> m a
data Maybe a
Nothing :: Maybe a
Just :: a -> Maybe a
(.) :: (b -> c) -> (a -> b) -> a -> c
($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
(++) :: [a] -> [a] -> [a]
(=<<) :: Monad m => (a -> m b) -> m a -> m b
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
data Bool
data Float
data Double
undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a
map :: (a -> b) -> [a] -> [b]
length :: Foldable t => t a -> Int
mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
when :: Applicative f => Bool -> f () -> f ()
fromIntegral :: (Integral a, Num b) => a -> b
realToFrac :: (Real a, Fractional b) => a -> b

module Data.GI.Base.Properties
setObjectPropertyString :: GObject a => a -> String -> Maybe Text -> IO ()
setObjectPropertyStringArray :: GObject a => a -> String -> Maybe [Text] -> IO ()
setObjectPropertyPtr :: GObject a => a -> String -> Ptr b -> IO ()
setObjectPropertyInt :: GObject a => a -> String -> CInt -> IO ()
setObjectPropertyUInt :: GObject a => a -> String -> CUInt -> IO ()
setObjectPropertyLong :: GObject a => a -> String -> CLong -> IO ()
setObjectPropertyULong :: GObject a => a -> String -> CULong -> IO ()
setObjectPropertyInt32 :: GObject a => a -> String -> Int32 -> IO ()
setObjectPropertyUInt32 :: GObject a => a -> String -> Word32 -> IO ()
setObjectPropertyInt64 :: GObject a => a -> String -> Int64 -> IO ()
setObjectPropertyUInt64 :: GObject a => a -> String -> Word64 -> IO ()
setObjectPropertyFloat :: GObject a => a -> String -> Float -> IO ()
setObjectPropertyDouble :: GObject a => a -> String -> Double -> IO ()
setObjectPropertyBool :: GObject a => a -> String -> Bool -> IO ()
setObjectPropertyGType :: GObject a => a -> String -> GType -> IO ()
setObjectPropertyObject :: forall a b. (GObject a, GObject b) => a -> String -> Maybe b -> IO ()
setObjectPropertyBoxed :: forall a b. (GObject a, GBoxed b) => a -> String -> Maybe b -> IO ()
setObjectPropertyEnum :: forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> b -> IO ()
setObjectPropertyFlags :: forall a b. (IsGFlag b, BoxedFlags b, GObject a) => a -> String -> [b] -> IO ()
setObjectPropertyClosure :: forall a b. GObject a => a -> String -> Maybe (GClosure b) -> IO ()
setObjectPropertyVariant :: GObject a => a -> String -> Maybe GVariant -> IO ()
setObjectPropertyByteArray :: GObject a => a -> String -> Maybe ByteString -> IO ()
setObjectPropertyPtrGList :: GObject a => a -> String -> [Ptr b] -> IO ()
setObjectPropertyHash :: GObject a => a -> String -> b -> IO ()
setObjectPropertyCallback :: GObject a => a -> String -> FunPtr b -> IO ()

-- | Set a property of type <a>GError</a>.
setObjectPropertyGError :: forall a. GObject a => a -> String -> Maybe GError -> IO ()

-- | Set a property of type <a>GValue</a>.
setObjectPropertyGValue :: forall a. GObject a => a -> String -> Maybe GValue -> IO ()
getObjectPropertyString :: GObject a => a -> String -> IO (Maybe Text)
getObjectPropertyStringArray :: GObject a => a -> String -> IO (Maybe [Text])
getObjectPropertyPtr :: GObject a => a -> String -> IO (Ptr b)
getObjectPropertyInt :: GObject a => a -> String -> IO CInt
getObjectPropertyUInt :: GObject a => a -> String -> IO CUInt
getObjectPropertyLong :: GObject a => a -> String -> IO CLong
getObjectPropertyULong :: GObject a => a -> String -> IO CULong
getObjectPropertyInt32 :: GObject a => a -> String -> IO Int32
getObjectPropertyUInt32 :: GObject a => a -> String -> IO Word32
getObjectPropertyInt64 :: GObject a => a -> String -> IO Int64
getObjectPropertyUInt64 :: GObject a => a -> String -> IO Word64
getObjectPropertyFloat :: GObject a => a -> String -> IO Float
getObjectPropertyDouble :: GObject a => a -> String -> IO Double
getObjectPropertyBool :: GObject a => a -> String -> IO Bool
getObjectPropertyGType :: GObject a => a -> String -> IO GType
getObjectPropertyObject :: forall a b. (GObject a, GObject b) => a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
getObjectPropertyBoxed :: forall a b. (GObject a, GBoxed b) => a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
getObjectPropertyEnum :: forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
getObjectPropertyFlags :: forall a b. (GObject a, IsGFlag b, BoxedFlags b) => a -> String -> IO [b]
getObjectPropertyClosure :: forall a b. GObject a => a -> String -> IO (Maybe (GClosure b))
getObjectPropertyVariant :: GObject a => a -> String -> IO (Maybe GVariant)
getObjectPropertyByteArray :: GObject a => a -> String -> IO (Maybe ByteString)
getObjectPropertyPtrGList :: GObject a => a -> String -> IO [Ptr b]
getObjectPropertyHash :: GObject a => a -> String -> IO b
getObjectPropertyCallback :: GObject a => a -> String -> (FunPtr b -> c) -> IO (Maybe c)

-- | Get the value of a property of type <a>GError</a>.
getObjectPropertyGError :: forall a. GObject a => a -> String -> IO (Maybe GError)

-- | Get the value of a property of type <a>GValue</a>.
getObjectPropertyGValue :: forall a. GObject a => a -> String -> IO (Maybe GValue)
constructObjectPropertyString :: String -> Maybe Text -> IO (GValueConstruct o)
constructObjectPropertyStringArray :: String -> Maybe [Text] -> IO (GValueConstruct o)
constructObjectPropertyPtr :: String -> Ptr b -> IO (GValueConstruct o)
constructObjectPropertyInt :: String -> CInt -> IO (GValueConstruct o)
constructObjectPropertyUInt :: String -> CUInt -> IO (GValueConstruct o)
constructObjectPropertyLong :: String -> CLong -> IO (GValueConstruct o)
constructObjectPropertyULong :: String -> CULong -> IO (GValueConstruct o)
constructObjectPropertyInt32 :: String -> Int32 -> IO (GValueConstruct o)
constructObjectPropertyUInt32 :: String -> Word32 -> IO (GValueConstruct o)
constructObjectPropertyInt64 :: String -> Int64 -> IO (GValueConstruct o)
constructObjectPropertyUInt64 :: String -> Word64 -> IO (GValueConstruct o)
constructObjectPropertyFloat :: String -> Float -> IO (GValueConstruct o)
constructObjectPropertyDouble :: String -> Double -> IO (GValueConstruct o)
constructObjectPropertyBool :: String -> Bool -> IO (GValueConstruct o)
constructObjectPropertyGType :: String -> GType -> IO (GValueConstruct o)
constructObjectPropertyObject :: forall a o. GObject a => String -> Maybe a -> IO (GValueConstruct o)
constructObjectPropertyBoxed :: forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
constructObjectPropertyEnum :: forall a o. (Enum a, BoxedEnum a) => String -> a -> IO (GValueConstruct o)
constructObjectPropertyFlags :: forall a o. (IsGFlag a, BoxedFlags a) => String -> [a] -> IO (GValueConstruct o)
constructObjectPropertyClosure :: String -> Maybe (GClosure a) -> IO (GValueConstruct o)
constructObjectPropertyVariant :: String -> Maybe GVariant -> IO (GValueConstruct o)
constructObjectPropertyByteArray :: String -> Maybe ByteString -> IO (GValueConstruct o)
constructObjectPropertyPtrGList :: String -> [Ptr a] -> IO (GValueConstruct o)
constructObjectPropertyHash :: String -> b -> IO (GValueConstruct o)
constructObjectPropertyCallback :: String -> FunPtr b -> IO (GValueConstruct o)

-- | Construct a property of type <a>GError</a>.
constructObjectPropertyGError :: String -> Maybe GError -> IO (GValueConstruct o)

-- | Construct a property of type <a>GValue</a>.
constructObjectPropertyGValue :: String -> Maybe GValue -> IO (GValueConstruct o)


-- | <h2>Convenience header for basic GObject-Introspection modules</h2>
--   
--   See the documentation for each individual module for a description and
--   usage help.
module Data.GI.Base

-- | Constructors for the different operations allowed on an attribute.
data AttrOp obj (tag :: AttrOpTag)

-- | Assign a value to an attribute
[:=] :: (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrSetTypeConstraint info b) => AttrLabelProxy (attr :: Symbol) -> b -> AttrOp obj tag

-- | Assign the result of an IO action to an attribute
[:=>] :: (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrSetTypeConstraint info b) => AttrLabelProxy (attr :: Symbol) -> IO b -> AttrOp obj tag

-- | Apply an update function to an attribute
[:~] :: (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, tag ~ 'AttrSet, AttrOpAllowed 'AttrSet info obj, AttrOpAllowed 'AttrGet info obj, AttrSetTypeConstraint info b, a ~ AttrGetType info) => AttrLabelProxy (attr :: Symbol) -> (a -> b) -> AttrOp obj tag

-- | Apply an IO update function to an attribute
[:~>] :: (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, tag ~ 'AttrSet, AttrOpAllowed 'AttrSet info obj, AttrOpAllowed 'AttrGet info obj, AttrSetTypeConstraint info b, a ~ AttrGetType info) => AttrLabelProxy (attr :: Symbol) -> (a -> IO b) -> AttrOp obj tag

-- | Assign a value to an attribute, allocating any necessary memory for
--   representing the Haskell value as a C value. Note that it is the
--   responsibility of the caller to make sure that the memory is freed
--   when no longer used, otherwise there will be a memory leak. In the
--   majority of cases you probably want to use <a>:=</a> instead, which
--   has no potential memory leaks (at the cost of sometimes requiring some
--   explicit Haskell -&gt; C marshalling).
[:&=] :: (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrTransferTypeConstraint info b, AttrSetTypeConstraint info (AttrTransferType info)) => AttrLabelProxy (attr :: Symbol) -> b -> AttrOp obj tag
infixr 0 :=
infixr 0 :~
infixr 0 :=>
infixr 0 :~>

-- | Set a number of properties for some object.
set :: forall o m. MonadIO m => o -> [AttrOp o 'AttrSet] -> m ()

-- | Get the value of an attribute for an object.
get :: forall info attr obj result m. (AttrGetC info obj attr result, MonadIO m) => obj -> AttrLabelProxy (attr :: Symbol) -> m result

-- | The basic type. This corresponds to a wrapped <tt>GClosure</tt> on the
--   C side, which is a boxed object.
data GClosure a

-- | Allocate a new instance of the given type, with the given attributes.
new :: (Constructible a tag, MonadIO m) => (ManagedPtr a -> a) -> [AttrOp a tag] -> m a

-- | A convenience class for marshaling back and forth between Haskell
--   values and <a>GValue</a>s.
class IsGValue a
toGValue :: IsGValue a => a -> IO GValue
fromGValue :: IsGValue a => GValue -> IO a

-- | Haskell-side representation of a <tt>GValue</tt>.
newtype GValue
GValue :: ManagedPtr GValue -> GValue

-- | Support for overloaded signal connectors.
data SignalProxy (object :: *) (info :: *)

-- | A signal connector annotated with a detail.
[:::] :: forall o info. SignalProxy o info -> Text -> SignalProxy o info

-- | A signal connector for the <tt>notify</tt> signal on the given
--   property.
[PropertyNotify] :: (info ~ ResolveAttribute propName o, AttrInfo info, pl ~ AttrLabel info, KnownSymbol pl) => AttrLabelProxy propName -> SignalProxy o GObjectNotifySignalInfo

-- | Connect a signal to a signal handler.
on :: forall object info m. (GObject object, MonadIO m, SignalInfo info) => object -> SignalProxy object info -> HaskellCallbackType info -> m SignalHandlerId

-- | Connect a signal to a handler, running the handler after the default
--   one.
after :: forall object info m. (GObject object, MonadIO m, SignalInfo info) => object -> SignalProxy object info -> HaskellCallbackType info -> m SignalHandlerId

-- | Safe coercions to a parent class. For instance:
--   
--   <pre>
--   #show $ label `asA` Gtk.Widget
--   </pre>
asA :: (ManagedPtrNewtype a, ManagedPtrNewtype b, HasParentTypes b, IsDescendantOf a b) => b -> (ManagedPtr a -> a) -> a
