gobject

package
v0.0.0-...-51f7e66 Latest Latest
Warning

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

 Go to latest Published: Aug 27, 2024 License: MIT Imports: 5 Imported by: 1

Documentation

Overview

Package gobject was automatically generated by github.com/jwijenbergh/puregotk DO NOT EDIT

Package gobject was automatically generated by github.com/jwijenbergh/puregotk DO NOT EDIT

Package gobject was automatically generated by github.com/jwijenbergh/puregotk DO NOT EDIT

Package gobject was automatically generated by github.com/jwijenbergh/puregotk DO NOT EDIT

Package gobject was automatically generated by github.com/jwijenbergh/puregotk DO NOT EDIT

Package gobject was automatically generated by github.com/jwijenbergh/puregotk DO NOT EDIT

Package gobject was automatically generated by github.com/jwijenbergh/puregotk DO NOT EDIT

Package gobject was automatically generated by github.com/jwijenbergh/puregotk DO NOT EDIT

Package gobject was automatically generated by github.com/jwijenbergh/puregotk DO NOT EDIT

Package gobject was automatically generated by github.com/jwijenbergh/puregotk DO NOT EDIT

Package gobject was automatically generated by github.com/jwijenbergh/puregotk DO NOT EDIT

Package gobject was automatically generated by github.com/jwijenbergh/puregotk DO NOT EDIT

Package gobject was automatically generated by github.com/jwijenbergh/puregotk DO NOT EDIT

Package gobject was automatically generated by github.com/jwijenbergh/puregotk DO NOT EDIT

Package gobject was automatically generated by github.com/jwijenbergh/puregotk DO NOT EDIT

Package gobject was automatically generated by github.com/jwijenbergh/puregotk DO NOT EDIT

Package gobject was automatically generated by github.com/jwijenbergh/puregotk DO NOT EDIT

Package gobject was automatically generated by github.com/jwijenbergh/puregotk DO NOT EDIT

Index

Constants

View Source 
const (
	// Mask containing the bits of #GParamSpec.flags which are reserved for GLib.
	PARAM_MASK int = 255
	// #GParamFlags value alias for %G_PARAM_STATIC_NAME | %G_PARAM_STATIC_NICK | %G_PARAM_STATIC_BLURB.
	//
	// Since 2.13.0
	PARAM_STATIC_STRINGS int = 224
	// Minimum shift count to be used for user defined flags, to be stored in
	// #GParamSpec.flags. The maximum allowed is 10.
	PARAM_USER_SHIFT int = 8
)
View Source 
const (
	// A mask for all #GSignalFlags bits.
	SIGNAL_FLAGS_MASK int = 511
	// A mask for all #GSignalMatchType bits.
	SIGNAL_MATCH_MASK int = 63
)
View Source 
const (
	// A bit in the type number that's supposed to be left untouched.
	TYPE_FLAG_RESERVED_ID_BIT glib.Type = 1
	// An integer constant that represents the number of identifiers reserved
	// for types that are assigned at compile-time.
	TYPE_FUNDAMENTAL_MAX int = 255
	// Shift value used in converting numbers to type IDs.
	TYPE_FUNDAMENTAL_SHIFT int = 2
	// First fundamental type number to create a new fundamental type id with
	// G_TYPE_MAKE_FUNDAMENTAL() reserved for BSE.
	TYPE_RESERVED_BSE_FIRST int = 32
	// Last fundamental type number reserved for BSE.
	TYPE_RESERVED_BSE_LAST int = 48
	// First fundamental type number to create a new fundamental type id with
	// G_TYPE_MAKE_FUNDAMENTAL() reserved for GLib.
	TYPE_RESERVED_GLIB_FIRST int = 22
	// Last fundamental type number reserved for GLib.
	TYPE_RESERVED_GLIB_LAST int = 31
	// First available fundamental type number to create new fundamental
	// type id with G_TYPE_MAKE_FUNDAMENTAL().
	TYPE_RESERVED_USER_FIRST int = 49
)
View Source 
const (
	// For string values, indicates that the string contained is canonical and will
	// exist for the duration of the process. See g_value_set_interned_string().
	VALUE_INTERNED_STRING int = 268435456
	// If passed to G_VALUE_COLLECT(), allocated data won't be copied
	// but used verbatim. This does not affect ref-counted types like
	// objects. This does not affect usage of g_value_copy(), the data will
	// be copied if it is not ref-counted.
	VALUE_NOCOPY_CONTENTS int = 134217728
)
View Source 
const (
	TypeInvalidVal           Type = 0
	TypeNoneVal                   = 1 << 2
	TypeInterfaceVal              = 2 << 2
	TypeCharVal                   = 3 << 2
	TypeUcharVal                  = 4 << 2
	TypeBooleanVal                = 5 << 2
	TypeIntVal                    = 6 << 2
	TypeUintVal                   = 7 << 2
	TypeLongVal                   = 8 << 2
	TypeUlongVal                  = 9 << 2
	TypeInt64Val                  = 10 << 2
	TypeUint64Val                 = 11 << 2
	TypeEnumVal                   = 12 << 2
	TypeFlagsVal                  = 13 << 2
	TypeFloatVal                  = 14 << 2
	TypeDoubleVal                 = 15 << 2
	TypeStringVal                 = 16 << 2
	TypePointerVal                = 17 << 2
	TypeBoxedVal                  = 18 << 2
	TypeParamVal                  = 19 << 2
	TypeObjectVal                 = 20 << 2
	TypeReservedGLibLastVal       = 31 << 2
	TypeReservedBseFirstVal       = 32 << 2
	TypeReservedBseLastVal        = 48 << 2
	TypeReservedUserFirstVal      = 49 << 2
)

types

Variables

View Source 
var XGTypePluginCompleteInterfaceInfo func(uintptr, []interface{}, []interface{}, *InterfaceInfo)
View Source 
var XGTypePluginCompleteTypeInfo func(uintptr, []interface{}, *TypeInfo, *TypeValueTable)
View Source 
var XGTypePluginUnuse func(uintptr)
View Source 
var XGTypePluginUse func(uintptr)

Functions

func BoxedCopy 

func BoxedCopy(BoxedTypeVar []interface{}, SrcBoxedVar uintptr) uintptr

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

func BoxedFree 

func BoxedFree(BoxedTypeVar []interface{}, BoxedVar uintptr)

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

func BoxedTypeRegisterStatic 

func BoxedTypeRegisterStatic(NameVar string, BoxedCopyVar *BoxedCopyFunc, BoxedFreeVar *BoxedFreeFunc) []interface{}

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.

For the general case, it is recommended to use G_DEFINE_BOXED_TYPE() instead of calling g_boxed_type_register_static() directly. The macro will create the appropriate `*_get_type()` function for the boxed type.

func CclosureMarshalBOOLEANBOXEDBOXED 

func CclosureMarshalBOOLEANBOXEDBOXED(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

A #GClosureMarshal function for use with signals with handlers that take two boxed pointers as arguments and return a boolean. If you have such a signal, you will probably also need to use an accumulator, such as g_signal_accumulator_true_handled().

func CclosureMarshalBOOLEANFLAGS 

func CclosureMarshalBOOLEANFLAGS(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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(ClosureVar *Closure, ReturnGvalueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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

func CclosureMarshalVOIDBOXED 

func CclosureMarshalVOIDBOXED(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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

func CclosureMarshalVOIDCHAR 

func CclosureMarshalVOIDCHAR(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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

func CclosureMarshalVOIDDOUBLE 

func CclosureMarshalVOIDDOUBLE(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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

func CclosureMarshalVOIDENUM 

func CclosureMarshalVOIDENUM(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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

func CclosureMarshalVOIDINT 

func CclosureMarshalVOIDINT(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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

func CclosureMarshalVOIDLONG 

func CclosureMarshalVOIDLONG(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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

func CclosureMarshalVOIDOBJECT 

func CclosureMarshalVOIDOBJECT(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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

func CclosureMarshalVOIDPARAM 

func CclosureMarshalVOIDPARAM(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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

func CclosureMarshalVOIDPOINTER 

func CclosureMarshalVOIDPOINTER(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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

func CclosureMarshalVOIDSTRING 

func CclosureMarshalVOIDSTRING(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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

func CclosureMarshalVOIDUCHAR 

func CclosureMarshalVOIDUCHAR(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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

func CclosureMarshalVOIDUINT 

func CclosureMarshalVOIDUINT(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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

func CclosureMarshalVOIDUINTPOINTER 

func CclosureMarshalVOIDUINTPOINTER(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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

func CclosureMarshalVOIDVARIANT 

func CclosureMarshalVOIDVARIANT(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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

func CclosureMarshalVOIDVOID 

func CclosureMarshalVOIDVOID(ClosureVar *Closure, ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar *Value, InvocationHintVar uintptr, MarshalDataVar uintptr)

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

func ClearObject 

func ClearObject(ObjectPtrVar **Object)

Clears a reference to a #GObject.

@object_ptr must not be %NULL.

If the reference is %NULL then this function does nothing. Otherwise, the reference count of the object is decreased and the pointer is set to %NULL.

A macro is also included that allows this function to be used without pointer casts.

func ClearSignalHandler 

func ClearSignalHandler(HandlerIdPtrVar uint32, InstanceVar *Object)

Disconnects a handler from @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_ptr is then set to zero, which is never a valid handler ID value (see g_signal_connect()).

If the handler ID is 0 then this function does nothing.

There is also a macro version of this function so that the code will be inlined.

func ConvertPtr 

func ConvertPtr(a interface{}) *uintptr

func EnumCompleteTypeInfo 

func EnumCompleteTypeInfo(GEnumTypeVar []interface{}, InfoVar *TypeInfo, ConstValuesVar *EnumValue)

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

|[&lt;!-- language="C" --&gt; 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 EnumRegisterStatic 

func EnumRegisterStatic(NameVar string, ConstStaticValuesVar *EnumValue) []interface{}

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 EnumToString 

func EnumToString(GEnumTypeVar []interface{}, ValueVar int) string

Pretty-prints @value in the form of the enum’s name.

This is intended to be used for debugging purposes. The format of the output may change in the future.

func FlagsCompleteTypeInfo 

func FlagsCompleteTypeInfo(GFlagsTypeVar []interface{}, InfoVar *TypeInfo, ConstValuesVar *FlagsValue)

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 FlagsRegisterStatic 

func FlagsRegisterStatic(NameVar string, ConstStaticValuesVar *FlagsValue) []interface{}

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 FlagsToString 

func FlagsToString(FlagsTypeVar []interface{}, ValueVar uint) string

Pretty-prints @value in the form of the flag names separated by ` | ` and sorted. Any extra bits will be shown at the end as a hexadecimal number.

This is intended to be used for debugging purposes. The format of the output may change in the future.

func GtypeGetType 

func GtypeGetType() []interface{}

func IncreaseRef 

func IncreaseRef(a uintptr)

func NewSignalQuery 

func NewSignalQuery(SignalIdVar uint, QueryVar *SignalQuery)

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 NewTypeQuery 

func NewTypeQuery(TypeVar []interface{}, QueryVar *TypeQuery)

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 ObjectCompatControl 

func ObjectCompatControl(WhatVar uint, DataVar uintptr) uint

func ObjectInterfaceInstallProperty 

func ObjectInterfaceInstallProperty(GIfaceVar *TypeInterface, PspecVar *ParamSpec)

Add a property to an interface; this is only useful for interfaces that are added to GObject-derived types. Adding a property to an interface forces all objects classes with that interface to have a compatible property. The compatible property could be a newly created #GParamSpec, but normally g_object_class_override_property() will be used so that the object class only needs to provide an implementation and inherits the property description, default value, bounds, and so forth from the interface property.

This function is meant to be called from the interface's default vtable initialization function (the @class_init member of #GTypeInfo.) It must not be called after after @class_init has been called for any object types implementing this interface.

If @pspec is a floating reference, it will be consumed.

func ObjectInterfaceListProperties 

func ObjectInterfaceListProperties(GIfaceVar *TypeInterface, NPropertiesPVar uint) uintptr

Lists the properties of an interface.Generally, the interface vtable passed in as @g_iface will be the default vtable from g_type_default_interface_ref(), or, if you know the interface has already been loaded, g_type_default_interface_peek().

func ParamSpecIsValidName 

func ParamSpecIsValidName(NameVar string) bool

Validate a property name for a #GParamSpec. This can be useful for dynamically-generated properties which need to be validated at run-time before actually trying to create them.

See [canonical parameter names][canonical-parameter-names] for details of the rules for valid names.

func ParamTypeRegisterStatic 

func ParamTypeRegisterStatic(NameVar string, PspecInfoVar *ParamSpecTypeInfo) []interface{}

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(PspecVar *ParamSpec, SrcValueVar *Value, DestValueVar *Value, StrictValidationVar bool) 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(PspecVar *ParamSpec, ValueVar *Value) bool

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

func ParamValueSetDefault 

func ParamValueSetDefault(PspecVar *ParamSpec, ValueVar *Value)

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

func ParamValueValidate 

func ParamValueValidate(PspecVar *ParamSpec, ValueVar *Value) 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(PspecVar *ParamSpec, Value1Var *Value, Value2Var *Value) 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(NameVar string) []interface{}

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

func SignalAccumulatorFirstWins 

func SignalAccumulatorFirstWins(IhintVar *SignalInvocationHint, ReturnAccuVar *Value, HandlerReturnVar *Value, DummyVar uintptr) 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(IhintVar *SignalInvocationHint, ReturnAccuVar *Value, HandlerReturnVar *Value, DummyVar uintptr) 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(SignalIdVar uint, DetailVar glib.Quark, HookFuncVar *SignalEmissionHook, HookDataVar uintptr, DataDestroyVar *glib.DestroyNotify) uint32

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(InstanceAndParamsVar uintptr, ReturnValueVar *Value)

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 SignalChainFromOverriddenHandler 

func SignalChainFromOverriddenHandler(InstanceVar *TypeInstance, varArgs ...interface{})

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 SignalConnect 

func SignalConnect(a uintptr, b string, c uintptr) uint32

func SignalConnectClosure 

func SignalConnectClosure(InstanceVar *Object, DetailedSignalVar string, ClosureVar *Closure, AfterVar bool) uint32

Connects a closure to a signal for a particular object.

func SignalConnectClosureById 

func SignalConnectClosureById(InstanceVar *Object, SignalIdVar uint, DetailVar glib.Quark, ClosureVar *Closure, AfterVar bool) uint32

Connects a closure to a signal for a particular object.

func SignalConnectData 

func SignalConnectData(InstanceVar *Object, DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr, DestroyDataVar *ClosureNotify, ConnectFlagsVar ConnectFlags) uint32

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(InstanceVar *TypeInstance, DetailedSignalVar string, CHandlerVar *Callback, GobjectVar *Object, ConnectFlagsVar ConnectFlags) uint32

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 SignalEmit 

func SignalEmit(InstanceVar *Object, SignalIdVar uint, DetailVar glib.Quark, varArgs ...interface{})

Emits a signal. Signal emission is done synchronously. The method will only return control after all handlers are called or signal emission was stopped.

Note that g_signal_emit() resets the return value to the default if no handlers are connected, in contrast to g_signal_emitv().

func SignalEmitByName 

func SignalEmitByName(InstanceVar *Object, DetailedSignalVar string, varArgs ...interface{})

Emits a signal. Signal emission is done synchronously. The method will only return control after all handlers are called or signal emission was stopped.

Note that g_signal_emit_by_name() resets the return value to the default if no handlers are connected, in contrast to g_signal_emitv().

func SignalEmitValist 

func SignalEmitValist(InstanceVar *TypeInstance, SignalIdVar uint, DetailVar glib.Quark, VarArgsVar []interface{})

Emits a signal. Signal emission is done synchronously. The method will only return control after all handlers are called or signal emission was stopped.

Note that g_signal_emit_valist() resets the return value to the default if no handlers are connected, in contrast to g_signal_emitv().

func SignalEmitv 

func SignalEmitv(InstanceAndParamsVar uintptr, SignalIdVar uint, DetailVar glib.Quark, ReturnValueVar *Value)

Emits a signal. Signal emission is done synchronously. The method will only return control after all handlers are called or signal emission was stopped.

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 SignalHandlerBlock 

func SignalHandlerBlock(InstanceVar *Object, HandlerIdVar uint32)

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 deactivate 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(InstanceVar *Object, HandlerIdVar uint32)

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(InstanceVar *Object, MaskVar SignalMatchType, SignalIdVar uint, DetailVar glib.Quark, ClosureVar *Closure, FuncVar uintptr, DataVar uintptr) uint32

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(InstanceVar *Object, HandlerIdVar uint32) bool

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

func SignalHandlerUnblock 

func SignalHandlerUnblock(InstanceVar *Object, HandlerIdVar uint32)

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(InstanceVar *Object, MaskVar SignalMatchType, SignalIdVar uint, DetailVar glib.Quark, ClosureVar *Closure, FuncVar uintptr, DataVar uintptr) 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(InstanceVar *Object)

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(InstanceVar *Object, MaskVar SignalMatchType, SignalIdVar uint, DetailVar glib.Quark, ClosureVar *Closure, FuncVar uintptr, DataVar uintptr) 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(InstanceVar *Object, MaskVar SignalMatchType, SignalIdVar uint, DetailVar glib.Quark, ClosureVar *Closure, FuncVar uintptr, DataVar uintptr) 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(InstanceVar *Object, SignalIdVar uint, DetailVar glib.Quark, MayBeBlockedVar bool) bool

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

If @detail is 0 then it will only match handlers that were connected without detail. If @detail is non-zero then it will match handlers connected both without detail and with the given detail. This is consistent with how a signal emitted with @detail would be delivered to those handlers.

Since 2.46 this also checks for a non-default class closure being installed, as this is basically always what you want.

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 SignalIsValidName 

func SignalIsValidName(NameVar string) bool

Validate a signal name. This can be useful for dynamically-generated signals which need to be validated at run-time before actually trying to create them.

See [canonical parameter names][canonical-parameter-names] for details of the rules for valid names. The rules for signal names are the same as those for property names.

func SignalListIds 

func SignalListIds(ItypeVar []interface{}, NIdsVar uint) uintptr

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(NameVar string, ItypeVar []interface{}) 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.

The type class passed as @itype must already have been instantiated (for example, using g_type_class_ref()) for this function to work, as signals are always installed during class initialization.

See g_signal_new() for details on allowed signal names.

func SignalName 

func SignalName(SignalIdVar uint) string

Given the signal's identifier, finds its name.

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

func SignalNew 

func SignalNew(SignalNameVar string, ItypeVar []interface{}, SignalFlagsVar SignalFlags, ClassOffsetVar uint, AccumulatorVar *SignalAccumulator, AccuDataVar uintptr, CMarshallerVar SignalCMarshaller, ReturnTypeVar []interface{}, NParamsVar uint, varArgs ...interface{}) uint

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

A signal name consists of segments consisting of ASCII letters and digits, separated by either the `-` or `_` character. The first character of a signal name must be a letter. Names which violate these rules lead to undefined behaviour. These are the same rules as for property naming (see g_param_spec_internal()).

When registering a signal and looking up a signal, either separator can be used, but they cannot be mixed. Using `-` is considerably more efficient. Using `_` is discouraged.

If 0 is used for @class_offset subclasses cannot override the class handler in their class_init method by doing super_class-&gt;signal_handler = my_signal_handler. Instead they will have to use g_signal_override_class_handler().

If @c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as the marshaller for this signal. In some simple cases, g_signal_new() will use a more optimized c_marshaller and va_marshaller for the signal instead of g_cclosure_marshal_generic().

If @c_marshaller is non-%NULL, you need to also specify a va_marshaller using g_signal_set_va_marshaller() or the generic va_marshaller will be used.

func SignalNewClassHandler 

func SignalNewClassHandler(SignalNameVar string, ItypeVar []interface{}, SignalFlagsVar SignalFlags, ClassHandlerVar *Callback, AccumulatorVar *SignalAccumulator, AccuDataVar uintptr, CMarshallerVar SignalCMarshaller, ReturnTypeVar []interface{}, NParamsVar uint, varArgs ...interface{}) uint

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

This is a variant of g_signal_new() that takes a C callback instead of a class offset for the signal's class handler. This function doesn't need a function pointer exposed in the class structure of an object definition, instead the function pointer is passed directly and can be overridden by derived classes with g_signal_override_class_closure() or g_signal_override_class_handler()and chained to with g_signal_chain_from_overridden() or g_signal_chain_from_overridden_handler().

See g_signal_new() for information about signal names.

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

func SignalNewValist 

func SignalNewValist(SignalNameVar string, ItypeVar []interface{}, SignalFlagsVar SignalFlags, ClassClosureVar *Closure, AccumulatorVar *SignalAccumulator, AccuDataVar uintptr, CMarshallerVar SignalCMarshaller, ReturnTypeVar []interface{}, NParamsVar uint, ArgsVar []interface{}) 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 SignalNewv 

func SignalNewv(SignalNameVar string, ItypeVar []interface{}, SignalFlagsVar SignalFlags, ClassClosureVar *Closure, AccumulatorVar *SignalAccumulator, AccuDataVar uintptr, CMarshallerVar SignalCMarshaller, ReturnTypeVar []interface{}, NParamsVar uint, ParamTypesVar uintptr) 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(SignalIdVar uint, InstanceTypeVar []interface{}, ClassClosureVar *Closure)

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(SignalNameVar string, InstanceTypeVar []interface{}, ClassHandlerVar *Callback)

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(DetailedSignalVar string, ItypeVar []interface{}, SignalIdPVar uint, DetailPVar *glib.Quark, ForceDetailQuarkVar bool) bool

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

func SignalRemoveEmissionHook 

func SignalRemoveEmissionHook(SignalIdVar uint, HookIdVar uint32)

Deletes an emission hook.

func SignalSetVaMarshaller 

func SignalSetVaMarshaller(SignalIdVar uint, InstanceTypeVar []interface{}, VaMarshallerVar SignalCVaMarshaller)

Change the #GSignalCVaMarshaller used for a given signal. This is a specialised form of the marshaller that can often be used for the common case of a single connected signal handler and avoids the overhead of #GValue. Its use is optional.

func SignalStopEmission 

func SignalStopEmission(InstanceVar *Object, SignalIdVar uint, DetailVar glib.Quark)

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(InstanceVar *Object, DetailedSignalVar 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 SourceSetClosure 

func SourceSetClosure(SourceVar *glib.Source, ClosureVar *Closure)

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(SourceVar *glib.Source)

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(ValueVar *Value) 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(CacheDataVar uintptr, CacheFuncVar *TypeClassCacheFunc)

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(ClassTypeVar []interface{}, PrivateSizeVar uint)

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(ClassTypeVar []interface{}, PrivateSizeVar uint) int

func TypeAddInterfaceCheck 

func TypeAddInterfaceCheck(CheckDataVar uintptr, CheckFuncVar *TypeInterfaceCheckFunc)

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(InstanceTypeVar []interface{}, InterfaceTypeVar []interface{}, PluginVar TypePlugin)

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

func TypeAddInterfaceStatic 

func TypeAddInterfaceStatic(InstanceTypeVar []interface{}, InterfaceTypeVar []interface{}, InfoVar *InterfaceInfo)

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

func TypeCheckClassIsA 

func TypeCheckClassIsA(GClassVar *TypeClass, IsATypeVar []interface{}) bool

func TypeCheckInstance 

func TypeCheckInstance(InstanceVar *TypeInstance) bool

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

func TypeCheckInstanceIsA 

func TypeCheckInstanceIsA(InstanceVar *TypeInstance, IfaceTypeVar []interface{}) bool

func TypeCheckInstanceIsFundamentallyA 

func TypeCheckInstanceIsFundamentallyA(InstanceVar *TypeInstance, FundamentalTypeVar []interface{}) bool

func TypeCheckIsValueType 

func TypeCheckIsValueType(TypeVar []interface{}) bool

func TypeCheckValue 

func TypeCheckValue(ValueVar *Value) bool

func TypeCheckValueHolds 

func TypeCheckValueHolds(ValueVar *Value, TypeVar []interface{}) bool

func TypeChildren 

func TypeChildren(TypeVar []interface{}, NChildrenVar uint) uintptr

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

func TypeClassAdjustPrivateOffset 

func TypeClassAdjustPrivateOffset(GClassVar uintptr, PrivateSizeOrOffsetVar int)

func TypeDefaultInterfaceUnref 

func TypeDefaultInterfaceUnref(GIfaceVar *TypeInterface)

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(TypeVar []interface{}) 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(TypeVar []interface{})

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(InstanceVar *TypeInstance)

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(NameVar string) []interface{}

Look up 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(TypeIdVar []interface{}) []interface{}

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

func TypeFundamentalNext 

func TypeFundamentalNext() []interface{}

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 TypeGetInstanceCount 

func TypeGetInstanceCount(TypeVar []interface{}) int

Returns the number of instances allocated of the particular type; this is only available if GLib is built with debugging support and the instance_count debug flag is set (by setting the GOBJECT_DEBUG variable to include instance-count).

func TypeGetQdata 

func TypeGetQdata(TypeVar []interface{}, QuarkVar glib.Quark) uintptr

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

func TypeInit()

This function used to initialise the type system. Since GLib 2.36, the type system is initialised automatically and this function does nothing.

func TypeInitWithDebugFlags 

func TypeInitWithDebugFlags(DebugFlagsVar TypeDebugFlags)

This function used to initialise the type system with debugging flags. Since GLib 2.36, the type system is initialised automatically and this function does nothing.

If you need to enable debugging features, use the GOBJECT_DEBUG environment variable.

func TypeInterfaceAddPrerequisite 

func TypeInterfaceAddPrerequisite(InterfaceTypeVar []interface{}, PrerequisiteTypeVar []interface{})

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 TypeInterfaceInstantiatablePrerequisite 

func TypeInterfaceInstantiatablePrerequisite(InterfaceTypeVar []interface{}) []interface{}

Returns the most specific instantiatable prerequisite of an interface type. If the interface type has no instantiatable prerequisite, %G_TYPE_INVALID is returned.

See g_type_interface_add_prerequisite() for more information about prerequisites.

func TypeInterfacePrerequisites 

func TypeInterfacePrerequisites(InterfaceTypeVar []interface{}, NPrerequisitesVar uint) uintptr

Returns the prerequisites of an interfaces type.

func TypeInterfaces 

func TypeInterfaces(TypeVar []interface{}, NInterfacesVar uint) uintptr

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

func TypeIsA 

func TypeIsA(TypeVar []interface{}, IsATypeVar []interface{}) 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(TypeVar []interface{}) 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(GClassVar *TypeClass) string

func TypeNameFromInstance 

func TypeNameFromInstance(InstanceVar *TypeInstance) string

func TypeNextBase 

func TypeNextBase(LeafTypeVar []interface{}, RootTypeVar []interface{}) []interface{}

Given a @leaf_type and a @root_type which is contained in its ancestry, 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(TypeVar []interface{}) []interface{}

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(TypeVar []interface{}) glib.Quark

Get the corresponding quark of the type IDs name.

func TypeRegisterDynamic 

func TypeRegisterDynamic(ParentTypeVar []interface{}, TypeNameVar string, PluginVar TypePlugin, FlagsVar TypeFlags) []interface{}

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(TypeIdVar []interface{}, TypeNameVar string, InfoVar *TypeInfo, FinfoVar *TypeFundamentalInfo, FlagsVar TypeFlags) []interface{}

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(ParentTypeVar []interface{}, TypeNameVar string, InfoVar *TypeInfo, FlagsVar TypeFlags) []interface{}

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(ParentTypeVar []interface{}, TypeNameVar string, ClassSizeVar uint, ClassInitVar *ClassInitFunc, InstanceSizeVar uint, InstanceInitVar *InstanceInitFunc, FlagsVar TypeFlags) []interface{}

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(CacheDataVar uintptr, CacheFuncVar *TypeClassCacheFunc)

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(CheckDataVar uintptr, CheckFuncVar *TypeInterfaceCheckFunc)

Removes an interface check function added with g_type_add_interface_check().

func TypeSetQdata 

func TypeSetQdata(TypeVar []interface{}, QuarkVar glib.Quark, DataVar uintptr)

Attaches arbitrary data to a type.

func TypeTestFlags 

func TypeTestFlags(TypeVar []interface{}, FlagsVar uint) bool

func ValueRegisterTransformFunc 

func ValueRegisterTransformFunc(SrcTypeVar []interface{}, DestTypeVar []interface{}, TransformFuncVar *ValueTransform)

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(SrcTypeVar []interface{}, DestTypeVar []interface{}) bool

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

func ValueTypeTransformable 

func ValueTypeTransformable(SrcTypeVar []interface{}, DestTypeVar []interface{}) 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 or a transformation function must be registered.

Types

type BaseFinalizeFunc 

type BaseFinalizeFunc func(*TypeClass)

A callback function used by the type system to finalize those portions of a derived types class structure that were setup from the corresponding GBaseInitFunc() function.

Class finalization basically works the inverse way in which class initialization is performed.

See GClassInitFunc() for a discussion of the class initialization process.

type BaseInitFunc 

type BaseInitFunc func(*TypeClass)

A callback function used by the type system to do base initialization of the class structures of derived types.

This function is called as part of the initialization process of all derived classes and should reallocate or reset all dynamic class members copied over from the parent class.

For example, class members (such as strings) that are not sufficiently handled by a plain memory copy of the parent class into the derived class have to be altered. See GClassInitFunc() for a discussion of the class initialization process.

type Binding 

type Binding struct {
	Object
}

#GBinding is the representation of a binding between a property on a #GObject instance (or source) and another property on another #GObject instance (or target).

Whenever the source property changes, the same value is applied to the target property; for instance, the following binding:

|[&lt;!-- language="C" --&gt; 

g_object_bind_property (object1, "property-a",
                        object2, "property-b",
                        G_BINDING_DEFAULT);

]|

will cause the property named "property-b" of @object2 to be updated every time g_object_set() or the specific accessor changes the value of the property "property-a" of @object1.

It is possible to create a bidirectional binding between two properties of two #GObject instances, so that if either property changes, the other is updated as well, for instance:

|[&lt;!-- language="C" --&gt; 

g_object_bind_property (object1, "property-a",
                        object2, "property-b",
                        G_BINDING_BIDIRECTIONAL);

]|

will keep the two properties in sync.

It is also possible to set a custom transformation function (in both directions, in case of a bidirectional binding) to apply a custom transformation from the source value to the target value before applying it; for instance, the following binding:

|[&lt;!-- language="C" --&gt; 

g_object_bind_property_full (adjustment1, "value",
                             adjustment2, "value",
                             G_BINDING_BIDIRECTIONAL,
                             celsius_to_fahrenheit,
                             fahrenheit_to_celsius,
                             NULL, NULL);

]|

will keep the "value" property of the two adjustments in sync; the @celsius_to_fahrenheit function will be called whenever the "value" property of @adjustment1 changes and will transform the current value of the property before applying it to the "value" property of @adjustment2.

Vice versa, the @fahrenheit_to_celsius function will be called whenever the "value" property of @adjustment2 changes, and will transform the current value of the property before applying it to the "value" property of @adjustment1.

Note that #GBinding does not resolve cycles by itself; a cycle like

|[ 

object1:propertyA -&gt; object2:propertyB
object2:propertyB -&gt; object3:propertyC
object3:propertyC -&gt; object1:propertyA

]|

might lead to an infinite loop. The loop, in this particular case, can be avoided if the objects emit the #GObject::notify signal only if the value has effectively been changed. A binding is implemented using the #GObject::notify signal, so it is susceptible to all the various ways of blocking a signal emission, like g_signal_stop_emission() or g_signal_handler_block().

A binding will be severed, and the resources it allocates freed, whenever either one of the #GObject instances it refers to are finalized, or when the #GBinding instance loses its last reference.

Bindings for languages with garbage collection can use g_binding_unbind() to explicitly release a binding between the source and target properties, instead of relying on the last reference on the binding, source, and target instances to drop.

#GBinding is available since GObject 2.26

func BindingNewFromInternalPtr 

func BindingNewFromInternalPtr(ptr uintptr) *Binding

func (*Binding) DupSource 

func (x *Binding) DupSource() *Object

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

A #GBinding can outlive the source #GObject as the binding does not hold a strong reference to the source. If the source is destroyed before the binding then this function will return %NULL.

func (*Binding) DupTarget 

func (x *Binding) DupTarget() *Object

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

A #GBinding can outlive the target #GObject as the binding does not hold a strong reference to the target. If the target is destroyed before the binding then this function will return %NULL.

func (*Binding) GetFlags 

func (x *Binding) GetFlags() BindingFlags

Retrieves the flags passed when constructing the #GBinding.

func (*Binding) GetSource 

func (x *Binding) GetSource() *Object

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

A #GBinding can outlive the source #GObject as the binding does not hold a strong reference to the source. If the source is destroyed before the binding then this function will return %NULL.

Use g_binding_dup_source() if the source or binding are used from different threads as otherwise the pointer returned from this function might become invalid if the source is finalized from another thread in the meantime.

func (*Binding) GetSourceProperty 

func (x *Binding) GetSourceProperty() string

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

func (*Binding) GetTarget 

func (x *Binding) GetTarget() *Object

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

A #GBinding can outlive the target #GObject as the binding does not hold a strong reference to the target. If the target is destroyed before the binding then this function will return %NULL.

Use g_binding_dup_target() if the target or binding are used from different threads as otherwise the pointer returned from this function might become invalid if the target is finalized from another thread in the meantime.

func (*Binding) GetTargetProperty 

func (x *Binding) GetTargetProperty() string

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

func (*Binding) GoPointer 

func (c *Binding) GoPointer() uintptr

func (*Binding) SetGoPointer 

func (c *Binding) SetGoPointer(ptr uintptr)

func (*Binding) Unbind 

func (x *Binding) 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 the binding is still bound; if you want to hold on to the #GBinding instance after calling g_binding_unbind(), you will need to hold a reference to it.

Note however that this function does not take ownership of @binding, it only unrefs the reference that was initially created by g_object_bind_property() and is owned by the binding.

type BindingFlags 

type BindingFlags int

Flags to be passed to g_object_bind_property() or g_object_bind_property_full().

This enumeration can be extended at later date. 

const (

	// The default binding; if the source property
	//   changes, the target property is updated with its value.
	GBindingDefaultValue BindingFlags = 0
	// Bidirectional binding; if either the
	//   property of the source or the property of the target changes,
	//   the other is updated.
	GBindingBidirectionalValue BindingFlags = 1
	// Synchronize the values of the source and
	//   target properties when creating the binding; the direction of
	//   the synchronization is always from the source to the target.
	GBindingSyncCreateValue BindingFlags = 2
	// If the two properties being bound are
	//   booleans, setting one to %TRUE will result in the other being
	//   set to %FALSE and vice versa. This flag will only work for
	//   boolean properties, and cannot be used when passing custom
	//   transformation functions to g_object_bind_property_full().
	GBindingInvertBooleanValue BindingFlags = 4
)

type BindingGroup 

type BindingGroup struct {
	Object
}

The #GBindingGroup can be used to bind multiple properties from an object collectively.

Use the various methods to bind properties from a single source object to multiple destination objects. Properties can be bound bidirectionally and are connected when the source object is set with g_binding_group_set_source().

func BindingGroupNewFromInternalPtr 

func BindingGroupNewFromInternalPtr(ptr uintptr) *BindingGroup

func NewBindingGroup 

func NewBindingGroup() *BindingGroup

Creates a new #GBindingGroup.

func (*BindingGroup) Bind 

func (x *BindingGroup) Bind(SourcePropertyVar string, TargetVar *Object, TargetPropertyVar string, FlagsVar BindingFlags)

Creates a binding between @source_property on the source object and @target_property on @target. Whenever the @source_property is changed the @target_property is updated using the same value. The binding flag %G_BINDING_SYNC_CREATE is automatically specified.

See g_object_bind_property() for more information.

func (*BindingGroup) BindFull 

func (x *BindingGroup) BindFull(SourcePropertyVar string, TargetVar *Object, TargetPropertyVar string, FlagsVar BindingFlags, TransformToVar *BindingTransformFunc, TransformFromVar *BindingTransformFunc, UserDataVar uintptr, UserDataDestroyVar *glib.DestroyNotify)

Creates a binding between @source_property on the source object and @target_property on @target, allowing you to set the transformation functions to be used by the binding. The binding flag %G_BINDING_SYNC_CREATE is automatically specified.

See g_object_bind_property_full() for more information.

func (*BindingGroup) BindWithClosures 

func (x *BindingGroup) BindWithClosures(SourcePropertyVar string, TargetVar *Object, TargetPropertyVar string, FlagsVar BindingFlags, TransformToVar *Closure, TransformFromVar *Closure)

Creates a binding between @source_property on the source object and @target_property on @target, allowing you to set the transformation functions to be used by the binding. The binding flag %G_BINDING_SYNC_CREATE is automatically specified.

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

See g_object_bind_property_with_closures() for more information.

func (*BindingGroup) DupSource 

func (x *BindingGroup) DupSource() *Object

Gets the source object used for binding properties.

func (*BindingGroup) GoPointer 

func (c *BindingGroup) GoPointer() uintptr

func (*BindingGroup) SetGoPointer 

func (c *BindingGroup) SetGoPointer(ptr uintptr)

func (*BindingGroup) SetSource 

func (x *BindingGroup) SetSource(SourceVar *Object)

Sets @source as the source object used for creating property bindings. If there is already a source object all bindings from it will be removed.

Note that all properties that have been bound must exist on @source.

type BindingTransformFunc 

type BindingTransformFunc func(uintptr, *Value, *Value, uintptr) bool

A function to be called to transform @from_value to @to_value.

If this is the @transform_to function of a binding, then @from_value is the @source_property on the @source object, and @to_value is the @target_property on the @target object. If this is the @transform_from function of a %G_BINDING_BIDIRECTIONAL binding, then those roles are reversed.

type BoxedCopyFunc 

type BoxedCopyFunc func(uintptr) uintptr

This function is provided by the user and should produce a copy of the passed in boxed structure.

type BoxedFreeFunc 

type BoxedFreeFunc func(uintptr)

This function is provided by the user and should free the boxed structure passed.

type CClosure 

type CClosure struct {
	Closure uintptr

	Callback uintptr
}

A #GCClosure is a specialization of #GClosure for C function callbacks.

func (*CClosure) GoPointer 

func (x *CClosure) GoPointer() uintptr

type Callback 

type Callback func()

The type used for callback functions in structure definitions and function signatures.

This doesn't mean that all callback functions must take no parameters and return void. The required signature of a callback function is determined by the context in which is used (e.g. the signal to which it is connected).

Use G_CALLBACK() to cast the callback function to a #GCallback.

type ClassFinalizeFunc 

type ClassFinalizeFunc func(*TypeClass, uintptr)

A callback function used by the type system to finalize a class.

This function is rarely needed, as dynamically allocated class resources should be handled by GBaseInitFunc() and GBaseFinalizeFunc().

Also, specification of a GClassFinalizeFunc() in the #GTypeInfo structure of a static type is invalid, because classes of static types will never be finalized (they are artificially kept alive when their reference count drops to zero).

type ClassInitFunc 

type ClassInitFunc func(*TypeClass, uintptr)

A callback function used by the type system to initialize the class of a specific type.

This function should initialize all static class members.

The initialization process of a class involves:

  • Copying common members from the parent class over to the derived class structure.
  • Zero initialization of the remaining members not copied over from the parent class.
  • Invocation of the GBaseInitFunc() initializers of all parent types and the class' type.
  • Invocation of the class' GClassInitFunc() initializer.

Since derived classes are partially initialized through a memory copy of the parent class, the general rule is that GBaseInitFunc() and GBaseFinalizeFunc() should take care of necessary reinitialization and release of those class members that were introduced by the type that specified these GBaseInitFunc()/GBaseFinalizeFunc(). GClassInitFunc() should only care about initializing static class members, while dynamic class members (such as allocated strings or reference counted resources) are better handled by a GBaseInitFunc() for this type, so proper initialization of the dynamic class members is performed for class initialization of derived types as well.

An example may help to correspond the intend of the different class initializers:

|[&lt;!-- language="C" --&gt; 

typedef struct {
  GObjectClass parent_class;
  gint         static_integer;
  gchar       *dynamic_string;
} TypeAClass;

static void type_a_base_class_init (TypeAClass *class) 

{
  class-&gt;dynamic_string = g_strdup ("some string");
}

static void type_a_base_class_finalize (TypeAClass *class) 

{
  g_free (class-&gt;dynamic_string);
}

static void type_a_class_init (TypeAClass *class) 

{
  class-&gt;static_integer = 42;
}

typedef struct {
  TypeAClass   parent_class;
  gfloat       static_float;
  GString     *dynamic_gstring;
} TypeBClass;

static void type_b_base_class_init (TypeBClass *class) 

{
  class-&gt;dynamic_gstring = g_string_new ("some other string");
}

static void type_b_base_class_finalize (TypeBClass *class) 

{
  g_string_free (class-&gt;dynamic_gstring);
}

static void type_b_class_init (TypeBClass *class) 

{
  class-&gt;static_float = 3.14159265358979323846;
}

]|

Initialization of TypeBClass will first cause initialization of TypeAClass (derived classes reference their parent classes, see g_type_class_ref() on this).

Initialization of TypeAClass roughly involves zero-initializing its fields, then calling its GBaseInitFunc() type_a_base_class_init() to allocate its dynamic members (dynamic_string), and finally calling its GClassInitFunc() type_a_class_init() to initialize its static members (static_integer). The first step in the initialization process of TypeBClass is then a plain memory copy of the contents of TypeAClass into TypeBClass and zero-initialization of the remaining fields in TypeBClass. The dynamic members of TypeAClass within TypeBClass now need reinitialization which is performed by calling type_a_base_class_init() with an argument of TypeBClass.

After that, the GBaseInitFunc() of TypeBClass, type_b_base_class_init() is called to allocate the dynamic members of TypeBClass (dynamic_gstring), and finally the GClassInitFunc() of TypeBClass, type_b_class_init(), is called to complete the initialization process with the static members (static_float).

Corresponding finalization counter parts to the GBaseInitFunc() functions have to be provided to release allocated resources at class finalization time.

type Closure 

type Closure struct {
	RefCount uint

	MetaMarshalNouse uint

	NGuards uint

	NFnotifiers uint

	NInotifiers uint

	InInotify uint

	Floating uint

	DerivativeFlag uint

	InMarshal uint

	IsInvalid uint

	Data uintptr

	Notifiers *ClosureNotifyData
}

A #GClosure represents a callback supplied by the programmer.

It will generally comprise a function of some kind and a marshaller used to call it. It is the responsibility of the marshaller to convert the arguments for the invocation from #GValues into a suitable form, perform the callback on the converted arguments, and transform the return value back into a #GValue.

In the case of C programs, a closure usually just holds a pointer to a function and maybe a data argument, and the marshaller converts between #GValue and native C types. The GObject library provides the #GCClosure type for this purpose. Bindings for other languages need marshallers which convert between #GValues and suitable representations in the runtime of the language in order to use functions written in that language as callbacks. Use g_closure_set_marshal() to set the marshaller on such a custom closure implementation.

Within GObject, closures play an important role in the implementation of signals. When a signal is registered, the @c_marshaller argument to g_signal_new() specifies the default C marshaller for any closure which is connected to this signal. GObject provides a number of C marshallers for this purpose, see the g_cclosure_marshal_*() functions. Additional C marshallers can be generated with the [glib-genmarshal][glib-genmarshal] utility. Closures can be explicitly connected to signals with g_signal_connect_closure(), but it usually more convenient to let GObject create a closure automatically by using one of the g_signal_connect_*() functions which take a callback function/user data pair.

Using closures has a number of important advantages over a simple callback function/data pointer combination:

  • Closures allow the callee to get the types of the callback parameters, which means that language bindings don't have to write individual glue for each callback type.

  • The reference counting of #GClosure makes it easy to handle reentrancy right; if a callback is removed while it is being invoked, the closure and its parameters won't be freed until the invocation finishes.

  • g_closure_invalidate() and invalidation notifiers allow callbacks to be automatically removed when the objects they point to go away.

func CclosureNew 

func CclosureNew(CallbackFuncVar *Callback, UserDataVar uintptr, DestroyDataVar *ClosureNotify) *Closure

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

@destroy_data will be called as a finalize notifier on the #GClosure.

func CclosureNewObject 

func CclosureNewObject(CallbackFuncVar *Callback, ObjectVar *Object) *Closure

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(CallbackFuncVar *Callback, ObjectVar *Object) *Closure

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(CallbackFuncVar *Callback, UserDataVar uintptr, DestroyDataVar *ClosureNotify) *Closure

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

@destroy_data will be called as a finalize notifier on the #GClosure.

func NewClosureObject 

func NewClosureObject(SizeofClosureVar uint, ObjectVar *Object) *Closure

A variant of g_closure_new_simple() which stores @object in the @data field of the closure and calls g_object_watch_closure() on @object and the created closure. This function is mainly useful when implementing new types of closures.

func NewClosureSimple 

func NewClosureSimple(SizeofClosureVar uint, DataVar uintptr) *Closure

Allocates a struct of the given size and initializes the initial part as a #GClosure.

This function is mainly useful when implementing new types of closures:

|[&lt;!-- language="C" --&gt; typedef struct _MyClosure MyClosure; struct _MyClosure 

{
  GClosure closure;
  // extra data goes here
};

static void my_closure_finalize (gpointer notify_data, 

GClosure *closure)

{
  MyClosure *my_closure = (MyClosure *)closure;

  // free extra data here
}

MyClosure *my_closure_new (gpointer data) 

{
  GClosure *closure;
  MyClosure *my_closure;

  closure = g_closure_new_simple (sizeof (MyClosure), data);
  my_closure = (MyClosure *) closure;

  // initialize extra data here

  g_closure_add_finalize_notifier (closure, notify_data,
                                   my_closure_finalize);
  return my_closure;
}

]|

func SignalTypeCclosureNew 

func SignalTypeCclosureNew(ItypeVar []interface{}, StructOffsetVar uint) *Closure

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 (*Closure) AddFinalizeNotifier 

func (x *Closure) AddFinalizeNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify)

Registers a finalization notifier which will be called when the reference count of @closure goes down to 0.

Multiple finalization notifiers on a single closure are invoked in unspecified order. If a single call to g_closure_unref() results in the closure being both invalidated and finalized, then the invalidate notifiers will be run before the finalize notifiers.

func (*Closure) AddInvalidateNotifier 

func (x *Closure) AddInvalidateNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify)

Registers an invalidation notifier which will be called when the @closure is invalidated with g_closure_invalidate().

Invalidation notifiers are invoked before finalization notifiers, in an unspecified order.

func (*Closure) AddMarshalGuards 

func (x *Closure) AddMarshalGuards(PreMarshalDataVar uintptr, PreMarshalNotifyVar *ClosureNotify, PostMarshalDataVar uintptr, PostMarshalNotifyVar *ClosureNotify)

Adds a pair of notifiers which get invoked before and after the closure callback, respectively.

This is typically used to protect the extra arguments for the duration of the callback. See g_object_watch_closure() for an example of marshal guards.

func (*Closure) GoPointer 

func (x *Closure) GoPointer() uintptr

func (*Closure) Invalidate 

func (x *Closure) Invalidate()

Sets a flag on the closure to indicate that its calling environment has become invalid, and thus causes any future invocations of g_closure_invoke() on this @closure to be ignored.

Also, invalidation notifiers installed on the closure will be called at this point. Note that unless you are holding a reference to the closure yourself, the invalidation notifiers may unref the closure and cause it to be destroyed, so if you need to access the closure after calling g_closure_invalidate(), make sure that you've previously called g_closure_ref().

Note that g_closure_invalidate() will also be called when the reference count of a closure drops to zero (unless it has already been invalidated before).

func (*Closure) Invoke 

func (x *Closure) Invoke(ReturnValueVar *Value, NParamValuesVar uint, ParamValuesVar uintptr, InvocationHintVar uintptr)

Invokes the closure, i.e. executes the callback represented by the @closure.

func (*Closure) Ref 

func (x *Closure) Ref() *Closure

Increments the reference count on a closure to force it staying alive while the caller holds a pointer to it.

func (*Closure) RemoveFinalizeNotifier 

func (x *Closure) RemoveFinalizeNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify)

Removes a finalization notifier.

Notice that notifiers are automatically removed after they are run.

func (*Closure) RemoveInvalidateNotifier 

func (x *Closure) RemoveInvalidateNotifier(NotifyDataVar uintptr, NotifyFuncVar *ClosureNotify)

Removes an invalidation notifier.

Notice that notifiers are automatically removed after they are run.

func (*Closure) SetMarshal 

func (x *Closure) SetMarshal(MarshalVar *ClosureMarshal)

Sets the marshaller of @closure.

The `marshal_data` of @marshal provides a way for a meta marshaller to provide additional information to the marshaller.

For GObject's C predefined marshallers (the `g_cclosure_marshal_*()` functions), what it provides is a callback function to use instead of @closure-&gt;callback.

See also: g_closure_set_meta_marshal()

func (*Closure) SetMetaMarshal 

func (x *Closure) SetMetaMarshal(MarshalDataVar uintptr, MetaMarshalVar *ClosureMarshal)

Sets the meta marshaller of @closure.

A meta marshaller wraps the @closure's marshal and modifies the way it is called in some fashion. The most common use of this facility is for C callbacks.

The same marshallers (generated by [glib-genmarshal][glib-genmarshal]), are used everywhere, but the way that we get the callback function differs. In most cases we want to use the @closure's callback, but in other cases we want to use some different technique to retrieve the callback function.

For example, class closures for signals (see g_signal_type_cclosure_new()) retrieve the callback function from a fixed offset in the class structure. The meta marshaller retrieves the right callback and passes it to the marshaller as the @marshal_data argument.

func (*Closure) Sink 

func (x *Closure) Sink()

Takes over the initial ownership of a closure.

Each closure is initially created in a "floating" state, which means that the initial reference count is not owned by any caller.

This function checks to see if the object is still floating, and if so, unsets the floating state and decreases the reference count. If the closure is not floating, g_closure_sink() does nothing.

The reason for the existence of the floating state is to prevent cumbersome code sequences like:

|[&lt;!-- language="C" --&gt; closure = g_cclosure_new (cb_func, cb_data); g_source_set_closure (source, closure); g_closure_unref (closure); // GObject doesn't really need this ]|

Because g_source_set_closure() (and similar functions) take ownership of the initial reference count, if it is unowned, we instead can write:

|[&lt;!-- language="C" --&gt; g_source_set_closure (source, g_cclosure_new (cb_func, cb_data)); ]|

Generally, this function is used together with g_closure_ref(). An example of storing a closure for later notification looks like:

|[&lt;!-- language="C" --&gt; static GClosure *notify_closure = NULL; void foo_notify_set_closure (GClosure *closure) 

{
  if (notify_closure)
    g_closure_unref (notify_closure);
  notify_closure = closure;
  if (notify_closure)
    {
      g_closure_ref (notify_closure);
      g_closure_sink (notify_closure);
    }
}

]|

Because g_closure_sink() may decrement the reference count of a closure (if it hasn't been called on @closure yet) just like g_closure_unref(), g_closure_ref() should be called prior to this function.

func (*Closure) Unref 

func (x *Closure) Unref()

Decrements the reference count of a closure after it was previously incremented by the same caller.

If no other callers are using the closure, then the closure will be destroyed and freed.

type ClosureMarshal 

type ClosureMarshal func(*Closure, *Value, uint, uintptr, uintptr, uintptr)

The type used for marshaller functions.

type ClosureNotify 

type ClosureNotify func(uintptr, *Closure)

The type used for the various notification callbacks which can be registered on closures.

type ClosureNotifyData 

type ClosureNotifyData struct {
	Data uintptr

	Notify ClosureNotify
}

func (*ClosureNotifyData) GoPointer 

func (x *ClosureNotifyData) GoPointer() uintptr

type ConnectFlags 

type ConnectFlags int

The connection flags are used to specify the behaviour of a signal's connection. 

const (

	// whether the handler should be called before or after the
	//  default handler of the signal.
	GConnectAfterValue ConnectFlags = 1
	// whether the instance and data should be swapped when
	//  calling the handler; see g_signal_connect_swapped() for an example.
	GConnectSwappedValue ConnectFlags = 2
)

type EnumClass 

type EnumClass struct {
	GTypeClass uintptr

	Minimum int32

	Maximum int32

	NValues uint

	Values *EnumValue
}

The class of an enumeration type holds information about its possible values.

func (*EnumClass) GoPointer 

func (x *EnumClass) GoPointer() uintptr

type EnumValue 

type EnumValue struct {
	Value int32

	ValueName uintptr

	ValueNick uintptr
}

A structure which contains a single enum value, its name, and its nickname.

func EnumGetValue 

func EnumGetValue(EnumClassVar *EnumClass, ValueVar int) *EnumValue

Returns the #GEnumValue for a value.

func EnumGetValueByName 

func EnumGetValueByName(EnumClassVar *EnumClass, NameVar string) *EnumValue

Looks up a #GEnumValue by name.

func EnumGetValueByNick 

func EnumGetValueByNick(EnumClassVar *EnumClass, NickVar string) *EnumValue

Looks up a #GEnumValue by nickname.

func (*EnumValue) GoPointer 

func (x *EnumValue) GoPointer() uintptr

type FlagsClass 

type FlagsClass struct {
	GTypeClass uintptr

	Mask uint

	NValues uint

	Values *FlagsValue
}

The class of a flags type holds information about its possible values.

func (*FlagsClass) GoPointer 

func (x *FlagsClass) GoPointer() uintptr

type FlagsValue 

type FlagsValue struct {
	Value uint

	ValueName uintptr

	ValueNick uintptr
}

A structure which contains a single flags value, its name, and its nickname.

func FlagsGetFirstValue 

func FlagsGetFirstValue(FlagsClassVar *FlagsClass, ValueVar uint) *FlagsValue

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

func FlagsGetValueByName 

func FlagsGetValueByName(FlagsClassVar *FlagsClass, NameVar string) *FlagsValue

Looks up a #GFlagsValue by name.

func FlagsGetValueByNick 

func FlagsGetValueByNick(FlagsClassVar *FlagsClass, NickVar string) *FlagsValue

Looks up a #GFlagsValue by nickname.

func (*FlagsValue) GoPointer 

func (x *FlagsValue) GoPointer() uintptr

type InitiallyUnowned 

type InitiallyUnowned struct {
	Object
}

A type for objects that have an initially floating reference.

All the fields in the `GInitiallyUnowned` structure are private to the implementation and should never be accessed directly.

func InitiallyUnownedNewFromInternalPtr 

func InitiallyUnownedNewFromInternalPtr(ptr uintptr) *InitiallyUnowned

func (*InitiallyUnowned) GoPointer 

func (c *InitiallyUnowned) GoPointer() uintptr

func (*InitiallyUnowned) SetGoPointer 

func (c *InitiallyUnowned) SetGoPointer(ptr uintptr)

type InitiallyUnownedClass 

type InitiallyUnownedClass struct {
	GTypeClass uintptr

	ConstructProperties *glib.SList

	Flags uint

	Pdummy uintptr
}

The class structure for the GInitiallyUnowned type.

func (*InitiallyUnownedClass) GoPointer 

func (x *InitiallyUnownedClass) GoPointer() uintptr

type InstanceInitFunc 

type InstanceInitFunc func(*TypeInstance, *TypeClass)

A callback function used by the type system to initialize a new instance of a type.

This function initializes all instance members and allocates any resources required by it.

Initialization of a derived instance involves calling all its parent types instance initializers, so the class member of the instance is altered during its initialization to always point to the class that belongs to the type the current initializer was introduced for.

The extended members of @instance are guaranteed to have been filled with zeros before this function is called.

type InterfaceFinalizeFunc 

type InterfaceFinalizeFunc func(*TypeInterface, uintptr)

A callback function used by the type system to finalize an interface.

This function should destroy any internal data and release any resources allocated by the corresponding GInterfaceInitFunc() function.

type InterfaceInfo 

type InterfaceInfo struct {
	InterfaceInit InterfaceInitFunc

	InterfaceFinalize InterfaceFinalizeFunc

	InterfaceData uintptr
}

A structure that provides information to the type system which is used specifically for managing interface types.

func (*InterfaceInfo) GoPointer 

func (x *InterfaceInfo) GoPointer() uintptr

type InterfaceInitFunc 

type InterfaceInitFunc func(*TypeInterface, uintptr)

A callback function used by the type system to initialize a new interface.

This function should initialize all internal data and* allocate any resources required by the interface.

The members of @iface_data are guaranteed to have been filled with zeros before this function is called.

type Object 

type Object struct {
	Ptr uintptr
}

The base object type.

All the fields in the `GObject` structure are private to the implementation and should never be accessed directly.

Since GLib 2.72, all #GObjects are guaranteed to be aligned to at least the alignment of the largest basic GLib type (typically this is #guint64 or #gdouble). If you need larger alignment for an element in a #GObject, you should allocate it on the heap (aligned), or arrange for your #GObject to be appropriately padded. This guarantee applies to the #GObject (or derived) struct, the #GObjectClass (or derived) struct, and any private data allocated by G_ADD_PRIVATE().

func NewObject 

func NewObject(ObjectTypeVar []interface{}, FirstPropertyNameVar string, varArgs ...interface{}) *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. Any private data for the object is guaranteed to be initialized with zeros, as per g_type_create_instance().

Note that in C, small integer types in variable argument lists are promoted up to #gint or #guint as appropriate, and read back accordingly. #gint is 32 bits on every platform on which GLib is currently supported. This means that you can use C expressions of type #gint with g_object_new() and properties of type #gint or #guint or smaller. Specifically, you can use integer literals with these property types.

When using property types of #gint64 or #guint64, you must ensure that the value that you provide is 64 bit. This means that you should use a cast or make use of the %G_GINT64_CONSTANT or %G_GUINT64_CONSTANT macros.

Similarly, #gfloat is promoted to #gdouble, so you must ensure that the value you provide is a #gdouble, even for a property of type #gfloat.

Since GLib 2.72, all #GObjects are guaranteed to be aligned to at least the alignment of the largest basic GLib type (typically this is #guint64 or #gdouble). If you need larger alignment for an element in a #GObject, you should allocate it on the heap (aligned), or arrange for your #GObject to be appropriately padded.

func NewObjectValist 

func NewObjectValist(ObjectTypeVar []interface{}, FirstPropertyNameVar string, VarArgsVar []interface{}) *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.

func NewObjectWithProperties 

func NewObjectWithProperties(ObjectTypeVar []interface{}, NPropertiesVar uint, NamesVar []string, ValuesVar uintptr) *Object

Creates a new instance of a #GObject subtype and sets its properties using the provided arrays. Both arrays must have exactly @n_properties elements, and the names and values correspond by index.

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

func NewObjectv 

func NewObjectv(ObjectTypeVar []interface{}, NParametersVar uint, ParametersVar uintptr) *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.

func ObjectNewFromInternalPtr 

func ObjectNewFromInternalPtr(ptr uintptr) *Object

func (*Object) AddToggleRef 

func (x *Object) AddToggleRef(NotifyVar *ToggleNotify, DataVar uintptr)

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 (*Object) AddWeakPointer 

func (x *Object) AddWeakPointer(WeakPointerLocationVar uintptr)

Adds a weak reference from weak_pointer to @object to indicate that the pointer located at @weak_pointer_location is only valid during the lifetime of @object. When the @object is finalized, @weak_pointer will be set to %NULL.

Note that as with g_object_weak_ref(), 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 (*Object) BindProperty 

func (x *Object) BindProperty(SourcePropertyVar string, TargetVar *Object, TargetPropertyVar string, FlagsVar BindingFlags) *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:

|[&lt;!-- language="C" --&gt; 

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.

Removing the binding by calling g_object_unref() on it must only be done if the binding, @source and @target are only used from a single thread and it is clear that both @source and @target outlive the binding. Especially it is not safe to rely on this if the binding, @source or @target can be finalized from different threads. Keep another reference to the binding and use g_binding_unbind() instead to be on the safe side.

A #GObject can have multiple bindings.

func (*Object) BindPropertyFull 

func (x *Object) BindPropertyFull(SourcePropertyVar string, TargetVar *Object, TargetPropertyVar string, FlagsVar BindingFlags, TransformToVar *BindingTransformFunc, TransformFromVar *BindingTransformFunc, UserDataVar uintptr, NotifyVar *glib.DestroyNotify) *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. This will release the reference that is being held on the #GBinding instance; if you want to hold on to the #GBinding instance, you will need to hold a reference to it.

To remove the binding, call g_binding_unbind().

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 (*Object) BindPropertyWithClosures 

func (x *Object) BindPropertyWithClosures(SourcePropertyVar string, TargetVar *Object, TargetPropertyVar string, FlagsVar BindingFlags, TransformToVar *Closure, TransformFromVar *Closure) *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 (Object) Cast 

func (o Object) Cast(v Ptr)

func (*Object) Connect 

func (x *Object) Connect(SignalSpecVar string, varArgs ...interface{}) *Object

A convenience function to connect multiple signals at once.

The signal specs expected by this function have the form "modifier::signal_name", where modifier can be one of the following: - signal: equivalent to g_signal_connect_data (..., NULL, 0) - object-signal, object_signal: equivalent to g_signal_connect_object (..., 0) - swapped-signal, swapped_signal: equivalent to g_signal_connect_data (..., NULL, G_CONNECT_SWAPPED) - swapped_object_signal, swapped-object-signal: equivalent to g_signal_connect_object (..., G_CONNECT_SWAPPED) - signal_after, signal-after: equivalent to g_signal_connect_data (..., NULL, G_CONNECT_AFTER) - object_signal_after, object-signal-after: equivalent to g_signal_connect_object (..., G_CONNECT_AFTER) - swapped_signal_after, swapped-signal-after: equivalent to g_signal_connect_data (..., NULL, G_CONNECT_SWAPPED | G_CONNECT_AFTER) - swapped_object_signal_after, swapped-object-signal-after: equivalent to g_signal_connect_object (..., G_CONNECT_SWAPPED | G_CONNECT_AFTER)

|[&lt;!-- language="C" --&gt; 

  menu-&gt;toplevel = g_object_connect (g_object_new (GTK_TYPE_WINDOW,
						   "type", GTK_WINDOW_POPUP,
						   "child", menu,
						   NULL),
				     "signal::event", gtk_menu_window_event, menu,
				     "signal::size_request", gtk_menu_window_size_request, menu,
				     "signal::destroy", gtk_widget_destroyed, &amp;menu-&gt;toplevel,
				     NULL);

]|

func (*Object) ConnectNotify 

func (x *Object) ConnectNotify(cb *func(Object, uintptr)) uint32

The notify signal is emitted on an object when one of its properties has its value set through g_object_set_property(), g_object_set(), et al.

Note that getting this signal doesn’t itself guarantee that the value of the property has actually changed. When it is emitted is determined by the derived GObject class. If the implementor did not create the property with %G_PARAM_EXPLICIT_NOTIFY, then any call to g_object_set_property() results in ::notify being emitted, even if the new value is the same as the old. If they did pass %G_PARAM_EXPLICIT_NOTIFY, then this signal is emitted only when they explicitly call g_object_notify() or g_object_notify_by_pspec(), and common practice is to do that only when the value has actually changed.

This signal is typically used to obtain change notification for a single property, by specifying the property name as a detail in the g_signal_connect() call, like this:

|[&lt;!-- language="C" --&gt; g_signal_connect (text_view-&gt;buffer, "notify::paste-target-list", 

G_CALLBACK (gtk_text_view_target_list_notify),
text_view)

]|

It is important to note that you must use [canonical parameter names][canonical-parameter-names] as detail strings for the notify signal.

func (Object) ConnectSignal 

func (o Object) ConnectSignal(signal string, cb *func()) uint32

func (*Object) Disconnect 

func (x *Object) Disconnect(SignalSpecVar string, varArgs ...interface{})

A convenience function to disconnect multiple signals at once.

The signal specs expected by this function have the form "any_signal", which means to disconnect any signal with matching callback and data, or "any_signal::signal_name", which only disconnects the signal named "signal_name".

func (Object) DisconnectSignal 

func (o Object) DisconnectSignal(handler uint32)

func (*Object) DupData 

func (x *Object) DupData(KeyVar string, DupFuncVar *glib.DuplicateFunc, UserDataVar uintptr) uintptr

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 (*Object) DupQdata 

func (x *Object) DupQdata(QuarkVar glib.Quark, DupFuncVar *glib.DuplicateFunc, UserDataVar uintptr) uintptr

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 (*Object) ForceFloating 

func (x *Object) 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 (*Object) FreezeNotify 

func (x *Object) 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 (*Object) Get 

func (x *Object) Get(FirstPropertyNameVar string, varArgs ...interface{})

Gets properties of an object.

In general, a copy is made of the property contents and the caller is responsible for freeing the memory in the appropriate manner for the type, for instance by calling g_free() or g_object_unref().

Here is an example of using g_object_get() to get the contents of three properties: an integer, a string and an object: |[&lt;!-- language="C" --&gt; 

gint intval;
guint64 uint64val;
gchar *strval;
GObject *objval;

g_object_get (my_object,
              "int-property", &amp;intval,
              "uint64-property", &amp;uint64val,
              "str-property", &amp;strval,
              "obj-property", &amp;objval,
              NULL);

// Do something with intval, uint64val, strval, objval

g_free (strval);
g_object_unref (objval);

]|

func (*Object) GetData 

func (x *Object) GetData(KeyVar string) uintptr

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

func (*Object) GetProperty 

func (x *Object) GetProperty(PropertyNameVar string, ValueVar *Value)

Gets a property of an object.

The @value can be:

  • an empty #GValue initialized by %G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
  • a #GValue initialized with the expected type of the property
  • a #GValue initialized with a type to which the expected type of the property can be transformed

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 (*Object) GetQdata 

func (x *Object) GetQdata(QuarkVar glib.Quark) uintptr

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

func (*Object) GetValist 

func (x *Object) GetValist(FirstPropertyNameVar string, VarArgsVar []interface{})

Gets properties of an object.

In general, a copy is made of the property contents and the caller is responsible for freeing the memory in the appropriate manner for the type, for instance by calling g_free() or g_object_unref().

See g_object_get().

func (*Object) Getv 

func (x *Object) Getv(NPropertiesVar uint, NamesVar uintptr, ValuesVar uintptr)

Gets @n_properties properties for an @object. Obtained properties will be set to @values. All properties must be valid. Warnings will be emitted and undefined behaviour may result if invalid properties are passed in.

func (*Object) GoPointer 

func (c *Object) GoPointer() uintptr

func (*Object) IsFloating 

func (x *Object) IsFloating() bool

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

func (*Object) Notify 

func (x *Object) Notify(PropertyNameVar 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 (*Object) NotifyByPspec 

func (x *Object) NotifyByPspec(PspecVar *ParamSpec)

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

|[&lt;!-- language="C" --&gt; 

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:

|[&lt;!-- language="C" --&gt; 

g_object_notify_by_pspec (self, properties[PROP_FOO]);

]|

func (*Object) Ref 

func (x *Object) Ref() *Object

Increases the reference count of @object.

Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type of @object will be propagated to the return type (using the GCC typeof() extension), so any casting the caller needs to do on the return type must be explicit.

func (*Object) RefSink 

func (x *Object) RefSink() *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.

Since GLib 2.56, the type of @object will be propagated to the return type under the same conditions as for g_object_ref().

func (*Object) RemoveToggleRef 

func (x *Object) RemoveToggleRef(NotifyVar *ToggleNotify, DataVar uintptr)

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

func (*Object) RemoveWeakPointer 

func (x *Object) RemoveWeakPointer(WeakPointerLocationVar uintptr)

Removes a weak reference from @object that was previously added using g_object_add_weak_pointer(). The @weak_pointer_location has to match the one used with g_object_add_weak_pointer().

func (*Object) ReplaceData 

func (x *Object) ReplaceData(KeyVar string, OldvalVar uintptr, NewvalVar uintptr, DestroyVar *glib.DestroyNotify, OldDestroyVar *glib.DestroyNotify) 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). It’s up to the caller to free this as needed, which may or may not include using @old_destroy as sometimes replacement should not destroy the object in the normal way.

See g_object_set_data() for guidance on using a small, bounded set of values for @key.

func (*Object) ReplaceQdata 

func (x *Object) ReplaceQdata(QuarkVar glib.Quark, OldvalVar uintptr, NewvalVar uintptr, DestroyVar *glib.DestroyNotify, OldDestroyVar *glib.DestroyNotify) 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). It’s up to the caller to free this as needed, which may or may not include using @old_destroy as sometimes replacement should not destroy the object in the normal way.

func (*Object) RunDispose 

func (x *Object) RunDispose()

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

This function should only be called from object system implementations.

func (*Object) Set 

func (x *Object) Set(FirstPropertyNameVar string, varArgs ...interface{})

Sets properties on an object.

The same caveats about passing integer literals as varargs apply as with g_object_new(). In particular, any integer literals set as the values for properties of type #gint64 or #guint64 must be 64 bits wide, using the %G_GINT64_CONSTANT or %G_GUINT64_CONSTANT macros.

Note that the "notify" signals are queued and only emitted (in reverse order) after all properties have been set. See g_object_freeze_notify().

func (*Object) SetData 

func (x *Object) SetData(KeyVar string, DataVar uintptr)

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.

Internally, the @key is converted to a #GQuark using g_quark_from_string(). This means a copy of @key is kept permanently (even after @object has been finalized) — so it is recommended to only use a small, bounded set of values for @key in your program, to avoid the #GQuark storage growing unbounded.

func (*Object) SetDataFull 

func (x *Object) SetDataFull(KeyVar string, DataVar uintptr, DestroyVar *glib.DestroyNotify)

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 (*Object) SetGoPointer 

func (c *Object) SetGoPointer(ptr uintptr)

func (*Object) SetProperty 

func (x *Object) SetProperty(PropertyNameVar string, ValueVar *Value)

Sets a property on an object.

func (*Object) SetQdata 

func (x *Object) SetQdata(QuarkVar glib.Quark, DataVar uintptr)

This sets an opaque, named pointer on an object. 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 @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 (*Object) SetQdataFull 

func (x *Object) SetQdataFull(QuarkVar glib.Quark, DataVar uintptr, DestroyVar *glib.DestroyNotify)

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 (*Object) SetValist 

func (x *Object) SetValist(FirstPropertyNameVar string, VarArgsVar []interface{})

Sets properties on an object.

func (*Object) Setv 

func (x *Object) Setv(NPropertiesVar uint, NamesVar uintptr, ValuesVar uintptr)

Sets @n_properties properties for an @object. Properties to be set will be taken from @values. All properties must be valid. Warnings will be emitted and undefined behaviour may result if invalid properties are passed in.

func (*Object) StealData 

func (x *Object) StealData(KeyVar string) uintptr

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

func (*Object) StealQdata 

func (x *Object) StealQdata(QuarkVar glib.Quark) uintptr

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: |[&lt;!-- language="C" --&gt; 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");
  // retrieve 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-&gt;next)
    g_free (node-&gt;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 (*Object) TakeRef 

func (x *Object) TakeRef() *Object

If @object is floating, sink it. Otherwise, do nothing.

In other words, this function will convert a floating reference (if present) into a full reference.

Typically you want to use g_object_ref_sink() in order to automatically do the correct thing with respect to floating or non-floating references, but there is one specific scenario where this function is helpful.

The situation where this function is helpful is when creating an API that allows the user to provide a callback function that returns a GObject. We certainly want to allow the user the flexibility to return a non-floating reference from this callback (for the case where the object that is being returned already exists).

At the same time, the API style of some popular GObject-based libraries (such as Gtk) make it likely that for newly-created GObject instances, the user can be saved some typing if they are allowed to return a floating reference.

Using this function on the return value of the user's callback allows the user to do whichever is more convenient for them. The caller will alway receives exactly one full reference to the value: either the one that was returned in the first place, or a floating reference that has been converted to a full reference.

This function has an odd interaction when combined with g_object_ref_sink() running at the same time in another thread on the same #GObject instance. If g_object_ref_sink() runs first then the result will be that the floating reference is converted to a hard reference. If g_object_take_ref() runs first then the result will be that the floating reference is converted to a hard reference and an additional reference on top of that one is added. It is best to avoid this situation.

func (*Object) ThawNotify 

func (x *Object) 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 (*Object) Unref 

func (x *Object) Unref()

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

If the pointer to the #GObject may be reused in future (for example, if it is an instance variable of another object), it is recommended to clear the pointer to %NULL rather than retain a dangling pointer to a potentially invalid #GObject instance. Use g_clear_object() for this.

func (*Object) WatchClosure 

func (x *Object) WatchClosure(ClosureVar *Closure)

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 (*Object) WeakRef 

func (x *Object) WeakRef(NotifyVar *WeakNotify, DataVar uintptr)

Adds a weak reference callback to an object. Weak references are used for notification when an object is disposed. 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 (*Object) WeakUnref 

func (x *Object) WeakUnref(NotifyVar *WeakNotify, DataVar uintptr)

Removes a weak reference callback to an object.

type ObjectClass 

type ObjectClass struct {
	GTypeClass uintptr

	ConstructProperties *glib.SList

	Flags uint

	Pdummy uintptr
}

The class structure for the GObject type.

|[&lt;!-- language="C" --&gt; // Example of implementing a singleton using a constructor. static MySingleton *the_singleton = NULL;

static GObject* my_singleton_constructor (GType type, 

guint                  n_construct_params,
GObjectConstructParam *construct_params)

{
  GObject *object;

  if (!the_singleton)
    {
      object = G_OBJECT_CLASS (parent_class)-&gt;constructor (type,
                                                           n_construct_params,
                                                           construct_params);
      the_singleton = MY_SINGLETON (object);
    }
  else
    object = g_object_ref (G_OBJECT (the_singleton));

  return object;
}

]|

func (*ObjectClass) FindProperty 

func (x *ObjectClass) FindProperty(PropertyNameVar string) *ParamSpec

Looks up the #GParamSpec for a property of a class.

func (*ObjectClass) GoPointer 

func (x *ObjectClass) GoPointer() uintptr

func (*ObjectClass) InstallProperties 

func (x *ObjectClass) InstallProperties(NPspecsVar uint, PspecsVar uintptr)

Installs new properties from an array of #GParamSpecs.

All properties should be installed during the class initializer. It is possible to install properties after that, but doing so is not recommend, and specifically, is not guaranteed to be thread-safe vs. use of properties on the same type on other threads.

The property id of each property is the index of each #GParamSpec in the @pspecs array.

The property id of 0 is treated specially by #GObject and it should not be used to store a #GParamSpec.

This function should be used if you plan to use a static array of #GParamSpecs and g_object_notify_by_pspec(). For instance, this class initialization:

|[&lt;!-- language="C" --&gt; 

enum {
  PROP_0, PROP_FOO, PROP_BAR, N_PROPERTIES
};

static GParamSpec *obj_properties[N_PROPERTIES] = { NULL, };

static void my_object_class_init (MyObjectClass *klass) 

{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  obj_properties[PROP_FOO] =
    g_param_spec_int ("foo", "Foo", "Foo",
                      -1, G_MAXINT,
                      0,
                      G_PARAM_READWRITE);

  obj_properties[PROP_BAR] =
    g_param_spec_string ("bar", "Bar", "Bar",
                         NULL,
                         G_PARAM_READWRITE);

  gobject_class-&gt;set_property = my_object_set_property;
  gobject_class-&gt;get_property = my_object_get_property;
  g_object_class_install_properties (gobject_class,
                                     N_PROPERTIES,
                                     obj_properties);
}

]|

allows calling g_object_notify_by_pspec() to notify of property changes:

|[&lt;!-- language="C" --&gt; void my_object_set_foo (MyObject *self, gint foo) 

{
  if (self-&gt;foo != foo)
    {
      self-&gt;foo = foo;
      g_object_notify_by_pspec (G_OBJECT (self), obj_properties[PROP_FOO]);
    }
 }

]|

func (*ObjectClass) InstallProperty 

func (x *ObjectClass) InstallProperty(PropertyIdVar uint, PspecVar *ParamSpec)

Installs a new property.

All properties should be installed during the class initializer. It is possible to install properties after that, but doing so is not recommend, and specifically, is not guaranteed to be thread-safe vs. use of properties on the same type on other threads.

Note that it is possible to redefine a property in a derived class, by installing a property with the same name. This can be useful at times, e.g. to change the range of allowed values or the default value.

func (*ObjectClass) ListProperties 

func (x *ObjectClass) ListProperties(NPropertiesVar uint) uintptr

Get an array of #GParamSpec* for all properties of a class.

func (*ObjectClass) OverrideProperty 

func (x *ObjectClass) OverrideProperty(PropertyIdVar uint, NameVar string)

Registers @property_id as referring to a property with the name @name in a parent class or in an interface implemented by @oclass. This allows this class to "override" a property implementation in a parent class or to provide the implementation of a property from an interface.

Internally, overriding is implemented by creating a property of type #GParamSpecOverride; generally operations that query the properties of the object class, such as g_object_class_find_property() or g_object_class_list_properties() will return the overridden property. However, in one case, the @construct_properties argument of the @constructor virtual function, the #GParamSpecOverride is passed instead, so that the @param_id field of the #GParamSpec will be correct. For virtually all uses, this makes no difference. If you need to get the overridden property, you can call g_param_spec_get_redirect_target().

type ObjectConstructParam 

type ObjectConstructParam struct {
	Pspec *ParamSpec

	Value *Value
}

The GObjectConstructParam struct is an auxiliary structure used to hand #GParamSpec/#GValue pairs to the @constructor of a #GObjectClass.

func (*ObjectConstructParam) GoPointer 

func (x *ObjectConstructParam) GoPointer() uintptr

type ObjectFinalizeFunc 

type ObjectFinalizeFunc func(uintptr)

The type of the @finalize function of #GObjectClass.

type ObjectGetPropertyFunc 

type ObjectGetPropertyFunc func(uintptr, uint, *Value, uintptr)

The type of the @get_property function of #GObjectClass.

type ObjectSetPropertyFunc 

type ObjectSetPropertyFunc func(uintptr, uint, *Value, uintptr)

The type of the @set_property function of #GObjectClass.

type ParamFlags 

type ParamFlags int

Through the #GParamFlags flag values, certain aspects of parameters can be configured.

See also: %G_PARAM_STATIC_STRINGS 

const (

	// the parameter is readable
	GParamReadableValue ParamFlags = 1
	// the parameter is writable
	GParamWritableValue ParamFlags = 2
	// alias for %G_PARAM_READABLE | %G_PARAM_WRITABLE
	GParamReadwriteValue ParamFlags = 3
	// the parameter will be set upon object construction
	GParamConstructValue ParamFlags = 4
	// the parameter can only be set upon object construction
	GParamConstructOnlyValue ParamFlags = 8
	// upon parameter conversion (see g_param_value_convert())
	//  strict validation is not required
	GParamLaxValidationValue ParamFlags = 16
	// the string used as name when constructing the
	//  parameter is guaranteed to remain valid and
	//  unmodified for the lifetime of the parameter.
	//  Since 2.8
	GParamStaticNameValue ParamFlags = 32
	// internal
	GParamPrivateValue ParamFlags = 32
	// the string used as nick when constructing the
	//  parameter is guaranteed to remain valid and
	//  unmmodified for the lifetime of the parameter.
	//  Since 2.8
	GParamStaticNickValue ParamFlags = 64
	// the string used as blurb when constructing the
	//  parameter is guaranteed to remain valid and
	//  unmodified for the lifetime of the parameter.
	//  Since 2.8
	GParamStaticBlurbValue ParamFlags = 128
	// calls to g_object_set_property() for this
	//   property will not automatically result in a "notify" signal being
	//   emitted: the implementation must call g_object_notify() themselves
	//   in case the property actually changes.  Since: 2.42.
	GParamExplicitNotifyValue ParamFlags = 1073741824
	// the parameter is deprecated and will be removed
	//  in a future version. A warning will be generated if it is used
	//  while running with G_ENABLE_DIAGNOSTIC=1.
	//  Since 2.26
	GParamDeprecatedValue ParamFlags = 2147483648
)

type ParamSpec 

type ParamSpec struct {
	Ptr uintptr
}

#GParamSpec is an object structure that encapsulates the metadata required to specify parameters, such as e.g. #GObject properties.

## Parameter names # {#canonical-parameter-names}

A property name consists of one or more segments consisting of ASCII letters and digits, separated by either the `-` or `_` character. The first character of a property name must be a letter. These are the same rules as for signal naming (see g_signal_new()).

When creating and looking up a #GParamSpec, either separator can be used, but they cannot be mixed. Using `-` is considerably more efficient, and is the ‘canonical form’. Using `_` is discouraged.

func NewParamSpecBoolean 

func NewParamSpecBoolean(NameVar string, NickVar string, BlurbVar string, DefaultValueVar bool, FlagsVar ParamFlags) *ParamSpec

Creates a new #GParamSpecBoolean instance specifying a %G_TYPE_BOOLEAN property. In many cases, it may be more appropriate to use an enum with g_param_spec_enum(), both to improve code clarity by using explicitly named values, and to allow for more values to be added in future without breaking API.

See g_param_spec_internal() for details on property names.

func NewParamSpecBoxed 

func NewParamSpecBoxed(NameVar string, NickVar string, BlurbVar string, BoxedTypeVar []interface{}, FlagsVar ParamFlags) *ParamSpec

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

See g_param_spec_internal() for details on property names.

func NewParamSpecChar 

func NewParamSpecChar(NameVar string, NickVar string, BlurbVar string, MinimumVar int8, MaximumVar int8, DefaultValueVar int8, FlagsVar ParamFlags) *ParamSpec

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

func NewParamSpecDouble 

func NewParamSpecDouble(NameVar string, NickVar string, BlurbVar string, MinimumVar float64, MaximumVar float64, DefaultValueVar float64, FlagsVar ParamFlags) *ParamSpec

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

See g_param_spec_internal() for details on property names.

func NewParamSpecEnum 

func NewParamSpecEnum(NameVar string, NickVar string, BlurbVar string, EnumTypeVar []interface{}, DefaultValueVar int, FlagsVar ParamFlags) *ParamSpec

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

See g_param_spec_internal() for details on property names.

func NewParamSpecFlags 

func NewParamSpecFlags(NameVar string, NickVar string, BlurbVar string, FlagsTypeVar []interface{}, DefaultValueVar uint, FlagsVar ParamFlags) *ParamSpec

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

See g_param_spec_internal() for details on property names.

func NewParamSpecFloat 

func NewParamSpecFloat(NameVar string, NickVar string, BlurbVar string, MinimumVar float32, MaximumVar float32, DefaultValueVar float32, FlagsVar ParamFlags) *ParamSpec

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

See g_param_spec_internal() for details on property names.

func NewParamSpecInt 

func NewParamSpecInt(NameVar string, NickVar string, BlurbVar string, MinimumVar int, MaximumVar int, DefaultValueVar int, FlagsVar ParamFlags) *ParamSpec

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

See g_param_spec_internal() for details on property names.

func NewParamSpecInt64 

func NewParamSpecInt64(NameVar string, NickVar string, BlurbVar string, MinimumVar int64, MaximumVar int64, DefaultValueVar int64, FlagsVar ParamFlags) *ParamSpec

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

See g_param_spec_internal() for details on property names.

func NewParamSpecLong 

func NewParamSpecLong(NameVar string, NickVar string, BlurbVar string, MinimumVar int32, MaximumVar int32, DefaultValueVar int32, FlagsVar ParamFlags) *ParamSpec

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

See g_param_spec_internal() for details on property names.

func NewParamSpecObject 

func NewParamSpecObject(NameVar string, NickVar string, BlurbVar string, ObjectTypeVar []interface{}, FlagsVar ParamFlags) *ParamSpec

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

See g_param_spec_internal() for details on property names.

func NewParamSpecOverride 

func NewParamSpecOverride(NameVar string, OverriddenVar *ParamSpec) *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 NewParamSpecParam 

func NewParamSpecParam(NameVar string, NickVar string, BlurbVar string, ParamTypeVar []interface{}, FlagsVar ParamFlags) *ParamSpec

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

See g_param_spec_internal() for details on property names.

func NewParamSpecPointer 

func NewParamSpecPointer(NameVar string, NickVar string, BlurbVar string, FlagsVar ParamFlags) *ParamSpec

Creates a new #GParamSpecPointer instance specifying a pointer property. Where possible, it is better to use g_param_spec_object() or g_param_spec_boxed() to expose memory management information.

See g_param_spec_internal() for details on property names.

func NewParamSpecString 

func NewParamSpecString(NameVar string, NickVar string, BlurbVar string, DefaultValueVar string, FlagsVar ParamFlags) *ParamSpec

Creates a new #GParamSpecString instance.

See g_param_spec_internal() for details on property names.

func NewParamSpecUnichar 

func NewParamSpecUnichar(NameVar string, NickVar string, BlurbVar string, DefaultValueVar uint32, FlagsVar ParamFlags) *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 NewParamSpecValueArray 

func NewParamSpecValueArray(NameVar string, NickVar string, BlurbVar string, ElementSpecVar *ParamSpec, FlagsVar ParamFlags) *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 NewParamSpecVariant 

func NewParamSpecVariant(NameVar string, NickVar string, BlurbVar string, TypeVar *glib.VariantType, DefaultValueVar *glib.Variant, FlagsVar ParamFlags) *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 ObjectInterfaceFindProperty 

func ObjectInterfaceFindProperty(GIfaceVar *TypeInterface, PropertyNameVar string) *ParamSpec

Find the #GParamSpec with the given name for an interface. Generally, the interface vtable passed in as @g_iface will be the default vtable from g_type_default_interface_ref(), or, if you know the interface has already been loaded, g_type_default_interface_peek().

func ParamSpecGtype 

func ParamSpecGtype(NameVar string, NickVar string, BlurbVar string, IsATypeVar []interface{}, FlagsVar ParamFlags) *ParamSpec

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

See g_param_spec_internal() for details on property names.

func ParamSpecInternal 

func ParamSpecInternal(ParamTypeVar []interface{}, NameVar string, NickVar string, BlurbVar string, FlagsVar ParamFlags) *ParamSpec

Creates a new #GParamSpec instance.

See [canonical parameter names][canonical-parameter-names] for details of the rules for @name. Names which violate these rules lead to undefined behaviour.

Beyond the name, #GParamSpecs have two more descriptive strings associated with them, the @nick, which should be suitable for use as a label for the property in a property editor, and the @blurb, which should be a somewhat longer description, suitable for e.g. a tooltip. The @nick and @blurb should ideally be localized.

func ParamSpecNewFromInternalPtr 

func ParamSpecNewFromInternalPtr(ptr uintptr) *ParamSpec

func ParamSpecUchar 

func ParamSpecUchar(NameVar string, NickVar string, BlurbVar string, MinimumVar byte, MaximumVar byte, DefaultValueVar byte, FlagsVar ParamFlags) *ParamSpec

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

func ParamSpecUint 

func ParamSpecUint(NameVar string, NickVar string, BlurbVar string, MinimumVar uint, MaximumVar uint, DefaultValueVar uint, FlagsVar ParamFlags) *ParamSpec

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

See g_param_spec_internal() for details on property names.

func ParamSpecUint64 

func ParamSpecUint64(NameVar string, NickVar string, BlurbVar string, MinimumVar uint64, MaximumVar uint64, DefaultValueVar uint64, FlagsVar ParamFlags) *ParamSpec

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

See g_param_spec_internal() for details on property names.

func ParamSpecUlong 

func ParamSpecUlong(NameVar string, NickVar string, BlurbVar string, MinimumVar uint32, MaximumVar uint32, DefaultValueVar uint32, FlagsVar ParamFlags) *ParamSpec

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

See g_param_spec_internal() for details on property names.

func (*ParamSpec) GetBlurb 

func (x *ParamSpec) GetBlurb() string

Get the short description of a #GParamSpec.

func (*ParamSpec) GetDefaultValue 

func (x *ParamSpec) GetDefaultValue() *Value

Gets the default value of @pspec as a pointer to a #GValue.

The #GValue will remain valid for the life of @pspec.

func (*ParamSpec) GetName 

func (x *ParamSpec) GetName() 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 (*ParamSpec) GetNameQuark 

func (x *ParamSpec) GetNameQuark() glib.Quark

Gets the GQuark for the name.

func (*ParamSpec) GetNick 

func (x *ParamSpec) GetNick() string

Get the nickname of a #GParamSpec.

func (*ParamSpec) GetQdata 

func (x *ParamSpec) GetQdata(QuarkVar glib.Quark) uintptr

Gets back user data pointers stored via g_param_spec_set_qdata().

func (*ParamSpec) GetRedirectTarget 

func (x *ParamSpec) GetRedirectTarget() *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 (*ParamSpec) GoPointer 

func (c *ParamSpec) GoPointer() uintptr

func (*ParamSpec) Ref 

func (x *ParamSpec) Ref() *ParamSpec

Increments the reference count of @pspec.

func (*ParamSpec) RefSink 

func (x *ParamSpec) RefSink() *ParamSpec

Convenience function to ref and sink a #GParamSpec.

func (*ParamSpec) SetGoPointer 

func (c *ParamSpec) SetGoPointer(ptr uintptr)

func (*ParamSpec) SetQdata 

func (x *ParamSpec) SetQdata(QuarkVar glib.Quark, DataVar uintptr)

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 (*ParamSpec) SetQdataFull 

func (x *ParamSpec) SetQdataFull(QuarkVar glib.Quark, DataVar uintptr, DestroyVar *glib.DestroyNotify)

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 (*ParamSpec) Sink 

func (x *ParamSpec) 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 (*ParamSpec) StealQdata 

func (x *ParamSpec) StealQdata(QuarkVar glib.Quark) uintptr

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 (*ParamSpec) Unref 

func (x *ParamSpec) Unref()

Decrements the reference count of a @pspec.

type ParamSpecBoolean 

type ParamSpecBoolean struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for boolean properties.

func ParamSpecBooleanNewFromInternalPtr 

func ParamSpecBooleanNewFromInternalPtr(ptr uintptr) *ParamSpecBoolean

func (*ParamSpecBoolean) GoPointer 

func (c *ParamSpecBoolean) GoPointer() uintptr

func (*ParamSpecBoolean) SetGoPointer 

func (c *ParamSpecBoolean) SetGoPointer(ptr uintptr)

type ParamSpecBoxed 

type ParamSpecBoxed struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for boxed properties.

func ParamSpecBoxedNewFromInternalPtr 

func ParamSpecBoxedNewFromInternalPtr(ptr uintptr) *ParamSpecBoxed

func (*ParamSpecBoxed) GoPointer 

func (c *ParamSpecBoxed) GoPointer() uintptr

func (*ParamSpecBoxed) SetGoPointer 

func (c *ParamSpecBoxed) SetGoPointer(ptr uintptr)

type ParamSpecChar 

type ParamSpecChar struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for character properties.

func ParamSpecCharNewFromInternalPtr 

func ParamSpecCharNewFromInternalPtr(ptr uintptr) *ParamSpecChar

func (*ParamSpecChar) GoPointer 

func (c *ParamSpecChar) GoPointer() uintptr

func (*ParamSpecChar) SetGoPointer 

func (c *ParamSpecChar) SetGoPointer(ptr uintptr)

type ParamSpecClass 

type ParamSpecClass struct {
	GTypeClass uintptr

	ValueType []interface{}

	Dummy uintptr
}

The class structure for the GParamSpec type. Normally, GParamSpec classes are filled by g_param_type_register_static().

func (*ParamSpecClass) GoPointer 

func (x *ParamSpecClass) GoPointer() uintptr

type ParamSpecDouble 

type ParamSpecDouble struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for double properties.

func ParamSpecDoubleNewFromInternalPtr 

func ParamSpecDoubleNewFromInternalPtr(ptr uintptr) *ParamSpecDouble

func (*ParamSpecDouble) GoPointer 

func (c *ParamSpecDouble) GoPointer() uintptr

func (*ParamSpecDouble) SetGoPointer 

func (c *ParamSpecDouble) SetGoPointer(ptr uintptr)

type ParamSpecEnum 

type ParamSpecEnum struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for enum properties.

func ParamSpecEnumNewFromInternalPtr 

func ParamSpecEnumNewFromInternalPtr(ptr uintptr) *ParamSpecEnum

func (*ParamSpecEnum) GoPointer 

func (c *ParamSpecEnum) GoPointer() uintptr

func (*ParamSpecEnum) SetGoPointer 

func (c *ParamSpecEnum) SetGoPointer(ptr uintptr)

type ParamSpecFlags 

type ParamSpecFlags struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for flags properties.

func ParamSpecFlagsNewFromInternalPtr 

func ParamSpecFlagsNewFromInternalPtr(ptr uintptr) *ParamSpecFlags

func (*ParamSpecFlags) GoPointer 

func (c *ParamSpecFlags) GoPointer() uintptr

func (*ParamSpecFlags) SetGoPointer 

func (c *ParamSpecFlags) SetGoPointer(ptr uintptr)

type ParamSpecFloat 

type ParamSpecFloat struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for float properties.

func ParamSpecFloatNewFromInternalPtr 

func ParamSpecFloatNewFromInternalPtr(ptr uintptr) *ParamSpecFloat

func (*ParamSpecFloat) GoPointer 

func (c *ParamSpecFloat) GoPointer() uintptr

func (*ParamSpecFloat) SetGoPointer 

func (c *ParamSpecFloat) SetGoPointer(ptr uintptr)

type ParamSpecGType 

type ParamSpecGType struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for #GType properties.

func ParamSpecGTypeNewFromInternalPtr 

func ParamSpecGTypeNewFromInternalPtr(ptr uintptr) *ParamSpecGType

func (*ParamSpecGType) GoPointer 

func (c *ParamSpecGType) GoPointer() uintptr

func (*ParamSpecGType) SetGoPointer 

func (c *ParamSpecGType) SetGoPointer(ptr uintptr)

type ParamSpecInt 

type ParamSpecInt struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for integer properties.

func ParamSpecIntNewFromInternalPtr 

func ParamSpecIntNewFromInternalPtr(ptr uintptr) *ParamSpecInt

func (*ParamSpecInt) GoPointer 

func (c *ParamSpecInt) GoPointer() uintptr

func (*ParamSpecInt) SetGoPointer 

func (c *ParamSpecInt) SetGoPointer(ptr uintptr)

type ParamSpecInt64 

type ParamSpecInt64 struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for 64bit integer properties.

func ParamSpecInt64NewFromInternalPtr 

func ParamSpecInt64NewFromInternalPtr(ptr uintptr) *ParamSpecInt64

func (*ParamSpecInt64) GoPointer 

func (c *ParamSpecInt64) GoPointer() uintptr

func (*ParamSpecInt64) SetGoPointer 

func (c *ParamSpecInt64) SetGoPointer(ptr uintptr)

type ParamSpecLong 

type ParamSpecLong struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for long integer properties.

func ParamSpecLongNewFromInternalPtr 

func ParamSpecLongNewFromInternalPtr(ptr uintptr) *ParamSpecLong

func (*ParamSpecLong) GoPointer 

func (c *ParamSpecLong) GoPointer() uintptr

func (*ParamSpecLong) SetGoPointer 

func (c *ParamSpecLong) SetGoPointer(ptr uintptr)

type ParamSpecObject 

type ParamSpecObject struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for object properties.

func ParamSpecObjectNewFromInternalPtr 

func ParamSpecObjectNewFromInternalPtr(ptr uintptr) *ParamSpecObject

func (*ParamSpecObject) GoPointer 

func (c *ParamSpecObject) GoPointer() uintptr

func (*ParamSpecObject) SetGoPointer 

func (c *ParamSpecObject) SetGoPointer(ptr uintptr)

type ParamSpecOverride 

type ParamSpecOverride struct {
	ParamSpec
}

A #GParamSpec derived structure that redirects operations to other types of #GParamSpec.

All operations other than getting or setting the value are redirected, including accessing the nick and blurb, validating a value, and so forth.

See g_param_spec_get_redirect_target() for retrieving the overridden property. #GParamSpecOverride is used in implementing g_object_class_override_property(), and will not be directly useful unless you are implementing a new base type similar to GObject.

func ParamSpecOverrideNewFromInternalPtr 

func ParamSpecOverrideNewFromInternalPtr(ptr uintptr) *ParamSpecOverride

func (*ParamSpecOverride) GoPointer 

func (c *ParamSpecOverride) GoPointer() uintptr

func (*ParamSpecOverride) SetGoPointer 

func (c *ParamSpecOverride) SetGoPointer(ptr uintptr)

type ParamSpecParam 

type ParamSpecParam struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for %G_TYPE_PARAM properties.

func ParamSpecParamNewFromInternalPtr 

func ParamSpecParamNewFromInternalPtr(ptr uintptr) *ParamSpecParam

func (*ParamSpecParam) GoPointer 

func (c *ParamSpecParam) GoPointer() uintptr

func (*ParamSpecParam) SetGoPointer 

func (c *ParamSpecParam) SetGoPointer(ptr uintptr)

type ParamSpecPointer 

type ParamSpecPointer struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for pointer properties.

func ParamSpecPointerNewFromInternalPtr 

func ParamSpecPointerNewFromInternalPtr(ptr uintptr) *ParamSpecPointer

func (*ParamSpecPointer) GoPointer 

func (c *ParamSpecPointer) GoPointer() uintptr

func (*ParamSpecPointer) SetGoPointer 

func (c *ParamSpecPointer) SetGoPointer(ptr uintptr)

type ParamSpecPool 

type ParamSpecPool struct {
}

A #GParamSpecPool maintains a collection of #GParamSpecs which can be quickly accessed by owner and name.

The implementation of the #GObject property system uses such a pool to store the #GParamSpecs of the properties all object types.

func (*ParamSpecPool) GoPointer 

func (x *ParamSpecPool) GoPointer() uintptr

func (*ParamSpecPool) Insert 

func (x *ParamSpecPool) Insert(PspecVar *ParamSpec, OwnerTypeVar []interface{})

Inserts a #GParamSpec in the pool.

func (*ParamSpecPool) List 

func (x *ParamSpecPool) List(OwnerTypeVar []interface{}, NPspecsPVar uint) uintptr

Gets an array of all #GParamSpecs owned by @owner_type in the pool.

func (*ParamSpecPool) ListOwned 

func (x *ParamSpecPool) ListOwned(OwnerTypeVar []interface{}) *glib.List

Gets an #GList of all #GParamSpecs owned by @owner_type in the pool.

func (*ParamSpecPool) Lookup 

func (x *ParamSpecPool) Lookup(ParamNameVar string, OwnerTypeVar []interface{}, WalkAncestorsVar bool) *ParamSpec

Looks up a #GParamSpec in the pool.

func (*ParamSpecPool) Remove 

func (x *ParamSpecPool) Remove(PspecVar *ParamSpec)

Removes a #GParamSpec from the pool.

type ParamSpecString 

type ParamSpecString struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for string properties.

func ParamSpecStringNewFromInternalPtr 

func ParamSpecStringNewFromInternalPtr(ptr uintptr) *ParamSpecString

func (*ParamSpecString) GoPointer 

func (c *ParamSpecString) GoPointer() uintptr

func (*ParamSpecString) SetGoPointer 

func (c *ParamSpecString) SetGoPointer(ptr uintptr)

type ParamSpecTypeInfo 

type ParamSpecTypeInfo struct {
	InstanceSize uint16

	NPreallocs uint16

	ValueType []interface{}
}

This structure is used to provide the type system with the information required to initialize and destruct (finalize) a parameter's class and instances thereof.

The initialized structure is passed to the g_param_type_register_static() The type system will perform a deep copy of this structure, so its memory does not need to be persistent across invocation of g_param_type_register_static().

func (*ParamSpecTypeInfo) GoPointer 

func (x *ParamSpecTypeInfo) GoPointer() uintptr

type ParamSpecUChar 

type ParamSpecUChar struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for unsigned character properties.

func ParamSpecUCharNewFromInternalPtr 

func ParamSpecUCharNewFromInternalPtr(ptr uintptr) *ParamSpecUChar

func (*ParamSpecUChar) GoPointer 

func (c *ParamSpecUChar) GoPointer() uintptr

func (*ParamSpecUChar) SetGoPointer 

func (c *ParamSpecUChar) SetGoPointer(ptr uintptr)

type ParamSpecUInt 

type ParamSpecUInt struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for unsigned integer properties.

func ParamSpecUIntNewFromInternalPtr 

func ParamSpecUIntNewFromInternalPtr(ptr uintptr) *ParamSpecUInt

func (*ParamSpecUInt) GoPointer 

func (c *ParamSpecUInt) GoPointer() uintptr

func (*ParamSpecUInt) SetGoPointer 

func (c *ParamSpecUInt) SetGoPointer(ptr uintptr)

type ParamSpecUInt64 

type ParamSpecUInt64 struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for unsigned 64bit integer properties.

func ParamSpecUInt64NewFromInternalPtr 

func ParamSpecUInt64NewFromInternalPtr(ptr uintptr) *ParamSpecUInt64

func (*ParamSpecUInt64) GoPointer 

func (c *ParamSpecUInt64) GoPointer() uintptr

func (*ParamSpecUInt64) SetGoPointer 

func (c *ParamSpecUInt64) SetGoPointer(ptr uintptr)

type ParamSpecULong 

type ParamSpecULong struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for unsigned long integer properties.

func ParamSpecULongNewFromInternalPtr 

func ParamSpecULongNewFromInternalPtr(ptr uintptr) *ParamSpecULong

func (*ParamSpecULong) GoPointer 

func (c *ParamSpecULong) GoPointer() uintptr

func (*ParamSpecULong) SetGoPointer 

func (c *ParamSpecULong) SetGoPointer(ptr uintptr)

type ParamSpecUnichar 

type ParamSpecUnichar struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for unichar (unsigned integer) properties.

func ParamSpecUnicharNewFromInternalPtr 

func ParamSpecUnicharNewFromInternalPtr(ptr uintptr) *ParamSpecUnichar

func (*ParamSpecUnichar) GoPointer 

func (c *ParamSpecUnichar) GoPointer() uintptr

func (*ParamSpecUnichar) SetGoPointer 

func (c *ParamSpecUnichar) SetGoPointer(ptr uintptr)

type ParamSpecValueArray 

type ParamSpecValueArray struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for #GValueArray properties.

func ParamSpecValueArrayNewFromInternalPtr 

func ParamSpecValueArrayNewFromInternalPtr(ptr uintptr) *ParamSpecValueArray

func (*ParamSpecValueArray) GoPointer 

func (c *ParamSpecValueArray) GoPointer() uintptr

func (*ParamSpecValueArray) SetGoPointer 

func (c *ParamSpecValueArray) SetGoPointer(ptr uintptr)

type ParamSpecVariant 

type ParamSpecVariant struct {
	ParamSpec
}

A #GParamSpec derived structure that contains the meta data for #GVariant properties.

When comparing values with g_param_values_cmp(), scalar values with the same type will be compared with g_variant_compare(). Other non-%NULL variants will be checked for equality with g_variant_equal(), and their sort order is otherwise undefined. %NULL is ordered before non-%NULL variants. Two %NULL values compare equal.

func ParamSpecVariantNewFromInternalPtr 

func ParamSpecVariantNewFromInternalPtr(ptr uintptr) *ParamSpecVariant

func (*ParamSpecVariant) GoPointer 

func (c *ParamSpecVariant) GoPointer() uintptr

func (*ParamSpecVariant) SetGoPointer 

func (c *ParamSpecVariant) SetGoPointer(ptr uintptr)

type Parameter 

type Parameter struct {
	Name uintptr

	Value uintptr
}

The GParameter struct is an auxiliary structure used to hand parameter name/value pairs to g_object_newv().

func (*Parameter) GoPointer 

func (x *Parameter) GoPointer() uintptr

type Ptr 

type Ptr interface {
	GoPointer() uintptr
	SetGoPointer(uintptr)
}

type SignalAccumulator 

type SignalAccumulator func(*SignalInvocationHint, *Value, *Value, uintptr) bool

The signal accumulator is a special callback function that can be used to collect return values of the various callbacks that are called during a signal emission.

The signal accumulator is specified at signal creation time, if it is left %NULL, no accumulation of callback return values is performed. The return value of signal emissions is then the value returned by the last callback.

type SignalCMarshaller 

type SignalCMarshaller = ClosureMarshal

This is the signature of marshaller functions, required to marshall arrays of parameter values to signal emissions into C language callback invocations.

It is merely an alias to #GClosureMarshal since the #GClosure mechanism takes over responsibility of actual function invocation for the signal system.

type SignalCVaMarshaller 

type SignalCVaMarshaller = VaClosureMarshal

This is the signature of va_list marshaller functions, an optional marshaller that can be used in some situations to avoid marshalling the signal argument into GValues.

type SignalEmissionHook 

type SignalEmissionHook func(*SignalInvocationHint, uint, uintptr, uintptr) bool

A simple function pointer to get invoked when the signal is emitted.

Emission hooks allow you to tie a hook to the signal type, so that it will trap all emissions of that signal, from any object.

You may not attach these to signals created with the %G_SIGNAL_NO_HOOKS flag.

type SignalFlags 

type SignalFlags int

The signal flags are used to specify a signal's behaviour. 

const (

	// Invoke the object method handler in the first emission stage.
	GSignalRunFirstValue SignalFlags = 1
	// Invoke the object method handler in the third emission stage.
	GSignalRunLastValue SignalFlags = 2
	// Invoke the object method handler in the last emission stage.
	GSignalRunCleanupValue SignalFlags = 4
	// Signals being emitted for an object while currently being in
	//  emission for this very object will not be emitted recursively,
	//  but instead cause the first emission to be restarted.
	GSignalNoRecurseValue SignalFlags = 8
	// This signal supports "::detail" appendices to the signal name
	//  upon handler connections and emissions.
	GSignalDetailedValue SignalFlags = 16
	// Action signals are signals that may freely be emitted on alive
	//  objects from user code via g_signal_emit() and friends, without
	//  the need of being embedded into extra code that performs pre or
	//  post emission adjustments on the object. They can also be thought
	//  of as object methods which can be called generically by
	//  third-party code.
	GSignalActionValue SignalFlags = 32
	// No emissions hooks are supported for this signal.
	GSignalNoHooksValue SignalFlags = 64
	// Varargs signal emission will always collect the
	//   arguments, even if there are no signal handlers connected.  Since 2.30.
	GSignalMustCollectValue SignalFlags = 128
	// The signal is deprecated and will be removed
	//   in a future version. A warning will be generated if it is connected while
	//   running with G_ENABLE_DIAGNOSTIC=1.  Since 2.32.
	GSignalDeprecatedValue SignalFlags = 256
	// Only used in #GSignalAccumulator accumulator
	//   functions for the #GSignalInvocationHint::run_type field to mark the first
	//   call to the accumulator function for a signal emission.  Since 2.68.
	GSignalAccumulatorFirstRunValue SignalFlags = 131072
)

type SignalGroup 

type SignalGroup struct {
	Object
}

#GSignalGroup manages to simplify the process of connecting many signals to a #GObject as a group. As such there is no API to disconnect a signal from the group.

In particular, this allows you to:

  • Change the target instance, which automatically causes disconnection of the signals from the old instance and connecting to the new instance.
  • Block and unblock signals as a group
  • Ensuring that blocked state transfers across target instances.

One place you might want to use such a structure is with #GtkTextView and #GtkTextBuffer. Often times, you'll need to connect to many signals on #GtkTextBuffer from a #GtkTextView subclass. This allows you to create a signal group during instance construction, simply bind the #GtkTextView:buffer property to #GSignalGroup:target and connect all the signals you need. When the #GtkTextView:buffer property changes all of the signals will be transitioned correctly.

func NewSignalGroup 

func NewSignalGroup(TargetTypeVar []interface{}) *SignalGroup

Creates a new #GSignalGroup for target instances of @target_type.

func SignalGroupNewFromInternalPtr 

func SignalGroupNewFromInternalPtr(ptr uintptr) *SignalGroup

func (*SignalGroup) Block 

func (x *SignalGroup) Block()

Blocks all signal handlers managed by @self so they will not be called during any signal emissions. Must be unblocked exactly the same number of times it has been blocked to become active again.

This blocked state will be kept across changes of the target instance.

func (*SignalGroup) Connect 

func (x *SignalGroup) Connect(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr)

Connects @c_handler to the signal @detailed_signal on the target instance of @self.

You cannot connect a signal handler after #GSignalGroup:target has been set.

func (*SignalGroup) ConnectAfter 

func (x *SignalGroup) ConnectAfter(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr)

Connects @c_handler to the signal @detailed_signal on the target instance of @self.

The @c_handler will be called after the default handler of the signal.

You cannot connect a signal handler after #GSignalGroup:target has been set.

func (*SignalGroup) ConnectBind 

func (x *SignalGroup) ConnectBind(cb *func(SignalGroup, uintptr)) uint32

This signal is emitted when #GSignalGroup:target is set to a new value other than %NULL. It is similar to #GObject::notify on `target` except it will not emit when #GSignalGroup:target is %NULL and also allows for receiving the #GObject without a data-race.

func (*SignalGroup) ConnectData 

func (x *SignalGroup) ConnectData(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr, NotifyVar *ClosureNotify, FlagsVar ConnectFlags)

Connects @c_handler to the signal @detailed_signal on the target instance of @self.

You cannot connect a signal handler after #GSignalGroup:target has been set.

func (*SignalGroup) ConnectObject 

func (x *SignalGroup) ConnectObject(DetailedSignalVar string, CHandlerVar *Callback, ObjectVar uintptr, FlagsVar ConnectFlags)

Connects @c_handler to the signal @detailed_signal on #GSignalGroup:target.

Ensures that the @object stays alive during the call to @c_handler by temporarily adding a reference count. When the @object is destroyed the signal handler will automatically be removed.

You cannot connect a signal handler after #GSignalGroup:target has been set.

func (*SignalGroup) ConnectSwapped 

func (x *SignalGroup) ConnectSwapped(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr)

Connects @c_handler to the signal @detailed_signal on the target instance of @self.

The instance on which the signal is emitted and @data will be swapped when calling @c_handler.

You cannot connect a signal handler after #GSignalGroup:target has been set.

func (*SignalGroup) ConnectUnbind 

func (x *SignalGroup) ConnectUnbind(cb *func(SignalGroup)) uint32

This signal is emitted when the target instance of @self is set to a new #GObject.

This signal will only be emitted if the previous target of @self is non-%NULL.

func (*SignalGroup) DupTarget 

func (x *SignalGroup) DupTarget() *Object

Gets the target instance used when connecting signals.

func (*SignalGroup) GoPointer 

func (c *SignalGroup) GoPointer() uintptr

func (*SignalGroup) SetGoPointer 

func (c *SignalGroup) SetGoPointer(ptr uintptr)

func (*SignalGroup) SetTarget 

func (x *SignalGroup) SetTarget(TargetVar *Object)

Sets the target instance used when connecting signals. Any signal that has been registered with g_signal_group_connect_object() or similar functions will be connected to this object.

If the target instance was previously set, signals will be disconnected from that object prior to connecting to @target.

func (*SignalGroup) Unblock 

func (x *SignalGroup) Unblock()

Unblocks all signal handlers managed by @self so they will be called again during any signal emissions unless it is blocked again. Must be unblocked exactly the same number of times it has been blocked to become active again.

type SignalInvocationHint 

type SignalInvocationHint struct {
	SignalId uint

	Detail glib.Quark

	RunType SignalFlags
}

The #GSignalInvocationHint structure is used to pass on additional information to callbacks during a signal emission.

func SignalGetInvocationHint 

func SignalGetInvocationHint(InstanceVar *Object) *SignalInvocationHint

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

func (*SignalInvocationHint) GoPointer 

func (x *SignalInvocationHint) GoPointer() uintptr

type SignalMatchType 

type SignalMatchType int

The match types specify what g_signal_handlers_block_matched(), g_signal_handlers_unblock_matched() and g_signal_handlers_disconnect_matched() match signals by. 

const (

	// The signal id must be equal.
	GSignalMatchIdValue SignalMatchType = 1
	// The signal detail must be equal.
	GSignalMatchDetailValue SignalMatchType = 2
	// The closure must be the same.
	GSignalMatchClosureValue SignalMatchType = 4
	// The C closure callback must be the same.
	GSignalMatchFuncValue SignalMatchType = 8
	// The closure data must be the same.
	GSignalMatchDataValue SignalMatchType = 16
	// Only unblocked signals may be matched.
	GSignalMatchUnblockedValue SignalMatchType = 32
)

type SignalQuery 

type SignalQuery struct {
	SignalId uint

	SignalName uintptr

	Itype []interface{}

	SignalFlags SignalFlags

	ReturnType []interface{}

	NParams uint

	ParamTypes uintptr
}

A structure holding in-depth information for a specific signal.

See also: g_signal_query()

func (*SignalQuery) GoPointer 

func (x *SignalQuery) GoPointer() uintptr

type ToggleNotify 

type ToggleNotify func(uintptr, uintptr, bool)

A callback function used for notification when the state of a toggle reference changes.

See also: g_object_add_toggle_ref()

type Type 

type Type = uint

A numerical value which represents the unique identifier of a registered type.

type TypeCValue 

type TypeCValue = uintptr

type TypeClass 

type TypeClass struct {
	GType []interface{}
}

An opaque structure used as the base of all classes.

func TypeCheckClassCast 

func TypeCheckClassCast(GClassVar *TypeClass, IsATypeVar []interface{}) *TypeClass

func TypeClassPeek 

func TypeClassPeek(TypeVar []interface{}) *TypeClass

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(TypeVar []interface{}) *TypeClass

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

func TypeClassRef 

func TypeClassRef(TypeVar []interface{}) *TypeClass

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 (*TypeClass) AddPrivate 

func (x *TypeClass) AddPrivate(PrivateSizeVar uint)

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

|[&lt;!-- language="C" --&gt; 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-&gt;priv = G_TYPE_INSTANCE_GET_PRIVATE (my_object,
                                                 MY_TYPE_OBJECT,
                                                 MyObjectPrivate);
  // my_object-&gt;priv-&gt;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-&gt;priv;

  return priv-&gt;some_field;
}

]|

func (*TypeClass) GetInstancePrivateOffset 

func (x *TypeClass) GetInstancePrivateOffset() 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 (*TypeClass) GetPrivate 

func (x *TypeClass) GetPrivate(PrivateTypeVar []interface{}) uintptr

func (*TypeClass) GoPointer 

func (x *TypeClass) GoPointer() uintptr

func (*TypeClass) PeekParent 

func (x *TypeClass) PeekParent() *TypeClass

This is a convenience function often needed in class initializers. It returns the class structure of the immediate parent type of the class passed in. Since derived classes hold a reference count on their parent classes as long as they are instantiated, the returned class will always exist.

This function is essentially equivalent to: g_type_class_peek (g_type_parent (G_TYPE_FROM_CLASS (g_class)))

func (*TypeClass) Unref 

func (x *TypeClass) Unref()

Decrements the reference count of the class structure being passed in. Once the last reference count of a class has been released, classes may be finalized by the type system, so further dereferencing of a class pointer after g_type_class_unref() are invalid.

func (*TypeClass) UnrefUncached 

func (x *TypeClass) UnrefUncached()

A variant of g_type_class_unref() for use in #GTypeClassCacheFunc implementations. It unreferences a class without consulting the chain of #GTypeClassCacheFuncs, avoiding the recursion which would occur otherwise.

type TypeClassCacheFunc 

type TypeClassCacheFunc func(uintptr, *TypeClass) bool

A callback function which is called when the reference count of a class drops to zero.

It may use g_type_class_ref() to prevent the class from being freed. You should not call g_type_class_unref() from a #GTypeClassCacheFunc function to prevent infinite recursion, use g_type_class_unref_uncached() instead.

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.

type TypeDebugFlags 

type TypeDebugFlags int

These flags used to be passed to g_type_init_with_debug_flags() which is now deprecated.

If you need to enable debugging features, use the GOBJECT_DEBUG environment variable. 

const (

	// Print no messages
	GTypeDebugNoneValue TypeDebugFlags = 0
	// Print messages about object bookkeeping
	GTypeDebugObjectsValue TypeDebugFlags = 1
	// Print messages about signal emissions
	GTypeDebugSignalsValue TypeDebugFlags = 2
	// Keep a count of instances of each type
	GTypeDebugInstanceCountValue TypeDebugFlags = 4
	// Mask covering all debug flags
	GTypeDebugMaskValue TypeDebugFlags = 7
)

type TypeFlags 

type TypeFlags int

Bit masks used to check or determine characteristics of a type. 

const (

	// Indicates an abstract type. No instances can be
	//  created for an abstract type
	GTypeFlagAbstractValue TypeFlags = 16
	// Indicates an abstract value type, i.e. a type
	//  that introduces a value table, but can't be used for
	//  g_value_init()
	GTypeFlagValueAbstractValue TypeFlags = 32
	// Indicates a final type. A final type is a non-derivable
	//  leaf node in a deep derivable type hierarchy tree. Since: 2.70
	GTypeFlagFinalValue TypeFlags = 64
)

type TypeFundamentalFlags 

type TypeFundamentalFlags int

Bit masks used to check or determine specific characteristics of a fundamental type. 

const (

	// Indicates a classed type
	GTypeFlagClassedValue TypeFundamentalFlags = 1
	// Indicates an instantiatable type (implies classed)
	GTypeFlagInstantiatableValue TypeFundamentalFlags = 2
	// Indicates a flat derivable type
	GTypeFlagDerivableValue TypeFundamentalFlags = 4
	// Indicates a deep derivable type (implies derivable)
	GTypeFlagDeepDerivableValue TypeFundamentalFlags = 8
)

type TypeFundamentalInfo 

type TypeFundamentalInfo struct {
	TypeFlags TypeFundamentalFlags
}

A structure that provides information to the type system which is used specifically for managing fundamental types.

func (*TypeFundamentalInfo) GoPointer 

func (x *TypeFundamentalInfo) GoPointer() uintptr

type TypeInfo 

type TypeInfo struct {
	ClassSize uint16

	BaseInit BaseInitFunc

	BaseFinalize BaseFinalizeFunc

	ClassInit ClassInitFunc

	ClassFinalize ClassFinalizeFunc

	ClassData uintptr

	InstanceSize uint16

	NPreallocs uint16

	InstanceInit InstanceInitFunc

	ValueTable *TypeValueTable
}

This structure is used to provide the type system with the information required to initialize and destruct (finalize) a type's class and its instances.

The initialized structure is passed to the g_type_register_static() function (or is copied into the provided #GTypeInfo structure in the g_type_plugin_complete_type_info()). The type system will perform a deep copy of this structure, so its memory does not need to be persistent across invocation of g_type_register_static().

func (*TypeInfo) GoPointer 

func (x *TypeInfo) GoPointer() uintptr

type TypeInstance 

type TypeInstance struct {
	GClass *TypeClass
}

An opaque structure used as the base of all type instances.

func TypeCheckInstanceCast 

func TypeCheckInstanceCast(InstanceVar *TypeInstance, IfaceTypeVar []interface{}) *TypeInstance

func TypeCreateInstance 

func TypeCreateInstance(TypeVar []interface{}) *TypeInstance

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 implementers 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 (*TypeInstance) GetPrivate 

func (x *TypeInstance) GetPrivate(PrivateTypeVar []interface{}) uintptr

func (*TypeInstance) GoPointer 

func (x *TypeInstance) GoPointer() uintptr

type TypeInterface 

type TypeInterface struct {
	GType []interface{}

	GInstanceType []interface{}
}

An opaque structure used as the base of all interface types.

func TypeDefaultInterfacePeek 

func TypeDefaultInterfacePeek(GTypeVar []interface{}) *TypeInterface

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

func TypeDefaultInterfaceRef 

func TypeDefaultInterfaceRef(GTypeVar []interface{}) *TypeInterface

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

func TypeInterfacePeek(InstanceClassVar *TypeClass, IfaceTypeVar []interface{}) *TypeInterface

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

func (*TypeInterface) GoPointer 

func (x *TypeInterface) GoPointer() uintptr

func (*TypeInterface) PeekParent 

func (x *TypeInterface) PeekParent() *TypeInterface

Returns the corresponding #GTypeInterface structure of the parent type of the instance type to which @g_iface belongs. This is useful when deriving the implementation of an interface from the parent type and then possibly overriding some methods.

type TypeInterfaceCheckFunc 

type TypeInterfaceCheckFunc func(uintptr, *TypeInterface)

A callback called after an interface vtable is initialized.

See g_type_add_interface_check().

type TypeModule 

type TypeModule struct {
	Object
}

#GTypeModule provides a simple implementation of the #GTypePlugin interface.

The model of #GTypeModule is a dynamically loaded module which implements some number of types and interface implementations.

When the module is loaded, it registers its types and interfaces using g_type_module_register_type() and g_type_module_add_interface(). As long as any instances of these types and interface implementations are in use, the module is kept loaded. When the types and interfaces are gone, the module may be unloaded. If the types and interfaces become used again, the module will be reloaded. Note that the last reference cannot be released from within the module code, since that would lead to the caller's code being unloaded before g_object_unref() returns to it.

Keeping track of whether the module should be loaded or not is done by using a use count - it starts at zero, and whenever it is greater than zero, the module is loaded. The use count is maintained internally by the type system, but also can be explicitly controlled by g_type_module_use() and g_type_module_unuse(). Typically, when loading a module for the first type, g_type_module_use() will be used to load it so that it can initialize its types. At some later point, when the module no longer needs to be loaded except for the type implementations it contains, g_type_module_unuse() is called.

#GTypeModule does not actually provide any implementation of module loading and unloading. To create a particular module type you must derive from #GTypeModule and implement the load and unload functions in #GTypeModuleClass.

func TypeModuleNewFromInternalPtr 

func TypeModuleNewFromInternalPtr(ptr uintptr) *TypeModule

func (*TypeModule) AddInterface 

func (x *TypeModule) AddInterface(InstanceTypeVar []interface{}, InterfaceTypeVar []interface{}, InterfaceInfoVar *InterfaceInfo)

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.

Since 2.56 if @module is %NULL this will call g_type_add_interface_static() instead. This can be used when making a static build of the module.

func (*TypeModule) CompleteInterfaceInfo 

func (x *TypeModule) CompleteInterfaceInfo(InstanceTypeVar []interface{}, InterfaceTypeVar []interface{}, InfoVar *InterfaceInfo)

Calls the @complete_interface_info function from the #GTypePluginClass of @plugin. There should be no need to use this function outside of the GObject type system itself.

func (*TypeModule) CompleteTypeInfo 

func (x *TypeModule) CompleteTypeInfo(GTypeVar []interface{}, InfoVar *TypeInfo, ValueTableVar *TypeValueTable)

Calls the @complete_type_info function from the #GTypePluginClass of @plugin. There should be no need to use this function outside of the GObject type system itself.

func (*TypeModule) GoPointer 

func (c *TypeModule) GoPointer() uintptr

func (*TypeModule) RegisterEnum 

func (x *TypeModule) RegisterEnum(NameVar string, ConstStaticValuesVar *EnumValue) []interface{}

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.

Since 2.56 if @module is %NULL this will call g_type_register_static() instead. This can be used when making a static build of the module.

func (*TypeModule) RegisterFlags 

func (x *TypeModule) RegisterFlags(NameVar string, ConstStaticValuesVar *FlagsValue) []interface{}

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.

Since 2.56 if @module is %NULL this will call g_type_register_static() instead. This can be used when making a static build of the module.

func (*TypeModule) RegisterType 

func (x *TypeModule) RegisterType(ParentTypeVar []interface{}, TypeNameVar string, TypeInfoVar *TypeInfo, FlagsVar TypeFlags) []interface{}

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.

Since 2.56 if @module is %NULL this will call g_type_register_static() instead. This can be used when making a static build of the module.

func (*TypeModule) SetGoPointer 

func (c *TypeModule) SetGoPointer(ptr uintptr)

func (*TypeModule) SetName 

func (x *TypeModule) SetName(NameVar string)

Sets the name for a #GTypeModule

func (*TypeModule) Unuse 

func (x *TypeModule) 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 (*TypeModule) Use 

func (x *TypeModule) Use() 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 TypeModuleClass 

type TypeModuleClass struct {
	ParentClass uintptr
}

In order to implement dynamic loading of types based on #GTypeModule, the @load and @unload functions in #GTypeModuleClass must be implemented.

func (*TypeModuleClass) GoPointer 

func (x *TypeModuleClass) GoPointer() uintptr

type TypePlugin 

type TypePlugin interface {
	GoPointer() uintptr
	SetGoPointer(uintptr)
	CompleteInterfaceInfo(InstanceTypeVar []interface{}, InterfaceTypeVar []interface{}, InfoVar *InterfaceInfo)
	CompleteTypeInfo(GTypeVar []interface{}, InfoVar *TypeInfo, ValueTableVar *TypeValueTable)
	Unuse()
	Use()
}

An interface that handles the lifecycle of dynamically loaded types.

The GObject type system supports dynamic loading of types. It goes as follows:

  1. The type is initially introduced (usually upon loading the module the first time, or by your main application that knows what modules introduces what types), like this: |[&lt;!-- language="C" --&gt; new_type_id = g_type_register_dynamic (parent_type_id, "TypeName", new_type_plugin, type_flags); ]| where @new_type_plugin is an implementation of the #GTypePlugin interface.

  2. The type's implementation is referenced, e.g. through g_type_class_ref() or through g_type_create_instance() (this is being called by g_object_new()) or through one of the above done on a type derived from @new_type_id.

  3. This causes the type system to load the type's implementation by calling g_type_plugin_use() and g_type_plugin_complete_type_info() on @new_type_plugin.

  4. At some point the type's implementation isn't required anymore, e.g. after g_type_class_unref() or g_type_free_instance() (called when the reference count of an instance drops to zero).

  5. This causes the type system to throw away the information retrieved from g_type_plugin_complete_type_info() and then it calls g_type_plugin_unuse() on @new_type_plugin.

6. Things may repeat from the second step.

So basically, you need to implement a #GTypePlugin type that carries a use_count, once use_count goes from zero to one, you need to load the implementation to successfully handle the upcoming g_type_plugin_complete_type_info() call. Later, maybe after succeeding use/unuse calls, once use_count drops to zero, you can unload the implementation again. The type system makes sure to call g_type_plugin_use() and g_type_plugin_complete_type_info() again when the type is needed again.

#GTypeModule is an implementation of #GTypePlugin that already implements most of this except for the actual module loading and unloading. It even handles multiple registered types per module.

type TypePluginBase 

type TypePluginBase struct {
	Ptr uintptr
}

func TypeGetPlugin 

func TypeGetPlugin(TypeVar []interface{}) *TypePluginBase

Returns the #GTypePlugin structure for @type.

func TypeInterfaceGetPlugin 

func TypeInterfaceGetPlugin(InstanceTypeVar []interface{}, InterfaceTypeVar []interface{}) *TypePluginBase

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 (*TypePluginBase) CompleteInterfaceInfo 

func (x *TypePluginBase) CompleteInterfaceInfo(InstanceTypeVar []interface{}, InterfaceTypeVar []interface{}, InfoVar *InterfaceInfo)

Calls the @complete_interface_info function from the #GTypePluginClass of @plugin. There should be no need to use this function outside of the GObject type system itself.

func (*TypePluginBase) CompleteTypeInfo 

func (x *TypePluginBase) CompleteTypeInfo(GTypeVar []interface{}, InfoVar *TypeInfo, ValueTableVar *TypeValueTable)

Calls the @complete_type_info function from the #GTypePluginClass of @plugin. There should be no need to use this function outside of the GObject type system itself.

func (*TypePluginBase) GoPointer 

func (x *TypePluginBase) GoPointer() uintptr

func (*TypePluginBase) SetGoPointer 

func (x *TypePluginBase) SetGoPointer(ptr uintptr)

func (*TypePluginBase) Unuse 

func (x *TypePluginBase) Unuse()

Calls the @unuse_plugin function from the #GTypePluginClass of @plugin. There should be no need to use this function outside of the GObject type system itself.

func (*TypePluginBase) Use 

func (x *TypePluginBase) Use()

Calls the @use_plugin function from the #GTypePluginClass of @plugin. There should be no need to use this function outside of the GObject type system itself.

type TypePluginClass 

type TypePluginClass struct {
	BaseIface uintptr

	UsePlugin TypePluginUse

	UnusePlugin TypePluginUnuse

	CompleteTypeInfo TypePluginCompleteTypeInfo

	CompleteInterfaceInfo TypePluginCompleteInterfaceInfo
}

The #GTypePlugin interface is used by the type system in order to handle the lifecycle of dynamically loaded types.

func (*TypePluginClass) GoPointer 

func (x *TypePluginClass) GoPointer() uintptr

type TypePluginCompleteInterfaceInfo 

type TypePluginCompleteInterfaceInfo func(uintptr, []interface{}, []interface{}, *InterfaceInfo)

The type of the @complete_interface_info function of #GTypePluginClass.

type TypePluginCompleteTypeInfo 

type TypePluginCompleteTypeInfo func(uintptr, []interface{}, *TypeInfo, *TypeValueTable)

The type of the @complete_type_info function of #GTypePluginClass.

type TypePluginUnuse 

type TypePluginUnuse func(uintptr)

The type of the @unuse_plugin function of #GTypePluginClass.

type TypePluginUse 

type TypePluginUse func(uintptr)

The type of the @use_plugin function of #GTypePluginClass, which gets called to increase the use count of @plugin.

type TypeQuery 

type TypeQuery struct {
	Type []interface{}

	TypeName uintptr

	ClassSize uint

	InstanceSize uint
}

A structure holding information for a specific type.

See also: g_type_query()

func (*TypeQuery) GoPointer 

func (x *TypeQuery) GoPointer() uintptr

type TypeValueTable 

type TypeValueTable struct {
	CollectFormat uintptr

	LcopyFormat uintptr
}

The #GTypeValueTable provides the functions required by the #GValue implementation, to serve as a container for values of a type.

func TypeValueTablePeek 

func TypeValueTablePeek(TypeVar []interface{}) *TypeValueTable

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 (*TypeValueTable) GoPointer 

func (x *TypeValueTable) GoPointer() uintptr

type VaClosureMarshal 

type VaClosureMarshal func(*Closure, *Value, *TypeInstance, []interface{}, uintptr, int, uintptr)

This is the signature of va_list marshaller functions, an optional marshaller that can be used in some situations to avoid marshalling the signal argument into GValues.

type Value 

type Value struct {
	GType []interface{}

	Data uintptr
}

An opaque structure used to hold different types of values.

The data within the structure has protected scope: it is accessible only to functions within a #GTypeValueTable structure, or implementations of the g_value_*() API. That is, code portions which implement new fundamental types.

#GValue users cannot make any assumptions about how data is stored within the 2 element @data union, and the @g_type member should only be accessed through the G_VALUE_TYPE() macro.

func (*Value) Copy 

func (x *Value) Copy(DestValueVar *Value)

Copies the value of @src_value into @dest_value.

func (*Value) DupBoxed 

func (x *Value) DupBoxed() uintptr

Get the contents of a %G_TYPE_BOXED derived #GValue. Upon getting, the boxed value is duplicated and needs to be later freed with g_boxed_free(), e.g. like: g_boxed_free (G_VALUE_TYPE (@value), return_value);

func (*Value) DupObject 

func (x *Value) DupObject() *Object

Get the contents of a %G_TYPE_OBJECT derived #GValue, increasing its reference count. If the contents of the #GValue are %NULL, then %NULL will be returned.

func (*Value) DupParam 

func (x *Value) DupParam() *ParamSpec

Get the contents of a %G_TYPE_PARAM #GValue, increasing its reference count.

func (*Value) DupString 

func (x *Value) DupString() string

Get a copy the contents of a %G_TYPE_STRING #GValue.

func (*Value) DupVariant 

func (x *Value) DupVariant() *glib.Variant

Get the contents of a variant #GValue, increasing its refcount. The returned #GVariant is never floating.

func (*Value) FitsPointer 

func (x *Value) FitsPointer() bool

Determines if @value will fit inside the size of a pointer value. This is an internal function introduced mainly for C marshallers.

func (*Value) GetBoolean 

func (x *Value) GetBoolean() bool

Get the contents of a %G_TYPE_BOOLEAN #GValue.

func (*Value) GetBoxed 

func (x *Value) GetBoxed() uintptr

Get the contents of a %G_TYPE_BOXED derived #GValue.

func (*Value) GetChar 

func (x *Value) GetChar() byte

Do not use this function; it is broken on platforms where the %char type is unsigned, such as ARM and PowerPC. See g_value_get_schar().

Get the contents of a %G_TYPE_CHAR #GValue.

func (*Value) GetDouble 

func (x *Value) GetDouble() float64

Get the contents of a %G_TYPE_DOUBLE #GValue.

func (*Value) GetEnum 

func (x *Value) GetEnum() int

Get the contents of a %G_TYPE_ENUM #GValue.

func (*Value) GetFlags 

func (x *Value) GetFlags() uint

Get the contents of a %G_TYPE_FLAGS #GValue.

func (*Value) GetFloat 

func (x *Value) GetFloat() float32

Get the contents of a %G_TYPE_FLOAT #GValue.

func (*Value) GetGtype 

func (x *Value) GetGtype() []interface{}

Get the contents of a %G_TYPE_GTYPE #GValue.

func (*Value) GetInt 

func (x *Value) GetInt() int

Get the contents of a %G_TYPE_INT #GValue.

func (*Value) GetInt64 

func (x *Value) GetInt64() int64

Get the contents of a %G_TYPE_INT64 #GValue.

func (*Value) GetLong 

func (x *Value) GetLong() int32

Get the contents of a %G_TYPE_LONG #GValue.

func (*Value) GetObject 

func (x *Value) GetObject() *Object

Get the contents of a %G_TYPE_OBJECT derived #GValue.

func (*Value) GetParam 

func (x *Value) GetParam() *ParamSpec

Get the contents of a %G_TYPE_PARAM #GValue.

func (*Value) GetPointer 

func (x *Value) GetPointer() uintptr

Get the contents of a pointer #GValue.

func (*Value) GetSchar 

func (x *Value) GetSchar() int8

Get the contents of a %G_TYPE_CHAR #GValue.

func (*Value) GetString 

func (x *Value) GetString() string

Get the contents of a %G_TYPE_STRING #GValue.

func (*Value) GetUchar 

func (x *Value) GetUchar() byte

Get the contents of a %G_TYPE_UCHAR #GValue.

func (*Value) GetUint 

func (x *Value) GetUint() uint

Get the contents of a %G_TYPE_UINT #GValue.

func (*Value) GetUint64 

func (x *Value) GetUint64() uint64

Get the contents of a %G_TYPE_UINT64 #GValue.

func (*Value) GetUlong 

func (x *Value) GetUlong() uint32

Get the contents of a %G_TYPE_ULONG #GValue.

func (*Value) GetVariant 

func (x *Value) GetVariant() *glib.Variant

Get the contents of a variant #GValue.

func (*Value) GoPointer 

func (x *Value) GoPointer() uintptr

func (*Value) Init 

func (x *Value) Init(GTypeVar []interface{}) *Value

Initializes @value with the default value of @type.

func (*Value) InitFromInstance 

func (x *Value) InitFromInstance(InstanceVar *TypeInstance)

Initializes and sets @value from an instantiatable type via the value_table's collect_value() function.

Note: The @value will be initialised with the exact type of @instance. If you wish to set the @value's type to a different GType (such as a parent class GType), you need to manually call g_value_init() and g_value_set_instance().

func (*Value) PeekPointer 

func (x *Value) PeekPointer() uintptr

Returns the value contents as pointer. This function asserts that g_value_fits_pointer() returned %TRUE for the passed in value. This is an internal function introduced mainly for C marshallers.

func (*Value) Reset 

func (x *Value) Reset() *Value

Clears the current value in @value and resets it to the default value (as if the value had just been initialized).

func (*Value) SetBoolean 

func (x *Value) SetBoolean(VBooleanVar bool)

Set the contents of a %G_TYPE_BOOLEAN #GValue to @v_boolean.

func (*Value) SetBoxed 

func (x *Value) SetBoxed(VBoxedVar uintptr)

Set the contents of a %G_TYPE_BOXED derived #GValue to @v_boxed.

func (*Value) SetBoxedTakeOwnership 

func (x *Value) SetBoxedTakeOwnership(VBoxedVar uintptr)

This is an internal function introduced mainly for C marshallers.

func (*Value) SetChar 

func (x *Value) SetChar(VCharVar byte)

Set the contents of a %G_TYPE_CHAR #GValue to @v_char.

func (*Value) SetDouble 

func (x *Value) SetDouble(VDoubleVar float64)

Set the contents of a %G_TYPE_DOUBLE #GValue to @v_double.

func (*Value) SetEnum 

func (x *Value) SetEnum(VEnumVar int)

Set the contents of a %G_TYPE_ENUM #GValue to @v_enum.

func (*Value) SetFlags 

func (x *Value) SetFlags(VFlagsVar uint)

Set the contents of a %G_TYPE_FLAGS #GValue to @v_flags.

func (*Value) SetFloat 

func (x *Value) SetFloat(VFloatVar float32)

Set the contents of a %G_TYPE_FLOAT #GValue to @v_float.

func (*Value) SetGtype 

func (x *Value) SetGtype(VGtypeVar []interface{})

Set the contents of a %G_TYPE_GTYPE #GValue to @v_gtype.

func (*Value) SetInstance 

func (x *Value) SetInstance(InstanceVar uintptr)

Sets @value from an instantiatable type via the value_table's collect_value() function.

func (*Value) SetInt 

func (x *Value) SetInt(VIntVar int)

Set the contents of a %G_TYPE_INT #GValue to @v_int.

func (*Value) SetInt64 

func (x *Value) SetInt64(VInt64Var int64)

Set the contents of a %G_TYPE_INT64 #GValue to @v_int64.

func (*Value) SetInternedString 

func (x *Value) SetInternedString(VStringVar string)

Set the contents of a %G_TYPE_STRING #GValue to @v_string. The string is assumed to be static and interned (canonical, for example from g_intern_string()), and is thus not duplicated when setting the #GValue.

func (*Value) SetLong 

func (x *Value) SetLong(VLongVar int32)

Set the contents of a %G_TYPE_LONG #GValue to @v_long.

func (*Value) SetObject 

func (x *Value) SetObject(VObjectVar *Object)

Set the contents of a %G_TYPE_OBJECT derived #GValue to @v_object.

g_value_set_object() increases the reference count of @v_object (the #GValue holds a reference to @v_object). If you do not wish to increase the reference count of the object (i.e. you wish to pass your current reference to the #GValue because you no longer need it), use g_value_take_object() instead.

It is important that your #GValue holds a reference to @v_object (either its own, or one it has taken) to ensure that the object won't be destroyed while the #GValue still exists).

func (*Value) SetObjectTakeOwnership 

func (x *Value) SetObjectTakeOwnership(VObjectVar uintptr)

This is an internal function introduced mainly for C marshallers.

func (*Value) SetParam 

func (x *Value) SetParam(ParamVar *ParamSpec)

Set the contents of a %G_TYPE_PARAM #GValue to @param.

func (*Value) SetParamTakeOwnership 

func (x *Value) SetParamTakeOwnership(ParamVar *ParamSpec)

This is an internal function introduced mainly for C marshallers.

func (*Value) SetPointer 

func (x *Value) SetPointer(VPointerVar uintptr)

Set the contents of a pointer #GValue to @v_pointer.

func (*Value) SetSchar 

func (x *Value) SetSchar(VCharVar int8)

Set the contents of a %G_TYPE_CHAR #GValue to @v_char.

func (*Value) SetStaticBoxed 

func (x *Value) SetStaticBoxed(VBoxedVar uintptr)

Set the contents of a %G_TYPE_BOXED derived #GValue to @v_boxed.

The boxed value is assumed to be static, and is thus not duplicated when setting the #GValue.

func (*Value) SetStaticString 

func (x *Value) SetStaticString(VStringVar string)

Set the contents of a %G_TYPE_STRING #GValue to @v_string. The string is assumed to be static, and is thus not duplicated when setting the #GValue.

If the the string is a canonical string, using g_value_set_interned_string() is more appropriate.

func (*Value) SetString 

func (x *Value) SetString(VStringVar string)

Set the contents of a %G_TYPE_STRING #GValue to a copy of @v_string.

func (*Value) SetStringTakeOwnership 

func (x *Value) SetStringTakeOwnership(VStringVar string)

This is an internal function introduced mainly for C marshallers.

func (*Value) SetUchar 

func (x *Value) SetUchar(VUcharVar byte)

Set the contents of a %G_TYPE_UCHAR #GValue to @v_uchar.

func (*Value) SetUint 

func (x *Value) SetUint(VUintVar uint)

Set the contents of a %G_TYPE_UINT #GValue to @v_uint.

func (*Value) SetUint64 

func (x *Value) SetUint64(VUint64Var uint64)

Set the contents of a %G_TYPE_UINT64 #GValue to @v_uint64.

func (*Value) SetUlong 

func (x *Value) SetUlong(VUlongVar uint32)

Set the contents of a %G_TYPE_ULONG #GValue to @v_ulong.

func (*Value) SetVariant 

func (x *Value) SetVariant(VariantVar *glib.Variant)

Set the contents of a variant #GValue to @variant. If the variant is floating, it is consumed.

func (*Value) TakeBoxed 

func (x *Value) TakeBoxed(VBoxedVar uintptr)

Sets the contents of a %G_TYPE_BOXED derived #GValue to @v_boxed and takes over the ownership of the caller’s reference to @v_boxed; the caller doesn’t have to unref it any more.

func (*Value) TakeObject 

func (x *Value) TakeObject(VObjectVar uintptr)

Sets the contents of a %G_TYPE_OBJECT derived #GValue to @v_object and takes over the ownership of the caller’s reference to @v_object; the caller doesn’t have to unref it any more (i.e. the reference count of the object is not increased).

If you want the #GValue to hold its own reference to @v_object, use g_value_set_object() instead.

func (*Value) TakeParam 

func (x *Value) TakeParam(ParamVar *ParamSpec)

Sets the contents of a %G_TYPE_PARAM #GValue to @param and takes over the ownership of the caller’s reference to @param; the caller doesn’t have to unref it any more.

func (*Value) TakeString 

func (x *Value) TakeString(VStringVar string)

Sets the contents of a %G_TYPE_STRING #GValue to @v_string.

func (*Value) TakeVariant 

func (x *Value) TakeVariant(VariantVar *glib.Variant)

Set the contents of a variant #GValue to @variant, and takes over the ownership of the caller's reference to @variant; the caller doesn't have to unref it any more (i.e. the reference count of the variant is not increased).

If @variant was floating then its floating reference is converted to a hard reference.

If you want the #GValue to hold its own reference to @variant, use g_value_set_variant() instead.

This is an internal function introduced mainly for C marshallers.

func (*Value) Transform 

func (x *Value) Transform(DestValueVar *Value) bool

Tries to cast the contents of @src_value into a type appropriate to store in @dest_value, e.g. to transform a %G_TYPE_INT value into a %G_TYPE_FLOAT value. Performing transformations between value types might incur precision lossage. Especially transformations into strings might reveal seemingly arbitrary results and shouldn't be relied upon for production code (such as rcfile value or object property serialization).

func (*Value) Unset 

func (x *Value) Unset()

Clears the current value in @value (if any) and "unsets" the type, this releases all resources associated with this GValue. An unset value is the same as an uninitialized (zero-filled) #GValue structure.

type ValueArray 

type ValueArray struct {
	NValues uint

	Values *Value

	NPrealloced uint
}

A #GValueArray contains an array of #GValue elements.

func NewValueArray 

func NewValueArray(NPreallocedVar uint) *ValueArray

Allocate and initialize a new #GValueArray, optionally preserve space for @n_prealloced elements. New arrays always contain 0 elements, regardless of the value of @n_prealloced.

func (*ValueArray) Append 

func (x *ValueArray) Append(ValueVar *Value) *ValueArray

Insert a copy of @value as last element of @value_array. If @value is %NULL, an uninitialized value is appended.

func (*ValueArray) Copy 

func (x *ValueArray) Copy() *ValueArray

Construct an exact copy of a #GValueArray by duplicating all its contents.

func (*ValueArray) Free 

func (x *ValueArray) Free()

Free a #GValueArray including its contents.

func (*ValueArray) GetNth 

func (x *ValueArray) GetNth(IndexVar uint) *Value

Return a pointer to the value at @index_ containd in @value_array.

func (*ValueArray) GoPointer 

func (x *ValueArray) GoPointer() uintptr

func (*ValueArray) Insert 

func (x *ValueArray) Insert(IndexVar uint, ValueVar *Value) *ValueArray

Insert a copy of @value at specified position into @value_array. If @value is %NULL, an uninitialized value is inserted.

func (*ValueArray) Prepend 

func (x *ValueArray) Prepend(ValueVar *Value) *ValueArray

Insert a copy of @value as first element of @value_array. If @value is %NULL, an uninitialized value is prepended.

func (*ValueArray) Remove 

func (x *ValueArray) Remove(IndexVar uint) *ValueArray

Remove the value at position @index_ from @value_array.

func (*ValueArray) Sort 

func (x *ValueArray) Sort(CompareFuncVar *glib.CompareFunc) *ValueArray

Sort @value_array using @compare_func to compare the elements according to the semantics of #GCompareFunc.

The current implementation uses the same sorting algorithm as standard C qsort() function.

func (*ValueArray) SortWithData 

func (x *ValueArray) SortWithData(CompareFuncVar *glib.CompareDataFunc, UserDataVar uintptr) *ValueArray

Sort @value_array using @compare_func to compare the elements according to the semantics of #GCompareDataFunc.

The current implementation uses the same sorting algorithm as standard C qsort() function.

type ValueDataUnion 

type ValueDataUnion = uintptr

type ValueTransform 

type ValueTransform func(*Value, *Value)

The type of value transformation functions which can be registered with g_value_register_transform_func().

@dest_value will be initialized to the correct destination type.

type WeakNotify 

type WeakNotify func(uintptr, uintptr)

A #GWeakNotify function can be added to an object as a callback that gets triggered when the object is finalized.

Since the object is already being disposed when the #GWeakNotify is called, there's not much you could do with the object, apart from e.g. using its address as hash-index or the like.

In particular, this means it’s invalid to call g_object_ref(), g_weak_ref_init(), g_weak_ref_set(), g_object_add_toggle_ref(), g_object_weak_ref(), g_object_add_weak_pointer() or any function which calls them on the object from this callback.

type WeakRef 

type WeakRef struct {
}

A structure containing a weak reference to a #GObject.

A `GWeakRef` can either be empty (i.e. point to %NULL), or point to an object for as long as at least one "strong" reference to that object exists. Before the object's #GObjectClass.dispose method is called, every #GWeakRef associated with becomes empty (i.e. points to %NULL).

Like #GValue, #GWeakRef can be statically allocated, stack- or heap-allocated, or embedded in larger structures.

Unlike g_object_weak_ref() and g_object_add_weak_pointer(), this weak reference is thread-safe: converting a weak pointer to a reference is atomic with respect to invalidation of weak pointers to destroyed objects.

If the object's #GObjectClass.dispose method results in additional references to the object being held (‘re-referencing’), any #GWeakRefs taken before it was disposed will continue to point to %NULL. Any #GWeakRefs taken during disposal and after re-referencing, or after disposal has returned due to the re-referencing, will continue to point to the object until its refcount goes back to zero, at which point they too will be invalidated.

It is invalid to take a #GWeakRef on an object during #GObjectClass.dispose without first having or creating a strong reference to the object.

func (*WeakRef) Clear 

func (x *WeakRef) Clear()

Frees resources associated with a non-statically-allocated #GWeakRef. After this call, the #GWeakRef is left in an undefined state.

You should only call this on a #GWeakRef that previously had g_weak_ref_init() called on it.

func (*WeakRef) Get 

func (x *WeakRef) Get() *Object

If @weak_ref is not empty, atomically acquire a strong reference to the object it points to, and return that reference.

This function is needed because of the potential race between taking the pointer value and g_object_ref() on it, if the object was losing its last reference at the same time in a different thread.

The caller should release the resulting reference in the usual way, by using g_object_unref().

func (*WeakRef) GoPointer 

func (x *WeakRef) GoPointer() uintptr

func (*WeakRef) Init 

func (x *WeakRef) Init(ObjectVar *Object)

Initialise a non-statically-allocated #GWeakRef.

This function also calls g_weak_ref_set() with @object on the freshly-initialised weak reference.

This function should always be matched with a call to g_weak_ref_clear(). It is not necessary to use this function for a #GWeakRef in static storage because it will already be properly initialised. Just use g_weak_ref_set() directly.

func (*WeakRef) Set 

func (x *WeakRef) Set(ObjectVar *Object)

Change the object to which @weak_ref points, or set it to %NULL.

You must own a strong reference on @object while calling this function.

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.