ctkheaderbar.c

Bug Summary

File:	ctk/ctkheaderbar.c
Warning:	line 1119, column 30 Access of the memory returned by 'alloca' at index 0, while it holds only 0 'struct _CtkRequestedSize' element
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ctkheaderbar.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/rootdir/ctk -fcoverage-compilation-dir=/rootdir/ctk -resource-dir /usr/lib/llvm-19/lib/clang/19 -D HAVE_CONFIG_H -I . -I .. -D G_LOG_DOMAIN="Ctk" -D G_LOG_USE_STRUCTURED=1 -D CTK_VERSION="3.25.6" -D CTK_BINARY_VERSION="3.0.0" -D CTK_COMPILATION -D CTK_PRINT_BACKEND_ENABLE_UNSUPPORTED -D CTK_LIBDIR="/usr/lib" -D CTK_LOCALEDIR="/usr/share/locale" -D CTK_DATADIR="/usr/share" -D CTK_DATA_PREFIX="/usr" -D CTK_SYSCONFDIR="/usr/etc" -D CTK_HOST="x86_64-pc-linux-gnu" -D CTK_PRINT_BACKENDS="file,cups" -D X11_DATA_PREFIX="/usr" -D ISO_CODES_PREFIX="" -I .. -I ../ctk -I .. -I ../cdk -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/sysprof-6 -D G_ENABLE_DEBUG -D G_ENABLE_CONSISTENCY_CHECKS -D GLIB_MIN_REQUIRED_VERSION=GLIB_VERSION_2_66 -D GLIB_MAX_ALLOWED_VERSION=GLIB_VERSION_2_66 -I /usr/include/pango-1.0 -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/sysprof-6 -I /usr/include/harfbuzz -I /usr/include/freetype2 -I /usr/include/libpng16 -I /usr/include/libmount -I /usr/include/blkid -I /usr/include/fribidi -I /usr/include/cairo -I /usr/include/pixman-1 -I /usr/include/atk-1.0 -I /usr/include/gdk-pixbuf-2.0 -I /usr/include/x86_64-linux-gnu -I /usr/include/webp -I /usr/include/at-spi2-atk/2.0 -I /usr/include/at-spi-2.0 -I /usr/include/dbus-1.0 -I /usr/lib/x86_64-linux-gnu/dbus-1.0/include -I /usr/include/gio-unix-2.0 -I /usr/include/harfbuzz -I /usr/include/freetype2 -I /usr/include/libpng16 -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/sysprof-6 -I /usr/include/pango-1.0 -I /usr/include/libmount -I /usr/include/blkid -I /usr/include/fribidi -I /usr/include/cairo -I /usr/include/pixman-1 -D PIC -internal-isystem /usr/lib/llvm-19/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/15/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -ferror-limit 19 -fvisibility=hidden -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -analyzer-checker deadcode.DeadStores -analyzer-checker alpha.security.ArrayBoundV2 -analyzer-checker alpha.unix.cstring.NotNullTerminated -analyzer-checker alpha.deadcode.UnreachableCode -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -analyzer-checker alpha.unix.cstring.OutOfBounds -analyzer-checker alpha.core.FixedAddr -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /rootdir/html-report/2025-12-18-102107-44033-1 -x c ctkheaderbar.c
1/*
* 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
*
*/

20#include "config.h"

22#include "ctkheaderbar.h"
23#include "ctkheaderbarprivate.h"
24#include "ctkintl.h"
25#include "ctkprivate.h"
26#include "ctktypebuiltins.h"
27#include "ctkwidgetprivate.h"
28#include "ctkcssnodeprivate.h"
29#include "ctkcsscustomgadgetprivate.h"
30#include "ctkwindowprivate.h"
31#include "ctkwidgetprivate.h"
32#include "ctkcontainerprivate.h"
33#include "a11y/ctkheaderbaraccessible.h"

35#include <string.h>

37/**
* SECTION:ctkheaderbar
* @Short_description: A box with a centered child
* @Title: CtkHeaderBar
* @See_also: #CtkBox, #CtkActionBar
*
* CtkHeaderBar is similar to a horizontal #CtkBox. It allows children to 
* be placed at the start or the end. In addition, it allows a title and
* subtitle 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. The height of the titlebar will be
* set to provide sufficient space for the subtitle, even if none is
* currently set. If a subtitle is not needed, the space reservation
* can be turned off with ctk_header_bar_set_has_subtitle().
*
* CtkHeaderBar can add typical window frame controls, such as minimize,
* maximize and close buttons, or the window icon.
*
* For these reasons, CtkHeaderBar is the natural choice for use as the custom
* titlebar widget of a #CtkWindow (see ctk_window_set_titlebar()), as it gives
* features typical of titlebars while allowing the addition of child widgets.
*/

60#define DEFAULT_SPACING6 6
61#define MIN_TITLE_CHARS5 5

63struct _CtkHeaderBarPrivate
64{
gchar *title;
gchar *subtitle;
CtkWidget *title_label;
CtkWidget *subtitle_label;
CtkWidget *label_box;
CtkWidget *label_sizing_box;
CtkWidget *subtitle_sizing_label;
CtkWidget *custom_title;
gint spacing;
gboolean has_subtitle;

GList *children;

gboolean shows_wm_decorations;
gchar *decoration_layout;
gboolean decoration_layout_set;

CtkWidget *titlebar_start_box;
CtkWidget *titlebar_end_box;

CtkWidget *titlebar_start_separator;
CtkWidget *titlebar_end_separator;

CtkWidget *titlebar_icon;

CtkCssGadget *gadget;
91};

93typedef struct _Child Child;
94struct _Child
95{
CtkWidget *widget;
CtkPackType pack_type;
98};

100enum {
PROP_0,
PROP_TITLE,
PROP_SUBTITLE,
PROP_HAS_SUBTITLE,
PROP_CUSTOM_TITLE,
PROP_SPACING,
PROP_SHOW_CLOSE_BUTTON,
PROP_DECORATION_LAYOUT,
PROP_DECORATION_LAYOUT_SET,
LAST_PROP
111};

113enum {
CHILD_PROP_0,
CHILD_PROP_PACK_TYPE,
CHILD_PROP_POSITION
117};

119static GParamSpec *header_bar_props[LAST_PROP] = { NULL((void*)0), };

121static void ctk_header_bar_buildable_init (CtkBuildableIface *iface);

123G_DEFINE_TYPE_WITH_CODE (CtkHeaderBar, ctk_header_bar, CTK_TYPE_CONTAINER,static void ctk_header_bar_init (CtkHeaderBar *self); static void
 ctk_header_bar_class_init (CtkHeaderBarClass *klass); static
 GType ctk_header_bar_get_type_once (void); static gpointer ctk_header_bar_parent_class
 = ((void*)0); static gint CtkHeaderBar_private_offset; static
 void ctk_header_bar_class_intern_init (gpointer klass) { ctk_header_bar_parent_class
 = g_type_class_peek_parent (klass); if (CtkHeaderBar_private_offset
 != 0) g_type_class_adjust_private_offset (klass, &CtkHeaderBar_private_offset
); ctk_header_bar_class_init ((CtkHeaderBarClass*) klass); } __attribute__
 ((__unused__)) static inline gpointer ctk_header_bar_get_instance_private
 (CtkHeaderBar *self) { return (((gpointer) ((guint8*) (self)
 + (glong) (CtkHeaderBar_private_offset)))); } GType ctk_header_bar_get_type
 (void) { static GType static_g_define_type_id = 0; if ((__extension__
 ({ _Static_assert (sizeof *(&static_g_define_type_id) ==
 sizeof (gpointer), "Expression evaluates to false"); (void) (
? (gpointer) * (&static_g_define_type_id) : ((void*)0))
; (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
 ((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter_pointer (
&static_g_define_type_id)); })) ) { GType g_define_type_id
 = ctk_header_bar_get_type_once (); (__extension__ ({ _Static_assert
 (sizeof *(&static_g_define_type_id) == sizeof (gpointer)
, "Expression evaluates to false"); 0 ? (void) (*(&static_g_define_type_id
) = (g_define_type_id)) : (void) 0; g_once_init_leave_pointer
 ((&static_g_define_type_id), (gpointer) (guintptr) (g_define_type_id
)); })) ; } return static_g_define_type_id; } __attribute__ (
(__noinline__)) static GType ctk_header_bar_get_type_once (void
) { GType g_define_type_id = g_type_register_static_simple ((
ctk_container_get_type ()), g_intern_static_string ("CtkHeaderBar"
), sizeof (CtkHeaderBarClass), (GClassInitFunc)(void (*)(void
)) ctk_header_bar_class_intern_init, sizeof (CtkHeaderBar), (
GInstanceInitFunc)(void (*)(void)) ctk_header_bar_init, (GTypeFlags
) 0); { {{ CtkHeaderBar_private_offset = g_type_add_instance_private
 (g_define_type_id, sizeof (CtkHeaderBarPrivate)); } { const GInterfaceInfo
 g_implement_interface_info = { (GInterfaceInitFunc)(void (*)
(void)) ctk_header_bar_buildable_init, ((void*)0), ((void*)0)
 }; g_type_add_interface_static (g_define_type_id, (ctk_buildable_get_type
 ()), &g_implement_interface_info); };} } return g_define_type_id
; }
                       G_ADD_PRIVATE (CtkHeaderBar)static void ctk_header_bar_init (CtkHeaderBar *self); static void
 ctk_header_bar_class_init (CtkHeaderBarClass *klass); static
 GType ctk_header_bar_get_type_once (void); static gpointer ctk_header_bar_parent_class
 = ((void*)0); static gint CtkHeaderBar_private_offset; static
 void ctk_header_bar_class_intern_init (gpointer klass) { ctk_header_bar_parent_class
 = g_type_class_peek_parent (klass); if (CtkHeaderBar_private_offset
 != 0) g_type_class_adjust_private_offset (klass, &CtkHeaderBar_private_offset
); ctk_header_bar_class_init ((CtkHeaderBarClass*) klass); } __attribute__
 ((__unused__)) static inline gpointer ctk_header_bar_get_instance_private
 (CtkHeaderBar *self) { return (((gpointer) ((guint8*) (self)
 + (glong) (CtkHeaderBar_private_offset)))); } GType ctk_header_bar_get_type
 (void) { static GType static_g_define_type_id = 0; if ((__extension__
 ({ _Static_assert (sizeof *(&static_g_define_type_id) ==
 sizeof (gpointer), "Expression evaluates to false"); (void) (
? (gpointer) * (&static_g_define_type_id) : ((void*)0))
; (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
 ((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter_pointer (
&static_g_define_type_id)); })) ) { GType g_define_type_id
 = ctk_header_bar_get_type_once (); (__extension__ ({ _Static_assert
 (sizeof *(&static_g_define_type_id) == sizeof (gpointer)
, "Expression evaluates to false"); 0 ? (void) (*(&static_g_define_type_id
) = (g_define_type_id)) : (void) 0; g_once_init_leave_pointer
 ((&static_g_define_type_id), (gpointer) (guintptr) (g_define_type_id
)); })) ; } return static_g_define_type_id; } __attribute__ (
(__noinline__)) static GType ctk_header_bar_get_type_once (void
) { GType g_define_type_id = g_type_register_static_simple ((
ctk_container_get_type ()), g_intern_static_string ("CtkHeaderBar"
), sizeof (CtkHeaderBarClass), (GClassInitFunc)(void (*)(void
)) ctk_header_bar_class_intern_init, sizeof (CtkHeaderBar), (
GInstanceInitFunc)(void (*)(void)) ctk_header_bar_init, (GTypeFlags
) 0); { {{ CtkHeaderBar_private_offset = g_type_add_instance_private
 (g_define_type_id, sizeof (CtkHeaderBarPrivate)); } { const GInterfaceInfo
 g_implement_interface_info = { (GInterfaceInitFunc)(void (*)
(void)) ctk_header_bar_buildable_init, ((void*)0), ((void*)0)
 }; g_type_add_interface_static (g_define_type_id, (ctk_buildable_get_type
 ()), &g_implement_interface_info); };} } return g_define_type_id
; }
                       G_IMPLEMENT_INTERFACE (CTK_TYPE_BUILDABLE,static void ctk_header_bar_init (CtkHeaderBar *self); static void
 ctk_header_bar_class_init (CtkHeaderBarClass *klass); static
 GType ctk_header_bar_get_type_once (void); static gpointer ctk_header_bar_parent_class
 = ((void*)0); static gint CtkHeaderBar_private_offset; static
 void ctk_header_bar_class_intern_init (gpointer klass) { ctk_header_bar_parent_class
 = g_type_class_peek_parent (klass); if (CtkHeaderBar_private_offset
 != 0) g_type_class_adjust_private_offset (klass, &CtkHeaderBar_private_offset
); ctk_header_bar_class_init ((CtkHeaderBarClass*) klass); } __attribute__
 ((__unused__)) static inline gpointer ctk_header_bar_get_instance_private
 (CtkHeaderBar *self) { return (((gpointer) ((guint8*) (self)
 + (glong) (CtkHeaderBar_private_offset)))); } GType ctk_header_bar_get_type
 (void) { static GType static_g_define_type_id = 0; if ((__extension__
 ({ _Static_assert (sizeof *(&static_g_define_type_id) ==
 sizeof (gpointer), "Expression evaluates to false"); (void) (
? (gpointer) * (&static_g_define_type_id) : ((void*)0))
; (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
 ((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter_pointer (
&static_g_define_type_id)); })) ) { GType g_define_type_id
 = ctk_header_bar_get_type_once (); (__extension__ ({ _Static_assert
 (sizeof *(&static_g_define_type_id) == sizeof (gpointer)
, "Expression evaluates to false"); 0 ? (void) (*(&static_g_define_type_id
) = (g_define_type_id)) : (void) 0; g_once_init_leave_pointer
 ((&static_g_define_type_id), (gpointer) (guintptr) (g_define_type_id
)); })) ; } return static_g_define_type_id; } __attribute__ (
(__noinline__)) static GType ctk_header_bar_get_type_once (void
) { GType g_define_type_id = g_type_register_static_simple ((
ctk_container_get_type ()), g_intern_static_string ("CtkHeaderBar"
), sizeof (CtkHeaderBarClass), (GClassInitFunc)(void (*)(void
)) ctk_header_bar_class_intern_init, sizeof (CtkHeaderBar), (
GInstanceInitFunc)(void (*)(void)) ctk_header_bar_init, (GTypeFlags
) 0); { {{ CtkHeaderBar_private_offset = g_type_add_instance_private
 (g_define_type_id, sizeof (CtkHeaderBarPrivate)); } { const GInterfaceInfo
 g_implement_interface_info = { (GInterfaceInitFunc)(void (*)
(void)) ctk_header_bar_buildable_init, ((void*)0), ((void*)0)
 }; g_type_add_interface_static (g_define_type_id, (ctk_buildable_get_type
 ()), &g_implement_interface_info); };} } return g_define_type_id
; }
                                              ctk_header_bar_buildable_init))static void ctk_header_bar_init (CtkHeaderBar *self); static void
 ctk_header_bar_class_init (CtkHeaderBarClass *klass); static
 GType ctk_header_bar_get_type_once (void); static gpointer ctk_header_bar_parent_class
 = ((void*)0); static gint CtkHeaderBar_private_offset; static
 void ctk_header_bar_class_intern_init (gpointer klass) { ctk_header_bar_parent_class
 = g_type_class_peek_parent (klass); if (CtkHeaderBar_private_offset
 != 0) g_type_class_adjust_private_offset (klass, &CtkHeaderBar_private_offset
); ctk_header_bar_class_init ((CtkHeaderBarClass*) klass); } __attribute__
 ((__unused__)) static inline gpointer ctk_header_bar_get_instance_private
 (CtkHeaderBar *self) { return (((gpointer) ((guint8*) (self)
 + (glong) (CtkHeaderBar_private_offset)))); } GType ctk_header_bar_get_type
 (void) { static GType static_g_define_type_id = 0; if ((__extension__
 ({ _Static_assert (sizeof *(&static_g_define_type_id) ==
 sizeof (gpointer), "Expression evaluates to false"); (void) (
? (gpointer) * (&static_g_define_type_id) : ((void*)0))
; (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
 ((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter_pointer (
&static_g_define_type_id)); })) ) { GType g_define_type_id
 = ctk_header_bar_get_type_once (); (__extension__ ({ _Static_assert
 (sizeof *(&static_g_define_type_id) == sizeof (gpointer)
, "Expression evaluates to false"); 0 ? (void) (*(&static_g_define_type_id
) = (g_define_type_id)) : (void) 0; g_once_init_leave_pointer
 ((&static_g_define_type_id), (gpointer) (guintptr) (g_define_type_id
)); })) ; } return static_g_define_type_id; } __attribute__ (
(__noinline__)) static GType ctk_header_bar_get_type_once (void
) { GType g_define_type_id = g_type_register_static_simple ((
ctk_container_get_type ()), g_intern_static_string ("CtkHeaderBar"
), sizeof (CtkHeaderBarClass), (GClassInitFunc)(void (*)(void
)) ctk_header_bar_class_intern_init, sizeof (CtkHeaderBar), (
GInstanceInitFunc)(void (*)(void)) ctk_header_bar_init, (GTypeFlags
) 0); { {{ CtkHeaderBar_private_offset = g_type_add_instance_private
 (g_define_type_id, sizeof (CtkHeaderBarPrivate)); } { const GInterfaceInfo
 g_implement_interface_info = { (GInterfaceInitFunc)(void (*)
(void)) ctk_header_bar_buildable_init, ((void*)0), ((void*)0)
 }; g_type_add_interface_static (g_define_type_id, (ctk_buildable_get_type
 ()), &g_implement_interface_info); };} } return g_define_type_id
; };

128static void
129init_sizing_box (CtkHeaderBar *bar)
130{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);
CtkWidget *w;
CtkStyleContext *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.
 */
w = ctk_box_new (CTK_ORIENTATION_VERTICAL, 0);
ctk_widget_show (w);
priv->label_sizing_box = g_object_ref_sink (w)((__typeof__ (w)) (g_object_ref_sink) (w));

w = ctk_label_new (NULL((void*)0));
ctk_widget_show (w);
context = ctk_widget_get_style_context (w);
ctk_style_context_add_class (context, CTK_STYLE_CLASS_TITLE"title");
ctk_box_pack_start (CTK_BOX (priv->label_sizing_box)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((priv->label_sizing_box)), ((ctk_box_get_type ())))))), w, FALSE(0), FALSE(0), 0);
ctk_label_set_line_wrap (CTK_LABEL (w)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((w)), ((ctk_label_get_type ())))))), FALSE(0));
ctk_label_set_single_line_mode (CTK_LABEL (w)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((w)), ((ctk_label_get_type ())))))), TRUE(!(0)));
ctk_label_set_ellipsize (CTK_LABEL (w)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((w)), ((ctk_label_get_type ())))))), PANGO_ELLIPSIZE_END);
ctk_label_set_width_chars (CTK_LABEL (w)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((w)), ((ctk_label_get_type ())))))), MIN_TITLE_CHARS5);

w = ctk_label_new (NULL((void*)0));
context = ctk_widget_get_style_context (w);
ctk_style_context_add_class (context, CTK_STYLE_CLASS_SUBTITLE"subtitle");
ctk_box_pack_start (CTK_BOX (priv->label_sizing_box)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((priv->label_sizing_box)), ((ctk_box_get_type ())))))), w, FALSE(0), FALSE(0), 0);
ctk_label_set_line_wrap (CTK_LABEL (w)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((w)), ((ctk_label_get_type ())))))), FALSE(0));
ctk_label_set_single_line_mode (CTK_LABEL (w)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((w)), ((ctk_label_get_type ())))))), TRUE(!(0)));
ctk_label_set_ellipsize (CTK_LABEL (w)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((w)), ((ctk_label_get_type ())))))), PANGO_ELLIPSIZE_END);
ctk_widget_set_visible (w, priv->has_subtitle || (priv->subtitle && priv->subtitle[0]));
priv->subtitle_sizing_label = w;
163}

165static CtkWidget *
166create_title_box (const char *title,
                const char *subtitle,
                CtkWidget **ret_title_label,
                CtkWidget **ret_subtitle_label)
170{
CtkWidget *label_box;
CtkWidget *title_label;
CtkWidget *subtitle_label;
CtkStyleContext *context;

label_box = ctk_box_new (CTK_ORIENTATION_VERTICAL, 0);
ctk_widget_set_valign (label_box, CTK_ALIGN_CENTER);
ctk_widget_show (label_box);

title_label = ctk_label_new (title);
context = ctk_widget_get_style_context (title_label);
ctk_style_context_add_class (context, CTK_STYLE_CLASS_TITLE"title");
ctk_label_set_line_wrap (CTK_LABEL (title_label)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((title_label)), ((ctk_label_get_type ())))))), FALSE(0));
ctk_label_set_single_line_mode (CTK_LABEL (title_label)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((title_label)), ((ctk_label_get_type ())))))), TRUE(!(0)));
ctk_label_set_ellipsize (CTK_LABEL (title_label)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((title_label)), ((ctk_label_get_type ())))))), PANGO_ELLIPSIZE_END);
ctk_box_pack_start (CTK_BOX (label_box)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label_box)), ((ctk_box_get_type ())))))), title_label, FALSE(0), FALSE(0), 0);
ctk_widget_show (title_label);
ctk_label_set_width_chars (CTK_LABEL (title_label)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((title_label)), ((ctk_label_get_type ())))))), MIN_TITLE_CHARS5);

subtitle_label = ctk_label_new (subtitle);
context = ctk_widget_get_style_context (subtitle_label);
ctk_style_context_add_class (context, CTK_STYLE_CLASS_SUBTITLE"subtitle");
ctk_label_set_line_wrap (CTK_LABEL (subtitle_label)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((subtitle_label)), ((ctk_label_get_type ())))))), FALSE(0));
ctk_label_set_single_line_mode (CTK_LABEL (subtitle_label)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((subtitle_label)), ((ctk_label_get_type ())))))), TRUE(!(0)));
ctk_label_set_ellipsize (CTK_LABEL (subtitle_label)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((subtitle_label)), ((ctk_label_get_type ())))))), PANGO_ELLIPSIZE_END);
ctk_box_pack_start (CTK_BOX (label_box)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((label_box)), ((ctk_box_get_type ())))))), subtitle_label, FALSE(0), FALSE(0), 0);
ctk_widget_set_no_show_all (subtitle_label, TRUE(!(0)));
ctk_widget_set_visible (subtitle_label, subtitle && subtitle[0]);

if (ret_title_label)
  *ret_title_label = title_label;
if (ret_subtitle_label)
  *ret_subtitle_label = subtitle_label;

return label_box;
206}

208gboolean
209_ctk_header_bar_update_window_icon (CtkHeaderBar *bar,
                                  CtkWindow    *window)
211{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);
GdkPixbuf *pixbuf;
gint scale;

if (priv->titlebar_icon == NULL((void*)0))
  return FALSE(0);

scale = ctk_widget_get_scale_factor (priv->titlebar_icon);
if (CTK_IS_BUTTON (ctk_widget_get_parent (priv->titlebar_icon))(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) (
(ctk_widget_get_parent (priv->titlebar_icon))); GType __t =
 ((ctk_button_get_type ())); gboolean __r; if (!__inst) __r =
 (0); else if (__inst->g_class && __inst->g_class
->g_type == __t) __r = (!(0)); else __r = g_type_check_instance_is_a
 (__inst, __t); __r; })))))
  pixbuf = ctk_window_get_icon_for_size (window, scale * 16);
else
  pixbuf = ctk_window_get_icon_for_size (window, scale * 20);

if (pixbuf)
  {
    cairo_surface_t *surface;

    surface = cdk_cairo_surface_create_from_pixbuf (pixbuf, scale, ctk_widget_get_window (priv->titlebar_icon));

    ctk_image_set_from_surface (CTK_IMAGE (priv->titlebar_icon)((((CtkImage*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((priv->titlebar_icon)), ((ctk_image_get_type ())))))), surface);
    cairo_surface_destroy (surface);
    g_object_unref (pixbuf);
    ctk_widget_show (priv->titlebar_icon);

    return TRUE(!(0));
  }

return FALSE(0);
240}

242static void
243_ctk_header_bar_update_separator_visibility (CtkHeaderBar *bar)
244{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);
gboolean have_visible_at_start = FALSE(0);
gboolean have_visible_at_end = FALSE(0);
GList *l;

for (l = priv->children; l != NULL((void*)0); l = l->next)
  {
    Child *child = l->data;

    if (ctk_widget_get_visible (child->widget))
      {
        if (child->pack_type == CTK_PACK_START)
          have_visible_at_start = TRUE(!(0));
        else
          have_visible_at_end = TRUE(!(0));
      }
  }

if (priv->titlebar_start_separator != NULL((void*)0))
  ctk_widget_set_visible (priv->titlebar_start_separator, have_visible_at_start);

if (priv->titlebar_end_separator != NULL((void*)0))
  ctk_widget_set_visible (priv->titlebar_end_separator, have_visible_at_end);
268}

270void
271_ctk_header_bar_update_window_buttons (CtkHeaderBar *bar)
272{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);
CtkWidget *widget = CTK_WIDGET (bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), ((ctk_widget_get_type ())))))), *toplevel;
CtkWindow *window;
CtkTextDirection direction;
gchar *layout_desc;
gchar **tokens, **t;
gint i, j;
GMenuModel *menu;
gboolean shown_by_shell;
gboolean is_sovereign_window;

toplevel = ctk_widget_get_toplevel (widget);
if (!ctk_widget_is_toplevel (toplevel))
  return;

if (priv->titlebar_start_box)
  {
    ctk_widget_unparent (priv->titlebar_start_box);
    priv->titlebar_start_box = NULL((void*)0);
    priv->titlebar_start_separator = NULL((void*)0);
  }
if (priv->titlebar_end_box)
  {
    ctk_widget_unparent (priv->titlebar_end_box);
    priv->titlebar_end_box = NULL((void*)0);
    priv->titlebar_end_separator = NULL((void*)0);
  }

priv->titlebar_icon = NULL((void*)0);

if (!priv->shows_wm_decorations)
  return;

direction = ctk_widget_get_direction (widget);

g_object_get (ctk_widget_get_settings (widget),
              "ctk-shell-shows-app-menu", &shown_by_shell,
              "ctk-decoration-layout", &layout_desc,
              NULL((void*)0));

if (priv->decoration_layout_set)
  {
    g_free (layout_desc);
    layout_desc = g_strdup (priv->decoration_layout)g_strdup_inline (priv->decoration_layout);
  }

window = CTK_WINDOW (toplevel)((((CtkWindow*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((toplevel)), ((ctk_window_get_type ()))))));

if (!shown_by_shell && ctk_window_get_application (window))
  menu = ctk_application_get_app_menu (ctk_window_get_application (window));
else
  menu = NULL((void*)0);

is_sovereign_window = (!ctk_window_get_modal (window) &&
                        ctk_window_get_transient_for (window) == NULL((void*)0) &&
                        ctk_window_get_type_hint (window) == CDK_WINDOW_TYPE_HINT_NORMAL);

tokens = g_strsplit (layout_desc, ":", 2);
if (tokens)
  {
    for (i = 0; i < 2; i++)
      {
        CtkWidget *box;
        CtkWidget *separator;
        int n_children = 0;

        if (tokens[i] == NULL((void*)0))
          break;

        t = g_strsplit (tokens[i], ",", -1);

        separator = ctk_separator_new (CTK_ORIENTATION_VERTICAL);
        ctk_widget_set_no_show_all (separator, TRUE(!(0)));
        ctk_style_context_add_class (ctk_widget_get_style_context (separator), "titlebutton");

        box = ctk_box_new (CTK_ORIENTATION_HORIZONTAL, priv->spacing);

        for (j = 0; t[j]; j++)
          {
            CtkWidget *button = NULL((void*)0);
            CtkWidget *image = NULL((void*)0);
            AtkObject *accessible;

            if (strcmp (t[j], "icon") == 0 &&
                is_sovereign_window)
              {
                button = ctk_image_new ();
                ctk_widget_set_valign (button, CTK_ALIGN_CENTER);
                priv->titlebar_icon = button;
                ctk_style_context_add_class (ctk_widget_get_style_context (button), "titlebutton");
                ctk_style_context_add_class (ctk_widget_get_style_context (button), "icon");
                ctk_widget_set_size_request (button, 20, 20);
                ctk_widget_show (button);

                if (!_ctk_header_bar_update_window_icon (bar, window))
                  {
                    ctk_widget_destroy (button);
                    priv->titlebar_icon = NULL((void*)0);
                    button = NULL((void*)0);
                  }
              }
            else if (strcmp (t[j], "menu") == 0 &&
                     menu != NULL((void*)0) &&
                     is_sovereign_window)
              {
                button = ctk_menu_button_new ();
                ctk_widget_set_valign (button, CTK_ALIGN_CENTER);
                ctk_menu_button_set_menu_model (CTK_MENU_BUTTON (button)((((CtkMenuButton*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button)), ((ctk_menu_button_get_type ())))))), menu);
                ctk_menu_button_set_use_popover (CTK_MENU_BUTTON (button)((((CtkMenuButton*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button)), ((ctk_menu_button_get_type ())))))), TRUE(!(0)));
                ctk_style_context_add_class (ctk_widget_get_style_context (button), "titlebutton");
                ctk_style_context_add_class (ctk_widget_get_style_context (button), "appmenu");
                image = ctk_image_new ();
                ctk_container_add (CTK_CONTAINER (button)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button)), ((ctk_container_get_type ())))))), image);
                ctk_widget_set_can_focus (button, FALSE(0));
                ctk_widget_show_all (button);

                accessible = ctk_widget_get_accessible (button);
                if (CTK_IS_ACCESSIBLE (accessible)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) (
(accessible)); GType __t = ((ctk_accessible_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))
                  atk_object_set_name (accessible, _("Application menu")((char *) g_dgettext ("ctk30", "Application menu")));

                priv->titlebar_icon = image;
                if (!_ctk_header_bar_update_window_icon (bar, window))
                  ctk_image_set_from_icon_name (CTK_IMAGE (priv->titlebar_icon)((((CtkImage*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((priv->titlebar_icon)), ((ctk_image_get_type ())))))),
                                                "application-x-executable-symbolic", CTK_ICON_SIZE_MENU);
              }
            else if (strcmp (t[j], "minimize") == 0 &&
                     is_sovereign_window)
              {
                button = ctk_button_new ();
                ctk_widget_set_valign (button, CTK_ALIGN_CENTER);
                ctk_style_context_add_class (ctk_widget_get_style_context (button), "titlebutton");
                ctk_style_context_add_class (ctk_widget_get_style_context (button), "minimize");
                image = ctk_image_new_from_icon_name ("window-minimize-symbolic", CTK_ICON_SIZE_MENU);
                g_object_set (image, "use-fallback", TRUE(!(0)), NULL((void*)0));
                ctk_container_add (CTK_CONTAINER (button)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button)), ((ctk_container_get_type ())))))), image);
                ctk_widget_set_can_focus (button, FALSE(0));
                ctk_widget_show_all (button);
                g_signal_connect_swapped (button, "clicked",g_signal_connect_data ((button), ("clicked"), (((GCallback) (
ctk_window_iconify))), (window), ((void*)0), G_CONNECT_SWAPPED
)
                                          G_CALLBACK (ctk_window_iconify), window)g_signal_connect_data ((button), ("clicked"), (((GCallback) (
ctk_window_iconify))), (window), ((void*)0), G_CONNECT_SWAPPED
);

                accessible = ctk_widget_get_accessible (button);
                if (CTK_IS_ACCESSIBLE (accessible)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) (
(accessible)); GType __t = ((ctk_accessible_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))
                  atk_object_set_name (accessible, _("Minimize")((char *) g_dgettext ("ctk30", "Minimize")));
              }
            else if (strcmp (t[j], "maximize") == 0 &&
                     ctk_window_get_resizable (window) &&
                     is_sovereign_window)
              {
                const gchar *icon_name;
                gboolean maximized = ctk_window_is_maximized (window);

                icon_name = maximized ? "window-restore-symbolic" : "window-maximize-symbolic";
                button = ctk_button_new ();
                ctk_widget_set_valign (button, CTK_ALIGN_CENTER);
                ctk_style_context_add_class (ctk_widget_get_style_context (button), "titlebutton");
                ctk_style_context_add_class (ctk_widget_get_style_context (button), "maximize");
                image = ctk_image_new_from_icon_name (icon_name, CTK_ICON_SIZE_MENU);
                g_object_set (image, "use-fallback", TRUE(!(0)), NULL((void*)0));
                ctk_container_add (CTK_CONTAINER (button)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button)), ((ctk_container_get_type ())))))), image);
                ctk_widget_set_can_focus (button, FALSE(0));
                ctk_widget_show_all (button);
                g_signal_connect_swapped (button, "clicked",g_signal_connect_data ((button), ("clicked"), (((GCallback) (
_ctk_window_toggle_maximized))), (window), ((void*)0), G_CONNECT_SWAPPED
)
                                          G_CALLBACK (_ctk_window_toggle_maximized), window)g_signal_connect_data ((button), ("clicked"), (((GCallback) (
_ctk_window_toggle_maximized))), (window), ((void*)0), G_CONNECT_SWAPPED
);

                accessible = ctk_widget_get_accessible (button);
                if (CTK_IS_ACCESSIBLE (accessible)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) (
(accessible)); GType __t = ((ctk_accessible_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))
                  atk_object_set_name (accessible, maximized ? _("Restore")((char *) g_dgettext ("ctk30", "Restore")) : _("Maximize")((char *) g_dgettext ("ctk30", "Maximize")));
              }
            else if (strcmp (t[j], "close") == 0 &&
                     ctk_window_get_deletable (window))
              {
                button = ctk_button_new ();
                ctk_widget_set_valign (button, CTK_ALIGN_CENTER);
                image = ctk_image_new_from_icon_name ("window-close-symbolic", CTK_ICON_SIZE_MENU);
                ctk_style_context_add_class (ctk_widget_get_style_context (button), "titlebutton");
                ctk_style_context_add_class (ctk_widget_get_style_context (button), "close");
                g_object_set (image, "use-fallback", TRUE(!(0)), NULL((void*)0));
                ctk_container_add (CTK_CONTAINER (button)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((button)), ((ctk_container_get_type ())))))), image);
                ctk_widget_set_can_focus (button, FALSE(0));
                ctk_widget_show_all (button);
                g_signal_connect_swapped (button, "clicked",g_signal_connect_data ((button), ("clicked"), (((GCallback) (
ctk_window_close))), (window), ((void*)0), G_CONNECT_SWAPPED)
                                          G_CALLBACK (ctk_window_close), window)g_signal_connect_data ((button), ("clicked"), (((GCallback) (
ctk_window_close))), (window), ((void*)0), G_CONNECT_SWAPPED);

                accessible = ctk_widget_get_accessible (button);
                if (CTK_IS_ACCESSIBLE (accessible)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) (
(accessible)); GType __t = ((ctk_accessible_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))
                  atk_object_set_name (accessible, _("Close")((char *) g_dgettext ("ctk30", "Close")));
              }

            if (button)
              {
                ctk_box_pack_start (CTK_BOX (box)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_box_get_type ())))))), button, FALSE(0), FALSE(0), 0);
                n_children ++;
              }
          }
        g_strfreev (t);

        if (n_children == 0)
          {
            g_object_ref_sink (box)((__typeof__ (box)) (g_object_ref_sink) (box));
            g_object_unref (box);
            g_object_ref_sink (separator)((__typeof__ (separator)) (g_object_ref_sink) (separator));
            g_object_unref (separator);
            continue;
          }

        ctk_box_pack_start (CTK_BOX (box)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_box_get_type ())))))), separator, FALSE(0), FALSE(0), 0);
        if (i == 1)
          ctk_box_reorder_child (CTK_BOX (box)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_box_get_type ())))))), separator, 0);

        if ((direction == CTK_TEXT_DIR_LTR && i == 0) ||
            (direction == CTK_TEXT_DIR_RTL && i == 1))
          {
            ctk_style_context_add_class (ctk_widget_get_style_context (box), CTK_STYLE_CLASS_LEFT"left");
            ctk_css_node_insert_after (ctk_widget_get_css_node (CTK_WIDGET (bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), ((ctk_widget_get_type ()))))))),
                                       ctk_widget_get_css_node (box),
                                       NULL((void*)0));
          }
        else
          {
            ctk_style_context_add_class (ctk_widget_get_style_context (box), CTK_STYLE_CLASS_RIGHT"right");
            ctk_css_node_insert_before (ctk_widget_get_css_node (CTK_WIDGET (bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), ((ctk_widget_get_type ()))))))),
                                        ctk_widget_get_css_node (box),
                                        NULL((void*)0));
          }

        ctk_widget_show (box);
        ctk_widget_set_parent (box, CTK_WIDGET (bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), ((ctk_widget_get_type ())))))));

        if (i == 0)
          {
            priv->titlebar_start_box = box;
            priv->titlebar_start_separator = separator;
          }
        else
          {
            priv->titlebar_end_box = box;
            priv->titlebar_end_separator = separator;
          }
      }
    g_strfreev (tokens);
  }
g_free (layout_desc);

_ctk_header_bar_update_separator_visibility (bar);
517}

519gboolean
520_ctk_header_bar_shows_app_menu (CtkHeaderBar *bar)
521{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);
CtkWindow *window;
gchar *layout_desc;
gboolean ret;

window = CTK_WINDOW (ctk_widget_get_toplevel (CTK_WIDGET (bar)))((((CtkWindow*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((ctk_widget_get_toplevel (((((CtkWidget*) (void *) g_type_check_instance_cast
 ((GTypeInstance*) ((bar)), ((ctk_widget_get_type ())))))))))
, ((ctk_window_get_type ()))))));
ctk_widget_style_get (CTK_WIDGET (window)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((window)), ((ctk_widget_get_type ())))))),
                      "decoration-button-layout", &layout_desc,
                      NULL((void*)0));

ret = priv->shows_wm_decorations &&
      (layout_desc && strstr (layout_desc, "menu"));

g_free (layout_desc);

return ret;
538}

540/* As an intended side effect, this function allows @child
* to be the title/label box */
542static void
543ctk_header_bar_reorder_css_node (CtkHeaderBar *bar,
                               CtkPackType   pack_type,
                               CtkWidget    *widget)
546{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);
CtkWidget *previous_widget;
GList *l;

if (pack_type == CTK_PACK_START)
  previous_widget = priv->titlebar_start_box;
else
  previous_widget = priv->titlebar_end_box;

for (l = priv->children; l; l = l->next)
  {
    Child *iter = l->data;

    if (iter->widget == widget)
      break;

    if (iter->pack_type == pack_type)
      previous_widget = iter->widget;
  }

if ((pack_type == CTK_PACK_START)
    ^ (ctk_widget_get_direction (CTK_WIDGET (bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), ((ctk_widget_get_type ()))))))) == CTK_TEXT_DIR_LTR))
  ctk_css_node_insert_after (ctk_widget_get_css_node (CTK_WIDGET (bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), ((ctk_widget_get_type ()))))))),
                             ctk_widget_get_css_node (widget),
                             previous_widget ? ctk_widget_get_css_node (previous_widget) : NULL((void*)0));
else
  ctk_css_node_insert_before (ctk_widget_get_css_node (CTK_WIDGET (bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), ((ctk_widget_get_type ()))))))),
                              ctk_widget_get_css_node (widget),
                              previous_widget ? ctk_widget_get_css_node (previous_widget) : NULL((void*)0));
576}

578static void
579construct_label_box (CtkHeaderBar *bar)
580{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);

g_assert (priv->label_box == NULL)do { if (priv->label_box == ((void*)0)) ; else g_assertion_message_expr
 ("Ctk", "ctkheaderbar.c", 583, ((const char*) (__func__)), "priv->label_box == NULL"
); } while (0);

priv->label_box = create_title_box (priv->title,
                                    priv->subtitle,
                                    &priv->title_label,
                                    &priv->subtitle_label);
ctk_header_bar_reorder_css_node (bar, CTK_PACK_START, priv->label_box);
ctk_widget_set_parent (priv->label_box, CTK_WIDGET (bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), ((ctk_widget_get_type ())))))));
591}

593static gint
594count_visible_children (CtkHeaderBar *bar)
595{
CtkHeaderBarPrivate *priv = ctk_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 (ctk_widget_get_visible (child->widget))
      n++;
  }

return n;
610}

612static gboolean
613add_child_size (CtkWidget      *child,
              CtkOrientation  orientation,
              gint           *minimum,
              gint           *natural)
617{
gint child_minimum, child_natural;

if (!ctk_widget_get_visible (child))
  return FALSE(0);

if (orientation == CTK_ORIENTATION_HORIZONTAL)
  ctk_widget_get_preferred_width (child, &child_minimum, &child_natural);
else
  ctk_widget_get_preferred_height (child, &child_minimum, &child_natural);

if (CTK_ORIENTATION_HORIZONTAL == orientation)
  {
    *minimum += child_minimum;
    *natural += child_natural;
  }
else
  {
    *minimum = MAX (*minimum, child_minimum)(((*minimum) > (child_minimum)) ? (*minimum) : (child_minimum
));
    *natural = MAX (*natural, child_natural)(((*natural) > (child_natural)) ? (*natural) : (child_natural
));
  }

return TRUE(!(0));
640}

642static void
643ctk_header_bar_get_size (CtkWidget      *widget,
                       CtkOrientation  orientation,
                       gint           *minimum_size,
                       gint           *natural_size)
647{
CtkHeaderBar *bar = CTK_HEADER_BAR (widget)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_header_bar_get_type ()))))));
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);
GList *l;
gint nvis_children;
gint minimum, natural;
gint center_min, center_nat;

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;
  }

center_min = center_nat = 0;
if (priv->label_box != NULL((void*)0))
  {
    if (orientation == CTK_ORIENTATION_HORIZONTAL)
      add_child_size (priv->label_box, orientation, &center_min, &center_nat);
    else
      add_child_size (priv->label_sizing_box, orientation, &center_min, &center_nat);

    if (_ctk_widget_get_visible (priv->label_sizing_box))
      nvis_children += 1;
  }

if (priv->custom_title != NULL((void*)0))
  {
    if (add_child_size (priv->custom_title, orientation, &center_min, &center_nat))
      nvis_children += 1;
  }

if (priv->titlebar_start_box != NULL((void*)0))
  {
    if (add_child_size (priv->titlebar_start_box, orientation, &minimum, &natural))
      nvis_children += 1;
  }

if (priv->titlebar_end_box != NULL((void*)0))
  {
    if (add_child_size (priv->titlebar_end_box, orientation, &minimum, &natural))
      nvis_children += 1;
  }

if (orientation == CTK_ORIENTATION_HORIZONTAL)
  {
    minimum += center_min;
    natural += center_nat;
  }
else
  {
    minimum = MAX (minimum, center_min)(((minimum) > (center_min)) ? (minimum) : (center_min));
    natural = MAX (natural, center_nat)(((natural) > (center_nat)) ? (natural) : (center_nat));
  }

if (nvis_children > 0 && orientation == CTK_ORIENTATION_HORIZONTAL)
  {
    minimum += nvis_children * priv->spacing;
    natural += nvis_children * priv->spacing;
  }

*minimum_size = minimum;
*natural_size = natural;
715}

717static void
718ctk_header_bar_compute_size_for_orientation (CtkWidget *widget,
                                           gint       avail_size,
                                           gint      *minimum_size,
                                           gint      *natural_size)
722{
CtkHeaderBar *bar = CTK_HEADER_BAR (widget)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_header_bar_get_type ()))))));
CtkHeaderBarPrivate *priv = ctk_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;

nvis_children = 0;

for (children = priv->children; children != NULL((void*)0); children = children->next)
  {
    Child *child = children->data;

    if (ctk_widget_get_visible (child->widget))
      {
        ctk_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((void*)0))
  {
    ctk_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((void*)0) &&
    ctk_widget_get_visible (priv->custom_title))
  {
    ctk_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((void*)0))
  {
    ctk_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((void*)0))
  {
    ctk_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;
  }

*minimum_size = required_size;
*natural_size = required_natural;
793}

795static void
796ctk_header_bar_compute_size_for_opposing_orientation (CtkWidget *widget,
                                                    gint       avail_size,
                                                    gint      *minimum_size,
                                                    gint      *natural_size)
800{
CtkHeaderBar *bar = CTK_HEADER_BAR (widget)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_header_bar_get_type ()))))));
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);
Child *child;
GList *children;
gint nvis_children;
gint computed_minimum = 0;
gint computed_natural = 0;
CtkRequestedSize *sizes;
CtkPackType packing;
gint size = 0;
gint i;
gint child_size;
gint child_minimum;
gint child_natural;
gint center_min, center_nat;

nvis_children = count_visible_children (bar);

if (nvis_children <= 0)
  return;

sizes = g_newa (CtkRequestedSize, nvis_children)((CtkRequestedSize*) __builtin_alloca (sizeof (CtkRequestedSize
) * (gsize) (nvis_children)));

/* Retrieve desired size for visible children */
for (i = 0, children = priv->children; children; children = children->next)
  {
    child = children->data;

    if (ctk_widget_get_visible (child->widget))
      {
        ctk_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 = ctk_distribute_natural_allocation (MAX (0, avail_size)(((0) > (avail_size)) ? (0) : (avail_size)), nvis_children, sizes);

/* Allocate child positions. */
for (packing = CTK_PACK_START; packing <= CTK_PACK_END; ++packing)
  {
    for (i = 0, children = priv->children; children; children = children->next)
      {
        child = children->data;

        /* If widget is not visible, skip it. */
        if (!ctk_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;

        ctk_widget_get_preferred_height_for_width (child->widget,
                                                   child_size, &child_minimum, &child_natural);

        computed_minimum = MAX (computed_minimum, child_minimum)(((computed_minimum) > (child_minimum)) ? (computed_minimum
) : (child_minimum));
        computed_natural = MAX (computed_natural, child_natural)(((computed_natural) > (child_natural)) ? (computed_natural
) : (child_natural));
      }
    i += 1;
  }

center_min = center_nat = 0;
if (priv->label_box != NULL((void*)0))
  {
    ctk_widget_get_preferred_height (priv->label_sizing_box,
                                     &center_min, &center_nat);
  }

if (priv->custom_title != NULL((void*)0) &&
    ctk_widget_get_visible (priv->custom_title))
  {
    ctk_widget_get_preferred_height (priv->custom_title,
                                     &center_min, &center_nat);
  }

if (priv->titlebar_start_box != NULL((void*)0))
  {
    ctk_widget_get_preferred_height (priv->titlebar_start_box,
                                     &child_minimum, &child_natural);
    computed_minimum = MAX (computed_minimum, child_minimum)(((computed_minimum) > (child_minimum)) ? (computed_minimum
) : (child_minimum));
    computed_natural = MAX (computed_natural, child_natural)(((computed_natural) > (child_natural)) ? (computed_natural
) : (child_natural));
  }

if (priv->titlebar_end_box != NULL((void*)0))
  {
    ctk_widget_get_preferred_height (priv->titlebar_end_box,
                                     &child_minimum, &child_natural);
    computed_minimum = MAX (computed_minimum, child_minimum)(((computed_minimum) > (child_minimum)) ? (computed_minimum
) : (child_minimum));
    computed_natural = MAX (computed_natural, child_natural)(((computed_natural) > (child_natural)) ? (computed_natural
) : (child_natural));
  }

*minimum_size = computed_minimum;
*natural_size = computed_natural;
908}

910static void
911ctk_header_bar_get_content_size (CtkCssGadget   *gadget,
                               CtkOrientation  orientation,
                               gint            for_size,
                               gint           *minimum,
                               gint           *natural,
                               gint           *minimum_baseline G_GNUC_UNUSED__attribute__ ((__unused__)),
                               gint           *natural_baseline G_GNUC_UNUSED__attribute__ ((__unused__)),
                               gpointer        unused G_GNUC_UNUSED__attribute__ ((__unused__)))
919{
CtkWidget *widget = ctk_css_gadget_get_owner (gadget);

if (for_size < 0)
  ctk_header_bar_get_size (widget, orientation, minimum, natural);
else if (orientation == CTK_ORIENTATION_HORIZONTAL)
  ctk_header_bar_compute_size_for_orientation (widget, for_size, minimum, natural);
else
  ctk_header_bar_compute_size_for_opposing_orientation (widget, for_size, minimum, natural);
928}

930static void
931ctk_header_bar_get_preferred_width (CtkWidget *widget,
                                  gint      *minimum,
                                  gint      *natural)
934{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (CTK_HEADER_BAR (widget)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_header_bar_get_type ())))))));

ctk_css_gadget_get_preferred_size (priv->gadget,
                                   CTK_ORIENTATION_HORIZONTAL,
                                   -1,
                                   minimum, natural,
                                   NULL((void*)0), NULL((void*)0));
942}

944static void
945ctk_header_bar_get_preferred_height (CtkWidget *widget,
                                   gint      *minimum,
                                   gint      *natural)
948{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (CTK_HEADER_BAR (widget)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_header_bar_get_type ())))))));

ctk_css_gadget_get_preferred_size (priv->gadget,
                                   CTK_ORIENTATION_VERTICAL,
                                   -1,
                                   minimum, natural,
                                   NULL((void*)0), NULL((void*)0));
956}

958static void
959ctk_header_bar_get_preferred_width_for_height (CtkWidget *widget,
                                             gint       height,
                                             gint      *minimum,
                                             gint      *natural)
963{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (CTK_HEADER_BAR (widget)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_header_bar_get_type ())))))));

ctk_css_gadget_get_preferred_size (priv->gadget,
                                   CTK_ORIENTATION_HORIZONTAL,
                                   height,
                                   minimum, natural,
                                   NULL((void*)0), NULL((void*)0));
971}

973static void
974ctk_header_bar_get_preferred_height_for_width (CtkWidget *widget,
                                             gint       width,
                                             gint      *minimum,
                                             gint      *natural)
978{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (CTK_HEADER_BAR (widget)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_header_bar_get_type ())))))));

ctk_css_gadget_get_preferred_size (priv->gadget,
                                   CTK_ORIENTATION_VERTICAL,
                                   width,
                                   minimum, natural,
                                   NULL((void*)0), NULL((void*)0));
986}

988static void
989ctk_header_bar_size_allocate (CtkWidget     *widget,
                            CtkAllocation *allocation)
991{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (CTK_HEADER_BAR (widget)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_header_bar_get_type ())))))));
CtkAllocation clip;

ctk_widget_set_allocation (widget, allocation);

ctk_css_gadget_allocate (priv->gadget, allocation, ctk_widget_get_allocated_baseline (widget), &clip);

ctk_widget_set_clip (widget, &clip);
1000}

1002static void
1003ctk_header_bar_allocate_contents (CtkCssGadget        *gadget,
                                const CtkAllocation *allocation,
                                int                  baseline G_GNUC_UNUSED__attribute__ ((__unused__)),
                                CtkAllocation       *out_clip,
                                gpointer             unused G_GNUC_UNUSED__attribute__ ((__unused__)))
1008{
CtkWidget *widget = ctk_css_gadget_get_owner (gadget);
CtkWidget *title_widget;
CtkHeaderBar *bar = CTK_HEADER_BAR (widget)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_header_bar_get_type ()))))));
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);
CtkRequestedSize *sizes;
gint width, height;
gint nvis_children;
gint title_minimum_size;
gint title_natural_size;
gboolean title_expands = FALSE(0);
gint start_width, end_width;
gint uniform_expand_bonus[2] = { 0 };
gint leftover_expand_bonus[2] = { 0 };
gint nexpand_children[2] = { 0 };
gint side[2];
GList *l;
gint i;
Child *child;
CtkPackType packing;
CtkAllocation child_allocation;
gint x;
gint child_size;
CtkTextDirection direction;

direction = ctk_widget_get_direction (widget);
nvis_children = count_visible_children (bar);
sizes = g_newa (CtkRequestedSize, nvis_children)((CtkRequestedSize*) __builtin_alloca (sizeof (CtkRequestedSize
) * (gsize) (nvis_children)));

width = allocation->width - nvis_children * priv->spacing;
height = allocation->height;

i = 0;
for (l = priv->children; l; l = l->next)
1
Loop condition is true.  Entering loop body→
5
←
Loop condition is false. Execution continues on line 1058→
  {
    child = l->data;
    if (!ctk_widget_get_visible (child->widget))
2
←
Assuming the condition is true→
3
←
Taking true branch→
      continue;
4
←
 Execution continues on line 1041→

    if (ctk_widget_compute_expand (child->widget, CTK_ORIENTATION_HORIZONTAL))
      nexpand_children[child->pack_type]++;

    ctk_widget_get_preferred_width_for_height (child->widget,
                                               height,
                                               &sizes[i].minimum_size,
                                               &sizes[i].natural_size);
    width -= sizes[i].minimum_size;
    i++;
  }

title_minimum_size = 0;
title_natural_size = 0;

if (priv->custom_title != NULL((void*)0) &&
6
←
Assuming field 'custom_title' is equal to NULL→
    ctk_widget_get_visible (priv->custom_title))
  title_widget = priv->custom_title;
else if (priv->label_box != NULL((void*)0))
7
←
Assuming field 'label_box' is equal to NULL→
8
←
Taking false branch→
  title_widget = priv->label_box;
else
  title_widget = NULL((void*)0);

if (title_widget8.1
'title_widget' is null
)
9
←
Taking false branch→
  {
    ctk_widget_get_preferred_width_for_height (title_widget,
                                               height,
                                               &title_minimum_size,
                                               &title_natural_size);
    width -= title_natural_size;

    title_expands = ctk_widget_compute_expand (title_widget, CTK_ORIENTATION_HORIZONTAL);
  }

start_width = 0;
if (priv->titlebar_start_box != NULL((void*)0))
10
←
Assuming field 'titlebar_start_box' is equal to NULL→
11
←
Taking false branch→
  {
    gint min, nat;
    ctk_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((void*)0))
12
←
Assuming field 'titlebar_end_box' is equal to NULL→
13
←
Taking false branch→
  {
    gint min, nat;
    ctk_widget_get_preferred_width_for_height (priv->titlebar_end_box,
                                               height,
                                               &min, &nat);
    end_width = nat + priv->spacing;
  }
width -= end_width;

width = ctk_distribute_natural_allocation (MAX (0, width)(((0) > (width)) ? (0) : (width)), nvis_children, sizes);
14
←
Assuming 'width' is < 0→
15
←
'?' condition is true→

/* compute the nominal size of the children filling up each side of
 * the title in titlebar
 */
side[0] = start_width;
side[1] = end_width;
for (packing = CTK_PACK_START; packing <= CTK_PACK_END; packing++)
16
←
Loop condition is true.  Entering loop body→
  {
    i = 0;
    for (l = priv->children; l16.1
'l' is not equal to NULL
 != NULL((void*)0); l = l->next)
17
←
Loop condition is true.  Entering loop body→
      {
        child = l->data;
        if (!ctk_widget_get_visible (child->widget))
18
←
Assuming the condition is false→
19
←
Taking false branch→
          continue;

        if (child->pack_type == packing)
20
←
Assuming 'packing' is equal to field 'pack_type'→
21
←
Taking true branch→
          side[packing] += sizes[i].minimum_size + priv->spacing;
22
←
Access of the memory returned by 'alloca' at index 0, while it holds only 0 'struct _CtkRequestedSize' element

        i++;
      }
  }

/* figure out how much space is left on each side of the title,
 * and earkmark that space for the expanded children.
 *
 * If the title itself is expanded, then it gets half the spoils
 * from each side.
 */
for (packing = CTK_PACK_START; packing <= CTK_PACK_END; packing++)
  {
    gint side_free_space;

    side_free_space = allocation->width / 2 - title_natural_size / 2 - side[packing];

    if (side_free_space > 0 && nexpand_children[packing] > 0)
      {
        width -= side_free_space;

        if (title_expands)
          side_free_space -= side_free_space / 2;

        side[packing] += side_free_space;
        uniform_expand_bonus[packing] = side_free_space / nexpand_children[packing];
        leftover_expand_bonus[packing] = side_free_space % nexpand_children[packing];
      }
  }

/* allocate the children on both sides of the title */
for (packing = CTK_PACK_START; packing <= CTK_PACK_END; packing++)
  {
    child_allocation.y = allocation->y;
    child_allocation.height = height;
    if (packing == CTK_PACK_START)
      x = allocation->x + start_width;
    else
      x = allocation->x + allocation->width - end_width;

    i = 0;
    for (l = priv->children; l != NULL((void*)0); l = l->next)
      {
        child = l->data;
        if (!ctk_widget_get_visible (child->widget))
          continue;

        if (child->pack_type != packing)
          goto next;

        child_size = sizes[i].minimum_size;

        /* if this child is expanded, give it extra space from the reserves */
        if (ctk_widget_compute_expand (child->widget, CTK_ORIENTATION_HORIZONTAL))
          {
            gint expand_bonus;

            expand_bonus = uniform_expand_bonus[packing];

            if (leftover_expand_bonus[packing] > 0)
              {
                expand_bonus++;
                leftover_expand_bonus[packing]--;
              }

            child_size += expand_bonus;
          }

        child_allocation.width = child_size;

        if (packing == CTK_PACK_START)
          {
            child_allocation.x = x;
            x += child_size;
            x += priv->spacing;
          }
        else
          {
            x -= child_size;
            child_allocation.x = x;
            x -= priv->spacing;
          }

        if (direction == CTK_TEXT_DIR_RTL)
          child_allocation.x = allocation->x + allocation->width - (child_allocation.x - allocation->x) - child_allocation.width;

        ctk_widget_size_allocate (child->widget, &child_allocation);

      next:
        i++;
      }
  }

/* We don't enforce css borders on the center widget, to make
 * title/subtitle combinations fit without growing the header
 */
child_allocation.y = allocation->y;
child_allocation.height = allocation->height;

child_size = MIN (allocation->width - side[0] - side[1], title_natural_size)(((allocation->width - side[0] - side[1]) < (title_natural_size
)) ? (allocation->width - side[0] - side[1]) : (title_natural_size
));

child_allocation.x = allocation->x + (allocation->width - child_size) / 2;
child_allocation.width = child_size;

/* if the title widget is expanded, then grow it by all the available
 * free space, and recenter it
 */
if (title_expands && width > 0)
  {
    child_allocation.width += width;
    child_allocation.x -= width / 2;
  }

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 == CTK_TEXT_DIR_RTL)
  child_allocation.x = allocation->x + allocation->width - (child_allocation.x - allocation->x) - child_allocation.width;

if (title_widget != NULL((void*)0))
  ctk_widget_size_allocate (title_widget, &child_allocation);

child_allocation.y = allocation->y;
child_allocation.height = height;

if (priv->titlebar_start_box)
  {
    gboolean left = (direction == CTK_TEXT_DIR_LTR);
    if (left)
      child_allocation.x = allocation->x;
    else
      child_allocation.x = allocation->x + allocation->width - start_width + priv->spacing;
    child_allocation.width = start_width - priv->spacing;
    ctk_widget_size_allocate (priv->titlebar_start_box, &child_allocation);
  }

if (priv->titlebar_end_box)
  {
    gboolean left = (direction != CTK_TEXT_DIR_LTR);
    if (left)
      child_allocation.x = allocation->x;
    else
      child_allocation.x = allocation->x + allocation->width - end_width + priv->spacing;
    child_allocation.width = end_width - priv->spacing;
    ctk_widget_size_allocate (priv->titlebar_end_box, &child_allocation);
  }

ctk_container_get_children_clip (CTK_CONTAINER (widget)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_container_get_type ())))))), out_clip);
1270}

1272/**
* ctk_header_bar_set_title:
* @bar: a #CtkHeaderBar
* @title: (allow-none): a title, or %NULL
*
* Sets the title of the #CtkHeaderBar. The title should help a user
* identify the current view. A good title should not include the
* application name.
*
* Since: 3.10
*/
1283void
1284ctk_header_bar_set_title (CtkHeaderBar *bar,
                        const gchar  *title)
1286{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);
gchar *new_title;

g_return_if_fail (CTK_IS_HEADER_BAR (bar))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((bar)); GType __t = ((ctk_header_bar_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("Ctk", ((const char*) (__func__
)), "CTK_IS_HEADER_BAR (bar)"); return; } } while (0);

new_title = g_strdup (title)g_strdup_inline (title);
g_free (priv->title);
priv->title = new_title;

if (priv->title_label != NULL((void*)0))
  {
    ctk_label_set_label (CTK_LABEL (priv->title_label)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((priv->title_label)), ((ctk_label_get_type ())))))), priv->title);
    ctk_widget_queue_resize (CTK_WIDGET (bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), ((ctk_widget_get_type ())))))));
  }

g_object_notify_by_pspec (G_OBJECT (bar)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), (((GType) ((20) << (2)))))))), header_bar_props[PROP_TITLE]);
1303}

1305/**
* ctk_header_bar_get_title:
* @bar: a #CtkHeaderBar
*
* Retrieves the title of the header. See ctk_header_bar_set_title().
*
* Returns: (nullable): the title of the header, or %NULL if none has
*    been set explicitly. The returned string is owned by the widget
*    and must not be modified or freed.
*
* Since: 3.10
*/
1317const gchar *
1318ctk_header_bar_get_title (CtkHeaderBar *bar)
1319{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);

g_return_val_if_fail (CTK_IS_HEADER_BAR (bar), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((bar)); GType __t = ((ctk_header_bar_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("Ctk", ((const char*) (__func__
)), "CTK_IS_HEADER_BAR (bar)"); return (((void*)0)); } } while
 (0);

return priv->title;
1325}

1327/**
* ctk_header_bar_set_subtitle:
* @bar: a #CtkHeaderBar
* @subtitle: (allow-none): a subtitle, or %NULL
*
* Sets the subtitle of the #CtkHeaderBar. The title should give a user
* an additional detail to help him identify the current view.
*
* Note that CtkHeaderBar by default reserves room for the subtitle,
* even if none is currently set. If this is not desired, set the
* #CtkHeaderBar:has-subtitle property to %FALSE.
*
* Since: 3.10
*/
1341void
1342ctk_header_bar_set_subtitle (CtkHeaderBar *bar,
                           const gchar  *subtitle)
1344{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);
gchar *new_subtitle;

g_return_if_fail (CTK_IS_HEADER_BAR (bar))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((bar)); GType __t = ((ctk_header_bar_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("Ctk", ((const char*) (__func__
)), "CTK_IS_HEADER_BAR (bar)"); return; } } while (0);

new_subtitle = g_strdup (subtitle)g_strdup_inline (subtitle);
g_free (priv->subtitle);
priv->subtitle = new_subtitle;

if (priv->subtitle_label != NULL((void*)0))
  {
    ctk_label_set_label (CTK_LABEL (priv->subtitle_label)((((CtkLabel*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((priv->subtitle_label)), ((ctk_label_get_type ())))))), priv->subtitle);
    ctk_widget_set_visible (priv->subtitle_label, priv->subtitle && priv->subtitle[0]);
    ctk_widget_queue_resize (CTK_WIDGET (bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), ((ctk_widget_get_type ())))))));
  }

ctk_widget_set_visible (priv->subtitle_sizing_label, priv->has_subtitle || (priv->subtitle && priv->subtitle[0]));

g_object_notify_by_pspec (G_OBJECT (bar)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), (((GType) ((20) << (2)))))))), header_bar_props[PROP_SUBTITLE]);
1364}

1366/**
* ctk_header_bar_get_subtitle:
* @bar: a #CtkHeaderBar
*
* Retrieves the subtitle of the header. See ctk_header_bar_set_subtitle().
*
* Returns: (nullable): the subtitle of the header, or %NULL if none has
*    been set explicitly. The returned string is owned by the widget
*    and must not be modified or freed.
*
* Since: 3.10
*/
1378const gchar *
1379ctk_header_bar_get_subtitle (CtkHeaderBar *bar)
1380{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);

g_return_val_if_fail (CTK_IS_HEADER_BAR (bar), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((bar)); GType __t = ((ctk_header_bar_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("Ctk", ((const char*) (__func__
)), "CTK_IS_HEADER_BAR (bar)"); return (((void*)0)); } } while
 (0);

return priv->subtitle;
1386}

1388/**
* ctk_header_bar_set_custom_title:
* @bar: a #CtkHeaderBar
* @title_widget: (allow-none): a custom widget to use for a title
*
* Sets a custom title for the #CtkHeaderBar.
*
* The title should help a user identify the current view. This
* supersedes any title set by ctk_header_bar_set_title() or
* ctk_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
*/
1406void
1407ctk_header_bar_set_custom_title (CtkHeaderBar *bar,
                               CtkWidget    *title_widget)
1409{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);

g_return_if_fail (CTK_IS_HEADER_BAR (bar))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((bar)); GType __t = ((ctk_header_bar_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("Ctk", ((const char*) (__func__
)), "CTK_IS_HEADER_BAR (bar)"); return; } } while (0);
if (title_widget)
  g_return_if_fail (CTK_IS_WIDGET (title_widget))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((title_widget)); GType __t = ((ctk_widget_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("Ctk", ((const char*) (__func__
)), "CTK_IS_WIDGET (title_widget)"); return; } } while (0);

/* No need to do anything if the custom widget stays the same */
if (priv->custom_title == title_widget)
  return;

if (priv->custom_title)
  {
    CtkWidget *custom = priv->custom_title;

    priv->custom_title = NULL((void*)0);
    ctk_widget_unparent (custom);
  }

if (title_widget != NULL((void*)0))
  {
    priv->custom_title = title_widget;

    ctk_header_bar_reorder_css_node (bar, CTK_PACK_START, priv->custom_title);
    ctk_widget_set_parent (priv->custom_title, CTK_WIDGET (bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), ((ctk_widget_get_type ())))))));
    ctk_widget_set_valign (priv->custom_title, CTK_ALIGN_CENTER);

    if (priv->label_box != NULL((void*)0))
      {
        CtkWidget *label_box = priv->label_box;

        priv->label_box = NULL((void*)0);
        priv->title_label = NULL((void*)0);
        priv->subtitle_label = NULL((void*)0);
        ctk_widget_unparent (label_box);
      }

  }
else
  {
    if (priv->label_box == NULL((void*)0))
      construct_label_box (bar);
  }

ctk_widget_queue_resize (CTK_WIDGET (bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), ((ctk_widget_get_type ())))))));

g_object_notify_by_pspec (G_OBJECT (bar)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), (((GType) ((20) << (2)))))))), header_bar_props[PROP_CUSTOM_TITLE]);
1456}

1458/**
* ctk_header_bar_get_custom_title:
* @bar: a #CtkHeaderBar
*
* Retrieves the custom title widget of the header. See
* ctk_header_bar_set_custom_title().
*
* Returns: (nullable) (transfer none): the custom title widget
*    of the header, or %NULL if none has been set explicitly.
*
* Since: 3.10
*/
1470CtkWidget *
1471ctk_header_bar_get_custom_title (CtkHeaderBar *bar)
1472{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);

g_return_val_if_fail (CTK_IS_HEADER_BAR (bar), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((bar)); GType __t = ((ctk_header_bar_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("Ctk", ((const char*) (__func__
)), "CTK_IS_HEADER_BAR (bar)"); return (((void*)0)); } } while
 (0);

return priv->custom_title;
1478}

1480static void
1481ctk_header_bar_destroy (CtkWidget *widget)
1482{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (CTK_HEADER_BAR (widget)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_header_bar_get_type ())))))));

if (priv->label_sizing_box)
  {
    ctk_widget_destroy (priv->label_sizing_box);
    g_clear_object (&priv->label_sizing_box)do { _Static_assert (sizeof *((&priv->label_sizing_box
)) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (((&priv->label_sizing_box))) _pp = ((&priv->label_sizing_box
)); __typeof__ (*((&priv->label_sizing_box))) _ptr = *
_pp; *_pp = ((void*)0); if (_ptr) (g_object_unref) (_ptr); } while
 (0);
  }

if (priv->custom_title)
  {
    ctk_widget_unparent (priv->custom_title);
    priv->custom_title = NULL((void*)0);
  }

if (priv->label_box)
  {
    ctk_widget_unparent (priv->label_box);
    priv->label_box = NULL((void*)0);
  }

if (priv->titlebar_start_box)
  {
    ctk_widget_unparent (priv->titlebar_start_box);
    priv->titlebar_start_box = NULL((void*)0);
    priv->titlebar_start_separator = NULL((void*)0);
  }

if (priv->titlebar_end_box)
  {
    ctk_widget_unparent (priv->titlebar_end_box);
    priv->titlebar_end_box = NULL((void*)0);
    priv->titlebar_end_separator = NULL((void*)0);
  }

CTK_WIDGET_CLASS (ctk_header_bar_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((ctk_header_bar_parent_class)), ((ctk_widget_get_type ())
)))))->destroy (widget);
1518}

1520static void
1521ctk_header_bar_finalize (GObject *object)
1522{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (CTK_HEADER_BAR (object)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((ctk_header_bar_get_type ())))))));

g_free (priv->title);
g_free (priv->subtitle);
g_free (priv->decoration_layout);

g_clear_object (&priv->gadget)do { _Static_assert (sizeof *((&priv->gadget)) == sizeof
 (gpointer), "Expression evaluates to false"); __typeof__ (((
&priv->gadget))) _pp = ((&priv->gadget)); __typeof__
 (*((&priv->gadget))) _ptr = *_pp; *_pp = ((void*)0); if
 (_ptr) (g_object_unref) (_ptr); } while (0);

G_OBJECT_CLASS (ctk_header_bar_parent_class)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((ctk_header_bar_parent_class)), (((GType) ((20) << (
2))))))))->finalize (object);
1532}

1534static void
1535ctk_header_bar_get_property (GObject    *object,
                           guint       prop_id,
                           GValue     *value,
                           GParamSpec *pspec)
1539{
CtkHeaderBar *bar = CTK_HEADER_BAR (object)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((ctk_header_bar_get_type ()))))));
CtkHeaderBarPrivate *priv = ctk_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, ctk_header_bar_get_show_close_button (bar));
    break;

  case PROP_HAS_SUBTITLE:
    g_value_set_boolean (value, ctk_header_bar_get_has_subtitle (bar));
    break;

  case PROP_DECORATION_LAYOUT:
    g_value_set_string (value, ctk_header_bar_get_decoration_layout (bar));
    break;

  case PROP_DECORATION_LAYOUT_SET:
    g_value_set_boolean (value, priv->decoration_layout_set);
    break;

  default:
    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec)do { GObject *_glib__object = (GObject*) ((object)); GParamSpec
 *_glib__pspec = (GParamSpec*) ((pspec)); guint _glib__property_id
 = ((prop_id)); g_warning ("%s:%d: invalid %s id %u for \"%s\" of type '%s' in '%s'"
, "ctkheaderbar.c", 1578, ("property"), _glib__property_id, _glib__pspec
->name, g_type_name ((((((GTypeClass*) (((GTypeInstance*) (
_glib__pspec))->g_class))->g_type)))), (g_type_name (((
(((GTypeClass*) (((GTypeInstance*) (_glib__object))->g_class
))->g_type)))))); } while (0);
    break;
  }
1581}

1583static void
1584ctk_header_bar_set_property (GObject      *object,
                           guint         prop_id,
                           const GValue *value,
                           GParamSpec   *pspec)
1588{
CtkHeaderBar *bar = CTK_HEADER_BAR (object)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((ctk_header_bar_get_type ()))))));
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);

switch (prop_id)
  {
  case PROP_TITLE:
    ctk_header_bar_set_title (bar, g_value_get_string (value));
    break;

  case PROP_SUBTITLE:
    ctk_header_bar_set_subtitle (bar, g_value_get_string (value));
    break;

  case PROP_CUSTOM_TITLE:
    ctk_header_bar_set_custom_title (bar, g_value_get_object (value));
    break;

  case PROP_SPACING:
    if (priv->spacing != g_value_get_int (value))
      {
        priv->spacing = g_value_get_int (value);
        ctk_widget_queue_resize (CTK_WIDGET (bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), ((ctk_widget_get_type ())))))));
        g_object_notify_by_pspec (object, pspec);
      }
    break;

  case PROP_SHOW_CLOSE_BUTTON:
    ctk_header_bar_set_show_close_button (bar, g_value_get_boolean (value));
    break;

  case PROP_HAS_SUBTITLE:
    ctk_header_bar_set_has_subtitle (bar, g_value_get_boolean (value));
    break;

  case PROP_DECORATION_LAYOUT:
    ctk_header_bar_set_decoration_layout (bar, g_value_get_string (value));
    break;

  case PROP_DECORATION_LAYOUT_SET:
    priv->decoration_layout_set = g_value_get_boolean (value);
    break;

  default:
    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec)do { GObject *_glib__object = (GObject*) ((object)); GParamSpec
 *_glib__pspec = (GParamSpec*) ((pspec)); guint _glib__property_id
 = ((prop_id)); g_warning ("%s:%d: invalid %s id %u for \"%s\" of type '%s' in '%s'"
, "ctkheaderbar.c", 1632, ("property"), _glib__property_id, _glib__pspec
->name, g_type_name ((((((GTypeClass*) (((GTypeInstance*) (
_glib__pspec))->g_class))->g_type)))), (g_type_name (((
(((GTypeClass*) (((GTypeInstance*) (_glib__object))->g_class
))->g_type)))))); } while (0);
    break;
  }
1635}

1637static void
1638notify_child_cb (GObject      *child G_GNUC_UNUSED__attribute__ ((__unused__)),
               GParamSpec   *pspec G_GNUC_UNUSED__attribute__ ((__unused__)),
               CtkHeaderBar *bar)
1641{
_ctk_header_bar_update_separator_visibility (bar);
1643}

1645static void
1646ctk_header_bar_pack (CtkHeaderBar *bar,
                   CtkWidget    *widget,
                   CtkPackType   pack_type)
1649{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);
Child *child;

g_return_if_fail (ctk_widget_get_parent (widget) == NULL)do { if ((ctk_widget_get_parent (widget) == ((void*)0))) { } else
 { g_return_if_fail_warning ("Ctk", ((const char*) (__func__)
), "ctk_widget_get_parent (widget) == NULL"); return; } } while
 (0);

child = g_new (Child, 1)((Child *) g_malloc_n ((1), sizeof (Child)));
child->widget = widget;
child->pack_type = pack_type;

priv->children = g_list_append (priv->children, child);

ctk_widget_freeze_child_notify (widget);
ctk_header_bar_reorder_css_node (bar, CTK_PACK_START, widget);
ctk_widget_set_parent (widget, CTK_WIDGET (bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), ((ctk_widget_get_type ())))))));
g_signal_connect (widget, "notify::visible", G_CALLBACK (notify_child_cb), bar)g_signal_connect_data ((widget), ("notify::visible"), (((GCallback
) (notify_child_cb))), (bar), ((void*)0), (GConnectFlags) 0);
ctk_widget_child_notify (widget, "pack-type");
ctk_widget_child_notify (widget, "position");
ctk_widget_thaw_child_notify (widget);

_ctk_header_bar_update_separator_visibility (bar);
1670}

1672static void
1673ctk_header_bar_add (CtkContainer *container,
                  CtkWidget    *child)
1675{
ctk_header_bar_pack (CTK_HEADER_BAR (container)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_header_bar_get_type ())))))), child, CTK_PACK_START);
1677}

1679static GList *
1680find_child_link (CtkHeaderBar *bar,
               CtkWidget    *widget,
               gint         *position)
1683{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);
GList *l;
Child *child;
gint i;

for (l = priv->children, i = 0; l; l = l->next, i++)
  {
    child = l->data;
    if (child->widget == widget)
      {
        if (position)
          *position = i;
        return l;
      }
  }

return NULL((void*)0);
1701}

1703static void
1704ctk_header_bar_remove (CtkContainer *container,
                     CtkWidget    *widget)
1706{
CtkHeaderBar *bar = CTK_HEADER_BAR (container)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_header_bar_get_type ()))))));
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);
GList *l;
Child *child;

l = find_child_link (bar, widget, NULL((void*)0));
if (l)
  {
    child = l->data;
    g_signal_handlers_disconnect_by_func (widget, notify_child_cb, bar)g_signal_handlers_disconnect_matched ((widget), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)
0), (notify_child_cb), (bar));
    ctk_widget_unparent (child->widget);
    priv->children = g_list_delete_link (priv->children, l);
    g_free (child);
    ctk_widget_queue_resize (CTK_WIDGET (container)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_widget_get_type ())))))));
    _ctk_header_bar_update_separator_visibility (bar);
  }
1723}

1725static void
1726ctk_header_bar_forall (CtkContainer *container,
                     gboolean      include_internals,
                     CtkCallback   callback,
                     gpointer      callback_data)
1730{
CtkHeaderBar *bar = CTK_HEADER_BAR (container)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_header_bar_get_type ()))))));
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);
Child *child;
GList *children;

if (include_internals && priv->titlebar_start_box != NULL((void*)0))
  (* callback) (priv->titlebar_start_box, callback_data);

children = priv->children;
while (children)
  {
    child = children->data;
    children = children->next;
    if (child->pack_type == CTK_PACK_START)
      (* callback) (child->widget, callback_data);
  }

if (priv->custom_title != NULL((void*)0))
  (* callback) (priv->custom_title, callback_data);

if (include_internals && priv->label_box != NULL((void*)0))
  (* callback) (priv->label_box, callback_data);

children = priv->children;
while (children)
  {
    child = children->data;
    children = children->next;
    if (child->pack_type == CTK_PACK_END)
      (* callback) (child->widget, callback_data);
  }

if (include_internals && priv->titlebar_end_box != NULL((void*)0))
  (* callback) (priv->titlebar_end_box, callback_data);
1765}

1767static void
1768ctk_header_bar_reorder_child (CtkHeaderBar *bar,
                            CtkWidget    *widget,
                            gint          position)
1771{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);
GList *l;
gint old_position;
Child *child;

l = find_child_link (bar, widget, &old_position);

if (l == NULL((void*)0))
  return;

if (old_position == position)
  return;

child = l->data; 
priv->children = g_list_delete_link (priv->children, l);

if (position < 0)
  l = NULL((void*)0);
else
  l = g_list_nth (priv->children, position);

priv->children = g_list_insert_before (priv->children, l, child);
ctk_header_bar_reorder_css_node (bar, child->pack_type, widget);
ctk_widget_child_notify (widget, "position");
ctk_widget_queue_resize (widget);
1797}

1799static GType
1800ctk_header_bar_child_type (CtkContainer *container G_GNUC_UNUSED__attribute__ ((__unused__)))
1801{
return CTK_TYPE_WIDGET(ctk_widget_get_type ());
1803}

1805static void
1806ctk_header_bar_get_child_property (CtkContainer *container,
                                 CtkWidget    *widget,
                                 guint         property_id,
                                 GValue       *value,
                                 GParamSpec   *pspec)
1811{
CtkHeaderBar *bar = CTK_HEADER_BAR (container)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_header_bar_get_type ()))))));
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (bar);
GList *l;
Child *child;

l = find_child_link (bar, widget, NULL((void*)0));
if (l == NULL((void*)0))
  {
    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:
    CTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec)do { GObject *_glib__object = (GObject*) ((container)); GParamSpec
 *_glib__pspec = (GParamSpec*) ((pspec)); guint _glib__property_id
 = ((property_id)); g_warning ("%s:%d: invalid %s id %u for \"%s\" of type '%s' in '%s'"
, "ctkheaderbar.c", 1837, ("child property"), _glib__property_id
, _glib__pspec->name, g_type_name ((((((GTypeClass*) (((GTypeInstance
*) (_glib__pspec))->g_class))->g_type)))), (g_type_name
 ((((((GTypeClass*) (((GTypeInstance*) (_glib__object))->g_class
))->g_type)))))); } while (0);
    break;
  }
1840}

1842static void
1843ctk_header_bar_set_child_property (CtkContainer *container,
                                 CtkWidget    *widget,
                                 guint         property_id,
                                 const GValue *value,
                                 GParamSpec   *pspec)
1848{
CtkHeaderBar *bar = CTK_HEADER_BAR (container)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_header_bar_get_type ()))))));
GList *l;
Child *child;

l = find_child_link (bar, widget, NULL((void*)0));
if (l == NULL((void*)0))
  return;

child = l->data;

switch (property_id)
  {
  case CHILD_PROP_PACK_TYPE:
    child->pack_type = g_value_get_enum (value);
    _ctk_header_bar_update_separator_visibility (bar);
    ctk_widget_queue_resize (widget);
    break;

  case CHILD_PROP_POSITION:
    ctk_header_bar_reorder_child (bar, widget, g_value_get_int (value));
    break;

  default:
    CTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec)do { GObject *_glib__object = (GObject*) ((container)); GParamSpec
 *_glib__pspec = (GParamSpec*) ((pspec)); guint _glib__property_id
 = ((property_id)); g_warning ("%s:%d: invalid %s id %u for \"%s\" of type '%s' in '%s'"
, "ctkheaderbar.c", 1872, ("child property"), _glib__property_id
, _glib__pspec->name, g_type_name ((((((GTypeClass*) (((GTypeInstance
*) (_glib__pspec))->g_class))->g_type)))), (g_type_name
 ((((((GTypeClass*) (((GTypeInstance*) (_glib__object))->g_class
))->g_type)))))); } while (0);
    break;
  }
1875}

1877static gint
1878ctk_header_bar_draw (CtkWidget *widget,
                   cairo_t   *cr)
1880{
CtkHeaderBarPrivate *priv = ctk_header_bar_get_instance_private (CTK_HEADER_BAR (widget)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_header_bar_get_type ())))))));

ctk_css_gadget_draw (priv->gadget, cr);

return FALSE(0);
1886}

1888static gboolean
1889ctk_header_bar_render_contents (CtkCssGadget *gadget,
                              cairo_t      *cr,
                              int           x G_GNUC_UNUSED__attribute__ ((__unused__)),
                              int           y G_GNUC_UNUSED__attribute__ ((__unused__)),
                              int           width G_GNUC_UNUSED__attribute__ ((__unused__)),
                              int           height G_GNUC_UNUSED__attribute__ ((__unused__)),
                              gpointer      unused G_GNUC_UNUSED__attribute__ ((__unused__)))
1896{
CtkWidget *widget = ctk_css_gadget_get_owner (gadget);

CTK_WIDGET_CLASS (ctk_header_bar_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((ctk_header_bar_parent_class)), ((ctk_widget_get_type ())
)))))->draw (widget, cr);

return FALSE(0);
1902}

1904static void
1905ctk_header_bar_realize (CtkWidget *widget)
1906{
CtkSettings *settings;

CTK_WIDGET_CLASS (ctk_header_bar_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((ctk_header_bar_parent_class)), ((ctk_widget_get_type ())
)))))->realize (widget);

settings = ctk_widget_get_settings (widget);
g_signal_connect_swapped (settings, "notify::ctk-shell-shows-app-menu",g_signal_connect_data ((settings), ("notify::ctk-shell-shows-app-menu"
), (((GCallback) (_ctk_header_bar_update_window_buttons))), (
widget), ((void*)0), G_CONNECT_SWAPPED)
                          G_CALLBACK (_ctk_header_bar_update_window_buttons), widget)g_signal_connect_data ((settings), ("notify::ctk-shell-shows-app-menu"
), (((GCallback) (_ctk_header_bar_update_window_buttons))), (
widget), ((void*)0), G_CONNECT_SWAPPED);
g_signal_connect_swapped (settings, "notify::ctk-decoration-layout",g_signal_connect_data ((settings), ("notify::ctk-decoration-layout"
), (((GCallback) (_ctk_header_bar_update_window_buttons))), (
widget), ((void*)0), G_CONNECT_SWAPPED)
                          G_CALLBACK (_ctk_header_bar_update_window_buttons), widget)g_signal_connect_data ((settings), ("notify::ctk-decoration-layout"
), (((GCallback) (_ctk_header_bar_update_window_buttons))), (
widget), ((void*)0), G_CONNECT_SWAPPED);
_ctk_header_bar_update_window_buttons (CTK_HEADER_BAR (widget)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_header_bar_get_type ())))))));
1917}

1919static void
1920ctk_header_bar_unrealize (CtkWidget *widget)
1921{
CtkSettings *settings;

settings = ctk_widget_get_settings (widget);

g_signal_handlers_disconnect_by_func (settings, _ctk_header_bar_update_window_buttons, widget)g_signal_handlers_disconnect_matched ((settings), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)
0), (_ctk_header_bar_update_window_buttons), (widget));

CTK_WIDGET_CLASS (ctk_header_bar_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((ctk_header_bar_parent_class)), ((ctk_widget_get_type ())
)))))->unrealize (widget);
1929}

1931static gboolean
1932window_state_changed (CtkWidget           *window G_GNUC_UNUSED__attribute__ ((__unused__)),
                    CdkEventWindowState *event,
                    gpointer             data)
1935{
CtkHeaderBar *bar = CTK_HEADER_BAR (data)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((data)), ((ctk_header_bar_get_type ()))))));

if (event->changed_mask & (CDK_WINDOW_STATE_FULLSCREEN |
                           CDK_WINDOW_STATE_MAXIMIZED |
                           CDK_WINDOW_STATE_TILED |
                           CDK_WINDOW_STATE_TOP_TILED |
                           CDK_WINDOW_STATE_RIGHT_TILED |
                           CDK_WINDOW_STATE_BOTTOM_TILED |
                           CDK_WINDOW_STATE_LEFT_TILED))
  _ctk_header_bar_update_window_buttons (bar);

return FALSE(0);
1948}

1950static void
1951ctk_header_bar_hierarchy_changed (CtkWidget *widget,
                                CtkWidget *previous_toplevel)
1953{
CtkWidget *toplevel;
CtkHeaderBar *bar = CTK_HEADER_BAR (widget)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_header_bar_get_type ()))))));

toplevel = ctk_widget_get_toplevel (widget);

if (previous_toplevel)
  g_signal_handlers_disconnect_by_func (previous_toplevel,g_signal_handlers_disconnect_matched ((previous_toplevel), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)
0), (window_state_changed), (widget))
                                        window_state_changed, widget)g_signal_handlers_disconnect_matched ((previous_toplevel), (GSignalMatchType
) (G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA), 0, 0, ((void*)
0), (window_state_changed), (widget));

if (toplevel)
  g_signal_connect_after (toplevel, "window-state-event",g_signal_connect_data ((toplevel), ("window-state-event"), ((
(GCallback) (window_state_changed))), (widget), ((void*)0), G_CONNECT_AFTER
)
                          G_CALLBACK (window_state_changed), widget)g_signal_connect_data ((toplevel), ("window-state-event"), ((
(GCallback) (window_state_changed))), (widget), ((void*)0), G_CONNECT_AFTER
);

_ctk_header_bar_update_window_buttons (bar);
1968}

1970static void
1971ctk_header_bar_direction_changed (CtkWidget        *widget,
                                CtkTextDirection  previous_direction)
1973{
CTK_WIDGET_CLASS (ctk_header_bar_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((ctk_header_bar_parent_class)), ((ctk_widget_get_type ())
)))))->direction_changed (widget, previous_direction);

ctk_css_node_reverse_children (ctk_widget_get_css_node (widget));
1977}

1979static void
1980ctk_header_bar_class_init (CtkHeaderBarClass *class)
1981{
GObjectClass *object_class = G_OBJECT_CLASS (class)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((class)), (((GType) ((20) << (2))))))));
CtkWidgetClass *widget_class = CTK_WIDGET_CLASS (class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((class)), ((ctk_widget_get_type ()))))));
CtkContainerClass *container_class = CTK_CONTAINER_CLASS (class)((((CtkContainerClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((class)), ((ctk_container_get_type ()))))));

object_class->finalize = ctk_header_bar_finalize;
object_class->get_property = ctk_header_bar_get_property;
object_class->set_property = ctk_header_bar_set_property;

widget_class->destroy = ctk_header_bar_destroy;
widget_class->size_allocate = ctk_header_bar_size_allocate;
widget_class->get_preferred_width = ctk_header_bar_get_preferred_width;
widget_class->get_preferred_height = ctk_header_bar_get_preferred_height;
widget_class->get_preferred_height_for_width = ctk_header_bar_get_preferred_height_for_width;
widget_class->get_preferred_width_for_height = ctk_header_bar_get_preferred_width_for_height;
widget_class->draw = ctk_header_bar_draw;
widget_class->realize = ctk_header_bar_realize;
widget_class->unrealize = ctk_header_bar_unrealize;
widget_class->hierarchy_changed = ctk_header_bar_hierarchy_changed;
widget_class->direction_changed = ctk_header_bar_direction_changed;

container_class->add = ctk_header_bar_add;
container_class->remove = ctk_header_bar_remove;
container_class->forall = ctk_header_bar_forall;
container_class->child_type = ctk_header_bar_child_type;
container_class->set_child_property = ctk_header_bar_set_child_property;
container_class->get_child_property = ctk_header_bar_get_child_property;
ctk_container_class_handle_border_width (container_class);

ctk_container_class_install_child_property (container_class,
                                            CHILD_PROP_PACK_TYPE,
                                            g_param_spec_enum ("pack-type",
                                                               P_("Pack type")g_dgettext("ctk30" "-properties","Pack type"),
                                                               P_("A CtkPackType indicating whether the child is packed with reference to the start or end of the parent")g_dgettext("ctk30" "-properties","A CtkPackType indicating whether the child is packed with reference to the start or end of the parent"
),
                                                               CTK_TYPE_PACK_TYPE(ctk_pack_type_get_type ()), CTK_PACK_START,
                                                               CTK_PARAM_READWRITEG_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
ctk_container_class_install_child_property (container_class,
                                            CHILD_PROP_POSITION,
                                            g_param_spec_int ("position",
                                                              P_("Position")g_dgettext("ctk30" "-properties","Position"),
                                                              P_("The index of the child in the parent")g_dgettext("ctk30" "-properties","The index of the child in the parent"
),
                                                              -1, G_MAXINT2147483647, 0,
                                                              CTK_PARAM_READWRITEG_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));

header_bar_props[PROP_TITLE] =
    g_param_spec_string ("title",
                         P_("Title")g_dgettext("ctk30" "-properties","Title"),
                         P_("The title to display")g_dgettext("ctk30" "-properties","The title to display"),
                         NULL((void*)0),
                         G_PARAM_READWRITE);

header_bar_props[PROP_SUBTITLE] =
    g_param_spec_string ("subtitle",
                         P_("Subtitle")g_dgettext("ctk30" "-properties","Subtitle"),
                         P_("The subtitle to display")g_dgettext("ctk30" "-properties","The subtitle to display"),
                         NULL((void*)0),
                         G_PARAM_READWRITE);

header_bar_props[PROP_CUSTOM_TITLE] =
    g_param_spec_object ("custom-title",
                         P_("Custom Title")g_dgettext("ctk30" "-properties","Custom Title"),
                         P_("Custom title widget to display")g_dgettext("ctk30" "-properties","Custom title widget to display"
),
                         CTK_TYPE_WIDGET(ctk_widget_get_type ()),
                         G_PARAM_READWRITE|G_PARAM_STATIC_STRINGS(G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB
));

header_bar_props[PROP_SPACING] =
    g_param_spec_int ("spacing",
                      P_("Spacing")g_dgettext("ctk30" "-properties","Spacing"),
                      P_("The amount of space between children")g_dgettext("ctk30" "-properties","The amount of space between children"
),
                      0, G_MAXINT2147483647,
                      DEFAULT_SPACING6,
                      CTK_PARAM_READWRITEG_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB|G_PARAM_EXPLICIT_NOTIFY);

/**
 * CtkHeaderBar:show-close-button:
 *
 * Whether to show window decorations.
 *
 * Which buttons are actually shown and where is determined
 * by the #CtkHeaderBar:decoration-layout property, and by
 * the state of the window (e.g. a close button will not be
 * shown if the window can't be closed).
 */
header_bar_props[PROP_SHOW_CLOSE_BUTTON] =
    g_param_spec_boolean ("show-close-button",
                          P_("Show decorations")g_dgettext("ctk30" "-properties","Show decorations"),
                          P_("Whether to show window decorations")g_dgettext("ctk30" "-properties","Whether to show window decorations"
),
                          FALSE(0),
                          CTK_PARAM_READWRITEG_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB|G_PARAM_EXPLICIT_NOTIFY);

/**
 * CtkHeaderBar:decoration-layout:
 *
 * The decoration layout for buttons. If this property is
 * not set, the #CtkSettings:ctk-decoration-layout setting
 * is used.
 *
 * See ctk_header_bar_set_decoration_layout() for information
 * about the format of this string.
 *
 * Since: 3.12
 */
header_bar_props[PROP_DECORATION_LAYOUT] =
    g_param_spec_string ("decoration-layout",
                         P_("Decoration Layout")g_dgettext("ctk30" "-properties","Decoration Layout"),
                         P_("The layout for window decorations")g_dgettext("ctk30" "-properties","The layout for window decorations"
),
                         NULL((void*)0),
                         CTK_PARAM_READWRITEG_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB);

/**
 * CtkHeaderBar:decoration-layout-set:
 *
 * Set to %TRUE if #CtkHeaderBar:decoration-layout is set.
 *
 * Since: 3.12
 */
header_bar_props[PROP_DECORATION_LAYOUT_SET] =
    g_param_spec_boolean ("decoration-layout-set",
                          P_("Decoration Layout Set")g_dgettext("ctk30" "-properties","Decoration Layout Set"),
                          P_("Whether the decoration-layout property has been set")g_dgettext("ctk30" "-properties","Whether the decoration-layout property has been set"
),
                          FALSE(0),
                          CTK_PARAM_READWRITEG_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB);

/**
 * CtkHeaderBar:has-subtitle:
 *
 * If %TRUE, reserve space for a subtitle, even if none
 * is currently set.
 *
 * Since: 3.12
 */
header_bar_props[PROP_HAS_SUBTITLE] =
    g_param_spec_boolean ("has-subtitle",
                          P_("Has Subtitle")g_dgettext("ctk30" "-properties","Has Subtitle"),
                          P_("Whether to reserve space for a subtitle")g_dgettext("ctk30" "-properties","Whether to reserve space for a subtitle"
),
                          TRUE(!(0)),
                          CTK_PARAM_READWRITEG_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB|G_PARAM_EXPLICIT_NOTIFY);

g_object_class_install_properties (object_class, LAST_PROP, header_bar_props);

ctk_widget_class_set_accessible_type (widget_class, CTK_TYPE_HEADER_BAR_ACCESSIBLE(ctk_header_bar_accessible_get_type ()));
ctk_widget_class_set_accessible_role (widget_class, ATK_ROLE_PANEL);
ctk_widget_class_set_css_name (widget_class, "headerbar");
2124}

2126static void
2127ctk_header_bar_init (CtkHeaderBar *bar)
2128{
CtkHeaderBarPrivate *priv;
CtkCssNode *widget_node;

priv = ctk_header_bar_get_instance_private (bar);

ctk_widget_set_has_window (CTK_WIDGET (bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), ((ctk_widget_get_type ())))))), FALSE(0));

priv->title = NULL((void*)0);
priv->subtitle = NULL((void*)0);
priv->custom_title = NULL((void*)0);
priv->children = NULL((void*)0);
priv->spacing = DEFAULT_SPACING6;
priv->has_subtitle = TRUE(!(0));
priv->decoration_layout = NULL((void*)0);
priv->decoration_layout_set = FALSE(0);

init_sizing_box (bar);
construct_label_box (bar);

widget_node = ctk_widget_get_css_node (CTK_WIDGET (bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), ((ctk_widget_get_type ())))))));
priv->gadget = ctk_css_custom_gadget_new_for_node (widget_node,
                                                   CTK_WIDGET (bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), ((ctk_widget_get_type ())))))),
                                                   ctk_header_bar_get_content_size,
                                                   ctk_header_bar_allocate_contents,
                                                   ctk_header_bar_render_contents,
                                                   NULL((void*)0),
                                                   NULL((void*)0));

2157}

2159static void
2160ctk_header_bar_buildable_add_child (CtkBuildable *buildable,
                                  CtkBuilder   *builder G_GNUC_UNUSED__attribute__ ((__unused__)),
                                  GObject      *child,
                                  const gchar  *type)
2164{
if (type && strcmp (type, "title") == 0)
  ctk_header_bar_set_custom_title (CTK_HEADER_BAR (buildable)((((CtkHeaderBar*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((buildable)), ((ctk_header_bar_get_type ())))))), CTK_WIDGET (child)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((child)), ((ctk_widget_get_type ())))))));
else if (!type)
  ctk_container_add (CTK_CONTAINER (buildable)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((buildable)), ((ctk_container_get_type ())))))), CTK_WIDGET (child)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((child)), ((ctk_widget_get_type ())))))));
else
  CTK_BUILDER_WARN_INVALID_CHILD_TYPE (CTK_HEADER_BAR (buildable), type)g_warning ("'%s' is not a valid child type of '%s'", type, g_type_name
 ((((((GTypeClass*) (((GTypeInstance*) (((((CtkHeaderBar*) (void
 *) g_type_check_instance_cast ((GTypeInstance*) ((buildable)
), ((ctk_header_bar_get_type ()))))))))->g_class))->g_type
)))));
2171}

2173static void
2174ctk_header_bar_buildable_init (CtkBuildableIface *iface)
2175{
iface->add_child = ctk_header_bar_buildable_add_child;
2177}

2179/**
* ctk_header_bar_pack_start:
* @bar: A #CtkHeaderBar
* @child: the #CtkWidget to be added to @bar
*
* Adds @child to @bar, packed with reference to the
* start of the @bar.
*
* Since: 3.10
*/
2189void
2190ctk_header_bar_pack_start (CtkHeaderBar *bar,
                         CtkWidget    *child)
2192{
ctk_header_bar_pack (bar, child, CTK_PACK_START);
2194}

2196/**
* ctk_header_bar_pack_end:
* @bar: A #CtkHeaderBar
* @child: the #CtkWidget to be added to @bar
*
* Adds @child to @bar, packed with reference to the
* end of the @bar.
*
* Since: 3.10
*/
2206void
2207ctk_header_bar_pack_end (CtkHeaderBar *bar,
                       CtkWidget    *child)
2209{
ctk_header_bar_pack (bar, child, CTK_PACK_END);
2211}

2213/**
* ctk_header_bar_new:
*
* Creates a new #CtkHeaderBar widget.
*
* Returns: a new #CtkHeaderBar
*
* Since: 3.10
*/
2222CtkWidget *
2223ctk_header_bar_new (void)
2224{
return CTK_WIDGET (g_object_new (CTK_TYPE_HEADER_BAR, NULL))((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((g_object_new ((ctk_header_bar_get_type ()), ((void*)0)))
), ((ctk_widget_get_type ()))))));
2226}

2228/**
* ctk_header_bar_get_show_close_button:
* @bar: a #CtkHeaderBar
*
* Returns whether this header bar shows the standard window
* decorations.
*
* Returns: %TRUE if the decorations are shown
*
* Since: 3.10
*/
2239gboolean
2240ctk_header_bar_get_show_close_button (CtkHeaderBar *bar)
2241{
CtkHeaderBarPrivate *priv;

g_return_val_if_fail (CTK_IS_HEADER_BAR (bar), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((bar)); GType __t = ((ctk_header_bar_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("Ctk", ((const char*) (__func__
)), "CTK_IS_HEADER_BAR (bar)"); return ((0)); } } while (0);

priv = ctk_header_bar_get_instance_private (bar);

return priv->shows_wm_decorations;
2249}

2251/**
* ctk_header_bar_set_show_close_button:
* @bar: a #CtkHeaderBar
* @setting: %TRUE to show standard window decorations
*
* Sets whether this header bar shows the standard window decorations,
* including close, maximize, and minimize.
*
* Since: 3.10
*/
2261void
2262ctk_header_bar_set_show_close_button (CtkHeaderBar *bar,
                                    gboolean      setting)
2264{
CtkHeaderBarPrivate *priv;

g_return_if_fail (CTK_IS_HEADER_BAR (bar))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((bar)); GType __t = ((ctk_header_bar_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("Ctk", ((const char*) (__func__
)), "CTK_IS_HEADER_BAR (bar)"); return; } } while (0);

priv = ctk_header_bar_get_instance_private (bar);

setting = setting != FALSE(0);

if (priv->shows_wm_decorations == setting)
  return;

priv->shows_wm_decorations = setting;
_ctk_header_bar_update_window_buttons (bar);
g_object_notify_by_pspec (G_OBJECT (bar)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), (((GType) ((20) << (2)))))))), header_bar_props[PROP_SHOW_CLOSE_BUTTON]);
2279}

2281/**
* ctk_header_bar_set_has_subtitle:
* @bar: a #CtkHeaderBar
* @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
*/
2291void
2292ctk_header_bar_set_has_subtitle (CtkHeaderBar *bar,
                               gboolean      setting)
2294{
CtkHeaderBarPrivate *priv;

g_return_if_fail (CTK_IS_HEADER_BAR (bar))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((bar)); GType __t = ((ctk_header_bar_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("Ctk", ((const char*) (__func__
)), "CTK_IS_HEADER_BAR (bar)"); return; } } while (0);

priv = ctk_header_bar_get_instance_private (bar);

setting = setting != FALSE(0);

if (priv->has_subtitle == setting)
  return;

priv->has_subtitle = setting;
ctk_widget_set_visible (priv->subtitle_sizing_label, setting || (priv->subtitle && priv->subtitle[0]));

ctk_widget_queue_resize (CTK_WIDGET (bar)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), ((ctk_widget_get_type ())))))));

g_object_notify_by_pspec (G_OBJECT (bar)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), (((GType) ((20) << (2)))))))), header_bar_props[PROP_HAS_SUBTITLE]);
2312}

2314/**
* ctk_header_bar_get_has_subtitle:
* @bar: a #CtkHeaderBar
*
* Retrieves whether the header bar reserves space for
* a subtitle, regardless if one is currently set or not.
*
* Returns: %TRUE if the header bar reserves space
*     for a subtitle
*
* Since: 3.12
*/
2326gboolean
2327ctk_header_bar_get_has_subtitle (CtkHeaderBar *bar)
2328{
CtkHeaderBarPrivate *priv;

g_return_val_if_fail (CTK_IS_HEADER_BAR (bar), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((bar)); GType __t = ((ctk_header_bar_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("Ctk", ((const char*) (__func__
)), "CTK_IS_HEADER_BAR (bar)"); return ((0)); } } while (0);

priv = ctk_header_bar_get_instance_private (bar);

return priv->has_subtitle;
2336}

2338/**
* ctk_header_bar_set_decoration_layout:
* @bar: a #CtkHeaderBar
* @layout: (allow-none): a decoration layout, or %NULL to
*     unset the layout
*
* Sets the decoration layout for this header bar, overriding
* the #CtkSettings:ctk-decoration-layout setting. 
*
* There can be valid reasons for overriding the setting, such
* as a header bar design that does not allow for buttons to take
* room on the right, or only offers room for a single close button.
* Split header bars are another example for overriding the
* setting.
*
* The format of the string is button names, separated by commas.
* A colon separates the buttons that should appear on the left
* from those on the right. Recognized button names are minimize,
* maximize, close, icon (the window icon) and menu (a menu button
* for the fallback app menu).
*
* For example, “menu:minimize,maximize,close” specifies a menu
* on the left, and minimize, maximize and close buttons on the right.
*
* Since: 3.12
*/
2364void
2365ctk_header_bar_set_decoration_layout (CtkHeaderBar *bar,
                                    const gchar  *layout)
2367{
CtkHeaderBarPrivate *priv;

g_return_if_fail (CTK_IS_HEADER_BAR (bar))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((bar)); GType __t = ((ctk_header_bar_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("Ctk", ((const char*) (__func__
)), "CTK_IS_HEADER_BAR (bar)"); return; } } while (0);

priv = ctk_header_bar_get_instance_private (bar);

g_free (priv->decoration_layout);
priv->decoration_layout = g_strdup (layout)g_strdup_inline (layout);
priv->decoration_layout_set = (layout != NULL((void*)0));

_ctk_header_bar_update_window_buttons (bar);

g_object_notify_by_pspec (G_OBJECT (bar)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), (((GType) ((20) << (2)))))))), header_bar_props[PROP_DECORATION_LAYOUT]);
g_object_notify_by_pspec (G_OBJECT (bar)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((bar)), (((GType) ((20) << (2)))))))), header_bar_props[PROP_DECORATION_LAYOUT_SET]);
2382}

2384/**
* ctk_header_bar_get_decoration_layout:
* @bar: a #CtkHeaderBar
*
* Gets the decoration layout set with
* ctk_header_bar_set_decoration_layout().
*
* Returns: the decoration layout
*
* Since: 3.12 
*/
2395const gchar *
2396ctk_header_bar_get_decoration_layout (CtkHeaderBar *bar)
2397{
CtkHeaderBarPrivate *priv;

g_return_val_if_fail (CTK_IS_HEADER_BAR (bar), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((bar)); GType __t = ((ctk_header_bar_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))) { }
 else { g_return_if_fail_warning ("Ctk", ((const char*) (__func__
)), "CTK_IS_HEADER_BAR (bar)"); return (((void*)0)); } } while
 (0);

priv = ctk_header_bar_get_instance_private (bar);

return priv->decoration_layout;
2405}