diff options
Diffstat (limited to 'bindings/lazgobject2.pas')
| -rw-r--r-- | bindings/lazgobject2.pas | 2765 |
1 files changed, 2765 insertions, 0 deletions
diff --git a/bindings/lazgobject2.pas b/bindings/lazgobject2.pas new file mode 100644 index 0000000..8d561d7 --- /dev/null +++ b/bindings/lazgobject2.pas @@ -0,0 +1,2765 @@ +{ This is an autogenerated unit using gobject introspection (gir2pascal). Do not Edit. } +unit LazGObject2; + +{$MODE OBJFPC}{$H+} + +{$PACKRECORDS C} +{$MODESWITCH DUPLICATELOCALS+} + +{$ifdef Unix} +{$LINKLIB libgobject-2.0.so.0} +{$endif} +{$WARN 3031 off : Values in enumeration types have to be ascending} +interface +uses + CTypes, LazGLib2; + +const + {$ifdef MsWindows} + LazGObject2_library = 'libgobject-2.0.so.dll'; + {$else} + LazGObject2_library = 'libgobject-2.0.so.0'; + {$endif} + + G_PARAM_MASK = 255; + G_PARAM_STATIC_STRINGS = 224; + G_PARAM_USER_SHIFT = 8; + G_SIGNAL_FLAGS_MASK = 511; + G_SIGNAL_MATCH_MASK = 63; + G_TYPE_FLAG_RESERVED_ID_BIT = 1; + G_TYPE_FUNDAMENTAL_MAX = 255; + G_TYPE_FUNDAMENTAL_SHIFT = 2; + G_TYPE_RESERVED_BSE_FIRST = 32; + G_TYPE_RESERVED_BSE_LAST = 48; + G_TYPE_RESERVED_GLIB_FIRST = 22; + G_TYPE_RESERVED_GLIB_LAST = 31; + G_TYPE_RESERVED_USER_FIRST = 49; + G_VALUE_INTERNED_STRING = 268435456; + G_VALUE_NOCOPY_CONTENTS = 134217728; +type + TGBindingFlagsIdx = ( + TGBindingFlagsIdxMinValue = 0, + G_BINDING_BIDIRECTIONAL = 0, + G_BINDING_SYNC_CREATE = 1, + G_BINDING_INVERT_BOOLEAN = 2, + TGBindingFlagsIdxMaxValue = 31 + ); + TGBindingFlags = Set of TGBindingFlagsIdx; +const + G_BINDING_DEFAULT = []; {0 = $00000000} + +type + TGConnectFlagsIdx = ( + TGConnectFlagsIdxMinValue = 0, + G_CONNECT_AFTER = 0, + G_CONNECT_SWAPPED = 1, + TGConnectFlagsIdxMaxValue = 31 + ); + TGConnectFlags = Set of TGConnectFlagsIdx; +const + G_CONNECT_DEFAULT = []; {0 = $00000000} + +type + TGParamFlagsIdx = ( + TGParamFlagsIdxMinValue = 0, + G_PARAM_READABLE = 0, + G_PARAM_WRITABLE = 1, + G_PARAM_CONSTRUCT = 2, + G_PARAM_CONSTRUCT_ONLY = 3, + G_PARAM_LAX_VALIDATION = 4, + G_PARAM_PRIVATE = 5, + G_PARAM_STATIC_NAME = 5, + G_PARAM_STATIC_NICK = 6, + G_PARAM_STATIC_BLURB = 7, + G_PARAM_EXPLICIT_NOTIFY = 30, + G_PARAM_DEPRECATED = 63, + TGParamFlagsIdxMaxValue = 31 + ); + TGParamFlags = Set of TGParamFlagsIdx; +const + G_PARAM_READWRITE = [ + G_PARAM_READABLE, + G_PARAM_WRITABLE + ]; {3 = $00000003} + +type + TGSignalFlagsIdx = ( + TGSignalFlagsIdxMinValue = 0, + G_SIGNAL_RUN_FIRST = 0, + G_SIGNAL_RUN_LAST = 1, + G_SIGNAL_RUN_CLEANUP = 2, + G_SIGNAL_NO_RECURSE = 3, + G_SIGNAL_DETAILED = 4, + G_SIGNAL_ACTION = 5, + G_SIGNAL_NO_HOOKS = 6, + G_SIGNAL_MUST_COLLECT = 7, + G_SIGNAL_DEPRECATED = 8, + G_SIGNAL_ACCUMULATOR_FIRST_RUN = 17, + TGSignalFlagsIdxMaxValue = 31 + ); + TGSignalFlags = Set of TGSignalFlagsIdx; + TGSignalMatchTypeIdx = ( + TGSignalMatchTypeIdxMinValue = 0, + G_SIGNAL_MATCH_ID = 0, + G_SIGNAL_MATCH_DETAIL = 1, + G_SIGNAL_MATCH_CLOSURE = 2, + G_SIGNAL_MATCH_FUNC = 3, + G_SIGNAL_MATCH_DATA = 4, + G_SIGNAL_MATCH_UNBLOCKED = 5, + TGSignalMatchTypeIdxMaxValue = 31 + ); + TGSignalMatchType = Set of TGSignalMatchTypeIdx; + TGTypeDebugFlagsIdx = ( + TGTypeDebugFlagsIdxMinValue = 0, + G_TYPE_DEBUG_OBJECTS = 0, + G_TYPE_DEBUG_SIGNALS = 1, + G_TYPE_DEBUG_INSTANCE_COUNT = 2, + TGTypeDebugFlagsIdxMaxValue = 31 + ); + TGTypeDebugFlags = Set of TGTypeDebugFlagsIdx; +const + G_TYPE_DEBUG_NONE = []; {0 = $00000000} + + G_TYPE_DEBUG_MASK = [ + G_TYPE_DEBUG_OBJECTS, + G_TYPE_DEBUG_SIGNALS, + G_TYPE_DEBUG_INSTANCE_COUNT + ]; {7 = $00000007} + +type + TGTypeFlagsIdx = ( + TGTypeFlagsIdxMinValue = 0, + G_TYPE_FLAG_ABSTRACT = 4, + G_TYPE_FLAG_VALUE_ABSTRACT = 5, + G_TYPE_FLAG_FINAL = 6, + TGTypeFlagsIdxMaxValue = 31 + ); + TGTypeFlags = Set of TGTypeFlagsIdx; +const + G_TYPE_FLAG_NONE = []; {0 = $00000000} + +type + TGTypeFundamentalFlagsIdx = ( + TGTypeFundamentalFlagsIdxMinValue = 0, + G_TYPE_FLAG_CLASSED = 0, + G_TYPE_FLAG_INSTANTIATABLE = 1, + G_TYPE_FLAG_DERIVABLE = 2, + G_TYPE_FLAG_DEEP_DERIVABLE = 3, + TGTypeFundamentalFlagsIdxMaxValue = 31 + ); + TGTypeFundamentalFlags = Set of TGTypeFundamentalFlagsIdx; +type + + + { TGClosure } + PPGClosure = ^PGClosure; + PGClosure = ^TGClosure; + + + { TGParameter } + PPGParameter = ^PGParameter; + PGParameter = ^TGParameter; + + + { TGValue } + PPPGValue = ^PPGValue; + PPGValue = ^PGValue; + PGValue = ^TGValue; + TGClosureMarshal = procedure(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; user_data: gpointer); cdecl; + + + { TGSignalCMarshaller } + PPGSignalCMarshaller = ^PGSignalCMarshaller; + PGSignalCMarshaller = ^TGSignalCMarshaller; + TGSignalCMarshaller = TGClosureMarshal; + + + { TGTypeInstance } + PPGTypeInstance = ^PGTypeInstance; + PGTypeInstance = ^TGTypeInstance; + + + { TGTypeClass } + PPGTypeClass = ^PGTypeClass; + PGTypeClass = ^TGTypeClass; + TGTypeInstance = object + g_class: PGTypeClass; + function get_private(private_type: TGType): gpointer; cdecl; inline; + end; + TGVaClosureMarshal = procedure(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; + + + { TGSignalCVaMarshaller } + PPGSignalCVaMarshaller = ^PGSignalCVaMarshaller; + PGSignalCVaMarshaller = ^TGSignalCVaMarshaller; + TGSignalCVaMarshaller = TGVaClosureMarshal; + + + { TGType } + PPGType = ^PGType; + PGType = ^TGType; + TGType = gsize; + TGTypeClass = object + g_type: TGType; + function get_instance_private_offset: gint; cdecl; inline; + function get_private(private_type: TGType): gpointer; cdecl; inline; + function peek_parent: PGTypeClass; cdecl; inline; + procedure unref; cdecl; inline; + procedure unref_uncached; cdecl; inline; + procedure adjust_private_offset(g_class: gpointer; private_size_or_offset: Pgint); cdecl; inline; static; + function peek(type_: TGType): PGTypeClass; cdecl; inline; static; + function peek_static(type_: TGType): PGTypeClass; cdecl; inline; static; + function ref(type_: TGType): PGTypeClass; cdecl; inline; static; + end; + TGBaseFinalizeFunc = procedure(g_class: PGTypeClass); cdecl; + TGBaseInitFunc = procedure(g_class: PGTypeClass); cdecl; + + + { TGObject } + PPPGObject = ^PPGObject; + PPGObject = ^PGObject; + PGObject = ^TGObject; + + + { TGParamSpec } + PPGParamSpec = ^PGParamSpec; + PGParamSpec = ^TGParamSpec; + + + { TGTypeInterface } + PPGTypeInterface = ^PGTypeInterface; + PGTypeInterface = ^TGTypeInterface; + + + { TGTypePlugin } + PPGTypePlugin = ^PGTypePlugin; + PGTypePlugin = ^TGTypePlugin; + TGTypeInterface = object + g_type: TGType; + g_instance_type: TGType; + function peek_parent: PGTypeInterface; cdecl; inline; + procedure add_prerequisite(interface_type: TGType; prerequisite_type: TGType); cdecl; inline; static; + function get_plugin(instance_type: TGType; interface_type: TGType): PGTypePlugin; cdecl; inline; static; + function peek(instance_class: PGTypeClass; iface_type: TGType): PGTypeInterface; cdecl; inline; static; + function prerequisites(interface_type: TGType; n_prerequisites: Pguint): PGType; cdecl; inline; static; + end; + + + { TGToggleNotify } + PPGToggleNotify = ^PGToggleNotify; + PGToggleNotify = ^TGToggleNotify; + TGToggleNotify = procedure(data: gpointer; object_: PGObject; is_last_ref: gboolean); cdecl; + + + { TGBinding } + PPGBinding = ^PGBinding; + PGBinding = ^TGBinding; + + + { TGBindingFlags } + PPGBindingFlags = ^PGBindingFlags; + PGBindingFlags = ^TGBindingFlags; + + + { TGBindingTransformFunc } + PPGBindingTransformFunc = ^PGBindingTransformFunc; + PGBindingTransformFunc = ^TGBindingTransformFunc; + TGBindingTransformFunc = function(binding: PGBinding; from_value: PGValue; to_value: PGValue; user_data: gpointer): gboolean; cdecl; + + + { TGWeakNotify } + PPGWeakNotify = ^PGWeakNotify; + PGWeakNotify = ^TGWeakNotify; + TGWeakNotify = procedure(data: gpointer; where_the_object_was: PGObject); cdecl; + TGObject = object + g_type_instance: TGTypeInstance; + ref_count: guint; + qdata: PGData; + //function new(object_type: TGType; first_property_name: Pgchar; args: array of const): PGObject; cdecl; inline; static; + //function new_valist(object_type: TGType; first_property_name: Pgchar; var_args: Tva_list): PGObject; cdecl; inline; static; + function newv(object_type: TGType; n_parameters: guint; parameters: PGParameter): PGObject; cdecl; inline; static; + function new_with_properties(object_type: TGType; n_properties: guint; names: PPgchar; values: PGValue): PGObject; cdecl; inline; static; + function compat_control(what: gsize; data: gpointer): gsize; cdecl; inline; static; + function interface_find_property(g_iface: PGTypeInterface; property_name: Pgchar): PGParamSpec; cdecl; inline; static; + procedure interface_install_property(g_iface: PGTypeInterface; pspec: PGParamSpec); cdecl; inline; static; + function interface_list_properties(g_iface: PGTypeInterface; n_properties_p: Pguint): PPGParamSpec; cdecl; inline; static; + procedure add_toggle_ref(notify: TGToggleNotify; data: gpointer); cdecl; inline; + procedure add_weak_pointer(weak_pointer_location: Pgpointer); cdecl; inline; + function bind_property(source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags): PGBinding; cdecl; inline; + function bind_property_full(source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags; transform_to: TGBindingTransformFunc; transform_from: TGBindingTransformFunc; user_data: gpointer; notify: TGDestroyNotify): PGBinding; cdecl; inline; + function bind_property_with_closures(source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags; transform_to: PGClosure; transform_from: PGClosure): PGBinding; cdecl; inline; + //function connect(signal_spec: Pgchar; args: array of const): PGObject; cdecl; inline; + //procedure disconnect(signal_spec: Pgchar; args: array of const); cdecl; inline; + function dup_data(key: Pgchar; dup_func: TGDuplicateFunc; user_data: gpointer): gpointer; cdecl; inline; + function dup_qdata(quark: TGQuark; dup_func: TGDuplicateFunc; user_data: gpointer): gpointer; cdecl; inline; + procedure force_floating; cdecl; inline; + procedure freeze_notify; cdecl; inline; + //procedure get(first_property_name: Pgchar; args: array of const); cdecl; inline; + function get_data(key: Pgchar): gpointer; cdecl; inline; + procedure get_property(property_name: Pgchar; value: PGValue); cdecl; inline; + function get_qdata(quark: TGQuark): gpointer; cdecl; inline; + //procedure get_valist(first_property_name: Pgchar; var_args: Tva_list); cdecl; inline; + procedure getv(n_properties: guint; names: PPgchar; values: PGValue); cdecl; inline; + function is_floating: gboolean; cdecl; inline; + procedure notify(property_name: Pgchar); cdecl; inline; + procedure notify_by_pspec(pspec: PGParamSpec); cdecl; inline; + function ref: PGObject; cdecl; inline; + function ref_sink: PGObject; cdecl; inline; + procedure remove_toggle_ref(notify: TGToggleNotify; data: gpointer); cdecl; inline; + procedure remove_weak_pointer(weak_pointer_location: Pgpointer); cdecl; inline; + function replace_data(key: Pgchar; oldval: gpointer; newval: gpointer; destroy_: TGDestroyNotify; old_destroy: PGDestroyNotify): gboolean; cdecl; inline; + function replace_qdata(quark: TGQuark; oldval: gpointer; newval: gpointer; destroy_: TGDestroyNotify; old_destroy: PGDestroyNotify): gboolean; cdecl; inline; + procedure run_dispose; cdecl; inline; + //procedure set_(first_property_name: Pgchar; args: array of const); cdecl; inline; + procedure set_data(key: Pgchar; data: gpointer); cdecl; inline; + procedure set_data_full(key: Pgchar; data: gpointer; destroy_: TGDestroyNotify); cdecl; inline; + procedure set_property(property_name: Pgchar; value: PGValue); cdecl; inline; + procedure set_qdata(quark: TGQuark; data: gpointer); cdecl; inline; + procedure set_qdata_full(quark: TGQuark; data: gpointer; destroy_: TGDestroyNotify); cdecl; inline; + //procedure set_valist(first_property_name: Pgchar; var_args: Tva_list); cdecl; inline; + procedure setv(n_properties: guint; names: PPgchar; values: PGValue); cdecl; inline; + function steal_data(key: Pgchar): gpointer; cdecl; inline; + function steal_qdata(quark: TGQuark): gpointer; cdecl; inline; + procedure thaw_notify; cdecl; inline; + procedure unref; cdecl; inline; + procedure watch_closure(closure: PGClosure); cdecl; inline; + procedure weak_ref(notify: TGWeakNotify; data: gpointer); cdecl; inline; + procedure weak_unref(notify: TGWeakNotify; data: gpointer); cdecl; inline; + end; + TGBinding = object(TGObject) + function get_flags: TGBindingFlags; cdecl; inline; + function get_source_property: Pgchar; cdecl; inline; + function get_target_property: Pgchar; cdecl; inline; + procedure unbind; cdecl; inline; + property flags: TGBindingFlags read get_flags { property is writeable but setter not declared } ; + //property source: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_source { property is writeable but setter not declared } ; + property source_property: Pgchar read get_source_property { property is writeable but setter not declared } ; + //property target: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_target { property is writeable but setter not declared } ; + property target_property: Pgchar read get_target_property { property is writeable but setter not declared } ; + end; + + + { TGBindingGroup } + PPGBindingGroup = ^PGBindingGroup; + PGBindingGroup = ^TGBindingGroup; + TGBindingGroup = object(TGObject) + //property source: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_source { property is writeable but setter not declared } ; + end; + + + { TGClosureNotify } + PPGClosureNotify = ^PGClosureNotify; + PGClosureNotify = ^TGClosureNotify; + TGClosureNotify = procedure(data: gpointer; closure: PGClosure); cdecl; + + + { TGClosureMarshal } + PPGClosureMarshal = ^PGClosureMarshal; + PGClosureMarshal = ^TGClosureMarshal; + TGClosureBitfield0 = bitpacked record + ref_count: guint15 { changed from guint to accomodate 15 bitsize requirement }; + meta_marshal_nouse: guint1 { changed from guint to accomodate 1 bitsize requirement }; + n_guards: guint1 { changed from guint to accomodate 1 bitsize requirement }; + n_fnotifiers: guint2 { changed from guint to accomodate 2 bitsize requirement }; + n_inotifiers: guint8 { changed from guint to accomodate 8 bitsize requirement }; + in_inotify: guint1 { changed from guint to accomodate 1 bitsize requirement }; + floating: guint1 { changed from guint to accomodate 1 bitsize requirement }; + derivative_flag: guint1 { changed from guint to accomodate 1 bitsize requirement }; + in_marshal: guint1 { changed from guint to accomodate 1 bitsize requirement }; + is_invalid: guint1 { changed from guint to accomodate 1 bitsize requirement }; + end; + + + + { TGClosureNotifyData } + PPGClosureNotifyData = ^PGClosureNotifyData; + PGClosureNotifyData = ^TGClosureNotifyData; + TGClosure = object + Bitfield0 : TGClosureBitfield0; { auto generated type } + marshal: procedure(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; + data: gpointer; + notifiers: PGClosureNotifyData; + function new_object(sizeof_closure: guint; object_: PGObject): PGClosure; cdecl; inline; static; + function new_simple(sizeof_closure: guint; data: gpointer): PGClosure; cdecl; inline; static; + procedure add_finalize_notifier(notify_data: gpointer; notify_func: TGClosureNotify); cdecl; inline; + procedure add_invalidate_notifier(notify_data: gpointer; notify_func: TGClosureNotify); cdecl; inline; + procedure add_marshal_guards(pre_marshal_data: gpointer; pre_marshal_notify: TGClosureNotify; post_marshal_data: gpointer; post_marshal_notify: TGClosureNotify); cdecl; inline; + procedure invalidate; cdecl; inline; + procedure invoke(return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer); cdecl; inline; + function ref: PGClosure; cdecl; inline; + procedure remove_finalize_notifier(notify_data: gpointer; notify_func: TGClosureNotify); cdecl; inline; + procedure remove_invalidate_notifier(notify_data: gpointer; notify_func: TGClosureNotify); cdecl; inline; + procedure set_marshal(marshal: TGClosureMarshal); cdecl; inline; + procedure set_meta_marshal(marshal_data: gpointer; meta_marshal: TGClosureMarshal); cdecl; inline; + procedure sink; cdecl; inline; + procedure unref; cdecl; inline; + end; + + + { TGValueTransform } + PPGValueTransform = ^PGValueTransform; + PGValueTransform = ^TGValueTransform; + TGValueTransform = procedure(src_value: PGValue; dest_value: PGValue); cdecl; + + + { T_Value__data__union } + PP_Value__data__union = ^P_Value__data__union; + P_Value__data__union = ^T_Value__data__union; + T_Value__data__union = record + case longint of + 0 : (v_int: gint); + 1 : (v_uint: guint); + 2 : (v_long: glong); + 3 : (v_ulong: gulong); + 4 : (v_int64: gint64); + 5 : (v_uint64: guint64); + 6 : (v_float: gfloat); + 7 : (v_double: gdouble); + 8 : (v_pointer: gpointer); + end; + + + TGValue = object + g_type: TGType; + data: array [0..1] of T_Value__data__union; + procedure copy(dest_value: PGValue); cdecl; inline; + function dup_boxed: gpointer; cdecl; inline; + function dup_object: PGObject; cdecl; inline; + function dup_param: PGParamSpec; cdecl; inline; + function dup_string: Pgchar; cdecl; inline; + function dup_variant: PGVariant; cdecl; inline; + function fits_pointer: gboolean; cdecl; inline; + function get_boolean: gboolean; cdecl; inline; + function get_boxed: gpointer; cdecl; inline; + function get_double: gdouble; cdecl; inline; + function get_enum: gint; cdecl; inline; + function get_flags: guint; cdecl; inline; + function get_float: gfloat; cdecl; inline; + function get_gtype: TGType; cdecl; inline; + function get_int: gint; cdecl; inline; + function get_int64: gint64; cdecl; inline; + function get_long: glong; cdecl; inline; + function get_object: PGObject; cdecl; inline; + function get_param: PGParamSpec; cdecl; inline; + function get_pointer: gpointer; cdecl; inline; + function get_schar: gint8; cdecl; inline; + function get_string: Pgchar; cdecl; inline; + function get_uchar: guint8; cdecl; inline; + function get_uint: guint; cdecl; inline; + function get_uint64: guint64; cdecl; inline; + function get_ulong: gulong; cdecl; inline; + function get_variant: PGVariant; cdecl; inline; + function init(g_type: TGType): PGValue; cdecl; inline; + procedure init_from_instance(instance: PGTypeInstance); cdecl; inline; + function peek_pointer: gpointer; cdecl; inline; + function reset: PGValue; cdecl; inline; + procedure set_boolean(v_boolean: gboolean); cdecl; inline; + procedure set_boxed(v_boxed: Pgpointer); cdecl; inline; + procedure set_double(v_double: gdouble); cdecl; inline; + procedure set_enum(v_enum: gint); cdecl; inline; + procedure set_flags(v_flags: guint); cdecl; inline; + procedure set_float(v_float: gfloat); cdecl; inline; + procedure set_gtype(v_gtype: TGType); cdecl; inline; + procedure set_instance(instance: gpointer); cdecl; inline; + procedure set_int(v_int: gint); cdecl; inline; + procedure set_int64(v_int64: gint64); cdecl; inline; + {$IFDEF USEGTK3LATESTBINDINGS} + procedure set_interned_string(v_string: Pgchar); cdecl; inline; + {$ENDIF} + procedure set_long(v_long: glong); cdecl; inline; + procedure set_object(v_object: PGObject); cdecl; inline; + procedure set_param(param: PGParamSpec); cdecl; inline; + procedure set_pointer(v_pointer: gpointer); cdecl; inline; + procedure set_schar(v_char: gint8); cdecl; inline; + procedure set_static_boxed(v_boxed: Pgpointer); cdecl; inline; + procedure set_static_string(v_string: Pgchar); cdecl; inline; + procedure set_string(v_string: Pgchar); cdecl; inline; + procedure set_uchar(v_uchar: guint8); cdecl; inline; + procedure set_uint(v_uint: guint); cdecl; inline; + procedure set_uint64(v_uint64: guint64); cdecl; inline; + procedure set_ulong(v_ulong: gulong); cdecl; inline; + procedure set_variant(variant: PGVariant); cdecl; inline; + procedure take_boxed(v_boxed: Pgpointer); cdecl; inline; + procedure take_object(v_object: gpointer); cdecl; inline; + procedure take_param(param: PGParamSpec); cdecl; inline; + procedure take_string(v_string: Pgchar); cdecl; inline; + procedure take_variant(variant: PGVariant); cdecl; inline; + function transform(dest_value: PGValue): gboolean; cdecl; inline; + procedure unset; cdecl; inline; + procedure register_transform_func(src_type: TGType; dest_type: TGType; transform_func: TGValueTransform); cdecl; inline; static; + function type_compatible(src_type: TGType; dest_type: TGType): gboolean; cdecl; inline; static; + function type_transformable(src_type: TGType; dest_type: TGType): gboolean; cdecl; inline; static; + procedure clear; inline; + end; + TGBoxedCopyFunc = function(boxed: gpointer): gpointer; cdecl; + TGBoxedFreeFunc = procedure(boxed: gpointer); cdecl; + TGCallback = procedure; cdecl; + + + { TGCClosure } + PPGCClosure = ^PGCClosure; + PGCClosure = ^TGCClosure; + + + { TGCallback } + PPGCallback = ^PGCallback; + PGCallback = ^TGCallback; + TGCClosure = object + closure: TGClosure; + callback: gpointer; + procedure marshal_BOOLEAN__BOXED_BOXED(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_BOOLEAN__BOXED_BOXEDv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_BOOLEAN__FLAGS(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_BOOLEAN__FLAGSv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_STRING__OBJECT_POINTER(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_STRING__OBJECT_POINTERv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_VOID__BOOLEAN(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_VOID__BOOLEANv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_VOID__BOXED(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_VOID__BOXEDv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_VOID__CHAR(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_VOID__CHARv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_VOID__DOUBLE(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_VOID__DOUBLEv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_VOID__ENUM(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_VOID__ENUMv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_VOID__FLAGS(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_VOID__FLAGSv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_VOID__FLOAT(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_VOID__FLOATv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_VOID__INT(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_VOID__INTv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_VOID__LONG(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_VOID__LONGv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_VOID__OBJECT(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_VOID__OBJECTv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_VOID__PARAM(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_VOID__PARAMv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_VOID__POINTER(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_VOID__POINTERv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_VOID__STRING(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_VOID__STRINGv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_VOID__UCHAR(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_VOID__UCHARv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_VOID__UINT(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + procedure marshal_VOID__UINT_POINTER(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_VOID__UINT_POINTERv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + //procedure marshal_VOID__UINTv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_VOID__ULONG(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_VOID__ULONGv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_VOID__VARIANT(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_VOID__VARIANTv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_VOID__VOID(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_VOID__VOIDv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + procedure marshal_generic(closure: PGClosure; return_gvalue: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static; + //procedure marshal_generic_va(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args_list: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static; + function new(callback_func: TGCallback; user_data: gpointer; destroy_data: TGClosureNotify): PGClosure; cdecl; inline; static; + function new_object(callback_func: TGCallback; object_: PGObject): PGClosure; cdecl; inline; static; + function new_object_swap(callback_func: TGCallback; object_: PGObject): PGClosure; cdecl; inline; static; + function new_swap(callback_func: TGCallback; user_data: gpointer; destroy_data: TGClosureNotify): PGClosure; cdecl; inline; static; + end; + TGClassFinalizeFunc = procedure(g_class: PGTypeClass; class_data: gpointer); cdecl; + TGClassInitFunc = procedure(g_class: PGTypeClass; class_data: gpointer); cdecl; + + TGClosureNotifyData = record + data: gpointer; + notify: TGClosureNotify; + end; + + + + + { TGConnectFlags } + PPGConnectFlags = ^PGConnectFlags; + PGConnectFlags = ^TGConnectFlags; + + + { TGEnumValue } + PPGEnumValue = ^PGEnumValue; + PGEnumValue = ^TGEnumValue; + + TGEnumValue = record + value: gint; + value_name: Pgchar; + value_nick: Pgchar; + end; + + + + + { TGEnumClass } + PPGEnumClass = ^PGEnumClass; + PGEnumClass = ^TGEnumClass; + + TGEnumClass = record + g_type_class: TGTypeClass; + minimum: gint; + maximum: gint; + n_values: guint; + values: PGEnumValue; + end; + + + + + { TGFlagsValue } + PPGFlagsValue = ^PGFlagsValue; + PGFlagsValue = ^TGFlagsValue; + + TGFlagsValue = record + value: guint; + value_name: Pgchar; + value_nick: Pgchar; + end; + + + + + { TGFlagsClass } + PPGFlagsClass = ^PGFlagsClass; + PGFlagsClass = ^TGFlagsClass; + + TGFlagsClass = record + g_type_class: TGTypeClass; + mask: guint; + n_values: guint; + values: PGFlagsValue; + end; + + + + + { TGInitiallyUnowned } + PPGInitiallyUnowned = ^PGInitiallyUnowned; + PGInitiallyUnowned = ^TGInitiallyUnowned; + TGInitiallyUnowned = object(TGObject) + end; + + + { TGObjectConstructParam } + PPGObjectConstructParam = ^PGObjectConstructParam; + PGObjectConstructParam = ^TGObjectConstructParam; + + TGObjectConstructParam = record + pspec: PGParamSpec; + value: PGValue; + end; + + + + + { TGParamFlags } + PPGParamFlags = ^PGParamFlags; + PGParamFlags = ^TGParamFlags; + TGParamSpec = object + g_type_instance: TGTypeInstance; + name: Pgchar; + flags: TGParamFlags; + value_type: TGType; + owner_type: TGType; + _nick: Pgchar; + _blurb: Pgchar; + qdata: PGData; + ref_count: guint; + param_id: guint; + function internal(param_type: TGType; name: Pgchar; nick: Pgchar; blurb: Pgchar; flags: TGParamFlags): PGParamSpec; cdecl; inline; static; + {$IFDEF USEGTK3LATESTBINDINGS} + function is_valid_name(name: Pgchar): gboolean; cdecl; inline; static; + {$ENDIF} + function get_blurb: Pgchar; cdecl; inline; + function get_default_value: PGValue; cdecl; inline; + function get_name: Pgchar; cdecl; inline; + function get_name_quark: TGQuark; cdecl; inline; + function get_nick: Pgchar; cdecl; inline; + function get_qdata(quark: TGQuark): gpointer; cdecl; inline; + function get_redirect_target: PGParamSpec; cdecl; inline; + function ref: PGParamSpec; cdecl; inline; + function ref_sink: PGParamSpec; cdecl; inline; + procedure set_qdata(quark: TGQuark; data: gpointer); cdecl; inline; + procedure set_qdata_full(quark: TGQuark; data: gpointer; destroy_: TGDestroyNotify); cdecl; inline; + procedure sink; cdecl; inline; + function steal_qdata(quark: TGQuark): gpointer; cdecl; inline; + procedure unref; cdecl; inline; + end; + + + { TGInitiallyUnownedClass } + PPGInitiallyUnownedClass = ^PGInitiallyUnownedClass; + PGInitiallyUnownedClass = ^TGInitiallyUnownedClass; + TGInitiallyUnownedClass = object + g_type_class: TGTypeClass; + construct_properties: PGSList; + constructor_: function(type_: TGType; n_construct_properties: guint; construct_properties: PGObjectConstructParam): PGObject; cdecl; + set_property: procedure(object_: PGObject; property_id: guint; value: PGValue; pspec: PGParamSpec); cdecl; + get_property: procedure(object_: PGObject; property_id: guint; value: PGValue; pspec: PGParamSpec); cdecl; + dispose: procedure(object_: PGObject); cdecl; + finalize: procedure(object_: PGObject); cdecl; + dispatch_properties_changed: procedure(object_: PGObject; n_pspecs: guint; pspecs: PPGParamSpec); cdecl; + notify: procedure(object_: PGObject; pspec: PGParamSpec); cdecl; + constructed: procedure(object_: PGObject); cdecl; + flags: gsize; + n_construct_properties: gsize; + pspecs: gpointer; + n_pspecs: gsize; + pdummy: array [0..2] of gpointer; + end; + TGInstanceInitFunc = procedure(instance: PGTypeInstance; g_class: PGTypeClass); cdecl; + TGInterfaceFinalizeFunc = procedure(g_iface: PGTypeInterface; iface_data: gpointer); cdecl; + TGInterfaceInitFunc = procedure(g_iface: PGTypeInterface; iface_data: gpointer); cdecl; + + + { TGInterfaceInfo } + PPGInterfaceInfo = ^PGInterfaceInfo; + PGInterfaceInfo = ^TGInterfaceInfo; + + + { TGInterfaceInitFunc } + PPGInterfaceInitFunc = ^PGInterfaceInitFunc; + PGInterfaceInitFunc = ^TGInterfaceInitFunc; + + + { TGInterfaceFinalizeFunc } + PPGInterfaceFinalizeFunc = ^PGInterfaceFinalizeFunc; + PGInterfaceFinalizeFunc = ^TGInterfaceFinalizeFunc; + + TGInterfaceInfo = record + interface_init: TGInterfaceInitFunc; + interface_finalize: TGInterfaceFinalizeFunc; + interface_data: gpointer; + end; + + + + + { TGParameter } + + TGParameter = record + name: Pgchar; + value: TGValue; + end; + + + + + { TGObjectClass } + PPGObjectClass = ^PGObjectClass; + PGObjectClass = ^TGObjectClass; + TGObjectClass = object + g_type_class: TGTypeClass; + construct_properties: PGSList; + constructor_: function(type_: TGType; n_construct_properties: guint; construct_properties: PGObjectConstructParam): PGObject; cdecl; + set_property: procedure(object_: PGObject; property_id: guint; value: PGValue; pspec: PGParamSpec); cdecl; + get_property: procedure(object_: PGObject; property_id: guint; value: PGValue; pspec: PGParamSpec); cdecl; + dispose: procedure(object_: PGObject); cdecl; + finalize: procedure(object_: PGObject); cdecl; + dispatch_properties_changed: procedure(object_: PGObject; n_pspecs: guint; pspecs: PPGParamSpec); cdecl; + notify: procedure(object_: PGObject; pspec: PGParamSpec); cdecl; + constructed: procedure(object_: PGObject); cdecl; + flags: gsize; + n_construct_properties: gsize; + pspecs: gpointer; + n_pspecs: gsize; + pdummy: array [0..2] of gpointer; + function find_property(property_name: Pgchar): PGParamSpec; cdecl; inline; + procedure install_properties(n_pspecs: guint; pspecs: PPGParamSpec); cdecl; inline; + procedure install_property(property_id: guint; pspec: PGParamSpec); cdecl; inline; + function list_properties(n_properties: Pguint): PPGParamSpec; cdecl; inline; + procedure override_property(property_id: guint; name: Pgchar); cdecl; inline; + end; + TGObjectFinalizeFunc = procedure(object_: PGObject); cdecl; + TGObjectGetPropertyFunc = procedure(object_: PGObject; property_id: guint; value: PGValue; pspec: PGParamSpec); cdecl; + TGObjectSetPropertyFunc = procedure(object_: PGObject; property_id: guint; value: PGValue; pspec: PGParamSpec); cdecl; + + + { TGParamSpecBoolean } + PPGParamSpecBoolean = ^PGParamSpecBoolean; + PGParamSpecBoolean = ^TGParamSpecBoolean; + TGParamSpecBoolean = object(TGParamSpec) + default_value: gboolean; + end; + + + { TGParamSpecBoxed } + PPGParamSpecBoxed = ^PGParamSpecBoxed; + PGParamSpecBoxed = ^TGParamSpecBoxed; + TGParamSpecBoxed = object(TGParamSpec) + end; + + + { TGParamSpecChar } + PPGParamSpecChar = ^PGParamSpecChar; + PGParamSpecChar = ^TGParamSpecChar; + TGParamSpecChar = object(TGParamSpec) + minimum: gint8; + maximum: gint8; + default_value: gint8; + end; + + + { TGParamSpecClass } + PPGParamSpecClass = ^PGParamSpecClass; + PGParamSpecClass = ^TGParamSpecClass; + TGParamSpecClass = object + g_type_class: TGTypeClass; + value_type: TGType; + finalize: procedure(pspec: PGParamSpec); cdecl; + value_set_default: procedure(pspec: PGParamSpec; value: PGValue); cdecl; + value_validate: function(pspec: PGParamSpec; value: PGValue): gboolean; cdecl; + values_cmp: function(pspec: PGParamSpec; value1: PGValue; value2: PGValue): gint; cdecl; + value_is_valid: function(pspec: PGParamSpec; value: PGValue): gboolean; cdecl; + dummy: array [0..2] of gpointer; + end; + + + { TGParamSpecDouble } + PPGParamSpecDouble = ^PGParamSpecDouble; + PGParamSpecDouble = ^TGParamSpecDouble; + TGParamSpecDouble = object(TGParamSpec) + minimum: gdouble; + maximum: gdouble; + default_value: gdouble; + epsilon: gdouble; + end; + + + { TGParamSpecEnum } + PPGParamSpecEnum = ^PGParamSpecEnum; + PGParamSpecEnum = ^TGParamSpecEnum; + TGParamSpecEnum = object(TGParamSpec) + enum_class: PGEnumClass; + default_value: gint; + end; + + + { TGParamSpecFlags } + PPGParamSpecFlags = ^PGParamSpecFlags; + PGParamSpecFlags = ^TGParamSpecFlags; + TGParamSpecFlags = object(TGParamSpec) + flags_class: PGFlagsClass; + default_value: guint; + end; + + + { TGParamSpecFloat } + PPGParamSpecFloat = ^PGParamSpecFloat; + PGParamSpecFloat = ^TGParamSpecFloat; + TGParamSpecFloat = object(TGParamSpec) + minimum: gfloat; + maximum: gfloat; + default_value: gfloat; + epsilon: gfloat; + end; + + + { TGParamSpecGType } + PPGParamSpecGType = ^PGParamSpecGType; + PGParamSpecGType = ^TGParamSpecGType; + TGParamSpecGType = object(TGParamSpec) + is_a_type: TGType; + end; + + + { TGParamSpecInt } + PPGParamSpecInt = ^PGParamSpecInt; + PGParamSpecInt = ^TGParamSpecInt; + TGParamSpecInt = object(TGParamSpec) + minimum: gint; + maximum: gint; + default_value: gint; + end; + + + { TGParamSpecInt64 } + PPGParamSpecInt64 = ^PGParamSpecInt64; + PGParamSpecInt64 = ^TGParamSpecInt64; + TGParamSpecInt64 = object(TGParamSpec) + minimum: gint64; + maximum: gint64; + default_value: gint64; + end; + + + { TGParamSpecLong } + PPGParamSpecLong = ^PGParamSpecLong; + PGParamSpecLong = ^TGParamSpecLong; + TGParamSpecLong = object(TGParamSpec) + minimum: glong; + maximum: glong; + default_value: glong; + end; + + + { TGParamSpecObject } + PPGParamSpecObject = ^PGParamSpecObject; + PGParamSpecObject = ^TGParamSpecObject; + TGParamSpecObject = object(TGParamSpec) + end; + + + { TGParamSpecOverride } + PPGParamSpecOverride = ^PGParamSpecOverride; + PGParamSpecOverride = ^TGParamSpecOverride; + TGParamSpecOverride = object(TGParamSpec) + overridden: PGParamSpec; + end; + + + { TGParamSpecParam } + PPGParamSpecParam = ^PGParamSpecParam; + PGParamSpecParam = ^TGParamSpecParam; + TGParamSpecParam = object(TGParamSpec) + end; + + + { TGParamSpecPointer } + PPGParamSpecPointer = ^PGParamSpecPointer; + PGParamSpecPointer = ^TGParamSpecPointer; + TGParamSpecPointer = object(TGParamSpec) + end; + + + { TGParamSpecPool } + PPGParamSpecPool = ^PGParamSpecPool; + PGParamSpecPool = ^TGParamSpecPool; + TGParamSpecPool = object + procedure insert(pspec: PGParamSpec; owner_type: TGType); cdecl; inline; + function list(owner_type: TGType; n_pspecs_p: Pguint): PPGParamSpec; cdecl; inline; + function list_owned(owner_type: TGType): PGList; cdecl; inline; + function lookup(param_name: Pgchar; owner_type: TGType; walk_ancestors: gboolean): PGParamSpec; cdecl; inline; + procedure remove(pspec: PGParamSpec); cdecl; inline; + function new(type_prefixing: gboolean): PGParamSpecPool; cdecl; inline; static; + end; + + + { TGParamSpecString } + PPGParamSpecString = ^PGParamSpecString; + PGParamSpecString = ^TGParamSpecString; + TGParamSpecStringBitfield0 = bitpacked record + null_fold_if_empty: guint1 { changed from guint to accomodate 1 bitsize requirement }; + ensure_non_null: guint1 { changed from guint to accomodate 1 bitsize requirement }; + end; + + TGParamSpecString = object(TGParamSpec) + default_value: Pgchar; + cset_first: Pgchar; + cset_nth: Pgchar; + substitutor: gchar; + Bitfield0 : TGParamSpecStringBitfield0; { auto generated type } + end; + + + { TGParamSpecTypeInfo } + PPGParamSpecTypeInfo = ^PGParamSpecTypeInfo; + PGParamSpecTypeInfo = ^TGParamSpecTypeInfo; + + TGParamSpecTypeInfo = record + instance_size: guint16; + n_preallocs: guint16; + instance_init: procedure(pspec: PGParamSpec); cdecl; + value_type: TGType; + finalize: procedure(pspec: PGParamSpec); cdecl; + value_set_default: procedure(pspec: PGParamSpec; value: PGValue); cdecl; + value_validate: function(pspec: PGParamSpec; value: PGValue): gboolean; cdecl; + values_cmp: function(pspec: PGParamSpec; value1: PGValue; value2: PGValue): gint; cdecl; + end; + + + + + { TGParamSpecUChar } + PPGParamSpecUChar = ^PGParamSpecUChar; + PGParamSpecUChar = ^TGParamSpecUChar; + TGParamSpecUChar = object(TGParamSpec) + minimum: guint8; + maximum: guint8; + default_value: guint8; + end; + + + { TGParamSpecUInt } + PPGParamSpecUInt = ^PGParamSpecUInt; + PGParamSpecUInt = ^TGParamSpecUInt; + TGParamSpecUInt = object(TGParamSpec) + minimum: guint; + maximum: guint; + default_value: guint; + end; + + + { TGParamSpecUInt64 } + PPGParamSpecUInt64 = ^PGParamSpecUInt64; + PGParamSpecUInt64 = ^TGParamSpecUInt64; + TGParamSpecUInt64 = object(TGParamSpec) + minimum: guint64; + maximum: guint64; + default_value: guint64; + end; + + + { TGParamSpecULong } + PPGParamSpecULong = ^PGParamSpecULong; + PGParamSpecULong = ^TGParamSpecULong; + TGParamSpecULong = object(TGParamSpec) + minimum: gulong; + maximum: gulong; + default_value: gulong; + end; + + + { TGParamSpecUnichar } + PPGParamSpecUnichar = ^PGParamSpecUnichar; + PGParamSpecUnichar = ^TGParamSpecUnichar; + TGParamSpecUnichar = object(TGParamSpec) + default_value: gunichar; + end; + + + { TGParamSpecValueArray } + PPGParamSpecValueArray = ^PGParamSpecValueArray; + PGParamSpecValueArray = ^TGParamSpecValueArray; + TGParamSpecValueArray = object(TGParamSpec) + element_spec: PGParamSpec; + fixed_n_elements: guint; + end; + + + { TGParamSpecVariant } + PPGParamSpecVariant = ^PGParamSpecVariant; + PGParamSpecVariant = ^TGParamSpecVariant; + TGParamSpecVariant = object(TGParamSpec) + type_: PGVariantType; + default_value: PGVariant; + padding: array [0..3] of gpointer; + end; + + + { TGSignalInvocationHint } + PPGSignalInvocationHint = ^PGSignalInvocationHint; + PGSignalInvocationHint = ^TGSignalInvocationHint; + + + { TGSignalFlags } + PPGSignalFlags = ^PGSignalFlags; + PGSignalFlags = ^TGSignalFlags; + + TGSignalInvocationHint = record + signal_id: guint; + detail: TGQuark; + run_type: TGSignalFlags; + end; + + + TGSignalAccumulator = function(ihint: PGSignalInvocationHint; return_accu: PGValue; handler_return: PGValue; user_data: gpointer): gboolean; cdecl; + TGSignalEmissionHook = function(ihint: PGSignalInvocationHint; n_param_values: guint; param_values: PGValue; user_data: gpointer): gboolean; cdecl; + + + { TGSignalGroup } + PPGSignalGroup = ^PGSignalGroup; + PGSignalGroup = ^TGSignalGroup; + TGSignalGroup = object(TGObject) + //property target: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_target { property is writeable but setter not declared } ; + //property target_type: UNABLE_TO_FIND_TYPE_FOR_PROPERTY read get_target_type { property is writeable but setter not declared } ; + end; + + + { TGSignalMatchType } + PPGSignalMatchType = ^PGSignalMatchType; + PGSignalMatchType = ^TGSignalMatchType; + + + { TGSignalQuery } + PPGSignalQuery = ^PGSignalQuery; + PGSignalQuery = ^TGSignalQuery; + + TGSignalQuery = record + signal_id: guint; + signal_name: Pgchar; + itype: TGType; + signal_flags: TGSignalFlags; + return_type: TGType; + n_params: guint; + param_types: PGType; + end; + + + + + { TGTypeCValue } + PPGTypeCValue = ^PGTypeCValue; + PGTypeCValue = ^TGTypeCValue; + TGTypeCValue = record + end; + + + TGTypeClassCacheFunc = function(cache_data: gpointer; g_class: PGTypeClass): gboolean; cdecl; + + + { TGTypeDebugFlags } + PPGTypeDebugFlags = ^PGTypeDebugFlags; + PGTypeDebugFlags = ^TGTypeDebugFlags; + + + { TGTypeFlags } + PPGTypeFlags = ^PGTypeFlags; + PGTypeFlags = ^TGTypeFlags; + + + { TGTypeFundamentalFlags } + PPGTypeFundamentalFlags = ^PGTypeFundamentalFlags; + PGTypeFundamentalFlags = ^TGTypeFundamentalFlags; + + + { TGTypeFundamentalInfo } + PPGTypeFundamentalInfo = ^PGTypeFundamentalInfo; + PGTypeFundamentalInfo = ^TGTypeFundamentalInfo; + + TGTypeFundamentalInfo = record + type_flags: TGTypeFundamentalFlags; + end; + + + + + { TGTypeValueTable } + PPGTypeValueTable = ^PGTypeValueTable; + PGTypeValueTable = ^TGTypeValueTable; + TGTypeValueTable = object + value_init: procedure(value: PGValue); cdecl; + value_free: procedure(value: PGValue); cdecl; + value_copy: procedure(src_value: PGValue; dest_value: PGValue); cdecl; + value_peek_pointer: function(value: PGValue): gpointer; cdecl; + collect_format: Pgchar; + collect_value: function(value: PGValue; n_collect_values: guint; collect_values: PGTypeCValue; collect_flags: guint): Pgchar; cdecl; + lcopy_format: Pgchar; + lcopy_value: function(value: PGValue; n_collect_values: guint; collect_values: PGTypeCValue; collect_flags: guint): Pgchar; cdecl; + function peek(type_: TGType): PGTypeValueTable; cdecl; inline; static; + end; + + + { TGTypeInfo } + PPGTypeInfo = ^PGTypeInfo; + PGTypeInfo = ^TGTypeInfo; + + + { TGBaseInitFunc } + PPGBaseInitFunc = ^PGBaseInitFunc; + PGBaseInitFunc = ^TGBaseInitFunc; + + + { TGBaseFinalizeFunc } + PPGBaseFinalizeFunc = ^PGBaseFinalizeFunc; + PGBaseFinalizeFunc = ^TGBaseFinalizeFunc; + + + { TGClassInitFunc } + PPGClassInitFunc = ^PGClassInitFunc; + PGClassInitFunc = ^TGClassInitFunc; + + + { TGClassFinalizeFunc } + PPGClassFinalizeFunc = ^PGClassFinalizeFunc; + PGClassFinalizeFunc = ^TGClassFinalizeFunc; + + + { TGInstanceInitFunc } + PPGInstanceInitFunc = ^PGInstanceInitFunc; + PGInstanceInitFunc = ^TGInstanceInitFunc; + + TGTypeInfo = record + class_size: guint16; + base_init: TGBaseInitFunc; + base_finalize: TGBaseFinalizeFunc; + class_init: TGClassInitFunc; + class_finalize: TGClassFinalizeFunc; + class_data: Pgpointer; + instance_size: guint16; + n_preallocs: guint16; + instance_init: TGInstanceInitFunc; + value_table: PGTypeValueTable; + end; + + + TGTypePlugin = object + procedure complete_interface_info(instance_type: TGType; interface_type: TGType; info: PGInterfaceInfo); cdecl; inline; + procedure complete_type_info(g_type: TGType; info: PGTypeInfo; value_table: PGTypeValueTable); cdecl; inline; + procedure unuse; cdecl; inline; + procedure use; cdecl; inline; + end; + TGTypeInterfaceCheckFunc = procedure(check_data: gpointer; g_iface: PGTypeInterface); cdecl; + + + { TGTypeModule } + PPGTypeModule = ^PGTypeModule; + PGTypeModule = ^TGTypeModule; + TGTypeModule = object(TGObject) + use_count: guint; + type_infos: PGSList; + interface_infos: PGSList; + name: Pgchar; + procedure add_interface(instance_type: TGType; interface_type: TGType; interface_info: PGInterfaceInfo); cdecl; inline; + function register_enum(name: Pgchar; const_static_values: PGEnumValue): TGType; cdecl; inline; + function register_flags(name: Pgchar; const_static_values: PGFlagsValue): TGType; cdecl; inline; + function register_type(parent_type: TGType; type_name: Pgchar; type_info: PGTypeInfo; flags: TGTypeFlags): TGType; cdecl; inline; + procedure set_name(name: Pgchar); cdecl; inline; + procedure unuse; cdecl; inline; + function use: gboolean; cdecl; inline; + end; + + + { TGTypeModuleClass } + PPGTypeModuleClass = ^PGTypeModuleClass; + PGTypeModuleClass = ^TGTypeModuleClass; + TGTypeModuleClass = object + parent_class: TGObjectClass; + load: function(module: PGTypeModule): gboolean; cdecl; + unload: procedure(module: PGTypeModule); cdecl; + reserved1: procedure; cdecl; + reserved2: procedure; cdecl; + reserved3: procedure; cdecl; + reserved4: procedure; cdecl; + end; + TGTypePluginUse = procedure(plugin: PGTypePlugin); cdecl; + TGTypePluginUnuse = procedure(plugin: PGTypePlugin); cdecl; + TGTypePluginCompleteTypeInfo = procedure(plugin: PGTypePlugin; g_type: TGType; info: PGTypeInfo; value_table: PGTypeValueTable); cdecl; + TGTypePluginCompleteInterfaceInfo = procedure(plugin: PGTypePlugin; instance_type: TGType; interface_type: TGType; info: PGInterfaceInfo); cdecl; + + + { TGTypePluginClass } + PPGTypePluginClass = ^PGTypePluginClass; + PGTypePluginClass = ^TGTypePluginClass; + + + { TGTypePluginUse } + PPGTypePluginUse = ^PGTypePluginUse; + PGTypePluginUse = ^TGTypePluginUse; + + + { TGTypePluginUnuse } + PPGTypePluginUnuse = ^PGTypePluginUnuse; + PGTypePluginUnuse = ^TGTypePluginUnuse; + + + { TGTypePluginCompleteTypeInfo } + PPGTypePluginCompleteTypeInfo = ^PGTypePluginCompleteTypeInfo; + PGTypePluginCompleteTypeInfo = ^TGTypePluginCompleteTypeInfo; + + + { TGTypePluginCompleteInterfaceInfo } + PPGTypePluginCompleteInterfaceInfo = ^PGTypePluginCompleteInterfaceInfo; + PGTypePluginCompleteInterfaceInfo = ^TGTypePluginCompleteInterfaceInfo; + + TGTypePluginClass = record + base_iface: TGTypeInterface; + use_plugin: TGTypePluginUse; + unuse_plugin: TGTypePluginUnuse; + complete_type_info: TGTypePluginCompleteTypeInfo; + complete_interface_info: TGTypePluginCompleteInterfaceInfo; + end; + + + + + { TGTypeQuery } + PPGTypeQuery = ^PGTypeQuery; + PGTypeQuery = ^TGTypeQuery; + + TGTypeQuery = record + type_: TGType; + type_name: Pgchar; + class_size: guint; + instance_size: guint; + end; + + + + + { TGValueArray } + PPGValueArray = ^PGValueArray; + PGValueArray = ^TGValueArray; + TGValueArray = object + n_values: guint; + values: PGValue; + n_prealloced: guint; + end; + + + { TGWeakRef } + PPGWeakRef = ^PGWeakRef; + PGWeakRef = ^TGWeakRef; + + + { TGWeakRef_union_priv } + PPGWeakRef_union_priv = ^PGWeakRef_union_priv; + PGWeakRef_union_priv = ^TGWeakRef_union_priv; + TGWeakRef_union_priv = record + case longint of + 0 : (p: gpointer); + end; + + + TGWeakRef = object + priv: TGWeakRef_union_priv; //union extracted from object and named 'TGWeakRef_union_priv' + procedure clear; cdecl; inline; + function get: PGObject; cdecl; inline; + procedure init(object_: PGObject); cdecl; inline; + procedure set_(object_: PGObject); cdecl; inline; + end; + +function g_binding_get_flags(binding: PGBinding): TGBindingFlags; cdecl; external LazGObject2_library name 'g_binding_get_flags'; +function g_binding_get_source_property(binding: PGBinding): Pgchar; cdecl; external LazGObject2_library name 'g_binding_get_source_property'; +function g_binding_get_target_property(binding: PGBinding): Pgchar; cdecl; external LazGObject2_library name 'g_binding_get_target_property'; +function g_binding_get_type: TGType; cdecl; external LazGObject2_library name 'g_binding_get_type'; +function g_binding_group_get_type: TGType; cdecl; external LazGObject2_library name 'g_binding_group_get_type'; +function g_boxed_copy(boxed_type: TGType; src_boxed: Pgpointer): gpointer; cdecl; external LazGObject2_library name 'g_boxed_copy'; +function g_boxed_type_register_static(name: Pgchar; boxed_copy: TGBoxedCopyFunc; boxed_free: TGBoxedFreeFunc): TGType; cdecl; external LazGObject2_library name 'g_boxed_type_register_static'; +function g_cclosure_new(callback_func: TGCallback; user_data: gpointer; destroy_data: TGClosureNotify): PGClosure; cdecl; external LazGObject2_library name 'g_cclosure_new'; +function g_cclosure_new_object(callback_func: TGCallback; object_: PGObject): PGClosure; cdecl; external LazGObject2_library name 'g_cclosure_new_object'; +function g_cclosure_new_object_swap(callback_func: TGCallback; object_: PGObject): PGClosure; cdecl; external LazGObject2_library name 'g_cclosure_new_object_swap'; +function g_cclosure_new_swap(callback_func: TGCallback; user_data: gpointer; destroy_data: TGClosureNotify): PGClosure; cdecl; external LazGObject2_library name 'g_cclosure_new_swap'; +function g_closure_get_type: TGType; cdecl; external LazGObject2_library name 'g_closure_get_type'; +function g_closure_new_object(sizeof_closure: guint; object_: PGObject): PGClosure; cdecl; external LazGObject2_library name 'g_closure_new_object'; +function g_closure_new_simple(sizeof_closure: guint; data: gpointer): PGClosure; cdecl; external LazGObject2_library name 'g_closure_new_simple'; +function g_closure_ref(closure: PGClosure): PGClosure; cdecl; external LazGObject2_library name 'g_closure_ref'; +function g_enum_get_value(enum_class: PGEnumClass; value: gint): PGEnumValue; cdecl; external LazGObject2_library name 'g_enum_get_value'; +function g_enum_get_value_by_name(enum_class: PGEnumClass; name: Pgchar): PGEnumValue; cdecl; external LazGObject2_library name 'g_enum_get_value_by_name'; +function g_enum_get_value_by_nick(enum_class: PGEnumClass; nick: Pgchar): PGEnumValue; cdecl; external LazGObject2_library name 'g_enum_get_value_by_nick'; +function g_enum_register_static(name: Pgchar; const_static_values: PGEnumValue): TGType; cdecl; external LazGObject2_library name 'g_enum_register_static'; +function g_enum_to_string(g_enum_type: TGType; value: gint): Pgchar; cdecl; external LazGObject2_library name 'g_enum_to_string'; +function g_flags_get_first_value(flags_class: PGFlagsClass; value: guint): PGFlagsValue; cdecl; external LazGObject2_library name 'g_flags_get_first_value'; +function g_flags_get_value_by_name(flags_class: PGFlagsClass; name: Pgchar): PGFlagsValue; cdecl; external LazGObject2_library name 'g_flags_get_value_by_name'; +function g_flags_get_value_by_nick(flags_class: PGFlagsClass; nick: Pgchar): PGFlagsValue; cdecl; external LazGObject2_library name 'g_flags_get_value_by_nick'; +function g_flags_register_static(name: Pgchar; const_static_values: PGFlagsValue): TGType; cdecl; external LazGObject2_library name 'g_flags_register_static'; +function g_flags_to_string(flags_type: TGType; value: guint): Pgchar; cdecl; external LazGObject2_library name 'g_flags_to_string'; +function g_gtype_get_type: TGType; cdecl; external LazGObject2_library name 'g_gtype_get_type'; +function g_initially_unowned_get_type: TGType; cdecl; external LazGObject2_library name 'g_initially_unowned_get_type'; +function g_object_bind_property(source: PGObject; source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags): PGBinding; cdecl; external LazGObject2_library name 'g_object_bind_property'; +function g_object_bind_property_full(source: PGObject; source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags; transform_to: TGBindingTransformFunc; transform_from: TGBindingTransformFunc; user_data: gpointer; notify: TGDestroyNotify): PGBinding; cdecl; external LazGObject2_library name 'g_object_bind_property_full'; +function g_object_bind_property_with_closures(source: PGObject; source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags; transform_to: PGClosure; transform_from: PGClosure): PGBinding; cdecl; external LazGObject2_library name 'g_object_bind_property_with_closures'; +function g_object_class_find_property(oclass: PGObjectClass; property_name: Pgchar): PGParamSpec; cdecl; external LazGObject2_library name 'g_object_class_find_property'; +function g_object_class_list_properties(oclass: PGObjectClass; n_properties: Pguint): PPGParamSpec; cdecl; external LazGObject2_library name 'g_object_class_list_properties'; +function g_object_compat_control(what: gsize; data: gpointer): gsize; cdecl; external LazGObject2_library name 'g_object_compat_control'; +function g_object_connect(object_: PGObject; signal_spec: Pgchar; args: array of const): PGObject; cdecl; external LazGObject2_library name 'g_object_connect'; +function g_object_dup_data(object_: PGObject; key: Pgchar; dup_func: TGDuplicateFunc; user_data: gpointer): gpointer; cdecl; external LazGObject2_library name 'g_object_dup_data'; +function g_object_dup_qdata(object_: PGObject; quark: TGQuark; dup_func: TGDuplicateFunc; user_data: gpointer): gpointer; cdecl; external LazGObject2_library name 'g_object_dup_qdata'; +function g_object_get_data(object_: PGObject; key: Pgchar): gpointer; cdecl; external LazGObject2_library name 'g_object_get_data'; +function g_object_get_qdata(object_: PGObject; quark: TGQuark): gpointer; cdecl; external LazGObject2_library name 'g_object_get_qdata'; +function g_object_get_type: TGType; cdecl; external LazGObject2_library name 'g_object_get_type'; +function g_object_interface_find_property(g_iface: PGTypeInterface; property_name: Pgchar): PGParamSpec; cdecl; external LazGObject2_library name 'g_object_interface_find_property'; +function g_object_interface_list_properties(g_iface: PGTypeInterface; n_properties_p: Pguint): PPGParamSpec; cdecl; external LazGObject2_library name 'g_object_interface_list_properties'; +function g_object_is_floating(object_: PGObject): gboolean; cdecl; external LazGObject2_library name 'g_object_is_floating'; +function g_object_new(object_type: TGType; first_property_name: Pgchar; args: array of const): PGObject; cdecl; external LazGObject2_library name 'g_object_new'; +function g_object_new_valist(object_type: TGType; first_property_name: Pgchar; var_args: Tva_list): PGObject; cdecl; external LazGObject2_library name 'g_object_new_valist'; +function g_object_newv(object_type: TGType; n_parameters: guint; parameters: PGParameter): PGObject; cdecl; external; +function g_object_new_with_properties(object_type: TGType; n_properties: guint; names: PPgchar; values: PGValue): PGObject; cdecl; external LazGObject2_library name 'g_object_new_with_properties'; +function g_object_ref(object_: PGObject): PGObject; cdecl; external LazGObject2_library name 'g_object_ref'; +function g_object_ref_sink(object_: PGObject): PGObject; cdecl; external LazGObject2_library name 'g_object_ref_sink'; +function g_object_replace_data(object_: PGObject; key: Pgchar; oldval: gpointer; newval: gpointer; destroy_: TGDestroyNotify; old_destroy: PGDestroyNotify): gboolean; cdecl; external LazGObject2_library name 'g_object_replace_data'; +function g_object_replace_qdata(object_: PGObject; quark: TGQuark; oldval: gpointer; newval: gpointer; destroy_: TGDestroyNotify; old_destroy: PGDestroyNotify): gboolean; cdecl; external LazGObject2_library name 'g_object_replace_qdata'; +function g_object_steal_data(object_: PGObject; key: Pgchar): gpointer; cdecl; external LazGObject2_library name 'g_object_steal_data'; +function g_object_steal_qdata(object_: PGObject; quark: TGQuark): gpointer; cdecl; external LazGObject2_library name 'g_object_steal_qdata'; +function g_param_spec_boolean(name: Pgchar; nick: Pgchar; blurb: Pgchar; default_value: gboolean; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_boolean'; +function g_param_spec_boxed(name: Pgchar; nick: Pgchar; blurb: Pgchar; boxed_type: TGType; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_boxed'; +function g_param_spec_char(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: gint8; maximum: gint8; default_value: gint8; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_char'; +function g_param_spec_double(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: gdouble; maximum: gdouble; default_value: gdouble; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_double'; +function g_param_spec_enum(name: Pgchar; nick: Pgchar; blurb: Pgchar; enum_type: TGType; default_value: gint; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_enum'; +function g_param_spec_flags(name: Pgchar; nick: Pgchar; blurb: Pgchar; flags_type: TGType; default_value: guint; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_flags'; +function g_param_spec_float(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: gfloat; maximum: gfloat; default_value: gfloat; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_float'; +function g_param_spec_get_blurb(pspec: PGParamSpec): Pgchar; cdecl; external LazGObject2_library name 'g_param_spec_get_blurb'; +function g_param_spec_get_default_value(pspec: PGParamSpec): PGValue; cdecl; external LazGObject2_library name 'g_param_spec_get_default_value'; +function g_param_spec_get_name(pspec: PGParamSpec): Pgchar; cdecl; external LazGObject2_library name 'g_param_spec_get_name'; +function g_param_spec_get_name_quark(pspec: PGParamSpec): TGQuark; cdecl; external LazGObject2_library name 'g_param_spec_get_name_quark'; +function g_param_spec_get_nick(pspec: PGParamSpec): Pgchar; cdecl; external LazGObject2_library name 'g_param_spec_get_nick'; +function g_param_spec_get_qdata(pspec: PGParamSpec; quark: TGQuark): gpointer; cdecl; external LazGObject2_library name 'g_param_spec_get_qdata'; +function g_param_spec_get_redirect_target(pspec: PGParamSpec): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_get_redirect_target'; +function g_param_spec_gtype(name: Pgchar; nick: Pgchar; blurb: Pgchar; is_a_type: TGType; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_gtype'; +function g_param_spec_int(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: gint; maximum: gint; default_value: gint; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_int'; +function g_param_spec_int64(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: gint64; maximum: gint64; default_value: gint64; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_int64'; +function g_param_spec_internal(param_type: TGType; name: Pgchar; nick: Pgchar; blurb: Pgchar; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_internal'; +{$IFDEF USEGTK3LATESTBINDINGS} +function g_param_spec_is_valid_name(name: Pgchar): gboolean; cdecl; external LazGObject2_library name 'g_param_spec_is_valid_name'; +{$ENDIF} +function g_param_spec_long(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: glong; maximum: glong; default_value: glong; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_long'; +function g_param_spec_object(name: Pgchar; nick: Pgchar; blurb: Pgchar; object_type: TGType; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_object'; +function g_param_spec_override(name: Pgchar; overridden: PGParamSpec): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_override'; +function g_param_spec_param(name: Pgchar; nick: Pgchar; blurb: Pgchar; param_type: TGType; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_param'; +function g_param_spec_pointer(name: Pgchar; nick: Pgchar; blurb: Pgchar; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_pointer'; +function g_param_spec_pool_list(pool: PGParamSpecPool; owner_type: TGType; n_pspecs_p: Pguint): PPGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_pool_list'; +function g_param_spec_pool_list_owned(pool: PGParamSpecPool; owner_type: TGType): PGList; cdecl; external LazGObject2_library name 'g_param_spec_pool_list_owned'; +function g_param_spec_pool_lookup(pool: PGParamSpecPool; param_name: Pgchar; owner_type: TGType; walk_ancestors: gboolean): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_pool_lookup'; +function g_param_spec_pool_new(type_prefixing: gboolean): PGParamSpecPool; cdecl; external LazGObject2_library name 'g_param_spec_pool_new'; +function g_param_spec_ref(pspec: PGParamSpec): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_ref'; +function g_param_spec_ref_sink(pspec: PGParamSpec): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_ref_sink'; +function g_param_spec_steal_qdata(pspec: PGParamSpec; quark: TGQuark): gpointer; cdecl; external LazGObject2_library name 'g_param_spec_steal_qdata'; +function g_param_spec_string(name: Pgchar; nick: Pgchar; blurb: Pgchar; default_value: Pgchar; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_string'; +function g_param_spec_uchar(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: guint8; maximum: guint8; default_value: guint8; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_uchar'; +function g_param_spec_uint(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: guint; maximum: guint; default_value: guint; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_uint'; +function g_param_spec_uint64(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: guint64; maximum: guint64; default_value: guint64; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_uint64'; +function g_param_spec_ulong(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: gulong; maximum: gulong; default_value: gulong; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_ulong'; +function g_param_spec_unichar(name: Pgchar; nick: Pgchar; blurb: Pgchar; default_value: gunichar; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_unichar'; +function g_param_spec_value_array(name: Pgchar; nick: Pgchar; blurb: Pgchar; element_spec: PGParamSpec; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_value_array'; +function g_param_spec_variant(name: Pgchar; nick: Pgchar; blurb: Pgchar; type_: PGVariantType; default_value: PGVariant; flags: TGParamFlags): PGParamSpec; cdecl; external LazGObject2_library name 'g_param_spec_variant'; +function g_param_type_register_static(name: Pgchar; pspec_info: PGParamSpecTypeInfo): TGType; cdecl; external LazGObject2_library name 'g_param_type_register_static'; +function g_param_value_convert(pspec: PGParamSpec; src_value: PGValue; dest_value: PGValue; strict_validation: gboolean): gboolean; cdecl; external LazGObject2_library name 'g_param_value_convert'; +function g_param_value_defaults(pspec: PGParamSpec; value: PGValue): gboolean; cdecl; external LazGObject2_library name 'g_param_value_defaults'; +function g_param_value_is_valid(pspec: PGParamSpec; value: PGValue): gboolean; cdecl; external LazGObject2_library name 'g_param_value_is_valid'; +function g_param_value_validate(pspec: PGParamSpec; value: PGValue): gboolean; cdecl; external LazGObject2_library name 'g_param_value_validate'; +function g_param_values_cmp(pspec: PGParamSpec; value1: PGValue; value2: PGValue): gint; cdecl; external LazGObject2_library name 'g_param_values_cmp'; +function g_pointer_type_register_static(name: Pgchar): TGType; cdecl; external LazGObject2_library name 'g_pointer_type_register_static'; +function g_signal_accumulator_first_wins(ihint: PGSignalInvocationHint; return_accu: PGValue; handler_return: PGValue; dummy: gpointer): gboolean; cdecl; external LazGObject2_library name 'g_signal_accumulator_first_wins'; +function g_signal_accumulator_true_handled(ihint: PGSignalInvocationHint; return_accu: PGValue; handler_return: PGValue; dummy: gpointer): gboolean; cdecl; external LazGObject2_library name 'g_signal_accumulator_true_handled'; +function g_signal_add_emission_hook(signal_id: guint; detail: TGQuark; hook_func: TGSignalEmissionHook; hook_data: gpointer; data_destroy: TGDestroyNotify): gulong; cdecl; external LazGObject2_library name 'g_signal_add_emission_hook'; +function g_signal_connect_closure(instance: PGObject; detailed_signal: Pgchar; closure: PGClosure; after: gboolean): gulong; cdecl; external LazGObject2_library name 'g_signal_connect_closure'; +function g_signal_connect_closure_by_id(instance: PGObject; signal_id: guint; detail: TGQuark; closure: PGClosure; after: gboolean): gulong; cdecl; external LazGObject2_library name 'g_signal_connect_closure_by_id'; +function g_signal_connect_data(instance: PGObject; detailed_signal: Pgchar; c_handler: TGCallback; data: gpointer; destroy_data: TGClosureNotify; connect_flags: TGConnectFlags): gulong; cdecl; external LazGObject2_library name 'g_signal_connect_data'; +function g_signal_connect_object(instance: PGTypeInstance; detailed_signal: Pgchar; c_handler: TGCallback; gobject: PGObject; connect_flags: TGConnectFlags): gulong; cdecl; external LazGObject2_library name 'g_signal_connect_object'; +function g_signal_get_invocation_hint(instance: PGObject): PGSignalInvocationHint; cdecl; external LazGObject2_library name 'g_signal_get_invocation_hint'; +function g_signal_group_get_type: TGType; cdecl; external LazGObject2_library name 'g_signal_group_get_type'; +function g_signal_handler_find(instance: PGObject; mask: TGSignalMatchType; signal_id: guint; detail: TGQuark; closure: PGClosure; func: gpointer; data: gpointer): gulong; cdecl; external LazGObject2_library name 'g_signal_handler_find'; +function g_signal_handler_is_connected(instance: PGObject; handler_id: gulong): gboolean; cdecl; external LazGObject2_library name 'g_signal_handler_is_connected'; +function g_signal_handlers_block_matched(instance: PGObject; mask: TGSignalMatchType; signal_id: guint; detail: TGQuark; closure: PGClosure; func: gpointer; data: gpointer): guint; cdecl; external LazGObject2_library name 'g_signal_handlers_block_matched'; +function g_signal_handlers_disconnect_matched(instance: PGObject; mask: TGSignalMatchType; signal_id: guint; detail: TGQuark; closure: PGClosure; func: gpointer; data: gpointer): guint; cdecl; external LazGObject2_library name 'g_signal_handlers_disconnect_matched'; +function g_signal_handlers_unblock_matched(instance: PGObject; mask: TGSignalMatchType; signal_id: guint; detail: TGQuark; closure: PGClosure; func: gpointer; data: gpointer): guint; cdecl; external LazGObject2_library name 'g_signal_handlers_unblock_matched'; +function g_signal_has_handler_pending(instance: PGObject; signal_id: guint; detail: TGQuark; may_be_blocked: gboolean): gboolean; cdecl; external LazGObject2_library name 'g_signal_has_handler_pending'; +function g_signal_is_valid_name(name: Pgchar): gboolean; cdecl; external LazGObject2_library name 'g_signal_is_valid_name'; +function g_signal_list_ids(itype: TGType; n_ids: Pguint): Pguint; cdecl; external LazGObject2_library name 'g_signal_list_ids'; +function g_signal_lookup(name: Pgchar; itype: TGType): guint; cdecl; external LazGObject2_library name 'g_signal_lookup'; +function g_signal_name(signal_id: guint): Pgchar; cdecl; external LazGObject2_library name 'g_signal_name'; +function g_signal_new(signal_name: Pgchar; itype: TGType; signal_flags: TGSignalFlags; class_offset: guint; accumulator: TGSignalAccumulator; accu_data: gpointer; c_marshaller: TGSignalCMarshaller; return_type: TGType; n_params: guint; args: array of const): guint; cdecl; external LazGObject2_library name 'g_signal_new'; +function g_signal_new_class_handler(signal_name: Pgchar; itype: TGType; signal_flags: TGSignalFlags; class_handler: TGCallback; accumulator: TGSignalAccumulator; accu_data: gpointer; c_marshaller: TGSignalCMarshaller; return_type: TGType; n_params: guint; args: array of const): guint; cdecl; external LazGObject2_library name 'g_signal_new_class_handler'; +function g_signal_new_valist(signal_name: Pgchar; itype: TGType; signal_flags: TGSignalFlags; class_closure: PGClosure; accumulator: TGSignalAccumulator; accu_data: gpointer; c_marshaller: TGSignalCMarshaller; return_type: TGType; n_params: guint; args: Tva_list): guint; cdecl; external LazGObject2_library name 'g_signal_new_valist'; +function g_signal_newv(signal_name: Pgchar; itype: TGType; signal_flags: TGSignalFlags; class_closure: PGClosure; accumulator: TGSignalAccumulator; accu_data: gpointer; c_marshaller: TGSignalCMarshaller; return_type: TGType; n_params: guint; param_types: PGType): guint; cdecl; external LazGObject2_library name 'g_signal_newv'; +function g_signal_parse_name(detailed_signal: Pgchar; itype: TGType; signal_id_p: Pguint; detail_p: PGQuark; force_detail_quark: gboolean): gboolean; cdecl; external LazGObject2_library name 'g_signal_parse_name'; +function g_signal_type_cclosure_new(itype: TGType; struct_offset: guint): PGClosure; cdecl; external LazGObject2_library name 'g_signal_type_cclosure_new'; +function g_strdup_value_contents(value: PGValue): Pgchar; cdecl; external LazGObject2_library name 'g_strdup_value_contents'; +function g_type_add_instance_private(class_type: TGType; private_size: gsize): gint; cdecl; external LazGObject2_library name 'g_type_add_instance_private'; +function g_type_check_class_cast(g_class: PGTypeClass; is_a_type: TGType): PGTypeClass; cdecl; external LazGObject2_library name 'g_type_check_class_cast'; +function g_type_check_class_is_a(g_class: PGTypeClass; is_a_type: TGType): gboolean; cdecl; external LazGObject2_library name 'g_type_check_class_is_a'; +function g_type_check_instance(instance: PGTypeInstance): gboolean; cdecl; external LazGObject2_library name 'g_type_check_instance'; +function g_type_check_instance_cast(instance: PGTypeInstance; iface_type: TGType): PGTypeInstance; cdecl; external LazGObject2_library name 'g_type_check_instance_cast'; +function g_type_check_instance_is_a(instance: PGTypeInstance; iface_type: TGType): gboolean; cdecl; external LazGObject2_library name 'g_type_check_instance_is_a'; +function g_type_check_instance_is_fundamentally_a(instance: PGTypeInstance; fundamental_type: TGType): gboolean; cdecl; external LazGObject2_library name 'g_type_check_instance_is_fundamentally_a'; +function g_type_check_is_value_type(type_: TGType): gboolean; cdecl; external LazGObject2_library name 'g_type_check_is_value_type'; +function g_type_check_value(value: PGValue): gboolean; cdecl; external LazGObject2_library name 'g_type_check_value'; +function g_type_check_value_holds(value: PGValue; type_: TGType): gboolean; cdecl; external LazGObject2_library name 'g_type_check_value_holds'; +function g_type_children(type_: TGType; n_children: Pguint): PGType; cdecl; external LazGObject2_library name 'g_type_children'; +function g_type_class_get_instance_private_offset(g_class: PGTypeClass): gint; cdecl; external LazGObject2_library name 'g_type_class_get_instance_private_offset'; +function g_type_class_get_private(klass: PGTypeClass; private_type: TGType): gpointer; cdecl; external LazGObject2_library name 'g_type_class_get_private'; +function g_type_class_peek(type_: TGType): PGTypeClass; cdecl; external LazGObject2_library name 'g_type_class_peek'; +function g_type_class_peek_parent(g_class: PGTypeClass): PGTypeClass; cdecl; external LazGObject2_library name 'g_type_class_peek_parent'; +function g_type_class_peek_static(type_: TGType): PGTypeClass; cdecl; external LazGObject2_library name 'g_type_class_peek_static'; +function g_type_class_ref(type_: TGType): PGTypeClass; cdecl; external LazGObject2_library name 'g_type_class_ref'; +function g_type_create_instance(type_: TGType): PGTypeInstance; cdecl; external LazGObject2_library name 'g_type_create_instance'; +function g_type_default_interface_peek(g_type: TGType): PGTypeInterface; cdecl; external LazGObject2_library name 'g_type_default_interface_peek'; +function g_type_default_interface_ref(g_type: TGType): PGTypeInterface; cdecl; external LazGObject2_library name 'g_type_default_interface_ref'; +function g_type_depth(type_: TGType): guint; cdecl; external LazGObject2_library name 'g_type_depth'; +function g_type_from_name(name: Pgchar): TGType; cdecl; external LazGObject2_library name 'g_type_from_name'; +function g_type_fundamental(type_id: TGType): TGType; cdecl; external LazGObject2_library name 'g_type_fundamental'; +function g_type_fundamental_next: TGType; cdecl; external LazGObject2_library name 'g_type_fundamental_next'; +function g_type_get_instance_count(type_: TGType): gint; cdecl; external LazGObject2_library name 'g_type_get_instance_count'; +function g_type_get_plugin(type_: TGType): PGTypePlugin; cdecl; external LazGObject2_library name 'g_type_get_plugin'; +function g_type_get_qdata(type_: TGType; quark: TGQuark): gpointer; cdecl; external LazGObject2_library name 'g_type_get_qdata'; +function g_type_get_type_registration_serial: guint; cdecl; external LazGObject2_library name 'g_type_get_type_registration_serial'; +function g_type_instance_get_private(instance: PGTypeInstance; private_type: TGType): gpointer; cdecl; external LazGObject2_library name 'g_type_instance_get_private'; +function g_type_interface_get_plugin(instance_type: TGType; interface_type: TGType): PGTypePlugin; cdecl; external LazGObject2_library name 'g_type_interface_get_plugin'; +function g_type_interface_peek(instance_class: PGTypeClass; iface_type: TGType): PGTypeInterface; cdecl; external LazGObject2_library name 'g_type_interface_peek'; +function g_type_interface_peek_parent(g_iface: PGTypeInterface): PGTypeInterface; cdecl; external LazGObject2_library name 'g_type_interface_peek_parent'; +function g_type_interface_prerequisites(interface_type: TGType; n_prerequisites: Pguint): PGType; cdecl; external LazGObject2_library name 'g_type_interface_prerequisites'; +function g_type_interfaces(type_: TGType; n_interfaces: Pguint): PGType; cdecl; external LazGObject2_library name 'g_type_interfaces'; +function g_type_is_a(type_: TGType; is_a_type: TGType): gboolean; cdecl; external LazGObject2_library name 'g_type_is_a'; +function g_type_module_get_type: TGType; cdecl; external LazGObject2_library name 'g_type_module_get_type'; +function g_type_module_register_enum(module: PGTypeModule; name: Pgchar; const_static_values: PGEnumValue): TGType; cdecl; external LazGObject2_library name 'g_type_module_register_enum'; +function g_type_module_register_flags(module: PGTypeModule; name: Pgchar; const_static_values: PGFlagsValue): TGType; cdecl; external LazGObject2_library name 'g_type_module_register_flags'; +function g_type_module_register_type(module: PGTypeModule; parent_type: TGType; type_name: Pgchar; type_info: PGTypeInfo; flags: TGTypeFlags): TGType; cdecl; external LazGObject2_library name 'g_type_module_register_type'; +function g_type_module_use(module: PGTypeModule): gboolean; cdecl; external LazGObject2_library name 'g_type_module_use'; +function g_type_name(type_: TGType): Pgchar; cdecl; external LazGObject2_library name 'g_type_name'; +function g_type_name_from_class(g_class: PGTypeClass): Pgchar; cdecl; external LazGObject2_library name 'g_type_name_from_class'; +function g_type_name_from_instance(instance: PGTypeInstance): Pgchar; cdecl; external LazGObject2_library name 'g_type_name_from_instance'; +function g_type_next_base(leaf_type: TGType; root_type: TGType): TGType; cdecl; external LazGObject2_library name 'g_type_next_base'; +function g_type_parent(type_: TGType): TGType; cdecl; external LazGObject2_library name 'g_type_parent'; +function g_type_plugin_get_type: TGType; cdecl; external LazGObject2_library name 'g_type_plugin_get_type'; +function g_type_qname(type_: TGType): TGQuark; cdecl; external LazGObject2_library name 'g_type_qname'; +function g_type_register_dynamic(parent_type: TGType; type_name: Pgchar; plugin: PGTypePlugin; flags: TGTypeFlags): TGType; cdecl; external LazGObject2_library name 'g_type_register_dynamic'; +function g_type_register_fundamental(type_id: TGType; type_name: Pgchar; info: PGTypeInfo; finfo: PGTypeFundamentalInfo; flags: TGTypeFlags): TGType; cdecl; external LazGObject2_library name 'g_type_register_fundamental'; +function g_type_register_static(parent_type: TGType; type_name: Pgchar; info: PGTypeInfo; flags: TGTypeFlags): TGType; cdecl; external LazGObject2_library name 'g_type_register_static'; +function g_type_register_static_simple(parent_type: TGType; type_name: Pgchar; class_size: guint; class_init: TGClassInitFunc; instance_size: guint; instance_init: TGInstanceInitFunc; flags: TGTypeFlags): TGType; cdecl; external LazGObject2_library name 'g_type_register_static_simple'; +function g_type_test_flags(type_: TGType; flags: guint): gboolean; cdecl; external LazGObject2_library name 'g_type_test_flags'; +function g_type_value_table_peek(type_: TGType): PGTypeValueTable; cdecl; external LazGObject2_library name 'g_type_value_table_peek'; +function g_value_array_get_type: TGType; cdecl; external LazGObject2_library name 'g_value_array_get_type'; +function g_value_dup_boxed(value: PGValue): gpointer; cdecl; external LazGObject2_library name 'g_value_dup_boxed'; +function g_value_dup_object(value: PGValue): PGObject; cdecl; external LazGObject2_library name 'g_value_dup_object'; +function g_value_dup_param(value: PGValue): PGParamSpec; cdecl; external LazGObject2_library name 'g_value_dup_param'; +function g_value_dup_string(value: PGValue): Pgchar; cdecl; external LazGObject2_library name 'g_value_dup_string'; +function g_value_dup_variant(value: PGValue): PGVariant; cdecl; external LazGObject2_library name 'g_value_dup_variant'; +function g_value_fits_pointer(value: PGValue): gboolean; cdecl; external LazGObject2_library name 'g_value_fits_pointer'; +function g_value_get_boolean(value: PGValue): gboolean; cdecl; external LazGObject2_library name 'g_value_get_boolean'; +function g_value_get_boxed(value: PGValue): gpointer; cdecl; external LazGObject2_library name 'g_value_get_boxed'; +function g_value_get_double(value: PGValue): gdouble; cdecl; external LazGObject2_library name 'g_value_get_double'; +function g_value_get_enum(value: PGValue): gint; cdecl; external LazGObject2_library name 'g_value_get_enum'; +function g_value_get_flags(value: PGValue): guint; cdecl; external LazGObject2_library name 'g_value_get_flags'; +function g_value_get_float(value: PGValue): gfloat; cdecl; external LazGObject2_library name 'g_value_get_float'; +function g_value_get_gtype(value: PGValue): TGType; cdecl; external LazGObject2_library name 'g_value_get_gtype'; +function g_value_get_int(value: PGValue): gint; cdecl; external LazGObject2_library name 'g_value_get_int'; +function g_value_get_int64(value: PGValue): gint64; cdecl; external LazGObject2_library name 'g_value_get_int64'; +function g_value_get_long(value: PGValue): glong; cdecl; external LazGObject2_library name 'g_value_get_long'; +function g_value_get_object(value: PGValue): PGObject; cdecl; external LazGObject2_library name 'g_value_get_object'; +function g_value_get_param(value: PGValue): PGParamSpec; cdecl; external LazGObject2_library name 'g_value_get_param'; +function g_value_get_pointer(value: PGValue): gpointer; cdecl; external LazGObject2_library name 'g_value_get_pointer'; +function g_value_get_schar(value: PGValue): gint8; cdecl; external LazGObject2_library name 'g_value_get_schar'; +function g_value_get_string(value: PGValue): Pgchar; cdecl; external LazGObject2_library name 'g_value_get_string'; +function g_value_get_type: TGType; cdecl; external LazGObject2_library name 'g_value_get_type'; +function g_value_get_uchar(value: PGValue): guint8; cdecl; external LazGObject2_library name 'g_value_get_uchar'; +function g_value_get_uint(value: PGValue): guint; cdecl; external LazGObject2_library name 'g_value_get_uint'; +function g_value_get_uint64(value: PGValue): guint64; cdecl; external LazGObject2_library name 'g_value_get_uint64'; +function g_value_get_ulong(value: PGValue): gulong; cdecl; external LazGObject2_library name 'g_value_get_ulong'; +function g_value_get_variant(value: PGValue): PGVariant; cdecl; external LazGObject2_library name 'g_value_get_variant'; +function g_value_init(value: PGValue; g_type: TGType): PGValue; cdecl; external LazGObject2_library name 'g_value_init'; +function g_value_peek_pointer(value: PGValue): gpointer; cdecl; external LazGObject2_library name 'g_value_peek_pointer'; +function g_value_reset(value: PGValue): PGValue; cdecl; external LazGObject2_library name 'g_value_reset'; +function g_value_transform(src_value: PGValue; dest_value: PGValue): gboolean; cdecl; external LazGObject2_library name 'g_value_transform'; +function g_value_type_compatible(src_type: TGType; dest_type: TGType): gboolean; cdecl; external LazGObject2_library name 'g_value_type_compatible'; +function g_value_type_transformable(src_type: TGType; dest_type: TGType): gboolean; cdecl; external LazGObject2_library name 'g_value_type_transformable'; +function g_weak_ref_get(weak_ref: PGWeakRef): PGObject; cdecl; external LazGObject2_library name 'g_weak_ref_get'; +procedure g_binding_group_bind(self: PGBindingGroup; source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags); cdecl; external LazGObject2_library name 'g_binding_group_bind'; +procedure g_binding_unbind(binding: PGBinding); cdecl; external LazGObject2_library name 'g_binding_unbind'; +procedure g_boxed_free(boxed_type: TGType; boxed: gpointer); cdecl; external LazGObject2_library name 'g_boxed_free'; +procedure g_cclosure_marshal_BOOLEAN__BOXED_BOXED(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_BOOLEAN__BOXED_BOXED'; +procedure g_cclosure_marshal_BOOLEAN__BOXED_BOXEDv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_BOOLEAN__BOXED_BOXEDv'; +procedure g_cclosure_marshal_BOOLEAN__FLAGS(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_BOOLEAN__FLAGS'; +procedure g_cclosure_marshal_BOOLEAN__FLAGSv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_BOOLEAN__FLAGSv'; +procedure g_cclosure_marshal_generic(closure: PGClosure; return_gvalue: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_generic'; +procedure g_cclosure_marshal_generic_va(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args_list: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_generic_va'; +procedure g_cclosure_marshal_STRING__OBJECT_POINTER(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_STRING__OBJECT_POINTER'; +procedure g_cclosure_marshal_STRING__OBJECT_POINTERv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_STRING__OBJECT_POINTERv'; +procedure g_cclosure_marshal_VOID__BOOLEAN(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__BOOLEAN'; +procedure g_cclosure_marshal_VOID__BOOLEANv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__BOOLEANv'; +procedure g_cclosure_marshal_VOID__BOXED(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__BOXED'; +procedure g_cclosure_marshal_VOID__BOXEDv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__BOXEDv'; +procedure g_cclosure_marshal_VOID__CHAR(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__CHAR'; +procedure g_cclosure_marshal_VOID__CHARv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__CHARv'; +procedure g_cclosure_marshal_VOID__DOUBLE(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__DOUBLE'; +procedure g_cclosure_marshal_VOID__DOUBLEv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__DOUBLEv'; +procedure g_cclosure_marshal_VOID__ENUM(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__ENUM'; +procedure g_cclosure_marshal_VOID__ENUMv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__ENUMv'; +procedure g_cclosure_marshal_VOID__FLAGS(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__FLAGS'; +procedure g_cclosure_marshal_VOID__FLAGSv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__FLAGSv'; +procedure g_cclosure_marshal_VOID__FLOAT(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__FLOAT'; +procedure g_cclosure_marshal_VOID__FLOATv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__FLOATv'; +procedure g_cclosure_marshal_VOID__INT(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__INT'; +procedure g_cclosure_marshal_VOID__INTv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__INTv'; +procedure g_cclosure_marshal_VOID__LONG(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__LONG'; +procedure g_cclosure_marshal_VOID__LONGv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__LONGv'; +procedure g_cclosure_marshal_VOID__OBJECT(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__OBJECT'; +procedure g_cclosure_marshal_VOID__OBJECTv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__OBJECTv'; +procedure g_cclosure_marshal_VOID__PARAM(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__PARAM'; +procedure g_cclosure_marshal_VOID__PARAMv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__PARAMv'; +procedure g_cclosure_marshal_VOID__POINTER(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__POINTER'; +procedure g_cclosure_marshal_VOID__POINTERv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__POINTERv'; +procedure g_cclosure_marshal_VOID__STRING(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__STRING'; +procedure g_cclosure_marshal_VOID__STRINGv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__STRINGv'; +procedure g_cclosure_marshal_VOID__UCHAR(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__UCHAR'; +procedure g_cclosure_marshal_VOID__UCHARv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__UCHARv'; +procedure g_cclosure_marshal_VOID__UINT(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__UINT'; +procedure g_cclosure_marshal_VOID__UINT_POINTER(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__UINT_POINTER'; +procedure g_cclosure_marshal_VOID__UINT_POINTERv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__UINT_POINTERv'; +procedure g_cclosure_marshal_VOID__UINTv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__UINTv'; +procedure g_cclosure_marshal_VOID__ULONG(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__ULONG'; +procedure g_cclosure_marshal_VOID__ULONGv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__ULONGv'; +procedure g_cclosure_marshal_VOID__VARIANT(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__VARIANT'; +procedure g_cclosure_marshal_VOID__VARIANTv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__VARIANTv'; +procedure g_cclosure_marshal_VOID__VOID(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__VOID'; +procedure g_cclosure_marshal_VOID__VOIDv(closure: PGClosure; return_value: PGValue; instance: PGTypeInstance; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external LazGObject2_library name 'g_cclosure_marshal_VOID__VOIDv'; +procedure g_clear_object(object_ptr: PPGObject); cdecl; external LazGObject2_library name 'g_clear_object'; +procedure g_clear_signal_handler(handler_id_ptr: Pgulong; instance: PGObject); cdecl; external LazGObject2_library name 'g_clear_signal_handler'; +procedure g_closure_add_finalize_notifier(closure: PGClosure; notify_data: gpointer; notify_func: TGClosureNotify); cdecl; external LazGObject2_library name 'g_closure_add_finalize_notifier'; +procedure g_closure_add_invalidate_notifier(closure: PGClosure; notify_data: gpointer; notify_func: TGClosureNotify); cdecl; external LazGObject2_library name 'g_closure_add_invalidate_notifier'; +procedure g_closure_add_marshal_guards(closure: PGClosure; pre_marshal_data: gpointer; pre_marshal_notify: TGClosureNotify; post_marshal_data: gpointer; post_marshal_notify: TGClosureNotify); cdecl; external LazGObject2_library name 'g_closure_add_marshal_guards'; +procedure g_closure_invalidate(closure: PGClosure); cdecl; external LazGObject2_library name 'g_closure_invalidate'; +procedure g_closure_invoke(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer); cdecl; external LazGObject2_library name 'g_closure_invoke'; +procedure g_closure_remove_finalize_notifier(closure: PGClosure; notify_data: gpointer; notify_func: TGClosureNotify); cdecl; external LazGObject2_library name 'g_closure_remove_finalize_notifier'; +procedure g_closure_remove_invalidate_notifier(closure: PGClosure; notify_data: gpointer; notify_func: TGClosureNotify); cdecl; external LazGObject2_library name 'g_closure_remove_invalidate_notifier'; +procedure g_closure_set_marshal(closure: PGClosure; marshal: TGClosureMarshal); cdecl; external LazGObject2_library name 'g_closure_set_marshal'; +procedure g_closure_set_meta_marshal(closure: PGClosure; marshal_data: gpointer; meta_marshal: TGClosureMarshal); cdecl; external LazGObject2_library name 'g_closure_set_meta_marshal'; +procedure g_closure_sink(closure: PGClosure); cdecl; external LazGObject2_library name 'g_closure_sink'; +procedure g_closure_unref(closure: PGClosure); cdecl; external LazGObject2_library name 'g_closure_unref'; +procedure g_enum_complete_type_info(g_enum_type: TGType; info: PGTypeInfo; const_values: PGEnumValue); cdecl; external LazGObject2_library name 'g_enum_complete_type_info'; +procedure g_flags_complete_type_info(g_flags_type: TGType; info: PGTypeInfo; const_values: PGFlagsValue); cdecl; external LazGObject2_library name 'g_flags_complete_type_info'; +procedure g_object_add_toggle_ref(object_: PGObject; notify: TGToggleNotify; data: gpointer); cdecl; external LazGObject2_library name 'g_object_add_toggle_ref'; +procedure g_object_add_weak_pointer(object_: PGObject; weak_pointer_location: Pgpointer); cdecl; external LazGObject2_library name 'g_object_add_weak_pointer'; +procedure g_object_class_install_properties(oclass: PGObjectClass; n_pspecs: guint; pspecs: PPGParamSpec); cdecl; external LazGObject2_library name 'g_object_class_install_properties'; +procedure g_object_class_install_property(oclass: PGObjectClass; property_id: guint; pspec: PGParamSpec); cdecl; external LazGObject2_library name 'g_object_class_install_property'; +procedure g_object_class_override_property(oclass: PGObjectClass; property_id: guint; name: Pgchar); cdecl; external LazGObject2_library name 'g_object_class_override_property'; +procedure g_object_disconnect(object_: PGObject; signal_spec: Pgchar; args: array of const); cdecl; external LazGObject2_library name 'g_object_disconnect'; +procedure g_object_force_floating(object_: PGObject); cdecl; external LazGObject2_library name 'g_object_force_floating'; +procedure g_object_freeze_notify(object_: PGObject); cdecl; external LazGObject2_library name 'g_object_freeze_notify'; +procedure g_object_get(object_: PGObject; first_property_name: Pgchar; args: array of const); cdecl; external LazGObject2_library name 'g_object_get'; +procedure g_object_get_property(object_: PGObject; property_name: Pgchar; value: PGValue); cdecl; external LazGObject2_library name 'g_object_get_property'; +procedure g_object_get_valist(object_: PGObject; first_property_name: Pgchar; var_args: Tva_list); cdecl; external LazGObject2_library name 'g_object_get_valist'; +procedure g_object_getv(object_: PGObject; n_properties: guint; names: PPgchar; values: PGValue); cdecl; external LazGObject2_library name 'g_object_getv'; +procedure g_object_interface_install_property(g_iface: PGTypeInterface; pspec: PGParamSpec); cdecl; external LazGObject2_library name 'g_object_interface_install_property'; +procedure g_object_notify(object_: PGObject; property_name: Pgchar); cdecl; external LazGObject2_library name 'g_object_notify'; +procedure g_object_notify_by_pspec(object_: PGObject; pspec: PGParamSpec); cdecl; external LazGObject2_library name 'g_object_notify_by_pspec'; +procedure g_object_remove_toggle_ref(object_: PGObject; notify: TGToggleNotify; data: gpointer); cdecl; external LazGObject2_library name 'g_object_remove_toggle_ref'; +procedure g_object_remove_weak_pointer(object_: PGObject; weak_pointer_location: Pgpointer); cdecl; external LazGObject2_library name 'g_object_remove_weak_pointer'; +procedure g_object_run_dispose(object_: PGObject); cdecl; external LazGObject2_library name 'g_object_run_dispose'; +procedure g_object_set(object_: PGObject; first_property_name: Pgchar; args: array of const); cdecl; external LazGObject2_library name 'g_object_set'; +procedure g_object_set_data(object_: PGObject; key: Pgchar; data: gpointer); cdecl; external LazGObject2_library name 'g_object_set_data'; +procedure g_object_set_data_full(object_: PGObject; key: Pgchar; data: gpointer; destroy_: TGDestroyNotify); cdecl; external LazGObject2_library name 'g_object_set_data_full'; +procedure g_object_set_property(object_: PGObject; property_name: Pgchar; value: PGValue); cdecl; external LazGObject2_library name 'g_object_set_property'; +procedure g_object_set_qdata(object_: PGObject; quark: TGQuark; data: gpointer); cdecl; external LazGObject2_library name 'g_object_set_qdata'; +procedure g_object_set_qdata_full(object_: PGObject; quark: TGQuark; data: gpointer; destroy_: TGDestroyNotify); cdecl; external LazGObject2_library name 'g_object_set_qdata_full'; +procedure g_object_set_valist(object_: PGObject; first_property_name: Pgchar; var_args: Tva_list); cdecl; external LazGObject2_library name 'g_object_set_valist'; +procedure g_object_setv(object_: PGObject; n_properties: guint; names: PPgchar; values: PGValue); cdecl; external LazGObject2_library name 'g_object_setv'; +procedure g_object_thaw_notify(object_: PGObject); cdecl; external LazGObject2_library name 'g_object_thaw_notify'; +procedure g_object_unref(object_: PGObject); cdecl; external LazGObject2_library name 'g_object_unref'; +procedure g_object_watch_closure(object_: PGObject; closure: PGClosure); cdecl; external LazGObject2_library name 'g_object_watch_closure'; +procedure g_object_weak_ref(object_: PGObject; notify: TGWeakNotify; data: gpointer); cdecl; external LazGObject2_library name 'g_object_weak_ref'; +procedure g_object_weak_unref(object_: PGObject; notify: TGWeakNotify; data: gpointer); cdecl; external LazGObject2_library name 'g_object_weak_unref'; +procedure g_param_spec_pool_insert(pool: PGParamSpecPool; pspec: PGParamSpec; owner_type: TGType); cdecl; external LazGObject2_library name 'g_param_spec_pool_insert'; +procedure g_param_spec_pool_remove(pool: PGParamSpecPool; pspec: PGParamSpec); cdecl; external LazGObject2_library name 'g_param_spec_pool_remove'; +procedure g_param_spec_set_qdata(pspec: PGParamSpec; quark: TGQuark; data: gpointer); cdecl; external LazGObject2_library name 'g_param_spec_set_qdata'; +procedure g_param_spec_set_qdata_full(pspec: PGParamSpec; quark: TGQuark; data: gpointer; destroy_: TGDestroyNotify); cdecl; external LazGObject2_library name 'g_param_spec_set_qdata_full'; +procedure g_param_spec_sink(pspec: PGParamSpec); cdecl; external LazGObject2_library name 'g_param_spec_sink'; +procedure g_param_spec_unref(pspec: PGParamSpec); cdecl; external LazGObject2_library name 'g_param_spec_unref'; +procedure g_param_value_set_default(pspec: PGParamSpec; value: PGValue); cdecl; external LazGObject2_library name 'g_param_value_set_default'; +procedure g_signal_chain_from_overridden(instance_and_params: PGValue; return_value: PGValue); cdecl; external LazGObject2_library name 'g_signal_chain_from_overridden'; +procedure g_signal_chain_from_overridden_handler(instance: PGTypeInstance; args: array of const); cdecl; external LazGObject2_library name 'g_signal_chain_from_overridden_handler'; +procedure g_signal_emit(instance: PGObject; signal_id: guint; detail: TGQuark; args: array of const); cdecl; external LazGObject2_library name 'g_signal_emit'; +procedure g_signal_emit_by_name(instance: PGObject; detailed_signal: Pgchar; args: array of const); cdecl; external LazGObject2_library name 'g_signal_emit_by_name'; +procedure g_signal_emit_valist(instance: PGTypeInstance; signal_id: guint; detail: TGQuark; var_args: Tva_list); cdecl; external LazGObject2_library name 'g_signal_emit_valist'; +procedure g_signal_emitv(instance_and_params: PGValue; signal_id: guint; detail: TGQuark; return_value: PGValue); cdecl; external LazGObject2_library name 'g_signal_emitv'; +procedure g_signal_handler_block(instance: PGObject; handler_id: gulong); cdecl; external LazGObject2_library name 'g_signal_handler_block'; +procedure g_signal_handler_disconnect(instance: PGObject; handler_id: gulong); cdecl; external LazGObject2_library name 'g_signal_handler_disconnect'; +procedure g_signal_handler_unblock(instance: PGObject; handler_id: gulong); cdecl; external LazGObject2_library name 'g_signal_handler_unblock'; +procedure g_signal_handlers_destroy(instance: PGObject); cdecl; external LazGObject2_library name 'g_signal_handlers_destroy'; +procedure g_signal_override_class_closure(signal_id: guint; instance_type: TGType; class_closure: PGClosure); cdecl; external LazGObject2_library name 'g_signal_override_class_closure'; +procedure g_signal_override_class_handler(signal_name: Pgchar; instance_type: TGType; class_handler: TGCallback); cdecl; external LazGObject2_library name 'g_signal_override_class_handler'; +procedure g_signal_query(signal_id: guint; query: PGSignalQuery); cdecl; external LazGObject2_library name 'g_signal_query'; +procedure g_signal_remove_emission_hook(signal_id: guint; hook_id: gulong); cdecl; external LazGObject2_library name 'g_signal_remove_emission_hook'; +procedure g_signal_set_va_marshaller(signal_id: guint; instance_type: TGType; va_marshaller: TGSignalCVaMarshaller); cdecl; external LazGObject2_library name 'g_signal_set_va_marshaller'; +procedure g_signal_stop_emission(instance: PGObject; signal_id: guint; detail: TGQuark); cdecl; external LazGObject2_library name 'g_signal_stop_emission'; +procedure g_signal_stop_emission_by_name(instance: PGObject; detailed_signal: Pgchar); cdecl; external LazGObject2_library name 'g_signal_stop_emission_by_name'; +procedure g_source_set_closure(source: PGSource; closure: PGClosure); cdecl; external LazGObject2_library name 'g_source_set_closure'; +procedure g_source_set_dummy_callback(source: PGSource); cdecl; external LazGObject2_library name 'g_source_set_dummy_callback'; +procedure g_type_add_class_cache_func(cache_data: gpointer; cache_func: TGTypeClassCacheFunc); cdecl; external LazGObject2_library name 'g_type_add_class_cache_func'; +procedure g_type_add_class_private(class_type: TGType; private_size: gsize); cdecl; external LazGObject2_library name 'g_type_add_class_private'; +procedure g_type_add_interface_check(check_data: gpointer; check_func: TGTypeInterfaceCheckFunc); cdecl; external LazGObject2_library name 'g_type_add_interface_check'; +procedure g_type_add_interface_dynamic(instance_type: TGType; interface_type: TGType; plugin: PGTypePlugin); cdecl; external LazGObject2_library name 'g_type_add_interface_dynamic'; +procedure g_type_add_interface_static(instance_type: TGType; interface_type: TGType; info: PGInterfaceInfo); cdecl; external LazGObject2_library name 'g_type_add_interface_static'; +procedure g_type_class_adjust_private_offset(g_class: gpointer; private_size_or_offset: Pgint); cdecl; external LazGObject2_library name 'g_type_class_adjust_private_offset'; +procedure g_type_class_unref(g_class: PGTypeClass); cdecl; external LazGObject2_library name 'g_type_class_unref'; +procedure g_type_class_unref_uncached(g_class: PGTypeClass); cdecl; external LazGObject2_library name 'g_type_class_unref_uncached'; +procedure g_type_default_interface_unref(g_iface: PGTypeInterface); cdecl; external LazGObject2_library name 'g_type_default_interface_unref'; +procedure g_type_ensure(type_: TGType); cdecl; external LazGObject2_library name 'g_type_ensure'; +procedure g_type_free_instance(instance: PGTypeInstance); cdecl; external LazGObject2_library name 'g_type_free_instance'; +procedure g_type_init; cdecl; external; +procedure g_type_interface_add_prerequisite(interface_type: TGType; prerequisite_type: TGType); cdecl; external LazGObject2_library name 'g_type_interface_add_prerequisite'; +procedure g_type_module_add_interface(module: PGTypeModule; instance_type: TGType; interface_type: TGType; interface_info: PGInterfaceInfo); cdecl; external LazGObject2_library name 'g_type_module_add_interface'; +procedure g_type_module_set_name(module: PGTypeModule; name: Pgchar); cdecl; external LazGObject2_library name 'g_type_module_set_name'; +procedure g_type_module_unuse(module: PGTypeModule); cdecl; external LazGObject2_library name 'g_type_module_unuse'; +procedure g_type_plugin_complete_interface_info(plugin: PGTypePlugin; instance_type: TGType; interface_type: TGType; info: PGInterfaceInfo); cdecl; external LazGObject2_library name 'g_type_plugin_complete_interface_info'; +procedure g_type_plugin_complete_type_info(plugin: PGTypePlugin; g_type: TGType; info: PGTypeInfo; value_table: PGTypeValueTable); cdecl; external LazGObject2_library name 'g_type_plugin_complete_type_info'; +procedure g_type_plugin_unuse(plugin: PGTypePlugin); cdecl; external LazGObject2_library name 'g_type_plugin_unuse'; +procedure g_type_plugin_use(plugin: PGTypePlugin); cdecl; external LazGObject2_library name 'g_type_plugin_use'; +procedure g_type_query(type_: TGType; query: PGTypeQuery); cdecl; external LazGObject2_library name 'g_type_query'; +procedure g_type_remove_class_cache_func(cache_data: gpointer; cache_func: TGTypeClassCacheFunc); cdecl; external LazGObject2_library name 'g_type_remove_class_cache_func'; +procedure g_type_remove_interface_check(check_data: gpointer; check_func: TGTypeInterfaceCheckFunc); cdecl; external LazGObject2_library name 'g_type_remove_interface_check'; +procedure g_type_set_qdata(type_: TGType; quark: TGQuark; data: gpointer); cdecl; external LazGObject2_library name 'g_type_set_qdata'; +procedure g_value_copy(src_value: PGValue; dest_value: PGValue); cdecl; external LazGObject2_library name 'g_value_copy'; +procedure g_value_init_from_instance(value: PGValue; instance: PGTypeInstance); cdecl; external LazGObject2_library name 'g_value_init_from_instance'; +procedure g_value_register_transform_func(src_type: TGType; dest_type: TGType; transform_func: TGValueTransform); cdecl; external LazGObject2_library name 'g_value_register_transform_func'; +procedure g_value_set_boolean(value: PGValue; v_boolean: gboolean); cdecl; external LazGObject2_library name 'g_value_set_boolean'; +procedure g_value_set_boxed(value: PGValue; v_boxed: Pgpointer); cdecl; external LazGObject2_library name 'g_value_set_boxed'; +procedure g_value_set_double(value: PGValue; v_double: gdouble); cdecl; external LazGObject2_library name 'g_value_set_double'; +procedure g_value_set_enum(value: PGValue; v_enum: gint); cdecl; external LazGObject2_library name 'g_value_set_enum'; +procedure g_value_set_flags(value: PGValue; v_flags: guint); cdecl; external LazGObject2_library name 'g_value_set_flags'; +procedure g_value_set_float(value: PGValue; v_float: gfloat); cdecl; external LazGObject2_library name 'g_value_set_float'; +procedure g_value_set_gtype(value: PGValue; v_gtype: TGType); cdecl; external LazGObject2_library name 'g_value_set_gtype'; +procedure g_value_set_instance(value: PGValue; instance: gpointer); cdecl; external LazGObject2_library name 'g_value_set_instance'; +procedure g_value_set_int(value: PGValue; v_int: gint); cdecl; external LazGObject2_library name 'g_value_set_int'; +procedure g_value_set_int64(value: PGValue; v_int64: gint64); cdecl; external LazGObject2_library name 'g_value_set_int64'; +{$IFDEF USEGTK3LATESTBINDINGS} +procedure g_value_set_interned_string(value: PGValue; v_string: Pgchar); cdecl; external LazGObject2_library name 'g_value_set_interned_string'; +{$ENDIF} +procedure g_value_set_long(value: PGValue; v_long: glong); cdecl; external LazGObject2_library name 'g_value_set_long'; +procedure g_value_set_object(value: PGValue; v_object: PGObject); cdecl; external LazGObject2_library name 'g_value_set_object'; +procedure g_value_set_param(value: PGValue; param: PGParamSpec); cdecl; external LazGObject2_library name 'g_value_set_param'; +procedure g_value_set_pointer(value: PGValue; v_pointer: gpointer); cdecl; external LazGObject2_library name 'g_value_set_pointer'; +procedure g_value_set_schar(value: PGValue; v_char: gint8); cdecl; external LazGObject2_library name 'g_value_set_schar'; +procedure g_value_set_static_boxed(value: PGValue; v_boxed: Pgpointer); cdecl; external LazGObject2_library name 'g_value_set_static_boxed'; +procedure g_value_set_static_string(value: PGValue; v_string: Pgchar); cdecl; external LazGObject2_library name 'g_value_set_static_string'; +procedure g_value_set_string(value: PGValue; v_string: Pgchar); cdecl; external LazGObject2_library name 'g_value_set_string'; +procedure g_value_set_uchar(value: PGValue; v_uchar: guint8); cdecl; external LazGObject2_library name 'g_value_set_uchar'; +procedure g_value_set_uint(value: PGValue; v_uint: guint); cdecl; external LazGObject2_library name 'g_value_set_uint'; +procedure g_value_set_uint64(value: PGValue; v_uint64: guint64); cdecl; external LazGObject2_library name 'g_value_set_uint64'; +procedure g_value_set_ulong(value: PGValue; v_ulong: gulong); cdecl; external LazGObject2_library name 'g_value_set_ulong'; +procedure g_value_set_variant(value: PGValue; variant: PGVariant); cdecl; external LazGObject2_library name 'g_value_set_variant'; +procedure g_value_take_boxed(value: PGValue; v_boxed: Pgpointer); cdecl; external LazGObject2_library name 'g_value_take_boxed'; +procedure g_value_take_object(value: PGValue; v_object: gpointer); cdecl; external LazGObject2_library name 'g_value_take_object'; +procedure g_value_take_param(value: PGValue; param: PGParamSpec); cdecl; external LazGObject2_library name 'g_value_take_param'; +procedure g_value_take_string(value: PGValue; v_string: Pgchar); cdecl; external LazGObject2_library name 'g_value_take_string'; +procedure g_value_take_variant(value: PGValue; variant: PGVariant); cdecl; external LazGObject2_library name 'g_value_take_variant'; +procedure g_value_unset(value: PGValue); cdecl; external LazGObject2_library name 'g_value_unset'; +procedure g_weak_ref_clear(weak_ref: PGWeakRef); cdecl; external LazGObject2_library name 'g_weak_ref_clear'; +procedure g_weak_ref_init(weak_ref: PGWeakRef; object_: PGObject); cdecl; external LazGObject2_library name 'g_weak_ref_init'; +procedure g_weak_ref_set(weak_ref: PGWeakRef; object_: PGObject); cdecl; external LazGObject2_library name 'g_weak_ref_set'; +implementation +function TGObject.newv(object_type: TGType; n_parameters: guint; parameters: PGParameter): PGObject; cdecl; +begin + Result := LazGObject2.g_object_newv(object_type, n_parameters, parameters); +end; + +function TGTypeInstance.get_private(private_type: TGType): gpointer; cdecl; +begin + Result := LazGObject2.g_type_instance_get_private(@self, private_type); +end; + +function TGTypeClass.get_instance_private_offset: gint; cdecl; +begin + Result := LazGObject2.g_type_class_get_instance_private_offset(@self); +end; + +function TGTypeClass.get_private(private_type: TGType): gpointer; cdecl; +begin + Result := LazGObject2.g_type_class_get_private(@self, private_type); +end; + +function TGTypeClass.peek_parent: PGTypeClass; cdecl; +begin + Result := LazGObject2.g_type_class_peek_parent(@self); +end; + +procedure TGTypeClass.unref; cdecl; +begin + LazGObject2.g_type_class_unref(@self); +end; + +procedure TGTypeClass.unref_uncached; cdecl; +begin + LazGObject2.g_type_class_unref_uncached(@self); +end; + +procedure TGTypeClass.adjust_private_offset(g_class: gpointer; private_size_or_offset: Pgint); cdecl; +begin + LazGObject2.g_type_class_adjust_private_offset(g_class, private_size_or_offset); +end; + +function TGTypeClass.peek(type_: TGType): PGTypeClass; cdecl; +begin + Result := LazGObject2.g_type_class_peek(type_); +end; + +function TGTypeClass.peek_static(type_: TGType): PGTypeClass; cdecl; +begin + Result := LazGObject2.g_type_class_peek_static(type_); +end; + +function TGTypeClass.ref(type_: TGType): PGTypeClass; cdecl; +begin + Result := LazGObject2.g_type_class_ref(type_); +end; + +function TGObject.new_with_properties(object_type: TGType; n_properties: guint; names: PPgchar; values: PGValue): PGObject; cdecl; +begin + Result := LazGObject2.g_object_new_with_properties(object_type, n_properties, names, values); +end; + +function TGObject.compat_control(what: gsize; data: gpointer): gsize; cdecl; +begin + Result := LazGObject2.g_object_compat_control(what, data); +end; + +function TGTypeInterface.peek_parent: PGTypeInterface; cdecl; +begin + Result := LazGObject2.g_type_interface_peek_parent(@self); +end; + +procedure TGTypeInterface.add_prerequisite(interface_type: TGType; prerequisite_type: TGType); cdecl; +begin + LazGObject2.g_type_interface_add_prerequisite(interface_type, prerequisite_type); +end; + +function TGTypeInterface.get_plugin(instance_type: TGType; interface_type: TGType): PGTypePlugin; cdecl; +begin + Result := LazGObject2.g_type_interface_get_plugin(instance_type, interface_type); +end; + +function TGTypeInterface.peek(instance_class: PGTypeClass; iface_type: TGType): PGTypeInterface; cdecl; +begin + Result := LazGObject2.g_type_interface_peek(instance_class, iface_type); +end; + +function TGTypeInterface.prerequisites(interface_type: TGType; n_prerequisites: Pguint): PGType; cdecl; +begin + Result := LazGObject2.g_type_interface_prerequisites(interface_type, n_prerequisites); +end; + +function TGObject.interface_find_property(g_iface: PGTypeInterface; property_name: Pgchar): PGParamSpec; cdecl; +begin + Result := LazGObject2.g_object_interface_find_property(g_iface, property_name); +end; + +procedure TGObject.interface_install_property(g_iface: PGTypeInterface; pspec: PGParamSpec); cdecl; +begin + LazGObject2.g_object_interface_install_property(g_iface, pspec); +end; + +function TGObject.interface_list_properties(g_iface: PGTypeInterface; n_properties_p: Pguint): PPGParamSpec; cdecl; +begin + Result := LazGObject2.g_object_interface_list_properties(g_iface, n_properties_p); +end; + +procedure TGObject.add_toggle_ref(notify: TGToggleNotify; data: gpointer); cdecl; +begin + LazGObject2.g_object_add_toggle_ref(@self, notify, data); +end; + +procedure TGObject.add_weak_pointer(weak_pointer_location: Pgpointer); cdecl; +begin + LazGObject2.g_object_add_weak_pointer(@self, weak_pointer_location); +end; + +function TGObject.bind_property(source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags): PGBinding; cdecl; +begin + Result := LazGObject2.g_object_bind_property(@self, source_property, target, target_property, flags); +end; + +function TGObject.bind_property_full(source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags; transform_to: TGBindingTransformFunc; transform_from: TGBindingTransformFunc; user_data: gpointer; notify: TGDestroyNotify): PGBinding; cdecl; +begin + Result := LazGObject2.g_object_bind_property_full(@self, source_property, target, target_property, flags, transform_to, transform_from, user_data, notify); +end; + +function TGObject.bind_property_with_closures(source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags; transform_to: PGClosure; transform_from: PGClosure): PGBinding; cdecl; +begin + Result := LazGObject2.g_object_bind_property_with_closures(@self, source_property, target, target_property, flags, transform_to, transform_from); +end; + +function TGObject.dup_data(key: Pgchar; dup_func: TGDuplicateFunc; user_data: gpointer): gpointer; cdecl; +begin + Result := LazGObject2.g_object_dup_data(@self, key, dup_func, user_data); +end; + +function TGObject.dup_qdata(quark: TGQuark; dup_func: TGDuplicateFunc; user_data: gpointer): gpointer; cdecl; +begin + Result := LazGObject2.g_object_dup_qdata(@self, quark, dup_func, user_data); +end; + +procedure TGObject.force_floating; cdecl; +begin + LazGObject2.g_object_force_floating(@self); +end; + +procedure TGObject.freeze_notify; cdecl; +begin + LazGObject2.g_object_freeze_notify(@self); +end; + +function TGObject.get_data(key: Pgchar): gpointer; cdecl; +begin + Result := LazGObject2.g_object_get_data(@self, key); +end; + +procedure TGObject.get_property(property_name: Pgchar; value: PGValue); cdecl; +begin + LazGObject2.g_object_get_property(@self, property_name, value); +end; + +function TGObject.get_qdata(quark: TGQuark): gpointer; cdecl; +begin + Result := LazGObject2.g_object_get_qdata(@self, quark); +end; + +procedure TGObject.getv(n_properties: guint; names: PPgchar; values: PGValue); cdecl; +begin + LazGObject2.g_object_getv(@self, n_properties, names, values); +end; + +function TGObject.is_floating: gboolean; cdecl; +begin + Result := LazGObject2.g_object_is_floating(@self); +end; + +procedure TGObject.notify(property_name: Pgchar); cdecl; +begin + LazGObject2.g_object_notify(@self, property_name); +end; + +procedure TGObject.notify_by_pspec(pspec: PGParamSpec); cdecl; +begin + LazGObject2.g_object_notify_by_pspec(@self, pspec); +end; + +function TGObject.ref: PGObject; cdecl; +begin + Result := LazGObject2.g_object_ref(@self); +end; + +function TGObject.ref_sink: PGObject; cdecl; +begin + Result := LazGObject2.g_object_ref_sink(@self); +end; + +procedure TGObject.remove_toggle_ref(notify: TGToggleNotify; data: gpointer); cdecl; +begin + LazGObject2.g_object_remove_toggle_ref(@self, notify, data); +end; + +procedure TGObject.remove_weak_pointer(weak_pointer_location: Pgpointer); cdecl; +begin + LazGObject2.g_object_remove_weak_pointer(@self, weak_pointer_location); +end; + +function TGObject.replace_data(key: Pgchar; oldval: gpointer; newval: gpointer; destroy_: TGDestroyNotify; old_destroy: PGDestroyNotify): gboolean; cdecl; +begin + Result := LazGObject2.g_object_replace_data(@self, key, oldval, newval, destroy_, old_destroy); +end; + +function TGObject.replace_qdata(quark: TGQuark; oldval: gpointer; newval: gpointer; destroy_: TGDestroyNotify; old_destroy: PGDestroyNotify): gboolean; cdecl; +begin + Result := LazGObject2.g_object_replace_qdata(@self, quark, oldval, newval, destroy_, old_destroy); +end; + +procedure TGObject.run_dispose; cdecl; +begin + LazGObject2.g_object_run_dispose(@self); +end; + +procedure TGObject.set_data(key: Pgchar; data: gpointer); cdecl; +begin + LazGObject2.g_object_set_data(@self, key, data); +end; + +procedure TGObject.set_data_full(key: Pgchar; data: gpointer; destroy_: TGDestroyNotify); cdecl; +begin + LazGObject2.g_object_set_data_full(@self, key, data, destroy_); +end; + +procedure TGObject.set_property(property_name: Pgchar; value: PGValue); cdecl; +begin + LazGObject2.g_object_set_property(@self, property_name, value); +end; + +procedure TGObject.set_qdata(quark: TGQuark; data: gpointer); cdecl; +begin + LazGObject2.g_object_set_qdata(@self, quark, data); +end; + +procedure TGObject.set_qdata_full(quark: TGQuark; data: gpointer; destroy_: TGDestroyNotify); cdecl; +begin + LazGObject2.g_object_set_qdata_full(@self, quark, data, destroy_); +end; + +procedure TGObject.setv(n_properties: guint; names: PPgchar; values: PGValue); cdecl; +begin + LazGObject2.g_object_setv(@self, n_properties, names, values); +end; + +function TGObject.steal_data(key: Pgchar): gpointer; cdecl; +begin + Result := LazGObject2.g_object_steal_data(@self, key); +end; + +function TGObject.steal_qdata(quark: TGQuark): gpointer; cdecl; +begin + Result := LazGObject2.g_object_steal_qdata(@self, quark); +end; + +procedure TGObject.thaw_notify; cdecl; +begin + LazGObject2.g_object_thaw_notify(@self); +end; + +procedure TGObject.unref; cdecl; +begin + LazGObject2.g_object_unref(@self); +end; + +procedure TGObject.watch_closure(closure: PGClosure); cdecl; +begin + LazGObject2.g_object_watch_closure(@self, closure); +end; + +procedure TGObject.weak_ref(notify: TGWeakNotify; data: gpointer); cdecl; +begin + LazGObject2.g_object_weak_ref(@self, notify, data); +end; + +procedure TGObject.weak_unref(notify: TGWeakNotify; data: gpointer); cdecl; +begin + LazGObject2.g_object_weak_unref(@self, notify, data); +end; + +function TGBinding.get_flags: TGBindingFlags; cdecl; +begin + Result := LazGObject2.g_binding_get_flags(@self); +end; + +function TGBinding.get_source_property: Pgchar; cdecl; +begin + Result := LazGObject2.g_binding_get_source_property(@self); +end; + +function TGBinding.get_target_property: Pgchar; cdecl; +begin + Result := LazGObject2.g_binding_get_target_property(@self); +end; + +procedure TGBinding.unbind; cdecl; +begin + LazGObject2.g_binding_unbind(@self); +end; + +function TGClosure.new_object(sizeof_closure: guint; object_: PGObject): PGClosure; cdecl; +begin + Result := LazGObject2.g_closure_new_object(sizeof_closure, object_); +end; + +function TGClosure.new_simple(sizeof_closure: guint; data: gpointer): PGClosure; cdecl; +begin + Result := LazGObject2.g_closure_new_simple(sizeof_closure, data); +end; + +procedure TGClosure.add_finalize_notifier(notify_data: gpointer; notify_func: TGClosureNotify); cdecl; +begin + LazGObject2.g_closure_add_finalize_notifier(@self, notify_data, notify_func); +end; + +procedure TGClosure.add_invalidate_notifier(notify_data: gpointer; notify_func: TGClosureNotify); cdecl; +begin + LazGObject2.g_closure_add_invalidate_notifier(@self, notify_data, notify_func); +end; + +procedure TGClosure.add_marshal_guards(pre_marshal_data: gpointer; pre_marshal_notify: TGClosureNotify; post_marshal_data: gpointer; post_marshal_notify: TGClosureNotify); cdecl; +begin + LazGObject2.g_closure_add_marshal_guards(@self, pre_marshal_data, pre_marshal_notify, post_marshal_data, post_marshal_notify); +end; + +procedure TGClosure.invalidate; cdecl; +begin + LazGObject2.g_closure_invalidate(@self); +end; + +procedure TGClosure.invoke(return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer); cdecl; +begin + LazGObject2.g_closure_invoke(@self, return_value, n_param_values, param_values, invocation_hint); +end; + +function TGClosure.ref: PGClosure; cdecl; +begin + Result := LazGObject2.g_closure_ref(@self); +end; + +procedure TGClosure.remove_finalize_notifier(notify_data: gpointer; notify_func: TGClosureNotify); cdecl; +begin + LazGObject2.g_closure_remove_finalize_notifier(@self, notify_data, notify_func); +end; + +procedure TGClosure.remove_invalidate_notifier(notify_data: gpointer; notify_func: TGClosureNotify); cdecl; +begin + LazGObject2.g_closure_remove_invalidate_notifier(@self, notify_data, notify_func); +end; + +procedure TGClosure.set_marshal(marshal: TGClosureMarshal); cdecl; +begin + LazGObject2.g_closure_set_marshal(@self, marshal); +end; + +procedure TGClosure.set_meta_marshal(marshal_data: gpointer; meta_marshal: TGClosureMarshal); cdecl; +begin + LazGObject2.g_closure_set_meta_marshal(@self, marshal_data, meta_marshal); +end; + +procedure TGClosure.sink; cdecl; +begin + LazGObject2.g_closure_sink(@self); +end; + +procedure TGClosure.unref; cdecl; +begin + LazGObject2.g_closure_unref(@self); +end; + +procedure TGValue.copy(dest_value: PGValue); cdecl; +begin + LazGObject2.g_value_copy(@self, dest_value); +end; + +function TGValue.dup_boxed: gpointer; cdecl; +begin + Result := LazGObject2.g_value_dup_boxed(@self); +end; + +function TGValue.dup_object: PGObject; cdecl; +begin + Result := LazGObject2.g_value_dup_object(@self); +end; + +function TGValue.dup_param: PGParamSpec; cdecl; +begin + Result := LazGObject2.g_value_dup_param(@self); +end; + +function TGValue.dup_string: Pgchar; cdecl; +begin + Result := LazGObject2.g_value_dup_string(@self); +end; + +function TGValue.dup_variant: PGVariant; cdecl; +begin + Result := LazGObject2.g_value_dup_variant(@self); +end; + +function TGValue.fits_pointer: gboolean; cdecl; +begin + Result := LazGObject2.g_value_fits_pointer(@self); +end; + +function TGValue.get_boolean: gboolean; cdecl; +begin + Result := LazGObject2.g_value_get_boolean(@self); +end; + +function TGValue.get_boxed: gpointer; cdecl; +begin + Result := LazGObject2.g_value_get_boxed(@self); +end; + +function TGValue.get_double: gdouble; cdecl; +begin + Result := LazGObject2.g_value_get_double(@self); +end; + +function TGValue.get_enum: gint; cdecl; +begin + Result := LazGObject2.g_value_get_enum(@self); +end; + +function TGValue.get_flags: guint; cdecl; +begin + Result := LazGObject2.g_value_get_flags(@self); +end; + +function TGValue.get_float: gfloat; cdecl; +begin + Result := LazGObject2.g_value_get_float(@self); +end; + +function TGValue.get_gtype: TGType; cdecl; +begin + Result := LazGObject2.g_value_get_gtype(@self); +end; + +function TGValue.get_int: gint; cdecl; +begin + Result := LazGObject2.g_value_get_int(@self); +end; + +function TGValue.get_int64: gint64; cdecl; +begin + Result := LazGObject2.g_value_get_int64(@self); +end; + +function TGValue.get_long: glong; cdecl; +begin + Result := LazGObject2.g_value_get_long(@self); +end; + +function TGValue.get_object: PGObject; cdecl; +begin + Result := LazGObject2.g_value_get_object(@self); +end; + +function TGValue.get_param: PGParamSpec; cdecl; +begin + Result := LazGObject2.g_value_get_param(@self); +end; + +function TGValue.get_pointer: gpointer; cdecl; +begin + Result := LazGObject2.g_value_get_pointer(@self); +end; + +function TGValue.get_schar: gint8; cdecl; +begin + Result := LazGObject2.g_value_get_schar(@self); +end; + +function TGValue.get_string: Pgchar; cdecl; +begin + Result := LazGObject2.g_value_get_string(@self); +end; + +function TGValue.get_uchar: guint8; cdecl; +begin + Result := LazGObject2.g_value_get_uchar(@self); +end; + +function TGValue.get_uint: guint; cdecl; +begin + Result := LazGObject2.g_value_get_uint(@self); +end; + +function TGValue.get_uint64: guint64; cdecl; +begin + Result := LazGObject2.g_value_get_uint64(@self); +end; + +function TGValue.get_ulong: gulong; cdecl; +begin + Result := LazGObject2.g_value_get_ulong(@self); +end; + +function TGValue.get_variant: PGVariant; cdecl; +begin + Result := LazGObject2.g_value_get_variant(@self); +end; + +function TGValue.init(g_type: TGType): PGValue; cdecl; +begin + Result := LazGObject2.g_value_init(@self, g_type); +end; + +procedure TGValue.init_from_instance(instance: PGTypeInstance); cdecl; +begin + LazGObject2.g_value_init_from_instance(@self, instance); +end; + +function TGValue.peek_pointer: gpointer; cdecl; +begin + Result := LazGObject2.g_value_peek_pointer(@self); +end; + +function TGValue.reset: PGValue; cdecl; +begin + Result := LazGObject2.g_value_reset(@self); +end; + +procedure TGValue.set_boolean(v_boolean: gboolean); cdecl; +begin + LazGObject2.g_value_set_boolean(@self, v_boolean); +end; + +procedure TGValue.set_boxed(v_boxed: Pgpointer); cdecl; +begin + LazGObject2.g_value_set_boxed(@self, v_boxed); +end; + +procedure TGValue.set_double(v_double: gdouble); cdecl; +begin + LazGObject2.g_value_set_double(@self, v_double); +end; + +procedure TGValue.set_enum(v_enum: gint); cdecl; +begin + LazGObject2.g_value_set_enum(@self, v_enum); +end; + +procedure TGValue.set_flags(v_flags: guint); cdecl; +begin + LazGObject2.g_value_set_flags(@self, v_flags); +end; + +procedure TGValue.set_float(v_float: gfloat); cdecl; +begin + LazGObject2.g_value_set_float(@self, v_float); +end; + +procedure TGValue.set_gtype(v_gtype: TGType); cdecl; +begin + LazGObject2.g_value_set_gtype(@self, v_gtype); +end; + +procedure TGValue.set_instance(instance: gpointer); cdecl; +begin + LazGObject2.g_value_set_instance(@self, instance); +end; + +procedure TGValue.set_int(v_int: gint); cdecl; +begin + LazGObject2.g_value_set_int(@self, v_int); +end; + +procedure TGValue.set_int64(v_int64: gint64); cdecl; +begin + LazGObject2.g_value_set_int64(@self, v_int64); +end; + +{$IFDEF USEGTK3LATESTBINDINGS} +procedure TGValue.set_interned_string(v_string: Pgchar); cdecl; +begin + LazGObject2.g_value_set_interned_string(@self, v_string); +end; +{$ENDIF} + +procedure TGValue.set_long(v_long: glong); cdecl; +begin + LazGObject2.g_value_set_long(@self, v_long); +end; + +procedure TGValue.set_object(v_object: PGObject); cdecl; +begin + LazGObject2.g_value_set_object(@self, v_object); +end; + +procedure TGValue.set_param(param: PGParamSpec); cdecl; +begin + LazGObject2.g_value_set_param(@self, param); +end; + +procedure TGValue.set_pointer(v_pointer: gpointer); cdecl; +begin + LazGObject2.g_value_set_pointer(@self, v_pointer); +end; + +procedure TGValue.set_schar(v_char: gint8); cdecl; +begin + LazGObject2.g_value_set_schar(@self, v_char); +end; + +procedure TGValue.set_static_boxed(v_boxed: Pgpointer); cdecl; +begin + LazGObject2.g_value_set_static_boxed(@self, v_boxed); +end; + +procedure TGValue.set_static_string(v_string: Pgchar); cdecl; +begin + LazGObject2.g_value_set_static_string(@self, v_string); +end; + +procedure TGValue.set_string(v_string: Pgchar); cdecl; +begin + LazGObject2.g_value_set_string(@self, v_string); +end; + +procedure TGValue.set_uchar(v_uchar: guint8); cdecl; +begin + LazGObject2.g_value_set_uchar(@self, v_uchar); +end; + +procedure TGValue.set_uint(v_uint: guint); cdecl; +begin + LazGObject2.g_value_set_uint(@self, v_uint); +end; + +procedure TGValue.set_uint64(v_uint64: guint64); cdecl; +begin + LazGObject2.g_value_set_uint64(@self, v_uint64); +end; + +procedure TGValue.set_ulong(v_ulong: gulong); cdecl; +begin + LazGObject2.g_value_set_ulong(@self, v_ulong); +end; + +procedure TGValue.set_variant(variant: PGVariant); cdecl; +begin + LazGObject2.g_value_set_variant(@self, variant); +end; + +procedure TGValue.take_boxed(v_boxed: Pgpointer); cdecl; +begin + LazGObject2.g_value_take_boxed(@self, v_boxed); +end; + +procedure TGValue.take_object(v_object: gpointer); cdecl; +begin + LazGObject2.g_value_take_object(@self, v_object); +end; + +procedure TGValue.take_param(param: PGParamSpec); cdecl; +begin + LazGObject2.g_value_take_param(@self, param); +end; + +procedure TGValue.take_string(v_string: Pgchar); cdecl; +begin + LazGObject2.g_value_take_string(@self, v_string); +end; + +procedure TGValue.take_variant(variant: PGVariant); cdecl; +begin + LazGObject2.g_value_take_variant(@self, variant); +end; + +function TGValue.transform(dest_value: PGValue): gboolean; cdecl; +begin + Result := LazGObject2.g_value_transform(@self, dest_value); +end; + +procedure TGValue.unset; cdecl; +begin + LazGObject2.g_value_unset(@self); +end; + +procedure TGValue.register_transform_func(src_type: TGType; dest_type: TGType; transform_func: TGValueTransform); cdecl; +begin + LazGObject2.g_value_register_transform_func(src_type, dest_type, transform_func); +end; + +function TGValue.type_compatible(src_type: TGType; dest_type: TGType): gboolean; cdecl; +begin + Result := LazGObject2.g_value_type_compatible(src_type, dest_type); +end; + +function TGValue.type_transformable(src_type: TGType; dest_type: TGType): gboolean; cdecl; +begin + Result := LazGObject2.g_value_type_transformable(src_type, dest_type); +end; + +procedure TGValue.clear; +begin + fillchar(Self,sizeof(Self),0); +end; + +procedure TGCClosure.marshal_BOOLEAN__BOXED_BOXED(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_BOOLEAN__BOXED_BOXED(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_BOOLEAN__FLAGS(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_BOOLEAN__FLAGS(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_STRING__OBJECT_POINTER(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_STRING__OBJECT_POINTER(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_VOID__BOOLEAN(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_VOID__BOOLEAN(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_VOID__BOXED(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_VOID__BOXED(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_VOID__CHAR(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_VOID__CHAR(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_VOID__DOUBLE(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_VOID__DOUBLE(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_VOID__ENUM(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_VOID__ENUM(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_VOID__FLAGS(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_VOID__FLAGS(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_VOID__FLOAT(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_VOID__FLOAT(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_VOID__INT(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_VOID__INT(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_VOID__LONG(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_VOID__LONG(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_VOID__OBJECT(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_VOID__OBJECT(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_VOID__PARAM(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_VOID__PARAM(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_VOID__POINTER(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_VOID__POINTER(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_VOID__STRING(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_VOID__STRING(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_VOID__UCHAR(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_VOID__UCHAR(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_VOID__UINT(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_VOID__UINT(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_VOID__UINT_POINTER(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_VOID__UINT_POINTER(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_VOID__ULONG(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_VOID__ULONG(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_VOID__VARIANT(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_VOID__VARIANT(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_VOID__VOID(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_VOID__VOID(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data); +end; + +procedure TGCClosure.marshal_generic(closure: PGClosure; return_gvalue: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; +begin + LazGObject2.g_cclosure_marshal_generic(closure, return_gvalue, n_param_values, param_values, invocation_hint, marshal_data); +end; + +function TGCClosure.new(callback_func: TGCallback; user_data: gpointer; destroy_data: TGClosureNotify): PGClosure; cdecl; +begin + Result := LazGObject2.g_cclosure_new(callback_func, user_data, destroy_data); +end; + +function TGCClosure.new_object(callback_func: TGCallback; object_: PGObject): PGClosure; cdecl; +begin + Result := LazGObject2.g_cclosure_new_object(callback_func, object_); +end; + +function TGCClosure.new_object_swap(callback_func: TGCallback; object_: PGObject): PGClosure; cdecl; +begin + Result := LazGObject2.g_cclosure_new_object_swap(callback_func, object_); +end; + +function TGCClosure.new_swap(callback_func: TGCallback; user_data: gpointer; destroy_data: TGClosureNotify): PGClosure; cdecl; +begin + Result := LazGObject2.g_cclosure_new_swap(callback_func, user_data, destroy_data); +end; + +function TGParamSpec.internal(param_type: TGType; name: Pgchar; nick: Pgchar; blurb: Pgchar; flags: TGParamFlags): PGParamSpec; cdecl; +begin + Result := LazGObject2.g_param_spec_internal(param_type, name, nick, blurb, flags); +end; + +{$IFDEF USEGTK3LATESTBINDINGS} +function TGParamSpec.is_valid_name(name: Pgchar): gboolean; cdecl; +begin + Result := LazGObject2.g_param_spec_is_valid_name(name); +end; +{$ENDIF} + +function TGParamSpec.get_blurb: Pgchar; cdecl; +begin + Result := LazGObject2.g_param_spec_get_blurb(@self); +end; + +function TGParamSpec.get_default_value: PGValue; cdecl; +begin + Result := LazGObject2.g_param_spec_get_default_value(@self); +end; + +function TGParamSpec.get_name: Pgchar; cdecl; +begin + Result := LazGObject2.g_param_spec_get_name(@self); +end; + +function TGParamSpec.get_name_quark: TGQuark; cdecl; +begin + Result := LazGObject2.g_param_spec_get_name_quark(@self); +end; + +function TGParamSpec.get_nick: Pgchar; cdecl; +begin + Result := LazGObject2.g_param_spec_get_nick(@self); +end; + +function TGParamSpec.get_qdata(quark: TGQuark): gpointer; cdecl; +begin + Result := LazGObject2.g_param_spec_get_qdata(@self, quark); +end; + +function TGParamSpec.get_redirect_target: PGParamSpec; cdecl; +begin + Result := LazGObject2.g_param_spec_get_redirect_target(@self); +end; + +function TGParamSpec.ref: PGParamSpec; cdecl; +begin + Result := LazGObject2.g_param_spec_ref(@self); +end; + +function TGParamSpec.ref_sink: PGParamSpec; cdecl; +begin + Result := LazGObject2.g_param_spec_ref_sink(@self); +end; + +procedure TGParamSpec.set_qdata(quark: TGQuark; data: gpointer); cdecl; +begin + LazGObject2.g_param_spec_set_qdata(@self, quark, data); +end; + +procedure TGParamSpec.set_qdata_full(quark: TGQuark; data: gpointer; destroy_: TGDestroyNotify); cdecl; +begin + LazGObject2.g_param_spec_set_qdata_full(@self, quark, data, destroy_); +end; + +procedure TGParamSpec.sink; cdecl; +begin + LazGObject2.g_param_spec_sink(@self); +end; + +function TGParamSpec.steal_qdata(quark: TGQuark): gpointer; cdecl; +begin + Result := LazGObject2.g_param_spec_steal_qdata(@self, quark); +end; + +procedure TGParamSpec.unref; cdecl; +begin + LazGObject2.g_param_spec_unref(@self); +end; + +function TGObjectClass.find_property(property_name: Pgchar): PGParamSpec; cdecl; +begin + Result := LazGObject2.g_object_class_find_property(@self, property_name); +end; + +procedure TGObjectClass.install_properties(n_pspecs: guint; pspecs: PPGParamSpec); cdecl; +begin + LazGObject2.g_object_class_install_properties(@self, n_pspecs, pspecs); +end; + +procedure TGObjectClass.install_property(property_id: guint; pspec: PGParamSpec); cdecl; +begin + LazGObject2.g_object_class_install_property(@self, property_id, pspec); +end; + +function TGObjectClass.list_properties(n_properties: Pguint): PPGParamSpec; cdecl; +begin + Result := LazGObject2.g_object_class_list_properties(@self, n_properties); +end; + +procedure TGObjectClass.override_property(property_id: guint; name: Pgchar); cdecl; +begin + LazGObject2.g_object_class_override_property(@self, property_id, name); +end; + +procedure TGParamSpecPool.insert(pspec: PGParamSpec; owner_type: TGType); cdecl; +begin + LazGObject2.g_param_spec_pool_insert(@self, pspec, owner_type); +end; + +function TGParamSpecPool.list(owner_type: TGType; n_pspecs_p: Pguint): PPGParamSpec; cdecl; +begin + Result := LazGObject2.g_param_spec_pool_list(@self, owner_type, n_pspecs_p); +end; + +function TGParamSpecPool.list_owned(owner_type: TGType): PGList; cdecl; +begin + Result := LazGObject2.g_param_spec_pool_list_owned(@self, owner_type); +end; + +function TGParamSpecPool.lookup(param_name: Pgchar; owner_type: TGType; walk_ancestors: gboolean): PGParamSpec; cdecl; +begin + Result := LazGObject2.g_param_spec_pool_lookup(@self, param_name, owner_type, walk_ancestors); +end; + +procedure TGParamSpecPool.remove(pspec: PGParamSpec); cdecl; +begin + LazGObject2.g_param_spec_pool_remove(@self, pspec); +end; + +function TGParamSpecPool.new(type_prefixing: gboolean): PGParamSpecPool; cdecl; +begin + Result := LazGObject2.g_param_spec_pool_new(type_prefixing); +end; + +function TGTypeValueTable.peek(type_: TGType): PGTypeValueTable; cdecl; +begin + Result := LazGObject2.g_type_value_table_peek(type_); +end; + +procedure TGTypePlugin.complete_interface_info(instance_type: TGType; interface_type: TGType; info: PGInterfaceInfo); cdecl; +begin + LazGObject2.g_type_plugin_complete_interface_info(@self, instance_type, interface_type, info); +end; + +procedure TGTypePlugin.complete_type_info(g_type: TGType; info: PGTypeInfo; value_table: PGTypeValueTable); cdecl; +begin + LazGObject2.g_type_plugin_complete_type_info(@self, g_type, info, value_table); +end; + +procedure TGTypePlugin.unuse; cdecl; +begin + LazGObject2.g_type_plugin_unuse(@self); +end; + +procedure TGTypePlugin.use; cdecl; +begin + LazGObject2.g_type_plugin_use(@self); +end; + +procedure TGTypeModule.add_interface(instance_type: TGType; interface_type: TGType; interface_info: PGInterfaceInfo); cdecl; +begin + LazGObject2.g_type_module_add_interface(@self, instance_type, interface_type, interface_info); +end; + +function TGTypeModule.register_enum(name: Pgchar; const_static_values: PGEnumValue): TGType; cdecl; +begin + Result := LazGObject2.g_type_module_register_enum(@self, name, const_static_values); +end; + +function TGTypeModule.register_flags(name: Pgchar; const_static_values: PGFlagsValue): TGType; cdecl; +begin + Result := LazGObject2.g_type_module_register_flags(@self, name, const_static_values); +end; + +function TGTypeModule.register_type(parent_type: TGType; type_name: Pgchar; type_info: PGTypeInfo; flags: TGTypeFlags): TGType; cdecl; +begin + Result := LazGObject2.g_type_module_register_type(@self, parent_type, type_name, type_info, flags); +end; + +procedure TGTypeModule.set_name(name: Pgchar); cdecl; +begin + LazGObject2.g_type_module_set_name(@self, name); +end; + +procedure TGTypeModule.unuse; cdecl; +begin + LazGObject2.g_type_module_unuse(@self); +end; + +function TGTypeModule.use: gboolean; cdecl; +begin + Result := LazGObject2.g_type_module_use(@self); +end; + +procedure TGWeakRef.clear; cdecl; +begin + LazGObject2.g_weak_ref_clear(@self); +end; + +function TGWeakRef.get: PGObject; cdecl; +begin + Result := LazGObject2.g_weak_ref_get(@self); +end; + +procedure TGWeakRef.init(object_: PGObject); cdecl; +begin + LazGObject2.g_weak_ref_init(@self, object_); +end; + +procedure TGWeakRef.set_(object_: PGObject); cdecl; +begin + LazGObject2.g_weak_ref_set(@self, object_); +end; + +end. |