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


-- | GModule bindings
--   
--   Bindings for GModule, autogenerated by haskell-gi.
@package gi-gmodule
@version 2.0.6


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

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

-- | Modules in this package
modules :: [Text]


module GI.GModule.Constants

-- | <i>No description available in the introspection data.</i>
pattern MODULE_IMPL_WIN32 :: Int32

-- | <i>No description available in the introspection data.</i>
pattern MODULE_IMPL_NONE :: Int32

-- | <i>No description available in the introspection data.</i>
pattern MODULE_IMPL_DL :: Int32

-- | <i>No description available in the introspection data.</i>
pattern MODULE_IMPL_AR :: Int32


module GI.GModule.Enums

-- | Errors returned by <tt><i>g_module_open_full()</i></tt>.
--   
--   <i>Since: 2.70</i>
data ModuleError

-- | there was an error loading or opening a module file
ModuleErrorFailed :: ModuleError

-- | a module returned an error from its <tt>g_module_check_init()</tt>
--   function
ModuleErrorCheckFailed :: ModuleError

-- | Catch-all for unknown values
AnotherModuleError :: Int -> ModuleError

-- | Catch exceptions of type <a>ModuleError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchModuleError :: IO a -> (ModuleError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>ModuleError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handleModuleError :: (ModuleError -> GErrorMessage -> IO a) -> IO a -> IO a
instance GHC.Internal.Enum.Enum GI.GModule.Enums.ModuleError
instance GHC.Classes.Eq GI.GModule.Enums.ModuleError
instance Data.GI.Base.GError.GErrorClass GI.GModule.Enums.ModuleError
instance GHC.Classes.Ord GI.GModule.Enums.ModuleError
instance GHC.Internal.Show.Show GI.GModule.Enums.ModuleError


module GI.GModule.Flags

-- | Flags passed to <tt><i>g_module_open()</i></tt>. Note that these flags
--   are not supported on all platforms.
data ModuleFlags

-- | specifies that symbols are only resolved when needed. The default
--   action is to bind all symbols when the module is loaded.
ModuleFlagsLazy :: ModuleFlags

-- | specifies that symbols in the module should not be added to the global
--   name space. The default action on most platforms is to place symbols
--   in the module in the global name space, which may cause conflicts with
--   existing symbols.
ModuleFlagsLocal :: ModuleFlags

-- | mask for all flags.
ModuleFlagsMask :: ModuleFlags

-- | Catch-all for unknown values
AnotherModuleFlags :: Int -> ModuleFlags
instance GHC.Internal.Enum.Enum GI.GModule.Flags.ModuleFlags
instance GHC.Classes.Eq GI.GModule.Flags.ModuleFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GModule.Flags.ModuleFlags
instance GHC.Classes.Ord GI.GModule.Flags.ModuleFlags
instance GHC.Internal.Show.Show GI.GModule.Flags.ModuleFlags


-- | The <a>Module</a> struct is an opaque data structure to represent a
--   <a>dynamically-loaded module</a>. It should only be accessed via the
--   following functions.
--   
--   To ensure correct lock ordering, these functions must not be called
--   from global constructors (for example, those using GCC’s
--   <tt><b>attribute</b>((constructor))</tt> attribute).
module GI.GModule.Structs.Module

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

-- | A portable way to build the filename of a module. The
--   platform-specific prefix and suffix are added to the filename, if
--   needed, and the result is added to the directory, using the correct
--   separator character.
--   
--   The directory should specify the directory where the module can be
--   found. It can be <a>Nothing</a> or an empty string to indicate that
--   the module is in a standard platform-specific directory, though this
--   is not recommended since the wrong module may be found.
--   
--   For example, calling <a>moduleBuildPath</a> on a Linux system with a
--   <i><tt>directory</tt></i> of <tt>/lib</tt> and a
--   <i><tt>moduleName</tt></i> of "mylibrary" will return
--   <tt>/lib/libmylibrary.so</tt>. On a Windows system, using
--   <tt>\Windows</tt> as the directory it will return
--   <tt>\Windows\mylibrary.dll</tt>.

-- | <i>Deprecated: (Since version 2.76)Use <tt><i>g_module_open()</i></tt>
--   instead with <i><tt>moduleName</tt></i> as thebasename of the
--   file_name argument. See <a>MODULE_SUFFIX</a> for why.</i>
moduleBuildPath :: (HasCallStack, MonadIO m) => Maybe Text -> Text -> m Text

-- | Closes a module.
moduleClose :: (HasCallStack, MonadIO m) => Module -> m Bool

-- | Gets a string describing the last module error.
moduleError :: (HasCallStack, MonadIO m) => m Text

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

-- | Ensures that a module will never be unloaded. Any future
--   <a>moduleClose</a> calls on the module will be ignored.
moduleMakeResident :: (HasCallStack, MonadIO m) => Module -> m ()

-- | Returns the filename that the module was opened with.
--   
--   If <i><tt>module</tt></i> refers to the application itself, "main" is
--   returned.
moduleName :: (HasCallStack, MonadIO m) => Module -> m Text

-- | Checks if modules are supported on the current platform.
moduleSupported :: (HasCallStack, MonadIO m) => m Bool

-- | Gets a symbol pointer from a module, such as one exported by
--   <tt><i>G_MODULE_EXPORT</i></tt>. Note that a valid symbol can be
--   <a>Nothing</a>.
moduleSymbol :: (HasCallStack, MonadIO m) => Module -> Text -> m (Bool, Ptr ())
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GModule.Structs.Module.Module
instance GHC.Classes.Eq GI.GModule.Structs.Module.Module
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GModule.Structs.Module.Module


module GI.GModule.Structs


module GI.GModule.Callbacks

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

-- | Specifies the type of the module initialization function. If a module
--   contains a function named <tt><i>g_module_check_init()</i></tt> it is
--   called automatically when the module is loaded. It is passed the
--   <a>Module</a> structure and should return <a>Nothing</a> on success or
--   a string describing the initialization error.
type ModuleCheckInit = Module -> IO Text

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ModuleCheckInit :: (HasCallStack, MonadIO m) => FunPtr C_ModuleCheckInit -> Module -> m Text

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ModuleCheckInit :: MonadIO m => ModuleCheckInit -> m (GClosure C_ModuleCheckInit)

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

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ModuleCheckInit</a></tt>.
noModuleCheckInit :: Maybe ModuleCheckInit

-- | Wrap a <a>ModuleCheckInit</a> into a <a>C_ModuleCheckInit</a>.
wrap_ModuleCheckInit :: Maybe (Ptr (FunPtr C_ModuleCheckInit)) -> ModuleCheckInit -> C_ModuleCheckInit

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

-- | Specifies the type of the module function called when it is unloaded.
--   If a module contains a function named
--   <tt><i>g_module_unload()</i></tt> it is called automatically when the
--   module is unloaded. It is passed the <a>Module</a> structure.
type ModuleUnload = Module -> IO ()

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

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ModuleUnload :: MonadIO m => ModuleUnload -> m (GClosure C_ModuleUnload)

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

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ModuleUnload</a></tt>.
noModuleUnload :: Maybe ModuleUnload

-- | Wrap a <a>ModuleUnload</a> into a <a>C_ModuleUnload</a>.
wrap_ModuleUnload :: Maybe (Ptr (FunPtr C_ModuleUnload)) -> ModuleUnload -> C_ModuleUnload


module GI.GModule
data ManagedPtr a
ManagedPtr :: ForeignPtr a -> Maybe CallStack -> IORef (Maybe CallStack) -> ManagedPtr a
[managedForeignPtr] :: ManagedPtr a -> ForeignPtr a
[managedPtrAllocCallStack] :: ManagedPtr a -> Maybe CallStack
[managedPtrIsDisowned] :: ManagedPtr a -> IORef (Maybe CallStack)
data GArray a
GArray :: Ptr (GArray a) -> GArray a
data GClosure a
newtype GError
GError :: ManagedPtr GError -> GError
data GHashTable a b
GHashTable :: Ptr (GHashTable a b) -> GHashTable a b
newtype GVariant
GVariant :: ManagedPtr GVariant -> GVariant
newtype GValue
GValue :: ManagedPtr GValue -> GValue
newtype GParamSpec
GParamSpec :: ManagedPtr GParamSpec -> GParamSpec
class Enum a => IsGFlag a
new :: (Constructible a tag, MonadIO m) => (ManagedPtr a -> a) -> [AttrOp a tag] -> m a
get :: forall info (attr :: Symbol) obj result m. (AttrGetC info obj attr result, MonadIO m) => obj -> AttrLabelProxy attr -> m result
data AttrOp obj (tag :: AttrOpTag)
[:=] :: 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
[:=>] :: 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
[:~] :: 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
[:~>] :: 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
[:&=] :: 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
[:!<~] :: 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
[:<~] :: 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
[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
[On] :: forall obj info (tag :: AttrOpTag). (GObject obj, SignalInfo info) => SignalProxy obj info -> ((?self :: obj) => HaskellCallbackType info) -> AttrOp obj tag
[After] :: forall obj info (tag :: AttrOpTag). (GObject obj, SignalInfo info) => SignalProxy obj info -> ((?self :: obj) => HaskellCallbackType info) -> AttrOp obj tag
byteStringToCString :: ByteString -> IO CString
cstringToByteString :: HasCallStack => CString -> IO ByteString
cstringToString :: HasCallStack => CString -> IO String
cstringToText :: HasCallStack => CString -> IO Text
gflagsToWord :: (Num b, IsGFlag a) => [a] -> b
mapCArrayWithLength :: (Storable a, Integral b) => b -> (a -> IO c) -> Ptr a -> IO ()
mapGArray :: Storable a => (a -> IO b) -> Ptr (GArray a) -> IO ()
mapGList :: (Ptr a -> IO b) -> Ptr (GList (Ptr a)) -> IO ()
mapGSList :: (Ptr a -> IO b) -> Ptr (GSList (Ptr a)) -> IO ()
mapPtrArray :: (Ptr a -> IO b) -> Ptr (GPtrArray (Ptr a)) -> IO ()
mapZeroTerminatedCArray :: (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
packBlockArray :: Int -> [Ptr a] -> IO (Ptr a)
packByteString :: ByteString -> IO (Ptr Word8)
packFileNameArray :: [String] -> IO (Ptr CString)
packGArray :: Storable a => [a] -> IO (Ptr (GArray a))
packGByteArray :: ByteString -> IO (Ptr GByteArray)
packGHashTable :: GHashFunc a -> GEqualFunc a -> Maybe (GDestroyNotify a) -> Maybe (GDestroyNotify b) -> [(PtrWrapped a, PtrWrapped b)] -> IO (Ptr (GHashTable a b))
packGList :: [Ptr a] -> IO (Ptr (GList (Ptr a)))
packGPtrArray :: [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGSList :: [Ptr a] -> IO (Ptr (GSList (Ptr 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)
packPtrArray :: [Ptr a] -> IO (Ptr (Ptr a))
packStorableArray :: Storable a => [a] -> IO (Ptr a)
packUTF8CArray :: [Text] -> IO (Ptr CString)
packZeroTerminatedByteString :: ByteString -> IO (Ptr Word8)
packZeroTerminatedFileNameArray :: [String] -> IO (Ptr CString)
packZeroTerminatedPtrArray :: [Ptr a] -> IO (Ptr (Ptr a))
packZeroTerminatedStorableArray :: (Num a, Storable a) => [a] -> IO (Ptr a)
packZeroTerminatedUTF8CArray :: [Text] -> IO (Ptr CString)
stringToCString :: String -> IO CString
textToCString :: Text -> IO CString
unpackBlockArrayWithLength :: Integral a => Int -> a -> Ptr b -> IO [Ptr b]
unpackBoxedArrayWithLength :: (Integral a, GBoxed b) => Int -> a -> Ptr b -> IO [Ptr b]
unpackByteStringWithLength :: Integral a => a -> Ptr Word8 -> IO ByteString
unpackFileNameArrayWithLength :: (HasCallStack, Integral a) => a -> Ptr CString -> IO [String]
unpackGArray :: Storable a => Ptr (GArray a) -> IO [a]
unpackGByteArray :: Ptr GByteArray -> IO ByteString
unpackGHashTable :: Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGList :: Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGPtrArray :: Ptr (GPtrArray (Ptr a)) -> IO [Ptr a]
unpackGSList :: Ptr (GSList (Ptr a)) -> IO [Ptr a]
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]
unpackPtrArrayWithLength :: Integral a => a -> Ptr (Ptr b) -> IO [Ptr b]
unpackStorableArrayWithLength :: (Integral a, Storable b) => a -> Ptr b -> IO [b]
unpackUTF8CArrayWithLength :: (HasCallStack, Integral a) => a -> Ptr CString -> IO [Text]
unpackZeroTerminatedByteString :: Ptr Word8 -> IO ByteString
unpackZeroTerminatedFileNameArray :: HasCallStack => Ptr CString -> IO [String]
unpackZeroTerminatedPtrArray :: Ptr (Ptr a) -> IO [Ptr a]
unpackZeroTerminatedStorableArray :: (Eq a, Num a, Storable a) => Ptr a -> IO [a]
unpackZeroTerminatedUTF8CArray :: HasCallStack => Ptr CString -> IO [Text]
unrefGArray :: Ptr (GArray a) -> IO ()
unrefGByteArray :: Ptr GByteArray -> IO ()
unrefGHashTable :: Ptr (GHashTable a b) -> IO ()
unrefPtrArray :: Ptr (GPtrArray a) -> IO ()
withTextCString :: Text -> (CString -> IO a) -> IO a
wordToGFlags :: (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
class TypedObject a => BoxedEnum a
class TypedObject a => BoxedFlags a
class ManagedPtrNewtype a => BoxedPtr a
boxedPtrCopy :: BoxedPtr a => a -> IO a
boxedPtrFree :: BoxedPtr a => a -> IO ()
type CGType = Word32
class BoxedPtr a => CallocPtr a
boxedPtrCalloc :: CallocPtr a => IO (Ptr a)
class (ManagedPtrNewtype a, TypedObject a) => GBoxed a
data GByteArray
GByteArray :: Ptr GByteArray -> GByteArray
type GDestroyNotify ptr = FunPtr ptr -> IO ()
type GEqualFunc a = FunPtr PtrWrapped a -> PtrWrapped a -> IO Int32
type GHashFunc a = FunPtr PtrWrapped a -> IO Word32
data GList a
GList :: Ptr (GList a) -> GList a
class (ManagedPtrNewtype a, TypedObject a) => GObject a
data GPtrArray a
GPtrArray :: Ptr (GPtrArray a) -> GPtrArray a
data GSList a
GSList :: Ptr (GSList a) -> GSList a
newtype GType
GType :: CGType -> GType
[gtypeToCGType] :: GType -> CGType
class Coercible a ManagedPtr () => ManagedPtrNewtype a
toManagedPtr :: ManagedPtrNewtype a => a -> ManagedPtr a
newtype PtrWrapped a
PtrWrapped :: Ptr a -> PtrWrapped a
[unwrapPtr] :: PtrWrapped a -> Ptr a
class HasParentTypes a => TypedObject a
glibType :: TypedObject a => IO GType
data UnexpectedNullPointerReturn
UnexpectedNullPointerReturn :: Text -> UnexpectedNullPointerReturn
[nullPtrErrorMsg] :: UnexpectedNullPointerReturn -> Text
g_list_free :: Ptr (GList a) -> IO ()
g_slist_free :: Ptr (GSList a) -> IO ()
gtypeName :: GType -> IO String
noGParamSpec :: Maybe GParamSpec
class Enum err => GErrorClass err
gerrorClassDomain :: GErrorClass err => err -> Text
type GErrorCode = C_gint
type GErrorDomain = GQuark
type GErrorMessage = Text
catchGErrorJust :: GErrorClass err => err -> IO a -> (GErrorMessage -> IO a) -> IO a
catchGErrorJustDomain :: GErrorClass err => IO a -> (err -> GErrorMessage -> IO a) -> IO a
checkGError :: (Ptr (Ptr GError) -> IO a) -> (GError -> IO a) -> IO a
gerrorCode :: GError -> IO GErrorCode
gerrorDomain :: GError -> IO GQuark
gerrorMessage :: GError -> IO GErrorMessage
gerrorNew :: GErrorDomain -> GErrorCode -> GErrorMessage -> IO GError
handleGErrorJust :: GErrorClass err => err -> (GErrorMessage -> IO a) -> IO a -> IO a
handleGErrorJustDomain :: GErrorClass err => (err -> GErrorMessage -> IO a) -> IO a -> IO a
maybePokeGError :: Ptr (Ptr GError) -> Maybe GError -> IO ()
propagateGError :: (Ptr (Ptr GError) -> IO a) -> IO a
cstringPackPtr :: CString -> PtrWrapped CString
cstringUnpackPtr :: PtrWrapped CString -> CString
gDirectEqual :: GEqualFunc (Ptr a)
gDirectHash :: GHashFunc (Ptr a)
gStrEqual :: GEqualFunc CString
gStrHash :: GHashFunc CString
gvaluePackPtr :: Ptr GValue -> PtrWrapped (Ptr GValue)
gvalueUnpackPtr :: PtrWrapped (Ptr GValue) -> Ptr GValue
ptrPackPtr :: Ptr a -> PtrWrapped (Ptr a)
ptrUnpackPtr :: PtrWrapped (Ptr a) -> Ptr a
class IsGValue a
gvalueGType_ :: IsGValue a => IO GType
gvalueSet_ :: IsGValue a => Ptr GValue -> a -> IO ()
gvalueGet_ :: IsGValue a => Ptr GValue -> IO a
fromGValue :: (IsGValue a, MonadIO m) => GValue -> m a
toGValue :: (IsGValue a, MonadIO m) => a -> m GValue
data GVariantDictEntry key value
GVariantDictEntry :: key -> value -> GVariantDictEntry key value
newtype GVariantHandle
GVariantHandle :: Int32 -> GVariantHandle
data GVariantObjectPath
data GVariantSignature
newtype GVariantSinglet a
GVariantSinglet :: a -> GVariantSinglet a
class IsGVariant a
toGVariant :: IsGVariant a => a -> IO GVariant
fromGVariant :: IsGVariant a => GVariant -> IO (Maybe a)
toGVariantFormatString :: IsGVariant a => a -> Text
class Ord a => IsGVariantBasicType a
disownGVariant :: GVariant -> IO (Ptr GVariant)
gvariantFromBool :: Bool -> IO GVariant
gvariantFromBytestring :: ByteString -> IO GVariant
gvariantFromDictEntry :: (IsGVariant key, IsGVariantBasicType key, IsGVariant value) => key -> value -> IO GVariant
gvariantFromDouble :: Double -> IO GVariant
gvariantFromGVariant :: GVariant -> IO GVariant
gvariantFromHandle :: Int32 -> IO GVariant
gvariantFromInt16 :: Int16 -> IO GVariant
gvariantFromInt32 :: Int32 -> IO GVariant
gvariantFromInt64 :: Int64 -> IO GVariant
gvariantFromList :: IsGVariant a => [a] -> IO GVariant
gvariantFromMap :: (IsGVariant key, IsGVariantBasicType key, IsGVariant value) => Map key value -> IO GVariant
gvariantFromMaybe :: IsGVariant a => Maybe a -> IO GVariant
gvariantFromObjectPath :: GVariantObjectPath -> IO GVariant
gvariantFromSignature :: GVariantSignature -> IO GVariant
gvariantFromText :: Text -> IO GVariant
gvariantFromTuple :: [GVariant] -> IO GVariant
gvariantFromWord16 :: Word16 -> IO GVariant
gvariantFromWord32 :: Word32 -> IO GVariant
gvariantFromWord64 :: Word64 -> IO GVariant
gvariantFromWord8 :: Word8 -> IO GVariant
gvariantGetTypeString :: GVariant -> IO Text
gvariantObjectPathToText :: GVariantObjectPath -> Text
gvariantSignatureToText :: GVariantSignature -> Text
gvariantToBool :: GVariant -> IO (Maybe Bool)
gvariantToBytestring :: GVariant -> IO (Maybe ByteString)
gvariantToDictEntry :: (IsGVariant key, IsGVariantBasicType key, IsGVariant value) => GVariant -> IO (Maybe (key, value))
gvariantToDouble :: GVariant -> IO (Maybe Double)
gvariantToGVariant :: GVariant -> IO (Maybe GVariant)
gvariantToHandle :: GVariant -> IO (Maybe Int32)
gvariantToInt16 :: GVariant -> IO (Maybe Int16)
gvariantToInt32 :: GVariant -> IO (Maybe Int32)
gvariantToInt64 :: GVariant -> IO (Maybe Int64)
gvariantToList :: IsGVariant a => GVariant -> IO (Maybe [a])
gvariantToMap :: (IsGVariant key, IsGVariantBasicType key, IsGVariant value) => GVariant -> IO (Maybe (Map key value))
gvariantToMaybe :: IsGVariant a => GVariant -> IO (Maybe (Maybe a))
gvariantToObjectPath :: GVariant -> IO (Maybe Text)
gvariantToSignature :: GVariant -> IO (Maybe Text)
gvariantToText :: GVariant -> IO (Maybe Text)
gvariantToTuple :: GVariant -> IO (Maybe [GVariant])
gvariantToWord16 :: GVariant -> IO (Maybe Word16)
gvariantToWord32 :: GVariant -> IO (Maybe Word32)
gvariantToWord64 :: GVariant -> IO (Maybe Word64)
gvariantToWord8 :: GVariant -> IO (Maybe Word8)
newGVariantFromPtr :: Ptr GVariant -> IO GVariant
newGVariantObjectPath :: Text -> Maybe GVariantObjectPath
newGVariantSignature :: Text -> Maybe GVariantSignature
noGVariant :: Maybe GVariant
unrefGVariant :: GVariant -> IO ()
wrapGVariantPtr :: Ptr GVariant -> IO GVariant
castTo :: (HasCallStack, ManagedPtrNewtype o, TypedObject o, ManagedPtrNewtype o', TypedObject o', GObject o') => (ManagedPtr o' -> o') -> o -> IO (Maybe o')
checkInstanceType :: (ManagedPtrNewtype o, TypedObject o) => o -> GType -> IO Bool
copyBoxed :: (HasCallStack, GBoxed a) => a -> IO (Ptr a)
copyBoxedPtr :: GBoxed a => Ptr a -> IO (Ptr a)
copyBytes :: (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
disownBoxed :: (HasCallStack, GBoxed a) => a -> IO (Ptr a)
disownManagedPtr :: (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
disownObject :: (HasCallStack, GObject a) => a -> IO (Ptr b)
freeBoxed :: (HasCallStack, GBoxed a) => a -> IO ()
maybeWithManagedPtr :: (HasCallStack, ManagedPtrNewtype a) => Maybe a -> (Ptr a -> IO c) -> IO c
newBoxed :: (HasCallStack, GBoxed a) => (ManagedPtr a -> a) -> Ptr a -> IO a
newManagedPtr :: HasCallStack => Ptr a -> IO () -> IO (ManagedPtr a)
newManagedPtr' :: HasCallStack => FinalizerPtr a -> Ptr a -> IO (ManagedPtr a)
newManagedPtr_ :: Ptr a -> IO (ManagedPtr a)
newObject :: (HasCallStack, GObject a, GObject b) => (ManagedPtr a -> a) -> Ptr b -> IO a
newPtr :: (HasCallStack, BoxedPtr a) => (ManagedPtr a -> a) -> Ptr a -> IO a
releaseObject :: (HasCallStack, GObject a) => a -> IO ()
touchManagedPtr :: ManagedPtrNewtype a => a -> IO ()
unrefObject :: (HasCallStack, GObject a) => a -> IO ()
unsafeCastTo :: (HasCallStack, ManagedPtrNewtype o, TypedObject o, ManagedPtrNewtype o', TypedObject o') => (ManagedPtr o' -> o') -> o -> IO o'
unsafeManagedPtrCastPtr :: (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrGetPtr :: (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
withManagedPtr :: (HasCallStack, ManagedPtrNewtype a) => a -> (Ptr a -> IO c) -> IO c
withManagedPtrList :: (HasCallStack, ManagedPtrNewtype a) => [a] -> ([Ptr a] -> IO c) -> IO c
withNewObject :: (HasCallStack, GObject o) => Ptr o -> (o -> IO b) -> IO b
withTransient :: (HasCallStack, ManagedPtrNewtype a) => Ptr a -> (a -> IO b) -> IO b
wrapBoxed :: (HasCallStack, GBoxed a) => (ManagedPtr a -> a) -> Ptr a -> IO a
wrapObject :: (HasCallStack, GObject a, GObject b) => (ManagedPtr a -> a) -> Ptr b -> IO a
wrapPtr :: (HasCallStack, BoxedPtr a) => (ManagedPtr a -> a) -> Ptr a -> IO a
asA :: (ManagedPtrNewtype a, ManagedPtrNewtype b, HasParentTypes b, IsDescendantOf a b) => b -> (ManagedPtr a -> a) -> a
data SignalProxy object info
[:::] :: forall object info. SignalProxy object info -> Text -> SignalProxy object info
[PropertyNotify] :: forall info1 (propName :: Symbol) object (pl :: Symbol). (info1 ~ ResolveAttribute propName object, AttrInfo info1, pl ~ AttrLabel info1, KnownSymbol pl) => AttrLabelProxy propName -> SignalProxy object GObjectNotifySignalInfo
[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)
after :: forall object info m. (GObject object, MonadIO m, SignalInfo info) => object -> SignalProxy object info -> ((?self :: object) => HaskellCallbackType info) -> m SignalHandlerId
on :: forall object info m. (GObject object, MonadIO m, SignalInfo info) => object -> SignalProxy object info -> ((?self :: object) => HaskellCallbackType info) -> m SignalHandlerId
set :: forall o m. MonadIO m => o -> [AttrOp o 'AttrSet] -> m ()
