gobject_sys/
lib.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// DO NOT EDIT
4
5#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
6#![allow(
7    clippy::approx_constant,
8    clippy::type_complexity,
9    clippy::unreadable_literal
10)]
11
12extern crate glib_sys as glib;
13extern crate libc;
14
15#[allow(unused_imports)]
16use libc::{
17    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
18    intptr_t, size_t, ssize_t, time_t, uintptr_t, FILE,
19};
20
21#[allow(unused_imports)]
22use glib::{gboolean, gconstpointer, gpointer, GType};
23
24pub const G_TYPE_INVALID: GType = 0 << G_TYPE_FUNDAMENTAL_SHIFT;
25pub const G_TYPE_NONE: GType = 1 << G_TYPE_FUNDAMENTAL_SHIFT;
26pub const G_TYPE_INTERFACE: GType = 2 << G_TYPE_FUNDAMENTAL_SHIFT;
27pub const G_TYPE_CHAR: GType = 3 << G_TYPE_FUNDAMENTAL_SHIFT;
28pub const G_TYPE_UCHAR: GType = 4 << G_TYPE_FUNDAMENTAL_SHIFT;
29pub const G_TYPE_BOOLEAN: GType = 5 << G_TYPE_FUNDAMENTAL_SHIFT;
30pub const G_TYPE_INT: GType = 6 << G_TYPE_FUNDAMENTAL_SHIFT;
31pub const G_TYPE_UINT: GType = 7 << G_TYPE_FUNDAMENTAL_SHIFT;
32pub const G_TYPE_LONG: GType = 8 << G_TYPE_FUNDAMENTAL_SHIFT;
33pub const G_TYPE_ULONG: GType = 9 << G_TYPE_FUNDAMENTAL_SHIFT;
34pub const G_TYPE_INT64: GType = 10 << G_TYPE_FUNDAMENTAL_SHIFT;
35pub const G_TYPE_UINT64: GType = 11 << G_TYPE_FUNDAMENTAL_SHIFT;
36pub const G_TYPE_ENUM: GType = 12 << G_TYPE_FUNDAMENTAL_SHIFT;
37pub const G_TYPE_FLAGS: GType = 13 << G_TYPE_FUNDAMENTAL_SHIFT;
38pub const G_TYPE_FLOAT: GType = 14 << G_TYPE_FUNDAMENTAL_SHIFT;
39pub const G_TYPE_DOUBLE: GType = 15 << G_TYPE_FUNDAMENTAL_SHIFT;
40pub const G_TYPE_STRING: GType = 16 << G_TYPE_FUNDAMENTAL_SHIFT;
41pub const G_TYPE_POINTER: GType = 17 << G_TYPE_FUNDAMENTAL_SHIFT;
42pub const G_TYPE_BOXED: GType = 18 << G_TYPE_FUNDAMENTAL_SHIFT;
43pub const G_TYPE_PARAM: GType = 19 << G_TYPE_FUNDAMENTAL_SHIFT;
44pub const G_TYPE_OBJECT: GType = 20 << G_TYPE_FUNDAMENTAL_SHIFT;
45pub const G_TYPE_VARIANT: GType = 21 << G_TYPE_FUNDAMENTAL_SHIFT;
46
47// Aliases
48pub type GSignalCMarshaller = GClosureMarshal;
49
50// Constants
51pub const G_PARAM_MASK: c_int = 255;
52pub const G_PARAM_STATIC_STRINGS: c_int = 224;
53pub const G_PARAM_USER_SHIFT: c_int = 8;
54pub const G_SIGNAL_FLAGS_MASK: c_int = 511;
55pub const G_SIGNAL_MATCH_MASK: c_int = 63;
56pub const G_TYPE_FLAG_RESERVED_ID_BIT: GType = 1;
57pub const G_TYPE_FUNDAMENTAL_MAX: c_int = 255;
58pub const G_TYPE_FUNDAMENTAL_SHIFT: c_int = 2;
59pub const G_TYPE_RESERVED_BSE_FIRST: c_int = 32;
60pub const G_TYPE_RESERVED_BSE_LAST: c_int = 48;
61pub const G_TYPE_RESERVED_GLIB_FIRST: c_int = 22;
62pub const G_TYPE_RESERVED_GLIB_LAST: c_int = 31;
63pub const G_TYPE_RESERVED_USER_FIRST: c_int = 49;
64pub const G_VALUE_COLLECT_FORMAT_MAX_LENGTH: c_int = 8;
65pub const G_VALUE_NOCOPY_CONTENTS: c_int = 134217728;
66
67// Flags
68pub type GBindingFlags = c_uint;
69pub const G_BINDING_DEFAULT: GBindingFlags = 0;
70pub const G_BINDING_BIDIRECTIONAL: GBindingFlags = 1;
71pub const G_BINDING_SYNC_CREATE: GBindingFlags = 2;
72pub const G_BINDING_INVERT_BOOLEAN: GBindingFlags = 4;
73
74pub type GConnectFlags = c_uint;
75pub const G_CONNECT_AFTER: GConnectFlags = 1;
76pub const G_CONNECT_SWAPPED: GConnectFlags = 2;
77
78pub type GParamFlags = c_uint;
79pub const G_PARAM_READABLE: GParamFlags = 1;
80pub const G_PARAM_WRITABLE: GParamFlags = 2;
81pub const G_PARAM_READWRITE: GParamFlags = 3;
82pub const G_PARAM_CONSTRUCT: GParamFlags = 4;
83pub const G_PARAM_CONSTRUCT_ONLY: GParamFlags = 8;
84pub const G_PARAM_LAX_VALIDATION: GParamFlags = 16;
85pub const G_PARAM_STATIC_NAME: GParamFlags = 32;
86pub const G_PARAM_PRIVATE: GParamFlags = 32;
87pub const G_PARAM_STATIC_NICK: GParamFlags = 64;
88pub const G_PARAM_STATIC_BLURB: GParamFlags = 128;
89pub const G_PARAM_EXPLICIT_NOTIFY: GParamFlags = 1073741824;
90pub const G_PARAM_DEPRECATED: GParamFlags = 2147483648;
91
92pub type GSignalFlags = c_uint;
93pub const G_SIGNAL_RUN_FIRST: GSignalFlags = 1;
94pub const G_SIGNAL_RUN_LAST: GSignalFlags = 2;
95pub const G_SIGNAL_RUN_CLEANUP: GSignalFlags = 4;
96pub const G_SIGNAL_NO_RECURSE: GSignalFlags = 8;
97pub const G_SIGNAL_DETAILED: GSignalFlags = 16;
98pub const G_SIGNAL_ACTION: GSignalFlags = 32;
99pub const G_SIGNAL_NO_HOOKS: GSignalFlags = 64;
100pub const G_SIGNAL_MUST_COLLECT: GSignalFlags = 128;
101pub const G_SIGNAL_DEPRECATED: GSignalFlags = 256;
102
103pub type GSignalMatchType = c_uint;
104pub const G_SIGNAL_MATCH_ID: GSignalMatchType = 1;
105pub const G_SIGNAL_MATCH_DETAIL: GSignalMatchType = 2;
106pub const G_SIGNAL_MATCH_CLOSURE: GSignalMatchType = 4;
107pub const G_SIGNAL_MATCH_FUNC: GSignalMatchType = 8;
108pub const G_SIGNAL_MATCH_DATA: GSignalMatchType = 16;
109pub const G_SIGNAL_MATCH_UNBLOCKED: GSignalMatchType = 32;
110
111pub type GTypeDebugFlags = c_uint;
112pub const G_TYPE_DEBUG_NONE: GTypeDebugFlags = 0;
113pub const G_TYPE_DEBUG_OBJECTS: GTypeDebugFlags = 1;
114pub const G_TYPE_DEBUG_SIGNALS: GTypeDebugFlags = 2;
115pub const G_TYPE_DEBUG_INSTANCE_COUNT: GTypeDebugFlags = 4;
116pub const G_TYPE_DEBUG_MASK: GTypeDebugFlags = 7;
117
118pub type GTypeFlags = c_uint;
119pub const G_TYPE_FLAG_ABSTRACT: GTypeFlags = 16;
120pub const G_TYPE_FLAG_VALUE_ABSTRACT: GTypeFlags = 32;
121
122pub type GTypeFundamentalFlags = c_uint;
123pub const G_TYPE_FLAG_CLASSED: GTypeFundamentalFlags = 1;
124pub const G_TYPE_FLAG_INSTANTIATABLE: GTypeFundamentalFlags = 2;
125pub const G_TYPE_FLAG_DERIVABLE: GTypeFundamentalFlags = 4;
126pub const G_TYPE_FLAG_DEEP_DERIVABLE: GTypeFundamentalFlags = 8;
127
128// Unions
129#[repr(C)]
130#[derive(Copy, Clone)]
131pub union GTypeCValue {
132    pub v_int: c_int,
133    pub v_long: c_long,
134    pub v_int64: i64,
135    pub v_double: c_double,
136    pub v_pointer: gpointer,
137}
138
139impl ::std::fmt::Debug for GTypeCValue {
140    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
141        f.debug_struct(&format!("GTypeCValue @ {:?}", self as *const _))
142            .field("v_int", unsafe { &self.v_int })
143            .field("v_long", unsafe { &self.v_long })
144            .field("v_int64", unsafe { &self.v_int64 })
145            .field("v_double", unsafe { &self.v_double })
146            .field("v_pointer", unsafe { &self.v_pointer })
147            .finish()
148    }
149}
150
151#[repr(C)]
152#[derive(Copy, Clone)]
153pub union GValue_data {
154    pub v_int: c_int,
155    pub v_uint: c_uint,
156    pub v_long: c_long,
157    pub v_ulong: c_ulong,
158    pub v_int64: i64,
159    pub v_uint64: u64,
160    pub v_float: c_float,
161    pub v_double: c_double,
162    pub v_pointer: gpointer,
163}
164
165impl ::std::fmt::Debug for GValue_data {
166    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
167        f.debug_struct(&format!("GValue_data @ {:?}", self as *const _))
168            .field("v_int", unsafe { &self.v_int })
169            .field("v_uint", unsafe { &self.v_uint })
170            .field("v_long", unsafe { &self.v_long })
171            .field("v_ulong", unsafe { &self.v_ulong })
172            .field("v_int64", unsafe { &self.v_int64 })
173            .field("v_uint64", unsafe { &self.v_uint64 })
174            .field("v_float", unsafe { &self.v_float })
175            .field("v_double", unsafe { &self.v_double })
176            .field("v_pointer", unsafe { &self.v_pointer })
177            .finish()
178    }
179}
180
181#[repr(C)]
182#[derive(Copy, Clone)]
183pub union GWeakRef_priv {
184    pub p: gpointer,
185}
186
187impl ::std::fmt::Debug for GWeakRef_priv {
188    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
189        f.debug_struct(&format!("GWeakRef_priv @ {:?}", self as *const _))
190            .field("p", unsafe { &self.p })
191            .finish()
192    }
193}
194
195// Callbacks
196pub type GBaseFinalizeFunc = Option<unsafe extern "C" fn(gpointer)>;
197pub type GBaseInitFunc = Option<unsafe extern "C" fn(gpointer)>;
198pub type GBindingTransformFunc =
199    Option<unsafe extern "C" fn(*mut GBinding, *const GValue, *mut GValue, gpointer) -> gboolean>;
200pub type GBoxedCopyFunc = Option<unsafe extern "C" fn(gpointer) -> gpointer>;
201pub type GBoxedFreeFunc = Option<unsafe extern "C" fn(gpointer)>;
202pub type GCallback = Option<unsafe extern "C" fn()>;
203pub type GClassFinalizeFunc = Option<unsafe extern "C" fn(gpointer, gpointer)>;
204pub type GClassInitFunc = Option<unsafe extern "C" fn(gpointer, gpointer)>;
205pub type GClosureMarshal = Option<
206    unsafe extern "C" fn(*mut GClosure, *mut GValue, c_uint, *const GValue, gpointer, gpointer),
207>;
208pub type GClosureNotify = Option<unsafe extern "C" fn(gpointer, *mut GClosure)>;
209pub type GInstanceInitFunc = Option<unsafe extern "C" fn(*mut GTypeInstance, gpointer)>;
210pub type GInterfaceFinalizeFunc = Option<unsafe extern "C" fn(gpointer, gpointer)>;
211pub type GInterfaceInitFunc = Option<unsafe extern "C" fn(gpointer, gpointer)>;
212pub type GObjectFinalizeFunc = Option<unsafe extern "C" fn(*mut GObject)>;
213pub type GObjectGetPropertyFunc =
214    Option<unsafe extern "C" fn(*mut GObject, c_uint, *mut GValue, *mut GParamSpec)>;
215pub type GObjectSetPropertyFunc =
216    Option<unsafe extern "C" fn(*mut GObject, c_uint, *const GValue, *mut GParamSpec)>;
217pub type GSignalAccumulator = Option<
218    unsafe extern "C" fn(
219        *mut GSignalInvocationHint,
220        *mut GValue,
221        *const GValue,
222        gpointer,
223    ) -> gboolean,
224>;
225pub type GSignalEmissionHook = Option<
226    unsafe extern "C" fn(*mut GSignalInvocationHint, c_uint, *const GValue, gpointer) -> gboolean,
227>;
228pub type GToggleNotify = Option<unsafe extern "C" fn(gpointer, *mut GObject, gboolean)>;
229pub type GTypeClassCacheFunc = Option<unsafe extern "C" fn(gpointer, *mut GTypeClass) -> gboolean>;
230pub type GTypeInterfaceCheckFunc = Option<unsafe extern "C" fn(gpointer, gpointer)>;
231pub type GTypePluginCompleteInterfaceInfo =
232    Option<unsafe extern "C" fn(*mut GTypePlugin, GType, GType, *mut GInterfaceInfo)>;
233pub type GTypePluginCompleteTypeInfo =
234    Option<unsafe extern "C" fn(*mut GTypePlugin, GType, *mut GTypeInfo, *mut GTypeValueTable)>;
235pub type GTypePluginUnuse = Option<unsafe extern "C" fn(*mut GTypePlugin)>;
236pub type GTypePluginUse = Option<unsafe extern "C" fn(*mut GTypePlugin)>;
237//pub type GVaClosureMarshal = Option<unsafe extern "C" fn(*mut GClosure, *mut GValue, gpointer, /*Unimplemented*/va_list, gpointer, c_int, *mut GType)>;
238pub type GValueTransform = Option<unsafe extern "C" fn(*const GValue, *mut GValue)>;
239pub type GWeakNotify = Option<unsafe extern "C" fn(gpointer, *mut GObject)>;
240
241// Records
242#[repr(C)]
243pub struct GCClosure {
244    _truncated_record_marker: c_void,
245    // /*Ignored*/field closure has incomplete type
246}
247
248impl ::std::fmt::Debug for GCClosure {
249    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
250        f.debug_struct(&format!("GCClosure @ {:?}", self as *const _))
251            .finish()
252    }
253}
254
255#[repr(C)]
256pub struct GClosure {
257    pub ref_count: c_uint,
258    _truncated_record_marker: c_void,
259    // field meta_marshal_nouse has incomplete type
260}
261
262impl ::std::fmt::Debug for GClosure {
263    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
264        f.debug_struct(&format!("GClosure @ {:?}", self as *const _))
265            .finish()
266    }
267}
268
269#[repr(C)]
270#[derive(Copy, Clone)]
271pub struct GClosureNotifyData {
272    pub data: gpointer,
273    pub notify: GClosureNotify,
274}
275
276impl ::std::fmt::Debug for GClosureNotifyData {
277    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
278        f.debug_struct(&format!("GClosureNotifyData @ {:?}", self as *const _))
279            .field("data", &self.data)
280            .field("notify", &self.notify)
281            .finish()
282    }
283}
284
285#[repr(C)]
286#[derive(Copy, Clone)]
287pub struct GEnumClass {
288    pub g_type_class: GTypeClass,
289    pub minimum: c_int,
290    pub maximum: c_int,
291    pub n_values: c_uint,
292    pub values: *mut GEnumValue,
293}
294
295impl ::std::fmt::Debug for GEnumClass {
296    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
297        f.debug_struct(&format!("GEnumClass @ {:?}", self as *const _))
298            .field("g_type_class", &self.g_type_class)
299            .field("minimum", &self.minimum)
300            .field("maximum", &self.maximum)
301            .field("n_values", &self.n_values)
302            .field("values", &self.values)
303            .finish()
304    }
305}
306
307#[repr(C)]
308#[derive(Copy, Clone)]
309pub struct GEnumValue {
310    pub value: c_int,
311    pub value_name: *const c_char,
312    pub value_nick: *const c_char,
313}
314
315impl ::std::fmt::Debug for GEnumValue {
316    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
317        f.debug_struct(&format!("GEnumValue @ {:?}", self as *const _))
318            .field("value", &self.value)
319            .field("value_name", &self.value_name)
320            .field("value_nick", &self.value_nick)
321            .finish()
322    }
323}
324
325#[repr(C)]
326#[derive(Copy, Clone)]
327pub struct GFlagsClass {
328    pub g_type_class: GTypeClass,
329    pub mask: c_uint,
330    pub n_values: c_uint,
331    pub values: *mut GFlagsValue,
332}
333
334impl ::std::fmt::Debug for GFlagsClass {
335    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
336        f.debug_struct(&format!("GFlagsClass @ {:?}", self as *const _))
337            .field("g_type_class", &self.g_type_class)
338            .field("mask", &self.mask)
339            .field("n_values", &self.n_values)
340            .field("values", &self.values)
341            .finish()
342    }
343}
344
345#[repr(C)]
346#[derive(Copy, Clone)]
347pub struct GFlagsValue {
348    pub value: c_uint,
349    pub value_name: *const c_char,
350    pub value_nick: *const c_char,
351}
352
353impl ::std::fmt::Debug for GFlagsValue {
354    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
355        f.debug_struct(&format!("GFlagsValue @ {:?}", self as *const _))
356            .field("value", &self.value)
357            .field("value_name", &self.value_name)
358            .field("value_nick", &self.value_nick)
359            .finish()
360    }
361}
362
363#[repr(C)]
364#[derive(Copy, Clone)]
365pub struct GInitiallyUnownedClass {
366    pub g_type_class: GTypeClass,
367    pub construct_properties: *mut glib::GSList,
368    pub constructor:
369        Option<unsafe extern "C" fn(GType, c_uint, *mut GObjectConstructParam) -> *mut GObject>,
370    pub set_property:
371        Option<unsafe extern "C" fn(*mut GObject, c_uint, *mut GValue, *mut GParamSpec)>,
372    pub get_property:
373        Option<unsafe extern "C" fn(*mut GObject, c_uint, *mut GValue, *mut GParamSpec)>,
374    pub dispose: Option<unsafe extern "C" fn(*mut GObject)>,
375    pub finalize: Option<unsafe extern "C" fn(*mut GObject)>,
376    pub dispatch_properties_changed:
377        Option<unsafe extern "C" fn(*mut GObject, c_uint, *mut *mut GParamSpec)>,
378    pub notify: Option<unsafe extern "C" fn(*mut GObject, *mut GParamSpec)>,
379    pub constructed: Option<unsafe extern "C" fn(*mut GObject)>,
380    pub flags: size_t,
381    pub pdummy: [gpointer; 6],
382}
383
384impl ::std::fmt::Debug for GInitiallyUnownedClass {
385    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
386        f.debug_struct(&format!("GInitiallyUnownedClass @ {:?}", self as *const _))
387            .field("g_type_class", &self.g_type_class)
388            .field("constructor", &self.constructor)
389            .field("set_property", &self.set_property)
390            .field("get_property", &self.get_property)
391            .field("dispose", &self.dispose)
392            .field("finalize", &self.finalize)
393            .field(
394                "dispatch_properties_changed",
395                &self.dispatch_properties_changed,
396            )
397            .field("notify", &self.notify)
398            .field("constructed", &self.constructed)
399            .finish()
400    }
401}
402
403#[repr(C)]
404#[derive(Copy, Clone)]
405pub struct GInterfaceInfo {
406    pub interface_init: GInterfaceInitFunc,
407    pub interface_finalize: GInterfaceFinalizeFunc,
408    pub interface_data: gpointer,
409}
410
411impl ::std::fmt::Debug for GInterfaceInfo {
412    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
413        f.debug_struct(&format!("GInterfaceInfo @ {:?}", self as *const _))
414            .field("interface_init", &self.interface_init)
415            .field("interface_finalize", &self.interface_finalize)
416            .field("interface_data", &self.interface_data)
417            .finish()
418    }
419}
420
421#[repr(C)]
422#[derive(Copy, Clone)]
423pub struct GObjectClass {
424    pub g_type_class: GTypeClass,
425    pub construct_properties: *mut glib::GSList,
426    pub constructor:
427        Option<unsafe extern "C" fn(GType, c_uint, *mut GObjectConstructParam) -> *mut GObject>,
428    pub set_property:
429        Option<unsafe extern "C" fn(*mut GObject, c_uint, *mut GValue, *mut GParamSpec)>,
430    pub get_property:
431        Option<unsafe extern "C" fn(*mut GObject, c_uint, *mut GValue, *mut GParamSpec)>,
432    pub dispose: Option<unsafe extern "C" fn(*mut GObject)>,
433    pub finalize: Option<unsafe extern "C" fn(*mut GObject)>,
434    pub dispatch_properties_changed:
435        Option<unsafe extern "C" fn(*mut GObject, c_uint, *mut *mut GParamSpec)>,
436    pub notify: Option<unsafe extern "C" fn(*mut GObject, *mut GParamSpec)>,
437    pub constructed: Option<unsafe extern "C" fn(*mut GObject)>,
438    pub flags: size_t,
439    pub pdummy: [gpointer; 6],
440}
441
442impl ::std::fmt::Debug for GObjectClass {
443    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
444        f.debug_struct(&format!("GObjectClass @ {:?}", self as *const _))
445            .field("g_type_class", &self.g_type_class)
446            .field("constructor", &self.constructor)
447            .field("set_property", &self.set_property)
448            .field("get_property", &self.get_property)
449            .field("dispose", &self.dispose)
450            .field("finalize", &self.finalize)
451            .field(
452                "dispatch_properties_changed",
453                &self.dispatch_properties_changed,
454            )
455            .field("notify", &self.notify)
456            .field("constructed", &self.constructed)
457            .finish()
458    }
459}
460
461#[repr(C)]
462#[derive(Copy, Clone)]
463pub struct GObjectConstructParam {
464    pub pspec: *mut GParamSpec,
465    pub value: *mut GValue,
466}
467
468impl ::std::fmt::Debug for GObjectConstructParam {
469    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
470        f.debug_struct(&format!("GObjectConstructParam @ {:?}", self as *const _))
471            .field("pspec", &self.pspec)
472            .field("value", &self.value)
473            .finish()
474    }
475}
476
477#[repr(C)]
478#[derive(Copy, Clone)]
479pub struct GParamSpecClass {
480    pub g_type_class: GTypeClass,
481    pub value_type: GType,
482    pub finalize: Option<unsafe extern "C" fn(*mut GParamSpec)>,
483    pub value_set_default: Option<unsafe extern "C" fn(*mut GParamSpec, *mut GValue)>,
484    pub value_validate: Option<unsafe extern "C" fn(*mut GParamSpec, *mut GValue) -> gboolean>,
485    pub values_cmp:
486        Option<unsafe extern "C" fn(*mut GParamSpec, *const GValue, *const GValue) -> c_int>,
487    pub dummy: [gpointer; 4],
488}
489
490impl ::std::fmt::Debug for GParamSpecClass {
491    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
492        f.debug_struct(&format!("GParamSpecClass @ {:?}", self as *const _))
493            .field("g_type_class", &self.g_type_class)
494            .field("value_type", &self.value_type)
495            .field("finalize", &self.finalize)
496            .field("value_set_default", &self.value_set_default)
497            .field("value_validate", &self.value_validate)
498            .field("values_cmp", &self.values_cmp)
499            .finish()
500    }
501}
502
503#[repr(C)]
504pub struct _GParamSpecPool(c_void);
505
506pub type GParamSpecPool = *mut _GParamSpecPool;
507
508#[repr(C)]
509#[derive(Copy, Clone)]
510pub struct GParamSpecTypeInfo {
511    pub instance_size: u16,
512    pub n_preallocs: u16,
513    pub instance_init: Option<unsafe extern "C" fn(*mut GParamSpec)>,
514    pub value_type: GType,
515    pub finalize: Option<unsafe extern "C" fn(*mut GParamSpec)>,
516    pub value_set_default: Option<unsafe extern "C" fn(*mut GParamSpec, *mut GValue)>,
517    pub value_validate: Option<unsafe extern "C" fn(*mut GParamSpec, *mut GValue) -> gboolean>,
518    pub values_cmp:
519        Option<unsafe extern "C" fn(*mut GParamSpec, *const GValue, *const GValue) -> c_int>,
520}
521
522impl ::std::fmt::Debug for GParamSpecTypeInfo {
523    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
524        f.debug_struct(&format!("GParamSpecTypeInfo @ {:?}", self as *const _))
525            .field("instance_size", &self.instance_size)
526            .field("n_preallocs", &self.n_preallocs)
527            .field("instance_init", &self.instance_init)
528            .field("value_type", &self.value_type)
529            .field("finalize", &self.finalize)
530            .field("value_set_default", &self.value_set_default)
531            .field("value_validate", &self.value_validate)
532            .field("values_cmp", &self.values_cmp)
533            .finish()
534    }
535}
536
537#[repr(C)]
538#[derive(Copy, Clone)]
539pub struct GParameter {
540    pub name: *const c_char,
541    pub value: GValue,
542}
543
544impl ::std::fmt::Debug for GParameter {
545    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
546        f.debug_struct(&format!("GParameter @ {:?}", self as *const _))
547            .field("name", &self.name)
548            .field("value", &self.value)
549            .finish()
550    }
551}
552
553#[repr(C)]
554#[derive(Copy, Clone)]
555pub struct GSignalInvocationHint {
556    pub signal_id: c_uint,
557    pub detail: glib::GQuark,
558    pub run_type: GSignalFlags,
559}
560
561impl ::std::fmt::Debug for GSignalInvocationHint {
562    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
563        f.debug_struct(&format!("GSignalInvocationHint @ {:?}", self as *const _))
564            .field("signal_id", &self.signal_id)
565            .field("detail", &self.detail)
566            .field("run_type", &self.run_type)
567            .finish()
568    }
569}
570
571#[repr(C)]
572#[derive(Copy, Clone)]
573pub struct GSignalQuery {
574    pub signal_id: c_uint,
575    pub signal_name: *const c_char,
576    pub itype: GType,
577    pub signal_flags: GSignalFlags,
578    pub return_type: GType,
579    pub n_params: c_uint,
580    pub param_types: *const GType,
581}
582
583impl ::std::fmt::Debug for GSignalQuery {
584    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
585        f.debug_struct(&format!("GSignalQuery @ {:?}", self as *const _))
586            .field("signal_id", &self.signal_id)
587            .field("signal_name", &self.signal_name)
588            .field("itype", &self.itype)
589            .field("signal_flags", &self.signal_flags)
590            .field("return_type", &self.return_type)
591            .field("n_params", &self.n_params)
592            .field("param_types", &self.param_types)
593            .finish()
594    }
595}
596
597#[repr(C)]
598#[derive(Copy, Clone)]
599pub struct GTypeClass {
600    pub g_type: GType,
601}
602
603impl ::std::fmt::Debug for GTypeClass {
604    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
605        f.debug_struct(&format!("GTypeClass @ {:?}", self as *const _))
606            .finish()
607    }
608}
609
610#[repr(C)]
611#[derive(Copy, Clone)]
612pub struct GTypeFundamentalInfo {
613    pub type_flags: GTypeFundamentalFlags,
614}
615
616impl ::std::fmt::Debug for GTypeFundamentalInfo {
617    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
618        f.debug_struct(&format!("GTypeFundamentalInfo @ {:?}", self as *const _))
619            .field("type_flags", &self.type_flags)
620            .finish()
621    }
622}
623
624#[repr(C)]
625#[derive(Copy, Clone)]
626pub struct GTypeInfo {
627    pub class_size: u16,
628    pub base_init: GBaseInitFunc,
629    pub base_finalize: GBaseFinalizeFunc,
630    pub class_init: GClassInitFunc,
631    pub class_finalize: GClassFinalizeFunc,
632    pub class_data: gconstpointer,
633    pub instance_size: u16,
634    pub n_preallocs: u16,
635    pub instance_init: GInstanceInitFunc,
636    pub value_table: *const GTypeValueTable,
637}
638
639impl ::std::fmt::Debug for GTypeInfo {
640    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
641        f.debug_struct(&format!("GTypeInfo @ {:?}", self as *const _))
642            .field("class_size", &self.class_size)
643            .field("base_init", &self.base_init)
644            .field("base_finalize", &self.base_finalize)
645            .field("class_init", &self.class_init)
646            .field("class_finalize", &self.class_finalize)
647            .field("class_data", &self.class_data)
648            .field("instance_size", &self.instance_size)
649            .field("n_preallocs", &self.n_preallocs)
650            .field("instance_init", &self.instance_init)
651            .field("value_table", &self.value_table)
652            .finish()
653    }
654}
655
656#[repr(C)]
657#[derive(Copy, Clone)]
658pub struct GTypeInstance {
659    pub g_class: *mut GTypeClass,
660}
661
662impl ::std::fmt::Debug for GTypeInstance {
663    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
664        f.debug_struct(&format!("GTypeInstance @ {:?}", self as *const _))
665            .finish()
666    }
667}
668
669#[repr(C)]
670#[derive(Copy, Clone)]
671pub struct GTypeInterface {
672    pub g_type: GType,
673    pub g_instance_type: GType,
674}
675
676impl ::std::fmt::Debug for GTypeInterface {
677    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
678        f.debug_struct(&format!("GTypeInterface @ {:?}", self as *const _))
679            .finish()
680    }
681}
682
683#[repr(C)]
684#[derive(Copy, Clone)]
685pub struct GTypeModuleClass {
686    pub parent_class: GObjectClass,
687    pub load: Option<unsafe extern "C" fn(*mut GTypeModule) -> gboolean>,
688    pub unload: Option<unsafe extern "C" fn(*mut GTypeModule)>,
689    pub reserved1: Option<unsafe extern "C" fn()>,
690    pub reserved2: Option<unsafe extern "C" fn()>,
691    pub reserved3: Option<unsafe extern "C" fn()>,
692    pub reserved4: Option<unsafe extern "C" fn()>,
693}
694
695impl ::std::fmt::Debug for GTypeModuleClass {
696    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
697        f.debug_struct(&format!("GTypeModuleClass @ {:?}", self as *const _))
698            .field("parent_class", &self.parent_class)
699            .field("load", &self.load)
700            .field("unload", &self.unload)
701            .field("reserved1", &self.reserved1)
702            .field("reserved2", &self.reserved2)
703            .field("reserved3", &self.reserved3)
704            .field("reserved4", &self.reserved4)
705            .finish()
706    }
707}
708
709#[repr(C)]
710#[derive(Copy, Clone)]
711pub struct GTypePluginClass {
712    pub base_iface: GTypeInterface,
713    pub use_plugin: GTypePluginUse,
714    pub unuse_plugin: GTypePluginUnuse,
715    pub complete_type_info: GTypePluginCompleteTypeInfo,
716    pub complete_interface_info: GTypePluginCompleteInterfaceInfo,
717}
718
719impl ::std::fmt::Debug for GTypePluginClass {
720    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
721        f.debug_struct(&format!("GTypePluginClass @ {:?}", self as *const _))
722            .field("use_plugin", &self.use_plugin)
723            .field("unuse_plugin", &self.unuse_plugin)
724            .field("complete_type_info", &self.complete_type_info)
725            .field("complete_interface_info", &self.complete_interface_info)
726            .finish()
727    }
728}
729
730#[repr(C)]
731#[derive(Copy, Clone)]
732pub struct GTypeQuery {
733    pub type_: GType,
734    pub type_name: *const c_char,
735    pub class_size: c_uint,
736    pub instance_size: c_uint,
737}
738
739impl ::std::fmt::Debug for GTypeQuery {
740    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
741        f.debug_struct(&format!("GTypeQuery @ {:?}", self as *const _))
742            .field("type_", &self.type_)
743            .field("type_name", &self.type_name)
744            .field("class_size", &self.class_size)
745            .field("instance_size", &self.instance_size)
746            .finish()
747    }
748}
749
750#[repr(C)]
751#[derive(Copy, Clone)]
752pub struct GTypeValueTable {
753    pub value_init: Option<unsafe extern "C" fn(*mut GValue)>,
754    pub value_free: Option<unsafe extern "C" fn(*mut GValue)>,
755    pub value_copy: Option<unsafe extern "C" fn(*const GValue, *mut GValue)>,
756    pub value_peek_pointer: Option<unsafe extern "C" fn(*const GValue) -> gpointer>,
757    pub collect_format: *const c_char,
758    pub collect_value: Option<
759        unsafe extern "C" fn(*const GValue, c_uint, *mut GTypeCValue, c_uint) -> *mut c_char,
760    >,
761    pub lcopy_format: *const c_char,
762    pub lcopy_value: Option<
763        unsafe extern "C" fn(*const GValue, c_uint, *mut GTypeCValue, c_uint) -> *mut c_char,
764    >,
765}
766
767impl ::std::fmt::Debug for GTypeValueTable {
768    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
769        f.debug_struct(&format!("GTypeValueTable @ {:?}", self as *const _))
770            .field("value_init", &self.value_init)
771            .field("value_free", &self.value_free)
772            .field("value_copy", &self.value_copy)
773            .field("value_peek_pointer", &self.value_peek_pointer)
774            .field("collect_format", &self.collect_format)
775            .field("collect_value", &self.collect_value)
776            .field("lcopy_format", &self.lcopy_format)
777            .field("lcopy_value", &self.lcopy_value)
778            .finish()
779    }
780}
781
782#[repr(C)]
783#[derive(Copy, Clone)]
784pub struct GValue {
785    pub g_type: GType,
786    pub data: [GValue_data; 2],
787}
788
789impl ::std::fmt::Debug for GValue {
790    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
791        f.debug_struct(&format!("GValue @ {:?}", self as *const _))
792            .field("data", &self.data)
793            .finish()
794    }
795}
796
797#[repr(C)]
798#[derive(Copy, Clone)]
799pub struct GValueArray {
800    pub n_values: c_uint,
801    pub values: *mut GValue,
802    pub n_prealloced: c_uint,
803}
804
805impl ::std::fmt::Debug for GValueArray {
806    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
807        f.debug_struct(&format!("GValueArray @ {:?}", self as *const _))
808            .field("n_values", &self.n_values)
809            .field("values", &self.values)
810            .finish()
811    }
812}
813
814#[repr(C)]
815#[derive(Copy, Clone)]
816pub struct GWeakRef {
817    pub priv_: GWeakRef_priv,
818}
819
820impl ::std::fmt::Debug for GWeakRef {
821    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
822        f.debug_struct(&format!("GWeakRef @ {:?}", self as *const _))
823            .field("priv_", &self.priv_)
824            .finish()
825    }
826}
827
828// Classes
829#[repr(C)]
830pub struct GBinding(c_void);
831
832impl ::std::fmt::Debug for GBinding {
833    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
834        f.debug_struct(&format!("GBinding @ {:?}", self as *const _))
835            .finish()
836    }
837}
838
839#[repr(C)]
840#[derive(Copy, Clone)]
841pub struct GInitiallyUnowned {
842    pub g_type_instance: GTypeInstance,
843    pub ref_count: c_uint,
844    pub qdata: *mut glib::GData,
845}
846
847impl ::std::fmt::Debug for GInitiallyUnowned {
848    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
849        f.debug_struct(&format!("GInitiallyUnowned @ {:?}", self as *const _))
850            .field("g_type_instance", &self.g_type_instance)
851            .finish()
852    }
853}
854
855#[repr(C)]
856#[derive(Copy, Clone)]
857pub struct GObject {
858    pub g_type_instance: GTypeInstance,
859    pub ref_count: c_uint,
860    pub qdata: *mut glib::GData,
861}
862
863impl ::std::fmt::Debug for GObject {
864    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
865        f.debug_struct(&format!("GObject @ {:?}", self as *const _))
866            .field("g_type_instance", &self.g_type_instance)
867            .finish()
868    }
869}
870
871#[repr(C)]
872#[derive(Copy, Clone)]
873pub struct GParamSpec {
874    pub g_type_instance: GTypeInstance,
875    pub name: *const c_char,
876    pub flags: GParamFlags,
877    pub value_type: GType,
878    pub owner_type: GType,
879    pub _nick: *mut c_char,
880    pub _blurb: *mut c_char,
881    pub qdata: *mut glib::GData,
882    pub ref_count: c_uint,
883    pub param_id: c_uint,
884}
885
886impl ::std::fmt::Debug for GParamSpec {
887    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
888        f.debug_struct(&format!("GParamSpec @ {:?}", self as *const _))
889            .field("g_type_instance", &self.g_type_instance)
890            .field("name", &self.name)
891            .field("flags", &self.flags)
892            .field("value_type", &self.value_type)
893            .field("owner_type", &self.owner_type)
894            .finish()
895    }
896}
897
898#[repr(C)]
899#[derive(Copy, Clone)]
900pub struct GParamSpecBoolean {
901    pub parent_instance: GParamSpec,
902    pub default_value: gboolean,
903}
904
905impl ::std::fmt::Debug for GParamSpecBoolean {
906    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
907        f.debug_struct(&format!("GParamSpecBoolean @ {:?}", self as *const _))
908            .field("parent_instance", &self.parent_instance)
909            .field("default_value", &self.default_value)
910            .finish()
911    }
912}
913
914#[repr(C)]
915#[derive(Copy, Clone)]
916pub struct GParamSpecBoxed {
917    pub parent_instance: GParamSpec,
918}
919
920impl ::std::fmt::Debug for GParamSpecBoxed {
921    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
922        f.debug_struct(&format!("GParamSpecBoxed @ {:?}", self as *const _))
923            .field("parent_instance", &self.parent_instance)
924            .finish()
925    }
926}
927
928#[repr(C)]
929#[derive(Copy, Clone)]
930pub struct GParamSpecChar {
931    pub parent_instance: GParamSpec,
932    pub minimum: i8,
933    pub maximum: i8,
934    pub default_value: i8,
935}
936
937impl ::std::fmt::Debug for GParamSpecChar {
938    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
939        f.debug_struct(&format!("GParamSpecChar @ {:?}", self as *const _))
940            .field("parent_instance", &self.parent_instance)
941            .field("minimum", &self.minimum)
942            .field("maximum", &self.maximum)
943            .field("default_value", &self.default_value)
944            .finish()
945    }
946}
947
948#[repr(C)]
949#[derive(Copy, Clone)]
950pub struct GParamSpecDouble {
951    pub parent_instance: GParamSpec,
952    pub minimum: c_double,
953    pub maximum: c_double,
954    pub default_value: c_double,
955    pub epsilon: c_double,
956}
957
958impl ::std::fmt::Debug for GParamSpecDouble {
959    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
960        f.debug_struct(&format!("GParamSpecDouble @ {:?}", self as *const _))
961            .field("parent_instance", &self.parent_instance)
962            .field("minimum", &self.minimum)
963            .field("maximum", &self.maximum)
964            .field("default_value", &self.default_value)
965            .field("epsilon", &self.epsilon)
966            .finish()
967    }
968}
969
970#[repr(C)]
971#[derive(Copy, Clone)]
972pub struct GParamSpecEnum {
973    pub parent_instance: GParamSpec,
974    pub enum_class: *mut GEnumClass,
975    pub default_value: c_int,
976}
977
978impl ::std::fmt::Debug for GParamSpecEnum {
979    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
980        f.debug_struct(&format!("GParamSpecEnum @ {:?}", self as *const _))
981            .field("parent_instance", &self.parent_instance)
982            .field("enum_class", &self.enum_class)
983            .field("default_value", &self.default_value)
984            .finish()
985    }
986}
987
988#[repr(C)]
989#[derive(Copy, Clone)]
990pub struct GParamSpecFlags {
991    pub parent_instance: GParamSpec,
992    pub flags_class: *mut GFlagsClass,
993    pub default_value: c_uint,
994}
995
996impl ::std::fmt::Debug for GParamSpecFlags {
997    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
998        f.debug_struct(&format!("GParamSpecFlags @ {:?}", self as *const _))
999            .field("parent_instance", &self.parent_instance)
1000            .field("flags_class", &self.flags_class)
1001            .field("default_value", &self.default_value)
1002            .finish()
1003    }
1004}
1005
1006#[repr(C)]
1007#[derive(Copy, Clone)]
1008pub struct GParamSpecFloat {
1009    pub parent_instance: GParamSpec,
1010    pub minimum: c_float,
1011    pub maximum: c_float,
1012    pub default_value: c_float,
1013    pub epsilon: c_float,
1014}
1015
1016impl ::std::fmt::Debug for GParamSpecFloat {
1017    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1018        f.debug_struct(&format!("GParamSpecFloat @ {:?}", self as *const _))
1019            .field("parent_instance", &self.parent_instance)
1020            .field("minimum", &self.minimum)
1021            .field("maximum", &self.maximum)
1022            .field("default_value", &self.default_value)
1023            .field("epsilon", &self.epsilon)
1024            .finish()
1025    }
1026}
1027
1028#[repr(C)]
1029#[derive(Copy, Clone)]
1030pub struct GParamSpecGType {
1031    pub parent_instance: GParamSpec,
1032    pub is_a_type: GType,
1033}
1034
1035impl ::std::fmt::Debug for GParamSpecGType {
1036    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1037        f.debug_struct(&format!("GParamSpecGType @ {:?}", self as *const _))
1038            .field("parent_instance", &self.parent_instance)
1039            .field("is_a_type", &self.is_a_type)
1040            .finish()
1041    }
1042}
1043
1044#[repr(C)]
1045#[derive(Copy, Clone)]
1046pub struct GParamSpecInt {
1047    pub parent_instance: GParamSpec,
1048    pub minimum: c_int,
1049    pub maximum: c_int,
1050    pub default_value: c_int,
1051}
1052
1053impl ::std::fmt::Debug for GParamSpecInt {
1054    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1055        f.debug_struct(&format!("GParamSpecInt @ {:?}", self as *const _))
1056            .field("parent_instance", &self.parent_instance)
1057            .field("minimum", &self.minimum)
1058            .field("maximum", &self.maximum)
1059            .field("default_value", &self.default_value)
1060            .finish()
1061    }
1062}
1063
1064#[repr(C)]
1065#[derive(Copy, Clone)]
1066pub struct GParamSpecInt64 {
1067    pub parent_instance: GParamSpec,
1068    pub minimum: i64,
1069    pub maximum: i64,
1070    pub default_value: i64,
1071}
1072
1073impl ::std::fmt::Debug for GParamSpecInt64 {
1074    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1075        f.debug_struct(&format!("GParamSpecInt64 @ {:?}", self as *const _))
1076            .field("parent_instance", &self.parent_instance)
1077            .field("minimum", &self.minimum)
1078            .field("maximum", &self.maximum)
1079            .field("default_value", &self.default_value)
1080            .finish()
1081    }
1082}
1083
1084#[repr(C)]
1085#[derive(Copy, Clone)]
1086pub struct GParamSpecLong {
1087    pub parent_instance: GParamSpec,
1088    pub minimum: c_long,
1089    pub maximum: c_long,
1090    pub default_value: c_long,
1091}
1092
1093impl ::std::fmt::Debug for GParamSpecLong {
1094    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1095        f.debug_struct(&format!("GParamSpecLong @ {:?}", self as *const _))
1096            .field("parent_instance", &self.parent_instance)
1097            .field("minimum", &self.minimum)
1098            .field("maximum", &self.maximum)
1099            .field("default_value", &self.default_value)
1100            .finish()
1101    }
1102}
1103
1104#[repr(C)]
1105#[derive(Copy, Clone)]
1106pub struct GParamSpecObject {
1107    pub parent_instance: GParamSpec,
1108}
1109
1110impl ::std::fmt::Debug for GParamSpecObject {
1111    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1112        f.debug_struct(&format!("GParamSpecObject @ {:?}", self as *const _))
1113            .field("parent_instance", &self.parent_instance)
1114            .finish()
1115    }
1116}
1117
1118#[repr(C)]
1119#[derive(Copy, Clone)]
1120pub struct GParamSpecOverride {
1121    pub parent_instance: GParamSpec,
1122    pub overridden: *mut GParamSpec,
1123}
1124
1125impl ::std::fmt::Debug for GParamSpecOverride {
1126    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1127        f.debug_struct(&format!("GParamSpecOverride @ {:?}", self as *const _))
1128            .finish()
1129    }
1130}
1131
1132#[repr(C)]
1133#[derive(Copy, Clone)]
1134pub struct GParamSpecParam {
1135    pub parent_instance: GParamSpec,
1136}
1137
1138impl ::std::fmt::Debug for GParamSpecParam {
1139    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1140        f.debug_struct(&format!("GParamSpecParam @ {:?}", self as *const _))
1141            .field("parent_instance", &self.parent_instance)
1142            .finish()
1143    }
1144}
1145
1146#[repr(C)]
1147#[derive(Copy, Clone)]
1148pub struct GParamSpecPointer {
1149    pub parent_instance: GParamSpec,
1150}
1151
1152impl ::std::fmt::Debug for GParamSpecPointer {
1153    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1154        f.debug_struct(&format!("GParamSpecPointer @ {:?}", self as *const _))
1155            .field("parent_instance", &self.parent_instance)
1156            .finish()
1157    }
1158}
1159
1160#[repr(C)]
1161pub struct GParamSpecString {
1162    pub parent_instance: GParamSpec,
1163    pub default_value: *mut c_char,
1164    pub cset_first: *mut c_char,
1165    pub cset_nth: *mut c_char,
1166    pub substitutor: c_char,
1167    pub null_fold_if_empty: c_uint,
1168    _truncated_record_marker: c_void,
1169    // field ensure_non_null has incomplete type
1170}
1171
1172impl ::std::fmt::Debug for GParamSpecString {
1173    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1174        f.debug_struct(&format!("GParamSpecString @ {:?}", self as *const _))
1175            .field("parent_instance", &self.parent_instance)
1176            .field("default_value", &self.default_value)
1177            .field("cset_first", &self.cset_first)
1178            .field("cset_nth", &self.cset_nth)
1179            .field("substitutor", &self.substitutor)
1180            .field("null_fold_if_empty", &self.null_fold_if_empty)
1181            .finish()
1182    }
1183}
1184
1185#[repr(C)]
1186#[derive(Copy, Clone)]
1187pub struct GParamSpecUChar {
1188    pub parent_instance: GParamSpec,
1189    pub minimum: u8,
1190    pub maximum: u8,
1191    pub default_value: u8,
1192}
1193
1194impl ::std::fmt::Debug for GParamSpecUChar {
1195    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1196        f.debug_struct(&format!("GParamSpecUChar @ {:?}", self as *const _))
1197            .field("parent_instance", &self.parent_instance)
1198            .field("minimum", &self.minimum)
1199            .field("maximum", &self.maximum)
1200            .field("default_value", &self.default_value)
1201            .finish()
1202    }
1203}
1204
1205#[repr(C)]
1206#[derive(Copy, Clone)]
1207pub struct GParamSpecUInt {
1208    pub parent_instance: GParamSpec,
1209    pub minimum: c_uint,
1210    pub maximum: c_uint,
1211    pub default_value: c_uint,
1212}
1213
1214impl ::std::fmt::Debug for GParamSpecUInt {
1215    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1216        f.debug_struct(&format!("GParamSpecUInt @ {:?}", self as *const _))
1217            .field("parent_instance", &self.parent_instance)
1218            .field("minimum", &self.minimum)
1219            .field("maximum", &self.maximum)
1220            .field("default_value", &self.default_value)
1221            .finish()
1222    }
1223}
1224
1225#[repr(C)]
1226#[derive(Copy, Clone)]
1227pub struct GParamSpecUInt64 {
1228    pub parent_instance: GParamSpec,
1229    pub minimum: u64,
1230    pub maximum: u64,
1231    pub default_value: u64,
1232}
1233
1234impl ::std::fmt::Debug for GParamSpecUInt64 {
1235    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1236        f.debug_struct(&format!("GParamSpecUInt64 @ {:?}", self as *const _))
1237            .field("parent_instance", &self.parent_instance)
1238            .field("minimum", &self.minimum)
1239            .field("maximum", &self.maximum)
1240            .field("default_value", &self.default_value)
1241            .finish()
1242    }
1243}
1244
1245#[repr(C)]
1246#[derive(Copy, Clone)]
1247pub struct GParamSpecULong {
1248    pub parent_instance: GParamSpec,
1249    pub minimum: c_ulong,
1250    pub maximum: c_ulong,
1251    pub default_value: c_ulong,
1252}
1253
1254impl ::std::fmt::Debug for GParamSpecULong {
1255    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1256        f.debug_struct(&format!("GParamSpecULong @ {:?}", self as *const _))
1257            .field("parent_instance", &self.parent_instance)
1258            .field("minimum", &self.minimum)
1259            .field("maximum", &self.maximum)
1260            .field("default_value", &self.default_value)
1261            .finish()
1262    }
1263}
1264
1265#[repr(C)]
1266#[derive(Copy, Clone)]
1267pub struct GParamSpecUnichar {
1268    pub parent_instance: GParamSpec,
1269    pub default_value: u32,
1270}
1271
1272impl ::std::fmt::Debug for GParamSpecUnichar {
1273    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1274        f.debug_struct(&format!("GParamSpecUnichar @ {:?}", self as *const _))
1275            .field("parent_instance", &self.parent_instance)
1276            .field("default_value", &self.default_value)
1277            .finish()
1278    }
1279}
1280
1281#[repr(C)]
1282#[derive(Copy, Clone)]
1283pub struct GParamSpecValueArray {
1284    pub parent_instance: GParamSpec,
1285    pub element_spec: *mut GParamSpec,
1286    pub fixed_n_elements: c_uint,
1287}
1288
1289impl ::std::fmt::Debug for GParamSpecValueArray {
1290    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1291        f.debug_struct(&format!("GParamSpecValueArray @ {:?}", self as *const _))
1292            .field("parent_instance", &self.parent_instance)
1293            .field("element_spec", &self.element_spec)
1294            .field("fixed_n_elements", &self.fixed_n_elements)
1295            .finish()
1296    }
1297}
1298
1299#[repr(C)]
1300#[derive(Copy, Clone)]
1301pub struct GParamSpecVariant {
1302    pub parent_instance: GParamSpec,
1303    pub type_: *mut glib::GVariantType,
1304    pub default_value: *mut glib::GVariant,
1305    pub padding: [gpointer; 4],
1306}
1307
1308impl ::std::fmt::Debug for GParamSpecVariant {
1309    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1310        f.debug_struct(&format!("GParamSpecVariant @ {:?}", self as *const _))
1311            .field("parent_instance", &self.parent_instance)
1312            .field("type_", &self.type_)
1313            .field("default_value", &self.default_value)
1314            .finish()
1315    }
1316}
1317
1318#[repr(C)]
1319#[derive(Copy, Clone)]
1320pub struct GTypeModule {
1321    pub parent_instance: GObject,
1322    pub use_count: c_uint,
1323    pub type_infos: *mut glib::GSList,
1324    pub interface_infos: *mut glib::GSList,
1325    pub name: *mut c_char,
1326}
1327
1328impl ::std::fmt::Debug for GTypeModule {
1329    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1330        f.debug_struct(&format!("GTypeModule @ {:?}", self as *const _))
1331            .field("parent_instance", &self.parent_instance)
1332            .field("use_count", &self.use_count)
1333            .field("type_infos", &self.type_infos)
1334            .field("interface_infos", &self.interface_infos)
1335            .field("name", &self.name)
1336            .finish()
1337    }
1338}
1339
1340// Interfaces
1341#[repr(C)]
1342pub struct GTypePlugin(c_void);
1343
1344impl ::std::fmt::Debug for GTypePlugin {
1345    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1346        write!(f, "GTypePlugin @ {:?}", self as *const _)
1347    }
1348}
1349
1350extern "C" {
1351
1352    //=========================================================================
1353    // GBindingFlags
1354    //=========================================================================
1355    pub fn g_binding_flags_get_type() -> GType;
1356
1357    //=========================================================================
1358    // GCClosure
1359    //=========================================================================
1360    pub fn g_cclosure_marshal_BOOLEAN__BOXED_BOXED(
1361        closure: *mut GClosure,
1362        return_value: *mut GValue,
1363        n_param_values: c_uint,
1364        param_values: *const GValue,
1365        invocation_hint: gpointer,
1366        marshal_data: gpointer,
1367    );
1368    //pub fn g_cclosure_marshal_BOOLEAN__BOXED_BOXEDv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1369    pub fn g_cclosure_marshal_BOOLEAN__FLAGS(
1370        closure: *mut GClosure,
1371        return_value: *mut GValue,
1372        n_param_values: c_uint,
1373        param_values: *const GValue,
1374        invocation_hint: gpointer,
1375        marshal_data: gpointer,
1376    );
1377    //pub fn g_cclosure_marshal_BOOLEAN__FLAGSv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1378    pub fn g_cclosure_marshal_STRING__OBJECT_POINTER(
1379        closure: *mut GClosure,
1380        return_value: *mut GValue,
1381        n_param_values: c_uint,
1382        param_values: *const GValue,
1383        invocation_hint: gpointer,
1384        marshal_data: gpointer,
1385    );
1386    //pub fn g_cclosure_marshal_STRING__OBJECT_POINTERv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1387    pub fn g_cclosure_marshal_VOID__BOOLEAN(
1388        closure: *mut GClosure,
1389        return_value: *mut GValue,
1390        n_param_values: c_uint,
1391        param_values: *const GValue,
1392        invocation_hint: gpointer,
1393        marshal_data: gpointer,
1394    );
1395    //pub fn g_cclosure_marshal_VOID__BOOLEANv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1396    pub fn g_cclosure_marshal_VOID__BOXED(
1397        closure: *mut GClosure,
1398        return_value: *mut GValue,
1399        n_param_values: c_uint,
1400        param_values: *const GValue,
1401        invocation_hint: gpointer,
1402        marshal_data: gpointer,
1403    );
1404    //pub fn g_cclosure_marshal_VOID__BOXEDv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1405    pub fn g_cclosure_marshal_VOID__CHAR(
1406        closure: *mut GClosure,
1407        return_value: *mut GValue,
1408        n_param_values: c_uint,
1409        param_values: *const GValue,
1410        invocation_hint: gpointer,
1411        marshal_data: gpointer,
1412    );
1413    //pub fn g_cclosure_marshal_VOID__CHARv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1414    pub fn g_cclosure_marshal_VOID__DOUBLE(
1415        closure: *mut GClosure,
1416        return_value: *mut GValue,
1417        n_param_values: c_uint,
1418        param_values: *const GValue,
1419        invocation_hint: gpointer,
1420        marshal_data: gpointer,
1421    );
1422    //pub fn g_cclosure_marshal_VOID__DOUBLEv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1423    pub fn g_cclosure_marshal_VOID__ENUM(
1424        closure: *mut GClosure,
1425        return_value: *mut GValue,
1426        n_param_values: c_uint,
1427        param_values: *const GValue,
1428        invocation_hint: gpointer,
1429        marshal_data: gpointer,
1430    );
1431    //pub fn g_cclosure_marshal_VOID__ENUMv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1432    pub fn g_cclosure_marshal_VOID__FLAGS(
1433        closure: *mut GClosure,
1434        return_value: *mut GValue,
1435        n_param_values: c_uint,
1436        param_values: *const GValue,
1437        invocation_hint: gpointer,
1438        marshal_data: gpointer,
1439    );
1440    //pub fn g_cclosure_marshal_VOID__FLAGSv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1441    pub fn g_cclosure_marshal_VOID__FLOAT(
1442        closure: *mut GClosure,
1443        return_value: *mut GValue,
1444        n_param_values: c_uint,
1445        param_values: *const GValue,
1446        invocation_hint: gpointer,
1447        marshal_data: gpointer,
1448    );
1449    //pub fn g_cclosure_marshal_VOID__FLOATv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1450    pub fn g_cclosure_marshal_VOID__INT(
1451        closure: *mut GClosure,
1452        return_value: *mut GValue,
1453        n_param_values: c_uint,
1454        param_values: *const GValue,
1455        invocation_hint: gpointer,
1456        marshal_data: gpointer,
1457    );
1458    //pub fn g_cclosure_marshal_VOID__INTv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1459    pub fn g_cclosure_marshal_VOID__LONG(
1460        closure: *mut GClosure,
1461        return_value: *mut GValue,
1462        n_param_values: c_uint,
1463        param_values: *const GValue,
1464        invocation_hint: gpointer,
1465        marshal_data: gpointer,
1466    );
1467    //pub fn g_cclosure_marshal_VOID__LONGv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1468    pub fn g_cclosure_marshal_VOID__OBJECT(
1469        closure: *mut GClosure,
1470        return_value: *mut GValue,
1471        n_param_values: c_uint,
1472        param_values: *const GValue,
1473        invocation_hint: gpointer,
1474        marshal_data: gpointer,
1475    );
1476    //pub fn g_cclosure_marshal_VOID__OBJECTv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1477    pub fn g_cclosure_marshal_VOID__PARAM(
1478        closure: *mut GClosure,
1479        return_value: *mut GValue,
1480        n_param_values: c_uint,
1481        param_values: *const GValue,
1482        invocation_hint: gpointer,
1483        marshal_data: gpointer,
1484    );
1485    //pub fn g_cclosure_marshal_VOID__PARAMv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1486    pub fn g_cclosure_marshal_VOID__POINTER(
1487        closure: *mut GClosure,
1488        return_value: *mut GValue,
1489        n_param_values: c_uint,
1490        param_values: *const GValue,
1491        invocation_hint: gpointer,
1492        marshal_data: gpointer,
1493    );
1494    //pub fn g_cclosure_marshal_VOID__POINTERv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1495    pub fn g_cclosure_marshal_VOID__STRING(
1496        closure: *mut GClosure,
1497        return_value: *mut GValue,
1498        n_param_values: c_uint,
1499        param_values: *const GValue,
1500        invocation_hint: gpointer,
1501        marshal_data: gpointer,
1502    );
1503    //pub fn g_cclosure_marshal_VOID__STRINGv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1504    pub fn g_cclosure_marshal_VOID__UCHAR(
1505        closure: *mut GClosure,
1506        return_value: *mut GValue,
1507        n_param_values: c_uint,
1508        param_values: *const GValue,
1509        invocation_hint: gpointer,
1510        marshal_data: gpointer,
1511    );
1512    //pub fn g_cclosure_marshal_VOID__UCHARv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1513    pub fn g_cclosure_marshal_VOID__UINT(
1514        closure: *mut GClosure,
1515        return_value: *mut GValue,
1516        n_param_values: c_uint,
1517        param_values: *const GValue,
1518        invocation_hint: gpointer,
1519        marshal_data: gpointer,
1520    );
1521    pub fn g_cclosure_marshal_VOID__UINT_POINTER(
1522        closure: *mut GClosure,
1523        return_value: *mut GValue,
1524        n_param_values: c_uint,
1525        param_values: *const GValue,
1526        invocation_hint: gpointer,
1527        marshal_data: gpointer,
1528    );
1529    //pub fn g_cclosure_marshal_VOID__UINT_POINTERv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1530    //pub fn g_cclosure_marshal_VOID__UINTv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1531    pub fn g_cclosure_marshal_VOID__ULONG(
1532        closure: *mut GClosure,
1533        return_value: *mut GValue,
1534        n_param_values: c_uint,
1535        param_values: *const GValue,
1536        invocation_hint: gpointer,
1537        marshal_data: gpointer,
1538    );
1539    //pub fn g_cclosure_marshal_VOID__ULONGv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1540    pub fn g_cclosure_marshal_VOID__VARIANT(
1541        closure: *mut GClosure,
1542        return_value: *mut GValue,
1543        n_param_values: c_uint,
1544        param_values: *const GValue,
1545        invocation_hint: gpointer,
1546        marshal_data: gpointer,
1547    );
1548    //pub fn g_cclosure_marshal_VOID__VARIANTv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1549    pub fn g_cclosure_marshal_VOID__VOID(
1550        closure: *mut GClosure,
1551        return_value: *mut GValue,
1552        n_param_values: c_uint,
1553        param_values: *const GValue,
1554        invocation_hint: gpointer,
1555        marshal_data: gpointer,
1556    );
1557    //pub fn g_cclosure_marshal_VOID__VOIDv(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1558    pub fn g_cclosure_marshal_generic(
1559        closure: *mut GClosure,
1560        return_gvalue: *mut GValue,
1561        n_param_values: c_uint,
1562        param_values: *const GValue,
1563        invocation_hint: gpointer,
1564        marshal_data: gpointer,
1565    );
1566    //pub fn g_cclosure_marshal_generic_va(closure: *mut GClosure, return_value: *mut GValue, instance: gpointer, args_list: /*Unimplemented*/va_list, marshal_data: gpointer, n_params: c_int, param_types: *mut GType);
1567    pub fn g_cclosure_new(
1568        callback_func: GCallback,
1569        user_data: gpointer,
1570        destroy_data: GClosureNotify,
1571    ) -> *mut GClosure;
1572    pub fn g_cclosure_new_object(callback_func: GCallback, object: *mut GObject) -> *mut GClosure;
1573    pub fn g_cclosure_new_object_swap(
1574        callback_func: GCallback,
1575        object: *mut GObject,
1576    ) -> *mut GClosure;
1577    pub fn g_cclosure_new_swap(
1578        callback_func: GCallback,
1579        user_data: gpointer,
1580        destroy_data: GClosureNotify,
1581    ) -> *mut GClosure;
1582
1583    //=========================================================================
1584    // GClosure
1585    //=========================================================================
1586    pub fn g_closure_get_type() -> GType;
1587    pub fn g_closure_new_object(sizeof_closure: c_uint, object: *mut GObject) -> *mut GClosure;
1588    pub fn g_closure_new_simple(sizeof_closure: c_uint, data: gpointer) -> *mut GClosure;
1589    pub fn g_closure_add_finalize_notifier(
1590        closure: *mut GClosure,
1591        notify_data: gpointer,
1592        notify_func: GClosureNotify,
1593    );
1594    pub fn g_closure_add_invalidate_notifier(
1595        closure: *mut GClosure,
1596        notify_data: gpointer,
1597        notify_func: GClosureNotify,
1598    );
1599    pub fn g_closure_add_marshal_guards(
1600        closure: *mut GClosure,
1601        pre_marshal_data: gpointer,
1602        pre_marshal_notify: GClosureNotify,
1603        post_marshal_data: gpointer,
1604        post_marshal_notify: GClosureNotify,
1605    );
1606    pub fn g_closure_invalidate(closure: *mut GClosure);
1607    pub fn g_closure_invoke(
1608        closure: *mut GClosure,
1609        return_value: *mut GValue,
1610        n_param_values: c_uint,
1611        param_values: *const GValue,
1612        invocation_hint: gpointer,
1613    );
1614    pub fn g_closure_ref(closure: *mut GClosure) -> *mut GClosure;
1615    pub fn g_closure_remove_finalize_notifier(
1616        closure: *mut GClosure,
1617        notify_data: gpointer,
1618        notify_func: GClosureNotify,
1619    );
1620    pub fn g_closure_remove_invalidate_notifier(
1621        closure: *mut GClosure,
1622        notify_data: gpointer,
1623        notify_func: GClosureNotify,
1624    );
1625    pub fn g_closure_set_marshal(closure: *mut GClosure, marshal: GClosureMarshal);
1626    pub fn g_closure_set_meta_marshal(
1627        closure: *mut GClosure,
1628        marshal_data: gpointer,
1629        meta_marshal: GClosureMarshal,
1630    );
1631    pub fn g_closure_sink(closure: *mut GClosure);
1632    pub fn g_closure_unref(closure: *mut GClosure);
1633
1634    //=========================================================================
1635    // GObjectClass
1636    //=========================================================================
1637    pub fn g_object_class_find_property(
1638        oclass: *mut GObjectClass,
1639        property_name: *const c_char,
1640    ) -> *mut GParamSpec;
1641    pub fn g_object_class_install_properties(
1642        oclass: *mut GObjectClass,
1643        n_pspecs: c_uint,
1644        pspecs: *mut *mut GParamSpec,
1645    );
1646    pub fn g_object_class_install_property(
1647        oclass: *mut GObjectClass,
1648        property_id: c_uint,
1649        pspec: *mut GParamSpec,
1650    );
1651    pub fn g_object_class_list_properties(
1652        oclass: *mut GObjectClass,
1653        n_properties: *mut c_uint,
1654    ) -> *mut *mut GParamSpec;
1655    pub fn g_object_class_override_property(
1656        oclass: *mut GObjectClass,
1657        property_id: c_uint,
1658        name: *const c_char,
1659    );
1660
1661    //=========================================================================
1662    // GParamSpecPool
1663    //=========================================================================
1664    pub fn g_param_spec_pool_insert(
1665        pool: *mut GParamSpecPool,
1666        pspec: *mut GParamSpec,
1667        owner_type: GType,
1668    );
1669    pub fn g_param_spec_pool_list(
1670        pool: *mut GParamSpecPool,
1671        owner_type: GType,
1672        n_pspecs_p: *mut c_uint,
1673    ) -> *mut *mut GParamSpec;
1674    pub fn g_param_spec_pool_list_owned(
1675        pool: *mut GParamSpecPool,
1676        owner_type: GType,
1677    ) -> *mut glib::GList;
1678    pub fn g_param_spec_pool_lookup(
1679        pool: *mut GParamSpecPool,
1680        param_name: *const c_char,
1681        owner_type: GType,
1682        walk_ancestors: gboolean,
1683    ) -> *mut GParamSpec;
1684    pub fn g_param_spec_pool_remove(pool: *mut GParamSpecPool, pspec: *mut GParamSpec);
1685    pub fn g_param_spec_pool_new(type_prefixing: gboolean) -> *mut GParamSpecPool;
1686
1687    //=========================================================================
1688    // GTypeClass
1689    //=========================================================================
1690    pub fn g_type_class_add_private(g_class: gpointer, private_size: size_t);
1691    pub fn g_type_class_get_instance_private_offset(g_class: gpointer) -> c_int;
1692    pub fn g_type_class_get_private(klass: *mut GTypeClass, private_type: GType) -> gpointer;
1693    pub fn g_type_class_peek_parent(g_class: gpointer) -> gpointer;
1694    pub fn g_type_class_unref(g_class: gpointer);
1695    pub fn g_type_class_unref_uncached(g_class: gpointer);
1696    pub fn g_type_class_adjust_private_offset(
1697        g_class: gpointer,
1698        private_size_or_offset: *mut c_int,
1699    );
1700    pub fn g_type_class_peek(type_: GType) -> gpointer;
1701    pub fn g_type_class_peek_static(type_: GType) -> gpointer;
1702    pub fn g_type_class_ref(type_: GType) -> gpointer;
1703
1704    //=========================================================================
1705    // GTypeInstance
1706    //=========================================================================
1707    pub fn g_type_instance_get_private(
1708        instance: *mut GTypeInstance,
1709        private_type: GType,
1710    ) -> gpointer;
1711
1712    //=========================================================================
1713    // GTypeInterface
1714    //=========================================================================
1715    pub fn g_type_interface_peek_parent(g_iface: gpointer) -> gpointer;
1716    pub fn g_type_interface_add_prerequisite(interface_type: GType, prerequisite_type: GType);
1717    pub fn g_type_interface_get_plugin(
1718        instance_type: GType,
1719        interface_type: GType,
1720    ) -> *mut GTypePlugin;
1721    pub fn g_type_interface_peek(instance_class: gpointer, iface_type: GType) -> gpointer;
1722    pub fn g_type_interface_prerequisites(
1723        interface_type: GType,
1724        n_prerequisites: *mut c_uint,
1725    ) -> *mut GType;
1726
1727    //=========================================================================
1728    // GTypeValueTable
1729    //=========================================================================
1730    pub fn g_type_value_table_peek(type_: GType) -> *mut GTypeValueTable;
1731
1732    //=========================================================================
1733    // GValue
1734    //=========================================================================
1735    pub fn g_value_get_type() -> GType;
1736    pub fn g_value_copy(src_value: *const GValue, dest_value: *mut GValue);
1737    pub fn g_value_dup_boxed(value: *const GValue) -> gpointer;
1738    pub fn g_value_dup_object(value: *const GValue) -> *mut GObject;
1739    pub fn g_value_dup_param(value: *const GValue) -> *mut GParamSpec;
1740    pub fn g_value_dup_string(value: *const GValue) -> *mut c_char;
1741    pub fn g_value_dup_variant(value: *const GValue) -> *mut glib::GVariant;
1742    pub fn g_value_fits_pointer(value: *const GValue) -> gboolean;
1743    pub fn g_value_get_boolean(value: *const GValue) -> gboolean;
1744    pub fn g_value_get_boxed(value: *const GValue) -> gpointer;
1745    pub fn g_value_get_char(value: *const GValue) -> c_char;
1746    pub fn g_value_get_double(value: *const GValue) -> c_double;
1747    pub fn g_value_get_enum(value: *const GValue) -> c_int;
1748    pub fn g_value_get_flags(value: *const GValue) -> c_uint;
1749    pub fn g_value_get_float(value: *const GValue) -> c_float;
1750    pub fn g_value_get_gtype(value: *const GValue) -> GType;
1751    pub fn g_value_get_int(value: *const GValue) -> c_int;
1752    pub fn g_value_get_int64(value: *const GValue) -> i64;
1753    pub fn g_value_get_long(value: *const GValue) -> c_long;
1754    pub fn g_value_get_object(value: *const GValue) -> *mut GObject;
1755    pub fn g_value_get_param(value: *const GValue) -> *mut GParamSpec;
1756    pub fn g_value_get_pointer(value: *const GValue) -> gpointer;
1757    pub fn g_value_get_schar(value: *const GValue) -> i8;
1758    pub fn g_value_get_string(value: *const GValue) -> *const c_char;
1759    pub fn g_value_get_uchar(value: *const GValue) -> c_uchar;
1760    pub fn g_value_get_uint(value: *const GValue) -> c_uint;
1761    pub fn g_value_get_uint64(value: *const GValue) -> u64;
1762    pub fn g_value_get_ulong(value: *const GValue) -> c_ulong;
1763    pub fn g_value_get_variant(value: *const GValue) -> *mut glib::GVariant;
1764    pub fn g_value_init(value: *mut GValue, g_type: GType) -> *mut GValue;
1765    pub fn g_value_init_from_instance(value: *mut GValue, instance: gpointer);
1766    pub fn g_value_peek_pointer(value: *const GValue) -> gpointer;
1767    pub fn g_value_reset(value: *mut GValue) -> *mut GValue;
1768    pub fn g_value_set_boolean(value: *mut GValue, v_boolean: gboolean);
1769    pub fn g_value_set_boxed(value: *mut GValue, v_boxed: gconstpointer);
1770    pub fn g_value_set_boxed_take_ownership(value: *mut GValue, v_boxed: gconstpointer);
1771    pub fn g_value_set_char(value: *mut GValue, v_char: c_char);
1772    pub fn g_value_set_double(value: *mut GValue, v_double: c_double);
1773    pub fn g_value_set_enum(value: *mut GValue, v_enum: c_int);
1774    pub fn g_value_set_flags(value: *mut GValue, v_flags: c_uint);
1775    pub fn g_value_set_float(value: *mut GValue, v_float: c_float);
1776    pub fn g_value_set_gtype(value: *mut GValue, v_gtype: GType);
1777    pub fn g_value_set_instance(value: *mut GValue, instance: gpointer);
1778    pub fn g_value_set_int(value: *mut GValue, v_int: c_int);
1779    pub fn g_value_set_int64(value: *mut GValue, v_int64: i64);
1780    pub fn g_value_set_long(value: *mut GValue, v_long: c_long);
1781    pub fn g_value_set_object(value: *mut GValue, v_object: *mut GObject);
1782    pub fn g_value_set_object_take_ownership(value: *mut GValue, v_object: gpointer);
1783    pub fn g_value_set_param(value: *mut GValue, param: *mut GParamSpec);
1784    pub fn g_value_set_param_take_ownership(value: *mut GValue, param: *mut GParamSpec);
1785    pub fn g_value_set_pointer(value: *mut GValue, v_pointer: gpointer);
1786    pub fn g_value_set_schar(value: *mut GValue, v_char: i8);
1787    pub fn g_value_set_static_boxed(value: *mut GValue, v_boxed: gconstpointer);
1788    pub fn g_value_set_static_string(value: *mut GValue, v_string: *const c_char);
1789    pub fn g_value_set_string(value: *mut GValue, v_string: *const c_char);
1790    pub fn g_value_set_string_take_ownership(value: *mut GValue, v_string: *mut c_char);
1791    pub fn g_value_set_uchar(value: *mut GValue, v_uchar: c_uchar);
1792    pub fn g_value_set_uint(value: *mut GValue, v_uint: c_uint);
1793    pub fn g_value_set_uint64(value: *mut GValue, v_uint64: u64);
1794    pub fn g_value_set_ulong(value: *mut GValue, v_ulong: c_ulong);
1795    pub fn g_value_set_variant(value: *mut GValue, variant: *mut glib::GVariant);
1796    pub fn g_value_take_boxed(value: *mut GValue, v_boxed: gconstpointer);
1797    pub fn g_value_take_object(value: *mut GValue, v_object: gpointer);
1798    pub fn g_value_take_param(value: *mut GValue, param: *mut GParamSpec);
1799    pub fn g_value_take_string(value: *mut GValue, v_string: *mut c_char);
1800    pub fn g_value_take_variant(value: *mut GValue, variant: *mut glib::GVariant);
1801    pub fn g_value_transform(src_value: *const GValue, dest_value: *mut GValue) -> gboolean;
1802    pub fn g_value_unset(value: *mut GValue);
1803    pub fn g_value_register_transform_func(
1804        src_type: GType,
1805        dest_type: GType,
1806        transform_func: GValueTransform,
1807    );
1808    pub fn g_value_type_compatible(src_type: GType, dest_type: GType) -> gboolean;
1809    pub fn g_value_type_transformable(src_type: GType, dest_type: GType) -> gboolean;
1810
1811    //=========================================================================
1812    // GValueArray
1813    //=========================================================================
1814    pub fn g_value_array_get_type() -> GType;
1815    pub fn g_value_array_new(n_prealloced: c_uint) -> *mut GValueArray;
1816    pub fn g_value_array_append(
1817        value_array: *mut GValueArray,
1818        value: *const GValue,
1819    ) -> *mut GValueArray;
1820    pub fn g_value_array_copy(value_array: *const GValueArray) -> *mut GValueArray;
1821    pub fn g_value_array_free(value_array: *mut GValueArray);
1822    pub fn g_value_array_get_nth(value_array: *mut GValueArray, index_: c_uint) -> *mut GValue;
1823    pub fn g_value_array_insert(
1824        value_array: *mut GValueArray,
1825        index_: c_uint,
1826        value: *const GValue,
1827    ) -> *mut GValueArray;
1828    pub fn g_value_array_prepend(
1829        value_array: *mut GValueArray,
1830        value: *const GValue,
1831    ) -> *mut GValueArray;
1832    pub fn g_value_array_remove(value_array: *mut GValueArray, index_: c_uint) -> *mut GValueArray;
1833    pub fn g_value_array_sort(
1834        value_array: *mut GValueArray,
1835        compare_func: glib::GCompareFunc,
1836    ) -> *mut GValueArray;
1837    pub fn g_value_array_sort_with_data(
1838        value_array: *mut GValueArray,
1839        compare_func: glib::GCompareDataFunc,
1840        user_data: gpointer,
1841    ) -> *mut GValueArray;
1842
1843    //=========================================================================
1844    // GWeakRef
1845    //=========================================================================
1846    pub fn g_weak_ref_clear(weak_ref: *mut GWeakRef);
1847    pub fn g_weak_ref_get(weak_ref: *mut GWeakRef) -> *mut GObject;
1848    pub fn g_weak_ref_init(weak_ref: *mut GWeakRef, object: *mut GObject);
1849    pub fn g_weak_ref_set(weak_ref: *mut GWeakRef, object: *mut GObject);
1850
1851    //=========================================================================
1852    // GBinding
1853    //=========================================================================
1854    pub fn g_binding_get_type() -> GType;
1855    pub fn g_binding_get_flags(binding: *mut GBinding) -> GBindingFlags;
1856    pub fn g_binding_get_source(binding: *mut GBinding) -> *mut GObject;
1857    pub fn g_binding_get_source_property(binding: *mut GBinding) -> *const c_char;
1858    pub fn g_binding_get_target(binding: *mut GBinding) -> *mut GObject;
1859    pub fn g_binding_get_target_property(binding: *mut GBinding) -> *const c_char;
1860    pub fn g_binding_unbind(binding: *mut GBinding);
1861
1862    //=========================================================================
1863    // GInitiallyUnowned
1864    //=========================================================================
1865    pub fn g_initially_unowned_get_type() -> GType;
1866
1867    //=========================================================================
1868    // GObject
1869    //=========================================================================
1870    pub fn g_object_get_type() -> GType;
1871    pub fn g_object_new(
1872        object_type: GType,
1873        first_property_name: *const c_char,
1874        ...
1875    ) -> *mut GObject;
1876    //pub fn g_object_new_valist(object_type: GType, first_property_name: *const c_char, var_args: /*Unimplemented*/va_list) -> *mut GObject;
1877    #[cfg(any(feature = "v2_54", feature = "dox"))]
1878    pub fn g_object_new_with_properties(
1879        object_type: GType,
1880        n_properties: c_uint,
1881        names: *mut *const c_char,
1882        values: *const GValue,
1883    ) -> *mut GObject;
1884    pub fn g_object_newv(
1885        object_type: GType,
1886        n_parameters: c_uint,
1887        parameters: *mut GParameter,
1888    ) -> *mut GObject;
1889    pub fn g_object_compat_control(what: size_t, data: gpointer) -> size_t;
1890    pub fn g_object_interface_find_property(
1891        g_iface: gpointer,
1892        property_name: *const c_char,
1893    ) -> *mut GParamSpec;
1894    pub fn g_object_interface_install_property(g_iface: gpointer, pspec: *mut GParamSpec);
1895    pub fn g_object_interface_list_properties(
1896        g_iface: gpointer,
1897        n_properties_p: *mut c_uint,
1898    ) -> *mut *mut GParamSpec;
1899    pub fn g_object_add_toggle_ref(object: *mut GObject, notify: GToggleNotify, data: gpointer);
1900    pub fn g_object_add_weak_pointer(object: *mut GObject, weak_pointer_location: *mut gpointer);
1901    pub fn g_object_bind_property(
1902        source: *mut GObject,
1903        source_property: *const c_char,
1904        target: *mut GObject,
1905        target_property: *const c_char,
1906        flags: GBindingFlags,
1907    ) -> *mut GBinding;
1908    pub fn g_object_bind_property_full(
1909        source: *mut GObject,
1910        source_property: *const c_char,
1911        target: *mut GObject,
1912        target_property: *const c_char,
1913        flags: GBindingFlags,
1914        transform_to: GBindingTransformFunc,
1915        transform_from: GBindingTransformFunc,
1916        user_data: gpointer,
1917        notify: glib::GDestroyNotify,
1918    ) -> *mut GBinding;
1919    pub fn g_object_bind_property_with_closures(
1920        source: *mut GObject,
1921        source_property: *const c_char,
1922        target: *mut GObject,
1923        target_property: *const c_char,
1924        flags: GBindingFlags,
1925        transform_to: *mut GClosure,
1926        transform_from: *mut GClosure,
1927    ) -> *mut GBinding;
1928    pub fn g_object_connect(object: *mut GObject, signal_spec: *const c_char, ...) -> *mut GObject;
1929    pub fn g_object_disconnect(object: *mut GObject, signal_spec: *const c_char, ...);
1930    pub fn g_object_dup_data(
1931        object: *mut GObject,
1932        key: *const c_char,
1933        dup_func: glib::GDuplicateFunc,
1934        user_data: gpointer,
1935    ) -> gpointer;
1936    pub fn g_object_dup_qdata(
1937        object: *mut GObject,
1938        quark: glib::GQuark,
1939        dup_func: glib::GDuplicateFunc,
1940        user_data: gpointer,
1941    ) -> gpointer;
1942    pub fn g_object_force_floating(object: *mut GObject);
1943    pub fn g_object_freeze_notify(object: *mut GObject);
1944    pub fn g_object_get(object: *mut GObject, first_property_name: *const c_char, ...);
1945    pub fn g_object_get_data(object: *mut GObject, key: *const c_char) -> gpointer;
1946    pub fn g_object_get_property(
1947        object: *mut GObject,
1948        property_name: *const c_char,
1949        value: *mut GValue,
1950    );
1951    pub fn g_object_get_qdata(object: *mut GObject, quark: glib::GQuark) -> gpointer;
1952    //pub fn g_object_get_valist(object: *mut GObject, first_property_name: *const c_char, var_args: /*Unimplemented*/va_list);
1953    #[cfg(any(feature = "v2_54", feature = "dox"))]
1954    pub fn g_object_getv(
1955        object: *mut GObject,
1956        n_properties: c_uint,
1957        names: *mut *const c_char,
1958        values: *mut GValue,
1959    );
1960    pub fn g_object_is_floating(object: *mut GObject) -> gboolean;
1961    pub fn g_object_notify(object: *mut GObject, property_name: *const c_char);
1962    pub fn g_object_notify_by_pspec(object: *mut GObject, pspec: *mut GParamSpec);
1963    pub fn g_object_ref(object: *mut GObject) -> *mut GObject;
1964    pub fn g_object_ref_sink(object: *mut GObject) -> *mut GObject;
1965    pub fn g_object_remove_toggle_ref(object: *mut GObject, notify: GToggleNotify, data: gpointer);
1966    pub fn g_object_remove_weak_pointer(object: *mut GObject, weak_pointer_location: *mut gpointer);
1967    pub fn g_object_replace_data(
1968        object: *mut GObject,
1969        key: *const c_char,
1970        oldval: gpointer,
1971        newval: gpointer,
1972        destroy: glib::GDestroyNotify,
1973        old_destroy: *mut glib::GDestroyNotify,
1974    ) -> gboolean;
1975    pub fn g_object_replace_qdata(
1976        object: *mut GObject,
1977        quark: glib::GQuark,
1978        oldval: gpointer,
1979        newval: gpointer,
1980        destroy: glib::GDestroyNotify,
1981        old_destroy: *mut glib::GDestroyNotify,
1982    ) -> gboolean;
1983    pub fn g_object_run_dispose(object: *mut GObject);
1984    pub fn g_object_set(object: *mut GObject, first_property_name: *const c_char, ...);
1985    pub fn g_object_set_data(object: *mut GObject, key: *const c_char, data: gpointer);
1986    pub fn g_object_set_data_full(
1987        object: *mut GObject,
1988        key: *const c_char,
1989        data: gpointer,
1990        destroy: glib::GDestroyNotify,
1991    );
1992    pub fn g_object_set_property(
1993        object: *mut GObject,
1994        property_name: *const c_char,
1995        value: *const GValue,
1996    );
1997    pub fn g_object_set_qdata(object: *mut GObject, quark: glib::GQuark, data: gpointer);
1998    pub fn g_object_set_qdata_full(
1999        object: *mut GObject,
2000        quark: glib::GQuark,
2001        data: gpointer,
2002        destroy: glib::GDestroyNotify,
2003    );
2004    //pub fn g_object_set_valist(object: *mut GObject, first_property_name: *const c_char, var_args: /*Unimplemented*/va_list);
2005    #[cfg(any(feature = "v2_54", feature = "dox"))]
2006    pub fn g_object_setv(
2007        object: *mut GObject,
2008        n_properties: c_uint,
2009        names: *mut *const c_char,
2010        values: *const GValue,
2011    );
2012    pub fn g_object_steal_data(object: *mut GObject, key: *const c_char) -> gpointer;
2013    pub fn g_object_steal_qdata(object: *mut GObject, quark: glib::GQuark) -> gpointer;
2014    pub fn g_object_thaw_notify(object: *mut GObject);
2015    pub fn g_object_unref(object: *mut GObject);
2016    pub fn g_object_watch_closure(object: *mut GObject, closure: *mut GClosure);
2017    pub fn g_object_weak_ref(object: *mut GObject, notify: GWeakNotify, data: gpointer);
2018    pub fn g_object_weak_unref(object: *mut GObject, notify: GWeakNotify, data: gpointer);
2019
2020    //=========================================================================
2021    // GParamSpec
2022    //=========================================================================
2023    pub fn g_param_spec_internal(
2024        param_type: GType,
2025        name: *const c_char,
2026        nick: *const c_char,
2027        blurb: *const c_char,
2028        flags: GParamFlags,
2029    ) -> *mut GParamSpec;
2030    pub fn g_param_spec_get_blurb(pspec: *mut GParamSpec) -> *const c_char;
2031    pub fn g_param_spec_get_default_value(pspec: *mut GParamSpec) -> *const GValue;
2032    pub fn g_param_spec_get_name(pspec: *mut GParamSpec) -> *const c_char;
2033    #[cfg(any(feature = "v2_46", feature = "dox"))]
2034    pub fn g_param_spec_get_name_quark(pspec: *mut GParamSpec) -> glib::GQuark;
2035    pub fn g_param_spec_get_nick(pspec: *mut GParamSpec) -> *const c_char;
2036    pub fn g_param_spec_get_qdata(pspec: *mut GParamSpec, quark: glib::GQuark) -> gpointer;
2037    pub fn g_param_spec_get_redirect_target(pspec: *mut GParamSpec) -> *mut GParamSpec;
2038    pub fn g_param_spec_ref(pspec: *mut GParamSpec) -> *mut GParamSpec;
2039    pub fn g_param_spec_ref_sink(pspec: *mut GParamSpec) -> *mut GParamSpec;
2040    pub fn g_param_spec_set_qdata(pspec: *mut GParamSpec, quark: glib::GQuark, data: gpointer);
2041    pub fn g_param_spec_set_qdata_full(
2042        pspec: *mut GParamSpec,
2043        quark: glib::GQuark,
2044        data: gpointer,
2045        destroy: glib::GDestroyNotify,
2046    );
2047    pub fn g_param_spec_sink(pspec: *mut GParamSpec);
2048    pub fn g_param_spec_steal_qdata(pspec: *mut GParamSpec, quark: glib::GQuark) -> gpointer;
2049    pub fn g_param_spec_unref(pspec: *mut GParamSpec);
2050
2051    //=========================================================================
2052    // GTypeModule
2053    //=========================================================================
2054    pub fn g_type_module_get_type() -> GType;
2055    pub fn g_type_module_add_interface(
2056        module: *mut GTypeModule,
2057        instance_type: GType,
2058        interface_type: GType,
2059        interface_info: *const GInterfaceInfo,
2060    );
2061    pub fn g_type_module_register_enum(
2062        module: *mut GTypeModule,
2063        name: *const c_char,
2064        const_static_values: *const GEnumValue,
2065    ) -> GType;
2066    pub fn g_type_module_register_flags(
2067        module: *mut GTypeModule,
2068        name: *const c_char,
2069        const_static_values: *const GFlagsValue,
2070    ) -> GType;
2071    pub fn g_type_module_register_type(
2072        module: *mut GTypeModule,
2073        parent_type: GType,
2074        type_name: *const c_char,
2075        type_info: *const GTypeInfo,
2076        flags: GTypeFlags,
2077    ) -> GType;
2078    pub fn g_type_module_set_name(module: *mut GTypeModule, name: *const c_char);
2079    pub fn g_type_module_unuse(module: *mut GTypeModule);
2080    pub fn g_type_module_use(module: *mut GTypeModule) -> gboolean;
2081
2082    //=========================================================================
2083    // GTypePlugin
2084    //=========================================================================
2085    pub fn g_type_plugin_get_type() -> GType;
2086    pub fn g_type_plugin_complete_interface_info(
2087        plugin: *mut GTypePlugin,
2088        instance_type: GType,
2089        interface_type: GType,
2090        info: *mut GInterfaceInfo,
2091    );
2092    pub fn g_type_plugin_complete_type_info(
2093        plugin: *mut GTypePlugin,
2094        g_type: GType,
2095        info: *mut GTypeInfo,
2096        value_table: *mut GTypeValueTable,
2097    );
2098    pub fn g_type_plugin_unuse(plugin: *mut GTypePlugin);
2099    pub fn g_type_plugin_use(plugin: *mut GTypePlugin);
2100
2101    //=========================================================================
2102    // Other functions
2103    //=========================================================================
2104    pub fn g_boxed_copy(boxed_type: GType, src_boxed: gconstpointer) -> gpointer;
2105    pub fn g_boxed_free(boxed_type: GType, boxed: gpointer);
2106    pub fn g_boxed_type_register_static(
2107        name: *const c_char,
2108        boxed_copy: GBoxedCopyFunc,
2109        boxed_free: GBoxedFreeFunc,
2110    ) -> GType;
2111    pub fn g_clear_object(object_ptr: *mut *mut GObject);
2112    pub fn g_enum_complete_type_info(
2113        g_enum_type: GType,
2114        info: *mut GTypeInfo,
2115        const_values: *const GEnumValue,
2116    );
2117    pub fn g_enum_get_value(enum_class: *mut GEnumClass, value: c_int) -> *mut GEnumValue;
2118    pub fn g_enum_get_value_by_name(
2119        enum_class: *mut GEnumClass,
2120        name: *const c_char,
2121    ) -> *mut GEnumValue;
2122    pub fn g_enum_get_value_by_nick(
2123        enum_class: *mut GEnumClass,
2124        nick: *const c_char,
2125    ) -> *mut GEnumValue;
2126    pub fn g_enum_register_static(
2127        name: *const c_char,
2128        const_static_values: *const GEnumValue,
2129    ) -> GType;
2130    #[cfg(any(feature = "v2_54", feature = "dox"))]
2131    pub fn g_enum_to_string(g_enum_type: GType, value: c_int) -> *mut c_char;
2132    pub fn g_flags_complete_type_info(
2133        g_flags_type: GType,
2134        info: *mut GTypeInfo,
2135        const_values: *const GFlagsValue,
2136    );
2137    pub fn g_flags_get_first_value(
2138        flags_class: *mut GFlagsClass,
2139        value: c_uint,
2140    ) -> *mut GFlagsValue;
2141    pub fn g_flags_get_value_by_name(
2142        flags_class: *mut GFlagsClass,
2143        name: *const c_char,
2144    ) -> *mut GFlagsValue;
2145    pub fn g_flags_get_value_by_nick(
2146        flags_class: *mut GFlagsClass,
2147        nick: *const c_char,
2148    ) -> *mut GFlagsValue;
2149    pub fn g_flags_register_static(
2150        name: *const c_char,
2151        const_static_values: *const GFlagsValue,
2152    ) -> GType;
2153    #[cfg(any(feature = "v2_54", feature = "dox"))]
2154    pub fn g_flags_to_string(flags_type: GType, value: c_uint) -> *mut c_char;
2155    pub fn g_gtype_get_type() -> GType;
2156    pub fn g_param_spec_boolean(
2157        name: *const c_char,
2158        nick: *const c_char,
2159        blurb: *const c_char,
2160        default_value: gboolean,
2161        flags: GParamFlags,
2162    ) -> *mut GParamSpec;
2163    pub fn g_param_spec_boxed(
2164        name: *const c_char,
2165        nick: *const c_char,
2166        blurb: *const c_char,
2167        boxed_type: GType,
2168        flags: GParamFlags,
2169    ) -> *mut GParamSpec;
2170    pub fn g_param_spec_char(
2171        name: *const c_char,
2172        nick: *const c_char,
2173        blurb: *const c_char,
2174        minimum: i8,
2175        maximum: i8,
2176        default_value: i8,
2177        flags: GParamFlags,
2178    ) -> *mut GParamSpec;
2179    pub fn g_param_spec_double(
2180        name: *const c_char,
2181        nick: *const c_char,
2182        blurb: *const c_char,
2183        minimum: c_double,
2184        maximum: c_double,
2185        default_value: c_double,
2186        flags: GParamFlags,
2187    ) -> *mut GParamSpec;
2188    pub fn g_param_spec_enum(
2189        name: *const c_char,
2190        nick: *const c_char,
2191        blurb: *const c_char,
2192        enum_type: GType,
2193        default_value: c_int,
2194        flags: GParamFlags,
2195    ) -> *mut GParamSpec;
2196    pub fn g_param_spec_flags(
2197        name: *const c_char,
2198        nick: *const c_char,
2199        blurb: *const c_char,
2200        flags_type: GType,
2201        default_value: c_uint,
2202        flags: GParamFlags,
2203    ) -> *mut GParamSpec;
2204    pub fn g_param_spec_float(
2205        name: *const c_char,
2206        nick: *const c_char,
2207        blurb: *const c_char,
2208        minimum: c_float,
2209        maximum: c_float,
2210        default_value: c_float,
2211        flags: GParamFlags,
2212    ) -> *mut GParamSpec;
2213    pub fn g_param_spec_gtype(
2214        name: *const c_char,
2215        nick: *const c_char,
2216        blurb: *const c_char,
2217        is_a_type: GType,
2218        flags: GParamFlags,
2219    ) -> *mut GParamSpec;
2220    pub fn g_param_spec_int(
2221        name: *const c_char,
2222        nick: *const c_char,
2223        blurb: *const c_char,
2224        minimum: c_int,
2225        maximum: c_int,
2226        default_value: c_int,
2227        flags: GParamFlags,
2228    ) -> *mut GParamSpec;
2229    pub fn g_param_spec_int64(
2230        name: *const c_char,
2231        nick: *const c_char,
2232        blurb: *const c_char,
2233        minimum: i64,
2234        maximum: i64,
2235        default_value: i64,
2236        flags: GParamFlags,
2237    ) -> *mut GParamSpec;
2238    pub fn g_param_spec_long(
2239        name: *const c_char,
2240        nick: *const c_char,
2241        blurb: *const c_char,
2242        minimum: c_long,
2243        maximum: c_long,
2244        default_value: c_long,
2245        flags: GParamFlags,
2246    ) -> *mut GParamSpec;
2247    pub fn g_param_spec_object(
2248        name: *const c_char,
2249        nick: *const c_char,
2250        blurb: *const c_char,
2251        object_type: GType,
2252        flags: GParamFlags,
2253    ) -> *mut GParamSpec;
2254    pub fn g_param_spec_override(
2255        name: *const c_char,
2256        overridden: *mut GParamSpec,
2257    ) -> *mut GParamSpec;
2258    pub fn g_param_spec_param(
2259        name: *const c_char,
2260        nick: *const c_char,
2261        blurb: *const c_char,
2262        param_type: GType,
2263        flags: GParamFlags,
2264    ) -> *mut GParamSpec;
2265    pub fn g_param_spec_pointer(
2266        name: *const c_char,
2267        nick: *const c_char,
2268        blurb: *const c_char,
2269        flags: GParamFlags,
2270    ) -> *mut GParamSpec;
2271    pub fn g_param_spec_string(
2272        name: *const c_char,
2273        nick: *const c_char,
2274        blurb: *const c_char,
2275        default_value: *const c_char,
2276        flags: GParamFlags,
2277    ) -> *mut GParamSpec;
2278    pub fn g_param_spec_uchar(
2279        name: *const c_char,
2280        nick: *const c_char,
2281        blurb: *const c_char,
2282        minimum: u8,
2283        maximum: u8,
2284        default_value: u8,
2285        flags: GParamFlags,
2286    ) -> *mut GParamSpec;
2287    pub fn g_param_spec_uint(
2288        name: *const c_char,
2289        nick: *const c_char,
2290        blurb: *const c_char,
2291        minimum: c_uint,
2292        maximum: c_uint,
2293        default_value: c_uint,
2294        flags: GParamFlags,
2295    ) -> *mut GParamSpec;
2296    pub fn g_param_spec_uint64(
2297        name: *const c_char,
2298        nick: *const c_char,
2299        blurb: *const c_char,
2300        minimum: u64,
2301        maximum: u64,
2302        default_value: u64,
2303        flags: GParamFlags,
2304    ) -> *mut GParamSpec;
2305    pub fn g_param_spec_ulong(
2306        name: *const c_char,
2307        nick: *const c_char,
2308        blurb: *const c_char,
2309        minimum: c_ulong,
2310        maximum: c_ulong,
2311        default_value: c_ulong,
2312        flags: GParamFlags,
2313    ) -> *mut GParamSpec;
2314    pub fn g_param_spec_unichar(
2315        name: *const c_char,
2316        nick: *const c_char,
2317        blurb: *const c_char,
2318        default_value: u32,
2319        flags: GParamFlags,
2320    ) -> *mut GParamSpec;
2321    pub fn g_param_spec_value_array(
2322        name: *const c_char,
2323        nick: *const c_char,
2324        blurb: *const c_char,
2325        element_spec: *mut GParamSpec,
2326        flags: GParamFlags,
2327    ) -> *mut GParamSpec;
2328    pub fn g_param_spec_variant(
2329        name: *const c_char,
2330        nick: *const c_char,
2331        blurb: *const c_char,
2332        type_: *const glib::GVariantType,
2333        default_value: *mut glib::GVariant,
2334        flags: GParamFlags,
2335    ) -> *mut GParamSpec;
2336    pub fn g_param_type_register_static(
2337        name: *const c_char,
2338        pspec_info: *const GParamSpecTypeInfo,
2339    ) -> GType;
2340    pub fn g_param_value_convert(
2341        pspec: *mut GParamSpec,
2342        src_value: *const GValue,
2343        dest_value: *mut GValue,
2344        strict_validation: gboolean,
2345    ) -> gboolean;
2346    pub fn g_param_value_defaults(pspec: *mut GParamSpec, value: *mut GValue) -> gboolean;
2347    pub fn g_param_value_set_default(pspec: *mut GParamSpec, value: *mut GValue);
2348    pub fn g_param_value_validate(pspec: *mut GParamSpec, value: *mut GValue) -> gboolean;
2349    pub fn g_param_values_cmp(
2350        pspec: *mut GParamSpec,
2351        value1: *const GValue,
2352        value2: *const GValue,
2353    ) -> c_int;
2354    pub fn g_pointer_type_register_static(name: *const c_char) -> GType;
2355    pub fn g_signal_accumulator_first_wins(
2356        ihint: *mut GSignalInvocationHint,
2357        return_accu: *mut GValue,
2358        handler_return: *const GValue,
2359        dummy: gpointer,
2360    ) -> gboolean;
2361    pub fn g_signal_accumulator_true_handled(
2362        ihint: *mut GSignalInvocationHint,
2363        return_accu: *mut GValue,
2364        handler_return: *const GValue,
2365        dummy: gpointer,
2366    ) -> gboolean;
2367    pub fn g_signal_add_emission_hook(
2368        signal_id: c_uint,
2369        detail: glib::GQuark,
2370        hook_func: GSignalEmissionHook,
2371        hook_data: gpointer,
2372        data_destroy: glib::GDestroyNotify,
2373    ) -> c_ulong;
2374    pub fn g_signal_chain_from_overridden(
2375        instance_and_params: *const GValue,
2376        return_value: *mut GValue,
2377    );
2378    pub fn g_signal_chain_from_overridden_handler(instance: gpointer, ...);
2379    pub fn g_signal_connect_closure(
2380        instance: *mut GObject,
2381        detailed_signal: *const c_char,
2382        closure: *mut GClosure,
2383        after: gboolean,
2384    ) -> c_ulong;
2385    pub fn g_signal_connect_closure_by_id(
2386        instance: *mut GObject,
2387        signal_id: c_uint,
2388        detail: glib::GQuark,
2389        closure: *mut GClosure,
2390        after: gboolean,
2391    ) -> c_ulong;
2392    pub fn g_signal_connect_data(
2393        instance: *mut GObject,
2394        detailed_signal: *const c_char,
2395        c_handler: GCallback,
2396        data: gpointer,
2397        destroy_data: GClosureNotify,
2398        connect_flags: GConnectFlags,
2399    ) -> c_ulong;
2400    pub fn g_signal_connect_object(
2401        instance: gpointer,
2402        detailed_signal: *const c_char,
2403        c_handler: GCallback,
2404        gobject: *mut GObject,
2405        connect_flags: GConnectFlags,
2406    ) -> c_ulong;
2407    pub fn g_signal_emit(instance: *mut GObject, signal_id: c_uint, detail: glib::GQuark, ...);
2408    pub fn g_signal_emit_by_name(instance: *mut GObject, detailed_signal: *const c_char, ...);
2409    //pub fn g_signal_emit_valist(instance: gpointer, signal_id: c_uint, detail: glib::GQuark, var_args: /*Unimplemented*/va_list);
2410    pub fn g_signal_emitv(
2411        instance_and_params: *const GValue,
2412        signal_id: c_uint,
2413        detail: glib::GQuark,
2414        return_value: *mut GValue,
2415    );
2416    pub fn g_signal_get_invocation_hint(instance: *mut GObject) -> *mut GSignalInvocationHint;
2417    pub fn g_signal_handler_block(instance: *mut GObject, handler_id: c_ulong);
2418    pub fn g_signal_handler_disconnect(instance: *mut GObject, handler_id: c_ulong);
2419    pub fn g_signal_handler_find(
2420        instance: *mut GObject,
2421        mask: GSignalMatchType,
2422        signal_id: c_uint,
2423        detail: glib::GQuark,
2424        closure: *mut GClosure,
2425        func: gpointer,
2426        data: gpointer,
2427    ) -> c_ulong;
2428    pub fn g_signal_handler_is_connected(instance: *mut GObject, handler_id: c_ulong) -> gboolean;
2429    pub fn g_signal_handler_unblock(instance: *mut GObject, handler_id: c_ulong);
2430    pub fn g_signal_handlers_block_matched(
2431        instance: *mut GObject,
2432        mask: GSignalMatchType,
2433        signal_id: c_uint,
2434        detail: glib::GQuark,
2435        closure: *mut GClosure,
2436        func: gpointer,
2437        data: gpointer,
2438    ) -> c_uint;
2439    pub fn g_signal_handlers_destroy(instance: *mut GObject);
2440    pub fn g_signal_handlers_disconnect_matched(
2441        instance: *mut GObject,
2442        mask: GSignalMatchType,
2443        signal_id: c_uint,
2444        detail: glib::GQuark,
2445        closure: *mut GClosure,
2446        func: gpointer,
2447        data: gpointer,
2448    ) -> c_uint;
2449    pub fn g_signal_handlers_unblock_matched(
2450        instance: *mut GObject,
2451        mask: GSignalMatchType,
2452        signal_id: c_uint,
2453        detail: glib::GQuark,
2454        closure: *mut GClosure,
2455        func: gpointer,
2456        data: gpointer,
2457    ) -> c_uint;
2458    pub fn g_signal_has_handler_pending(
2459        instance: *mut GObject,
2460        signal_id: c_uint,
2461        detail: glib::GQuark,
2462        may_be_blocked: gboolean,
2463    ) -> gboolean;
2464    pub fn g_signal_list_ids(itype: GType, n_ids: *mut c_uint) -> *mut c_uint;
2465    pub fn g_signal_lookup(name: *const c_char, itype: GType) -> c_uint;
2466    pub fn g_signal_name(signal_id: c_uint) -> *const c_char;
2467    pub fn g_signal_new(
2468        signal_name: *const c_char,
2469        itype: GType,
2470        signal_flags: GSignalFlags,
2471        class_offset: c_uint,
2472        accumulator: GSignalAccumulator,
2473        accu_data: gpointer,
2474        c_marshaller: GSignalCMarshaller,
2475        return_type: GType,
2476        n_params: c_uint,
2477        ...
2478    ) -> c_uint;
2479    pub fn g_signal_new_class_handler(
2480        signal_name: *const c_char,
2481        itype: GType,
2482        signal_flags: GSignalFlags,
2483        class_handler: GCallback,
2484        accumulator: GSignalAccumulator,
2485        accu_data: gpointer,
2486        c_marshaller: GSignalCMarshaller,
2487        return_type: GType,
2488        n_params: c_uint,
2489        ...
2490    ) -> c_uint;
2491    //pub fn g_signal_new_valist(signal_name: *const c_char, itype: GType, signal_flags: GSignalFlags, class_closure: *mut GClosure, accumulator: GSignalAccumulator, accu_data: gpointer, c_marshaller: GSignalCMarshaller, return_type: GType, n_params: c_uint, args: /*Unimplemented*/va_list) -> c_uint;
2492    pub fn g_signal_newv(
2493        signal_name: *const c_char,
2494        itype: GType,
2495        signal_flags: GSignalFlags,
2496        class_closure: *mut GClosure,
2497        accumulator: GSignalAccumulator,
2498        accu_data: gpointer,
2499        c_marshaller: GSignalCMarshaller,
2500        return_type: GType,
2501        n_params: c_uint,
2502        param_types: *mut GType,
2503    ) -> c_uint;
2504    pub fn g_signal_override_class_closure(
2505        signal_id: c_uint,
2506        instance_type: GType,
2507        class_closure: *mut GClosure,
2508    );
2509    pub fn g_signal_override_class_handler(
2510        signal_name: *const c_char,
2511        instance_type: GType,
2512        class_handler: GCallback,
2513    );
2514    pub fn g_signal_parse_name(
2515        detailed_signal: *const c_char,
2516        itype: GType,
2517        signal_id_p: *mut c_uint,
2518        detail_p: *mut glib::GQuark,
2519        force_detail_quark: gboolean,
2520    ) -> gboolean;
2521    pub fn g_signal_query(signal_id: c_uint, query: *mut GSignalQuery);
2522    pub fn g_signal_remove_emission_hook(signal_id: c_uint, hook_id: c_ulong);
2523    //pub fn g_signal_set_va_marshaller(signal_id: c_uint, instance_type: GType, va_marshaller: /*Ignored*/GSignalCVaMarshaller);
2524    pub fn g_signal_stop_emission(instance: *mut GObject, signal_id: c_uint, detail: glib::GQuark);
2525    pub fn g_signal_stop_emission_by_name(instance: *mut GObject, detailed_signal: *const c_char);
2526    pub fn g_signal_type_cclosure_new(itype: GType, struct_offset: c_uint) -> *mut GClosure;
2527    pub fn g_source_set_closure(source: *mut glib::GSource, closure: *mut GClosure);
2528    pub fn g_source_set_dummy_callback(source: *mut glib::GSource);
2529    pub fn g_strdup_value_contents(value: *const GValue) -> *mut c_char;
2530    pub fn g_type_add_class_cache_func(cache_data: gpointer, cache_func: GTypeClassCacheFunc);
2531    pub fn g_type_add_class_private(class_type: GType, private_size: size_t);
2532    pub fn g_type_add_instance_private(class_type: GType, private_size: size_t) -> c_int;
2533    pub fn g_type_add_interface_check(check_data: gpointer, check_func: GTypeInterfaceCheckFunc);
2534    pub fn g_type_add_interface_dynamic(
2535        instance_type: GType,
2536        interface_type: GType,
2537        plugin: *mut GTypePlugin,
2538    );
2539    pub fn g_type_add_interface_static(
2540        instance_type: GType,
2541        interface_type: GType,
2542        info: *const GInterfaceInfo,
2543    );
2544    pub fn g_type_check_class_cast(g_class: *mut GTypeClass, is_a_type: GType) -> *mut GTypeClass;
2545    pub fn g_type_check_class_is_a(g_class: *mut GTypeClass, is_a_type: GType) -> gboolean;
2546    pub fn g_type_check_instance(instance: *mut GTypeInstance) -> gboolean;
2547    pub fn g_type_check_instance_cast(
2548        instance: *mut GTypeInstance,
2549        iface_type: GType,
2550    ) -> *mut GTypeInstance;
2551    pub fn g_type_check_instance_is_a(instance: *mut GTypeInstance, iface_type: GType) -> gboolean;
2552    pub fn g_type_check_instance_is_fundamentally_a(
2553        instance: *mut GTypeInstance,
2554        fundamental_type: GType,
2555    ) -> gboolean;
2556    pub fn g_type_check_is_value_type(type_: GType) -> gboolean;
2557    pub fn g_type_check_value(value: *const GValue) -> gboolean;
2558    pub fn g_type_check_value_holds(value: *const GValue, type_: GType) -> gboolean;
2559    pub fn g_type_children(type_: GType, n_children: *mut c_uint) -> *mut GType;
2560    pub fn g_type_create_instance(type_: GType) -> *mut GTypeInstance;
2561    pub fn g_type_default_interface_peek(g_type: GType) -> gpointer;
2562    pub fn g_type_default_interface_ref(g_type: GType) -> gpointer;
2563    pub fn g_type_default_interface_unref(g_iface: gpointer);
2564    pub fn g_type_depth(type_: GType) -> c_uint;
2565    pub fn g_type_ensure(type_: GType);
2566    pub fn g_type_free_instance(instance: *mut GTypeInstance);
2567    pub fn g_type_from_name(name: *const c_char) -> GType;
2568    pub fn g_type_fundamental(type_id: GType) -> GType;
2569    pub fn g_type_fundamental_next() -> GType;
2570    #[cfg(any(feature = "v2_44", feature = "dox"))]
2571    pub fn g_type_get_instance_count(type_: GType) -> c_int;
2572    pub fn g_type_get_plugin(type_: GType) -> *mut GTypePlugin;
2573    pub fn g_type_get_qdata(type_: GType, quark: glib::GQuark) -> gpointer;
2574    pub fn g_type_get_type_registration_serial() -> c_uint;
2575    pub fn g_type_init();
2576    pub fn g_type_init_with_debug_flags(debug_flags: GTypeDebugFlags);
2577    pub fn g_type_interfaces(type_: GType, n_interfaces: *mut c_uint) -> *mut GType;
2578    pub fn g_type_is_a(type_: GType, is_a_type: GType) -> gboolean;
2579    pub fn g_type_name(type_: GType) -> *const c_char;
2580    pub fn g_type_name_from_class(g_class: *mut GTypeClass) -> *const c_char;
2581    pub fn g_type_name_from_instance(instance: *mut GTypeInstance) -> *const c_char;
2582    pub fn g_type_next_base(leaf_type: GType, root_type: GType) -> GType;
2583    pub fn g_type_parent(type_: GType) -> GType;
2584    pub fn g_type_qname(type_: GType) -> glib::GQuark;
2585    pub fn g_type_query(type_: GType, query: *mut GTypeQuery);
2586    pub fn g_type_register_dynamic(
2587        parent_type: GType,
2588        type_name: *const c_char,
2589        plugin: *mut GTypePlugin,
2590        flags: GTypeFlags,
2591    ) -> GType;
2592    pub fn g_type_register_fundamental(
2593        type_id: GType,
2594        type_name: *const c_char,
2595        info: *const GTypeInfo,
2596        finfo: *const GTypeFundamentalInfo,
2597        flags: GTypeFlags,
2598    ) -> GType;
2599    pub fn g_type_register_static(
2600        parent_type: GType,
2601        type_name: *const c_char,
2602        info: *const GTypeInfo,
2603        flags: GTypeFlags,
2604    ) -> GType;
2605    pub fn g_type_register_static_simple(
2606        parent_type: GType,
2607        type_name: *const c_char,
2608        class_size: c_uint,
2609        class_init: GClassInitFunc,
2610        instance_size: c_uint,
2611        instance_init: GInstanceInitFunc,
2612        flags: GTypeFlags,
2613    ) -> GType;
2614    pub fn g_type_remove_class_cache_func(cache_data: gpointer, cache_func: GTypeClassCacheFunc);
2615    pub fn g_type_remove_interface_check(check_data: gpointer, check_func: GTypeInterfaceCheckFunc);
2616    pub fn g_type_set_qdata(type_: GType, quark: glib::GQuark, data: gpointer);
2617    pub fn g_type_test_flags(type_: GType, flags: c_uint) -> gboolean;
2618
2619}