← Back to branch summary

~ubuntu-branches/ubuntu/vivid/lazarus/vivid

« back to all changes in this revision

Viewing changes to lcl/interfaces/gtk3/gtk3bindings/lazgobject2.pas

  • Committer: Package Import Robot
  • Author(s): Paul Gevers, Abou Al Montacir, Paul Gevers
  • Date: 2014-02-22 10:25:57 UTC
  • mfrom: (1.1.11)
  • Revision ID: package-import@ubuntu.com-20140222102557-ors9d31r84nz31jq
Tags: 1.2~rc2+dfsg-1
http://bugs.debian.org/724776
[ Abou Al Montacir ]
* New upstream pre-release.
  + Moved ideintf to components directory.
  + Added new package cairocanvas.
* Remove usage of depreciated parameters form of find. (Closes: Bug#724776)
* Bumped standard version to 3.9.5.
* Clean the way handling make files generation and removal.

[ Paul Gevers ]
* Remove nearly obsolete bzip compression for binary packages
  (See https://lists.debian.org/debian-devel/2014/01/msg00542.html)
* Update d/copyright for newly added dir in examples and components
* Update Vcs-* fields with new packaging location
* Update d/watch file to properly (Debian way) change upstreams versions
* Prevent 46MB of package size by sym linking duplicate files
* Patches
  - refresh to remove fuzz
  - add more Lintian found spelling errors
  - new patch to add shbang to two scripts in lazarus-src
* Drop lcl-# from Provides list of lcl-units-#
* Make lazarus-ide-qt4-# an arch all until it really contains stuff
* Make all metapackages arch all as the usecase for arch any doesn't
  seem to warrant the addition archive hit
* Fix permissions of non-scripts in lazarus-src-#

Show diffs side-by-side

added added

removed removed

Lines of Context:
lcl/interfaces/gtk3/gtk3bindings/lazgobject2.pas
 
1
{ This is an autogenerated unit using gobject introspection (gir2pascal). Do not Edit. }
 
2
unit LazGObject2;
 
3
 
 
4
{$MODE OBJFPC}{$H+}
 
5
 
 
6
{$PACKRECORDS C}
 
7
{$MODESWITCH DUPLICATELOCALS+}
 
8
 
 
9
{$LINKLIB libgobject-2.0.so.0}
 
10
interface
 
11
uses
 
12
  CTypes, LazGLib2;
 
13
 
 
14
const
 
15
  GObject2_library = 'libgobject-2.0.so.0';
 
16
 
 
17
  PARAM_MASK = 255;
 
18
  PARAM_READWRITE = 0;
 
19
  PARAM_STATIC_STRINGS = 0;
 
20
  PARAM_USER_SHIFT = 8;
 
21
  SIGNAL_FLAGS_MASK = 511;
 
22
  SIGNAL_MATCH_MASK = 63;
 
23
  TYPE_FUNDAMENTAL_MAX = 255;
 
24
  TYPE_FUNDAMENTAL_SHIFT = 2;
 
25
  TYPE_RESERVED_BSE_FIRST = 32;
 
26
  TYPE_RESERVED_BSE_LAST = 48;
 
27
  TYPE_RESERVED_GLIB_FIRST = 22;
 
28
  TYPE_RESERVED_GLIB_LAST = 31;
 
29
  TYPE_RESERVED_USER_FIRST = 49;
 
30
  VALUE_COLLECT_FORMAT_MAX_LENGTH = 8;
 
31
  VALUE_NOCOPY_CONTENTS = 134217728;
 
32
 
 
33
type
 
34
  TGBindingFlags = Integer;
 
35
const
 
36
  { GBindingFlags }
 
37
  G_BINDING_DEFAULT: TGBindingFlags = 0;
 
38
  G_BINDING_BIDIRECTIONAL: TGBindingFlags = 1;
 
39
  G_BINDING_SYNC_CREATE: TGBindingFlags = 2;
 
40
  G_BINDING_INVERT_BOOLEAN: TGBindingFlags = 4;
 
41
 
 
42
type
 
43
  TGConnectFlags = Integer;
 
44
const
 
45
  { GConnectFlags }
 
46
  G_CONNECT_AFTER: TGConnectFlags = 1;
 
47
  G_CONNECT_SWAPPED: TGConnectFlags = 2;
 
48
 
 
49
type
 
50
  TGParamFlags = Integer;
 
51
const
 
52
  { GParamFlags }
 
53
  G_PARAM_READABLE: TGParamFlags = 1;
 
54
  G_PARAM_WRITABLE: TGParamFlags = 2;
 
55
  G_PARAM_CONSTRUCT: TGParamFlags = 4;
 
56
  G_PARAM_CONSTRUCT_ONLY: TGParamFlags = 8;
 
57
  G_PARAM_LAX_VALIDATION: TGParamFlags = 16;
 
58
  G_PARAM_STATIC_NAME: TGParamFlags = 32;
 
59
  G_PARAM_PRIVATE: TGParamFlags = 32;
 
60
  G_PARAM_STATIC_NICK: TGParamFlags = 64;
 
61
  G_PARAM_STATIC_BLURB: TGParamFlags = 128;
 
62
  G_PARAM_DEPRECATED: TGParamFlags = 2147483648;
 
63
 
 
64
type
 
65
  TGSignalFlags = Integer;
 
66
const
 
67
  { GSignalFlags }
 
68
  G_SIGNAL_RUN_FIRST: TGSignalFlags = 1;
 
69
  G_SIGNAL_RUN_LAST: TGSignalFlags = 2;
 
70
  G_SIGNAL_RUN_CLEANUP: TGSignalFlags = 4;
 
71
  G_SIGNAL_NO_RECURSE: TGSignalFlags = 8;
 
72
  G_SIGNAL_DETAILED: TGSignalFlags = 16;
 
73
  G_SIGNAL_ACTION: TGSignalFlags = 32;
 
74
  G_SIGNAL_NO_HOOKS: TGSignalFlags = 64;
 
75
  G_SIGNAL_MUST_COLLECT: TGSignalFlags = 128;
 
76
  G_SIGNAL_DEPRECATED: TGSignalFlags = 256;
 
77
 
 
78
type
 
79
  TGSignalMatchType = Integer;
 
80
const
 
81
  { GSignalMatchType }
 
82
  G_SIGNAL_MATCH_ID: TGSignalMatchType = 1;
 
83
  G_SIGNAL_MATCH_DETAIL: TGSignalMatchType = 2;
 
84
  G_SIGNAL_MATCH_CLOSURE: TGSignalMatchType = 4;
 
85
  G_SIGNAL_MATCH_FUNC: TGSignalMatchType = 8;
 
86
  G_SIGNAL_MATCH_DATA: TGSignalMatchType = 16;
 
87
  G_SIGNAL_MATCH_UNBLOCKED: TGSignalMatchType = 32;
 
88
 
 
89
type
 
90
  TGTypeDebugFlags = Integer;
 
91
const
 
92
  { GTypeDebugFlags }
 
93
  G_TYPE_DEBUG_NONE: TGTypeDebugFlags = 0;
 
94
  G_TYPE_DEBUG_OBJECTS: TGTypeDebugFlags = 1;
 
95
  G_TYPE_DEBUG_SIGNALS: TGTypeDebugFlags = 2;
 
96
  G_TYPE_DEBUG_MASK: TGTypeDebugFlags = 3;
 
97
 
 
98
type
 
99
  TGTypeFlags = Integer;
 
100
const
 
101
  { GTypeFlags }
 
102
  G_TYPE_FLAG_ABSTRACT: TGTypeFlags = 16;
 
103
  G_TYPE_FLAG_VALUE_ABSTRACT: TGTypeFlags = 32;
 
104
 
 
105
type
 
106
  TGTypeFundamentalFlags = Integer;
 
107
const
 
108
  { GTypeFundamentalFlags }
 
109
  G_TYPE_FLAG_CLASSED: TGTypeFundamentalFlags = 1;
 
110
  G_TYPE_FLAG_INSTANTIATABLE: TGTypeFundamentalFlags = 2;
 
111
  G_TYPE_FLAG_DERIVABLE: TGTypeFundamentalFlags = 4;
 
112
  G_TYPE_FLAG_DEEP_DERIVABLE: TGTypeFundamentalFlags = 8;
 
113
type
 
114
 
 
115
  PPGClosure = ^PGClosure;
 
116
  PGClosure = ^TGClosure;
 
117
 
 
118
  PPPGValue = ^PPGValue;
 
119
  PPGValue = ^PGValue;
 
120
  PGValue = ^TGValue;
 
121
  TGClosureMarshal = procedure(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
122
 
 
123
  PPGSignalCMarshaller = ^PGSignalCMarshaller;
 
124
  PGSignalCMarshaller = ^TGSignalCMarshaller;
 
125
  TGSignalCMarshaller = TGClosureMarshal;
 
126
  TGVaClosureMarshal = procedure(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl;
 
127
 
 
128
  PPGSignalCVaMarshaller = ^PGSignalCVaMarshaller;
 
129
  PGSignalCVaMarshaller = ^TGSignalCVaMarshaller;
 
130
  TGSignalCVaMarshaller = TGVaClosureMarshal;
 
131
 
 
132
  PPGType = ^PGType;
 
133
  PGType = ^TGType;
 
134
  TGType = gsize;
 
135
  TGBaseFinalizeFunc = procedure(g_class: gpointer); cdecl;
 
136
  TGBaseInitFunc = procedure(g_class: gpointer); cdecl;
 
137
 
 
138
  PPGBindingFlags = ^PGBindingFlags;
 
139
  PGBindingFlags = ^TGBindingFlags;
 
140
 
 
141
  PPGObject = ^PGObject;
 
142
  PGObject = ^TGObject;
 
143
 
 
144
  PPGParameter = ^PGParameter;
 
145
  PGParameter = ^TGParameter;
 
146
 
 
147
  PPGParamSpec = ^PGParamSpec;
 
148
  PGParamSpec = ^TGParamSpec;
 
149
 
 
150
  PPGToggleNotify = ^PGToggleNotify;
 
151
  PGToggleNotify = ^TGToggleNotify;
 
152
  TGToggleNotify = procedure(data: gpointer; object_: PGObject; is_last_ref: gboolean); cdecl;
 
153
 
 
154
  PPGBinding = ^PGBinding;
 
155
  PGBinding = ^TGBinding;
 
156
 
 
157
  PPGBindingTransformFunc = ^PGBindingTransformFunc;
 
158
  PGBindingTransformFunc = ^TGBindingTransformFunc;
 
159
  TGBindingTransformFunc = function(binding: PGBinding; source_value: PGValue; target_value: PGValue; user_data: gpointer): gboolean; cdecl;
 
160
 
 
161
  PPGWeakNotify = ^PGWeakNotify;
 
162
  PGWeakNotify = ^TGWeakNotify;
 
163
  TGWeakNotify = procedure(data: gpointer; where_the_object_was: PGObject); cdecl;
 
164
 
 
165
  PPGTypeInstance = ^PGTypeInstance;
 
166
  PGTypeInstance = ^TGTypeInstance;
 
167
 
 
168
  PPGTypeClass = ^PGTypeClass;
 
169
  PGTypeClass = ^TGTypeClass;
 
170
  TGTypeInstance = object
 
171
    g_class: PGTypeClass;
 
172
    function get_private(private_type: TGType): gpointer; cdecl; inline;
 
173
  end;
 
174
  TGObject = object
 
175
    g_type_instance: TGTypeInstance;
 
176
    ref_count: guint;
 
177
    qdata: PGData;
 
178
    //function new_valist(object_type: TGType; first_property_name: Pgchar; var_args: Tva_list): PGObject; cdecl; inline; static;
 
179
    function newv(object_type: TGType; n_parameters: guint; parameters: PGParameter): PGObject; cdecl; inline; static;
 
180
    function compat_control(what: gsize; data: gpointer): gsize; cdecl; inline; static;
 
181
    //function connect(object_: gpointer; signal_spec: Pgchar; args: array of const): gpointer; cdecl; inline; static;
 
182
    //procedure disconnect(object_: gpointer; signal_spec: Pgchar; args: array of const); cdecl; inline; static;
 
183
    //procedure get(object_: gpointer; first_property_name: Pgchar; args: array of const); cdecl; inline; static;
 
184
    function interface_find_property(g_iface: gpointer; property_name: Pgchar): PGParamSpec; cdecl; inline; static;
 
185
    procedure interface_install_property(g_iface: gpointer; pspec: PGParamSpec); cdecl; inline; static;
 
186
    function interface_list_properties(g_iface: gpointer; n_properties_p: Pguint): PPGParamSpec; cdecl; inline; static;
 
187
    //function new(object_type: TGType; first_property_name: Pgchar; args: array of const): gpointer; cdecl; inline; static;
 
188
    //procedure set_(object_: gpointer; first_property_name: Pgchar; args: array of const); cdecl; inline; static;
 
189
    procedure add_toggle_ref(notify: TGToggleNotify; data: gpointer); cdecl; inline;
 
190
    procedure add_weak_pointer(weak_pointer_location: Pgpointer); cdecl; inline;
 
191
    function bind_property(source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags): PGBinding; cdecl; inline;
 
192
    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;
 
193
    function bind_property_with_closures(source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags; transform_to: PGClosure; transform_from: PGClosure): PGBinding; cdecl; inline;
 
194
    procedure force_floating; cdecl; inline;
 
195
    procedure freeze_notify; cdecl; inline;
 
196
    function get_data(key: Pgchar): gpointer; cdecl; inline;
 
197
    procedure get_property(property_name: Pgchar; value: PGValue); cdecl; inline;
 
198
    function get_qdata(quark: TGQuark): gpointer; cdecl; inline;
 
199
    //procedure get_valist(first_property_name: Pgchar; var_args: Tva_list); cdecl; inline;
 
200
    function is_floating: gboolean; cdecl; inline;
 
201
    procedure notify(property_name: Pgchar); cdecl; inline;
 
202
    procedure notify_by_pspec(pspec: PGParamSpec); cdecl; inline;
 
203
    function ref: PGObject; cdecl; inline;
 
204
    function ref_sink: PGObject; cdecl; inline;
 
205
    procedure remove_toggle_ref(notify: TGToggleNotify; data: gpointer); cdecl; inline;
 
206
    procedure remove_weak_pointer(weak_pointer_location: Pgpointer); cdecl; inline;
 
207
    procedure run_dispose; cdecl; inline;
 
208
    procedure set_data(key: Pgchar; data: gpointer); cdecl; inline;
 
209
    procedure set_data_full(key: Pgchar; data: gpointer; destroy_: TGDestroyNotify); cdecl; inline;
 
210
    procedure set_property(property_name: Pgchar; value: PGValue); cdecl; inline;
 
211
    procedure set_qdata(quark: TGQuark; data: gpointer); cdecl; inline;
 
212
    procedure set_qdata_full(quark: TGQuark; data: gpointer; destroy_: TGDestroyNotify); cdecl; inline;
 
213
    //procedure set_valist(first_property_name: Pgchar; var_args: Tva_list); cdecl; inline;
 
214
    function steal_data(key: Pgchar): gpointer; cdecl; inline;
 
215
    function steal_qdata(quark: TGQuark): gpointer; cdecl; inline;
 
216
    procedure thaw_notify; cdecl; inline;
 
217
    procedure unref; cdecl; inline;
 
218
    procedure watch_closure(closure: PGClosure); cdecl; inline;
 
219
    procedure weak_ref(notify: TGWeakNotify; data: gpointer); cdecl; inline;
 
220
    procedure weak_unref(notify: TGWeakNotify; data: gpointer); cdecl; inline;
 
221
  end;
 
222
  TGBinding = object(TGObject)
 
223
    function get_flags: TGBindingFlags; cdecl; inline;
 
224
    function get_source: PGObject; cdecl; inline;
 
225
    function get_source_property: Pgchar; cdecl; inline;
 
226
    function get_target: PGObject; cdecl; inline;
 
227
    function get_target_property: Pgchar; cdecl; inline;
 
228
    property flags: TGBindingFlags read get_flags  { property is writeable but setter not declared } ;
 
229
    property source: PGObject read get_source  { property is writeable but setter not declared } ;
 
230
    property source_property: Pgchar read get_source_property  { property is writeable but setter not declared } ;
 
231
    property target: PGObject read get_target  { property is writeable but setter not declared } ;
 
232
    property target_property: Pgchar read get_target_property  { property is writeable but setter not declared } ;
 
233
  end;
 
234
 
 
235
  PPGValueTransform = ^PGValueTransform;
 
236
  PGValueTransform = ^TGValueTransform;
 
237
  TGValueTransform = procedure(src_value: PGValue; dest_value: PGValue); cdecl;
 
238
 
 
239
  PP_Value__data__union = ^P_Value__data__union;
 
240
  P_Value__data__union = ^T_Value__data__union;
 
241
  T_Value__data__union = record
 
242
    case longint of
 
243
      0 : (v_int: gint);
 
244
      1 : (v_uint: guint);
 
245
      2 : (v_long: glong);
 
246
      3 : (v_ulong: gulong);
 
247
      4 : (v_int64: gint64);
 
248
      5 : (v_uint64: guint64);
 
249
      6 : (v_float: gfloat);
 
250
      7 : (v_double: gdouble);
 
251
      8 : (v_pointer: gpointer);
 
252
  end;
 
253
 
 
254
 
 
255
  TGValue = object
 
256
    g_type: TGType;
 
257
    data: array [0..1] of T_Value__data__union;
 
258
    procedure copy(dest_value: PGValue); cdecl; inline;
 
259
    function dup_boxed: gpointer; cdecl; inline;
 
260
    function dup_object: PGObject; cdecl; inline;
 
261
    function dup_param: PGParamSpec; cdecl; inline;
 
262
    function dup_string: Pgchar; cdecl; inline;
 
263
    function dup_variant: PGVariant; cdecl; inline;
 
264
    function fits_pointer: gboolean; cdecl; inline;
 
265
    function get_boolean: gboolean; cdecl; inline;
 
266
    function get_boxed: gpointer; cdecl; inline;
 
267
    function get_double: gdouble; cdecl; inline;
 
268
    function get_enum: gint; cdecl; inline;
 
269
    function get_flags: guint; cdecl; inline;
 
270
    function get_float: gfloat; cdecl; inline;
 
271
    function get_gtype: TGType; cdecl; inline;
 
272
    function get_int: gint; cdecl; inline;
 
273
    function get_int64: gint64; cdecl; inline;
 
274
    function get_long: glong; cdecl; inline;
 
275
    function get_object: PGObject; cdecl; inline;
 
276
    function get_param: PGParamSpec; cdecl; inline;
 
277
    function get_pointer: gpointer; cdecl; inline;
 
278
    function get_schar: gint8; cdecl; inline;
 
279
    function get_string: Pgchar; cdecl; inline;
 
280
    function get_uchar: guint8; cdecl; inline;
 
281
    function get_uint: guint; cdecl; inline;
 
282
    function get_uint64: guint64; cdecl; inline;
 
283
    function get_ulong: gulong; cdecl; inline;
 
284
    function get_variant: PGVariant; cdecl; inline;
 
285
    function init(g_type: TGType): PGValue; cdecl; inline;
 
286
    function peek_pointer: gpointer; cdecl; inline;
 
287
    function reset: PGValue; cdecl; inline;
 
288
    procedure set_boolean(v_boolean: gboolean); cdecl; inline;
 
289
    procedure set_boxed(v_boxed: gpointer); cdecl; inline;
 
290
    procedure set_double(v_double: gdouble); cdecl; inline;
 
291
    procedure set_enum(v_enum: gint); cdecl; inline;
 
292
    procedure set_flags(v_flags: guint); cdecl; inline;
 
293
    procedure set_float(v_float: gfloat); cdecl; inline;
 
294
    procedure set_gtype(v_gtype: TGType); cdecl; inline;
 
295
    procedure set_instance(instance: gpointer); cdecl; inline;
 
296
    procedure set_int(v_int: gint); cdecl; inline;
 
297
    procedure set_int64(v_int64: gint64); cdecl; inline;
 
298
    procedure set_long(v_long: glong); cdecl; inline;
 
299
    procedure set_object(v_object: PGObject); cdecl; inline;
 
300
    procedure set_param(param: PGParamSpec); cdecl; inline;
 
301
    procedure set_pointer(v_pointer: gpointer); cdecl; inline;
 
302
    procedure set_schar(v_char: gint8); cdecl; inline;
 
303
    procedure set_static_boxed(v_boxed: gpointer); cdecl; inline;
 
304
    procedure set_static_string(v_string: Pgchar); cdecl; inline;
 
305
    procedure set_string(v_string: Pgchar); cdecl; inline;
 
306
    procedure set_uchar(v_uchar: guint8); cdecl; inline;
 
307
    procedure set_uint(v_uint: guint); cdecl; inline;
 
308
    procedure set_uint64(v_uint64: guint64); cdecl; inline;
 
309
    procedure set_ulong(v_ulong: gulong); cdecl; inline;
 
310
    procedure set_variant(variant: PGVariant); cdecl; inline;
 
311
    procedure take_boxed(v_boxed: gpointer); cdecl; inline;
 
312
    procedure take_object(v_object: gpointer); cdecl; inline;
 
313
    procedure take_param(param: PGParamSpec); cdecl; inline;
 
314
    procedure take_string(v_string: Pgchar); cdecl; inline;
 
315
    procedure take_variant(variant: PGVariant); cdecl; inline;
 
316
    function transform(dest_value: PGValue): gboolean; cdecl; inline;
 
317
    procedure unset; cdecl; inline;
 
318
    procedure register_transform_func(src_type: TGType; dest_type: TGType; transform_func: TGValueTransform); cdecl; inline; static;
 
319
    function type_compatible(src_type: TGType; dest_type: TGType): gboolean; cdecl; inline; static;
 
320
    function type_transformable(src_type: TGType; dest_type: TGType): gboolean; cdecl; inline; static;
 
321
  end;
 
322
  TGBoxedCopyFunc = function(boxed: gpointer): gpointer; cdecl;
 
323
  TGBoxedFreeFunc = procedure(boxed: gpointer); cdecl;
 
324
 
 
325
  PPGClosureNotify = ^PGClosureNotify;
 
326
  PGClosureNotify = ^TGClosureNotify;
 
327
  TGClosureNotify = procedure(data: gpointer; closure: PGClosure); cdecl;
 
328
 
 
329
  PPGClosureMarshal = ^PGClosureMarshal;
 
330
  PGClosureMarshal = ^TGClosureMarshal;
 
331
  TGClosureBitfield0 = bitpacked record
 
332
    ref_count: guint15 { changed from guint to accomodate 15 bitsize requirement };
 
333
    meta_marshal_nouse: guint1 { changed from guint to accomodate 1 bitsize requirement };
 
334
    n_guards: guint1 { changed from guint to accomodate 1 bitsize requirement };
 
335
    n_fnotifiers: guint2 { changed from guint to accomodate 2 bitsize requirement };
 
336
    n_inotifiers: guint8 { changed from guint to accomodate 8 bitsize requirement };
 
337
    in_inotify: guint1 { changed from guint to accomodate 1 bitsize requirement };
 
338
    floating: guint1 { changed from guint to accomodate 1 bitsize requirement };
 
339
    derivative_flag: guint1 { changed from guint to accomodate 1 bitsize requirement };
 
340
    in_marshal: guint1 { changed from guint to accomodate 1 bitsize requirement };
 
341
    is_invalid: guint1 { changed from guint to accomodate 1 bitsize requirement };
 
342
  end;
 
343
 
 
344
 
 
345
  PPGClosureNotifyData = ^PGClosureNotifyData;
 
346
  PGClosureNotifyData = ^TGClosureNotifyData;
 
347
  TGClosure = object
 
348
    Bitfield0 : TGClosureBitfield0; { auto generated type }
 
349
    marshal: procedure(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
350
    data: gpointer;
 
351
    notifiers: PGClosureNotifyData;
 
352
    function new_object(sizeof_closure: guint; object_: PGObject): PGClosure; cdecl; inline; static;
 
353
    function new_simple(sizeof_closure: guint; data: gpointer): PGClosure; cdecl; inline; static;
 
354
    procedure add_finalize_notifier(notify_data: gpointer; notify_func: TGClosureNotify); cdecl; inline;
 
355
    procedure add_invalidate_notifier(notify_data: gpointer; notify_func: TGClosureNotify); cdecl; inline;
 
356
    procedure add_marshal_guards(pre_marshal_data: gpointer; pre_marshal_notify: TGClosureNotify; post_marshal_data: gpointer; post_marshal_notify: TGClosureNotify); cdecl; inline;
 
357
    procedure invalidate; cdecl; inline;
 
358
    procedure invoke(return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer); cdecl; inline;
 
359
    function ref: PGClosure; cdecl; inline;
 
360
    procedure remove_finalize_notifier(notify_data: gpointer; notify_func: TGClosureNotify); cdecl; inline;
 
361
    procedure remove_invalidate_notifier(notify_data: gpointer; notify_func: TGClosureNotify); cdecl; inline;
 
362
    procedure set_marshal(marshal: TGClosureMarshal); cdecl; inline;
 
363
    procedure set_meta_marshal(marshal_data: gpointer; meta_marshal: TGClosureMarshal); cdecl; inline;
 
364
    procedure sink; cdecl; inline;
 
365
    procedure unref; cdecl; inline;
 
366
  end;
 
367
  TGCallback = procedure; cdecl;
 
368
 
 
369
  PPGCClosure = ^PGCClosure;
 
370
  PGCClosure = ^TGCClosure;
 
371
 
 
372
  PPGCallback = ^PGCallback;
 
373
  PGCallback = ^TGCallback;
 
374
  TGCClosure = object
 
375
    closure: TGClosure;
 
376
    callback: gpointer;
 
377
    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;
 
378
    //procedure marshal_BOOLEAN__BOXED_BOXEDv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
379
    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;
 
380
    //procedure marshal_BOOLEAN__FLAGSv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
381
    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;
 
382
    //procedure marshal_STRING__OBJECT_POINTERv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
383
    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;
 
384
    //procedure marshal_VOID__BOOLEANv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
385
    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;
 
386
    //procedure marshal_VOID__BOXEDv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
387
    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;
 
388
    //procedure marshal_VOID__CHARv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
389
    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;
 
390
    //procedure marshal_VOID__DOUBLEv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
391
    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;
 
392
    //procedure marshal_VOID__ENUMv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
393
    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;
 
394
    //procedure marshal_VOID__FLAGSv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
395
    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;
 
396
    //procedure marshal_VOID__FLOATv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
397
    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;
 
398
    //procedure marshal_VOID__INTv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
399
    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;
 
400
    //procedure marshal_VOID__LONGv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
401
    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;
 
402
    //procedure marshal_VOID__OBJECTv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
403
    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;
 
404
    //procedure marshal_VOID__PARAMv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
405
    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;
 
406
    //procedure marshal_VOID__POINTERv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
407
    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;
 
408
    //procedure marshal_VOID__STRINGv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
409
    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;
 
410
    //procedure marshal_VOID__UCHARv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
411
    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;
 
412
    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;
 
413
    //procedure marshal_VOID__UINT_POINTERv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
414
    //procedure marshal_VOID__UINTv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
415
    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;
 
416
    //procedure marshal_VOID__ULONGv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
417
    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;
 
418
    //procedure marshal_VOID__VARIANTv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
419
    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;
 
420
    //procedure marshal_VOID__VOIDv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
421
    procedure marshal_generic(closure: PGClosure; return_gvalue: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl; inline; static;
 
422
    //procedure marshal_generic_va(closure: PGClosure; return_value: PGValue; instance: gpointer; args_list: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; inline; static;
 
423
    function new(callback_func: TGCallback; user_data: gpointer; destroy_data: TGClosureNotify): PGClosure; cdecl; inline; static;
 
424
    function new_object(callback_func: TGCallback; object_: PGObject): PGClosure; cdecl; inline; static;
 
425
    function new_object_swap(callback_func: TGCallback; object_: PGObject): PGClosure; cdecl; inline; static;
 
426
    function new_swap(callback_func: TGCallback; user_data: gpointer; destroy_data: TGClosureNotify): PGClosure; cdecl; inline; static;
 
427
  end;
 
428
  TGClassFinalizeFunc = procedure(g_class: gpointer; class_data: gpointer); cdecl;
 
429
  TGClassInitFunc = procedure(g_class: gpointer; class_data: gpointer); cdecl;
 
430
 
 
431
  TGClosureNotifyData = record
 
432
    data: gpointer;
 
433
    notify: TGClosureNotify;
 
434
  end;
 
435
 
 
436
 
 
437
 
 
438
  PPGConnectFlags = ^PGConnectFlags;
 
439
  PGConnectFlags = ^TGConnectFlags;
 
440
  TGTypeClass = object
 
441
    g_type: TGType;
 
442
    function get_private(private_type: TGType): gpointer; cdecl; inline;
 
443
    function peek_parent: PGTypeClass; cdecl; inline;
 
444
    procedure unref; cdecl; inline;
 
445
    procedure unref_uncached; cdecl; inline;
 
446
    procedure add_private(g_class: gpointer; private_size: gsize); cdecl; inline; static;
 
447
    function peek(type_: TGType): PGTypeClass; cdecl; inline; static;
 
448
    function peek_static(type_: TGType): PGTypeClass; cdecl; inline; static;
 
449
    function ref(type_: TGType): PGTypeClass; cdecl; inline; static;
 
450
  end;
 
451
 
 
452
  PPGEnumValue = ^PGEnumValue;
 
453
  PGEnumValue = ^TGEnumValue;
 
454
 
 
455
  TGEnumValue = record
 
456
    value: gint;
 
457
    value_name: Pgchar;
 
458
    value_nick: Pgchar;
 
459
  end;
 
460
 
 
461
 
 
462
 
 
463
  PPGEnumClass = ^PGEnumClass;
 
464
  PGEnumClass = ^TGEnumClass;
 
465
 
 
466
  TGEnumClass = record
 
467
    g_type_class: TGTypeClass;
 
468
    minimum: gint;
 
469
    maximum: gint;
 
470
    n_values: guint;
 
471
    values: PGEnumValue;
 
472
  end;
 
473
 
 
474
 
 
475
 
 
476
  PPGFlagsValue = ^PGFlagsValue;
 
477
  PGFlagsValue = ^TGFlagsValue;
 
478
 
 
479
  TGFlagsValue = record
 
480
    value: guint;
 
481
    value_name: Pgchar;
 
482
    value_nick: Pgchar;
 
483
  end;
 
484
 
 
485
 
 
486
 
 
487
  PPGFlagsClass = ^PGFlagsClass;
 
488
  PGFlagsClass = ^TGFlagsClass;
 
489
 
 
490
  TGFlagsClass = record
 
491
    g_type_class: TGTypeClass;
 
492
    mask: guint;
 
493
    n_values: guint;
 
494
    values: PGFlagsValue;
 
495
  end;
 
496
 
 
497
 
 
498
 
 
499
  PPGInitiallyUnowned = ^PGInitiallyUnowned;
 
500
  PGInitiallyUnowned = ^TGInitiallyUnowned;
 
501
  TGInitiallyUnowned = object(TGObject)
 
502
  end;
 
503
 
 
504
  PPGObjectConstructParam = ^PGObjectConstructParam;
 
505
  PGObjectConstructParam = ^TGObjectConstructParam;
 
506
 
 
507
  TGObjectConstructParam = record
 
508
    pspec: PGParamSpec;
 
509
    value: PGValue;
 
510
  end;
 
511
 
 
512
 
 
513
 
 
514
  PPGParamFlags = ^PGParamFlags;
 
515
  PGParamFlags = ^TGParamFlags;
 
516
  TGParamSpec = object
 
517
    g_type_instance: TGTypeInstance;
 
518
    name: Pgchar;
 
519
    flags: TGParamFlags;
 
520
    value_type: TGType;
 
521
    owner_type: TGType;
 
522
    _nick: Pgchar;
 
523
    _blurb: Pgchar;
 
524
    qdata: PGData;
 
525
    ref_count: guint;
 
526
    param_id: guint;
 
527
    function internal(param_type: TGType; name: Pgchar; nick: Pgchar; blurb: Pgchar; flags: TGParamFlags): gpointer; cdecl; inline; static;
 
528
    function get_blurb: Pgchar; cdecl; inline;
 
529
    function get_name: Pgchar; cdecl; inline;
 
530
    function get_nick: Pgchar; cdecl; inline;
 
531
    function get_qdata(quark: TGQuark): gpointer; cdecl; inline;
 
532
    function get_redirect_target: PGParamSpec; cdecl; inline;
 
533
    function ref: PGParamSpec; cdecl; inline;
 
534
    function ref_sink: PGParamSpec; cdecl; inline;
 
535
    procedure set_qdata(quark: TGQuark; data: gpointer); cdecl; inline;
 
536
    procedure set_qdata_full(quark: TGQuark; data: gpointer; destroy_: TGDestroyNotify); cdecl; inline;
 
537
    procedure sink; cdecl; inline;
 
538
    function steal_qdata(quark: TGQuark): gpointer; cdecl; inline;
 
539
    procedure unref; cdecl; inline;
 
540
  end;
 
541
 
 
542
  PPGInitiallyUnownedClass = ^PGInitiallyUnownedClass;
 
543
  PGInitiallyUnownedClass = ^TGInitiallyUnownedClass;
 
544
  TGInitiallyUnownedClass = object
 
545
    g_type_class: TGTypeClass;
 
546
    construct_properties: PGSList;
 
547
    constructor_: function(type_: TGType; n_construct_properties: guint; construct_properties: PGObjectConstructParam): PGObject; cdecl;
 
548
    set_property: procedure(object_: PGObject; property_id: guint; value: PGValue; pspec: PGParamSpec); cdecl;
 
549
    get_property: procedure(object_: PGObject; property_id: guint; value: PGValue; pspec: PGParamSpec); cdecl;
 
550
    dispose: procedure(object_: PGObject); cdecl;
 
551
    finalize: procedure(object_: PGObject); cdecl;
 
552
    dispatch_properties_changed: procedure(object_: PGObject; n_pspecs: guint; pspecs: PPGParamSpec); cdecl;
 
553
    notify: procedure(object_: PGObject; pspec: PGParamSpec); cdecl;
 
554
    constructed: procedure(object_: PGObject); cdecl;
 
555
    flags: gsize;
 
556
    pdummy: array [0..5] of gpointer;
 
557
  end;
 
558
  TGInstanceInitFunc = procedure(instance: PGTypeInstance; g_class: gpointer); cdecl;
 
559
  TGInterfaceFinalizeFunc = procedure(g_iface: gpointer; iface_data: gpointer); cdecl;
 
560
  TGInterfaceInitFunc = procedure(g_iface: gpointer; iface_data: gpointer); cdecl;
 
561
 
 
562
  PPGInterfaceInfo = ^PGInterfaceInfo;
 
563
  PGInterfaceInfo = ^TGInterfaceInfo;
 
564
 
 
565
  PPGInterfaceInitFunc = ^PGInterfaceInitFunc;
 
566
  PGInterfaceInitFunc = ^TGInterfaceInitFunc;
 
567
 
 
568
  PPGInterfaceFinalizeFunc = ^PGInterfaceFinalizeFunc;
 
569
  PGInterfaceFinalizeFunc = ^TGInterfaceFinalizeFunc;
 
570
 
 
571
  TGInterfaceInfo = record
 
572
    interface_init: TGInterfaceInitFunc;
 
573
    interface_finalize: TGInterfaceFinalizeFunc;
 
574
    interface_data: gpointer;
 
575
  end;
 
576
 
 
577
 
 
578
 
 
579
  TGParameter = record
 
580
    name: Pgchar;
 
581
    value: TGValue;
 
582
  end;
 
583
 
 
584
 
 
585
 
 
586
  PPGObjectClass = ^PGObjectClass;
 
587
  PGObjectClass = ^TGObjectClass;
 
588
  TGObjectClass = object
 
589
    g_type_class: TGTypeClass;
 
590
    construct_properties: PGSList;
 
591
    constructor_: function(type_: TGType; n_construct_properties: guint; construct_properties: PGObjectConstructParam): PGObject; cdecl;
 
592
    set_property: procedure(object_: PGObject; property_id: guint; value: PGValue; pspec: PGParamSpec); cdecl;
 
593
    get_property: procedure(object_: PGObject; property_id: guint; value: PGValue; pspec: PGParamSpec); cdecl;
 
594
    dispose: procedure(object_: PGObject); cdecl;
 
595
    finalize: procedure(object_: PGObject); cdecl;
 
596
    dispatch_properties_changed: procedure(object_: PGObject; n_pspecs: guint; pspecs: PPGParamSpec); cdecl;
 
597
    notify: procedure(object_: PGObject; pspec: PGParamSpec); cdecl;
 
598
    constructed: procedure(object_: PGObject); cdecl;
 
599
    flags: gsize;
 
600
    pdummy: array [0..5] of gpointer;
 
601
    function find_property(property_name: Pgchar): PGParamSpec; cdecl; inline;
 
602
    procedure install_properties(n_pspecs: guint; pspecs: PPGParamSpec); cdecl; inline;
 
603
    procedure install_property(property_id: guint; pspec: PGParamSpec); cdecl; inline;
 
604
    function list_properties(n_properties: Pguint): PPGParamSpec; cdecl; inline;
 
605
    procedure override_property(property_id: guint; name: Pgchar); cdecl; inline;
 
606
  end;
 
607
  TGObjectFinalizeFunc = procedure(object_: PGObject); cdecl;
 
608
  TGObjectGetPropertyFunc = procedure(object_: PGObject; property_id: guint; value: PGValue; pspec: PGParamSpec); cdecl;
 
609
  TGObjectSetPropertyFunc = procedure(object_: PGObject; property_id: guint; value: PGValue; pspec: PGParamSpec); cdecl;
 
610
 
 
611
  PPGParamSpecBoolean = ^PGParamSpecBoolean;
 
612
  PGParamSpecBoolean = ^TGParamSpecBoolean;
 
613
  TGParamSpecBoolean = object(TGParamSpec)
 
614
    default_value: gboolean;
 
615
  end;
 
616
 
 
617
  PPGParamSpecBoxed = ^PGParamSpecBoxed;
 
618
  PGParamSpecBoxed = ^TGParamSpecBoxed;
 
619
  TGParamSpecBoxed = object(TGParamSpec)
 
620
  end;
 
621
 
 
622
  PPGParamSpecChar = ^PGParamSpecChar;
 
623
  PGParamSpecChar = ^TGParamSpecChar;
 
624
  TGParamSpecChar = object(TGParamSpec)
 
625
    minimum: gint8;
 
626
    maximum: gint8;
 
627
    default_value: gint8;
 
628
  end;
 
629
 
 
630
  PPGParamSpecClass = ^PGParamSpecClass;
 
631
  PGParamSpecClass = ^TGParamSpecClass;
 
632
  TGParamSpecClass = object
 
633
    g_type_class: TGTypeClass;
 
634
    value_type: TGType;
 
635
    finalize: procedure(pspec: PGParamSpec); cdecl;
 
636
    value_set_default: procedure(pspec: PGParamSpec; value: PGValue); cdecl;
 
637
    value_validate: function(pspec: PGParamSpec; value: PGValue): gboolean; cdecl;
 
638
    values_cmp: function(pspec: PGParamSpec; value1: PGValue; value2: PGValue): gint; cdecl;
 
639
    dummy: array [0..3] of gpointer;
 
640
  end;
 
641
 
 
642
  PPGParamSpecDouble = ^PGParamSpecDouble;
 
643
  PGParamSpecDouble = ^TGParamSpecDouble;
 
644
  TGParamSpecDouble = object(TGParamSpec)
 
645
    minimum: gdouble;
 
646
    maximum: gdouble;
 
647
    default_value: gdouble;
 
648
    epsilon: gdouble;
 
649
  end;
 
650
 
 
651
  PPGParamSpecEnum = ^PGParamSpecEnum;
 
652
  PGParamSpecEnum = ^TGParamSpecEnum;
 
653
  TGParamSpecEnum = object(TGParamSpec)
 
654
    enum_class: PGEnumClass;
 
655
    default_value: gint;
 
656
  end;
 
657
 
 
658
  PPGParamSpecFlags = ^PGParamSpecFlags;
 
659
  PGParamSpecFlags = ^TGParamSpecFlags;
 
660
  TGParamSpecFlags = object(TGParamSpec)
 
661
    flags_class: PGFlagsClass;
 
662
    default_value: guint;
 
663
  end;
 
664
 
 
665
  PPGParamSpecFloat = ^PGParamSpecFloat;
 
666
  PGParamSpecFloat = ^TGParamSpecFloat;
 
667
  TGParamSpecFloat = object(TGParamSpec)
 
668
    minimum: gfloat;
 
669
    maximum: gfloat;
 
670
    default_value: gfloat;
 
671
    epsilon: gfloat;
 
672
  end;
 
673
 
 
674
  PPGParamSpecGType = ^PGParamSpecGType;
 
675
  PGParamSpecGType = ^TGParamSpecGType;
 
676
  TGParamSpecGType = object(TGParamSpec)
 
677
    is_a_type: TGType;
 
678
  end;
 
679
 
 
680
  PPGParamSpecInt = ^PGParamSpecInt;
 
681
  PGParamSpecInt = ^TGParamSpecInt;
 
682
  TGParamSpecInt = object(TGParamSpec)
 
683
    minimum: gint;
 
684
    maximum: gint;
 
685
    default_value: gint;
 
686
  end;
 
687
 
 
688
  PPGParamSpecInt64 = ^PGParamSpecInt64;
 
689
  PGParamSpecInt64 = ^TGParamSpecInt64;
 
690
  TGParamSpecInt64 = object(TGParamSpec)
 
691
    minimum: gint64;
 
692
    maximum: gint64;
 
693
    default_value: gint64;
 
694
  end;
 
695
 
 
696
  PPGParamSpecLong = ^PGParamSpecLong;
 
697
  PGParamSpecLong = ^TGParamSpecLong;
 
698
  TGParamSpecLong = object(TGParamSpec)
 
699
    minimum: glong;
 
700
    maximum: glong;
 
701
    default_value: glong;
 
702
  end;
 
703
 
 
704
  PPGParamSpecObject = ^PGParamSpecObject;
 
705
  PGParamSpecObject = ^TGParamSpecObject;
 
706
  TGParamSpecObject = object(TGParamSpec)
 
707
  end;
 
708
 
 
709
  PPGParamSpecOverride = ^PGParamSpecOverride;
 
710
  PGParamSpecOverride = ^TGParamSpecOverride;
 
711
  TGParamSpecOverride = object(TGParamSpec)
 
712
    overridden: PGParamSpec;
 
713
  end;
 
714
 
 
715
  PPGParamSpecParam = ^PGParamSpecParam;
 
716
  PGParamSpecParam = ^TGParamSpecParam;
 
717
  TGParamSpecParam = object(TGParamSpec)
 
718
  end;
 
719
 
 
720
  PPGParamSpecPointer = ^PGParamSpecPointer;
 
721
  PGParamSpecPointer = ^TGParamSpecPointer;
 
722
  TGParamSpecPointer = object(TGParamSpec)
 
723
  end;
 
724
 
 
725
  PPGParamSpecPool = ^PGParamSpecPool;
 
726
  PGParamSpecPool = ^TGParamSpecPool;
 
727
  TGParamSpecPool = object
 
728
    procedure insert(pspec: PGParamSpec; owner_type: TGType); cdecl; inline;
 
729
    function list(owner_type: TGType; n_pspecs_p: Pguint): PPGParamSpec; cdecl; inline;
 
730
    function list_owned(owner_type: TGType): PGList; cdecl; inline;
 
731
    function lookup(param_name: Pgchar; owner_type: TGType; walk_ancestors: gboolean): PGParamSpec; cdecl; inline;
 
732
    procedure remove(pspec: PGParamSpec); cdecl; inline;
 
733
    function new(type_prefixing: gboolean): PGParamSpecPool; cdecl; inline; static;
 
734
  end;
 
735
 
 
736
  PPGParamSpecString = ^PGParamSpecString;
 
737
  PGParamSpecString = ^TGParamSpecString;
 
738
  TGParamSpecStringBitfield0 = bitpacked record
 
739
    null_fold_if_empty: guint1 { changed from guint to accomodate 1 bitsize requirement };
 
740
    ensure_non_null: guint1 { changed from guint to accomodate 1 bitsize requirement };
 
741
  end;
 
742
 
 
743
  TGParamSpecString = object(TGParamSpec)
 
744
    default_value: Pgchar;
 
745
    cset_first: Pgchar;
 
746
    cset_nth: Pgchar;
 
747
    substitutor: gchar;
 
748
    Bitfield0 : TGParamSpecStringBitfield0; { auto generated type }
 
749
  end;
 
750
 
 
751
  PPGParamSpecTypeInfo = ^PGParamSpecTypeInfo;
 
752
  PGParamSpecTypeInfo = ^TGParamSpecTypeInfo;
 
753
 
 
754
  TGParamSpecTypeInfo = record
 
755
    instance_size: guint16;
 
756
    n_preallocs: guint16;
 
757
    instance_init: procedure(pspec: PGParamSpec); cdecl;
 
758
    value_type: TGType;
 
759
    finalize: procedure(pspec: PGParamSpec); cdecl;
 
760
    value_set_default: procedure(pspec: PGParamSpec; value: PGValue); cdecl;
 
761
    value_validate: function(pspec: PGParamSpec; value: PGValue): gboolean; cdecl;
 
762
    values_cmp: function(pspec: PGParamSpec; value1: PGValue; value2: PGValue): gint; cdecl;
 
763
  end;
 
764
 
 
765
 
 
766
 
 
767
  PPGParamSpecUChar = ^PGParamSpecUChar;
 
768
  PGParamSpecUChar = ^TGParamSpecUChar;
 
769
  TGParamSpecUChar = object(TGParamSpec)
 
770
    minimum: guint8;
 
771
    maximum: guint8;
 
772
    default_value: guint8;
 
773
  end;
 
774
 
 
775
  PPGParamSpecUInt = ^PGParamSpecUInt;
 
776
  PGParamSpecUInt = ^TGParamSpecUInt;
 
777
  TGParamSpecUInt = object(TGParamSpec)
 
778
    minimum: guint;
 
779
    maximum: guint;
 
780
    default_value: guint;
 
781
  end;
 
782
 
 
783
  PPGParamSpecUInt64 = ^PGParamSpecUInt64;
 
784
  PGParamSpecUInt64 = ^TGParamSpecUInt64;
 
785
  TGParamSpecUInt64 = object(TGParamSpec)
 
786
    minimum: guint64;
 
787
    maximum: guint64;
 
788
    default_value: guint64;
 
789
  end;
 
790
 
 
791
  PPGParamSpecULong = ^PGParamSpecULong;
 
792
  PGParamSpecULong = ^TGParamSpecULong;
 
793
  TGParamSpecULong = object(TGParamSpec)
 
794
    minimum: gulong;
 
795
    maximum: gulong;
 
796
    default_value: gulong;
 
797
  end;
 
798
 
 
799
  PPGParamSpecUnichar = ^PGParamSpecUnichar;
 
800
  PGParamSpecUnichar = ^TGParamSpecUnichar;
 
801
  TGParamSpecUnichar = object(TGParamSpec)
 
802
    default_value: gunichar;
 
803
  end;
 
804
 
 
805
  PPGParamSpecValueArray = ^PGParamSpecValueArray;
 
806
  PGParamSpecValueArray = ^TGParamSpecValueArray;
 
807
  TGParamSpecValueArray = object(TGParamSpec)
 
808
    element_spec: PGParamSpec;
 
809
    fixed_n_elements: guint;
 
810
  end;
 
811
 
 
812
  PPGParamSpecVariant = ^PGParamSpecVariant;
 
813
  PGParamSpecVariant = ^TGParamSpecVariant;
 
814
  TGParamSpecVariant = object(TGParamSpec)
 
815
    type_: PGVariantType;
 
816
    default_value: PGVariant;
 
817
    padding: array [0..3] of gpointer;
 
818
  end;
 
819
 
 
820
  PPGSignalInvocationHint = ^PGSignalInvocationHint;
 
821
  PGSignalInvocationHint = ^TGSignalInvocationHint;
 
822
 
 
823
  PPGSignalFlags = ^PGSignalFlags;
 
824
  PGSignalFlags = ^TGSignalFlags;
 
825
 
 
826
  TGSignalInvocationHint = record
 
827
    signal_id: guint;
 
828
    detail: TGQuark;
 
829
    run_type: TGSignalFlags;
 
830
  end;
 
831
 
 
832
 
 
833
  TGSignalAccumulator = function(ihint: PGSignalInvocationHint; return_accu: PGValue; handler_return: PGValue; data: gpointer): gboolean; cdecl;
 
834
  TGSignalEmissionHook = function(ihint: PGSignalInvocationHint; n_param_values: guint; param_values: PGValue; data: gpointer): gboolean; cdecl;
 
835
 
 
836
  PPGSignalMatchType = ^PGSignalMatchType;
 
837
  PGSignalMatchType = ^TGSignalMatchType;
 
838
 
 
839
  PPGSignalQuery = ^PGSignalQuery;
 
840
  PGSignalQuery = ^TGSignalQuery;
 
841
 
 
842
  TGSignalQuery = record
 
843
    signal_id: guint;
 
844
    signal_name: Pgchar;
 
845
    itype: TGType;
 
846
    signal_flags: TGSignalFlags;
 
847
    return_type: TGType;
 
848
    n_params: guint;
 
849
    param_types: PGType;
 
850
  end;
 
851
 
 
852
 
 
853
  TGTypeCValue = record
 
854
    case longint of
 
855
      0 : (v_int: gint);
 
856
      1 : (v_long: glong);
 
857
      2 : (v_int64: gint64);
 
858
      3 : (v_double: gdouble);
 
859
      4 : (v_pointer: gpointer);
 
860
  end;
 
861
 
 
862
 
 
863
  TGTypeClassCacheFunc = function(cache_data: gpointer; g_class: PGTypeClass): gboolean; cdecl;
 
864
 
 
865
  PPGTypeDebugFlags = ^PGTypeDebugFlags;
 
866
  PGTypeDebugFlags = ^TGTypeDebugFlags;
 
867
 
 
868
  PPGTypeFlags = ^PGTypeFlags;
 
869
  PGTypeFlags = ^TGTypeFlags;
 
870
 
 
871
  PPGTypeFundamentalFlags = ^PGTypeFundamentalFlags;
 
872
  PGTypeFundamentalFlags = ^TGTypeFundamentalFlags;
 
873
 
 
874
  PPGTypeFundamentalInfo = ^PGTypeFundamentalInfo;
 
875
  PGTypeFundamentalInfo = ^TGTypeFundamentalInfo;
 
876
 
 
877
  TGTypeFundamentalInfo = record
 
878
    type_flags: TGTypeFundamentalFlags;
 
879
  end;
 
880
 
 
881
 
 
882
 
 
883
  PPGTypeValueTable = ^PGTypeValueTable;
 
884
  PGTypeValueTable = ^TGTypeValueTable;
 
885
 
 
886
  PPGTypeCValue = ^PGTypeCValue;
 
887
  PGTypeCValue = ^TGTypeCValue;
 
888
  TGTypeValueTable = object
 
889
    value_init: procedure(value: PGValue); cdecl;
 
890
    value_free: procedure(value: PGValue); cdecl;
 
891
    value_copy: procedure(src_value: PGValue; dest_value: PGValue); cdecl;
 
892
    value_peek_pointer: function(value: PGValue): gpointer; cdecl;
 
893
    collect_format: Pgchar;
 
894
    collect_value: function(value: PGValue; n_collect_values: guint; collect_values: PGTypeCValue; collect_flags: guint): Pgchar; cdecl;
 
895
    lcopy_format: Pgchar;
 
896
    lcopy_value: function(value: PGValue; n_collect_values: guint; collect_values: PGTypeCValue; collect_flags: guint): Pgchar; cdecl;
 
897
    function peek(type_: TGType): PGTypeValueTable; cdecl; inline; static;
 
898
  end;
 
899
 
 
900
  PPGTypeInfo = ^PGTypeInfo;
 
901
  PGTypeInfo = ^TGTypeInfo;
 
902
 
 
903
  PPGBaseInitFunc = ^PGBaseInitFunc;
 
904
  PGBaseInitFunc = ^TGBaseInitFunc;
 
905
 
 
906
  PPGBaseFinalizeFunc = ^PGBaseFinalizeFunc;
 
907
  PGBaseFinalizeFunc = ^TGBaseFinalizeFunc;
 
908
 
 
909
  PPGClassInitFunc = ^PGClassInitFunc;
 
910
  PGClassInitFunc = ^TGClassInitFunc;
 
911
 
 
912
  PPGClassFinalizeFunc = ^PGClassFinalizeFunc;
 
913
  PGClassFinalizeFunc = ^TGClassFinalizeFunc;
 
914
 
 
915
  PPGInstanceInitFunc = ^PGInstanceInitFunc;
 
916
  PGInstanceInitFunc = ^TGInstanceInitFunc;
 
917
 
 
918
  TGTypeInfo = record
 
919
    class_size: guint16;
 
920
    base_init: TGBaseInitFunc;
 
921
    base_finalize: TGBaseFinalizeFunc;
 
922
    class_init: TGClassInitFunc;
 
923
    class_finalize: TGClassFinalizeFunc;
 
924
    class_data: gpointer;
 
925
    instance_size: guint16;
 
926
    n_preallocs: guint16;
 
927
    instance_init: TGInstanceInitFunc;
 
928
    value_table: PGTypeValueTable;
 
929
  end;
 
930
 
 
931
 
 
932
 
 
933
  PPGTypeInterface = ^PGTypeInterface;
 
934
  PGTypeInterface = ^TGTypeInterface;
 
935
 
 
936
  PPGTypePlugin = ^PGTypePlugin;
 
937
  PGTypePlugin = ^TGTypePlugin;
 
938
  TGTypeInterface = object
 
939
    g_type: TGType;
 
940
    g_instance_type: TGType;
 
941
    function peek_parent: PGTypeInterface; cdecl; inline;
 
942
    procedure add_prerequisite(interface_type: TGType; prerequisite_type: TGType); cdecl; inline; static;
 
943
    function get_plugin(instance_type: TGType; interface_type: TGType): PGTypePlugin; cdecl; inline; static;
 
944
    function peek(instance_class: PGTypeClass; iface_type: TGType): PGTypeInterface; cdecl; inline; static;
 
945
    function prerequisites(interface_type: TGType; n_prerequisites: Pguint): PGType; cdecl; inline; static;
 
946
  end;
 
947
  TGTypePlugin = object
 
948
    procedure complete_interface_info(instance_type: TGType; interface_type: TGType; info: PGInterfaceInfo); cdecl; inline;
 
949
    procedure complete_type_info(g_type: TGType; info: PGTypeInfo; value_table: PGTypeValueTable); cdecl; inline;
 
950
    procedure unuse; cdecl; inline;
 
951
    procedure use; cdecl; inline;
 
952
  end;
 
953
  TGTypeInterfaceCheckFunc = procedure(check_data: gpointer; g_iface: gpointer); cdecl;
 
954
 
 
955
  PPGTypeModule = ^PGTypeModule;
 
956
  PGTypeModule = ^TGTypeModule;
 
957
  TGTypeModule = object(TGObject)
 
958
    use_count: guint;
 
959
    type_infos: PGSList;
 
960
    interface_infos: PGSList;
 
961
    name: Pgchar;
 
962
    procedure add_interface(instance_type: TGType; interface_type: TGType; interface_info: PGInterfaceInfo); cdecl; inline;
 
963
    function register_enum(name: Pgchar; const_static_values: PGEnumValue): TGType; cdecl; inline;
 
964
    function register_flags(name: Pgchar; const_static_values: PGFlagsValue): TGType; cdecl; inline;
 
965
    function register_type(parent_type: TGType; type_name: Pgchar; type_info: PGTypeInfo; flags: TGTypeFlags): TGType; cdecl; inline;
 
966
    procedure set_name(name: Pgchar); cdecl; inline;
 
967
    procedure unuse; cdecl; inline;
 
968
    function use: gboolean; cdecl; inline;
 
969
  end;
 
970
 
 
971
  PPGTypeModuleClass = ^PGTypeModuleClass;
 
972
  PGTypeModuleClass = ^TGTypeModuleClass;
 
973
  TGTypeModuleClass = object
 
974
    parent_class: TGObjectClass;
 
975
    load: function(module: PGTypeModule): gboolean; cdecl;
 
976
    unload: procedure(module: PGTypeModule); cdecl;
 
977
    reserved1: procedure; cdecl;
 
978
    reserved2: procedure; cdecl;
 
979
    reserved3: procedure; cdecl;
 
980
    reserved4: procedure; cdecl;
 
981
  end;
 
982
  TGTypePluginUse = procedure(plugin: PGTypePlugin); cdecl;
 
983
  TGTypePluginUnuse = procedure(plugin: PGTypePlugin); cdecl;
 
984
  TGTypePluginCompleteTypeInfo = procedure(plugin: PGTypePlugin; g_type: TGType; info: PGTypeInfo; value_table: PGTypeValueTable); cdecl;
 
985
  TGTypePluginCompleteInterfaceInfo = procedure(plugin: PGTypePlugin; instance_type: TGType; interface_type: TGType; info: PGInterfaceInfo); cdecl;
 
986
 
 
987
  PPGTypePluginClass = ^PGTypePluginClass;
 
988
  PGTypePluginClass = ^TGTypePluginClass;
 
989
 
 
990
  PPGTypePluginUse = ^PGTypePluginUse;
 
991
  PGTypePluginUse = ^TGTypePluginUse;
 
992
 
 
993
  PPGTypePluginUnuse = ^PGTypePluginUnuse;
 
994
  PGTypePluginUnuse = ^TGTypePluginUnuse;
 
995
 
 
996
  PPGTypePluginCompleteTypeInfo = ^PGTypePluginCompleteTypeInfo;
 
997
  PGTypePluginCompleteTypeInfo = ^TGTypePluginCompleteTypeInfo;
 
998
 
 
999
  PPGTypePluginCompleteInterfaceInfo = ^PGTypePluginCompleteInterfaceInfo;
 
1000
  PGTypePluginCompleteInterfaceInfo = ^TGTypePluginCompleteInterfaceInfo;
 
1001
 
 
1002
  TGTypePluginClass = record
 
1003
    base_iface: TGTypeInterface;
 
1004
    use_plugin: TGTypePluginUse;
 
1005
    unuse_plugin: TGTypePluginUnuse;
 
1006
    complete_type_info: TGTypePluginCompleteTypeInfo;
 
1007
    complete_interface_info: TGTypePluginCompleteInterfaceInfo;
 
1008
  end;
 
1009
 
 
1010
 
 
1011
 
 
1012
  PPGTypeQuery = ^PGTypeQuery;
 
1013
  PGTypeQuery = ^TGTypeQuery;
 
1014
 
 
1015
  TGTypeQuery = record
 
1016
    type_: TGType;
 
1017
    type_name: Pgchar;
 
1018
    class_size: guint;
 
1019
    instance_size: guint;
 
1020
  end;
 
1021
 
 
1022
 
 
1023
 
 
1024
  PPGValueArray = ^PGValueArray;
 
1025
  PGValueArray = ^TGValueArray;
 
1026
  TGValueArray = object
 
1027
    n_values: guint;
 
1028
    values: PGValue;
 
1029
    n_prealloced: guint;
 
1030
  end;
 
1031
 
 
1032
  PPGWeakRef = ^PGWeakRef;
 
1033
  PGWeakRef = ^TGWeakRef;
 
1034
  TGWeakRef_union_priv = record
 
1035
    case longint of
 
1036
      0 : (p: gpointer);
 
1037
  end;
 
1038
 
 
1039
 
 
1040
  TGWeakRef = object
 
1041
    priv: TGWeakRef_union_priv; //union extracted from object and named 'TGWeakRef_union_priv'
 
1042
    procedure clear; cdecl; inline;
 
1043
    function get: PGObject; cdecl; inline;
 
1044
    procedure init(object_: gpointer); cdecl; inline;
 
1045
    procedure set_(object_: gpointer); cdecl; inline;
 
1046
  end;
 
1047
 
 
1048
function g_binding_get_flags(ABinding: PGBinding): TGBindingFlags; cdecl; external;
 
1049
function g_binding_get_source(ABinding: PGBinding): PGObject; cdecl; external;
 
1050
function g_binding_get_source_property(ABinding: PGBinding): Pgchar; cdecl; external;
 
1051
function g_binding_get_target(ABinding: PGBinding): PGObject; cdecl; external;
 
1052
function g_binding_get_target_property(ABinding: PGBinding): Pgchar; cdecl; external;
 
1053
function g_binding_get_type: TGType; cdecl; external;
 
1054
function g_boxed_copy(boxed_type: TGType; src_boxed: gpointer): gpointer; cdecl; external;
 
1055
function g_boxed_type_register_static(name: Pgchar; boxed_copy: TGBoxedCopyFunc; boxed_free: TGBoxedFreeFunc): TGType; cdecl; external;
 
1056
function g_cclosure_new(callback_func: TGCallback; user_data: gpointer; destroy_data: TGClosureNotify): PGClosure; cdecl; external;
 
1057
function g_cclosure_new_object(callback_func: TGCallback; object_: PGObject): PGClosure; cdecl; external;
 
1058
function g_cclosure_new_object_swap(callback_func: TGCallback; object_: PGObject): PGClosure; cdecl; external;
 
1059
function g_cclosure_new_swap(callback_func: TGCallback; user_data: gpointer; destroy_data: TGClosureNotify): PGClosure; cdecl; external;
 
1060
function g_closure_get_type: TGType; cdecl; external;
 
1061
function g_closure_new_object(sizeof_closure: guint; object_: PGObject): PGClosure; cdecl; external;
 
1062
function g_closure_new_simple(sizeof_closure: guint; data: gpointer): PGClosure; cdecl; external;
 
1063
function g_closure_ref(AClosure: PGClosure): PGClosure; cdecl; external;
 
1064
function g_enum_get_value(enum_class: PGEnumClass; value: gint): PGEnumValue; cdecl; external;
 
1065
function g_enum_get_value_by_name(enum_class: PGEnumClass; name: Pgchar): PGEnumValue; cdecl; external;
 
1066
function g_enum_get_value_by_nick(enum_class: PGEnumClass; nick: Pgchar): PGEnumValue; cdecl; external;
 
1067
function g_enum_register_static(name: Pgchar; const_static_values: PGEnumValue): TGType; cdecl; external;
 
1068
function g_flags_get_first_value(flags_class: PGFlagsClass; value: guint): PGFlagsValue; cdecl; external;
 
1069
function g_flags_get_value_by_name(flags_class: PGFlagsClass; name: Pgchar): PGFlagsValue; cdecl; external;
 
1070
function g_flags_get_value_by_nick(flags_class: PGFlagsClass; nick: Pgchar): PGFlagsValue; cdecl; external;
 
1071
function g_flags_register_static(name: Pgchar; const_static_values: PGFlagsValue): TGType; cdecl; external;
 
1072
function g_gtype_get_type: TGType; cdecl; external;
 
1073
function g_initially_unowned_get_type: TGType; cdecl; external;
 
1074
function g_object_bind_property(AObject: PGObject; source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags): PGBinding; cdecl; external;
 
1075
function g_object_bind_property_full(AObject: 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;
 
1076
function g_object_bind_property_with_closures(AObject: PGObject; source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags; transform_to: PGClosure; transform_from: PGClosure): PGBinding; cdecl; external;
 
1077
function g_object_class_find_property(AObjectClass: PGObjectClass; property_name: Pgchar): PGParamSpec; cdecl; external;
 
1078
function g_object_class_list_properties(AObjectClass: PGObjectClass; n_properties: Pguint): PPGParamSpec; cdecl; external;
 
1079
function g_object_compat_control(what: gsize; data: gpointer): gsize; cdecl; external;
 
1080
function g_object_connect(object_: gpointer; signal_spec: Pgchar; args: array of const): gpointer; cdecl; external;
 
1081
function g_object_get_data(AObject: PGObject; key: Pgchar): gpointer; cdecl; external;
 
1082
function g_object_get_qdata(AObject: PGObject; quark: TGQuark): gpointer; cdecl; external;
 
1083
function g_object_get_type: TGType; cdecl; external;
 
1084
function g_object_interface_find_property(g_iface: gpointer; property_name: Pgchar): PGParamSpec; cdecl; external;
 
1085
function g_object_interface_list_properties(g_iface: gpointer; n_properties_p: Pguint): PPGParamSpec; cdecl; external;
 
1086
function g_object_is_floating(AObject: PGObject): gboolean; cdecl; external;
 
1087
function g_object_new(object_type: TGType; first_property_name: Pgchar; args: array of const): gpointer; cdecl; external;
 
1088
function g_object_new_valist(object_type: TGType; first_property_name: Pgchar; var_args: Tva_list): PGObject; cdecl; external;
 
1089
function g_object_newv(object_type: TGType; n_parameters: guint; parameters: PGParameter): PGObject; cdecl; external;
 
1090
function g_object_ref(AObject: PGObject): PGObject; cdecl; external;
 
1091
function g_object_ref_sink(AObject: PGObject): PGObject; cdecl; external;
 
1092
function g_object_steal_data(AObject: PGObject; key: Pgchar): gpointer; cdecl; external;
 
1093
function g_object_steal_qdata(AObject: PGObject; quark: TGQuark): gpointer; cdecl; external;
 
1094
function g_param_spec_boolean(name: Pgchar; nick: Pgchar; blurb: Pgchar; default_value: gboolean; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1095
function g_param_spec_boxed(name: Pgchar; nick: Pgchar; blurb: Pgchar; boxed_type: TGType; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1096
function g_param_spec_char(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: gint8; maximum: gint8; default_value: gint8; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1097
function g_param_spec_double(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: gdouble; maximum: gdouble; default_value: gdouble; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1098
function g_param_spec_enum(name: Pgchar; nick: Pgchar; blurb: Pgchar; enum_type: TGType; default_value: gint; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1099
function g_param_spec_flags(name: Pgchar; nick: Pgchar; blurb: Pgchar; flags_type: TGType; default_value: guint; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1100
function g_param_spec_float(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: gfloat; maximum: gfloat; default_value: gfloat; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1101
function g_param_spec_get_blurb(AParamSpec: PGParamSpec): Pgchar; cdecl; external;
 
1102
function g_param_spec_get_name(AParamSpec: PGParamSpec): Pgchar; cdecl; external;
 
1103
function g_param_spec_get_nick(AParamSpec: PGParamSpec): Pgchar; cdecl; external;
 
1104
function g_param_spec_get_qdata(AParamSpec: PGParamSpec; quark: TGQuark): gpointer; cdecl; external;
 
1105
function g_param_spec_get_redirect_target(AParamSpec: PGParamSpec): PGParamSpec; cdecl; external;
 
1106
function g_param_spec_gtype(name: Pgchar; nick: Pgchar; blurb: Pgchar; is_a_type: TGType; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1107
function g_param_spec_int(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: gint; maximum: gint; default_value: gint; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1108
function g_param_spec_int64(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: gint64; maximum: gint64; default_value: gint64; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1109
function g_param_spec_internal(param_type: TGType; name: Pgchar; nick: Pgchar; blurb: Pgchar; flags: TGParamFlags): gpointer; cdecl; external;
 
1110
function g_param_spec_long(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: glong; maximum: glong; default_value: glong; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1111
function g_param_spec_object(name: Pgchar; nick: Pgchar; blurb: Pgchar; object_type: TGType; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1112
function g_param_spec_override(name: Pgchar; overridden: PGParamSpec): PGParamSpec; cdecl; external;
 
1113
function g_param_spec_param(name: Pgchar; nick: Pgchar; blurb: Pgchar; param_type: TGType; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1114
function g_param_spec_pointer(name: Pgchar; nick: Pgchar; blurb: Pgchar; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1115
function g_param_spec_pool_list(AParamSpecPool: PGParamSpecPool; owner_type: TGType; n_pspecs_p: Pguint): PPGParamSpec; cdecl; external;
 
1116
function g_param_spec_pool_list_owned(AParamSpecPool: PGParamSpecPool; owner_type: TGType): PGList; cdecl; external;
 
1117
function g_param_spec_pool_lookup(AParamSpecPool: PGParamSpecPool; param_name: Pgchar; owner_type: TGType; walk_ancestors: gboolean): PGParamSpec; cdecl; external;
 
1118
function g_param_spec_pool_new(type_prefixing: gboolean): PGParamSpecPool; cdecl; external;
 
1119
function g_param_spec_ref(AParamSpec: PGParamSpec): PGParamSpec; cdecl; external;
 
1120
function g_param_spec_ref_sink(AParamSpec: PGParamSpec): PGParamSpec; cdecl; external;
 
1121
function g_param_spec_steal_qdata(AParamSpec: PGParamSpec; quark: TGQuark): gpointer; cdecl; external;
 
1122
function g_param_spec_string(name: Pgchar; nick: Pgchar; blurb: Pgchar; default_value: Pgchar; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1123
function g_param_spec_uchar(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: guint8; maximum: guint8; default_value: guint8; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1124
function g_param_spec_uint(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: guint; maximum: guint; default_value: guint; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1125
function g_param_spec_uint64(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: guint64; maximum: guint64; default_value: guint64; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1126
function g_param_spec_ulong(name: Pgchar; nick: Pgchar; blurb: Pgchar; minimum: gulong; maximum: gulong; default_value: gulong; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1127
function g_param_spec_unichar(name: Pgchar; nick: Pgchar; blurb: Pgchar; default_value: gunichar; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1128
function g_param_spec_value_array(name: Pgchar; nick: Pgchar; blurb: Pgchar; element_spec: PGParamSpec; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1129
function g_param_spec_variant(name: Pgchar; nick: Pgchar; blurb: Pgchar; type_: PGVariantType; default_value: PGVariant; flags: TGParamFlags): PGParamSpec; cdecl; external;
 
1130
function g_param_type_register_static(name: Pgchar; pspec_info: PGParamSpecTypeInfo): TGType; cdecl; external;
 
1131
function g_param_value_convert(pspec: PGParamSpec; src_value: PGValue; dest_value: PGValue; strict_validation: gboolean): gboolean; cdecl; external;
 
1132
function g_param_value_defaults(pspec: PGParamSpec; value: PGValue): gboolean; cdecl; external;
 
1133
function g_param_value_validate(pspec: PGParamSpec; value: PGValue): gboolean; cdecl; external;
 
1134
function g_param_values_cmp(pspec: PGParamSpec; value1: PGValue; value2: PGValue): gint; cdecl; external;
 
1135
function g_pointer_type_register_static(name: Pgchar): TGType; cdecl; external;
 
1136
function g_signal_accumulator_first_wins(ihint: PGSignalInvocationHint; return_accu: PGValue; handler_return: PGValue; dummy: gpointer): gboolean; cdecl; external;
 
1137
function g_signal_accumulator_true_handled(ihint: PGSignalInvocationHint; return_accu: PGValue; handler_return: PGValue; dummy: gpointer): gboolean; cdecl; external;
 
1138
function g_signal_add_emission_hook(signal_id: guint; detail: TGQuark; hook_func: TGSignalEmissionHook; hook_data: gpointer; data_destroy: TGDestroyNotify): gulong; cdecl; external;
 
1139
function g_signal_connect_closure(instance: gpointer; detailed_signal: Pgchar; closure: PGClosure; after: gboolean): gulong; cdecl; external;
 
1140
function g_signal_connect_closure_by_id(instance: gpointer; signal_id: guint; detail: TGQuark; closure: PGClosure; after: gboolean): gulong; cdecl; external;
 
1141
function g_signal_connect_data(instance: gpointer; detailed_signal: Pgchar; c_handler: TGCallback; data: gpointer; destroy_data: TGClosureNotify; connect_flags: TGConnectFlags): gulong; cdecl; external;
 
1142
function g_signal_connect_object(instance: gpointer; detailed_signal: Pgchar; c_handler: TGCallback; gobject: gpointer; connect_flags: TGConnectFlags): gulong; cdecl; external;
 
1143
function g_signal_get_invocation_hint(instance: gpointer): PGSignalInvocationHint; cdecl; external;
 
1144
function g_signal_handler_find(instance: gpointer; mask: TGSignalMatchType; signal_id: guint; detail: TGQuark; closure: PGClosure; func: gpointer; data: gpointer): gulong; cdecl; external;
 
1145
function g_signal_handler_is_connected(instance: gpointer; handler_id: gulong): gboolean; cdecl; external;
 
1146
function g_signal_handlers_block_matched(instance: gpointer; mask: TGSignalMatchType; signal_id: guint; detail: TGQuark; closure: PGClosure; func: gpointer; data: gpointer): guint; cdecl; external;
 
1147
function g_signal_handlers_disconnect_matched(instance: gpointer; mask: TGSignalMatchType; signal_id: guint; detail: TGQuark; closure: PGClosure; func: gpointer; data: gpointer): guint; cdecl; external;
 
1148
function g_signal_handlers_unblock_matched(instance: gpointer; mask: TGSignalMatchType; signal_id: guint; detail: TGQuark; closure: PGClosure; func: gpointer; data: gpointer): guint; cdecl; external;
 
1149
function g_signal_has_handler_pending(instance: gpointer; signal_id: guint; detail: TGQuark; may_be_blocked: gboolean): gboolean; cdecl; external;
 
1150
function g_signal_list_ids(itype: TGType; n_ids: Pguint): Pguint; cdecl; external;
 
1151
function g_signal_lookup(name: Pgchar; itype: TGType): guint; cdecl; external;
 
1152
function g_signal_name(signal_id: guint): Pgchar; cdecl; external;
 
1153
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;
 
1154
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;
 
1155
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;
 
1156
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;
 
1157
function g_signal_parse_name(detailed_signal: Pgchar; itype: TGType; signal_id_p: Pguint; detail_p: PGQuark; force_detail_quark: gboolean): gboolean; cdecl; external;
 
1158
function g_signal_type_cclosure_new(itype: TGType; struct_offset: guint): PGClosure; cdecl; external;
 
1159
function g_strdup_value_contents(value: PGValue): Pgchar; cdecl; external;
 
1160
function g_type_check_class_cast(g_class: PGTypeClass; is_a_type: TGType): PGTypeClass; cdecl; external;
 
1161
function g_type_check_class_is_a(g_class: PGTypeClass; is_a_type: TGType): gboolean; cdecl; external;
 
1162
function g_type_check_instance(instance: PGTypeInstance): gboolean; cdecl; external;
 
1163
function g_type_check_instance_cast(instance: PGTypeInstance; iface_type: TGType): PGTypeInstance; cdecl; external;
 
1164
function g_type_check_instance_is_a(instance: PGTypeInstance; iface_type: TGType): gboolean; cdecl; external;
 
1165
function g_type_check_is_value_type(type_: TGType): gboolean; cdecl; external;
 
1166
function g_type_check_value(value: PGValue): gboolean; cdecl; external;
 
1167
function g_type_check_value_holds(value: PGValue; type_: TGType): gboolean; cdecl; external;
 
1168
function g_type_children(type_: TGType; n_children: Pguint): PGType; cdecl; external;
 
1169
function g_type_class_get_private(ATypeClass: PGTypeClass; private_type: TGType): gpointer; cdecl; external;
 
1170
function g_type_class_peek(type_: TGType): PGTypeClass; cdecl; external;
 
1171
function g_type_class_peek_parent(ATypeClass: PGTypeClass): PGTypeClass; cdecl; external;
 
1172
function g_type_class_peek_static(type_: TGType): PGTypeClass; cdecl; external;
 
1173
function g_type_class_ref(type_: TGType): PGTypeClass; cdecl; external;
 
1174
function g_type_create_instance(type_: TGType): PGTypeInstance; cdecl; external;
 
1175
function g_type_default_interface_peek(g_type: TGType): PGTypeInterface; cdecl; external;
 
1176
function g_type_default_interface_ref(g_type: TGType): PGTypeInterface; cdecl; external;
 
1177
function g_type_depth(type_: TGType): guint; cdecl; external;
 
1178
function g_type_from_name(name: Pgchar): TGType; cdecl; external;
 
1179
function g_type_fundamental(type_id: TGType): TGType; cdecl; external;
 
1180
function g_type_fundamental_next: TGType; cdecl; external;
 
1181
function g_type_get_plugin(type_: TGType): PGTypePlugin; cdecl; external;
 
1182
function g_type_get_qdata(type_: TGType; quark: TGQuark): gpointer; cdecl; external;
 
1183
function g_type_instance_get_private(ATypeInstance: PGTypeInstance; private_type: TGType): gpointer; cdecl; external;
 
1184
function g_type_interface_get_plugin(instance_type: TGType; interface_type: TGType): PGTypePlugin; cdecl; external;
 
1185
function g_type_interface_peek(instance_class: PGTypeClass; iface_type: TGType): PGTypeInterface; cdecl; external;
 
1186
function g_type_interface_peek_parent(ATypeInterface: PGTypeInterface): PGTypeInterface; cdecl; external;
 
1187
function g_type_interface_prerequisites(interface_type: TGType; n_prerequisites: Pguint): PGType; cdecl; external;
 
1188
function g_type_interfaces(type_: TGType; n_interfaces: Pguint): PGType; cdecl; external;
 
1189
function g_type_is_a(type_: TGType; is_a_type: TGType): gboolean; cdecl; external;
 
1190
function g_type_module_get_type: TGType; cdecl; external;
 
1191
function g_type_module_register_enum(ATypeModule: PGTypeModule; name: Pgchar; const_static_values: PGEnumValue): TGType; cdecl; external;
 
1192
function g_type_module_register_flags(ATypeModule: PGTypeModule; name: Pgchar; const_static_values: PGFlagsValue): TGType; cdecl; external;
 
1193
function g_type_module_register_type(ATypeModule: PGTypeModule; parent_type: TGType; type_name: Pgchar; type_info: PGTypeInfo; flags: TGTypeFlags): TGType; cdecl; external;
 
1194
function g_type_module_use(ATypeModule: PGTypeModule): gboolean; cdecl; external;
 
1195
function g_type_name(type_: TGType): Pgchar; cdecl; external;
 
1196
function g_type_name_from_class(g_class: PGTypeClass): Pgchar; cdecl; external;
 
1197
function g_type_name_from_instance(instance: PGTypeInstance): Pgchar; cdecl; external;
 
1198
function g_type_next_base(leaf_type: TGType; root_type: TGType): TGType; cdecl; external;
 
1199
function g_type_parent(type_: TGType): TGType; cdecl; external;
 
1200
function g_type_plugin_get_type: TGType; cdecl; external;
 
1201
function g_type_qname(type_: TGType): TGQuark; cdecl; external;
 
1202
function g_type_register_dynamic(parent_type: TGType; type_name: Pgchar; plugin: PGTypePlugin; flags: TGTypeFlags): TGType; cdecl; external;
 
1203
function g_type_register_fundamental(type_id: TGType; type_name: Pgchar; info: PGTypeInfo; finfo: PGTypeFundamentalInfo; flags: TGTypeFlags): TGType; cdecl; external;
 
1204
function g_type_register_static(parent_type: TGType; type_name: Pgchar; info: PGTypeInfo; flags: TGTypeFlags): TGType; cdecl; external;
 
1205
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;
 
1206
function g_type_test_flags(type_: TGType; flags: guint): gboolean; cdecl; external;
 
1207
function g_type_value_table_peek(type_: TGType): PGTypeValueTable; cdecl; external;
 
1208
function g_value_array_get_type: TGType; cdecl; external;
 
1209
function g_value_dup_boxed(AValue: PGValue): gpointer; cdecl; external;
 
1210
function g_value_dup_object(AValue: PGValue): PGObject; cdecl; external;
 
1211
function g_value_dup_param(AValue: PGValue): PGParamSpec; cdecl; external;
 
1212
function g_value_dup_string(AValue: PGValue): Pgchar; cdecl; external;
 
1213
function g_value_dup_variant(AValue: PGValue): PGVariant; cdecl; external;
 
1214
function g_value_fits_pointer(AValue: PGValue): gboolean; cdecl; external;
 
1215
function g_value_get_boolean(AValue: PGValue): gboolean; cdecl; external;
 
1216
function g_value_get_boxed(AValue: PGValue): gpointer; cdecl; external;
 
1217
function g_value_get_double(AValue: PGValue): gdouble; cdecl; external;
 
1218
function g_value_get_enum(AValue: PGValue): gint; cdecl; external;
 
1219
function g_value_get_flags(AValue: PGValue): guint; cdecl; external;
 
1220
function g_value_get_float(AValue: PGValue): gfloat; cdecl; external;
 
1221
function g_value_get_gtype(AValue: PGValue): TGType; cdecl; external;
 
1222
function g_value_get_int(AValue: PGValue): gint; cdecl; external;
 
1223
function g_value_get_int64(AValue: PGValue): gint64; cdecl; external;
 
1224
function g_value_get_long(AValue: PGValue): glong; cdecl; external;
 
1225
function g_value_get_object(AValue: PGValue): PGObject; cdecl; external;
 
1226
function g_value_get_param(AValue: PGValue): PGParamSpec; cdecl; external;
 
1227
function g_value_get_pointer(AValue: PGValue): gpointer; cdecl; external;
 
1228
function g_value_get_schar(AValue: PGValue): gint8; cdecl; external;
 
1229
function g_value_get_string(AValue: PGValue): Pgchar; cdecl; external;
 
1230
function g_value_get_type: TGType; cdecl; external;
 
1231
function g_value_get_uchar(AValue: PGValue): guint8; cdecl; external;
 
1232
function g_value_get_uint(AValue: PGValue): guint; cdecl; external;
 
1233
function g_value_get_uint64(AValue: PGValue): guint64; cdecl; external;
 
1234
function g_value_get_ulong(AValue: PGValue): gulong; cdecl; external;
 
1235
function g_value_get_variant(AValue: PGValue): PGVariant; cdecl; external;
 
1236
function g_value_init(AValue: PGValue; g_type: TGType): PGValue; cdecl; external;
 
1237
function g_value_peek_pointer(AValue: PGValue): gpointer; cdecl; external;
 
1238
function g_value_reset(AValue: PGValue): PGValue; cdecl; external;
 
1239
function g_value_transform(AValue: PGValue; dest_value: PGValue): gboolean; cdecl; external;
 
1240
function g_value_type_compatible(src_type: TGType; dest_type: TGType): gboolean; cdecl; external;
 
1241
function g_value_type_transformable(src_type: TGType; dest_type: TGType): gboolean; cdecl; external;
 
1242
function g_weak_ref_get(AWeakRef: PGWeakRef): PGObject; cdecl; external;
 
1243
procedure g_boxed_free(boxed_type: TGType; boxed: gpointer); cdecl; external;
 
1244
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;
 
1245
procedure g_cclosure_marshal_BOOLEAN__BOXED_BOXEDv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1246
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;
 
1247
procedure g_cclosure_marshal_BOOLEAN__FLAGSv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1248
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;
 
1249
procedure g_cclosure_marshal_generic_va(closure: PGClosure; return_value: PGValue; instance: gpointer; args_list: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1250
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;
 
1251
procedure g_cclosure_marshal_STRING__OBJECT_POINTERv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1252
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;
 
1253
procedure g_cclosure_marshal_VOID__BOOLEANv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1254
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;
 
1255
procedure g_cclosure_marshal_VOID__BOXEDv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1256
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;
 
1257
procedure g_cclosure_marshal_VOID__CHARv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1258
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;
 
1259
procedure g_cclosure_marshal_VOID__DOUBLEv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1260
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;
 
1261
procedure g_cclosure_marshal_VOID__ENUMv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1262
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;
 
1263
procedure g_cclosure_marshal_VOID__FLAGSv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1264
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;
 
1265
procedure g_cclosure_marshal_VOID__FLOATv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1266
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;
 
1267
procedure g_cclosure_marshal_VOID__INTv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1268
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;
 
1269
procedure g_cclosure_marshal_VOID__LONGv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1270
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;
 
1271
procedure g_cclosure_marshal_VOID__OBJECTv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1272
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;
 
1273
procedure g_cclosure_marshal_VOID__PARAMv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1274
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;
 
1275
procedure g_cclosure_marshal_VOID__POINTERv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1276
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;
 
1277
procedure g_cclosure_marshal_VOID__STRINGv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1278
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;
 
1279
procedure g_cclosure_marshal_VOID__UCHARv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1280
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;
 
1281
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;
 
1282
procedure g_cclosure_marshal_VOID__UINT_POINTERv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1283
procedure g_cclosure_marshal_VOID__UINTv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1284
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;
 
1285
procedure g_cclosure_marshal_VOID__ULONGv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1286
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;
 
1287
procedure g_cclosure_marshal_VOID__VARIANTv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1288
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;
 
1289
procedure g_cclosure_marshal_VOID__VOIDv(closure: PGClosure; return_value: PGValue; instance: gpointer; args: Tva_list; marshal_data: gpointer; n_params: gint; param_types: PGType); cdecl; external;
 
1290
procedure g_clear_object(object_ptr: PPGObject); cdecl; external;
 
1291
procedure g_closure_add_finalize_notifier(AClosure: PGClosure; notify_data: gpointer; notify_func: TGClosureNotify); cdecl; external;
 
1292
procedure g_closure_add_invalidate_notifier(AClosure: PGClosure; notify_data: gpointer; notify_func: TGClosureNotify); cdecl; external;
 
1293
procedure g_closure_add_marshal_guards(AClosure: PGClosure; pre_marshal_data: gpointer; pre_marshal_notify: TGClosureNotify; post_marshal_data: gpointer; post_marshal_notify: TGClosureNotify); cdecl; external;
 
1294
procedure g_closure_invalidate(AClosure: PGClosure); cdecl; external;
 
1295
procedure g_closure_invoke(AClosure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer); cdecl; external;
 
1296
procedure g_closure_remove_finalize_notifier(AClosure: PGClosure; notify_data: gpointer; notify_func: TGClosureNotify); cdecl; external;
 
1297
procedure g_closure_remove_invalidate_notifier(AClosure: PGClosure; notify_data: gpointer; notify_func: TGClosureNotify); cdecl; external;
 
1298
procedure g_closure_set_marshal(AClosure: PGClosure; marshal: TGClosureMarshal); cdecl; external;
 
1299
procedure g_closure_set_meta_marshal(AClosure: PGClosure; marshal_data: gpointer; meta_marshal: TGClosureMarshal); cdecl; external;
 
1300
procedure g_closure_sink(AClosure: PGClosure); cdecl; external;
 
1301
procedure g_closure_unref(AClosure: PGClosure); cdecl; external;
 
1302
procedure g_enum_complete_type_info(g_enum_type: TGType; info: PGTypeInfo; const_values: PGEnumValue); cdecl; external;
 
1303
procedure g_flags_complete_type_info(g_flags_type: TGType; info: PGTypeInfo; const_values: PGFlagsValue); cdecl; external;
 
1304
procedure g_object_add_toggle_ref(AObject: PGObject; notify: TGToggleNotify; data: gpointer); cdecl; external;
 
1305
procedure g_object_add_weak_pointer(AObject: PGObject; weak_pointer_location: Pgpointer); cdecl; external;
 
1306
procedure g_object_class_install_properties(AObjectClass: PGObjectClass; n_pspecs: guint; pspecs: PPGParamSpec); cdecl; external;
 
1307
procedure g_object_class_install_property(AObjectClass: PGObjectClass; property_id: guint; pspec: PGParamSpec); cdecl; external;
 
1308
procedure g_object_class_override_property(AObjectClass: PGObjectClass; property_id: guint; name: Pgchar); cdecl; external;
 
1309
procedure g_object_disconnect(object_: gpointer; signal_spec: Pgchar; args: array of const); cdecl; external;
 
1310
procedure g_object_force_floating(AObject: PGObject); cdecl; external;
 
1311
procedure g_object_freeze_notify(AObject: PGObject); cdecl; external;
 
1312
procedure g_object_get(object_: gpointer; first_property_name: Pgchar; args: array of const); cdecl; external;
 
1313
procedure g_object_get_property(AObject: PGObject; property_name: Pgchar; value: PGValue); cdecl; external;
 
1314
procedure g_object_get_valist(AObject: PGObject; first_property_name: Pgchar; var_args: Tva_list); cdecl; external;
 
1315
procedure g_object_interface_install_property(g_iface: gpointer; pspec: PGParamSpec); cdecl; external;
 
1316
procedure g_object_notify(AObject: PGObject; property_name: Pgchar); cdecl; external;
 
1317
procedure g_object_notify_by_pspec(AObject: PGObject; pspec: PGParamSpec); cdecl; external;
 
1318
procedure g_object_remove_toggle_ref(AObject: PGObject; notify: TGToggleNotify; data: gpointer); cdecl; external;
 
1319
procedure g_object_remove_weak_pointer(AObject: PGObject; weak_pointer_location: Pgpointer); cdecl; external;
 
1320
procedure g_object_run_dispose(AObject: PGObject); cdecl; external;
 
1321
procedure g_object_set(object_: gpointer; first_property_name: Pgchar; args: array of const); cdecl; external;
 
1322
procedure g_object_set_data(AObject: PGObject; key: Pgchar; data: gpointer); cdecl; external;
 
1323
procedure g_object_set_data_full(AObject: PGObject; key: Pgchar; data: gpointer; destroy_: TGDestroyNotify); cdecl; external;
 
1324
procedure g_object_set_property(AObject: PGObject; property_name: Pgchar; value: PGValue); cdecl; external;
 
1325
procedure g_object_set_qdata(AObject: PGObject; quark: TGQuark; data: gpointer); cdecl; external;
 
1326
procedure g_object_set_qdata_full(AObject: PGObject; quark: TGQuark; data: gpointer; destroy_: TGDestroyNotify); cdecl; external;
 
1327
procedure g_object_set_valist(AObject: PGObject; first_property_name: Pgchar; var_args: Tva_list); cdecl; external;
 
1328
procedure g_object_thaw_notify(AObject: PGObject); cdecl; external;
 
1329
procedure g_object_unref(AObject: PGObject); cdecl; external;
 
1330
procedure g_object_watch_closure(AObject: PGObject; closure: PGClosure); cdecl; external;
 
1331
procedure g_object_weak_ref(AObject: PGObject; notify: TGWeakNotify; data: gpointer); cdecl; external;
 
1332
procedure g_object_weak_unref(AObject: PGObject; notify: TGWeakNotify; data: gpointer); cdecl; external;
 
1333
procedure g_param_spec_pool_insert(AParamSpecPool: PGParamSpecPool; pspec: PGParamSpec; owner_type: TGType); cdecl; external;
 
1334
procedure g_param_spec_pool_remove(AParamSpecPool: PGParamSpecPool; pspec: PGParamSpec); cdecl; external;
 
1335
procedure g_param_spec_set_qdata(AParamSpec: PGParamSpec; quark: TGQuark; data: gpointer); cdecl; external;
 
1336
procedure g_param_spec_set_qdata_full(AParamSpec: PGParamSpec; quark: TGQuark; data: gpointer; destroy_: TGDestroyNotify); cdecl; external;
 
1337
procedure g_param_spec_sink(AParamSpec: PGParamSpec); cdecl; external;
 
1338
procedure g_param_spec_unref(AParamSpec: PGParamSpec); cdecl; external;
 
1339
procedure g_param_value_set_default(pspec: PGParamSpec; value: PGValue); cdecl; external;
 
1340
procedure g_signal_chain_from_overridden(instance_and_params: PGValue; return_value: PGValue); cdecl; external;
 
1341
procedure g_signal_chain_from_overridden_handler(instance: gpointer; args: array of const); cdecl; external;
 
1342
procedure g_signal_emit(instance: gpointer; signal_id: guint; detail: TGQuark; args: array of const); cdecl; external;
 
1343
procedure g_signal_emit_by_name(instance: gpointer; detailed_signal: Pgchar; args: array of const); cdecl; external;
 
1344
procedure g_signal_emit_valist(instance: gpointer; signal_id: guint; detail: TGQuark; var_args: Tva_list); cdecl; external;
 
1345
procedure g_signal_emitv(instance_and_params: PGValue; signal_id: guint; detail: TGQuark; return_value: PGValue); cdecl; external;
 
1346
procedure g_signal_handler_block(instance: gpointer; handler_id: gulong); cdecl; external;
 
1347
procedure g_signal_handler_disconnect(instance: gpointer; handler_id: gulong); cdecl; external;
 
1348
procedure g_signal_handler_unblock(instance: gpointer; handler_id: gulong); cdecl; external;
 
1349
procedure g_signal_handlers_destroy(instance: gpointer); cdecl; external;
 
1350
procedure g_signal_override_class_closure(signal_id: guint; instance_type: TGType; class_closure: PGClosure); cdecl; external;
 
1351
procedure g_signal_override_class_handler(signal_name: Pgchar; instance_type: TGType; class_handler: TGCallback); cdecl; external;
 
1352
procedure g_signal_query(signal_id: guint; query: PGSignalQuery); cdecl; external;
 
1353
procedure g_signal_remove_emission_hook(signal_id: guint; hook_id: gulong); cdecl; external;
 
1354
procedure g_signal_set_va_marshaller(signal_id: guint; instance_type: TGType; va_marshaller: TGSignalCVaMarshaller); cdecl; external;
 
1355
procedure g_signal_stop_emission(instance: gpointer; signal_id: guint; detail: TGQuark); cdecl; external;
 
1356
procedure g_signal_stop_emission_by_name(instance: gpointer; detailed_signal: Pgchar); cdecl; external;
 
1357
procedure g_source_set_closure(source: PGSource; closure: PGClosure); cdecl; external;
 
1358
procedure g_source_set_dummy_callback(source: PGSource); cdecl; external;
 
1359
procedure g_type_add_class_cache_func(cache_data: gpointer; cache_func: TGTypeClassCacheFunc); cdecl; external;
 
1360
procedure g_type_add_class_private(class_type: TGType; private_size: gsize); cdecl; external;
 
1361
procedure g_type_add_interface_check(check_data: gpointer; check_func: TGTypeInterfaceCheckFunc); cdecl; external;
 
1362
procedure g_type_add_interface_dynamic(instance_type: TGType; interface_type: TGType; plugin: PGTypePlugin); cdecl; external;
 
1363
procedure g_type_add_interface_static(instance_type: TGType; interface_type: TGType; info: PGInterfaceInfo); cdecl; external;
 
1364
procedure g_type_class_add_private(g_class: gpointer; private_size: gsize); cdecl; external;
 
1365
procedure g_type_class_unref(ATypeClass: PGTypeClass); cdecl; external;
 
1366
procedure g_type_class_unref_uncached(ATypeClass: PGTypeClass); cdecl; external;
 
1367
procedure g_type_default_interface_unref(g_iface: PGTypeInterface); cdecl; external;
 
1368
procedure g_type_free_instance(instance: PGTypeInstance); cdecl; external;
 
1369
procedure g_type_init; cdecl; external;
 
1370
procedure g_type_init_with_debug_flags(debug_flags: TGTypeDebugFlags); cdecl; external;
 
1371
procedure g_type_interface_add_prerequisite(interface_type: TGType; prerequisite_type: TGType); cdecl; external;
 
1372
procedure g_type_module_add_interface(ATypeModule: PGTypeModule; instance_type: TGType; interface_type: TGType; interface_info: PGInterfaceInfo); cdecl; external;
 
1373
procedure g_type_module_set_name(ATypeModule: PGTypeModule; name: Pgchar); cdecl; external;
 
1374
procedure g_type_module_unuse(ATypeModule: PGTypeModule); cdecl; external;
 
1375
procedure g_type_plugin_complete_interface_info(ATypePlugin: PGTypePlugin; instance_type: TGType; interface_type: TGType; info: PGInterfaceInfo); cdecl; external;
 
1376
procedure g_type_plugin_complete_type_info(ATypePlugin: PGTypePlugin; g_type: TGType; info: PGTypeInfo; value_table: PGTypeValueTable); cdecl; external;
 
1377
procedure g_type_plugin_unuse(ATypePlugin: PGTypePlugin); cdecl; external;
 
1378
procedure g_type_plugin_use(ATypePlugin: PGTypePlugin); cdecl; external;
 
1379
procedure g_type_query(type_: TGType; query: PGTypeQuery); cdecl; external;
 
1380
procedure g_type_remove_class_cache_func(cache_data: gpointer; cache_func: TGTypeClassCacheFunc); cdecl; external;
 
1381
procedure g_type_remove_interface_check(check_data: gpointer; check_func: TGTypeInterfaceCheckFunc); cdecl; external;
 
1382
procedure g_type_set_qdata(type_: TGType; quark: TGQuark; data: gpointer); cdecl; external;
 
1383
procedure g_value_copy(AValue: PGValue; dest_value: PGValue); cdecl; external;
 
1384
procedure g_value_register_transform_func(src_type: TGType; dest_type: TGType; transform_func: TGValueTransform); cdecl; external;
 
1385
procedure g_value_set_boolean(AValue: PGValue; v_boolean: gboolean); cdecl; external;
 
1386
procedure g_value_set_boxed(AValue: PGValue; v_boxed: gpointer); cdecl; external;
 
1387
procedure g_value_set_double(AValue: PGValue; v_double: gdouble); cdecl; external;
 
1388
procedure g_value_set_enum(AValue: PGValue; v_enum: gint); cdecl; external;
 
1389
procedure g_value_set_flags(AValue: PGValue; v_flags: guint); cdecl; external;
 
1390
procedure g_value_set_float(AValue: PGValue; v_float: gfloat); cdecl; external;
 
1391
procedure g_value_set_gtype(AValue: PGValue; v_gtype: TGType); cdecl; external;
 
1392
procedure g_value_set_instance(AValue: PGValue; instance: gpointer); cdecl; external;
 
1393
procedure g_value_set_int(AValue: PGValue; v_int: gint); cdecl; external;
 
1394
procedure g_value_set_int64(AValue: PGValue; v_int64: gint64); cdecl; external;
 
1395
procedure g_value_set_long(AValue: PGValue; v_long: glong); cdecl; external;
 
1396
procedure g_value_set_object(AValue: PGValue; v_object: PGObject); cdecl; external;
 
1397
procedure g_value_set_param(AValue: PGValue; param: PGParamSpec); cdecl; external;
 
1398
procedure g_value_set_pointer(AValue: PGValue; v_pointer: gpointer); cdecl; external;
 
1399
procedure g_value_set_schar(AValue: PGValue; v_char: gint8); cdecl; external;
 
1400
procedure g_value_set_static_boxed(AValue: PGValue; v_boxed: gpointer); cdecl; external;
 
1401
procedure g_value_set_static_string(AValue: PGValue; v_string: Pgchar); cdecl; external;
 
1402
procedure g_value_set_string(AValue: PGValue; v_string: Pgchar); cdecl; external;
 
1403
procedure g_value_set_uchar(AValue: PGValue; v_uchar: guint8); cdecl; external;
 
1404
procedure g_value_set_uint(AValue: PGValue; v_uint: guint); cdecl; external;
 
1405
procedure g_value_set_uint64(AValue: PGValue; v_uint64: guint64); cdecl; external;
 
1406
procedure g_value_set_ulong(AValue: PGValue; v_ulong: gulong); cdecl; external;
 
1407
procedure g_value_set_variant(AValue: PGValue; variant: PGVariant); cdecl; external;
 
1408
procedure g_value_take_boxed(AValue: PGValue; v_boxed: gpointer); cdecl; external;
 
1409
procedure g_value_take_object(AValue: PGValue; v_object: gpointer); cdecl; external;
 
1410
procedure g_value_take_param(AValue: PGValue; param: PGParamSpec); cdecl; external;
 
1411
procedure g_value_take_string(AValue: PGValue; v_string: Pgchar); cdecl; external;
 
1412
procedure g_value_take_variant(AValue: PGValue; variant: PGVariant); cdecl; external;
 
1413
procedure g_value_unset(AValue: PGValue); cdecl; external;
 
1414
procedure g_weak_ref_clear(AWeakRef: PGWeakRef); cdecl; external;
 
1415
procedure g_weak_ref_init(AWeakRef: PGWeakRef; object_: gpointer); cdecl; external;
 
1416
procedure g_weak_ref_set(AWeakRef: PGWeakRef; object_: gpointer); cdecl; external;
 
1417
implementation
 
1418
function TGObject.newv(object_type: TGType; n_parameters: guint; parameters: PGParameter): PGObject; cdecl;
 
1419
begin
 
1420
  Result := LazGObject2.g_object_newv(object_type, n_parameters, parameters);
 
1421
end;
 
1422
 
 
1423
function TGObject.compat_control(what: gsize; data: gpointer): gsize; cdecl;
 
1424
begin
 
1425
  Result := LazGObject2.g_object_compat_control(what, data);
 
1426
end;
 
1427
 
 
1428
function TGObject.interface_find_property(g_iface: gpointer; property_name: Pgchar): PGParamSpec; cdecl;
 
1429
begin
 
1430
  Result := LazGObject2.g_object_interface_find_property(g_iface, property_name);
 
1431
end;
 
1432
 
 
1433
procedure TGObject.interface_install_property(g_iface: gpointer; pspec: PGParamSpec); cdecl;
 
1434
begin
 
1435
  LazGObject2.g_object_interface_install_property(g_iface, pspec);
 
1436
end;
 
1437
 
 
1438
function TGObject.interface_list_properties(g_iface: gpointer; n_properties_p: Pguint): PPGParamSpec; cdecl;
 
1439
begin
 
1440
  Result := LazGObject2.g_object_interface_list_properties(g_iface, n_properties_p);
 
1441
end;
 
1442
 
 
1443
procedure TGObject.add_toggle_ref(notify: TGToggleNotify; data: gpointer); cdecl;
 
1444
begin
 
1445
  LazGObject2.g_object_add_toggle_ref(@self, notify, data);
 
1446
end;
 
1447
 
 
1448
procedure TGObject.add_weak_pointer(weak_pointer_location: Pgpointer); cdecl;
 
1449
begin
 
1450
  LazGObject2.g_object_add_weak_pointer(@self, weak_pointer_location);
 
1451
end;
 
1452
 
 
1453
function TGObject.bind_property(source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags): PGBinding; cdecl;
 
1454
begin
 
1455
  Result := LazGObject2.g_object_bind_property(@self, source_property, target, target_property, flags);
 
1456
end;
 
1457
 
 
1458
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;
 
1459
begin
 
1460
  Result := LazGObject2.g_object_bind_property_full(@self, source_property, target, target_property, flags, transform_to, transform_from, user_data, notify);
 
1461
end;
 
1462
 
 
1463
function TGObject.bind_property_with_closures(source_property: Pgchar; target: PGObject; target_property: Pgchar; flags: TGBindingFlags; transform_to: PGClosure; transform_from: PGClosure): PGBinding; cdecl;
 
1464
begin
 
1465
  Result := LazGObject2.g_object_bind_property_with_closures(@self, source_property, target, target_property, flags, transform_to, transform_from);
 
1466
end;
 
1467
 
 
1468
procedure TGObject.force_floating; cdecl;
 
1469
begin
 
1470
  LazGObject2.g_object_force_floating(@self);
 
1471
end;
 
1472
 
 
1473
procedure TGObject.freeze_notify; cdecl;
 
1474
begin
 
1475
  LazGObject2.g_object_freeze_notify(@self);
 
1476
end;
 
1477
 
 
1478
function TGObject.get_data(key: Pgchar): gpointer; cdecl;
 
1479
begin
 
1480
  Result := LazGObject2.g_object_get_data(@self, key);
 
1481
end;
 
1482
 
 
1483
procedure TGObject.get_property(property_name: Pgchar; value: PGValue); cdecl;
 
1484
begin
 
1485
  LazGObject2.g_object_get_property(@self, property_name, value);
 
1486
end;
 
1487
 
 
1488
function TGObject.get_qdata(quark: TGQuark): gpointer; cdecl;
 
1489
begin
 
1490
  Result := LazGObject2.g_object_get_qdata(@self, quark);
 
1491
end;
 
1492
 
 
1493
function TGObject.is_floating: gboolean; cdecl;
 
1494
begin
 
1495
  Result := LazGObject2.g_object_is_floating(@self);
 
1496
end;
 
1497
 
 
1498
procedure TGObject.notify(property_name: Pgchar); cdecl;
 
1499
begin
 
1500
  LazGObject2.g_object_notify(@self, property_name);
 
1501
end;
 
1502
 
 
1503
procedure TGObject.notify_by_pspec(pspec: PGParamSpec); cdecl;
 
1504
begin
 
1505
  LazGObject2.g_object_notify_by_pspec(@self, pspec);
 
1506
end;
 
1507
 
 
1508
function TGObject.ref: PGObject; cdecl;
 
1509
begin
 
1510
  Result := LazGObject2.g_object_ref(@self);
 
1511
end;
 
1512
 
 
1513
function TGObject.ref_sink: PGObject; cdecl;
 
1514
begin
 
1515
  Result := LazGObject2.g_object_ref_sink(@self);
 
1516
end;
 
1517
 
 
1518
procedure TGObject.remove_toggle_ref(notify: TGToggleNotify; data: gpointer); cdecl;
 
1519
begin
 
1520
  LazGObject2.g_object_remove_toggle_ref(@self, notify, data);
 
1521
end;
 
1522
 
 
1523
procedure TGObject.remove_weak_pointer(weak_pointer_location: Pgpointer); cdecl;
 
1524
begin
 
1525
  LazGObject2.g_object_remove_weak_pointer(@self, weak_pointer_location);
 
1526
end;
 
1527
 
 
1528
procedure TGObject.run_dispose; cdecl;
 
1529
begin
 
1530
  LazGObject2.g_object_run_dispose(@self);
 
1531
end;
 
1532
 
 
1533
procedure TGObject.set_data(key: Pgchar; data: gpointer); cdecl;
 
1534
begin
 
1535
  LazGObject2.g_object_set_data(@self, key, data);
 
1536
end;
 
1537
 
 
1538
procedure TGObject.set_data_full(key: Pgchar; data: gpointer; destroy_: TGDestroyNotify); cdecl;
 
1539
begin
 
1540
  LazGObject2.g_object_set_data_full(@self, key, data, destroy_);
 
1541
end;
 
1542
 
 
1543
procedure TGObject.set_property(property_name: Pgchar; value: PGValue); cdecl;
 
1544
begin
 
1545
  LazGObject2.g_object_set_property(@self, property_name, value);
 
1546
end;
 
1547
 
 
1548
procedure TGObject.set_qdata(quark: TGQuark; data: gpointer); cdecl;
 
1549
begin
 
1550
  LazGObject2.g_object_set_qdata(@self, quark, data);
 
1551
end;
 
1552
 
 
1553
procedure TGObject.set_qdata_full(quark: TGQuark; data: gpointer; destroy_: TGDestroyNotify); cdecl;
 
1554
begin
 
1555
  LazGObject2.g_object_set_qdata_full(@self, quark, data, destroy_);
 
1556
end;
 
1557
 
 
1558
function TGObject.steal_data(key: Pgchar): gpointer; cdecl;
 
1559
begin
 
1560
  Result := LazGObject2.g_object_steal_data(@self, key);
 
1561
end;
 
1562
 
 
1563
function TGObject.steal_qdata(quark: TGQuark): gpointer; cdecl;
 
1564
begin
 
1565
  Result := LazGObject2.g_object_steal_qdata(@self, quark);
 
1566
end;
 
1567
 
 
1568
procedure TGObject.thaw_notify; cdecl;
 
1569
begin
 
1570
  LazGObject2.g_object_thaw_notify(@self);
 
1571
end;
 
1572
 
 
1573
procedure TGObject.unref; cdecl;
 
1574
begin
 
1575
  LazGObject2.g_object_unref(@self);
 
1576
end;
 
1577
 
 
1578
procedure TGObject.watch_closure(closure: PGClosure); cdecl;
 
1579
begin
 
1580
  LazGObject2.g_object_watch_closure(@self, closure);
 
1581
end;
 
1582
 
 
1583
procedure TGObject.weak_ref(notify: TGWeakNotify; data: gpointer); cdecl;
 
1584
begin
 
1585
  LazGObject2.g_object_weak_ref(@self, notify, data);
 
1586
end;
 
1587
 
 
1588
procedure TGObject.weak_unref(notify: TGWeakNotify; data: gpointer); cdecl;
 
1589
begin
 
1590
  LazGObject2.g_object_weak_unref(@self, notify, data);
 
1591
end;
 
1592
 
 
1593
function TGTypeInstance.get_private(private_type: TGType): gpointer; cdecl;
 
1594
begin
 
1595
  Result := LazGObject2.g_type_instance_get_private(@self, private_type);
 
1596
end;
 
1597
 
 
1598
function TGBinding.get_flags: TGBindingFlags; cdecl;
 
1599
begin
 
1600
  Result := LazGObject2.g_binding_get_flags(@self);
 
1601
end;
 
1602
 
 
1603
function TGBinding.get_source: PGObject; cdecl;
 
1604
begin
 
1605
  Result := LazGObject2.g_binding_get_source(@self);
 
1606
end;
 
1607
 
 
1608
function TGBinding.get_source_property: Pgchar; cdecl;
 
1609
begin
 
1610
  Result := LazGObject2.g_binding_get_source_property(@self);
 
1611
end;
 
1612
 
 
1613
function TGBinding.get_target: PGObject; cdecl;
 
1614
begin
 
1615
  Result := LazGObject2.g_binding_get_target(@self);
 
1616
end;
 
1617
 
 
1618
function TGBinding.get_target_property: Pgchar; cdecl;
 
1619
begin
 
1620
  Result := LazGObject2.g_binding_get_target_property(@self);
 
1621
end;
 
1622
 
 
1623
procedure TGValue.copy(dest_value: PGValue); cdecl;
 
1624
begin
 
1625
  LazGObject2.g_value_copy(@self, dest_value);
 
1626
end;
 
1627
 
 
1628
function TGValue.dup_boxed: gpointer; cdecl;
 
1629
begin
 
1630
  Result := LazGObject2.g_value_dup_boxed(@self);
 
1631
end;
 
1632
 
 
1633
function TGValue.dup_object: PGObject; cdecl;
 
1634
begin
 
1635
  Result := LazGObject2.g_value_dup_object(@self);
 
1636
end;
 
1637
 
 
1638
function TGValue.dup_param: PGParamSpec; cdecl;
 
1639
begin
 
1640
  Result := LazGObject2.g_value_dup_param(@self);
 
1641
end;
 
1642
 
 
1643
function TGValue.dup_string: Pgchar; cdecl;
 
1644
begin
 
1645
  Result := LazGObject2.g_value_dup_string(@self);
 
1646
end;
 
1647
 
 
1648
function TGValue.dup_variant: PGVariant; cdecl;
 
1649
begin
 
1650
  Result := LazGObject2.g_value_dup_variant(@self);
 
1651
end;
 
1652
 
 
1653
function TGValue.fits_pointer: gboolean; cdecl;
 
1654
begin
 
1655
  Result := LazGObject2.g_value_fits_pointer(@self);
 
1656
end;
 
1657
 
 
1658
function TGValue.get_boolean: gboolean; cdecl;
 
1659
begin
 
1660
  Result := LazGObject2.g_value_get_boolean(@self);
 
1661
end;
 
1662
 
 
1663
function TGValue.get_boxed: gpointer; cdecl;
 
1664
begin
 
1665
  Result := LazGObject2.g_value_get_boxed(@self);
 
1666
end;
 
1667
 
 
1668
function TGValue.get_double: gdouble; cdecl;
 
1669
begin
 
1670
  Result := LazGObject2.g_value_get_double(@self);
 
1671
end;
 
1672
 
 
1673
function TGValue.get_enum: gint; cdecl;
 
1674
begin
 
1675
  Result := LazGObject2.g_value_get_enum(@self);
 
1676
end;
 
1677
 
 
1678
function TGValue.get_flags: guint; cdecl;
 
1679
begin
 
1680
  Result := LazGObject2.g_value_get_flags(@self);
 
1681
end;
 
1682
 
 
1683
function TGValue.get_float: gfloat; cdecl;
 
1684
begin
 
1685
  Result := LazGObject2.g_value_get_float(@self);
 
1686
end;
 
1687
 
 
1688
function TGValue.get_gtype: TGType; cdecl;
 
1689
begin
 
1690
  Result := LazGObject2.g_value_get_gtype(@self);
 
1691
end;
 
1692
 
 
1693
function TGValue.get_int: gint; cdecl;
 
1694
begin
 
1695
  Result := LazGObject2.g_value_get_int(@self);
 
1696
end;
 
1697
 
 
1698
function TGValue.get_int64: gint64; cdecl;
 
1699
begin
 
1700
  Result := LazGObject2.g_value_get_int64(@self);
 
1701
end;
 
1702
 
 
1703
function TGValue.get_long: glong; cdecl;
 
1704
begin
 
1705
  Result := LazGObject2.g_value_get_long(@self);
 
1706
end;
 
1707
 
 
1708
function TGValue.get_object: PGObject; cdecl;
 
1709
begin
 
1710
  Result := LazGObject2.g_value_get_object(@self);
 
1711
end;
 
1712
 
 
1713
function TGValue.get_param: PGParamSpec; cdecl;
 
1714
begin
 
1715
  Result := LazGObject2.g_value_get_param(@self);
 
1716
end;
 
1717
 
 
1718
function TGValue.get_pointer: gpointer; cdecl;
 
1719
begin
 
1720
  Result := LazGObject2.g_value_get_pointer(@self);
 
1721
end;
 
1722
 
 
1723
function TGValue.get_schar: gint8; cdecl;
 
1724
begin
 
1725
  Result := LazGObject2.g_value_get_schar(@self);
 
1726
end;
 
1727
 
 
1728
function TGValue.get_string: Pgchar; cdecl;
 
1729
begin
 
1730
  Result := LazGObject2.g_value_get_string(@self);
 
1731
end;
 
1732
 
 
1733
function TGValue.get_uchar: guint8; cdecl;
 
1734
begin
 
1735
  Result := LazGObject2.g_value_get_uchar(@self);
 
1736
end;
 
1737
 
 
1738
function TGValue.get_uint: guint; cdecl;
 
1739
begin
 
1740
  Result := LazGObject2.g_value_get_uint(@self);
 
1741
end;
 
1742
 
 
1743
function TGValue.get_uint64: guint64; cdecl;
 
1744
begin
 
1745
  Result := LazGObject2.g_value_get_uint64(@self);
 
1746
end;
 
1747
 
 
1748
function TGValue.get_ulong: gulong; cdecl;
 
1749
begin
 
1750
  Result := LazGObject2.g_value_get_ulong(@self);
 
1751
end;
 
1752
 
 
1753
function TGValue.get_variant: PGVariant; cdecl;
 
1754
begin
 
1755
  Result := LazGObject2.g_value_get_variant(@self);
 
1756
end;
 
1757
 
 
1758
function TGValue.init(g_type: TGType): PGValue; cdecl;
 
1759
begin
 
1760
  Result := LazGObject2.g_value_init(@self, g_type);
 
1761
end;
 
1762
 
 
1763
function TGValue.peek_pointer: gpointer; cdecl;
 
1764
begin
 
1765
  Result := LazGObject2.g_value_peek_pointer(@self);
 
1766
end;
 
1767
 
 
1768
function TGValue.reset: PGValue; cdecl;
 
1769
begin
 
1770
  Result := LazGObject2.g_value_reset(@self);
 
1771
end;
 
1772
 
 
1773
procedure TGValue.set_boolean(v_boolean: gboolean); cdecl;
 
1774
begin
 
1775
  LazGObject2.g_value_set_boolean(@self, v_boolean);
 
1776
end;
 
1777
 
 
1778
procedure TGValue.set_boxed(v_boxed: gpointer); cdecl;
 
1779
begin
 
1780
  LazGObject2.g_value_set_boxed(@self, v_boxed);
 
1781
end;
 
1782
 
 
1783
procedure TGValue.set_double(v_double: gdouble); cdecl;
 
1784
begin
 
1785
  LazGObject2.g_value_set_double(@self, v_double);
 
1786
end;
 
1787
 
 
1788
procedure TGValue.set_enum(v_enum: gint); cdecl;
 
1789
begin
 
1790
  LazGObject2.g_value_set_enum(@self, v_enum);
 
1791
end;
 
1792
 
 
1793
procedure TGValue.set_flags(v_flags: guint); cdecl;
 
1794
begin
 
1795
  LazGObject2.g_value_set_flags(@self, v_flags);
 
1796
end;
 
1797
 
 
1798
procedure TGValue.set_float(v_float: gfloat); cdecl;
 
1799
begin
 
1800
  LazGObject2.g_value_set_float(@self, v_float);
 
1801
end;
 
1802
 
 
1803
procedure TGValue.set_gtype(v_gtype: TGType); cdecl;
 
1804
begin
 
1805
  LazGObject2.g_value_set_gtype(@self, v_gtype);
 
1806
end;
 
1807
 
 
1808
procedure TGValue.set_instance(instance: gpointer); cdecl;
 
1809
begin
 
1810
  LazGObject2.g_value_set_instance(@self, instance);
 
1811
end;
 
1812
 
 
1813
procedure TGValue.set_int(v_int: gint); cdecl;
 
1814
begin
 
1815
  LazGObject2.g_value_set_int(@self, v_int);
 
1816
end;
 
1817
 
 
1818
procedure TGValue.set_int64(v_int64: gint64); cdecl;
 
1819
begin
 
1820
  LazGObject2.g_value_set_int64(@self, v_int64);
 
1821
end;
 
1822
 
 
1823
procedure TGValue.set_long(v_long: glong); cdecl;
 
1824
begin
 
1825
  LazGObject2.g_value_set_long(@self, v_long);
 
1826
end;
 
1827
 
 
1828
procedure TGValue.set_object(v_object: PGObject); cdecl;
 
1829
begin
 
1830
  LazGObject2.g_value_set_object(@self, v_object);
 
1831
end;
 
1832
 
 
1833
procedure TGValue.set_param(param: PGParamSpec); cdecl;
 
1834
begin
 
1835
  LazGObject2.g_value_set_param(@self, param);
 
1836
end;
 
1837
 
 
1838
procedure TGValue.set_pointer(v_pointer: gpointer); cdecl;
 
1839
begin
 
1840
  LazGObject2.g_value_set_pointer(@self, v_pointer);
 
1841
end;
 
1842
 
 
1843
procedure TGValue.set_schar(v_char: gint8); cdecl;
 
1844
begin
 
1845
  LazGObject2.g_value_set_schar(@self, v_char);
 
1846
end;
 
1847
 
 
1848
procedure TGValue.set_static_boxed(v_boxed: gpointer); cdecl;
 
1849
begin
 
1850
  LazGObject2.g_value_set_static_boxed(@self, v_boxed);
 
1851
end;
 
1852
 
 
1853
procedure TGValue.set_static_string(v_string: Pgchar); cdecl;
 
1854
begin
 
1855
  LazGObject2.g_value_set_static_string(@self, v_string);
 
1856
end;
 
1857
 
 
1858
procedure TGValue.set_string(v_string: Pgchar); cdecl;
 
1859
begin
 
1860
  LazGObject2.g_value_set_string(@self, v_string);
 
1861
end;
 
1862
 
 
1863
procedure TGValue.set_uchar(v_uchar: guint8); cdecl;
 
1864
begin
 
1865
  LazGObject2.g_value_set_uchar(@self, v_uchar);
 
1866
end;
 
1867
 
 
1868
procedure TGValue.set_uint(v_uint: guint); cdecl;
 
1869
begin
 
1870
  LazGObject2.g_value_set_uint(@self, v_uint);
 
1871
end;
 
1872
 
 
1873
procedure TGValue.set_uint64(v_uint64: guint64); cdecl;
 
1874
begin
 
1875
  LazGObject2.g_value_set_uint64(@self, v_uint64);
 
1876
end;
 
1877
 
 
1878
procedure TGValue.set_ulong(v_ulong: gulong); cdecl;
 
1879
begin
 
1880
  LazGObject2.g_value_set_ulong(@self, v_ulong);
 
1881
end;
 
1882
 
 
1883
procedure TGValue.set_variant(variant: PGVariant); cdecl;
 
1884
begin
 
1885
  LazGObject2.g_value_set_variant(@self, variant);
 
1886
end;
 
1887
 
 
1888
procedure TGValue.take_boxed(v_boxed: gpointer); cdecl;
 
1889
begin
 
1890
  LazGObject2.g_value_take_boxed(@self, v_boxed);
 
1891
end;
 
1892
 
 
1893
procedure TGValue.take_object(v_object: gpointer); cdecl;
 
1894
begin
 
1895
  LazGObject2.g_value_take_object(@self, v_object);
 
1896
end;
 
1897
 
 
1898
procedure TGValue.take_param(param: PGParamSpec); cdecl;
 
1899
begin
 
1900
  LazGObject2.g_value_take_param(@self, param);
 
1901
end;
 
1902
 
 
1903
procedure TGValue.take_string(v_string: Pgchar); cdecl;
 
1904
begin
 
1905
  LazGObject2.g_value_take_string(@self, v_string);
 
1906
end;
 
1907
 
 
1908
procedure TGValue.take_variant(variant: PGVariant); cdecl;
 
1909
begin
 
1910
  LazGObject2.g_value_take_variant(@self, variant);
 
1911
end;
 
1912
 
 
1913
function TGValue.transform(dest_value: PGValue): gboolean; cdecl;
 
1914
begin
 
1915
  Result := LazGObject2.g_value_transform(@self, dest_value);
 
1916
end;
 
1917
 
 
1918
procedure TGValue.unset; cdecl;
 
1919
begin
 
1920
  LazGObject2.g_value_unset(@self);
 
1921
end;
 
1922
 
 
1923
procedure TGValue.register_transform_func(src_type: TGType; dest_type: TGType; transform_func: TGValueTransform); cdecl;
 
1924
begin
 
1925
  LazGObject2.g_value_register_transform_func(src_type, dest_type, transform_func);
 
1926
end;
 
1927
 
 
1928
function TGValue.type_compatible(src_type: TGType; dest_type: TGType): gboolean; cdecl;
 
1929
begin
 
1930
  Result := LazGObject2.g_value_type_compatible(src_type, dest_type);
 
1931
end;
 
1932
 
 
1933
function TGValue.type_transformable(src_type: TGType; dest_type: TGType): gboolean; cdecl;
 
1934
begin
 
1935
  Result := LazGObject2.g_value_type_transformable(src_type, dest_type);
 
1936
end;
 
1937
 
 
1938
function TGClosure.new_object(sizeof_closure: guint; object_: PGObject): PGClosure; cdecl;
 
1939
begin
 
1940
  Result := LazGObject2.g_closure_new_object(sizeof_closure, object_);
 
1941
end;
 
1942
 
 
1943
function TGClosure.new_simple(sizeof_closure: guint; data: gpointer): PGClosure; cdecl;
 
1944
begin
 
1945
  Result := LazGObject2.g_closure_new_simple(sizeof_closure, data);
 
1946
end;
 
1947
 
 
1948
procedure TGClosure.add_finalize_notifier(notify_data: gpointer; notify_func: TGClosureNotify); cdecl;
 
1949
begin
 
1950
  LazGObject2.g_closure_add_finalize_notifier(@self, notify_data, notify_func);
 
1951
end;
 
1952
 
 
1953
procedure TGClosure.add_invalidate_notifier(notify_data: gpointer; notify_func: TGClosureNotify); cdecl;
 
1954
begin
 
1955
  LazGObject2.g_closure_add_invalidate_notifier(@self, notify_data, notify_func);
 
1956
end;
 
1957
 
 
1958
procedure TGClosure.add_marshal_guards(pre_marshal_data: gpointer; pre_marshal_notify: TGClosureNotify; post_marshal_data: gpointer; post_marshal_notify: TGClosureNotify); cdecl;
 
1959
begin
 
1960
  LazGObject2.g_closure_add_marshal_guards(@self, pre_marshal_data, pre_marshal_notify, post_marshal_data, post_marshal_notify);
 
1961
end;
 
1962
 
 
1963
procedure TGClosure.invalidate; cdecl;
 
1964
begin
 
1965
  LazGObject2.g_closure_invalidate(@self);
 
1966
end;
 
1967
 
 
1968
procedure TGClosure.invoke(return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer); cdecl;
 
1969
begin
 
1970
  LazGObject2.g_closure_invoke(@self, return_value, n_param_values, param_values, invocation_hint);
 
1971
end;
 
1972
 
 
1973
function TGClosure.ref: PGClosure; cdecl;
 
1974
begin
 
1975
  Result := LazGObject2.g_closure_ref(@self);
 
1976
end;
 
1977
 
 
1978
procedure TGClosure.remove_finalize_notifier(notify_data: gpointer; notify_func: TGClosureNotify); cdecl;
 
1979
begin
 
1980
  LazGObject2.g_closure_remove_finalize_notifier(@self, notify_data, notify_func);
 
1981
end;
 
1982
 
 
1983
procedure TGClosure.remove_invalidate_notifier(notify_data: gpointer; notify_func: TGClosureNotify); cdecl;
 
1984
begin
 
1985
  LazGObject2.g_closure_remove_invalidate_notifier(@self, notify_data, notify_func);
 
1986
end;
 
1987
 
 
1988
procedure TGClosure.set_marshal(marshal: TGClosureMarshal); cdecl;
 
1989
begin
 
1990
  LazGObject2.g_closure_set_marshal(@self, marshal);
 
1991
end;
 
1992
 
 
1993
procedure TGClosure.set_meta_marshal(marshal_data: gpointer; meta_marshal: TGClosureMarshal); cdecl;
 
1994
begin
 
1995
  LazGObject2.g_closure_set_meta_marshal(@self, marshal_data, meta_marshal);
 
1996
end;
 
1997
 
 
1998
procedure TGClosure.sink; cdecl;
 
1999
begin
 
2000
  LazGObject2.g_closure_sink(@self);
 
2001
end;
 
2002
 
 
2003
procedure TGClosure.unref; cdecl;
 
2004
begin
 
2005
  LazGObject2.g_closure_unref(@self);
 
2006
end;
 
2007
 
 
2008
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;
 
2009
begin
 
2010
  LazGObject2.g_cclosure_marshal_BOOLEAN__BOXED_BOXED(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2011
end;
 
2012
 
 
2013
procedure TGCClosure.marshal_BOOLEAN__FLAGS(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
2014
begin
 
2015
  LazGObject2.g_cclosure_marshal_BOOLEAN__FLAGS(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2016
end;
 
2017
 
 
2018
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;
 
2019
begin
 
2020
  LazGObject2.g_cclosure_marshal_STRING__OBJECT_POINTER(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2021
end;
 
2022
 
 
2023
procedure TGCClosure.marshal_VOID__BOOLEAN(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
2024
begin
 
2025
  LazGObject2.g_cclosure_marshal_VOID__BOOLEAN(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2026
end;
 
2027
 
 
2028
procedure TGCClosure.marshal_VOID__BOXED(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
2029
begin
 
2030
  LazGObject2.g_cclosure_marshal_VOID__BOXED(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2031
end;
 
2032
 
 
2033
procedure TGCClosure.marshal_VOID__CHAR(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
2034
begin
 
2035
  LazGObject2.g_cclosure_marshal_VOID__CHAR(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2036
end;
 
2037
 
 
2038
procedure TGCClosure.marshal_VOID__DOUBLE(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
2039
begin
 
2040
  LazGObject2.g_cclosure_marshal_VOID__DOUBLE(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2041
end;
 
2042
 
 
2043
procedure TGCClosure.marshal_VOID__ENUM(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
2044
begin
 
2045
  LazGObject2.g_cclosure_marshal_VOID__ENUM(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2046
end;
 
2047
 
 
2048
procedure TGCClosure.marshal_VOID__FLAGS(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
2049
begin
 
2050
  LazGObject2.g_cclosure_marshal_VOID__FLAGS(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2051
end;
 
2052
 
 
2053
procedure TGCClosure.marshal_VOID__FLOAT(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
2054
begin
 
2055
  LazGObject2.g_cclosure_marshal_VOID__FLOAT(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2056
end;
 
2057
 
 
2058
procedure TGCClosure.marshal_VOID__INT(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
2059
begin
 
2060
  LazGObject2.g_cclosure_marshal_VOID__INT(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2061
end;
 
2062
 
 
2063
procedure TGCClosure.marshal_VOID__LONG(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
2064
begin
 
2065
  LazGObject2.g_cclosure_marshal_VOID__LONG(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2066
end;
 
2067
 
 
2068
procedure TGCClosure.marshal_VOID__OBJECT(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
2069
begin
 
2070
  LazGObject2.g_cclosure_marshal_VOID__OBJECT(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2071
end;
 
2072
 
 
2073
procedure TGCClosure.marshal_VOID__PARAM(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
2074
begin
 
2075
  LazGObject2.g_cclosure_marshal_VOID__PARAM(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2076
end;
 
2077
 
 
2078
procedure TGCClosure.marshal_VOID__POINTER(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
2079
begin
 
2080
  LazGObject2.g_cclosure_marshal_VOID__POINTER(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2081
end;
 
2082
 
 
2083
procedure TGCClosure.marshal_VOID__STRING(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
2084
begin
 
2085
  LazGObject2.g_cclosure_marshal_VOID__STRING(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2086
end;
 
2087
 
 
2088
procedure TGCClosure.marshal_VOID__UCHAR(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
2089
begin
 
2090
  LazGObject2.g_cclosure_marshal_VOID__UCHAR(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2091
end;
 
2092
 
 
2093
procedure TGCClosure.marshal_VOID__UINT(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
2094
begin
 
2095
  LazGObject2.g_cclosure_marshal_VOID__UINT(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2096
end;
 
2097
 
 
2098
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;
 
2099
begin
 
2100
  LazGObject2.g_cclosure_marshal_VOID__UINT_POINTER(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2101
end;
 
2102
 
 
2103
procedure TGCClosure.marshal_VOID__ULONG(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
2104
begin
 
2105
  LazGObject2.g_cclosure_marshal_VOID__ULONG(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2106
end;
 
2107
 
 
2108
procedure TGCClosure.marshal_VOID__VARIANT(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
2109
begin
 
2110
  LazGObject2.g_cclosure_marshal_VOID__VARIANT(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2111
end;
 
2112
 
 
2113
procedure TGCClosure.marshal_VOID__VOID(closure: PGClosure; return_value: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
2114
begin
 
2115
  LazGObject2.g_cclosure_marshal_VOID__VOID(closure, return_value, n_param_values, param_values, invocation_hint, marshal_data);
 
2116
end;
 
2117
 
 
2118
procedure TGCClosure.marshal_generic(closure: PGClosure; return_gvalue: PGValue; n_param_values: guint; param_values: PGValue; invocation_hint: gpointer; marshal_data: gpointer); cdecl;
 
2119
begin
 
2120
  LazGObject2.g_cclosure_marshal_generic(closure, return_gvalue, n_param_values, param_values, invocation_hint, marshal_data);
 
2121
end;
 
2122
 
 
2123
function TGCClosure.new(callback_func: TGCallback; user_data: gpointer; destroy_data: TGClosureNotify): PGClosure; cdecl;
 
2124
begin
 
2125
  Result := LazGObject2.g_cclosure_new(callback_func, user_data, destroy_data);
 
2126
end;
 
2127
 
 
2128
function TGCClosure.new_object(callback_func: TGCallback; object_: PGObject): PGClosure; cdecl;
 
2129
begin
 
2130
  Result := LazGObject2.g_cclosure_new_object(callback_func, object_);
 
2131
end;
 
2132
 
 
2133
function TGCClosure.new_object_swap(callback_func: TGCallback; object_: PGObject): PGClosure; cdecl;
 
2134
begin
 
2135
  Result := LazGObject2.g_cclosure_new_object_swap(callback_func, object_);
 
2136
end;
 
2137
 
 
2138
function TGCClosure.new_swap(callback_func: TGCallback; user_data: gpointer; destroy_data: TGClosureNotify): PGClosure; cdecl;
 
2139
begin
 
2140
  Result := LazGObject2.g_cclosure_new_swap(callback_func, user_data, destroy_data);
 
2141
end;
 
2142
 
 
2143
function TGTypeClass.get_private(private_type: TGType): gpointer; cdecl;
 
2144
begin
 
2145
  Result := LazGObject2.g_type_class_get_private(@self, private_type);
 
2146
end;
 
2147
 
 
2148
function TGTypeClass.peek_parent: PGTypeClass; cdecl;
 
2149
begin
 
2150
  Result := LazGObject2.g_type_class_peek_parent(@self);
 
2151
end;
 
2152
 
 
2153
procedure TGTypeClass.unref; cdecl;
 
2154
begin
 
2155
  LazGObject2.g_type_class_unref(@self);
 
2156
end;
 
2157
 
 
2158
procedure TGTypeClass.unref_uncached; cdecl;
 
2159
begin
 
2160
  LazGObject2.g_type_class_unref_uncached(@self);
 
2161
end;
 
2162
 
 
2163
procedure TGTypeClass.add_private(g_class: gpointer; private_size: gsize); cdecl;
 
2164
begin
 
2165
  LazGObject2.g_type_class_add_private(g_class, private_size);
 
2166
end;
 
2167
 
 
2168
function TGTypeClass.peek(type_: TGType): PGTypeClass; cdecl;
 
2169
begin
 
2170
  Result := LazGObject2.g_type_class_peek(type_);
 
2171
end;
 
2172
 
 
2173
function TGTypeClass.peek_static(type_: TGType): PGTypeClass; cdecl;
 
2174
begin
 
2175
  Result := LazGObject2.g_type_class_peek_static(type_);
 
2176
end;
 
2177
 
 
2178
function TGTypeClass.ref(type_: TGType): PGTypeClass; cdecl;
 
2179
begin
 
2180
  Result := LazGObject2.g_type_class_ref(type_);
 
2181
end;
 
2182
 
 
2183
function TGParamSpec.internal(param_type: TGType; name: Pgchar; nick: Pgchar; blurb: Pgchar; flags: TGParamFlags): gpointer; cdecl;
 
2184
begin
 
2185
  Result := LazGObject2.g_param_spec_internal(param_type, name, nick, blurb, flags);
 
2186
end;
 
2187
 
 
2188
function TGParamSpec.get_blurb: Pgchar; cdecl;
 
2189
begin
 
2190
  Result := LazGObject2.g_param_spec_get_blurb(@self);
 
2191
end;
 
2192
 
 
2193
function TGParamSpec.get_name: Pgchar; cdecl;
 
2194
begin
 
2195
  Result := LazGObject2.g_param_spec_get_name(@self);
 
2196
end;
 
2197
 
 
2198
function TGParamSpec.get_nick: Pgchar; cdecl;
 
2199
begin
 
2200
  Result := LazGObject2.g_param_spec_get_nick(@self);
 
2201
end;
 
2202
 
 
2203
function TGParamSpec.get_qdata(quark: TGQuark): gpointer; cdecl;
 
2204
begin
 
2205
  Result := LazGObject2.g_param_spec_get_qdata(@self, quark);
 
2206
end;
 
2207
 
 
2208
function TGParamSpec.get_redirect_target: PGParamSpec; cdecl;
 
2209
begin
 
2210
  Result := LazGObject2.g_param_spec_get_redirect_target(@self);
 
2211
end;
 
2212
 
 
2213
function TGParamSpec.ref: PGParamSpec; cdecl;
 
2214
begin
 
2215
  Result := LazGObject2.g_param_spec_ref(@self);
 
2216
end;
 
2217
 
 
2218
function TGParamSpec.ref_sink: PGParamSpec; cdecl;
 
2219
begin
 
2220
  Result := LazGObject2.g_param_spec_ref_sink(@self);
 
2221
end;
 
2222
 
 
2223
procedure TGParamSpec.set_qdata(quark: TGQuark; data: gpointer); cdecl;
 
2224
begin
 
2225
  LazGObject2.g_param_spec_set_qdata(@self, quark, data);
 
2226
end;
 
2227
 
 
2228
procedure TGParamSpec.set_qdata_full(quark: TGQuark; data: gpointer; destroy_: TGDestroyNotify); cdecl;
 
2229
begin
 
2230
  LazGObject2.g_param_spec_set_qdata_full(@self, quark, data, destroy_);
 
2231
end;
 
2232
 
 
2233
procedure TGParamSpec.sink; cdecl;
 
2234
begin
 
2235
  LazGObject2.g_param_spec_sink(@self);
 
2236
end;
 
2237
 
 
2238
function TGParamSpec.steal_qdata(quark: TGQuark): gpointer; cdecl;
 
2239
begin
 
2240
  Result := LazGObject2.g_param_spec_steal_qdata(@self, quark);
 
2241
end;
 
2242
 
 
2243
procedure TGParamSpec.unref; cdecl;
 
2244
begin
 
2245
  LazGObject2.g_param_spec_unref(@self);
 
2246
end;
 
2247
 
 
2248
function TGObjectClass.find_property(property_name: Pgchar): PGParamSpec; cdecl;
 
2249
begin
 
2250
  Result := LazGObject2.g_object_class_find_property(@self, property_name);
 
2251
end;
 
2252
 
 
2253
procedure TGObjectClass.install_properties(n_pspecs: guint; pspecs: PPGParamSpec); cdecl;
 
2254
begin
 
2255
  LazGObject2.g_object_class_install_properties(@self, n_pspecs, pspecs);
 
2256
end;
 
2257
 
 
2258
procedure TGObjectClass.install_property(property_id: guint; pspec: PGParamSpec); cdecl;
 
2259
begin
 
2260
  LazGObject2.g_object_class_install_property(@self, property_id, pspec);
 
2261
end;
 
2262
 
 
2263
function TGObjectClass.list_properties(n_properties: Pguint): PPGParamSpec; cdecl;
 
2264
begin
 
2265
  Result := LazGObject2.g_object_class_list_properties(@self, n_properties);
 
2266
end;
 
2267
 
 
2268
procedure TGObjectClass.override_property(property_id: guint; name: Pgchar); cdecl;
 
2269
begin
 
2270
  LazGObject2.g_object_class_override_property(@self, property_id, name);
 
2271
end;
 
2272
 
 
2273
procedure TGParamSpecPool.insert(pspec: PGParamSpec; owner_type: TGType); cdecl;
 
2274
begin
 
2275
  LazGObject2.g_param_spec_pool_insert(@self, pspec, owner_type);
 
2276
end;
 
2277
 
 
2278
function TGParamSpecPool.list(owner_type: TGType; n_pspecs_p: Pguint): PPGParamSpec; cdecl;
 
2279
begin
 
2280
  Result := LazGObject2.g_param_spec_pool_list(@self, owner_type, n_pspecs_p);
 
2281
end;
 
2282
 
 
2283
function TGParamSpecPool.list_owned(owner_type: TGType): PGList; cdecl;
 
2284
begin
 
2285
  Result := LazGObject2.g_param_spec_pool_list_owned(@self, owner_type);
 
2286
end;
 
2287
 
 
2288
function TGParamSpecPool.lookup(param_name: Pgchar; owner_type: TGType; walk_ancestors: gboolean): PGParamSpec; cdecl;
 
2289
begin
 
2290
  Result := LazGObject2.g_param_spec_pool_lookup(@self, param_name, owner_type, walk_ancestors);
 
2291
end;
 
2292
 
 
2293
procedure TGParamSpecPool.remove(pspec: PGParamSpec); cdecl;
 
2294
begin
 
2295
  LazGObject2.g_param_spec_pool_remove(@self, pspec);
 
2296
end;
 
2297
 
 
2298
function TGParamSpecPool.new(type_prefixing: gboolean): PGParamSpecPool; cdecl;
 
2299
begin
 
2300
  Result := LazGObject2.g_param_spec_pool_new(type_prefixing);
 
2301
end;
 
2302
 
 
2303
function TGTypeValueTable.peek(type_: TGType): PGTypeValueTable; cdecl;
 
2304
begin
 
2305
  Result := LazGObject2.g_type_value_table_peek(type_);
 
2306
end;
 
2307
 
 
2308
function TGTypeInterface.peek_parent: PGTypeInterface; cdecl;
 
2309
begin
 
2310
  Result := LazGObject2.g_type_interface_peek_parent(@self);
 
2311
end;
 
2312
 
 
2313
procedure TGTypeInterface.add_prerequisite(interface_type: TGType; prerequisite_type: TGType); cdecl;
 
2314
begin
 
2315
  LazGObject2.g_type_interface_add_prerequisite(interface_type, prerequisite_type);
 
2316
end;
 
2317
 
 
2318
function TGTypeInterface.get_plugin(instance_type: TGType; interface_type: TGType): PGTypePlugin; cdecl;
 
2319
begin
 
2320
  Result := LazGObject2.g_type_interface_get_plugin(instance_type, interface_type);
 
2321
end;
 
2322
 
 
2323
function TGTypeInterface.peek(instance_class: PGTypeClass; iface_type: TGType): PGTypeInterface; cdecl;
 
2324
begin
 
2325
  Result := LazGObject2.g_type_interface_peek(instance_class, iface_type);
 
2326
end;
 
2327
 
 
2328
function TGTypeInterface.prerequisites(interface_type: TGType; n_prerequisites: Pguint): PGType; cdecl;
 
2329
begin
 
2330
  Result := LazGObject2.g_type_interface_prerequisites(interface_type, n_prerequisites);
 
2331
end;
 
2332
 
 
2333
procedure TGTypePlugin.complete_interface_info(instance_type: TGType; interface_type: TGType; info: PGInterfaceInfo); cdecl;
 
2334
begin
 
2335
  LazGObject2.g_type_plugin_complete_interface_info(@self, instance_type, interface_type, info);
 
2336
end;
 
2337
 
 
2338
procedure TGTypePlugin.complete_type_info(g_type: TGType; info: PGTypeInfo; value_table: PGTypeValueTable); cdecl;
 
2339
begin
 
2340
  LazGObject2.g_type_plugin_complete_type_info(@self, g_type, info, value_table);
 
2341
end;
 
2342
 
 
2343
procedure TGTypePlugin.unuse; cdecl;
 
2344
begin
 
2345
  LazGObject2.g_type_plugin_unuse(@self);
 
2346
end;
 
2347
 
 
2348
procedure TGTypePlugin.use; cdecl;
 
2349
begin
 
2350
  LazGObject2.g_type_plugin_use(@self);
 
2351
end;
 
2352
 
 
2353
procedure TGTypeModule.add_interface(instance_type: TGType; interface_type: TGType; interface_info: PGInterfaceInfo); cdecl;
 
2354
begin
 
2355
  LazGObject2.g_type_module_add_interface(@self, instance_type, interface_type, interface_info);
 
2356
end;
 
2357
 
 
2358
function TGTypeModule.register_enum(name: Pgchar; const_static_values: PGEnumValue): TGType; cdecl;
 
2359
begin
 
2360
  Result := LazGObject2.g_type_module_register_enum(@self, name, const_static_values);
 
2361
end;
 
2362
 
 
2363
function TGTypeModule.register_flags(name: Pgchar; const_static_values: PGFlagsValue): TGType; cdecl;
 
2364
begin
 
2365
  Result := LazGObject2.g_type_module_register_flags(@self, name, const_static_values);
 
2366
end;
 
2367
 
 
2368
function TGTypeModule.register_type(parent_type: TGType; type_name: Pgchar; type_info: PGTypeInfo; flags: TGTypeFlags): TGType; cdecl;
 
2369
begin
 
2370
  Result := LazGObject2.g_type_module_register_type(@self, parent_type, type_name, type_info, flags);
 
2371
end;
 
2372
 
 
2373
procedure TGTypeModule.set_name(name: Pgchar); cdecl;
 
2374
begin
 
2375
  LazGObject2.g_type_module_set_name(@self, name);
 
2376
end;
 
2377
 
 
2378
procedure TGTypeModule.unuse; cdecl;
 
2379
begin
 
2380
  LazGObject2.g_type_module_unuse(@self);
 
2381
end;
 
2382
 
 
2383
function TGTypeModule.use: gboolean; cdecl;
 
2384
begin
 
2385
  Result := LazGObject2.g_type_module_use(@self);
 
2386
end;
 
2387
 
 
2388
procedure TGWeakRef.clear; cdecl;
 
2389
begin
 
2390
  LazGObject2.g_weak_ref_clear(@self);
 
2391
end;
 
2392
 
 
2393
function TGWeakRef.get: PGObject; cdecl;
 
2394
begin
 
2395
  Result := LazGObject2.g_weak_ref_get(@self);
 
2396
end;
 
2397
 
 
2398
procedure TGWeakRef.init(object_: gpointer); cdecl;
 
2399
begin
 
2400
  LazGObject2.g_weak_ref_init(@self, object_);
 
2401
end;
 
2402
 
 
2403
procedure TGWeakRef.set_(object_: gpointer); cdecl;
 
2404
begin
 
2405
  LazGObject2.g_weak_ref_set(@self, object_);
 
2406
end;
 
2407
 
 
2408
end.