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