// 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 crate::{LayoutChild, Orientation, SizeRequestMode, Widget};
use glib::{prelude::*, translate::*};

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 [`layout-manager`][struct@crate::LayoutChild#layout-manager] and
    /// [`child-widget`][struct@crate::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(),
    }
}

impl LayoutManager {
    pub const NONE: Option<&'static LayoutManager> = None;
}

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::LayoutManager>> Sealed for T {}
}

/// 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: IsA<LayoutManager> + sealed::Sealed + '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(&self, widget: &impl IsA<Widget>, 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,
            );
        }
    }

    /// 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(&self, child: &impl IsA<Widget>) -> 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,
            ))
        }
    }

    /// 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 {
        unsafe {
            from_glib(ffi::gtk_layout_manager_get_request_mode(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// 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> {
        unsafe {
            from_glib_none(ffi::gtk_layout_manager_get_widget(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// 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) {
        unsafe {
            ffi::gtk_layout_manager_layout_changed(self.as_ref().to_glib_none().0);
        }
    }

    /// 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(
        &self,
        widget: &impl IsA<Widget>,
        orientation: Orientation,
        for_size: i32,
    ) -> (i32, i32, i32, i32) {
        unsafe {
            let mut minimum = std::mem::MaybeUninit::uninit();
            let mut natural = std::mem::MaybeUninit::uninit();
            let mut minimum_baseline = std::mem::MaybeUninit::uninit();
            let mut natural_baseline = std::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(),
            );
            (
                minimum.assume_init(),
                natural.assume_init(),
                minimum_baseline.assume_init(),
                natural_baseline.assume_init(),
            )
        }
    }
}

impl<O: IsA<LayoutManager>> LayoutManagerExt for O {}