AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
f59d2ae89d
gtk2/gtk/gtkmenusectionbox.c

761 lines
25 KiB
C
Raw Normal View History

GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
/*
* 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"
Rename a bunch of private headers We want to follow the convention that all private headers have names ending in private.h
2019-06-10 03:10:13 +00:00
#include "gtkmenusectionboxprivate.h"
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
#include "gtkwidgetprivate.h"
#include "gtklabel.h"
Rename a bunch of private headers We want to follow the convention that all private headers have names ending in private.h
2019-06-10 03:10:13 +00:00
#include "gtkmenutrackerprivate.h"
Privatize popover menu pieces Don't allow manual creation of popover menus anymore. This lets us also make GtkModelButton private
2019-11-11 10:58:43 +00:00
#include "gtkmodelbuttonprivate.h"
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
#include "gtkseparator.h"
#include "gtksizegroup.h"
#include "gtkstack.h"
Privatize popover menu pieces Don't allow manual creation of popover menus anymore. This lets us also make GtkModelButton private
2019-11-11 10:58:43 +00:00
#include "gtkpopovermenuprivate.h"
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
#include "gtkorientable.h"
Rename GtkIcon widget to GtkBuiltinIcon This is an internal widget whose name is not very important, and we want to rename GtkIconInfo to GtkIcon, so lets rename this.
2020-01-28 14:03:42 +00:00
#include "gtkbuiltiniconprivate.h"
popovermenu: Allow custom items Add a way to add children at certain places in the generated menu for both GtkPopoverMenu and GtkPopoverMenuBar. New apis: gtk_popover_menu_add_child gtk_popover_menu_remove_child gtk_popover_menu_bar_add_child gtk_popover_menu_bar_remove_child Fixes: #3260
2020-10-20 18:26:45 +00:00
#include "gtkgizmoprivate.h"
#include "gtkbinlayout.h"
Avoid copying static debug strings The g_source_set_name calls were showing up as a major source of strdups in our profiles. Avoid that by using new GLib api when available.
2021-07-26 21:03:15 +00:00
#include "gtkprivate.h"
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
typedef GtkBoxClass GtkMenuSectionBoxClass;
struct _GtkMenuSectionBox
{
Add nesting popover menus Add a variant of popover menus that are nesting like traditional menus. This is a better fit for replacing traditional main menus.
2019-08-27 08:28:29 +00:00
GtkBox parent_instance;
GtkMenuSectionBox *toplevel;
GtkMenuTracker *tracker;
GtkBox *item_box;
GtkWidget *separator;
guint separator_sync_idle;
gboolean iconic;
gboolean inline_buttons;
gboolean circular;
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int depth;
Add nesting popover menus Add a variant of popover menus that are nesting like traditional menus. This is a better fit for replacing traditional main menus.
2019-08-27 08:28:29 +00:00
GtkPopoverMenuFlags flags;
GtkSizeGroup *indicators;
popovermenu: Allow custom items Add a way to add children at certain places in the generated menu for both GtkPopoverMenu and GtkPopoverMenuBar. New apis: gtk_popover_menu_add_child gtk_popover_menu_remove_child gtk_popover_menu_bar_add_child gtk_popover_menu_bar_remove_child Fixes: #3260
2020-10-20 18:26:45 +00:00
GHashTable *custom_slots;
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
};
popover menus: Take iconic into account We don't want separators in both side of an iconic section and use a 10px margin to separate two iconic sections. Separators are also updated in case of dynamic insertion ( often used with menu items for plugins ) https://bugzilla.gnome.org/show_bug.cgi?id=738650
2014-10-18 09:19:26 +00:00
typedef struct
{
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int n_items;
popover menus: Take iconic into account We don't want separators in both side of an iconic section and use a 10px margin to separate two iconic sections. Separators are also updated in case of dynamic insertion ( often used with menu items for plugins ) https://bugzilla.gnome.org/show_bug.cgi?id=738650
2014-10-18 09:19:26 +00:00
gboolean previous_is_iconic;
} MenuData;
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
G_DEFINE_TYPE (GtkMenuSectionBox, gtk_menu_section_box, GTK_TYPE_BOX)
Drop GtkModelButton:has-submenu Replace the has-submenu property with checking menu-name != NULL.
2014-10-26 20:23:31 +00:00
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,
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *name);
Drop GtkModelButton:has-submenu Replace the has-submenu property with checking menu-name != NULL.
2014-10-26 20:23:31 +00:00
static GtkWidget * gtk_menu_section_box_new_section (GtkMenuTrackerItem *item,
GtkMenuSectionBox *parent);
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
Add a comment with rules for separators
2014-04-29 15:50:54 +00:00
/* 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
popover menus: Take iconic into account We don't want separators in both side of an iconic section and use a 10px margin to separate two iconic sections. Separators are also updated in case of dynamic insertion ( often used with menu items for plugins ) https://bugzilla.gnome.org/show_bug.cgi?id=738650
2014-10-18 09:19:26 +00:00
* 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)
Add a comment with rules for separators
2014-04-29 15:50:54 +00:00
*/
Drop GtkModelButton:has-submenu Replace the has-submenu property with checking menu-name != NULL.
2014-10-26 20:23:31 +00:00
static void
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
gtk_menu_section_box_sync_separators (GtkMenuSectionBox *box,
popover menus: Take iconic into account We don't want separators in both side of an iconic section and use a 10px margin to separate two iconic sections. Separators are also updated in case of dynamic insertion ( often used with menu items for plugins ) https://bugzilla.gnome.org/show_bug.cgi?id=738650
2014-10-18 09:19:26 +00:00
MenuData *data)
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
{
popover menus: Take iconic into account We don't want separators in both side of an iconic section and use a 10px margin to separate two iconic sections. Separators are also updated in case of dynamic insertion ( often used with menu items for plugins ) https://bugzilla.gnome.org/show_bug.cgi?id=738650
2014-10-18 09:19:26 +00:00
gboolean previous_section_is_iconic;
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
gboolean should_have_separator;
popover menus: Take iconic into account We don't want separators in both side of an iconic section and use a 10px margin to separate two iconic sections. Separators are also updated in case of dynamic insertion ( often used with menu items for plugins ) https://bugzilla.gnome.org/show_bug.cgi?id=738650
2014-10-18 09:19:26 +00:00
gboolean should_have_top_margin = FALSE;
gboolean is_not_empty_item;
GtkMenuSectionBox: Always show separators for labeled sections ...unless they are empty.
2014-04-29 15:48:52 +00:00
gboolean has_separator;
gboolean has_label;
popover menus: Take iconic into account We don't want separators in both side of an iconic section and use a 10px margin to separate two iconic sections. Separators are also updated in case of dynamic insertion ( often used with menu items for plugins ) https://bugzilla.gnome.org/show_bug.cgi?id=738650
2014-10-18 09:19:26 +00:00
gboolean separator_condition;
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int n_items_before;
Replace most remaining uses of container api These are all on GtkBox or enumerating children.
2020-05-09 12:26:52 +00:00
GtkWidget *child;
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
popover menus: Take iconic into account We don't want separators in both side of an iconic section and use a 10px margin to separate two iconic sections. Separators are also updated in case of dynamic insertion ( often used with menu items for plugins ) https://bugzilla.gnome.org/show_bug.cgi?id=738650
2014-10-18 09:19:26 +00:00
n_items_before = data->n_items;
previous_section_is_iconic = data->previous_is_iconic;
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
Replace most remaining uses of container api These are all on GtkBox or enumerating children.
2020-05-09 12:26:52 +00:00
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++;
}
popover menus: Take iconic into account We don't want separators in both side of an iconic section and use a 10px margin to separate two iconic sections. Separators are also updated in case of dynamic insertion ( often used with menu items for plugins ) https://bugzilla.gnome.org/show_bug.cgi?id=738650
2014-10-18 09:19:26 +00:00
is_not_empty_item = (data->n_items > n_items_before);
if (is_not_empty_item)
data->previous_is_iconic = box->iconic;
Improve popover menu spacing Make iconic buttons have a more reasonable height, and add some space above an iconic row. https://bugzilla.gnome.org/show_bug.cgi?id=732229
2014-06-28 04:00:16 +00:00
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
if (box->separator == NULL)
return;
GtkMenuSectionBox: Always show separators for labeled sections ...unless they are empty.
2014-04-29 15:48:52 +00:00
has_separator = gtk_widget_get_parent (box->separator) != NULL;
has_label = !GTK_IS_SEPARATOR (box->separator);
popover menus: Take iconic into account We don't want separators in both side of an iconic section and use a 10px margin to separate two iconic sections. Separators are also updated in case of dynamic insertion ( often used with menu items for plugins ) https://bugzilla.gnome.org/show_bug.cgi?id=738650
2014-10-18 09:19:26 +00:00
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 &&
menu section box: Introduce more section variants Allow display-hint to be circular-buttons or inline-buttons, to produce variations of horizontal button layouts.
2019-06-06 01:36:17 +00:00
(box->depth <= 1 || box->iconic || box->circular) &&
popover menus: Take iconic into account We don't want separators in both side of an iconic section and use a 10px margin to separate two iconic sections. Separators are also updated in case of dynamic insertion ( often used with menu items for plugins ) https://bugzilla.gnome.org/show_bug.cgi?id=738650
2014-10-18 09:19:26 +00:00
n_items_before > 0 &&
is_not_empty_item;
gtk_widget_set_margin_top (GTK_WIDGET (box->item_box), should_have_top_margin ? 10 : 0);
GtkMenuSectionBox: Always show separators for labeled sections ...unless they are empty.
2014-04-29 15:48:52 +00:00
popovermenu: Don't put a separator before the first section When we have section titles, we were not hiding the separator before the first section as we should; fix this. Fixes: #2672
2020-04-28 00:26:02 +00:00
if (has_label)
{
GtkWidget *separator = gtk_widget_get_first_child (box->separator);
gtk_widget_set_visible (separator, n_items_before > 0);
}
GtkMenuSectionBox: Always show separators for labeled sections ...unless they are empty.
2014-04-29 15:48:52 +00:00
if (should_have_separator == has_separator)
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
return;
if (should_have_separator)
box: Avoid position in the reorder api Change the reorder api to insert after a sibling, so that moving to first place becomes reorder (... NULL). And add a insert_after api that can replace the common container_add / reorder_after (... NULL) combination. Update all callers.
2019-01-22 23:44:34 +00:00
gtk_box_insert_child_after (GTK_BOX (box), box->separator, NULL);
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
else
Replace most remaining uses of container api These are all on GtkBox or enumerating children.
2020-05-09 12:26:52 +00:00
gtk_box_remove (GTK_BOX (box), box->separator);
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
}
static gboolean
gtk_menu_section_box_handle_sync_separators (gpointer user_data)
{
GtkMenuSectionBox *box = user_data;
popover menus: Take iconic into account We don't want separators in both side of an iconic section and use a 10px margin to separate two iconic sections. Separators are also updated in case of dynamic insertion ( often used with menu items for plugins ) https://bugzilla.gnome.org/show_bug.cgi?id=738650
2014-10-18 09:19:26 +00:00
MenuData data;
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
popover menus: Take iconic into account We don't want separators in both side of an iconic section and use a 10px margin to separate two iconic sections. Separators are also updated in case of dynamic insertion ( often used with menu items for plugins ) https://bugzilla.gnome.org/show_bug.cgi?id=738650
2014-10-18 09:19:26 +00:00
data.n_items = 0;
data.previous_is_iconic = FALSE;
gtk_menu_section_box_sync_separators (box, &data);
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
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)
Replace gdk_threads_add_idle* with g_idle_add() The main GDK thread lock is not portable and deprecated. The only reason why gdk_threads_add_idle() and gdk_threads_add_idle_full() exist is to allow invoking a callback with the GDK lock held, in case 3rd party libraries still use the deprecated gdk_threads_enter()/gdk_threads_leave() API. Since we're removing the GDK lock, and we're releasing a new major API, such code cannot exist any more; this means we can use the GLib API for installing idle callbacks. https://bugzilla.gnome.org/show_bug.cgi?id=793124
2018-02-02 14:08:02 +00:00
{
box->separator_sync_idle = g_idle_add_full (G_PRIORITY_HIGH_IDLE, /* before resize... */
gtk_menu_section_box_handle_sync_separators,
box, NULL);
Avoid copying static debug strings The g_source_set_name calls were showing up as a major source of strdups in our profiles. Avoid that by using new GLib api when available.
2021-07-26 21:03:15 +00:00
gdk_source_set_static_name_by_id (box->separator_sync_idle, "[gtk] menu section box handle sync separators");
Replace gdk_threads_add_idle* with g_idle_add() The main GDK thread lock is not portable and deprecated. The only reason why gdk_threads_add_idle() and gdk_threads_add_idle_full() exist is to allow invoking a callback with the GDK lock held, in case 3rd party libraries still use the deprecated gdk_threads_enter()/gdk_threads_leave() API. Since we're removing the GDK lock, and we're releasing a new major API, such code cannot exist any more; this means we can use the GLib API for installing idle callbacks. https://bugzilla.gnome.org/show_bug.cgi?id=793124
2018-02-02 14:08:02 +00:00
}
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
}
static void
gtk_popover_item_activate (GtkWidget *button,
gpointer user_data)
{
GtkMenuTrackerItem *item = user_data;
Ref the popover before activating the item Otherwise the item could cause the popover to be destroyed, for example a Quit item, and cause a warning to be printed.
2014-08-23 13:55:07 +00:00
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
*/
menusectionbox: Avoid a critical warning The popover may already be gone when the item is activated. Don't trigger a critical in that case. Related: #2986
2020-08-02 02:03:06 +00:00
popover = gtk_widget_get_ancestor (button, GTK_TYPE_POPOVER);
if (popover)
g_object_ref (popover);
Ref the popover before activating the item Otherwise the item could cause the popover to be destroyed, for example a Quit item, and cause a warning to be printed.
2014-08-23 13:55:07 +00:00
}
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
gtk_menu_tracker_item_activated (item);
Ref the popover before activating the item Otherwise the item could cause the popover to be destroyed, for example a Quit item, and cause a warning to be printed.
2014-08-23 13:55:07 +00:00
if (popover != NULL)
{
gtk_widget_hide (popover);
g_object_unref (popover);
}
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
}
static void
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
gtk_menu_section_box_remove_func (int position,
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
gpointer user_data)
{
GtkMenuSectionBox *box = user_data;
gtkmenusectionbox: remove submenus when the parent item is removed https://bugzilla.gnome.org/show_bug.cgi?id=749405
2016-03-09 12:44:45 +00:00
GtkMenuTrackerItem *item;
GtkWidget *widget;
Replace most remaining uses of container api These are all on GtkBox or enumerating children.
2020-05-09 12:26:52 +00:00
int pos;
gtkmenusectionbox: remove submenus when the parent item is removed https://bugzilla.gnome.org/show_bug.cgi?id=749405
2016-03-09 12:44:45 +00:00
Replace most remaining uses of container api These are all on GtkBox or enumerating children.
2020-05-09 12:26:52 +00:00
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;
}
gtkmenusectionbox: remove submenus when the parent item is removed https://bugzilla.gnome.org/show_bug.cgi?id=749405
2016-03-09 12:44:45 +00:00
item = g_object_get_data (G_OBJECT (widget), "GtkMenuTrackerItem");
Fix formatting The previous change was not quite using the right coding style.
2016-04-22 03:24:13 +00:00
if (gtk_menu_tracker_item_get_has_link (item, G_MENU_LINK_SUBMENU))
{
GtkWidget *stack, *subbox;
gtkmenusectionbox: remove submenus when the parent item is removed https://bugzilla.gnome.org/show_bug.cgi?id=749405
2016-03-09 12:44:45 +00:00
Fix formatting The previous change was not quite using the right coding style.
2016-04-22 03:24:13 +00:00
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)
Don't use container api on GtkStack
2020-05-10 01:01:24 +00:00
gtk_stack_remove (GTK_STACK (stack), subbox);
gtkmenusectionbox: remove submenus when the parent item is removed https://bugzilla.gnome.org/show_bug.cgi?id=749405
2016-03-09 12:44:45 +00:00
}
Replace most remaining uses of container api These are all on GtkBox or enumerating children.
2020-05-09 12:26:52 +00:00
gtk_box_remove (GTK_BOX (box->item_box), widget);
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
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);
}
menusectionbox: Fix submenu-action for nested menus We were not updating the state of submenu-actions for nested submenus. Fixes: #3721
2021-03-08 05:43:43 +00:00
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);
}
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
static void
gtk_menu_section_box_insert_func (GtkMenuTrackerItem *item,
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int position,
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
gpointer user_data)
{
GtkMenuSectionBox *box = user_data;
GtkWidget *widget;
if (gtk_menu_tracker_item_get_is_separator (item))
{
GtkMenuSectionBox: Don't show separators for nested subsections ...unless they are labeled. To implement this, keep track of the nesting depth of section boxes, starting from 0 for the toplevel and the submenu ones, and only insert unlabeled separators if the depth is at most 1.
2014-04-29 16:17:40 +00:00
widget = gtk_menu_section_box_new_section (item, box);
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
}
else if (gtk_menu_tracker_item_get_has_link (item, G_MENU_LINK_SUBMENU))
{
Add nesting popover menus Add a variant of popover menus that are nesting like traditional menus. This is a better fit for replacing traditional main menus.
2019-08-27 08:28:29 +00:00
if (box->flags & GTK_POPOVER_MENU_NESTED)
{
GMenuModel *model;
GtkWidget *submenu;
Drop GtkModelButton:has-submenu Replace the has-submenu property with checking menu-name != NULL.
2014-10-26 20:23:31 +00:00
Add nesting popover menus Add a variant of popover menus that are nesting like traditional menus. This is a better fit for replacing traditional main menus.
2019-08-27 08:28:29 +00:00
model = _gtk_menu_tracker_item_get_link (item, G_MENU_LINK_SUBMENU);
Drop GtkModelButton:has-submenu Replace the has-submenu property with checking menu-name != NULL.
2014-10-26 20:23:31 +00:00
popover: Drop ::relative-to It is enough to just set the parent (and make the parent call gtk_native_check_resize in size_allocate). This commit removes the relative_to argument to the constructors of GtkPopover and GtkPopoverMenu, and updates all callers.
2020-02-24 12:21:46 +00:00
submenu = gtk_popover_menu_new_from_model_full (model, box->flags);
Add nesting popover menus Add a variant of popover menus that are nesting like traditional menus. This is a better fit for replacing traditional main menus.
2019-08-27 08:28:29 +00:00
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,
Fix menu item alignment with submenus We were not aligning model button labels with nesting submenus with indicators in their containing menu. This was visible in the application demo of gtk4-demo.
2020-12-29 17:10:35 +00:00
"indicator-size-group", box->indicators,
Add nesting popover menus Add a variant of popover menus that are nesting like traditional menus. This is a better fit for replacing traditional main menus.
2019-08-27 08:28:29 +00:00
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);
menusectionbox: Fix submenu-action for nested menus We were not updating the state of submenu-actions for nested submenus. Fixes: #3721
2021-03-08 05:43:43 +00:00
g_signal_connect (submenu, "show", G_CALLBACK (submenu_shown), item);
g_signal_connect (submenu, "hide", G_CALLBACK (submenu_hidden), item);
Add nesting popover menus Add a variant of popover menus that are nesting like traditional menus. This is a better fit for replacing traditional main menus.
2019-08-27 08:28:29 +00:00
}
else
{
GtkWidget *stack = NULL;
GtkWidget *parent = NULL;
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
char *name;
Add nesting popover menus Add a variant of popover menus that are nesting like traditional menus. This is a better fit for replacing traditional main menus.
2019-08-27 08:28:29 +00:00
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);
}
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
}
popovermenu: Allow custom items Add a way to add children at certain places in the generated menu for both GtkPopoverMenu and GtkPopoverMenuBar. New apis: gtk_popover_menu_add_child gtk_popover_menu_remove_child gtk_popover_menu_bar_add_child gtk_popover_menu_bar_remove_child Fixes: #3260
2020-10-20 18:26:45 +00:00
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, NULL, NULL);
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);
}
}
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
else
{
model button: Redo layout Move checks to the left, and introduce a size group to align things. The size group is provided by the parent, using the new ::indicator-size-group property.
2019-06-06 00:41:45 +00:00
widget = g_object_new (GTK_TYPE_MODEL_BUTTON,
"indicator-size-group", box->indicators,
NULL);
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
g_object_bind_property (item, "label", widget, "text", G_BINDING_SYNC_CREATE);
GtkMenuSectionBox: add support for iconic sections Sections that have the display-hint attribute set to "horizontal-boxes" will be rendered as a row of icon buttons, instead of menuitem-like.
2014-04-28 18:18:39 +00:00
if (box->iconic)
{
g_object_bind_property (item, "verb-icon", widget, "icon", G_BINDING_SYNC_CREATE);
model button: Drop centered, inverted properties These properties were only useful for titles, and we have a role for that now.
2019-06-05 22:31:14 +00:00
g_object_set (widget, "iconic", TRUE, NULL);
GtkMenuSectionBox: add support for iconic sections Sections that have the display-hint attribute set to "horizontal-boxes" will be rendered as a row of icon buttons, instead of menuitem-like.
2014-04-28 18:18:39 +00:00
}
menu section box: Introduce more section variants Allow display-hint to be circular-buttons or inline-buttons, to produce variations of horizontal button layouts.
2019-06-06 01:36:17 +00:00
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);
Rename gtk_widget{get,set,has}_style_class to _css_class We want to use css instead of style everywhere now.
2020-02-06 16:32:26 +00:00
gtk_widget_add_css_class (widget, "flat");
menu section box: Introduce more section variants Allow display-hint to be circular-buttons or inline-buttons, to produce variations of horizontal button layouts.
2019-06-06 01:36:17 +00:00
}
else if (box->circular)
{
g_object_bind_property (item, "verb-icon", widget, "icon", G_BINDING_SYNC_CREATE);
g_object_set (widget, "iconic", TRUE, NULL);
Rename gtk_widget{get,set,has}_style_class to _css_class We want to use css instead of style everywhere now.
2020-02-06 16:32:26 +00:00
gtk_widget_add_css_class (widget, "circular");
menu section box: Introduce more section variants Allow display-hint to be circular-buttons or inline-buttons, to produce variations of horizontal button layouts.
2019-06-06 01:36:17 +00:00
}
GtkMenuSectionBox: add support for iconic sections Sections that have the display-hint attribute set to "horizontal-boxes" will be rendered as a row of icon buttons, instead of menuitem-like.
2014-04-28 18:18:39 +00:00
else
g_object_bind_property (item, "icon", widget, "icon", G_BINDING_SYNC_CREATE);
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
g_object_bind_property (item, "sensitive", widget, "sensitive", G_BINDING_SYNC_CREATE);
GtkModelButton: Rename action-role to role Rename action-role to role, and make all properties readable.
2014-10-26 22:08:26 +00:00
g_object_bind_property (item, "role", widget, "role", G_BINDING_SYNC_CREATE);
Make GtkModelButton a better GtkActionable Rename the "toggled" property to "active", since that is what GtkActionHelper expects to update for check and radio actions. Also make the property readable, since GtkActionHelper wants to read it.
2014-10-24 01:43:28 +00:00
g_object_bind_property (item, "toggled", widget, "active", G_BINDING_SYNC_CREATE);
model button: Show shortcuts Most of the machinery for this is already in place. We just need to add an accel property to GtkMenuButton and pass it through.
2019-06-07 13:02:45 +00:00
g_object_bind_property (item, "accel", widget, "accel", G_BINDING_SYNC_CREATE);
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
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);
menu section box: Introduce more section variants Allow display-hint to be circular-buttons or inline-buttons, to produce variations of horizontal button layouts.
2019-06-06 01:36:17 +00:00
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);
}
Replace most remaining uses of container api These are all on GtkBox or enumerating children.
2020-05-09 12:26:52 +00:00
gtk_box_append (GTK_BOX (box->item_box), widget);
box: Avoid position in the reorder api Change the reorder api to insert after a sibling, so that moving to first place becomes reorder (... NULL). And add a insert_after api that can replace the common container_add / reorder_after (... NULL) combination. Update all callers.
2019-01-22 23:44:34 +00:00
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);
}
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
menusectionbox: Improve circular button spacing In the n == 2 case, we want to avoid the buttons being drawn all the way out to the ends of the box, but in the n >= 3 case, that is exactly what we want for the first and last button.
2020-04-23 02:16:46 +00:00
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);
}
}
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
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);
Replace most remaining uses of container api These are all on GtkBox or enumerating children.
2020-05-09 12:26:52 +00:00
gtk_box_append (GTK_BOX (box), item_box);
GtkMenuSectionBox: add support for iconic sections Sections that have the display-hint attribute set to "horizontal-boxes" will be rendered as a row of icon buttons, instead of menuitem-like.
2014-04-28 18:18:39 +00:00
gtk_widget_set_halign (GTK_WIDGET (item_box), GTK_ALIGN_FILL);
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
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;
}
Indentation fix
2014-10-27 11:19:50 +00:00
g_clear_object (&box->separator);
GtkMenuSectionBox: don't leak This wasn't fully fleshed out yet.
2014-04-29 14:18:22 +00:00
if (box->tracker)
{
gtk_menu_tracker_free (box->tracker);
box->tracker = NULL;
}
model button: Redo layout Move checks to the left, and introduce a size group to align things. The size group is provided by the parent, using the new ::indicator-size-group property.
2019-06-06 00:41:45 +00:00
g_clear_object (&box->indicators);
popovermenu: Allow custom items Add a way to add children at certain places in the generated menu for both GtkPopoverMenu and GtkPopoverMenuBar. New apis: gtk_popover_menu_add_child gtk_popover_menu_remove_child gtk_popover_menu_bar_add_child gtk_popover_menu_bar_remove_child Fixes: #3260
2020-10-20 18:26:45 +00:00
g_clear_pointer (&box->custom_slots, g_hash_table_unref);
model button: Redo layout Move checks to the left, and introduce a size group to align things. The size group is provided by the parent, using the new ::indicator-size-group property.
2019-06-06 00:41:45 +00:00
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
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;
}
gtkpopover: Update the menu's alignment ... when the popover position changes.
2015-03-17 18:34:43 +00:00
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);
Don't use container api on GtkStack
2020-05-10 01:01:24 +00:00
GtkWidget *w;
gtkpopover: Update the menu's alignment ... when the popover position changes.
2015-03-17 18:34:43 +00:00
GtkPositionType new_pos = gtk_popover_get_position (popover);
Don't use container api on GtkStack
2020-05-10 01:01:24 +00:00
for (w = gtk_widget_get_first_child (gtk_widget_get_parent (GTK_WIDGET (box)));
w != NULL;
w = gtk_widget_get_next_sibling (w))
gtkpopover: Update the menu's alignment ... when the popover position changes.
2015-03-17 18:34:43 +00:00
{
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);
}
}
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
void
Add nesting popover menus Add a variant of popover menus that are nesting like traditional menus. This is a better fit for replacing traditional main menus.
2019-08-27 08:28:29 +00:00
gtk_menu_section_box_new_toplevel (GtkPopoverMenu *popover,
GMenuModel *model,
GtkPopoverMenuFlags flags)
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
{
GtkMenuSectionBox *box;
popovermenu: Allow custom items Add a way to add children at certain places in the generated menu for both GtkPopoverMenu and GtkPopoverMenuBar. New apis: gtk_popover_menu_add_child gtk_popover_menu_remove_child gtk_popover_menu_bar_add_child gtk_popover_menu_bar_remove_child Fixes: #3260
2020-10-20 18:26:45 +00:00
box = g_object_new (GTK_TYPE_MENU_SECTION_BOX, NULL);
model button: Redo layout Move checks to the left, and introduce a size group to align things. The size group is provided by the parent, using the new ::indicator-size-group property.
2019-06-06 00:41:45 +00:00
box->indicators = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
popovermenu: Allow custom items Add a way to add children at certain places in the generated menu for both GtkPopoverMenu and GtkPopoverMenuBar. New apis: gtk_popover_menu_add_child gtk_popover_menu_remove_child gtk_popover_menu_bar_add_child gtk_popover_menu_bar_remove_child Fixes: #3260
2020-10-20 18:26:45 +00:00
box->custom_slots = g_hash_table_new (g_str_hash, g_str_equal);
Add nesting popover menus Add a variant of popover menus that are nesting like traditional menus. This is a better fit for replacing traditional main menus.
2019-08-27 08:28:29 +00:00
box->flags = flags;
model button: Redo layout Move checks to the left, and introduce a size group to align things. The size group is provided by the parent, using the new ::indicator-size-group property.
2019-06-06 00:41:45 +00:00
Rationalize popover menu apis Make gtk_popover_new_from_model() return a GtkPopoverMenu, rename it to gtk_popover_menu_new_from_model() and add a relative_to argument to gtk_popover_menu_new(). Update all callers.
2019-06-07 17:05:48 +00:00
gtk_popover_menu_add_submenu (popover, GTK_WIDGET (box), "main");
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
gtkwindow: Use actions from focused widget to activate accel Currently we only take into account the window GActionGroup for activating the accels. However, the application could have some custom GActionGroup in the chain of focused widgets that could want to activate some action if some accel is activated while that widget is focused. To allow applications to set accels on widgets that use custom GActionGroups, simply use the muxer of the focused widget, which already contains the actions of the parents. https://bugzilla.gnome.org/show_bug.cgi?id=740682
2014-12-03 14:53:59 +00:00
box->tracker = gtk_menu_tracker_new (GTK_ACTION_OBSERVABLE (_gtk_widget_get_action_muxer (GTK_WIDGET (box), TRUE)),
Rationalize popover menu apis Make gtk_popover_new_from_model() return a GtkPopoverMenu, rename it to gtk_popover_menu_new_from_model() and add a relative_to argument to gtk_popover_menu_new(). Update all callers.
2019-06-07 17:05:48 +00:00
model, TRUE, FALSE, FALSE, NULL,
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
gtk_menu_section_box_insert_func,
gtk_menu_section_box_remove_func, box);
gtkpopover: Update the menu's alignment ... when the popover position changes.
2015-03-17 18:34:43 +00:00
g_signal_connect (G_OBJECT (popover), "notify::position", G_CALLBACK (update_popover_position_cb), box);
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
}
Drop GtkModelButton:has-submenu Replace the has-submenu property with checking menu-name != NULL.
2014-10-26 20:23:31 +00:00
static void
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
gtk_menu_section_box_new_submenu (GtkMenuTrackerItem *item,
GtkMenuSectionBox *toplevel,
Drop GtkModelButton:has-submenu Replace the has-submenu property with checking menu-name != NULL.
2014-10-26 20:23:31 +00:00
GtkWidget *focus,
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *name)
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
{
GtkMenuSectionBox *box;
GtkWidget *button;
menusectionbox: Remove margins So the theme can add the spacing on its own.
2016-10-24 18:08:58 +00:00
box = g_object_new (GTK_TYPE_MENU_SECTION_BOX, NULL);
model button: Redo layout Move checks to the left, and introduce a size group to align things. The size group is provided by the parent, using the new ::indicator-size-group property.
2019-06-06 00:41:45 +00:00
box->indicators = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
popovermenu: Allow custom items Add a way to add children at certain places in the generated menu for both GtkPopoverMenu and GtkPopoverMenuBar. New apis: gtk_popover_menu_add_child gtk_popover_menu_remove_child gtk_popover_menu_bar_add_child gtk_popover_menu_bar_remove_child Fixes: #3260
2020-10-20 18:26:45 +00:00
box->custom_slots = g_hash_table_ref (toplevel->custom_slots);
Add nesting popover menus Add a variant of popover menus that are nesting like traditional menus. This is a better fit for replacing traditional main menus.
2019-08-27 08:28:29 +00:00
box->flags = toplevel->flags;
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
button = g_object_new (GTK_TYPE_MODEL_BUTTON,
Drop GtkModelButton:has-submenu Replace the has-submenu property with checking menu-name != NULL.
2014-10-26 20:23:31 +00:00
"menu-name", name,
model button: Add a role for titles This gets us out of using direct presentational markup like 'inverted' and 'centered' and will make it easier to play with different layout. Use the new role when creating popover menus from models.
2019-06-05 21:22:01 +00:00
"role", GTK_BUTTON_ROLE_TITLE,
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
NULL);
Drop GtkModelButton:has-submenu Replace the has-submenu property with checking menu-name != NULL.
2014-10-26 20:23:31 +00:00
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
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);
box: Avoid position in the reorder api Change the reorder api to insert after a sibling, so that moving to first place becomes reorder (... NULL). And add a insert_after api that can replace the common container_add / reorder_after (... NULL) combination. Update all callers.
2019-01-22 23:44:34 +00:00
gtk_box_insert_child_after (GTK_BOX (box), button, NULL);
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
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));
GtkMenuTracker: add hidden-when='macos-menubar' Provide a mechanism for hiding the "Quit", "About" and "Preferences" menu items from the normal places in a traditional menubar layout (in the File and Edit menus) when the menu is being rendered in the Mac OS menubar. These items can already be found in the application menu. With this feature, applications can now define a single menu to use in all 'traditional' scenarios. Use this new attribute in Bloatpad. https://bugzilla.gnome.org/show_bug.cgi?id=741610
2014-12-16 17:14:23 +00:00
box->tracker = gtk_menu_tracker_new_for_item_link (item, G_MENU_LINK_SUBMENU, FALSE, FALSE,
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
gtk_menu_section_box_insert_func,
gtk_menu_section_box_remove_func,
box);
}
Drop GtkModelButton:has-submenu Replace the has-submenu property with checking menu-name != NULL.
2014-10-26 20:23:31 +00:00
static GtkWidget *
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
gtk_menu_section_box_new_section (GtkMenuTrackerItem *item,
GtkMenuSectionBox: Don't show separators for nested subsections ...unless they are labeled. To implement this, keep track of the nesting depth of section boxes, starting from 0 for the toplevel and the submenu ones, and only insert unlabeled separators if the depth is at most 1.
2014-04-29 16:17:40 +00:00
GtkMenuSectionBox *parent)
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
{
GtkMenuSectionBox *box;
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
const char *label;
const char *hint;
const char *text_direction;
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
box = g_object_new (GTK_TYPE_MENU_SECTION_BOX, NULL);
model button: Redo layout Move checks to the left, and introduce a size group to align things. The size group is provided by the parent, using the new ::indicator-size-group property.
2019-06-06 00:41:45 +00:00
box->indicators = g_object_ref (parent->indicators);
popovermenu: Allow custom items Add a way to add children at certain places in the generated menu for both GtkPopoverMenu and GtkPopoverMenuBar. New apis: gtk_popover_menu_add_child gtk_popover_menu_remove_child gtk_popover_menu_bar_add_child gtk_popover_menu_bar_remove_child Fixes: #3260
2020-10-20 18:26:45 +00:00
box->custom_slots = g_hash_table_ref (parent->toplevel->custom_slots);
GtkMenuSectionBox: Don't show separators for nested subsections ...unless they are labeled. To implement this, keep track of the nesting depth of section boxes, starting from 0 for the toplevel and the submenu ones, and only insert unlabeled separators if the depth is at most 1.
2014-04-29 16:17:40 +00:00
box->toplevel = parent->toplevel;
box->depth = parent->depth + 1;
Add nesting popover menus Add a variant of popover menus that are nesting like traditional menus. This is a better fit for replacing traditional main menus.
2019-08-27 08:28:29 +00:00
box->flags = parent->flags;
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
label = gtk_menu_tracker_item_get_label (item);
GtkMenuSectionBox: add support for iconic sections Sections that have the display-hint attribute set to "horizontal-boxes" will be rendered as a row of icon buttons, instead of menuitem-like.
2014-04-28 18:18:39 +00:00
hint = gtk_menu_tracker_item_get_display_hint (item);
menusectionbox: add support for "text-direction" attribute This allows the use of a "text-direction" hint set to one of "none", "rtl", or "ltr" to enforce the text direction of a "horizontal-buttons" display-hint. This is useful when a menu has buttons that map to physical space in the UI and therefore must match the application widgetry. https://bugzilla.gnome.org/show_bug.cgi?id=772775
2016-10-12 20:56:57 +00:00
text_direction = gtk_menu_tracker_item_get_text_direction (item);
GtkMenuSectionBox: add support for iconic sections Sections that have the display-hint attribute set to "horizontal-boxes" will be rendered as a row of icon buttons, instead of menuitem-like.
2014-04-28 18:18:39 +00:00
if (hint && g_str_equal (hint, "horizontal-buttons"))
{
box: Remove expand child property GtkWidget already has hexpand/vexpand properties.
2017-04-21 16:59:59 +00:00
gtk_box_set_homogeneous (box->item_box, TRUE);
GtkMenuSectionBox: add support for iconic sections Sections that have the display-hint attribute set to "horizontal-boxes" will be rendered as a row of icon buttons, instead of menuitem-like.
2014-04-28 18:18:39 +00:00
gtk_orientable_set_orientation (GTK_ORIENTABLE (box->item_box), GTK_ORIENTATION_HORIZONTAL);
Rename gtk_widget{get,set,has}_style_class to _css_class We want to use css instead of style everywhere now.
2020-02-06 16:32:26 +00:00
gtk_widget_add_css_class (GTK_WIDGET (box->item_box), "linked");
gtk_widget_add_css_class (GTK_WIDGET (box->item_box), "horizontal-buttons");
GtkMenuSectionBox: add support for iconic sections Sections that have the display-hint attribute set to "horizontal-boxes" will be rendered as a row of icon buttons, instead of menuitem-like.
2014-04-28 18:18:39 +00:00
box->iconic = TRUE;
menusectionbox: add support for "text-direction" attribute This allows the use of a "text-direction" hint set to one of "none", "rtl", or "ltr" to enforce the text direction of a "horizontal-buttons" display-hint. This is useful when a menu has buttons that map to physical space in the UI and therefore must match the application widgetry. https://bugzilla.gnome.org/show_bug.cgi?id=772775
2016-10-12 20:56:57 +00:00
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);
}
GtkMenuSectionBox: add support for iconic sections Sections that have the display-hint attribute set to "horizontal-boxes" will be rendered as a row of icon buttons, instead of menuitem-like.
2014-04-28 18:18:39 +00:00
}
menu section box: Introduce more section variants Allow display-hint to be circular-buttons or inline-buttons, to produce variations of horizontal button layouts.
2019-06-06 01:36:17 +00:00
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);
Rename gtk_widget{get,set,has}_style_class to _css_class We want to use css instead of style everywhere now.
2020-02-06 16:32:26 +00:00
gtk_widget_add_css_class (GTK_WIDGET (box->item_box), "inline-buttons");
menu section box: Introduce more section variants Allow display-hint to be circular-buttons or inline-buttons, to produce variations of horizontal button layouts.
2019-06-06 01:36:17 +00:00
Rename GtkIcon widget to GtkBuiltinIcon This is an internal widget whose name is not very important, and we want to rename GtkIconInfo to GtkIcon, so lets rename this.
2020-01-28 14:03:42 +00:00
spacer = gtk_builtin_icon_new ("none");
Replace most remaining uses of container api These are all on GtkBox or enumerating children.
2020-05-09 12:26:52 +00:00
gtk_box_append (GTK_BOX (box->item_box), spacer);
menu section box: Introduce more section variants Allow display-hint to be circular-buttons or inline-buttons, to produce variations of horizontal button layouts.
2019-06-06 01:36:17 +00:00
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);
Replace most remaining uses of container api These are all on GtkBox or enumerating children.
2020-05-09 12:26:52 +00:00
gtk_box_append (GTK_BOX (box->item_box), title);
menu section box: Introduce more section variants Allow display-hint to be circular-buttons or inline-buttons, to produce variations of horizontal button layouts.
2019-06-06 01:36:17 +00:00
}
item_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
Replace most remaining uses of container api These are all on GtkBox or enumerating children.
2020-05-09 12:26:52 +00:00
gtk_box_append (GTK_BOX (box->item_box), item_box);
menu section box: Introduce more section variants Allow display-hint to be circular-buttons or inline-buttons, to produce variations of horizontal button layouts.
2019-06-06 01:36:17 +00:00
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);
Rename gtk_widget{get,set,has}_style_class to _css_class We want to use css instead of style everywhere now.
2020-02-06 16:32:26 +00:00
gtk_widget_add_css_class (GTK_WIDGET (box->item_box), "circular-buttons");
menu section box: Introduce more section variants Allow display-hint to be circular-buttons or inline-buttons, to produce variations of horizontal button layouts.
2019-06-06 01:36:17 +00:00
box->circular = TRUE;
}
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
menu section box: Introduce more section variants Allow display-hint to be circular-buttons or inline-buttons, to produce variations of horizontal button layouts.
2019-06-06 01:36:17 +00:00
if (label != NULL && !box->inline_buttons)
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
{
popover menu: Improved labeled separators Embed the label in the middle of the separators instead of putting it above the separator. https://bugzilla.gnome.org/show_bug.cgi?id=767108
2016-06-01 15:52:20 +00:00
GtkWidget *separator;
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
GtkWidget *title;
Change the approach to menu section titles Put the label below the separator, and give it the title style class.
2020-04-21 18:48:39 +00:00
box->separator = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
popover menu: Improved labeled separators Embed the label in the middle of the separators instead of putting it above the separator. https://bugzilla.gnome.org/show_bug.cgi?id=767108
2016-06-01 15:52:20 +00:00
g_object_ref_sink (box->separator);
separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_widget_set_valign (separator, GTK_ALIGN_CENTER);
Change the approach to menu section titles Put the label below the separator, and give it the title style class.
2020-04-21 18:48:39 +00:00
gtk_widget_set_hexpand (separator, TRUE);
Replace most remaining uses of container api These are all on GtkBox or enumerating children.
2020-05-09 12:26:52 +00:00
gtk_box_append (GTK_BOX (box->separator), separator);
popover menu: Improved labeled separators Embed the label in the middle of the separators instead of putting it above the separator. https://bugzilla.gnome.org/show_bug.cgi?id=767108
2016-06-01 15:52:20 +00:00
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
title = gtk_label_new (label);
g_object_bind_property (item, "label", title, "label", G_BINDING_SYNC_CREATE);
Drop style class defines We document the supported style classes by name, not by macro name, and these macros don't really add any value. Drop them for GTK 4.
2020-08-13 23:49:02 +00:00
gtk_widget_add_css_class (title, "separator");
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
gtk_widget_set_halign (title, GTK_ALIGN_START);
Change the approach to menu section titles Put the label below the separator, and give it the title style class.
2020-04-21 18:48:39 +00:00
gtk_label_set_xalign (GTK_LABEL (title), 0.0);
Drop style class defines We document the supported style classes by name, not by macro name, and these macros don't really add any value. Drop them for GTK 4.
2020-08-13 23:49:02 +00:00
gtk_widget_add_css_class (title, "title");
Replace most remaining uses of container api These are all on GtkBox or enumerating children.
2020-05-09 12:26:52 +00:00
gtk_box_append (GTK_BOX (box->separator), title);
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
}
else
{
popover menu: Improved labeled separators Embed the label in the middle of the separators instead of putting it above the separator. https://bugzilla.gnome.org/show_bug.cgi?id=767108
2016-06-01 15:52:20 +00:00
box->separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
popover menus: Take iconic into account We don't want separators in both side of an iconic section and use a 10px margin to separate two iconic sections. Separators are also updated in case of dynamic insertion ( often used with menu items for plugins ) https://bugzilla.gnome.org/show_bug.cgi?id=738650
2014-10-18 09:19:26 +00:00
g_object_ref_sink (box->separator);
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
}
GtkMenuTracker: add hidden-when='macos-menubar' Provide a mechanism for hiding the "Quit", "About" and "Preferences" menu items from the normal places in a traditional menubar layout (in the File and Edit menus) when the menu is being rendered in the Mac OS menubar. These items can already be found in the application menu. With this feature, applications can now define a single menu to use in all 'traditional' scenarios. Use this new attribute in Bloatpad. https://bugzilla.gnome.org/show_bug.cgi?id=741610
2014-12-16 17:14:23 +00:00
box->tracker = gtk_menu_tracker_new_for_item_link (item, G_MENU_LINK_SECTION, FALSE, FALSE,
GtkPopover: new approach to menu model binding Instead of using GtkMenuTracker to flatten the sections into a single linear menu, handle the sections ourselves by nesting boxes. Each section gets an inner and outer box. The inner box numbers its children in the way that the tracker instructs. The outer box containes the inner box and the separator, if appropriate. Having the two separate boxes will allow us to change the orientation of the inner box if we want to pack widgets horizontally within a section.
2014-04-28 15:55:52 +00:00
gtk_menu_section_box_insert_func,
gtk_menu_section_box_remove_func,
box);
return GTK_WIDGET (box);
}
popovermenu: Allow custom items Add a way to add children at certain places in the generated menu for both GtkPopoverMenu and GtkPopoverMenuBar. New apis: gtk_popover_menu_add_child gtk_popover_menu_remove_child gtk_popover_menu_bar_add_child gtk_popover_menu_bar_remove_child Fixes: #3260
2020-10-20 18:26:45 +00:00
gboolean
gtk_menu_section_box_add_custom (GtkPopoverMenu *popover,
GtkWidget *child,
const char *id)
{
GtkWidget *stack;
GtkMenuSectionBox *box;
GtkWidget *slot;
popovermenu: Scroll when necessary Add a scrolled window to GtkPopoverMenu, so we can scroll long menus when there is not enough room.
2021-07-02 17:19:02 +00:00
stack = gtk_popover_menu_get_stack (popover);
popovermenu: Allow custom items Add a way to add children at certain places in the generated menu for both GtkPopoverMenu and GtkPopoverMenuBar. New apis: gtk_popover_menu_add_child gtk_popover_menu_remove_child gtk_popover_menu_bar_add_child gtk_popover_menu_bar_remove_child Fixes: #3260
2020-10-20 18:26:45 +00:00
box = GTK_MENU_SECTION_BOX (gtk_stack_get_child_by_name (GTK_STACK (stack), "main"));
popovermenu: Fail gracefully if no model If we don't have a model yet, return FALSE from gtk_popover_menu_add_custom().
2020-11-04 19:56:52 +00:00
if (box == NULL)
return FALSE;
popovermenu: Allow custom items Add a way to add children at certain places in the generated menu for both GtkPopoverMenu and GtkPopoverMenuBar. New apis: gtk_popover_menu_add_child gtk_popover_menu_remove_child gtk_popover_menu_bar_add_child gtk_popover_menu_bar_remove_child Fixes: #3260
2020-10-20 18:26:45 +00:00
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 Copy Permalink