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