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


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


-- | This is an <b>experimental</b> module that introduces support for
--   dynamic values: these are functions from a record <tt>model</tt> to
--   some type <tt>a</tt> which keep track of which selectors of
--   <tt>model</tt> does the result depend on. For example, for a record of
--   the form
--   
--   <pre>
--   data Example = Example {
--       first  :: Int,
--       second :: Bool,
--       third  :: Float
--   }
--   </pre>
--   
--   a `DynVal Example String` could be constructed, assuming that you are
--   given a <tt>record</tt> <a>DynVal</a> representing the full record,
--   using:
--   
--   <pre>
--   let format = \f s -&gt; "First is " &lt;&gt; f &lt;&gt; " and second is " &lt;&gt; s
--       formatted = format &lt;$&gt; record.first &lt;*&gt; record.second :: DynVal Example String
--   </pre>
--   
--   Here we are showcasing two properties of <a>DynVal</a>s: they can be
--   conveniently constructed using <tt>OverloadedRecordDot</tt>, and they
--   provide an <a>Applicative</a> instance. The resulting
--   <tt>formatted</tt> <a>DynVal</a> keeps track of the fact that it
--   depends on the <tt>first</tt> and <tt>second</tt> record selectors.
module Data.GI.Base.DynVal

-- | A <a>DynVal</a> is a way of extracting values of type <tt>a</tt> from
--   <tt>model</tt>, which keeps track of which fields (parameterised by
--   <a>dvKeys</a>) in <tt>model</tt> are needed for computing the
--   <a>DynVal</a>.
data DynVal model a
DynVal :: DVKey -> (model -> a) -> DynVal model a
data DVKey

-- | Direct access to subfields: for example writing
--   <tt>record.field.subfield</tt> (using the <a>HasField</a> instance)
--   would lead to <tt><a>DVKeyDirect</a> ["field", "subfield"]</tt>
DVKeyDirect :: [Text] -> DVKey

-- | Value derived from a direct key, by acting with the functor or
--   applicative instances.
DVKeyDerived :: Set [Text] -> DVKey

-- | A <a>ModelProxy</a> is a way of obtaining records of type
--   <tt>model</tt>, which allows for registering for notifications
--   whenever certain keys (typically associated to record fields) get
--   modified, and allows to modify fields of the model.
data ModelProxy model
ModelProxy :: IO model -> (DVKey -> (model -> IO ()) -> IO ()) -> ([Text] -> (model -> Maybe model) -> IO ()) -> ModelProxy model

-- | Keys to fields in the model that this <a>DynVal</a> depends on.
dvKeys :: DynVal model a -> DVKey

-- | Compute the actual value given a model.
dvRead :: DynVal model a -> model -> a

-- | Obtain the current value of the model.
modelProxyCurrentValue :: ModelProxy model -> IO model

-- | Register a handler that will be executed whenever any of the fields in
--   the model pointed to by the keys is modified.
modelProxyRegisterHandler :: ModelProxy model -> DVKey -> (model -> IO ()) -> IO ()

-- | Modify the given keys in the proxy, using the given update function,
--   of type (model -&gt; Maybe model). If this function returns Nothing no
--   modification will be performed, otherwise the modified model will be
--   stored in the ModelProxy, and any listeners will be notified of a
--   change.
modelProxyUpdate :: ModelProxy model -> [Text] -> (model -> Maybe model) -> IO ()
instance GHC.Internal.Base.Applicative (Data.GI.Base.DynVal.DynVal model)
instance GHC.Classes.Eq Data.GI.Base.DynVal.DVKey
instance GHC.Internal.Base.Functor (Data.GI.Base.DynVal.DynVal model)
instance (GHC.Internal.Records.HasField fieldName field a, GHC.Internal.TypeLits.KnownSymbol fieldName) => GHC.Internal.Records.HasField fieldName (Data.GI.Base.DynVal.DynVal model field) (Data.GI.Base.DynVal.DynVal model a)
instance GHC.Internal.Data.String.IsString (Data.GI.Base.DynVal.DynVal model Data.Text.Internal.Text)
instance GHC.Classes.Ord Data.GI.Base.DynVal.DVKey
instance GHC.Internal.Base.Semigroup Data.GI.Base.DynVal.DVKey
instance GHC.Internal.Show.Show Data.GI.Base.DynVal.DVKey


-- | Versions of hsc2hs older than 0.68.6 cannot deal with Haskell code
--   including promoted constructors, so isolate the required types in
--   here.
--   
--   <i>Warning</i>: This module is internal, and might disappear in the
--   future.
module Data.GI.Base.Internal.CTypes

-- | The Haskell type corresponding to a GQuark on the C side.
type GQuark = Word32

-- | The Haskell type corresponding to a gint on the C side.
type C_gint = Int32

-- | The size in bytes of a GValue struct in C.
cgvalueSize :: Int

-- | The offset in bytes inside a <tt>GError</tt> of its <tt>domain</tt>
--   field.
gerror_domain_offset :: Int

-- | The offset in bytes inside a <tt>GError</tt> of its <tt>code</tt>
--   field.
gerror_code_offset :: Int

-- | The offset in bytes inside a <tt>GError</tt> of its <tt>emssage</tt>
--   field.
gerror_message_offset :: Int


-- | Support for creating lenses from overloaded labels of the type
--   <tt>#fieldName</tt>, or <tt>#"fieldName.subfield"</tt>.
module Data.GI.Base.Internal.PathFieldAccess
type family Components (s :: Symbol) :: [Symbol]

-- | Create a lens for the given path, and return it together with the path
--   split into components.
class PathFieldAccess (path :: [Symbol]) model val | path model -> val
pathFieldAccess :: PathFieldAccess path model val => Proxy path -> Proxy model -> (Lens' model val, [Text])
instance (Optics.Internal.Generic.GFieldImpl fieldName model model val val, Data.GI.Base.Internal.PathFieldAccess.NonEmpty fieldName ('GHC.Internal.TypeError.Text "Field names cannot be empty"), GHC.Internal.TypeLits.KnownSymbol fieldName) => Data.GI.Base.Internal.PathFieldAccess.PathFieldAccess '[fieldName] model val
instance (Optics.Internal.Generic.GFieldImpl fieldName model model val val, GHC.Internal.TypeLits.KnownSymbol fieldName, Data.GI.Base.Internal.PathFieldAccess.PathFieldAccess rest val inner) => Data.GI.Base.Internal.PathFieldAccess.PathFieldAccess (fieldName : rest) model inner


-- | 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 = Word32

-- | 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 pointed to by a given pointer type.
type GDestroyNotify ptr = FunPtr ptr -> IO ()

-- | 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
instance GHC.Classes.Eq Data.GI.Base.BasicTypes.GType
instance GHC.Classes.Eq (Data.GI.Base.BasicTypes.ManagedPtr a)
instance GHC.Internal.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.Internal.Show.Show Data.GI.Base.BasicTypes.GType
instance GHC.Internal.Show.Show Data.GI.Base.BasicTypes.UnexpectedNullPointerReturn


-- | 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 :: [Type]

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

-- | 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, Type)]

-- | 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 :: k)

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

-- | 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, Type)]

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

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

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

-- | This is for debugging purposes, see <a>resolveMethod</a> below.
class OverloadedMethodInfo (i :: k) (o :: k1)
overloadedMethodInfo :: OverloadedMethodInfo i o => Maybe ResolvedSymbolInfo

-- | Class for types containing the information about an overloaded method
--   of type <tt>o -&gt; s</tt>.
class OverloadedMethod (i :: k) o s
overloadedMethod :: OverloadedMethod i o s => o -> s

-- | A proxy for carrying the types <tt>MethodInfoName</tt> needs (this is
--   used for <a>resolveMethod</a>, see below).
data MethodProxy info obj
MethodProxy :: MethodProxy info obj

-- | Information about a fully resolved symbol, for debugging purposes.
data ResolvedSymbolInfo
ResolvedSymbolInfo :: Text -> Text -> ResolvedSymbolInfo
[resolvedSymbolName] :: ResolvedSymbolInfo -> Text
[resolvedSymbolURL] :: ResolvedSymbolInfo -> Text

-- | Return the fully qualified method name that a given overloaded method
--   call resolves to (mostly useful for debugging).
--   
--   <pre>
--   resolveMethod widget #show
--   </pre>
resolveMethod :: OverloadedMethodInfo info obj => obj -> MethodProxy info obj -> Maybe ResolvedSymbolInfo
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
instance GHC.Internal.Show.Show Data.GI.Base.Overloading.ResolvedSymbolInfo


-- | 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> corresponding to <a>GParamSpec</a>.
gtypeParam :: GType

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

-- | The <a>GType</a> for a generic Haskell value.
gtypeHValue :: GType


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


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

-- | Similar to <a>safeFreeFunPtrPtr</a>, but accepts an additional
--   (ignored) argument. The first argument is interpreted as a
--   <a>FunPtr</a>, and released.
safeFreeFunPtrPtr' :: FunPtr (Ptr a -> Ptr b -> 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 finishes.
withTransient :: (HasCallStack, ManagedPtrNewtype 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 :: (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 :: ManagedPtrNewtype a => a -> IO ()

-- | Do not run the finalizers upon garbage collection of the
--   <a>ManagedPtr</a>.
disownManagedPtr :: (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 :: (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 :: (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

-- | Perform the given IO action with a wrapped copy of the given ptr to a
--   GObject. Note that this increases the reference count of the wrapped
--   GObject, similarly to <a>newObject</a>.
withNewObject :: (HasCallStack, GObject o) => Ptr o -> (o -> IO b) -> IO b

-- | Same as <a>newObject</a>, but we steal ownership of the object.
wrapObject :: (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 :: (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 :: (HasCallStack, GBoxed a) => (ManagedPtr a -> a) -> Ptr a -> IO a

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

-- | Like <a>copyBoxed</a>, but acting directly on a pointer, instead of a
--   managed pointer.
copyBoxedPtr :: 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 :: (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.BasicTypes.GBoxed (Data.GI.Base.GClosure.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)

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 :: Storable a => [a] -> IO (Ptr (GArray a))
unpackGArray :: 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 :: (Integral a, Storable b) => (b -> c) -> a -> Ptr b -> IO [c]
unpackMapZeroTerminatedStorableArray :: (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 :: (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 :: 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://docs.gtk.org/glib/struct.VariantType.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 :: 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 :: 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 :: (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 :: (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 :: IsGVariant a => [a] -> IO GVariant

-- | Unpack a <a>GVariant</a> array into its elements.
gvariantToList :: 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.Classes.Eq key, GHC.Classes.Eq value) => GHC.Classes.Eq (Data.GI.Base.GVariant.GVariantDictEntry key value)
instance GHC.Classes.Eq Data.GI.Base.GVariant.GVariantHandle
instance GHC.Classes.Eq Data.GI.Base.GVariant.GVariantObjectPath
instance GHC.Classes.Eq Data.GI.Base.GVariant.GVariantSignature
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.GI.Base.GVariant.GVariantSinglet a)
instance Data.GI.Base.GVariant.IsGVariantBasicType GHC.Types.Bool
instance Data.GI.Base.GVariant.IsGVariantBasicType GHC.Types.Double
instance Data.GI.Base.GVariant.IsGVariantBasicType Data.GI.Base.GVariant.GVariantHandle
instance Data.GI.Base.GVariant.IsGVariantBasicType Data.GI.Base.GVariant.GVariantObjectPath
instance Data.GI.Base.GVariant.IsGVariantBasicType Data.GI.Base.GVariant.GVariantSignature
instance Data.GI.Base.GVariant.IsGVariantBasicType GHC.Internal.Int.Int16
instance Data.GI.Base.GVariant.IsGVariantBasicType GHC.Internal.Int.Int32
instance Data.GI.Base.GVariant.IsGVariantBasicType GHC.Internal.Int.Int64
instance Data.GI.Base.GVariant.IsGVariantBasicType Data.Text.Internal.Text
instance Data.GI.Base.GVariant.IsGVariantBasicType GHC.Internal.Word.Word16
instance Data.GI.Base.GVariant.IsGVariantBasicType GHC.Internal.Word.Word32
instance Data.GI.Base.GVariant.IsGVariantBasicType GHC.Internal.Word.Word64
instance Data.GI.Base.GVariant.IsGVariantBasicType GHC.Internal.Word.Word8
instance Data.GI.Base.GVariant.IsGVariant GHC.Types.Bool
instance Data.GI.Base.GVariant.IsGVariant Data.ByteString.Internal.Type.ByteString
instance Data.GI.Base.GVariant.IsGVariant GHC.Types.Double
instance Data.GI.Base.GVariant.IsGVariant Data.GI.Base.BasicTypes.GVariant
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.GVariantHandle
instance Data.GI.Base.GVariant.IsGVariant Data.GI.Base.GVariant.GVariantObjectPath
instance Data.GI.Base.GVariant.IsGVariant Data.GI.Base.GVariant.GVariantSignature
instance Data.GI.Base.GVariant.IsGVariant a => Data.GI.Base.GVariant.IsGVariant (Data.GI.Base.GVariant.GVariantSinglet a)
instance Data.GI.Base.GVariant.IsGVariant GHC.Internal.Int.Int16
instance Data.GI.Base.GVariant.IsGVariant GHC.Internal.Int.Int32
instance Data.GI.Base.GVariant.IsGVariant GHC.Internal.Int.Int64
instance Data.GI.Base.GVariant.IsGVariant a => Data.GI.Base.GVariant.IsGVariant [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.Map.Internal.Map a b)
instance Data.GI.Base.GVariant.IsGVariant a => Data.GI.Base.GVariant.IsGVariant (GHC.Internal.Maybe.Maybe a)
instance Data.GI.Base.GVariant.IsGVariant Data.Text.Internal.Text
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)
instance Data.GI.Base.GVariant.IsGVariant ()
instance Data.GI.Base.GVariant.IsGVariant GHC.Internal.Word.Word16
instance Data.GI.Base.GVariant.IsGVariant GHC.Internal.Word.Word32
instance Data.GI.Base.GVariant.IsGVariant GHC.Internal.Word.Word64
instance Data.GI.Base.GVariant.IsGVariant GHC.Internal.Word.Word8
instance GHC.Classes.Ord Data.GI.Base.GVariant.GVariantHandle
instance GHC.Classes.Ord Data.GI.Base.GVariant.GVariantObjectPath
instance GHC.Classes.Ord Data.GI.Base.GVariant.GVariantSignature
instance (GHC.Internal.Show.Show key, GHC.Internal.Show.Show value) => GHC.Internal.Show.Show (Data.GI.Base.GVariant.GVariantDictEntry key value)
instance GHC.Internal.Show.Show Data.GI.Base.GVariant.GVariantHandle
instance GHC.Internal.Show.Show Data.GI.Base.GVariant.GVariantObjectPath
instance GHC.Internal.Show.Show Data.GI.Base.GVariant.GVariantSignature
instance GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Data.GI.Base.GVariant.GVariantSinglet a)

module Data.GI.Base.GValue

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

-- | Class for types that can be marshaled back and forth between Haskell
--   values and <a>GValue</a>s. These are low-level methods, you might want
--   to use <a>toGValue</a> and <a>fromGValue</a> instead for a higher
--   level interface.
class IsGValue a
gvalueGType_ :: IsGValue a => IO GType
gvalueSet_ :: IsGValue a => Ptr GValue -> a -> IO ()
gvalueGet_ :: IsGValue a => Ptr GValue -> IO a

-- | Create a <a>GValue</a> from the given Haskell value.
toGValue :: (IsGValue a, MonadIO m) => a -> m GValue

-- | Create a Haskell object out of the given <a>GValue</a>.
fromGValue :: (IsGValue a, MonadIO m) => GValue -> m 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

-- | A pointer to a function freeing GValues.
ptr_to_gvalue_free :: FunPtr (Ptr GValue -> IO ())

-- | 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 -> (Ptr 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 convenient alias for <tt>Nothing :: Maybe GValue</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 ()

-- | Return the <a>GType</a> contained by a <a>GValue</a>.
gvalueType :: GValue -> IO GType

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

-- | A type isomorphic to `Maybe a`, used to indicate to
--   <a>fromGValue</a>/<a>toGValue</a> that we are packing a native Haskell
--   value, without attempting to marshall it to the corresponding C type.
data HValue a

-- | A packed value of type <tt>a</tt>
HValue :: a -> HValue a

-- | An empty <a>HValue</a>
NoHValue :: HValue a
set_object :: GObject a => Ptr GValue -> Ptr a -> IO ()
get_object :: GObject a => Ptr GValue -> IO (Ptr a)
set_boxed :: Ptr GValue -> Ptr a -> IO ()
get_boxed :: Ptr GValue -> IO (Ptr b)
set_variant :: Ptr GValue -> Ptr GVariant -> IO ()
get_variant :: Ptr GValue -> IO (Ptr GVariant)
set_enum :: Ptr GValue -> CUInt -> IO ()
get_enum :: Ptr GValue -> IO CUInt
set_flags :: Ptr GValue -> CUInt -> IO ()
get_flags :: Ptr GValue -> IO CUInt

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

-- | Get (a freshly allocated copy of) the value of a <a>GValue</a>
--   containing a <a>StablePtr</a>
get_stablePtr :: Ptr 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 ()

-- | Set the value of <a>GValue</a> containing a <a>GParamSpec</a>
set_param :: Ptr GValue -> Maybe GParamSpec -> IO ()

-- | Get the value of a <a>GValue</a> containing a <a>GParamSpec</a>
get_param :: Ptr GValue -> IO (Maybe GParamSpec)

-- | Set the <a>GValue</a> to the given Haskell value.
set_hvalue :: Typeable a => Ptr GValue -> HValue a -> IO ()

-- | Read the Haskell value of the given type from the <a>GValue</a>. If
--   the <a>GValue</a> contains no value of the expected type,
--   <a>NoHValue</a> will be returned instead, and an error will be printed
--   to stderr.
get_hvalue :: Typeable a => Ptr GValue -> IO (HValue a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.GI.Base.GValue.HValue a)
instance Data.GI.Base.BasicTypes.GBoxed Data.GI.Base.GValue.GValue
instance Data.GI.Base.Overloading.HasParentTypes Data.GI.Base.GValue.GValue
instance Data.GI.Base.GValue.IsGValue GHC.Types.Bool
instance Data.GI.Base.GValue.IsGValue GHC.Internal.Foreign.C.Types.CInt
instance Data.GI.Base.GValue.IsGValue GHC.Internal.Foreign.C.Types.CLong
instance Data.GI.Base.GValue.IsGValue GHC.Internal.Foreign.C.Types.CUInt
instance Data.GI.Base.GValue.IsGValue GHC.Internal.Foreign.C.Types.CULong
instance Data.GI.Base.GValue.IsGValue GHC.Types.Double
instance Data.GI.Base.GValue.IsGValue GHC.Types.Float
instance Data.GI.Base.GValue.IsGValue Data.GI.Base.BasicTypes.GType
instance GHC.Internal.Data.Typeable.Internal.Typeable a => Data.GI.Base.GValue.IsGValue (Data.GI.Base.GValue.HValue a)
instance Data.GI.Base.GValue.IsGValue GHC.Internal.Int.Int32
instance Data.GI.Base.GValue.IsGValue GHC.Internal.Int.Int64
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GHC.Internal.Base.String)
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe Data.Text.Internal.Text)
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe Data.GI.Base.BasicTypes.GParamSpec)
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Ptr.Ptr a)
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Stable.StablePtr a)
instance Data.GI.Base.GValue.IsGValue GHC.Internal.Word.Word32
instance Data.GI.Base.GValue.IsGValue GHC.Internal.Word.Word64
instance GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Data.GI.Base.GValue.HValue a)
instance Data.GI.Base.BasicTypes.TypedObject Data.GI.Base.GValue.GValue


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

-- | Pack a <a>Ptr</a> to <a>GValue</a> into a <a>Ptr</a> than can go into
--   a <tt>GHashTable</tt>.
gvaluePackPtr :: Ptr GValue -> PtrWrapped (Ptr GValue)

-- | Extract a <a>Ptr</a> to <a>GValue</a> wrapped into a <a>Ptr</a> coming
--   from a <tt>GHashTable</tt>.
gvalueUnpackPtr :: PtrWrapped (Ptr GValue) -> Ptr 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 AttrAllowedOps info :: [AttrOpTag];
    
    -- | Constraint on the type for which we are allowed to create/set/get the
    --   attribute.
    type AttrBaseTypeConstraint info :: Type -> Constraint;
    
    -- | Type returned by <a>attrGet</a>.
    type AttrGetType info;
    
    -- | Constraint on the value being set.
    type AttrSetTypeConstraint info :: Type -> Constraint;
    
    -- | Constraint on the value being set, with allocation allowed (see
    --   <a>:&amp;=</a> below).
    type AttrTransferTypeConstraint info :: Type -> Constraint;
    
    -- | Type resulting from the allocation.
    type AttrTransferType info;
    
    -- | Name of the attribute.
    type AttrLabel info :: Symbol;
    
    -- | Type which introduces the attribute.
    type AttrOrigin info;
    type AttrSetTypeConstraint info = Type ~ AttrGetType info;
    type AttrTransferTypeConstraint info = Type ~ AttrTransferType info;
    type AttrTransferType info = AttrGetType info;
}

-- | Get the value of the given attribute.
attrGet :: (AttrInfo info, AttrBaseTypeConstraint info o) => o -> IO (AttrGetType info)
($dmattrGet) :: (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 ()
($dmattrSet) :: (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 ()
($dmattrClear) :: (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)
($dmattrConstruct) :: (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 :: (AttrInfo info, AttrBaseTypeConstraint info o, AttrTransferTypeConstraint info b) => Proxy o -> b -> IO (AttrTransferType info)
($dmattrTransfer) :: (AttrInfo info, AttrBaseTypeConstraint info o, AttrTransferTypeConstraint info b, b ~ AttrGetType info, b ~ AttrTransferType info) => Proxy o -> b -> IO (AttrTransferType info)

-- | Like <a>attrSet</a>, but it uses the same type as the getter. This is
--   useful for some nullable types, for which the getter returns <tt>Maybe
--   a</tt>, while the setter takes an <tt>a</tt>. <a>attrPut</a> will
--   instead accept an <tt>Maybe a</tt>.
attrPut :: (AttrInfo info, AttrBaseTypeConstraint info o) => o -> AttrGetType info -> IO ()
($dmattrPut) :: (AttrInfo info, CheckNotElem 'AttrPut (AttrAllowedOps info) (PutNotProvidedError info)) => o -> AttrGetType info -> IO ()

-- | Return some information about the overloaded attribute, useful for
--   debugging. See <a>resolveAttr</a> for how to access this conveniently.
dbgAttrInfo :: AttrInfo info => Maybe ResolvedSymbolInfo

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

-- | It is possible to set a value of the same type as the one returned by
--   <a>get</a>.
AttrPut :: AttrOpTag

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

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

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

-- | Apply an update function to an attribute
[:~] :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b a. (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 -> (a -> b) -> AttrOp obj tag

-- | Apply an IO update function to an attribute
[:~>] :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b a. (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 -> (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).
[:&=] :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrTransferTypeConstraint info b, AttrSetTypeConstraint info (AttrTransferType info)) => AttrLabelProxy attr -> b -> AttrOp obj tag

-- | Bind a property to the given <a>DynVal</a>, so that the property is
--   changed whenever the <a>DynVal</a> is. This requires the implicit
--   param <tt>?_haskell_gi_modelProxy</tt>, of type <tt><a>ModelProxy</a>
--   model</tt> to be set.
[:!<~] :: forall obj info (attr :: Symbol) (tag1 :: AttrOpTag) b model (tag :: AttrOpTag). (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag1 info obj, AttrSetTypeConstraint info b, ?_haskell_gi_modelProxy :: ModelProxy model) => AttrLabelProxy attr -> DynVal model b -> AttrOp obj tag

-- | Bind a property to the given <a>DynVal</a>, so that the property is
--   changed whenever the <a>DynVal</a> is. This requires the implicit
--   param <tt>?_haskell_gi_modelProxy</tt>, of type <tt><a>ModelProxy</a>
--   model</tt> to be set. This will only actually set the property
--   whenever the <a>DynVal</a> changes if the new value of the
--   <a>DynVal</a> is different from the actual value of the property. If
--   you want to set the property without checking equality you can use
--   <a>:!&lt;~</a> instead.
[:<~] :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b model. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrSetTypeConstraint info b, AttrOpAllowed 'AttrGet info obj, EqMaybe b (AttrGetType info), ?_haskell_gi_modelProxy :: ModelProxy model) => AttrLabelProxy attr -> DynVal model b -> AttrOp obj tag

-- | Given an AttrLabelProxy, bind the given attribute to the corresponding
--   field in the model proxy (if there's one), so that changes in the
--   attribute are reflected back into changes of the model.
[Bind] :: forall obj info (propName :: Symbol) (tag :: AttrOpTag) model outType (components :: [Symbol]) (fieldName :: Symbol). (HasAttributeList obj, GObject obj, info ~ ResolveAttribute propName obj, AttrInfo info, KnownSymbol (AttrLabel info), AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrOpAllowed 'AttrPut info obj, ?_haskell_gi_modelProxy :: ModelProxy model, outType ~ AttrGetType info, AttrSetTypeConstraint info outType, components ~ Components fieldName, PathFieldAccess components model outType, KnownSymbol fieldName, Eq outType) => AttrLabelProxy propName -> AttrLabelProxy fieldName -> AttrOp obj tag

-- | Connect the given signal to a signal handler.
[On] :: forall obj info (tag :: AttrOpTag). (GObject obj, SignalInfo info) => SignalProxy obj info -> ((?self :: obj) => HaskellCallbackType info) -> AttrOp obj tag

-- | Like <a>On</a>, but connect after the default signal.
[After] :: forall obj info (tag :: AttrOpTag). (GObject obj, SignalInfo info) => SignalProxy obj info -> ((?self :: obj) => HaskellCallbackType info) -> AttrOp obj tag
infixr 0 :=
infixr 0 :=>
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

-- | 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 :: Symbol) 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 :: Symbol) 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 :: Symbol) 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 :: Symbol) = (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 :: Symbol) obj result m. (AttrGetC info obj attr result, MonadIO m) => obj -> AttrLabelProxy attr -> 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 :: Symbol) obj m. (AttrClearC info obj attr, MonadIO m) => obj -> AttrLabelProxy attr -> m ()

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

-- | Return the fully qualified attribute name that a given overloaded
--   attribute resolves to (mostly useful for debugging).
--   
--   <pre>
--   resolveAttr #sensitive button
--   </pre>
resolveAttr :: forall info (attr :: Symbol) obj. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info) => obj -> AttrLabelProxy attr -> Maybe ResolvedSymbolInfo

-- | Create a binding between the given property of an object and a field
--   in the model.
bindPropToField :: forall o info (prop :: Symbol) (field :: Symbol) model outType (tag :: AttrOpTag) (components :: [Symbol]). (HasAttributeList o, GObject o, info ~ ResolveAttribute prop o, AttrInfo info, KnownSymbol (AttrLabel info), AttrBaseTypeConstraint info o, AttrOpAllowed tag info o, AttrOpAllowed 'AttrPut info o, ?_haskell_gi_modelProxy :: ModelProxy model, outType ~ AttrGetType info, AttrSetTypeConstraint info outType, components ~ Components field, PathFieldAccess components model outType, KnownSymbol field, Eq outType) => Proxy tag -> o -> AttrLabelProxy prop -> AttrLabelProxy field -> IO ()
class EqMaybe a b
eqMaybe :: EqMaybe a b => a -> b -> Bool
instance GHC.Internal.Enum.Bounded Data.GI.Base.Attributes.AttrOpTag
instance GHC.Internal.Enum.Enum Data.GI.Base.Attributes.AttrOpTag
instance GHC.Classes.Eq Data.GI.Base.Attributes.AttrOpTag
instance GHC.Classes.Eq a => Data.GI.Base.Attributes.EqMaybe a (GHC.Internal.Maybe.Maybe a)
instance GHC.Classes.Eq a => Data.GI.Base.Attributes.EqMaybe a a
instance (a GHC.Types.~ x) => GHC.Internal.OverloadedLabels.IsLabel x (Data.GI.Base.Attributes.AttrLabelProxy a)
instance GHC.Classes.Ord Data.GI.Base.Attributes.AttrOpTag
instance GHC.Internal.Show.Show Data.GI.Base.Attributes.AttrOpTag


-- | 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.
[name] :: PropertyInfo o a -> Text

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

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

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

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

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

-- | Create a <a>GParamSpec</a> for a Haskell value.
gParamSpecValue :: 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
[name] :: CStringPropertyInfo o -> Text
[nick] :: CStringPropertyInfo o -> Text
[blurb] :: CStringPropertyInfo o -> Text
[defaultValue] :: CStringPropertyInfo o -> Maybe Text
[flags] :: CStringPropertyInfo o -> Maybe [GParamFlag]
[setter] :: CStringPropertyInfo o -> o -> Maybe Text -> IO ()
[getter] :: 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.
[name] :: CIntPropertyInfo o -> Text

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

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

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

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

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

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

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

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

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

-- | Information on a property of type `type gboolean` 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 GBooleanPropertyInfo o
GBooleanPropertyInfo :: Text -> Text -> Text -> Bool -> Maybe [GParamFlag] -> (o -> Bool -> IO ()) -> (o -> IO Bool) -> GBooleanPropertyInfo o
[name] :: GBooleanPropertyInfo o -> Text
[nick] :: GBooleanPropertyInfo o -> Text
[blurb] :: GBooleanPropertyInfo o -> Text
[defaultValue] :: GBooleanPropertyInfo o -> Bool
[flags] :: GBooleanPropertyInfo o -> Maybe [GParamFlag]
[setter] :: GBooleanPropertyInfo o -> o -> Bool -> IO ()
[getter] :: GBooleanPropertyInfo o -> o -> IO Bool

-- | Create a <a>GParamSpec</a> for a bool param.
gParamSpecGBoolean :: GObject o => GBooleanPropertyInfo o -> IO GParamSpec

-- | Flags controlling the behaviour of the the parameters.
data GParamFlag

-- | the parameter is readable
GParamReadable :: GParamFlag

-- | the parameter is writable
GParamWritable :: GParamFlag

-- | the parameter will be set upon object construction
GParamConstruct :: GParamFlag

-- | the parameter can only be set upon object construction
GParamConstructOnly :: GParamFlag

-- | calls to <a>objectSetProperty</a> for this property will not
--   automatically result in a "notify" signal being emitted: the
--   implementation must call <a>objectNotify</a> themselves in case the
--   property actually changes.
GParamExplicitNotify :: GParamFlag

-- | Catch-all for unknown values
AnotherGParamFlag :: Int -> GParamFlag

-- | Low-level getter and setter for the property.
data PropGetSetter o
PropGetSetter :: (Ptr o -> Ptr GValue -> IO ()) -> (Ptr o -> Ptr GValue -> IO ()) -> PropGetSetter o
[propGetter] :: PropGetSetter o -> Ptr o -> Ptr GValue -> IO ()
[propSetter] :: 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 :: Ptr GParamSpec -> IO (Maybe (PropGetSetter o))
instance GHC.Internal.Enum.Enum Data.GI.Base.GParamSpec.GParamFlag
instance GHC.Classes.Eq Data.GI.Base.GParamSpec.GParamFlag
instance Data.GI.Base.BasicTypes.IsGFlag Data.GI.Base.GParamSpec.GParamFlag
instance GHC.Classes.Ord Data.GI.Base.GParamSpec.GParamFlag
instance GHC.Internal.Show.Show 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 -> ((?self :: object) => 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 -> ((?self :: object) => HaskellCallbackType info) -> m SignalHandlerId

-- | Support for overloaded signal connectors.
data SignalProxy object info

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

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

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

-- | A signal connector for the <tt>notify</tt> signal on the given
--   property, similar to <a>PropertyNotify</a>, but it passes the new
--   value of the property to the callback for convenience.
[PropertySet] :: forall info1 (propName :: Symbol) object b (pl :: Symbol). (info1 ~ ResolveAttribute propName object, AttrInfo info1, AttrBaseTypeConstraint info1 object, b ~ AttrGetType info1, pl ~ AttrLabel info1, KnownSymbol pl) => AttrLabelProxy propName -> SignalProxy object (GObjectPropertySetSignalInfo b)

-- | 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 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. Note that the callback being passed here admits an
--   extra initial parameter with respect to the usual Haskell callback
--   type. This will be passed as an <i>implicit</i> <tt>?self</tt>
--   argument to the Haskell callback.
connectSignal :: (SignalInfo info, GObject o) => o -> (o -> HaskellCallbackType info) -> SignalConnectMode -> Maybe Text -> IO SignalHandlerId

-- | Optional extra debug information, for <a>resolveSignal</a> below.
dbgSignalInfo :: SignalInfo info => Maybe ResolvedSymbolInfo

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

-- | Return the fully qualified signal name that a given overloaded signal
--   resolves to (mostly useful for debugging).
--   
--   <pre>
--   resolveSignal #childNotify button
--   </pre>
resolveSignal :: (GObject object, SignalInfo info) => object -> SignalProxy object info -> Maybe ResolvedSymbolInfo

-- | Connect the given notify callback for a GObject.
connectGObjectNotify :: GObject o => o -> (o -> GObjectNotifyCallback) -> SignalConnectMode -> Maybe Text -> IO SignalHandlerId
instance (info GHC.Types.~ Data.GI.Base.Overloading.ResolveSignal slot object) => GHC.Internal.OverloadedLabels.IsLabel slot (Data.GI.Base.Signals.SignalProxy object info)
instance Data.GI.Base.Signals.SignalInfo Data.GI.Base.Signals.GObjectNotifySignalInfo
instance Data.GI.Base.Signals.SignalInfo (Data.GI.Base.Signals.GObjectPropertySetSignalInfo b)


-- | 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 :: (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' :: (HasCallStack, 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
--   <tt>StablePtr</tt> to the given Haskell object. The <tt>StablePtr</tt>
--   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 GObjectParentType a;
    
    -- | Type of the private data for each instance.
    type 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)

-- | List of interfaces implemented by the type. Each element is a triplet
--   (<tt>gtype</tt>, <tt>interfaceInit</tt>, <tt>interfaceFinalize</tt>),
--   where <tt>gtype :: IO GType</tt> is a constructor for the type of the
--   interface, <tt>interfaceInit :: Ptr () -&gt; IO ()</tt> is a function
--   that registers the callbacks in the interface, and
--   <tt>interfaceFinalize :: Maybe (Ptr () -&gt; IO ())</tt> is the
--   (optional) finalizer.
objectInterfaces :: DerivedGObject a => [(IO GType, Ptr () -> IO (), Maybe (Ptr () -> IO ()))]

-- | 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 :: (HasCallStack, DerivedGObject o, GObject (GObjectParentType o), GObject o) => (ManagedPtr o -> o) -> IO GType

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

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

-- | Modify the private data for the given object.
gobjectModifyPrivateData :: (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 ()

-- | Add a `${type gboolean}`-valued property to the given object class.
gobjectInstallGBooleanProperty :: DerivedGObject o => GObjectClass -> GBooleanPropertyInfo 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 = C_gint

-- | 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 :: 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.Internal.Exception.Type.Exception Data.GI.Base.GError.GError
instance Data.GI.Base.BasicTypes.GBoxed Data.GI.Base.GError.GError
instance Data.GI.Base.Overloading.HasParentTypes Data.GI.Base.GError.GError
instance GHC.Internal.Show.Show Data.GI.Base.GError.GError
instance Data.GI.Base.BasicTypes.TypedObject 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 Int32
data Int64
data Int8
data Int16
data Word8
data Word32
data Word64
data Word16
data ByteString
newtype CInt
CInt :: Int32 -> CInt
newtype CUInt
CUInt :: Word32 -> CUInt
type CString = Ptr CChar
newtype CFloat
CFloat :: Float -> CFloat
newtype CDouble
CDouble :: Double -> CDouble
newtype CLong
CLong :: Int32 -> CLong
newtype CULong
CULong :: Word32 -> CULong
newtype CIntPtr
CIntPtr :: Int32 -> CIntPtr
newtype CUIntPtr
CUIntPtr :: Word32 -> CUIntPtr
data Ptr a
plusPtr :: Ptr a -> Int -> Ptr b
nullPtr :: Ptr a
data FunPtr a
castFunPtrToPtr :: FunPtr a -> Ptr b
castPtrToFunPtr :: Ptr a -> FunPtr 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

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

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

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

-- | Apply an update function to an attribute
[:~] :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b a. (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 -> (a -> b) -> AttrOp obj tag

-- | Apply an IO update function to an attribute
[:~>] :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b a. (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 -> (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).
[:&=] :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrTransferTypeConstraint info b, AttrSetTypeConstraint info (AttrTransferType info)) => AttrLabelProxy attr -> b -> AttrOp obj tag

-- | Bind a property to the given <a>DynVal</a>, so that the property is
--   changed whenever the <a>DynVal</a> is. This requires the implicit
--   param <tt>?_haskell_gi_modelProxy</tt>, of type <tt><a>ModelProxy</a>
--   model</tt> to be set.
[:!<~] :: forall obj info (attr :: Symbol) (tag1 :: AttrOpTag) b model (tag :: AttrOpTag). (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag1 info obj, AttrSetTypeConstraint info b, ?_haskell_gi_modelProxy :: ModelProxy model) => AttrLabelProxy attr -> DynVal model b -> AttrOp obj tag

-- | Bind a property to the given <a>DynVal</a>, so that the property is
--   changed whenever the <a>DynVal</a> is. This requires the implicit
--   param <tt>?_haskell_gi_modelProxy</tt>, of type <tt><a>ModelProxy</a>
--   model</tt> to be set. This will only actually set the property
--   whenever the <a>DynVal</a> changes if the new value of the
--   <a>DynVal</a> is different from the actual value of the property. If
--   you want to set the property without checking equality you can use
--   <a>:!&lt;~</a> instead.
[:<~] :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b model. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrSetTypeConstraint info b, AttrOpAllowed 'AttrGet info obj, EqMaybe b (AttrGetType info), ?_haskell_gi_modelProxy :: ModelProxy model) => AttrLabelProxy attr -> DynVal model b -> AttrOp obj tag

-- | Given an AttrLabelProxy, bind the given attribute to the corresponding
--   field in the model proxy (if there's one), so that changes in the
--   attribute are reflected back into changes of the model.
[Bind] :: forall obj info (propName :: Symbol) (tag :: AttrOpTag) model outType (components :: [Symbol]) (fieldName :: Symbol). (HasAttributeList obj, GObject obj, info ~ ResolveAttribute propName obj, AttrInfo info, KnownSymbol (AttrLabel info), AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrOpAllowed 'AttrPut info obj, ?_haskell_gi_modelProxy :: ModelProxy model, outType ~ AttrGetType info, AttrSetTypeConstraint info outType, components ~ Components fieldName, PathFieldAccess components model outType, KnownSymbol fieldName, Eq outType) => AttrLabelProxy propName -> AttrLabelProxy fieldName -> AttrOp obj tag

-- | Connect the given signal to a signal handler.
[On] :: forall obj info (tag :: AttrOpTag). (GObject obj, SignalInfo info) => SignalProxy obj info -> ((?self :: obj) => HaskellCallbackType info) -> AttrOp obj tag

-- | Like <a>On</a>, but connect after the default signal.
[After] :: forall obj info (tag :: AttrOpTag). (GObject obj, SignalInfo info) => SignalProxy obj info -> ((?self :: obj) => HaskellCallbackType info) -> AttrOp obj tag
infixr 0 :=
infixr 0 :=>
infixr 0 :~
infixr 0 :~>
infixr 0 :!<~
infixr 0 :<~

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

-- | Get the value of the given attribute.
attrGet :: (AttrInfo info, AttrBaseTypeConstraint info o) => o -> IO (AttrGetType info)
($dmattrGet) :: (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 ()
($dmattrSet) :: (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 ()
($dmattrClear) :: (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)
($dmattrConstruct) :: (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 :: (AttrInfo info, AttrBaseTypeConstraint info o, AttrTransferTypeConstraint info b) => Proxy o -> b -> IO (AttrTransferType info)
($dmattrTransfer) :: (AttrInfo info, AttrBaseTypeConstraint info o, AttrTransferTypeConstraint info b, b ~ AttrGetType info, b ~ AttrTransferType info) => Proxy o -> b -> IO (AttrTransferType info)

-- | Like <a>attrSet</a>, but it uses the same type as the getter. This is
--   useful for some nullable types, for which the getter returns <tt>Maybe
--   a</tt>, while the setter takes an <tt>a</tt>. <a>attrPut</a> will
--   instead accept an <tt>Maybe a</tt>.
attrPut :: (AttrInfo info, AttrBaseTypeConstraint info o) => o -> AttrGetType info -> IO ()
($dmattrPut) :: (AttrInfo info, CheckNotElem 'AttrPut (AttrAllowedOps info) (PutNotProvidedError info)) => o -> AttrGetType info -> IO ()

-- | Return some information about the overloaded attribute, useful for
--   debugging. See <a>resolveAttr</a> for how to access this conveniently.
dbgAttrInfo :: AttrInfo info => Maybe ResolvedSymbolInfo

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

-- | It is possible to set a value of the same type as the one returned by
--   <a>get</a>.
AttrPut :: AttrOpTag

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

-- | 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 :: Symbol) 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 :: Symbol) 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 :: Symbol) 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 :: Symbol) = (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed 'AttrClear info obj)

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

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

-- | Return the fully qualified attribute name that a given overloaded
--   attribute resolves to (mostly useful for debugging).
--   
--   <pre>
--   resolveAttr #sensitive button
--   </pre>
resolveAttr :: forall info (attr :: Symbol) obj. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info) => obj -> AttrLabelProxy attr -> Maybe ResolvedSymbolInfo

-- | Create a binding between the given property of an object and a field
--   in the model.
bindPropToField :: forall o info (prop :: Symbol) (field :: Symbol) model outType (tag :: AttrOpTag) (components :: [Symbol]). (HasAttributeList o, GObject o, info ~ ResolveAttribute prop o, AttrInfo info, KnownSymbol (AttrLabel info), AttrBaseTypeConstraint info o, AttrOpAllowed tag info o, AttrOpAllowed 'AttrPut info o, ?_haskell_gi_modelProxy :: ModelProxy model, outType ~ AttrGetType info, AttrSetTypeConstraint info outType, components ~ Components field, PathFieldAccess components model outType, KnownSymbol field, Eq outType) => Proxy tag -> o -> AttrLabelProxy prop -> AttrLabelProxy field -> IO ()
class EqMaybe a b
eqMaybe :: EqMaybe a b => a -> b -> Bool

-- | Name of the attribute.
type family AttrLabel info :: Symbol

-- | Type returned by <a>attrGet</a>.
type family AttrGetType info

-- | Constraint on the type for which we are allowed to create/set/get the
--   attribute.
type family AttrBaseTypeConstraint info :: Type -> Constraint

-- | The operations that are allowed on the attribute.
type family AttrAllowedOps info :: [AttrOpTag]

-- | Constraint on the value being set.
type family AttrSetTypeConstraint info :: Type -> Constraint

-- | Constraint on the value being set, with allocation allowed (see
--   <a>:&amp;=</a> below).
type family AttrTransferTypeConstraint info :: Type -> Constraint

-- | Type resulting from the allocation.
type family AttrTransferType info

-- | Type which introduces the attribute.
type family AttrOrigin info

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

-- | Information about an overloaded signal.
class SignalInfo info where {
    
    -- | The type for the signal handler.
    type 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. Note that the callback being passed here admits an
--   extra initial parameter with respect to the usual Haskell callback
--   type. This will be passed as an <i>implicit</i> <tt>?self</tt>
--   argument to the Haskell callback.
connectSignal :: (SignalInfo info, GObject o) => o -> (o -> HaskellCallbackType info) -> SignalConnectMode -> Maybe Text -> IO SignalHandlerId

-- | Optional extra debug information, for <a>resolveSignal</a> below.
dbgSignalInfo :: SignalInfo info => Maybe ResolvedSymbolInfo

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

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

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

-- | The type for the signal handler.
type family HaskellCallbackType info
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
($) :: (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 :: HasCallStack => a
error :: 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
class a ~# b => (a :: k) ~ (b :: k)

module Data.GI.Base.Properties

-- | Set a property for a type with a <a>IsGValue</a> instance.
setObjectPropertyIsGValueInstance :: (GObject a, IsGValue b) => a -> String -> b -> IO ()
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 :: (GObject a, GObject b) => a -> String -> Maybe b -> IO ()
setObjectPropertyBoxed :: (GObject a, GBoxed b) => a -> String -> Maybe b -> IO ()
setObjectPropertyEnum :: (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 :: 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 :: GObject a => a -> String -> Maybe GError -> IO ()

-- | Set a property of type <a>GValue</a>.
setObjectPropertyGValue :: GObject a => a -> String -> Maybe GValue -> IO ()

-- | Set a property of type <a>GParamSpec</a>.
setObjectPropertyParamSpec :: GObject a => a -> String -> Maybe GParamSpec -> IO ()

-- | Get a nullable property for a type with a <a>IsGValue</a> instance.
getObjectPropertyIsGValueInstance :: (GObject a, IsGValue b) => a -> String -> IO b
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 :: (GObject a, GObject b) => a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
getObjectPropertyBoxed :: (GObject a, GBoxed b) => a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
getObjectPropertyEnum :: (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
getObjectPropertyFlags :: (GObject a, IsGFlag b, BoxedFlags b) => a -> String -> IO [b]
getObjectPropertyClosure :: 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 :: GObject a => a -> String -> IO (Maybe GError)

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

-- | Get a property of type <a>GParamSpec</a>.
getObjectPropertyParamSpec :: GObject a => a -> String -> IO (Maybe GParamSpec)

-- | Construct a property for a type with a <a>IsGValue</a> instance.
constructObjectPropertyIsGValueInstance :: IsGValue b => String -> b -> IO (GValueConstruct o)
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 :: GObject a => String -> Maybe a -> IO (GValueConstruct o)
constructObjectPropertyBoxed :: GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
constructObjectPropertyEnum :: (Enum a, BoxedEnum a) => String -> a -> IO (GValueConstruct o)
constructObjectPropertyFlags :: (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)

-- | Construct a property of type <a>GParamSpec</a>.
constructObjectPropertyParamSpec :: String -> Maybe GParamSpec -> 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

-- | 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 :: Symbol) obj result m. (AttrGetC info obj attr result, MonadIO m) => obj -> AttrLabelProxy attr -> m result

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

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

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

-- | Apply an update function to an attribute
[:~] :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b a. (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 -> (a -> b) -> AttrOp obj tag

-- | Apply an IO update function to an attribute
[:~>] :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b a. (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 -> (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).
[:&=] :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrTransferTypeConstraint info b, AttrSetTypeConstraint info (AttrTransferType info)) => AttrLabelProxy attr -> b -> AttrOp obj tag

-- | Bind a property to the given <a>DynVal</a>, so that the property is
--   changed whenever the <a>DynVal</a> is. This requires the implicit
--   param <tt>?_haskell_gi_modelProxy</tt>, of type <tt><a>ModelProxy</a>
--   model</tt> to be set.
[:!<~] :: forall obj info (attr :: Symbol) (tag1 :: AttrOpTag) b model (tag :: AttrOpTag). (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag1 info obj, AttrSetTypeConstraint info b, ?_haskell_gi_modelProxy :: ModelProxy model) => AttrLabelProxy attr -> DynVal model b -> AttrOp obj tag

-- | Bind a property to the given <a>DynVal</a>, so that the property is
--   changed whenever the <a>DynVal</a> is. This requires the implicit
--   param <tt>?_haskell_gi_modelProxy</tt>, of type <tt><a>ModelProxy</a>
--   model</tt> to be set. This will only actually set the property
--   whenever the <a>DynVal</a> changes if the new value of the
--   <a>DynVal</a> is different from the actual value of the property. If
--   you want to set the property without checking equality you can use
--   <a>:!&lt;~</a> instead.
[:<~] :: forall obj info (attr :: Symbol) (tag :: AttrOpTag) b model. (HasAttributeList obj, info ~ ResolveAttribute attr obj, AttrInfo info, AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrSetTypeConstraint info b, AttrOpAllowed 'AttrGet info obj, EqMaybe b (AttrGetType info), ?_haskell_gi_modelProxy :: ModelProxy model) => AttrLabelProxy attr -> DynVal model b -> AttrOp obj tag

-- | Given an AttrLabelProxy, bind the given attribute to the corresponding
--   field in the model proxy (if there's one), so that changes in the
--   attribute are reflected back into changes of the model.
[Bind] :: forall obj info (propName :: Symbol) (tag :: AttrOpTag) model outType (components :: [Symbol]) (fieldName :: Symbol). (HasAttributeList obj, GObject obj, info ~ ResolveAttribute propName obj, AttrInfo info, KnownSymbol (AttrLabel info), AttrBaseTypeConstraint info obj, AttrOpAllowed tag info obj, AttrOpAllowed 'AttrPut info obj, ?_haskell_gi_modelProxy :: ModelProxy model, outType ~ AttrGetType info, AttrSetTypeConstraint info outType, components ~ Components fieldName, PathFieldAccess components model outType, KnownSymbol fieldName, Eq outType) => AttrLabelProxy propName -> AttrLabelProxy fieldName -> AttrOp obj tag

-- | Connect the given signal to a signal handler.
[On] :: forall obj info (tag :: AttrOpTag). (GObject obj, SignalInfo info) => SignalProxy obj info -> ((?self :: obj) => HaskellCallbackType info) -> AttrOp obj tag

-- | Like <a>On</a>, but connect after the default signal.
[After] :: forall obj info (tag :: AttrOpTag). (GObject obj, SignalInfo info) => SignalProxy obj info -> ((?self :: obj) => HaskellCallbackType info) -> AttrOp obj tag
infixr 0 :=
infixr 0 :=>
infixr 0 :~
infixr 0 :~>
infixr 0 :!<~
infixr 0 :<~

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

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

-- | Create a Haskell object out of the given <a>GValue</a>.
fromGValue :: (IsGValue a, MonadIO m) => GValue -> m a

-- | Create a <a>GValue</a> from the given Haskell value.
toGValue :: (IsGValue a, MonadIO m) => a -> m GValue

-- | Class for types that can be marshaled back and forth between Haskell
--   values and <a>GValue</a>s. These are low-level methods, you might want
--   to use <a>toGValue</a> and <a>fromGValue</a> instead for a higher
--   level interface.
class IsGValue a
gvalueGType_ :: IsGValue a => IO GType
gvalueSet_ :: IsGValue a => Ptr GValue -> a -> IO ()
gvalueGet_ :: IsGValue a => Ptr GValue -> IO a

-- | Connect a signal to a signal handler.
on :: forall object info m. (GObject object, MonadIO m, SignalInfo info) => object -> SignalProxy object info -> ((?self :: object) => 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 -> ((?self :: object) => HaskellCallbackType info) -> m SignalHandlerId

-- | Support for overloaded signal connectors.
data SignalProxy object info

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

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

-- | A signal connector for the <tt>notify</tt> signal on the given
--   property, similar to <a>PropertyNotify</a>, but it passes the new
--   value of the property to the callback for convenience.
[PropertySet] :: forall info1 (propName :: Symbol) object b (pl :: Symbol). (info1 ~ ResolveAttribute propName object, AttrInfo info1, AttrBaseTypeConstraint info1 object, b ~ AttrGetType info1, pl ~ AttrLabel info1, KnownSymbol pl) => AttrLabelProxy propName -> SignalProxy object (GObjectPropertySetSignalInfo b)

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