jean
/
Learning_GTK4_tree
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Learning_GTK4_tree/gtk/gtkpopovermenu.c

958 lines
31 KiB
C
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* GTK - The GIMP Toolkit
* Copyright © 2014 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gtkpopovermenu.h"
#include "gtkpopovermenuprivate.h"
#include "gtkstack.h"
#include "gtkmenusectionboxprivate.h"
#include "gtkmenubutton.h"
#include "gtkactionmuxerprivate.h"
#include "gtkmenutrackerprivate.h"
#include "gtkpopoverprivate.h"
#include "gtkwidgetprivate.h"
#include "gtkeventcontrollerfocus.h"
#include "gtkeventcontrollermotion.h"
#include "gtkmain.h"
#include "gtktypebuiltins.h"
#include "gtkmodelbuttonprivate.h"
#include "gtkpopovermenubar.h"
#include "gtkshortcutmanager.h"
#include "gtkshortcutcontroller.h"
#include "gtkbuildable.h"
#include "gtkscrolledwindow.h"
#include "gtkviewport.h"
/**
* GtkPopoverMenu:
*
* `GtkPopoverMenu` is a subclass of `GtkPopover` that implements menu
* behavior.
*
* ![An example GtkPopoverMenu](menu.png)
*
* `GtkPopoverMenu` 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 [property@Gtk.PopoverMenu:flags] controls this appearance.
*
* `GtkPopoverMenu` is meant to be used primarily with menu models,
* using [ctor@Gtk.PopoverMenu.new_from_model]. If you need to put
* other widgets such as a `GtkSpinButton` or a `GtkSwitch` into a popover,
* you can use [method@Gtk.PopoverMenu.add_child].
*
* For more dialog-like behavior, use a plain `GtkPopover`.
*
* ## Menu models
*
* The XML format understood by `GtkBuilder` 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 `GtkBuilder`
* 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 `GtkBuilder` 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 [method@Gtk.Application.set_menubar].
* - "custom": a string used to match against the ID of a custom child added with
* [method@Gtk.PopoverMenu.add_child], [method@Gtk.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 `GtkTextDirection` 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 [method@Gtk.Application.set_accels_for_action],
* [method@WidgetClass.add_binding_action] or
* [method@Gtk.ShortcutController.add_shortcut].
*
* # CSS Nodes
*
* `GtkPopoverMenu` is just a subclass of `GtkPopover` 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
*
* `GtkPopoverMenu` uses the %GTK_ACCESSIBLE_ROLE_MENU role, and its
* items use the %GTK_ACCESSIBLE_ROLE_MENU_ITEM,
* %GTK_ACCESSIBLE_ROLE_MENU_ITEM_CHECKBOX or
* %GTK_ACCESSIBLE_ROLE_MENU_ITEM_RADIO roles, depending on the
* action they are connected to.
*/
typedef struct _GtkPopoverMenuClass GtkPopoverMenuClass;
struct _GtkPopoverMenu
{
GtkPopover parent_instance;
GtkWidget *active_item;
GtkWidget *open_submenu;
GtkWidget *parent_menu;
GMenuModel *model;
GtkPopoverMenuFlags flags;
};
struct _GtkPopoverMenuClass
{
GtkPopoverClass parent_class;
};
enum {
PROP_VISIBLE_SUBMENU = 1,
PROP_MENU_MODEL,
PROP_FLAGS
};
static void gtk_popover_menu_buildable_iface_init (GtkBuildableIface *iface);
G_DEFINE_TYPE_WITH_CODE (GtkPopoverMenu, gtk_popover_menu, GTK_TYPE_POPOVER,
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_popover_menu_buildable_iface_init))
GtkWidget *
gtk_popover_menu_get_parent_menu (GtkPopoverMenu *menu)
{
return menu->parent_menu;
}
void
gtk_popover_menu_set_parent_menu (GtkPopoverMenu *menu,
GtkWidget *parent)
{
menu->parent_menu = parent;
}
GtkWidget *
gtk_popover_menu_get_open_submenu (GtkPopoverMenu *menu)
{
return menu->open_submenu;
}
void
gtk_popover_menu_set_open_submenu (GtkPopoverMenu *menu,
GtkWidget *submenu)
{
menu->open_submenu = submenu;
}
void
gtk_popover_menu_close_submenus (GtkPopoverMenu *menu)
{
GtkWidget *submenu;
submenu = menu->open_submenu;
if (submenu)
{
gtk_popover_menu_close_submenus (GTK_POPOVER_MENU (submenu));
gtk_widget_set_visible (submenu, FALSE);
gtk_popover_menu_set_open_submenu (menu, NULL);
}
}
GtkWidget *
gtk_popover_menu_get_active_item (GtkPopoverMenu *menu)
{
return menu->active_item;
}
void
gtk_popover_menu_set_active_item (GtkPopoverMenu *menu,
GtkWidget *item)
{
if (menu->active_item != item)
{
if (menu->active_item)
{
gtk_widget_unset_state_flags (menu->active_item, GTK_STATE_FLAG_SELECTED);
g_object_remove_weak_pointer (G_OBJECT (menu->active_item), (gpointer *)&menu->active_item);
}
menu->active_item = item;
if (menu->active_item)
{
GtkWidget *popover;
g_object_add_weak_pointer (G_OBJECT (menu->active_item), (gpointer *)&menu->active_item);
gtk_widget_set_state_flags (menu->active_item, GTK_STATE_FLAG_SELECTED, FALSE);
if (GTK_IS_MODEL_BUTTON (item))
g_object_get (item, "popover", &popover, NULL);
else
popover = NULL;
if (!popover || popover != menu->open_submenu)
gtk_widget_grab_focus (menu->active_item);
g_clear_object (&popover);
}
}
}
static void
visible_submenu_changed (GObject *object,
GParamSpec *pspec,
GtkPopoverMenu *popover)
{
g_object_notify (G_OBJECT (popover), "visible-submenu");
}
static void
focus_out (GtkEventController *controller,
GtkPopoverMenu *menu)
{
GtkRoot *root;
GtkWidget *new_focus;
root = gtk_widget_get_root (GTK_WIDGET (menu));
if (!root)
return;
new_focus = gtk_root_get_focus (root);
if (!gtk_event_controller_focus_contains_focus (GTK_EVENT_CONTROLLER_FOCUS (controller)) &&
new_focus != NULL)
{
if (menu->parent_menu &&
GTK_POPOVER_MENU (menu->parent_menu)->open_submenu == (GtkWidget*) menu)
GTK_POPOVER_MENU (menu->parent_menu)->open_submenu = NULL;
gtk_popover_popdown (GTK_POPOVER (menu));
}
}
static void
leave_cb (GtkEventController *controller,
gpointer data)
{
if (!gtk_event_controller_motion_contains_pointer (GTK_EVENT_CONTROLLER_MOTION (controller)))
{
GtkWidget *target = gtk_event_controller_get_widget (controller);
gtk_popover_menu_set_active_item (GTK_POPOVER_MENU (target), NULL);
}
}
static void
gtk_popover_menu_init (GtkPopoverMenu *popover)
{
GtkWidget *sw;
GtkWidget *stack;
GtkEventController *controller;
GtkEventController **controllers;
guint n_controllers, i;
sw = gtk_scrolled_window_new ();
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_propagate_natural_width (GTK_SCROLLED_WINDOW (sw), TRUE);
gtk_scrolled_window_set_propagate_natural_height (GTK_SCROLLED_WINDOW (sw), TRUE);
gtk_popover_set_child (GTK_POPOVER (popover), sw);
stack = gtk_stack_new ();
gtk_stack_set_vhomogeneous (GTK_STACK (stack), FALSE);
gtk_stack_set_transition_type (GTK_STACK (stack), GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT);
gtk_stack_set_interpolate_size (GTK_STACK (stack), TRUE);
gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), stack);
g_signal_connect (stack, "notify::visible-child-name",
G_CALLBACK (visible_submenu_changed), popover);
gtk_widget_add_css_class (GTK_WIDGET (popover), "menu");
controller = gtk_event_controller_focus_new ();
g_signal_connect (controller, "leave", G_CALLBACK (focus_out), popover);
gtk_widget_add_controller (GTK_WIDGET (popover), controller);
controller = gtk_event_controller_motion_new ();
g_signal_connect (controller, "notify::contains-pointer", G_CALLBACK (leave_cb), popover);
gtk_widget_add_controller (GTK_WIDGET (popover), controller);
controllers = gtk_widget_list_controllers (GTK_WIDGET (popover), GTK_PHASE_CAPTURE, &n_controllers);
for (i = 0; i < n_controllers; i ++)
{
controller = controllers[i];
if (GTK_IS_SHORTCUT_CONTROLLER (controller) &&
strcmp (gtk_event_controller_get_name (controller), "gtk-shortcut-manager-capture") == 0)
gtk_shortcut_controller_set_mnemonics_modifiers (GTK_SHORTCUT_CONTROLLER (controller), 0);
}
g_free (controllers);
gtk_popover_disable_auto_mnemonics (GTK_POPOVER (popover));
gtk_popover_set_cascade_popdown (GTK_POPOVER (popover), TRUE);
}
GtkWidget *
gtk_popover_menu_get_stack (GtkPopoverMenu *menu)
{
GtkWidget *sw = gtk_popover_get_child (GTK_POPOVER (menu));
GtkWidget *vp = gtk_scrolled_window_get_child (GTK_SCROLLED_WINDOW (sw));
GtkWidget *stack = gtk_viewport_get_child (GTK_VIEWPORT (vp));
return stack;
}
static void
gtk_popover_menu_dispose (GObject *object)
{
GtkPopoverMenu *popover = GTK_POPOVER_MENU (object);
if (popover->active_item)
{
g_object_remove_weak_pointer (G_OBJECT (popover->active_item), (gpointer *)&popover->active_item);
popover->active_item = NULL;
}
g_clear_object (&popover->model);
G_OBJECT_CLASS (gtk_popover_menu_parent_class)->dispose (object);
}
static void
gtk_popover_menu_map (GtkWidget *widget)
{
gtk_popover_menu_open_submenu (GTK_POPOVER_MENU (widget), "main");
GTK_WIDGET_CLASS (gtk_popover_menu_parent_class)->map (widget);
}
static void
gtk_popover_menu_unmap (GtkWidget *widget)
{
GTK_WIDGET_CLASS (gtk_popover_menu_parent_class)->unmap (widget);
gtk_popover_menu_open_submenu (GTK_POPOVER_MENU (widget), "main");
}
static void
gtk_popover_menu_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GtkPopoverMenu *menu = GTK_POPOVER_MENU (object);
switch (property_id)
{
case PROP_VISIBLE_SUBMENU:
g_value_set_string (value, gtk_stack_get_visible_child_name (GTK_STACK (gtk_popover_menu_get_stack (menu))));
break;
case PROP_MENU_MODEL:
g_value_set_object (value, gtk_popover_menu_get_menu_model (menu));
break;
case PROP_FLAGS:
g_value_set_flags (value, gtk_popover_menu_get_flags (menu));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gtk_popover_menu_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GtkPopoverMenu *menu = GTK_POPOVER_MENU (object);
switch (property_id)
{
case PROP_VISIBLE_SUBMENU:
gtk_stack_set_visible_child_name (GTK_STACK (gtk_popover_menu_get_stack (menu)), g_value_get_string (value));
break;
case PROP_MENU_MODEL:
gtk_popover_menu_set_menu_model (menu, g_value_get_object (value));
break;
case PROP_FLAGS:
gtk_popover_menu_set_flags (menu, g_value_get_flags (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static gboolean
gtk_popover_menu_focus (GtkWidget *widget,
GtkDirectionType direction)
{
GtkPopoverMenu *menu = GTK_POPOVER_MENU (widget);
if (gtk_widget_get_first_child (widget) == NULL)
{
return FALSE;
}
else
{
if (menu->open_submenu)
{
if (gtk_widget_child_focus (menu->open_submenu, direction))
return TRUE;
if (direction == GTK_DIR_LEFT)
{
if (menu->open_submenu)
{
gtk_popover_popdown (GTK_POPOVER (menu->open_submenu));
menu->open_submenu = NULL;
}
gtk_widget_grab_focus (menu->active_item);
return TRUE;
}
return FALSE;
}
if (gtk_widget_focus_move (widget, direction))
return TRUE;
if (direction == GTK_DIR_LEFT || direction == GTK_DIR_RIGHT)
{
/* If we are part of a menubar, we want to let the
* menubar use left/right arrows for cycling, else
* we eat them.
*/
if (gtk_widget_get_ancestor (widget, GTK_TYPE_POPOVER_MENU_BAR) ||
(gtk_popover_menu_get_parent_menu (menu) &&
direction == GTK_DIR_LEFT))
return FALSE;
else
return TRUE;
}
/* Cycle around with up/down arrows and (Shift+)Tab when modal */
else if (gtk_popover_get_autohide (GTK_POPOVER (menu)))
{
GtkWidget *p = gtk_root_get_focus (gtk_widget_get_root (widget));
/* In the case where the popover doesn't have any focusable child, if
* the menu doesn't have any item for example, then the focus will end
* up out of the popover, hence creating an infinite loop below. To
* avoid this, just say we had focus and stop here.
*/
if (!gtk_widget_is_ancestor (p, widget) && p != widget)
return TRUE;
/* cycle around */
for (;
p != widget;
p = gtk_widget_get_parent (p))
{
gtk_widget_set_focus_child (p, NULL);
}
if (gtk_widget_focus_move (widget, direction))
return TRUE;
}
}
return FALSE;
}
static void
add_tab_bindings (GtkWidgetClass *widget_class,
GdkModifierType modifiers,
GtkDirectionType direction)
{
gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_Tab, modifiers,
"move-focus",
"(i)", direction);
gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_KP_Tab, modifiers,
"move-focus",
"(i)", direction);
}
static void
add_arrow_bindings (GtkWidgetClass *widget_class,
guint keysym,
GtkDirectionType direction)
{
guint keypad_keysym = keysym - GDK_KEY_Left + GDK_KEY_KP_Left;
gtk_widget_class_add_binding_signal (widget_class, keysym, 0,
"move-focus",
"(i)", direction);
gtk_widget_class_add_binding_signal (widget_class, keysym, GDK_CONTROL_MASK,
"move-focus",
"(i)", direction);
gtk_widget_class_add_binding_signal (widget_class, keypad_keysym, 0,
"move-focus",
"(i)", direction);
gtk_widget_class_add_binding_signal (widget_class, keypad_keysym, GDK_CONTROL_MASK,
"move-focus",
"(i)", direction);
}
static void
gtk_popover_menu_show (GtkWidget *widget)
{
gtk_popover_menu_set_open_submenu (GTK_POPOVER_MENU (widget), NULL);
GTK_WIDGET_CLASS (gtk_popover_menu_parent_class)->show (widget);
}
static void
gtk_popover_menu_move_focus (GtkWidget *widget,
GtkDirectionType direction)
{
gtk_popover_set_mnemonics_visible (GTK_POPOVER (widget), TRUE);
GTK_WIDGET_CLASS (gtk_popover_menu_parent_class)->move_focus (widget, direction);
}
static void
gtk_popover_menu_root (GtkWidget *widget)
{
GTK_WIDGET_CLASS (gtk_popover_menu_parent_class)->root (widget);
gtk_accessible_update_property (GTK_ACCESSIBLE (widget),
GTK_ACCESSIBLE_PROPERTY_ORIENTATION, GTK_ORIENTATION_VERTICAL,
-1);
}
static void
gtk_popover_menu_class_init (GtkPopoverMenuClass *klass)
{
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->dispose = gtk_popover_menu_dispose;
object_class->set_property = gtk_popover_menu_set_property;
object_class->get_property = gtk_popover_menu_get_property;
widget_class->root = gtk_popover_menu_root;
widget_class->map = gtk_popover_menu_map;
widget_class->unmap = gtk_popover_menu_unmap;
widget_class->focus = gtk_popover_menu_focus;
widget_class->show = gtk_popover_menu_show;
widget_class->move_focus = gtk_popover_menu_move_focus;
/**
* GtkPopoverMenu:visible-submenu:
*
* The name of the visible submenu.
*/
g_object_class_install_property (object_class,
PROP_VISIBLE_SUBMENU,
g_param_spec_string ("visible-submenu", NULL, NULL,
NULL,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GtkPopoverMenu:menu-model: (attributes org.gtk.Property.get=gtk_popover_menu_get_menu_model org.gtk.Property.set=gtk_popover_menu_set_menu_model)
*
* The model from which the menu is made.
*/
g_object_class_install_property (object_class,
PROP_MENU_MODEL,
g_param_spec_object ("menu-model", NULL, NULL,
G_TYPE_MENU_MODEL,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GtkPopoverMenu:flags: (attributes org.gtk.Property.get=gtk_popover_menu_get_flags org.gtk.Property.set=gtk_popover_menu_set_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.
*
* Since: 4.14
*/
g_object_class_install_property (object_class,
PROP_FLAGS,
g_param_spec_flags ("flags", NULL, NULL,
GTK_TYPE_POPOVER_MENU_FLAGS, 0,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS
| G_PARAM_EXPLICIT_NOTIFY));
add_arrow_bindings (widget_class, GDK_KEY_Up, GTK_DIR_UP);
add_arrow_bindings (widget_class, GDK_KEY_Down, GTK_DIR_DOWN);
add_arrow_bindings (widget_class, GDK_KEY_Left, GTK_DIR_LEFT);
add_arrow_bindings (widget_class, GDK_KEY_Right, GTK_DIR_RIGHT);
add_tab_bindings (widget_class, 0, GTK_DIR_TAB_FORWARD);
add_tab_bindings (widget_class, GDK_CONTROL_MASK, GTK_DIR_TAB_FORWARD);
add_tab_bindings (widget_class, GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
add_tab_bindings (widget_class, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_Return, 0,
"activate-default", NULL);
gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_ISO_Enter, 0,
"activate-default", NULL);
gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_KP_Enter, 0,
"activate-default", NULL);
gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_space, 0,
"activate-default", NULL);
gtk_widget_class_add_binding_signal (widget_class, GDK_KEY_KP_Space, 0,
"activate-default", NULL);
gtk_widget_class_set_accessible_role (widget_class, GTK_ACCESSIBLE_ROLE_MENU);
}
static GtkBuildableIface *parent_buildable_iface;
static void
gtk_popover_menu_buildable_add_child (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
const char *type)
{
if (GTK_IS_WIDGET (child))
{
if (!gtk_popover_menu_add_child (GTK_POPOVER_MENU (buildable), GTK_WIDGET (child), type))
g_warning ("No such custom attribute: %s", type);
}
else
parent_buildable_iface->add_child (buildable, builder, child, type);
}
static void
gtk_popover_menu_buildable_iface_init (GtkBuildableIface *iface)
{
parent_buildable_iface = g_type_interface_peek_parent (iface);
iface->add_child = gtk_popover_menu_buildable_add_child;
}
static void
gtk_popover_menu_rebuild_contents (GtkPopoverMenu *popover)
{
GtkWidget *stack;
GtkWidget *child;
stack = gtk_popover_menu_get_stack (popover);
while ((child = gtk_widget_get_first_child (stack)))
gtk_stack_remove (GTK_STACK (stack), child);
if (popover->model)
gtk_menu_section_box_new_toplevel (popover, popover->model, popover->flags);
}
/**
* gtk_popover_menu_new:
*
* Creates a new popover menu.
*
* Returns: a new `GtkPopoverMenu`
*/
GtkWidget *
gtk_popover_menu_new (void)
{
GtkWidget *popover;
popover = g_object_new (GTK_TYPE_POPOVER_MENU,
"autohide", TRUE,
NULL);
return popover;
}
/*<private>
* gtk_popover_menu_open_submenu:
* @popover: a `GtkPopoverMenu`
* @name: the name of the menu to switch to
*
* Opens a submenu of the @popover. The @name
* must be one of the names given to the submenus
* of @popover with `GtkPopoverMenu:submenu`, or
* "main" to switch back to the main menu.
*
* `GtkModelButton` will open submenus automatically
* when the `GtkModelButton:menu-name` property is set,
* so this function is only needed when you are using
* other kinds of widgets to initiate menu changes.
*/
void
gtk_popover_menu_open_submenu (GtkPopoverMenu *popover,
const char *name)
{
GtkWidget *stack;
g_return_if_fail (GTK_IS_POPOVER_MENU (popover));
stack = gtk_popover_menu_get_stack (popover);
gtk_stack_set_visible_child_name (GTK_STACK (stack), name);
}
void
gtk_popover_menu_add_submenu (GtkPopoverMenu *popover,
GtkWidget *submenu,
const char *name)
{
GtkWidget *stack = gtk_popover_menu_get_stack (popover);
gtk_stack_add_named (GTK_STACK (stack), submenu, name);
}
/**
* gtk_popover_menu_new_from_model:
* @model: (nullable): a `GMenuModel`
*
* Creates a `GtkPopoverMenu` and populates it according to @model.
*
* The created buttons are connected to actions found in the
* `GtkApplicationWindow` to which the popover belongs - typically
* by means of being attached to a widget that is contained within
* the `GtkApplicationWindow`s widget hierarchy.
*
* Actions can also be added using [method@Gtk.Widget.insert_action_group]
* on the menus attach widget or on any of its parent widgets.
*
* This function creates menus with sliding submenus.
* See [ctor@Gtk.PopoverMenu.new_from_model_full] for a way
* to control this.
*
* Returns: the new `GtkPopoverMenu`
*/
GtkWidget *
gtk_popover_menu_new_from_model (GMenuModel *model)
{
return gtk_popover_menu_new_from_model_full (model, 0);
}
/**
* gtk_popover_menu_new_from_model_full:
* @model: a `GMenuModel`
* @flags: flags that affect how the menu is created
*
* Creates a `GtkPopoverMenu` 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 `GtkApplicationWindow` to which the popover
* belongs. Actions can also be added using [method@Gtk.Widget.insert_action_group]
* on the parent widget or on any of its parent widgets.
*
* The only flag that is supported currently is
* %GTK_POPOVER_MENU_NESTED, which makes GTK create traditional,
* nested submenus instead of the default sliding submenus.
*
* Returns: the new `GtkPopoverMenu`
*/
GtkWidget *
gtk_popover_menu_new_from_model_full (GMenuModel *model,
GtkPopoverMenuFlags flags)
{
GtkWidget *popover;
g_return_val_if_fail (model == NULL || G_IS_MENU_MODEL (model), NULL);
popover = gtk_popover_menu_new ();
gtk_popover_menu_set_flags (GTK_POPOVER_MENU (popover), flags);
gtk_popover_menu_set_menu_model (GTK_POPOVER_MENU (popover), model);
return popover;
}
/**
* gtk_popover_menu_set_menu_model: (attributes org.gtk.Method.set_property=menu-model)
* @popover: a `GtkPopoverMenu`
* @model: (nullable): a `GMenuModel`
*
* Sets a new menu model on @popover.
*
* The existing contents of @popover are removed, and
* the @popover is populated with new contents according
* to @model.
*/
void
gtk_popover_menu_set_menu_model (GtkPopoverMenu *popover,
GMenuModel *model)
{
g_return_if_fail (GTK_IS_POPOVER_MENU (popover));
g_return_if_fail (model == NULL || G_IS_MENU_MODEL (model));
if (g_set_object (&popover->model, model))
{
gtk_popover_menu_rebuild_contents (popover);
g_object_notify (G_OBJECT (popover), "menu-model");
}
}
/**
* gtk_popover_menu_set_flags: (attributes org.gtk.Method.set_property=flags)
* @popover: a `GtkPopoverMenu`
* @flags: a set of `GtkPopoverMenuFlags`
*
* Sets 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.
*
* Since: 4.14
*/
void
gtk_popover_menu_set_flags (GtkPopoverMenu *popover,
GtkPopoverMenuFlags flags)
{
g_return_if_fail (GTK_IS_POPOVER_MENU (popover));
if (popover->flags == flags)
return;
popover->flags = flags;
/* This shouldn’t happen IRL, but notify test unsets :child, so dodge error */
if (gtk_popover_get_child (GTK_POPOVER (popover)) != NULL)
gtk_popover_menu_rebuild_contents (popover);
g_object_notify (G_OBJECT (popover), "flags");
}
/**
* gtk_popover_menu_get_menu_model: (attributes org.gtk.Method.get_property=menu-model)
* @popover: a `GtkPopoverMenu`
*
* Returns the menu model used to populate the popover.
*
* Returns: (transfer none) (nullable): the menu model of @popover
*/
GMenuModel *
gtk_popover_menu_get_menu_model (GtkPopoverMenu *popover)
{
g_return_val_if_fail (GTK_IS_POPOVER_MENU (popover), NULL);
return popover->model;
}
/**
* gtk_popover_menu_get_flags: (attributes org.gtk.Method.get_property=flags)
* @popover: a `GtkPopoverMenu`
*
* Returns the flags that @popover uses to create/display a menu from its model.
*
* Returns: the `GtkPopoverMenuFlags`
*
* Since: 4.14
*/
GtkPopoverMenuFlags
gtk_popover_menu_get_flags (GtkPopoverMenu *popover)
{
g_return_val_if_fail (GTK_IS_POPOVER_MENU (popover), 0);
return popover->flags;
}
/**
* gtk_popover_menu_add_child:
* @popover: a `GtkPopoverMenu`
* @child: the `GtkWidget` to add
* @id: the ID to insert @child at
*
* Adds a custom widget to a generated menu.
*
* For this to work, the menu model of @popover must have
* an item with a `custom` attribute that matches @id.
*
* Returns: %TRUE if @id was found and the widget added
*/
gboolean
gtk_popover_menu_add_child (GtkPopoverMenu *popover,
GtkWidget *child,
const char *id)
{
g_return_val_if_fail (GTK_IS_POPOVER_MENU (popover), FALSE);
g_return_val_if_fail (GTK_IS_WIDGET (child), FALSE);
g_return_val_if_fail (id != NULL, FALSE);
return gtk_menu_section_box_add_custom (popover, child, id);
}
/**
* gtk_popover_menu_remove_child:
* @popover: a `GtkPopoverMenu`
* @child: the `GtkWidget` to remove
*
* Removes a widget that has previously been added with
* [method@Gtk.PopoverMenu.add_child()]
*
* Returns: %TRUE if the widget was removed
*/
gboolean
gtk_popover_menu_remove_child (GtkPopoverMenu *popover,
GtkWidget *child)
{
g_return_val_if_fail (GTK_IS_POPOVER_MENU (popover), FALSE);
g_return_val_if_fail (GTK_IS_WIDGET (child), FALSE);
return gtk_menu_section_box_remove_custom (popover, child);
}
Reference in New Issue View Git Blame Copy Permalink