a33e5748db
If we don't have a window icon, we hide the titlebar_icon, we still add it, so we can't simply go by the number of children when deciding whether to show the separator or now. Instead, update the separator visibility as we create the various buttons.
1969 lines
60 KiB
C
1969 lines
60 KiB
C
/*
|
|
* Copyright (c) 2013 Red Hat, Inc.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or (at your
|
|
* option) any later version.
|
|
*
|
|
* This program 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 program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include "gtkheaderbar.h"
|
|
#include "gtkheaderbarprivate.h"
|
|
#include "gtkintl.h"
|
|
#include "gtkprivate.h"
|
|
#include "gtktypebuiltins.h"
|
|
#include "gtkwidgetprivate.h"
|
|
#include "gtkcontainerprivate.h"
|
|
#include "gtkwindowprivate.h"
|
|
#include "a11y/gtkcontaineraccessible.h"
|
|
|
|
#include <string.h>
|
|
|
|
/**
|
|
* SECTION:gtkheaderbar
|
|
* @Short_description: A box with a centered child
|
|
* @Title: GtkHeaderBar
|
|
* @See_also: #GtkBox
|
|
*
|
|
* GtkHeaderBar is similar to a horizontal #GtkBox, it allows
|
|
* to place children at the start or the end. In addition,
|
|
* it allows a title to be displayed. The title will be
|
|
* centered with respect to the width of the box, even if the children
|
|
* at either side take up different amounts of space.
|
|
*/
|
|
|
|
#define DEFAULT_SPACING 6
|
|
|
|
struct _GtkHeaderBarPrivate
|
|
{
|
|
gchar *title;
|
|
gchar *subtitle;
|
|
GtkWidget *title_label;
|
|
GtkWidget *subtitle_label;
|
|
GtkWidget *label_box;
|
|
GtkWidget *label_sizing_box;
|
|
GtkWidget *subtitle_sizing_label;
|
|
GtkWidget *custom_title;
|
|
gint spacing;
|
|
gboolean has_subtitle;
|
|
|
|
GList *children;
|
|
|
|
gboolean shows_wm_decorations;
|
|
|
|
GtkWidget *titlebar_start_box;
|
|
GtkWidget *titlebar_end_box;
|
|
|
|
GtkWidget *titlebar_icon;
|
|
GtkWidget *titlebar_menu_button;
|
|
GtkWidget *titlebar_min_button;
|
|
GtkWidget *titlebar_max_button;
|
|
GtkWidget *titlebar_close_button;
|
|
};
|
|
|
|
typedef struct _Child Child;
|
|
struct _Child
|
|
{
|
|
GtkWidget *widget;
|
|
GtkPackType pack_type;
|
|
};
|
|
|
|
enum {
|
|
PROP_0,
|
|
PROP_TITLE,
|
|
PROP_SUBTITLE,
|
|
PROP_HAS_SUBTITLE,
|
|
PROP_CUSTOM_TITLE,
|
|
PROP_SPACING,
|
|
PROP_SHOW_CLOSE_BUTTON,
|
|
};
|
|
|
|
enum {
|
|
CHILD_PROP_0,
|
|
CHILD_PROP_PACK_TYPE,
|
|
CHILD_PROP_POSITION
|
|
};
|
|
|
|
static void gtk_header_bar_buildable_init (GtkBuildableIface *iface);
|
|
|
|
G_DEFINE_TYPE_WITH_CODE (GtkHeaderBar, gtk_header_bar, GTK_TYPE_CONTAINER,
|
|
G_ADD_PRIVATE (GtkHeaderBar)
|
|
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
|
|
gtk_header_bar_buildable_init));
|
|
|
|
static void
|
|
get_css_padding_and_border (GtkWidget *widget,
|
|
GtkBorder *border)
|
|
{
|
|
GtkStyleContext *context;
|
|
GtkStateFlags state;
|
|
GtkBorder tmp;
|
|
|
|
context = gtk_widget_get_style_context (widget);
|
|
state = gtk_widget_get_state_flags (widget);
|
|
|
|
gtk_style_context_get_padding (context, state, border);
|
|
gtk_style_context_get_border (context, state, &tmp);
|
|
border->top += tmp.top;
|
|
border->right += tmp.right;
|
|
border->bottom += tmp.bottom;
|
|
border->left += tmp.left;
|
|
}
|
|
|
|
static void
|
|
init_sizing_box (GtkHeaderBar *bar)
|
|
{
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
GtkWidget *w;
|
|
GtkStyleContext *context;
|
|
|
|
/* We use this box to always request size for the two labels (title
|
|
* and subtitle) as if they were always visible, but then allocate
|
|
* the real label box with its actual size, to keep it center-aligned
|
|
* in case we have only the title.
|
|
*/
|
|
priv->label_sizing_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
|
|
gtk_widget_show (priv->label_sizing_box);
|
|
|
|
w = gtk_label_new (NULL);
|
|
gtk_widget_show (w);
|
|
context = gtk_widget_get_style_context (w);
|
|
gtk_style_context_add_class (context, "title");
|
|
gtk_box_pack_start (GTK_BOX (priv->label_sizing_box), w, FALSE, FALSE, 0);
|
|
gtk_label_set_line_wrap (GTK_LABEL (w), FALSE);
|
|
gtk_label_set_single_line_mode (GTK_LABEL (w), TRUE);
|
|
gtk_label_set_ellipsize (GTK_LABEL (w), PANGO_ELLIPSIZE_END);
|
|
|
|
w = gtk_label_new (NULL);
|
|
context = gtk_widget_get_style_context (w);
|
|
gtk_style_context_add_class (context, "subtitle");
|
|
gtk_style_context_add_class (context, "dim-label");
|
|
gtk_box_pack_start (GTK_BOX (priv->label_sizing_box), w, FALSE, FALSE, 0);
|
|
gtk_label_set_line_wrap (GTK_LABEL (w), FALSE);
|
|
gtk_label_set_single_line_mode (GTK_LABEL (w), TRUE);
|
|
gtk_label_set_ellipsize (GTK_LABEL (w), PANGO_ELLIPSIZE_END);
|
|
gtk_widget_set_visible (w, priv->has_subtitle || (priv->subtitle && priv->subtitle[0]));
|
|
priv->subtitle_sizing_label = w;
|
|
}
|
|
|
|
static GtkWidget *
|
|
create_title_box (const char *title,
|
|
const char *subtitle,
|
|
GtkWidget **ret_title_label,
|
|
GtkWidget **ret_subtitle_label)
|
|
{
|
|
GtkWidget *label_box;
|
|
GtkWidget *title_label;
|
|
GtkWidget *subtitle_label;
|
|
GtkStyleContext *context;
|
|
|
|
label_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
|
|
gtk_widget_set_valign (label_box, GTK_ALIGN_CENTER);
|
|
gtk_widget_show (label_box);
|
|
|
|
title_label = gtk_label_new (title);
|
|
context = gtk_widget_get_style_context (title_label);
|
|
gtk_style_context_add_class (context, "title");
|
|
gtk_label_set_line_wrap (GTK_LABEL (title_label), FALSE);
|
|
gtk_label_set_single_line_mode (GTK_LABEL (title_label), TRUE);
|
|
gtk_label_set_ellipsize (GTK_LABEL (title_label), PANGO_ELLIPSIZE_END);
|
|
gtk_box_pack_start (GTK_BOX (label_box), title_label, FALSE, FALSE, 0);
|
|
gtk_widget_show (title_label);
|
|
|
|
subtitle_label = gtk_label_new (subtitle);
|
|
context = gtk_widget_get_style_context (subtitle_label);
|
|
gtk_style_context_add_class (context, "subtitle");
|
|
gtk_style_context_add_class (context, "dim-label");
|
|
gtk_label_set_line_wrap (GTK_LABEL (subtitle_label), FALSE);
|
|
gtk_label_set_single_line_mode (GTK_LABEL (subtitle_label), TRUE);
|
|
gtk_label_set_ellipsize (GTK_LABEL (subtitle_label), PANGO_ELLIPSIZE_END);
|
|
gtk_box_pack_start (GTK_BOX (label_box), subtitle_label, FALSE, FALSE, 0);
|
|
gtk_widget_set_no_show_all (subtitle_label, TRUE);
|
|
|
|
if (ret_title_label)
|
|
*ret_title_label = title_label;
|
|
if (ret_subtitle_label)
|
|
*ret_subtitle_label = subtitle_label;
|
|
|
|
return label_box;
|
|
}
|
|
|
|
gboolean
|
|
_gtk_header_bar_update_window_icon (GtkHeaderBar *bar,
|
|
GtkWindow *window)
|
|
{
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
gint size;
|
|
GList *list;
|
|
const gchar *name;
|
|
GdkPixbuf *best = NULL;
|
|
|
|
if (priv->titlebar_icon == NULL)
|
|
return FALSE;
|
|
|
|
if (GTK_IS_BUTTON (gtk_widget_get_parent (priv->titlebar_icon)))
|
|
size = 16;
|
|
else
|
|
size = 20;
|
|
|
|
list = gtk_window_get_icon_list (window);
|
|
|
|
if (list != NULL)
|
|
{
|
|
GdkPixbuf *pixbuf;
|
|
GList *l;
|
|
|
|
best = NULL;
|
|
for (l = list; l; l = l->next)
|
|
{
|
|
pixbuf = list->data;
|
|
if (gdk_pixbuf_get_width (pixbuf) <= size)
|
|
{
|
|
best = g_object_ref (pixbuf);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (best == NULL)
|
|
best = gdk_pixbuf_scale_simple (GDK_PIXBUF (list->data), size, size, GDK_INTERP_BILINEAR);
|
|
|
|
g_list_free (list);
|
|
}
|
|
else
|
|
{
|
|
name = gtk_window_get_icon_name (window);
|
|
if (name != NULL)
|
|
best = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
|
|
name, size, GTK_ICON_LOOKUP_FORCE_SIZE, NULL);
|
|
}
|
|
|
|
if (best)
|
|
{
|
|
gtk_image_set_from_pixbuf (GTK_IMAGE (priv->titlebar_icon), best);
|
|
g_object_unref (best);
|
|
gtk_widget_show (priv->titlebar_icon);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void
|
|
_gtk_header_bar_update_window_buttons (GtkHeaderBar *bar)
|
|
{
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
GtkWindow *window;
|
|
GtkTextDirection direction;
|
|
gchar *layout_desc;
|
|
gchar **tokens, **t;
|
|
gint i, j;
|
|
GMenuModel *menu;
|
|
gboolean shown_by_shell;
|
|
|
|
if (!gtk_widget_get_realized (GTK_WIDGET (bar)))
|
|
return;
|
|
|
|
window = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (bar)));
|
|
|
|
direction = gtk_widget_get_direction (GTK_WIDGET (window));
|
|
|
|
if (priv->titlebar_icon)
|
|
{
|
|
gtk_widget_destroy (priv->titlebar_icon);
|
|
priv->titlebar_icon = NULL;
|
|
}
|
|
if (priv->titlebar_menu_button)
|
|
{
|
|
gtk_widget_destroy (priv->titlebar_menu_button);
|
|
priv->titlebar_menu_button = NULL;
|
|
}
|
|
if (priv->titlebar_min_button)
|
|
{
|
|
gtk_widget_destroy (priv->titlebar_min_button);
|
|
priv->titlebar_min_button = NULL;
|
|
}
|
|
if (priv->titlebar_max_button)
|
|
{
|
|
gtk_widget_destroy (priv->titlebar_max_button);
|
|
priv->titlebar_max_button = NULL;
|
|
}
|
|
if (priv->titlebar_close_button)
|
|
{
|
|
gtk_widget_destroy (priv->titlebar_close_button);
|
|
priv->titlebar_close_button = NULL;
|
|
}
|
|
if (priv->titlebar_start_box)
|
|
{
|
|
gtk_widget_destroy (priv->titlebar_start_box);
|
|
priv->titlebar_start_box = NULL;
|
|
}
|
|
if (priv->titlebar_end_box)
|
|
{
|
|
gtk_widget_destroy (priv->titlebar_end_box);
|
|
priv->titlebar_end_box = NULL;
|
|
}
|
|
|
|
if (!priv->shows_wm_decorations)
|
|
return;
|
|
|
|
gtk_widget_style_get (GTK_WIDGET (window),
|
|
"decoration-button-layout", &layout_desc,
|
|
NULL);
|
|
|
|
g_object_get (gtk_widget_get_settings (GTK_WIDGET (window)),
|
|
"gtk-shell-shows-app-menu", &shown_by_shell, NULL);
|
|
|
|
if (!shown_by_shell && gtk_window_get_application (window))
|
|
menu = gtk_application_get_app_menu (gtk_window_get_application (window));
|
|
else
|
|
menu = NULL;
|
|
|
|
tokens = g_strsplit (layout_desc, ":", 2);
|
|
if (tokens)
|
|
{
|
|
for (i = 0; i < 2; i++)
|
|
{
|
|
GtkWidget *box;
|
|
GtkWidget *separator;
|
|
int n_children = 0;
|
|
|
|
if (tokens[i] == NULL)
|
|
continue;
|
|
|
|
t = g_strsplit (tokens[i], ",", -1);
|
|
|
|
separator = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
|
|
|
|
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, priv->spacing);
|
|
|
|
for (j = 0; t[j]; j++)
|
|
{
|
|
GtkWidget *button = NULL;
|
|
GtkWidget *image = NULL;
|
|
AtkObject *accessible;
|
|
|
|
if (strcmp (t[j], "icon") == 0)
|
|
{
|
|
button = gtk_image_new ();
|
|
gtk_style_context_add_class (gtk_widget_get_style_context (button), "titlebutton");
|
|
gtk_widget_set_size_request (button, 20, 20);
|
|
gtk_widget_show (button);
|
|
priv->titlebar_icon = button;
|
|
if (!_gtk_header_bar_update_window_icon (bar, window))
|
|
gtk_widget_hide (button);
|
|
else
|
|
gtk_widget_show (separator);
|
|
}
|
|
else if (strcmp (t[j], "menu") == 0 && menu != NULL)
|
|
{
|
|
button = gtk_menu_button_new ();
|
|
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (button), menu);
|
|
gtk_style_context_add_class (gtk_widget_get_style_context (button), "titlebutton");
|
|
image = gtk_image_new ();
|
|
gtk_container_add (GTK_CONTAINER (button), image);
|
|
gtk_widget_set_can_focus (button, FALSE);
|
|
gtk_widget_show_all (button);
|
|
accessible = gtk_widget_get_accessible (button);
|
|
if (GTK_IS_ACCESSIBLE (accessible))
|
|
atk_object_set_name (accessible, _("Application menu"));
|
|
priv->titlebar_icon = image;
|
|
priv->titlebar_menu_button = button;
|
|
|
|
if (!_gtk_header_bar_update_window_icon (bar, window))
|
|
gtk_image_set_from_icon_name (GTK_IMAGE (priv->titlebar_icon), "process-stop-symbolic", GTK_ICON_SIZE_MENU);
|
|
gtk_widget_show (separator);
|
|
}
|
|
else if (strcmp (t[j], "minimize") == 0 &&
|
|
gtk_window_get_type_hint (window) == GDK_WINDOW_TYPE_HINT_NORMAL)
|
|
{
|
|
button = gtk_button_new ();
|
|
gtk_style_context_add_class (gtk_widget_get_style_context (button), "titlebutton");
|
|
image = gtk_image_new_from_icon_name ("window-minimize-symbolic", GTK_ICON_SIZE_MENU);
|
|
g_object_set (image, "use-fallback", TRUE, NULL);
|
|
gtk_container_add (GTK_CONTAINER (button), image);
|
|
gtk_widget_set_can_focus (button, FALSE);
|
|
gtk_widget_show_all (button);
|
|
g_signal_connect_swapped (button, "clicked",
|
|
G_CALLBACK (gtk_window_iconify), window);
|
|
accessible = gtk_widget_get_accessible (button);
|
|
if (GTK_IS_ACCESSIBLE (accessible))
|
|
atk_object_set_name (accessible, _("Minimize"));
|
|
priv->titlebar_min_button = button;
|
|
gtk_widget_show (separator);
|
|
}
|
|
else if (strcmp (t[j], "maximize") == 0 &&
|
|
gtk_window_get_resizable (window) &&
|
|
gtk_window_get_type_hint (window) == GDK_WINDOW_TYPE_HINT_NORMAL)
|
|
{
|
|
const gchar *icon_name;
|
|
gboolean maximized = _gtk_window_get_maximized (window);
|
|
|
|
icon_name = maximized ? "window-restore-symbolic" : "window-maximize-symbolic";
|
|
button = gtk_button_new ();
|
|
gtk_style_context_add_class (gtk_widget_get_style_context (button), "titlebutton");
|
|
image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU);
|
|
g_object_set (image, "use-fallback", TRUE, NULL);
|
|
gtk_container_add (GTK_CONTAINER (button), image);
|
|
gtk_widget_set_can_focus (button, FALSE);
|
|
gtk_widget_show_all (button);
|
|
g_signal_connect_swapped (button, "clicked",
|
|
G_CALLBACK (_gtk_window_toggle_maximized), window);
|
|
accessible = gtk_widget_get_accessible (button);
|
|
if (GTK_IS_ACCESSIBLE (accessible))
|
|
atk_object_set_name (accessible, maximized ? _("Restore") : _("Maximize"));
|
|
priv->titlebar_max_button = button;
|
|
gtk_widget_show (separator);
|
|
}
|
|
else if (strcmp (t[j], "close") == 0 &&
|
|
gtk_window_get_deletable (window) &&
|
|
gtk_window_get_type_hint (window) == GDK_WINDOW_TYPE_HINT_NORMAL)
|
|
{
|
|
button = gtk_button_new ();
|
|
image = gtk_image_new_from_icon_name ("window-close-symbolic", GTK_ICON_SIZE_MENU);
|
|
gtk_style_context_add_class (gtk_widget_get_style_context (button), "titlebutton");
|
|
g_object_set (image, "use-fallback", TRUE, NULL);
|
|
gtk_container_add (GTK_CONTAINER (button), image);
|
|
gtk_widget_set_can_focus (button, FALSE);
|
|
gtk_widget_show_all (button);
|
|
g_signal_connect_swapped (button, "clicked",
|
|
G_CALLBACK (gtk_window_close), window);
|
|
accessible = gtk_widget_get_accessible (button);
|
|
if (GTK_IS_ACCESSIBLE (accessible))
|
|
atk_object_set_name (accessible, _("Close"));
|
|
priv->titlebar_close_button = button;
|
|
gtk_widget_show (separator);
|
|
}
|
|
|
|
if (button)
|
|
{
|
|
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
|
|
n_children ++;
|
|
}
|
|
}
|
|
g_strfreev (t);
|
|
|
|
if (n_children == 0)
|
|
{
|
|
gtk_widget_destroy (box);
|
|
continue;
|
|
}
|
|
|
|
gtk_widget_show (box);
|
|
gtk_widget_set_parent (box, GTK_WIDGET (bar));
|
|
|
|
if ((direction == GTK_TEXT_DIR_LTR && i == 0) ||
|
|
(direction == GTK_TEXT_DIR_RTL && i == 1))
|
|
{
|
|
gtk_style_context_add_class (gtk_widget_get_style_context (box), "left");
|
|
gtk_box_pack_end (GTK_BOX (box), separator, FALSE, FALSE, 0);
|
|
}
|
|
else
|
|
{
|
|
gtk_style_context_add_class (gtk_widget_get_style_context (box), "right");
|
|
gtk_box_pack_start (GTK_BOX (box), separator, FALSE, FALSE, 0);
|
|
gtk_box_reorder_child (GTK_BOX (box), separator, 0);
|
|
}
|
|
|
|
if (i == 0)
|
|
priv->titlebar_start_box = box;
|
|
else
|
|
priv->titlebar_end_box = box;
|
|
}
|
|
g_strfreev (tokens);
|
|
}
|
|
g_free (layout_desc);
|
|
}
|
|
|
|
gboolean
|
|
_gtk_header_bar_get_shows_app_menu (GtkHeaderBar *bar)
|
|
{
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
|
|
return (priv->titlebar_menu_button != NULL);
|
|
}
|
|
|
|
static void
|
|
construct_label_box (GtkHeaderBar *bar)
|
|
{
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
|
|
g_assert (priv->label_box == NULL);
|
|
|
|
priv->label_box = create_title_box (priv->title,
|
|
priv->subtitle,
|
|
&priv->title_label,
|
|
&priv->subtitle_label);
|
|
gtk_widget_set_parent (priv->label_box, GTK_WIDGET (bar));
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_init (GtkHeaderBar *bar)
|
|
{
|
|
GtkStyleContext *context;
|
|
GtkHeaderBarPrivate *priv;
|
|
|
|
priv = gtk_header_bar_get_instance_private (bar);
|
|
|
|
gtk_widget_set_has_window (GTK_WIDGET (bar), FALSE);
|
|
gtk_widget_set_redraw_on_allocate (GTK_WIDGET (bar), FALSE);
|
|
|
|
priv->title = NULL;
|
|
priv->subtitle = NULL;
|
|
priv->custom_title = NULL;
|
|
priv->children = NULL;
|
|
priv->spacing = DEFAULT_SPACING;
|
|
priv->has_subtitle = TRUE;
|
|
|
|
init_sizing_box (bar);
|
|
construct_label_box (bar);
|
|
|
|
context = gtk_widget_get_style_context (GTK_WIDGET (bar));
|
|
gtk_style_context_add_class (context, "header-bar");
|
|
gtk_style_context_add_class (context, GTK_STYLE_CLASS_HORIZONTAL);
|
|
}
|
|
|
|
static gint
|
|
count_visible_children (GtkHeaderBar *bar)
|
|
{
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
GList *l;
|
|
Child *child;
|
|
gint n;
|
|
|
|
n = 0;
|
|
for (l = priv->children; l; l = l->next)
|
|
{
|
|
child = l->data;
|
|
if (gtk_widget_get_visible (child->widget))
|
|
n++;
|
|
}
|
|
|
|
return n;
|
|
}
|
|
|
|
static gboolean
|
|
add_child_size (GtkWidget *child,
|
|
GtkOrientation orientation,
|
|
gint *minimum,
|
|
gint *natural)
|
|
{
|
|
gint child_minimum, child_natural;
|
|
|
|
if (!gtk_widget_get_visible (child))
|
|
return FALSE;
|
|
|
|
if (orientation == GTK_ORIENTATION_HORIZONTAL)
|
|
gtk_widget_get_preferred_width (child, &child_minimum, &child_natural);
|
|
else
|
|
gtk_widget_get_preferred_height (child, &child_minimum, &child_natural);
|
|
|
|
if (GTK_ORIENTATION_HORIZONTAL == orientation)
|
|
{
|
|
*minimum += child_minimum;
|
|
*natural += child_natural;
|
|
}
|
|
else
|
|
{
|
|
*minimum = MAX (*minimum, child_minimum);
|
|
*natural = MAX (*natural, child_natural);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_get_size (GtkWidget *widget,
|
|
GtkOrientation orientation,
|
|
gint *minimum_size,
|
|
gint *natural_size)
|
|
{
|
|
GtkHeaderBar *bar = GTK_HEADER_BAR (widget);
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
GList *l;
|
|
gint nvis_children;
|
|
gint minimum, natural;
|
|
GtkBorder css_borders;
|
|
|
|
minimum = natural = 0;
|
|
nvis_children = 0;
|
|
|
|
for (l = priv->children; l; l = l->next)
|
|
{
|
|
Child *child = l->data;
|
|
|
|
if (add_child_size (child->widget, orientation, &minimum, &natural))
|
|
nvis_children += 1;
|
|
}
|
|
|
|
if (priv->label_box != NULL)
|
|
{
|
|
if (add_child_size (priv->label_sizing_box, orientation, &minimum, &natural))
|
|
nvis_children += 1;
|
|
}
|
|
|
|
if (priv->custom_title != NULL)
|
|
{
|
|
if (add_child_size (priv->custom_title, orientation, &minimum, &natural))
|
|
nvis_children += 1;
|
|
}
|
|
|
|
if (priv->titlebar_start_box != NULL)
|
|
{
|
|
if (add_child_size (priv->titlebar_start_box, orientation, &minimum, &natural))
|
|
nvis_children += 1;
|
|
}
|
|
|
|
if (priv->titlebar_end_box != NULL)
|
|
{
|
|
if (add_child_size (priv->titlebar_end_box, orientation, &minimum, &natural))
|
|
nvis_children += 1;
|
|
}
|
|
|
|
if (nvis_children > 0 && orientation == GTK_ORIENTATION_HORIZONTAL)
|
|
{
|
|
minimum += nvis_children * priv->spacing;
|
|
natural += nvis_children * priv->spacing;
|
|
}
|
|
|
|
get_css_padding_and_border (widget, &css_borders);
|
|
|
|
if (GTK_ORIENTATION_HORIZONTAL == orientation)
|
|
{
|
|
minimum += css_borders.left + css_borders.right;
|
|
natural += css_borders.left + css_borders.right;
|
|
}
|
|
else
|
|
{
|
|
minimum += css_borders.top + css_borders.bottom;
|
|
natural += css_borders.top + css_borders.bottom;
|
|
}
|
|
|
|
if (minimum_size)
|
|
*minimum_size = minimum;
|
|
|
|
if (natural_size)
|
|
*natural_size = natural;
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_compute_size_for_orientation (GtkWidget *widget,
|
|
gint avail_size,
|
|
gint *minimum_size,
|
|
gint *natural_size)
|
|
{
|
|
GtkHeaderBar *bar = GTK_HEADER_BAR (widget);
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
GList *children;
|
|
gint required_size = 0;
|
|
gint required_natural = 0;
|
|
gint child_size;
|
|
gint child_natural;
|
|
gint nvis_children;
|
|
GtkBorder css_borders;
|
|
|
|
nvis_children = 0;
|
|
|
|
for (children = priv->children; children != NULL; children = children->next)
|
|
{
|
|
Child *child = children->data;
|
|
|
|
if (gtk_widget_get_visible (child->widget))
|
|
{
|
|
gtk_widget_get_preferred_width_for_height (child->widget,
|
|
avail_size, &child_size, &child_natural);
|
|
|
|
required_size += child_size;
|
|
required_natural += child_natural;
|
|
|
|
nvis_children += 1;
|
|
}
|
|
}
|
|
|
|
if (priv->label_box != NULL &&
|
|
gtk_widget_get_visible (priv->label_box))
|
|
{
|
|
gtk_widget_get_preferred_width (priv->label_sizing_box,
|
|
&child_size, &child_natural);
|
|
required_size += child_size;
|
|
required_natural += child_natural;
|
|
}
|
|
|
|
if (priv->custom_title != NULL &&
|
|
gtk_widget_get_visible (priv->custom_title))
|
|
{
|
|
gtk_widget_get_preferred_width (priv->custom_title,
|
|
&child_size, &child_natural);
|
|
required_size += child_size;
|
|
required_natural += child_natural;
|
|
}
|
|
|
|
if (priv->titlebar_start_box != NULL)
|
|
{
|
|
gtk_widget_get_preferred_width (priv->titlebar_start_box,
|
|
&child_size, &child_natural);
|
|
required_size += child_size;
|
|
required_natural += child_natural;
|
|
nvis_children += 1;
|
|
}
|
|
|
|
if (priv->titlebar_end_box != NULL)
|
|
{
|
|
gtk_widget_get_preferred_width (priv->titlebar_end_box,
|
|
&child_size, &child_natural);
|
|
required_size += child_size;
|
|
required_natural += child_natural;
|
|
nvis_children += 1;
|
|
}
|
|
|
|
if (nvis_children > 0)
|
|
{
|
|
required_size += nvis_children * priv->spacing;
|
|
required_natural += nvis_children * priv->spacing;
|
|
}
|
|
|
|
get_css_padding_and_border (widget, &css_borders);
|
|
|
|
required_size += css_borders.left + css_borders.right;
|
|
required_natural += css_borders.left + css_borders.right;
|
|
|
|
if (minimum_size)
|
|
*minimum_size = required_size;
|
|
|
|
if (natural_size)
|
|
*natural_size = required_natural;
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_compute_size_for_opposing_orientation (GtkWidget *widget,
|
|
gint avail_size,
|
|
gint *minimum_size,
|
|
gint *natural_size)
|
|
{
|
|
GtkHeaderBar *bar = GTK_HEADER_BAR (widget);
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
Child *child;
|
|
GList *children;
|
|
gint nvis_children;
|
|
gint computed_minimum = 0;
|
|
gint computed_natural = 0;
|
|
GtkRequestedSize *sizes;
|
|
GtkPackType packing;
|
|
gint size = 0;
|
|
gint i;
|
|
gint child_size;
|
|
gint child_minimum;
|
|
gint child_natural;
|
|
GtkBorder css_borders;
|
|
|
|
nvis_children = count_visible_children (bar);
|
|
|
|
if (nvis_children <= 0)
|
|
return;
|
|
|
|
sizes = g_newa (GtkRequestedSize, nvis_children);
|
|
|
|
/* Retrieve desired size for visible children */
|
|
for (i = 0, children = priv->children; children; children = children->next)
|
|
{
|
|
child = children->data;
|
|
|
|
if (gtk_widget_get_visible (child->widget))
|
|
{
|
|
gtk_widget_get_preferred_width (child->widget,
|
|
&sizes[i].minimum_size,
|
|
&sizes[i].natural_size);
|
|
|
|
size -= sizes[i].minimum_size;
|
|
sizes[i].data = child;
|
|
i += 1;
|
|
}
|
|
}
|
|
|
|
/* Bring children up to size first */
|
|
size = gtk_distribute_natural_allocation (MAX (0, avail_size), nvis_children, sizes);
|
|
|
|
/* Allocate child positions. */
|
|
for (packing = GTK_PACK_START; packing <= GTK_PACK_END; ++packing)
|
|
{
|
|
for (i = 0, children = priv->children; children; children = children->next)
|
|
{
|
|
child = children->data;
|
|
|
|
/* If widget is not visible, skip it. */
|
|
if (!gtk_widget_get_visible (child->widget))
|
|
continue;
|
|
|
|
/* If widget is packed differently skip it, but still increment i,
|
|
* since widget is visible and will be handled in next loop
|
|
* iteration.
|
|
*/
|
|
if (child->pack_type != packing)
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
child_size = sizes[i].minimum_size;
|
|
|
|
gtk_widget_get_preferred_height_for_width (child->widget,
|
|
child_size, &child_minimum, &child_natural);
|
|
|
|
computed_minimum = MAX (computed_minimum, child_minimum);
|
|
computed_natural = MAX (computed_natural, child_natural);
|
|
}
|
|
i += 1;
|
|
}
|
|
|
|
if (priv->label_box != NULL &&
|
|
gtk_widget_get_visible (priv->label_box))
|
|
{
|
|
gtk_widget_get_preferred_height (priv->label_sizing_box,
|
|
&child_minimum, &child_natural);
|
|
computed_minimum = MAX (computed_minimum, child_minimum);
|
|
computed_natural = MAX (computed_natural, child_natural);
|
|
}
|
|
|
|
if (priv->custom_title != NULL &&
|
|
gtk_widget_get_visible (priv->custom_title))
|
|
{
|
|
gtk_widget_get_preferred_height (priv->custom_title,
|
|
&child_minimum, &child_natural);
|
|
computed_minimum = MAX (computed_minimum, child_minimum);
|
|
computed_natural = MAX (computed_natural, child_natural);
|
|
}
|
|
|
|
if (priv->titlebar_start_box != NULL)
|
|
{
|
|
gtk_widget_get_preferred_height (priv->titlebar_start_box,
|
|
&child_minimum, &child_natural);
|
|
computed_minimum = MAX (computed_minimum, child_minimum);
|
|
computed_natural = MAX (computed_natural, child_natural);
|
|
}
|
|
|
|
if (priv->titlebar_end_box != NULL)
|
|
{
|
|
gtk_widget_get_preferred_height (priv->titlebar_end_box,
|
|
&child_minimum, &child_natural);
|
|
computed_minimum = MAX (computed_minimum, child_minimum);
|
|
computed_natural = MAX (computed_natural, child_natural);
|
|
}
|
|
|
|
get_css_padding_and_border (widget, &css_borders);
|
|
|
|
computed_minimum += css_borders.top + css_borders.bottom;
|
|
computed_natural += css_borders.top + css_borders.bottom;
|
|
|
|
if (minimum_size)
|
|
*minimum_size = computed_minimum;
|
|
|
|
if (natural_size)
|
|
*natural_size = computed_natural;
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_get_preferred_width (GtkWidget *widget,
|
|
gint *minimum_size,
|
|
gint *natural_size)
|
|
{
|
|
gtk_header_bar_get_size (widget, GTK_ORIENTATION_HORIZONTAL, minimum_size, natural_size);
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_get_preferred_height (GtkWidget *widget,
|
|
gint *minimum_size,
|
|
gint *natural_size)
|
|
{
|
|
gtk_header_bar_get_size (widget, GTK_ORIENTATION_VERTICAL, minimum_size, natural_size);
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_get_preferred_width_for_height (GtkWidget *widget,
|
|
gint height,
|
|
gint *minimum_width,
|
|
gint *natural_width)
|
|
{
|
|
gtk_header_bar_compute_size_for_orientation (widget, height, minimum_width, natural_width);
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_get_preferred_height_for_width (GtkWidget *widget,
|
|
gint width,
|
|
gint *minimum_height,
|
|
gint *natural_height)
|
|
{
|
|
gtk_header_bar_compute_size_for_opposing_orientation (widget, width, minimum_height, natural_height);
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_size_allocate (GtkWidget *widget,
|
|
GtkAllocation *allocation)
|
|
{
|
|
GtkHeaderBar *bar = GTK_HEADER_BAR (widget);
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
GtkRequestedSize *sizes;
|
|
gint width, height;
|
|
gint nvis_children;
|
|
gint title_minimum_size;
|
|
gint title_natural_size;
|
|
gint start_width, end_width;
|
|
gint side[2];
|
|
GList *l;
|
|
gint i;
|
|
Child *child;
|
|
GtkPackType packing;
|
|
GtkAllocation child_allocation;
|
|
gint x;
|
|
gint child_size;
|
|
GtkTextDirection direction;
|
|
GtkBorder css_borders;
|
|
|
|
gtk_widget_set_allocation (widget, allocation);
|
|
|
|
direction = gtk_widget_get_direction (widget);
|
|
nvis_children = count_visible_children (bar);
|
|
sizes = g_newa (GtkRequestedSize, nvis_children);
|
|
|
|
get_css_padding_and_border (widget, &css_borders);
|
|
width = allocation->width - nvis_children * priv->spacing - css_borders.left - css_borders.right;
|
|
height = allocation->height - css_borders.top - css_borders.bottom;
|
|
|
|
i = 0;
|
|
for (l = priv->children; l; l = l->next)
|
|
{
|
|
child = l->data;
|
|
if (!gtk_widget_get_visible (child->widget))
|
|
continue;
|
|
|
|
gtk_widget_get_preferred_width_for_height (child->widget,
|
|
height,
|
|
&sizes[i].minimum_size,
|
|
&sizes[i].natural_size);
|
|
width -= sizes[i].minimum_size;
|
|
i++;
|
|
}
|
|
|
|
if (priv->custom_title)
|
|
{
|
|
gtk_widget_get_preferred_width_for_height (priv->custom_title,
|
|
height,
|
|
&title_minimum_size,
|
|
&title_natural_size);
|
|
}
|
|
else
|
|
{
|
|
gtk_widget_get_preferred_width_for_height (priv->label_box,
|
|
height,
|
|
&title_minimum_size,
|
|
&title_natural_size);
|
|
}
|
|
width -= title_natural_size;
|
|
|
|
start_width = 0;
|
|
if (priv->titlebar_start_box != NULL)
|
|
{
|
|
gint min, nat;
|
|
gtk_widget_get_preferred_width_for_height (priv->titlebar_start_box,
|
|
height,
|
|
&min, &nat);
|
|
start_width = nat + priv->spacing;
|
|
}
|
|
width -= start_width;
|
|
|
|
end_width = 0;
|
|
if (priv->titlebar_end_box != NULL)
|
|
{
|
|
gint min, nat;
|
|
gtk_widget_get_preferred_width_for_height (priv->titlebar_end_box,
|
|
height,
|
|
&min, &nat);
|
|
end_width = nat + priv->spacing;
|
|
}
|
|
width -= end_width;
|
|
|
|
width = gtk_distribute_natural_allocation (MAX (0, width), nvis_children, sizes);
|
|
|
|
side[0] = side[1] = 0;
|
|
for (packing = GTK_PACK_START; packing <= GTK_PACK_END; packing++)
|
|
{
|
|
child_allocation.y = allocation->y + css_borders.top;
|
|
child_allocation.height = height;
|
|
if (packing == GTK_PACK_START)
|
|
x = allocation->x + css_borders.left + start_width;
|
|
else
|
|
x = allocation->x + allocation->width - end_width - css_borders.right;
|
|
|
|
if (packing == GTK_PACK_START)
|
|
{
|
|
l = priv->children;
|
|
i = 0;
|
|
}
|
|
else
|
|
{
|
|
l = g_list_last (priv->children);
|
|
i = nvis_children - 1;
|
|
}
|
|
|
|
for (; l != NULL; (packing == GTK_PACK_START) ? (l = l->next) : (l = l->prev))
|
|
{
|
|
child = l->data;
|
|
if (!gtk_widget_get_visible (child->widget))
|
|
continue;
|
|
|
|
if (child->pack_type != packing)
|
|
goto next;
|
|
|
|
child_size = sizes[i].minimum_size;
|
|
|
|
child_allocation.width = child_size;
|
|
|
|
if (packing == GTK_PACK_START)
|
|
{
|
|
child_allocation.x = x;
|
|
x += child_size;
|
|
x += priv->spacing;
|
|
}
|
|
else
|
|
{
|
|
x -= child_size;
|
|
child_allocation.x = x;
|
|
x -= priv->spacing;
|
|
}
|
|
|
|
side[packing] += child_size + priv->spacing;
|
|
|
|
if (direction == GTK_TEXT_DIR_RTL)
|
|
child_allocation.x = allocation->x + allocation->width - (child_allocation.x - allocation->x) - child_allocation.width;
|
|
|
|
gtk_widget_size_allocate (child->widget, &child_allocation);
|
|
|
|
next:
|
|
if (packing == GTK_PACK_START)
|
|
i++;
|
|
else
|
|
i--;
|
|
}
|
|
}
|
|
|
|
side[GTK_PACK_START] += start_width;
|
|
side[GTK_PACK_END] += end_width;
|
|
|
|
child_allocation.y = allocation->y + css_borders.top;
|
|
child_allocation.height = height;
|
|
|
|
width = MAX (side[0], side[1]);
|
|
|
|
if (allocation->width - 2 * width >= title_natural_size)
|
|
child_size = MIN (title_natural_size, allocation->width - 2 * width);
|
|
else if (allocation->width - side[0] - side[1] >= title_natural_size)
|
|
child_size = MIN (title_natural_size, allocation->width - side[0] - side[1]);
|
|
else
|
|
child_size = allocation->width - side[0] - side[1];
|
|
|
|
child_allocation.x = allocation->x + (allocation->width - child_size) / 2;
|
|
child_allocation.width = child_size;
|
|
|
|
if (allocation->x + side[0] > child_allocation.x)
|
|
child_allocation.x = allocation->x + side[0];
|
|
else if (allocation->x + allocation->width - side[1] < child_allocation.x + child_allocation.width)
|
|
child_allocation.x = allocation->x + allocation->width - side[1] - child_allocation.width;
|
|
|
|
if (direction == GTK_TEXT_DIR_RTL)
|
|
child_allocation.x = allocation->x + allocation->width - (child_allocation.x - allocation->x) - child_allocation.width;
|
|
|
|
if (priv->custom_title)
|
|
gtk_widget_size_allocate (priv->custom_title, &child_allocation);
|
|
else
|
|
gtk_widget_size_allocate (priv->label_box, &child_allocation);
|
|
|
|
if (priv->titlebar_start_box)
|
|
{
|
|
gboolean left = (direction == GTK_TEXT_DIR_LTR);
|
|
if (left)
|
|
child_allocation.x = allocation->x + css_borders.left;
|
|
else
|
|
child_allocation.x = allocation->x + allocation->width - css_borders.right - start_width;
|
|
child_allocation.width = start_width;
|
|
gtk_widget_size_allocate (priv->titlebar_start_box, &child_allocation);
|
|
}
|
|
|
|
if (priv->titlebar_end_box)
|
|
{
|
|
gboolean left = (direction != GTK_TEXT_DIR_LTR);
|
|
if (left)
|
|
child_allocation.x = allocation->x + css_borders.left;
|
|
else
|
|
child_allocation.x = allocation->x + allocation->width - css_borders.right - end_width;
|
|
child_allocation.width = end_width;
|
|
gtk_widget_size_allocate (priv->titlebar_end_box, &child_allocation);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gtk_header_bar_set_title:
|
|
* @bar: a #GtkHeaderBar
|
|
* @title: (allow-none): a title, or %NULL
|
|
*
|
|
* Sets the title of the #GtkHeaderBar. The title should help a user
|
|
* identify the current view. A good title should not include the
|
|
* application name.
|
|
*
|
|
* Since: 3.10
|
|
*/
|
|
void
|
|
gtk_header_bar_set_title (GtkHeaderBar *bar,
|
|
const gchar *title)
|
|
{
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
gchar *new_title;
|
|
|
|
g_return_if_fail (GTK_IS_HEADER_BAR (bar));
|
|
|
|
new_title = g_strdup (title);
|
|
g_free (priv->title);
|
|
priv->title = new_title;
|
|
|
|
if (priv->title_label != NULL)
|
|
{
|
|
gtk_label_set_label (GTK_LABEL (priv->title_label), priv->title);
|
|
gtk_widget_queue_resize (GTK_WIDGET (bar));
|
|
}
|
|
|
|
g_object_notify (G_OBJECT (bar), "title");
|
|
}
|
|
|
|
/**
|
|
* gtk_header_bar_get_title:
|
|
* @bar: a #GtkHeaderBar
|
|
*
|
|
* Retrieves the title of the header. See gtk_header_bar_set_title().
|
|
*
|
|
* Return value: the title of the header, or %NULL if none has
|
|
* been set explicitely. The returned string is owned by the widget
|
|
* and must not be modified or freed.
|
|
*
|
|
* Since: 3.10
|
|
*/
|
|
const gchar *
|
|
gtk_header_bar_get_title (GtkHeaderBar *bar)
|
|
{
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
|
|
g_return_val_if_fail (GTK_IS_HEADER_BAR (bar), NULL);
|
|
|
|
return priv->title;
|
|
}
|
|
|
|
/**
|
|
* gtk_header_bar_set_subtitle:
|
|
* @bar: a #GtkHeaderBar
|
|
* @subtitle: (allow-none): a subtitle, or %NULL
|
|
*
|
|
* Sets the subtitle of the #GtkHeaderBar. The title should give a user
|
|
* an additional detail to help him identify the current view.
|
|
*
|
|
* Note that GtkHeaderBar by default reserves room for the subtitle,
|
|
* even if none is currently set. If this is not desired, set the
|
|
* #GtkHeaderBar:has-subtitle property to %FALSE.
|
|
*
|
|
* Since: 3.10
|
|
*/
|
|
void
|
|
gtk_header_bar_set_subtitle (GtkHeaderBar *bar,
|
|
const gchar *subtitle)
|
|
{
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
gchar *new_subtitle;
|
|
|
|
g_return_if_fail (GTK_IS_HEADER_BAR (bar));
|
|
|
|
new_subtitle = g_strdup (subtitle);
|
|
g_free (priv->subtitle);
|
|
priv->subtitle = new_subtitle;
|
|
|
|
if (priv->subtitle_label != NULL)
|
|
{
|
|
gtk_label_set_label (GTK_LABEL (priv->subtitle_label), priv->subtitle);
|
|
gtk_widget_set_visible (priv->subtitle_label, priv->subtitle && priv->subtitle[0]);
|
|
gtk_widget_queue_resize (GTK_WIDGET (bar));
|
|
}
|
|
|
|
gtk_widget_set_visible (priv->subtitle_sizing_label, priv->has_subtitle || (priv->subtitle && priv->subtitle[0]));
|
|
|
|
g_object_notify (G_OBJECT (bar), "subtitle");
|
|
}
|
|
|
|
/**
|
|
* gtk_header_bar_get_subtitle:
|
|
* @bar: a #GtkHeaderBar
|
|
*
|
|
* Retrieves the subtitle of the header. See gtk_header_bar_set_subtitle().
|
|
*
|
|
* Return value: the subtitle of the header, or %NULL if none has
|
|
* been set explicitely. The returned string is owned by the widget
|
|
* and must not be modified or freed.
|
|
*
|
|
* Since: 3.10
|
|
*/
|
|
const gchar *
|
|
gtk_header_bar_get_subtitle (GtkHeaderBar *bar)
|
|
{
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
|
|
g_return_val_if_fail (GTK_IS_HEADER_BAR (bar), NULL);
|
|
|
|
return priv->subtitle;
|
|
}
|
|
|
|
/**
|
|
* gtk_header_bar_set_custom_title:
|
|
* @bar: a #GtkHeaderBar
|
|
* @title_widget: (allow-none): a custom widget to use for a title
|
|
*
|
|
* Sets a custom title for the #GtkHeaderBar.
|
|
*
|
|
* The title should help a user identify the current view. This
|
|
* supersedes any title set by gtk_header_bar_set_title() or
|
|
* gtk_header_bar_set_subtitle(). To achieve the same style as
|
|
* the builtin title and subtitle, use the "title" and "subtitle"
|
|
* style classes.
|
|
*
|
|
* You should set the custom title to %NULL, for the header title
|
|
* label to be visible again.
|
|
*
|
|
* Since: 3.10
|
|
*/
|
|
void
|
|
gtk_header_bar_set_custom_title (GtkHeaderBar *bar,
|
|
GtkWidget *title_widget)
|
|
{
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
|
|
g_return_if_fail (GTK_IS_HEADER_BAR (bar));
|
|
if (title_widget)
|
|
g_return_if_fail (GTK_IS_WIDGET (title_widget));
|
|
|
|
/* No need to do anything if the custom widget stays the same */
|
|
if (priv->custom_title == title_widget)
|
|
return;
|
|
|
|
if (priv->custom_title)
|
|
{
|
|
GtkWidget *custom = priv->custom_title;
|
|
|
|
priv->custom_title = NULL;
|
|
gtk_widget_unparent (custom);
|
|
}
|
|
|
|
if (title_widget != NULL)
|
|
{
|
|
priv->custom_title = title_widget;
|
|
|
|
gtk_widget_set_parent (priv->custom_title, GTK_WIDGET (bar));
|
|
gtk_widget_set_valign (priv->custom_title, GTK_ALIGN_CENTER);
|
|
gtk_widget_show (title_widget);
|
|
|
|
if (priv->label_box != NULL)
|
|
{
|
|
GtkWidget *label_box = priv->label_box;
|
|
|
|
priv->label_box = NULL;
|
|
priv->title_label = NULL;
|
|
priv->subtitle_label = NULL;
|
|
gtk_widget_unparent (label_box);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if (priv->label_box == NULL)
|
|
construct_label_box (bar);
|
|
}
|
|
|
|
gtk_widget_queue_resize (GTK_WIDGET (bar));
|
|
|
|
g_object_notify (G_OBJECT (bar), "custom-title");
|
|
}
|
|
|
|
/**
|
|
* gtk_header_bar_get_custom_title:
|
|
* @bar: a #GtkHeaderBar
|
|
*
|
|
* Retrieves the custom title widget of the header. See
|
|
* gtk_header_bar_set_custom_title().
|
|
*
|
|
* Return value: (transfer none): the custom title widget
|
|
* of the header, or %NULL if none has been set explicitely.
|
|
*
|
|
* Since: 3.10
|
|
*/
|
|
GtkWidget *
|
|
gtk_header_bar_get_custom_title (GtkHeaderBar *bar)
|
|
{
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
|
|
g_return_val_if_fail (GTK_IS_HEADER_BAR (bar), NULL);
|
|
|
|
return priv->custom_title;
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_finalize (GObject *object)
|
|
{
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (GTK_HEADER_BAR (object));
|
|
|
|
g_free (priv->title);
|
|
g_free (priv->subtitle);
|
|
|
|
G_OBJECT_CLASS (gtk_header_bar_parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_get_property (GObject *object,
|
|
guint prop_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
GtkHeaderBar *bar = GTK_HEADER_BAR (object);
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_TITLE:
|
|
g_value_set_string (value, priv->title);
|
|
break;
|
|
|
|
case PROP_SUBTITLE:
|
|
g_value_set_string (value, priv->subtitle);
|
|
break;
|
|
|
|
case PROP_CUSTOM_TITLE:
|
|
g_value_set_object (value, priv->custom_title);
|
|
break;
|
|
|
|
case PROP_SPACING:
|
|
g_value_set_int (value, priv->spacing);
|
|
break;
|
|
|
|
case PROP_SHOW_CLOSE_BUTTON:
|
|
g_value_set_boolean (value, gtk_header_bar_get_show_close_button (bar));
|
|
break;
|
|
|
|
case PROP_HAS_SUBTITLE:
|
|
g_value_set_boolean (value, gtk_header_bar_get_has_subtitle (bar));
|
|
break;
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_set_property (GObject *object,
|
|
guint prop_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
GtkHeaderBar *bar = GTK_HEADER_BAR (object);
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_TITLE:
|
|
gtk_header_bar_set_title (bar, g_value_get_string (value));
|
|
break;
|
|
|
|
case PROP_SUBTITLE:
|
|
gtk_header_bar_set_subtitle (bar, g_value_get_string (value));
|
|
break;
|
|
|
|
case PROP_CUSTOM_TITLE:
|
|
gtk_header_bar_set_custom_title (bar, g_value_get_object (value));
|
|
break;
|
|
|
|
case PROP_SPACING:
|
|
priv->spacing = g_value_get_int (value);
|
|
gtk_widget_queue_resize (GTK_WIDGET (bar));
|
|
break;
|
|
|
|
case PROP_SHOW_CLOSE_BUTTON:
|
|
gtk_header_bar_set_show_close_button (bar, g_value_get_boolean (value));
|
|
break;
|
|
|
|
case PROP_HAS_SUBTITLE:
|
|
gtk_header_bar_set_has_subtitle (bar, g_value_get_boolean (value));
|
|
break;
|
|
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_pack (GtkHeaderBar *bar,
|
|
GtkWidget *widget,
|
|
GtkPackType pack_type)
|
|
{
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
Child *child;
|
|
|
|
g_return_if_fail (gtk_widget_get_parent (widget) == NULL);
|
|
|
|
child = g_new (Child, 1);
|
|
child->widget = widget;
|
|
child->pack_type = pack_type;
|
|
|
|
priv->children = g_list_append (priv->children, child);
|
|
|
|
gtk_widget_freeze_child_notify (widget);
|
|
gtk_widget_set_parent (widget, GTK_WIDGET (bar));
|
|
gtk_widget_child_notify (widget, "pack-type");
|
|
gtk_widget_child_notify (widget, "position");
|
|
gtk_widget_thaw_child_notify (widget);
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_add (GtkContainer *container,
|
|
GtkWidget *child)
|
|
{
|
|
gtk_header_bar_pack (GTK_HEADER_BAR (container), child, GTK_PACK_START);
|
|
}
|
|
|
|
static GList *
|
|
find_child_link (GtkHeaderBar *bar,
|
|
GtkWidget *widget)
|
|
{
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
GList *l;
|
|
Child *child;
|
|
|
|
for (l = priv->children; l; l = l->next)
|
|
{
|
|
child = l->data;
|
|
if (child->widget == widget)
|
|
return l;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_remove (GtkContainer *container,
|
|
GtkWidget *widget)
|
|
{
|
|
GtkHeaderBar *bar = GTK_HEADER_BAR (container);
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
GList *l;
|
|
Child *child;
|
|
|
|
l = find_child_link (bar, widget);
|
|
if (l)
|
|
{
|
|
child = l->data;
|
|
gtk_widget_unparent (child->widget);
|
|
priv->children = g_list_delete_link (priv->children, l);
|
|
g_free (child);
|
|
gtk_widget_queue_resize (GTK_WIDGET (container));
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_forall (GtkContainer *container,
|
|
gboolean include_internals,
|
|
GtkCallback callback,
|
|
gpointer callback_data)
|
|
{
|
|
GtkHeaderBar *bar = GTK_HEADER_BAR (container);
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
Child *child;
|
|
GList *children;
|
|
|
|
children = priv->children;
|
|
while (children)
|
|
{
|
|
child = children->data;
|
|
children = children->next;
|
|
if (child->pack_type == GTK_PACK_START)
|
|
(* callback) (child->widget, callback_data);
|
|
}
|
|
|
|
if (priv->custom_title != NULL)
|
|
(* callback) (priv->custom_title, callback_data);
|
|
|
|
if (include_internals && priv->label_box != NULL)
|
|
(* callback) (priv->label_box, callback_data);
|
|
|
|
if (include_internals && priv->titlebar_start_box != NULL)
|
|
(* callback) (priv->titlebar_start_box, callback_data);
|
|
|
|
if (include_internals && priv->titlebar_end_box != NULL)
|
|
(* callback) (priv->titlebar_end_box, callback_data);
|
|
|
|
children = priv->children;
|
|
while (children)
|
|
{
|
|
child = children->data;
|
|
children = children->next;
|
|
if (child->pack_type == GTK_PACK_END)
|
|
(* callback) (child->widget, callback_data);
|
|
}
|
|
}
|
|
|
|
static GType
|
|
gtk_header_bar_child_type (GtkContainer *container)
|
|
{
|
|
return GTK_TYPE_WIDGET;
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_get_child_property (GtkContainer *container,
|
|
GtkWidget *widget,
|
|
guint property_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
GtkHeaderBar *bar = GTK_HEADER_BAR (container);
|
|
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
|
|
GList *l;
|
|
Child *child;
|
|
|
|
l = find_child_link (bar, widget);
|
|
if (l == NULL)
|
|
{
|
|
g_param_value_set_default (pspec, value);
|
|
return;
|
|
}
|
|
|
|
child = l->data;
|
|
|
|
switch (property_id)
|
|
{
|
|
case CHILD_PROP_PACK_TYPE:
|
|
g_value_set_enum (value, child->pack_type);
|
|
break;
|
|
|
|
case CHILD_PROP_POSITION:
|
|
g_value_set_int (value, g_list_position (priv->children, l));
|
|
break;
|
|
|
|
default:
|
|
GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_set_child_property (GtkContainer *container,
|
|
GtkWidget *widget,
|
|
guint property_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
GList *l;
|
|
Child *child;
|
|
|
|
l = find_child_link (GTK_HEADER_BAR (container), widget);
|
|
child = l->data;
|
|
|
|
switch (property_id)
|
|
{
|
|
case CHILD_PROP_PACK_TYPE:
|
|
child->pack_type = g_value_get_enum (value);
|
|
break;
|
|
default:
|
|
GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static GtkWidgetPath *
|
|
gtk_header_bar_get_path_for_child (GtkContainer *container,
|
|
GtkWidget *child)
|
|
{
|
|
GtkHeaderBar *bar = GTK_HEADER_BAR (container);
|
|
GtkWidgetPath *path, *sibling_path;
|
|
GList *list, *children;
|
|
|
|
path = _gtk_widget_create_path (GTK_WIDGET (container));
|
|
|
|
if (gtk_widget_get_visible (child))
|
|
{
|
|
gint i, position;
|
|
|
|
sibling_path = gtk_widget_path_new ();
|
|
|
|
/* get_all_children works in reverse (!) visible order */
|
|
children = _gtk_container_get_all_children (container);
|
|
if (gtk_widget_get_direction (GTK_WIDGET (bar)) == GTK_TEXT_DIR_LTR)
|
|
children = g_list_reverse (children);
|
|
|
|
position = -1;
|
|
i = 0;
|
|
for (list = children; list; list = list->next)
|
|
{
|
|
if (!gtk_widget_get_visible (list->data))
|
|
continue;
|
|
|
|
gtk_widget_path_append_for_widget (sibling_path, list->data);
|
|
|
|
if (list->data == child)
|
|
position = i;
|
|
i++;
|
|
}
|
|
g_list_free (children);
|
|
|
|
if (position >= 0)
|
|
gtk_widget_path_append_with_siblings (path, sibling_path, position);
|
|
else
|
|
gtk_widget_path_append_for_widget (path, child);
|
|
|
|
gtk_widget_path_unref (sibling_path);
|
|
}
|
|
else
|
|
gtk_widget_path_append_for_widget (path, child);
|
|
|
|
return path;
|
|
}
|
|
|
|
static gint
|
|
gtk_header_bar_draw (GtkWidget *widget,
|
|
cairo_t *cr)
|
|
{
|
|
GtkStyleContext *context;
|
|
|
|
context = gtk_widget_get_style_context (widget);
|
|
|
|
gtk_render_background (context, cr, 0, 0,
|
|
gtk_widget_get_allocated_width (widget),
|
|
gtk_widget_get_allocated_height (widget));
|
|
gtk_render_frame (context, cr, 0, 0,
|
|
gtk_widget_get_allocated_width (widget),
|
|
gtk_widget_get_allocated_height (widget));
|
|
|
|
|
|
GTK_WIDGET_CLASS (gtk_header_bar_parent_class)->draw (widget, cr);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_realize (GtkWidget *widget)
|
|
{
|
|
GtkSettings *settings;
|
|
|
|
GTK_WIDGET_CLASS (gtk_header_bar_parent_class)->realize (widget);
|
|
|
|
settings = gtk_widget_get_settings (widget);
|
|
g_signal_connect_swapped (settings, "notify::gtk-shell-shows-app-menu",
|
|
G_CALLBACK (_gtk_header_bar_update_window_buttons), widget);
|
|
_gtk_header_bar_update_window_buttons (GTK_HEADER_BAR (widget));
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_unrealize (GtkWidget *widget)
|
|
{
|
|
GtkSettings *settings;
|
|
|
|
settings = gtk_widget_get_settings (widget);
|
|
|
|
g_signal_handlers_disconnect_by_func (settings, _gtk_header_bar_update_window_buttons, widget);
|
|
|
|
GTK_WIDGET_CLASS (gtk_header_bar_parent_class)->unrealize (widget);
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_class_init (GtkHeaderBarClass *class)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (class);
|
|
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
|
|
GtkContainerClass *container_class = GTK_CONTAINER_CLASS (class);
|
|
|
|
object_class->finalize = gtk_header_bar_finalize;
|
|
object_class->get_property = gtk_header_bar_get_property;
|
|
object_class->set_property = gtk_header_bar_set_property;
|
|
|
|
widget_class->size_allocate = gtk_header_bar_size_allocate;
|
|
widget_class->get_preferred_width = gtk_header_bar_get_preferred_width;
|
|
widget_class->get_preferred_height = gtk_header_bar_get_preferred_height;
|
|
widget_class->get_preferred_height_for_width = gtk_header_bar_get_preferred_height_for_width;
|
|
widget_class->get_preferred_width_for_height = gtk_header_bar_get_preferred_width_for_height;
|
|
widget_class->draw = gtk_header_bar_draw;
|
|
widget_class->realize = gtk_header_bar_realize;
|
|
widget_class->unrealize = gtk_header_bar_unrealize;
|
|
|
|
container_class->add = gtk_header_bar_add;
|
|
container_class->remove = gtk_header_bar_remove;
|
|
container_class->forall = gtk_header_bar_forall;
|
|
container_class->child_type = gtk_header_bar_child_type;
|
|
container_class->set_child_property = gtk_header_bar_set_child_property;
|
|
container_class->get_child_property = gtk_header_bar_get_child_property;
|
|
container_class->get_path_for_child = gtk_header_bar_get_path_for_child;
|
|
gtk_container_class_handle_border_width (container_class);
|
|
|
|
gtk_container_class_install_child_property (container_class,
|
|
CHILD_PROP_PACK_TYPE,
|
|
g_param_spec_enum ("pack-type",
|
|
P_("Pack type"),
|
|
P_("A GtkPackType indicating whether the child is packed with reference to the start or end of the parent"),
|
|
GTK_TYPE_PACK_TYPE, GTK_PACK_START,
|
|
GTK_PARAM_READWRITE));
|
|
gtk_container_class_install_child_property (container_class,
|
|
CHILD_PROP_POSITION,
|
|
g_param_spec_int ("position",
|
|
P_("Position"),
|
|
P_("The index of the child in the parent"),
|
|
-1, G_MAXINT, 0,
|
|
GTK_PARAM_READABLE));
|
|
|
|
g_object_class_install_property (object_class,
|
|
PROP_TITLE,
|
|
g_param_spec_string ("title",
|
|
P_("Title"),
|
|
P_("The title to display"),
|
|
NULL,
|
|
G_PARAM_READWRITE));
|
|
|
|
g_object_class_install_property (object_class,
|
|
PROP_SUBTITLE,
|
|
g_param_spec_string ("subtitle",
|
|
P_("Subtitle"),
|
|
P_("The subtitle to display"),
|
|
NULL,
|
|
G_PARAM_READWRITE));
|
|
|
|
g_object_class_install_property (object_class,
|
|
PROP_CUSTOM_TITLE,
|
|
g_param_spec_object ("custom-title",
|
|
P_("Custom Title"),
|
|
P_("Custom title widget to display"),
|
|
GTK_TYPE_WIDGET,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT |
|
|
G_PARAM_STATIC_STRINGS));
|
|
|
|
g_object_class_install_property (object_class,
|
|
PROP_SPACING,
|
|
g_param_spec_int ("spacing",
|
|
P_("Spacing"),
|
|
P_("The amount of space between children"),
|
|
0, G_MAXINT,
|
|
DEFAULT_SPACING,
|
|
GTK_PARAM_READWRITE));
|
|
|
|
g_object_class_install_property (object_class,
|
|
PROP_SHOW_CLOSE_BUTTON,
|
|
g_param_spec_boolean ("show-close-button",
|
|
P_("Show decorations"),
|
|
P_("Whether to show window decorations"),
|
|
FALSE,
|
|
GTK_PARAM_READWRITE));
|
|
|
|
/**
|
|
* GtkHeaderBar:has-subtitle:
|
|
*
|
|
* If %TRUE, reserve space for a subtitle, even if none
|
|
* is currently set.
|
|
*
|
|
* Since: 3.12
|
|
*/
|
|
g_object_class_install_property (object_class,
|
|
PROP_HAS_SUBTITLE,
|
|
g_param_spec_boolean ("has-subtitle",
|
|
P_("Has Subtitle"),
|
|
P_("Whether to reserve space for a subtitle"),
|
|
TRUE,
|
|
GTK_PARAM_READWRITE));
|
|
|
|
gtk_widget_class_set_accessible_role (widget_class, ATK_ROLE_PANEL);
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_buildable_add_child (GtkBuildable *buildable,
|
|
GtkBuilder *builder,
|
|
GObject *child,
|
|
const gchar *type)
|
|
{
|
|
if (type && strcmp (type, "title") == 0)
|
|
gtk_header_bar_set_custom_title (GTK_HEADER_BAR (buildable), GTK_WIDGET (child));
|
|
else if (!type)
|
|
gtk_container_add (GTK_CONTAINER (buildable), GTK_WIDGET (child));
|
|
else
|
|
GTK_BUILDER_WARN_INVALID_CHILD_TYPE (GTK_HEADER_BAR (buildable), type);
|
|
}
|
|
|
|
static void
|
|
gtk_header_bar_buildable_init (GtkBuildableIface *iface)
|
|
{
|
|
iface->add_child = gtk_header_bar_buildable_add_child;
|
|
}
|
|
|
|
/**
|
|
* gtk_header_bar_pack_start:
|
|
* @bar: A #GtkHeaderBar
|
|
* @child: the #GtkWidget to be added to @bar
|
|
*
|
|
* Adds @child to @box, packed with reference to the
|
|
* start of the @box.
|
|
*
|
|
* Since: 3.10
|
|
*/
|
|
void
|
|
gtk_header_bar_pack_start (GtkHeaderBar *bar,
|
|
GtkWidget *child)
|
|
{
|
|
gtk_header_bar_pack (bar, child, GTK_PACK_START);
|
|
}
|
|
|
|
/**
|
|
* gtk_header_bar_pack_end:
|
|
* @bar: A #GtkHeaderBar
|
|
* @child: the #GtkWidget to be added to @bar
|
|
*
|
|
* Adds @child to @box, packed with reference to the
|
|
* end of the @box.
|
|
*
|
|
* Since: 3.10
|
|
*/
|
|
void
|
|
gtk_header_bar_pack_end (GtkHeaderBar *bar,
|
|
GtkWidget *child)
|
|
{
|
|
gtk_header_bar_pack (bar, child, GTK_PACK_END);
|
|
}
|
|
|
|
/**
|
|
* gtk_header_bar_new:
|
|
*
|
|
* Creates a new #GtkHeaderBar widget.
|
|
*
|
|
* Returns: a new #GtkHeaderBar
|
|
*
|
|
* Since: 3.10
|
|
*/
|
|
GtkWidget *
|
|
gtk_header_bar_new (void)
|
|
{
|
|
return GTK_WIDGET (g_object_new (GTK_TYPE_HEADER_BAR, NULL));
|
|
}
|
|
|
|
/**
|
|
* gtk_header_bar_get_show_close_button:
|
|
* @bar: a #GtkHeaderBar
|
|
*
|
|
* Returns whether this header bar shows the standard window
|
|
* decorations.
|
|
*
|
|
* Returns: %TRUE if the decorations are shown
|
|
*
|
|
* Since: 3.10
|
|
*/
|
|
gboolean
|
|
gtk_header_bar_get_show_close_button (GtkHeaderBar *bar)
|
|
{
|
|
GtkHeaderBarPrivate *priv;
|
|
|
|
g_return_val_if_fail (GTK_IS_HEADER_BAR (bar), FALSE);
|
|
|
|
priv = gtk_header_bar_get_instance_private (bar);
|
|
|
|
return priv->shows_wm_decorations;
|
|
}
|
|
|
|
/**
|
|
* gtk_header_bar_set_show_close_button:
|
|
* @bar: a #GtkHeaderBar
|
|
* @setting: %TRUE to show standard widow decorations
|
|
*
|
|
* Sets whether this header bar shows the standard window decorations,
|
|
* including close, maximize, and minimize.
|
|
*
|
|
* Since: 3.10
|
|
*/
|
|
void
|
|
gtk_header_bar_set_show_close_button (GtkHeaderBar *bar,
|
|
gboolean setting)
|
|
{
|
|
GtkHeaderBarPrivate *priv;
|
|
|
|
g_return_if_fail (GTK_IS_HEADER_BAR (bar));
|
|
|
|
priv = gtk_header_bar_get_instance_private (bar);
|
|
|
|
setting = setting != FALSE;
|
|
|
|
if (priv->shows_wm_decorations == setting)
|
|
return;
|
|
|
|
priv->shows_wm_decorations = setting;
|
|
_gtk_header_bar_update_window_buttons (bar);
|
|
g_object_notify (G_OBJECT (bar), "show-close-button");
|
|
}
|
|
|
|
/**
|
|
* gtk_header_bar_set_has_subtitle:
|
|
* @bar: a #GtkHeaderBar
|
|
* @setting: %TRUE to reserve space for a subtitle
|
|
*
|
|
* Sets whether the header bar should reserve space
|
|
* for a subtitle, even if none is currently set.
|
|
*
|
|
* Since: 3.12
|
|
*/
|
|
void
|
|
gtk_header_bar_set_has_subtitle (GtkHeaderBar *bar,
|
|
gboolean setting)
|
|
{
|
|
GtkHeaderBarPrivate *priv;
|
|
|
|
g_return_if_fail (GTK_IS_HEADER_BAR (bar));
|
|
|
|
priv = gtk_header_bar_get_instance_private (bar);
|
|
|
|
setting = setting != FALSE;
|
|
|
|
if (priv->has_subtitle == setting)
|
|
return;
|
|
|
|
priv->has_subtitle = setting;
|
|
gtk_widget_set_visible (priv->subtitle_sizing_label, setting || (priv->subtitle && priv->subtitle[0]));
|
|
|
|
gtk_widget_queue_resize (GTK_WIDGET (bar));
|
|
|
|
g_object_notify (G_OBJECT (bar), "has-subtitle");
|
|
}
|
|
|
|
/**
|
|
* gtk_header_bar_get_has_subtitle:
|
|
* @bar: a #GtkHeaderBar
|
|
*
|
|
* Returns whether the header bar reserves space
|
|
* for a subtitle.
|
|
*
|
|
* Since: 3.12
|
|
*/
|
|
gboolean
|
|
gtk_header_bar_get_has_subtitle (GtkHeaderBar *bar)
|
|
{
|
|
GtkHeaderBarPrivate *priv;
|
|
|
|
g_return_val_if_fail (GTK_IS_HEADER_BAR (bar), FALSE);
|
|
|
|
priv = gtk_header_bar_get_instance_private (bar);
|
|
|
|
return priv->has_subtitle;
|
|
}
|