gtk4/

notebook.rs

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

use glib::translate::*;
use libc::c_int;

use crate::{Notebook, Widget, ffi, prelude::*};

impl Notebook {
    /// Appends a page to @self.
    /// ## `child`
    /// the [`Widget`][crate::Widget] to use as the contents of the page
    /// ## `tab_label`
    /// page N
    ///
    /// # Returns
    ///
    /// the index (starting from 0) of the appended
    ///   page in the notebook, or -1 if function fails
    #[doc(alias = "gtk_notebook_append_page")]
    pub fn append_page(
        &self,
        child: &impl IsA<Widget>,
        tab_label: Option<&impl IsA<Widget>>,
    ) -> u32 {
        unsafe {
            let ret = ffi::gtk_notebook_append_page(
                self.to_glib_none().0,
                child.as_ref().to_glib_none().0,
                tab_label.map(|p| p.as_ref()).to_glib_none().0,
            );
            debug_assert!(ret >= 0);
            ret as u32
        }
    }

    /// Appends a page to @self, specifying the widget to use as the
    /// label in the popup menu.
    /// ## `child`
    /// the [`Widget`][crate::Widget] to use as the contents of the page
    /// ## `tab_label`
    /// page N
    /// ## `menu_label`
    /// the widget to use as a label for the
    ///   page-switch menu, if that is enabled. If [`None`], and @tab_label
    ///   is a [`Label`][crate::Label] or [`None`], then the menu label will be a newly
    ///   created label with the same text as @tab_label; if @tab_label
    ///   is not a [`Label`][crate::Label], @menu_label must be specified if the
    ///   page-switch menu is to be used.
    ///
    /// # Returns
    ///
    /// the index (starting from 0) of the appended
    ///   page in the notebook, or -1 if function fails
    #[doc(alias = "gtk_notebook_append_page_menu")]
    pub fn append_page_menu(
        &self,
        child: &impl IsA<Widget>,
        tab_label: Option<&impl IsA<Widget>>,
        menu_label: Option<&impl IsA<Widget>>,
    ) -> u32 {
        unsafe {
            let ret = ffi::gtk_notebook_append_page_menu(
                self.to_glib_none().0,
                child.as_ref().to_glib_none().0,
                tab_label.map(|p| p.as_ref()).to_glib_none().0,
                menu_label.map(|p| p.as_ref()).to_glib_none().0,
            );
            debug_assert!(ret >= 0);
            ret as u32
        }
    }

    /// Returns the page number of the current page.
    ///
    /// # Returns
    ///
    /// the index (starting from 0) of the current
    ///   page in the notebook. If the notebook has no pages,
    ///   then -1 will be returned.
    #[doc(alias = "gtk_notebook_get_current_page")]
    #[doc(alias = "get_current_page")]
    pub fn current_page(&self) -> Option<u32> {
        unsafe {
            let ret = ffi::gtk_notebook_get_current_page(self.to_glib_none().0);
            if ret >= 0 { Some(ret as u32) } else { None }
        }
    }

    /// Gets the number of pages in a notebook.
    ///
    /// # Returns
    ///
    /// the number of pages in the notebook
    #[doc(alias = "gtk_notebook_get_n_pages")]
    #[doc(alias = "get_n_pages")]
    pub fn n_pages(&self) -> u32 {
        unsafe {
            let ret = ffi::gtk_notebook_get_n_pages(self.to_glib_none().0);
            debug_assert!(ret >= 0);
            ret as u32
        }
    }

    /// Returns the child widget contained in page number @page_num.
    /// ## `page_num`
    /// the index of a page in the notebook, or -1
    ///   to get the last page
    ///
    /// # Returns
    ///
    /// the child widget, or [`None`] if @page_num
    /// is out of bounds
    #[doc(alias = "gtk_notebook_get_nth_page")]
    #[doc(alias = "get_nth_page")]
    pub fn nth_page(&self, page_num: Option<u32>) -> Option<Widget> {
        unsafe {
            from_glib_none(ffi::gtk_notebook_get_nth_page(
                self.to_glib_none().0,
                page_num.map_or(-1, |n| n as c_int),
            ))
        }
    }

    /// Insert a page into @self at the given position.
    /// ## `child`
    /// the [`Widget`][crate::Widget] to use as the contents of the page
    /// ## `tab_label`
    /// page N
    /// ## `position`
    /// the index (starting at 0) at which to insert the page,
    ///   or -1 to append the page after all other pages
    ///
    /// # Returns
    ///
    /// the index (starting from 0) of the inserted
    ///   page in the notebook, or -1 if function fails
    #[doc(alias = "gtk_notebook_insert_page")]
    pub fn insert_page(
        &self,
        child: &impl IsA<Widget>,
        tab_label: Option<&impl IsA<Widget>>,
        position: Option<u32>,
    ) -> u32 {
        unsafe {
            let ret = ffi::gtk_notebook_insert_page(
                self.to_glib_none().0,
                child.as_ref().to_glib_none().0,
                tab_label.map(|p| p.as_ref()).to_glib_none().0,
                position.map_or(-1, |n| n as c_int),
            );
            debug_assert!(ret >= 0);
            ret as u32
        }
    }

    /// Insert a page into @self at the given position, specifying
    /// the widget to use as the label in the popup menu.
    /// ## `child`
    /// the [`Widget`][crate::Widget] to use as the contents of the page
    /// ## `tab_label`
    /// page N
    /// ## `menu_label`
    /// the widget to use as a label for the
    ///   page-switch menu, if that is enabled. If [`None`], and @tab_label
    ///   is a [`Label`][crate::Label] or [`None`], then the menu label will be a newly
    ///   created label with the same text as @tab_label; if @tab_label
    ///   is not a [`Label`][crate::Label], @menu_label must be specified if the
    ///   page-switch menu is to be used.
    /// ## `position`
    /// the index (starting at 0) at which to insert the page,
    ///   or -1 to append the page after all other pages.
    ///
    /// # Returns
    ///
    /// the index (starting from 0) of the inserted
    ///   page in the notebook
    #[doc(alias = "gtk_notebook_insert_page_menu")]
    pub fn insert_page_menu(
        &self,
        child: &impl IsA<Widget>,
        tab_label: Option<&impl IsA<Widget>>,
        menu_label: Option<&impl IsA<Widget>>,
        position: Option<u32>,
    ) -> u32 {
        unsafe {
            let ret = ffi::gtk_notebook_insert_page_menu(
                self.to_glib_none().0,
                child.as_ref().to_glib_none().0,
                tab_label.map(|p| p.as_ref()).to_glib_none().0,
                menu_label.map(|p| p.as_ref()).to_glib_none().0,
                position.map_or(-1, |n| n as c_int),
            );
            debug_assert!(ret >= 0);
            ret as u32
        }
    }
    /// Finds the index of the page which contains the given child
    /// widget.
    /// ## `child`
    /// a [`Widget`][crate::Widget]
    ///
    /// # Returns
    ///
    /// the index of the page containing @child, or
    ///   -1 if @child is not in the notebook
    #[doc(alias = "gtk_notebook_page_num")]
    pub fn page_num(&self, child: &impl IsA<Widget>) -> Option<u32> {
        unsafe {
            let ret =
                ffi::gtk_notebook_page_num(self.to_glib_none().0, child.as_ref().to_glib_none().0);
            if ret >= 0 { Some(ret as u32) } else { None }
        }
    }
    /// Prepends a page to @self.
    /// ## `child`
    /// the [`Widget`][crate::Widget] to use as the contents of the page
    /// ## `tab_label`
    /// page N
    ///
    /// # Returns
    ///
    /// the index (starting from 0) of the prepended
    ///   page in the notebook, or -1 if function fails
    #[doc(alias = "gtk_notebook_prepend_page")]
    pub fn prepend_page(
        &self,
        child: &impl IsA<Widget>,
        tab_label: Option<&impl IsA<Widget>>,
    ) -> u32 {
        unsafe {
            let ret = ffi::gtk_notebook_prepend_page(
                self.to_glib_none().0,
                child.as_ref().to_glib_none().0,
                tab_label.map(|p| p.as_ref()).to_glib_none().0,
            );
            debug_assert!(ret >= 0);
            ret as u32
        }
    }

    /// Prepends a page to @self, specifying the widget to use as the
    /// label in the popup menu.
    /// ## `child`
    /// the [`Widget`][crate::Widget] to use as the contents of the page
    /// ## `tab_label`
    /// page N
    /// ## `menu_label`
    /// the widget to use as a label for the
    ///   page-switch menu, if that is enabled. If [`None`], and @tab_label
    ///   is a [`Label`][crate::Label] or [`None`], then the menu label will be a newly
    ///   created label with the same text as @tab_label; if @tab_label
    ///   is not a [`Label`][crate::Label], @menu_label must be specified if the
    ///   page-switch menu is to be used.
    ///
    /// # Returns
    ///
    /// the index (starting from 0) of the prepended
    ///   page in the notebook, or -1 if function fails
    #[doc(alias = "gtk_notebook_prepend_page_menu")]
    pub fn prepend_page_menu(
        &self,
        child: &impl IsA<Widget>,
        tab_label: Option<&impl IsA<Widget>>,
        menu_label: Option<&impl IsA<Widget>>,
    ) -> u32 {
        unsafe {
            let ret = ffi::gtk_notebook_prepend_page_menu(
                self.to_glib_none().0,
                child.as_ref().to_glib_none().0,
                tab_label.map(|p| p.as_ref()).to_glib_none().0,
                menu_label.map(|p| p.as_ref()).to_glib_none().0,
            );
            debug_assert!(ret >= 0);
            ret as u32
        }
    }

    /// Removes a page from the notebook given its index
    /// in the notebook.
    /// ## `page_num`
    /// the index of a notebook page, starting
    ///   from 0. If -1, the last page will be removed.
    #[doc(alias = "gtk_notebook_remove_page")]
    pub fn remove_page(&self, page_num: Option<u32>) {
        unsafe {
            ffi::gtk_notebook_remove_page(
                self.to_glib_none().0,
                page_num.map_or(-1, |n| n as c_int),
            );
        }
    }

    /// Reorders the page containing @child, so that it appears in position
    /// @position.
    ///
    /// If @position is greater than or equal to the number of children in
    /// the list or negative, @child will be moved to the end of the list.
    /// ## `child`
    /// the child to move
    /// ## `position`
    /// the new position, or -1 to move to the end
    #[doc(alias = "gtk_notebook_reorder_child")]
    pub fn reorder_child(&self, child: &impl IsA<Widget>, position: Option<u32>) {
        unsafe {
            ffi::gtk_notebook_reorder_child(
                self.to_glib_none().0,
                child.as_ref().to_glib_none().0,
                position.map_or(-1, |n| n as c_int),
            );
        }
    }

    /// Switches to the page number @page_num.
    ///
    /// Note that due to historical reasons, GtkNotebook refuses
    /// to switch to a page unless the child widget is visible.
    /// Therefore, it is recommended to show child widgets before
    /// adding them to a notebook.
    /// ## `page_num`
    /// index of the page to switch to, starting from 0.
    ///   If negative, the last page will be used. If greater
    ///   than the number of pages in the notebook, nothing
    ///   will be done.
    #[doc(alias = "gtk_notebook_set_current_page")]
    pub fn set_current_page(&self, page_num: Option<u32>) {
        unsafe {
            ffi::gtk_notebook_set_current_page(
                self.to_glib_none().0,
                page_num.map_or(-1, |n| n as c_int),
            );
        }
    }
}