#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]

use gtk_sys::{
    GtkContainer, GtkContainerPrivate, GtkMenu, GtkMenuPrivate, GtkMenuShell, GtkMenuShellPrivate,
    GtkStatusIcon, GtkStatusIconPrivate, GtkWidget, GtkWidgetPrivate,
};

use std::os::raw::*;

pub type guint32 = c_uint;
pub type gint64 = c_long;
pub type guint64 = c_ulong;
pub type gsize = c_ulong;
pub type gchar = c_char;
pub type glong = c_long;
pub type gint = c_int;
pub type gboolean = gint;
pub type gulong = c_ulong;
pub type guint = c_uint;
pub type gfloat = f32;
pub type gdouble = f64;
pub type gpointer = *mut c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GData {
    _unused: [u8; 0],
}
pub type GData = _GData;
pub type GSList = _GSList;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GSList {
    pub data: gpointer,
    pub next: *mut GSList,
}
#[test]
fn bindgen_test_layout__GSList() {
    assert_eq!(
        ::std::mem::size_of::<_GSList>(),
        16usize,
        concat!("Size of: ", stringify!(_GSList))
    );
    assert_eq!(
        ::std::mem::align_of::<_GSList>(),
        8usize,
        concat!("Alignment of ", stringify!(_GSList))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GSList>())).data as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GSList),
            "::",
            stringify!(data)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GSList>())).next as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_GSList),
            "::",
            stringify!(next)
        )
    );
}
pub type GType = gsize;
pub type GValue = _GValue;
pub type GTypeClass = _GTypeClass;
pub type GTypeInstance = _GTypeInstance;
#[doc = " GTypeClass:"]
#[doc = ""]
#[doc = " An opaque structure used as the base of all classes."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GTypeClass {
    pub g_type: GType,
}
#[test]
fn bindgen_test_layout__GTypeClass() {
    assert_eq!(
        ::std::mem::size_of::<_GTypeClass>(),
        8usize,
        concat!("Size of: ", stringify!(_GTypeClass))
    );
    assert_eq!(
        ::std::mem::align_of::<_GTypeClass>(),
        8usize,
        concat!("Alignment of ", stringify!(_GTypeClass))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GTypeClass>())).g_type as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GTypeClass),
            "::",
            stringify!(g_type)
        )
    );
}
#[doc = " GTypeInstance:"]
#[doc = ""]
#[doc = " An opaque structure used as the base of all type instances."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GTypeInstance {
    pub g_class: *mut GTypeClass,
}
#[test]
fn bindgen_test_layout__GTypeInstance() {
    assert_eq!(
        ::std::mem::size_of::<_GTypeInstance>(),
        8usize,
        concat!("Size of: ", stringify!(_GTypeInstance))
    );
    assert_eq!(
        ::std::mem::align_of::<_GTypeInstance>(),
        8usize,
        concat!("Alignment of ", stringify!(_GTypeInstance))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GTypeInstance>())).g_class as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GTypeInstance),
            "::",
            stringify!(g_class)
        )
    );
}
#[doc = " GValue:"]
#[doc = ""]
#[doc = " An opaque structure used to hold different types of values."]
#[doc = " The data within the structure has protected scope: it is accessible only"]
#[doc = " to functions within a #GTypeValueTable structure, or implementations of"]
#[doc = " the g_value_*() API. That is, code portions which implement new fundamental"]
#[doc = " types."]
#[doc = " #GValue users cannot make any assumptions about how data is stored"]
#[doc = " within the 2 element @data union, and the @g_type member should"]
#[doc = " only be accessed through the G_VALUE_TYPE() macro."]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _GValue {
    pub g_type: GType,
    pub data: [_GValue__bindgen_ty_1; 2usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _GValue__bindgen_ty_1 {
    pub v_int: gint,
    pub v_uint: guint,
    pub v_long: glong,
    pub v_ulong: gulong,
    pub v_int64: gint64,
    pub v_uint64: guint64,
    pub v_float: gfloat,
    pub v_double: gdouble,
    pub v_pointer: gpointer,
    _bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout__GValue__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<_GValue__bindgen_ty_1>(),
        8usize,
        concat!("Size of: ", stringify!(_GValue__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<_GValue__bindgen_ty_1>(),
        8usize,
        concat!("Alignment of ", stringify!(_GValue__bindgen_ty_1))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue__bindgen_ty_1>())).v_int as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue__bindgen_ty_1),
            "::",
            stringify!(v_int)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue__bindgen_ty_1>())).v_uint as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue__bindgen_ty_1),
            "::",
            stringify!(v_uint)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue__bindgen_ty_1>())).v_long as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue__bindgen_ty_1),
            "::",
            stringify!(v_long)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue__bindgen_ty_1>())).v_ulong as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue__bindgen_ty_1),
            "::",
            stringify!(v_ulong)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue__bindgen_ty_1>())).v_int64 as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue__bindgen_ty_1),
            "::",
            stringify!(v_int64)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue__bindgen_ty_1>())).v_uint64 as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue__bindgen_ty_1),
            "::",
            stringify!(v_uint64)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue__bindgen_ty_1>())).v_float as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue__bindgen_ty_1),
            "::",
            stringify!(v_float)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue__bindgen_ty_1>())).v_double as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue__bindgen_ty_1),
            "::",
            stringify!(v_double)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue__bindgen_ty_1>())).v_pointer as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue__bindgen_ty_1),
            "::",
            stringify!(v_pointer)
        )
    );
}
#[test]
fn bindgen_test_layout__GValue() {
    assert_eq!(
        ::std::mem::size_of::<_GValue>(),
        24usize,
        concat!("Size of: ", stringify!(_GValue))
    );
    assert_eq!(
        ::std::mem::align_of::<_GValue>(),
        8usize,
        concat!("Alignment of ", stringify!(_GValue))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue>())).g_type as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue),
            "::",
            stringify!(g_type)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GValue>())).data as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_GValue),
            "::",
            stringify!(data)
        )
    );
}
pub const GParamFlags_G_PARAM_READABLE: GParamFlags = 1;
pub const GParamFlags_G_PARAM_WRITABLE: GParamFlags = 2;
pub const GParamFlags_G_PARAM_READWRITE: GParamFlags = 3;
pub const GParamFlags_G_PARAM_CONSTRUCT: GParamFlags = 4;
pub const GParamFlags_G_PARAM_CONSTRUCT_ONLY: GParamFlags = 8;
pub const GParamFlags_G_PARAM_LAX_VALIDATION: GParamFlags = 16;
pub const GParamFlags_G_PARAM_STATIC_NAME: GParamFlags = 32;
pub const GParamFlags_G_PARAM_PRIVATE: GParamFlags = 32;
pub const GParamFlags_G_PARAM_STATIC_NICK: GParamFlags = 64;
pub const GParamFlags_G_PARAM_STATIC_BLURB: GParamFlags = 128;
pub const GParamFlags_G_PARAM_EXPLICIT_NOTIFY: GParamFlags = 1073741824;
pub const GParamFlags_G_PARAM_DEPRECATED: GParamFlags = -2147483648;
#[doc = " GParamFlags:"]
#[doc = " @G_PARAM_READABLE: the parameter is readable"]
#[doc = " @G_PARAM_WRITABLE: the parameter is writable"]
#[doc = " @G_PARAM_READWRITE: alias for %G_PARAM_READABLE | %G_PARAM_WRITABLE"]
#[doc = " @G_PARAM_CONSTRUCT: the parameter will be set upon object construction"]
#[doc = " @G_PARAM_CONSTRUCT_ONLY: the parameter can only be set upon object construction"]
#[doc = " @G_PARAM_LAX_VALIDATION: upon parameter conversion (see g_param_value_convert())"]
#[doc = "  strict validation is not required"]
#[doc = " @G_PARAM_STATIC_NAME: the string used as name when constructing the"]
#[doc = "  parameter is guaranteed to remain valid and"]
#[doc = "  unmodified for the lifetime of the parameter."]
#[doc = "  Since 2.8"]
#[doc = " @G_PARAM_STATIC_NICK: the string used as nick when constructing the"]
#[doc = "  parameter is guaranteed to remain valid and"]
#[doc = "  unmmodified for the lifetime of the parameter."]
#[doc = "  Since 2.8"]
#[doc = " @G_PARAM_STATIC_BLURB: the string used as blurb when constructing the"]
#[doc = "  parameter is guaranteed to remain valid and"]
#[doc = "  unmodified for the lifetime of the parameter."]
#[doc = "  Since 2.8"]
#[doc = " @G_PARAM_EXPLICIT_NOTIFY: calls to g_object_set_property() for this"]
#[doc = "   property will not automatically result in a \"notify\" signal being"]
#[doc = "   emitted: the implementation must call g_object_notify() themselves"]
#[doc = "   in case the property actually changes.  Since: 2.42."]
#[doc = " @G_PARAM_PRIVATE: internal"]
#[doc = " @G_PARAM_DEPRECATED: the parameter is deprecated and will be removed"]
#[doc = "  in a future version. A warning will be generated if it is used"]
#[doc = "  while running with G_ENABLE_DIAGNOSTIC=1."]
#[doc = "  Since 2.26"]
#[doc = ""]
#[doc = " Through the #GParamFlags flag values, certain aspects of parameters"]
#[doc = " can be configured. See also #G_PARAM_STATIC_STRINGS."]
pub type GParamFlags = i32;
pub type GParamSpec = _GParamSpec;
#[doc = " GParamSpec: (ref-func g_param_spec_ref_sink) (unref-func g_param_spec_uref) (set-value-func g_value_set_param) (get-value-func g_value_get_param)"]
#[doc = " @g_type_instance: private #GTypeInstance portion"]
#[doc = " @name: name of this parameter: always an interned string"]
#[doc = " @flags: #GParamFlags flags for this parameter"]
#[doc = " @value_type: the #GValue type for this parameter"]
#[doc = " @owner_type: #GType type that uses (introduces) this parameter"]
#[doc = ""]
#[doc = " All other fields of the GParamSpec struct are private and"]
#[doc = " should not be used directly."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GParamSpec {
    pub g_type_instance: GTypeInstance,
    pub name: *const gchar,
    pub flags: GParamFlags,
    pub value_type: GType,
    pub owner_type: GType,
    pub _nick: *mut gchar,
    pub _blurb: *mut gchar,
    pub qdata: *mut GData,
    pub ref_count: guint,
    pub param_id: guint,
}
#[test]
fn bindgen_test_layout__GParamSpec() {
    assert_eq!(
        ::std::mem::size_of::<_GParamSpec>(),
        72usize,
        concat!("Size of: ", stringify!(_GParamSpec))
    );
    assert_eq!(
        ::std::mem::align_of::<_GParamSpec>(),
        8usize,
        concat!("Alignment of ", stringify!(_GParamSpec))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParamSpec>())).g_type_instance as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParamSpec),
            "::",
            stringify!(g_type_instance)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParamSpec>())).name as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParamSpec),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParamSpec>())).flags as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParamSpec),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParamSpec>())).value_type as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParamSpec),
            "::",
            stringify!(value_type)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParamSpec>())).owner_type as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParamSpec),
            "::",
            stringify!(owner_type)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParamSpec>()))._nick as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParamSpec),
            "::",
            stringify!(_nick)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParamSpec>()))._blurb as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParamSpec),
            "::",
            stringify!(_blurb)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParamSpec>())).qdata as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParamSpec),
            "::",
            stringify!(qdata)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParamSpec>())).ref_count as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParamSpec),
            "::",
            stringify!(ref_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GParamSpec>())).param_id as *const _ as usize },
        68usize,
        concat!(
            "Offset of field: ",
            stringify!(_GParamSpec),
            "::",
            stringify!(param_id)
        )
    );
}
pub type GObject = _GObject;
pub type GObjectClass = _GObjectClass;
pub type GInitiallyUnowned = _GObject;
pub type GObjectConstructParam = _GObjectConstructParam;
#[doc = " GObject:"]
#[doc = ""]
#[doc = " All the fields in the GObject structure are private"]
#[doc = " to the #GObject implementation and should never be accessed directly."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GObject {
    pub g_type_instance: GTypeInstance,
    pub ref_count: guint,
    pub qdata: *mut GData,
}
#[test]
fn bindgen_test_layout__GObject() {
    assert_eq!(
        ::std::mem::size_of::<_GObject>(),
        24usize,
        concat!("Size of: ", stringify!(_GObject))
    );
    assert_eq!(
        ::std::mem::align_of::<_GObject>(),
        8usize,
        concat!("Alignment of ", stringify!(_GObject))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObject>())).g_type_instance as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObject),
            "::",
            stringify!(g_type_instance)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObject>())).ref_count as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObject),
            "::",
            stringify!(ref_count)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObject>())).qdata as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObject),
            "::",
            stringify!(qdata)
        )
    );
}
#[doc = " GObjectClass:"]
#[doc = " @g_type_class: the parent class"]
#[doc = " @constructor: the @constructor function is called by g_object_new () to"]
#[doc = "  complete the object initialization after all the construction properties are"]
#[doc = "  set. The first thing a @constructor implementation must do is chain up to the"]
#[doc = "  @constructor of the parent class. Overriding @constructor should be rarely"]
#[doc = "  needed, e.g. to handle construct properties, or to implement singletons."]
#[doc = " @set_property: the generic setter for all properties of this type. Should be"]
#[doc = "  overridden for every type with properties. If implementations of"]
#[doc = "  @set_property don't emit property change notification explicitly, this will"]
#[doc = "  be done implicitly by the type system. However, if the notify signal is"]
#[doc = "  emitted explicitly, the type system will not emit it a second time."]
#[doc = " @get_property: the generic getter for all properties of this type. Should be"]
#[doc = "  overridden for every type with properties."]
#[doc = " @dispose: the @dispose function is supposed to drop all references to other"]
#[doc = "  objects, but keep the instance otherwise intact, so that client method"]
#[doc = "  invocations still work. It may be run multiple times (due to reference"]
#[doc = "  loops). Before returning, @dispose should chain up to the @dispose method"]
#[doc = "  of the parent class."]
#[doc = " @finalize: instance finalization function, should finish the finalization of"]
#[doc = "  the instance begun in @dispose and chain up to the @finalize method of the"]
#[doc = "  parent class."]
#[doc = " @dispatch_properties_changed: emits property change notification for a bunch"]
#[doc = "  of properties. Overriding @dispatch_properties_changed should be rarely"]
#[doc = "  needed."]
#[doc = " @notify: the class closure for the notify signal"]
#[doc = " @constructed: the @constructed function is called by g_object_new() as the"]
#[doc = "  final step of the object creation process.  At the point of the call, all"]
#[doc = "  construction properties have been set on the object.  The purpose of this"]
#[doc = "  call is to allow for object initialisation steps that can only be performed"]
#[doc = "  after construction properties have been set.  @constructed implementors"]
#[doc = "  should chain up to the @constructed call of their parent class to allow it"]
#[doc = "  to complete its initialisation."]
#[doc = ""]
#[doc = " The class structure for the GObject type."]
#[doc = ""]
#[doc = " |[<!-- language=\"C\" -->"]
#[doc = " // Example of implementing a singleton using a constructor."]
#[doc = " static MySingleton *the_singleton = NULL;"]
#[doc = ""]
#[doc = " static GObject*"]
#[doc = " my_singleton_constructor (GType                  type,"]
#[doc = "                           guint                  n_construct_params,"]
#[doc = "                           GObjectConstructParam *construct_params)"]
#[doc = " {"]
#[doc = "   GObject *object;"]
#[doc = ""]
#[doc = "   if (!the_singleton)"]
#[doc = "     {"]
#[doc = "       object = G_OBJECT_CLASS (parent_class)->constructor (type,"]
#[doc = "                                                            n_construct_params,"]
#[doc = "                                                            construct_params);"]
#[doc = "       the_singleton = MY_SINGLETON (object);"]
#[doc = "     }"]
#[doc = "   else"]
#[doc = "     object = g_object_ref (G_OBJECT (the_singleton));"]
#[doc = ""]
#[doc = "   return object;"]
#[doc = " }"]
#[doc = " ]|"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GObjectClass {
    pub g_type_class: GTypeClass,
    pub construct_properties: *mut GSList,
    pub constructor: ::std::option::Option<
        unsafe extern "C" fn(
            type_: GType,
            n_construct_properties: guint,
            construct_properties: *mut GObjectConstructParam,
        ) -> *mut GObject,
    >,
    pub set_property: ::std::option::Option<
        unsafe extern "C" fn(
            object: *mut GObject,
            property_id: guint,
            value: *const GValue,
            pspec: *mut GParamSpec,
        ),
    >,
    pub get_property: ::std::option::Option<
        unsafe extern "C" fn(
            object: *mut GObject,
            property_id: guint,
            value: *mut GValue,
            pspec: *mut GParamSpec,
        ),
    >,
    pub dispose: ::std::option::Option<unsafe extern "C" fn(object: *mut GObject)>,
    pub finalize: ::std::option::Option<unsafe extern "C" fn(object: *mut GObject)>,
    pub dispatch_properties_changed: ::std::option::Option<
        unsafe extern "C" fn(object: *mut GObject, n_pspecs: guint, pspecs: *mut *mut GParamSpec),
    >,
    pub notify:
        ::std::option::Option<unsafe extern "C" fn(object: *mut GObject, pspec: *mut GParamSpec)>,
    pub constructed: ::std::option::Option<unsafe extern "C" fn(object: *mut GObject)>,
    pub flags: gsize,
    pub pdummy: [gpointer; 6usize],
}
#[test]
fn bindgen_test_layout__GObjectClass() {
    assert_eq!(
        ::std::mem::size_of::<_GObjectClass>(),
        136usize,
        concat!("Size of: ", stringify!(_GObjectClass))
    );
    assert_eq!(
        ::std::mem::align_of::<_GObjectClass>(),
        8usize,
        concat!("Alignment of ", stringify!(_GObjectClass))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectClass>())).g_type_class as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(g_type_class)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_GObjectClass>())).construct_properties as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(construct_properties)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectClass>())).constructor as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(constructor)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectClass>())).set_property as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(set_property)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectClass>())).get_property as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(get_property)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectClass>())).dispose as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(dispose)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectClass>())).finalize as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(finalize)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_GObjectClass>())).dispatch_properties_changed as *const _
                as usize
        },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(dispatch_properties_changed)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectClass>())).notify as *const _ as usize },
        64usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(notify)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectClass>())).constructed as *const _ as usize },
        72usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(constructed)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectClass>())).flags as *const _ as usize },
        80usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectClass>())).pdummy as *const _ as usize },
        88usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectClass),
            "::",
            stringify!(pdummy)
        )
    );
}
#[doc = " GObjectConstructParam:"]
#[doc = " @pspec: the #GParamSpec of the construct parameter"]
#[doc = " @value: the value to set the parameter to"]
#[doc = ""]
#[doc = " The GObjectConstructParam struct is an auxiliary"]
#[doc = " structure used to hand #GParamSpec/#GValue pairs to the @constructor of"]
#[doc = " a #GObjectClass."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GObjectConstructParam {
    pub pspec: *mut GParamSpec,
    pub value: *mut GValue,
}
#[test]
fn bindgen_test_layout__GObjectConstructParam() {
    assert_eq!(
        ::std::mem::size_of::<_GObjectConstructParam>(),
        16usize,
        concat!("Size of: ", stringify!(_GObjectConstructParam))
    );
    assert_eq!(
        ::std::mem::align_of::<_GObjectConstructParam>(),
        8usize,
        concat!("Alignment of ", stringify!(_GObjectConstructParam))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectConstructParam>())).pspec as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectConstructParam),
            "::",
            stringify!(pspec)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GObjectConstructParam>())).value as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(_GObjectConstructParam),
            "::",
            stringify!(value)
        )
    );
}
pub const GdkScrollDirection_GDK_SCROLL_UP: GdkScrollDirection = 0;
pub const GdkScrollDirection_GDK_SCROLL_DOWN: GdkScrollDirection = 1;
pub const GdkScrollDirection_GDK_SCROLL_LEFT: GdkScrollDirection = 2;
pub const GdkScrollDirection_GDK_SCROLL_RIGHT: GdkScrollDirection = 3;
pub const GdkScrollDirection_GDK_SCROLL_SMOOTH: GdkScrollDirection = 4;
#[doc = " GdkScrollDirection:"]
#[doc = " @GDK_SCROLL_UP: the window is scrolled up."]
#[doc = " @GDK_SCROLL_DOWN: the window is scrolled down."]
#[doc = " @GDK_SCROLL_LEFT: the window is scrolled to the left."]
#[doc = " @GDK_SCROLL_RIGHT: the window is scrolled to the right."]
#[doc = " @GDK_SCROLL_SMOOTH: the scrolling is determined by the delta values"]
#[doc = "   in #GdkEventScroll. See gdk_event_get_scroll_deltas(). Since: 3.4"]
#[doc = ""]
#[doc = " Specifies the direction for #GdkEventScroll."]
pub type GdkScrollDirection = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkWidgetPrivate {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkWidget {
    pub parent_instance: GInitiallyUnowned,
    pub priv_: *mut GtkWidgetPrivate,
}
#[test]
fn bindgen_test_layout__GtkWidget() {
    assert_eq!(
        ::std::mem::size_of::<_GtkWidget>(),
        32usize,
        concat!("Size of: ", stringify!(_GtkWidget))
    );
    assert_eq!(
        ::std::mem::align_of::<_GtkWidget>(),
        8usize,
        concat!("Alignment of ", stringify!(_GtkWidget))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GtkWidget>())).parent_instance as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GtkWidget),
            "::",
            stringify!(parent_instance)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GtkWidget>())).priv_ as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_GtkWidget),
            "::",
            stringify!(priv_)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkContainerPrivate {
    _unused: [u8; 0],
}
#[repr(C)]
pub struct _GtkContainer {
    pub widget: GtkWidget,
    pub priv_: *mut GtkContainerPrivate,
}
#[test]
fn bindgen_test_layout__GtkContainer() {
    assert_eq!(
        ::std::mem::size_of::<_GtkContainer>(),
        40usize,
        concat!("Size of: ", stringify!(_GtkContainer))
    );
    assert_eq!(
        ::std::mem::align_of::<_GtkContainer>(),
        8usize,
        concat!("Alignment of ", stringify!(_GtkContainer))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GtkContainer>())).widget as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GtkContainer),
            "::",
            stringify!(widget)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GtkContainer>())).priv_ as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(_GtkContainer),
            "::",
            stringify!(priv_)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkMenuShellPrivate {
    _unused: [u8; 0],
}
#[repr(C)]
pub struct _GtkMenuShell {
    pub container: GtkContainer,
    pub priv_: *mut GtkMenuShellPrivate,
}
#[test]
fn bindgen_test_layout__GtkMenuShell() {
    assert_eq!(
        ::std::mem::size_of::<_GtkMenuShell>(),
        48usize,
        concat!("Size of: ", stringify!(_GtkMenuShell))
    );
    assert_eq!(
        ::std::mem::align_of::<_GtkMenuShell>(),
        8usize,
        concat!("Alignment of ", stringify!(_GtkMenuShell))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GtkMenuShell>())).container as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GtkMenuShell),
            "::",
            stringify!(container)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GtkMenuShell>())).priv_ as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(_GtkMenuShell),
            "::",
            stringify!(priv_)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkMenuPrivate {
    _unused: [u8; 0],
}
#[repr(C)]
pub struct _GtkMenu {
    pub menu_shell: GtkMenuShell,
    pub priv_: *mut GtkMenuPrivate,
}
#[test]
fn bindgen_test_layout__GtkMenu() {
    assert_eq!(
        ::std::mem::size_of::<_GtkMenu>(),
        56usize,
        concat!("Size of: ", stringify!(_GtkMenu))
    );
    assert_eq!(
        ::std::mem::align_of::<_GtkMenu>(),
        8usize,
        concat!("Alignment of ", stringify!(_GtkMenu))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GtkMenu>())).menu_shell as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GtkMenu),
            "::",
            stringify!(menu_shell)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GtkMenu>())).priv_ as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(_GtkMenu),
            "::",
            stringify!(priv_)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkStatusIconPrivate {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _GtkStatusIcon {
    pub parent_instance: GObject,
    pub priv_: *mut GtkStatusIconPrivate,
}
#[test]
fn bindgen_test_layout__GtkStatusIcon() {
    assert_eq!(
        ::std::mem::size_of::<_GtkStatusIcon>(),
        32usize,
        concat!("Size of: ", stringify!(_GtkStatusIcon))
    );
    assert_eq!(
        ::std::mem::align_of::<_GtkStatusIcon>(),
        8usize,
        concat!("Alignment of ", stringify!(_GtkStatusIcon))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GtkStatusIcon>())).parent_instance as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_GtkStatusIcon),
            "::",
            stringify!(parent_instance)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_GtkStatusIcon>())).priv_ as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_GtkStatusIcon),
            "::",
            stringify!(priv_)
        )
    );
}
pub const AppIndicatorCategory_APP_INDICATOR_CATEGORY_APPLICATION_STATUS: AppIndicatorCategory = 0;
pub const AppIndicatorCategory_APP_INDICATOR_CATEGORY_COMMUNICATIONS: AppIndicatorCategory = 1;
pub const AppIndicatorCategory_APP_INDICATOR_CATEGORY_SYSTEM_SERVICES: AppIndicatorCategory = 2;
pub const AppIndicatorCategory_APP_INDICATOR_CATEGORY_HARDWARE: AppIndicatorCategory = 3;
pub const AppIndicatorCategory_APP_INDICATOR_CATEGORY_OTHER: AppIndicatorCategory = 4;
#[doc = " AppIndicatorCategory:"]
#[doc = " @APP_INDICATOR_CATEGORY_APPLICATION_STATUS: The indicator is used to display the status of the application."]
#[doc = " @APP_INDICATOR_CATEGORY_COMMUNICATIONS: The application is used for communication with other people."]
#[doc = " @APP_INDICATOR_CATEGORY_SYSTEM_SERVICES: A system indicator relating to something in the user's system."]
#[doc = " @APP_INDICATOR_CATEGORY_HARDWARE: An indicator relating to the user's hardware."]
#[doc = " @APP_INDICATOR_CATEGORY_OTHER: Something not defined in this enum, please don't use unless you really need it."]
#[doc = ""]
#[doc = " The category provides grouping for the indicators so that"]
#[doc = " users can find indicators that are similar together."]
pub type AppIndicatorCategory = u32;
pub const AppIndicatorStatus_APP_INDICATOR_STATUS_PASSIVE: AppIndicatorStatus = 0;
pub const AppIndicatorStatus_APP_INDICATOR_STATUS_ACTIVE: AppIndicatorStatus = 1;
pub const AppIndicatorStatus_APP_INDICATOR_STATUS_ATTENTION: AppIndicatorStatus = 2;
#[doc = " AppIndicatorStatus:"]
#[doc = " @APP_INDICATOR_STATUS_PASSIVE: The indicator should not be shown to the user."]
#[doc = " @APP_INDICATOR_STATUS_ACTIVE: The indicator should be shown in it's default state."]
#[doc = " @APP_INDICATOR_STATUS_ATTENTION: The indicator should show it's attention icon."]
#[doc = ""]
#[doc = " These are the states that the indicator can be on in"]
#[doc = " the user's panel.  The indicator by default starts"]
#[doc = " in the state @APP_INDICATOR_STATUS_PASSIVE and can be"]
#[doc = " shown by setting it to @APP_INDICATOR_STATUS_ACTIVE."]
pub type AppIndicatorStatus = u32;
pub type AppIndicator = _AppIndicator;
pub type AppIndicatorClass = _AppIndicatorClass;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _AppIndicatorPrivate {
    _unused: [u8; 0],
}
pub type AppIndicatorPrivate = _AppIndicatorPrivate;
#[doc = " AppIndicatorClass:"]
#[doc = " @parent_class: Mia familia"]
#[doc = " @new_icon: Slot for #AppIndicator::new-icon."]
#[doc = " @new_attention_icon: Slot for #AppIndicator::new-attention-icon."]
#[doc = " @new_status: Slot for #AppIndicator::new-status."]
#[doc = " @new_icon_theme_path: Slot for #AppIndicator::new-icon-theme-path"]
#[doc = " @new_label: Slot for #AppIndicator::new-label."]
#[doc = " @connection_changed: Slot for #AppIndicator::connection-changed."]
#[doc = " @scroll_event: Slot for #AppIndicator::scroll-event"]
#[doc = " @app_indicator_reserved_ats: Reserved for future use."]
#[doc = " @fallback: Function that gets called to make a #GtkStatusIcon when"]
#[doc = "            there is no Application Indicator area available."]
#[doc = " @unfallback: The function that gets called if an Application"]
#[doc = "              Indicator area appears after the fallback has been created."]
#[doc = " @app_indicator_reserved_1: Reserved for future use."]
#[doc = " @app_indicator_reserved_2: Reserved for future use."]
#[doc = " @app_indicator_reserved_3: Reserved for future use."]
#[doc = " @app_indicator_reserved_4: Reserved for future use."]
#[doc = " @app_indicator_reserved_5: Reserved for future use."]
#[doc = " @app_indicator_reserved_6: Reserved for future use."]
#[doc = ""]
#[doc = " The signals and external functions that make up the #AppIndicator"]
#[doc = " class object."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _AppIndicatorClass {
    pub parent_class: GObjectClass,
    pub new_icon: ::std::option::Option<
        unsafe extern "C" fn(indicator: *mut AppIndicator, user_data: gpointer),
    >,
    pub new_attention_icon: ::std::option::Option<
        unsafe extern "C" fn(indicator: *mut AppIndicator, user_data: gpointer),
    >,
    pub new_status: ::std::option::Option<
        unsafe extern "C" fn(
            indicator: *mut AppIndicator,
            status: *const gchar,
            user_data: gpointer,
        ),
    >,
    pub new_icon_theme_path: ::std::option::Option<
        unsafe extern "C" fn(
            indicator: *mut AppIndicator,
            icon_theme_path: *const gchar,
            user_data: gpointer,
        ),
    >,
    pub new_label: ::std::option::Option<
        unsafe extern "C" fn(
            indicator: *mut AppIndicator,
            label: *const gchar,
            guide: *const gchar,
            user_data: gpointer,
        ),
    >,
    pub connection_changed: ::std::option::Option<
        unsafe extern "C" fn(
            indicator: *mut AppIndicator,
            connected: gboolean,
            user_data: gpointer,
        ),
    >,
    pub scroll_event: ::std::option::Option<
        unsafe extern "C" fn(
            indicator: *mut AppIndicator,
            delta: gint,
            direction: GdkScrollDirection,
            user_data: gpointer,
        ),
    >,
    pub app_indicator_reserved_ats: ::std::option::Option<unsafe extern "C" fn()>,
    pub fallback: ::std::option::Option<
        unsafe extern "C" fn(indicator: *mut AppIndicator) -> *mut GtkStatusIcon,
    >,
    pub unfallback: ::std::option::Option<
        unsafe extern "C" fn(indicator: *mut AppIndicator, status_icon: *mut GtkStatusIcon),
    >,
    pub app_indicator_reserved_1: ::std::option::Option<unsafe extern "C" fn()>,
    pub app_indicator_reserved_2: ::std::option::Option<unsafe extern "C" fn()>,
    pub app_indicator_reserved_3: ::std::option::Option<unsafe extern "C" fn()>,
    pub app_indicator_reserved_4: ::std::option::Option<unsafe extern "C" fn()>,
    pub app_indicator_reserved_5: ::std::option::Option<unsafe extern "C" fn()>,
    pub app_indicator_reserved_6: ::std::option::Option<unsafe extern "C" fn()>,
}
#[test]
fn bindgen_test_layout__AppIndicatorClass() {
    assert_eq!(
        ::std::mem::size_of::<_AppIndicatorClass>(),
        264usize,
        concat!("Size of: ", stringify!(_AppIndicatorClass))
    );
    assert_eq!(
        ::std::mem::align_of::<_AppIndicatorClass>(),
        8usize,
        concat!("Alignment of ", stringify!(_AppIndicatorClass))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_AppIndicatorClass>())).parent_class as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_AppIndicatorClass),
            "::",
            stringify!(parent_class)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_AppIndicatorClass>())).new_icon as *const _ as usize },
        136usize,
        concat!(
            "Offset of field: ",
            stringify!(_AppIndicatorClass),
            "::",
            stringify!(new_icon)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_AppIndicatorClass>())).new_attention_icon as *const _ as usize
        },
        144usize,
        concat!(
            "Offset of field: ",
            stringify!(_AppIndicatorClass),
            "::",
            stringify!(new_attention_icon)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_AppIndicatorClass>())).new_status as *const _ as usize },
        152usize,
        concat!(
            "Offset of field: ",
            stringify!(_AppIndicatorClass),
            "::",
            stringify!(new_status)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_AppIndicatorClass>())).new_icon_theme_path as *const _ as usize
        },
        160usize,
        concat!(
            "Offset of field: ",
            stringify!(_AppIndicatorClass),
            "::",
            stringify!(new_icon_theme_path)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_AppIndicatorClass>())).new_label as *const _ as usize },
        168usize,
        concat!(
            "Offset of field: ",
            stringify!(_AppIndicatorClass),
            "::",
            stringify!(new_label)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_AppIndicatorClass>())).connection_changed as *const _ as usize
        },
        176usize,
        concat!(
            "Offset of field: ",
            stringify!(_AppIndicatorClass),
            "::",
            stringify!(connection_changed)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_AppIndicatorClass>())).scroll_event as *const _ as usize },
        184usize,
        concat!(
            "Offset of field: ",
            stringify!(_AppIndicatorClass),
            "::",
            stringify!(scroll_event)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_AppIndicatorClass>())).app_indicator_reserved_ats as *const _
                as usize
        },
        192usize,
        concat!(
            "Offset of field: ",
            stringify!(_AppIndicatorClass),
            "::",
            stringify!(app_indicator_reserved_ats)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_AppIndicatorClass>())).fallback as *const _ as usize },
        200usize,
        concat!(
            "Offset of field: ",
            stringify!(_AppIndicatorClass),
            "::",
            stringify!(fallback)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_AppIndicatorClass>())).unfallback as *const _ as usize },
        208usize,
        concat!(
            "Offset of field: ",
            stringify!(_AppIndicatorClass),
            "::",
            stringify!(unfallback)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_AppIndicatorClass>())).app_indicator_reserved_1 as *const _
                as usize
        },
        216usize,
        concat!(
            "Offset of field: ",
            stringify!(_AppIndicatorClass),
            "::",
            stringify!(app_indicator_reserved_1)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_AppIndicatorClass>())).app_indicator_reserved_2 as *const _
                as usize
        },
        224usize,
        concat!(
            "Offset of field: ",
            stringify!(_AppIndicatorClass),
            "::",
            stringify!(app_indicator_reserved_2)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_AppIndicatorClass>())).app_indicator_reserved_3 as *const _
                as usize
        },
        232usize,
        concat!(
            "Offset of field: ",
            stringify!(_AppIndicatorClass),
            "::",
            stringify!(app_indicator_reserved_3)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_AppIndicatorClass>())).app_indicator_reserved_4 as *const _
                as usize
        },
        240usize,
        concat!(
            "Offset of field: ",
            stringify!(_AppIndicatorClass),
            "::",
            stringify!(app_indicator_reserved_4)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_AppIndicatorClass>())).app_indicator_reserved_5 as *const _
                as usize
        },
        248usize,
        concat!(
            "Offset of field: ",
            stringify!(_AppIndicatorClass),
            "::",
            stringify!(app_indicator_reserved_5)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<_AppIndicatorClass>())).app_indicator_reserved_6 as *const _
                as usize
        },
        256usize,
        concat!(
            "Offset of field: ",
            stringify!(_AppIndicatorClass),
            "::",
            stringify!(app_indicator_reserved_6)
        )
    );
}
#[doc = " AppIndicator:"]
#[doc = ""]
#[doc = " A application indicator represents the values that are needed to show a"]
#[doc = " unique status in the panel for an application.  In general, applications"]
#[doc = " should try to fit in the other indicators that are available on the"]
#[doc = " panel before using this.  But, sometimes it is necissary."]
#[doc = ""]
#[doc = "  Private fields"]
#[doc = " @parent: Parent object."]
#[doc = " @priv: Internal data."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _AppIndicator {
    pub parent: GObject,
    pub priv_: *mut AppIndicatorPrivate,
}
#[test]
fn bindgen_test_layout__AppIndicator() {
    assert_eq!(
        ::std::mem::size_of::<_AppIndicator>(),
        32usize,
        concat!("Size of: ", stringify!(_AppIndicator))
    );
    assert_eq!(
        ::std::mem::align_of::<_AppIndicator>(),
        8usize,
        concat!("Alignment of ", stringify!(_AppIndicator))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_AppIndicator>())).parent as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(_AppIndicator),
            "::",
            stringify!(parent)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<_AppIndicator>())).priv_ as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(_AppIndicator),
            "::",
            stringify!(priv_)
        )
    );
}
extern "C" {
    pub fn app_indicator_get_type() -> GType;
}
extern "C" {
    pub fn app_indicator_new(
        id: *const gchar,
        icon_name: *const gchar,
        category: AppIndicatorCategory,
    ) -> *mut AppIndicator;
}
extern "C" {
    pub fn app_indicator_new_with_path(
        id: *const gchar,
        icon_name: *const gchar,
        category: AppIndicatorCategory,
        icon_theme_path: *const gchar,
    ) -> *mut AppIndicator;
}
extern "C" {
    pub fn app_indicator_set_status(self_: *mut AppIndicator, status: AppIndicatorStatus);
}
extern "C" {
    pub fn app_indicator_set_attention_icon(self_: *mut AppIndicator, icon_name: *const gchar);
}
extern "C" {
    pub fn app_indicator_set_attention_icon_full(
        self_: *mut AppIndicator,
        icon_name: *const gchar,
        icon_desc: *const gchar,
    );
}
extern "C" {
    pub fn app_indicator_set_menu(self_: *mut AppIndicator, menu: *mut GtkMenu);
}
extern "C" {
    pub fn app_indicator_set_icon(self_: *mut AppIndicator, icon_name: *const gchar);
}
extern "C" {
    pub fn app_indicator_set_icon_full(
        self_: *mut AppIndicator,
        icon_name: *const gchar,
        icon_desc: *const gchar,
    );
}
extern "C" {
    pub fn app_indicator_set_label(
        self_: *mut AppIndicator,
        label: *const gchar,
        guide: *const gchar,
    );
}
extern "C" {
    pub fn app_indicator_set_icon_theme_path(
        self_: *mut AppIndicator,
        icon_theme_path: *const gchar,
    );
}
extern "C" {
    pub fn app_indicator_set_ordering_index(self_: *mut AppIndicator, ordering_index: guint32);
}
extern "C" {
    pub fn app_indicator_set_secondary_activate_target(
        self_: *mut AppIndicator,
        menuitem: *mut GtkWidget,
    );
}
extern "C" {
    pub fn app_indicator_set_title(self_: *mut AppIndicator, title: *const gchar);
}
extern "C" {
    pub fn app_indicator_get_id(self_: *mut AppIndicator) -> *const gchar;
}
extern "C" {
    pub fn app_indicator_get_category(self_: *mut AppIndicator) -> AppIndicatorCategory;
}
extern "C" {
    pub fn app_indicator_get_status(self_: *mut AppIndicator) -> AppIndicatorStatus;
}
extern "C" {
    pub fn app_indicator_get_icon(self_: *mut AppIndicator) -> *const gchar;
}
extern "C" {
    pub fn app_indicator_get_icon_desc(self_: *mut AppIndicator) -> *const gchar;
}
extern "C" {
    pub fn app_indicator_get_icon_theme_path(self_: *mut AppIndicator) -> *const gchar;
}
extern "C" {
    pub fn app_indicator_get_attention_icon(self_: *mut AppIndicator) -> *const gchar;
}
extern "C" {
    pub fn app_indicator_get_attention_icon_desc(self_: *mut AppIndicator) -> *const gchar;
}
extern "C" {
    pub fn app_indicator_get_title(self_: *mut AppIndicator) -> *const gchar;
}
extern "C" {
    pub fn app_indicator_get_menu(self_: *mut AppIndicator) -> *mut GtkMenu;
}
extern "C" {
    pub fn app_indicator_get_label(self_: *mut AppIndicator) -> *const gchar;
}
extern "C" {
    pub fn app_indicator_get_label_guide(self_: *mut AppIndicator) -> *const gchar;
}
extern "C" {
    pub fn app_indicator_get_ordering_index(self_: *mut AppIndicator) -> guint32;
}
extern "C" {
    pub fn app_indicator_get_secondary_activate_target(self_: *mut AppIndicator) -> *mut GtkWidget;
}
extern "C" {
    pub fn app_indicator_build_menu_from_desktop(
        self_: *mut AppIndicator,
        desktop_file: *const gchar,
        desktop_profile: *const gchar,
    );
}