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