{ This is an autogenerated unit using gobject introspection (gir2pascal). Do not Edit. }
unit GObject2;

{$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, GLib2;

const
  {$ifdef MsWindows}
  GObject2_library = 'libgobject-2.0.so.dll';
  {$else}
  GObject2_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 = 1020;
  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_COLLECT_FORMAT_MAX_LENGTH = 8;
  G_VALUE_INTERNED_STRING = 268435456;
  G_VALUE_NOCOPY_CONTENTS = 134217728;
type


  { TGBindingFlags }
  PPGBindingFlags = ^PGBindingFlags;
  PGBindingFlags = ^TGBindingFlags;
  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


  { TGConnectFlags }
  PPGConnectFlags = ^PGConnectFlags;
  PGConnectFlags = ^TGConnectFlags;
  TGConnectFlagsIdx = (
    TGConnectFlagsIdxMinValue = 0,
    G_CONNECT_AFTER = 0,
    G_CONNECT_SWAPPED = 1,
    TGConnectFlagsIdxMaxValue = 31
  );
  TGConnectFlags = Set of TGConnectFlagsIdx;

const
  G_CONNECT_DEFAULT = []; {0 = $00000000}


type


  { TGIOCondition }
  PPGIOCondition = ^PGIOCondition;
  PGIOCondition = ^TGIOCondition;
  TGIOConditionIdx = (
    TGIOConditionIdxMinValue = 0,
    G_IO_IN = 0,
    G_IO_PRI = 1,
    G_IO_OUT = 2,
    G_IO_ERR = 3,
    G_IO_HUP = 4,
    G_IO_NVAL = 5,
    TGIOConditionIdxMaxValue = 31
  );
  TGIOCondition = Set of TGIOConditionIdx;


  { TGParamFlags }
  PPGParamFlags = ^PGParamFlags;
  PGParamFlags = ^TGParamFlags;
  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


  { TGSignalFlags }
  PPGSignalFlags = ^PGSignalFlags;
  PGSignalFlags = ^TGSignalFlags;
  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;


  { TGSignalMatchType }
  PPGSignalMatchType = ^PGSignalMatchType;
  PGSignalMatchType = ^TGSignalMatchType;
  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;


  { TGTypeDebugFlags }
  PPGTypeDebugFlags = ^PGTypeDebugFlags;
  PGTypeDebugFlags = ^TGTypeDebugFlags;
  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


  { TGTypeFlags }
  PPGTypeFlags = ^PGTypeFlags;
  PGTypeFlags = ^TGTypeFlags;
  TGTypeFlagsIdx = (
    TGTypeFlagsIdxMinValue = 0,
    G_TYPE_FLAG_ABSTRACT = 4,
    G_TYPE_FLAG_VALUE_ABSTRACT = 5,
    G_TYPE_FLAG_FINAL = 6,
    G_TYPE_FLAG_DEPRECATED = 7,
    TGTypeFlagsIdxMaxValue = 31
  );
  TGTypeFlags = Set of TGTypeFlagsIdx;

const
  G_TYPE_FLAG_NONE = []; {0 = $00000000}


type


  { TGTypeFundamentalFlags }
  PPGTypeFundamentalFlags = ^PGTypeFundamentalFlags;
  PGTypeFundamentalFlags = ^TGTypeFundamentalFlags;
  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;


  { TGClosure }
  PPGClosure = ^PGClosure;
  PGClosure = ^TGClosure;


  { TGValue }
  PPPGValue = ^PPGValue;
  PPGValue = ^PGValue;
  PGValue = ^TGValue;
  TGClosureMarshal = procedure(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_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;
    procedure add_private(private_size: gsize); cdecl; inline; deprecated 'Use the G_ADD_PRIVATE() macro with the `G_DEFINE_*`   family of macros to add instance private data to a type';
    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; deprecated 'Type class reference counting has been removed and type    classes now cannot be finalized. This function no longer does anything.';
    procedure unref_uncached; cdecl; inline; deprecated 'Type class reference counting has been removed and type    classes now cannot be finalized. This function no longer does anything.';
    procedure adjust_private_offset(g_class: gpointer; private_size_or_offset: Pgint); cdecl; inline; static;
    function get(type_: TGType): PGTypeClass; 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; deprecated 'Use g_type_class_get() instead';
  end;
  TGBaseFinalizeFunc = procedure(g_class: PGTypeClass); cdecl;
  TGBaseInitFunc = procedure(g_class: PGTypeClass); cdecl;


  { TGObject }
  PPPGObject = ^PPGObject;
  PPGObject = ^PGObject;
  PGObject = ^TGObject;


  { TGParameter }
  PPGParameter = ^PGParameter;
  PGParameter = ^TGParameter;


  { 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 instantiatable_prerequisite(interface_type: TGType): TGType; 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;


  { 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 new_with_properties(object_type: TGType; n_properties: guint; names: PPgchar; values: PGValue): PGObject; cdecl; inline; static;
    function newv(object_type: TGType; n_parameters: guint; parameters: PGParameter): PGObject; cdecl; inline; static; deprecated 'Use g_object_new_with_properties() instead. deprecated. See #GParameter for more information.';
    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;
    function take_ref: PGObject; 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 dup_source: PGObject; cdecl; inline;
    function dup_target: PGObject; cdecl; inline;
    function get_flags: TGBindingFlags; cdecl; inline;
    function get_source: PGObject; cdecl; inline; deprecated 'Use g_binding_dup_source() for a safer version of this function.';
    function get_source_property: Pgchar; cdecl; inline;
    function get_target: PGObject; cdecl; inline; deprecated 'Use g_binding_dup_target() for a safer version of this function.';
    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: PGObject 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: PGObject 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)
    function new: PGBindingGroup; cdecl; inline; static;
    procedure bind(source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags); cdecl; inline;
    procedure bind_full(source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags; transform_to: TGBindingTransformFunc; transform_from: TGBindingTransformFunc; user_data: gpointer; user_data_destroy: TGDestroyNotify); cdecl; inline;
    procedure bind_with_closures(source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags; transform_to: PGClosure; transform_from: PGClosure); cdecl; inline;
    function dup_source: PGObject; cdecl; inline;
    procedure set_source(source: PGObject); cdecl; inline;
    //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_char: gchar; cdecl; inline; deprecated 'This function''s return type is broken, see g_value_get_schar()';
    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_boxed_take_ownership(v_boxed: Pgpointer); cdecl; inline; deprecated 'Use g_value_take_boxed() instead.';
    procedure set_char(v_char: gchar); cdecl; inline; deprecated 'This function''s input type is broken, see g_value_set_schar()';
    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;
    procedure set_interned_string(v_string: Pgchar); cdecl; inline;
    procedure set_long(v_long: glong); cdecl; inline;
    procedure set_object(v_object: PGObject); cdecl; inline;
    procedure set_object_take_ownership(v_object: gpointer); cdecl; inline; deprecated 'Use g_value_take_object() instead.';
    procedure set_param(param: PGParamSpec); cdecl; inline;
    procedure set_param_take_ownership(param: PGParamSpec); cdecl; inline; deprecated 'Use g_value_take_param() instead.';
    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_string_take_ownership(v_string: Pgchar); cdecl; inline; deprecated 'Use g_value_take_string() instead.';
    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;
    function steal_string: Pgchar; 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;
  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;




  { 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;


  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;
    function is_valid_name(name: Pgchar): gboolean; cdecl; inline; static;
    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 = 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 free; cdecl; inline;
    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;

  TGSignalInvocationHint = record
    signal_id: guint;
    detail: TGQuark;
    run_type: TGSignalFlags;
  end;


  TGSignalAccumulator = function(ihint: PGSignalInvocationHint; return_accu: PGValue; handler_return: PGValue; data: gpointer): gboolean; cdecl;
  TGSignalEmissionHook = function(ihint: PGSignalInvocationHint; n_param_values: guint; param_values: PGValue; data: gpointer): gboolean; cdecl;


  { TGSignalGroup }
  PPGSignalGroup = ^PGSignalGroup;
  PGSignalGroup = ^TGSignalGroup;
  TGSignalGroup = object(TGObject)
    function new(target_type: TGType): PGSignalGroup; cdecl; inline; static;
    procedure block; cdecl; inline;
    procedure connect(detailed_signal: Pgchar; c_handler: TGCallback; data: gpointer); cdecl; inline;
    procedure connect_after(detailed_signal: Pgchar; c_handler: TGCallback; data: gpointer); cdecl; inline;
    procedure connect_closure(detailed_signal: Pgchar; closure: PGClosure; after: gboolean); cdecl; inline;
    procedure connect_data(detailed_signal: Pgchar; c_handler: TGCallback; data: gpointer; notify: TGClosureNotify; flags: TGConnectFlags); cdecl; inline;
    procedure connect_object(detailed_signal: Pgchar; c_handler: TGCallback; object_: gpointer; flags: TGConnectFlags); cdecl; inline;
    procedure connect_swapped(detailed_signal: Pgchar; c_handler: TGCallback; data: gpointer); cdecl; inline;
    function dup_target: PGObject; cdecl; inline;
    procedure set_target(target: PGObject); cdecl; inline;
    procedure unblock; cdecl; inline;
    //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;


  { 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
    case longint of
      0 : (v_int: gint);
      1 : (v_long: glong);
      2 : (v_int64: gint64);
      3 : (v_double: gdouble);
      4 : (v_pointer: gpointer);
  end;


  TGTypeClassCacheFunc = function(cache_data: gpointer; g_class: PGTypeClass): gboolean; cdecl;


  { TGTypeFundamentalInfo }
  PPGTypeFundamentalInfo = ^PGTypeFundamentalInfo;
  PGTypeFundamentalInfo = ^TGTypeFundamentalInfo;

  TGTypeFundamentalInfo = record
    type_flags: TGTypeFundamentalFlags;
  end;




  { TGTypeValueTable }
  PPGTypeValueTable = ^PGTypeValueTable;
  PGTypeValueTable = ^TGTypeValueTable;


  { TGTypeValueInitFunc }
  PPGTypeValueInitFunc = ^PGTypeValueInitFunc;
  PGTypeValueInitFunc = ^TGTypeValueInitFunc;
  TGTypeValueInitFunc = procedure(value: PGValue); cdecl;


  { TGTypeValueFreeFunc }
  PPGTypeValueFreeFunc = ^PGTypeValueFreeFunc;
  PGTypeValueFreeFunc = ^TGTypeValueFreeFunc;
  TGTypeValueFreeFunc = procedure(value: PGValue); cdecl;


  { TGTypeValueCopyFunc }
  PPGTypeValueCopyFunc = ^PGTypeValueCopyFunc;
  PGTypeValueCopyFunc = ^TGTypeValueCopyFunc;
  TGTypeValueCopyFunc = procedure(src_value: PGValue; dest_value: PGValue); cdecl;


  { TGTypeValuePeekPointerFunc }
  PPGTypeValuePeekPointerFunc = ^PGTypeValuePeekPointerFunc;
  PGTypeValuePeekPointerFunc = ^TGTypeValuePeekPointerFunc;
  TGTypeValuePeekPointerFunc = function(value: PGValue): gpointer; cdecl;


  { TGTypeValueCollectFunc }
  PPGTypeValueCollectFunc = ^PGTypeValueCollectFunc;
  PGTypeValueCollectFunc = ^TGTypeValueCollectFunc;
  TGTypeValueCollectFunc = function(value: PGValue; n_collect_values: guint; collect_values: PGTypeCValue; collect_flags: guint): Pgchar; cdecl;


  { TGTypeValueLCopyFunc }
  PPGTypeValueLCopyFunc = ^PGTypeValueLCopyFunc;
  PGTypeValueLCopyFunc = ^TGTypeValueLCopyFunc;
  TGTypeValueLCopyFunc = function(value: PGValue; n_collect_values: guint; collect_values: PGTypeCValue; collect_flags: guint): Pgchar; cdecl;
  TGTypeValueTable = object
    value_init: TGTypeValueInitFunc;
    value_free: TGTypeValueFreeFunc;
    value_copy: TGTypeValueCopyFunc;
    value_peek_pointer: TGTypeValuePeekPointerFunc;
    collect_format: Pgchar;
    collect_value: TGTypeValueCollectFunc;
    lcopy_format: Pgchar;
    lcopy_value: TGTypeValueLCopyFunc;
    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;
    function new(n_prealloced: guint): PGValueArray; cdecl; inline; static; deprecated 'Use #GArray and g_array_sized_new() instead.';
    function append(value: PGValue): PGValueArray; cdecl; inline; deprecated 'Use #GArray and g_array_append_val() instead.';
    function copy: PGValueArray; cdecl; inline; deprecated 'Use #GArray and g_array_ref() instead.';
    procedure free; cdecl; inline; deprecated 'Use #GArray and g_array_unref() instead.';
    function get_nth(index_: guint): PGValue; cdecl; inline; deprecated 'Use g_array_index() instead.';
    function insert(index_: guint; value: PGValue): PGValueArray; cdecl; inline; deprecated 'Use #GArray and g_array_insert_val() instead.';
    function prepend(value: PGValue): PGValueArray; cdecl; inline; deprecated 'Use #GArray and g_array_prepend_val() instead.';
    function remove(index_: guint): PGValueArray; cdecl; inline; deprecated 'Use #GArray and g_array_remove_index() instead.';
    function sort(compare_func: TGCompareFunc): PGValueArray; cdecl; inline; deprecated 'Use #GArray and g_array_sort().';
    function sort_with_data(compare_func: TGCompareDataFunc; user_data: gpointer): PGValueArray; cdecl; inline; deprecated 'Use #GArray and g_array_sort_with_data().';
  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_dup_source(binding: PGBinding): PGObject; cdecl; external GObject2_library name 'g_binding_dup_source';
function g_binding_dup_target(binding: PGBinding): PGObject; cdecl; external GObject2_library name 'g_binding_dup_target';
function g_binding_get_flags(binding: PGBinding): TGBindingFlags; cdecl; external GObject2_library name 'g_binding_get_flags';
function g_binding_get_source(binding: PGBinding): PGObject; cdecl; external GObject2_library name 'g_binding_get_source'; deprecated 'Use g_binding_dup_source() for a safer version of this function.';
function g_binding_get_source_property(binding: PGBinding): Pgchar; cdecl; external GObject2_library name 'g_binding_get_source_property';
function g_binding_get_target(binding: PGBinding): PGObject; cdecl; external GObject2_library name 'g_binding_get_target'; deprecated 'Use g_binding_dup_target() for a safer version of this function.';
function g_binding_get_target_property(binding: PGBinding): Pgchar; cdecl; external GObject2_library name 'g_binding_get_target_property';
function g_binding_get_type: TGType; cdecl; external GObject2_library name 'g_binding_get_type';
function g_binding_group_dup_source(self: PGBindingGroup): PGObject; cdecl; external GObject2_library name 'g_binding_group_dup_source';
function g_binding_group_get_type: TGType; cdecl; external GObject2_library name 'g_binding_group_get_type';
function g_binding_group_new: PGBindingGroup; cdecl; external GObject2_library name 'g_binding_group_new';
function g_boxed_copy(boxed_type: TGType; src_boxed: Pgpointer): gpointer; cdecl; external GObject2_library name 'g_boxed_copy';
function g_boxed_type_register_static(name: Pgchar; boxed_copy: TGBoxedCopyFunc; boxed_free: TGBoxedFreeFunc): TGType; cdecl; external GObject2_library name 'g_boxed_type_register_static';
function g_cclosure_new(callback_func: TGCallback; user_data: gpointer; destroy_data: TGClosureNotify): PGClosure; cdecl; external GObject2_library name 'g_cclosure_new';
function g_cclosure_new_object(callback_func: TGCallback; object_: PGObject): PGClosure; cdecl; external GObject2_library name 'g_cclosure_new_object';
function g_cclosure_new_object_swap(callback_func: TGCallback; object_: PGObject): PGClosure; cdecl; external GObject2_library name 'g_cclosure_new_object_swap';
function g_cclosure_new_swap(callback_func: TGCallback; user_data: gpointer; destroy_data: TGClosureNotify): PGClosure; cdecl; external GObject2_library name 'g_cclosure_new_swap';
function g_closure_get_type: TGType; cdecl; external GObject2_library name 'g_closure_get_type';
function g_closure_new_object(sizeof_closure: guint; object_: PGObject): PGClosure; cdecl; external GObject2_library name 'g_closure_new_object';
function g_closure_new_simple(sizeof_closure: guint; data: gpointer): PGClosure; cdecl; external GObject2_library name 'g_closure_new_simple';
function g_closure_ref(closure: PGClosure): PGClosure; cdecl; external GObject2_library name 'g_closure_ref';
function g_enum_get_value(enum_class: PGEnumClass; value: gint): PGEnumValue; cdecl; external GObject2_library name 'g_enum_get_value';
function g_enum_get_value_by_name(enum_class: PGEnumClass; name: Pgchar): PGEnumValue; cdecl; external GObject2_library name 'g_enum_get_value_by_name';
function g_enum_get_value_by_nick(enum_class: PGEnumClass; nick: Pgchar): PGEnumValue; cdecl; external GObject2_library name 'g_enum_get_value_by_nick';
function g_enum_register_static(name: Pgchar; const_static_values: PGEnumValue): TGType; cdecl; external GObject2_library name 'g_enum_register_static';
function g_enum_to_string(g_enum_type: TGType; value: gint): Pgchar; cdecl; external GObject2_library name 'g_enum_to_string';
function g_flags_get_first_value(flags_class: PGFlagsClass; value: guint): PGFlagsValue; cdecl; external GObject2_library name 'g_flags_get_first_value';
function g_flags_get_value_by_name(flags_class: PGFlagsClass; name: Pgchar): PGFlagsValue; cdecl; external GObject2_library name 'g_flags_get_value_by_name';
function g_flags_get_value_by_nick(flags_class: PGFlagsClass; nick: Pgchar): PGFlagsValue; cdecl; external GObject2_library name 'g_flags_get_value_by_nick';
function g_flags_register_static(name: Pgchar; const_static_values: PGFlagsValue): TGType; cdecl; external GObject2_library name 'g_flags_register_static';
function g_flags_to_string(flags_type: TGType; value: guint): Pgchar; cdecl; external GObject2_library name 'g_flags_to_string';
function g_gtype_get_type: TGType; cdecl; external GObject2_library name 'g_gtype_get_type';
function g_initially_unowned_get_type: TGType; cdecl; external GObject2_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 GObject2_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 GObject2_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 GObject2_library name 'g_object_bind_property_with_closures';
function g_object_class_find_property(oclass: PGObjectClass; property_name: Pgchar): PGParamSpec; cdecl; external GObject2_library name 'g_object_class_find_property';
function g_object_class_list_properties(oclass: PGObjectClass; n_properties: Pguint): PPGParamSpec; cdecl; external GObject2_library name 'g_object_class_list_properties';
function g_object_compat_control(what: gsize; data: gpointer): gsize; cdecl; external GObject2_library name 'g_object_compat_control';
function g_object_connect(object_: PGObject; signal_spec: Pgchar; args: array of const): PGObject; cdecl; external GObject2_library name 'g_object_connect';
function g_object_dup_data(object_: PGObject; key: Pgchar; dup_func: TGDuplicateFunc; user_data: gpointer): gpointer; cdecl; external GObject2_library name 'g_object_dup_data';
function g_object_dup_qdata(object_: PGObject; quark: TGQuark; dup_func: TGDuplicateFunc; user_data: gpointer): gpointer; cdecl; external GObject2_library name 'g_object_dup_qdata';
function g_object_get_data(object_: PGObject; key: Pgchar): gpointer; cdecl; external GObject2_library name 'g_object_get_data';
function g_object_get_qdata(object_: PGObject; quark: TGQuark): gpointer; cdecl; external GObject2_library name 'g_object_get_qdata';
function g_object_get_type: TGType; cdecl; external GObject2_library name 'g_object_get_type';
function g_object_interface_find_property(g_iface: PGTypeInterface; property_name: Pgchar): PGParamSpec; cdecl; external GObject2_library name 'g_object_interface_find_property';
function g_object_interface_list_properties(g_iface: PGTypeInterface; n_properties_p: Pguint): PPGParamSpec; cdecl; external GObject2_library name 'g_object_interface_list_properties';
function g_object_is_floating(object_: PGObject): gboolean; cdecl; external GObject2_library name 'g_object_is_floating';
function g_object_new(object_type: TGType; first_property_name: Pgchar; args: array of const): PGObject; cdecl; external GObject2_library name 'g_object_new';
function g_object_new_valist(object_type: TGType; first_property_name: Pgchar; var_args: Tva_list): PGObject; cdecl; external GObject2_library name 'g_object_new_valist';
function g_object_new_with_properties(object_type: TGType; n_properties: guint; names: PPgchar; values: PGValue): PGObject; cdecl; external GObject2_library name 'g_object_new_with_properties';
function g_object_newv(object_type: TGType; n_parameters: guint; parameters: PGParameter): PGObject; cdecl; external GObject2_library name 'g_object_newv'; deprecated 'Use g_object_new_with_properties() instead. deprecated. See #GParameter for more information.';
function g_object_ref(object_: PGObject): PGObject; cdecl; external GObject2_library name 'g_object_ref';
function g_object_ref_sink(object_: PGObject): PGObject; cdecl; external GObject2_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 GObject2_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 GObject2_library name 'g_object_replace_qdata';
function g_object_steal_data(object_: PGObject; key: Pgchar): gpointer; cdecl; external GObject2_library name 'g_object_steal_data';
function g_object_steal_qdata(object_: PGObject; quark: TGQuark): gpointer; cdecl; external GObject2_library name 'g_object_steal_qdata';
function g_object_take_ref(object_: PGObject): PGObject; cdecl; external GObject2_library name 'g_object_take_ref';
function g_param_spec_boolean(name: Pgchar; nick: Pgchar; blurb: Pgchar; default_value: gboolean; flags: TGParamFlags): PGParamSpec; cdecl; external GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_library name 'g_param_spec_float';
function g_param_spec_get_blurb(pspec: PGParamSpec): Pgchar; cdecl; external GObject2_library name 'g_param_spec_get_blurb';
function g_param_spec_get_default_value(pspec: PGParamSpec): PGValue; cdecl; external GObject2_library name 'g_param_spec_get_default_value';
function g_param_spec_get_name(pspec: PGParamSpec): Pgchar; cdecl; external GObject2_library name 'g_param_spec_get_name';
function g_param_spec_get_name_quark(pspec: PGParamSpec): TGQuark; cdecl; external GObject2_library name 'g_param_spec_get_name_quark';
function g_param_spec_get_nick(pspec: PGParamSpec): Pgchar; cdecl; external GObject2_library name 'g_param_spec_get_nick';
function g_param_spec_get_qdata(pspec: PGParamSpec; quark: TGQuark): gpointer; cdecl; external GObject2_library name 'g_param_spec_get_qdata';
function g_param_spec_get_redirect_target(pspec: PGParamSpec): PGParamSpec; cdecl; external GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_library name 'g_param_spec_internal';
function g_param_spec_is_valid_name(name: Pgchar): gboolean; cdecl; external GObject2_library name 'g_param_spec_is_valid_name';
function g_param_spec_long(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: glong; maximum: glong; default_value: glong; flags: TGParamFlags): PGParamSpec; cdecl; external GObject2_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 GObject2_library name 'g_param_spec_object';
function g_param_spec_override(name: Pgchar; overridden: PGParamSpec): PGParamSpec; cdecl; external GObject2_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 GObject2_library name 'g_param_spec_param';
function g_param_spec_pointer(name: Pgchar; nick: Pgchar; blurb: Pgchar; flags: TGParamFlags): PGParamSpec; cdecl; external GObject2_library name 'g_param_spec_pointer';
function g_param_spec_pool_list(pool: PGParamSpecPool; owner_type: TGType; n_pspecs_p: Pguint): PPGParamSpec; cdecl; external GObject2_library name 'g_param_spec_pool_list';
function g_param_spec_pool_list_owned(pool: PGParamSpecPool; owner_type: TGType): PGList; cdecl; external GObject2_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 GObject2_library name 'g_param_spec_pool_lookup';
function g_param_spec_pool_new(type_prefixing: gboolean): PGParamSpecPool; cdecl; external GObject2_library name 'g_param_spec_pool_new';
function g_param_spec_ref(pspec: PGParamSpec): PGParamSpec; cdecl; external GObject2_library name 'g_param_spec_ref';
function g_param_spec_ref_sink(pspec: PGParamSpec): PGParamSpec; cdecl; external GObject2_library name 'g_param_spec_ref_sink';
function g_param_spec_steal_qdata(pspec: PGParamSpec; quark: TGQuark): gpointer; cdecl; external GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_library name 'g_param_spec_variant';
function g_param_type_register_static(name: Pgchar; pspec_info: PGParamSpecTypeInfo): TGType; cdecl; external GObject2_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 GObject2_library name 'g_param_value_convert';
function g_param_value_defaults(pspec: PGParamSpec; value: PGValue): gboolean; cdecl; external GObject2_library name 'g_param_value_defaults';
function g_param_value_is_valid(pspec: PGParamSpec; value: PGValue): gboolean; cdecl; external GObject2_library name 'g_param_value_is_valid';
function g_param_value_validate(pspec: PGParamSpec; value: PGValue): gboolean; cdecl; external GObject2_library name 'g_param_value_validate';
function g_param_values_cmp(pspec: PGParamSpec; value1: PGValue; value2: PGValue): gint; cdecl; external GObject2_library name 'g_param_values_cmp';
function g_pointer_type_register_static(name: Pgchar): TGType; cdecl; external GObject2_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 GObject2_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 GObject2_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 GObject2_library name 'g_signal_add_emission_hook';
function g_signal_connect_closure(instance: PGObject; detailed_signal: Pgchar; closure: PGClosure; after: gboolean): gulong; cdecl; external GObject2_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 GObject2_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 GObject2_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 GObject2_library name 'g_signal_connect_object';
function g_signal_get_invocation_hint(instance: PGObject): PGSignalInvocationHint; cdecl; external GObject2_library name 'g_signal_get_invocation_hint';
function g_signal_group_dup_target(self: PGSignalGroup): PGObject; cdecl; external GObject2_library name 'g_signal_group_dup_target';
function g_signal_group_get_type: TGType; cdecl; external GObject2_library name 'g_signal_group_get_type';
function g_signal_group_new(target_type: TGType): PGSignalGroup; cdecl; external GObject2_library name 'g_signal_group_new';
function g_signal_handler_find(instance: PGObject; mask: TGSignalMatchType; signal_id: guint; detail: TGQuark; closure: PGClosure; func: gpointer; data: gpointer): gulong; cdecl; external GObject2_library name 'g_signal_handler_find';
function g_signal_handler_is_connected(instance: PGObject; handler_id: gulong): gboolean; cdecl; external GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_library name 'g_signal_has_handler_pending';
function g_signal_is_valid_name(name: Pgchar): gboolean; cdecl; external GObject2_library name 'g_signal_is_valid_name';
function g_signal_list_ids(itype: TGType; n_ids: Pguint): Pguint; cdecl; external GObject2_library name 'g_signal_list_ids';
function g_signal_lookup(name: Pgchar; itype: TGType): guint; cdecl; external GObject2_library name 'g_signal_lookup';
function g_signal_name(signal_id: guint): Pgchar; cdecl; external GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_library name 'g_signal_parse_name';
function g_signal_type_cclosure_new(itype: TGType; struct_offset: guint): PGClosure; cdecl; external GObject2_library name 'g_signal_type_cclosure_new';
function g_strdup_value_contents(value: PGValue): Pgchar; cdecl; external GObject2_library name 'g_strdup_value_contents';
function g_type_add_instance_private(class_type: TGType; private_size: gsize): gint; cdecl; external GObject2_library name 'g_type_add_instance_private';
function g_type_check_class_cast(g_class: PGTypeClass; is_a_type: TGType): PGTypeClass; cdecl; external GObject2_library name 'g_type_check_class_cast';
function g_type_check_class_is_a(g_class: PGTypeClass; is_a_type: TGType): gboolean; cdecl; external GObject2_library name 'g_type_check_class_is_a';
function g_type_check_instance(instance: PGTypeInstance): gboolean; cdecl; external GObject2_library name 'g_type_check_instance';
function g_type_check_instance_cast(instance: PGTypeInstance; iface_type: TGType): PGTypeInstance; cdecl; external GObject2_library name 'g_type_check_instance_cast';
function g_type_check_instance_is_a(instance: PGTypeInstance; iface_type: TGType): gboolean; cdecl; external GObject2_library name 'g_type_check_instance_is_a';
function g_type_check_instance_is_fundamentally_a(instance: PGTypeInstance; fundamental_type: TGType): gboolean; cdecl; external GObject2_library name 'g_type_check_instance_is_fundamentally_a';
function g_type_check_is_value_type(type_: TGType): gboolean; cdecl; external GObject2_library name 'g_type_check_is_value_type';
function g_type_check_value(value: PGValue): gboolean; cdecl; external GObject2_library name 'g_type_check_value';
function g_type_check_value_holds(value: PGValue; type_: TGType): gboolean; cdecl; external GObject2_library name 'g_type_check_value_holds';
function g_type_children(type_: TGType; n_children: Pguint): PGType; cdecl; external GObject2_library name 'g_type_children';
function g_type_class_get(type_: TGType): PGTypeClass; cdecl; external GObject2_library name 'g_type_class_get';
function g_type_class_get_instance_private_offset(g_class: PGTypeClass): gint; cdecl; external GObject2_library name 'g_type_class_get_instance_private_offset';
function g_type_class_get_private(klass: PGTypeClass; private_type: TGType): gpointer; cdecl; external GObject2_library name 'g_type_class_get_private';
function g_type_class_peek(type_: TGType): PGTypeClass; cdecl; external GObject2_library name 'g_type_class_peek';
function g_type_class_peek_parent(g_class: PGTypeClass): PGTypeClass; cdecl; external GObject2_library name 'g_type_class_peek_parent';
function g_type_class_peek_static(type_: TGType): PGTypeClass; cdecl; external GObject2_library name 'g_type_class_peek_static';
function g_type_class_ref(type_: TGType): PGTypeClass; cdecl; external GObject2_library name 'g_type_class_ref'; deprecated 'Use g_type_class_get() instead';
function g_type_create_instance(type_: TGType): PGTypeInstance; cdecl; external GObject2_library name 'g_type_create_instance';
function g_type_default_interface_get(g_type: TGType): PGTypeInterface; cdecl; external GObject2_library name 'g_type_default_interface_get';
function g_type_default_interface_peek(g_type: TGType): PGTypeInterface; cdecl; external GObject2_library name 'g_type_default_interface_peek';
function g_type_default_interface_ref(g_type: TGType): PGTypeInterface; cdecl; external GObject2_library name 'g_type_default_interface_ref'; deprecated 'Use g_type_default_interface_get() instead';
function g_type_depth(type_: TGType): guint; cdecl; external GObject2_library name 'g_type_depth';
function g_type_from_name(name: Pgchar): TGType; cdecl; external GObject2_library name 'g_type_from_name';
function g_type_fundamental(type_id: TGType): TGType; cdecl; external GObject2_library name 'g_type_fundamental';
function g_type_fundamental_next: TGType; cdecl; external GObject2_library name 'g_type_fundamental_next';
function g_type_get_instance_count(type_: TGType): gint; cdecl; external GObject2_library name 'g_type_get_instance_count';
function g_type_get_plugin(type_: TGType): PGTypePlugin; cdecl; external GObject2_library name 'g_type_get_plugin';
function g_type_get_qdata(type_: TGType; quark: TGQuark): gpointer; cdecl; external GObject2_library name 'g_type_get_qdata';
function g_type_get_type_registration_serial: guint; cdecl; external GObject2_library name 'g_type_get_type_registration_serial';
function g_type_instance_get_private(instance: PGTypeInstance; private_type: TGType): gpointer; cdecl; external GObject2_library name 'g_type_instance_get_private';
function g_type_interface_get_plugin(instance_type: TGType; interface_type: TGType): PGTypePlugin; cdecl; external GObject2_library name 'g_type_interface_get_plugin';
function g_type_interface_instantiatable_prerequisite(interface_type: TGType): TGType; cdecl; external GObject2_library name 'g_type_interface_instantiatable_prerequisite';
function g_type_interface_peek(instance_class: PGTypeClass; iface_type: TGType): PGTypeInterface; cdecl; external GObject2_library name 'g_type_interface_peek';
function g_type_interface_peek_parent(g_iface: PGTypeInterface): PGTypeInterface; cdecl; external GObject2_library name 'g_type_interface_peek_parent';
function g_type_interface_prerequisites(interface_type: TGType; n_prerequisites: Pguint): PGType; cdecl; external GObject2_library name 'g_type_interface_prerequisites';
function g_type_interfaces(type_: TGType; n_interfaces: Pguint): PGType; cdecl; external GObject2_library name 'g_type_interfaces';
function g_type_is_a(type_: TGType; is_a_type: TGType): gboolean; cdecl; external GObject2_library name 'g_type_is_a';
function g_type_module_get_type: TGType; cdecl; external GObject2_library name 'g_type_module_get_type';
function g_type_module_register_enum(module: PGTypeModule; name: Pgchar; const_static_values: PGEnumValue): TGType; cdecl; external GObject2_library name 'g_type_module_register_enum';
function g_type_module_register_flags(module: PGTypeModule; name: Pgchar; const_static_values: PGFlagsValue): TGType; cdecl; external GObject2_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 GObject2_library name 'g_type_module_register_type';
function g_type_module_use(module: PGTypeModule): gboolean; cdecl; external GObject2_library name 'g_type_module_use';
function g_type_name(type_: TGType): Pgchar; cdecl; external GObject2_library name 'g_type_name';
function g_type_name_from_class(g_class: PGTypeClass): Pgchar; cdecl; external GObject2_library name 'g_type_name_from_class';
function g_type_name_from_instance(instance: PGTypeInstance): Pgchar; cdecl; external GObject2_library name 'g_type_name_from_instance';
function g_type_next_base(leaf_type: TGType; root_type: TGType): TGType; cdecl; external GObject2_library name 'g_type_next_base';
function g_type_parent(type_: TGType): TGType; cdecl; external GObject2_library name 'g_type_parent';
function g_type_plugin_get_type: TGType; cdecl; external GObject2_library name 'g_type_plugin_get_type';
function g_type_qname(type_: TGType): TGQuark; cdecl; external GObject2_library name 'g_type_qname';
function g_type_register_dynamic(parent_type: TGType; type_name: Pgchar; plugin: PGTypePlugin; flags: TGTypeFlags): TGType; cdecl; external GObject2_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 GObject2_library name 'g_type_register_fundamental';
function g_type_register_static(parent_type: TGType; type_name: Pgchar; info: PGTypeInfo; flags: TGTypeFlags): TGType; cdecl; external GObject2_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 GObject2_library name 'g_type_register_static_simple';
function g_type_test_flags(type_: TGType; flags: guint): gboolean; cdecl; external GObject2_library name 'g_type_test_flags';
function g_type_value_table_peek(type_: TGType): PGTypeValueTable; cdecl; external GObject2_library name 'g_type_value_table_peek';
function g_value_array_append(value_array: PGValueArray; value: PGValue): PGValueArray; cdecl; external GObject2_library name 'g_value_array_append'; deprecated 'Use #GArray and g_array_append_val() instead.';
function g_value_array_copy(value_array: PGValueArray): PGValueArray; cdecl; external GObject2_library name 'g_value_array_copy'; deprecated 'Use #GArray and g_array_ref() instead.';
function g_value_array_get_nth(value_array: PGValueArray; index_: guint): PGValue; cdecl; external GObject2_library name 'g_value_array_get_nth'; deprecated 'Use g_array_index() instead.';
function g_value_array_get_type: TGType; cdecl; external GObject2_library name 'g_value_array_get_type';
function g_value_array_insert(value_array: PGValueArray; index_: guint; value: PGValue): PGValueArray; cdecl; external GObject2_library name 'g_value_array_insert'; deprecated 'Use #GArray and g_array_insert_val() instead.';
function g_value_array_new(n_prealloced: guint): PGValueArray; cdecl; external GObject2_library name 'g_value_array_new'; deprecated 'Use #GArray and g_array_sized_new() instead.';
function g_value_array_prepend(value_array: PGValueArray; value: PGValue): PGValueArray; cdecl; external GObject2_library name 'g_value_array_prepend'; deprecated 'Use #GArray and g_array_prepend_val() instead.';
function g_value_array_remove(value_array: PGValueArray; index_: guint): PGValueArray; cdecl; external GObject2_library name 'g_value_array_remove'; deprecated 'Use #GArray and g_array_remove_index() instead.';
function g_value_array_sort(value_array: PGValueArray; compare_func: TGCompareFunc): PGValueArray; cdecl; external GObject2_library name 'g_value_array_sort'; deprecated 'Use #GArray and g_array_sort().';
function g_value_array_sort_with_data(value_array: PGValueArray; compare_func: TGCompareDataFunc; user_data: gpointer): PGValueArray; cdecl; external GObject2_library name 'g_value_array_sort_with_data'; deprecated 'Use #GArray and g_array_sort_with_data().';
function g_value_dup_boxed(value: PGValue): gpointer; cdecl; external GObject2_library name 'g_value_dup_boxed';
function g_value_dup_object(value: PGValue): PGObject; cdecl; external GObject2_library name 'g_value_dup_object';
function g_value_dup_param(value: PGValue): PGParamSpec; cdecl; external GObject2_library name 'g_value_dup_param';
function g_value_dup_string(value: PGValue): Pgchar; cdecl; external GObject2_library name 'g_value_dup_string';
function g_value_dup_variant(value: PGValue): PGVariant; cdecl; external GObject2_library name 'g_value_dup_variant';
function g_value_fits_pointer(value: PGValue): gboolean; cdecl; external GObject2_library name 'g_value_fits_pointer';
function g_value_get_boolean(value: PGValue): gboolean; cdecl; external GObject2_library name 'g_value_get_boolean';
function g_value_get_boxed(value: PGValue): gpointer; cdecl; external GObject2_library name 'g_value_get_boxed';
function g_value_get_char(value: PGValue): gchar; cdecl; external GObject2_library name 'g_value_get_char'; deprecated 'This function''s return type is broken, see g_value_get_schar()';
function g_value_get_double(value: PGValue): gdouble; cdecl; external GObject2_library name 'g_value_get_double';
function g_value_get_enum(value: PGValue): gint; cdecl; external GObject2_library name 'g_value_get_enum';
function g_value_get_flags(value: PGValue): guint; cdecl; external GObject2_library name 'g_value_get_flags';
function g_value_get_float(value: PGValue): gfloat; cdecl; external GObject2_library name 'g_value_get_float';
function g_value_get_gtype(value: PGValue): TGType; cdecl; external GObject2_library name 'g_value_get_gtype';
function g_value_get_int(value: PGValue): gint; cdecl; external GObject2_library name 'g_value_get_int';
function g_value_get_int64(value: PGValue): gint64; cdecl; external GObject2_library name 'g_value_get_int64';
function g_value_get_long(value: PGValue): glong; cdecl; external GObject2_library name 'g_value_get_long';
function g_value_get_object(value: PGValue): PGObject; cdecl; external GObject2_library name 'g_value_get_object';
function g_value_get_param(value: PGValue): PGParamSpec; cdecl; external GObject2_library name 'g_value_get_param';
function g_value_get_pointer(value: PGValue): gpointer; cdecl; external GObject2_library name 'g_value_get_pointer';
function g_value_get_schar(value: PGValue): gint8; cdecl; external GObject2_library name 'g_value_get_schar';
function g_value_get_string(value: PGValue): Pgchar; cdecl; external GObject2_library name 'g_value_get_string';
function g_value_get_type: TGType; cdecl; external GObject2_library name 'g_value_get_type';
function g_value_get_uchar(value: PGValue): guint8; cdecl; external GObject2_library name 'g_value_get_uchar';
function g_value_get_uint(value: PGValue): guint; cdecl; external GObject2_library name 'g_value_get_uint';
function g_value_get_uint64(value: PGValue): guint64; cdecl; external GObject2_library name 'g_value_get_uint64';
function g_value_get_ulong(value: PGValue): gulong; cdecl; external GObject2_library name 'g_value_get_ulong';
function g_value_get_variant(value: PGValue): PGVariant; cdecl; external GObject2_library name 'g_value_get_variant';
function g_value_init(value: PGValue; g_type: TGType): PGValue; cdecl; external GObject2_library name 'g_value_init';
function g_value_peek_pointer(value: PGValue): gpointer; cdecl; external GObject2_library name 'g_value_peek_pointer';
function g_value_reset(value: PGValue): PGValue; cdecl; external GObject2_library name 'g_value_reset';
function g_value_steal_string(value: PGValue): Pgchar; cdecl; external GObject2_library name 'g_value_steal_string';
function g_value_transform(src_value: PGValue; dest_value: PGValue): gboolean; cdecl; external GObject2_library name 'g_value_transform';
function g_value_type_compatible(src_type: TGType; dest_type: TGType): gboolean; cdecl; external GObject2_library name 'g_value_type_compatible';
function g_value_type_transformable(src_type: TGType; dest_type: TGType): gboolean; cdecl; external GObject2_library name 'g_value_type_transformable';
function g_variant_get_gtype: TGType; cdecl; external GObject2_library name 'g_variant_get_gtype';
function g_weak_ref_get(weak_ref: PGWeakRef): PGObject; cdecl; external GObject2_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 GObject2_library name 'g_binding_group_bind';
procedure g_binding_group_bind_full(self: PGBindingGroup; source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags; transform_to: TGBindingTransformFunc; transform_from: TGBindingTransformFunc; user_data: gpointer; user_data_destroy: TGDestroyNotify); cdecl; external GObject2_library name 'g_binding_group_bind_full';
procedure g_binding_group_bind_with_closures(self: PGBindingGroup; source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags; transform_to: PGClosure; transform_from: PGClosure); cdecl; external GObject2_library name 'g_binding_group_bind_with_closures';
procedure g_binding_group_set_source(self: PGBindingGroup; source: PGObject); cdecl; external GObject2_library name 'g_binding_group_set_source';
procedure g_binding_unbind(binding: PGBinding); cdecl; external GObject2_library name 'g_binding_unbind';
procedure g_boxed_free(boxed_type: TGType; boxed: gpointer); cdecl; external GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_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 GObject2_library name 'g_cclosure_marshal_VOID__VOIDv';
procedure g_clear_object(object_ptr: PPGObject); cdecl; external GObject2_library name 'g_clear_object';
procedure g_clear_signal_handler(handler_id_ptr: Pgulong; instance: PGObject); cdecl; external GObject2_library name 'g_clear_signal_handler';
procedure g_closure_add_finalize_notifier(closure: PGClosure; notify_data: gpointer; notify_func: TGClosureNotify); cdecl; external GObject2_library name 'g_closure_add_finalize_notifier';
procedure g_closure_add_invalidate_notifier(closure: PGClosure; notify_data: gpointer; notify_func: TGClosureNotify); cdecl; external GObject2_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 GObject2_library name 'g_closure_add_marshal_guards';
procedure g_closure_invalidate(closure: PGClosure); cdecl; external GObject2_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 GObject2_library name 'g_closure_invoke';
procedure g_closure_remove_finalize_notifier(closure: PGClosure; notify_data: gpointer; notify_func: TGClosureNotify); cdecl; external GObject2_library name 'g_closure_remove_finalize_notifier';
procedure g_closure_remove_invalidate_notifier(closure: PGClosure; notify_data: gpointer; notify_func: TGClosureNotify); cdecl; external GObject2_library name 'g_closure_remove_invalidate_notifier';
procedure g_closure_set_marshal(closure: PGClosure; marshal: TGClosureMarshal); cdecl; external GObject2_library name 'g_closure_set_marshal';
procedure g_closure_set_meta_marshal(closure: PGClosure; marshal_data: gpointer; meta_marshal: TGClosureMarshal); cdecl; external GObject2_library name 'g_closure_set_meta_marshal';
procedure g_closure_sink(closure: PGClosure); cdecl; external GObject2_library name 'g_closure_sink';
procedure g_closure_unref(closure: PGClosure); cdecl; external GObject2_library name 'g_closure_unref';
procedure g_enum_complete_type_info(g_enum_type: TGType; info: PGTypeInfo; const_values: PGEnumValue); cdecl; external GObject2_library name 'g_enum_complete_type_info';
procedure g_flags_complete_type_info(g_flags_type: TGType; info: PGTypeInfo; const_values: PGFlagsValue); cdecl; external GObject2_library name 'g_flags_complete_type_info';
procedure g_object_add_toggle_ref(object_: PGObject; notify: TGToggleNotify; data: gpointer); cdecl; external GObject2_library name 'g_object_add_toggle_ref';
procedure g_object_add_weak_pointer(object_: PGObject; weak_pointer_location: Pgpointer); cdecl; external GObject2_library name 'g_object_add_weak_pointer';
procedure g_object_class_install_properties(oclass: PGObjectClass; n_pspecs: guint; pspecs: PPGParamSpec); cdecl; external GObject2_library name 'g_object_class_install_properties';
procedure g_object_class_install_property(oclass: PGObjectClass; property_id: guint; pspec: PGParamSpec); cdecl; external GObject2_library name 'g_object_class_install_property';
procedure g_object_class_override_property(oclass: PGObjectClass; property_id: guint; name: Pgchar); cdecl; external GObject2_library name 'g_object_class_override_property';
procedure g_object_disconnect(object_: PGObject; signal_spec: Pgchar; args: array of const); cdecl; external GObject2_library name 'g_object_disconnect';
procedure g_object_force_floating(object_: PGObject); cdecl; external GObject2_library name 'g_object_force_floating';
procedure g_object_freeze_notify(object_: PGObject); cdecl; external GObject2_library name 'g_object_freeze_notify';
procedure g_object_get(object_: PGObject; first_property_name: Pgchar; args: array of const); cdecl; external GObject2_library name 'g_object_get';
procedure g_object_get_property(object_: PGObject; property_name: Pgchar; value: PGValue); cdecl; external GObject2_library name 'g_object_get_property';
procedure g_object_get_valist(object_: PGObject; first_property_name: Pgchar; var_args: Tva_list); cdecl; external GObject2_library name 'g_object_get_valist';
procedure g_object_getv(object_: PGObject; n_properties: guint; names: PPgchar; values: PGValue); cdecl; external GObject2_library name 'g_object_getv';
procedure g_object_interface_install_property(g_iface: PGTypeInterface; pspec: PGParamSpec); cdecl; external GObject2_library name 'g_object_interface_install_property';
procedure g_object_notify(object_: PGObject; property_name: Pgchar); cdecl; external GObject2_library name 'g_object_notify';
procedure g_object_notify_by_pspec(object_: PGObject; pspec: PGParamSpec); cdecl; external GObject2_library name 'g_object_notify_by_pspec';
procedure g_object_remove_toggle_ref(object_: PGObject; notify: TGToggleNotify; data: gpointer); cdecl; external GObject2_library name 'g_object_remove_toggle_ref';
procedure g_object_remove_weak_pointer(object_: PGObject; weak_pointer_location: Pgpointer); cdecl; external GObject2_library name 'g_object_remove_weak_pointer';
procedure g_object_run_dispose(object_: PGObject); cdecl; external GObject2_library name 'g_object_run_dispose';
procedure g_object_set(object_: PGObject; first_property_name: Pgchar; args: array of const); cdecl; external GObject2_library name 'g_object_set';
procedure g_object_set_data(object_: PGObject; key: Pgchar; data: gpointer); cdecl; external GObject2_library name 'g_object_set_data';
procedure g_object_set_data_full(object_: PGObject; key: Pgchar; data: gpointer; destroy_: TGDestroyNotify); cdecl; external GObject2_library name 'g_object_set_data_full';
procedure g_object_set_property(object_: PGObject; property_name: Pgchar; value: PGValue); cdecl; external GObject2_library name 'g_object_set_property';
procedure g_object_set_qdata(object_: PGObject; quark: TGQuark; data: gpointer); cdecl; external GObject2_library name 'g_object_set_qdata';
procedure g_object_set_qdata_full(object_: PGObject; quark: TGQuark; data: gpointer; destroy_: TGDestroyNotify); cdecl; external GObject2_library name 'g_object_set_qdata_full';
procedure g_object_set_valist(object_: PGObject; first_property_name: Pgchar; var_args: Tva_list); cdecl; external GObject2_library name 'g_object_set_valist';
procedure g_object_setv(object_: PGObject; n_properties: guint; names: PPgchar; values: PGValue); cdecl; external GObject2_library name 'g_object_setv';
procedure g_object_thaw_notify(object_: PGObject); cdecl; external GObject2_library name 'g_object_thaw_notify';
procedure g_object_unref(object_: PGObject); cdecl; external GObject2_library name 'g_object_unref';
procedure g_object_watch_closure(object_: PGObject; closure: PGClosure); cdecl; external GObject2_library name 'g_object_watch_closure';
procedure g_object_weak_ref(object_: PGObject; notify: TGWeakNotify; data: gpointer); cdecl; external GObject2_library name 'g_object_weak_ref';
procedure g_object_weak_unref(object_: PGObject; notify: TGWeakNotify; data: gpointer); cdecl; external GObject2_library name 'g_object_weak_unref';
procedure g_param_spec_pool_free(pool: PGParamSpecPool); cdecl; external GObject2_library name 'g_param_spec_pool_free';
procedure g_param_spec_pool_insert(pool: PGParamSpecPool; pspec: PGParamSpec; owner_type: TGType); cdecl; external GObject2_library name 'g_param_spec_pool_insert';
procedure g_param_spec_pool_remove(pool: PGParamSpecPool; pspec: PGParamSpec); cdecl; external GObject2_library name 'g_param_spec_pool_remove';
procedure g_param_spec_set_qdata(pspec: PGParamSpec; quark: TGQuark; data: gpointer); cdecl; external GObject2_library name 'g_param_spec_set_qdata';
procedure g_param_spec_set_qdata_full(pspec: PGParamSpec; quark: TGQuark; data: gpointer; destroy_: TGDestroyNotify); cdecl; external GObject2_library name 'g_param_spec_set_qdata_full';
procedure g_param_spec_sink(pspec: PGParamSpec); cdecl; external GObject2_library name 'g_param_spec_sink';
procedure g_param_spec_unref(pspec: PGParamSpec); cdecl; external GObject2_library name 'g_param_spec_unref';
procedure g_param_value_set_default(pspec: PGParamSpec; value: PGValue); cdecl; external GObject2_library name 'g_param_value_set_default';
procedure g_signal_chain_from_overridden(instance_and_params: PGValue; return_value: PGValue); cdecl; external GObject2_library name 'g_signal_chain_from_overridden';
procedure g_signal_chain_from_overridden_handler(instance: PGTypeInstance; args: array of const); cdecl; external GObject2_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 GObject2_library name 'g_signal_emit';
procedure g_signal_emit_by_name(instance: PGObject; detailed_signal: Pgchar; args: array of const); cdecl; external GObject2_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 GObject2_library name 'g_signal_emit_valist';
procedure g_signal_emitv(instance_and_params: PGValue; signal_id: guint; detail: TGQuark; return_value: PGValue); cdecl; external GObject2_library name 'g_signal_emitv';
procedure g_signal_group_block(self: PGSignalGroup); cdecl; external GObject2_library name 'g_signal_group_block';
procedure g_signal_group_connect(self: PGSignalGroup; detailed_signal: Pgchar; c_handler: TGCallback; data: gpointer); cdecl; external GObject2_library name 'g_signal_group_connect';
procedure g_signal_group_connect_after(self: PGSignalGroup; detailed_signal: Pgchar; c_handler: TGCallback; data: gpointer); cdecl; external GObject2_library name 'g_signal_group_connect_after';
procedure g_signal_group_connect_closure(self: PGSignalGroup; detailed_signal: Pgchar; closure: PGClosure; after: gboolean); cdecl; external GObject2_library name 'g_signal_group_connect_closure';
procedure g_signal_group_connect_data(self: PGSignalGroup; detailed_signal: Pgchar; c_handler: TGCallback; data: gpointer; notify: TGClosureNotify; flags: TGConnectFlags); cdecl; external GObject2_library name 'g_signal_group_connect_data';
procedure g_signal_group_connect_object(self: PGSignalGroup; detailed_signal: Pgchar; c_handler: TGCallback; object_: gpointer; flags: TGConnectFlags); cdecl; external GObject2_library name 'g_signal_group_connect_object';
procedure g_signal_group_connect_swapped(self: PGSignalGroup; detailed_signal: Pgchar; c_handler: TGCallback; data: gpointer); cdecl; external GObject2_library name 'g_signal_group_connect_swapped';
procedure g_signal_group_set_target(self: PGSignalGroup; target: PGObject); cdecl; external GObject2_library name 'g_signal_group_set_target';
procedure g_signal_group_unblock(self: PGSignalGroup); cdecl; external GObject2_library name 'g_signal_group_unblock';
procedure g_signal_handler_block(instance: PGObject; handler_id: gulong); cdecl; external GObject2_library name 'g_signal_handler_block';
procedure g_signal_handler_disconnect(instance: PGObject; handler_id: gulong); cdecl; external GObject2_library name 'g_signal_handler_disconnect';
procedure g_signal_handler_unblock(instance: PGObject; handler_id: gulong); cdecl; external GObject2_library name 'g_signal_handler_unblock';
procedure g_signal_handlers_destroy(instance: PGObject); cdecl; external GObject2_library name 'g_signal_handlers_destroy';
procedure g_signal_override_class_closure(signal_id: guint; instance_type: TGType; class_closure: PGClosure); cdecl; external GObject2_library name 'g_signal_override_class_closure';
procedure g_signal_override_class_handler(signal_name: Pgchar; instance_type: TGType; class_handler: TGCallback); cdecl; external GObject2_library name 'g_signal_override_class_handler';
procedure g_signal_query(signal_id: guint; query: PGSignalQuery); cdecl; external GObject2_library name 'g_signal_query';
procedure g_signal_remove_emission_hook(signal_id: guint; hook_id: gulong); cdecl; external GObject2_library name 'g_signal_remove_emission_hook';
procedure g_signal_set_va_marshaller(signal_id: guint; instance_type: TGType; va_marshaller: TGSignalCVaMarshaller); cdecl; external GObject2_library name 'g_signal_set_va_marshaller';
procedure g_signal_stop_emission(instance: PGObject; signal_id: guint; detail: TGQuark); cdecl; external GObject2_library name 'g_signal_stop_emission';
procedure g_signal_stop_emission_by_name(instance: PGObject; detailed_signal: Pgchar); cdecl; external GObject2_library name 'g_signal_stop_emission_by_name';
procedure g_source_set_closure(source: PGSource; closure: PGClosure); cdecl; external GObject2_library name 'g_source_set_closure';
procedure g_source_set_dummy_callback(source: PGSource); cdecl; external GObject2_library name 'g_source_set_dummy_callback';
procedure g_type_add_class_cache_func(cache_data: gpointer; cache_func: TGTypeClassCacheFunc); cdecl; external GObject2_library name 'g_type_add_class_cache_func';
procedure g_type_add_class_private(class_type: TGType; private_size: gsize); cdecl; external GObject2_library name 'g_type_add_class_private';
procedure g_type_add_interface_check(check_data: gpointer; check_func: TGTypeInterfaceCheckFunc); cdecl; external GObject2_library name 'g_type_add_interface_check';
procedure g_type_add_interface_dynamic(instance_type: TGType; interface_type: TGType; plugin: PGTypePlugin); cdecl; external GObject2_library name 'g_type_add_interface_dynamic';
procedure g_type_add_interface_static(instance_type: TGType; interface_type: TGType; info: PGInterfaceInfo); cdecl; external GObject2_library name 'g_type_add_interface_static';
procedure g_type_class_add_private(g_class: PGTypeClass; private_size: gsize); cdecl; external GObject2_library name 'g_type_class_add_private'; deprecated 'Use the G_ADD_PRIVATE() macro with the `G_DEFINE_*`   family of macros to add instance private data to a type';
procedure g_type_class_adjust_private_offset(g_class: gpointer; private_size_or_offset: Pgint); cdecl; external GObject2_library name 'g_type_class_adjust_private_offset';
procedure g_type_class_unref(g_class: PGTypeClass); cdecl; external GObject2_library name 'g_type_class_unref'; deprecated 'Type class reference counting has been removed and type    classes now cannot be finalized. This function no longer does anything.';
procedure g_type_class_unref_uncached(g_class: PGTypeClass); cdecl; external GObject2_library name 'g_type_class_unref_uncached'; deprecated 'Type class reference counting has been removed and type    classes now cannot be finalized. This function no longer does anything.';
procedure g_type_default_interface_unref(g_iface: PGTypeInterface); cdecl; external GObject2_library name 'g_type_default_interface_unref'; deprecated 'Interface reference counting has been removed and   interface types now cannot be finalized. This function no longer does   anything.';
procedure g_type_ensure(type_: TGType); cdecl; external GObject2_library name 'g_type_ensure';
procedure g_type_free_instance(instance: PGTypeInstance); cdecl; external GObject2_library name 'g_type_free_instance';
procedure g_type_init; cdecl; external GObject2_library name 'g_type_init'; deprecated 'the type system is now initialised automatically';
procedure g_type_init_with_debug_flags(debug_flags: TGTypeDebugFlags); cdecl; external GObject2_library name 'g_type_init_with_debug_flags'; deprecated 'the type system is now initialised automatically';
procedure g_type_interface_add_prerequisite(interface_type: TGType; prerequisite_type: TGType); cdecl; external GObject2_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 GObject2_library name 'g_type_module_add_interface';
procedure g_type_module_set_name(module: PGTypeModule; name: Pgchar); cdecl; external GObject2_library name 'g_type_module_set_name';
procedure g_type_module_unuse(module: PGTypeModule); cdecl; external GObject2_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 GObject2_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 GObject2_library name 'g_type_plugin_complete_type_info';
procedure g_type_plugin_unuse(plugin: PGTypePlugin); cdecl; external GObject2_library name 'g_type_plugin_unuse';
procedure g_type_plugin_use(plugin: PGTypePlugin); cdecl; external GObject2_library name 'g_type_plugin_use';
procedure g_type_query(type_: TGType; query: PGTypeQuery); cdecl; external GObject2_library name 'g_type_query';
procedure g_type_remove_class_cache_func(cache_data: gpointer; cache_func: TGTypeClassCacheFunc); cdecl; external GObject2_library name 'g_type_remove_class_cache_func';
procedure g_type_remove_interface_check(check_data: gpointer; check_func: TGTypeInterfaceCheckFunc); cdecl; external GObject2_library name 'g_type_remove_interface_check';
procedure g_type_set_qdata(type_: TGType; quark: TGQuark; data: gpointer); cdecl; external GObject2_library name 'g_type_set_qdata';
procedure g_value_array_free(value_array: PGValueArray); cdecl; external GObject2_library name 'g_value_array_free'; deprecated 'Use #GArray and g_array_unref() instead.';
procedure g_value_copy(src_value: PGValue; dest_value: PGValue); cdecl; external GObject2_library name 'g_value_copy';
procedure g_value_init_from_instance(value: PGValue; instance: PGTypeInstance); cdecl; external GObject2_library name 'g_value_init_from_instance';
procedure g_value_register_transform_func(src_type: TGType; dest_type: TGType; transform_func: TGValueTransform); cdecl; external GObject2_library name 'g_value_register_transform_func';
procedure g_value_set_boolean(value: PGValue; v_boolean: gboolean); cdecl; external GObject2_library name 'g_value_set_boolean';
procedure g_value_set_boxed(value: PGValue; v_boxed: Pgpointer); cdecl; external GObject2_library name 'g_value_set_boxed';
procedure g_value_set_boxed_take_ownership(value: PGValue; v_boxed: Pgpointer); cdecl; external GObject2_library name 'g_value_set_boxed_take_ownership'; deprecated 'Use g_value_take_boxed() instead.';
procedure g_value_set_char(value: PGValue; v_char: gchar); cdecl; external GObject2_library name 'g_value_set_char'; deprecated 'This function''s input type is broken, see g_value_set_schar()';
procedure g_value_set_double(value: PGValue; v_double: gdouble); cdecl; external GObject2_library name 'g_value_set_double';
procedure g_value_set_enum(value: PGValue; v_enum: gint); cdecl; external GObject2_library name 'g_value_set_enum';
procedure g_value_set_flags(value: PGValue; v_flags: guint); cdecl; external GObject2_library name 'g_value_set_flags';
procedure g_value_set_float(value: PGValue; v_float: gfloat); cdecl; external GObject2_library name 'g_value_set_float';
procedure g_value_set_gtype(value: PGValue; v_gtype: TGType); cdecl; external GObject2_library name 'g_value_set_gtype';
procedure g_value_set_instance(value: PGValue; instance: gpointer); cdecl; external GObject2_library name 'g_value_set_instance';
procedure g_value_set_int(value: PGValue; v_int: gint); cdecl; external GObject2_library name 'g_value_set_int';
procedure g_value_set_int64(value: PGValue; v_int64: gint64); cdecl; external GObject2_library name 'g_value_set_int64';
procedure g_value_set_interned_string(value: PGValue; v_string: Pgchar); cdecl; external GObject2_library name 'g_value_set_interned_string';
procedure g_value_set_long(value: PGValue; v_long: glong); cdecl; external GObject2_library name 'g_value_set_long';
procedure g_value_set_object(value: PGValue; v_object: PGObject); cdecl; external GObject2_library name 'g_value_set_object';
procedure g_value_set_object_take_ownership(value: PGValue; v_object: gpointer); cdecl; external GObject2_library name 'g_value_set_object_take_ownership'; deprecated 'Use g_value_take_object() instead.';
procedure g_value_set_param(value: PGValue; param: PGParamSpec); cdecl; external GObject2_library name 'g_value_set_param';
procedure g_value_set_param_take_ownership(value: PGValue; param: PGParamSpec); cdecl; external GObject2_library name 'g_value_set_param_take_ownership'; deprecated 'Use g_value_take_param() instead.';
procedure g_value_set_pointer(value: PGValue; v_pointer: gpointer); cdecl; external GObject2_library name 'g_value_set_pointer';
procedure g_value_set_schar(value: PGValue; v_char: gint8); cdecl; external GObject2_library name 'g_value_set_schar';
procedure g_value_set_static_boxed(value: PGValue; v_boxed: Pgpointer); cdecl; external GObject2_library name 'g_value_set_static_boxed';
procedure g_value_set_static_string(value: PGValue; v_string: Pgchar); cdecl; external GObject2_library name 'g_value_set_static_string';
procedure g_value_set_string(value: PGValue; v_string: Pgchar); cdecl; external GObject2_library name 'g_value_set_string';
procedure g_value_set_string_take_ownership(value: PGValue; v_string: Pgchar); cdecl; external GObject2_library name 'g_value_set_string_take_ownership'; deprecated 'Use g_value_take_string() instead.';
procedure g_value_set_uchar(value: PGValue; v_uchar: guint8); cdecl; external GObject2_library name 'g_value_set_uchar';
procedure g_value_set_uint(value: PGValue; v_uint: guint); cdecl; external GObject2_library name 'g_value_set_uint';
procedure g_value_set_uint64(value: PGValue; v_uint64: guint64); cdecl; external GObject2_library name 'g_value_set_uint64';
procedure g_value_set_ulong(value: PGValue; v_ulong: gulong); cdecl; external GObject2_library name 'g_value_set_ulong';
procedure g_value_set_variant(value: PGValue; variant: PGVariant); cdecl; external GObject2_library name 'g_value_set_variant';
procedure g_value_take_boxed(value: PGValue; v_boxed: Pgpointer); cdecl; external GObject2_library name 'g_value_take_boxed';
procedure g_value_take_object(value: PGValue; v_object: gpointer); cdecl; external GObject2_library name 'g_value_take_object';
procedure g_value_take_param(value: PGValue; param: PGParamSpec); cdecl; external GObject2_library name 'g_value_take_param';
procedure g_value_take_string(value: PGValue; v_string: Pgchar); cdecl; external GObject2_library name 'g_value_take_string';
procedure g_value_take_variant(value: PGValue; variant: PGVariant); cdecl; external GObject2_library name 'g_value_take_variant';
procedure g_value_unset(value: PGValue); cdecl; external GObject2_library name 'g_value_unset';
procedure g_weak_ref_clear(weak_ref: PGWeakRef); cdecl; external GObject2_library name 'g_weak_ref_clear';
procedure g_weak_ref_init(weak_ref: PGWeakRef; object_: PGObject); cdecl; external GObject2_library name 'g_weak_ref_init';
procedure g_weak_ref_set(weak_ref: PGWeakRef; object_: PGObject); cdecl; external GObject2_library name 'g_weak_ref_set';
implementation
function TGTypeInstance.get_private(private_type: TGType): gpointer; cdecl;
begin
  Result := GObject2.g_type_instance_get_private(@self, private_type);
end;

procedure TGTypeClass.add_private(private_size: gsize); cdecl;
begin
  GObject2.g_type_class_add_private(@self, private_size);
end;

function TGTypeClass.get_instance_private_offset: gint; cdecl;
begin
  Result := GObject2.g_type_class_get_instance_private_offset(@self);
end;

function TGTypeClass.get_private(private_type: TGType): gpointer; cdecl;
begin
  Result := GObject2.g_type_class_get_private(@self, private_type);
end;

function TGTypeClass.peek_parent: PGTypeClass; cdecl;
begin
  Result := GObject2.g_type_class_peek_parent(@self);
end;

procedure TGTypeClass.unref; cdecl;
begin
  GObject2.g_type_class_unref(@self);
end;

procedure TGTypeClass.unref_uncached; cdecl;
begin
  GObject2.g_type_class_unref_uncached(@self);
end;

procedure TGTypeClass.adjust_private_offset(g_class: gpointer; private_size_or_offset: Pgint); cdecl;
begin
  GObject2.g_type_class_adjust_private_offset(g_class, private_size_or_offset);
end;

function TGTypeClass.get(type_: TGType): PGTypeClass; cdecl;
begin
  Result := GObject2.g_type_class_get(type_);
end;

function TGTypeClass.peek(type_: TGType): PGTypeClass; cdecl;
begin
  Result := GObject2.g_type_class_peek(type_);
end;

function TGTypeClass.peek_static(type_: TGType): PGTypeClass; cdecl;
begin
  Result := GObject2.g_type_class_peek_static(type_);
end;

function TGTypeClass.ref(type_: TGType): PGTypeClass; cdecl;
begin
  Result := GObject2.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 := GObject2.g_object_new_with_properties(object_type, n_properties, names, values);
end;

function TGObject.newv(object_type: TGType; n_parameters: guint; parameters: PGParameter): PGObject; cdecl;
begin
  Result := GObject2.g_object_newv(object_type, n_parameters, parameters);
end;

function TGObject.compat_control(what: gsize; data: gpointer): gsize; cdecl;
begin
  Result := GObject2.g_object_compat_control(what, data);
end;

function TGTypeInterface.peek_parent: PGTypeInterface; cdecl;
begin
  Result := GObject2.g_type_interface_peek_parent(@self);
end;

procedure TGTypeInterface.add_prerequisite(interface_type: TGType; prerequisite_type: TGType); cdecl;
begin
  GObject2.g_type_interface_add_prerequisite(interface_type, prerequisite_type);
end;

function TGTypeInterface.get_plugin(instance_type: TGType; interface_type: TGType): PGTypePlugin; cdecl;
begin
  Result := GObject2.g_type_interface_get_plugin(instance_type, interface_type);
end;

function TGTypeInterface.instantiatable_prerequisite(interface_type: TGType): TGType; cdecl;
begin
  Result := GObject2.g_type_interface_instantiatable_prerequisite(interface_type);
end;

function TGTypeInterface.peek(instance_class: PGTypeClass; iface_type: TGType): PGTypeInterface; cdecl;
begin
  Result := GObject2.g_type_interface_peek(instance_class, iface_type);
end;

function TGTypeInterface.prerequisites(interface_type: TGType; n_prerequisites: Pguint): PGType; cdecl;
begin
  Result := GObject2.g_type_interface_prerequisites(interface_type, n_prerequisites);
end;

function TGObject.interface_find_property(g_iface: PGTypeInterface; property_name: Pgchar): PGParamSpec; cdecl;
begin
  Result := GObject2.g_object_interface_find_property(g_iface, property_name);
end;

procedure TGObject.interface_install_property(g_iface: PGTypeInterface; pspec: PGParamSpec); cdecl;
begin
  GObject2.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 := GObject2.g_object_interface_list_properties(g_iface, n_properties_p);
end;

procedure TGObject.add_toggle_ref(notify: TGToggleNotify; data: gpointer); cdecl;
begin
  GObject2.g_object_add_toggle_ref(@self, notify, data);
end;

procedure TGObject.add_weak_pointer(weak_pointer_location: Pgpointer); cdecl;
begin
  GObject2.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 := GObject2.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 := GObject2.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 := GObject2.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 := GObject2.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 := GObject2.g_object_dup_qdata(@self, quark, dup_func, user_data);
end;

procedure TGObject.force_floating; cdecl;
begin
  GObject2.g_object_force_floating(@self);
end;

procedure TGObject.freeze_notify; cdecl;
begin
  GObject2.g_object_freeze_notify(@self);
end;

function TGObject.get_data(key: Pgchar): gpointer; cdecl;
begin
  Result := GObject2.g_object_get_data(@self, key);
end;

procedure TGObject.get_property(property_name: Pgchar; value: PGValue); cdecl;
begin
  GObject2.g_object_get_property(@self, property_name, value);
end;

function TGObject.get_qdata(quark: TGQuark): gpointer; cdecl;
begin
  Result := GObject2.g_object_get_qdata(@self, quark);
end;

procedure TGObject.getv(n_properties: guint; names: PPgchar; values: PGValue); cdecl;
begin
  GObject2.g_object_getv(@self, n_properties, names, values);
end;

function TGObject.is_floating: gboolean; cdecl;
begin
  Result := GObject2.g_object_is_floating(@self);
end;

procedure TGObject.notify(property_name: Pgchar); cdecl;
begin
  GObject2.g_object_notify(@self, property_name);
end;

procedure TGObject.notify_by_pspec(pspec: PGParamSpec); cdecl;
begin
  GObject2.g_object_notify_by_pspec(@self, pspec);
end;

function TGObject.ref: PGObject; cdecl;
begin
  Result := GObject2.g_object_ref(@self);
end;

function TGObject.ref_sink: PGObject; cdecl;
begin
  Result := GObject2.g_object_ref_sink(@self);
end;

procedure TGObject.remove_toggle_ref(notify: TGToggleNotify; data: gpointer); cdecl;
begin
  GObject2.g_object_remove_toggle_ref(@self, notify, data);
end;

procedure TGObject.remove_weak_pointer(weak_pointer_location: Pgpointer); cdecl;
begin
  GObject2.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 := GObject2.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 := GObject2.g_object_replace_qdata(@self, quark, oldval, newval, destroy_, old_destroy);
end;

procedure TGObject.run_dispose; cdecl;
begin
  GObject2.g_object_run_dispose(@self);
end;

procedure TGObject.set_data(key: Pgchar; data: gpointer); cdecl;
begin
  GObject2.g_object_set_data(@self, key, data);
end;

procedure TGObject.set_data_full(key: Pgchar; data: gpointer; destroy_: TGDestroyNotify); cdecl;
begin
  GObject2.g_object_set_data_full(@self, key, data, destroy_);
end;

procedure TGObject.set_property(property_name: Pgchar; value: PGValue); cdecl;
begin
  GObject2.g_object_set_property(@self, property_name, value);
end;

procedure TGObject.set_qdata(quark: TGQuark; data: gpointer); cdecl;
begin
  GObject2.g_object_set_qdata(@self, quark, data);
end;

procedure TGObject.set_qdata_full(quark: TGQuark; data: gpointer; destroy_: TGDestroyNotify); cdecl;
begin
  GObject2.g_object_set_qdata_full(@self, quark, data, destroy_);
end;

procedure TGObject.setv(n_properties: guint; names: PPgchar; values: PGValue); cdecl;
begin
  GObject2.g_object_setv(@self, n_properties, names, values);
end;

function TGObject.steal_data(key: Pgchar): gpointer; cdecl;
begin
  Result := GObject2.g_object_steal_data(@self, key);
end;

function TGObject.steal_qdata(quark: TGQuark): gpointer; cdecl;
begin
  Result := GObject2.g_object_steal_qdata(@self, quark);
end;

function TGObject.take_ref: PGObject; cdecl;
begin
  Result := GObject2.g_object_take_ref(@self);
end;

procedure TGObject.thaw_notify; cdecl;
begin
  GObject2.g_object_thaw_notify(@self);
end;

procedure TGObject.unref; cdecl;
begin
  GObject2.g_object_unref(@self);
end;

procedure TGObject.watch_closure(closure: PGClosure); cdecl;
begin
  GObject2.g_object_watch_closure(@self, closure);
end;

procedure TGObject.weak_ref(notify: TGWeakNotify; data: gpointer); cdecl;
begin
  GObject2.g_object_weak_ref(@self, notify, data);
end;

procedure TGObject.weak_unref(notify: TGWeakNotify; data: gpointer); cdecl;
begin
  GObject2.g_object_weak_unref(@self, notify, data);
end;

function TGBinding.dup_source: PGObject; cdecl;
begin
  Result := GObject2.g_binding_dup_source(@self);
end;

function TGBinding.dup_target: PGObject; cdecl;
begin
  Result := GObject2.g_binding_dup_target(@self);
end;

function TGBinding.get_flags: TGBindingFlags; cdecl;
begin
  Result := GObject2.g_binding_get_flags(@self);
end;

function TGBinding.get_source: PGObject; cdecl;
begin
  Result := GObject2.g_binding_get_source(@self);
end;

function TGBinding.get_source_property: Pgchar; cdecl;
begin
  Result := GObject2.g_binding_get_source_property(@self);
end;

function TGBinding.get_target: PGObject; cdecl;
begin
  Result := GObject2.g_binding_get_target(@self);
end;

function TGBinding.get_target_property: Pgchar; cdecl;
begin
  Result := GObject2.g_binding_get_target_property(@self);
end;

procedure TGBinding.unbind; cdecl;
begin
  GObject2.g_binding_unbind(@self);
end;

function TGBindingGroup.new: PGBindingGroup; cdecl;
begin
  Result := GObject2.g_binding_group_new();
end;

procedure TGBindingGroup.bind(source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags); cdecl;
begin
  GObject2.g_binding_group_bind(@self, source_property, target, target_property, flags);
end;

procedure TGBindingGroup.bind_full(source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags; transform_to: TGBindingTransformFunc; transform_from: TGBindingTransformFunc; user_data: gpointer; user_data_destroy: TGDestroyNotify); cdecl;
begin
  GObject2.g_binding_group_bind_full(@self, source_property, target, target_property, flags, transform_to, transform_from, user_data, user_data_destroy);
end;

procedure TGBindingGroup.bind_with_closures(source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags; transform_to: PGClosure; transform_from: PGClosure); cdecl;
begin
  GObject2.g_binding_group_bind_with_closures(@self, source_property, target, target_property, flags, transform_to, transform_from);
end;

function TGBindingGroup.dup_source: PGObject; cdecl;
begin
  Result := GObject2.g_binding_group_dup_source(@self);
end;

procedure TGBindingGroup.set_source(source: PGObject); cdecl;
begin
  GObject2.g_binding_group_set_source(@self, source);
end;

function TGClosure.new_object(sizeof_closure: guint; object_: PGObject): PGClosure; cdecl;
begin
  Result := GObject2.g_closure_new_object(sizeof_closure, object_);
end;

function TGClosure.new_simple(sizeof_closure: guint; data: gpointer): PGClosure; cdecl;
begin
  Result := GObject2.g_closure_new_simple(sizeof_closure, data);
end;

procedure TGClosure.add_finalize_notifier(notify_data: gpointer; notify_func: TGClosureNotify); cdecl;
begin
  GObject2.g_closure_add_finalize_notifier(@self, notify_data, notify_func);
end;

procedure TGClosure.add_invalidate_notifier(notify_data: gpointer; notify_func: TGClosureNotify); cdecl;
begin
  GObject2.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
  GObject2.g_closure_add_marshal_guards(@self, pre_marshal_data, pre_marshal_notify, post_marshal_data, post_marshal_notify);
end;

procedure TGClosure.invalidate; cdecl;
begin
  GObject2.g_closure_invalidate(@self);
end;

procedure TGClosure.invoke(return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer); cdecl;
begin
  GObject2.g_closure_invoke(@self, return_value, n_param_values, param_values, invocation_hint);
end;

function TGClosure.ref: PGClosure; cdecl;
begin
  Result := GObject2.g_closure_ref(@self);
end;

procedure TGClosure.remove_finalize_notifier(notify_data: gpointer; notify_func: TGClosureNotify); cdecl;
begin
  GObject2.g_closure_remove_finalize_notifier(@self, notify_data, notify_func);
end;

procedure TGClosure.remove_invalidate_notifier(notify_data: gpointer; notify_func: TGClosureNotify); cdecl;
begin
  GObject2.g_closure_remove_invalidate_notifier(@self, notify_data, notify_func);
end;

procedure TGClosure.set_marshal(marshal: TGClosureMarshal); cdecl;
begin
  GObject2.g_closure_set_marshal(@self, marshal);
end;

procedure TGClosure.set_meta_marshal(marshal_data: gpointer; meta_marshal: TGClosureMarshal); cdecl;
begin
  GObject2.g_closure_set_meta_marshal(@self, marshal_data, meta_marshal);
end;

procedure TGClosure.sink; cdecl;
begin
  GObject2.g_closure_sink(@self);
end;

procedure TGClosure.unref; cdecl;
begin
  GObject2.g_closure_unref(@self);
end;

procedure TGValue.copy(dest_value: PGValue); cdecl;
begin
  GObject2.g_value_copy(@self, dest_value);
end;

function TGValue.dup_boxed: gpointer; cdecl;
begin
  Result := GObject2.g_value_dup_boxed(@self);
end;

function TGValue.dup_object: PGObject; cdecl;
begin
  Result := GObject2.g_value_dup_object(@self);
end;

function TGValue.dup_param: PGParamSpec; cdecl;
begin
  Result := GObject2.g_value_dup_param(@self);
end;

function TGValue.dup_string: Pgchar; cdecl;
begin
  Result := GObject2.g_value_dup_string(@self);
end;

function TGValue.dup_variant: PGVariant; cdecl;
begin
  Result := GObject2.g_value_dup_variant(@self);
end;

function TGValue.fits_pointer: gboolean; cdecl;
begin
  Result := GObject2.g_value_fits_pointer(@self);
end;

function TGValue.get_boolean: gboolean; cdecl;
begin
  Result := GObject2.g_value_get_boolean(@self);
end;

function TGValue.get_boxed: gpointer; cdecl;
begin
  Result := GObject2.g_value_get_boxed(@self);
end;

function TGValue.get_char: gchar; cdecl;
begin
  Result := GObject2.g_value_get_char(@self);
end;

function TGValue.get_double: gdouble; cdecl;
begin
  Result := GObject2.g_value_get_double(@self);
end;

function TGValue.get_enum: gint; cdecl;
begin
  Result := GObject2.g_value_get_enum(@self);
end;

function TGValue.get_flags: guint; cdecl;
begin
  Result := GObject2.g_value_get_flags(@self);
end;

function TGValue.get_float: gfloat; cdecl;
begin
  Result := GObject2.g_value_get_float(@self);
end;

function TGValue.get_gtype: TGType; cdecl;
begin
  Result := GObject2.g_value_get_gtype(@self);
end;

function TGValue.get_int: gint; cdecl;
begin
  Result := GObject2.g_value_get_int(@self);
end;

function TGValue.get_int64: gint64; cdecl;
begin
  Result := GObject2.g_value_get_int64(@self);
end;

function TGValue.get_long: glong; cdecl;
begin
  Result := GObject2.g_value_get_long(@self);
end;

function TGValue.get_object: PGObject; cdecl;
begin
  Result := GObject2.g_value_get_object(@self);
end;

function TGValue.get_param: PGParamSpec; cdecl;
begin
  Result := GObject2.g_value_get_param(@self);
end;

function TGValue.get_pointer: gpointer; cdecl;
begin
  Result := GObject2.g_value_get_pointer(@self);
end;

function TGValue.get_schar: gint8; cdecl;
begin
  Result := GObject2.g_value_get_schar(@self);
end;

function TGValue.get_string: Pgchar; cdecl;
begin
  Result := GObject2.g_value_get_string(@self);
end;

function TGValue.get_uchar: guint8; cdecl;
begin
  Result := GObject2.g_value_get_uchar(@self);
end;

function TGValue.get_uint: guint; cdecl;
begin
  Result := GObject2.g_value_get_uint(@self);
end;

function TGValue.get_uint64: guint64; cdecl;
begin
  Result := GObject2.g_value_get_uint64(@self);
end;

function TGValue.get_ulong: gulong; cdecl;
begin
  Result := GObject2.g_value_get_ulong(@self);
end;

function TGValue.get_variant: PGVariant; cdecl;
begin
  Result := GObject2.g_value_get_variant(@self);
end;

function TGValue.init(g_type: TGType): PGValue; cdecl;
begin
  Result := GObject2.g_value_init(@self, g_type);
end;

procedure TGValue.init_from_instance(instance: PGTypeInstance); cdecl;
begin
  GObject2.g_value_init_from_instance(@self, instance);
end;

function TGValue.peek_pointer: gpointer; cdecl;
begin
  Result := GObject2.g_value_peek_pointer(@self);
end;

function TGValue.reset: PGValue; cdecl;
begin
  Result := GObject2.g_value_reset(@self);
end;

procedure TGValue.set_boolean(v_boolean: gboolean); cdecl;
begin
  GObject2.g_value_set_boolean(@self, v_boolean);
end;

procedure TGValue.set_boxed(v_boxed: Pgpointer); cdecl;
begin
  GObject2.g_value_set_boxed(@self, v_boxed);
end;

procedure TGValue.set_boxed_take_ownership(v_boxed: Pgpointer); cdecl;
begin
  GObject2.g_value_set_boxed_take_ownership(@self, v_boxed);
end;

procedure TGValue.set_char(v_char: gchar); cdecl;
begin
  GObject2.g_value_set_char(@self, v_char);
end;

procedure TGValue.set_double(v_double: gdouble); cdecl;
begin
  GObject2.g_value_set_double(@self, v_double);
end;

procedure TGValue.set_enum(v_enum: gint); cdecl;
begin
  GObject2.g_value_set_enum(@self, v_enum);
end;

procedure TGValue.set_flags(v_flags: guint); cdecl;
begin
  GObject2.g_value_set_flags(@self, v_flags);
end;

procedure TGValue.set_float(v_float: gfloat); cdecl;
begin
  GObject2.g_value_set_float(@self, v_float);
end;

procedure TGValue.set_gtype(v_gtype: TGType); cdecl;
begin
  GObject2.g_value_set_gtype(@self, v_gtype);
end;

procedure TGValue.set_instance(instance: gpointer); cdecl;
begin
  GObject2.g_value_set_instance(@self, instance);
end;

procedure TGValue.set_int(v_int: gint); cdecl;
begin
  GObject2.g_value_set_int(@self, v_int);
end;

procedure TGValue.set_int64(v_int64: gint64); cdecl;
begin
  GObject2.g_value_set_int64(@self, v_int64);
end;

procedure TGValue.set_interned_string(v_string: Pgchar); cdecl;
begin
  GObject2.g_value_set_interned_string(@self, v_string);
end;

procedure TGValue.set_long(v_long: glong); cdecl;
begin
  GObject2.g_value_set_long(@self, v_long);
end;

procedure TGValue.set_object(v_object: PGObject); cdecl;
begin
  GObject2.g_value_set_object(@self, v_object);
end;

procedure TGValue.set_object_take_ownership(v_object: gpointer); cdecl;
begin
  GObject2.g_value_set_object_take_ownership(@self, v_object);
end;

procedure TGValue.set_param(param: PGParamSpec); cdecl;
begin
  GObject2.g_value_set_param(@self, param);
end;

procedure TGValue.set_param_take_ownership(param: PGParamSpec); cdecl;
begin
  GObject2.g_value_set_param_take_ownership(@self, param);
end;

procedure TGValue.set_pointer(v_pointer: gpointer); cdecl;
begin
  GObject2.g_value_set_pointer(@self, v_pointer);
end;

procedure TGValue.set_schar(v_char: gint8); cdecl;
begin
  GObject2.g_value_set_schar(@self, v_char);
end;

procedure TGValue.set_static_boxed(v_boxed: Pgpointer); cdecl;
begin
  GObject2.g_value_set_static_boxed(@self, v_boxed);
end;

procedure TGValue.set_static_string(v_string: Pgchar); cdecl;
begin
  GObject2.g_value_set_static_string(@self, v_string);
end;

procedure TGValue.set_string(v_string: Pgchar); cdecl;
begin
  GObject2.g_value_set_string(@self, v_string);
end;

procedure TGValue.set_string_take_ownership(v_string: Pgchar); cdecl;
begin
  GObject2.g_value_set_string_take_ownership(@self, v_string);
end;

procedure TGValue.set_uchar(v_uchar: guint8); cdecl;
begin
  GObject2.g_value_set_uchar(@self, v_uchar);
end;

procedure TGValue.set_uint(v_uint: guint); cdecl;
begin
  GObject2.g_value_set_uint(@self, v_uint);
end;

procedure TGValue.set_uint64(v_uint64: guint64); cdecl;
begin
  GObject2.g_value_set_uint64(@self, v_uint64);
end;

procedure TGValue.set_ulong(v_ulong: gulong); cdecl;
begin
  GObject2.g_value_set_ulong(@self, v_ulong);
end;

procedure TGValue.set_variant(variant: PGVariant); cdecl;
begin
  GObject2.g_value_set_variant(@self, variant);
end;

function TGValue.steal_string: Pgchar; cdecl;
begin
  Result := GObject2.g_value_steal_string(@self);
end;

procedure TGValue.take_boxed(v_boxed: Pgpointer); cdecl;
begin
  GObject2.g_value_take_boxed(@self, v_boxed);
end;

procedure TGValue.take_object(v_object: gpointer); cdecl;
begin
  GObject2.g_value_take_object(@self, v_object);
end;

procedure TGValue.take_param(param: PGParamSpec); cdecl;
begin
  GObject2.g_value_take_param(@self, param);
end;

procedure TGValue.take_string(v_string: Pgchar); cdecl;
begin
  GObject2.g_value_take_string(@self, v_string);
end;

procedure TGValue.take_variant(variant: PGVariant); cdecl;
begin
  GObject2.g_value_take_variant(@self, variant);
end;

function TGValue.transform(dest_value: PGValue): gboolean; cdecl;
begin
  Result := GObject2.g_value_transform(@self, dest_value);
end;

procedure TGValue.unset; cdecl;
begin
  GObject2.g_value_unset(@self);
end;

procedure TGValue.register_transform_func(src_type: TGType; dest_type: TGType; transform_func: TGValueTransform); cdecl;
begin
  GObject2.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 := GObject2.g_value_type_compatible(src_type, dest_type);
end;

function TGValue.type_transformable(src_type: TGType; dest_type: TGType): gboolean; cdecl;
begin
  Result := GObject2.g_value_type_transformable(src_type, dest_type);
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
  GObject2.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
  GObject2.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
  GObject2.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
  GObject2.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
  GObject2.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
  GObject2.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
  GObject2.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
  GObject2.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
  GObject2.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
  GObject2.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
  GObject2.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
  GObject2.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
  GObject2.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
  GObject2.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
  GObject2.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
  GObject2.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
  GObject2.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
  GObject2.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
  GObject2.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
  GObject2.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
  GObject2.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
  GObject2.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
  GObject2.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 := GObject2.g_cclosure_new(callback_func, user_data, destroy_data);
end;

function TGCClosure.new_object(callback_func: TGCallback; object_: PGObject): PGClosure; cdecl;
begin
  Result := GObject2.g_cclosure_new_object(callback_func, object_);
end;

function TGCClosure.new_object_swap(callback_func: TGCallback; object_: PGObject): PGClosure; cdecl;
begin
  Result := GObject2.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 := GObject2.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 := GObject2.g_param_spec_internal(param_type, name, nick, blurb, flags);
end;

function TGParamSpec.is_valid_name(name: Pgchar): gboolean; cdecl;
begin
  Result := GObject2.g_param_spec_is_valid_name(name);
end;

function TGParamSpec.get_blurb: Pgchar; cdecl;
begin
  Result := GObject2.g_param_spec_get_blurb(@self);
end;

function TGParamSpec.get_default_value: PGValue; cdecl;
begin
  Result := GObject2.g_param_spec_get_default_value(@self);
end;

function TGParamSpec.get_name: Pgchar; cdecl;
begin
  Result := GObject2.g_param_spec_get_name(@self);
end;

function TGParamSpec.get_name_quark: TGQuark; cdecl;
begin
  Result := GObject2.g_param_spec_get_name_quark(@self);
end;

function TGParamSpec.get_nick: Pgchar; cdecl;
begin
  Result := GObject2.g_param_spec_get_nick(@self);
end;

function TGParamSpec.get_qdata(quark: TGQuark): gpointer; cdecl;
begin
  Result := GObject2.g_param_spec_get_qdata(@self, quark);
end;

function TGParamSpec.get_redirect_target: PGParamSpec; cdecl;
begin
  Result := GObject2.g_param_spec_get_redirect_target(@self);
end;

function TGParamSpec.ref: PGParamSpec; cdecl;
begin
  Result := GObject2.g_param_spec_ref(@self);
end;

function TGParamSpec.ref_sink: PGParamSpec; cdecl;
begin
  Result := GObject2.g_param_spec_ref_sink(@self);
end;

procedure TGParamSpec.set_qdata(quark: TGQuark; data: gpointer); cdecl;
begin
  GObject2.g_param_spec_set_qdata(@self, quark, data);
end;

procedure TGParamSpec.set_qdata_full(quark: TGQuark; data: gpointer; destroy_: TGDestroyNotify); cdecl;
begin
  GObject2.g_param_spec_set_qdata_full(@self, quark, data, destroy_);
end;

procedure TGParamSpec.sink; cdecl;
begin
  GObject2.g_param_spec_sink(@self);
end;

function TGParamSpec.steal_qdata(quark: TGQuark): gpointer; cdecl;
begin
  Result := GObject2.g_param_spec_steal_qdata(@self, quark);
end;

procedure TGParamSpec.unref; cdecl;
begin
  GObject2.g_param_spec_unref(@self);
end;

function TGObjectClass.find_property(property_name: Pgchar): PGParamSpec; cdecl;
begin
  Result := GObject2.g_object_class_find_property(@self, property_name);
end;

procedure TGObjectClass.install_properties(n_pspecs: guint; pspecs: PPGParamSpec); cdecl;
begin
  GObject2.g_object_class_install_properties(@self, n_pspecs, pspecs);
end;

procedure TGObjectClass.install_property(property_id: guint; pspec: PGParamSpec); cdecl;
begin
  GObject2.g_object_class_install_property(@self, property_id, pspec);
end;

function TGObjectClass.list_properties(n_properties: Pguint): PPGParamSpec; cdecl;
begin
  Result := GObject2.g_object_class_list_properties(@self, n_properties);
end;

procedure TGObjectClass.override_property(property_id: guint; name: Pgchar); cdecl;
begin
  GObject2.g_object_class_override_property(@self, property_id, name);
end;

procedure TGParamSpecPool.free; cdecl;
begin
  GObject2.g_param_spec_pool_free(@self);
end;

procedure TGParamSpecPool.insert(pspec: PGParamSpec; owner_type: TGType); cdecl;
begin
  GObject2.g_param_spec_pool_insert(@self, pspec, owner_type);
end;

function TGParamSpecPool.list(owner_type: TGType; n_pspecs_p: Pguint): PPGParamSpec; cdecl;
begin
  Result := GObject2.g_param_spec_pool_list(@self, owner_type, n_pspecs_p);
end;

function TGParamSpecPool.list_owned(owner_type: TGType): PGList; cdecl;
begin
  Result := GObject2.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 := GObject2.g_param_spec_pool_lookup(@self, param_name, owner_type, walk_ancestors);
end;

procedure TGParamSpecPool.remove(pspec: PGParamSpec); cdecl;
begin
  GObject2.g_param_spec_pool_remove(@self, pspec);
end;

function TGParamSpecPool.new(type_prefixing: gboolean): PGParamSpecPool; cdecl;
begin
  Result := GObject2.g_param_spec_pool_new(type_prefixing);
end;

function TGSignalGroup.new(target_type: TGType): PGSignalGroup; cdecl;
begin
  Result := GObject2.g_signal_group_new(target_type);
end;

procedure TGSignalGroup.block; cdecl;
begin
  GObject2.g_signal_group_block(@self);
end;

procedure TGSignalGroup.connect(detailed_signal: Pgchar; c_handler: TGCallback; data: gpointer); cdecl;
begin
  GObject2.g_signal_group_connect(@self, detailed_signal, c_handler, data);
end;

procedure TGSignalGroup.connect_after(detailed_signal: Pgchar; c_handler: TGCallback; data: gpointer); cdecl;
begin
  GObject2.g_signal_group_connect_after(@self, detailed_signal, c_handler, data);
end;

procedure TGSignalGroup.connect_closure(detailed_signal: Pgchar; closure: PGClosure; after: gboolean); cdecl;
begin
  GObject2.g_signal_group_connect_closure(@self, detailed_signal, closure, after);
end;

procedure TGSignalGroup.connect_data(detailed_signal: Pgchar; c_handler: TGCallback; data: gpointer; notify: TGClosureNotify; flags: TGConnectFlags); cdecl;
begin
  GObject2.g_signal_group_connect_data(@self, detailed_signal, c_handler, data, notify, flags);
end;

procedure TGSignalGroup.connect_object(detailed_signal: Pgchar; c_handler: TGCallback; object_: gpointer; flags: TGConnectFlags); cdecl;
begin
  GObject2.g_signal_group_connect_object(@self, detailed_signal, c_handler, object_, flags);
end;

procedure TGSignalGroup.connect_swapped(detailed_signal: Pgchar; c_handler: TGCallback; data: gpointer); cdecl;
begin
  GObject2.g_signal_group_connect_swapped(@self, detailed_signal, c_handler, data);
end;

function TGSignalGroup.dup_target: PGObject; cdecl;
begin
  Result := GObject2.g_signal_group_dup_target(@self);
end;

procedure TGSignalGroup.set_target(target: PGObject); cdecl;
begin
  GObject2.g_signal_group_set_target(@self, target);
end;

procedure TGSignalGroup.unblock; cdecl;
begin
  GObject2.g_signal_group_unblock(@self);
end;

function TGTypeValueTable.peek(type_: TGType): PGTypeValueTable; cdecl;
begin
  Result := GObject2.g_type_value_table_peek(type_);
end;

procedure TGTypePlugin.complete_interface_info(instance_type: TGType; interface_type: TGType; info: PGInterfaceInfo); cdecl;
begin
  GObject2.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
  GObject2.g_type_plugin_complete_type_info(@self, g_type, info, value_table);
end;

procedure TGTypePlugin.unuse; cdecl;
begin
  GObject2.g_type_plugin_unuse(@self);
end;

procedure TGTypePlugin.use; cdecl;
begin
  GObject2.g_type_plugin_use(@self);
end;

procedure TGTypeModule.add_interface(instance_type: TGType; interface_type: TGType; interface_info: PGInterfaceInfo); cdecl;
begin
  GObject2.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 := GObject2.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 := GObject2.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 := GObject2.g_type_module_register_type(@self, parent_type, type_name, type_info, flags);
end;

procedure TGTypeModule.set_name(name: Pgchar); cdecl;
begin
  GObject2.g_type_module_set_name(@self, name);
end;

procedure TGTypeModule.unuse; cdecl;
begin
  GObject2.g_type_module_unuse(@self);
end;

function TGTypeModule.use: gboolean; cdecl;
begin
  Result := GObject2.g_type_module_use(@self);
end;

function TGValueArray.new(n_prealloced: guint): PGValueArray; cdecl;
begin
  Result := GObject2.g_value_array_new(n_prealloced);
end;

function TGValueArray.append(value: PGValue): PGValueArray; cdecl;
begin
  Result := GObject2.g_value_array_append(@self, value);
end;

function TGValueArray.copy: PGValueArray; cdecl;
begin
  Result := GObject2.g_value_array_copy(@self);
end;

procedure TGValueArray.free; cdecl;
begin
  GObject2.g_value_array_free(@self);
end;

function TGValueArray.get_nth(index_: guint): PGValue; cdecl;
begin
  Result := GObject2.g_value_array_get_nth(@self, index_);
end;

function TGValueArray.insert(index_: guint; value: PGValue): PGValueArray; cdecl;
begin
  Result := GObject2.g_value_array_insert(@self, index_, value);
end;

function TGValueArray.prepend(value: PGValue): PGValueArray; cdecl;
begin
  Result := GObject2.g_value_array_prepend(@self, value);
end;

function TGValueArray.remove(index_: guint): PGValueArray; cdecl;
begin
  Result := GObject2.g_value_array_remove(@self, index_);
end;

function TGValueArray.sort(compare_func: TGCompareFunc): PGValueArray; cdecl;
begin
  Result := GObject2.g_value_array_sort(@self, compare_func);
end;

function TGValueArray.sort_with_data(compare_func: TGCompareDataFunc; user_data: gpointer): PGValueArray; cdecl;
begin
  Result := GObject2.g_value_array_sort_with_data(@self, compare_func, user_data);
end;

procedure TGWeakRef.clear; cdecl;
begin
  GObject2.g_weak_ref_clear(@self);
end;

function TGWeakRef.get: PGObject; cdecl;
begin
  Result := GObject2.g_weak_ref_get(@self);
end;

procedure TGWeakRef.init(object_: PGObject); cdecl;
begin
  GObject2.g_weak_ref_init(@self, object_);
end;

procedure TGWeakRef.set_(object_: PGObject); cdecl;
begin
  GObject2.g_weak_ref_set(@self, object_);
end;

end.