AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
0aad053507
gtk2/gtk/gtkmenusectionbox.c
Christopher Davis 0775e21131 Add support for pango markup in menu items 
Before c4a2234a28
menu models could use markup for items and the markup would
be parsed, but this was not intended behavior.

This commit adds official support for using markup
for menu items via the `use-markup` property.

Fixes https://gitlab.gnome.org/GNOME/gtk/-/issues/4306
2021-10-07 02:49:11 -07:00

781 lines
26 KiB
C
Raw Blame History

/*
* Copyright © 2014 Canonical Limited
* Copyright © 2013 Carlos Garnacho
*
* 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 licence, 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/>.
*
* Author: Ryan Lortie <desrt@desrt.ca>
*/
#include "config.h"
#include "gtkmenusectionboxprivate.h"
#include "gtkwidgetprivate.h"
#include "gtklabel.h"
#include "gtkmenutrackerprivate.h"
#include "gtkmodelbuttonprivate.h"
#include "gtkseparator.h"
#include "gtksizegroup.h"
#include "gtkstack.h"
#include "gtkpopovermenuprivate.h"
#include "gtkorientable.h"
#include "gtkbuiltiniconprivate.h"
#include "gtkgizmoprivate.h"
#include "gtkbinlayout.h"
#include "gtkprivate.h"
typedef GtkBoxClass GtkMenuSectionBoxClass;
struct _GtkMenuSectionBox
{
GtkBox parent_instance;
GtkMenuSectionBox *toplevel;
GtkMenuTracker *tracker;
GtkBox *item_box;
GtkWidget *separator;
guint separator_sync_idle;
gboolean iconic;
gboolean inline_buttons;
gboolean circular;
int depth;
GtkPopoverMenuFlags flags;
GtkSizeGroup *indicators;
GHashTable *custom_slots;
};
typedef struct
{
int n_items;
gboolean previous_is_iconic;
} MenuData;
G_DEFINE_TYPE (GtkMenuSectionBox, gtk_menu_section_box, GTK_TYPE_BOX)
static void gtk_menu_section_box_sync_separators (GtkMenuSectionBox *box,
MenuData *data);
static void gtk_menu_section_box_new_submenu (GtkMenuTrackerItem *item,
GtkMenuSectionBox *toplevel,
GtkWidget *focus,
const char *name);
static GtkWidget * gtk_menu_section_box_new_section (GtkMenuTrackerItem *item,
GtkMenuSectionBox *parent);
/* We are trying to implement the following rules here:
*
* rule 1: never ever show separators for empty sections
* rule 2: always show a separator if there is a label
* rule 3: don't show a separator for the first section
* rule 4: don't show a separator for the following sections if there are
* no items before it
* rule 5: never show separators directly above or below an iconic box
* (rule 6: these rules don't apply exactly the same way for subsections)
*/
static void
gtk_menu_section_box_sync_separators (GtkMenuSectionBox *box,
MenuData *data)
{
gboolean previous_section_is_iconic;
gboolean should_have_separator;
gboolean should_have_top_margin = FALSE;
gboolean is_not_empty_item;
gboolean has_separator;
gboolean has_label;
gboolean separator_condition;
int n_items_before;
GtkWidget *child;
n_items_before = data->n_items;
previous_section_is_iconic = data->previous_is_iconic;
for (child = gtk_widget_get_first_child (GTK_WIDGET (box->item_box));
child != NULL;
child = gtk_widget_get_next_sibling (child))
{
if (GTK_IS_MENU_SECTION_BOX (child))
gtk_menu_section_box_sync_separators (GTK_MENU_SECTION_BOX (child), data);
else
data->n_items++;
}
is_not_empty_item = (data->n_items > n_items_before);
if (is_not_empty_item)
data->previous_is_iconic = box->iconic;
if (box->separator == NULL)
return;
has_separator = gtk_widget_get_parent (box->separator) != NULL;
has_label = !GTK_IS_SEPARATOR (box->separator);
separator_condition = has_label ? TRUE : n_items_before > 0 &&
box->depth <= 1 &&
!previous_section_is_iconic &&
!box->iconic;
should_have_separator = separator_condition && is_not_empty_item;
should_have_top_margin = !should_have_separator &&
(box->depth <= 1 || box->iconic || box->circular) &&
n_items_before > 0 &&
is_not_empty_item;
gtk_widget_set_margin_top (GTK_WIDGET (box->item_box), should_have_top_margin ? 10 : 0);
if (has_label)
{
GtkWidget *separator = gtk_widget_get_first_child (box->separator);
gtk_widget_set_visible (separator, n_items_before > 0);
}
if (should_have_separator == has_separator)
return;
if (should_have_separator)
gtk_box_insert_child_after (GTK_BOX (box), box->separator, NULL);
else
gtk_box_remove (GTK_BOX (box), box->separator);
}
static gboolean
gtk_menu_section_box_handle_sync_separators (gpointer user_data)
{
GtkMenuSectionBox *box = user_data;
MenuData data;
data.n_items = 0;
data.previous_is_iconic = FALSE;
gtk_menu_section_box_sync_separators (box, &data);
box->separator_sync_idle = 0;
return G_SOURCE_REMOVE;
}
static void
gtk_menu_section_box_schedule_separator_sync (GtkMenuSectionBox *box)
{
box = box->toplevel;
if (!box->separator_sync_idle)
{
box->separator_sync_idle = g_idle_add_full (G_PRIORITY_HIGH_IDLE, /* before resize... */
gtk_menu_section_box_handle_sync_separators,
box, NULL);
gdk_source_set_static_name_by_id (box->separator_sync_idle, "[gtk] menu section box handle sync separators");
}
}
static void
gtk_popover_item_activate (GtkWidget *button,
gpointer user_data)
{
GtkMenuTrackerItem *item = user_data;
GtkWidget *popover = NULL;
if (gtk_menu_tracker_item_get_role (item) == GTK_MENU_TRACKER_ITEM_ROLE_NORMAL)
{
/* Activating the item could cause the popover
* to be free'd, for example if it is a Quit item
*/
popover = gtk_widget_get_ancestor (button, GTK_TYPE_POPOVER);
if (popover)
g_object_ref (popover);
}
gtk_menu_tracker_item_activated (item);
if (popover != NULL)
{
gtk_widget_hide (popover);
g_object_unref (popover);
}
}
static void
gtk_menu_section_box_remove_func (int position,
gpointer user_data)
{
GtkMenuSectionBox *box = user_data;
GtkMenuTrackerItem *item;
GtkWidget *widget;
int pos;
for (widget = gtk_widget_get_first_child (GTK_WIDGET (box->item_box)), pos = 0;
widget != NULL;
widget = gtk_widget_get_next_sibling (widget), pos++)
{
if (pos == position)
break;
}
item = g_object_get_data (G_OBJECT (widget), "GtkMenuTrackerItem");
if (gtk_menu_tracker_item_get_has_link (item, G_MENU_LINK_SUBMENU))
{
GtkWidget *stack, *subbox;
stack = gtk_widget_get_ancestor (GTK_WIDGET (box->toplevel), GTK_TYPE_STACK);
subbox = gtk_stack_get_child_by_name (GTK_STACK (stack), gtk_menu_tracker_item_get_label (item));
if (subbox != NULL)
gtk_stack_remove (GTK_STACK (stack), subbox);
}
gtk_box_remove (GTK_BOX (box->item_box), widget);
gtk_menu_section_box_schedule_separator_sync (box);
}
static gboolean
get_ancestors (GtkWidget *widget,
GType widget_type,
GtkWidget **ancestor,
GtkWidget **below)
{
GtkWidget *a, *b;
a = NULL;
b = widget;
while (b != NULL)
{
a = gtk_widget_get_parent (b);
if (!a)
return FALSE;
if (g_type_is_a (G_OBJECT_TYPE (a), widget_type))
break;
b = a;
}
*below = b;
*ancestor = a;
return TRUE;
}
static void
close_submenu (GtkWidget *button,
gpointer data)
{
GtkMenuTrackerItem *item = data;
GtkWidget *focus;
if (gtk_menu_tracker_item_get_should_request_show (item))
gtk_menu_tracker_item_request_submenu_shown (item, FALSE);
focus = GTK_WIDGET (g_object_get_data (G_OBJECT (button), "focus"));
gtk_widget_grab_focus (focus);
}
static void
open_submenu (GtkWidget *button,
gpointer data)
{
GtkMenuTrackerItem *item = data;
GtkWidget *focus;
if (gtk_menu_tracker_item_get_should_request_show (item))
gtk_menu_tracker_item_request_submenu_shown (item, TRUE);
focus = GTK_WIDGET (g_object_get_data (G_OBJECT (button), "focus"));
gtk_widget_grab_focus (focus);
}
static void
submenu_shown (GtkPopoverMenu *popover,
GtkMenuTrackerItem *item)
{
if (gtk_menu_tracker_item_get_should_request_show (item))
gtk_menu_tracker_item_request_submenu_shown (item, TRUE);
}
static void
submenu_hidden (GtkPopoverMenu *popover,
GtkMenuTrackerItem *item)
{
if (gtk_menu_tracker_item_get_should_request_show (item))
gtk_menu_tracker_item_request_submenu_shown (item, FALSE);
}
/* We're using the gizmo as an easy single child container, not as
* a custom widget to draw some visual indicators (like markers).
* As such its default focus functions blocks focus through the children,
* so we need to handle it correctly here so that custom widgets inside
* menus can be focused.
*/
static gboolean
custom_widget_focus (GtkGizmo *gizmo,
GtkDirectionType direction)
{
return gtk_widget_focus_child (GTK_WIDGET (gizmo), direction);
}
static gboolean
custom_widget_grab_focus (GtkGizmo *gizmo)
{
return gtk_widget_grab_focus_child (GTK_WIDGET (gizmo));
}
static void
gtk_menu_section_box_insert_func (GtkMenuTrackerItem *item,
int position,
gpointer user_data)
{
GtkMenuSectionBox *box = user_data;
GtkWidget *widget;
if (gtk_menu_tracker_item_get_is_separator (item))
{
widget = gtk_menu_section_box_new_section (item, box);
}
else if (gtk_menu_tracker_item_get_has_link (item, G_MENU_LINK_SUBMENU))
{
if (box->flags & GTK_POPOVER_MENU_NESTED)
{
GMenuModel *model;
GtkWidget *submenu;
model = _gtk_menu_tracker_item_get_link (item, G_MENU_LINK_SUBMENU);
submenu = gtk_popover_menu_new_from_model_full (model, box->flags);
gtk_popover_set_has_arrow (GTK_POPOVER (submenu), FALSE);
gtk_widget_set_valign (submenu, GTK_ALIGN_START);
widget = g_object_new (GTK_TYPE_MODEL_BUTTON,
"popover", submenu,
"indicator-size-group", box->indicators,
NULL);
g_object_bind_property (item, "label", widget, "text", G_BINDING_SYNC_CREATE);
g_object_bind_property (item, "icon", widget, "icon", G_BINDING_SYNC_CREATE);
g_object_bind_property (item, "sensitive", widget, "sensitive", G_BINDING_SYNC_CREATE);
g_signal_connect (submenu, "show", G_CALLBACK (submenu_shown), item);
g_signal_connect (submenu, "hide", G_CALLBACK (submenu_hidden), item);
}
else
{
GtkWidget *stack = NULL;
GtkWidget *parent = NULL;
char *name;
widget = g_object_new (GTK_TYPE_MODEL_BUTTON,
"menu-name", gtk_menu_tracker_item_get_label (item),
"indicator-size-group", box->indicators,
NULL);
g_object_bind_property (item, "label", widget, "text", G_BINDING_SYNC_CREATE);
g_object_bind_property (item, "icon", widget, "icon", G_BINDING_SYNC_CREATE);
g_object_bind_property (item, "sensitive", widget, "sensitive", G_BINDING_SYNC_CREATE);
get_ancestors (GTK_WIDGET (box->toplevel), GTK_TYPE_STACK, &stack, &parent);
g_object_get (gtk_stack_get_page (GTK_STACK (stack), parent), "name", &name, NULL);
gtk_menu_section_box_new_submenu (item, box->toplevel, widget, name);
g_free (name);
}
}
else if (gtk_menu_tracker_item_get_custom (item))
{
const char *id = gtk_menu_tracker_item_get_custom (item);
widget = gtk_gizmo_new ("widget", NULL, NULL, NULL, NULL, custom_widget_focus, custom_widget_grab_focus);
gtk_widget_set_layout_manager (widget, gtk_bin_layout_new ());
if (g_hash_table_lookup (box->custom_slots, id))
g_warning ("Duplicate custom ID: %s", id);
else
{
char *slot_id = g_strdup (id);
g_object_set_data_full (G_OBJECT (widget), "slot-id", slot_id, g_free);
g_hash_table_insert (box->custom_slots, slot_id, widget);
}
}
else
{
widget = g_object_new (GTK_TYPE_MODEL_BUTTON,
"indicator-size-group", box->indicators,
NULL);
g_object_bind_property (item, "label", widget, "text", G_BINDING_SYNC_CREATE);
if (box->iconic)
{
g_object_bind_property (item, "verb-icon", widget, "icon", G_BINDING_SYNC_CREATE);
g_object_set (widget, "iconic", TRUE, NULL);
}
else if (box->inline_buttons)
{
g_object_bind_property (item, "verb-icon", widget, "icon", G_BINDING_SYNC_CREATE);
g_object_set (widget, "iconic", TRUE, NULL);
gtk_widget_add_css_class (widget, "flat");
}
else if (box->circular)
{
g_object_bind_property (item, "verb-icon", widget, "icon", G_BINDING_SYNC_CREATE);
g_object_set (widget, "iconic", TRUE, NULL);
gtk_widget_add_css_class (widget, "circular");
}
else
g_object_bind_property (item, "icon", widget, "icon", G_BINDING_SYNC_CREATE);
g_object_bind_property (item, "use-markup", widget, "use-markup", G_BINDING_SYNC_CREATE);
g_object_bind_property (item, "sensitive", widget, "sensitive", G_BINDING_SYNC_CREATE);
g_object_bind_property (item, "role", widget, "role", G_BINDING_SYNC_CREATE);
g_object_bind_property (item, "toggled", widget, "active", G_BINDING_SYNC_CREATE);
g_object_bind_property (item, "accel", widget, "accel", G_BINDING_SYNC_CREATE);
g_signal_connect (widget, "clicked", G_CALLBACK (gtk_popover_item_activate), item);
}
g_object_set_data_full (G_OBJECT (widget), "GtkMenuTrackerItem", g_object_ref (item), g_object_unref);
if (box->circular)
{
gtk_widget_set_hexpand (widget, TRUE);
gtk_widget_set_halign (widget, GTK_ALIGN_CENTER);
}
else
{
gtk_widget_set_halign (widget, GTK_ALIGN_FILL);
}
gtk_box_append (GTK_BOX (box->item_box), widget);
if (position == 0)
gtk_box_reorder_child_after (GTK_BOX (box->item_box), widget, NULL);
else
{
GtkWidget *sibling = gtk_widget_get_first_child (GTK_WIDGET (box->item_box));
int i;
for (i = 1; i < position; i++)
sibling = gtk_widget_get_next_sibling (sibling);
gtk_box_reorder_child_after (GTK_BOX (box->item_box), widget, sibling);
}
if (box->circular)
{
GtkWidget *c1, *c2, *c3;
/* special-case the n > 2 case */
c1 = gtk_widget_get_first_child (GTK_WIDGET (box->item_box));
if ((c2 = gtk_widget_get_next_sibling (c1)) != NULL &&
(c3 = gtk_widget_get_next_sibling (c2)) != NULL)
{
gtk_widget_set_halign (c1, GTK_ALIGN_START);
while (c3 != NULL)
{
gtk_widget_set_halign (c2, GTK_ALIGN_CENTER);
c2 = c3;
c3 = gtk_widget_get_next_sibling (c3);
}
gtk_widget_set_halign (c2, GTK_ALIGN_END);
}
}
gtk_menu_section_box_schedule_separator_sync (box);
}
static void
gtk_menu_section_box_init (GtkMenuSectionBox *box)
{
GtkWidget *item_box;
gtk_orientable_set_orientation (GTK_ORIENTABLE (box), GTK_ORIENTATION_VERTICAL);
box->toplevel = box;
item_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
box->item_box = GTK_BOX (item_box);
gtk_box_append (GTK_BOX (box), item_box);
gtk_widget_set_halign (GTK_WIDGET (item_box), GTK_ALIGN_FILL);
gtk_widget_set_halign (GTK_WIDGET (box), GTK_ALIGN_FILL);
}
static void
gtk_menu_section_box_dispose (GObject *object)
{
GtkMenuSectionBox *box = GTK_MENU_SECTION_BOX (object);
if (box->separator_sync_idle)
{
g_source_remove (box->separator_sync_idle);
box->separator_sync_idle = 0;
}
g_clear_object (&box->separator);
if (box->tracker)
{
gtk_menu_tracker_free (box->tracker);
box->tracker = NULL;
}
g_clear_object (&box->indicators);
g_clear_pointer (&box->custom_slots, g_hash_table_unref);
G_OBJECT_CLASS (gtk_menu_section_box_parent_class)->dispose (object);
}
static void
gtk_menu_section_box_class_init (GtkMenuSectionBoxClass *class)
{
G_OBJECT_CLASS (class)->dispose = gtk_menu_section_box_dispose;
}
static void
update_popover_position_cb (GObject *source,
GParamSpec *spec,
gpointer *user_data)
{
GtkPopover *popover = GTK_POPOVER (source);
GtkMenuSectionBox *box = GTK_MENU_SECTION_BOX (user_data);
GtkWidget *w;
GtkPositionType new_pos = gtk_popover_get_position (popover);
for (w = gtk_widget_get_first_child (gtk_widget_get_parent (GTK_WIDGET (box)));
w != NULL;
w = gtk_widget_get_next_sibling (w))
{
if (new_pos == GTK_POS_BOTTOM)
gtk_widget_set_valign (w, GTK_ALIGN_START);
else if (new_pos == GTK_POS_TOP)
gtk_widget_set_valign (w, GTK_ALIGN_END);
else
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
}
}
void
gtk_menu_section_box_new_toplevel (GtkPopoverMenu *popover,
GMenuModel *model,
GtkPopoverMenuFlags flags)
{
GtkMenuSectionBox *box;
box = g_object_new (GTK_TYPE_MENU_SECTION_BOX, NULL);
box->indicators = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
box->custom_slots = g_hash_table_new (g_str_hash, g_str_equal);
box->flags = flags;
gtk_popover_menu_add_submenu (popover, GTK_WIDGET (box), "main");
box->tracker = gtk_menu_tracker_new (GTK_ACTION_OBSERVABLE (_gtk_widget_get_action_muxer (GTK_WIDGET (box), TRUE)),
model, TRUE, FALSE, FALSE, NULL,
gtk_menu_section_box_insert_func,
gtk_menu_section_box_remove_func, box);
g_signal_connect (G_OBJECT (popover), "notify::position", G_CALLBACK (update_popover_position_cb), box);
}
static void
gtk_menu_section_box_new_submenu (GtkMenuTrackerItem *item,
GtkMenuSectionBox *toplevel,
GtkWidget *focus,
const char *name)
{
GtkMenuSectionBox *box;
GtkWidget *button;
box = g_object_new (GTK_TYPE_MENU_SECTION_BOX, NULL);
box->indicators = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
box->custom_slots = g_hash_table_ref (toplevel->custom_slots);
box->flags = toplevel->flags;
button = g_object_new (GTK_TYPE_MODEL_BUTTON,
"menu-name", name,
"role", GTK_BUTTON_ROLE_TITLE,
NULL);
g_object_bind_property (item, "label", button, "text", G_BINDING_SYNC_CREATE);
g_object_bind_property (item, "icon", button, "icon", G_BINDING_SYNC_CREATE);
g_object_set_data (G_OBJECT (button), "focus", focus);
g_object_set_data (G_OBJECT (focus), "focus", button);
gtk_box_insert_child_after (GTK_BOX (box), button, NULL);
g_signal_connect (focus, "clicked", G_CALLBACK (open_submenu), item);
g_signal_connect (button, "clicked", G_CALLBACK (close_submenu), item);
gtk_stack_add_named (GTK_STACK (gtk_widget_get_ancestor (GTK_WIDGET (toplevel), GTK_TYPE_STACK)),
GTK_WIDGET (box), gtk_menu_tracker_item_get_label (item));
box->tracker = gtk_menu_tracker_new_for_item_link (item, G_MENU_LINK_SUBMENU, FALSE, FALSE,
gtk_menu_section_box_insert_func,
gtk_menu_section_box_remove_func,
box);
}
static GtkWidget *
gtk_menu_section_box_new_section (GtkMenuTrackerItem *item,
GtkMenuSectionBox *parent)
{
GtkMenuSectionBox *box;
const char *label;
const char *hint;
const char *text_direction;
box = g_object_new (GTK_TYPE_MENU_SECTION_BOX, NULL);
box->indicators = g_object_ref (parent->indicators);
box->custom_slots = g_hash_table_ref (parent->toplevel->custom_slots);
box->toplevel = parent->toplevel;
box->depth = parent->depth + 1;
box->flags = parent->flags;
label = gtk_menu_tracker_item_get_label (item);
hint = gtk_menu_tracker_item_get_display_hint (item);
text_direction = gtk_menu_tracker_item_get_text_direction (item);
if (hint && g_str_equal (hint, "horizontal-buttons"))
{
gtk_box_set_homogeneous (box->item_box, TRUE);
gtk_orientable_set_orientation (GTK_ORIENTABLE (box->item_box), GTK_ORIENTATION_HORIZONTAL);
gtk_widget_add_css_class (GTK_WIDGET (box->item_box), "linked");
gtk_widget_add_css_class (GTK_WIDGET (box->item_box), "horizontal-buttons");
box->iconic = TRUE;
if (text_direction)
{
GtkTextDirection dir = GTK_TEXT_DIR_NONE;
if (g_str_equal (text_direction, "rtl"))
dir = GTK_TEXT_DIR_RTL;
else if (g_str_equal (text_direction, "ltr"))
dir = GTK_TEXT_DIR_LTR;
gtk_widget_set_direction (GTK_WIDGET (box->item_box), dir);
}
}
else if (hint && g_str_equal (hint, "inline-buttons"))
{
GtkWidget *item_box;
GtkWidget *spacer;
box->inline_buttons = TRUE;
gtk_orientable_set_orientation (GTK_ORIENTABLE (box->item_box), GTK_ORIENTATION_HORIZONTAL);
gtk_widget_add_css_class (GTK_WIDGET (box->item_box), "inline-buttons");
spacer = gtk_builtin_icon_new ("none");
gtk_box_append (GTK_BOX (box->item_box), spacer);
gtk_size_group_add_widget (box->indicators, spacer);
if (label != NULL)
{
GtkWidget *title;
title = gtk_label_new (label);
gtk_widget_set_hexpand (title, TRUE);
gtk_widget_set_halign (title, GTK_ALIGN_START);
g_object_bind_property (item, "label", title, "label", G_BINDING_SYNC_CREATE);
gtk_box_append (GTK_BOX (box->item_box), title);
}
item_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_append (GTK_BOX (box->item_box), item_box);
box->item_box = GTK_BOX (item_box);
}
else if (hint && g_str_equal (hint, "circular-buttons"))
{
gtk_box_set_homogeneous (box->item_box, TRUE);
gtk_orientable_set_orientation (GTK_ORIENTABLE (box->item_box), GTK_ORIENTATION_HORIZONTAL);
gtk_widget_add_css_class (GTK_WIDGET (box->item_box), "circular-buttons");
box->circular = TRUE;
}
if (label != NULL && !box->inline_buttons)
{
GtkWidget *separator;
GtkWidget *title;
box->separator = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
g_object_ref_sink (box->separator);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_widget_set_valign (separator, GTK_ALIGN_CENTER);
gtk_widget_set_hexpand (separator, TRUE);
gtk_box_append (GTK_BOX (box->separator), separator);
title = gtk_label_new (label);
g_object_bind_property (item, "label", title, "label", G_BINDING_SYNC_CREATE);
gtk_widget_add_css_class (title, "separator");
gtk_widget_set_halign (title, GTK_ALIGN_START);
gtk_label_set_xalign (GTK_LABEL (title), 0.0);
gtk_widget_add_css_class (title, "title");
gtk_box_append (GTK_BOX (box->separator), title);
}
else
{
box->separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
g_object_ref_sink (box->separator);
}
box->tracker = gtk_menu_tracker_new_for_item_link (item, G_MENU_LINK_SECTION, FALSE, FALSE,
gtk_menu_section_box_insert_func,
gtk_menu_section_box_remove_func,
box);
return GTK_WIDGET (box);
}
gboolean
gtk_menu_section_box_add_custom (GtkPopoverMenu *popover,
GtkWidget *child,
const char *id)
{
GtkWidget *stack;
GtkMenuSectionBox *box;
GtkWidget *slot;
stack = gtk_popover_menu_get_stack (popover);
box = GTK_MENU_SECTION_BOX (gtk_stack_get_child_by_name (GTK_STACK (stack), "main"));
if (box == NULL)
return FALSE;
slot = (GtkWidget *)g_hash_table_lookup (box->custom_slots, id);
if (slot == NULL)
return FALSE;
if (gtk_widget_get_first_child (slot))
return FALSE;
gtk_widget_insert_before (child, slot, NULL);
return TRUE;
}
gboolean
gtk_menu_section_box_remove_custom (GtkPopoverMenu *popover,
GtkWidget *child)
{
GtkWidget *stack;
GtkMenuSectionBox *box;
GtkWidget *parent;
const char *id;
GtkWidget *slot;
stack = gtk_popover_get_child (GTK_POPOVER (popover));
box = GTK_MENU_SECTION_BOX (gtk_stack_get_child_by_name (GTK_STACK (stack), "main"));
parent = gtk_widget_get_parent (child);
id = (const char *) g_object_get_data (G_OBJECT (parent), "slot-id");
g_return_val_if_fail (id != NULL, FALSE);
slot = (GtkWidget *)g_hash_table_lookup (box->custom_slots, id);
if (slot != parent)
return FALSE;
gtk_widget_unparent (child);
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink