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