gtk4/auto/

popover_menu.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::{
    ffi, Accessible, AccessibleRole, Align, Buildable, ConstraintTarget, LayoutManager, Native,
    Overflow, Popover, PopoverMenuFlags, PositionType, ShortcutManager, Widget,
};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// [`PopoverMenu`][crate::PopoverMenu] is a subclass of [`Popover`][crate::Popover] that implements menu
    /// behavior.
    ///
    /// ![An example GtkPopoverMenu](menu.png)
    ///
    /// [`PopoverMenu`][crate::PopoverMenu] treats its children like menus and allows switching
    /// between them. It can open submenus as traditional, nested submenus,
    /// or in a more touch-friendly sliding fashion.
    /// The property [`flags`][struct@crate::PopoverMenu#flags] controls this appearance.
    ///
    /// [`PopoverMenu`][crate::PopoverMenu] is meant to be used primarily with menu models,
    /// using [`from_model()`][Self::from_model()]. If you need to put
    /// other widgets such as a [`SpinButton`][crate::SpinButton] or a [`Switch`][crate::Switch] into a popover,
    /// you can use [`add_child()`][Self::add_child()].
    ///
    /// For more dialog-like behavior, use a plain [`Popover`][crate::Popover].
    ///
    /// ## Menu models
    ///
    /// The XML format understood by [`Builder`][crate::Builder] for `GMenuModel` consists
    /// of a toplevel `<menu>` element, which contains one or more `<item>`
    /// elements. Each `<item>` element contains `<attribute>` and `<link>`
    /// elements with a mandatory name attribute. `<link>` elements have the
    /// same content model as `<menu>`. Instead of `<link name="submenu">`
    /// or `<link name="section">`, you can use `<submenu>` or `<section>`
    /// elements.
    ///
    /// ```xml
    /// <menu id='app-menu'>
    ///   <section>
    ///     <item>
    ///       <attribute name='label' translatable='yes'>_New Window</attribute>
    ///       <attribute name='action'>app.new</attribute>
    ///     </item>
    ///     <item>
    ///       <attribute name='label' translatable='yes'>_About Sunny</attribute>
    ///       <attribute name='action'>app.about</attribute>
    ///     </item>
    ///     <item>
    ///       <attribute name='label' translatable='yes'>_Quit</attribute>
    ///       <attribute name='action'>app.quit</attribute>
    ///     </item>
    ///   </section>
    /// </menu>
    /// ```
    ///
    /// Attribute values can be translated using gettext, like other [`Builder`][crate::Builder]
    /// content. `<attribute>` elements can be marked for translation with a
    /// `translatable="yes"` attribute. It is also possible to specify message
    /// context and translator comments, using the context and comments attributes.
    /// To make use of this, the [`Builder`][crate::Builder] must have been given the gettext
    /// domain to use.
    ///
    /// The following attributes are used when constructing menu items:
    ///
    /// - "label": a user-visible string to display
    /// - "use-markup": whether the text in the menu item includes [Pango markup](https://docs.gtk.org/Pango/pango_markup.html)
    /// - "action": the prefixed name of the action to trigger
    /// - "target": the parameter to use when activating the action
    /// - "icon" and "verb-icon": names of icons that may be displayed
    /// - "submenu-action": name of an action that may be used to track
    ///      whether a submenu is open
    /// - "hidden-when": a string used to determine when the item will be hidden.
    ///      Possible values include "action-disabled", "action-missing", "macos-menubar".
    ///      This is mainly useful for exported menus, see [`GtkApplicationExt::set_menubar()`][crate::prelude::GtkApplicationExt::set_menubar()].
    /// - "custom": a string used to match against the ID of a custom child added with
    ///      [`add_child()`][Self::add_child()], [`PopoverMenuBar::add_child()`][crate::PopoverMenuBar::add_child()],
    ///      or in the ui file with `<child type="ID">`.
    ///
    /// The following attributes are used when constructing sections:
    ///
    /// - "label": a user-visible string to use as section heading
    /// - "display-hint": a string used to determine special formatting for the section.
    ///     Possible values include "horizontal-buttons", "circular-buttons" and
    ///     "inline-buttons". They all indicate that section should be
    ///     displayed as a horizontal row of buttons.
    /// - "text-direction": a string used to determine the [`TextDirection`][crate::TextDirection] to use
    ///     when "display-hint" is set to "horizontal-buttons". Possible values
    ///     include "rtl", "ltr", and "none".
    ///
    /// The following attributes are used when constructing submenus:
    ///
    /// - "label": a user-visible string to display
    /// - "icon": icon name to display
    ///
    /// Menu items will also show accelerators, which are usually associated
    /// with actions via [`GtkApplicationExt::set_accels_for_action()`][crate::prelude::GtkApplicationExt::set_accels_for_action()],
    /// [`WidgetClassExt::add_binding_action()`][crate::subclass::prelude::WidgetClassExt::add_binding_action()] or
    /// [`ShortcutController::add_shortcut()`][crate::ShortcutController::add_shortcut()].
    ///
    /// # Shortcuts and Gestures
    ///
    /// [`PopoverMenu`][crate::PopoverMenu] supports the following keyboard shortcuts:
    ///
    /// - <kbd>Space</kbd> activates the default widget.
    ///
    /// # CSS Nodes
    ///
    /// [`PopoverMenu`][crate::PopoverMenu] is just a subclass of [`Popover`][crate::Popover] that adds custom content
    /// to it, therefore it has the same CSS nodes. It is one of the cases that add
    /// a `.menu` style class to the main `popover` node.
    ///
    /// Menu items have nodes with name `button` and class `.model`. If a section
    /// display-hint is set, the section gets a node `box` with class `horizontal`
    /// plus a class with the same text as the display hint. Note that said box may
    /// not be the direct ancestor of the item `button`s. Thus, for example, to style
    /// items in an `inline-buttons` section, select `.inline-buttons button.model`.
    /// Other things that may be of interest to style in menus include `label` nodes.
    ///
    /// # Accessibility
    ///
    /// [`PopoverMenu`][crate::PopoverMenu] uses the [`AccessibleRole::Menu`][crate::AccessibleRole::Menu] role, and its
    /// items use the [`AccessibleRole::MenuItem`][crate::AccessibleRole::MenuItem],
    /// [`AccessibleRole::MenuItemCheckbox`][crate::AccessibleRole::MenuItemCheckbox] or
    /// [`AccessibleRole::MenuItemRadio`][crate::AccessibleRole::MenuItemRadio] roles, depending on the
    /// action they are connected to.
    ///
    /// ## Properties
    ///
    ///
    /// #### `flags`
    ///  The flags that @popover uses to create/display a menu from its model.
    ///
    /// If a model is set and the flags change, contents are rebuilt, so if setting
    /// properties individually, set flags before model to avoid a redundant rebuild.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `menu-model`
    ///  The model from which the menu is made.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `visible-submenu`
    ///  The name of the visible submenu.
    ///
    /// Readable | Writeable
    /// <details><summary><h4>Popover</h4></summary>
    ///
    ///
    /// #### `autohide`
    ///  Whether to dismiss the popover on outside clicks.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `cascade-popdown`
    ///  Whether the popover pops down after a child popover.
    ///
    /// This is used to implement the expected behavior of submenus.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `child`
    ///  The child widget.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `default-widget`
    ///  The default widget inside the popover.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `has-arrow`
    ///  Whether to draw an arrow.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `mnemonics-visible`
    ///  Whether mnemonics are currently visible in this popover.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `pointing-to`
    ///  Rectangle in the parent widget that the popover points to.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `position`
    ///  How to place the popover, relative to its parent.
    ///
    /// Readable | Writeable
    /// </details>
    /// <details><summary><h4>Widget</h4></summary>
    ///
    ///
    /// #### `can-focus`
    ///  Whether the widget or any of its descendents can accept
    /// the input focus.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `can-target`
    ///  Whether the widget can receive pointer events.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `css-classes`
    ///  A list of css classes applied to this widget.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `css-name`
    ///  The name of this widget in the CSS tree.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `cursor`
    ///  The cursor used by @widget.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `focus-on-click`
    ///  Whether the widget should grab focus when it is clicked with the mouse.
    ///
    /// This property is only relevant for widgets that can take focus.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `focusable`
    ///  Whether this widget itself will accept the input focus.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `halign`
    ///  How to distribute horizontal space if widget gets extra space.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `has-default`
    ///  Whether the widget is the default widget.
    ///
    /// Readable
    ///
    ///
    /// #### `has-focus`
    ///  Whether the widget has the input focus.
    ///
    /// Readable
    ///
    ///
    /// #### `has-tooltip`
    ///  Enables or disables the emission of the ::query-tooltip signal on @widget.
    ///
    /// A value of [`true`] indicates that @widget can have a tooltip, in this case
    /// the widget will be queried using [`query-tooltip`][struct@crate::Widget#query-tooltip] to
    /// determine whether it will provide a tooltip or not.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `height-request`
    ///  Override for height request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `hexpand`
    ///  Whether to expand horizontally.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `hexpand-set`
    ///  Whether to use the `hexpand` property.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `layout-manager`
    ///  The [`LayoutManager`][crate::LayoutManager] instance to use to compute the preferred size
    /// of the widget, and allocate its children.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-bottom`
    ///  Margin on bottom side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-end`
    ///  Margin on end of widget, horizontally.
    ///
    /// This property supports left-to-right and right-to-left text
    /// directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-start`
    ///  Margin on start of widget, horizontally.
    ///
    /// This property supports left-to-right and right-to-left text
    /// directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `margin-top`
    ///  Margin on top side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `name`
    ///  The name of the widget.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `opacity`
    ///  The requested opacity of the widget.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `overflow`
    ///  How content outside the widget's content area is treated.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `parent`
    ///  The parent widget of this widget.
    ///
    /// Readable
    ///
    ///
    /// #### `receives-default`
    ///  Whether the widget will receive the default action when it is focused.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `root`
    ///  The [`Root`][crate::Root] widget of the widget tree containing this widget.
    ///
    /// This will be [`None`] if the widget is not contained in a root widget.
    ///
    /// Readable
    ///
    ///
    /// #### `scale-factor`
    ///  The scale factor of the widget.
    ///
    /// Readable
    ///
    ///
    /// #### `sensitive`
    ///  Whether the widget responds to input.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `tooltip-markup`
    ///  Sets the text of tooltip to be the given string, which is marked up
    /// with Pango markup.
    ///
    /// Also see [`Tooltip::set_markup()`][crate::Tooltip::set_markup()].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]:
    /// [`has-tooltip`][struct@crate::Widget#has-tooltip] will automatically be set to [`true`]
    /// and there will be taken care of [`query-tooltip`][struct@crate::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::Widget#tooltip-markup] are set, the last one wins.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `tooltip-text`
    ///  Sets the text of tooltip to be the given string.
    ///
    /// Also see [`Tooltip::set_text()`][crate::Tooltip::set_text()].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]:
    /// [`has-tooltip`][struct@crate::Widget#has-tooltip] will automatically be set to [`true`]
    /// and there will be taken care of [`query-tooltip`][struct@crate::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::Widget#tooltip-markup] are set, the last one wins.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `valign`
    ///  How to distribute vertical space if widget gets extra space.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `vexpand`
    ///  Whether to expand vertically.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `vexpand-set`
    ///  Whether to use the `vexpand` property.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `visible`
    ///  Whether the widget is visible.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `width-request`
    ///  Override for width request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    ///
    /// Readable | Writeable
    /// </details>
    /// <details><summary><h4>Accessible</h4></summary>
    ///
    ///
    /// #### `accessible-role`
    ///  The accessible role of the given [`Accessible`][crate::Accessible] implementation.
    ///
    /// The accessible role cannot be changed once set.
    ///
    /// Readable | Writeable
    /// </details>
    ///
    /// # Implements
    ///
    /// [`PopoverExt`][trait@crate::prelude::PopoverExt], [`WidgetExt`][trait@crate::prelude::WidgetExt], [`trait@glib::ObjectExt`], [`AccessibleExt`][trait@crate::prelude::AccessibleExt], [`BuildableExt`][trait@crate::prelude::BuildableExt], [`ConstraintTargetExt`][trait@crate::prelude::ConstraintTargetExt], [`NativeExt`][trait@crate::prelude::NativeExt], [`ShortcutManagerExt`][trait@crate::prelude::ShortcutManagerExt], [`WidgetExtManual`][trait@crate::prelude::WidgetExtManual], [`AccessibleExtManual`][trait@crate::prelude::AccessibleExtManual]
    #[doc(alias = "GtkPopoverMenu")]
    pub struct PopoverMenu(Object<ffi::GtkPopoverMenu>) @extends Popover, Widget, @implements Accessible, Buildable, ConstraintTarget, Native, ShortcutManager;

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

impl PopoverMenu {
    /// Creates a [`PopoverMenu`][crate::PopoverMenu] and populates it according to @model.
    ///
    /// The created buttons are connected to actions found in the
    /// [`ApplicationWindow`][crate::ApplicationWindow] to which the popover belongs - typically
    /// by means of being attached to a widget that is contained within
    /// the [`ApplicationWindow`][crate::ApplicationWindow]s widget hierarchy.
    ///
    /// Actions can also be added using [`WidgetExt::insert_action_group()`][crate::prelude::WidgetExt::insert_action_group()]
    /// on the menus attach widget or on any of its parent widgets.
    ///
    /// This function creates menus with sliding submenus.
    /// See [`from_model_full()`][Self::from_model_full()] for a way
    /// to control this.
    /// ## `model`
    /// a `GMenuModel`
    ///
    /// # Returns
    ///
    /// the new [`PopoverMenu`][crate::PopoverMenu]
    #[doc(alias = "gtk_popover_menu_new_from_model")]
    #[doc(alias = "new_from_model")]
    pub fn from_model(model: Option<&impl IsA<gio::MenuModel>>) -> PopoverMenu {
        assert_initialized_main_thread!();
        unsafe {
            Widget::from_glib_none(ffi::gtk_popover_menu_new_from_model(
                model.map(|p| p.as_ref()).to_glib_none().0,
            ))
            .unsafe_cast()
        }
    }

    /// Creates a [`PopoverMenu`][crate::PopoverMenu] and populates it according to @model.
    ///
    /// The created buttons are connected to actions found in the
    /// action groups that are accessible from the parent widget.
    /// This includes the [`ApplicationWindow`][crate::ApplicationWindow] to which the popover
    /// belongs. Actions can also be added using [`WidgetExt::insert_action_group()`][crate::prelude::WidgetExt::insert_action_group()]
    /// on the parent widget or on any of its parent widgets.
    /// ## `model`
    /// a `GMenuModel`
    /// ## `flags`
    /// flags that affect how the menu is created
    ///
    /// # Returns
    ///
    /// the new [`PopoverMenu`][crate::PopoverMenu]
    #[doc(alias = "gtk_popover_menu_new_from_model_full")]
    #[doc(alias = "new_from_model_full")]
    pub fn from_model_full(
        model: &impl IsA<gio::MenuModel>,
        flags: PopoverMenuFlags,
    ) -> PopoverMenu {
        assert_initialized_main_thread!();
        unsafe {
            Widget::from_glib_none(ffi::gtk_popover_menu_new_from_model_full(
                model.as_ref().to_glib_none().0,
                flags.into_glib(),
            ))
            .unsafe_cast()
        }
    }

    // rustdoc-stripper-ignore-next
    /// Creates a new builder-pattern struct instance to construct [`PopoverMenu`] objects.
    ///
    /// This method returns an instance of [`PopoverMenuBuilder`](crate::builders::PopoverMenuBuilder) which can be used to create [`PopoverMenu`] objects.
    pub fn builder() -> PopoverMenuBuilder {
        PopoverMenuBuilder::new()
    }

    /// Adds a custom widget to a generated menu.
    ///
    /// For this to work, the menu model of @self must have
    /// an item with a `custom` attribute that matches @id.
    /// ## `child`
    /// the [`Widget`][crate::Widget] to add
    /// ## `id`
    /// the ID to insert @child at
    ///
    /// # Returns
    ///
    /// [`true`] if @id was found and the widget added
    #[doc(alias = "gtk_popover_menu_add_child")]
    pub fn add_child(&self, child: &impl IsA<Widget>, id: &str) -> bool {
        unsafe {
            from_glib(ffi::gtk_popover_menu_add_child(
                self.to_glib_none().0,
                child.as_ref().to_glib_none().0,
                id.to_glib_none().0,
            ))
        }
    }

    /// Returns the flags that @self uses to create/display a menu from its model.
    ///
    /// # Returns
    ///
    /// the [`PopoverMenuFlags`][crate::PopoverMenuFlags]
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    #[doc(alias = "gtk_popover_menu_get_flags")]
    #[doc(alias = "get_flags")]
    pub fn flags(&self) -> PopoverMenuFlags {
        unsafe { from_glib(ffi::gtk_popover_menu_get_flags(self.to_glib_none().0)) }
    }

    /// Returns the menu model used to populate the popover.
    ///
    /// # Returns
    ///
    /// the menu model of @self
    #[doc(alias = "gtk_popover_menu_get_menu_model")]
    #[doc(alias = "get_menu_model")]
    #[doc(alias = "menu-model")]
    pub fn menu_model(&self) -> Option<gio::MenuModel> {
        unsafe { from_glib_none(ffi::gtk_popover_menu_get_menu_model(self.to_glib_none().0)) }
    }

    /// Removes a widget that has previously been added with
    /// [`add_child()`][Self::add_child()]()]
    /// ## `child`
    /// the [`Widget`][crate::Widget] to remove
    ///
    /// # Returns
    ///
    /// [`true`] if the widget was removed
    #[doc(alias = "gtk_popover_menu_remove_child")]
    pub fn remove_child(&self, child: &impl IsA<Widget>) -> bool {
        unsafe {
            from_glib(ffi::gtk_popover_menu_remove_child(
                self.to_glib_none().0,
                child.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Sets the flags that @self uses to create/display a menu from its model.
    ///
    /// If a model is set and the flags change, contents are rebuilt, so if setting
    /// properties individually, set flags before model to avoid a redundant rebuild.
    /// ## `flags`
    /// a set of [`PopoverMenuFlags`][crate::PopoverMenuFlags]
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    #[doc(alias = "gtk_popover_menu_set_flags")]
    #[doc(alias = "flags")]
    pub fn set_flags(&self, flags: PopoverMenuFlags) {
        unsafe {
            ffi::gtk_popover_menu_set_flags(self.to_glib_none().0, flags.into_glib());
        }
    }

    /// Sets a new menu model on @self.
    ///
    /// The existing contents of @self are removed, and
    /// the @self is populated with new contents according
    /// to @model.
    /// ## `model`
    /// a `GMenuModel`
    #[doc(alias = "gtk_popover_menu_set_menu_model")]
    #[doc(alias = "menu-model")]
    pub fn set_menu_model(&self, model: Option<&impl IsA<gio::MenuModel>>) {
        unsafe {
            ffi::gtk_popover_menu_set_menu_model(
                self.to_glib_none().0,
                model.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// The name of the visible submenu.
    #[doc(alias = "visible-submenu")]
    pub fn visible_submenu(&self) -> Option<glib::GString> {
        ObjectExt::property(self, "visible-submenu")
    }

    /// The name of the visible submenu.
    #[doc(alias = "visible-submenu")]
    pub fn set_visible_submenu(&self, visible_submenu: Option<&str>) {
        ObjectExt::set_property(self, "visible-submenu", visible_submenu)
    }

    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    #[doc(alias = "flags")]
    pub fn connect_flags_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_flags_trampoline<F: Fn(&PopoverMenu) + 'static>(
            this: *mut ffi::GtkPopoverMenu,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::flags\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_flags_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "menu-model")]
    pub fn connect_menu_model_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_menu_model_trampoline<F: Fn(&PopoverMenu) + 'static>(
            this: *mut ffi::GtkPopoverMenu,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::menu-model\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_menu_model_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "visible-submenu")]
    pub fn connect_visible_submenu_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_visible_submenu_trampoline<F: Fn(&PopoverMenu) + 'static>(
            this: *mut ffi::GtkPopoverMenu,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::visible-submenu\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_visible_submenu_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`PopoverMenu`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
#[must_use = "The builder must be built to be used"]
pub struct PopoverMenuBuilder {
    builder: glib::object::ObjectBuilder<'static, PopoverMenu>,
}

impl PopoverMenuBuilder {
    fn new() -> Self {
        Self {
            builder: glib::object::Object::builder(),
        }
    }

    /// The flags that @popover uses to create/display a menu from its model.
    ///
    /// If a model is set and the flags change, contents are rebuilt, so if setting
    /// properties individually, set flags before model to avoid a redundant rebuild.
    #[cfg(feature = "v4_14")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_14")))]
    pub fn flags(self, flags: PopoverMenuFlags) -> Self {
        Self {
            builder: self.builder.property("flags", flags),
        }
    }

    /// The model from which the menu is made.
    pub fn menu_model(self, menu_model: &impl IsA<gio::MenuModel>) -> Self {
        Self {
            builder: self
                .builder
                .property("menu-model", menu_model.clone().upcast()),
        }
    }

    /// The name of the visible submenu.
    pub fn visible_submenu(self, visible_submenu: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("visible-submenu", visible_submenu.into()),
        }
    }

    /// Whether to dismiss the popover on outside clicks.
    pub fn autohide(self, autohide: bool) -> Self {
        Self {
            builder: self.builder.property("autohide", autohide),
        }
    }

    /// Whether the popover pops down after a child popover.
    ///
    /// This is used to implement the expected behavior of submenus.
    pub fn cascade_popdown(self, cascade_popdown: bool) -> Self {
        Self {
            builder: self.builder.property("cascade-popdown", cascade_popdown),
        }
    }

    /// The child widget.
    pub fn child(self, child: &impl IsA<Widget>) -> Self {
        Self {
            builder: self.builder.property("child", child.clone().upcast()),
        }
    }

    /// The default widget inside the popover.
    pub fn default_widget(self, default_widget: &impl IsA<Widget>) -> Self {
        Self {
            builder: self
                .builder
                .property("default-widget", default_widget.clone().upcast()),
        }
    }

    /// Whether to draw an arrow.
    pub fn has_arrow(self, has_arrow: bool) -> Self {
        Self {
            builder: self.builder.property("has-arrow", has_arrow),
        }
    }

    /// Whether mnemonics are currently visible in this popover.
    pub fn mnemonics_visible(self, mnemonics_visible: bool) -> Self {
        Self {
            builder: self
                .builder
                .property("mnemonics-visible", mnemonics_visible),
        }
    }

    /// Rectangle in the parent widget that the popover points to.
    pub fn pointing_to(self, pointing_to: &gdk::Rectangle) -> Self {
        Self {
            builder: self.builder.property("pointing-to", pointing_to),
        }
    }

    /// How to place the popover, relative to its parent.
    pub fn position(self, position: PositionType) -> Self {
        Self {
            builder: self.builder.property("position", position),
        }
    }

    /// Whether the widget or any of its descendents can accept
    /// the input focus.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    pub fn can_focus(self, can_focus: bool) -> Self {
        Self {
            builder: self.builder.property("can-focus", can_focus),
        }
    }

    /// Whether the widget can receive pointer events.
    pub fn can_target(self, can_target: bool) -> Self {
        Self {
            builder: self.builder.property("can-target", can_target),
        }
    }

    /// A list of css classes applied to this widget.
    pub fn css_classes(self, css_classes: impl Into<glib::StrV>) -> Self {
        Self {
            builder: self.builder.property("css-classes", css_classes.into()),
        }
    }

    /// The name of this widget in the CSS tree.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    pub fn css_name(self, css_name: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("css-name", css_name.into()),
        }
    }

    /// The cursor used by @widget.
    pub fn cursor(self, cursor: &gdk::Cursor) -> Self {
        Self {
            builder: self.builder.property("cursor", cursor.clone()),
        }
    }

    /// Whether the widget should grab focus when it is clicked with the mouse.
    ///
    /// This property is only relevant for widgets that can take focus.
    pub fn focus_on_click(self, focus_on_click: bool) -> Self {
        Self {
            builder: self.builder.property("focus-on-click", focus_on_click),
        }
    }

    /// Whether this widget itself will accept the input focus.
    pub fn focusable(self, focusable: bool) -> Self {
        Self {
            builder: self.builder.property("focusable", focusable),
        }
    }

    /// How to distribute horizontal space if widget gets extra space.
    pub fn halign(self, halign: Align) -> Self {
        Self {
            builder: self.builder.property("halign", halign),
        }
    }

    /// Enables or disables the emission of the ::query-tooltip signal on @widget.
    ///
    /// A value of [`true`] indicates that @widget can have a tooltip, in this case
    /// the widget will be queried using [`query-tooltip`][struct@crate::Widget#query-tooltip] to
    /// determine whether it will provide a tooltip or not.
    pub fn has_tooltip(self, has_tooltip: bool) -> Self {
        Self {
            builder: self.builder.property("has-tooltip", has_tooltip),
        }
    }

    /// Override for height request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    pub fn height_request(self, height_request: i32) -> Self {
        Self {
            builder: self.builder.property("height-request", height_request),
        }
    }

    /// Whether to expand horizontally.
    pub fn hexpand(self, hexpand: bool) -> Self {
        Self {
            builder: self.builder.property("hexpand", hexpand),
        }
    }

    /// Whether to use the `hexpand` property.
    pub fn hexpand_set(self, hexpand_set: bool) -> Self {
        Self {
            builder: self.builder.property("hexpand-set", hexpand_set),
        }
    }

    /// The [`LayoutManager`][crate::LayoutManager] instance to use to compute the preferred size
    /// of the widget, and allocate its children.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    pub fn layout_manager(self, layout_manager: &impl IsA<LayoutManager>) -> Self {
        Self {
            builder: self
                .builder
                .property("layout-manager", layout_manager.clone().upcast()),
        }
    }

    /// Margin on bottom side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    pub fn margin_bottom(self, margin_bottom: i32) -> Self {
        Self {
            builder: self.builder.property("margin-bottom", margin_bottom),
        }
    }

    /// Margin on end of widget, horizontally.
    ///
    /// This property supports left-to-right and right-to-left text
    /// directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    pub fn margin_end(self, margin_end: i32) -> Self {
        Self {
            builder: self.builder.property("margin-end", margin_end),
        }
    }

    /// Margin on start of widget, horizontally.
    ///
    /// This property supports left-to-right and right-to-left text
    /// directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    pub fn margin_start(self, margin_start: i32) -> Self {
        Self {
            builder: self.builder.property("margin-start", margin_start),
        }
    }

    /// Margin on top side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    pub fn margin_top(self, margin_top: i32) -> Self {
        Self {
            builder: self.builder.property("margin-top", margin_top),
        }
    }

    /// The name of the widget.
    pub fn name(self, name: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("name", name.into()),
        }
    }

    /// The requested opacity of the widget.
    pub fn opacity(self, opacity: f64) -> Self {
        Self {
            builder: self.builder.property("opacity", opacity),
        }
    }

    /// How content outside the widget's content area is treated.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    pub fn overflow(self, overflow: Overflow) -> Self {
        Self {
            builder: self.builder.property("overflow", overflow),
        }
    }

    /// Whether the widget will receive the default action when it is focused.
    pub fn receives_default(self, receives_default: bool) -> Self {
        Self {
            builder: self.builder.property("receives-default", receives_default),
        }
    }

    /// Whether the widget responds to input.
    pub fn sensitive(self, sensitive: bool) -> Self {
        Self {
            builder: self.builder.property("sensitive", sensitive),
        }
    }

    /// Sets the text of tooltip to be the given string, which is marked up
    /// with Pango markup.
    ///
    /// Also see [`Tooltip::set_markup()`][crate::Tooltip::set_markup()].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]:
    /// [`has-tooltip`][struct@crate::Widget#has-tooltip] will automatically be set to [`true`]
    /// and there will be taken care of [`query-tooltip`][struct@crate::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::Widget#tooltip-markup] are set, the last one wins.
    pub fn tooltip_markup(self, tooltip_markup: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("tooltip-markup", tooltip_markup.into()),
        }
    }

    /// Sets the text of tooltip to be the given string.
    ///
    /// Also see [`Tooltip::set_text()`][crate::Tooltip::set_text()].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]:
    /// [`has-tooltip`][struct@crate::Widget#has-tooltip] will automatically be set to [`true`]
    /// and there will be taken care of [`query-tooltip`][struct@crate::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::Widget#tooltip-markup] are set, the last one wins.
    pub fn tooltip_text(self, tooltip_text: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("tooltip-text", tooltip_text.into()),
        }
    }

    /// How to distribute vertical space if widget gets extra space.
    pub fn valign(self, valign: Align) -> Self {
        Self {
            builder: self.builder.property("valign", valign),
        }
    }

    /// Whether to expand vertically.
    pub fn vexpand(self, vexpand: bool) -> Self {
        Self {
            builder: self.builder.property("vexpand", vexpand),
        }
    }

    /// Whether to use the `vexpand` property.
    pub fn vexpand_set(self, vexpand_set: bool) -> Self {
        Self {
            builder: self.builder.property("vexpand-set", vexpand_set),
        }
    }

    /// Whether the widget is visible.
    pub fn visible(self, visible: bool) -> Self {
        Self {
            builder: self.builder.property("visible", visible),
        }
    }

    /// Override for width request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    pub fn width_request(self, width_request: i32) -> Self {
        Self {
            builder: self.builder.property("width-request", width_request),
        }
    }

    /// The accessible role of the given [`Accessible`][crate::Accessible] implementation.
    ///
    /// The accessible role cannot be changed once set.
    pub fn accessible_role(self, accessible_role: AccessibleRole) -> Self {
        Self {
            builder: self.builder.property("accessible-role", accessible_role),
        }
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`PopoverMenu`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> PopoverMenu {
        self.builder.build()
    }
}