// 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::MenuItem;
use crate::MenuModel;
use glib::object::IsA;
use glib::translate::*;
use std::fmt;

glib::wrapper! {
    /// [`Menu`][crate::Menu] is a simple implementation of [`MenuModel`][crate::MenuModel].
    /// You populate a [`Menu`][crate::Menu] by adding [`MenuItem`][crate::MenuItem] instances to it.
    ///
    /// There are some convenience functions to allow you to directly
    /// add items (avoiding [`MenuItem`][crate::MenuItem]) for the common cases. To add
    /// a regular item, use [`insert()`][Self::insert()]. To add a section, use
    /// [`insert_section()`][Self::insert_section()]. To add a submenu, use
    /// [`insert_submenu()`][Self::insert_submenu()].
    ///
    /// # Implements
    ///
    /// [`MenuModelExt`][trait@crate::prelude::MenuModelExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "GMenu")]
    pub struct Menu(Object<ffi::GMenu>) @extends MenuModel;

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

impl Menu {
    /// Creates a new [`Menu`][crate::Menu].
    ///
    /// The new menu has no items.
    ///
    /// # Returns
    ///
    /// a new [`Menu`][crate::Menu]
    #[doc(alias = "g_menu_new")]
    pub fn new() -> Menu {
        unsafe { from_glib_full(ffi::g_menu_new()) }
    }

    /// Convenience function for appending a normal menu item to the end of
    /// `self`. Combine [`MenuItem::new()`][crate::MenuItem::new()] and [`insert_item()`][Self::insert_item()] for a more
    /// flexible alternative.
    /// ## `label`
    /// the section label, or [`None`]
    /// ## `detailed_action`
    /// the detailed action string, or [`None`]
    #[doc(alias = "g_menu_append")]
    pub fn append(&self, label: Option<&str>, detailed_action: Option<&str>) {
        unsafe {
            ffi::g_menu_append(
                self.to_glib_none().0,
                label.to_glib_none().0,
                detailed_action.to_glib_none().0,
            );
        }
    }

    /// Appends `item` to the end of `self`.
    ///
    /// See [`insert_item()`][Self::insert_item()] for more information.
    /// ## `item`
    /// a [`MenuItem`][crate::MenuItem] to append
    #[doc(alias = "g_menu_append_item")]
    pub fn append_item(&self, item: &MenuItem) {
        unsafe {
            ffi::g_menu_append_item(self.to_glib_none().0, item.to_glib_none().0);
        }
    }

    /// Convenience function for appending a section menu item to the end of
    /// `self`. Combine [`MenuItem::new_section()`][crate::MenuItem::new_section()] and [`insert_item()`][Self::insert_item()] for a
    /// more flexible alternative.
    /// ## `label`
    /// the section label, or [`None`]
    /// ## `section`
    /// a [`MenuModel`][crate::MenuModel] with the items of the section
    #[doc(alias = "g_menu_append_section")]
    pub fn append_section<P: IsA<MenuModel>>(&self, label: Option<&str>, section: &P) {
        unsafe {
            ffi::g_menu_append_section(
                self.to_glib_none().0,
                label.to_glib_none().0,
                section.as_ref().to_glib_none().0,
            );
        }
    }

    /// Convenience function for appending a submenu menu item to the end of
    /// `self`. Combine [`MenuItem::new_submenu()`][crate::MenuItem::new_submenu()] and [`insert_item()`][Self::insert_item()] for a
    /// more flexible alternative.
    /// ## `label`
    /// the section label, or [`None`]
    /// ## `submenu`
    /// a [`MenuModel`][crate::MenuModel] with the items of the submenu
    #[doc(alias = "g_menu_append_submenu")]
    pub fn append_submenu<P: IsA<MenuModel>>(&self, label: Option<&str>, submenu: &P) {
        unsafe {
            ffi::g_menu_append_submenu(
                self.to_glib_none().0,
                label.to_glib_none().0,
                submenu.as_ref().to_glib_none().0,
            );
        }
    }

    /// Marks `self` as frozen.
    ///
    /// After the menu is frozen, it is an error to attempt to make any
    /// changes to it. In effect this means that the [`Menu`][crate::Menu] API must no
    /// longer be used.
    ///
    /// This function causes [`MenuModelExt::is_mutable()`][crate::prelude::MenuModelExt::is_mutable()] to begin returning
    /// [`false`], which has some positive performance implications.
    #[doc(alias = "g_menu_freeze")]
    pub fn freeze(&self) {
        unsafe {
            ffi::g_menu_freeze(self.to_glib_none().0);
        }
    }

    /// Convenience function for inserting a normal menu item into `self`.
    /// Combine [`MenuItem::new()`][crate::MenuItem::new()] and [`insert_item()`][Self::insert_item()] for a more flexible
    /// alternative.
    /// ## `position`
    /// the position at which to insert the item
    /// ## `label`
    /// the section label, or [`None`]
    /// ## `detailed_action`
    /// the detailed action string, or [`None`]
    #[doc(alias = "g_menu_insert")]
    pub fn insert(&self, position: i32, label: Option<&str>, detailed_action: Option<&str>) {
        unsafe {
            ffi::g_menu_insert(
                self.to_glib_none().0,
                position,
                label.to_glib_none().0,
                detailed_action.to_glib_none().0,
            );
        }
    }

    /// Inserts `item` into `self`.
    ///
    /// The "insertion" is actually done by copying all of the attribute and
    /// link values of `item` and using them to form a new item within `self`.
    /// As such, `item` itself is not really inserted, but rather, a menu item
    /// that is exactly the same as the one presently described by `item`.
    ///
    /// This means that `item` is essentially useless after the insertion
    /// occurs. Any changes you make to it are ignored unless it is inserted
    /// again (at which point its updated values will be copied).
    ///
    /// You should probably just free `item` once you're done.
    ///
    /// There are many convenience functions to take care of common cases.
    /// See [`insert()`][Self::insert()], [`insert_section()`][Self::insert_section()] and
    /// [`insert_submenu()`][Self::insert_submenu()] as well as "prepend" and "append" variants of
    /// each of these functions.
    /// ## `position`
    /// the position at which to insert the item
    /// ## `item`
    /// the [`MenuItem`][crate::MenuItem] to insert
    #[doc(alias = "g_menu_insert_item")]
    pub fn insert_item(&self, position: i32, item: &MenuItem) {
        unsafe {
            ffi::g_menu_insert_item(self.to_glib_none().0, position, item.to_glib_none().0);
        }
    }

    /// Convenience function for inserting a section menu item into `self`.
    /// Combine [`MenuItem::new_section()`][crate::MenuItem::new_section()] and [`insert_item()`][Self::insert_item()] for a more
    /// flexible alternative.
    /// ## `position`
    /// the position at which to insert the item
    /// ## `label`
    /// the section label, or [`None`]
    /// ## `section`
    /// a [`MenuModel`][crate::MenuModel] with the items of the section
    #[doc(alias = "g_menu_insert_section")]
    pub fn insert_section<P: IsA<MenuModel>>(
        &self,
        position: i32,
        label: Option<&str>,
        section: &P,
    ) {
        unsafe {
            ffi::g_menu_insert_section(
                self.to_glib_none().0,
                position,
                label.to_glib_none().0,
                section.as_ref().to_glib_none().0,
            );
        }
    }

    /// Convenience function for inserting a submenu menu item into `self`.
    /// Combine [`MenuItem::new_submenu()`][crate::MenuItem::new_submenu()] and [`insert_item()`][Self::insert_item()] for a more
    /// flexible alternative.
    /// ## `position`
    /// the position at which to insert the item
    /// ## `label`
    /// the section label, or [`None`]
    /// ## `submenu`
    /// a [`MenuModel`][crate::MenuModel] with the items of the submenu
    #[doc(alias = "g_menu_insert_submenu")]
    pub fn insert_submenu<P: IsA<MenuModel>>(
        &self,
        position: i32,
        label: Option<&str>,
        submenu: &P,
    ) {
        unsafe {
            ffi::g_menu_insert_submenu(
                self.to_glib_none().0,
                position,
                label.to_glib_none().0,
                submenu.as_ref().to_glib_none().0,
            );
        }
    }

    /// Convenience function for prepending a normal menu item to the start
    /// of `self`. Combine [`MenuItem::new()`][crate::MenuItem::new()] and [`insert_item()`][Self::insert_item()] for a more
    /// flexible alternative.
    /// ## `label`
    /// the section label, or [`None`]
    /// ## `detailed_action`
    /// the detailed action string, or [`None`]
    #[doc(alias = "g_menu_prepend")]
    pub fn prepend(&self, label: Option<&str>, detailed_action: Option<&str>) {
        unsafe {
            ffi::g_menu_prepend(
                self.to_glib_none().0,
                label.to_glib_none().0,
                detailed_action.to_glib_none().0,
            );
        }
    }

    /// Prepends `item` to the start of `self`.
    ///
    /// See [`insert_item()`][Self::insert_item()] for more information.
    /// ## `item`
    /// a [`MenuItem`][crate::MenuItem] to prepend
    #[doc(alias = "g_menu_prepend_item")]
    pub fn prepend_item(&self, item: &MenuItem) {
        unsafe {
            ffi::g_menu_prepend_item(self.to_glib_none().0, item.to_glib_none().0);
        }
    }

    /// Convenience function for prepending a section menu item to the start
    /// of `self`. Combine [`MenuItem::new_section()`][crate::MenuItem::new_section()] and [`insert_item()`][Self::insert_item()] for
    /// a more flexible alternative.
    /// ## `label`
    /// the section label, or [`None`]
    /// ## `section`
    /// a [`MenuModel`][crate::MenuModel] with the items of the section
    #[doc(alias = "g_menu_prepend_section")]
    pub fn prepend_section<P: IsA<MenuModel>>(&self, label: Option<&str>, section: &P) {
        unsafe {
            ffi::g_menu_prepend_section(
                self.to_glib_none().0,
                label.to_glib_none().0,
                section.as_ref().to_glib_none().0,
            );
        }
    }

    /// Convenience function for prepending a submenu menu item to the start
    /// of `self`. Combine [`MenuItem::new_submenu()`][crate::MenuItem::new_submenu()] and [`insert_item()`][Self::insert_item()] for
    /// a more flexible alternative.
    /// ## `label`
    /// the section label, or [`None`]
    /// ## `submenu`
    /// a [`MenuModel`][crate::MenuModel] with the items of the submenu
    #[doc(alias = "g_menu_prepend_submenu")]
    pub fn prepend_submenu<P: IsA<MenuModel>>(&self, label: Option<&str>, submenu: &P) {
        unsafe {
            ffi::g_menu_prepend_submenu(
                self.to_glib_none().0,
                label.to_glib_none().0,
                submenu.as_ref().to_glib_none().0,
            );
        }
    }

    /// Removes an item from the menu.
    ///
    /// `position` gives the index of the item to remove.
    ///
    /// It is an error if position is not in range the range from 0 to one
    /// less than the number of items in the menu.
    ///
    /// It is not possible to remove items by identity since items are added
    /// to the menu simply by copying their links and attributes (ie:
    /// identity of the item itself is not preserved).
    /// ## `position`
    /// the position of the item to remove
    #[doc(alias = "g_menu_remove")]
    pub fn remove(&self, position: i32) {
        unsafe {
            ffi::g_menu_remove(self.to_glib_none().0, position);
        }
    }

    /// Removes all items in the menu.
    #[doc(alias = "g_menu_remove_all")]
    pub fn remove_all(&self) {
        unsafe {
            ffi::g_menu_remove_all(self.to_glib_none().0);
        }
    }
}

impl Default for Menu {
    fn default() -> Self {
        Self::new()
    }
}

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