Data.GI.Base.BasicTypes

Basic types used in the bindings.

GType related

newtype GType

A newtype for use on the haskell side.

Constructors

GType

Fields

gtypeToCGType :: CGType

Instances

IsGValue GType

type CGType = Word64

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

gtypeName :: GType -> IO String

Get the name assigned to the given GType.

gtypeString :: GType

Note: compile-time vs run-time GTypes

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

GType of strings.

gtypePointer :: GType

GType of pointers.

gtypeInt :: GType

GType for signed integers (gint or gint32).

gtypeUInt :: GType

GType for unsigned integers (guint or guint32).

gtypeLong :: GType

GType for glong.

gtypeULong :: GType

GType for gulong.

gtypeInt64 :: GType

GType for signed 64 bit integers.

gtypeUInt64 :: GType

GType for unsigned 64 bit integers.

gtypeFloat :: GType

GType for floating point values.

gtypeDouble :: GType

GType for gdouble.

gtypeBoolean :: GType

GType corresponding to gboolean.

gtypeGType :: GType

GType corresponding to a GType itself.

gtypeStrv :: GType

GType for a NULL terminated array of strings.

gtypeBoxed :: GType

GType corresponding to a BoxedObject.

gtypeObject :: GType

GType corresponding to a GObject.

gtypeVariant :: GType

The GType corresponding to a GVariant.

gtypeByteArray :: GType

GType for a boxed type holding a GByteArray.

gtypeInvalid :: GType

An invalid GType used as error return value in some functions which return a GType.

Memory management

type ForeignPtrNewtype a = Coercible a (ForeignPtr ())

A constraint ensuring that the given type is coercible to a ForeignPtr. It will hold for newtypes of the form

newtype Foo = Foo (ForeignPtr Foo)

which is the typical shape of wrapped GObjects.

class ForeignPtrNewtype a => BoxedObject a where

Wrapped boxed structures, identified by their GType.

Methods

boxedType :: a -> IO GType

Instances

BoxedObject Closure

BoxedObject GError

BoxedObject GValue

class BoxedEnum a where

Enums with an associated GType.

Methods

boxedEnumType :: a -> IO GType

class BoxedFlags a where

Flags with an associated GType.

Methods

boxedFlagsType :: Proxy a -> IO GType

class ForeignPtrNewtype a => GObject a where

A wrapped GObject.

Methods

gobjectIsInitiallyUnowned :: a -> Bool

Whether the GObject is a descendent of GInitiallyUnowned.

gobjectType :: a -> IO GType

The GType for this object.

class ForeignPtrNewtype a => WrappedPtr a where

Pointers to structs/unions without an associated GType.

Methods

wrappedPtrCalloc :: IO (Ptr a)

Allocate a zero-initialized block of memory for the given type.

wrappedPtrCopy :: Ptr a -> IO (Ptr a)

Make a copy of the given pointer.

wrappedPtrFree :: Maybe (FunPtr (Ptr a -> IO ()))

A pointer to a function for freeing the given pointer, or Nothing is the memory associated to the pointer does not need to be freed.

data UnexpectedNullPointerReturn

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

Constructors

UnexpectedNullPointerReturn

Fields

nullPtrErrorMsg :: Text

Instances

Show UnexpectedNullPointerReturn

Exception UnexpectedNullPointerReturn

Typeable * UnexpectedNullPointerReturn

class NullToNothing a where

Methods

nullToNothing :: MonadIO m => IO a -> m (Maybe (UnMaybe a))

Some functions are not marked as having a nullable return type in the introspection data. The result is that they currently do not return a Maybe type. This functions lets you work around this in a way that will not break when the introspection data is fixed.

When you want to call a someHaskellGIFunction that may return null wrap the call like this.

nullToNothing (someHaskellGIFunction x y)

The result will be a Maybe type even if the introspection data has not been fixed for someHaskellGIFunction yet.

Instances

(~) * a (UnMaybe a) => NullToNothing a

NullToNothing (Maybe a)

Basic GLib / GObject types

newtype GVariant

A GVariant. See Data.GI.Base.GVariant for further methods.

Constructors

GVariant (ForeignPtr GVariant)

Instances

IsGVariant GVariant

newtype GParamSpec

A GParamSpec. See Data.GI.Base.GParamSpec for further methods.

Constructors

GParamSpec (ForeignPtr GParamSpec)

data GArray a

A GArray. Marshalling for this type is done in Data.GI.Base.BasicConversions, it is mapped to a list on the Haskell side.

Constructors

GArray (Ptr (GArray a))

data GPtrArray a

A GPtrArray. Marshalling for this type is done in Data.GI.Base.BasicConversions, it is mapped to a list on the Haskell side.

Constructors

GPtrArray (Ptr (GPtrArray a))

data GByteArray

A GByteArray. Marshalling for this type is done in Data.GI.Base.BasicConversions, it is packed to a ByteString on the Haskell side.

Constructors

GByteArray (Ptr GByteArray)

data GHashTable a b

A GHashTable. It is mapped to a Map on the Haskell side.

Constructors

GHashTable (Ptr (GHashTable a b))

data GList a

A GList, mapped to a list on the Haskell side. Marshalling is done in Data.GI.Base.BasicConversions.

Constructors

GList (Ptr (GList a))

g_list_free :: Ptr (GList a) -> IO ()

Free the given GList.

data GSList a

A GSList, mapped to a list on the Haskell side. Marshalling is done in Data.GI.Base.BasicConversions.

Constructors

GSList (Ptr (GSList a))

g_slist_free :: Ptr (GSList a) -> IO ()

Free the given GSList.

class Enum a => IsGFlag a

An enum usable as a flag for a function.

newtype PtrWrapped a

Some APIs, such as GHashTable, pass around scalar types wrapped into a pointer. We encode such a type as follows.

Constructors

PtrWrapped

Fields

unwrapPtr :: Ptr a

type GDestroyNotify a = FunPtr (Ptr a -> IO ())

Destroy the memory associated with a given pointer.