gtk/subclass/

container.rs

// Take a look at the license at the top of the repository in the LICENSE file.

use std::ptr;

use glib::{ParamSpec, Value, gobject_ffi, translate::*};

use glib::object::IsA;
use glib::subclass::prelude::*;

use glib::object::Cast;

use super::widget::WidgetImpl;
use crate::Widget;
use crate::WidgetPath;
use crate::{Container, ffi};

pub trait ContainerImpl: WidgetImpl + ObjectSubclass<Type: IsA<Container>> {
    // rustdoc-stripper-ignore-next
    /// Child properties installed for this type.
    ///
    /// Override and return an array of [`ParamSpec`] to register new child properties on your
    /// subclass.
    fn child_properties() -> &'static [ParamSpec] {
        &[]
    }

    /// Adds `widget` to `container`. Typically used for simple containers
    /// such as [`Window`][crate::Window], [`Frame`][crate::Frame], or [`Button`][crate::Button]; for more complicated
    /// layout containers such as [`Box`][crate::Box] or [`Grid`][crate::Grid], this function will
    /// pick default packing parameters that may not be correct. So
    /// consider functions such as [`BoxExt::pack_start()`][crate::prelude::BoxExt::pack_start()] and
    /// [`GridExt::attach()`][crate::prelude::GridExt::attach()] as an alternative to [`ContainerExt::add()`][crate::prelude::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`][crate::ScrolledWindow] or [`ListBox`][crate::ListBox],
    /// may add intermediate children between the added widget and the
    /// container.
    /// ## `widget`
    /// a widget to be placed inside `container`
    fn add(&self, widget: &Widget) {
        self.parent_add(widget)
    }

    /// Removes `widget` from `container`. `widget` must be inside `container`.
    /// Note that `container` 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 `g_object_ref()`. If you don’t want to use `widget`
    /// again it’s usually more efficient to simply destroy it directly
    /// using `gtk_widget_destroy()` since this will remove it from the
    /// container and help break any circular reference count cycles.
    /// ## `widget`
    /// a current child of `container`
    fn remove(&self, widget: &Widget) {
        self.parent_remove(widget)
    }

    /// Signal emitted when a size recalculation is needed.
    fn check_resize(&self) {
        self.parent_check_resize()
    }

    /// Sets, or unsets if `child` is [`None`], the focused child of `container`.
    ///
    /// This function emits the GtkContainer::set_focus_child signal of
    /// `container`. Implementations of [`Container`][crate::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()`][crate::prelude::WidgetExt::grab_focus()] to manually set the focus to a specific widget.
    /// ## `child`
    /// a [`Widget`][crate::Widget], or [`None`]
    fn set_focus_child(&self, widget: Option<&Widget>) {
        self.parent_set_focus_child(widget)
    }

    /// 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`][crate::Paned] which already has two
    /// children.
    ///
    /// # Returns
    ///
    /// a `GType`.
    fn child_type(&self) -> glib::Type {
        self.parent_child_type()
    }

    /// Returns a newly created widget path representing all the widget hierarchy
    /// from the toplevel down to and including `child`.
    /// ## `child`
    /// a child of `container`
    ///
    /// # Returns
    ///
    /// A newly created [`WidgetPath`][crate::WidgetPath]
    #[doc(alias = "get_path_for_child")]
    fn path_for_child(&self, widget: &Widget) -> WidgetPath {
        self.parent_path_for_child(widget)
    }

    /// Invokes `callback` on each direct child of `container`, 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()`][crate::prelude::ContainerExt::foreach()], rather
    /// than [`ContainerExt::forall()`][crate::prelude::ContainerExt::forall()].
    /// ## `callback`
    /// a callback
    /// ## `callback_data`
    /// callback user data
    fn forall(&self, include_internals: bool, callback: &Callback) {
        self.parent_forall(include_internals, callback);
    }

    /// Set a property on a child of container.
    fn set_child_property(&self, _child: &Widget, _id: usize, _value: &Value, _pspec: &ParamSpec) {
        unimplemented!()
    }

    /// Get a property from a child of container.
    #[doc(alias = "get_child_property")]
    fn child_property(&self, _child: &Widget, _id: usize, _pspec: &ParamSpec) -> Value {
        unimplemented!()
    }
}

pub trait ContainerImplExt: ContainerImpl {
    fn parent_add(&self, widget: &Widget) {
        unsafe {
            let data = Self::type_data();
            let parent_class = data.as_ref().parent_class() as *mut ffi::GtkContainerClass;
            if let Some(f) = (*parent_class).add {
                f(
                    self.obj().unsafe_cast_ref::<Container>().to_glib_none().0,
                    widget.to_glib_none().0,
                )
            }
        }
    }
    fn parent_remove(&self, widget: &Widget) {
        unsafe {
            let data = Self::type_data();
            let parent_class = data.as_ref().parent_class() as *mut ffi::GtkContainerClass;
            if let Some(f) = (*parent_class).remove {
                f(
                    self.obj().unsafe_cast_ref::<Container>().to_glib_none().0,
                    widget.to_glib_none().0,
                )
            }
        }
    }
    fn parent_check_resize(&self) {
        unsafe {
            let data = Self::type_data();
            let parent_class = data.as_ref().parent_class() as *mut ffi::GtkContainerClass;
            if let Some(f) = (*parent_class).check_resize {
                f(self.obj().unsafe_cast_ref::<Container>().to_glib_none().0)
            }
        }
    }
    fn parent_set_focus_child(&self, widget: Option<&Widget>) {
        unsafe {
            let data = Self::type_data();
            let parent_class = data.as_ref().parent_class() as *mut ffi::GtkContainerClass;
            if let Some(f) = (*parent_class).set_focus_child {
                f(
                    self.obj().unsafe_cast_ref::<Container>().to_glib_none().0,
                    widget.to_glib_none().0,
                )
            }
        }
    }
    fn parent_child_type(&self) -> glib::Type {
        unsafe {
            let data = Self::type_data();
            let parent_class = data.as_ref().parent_class() as *mut ffi::GtkContainerClass;
            if let Some(f) = (*parent_class).child_type {
                from_glib(f(self
                    .obj()
                    .unsafe_cast_ref::<Container>()
                    .to_glib_none()
                    .0))
            } else {
                glib::Type::UNIT
            }
        }
    }
    fn parent_path_for_child(&self, widget: &Widget) -> WidgetPath {
        unsafe {
            let data = Self::type_data();
            let parent_class = data.as_ref().parent_class() as *mut ffi::GtkContainerClass;
            let f = (*parent_class)
                .get_path_for_child
                .expect("No parent class impl for \"get_path_for_child\"");
            from_glib_none(f(
                self.obj().unsafe_cast_ref::<Container>().to_glib_none().0,
                widget.to_glib_none().0,
            ))
        }
    }
    fn parent_forall(&self, include_internals: bool, callback: &Callback) {
        unsafe {
            let data = Self::type_data();
            let parent_class = data.as_ref().parent_class() as *mut ffi::GtkContainerClass;
            if let Some(f) = (*parent_class).forall {
                f(
                    self.obj().unsafe_cast_ref::<Container>().to_glib_none().0,
                    include_internals.into_glib(),
                    callback.callback,
                    callback.user_data,
                )
            }
        }
    }
}

impl<T: ContainerImpl> ContainerImplExt for T {}

unsafe impl<T: ContainerImpl> IsSubclassable<T> for Container {
    fn class_init(class: &mut ::glib::Class<Self>) {
        Self::parent_class_init::<T>(class);

        if !crate::rt::is_initialized() {
            panic!("GTK has to be initialized first");
        }

        let klass = class.as_mut();
        klass.add = Some(container_add::<T>);
        klass.remove = Some(container_remove::<T>);
        klass.check_resize = Some(container_check_resize::<T>);
        klass.set_focus_child = Some(container_set_focus_child::<T>);
        klass.child_type = Some(container_child_type::<T>);
        klass.get_path_for_child = Some(container_get_path_for_child::<T>);
        klass.forall = Some(container_forall::<T>);
        klass.set_child_property = Some(container_set_child_property::<T>);
        klass.get_child_property = Some(container_get_child_property::<T>);

        let pspecs = <T as ContainerImpl>::child_properties();
        if !pspecs.is_empty() {
            unsafe {
                let mut pspecs_ptrs = std::iter::once(ptr::null_mut())
                    .chain(pspecs.iter().map(|pspec| pspec.to_glib_none().0))
                    .collect::<Vec<_>>();
                ffi::gtk_container_class_install_child_properties(
                    klass,
                    pspecs_ptrs.len() as u32,
                    pspecs_ptrs.as_mut_ptr(),
                );
            }
        }
    }
}

unsafe extern "C" fn container_add<T: ContainerImpl>(
    ptr: *mut ffi::GtkContainer,
    wdgtptr: *mut ffi::GtkWidget,
) {
    unsafe {
        let instance = &*(ptr as *mut T::Instance);
        let imp = instance.imp();
        let widget: Borrowed<Widget> = from_glib_borrow(wdgtptr);

        imp.add(&widget)
    }
}

unsafe extern "C" fn container_remove<T: ContainerImpl>(
    ptr: *mut ffi::GtkContainer,
    wdgtptr: *mut ffi::GtkWidget,
) {
    unsafe {
        let instance = &*(ptr as *mut T::Instance);
        let imp = instance.imp();
        let widget: Borrowed<Widget> = from_glib_borrow(wdgtptr);

        imp.remove(&widget)
    }
}

unsafe extern "C" fn container_check_resize<T: ContainerImpl>(ptr: *mut ffi::GtkContainer) {
    unsafe {
        let instance = &*(ptr as *mut T::Instance);
        let imp = instance.imp();

        imp.check_resize()
    }
}

unsafe extern "C" fn container_set_focus_child<T: ContainerImpl>(
    ptr: *mut ffi::GtkContainer,
    wdgtptr: *mut ffi::GtkWidget,
) {
    unsafe {
        let instance = &*(ptr as *mut T::Instance);
        let imp = instance.imp();
        let widget: Borrowed<Option<Widget>> = from_glib_borrow(wdgtptr);

        imp.set_focus_child(widget.as_ref().as_ref())
    }
}

unsafe extern "C" fn container_child_type<T: ContainerImpl>(
    ptr: *mut ffi::GtkContainer,
) -> glib::ffi::GType {
    unsafe {
        let instance = &*(ptr as *mut T::Instance);
        let imp = instance.imp();

        imp.child_type().into_glib()
    }
}

unsafe extern "C" fn container_get_path_for_child<T: ContainerImpl>(
    ptr: *mut ffi::GtkContainer,
    wdgtptr: *mut ffi::GtkWidget,
) -> *mut ffi::GtkWidgetPath {
    unsafe {
        let instance = &*(ptr as *mut T::Instance);
        let imp = instance.imp();
        let widget: Borrowed<Widget> = from_glib_borrow(wdgtptr);

        imp.path_for_child(&widget).to_glib_none().0
    }
}

unsafe extern "C" fn container_forall<T>(
    ptr: *mut ffi::GtkContainer,
    include_internals: glib::ffi::gboolean,
    callback: ffi::GtkCallback,
    user_data: glib::ffi::gpointer,
) where
    T: ObjectSubclass + ContainerImpl,
{
    unsafe {
        let instance = &*(ptr as *mut T::Instance);
        let imp = instance.imp();
        let callback = Callback {
            callback,
            user_data,
        };

        imp.forall(from_glib(include_internals), &callback)
    }
}

unsafe extern "C" fn container_set_child_property<T: ContainerImpl>(
    ptr: *mut ffi::GtkContainer,
    childptr: *mut ffi::GtkWidget,
    property_id: libc::c_uint,
    valueptr: *mut gobject_ffi::GValue,
    pspecptr: *mut gobject_ffi::GParamSpec,
) {
    unsafe {
        let instance = &*(ptr as *mut T::Instance);
        let imp = instance.imp();
        let child: Borrowed<Widget> = from_glib_borrow(childptr);
        let value: Borrowed<glib::Value> = from_glib_borrow(valueptr);
        let pspec: Borrowed<ParamSpec> = from_glib_borrow(pspecptr);

        imp.set_child_property(&child, property_id as usize, &value, &pspec);
    }
}

unsafe extern "C" fn container_get_child_property<T: ContainerImpl>(
    ptr: *mut ffi::GtkContainer,
    childptr: *mut ffi::GtkWidget,
    property_id: libc::c_uint,
    valueptr: *mut gobject_ffi::GValue,
    pspecptr: *mut gobject_ffi::GParamSpec,
) {
    unsafe {
        let instance = &*(ptr as *mut T::Instance);
        let imp = instance.imp();
        let child: Borrowed<Widget> = from_glib_borrow(childptr);
        let pspec: Borrowed<ParamSpec> = from_glib_borrow(pspecptr);

        let v = imp.child_property(&child, property_id as usize, &pspec);

        // Unset first just in case there's anything in there already.
        gobject_ffi::g_value_unset(valueptr);
        // Then consume `v` and transfer ownership of its bits to `valueptr`.
        std::ptr::write(valueptr, v.into_raw());
    }
}

#[derive(Debug)]
pub struct Callback {
    callback: ffi::GtkCallback,
    user_data: glib::ffi::gpointer,
}

impl Callback {
    pub fn call(&self, widget: &Widget) {
        unsafe {
            if let Some(callback) = self.callback {
                callback(widget.to_glib_none().0, self.user_data);
            }
        }
    }
}

pub unsafe trait ContainerClassSubclassExt: ClassStruct {
    #[doc(alias = "gtk_container_class_handle_border_width")]
    fn handle_border_width(&mut self) {
        unsafe {
            let widget_class = self as *mut _ as *mut ffi::GtkContainerClass;
            ffi::gtk_container_class_handle_border_width(widget_class);
        }
    }
}

unsafe impl<T: ClassStruct> ContainerClassSubclassExt for T where T::Type: ContainerImpl {}