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