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

use crate::LayoutChild;
use crate::Orientation;
use crate::SizeRequestMode;
use crate::Widget;
use glib::object::IsA;
use glib::translate::*;
use std::fmt;
use std::mem;

glib::wrapper! {
    /// Layout managers are delegate classes that handle the preferred size
    /// and the allocation of a widget.
    ///
    /// You typically subclass [`LayoutManager`][crate::LayoutManager] if you want to implement a
    /// layout policy for the children of a widget, or if you want to determine
    /// the size of a widget depending on its contents.
    ///
    /// Each [`Widget`][crate::Widget] can only have a [`LayoutManager`][crate::LayoutManager] instance associated
    /// to it at any given time; it is possible, though, to replace the layout
    /// manager instance using [``WidgetExt::set_layout_manager()``][crate::prelude::`WidgetExt::set_layout_manager()`].
    ///
    /// ## Layout properties
    ///
    /// A layout manager can expose properties for controlling the layout of
    /// each child, by creating an object type derived from [`LayoutChild`][crate::LayoutChild]
    /// and installing the properties on it as normal `GObject` properties.
    ///
    /// Each [`LayoutChild`][crate::LayoutChild] instance storing the layout properties for a
    /// specific child is created through the [``LayoutManagerExt::layout_child()``][crate::prelude::`LayoutManagerExt::layout_child()`]
    /// method; a [`LayoutManager`][crate::LayoutManager] controls the creation of its [`LayoutChild`][crate::LayoutChild]
    /// instances by overriding the `GtkLayoutManagerClass.create_layout_child()`
    /// virtual function. The typical implementation should look like:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// static GtkLayoutChild *
    /// create_layout_child (GtkLayoutManager *manager,
    ///                      GtkWidget        *container,
    ///                      GtkWidget        *child)
    /// {
    ///   return g_object_new (your_layout_child_get_type (),
    ///                        "layout-manager", manager,
    ///                        "child-widget", child,
    ///                        NULL);
    /// }
    /// ```
    ///
    /// The `property::LayoutChild::layout-manager` and
    /// `property::LayoutChild::child-widget` properties
    /// on the newly created [`LayoutChild`][crate::LayoutChild] instance are mandatory. The
    /// [`LayoutManager`][crate::LayoutManager] will cache the newly created [`LayoutChild`][crate::LayoutChild] instance
    /// until the widget is removed from its parent, or the parent removes the
    /// layout manager.
    ///
    /// Each [`LayoutManager`][crate::LayoutManager] instance creating a [`LayoutChild`][crate::LayoutChild] should use
    /// [``LayoutManagerExt::layout_child()``][crate::prelude::`LayoutManagerExt::layout_child()`] every time it needs to query
    /// the layout properties; each [`LayoutChild`][crate::LayoutChild] instance should call
    /// [``LayoutManagerExt::layout_changed()``][crate::prelude::`LayoutManagerExt::layout_changed()`] every time a property is
    /// updated, in order to queue a new size measuring and allocation.
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    ///
    /// # Implements
    ///
    /// [`LayoutManagerExt`][trait@crate::prelude::LayoutManagerExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "GtkLayoutManager")]
    pub struct LayoutManager(Object<ffi::GtkLayoutManager, ffi::GtkLayoutManagerClass>);

    match fn {
        type_ => || ffi::gtk_layout_manager_get_type(),
    }
}

pub const NONE_LAYOUT_MANAGER: Option<&LayoutManager> = None;

/// Trait containing all [`struct@LayoutManager`] methods.
///
/// # Implementors
///
/// [`BinLayout`][struct@crate::BinLayout], [`BoxLayout`][struct@crate::BoxLayout], [`CenterLayout`][struct@crate::CenterLayout], [`ConstraintLayout`][struct@crate::ConstraintLayout], [`FixedLayout`][struct@crate::FixedLayout], [`GridLayout`][struct@crate::GridLayout], [`LayoutManager`][struct@crate::LayoutManager], [`OverlayLayout`][struct@crate::OverlayLayout]
pub trait LayoutManagerExt: 'static {
    /// Assigns the given `width`, `height`, and `baseline` to
    /// a `widget`, and computes the position and sizes of the children of
    /// the `widget` using the layout management policy of `self`.
    /// ## `widget`
    /// the [`Widget`][crate::Widget] using `self`
    /// ## `width`
    /// the new width of the `widget`
    /// ## `height`
    /// the new height of the `widget`
    /// ## `baseline`
    /// the baseline position of the `widget`, or -1
    #[doc(alias = "gtk_layout_manager_allocate")]
    fn allocate<P: IsA<Widget>>(&self, widget: &P, width: i32, height: i32, baseline: i32);

    /// Retrieves a [`LayoutChild`][crate::LayoutChild] instance for the [`LayoutManager`][crate::LayoutManager],
    /// creating one if necessary.
    ///
    /// The `child` widget must be a child of the widget using `self`.
    ///
    /// The [`LayoutChild`][crate::LayoutChild] instance is owned by the [`LayoutManager`][crate::LayoutManager],
    /// and is guaranteed to exist as long as `child` is a child of the
    /// [`Widget`][crate::Widget] using the given [`LayoutManager`][crate::LayoutManager].
    /// ## `child`
    /// a [`Widget`][crate::Widget]
    ///
    /// # Returns
    ///
    /// a [`LayoutChild`][crate::LayoutChild]
    #[doc(alias = "gtk_layout_manager_get_layout_child")]
    #[doc(alias = "get_layout_child")]
    fn layout_child<P: IsA<Widget>>(&self, child: &P) -> Option<LayoutChild>;

    /// Retrieves the request mode of `self`.
    ///
    /// # Returns
    ///
    /// a [`SizeRequestMode`][crate::SizeRequestMode]
    #[doc(alias = "gtk_layout_manager_get_request_mode")]
    #[doc(alias = "get_request_mode")]
    fn request_mode(&self) -> SizeRequestMode;

    /// Retrieves the [`Widget`][crate::Widget] using the given [`LayoutManager`][crate::LayoutManager].
    ///
    /// # Returns
    ///
    /// a [`Widget`][crate::Widget]
    #[doc(alias = "gtk_layout_manager_get_widget")]
    #[doc(alias = "get_widget")]
    fn widget(&self) -> Option<Widget>;

    /// Queues a resize on the [`Widget`][crate::Widget] using `self`, if any.
    ///
    /// This function should be called by subclasses of [`LayoutManager`][crate::LayoutManager]
    /// in response to changes to their layout management policies.
    #[doc(alias = "gtk_layout_manager_layout_changed")]
    fn layout_changed(&self);

    /// Measures the size of the `widget` using `self`, for the
    /// given `orientation` and size.
    ///
    /// See the [`Widget`][crate::Widget] documentation on layout management for
    /// more details.
    /// ## `widget`
    /// the [`Widget`][crate::Widget] using `self`
    /// ## `orientation`
    /// the orientation to measure
    /// ## `for_size`
    /// Size for the opposite of `orientation`; for instance, if
    ///  the `orientation` is [`Orientation::Horizontal`][crate::Orientation::Horizontal], this is the height
    ///  of the widget; if the `orientation` is [`Orientation::Vertical`][crate::Orientation::Vertical], this
    ///  is the width of the widget. This allows to measure the height for the
    ///  given width, and the width for the given height. Use -1 if the size
    ///  is not known
    ///
    /// # Returns
    ///
    ///
    /// ## `minimum`
    /// the minimum size for the given size and
    ///  orientation
    ///
    /// ## `natural`
    /// the natural, or preferred size for the
    ///  given size and orientation
    ///
    /// ## `minimum_baseline`
    /// the baseline position for the
    ///  minimum size
    ///
    /// ## `natural_baseline`
    /// the baseline position for the
    ///  natural size
    #[doc(alias = "gtk_layout_manager_measure")]
    fn measure<P: IsA<Widget>>(
        &self,
        widget: &P,
        orientation: Orientation,
        for_size: i32,
    ) -> (i32, i32, i32, i32);
}

impl<O: IsA<LayoutManager>> LayoutManagerExt for O {
    fn allocate<P: IsA<Widget>>(&self, widget: &P, width: i32, height: i32, baseline: i32) {
        unsafe {
            ffi::gtk_layout_manager_allocate(
                self.as_ref().to_glib_none().0,
                widget.as_ref().to_glib_none().0,
                width,
                height,
                baseline,
            );
        }
    }

    fn layout_child<P: IsA<Widget>>(&self, child: &P) -> Option<LayoutChild> {
        unsafe {
            from_glib_none(ffi::gtk_layout_manager_get_layout_child(
                self.as_ref().to_glib_none().0,
                child.as_ref().to_glib_none().0,
            ))
        }
    }

    fn request_mode(&self) -> SizeRequestMode {
        unsafe {
            from_glib(ffi::gtk_layout_manager_get_request_mode(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn widget(&self) -> Option<Widget> {
        unsafe {
            from_glib_none(ffi::gtk_layout_manager_get_widget(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn layout_changed(&self) {
        unsafe {
            ffi::gtk_layout_manager_layout_changed(self.as_ref().to_glib_none().0);
        }
    }

    fn measure<P: IsA<Widget>>(
        &self,
        widget: &P,
        orientation: Orientation,
        for_size: i32,
    ) -> (i32, i32, i32, i32) {
        unsafe {
            let mut minimum = mem::MaybeUninit::uninit();
            let mut natural = mem::MaybeUninit::uninit();
            let mut minimum_baseline = mem::MaybeUninit::uninit();
            let mut natural_baseline = mem::MaybeUninit::uninit();
            ffi::gtk_layout_manager_measure(
                self.as_ref().to_glib_none().0,
                widget.as_ref().to_glib_none().0,
                orientation.into_glib(),
                for_size,
                minimum.as_mut_ptr(),
                natural.as_mut_ptr(),
                minimum_baseline.as_mut_ptr(),
                natural_baseline.as_mut_ptr(),
            );
            let minimum = minimum.assume_init();
            let natural = natural.assume_init();
            let minimum_baseline = minimum_baseline.assume_init();
            let natural_baseline = natural_baseline.assume_init();
            (minimum, natural, minimum_baseline, natural_baseline)
        }
    }
}

impl fmt::Display for LayoutManager {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("LayoutManager")
    }
}