gtk/auto/

cell_area_context.rs

// 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::CellArea;
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, fmt, mem, mem::transmute};

glib::wrapper! {
    /// The [`CellAreaContext`][crate::CellAreaContext] object is created by a given [`CellArea`][crate::CellArea]
    /// implementation via its `GtkCellAreaClass.create_context()` virtual
    /// method and is used to store cell sizes and alignments for a series of
    /// [`TreeModel`][crate::TreeModel] rows that are requested and rendered in the same context.
    ///
    /// [`CellLayout`][crate::CellLayout] widgets can create any number of contexts in which to
    /// request and render groups of data rows. However, it’s important that the
    /// same context which was used to request sizes for a given [`TreeModel`][crate::TreeModel]
    /// row also be used for the same row when calling other [`CellArea`][crate::CellArea] APIs
    /// such as [`CellAreaExt::render()`][crate::prelude::CellAreaExt::render()] and [`CellAreaExt::event()`][crate::prelude::CellAreaExt::event()].
    ///
    /// ## Properties
    ///
    ///
    /// #### `area`
    ///  The [`CellArea`][crate::CellArea] this context was created by
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `minimum-height`
    ///  The minimum height for the [`CellArea`][crate::CellArea] in this context
    /// for all [`TreeModel`][crate::TreeModel] rows that this context was requested
    /// for using [`CellAreaExt::preferred_height()`][crate::prelude::CellAreaExt::preferred_height()].
    ///
    /// Readable
    ///
    ///
    /// #### `minimum-width`
    ///  The minimum width for the [`CellArea`][crate::CellArea] in this context
    /// for all [`TreeModel`][crate::TreeModel] rows that this context was requested
    /// for using [`CellAreaExt::preferred_width()`][crate::prelude::CellAreaExt::preferred_width()].
    ///
    /// Readable
    ///
    ///
    /// #### `natural-height`
    ///  The natural height for the [`CellArea`][crate::CellArea] in this context
    /// for all [`TreeModel`][crate::TreeModel] rows that this context was requested
    /// for using [`CellAreaExt::preferred_height()`][crate::prelude::CellAreaExt::preferred_height()].
    ///
    /// Readable
    ///
    ///
    /// #### `natural-width`
    ///  The natural width for the [`CellArea`][crate::CellArea] in this context
    /// for all [`TreeModel`][crate::TreeModel] rows that this context was requested
    /// for using [`CellAreaExt::preferred_width()`][crate::prelude::CellAreaExt::preferred_width()].
    ///
    /// Readable
    ///
    /// # Implements
    ///
    /// [`CellAreaContextExt`][trait@crate::prelude::CellAreaContextExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "GtkCellAreaContext")]
    pub struct CellAreaContext(Object<ffi::GtkCellAreaContext, ffi::GtkCellAreaContextClass>);

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

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

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

/// Trait containing all [`struct@CellAreaContext`] methods.
///
/// # Implementors
///
/// [`CellAreaContext`][struct@crate::CellAreaContext]
pub trait CellAreaContextExt: IsA<CellAreaContext> + sealed::Sealed + 'static {
    /// Allocates a width and/or a height for all rows which are to be
    /// rendered with `self`.
    ///
    /// Usually allocation is performed only horizontally or sometimes
    /// vertically since a group of rows are usually rendered side by
    /// side vertically or horizontally and share either the same width
    /// or the same height. Sometimes they are allocated in both horizontal
    /// and vertical orientations producing a homogeneous effect of the
    /// rows. This is generally the case for [`TreeView`][crate::TreeView] when
    /// [`fixed-height-mode`][struct@crate::TreeView#fixed-height-mode] is enabled.
    ///
    /// Since 3.0
    /// ## `width`
    /// the allocated width for all [`TreeModel`][crate::TreeModel] rows rendered
    ///  with `self`, or -1.
    /// ## `height`
    /// the allocated height for all [`TreeModel`][crate::TreeModel] rows rendered
    ///  with `self`, or -1.
    #[doc(alias = "gtk_cell_area_context_allocate")]
    fn allocate(&self, width: i32, height: i32) {
        unsafe {
            ffi::gtk_cell_area_context_allocate(self.as_ref().to_glib_none().0, width, height);
        }
    }

    /// Fetches the current allocation size for `self`.
    ///
    /// If the context was not allocated in width or height, or if the
    /// context was recently reset with [`reset()`][Self::reset()],
    /// the returned value will be -1.
    ///
    /// # Returns
    ///
    ///
    /// ## `width`
    /// location to store the allocated width, or [`None`]
    ///
    /// ## `height`
    /// location to store the allocated height, or [`None`]
    #[doc(alias = "gtk_cell_area_context_get_allocation")]
    #[doc(alias = "get_allocation")]
    fn allocation(&self) -> (i32, i32) {
        unsafe {
            let mut width = mem::MaybeUninit::uninit();
            let mut height = mem::MaybeUninit::uninit();
            ffi::gtk_cell_area_context_get_allocation(
                self.as_ref().to_glib_none().0,
                width.as_mut_ptr(),
                height.as_mut_ptr(),
            );
            (width.assume_init(), height.assume_init())
        }
    }

    /// Fetches the [`CellArea`][crate::CellArea] this `self` was created by.
    ///
    /// This is generally unneeded by layouting widgets; however,
    /// it is important for the context implementation itself to
    /// fetch information about the area it is being used for.
    ///
    /// For instance at `GtkCellAreaContextClass.allocate()` time
    /// it’s important to know details about any cell spacing
    /// that the [`CellArea`][crate::CellArea] is configured with in order to
    /// compute a proper allocation.
    ///
    /// # Returns
    ///
    /// the [`CellArea`][crate::CellArea] this context was created by.
    #[doc(alias = "gtk_cell_area_context_get_area")]
    #[doc(alias = "get_area")]
    fn area(&self) -> Option<CellArea> {
        unsafe {
            from_glib_none(ffi::gtk_cell_area_context_get_area(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the accumulative preferred height for all rows which have been
    /// requested with this context.
    ///
    /// After [`reset()`][Self::reset()] is called and/or before ever
    /// requesting the size of a [`CellArea`][crate::CellArea], the returned values are 0.
    ///
    /// # Returns
    ///
    ///
    /// ## `minimum_height`
    /// location to store the minimum height,
    ///  or [`None`]
    ///
    /// ## `natural_height`
    /// location to store the natural height,
    ///  or [`None`]
    #[doc(alias = "gtk_cell_area_context_get_preferred_height")]
    #[doc(alias = "get_preferred_height")]
    fn preferred_height(&self) -> (i32, i32) {
        unsafe {
            let mut minimum_height = mem::MaybeUninit::uninit();
            let mut natural_height = mem::MaybeUninit::uninit();
            ffi::gtk_cell_area_context_get_preferred_height(
                self.as_ref().to_glib_none().0,
                minimum_height.as_mut_ptr(),
                natural_height.as_mut_ptr(),
            );
            (minimum_height.assume_init(), natural_height.assume_init())
        }
    }

    /// Gets the accumulative preferred height for `width` for all rows
    /// which have been requested for the same said `width` with this context.
    ///
    /// After [`reset()`][Self::reset()] is called and/or before ever
    /// requesting the size of a [`CellArea`][crate::CellArea], the returned values are -1.
    /// ## `width`
    /// a proposed width for allocation
    ///
    /// # Returns
    ///
    ///
    /// ## `minimum_height`
    /// location to store the minimum height,
    ///  or [`None`]
    ///
    /// ## `natural_height`
    /// location to store the natural height,
    ///  or [`None`]
    #[doc(alias = "gtk_cell_area_context_get_preferred_height_for_width")]
    #[doc(alias = "get_preferred_height_for_width")]
    fn preferred_height_for_width(&self, width: i32) -> (i32, i32) {
        unsafe {
            let mut minimum_height = mem::MaybeUninit::uninit();
            let mut natural_height = mem::MaybeUninit::uninit();
            ffi::gtk_cell_area_context_get_preferred_height_for_width(
                self.as_ref().to_glib_none().0,
                width,
                minimum_height.as_mut_ptr(),
                natural_height.as_mut_ptr(),
            );
            (minimum_height.assume_init(), natural_height.assume_init())
        }
    }

    /// Gets the accumulative preferred width for all rows which have been
    /// requested with this context.
    ///
    /// After [`reset()`][Self::reset()] is called and/or before ever
    /// requesting the size of a [`CellArea`][crate::CellArea], the returned values are 0.
    ///
    /// # Returns
    ///
    ///
    /// ## `minimum_width`
    /// location to store the minimum width,
    ///  or [`None`]
    ///
    /// ## `natural_width`
    /// location to store the natural width,
    ///  or [`None`]
    #[doc(alias = "gtk_cell_area_context_get_preferred_width")]
    #[doc(alias = "get_preferred_width")]
    fn preferred_width(&self) -> (i32, i32) {
        unsafe {
            let mut minimum_width = mem::MaybeUninit::uninit();
            let mut natural_width = mem::MaybeUninit::uninit();
            ffi::gtk_cell_area_context_get_preferred_width(
                self.as_ref().to_glib_none().0,
                minimum_width.as_mut_ptr(),
                natural_width.as_mut_ptr(),
            );
            (minimum_width.assume_init(), natural_width.assume_init())
        }
    }

    /// Gets the accumulative preferred width for `height` for all rows which
    /// have been requested for the same said `height` with this context.
    ///
    /// After [`reset()`][Self::reset()] is called and/or before ever
    /// requesting the size of a [`CellArea`][crate::CellArea], the returned values are -1.
    /// ## `height`
    /// a proposed height for allocation
    ///
    /// # Returns
    ///
    ///
    /// ## `minimum_width`
    /// location to store the minimum width,
    ///  or [`None`]
    ///
    /// ## `natural_width`
    /// location to store the natural width,
    ///  or [`None`]
    #[doc(alias = "gtk_cell_area_context_get_preferred_width_for_height")]
    #[doc(alias = "get_preferred_width_for_height")]
    fn preferred_width_for_height(&self, height: i32) -> (i32, i32) {
        unsafe {
            let mut minimum_width = mem::MaybeUninit::uninit();
            let mut natural_width = mem::MaybeUninit::uninit();
            ffi::gtk_cell_area_context_get_preferred_width_for_height(
                self.as_ref().to_glib_none().0,
                height,
                minimum_width.as_mut_ptr(),
                natural_width.as_mut_ptr(),
            );
            (minimum_width.assume_init(), natural_width.assume_init())
        }
    }

    /// Causes the minimum and/or natural height to grow if the new
    /// proposed sizes exceed the current minimum and natural height.
    ///
    /// This is used by [`CellAreaContext`][crate::CellAreaContext] implementations during
    /// the request process over a series of [`TreeModel`][crate::TreeModel] rows to
    /// progressively push the requested height over a series of
    /// [`CellAreaExt::preferred_height()`][crate::prelude::CellAreaExt::preferred_height()] requests.
    /// ## `minimum_height`
    /// the proposed new minimum height for `self`
    /// ## `natural_height`
    /// the proposed new natural height for `self`
    #[doc(alias = "gtk_cell_area_context_push_preferred_height")]
    fn push_preferred_height(&self, minimum_height: i32, natural_height: i32) {
        unsafe {
            ffi::gtk_cell_area_context_push_preferred_height(
                self.as_ref().to_glib_none().0,
                minimum_height,
                natural_height,
            );
        }
    }

    /// Causes the minimum and/or natural width to grow if the new
    /// proposed sizes exceed the current minimum and natural width.
    ///
    /// This is used by [`CellAreaContext`][crate::CellAreaContext] implementations during
    /// the request process over a series of [`TreeModel`][crate::TreeModel] rows to
    /// progressively push the requested width over a series of
    /// [`CellAreaExt::preferred_width()`][crate::prelude::CellAreaExt::preferred_width()] requests.
    /// ## `minimum_width`
    /// the proposed new minimum width for `self`
    /// ## `natural_width`
    /// the proposed new natural width for `self`
    #[doc(alias = "gtk_cell_area_context_push_preferred_width")]
    fn push_preferred_width(&self, minimum_width: i32, natural_width: i32) {
        unsafe {
            ffi::gtk_cell_area_context_push_preferred_width(
                self.as_ref().to_glib_none().0,
                minimum_width,
                natural_width,
            );
        }
    }

    /// Resets any previously cached request and allocation
    /// data.
    ///
    /// When underlying [`TreeModel`][crate::TreeModel] data changes its
    /// important to reset the context if the content
    /// size is allowed to shrink. If the content size
    /// is only allowed to grow (this is usually an option
    /// for views rendering large data stores as a measure
    /// of optimization), then only the row that changed
    /// or was inserted needs to be (re)requested with
    /// [`CellAreaExt::preferred_width()`][crate::prelude::CellAreaExt::preferred_width()].
    ///
    /// When the new overall size of the context requires
    /// that the allocated size changes (or whenever this
    /// allocation changes at all), the variable row
    /// sizes need to be re-requested for every row.
    ///
    /// For instance, if the rows are displayed all with
    /// the same width from top to bottom then a change
    /// in the allocated width necessitates a recalculation
    /// of all the displayed row heights using
    /// [`CellAreaExt::preferred_height_for_width()`][crate::prelude::CellAreaExt::preferred_height_for_width()].
    ///
    /// Since 3.0
    #[doc(alias = "gtk_cell_area_context_reset")]
    fn reset(&self) {
        unsafe {
            ffi::gtk_cell_area_context_reset(self.as_ref().to_glib_none().0);
        }
    }

    /// The minimum height for the [`CellArea`][crate::CellArea] in this context
    /// for all [`TreeModel`][crate::TreeModel] rows that this context was requested
    /// for using [`CellAreaExt::preferred_height()`][crate::prelude::CellAreaExt::preferred_height()].
    #[doc(alias = "minimum-height")]
    fn minimum_height(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "minimum-height")
    }

    /// The minimum width for the [`CellArea`][crate::CellArea] in this context
    /// for all [`TreeModel`][crate::TreeModel] rows that this context was requested
    /// for using [`CellAreaExt::preferred_width()`][crate::prelude::CellAreaExt::preferred_width()].
    #[doc(alias = "minimum-width")]
    fn minimum_width(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "minimum-width")
    }

    /// The natural height for the [`CellArea`][crate::CellArea] in this context
    /// for all [`TreeModel`][crate::TreeModel] rows that this context was requested
    /// for using [`CellAreaExt::preferred_height()`][crate::prelude::CellAreaExt::preferred_height()].
    #[doc(alias = "natural-height")]
    fn natural_height(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "natural-height")
    }

    /// The natural width for the [`CellArea`][crate::CellArea] in this context
    /// for all [`TreeModel`][crate::TreeModel] rows that this context was requested
    /// for using [`CellAreaExt::preferred_width()`][crate::prelude::CellAreaExt::preferred_width()].
    #[doc(alias = "natural-width")]
    fn natural_width(&self) -> i32 {
        ObjectExt::property(self.as_ref(), "natural-width")
    }

    #[doc(alias = "minimum-height")]
    fn connect_minimum_height_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_minimum_height_trampoline<
            P: IsA<CellAreaContext>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkCellAreaContext,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(CellAreaContext::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::minimum-height\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_minimum_height_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "minimum-width")]
    fn connect_minimum_width_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_minimum_width_trampoline<
            P: IsA<CellAreaContext>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkCellAreaContext,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(CellAreaContext::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::minimum-width\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_minimum_width_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "natural-height")]
    fn connect_natural_height_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_natural_height_trampoline<
            P: IsA<CellAreaContext>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkCellAreaContext,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(CellAreaContext::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::natural-height\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_natural_height_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "natural-width")]
    fn connect_natural_width_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_natural_width_trampoline<
            P: IsA<CellAreaContext>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkCellAreaContext,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(CellAreaContext::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::natural-width\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_natural_width_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<CellAreaContext>> CellAreaContextExt for O {}

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