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 )] 11 12 extern crate glib_sys as glib; 13 extern crate libc; 14 15 #[allow(unused_imports)] 16 use libc::{ 17 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void, 18 intptr_t, size_t, ssize_t, time_t, uintptr_t, FILE, 19 }; 20 21 #[allow(unused_imports)] 22 use glib::{gboolean, gconstpointer, gpointer, GType}; 23 24 pub const G_TYPE_INVALID: GType = 0 << G_TYPE_FUNDAMENTAL_SHIFT; 25 pub const G_TYPE_NONE: GType = 1 << G_TYPE_FUNDAMENTAL_SHIFT; 26 pub const G_TYPE_INTERFACE: GType = 2 << G_TYPE_FUNDAMENTAL_SHIFT; 27 pub const G_TYPE_CHAR: GType = 3 << G_TYPE_FUNDAMENTAL_SHIFT; 28 pub const G_TYPE_UCHAR: GType = 4 << G_TYPE_FUNDAMENTAL_SHIFT; 29 pub const G_TYPE_BOOLEAN: GType = 5 << G_TYPE_FUNDAMENTAL_SHIFT; 30 pub const G_TYPE_INT: GType = 6 << G_TYPE_FUNDAMENTAL_SHIFT; 31 pub const G_TYPE_UINT: GType = 7 << G_TYPE_FUNDAMENTAL_SHIFT; 32 pub const G_TYPE_LONG: GType = 8 << G_TYPE_FUNDAMENTAL_SHIFT; 33 pub const G_TYPE_ULONG: GType = 9 << G_TYPE_FUNDAMENTAL_SHIFT; 34 pub const G_TYPE_INT64: GType = 10 << G_TYPE_FUNDAMENTAL_SHIFT; 35 pub const G_TYPE_UINT64: GType = 11 << G_TYPE_FUNDAMENTAL_SHIFT; 36 pub const G_TYPE_ENUM: GType = 12 << G_TYPE_FUNDAMENTAL_SHIFT; 37 pub const G_TYPE_FLAGS: GType = 13 << G_TYPE_FUNDAMENTAL_SHIFT; 38 pub const G_TYPE_FLOAT: GType = 14 << G_TYPE_FUNDAMENTAL_SHIFT; 39 pub const G_TYPE_DOUBLE: GType = 15 << G_TYPE_FUNDAMENTAL_SHIFT; 40 pub const G_TYPE_STRING: GType = 16 << G_TYPE_FUNDAMENTAL_SHIFT; 41 pub const G_TYPE_POINTER: GType = 17 << G_TYPE_FUNDAMENTAL_SHIFT; 42 pub const G_TYPE_BOXED: GType = 18 << G_TYPE_FUNDAMENTAL_SHIFT; 43 pub const G_TYPE_PARAM: GType = 19 << G_TYPE_FUNDAMENTAL_SHIFT; 44 pub const G_TYPE_OBJECT: GType = 20 << G_TYPE_FUNDAMENTAL_SHIFT; 45 pub const G_TYPE_VARIANT: GType = 21 << G_TYPE_FUNDAMENTAL_SHIFT; 46 47 // Aliases 48 pub type GSignalCMarshaller = GClosureMarshal; 49 50 // Constants 51 pub const G_PARAM_MASK: c_int = 255; 52 pub const G_PARAM_STATIC_STRINGS: c_int = 224; 53 pub const G_PARAM_USER_SHIFT: c_int = 8; 54 pub const G_SIGNAL_FLAGS_MASK: c_int = 511; 55 pub const G_SIGNAL_MATCH_MASK: c_int = 63; 56 pub const G_TYPE_FLAG_RESERVED_ID_BIT: GType = 1; 57 pub const G_TYPE_FUNDAMENTAL_MAX: c_int = 255; 58 pub const G_TYPE_FUNDAMENTAL_SHIFT: c_int = 2; 59 pub const G_TYPE_RESERVED_BSE_FIRST: c_int = 32; 60 pub const G_TYPE_RESERVED_BSE_LAST: c_int = 48; 61 pub const G_TYPE_RESERVED_GLIB_FIRST: c_int = 22; 62 pub const G_TYPE_RESERVED_GLIB_LAST: c_int = 31; 63 pub const G_TYPE_RESERVED_USER_FIRST: c_int = 49; 64 pub const G_VALUE_NOCOPY_CONTENTS: c_int = 134217728; 65 66 // Flags 67 pub type GBindingFlags = c_uint; 68 pub const G_BINDING_DEFAULT: GBindingFlags = 0; 69 pub const G_BINDING_BIDIRECTIONAL: GBindingFlags = 1; 70 pub const G_BINDING_SYNC_CREATE: GBindingFlags = 2; 71 pub const G_BINDING_INVERT_BOOLEAN: GBindingFlags = 4; 72 73 pub type GConnectFlags = c_uint; 74 pub const G_CONNECT_AFTER: GConnectFlags = 1; 75 pub const G_CONNECT_SWAPPED: GConnectFlags = 2; 76 77 pub type GParamFlags = c_uint; 78 pub const G_PARAM_READABLE: GParamFlags = 1; 79 pub const G_PARAM_WRITABLE: GParamFlags = 2; 80 pub const G_PARAM_READWRITE: GParamFlags = 3; 81 pub const G_PARAM_CONSTRUCT: GParamFlags = 4; 82 pub const G_PARAM_CONSTRUCT_ONLY: GParamFlags = 8; 83 pub const G_PARAM_LAX_VALIDATION: GParamFlags = 16; 84 pub const G_PARAM_STATIC_NAME: GParamFlags = 32; 85 pub const G_PARAM_PRIVATE: GParamFlags = 32; 86 pub const G_PARAM_STATIC_NICK: GParamFlags = 64; 87 pub const G_PARAM_STATIC_BLURB: GParamFlags = 128; 88 pub const G_PARAM_EXPLICIT_NOTIFY: GParamFlags = 1073741824; 89 pub const G_PARAM_DEPRECATED: GParamFlags = 2147483648; 90 91 pub type GSignalFlags = c_uint; 92 pub const G_SIGNAL_RUN_FIRST: GSignalFlags = 1; 93 pub const G_SIGNAL_RUN_LAST: GSignalFlags = 2; 94 pub const G_SIGNAL_RUN_CLEANUP: GSignalFlags = 4; 95 pub const G_SIGNAL_NO_RECURSE: GSignalFlags = 8; 96 pub const G_SIGNAL_DETAILED: GSignalFlags = 16; 97 pub const G_SIGNAL_ACTION: GSignalFlags = 32; 98 pub const G_SIGNAL_NO_HOOKS: GSignalFlags = 64; 99 pub const G_SIGNAL_MUST_COLLECT: GSignalFlags = 128; 100 pub const G_SIGNAL_DEPRECATED: GSignalFlags = 256; 101 102 pub type GSignalMatchType = c_uint; 103 pub const G_SIGNAL_MATCH_ID: GSignalMatchType = 1; 104 pub const G_SIGNAL_MATCH_DETAIL: GSignalMatchType = 2; 105 pub const G_SIGNAL_MATCH_CLOSURE: GSignalMatchType = 4; 106 pub const G_SIGNAL_MATCH_FUNC: GSignalMatchType = 8; 107 pub const G_SIGNAL_MATCH_DATA: GSignalMatchType = 16; 108 pub const G_SIGNAL_MATCH_UNBLOCKED: GSignalMatchType = 32; 109 110 pub type GTypeDebugFlags = c_uint; 111 pub const G_TYPE_DEBUG_NONE: GTypeDebugFlags = 0; 112 pub const G_TYPE_DEBUG_OBJECTS: GTypeDebugFlags = 1; 113 pub const G_TYPE_DEBUG_SIGNALS: GTypeDebugFlags = 2; 114 pub const G_TYPE_DEBUG_INSTANCE_COUNT: GTypeDebugFlags = 4; 115 pub const G_TYPE_DEBUG_MASK: GTypeDebugFlags = 7; 116 117 pub type GTypeFlags = c_uint; 118 pub const G_TYPE_FLAG_ABSTRACT: GTypeFlags = 16; 119 pub const G_TYPE_FLAG_VALUE_ABSTRACT: GTypeFlags = 32; 120 121 pub type GTypeFundamentalFlags = c_uint; 122 pub const G_TYPE_FLAG_CLASSED: GTypeFundamentalFlags = 1; 123 pub const G_TYPE_FLAG_INSTANTIATABLE: GTypeFundamentalFlags = 2; 124 pub const G_TYPE_FLAG_DERIVABLE: GTypeFundamentalFlags = 4; 125 pub const G_TYPE_FLAG_DEEP_DERIVABLE: GTypeFundamentalFlags = 8; 126 127 // Unions 128 #[repr(C)] 129 pub struct GTypeCValue(c_void); 130 131 impl ::std::fmt::Debug for GTypeCValue { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result132 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 133 f.debug_struct(&format!("GTypeCValue @ {:?}", self as *const _)) 134 .finish() 135 } 136 } 137 138 #[repr(C)] 139 #[derive(Copy, Clone)] 140 pub union GValue_data { 141 pub v_int: c_int, 142 pub v_uint: c_uint, 143 pub v_long: c_long, 144 pub v_ulong: c_ulong, 145 pub v_int64: i64, 146 pub v_uint64: u64, 147 pub v_float: c_float, 148 pub v_double: c_double, 149 pub v_pointer: gpointer, 150 } 151 152 impl ::std::fmt::Debug for GValue_data { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result153 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 154 f.debug_struct(&format!("GValue_data @ {:?}", self as *const _)) 155 .field("v_int", unsafe { &self.v_int }) 156 .field("v_uint", unsafe { &self.v_uint }) 157 .field("v_long", unsafe { &self.v_long }) 158 .field("v_ulong", unsafe { &self.v_ulong }) 159 .field("v_int64", unsafe { &self.v_int64 }) 160 .field("v_uint64", unsafe { &self.v_uint64 }) 161 .field("v_float", unsafe { &self.v_float }) 162 .field("v_double", unsafe { &self.v_double }) 163 .field("v_pointer", unsafe { &self.v_pointer }) 164 .finish() 165 } 166 } 167 168 #[repr(C)] 169 #[derive(Copy, Clone)] 170 pub union GWeakRef_priv { 171 pub p: gpointer, 172 } 173 174 impl ::std::fmt::Debug for GWeakRef_priv { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result175 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 176 f.debug_struct(&format!("GWeakRef_priv @ {:?}", self as *const _)) 177 .field("p", unsafe { &self.p }) 178 .finish() 179 } 180 } 181 182 // Callbacks 183 pub type GBaseFinalizeFunc = Option<unsafe extern "C" fn(gpointer)>; 184 pub type GBaseInitFunc = Option<unsafe extern "C" fn(gpointer)>; 185 pub type GBindingTransformFunc = 186 Option<unsafe extern "C" fn(*mut GBinding, *const GValue, *mut GValue, gpointer) -> gboolean>; 187 pub type GBoxedCopyFunc = Option<unsafe extern "C" fn(gpointer) -> gpointer>; 188 pub type GBoxedFreeFunc = Option<unsafe extern "C" fn(gpointer)>; 189 pub type GCallback = Option<unsafe extern "C" fn()>; 190 pub type GClassFinalizeFunc = Option<unsafe extern "C" fn(gpointer, gpointer)>; 191 pub type GClassInitFunc = Option<unsafe extern "C" fn(gpointer, gpointer)>; 192 pub type GClosureMarshal = Option< 193 unsafe extern "C" fn(*mut GClosure, *mut GValue, c_uint, *const GValue, gpointer, gpointer), 194 >; 195 pub type GClosureNotify = Option<unsafe extern "C" fn(gpointer, *mut GClosure)>; 196 pub type GInstanceInitFunc = Option<unsafe extern "C" fn(*mut GTypeInstance, gpointer)>; 197 pub type GInterfaceFinalizeFunc = Option<unsafe extern "C" fn(gpointer, gpointer)>; 198 pub type GInterfaceInitFunc = Option<unsafe extern "C" fn(gpointer, gpointer)>; 199 pub type GObjectFinalizeFunc = Option<unsafe extern "C" fn(*mut GObject)>; 200 pub type GObjectGetPropertyFunc = 201 Option<unsafe extern "C" fn(*mut GObject, c_uint, *mut GValue, *mut GParamSpec)>; 202 pub type GObjectSetPropertyFunc = 203 Option<unsafe extern "C" fn(*mut GObject, c_uint, *const GValue, *mut GParamSpec)>; 204 pub type GSignalAccumulator = Option< 205 unsafe extern "C" fn( 206 *mut GSignalInvocationHint, 207 *mut GValue, 208 *const GValue, 209 gpointer, 210 ) -> gboolean, 211 >; 212 pub type GSignalEmissionHook = Option< 213 unsafe extern "C" fn(*mut GSignalInvocationHint, c_uint, *const GValue, gpointer) -> gboolean, 214 >; 215 pub type GToggleNotify = Option<unsafe extern "C" fn(gpointer, *mut GObject, gboolean)>; 216 pub type GTypeClassCacheFunc = Option<unsafe extern "C" fn(gpointer, *mut GTypeClass) -> gboolean>; 217 pub type GTypeInterfaceCheckFunc = Option<unsafe extern "C" fn(gpointer, gpointer)>; 218 pub type GTypePluginCompleteInterfaceInfo = 219 Option<unsafe extern "C" fn(*mut GTypePlugin, GType, GType, *mut GInterfaceInfo)>; 220 pub type GTypePluginCompleteTypeInfo = 221 Option<unsafe extern "C" fn(*mut GTypePlugin, GType, *mut GTypeInfo, *mut GTypeValueTable)>; 222 pub type GTypePluginUnuse = Option<unsafe extern "C" fn(*mut GTypePlugin)>; 223 pub type GTypePluginUse = Option<unsafe extern "C" fn(*mut GTypePlugin)>; 224 //pub type GVaClosureMarshal = Option<unsafe extern "C" fn(*mut GClosure, *mut GValue, gpointer, /*Unimplemented*/va_list, gpointer, c_int, *mut GType)>; 225 pub type GValueTransform = Option<unsafe extern "C" fn(*const GValue, *mut GValue)>; 226 pub type GWeakNotify = Option<unsafe extern "C" fn(gpointer, *mut GObject)>; 227 228 // Records 229 #[repr(C)] 230 pub struct GCClosure { 231 _truncated_record_marker: c_void, 232 // /*Ignored*/field closure has incomplete type 233 } 234 235 impl ::std::fmt::Debug for GCClosure { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result236 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 237 f.debug_struct(&format!("GCClosure @ {:?}", self as *const _)) 238 .finish() 239 } 240 } 241 242 #[repr(C)] 243 pub struct GClosure { 244 pub ref_count: c_uint, 245 _truncated_record_marker: c_void, 246 // field meta_marshal_nouse has incomplete type 247 } 248 249 impl ::std::fmt::Debug for GClosure { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result250 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 251 f.debug_struct(&format!("GClosure @ {:?}", self as *const _)) 252 .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 @ {:?}", self as *const _)) 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 @ {:?}", self as *const _)) 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 @ {:?}", self as *const _)) 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 @ {:?}", self as *const _)) 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 @ {:?}", self as *const _)) 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 @ {:?}", self as *const _)) 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 @ {:?}", self as *const _)) 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 @ {:?}", self as *const _)) 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 @ {:?}", self as *const _)) 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 @ {:?}", self as *const _)) 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 @ {:?}", self as *const _)) 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 @ {:?}", self as *const _)) 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 @ {:?}", self as *const _)) 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 @ {:?}", self as *const _)) 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 @ {:?}", self as *const _)) 593 .finish() 594 } 595 } 596 597 #[repr(C)] 598 #[derive(Copy, Clone)] 599 pub struct GTypeFundamentalInfo { 600 pub type_flags: GTypeFundamentalFlags, 601 } 602 603 impl ::std::fmt::Debug for GTypeFundamentalInfo { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result604 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 605 f.debug_struct(&format!("GTypeFundamentalInfo @ {:?}", self as *const _)) 606 .field("type_flags", &self.type_flags) 607 .finish() 608 } 609 } 610 611 #[repr(C)] 612 #[derive(Copy, Clone)] 613 pub struct GTypeInfo { 614 pub class_size: u16, 615 pub base_init: GBaseInitFunc, 616 pub base_finalize: GBaseFinalizeFunc, 617 pub class_init: GClassInitFunc, 618 pub class_finalize: GClassFinalizeFunc, 619 pub class_data: gconstpointer, 620 pub instance_size: u16, 621 pub n_preallocs: u16, 622 pub instance_init: GInstanceInitFunc, 623 pub value_table: *const GTypeValueTable, 624 } 625 626 impl ::std::fmt::Debug for GTypeInfo { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result627 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 628 f.debug_struct(&format!("GTypeInfo @ {:?}", self as *const _)) 629 .field("class_size", &self.class_size) 630 .field("base_init", &self.base_init) 631 .field("base_finalize", &self.base_finalize) 632 .field("class_init", &self.class_init) 633 .field("class_finalize", &self.class_finalize) 634 .field("class_data", &self.class_data) 635 .field("instance_size", &self.instance_size) 636 .field("n_preallocs", &self.n_preallocs) 637 .field("instance_init", &self.instance_init) 638 .field("value_table", &self.value_table) 639 .finish() 640 } 641 } 642 643 #[repr(C)] 644 #[derive(Copy, Clone)] 645 pub struct GTypeInstance { 646 pub g_class: *mut GTypeClass, 647 } 648 649 impl ::std::fmt::Debug for GTypeInstance { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result650 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 651 f.debug_struct(&format!("GTypeInstance @ {:?}", self as *const _)) 652 .finish() 653 } 654 } 655 656 #[repr(C)] 657 #[derive(Copy, Clone)] 658 pub struct GTypeInterface { 659 pub g_type: GType, 660 pub g_instance_type: GType, 661 } 662 663 impl ::std::fmt::Debug for GTypeInterface { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result664 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 665 f.debug_struct(&format!("GTypeInterface @ {:?}", self as *const _)) 666 .finish() 667 } 668 } 669 670 #[repr(C)] 671 #[derive(Copy, Clone)] 672 pub struct GTypeModuleClass { 673 pub parent_class: GObjectClass, 674 pub load: Option<unsafe extern "C" fn(*mut GTypeModule) -> gboolean>, 675 pub unload: Option<unsafe extern "C" fn(*mut GTypeModule)>, 676 pub reserved1: Option<unsafe extern "C" fn()>, 677 pub reserved2: Option<unsafe extern "C" fn()>, 678 pub reserved3: Option<unsafe extern "C" fn()>, 679 pub reserved4: Option<unsafe extern "C" fn()>, 680 } 681 682 impl ::std::fmt::Debug for GTypeModuleClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result683 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 684 f.debug_struct(&format!("GTypeModuleClass @ {:?}", self as *const _)) 685 .field("parent_class", &self.parent_class) 686 .field("load", &self.load) 687 .field("unload", &self.unload) 688 .field("reserved1", &self.reserved1) 689 .field("reserved2", &self.reserved2) 690 .field("reserved3", &self.reserved3) 691 .field("reserved4", &self.reserved4) 692 .finish() 693 } 694 } 695 696 #[repr(C)] 697 #[derive(Copy, Clone)] 698 pub struct GTypePluginClass { 699 pub base_iface: GTypeInterface, 700 pub use_plugin: GTypePluginUse, 701 pub unuse_plugin: GTypePluginUnuse, 702 pub complete_type_info: GTypePluginCompleteTypeInfo, 703 pub complete_interface_info: GTypePluginCompleteInterfaceInfo, 704 } 705 706 impl ::std::fmt::Debug for GTypePluginClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result707 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 708 f.debug_struct(&format!("GTypePluginClass @ {:?}", self as *const _)) 709 .field("use_plugin", &self.use_plugin) 710 .field("unuse_plugin", &self.unuse_plugin) 711 .field("complete_type_info", &self.complete_type_info) 712 .field("complete_interface_info", &self.complete_interface_info) 713 .finish() 714 } 715 } 716 717 #[repr(C)] 718 #[derive(Copy, Clone)] 719 pub struct GTypeQuery { 720 pub type_: GType, 721 pub type_name: *const c_char, 722 pub class_size: c_uint, 723 pub instance_size: c_uint, 724 } 725 726 impl ::std::fmt::Debug for GTypeQuery { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result727 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 728 f.debug_struct(&format!("GTypeQuery @ {:?}", self as *const _)) 729 .field("type_", &self.type_) 730 .field("type_name", &self.type_name) 731 .field("class_size", &self.class_size) 732 .field("instance_size", &self.instance_size) 733 .finish() 734 } 735 } 736 737 #[repr(C)] 738 #[derive(Copy, Clone)] 739 pub struct GTypeValueTable { 740 pub value_init: Option<unsafe extern "C" fn(*mut GValue)>, 741 pub value_free: Option<unsafe extern "C" fn(*mut GValue)>, 742 pub value_copy: Option<unsafe extern "C" fn(*const GValue, *mut GValue)>, 743 pub value_peek_pointer: Option<unsafe extern "C" fn(*const GValue) -> gpointer>, 744 pub collect_format: *const c_char, 745 pub collect_value: Option< 746 unsafe extern "C" fn(*const GValue, c_uint, *mut GTypeCValue, c_uint) -> *mut c_char, 747 >, 748 pub lcopy_format: *const c_char, 749 pub lcopy_value: Option< 750 unsafe extern "C" fn(*const GValue, c_uint, *mut GTypeCValue, c_uint) -> *mut c_char, 751 >, 752 } 753 754 impl ::std::fmt::Debug for GTypeValueTable { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result755 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 756 f.debug_struct(&format!("GTypeValueTable @ {:?}", self as *const _)) 757 .field("value_init", &self.value_init) 758 .field("value_free", &self.value_free) 759 .field("value_copy", &self.value_copy) 760 .field("value_peek_pointer", &self.value_peek_pointer) 761 .field("collect_format", &self.collect_format) 762 .field("collect_value", &self.collect_value) 763 .field("lcopy_format", &self.lcopy_format) 764 .field("lcopy_value", &self.lcopy_value) 765 .finish() 766 } 767 } 768 769 #[repr(C)] 770 #[derive(Copy, Clone)] 771 pub struct GValue { 772 pub g_type: GType, 773 pub data: [GValue_data; 2], 774 } 775 776 impl ::std::fmt::Debug for GValue { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result777 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 778 f.debug_struct(&format!("GValue @ {:?}", self as *const _)) 779 .field("data", &self.data) 780 .finish() 781 } 782 } 783 784 #[repr(C)] 785 #[derive(Copy, Clone)] 786 pub struct GValueArray { 787 pub n_values: c_uint, 788 pub values: *mut GValue, 789 pub n_prealloced: c_uint, 790 } 791 792 impl ::std::fmt::Debug for GValueArray { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result793 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 794 f.debug_struct(&format!("GValueArray @ {:?}", self as *const _)) 795 .field("n_values", &self.n_values) 796 .field("values", &self.values) 797 .finish() 798 } 799 } 800 801 #[repr(C)] 802 #[derive(Copy, Clone)] 803 pub struct GWeakRef { 804 pub priv_: GWeakRef_priv, 805 } 806 807 impl ::std::fmt::Debug for GWeakRef { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result808 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 809 f.debug_struct(&format!("GWeakRef @ {:?}", self as *const _)) 810 .field("priv_", &self.priv_) 811 .finish() 812 } 813 } 814 815 // Classes 816 #[repr(C)] 817 pub struct GBinding(c_void); 818 819 impl ::std::fmt::Debug for GBinding { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result820 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 821 f.debug_struct(&format!("GBinding @ {:?}", self as *const _)) 822 .finish() 823 } 824 } 825 826 #[repr(C)] 827 #[derive(Copy, Clone)] 828 pub struct GInitiallyUnowned { 829 pub g_type_instance: GTypeInstance, 830 pub ref_count: c_uint, 831 pub qdata: *mut glib::GData, 832 } 833 834 impl ::std::fmt::Debug for GInitiallyUnowned { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result835 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 836 f.debug_struct(&format!("GInitiallyUnowned @ {:?}", self as *const _)) 837 .field("g_type_instance", &self.g_type_instance) 838 .finish() 839 } 840 } 841 842 #[repr(C)] 843 #[derive(Copy, Clone)] 844 pub struct GObject { 845 pub g_type_instance: GTypeInstance, 846 pub ref_count: c_uint, 847 pub qdata: *mut glib::GData, 848 } 849 850 impl ::std::fmt::Debug for GObject { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result851 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 852 f.debug_struct(&format!("GObject @ {:?}", self as *const _)) 853 .field("g_type_instance", &self.g_type_instance) 854 .finish() 855 } 856 } 857 858 #[repr(C)] 859 #[derive(Copy, Clone)] 860 pub struct GParamSpec { 861 pub g_type_instance: GTypeInstance, 862 pub name: *const c_char, 863 pub flags: GParamFlags, 864 pub value_type: GType, 865 pub owner_type: GType, 866 pub _nick: *mut c_char, 867 pub _blurb: *mut c_char, 868 pub qdata: *mut glib::GData, 869 pub ref_count: c_uint, 870 pub param_id: c_uint, 871 } 872 873 impl ::std::fmt::Debug for GParamSpec { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result874 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 875 f.debug_struct(&format!("GParamSpec @ {:?}", self as *const _)) 876 .field("g_type_instance", &self.g_type_instance) 877 .field("name", &self.name) 878 .field("flags", &self.flags) 879 .field("value_type", &self.value_type) 880 .field("owner_type", &self.owner_type) 881 .finish() 882 } 883 } 884 885 #[repr(C)] 886 #[derive(Copy, Clone)] 887 pub struct GParamSpecBoolean { 888 pub parent_instance: GParamSpec, 889 pub default_value: gboolean, 890 } 891 892 impl ::std::fmt::Debug for GParamSpecBoolean { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result893 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 894 f.debug_struct(&format!("GParamSpecBoolean @ {:?}", self as *const _)) 895 .field("parent_instance", &self.parent_instance) 896 .field("default_value", &self.default_value) 897 .finish() 898 } 899 } 900 901 #[repr(C)] 902 #[derive(Copy, Clone)] 903 pub struct GParamSpecBoxed { 904 pub parent_instance: GParamSpec, 905 } 906 907 impl ::std::fmt::Debug for GParamSpecBoxed { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result908 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 909 f.debug_struct(&format!("GParamSpecBoxed @ {:?}", self as *const _)) 910 .field("parent_instance", &self.parent_instance) 911 .finish() 912 } 913 } 914 915 #[repr(C)] 916 #[derive(Copy, Clone)] 917 pub struct GParamSpecChar { 918 pub parent_instance: GParamSpec, 919 pub minimum: i8, 920 pub maximum: i8, 921 pub default_value: i8, 922 } 923 924 impl ::std::fmt::Debug for GParamSpecChar { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result925 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 926 f.debug_struct(&format!("GParamSpecChar @ {:?}", self as *const _)) 927 .field("parent_instance", &self.parent_instance) 928 .field("minimum", &self.minimum) 929 .field("maximum", &self.maximum) 930 .field("default_value", &self.default_value) 931 .finish() 932 } 933 } 934 935 #[repr(C)] 936 #[derive(Copy, Clone)] 937 pub struct GParamSpecDouble { 938 pub parent_instance: GParamSpec, 939 pub minimum: c_double, 940 pub maximum: c_double, 941 pub default_value: c_double, 942 pub epsilon: c_double, 943 } 944 945 impl ::std::fmt::Debug for GParamSpecDouble { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result946 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 947 f.debug_struct(&format!("GParamSpecDouble @ {:?}", self as *const _)) 948 .field("parent_instance", &self.parent_instance) 949 .field("minimum", &self.minimum) 950 .field("maximum", &self.maximum) 951 .field("default_value", &self.default_value) 952 .field("epsilon", &self.epsilon) 953 .finish() 954 } 955 } 956 957 #[repr(C)] 958 #[derive(Copy, Clone)] 959 pub struct GParamSpecEnum { 960 pub parent_instance: GParamSpec, 961 pub enum_class: *mut GEnumClass, 962 pub default_value: c_int, 963 } 964 965 impl ::std::fmt::Debug for GParamSpecEnum { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result966 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 967 f.debug_struct(&format!("GParamSpecEnum @ {:?}", self as *const _)) 968 .field("parent_instance", &self.parent_instance) 969 .field("enum_class", &self.enum_class) 970 .field("default_value", &self.default_value) 971 .finish() 972 } 973 } 974 975 #[repr(C)] 976 #[derive(Copy, Clone)] 977 pub struct GParamSpecFlags { 978 pub parent_instance: GParamSpec, 979 pub flags_class: *mut GFlagsClass, 980 pub default_value: c_uint, 981 } 982 983 impl ::std::fmt::Debug for GParamSpecFlags { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result984 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 985 f.debug_struct(&format!("GParamSpecFlags @ {:?}", self as *const _)) 986 .field("parent_instance", &self.parent_instance) 987 .field("flags_class", &self.flags_class) 988 .field("default_value", &self.default_value) 989 .finish() 990 } 991 } 992 993 #[repr(C)] 994 #[derive(Copy, Clone)] 995 pub struct GParamSpecFloat { 996 pub parent_instance: GParamSpec, 997 pub minimum: c_float, 998 pub maximum: c_float, 999 pub default_value: c_float, 1000 pub epsilon: c_float, 1001 } 1002 1003 impl ::std::fmt::Debug for GParamSpecFloat { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1004 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1005 f.debug_struct(&format!("GParamSpecFloat @ {:?}", self as *const _)) 1006 .field("parent_instance", &self.parent_instance) 1007 .field("minimum", &self.minimum) 1008 .field("maximum", &self.maximum) 1009 .field("default_value", &self.default_value) 1010 .field("epsilon", &self.epsilon) 1011 .finish() 1012 } 1013 } 1014 1015 #[repr(C)] 1016 #[derive(Copy, Clone)] 1017 pub struct GParamSpecGType { 1018 pub parent_instance: GParamSpec, 1019 pub is_a_type: GType, 1020 } 1021 1022 impl ::std::fmt::Debug for GParamSpecGType { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1023 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1024 f.debug_struct(&format!("GParamSpecGType @ {:?}", self as *const _)) 1025 .field("parent_instance", &self.parent_instance) 1026 .field("is_a_type", &self.is_a_type) 1027 .finish() 1028 } 1029 } 1030 1031 #[repr(C)] 1032 #[derive(Copy, Clone)] 1033 pub struct GParamSpecInt { 1034 pub parent_instance: GParamSpec, 1035 pub minimum: c_int, 1036 pub maximum: c_int, 1037 pub default_value: c_int, 1038 } 1039 1040 impl ::std::fmt::Debug for GParamSpecInt { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1041 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1042 f.debug_struct(&format!("GParamSpecInt @ {:?}", self as *const _)) 1043 .field("parent_instance", &self.parent_instance) 1044 .field("minimum", &self.minimum) 1045 .field("maximum", &self.maximum) 1046 .field("default_value", &self.default_value) 1047 .finish() 1048 } 1049 } 1050 1051 #[repr(C)] 1052 #[derive(Copy, Clone)] 1053 pub struct GParamSpecInt64 { 1054 pub parent_instance: GParamSpec, 1055 pub minimum: i64, 1056 pub maximum: i64, 1057 pub default_value: i64, 1058 } 1059 1060 impl ::std::fmt::Debug for GParamSpecInt64 { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1061 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1062 f.debug_struct(&format!("GParamSpecInt64 @ {:?}", self as *const _)) 1063 .field("parent_instance", &self.parent_instance) 1064 .field("minimum", &self.minimum) 1065 .field("maximum", &self.maximum) 1066 .field("default_value", &self.default_value) 1067 .finish() 1068 } 1069 } 1070 1071 #[repr(C)] 1072 #[derive(Copy, Clone)] 1073 pub struct GParamSpecLong { 1074 pub parent_instance: GParamSpec, 1075 pub minimum: c_long, 1076 pub maximum: c_long, 1077 pub default_value: c_long, 1078 } 1079 1080 impl ::std::fmt::Debug for GParamSpecLong { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1081 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1082 f.debug_struct(&format!("GParamSpecLong @ {:?}", self as *const _)) 1083 .field("parent_instance", &self.parent_instance) 1084 .field("minimum", &self.minimum) 1085 .field("maximum", &self.maximum) 1086 .field("default_value", &self.default_value) 1087 .finish() 1088 } 1089 } 1090 1091 #[repr(C)] 1092 #[derive(Copy, Clone)] 1093 pub struct GParamSpecObject { 1094 pub parent_instance: GParamSpec, 1095 } 1096 1097 impl ::std::fmt::Debug for GParamSpecObject { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1098 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1099 f.debug_struct(&format!("GParamSpecObject @ {:?}", self as *const _)) 1100 .field("parent_instance", &self.parent_instance) 1101 .finish() 1102 } 1103 } 1104 1105 #[repr(C)] 1106 #[derive(Copy, Clone)] 1107 pub struct GParamSpecOverride { 1108 pub parent_instance: GParamSpec, 1109 pub overridden: *mut GParamSpec, 1110 } 1111 1112 impl ::std::fmt::Debug for GParamSpecOverride { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1113 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1114 f.debug_struct(&format!("GParamSpecOverride @ {:?}", self as *const _)) 1115 .finish() 1116 } 1117 } 1118 1119 #[repr(C)] 1120 #[derive(Copy, Clone)] 1121 pub struct GParamSpecParam { 1122 pub parent_instance: GParamSpec, 1123 } 1124 1125 impl ::std::fmt::Debug for GParamSpecParam { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1126 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1127 f.debug_struct(&format!("GParamSpecParam @ {:?}", self as *const _)) 1128 .field("parent_instance", &self.parent_instance) 1129 .finish() 1130 } 1131 } 1132 1133 #[repr(C)] 1134 #[derive(Copy, Clone)] 1135 pub struct GParamSpecPointer { 1136 pub parent_instance: GParamSpec, 1137 } 1138 1139 impl ::std::fmt::Debug for GParamSpecPointer { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1140 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1141 f.debug_struct(&format!("GParamSpecPointer @ {:?}", self as *const _)) 1142 .field("parent_instance", &self.parent_instance) 1143 .finish() 1144 } 1145 } 1146 1147 #[repr(C)] 1148 pub struct GParamSpecString { 1149 pub parent_instance: GParamSpec, 1150 pub default_value: *mut c_char, 1151 pub cset_first: *mut c_char, 1152 pub cset_nth: *mut c_char, 1153 pub substitutor: c_char, 1154 pub null_fold_if_empty: c_uint, 1155 _truncated_record_marker: c_void, 1156 // field ensure_non_null has incomplete type 1157 } 1158 1159 impl ::std::fmt::Debug for GParamSpecString { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1160 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1161 f.debug_struct(&format!("GParamSpecString @ {:?}", self as *const _)) 1162 .field("parent_instance", &self.parent_instance) 1163 .field("default_value", &self.default_value) 1164 .field("cset_first", &self.cset_first) 1165 .field("cset_nth", &self.cset_nth) 1166 .field("substitutor", &self.substitutor) 1167 .field("null_fold_if_empty", &self.null_fold_if_empty) 1168 .finish() 1169 } 1170 } 1171 1172 #[repr(C)] 1173 #[derive(Copy, Clone)] 1174 pub struct GParamSpecUChar { 1175 pub parent_instance: GParamSpec, 1176 pub minimum: u8, 1177 pub maximum: u8, 1178 pub default_value: u8, 1179 } 1180 1181 impl ::std::fmt::Debug for GParamSpecUChar { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1182 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1183 f.debug_struct(&format!("GParamSpecUChar @ {:?}", self as *const _)) 1184 .field("parent_instance", &self.parent_instance) 1185 .field("minimum", &self.minimum) 1186 .field("maximum", &self.maximum) 1187 .field("default_value", &self.default_value) 1188 .finish() 1189 } 1190 } 1191 1192 #[repr(C)] 1193 #[derive(Copy, Clone)] 1194 pub struct GParamSpecUInt { 1195 pub parent_instance: GParamSpec, 1196 pub minimum: c_uint, 1197 pub maximum: c_uint, 1198 pub default_value: c_uint, 1199 } 1200 1201 impl ::std::fmt::Debug for GParamSpecUInt { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1202 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1203 f.debug_struct(&format!("GParamSpecUInt @ {:?}", self as *const _)) 1204 .field("parent_instance", &self.parent_instance) 1205 .field("minimum", &self.minimum) 1206 .field("maximum", &self.maximum) 1207 .field("default_value", &self.default_value) 1208 .finish() 1209 } 1210 } 1211 1212 #[repr(C)] 1213 #[derive(Copy, Clone)] 1214 pub struct GParamSpecUInt64 { 1215 pub parent_instance: GParamSpec, 1216 pub minimum: u64, 1217 pub maximum: u64, 1218 pub default_value: u64, 1219 } 1220 1221 impl ::std::fmt::Debug for GParamSpecUInt64 { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1222 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1223 f.debug_struct(&format!("GParamSpecUInt64 @ {:?}", self as *const _)) 1224 .field("parent_instance", &self.parent_instance) 1225 .field("minimum", &self.minimum) 1226 .field("maximum", &self.maximum) 1227 .field("default_value", &self.default_value) 1228 .finish() 1229 } 1230 } 1231 1232 #[repr(C)] 1233 #[derive(Copy, Clone)] 1234 pub struct GParamSpecULong { 1235 pub parent_instance: GParamSpec, 1236 pub minimum: c_ulong, 1237 pub maximum: c_ulong, 1238 pub default_value: c_ulong, 1239 } 1240 1241 impl ::std::fmt::Debug for GParamSpecULong { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1242 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1243 f.debug_struct(&format!("GParamSpecULong @ {:?}", self as *const _)) 1244 .field("parent_instance", &self.parent_instance) 1245 .field("minimum", &self.minimum) 1246 .field("maximum", &self.maximum) 1247 .field("default_value", &self.default_value) 1248 .finish() 1249 } 1250 } 1251 1252 #[repr(C)] 1253 #[derive(Copy, Clone)] 1254 pub struct GParamSpecUnichar { 1255 pub parent_instance: GParamSpec, 1256 pub default_value: u32, 1257 } 1258 1259 impl ::std::fmt::Debug for GParamSpecUnichar { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1260 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1261 f.debug_struct(&format!("GParamSpecUnichar @ {:?}", self as *const _)) 1262 .field("parent_instance", &self.parent_instance) 1263 .field("default_value", &self.default_value) 1264 .finish() 1265 } 1266 } 1267 1268 #[repr(C)] 1269 #[derive(Copy, Clone)] 1270 pub struct GParamSpecValueArray { 1271 pub parent_instance: GParamSpec, 1272 pub element_spec: *mut GParamSpec, 1273 pub fixed_n_elements: c_uint, 1274 } 1275 1276 impl ::std::fmt::Debug for GParamSpecValueArray { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1277 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1278 f.debug_struct(&format!("GParamSpecValueArray @ {:?}", self as *const _)) 1279 .field("parent_instance", &self.parent_instance) 1280 .field("element_spec", &self.element_spec) 1281 .field("fixed_n_elements", &self.fixed_n_elements) 1282 .finish() 1283 } 1284 } 1285 1286 #[repr(C)] 1287 #[derive(Copy, Clone)] 1288 pub struct GParamSpecVariant { 1289 pub parent_instance: GParamSpec, 1290 pub type_: *mut glib::GVariantType, 1291 pub default_value: *mut glib::GVariant, 1292 pub padding: [gpointer; 4], 1293 } 1294 1295 impl ::std::fmt::Debug for GParamSpecVariant { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1296 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1297 f.debug_struct(&format!("GParamSpecVariant @ {:?}", self as *const _)) 1298 .field("parent_instance", &self.parent_instance) 1299 .field("type_", &self.type_) 1300 .field("default_value", &self.default_value) 1301 .finish() 1302 } 1303 } 1304 1305 #[repr(C)] 1306 #[derive(Copy, Clone)] 1307 pub struct GTypeModule { 1308 pub parent_instance: GObject, 1309 pub use_count: c_uint, 1310 pub type_infos: *mut glib::GSList, 1311 pub interface_infos: *mut glib::GSList, 1312 pub name: *mut c_char, 1313 } 1314 1315 impl ::std::fmt::Debug for GTypeModule { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1316 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1317 f.debug_struct(&format!("GTypeModule @ {:?}", self as *const _)) 1318 .field("parent_instance", &self.parent_instance) 1319 .field("use_count", &self.use_count) 1320 .field("type_infos", &self.type_infos) 1321 .field("interface_infos", &self.interface_infos) 1322 .field("name", &self.name) 1323 .finish() 1324 } 1325 } 1326 1327 // Interfaces 1328 #[repr(C)] 1329 pub struct GTypePlugin(c_void); 1330 1331 impl ::std::fmt::Debug for GTypePlugin { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1332 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1333 write!(f, "GTypePlugin @ {:?}", self as *const _) 1334 } 1335 } 1336 1337 extern "C" { 1338 1339 //========================================================================= 1340 // GBindingFlags 1341 //========================================================================= g_binding_flags_get_type() -> GType1342 pub fn g_binding_flags_get_type() -> GType; 1343 1344 //========================================================================= 1345 // GCClosure 1346 //========================================================================= 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, )1347 pub fn g_cclosure_marshal_BOOLEAN__BOXED_BOXED( 1348 closure: *mut GClosure, 1349 return_value: *mut GValue, 1350 n_param_values: c_uint, 1351 param_values: *const GValue, 1352 invocation_hint: gpointer, 1353 marshal_data: gpointer, 1354 ); 1355 //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, )1356 pub fn g_cclosure_marshal_BOOLEAN__FLAGS( 1357 closure: *mut GClosure, 1358 return_value: *mut GValue, 1359 n_param_values: c_uint, 1360 param_values: *const GValue, 1361 invocation_hint: gpointer, 1362 marshal_data: gpointer, 1363 ); 1364 //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, )1365 pub fn g_cclosure_marshal_STRING__OBJECT_POINTER( 1366 closure: *mut GClosure, 1367 return_value: *mut GValue, 1368 n_param_values: c_uint, 1369 param_values: *const GValue, 1370 invocation_hint: gpointer, 1371 marshal_data: gpointer, 1372 ); 1373 //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, )1374 pub fn g_cclosure_marshal_VOID__BOOLEAN( 1375 closure: *mut GClosure, 1376 return_value: *mut GValue, 1377 n_param_values: c_uint, 1378 param_values: *const GValue, 1379 invocation_hint: gpointer, 1380 marshal_data: gpointer, 1381 ); 1382 //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, )1383 pub fn g_cclosure_marshal_VOID__BOXED( 1384 closure: *mut GClosure, 1385 return_value: *mut GValue, 1386 n_param_values: c_uint, 1387 param_values: *const GValue, 1388 invocation_hint: gpointer, 1389 marshal_data: gpointer, 1390 ); 1391 //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, )1392 pub fn g_cclosure_marshal_VOID__CHAR( 1393 closure: *mut GClosure, 1394 return_value: *mut GValue, 1395 n_param_values: c_uint, 1396 param_values: *const GValue, 1397 invocation_hint: gpointer, 1398 marshal_data: gpointer, 1399 ); 1400 //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, )1401 pub fn g_cclosure_marshal_VOID__DOUBLE( 1402 closure: *mut GClosure, 1403 return_value: *mut GValue, 1404 n_param_values: c_uint, 1405 param_values: *const GValue, 1406 invocation_hint: gpointer, 1407 marshal_data: gpointer, 1408 ); 1409 //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, )1410 pub fn g_cclosure_marshal_VOID__ENUM( 1411 closure: *mut GClosure, 1412 return_value: *mut GValue, 1413 n_param_values: c_uint, 1414 param_values: *const GValue, 1415 invocation_hint: gpointer, 1416 marshal_data: gpointer, 1417 ); 1418 //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, )1419 pub fn g_cclosure_marshal_VOID__FLAGS( 1420 closure: *mut GClosure, 1421 return_value: *mut GValue, 1422 n_param_values: c_uint, 1423 param_values: *const GValue, 1424 invocation_hint: gpointer, 1425 marshal_data: gpointer, 1426 ); 1427 //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, )1428 pub fn g_cclosure_marshal_VOID__FLOAT( 1429 closure: *mut GClosure, 1430 return_value: *mut GValue, 1431 n_param_values: c_uint, 1432 param_values: *const GValue, 1433 invocation_hint: gpointer, 1434 marshal_data: gpointer, 1435 ); 1436 //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, )1437 pub fn g_cclosure_marshal_VOID__INT( 1438 closure: *mut GClosure, 1439 return_value: *mut GValue, 1440 n_param_values: c_uint, 1441 param_values: *const GValue, 1442 invocation_hint: gpointer, 1443 marshal_data: gpointer, 1444 ); 1445 //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, )1446 pub fn g_cclosure_marshal_VOID__LONG( 1447 closure: *mut GClosure, 1448 return_value: *mut GValue, 1449 n_param_values: c_uint, 1450 param_values: *const GValue, 1451 invocation_hint: gpointer, 1452 marshal_data: gpointer, 1453 ); 1454 //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, )1455 pub fn g_cclosure_marshal_VOID__OBJECT( 1456 closure: *mut GClosure, 1457 return_value: *mut GValue, 1458 n_param_values: c_uint, 1459 param_values: *const GValue, 1460 invocation_hint: gpointer, 1461 marshal_data: gpointer, 1462 ); 1463 //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, )1464 pub fn g_cclosure_marshal_VOID__PARAM( 1465 closure: *mut GClosure, 1466 return_value: *mut GValue, 1467 n_param_values: c_uint, 1468 param_values: *const GValue, 1469 invocation_hint: gpointer, 1470 marshal_data: gpointer, 1471 ); 1472 //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, )1473 pub fn g_cclosure_marshal_VOID__POINTER( 1474 closure: *mut GClosure, 1475 return_value: *mut GValue, 1476 n_param_values: c_uint, 1477 param_values: *const GValue, 1478 invocation_hint: gpointer, 1479 marshal_data: gpointer, 1480 ); 1481 //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, )1482 pub fn g_cclosure_marshal_VOID__STRING( 1483 closure: *mut GClosure, 1484 return_value: *mut GValue, 1485 n_param_values: c_uint, 1486 param_values: *const GValue, 1487 invocation_hint: gpointer, 1488 marshal_data: gpointer, 1489 ); 1490 //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, )1491 pub fn g_cclosure_marshal_VOID__UCHAR( 1492 closure: *mut GClosure, 1493 return_value: *mut GValue, 1494 n_param_values: c_uint, 1495 param_values: *const GValue, 1496 invocation_hint: gpointer, 1497 marshal_data: gpointer, 1498 ); 1499 //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, )1500 pub fn g_cclosure_marshal_VOID__UINT( 1501 closure: *mut GClosure, 1502 return_value: *mut GValue, 1503 n_param_values: c_uint, 1504 param_values: *const GValue, 1505 invocation_hint: gpointer, 1506 marshal_data: gpointer, 1507 ); 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, )1508 pub fn g_cclosure_marshal_VOID__UINT_POINTER( 1509 closure: *mut GClosure, 1510 return_value: *mut GValue, 1511 n_param_values: c_uint, 1512 param_values: *const GValue, 1513 invocation_hint: gpointer, 1514 marshal_data: gpointer, 1515 ); 1516 //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); 1517 //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, )1518 pub fn g_cclosure_marshal_VOID__ULONG( 1519 closure: *mut GClosure, 1520 return_value: *mut GValue, 1521 n_param_values: c_uint, 1522 param_values: *const GValue, 1523 invocation_hint: gpointer, 1524 marshal_data: gpointer, 1525 ); 1526 //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, )1527 pub fn g_cclosure_marshal_VOID__VARIANT( 1528 closure: *mut GClosure, 1529 return_value: *mut GValue, 1530 n_param_values: c_uint, 1531 param_values: *const GValue, 1532 invocation_hint: gpointer, 1533 marshal_data: gpointer, 1534 ); 1535 //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, )1536 pub fn g_cclosure_marshal_VOID__VOID( 1537 closure: *mut GClosure, 1538 return_value: *mut GValue, 1539 n_param_values: c_uint, 1540 param_values: *const GValue, 1541 invocation_hint: gpointer, 1542 marshal_data: gpointer, 1543 ); 1544 //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, )1545 pub fn g_cclosure_marshal_generic( 1546 closure: *mut GClosure, 1547 return_gvalue: *mut GValue, 1548 n_param_values: c_uint, 1549 param_values: *const GValue, 1550 invocation_hint: gpointer, 1551 marshal_data: gpointer, 1552 ); 1553 //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 GClosure1554 pub fn g_cclosure_new( 1555 callback_func: GCallback, 1556 user_data: gpointer, 1557 destroy_data: GClosureNotify, 1558 ) -> *mut GClosure; g_cclosure_new_object(callback_func: GCallback, object: *mut GObject) -> *mut GClosure1559 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 GClosure1560 pub fn g_cclosure_new_object_swap( 1561 callback_func: GCallback, 1562 object: *mut GObject, 1563 ) -> *mut GClosure; g_cclosure_new_swap( callback_func: GCallback, user_data: gpointer, destroy_data: GClosureNotify, ) -> *mut GClosure1564 pub fn g_cclosure_new_swap( 1565 callback_func: GCallback, 1566 user_data: gpointer, 1567 destroy_data: GClosureNotify, 1568 ) -> *mut GClosure; 1569 1570 //========================================================================= 1571 // GClosure 1572 //========================================================================= g_closure_get_type() -> GType1573 pub fn g_closure_get_type() -> GType; g_closure_new_object(sizeof_closure: c_uint, object: *mut GObject) -> *mut GClosure1574 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 GClosure1575 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, )1576 pub fn g_closure_add_finalize_notifier( 1577 closure: *mut GClosure, 1578 notify_data: gpointer, 1579 notify_func: GClosureNotify, 1580 ); g_closure_add_invalidate_notifier( closure: *mut GClosure, notify_data: gpointer, notify_func: GClosureNotify, )1581 pub fn g_closure_add_invalidate_notifier( 1582 closure: *mut GClosure, 1583 notify_data: gpointer, 1584 notify_func: GClosureNotify, 1585 ); g_closure_add_marshal_guards( closure: *mut GClosure, pre_marshal_data: gpointer, pre_marshal_notify: GClosureNotify, post_marshal_data: gpointer, post_marshal_notify: GClosureNotify, )1586 pub fn g_closure_add_marshal_guards( 1587 closure: *mut GClosure, 1588 pre_marshal_data: gpointer, 1589 pre_marshal_notify: GClosureNotify, 1590 post_marshal_data: gpointer, 1591 post_marshal_notify: GClosureNotify, 1592 ); g_closure_invalidate(closure: *mut GClosure)1593 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, )1594 pub fn g_closure_invoke( 1595 closure: *mut GClosure, 1596 return_value: *mut GValue, 1597 n_param_values: c_uint, 1598 param_values: *const GValue, 1599 invocation_hint: gpointer, 1600 ); g_closure_ref(closure: *mut GClosure) -> *mut GClosure1601 pub fn g_closure_ref(closure: *mut GClosure) -> *mut GClosure; g_closure_remove_finalize_notifier( closure: *mut GClosure, notify_data: gpointer, notify_func: GClosureNotify, )1602 pub fn g_closure_remove_finalize_notifier( 1603 closure: *mut GClosure, 1604 notify_data: gpointer, 1605 notify_func: GClosureNotify, 1606 ); g_closure_remove_invalidate_notifier( closure: *mut GClosure, notify_data: gpointer, notify_func: GClosureNotify, )1607 pub fn g_closure_remove_invalidate_notifier( 1608 closure: *mut GClosure, 1609 notify_data: gpointer, 1610 notify_func: GClosureNotify, 1611 ); g_closure_set_marshal(closure: *mut GClosure, marshal: GClosureMarshal)1612 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, )1613 pub fn g_closure_set_meta_marshal( 1614 closure: *mut GClosure, 1615 marshal_data: gpointer, 1616 meta_marshal: GClosureMarshal, 1617 ); g_closure_sink(closure: *mut GClosure)1618 pub fn g_closure_sink(closure: *mut GClosure); g_closure_unref(closure: *mut GClosure)1619 pub fn g_closure_unref(closure: *mut GClosure); 1620 1621 //========================================================================= 1622 // GObjectClass 1623 //========================================================================= g_object_class_find_property( oclass: *mut GObjectClass, property_name: *const c_char, ) -> *mut GParamSpec1624 pub fn g_object_class_find_property( 1625 oclass: *mut GObjectClass, 1626 property_name: *const c_char, 1627 ) -> *mut GParamSpec; g_object_class_install_properties( oclass: *mut GObjectClass, n_pspecs: c_uint, pspecs: *mut *mut GParamSpec, )1628 pub fn g_object_class_install_properties( 1629 oclass: *mut GObjectClass, 1630 n_pspecs: c_uint, 1631 pspecs: *mut *mut GParamSpec, 1632 ); g_object_class_install_property( oclass: *mut GObjectClass, property_id: c_uint, pspec: *mut GParamSpec, )1633 pub fn g_object_class_install_property( 1634 oclass: *mut GObjectClass, 1635 property_id: c_uint, 1636 pspec: *mut GParamSpec, 1637 ); g_object_class_list_properties( oclass: *mut GObjectClass, n_properties: *mut c_uint, ) -> *mut *mut GParamSpec1638 pub fn g_object_class_list_properties( 1639 oclass: *mut GObjectClass, 1640 n_properties: *mut c_uint, 1641 ) -> *mut *mut GParamSpec; g_object_class_override_property( oclass: *mut GObjectClass, property_id: c_uint, name: *const c_char, )1642 pub fn g_object_class_override_property( 1643 oclass: *mut GObjectClass, 1644 property_id: c_uint, 1645 name: *const c_char, 1646 ); 1647 1648 //========================================================================= 1649 // GParamSpecPool 1650 //========================================================================= g_param_spec_pool_insert( pool: *mut GParamSpecPool, pspec: *mut GParamSpec, owner_type: GType, )1651 pub fn g_param_spec_pool_insert( 1652 pool: *mut GParamSpecPool, 1653 pspec: *mut GParamSpec, 1654 owner_type: GType, 1655 ); g_param_spec_pool_list( pool: *mut GParamSpecPool, owner_type: GType, n_pspecs_p: *mut c_uint, ) -> *mut *mut GParamSpec1656 pub fn g_param_spec_pool_list( 1657 pool: *mut GParamSpecPool, 1658 owner_type: GType, 1659 n_pspecs_p: *mut c_uint, 1660 ) -> *mut *mut GParamSpec; g_param_spec_pool_list_owned( pool: *mut GParamSpecPool, owner_type: GType, ) -> *mut glib::GList1661 pub fn g_param_spec_pool_list_owned( 1662 pool: *mut GParamSpecPool, 1663 owner_type: GType, 1664 ) -> *mut glib::GList; g_param_spec_pool_lookup( pool: *mut GParamSpecPool, param_name: *const c_char, owner_type: GType, walk_ancestors: gboolean, ) -> *mut GParamSpec1665 pub fn g_param_spec_pool_lookup( 1666 pool: *mut GParamSpecPool, 1667 param_name: *const c_char, 1668 owner_type: GType, 1669 walk_ancestors: gboolean, 1670 ) -> *mut GParamSpec; g_param_spec_pool_remove(pool: *mut GParamSpecPool, pspec: *mut GParamSpec)1671 pub fn g_param_spec_pool_remove(pool: *mut GParamSpecPool, pspec: *mut GParamSpec); g_param_spec_pool_new(type_prefixing: gboolean) -> *mut GParamSpecPool1672 pub fn g_param_spec_pool_new(type_prefixing: gboolean) -> *mut GParamSpecPool; 1673 1674 //========================================================================= 1675 // GTypeClass 1676 //========================================================================= g_type_class_add_private(g_class: gpointer, private_size: size_t)1677 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_int1678 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) -> gpointer1679 pub fn g_type_class_get_private(klass: *mut GTypeClass, private_type: GType) -> gpointer; g_type_class_peek_parent(g_class: gpointer) -> gpointer1680 pub fn g_type_class_peek_parent(g_class: gpointer) -> gpointer; g_type_class_unref(g_class: gpointer)1681 pub fn g_type_class_unref(g_class: gpointer); g_type_class_unref_uncached(g_class: gpointer)1682 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, )1683 pub fn g_type_class_adjust_private_offset( 1684 g_class: gpointer, 1685 private_size_or_offset: *mut c_int, 1686 ); g_type_class_peek(type_: GType) -> gpointer1687 pub fn g_type_class_peek(type_: GType) -> gpointer; g_type_class_peek_static(type_: GType) -> gpointer1688 pub fn g_type_class_peek_static(type_: GType) -> gpointer; g_type_class_ref(type_: GType) -> gpointer1689 pub fn g_type_class_ref(type_: GType) -> gpointer; 1690 1691 //========================================================================= 1692 // GTypeInstance 1693 //========================================================================= g_type_instance_get_private( instance: *mut GTypeInstance, private_type: GType, ) -> gpointer1694 pub fn g_type_instance_get_private( 1695 instance: *mut GTypeInstance, 1696 private_type: GType, 1697 ) -> gpointer; 1698 1699 //========================================================================= 1700 // GTypeInterface 1701 //========================================================================= g_type_interface_peek_parent(g_iface: gpointer) -> gpointer1702 pub fn g_type_interface_peek_parent(g_iface: gpointer) -> gpointer; g_type_interface_add_prerequisite(interface_type: GType, prerequisite_type: GType)1703 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 GTypePlugin1704 pub fn g_type_interface_get_plugin( 1705 instance_type: GType, 1706 interface_type: GType, 1707 ) -> *mut GTypePlugin; g_type_interface_peek(instance_class: gpointer, iface_type: GType) -> gpointer1708 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 GType1709 pub fn g_type_interface_prerequisites( 1710 interface_type: GType, 1711 n_prerequisites: *mut c_uint, 1712 ) -> *mut GType; 1713 1714 //========================================================================= 1715 // GTypeValueTable 1716 //========================================================================= g_type_value_table_peek(type_: GType) -> *mut GTypeValueTable1717 pub fn g_type_value_table_peek(type_: GType) -> *mut GTypeValueTable; 1718 1719 //========================================================================= 1720 // GValue 1721 //========================================================================= g_value_get_type() -> GType1722 pub fn g_value_get_type() -> GType; g_value_copy(src_value: *const GValue, dest_value: *mut GValue)1723 pub fn g_value_copy(src_value: *const GValue, dest_value: *mut GValue); g_value_dup_boxed(value: *const GValue) -> gpointer1724 pub fn g_value_dup_boxed(value: *const GValue) -> gpointer; g_value_dup_object(value: *const GValue) -> *mut GObject1725 pub fn g_value_dup_object(value: *const GValue) -> *mut GObject; g_value_dup_param(value: *const GValue) -> *mut GParamSpec1726 pub fn g_value_dup_param(value: *const GValue) -> *mut GParamSpec; g_value_dup_string(value: *const GValue) -> *mut c_char1727 pub fn g_value_dup_string(value: *const GValue) -> *mut c_char; g_value_dup_variant(value: *const GValue) -> *mut glib::GVariant1728 pub fn g_value_dup_variant(value: *const GValue) -> *mut glib::GVariant; g_value_fits_pointer(value: *const GValue) -> gboolean1729 pub fn g_value_fits_pointer(value: *const GValue) -> gboolean; g_value_get_boolean(value: *const GValue) -> gboolean1730 pub fn g_value_get_boolean(value: *const GValue) -> gboolean; g_value_get_boxed(value: *const GValue) -> gpointer1731 pub fn g_value_get_boxed(value: *const GValue) -> gpointer; g_value_get_char(value: *const GValue) -> c_char1732 pub fn g_value_get_char(value: *const GValue) -> c_char; g_value_get_double(value: *const GValue) -> c_double1733 pub fn g_value_get_double(value: *const GValue) -> c_double; g_value_get_enum(value: *const GValue) -> c_int1734 pub fn g_value_get_enum(value: *const GValue) -> c_int; g_value_get_flags(value: *const GValue) -> c_uint1735 pub fn g_value_get_flags(value: *const GValue) -> c_uint; g_value_get_float(value: *const GValue) -> c_float1736 pub fn g_value_get_float(value: *const GValue) -> c_float; g_value_get_gtype(value: *const GValue) -> GType1737 pub fn g_value_get_gtype(value: *const GValue) -> GType; g_value_get_int(value: *const GValue) -> c_int1738 pub fn g_value_get_int(value: *const GValue) -> c_int; g_value_get_int64(value: *const GValue) -> i641739 pub fn g_value_get_int64(value: *const GValue) -> i64; g_value_get_long(value: *const GValue) -> c_long1740 pub fn g_value_get_long(value: *const GValue) -> c_long; g_value_get_object(value: *const GValue) -> *mut GObject1741 pub fn g_value_get_object(value: *const GValue) -> *mut GObject; g_value_get_param(value: *const GValue) -> *mut GParamSpec1742 pub fn g_value_get_param(value: *const GValue) -> *mut GParamSpec; g_value_get_pointer(value: *const GValue) -> gpointer1743 pub fn g_value_get_pointer(value: *const GValue) -> gpointer; g_value_get_schar(value: *const GValue) -> i81744 pub fn g_value_get_schar(value: *const GValue) -> i8; g_value_get_string(value: *const GValue) -> *const c_char1745 pub fn g_value_get_string(value: *const GValue) -> *const c_char; g_value_get_uchar(value: *const GValue) -> c_uchar1746 pub fn g_value_get_uchar(value: *const GValue) -> c_uchar; g_value_get_uint(value: *const GValue) -> c_uint1747 pub fn g_value_get_uint(value: *const GValue) -> c_uint; g_value_get_uint64(value: *const GValue) -> u641748 pub fn g_value_get_uint64(value: *const GValue) -> u64; g_value_get_ulong(value: *const GValue) -> c_ulong1749 pub fn g_value_get_ulong(value: *const GValue) -> c_ulong; g_value_get_variant(value: *const GValue) -> *mut glib::GVariant1750 pub fn g_value_get_variant(value: *const GValue) -> *mut glib::GVariant; g_value_init(value: *mut GValue, g_type: GType) -> *mut GValue1751 pub fn g_value_init(value: *mut GValue, g_type: GType) -> *mut GValue; g_value_init_from_instance(value: *mut GValue, instance: gpointer)1752 pub fn g_value_init_from_instance(value: *mut GValue, instance: gpointer); g_value_peek_pointer(value: *const GValue) -> gpointer1753 pub fn g_value_peek_pointer(value: *const GValue) -> gpointer; g_value_reset(value: *mut GValue) -> *mut GValue1754 pub fn g_value_reset(value: *mut GValue) -> *mut GValue; g_value_set_boolean(value: *mut GValue, v_boolean: gboolean)1755 pub fn g_value_set_boolean(value: *mut GValue, v_boolean: gboolean); g_value_set_boxed(value: *mut GValue, v_boxed: gconstpointer)1756 pub fn g_value_set_boxed(value: *mut GValue, v_boxed: gconstpointer); g_value_set_boxed_take_ownership(value: *mut GValue, v_boxed: gconstpointer)1757 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)1758 pub fn g_value_set_char(value: *mut GValue, v_char: c_char); g_value_set_double(value: *mut GValue, v_double: c_double)1759 pub fn g_value_set_double(value: *mut GValue, v_double: c_double); g_value_set_enum(value: *mut GValue, v_enum: c_int)1760 pub fn g_value_set_enum(value: *mut GValue, v_enum: c_int); g_value_set_flags(value: *mut GValue, v_flags: c_uint)1761 pub fn g_value_set_flags(value: *mut GValue, v_flags: c_uint); g_value_set_float(value: *mut GValue, v_float: c_float)1762 pub fn g_value_set_float(value: *mut GValue, v_float: c_float); g_value_set_gtype(value: *mut GValue, v_gtype: GType)1763 pub fn g_value_set_gtype(value: *mut GValue, v_gtype: GType); g_value_set_instance(value: *mut GValue, instance: gpointer)1764 pub fn g_value_set_instance(value: *mut GValue, instance: gpointer); g_value_set_int(value: *mut GValue, v_int: c_int)1765 pub fn g_value_set_int(value: *mut GValue, v_int: c_int); g_value_set_int64(value: *mut GValue, v_int64: i64)1766 pub fn g_value_set_int64(value: *mut GValue, v_int64: i64); g_value_set_long(value: *mut GValue, v_long: c_long)1767 pub fn g_value_set_long(value: *mut GValue, v_long: c_long); g_value_set_object(value: *mut GValue, v_object: *mut GObject)1768 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)1769 pub fn g_value_set_object_take_ownership(value: *mut GValue, v_object: gpointer); g_value_set_param(value: *mut GValue, param: *mut GParamSpec)1770 pub fn g_value_set_param(value: *mut GValue, param: *mut GParamSpec); g_value_set_param_take_ownership(value: *mut GValue, param: *mut GParamSpec)1771 pub fn g_value_set_param_take_ownership(value: *mut GValue, param: *mut GParamSpec); g_value_set_pointer(value: *mut GValue, v_pointer: gpointer)1772 pub fn g_value_set_pointer(value: *mut GValue, v_pointer: gpointer); g_value_set_schar(value: *mut GValue, v_char: i8)1773 pub fn g_value_set_schar(value: *mut GValue, v_char: i8); g_value_set_static_boxed(value: *mut GValue, v_boxed: gconstpointer)1774 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)1775 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)1776 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)1777 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)1778 pub fn g_value_set_uchar(value: *mut GValue, v_uchar: c_uchar); g_value_set_uint(value: *mut GValue, v_uint: c_uint)1779 pub fn g_value_set_uint(value: *mut GValue, v_uint: c_uint); g_value_set_uint64(value: *mut GValue, v_uint64: u64)1780 pub fn g_value_set_uint64(value: *mut GValue, v_uint64: u64); g_value_set_ulong(value: *mut GValue, v_ulong: c_ulong)1781 pub fn g_value_set_ulong(value: *mut GValue, v_ulong: c_ulong); g_value_set_variant(value: *mut GValue, variant: *mut glib::GVariant)1782 pub fn g_value_set_variant(value: *mut GValue, variant: *mut glib::GVariant); g_value_take_boxed(value: *mut GValue, v_boxed: gconstpointer)1783 pub fn g_value_take_boxed(value: *mut GValue, v_boxed: gconstpointer); g_value_take_object(value: *mut GValue, v_object: gpointer)1784 pub fn g_value_take_object(value: *mut GValue, v_object: gpointer); g_value_take_param(value: *mut GValue, param: *mut GParamSpec)1785 pub fn g_value_take_param(value: *mut GValue, param: *mut GParamSpec); g_value_take_string(value: *mut GValue, v_string: *mut c_char)1786 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)1787 pub fn g_value_take_variant(value: *mut GValue, variant: *mut glib::GVariant); g_value_transform(src_value: *const GValue, dest_value: *mut GValue) -> gboolean1788 pub fn g_value_transform(src_value: *const GValue, dest_value: *mut GValue) -> gboolean; g_value_unset(value: *mut GValue)1789 pub fn g_value_unset(value: *mut GValue); g_value_register_transform_func( src_type: GType, dest_type: GType, transform_func: GValueTransform, )1790 pub fn g_value_register_transform_func( 1791 src_type: GType, 1792 dest_type: GType, 1793 transform_func: GValueTransform, 1794 ); g_value_type_compatible(src_type: GType, dest_type: GType) -> gboolean1795 pub fn g_value_type_compatible(src_type: GType, dest_type: GType) -> gboolean; g_value_type_transformable(src_type: GType, dest_type: GType) -> gboolean1796 pub fn g_value_type_transformable(src_type: GType, dest_type: GType) -> gboolean; 1797 1798 //========================================================================= 1799 // GValueArray 1800 //========================================================================= g_value_array_get_type() -> GType1801 pub fn g_value_array_get_type() -> GType; g_value_array_new(n_prealloced: c_uint) -> *mut GValueArray1802 pub fn g_value_array_new(n_prealloced: c_uint) -> *mut GValueArray; g_value_array_append( value_array: *mut GValueArray, value: *const GValue, ) -> *mut GValueArray1803 pub fn g_value_array_append( 1804 value_array: *mut GValueArray, 1805 value: *const GValue, 1806 ) -> *mut GValueArray; g_value_array_copy(value_array: *const GValueArray) -> *mut GValueArray1807 pub fn g_value_array_copy(value_array: *const GValueArray) -> *mut GValueArray; g_value_array_free(value_array: *mut GValueArray)1808 pub fn g_value_array_free(value_array: *mut GValueArray); g_value_array_get_nth(value_array: *mut GValueArray, index_: c_uint) -> *mut GValue1809 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 GValueArray1810 pub fn g_value_array_insert( 1811 value_array: *mut GValueArray, 1812 index_: c_uint, 1813 value: *const GValue, 1814 ) -> *mut GValueArray; g_value_array_prepend( value_array: *mut GValueArray, value: *const GValue, ) -> *mut GValueArray1815 pub fn g_value_array_prepend( 1816 value_array: *mut GValueArray, 1817 value: *const GValue, 1818 ) -> *mut GValueArray; g_value_array_remove(value_array: *mut GValueArray, index_: c_uint) -> *mut GValueArray1819 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 GValueArray1820 pub fn g_value_array_sort( 1821 value_array: *mut GValueArray, 1822 compare_func: glib::GCompareFunc, 1823 ) -> *mut GValueArray; g_value_array_sort_with_data( value_array: *mut GValueArray, compare_func: glib::GCompareDataFunc, user_data: gpointer, ) -> *mut GValueArray1824 pub fn g_value_array_sort_with_data( 1825 value_array: *mut GValueArray, 1826 compare_func: glib::GCompareDataFunc, 1827 user_data: gpointer, 1828 ) -> *mut GValueArray; 1829 1830 //========================================================================= 1831 // GWeakRef 1832 //========================================================================= g_weak_ref_clear(weak_ref: *mut GWeakRef)1833 pub fn g_weak_ref_clear(weak_ref: *mut GWeakRef); g_weak_ref_get(weak_ref: *mut GWeakRef) -> *mut GObject1834 pub fn g_weak_ref_get(weak_ref: *mut GWeakRef) -> *mut GObject; g_weak_ref_init(weak_ref: *mut GWeakRef, object: *mut GObject)1835 pub fn g_weak_ref_init(weak_ref: *mut GWeakRef, object: *mut GObject); g_weak_ref_set(weak_ref: *mut GWeakRef, object: *mut GObject)1836 pub fn g_weak_ref_set(weak_ref: *mut GWeakRef, object: *mut GObject); 1837 1838 //========================================================================= 1839 // GBinding 1840 //========================================================================= g_binding_get_type() -> GType1841 pub fn g_binding_get_type() -> GType; g_binding_get_flags(binding: *mut GBinding) -> GBindingFlags1842 pub fn g_binding_get_flags(binding: *mut GBinding) -> GBindingFlags; g_binding_get_source(binding: *mut GBinding) -> *mut GObject1843 pub fn g_binding_get_source(binding: *mut GBinding) -> *mut GObject; g_binding_get_source_property(binding: *mut GBinding) -> *const c_char1844 pub fn g_binding_get_source_property(binding: *mut GBinding) -> *const c_char; g_binding_get_target(binding: *mut GBinding) -> *mut GObject1845 pub fn g_binding_get_target(binding: *mut GBinding) -> *mut GObject; g_binding_get_target_property(binding: *mut GBinding) -> *const c_char1846 pub fn g_binding_get_target_property(binding: *mut GBinding) -> *const c_char; g_binding_unbind(binding: *mut GBinding)1847 pub fn g_binding_unbind(binding: *mut GBinding); 1848 1849 //========================================================================= 1850 // GInitiallyUnowned 1851 //========================================================================= g_initially_unowned_get_type() -> GType1852 pub fn g_initially_unowned_get_type() -> GType; 1853 1854 //========================================================================= 1855 // GObject 1856 //========================================================================= g_object_get_type() -> GType1857 pub fn g_object_get_type() -> GType; g_object_new( object_type: GType, first_property_name: *const c_char, ... ) -> *mut GObject1858 pub fn g_object_new( 1859 object_type: GType, 1860 first_property_name: *const c_char, 1861 ... 1862 ) -> *mut GObject; 1863 //pub fn g_object_new_valist(object_type: GType, first_property_name: *const c_char, var_args: /*Unimplemented*/va_list) -> *mut GObject; 1864 #[cfg(any(feature = "v2_54", feature = "dox"))] g_object_new_with_properties( object_type: GType, n_properties: c_uint, names: *mut *const c_char, values: *const GValue, ) -> *mut GObject1865 pub fn g_object_new_with_properties( 1866 object_type: GType, 1867 n_properties: c_uint, 1868 names: *mut *const c_char, 1869 values: *const GValue, 1870 ) -> *mut GObject; g_object_newv( object_type: GType, n_parameters: c_uint, parameters: *mut GParameter, ) -> *mut GObject1871 pub fn g_object_newv( 1872 object_type: GType, 1873 n_parameters: c_uint, 1874 parameters: *mut GParameter, 1875 ) -> *mut GObject; g_object_compat_control(what: size_t, data: gpointer) -> size_t1876 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 GParamSpec1877 pub fn g_object_interface_find_property( 1878 g_iface: gpointer, 1879 property_name: *const c_char, 1880 ) -> *mut GParamSpec; g_object_interface_install_property(g_iface: gpointer, pspec: *mut GParamSpec)1881 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 GParamSpec1882 pub fn g_object_interface_list_properties( 1883 g_iface: gpointer, 1884 n_properties_p: *mut c_uint, 1885 ) -> *mut *mut GParamSpec; g_object_add_toggle_ref(object: *mut GObject, notify: GToggleNotify, data: gpointer)1886 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)1887 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 GBinding1888 pub fn g_object_bind_property( 1889 source: *mut GObject, 1890 source_property: *const c_char, 1891 target: *mut GObject, 1892 target_property: *const c_char, 1893 flags: GBindingFlags, 1894 ) -> *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 GBinding1895 pub fn g_object_bind_property_full( 1896 source: *mut GObject, 1897 source_property: *const c_char, 1898 target: *mut GObject, 1899 target_property: *const c_char, 1900 flags: GBindingFlags, 1901 transform_to: GBindingTransformFunc, 1902 transform_from: GBindingTransformFunc, 1903 user_data: gpointer, 1904 notify: glib::GDestroyNotify, 1905 ) -> *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 GBinding1906 pub fn g_object_bind_property_with_closures( 1907 source: *mut GObject, 1908 source_property: *const c_char, 1909 target: *mut GObject, 1910 target_property: *const c_char, 1911 flags: GBindingFlags, 1912 transform_to: *mut GClosure, 1913 transform_from: *mut GClosure, 1914 ) -> *mut GBinding; g_object_connect(object: *mut GObject, signal_spec: *const c_char, ...) -> *mut GObject1915 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, ...)1916 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, ) -> gpointer1917 pub fn g_object_dup_data( 1918 object: *mut GObject, 1919 key: *const c_char, 1920 dup_func: glib::GDuplicateFunc, 1921 user_data: gpointer, 1922 ) -> gpointer; g_object_dup_qdata( object: *mut GObject, quark: glib::GQuark, dup_func: glib::GDuplicateFunc, user_data: gpointer, ) -> gpointer1923 pub fn g_object_dup_qdata( 1924 object: *mut GObject, 1925 quark: glib::GQuark, 1926 dup_func: glib::GDuplicateFunc, 1927 user_data: gpointer, 1928 ) -> gpointer; g_object_force_floating(object: *mut GObject)1929 pub fn g_object_force_floating(object: *mut GObject); g_object_freeze_notify(object: *mut GObject)1930 pub fn g_object_freeze_notify(object: *mut GObject); g_object_get(object: *mut GObject, first_property_name: *const c_char, ...)1931 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) -> gpointer1932 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, )1933 pub fn g_object_get_property( 1934 object: *mut GObject, 1935 property_name: *const c_char, 1936 value: *mut GValue, 1937 ); g_object_get_qdata(object: *mut GObject, quark: glib::GQuark) -> gpointer1938 pub fn g_object_get_qdata(object: *mut GObject, quark: glib::GQuark) -> gpointer; 1939 //pub fn g_object_get_valist(object: *mut GObject, first_property_name: *const c_char, var_args: /*Unimplemented*/va_list); 1940 #[cfg(any(feature = "v2_54", feature = "dox"))] g_object_getv( object: *mut GObject, n_properties: c_uint, names: *mut *const c_char, values: *mut GValue, )1941 pub fn g_object_getv( 1942 object: *mut GObject, 1943 n_properties: c_uint, 1944 names: *mut *const c_char, 1945 values: *mut GValue, 1946 ); g_object_is_floating(object: *mut GObject) -> gboolean1947 pub fn g_object_is_floating(object: *mut GObject) -> gboolean; g_object_notify(object: *mut GObject, property_name: *const c_char)1948 pub fn g_object_notify(object: *mut GObject, property_name: *const c_char); g_object_notify_by_pspec(object: *mut GObject, pspec: *mut GParamSpec)1949 pub fn g_object_notify_by_pspec(object: *mut GObject, pspec: *mut GParamSpec); g_object_ref(object: *mut GObject) -> *mut GObject1950 pub fn g_object_ref(object: *mut GObject) -> *mut GObject; g_object_ref_sink(object: *mut GObject) -> *mut GObject1951 pub fn g_object_ref_sink(object: *mut GObject) -> *mut GObject; g_object_remove_toggle_ref(object: *mut GObject, notify: GToggleNotify, data: gpointer)1952 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)1953 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, ) -> gboolean1954 pub fn g_object_replace_data( 1955 object: *mut GObject, 1956 key: *const c_char, 1957 oldval: gpointer, 1958 newval: gpointer, 1959 destroy: glib::GDestroyNotify, 1960 old_destroy: *mut glib::GDestroyNotify, 1961 ) -> gboolean; g_object_replace_qdata( object: *mut GObject, quark: glib::GQuark, oldval: gpointer, newval: gpointer, destroy: glib::GDestroyNotify, old_destroy: *mut glib::GDestroyNotify, ) -> gboolean1962 pub fn g_object_replace_qdata( 1963 object: *mut GObject, 1964 quark: glib::GQuark, 1965 oldval: gpointer, 1966 newval: gpointer, 1967 destroy: glib::GDestroyNotify, 1968 old_destroy: *mut glib::GDestroyNotify, 1969 ) -> gboolean; g_object_run_dispose(object: *mut GObject)1970 pub fn g_object_run_dispose(object: *mut GObject); g_object_set(object: *mut GObject, first_property_name: *const c_char, ...)1971 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)1972 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, )1973 pub fn g_object_set_data_full( 1974 object: *mut GObject, 1975 key: *const c_char, 1976 data: gpointer, 1977 destroy: glib::GDestroyNotify, 1978 ); g_object_set_property( object: *mut GObject, property_name: *const c_char, value: *const GValue, )1979 pub fn g_object_set_property( 1980 object: *mut GObject, 1981 property_name: *const c_char, 1982 value: *const GValue, 1983 ); g_object_set_qdata(object: *mut GObject, quark: glib::GQuark, data: gpointer)1984 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, )1985 pub fn g_object_set_qdata_full( 1986 object: *mut GObject, 1987 quark: glib::GQuark, 1988 data: gpointer, 1989 destroy: glib::GDestroyNotify, 1990 ); 1991 //pub fn g_object_set_valist(object: *mut GObject, first_property_name: *const c_char, var_args: /*Unimplemented*/va_list); 1992 #[cfg(any(feature = "v2_54", feature = "dox"))] g_object_setv( object: *mut GObject, n_properties: c_uint, names: *mut *const c_char, values: *const GValue, )1993 pub fn g_object_setv( 1994 object: *mut GObject, 1995 n_properties: c_uint, 1996 names: *mut *const c_char, 1997 values: *const GValue, 1998 ); g_object_steal_data(object: *mut GObject, key: *const c_char) -> gpointer1999 pub fn g_object_steal_data(object: *mut GObject, key: *const c_char) -> gpointer; g_object_steal_qdata(object: *mut GObject, quark: glib::GQuark) -> gpointer2000 pub fn g_object_steal_qdata(object: *mut GObject, quark: glib::GQuark) -> gpointer; g_object_thaw_notify(object: *mut GObject)2001 pub fn g_object_thaw_notify(object: *mut GObject); g_object_unref(object: *mut GObject)2002 pub fn g_object_unref(object: *mut GObject); g_object_watch_closure(object: *mut GObject, closure: *mut GClosure)2003 pub fn g_object_watch_closure(object: *mut GObject, closure: *mut GClosure); g_object_weak_ref(object: *mut GObject, notify: GWeakNotify, data: gpointer)2004 pub fn g_object_weak_ref(object: *mut GObject, notify: GWeakNotify, data: gpointer); g_object_weak_unref(object: *mut GObject, notify: GWeakNotify, data: gpointer)2005 pub fn g_object_weak_unref(object: *mut GObject, notify: GWeakNotify, data: gpointer); 2006 2007 //========================================================================= 2008 // GParamSpec 2009 //========================================================================= g_param_spec_internal( param_type: GType, name: *const c_char, nick: *const c_char, blurb: *const c_char, flags: GParamFlags, ) -> *mut GParamSpec2010 pub fn g_param_spec_internal( 2011 param_type: GType, 2012 name: *const c_char, 2013 nick: *const c_char, 2014 blurb: *const c_char, 2015 flags: GParamFlags, 2016 ) -> *mut GParamSpec; g_param_spec_get_blurb(pspec: *mut GParamSpec) -> *const c_char2017 pub fn g_param_spec_get_blurb(pspec: *mut GParamSpec) -> *const c_char; g_param_spec_get_default_value(pspec: *mut GParamSpec) -> *const GValue2018 pub fn g_param_spec_get_default_value(pspec: *mut GParamSpec) -> *const GValue; g_param_spec_get_name(pspec: *mut GParamSpec) -> *const c_char2019 pub fn g_param_spec_get_name(pspec: *mut GParamSpec) -> *const c_char; 2020 #[cfg(any(feature = "v2_46", feature = "dox"))] g_param_spec_get_name_quark(pspec: *mut GParamSpec) -> glib::GQuark2021 pub fn g_param_spec_get_name_quark(pspec: *mut GParamSpec) -> glib::GQuark; g_param_spec_get_nick(pspec: *mut GParamSpec) -> *const c_char2022 pub fn g_param_spec_get_nick(pspec: *mut GParamSpec) -> *const c_char; g_param_spec_get_qdata(pspec: *mut GParamSpec, quark: glib::GQuark) -> gpointer2023 pub fn g_param_spec_get_qdata(pspec: *mut GParamSpec, quark: glib::GQuark) -> gpointer; g_param_spec_get_redirect_target(pspec: *mut GParamSpec) -> *mut GParamSpec2024 pub fn g_param_spec_get_redirect_target(pspec: *mut GParamSpec) -> *mut GParamSpec; g_param_spec_ref(pspec: *mut GParamSpec) -> *mut GParamSpec2025 pub fn g_param_spec_ref(pspec: *mut GParamSpec) -> *mut GParamSpec; g_param_spec_ref_sink(pspec: *mut GParamSpec) -> *mut GParamSpec2026 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)2027 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, )2028 pub fn g_param_spec_set_qdata_full( 2029 pspec: *mut GParamSpec, 2030 quark: glib::GQuark, 2031 data: gpointer, 2032 destroy: glib::GDestroyNotify, 2033 ); g_param_spec_sink(pspec: *mut GParamSpec)2034 pub fn g_param_spec_sink(pspec: *mut GParamSpec); g_param_spec_steal_qdata(pspec: *mut GParamSpec, quark: glib::GQuark) -> gpointer2035 pub fn g_param_spec_steal_qdata(pspec: *mut GParamSpec, quark: glib::GQuark) -> gpointer; g_param_spec_unref(pspec: *mut GParamSpec)2036 pub fn g_param_spec_unref(pspec: *mut GParamSpec); 2037 2038 //========================================================================= 2039 // GTypeModule 2040 //========================================================================= g_type_module_get_type() -> GType2041 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, )2042 pub fn g_type_module_add_interface( 2043 module: *mut GTypeModule, 2044 instance_type: GType, 2045 interface_type: GType, 2046 interface_info: *const GInterfaceInfo, 2047 ); g_type_module_register_enum( module: *mut GTypeModule, name: *const c_char, const_static_values: *const GEnumValue, ) -> GType2048 pub fn g_type_module_register_enum( 2049 module: *mut GTypeModule, 2050 name: *const c_char, 2051 const_static_values: *const GEnumValue, 2052 ) -> GType; g_type_module_register_flags( module: *mut GTypeModule, name: *const c_char, const_static_values: *const GFlagsValue, ) -> GType2053 pub fn g_type_module_register_flags( 2054 module: *mut GTypeModule, 2055 name: *const c_char, 2056 const_static_values: *const GFlagsValue, 2057 ) -> GType; g_type_module_register_type( module: *mut GTypeModule, parent_type: GType, type_name: *const c_char, type_info: *const GTypeInfo, flags: GTypeFlags, ) -> GType2058 pub fn g_type_module_register_type( 2059 module: *mut GTypeModule, 2060 parent_type: GType, 2061 type_name: *const c_char, 2062 type_info: *const GTypeInfo, 2063 flags: GTypeFlags, 2064 ) -> GType; g_type_module_set_name(module: *mut GTypeModule, name: *const c_char)2065 pub fn g_type_module_set_name(module: *mut GTypeModule, name: *const c_char); g_type_module_unuse(module: *mut GTypeModule)2066 pub fn g_type_module_unuse(module: *mut GTypeModule); g_type_module_use(module: *mut GTypeModule) -> gboolean2067 pub fn g_type_module_use(module: *mut GTypeModule) -> gboolean; 2068 2069 //========================================================================= 2070 // GTypePlugin 2071 //========================================================================= g_type_plugin_get_type() -> GType2072 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, )2073 pub fn g_type_plugin_complete_interface_info( 2074 plugin: *mut GTypePlugin, 2075 instance_type: GType, 2076 interface_type: GType, 2077 info: *mut GInterfaceInfo, 2078 ); g_type_plugin_complete_type_info( plugin: *mut GTypePlugin, g_type: GType, info: *mut GTypeInfo, value_table: *mut GTypeValueTable, )2079 pub fn g_type_plugin_complete_type_info( 2080 plugin: *mut GTypePlugin, 2081 g_type: GType, 2082 info: *mut GTypeInfo, 2083 value_table: *mut GTypeValueTable, 2084 ); g_type_plugin_unuse(plugin: *mut GTypePlugin)2085 pub fn g_type_plugin_unuse(plugin: *mut GTypePlugin); g_type_plugin_use(plugin: *mut GTypePlugin)2086 pub fn g_type_plugin_use(plugin: *mut GTypePlugin); 2087 2088 //========================================================================= 2089 // Other functions 2090 //========================================================================= g_boxed_copy(boxed_type: GType, src_boxed: gconstpointer) -> gpointer2091 pub fn g_boxed_copy(boxed_type: GType, src_boxed: gconstpointer) -> gpointer; g_boxed_free(boxed_type: GType, boxed: gpointer)2092 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, ) -> GType2093 pub fn g_boxed_type_register_static( 2094 name: *const c_char, 2095 boxed_copy: GBoxedCopyFunc, 2096 boxed_free: GBoxedFreeFunc, 2097 ) -> GType; g_clear_object(object_ptr: *mut *mut GObject)2098 pub fn g_clear_object(object_ptr: *mut *mut GObject); 2099 #[cfg(any(feature = "v2_62", feature = "dox"))] g_clear_signal_handler(handler_id_ptr: *mut c_ulong, instance: *mut GObject)2100 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, )2101 pub fn g_enum_complete_type_info( 2102 g_enum_type: GType, 2103 info: *mut GTypeInfo, 2104 const_values: *const GEnumValue, 2105 ); g_enum_get_value(enum_class: *mut GEnumClass, value: c_int) -> *mut GEnumValue2106 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 GEnumValue2107 pub fn g_enum_get_value_by_name( 2108 enum_class: *mut GEnumClass, 2109 name: *const c_char, 2110 ) -> *mut GEnumValue; g_enum_get_value_by_nick( enum_class: *mut GEnumClass, nick: *const c_char, ) -> *mut GEnumValue2111 pub fn g_enum_get_value_by_nick( 2112 enum_class: *mut GEnumClass, 2113 nick: *const c_char, 2114 ) -> *mut GEnumValue; g_enum_register_static( name: *const c_char, const_static_values: *const GEnumValue, ) -> GType2115 pub fn g_enum_register_static( 2116 name: *const c_char, 2117 const_static_values: *const GEnumValue, 2118 ) -> GType; 2119 #[cfg(any(feature = "v2_54", feature = "dox"))] g_enum_to_string(g_enum_type: GType, value: c_int) -> *mut c_char2120 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, )2121 pub fn g_flags_complete_type_info( 2122 g_flags_type: GType, 2123 info: *mut GTypeInfo, 2124 const_values: *const GFlagsValue, 2125 ); g_flags_get_first_value( flags_class: *mut GFlagsClass, value: c_uint, ) -> *mut GFlagsValue2126 pub fn g_flags_get_first_value( 2127 flags_class: *mut GFlagsClass, 2128 value: c_uint, 2129 ) -> *mut GFlagsValue; g_flags_get_value_by_name( flags_class: *mut GFlagsClass, name: *const c_char, ) -> *mut GFlagsValue2130 pub fn g_flags_get_value_by_name( 2131 flags_class: *mut GFlagsClass, 2132 name: *const c_char, 2133 ) -> *mut GFlagsValue; g_flags_get_value_by_nick( flags_class: *mut GFlagsClass, nick: *const c_char, ) -> *mut GFlagsValue2134 pub fn g_flags_get_value_by_nick( 2135 flags_class: *mut GFlagsClass, 2136 nick: *const c_char, 2137 ) -> *mut GFlagsValue; g_flags_register_static( name: *const c_char, const_static_values: *const GFlagsValue, ) -> GType2138 pub fn g_flags_register_static( 2139 name: *const c_char, 2140 const_static_values: *const GFlagsValue, 2141 ) -> GType; 2142 #[cfg(any(feature = "v2_54", feature = "dox"))] g_flags_to_string(flags_type: GType, value: c_uint) -> *mut c_char2143 pub fn g_flags_to_string(flags_type: GType, value: c_uint) -> *mut c_char; g_gtype_get_type() -> GType2144 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 GParamSpec2145 pub fn g_param_spec_boolean( 2146 name: *const c_char, 2147 nick: *const c_char, 2148 blurb: *const c_char, 2149 default_value: gboolean, 2150 flags: GParamFlags, 2151 ) -> *mut GParamSpec; g_param_spec_boxed( name: *const c_char, nick: *const c_char, blurb: *const c_char, boxed_type: GType, flags: GParamFlags, ) -> *mut GParamSpec2152 pub fn g_param_spec_boxed( 2153 name: *const c_char, 2154 nick: *const c_char, 2155 blurb: *const c_char, 2156 boxed_type: GType, 2157 flags: GParamFlags, 2158 ) -> *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 GParamSpec2159 pub fn g_param_spec_char( 2160 name: *const c_char, 2161 nick: *const c_char, 2162 blurb: *const c_char, 2163 minimum: i8, 2164 maximum: i8, 2165 default_value: i8, 2166 flags: GParamFlags, 2167 ) -> *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 GParamSpec2168 pub fn g_param_spec_double( 2169 name: *const c_char, 2170 nick: *const c_char, 2171 blurb: *const c_char, 2172 minimum: c_double, 2173 maximum: c_double, 2174 default_value: c_double, 2175 flags: GParamFlags, 2176 ) -> *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 GParamSpec2177 pub fn g_param_spec_enum( 2178 name: *const c_char, 2179 nick: *const c_char, 2180 blurb: *const c_char, 2181 enum_type: GType, 2182 default_value: c_int, 2183 flags: GParamFlags, 2184 ) -> *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 GParamSpec2185 pub fn g_param_spec_flags( 2186 name: *const c_char, 2187 nick: *const c_char, 2188 blurb: *const c_char, 2189 flags_type: GType, 2190 default_value: c_uint, 2191 flags: GParamFlags, 2192 ) -> *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 GParamSpec2193 pub fn g_param_spec_float( 2194 name: *const c_char, 2195 nick: *const c_char, 2196 blurb: *const c_char, 2197 minimum: c_float, 2198 maximum: c_float, 2199 default_value: c_float, 2200 flags: GParamFlags, 2201 ) -> *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 GParamSpec2202 pub fn g_param_spec_gtype( 2203 name: *const c_char, 2204 nick: *const c_char, 2205 blurb: *const c_char, 2206 is_a_type: GType, 2207 flags: GParamFlags, 2208 ) -> *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 GParamSpec2209 pub fn g_param_spec_int( 2210 name: *const c_char, 2211 nick: *const c_char, 2212 blurb: *const c_char, 2213 minimum: c_int, 2214 maximum: c_int, 2215 default_value: c_int, 2216 flags: GParamFlags, 2217 ) -> *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 GParamSpec2218 pub fn g_param_spec_int64( 2219 name: *const c_char, 2220 nick: *const c_char, 2221 blurb: *const c_char, 2222 minimum: i64, 2223 maximum: i64, 2224 default_value: i64, 2225 flags: GParamFlags, 2226 ) -> *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 GParamSpec2227 pub fn g_param_spec_long( 2228 name: *const c_char, 2229 nick: *const c_char, 2230 blurb: *const c_char, 2231 minimum: c_long, 2232 maximum: c_long, 2233 default_value: c_long, 2234 flags: GParamFlags, 2235 ) -> *mut GParamSpec; g_param_spec_object( name: *const c_char, nick: *const c_char, blurb: *const c_char, object_type: GType, flags: GParamFlags, ) -> *mut GParamSpec2236 pub fn g_param_spec_object( 2237 name: *const c_char, 2238 nick: *const c_char, 2239 blurb: *const c_char, 2240 object_type: GType, 2241 flags: GParamFlags, 2242 ) -> *mut GParamSpec; g_param_spec_override( name: *const c_char, overridden: *mut GParamSpec, ) -> *mut GParamSpec2243 pub fn g_param_spec_override( 2244 name: *const c_char, 2245 overridden: *mut GParamSpec, 2246 ) -> *mut GParamSpec; g_param_spec_param( name: *const c_char, nick: *const c_char, blurb: *const c_char, param_type: GType, flags: GParamFlags, ) -> *mut GParamSpec2247 pub fn g_param_spec_param( 2248 name: *const c_char, 2249 nick: *const c_char, 2250 blurb: *const c_char, 2251 param_type: GType, 2252 flags: GParamFlags, 2253 ) -> *mut GParamSpec; g_param_spec_pointer( name: *const c_char, nick: *const c_char, blurb: *const c_char, flags: GParamFlags, ) -> *mut GParamSpec2254 pub fn g_param_spec_pointer( 2255 name: *const c_char, 2256 nick: *const c_char, 2257 blurb: *const c_char, 2258 flags: GParamFlags, 2259 ) -> *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 GParamSpec2260 pub fn g_param_spec_string( 2261 name: *const c_char, 2262 nick: *const c_char, 2263 blurb: *const c_char, 2264 default_value: *const c_char, 2265 flags: GParamFlags, 2266 ) -> *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 GParamSpec2267 pub fn g_param_spec_uchar( 2268 name: *const c_char, 2269 nick: *const c_char, 2270 blurb: *const c_char, 2271 minimum: u8, 2272 maximum: u8, 2273 default_value: u8, 2274 flags: GParamFlags, 2275 ) -> *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 GParamSpec2276 pub fn g_param_spec_uint( 2277 name: *const c_char, 2278 nick: *const c_char, 2279 blurb: *const c_char, 2280 minimum: c_uint, 2281 maximum: c_uint, 2282 default_value: c_uint, 2283 flags: GParamFlags, 2284 ) -> *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 GParamSpec2285 pub fn g_param_spec_uint64( 2286 name: *const c_char, 2287 nick: *const c_char, 2288 blurb: *const c_char, 2289 minimum: u64, 2290 maximum: u64, 2291 default_value: u64, 2292 flags: GParamFlags, 2293 ) -> *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 GParamSpec2294 pub fn g_param_spec_ulong( 2295 name: *const c_char, 2296 nick: *const c_char, 2297 blurb: *const c_char, 2298 minimum: c_ulong, 2299 maximum: c_ulong, 2300 default_value: c_ulong, 2301 flags: GParamFlags, 2302 ) -> *mut GParamSpec; g_param_spec_unichar( name: *const c_char, nick: *const c_char, blurb: *const c_char, default_value: u32, flags: GParamFlags, ) -> *mut GParamSpec2303 pub fn g_param_spec_unichar( 2304 name: *const c_char, 2305 nick: *const c_char, 2306 blurb: *const c_char, 2307 default_value: u32, 2308 flags: GParamFlags, 2309 ) -> *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 GParamSpec2310 pub fn g_param_spec_value_array( 2311 name: *const c_char, 2312 nick: *const c_char, 2313 blurb: *const c_char, 2314 element_spec: *mut GParamSpec, 2315 flags: GParamFlags, 2316 ) -> *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 GParamSpec2317 pub fn g_param_spec_variant( 2318 name: *const c_char, 2319 nick: *const c_char, 2320 blurb: *const c_char, 2321 type_: *const glib::GVariantType, 2322 default_value: *mut glib::GVariant, 2323 flags: GParamFlags, 2324 ) -> *mut GParamSpec; g_param_type_register_static( name: *const c_char, pspec_info: *const GParamSpecTypeInfo, ) -> GType2325 pub fn g_param_type_register_static( 2326 name: *const c_char, 2327 pspec_info: *const GParamSpecTypeInfo, 2328 ) -> GType; g_param_value_convert( pspec: *mut GParamSpec, src_value: *const GValue, dest_value: *mut GValue, strict_validation: gboolean, ) -> gboolean2329 pub fn g_param_value_convert( 2330 pspec: *mut GParamSpec, 2331 src_value: *const GValue, 2332 dest_value: *mut GValue, 2333 strict_validation: gboolean, 2334 ) -> gboolean; g_param_value_defaults(pspec: *mut GParamSpec, value: *mut GValue) -> gboolean2335 pub fn g_param_value_defaults(pspec: *mut GParamSpec, value: *mut GValue) -> gboolean; g_param_value_set_default(pspec: *mut GParamSpec, value: *mut GValue)2336 pub fn g_param_value_set_default(pspec: *mut GParamSpec, value: *mut GValue); g_param_value_validate(pspec: *mut GParamSpec, value: *mut GValue) -> gboolean2337 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_int2338 pub fn g_param_values_cmp( 2339 pspec: *mut GParamSpec, 2340 value1: *const GValue, 2341 value2: *const GValue, 2342 ) -> c_int; g_pointer_type_register_static(name: *const c_char) -> GType2343 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, ) -> gboolean2344 pub fn g_signal_accumulator_first_wins( 2345 ihint: *mut GSignalInvocationHint, 2346 return_accu: *mut GValue, 2347 handler_return: *const GValue, 2348 dummy: gpointer, 2349 ) -> gboolean; g_signal_accumulator_true_handled( ihint: *mut GSignalInvocationHint, return_accu: *mut GValue, handler_return: *const GValue, dummy: gpointer, ) -> gboolean2350 pub fn g_signal_accumulator_true_handled( 2351 ihint: *mut GSignalInvocationHint, 2352 return_accu: *mut GValue, 2353 handler_return: *const GValue, 2354 dummy: gpointer, 2355 ) -> gboolean; g_signal_add_emission_hook( signal_id: c_uint, detail: glib::GQuark, hook_func: GSignalEmissionHook, hook_data: gpointer, data_destroy: glib::GDestroyNotify, ) -> c_ulong2356 pub fn g_signal_add_emission_hook( 2357 signal_id: c_uint, 2358 detail: glib::GQuark, 2359 hook_func: GSignalEmissionHook, 2360 hook_data: gpointer, 2361 data_destroy: glib::GDestroyNotify, 2362 ) -> c_ulong; g_signal_chain_from_overridden( instance_and_params: *const GValue, return_value: *mut GValue, )2363 pub fn g_signal_chain_from_overridden( 2364 instance_and_params: *const GValue, 2365 return_value: *mut GValue, 2366 ); g_signal_chain_from_overridden_handler(instance: gpointer, ...)2367 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_ulong2368 pub fn g_signal_connect_closure( 2369 instance: *mut GObject, 2370 detailed_signal: *const c_char, 2371 closure: *mut GClosure, 2372 after: gboolean, 2373 ) -> c_ulong; g_signal_connect_closure_by_id( instance: *mut GObject, signal_id: c_uint, detail: glib::GQuark, closure: *mut GClosure, after: gboolean, ) -> c_ulong2374