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(feature = "dox", feature(doc_cfg))] 13 14 use glib_sys as glib; 15 16 #[allow(unused_imports)] 17 use libc::{ 18 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void, 19 intptr_t, size_t, ssize_t, time_t, uintptr_t, FILE, 20 }; 21 22 #[allow(unused_imports)] 23 use glib::{gboolean, gconstpointer, gpointer, GType}; 24 25 pub const G_TYPE_INVALID: GType = 0 << G_TYPE_FUNDAMENTAL_SHIFT; 26 pub const G_TYPE_NONE: GType = 1 << G_TYPE_FUNDAMENTAL_SHIFT; 27 pub const G_TYPE_INTERFACE: GType = 2 << G_TYPE_FUNDAMENTAL_SHIFT; 28 pub const G_TYPE_CHAR: GType = 3 << G_TYPE_FUNDAMENTAL_SHIFT; 29 pub const G_TYPE_UCHAR: GType = 4 << G_TYPE_FUNDAMENTAL_SHIFT; 30 pub const G_TYPE_BOOLEAN: GType = 5 << G_TYPE_FUNDAMENTAL_SHIFT; 31 pub const G_TYPE_INT: GType = 6 << G_TYPE_FUNDAMENTAL_SHIFT; 32 pub const G_TYPE_UINT: GType = 7 << G_TYPE_FUNDAMENTAL_SHIFT; 33 pub const G_TYPE_LONG: GType = 8 << G_TYPE_FUNDAMENTAL_SHIFT; 34 pub const G_TYPE_ULONG: GType = 9 << G_TYPE_FUNDAMENTAL_SHIFT; 35 pub const G_TYPE_INT64: GType = 10 << G_TYPE_FUNDAMENTAL_SHIFT; 36 pub const G_TYPE_UINT64: GType = 11 << G_TYPE_FUNDAMENTAL_SHIFT; 37 pub const G_TYPE_ENUM: GType = 12 << G_TYPE_FUNDAMENTAL_SHIFT; 38 pub const G_TYPE_FLAGS: GType = 13 << G_TYPE_FUNDAMENTAL_SHIFT; 39 pub const G_TYPE_FLOAT: GType = 14 << G_TYPE_FUNDAMENTAL_SHIFT; 40 pub const G_TYPE_DOUBLE: GType = 15 << G_TYPE_FUNDAMENTAL_SHIFT; 41 pub const G_TYPE_STRING: GType = 16 << G_TYPE_FUNDAMENTAL_SHIFT; 42 pub const G_TYPE_POINTER: GType = 17 << G_TYPE_FUNDAMENTAL_SHIFT; 43 pub const G_TYPE_BOXED: GType = 18 << G_TYPE_FUNDAMENTAL_SHIFT; 44 pub const G_TYPE_PARAM: GType = 19 << G_TYPE_FUNDAMENTAL_SHIFT; 45 pub const G_TYPE_OBJECT: GType = 20 << G_TYPE_FUNDAMENTAL_SHIFT; 46 pub const G_TYPE_VARIANT: GType = 21 << G_TYPE_FUNDAMENTAL_SHIFT; 47 48 // Aliases 49 pub type GSignalCMarshaller = GClosureMarshal; 50 51 // Constants 52 pub const G_PARAM_MASK: c_int = 255; 53 pub const G_PARAM_STATIC_STRINGS: c_int = 224; 54 pub const G_PARAM_USER_SHIFT: c_int = 8; 55 pub const G_SIGNAL_FLAGS_MASK: c_int = 511; 56 pub const G_SIGNAL_MATCH_MASK: c_int = 63; 57 pub const G_TYPE_FLAG_RESERVED_ID_BIT: GType = 1; 58 pub const G_TYPE_FUNDAMENTAL_MAX: c_int = 255; 59 pub const G_TYPE_FUNDAMENTAL_SHIFT: c_int = 2; 60 pub const G_TYPE_RESERVED_BSE_FIRST: c_int = 32; 61 pub const G_TYPE_RESERVED_BSE_LAST: c_int = 48; 62 pub const G_TYPE_RESERVED_GLIB_FIRST: c_int = 22; 63 pub const G_TYPE_RESERVED_GLIB_LAST: c_int = 31; 64 pub const G_TYPE_RESERVED_USER_FIRST: c_int = 49; 65 pub const G_VALUE_INTERNED_STRING: c_int = 268435456; 66 pub const G_VALUE_NOCOPY_CONTENTS: c_int = 134217728; 67 68 // Flags 69 pub type GBindingFlags = c_uint; 70 pub const G_BINDING_DEFAULT: GBindingFlags = 0; 71 pub const G_BINDING_BIDIRECTIONAL: GBindingFlags = 1; 72 pub const G_BINDING_SYNC_CREATE: GBindingFlags = 2; 73 pub const G_BINDING_INVERT_BOOLEAN: GBindingFlags = 4; 74 75 pub type GConnectFlags = c_uint; 76 pub const G_CONNECT_AFTER: GConnectFlags = 1; 77 pub const G_CONNECT_SWAPPED: GConnectFlags = 2; 78 79 pub type GParamFlags = c_uint; 80 pub const G_PARAM_READABLE: GParamFlags = 1; 81 pub const G_PARAM_WRITABLE: GParamFlags = 2; 82 pub const G_PARAM_READWRITE: GParamFlags = 3; 83 pub const G_PARAM_CONSTRUCT: GParamFlags = 4; 84 pub const G_PARAM_CONSTRUCT_ONLY: GParamFlags = 8; 85 pub const G_PARAM_LAX_VALIDATION: GParamFlags = 16; 86 pub const G_PARAM_STATIC_NAME: GParamFlags = 32; 87 pub const G_PARAM_PRIVATE: GParamFlags = 32; 88 pub const G_PARAM_STATIC_NICK: GParamFlags = 64; 89 pub const G_PARAM_STATIC_BLURB: GParamFlags = 128; 90 pub const G_PARAM_EXPLICIT_NOTIFY: GParamFlags = 1073741824; 91 pub const G_PARAM_DEPRECATED: GParamFlags = 2147483648; 92 93 pub type GSignalFlags = c_uint; 94 pub const G_SIGNAL_RUN_FIRST: GSignalFlags = 1; 95 pub const G_SIGNAL_RUN_LAST: GSignalFlags = 2; 96 pub const G_SIGNAL_RUN_CLEANUP: GSignalFlags = 4; 97 pub const G_SIGNAL_NO_RECURSE: GSignalFlags = 8; 98 pub const G_SIGNAL_DETAILED: GSignalFlags = 16; 99 pub const G_SIGNAL_ACTION: GSignalFlags = 32; 100 pub const G_SIGNAL_NO_HOOKS: GSignalFlags = 64; 101 pub const G_SIGNAL_MUST_COLLECT: GSignalFlags = 128; 102 pub const G_SIGNAL_DEPRECATED: GSignalFlags = 256; 103 104 pub type GSignalMatchType = c_uint; 105 pub const G_SIGNAL_MATCH_ID: GSignalMatchType = 1; 106 pub const G_SIGNAL_MATCH_DETAIL: GSignalMatchType = 2; 107 pub const G_SIGNAL_MATCH_CLOSURE: GSignalMatchType = 4; 108 pub const G_SIGNAL_MATCH_FUNC: GSignalMatchType = 8; 109 pub const G_SIGNAL_MATCH_DATA: GSignalMatchType = 16; 110 pub const G_SIGNAL_MATCH_UNBLOCKED: GSignalMatchType = 32; 111 112 pub type GTypeDebugFlags = c_uint; 113 pub const G_TYPE_DEBUG_NONE: GTypeDebugFlags = 0; 114 pub const G_TYPE_DEBUG_OBJECTS: GTypeDebugFlags = 1; 115 pub const G_TYPE_DEBUG_SIGNALS: GTypeDebugFlags = 2; 116 pub const G_TYPE_DEBUG_INSTANCE_COUNT: GTypeDebugFlags = 4; 117 pub const G_TYPE_DEBUG_MASK: GTypeDebugFlags = 7; 118 119 pub type GTypeFlags = c_uint; 120 pub const G_TYPE_FLAG_ABSTRACT: GTypeFlags = 16; 121 pub const G_TYPE_FLAG_VALUE_ABSTRACT: GTypeFlags = 32; 122 123 pub type GTypeFundamentalFlags = c_uint; 124 pub const G_TYPE_FLAG_CLASSED: GTypeFundamentalFlags = 1; 125 pub const G_TYPE_FLAG_INSTANTIATABLE: GTypeFundamentalFlags = 2; 126 pub const G_TYPE_FLAG_DERIVABLE: GTypeFundamentalFlags = 4; 127 pub const G_TYPE_FLAG_DEEP_DERIVABLE: GTypeFundamentalFlags = 8; 128 129 // Unions 130 #[repr(C)] 131 pub struct GTypeCValue(c_void); 132 133 impl ::std::fmt::Debug for GTypeCValue { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result134 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 135 f.debug_struct(&format!("GTypeCValue @ {:p}", self)) 136 .finish() 137 } 138 } 139 140 #[repr(C)] 141 #[derive(Copy, Clone)] 142 pub union GValue_data { 143 pub v_int: c_int, 144 pub v_uint: c_uint, 145 pub v_long: c_long, 146 pub v_ulong: c_ulong, 147 pub v_int64: i64, 148 pub v_uint64: u64, 149 pub v_float: c_float, 150 pub v_double: c_double, 151 pub v_pointer: gpointer, 152 } 153 154 impl ::std::fmt::Debug for GValue_data { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result155 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 156 f.debug_struct(&format!("GValue_data @ {:p}", self)) 157 .field("v_int", unsafe { &self.v_int }) 158 .field("v_uint", unsafe { &self.v_uint }) 159 .field("v_long", unsafe { &self.v_long }) 160 .field("v_ulong", unsafe { &self.v_ulong }) 161 .field("v_int64", unsafe { &self.v_int64 }) 162 .field("v_uint64", unsafe { &self.v_uint64 }) 163 .field("v_float", unsafe { &self.v_float }) 164 .field("v_double", unsafe { &self.v_double }) 165 .field("v_pointer", unsafe { &self.v_pointer }) 166 .finish() 167 } 168 } 169 170 #[repr(C)] 171 #[derive(Copy, Clone)] 172 pub union GWeakRef_priv { 173 pub p: gpointer, 174 } 175 176 impl ::std::fmt::Debug for GWeakRef_priv { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result177 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 178 f.debug_struct(&format!("GWeakRef_priv @ {:p}", self)) 179 .field("p", unsafe { &self.p }) 180 .finish() 181 } 182 } 183 184 // Callbacks 185 pub type GBaseFinalizeFunc = Option<unsafe extern "C" fn(gpointer)>; 186 pub type GBaseInitFunc = Option<unsafe extern "C" fn(gpointer)>; 187 pub type GBindingTransformFunc = 188 Option<unsafe extern "C" fn(*mut GBinding, *const GValue, *mut GValue, gpointer) -> gboolean>; 189 pub type GBoxedCopyFunc = Option<unsafe extern "C" fn(gpointer) -> gpointer>; 190 pub type GBoxedFreeFunc = Option<unsafe extern "C" fn(gpointer)>; 191 pub type GCallback = Option<unsafe extern "C" fn()>; 192 pub type GClassFinalizeFunc = Option<unsafe extern "C" fn(gpointer, gpointer)>; 193 pub type GClassInitFunc = Option<unsafe extern "C" fn(gpointer, gpointer)>; 194 pub type GClosureMarshal = Option< 195 unsafe extern "C" fn(*mut GClosure, *mut GValue, c_uint, *const GValue, gpointer, gpointer), 196 >; 197 pub type GClosureNotify = Option<unsafe extern "C" fn(gpointer, *mut GClosure)>; 198 pub type GInstanceInitFunc = Option<unsafe extern "C" fn(*mut GTypeInstance, gpointer)>; 199 pub type GInterfaceFinalizeFunc = Option<unsafe extern "C" fn(gpointer, gpointer)>; 200 pub type GInterfaceInitFunc = Option<unsafe extern "C" fn(gpointer, gpointer)>; 201 pub type GObjectFinalizeFunc = Option<unsafe extern "C" fn(*mut GObject)>; 202 pub type GObjectGetPropertyFunc = 203 Option<unsafe extern "C" fn(*mut GObject, c_uint, *mut GValue, *mut GParamSpec)>; 204 pub type GObjectSetPropertyFunc = 205 Option<unsafe extern "C" fn(*mut GObject, c_uint, *const GValue, *mut GParamSpec)>; 206 pub type GSignalAccumulator = Option< 207 unsafe extern "C" fn( 208 *mut GSignalInvocationHint, 209 *mut GValue, 210 *const GValue, 211 gpointer, 212 ) -> gboolean, 213 >; 214 pub type GSignalEmissionHook = Option< 215 unsafe extern "C" fn(*mut GSignalInvocationHint, c_uint, *const GValue, gpointer) -> gboolean, 216 >; 217 pub type GToggleNotify = Option<unsafe extern "C" fn(gpointer, *mut GObject, gboolean)>; 218 pub type GTypeClassCacheFunc = Option<unsafe extern "C" fn(gpointer, *mut GTypeClass) -> gboolean>; 219 pub type GTypeInterfaceCheckFunc = Option<unsafe extern "C" fn(gpointer, gpointer)>; 220 pub type GTypePluginCompleteInterfaceInfo = 221 Option<unsafe extern "C" fn(*mut GTypePlugin, GType, GType, *mut GInterfaceInfo)>; 222 pub type GTypePluginCompleteTypeInfo = 223 Option<unsafe extern "C" fn(*mut GTypePlugin, GType, *mut GTypeInfo, *mut GTypeValueTable)>; 224 pub type GTypePluginUnuse = Option<unsafe extern "C" fn(*mut GTypePlugin)>; 225 pub type GTypePluginUse = Option<unsafe extern "C" fn(*mut GTypePlugin)>; 226 //pub type GVaClosureMarshal = Option<unsafe extern "C" fn(*mut GClosure, *mut GValue, gpointer, /*Unimplemented*/va_list, gpointer, c_int, *mut GType)>; 227 pub type GValueTransform = Option<unsafe extern "C" fn(*const GValue, *mut GValue)>; 228 pub type GWeakNotify = Option<unsafe extern "C" fn(gpointer, *mut GObject)>; 229 230 // Records 231 #[repr(C)] 232 pub struct GCClosure { 233 _truncated_record_marker: c_void, 234 // /*Ignored*/field closure has incomplete type 235 } 236 237 impl ::std::fmt::Debug for GCClosure { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result238 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 239 f.debug_struct(&format!("GCClosure @ {:p}", self)).finish() 240 } 241 } 242 243 #[repr(C)] 244 pub struct GClosure { 245 pub ref_count: c_uint, 246 _truncated_record_marker: c_void, 247 // field meta_marshal_nouse has incomplete type 248 } 249 250 impl ::std::fmt::Debug for GClosure { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result251 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 252 f.debug_struct(&format!("GClosure @ {:p}", self)).finish() 253 } 254 } 255 256 #[repr(C)] 257 #[derive(Copy, Clone)] 258 pub struct GClosureNotifyData { 259 pub data: gpointer, 260 pub notify: GClosureNotify, 261 } 262 263 impl ::std::fmt::Debug for GClosureNotifyData { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result264 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 265 f.debug_struct(&format!("GClosureNotifyData @ {:p}", self)) 266 .field("data", &self.data) 267 .field("notify", &self.notify) 268 .finish() 269 } 270 } 271 272 #[repr(C)] 273 #[derive(Copy, Clone)] 274 pub struct GEnumClass { 275 pub g_type_class: GTypeClass, 276 pub minimum: c_int, 277 pub maximum: c_int, 278 pub n_values: c_uint, 279 pub values: *mut GEnumValue, 280 } 281 282 impl ::std::fmt::Debug for GEnumClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result283 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 284 f.debug_struct(&format!("GEnumClass @ {:p}", self)) 285 .field("g_type_class", &self.g_type_class) 286 .field("minimum", &self.minimum) 287 .field("maximum", &self.maximum) 288 .field("n_values", &self.n_values) 289 .field("values", &self.values) 290 .finish() 291 } 292 } 293 294 #[repr(C)] 295 #[derive(Copy, Clone)] 296 pub struct GEnumValue { 297 pub value: c_int, 298 pub value_name: *const c_char, 299 pub value_nick: *const c_char, 300 } 301 302 impl ::std::fmt::Debug for GEnumValue { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result303 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 304 f.debug_struct(&format!("GEnumValue @ {:p}", self)) 305 .field("value", &self.value) 306 .field("value_name", &self.value_name) 307 .field("value_nick", &self.value_nick) 308 .finish() 309 } 310 } 311 312 #[repr(C)] 313 #[derive(Copy, Clone)] 314 pub struct GFlagsClass { 315 pub g_type_class: GTypeClass, 316 pub mask: c_uint, 317 pub n_values: c_uint, 318 pub values: *mut GFlagsValue, 319 } 320 321 impl ::std::fmt::Debug for GFlagsClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result322 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 323 f.debug_struct(&format!("GFlagsClass @ {:p}", self)) 324 .field("g_type_class", &self.g_type_class) 325 .field("mask", &self.mask) 326 .field("n_values", &self.n_values) 327 .field("values", &self.values) 328 .finish() 329 } 330 } 331 332 #[repr(C)] 333 #[derive(Copy, Clone)] 334 pub struct GFlagsValue { 335 pub value: c_uint, 336 pub value_name: *const c_char, 337 pub value_nick: *const c_char, 338 } 339 340 impl ::std::fmt::Debug for GFlagsValue { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result341 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 342 f.debug_struct(&format!("GFlagsValue @ {:p}", self)) 343 .field("value", &self.value) 344 .field("value_name", &self.value_name) 345 .field("value_nick", &self.value_nick) 346 .finish() 347 } 348 } 349 350 #[repr(C)] 351 #[derive(Copy, Clone)] 352 pub struct GInitiallyUnownedClass { 353 pub g_type_class: GTypeClass, 354 pub construct_properties: *mut glib::GSList, 355 pub constructor: 356 Option<unsafe extern "C" fn(GType, c_uint, *mut GObjectConstructParam) -> *mut GObject>, 357 pub set_property: 358 Option<unsafe extern "C" fn(*mut GObject, c_uint, *mut GValue, *mut GParamSpec)>, 359 pub get_property: 360 Option<unsafe extern "C" fn(*mut GObject, c_uint, *mut GValue, *mut GParamSpec)>, 361 pub dispose: Option<unsafe extern "C" fn(*mut GObject)>, 362 pub finalize: Option<unsafe extern "C" fn(*mut GObject)>, 363 pub dispatch_properties_changed: 364 Option<unsafe extern "C" fn(*mut GObject, c_uint, *mut *mut GParamSpec)>, 365 pub notify: Option<unsafe extern "C" fn(*mut GObject, *mut GParamSpec)>, 366 pub constructed: Option<unsafe extern "C" fn(*mut GObject)>, 367 pub flags: size_t, 368 pub pdummy: [gpointer; 6], 369 } 370 371 impl ::std::fmt::Debug for GInitiallyUnownedClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result372 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 373 f.debug_struct(&format!("GInitiallyUnownedClass @ {:p}", self)) 374 .field("g_type_class", &self.g_type_class) 375 .field("constructor", &self.constructor) 376 .field("set_property", &self.set_property) 377 .field("get_property", &self.get_property) 378 .field("dispose", &self.dispose) 379 .field("finalize", &self.finalize) 380 .field( 381 "dispatch_properties_changed", 382 &self.dispatch_properties_changed, 383 ) 384 .field("notify", &self.notify) 385 .field("constructed", &self.constructed) 386 .finish() 387 } 388 } 389 390 #[repr(C)] 391 #[derive(Copy, Clone)] 392 pub struct GInterfaceInfo { 393 pub interface_init: GInterfaceInitFunc, 394 pub interface_finalize: GInterfaceFinalizeFunc, 395 pub interface_data: gpointer, 396 } 397 398 impl ::std::fmt::Debug for GInterfaceInfo { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result399 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 400 f.debug_struct(&format!("GInterfaceInfo @ {:p}", self)) 401 .field("interface_init", &self.interface_init) 402 .field("interface_finalize", &self.interface_finalize) 403 .field("interface_data", &self.interface_data) 404 .finish() 405 } 406 } 407 408 #[repr(C)] 409 #[derive(Copy, Clone)] 410 pub struct GObjectClass { 411 pub g_type_class: GTypeClass, 412 pub construct_properties: *mut glib::GSList, 413 pub constructor: 414 Option<unsafe extern "C" fn(GType, c_uint, *mut GObjectConstructParam) -> *mut GObject>, 415 pub set_property: 416 Option<unsafe extern "C" fn(*mut GObject, c_uint, *mut GValue, *mut GParamSpec)>, 417 pub get_property: 418 Option<unsafe extern "C" fn(*mut GObject, c_uint, *mut GValue, *mut GParamSpec)>, 419 pub dispose: Option<unsafe extern "C" fn(*mut GObject)>, 420 pub finalize: Option<unsafe extern "C" fn(*mut GObject)>, 421 pub dispatch_properties_changed: 422 Option<unsafe extern "C" fn(*mut GObject, c_uint, *mut *mut GParamSpec)>, 423 pub notify: Option<unsafe extern "C" fn(*mut GObject, *mut GParamSpec)>, 424 pub constructed: Option<unsafe extern "C" fn(*mut GObject)>, 425 pub flags: size_t, 426 pub pdummy: [gpointer; 6], 427 } 428 429 impl ::std::fmt::Debug for GObjectClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result430 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 431 f.debug_struct(&format!("GObjectClass @ {:p}", self)) 432 .field("g_type_class", &self.g_type_class) 433 .field("constructor", &self.constructor) 434 .field("set_property", &self.set_property) 435 .field("get_property", &self.get_property) 436 .field("dispose", &self.dispose) 437 .field("finalize", &self.finalize) 438 .field( 439 "dispatch_properties_changed", 440 &self.dispatch_properties_changed, 441 ) 442 .field("notify", &self.notify) 443 .field("constructed", &self.constructed) 444 .finish() 445 } 446 } 447 448 #[repr(C)] 449 #[derive(Copy, Clone)] 450 pub struct GObjectConstructParam { 451 pub pspec: *mut GParamSpec, 452 pub value: *mut GValue, 453 } 454 455 impl ::std::fmt::Debug for GObjectConstructParam { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result456 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 457 f.debug_struct(&format!("GObjectConstructParam @ {:p}", self)) 458 .field("pspec", &self.pspec) 459 .field("value", &self.value) 460 .finish() 461 } 462 } 463 464 #[repr(C)] 465 #[derive(Copy, Clone)] 466 pub struct GParamSpecClass { 467 pub g_type_class: GTypeClass, 468 pub value_type: GType, 469 pub finalize: Option<unsafe extern "C" fn(*mut GParamSpec)>, 470 pub value_set_default: Option<unsafe extern "C" fn(*mut GParamSpec, *mut GValue)>, 471 pub value_validate: Option<unsafe extern "C" fn(*mut GParamSpec, *mut GValue) -> gboolean>, 472 pub values_cmp: 473 Option<unsafe extern "C" fn(*mut GParamSpec, *const GValue, *const GValue) -> c_int>, 474 pub dummy: [gpointer; 4], 475 } 476 477 impl ::std::fmt::Debug for GParamSpecClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result478 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 479 f.debug_struct(&format!("GParamSpecClass @ {:p}", self)) 480 .field("g_type_class", &self.g_type_class) 481 .field("value_type", &self.value_type) 482 .field("finalize", &self.finalize) 483 .field("value_set_default", &self.value_set_default) 484 .field("value_validate", &self.value_validate) 485 .field("values_cmp", &self.values_cmp) 486 .finish() 487 } 488 } 489 490 #[repr(C)] 491 pub struct _GParamSpecPool(c_void); 492 493 pub type GParamSpecPool = *mut _GParamSpecPool; 494 495 #[repr(C)] 496 #[derive(Copy, Clone)] 497 pub struct GParamSpecTypeInfo { 498 pub instance_size: u16, 499 pub n_preallocs: u16, 500 pub instance_init: Option<unsafe extern "C" fn(*mut GParamSpec)>, 501 pub value_type: GType, 502 pub finalize: Option<unsafe extern "C" fn(*mut GParamSpec)>, 503 pub value_set_default: Option<unsafe extern "C" fn(*mut GParamSpec, *mut GValue)>, 504 pub value_validate: Option<unsafe extern "C" fn(*mut GParamSpec, *mut GValue) -> gboolean>, 505 pub values_cmp: 506 Option<unsafe extern "C" fn(*mut GParamSpec, *const GValue, *const GValue) -> c_int>, 507 } 508 509 impl ::std::fmt::Debug for GParamSpecTypeInfo { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result510 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 511 f.debug_struct(&format!("GParamSpecTypeInfo @ {:p}", self)) 512 .field("instance_size", &self.instance_size) 513 .field("n_preallocs", &self.n_preallocs) 514 .field("instance_init", &self.instance_init) 515 .field("value_type", &self.value_type) 516 .field("finalize", &self.finalize) 517 .field("value_set_default", &self.value_set_default) 518 .field("value_validate", &self.value_validate) 519 .field("values_cmp", &self.values_cmp) 520 .finish() 521 } 522 } 523 524 #[repr(C)] 525 #[derive(Copy, Clone)] 526 pub struct GParameter { 527 pub name: *const c_char, 528 pub value: GValue, 529 } 530 531 impl ::std::fmt::Debug for GParameter { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result532 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 533 f.debug_struct(&format!("GParameter @ {:p}", self)) 534 .field("name", &self.name) 535 .field("value", &self.value) 536 .finish() 537 } 538 } 539 540 #[repr(C)] 541 #[derive(Copy, Clone)] 542 pub struct GSignalInvocationHint { 543 pub signal_id: c_uint, 544 pub detail: glib::GQuark, 545 pub run_type: GSignalFlags, 546 } 547 548 impl ::std::fmt::Debug for GSignalInvocationHint { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result549 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 550 f.debug_struct(&format!("GSignalInvocationHint @ {:p}", self)) 551 .field("signal_id", &self.signal_id) 552 .field("detail", &self.detail) 553 .field("run_type", &self.run_type) 554 .finish() 555 } 556 } 557 558 #[repr(C)] 559 #[derive(Copy, Clone)] 560 pub struct GSignalQuery { 561 pub signal_id: c_uint, 562 pub signal_name: *const c_char, 563 pub itype: GType, 564 pub signal_flags: GSignalFlags, 565 pub return_type: GType, 566 pub n_params: c_uint, 567 pub param_types: *const GType, 568 } 569 570 impl ::std::fmt::Debug for GSignalQuery { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result571 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 572 f.debug_struct(&format!("GSignalQuery @ {:p}", self)) 573 .field("signal_id", &self.signal_id) 574 .field("signal_name", &self.signal_name) 575 .field("itype", &self.itype) 576 .field("signal_flags", &self.signal_flags) 577 .field("return_type", &self.return_type) 578 .field("n_params", &self.n_params) 579 .field("param_types", &self.param_types) 580 .finish() 581 } 582 } 583 584 #[repr(C)] 585 #[derive(Copy, Clone)] 586 pub struct GTypeClass { 587 pub g_type: GType, 588 } 589 590 impl ::std::fmt::Debug for GTypeClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result591 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 592 f.debug_struct(&format!("GTypeClass @ {:p}", self)).finish() 593 } 594 } 595 596 #[repr(C)] 597 #[derive(Copy, Clone)] 598 pub struct GTypeFundamentalInfo { 599 pub type_flags: GTypeFundamentalFlags, 600 } 601 602 impl ::std::fmt::Debug for GTypeFundamentalInfo { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result603 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 604 f.debug_struct(&format!("GTypeFundamentalInfo @ {:p}", self)) 605 .field("type_flags", &self.type_flags) 606 .finish() 607 } 608 } 609 610 #[repr(C)] 611 #[derive(Copy, Clone)] 612 pub struct GTypeInfo { 613 pub class_size: u16, 614 pub base_init: GBaseInitFunc, 615 pub base_finalize: GBaseFinalizeFunc, 616 pub class_init: GClassInitFunc, 617 pub class_finalize: GClassFinalizeFunc, 618 pub class_data: gconstpointer, 619 pub instance_size: u16, 620 pub n_preallocs: u16, 621 pub instance_init: GInstanceInitFunc, 622 pub value_table: *const GTypeValueTable, 623 } 624 625 impl ::std::fmt::Debug for GTypeInfo { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result626 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 627 f.debug_struct(&format!("GTypeInfo @ {:p}", self)) 628 .field("class_size", &self.class_size) 629 .field("base_init", &self.base_init) 630 .field("base_finalize", &self.base_finalize) 631 .field("class_init", &self.class_init) 632 .field("class_finalize", &self.class_finalize) 633 .field("class_data", &self.class_data) 634 .field("instance_size", &self.instance_size) 635 .field("n_preallocs", &self.n_preallocs) 636 .field("instance_init", &self.instance_init) 637 .field("value_table", &self.value_table) 638 .finish() 639 } 640 } 641 642 #[repr(C)] 643 #[derive(Copy, Clone)] 644 pub struct GTypeInstance { 645 pub g_class: *mut GTypeClass, 646 } 647 648 impl ::std::fmt::Debug for GTypeInstance { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result649 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 650 f.debug_struct(&format!("GTypeInstance @ {:p}", self)) 651 .finish() 652 } 653 } 654 655 #[repr(C)] 656 #[derive(Copy, Clone)] 657 pub struct GTypeInterface { 658 pub g_type: GType, 659 pub g_instance_type: GType, 660 } 661 662 impl ::std::fmt::Debug for GTypeInterface { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result663 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 664 f.debug_struct(&format!("GTypeInterface @ {:p}", self)) 665 .finish() 666 } 667 } 668 669 #[repr(C)] 670 #[derive(Copy, Clone)] 671 pub struct GTypeModuleClass { 672 pub parent_class: GObjectClass, 673 pub load: Option<unsafe extern "C" fn(*mut GTypeModule) -> gboolean>, 674 pub unload: Option<unsafe extern "C" fn(*mut GTypeModule)>, 675 pub reserved1: Option<unsafe extern "C" fn()>, 676 pub reserved2: Option<unsafe extern "C" fn()>, 677 pub reserved3: Option<unsafe extern "C" fn()>, 678 pub reserved4: Option<unsafe extern "C" fn()>, 679 } 680 681 impl ::std::fmt::Debug for GTypeModuleClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result682 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 683 f.debug_struct(&format!("GTypeModuleClass @ {:p}", self)) 684 .field("parent_class", &self.parent_class) 685 .field("load", &self.load) 686 .field("unload", &self.unload) 687 .field("reserved1", &self.reserved1) 688 .field("reserved2", &self.reserved2) 689 .field("reserved3", &self.reserved3) 690 .field("reserved4", &self.reserved4) 691 .finish() 692 } 693 } 694 695 #[repr(C)] 696 #[derive(Copy, Clone)] 697 pub struct GTypePluginClass { 698 pub base_iface: GTypeInterface, 699 pub use_plugin: GTypePluginUse, 700 pub unuse_plugin: GTypePluginUnuse, 701 pub complete_type_info: GTypePluginCompleteTypeInfo, 702 pub complete_interface_info: GTypePluginCompleteInterfaceInfo, 703 } 704 705 impl ::std::fmt::Debug for GTypePluginClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result706 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 707 f.debug_struct(&format!("GTypePluginClass @ {:p}", self)) 708 .field("use_plugin", &self.use_plugin) 709 .field("unuse_plugin", &self.unuse_plugin) 710 .field("complete_type_info", &self.complete_type_info) 711 .field("complete_interface_info", &self.complete_interface_info) 712 .finish() 713 } 714 } 715 716 #[repr(C)] 717 #[derive(Copy, Clone)] 718 pub struct GTypeQuery { 719 pub type_: GType, 720 pub type_name: *const c_char, 721 pub class_size: c_uint, 722 pub instance_size: c_uint, 723 } 724 725 impl ::std::fmt::Debug for GTypeQuery { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result726 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 727 f.debug_struct(&format!("GTypeQuery @ {:p}", self)) 728 .field("type_", &self.type_) 729 .field("type_name", &self.type_name) 730 .field("class_size", &self.class_size) 731 .field("instance_size", &self.instance_size) 732 .finish() 733 } 734 } 735 736 #[repr(C)] 737 #[derive(Copy, Clone)] 738 pub struct GTypeValueTable { 739 pub value_init: Option<unsafe extern "C" fn(*mut GValue)>, 740 pub value_free: Option<unsafe extern "C" fn(*mut GValue)>, 741 pub value_copy: Option<unsafe extern "C" fn(*const GValue, *mut GValue)>, 742 pub value_peek_pointer: Option<unsafe extern "C" fn(*const GValue) -> gpointer>, 743 pub collect_format: *const c_char, 744 pub collect_value: Option< 745 unsafe extern "C" fn(*const GValue, c_uint, *mut GTypeCValue, c_uint) -> *mut c_char, 746 >, 747 pub lcopy_format: *const c_char, 748 pub lcopy_value: Option< 749 unsafe extern "C" fn(*const GValue, c_uint, *mut GTypeCValue, c_uint) -> *mut c_char, 750 >, 751 } 752 753 impl ::std::fmt::Debug for GTypeValueTable { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result754 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 755 f.debug_struct(&format!("GTypeValueTable @ {:p}", self)) 756 .field("value_init", &self.value_init) 757 .field("value_free", &self.value_free) 758 .field("value_copy", &self.value_copy) 759 .field("value_peek_pointer", &self.value_peek_pointer) 760 .field("collect_format", &self.collect_format) 761 .field("collect_value", &self.collect_value) 762 .field("lcopy_format", &self.lcopy_format) 763 .field("lcopy_value", &self.lcopy_value) 764 .finish() 765 } 766 } 767 768 #[repr(C)] 769 #[derive(Copy, Clone)] 770 pub struct GValue { 771 pub g_type: GType, 772 pub data: [GValue_data; 2], 773 } 774 775 impl ::std::fmt::Debug for GValue { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result776 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 777 f.debug_struct(&format!("GValue @ {:p}", self)) 778 .field("data", &self.data) 779 .finish() 780 } 781 } 782 783 #[repr(C)] 784 #[derive(Copy, Clone)] 785 pub struct GValueArray { 786 pub n_values: c_uint, 787 pub values: *mut GValue, 788 pub n_prealloced: c_uint, 789 } 790 791 impl ::std::fmt::Debug for GValueArray { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result792 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 793 f.debug_struct(&format!("GValueArray @ {:p}", self)) 794 .field("n_values", &self.n_values) 795 .field("values", &self.values) 796 .finish() 797 } 798 } 799 800 #[repr(C)] 801 #[derive(Copy, Clone)] 802 pub struct GWeakRef { 803 pub priv_: GWeakRef_priv, 804 } 805 806 impl ::std::fmt::Debug for GWeakRef { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result807 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 808 f.debug_struct(&format!("GWeakRef @ {:p}", self)) 809 .field("priv_", &self.priv_) 810 .finish() 811 } 812 } 813 814 // Classes 815 #[repr(C)] 816 pub struct GBinding(c_void); 817 818 impl ::std::fmt::Debug for GBinding { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result819 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 820 f.debug_struct(&format!("GBinding @ {:p}", self)).finish() 821 } 822 } 823 824 #[repr(C)] 825 #[derive(Copy, Clone)] 826 pub struct GInitiallyUnowned { 827 pub g_type_instance: GTypeInstance, 828 pub ref_count: c_uint, 829 pub qdata: *mut glib::GData, 830 } 831 832 impl ::std::fmt::Debug for GInitiallyUnowned { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result833 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 834 f.debug_struct(&format!("GInitiallyUnowned @ {:p}", self)) 835 .field("g_type_instance", &self.g_type_instance) 836 .finish() 837 } 838 } 839 840 #[repr(C)] 841 #[derive(Copy, Clone)] 842 pub struct GObject { 843 pub g_type_instance: GTypeInstance, 844 pub ref_count: c_uint, 845 pub qdata: *mut glib::GData, 846 } 847 848 impl ::std::fmt::Debug for GObject { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result849 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 850 f.debug_struct(&format!("GObject @ {:p}", self)) 851 .field("g_type_instance", &self.g_type_instance) 852 .finish() 853 } 854 } 855 856 #[repr(C)] 857 #[derive(Copy, Clone)] 858 pub struct GParamSpec { 859 pub g_type_instance: GTypeInstance, 860 pub name: *const c_char, 861 pub flags: GParamFlags, 862 pub value_type: GType, 863 pub owner_type: GType, 864 pub _nick: *mut c_char, 865 pub _blurb: *mut c_char, 866 pub qdata: *mut glib::GData, 867 pub ref_count: c_uint, 868 pub param_id: c_uint, 869 } 870 871 impl ::std::fmt::Debug for GParamSpec { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result872 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 873 f.debug_struct(&format!("GParamSpec @ {:p}", self)) 874 .field("g_type_instance", &self.g_type_instance) 875 .field("name", &self.name) 876 .field("flags", &self.flags) 877 .field("value_type", &self.value_type) 878 .field("owner_type", &self.owner_type) 879 .finish() 880 } 881 } 882 883 #[repr(C)] 884 #[derive(Copy, Clone)] 885 pub struct GParamSpecBoolean { 886 pub parent_instance: GParamSpec, 887 pub default_value: gboolean, 888 } 889 890 impl ::std::fmt::Debug for GParamSpecBoolean { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result891 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 892 f.debug_struct(&format!("GParamSpecBoolean @ {:p}", self)) 893 .field("parent_instance", &self.parent_instance) 894 .field("default_value", &self.default_value) 895 .finish() 896 } 897 } 898 899 #[repr(C)] 900 #[derive(Copy, Clone)] 901 pub struct GParamSpecBoxed { 902 pub parent_instance: GParamSpec, 903 } 904 905 impl ::std::fmt::Debug for GParamSpecBoxed { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result906 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 907 f.debug_struct(&format!("GParamSpecBoxed @ {:p}", self)) 908 .field("parent_instance", &self.parent_instance) 909 .finish() 910 } 911 } 912 913 #[repr(C)] 914 #[derive(Copy, Clone)] 915 pub struct GParamSpecChar { 916 pub parent_instance: GParamSpec, 917 pub minimum: i8, 918 pub maximum: i8, 919 pub default_value: i8, 920 } 921 922 impl ::std::fmt::Debug for GParamSpecChar { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result923 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 924 f.debug_struct(&format!("GParamSpecChar @ {:p}", self)) 925 .field("parent_instance", &self.parent_instance) 926 .field("minimum", &self.minimum) 927 .field("maximum", &self.maximum) 928 .field("default_value", &self.default_value) 929 .finish() 930 } 931 } 932 933 #[repr(C)] 934 #[derive(Copy, Clone)] 935 pub struct GParamSpecDouble { 936 pub parent_instance: GParamSpec, 937 pub minimum: c_double, 938 pub maximum: c_double, 939 pub default_value: c_double, 940 pub epsilon: c_double, 941 } 942 943 impl ::std::fmt::Debug for GParamSpecDouble { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result944 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 945 f.debug_struct(&format!("GParamSpecDouble @ {:p}", self)) 946 .field("parent_instance", &self.parent_instance) 947 .field("minimum", &self.minimum) 948 .field("maximum", &self.maximum) 949 .field("default_value", &self.default_value) 950 .field("epsilon", &self.epsilon) 951 .finish() 952 } 953 } 954 955 #[repr(C)] 956 #[derive(Copy, Clone)] 957 pub struct GParamSpecEnum { 958 pub parent_instance: GParamSpec, 959 pub enum_class: *mut GEnumClass, 960 pub default_value: c_int, 961 } 962 963 impl ::std::fmt::Debug for GParamSpecEnum { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result964 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 965 f.debug_struct(&format!("GParamSpecEnum @ {:p}", self)) 966 .field("parent_instance", &self.parent_instance) 967 .field("enum_class", &self.enum_class) 968 .field("default_value", &self.default_value) 969 .finish() 970 } 971 } 972 973 #[repr(C)] 974 #[derive(Copy, Clone)] 975 pub struct GParamSpecFlags { 976 pub parent_instance: GParamSpec, 977 pub flags_class: *mut GFlagsClass, 978 pub default_value: c_uint, 979 } 980 981 impl ::std::fmt::Debug for GParamSpecFlags { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result982 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 983 f.debug_struct(&format!("GParamSpecFlags @ {:p}", self)) 984 .field("parent_instance", &self.parent_instance) 985 .field("flags_class", &self.flags_class) 986 .field("default_value", &self.default_value) 987 .finish() 988 } 989 } 990 991 #[repr(C)] 992 #[derive(Copy, Clone)] 993 pub struct GParamSpecFloat { 994 pub parent_instance: GParamSpec, 995 pub minimum: c_float, 996 pub maximum: c_float, 997 pub default_value: c_float, 998 pub epsilon: c_float, 999 } 1000 1001 impl ::std::fmt::Debug for GParamSpecFloat { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1002 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1003 f.debug_struct(&format!("GParamSpecFloat @ {:p}", self)) 1004 .field("parent_instance", &self.parent_instance) 1005 .field("minimum", &self.minimum) 1006 .field("maximum", &self.maximum) 1007 .field("default_value", &self.default_value) 1008 .field("epsilon", &self.epsilon) 1009 .finish() 1010 } 1011 } 1012 1013 #[repr(C)] 1014 #[derive(Copy, Clone)] 1015 pub struct GParamSpecGType { 1016 pub parent_instance: GParamSpec, 1017 pub is_a_type: GType, 1018 } 1019 1020 impl ::std::fmt::Debug for GParamSpecGType { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1021 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1022 f.debug_struct(&format!("GParamSpecGType @ {:p}", self)) 1023 .field("parent_instance", &self.parent_instance) 1024 .field("is_a_type", &self.is_a_type) 1025 .finish() 1026 } 1027 } 1028 1029 #[repr(C)] 1030 #[derive(Copy, Clone)] 1031 pub struct GParamSpecInt { 1032 pub parent_instance: GParamSpec, 1033 pub minimum: c_int, 1034 pub maximum: c_int, 1035 pub default_value: c_int, 1036 } 1037 1038 impl ::std::fmt::Debug for GParamSpecInt { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1039 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1040 f.debug_struct(&format!("GParamSpecInt @ {:p}", self)) 1041 .field("parent_instance", &self.parent_instance) 1042 .field("minimum", &self.minimum) 1043 .field("maximum", &self.maximum) 1044 .field("default_value", &self.default_value) 1045 .finish() 1046 } 1047 } 1048 1049 #[repr(C)] 1050 #[derive(Copy, Clone)] 1051 pub struct GParamSpecInt64 { 1052 pub parent_instance: GParamSpec, 1053 pub minimum: i64, 1054 pub maximum: i64, 1055 pub default_value: i64, 1056 } 1057 1058 impl ::std::fmt::Debug for GParamSpecInt64 { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1059 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1060 f.debug_struct(&format!("GParamSpecInt64 @ {:p}", self)) 1061 .field("parent_instance", &self.parent_instance) 1062 .field("minimum", &self.minimum) 1063 .field("maximum", &self.maximum) 1064 .field("default_value", &self.default_value) 1065 .finish() 1066 } 1067 } 1068 1069 #[repr(C)] 1070 #[derive(Copy, Clone)] 1071 pub struct GParamSpecLong { 1072 pub parent_instance: GParamSpec, 1073 pub minimum: c_long, 1074 pub maximum: c_long, 1075 pub default_value: c_long, 1076 } 1077 1078 impl ::std::fmt::Debug for GParamSpecLong { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1079 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1080 f.debug_struct(&format!("GParamSpecLong @ {:p}", self)) 1081 .field("parent_instance", &self.parent_instance) 1082 .field("minimum", &self.minimum) 1083 .field("maximum", &self.maximum) 1084 .field("default_value", &self.default_value) 1085 .finish() 1086 } 1087 } 1088 1089 #[repr(C)] 1090 #[derive(Copy, Clone)] 1091 pub struct GParamSpecObject { 1092 pub parent_instance: GParamSpec, 1093 } 1094 1095 impl ::std::fmt::Debug for GParamSpecObject { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1096 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1097 f.debug_struct(&format!("GParamSpecObject @ {:p}", self)) 1098 .field("parent_instance", &self.parent_instance) 1099 .finish() 1100 } 1101 } 1102 1103 #[repr(C)] 1104 #[derive(Copy, Clone)] 1105 pub struct GParamSpecOverride { 1106 pub parent_instance: GParamSpec, 1107 pub overridden: *mut GParamSpec, 1108 } 1109 1110 impl ::std::fmt::Debug for GParamSpecOverride { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1111 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1112 f.debug_struct(&format!("GParamSpecOverride @ {:p}", self)) 1113 .finish() 1114 } 1115 } 1116 1117 #[repr(C)] 1118 #[derive(Copy, Clone)] 1119 pub struct GParamSpecParam { 1120 pub parent_instance: GParamSpec, 1121 } 1122 1123 impl ::std::fmt::Debug for GParamSpecParam { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1124 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1125 f.debug_struct(&format!("GParamSpecParam @ {:p}", self)) 1126 .field("parent_instance", &self.parent_instance) 1127 .finish() 1128 } 1129 } 1130 1131 #[repr(C)] 1132 #[derive(Copy, Clone)] 1133 pub struct GParamSpecPointer { 1134 pub parent_instance: GParamSpec, 1135 } 1136 1137 impl ::std::fmt::Debug for GParamSpecPointer { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1138 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1139 f.debug_struct(&format!("GParamSpecPointer @ {:p}", self)) 1140 .field("parent_instance", &self.parent_instance) 1141 .finish() 1142 } 1143 } 1144 1145 #[repr(C)] 1146 pub struct GParamSpecString { 1147 pub parent_instance: GParamSpec, 1148 pub default_value: *mut c_char, 1149 pub cset_first: *mut c_char, 1150 pub cset_nth: *mut c_char, 1151 pub substitutor: c_char, 1152 pub null_fold_if_empty: c_uint, 1153 _truncated_record_marker: c_void, 1154 // field ensure_non_null has incomplete type 1155 } 1156 1157 impl ::std::fmt::Debug for GParamSpecString { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1158 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1159 f.debug_struct(&format!("GParamSpecString @ {:p}", self)) 1160 .field("parent_instance", &self.parent_instance) 1161 .field("default_value", &self.default_value) 1162 .field("cset_first", &self.cset_first) 1163 .field("cset_nth", &self.cset_nth) 1164 .field("substitutor", &self.substitutor) 1165 .field("null_fold_if_empty", &self.null_fold_if_empty) 1166 .finish() 1167 } 1168 } 1169 1170 #[repr(C)] 1171 #[derive(Copy, Clone)] 1172 pub struct GParamSpecUChar { 1173 pub parent_instance: GParamSpec, 1174 pub minimum: u8, 1175 pub maximum: u8, 1176 pub default_value: u8, 1177 } 1178 1179 impl ::std::fmt::Debug for GParamSpecUChar { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1180 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1181 f.debug_struct(&format!("GParamSpecUChar @ {:p}", self)) 1182 .field("parent_instance", &self.parent_instance) 1183 .field("minimum", &self.minimum) 1184 .field("maximum", &self.maximum) 1185 .field("default_value", &self.default_value) 1186 .finish() 1187 } 1188 } 1189 1190 #[repr(C)] 1191 #[derive(Copy, Clone)] 1192 pub struct GParamSpecUInt { 1193 pub parent_instance: GParamSpec, 1194 pub minimum: c_uint, 1195 pub maximum: c_uint, 1196 pub default_value: c_uint, 1197 } 1198 1199 impl ::std::fmt::Debug for GParamSpecUInt { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1200 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1201 f.debug_struct(&format!("GParamSpecUInt @ {:p}", self)) 1202 .field("parent_instance", &self.parent_instance) 1203 .field("minimum", &self.minimum) 1204 .field("maximum", &self.maximum) 1205 .field("default_value", &self.default_value) 1206 .finish() 1207 } 1208 } 1209 1210 #[repr(C)] 1211 #[derive(Copy, Clone)] 1212 pub struct GParamSpecUInt64 { 1213 pub parent_instance: GParamSpec, 1214 pub minimum: u64, 1215 pub maximum: u64, 1216 pub default_value: u64, 1217 } 1218 1219 impl ::std::fmt::Debug for GParamSpecUInt64 { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1220 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1221 f.debug_struct(&format!("GParamSpecUInt64 @ {:p}", self)) 1222 .field("parent_instance", &self.parent_instance) 1223 .field("minimum", &self.minimum) 1224 .field("maximum", &self.maximum) 1225 .field("default_value", &self.default_value) 1226 .finish() 1227 } 1228 } 1229 1230 #[repr(C)] 1231 #[derive(Copy, Clone)] 1232 pub struct GParamSpecULong { 1233 pub parent_instance: GParamSpec, 1234 pub minimum: c_ulong, 1235 pub maximum: c_ulong, 1236 pub default_value: c_ulong, 1237 } 1238 1239 impl ::std::fmt::Debug for GParamSpecULong { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1240 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1241 f.debug_struct(&format!("GParamSpecULong @ {:p}", self)) 1242 .field("parent_instance", &self.parent_instance) 1243 .field("minimum", &self.minimum) 1244 .field("maximum", &self.maximum) 1245 .field("default_value", &self.default_value) 1246 .finish() 1247 } 1248 } 1249 1250 #[repr(C)] 1251 #[derive(Copy, Clone)] 1252 pub struct GParamSpecUnichar { 1253 pub parent_instance: GParamSpec, 1254 pub default_value: u32, 1255 } 1256 1257 impl ::std::fmt::Debug for GParamSpecUnichar { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1258 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1259 f.debug_struct(&format!("GParamSpecUnichar @ {:p}", self)) 1260 .field("parent_instance", &self.parent_instance) 1261 .field("default_value", &self.default_value) 1262 .finish() 1263 } 1264 } 1265 1266 #[repr(C)] 1267 #[derive(Copy, Clone)] 1268 pub struct GParamSpecValueArray { 1269 pub parent_instance: GParamSpec, 1270 pub element_spec: *mut GParamSpec, 1271 pub fixed_n_elements: c_uint, 1272 } 1273 1274 impl ::std::fmt::Debug for GParamSpecValueArray { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1275 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1276 f.debug_struct(&format!("GParamSpecValueArray @ {:p}", self)) 1277 .field("parent_instance", &self.parent_instance) 1278 .field("element_spec", &self.element_spec) 1279 .field("fixed_n_elements", &self.fixed_n_elements) 1280 .finish() 1281 } 1282 } 1283 1284 #[repr(C)] 1285 #[derive(Copy, Clone)] 1286 pub struct GParamSpecVariant { 1287 pub parent_instance: GParamSpec, 1288 pub type_: *mut glib::GVariantType, 1289 pub default_value: *mut glib::GVariant, 1290 pub padding: [gpointer; 4], 1291 } 1292 1293 impl ::std::fmt::Debug for GParamSpecVariant { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1294 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1295 f.debug_struct(&format!("GParamSpecVariant @ {:p}", self)) 1296 .field("parent_instance", &self.parent_instance) 1297 .field("type_", &self.type_) 1298 .field("default_value", &self.default_value) 1299 .finish() 1300 } 1301 } 1302 1303 #[repr(C)] 1304 #[derive(Copy, Clone)] 1305 pub struct GTypeModule { 1306 pub parent_instance: GObject, 1307 pub use_count: c_uint, 1308 pub type_infos: *mut glib::GSList, 1309 pub interface_infos: *mut glib::GSList, 1310 pub name: *mut c_char, 1311 } 1312 1313 impl ::std::fmt::Debug for GTypeModule { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1314 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1315 f.debug_struct(&format!("GTypeModule @ {:p}", self)) 1316 .field("parent_instance", &self.parent_instance) 1317 .field("use_count", &self.use_count) 1318 .field("type_infos", &self.type_infos) 1319 .field("interface_infos", &self.interface_infos) 1320 .field("name", &self.name) 1321 .finish() 1322 } 1323 } 1324 1325 // Interfaces 1326 #[repr(C)] 1327 pub struct GTypePlugin(c_void); 1328 1329 impl ::std::fmt::Debug for GTypePlugin { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1330 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1331 write!(f, "GTypePlugin @ {:p}", self) 1332 } 1333 } 1334 1335 #[link(name = "gobject-2.0")] 1336 extern "C" { 1337 1338 //========================================================================= 1339 // GBindingFlags 1340 //========================================================================= g_binding_flags_get_type() -> GType1341 pub fn g_binding_flags_get_type() -> GType; 1342 1343 //========================================================================= 1344 // GCClosure 1345 //========================================================================= g_cclosure_marshal_BOOLEAN__BOXED_BOXED( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1346 pub fn g_cclosure_marshal_BOOLEAN__BOXED_BOXED( 1347 closure: *mut GClosure, 1348 return_value: *mut GValue, 1349 n_param_values: c_uint, 1350 param_values: *const GValue, 1351 invocation_hint: gpointer, 1352 marshal_data: gpointer, 1353 ); 1354 //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); g_cclosure_marshal_BOOLEAN__FLAGS( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1355 pub fn g_cclosure_marshal_BOOLEAN__FLAGS( 1356 closure: *mut GClosure, 1357 return_value: *mut GValue, 1358 n_param_values: c_uint, 1359 param_values: *const GValue, 1360 invocation_hint: gpointer, 1361 marshal_data: gpointer, 1362 ); 1363 //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); g_cclosure_marshal_STRING__OBJECT_POINTER( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1364 pub fn g_cclosure_marshal_STRING__OBJECT_POINTER( 1365 closure: *mut GClosure, 1366 return_value: *mut GValue, 1367 n_param_values: c_uint, 1368 param_values: *const GValue, 1369 invocation_hint: gpointer, 1370 marshal_data: gpointer, 1371 ); 1372 //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); g_cclosure_marshal_VOID__BOOLEAN( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1373 pub fn g_cclosure_marshal_VOID__BOOLEAN( 1374 closure: *mut GClosure, 1375 return_value: *mut GValue, 1376 n_param_values: c_uint, 1377 param_values: *const GValue, 1378 invocation_hint: gpointer, 1379 marshal_data: gpointer, 1380 ); 1381 //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); g_cclosure_marshal_VOID__BOXED( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1382 pub fn g_cclosure_marshal_VOID__BOXED( 1383 closure: *mut GClosure, 1384 return_value: *mut GValue, 1385 n_param_values: c_uint, 1386 param_values: *const GValue, 1387 invocation_hint: gpointer, 1388 marshal_data: gpointer, 1389 ); 1390 //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); g_cclosure_marshal_VOID__CHAR( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1391 pub fn g_cclosure_marshal_VOID__CHAR( 1392 closure: *mut GClosure, 1393 return_value: *mut GValue, 1394 n_param_values: c_uint, 1395 param_values: *const GValue, 1396 invocation_hint: gpointer, 1397 marshal_data: gpointer, 1398 ); 1399 //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); g_cclosure_marshal_VOID__DOUBLE( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1400 pub fn g_cclosure_marshal_VOID__DOUBLE( 1401 closure: *mut GClosure, 1402 return_value: *mut GValue, 1403 n_param_values: c_uint, 1404 param_values: *const GValue, 1405 invocation_hint: gpointer, 1406 marshal_data: gpointer, 1407 ); 1408 //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); g_cclosure_marshal_VOID__ENUM( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1409 pub fn g_cclosure_marshal_VOID__ENUM( 1410 closure: *mut GClosure, 1411 return_value: *mut GValue, 1412 n_param_values: c_uint, 1413 param_values: *const GValue, 1414 invocation_hint: gpointer, 1415 marshal_data: gpointer, 1416 ); 1417 //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); g_cclosure_marshal_VOID__FLAGS( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1418 pub fn g_cclosure_marshal_VOID__FLAGS( 1419 closure: *mut GClosure, 1420 return_value: *mut GValue, 1421 n_param_values: c_uint, 1422 param_values: *const GValue, 1423 invocation_hint: gpointer, 1424 marshal_data: gpointer, 1425 ); 1426 //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); g_cclosure_marshal_VOID__FLOAT( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1427 pub fn g_cclosure_marshal_VOID__FLOAT( 1428 closure: *mut GClosure, 1429 return_value: *mut GValue, 1430 n_param_values: c_uint, 1431 param_values: *const GValue, 1432 invocation_hint: gpointer, 1433 marshal_data: gpointer, 1434 ); 1435 //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); g_cclosure_marshal_VOID__INT( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1436 pub fn g_cclosure_marshal_VOID__INT( 1437 closure: *mut GClosure, 1438 return_value: *mut GValue, 1439 n_param_values: c_uint, 1440 param_values: *const GValue, 1441 invocation_hint: gpointer, 1442 marshal_data: gpointer, 1443 ); 1444 //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); g_cclosure_marshal_VOID__LONG( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1445 pub fn g_cclosure_marshal_VOID__LONG( 1446 closure: *mut GClosure, 1447 return_value: *mut GValue, 1448 n_param_values: c_uint, 1449 param_values: *const GValue, 1450 invocation_hint: gpointer, 1451 marshal_data: gpointer, 1452 ); 1453 //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); g_cclosure_marshal_VOID__OBJECT( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1454 pub fn g_cclosure_marshal_VOID__OBJECT( 1455 closure: *mut GClosure, 1456 return_value: *mut GValue, 1457 n_param_values: c_uint, 1458 param_values: *const GValue, 1459 invocation_hint: gpointer, 1460 marshal_data: gpointer, 1461 ); 1462 //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); g_cclosure_marshal_VOID__PARAM( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1463 pub fn g_cclosure_marshal_VOID__PARAM( 1464 closure: *mut GClosure, 1465 return_value: *mut GValue, 1466 n_param_values: c_uint, 1467 param_values: *const GValue, 1468 invocation_hint: gpointer, 1469 marshal_data: gpointer, 1470 ); 1471 //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); g_cclosure_marshal_VOID__POINTER( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1472 pub fn g_cclosure_marshal_VOID__POINTER( 1473 closure: *mut GClosure, 1474 return_value: *mut GValue, 1475 n_param_values: c_uint, 1476 param_values: *const GValue, 1477 invocation_hint: gpointer, 1478 marshal_data: gpointer, 1479 ); 1480 //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); g_cclosure_marshal_VOID__STRING( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1481 pub fn g_cclosure_marshal_VOID__STRING( 1482 closure: *mut GClosure, 1483 return_value: *mut GValue, 1484 n_param_values: c_uint, 1485 param_values: *const GValue, 1486 invocation_hint: gpointer, 1487 marshal_data: gpointer, 1488 ); 1489 //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); g_cclosure_marshal_VOID__UCHAR( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1490 pub fn g_cclosure_marshal_VOID__UCHAR( 1491 closure: *mut GClosure, 1492 return_value: *mut GValue, 1493 n_param_values: c_uint, 1494 param_values: *const GValue, 1495 invocation_hint: gpointer, 1496 marshal_data: gpointer, 1497 ); 1498 //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); g_cclosure_marshal_VOID__UINT( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1499 pub fn g_cclosure_marshal_VOID__UINT( 1500 closure: *mut GClosure, 1501 return_value: *mut GValue, 1502 n_param_values: c_uint, 1503 param_values: *const GValue, 1504 invocation_hint: gpointer, 1505 marshal_data: gpointer, 1506 ); g_cclosure_marshal_VOID__UINT_POINTER( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1507 pub fn g_cclosure_marshal_VOID__UINT_POINTER( 1508 closure: *mut GClosure, 1509 return_value: *mut GValue, 1510 n_param_values: c_uint, 1511 param_values: *const GValue, 1512 invocation_hint: gpointer, 1513 marshal_data: gpointer, 1514 ); 1515 //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); 1516 //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); g_cclosure_marshal_VOID__ULONG( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1517 pub fn g_cclosure_marshal_VOID__ULONG( 1518 closure: *mut GClosure, 1519 return_value: *mut GValue, 1520 n_param_values: c_uint, 1521 param_values: *const GValue, 1522 invocation_hint: gpointer, 1523 marshal_data: gpointer, 1524 ); 1525 //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); g_cclosure_marshal_VOID__VARIANT( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1526 pub fn g_cclosure_marshal_VOID__VARIANT( 1527 closure: *mut GClosure, 1528 return_value: *mut GValue, 1529 n_param_values: c_uint, 1530 param_values: *const GValue, 1531 invocation_hint: gpointer, 1532 marshal_data: gpointer, 1533 ); 1534 //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); g_cclosure_marshal_VOID__VOID( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1535 pub fn g_cclosure_marshal_VOID__VOID( 1536 closure: *mut GClosure, 1537 return_value: *mut GValue, 1538 n_param_values: c_uint, 1539 param_values: *const GValue, 1540 invocation_hint: gpointer, 1541 marshal_data: gpointer, 1542 ); 1543 //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); g_cclosure_marshal_generic( closure: *mut GClosure, return_gvalue: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, marshal_data: gpointer, )1544 pub fn g_cclosure_marshal_generic( 1545 closure: *mut GClosure, 1546 return_gvalue: *mut GValue, 1547 n_param_values: c_uint, 1548 param_values: *const GValue, 1549 invocation_hint: gpointer, 1550 marshal_data: gpointer, 1551 ); 1552 //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); g_cclosure_new( callback_func: GCallback, user_data: gpointer, destroy_data: GClosureNotify, ) -> *mut GClosure1553 pub fn g_cclosure_new( 1554 callback_func: GCallback, 1555 user_data: gpointer, 1556 destroy_data: GClosureNotify, 1557 ) -> *mut GClosure; g_cclosure_new_object(callback_func: GCallback, object: *mut GObject) -> *mut GClosure1558 pub fn g_cclosure_new_object(callback_func: GCallback, object: *mut GObject) -> *mut GClosure; g_cclosure_new_object_swap( callback_func: GCallback, object: *mut GObject, ) -> *mut GClosure1559 pub fn g_cclosure_new_object_swap( 1560 callback_func: GCallback, 1561 object: *mut GObject, 1562 ) -> *mut GClosure; g_cclosure_new_swap( callback_func: GCallback, user_data: gpointer, destroy_data: GClosureNotify, ) -> *mut GClosure1563 pub fn g_cclosure_new_swap( 1564 callback_func: GCallback, 1565 user_data: gpointer, 1566 destroy_data: GClosureNotify, 1567 ) -> *mut GClosure; 1568 1569 //========================================================================= 1570 // GClosure 1571 //========================================================================= g_closure_get_type() -> GType1572 pub fn g_closure_get_type() -> GType; g_closure_new_object(sizeof_closure: c_uint, object: *mut GObject) -> *mut GClosure1573 pub fn g_closure_new_object(sizeof_closure: c_uint, object: *mut GObject) -> *mut GClosure; g_closure_new_simple(sizeof_closure: c_uint, data: gpointer) -> *mut GClosure1574 pub fn g_closure_new_simple(sizeof_closure: c_uint, data: gpointer) -> *mut GClosure; g_closure_add_finalize_notifier( closure: *mut GClosure, notify_data: gpointer, notify_func: GClosureNotify, )1575 pub fn g_closure_add_finalize_notifier( 1576 closure: *mut GClosure, 1577 notify_data: gpointer, 1578 notify_func: GClosureNotify, 1579 ); g_closure_add_invalidate_notifier( closure: *mut GClosure, notify_data: gpointer, notify_func: GClosureNotify, )1580 pub fn g_closure_add_invalidate_notifier( 1581 closure: *mut GClosure, 1582 notify_data: gpointer, 1583 notify_func: GClosureNotify, 1584 ); g_closure_add_marshal_guards( closure: *mut GClosure, pre_marshal_data: gpointer, pre_marshal_notify: GClosureNotify, post_marshal_data: gpointer, post_marshal_notify: GClosureNotify, )1585 pub fn g_closure_add_marshal_guards( 1586 closure: *mut GClosure, 1587 pre_marshal_data: gpointer, 1588 pre_marshal_notify: GClosureNotify, 1589 post_marshal_data: gpointer, 1590 post_marshal_notify: GClosureNotify, 1591 ); g_closure_invalidate(closure: *mut GClosure)1592 pub fn g_closure_invalidate(closure: *mut GClosure); g_closure_invoke( closure: *mut GClosure, return_value: *mut GValue, n_param_values: c_uint, param_values: *const GValue, invocation_hint: gpointer, )1593 pub fn g_closure_invoke( 1594 closure: *mut GClosure, 1595 return_value: *mut GValue, 1596 n_param_values: c_uint, 1597 param_values: *const GValue, 1598 invocation_hint: gpointer, 1599 ); g_closure_ref(closure: *mut GClosure) -> *mut GClosure1600 pub fn g_closure_ref(closure: *mut GClosure) -> *mut GClosure; g_closure_remove_finalize_notifier( closure: *mut GClosure, notify_data: gpointer, notify_func: GClosureNotify, )1601 pub fn g_closure_remove_finalize_notifier( 1602 closure: *mut GClosure, 1603 notify_data: gpointer, 1604 notify_func: GClosureNotify, 1605 ); g_closure_remove_invalidate_notifier( closure: *mut GClosure, notify_data: gpointer, notify_func: GClosureNotify, )1606 pub fn g_closure_remove_invalidate_notifier( 1607 closure: *mut GClosure, 1608 notify_data: gpointer, 1609 notify_func: GClosureNotify, 1610 ); g_closure_set_marshal(closure: *mut GClosure, marshal: GClosureMarshal)1611 pub fn g_closure_set_marshal(closure: *mut GClosure, marshal: GClosureMarshal); g_closure_set_meta_marshal( closure: *mut GClosure, marshal_data: gpointer, meta_marshal: GClosureMarshal, )1612 pub fn g_closure_set_meta_marshal( 1613 closure: *mut GClosure, 1614 marshal_data: gpointer, 1615 meta_marshal: GClosureMarshal, 1616 ); g_closure_sink(closure: *mut GClosure)1617 pub fn g_closure_sink(closure: *mut GClosure); g_closure_unref(closure: *mut GClosure)1618 pub fn g_closure_unref(closure: *mut GClosure); 1619 1620 //========================================================================= 1621 // GObjectClass 1622 //========================================================================= g_object_class_find_property( oclass: *mut GObjectClass, property_name: *const c_char, ) -> *mut GParamSpec1623 pub fn g_object_class_find_property( 1624 oclass: *mut GObjectClass, 1625 property_name: *const c_char, 1626 ) -> *mut GParamSpec; g_object_class_install_properties( oclass: *mut GObjectClass, n_pspecs: c_uint, pspecs: *mut *mut GParamSpec, )1627 pub fn g_object_class_install_properties( 1628 oclass: *mut GObjectClass, 1629 n_pspecs: c_uint, 1630 pspecs: *mut *mut GParamSpec, 1631 ); g_object_class_install_property( oclass: *mut GObjectClass, property_id: c_uint, pspec: *mut GParamSpec, )1632 pub fn g_object_class_install_property( 1633 oclass: *mut GObjectClass, 1634 property_id: c_uint, 1635 pspec: *mut GParamSpec, 1636 ); g_object_class_list_properties( oclass: *mut GObjectClass, n_properties: *mut c_uint, ) -> *mut *mut GParamSpec1637 pub fn g_object_class_list_properties( 1638 oclass: *mut GObjectClass, 1639 n_properties: *mut c_uint, 1640 ) -> *mut *mut GParamSpec; g_object_class_override_property( oclass: *mut GObjectClass, property_id: c_uint, name: *const c_char, )1641 pub fn g_object_class_override_property( 1642 oclass: *mut GObjectClass, 1643 property_id: c_uint, 1644 name: *const c_char, 1645 ); 1646 1647 //========================================================================= 1648 // GParamSpecPool 1649 //========================================================================= g_param_spec_pool_insert( pool: *mut GParamSpecPool, pspec: *mut GParamSpec, owner_type: GType, )1650 pub fn g_param_spec_pool_insert( 1651 pool: *mut GParamSpecPool, 1652 pspec: *mut GParamSpec, 1653 owner_type: GType, 1654 ); g_param_spec_pool_list( pool: *mut GParamSpecPool, owner_type: GType, n_pspecs_p: *mut c_uint, ) -> *mut *mut GParamSpec1655 pub fn g_param_spec_pool_list( 1656 pool: *mut GParamSpecPool, 1657 owner_type: GType, 1658 n_pspecs_p: *mut c_uint, 1659 ) -> *mut *mut GParamSpec; g_param_spec_pool_list_owned( pool: *mut GParamSpecPool, owner_type: GType, ) -> *mut glib::GList1660 pub fn g_param_spec_pool_list_owned( 1661 pool: *mut GParamSpecPool, 1662 owner_type: GType, 1663 ) -> *mut glib::GList; g_param_spec_pool_lookup( pool: *mut GParamSpecPool, param_name: *const c_char, owner_type: GType, walk_ancestors: gboolean, ) -> *mut GParamSpec1664 pub fn g_param_spec_pool_lookup( 1665 pool: *mut GParamSpecPool, 1666 param_name: *const c_char, 1667 owner_type: GType, 1668 walk_ancestors: gboolean, 1669 ) -> *mut GParamSpec; g_param_spec_pool_remove(pool: *mut GParamSpecPool, pspec: *mut GParamSpec)1670 pub fn g_param_spec_pool_remove(pool: *mut GParamSpecPool, pspec: *mut GParamSpec); g_param_spec_pool_new(type_prefixing: gboolean) -> *mut GParamSpecPool1671 pub fn g_param_spec_pool_new(type_prefixing: gboolean) -> *mut GParamSpecPool; 1672 1673 //========================================================================= 1674 // GTypeClass 1675 //========================================================================= g_type_class_add_private(g_class: gpointer, private_size: size_t)1676 pub fn g_type_class_add_private(g_class: gpointer, private_size: size_t); g_type_class_get_instance_private_offset(g_class: gpointer) -> c_int1677 pub fn g_type_class_get_instance_private_offset(g_class: gpointer) -> c_int; g_type_class_get_private(klass: *mut GTypeClass, private_type: GType) -> gpointer1678 pub fn g_type_class_get_private(klass: *mut GTypeClass, private_type: GType) -> gpointer; g_type_class_peek_parent(g_class: gpointer) -> gpointer1679 pub fn g_type_class_peek_parent(g_class: gpointer) -> gpointer; g_type_class_unref(g_class: gpointer)1680 pub fn g_type_class_unref(g_class: gpointer); g_type_class_unref_uncached(g_class: gpointer)1681 pub fn g_type_class_unref_uncached(g_class: gpointer); g_type_class_adjust_private_offset( g_class: gpointer, private_size_or_offset: *mut c_int, )1682 pub fn g_type_class_adjust_private_offset( 1683 g_class: gpointer, 1684 private_size_or_offset: *mut c_int, 1685 ); g_type_class_peek(type_: GType) -> gpointer1686 pub fn g_type_class_peek(type_: GType) -> gpointer; g_type_class_peek_static(type_: GType) -> gpointer1687 pub fn g_type_class_peek_static(type_: GType) -> gpointer; g_type_class_ref(type_: GType) -> gpointer1688 pub fn g_type_class_ref(type_: GType) -> gpointer; 1689 1690 //========================================================================= 1691 // GTypeInstance 1692 //========================================================================= g_type_instance_get_private( instance: *mut GTypeInstance, private_type: GType, ) -> gpointer1693 pub fn g_type_instance_get_private( 1694 instance: *mut GTypeInstance, 1695 private_type: GType, 1696 ) -> gpointer; 1697 1698 //========================================================================= 1699 // GTypeInterface 1700 //========================================================================= g_type_interface_peek_parent(g_iface: gpointer) -> gpointer1701 pub fn g_type_interface_peek_parent(g_iface: gpointer) -> gpointer; g_type_interface_add_prerequisite(interface_type: GType, prerequisite_type: GType)1702 pub fn g_type_interface_add_prerequisite(interface_type: GType, prerequisite_type: GType); g_type_interface_get_plugin( instance_type: GType, interface_type: GType, ) -> *mut GTypePlugin1703 pub fn g_type_interface_get_plugin( 1704 instance_type: GType, 1705 interface_type: GType, 1706 ) -> *mut GTypePlugin; g_type_interface_peek(instance_class: gpointer, iface_type: GType) -> gpointer1707 pub fn g_type_interface_peek(instance_class: gpointer, iface_type: GType) -> gpointer; g_type_interface_prerequisites( interface_type: GType, n_prerequisites: *mut c_uint, ) -> *mut GType1708 pub fn g_type_interface_prerequisites( 1709 interface_type: GType, 1710 n_prerequisites: *mut c_uint, 1711 ) -> *mut GType; 1712 1713 //========================================================================= 1714 // GTypeValueTable 1715 //========================================================================= g_type_value_table_peek(type_: GType) -> *mut GTypeValueTable1716 pub fn g_type_value_table_peek(type_: GType) -> *mut GTypeValueTable; 1717 1718 //========================================================================= 1719 // GValue 1720 //========================================================================= g_value_get_type() -> GType1721 pub fn g_value_get_type() -> GType; g_value_copy(src_value: *const GValue, dest_value: *mut GValue)1722 pub fn g_value_copy(src_value: *const GValue, dest_value: *mut GValue); g_value_dup_boxed(value: *const GValue) -> gpointer1723 pub fn g_value_dup_boxed(value: *const GValue) -> gpointer; g_value_dup_object(value: *const GValue) -> *mut GObject1724 pub fn g_value_dup_object(value: *const GValue) -> *mut GObject; g_value_dup_param(value: *const GValue) -> *mut GParamSpec1725 pub fn g_value_dup_param(value: *const GValue) -> *mut GParamSpec; g_value_dup_string(value: *const GValue) -> *mut c_char1726 pub fn g_value_dup_string(value: *const GValue) -> *mut c_char; g_value_dup_variant(value: *const GValue) -> *mut glib::GVariant1727 pub fn g_value_dup_variant(value: *const GValue) -> *mut glib::GVariant; g_value_fits_pointer(value: *const GValue) -> gboolean1728 pub fn g_value_fits_pointer(value: *const GValue) -> gboolean; g_value_get_boolean(value: *const GValue) -> gboolean1729 pub fn g_value_get_boolean(value: *const GValue) -> gboolean; g_value_get_boxed(value: *const GValue) -> gpointer1730 pub fn g_value_get_boxed(value: *const GValue) -> gpointer; g_value_get_char(value: *const GValue) -> c_char1731 pub fn g_value_get_char(value: *const GValue) -> c_char; g_value_get_double(value: *const GValue) -> c_double1732 pub fn g_value_get_double(value: *const GValue) -> c_double; g_value_get_enum(value: *const GValue) -> c_int1733 pub fn g_value_get_enum(value: *const GValue) -> c_int; g_value_get_flags(value: *const GValue) -> c_uint1734 pub fn g_value_get_flags(value: *const GValue) -> c_uint; g_value_get_float(value: *const GValue) -> c_float1735 pub fn g_value_get_float(value: *const GValue) -> c_float; g_value_get_gtype(value: *const GValue) -> GType1736 pub fn g_value_get_gtype(value: *const GValue) -> GType; g_value_get_int(value: *const GValue) -> c_int1737 pub fn g_value_get_int(value: *const GValue) -> c_int; g_value_get_int64(value: *const GValue) -> i641738 pub fn g_value_get_int64(value: *const GValue) -> i64; g_value_get_long(value: *const GValue) -> c_long1739 pub fn g_value_get_long(value: *const GValue) -> c_long; g_value_get_object(value: *const GValue) -> *mut GObject1740 pub fn g_value_get_object(value: *const GValue) -> *mut GObject; g_value_get_param(value: *const GValue) -> *mut GParamSpec1741 pub fn g_value_get_param(value: *const GValue) -> *mut GParamSpec; g_value_get_pointer(value: *const GValue) -> gpointer1742 pub fn g_value_get_pointer(value: *const GValue) -> gpointer; g_value_get_schar(value: *const GValue) -> i81743 pub fn g_value_get_schar(value: *const GValue) -> i8; g_value_get_string(value: *const GValue) -> *const c_char1744 pub fn g_value_get_string(value: *const GValue) -> *const c_char; g_value_get_uchar(value: *const GValue) -> c_uchar1745 pub fn g_value_get_uchar(value: *const GValue) -> c_uchar; g_value_get_uint(value: *const GValue) -> c_uint1746 pub fn g_value_get_uint(value: *const GValue) -> c_uint; g_value_get_uint64(value: *const GValue) -> u641747 pub fn g_value_get_uint64(value: *const GValue) -> u64; g_value_get_ulong(value: *const GValue) -> c_ulong1748 pub fn g_value_get_ulong(value: *const GValue) -> c_ulong; g_value_get_variant(value: *const GValue) -> *mut glib::GVariant1749 pub fn g_value_get_variant(value: *const GValue) -> *mut glib::GVariant; g_value_init(value: *mut GValue, g_type: GType) -> *mut GValue1750 pub fn g_value_init(value: *mut GValue, g_type: GType) -> *mut GValue; g_value_init_from_instance(value: *mut GValue, instance: gpointer)1751 pub fn g_value_init_from_instance(value: *mut GValue, instance: gpointer); g_value_peek_pointer(value: *const GValue) -> gpointer1752 pub fn g_value_peek_pointer(value: *const GValue) -> gpointer; g_value_reset(value: *mut GValue) -> *mut GValue1753 pub fn g_value_reset(value: *mut GValue) -> *mut GValue; g_value_set_boolean(value: *mut GValue, v_boolean: gboolean)1754 pub fn g_value_set_boolean(value: *mut GValue, v_boolean: gboolean); g_value_set_boxed(value: *mut GValue, v_boxed: gconstpointer)1755 pub fn g_value_set_boxed(value: *mut GValue, v_boxed: gconstpointer); g_value_set_boxed_take_ownership(value: *mut GValue, v_boxed: gconstpointer)1756 pub fn g_value_set_boxed_take_ownership(value: *mut GValue, v_boxed: gconstpointer); g_value_set_char(value: *mut GValue, v_char: c_char)1757 pub fn g_value_set_char(value: *mut GValue, v_char: c_char); g_value_set_double(value: *mut GValue, v_double: c_double)1758 pub fn g_value_set_double(value: *mut GValue, v_double: c_double); g_value_set_enum(value: *mut GValue, v_enum: c_int)1759 pub fn g_value_set_enum(value: *mut GValue, v_enum: c_int); g_value_set_flags(value: *mut GValue, v_flags: c_uint)1760 pub fn g_value_set_flags(value: *mut GValue, v_flags: c_uint); g_value_set_float(value: *mut GValue, v_float: c_float)1761 pub fn g_value_set_float(value: *mut GValue, v_float: c_float); g_value_set_gtype(value: *mut GValue, v_gtype: GType)1762 pub fn g_value_set_gtype(value: *mut GValue, v_gtype: GType); g_value_set_instance(value: *mut GValue, instance: gpointer)1763 pub fn g_value_set_instance(value: *mut GValue, instance: gpointer); g_value_set_int(value: *mut GValue, v_int: c_int)1764 pub fn g_value_set_int(value: *mut GValue, v_int: c_int); g_value_set_int64(value: *mut GValue, v_int64: i64)1765 pub fn g_value_set_int64(value: *mut GValue, v_int64: i64); 1766 #[cfg(any(feature = "v2_66", feature = "dox"))] 1767 #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_66")))] g_value_set_interned_string(value: *mut GValue, v_string: *const c_char)1768 pub fn g_value_set_interned_string(value: *mut GValue, v_string: *const c_char); g_value_set_long(value: *mut GValue, v_long: c_long)1769 pub fn g_value_set_long(value: *mut GValue, v_long: c_long); g_value_set_object(value: *mut GValue, v_object: *mut GObject)1770 pub fn g_value_set_object(value: *mut GValue, v_object: *mut GObject); g_value_set_object_take_ownership(value: *mut GValue, v_object: gpointer)1771 pub fn g_value_set_object_take_ownership(value: *mut GValue, v_object: gpointer); g_value_set_param(value: *mut GValue, param: *mut GParamSpec)1772 pub fn g_value_set_param(value: *mut GValue, param: *mut GParamSpec); g_value_set_param_take_ownership(value: *mut GValue, param: *mut GParamSpec)1773 pub fn g_value_set_param_take_ownership(value: *mut GValue, param: *mut GParamSpec); g_value_set_pointer(value: *mut GValue, v_pointer: gpointer)1774 pub fn g_value_set_pointer(value: *mut GValue, v_pointer: gpointer); g_value_set_schar(value: *mut GValue, v_char: i8)1775 pub fn g_value_set_schar(value: *mut GValue, v_char: i8); g_value_set_static_boxed(value: *mut GValue, v_boxed: gconstpointer)1776 pub fn g_value_set_static_boxed(value: *mut GValue, v_boxed: gconstpointer); g_value_set_static_string(value: *mut GValue, v_string: *const c_char)1777 pub fn g_value_set_static_string(value: *mut GValue, v_string: *const c_char); g_value_set_string(value: *mut GValue, v_string: *const c_char)1778 pub fn g_value_set_string(value: *mut GValue, v_string: *const c_char); g_value_set_string_take_ownership(value: *mut GValue, v_string: *mut c_char)1779 pub fn g_value_set_string_take_ownership(value: *mut GValue, v_string: *mut c_char); g_value_set_uchar(value: *mut GValue, v_uchar: c_uchar)1780 pub fn g_value_set_uchar(value: *mut GValue, v_uchar: c_uchar); g_value_set_uint(value: *mut GValue, v_uint: c_uint)1781 pub fn g_value_set_uint(value: *mut GValue, v_uint: c_uint); g_value_set_uint64(value: *mut GValue, v_uint64: u64)1782 pub fn g_value_set_uint64(value: *mut GValue, v_uint64: u64); g_value_set_ulong(value: *mut GValue, v_ulong: c_ulong)1783 pub fn g_value_set_ulong(value: *mut GValue, v_ulong: c_ulong); g_value_set_variant(value: *mut GValue, variant: *mut glib::GVariant)1784 pub fn g_value_set_variant(value: *mut GValue, variant: *mut glib::GVariant); g_value_take_boxed(value: *mut GValue, v_boxed: gconstpointer)1785 pub fn g_value_take_boxed(value: *mut GValue, v_boxed: gconstpointer); g_value_take_object(value: *mut GValue, v_object: gpointer)1786 pub fn g_value_take_object(value: *mut GValue, v_object: gpointer); g_value_take_param(value: *mut GValue, param: *mut GParamSpec)1787 pub fn g_value_take_param(value: *mut GValue, param: *mut GParamSpec); g_value_take_string(value: *mut GValue, v_string: *mut c_char)1788 pub fn g_value_take_string(value: *mut GValue, v_string: *mut c_char); g_value_take_variant(value: *mut GValue, variant: *mut glib::GVariant)1789 pub fn g_value_take_variant(value: *mut GValue, variant: *mut glib::GVariant); g_value_transform(src_value: *const GValue, dest_value: *mut GValue) -> gboolean1790 pub fn g_value_transform(src_value: *const GValue, dest_value: *mut GValue) -> gboolean; g_value_unset(value: *mut GValue)1791 pub fn g_value_unset(value: *mut GValue); g_value_register_transform_func( src_type: GType, dest_type: GType, transform_func: GValueTransform, )1792 pub fn g_value_register_transform_func( 1793 src_type: GType, 1794 dest_type: GType, 1795 transform_func: GValueTransform, 1796 ); g_value_type_compatible(src_type: GType, dest_type: GType) -> gboolean1797 pub fn g_value_type_compatible(src_type: GType, dest_type: GType) -> gboolean; g_value_type_transformable(src_type: GType, dest_type: GType) -> gboolean1798 pub fn g_value_type_transformable(src_type: GType, dest_type: GType) -> gboolean; 1799 1800 //========================================================================= 1801 // GValueArray 1802 //========================================================================= g_value_array_get_type() -> GType1803 pub fn g_value_array_get_type() -> GType; g_value_array_new(n_prealloced: c_uint) -> *mut GValueArray1804 pub fn g_value_array_new(n_prealloced: c_uint) -> *mut GValueArray; g_value_array_append( value_array: *mut GValueArray, value: *const GValue, ) -> *mut GValueArray1805 pub fn g_value_array_append( 1806 value_array: *mut GValueArray, 1807 value: *const GValue, 1808 ) -> *mut GValueArray; g_value_array_copy(value_array: *const GValueArray) -> *mut GValueArray1809 pub fn g_value_array_copy(value_array: *const GValueArray) -> *mut GValueArray; g_value_array_free(value_array: *mut GValueArray)1810 pub fn g_value_array_free(value_array: *mut GValueArray); g_value_array_get_nth(value_array: *mut GValueArray, index_: c_uint) -> *mut GValue1811 pub fn g_value_array_get_nth(value_array: *mut GValueArray, index_: c_uint) -> *mut GValue; g_value_array_insert( value_array: *mut GValueArray, index_: c_uint, value: *const GValue, ) -> *mut GValueArray1812 pub fn g_value_array_insert( 1813 value_array: *mut GValueArray, 1814 index_: c_uint, 1815 value: *const GValue, 1816 ) -> *mut GValueArray; g_value_array_prepend( value_array: *mut GValueArray, value: *const GValue, ) -> *mut GValueArray1817 pub fn g_value_array_prepend( 1818 value_array: *mut GValueArray, 1819 value: *const GValue, 1820 ) -> *mut GValueArray; g_value_array_remove(value_array: *mut GValueArray, index_: c_uint) -> *mut GValueArray1821 pub fn g_value_array_remove(value_array: *mut GValueArray, index_: c_uint) -> *mut GValueArray; g_value_array_sort( value_array: *mut GValueArray, compare_func: glib::GCompareFunc, ) -> *mut GValueArray1822 pub fn g_value_array_sort( 1823 value_array: *mut GValueArray, 1824 compare_func: glib::GCompareFunc, 1825 ) -> *mut GValueArray; g_value_array_sort_with_data( value_array: *mut GValueArray, compare_func: glib::GCompareDataFunc, user_data: gpointer, ) -> *mut GValueArray1826 pub fn g_value_array_sort_with_data( 1827 value_array: *mut GValueArray, 1828 compare_func: glib::GCompareDataFunc, 1829 user_data: gpointer, 1830 ) -> *mut GValueArray; 1831 1832 //========================================================================= 1833 // GWeakRef 1834 //========================================================================= g_weak_ref_clear(weak_ref: *mut GWeakRef)1835 pub fn g_weak_ref_clear(weak_ref: *mut GWeakRef); g_weak_ref_get(weak_ref: *mut GWeakRef) -> *mut GObject1836 pub fn g_weak_ref_get(weak_ref: *mut GWeakRef) -> *mut GObject; g_weak_ref_init(weak_ref: *mut GWeakRef, object: *mut GObject)1837 pub fn g_weak_ref_init(weak_ref: *mut GWeakRef, object: *mut GObject); g_weak_ref_set(weak_ref: *mut GWeakRef, object: *mut GObject)1838 pub fn g_weak_ref_set(weak_ref: *mut GWeakRef, object: *mut GObject); 1839 1840 //========================================================================= 1841 // GBinding 1842 //========================================================================= g_binding_get_type() -> GType1843 pub fn g_binding_get_type() -> GType; g_binding_get_flags(binding: *mut GBinding) -> GBindingFlags1844 pub fn g_binding_get_flags(binding: *mut GBinding) -> GBindingFlags; g_binding_get_source(binding: *mut GBinding) -> *mut GObject1845 pub fn g_binding_get_source(binding: *mut GBinding) -> *mut GObject; g_binding_get_source_property(binding: *mut GBinding) -> *const c_char1846 pub fn g_binding_get_source_property(binding: *mut GBinding) -> *const c_char; g_binding_get_target(binding: *mut GBinding) -> *mut GObject1847 pub fn g_binding_get_target(binding: *mut GBinding) -> *mut GObject; g_binding_get_target_property(binding: *mut GBinding) -> *const c_char1848 pub fn g_binding_get_target_property(binding: *mut GBinding) -> *const c_char; g_binding_unbind(binding: *mut GBinding)1849 pub fn g_binding_unbind(binding: *mut GBinding); 1850 1851 //========================================================================= 1852 // GInitiallyUnowned 1853 //========================================================================= g_initially_unowned_get_type() -> GType1854 pub fn g_initially_unowned_get_type() -> GType; 1855 1856 //========================================================================= 1857 // GObject 1858 //========================================================================= g_object_get_type() -> GType1859 pub fn g_object_get_type() -> GType; g_object_new( object_type: GType, first_property_name: *const c_char, ... ) -> *mut GObject1860 pub fn g_object_new( 1861 object_type: GType, 1862 first_property_name: *const c_char, 1863 ... 1864 ) -> *mut GObject; 1865 //pub fn g_object_new_valist(object_type: GType, first_property_name: *const c_char, var_args: /*Unimplemented*/va_list) -> *mut GObject; 1866 #[cfg(any(feature = "v2_54", feature = "dox"))] 1867 #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_54")))] g_object_new_with_properties( object_type: GType, n_properties: c_uint, names: *mut *const c_char, values: *const GValue, ) -> *mut GObject1868 pub fn g_object_new_with_properties( 1869 object_type: GType, 1870 n_properties: c_uint, 1871 names: *mut *const c_char, 1872 values: *const GValue, 1873 ) -> *mut GObject; g_object_newv( object_type: GType, n_parameters: c_uint, parameters: *mut GParameter, ) -> *mut GObject1874 pub fn g_object_newv( 1875 object_type: GType, 1876 n_parameters: c_uint, 1877 parameters: *mut GParameter, 1878 ) -> *mut GObject; g_object_compat_control(what: size_t, data: gpointer) -> size_t1879 pub fn g_object_compat_control(what: size_t, data: gpointer) -> size_t; g_object_interface_find_property( g_iface: gpointer, property_name: *const c_char, ) -> *mut GParamSpec1880 pub fn g_object_interface_find_property( 1881 g_iface: gpointer, 1882 property_name: *const c_char, 1883 ) -> *mut GParamSpec; g_object_interface_install_property(g_iface: gpointer, pspec: *mut GParamSpec)1884 pub fn g_object_interface_install_property(g_iface: gpointer, pspec: *mut GParamSpec); g_object_interface_list_properties( g_iface: gpointer, n_properties_p: *mut c_uint, ) -> *mut *mut GParamSpec1885 pub fn g_object_interface_list_properties( 1886 g_iface: gpointer, 1887 n_properties_p: *mut c_uint, 1888 ) -> *mut *mut GParamSpec; g_object_add_toggle_ref(object: *mut GObject, notify: GToggleNotify, data: gpointer)1889 pub fn g_object_add_toggle_ref(object: *mut GObject, notify: GToggleNotify, data: gpointer); g_object_add_weak_pointer(object: *mut GObject, weak_pointer_location: *mut gpointer)1890 pub fn g_object_add_weak_pointer(object: *mut GObject, weak_pointer_location: *mut gpointer); g_object_bind_property( source: *mut GObject, source_property: *const c_char, target: *mut GObject, target_property: *const c_char, flags: GBindingFlags, ) -> *mut GBinding1891 pub fn g_object_bind_property( 1892 source: *mut GObject, 1893 source_property: *const c_char, 1894 target: *mut GObject, 1895 target_property: *const c_char, 1896 flags: GBindingFlags, 1897 ) -> *mut GBinding; g_object_bind_property_full( source: *mut GObject, source_property: *const c_char, target: *mut GObject, target_property: *const c_char, flags: GBindingFlags, transform_to: GBindingTransformFunc, transform_from: GBindingTransformFunc, user_data: gpointer, notify: glib::GDestroyNotify, ) -> *mut GBinding1898 pub fn g_object_bind_property_full( 1899 source: *mut GObject, 1900 source_property: *const c_char, 1901 target: *mut GObject, 1902 target_property: *const c_char, 1903 flags: GBindingFlags, 1904 transform_to: GBindingTransformFunc, 1905 transform_from: GBindingTransformFunc, 1906 user_data: gpointer, 1907 notify: glib::GDestroyNotify, 1908 ) -> *mut GBinding; g_object_bind_property_with_closures( source: *mut GObject, source_property: *const c_char, target: *mut GObject, target_property: *const c_char, flags: GBindingFlags, transform_to: *mut GClosure, transform_from: *mut GClosure, ) -> *mut GBinding1909 pub fn g_object_bind_property_with_closures( 1910 source: *mut GObject, 1911 source_property: *const c_char, 1912 target: *mut GObject, 1913 target_property: *const c_char, 1914 flags: GBindingFlags, 1915 transform_to: *mut GClosure, 1916 transform_from: *mut GClosure, 1917 ) -> *mut GBinding; g_object_connect(object: *mut GObject, signal_spec: *const c_char, ...) -> *mut GObject1918 pub fn g_object_connect(object: *mut GObject, signal_spec: *const c_char, ...) -> *mut GObject; g_object_disconnect(object: *mut GObject, signal_spec: *const c_char, ...)1919 pub fn g_object_disconnect(object: *mut GObject, signal_spec: *const c_char, ...); g_object_dup_data( object: *mut GObject, key: *const c_char, dup_func: glib::GDuplicateFunc, user_data: gpointer, ) -> gpointer1920 pub fn g_object_dup_data( 1921 object: *mut GObject, 1922 key: *const c_char, 1923 dup_func: glib::GDuplicateFunc, 1924 user_data: gpointer, 1925 ) -> gpointer; g_object_dup_qdata( object: *mut GObject, quark: glib::GQuark, dup_func: glib::GDuplicateFunc, user_data: gpointer, ) -> gpointer1926 pub fn g_object_dup_qdata( 1927 object: *mut GObject, 1928 quark: glib::GQuark, 1929 dup_func: glib::GDuplicateFunc, 1930 user_data: gpointer, 1931 ) -> gpointer; g_object_force_floating(object: *mut GObject)1932 pub fn g_object_force_floating(object: *mut GObject); g_object_freeze_notify(object: *mut GObject)1933 pub fn g_object_freeze_notify(object: *mut GObject); g_object_get(object: *mut GObject, first_property_name: *const c_char, ...)1934 pub fn g_object_get(object: *mut GObject, first_property_name: *const c_char, ...); g_object_get_data(object: *mut GObject, key: *const c_char) -> gpointer1935 pub fn g_object_get_data(object: *mut GObject, key: *const c_char) -> gpointer; g_object_get_property( object: *mut GObject, property_name: *const c_char, value: *mut GValue, )1936 pub fn g_object_get_property( 1937 object: *mut GObject, 1938 property_name: *const c_char, 1939 value: *mut GValue, 1940 ); g_object_get_qdata(object: *mut GObject, quark: glib::GQuark) -> gpointer1941 pub fn g_object_get_qdata(object: *mut GObject, quark: glib::GQuark) -> gpointer; 1942 //pub fn g_object_get_valist(object: *mut GObject, first_property_name: *const c_char, var_args: /*Unimplemented*/va_list); 1943 #[cfg(any(feature = "v2_54", feature = "dox"))] 1944 #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_54")))] g_object_getv( object: *mut GObject, n_properties: c_uint, names: *mut *const c_char, values: *mut GValue, )1945 pub fn g_object_getv( 1946 object: *mut GObject, 1947 n_properties: c_uint, 1948 names: *mut *const c_char, 1949 values: *mut GValue, 1950 ); g_object_is_floating(object: *mut GObject) -> gboolean1951 pub fn g_object_is_floating(object: *mut GObject) -> gboolean; g_object_notify(object: *mut GObject, property_name: *const c_char)1952 pub fn g_object_notify(object: *mut GObject, property_name: *const c_char); g_object_notify_by_pspec(object: *mut GObject, pspec: *mut GParamSpec)1953 pub fn g_object_notify_by_pspec(object: *mut GObject, pspec: *mut GParamSpec); g_object_ref(object: *mut GObject) -> *mut GObject1954 pub fn g_object_ref(object: *mut GObject) -> *mut GObject; g_object_ref_sink(object: *mut GObject) -> *mut GObject1955 pub fn g_object_ref_sink(object: *mut GObject) -> *mut GObject; g_object_remove_toggle_ref(object: *mut GObject, notify: GToggleNotify, data: gpointer)1956 pub fn g_object_remove_toggle_ref(object: *mut GObject, notify: GToggleNotify, data: gpointer); g_object_remove_weak_pointer(object: *mut GObject, weak_pointer_location: *mut gpointer)1957 pub fn g_object_remove_weak_pointer(object: *mut GObject, weak_pointer_location: *mut gpointer); g_object_replace_data( object: *mut GObject, key: *const c_char, oldval: gpointer, newval: gpointer, destroy: glib::GDestroyNotify, old_destroy: *mut glib::GDestroyNotify, ) -> gboolean1958 pub fn g_object_replace_data( 1959 object: *mut GObject, 1960 key: *const c_char, 1961 oldval: gpointer, 1962 newval: gpointer, 1963 destroy: glib::GDestroyNotify, 1964 old_destroy: *mut glib::GDestroyNotify, 1965 ) -> gboolean; g_object_replace_qdata( object: *mut GObject, quark: glib::GQuark, oldval: gpointer, newval: gpointer, destroy: glib::GDestroyNotify, old_destroy: *mut glib::GDestroyNotify, ) -> gboolean1966 pub fn g_object_replace_qdata( 1967 object: *mut GObject, 1968 quark: glib::GQuark, 1969 oldval: gpointer, 1970 newval: gpointer, 1971 destroy: glib::GDestroyNotify, 1972 old_destroy: *mut glib::GDestroyNotify, 1973 ) -> gboolean; g_object_run_dispose(object: *mut GObject)1974 pub fn g_object_run_dispose(object: *mut GObject); g_object_set(object: *mut GObject, first_property_name: *const c_char, ...)1975 pub fn g_object_set(object: *mut GObject, first_property_name: *const c_char, ...); g_object_set_data(object: *mut GObject, key: *const c_char, data: gpointer)1976 pub fn g_object_set_data(object: *mut GObject, key: *const c_char, data: gpointer); g_object_set_data_full( object: *mut GObject, key: *const c_char, data: gpointer, destroy: glib::GDestroyNotify, )1977 pub fn g_object_set_data_full( 1978 object: *mut GObject, 1979 key: *const c_char, 1980 data: gpointer, 1981 destroy: glib::GDestroyNotify, 1982 ); g_object_set_property( object: *mut GObject, property_name: *const c_char, value: *const GValue, )1983 pub fn g_object_set_property( 1984 object: *mut GObject, 1985 property_name: *const c_char, 1986 value: *const GValue, 1987 ); g_object_set_qdata(object: *mut GObject, quark: glib::GQuark, data: gpointer)1988 pub fn g_object_set_qdata(object: *mut GObject, quark: glib::GQuark, data: gpointer); g_object_set_qdata_full( object: *mut GObject, quark: glib::GQuark, data: gpointer, destroy: glib::GDestroyNotify, )1989 pub fn g_object_set_qdata_full( 1990 object: *mut GObject, 1991 quark: glib::GQuark, 1992 data: gpointer, 1993 destroy: glib::GDestroyNotify, 1994 ); 1995 //pub fn g_object_set_valist(object: *mut GObject, first_property_name: *const c_char, var_args: /*Unimplemented*/va_list); 1996 #[cfg(any(feature = "v2_54", feature = "dox"))] 1997 #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_54")))] g_object_setv( object: *mut GObject, n_properties: c_uint, names: *mut *const c_char, values: *const GValue, )1998 pub fn g_object_setv( 1999 object: *mut GObject, 2000 n_properties: c_uint, 2001 names: *mut *const c_char, 2002 values: *const GValue, 2003 ); g_object_steal_data(object: *mut GObject, key: *const c_char) -> gpointer2004 pub fn g_object_steal_data(object: *mut GObject, key: *const c_char) -> gpointer; g_object_steal_qdata(object: *mut GObject, quark: glib::GQuark) -> gpointer2005 pub fn g_object_steal_qdata(object: *mut GObject, quark: glib::GQuark) -> gpointer; g_object_thaw_notify(object: *mut GObject)2006 pub fn g_object_thaw_notify(object: *mut GObject); g_object_unref(object: *mut GObject)2007 pub fn g_object_unref(object: *mut GObject); g_object_watch_closure(object: *mut GObject, closure: *mut GClosure)2008 pub fn g_object_watch_closure(object: *mut GObject, closure: *mut GClosure); g_object_weak_ref(object: *mut GObject, notify: GWeakNotify, data: gpointer)2009 pub fn g_object_weak_ref(object: *mut GObject, notify: GWeakNotify, data: gpointer); g_object_weak_unref(object: *mut GObject, notify: GWeakNotify, data: gpointer)2010 pub fn g_object_weak_unref(object: *mut GObject, notify: GWeakNotify, data: gpointer); 2011 2012 //========================================================================= 2013 // GParamSpec 2014 //========================================================================= g_param_spec_internal( param_type: GType, name: *const c_char, nick: *const c_char, blurb: *const c_char, flags: GParamFlags, ) -> *mut GParamSpec2015 pub fn g_param_spec_internal( 2016 param_type: GType, 2017 name: *const c_char, 2018 nick: *const c_char, 2019 blurb: *const c_char, 2020 flags: GParamFlags, 2021 ) -> *mut GParamSpec; 2022 #[cfg(any(feature = "v2_66", feature = "dox"))] 2023 #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_66")))] g_param_spec_is_valid_name(name: *const c_char) -> gboolean2024 pub fn g_param_spec_is_valid_name(name: *const c_char) -> gboolean; g_param_spec_get_blurb(pspec: *mut GParamSpec) -> *const c_char2025 pub fn g_param_spec_get_blurb(pspec: *mut GParamSpec) -> *const c_char; g_param_spec_get_default_value(pspec: *mut GParamSpec) -> *const GValue2026 pub fn g_param_spec_get_default_value(pspec: *mut GParamSpec) -> *const GValue; g_param_spec_get_name(pspec: *mut GParamSpec) -> *const c_char2027 pub fn g_param_spec_get_name(pspec: *mut GParamSpec) -> *const c_char; g_param_spec_get_name_quark(pspec: *mut GParamSpec) -> glib::GQuark2028 pub fn g_param_spec_get_name_quark(pspec: *mut GParamSpec) -> glib::GQuark; g_param_spec_get_nick(pspec: *mut GParamSpec) -> *const c_char2029 pub fn g_param_spec_get_nick(pspec: *mut GParamSpec) -> *const c_char; g_param_spec_get_qdata(pspec: *mut GParamSpec, quark: glib::GQuark) -> gpointer2030 pub fn g_param_spec_get_qdata(pspec: *mut GParamSpec, quark: glib::GQuark) -> gpointer; g_param_spec_get_redirect_target(pspec: *mut GParamSpec) -> *mut GParamSpec2031 pub fn g_param_spec_get_redirect_target(pspec: *mut GParamSpec) -> *mut GParamSpec; g_param_spec_ref(pspec: *mut GParamSpec) -> *mut GParamSpec2032 pub fn g_param_spec_ref(pspec: *mut GParamSpec) -> *mut GParamSpec; g_param_spec_ref_sink(pspec: *mut GParamSpec) -> *mut GParamSpec2033 pub fn g_param_spec_ref_sink(pspec: *mut GParamSpec) -> *mut GParamSpec; g_param_spec_set_qdata(pspec: *mut GParamSpec, quark: glib::GQuark, data: gpointer)2034 pub fn g_param_spec_set_qdata(pspec: *mut GParamSpec, quark: glib::GQuark, data: gpointer); g_param_spec_set_qdata_full( pspec: *mut GParamSpec, quark: glib::GQuark, data: gpointer, destroy: glib::GDestroyNotify, )2035 pub fn g_param_spec_set_qdata_full( 2036 pspec: *mut GParamSpec, 2037 quark: glib::GQuark, 2038 data: gpointer, 2039 destroy: glib::GDestroyNotify, 2040 ); g_param_spec_sink(pspec: *mut GParamSpec)2041 pub fn g_param_spec_sink(pspec: *mut GParamSpec); g_param_spec_steal_qdata(pspec: *mut GParamSpec, quark: glib::GQuark) -> gpointer2042 pub fn g_param_spec_steal_qdata(pspec: *mut GParamSpec, quark: glib::GQuark) -> gpointer; g_param_spec_unref(pspec: *mut GParamSpec)2043 pub fn g_param_spec_unref(pspec: *mut GParamSpec); 2044 2045 //========================================================================= 2046 // GTypeModule 2047 //========================================================================= g_type_module_get_type() -> GType2048 pub fn g_type_module_get_type() -> GType; g_type_module_add_interface( module: *mut GTypeModule, instance_type: GType, interface_type: GType, interface_info: *const GInterfaceInfo, )2049 pub fn g_type_module_add_interface( 2050 module: *mut GTypeModule, 2051 instance_type: GType, 2052 interface_type: GType, 2053 interface_info: *const GInterfaceInfo, 2054 ); g_type_module_register_enum( module: *mut GTypeModule, name: *const c_char, const_static_values: *const GEnumValue, ) -> GType2055 pub fn g_type_module_register_enum( 2056 module: *mut GTypeModule, 2057 name: *const c_char, 2058 const_static_values: *const GEnumValue, 2059 ) -> GType; g_type_module_register_flags( module: *mut GTypeModule, name: *const c_char, const_static_values: *const GFlagsValue, ) -> GType2060 pub fn g_type_module_register_flags( 2061 module: *mut GTypeModule, 2062 name: *const c_char, 2063 const_static_values: *const GFlagsValue, 2064 ) -> GType; g_type_module_register_type( module: *mut GTypeModule, parent_type: GType, type_name: *const c_char, type_info: *const GTypeInfo, flags: GTypeFlags, ) -> GType2065 pub fn g_type_module_register_type( 2066 module: *mut GTypeModule, 2067 parent_type: GType, 2068 type_name: *const c_char, 2069 type_info: *const GTypeInfo, 2070 flags: GTypeFlags, 2071 ) -> GType; g_type_module_set_name(module: *mut GTypeModule, name: *const c_char)2072 pub fn g_type_module_set_name(module: *mut GTypeModule, name: *const c_char); g_type_module_unuse(module: *mut GTypeModule)2073 pub fn g_type_module_unuse(module: *mut GTypeModule); g_type_module_use(module: *mut GTypeModule) -> gboolean2074 pub fn g_type_module_use(module: *mut GTypeModule) -> gboolean; 2075 2076 //========================================================================= 2077 // GTypePlugin 2078 //========================================================================= g_type_plugin_get_type() -> GType2079 pub fn g_type_plugin_get_type() -> GType; g_type_plugin_complete_interface_info( plugin: *mut GTypePlugin, instance_type: GType, interface_type: GType, info: *mut GInterfaceInfo, )2080 pub fn g_type_plugin_complete_interface_info( 2081 plugin: *mut GTypePlugin, 2082 instance_type: GType, 2083 interface_type: GType, 2084 info: *mut GInterfaceInfo, 2085 ); g_type_plugin_complete_type_info( plugin: *mut GTypePlugin, g_type: GType, info: *mut GTypeInfo, value_table: *mut GTypeValueTable, )2086 pub fn g_type_plugin_complete_type_info( 2087 plugin: *mut GTypePlugin, 2088 g_type: GType, 2089 info: *mut GTypeInfo, 2090 value_table: *mut GTypeValueTable, 2091 ); g_type_plugin_unuse(plugin: *mut GTypePlugin)2092 pub fn g_type_plugin_unuse(plugin: *mut GTypePlugin); g_type_plugin_use(plugin: *mut GTypePlugin)2093 pub fn g_type_plugin_use(plugin: *mut GTypePlugin); 2094 2095 //========================================================================= 2096 // Other functions 2097 //========================================================================= g_boxed_copy(boxed_type: GType, src_boxed: gconstpointer) -> gpointer2098 pub fn g_boxed_copy(boxed_type: GType, src_boxed: gconstpointer) -> gpointer; g_boxed_free(boxed_type: GType, boxed: gpointer)2099 pub fn g_boxed_free(boxed_type: GType, boxed: gpointer); g_boxed_type_register_static( name: *const c_char, boxed_copy: GBoxedCopyFunc, boxed_free: GBoxedFreeFunc, ) -> GType2100 pub fn g_boxed_type_register_static( 2101 name: *const c_char, 2102 boxed_copy: GBoxedCopyFunc, 2103 boxed_free: GBoxedFreeFunc, 2104 ) -> GType; g_clear_object(object_ptr: *mut *mut GObject)2105 pub fn g_clear_object(object_ptr: *mut *mut GObject); 2106 #[cfg(any(feature = "v2_62", feature = "dox"))] 2107 #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_62")))] g_clear_signal_handler(handler_id_ptr: *mut c_ulong, instance: *mut GObject)2108 pub fn g_clear_signal_handler(handler_id_ptr: *mut c_ulong, instance: *mut GObject); g_enum_complete_type_info( g_enum_type: GType, info: *mut GTypeInfo, const_values: *const GEnumValue, )2109 pub fn g_enum_complete_type_info( 2110 g_enum_type: GType, 2111 info: *mut GTypeInfo, 2112 const_values: *const GEnumValue, 2113 ); g_enum_get_value(enum_class: *mut GEnumClass, value: c_int) -> *mut GEnumValue2114 pub fn g_enum_get_value(enum_class: *mut GEnumClass, value: c_int) -> *mut GEnumValue; g_enum_get_value_by_name( enum_class: *mut GEnumClass, name: *const c_char, ) -> *mut GEnumValue2115 pub fn g_enum_get_value_by_name( 2116 enum_class: *mut GEnumClass, 2117 name: *const c_char, 2118 ) -> *mut GEnumValue; g_enum_get_value_by_nick( enum_class: *mut GEnumClass, nick: *const c_char, ) -> *mut GEnumValue2119 pub fn g_enum_get_value_by_nick( 2120 enum_class: *mut GEnumClass, 2121 nick: *const c_char, 2122 ) -> *mut GEnumValue; g_enum_register_static( name: *const c_char, const_static_values: *const GEnumValue, ) -> GType2123 pub fn g_enum_register_static( 2124 name: *const c_char, 2125 const_static_values: *const GEnumValue, 2126 ) -> GType; 2127 #[cfg(any(feature = "v2_54", feature = "dox"))] 2128 #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_54")))] g_enum_to_string(g_enum_type: GType, value: c_int) -> *mut c_char2129 pub fn g_enum_to_string(g_enum_type: GType, value: c_int) -> *mut c_char; g_flags_complete_type_info( g_flags_type: GType, info: *mut GTypeInfo, const_values: *const GFlagsValue, )2130 pub fn g_flags_complete_type_info( 2131 g_flags_type: GType, 2132 info: *mut GTypeInfo, 2133 const_values: *const GFlagsValue, 2134 ); g_flags_get_first_value( flags_class: *mut GFlagsClass, value: c_uint, ) -> *mut GFlagsValue2135 pub fn g_flags_get_first_value( 2136 flags_class: *mut GFlagsClass, 2137 value: c_uint, 2138 ) -> *mut GFlagsValue; g_flags_get_value_by_name( flags_class: *mut GFlagsClass, name: *const c_char, ) -> *mut GFlagsValue2139 pub fn g_flags_get_value_by_name( 2140 flags_class: *mut GFlagsClass, 2141 name: *const c_char, 2142 ) -> *mut GFlagsValue; g_flags_get_value_by_nick( flags_class: *mut GFlagsClass, nick: *const c_char, ) -> *mut GFlagsValue2143 pub fn g_flags_get_value_by_nick( 2144 flags_class: *mut GFlagsClass, 2145 nick: *const c_char, 2146 ) -> *mut GFlagsValue; g_flags_register_static( name: *const c_char, const_static_values: *const GFlagsValue, ) -> GType2147 pub fn g_flags_register_static( 2148 name: *const c_char, 2149 const_static_values: *const GFlagsValue, 2150 ) -> GType; 2151 #[cfg(any(feature = "v2_54", feature = "dox"))] 2152 #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_54")))] g_flags_to_string(flags_type: GType, value: c_uint) -> *mut c_char2153 pub fn g_flags_to_string(flags_type: GType, value: c_uint) -> *mut c_char; g_gtype_get_type() -> GType2154 pub fn g_gtype_get_type() -> GType; g_param_spec_boolean( name: *const c_char, nick: *const c_char, blurb: *const c_char, default_value: gboolean, flags: GParamFlags, ) -> *mut GParamSpec2155 pub fn g_param_spec_boolean( 2156 name: *const c_char, 2157 nick: *const c_char, 2158 blurb: *const c_char, 2159 default_value: gboolean, 2160 flags: GParamFlags, 2161 ) -> *mut GParamSpec; g_param_spec_boxed( name: *const c_char, nick: *const c_char, blurb: *const c_char, boxed_type: GType, flags: GParamFlags, ) -> *mut GParamSpec2162 pub fn g_param_spec_boxed( 2163 name: *const c_char, 2164 nick: *const c_char, 2165 blurb: *const c_char, 2166 boxed_type: GType, 2167 flags: GParamFlags, 2168 ) -> *mut GParamSpec; g_param_spec_char( name: *const c_char, nick: *const c_char, blurb: *const c_char, minimum: i8, maximum: i8, default_value: i8, flags: GParamFlags, ) -> *mut GParamSpec2169 pub fn g_param_spec_char( 2170 name: *const c_char, 2171 nick: *const c_char, 2172 blurb: *const c_char, 2173 minimum: i8, 2174 maximum: i8, 2175 default_value: i8, 2176 flags: GParamFlags, 2177 ) -> *mut GParamSpec; g_param_spec_double( name: *const c_char, nick: *const c_char, blurb: *const c_char, minimum: c_double, maximum: c_double, default_value: c_double, flags: GParamFlags, ) -> *mut GParamSpec2178 pub fn g_param_spec_double( 2179 name: *const c_char, 2180 nick: *const c_char, 2181 blurb: *const c_char, 2182 minimum: c_double, 2183 maximum: c_double, 2184 default_value: c_double, 2185 flags: GParamFlags, 2186 ) -> *mut GParamSpec; g_param_spec_enum( name: *const c_char, nick: *const c_char, blurb: *const c_char, enum_type: GType, default_value: c_int, flags: GParamFlags, ) -> *mut GParamSpec2187 pub fn g_param_spec_enum( 2188 name: *const c_char, 2189 nick: *const c_char, 2190 blurb: *const c_char, 2191 enum_type: GType, 2192 default_value: c_int, 2193 flags: GParamFlags, 2194 ) -> *mut GParamSpec; g_param_spec_flags( name: *const c_char, nick: *const c_char, blurb: *const c_char, flags_type: GType, default_value: c_uint, flags: GParamFlags, ) -> *mut GParamSpec2195 pub fn g_param_spec_flags( 2196 name: *const c_char, 2197 nick: *const c_char, 2198 blurb: *const c_char, 2199 flags_type: GType, 2200 default_value: c_uint, 2201 flags: GParamFlags, 2202 ) -> *mut GParamSpec; g_param_spec_float( name: *const c_char, nick: *const c_char, blurb: *const c_char, minimum: c_float, maximum: c_float, default_value: c_float, flags: GParamFlags, ) -> *mut GParamSpec2203 pub fn g_param_spec_float( 2204 name: *const c_char, 2205 nick: *const c_char, 2206 blurb: *const c_char, 2207 minimum: c_float, 2208 maximum: c_float, 2209 default_value: c_float, 2210 flags: GParamFlags, 2211 ) -> *mut GParamSpec; g_param_spec_gtype( name: *const c_char, nick: *const c_char, blurb: *const c_char, is_a_type: GType, flags: GParamFlags, ) -> *mut GParamSpec2212 pub fn g_param_spec_gtype( 2213 name: *const c_char, 2214 nick: *const c_char, 2215 blurb: *const c_char, 2216 is_a_type: GType, 2217 flags: GParamFlags, 2218 ) -> *mut GParamSpec; g_param_spec_int( name: *const c_char, nick: *const c_char, blurb: *const c_char, minimum: c_int, maximum: c_int, default_value: c_int, flags: GParamFlags, ) -> *mut GParamSpec2219 pub fn g_param_spec_int( 2220 name: *const c_char, 2221 nick: *const c_char, 2222 blurb: *const c_char, 2223 minimum: c_int, 2224 maximum: c_int, 2225 default_value: c_int, 2226 flags: GParamFlags, 2227 ) -> *mut GParamSpec; g_param_spec_int64( name: *const c_char, nick: *const c_char, blurb: *const c_char, minimum: i64, maximum: i64, default_value: i64, flags: GParamFlags, ) -> *mut GParamSpec2228 pub fn g_param_spec_int64( 2229 name: *const c_char, 2230 nick: *const c_char, 2231 blurb: *const c_char, 2232 minimum: i64, 2233 maximum: i64, 2234 default_value: i64, 2235 flags: GParamFlags, 2236 ) -> *mut GParamSpec; g_param_spec_long( name: *const c_char, nick: *const c_char, blurb: *const c_char, minimum: c_long, maximum: c_long, default_value: c_long, flags: GParamFlags, ) -> *mut GParamSpec2237 pub fn g_param_spec_long( 2238 name: *const c_char, 2239 nick: *const c_char, 2240 blurb: *const c_char, 2241 minimum: c_long, 2242 maximum: c_long, 2243 default_value: c_long, 2244 flags: GParamFlags, 2245 ) -> *mut GParamSpec; g_param_spec_object( name: *const c_char, nick: *const c_char, blurb: *const c_char, object_type: GType, flags: GParamFlags, ) -> *mut GParamSpec2246 pub fn g_param_spec_object( 2247 name: *const c_char, 2248 nick: *const c_char, 2249 blurb: *const c_char, 2250 object_type: GType, 2251 flags: GParamFlags, 2252 ) -> *mut GParamSpec; g_param_spec_override( name: *const c_char, overridden: *mut GParamSpec, ) -> *mut GParamSpec2253 pub fn g_param_spec_override( 2254 name: *const c_char, 2255 overridden: *mut GParamSpec, 2256 ) -> *mut GParamSpec; g_param_spec_param( name: *const c_char, nick: *const c_char, blurb: *const c_char, param_type: GType, flags: GParamFlags, ) -> *mut GParamSpec2257 pub fn g_param_spec_param( 2258 name: *const c_char, 2259 nick: *const c_char, 2260 blurb: *const c_char, 2261 param_type: GType, 2262 flags: GParamFlags, 2263 ) -> *mut GParamSpec; g_param_spec_pointer( name: *const c_char, nick: *const c_char, blurb: *const c_char, flags: GParamFlags, ) -> *mut GParamSpec2264 pub fn g_param_spec_pointer( 2265 name: *const c_char, 2266 nick: *const c_char, 2267 blurb: *const c_char, 2268 flags: GParamFlags, 2269 ) -> *mut GParamSpec; g_param_spec_string( name: *const c_char, nick: *const c_char, blurb: *const c_char, default_value: *const c_char, flags: GParamFlags, ) -> *mut GParamSpec2270 pub fn g_param_spec_string( 2271 name: *const c_char, 2272 nick: *const c_char, 2273 blurb: *const c_char, 2274 default_value: *const c_char, 2275 flags: GParamFlags, 2276 ) -> *mut GParamSpec; g_param_spec_uchar( name: *const c_char, nick: *const c_char, blurb: *const c_char, minimum: u8, maximum: u8, default_value: u8, flags: GParamFlags, ) -> *mut GParamSpec2277 pub fn g_param_spec_uchar( 2278 name: *const c_char, 2279 nick: *const c_char, 2280 blurb: *const c_char, 2281 minimum: u8, 2282 maximum: u8, 2283 default_value: u8, 2284 flags: GParamFlags, 2285 ) -> *mut GParamSpec; g_param_spec_uint( name: *const c_char, nick: *const c_char, blurb: *const c_char, minimum: c_uint, maximum: c_uint, default_value: c_uint, flags: GParamFlags, ) -> *mut GParamSpec2286 pub fn g_param_spec_uint( 2287 name: *const c_char, 2288 nick: *const c_char, 2289 blurb: *const c_char, 2290 minimum: c_uint, 2291 maximum: c_uint, 2292 default_value: c_uint, 2293 flags: GParamFlags, 2294 ) -> *mut GParamSpec; g_param_spec_uint64( name: *const c_char, nick: *const c_char, blurb: *const c_char, minimum: u64, maximum: u64, default_value: u64, flags: GParamFlags, ) -> *mut GParamSpec2295 pub fn g_param_spec_uint64( 2296 name: *const c_char, 2297 nick: *const c_char, 2298 blurb: *const c_char, 2299 minimum: u64, 2300 maximum: u64, 2301 default_value: u64, 2302 flags: GParamFlags, 2303 ) -> *mut GParamSpec; g_param_spec_ulong( name: *const c_char, nick: *const c_char, blurb: *const c_char, minimum: c_ulong, maximum: c_ulong, default_value: c_ulong, flags: GParamFlags, ) -> *mut GParamSpec2304 pub fn g_param_spec_ulong( 2305 name: *const c_char, 2306 nick: *const c_char, 2307 blurb: *const c_char, 2308 minimum: c_ulong, 2309 maximum: c_ulong, 2310 default_value: c_ulong, 2311 flags: GParamFlags, 2312 ) -> *mut GParamSpec; g_param_spec_unichar( name: *const c_char, nick: *const c_char, blurb: *const c_char, default_value: u32, flags: GParamFlags, ) -> *mut GParamSpec2313 pub fn g_param_spec_unichar( 2314 name: *const c_char, 2315 nick: *const c_char, 2316 blurb: *const c_char, 2317 default_value: u32, 2318 flags: GParamFlags, 2319 ) -> *mut GParamSpec; g_param_spec_value_array( name: *const c_char, nick: *const c_char, blurb: *const c_char, element_spec: *mut GParamSpec, flags: GParamFlags, ) -> *mut GParamSpec2320 pub fn g_param_spec_value_array( 2321 name: *const c_char, 2322 nick: *const c_char, 2323 blurb: *const c_char, 2324 element_spec: *mut GParamSpec, 2325 flags: GParamFlags, 2326 ) -> *mut GParamSpec; g_param_spec_variant( name: *const c_char, nick: *const c_char, blurb: *const c_char, type_: *const glib::GVariantType, default_value: *mut glib::GVariant, flags: GParamFlags, ) -> *mut GParamSpec2327 pub fn g_param_spec_variant( 2328 name: *const c_char, 2329 nick: *const c_char, 2330 blurb: *const c_char, 2331 type_: *const glib::GVariantType, 2332 default_value: *mut glib::GVariant, 2333 flags: GParamFlags, 2334 ) -> *mut GParamSpec; g_param_type_register_static( name: *const c_char, pspec_info: *const GParamSpecTypeInfo, ) -> GType2335 pub fn g_param_type_register_static( 2336 name: *const c_char, 2337 pspec_info: *const GParamSpecTypeInfo, 2338 ) -> GType; g_param_value_convert( pspec: *mut GParamSpec, src_value: *const GValue, dest_value: *mut GValue, strict_validation: gboolean, ) -> gboolean2339 pub fn g_param_value_convert( 2340 pspec: *mut GParamSpec, 2341 src_value: *const GValue, 2342 dest_value: *mut GValue, 2343 strict_validation: gboolean, 2344 ) -> gboolean; g_param_value_defaults(pspec: *mut GParamSpec, value: *const GValue) -> gboolean2345 pub fn g_param_value_defaults(pspec: *mut GParamSpec, value: *const GValue) -> gboolean; g_param_value_set_default(pspec: *mut GParamSpec, value: *mut GValue)2346 pub fn g_param_value_set_default(pspec: *mut GParamSpec, value: *mut GValue); g_param_value_validate(pspec: *mut GParamSpec, value: *mut GValue) -> gboolean2347 pub fn g_param_value_validate(pspec: *mut GParamSpec, value: *mut GValue) -> gboolean; g_param_values_cmp( pspec: *mut GParamSpec, value1: *const GValue, value2: *const GValue, ) -> c_int2348 pub fn g_param_values_cmp( 2349 pspec: *mut GParamSpec, 2350 value1: *const GValue, 2351 value2: *const GValue, 2352 ) -> c_int; g_pointer_type_register_static(name: *const c_char) -> GType2353 pub fn g_pointer_type_register_static(name: *const c_char) -> GType; g_signal_accumulator_first_wins( ihint: *mut GSignalInvocationHint, return_accu: *mut GValue, handler_return: *const GValue, dummy: gpointer, ) -> gboolean2354 pub fn g_signal_accumulator_first_wins( 2355 ihint: *mut GSignalInvocationHint, 2356 return_accu: *mut GValue, 2357 handler_return: *const GValue, 2358 dummy: gpointer, 2359 ) -> gboolean; g_signal_accumulator_true_handled( ihint: *mut GSignalInvocationHint, return_accu: *mut GValue, handler_return: *const GValue, dummy: gpointer, ) -> gboolean2360 pub fn g_signal_accumulator_true_handled( 2361 ihint: *mut GSignalInvocationHint, 2362 return_accu: *mut GValue, 2363 handler_return: *const GValue, 2364 dummy: gpointer, 2365 ) -> gboolean; g_signal_add_emission_hook( signal_id: c_uint, detail: glib::GQuark, hook_func: GSignalEmissionHook, hook_data: gpointer, data_destroy: glib::GDestroyNotify, ) -> c_ulong2366 pub fn g_signal_add_emission_hook( 2367 signal_id: c_uint, 2368 detail: glib::GQuark, 2369 hook_func: GSignalEmissionHook, 2370 hook_data: gpointer, 2371 data_destroy: glib::GDestroyNotify, 2372 ) -> c_ulong; g_signal_chain_from_overridden( instance_and_params: *const GValue, return_value: *mut GValue, )2373 pub fn g_signal_chain_from_overridden( 2374 instance_and_params: *const GValue, 2375 return_value: *mut GValue, 2376 ); g_signal_chain_from_overridden_handler(instance: gpointer, ...)2377 pub fn g_signal_chain_from_overridden_handler(instance: gpointer, ...); g_signal_connect_closure( instance: *mut GObject, detailed_signal: *const c_char, closure: *mut GClosure, after: gboolean, ) -> c_ulong2378