// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use cairo;
use glib;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::value::SetValueOptional;
use glib::StaticType;
use glib::Value;
use glib_sys;
use gobject_sys;
use gtk_sys;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;
use Adjustment;
use Buildable;
use ResizeMode;
use Widget;
use WidgetPath;

glib_wrapper! {
    /// A GTK+ user interface is constructed by nesting widgets inside widgets.
    /// Container widgets are the inner nodes in the resulting tree of widgets:
    /// they contain other widgets. So, for example, you might have a `Window`
    /// containing a `Frame` containing a `Label`. If you wanted an image instead
    /// of a textual label inside the frame, you might replace the `Label` widget
    /// with a `Image` widget.
    ///
    /// There are two major kinds of container widgets in GTK+. Both are subclasses
    /// of the abstract `Container` base class.
    ///
    /// The first type of container widget has a single child widget and derives
    /// from `Bin`. These containers are decorators, which
    /// add some kind of functionality to the child. For example, a `Button` makes
    /// its child into a clickable button; a `Frame` draws a frame around its child
    /// and a `Window` places its child widget inside a top-level window.
    ///
    /// The second type of container can have more than one child; its purpose is to
    /// manage layout. This means that these containers assign
    /// sizes and positions to their children. For example, a `HBox` arranges its
    /// children in a horizontal row, and a `Grid` arranges the widgets it contains
    /// in a two-dimensional grid.
    ///
    /// # Child properties
    ///
    /// `Container` introduces child properties.
    /// These are object properties that are not specific
    /// to either the container or the contained widget, but rather to their relation.
    /// Typical examples of child properties are the position or pack-type of a widget
    /// which is contained in a `Box`.
    ///
    /// # `Container` as `Buildable`
    ///
    /// The `Container` implementation of the `Buildable` interface supports
    /// a `<packing>` element for children, which can contain multiple `<property>`
    /// elements that specify child properties for the child.
    ///
    /// Since 2.16, child properties can also be marked as translatable using
    /// the same “translatable”, “comments” and “context” attributes that are used
    /// for regular properties.
    ///
    /// Since 3.16, containers can have a `<focus-chain>` element containing multiple
    /// `<widget>` elements, one for each child that should be added to the focus
    /// chain. The ”name” attribute gives the id of the widget.
    ///
    /// An example of these properties in UI definitions:
    ///
    /// ```xml
    /// <object class="GtkBox">
    ///   <child>
    ///     <object class="GtkEntry" id="entry1"/>
    ///     <packing>
    ///       <property name="pack-type">start</property>
    ///     </packing>
    ///   </child>
    ///   <child>
    ///     <object class="GtkEntry" id="entry2"/>
    ///   </child>
    ///   <focus-chain>
    ///     <widget name="entry1"/>
    ///     <widget name="entry2"/>
    ///   </focus-chain>
    /// </object>
    /// ```
    ///
    /// # Implements
    ///
    /// [`ContainerExt`](trait.ContainerExt.html), [`WidgetExt`](trait.WidgetExt.html)
    pub struct Container(Object<gtk_sys::GtkContainer, gtk_sys::GtkContainerClass, ContainerClass>) @extends Widget, @implements Buildable;

    match fn {
        get_type => || gtk_sys::gtk_container_get_type(),
    }
}

pub const NONE_CONTAINER: Option<&Container> = None;

/// Trait containing all `Container` methods.
///
/// # Implementors
///
/// [`Bin`](struct.Bin.html), [`Box`](struct.Box.html), [`Container`](struct.Container.html), [`Fixed`](struct.Fixed.html), [`FlowBox`](struct.FlowBox.html), [`Grid`](struct.Grid.html), [`HeaderBar`](struct.HeaderBar.html), [`IconView`](struct.IconView.html), [`Layout`](struct.Layout.html), [`ListBox`](struct.ListBox.html), [`MenuShell`](struct.MenuShell.html), [`Notebook`](struct.Notebook.html), [`Paned`](struct.Paned.html), [`Socket`](struct.Socket.html), [`Stack`](struct.Stack.html), [`TextView`](struct.TextView.html), [`ToolItemGroup`](struct.ToolItemGroup.html), [`ToolPalette`](struct.ToolPalette.html), [`Toolbar`](struct.Toolbar.html), [`TreeView`](struct.TreeView.html)
pub trait ContainerExt: 'static {
    /// Adds `widget` to `self`. Typically used for simple containers
    /// such as `Window`, `Frame`, or `Button`; for more complicated
    /// layout containers such as `Box` or `Grid`, this function will
    /// pick default packing parameters that may not be correct. So
    /// consider functions such as `BoxExt::pack_start` and
    /// `GridExt::attach` as an alternative to `ContainerExt::add` in
    /// those cases. A widget may be added to only one container at a time;
    /// you can’t place the same widget inside two different containers.
    ///
    /// Note that some containers, such as `ScrolledWindow` or `ListBox`,
    /// may add intermediate children between the added widget and the
    /// container.
    /// ## `widget`
    /// a widget to be placed inside `self`
    fn add<P: IsA<Widget>>(&self, widget: &P);

    //fn add_with_properties<P: IsA<Widget>>(&self, widget: &P, first_prop_name: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs);

    fn check_resize(&self);

    //fn child_get<P: IsA<Widget>>(&self, child: &P, first_prop_name: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs);

    //fn child_get_valist<P: IsA<Widget>>(&self, child: &P, first_property_name: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported);

    /// Emits a `Widget::child-notify` signal for the
    /// [child property](struct.Container.html#child-properties)
    /// `child_property` on widget.
    ///
    /// This is an analogue of `gobject::Object::notify` for child properties.
    ///
    /// Also see `Widget::child_notify`.
    /// ## `child`
    /// the child widget
    /// ## `child_property`
    /// the name of a child property installed on
    ///  the class of `self`
    fn child_notify<P: IsA<Widget>>(&self, child: &P, child_property: &str);

    /// Emits a `Widget::child-notify` signal for the
    /// [child property][child-properties] specified by
    /// `pspec` on the child.
    ///
    /// This is an analogue of `gobject::ObjectExt::notify_by_pspec` for child properties.
    ///
    /// Feature: `v3_18`
    ///
    /// ## `child`
    /// the child widget
    /// ## `pspec`
    /// the `gobject::ParamSpec` of a child property instealled on
    ///  the class of `self`
    #[cfg(any(feature = "v3_18", feature = "dox"))]
    fn child_notify_by_pspec<P: IsA<Widget>>(&self, child: &P, pspec: &glib::ParamSpec);

    //fn child_set<P: IsA<Widget>>(&self, child: &P, first_prop_name: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs);

    //fn child_set_valist<P: IsA<Widget>>(&self, child: &P, first_property_name: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported);

    /// Returns the type of the children supported by the container.
    ///
    /// Note that this may return `G_TYPE_NONE` to indicate that no more
    /// children can be added, e.g. for a `Paned` which already has two
    /// children.
    ///
    /// # Returns
    ///
    /// a `glib::Type`.
    fn child_type(&self) -> glib::types::Type;

    /// Invokes `callback` on each direct child of `self`, including
    /// children that are considered “internal” (implementation details
    /// of the container). “Internal” children generally weren’t added
    /// by the user of the container, but were added by the container
    /// implementation itself.
    ///
    /// Most applications should use `ContainerExt::foreach`, rather
    /// than `ContainerExt::forall`.
    /// ## `callback`
    /// a callback
    /// ## `callback_data`
    /// callback user data
    fn forall<P: FnMut(&Widget)>(&self, callback: P);

    /// Invokes `callback` on each non-internal child of `self`.
    /// See `ContainerExt::forall` for details on what constitutes
    /// an “internal” child. For all practical purposes, this function
    /// should iterate over precisely those child widgets that were
    /// added to the container by the application with explicit `add`
    /// calls.
    ///
    /// It is permissible to remove the child from the `callback` handler.
    ///
    /// Most applications should use `ContainerExt::foreach`,
    /// rather than `ContainerExt::forall`.
    /// ## `callback`
    /// a callback
    /// ## `callback_data`
    /// callback user data
    fn foreach<P: FnMut(&Widget)>(&self, callback: P);

    /// Retrieves the border width of the container. See
    /// `ContainerExt::set_border_width`.
    ///
    /// # Returns
    ///
    /// the current border width
    fn get_border_width(&self) -> u32;

    /// Returns the container’s non-internal children. See
    /// `ContainerExt::forall` for details on what constitutes an "internal" child.
    ///
    /// # Returns
    ///
    /// a newly-allocated list of the container’s non-internal children.
    fn get_children(&self) -> Vec<Widget>;

    //#[cfg_attr(feature = "v3_24", deprecated)]
    //fn get_focus_chain(&self, focusable_widgets: /*Unimplemented*/Vec<Widget>) -> bool;

    /// Returns the current focus child widget inside `self`. This is not the
    /// currently focused widget. That can be obtained by calling
    /// `GtkWindowExt::get_focus`.
    ///
    /// # Returns
    ///
    /// The child widget which will receive the
    ///  focus inside `self` when the `self` is focused,
    ///  or `None` if none is set.
    fn get_focus_child(&self) -> Option<Widget>;

    /// Retrieves the horizontal focus adjustment for the container. See
    /// gtk_container_set_focus_hadjustment ().
    ///
    /// # Returns
    ///
    /// the horizontal focus adjustment, or `None` if
    ///  none has been set.
    fn get_focus_hadjustment(&self) -> Option<Adjustment>;

    /// Retrieves the vertical focus adjustment for the container. See
    /// `ContainerExt::set_focus_vadjustment`.
    ///
    /// # Returns
    ///
    /// the vertical focus adjustment, or
    ///  `None` if none has been set.
    fn get_focus_vadjustment(&self) -> Option<Adjustment>;

    /// Returns a newly created widget path representing all the widget hierarchy
    /// from the toplevel down to and including `child`.
    /// ## `child`
    /// a child of `self`
    ///
    /// # Returns
    ///
    /// A newly created `WidgetPath`
    fn get_path_for_child<P: IsA<Widget>>(&self, child: &P) -> Option<WidgetPath>;

    /// When a container receives a call to the draw function, it must send
    /// synthetic `Widget::draw` calls to all children that don’t have their
    /// own ``GdkWindows``. This function provides a convenient way of doing this.
    /// A container, when it receives a call to its `Widget::draw` function,
    /// calls `ContainerExt::propagate_draw` once for each child, passing in
    /// the `cr` the container received.
    ///
    /// `ContainerExt::propagate_draw` takes care of translating the origin of `cr`,
    /// and deciding whether the draw needs to be sent to the child. It is a
    /// convenient and optimized way of getting the same effect as calling
    /// `WidgetExt::draw` on the child directly.
    ///
    /// In most cases, a container can simply either inherit the
    /// `Widget::draw` implementation from `Container`, or do some drawing
    /// and then chain to the ::draw implementation from `Container`.
    /// ## `child`
    /// a child of `self`
    /// ## `cr`
    /// Cairo context as passed to the container. If you want to use `cr`
    ///  in container’s draw function, consider using `cairo_save` and
    ///  `cairo_restore` before calling this function.
    fn propagate_draw<P: IsA<Widget>>(&self, child: &P, cr: &cairo::Context);

    /// Removes `widget` from `self`. `widget` must be inside `self`.
    /// Note that `self` will own a reference to `widget`, and that this
    /// may be the last reference held; so removing a widget from its
    /// container can destroy that widget. If you want to use `widget`
    /// again, you need to add a reference to it before removing it from
    /// a container, using `gobject::ObjectExt::ref`. If you don’t want to use `widget`
    /// again it’s usually more efficient to simply destroy it directly
    /// using `Widget::destroy` since this will remove it from the
    /// container and help break any circular reference count cycles.
    /// ## `widget`
    /// a current child of `self`
    fn remove<P: IsA<Widget>>(&self, widget: &P);

    /// Sets the border width of the container.
    ///
    /// The border width of a container is the amount of space to leave
    /// around the outside of the container. The only exception to this is
    /// `Window`; because toplevel windows can’t leave space outside,
    /// they leave the space inside. The border is added on all sides of
    /// the container. To add space to only one side, use a specific
    /// `Widget:margin` property on the child widget, for example
    /// `Widget:margin-top`.
    /// ## `border_width`
    /// amount of blank space to leave outside
    ///  the container. Valid values are in the range 0-65535 pixels.
    fn set_border_width(&self, border_width: u32);

    /// Sets a focus chain, overriding the one computed automatically by GTK+.
    ///
    /// In principle each widget in the chain should be a descendant of the
    /// container, but this is not enforced by this method, since it’s allowed
    /// to set the focus chain before you pack the widgets, or have a widget
    /// in the chain that isn’t always packed. The necessary checks are done
    /// when the focus chain is actually traversed.
    ///
    /// # Deprecated since 3.24
    ///
    /// For overriding focus behavior, use the
    ///  `WidgetClass`::focus signal.
    /// ## `focusable_widgets`
    ///
    ///  the new focus chain
    #[cfg_attr(feature = "v3_24", deprecated)]
    fn set_focus_chain(&self, focusable_widgets: &[Widget]);

    /// Sets, or unsets if `child` is `None`, the focused child of `self`.
    ///
    /// This function emits the `Container`::set_focus_child signal of
    /// `self`. Implementations of `Container` can override the
    /// default behaviour by overriding the class closure of this signal.
    ///
    /// This is function is mostly meant to be used by widgets. Applications can use
    /// `WidgetExt::grab_focus` to manually set the focus to a specific widget.
    /// ## `child`
    /// a `Widget`, or `None`
    fn set_focus_child<P: IsA<Widget>>(&self, child: Option<&P>);

    /// Hooks up an adjustment to focus handling in a container, so when a child
    /// of the container is focused, the adjustment is scrolled to show that
    /// widget. This function sets the horizontal alignment.
    /// See `ScrolledWindowExt::get_hadjustment` for a typical way of obtaining
    /// the adjustment and `ContainerExt::set_focus_vadjustment` for setting
    /// the vertical adjustment.
    ///
    /// The adjustments have to be in pixel units and in the same coordinate
    /// system as the allocation for immediate children of the container.
    /// ## `adjustment`
    /// an adjustment which should be adjusted when the focus is
    ///  moved among the descendents of `self`
    fn set_focus_hadjustment<P: IsA<Adjustment>>(&self, adjustment: &P);

    /// Hooks up an adjustment to focus handling in a container, so when a
    /// child of the container is focused, the adjustment is scrolled to
    /// show that widget. This function sets the vertical alignment. See
    /// `ScrolledWindowExt::get_vadjustment` for a typical way of obtaining
    /// the adjustment and `ContainerExt::set_focus_hadjustment` for setting
    /// the horizontal adjustment.
    ///
    /// The adjustments have to be in pixel units and in the same coordinate
    /// system as the allocation for immediate children of the container.
    /// ## `adjustment`
    /// an adjustment which should be adjusted when the focus
    ///  is moved among the descendents of `self`
    fn set_focus_vadjustment<P: IsA<Adjustment>>(&self, adjustment: &P);

    /// Removes a focus chain explicitly set with `ContainerExt::set_focus_chain`.
    ///
    /// # Deprecated since 3.24
    ///
    /// For overriding focus behavior, use the
    ///  `WidgetClass`::focus signal.
    #[cfg_attr(feature = "v3_24", deprecated)]
    fn unset_focus_chain(&self);

    fn set_property_child<P: IsA<Widget> + SetValueOptional>(&self, child: Option<&P>);

    fn get_property_resize_mode(&self) -> ResizeMode;

    fn set_property_resize_mode(&self, resize_mode: ResizeMode);

    fn connect_add<F: Fn(&Self, &Widget) + 'static>(&self, f: F) -> SignalHandlerId;

    fn connect_check_resize<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    fn connect_remove<F: Fn(&Self, &Widget) + 'static>(&self, f: F) -> SignalHandlerId;

    fn connect_set_focus_child<F: Fn(&Self, &Widget) + 'static>(&self, f: F) -> SignalHandlerId;

    fn connect_property_border_width_notify<F: Fn(&Self) + 'static>(&self, f: F)
        -> SignalHandlerId;

    fn connect_property_child_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    fn connect_property_resize_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
}

impl<O: IsA<Container>> ContainerExt for O {
    fn add<P: IsA<Widget>>(&self, widget: &P) {
        unsafe {
            gtk_sys::gtk_container_add(
                self.as_ref().to_glib_none().0,
                widget.as_ref().to_glib_none().0,
            );
        }
    }

    //fn add_with_properties<P: IsA<Widget>>(&self, widget: &P, first_prop_name: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) {
    //    unsafe { TODO: call gtk_sys:gtk_container_add_with_properties() }
    //}

    fn check_resize(&self) {
        unsafe {
            gtk_sys::gtk_container_check_resize(self.as_ref().to_glib_none().0);
        }
    }

    //fn child_get<P: IsA<Widget>>(&self, child: &P, first_prop_name: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) {
    //    unsafe { TODO: call gtk_sys:gtk_container_child_get() }
    //}

    //fn child_get_valist<P: IsA<Widget>>(&self, child: &P, first_property_name: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) {
    //    unsafe { TODO: call gtk_sys:gtk_container_child_get_valist() }
    //}

    fn child_notify<P: IsA<Widget>>(&self, child: &P, child_property: &str) {
        unsafe {
            gtk_sys::gtk_container_child_notify(
                self.as_ref().to_glib_none().0,
                child.as_ref().to_glib_none().0,
                child_property.to_glib_none().0,
            );
        }
    }

    #[cfg(any(feature = "v3_18", feature = "dox"))]
    fn child_notify_by_pspec<P: IsA<Widget>>(&self, child: &P, pspec: &glib::ParamSpec) {
        unsafe {
            gtk_sys::gtk_container_child_notify_by_pspec(
                self.as_ref().to_glib_none().0,
                child.as_ref().to_glib_none().0,
                pspec.to_glib_none().0,
            );
        }
    }

    //fn child_set<P: IsA<Widget>>(&self, child: &P, first_prop_name: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) {
    //    unsafe { TODO: call gtk_sys:gtk_container_child_set() }
    //}

    //fn child_set_valist<P: IsA<Widget>>(&self, child: &P, first_property_name: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) {
    //    unsafe { TODO: call gtk_sys:gtk_container_child_set_valist() }
    //}

    fn child_type(&self) -> glib::types::Type {
        unsafe {
            from_glib(gtk_sys::gtk_container_child_type(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn forall<P: FnMut(&Widget)>(&self, callback: P) {
        let callback_data: P = callback;
        unsafe extern "C" fn callback_func<P: FnMut(&Widget)>(
            widget: *mut gtk_sys::GtkWidget,
            data: glib_sys::gpointer,
        ) {
            let widget = from_glib_borrow(widget);
            let callback: *mut P = data as *const _ as usize as *mut P;
            (*callback)(&widget);
        }
        let callback = Some(callback_func::<P> as _);
        let super_callback0: &P = &callback_data;
        unsafe {
            gtk_sys::gtk_container_forall(
                self.as_ref().to_glib_none().0,
                callback,
                super_callback0 as *const _ as usize as *mut _,
            );
        }
    }

    fn foreach<P: FnMut(&Widget)>(&self, callback: P) {
        let callback_data: P = callback;
        unsafe extern "C" fn callback_func<P: FnMut(&Widget)>(
            widget: *mut gtk_sys::GtkWidget,
            data: glib_sys::gpointer,
        ) {
            let widget = from_glib_borrow(widget);
            let callback: *mut P = data as *const _ as usize as *mut P;
            (*callback)(&widget);
        }
        let callback = Some(callback_func::<P> as _);
        let super_callback0: &P = &callback_data;
        unsafe {
            gtk_sys::gtk_container_foreach(
                self.as_ref().to_glib_none().0,
                callback,
                super_callback0 as *const _ as usize as *mut _,
            );
        }
    }

    fn get_border_width(&self) -> u32 {
        unsafe { gtk_sys::gtk_container_get_border_width(self.as_ref().to_glib_none().0) }
    }

    fn get_children(&self) -> Vec<Widget> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(gtk_sys::gtk_container_get_children(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    //fn get_focus_chain(&self, focusable_widgets: /*Unimplemented*/Vec<Widget>) -> bool {
    //    unsafe { TODO: call gtk_sys:gtk_container_get_focus_chain() }
    //}

    fn get_focus_child(&self) -> Option<Widget> {
        unsafe {
            from_glib_none(gtk_sys::gtk_container_get_focus_child(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_focus_hadjustment(&self) -> Option<Adjustment> {
        unsafe {
            from_glib_none(gtk_sys::gtk_container_get_focus_hadjustment(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_focus_vadjustment(&self) -> Option<Adjustment> {
        unsafe {
            from_glib_none(gtk_sys::gtk_container_get_focus_vadjustment(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_path_for_child<P: IsA<Widget>>(&self, child: &P) -> Option<WidgetPath> {
        unsafe {
            from_glib_full(gtk_sys::gtk_container_get_path_for_child(
                self.as_ref().to_glib_none().0,
                child.as_ref().to_glib_none().0,
            ))
        }
    }

    fn propagate_draw<P: IsA<Widget>>(&self, child: &P, cr: &cairo::Context) {
        unsafe {
            gtk_sys::gtk_container_propagate_draw(
                self.as_ref().to_glib_none().0,
                child.as_ref().to_glib_none().0,
                mut_override(cr.to_glib_none().0),
            );
        }
    }

    fn remove<P: IsA<Widget>>(&self, widget: &P) {
        unsafe {
            gtk_sys::gtk_container_remove(
                self.as_ref().to_glib_none().0,
                widget.as_ref().to_glib_none().0,
            );
        }
    }

    fn set_border_width(&self, border_width: u32) {
        unsafe {
            gtk_sys::gtk_container_set_border_width(self.as_ref().to_glib_none().0, border_width);
        }
    }

    fn set_focus_chain(&self, focusable_widgets: &[Widget]) {
        unsafe {
            gtk_sys::gtk_container_set_focus_chain(
                self.as_ref().to_glib_none().0,
                focusable_widgets.to_glib_none().0,
            );
        }
    }

    fn set_focus_child<P: IsA<Widget>>(&self, child: Option<&P>) {
        unsafe {
            gtk_sys::gtk_container_set_focus_child(
                self.as_ref().to_glib_none().0,
                child.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    fn set_focus_hadjustment<P: IsA<Adjustment>>(&self, adjustment: &P) {
        unsafe {
            gtk_sys::gtk_container_set_focus_hadjustment(
                self.as_ref().to_glib_none().0,
                adjustment.as_ref().to_glib_none().0,
            );
        }
    }

    fn set_focus_vadjustment<P: IsA<Adjustment>>(&self, adjustment: &P) {
        unsafe {
            gtk_sys::gtk_container_set_focus_vadjustment(
                self.as_ref().to_glib_none().0,
                adjustment.as_ref().to_glib_none().0,
            );
        }
    }

    fn unset_focus_chain(&self) {
        unsafe {
            gtk_sys::gtk_container_unset_focus_chain(self.as_ref().to_glib_none().0);
        }
    }

    fn set_property_child<P: IsA<Widget> + SetValueOptional>(&self, child: Option<&P>) {
        unsafe {
            gobject_sys::g_object_set_property(
                self.to_glib_none().0 as *mut gobject_sys::GObject,
                b"child\0".as_ptr() as *const _,
                Value::from(child).to_glib_none().0,
            );
        }
    }

    fn get_property_resize_mode(&self) -> ResizeMode {
        unsafe {
            let mut value = Value::from_type(<ResizeMode as StaticType>::static_type());
            gobject_sys::g_object_get_property(
                self.to_glib_none().0 as *mut gobject_sys::GObject,
                b"resize-mode\0".as_ptr() as *const _,
                value.to_glib_none_mut().0,
            );
            value
                .get()
                .expect("Return Value for property `resize-mode` getter")
                .unwrap()
        }
    }

    fn set_property_resize_mode(&self, resize_mode: ResizeMode) {
        unsafe {
            gobject_sys::g_object_set_property(
                self.to_glib_none().0 as *mut gobject_sys::GObject,
                b"resize-mode\0".as_ptr() as *const _,
                Value::from(&resize_mode).to_glib_none().0,
            );
        }
    }

    fn connect_add<F: Fn(&Self, &Widget) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn add_trampoline<P, F: Fn(&P, &Widget) + 'static>(
            this: *mut gtk_sys::GtkContainer,
            object: *mut gtk_sys::GtkWidget,
            f: glib_sys::gpointer,
        ) where
            P: IsA<Container>,
        {
            let f: &F = &*(f as *const F);
            f(
                &Container::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(object),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"add\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    add_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_check_resize<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn check_resize_trampoline<P, F: Fn(&P) + 'static>(
            this: *mut gtk_sys::GtkContainer,
            f: glib_sys::gpointer,
        ) where
            P: IsA<Container>,
        {
            let f: &F = &*(f as *const F);
            f(&Container::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"check-resize\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    check_resize_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_remove<F: Fn(&Self, &Widget) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn remove_trampoline<P, F: Fn(&P, &Widget) + 'static>(
            this: *mut gtk_sys::GtkContainer,
            object: *mut gtk_sys::GtkWidget,
            f: glib_sys::gpointer,
        ) where
            P: IsA<Container>,
        {
            let f: &F = &*(f as *const F);
            f(
                &Container::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(object),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"remove\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    remove_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_set_focus_child<F: Fn(&Self, &Widget) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn set_focus_child_trampoline<P, F: Fn(&P, &Widget) + 'static>(
            this: *mut gtk_sys::GtkContainer,
            object: *mut gtk_sys::GtkWidget,
            f: glib_sys::gpointer,
        ) where
            P: IsA<Container>,
        {
            let f: &F = &*(f as *const F);
            f(
                &Container::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(object),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"set-focus-child\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    set_focus_child_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_property_border_width_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_border_width_trampoline<P, F: Fn(&P) + 'static>(
            this: *mut gtk_sys::GtkContainer,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) where
            P: IsA<Container>,
        {
            let f: &F = &*(f as *const F);
            f(&Container::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::border-width\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_border_width_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_property_child_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_child_trampoline<P, F: Fn(&P) + 'static>(
            this: *mut gtk_sys::GtkContainer,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) where
            P: IsA<Container>,
        {
            let f: &F = &*(f as *const F);
            f(&Container::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::child\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_child_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_property_resize_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_resize_mode_trampoline<P, F: Fn(&P) + 'static>(
            this: *mut gtk_sys::GtkContainer,
            _param_spec: glib_sys::gpointer,
            f: glib_sys::gpointer,
        ) where
            P: IsA<Container>,
        {
            let f: &F = &*(f as *const F);
            f(&Container::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::resize-mode\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_resize_mode_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl fmt::Display for Container {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Container")
    }
}