gobject

package
v0.0.0-...-88ce485 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 13, 2014 License: MIT Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	PARAM_MASK                      = C.__G_PARAM_MASK
	PARAM_STATIC_STRINGS            = C.__G_PARAM_STATIC_STRINGS
	PARAM_USER_SHIFT                = C.__G_PARAM_USER_SHIFT
	SIGNAL_FLAGS_MASK               = C.__G_SIGNAL_FLAGS_MASK
	SIGNAL_MATCH_MASK               = C.__G_SIGNAL_MATCH_MASK
	TYPE_FLAG_RESERVED_ID_BIT       = C.__G_TYPE_FLAG_RESERVED_ID_BIT
	TYPE_FUNDAMENTAL_MAX            = C.__G_TYPE_FUNDAMENTAL_MAX
	TYPE_FUNDAMENTAL_SHIFT          = C.__G_TYPE_FUNDAMENTAL_SHIFT
	TYPE_RESERVED_BSE_FIRST         = C.__G_TYPE_RESERVED_BSE_FIRST
	TYPE_RESERVED_BSE_LAST          = C.__G_TYPE_RESERVED_BSE_LAST
	TYPE_RESERVED_GLIB_FIRST        = C.__G_TYPE_RESERVED_GLIB_FIRST
	TYPE_RESERVED_GLIB_LAST         = C.__G_TYPE_RESERVED_GLIB_LAST
	TYPE_RESERVED_USER_FIRST        = C.__G_TYPE_RESERVED_USER_FIRST
	VALUE_COLLECT_FORMAT_MAX_LENGTH = C.__G_VALUE_COLLECT_FORMAT_MAX_LENGTH
	VALUE_NOCOPY_CONTENTS           = C.__G_VALUE_NOCOPY_CONTENTS
)
View Source 
var (
	// BindingFlags
	BINDING_DEFAULT        = C.GBindingFlags(C.G_BINDING_DEFAULT)
	BINDING_BIDIRECTIONAL  = C.GBindingFlags(C.G_BINDING_BIDIRECTIONAL)
	BINDING_SYNC_CREATE    = C.GBindingFlags(C.G_BINDING_SYNC_CREATE)
	BINDING_INVERT_BOOLEAN = C.GBindingFlags(C.G_BINDING_INVERT_BOOLEAN)

	// ConnectFlags
	CONNECT_AFTER   = C.GConnectFlags(C.G_CONNECT_AFTER)
	CONNECT_SWAPPED = C.GConnectFlags(C.G_CONNECT_SWAPPED)

	// ParamFlags
	PARAM_READABLE        = C.GParamFlags(C.G_PARAM_READABLE)
	PARAM_WRITABLE        = C.GParamFlags(C.G_PARAM_WRITABLE)
	PARAM_READWRITE       = C.GParamFlags(C.G_PARAM_READWRITE)
	PARAM_CONSTRUCT       = C.GParamFlags(C.G_PARAM_CONSTRUCT)
	PARAM_CONSTRUCT_ONLY  = C.GParamFlags(C.G_PARAM_CONSTRUCT_ONLY)
	PARAM_LAX_VALIDATION  = C.GParamFlags(C.G_PARAM_LAX_VALIDATION)
	PARAM_STATIC_NAME     = C.GParamFlags(C.G_PARAM_STATIC_NAME)
	PARAM_PRIVATE         = C.GParamFlags(C.G_PARAM_PRIVATE)
	PARAM_STATIC_NICK     = C.GParamFlags(C.G_PARAM_STATIC_NICK)
	PARAM_STATIC_BLURB    = C.GParamFlags(C.G_PARAM_STATIC_BLURB)
	PARAM_EXPLICIT_NOTIFY = C.GParamFlags(C.G_PARAM_EXPLICIT_NOTIFY)
	PARAM_DEPRECATED      = C.GParamFlags(C.G_PARAM_DEPRECATED)

	// SignalFlags
	SIGNAL_RUN_FIRST    = C.GSignalFlags(C.G_SIGNAL_RUN_FIRST)
	SIGNAL_RUN_LAST     = C.GSignalFlags(C.G_SIGNAL_RUN_LAST)
	SIGNAL_RUN_CLEANUP  = C.GSignalFlags(C.G_SIGNAL_RUN_CLEANUP)
	SIGNAL_NO_RECURSE   = C.GSignalFlags(C.G_SIGNAL_NO_RECURSE)
	SIGNAL_DETAILED     = C.GSignalFlags(C.G_SIGNAL_DETAILED)
	SIGNAL_ACTION       = C.GSignalFlags(C.G_SIGNAL_ACTION)
	SIGNAL_NO_HOOKS     = C.GSignalFlags(C.G_SIGNAL_NO_HOOKS)
	SIGNAL_MUST_COLLECT = C.GSignalFlags(C.G_SIGNAL_MUST_COLLECT)
	SIGNAL_DEPRECATED   = C.GSignalFlags(C.G_SIGNAL_DEPRECATED)

	// SignalMatchType
	SIGNAL_MATCH_ID        = C.GSignalMatchType(C.G_SIGNAL_MATCH_ID)
	SIGNAL_MATCH_DETAIL    = C.GSignalMatchType(C.G_SIGNAL_MATCH_DETAIL)
	SIGNAL_MATCH_CLOSURE   = C.GSignalMatchType(C.G_SIGNAL_MATCH_CLOSURE)
	SIGNAL_MATCH_FUNC      = C.GSignalMatchType(C.G_SIGNAL_MATCH_FUNC)
	SIGNAL_MATCH_DATA      = C.GSignalMatchType(C.G_SIGNAL_MATCH_DATA)
	SIGNAL_MATCH_UNBLOCKED = C.GSignalMatchType(C.G_SIGNAL_MATCH_UNBLOCKED)

	// TypeDebugFlags
	TYPE_DEBUG_NONE    = C.GTypeDebugFlags(C.G_TYPE_DEBUG_NONE)
	TYPE_DEBUG_OBJECTS = C.GTypeDebugFlags(C.G_TYPE_DEBUG_OBJECTS)
	TYPE_DEBUG_SIGNALS = C.GTypeDebugFlags(C.G_TYPE_DEBUG_SIGNALS)
	TYPE_DEBUG_MASK    = C.GTypeDebugFlags(C.G_TYPE_DEBUG_MASK)

	// TypeFlags
	TYPE_FLAG_ABSTRACT       = C.GTypeFlags(C.G_TYPE_FLAG_ABSTRACT)
	TYPE_FLAG_VALUE_ABSTRACT = C.GTypeFlags(C.G_TYPE_FLAG_VALUE_ABSTRACT)

	// TypeFundamentalFlags
	TYPE_FLAG_CLASSED        = C.GTypeFundamentalFlags(C.G_TYPE_FLAG_CLASSED)
	TYPE_FLAG_INSTANTIATABLE = C.GTypeFundamentalFlags(C.G_TYPE_FLAG_INSTANTIATABLE)
	TYPE_FLAG_DERIVABLE      = C.GTypeFundamentalFlags(C.G_TYPE_FLAG_DERIVABLE)
	TYPE_FLAG_DEEP_DERIVABLE = C.GTypeFundamentalFlags(C.G_TYPE_FLAG_DEEP_DERIVABLE)
)
View Source 
var UnusedFix_ bool

Functions

func BoxedCopy 

func BoxedCopy(boxed_type C.GType, src_boxed unsafe.Pointer) (return__ unsafe.Pointer)

Provide a copy of a boxed structure @src_boxed which is of type @boxed_type.

func BoxedFree 

func BoxedFree(boxed_type C.GType, boxed unsafe.Pointer)

Free the boxed structure @boxed which is of type @boxed_type.

func BoxedTypeRegisterStatic 

func BoxedTypeRegisterStatic(name string, boxed_copy C.GBoxedCopyFunc, boxed_free C.GBoxedFreeFunc) (return__ C.GType)

This function creates a new %G_TYPE_BOXED derived type id for a new boxed type with name @name. Boxed type handling functions have to be provided to copy and free opaque boxed structures of this type.

func CclosureMarshalBOOLEANBOXEDBOXED 

func CclosureMarshalBOOLEANBOXEDBOXED(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

func CclosureMarshalBOOLEANFLAGS 

func CclosureMarshalBOOLEANFLAGS(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `gboolean (*callback) (gpointer instance, gint arg1, gpointer user_data)` where the #gint parameter denotes a flags type.

func CclosureMarshalGeneric 

func CclosureMarshalGeneric(closure *C.GClosure, return_gvalue *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A generic marshaller function implemented via [libffi](http://sourceware.org/libffi/).

Normally this function is not passed explicitly to g_signal_new(), but used automatically by GLib when specifying a %NULL marshaller.

func CclosureMarshalSTRINGOBJECTPOINTER 

func CclosureMarshalSTRINGOBJECTPOINTER(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `gchar* (*callback) (gpointer instance, GObject *arg1, gpointer arg2, gpointer user_data)`.

func CclosureMarshalVOIDBOOLEAN 

func CclosureMarshalVOIDBOOLEAN(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gboolean arg1, gpointer user_data)`.

func CclosureMarshalVOIDBOXED 

func CclosureMarshalVOIDBOXED(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, GBoxed *arg1, gpointer user_data)`.

func CclosureMarshalVOIDCHAR 

func CclosureMarshalVOIDCHAR(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gchar arg1, gpointer user_data)`.

func CclosureMarshalVOIDDOUBLE 

func CclosureMarshalVOIDDOUBLE(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gdouble arg1, gpointer user_data)`.

func CclosureMarshalVOIDENUM 

func CclosureMarshalVOIDENUM(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gint arg1, gpointer user_data)` where the #gint parameter denotes an enumeration type..

func CclosureMarshalVOIDFLAGS 

func CclosureMarshalVOIDFLAGS(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gint arg1, gpointer user_data)` where the #gint parameter denotes a flags type.

func CclosureMarshalVOIDFLOAT 

func CclosureMarshalVOIDFLOAT(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gfloat arg1, gpointer user_data)`.

func CclosureMarshalVOIDINT 

func CclosureMarshalVOIDINT(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gint arg1, gpointer user_data)`.

func CclosureMarshalVOIDLONG 

func CclosureMarshalVOIDLONG(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, glong arg1, gpointer user_data)`.

func CclosureMarshalVOIDOBJECT 

func CclosureMarshalVOIDOBJECT(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, GObject *arg1, gpointer user_data)`.

func CclosureMarshalVOIDPARAM 

func CclosureMarshalVOIDPARAM(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, GParamSpec *arg1, gpointer user_data)`.

func CclosureMarshalVOIDPOINTER 

func CclosureMarshalVOIDPOINTER(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gpointer arg1, gpointer user_data)`.

func CclosureMarshalVOIDSTRING 

func CclosureMarshalVOIDSTRING(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, const gchar *arg1, gpointer user_data)`.

func CclosureMarshalVOIDUCHAR 

func CclosureMarshalVOIDUCHAR(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, guchar arg1, gpointer user_data)`.

func CclosureMarshalVOIDUINT 

func CclosureMarshalVOIDUINT(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, guint arg1, gpointer user_data)`.

func CclosureMarshalVOIDUINTPOINTER 

func CclosureMarshalVOIDUINTPOINTER(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, guint arg1, gpointer arg2, gpointer user_data)`.

func CclosureMarshalVOIDULONG 

func CclosureMarshalVOIDULONG(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gulong arg1, gpointer user_data)`.

func CclosureMarshalVOIDVARIANT 

func CclosureMarshalVOIDVARIANT(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, GVariant *arg1, gpointer user_data)`.

func CclosureMarshalVOIDVOID 

func CclosureMarshalVOIDVOID(closure *C.GClosure, return_value *C.GValue, n_param_values uint, param_values *C.GValue, invocation_hint unsafe.Pointer, marshal_data unsafe.Pointer)

A marshaller for a #GCClosure with a callback of type `void (*callback) (gpointer instance, gpointer user_data)`.

func CclosureNew 

func CclosureNew(callback_func C.GCallback, user_data unsafe.Pointer, destroy_data C.GClosureNotify) (return__ *C.GClosure)

Creates a new closure which invokes @callback_func with @user_data as the last parameter.

func CclosureNewObject 

func CclosureNewObject(callback_func C.GCallback, object IsObject) (return__ *C.GClosure)

A variant of g_cclosure_new() which uses @object as @user_data and calls g_object_watch_closure() on @object and the created closure. This function is useful when you have a callback closely associated with a #GObject, and want the callback to no longer run after the object is is freed.

func CclosureNewObjectSwap 

func CclosureNewObjectSwap(callback_func C.GCallback, object IsObject) (return__ *C.GClosure)

A variant of g_cclosure_new_swap() which uses @object as @user_data and calls g_object_watch_closure() on @object and the created closure. This function is useful when you have a callback closely associated with a #GObject, and want the callback to no longer run after the object is is freed.

func CclosureNewSwap 

func CclosureNewSwap(callback_func C.GCallback, user_data unsafe.Pointer, destroy_data C.GClosureNotify) (return__ *C.GClosure)

Creates a new closure which invokes @callback_func with @user_data as the first parameter.

func Connect 

func Connect(obj unsafe.Pointer, signal string, cb interface{}) uint64

func EnumCompleteTypeInfo 

func EnumCompleteTypeInfo(g_enum_type C.GType, const_values *C.GEnumValue) (info C.GTypeInfo)

This function is meant to be called from the `complete_type_info` function of a #GTypePlugin implementation, as in the following example:

|[<!-- language="C" --> static void my_enum_complete_type_info (GTypePlugin *plugin, 

GType            g_type,
GTypeInfo       *info,
GTypeValueTable *value_table)

{
  static const GEnumValue values[] = {
    { MY_ENUM_FOO, "MY_ENUM_FOO", "foo" },
    { MY_ENUM_BAR, "MY_ENUM_BAR", "bar" },
    { 0, NULL, NULL }
  };

  g_enum_complete_type_info (type, info, values);
}

]|

func EnumGetValue 

func EnumGetValue(enum_class *C.GEnumClass, value int) (return__ *C.GEnumValue)

Returns the #GEnumValue for a value.

func EnumGetValueByName 

func EnumGetValueByName(enum_class *C.GEnumClass, name string) (return__ *C.GEnumValue)

Looks up a #GEnumValue by name.

func EnumGetValueByNick 

func EnumGetValueByNick(enum_class *C.GEnumClass, nick string) (return__ *C.GEnumValue)

Looks up a #GEnumValue by nickname.

func EnumRegisterStatic 

func EnumRegisterStatic(name string, const_static_values *C.GEnumValue) (return__ C.GType)

Registers a new static enumeration type with the name @name.

It is normally more convenient to let [glib-mkenums][glib-mkenums], generate a my_enum_get_type() function from a usual C enumeration definition than to write one yourself using g_enum_register_static().

func FlagsCompleteTypeInfo 

func FlagsCompleteTypeInfo(g_flags_type C.GType, const_values *C.GFlagsValue) (info C.GTypeInfo)

This function is meant to be called from the complete_type_info() function of a #GTypePlugin implementation, see the example for g_enum_complete_type_info() above.

func FlagsGetFirstValue 

func FlagsGetFirstValue(flags_class *C.GFlagsClass, value uint) (return__ *C.GFlagsValue)

Returns the first #GFlagsValue which is set in @value.

func FlagsGetValueByName 

func FlagsGetValueByName(flags_class *C.GFlagsClass, name string) (return__ *C.GFlagsValue)

Looks up a #GFlagsValue by name.

func FlagsGetValueByNick 

func FlagsGetValueByNick(flags_class *C.GFlagsClass, nick string) (return__ *C.GFlagsValue)

Looks up a #GFlagsValue by nickname.

func FlagsRegisterStatic 

func FlagsRegisterStatic(name string, const_static_values *C.GFlagsValue) (return__ C.GType)

Registers a new static flags type with the name @name.

It is normally more convenient to let [glib-mkenums][glib-mkenums] generate a my_flags_get_type() function from a usual C enumeration definition than to write one yourself using g_flags_register_static().

func GParamSpecPoolNew 

func GParamSpecPoolNew(type_prefixing bool) (return__ *C.GParamSpecPool)

Creates a new #GParamSpecPool.

If @type_prefixing is %TRUE, lookups in the newly created pool will allow to specify the owner as a colon-separated prefix of the property name, like "GtkContainer:border-width". This feature is deprecated, so you should always set @type_prefixing to %FALSE.

func GSignalQuery 

func GSignalQuery(signal_id uint) (query C.GSignalQuery)

Queries the signal system for in-depth information about a specific signal. This function will fill in a user-provided structure to hold signal-specific information. If an invalid signal id is passed in, the @signal_id member of the #GSignalQuery is 0. All members filled into the #GSignalQuery structure should be considered constant and have to be left untouched.

func GTypeQuery 

func GTypeQuery(type_ C.GType) (query C.GTypeQuery)

Queries the type system for information about a specific type. This function will fill in a user-provided structure to hold type-specific information. If an invalid #GType is passed in, the @type member of the #GTypeQuery is 0. All members filled into the #GTypeQuery structure should be considered constant and have to be left untouched.

func GtypeGetType 

func GtypeGetType() (return__ C.GType)

func ParamTypeRegisterStatic 

func ParamTypeRegisterStatic(name string, pspec_info *C.GParamSpecTypeInfo) (return__ C.GType)

Registers @name as the name of a new static type derived from #G_TYPE_PARAM. The type system uses the information contained in the #GParamSpecTypeInfo structure pointed to by @info to manage the #GParamSpec type and its instances.

func ParamValueConvert 

func ParamValueConvert(pspec IsParamSpec, src_value *C.GValue, dest_value *C.GValue, strict_validation bool) (return__ bool)

Transforms @src_value into @dest_value if possible, and then validates @dest_value, in order for it to conform to @pspec. If @strict_validation is %TRUE this function will only succeed if the transformed @dest_value complied to @pspec without modifications.

See also g_value_type_transformable(), g_value_transform() and g_param_value_validate().

func ParamValueDefaults 

func ParamValueDefaults(pspec IsParamSpec, value *C.GValue) (return__ bool)

Checks whether @value contains the default value as specified in @pspec.

func ParamValueSetDefault 

func ParamValueSetDefault(pspec IsParamSpec, value *C.GValue)

Sets @value to its default value as specified in @pspec.

func ParamValueValidate 

func ParamValueValidate(pspec IsParamSpec, value *C.GValue) (return__ bool)

Ensures that the contents of @value comply with the specifications set out by @pspec. For example, a #GParamSpecInt might require that integers stored in @value may not be smaller than -42 and not be greater than +42. If @value contains an integer outside of this range, it is modified accordingly, so the resulting value will fit into the range -42 .. +42.

func ParamValuesCmp 

func ParamValuesCmp(pspec IsParamSpec, value1 *C.GValue, value2 *C.GValue) (return__ int)

Compares @value1 with @value2 according to @pspec, and return -1, 0 or +1, if @value1 is found to be less than, equal to or greater than @value2, respectively.

func PointerTypeRegisterStatic 

func PointerTypeRegisterStatic(name string) (return__ C.GType)

Creates a new %G_TYPE_POINTER derived type id for a new pointer type with name @name.

func SignalAccumulatorFirstWins 

func SignalAccumulatorFirstWins(ihint *C.GSignalInvocationHint, return_accu *C.GValue, handler_return *C.GValue, dummy unsafe.Pointer) (return__ bool)

A predefined #GSignalAccumulator for signals intended to be used as a hook for application code to provide a particular value. Usually only one such value is desired and multiple handlers for the same signal don't make much sense (except for the case of the default handler defined in the class structure, in which case you will usually want the signal connection to override the class handler).

This accumulator will use the return value from the first signal handler that is run as the return value for the signal and not run any further handlers (ie: the first handler "wins").

func SignalAccumulatorTrueHandled 

func SignalAccumulatorTrueHandled(ihint *C.GSignalInvocationHint, return_accu *C.GValue, handler_return *C.GValue, dummy unsafe.Pointer) (return__ bool)

A predefined #GSignalAccumulator for signals that return a boolean values. The behavior that this accumulator gives is that a return of %TRUE stops the signal emission: no further callbacks will be invoked, while a return of %FALSE allows the emission to continue. The idea here is that a %TRUE return indicates that the callback handled the signal, and no further handling is needed.

func SignalAddEmissionHook 

func SignalAddEmissionHook(signal_id uint, detail C.GQuark, hook_func C.GSignalEmissionHook, hook_data unsafe.Pointer, data_destroy C.GDestroyNotify) (return__ uint64)

Adds an emission hook for a signal, which will get called for any emission of that signal, independent of the instance. This is possible only for signals which don't have #G_SIGNAL_NO_HOOKS flag set.

func SignalChainFromOverridden 

func SignalChainFromOverridden(instance_and_params *C.GValue, return_value *C.GValue)

Calls the original class closure of a signal. This function should only be called from an overridden class closure; see g_signal_override_class_closure() and g_signal_override_class_handler().

func SignalConnectClosure 

func SignalConnectClosure(instance IsObject, detailed_signal string, closure *C.GClosure, after bool) (return__ uint64)

Connects a closure to a signal for a particular object.

func SignalConnectClosureById 

func SignalConnectClosureById(instance IsObject, signal_id uint, detail C.GQuark, closure *C.GClosure, after bool) (return__ uint64)

Connects a closure to a signal for a particular object.

func SignalConnectData 

func SignalConnectData(instance IsObject, detailed_signal string, c_handler C.GCallback, data unsafe.Pointer, destroy_data C.GClosureNotify, connect_flags C.GConnectFlags) (return__ uint64)

Connects a #GCallback function to a signal for a particular object. Similar to g_signal_connect(), but allows to provide a #GClosureNotify for the data which will be called when the signal handler is disconnected and no longer used. Specify @connect_flags if you need `..._after()` or `..._swapped()` variants of this function.

func SignalConnectObject 

func SignalConnectObject(instance unsafe.Pointer, detailed_signal string, c_handler C.GCallback, gobject unsafe.Pointer, connect_flags C.GConnectFlags) (return__ uint64)

This is similar to g_signal_connect_data(), but uses a closure which ensures that the @gobject stays alive during the call to @c_handler by temporarily adding a reference count to @gobject.

When the @gobject is destroyed the signal handler will be automatically disconnected. Note that this is not currently threadsafe (ie: emitting a signal while @gobject is being destroyed in another thread is not safe).

func SignalEmitv 

func SignalEmitv(instance_and_params *C.GValue, signal_id uint, detail C.GQuark, return_value *C.GValue)

Emits a signal.

Note that g_signal_emitv() doesn't change @return_value if no handlers are connected, in contrast to g_signal_emit() and g_signal_emit_valist().

func SignalGetInvocationHint 

func SignalGetInvocationHint(instance IsObject) (return__ *C.GSignalInvocationHint)

Returns the invocation hint of the innermost signal emission of instance.

func SignalHandlerBlock 

func SignalHandlerBlock(instance IsObject, handler_id uint64)

Blocks a handler of an instance so it will not be called during any signal emissions unless it is unblocked again. Thus "blocking" a signal handler means to temporarily deactive it, a signal handler has to be unblocked exactly the same amount of times it has been blocked before to become active again.

The @handler_id has to be a valid signal handler id, connected to a signal of @instance.

func SignalHandlerDisconnect 

func SignalHandlerDisconnect(instance IsObject, handler_id uint64)

Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to. The @handler_id becomes invalid and may be reused.

The @handler_id has to be a valid signal handler id, connected to a signal of @instance.

func SignalHandlerFind 

func SignalHandlerFind(instance IsObject, mask C.GSignalMatchType, signal_id uint, detail C.GQuark, closure *C.GClosure, func_ unsafe.Pointer, data unsafe.Pointer) (return__ uint64)

Finds the first signal handler that matches certain selection criteria. The criteria mask is passed as an OR-ed combination of #GSignalMatchType flags, and the criteria values are passed as arguments. The match @mask has to be non-0 for successful matches. If no handler was found, 0 is returned.

func SignalHandlerIsConnected 

func SignalHandlerIsConnected(instance IsObject, handler_id uint64) (return__ bool)

Returns whether @handler_id is the id of a handler connected to @instance.

func SignalHandlerUnblock 

func SignalHandlerUnblock(instance IsObject, handler_id uint64)

Undoes the effect of a previous g_signal_handler_block() call. A blocked handler is skipped during signal emissions and will not be invoked, unblocking it (for exactly the amount of times it has been blocked before) reverts its "blocked" state, so the handler will be recognized by the signal system and is called upon future or currently ongoing signal emissions (since the order in which handlers are called during signal emissions is deterministic, whether the unblocked handler in question is called as part of a currently ongoing emission depends on how far that emission has proceeded yet).

The @handler_id has to be a valid id of a signal handler that is connected to a signal of @instance and is currently blocked.

func SignalHandlersBlockMatched 

func SignalHandlersBlockMatched(instance IsObject, mask C.GSignalMatchType, signal_id uint, detail C.GQuark, closure *C.GClosure, func_ unsafe.Pointer, data unsafe.Pointer) (return__ uint)

Blocks all handlers on an instance that match a certain selection criteria. The criteria mask is passed as an OR-ed combination of #GSignalMatchType flags, and the criteria values are passed as arguments. Passing at least one of the %G_SIGNAL_MATCH_CLOSURE, %G_SIGNAL_MATCH_FUNC or %G_SIGNAL_MATCH_DATA match flags is required for successful matches. If no handlers were found, 0 is returned, the number of blocked handlers otherwise.

func SignalHandlersDestroy 

func SignalHandlersDestroy(instance IsObject)

Destroy all signal handlers of a type instance. This function is an implementation detail of the #GObject dispose implementation, and should not be used outside of the type system.

func SignalHandlersDisconnectMatched 

func SignalHandlersDisconnectMatched(instance IsObject, mask C.GSignalMatchType, signal_id uint, detail C.GQuark, closure *C.GClosure, func_ unsafe.Pointer, data unsafe.Pointer) (return__ uint)

Disconnects all handlers on an instance that match a certain selection criteria. The criteria mask is passed as an OR-ed combination of #GSignalMatchType flags, and the criteria values are passed as arguments. Passing at least one of the %G_SIGNAL_MATCH_CLOSURE, %G_SIGNAL_MATCH_FUNC or %G_SIGNAL_MATCH_DATA match flags is required for successful matches. If no handlers were found, 0 is returned, the number of disconnected handlers otherwise.

func SignalHandlersUnblockMatched 

func SignalHandlersUnblockMatched(instance IsObject, mask C.GSignalMatchType, signal_id uint, detail C.GQuark, closure *C.GClosure, func_ unsafe.Pointer, data unsafe.Pointer) (return__ uint)

Unblocks all handlers on an instance that match a certain selection criteria. The criteria mask is passed as an OR-ed combination of #GSignalMatchType flags, and the criteria values are passed as arguments. Passing at least one of the %G_SIGNAL_MATCH_CLOSURE, %G_SIGNAL_MATCH_FUNC or %G_SIGNAL_MATCH_DATA match flags is required for successful matches. If no handlers were found, 0 is returned, the number of unblocked handlers otherwise. The match criteria should not apply to any handlers that are not currently blocked.

func SignalHasHandlerPending 

func SignalHasHandlerPending(instance IsObject, signal_id uint, detail C.GQuark, may_be_blocked bool) (return__ bool)

Returns whether there are any handlers connected to @instance for the given signal id and detail.

One example of when you might use this is when the arguments to the signal are difficult to compute. A class implementor may opt to not emit the signal if no one is attached anyway, thus saving the cost of building the arguments.

func SignalListIds 

func SignalListIds(itype C.GType) (n_ids uint, return__ []uint)

Lists the signals by id that a certain instance or interface type created. Further information about the signals can be acquired through g_signal_query().

func SignalLookup 

func SignalLookup(name string, itype C.GType) (return__ uint)

Given the name of the signal and the type of object it connects to, gets the signal's identifying integer. Emitting the signal by number is somewhat faster than using the name each time.

Also tries the ancestors of the given type.

See g_signal_new() for details on allowed signal names.

func SignalName 

func SignalName(signal_id uint) (return__ string)

Given the signal's identifier, finds its name.

Two different signals may have the same name, if they have differing types.

func SignalNewv 

func SignalNewv(signal_name string, itype C.GType, signal_flags C.GSignalFlags, class_closure *C.GClosure, accumulator C.GSignalAccumulator, accu_data unsafe.Pointer, c_marshaller C.GSignalCMarshaller, return_type C.GType, n_params uint, param_types *C.GType) (return__ uint)

Creates a new signal. (This is usually done in the class initializer.)

See g_signal_new() for details on allowed signal names.

If c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as the marshaller for this signal.

func SignalOverrideClassClosure 

func SignalOverrideClassClosure(signal_id uint, instance_type C.GType, class_closure *C.GClosure)

Overrides the class closure (i.e. the default handler) for the given signal for emissions on instances of @instance_type. @instance_type must be derived from the type to which the signal belongs.

See g_signal_chain_from_overridden() and g_signal_chain_from_overridden_handler() for how to chain up to the parent class closure from inside the overridden one.

func SignalOverrideClassHandler 

func SignalOverrideClassHandler(signal_name string, instance_type C.GType, class_handler C.GCallback)

Overrides the class closure (i.e. the default handler) for the given signal for emissions on instances of @instance_type with callback @class_handler. @instance_type must be derived from the type to which the signal belongs.

See g_signal_chain_from_overridden() and g_signal_chain_from_overridden_handler() for how to chain up to the parent class closure from inside the overridden one.

func SignalParseName 

func SignalParseName(detailed_signal string, itype C.GType, force_detail_quark bool) (signal_id_p uint, detail_p C.GQuark, return__ bool)

Internal function to parse a signal name into its @signal_id and @detail quark.

func SignalRemoveEmissionHook 

func SignalRemoveEmissionHook(signal_id uint, hook_id uint64)

Deletes an emission hook.

func SignalSetVaMarshaller 

func SignalSetVaMarshaller(signal_id uint, instance_type C.GType, va_marshaller C.GSignalCVaMarshaller)

func SignalStopEmission 

func SignalStopEmission(instance IsObject, signal_id uint, detail C.GQuark)

Stops a signal's current emission.

This will prevent the default method from running, if the signal was %G_SIGNAL_RUN_LAST and you connected normally (i.e. without the "after" flag).

Prints a warning if used on a signal which isn't being emitted.

func SignalStopEmissionByName 

func SignalStopEmissionByName(instance IsObject, detailed_signal string)

Stops a signal's current emission.

This is just like g_signal_stop_emission() except it will look up the signal id for you.

func SignalTypeCclosureNew 

func SignalTypeCclosureNew(itype C.GType, struct_offset uint) (return__ *C.GClosure)

Creates a new closure which invokes the function found at the offset @struct_offset in the class structure of the interface or classed type identified by @itype.

func SourceSetClosure 

func SourceSetClosure(source *C.GSource, closure *C.GClosure)

Set the callback for a source as a #GClosure.

If the source is not one of the standard GLib types, the @closure_callback and @closure_marshal fields of the #GSourceFuncs structure must have been filled in with pointers to appropriate functions.

func SourceSetDummyCallback 

func SourceSetDummyCallback(source *C.GSource)

Sets a dummy callback for @source. The callback will do nothing, and if the source expects a #gboolean return value, it will return %TRUE. (If the source expects any other type of return value, it will return a 0/%NULL value; whatever g_value_init() initializes a #GValue to for that type.)

If the source is not one of the standard GLib types, the @closure_callback and @closure_marshal fields of the #GSourceFuncs structure must have been filled in with pointers to appropriate functions.

func StrdupValueContents 

func StrdupValueContents(value *C.GValue) (return__ string)

Return a newly allocated string, which describes the contents of a #GValue. The main purpose of this function is to describe #GValue contents for debugging output, the way in which the contents are described may change between different GLib versions.

func TypeAddClassCacheFunc 

func TypeAddClassCacheFunc(cache_data unsafe.Pointer, cache_func C.GTypeClassCacheFunc)

Adds a #GTypeClassCacheFunc to be called before the reference count of a class goes from one to zero. This can be used to prevent premature class destruction. All installed #GTypeClassCacheFunc functions will be chained until one of them returns %TRUE. The functions have to check the class id passed in to figure whether they actually want to cache the class of this type, since all classes are routed through the same #GTypeClassCacheFunc chain.

func TypeAddClassPrivate 

func TypeAddClassPrivate(class_type C.GType, private_size int64)

Registers a private class structure for a classed type; when the class is allocated, the private structures for the class and all of its parent types are allocated sequentially in the same memory block as the public structures, and are zero-filled.

This function should be called in the type's get_type() function after the type is registered. The private structure can be retrieved using the G_TYPE_CLASS_GET_PRIVATE() macro.

func TypeAddInstancePrivate 

func TypeAddInstancePrivate(class_type C.GType, private_size int64) (return__ int)

func TypeAddInterfaceCheck 

func TypeAddInterfaceCheck(check_data unsafe.Pointer, check_func C.GTypeInterfaceCheckFunc)

Adds a function to be called after an interface vtable is initialized for any class (i.e. after the @interface_init member of #GInterfaceInfo has been called).

This function is useful when you want to check an invariant that depends on the interfaces of a class. For instance, the implementation of #GObject uses this facility to check that an object implements all of the properties that are defined on its interfaces.

func TypeAddInterfaceDynamic 

func TypeAddInterfaceDynamic(instance_type C.GType, interface_type C.GType, plugin *C.GTypePlugin)

Adds the dynamic @interface_type to @instantiable_type. The information contained in the #GTypePlugin structure pointed to by @plugin is used to manage the relationship.

func TypeAddInterfaceStatic 

func TypeAddInterfaceStatic(instance_type C.GType, interface_type C.GType, info *C.GInterfaceInfo)

Adds the static @interface_type to @instantiable_type. The information contained in the #GInterfaceInfo structure pointed to by @info is used to manage the relationship.

func TypeCheckClassCast 

func TypeCheckClassCast(g_class *C.GTypeClass, is_a_type C.GType) (return__ *C.GTypeClass)

func TypeCheckClassIsA 

func TypeCheckClassIsA(g_class *C.GTypeClass, is_a_type C.GType) (return__ bool)

func TypeCheckInstance 

func TypeCheckInstance(instance *C.GTypeInstance) (return__ bool)

Private helper function to aid implementation of the G_TYPE_CHECK_INSTANCE() macro.

func TypeCheckInstanceCast 

func TypeCheckInstanceCast(instance *C.GTypeInstance, iface_type C.GType) (return__ *C.GTypeInstance)

func TypeCheckInstanceIsA 

func TypeCheckInstanceIsA(instance *C.GTypeInstance, iface_type C.GType) (return__ bool)

func TypeCheckInstanceIsFundamentallyA 

func TypeCheckInstanceIsFundamentallyA(instance *C.GTypeInstance, fundamental_type C.GType) (return__ bool)

func TypeCheckIsValueType 

func TypeCheckIsValueType(type_ C.GType) (return__ bool)

func TypeCheckValue 

func TypeCheckValue(value *C.GValue) (return__ bool)

func TypeCheckValueHolds 

func TypeCheckValueHolds(value *C.GValue, type_ C.GType) (return__ bool)

func TypeChildren 

func TypeChildren(type_ C.GType) (n_children uint, return__ *C.GType)

Return a newly allocated and 0-terminated array of type IDs, listing the child types of @type.

func TypeClassAddPrivate 

func TypeClassAddPrivate(g_class unsafe.Pointer, private_size int64)

Registers a private structure for an instantiatable type.

When an object is allocated, the private structures for the type and all of its parent types are allocated sequentially in the same memory block as the public structures, and are zero-filled.

Note that the accumulated size of the private structures of a type and all its parent types cannot exceed 64 KiB.

This function should be called in the type's class_init() function. The private structure can be retrieved using the G_TYPE_INSTANCE_GET_PRIVATE() macro.

The following example shows attaching a private structure MyObjectPrivate to an object MyObject defined in the standard GObject fashion in the type's class_init() function.

Note the use of a structure member "priv" to avoid the overhead of repeatedly calling MY_OBJECT_GET_PRIVATE().

|[<!-- language="C" --> typedef struct _MyObject MyObject; typedef struct _MyObjectPrivate MyObjectPrivate; 

struct _MyObject {
 GObject parent;

 MyObjectPrivate *priv;
};

struct _MyObjectPrivate {
  int some_field;
};

static void my_object_class_init (MyObjectClass *klass) 

{
  g_type_class_add_private (klass, sizeof (MyObjectPrivate));
}

static void my_object_init (MyObject *my_object) 

{
  my_object->priv = G_TYPE_INSTANCE_GET_PRIVATE (my_object,
                                                 MY_TYPE_OBJECT,
                                                 MyObjectPrivate);
  // my_object->priv->some_field will be automatically initialised to 0
}

static int my_object_get_some_field (MyObject *my_object) 

{
  MyObjectPrivate *priv;

  g_return_val_if_fail (MY_IS_OBJECT (my_object), 0);

  priv = my_object->priv;

  return priv->some_field;
}

]|

func TypeClassAdjustPrivateOffset 

func TypeClassAdjustPrivateOffset(g_class unsafe.Pointer, private_size_or_offset *C.gint)

func TypeClassGetInstancePrivateOffset 

func TypeClassGetInstancePrivateOffset(g_class unsafe.Pointer) (return__ int)

Gets the offset of the private data for instances of @g_class.

This is how many bytes you should add to the instance pointer of a class in order to get the private data for the type represented by @g_class.

You can only call this function after you have registered a private data area for @g_class using g_type_class_add_private().

func TypeClassPeek 

func TypeClassPeek(type_ C.GType) (return__ *C.GTypeClass)

This function is essentially the same as g_type_class_ref(), except that the classes reference count isn't incremented. As a consequence, this function may return %NULL if the class of the type passed in does not currently exist (hasn't been referenced before).

func TypeClassPeekStatic 

func TypeClassPeekStatic(type_ C.GType) (return__ *C.GTypeClass)

A more efficient version of g_type_class_peek() which works only for static types.

func TypeClassRef 

func TypeClassRef(type_ C.GType) (return__ *C.GTypeClass)

Increments the reference count of the class structure belonging to @type. This function will demand-create the class if it doesn't exist already.

func TypeCreateInstance 

func TypeCreateInstance(type_ C.GType) (return__ *C.GTypeInstance)

Creates and initializes an instance of @type if @type is valid and can be instantiated. The type system only performs basic allocation and structure setups for instances: actual instance creation should happen through functions supplied by the type's fundamental type implementation. So use of g_type_create_instance() is reserved for implementators of fundamental types only. E.g. instances of the #GObject hierarchy should be created via g_object_new() and never directly through g_type_create_instance() which doesn't handle things like singleton objects or object construction.

The extended members of the returned instance are guaranteed to be filled with zeros.

Note: Do not use this function, unless you're implementing a fundamental type. Also language bindings should not use this function, but g_object_new() instead.

func TypeDefaultInterfacePeek 

func TypeDefaultInterfacePeek(g_type C.GType) (return__ *C.GTypeInterface)

If the interface type @g_type is currently in use, returns its default interface vtable.

func TypeDefaultInterfaceRef 

func TypeDefaultInterfaceRef(g_type C.GType) (return__ *C.GTypeInterface)

Increments the reference count for the interface type @g_type, and returns the default interface vtable for the type.

If the type is not currently in use, then the default vtable for the type will be created and initalized by calling the base interface init and default vtable init functions for the type (the @base_init and @class_init members of #GTypeInfo). Calling g_type_default_interface_ref() is useful when you want to make sure that signals and properties for an interface have been installed.

func TypeDefaultInterfaceUnref 

func TypeDefaultInterfaceUnref(g_iface *C.GTypeInterface)

Decrements the reference count for the type corresponding to the interface default vtable @g_iface. If the type is dynamic, then when no one is using the interface and all references have been released, the finalize function for the interface's default vtable (the @class_finalize member of #GTypeInfo) will be called.

func TypeDepth 

func TypeDepth(type_ C.GType) (return__ uint)

Returns the length of the ancestry of the passed in type. This includes the type itself, so that e.g. a fundamental type has depth 1.

func TypeEnsure 

func TypeEnsure(type_ C.GType)

Ensures that the indicated @type has been registered with the type system, and its _class_init() method has been run.

In theory, simply calling the type's _get_type() method (or using the corresponding macro) is supposed take care of this. However, _get_type() methods are often marked %G_GNUC_CONST for performance reasons, even though this is technically incorrect (since %G_GNUC_CONST requires that the function not have side effects, which _get_type() methods do on the first call). As a result, if you write a bare call to a _get_type() macro, it may get optimized out by the compiler. Using g_type_ensure() guarantees that the type's _get_type() method is called.

func TypeFreeInstance 

func TypeFreeInstance(instance *C.GTypeInstance)

Frees an instance of a type, returning it to the instance pool for the type, if there is one.

Like g_type_create_instance(), this function is reserved for implementors of fundamental types.

func TypeFromName 

func TypeFromName(name string) (return__ C.GType)

Lookup the type ID from a given type name, returning 0 if no type has been registered under this name (this is the preferred method to find out by name whether a specific type has been registered yet).

func TypeFundamental 

func TypeFundamental(type_id C.GType) (return__ C.GType)

Internal function, used to extract the fundamental type ID portion. Use G_TYPE_FUNDAMENTAL() instead.

func TypeFundamentalNext 

func TypeFundamentalNext() (return__ C.GType)

Returns the next free fundamental type id which can be used to register a new fundamental type with g_type_register_fundamental(). The returned type ID represents the highest currently registered fundamental type identifier.

func TypeGetPlugin 

func TypeGetPlugin(type_ C.GType) (return__ *C.GTypePlugin)

Returns the #GTypePlugin structure for @type.

func TypeGetQdata 

func TypeGetQdata(type_ C.GType, quark C.GQuark) (return__ unsafe.Pointer)

Obtains data which has previously been attached to @type with g_type_set_qdata().

Note that this does not take subtyping into account; data attached to one type with g_type_set_qdata() cannot be retrieved from a subtype using g_type_get_qdata().

func TypeGetTypeRegistrationSerial 

func TypeGetTypeRegistrationSerial() (return__ uint)

Returns an opaque serial number that represents the state of the set of registered types. Any time a type is registered this serial changes, which means you can cache information based on type lookups (such as g_type_from_name()) and know if the cache is still valid at a later time by comparing the current serial with the one at the type lookup.

func TypeInterfaceAddPrerequisite 

func TypeInterfaceAddPrerequisite(interface_type C.GType, prerequisite_type C.GType)

Adds @prerequisite_type to the list of prerequisites of @interface_type. This means that any type implementing @interface_type must also implement @prerequisite_type. Prerequisites can be thought of as an alternative to interface derivation (which GType doesn't support). An interface can have at most one instantiatable prerequisite type.

func TypeInterfaceGetPlugin 

func TypeInterfaceGetPlugin(instance_type C.GType, interface_type C.GType) (return__ *C.GTypePlugin)

Returns the #GTypePlugin structure for the dynamic interface @interface_type which has been added to @instance_type, or %NULL if @interface_type has not been added to @instance_type or does not have a #GTypePlugin structure. See g_type_add_interface_dynamic().

func TypeInterfacePeek 

func TypeInterfacePeek(instance_class *C.GTypeClass, iface_type C.GType) (return__ *C.GTypeInterface)

Returns the #GTypeInterface structure of an interface to which the passed in class conforms.

func TypeInterfacePrerequisites 

func TypeInterfacePrerequisites(interface_type C.GType) (n_prerequisites uint, return__ *C.GType)

Returns the prerequisites of an interfaces type.

func TypeInterfaces 

func TypeInterfaces(type_ C.GType) (n_interfaces uint, return__ *C.GType)

Return a newly allocated and 0-terminated array of type IDs, listing the interface types that @type conforms to.

func TypeIsA 

func TypeIsA(type_ C.GType, is_a_type C.GType) (return__ bool)

If @is_a_type is a derivable type, check whether @type is a descendant of @is_a_type. If @is_a_type is an interface, check whether @type conforms to it.

func TypeName 

func TypeName(type_ C.GType) (return__ string)

Get the unique name that is assigned to a type ID. Note that this function (like all other GType API) cannot cope with invalid type IDs. %G_TYPE_INVALID may be passed to this function, as may be any other validly registered type ID, but randomized type IDs should not be passed in and will most likely lead to a crash.

func TypeNameFromClass 

func TypeNameFromClass(g_class *C.GTypeClass) (return__ string)

func TypeNameFromInstance 

func TypeNameFromInstance(instance *C.GTypeInstance) (return__ string)

func TypeNextBase 

func TypeNextBase(leaf_type C.GType, root_type C.GType) (return__ C.GType)

Given a @leaf_type and a @root_type which is contained in its anchestry, return the type that @root_type is the immediate parent of. In other words, this function determines the type that is derived directly from @root_type which is also a base class of @leaf_type. Given a root type and a leaf type, this function can be used to determine the types and order in which the leaf type is descended from the root type.

func TypeParent 

func TypeParent(type_ C.GType) (return__ C.GType)

Return the direct parent type of the passed in type. If the passed in type has no parent, i.e. is a fundamental type, 0 is returned.

func TypeQname 

func TypeQname(type_ C.GType) (return__ C.GQuark)

Get the corresponding quark of the type IDs name.

func TypeRegisterDynamic 

func TypeRegisterDynamic(parent_type C.GType, type_name string, plugin *C.GTypePlugin, flags C.GTypeFlags) (return__ C.GType)

Registers @type_name as the name of a new dynamic type derived from @parent_type. The type system uses the information contained in the #GTypePlugin structure pointed to by @plugin to manage the type and its instances (if not abstract). The value of @flags determines the nature (e.g. abstract or not) of the type.

func TypeRegisterFundamental 

func TypeRegisterFundamental(type_id C.GType, type_name string, info *C.GTypeInfo, finfo *C.GTypeFundamentalInfo, flags C.GTypeFlags) (return__ C.GType)

Registers @type_id as the predefined identifier and @type_name as the name of a fundamental type. If @type_id is already registered, or a type named @type_name is already registered, the behaviour is undefined. The type system uses the information contained in the #GTypeInfo structure pointed to by @info and the #GTypeFundamentalInfo structure pointed to by @finfo to manage the type and its instances. The value of @flags determines additional characteristics of the fundamental type.

func TypeRegisterStatic 

func TypeRegisterStatic(parent_type C.GType, type_name string, info *C.GTypeInfo, flags C.GTypeFlags) (return__ C.GType)

Registers @type_name as the name of a new static type derived from @parent_type. The type system uses the information contained in the #GTypeInfo structure pointed to by @info to manage the type and its instances (if not abstract). The value of @flags determines the nature (e.g. abstract or not) of the type.

func TypeRegisterStaticSimple 

func TypeRegisterStaticSimple(parent_type C.GType, type_name string, class_size uint, class_init C.GClassInitFunc, instance_size uint, instance_init C.GInstanceInitFunc, flags C.GTypeFlags) (return__ C.GType)

Registers @type_name as the name of a new static type derived from @parent_type. The value of @flags determines the nature (e.g. abstract or not) of the type. It works by filling a #GTypeInfo struct and calling g_type_register_static().

func TypeRemoveClassCacheFunc 

func TypeRemoveClassCacheFunc(cache_data unsafe.Pointer, cache_func C.GTypeClassCacheFunc)

Removes a previously installed #GTypeClassCacheFunc. The cache maintained by @cache_func has to be empty when calling g_type_remove_class_cache_func() to avoid leaks.

func TypeRemoveInterfaceCheck 

func TypeRemoveInterfaceCheck(check_data unsafe.Pointer, check_func C.GTypeInterfaceCheckFunc)

Removes an interface check function added with g_type_add_interface_check().

func TypeSetQdata 

func TypeSetQdata(type_ C.GType, quark C.GQuark, data unsafe.Pointer)

Attaches arbitrary data to a type.

func TypeTestFlags 

func TypeTestFlags(type_ C.GType, flags uint) (return__ bool)

func TypeValueTablePeek 

func TypeValueTablePeek(type_ C.GType) (return__ *C.GTypeValueTable)

Returns the location of the #GTypeValueTable associated with @type.

Note that this function should only be used from source code that implements or has internal knowledge of the implementation of @type.

func ValueRegisterTransformFunc 

func ValueRegisterTransformFunc(src_type C.GType, dest_type C.GType, transform_func C.GValueTransform)

Registers a value transformation function for use in g_value_transform(). A previously registered transformation function for @src_type and @dest_type will be replaced.

func ValueTypeCompatible 

func ValueTypeCompatible(src_type C.GType, dest_type C.GType) (return__ bool)

Returns whether a #GValue of type @src_type can be copied into a #GValue of type @dest_type.

func ValueTypeTransformable 

func ValueTypeTransformable(src_type C.GType, dest_type C.GType) (return__ bool)

Check whether g_value_transform() is able to transform values of type @src_type into values of type @dest_type. Note that for the types to be transformable, they must be compatible and a transform function must be registered.

Types

type Binding 

type Binding struct {
	*TraitBinding
	*TraitObject
	CPointer unsafe.Pointer
}

func NewBindingFromCPointer 

func NewBindingFromCPointer(p unsafe.Pointer) *Binding

type CClosure 

type CClosure C.GCClosure

type Closure 

type Closure C.GClosure

type ClosureNotifyData 

type ClosureNotifyData C.GClosureNotifyData

type EnumClass 

type EnumClass C.GEnumClass

type EnumValue 

type EnumValue C.GEnumValue

type FlagsClass 

type FlagsClass C.GFlagsClass

type FlagsValue 

type FlagsValue C.GFlagsValue

type InitiallyUnowned 

type InitiallyUnowned struct {
	*TraitInitiallyUnowned
	*TraitObject
	CPointer unsafe.Pointer
}

func NewInitiallyUnownedFromCPointer 

func NewInitiallyUnownedFromCPointer(p unsafe.Pointer) *InitiallyUnowned

type InterfaceInfo 

type InterfaceInfo C.GInterfaceInfo

type IsBinding 

type IsBinding interface {
	GetBindingPointer() *C.GBinding
}

type IsInitiallyUnowned 

type IsInitiallyUnowned interface {
	GetInitiallyUnownedPointer() *C.GInitiallyUnowned
}

type IsObject 

type IsObject interface {
	GetObjectPointer() *C.GObject
}

type IsParamSpec 

type IsParamSpec interface {
	GetParamSpecPointer() *C.GParamSpec
}

type IsParamSpecBoolean 

type IsParamSpecBoolean interface {
	GetParamSpecBooleanPointer() *C.GParamSpecBoolean
}

type IsParamSpecBoxed 

type IsParamSpecBoxed interface {
	GetParamSpecBoxedPointer() *C.GParamSpecBoxed
}

type IsParamSpecChar 

type IsParamSpecChar interface {
	GetParamSpecCharPointer() *C.GParamSpecChar
}

type IsParamSpecDouble 

type IsParamSpecDouble interface {
	GetParamSpecDoublePointer() *C.GParamSpecDouble
}

type IsParamSpecEnum 

type IsParamSpecEnum interface {
	GetParamSpecEnumPointer() *C.GParamSpecEnum
}

type IsParamSpecFlags 

type IsParamSpecFlags interface {
	GetParamSpecFlagsPointer() *C.GParamSpecFlags
}

type IsParamSpecFloat 

type IsParamSpecFloat interface {
	GetParamSpecFloatPointer() *C.GParamSpecFloat
}

type IsParamSpecGType 

type IsParamSpecGType interface {
	GetParamSpecGTypePointer() *C.GParamSpecGType
}

type IsParamSpecInt 

type IsParamSpecInt interface {
	GetParamSpecIntPointer() *C.GParamSpecInt
}

type IsParamSpecInt64 

type IsParamSpecInt64 interface {
	GetParamSpecInt64Pointer() *C.GParamSpecInt64
}

type IsParamSpecLong 

type IsParamSpecLong interface {
	GetParamSpecLongPointer() *C.GParamSpecLong
}

type IsParamSpecObject 

type IsParamSpecObject interface {
	GetParamSpecObjectPointer() *C.GParamSpecObject
}

type IsParamSpecOverride 

type IsParamSpecOverride interface {
	GetParamSpecOverridePointer() *C.GParamSpecOverride
}

type IsParamSpecParam 

type IsParamSpecParam interface {
	GetParamSpecParamPointer() *C.GParamSpecParam
}

type IsParamSpecPointer 

type IsParamSpecPointer interface {
	GetParamSpecPointerPointer() *C.GParamSpecPointer
}

type IsParamSpecString 

type IsParamSpecString interface {
	GetParamSpecStringPointer() *C.GParamSpecString
}

type IsParamSpecUChar 

type IsParamSpecUChar interface {
	GetParamSpecUCharPointer() *C.GParamSpecUChar
}

type IsParamSpecUInt 

type IsParamSpecUInt interface {
	GetParamSpecUIntPointer() *C.GParamSpecUInt
}

type IsParamSpecUInt64 

type IsParamSpecUInt64 interface {
	GetParamSpecUInt64Pointer() *C.GParamSpecUInt64
}

type IsParamSpecULong 

type IsParamSpecULong interface {
	GetParamSpecULongPointer() *C.GParamSpecULong
}

type IsParamSpecUnichar 

type IsParamSpecUnichar interface {
	GetParamSpecUnicharPointer() *C.GParamSpecUnichar
}

type IsParamSpecValueArray 

type IsParamSpecValueArray interface {
	GetParamSpecValueArrayPointer() *C.GParamSpecValueArray
}

type IsParamSpecVariant 

type IsParamSpecVariant interface {
	GetParamSpecVariantPointer() *C.GParamSpecVariant
}

type IsTypeModule 

type IsTypeModule interface {
	GetTypeModulePointer() *C.GTypeModule
}

type Object 

type Object struct {
	*TraitObject
	CPointer unsafe.Pointer
}

func NewObjectFromCPointer 

func NewObjectFromCPointer(p unsafe.Pointer) *Object

func ObjectNewv 

func ObjectNewv(object_type C.GType, n_parameters uint, parameters *C.GParameter) (return__ *Object)

Creates a new instance of a #GObject subtype and sets its properties.

Construction parameters (see #G_PARAM_CONSTRUCT, #G_PARAM_CONSTRUCT_ONLY) which are not explicitly specified are set to their default values.

type ObjectConstructParam 

type ObjectConstructParam C.GObjectConstructParam

type ParamSpec 

type ParamSpec struct {
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func GParamSpecBoolean 

func GParamSpecBoolean(name string, nick string, blurb string, default_value bool, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecBoolean instance specifying a %G_TYPE_BOOLEAN property.

See g_param_spec_internal() for details on property names.

func GParamSpecBoxed 

func GParamSpecBoxed(name string, nick string, blurb string, boxed_type C.GType, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_BOXED derived property.

See g_param_spec_internal() for details on property names.

func GParamSpecChar 

func GParamSpecChar(name string, nick string, blurb string, minimum int8, maximum int8, default_value int8, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecChar instance specifying a %G_TYPE_CHAR property.

func GParamSpecDouble 

func GParamSpecDouble(name string, nick string, blurb string, minimum float64, maximum float64, default_value float64, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecDouble instance specifying a %G_TYPE_DOUBLE property.

See g_param_spec_internal() for details on property names.

func GParamSpecEnum 

func GParamSpecEnum(name string, nick string, blurb string, enum_type C.GType, default_value int, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecEnum instance specifying a %G_TYPE_ENUM property.

See g_param_spec_internal() for details on property names.

func GParamSpecFlags 

func GParamSpecFlags(name string, nick string, blurb string, flags_type C.GType, default_value uint, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecFlags instance specifying a %G_TYPE_FLAGS property.

See g_param_spec_internal() for details on property names.

func GParamSpecFloat 

func GParamSpecFloat(name string, nick string, blurb string, minimum float32, maximum float32, default_value float32, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecFloat instance specifying a %G_TYPE_FLOAT property.

See g_param_spec_internal() for details on property names.

func GParamSpecGtype 

func GParamSpecGtype(name string, nick string, blurb string, is_a_type C.GType, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecGType instance specifying a %G_TYPE_GTYPE property.

See g_param_spec_internal() for details on property names.

func GParamSpecInt 

func GParamSpecInt(name string, nick string, blurb string, minimum int, maximum int, default_value int, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecInt instance specifying a %G_TYPE_INT property.

See g_param_spec_internal() for details on property names.

func GParamSpecInt64 

func GParamSpecInt64(name string, nick string, blurb string, minimum int64, maximum int64, default_value int64, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecInt64 instance specifying a %G_TYPE_INT64 property.

See g_param_spec_internal() for details on property names.

func GParamSpecLong 

func GParamSpecLong(name string, nick string, blurb string, minimum int64, maximum int64, default_value int64, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecLong instance specifying a %G_TYPE_LONG property.

See g_param_spec_internal() for details on property names.

func GParamSpecObject 

func GParamSpecObject(name string, nick string, blurb string, object_type C.GType, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_OBJECT derived property.

See g_param_spec_internal() for details on property names.

func GParamSpecOverride 

func GParamSpecOverride(name string, overridden IsParamSpec) (return__ *ParamSpec)

Creates a new property of type #GParamSpecOverride. This is used to direct operations to another paramspec, and will not be directly useful unless you are implementing a new base type similar to GObject.

func GParamSpecParam 

func GParamSpecParam(name string, nick string, blurb string, param_type C.GType, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecParam instance specifying a %G_TYPE_PARAM property.

See g_param_spec_internal() for details on property names.

func GParamSpecPointer 

func GParamSpecPointer(name string, nick string, blurb string, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecPointer instance specifying a pointer property.

See g_param_spec_internal() for details on property names.

func GParamSpecString 

func GParamSpecString(name string, nick string, blurb string, default_value string, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecString instance.

See g_param_spec_internal() for details on property names.

func GParamSpecUchar 

func GParamSpecUchar(name string, nick string, blurb string, minimum uint8, maximum uint8, default_value uint8, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecUChar instance specifying a %G_TYPE_UCHAR property.

func GParamSpecUint 

func GParamSpecUint(name string, nick string, blurb string, minimum uint, maximum uint, default_value uint, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecUInt instance specifying a %G_TYPE_UINT property.

See g_param_spec_internal() for details on property names.

func GParamSpecUint64 

func GParamSpecUint64(name string, nick string, blurb string, minimum uint64, maximum uint64, default_value uint64, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecUInt64 instance specifying a %G_TYPE_UINT64 property.

See g_param_spec_internal() for details on property names.

func GParamSpecUlong 

func GParamSpecUlong(name string, nick string, blurb string, minimum uint64, maximum uint64, default_value uint64, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecULong instance specifying a %G_TYPE_ULONG property.

See g_param_spec_internal() for details on property names.

func GParamSpecUnichar 

func GParamSpecUnichar(name string, nick string, blurb string, default_value rune, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecUnichar instance specifying a %G_TYPE_UINT property. #GValue structures for this property can be accessed with g_value_set_uint() and g_value_get_uint().

See g_param_spec_internal() for details on property names.

func GParamSpecValueArray 

func GParamSpecValueArray(name string, nick string, blurb string, element_spec IsParamSpec, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecValueArray instance specifying a %G_TYPE_VALUE_ARRAY property. %G_TYPE_VALUE_ARRAY is a %G_TYPE_BOXED type, as such, #GValue structures for this property can be accessed with g_value_set_boxed() and g_value_get_boxed().

See g_param_spec_internal() for details on property names.

func GParamSpecVariant 

func GParamSpecVariant(name string, nick string, blurb string, type_ *C.GVariantType, default_value *C.GVariant, flags C.GParamFlags) (return__ *ParamSpec)

Creates a new #GParamSpecVariant instance specifying a #GVariant property.

If @default_value is floating, it is consumed.

See g_param_spec_internal() for details on property names.

func NewParamSpecFromCPointer 

func NewParamSpecFromCPointer(p unsafe.Pointer) *ParamSpec

type ParamSpecBoolean 

type ParamSpecBoolean struct {
	*TraitParamSpecBoolean
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecBooleanFromCPointer 

func NewParamSpecBooleanFromCPointer(p unsafe.Pointer) *ParamSpecBoolean

type ParamSpecBoxed 

type ParamSpecBoxed struct {
	*TraitParamSpecBoxed
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecBoxedFromCPointer 

func NewParamSpecBoxedFromCPointer(p unsafe.Pointer) *ParamSpecBoxed

type ParamSpecChar 

type ParamSpecChar struct {
	*TraitParamSpecChar
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecCharFromCPointer 

func NewParamSpecCharFromCPointer(p unsafe.Pointer) *ParamSpecChar

type ParamSpecDouble 

type ParamSpecDouble struct {
	*TraitParamSpecDouble
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecDoubleFromCPointer 

func NewParamSpecDoubleFromCPointer(p unsafe.Pointer) *ParamSpecDouble

type ParamSpecEnum 

type ParamSpecEnum struct {
	*TraitParamSpecEnum
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecEnumFromCPointer 

func NewParamSpecEnumFromCPointer(p unsafe.Pointer) *ParamSpecEnum

type ParamSpecFlags 

type ParamSpecFlags struct {
	*TraitParamSpecFlags
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecFlagsFromCPointer 

func NewParamSpecFlagsFromCPointer(p unsafe.Pointer) *ParamSpecFlags

type ParamSpecFloat 

type ParamSpecFloat struct {
	*TraitParamSpecFloat
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecFloatFromCPointer 

func NewParamSpecFloatFromCPointer(p unsafe.Pointer) *ParamSpecFloat

type ParamSpecGType 

type ParamSpecGType struct {
	*TraitParamSpecGType
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecGTypeFromCPointer 

func NewParamSpecGTypeFromCPointer(p unsafe.Pointer) *ParamSpecGType

type ParamSpecInt 

type ParamSpecInt struct {
	*TraitParamSpecInt
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecIntFromCPointer 

func NewParamSpecIntFromCPointer(p unsafe.Pointer) *ParamSpecInt

type ParamSpecInt64 

type ParamSpecInt64 struct {
	*TraitParamSpecInt64
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecInt64FromCPointer 

func NewParamSpecInt64FromCPointer(p unsafe.Pointer) *ParamSpecInt64

type ParamSpecLong 

type ParamSpecLong struct {
	*TraitParamSpecLong
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecLongFromCPointer 

func NewParamSpecLongFromCPointer(p unsafe.Pointer) *ParamSpecLong

type ParamSpecObject 

type ParamSpecObject struct {
	*TraitParamSpecObject
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecObjectFromCPointer 

func NewParamSpecObjectFromCPointer(p unsafe.Pointer) *ParamSpecObject

type ParamSpecOverride 

type ParamSpecOverride struct {
	*TraitParamSpecOverride
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecOverrideFromCPointer 

func NewParamSpecOverrideFromCPointer(p unsafe.Pointer) *ParamSpecOverride

type ParamSpecParam 

type ParamSpecParam struct {
	*TraitParamSpecParam
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecParamFromCPointer 

func NewParamSpecParamFromCPointer(p unsafe.Pointer) *ParamSpecParam

type ParamSpecPointer 

type ParamSpecPointer struct {
	*TraitParamSpecPointer
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecPointerFromCPointer 

func NewParamSpecPointerFromCPointer(p unsafe.Pointer) *ParamSpecPointer

type ParamSpecPool 

type ParamSpecPool C.GParamSpecPool

type ParamSpecString 

type ParamSpecString struct {
	*TraitParamSpecString
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecStringFromCPointer 

func NewParamSpecStringFromCPointer(p unsafe.Pointer) *ParamSpecString

type ParamSpecTypeInfo 

type ParamSpecTypeInfo C.GParamSpecTypeInfo

type ParamSpecUChar 

type ParamSpecUChar struct {
	*TraitParamSpecUChar
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecUCharFromCPointer 

func NewParamSpecUCharFromCPointer(p unsafe.Pointer) *ParamSpecUChar

type ParamSpecUInt 

type ParamSpecUInt struct {
	*TraitParamSpecUInt
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecUIntFromCPointer 

func NewParamSpecUIntFromCPointer(p unsafe.Pointer) *ParamSpecUInt

type ParamSpecUInt64 

type ParamSpecUInt64 struct {
	*TraitParamSpecUInt64
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecUInt64FromCPointer 

func NewParamSpecUInt64FromCPointer(p unsafe.Pointer) *ParamSpecUInt64

type ParamSpecULong 

type ParamSpecULong struct {
	*TraitParamSpecULong
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecULongFromCPointer 

func NewParamSpecULongFromCPointer(p unsafe.Pointer) *ParamSpecULong

type ParamSpecUnichar 

type ParamSpecUnichar struct {
	*TraitParamSpecUnichar
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecUnicharFromCPointer 

func NewParamSpecUnicharFromCPointer(p unsafe.Pointer) *ParamSpecUnichar

type ParamSpecValueArray 

type ParamSpecValueArray struct {
	*TraitParamSpecValueArray
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecValueArrayFromCPointer 

func NewParamSpecValueArrayFromCPointer(p unsafe.Pointer) *ParamSpecValueArray

type ParamSpecVariant 

type ParamSpecVariant struct {
	*TraitParamSpecVariant
	*TraitParamSpec
	CPointer unsafe.Pointer
}

func NewParamSpecVariantFromCPointer 

func NewParamSpecVariantFromCPointer(p unsafe.Pointer) *ParamSpecVariant

type Parameter 

type Parameter C.GParameter

type SignalInvocationHint 

type SignalInvocationHint C.GSignalInvocationHint

type SignalQuery 

type SignalQuery C.GSignalQuery

type TraitBinding 

type TraitBinding struct{ CPointer *C.GBinding }

func NewTraitBinding 

func NewTraitBinding(p unsafe.Pointer) *TraitBinding

func (*TraitBinding) GetBindingPointer 

func (self *TraitBinding) GetBindingPointer() *C.GBinding

func (*TraitBinding) GetFlags 

func (self *TraitBinding) GetFlags() (return__ C.GBindingFlags)

Retrieves the flags passed when constructing the #GBinding.

func (*TraitBinding) GetSource 

func (self *TraitBinding) GetSource() (return__ *Object)

Retrieves the #GObject instance used as the source of the binding.

func (*TraitBinding) GetSourceProperty 

func (self *TraitBinding) GetSourceProperty() (return__ string)

Retrieves the name of the property of #GBinding:source used as the source of the binding.

func (*TraitBinding) GetTarget 

func (self *TraitBinding) GetTarget() (return__ *Object)

Retrieves the #GObject instance used as the target of the binding.

func (*TraitBinding) GetTargetProperty 

func (self *TraitBinding) GetTargetProperty() (return__ string)

Retrieves the name of the property of #GBinding:target used as the target of the binding.

func (*TraitBinding) Unbind 

func (self *TraitBinding) Unbind()

Explicitly releases the binding between the source and the target property expressed by @binding.

This function will release the reference that is being held on the @binding instance; if you want to hold on to the #GBinding instance after calling g_binding_unbind(), you will need to hold a reference to it.

type TraitInitiallyUnowned 

type TraitInitiallyUnowned struct{ CPointer *C.GInitiallyUnowned }

func NewTraitInitiallyUnowned 

func NewTraitInitiallyUnowned(p unsafe.Pointer) *TraitInitiallyUnowned

func (*TraitInitiallyUnowned) GetInitiallyUnownedPointer 

func (self *TraitInitiallyUnowned) GetInitiallyUnownedPointer() *C.GInitiallyUnowned

type TraitObject 

type TraitObject struct{ CPointer *C.GObject }

func NewTraitObject 

func NewTraitObject(p unsafe.Pointer) *TraitObject

func (*TraitObject) AddToggleRef 

func (self *TraitObject) AddToggleRef(notify C.GToggleNotify, data unsafe.Pointer)

Increases the reference count of the object by one and sets a callback to be called when all other references to the object are dropped, or when this is already the last reference to the object and another reference is established.

This functionality is intended for binding @object to a proxy object managed by another memory manager. This is done with two paired references: the strong reference added by g_object_add_toggle_ref() and a reverse reference to the proxy object which is either a strong reference or weak reference.

The setup is that when there are no other references to @object, only a weak reference is held in the reverse direction from @object to the proxy object, but when there are other references held to @object, a strong reference is held. The @notify callback is called when the reference from @object to the proxy object should be "toggled" from strong to weak (@is_last_ref true) or weak to strong (@is_last_ref false).

Since a (normal) reference must be held to the object before calling g_object_add_toggle_ref(), the initial state of the reverse link is always strong.

Multiple toggle references may be added to the same gobject, however if there are multiple toggle references to an object, none of them will ever be notified until all but one are removed. For this reason, you should only ever use a toggle reference if there is important state in the proxy object.

func (*TraitObject) BindProperty 

func (self *TraitObject) BindProperty(source_property string, target IsObject, target_property string, flags C.GBindingFlags) (return__ *Binding)

Creates a binding between @source_property on @source and @target_property on @target. Whenever the @source_property is changed the @target_property is updated using the same value. For instance:

|[ 

g_object_bind_property (action, "active", widget, "sensitive", 0);

]|

Will result in the "sensitive" property of the widget #GObject instance to be updated with the same value of the "active" property of the action #GObject instance.

If @flags contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual: if @target_property on @target changes then the @source_property on @source will be updated as well.

The binding will automatically be removed when either the @source or the @target instances are finalized. To remove the binding without affecting the @source and the @target you can just call g_object_unref() on the returned #GBinding instance.

A #GObject can have multiple bindings.

func (*TraitObject) BindPropertyFull 

func (self *TraitObject) BindPropertyFull(source_property string, target IsObject, target_property string, flags C.GBindingFlags, transform_to C.GBindingTransformFunc, transform_from C.GBindingTransformFunc, user_data unsafe.Pointer, notify C.GDestroyNotify) (return__ *Binding)

Complete version of g_object_bind_property().

Creates a binding between @source_property on @source and @target_property on @target, allowing you to set the transformation functions to be used by the binding.

If @flags contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual: if @target_property on @target changes then the @source_property on @source will be updated as well. The @transform_from function is only used in case of bidirectional bindings, otherwise it will be ignored

The binding will automatically be removed when either the @source or the @target instances are finalized. To remove the binding without affecting the @source and the @target you can just call g_object_unref() on the returned #GBinding instance.

A #GObject can have multiple bindings.

The same @user_data parameter will be used for both @transform_to and @transform_from transformation functions; the @notify function will be called once, when the binding is removed. If you need different data for each transformation function, please use g_object_bind_property_with_closures() instead.

func (*TraitObject) BindPropertyWithClosures 

func (self *TraitObject) BindPropertyWithClosures(source_property string, target IsObject, target_property string, flags C.GBindingFlags, transform_to *C.GClosure, transform_from *C.GClosure) (return__ *Binding)

Creates a binding between @source_property on @source and @target_property on @target, allowing you to set the transformation functions to be used by the binding.

This function is the language bindings friendly version of g_object_bind_property_full(), using #GClosures instead of function pointers.

func (*TraitObject) Connect 

func (self *TraitObject) Connect(signal string, cb interface{}) uint64

func (*TraitObject) DupData 

func (self *TraitObject) DupData(key string, dup_func C.GDuplicateFunc, user_data unsafe.Pointer) (return__ unsafe.Pointer)

This is a variant of g_object_get_data() which returns a 'duplicate' of the value. @dup_func defines the meaning of 'duplicate' in this context, it could e.g. take a reference on a ref-counted object.

If the @key is not set on the object then @dup_func will be called with a %NULL argument.

Note that @dup_func is called while user data of @object is locked.

This function can be useful to avoid races when multiple threads are using object data on the same key on the same object.

func (*TraitObject) DupQdata 

func (self *TraitObject) DupQdata(quark C.GQuark, dup_func C.GDuplicateFunc, user_data unsafe.Pointer) (return__ unsafe.Pointer)

This is a variant of g_object_get_qdata() which returns a 'duplicate' of the value. @dup_func defines the meaning of 'duplicate' in this context, it could e.g. take a reference on a ref-counted object.

If the @quark is not set on the object then @dup_func will be called with a %NULL argument.

Note that @dup_func is called while user data of @object is locked.

This function can be useful to avoid races when multiple threads are using object data on the same key on the same object.

func (*TraitObject) ForceFloating 

func (self *TraitObject) ForceFloating()

This function is intended for #GObject implementations to re-enforce a [floating][floating-ref] object reference. Doing this is seldom required: all #GInitiallyUnowneds are created with a floating reference which usually just needs to be sunken by calling g_object_ref_sink().

func (*TraitObject) FreezeNotify 

func (self *TraitObject) FreezeNotify()

Increases the freeze count on @object. If the freeze count is non-zero, the emission of "notify" signals on @object is stopped. The signals are queued until the freeze count is decreased to zero. Duplicate notifications are squashed so that at most one #GObject::notify signal is emitted for each property modified while the object is frozen.

This is necessary for accessors that modify multiple properties to prevent premature notification while the object is still being modified.

func (*TraitObject) GetData 

func (self *TraitObject) GetData(key string) (return__ unsafe.Pointer)

Gets a named field from the objects table of associations (see g_object_set_data()).

func (*TraitObject) GetObjectPointer 

func (self *TraitObject) GetObjectPointer() *C.GObject

func (*TraitObject) GetProperty 

func (self *TraitObject) GetProperty(property_name string, value *C.GValue)

Gets a property of an object. @value must have been initialized to the expected type of the property (or a type to which the expected type can be transformed) using g_value_init().

In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling g_value_unset().

Note that g_object_get_property() is really intended for language bindings, g_object_get() is much more convenient for C programming.

func (*TraitObject) GetQdata 

func (self *TraitObject) GetQdata(quark C.GQuark) (return__ unsafe.Pointer)

This function gets back user data pointers stored via g_object_set_qdata().

func (*TraitObject) IsFloating 

func (self *TraitObject) IsFloating() (return__ bool)

Checks whether @object has a [floating][floating-ref] reference.

func (*TraitObject) Notify 

func (self *TraitObject) Notify(property_name string)

Emits a "notify" signal for the property @property_name on @object.

When possible, eg. when signaling a property change from within the class that registered the property, you should use g_object_notify_by_pspec() instead.

Note that emission of the notify signal may be blocked with g_object_freeze_notify(). In this case, the signal emissions are queued and will be emitted (in reverse order) when g_object_thaw_notify() is called.

func (*TraitObject) NotifyByPspec 

func (self *TraitObject) NotifyByPspec(pspec IsParamSpec)

Emits a "notify" signal for the property specified by @pspec on @object.

This function omits the property name lookup, hence it is faster than g_object_notify().

One way to avoid using g_object_notify() from within the class that registered the properties, and using g_object_notify_by_pspec() instead, is to store the GParamSpec used with g_object_class_install_property() inside a static array, e.g.:

|[<!-- language="C" --> 

enum
{
  PROP_0,
  PROP_FOO,
  PROP_LAST
};

static GParamSpec *properties[PROP_LAST];

static void
my_object_class_init (MyObjectClass *klass)
{
  properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
                                           0, 100,
                                           50,
                                           G_PARAM_READWRITE);
  g_object_class_install_property (gobject_class,
                                   PROP_FOO,
                                   properties[PROP_FOO]);
}

]|

and then notify a change on the "foo" property with:

|[<!-- language="C" --> 

g_object_notify_by_pspec (self, properties[PROP_FOO]);

]|

func (*TraitObject) Ref 

func (self *TraitObject) Ref() (return__ *Object)

Increases the reference count of @object.

func (*TraitObject) RefSink 

func (self *TraitObject) RefSink() (return__ *Object)

Increase the reference count of @object, and possibly remove the [floating][floating-ref] reference, if @object has a floating reference.

In other words, if the object is floating, then this call "assumes ownership" of the floating reference, converting it to a normal reference by clearing the floating flag while leaving the reference count unchanged. If the object is not floating, then this call adds a new normal reference increasing the reference count by one.

func (*TraitObject) RemoveToggleRef 

func (self *TraitObject) RemoveToggleRef(notify C.GToggleNotify, data unsafe.Pointer)

Removes a reference added with g_object_add_toggle_ref(). The reference count of the object is decreased by one.

func (*TraitObject) ReplaceData 

func (self *TraitObject) ReplaceData(key string, oldval unsafe.Pointer, newval unsafe.Pointer, destroy C.GDestroyNotify, old_destroy *C.GDestroyNotify) (return__ bool)

Compares the user data for the key @key on @object with @oldval, and if they are the same, replaces @oldval with @newval.

This is like a typical atomic compare-and-exchange operation, for user data on an object.

If the previous value was replaced then ownership of the old value (@oldval) is passed to the caller, including the registered destroy notify for it (passed out in @old_destroy). Its up to the caller to free this as he wishes, which may or may not include using @old_destroy as sometimes replacement should not destroy the object in the normal way.

func (*TraitObject) ReplaceQdata 

func (self *TraitObject) ReplaceQdata(quark C.GQuark, oldval unsafe.Pointer, newval unsafe.Pointer, destroy C.GDestroyNotify, old_destroy *C.GDestroyNotify) (return__ bool)

Compares the user data for the key @quark on @object with @oldval, and if they are the same, replaces @oldval with @newval.

This is like a typical atomic compare-and-exchange operation, for user data on an object.

If the previous value was replaced then ownership of the old value (@oldval) is passed to the caller, including the registered destroy notify for it (passed out in @old_destroy). Its up to the caller to free this as he wishes, which may or may not include using @old_destroy as sometimes replacement should not destroy the object in the normal way.

func (*TraitObject) RunDispose 

func (self *TraitObject) RunDispose()

Releases all references to other objects. This can be used to break reference cycles.

This functions should only be called from object system implementations.

func (*TraitObject) SetData 

func (self *TraitObject) SetData(key string, data unsafe.Pointer)

Each object carries around a table of associations from strings to pointers. This function lets you set an association.

If the object already had an association with that name, the old association will be destroyed.

func (*TraitObject) SetDataFull 

func (self *TraitObject) SetDataFull(key string, data unsafe.Pointer, destroy C.GDestroyNotify)

Like g_object_set_data() except it adds notification for when the association is destroyed, either by setting it to a different value or when the object is destroyed.

Note that the @destroy callback is not called if @data is %NULL.

func (*TraitObject) SetProperty 

func (self *TraitObject) SetProperty(property_name string, value *C.GValue)

Sets a property on an object.

func (*TraitObject) SetQdata 

func (self *TraitObject) SetQdata(quark C.GQuark, data unsafe.Pointer)

This sets an opaque, named pointer on an object. The name is specified through a #GQuark (retrived e.g. via g_quark_from_static_string()), and the pointer can be gotten back from the @object with g_object_get_qdata() until the @object is finalized. Setting a previously set user data pointer, overrides (frees) the old pointer set, using #NULL as pointer essentially removes the data stored.

func (*TraitObject) SetQdataFull 

func (self *TraitObject) SetQdataFull(quark C.GQuark, data unsafe.Pointer, destroy C.GDestroyNotify)

This function works like g_object_set_qdata(), but in addition, a void (*destroy) (gpointer) function may be specified which is called with @data as argument when the @object is finalized, or the data is being overwritten by a call to g_object_set_qdata() with the same @quark.

func (*TraitObject) StealData 

func (self *TraitObject) StealData(key string) (return__ unsafe.Pointer)

Remove a specified datum from the object's data associations, without invoking the association's destroy handler.

func (*TraitObject) StealQdata 

func (self *TraitObject) StealQdata(quark C.GQuark) (return__ unsafe.Pointer)

This function gets back user data pointers stored via g_object_set_qdata() and removes the @data from object without invoking its destroy() function (if any was set). Usually, calling this function is only required to update user data pointers with a destroy notifier, for example: |[<!-- language="C" --> void object_add_to_user_list (GObject *object, 

const gchar *new_string)

{
  // the quark, naming the object data
  GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
  // retrive the old string list
  GList *list = g_object_steal_qdata (object, quark_string_list);

  // prepend new string
  list = g_list_prepend (list, g_strdup (new_string));
  // this changed 'list', so we need to set it again
  g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
}

static void free_string_list (gpointer data) 

{
  GList *node, *list = data;

  for (node = list; node; node = node->next)
    g_free (node->data);
  g_list_free (list);
}

]| Using g_object_get_qdata() in the above example, instead of g_object_steal_qdata() would have left the destroy function set, and thus the partial string list would have been freed upon g_object_set_qdata_full().

func (*TraitObject) ThawNotify 

func (self *TraitObject) ThawNotify()

Reverts the effect of a previous call to g_object_freeze_notify(). The freeze count is decreased on @object and when it reaches zero, queued "notify" signals are emitted.

Duplicate notifications for each property are squashed so that at most one #GObject::notify signal is emitted for each property, in the reverse order in which they have been queued.

It is an error to call this function when the freeze count is zero.

func (*TraitObject) Unref 

func (self *TraitObject) Unref()

Decreases the reference count of @object. When its reference count drops to 0, the object is finalized (i.e. its memory is freed).

func (*TraitObject) WatchClosure 

func (self *TraitObject) WatchClosure(closure *C.GClosure)

This function essentially limits the life time of the @closure to the life time of the object. That is, when the object is finalized, the @closure is invalidated by calling g_closure_invalidate() on it, in order to prevent invocations of the closure with a finalized (nonexisting) object. Also, g_object_ref() and g_object_unref() are added as marshal guards to the @closure, to ensure that an extra reference count is held on @object during invocation of the @closure. Usually, this function will be called on closures that use this @object as closure data.

func (*TraitObject) WeakRef 

func (self *TraitObject) WeakRef(notify C.GWeakNotify, data unsafe.Pointer)

Adds a weak reference callback to an object. Weak references are used for notification when an object is finalized. They are called "weak references" because they allow you to safely hold a pointer to an object without calling g_object_ref() (g_object_ref() adds a strong reference, that is, forces the object to stay alive).

Note that the weak references created by this method are not thread-safe: they cannot safely be used in one thread if the object's last g_object_unref() might happen in another thread. Use #GWeakRef if thread-safety is required.

func (*TraitObject) WeakUnref 

func (self *TraitObject) WeakUnref(notify C.GWeakNotify, data unsafe.Pointer)

Removes a weak reference callback to an object.

type TraitParamSpec 

type TraitParamSpec struct{ CPointer *C.GParamSpec }

func NewTraitParamSpec 

func NewTraitParamSpec(p unsafe.Pointer) *TraitParamSpec

func (*TraitParamSpec) GetBlurb 

func (self *TraitParamSpec) GetBlurb() (return__ string)

Get the short description of a #GParamSpec.

func (*TraitParamSpec) GetDefaultValue 

func (self *TraitParamSpec) GetDefaultValue() (return__ *C.GValue)

func (*TraitParamSpec) GetName 

func (self *TraitParamSpec) GetName() (return__ string)

Get the name of a #GParamSpec.

The name is always an "interned" string (as per g_intern_string()). This allows for pointer-value comparisons.

func (*TraitParamSpec) GetNick 

func (self *TraitParamSpec) GetNick() (return__ string)

Get the nickname of a #GParamSpec.

func (*TraitParamSpec) GetParamSpecPointer 

func (self *TraitParamSpec) GetParamSpecPointer() *C.GParamSpec

func (*TraitParamSpec) GetQdata 

func (self *TraitParamSpec) GetQdata(quark C.GQuark) (return__ unsafe.Pointer)

Gets back user data pointers stored via g_param_spec_set_qdata().

func (*TraitParamSpec) GetRedirectTarget 

func (self *TraitParamSpec) GetRedirectTarget() (return__ *ParamSpec)

If the paramspec redirects operations to another paramspec, returns that paramspec. Redirect is used typically for providing a new implementation of a property in a derived type while preserving all the properties from the parent type. Redirection is established by creating a property of type #GParamSpecOverride. See g_object_class_override_property() for an example of the use of this capability.

func (*TraitParamSpec) Ref 

func (self *TraitParamSpec) Ref() (return__ *ParamSpec)

Increments the reference count of @pspec.

func (*TraitParamSpec) RefSink 

func (self *TraitParamSpec) RefSink() (return__ *ParamSpec)

Convenience function to ref and sink a #GParamSpec.

func (*TraitParamSpec) SetQdata 

func (self *TraitParamSpec) SetQdata(quark C.GQuark, data unsafe.Pointer)

Sets an opaque, named pointer on a #GParamSpec. The name is specified through a #GQuark (retrieved e.g. via g_quark_from_static_string()), and the pointer can be gotten back from the @pspec with g_param_spec_get_qdata(). Setting a previously set user data pointer, overrides (frees) the old pointer set, using %NULL as pointer essentially removes the data stored.

func (*TraitParamSpec) SetQdataFull 

func (self *TraitParamSpec) SetQdataFull(quark C.GQuark, data unsafe.Pointer, destroy C.GDestroyNotify)

This function works like g_param_spec_set_qdata(), but in addition, a `void (*destroy) (gpointer)` function may be specified which is called with @data as argument when the @pspec is finalized, or the data is being overwritten by a call to g_param_spec_set_qdata() with the same @quark.

func (*TraitParamSpec) Sink 

func (self *TraitParamSpec) Sink()

The initial reference count of a newly created #GParamSpec is 1, even though no one has explicitly called g_param_spec_ref() on it yet. So the initial reference count is flagged as "floating", until someone calls `g_param_spec_ref (pspec); g_param_spec_sink (pspec);` in sequence on it, taking over the initial reference count (thus ending up with a @pspec that has a reference count of 1 still, but is not flagged "floating" anymore).

func (*TraitParamSpec) StealQdata 

func (self *TraitParamSpec) StealQdata(quark C.GQuark) (return__ unsafe.Pointer)

Gets back user data pointers stored via g_param_spec_set_qdata() and removes the @data from @pspec without invoking its destroy() function (if any was set). Usually, calling this function is only required to update user data pointers with a destroy notifier.

func (*TraitParamSpec) Unref 

func (self *TraitParamSpec) Unref()

Decrements the reference count of a @pspec.

type TraitParamSpecBoolean 

type TraitParamSpecBoolean struct{ CPointer *C.GParamSpecBoolean }

func NewTraitParamSpecBoolean 

func NewTraitParamSpecBoolean(p unsafe.Pointer) *TraitParamSpecBoolean

func (*TraitParamSpecBoolean) GetParamSpecBooleanPointer 

func (self *TraitParamSpecBoolean) GetParamSpecBooleanPointer() *C.GParamSpecBoolean

type TraitParamSpecBoxed 

type TraitParamSpecBoxed struct{ CPointer *C.GParamSpecBoxed }

func NewTraitParamSpecBoxed 

func NewTraitParamSpecBoxed(p unsafe.Pointer) *TraitParamSpecBoxed

func (*TraitParamSpecBoxed) GetParamSpecBoxedPointer 

func (self *TraitParamSpecBoxed) GetParamSpecBoxedPointer() *C.GParamSpecBoxed

type TraitParamSpecChar 

type TraitParamSpecChar struct{ CPointer *C.GParamSpecChar }

func NewTraitParamSpecChar 

func NewTraitParamSpecChar(p unsafe.Pointer) *TraitParamSpecChar

func (*TraitParamSpecChar) GetParamSpecCharPointer 

func (self *TraitParamSpecChar) GetParamSpecCharPointer() *C.GParamSpecChar

type TraitParamSpecDouble 

type TraitParamSpecDouble struct{ CPointer *C.GParamSpecDouble }

func NewTraitParamSpecDouble 

func NewTraitParamSpecDouble(p unsafe.Pointer) *TraitParamSpecDouble

func (*TraitParamSpecDouble) GetParamSpecDoublePointer 

func (self *TraitParamSpecDouble) GetParamSpecDoublePointer() *C.GParamSpecDouble

type TraitParamSpecEnum 

type TraitParamSpecEnum struct{ CPointer *C.GParamSpecEnum }

func NewTraitParamSpecEnum 

func NewTraitParamSpecEnum(p unsafe.Pointer) *TraitParamSpecEnum

func (*TraitParamSpecEnum) GetParamSpecEnumPointer 

func (self *TraitParamSpecEnum) GetParamSpecEnumPointer() *C.GParamSpecEnum

type TraitParamSpecFlags 

type TraitParamSpecFlags struct{ CPointer *C.GParamSpecFlags }

func NewTraitParamSpecFlags 

func NewTraitParamSpecFlags(p unsafe.Pointer) *TraitParamSpecFlags

func (*TraitParamSpecFlags) GetParamSpecFlagsPointer 

func (self *TraitParamSpecFlags) GetParamSpecFlagsPointer() *C.GParamSpecFlags

type TraitParamSpecFloat 

type TraitParamSpecFloat struct{ CPointer *C.GParamSpecFloat }

func NewTraitParamSpecFloat 

func NewTraitParamSpecFloat(p unsafe.Pointer) *TraitParamSpecFloat

func (*TraitParamSpecFloat) GetParamSpecFloatPointer 

func (self *TraitParamSpecFloat) GetParamSpecFloatPointer() *C.GParamSpecFloat

type TraitParamSpecGType 

type TraitParamSpecGType struct{ CPointer *C.GParamSpecGType }

func NewTraitParamSpecGType 

func NewTraitParamSpecGType(p unsafe.Pointer) *TraitParamSpecGType

func (*TraitParamSpecGType) GetParamSpecGTypePointer 

func (self *TraitParamSpecGType) GetParamSpecGTypePointer() *C.GParamSpecGType

type TraitParamSpecInt 

type TraitParamSpecInt struct{ CPointer *C.GParamSpecInt }

func NewTraitParamSpecInt 

func NewTraitParamSpecInt(p unsafe.Pointer) *TraitParamSpecInt

func (*TraitParamSpecInt) GetParamSpecIntPointer 

func (self *TraitParamSpecInt) GetParamSpecIntPointer() *C.GParamSpecInt

type TraitParamSpecInt64 

type TraitParamSpecInt64 struct{ CPointer *C.GParamSpecInt64 }

func NewTraitParamSpecInt64 

func NewTraitParamSpecInt64(p unsafe.Pointer) *TraitParamSpecInt64

func (*TraitParamSpecInt64) GetParamSpecInt64Pointer 

func (self *TraitParamSpecInt64) GetParamSpecInt64Pointer() *C.GParamSpecInt64

type TraitParamSpecLong 

type TraitParamSpecLong struct{ CPointer *C.GParamSpecLong }

func NewTraitParamSpecLong 

func NewTraitParamSpecLong(p unsafe.Pointer) *TraitParamSpecLong

func (*TraitParamSpecLong) GetParamSpecLongPointer 

func (self *TraitParamSpecLong) GetParamSpecLongPointer() *C.GParamSpecLong

type TraitParamSpecObject 

type TraitParamSpecObject struct{ CPointer *C.GParamSpecObject }

func NewTraitParamSpecObject 

func NewTraitParamSpecObject(p unsafe.Pointer) *TraitParamSpecObject

func (*TraitParamSpecObject) GetParamSpecObjectPointer 

func (self *TraitParamSpecObject) GetParamSpecObjectPointer() *C.GParamSpecObject

type TraitParamSpecOverride 

type TraitParamSpecOverride struct{ CPointer *C.GParamSpecOverride }

func NewTraitParamSpecOverride 

func NewTraitParamSpecOverride(p unsafe.Pointer) *TraitParamSpecOverride

func (*TraitParamSpecOverride) GetParamSpecOverridePointer 

func (self *TraitParamSpecOverride) GetParamSpecOverridePointer() *C.GParamSpecOverride

type TraitParamSpecParam 

type TraitParamSpecParam struct{ CPointer *C.GParamSpecParam }

func NewTraitParamSpecParam 

func NewTraitParamSpecParam(p unsafe.Pointer) *TraitParamSpecParam

func (*TraitParamSpecParam) GetParamSpecParamPointer 

func (self *TraitParamSpecParam) GetParamSpecParamPointer() *C.GParamSpecParam

type TraitParamSpecPointer 

type TraitParamSpecPointer struct{ CPointer *C.GParamSpecPointer }

func NewTraitParamSpecPointer 

func NewTraitParamSpecPointer(p unsafe.Pointer) *TraitParamSpecPointer

func (*TraitParamSpecPointer) GetParamSpecPointerPointer 

func (self *TraitParamSpecPointer) GetParamSpecPointerPointer() *C.GParamSpecPointer

type TraitParamSpecString 

type TraitParamSpecString struct{ CPointer *C.GParamSpecString }

func NewTraitParamSpecString 

func NewTraitParamSpecString(p unsafe.Pointer) *TraitParamSpecString

func (*TraitParamSpecString) GetParamSpecStringPointer 

func (self *TraitParamSpecString) GetParamSpecStringPointer() *C.GParamSpecString

type TraitParamSpecUChar 

type TraitParamSpecUChar struct{ CPointer *C.GParamSpecUChar }

func NewTraitParamSpecUChar 

func NewTraitParamSpecUChar(p unsafe.Pointer) *TraitParamSpecUChar

func (*TraitParamSpecUChar) GetParamSpecUCharPointer 

func (self *TraitParamSpecUChar) GetParamSpecUCharPointer() *C.GParamSpecUChar

type TraitParamSpecUInt 

type TraitParamSpecUInt struct{ CPointer *C.GParamSpecUInt }

func NewTraitParamSpecUInt 

func NewTraitParamSpecUInt(p unsafe.Pointer) *TraitParamSpecUInt

func (*TraitParamSpecUInt) GetParamSpecUIntPointer 

func (self *TraitParamSpecUInt) GetParamSpecUIntPointer() *C.GParamSpecUInt

type TraitParamSpecUInt64 

type TraitParamSpecUInt64 struct{ CPointer *C.GParamSpecUInt64 }

func NewTraitParamSpecUInt64 

func NewTraitParamSpecUInt64(p unsafe.Pointer) *TraitParamSpecUInt64

func (*TraitParamSpecUInt64) GetParamSpecUInt64Pointer 

func (self *TraitParamSpecUInt64) GetParamSpecUInt64Pointer() *C.GParamSpecUInt64

type TraitParamSpecULong 

type TraitParamSpecULong struct{ CPointer *C.GParamSpecULong }

func NewTraitParamSpecULong 

func NewTraitParamSpecULong(p unsafe.Pointer) *TraitParamSpecULong

func (*TraitParamSpecULong) GetParamSpecULongPointer 

func (self *TraitParamSpecULong) GetParamSpecULongPointer() *C.GParamSpecULong

type TraitParamSpecUnichar 

type TraitParamSpecUnichar struct{ CPointer *C.GParamSpecUnichar }

func NewTraitParamSpecUnichar 

func NewTraitParamSpecUnichar(p unsafe.Pointer) *TraitParamSpecUnichar

func (*TraitParamSpecUnichar) GetParamSpecUnicharPointer 

func (self *TraitParamSpecUnichar) GetParamSpecUnicharPointer() *C.GParamSpecUnichar

type TraitParamSpecValueArray 

type TraitParamSpecValueArray struct{ CPointer *C.GParamSpecValueArray }

func NewTraitParamSpecValueArray 

func NewTraitParamSpecValueArray(p unsafe.Pointer) *TraitParamSpecValueArray

func (*TraitParamSpecValueArray) GetParamSpecValueArrayPointer 

func (self *TraitParamSpecValueArray) GetParamSpecValueArrayPointer() *C.GParamSpecValueArray

type TraitParamSpecVariant 

type TraitParamSpecVariant struct{ CPointer *C.GParamSpecVariant }

func NewTraitParamSpecVariant 

func NewTraitParamSpecVariant(p unsafe.Pointer) *TraitParamSpecVariant

func (*TraitParamSpecVariant) GetParamSpecVariantPointer 

func (self *TraitParamSpecVariant) GetParamSpecVariantPointer() *C.GParamSpecVariant

type TraitTypeModule 

type TraitTypeModule struct{ CPointer *C.GTypeModule }

func NewTraitTypeModule 

func NewTraitTypeModule(p unsafe.Pointer) *TraitTypeModule

func (*TraitTypeModule) AddInterface 

func (self *TraitTypeModule) AddInterface(instance_type C.GType, interface_type C.GType, interface_info *C.GInterfaceInfo)

Registers an additional interface for a type, whose interface lives in the given type plugin. If the interface was already registered for the type in this plugin, nothing will be done.

As long as any instances of the type exist, the type plugin will not be unloaded.

func (*TraitTypeModule) GetTypeModulePointer 

func (self *TraitTypeModule) GetTypeModulePointer() *C.GTypeModule

func (*TraitTypeModule) RegisterEnum 

func (self *TraitTypeModule) RegisterEnum(name string, const_static_values *C.GEnumValue) (return__ C.GType)

Looks up or registers an enumeration that is implemented with a particular type plugin. If a type with name @type_name was previously registered, the #GType identifier for the type is returned, otherwise the type is newly registered, and the resulting #GType identifier returned.

As long as any instances of the type exist, the type plugin will not be unloaded.

func (*TraitTypeModule) RegisterFlags 

func (self *TraitTypeModule) RegisterFlags(name string, const_static_values *C.GFlagsValue) (return__ C.GType)

Looks up or registers a flags type that is implemented with a particular type plugin. If a type with name @type_name was previously registered, the #GType identifier for the type is returned, otherwise the type is newly registered, and the resulting #GType identifier returned.

As long as any instances of the type exist, the type plugin will not be unloaded.

func (*TraitTypeModule) RegisterType 

func (self *TraitTypeModule) RegisterType(parent_type C.GType, type_name string, type_info *C.GTypeInfo, flags C.GTypeFlags) (return__ C.GType)

Looks up or registers a type that is implemented with a particular type plugin. If a type with name @type_name was previously registered, the #GType identifier for the type is returned, otherwise the type is newly registered, and the resulting #GType identifier returned.

When reregistering a type (typically because a module is unloaded then reloaded, and reinitialized), @module and @parent_type must be the same as they were previously.

As long as any instances of the type exist, the type plugin will not be unloaded.

func (*TraitTypeModule) SetName 

func (self *TraitTypeModule) SetName(name string)

Sets the name for a #GTypeModule

func (*TraitTypeModule) Unuse 

func (self *TraitTypeModule) Unuse()

Decreases the use count of a #GTypeModule by one. If the result is zero, the module will be unloaded. (However, the #GTypeModule will not be freed, and types associated with the #GTypeModule are not unregistered. Once a #GTypeModule is initialized, it must exist forever.)

func (*TraitTypeModule) Use 

func (self *TraitTypeModule) Use() (return__ bool)

Increases the use count of a #GTypeModule by one. If the use count was zero before, the plugin will be loaded. If loading the plugin fails, the use count is reset to its prior value.

type TypeClass 

type TypeClass C.GTypeClass

type TypeFundamentalInfo 

type TypeFundamentalInfo C.GTypeFundamentalInfo

type TypeInfo 

type TypeInfo C.GTypeInfo

type TypeInstance 

type TypeInstance C.GTypeInstance

type TypeInterface 

type TypeInterface C.GTypeInterface

type TypeModule 

type TypeModule struct {
	*TraitTypeModule
	*TraitObject
	CPointer unsafe.Pointer
}

func NewTypeModuleFromCPointer 

func NewTypeModuleFromCPointer(p unsafe.Pointer) *TypeModule

type TypePluginClass 

type TypePluginClass C.GTypePluginClass

type TypeQuery 

type TypeQuery C.GTypeQuery

type TypeValueTable 

type TypeValueTable C.GTypeValueTable

type Value 

type Value C.GValue

type ValueArray 

type ValueArray C.GValueArray

type WeakRef 

type WeakRef C.GWeakRef

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.